Olá pessoal! No artigo de hoje veremos como fazer o tratamento de retorno com a DLL DarumaFramework.

Os tratamentos desses retornos são de extrema importância, pois com eles conseguimos visualizar o que aconteceu em determinadas situações de não execução dos métodos,  e também de execução dos métodos.

Antes de começar com o código, falarei um pouco dos retornos e erros.

Existem alguns retornos dos métodos, que são:
 [1] quando o método é executado com sucesso, método foi realizado, efetivado.
[-1] quando existe erro no método, não executado em nenhum sentido.
[-6] quando a impressora está desligada ou desconectada. Quando o sistema não consegue comunicação com o ECF.
[-12] quando o método é executado, contudo alguma coisa aconteceu, por exemplo:
Erro: Cupom Fiscal Aberto
Aviso: Pouco Papel

Tecnicamente o tratamento de retorno é feito baseando-se no retorno -12, por quê?
Simples. Pelo fato de que os demais retornos são fixos, já sabendo o que de fato ocorreu.
O -12 é um retorno sem muitas explicações. Ele avisa que o método foi de fato executado, contudo algo ocorreu. Agora que fica mais legal: mas afinal, o que acontece?
Para responder essa e outras dúvidas, estamos criando este artigo! Vamos explicar como realizar o tratamento de retorno dos métodos da DarumaFramework.dll

Mãos a obra! Vamos alterar um pouco o layout do nosso projeto, nomeei a Janela do meu Form1 para Janela ECF. Aproveitei e alterei o nome do Class1 para Declarações_DLL_DarumaFramework.

Aproveitando o Class1 ele aberto, vamos inserir os métodos que precisaremos. Utilizarei três métodos para isso. São elas:

//Tratamento Erro e AViso
        [DllImport("DarumaFrameWork.dll")]
        public static extern int rStatusUltimoCmdInt_ECF_Daruma(ref int piErro, ref int piAviso);
        [DllImport("DarumaFrameWork.dll")]
        public static extern int eInterpretarErro_ECF_Daruma(int iErro, StringBuilder pszDescErro);
        [DllImport("DarumaFrameWork.dll")]
        public static extern int eInterpretarAviso_ECF_Daruma(int iAviso, StringBuilder pszDescAviso);
Com isso pronto, criaremos um GroupBox em nossa Janela ECF, e vamos inserir 10 Labels. 5 deles levarão o título, e os outros 5 receberão os retornos. Nomeei as cinco que receberão o retorno de:
label_retornometodo label_coderro label_stringerro label_codaviso label_stringaviso
Os labels que recebem o nome ficaram com o nome padrão (Label1, Label2...). Os asteriscos coloridos são os labels que citei acima, na ordem.

Então, a Janela ECF ficou desta forma:

Feito esses pequenos ajustes, vamos ao código.
Vamos criar uma função que realizará todo o tratamento de retorno. Podemos fazer o tratamento método a método, e isso não deixará seu programa lento. Optei por fazer dessa forma por ser mais rápido e prático.

Ao invés de falar linha a linha, copiei e colei o tratamento de retorno com todas as linhas comentadas.

//função tratamento de erro e aviso
        // TratamentoRetorno é o nome da função. Você pode trocar se preferir.
        // int RetornoFuncao recebe o retorno do método ( 1, -1, -6 , -12)
        private void TratamentoRetorno(int RetornoFuncao)
        {
            int iErro=0; //declara iErro
            int iAviso = 0; //declara iAviso
            //monta a string eErro com tamanho 300
            StringBuilder eErro = new StringBuilder(300);
            //monta a string eAviso com tamanho 300
            StringBuilder eAviso = new StringBuilder(300);
            label_coderro.Text = ""; //Limpa o Label
            label_codaviso.Text = ""; //Limpa o Label
            label_stringerro.Text = ""; //Limpa o Label
            label_stringaviso.Text = ""; //Limpa o Label
            //Mostra o retorno do método
            label_retornometodo.Text = RetornoFuncao.ToString();
            //trata os status de erro e aviso do ultimo comando
            ECF_Daruma.rStatusUltimoCmdInt_ECF_Daruma(ref iErro, ref iAviso);
           //Parte que interpreta os valores das variaveis da funcão acima.
            ECF_Daruma.eInterpretarErro_ECF_Daruma(iErro, eErro); //interpreta o iErro inteiro e mostra como eErro string
            ECF_Daruma.eInterpretarAviso_ECF_Daruma(iAviso, eAviso); //interpreta o iAviso inteiro e mostra como eAviso string
            //mostra nos labels os retornos
            label_coderro.Text = iErro.ToString();//Mostra codigo erro no label
            label_codaviso.Text = iAviso.ToString(); //mostra codigo aviso no label
            label_stringerro.Text = eErro.ToString(); //mostra string erro no label
            label_stringaviso.Text = eAviso.ToString(); //mostra string aviso no label
        }

