Пример #1
0
        public ActionResult Index(int id = 0)
        {
            var condicoesPagamento = _condicaoPagamentoFaturaRepositorio.ObterCondicoesPagamento();

            var viewModel = new AnaliseCreditoViewModel
            {
                ContasPesquisa            = new List <Conta>(),
                CondicoesPagamento        = condicoesPagamento,
                PendenciasFinanceiras     = new List <PendenciaFinanceiraDTO>(),
                ResultadoSPC              = new WsSPC.ConsultaSpcResponse(),
                SolicitacoesLimiteCredito = new List <LimiteCreditoSpcDTO>()
            };

            if (id != 0)
            {
                var contaSessao = _contaRepositorio.ObterContaPorId(id);
                Session["ContaId"]         = contaSessao.Id;
                Session["RazaoSocial"]     = contaSessao.Descricao;
                Session["FontePagadoraId"] = contaSessao.Id;
                Session["Cnpj"]            = contaSessao.Documento;
            }


            return(View(viewModel));
        }
Пример #2
0
        public ActionResult ConsultarClienteSpc(int?id)
        {
            try
            {
                var condicoesPagamento = _condicaoPagamentoFaturaRepositorio.ObterCondicoesPagamento();

                ViewBag.Controle = true;

                var viewModel = new AnaliseCreditoViewModel
                {
                    ContasPesquisa            = new List <Conta>(),
                    CondicoesPagamento        = condicoesPagamento,
                    PendenciasFinanceiras     = new List <PendenciaFinanceiraDTO>(),
                    ResultadoSPC              = new WsSPC.ConsultaSpcResponse(),
                    SolicitacoesLimiteCredito = new List <LimiteCreditoSpcDTO>()
                };

                viewModel.ContaPesquisaId = id.Value;

                ActionResult consulta = ConsultarSpc(viewModel);

                return(RedirectToAction("Index", "AnaliseCredito", new { id = id }));
            }
            catch (Exception e)
            {
                return(RedirectToAction(nameof(Index)));
            }
        }
Пример #3
0
        public IActionResult Post([FromBody] AnaliseCreditoViewModel model)
        {
            try
            {
                if (!ModelStateValida())
                {
                    return(Response());
                }

                var resuldadoAnalise = _analiseCreditoAppService.AnalisaCredito(model);

                if (_notifications.HasNotifications())
                {
                    return(Response(_notifications.GetNotifications()));
                }

                var retorno = new
                {
                    Status = resuldadoAnalise.Result.StatusCredito.ToString(),
                    Juros  = resuldadoAnalise.Result.ValorJuros,
                    Total  = resuldadoAnalise.Result.ValorToTal
                };

                return(Response(retorno));
            }
            catch (System.Exception ex)
            {
                return(Response(ex));
            }
        }
Пример #4
0
        public Task <ResultadoAnaliseViewModel> AnalisaCredito(AnaliseCreditoViewModel analiseCreditoViewModel)
        {
            var dadosAnaliseCredito = _mapper.Map <AnaliseCreditoRequest>(analiseCreditoViewModel);
            var resultadoAnalise    = _analiseCreditoService.AnalisaCredito(dadosAnaliseCredito);

            if (resultadoAnalise == null)
            {
                return(null);
            }

            var resultado = _mapper.Map <ResultadoAnaliseViewModel>(resultadoAnalise.Result);

            return(Task.FromResult(resultado));
        }
Пример #5
0
        public ActionResult ExcluirLimiteCredito(int id, [Bind(Include = "ContaPesquisaId")] AnaliseCreditoViewModel viewModel)
        {
            if (id == 0)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Nenhum Registro Selecionado"));
            }

            var solicitacaoBusca = _analiseCreditoRepositorio.ObterLimiteDeCreditoPorIdUnico(id);

            if (solicitacaoBusca == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Registro não encontrado"));
            }

            _analiseCreditoRepositorio.ExcluirLimiteDeCredito(id);

            return(Json(solicitacaoBusca, JsonRequestBehavior.AllowGet));
        }
