Afinal, que raio é esse XML que é falado em todo lugar?

O arquivo XML é uma evolução quanto ao armazenamento de informações importantes que são de extrema importância para a DarumaFramework.dll.
É de suma importância para o trabalho da DLL.

Com a evolução dos Sistemas Operacionais (Windows Vista, Windows 7), tratando mais do lado de segurança, algumas permissões estão sendo pedidas em diversas alterações que se deseja fazer no ambiente.
Até o antigo Windows XP, essas permissões não eram tão levadas a sério quanto é no Windows 7. No XP podemos fazer diversas alterações no registro, inicialização do sistema, sem nos preocupar com alguma contenção.

Isso já é diferente no Windows 7.

Para realizar uma simples modificação no registro, ou até uma execução tosca de aplicativo, não basta estar como administrador da máquina. Precisamos executar tal ação como administradores efetivos.
Tratando isso em uma larga escala, fica inviável para os desenvolvedores e software-houses prestarem um suporte eficiente e rápido para seus softwares, tendo em vista que cada computador tratará as permissões de uma maneira, consequentemente gravando as informações em locais distintos.
Um exemplo rápido: A DLL quando trabalha com o Registro do Windows para armazenar suas informações, dependendo da permissão do usuário, hora grava em HKEY_USERS, hora em HKEY_LOCAL_MACHINE, hora em HKEY_CURRENT_USER.

Até se localizar onde está, é demandado tempo, paciência do desenvolvedor que presta o suporte e do cliente que fica com seu frente de caixa parado enquanto é feita uma manutenção.

Pensando em todos a Daruma Automação, através da sua equipe de Integração e Desenvolvimento, criaram uma alternativa simples, rápida e leve: o Arquivo XML.

Com esse arquivo, que sempre acompanha a DLL, podemos realizar configurações e alterações de informações, para uma melhor eficiência do seu software.
Nele configuramos: Porta Serial, Velocidade, Mensagem de Aplicativo, Arredondamento, Truncamento, e por ai vai.
Esse arquivo, chamado de DarumaFramework.XML, ou apenas XML, pode ser alterado tanto via bloco de notas, wordpad, notepad++, XmlEditor, como via software.
A DLL possui métodos exclusivos de alteração desse arquivo XML.

A Estrutura do arquivo é montada nesse leiaute, separada por produtos e uma principal:
<DARUMAFRAMEWORK>
                <START>
                <DUAL>
                <ECF>
                <TA2000>
                <MODEM>
                <OBSERVER>

Como o curso é sobre ECF, falarei mais dessa chave, e um pouco sobre a START que é importante também para qualquer produto.
Chave <START>

Essa chave contem algumas informações muito importantes. A mais importante é a chave que indica com qual produto a DLL vai trabalhar: <Produto>ECF</Produto>, podendo ter o valor: ECF, DUAL, MODEM, TA2000.
Outra chave importante é a    
<LocalArquivos>c:\</LocalArquivos>
    <LocalArquivosRelatorios>c:\</LocalArquivosRelatorios>
Essas duas indicam os locais onde serão salvos os arquivos que a DLL consegue extrair do ECF, como os relatórios do PAF-ECF.

Chave <ECF>

Não falarei de todas as chaves, apenas as mais importantes.
<ArredondarTruncar> </ArredondarTruncar>
Essa chave indica a DLL com qual modo ela deve trabalhar na venda do item. A para Arredondamento e T para Truncamento.

<Auditoria></Auditoria>
Auditoria é o LOG que armazena os dados enviados e recebidos pela impressora. É muito utilizado no Suporte ao Desenvolvedor da Daruma, por conter muitas informações importantes na realização dos comandos. É habilitado com 1 e desabilitado com 0.

<ReducaoZAutomatica></ReducaoZAutomatica>
Efetua a redução Z de forma automática sempre que ficar pendente. Com ela ativada [1], a DLL verifica assim que aberto seu sistema, se no dia anterior foi tirada a ReduçãoZ. Se não, imprime. Se foi, não executa nada.

<RetornarAvisoErro></RetornarAvisoErro>
Essa chave é de extrema importância para nosso artigo 4 – Tratamento de Retorno. Com ela ativada [1], os métodos retornam -12 em caso de erro ou aviso. Com ela desativada [0], os métodos retornam que foram realizados com sucesso, mesmo se esbarraram com um cupom fiscal aberto, redução z pendente.
               
<PortaSerial> </PortaSerial>
É a porta com a qual a DLL irá tentar comunicação. Ela sempre vai enxergar essa porta e tentar estabelecer comunicação com ela. Ex: COM1, COM2.

<Velocidade></Velocidade>
É a velocidade que a impressora e a porta COMx estão configuradas. Ela deve ser igual às outras para que a comunicação seja estabelecida com sucesso. Ex: 9600, 115200


No HELP da DarumaFramework, existe uma parte que fala chave a chave. Esse HELP encontra-se no site http://www.desenvolvedoresdaruma.com.br/, ou no blog  em Links Importantes.

Alterando via Software

