public override async Task <Command> Add(Command command)
{
Command cmd = new Command(command);
try
{
var dto = await SerializerAsync.DeserializeJson <UserPlantaDto>(command.Json);
if (!string.IsNullOrEmpty(dto.UserId) && dto.PlantaId > 0)
{
var userPlantas = await MyRepository.Get(t => t.PlantaId == dto.PlantaId &&
t.UserId.Equals(dto.UserId));
var userDbSet = Context.Set <UserAccount>();
var user = await userDbSet.FindAsync(dto.UserId);
var plantaRep = new Repository <Planta>(Context);
var planta = await plantaRep.GetById(dto.PlantaId);
if (userPlantas != null && !userPlantas.Any() && user != null && planta != null)
{
var entity = new UserPlanta();
entity.UpdateEntity(dto);
entity.Codigo = dto.UserId + dto.PlantaId + DateTime.Now.ToString();
entity.Planta = planta;
var insertEntity = await MyRepository.Insert(entity);
if (insertEntity != null)
{
cmd.Cmd = ServerCommands.LogResultOk;
cmd.Json = await SerializerAsync.SerializeJson(true);
await MyRepository.Save();
cmd.EntityId = entity.Id;
}
else
{
cmd.Cmd = ServerCommands.RepeatedHumanCode;
ConsoleEx.WriteLine(ServerCommands.RepeatedHumanCode);
}
}
else
{
cmd.Cmd = ServerCommands.LogResultDeny;
}
}
else
{
cmd.Cmd = ServerCommands.LogResultDeny;
}
}
catch (Exception e)
{
ConsoleEx.WriteError(e);
}
return(cmd);
}
public override async Task <Command> Edit(Command command)
{
Command cmd = new Command(command);
try
{
var dto = await SerializerAsync.DeserializeJson <TipoEntradaDto>(command.Json);
var tipoEntrada = await MyRepository.GetById(cmd.EntityId);
if (tipoEntrada != null)
{
tipoEntrada.Descricao = dto.Description;
cmd.Cmd = ServerCommands.LogResultOk;
cmd.Json = await SerializerAsync.SerializeJson(true);
await MyRepository.Save();
}
else
{
cmd.Cmd = ServerCommands.LogResultDeny;
cmd.Json = await SerializerAsync.SerializeJson(false);
}
}
catch (Exception e)
{
ConsoleEx.WriteError(e);
}
return(cmd);
}
public static async void ReturnLoginRequest(Object[] server, Object[] local)
{
var dataJson = SerializerAsync.DeserializeJson <Command>(server[0].ToString()).Result;
try
{
if (dataJson != null)
{
if (dataJson.Cmd.Equals(ServerCommands.LogResultOk))
{
var username = await SerializerAsync.DeserializeJson <string>(dataJson.Json);
if (UsersConnections.TryGetValue(username, out var conn))
{
await conn.Zz.WriteServer(new Command { Cmd = ServerCommands.IsUser, Json = await SerializerAsync.SerializeJson(username) });
}
}
else if (dataJson.Cmd.Equals(ServerCommands.LogResultDeny))
{
var username = await SerializerAsync.DeserializeJson <string>(dataJson.Json);
await RemoveUserConnection(username);
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public static async void ReturnLogoutRequest(Object[] server, Object[] local)
{
var dataJson = SerializerAsync.DeserializeJson <Command>(server[0].ToString()).Result;
try
{
if (dataJson != null)
{
if (dataJson.Cmd.Equals(ServerCommands.LogResultOk))
{
var username = await SerializerAsync.DeserializeJson <string>(dataJson.Json);
UsersConnections.Remove(username);
ConsoleEx.WriteLine("Usuario removido da lista de autorizados com sucesso");
}
else if (dataJson.Cmd.Equals(ServerCommands.LogResultDeny))
{
var username = await SerializerAsync.DeserializeJson <string>(dataJson.Json);
UsersConnections.Remove(username);
ConsoleEx.WriteLine("Deu merda ao remover o usuario da lista de autorizados");
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public void ReturnServer(Object[] server, Object[] local)
{
var dataJson = SerializerAsync.DeserializeJson <Command>(server[0].ToString()).Result;
try
{
if (dataJson != null)
{
if (!dataJson.Cmd.Equals(ServerCommands.Exit))
{
if (dataJson.Cmd.Equals(ServerCommands.LogResultOk))
{
ConsoleEx.WriteLine("Uhulll, consegui logar");
_expirationTimer =
ZZApiMain.SetTimer(
(LoginResultDto.ExpirationDate - LoginResultDto.CreatedDate).TotalMilliseconds,
ExpirationTokenTimer);
}
else if (dataJson.Cmd.Equals(ServerCommands.LogResultDeny))
{
ConsoleEx.WriteLine("Algo deu errado");
ZZApiMain.RemoveUserConnection(LoginResultDto.Username);
}
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public async Task <ActionResult <UserDadosDto> > GetByHumanCode(UserDadosDto dto)
{
try
{
var myUsername = User.Identity.Name;
if (ZZApiMain.VerifyUserAuthorize(myUsername))
{
if (ZZApiMain.UsersConnections.TryGetValue(myUsername, out var myConn))
{
var myId = await myConn.Zz.ApiWriteServer(myUsername, new Command { Cmd = ServerCommands.GetById, EntityId = dto.Id, Tela = Tela, Json = await SerializerAsync.SerializeJson(dto) });
var responseCommand = await myConn.Zz.GetApiWaitCommand(myId);
if (responseCommand != null && responseCommand.Cmd.Equals(ServerCommands.LogResultOk))
{
return(await SerializerAsync.DeserializeJson <UserDadosDto>(responseCommand.Json));
}
}
}
return(NotFound());
}
catch (Exception e)
{
ConsoleEx.WriteError(e);
return(NotFound());
}
}
public async Task <Command> GetByHumanCode(Command command)
{
Command cmd = new Command(command);
try
{
var dto = await SerializerAsync.DeserializeJson <EntityDto>(cmd.Json);
var entity = await MyRepository.GetByHumanCode(dto.Codigo);
if (entity != null)
{
cmd.Cmd = ServerCommands.LogResultOk;
cmd.Json = await SerializerAsync.SerializeJson(entity.ConvertDto());
}
else
{
cmd.Cmd = ServerCommands.LogResultDeny;
}
}
catch (Exception e)
{
ConsoleEx.WriteError(e);
}
return(cmd);
}
public override async Task <Command> Add(Command command)
{
Command cmd = new Command(command);
try
{
var dto = await SerializerAsync.DeserializeJson <ServicoDto>(command.Json);
var servicos = await MyRepository.Get(t => t.Codigo.Equals(dto.Codigo));
if (servicos != null && !servicos.Any())
{
var unidadeMedidaRep = new Repository <UnidadeMedida>(Context);
var unidadeMedida = await unidadeMedidaRep.GetById(dto.UnidadeMedidaId);
var tipoServicoRep = new Repository <TipoServico>(Context);
var tipoServico = await tipoServicoRep.GetById(dto.TipoServicoId);
var centroCustoRep = new Repository <CentroCustoSintetico>(Context);
var centroCusto = await centroCustoRep.GetById(dto.CentroCustoId);
if (unidadeMedida != null && tipoServico != null && centroCusto != null)
{
var entity = new Servico();
entity.UpdateEntity(dto);
entity.UnidadeMedida = unidadeMedida;
entity.TipoServico = tipoServico;
entity.CentroCusto = centroCusto;
var insertEntity = await MyRepository.Insert(entity);
if (insertEntity != null)
{
cmd.Cmd = ServerCommands.LogResultOk;
cmd.Json = await SerializerAsync.SerializeJson(true);
await MyRepository.Save();
cmd.EntityId = entity.Id;
}
else
{
cmd.Cmd = ServerCommands.RepeatedHumanCode;
ConsoleEx.WriteLine(ServerCommands.RepeatedHumanCode);
}
}
}
else
{
cmd.Cmd = ServerCommands.LogResultDeny;
}
}
catch (Exception e)
{
ConsoleEx.WriteError(e);
}
return(cmd);
}
public static async Task <Command> GetAddress(Command command)
{
Command cmd = new Command(command);
try
{
using (var context = new ZZContext())
{
var dto = await SerializerAsync.DeserializeJson <EnderecoDto>(cmd.Json);
var rep = new Repository <Endereco>(context);
var enderecos = await rep.Get(e => e.Logradouro.Equals(dto.Logradouro) && e.Numero == dto.Numero);
var endList = enderecos.ToList();
if (endList.Any())
{
cmd.Cmd = ServerCommands.LogResultOk;
var dtosEnd = endList.Select(e => e.ConvertDto()).ToList();
cmd.Json = await SerializerAsync.SerializeJsonList(dtosEnd);
}
else
{
var addressList = await SearchAddressAsync(dto.Estado, dto.Cidade, dto.Logradouro,
CancellationToken.None);
var viaCepResults = addressList.ToList();
if (viaCepResults.Any())
{
cmd.Cmd = ServerCommands.LogResultOk;
var dtos = viaCepResults.Select(d => new EnderecoDto
{
Cep = d.ZipCode,
Bairro = d.Neighborhood,
Cidade = d.City,
Estado = d.StateInitials,
Logradouro = d.Street,
Complemento = d.Complement,
Ibge = d.IBGECode,
GIACode = d.GIACode,
Numero = dto.Numero,
Codigo = d.IBGECode.ToString() + d.GIACode.ToString() + d.ZipCode + dto.Numero.ToString()
});
cmd.Json = await SerializerAsync.SerializeJsonList(dtos.ToList());
}
else
{
cmd.Cmd = ServerCommands.LogResultDeny;
}
}
}
}
catch (Exception e)
{
ConsoleEx.WriteError(e);
}
return(cmd);
}
public static async Task <Command> GetAddressByZipCode(Command command)
{
Command cmd = new Command(command);
try
{
using (var context = new ZZContext())
{
var dto = await SerializerAsync.DeserializeJson <EnderecoDto>(cmd.Json);
var rep = new Repository <Endereco>(context);
var enderecos = await rep.Get(e => e.Cep.Equals(dto.Cep) && e.Numero == dto.Numero);
if (enderecos != null && enderecos.Any())
{
var endList = enderecos.FirstOrDefault();
cmd.Cmd = ServerCommands.LogResultOk;
var dtosEnd = endList.ConvertDto();
cmd.Json = await SerializerAsync.SerializeJson(dtosEnd);
}
else
{
var address = await SearchAddressAsync(dto.Cep, CancellationToken.None);
if (address != null)
{
cmd.Cmd = ServerCommands.LogResultOk;
var entity = new EnderecoDto
{
Cep = address.ZipCode,
Bairro = address.Neighborhood,
Cidade = address.City,
Estado = address.StateInitials,
Logradouro = address.Street,
Complemento = address.Complement,
Ibge = address.IBGECode,
GIACode = address.GIACode,
Numero = dto.Numero,
Codigo = address.IBGECode.ToString() + address.GIACode.ToString() + address.ZipCode + dto.Numero.ToString()
};
cmd.Json = await SerializerAsync.SerializeJson(entity);
}
else
{
cmd.Cmd = ServerCommands.LogResultDeny;
}
}
}
}
catch (Exception e)
{
ConsoleEx.WriteError(e);
}
return(cmd);
}
public override async Task <Command> Edit(Command command)
{
Command cmd = new Command(command);
try
{
var dto = await SerializerAsync.DeserializeJson <ServicoDto>(command.Json);
var servico = await MyRepository.GetById(cmd.EntityId);
if (servico != null)
{
servico.UpdateEntity(dto);
var unidadeMedidaRep = new Repository <UnidadeMedida>(Context);
var unidadeMedida = await unidadeMedidaRep.GetById(dto.UnidadeMedidaId);
if (unidadeMedida != null)
{
servico.UnidadeMedida = unidadeMedida;
}
var tipoServicoRep = new Repository <TipoServico>(Context);
var tipoServico = await tipoServicoRep.GetById(dto.TipoServicoId);
if (tipoServico != null)
{
servico.TipoServico = tipoServico;
}
var centroCustoRep = new Repository <CentroCustoSintetico>(Context);
var centroCusto = await centroCustoRep.GetById(dto.CentroCustoId);
if (centroCusto != null)
{
servico.CentroCusto = centroCusto;
}
cmd.Cmd = ServerCommands.LogResultOk;
cmd.Json = await SerializerAsync.SerializeJson(true);
await MyRepository.Save();
}
else
{
cmd.Cmd = ServerCommands.LogResultDeny;
cmd.Json = await SerializerAsync.SerializeJson(false);
}
}
catch (Exception e)
{
ConsoleEx.WriteError(e);
}
return(cmd);
}
public override async Task <Command> Add(Command command)
{
Command cmd = new Command(command);
try
{
var dto = await SerializerAsync.DeserializeJson <TabelaDto>(command.Json);
var tabelas = await MyRepository.Get(t => t.ServicoId == dto.ServicoId && t.Descricao.Equals(dto.Description));
if (tabelas != null && !tabelas.Any())
{
var servicoRep = new Repository <Servico>(Context);
var servico = await servicoRep.GetById(dto.ServicoId);
if (servico != null)
{
var entity = new TabelaCusto();
entity.UpdateEntity(dto);
entity.DataTabela = DateTime.Now;
entity.Servico = servico;
var insertEntity = await MyRepository.Insert(entity);
if (insertEntity != null)
{
cmd.Cmd = ServerCommands.LogResultOk;
cmd.Json = await SerializerAsync.SerializeJson(true);
await MyRepository.Save();
cmd.EntityId = entity.Id;
}
else
{
cmd.Cmd = ServerCommands.RepeatedHumanCode;
ConsoleEx.WriteLine(ServerCommands.RepeatedHumanCode);
}
}
}
else
{
cmd.Cmd = ServerCommands.LogResultDeny;
}
}
catch (Exception e)
{
ConsoleEx.WriteError(e);
}
return(cmd);
}
/// <summary>
/// Searches the asynchronous.
/// </summary>
/// <param name="zipCode">The zip code.</param>
/// <param name="token">The token.</param>
/// <returns></returns>
public static async Task <ViaCEPResult> SearchAddressAsync(String zipCode, CancellationToken token)
{
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(BaseUrl);
var response = await client.GetAsync($"/ws/{zipCode}/json", token).ConfigureAwait(false);
response.EnsureSuccessStatusCode();
var jsonContent = await response.Content.ReadAsStringAsync();
var json = await SerializerAsync.DeserializeJson <ViaCEPResult>(jsonContent);
json.ZipCode = new String(json.ZipCode.Where(Char.IsDigit).ToArray());
return(json);
}
}
public void ProcessLogin(Object[] server, Object[] local)
{
var dataJson = SerializerAsync.DeserializeJson <Command>(server[0].ToString()).Result;
try
{
if (dataJson != null)
{
if (!dataJson.Cmd.Equals(ServerCommands.Exit))
{
if (dataJson.Cmd.Equals(ServerCommands.IsController))
{
ConsoleEx.WriteLine("Oi Controller fofo *3* ");
_client = new ControllerClient();
MyId = ServerCommands.IsController;
_client.Login(this, connection);
}
else if (dataJson.Cmd.Equals(ServerCommands.IsUser))
{
if (Server.VerifyUserAuthorization(
SerializerAsync.DeserializeJson <string>(dataJson.Json).Result, this))
{
ConsoleEx.WriteLine("Oi Cli fofo *3* ");
MyId = SerializerAsync.DeserializeJson <string>(dataJson.Json).Result;
_client = new UserClient();
_client.Login(this, connection);
}
else
{
ConsoleEx.WriteLine("Cliente não autorizado");
connection.WriteServer("", 542, ServerCommands.LogResultDeny, "");
}
}
else
{
_client.Command(dataJson);
}
}
}
}
catch (Exception e)
{
ConsoleEx.WriteLine("Erro na criação do client : " + " | " + _client + " | " +
dataJson + " | " + e.Message);
}
}
/// <summary>
/// Converte um array de object recebido como entrada de um DelegateAction em Command
/// </summary>
/// <param name="s"></param>
/// <returns><typeparam name="dataJson"></typeparam></returns>
public static async Task <Command> ObjectToCommand(Object[] s)
{
try
{
var data = s[0].ToString();
Command dataJson = new Command();
dataJson = await SerializerAsync.DeserializeJson <Command>(data);
return(dataJson);
}
catch (Exception e)
{
ConsoleEx.WriteError(e);
return(null);
}
}
public override async Task Command(Command command)
{
try
{
if (Manager != null && Connection != null)
{
if (command.Cmd != null)
{
if (command.Cmd.Equals(ServerCommands.AddClientAuthorized))
{
if (Manager.Server.AddAuthorizedUser(
await SerializerAsync.DeserializeJson <string>(command.Json)))
{
command.Cmd = ServerCommands.LogResultOk;
}
else
{
command.Cmd = ServerCommands.LogResultDeny;
}
await Connection.WriteServer(command);
}
else if (command.Cmd.Equals(ServerCommands.RemoveClientAuthorized))
{
if (Manager.Server.RemoveAuthorizedUser(
await SerializerAsync.DeserializeJson <string>(command.Json)))
{
command.Cmd = ServerCommands.LogResultOk;
}
else
{
command.Cmd = ServerCommands.LogResultDeny;
}
await Connection.WriteServer(command);
}
}
}
}
catch (Exception e)
{
ConsoleEx.WriteError("Erro ao receber command do controller ", e);
throw;
}
}
public override async Task <Command> Add(Command command)
{
Command cmd = new Command(command);
try
{
var dto = await SerializerAsync.DeserializeJson <TipoEntradaDto>(command.Json);
var tipos = await MyRepository.Get(t => t.Descricao.Equals(dto.Description));
if (tipos != null && !tipos.Any())
{
var entity = new TipoEntrada();
entity.UpdateEntity(dto);
var insertEntity = await MyRepository.Insert(entity);
if (insertEntity != null)
{
cmd.Cmd = ServerCommands.LogResultOk;
cmd.Json = await SerializerAsync.SerializeJson(true);
await MyRepository.Save();
cmd.EntityId = entity.Id;
}
else
{
cmd.Cmd = ServerCommands.RepeatedHumanCode;
ConsoleEx.WriteLine(ServerCommands.RepeatedHumanCode);
}
}
else
{
cmd.Cmd = ServerCommands.LogResultDeny;
}
}
catch (Exception e)
{
ConsoleEx.WriteError(e);
}
return(cmd);
}
public override async Task <Command> Edit(Command command)
{
Command cmd = new Command(command);
try
{
var dto = await SerializerAsync.DeserializeJson <CompraManualDto>(command.Json);
var compras = await MyRepository.Get(c => c.Id == cmd.EntityId, null, "TipoEntrada,Fornecedor,Itens,Itens.Servico,Itens.Unidade");
var compraManual = compras.FirstOrDefault();
if (compraManual != null)
{
compraManual.UpdateEntity(dto);
if (compraManual.Itens != null && compraManual.Itens.Count > 0)
{
compraManual.ValorTotal = 0;
foreach (var item in compraManual.Itens)
{
compraManual.ValorTotal += item.ValorTotal;
}
}
cmd.Cmd = ServerCommands.LogResultOk;
cmd.Json = await SerializerAsync.SerializeJson(true);
await MyRepository.Save();
}
else
{
cmd.Cmd = ServerCommands.LogResultDeny;
cmd.Json = await SerializerAsync.SerializeJson(false);
}
}
catch (Exception e)
{
ConsoleEx.WriteError(e);
}
return(cmd);
}
public override async Task <Command> Edit(Command command)
{
Command cmd = new Command(command);
try
{
var dto = await SerializerAsync.DeserializeJson <UserDadosDto>(command.Json);
var cliente = await MyRepository.GetById(cmd.EntityId);
if (cliente != null)
{
cliente.UpdateEntity(dto);
var enderecoRep = new Repository <Endereco>(Context);
var endereco = await enderecoRep.GetById(dto.Endereco.Id);
if (endereco != null)
{
endereco.UpdateEntity(dto.Endereco);
cliente.Endereco = endereco;
}
cmd.Cmd = ServerCommands.LogResultOk;
cmd.Json = await SerializerAsync.SerializeJson(true);
await MyRepository.Save();
}
else
{
cmd.Cmd = ServerCommands.LogResultDeny;
cmd.Json = await SerializerAsync.SerializeJson(false);
}
}
catch (Exception e)
{
ConsoleEx.WriteError(e);
}
return(cmd);
}
public async Task <Command> GetApiWaitCommand(string id)
{
Command cmd = null;
_isWait = true;
int timeCount = 0;
//while (cmd == null && timeCount <= ServerCommands.TimeOutApiRequest)
//{
// cmd = _waitCommandsList.First(c => c.Id == id);
// await Task.Delay(100);
// timeCount++;
//}
do
{
var data = _sr?.ReadLine();
var dataDescomp = await StringCompressionAsync.DecompressString(data);
cmd = await SerializerAsync.DeserializeJson <Command>(dataDescomp);
if (cmd != null && !cmd.IsWait)
{
DelegateAction del;
if (!string.IsNullOrEmpty(cmd.Id) &&
_srvsCmdsBuffer.TryGetValue(cmd.Id, out del))
{
del.server[0] = dataDescomp;
del.Exec();
}
else if (_srvsCmdsBuffer.TryGetValue(ServerCommands.BroadCastId, out del))
{
del.server[0] = dataDescomp;
del.Exec();
}
}
} while (cmd != null && !cmd.IsWait);
_isWait = false;
return(cmd);
}
public static async Task <Command> EditAddress(Command command)
{
Command cmd = new Command(command);
try
{
using (var context = new ZZContext())
{
var dto = await SerializerAsync.DeserializeJson <EnderecoDto>(cmd.Json);
var repAddress = new Repository <Endereco>(context);
var repCity = new Repository <Cidade>(context);
var cidades = await repCity.Get(c => c.Descricao.Contains(dto.Cidade) && c.Estado.Sigla.Equals(dto.Estado), null, "Estado");
var cidade = cidades.FirstOrDefault();
if (cidade != null)
{
var address = await repAddress.GetById(dto.Id);
if (address != null)
{
cmd.Cmd = ServerCommands.LogResultOk;
address.UpdateEntity(dto);
await repAddress.Save();
}
else
{
cmd.Cmd = ServerCommands.LogResultDeny;
}
}
}
}
catch (Exception e)
{
ConsoleEx.WriteError(e);
}
return(cmd);
}
public static async Task <Command> GetCityByUf(Command command)
{
Command cmd = new Command(command);
try
{
using (var context = new ZZContext())
{
var dto = await SerializerAsync.DeserializeJson <TipoSiglaDto>(cmd.Json);
var repEstado = new Repository <Estado>(context);
var repCity = new Repository <Cidade>(context);
var list = await repEstado.Get(e => e.Sigla.Equals(dto.Sigla));
var entity = list.FirstOrDefault();
var cidades = await repCity.Get(c => c.EstadoId == entity.Id);
var cidadeList = cidades.ToList();
if (cidadeList.Any())
{
cmd.Cmd = ServerCommands.LogResultOk;
var dtos = cidadeList.Select(t => t.ConvertDto(dto.Sigla)).ToList();
cmd.Json = await SerializerAsync.SerializeJsonList(dtos);
}
else
{
cmd.Cmd = ServerCommands.LogResultDeny;
}
}
}
catch (Exception e)
{
ConsoleEx.WriteError(e);
}
return(cmd);
}
public static void ReturnServer(Object[] server, Object[] local)
{
var dataJson = SerializerAsync.DeserializeJson <Command>(server[0].ToString()).Result;
try
{
if (dataJson != null)
{
if (!dataJson.Cmd.Equals(ServerCommands.Exit))
{
if (dataJson.Cmd.Equals(ServerCommands.LogResultOk))
{
Id = dataJson.EntityId;
}
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public override async Task <Command> Add(Command command)
{
Command cmd = new Command(command);
try
{
var dto = await SerializerAsync.DeserializeJson <CompraManualDto>(command.Json);
var compras = await MyRepository.Get(t => t.Codigo.Equals(dto.Codigo));
if (compras != null && !compras.Any())
{
var unidadeMedidaRep = new Repository <UnidadeMedida>(Context);
var servicoRep = new Repository <Servico>(Context);
var tipoEntradaRep = new Repository <TipoEntrada>(Context);
var tipoEntrada = await tipoEntradaRep.GetById(dto.TipoEntradaId);
var fornecedorRep = new Repository <Fornecedor>(Context);
var fornecedor = await fornecedorRep.GetById(dto.FornecedorId);
var entity = new CompraManual();
entity.UpdateEntity(dto);
if (tipoEntrada != null)
{
entity.TipoEntrada = tipoEntrada;
}
if (fornecedor != null)
{
entity.Fornecedor = fornecedor;
}
if (entity.DataEmissao == DateTime.MinValue)
{
entity.DataEmissao = DateTime.Now;
}
if (String.IsNullOrEmpty(entity.Codigo))
{
if (!string.IsNullOrEmpty(entity.Fornecedor.NomeFantasia))
{
entity.Codigo = entity.Fornecedor.NomeFantasia + DateTime.Now.ToString();
}
}
if (entity.Itens != null && entity.Itens.Count > 0)
{
entity.ValorTotal = 0;
foreach (var item in entity.Itens)
{
var unidadeMedida = await unidadeMedidaRep.GetById(item.UnidadeId);
var servico = await servicoRep.GetById(item.ServicoId);
if (unidadeMedida != null)
{
item.Unidade = unidadeMedida;
}
if (servico != null)
{
item.Servico = servico;
item.Codigo = servico.Codigo + DateTime.Now.ToString();
}
entity.ValorTotal += item.ValorTotal;
}
}
var insertEntity = await MyRepository.Insert(entity);
if (insertEntity != null)
{
cmd.Cmd = ServerCommands.LogResultOk;
cmd.Json = await SerializerAsync.SerializeJson(true);
await MyRepository.Save();
cmd.EntityId = entity.Id;
}
else
{
cmd.Cmd = ServerCommands.RepeatedHumanCode;
ConsoleEx.WriteLine(ServerCommands.RepeatedHumanCode);
}
}
else
{
cmd.Cmd = ServerCommands.LogResultDeny;
}
}
catch (Exception e)
{
ConsoleEx.WriteError(e);
}
return(cmd);
}
public override async Task <Command> Add(Command command)
{
Command cmd = new Command(command);
try
{
var dto = await SerializerAsync.DeserializeJson <UserDadosDto>(command.Json);
var clientes = await MyRepository.Get(t => t.Codigo.Equals(dto.Codigo));
if (clientes != null && !clientes.Any())
{
var entity = new Cliente();
entity.UpdateEntity(dto);
var myCmd = new Command();
if (entity.EnderecoId <= 0)
{
var enderecoCmd = new Command {
Json = await SerializerAsync.SerializeJson(dto.Endereco)
};
if (string.IsNullOrEmpty(entity.Endereco.Cep))
{
myCmd = await LocalizationManager.GetAddress(enderecoCmd);
}
else
{
myCmd = await LocalizationManager.GetAddressByZipCode(enderecoCmd);
}
entity.Endereco.UpdateEntity(await SerializerAsync.DeserializeJson <EnderecoDto>(myCmd.Json));
entity.EnderecoId = entity.Endereco.Id;
}
if (entity.EnderecoId > 0)
{
entity.Endereco = null;
}
var insertEntity = await MyRepository.Insert(entity);
if (insertEntity != null)
{
cmd.Cmd = ServerCommands.LogResultOk;
cmd.Json = await SerializerAsync.SerializeJson(true);
await MyRepository.Save();
cmd.EntityId = entity.Id;
}
else
{
cmd.Cmd = ServerCommands.RepeatedHumanCode;
ConsoleEx.WriteLine(ServerCommands.RepeatedHumanCode);
}
}
else
{
cmd.Cmd = ServerCommands.LogResultDeny;
}
}
catch (Exception e)
{
ConsoleEx.WriteError(e);
}
return(cmd);
}
public static async Task <Command> SaveAddress(Command command)
{
Command cmd = new Command(command);
try
{
using (var context = new ZZContext())
{
var dto = await SerializerAsync.DeserializeJson <EnderecoDto>(cmd.Json);
var repAddress = new Repository <Endereco>(context);
if (dto.Ibge <= 0)
{
var viacep = await SearchAddressAsync(dto.Cep, CancellationToken.None);
dto.Ibge = viacep.IBGECode;
dto.GIACode = viacep.GIACode;
}
if (String.IsNullOrWhiteSpace(dto.Codigo))
{
dto.Codigo = dto.Ibge.ToString() + dto.GIACode.ToString() + dto.Cep + dto.Numero.ToString();
}
var address = await repAddress.Get(e =>
e.Logradouro.Equals(dto.Logradouro) && e.Numero == dto.Numero);
if (!address.Any())
{
var entity = new Endereco();
entity.UpdateEntity(dto);
var insertEntity = await repAddress.Insert(entity);
if (insertEntity != null)
{
cmd.Cmd = ServerCommands.LogResultOk;
await repAddress.Save();
cmd.Json = await SerializerAsync.SerializeJson(entity);
cmd.EntityId = entity.Id;
}
else
{
cmd.Cmd = ServerCommands.RepeatedHumanCode;
ConsoleEx.WriteLine(ServerCommands.RepeatedHumanCode);
}
}
else
{
cmd.Cmd = ServerCommands.LogResultDeny;
}
}
}
catch (Exception e)
{
ConsoleEx.WriteError(e);
}
return(cmd);
}
public override async Task <Command> Add(Command command)
{
Command cmd = new Command(command);
try
{
var dto = await SerializerAsync.DeserializeJson <DtoLigacao>(command.Json);
if (dto.FirstDtoId > 0 && dto.SecondDtoId > 0)
{
var funcionarioEstoques = await MyRepository.Get(t => t.FuncionarioId == dto.FirstDtoId &&
t.EstoqueId == dto.SecondDtoId);
var funcRep = new Repository <Funcionario>(Context);
var funcionario = await funcRep.GetById(dto.FirstDtoId);
var estoqueRep = new Repository <Estoque>(Context);
var estoque = await estoqueRep.GetById(dto.SecondDtoId);
if (funcionarioEstoques != null && !funcionarioEstoques.Any() && funcionario != null && estoque != null)
{
var entity = new FuncionarioEstoque();
entity.UpdateEntity(dto);
entity.Codigo = DateTime.Now.ToString();
entity.Funcionario = funcionario;
entity.Estoque = estoque;
var insertEntity = await MyRepository.Insert(entity);
if (insertEntity != null)
{
cmd.Cmd = ServerCommands.LogResultOk;
cmd.Json = await SerializerAsync.SerializeJson(true);
await MyRepository.Save();
cmd.EntityId = entity.Id;
}
else
{
cmd.Cmd = ServerCommands.RepeatedHumanCode;
ConsoleEx.WriteLine(ServerCommands.RepeatedHumanCode);
}
}
else
{
cmd.Cmd = ServerCommands.LogResultDeny;
}
}
else
{
cmd.Cmd = ServerCommands.LogResultDeny;
}
}
catch (Exception e)
{
ConsoleEx.WriteError(e);
}
return(cmd);
}
public override async Task <Command> Add(Command command)
{
Command cmd = new Command(command);
try
{
var dto = await SerializerAsync.DeserializeJson <MovimentoEstoqueDto>(command.Json);
if (await VerififyMovimentoEstoque(dto))
{
var servicoRep = new Repository <Servico>(Context);
var servico = await servicoRep.GetById(dto.ServicoId);
var tipoEntradaRep = new Repository <TipoEntrada>(Context);
var tipoEntrada = await tipoEntradaRep.GetById(dto.TipoEntradaId);
var estoqueRep = new Repository <Estoque>(Context);
var estoque = await estoqueRep.GetById(dto.EstoqueId);
var entity = new MovimentoEstoque();
entity.UpdateEntity(dto);
entity.Estoque = estoque;
entity.Servico = servico;
entity.TipoEntrada = tipoEntrada;
if (String.IsNullOrEmpty(entity.Codigo))
{
if (!string.IsNullOrEmpty(entity.Servico.Codigo))
{
entity.Codigo = entity.Servico.Codigo + DateTime.Now.ToString();
}
}
if (entity.DataMovimento == DateTime.MinValue)
{
entity.DataMovimento = entity.Data;
}
var insertEntity = await MyRepository.Insert(entity);
if (insertEntity != null)
{
cmd.Cmd = ServerCommands.LogResultOk;
cmd.Json = await SerializerAsync.SerializeJson(true);
await MyRepository.Save();
cmd.EntityId = entity.Id;
}
else
{
cmd.Cmd = ServerCommands.RepeatedHumanCode;
ConsoleEx.WriteLine(ServerCommands.RepeatedHumanCode);
}
}
else
{
cmd.Cmd = ServerCommands.LogResultDeny;
}
}
catch (Exception e)
{
ConsoleEx.WriteError(e);
}
return(cmd);
}
private async void Read(Object source, ElapsedEventArgs e)
{
try
{
// _timerRead.Enabled = false;
if (!_isWait && _clientSocket?.Client?.Available > 0)
{
_hearthBitCount = 0;
var data = _sr?.ReadLine();
string dataDescomp = await StringCompressionAsync.DecompressString(data);
try
{
var bt = await SerializerAsync.DeserializeJson <Command>(dataDescomp);
if (bt != null)
{
if (!bt.Cmd.Equals(ServerCommands.HearthBit))
{
//_bufferRead.Enqueue(dataDescomp);
// ConsoleEx.WriteLine("Olha o que eu coloquei aqui: " +dataDescomp);
DelegateAction del;
if (!string.IsNullOrEmpty(bt.Id) &&
_srvsCmdsBuffer.TryGetValue(bt.Id, out del))
{
del.server[0] = dataDescomp;
del.Exec();
}
else if (_srvsCmdsBuffer.TryGetValue(ServerCommands.BroadCastId, out del))
{
del.server[0] = dataDescomp;
del.Exec();
}
}
}
else
{
_bufferRead.Enqueue(dataDescomp);
}
}
catch (Exception ex)
{
ConsoleEx.WriteError("Read", ex);
//Dispose();
}
}
}
catch (Exception exception)
{
ConsoleEx.WriteError("erro do Read:", exception);
//Dispose();
}
finally
{
// _timerRead.Enabled = true;
}
}