Пример #6
0
        public ActionResult CadastrarLimiteCredito([Bind(Include = "ContaPesquisaId, Reprocessar, CondicaoPagamentoId, LimiteCredito, Observacao")] AnaliseCreditoViewModel viewModel)
        {
            if (viewModel.ContaPesquisaId == 0)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Nenhuma Conta Selecionada"));
            }

            if (string.IsNullOrEmpty(viewModel.CondicaoPagamentoId))
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Condição Pagamento não selecionada"));
            }

            if (viewModel.LimiteCredito == 0)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Limite de Crédito inválido"));
            }
            var resultadocond = _analiseCreditoRepositorio
                                .ObterSolicitacoesLimiteDeCreditoCond(viewModel.ContaPesquisaId, viewModel.CondicaoPagamentoId);

            if (resultadocond > 0)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Condição Pagamento já foi registrada"));
            }

            _analiseCreditoRepositorio.SolicitarLimiteDeCredito(
                new LimiteCreditoSpcDTO
            {
                ContaId             = viewModel.ContaPesquisaId,
                CondicaoPagamentoId = viewModel.CondicaoPagamentoId,
                LimiteCredito       = viewModel.LimiteCredito,
                Observacoes         = viewModel.Observacao,
                StatusLimiteCredito = StatusLimiteCredito.PENDENTE
            });

            var resultado = _analiseCreditoRepositorio
                            .ObterSolicitacoesLimiteDeCredito(viewModel.ContaPesquisaId);

            return(PartialView("_SolicitacoesLimiteCredito", resultado));
        }