Utilizaremos apenas 1 método para fazer alterações em todas as chaves. É, apenas um mesmo, não precisa se assustar. Essa é outra inovação da DarumaFramework.
Declaremos as funções:


        //Métodos de Registro
        [DllImport("DarumaFrameWork.dll")]//Altera valor do XML
        public static extern int regAlteraValorChave_DarumaFramework(string pszProduto, string pszChave, string pszValor);
        [DllImport("DarumaFrameWork.dll")]//Consulta Valor da chave do XML
        public static extern int regRetornaValorChave_DarumaFramework(string sProduto, string sChave, [MarshalAs(UnmanagedType.VBByRefStr)] ref string szRetorno);


Pessoal, uma dica: Tentem comentar e separar os trechos das declarações. Fica mais fácil de encontrar posteriormente.

Esses métodos têm como parâmetros três strings. A primeira indica o produto, a segunda a chave, e a terceira o valor a ser inserido.
O primeiro método altera as chaves. O segundo retorna o valor delas.

Para alterar as chaves, vamos criar um GroupBox, um botão, 3 labels e três textbox para brincar um pouco.
Para visualizar, criaremos outro GroupBox com 6 labels, onde 3 serão atualizados assim que alterarmos as chaves e os valores.

Toda minha ação será comandada pelo botão AlterarXml, que acionará o método de alteração e consulta, e mostrará a alteração que e fiz ao lado. Para facilitar o entendimento, segue a tela das alterações que fiz.




Feito isso,  vou alterar os nomes dos textbox e labels, para organizar.

Alterar XML
TextBox do Produto. Nomeei como tbx_produto
TextBox da Chave. Nomeei como tbx_chave
TextBox do Valor. Nomeei como tbx_valor

Valores XML
Label que recebe produto nomeei label_retproduto
Label que recebe Chave nomeei como label_retchave
Label que recebe Valor nomeei como label_retvalor

Feito essa pequena alteração, vamos a execução da função.
Usarei o método regAlteraValorChave_DarumaFramework para alterar o valor do XML e o método regRetornaValorChave_DarumaFramework para consultar o XML.

Vamos criar um evento para nosso botão de alteração, o bt_alterarxml.

        private void bt_alterarxml_Click(object sender, EventArgs e) //Comando de Alterar XML
        {
  }

Primeiramente terei de criar as strings para os parâmetros dos métodos. Criei então:

            string str_produto = tbx_produto.Text;
            string str_chave = tbx_chave.Text;
            string str_valor = tbx_valor.Text;

Aproveitei para já atribuir os valores das variáveis aos valores recebidos pelos textbox.

Feito isso, nosso evento está praticamente pronto. Falta apenas inserir a função:

TratamentoRetorno(ECF_Daruma.regAlteraValorChave_DarumaFramework(str_produto,str_chave, str_valor));

Não se esqueça de inserir sua função de tratamento de retorno.

Apenas com isso o arquivo XML já é alterado.  Mas e para consultar os registros, como faço?
Vamos para a segunda parte!
Aproveitando o mesmo evento, vou criar uma nova string chamada “str_valor_”, para receber o valor que eu alterei na chave.
Aproveitarei as outras duas variáveis str_produto e str_chave para consultar as mesmas logo depois que eu alterar os valores, troquei a que recebe o valor para não ter confusão e acharem que eu apenas mantive os valores.

Como a variável que recebe o valor é por referencia, então chamamos a função

ECF_Daruma.regRetornaValorChave_DarumaFramework(str_produto, str_chave, ref str_valor_); //Comando de Consultar XML

Note que utilizei 2 variaveis iguals, apenas a str_valor_ que é diferente. Isso fará que eu visualize a chave que eu acabei de alterar.

Como o C# pede que defina o tamanho de variáveis por referencia, criei a seguinte linha para atribuir um tamanho a variável str_valor_

string str_valor_ = new string(' ', 30);


Finalizando, para mostrar nos labels os retornos, igualei o label respectivo a sua variável.

            label_retproduto.Text = str_produto;
            label_retchave.Text = str_chave;
            label_retvalor.Text = str_valor_;


Temos então o seguinte evento Click do bt_alterarvalor

        private void bt_alterarxml_Click(object sender, EventArgs e)
        {
            string str_produto = tbx_produto.Text;
            string str_chave = tbx_chave.Text;
            string str_valor = tbx_valor.Text;

           TratamentoRetorno(ECF_Daruma.regAlteraValorChave_DarumaFramework(str_produto,str_chave, str_valor)); //Comando de Alterar XML

            string str_valor_ = new string(' ', 30);

            ECF_Daruma.regRetornaValorChave_DarumaFramework(str_produto, str_chave, ref str_valor_); //Comando de Consultar XML

            label_retproduto.Text = str_produto;
            label_retchave.Text = str_chave;
            label_retvalor.Text = str_valor_;

        }


Com isso, podemos executar nosso programa e testar!

Vamos alterar uma chave que aprendemos hoje aqui: a Auditoria.
Vamos deixa-la com valor 1.


 
Preencha os campos com o Produto, Chave e Valor, respectivamente.
Em seguida, clique em Alterar.


Conseguimos ver que o XML foi alterado graças a nossa visualização instantânea.
Também conseguimos ver que a função retornou 1, com sucesso, sem erro e sem aviso.


Bem pessoal, até a próxima!