Example #1
0
        public override async Task <Command> GetAll(Command command)
        {
            Command cmd = new Command(command);

            try
            {
                var entities = await MyRepository.Get(null, null, "Endereco");

                var list = entities.ToList();

                if (list.Any())
                {
                    cmd.Cmd = ServerCommands.LogResultOk;
                    var dtos = list.Select(t => t.ConvertDto()).ToList();
                    cmd.Json = await SerializerAsync.SerializeJsonList(dtos);
                }
                else
                {
                    cmd.Cmd = ServerCommands.LogResultDeny;
                }
            }
            catch (Exception e)
            {
                ConsoleEx.WriteError(e);
            }

            return(cmd);
        }
        public static async Task <Command> GetAllStates(Command command)
        {
            Command cmd = new Command(command);

            try
            {
                using (var context = new ZZContext())
                {
                    var rep      = new Repository <Estado>(context);
                    var entities = await rep.Get();

                    var list = entities.ToList();

                    if (list.Any())
                    {
                        cmd.Cmd = ServerCommands.LogResultOk;
                        var dtos = list.Select(t => t.ConvertDto()).ToList();
                        cmd.Json = await SerializerAsync.SerializeJsonList(dtos);
                    }
                    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> UpdateEstados(Command command)
        {
            Command cmd = new Command(command);

            try
            {
                using (var context = new ZZContext())
                {
                    var rep      = new Repository <Estado>(context);
                    var entities = await rep.Get();

                    var list     = entities.ToList();
                    var ibgeList = await SearchEstadoAsync();

                    if (list.Any() && ibgeList.Any())
                    {
                        foreach (var estado in ibgeList)
                        {
                            if (list.Exists(e => e.Ibge == estado.Ibge))
                            {
                                var est = list.Find(e => e.Ibge == estado.Ibge);
                                est.Ibge      = estado.Ibge;
                                est.Descricao = estado.Descricao;
                                est.Sigla     = estado.Sigla;
                            }
                        }
                        await rep.InsertList(list);

                        await rep.Save();

                        cmd.Cmd = ServerCommands.LogResultOk;
                        var dtos = list.Select(t => t.ConvertDto()).ToList();
                        cmd.Json = await SerializerAsync.SerializeJsonList(dtos);
                    }
                    else if (ibgeList.Any())
                    {
                        await rep.InsertList(ibgeList);

                        await rep.Save();

                        cmd.Cmd = ServerCommands.LogResultOk;
                        var dtos = ibgeList.Select(t => t.ConvertDto()).ToList();
                        cmd.Json = await SerializerAsync.SerializeJsonList(dtos);
                    }
                    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 async Task <Command> UpdateCidades(Command command)
        {
            Command cmd = new Command(command);

            try
            {
                using (var context = new ZZContext())
                {
                    var repEstado = new Repository <Estado>(context);
                    var repCity   = new Repository <Cidade>(context);
                    var entities  = await repEstado.Get();

                    var list    = entities.ToList();
                    var cidades = await repCity.Get();

                    var cidadeList = cidades.ToList();

                    if (list.Any() && cidadeList.Any())
                    {
                        foreach (var estado in list)
                        {
                            var ibgeCities = await SearchMunicipioAsync(estado.Ibge, estado.Id);

                            foreach (var city in ibgeCities)
                            {
                                if (cidadeList.Exists(c => c.Ibge == city.Ibge))
                                {
                                    var cidade = list.Find(c => c.Ibge == city.Ibge);
                                    cidade.Ibge      = city.Ibge;
                                    cidade.Descricao = city.Descricao;
                                }
                            }
                        }
                        await repCity.InsertList(cidadeList);

                        await repCity.Save();

                        cmd.Cmd = ServerCommands.LogResultOk;
                        var dtos = cidadeList.Select(t => t.ConvertDto()).ToList();
                        cmd.Json = await SerializerAsync.SerializeJsonList(dtos);
                    }
                    else if (list.Any())
                    {
                        foreach (var estado in list)
                        {
                            var ibgeCities = await SearchMunicipioAsync(estado.Ibge, estado.Id);

                            cidadeList.AddRange(ibgeCities);
                        }
                        await repCity.InsertList(cidadeList);

                        await repCity.Save();

                        cmd.Cmd = ServerCommands.LogResultOk;
                        var dtos = cidadeList.Select(t => t.ConvertDto()).ToList();
                        cmd.Json = await SerializerAsync.SerializeJsonList(dtos);
                    }
                    else
                    {
                        cmd.Cmd = ServerCommands.LogResultDeny;
                    }
                }
            }
            catch (Exception e)
            {
                ConsoleEx.WriteError(e);
            }

            return(cmd);
        }