Пример #7
0
        public ActionResult EnviarParaAprovacao(int processoId, Processo processo, [Bind(Include = "ContaPesquisaId")] AnaliseCreditoViewModel viewModel)
        {
            try
            {
                var contaSessao = _contaRepositorio.ObterContaPorId(viewModel.ContaPesquisaId);
                //string cnpj = razaoSocial.Substring(tamanho - 19, 18).Replace(")", "");
                ////achei
                //
                Session["ContaId"]         = contaSessao.Id;
                Session["RazaoSocial"]     = contaSessao.Descricao;
                Session["FontePagadoraId"] = contaSessao.Id;
                Session["Cnpj"]            = contaSessao.Documento;
                dynamic campos = null;

                var contaEspecifica = _contaRepositorio.ObterContaPorId(viewModel.ContaPesquisaId);

                var analiseCreditoBusca = _analiseCreditoRepositorio.ObterConsultaSpc(processoId);

                if (processo == Processo.ANALISE_DE_CREDITO)
                {
                    if (analiseCreditoBusca == null)
                    {
                        return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Consulta SPC não localizada!"));
                    }
                    if (analiseCreditoBusca.StatusAnaliseDeCredito == Ecoporto.CRM.Business.Enums.StatusAnaliseDeCredito.APROVADO)
                    {
                        return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Análise de Crédito dentro do prazo de Validade e está Aprovado!"));
                    }
                    if (analiseCreditoBusca.StatusAnaliseDeCredito == Ecoporto.CRM.Business.Enums.StatusAnaliseDeCredito.REJEITADO)
                    {
                        return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Análise de Crédito dentro do prazo de Validade e está Rejeitada!"));
                    }
                    if ((analiseCreditoBusca.InadimplenteSpc == false) && (analiseCreditoBusca.InadimplenteEcoporto == false))
                    {
                        return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Conta não precisa de Aprovação !"));
                    }
                    if (string.IsNullOrEmpty(analiseCreditoBusca.CondicaoPagamento))
                    {
                        return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Conta sem condição de Pagamento !"));
                    }

                    var contaBusca = _contaRepositorio.ObterContaPorIdAnalise(analiseCreditoBusca.ContaId);

                    if (contaBusca == null)
                    {
                        return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Conta não localizada!"));
                    }

                    var aprovacoes = _workflowRepositorio.ObterAprovacoesAnaliseDeCredito(analiseCreditoBusca.ContaId);

                    if (aprovacoes.Any() && analiseCreditoBusca.StatusAnaliseDeCredito == StatusAnaliseDeCredito.EM_APROVACAO)
                    {
                        return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Já existe uma aprovação pendente para esta Oportunidade"));
                    }


                    var limiteCreditoCondPgto = _analiseCreditoRepositorio.ObterLimiteDeCreditoPorId(analiseCreditoBusca.ContaId);

                    if (limiteCreditoCondPgto != null)
                    {
                        if (limiteCreditoCondPgto.StatusLimiteCredito == StatusLimiteCredito.PENDENTE)
                        {
                            _analiseCreditoRepositorio.AtualizarlimiteDeCredito(limiteCreditoCondPgto.Id);
                            //EnviarParaAprovacaocond(limiteCreditoCondPgto.Id);
                        }
                    }
                    campos = new
                    {
                        //ContaId = contaBusca.Descricao +" - "+ contaBusca.Documento,
                        ContaId = contaBusca.Id,
                        StatusAnaliseCreditoPEFIN = StatusAnaliseDeCredito.EM_APROVACAO.ToName().Replace("Ã", "A").Replace("ã", "a").Replace("ç", "c").Replace("Ç", "C"),
                        InadimplenteEcoporto      = analiseCreditoBusca.InadimplenteEcoporto.ToSimOuNao().Replace("Ã", "A").Replace("ã", "a").Replace("ç", "c").Replace("Ç", "C"),
                        InadimplenteSPC           = analiseCreditoBusca.InadimplenteSpc.ToSimOuNao().Replace("Ã", "A").Replace("ã", "a").Replace("ç", "c").Replace("Ç", "C"),
                        DividaSPC      = analiseCreditoBusca.TotalDividaSpc,
                        DividaEcoporto = analiseCreditoBusca.TotalDividaEcoporto,
                        CondicaoPagamentoFaturamentoId = analiseCreditoBusca.CondicaoPagamentoDescricao,
                        analiseCreditoBusca.LimiteCredito,
                        Observacao = analiseCreditoBusca.Observacoes,
                        Descricao  = "A - " + analiseCreditoBusca.Id
                    };
                }


                if (processo == Processo.ANALISE_DE_CREDITO_COND_PGTO)
                {
                    var limiteCreditoCondPgtoBusca = _analiseCreditoRepositorio.VerificarLimiteDeCreditoPorId(processoId, viewModel.ContaPesquisaId);

                    if (limiteCreditoCondPgtoBusca == null)
                    {
                        return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Conta não localizada!"));
                    }
                    if (limiteCreditoCondPgtoBusca.StatusLimiteCredito == StatusLimiteCredito.APROVADO)
                    {
                        return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Não precisa de Aprovação !"));
                    }

                    var contaBusca = _contaRepositorio.ObterContaPorIdAnalise(limiteCreditoCondPgtoBusca.ContaId);

                    if (contaBusca == null)
                    {
                        return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Conta não localizada!"));
                    }
                    var aprovacoes = _workflowRepositorio.ObterAprovacoesLimiteDeCredito(processoId);

                    if (aprovacoes.Any() && limiteCreditoCondPgtoBusca.StatusLimiteCredito == StatusLimiteCredito.EM_APROVACAO)
                    {
                        return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Já existe uma aprovação pendente para esta Oportunidade"));
                    }

                    campos = new
                    {
                        CondicaoPagamentoFaturamentoId = limiteCreditoCondPgtoBusca.CondicaoPagamentoDescricao,
                        ContaId = contaBusca.Descricao + " - " + contaBusca.Documento,
                        InadimplenteEcoporto = limiteCreditoCondPgtoBusca.InadimplenteEcoporto.ToSimOuNao().Replace("Ã", "A").Replace("ã", "a").Replace("ç", "c").Replace("Ç", "C"),
                        DividaEcoporto       = limiteCreditoCondPgtoBusca.TotalDividaEcoporto,
                        StatusCondPagto      = StatusLimiteCredito.EM_APROVACAO.ToName().Replace("Ã", "A").Replace("ã", "a").Replace("ç", "c").Replace("Ç", "C"),
                        limiteCreditoCondPgtoBusca.LimiteCredito,
                        Observacao = limiteCreditoCondPgtoBusca.Observacoes,
                        Descricao  = "P - " + limiteCreditoCondPgtoBusca.Id
                    };
                }

                var token = Autenticador.Autenticar();

                if (token == null)
                {
                    return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Não foi possível se autenticar no serviço de Workflow"));
                }

                var workflow = new WorkflowService(token);

                var retornoWorkflow = workflow.EnviarParaAprovacao(
                    new CadastroWorkflow(
                        processo,
                        1,
                        processoId,
                        User.ObterLogin(),
                        User.ObterNome(),
                        User.ObterEmail(),
                        JsonConvert.SerializeObject(campos)));

                if (retornoWorkflow == null)
                {
                    return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Nenhuma resposta do serviço de Workflow"));
                }

                if (retornoWorkflow.sucesso == false)
                {
                    return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, retornoWorkflow.mensagem));
                }
                if (processo == Processo.ANALISE_DE_CREDITO)
                {
                    _analiseCreditoRepositorio.AtualizarSPC(processoId);
                }

                if (processo == Processo.ANALISE_DE_CREDITO_COND_PGTO)
                {
                    _analiseCreditoRepositorio.AtualizarlimiteDeCredito(processoId);
                }
                var workFlowId = _workflowRepositorio.IncluirEnvioAprovacao(
                    new EnvioWorkflow(
                        processoId,
                        processo,
                        retornoWorkflow.protocolo,
                        retornoWorkflow.mensagem,
                        User.ObterId()));

                var resultado = _analiseCreditoRepositorio
                                .ObterSolicitacoesLimiteDeCredito(viewModel.ContaPesquisaId);

                return(PartialView("_SolicitacoesLimiteCredito", resultado));
                //return new HttpStatusCodeResult(HttpStatusCode.NoContent);
            }
            catch (Exception ex)
            {
                throw new Exception(ex.ToString());
            }
        }
