private void leFuncionarioPorPIS(String pis)
{
byte[] buffer = criarPacoteCabecalho(CommandCodes.START_PC, CommandCodes.LER_FUNCIONARIO,
Conversor.pisToByte(pis), new byte[2], new byte[6], (byte)0x00, CommandCodes.END);
sendBuffer(buffer, true, tcp);
// Lê e trata 1º cabeçalho
byte[] respostaREP = this.lerEtratarResposta(Protocol.QTD_BYTES_CABECALHO_CRIPTOGRAFADO);
if (errorCommand.getErro() == ErrorCommand.SUCESSO)
{
errorCommand.setErro(ErrorCommand.DADOS_OK);
// Lê e trata cabeçalho dos dados
respostaREP = this.lerEtratarResposta(Protocol.QTD_BYTES_FUNCIONARIO);
if (errorCommand.getErro() == ErrorCommand.DADOS_OK)
{
// Lê os dados do funcionário
respostaREP = ProtocolUtils.copyOfRange(respostaREP, Protocol.QTD_BYTES_CABECALHO_DADOS, respostaREP.Length);
int qtdBytesRecebidos = -1;
if (respostaREP != null)
{
qtdBytesRecebidos = respostaREP.Length;
}
if (Protocol.QTD_BYTES_FUNCIONARIO - Protocol.QTD_BYTES_CABECALHO_DADOS == qtdBytesRecebidos)
{
errorCommand = this.tratarResposta(0, respostaREP, 0, 0);
// Envia pacote de confirmação OK da leitura de funcionário
buffer = criarPacoteCabecalho(CommandCodes.START_PC, CommandCodes.LER_FUNCIONARIO,
new byte[] { 0x00, (byte)1, 0x00, (byte)1 }, new byte[4],
new byte[6], (byte)ErrorCommand.DADOS_OK, CommandCodes.END);
sendBuffer(buffer, true, tcp);
if (ErrorCommand.SUCESSO == errorCommand.getErro() || ErrorCommand.DADOS_OK == errorCommand.getErro())
{
listaFuncionariosLidos.Add(funcionarioLido);
}
}
}
}
else if (errorCommand.getErro() == ErrorCommand.PIS_INEXISTENTE)
{
listaPisNaoEncontrados.Add(pis);
}
}
public ErrorCommand execute(String ip, String porta, int nsr)
{
errorCommand = new ErrorCommand();
tcp = null;
try
{
tcp = new Tcp(ip, Convert.ToInt16(porta));
}
catch (IOException e) {
errorCommand.setErro(ErrorCommand.COMUNICACAO_NAO_ESTABELECIDA);
return(errorCommand);
}
try
{
try
{
/** Quando é informado um NSR maior do que o último gravado no REP,
* o REP retorna o flag 0x96 (O Frame recebido contém erro).
**/
byte[] buffer = criarPacoteCabecalho(CommandCodes.START_PC, CommandCodes.LER_MARCACAO,
Conversor.intToByteArray(nsr, 4),
Conversor.intToByteArray(Protocol.TAMANHO_PACOTE_MARCACOES, 4),
new byte[6], (byte)0x00, CommandCodes.END);
sendBuffer(buffer, true, tcp);
// Lê e trata 1º cabeçalho
byte[] respostaREP = this.lerEtratarResposta(Protocol.QTD_BYTES_CABECALHO_CRIPTOGRAFADO);
byte[] totalMarcacoes = ProtocolUtils.copyOfRange(respostaREP, Protocol.INDICE_INICIO_PARAMETRO, Protocol.INDICE_INICIO_PARAMETRO + 4);
int totalMarcacoesInt = Conversor.ByteArrayToint(totalMarcacoes);
// Cálculo necessário devido ao último pacote ser de tamanho variável
int qtdMarcacoesUltimoPacote = totalMarcacoesInt % Protocol.TAMANHO_PACOTE_MARCACOES;
int qtdBytesASeremLidos = 0;
if (errorCommand.getErro() == ErrorCommand.SUCESSO)
{
errorCommand.setErro(ErrorCommand.DADOS_OK);
int pacoteAtual = -1;
byte[] atual;
listaMarcacoes = new LinkedList <Marking>();
while (pacoteAtual < totalPacotes &&
(ErrorCommand.SUCESSO == errorCommand.getErro() || ErrorCommand.DADOS_OK == errorCommand.getErro()))
{
// Lê e trata cabeçalho dos dados
if (totalMarcacoesInt < Protocol.TAMANHO_PACOTE_MARCACOES ||
(pacoteAtual != -1 && (pacoteAtual + 1) == totalPacotes && qtdMarcacoesUltimoPacote > 0))
{ // último pacote a ser recebido
//qtdBytesASeremLidos = AES.defineTamanhoPacote(Protocol.QTD_BYTES_CABECALHO_DADOS + Protocol.QTD_BYTES_MARCACAO * qtdMarcacoesUltimoPacote);
}
else
{
qtdBytesASeremLidos = Protocol.QTD_BYTES_PACOTES_MARCACOES;
}
respostaREP = this.lerEtratarResposta(qtdBytesASeremLidos);
if (errorCommand.getErro() == ErrorCommand.DADOS_OK)
{
// Verificando o total de pacotes a serem lidos do REP
byte[] total = ProtocolUtils.copyOfRange(respostaREP, Protocol.INDICE_INICIO_PARAMETRO, Protocol.INDICE_INICIO_PARAMETRO + 2);
totalPacotes = Conversor.ByteArrayToint(total);
// Verificando o pacote atual
atual = ProtocolUtils.copyOfRange(respostaREP, Protocol.INDICE_FIM_PARAMETRO - 1, Protocol.INDICE_FIM_PARAMETRO + 1);
pacoteAtual = Conversor.ByteArrayToint(atual);
// Lê os pacotes de marcação de ponto
respostaREP = ProtocolUtils.copyOfRange(respostaREP, Protocol.QTD_BYTES_CABECALHO_DADOS, respostaREP.Length);
int qtdBytesRecebidos = -1;
if (respostaREP != null)
{
qtdBytesRecebidos = respostaREP.Length;
}
if (qtdBytesASeremLidos - Protocol.QTD_BYTES_CABECALHO_DADOS == qtdBytesRecebidos)
{
errorCommand = this.tratarResposta(0, respostaREP, 0, 0);
}
if (errorCommand.getErro() == ErrorCommand.FIM_LEITURA_MARCACOES)
{
atual[0] = total[0];
atual[1] = total[1];
}
// Envia comando de leitura do(s) próximo(s) pacote(s) de marcação de ponto
buffer = criarPacoteCabecalho(CommandCodes.START_PC, CommandCodes.LER_MARCACAO,
new byte[] { total[0], total[1], atual[0], atual[1] }, new byte[4],
new byte[6], (byte)ErrorCommand.DADOS_OK, CommandCodes.END);
sendBuffer(buffer, true, tcp);
}
}
if (errorCommand.getErro() == ErrorCommand.DADOS_OK ||
errorCommand.getErro() == ErrorCommand.FIM_LEITURA_MARCACOES)
{
errorCommand.setErro(ErrorCommand.SUCESSO);
}
}
}
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 <Employee> employees)
{
errorCommand = new ErrorCommand();
tcp = null;
try
{
tcp = new Tcp(ip, Convert.ToInt16(porta));
}
catch (IOException e) {
errorCommand.setErro(ErrorCommand.COMUNICACAO_NAO_ESTABELECIDA);
return(errorCommand);
}
try
{
try
{
int totalFuncionarios = employees.Count();
int funcionarioAtual = 1;
int flagErro = ErrorCommand.SUCESSO;
while (funcionarioAtual <= totalFuncionarios && (ErrorCommand.SUCESSO == errorCommand.getErro() || ErrorCommand.DADOS_OK == errorCommand.getErro()))
{
Employee employee = employees[funcionarioAtual - 1];
// Exclusão do funcionário antes de adicioná-lo no REP
CommandDeleteEmployee excluiFuncionario = new CommandDeleteEmployee(tcp);
errorCommand = excluiFuncionario.execute(ip, porta, cpf, employee.pisPasep);
// Envio do funcionário para o REP
if (flagErro == ErrorCommand.SUCESSO || flagErro == ErrorCommand.IDENTIFICADOR_RECUSADO || flagErro == ErrorCommand.PIS_INEXISTENTE)
{
byte[] bytesCPF = Conversor.cpfToByte(cpf);
byte[] cabecalhoDadosGravaFuncionario = Command.criarPacoteCabecalho(CommandCodes.START_PC, CommandCodes.ENVIAR_FUNCIONARIO,
new byte[] { 0x00, 0x00, 0x00, 0x01 },
new byte[4], bytesCPF,
(byte)ErrorCommand.ADICIONAR, CommandCodes.END);
// Envia o cabeçalho
Command.sendBuffer(cabecalhoDadosGravaFuncionario, true, tcp);
// Lê e trata 1º cabeçalho
lerEtratarResposta(Protocol.QTD_BYTES_CABECALHO_CRIPTOGRAFADO);
if (errorCommand.getErro() == ErrorCommand.SUCESSO)
{
cabecalhoDadosGravaFuncionario = Command.criarPacoteCabecalho(CommandCodes.START_PC, CommandCodes.ENVIAR_FUNCIONARIO,
new byte[] { 0x00, 0x01, 0x00, 0x01 },
new byte[] { 0x00, 0x00, 0x00, 0x61 },
bytesCPF, (byte)ErrorCommand.DADOS_OK, CommandCodes.END);
byte checkSumCabecalho = cabecalhoDadosGravaFuncionario[Protocol.QTD_BYTES_CABECALHO_DADOS - 2];
byte[] dadosGravaFuncionario = criaPacoteDados(checkSumCabecalho, employee);
// Envia os dados do funcionário
Command.sendBuffer(ProtocolUtils.merge(cabecalhoDadosGravaFuncionario, dadosGravaFuncionario), true, tcp);
// Lê e trata 2ª resposta do REP
lerEtratarResposta(Protocol.QTD_BYTES_CABECALHO_CRIPTOGRAFADO);
}
}
funcionarioAtual++;
}
}
catch (Exception e)
{
errorCommand.setErro(ErrorCommand.OCORREU_EXCECAO);
}
tcp.finalizaConexao();
}
catch (Exception e)
{
errorCommand.setErro(ErrorCommand.ERRO_FINALIZAR_CONEXAO);
}
return(errorCommand);
}
public override ErrorCommand tratarResposta(int codigoComandoEsperado, byte[] dados, int qdeRecebida, int qdeEsperada)
{
ErrorCommand errorCommand = new ErrorCommand(ErrorCommand.SUCESSO);
try
{
funcionarioLido = new Employee();
// Conversão do Nome
byte[] bytesNome = new byte[Protocol.TAMANHO_NOME_FUNCIONARIO];
for (int i = 0, j = Protocol.INDICE_NOME_FUNCIONARIO;
i < Protocol.TAMANHO_NOME_FUNCIONARIO &&
j < Protocol.INDICE_NOME_FUNCIONARIO + Protocol.TAMANHO_NOME_FUNCIONARIO;
i++, j++)
{
bytesNome[i] = dados[j];
}
funcionarioLido.employeeName = Conversor.bytesASCIIToString(bytesNome);
// Conversão do PIS
byte[] bytesPIS = new byte[Protocol.TAMANHO_PIS_FUNCIONARIO];
for (int i = 0, j = Protocol.INDICE_PIS_FUNCIONARIO;
i < Protocol.TAMANHO_PIS_FUNCIONARIO &&
j < Protocol.INDICE_PIS_FUNCIONARIO + Protocol.TAMANHO_PIS_FUNCIONARIO;
i++, j++)
{
bytesPIS[i] = dados[j];
}
funcionarioLido.pisPasep = Conversor.BCDtoString(bytesPIS);
// Conversão do ID BIO
byte[] bytesIDBio = new byte[Protocol.TAMANHO_ID_BIO];
for (int i = 0, j = Protocol.INDICE_ID_BIO;
i < Protocol.TAMANHO_ID_BIO &&
j < Protocol.INDICE_ID_BIO + Protocol.TAMANHO_ID_BIO;
i++, j++)
{
bytesIDBio[i] = dados[j];
}
// Conversão do Cartão
byte[] bytesCartao = new byte[Protocol.TAMANHO_CARTAO_FUNCIONARIO];
for (int i = 0, j = Protocol.INDICE_CARTAO_FUNCIONARIO;
i < Protocol.TAMANHO_CARTAO_FUNCIONARIO &&
j < Protocol.INDICE_CARTAO_FUNCIONARIO + Protocol.TAMANHO_CARTAO_FUNCIONARIO;
i++, j++)
{
bytesCartao[i] = dados[j];
}
Conversor.bytesASCIIToString(bytesCartao);
// Conversão do Código
byte[] bytesCodigo = new byte[Protocol.TAMANHO_CODIGO_FUNCIONARIO];
for (int i = 0, j = Protocol.INDICE_CODIGO_FUNCIONARIO;
i < Protocol.TAMANHO_CODIGO_FUNCIONARIO &&
j < Protocol.INDICE_CODIGO_FUNCIONARIO + Protocol.TAMANHO_CODIGO_FUNCIONARIO;
i++, j++)
{
bytesCodigo[i] = dados[j];
}
funcionarioLido.idEmployee = Convert.ToInt32(Conversor.bytesCodigoToString(bytesCodigo));
// Conversão do Mestre
Conversor.byteToInt(dados[Protocol.INDICE_MESTRE_FUNCIONARIO]);
// Conversão da Senha
byte[] bytesSenha = new byte[Protocol.TAMANHO_SENHA_FUNCIONARIO];
for (int i = 0, j = Protocol.INDICE_SENHA_FUNCIONARIO;
i < Protocol.TAMANHO_SENHA_FUNCIONARIO &&
j < Protocol.INDICE_SENHA_FUNCIONARIO + Protocol.TAMANHO_SENHA_FUNCIONARIO;
i++, j++)
{
bytesSenha[i] = dados[j];
}
Conversor.BCDtoString(bytesSenha);
// Conversão do Verificar 1 pra N
Conversor.byteToInt(dados[Protocol.INDICE_VERIFICAR_1_PRA_N]);
}
catch (Exception e)
{
errorCommand.setErro(ErrorCommand.RETORNO_INCONSISTENTE);
}
return(errorCommand);
}
public ErrorCommand execute(String ip, String porta, String cpf, String pis)
{
Boolean finalizarConexao = false;
ErrorCommand errorCommand = new ErrorCommand();
if (tcp == null)
{
try
{
finalizarConexao = true;
tcp = new Tcp(ip, Convert.ToInt16(porta));
}
catch (IOException e) {
errorCommand.setErro(ErrorCommand.COMUNICACAO_NAO_ESTABELECIDA);
return(errorCommand);
}
}
try
{
try
{
byte[] bytesCpf = Conversor.cpfToByte(cpf);
byte[] cabecalhoDadosGravaFuncionario = criarPacoteCabecalho(CommandCodes.START_PC, CommandCodes.ENVIAR_FUNCIONARIO,
new byte[] { 0x00, 0x00, 0x00, 0x01 }, new byte[4], bytesCpf,
(byte)ErrorCommand.EXCLUIR, CommandCodes.END);
// Envia o cabeçalho
sendBuffer(cabecalhoDadosGravaFuncionario, 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_FUNCIONARIO, retornoReal, qtdBytesRecebidos, Protocol.QTD_BYTES_CABECALHO_CRIPTOGRAFADO);
if (errorCommand.getErro() == ErrorCommand.SUCESSO)
{
cabecalhoDadosGravaFuncionario = criarPacoteCabecalho(CommandCodes.START_PC, CommandCodes.ENVIAR_FUNCIONARIO,
new byte[] { 0x00, 0x01, 0x00, 0x01 }, new byte[] { 0x00, 0x00, 0x00, 0x61 },
bytesCpf, (byte)ErrorCommand.DADOS_OK, CommandCodes.END);
byte checkSumCabecalho = cabecalhoDadosGravaFuncionario[cabecalhoDadosGravaFuncionario.Length - 2];
byte[] dadosGravaFuncionario = criaPacoteDados(checkSumCabecalho, bytesCpf, pis);
// Envia os dados do funcionário
sendBuffer(ProtocolUtils.merge(cabecalhoDadosGravaFuncionario, dadosGravaFuncionario), 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_FUNCIONARIO, retornoReal, qtdBytesRecebidos, Protocol.QTD_BYTES_CABECALHO_CRIPTOGRAFADO);
}
}
catch (Exception e)
{
errorCommand.setErro(ErrorCommand.OCORREU_EXCECAO);
}
if (finalizarConexao)
{
tcp.finalizaConexao();
}
}
catch (Exception e)
{
errorCommand.setErro(ErrorCommand.ERRO_FINALIZAR_CONEXAO);
}
return(errorCommand);
}
