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!