Пример #8
0
        public ActionResult ConsultarSpc([Bind(Include = "ContaPesquisaId, Reprocessar, CondicaoPagamentoId, LimiteCredito, Observacao")] AnaliseCreditoViewModel viewModel)
        {
            WsSPC.ConsultaSpcResponse consultaSpc = new WsSPC.ConsultaSpcResponse();

            // _analiseCreditoRepositorio.GravarBlackList();

            var contaBusca = _contaRepositorio.ObterContaPorIdAnalise(viewModel.ContaPesquisaId);

            ContaId = viewModel.ContaPesquisaId;
            var consultaspcnew = 0;

            if (contaBusca == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Cliente não encontrado"));
            }

            if (contaBusca.Blacklist == true)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Cliente não tem permissão para consultar SPC"));
            }

            string tipoPessoa = contaBusca.ClassificacaoFiscal == ClassificacaoFiscal.PF
                   ? "F"
                   : "J";

            string hash = "d41d8cd98f00b204e9800998ecf8427e";

            var analiseCreditoBusca = _analiseCreditoRepositorio.ObterConsultaSpc(contaBusca.Id);

            if (viewModel.Reprocessar == false)
            {
                if (analiseCreditoBusca == null)
                {
                    // pesquisa no web service
                    consultaspcnew = 1;
                    consultaSpc    = _wsSPC.ConsultarSPC(
                        tipoPessoa,
                        contaBusca.Documento.RemoverCaracteresEspeciaisDocumento(),
                        User.ObterId().ToString(),
                        hash);
                }
                else
                {
                    if (!ConsultaVigente(contaBusca, analiseCreditoBusca))
                    {
                        // pesquisa no web service
                        consultaspcnew = 1;
                        consultaSpc    = _wsSPC.ConsultarSPC(
                            tipoPessoa,
                            contaBusca.Documento.RemoverCaracteresEspeciaisDocumento(),
                            User.ObterId().ToString(),
                            hash);
                    }
                    else
                    {
                        // pesquisa no banco
                        consultaSpc = _wsSPC.ConsultarBancoDeDados(contaBusca.Id.ToString(), hash);
                    }
                }
            }
            else
            {
                // sempre pesquisa no web service
                consultaspcnew = 1;
                consultaSpc    = _wsSPC.ConsultarSPC(
                    tipoPessoa,
                    contaBusca.Documento.RemoverCaracteresEspeciaisDocumento(),
                    User.ObterId().ToString(),
                    hash);
            }

            viewModel.ResultadoSPC = consultaSpc;
            if (consultaspcnew == 1)
            {
                var resultadofat = _analiseCreditoRepositorio.GravarPendenciasFinanceiras(contaBusca.Documento.RemoverCaracteresEspeciaisDocumento());
            }

            return(PartialView("_ResultadoSpc", viewModel));
        }