public virtual ErrorCommand tratarResposta(int codigoComandoEsperado, byte[] retornoReal, int qdeRecebida, int qdeEsperada)
{
ErrorCommand flagErroComando = new ErrorCommand();
if ((qdeEsperada == qdeRecebida))
{
if (!validarComando(retornoReal, codigoComandoEsperado))
{
return(new ErrorCommand(ErrorCommand.RETORNO_INCONSISTENTE));
}
if (!validarBCC(retornoReal))
{
return(new ErrorCommand(ErrorCommand.ERRO_BCC));
}
flagErroComando.setErro(retornoReal[Protocol.INDICE_FLAG_RETORNO]);
}
else if ((-1 == qdeRecebida))
{
flagErroComando.setErro(ErrorCommand.COMUNICACAO_NAO_ESTABELECIDA);
}
else
{
flagErroComando.setErro(ErrorCommand.RETORNO_INCONSISTENTE);
}
return(flagErroComando);
}
public ErrorCommand execute(String ip, String porta, String cpf, String hash)
{
ErrorCommand errorCommand = new ErrorCommand();
Tcp tcp = null;
try
{
tcp = new Tcp(ip, Convert.ToInt16(porta));
}
catch (IOException e1) {
errorCommand.setErro(ErrorCommand.COMUNICACAO_NAO_ESTABELECIDA);
return(errorCommand);
}
try
{
try
{
byte[] bytesCpf = Conversor.cpfToByte(cpf);
byte[] buffer = criarPacoteCabecalho(CommandCodes.START_PC, CommandCodes.LER_EMPREGADOR,
new byte[4], new byte[4], bytesCpf,
(byte)0x00, CommandCodes.END);
sendBuffer(buffer, true, tcp);
byte[] respostaREP = new byte[Protocol.QTD_BYTES_RETORNO_LEITURA_EMPREGADOR];
// Lê resposta do REP
respostaREP = readAnswer(tcp, Protocol.QTD_BYTES_RETORNO_LEITURA_EMPREGADOR);
int qtdBytesRecebidos = -1;
if (respostaREP != null)
{
qtdBytesRecebidos = respostaREP.Length;
}
// Trata a resposta do REP
errorCommand = tratarResposta(CommandCodes.LER_EMPREGADOR, respostaREP, qtdBytesRecebidos, Protocol.QTD_BYTES_RETORNO_LEITURA_EMPREGADOR);
if (errorCommand.getErro() == ErrorCommand.SUCESSO)
{
errorCommand = this.tratarResposta(0, respostaREP, 0, 0);
// debug(errorCommand); // testes
}
}
catch (Exception e)
{
errorCommand.setErro(ErrorCommand.OCORREU_EXCECAO);
}
tcp.finalizaConexao();
}
catch (Exception e)
{
errorCommand.setErro(ErrorCommand.ERRO_FINALIZAR_CONEXAO);
}
return(errorCommand);
}
private byte[] lerEtratarResposta(int qtdBytesEsperada)
{
// Lê resposta do REP
byte[] respostaREP = readAnswer(tcp, qtdBytesEsperada);
int qtdBytesRecebidos = -1;
if (respostaREP != null)
{
qtdBytesRecebidos = respostaREP.Length;
}
// Trata a resposta do REP
errorCommand = tratarResposta(CommandCodes.ENVIAR_DIGITAL, respostaREP, qtdBytesRecebidos, qtdBytesEsperada);
return(respostaREP);
}
public override ErrorCommand tratarResposta(int codigoComandoEsperado, byte[] dados, int qdeRecebida, int qdeEsperada)
{
ErrorCommand errorCommand = new ErrorCommand(ErrorCommand.SUCESSO);
try
{
// Conversão do Identificador (CNPJ/CPF)
byte[] bytesIdentificador = new byte[Protocol.TAMANHO_IDENTIFICADOR_EMPREGADOR];
for (int i = 0, j = Protocol.INDICE_IDENTIFICADOR_EMPREGADOR;
i < Protocol.TAMANHO_IDENTIFICADOR_EMPREGADOR &&
j < Protocol.INDICE_IDENTIFICADOR_EMPREGADOR + Protocol.TAMANHO_IDENTIFICADOR_EMPREGADOR;
i++, j++)
{
bytesIdentificador[i] = dados[j];
}
String identificador = Conversor.bytesIdentificadorToString(bytesIdentificador);
int tipoIdentificador = Conversor.byteToInt(dados[Protocol.INDICE_TIPO_IDENTIFICADOR_EMPREGADOR]);
company.cnpj = identificador;
// Conversão do CEI
byte[] bytesCEI = new byte[Protocol.TAMANHO_CEI_EMPREGADOR];
for (int i = 0, j = Protocol.INDICE_CEI_EMPREGADOR;
i < Protocol.TAMANHO_CEI_EMPREGADOR &&
j < Protocol.INDICE_CEI_EMPREGADOR + Protocol.TAMANHO_CEI_EMPREGADOR;
i++, j++)
{
bytesCEI[i] = dados[j];
}
company.cei = Conversor.bytesCEIToString(bytesCEI);
// Conversão da Razão Social
byte[] bytesRazaoSocial = new byte[Protocol.TAMANHO_RAZAO_SOCIAL_EMPREGADOR];
for (int i = 0, j = Protocol.INDICE_RAZAO_SOCIAL_EMPREGADOR;
i < Protocol.TAMANHO_RAZAO_SOCIAL_EMPREGADOR &&
j < Protocol.INDICE_RAZAO_SOCIAL_EMPREGADOR + Protocol.TAMANHO_RAZAO_SOCIAL_EMPREGADOR;
i++, j++)
{
bytesRazaoSocial[i] = dados[j];
}
company.companyName = Conversor.bytesASCIIToString(bytesRazaoSocial);
// Conversão do Local da Prestação de Serviço
byte[] bytesLocalPrestacaoServico = new byte[Protocol.TAMANHO_LOCAL_EMPREGADOR];
for (int i = 0, j = Protocol.INDICE_LOCAL_EMPREGADOR;
i < Protocol.TAMANHO_LOCAL_EMPREGADOR &&
j < Protocol.INDICE_LOCAL_EMPREGADOR + Protocol.TAMANHO_LOCAL_EMPREGADOR;
i++, j++)
{
bytesLocalPrestacaoServico[i] = dados[j];
}
company.address = Conversor.bytesASCIIToString(bytesLocalPrestacaoServico);
}
catch (Exception e)
{
errorCommand.setErro(ErrorCommand.RETORNO_INCONSISTENTE);
}
return(errorCommand);
}
public ErrorCommand execute(String ip, String porta, String cpf, Company company)
{
ErrorCommand errorCommand = new ErrorCommand();
Tcp tcp = null;
try
{
tcp = new Tcp(ip, Convert.ToInt16(porta));
}
catch (IOException e) {
errorCommand.setErro(ErrorCommand.SUCESSO);
return(errorCommand);
}
try
{
try
{
byte[] bytesCpf = Conversor.cpfToByte(cpf);
byte[] cabecalhoDadosGravaEmpregador = Command.criarPacoteCabecalho(CommandCodes.START_PC, CommandCodes.ENVIAR_EMPREGADOR, new byte[] { 0x00, 0x00, 0x00, 0x01 }, new byte[4], bytesCpf, (byte)ErrorCommand.ADICIONAR_SUBSTITUIR, CommandCodes.END);
// Envia o cabeçalho
sendBuffer(cabecalhoDadosGravaEmpregador, true, tcp);
// Lê 1ª resposta do REP
byte[] retornoReal = readAnswer(tcp, Protocol.QTD_BYTES_CABECALHO_CRIPTOGRAFADO);
int qtdBytesRecebidos = -1;
if (retornoReal != null)
{
qtdBytesRecebidos = retornoReal.Length;
}
// Trata a 1ª resposta do REP
errorCommand = tratarResposta(CommandCodes.ENVIAR_EMPREGADOR, retornoReal, qtdBytesRecebidos, Protocol.QTD_BYTES_CABECALHO_CRIPTOGRAFADO);
if (errorCommand.getErro() == ErrorCommand.SUCESSO)
{
cabecalhoDadosGravaEmpregador = criarPacoteCabecalho(CommandCodes.START_PC, CommandCodes.ENVIAR_EMPREGADOR,
new byte[] { 0x00, 0x01, 0x00, 0x01 }, new byte[] { 0x00, 0x00, 0x01, 0x0C },
bytesCpf, (byte)ErrorCommand.DADOS_OK, CommandCodes.END);
byte checkSumCabecalho = cabecalhoDadosGravaEmpregador[cabecalhoDadosGravaEmpregador.Length - 2];
byte[] dadosGravaEmpregador = criaPacoteDados(checkSumCabecalho, bytesCpf, company);
// Envia os dados do empregador
sendBuffer(ProtocolUtils.merge(cabecalhoDadosGravaEmpregador, dadosGravaEmpregador), true, tcp);
retornoReal = new byte[Protocol.QTD_BYTES_CABECALHO_CRIPTOGRAFADO];
// Lê 2ª resposta do REP
retornoReal = readAnswer(tcp, Protocol.QTD_BYTES_CABECALHO_CRIPTOGRAFADO);
qtdBytesRecebidos = -1;
if (retornoReal != null)
{
qtdBytesRecebidos = retornoReal.Length;
}
// Trata a 2ª resposta do REP
errorCommand = tratarResposta(CommandCodes.ENVIAR_EMPREGADOR, retornoReal, qtdBytesRecebidos, Protocol.QTD_BYTES_CABECALHO_CRIPTOGRAFADO);
}
}
catch (Exception e)
{
errorCommand.setErro(ErrorCommand.OCORREU_EXCECAO);
}
tcp.finalizaConexao();
}
catch (Exception e)
{
errorCommand.setErro(ErrorCommand.ERRO_FINALIZAR_CONEXAO);
}
return(errorCommand);
}
public ErrorCommand execute(String ip, String porta, List <Digital> digitals, String pis)
{
errorCommand = new ErrorCommand();
tcp = null;
try
{
tcp = new Tcp(ip, Convert.ToInt16(porta));
}
catch (IOException e1) {
errorCommand.setErro(ErrorCommand.COMUNICACAO_NAO_ESTABELECIDA);
return(errorCommand);
}
int totalDigitais = 0;
try
{
try
{
totalDigitais = digitals.Count;
int digitalAtual = 1;
byte flag;
if (totalDigitais == 1)
{
flag = ErrorCommand.UNICA_TEMPLATE_USUARIO;
}
else
{
flag = ErrorCommand.TODAS_TEMPLATE_USUARIO;
}
byte[] cabecalhoDadosGravaDigital = criarPacoteCabecalho(CommandCodes.START_PC, CommandCodes.ENVIAR_DIGITAL,
new byte[] { 0x00, 0x00, 0x00, (byte)totalDigitais }, new byte[4],
Conversor.pisToByte(pis),
flag, CommandCodes.END);
byte[] primeiroBlocoCabecalho = ProtocolUtils.copyOfRange(cabecalhoDadosGravaDigital, 0, 16); // primeiros 16 bytes do cabeçalho
// Envia o cabeçalho
sendBuffer(primeiroBlocoCabecalho, true, tcp);
/**
* Envio dos bytes do cabeçalho ainda não enviados + bloco vazio (0xFF).
* Isto é necessário para o REP reconhecer tudo corretamente (visto empiricamente).
*/
Boolean incluirBytesNoInicio = true;
enviaBlocoVazio(ProtocolUtils.copyOfRange(cabecalhoDadosGravaDigital, 16, cabecalhoDadosGravaDigital.Length), incluirBytesNoInicio);
// Lê 1ª resposta do REP
lerEtratarResposta(Protocol.QTD_BYTES_CABECALHO_CRIPTOGRAFADO);
if (errorCommand.getErro() == ErrorCommand.SUCESSO)
{
errorCommand.setErro(ErrorCommand.DADOS_OK);
incluirBytesNoInicio = false;
for (; (digitalAtual <= totalDigitais) && (errorCommand.getErro() == ErrorCommand.DADOS_OK); digitalAtual++)
{
cabecalhoDadosGravaDigital = criarPacoteCabecalho(CommandCodes.START_PC, CommandCodes.ENVIAR_DIGITAL,
new byte[] { 0x00, (byte)totalDigitais, 0x00, (byte)digitalAtual },
new byte[] { 0x00, 0x00, 0x03, 0x23 }, // 803 bytes
new byte[6], (byte)ErrorCommand.DADOS_OK, CommandCodes.END);
byte checkSumCabecalho = cabecalhoDadosGravaDigital[cabecalhoDadosGravaDigital.Length - 2];
Digital digitalComunicador = digitals[digitalAtual - 1];
byte[] dadosGravaDigital = criaPacoteDados(checkSumCabecalho, digitalComunicador);
/**
* Envio de bloco vazio:
* Necessário para o REP reconhecer tudo corretamente (visto empiricamente).
*/
if (digitalAtual == 1)
{
enviaBlocoVazio(ProtocolUtils.copyOfRange(cabecalhoDadosGravaDigital, 0, 2), incluirBytesNoInicio);
// Envia a digital
sendBuffer(ProtocolUtils.merge(ProtocolUtils.copyOfRange(cabecalhoDadosGravaDigital, 2, cabecalhoDadosGravaDigital.Length), dadosGravaDigital), true, tcp);
}
else
{
primeiroBlocoCabecalho = ProtocolUtils.copyOfRange(cabecalhoDadosGravaDigital, 0, 16); // primeiros 16 bytes
sendBuffer(primeiroBlocoCabecalho, true, tcp);
// Envia a digital
sendBuffer(ProtocolUtils.merge(ProtocolUtils.copyOfRange(cabecalhoDadosGravaDigital, 16, cabecalhoDadosGravaDigital.Length), dadosGravaDigital), true, tcp);
}
// Lê e trata 2ª resposta do REP
lerEtratarResposta(Protocol.QTD_BYTES_CABECALHO_CRIPTOGRAFADO);
incluirBytesNoInicio = true;
}
}
}
catch (Exception e)
{
errorCommand.setErro(ErrorCommand.OCORREU_EXCECAO);
}
tcp.finalizaConexao();
}
catch (Exception e)
{
errorCommand.setErro(ErrorCommand.ERRO_FINALIZAR_CONEXAO);
}
return(errorCommand);
}