Com o código acima, nossa função tratará qualquer retorno do método. Isso não é interessante. Por quê?

Pense comigo: se o método retorna 1 sempre que executado com sucesso, eu não preciso tratar os retornos quando o meu retorno for igual a 1, certo? Não há sentido em tratar algo que não contém erros.

Por isso, vamos colocar uma condição if , para executar os métodos apenas quando minha variável int RetornoFuncao, for diferente de [1].

Colocaremos o if abaixo do início da nossa função.

        private void TratamentoRetorno(int RetornoFuncao)
        {
            if (RetornoFuncao != 1)
            {
                            .
.
.
                label_stringaviso.Text = eAviso.ToString(); //mostra string aviso no label
            }
        }

Pronto! Estrutura de tratamento de retorno criada com sucesso! Agora é hora de aplicar isso em nossas funções já criadas.

Até agora nós criamos as seguintes funções:

ECF_Daruma.iLeituraX_ECF_Daruma()
ECF_Daruma.iReducaoZ_ECF_Daruma("", "")
ECF_Daruma.iCFAbrir_ECF_Daruma("11111111111", "Rafael", "VisualStudio")
ECF_Daruma.iCFVender_ECF_Daruma("F1", "1,000", "01,40", "D%", "0,00", "123456", "UN", "COCA COLA 2LT")
ECF_Daruma.iCFTotalizarCupom_ECF_Daruma("D%", "0,00")
ECF_Daruma.iCFEfetuarPagamento_ECF_Daruma("Dinheiro", "5,00", "Volte Sempre")
ECF_Daruma.iCFEncerrar_ECF_Daruma("0", "Aplicativo Teste")
Para que tratemos os retornos das funções acima, devemos inserir o nome da nossa função de tratamento de retorno antes delas.
Ficará algo desse tipo:
            TratamentoRetorno(ECF_Daruma.iLeituraX_ECF_Daruma());
            TratamentoRetorno(ECF_Daruma.iReducaoZ_ECF_Daruma("", ""));
            TratamentoRetorno(ECF_Daruma.iCFAbrir_ECF_Daruma("11111111111", "Rafael", "VisualStudio"));
            TratamentoRetorno(ECF_Daruma.iCFVender_ECF_Daruma("F1", "1,000", "01,40", "D%", "0,00", "123456", "UN", "COCA COLA 2LT"));
            TratamentoRetorno(ECF_Daruma.iCFTotalizarCupom_ECF_Daruma("D%", "0,00"));
           TratamentoRetorno(ECF_Daruma.iCFEfetuarPagamento_ECF_Daruma("Dinheiro", "5,00", "Volte Sempre"));
            TratamentoRetorno(ECF_Daruma.iCFEncerrar_ECF_Daruma("0", "Aplicativo Teste"));
Prontinho! Nossos métodos já são tratados para qualquer erro ou aviso!
Faremos um teste!

Compile seu sistema e mande abrir um cupom fiscal. Depois de aberto, execute novamente o comando de abrir o cupom. Veja o que acontece com os labels!

Agora, pessoal, vamos fazer alguns ajustes. Em nosso próximo artigo, falaremos do arquivo XML. O que é ele afinal? Para que serve?

Basicamente ele é um arquivo de configuração. É o local onde a DLL armazena informações para seu correto funcionamento, tais como porta serial que a impressora está instalada, velocidade de trabalho. Existe uma chave dentro desse arquivo que modifica também o nosso tratamento de retorno. Falarei brevemente dela, pois alguém pode ter um problema com o tratamento de retorno com o condicional if .

Neste XML existe uma chave chamada <RetornarAvisoErro>0</RetornarAvisoErro>. Com ela DESABILITADA ( 0 ), a dll sempre retornará [1] no método. Nesse caso, nem sempre o retorno [1] significa que ocorreu tudo certo.

Vou dar um exemplo:
Eu mandei abrir um cupom, a impressora imprimiu. Eu mandei novamente o comando de abertura do cupom e o que acontece? O retorno do método é [1]. Aí você vem e diz: Mas aí tá errado, não pode ser assim! Depende. O método ser executado não está ligado a ter sido impresso ou não. O método foi executado, contudo o ECF emitiu um erro.
Se tirarmos o if e deixamos a função tratando TODOS retornos, vamos ter o seguinte cenário.

Abri o cupom.
Mandei abrir novamente
Retorno do método [1] – Com Sucesso
Função de tratamento é acionada.
Interpretação de erro e aviso acionada.
Retorno da função eInterpretarErro = 78
String do Erro: CF Aberto
Visualmente temos o seguinte:

Agora, se essa chave está habilitada (1), o tratamento é dispensável quando RetornoFunção  = [1].

Dúvidas sobre o XML? Não deixe de ler nosso próximo artigo!

Espero que vocês tenham entendido. Qualquer dúvida, postem ou entre em contato conosco!