public void acumular(string binario)
{
this._acumulador += Conversor.BinarioDecimal(binario);
}
public double ConverterValoresParaMoedas(double valor, TipoMoeda tipoMoeda)
{
var conversor = new Conversor(tipoMoeda);
return(conversor.Converter(valor));
}
public FlagErroComando execute(String ip, String porta, String cpf, String hash, ref LogManager logManager)
{
FlagErroComando flagErroComando = new FlagErroComando();
Tcp tcp = null;
try
{
tcp = new Tcp(ip, Convert.ToInt32(porta));
}
catch {
flagErroComando.setErro(FlagErroComando.COMUNICACAO_NAO_ESTABELECIDA);
return(flagErroComando);
}
byte[] buffer = criarPacoteCabecalho(CodigosComandos.START_PC, CodigosComandos.ENVIAR_DATA_HORA,
ProtocoloUtils.data(), ProtocoloUtils.horario(), Conversor.cpfToByte(cpf), (byte)0x00, CodigosComandos.END);
//0A 00 00 00 00 91 00 18 B7 E1 00 36 04 0F 00 02 96 46 19 C7 00 E4 40
try
{
enviaBuffer(buffer, true, tcp, hash, ref logManager);
try
{
// Lê resposta do REP
byte[] respostaREP = lerResposta(tcp, Protocolo.QTD_BYTES_CABECALHO_CRIPTOGRAFADO, hash, ref logManager);
int qtdBytesRecebidos = -1;
if (respostaREP != null)
{
qtdBytesRecebidos = respostaREP.Length;
}
// Trata a resposta do REP
flagErroComando = tratarResposta(CodigosComandos.ENVIAR_DATA_HORA, respostaREP, qtdBytesRecebidos, Protocolo.QTD_BYTES_CABECALHO_CRIPTOGRAFADO);
}
catch (Exception e)
{
throw e;
}
tcp.finalizaConexao();
}
catch (Exception e)
{
flagErroComando.setErro(FlagErroComando.OCORREU_EXCECAO);
throw e;
}
return(flagErroComando);
}
public ActionResult Edit(int id, MaterialViewModel viewModel)
{
if (ModelState.IsValid)
{
_context = new ApplicationDbContext();
try
{
var rst = _context.Materiais.FirstOrDefault(c => c.MaterialID == id);
rst.MaterialDescricao = viewModel.MaterialDescricao;
rst.MaterialClasse = viewModel.MaterialClasse;
rst.MaterialUM = viewModel.MaterialUM;
rst.FamiliaID = viewModel.FamiliaID;
rst.MGCodeID = viewModel.MGCodeID;
rst.ClassificacaoID = viewModel.ClassificacaoID;
rst.MaterialBloqueado = viewModel.MaterialBloqueado;
rst.MaterialSubId = viewModel.MaterialSubId;
_context.Materiais.Attach(rst);
_context.Entry(rst).State = System.Data.Entity.EntityState.Modified;
var usuario = _context.Usuarios.FirstOrDefault(c => c.UserName == User.Identity.Name);
var comp = new HistoricoMaterial
{
MaterialID = rst.MaterialID,
UsuarioLogisticaID = usuario.Id,
HistMatDataLanc = DateTime.Now,
HistMatInformacoes = viewModel.MaterialObservacoes
};
_context.HistoricoMateriais.Add(comp);
_context.Entry(comp).State = EntityState.Added;
_context.SaveChanges();
var val = Conversor.StringToDecimal(viewModel.ValorDeReferencia);
if (_context.ValorReferencias.Where(c => c.MaterialID == id).FirstOrDefault().ValorDeReferencia != val)
{
try {
var prec = _context.ReferenciaDePrecos.Where(c => c.MaterialID == id).FirstOrDefault();
prec.PrecoValor = val;
prec.PrecoDataLanc = DateTime.Now;
prec.UsuarioId = usuario.Id;
_context.ReferenciaDePrecos.Add(prec);
_context.Entry(prec).State = EntityState.Modified;
_context.SaveChanges();
}
catch (Exception)
{
var refPrec = new ReferenciaDePreco
{
MaterialID = id,
PrecoValor = val,
PrecoDataLanc = DateTime.Now,
UsuarioId = usuario.Id
};
_context.ReferenciaDePrecos.Add(refPrec);
_context.Entry(refPrec).State = EntityState.Added;
_context.SaveChanges();
}
// _context.Dispose();
//AtualizaBase();
}
// Task.Run(()=>AtualizaBase());
// var i = AtualizaBase();
// await AtualizaBase();
return(RedirectToAction("Index"));
}
catch
{
return(View("Edit/" + id));
}
}
else
{
return(View());
}
}
async void Confirmar()
{
try
{
ChamadaWebApi chamadaWebApi = new ChamadaWebApi();
chamadaWebApi.Post <Processo>(new Processo(clienteSelecionado, Status.Ativo, numero, estadoSelecionado, Conversor.StringParaDecimal(valor)));
await pagina.DisplayAlert("Processo", "Processo cadastrado com sucesso.", "Ok");
ClienteSelecionado = null;
Numero = string.Empty;
EstadoSelecionado = null;
Valor = string.Empty;
ListarProcessos();
}
catch (Exception ex)
{
await pagina.DisplayAlert("Erro", ex.Message, "Ok");
}
}
public RegraDeRemuneracaoBD ConverterDe(ParametrosDeRegraDeRemuneracao parametros)
{
return(Conversor.ConverterDe(parametros));
}
static void Main(string[] args)
{
double numero = 0;
int opcion = 0;
double acumuladorDouble = 0;
string cadena = "";
char continuar = 'S';
do
{
Console.Clear();
Console.WriteLine("\n\nCONVERSOR DE NUMEROS DE DIFERENTES BASES\n\n");
Console.WriteLine("\n 1_Convertir de DECIMAL A BINARIO\n");
Console.WriteLine("\n 2_Convertir de BINARIO A DECIMAL\n");
Console.WriteLine("\n\nSeleccionar una Opcion de Conversion\n\n");
cadena = Console.ReadLine();
while ((!(Ejercicio_11.Validacion.Validar(cadena))) || ((cadena != "1") && (cadena != "2")))
{
Console.Clear();
Console.WriteLine("\n\nCONVERSOR DE NUMEROS DE DIFERENTES BASES\n\n");
Console.WriteLine("\n 1_Convertir de DECIMAL A BINARIO\n");
Console.WriteLine("\n 2_Convertir de BINARIO A DECIMAL\n");
Console.WriteLine("\n\nERROR...Reingrese un numero de Opcion\n\n");
cadena = Console.ReadLine();
}
opcion = Convert.ToInt32(cadena);
switch (opcion)
{
case 1:
Console.Clear();
Console.WriteLine("\n 1_Convertir de DECIMAL A BINARIO\n");
Console.WriteLine("\n\nIngrese el numero a convertir\n\n");
cadena = Console.ReadLine();
while (!(Ejercicio_11.Validacion.ValidarDouble(cadena)))
{
Console.WriteLine("\n\nERROR...Reingrese un numero\n\n");
cadena = Console.ReadLine();
}
numero = Convert.ToDouble(cadena);
cadena = Conversor.DecimalBinario(numero);
Console.WriteLine("\n\nEl numero Binario es: {0} \n\n", cadena);
break;
case 2:
Console.Clear();
Console.WriteLine("\n 2_Convertir de BINARIO A DECIMAL\n");
Console.WriteLine("\n\nIngrese el numero a convertir\n\n");
cadena = Console.ReadLine();
acumuladorDouble = Conversor.BinarioDecimal(cadena);
Console.WriteLine("\n\nEl numero Decimal es: {0} \n\n", acumuladorDouble);
break;
}
Console.WriteLine("\n\n¿Continuar?\n\n");
cadena = Console.ReadLine();
//continuar = Convert.ToChar(cadena);
while (cadena == "")
{
Console.WriteLine("\n\nERROR...Ingrese S para continuar, o cualquier otra letra para salir...¿Desea Continuar?\n\n");
cadena = Console.ReadLine();
}
continuar = Ejercicio_12.ValidarRespuesta.CovertirStringAchar(cadena);
} while (Ejercicio_12.ValidarRespuesta.ValidaS_N(continuar));
}
// ii. double - (NumeroDecimal, NumeroBinario)
public static double operator -(NumeroDecimal d, NumeroBinario b)
{
double resultado = d.numero - (Conversor.BinarioDecimal(b.numero));
return(resultado);
}
// iii. bool == (NumeroDecimal, NumeroBinario)
public static bool operator ==(NumeroDecimal d, NumeroBinario b)
{
return(d.numero == (Conversor.BinarioDecimal(b.numero)));
}
private void btnBinarioDecimal_Click(object sender, EventArgs e)
{
txtResultadoBinDec.Text = (Conversor.BinarioDecimal(txtBinarioDecimal.Text)).ToString();
}
private void btnDecimalBinario_Click(object sender, EventArgs e)
{
txtResultadoDecBin.Text = (Conversor.DecimalBinario(double.Parse(txtDecimalBinario.Text)));
}
public static bool operator !=(NumeroBinario num_bin, NumeroDecimal num_dec)
{
return(!((double)Conversor.BinarioDecimal(num_bin.numero) == num_dec.numero));
}
public static string operator -(NumeroBinario num_bin, NumeroDecimal num_dec)
{
return(Conversor.DecimalBinario((int)((double)Conversor.BinarioDecimal(num_bin.numero) - num_dec.numero)));
}
public string getResultadoBinario()
{
return(Conversor.EnteroBinario(this._acumulador));
}
public void Cadastrar(LocalizacaoGeograficaDTO localizacaoGeograficaDTO)
{
DataContext.Localizacaogeograficas.Add(Conversor.Mapear(localizacaoGeograficaDTO));
DataContext.SaveChanges();
}
public static void Main(string[] args)
{
Conversor c = new Conversor(1024 * 1024);
Console.WriteLine(c.Binario());
}
public RegraDeRemuneracaoBD ConverteDe(IRegraDeRemuneracao regra)
{
return(Conversor.ConverterDe(regra));
}
private void button2_ConvertirADecimal(object sender, EventArgs e)
{
numeroAux = textBox2BinarioADecimal.Text;
numeroDecimal = Conversor.BinarioDecimal(numeroAux);
textBox1DecimalABinario.Text = numeroDecimal.ToString();
}
public ParametrosDeRegraDeRemuneracao ConvertePara(RegraDeRemuneracaoBD contratoBD)
{
return(Conversor.ConverterDe(contratoBD));
}
private void button1_ConvertirABinario(object sender, EventArgs e)
{
numeroAux = textBox1DecimalABinario.Text;
numeroBinal = Conversor.DecimalBinario(int.Parse(numeroAux));
textBox2BinarioADecimal.Text = numeroBinal;
}
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 Models.Response.FuncionarioResponse DeletarFuncionario(int idfuncionario)
{
Models.TbFuncionario removido = funcaoBusiness.DeletarBusiness(idfuncionario);
return(Conversor.Convert(removido));
}
static void Main(string[] args)
{
Console.WriteLine(Conversor.EuroParaReais(62));
Console.WriteLine(Conversor.RealParaEuro(62));
}
public Models.Response.FuncionarioResponse AlterarFuncionario(int idFuncionario, Models.Request.FuncionarioRequest novo)
{
Models.TbFuncionario funcionario = Conversor.Convert(novo);
Models.TbFuncionario alterado = funcaoBusiness.AlterarFuncionario(idfuncionario, funcionario);
return(Conversor.Convert(alterado));
}
public void TesteValorMagParaString()
{
conversor = new Conversor();
Assert.AreEqual("2500000000", conversor.ValorMagParaString(25, 10));
}
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);
}
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);
}
private void btnConvertirEuro_Click(object sender, EventArgs e)
{
_euro = Conversor.BinarioDecimal(this.txtBEuro.Text);
this.txtBEuroEuro.Text = _euro._numero.ToString();
this.txtBEuroEuro.Enabled = false;
}
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 virtual ParametrosDeFavorecimento ConvertePara(FavorecimentoBD favorecimento)
{
return(Conversor.ConverteDe(favorecimento));
}