Пример #1
0
        public async Task <ActionResult> Put(int id, DevedoresEnderecos model)
        {
            if (model.idDevedorEndereco == 0)
            {
                model.idDevedorEndereco = id;
            }
            try
            {
                var devedoresEnderecos = await _repo.GetDevedoresEnderecosId(id);

                if (devedoresEnderecos != null)
                {
                    _repo.Update(model);

                    if (await _repo.SaveChangeAsync())
                    {
                        return(Ok("Devedor Endereco atualizado com sucesso!"));
                    }
                }
            }
            catch (Exception ex)
            {
                return(BadRequest($"Erro: {ex}"));
            }
            return(BadRequest("Devedor Endereco não encontrado!"));
        }
Пример #2
0
        public async Task <IActionResult> Post(DevedoresEnderecos model)
        {
            try
            {
                var devedoresEnderecos = await _repo.GetDevedoresEnderecosCEP(model.CEP);

                if (devedoresEnderecos == null)
                {
                    _repo.Add(model);
                    if (await _repo.SaveChangeAsync())
                    {
                        return(Ok("Devedor Endereco cadastrado com sucesso!"));
                    }
                }
                else
                {
                    return(BadRequest($"Erro: Esse Devedor Endereco já está cadastrado!"));
                }
            }
            catch (Exception ex)
            {
                return(BadRequest($"Erro: {ex}"));
            }
            return(BadRequest("Erro: Não Salvou!!"));
        }
        public async Task <bool> SalvarDevedorEndereco(string webApi, DevedoresEnderecos devedorEndereco)
        {
            try
            {
                string validacao = ValidarSalvar(devedorEndereco);
                if (string.IsNullOrEmpty(validacao))
                {
                    if (devedorEndereco.idDevedorEndereco > 0)
                    {
                        resultado = await PutDevedorEnderecoAsync(webApi, devedorEndereco);

                        return(resultado);
                    }
                    else
                    {
                        resultado = await PostDevedorEnderecoAsync(webApi, devedorEndereco);

                        return(resultado);
                    }
                }
                else
                {
                    resultado = false;
                    throw new ArgumentException(validacao);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        private string ValidarSalvar(DevedoresEnderecos devedorEndereco)
        {
            string validacao = string.Empty;

            if (string.IsNullOrEmpty(devedorEndereco.Endereco))
            {
                validacao += "\r\nInforme o o Endereço!";
            }

            return(validacao);
        }
        private async Task <bool> PutDevedorEnderecoAsync(string webApi, DevedoresEnderecos devedorEndereco)
        {
            using (var client = new HttpClient())
            {
                var serializedDevedorEndereco = JsonConvert.SerializeObject(devedorEndereco);
                var content = new StringContent(serializedDevedorEndereco, Encoding.UTF8, "application/json");
                var result  = await client.PutAsync(webApi + "PutDevedorEndereco/" + devedorEndereco.idDevedorEndereco, content);

                resultado = result.IsSuccessStatusCode;
                return(resultado);
            }
        }
        public async Task <DevedoresEnderecos> GetDevedorEnderecoAsync(string webApi, int idDevedorEndereco)
        {
            try
            {
                HttpClient client   = new HttpClient();
                var        response = await client.GetStringAsync(webApi + "GetDevedorEndereco/" + idDevedorEndereco);

                devedorEndereco = JsonConvert.DeserializeObject <DevedoresEnderecos>(response);
                return(devedorEndereco);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Пример #7
0
        private async void btnImportarArquivo_Click(object sender, EventArgs e)
        {
            if (!string.IsNullOrEmpty(txtCaminhoArquivo.Text))
            {
                if (File.Exists(txtCaminhoArquivo.Text))
                {
                    pbImportacao.Maximum = File.ReadAllLines(txtCaminhoArquivo.Text).Count();
                    pbImportacao.Step    = 1;
                    StreamReader streamArq   = new StreamReader(txtCaminhoArquivo.Text);
                    int          numeroLinha = 1;
                    string       sLine       = string.Empty;
                    string[]     dados;

                    while (sLine != null)
                    {
                        sLine = streamArq.ReadLine();

                        if (sLine != null)
                        {
                            dados = sLine.Split(("\t").ToCharArray());

                            if (numeroLinha > 1)
                            {
                                // Bancos
                                Bancos banco = new Bancos
                                {
                                    Codigo        = Convert.ToInt32(dados[0]),
                                    CodigoInterno = dados[1],
                                    Nome          = dados[2]
                                };
                                await new BancoBLL().SalvarBanco(Program.UrlApi, banco);

                                BancoBLL listabanco = new BancoBLL();
                                await listabanco.GetBancosAsync(Program.UrlApi);

                                int codigoBanco = listabanco.listaBancos.Max(x => x.idBanco);

                                // UFs
                                UFs uf = new UFs
                                {
                                    Descricao = dados[11]
                                };
                                await new UFBLL().SalvarUF(Program.UrlApi, uf);

                                UFBLL listauf = new UFBLL();
                                await listauf.GetUfsAsync(Program.UrlApi);

                                int codigoUf = listauf.listaUfs.Max(x => x.idUf);

                                // Cidades
                                Cidades cidade = new Cidades
                                {
                                    Descricao = dados[11]
                                    ,
                                    UF = codigoUf
                                };
                                await new CidadeBLL().SalvarCidade(Program.UrlApi, cidade);

                                CidadeBLL listacidade = new CidadeBLL();
                                await listacidade.GetCidadesAsync(Program.UrlApi);

                                int codigoCidade = listacidade.listaCidades.Max(x => x.idCidade);

                                // Devedores
                                Devedores devedor = new Devedores
                                {
                                    Nome = dados[5]
                                    ,
                                    CPF_CNPJ = dados[6]
                                };
                                await new DevedorBLL().SalvarDevedor(Program.UrlApi, devedor);

                                DevedorBLL listaDevedor = new DevedorBLL();
                                await listaDevedor.GetDevedoresAsync(Program.UrlApi);

                                int codigoDevedor = listaDevedor.listaDevedores.Max(x => x.idDevedor);

                                // DevedoresEnderecos
                                DevedoresEnderecos devedorendereco = new DevedoresEnderecos
                                {
                                    Devedor = codigoDevedor
                                    ,
                                    Cidade = codigoCidade
                                    ,
                                    Endereco = dados[7]
                                    ,
                                    Bairro = dados[8]
                                    ,
                                    CEP = dados[10]
                                };
                                await new DevedorEnderecoBLL().SalvarDevedorEndereco(Program.UrlApi, devedorendereco);

                                DevedorEnderecoBLL listadevedorendereco = new DevedorEnderecoBLL();
                                await listadevedorendereco.GetDevedoresEnderecosAsync(Program.UrlApi);

                                int codigoDevedorEndereco = listadevedorendereco.listaDevedoresEnderecos.Max(x => x.idDevedorEndereco);

                                // PracasPagamentos
                                PracasPagamentos pracapagamento = new PracasPagamentos
                                {
                                    Cidade = codigoCidade
                                    ,
                                    Descricao = dados[12]
                                };
                                await new PracaPagamentoBLL().SalvarPracaPagamento(Program.UrlApi, pracapagamento);

                                PracaPagamentoBLL listapracapagamento = new PracaPagamentoBLL();
                                await listapracapagamento.GetPracasPagamentosAsync(Program.UrlApi);

                                int codigoPracaPagamento = listapracapagamento.listaPracasPagamentos.Max(x => x.idPracaPagamento);

                                //Contratos
                                Contratos contrato = new Contratos
                                {
                                    PracaPagamento = codigoPracaPagamento,

                                    Banco = codigoBanco
                                    ,
                                    Devedor = codigoDevedor
                                    ,
                                    Numero = dados[3]
                                    ,
                                    QtdParcelas = string.IsNullOrEmpty(dados[21]) ? 0 : Convert.ToInt32(dados[21])
                                    ,
                                    ValorPrimeiraParcela = string.IsNullOrEmpty(dados[20]) ? 0 : Convert.ToDecimal(dados[20])
                                    ,
                                    Valor = string.IsNullOrEmpty(dados[14]) ? 0 : Convert.ToDecimal(dados[14])
                                };
                                await new ContratoBLL().SalvarContrato(Program.UrlApi, contrato);

                                ContratoBLL listacontrato = new ContratoBLL();
                                await listacontrato.GetContratosAsync(Program.UrlApi);

                                int codigoContrato = listacontrato.listaContratos.Max(x => x.idContrato);

                                // ContratosParcelas
                                ContratosParcelas contratoparcela = new ContratosParcelas
                                {
                                    Contrato = codigoContrato
                                    ,
                                    Parcela = Convert.ToInt32(dados[4])
                                };
                                await new ContratoParcelaBLL().SalvarContratoParcela(Program.UrlApi, contratoparcela);

                                ContratoParcelaBLL listacontratoparcela = new ContratoParcelaBLL();
                                await listacontratoparcela.GetContratosParcelasAsync(Program.UrlApi);

                                int codigoContratoParcela = listacontratoparcela.listaContratosParcelas.Max(x => x.idContratoParcela);

                                // Protestos
                                Protestos protesto = new Protestos
                                {
                                    Contrato = codigoContrato
                                    ,
                                    Valor = string.IsNullOrEmpty(dados[15]) ? 0 : Convert.ToDecimal(dados[15])
                                    ,
                                    TipoDocumento = dados[18]
                                    ,
                                    Operacao = dados[19]
                                };

                                if (!string.IsNullOrEmpty(dados[16]))
                                {
                                    protesto.DataEmissao = Convert.ToDateTime(dados[16]);
                                }
                                if (!string.IsNullOrEmpty(dados[17]))
                                {
                                    protesto.Vencimento = Convert.ToDateTime(dados[17]);
                                }
                                ;

                                await new ProtestoBLL().SalvarProtesto(Program.UrlApi, protesto);

                                ProtestoBLL listaprotesto = new ProtestoBLL();
                                await listaprotesto.GetProtestosAsync(Program.UrlApi);

                                int codigoprotesto = listaprotesto.listaProtestos.Max(x => x.idProtesto);
                            }
                        }
                        numeroLinha++;
                        pbImportacao.Value = numeroLinha - 2;
                    }
                    streamArq.Close();
                    MessageBox.Show("Importação realizada com sucesso!");
                }
                else
                {
                    MessageBox.Show("Arquivo não encontrado!");
                }
            }
        }