Ejemplo n.º 1
0
 public UsuariosController(Contexto db, Autenticador tiaIdentity, Email email, GeradorDeListas geradorDeListas)
 {
     this.db              = db;
     this.tiaIdentity     = tiaIdentity;
     this.email           = email;
     this.geradorDeListas = geradorDeListas;
 }
Ejemplo n.º 2
0
        //recallfichafaturamento
        public ActionResult RecallFichaFaturamento(int recallFichasOportunidadeId, int recallFichasId, string motivoRecallFichas)
        {
            var oportunidadeBusca = _oportunidadeRepositorio.ObterOportunidadePorId(recallFichasOportunidadeId);

            if (oportunidadeBusca == null)
            {
                throw new Exception("Oportunidade não encontrada ou já excluída");
            }

            var fichaBusca = _oportunidadeRepositorio.ObterFichaFaturamentoPorId(recallFichasId);

            if (fichaBusca == null)
            {
                throw new Exception("Ficha Faturamento não encontrada ou já excluída");
            }

            if (!User.IsInRole("OportunidadesFichas:RecallFichaFaturamento"))
            {
                if (!_equipesService.ValidarEquipeOportunidade(oportunidadeBusca.Id))
                {
                    return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Usuário não possui permissão para edição da Oportunidade (Equipes)"));
                }
            }

            var token = Autenticador.Autenticar();

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

            var ultimoProtocolo = _workflowRepositorio.UltimoProtocolo(oportunidadeBusca.Id, Processo.FICHA_FATURAMENTO, fichaBusca.Id);

            var workflow = new RecallService(token);

            var retorno = workflow.Recall(new CadastroRecall(ultimoProtocolo, User.ObterLogin(), User.ObterNome(), User.ObterEmail(), motivoRecallFichas));

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

            if (retorno.sucesso)
            {
                if (fichaBusca.StatusFichaFaturamento == StatusFichaFaturamento.EM_APROVACAO)
                {
                    _oportunidadeRepositorio.AtualizarStatusFichaFaturamento(StatusFichaFaturamento.EM_ANDAMENTO, fichaBusca.Id);
                }

                return(Json(new
                {
                    Processo = Processo.FICHA_FATURAMENTO,
                    RedirectUrl = $"/Oportunidades/Atualizar/{oportunidadeBusca.Id}"
                }, JsonRequestBehavior.AllowGet));
            }

            return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, retorno.mensagem));
        }
Ejemplo n.º 3
0
        public ActionResult ObterHistoricoWorkflow(int contaId)
        {
            var token = Autenticador.Autenticar();

            int ProcessoId = 0;

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

            var analiseCreditoBusca = _analiseCreditoRepositorio.ObterConsultaSpc(contaId);

            var listaProcessoId = _analiseCreditoRepositorio.ObterListaProcessoId(contaId);


            if (analiseCreditoBusca != null)
            {
                var workflow = new RetornoHistoricoWorkflow();

                //int[] processo = new int[2] { 13, 14 };
                var workflow_ = new WorkflowService(token)
                                .ObterHistoricoWorkflow(contaId, 13, 1);
                if (workflow_ != null)
                {
                    workflow.list.AddRange(workflow_.list);
                }

                workflow_ = null;
                foreach (int processoId in listaProcessoId)
                {
                    workflow_ = new WorkflowService(token)
                                .ObterHistoricoWorkflow(processoId, 14, 1);
                    if (workflow_ != null)
                    {
                        workflow.list.AddRange(workflow_.list);
                    }

                    workflow_ = null;
                }

                if (workflow != null)
                {
                    var WorkFlowss = workflow
                                     .list.SelectMany(c => c.workFlows).ToList();


                    return(PartialView("_ConsultaHistoricoWorkflow", new HistoricoWorkflowViewModel
                    {
                        WorkFlows = workflow
                                    .list.SelectMany(c => c.workFlows).ToList()
                    }));
                }
            }

            return(null);
        }
Ejemplo n.º 4
0
        public ActionResult RecallLimiteCredito(int recallLimiteId, string motivoRecallLimite)
        {
            var solicitacaoBusca = _analiseCreditoRepositorio.ObterLimiteDeCreditoPorIdUnico(recallLimiteId);


            if (solicitacaoBusca == null)
            {
                throw new Exception("Solicitação não encontrada ou já excluída");
            }

            if (!User.IsInRole("OportunidadesFichas:RecallFichaFaturamento"))
            {
                if (!_equipesService.ValidarEquipeOportunidade(solicitacaoBusca.Id))
                {
                    return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Usuário não possui permissão para edição da Solicitacao (Equipes)"));
                }
            }

            var token = Autenticador.Autenticar();

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

            var ultimoProtocolo = _workflowRepositorio.UltimoProtocolo(solicitacaoBusca.Id, Processo.ANALISE_DE_CREDITO_COND_PGTO);


            var workflow = new RecallService(token);

            var retorno = workflow.Recall(new CadastroRecall(ultimoProtocolo, User.ObterLogin(), User.ObterNome(), User.ObterEmail(), motivoRecallLimite));

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

            if (retorno.sucesso)
            {
                if (solicitacaoBusca.StatusLimiteCredito == StatusLimiteCredito.EM_APROVACAO)
                {
                    _analiseCreditoRepositorio.AtualizarlimiteDeCreditoPendente(recallLimiteId);
                }

                //var resultado = _analiseCreditoRepositorio
                //.ObterSolicitacoesLimiteDeCredito(solicitacaoBusca.ContaId);

                //return PartialView("_SolicitacoesLimiteCredito", resultado);
                return(Json(new
                {
                    Processo = Processo.ANALISE_DE_CREDITO_COND_PGTO,
                    RedirectUrl = $"/AnaliseCredito/Index/{solicitacaoBusca.Id}"
                }, JsonRequestBehavior.AllowGet));
            }

            return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, retorno.mensagem));
        }
Ejemplo n.º 5
0
        public ActionResult RecallPremioParceria(int recallPremiosOportunidadeId, int recallPremioId, string motivoRecallPremios)
        {
            var oportunidadeBusca = _oportunidadeRepositorio.ObterOportunidadePorId(recallPremiosOportunidadeId);

            if (oportunidadeBusca == null)
            {
                throw new Exception("Oportunidade não encontrada ou já excluída");
            }

            var premioBusca = _premioParceriaRepositorio.ObterPremioParceriaPorId(recallPremioId);

            if (premioBusca == null)
            {
                throw new Exception("Prêmio Parceria não encontrado ou já excluído");
            }

            var token = Autenticador.Autenticar();

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

            var ultimoProtocolo = _workflowRepositorio.UltimoProtocolo(oportunidadeBusca.Id, Processo.PREMIO_PARCERIA);

            var workflow = new RecallService(token);

            var retorno = workflow.Recall(new CadastroRecall(ultimoProtocolo, User.ObterLogin(), User.ObterNome(), User.ObterEmail(), motivoRecallPremios));

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

            if (retorno.sucesso)
            {
                if (premioBusca.Cancelado)
                {
                    _premioParceriaRepositorio.AtualizarStatusPremioParceria(StatusPremioParceria.CADASTRADO, oportunidadeBusca.Id);
                    _premioParceriaRepositorio.AtualizarCancelamento(false);
                }

                if (premioBusca.StatusPremioParceria == StatusPremioParceria.EM_APROVACAO)
                {
                    _premioParceriaRepositorio.AtualizarStatusPremioParceria(StatusPremioParceria.EM_ANDAMENTO, premioBusca.Id);
                }

                return(Json(new
                {
                    Processo = Processo.PREMIO_PARCERIA,
                    RedirectUrl = $"/Oportunidades/Atualizar/{oportunidadeBusca.Id}"
                }, JsonRequestBehavior.AllowGet));
            }

            return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, retorno.mensagem));
        }
Ejemplo n.º 6
0
 /// MÉTODO PARA BUSCA E AUTENTICAÇÃO DE USUÁRIOS
 /// <summary>
 /// Compara o usuário-objeto-instanciado com o banco de dados SQL, retornando a (não) autenticação do mesmo.
 /// </summary>
 /// <param name="login"></param>
 /// <returns>Usuário (não) autenticado</returns>
 public Usuario AutenticarPorBusca(Autenticador login)
 {
     using (OpflixContext ctx = new OpflixContext())
     {
         Usuario usuarioInspecionado = ctx.Usuario.FirstOrDefault(x => x.Email == login.Email && x.Senha == login.Senha);
         if (usuarioInspecionado == null)
         {
             return(null);
         }
         return(usuarioInspecionado);
     }
 }
Ejemplo n.º 7
0
        public ActionResult LoginAdmin(Administrador admin)
        {
            validBasic(admin.Dni, admin.Pass, admin);

            if (ModelState.IsValid)
            {
                Autenticador.Login(admin.Dni, false);

                return(RedirectToAction("Productos", "Producto"));
            }
            return(View(admin));
        }
Ejemplo n.º 8
0
        public ActionResult LoginVend(Vendedor vend)
        {
            validBasic(vend.Dni, vend.Pass, vend);

            if (ModelState.IsValid)
            {
                Autenticador.Login(vend.Dni, false);
                return(RedirectToAction("Reportes", "Reporte"));
            }

            return(View(vend));
        }
Ejemplo n.º 9
0
 public bool cambioTerreno() //pasa del terreno 1 al plan b
 {
     if (validador == false && estadoTerreno == totalTerreno)
     {
         Autenticador a1 = null;
         validador = a1.autentica();
     }
     else
     {
         Console.WriteLine("El terreno principal no se enucentra totalmente lleno o planB ya está en ejecución.");
     }
     return(validador);
 }
Ejemplo n.º 10
0
        public IActionResult Autenticar(Autenticador autenticador)
        {
            try
            {
                Usuario usuario = usuarioRepositorio.AutenticarPorBusca(autenticador);
                if (usuario == null)
                {
                    return(NotFound(new { mensagem = "A inspeção do usuário não fora efetivada com sucesso; depure as possíveis falhas de inscrição. " }));
                }

                var claims = new[] {
                    new Claim(JwtRegisteredClaimNames.Email, usuario.Email),
                    new Claim(JwtRegisteredClaimNames.Jti, usuario.IdUsuario.ToString()),
                    new Claim(ClaimTypes.Role, usuario.IdTipoUsuario.ToString())
                };

                var key = new SymmetricSecurityKey(System.Text.Encoding.UTF8.GetBytes("opflix-chave-autenticacao"));

                var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);

                var token = new JwtSecurityToken(
                    issuer: "Opflix.WebApi",
                    audience: "Opflix.WebApi",
                    claims: claims,
                    expires: DateTime.Now.AddMinutes(30),
                    signingCredentials: creds);

                return(Ok(new
                {
                    token = new JwtSecurityTokenHandler().WriteToken(token)
                }));
            } catch (Exception ex)
            {
                return(BadRequest(new
                {
                    Mensagem = "A autenticação não fora efetivada com sucesso; depure a existência de um mesmo item para a consignação inequívoca. " + ex.Message
                }));
            }
        }
Ejemplo n.º 11
0
        public void EnviarPremioParceriaParaAprovacao(int id)
        {
            var premioParceriaBusca = _premioParceriaRepositorio.ObterPremioParceriaPorId(id);

            if (premioParceriaBusca == null)
            {
                _logger.Info($"Prêmio Parceria {premioParceriaBusca.Id} não encontrado");
            }

            var oportunidadeBusca = _oportunidadeRepositorio.ObterOportunidadePorId(premioParceriaBusca.OportunidadeId);

            if (oportunidadeBusca == null)
            {
                _logger.Info($"Oportunidade {oportunidadeBusca.Id} não encontrada");
            }

            var aprovacoes = _workflowRepositorio.ObterAprovacoesPorOportunidade(oportunidadeBusca.Id, Processo.PREMIO_PARCERIA);

            if (aprovacoes.Any() && premioParceriaBusca.StatusPremioParceria == StatusPremioParceria.EM_APROVACAO)
            {
                _logger.Info($"Já existe uma aprovação pendente para este Prêmio Parceria {premioParceriaBusca.Id}");
            }

            var token = Autenticador.Autenticar();

            if (token == null)
            {
                _logger.Info("Não foi possível se autenticar no serviço de Workflow");
            }

            var workflow = new WorkflowService(token);

            var premioDetalhes = _premioParceriaRepositorio.ObterDetalhesPremioParceria(premioParceriaBusca.Id);

            var campos = new
            {
                Descricao             = $"P-{premioDetalhes.Id}",
                DescricaoOportunidade = oportunidadeBusca.Descricao,
                ContaDescricao        = oportunidadeBusca.Conta.Descricao,
                premioDetalhes.OportunidadeId,
                ContatoId                 = premioDetalhes.DescricaoContato,
                StatusPremioParceria      = premioDetalhes.DescricaoStatusPremioParceria,
                Instrucao                 = premioDetalhes.DescricaoInstrucao,
                TipoServicoPremioParceria = premioDetalhes.DescricaoServicoPremioParceria,
                Favorecido1               = premioDetalhes.DescricaoFavorecido1,
                Favorecido2               = premioDetalhes.DescricaoFavorecido2,
                Favorecido3               = premioDetalhes.DescricaoFavorecido3,
                PremioReferenciaId        = $"P-{premioDetalhes.PremioReferenciaId}",
                premioDetalhes.Observacoes,
                premioDetalhes.Anexo,
                premioDetalhes.UrlPremio,
                DataUrlPremio = premioDetalhes.DataUrlPremio.DataFormatada(),
                premioDetalhes.EmailFavorecido1,
                premioDetalhes.EmailFavorecido2,
                premioDetalhes.EmailFavorecido3,
                premioDetalhes.CriadoPor,
                TipoOperacao = premioDetalhes.DescricaoTipoOperacao
            };

            var retorno = workflow.EnviarParaAprovacao(
                new CadastroWorkflow(Processo.PREMIO_PARCERIA, 1, premioParceriaBusca.Id, User.ObterLogin(), User.ObterNome(), User.ObterEmail(), JsonConvert.SerializeObject(campos)));

            if (retorno == null)
            {
                throw new Exception("Nenhuma resposta do serviço de Workflow");
            }

            if (retorno.sucesso == false)
            {
                _logger.Info(retorno.mensagem);
            }

            _workflowRepositorio.IncluirEnvioAprovacao(new EnvioWorkflow(oportunidadeBusca.Id, Processo.PREMIO_PARCERIA, retorno.protocolo, retorno.mensagem, User.ObterId()));

            _premioParceriaRepositorio.AtualizarStatusPremioParceria(StatusPremioParceria.EM_APROVACAO, premioParceriaBusca.Id);

            _logger.Info($"Prêmio Parceria {premioParceriaBusca.Id} enviado para Aprovação");
        }
Ejemplo n.º 12
0
        public void EnviarFichaFaturamentoParaAprovacao(int id)
        {
            var fichaFaturamentoBusca = _oportunidadeRepositorio.ObterFichaFaturamentoPorId(id);

            if (fichaFaturamentoBusca == null)
            {
                _logger.Info($"Ficha Faturamento {fichaFaturamentoBusca.Id} não encontrada");
            }

            var oportunidadeBusca = _oportunidadeRepositorio.ObterOportunidadePorId(fichaFaturamentoBusca.OportunidadeId);

            if (oportunidadeBusca == null)
            {
                _logger.Info($"Oportunidade {oportunidadeBusca.Id} não encontrada");
            }

            var aprovacoes = _workflowRepositorio.ObterAprovacoesPorOportunidade(oportunidadeBusca.Id, Processo.FICHA_FATURAMENTO);

            if (aprovacoes.Any() && fichaFaturamentoBusca.StatusFichaFaturamento == StatusFichaFaturamento.EM_APROVACAO)
            {
                _logger.Info($"Já existe uma aprovação pendente para esta Ficha de Faturamento {fichaFaturamentoBusca.Id}");
            }

            var token = Autenticador.Autenticar();

            if (token == null)
            {
                _logger.Info("Não foi possível se autenticar no serviço de Workflow");
            }

            var workflow = new WorkflowService(token);

            var conta = _contaRepositorio.ObterContaPorId(oportunidadeBusca.ContaId);

            CondicaoPagamentoFatura condicaoPagamentoFatura = null;

            if (fichaFaturamentoBusca.CondicaoPagamentoFaturamentoId != null)
            {
                condicaoPagamentoFatura = _condicaoPagamentoFaturaRepositorio.ObterCondicoPagamentoPorId(fichaFaturamentoBusca.CondicaoPagamentoFaturamentoId);
            }

            var oportunidadeDetalhes = _oportunidadeRepositorio.ObterDetalhesOportunidade(oportunidadeBusca.Id);

            var campos = new
            {
                OportunidadeId                 = oportunidadeBusca.Id,
                Descricao                      = $"F-{fichaFaturamentoBusca.Id}",
                DescricaoOportunidade          = oportunidadeBusca.Descricao,
                StatusFichaFaturamento         = fichaFaturamentoBusca.StatusFichaFaturamento.ToName(),
                CondicaoPagamentoFaturamentoId = condicaoPagamentoFatura?.Descricao,
                ContaId     = oportunidadeDetalhes.Conta,
                DataInicio  = oportunidadeDetalhes.DataInicio.DataFormatada(),
                DataTermino = oportunidadeDetalhes.DataTermino.DataFormatada(),
                oportunidadeDetalhes.TabelaId,
                fichaFaturamentoBusca.FaturadoContraId,
                fichaFaturamentoBusca.DiasSemana,
                fichaFaturamentoBusca.DiasFaturamento,
                fichaFaturamentoBusca.DataCorte,
                fichaFaturamentoBusca.EmailFaturamento,
                fichaFaturamentoBusca.ObservacoesFaturamento,
                fichaFaturamentoBusca.AnexoFaturamento,
                oportunidadeDetalhes.TipoOperacao
            };

            var retorno = workflow.EnviarParaAprovacao(
                new CadastroWorkflow(Processo.FICHA_FATURAMENTO, 1, fichaFaturamentoBusca.Id, User.ObterLogin(), User.ObterNome(), User.ObterEmail(), JsonConvert.SerializeObject(campos)));

            if (retorno == null)
            {
                throw new Exception("Nenhuma resposta do serviço de Workflow");
            }

            if (retorno.sucesso == false)
            {
                _logger.Info(retorno.mensagem);
            }

            _workflowRepositorio.IncluirEnvioAprovacao(new EnvioWorkflow(oportunidadeBusca.Id, Processo.FICHA_FATURAMENTO, retorno.protocolo, retorno.mensagem, User.ObterId()));

            _oportunidadeRepositorio.AtualizarStatusFichaFaturamento(StatusFichaFaturamento.EM_APROVACAO, fichaFaturamentoBusca.Id);

            _logger.Info($"Ficha de Faturamento {fichaFaturamentoBusca.Id} enviada para Aprovação");
        }
Ejemplo n.º 13
0
        public void EnviarOportunidadeParaAprovacao(int id, string criadoPor)
        {
            var oportunidadeBusca = _oportunidadeRepositorio.ObterOportunidadePorId(id);

            if (oportunidadeBusca == null)
            {
                _logger.Info($"Oportunidade {oportunidadeBusca.Id} não encontrada");
            }

            var token = Autenticador.Autenticar();

            if (token == null)
            {
                _logger.Info("Não foi possível se autenticar no serviço de Workflow");
            }

            var workflow = new WorkflowService(token);

            var oportunidadeDetalhes = _oportunidadeRepositorio.ObterDetalhesOportunidade(id);

            var usuario = _usuarioRepositorio.ObterUsuarioPorId(criadoPor.ToInt());

            var campos = new
            {
                oportunidadeId = oportunidadeDetalhes.Id,
                oportunidadeDetalhes.Descricao,
                oportunidadeDetalhes.Identificacao,
                ContaId      = oportunidadeDetalhes.Conta,
                ContatoId    = oportunidadeDetalhes.Contato,
                MercadoriaId = oportunidadeDetalhes.Mercadoria,
                oportunidadeDetalhes.Aprovada,
                oportunidadeDetalhes.DataFechamento,
                oportunidadeDetalhes.TabelaId,
                oportunidadeDetalhes.Probabilidade,
                oportunidadeDetalhes.SucessoNegociacao,
                oportunidadeDetalhes.ClassificacaoCliente,
                oportunidadeDetalhes.Segmento,
                oportunidadeDetalhes.EstagioNegociacao,
                oportunidadeDetalhes.StatusOportunidade,
                oportunidadeDetalhes.MotivoPerda,
                oportunidadeDetalhes.TipoDeProposta,
                oportunidadeDetalhes.TipoServico,
                oportunidadeDetalhes.TipoNegocio,
                oportunidadeDetalhes.TipoOperacaoOportunidade,
                oportunidadeDetalhes.RevisaoId,
                oportunidadeDetalhes.Observacao,
                oportunidadeDetalhes.FaturamentoMensalLCL,
                oportunidadeDetalhes.FaturamentoMensalFCL,
                oportunidadeDetalhes.VolumeMensal,
                oportunidadeDetalhes.CIFMedio,
                oportunidadeDetalhes.PremioParceria,
                CriadoPor = usuario.Login,
                oportunidadeDetalhes.TipoOperacao,
                oportunidadeDetalhes.Vendedor,
                oportunidadeDetalhes.FormaPagamento,
                DataInicio  = oportunidadeDetalhes.DataInicio.DataFormatada(),
                DataTermino = oportunidadeDetalhes.DataTermino.DataFormatada()
            };

            var retorno = workflow.EnviarParaAprovacao(
                new CadastroWorkflow(Processo.OPORTUNIDADE, 1, oportunidadeBusca.Id, usuario.Login, usuario.Nome, usuario.Email, JsonConvert.SerializeObject(campos)));

            if (retorno == null)
            {
                throw new Exception("Nenhuma resposta do serviço de Workflow");
            }

            if (retorno.sucesso == false)
            {
                _logger.Info(retorno.mensagem);
            }

            var oportunidadeWorkflow = new EnvioWorkflow(oportunidadeBusca.Id, Processo.OPORTUNIDADE, retorno.protocolo, retorno.mensagem, usuario.Id);

            _workflowRepositorio.IncluirEnvioAprovacao(oportunidadeWorkflow);

            if (oportunidadeBusca.StatusOportunidade != StatusOportunidade.CANCELADA)
            {
                oportunidadeBusca.StatusOportunidade = StatusOportunidade.ENVIADO_PARA_APROVACAO;
            }

            _oportunidadeRepositorio.AtualizarStatusOportunidade(oportunidadeBusca.StatusOportunidade, oportunidadeBusca.Id);
        }
Ejemplo n.º 14
0
        public ActionResult LogOut()
        {
            Autenticador.LogOut();

            return(RedirectToAction("LoginAdmin", "Home"));
        }
Ejemplo n.º 15
0
        public ActionResult RecallOportunidade(int recallOportunidadeId, string motivoRecallOportunidade)
        {
            var oportunidadeBusca = _oportunidadeRepositorio.ObterOportunidadePorId(recallOportunidadeId);

            if (oportunidadeBusca == null)
            {
                throw new Exception("Oportunidade não encontrada ou já excluída");
            }

            var token = Autenticador.Autenticar();

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

            var ultimoProtocolo = _workflowRepositorio.UltimoProtocolo(oportunidadeBusca.Id, Processo.OPORTUNIDADE);

            var workflow = new RecallService(token);

            var retorno = workflow.Recall(new CadastroRecall(ultimoProtocolo, User.ObterLogin(), User.ObterNome(), User.ObterEmail(), motivoRecallOportunidade));

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

            if (retorno.sucesso)
            {
                if (oportunidadeBusca.Cancelado)
                {
                    //_oportunidadeRepositorio.AtualizarStatusOportunidade(StatusOportunidade.ATIVA, oportunidadeBusca.Id);
                    //_oportunidadeRepositorio.AtualizarCancelamentoOportunidade(false, oportunidadeBusca.Id);
                    //_oportunidadeRepositorio.AtualizarDataCancelamentoOportunidade(null, oportunidadeBusca.Id);
                    _oportunidadeRepositorio.PermiteAlterarDataCancelamento(oportunidadeBusca.Id, true);
                }

                if (oportunidadeBusca.StatusOportunidade == StatusOportunidade.ENVIADO_PARA_APROVACAO)
                {
                    _oportunidadeRepositorio.AtualizarStatusOportunidade(null, oportunidadeBusca.Id);
                }

                var fichasFaturamento = _oportunidadeRepositorio.ObterFichasFaturamento(oportunidadeBusca.Id);

                foreach (var ficha in fichasFaturamento)
                {
                    if (ficha.StatusFichaFaturamento == StatusFichaFaturamento.EM_APROVACAO)
                    {
                        _oportunidadeRepositorio.AtualizarStatusFichaFaturamento(StatusFichaFaturamento.EM_ANDAMENTO, ficha.Id);
                    }
                }

                return(Json(new
                {
                    Processo = Processo.OPORTUNIDADE,
                    RedirectUrl = $"/Oportunidades/Atualizar/{oportunidadeBusca.Id}"
                }, JsonRequestBehavior.AllowGet));
            }

            return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, retorno.mensagem));
        }
Ejemplo n.º 16
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());
            }
        }
Ejemplo n.º 17
0
        public ActionResult RecallAdendos(int recallAdendosOportunidadeId, int recallAdendoId, string motivoRecallAdendos)
        {
            var oportunidadeBusca = _oportunidadeRepositorio.ObterOportunidadePorId(recallAdendosOportunidadeId);

            if (oportunidadeBusca == null)
            {
                throw new Exception("Oportunidade não encontrada ou já excluída");
            }

            var adendoBusca = _oportunidadeRepositorio.ObterAdendoPorId(recallAdendoId);

            if (adendoBusca == null)
            {
                throw new Exception("Adendo não encontrado ou já excluído");
            }

            var token = Autenticador.Autenticar();

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

            var ultimoProtocolo = _workflowRepositorio.UltimoProtocolo(oportunidadeBusca.Id, Processo.ADENDO, adendoBusca.Id);

            var workflow = new RecallService(token);

            var retorno = workflow.Recall(new CadastroRecall(ultimoProtocolo, User.ObterLogin(), User.ObterNome(), User.ObterEmail(), motivoRecallAdendos));

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

            if (retorno.sucesso)
            {
                if (adendoBusca.StatusAdendo == StatusAdendo.ENVIADO)
                {
                    _oportunidadeRepositorio.AtualizarStatusAdendo(StatusAdendo.ABERTO, adendoBusca.Id);

                    if (adendoBusca.TipoAdendo == TipoAdendo.FORMA_PAGAMENTO || adendoBusca.TipoAdendo == TipoAdendo.INCLUSAO_SUB_CLIENTE)
                    {
                        var fichasFaturamento = _oportunidadeRepositorio.ObterFichasFaturamento(oportunidadeBusca.Id);

                        foreach (var ficha in fichasFaturamento)
                        {
                            if (ficha.StatusFichaFaturamento == StatusFichaFaturamento.EM_APROVACAO)
                            {
                                _oportunidadeRepositorio.AtualizarStatusFichaFaturamento(StatusFichaFaturamento.EM_ANDAMENTO, ficha.Id);
                            }
                        }
                    }
                }

                return(Json(new
                {
                    Processo = Processo.ADENDO,
                    RedirectUrl = $"/Oportunidades/Atualizar/{oportunidadeBusca.Id}"
                }, JsonRequestBehavior.AllowGet));
            }

            return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, retorno.mensagem));
        }
Ejemplo n.º 18
0
        public static void Main(string[] args)
        {
            string       cpf;
            string       opcaoPerfil;
            string       opcaoUsuario;
            string       opcaoCpf;
            string       empreendedorString;
            bool         finded = false;
            StreamReader Autenticador;

            Empreendedor          empreendedor          = new Empreendedor();
            Comprador             comprador             = new Comprador();
            BaseSombra            basesombra            = new BaseSombra();
            EmpreendedorComprador empreendedorComprador = new EmpreendedorComprador();


            Console.WriteLine("Bem vindo ao InvestCity!");
            Console.WriteLine("Desenvolvendo relações!");
            Console.WriteLine("Qual o seu Perfil? ");
            Console.WriteLine("Digite: \n 1 - Empreendedor \n 2 - Comprador");
            opcaoPerfil = Console.ReadLine();

            if (opcaoPerfil == "1")
            {
                Console.WriteLine("Possui cadastro conosco? ");
                Console.WriteLine("Digite: \n 1 - SIM \n 2 - NÃO");
                opcaoUsuario = Console.ReadLine();
                if (opcaoUsuario == "1")
                {
                    Autenticador = File.OpenText("./BD/empreendedor.txt");
                    Console.WriteLine("Digite seu CPF (Sem pontos) ");
                    opcaoCpf = Console.ReadLine();
                    if (basesombra.ValidaCPF(opcaoCpf))
                    {
                        while (Autenticador.EndOfStream != true)
                        {
                            string linha = Autenticador.ReadLine();
                            if (linha.Contains(opcaoCpf))
                            {
                                finded = true;
                                Console.WriteLine("Usuário encontrado!");

                                Console.WriteLine("Seus Servicos:");
                                empreendedorComprador.listar(opcaoCpf);
                            }
                        }
                        Autenticador.Close();
                        if (!finded)
                        {
                            Console.WriteLine("Usuário não encontrado!");
                        }
                    }
                    else
                    {
                        Console.WriteLine("CPF inválido!");
                    }
                }
                else
                {
                    Console.WriteLine("Nome do Empreendedor: ");
                    empreendedor.setNome(Console.ReadLine());
                    Console.WriteLine("Cpf do Empreendedor: ");
                    cpf = Console.ReadLine();
                    while (!basesombra.ValidaCPF(cpf))
                    {
                        Console.WriteLine("Cpf inválido, digite novamente: ");
                        cpf = Console.ReadLine();
                    }
                    empreendedor.setCpf(cpf);

                    Console.WriteLine("Telefone para Contato: ");
                    empreendedor.setTelefone(Console.ReadLine());
                    Console.WriteLine("Tipo de serviço: ");
                    empreendedor.setTipoServico(Console.ReadLine());
                    Console.WriteLine("Cidade da prestação de serviço: ");
                    empreendedor.setCidade(Console.ReadLine());
                    Console.WriteLine("Valor do serviço: ");
                    empreendedor.setPreco(Double.Parse(Console.ReadLine()));

                    empreendedor.insert();
                    Console.WriteLine("Empreendedor cadastrado com sucesso!");
                }
            }
            else
            {
                Console.WriteLine("Possui cadastro conosco? ");
                Console.WriteLine("Digite: \n 1 - SIM \n 2 - NÃO");
                opcaoUsuario = Console.ReadLine();
                if (opcaoUsuario == "1")
                {
                    Autenticador = File.OpenText("./BD/comprador.txt");
                    Console.WriteLine("Digite seu CPF (Sem pontos) ");
                    opcaoCpf = Console.ReadLine();
                    while (Autenticador.EndOfStream != true)
                    {
                        string linha = Autenticador.ReadLine();
                        if (linha.Contains(opcaoCpf))
                        {
                            finded = true;
                            Console.WriteLine("Usuário encontrado!");
                            Console.WriteLine("Serviços disponiveis:");
                            empreendedor.listar();
                        }
                    }
                    Autenticador.Close();
                    if (finded)
                    {
                        Console.WriteLine("Selecione um serviço (Digite o cpf):");
                        cpf = Console.ReadLine();
                        while (empreendedor.selecionar(cpf) == "false")
                        {
                            Console.WriteLine("Cpf inválido, digite novamente: ");
                            cpf = Console.ReadLine();
                        }
                        empreendedorString = empreendedor.selecionar(cpf);
                        string[] empreendedorArray = empreendedorString.Split(";".ToCharArray());

                        empreendedorComprador.setCpfEmpreendedor(empreendedorArray[1]);
                        empreendedorComprador.setCpfComprador(opcaoCpf);
                        empreendedorComprador.setServico(empreendedorArray[4]);
                        empreendedorComprador.setValor(Double.Parse(empreendedorArray[6]));

                        empreendedorComprador.insert();
                    }
                    else
                    {
                        Console.WriteLine("Usuário não encontrado!");
                    }
                }
                else
                {
                    Console.WriteLine("Nome do comprador: ");
                    comprador.setNome(Console.ReadLine());
                    Console.WriteLine("Cpf do comprador: ");
                    cpf = Console.ReadLine();
                    while (!basesombra.ValidaCPF(cpf))
                    {
                        Console.WriteLine("Cpf inválido, digite novamente: ");
                        cpf = Console.ReadLine();
                    }
                    comprador.setCpf(cpf);
                    Console.WriteLine("Telefone para Contato: ");
                    comprador.setTelefone(Console.ReadLine());
                    Console.WriteLine("Cidade que deseja o serviço: ");
                    comprador.setCidade(Console.ReadLine());
                    Console.WriteLine("Valor do Investimento: ");
                    comprador.setValorInvestido(Double.Parse(Console.ReadLine()));

                    comprador.insert();
                    Console.WriteLine("Comprador cadastrado com sucesso!");
                }
            }
        }
Ejemplo n.º 19
0
        public void Iniciar()
        {
            var token = Autenticador.Autenticar();

            if (token == null)
            {
                logger.Error("Não foi possível se autenticar no serviço de Workflow");
                return;
            }

            var workflow = new WorkflowService(token);

            var fila = workflow.ObterFilaWorkflow();

            if (fila == null)
            {
                logger.Info("Não foi possível obter a lista de Workflows");
                return;
            }

            foreach (var wkf in fila.list)
            {
                var idWorkflow             = wkf.id_WorkFlow;
                var idProcessoRequisitante = wkf.autonum_Sistema_Processo_Requisitante;
                var idProcesso             = wkf.id_Processo;
                logger.Info("Lendo Fila  : IdProcesso" + idProcesso.ToString() + " Status " + wkf.id_Status.ToString() + " ID " + idProcessoRequisitante.ToString());


                if (!Int32.TryParse(idProcessoRequisitante, out _))
                {
                    logger.Error($"O Id (Sistema Processo Requisitante) {idProcessoRequisitante} não é um número válido");
                    continue;
                }

                if (!Int32.TryParse(idProcesso.ToString(), out _))
                {
                    logger.Error($"O Id (Sistema Processo Requisitante) {idProcesso} deve ser um número válido");
                    continue;
                }

                if (!(idProcesso >= 1 && idProcesso <= 14))
                {
                    logger.Error($"O Id do Processo deve ser um valor numérico e estar entre 1-14");
                    continue;
                }

                var idStatus = wkf.id_Status;

                if (idStatus == 2 || idStatus == 3)
                {
                    try
                    {
                        /*
                         *  Processos:
                         *
                         *  01. OPORTUNIDADE,
                         *  02. FICHA_FATURAMENTO,
                         *  03. PREMIO_PARCERIA,
                         *  04. ADENDO,
                         *  05. SOLICITACAO_CANCELAMENTO,
                         *  06. SOLICITACAO_DESCONTO,
                         *  07. SOLICITACAO_RESTITUICAO,
                         *  08. SOLICITACAO_PRORROGACAO,
                         *  09. CANCELAMENTO_OPORTUNIDADE,
                         *  10. SOLICITACAO_OUTROS
                         */

                        if (idProcesso < 5 || idProcesso == 9)
                        {
                            if (!OportunidadeExistente(idProcessoRequisitante, idProcesso))
                            {
                                switch (idProcesso)
                                {
                                case 9:
                                    logger.Error("Oportunidade inexistente - autonum_Sistema_Processo_Requisitante: " + idWorkflow);
                                    break;

                                case 2:
                                    logger.Error("Ficha inexistente - autonum_Sistema_Processo_Requisitante: " + idWorkflow);
                                    break;

                                case 3:
                                    logger.Error("Prêmio inexistente - autonum_Sistema_Processo_Requisitante: " + idWorkflow);
                                    break;

                                case 4:
                                    logger.Error("Adendo inexistente - autonum_Sistema_Processo_Requisitante: " + idWorkflow);
                                    break;
                                }

                                continue;
                            }
                        }
                        else
                        {
                            if (idProcesso <= 12)
                            {
                                if (!SolicitacaoExistente(idProcessoRequisitante))
                                {
                                    logger.Error("Solicitação Comercial inexistente - autonum_Sistema_Processo_Requisitante: " + idWorkflow);
                                    continue;
                                }
                            }
                        }

                        AtualizarStatus(idProcessoRequisitante, idWorkflow, idProcesso, idStatus, workflow);
                    }
                    catch (Exception ex)
                    {
                        logger.Error("Falha ao atualizar o Status do registro " + ex.ToString());
                    }
                }
            }

            logger.Info("Processamento concluído");
        }
Ejemplo n.º 20
0
        public void EnviarAdendoParaAprovacao(int id)
        {
            var adendoBusca = _oportunidadeRepositorio.ObterAdendoPorId(id);

            if (adendoBusca == null)
            {
                _logger.Info($"Adendo {adendoBusca.Id} não encontrado");
            }

            var oportunidadeBusca = _oportunidadeRepositorio.ObterOportunidadePorId(adendoBusca.OportunidadeId);

            if (oportunidadeBusca == null)
            {
                _logger.Info($"Oportunidade {oportunidadeBusca.Id} não encontrada");
            }

            if (oportunidadeBusca.OportunidadeProposta == null || oportunidadeBusca.OportunidadeProposta.ModeloId == 0)
            {
                _logger.Info($"A Oportunidade {oportunidadeBusca.Id} não possui nenhum Modelo Vinculado");
            }

            var modelo = _modeloRepositorio.ObterModeloPorId(oportunidadeBusca.OportunidadeProposta.ModeloId);

            var aprovacoes = _workflowRepositorio.ObterAprovacoesPorOportunidade(oportunidadeBusca.Id, Processo.ADENDO);

            if (aprovacoes.Any() && adendoBusca.StatusAdendo == StatusAdendo.ENVIADO)
            {
                _logger.Info($"Já existe uma aprovação pendente para este Adendo {adendoBusca.Id}");
            }

            var token = Autenticador.Autenticar();

            if (token == null)
            {
                _logger.Info("Não foi possível se autenticar no serviço de Workflow");
            }

            var workflow = new WorkflowService(token);

            IEnumerable <dynamic> clientes = null;

            if (adendoBusca.TipoAdendo == TipoAdendo.INCLUSAO_SUB_CLIENTE)
            {
                clientes = _oportunidadeRepositorio
                           .ObterAdendoSubClientesInclusao(adendoBusca.Id)
                           .Select(c => $"{c.Descricao} ({ c.Documento})");
            }

            if (adendoBusca.TipoAdendo == TipoAdendo.INCLUSAO_GRUPO_CNPJ)
            {
                clientes = _oportunidadeRepositorio
                           .ObterAdendoGruposCNPJ(adendoBusca.Id, AdendoAcao.INCLUSAO)
                           .Select(c => $"{c.Descricao} ({ c.Documento})");
            }

            if (adendoBusca.TipoAdendo == TipoAdendo.EXCLUSAO_SUB_CLIENTE)
            {
                clientes = _oportunidadeRepositorio
                           .ObterAdendoSubClientesExclusao(adendoBusca.Id)
                           .Select(c => $"{c.Descricao} ({ c.Documento})");
            }

            if (adendoBusca.TipoAdendo == TipoAdendo.EXCLUSAO_GRUPO_CNPJ)
            {
                clientes = _oportunidadeRepositorio
                           .ObterAdendoGruposCNPJ(adendoBusca.Id, AdendoAcao.EXCLUSAO)
                           .Select(c => $"{c.Descricao} ({ c.Documento})");
            }

            if (adendoBusca.TipoAdendo == TipoAdendo.FORMA_PAGAMENTO)
            {
                var adendoFormaPagamento = _oportunidadeRepositorio
                                           .ObterAdendoFormaPagamento(adendoBusca.Id)
                                           .FormaPagamento
                                           .ToName();

                var lst = new List <string>
                {
                    adendoFormaPagamento
                };

                clientes = lst;
            }

            if (adendoBusca.TipoAdendo == TipoAdendo.ALTERACAO_VENDEDOR)
            {
                var adendoVendedor = _oportunidadeRepositorio
                                     .ObterAdendoVendedor(adendoBusca.Id).VendedorId;

                var vendedor = _vendedorRepositorio.ObterVendedorPorId(adendoVendedor);

                var lst = new List <string>
                {
                    vendedor.Nome
                };

                clientes = lst;
            }

            var oportunidadeDetalhes = _oportunidadeRepositorio.ObterDetalhesOportunidade(oportunidadeBusca.Id);

            var campos = new
            {
                OportunidadeId        = oportunidadeBusca.Id,
                Descricao             = $"A-{adendoBusca.Id}",
                DescricaoOportunidade = oportunidadeBusca.Descricao,
                oportunidadeDetalhes.Conta,
                oportunidadeDetalhes.TabelaId,
                TipoAdendo   = adendoBusca.TipoAdendo.ToName(),
                StatusAdendo = adendoBusca.StatusAdendo.ToName(),
                adendoBusca.DataCadastro,
                adendoBusca.CriadoPor,
                TipoOperacao = modelo.TipoOperacao.ToString(),
                Clientes     = clientes != null?string.Join(",", clientes) : string.Empty
            };

            var retorno = workflow.EnviarParaAprovacao(
                new CadastroWorkflow(Processo.ADENDO, 1, adendoBusca.Id, User.ObterLogin(), User.ObterNome(), User.ObterEmail(), JsonConvert.SerializeObject(campos)));

            if (retorno == null)
            {
                throw new Exception("Nenhuma resposta do serviço de Workflow");
            }

            if (retorno.sucesso == false)
            {
                _logger.Info(retorno.mensagem);
            }

            _workflowRepositorio.IncluirEnvioAprovacao(new EnvioWorkflow(oportunidadeBusca.Id, Processo.ADENDO, retorno.protocolo, retorno.mensagem, User.ObterId()));

            _oportunidadeRepositorio.AtualizarStatusAdendo(StatusAdendo.ENVIADO, adendoBusca.Id);

            _logger.Info($"Adendo {adendoBusca.Id} enviado para Aprovação");
        }
Ejemplo n.º 21
0
        public ActionResult RecallAnaliseCredito(int recallAnaliseId, string motivoRecallAnalise)
        {
            var contaSessao = _contaRepositorio.ObterContaPorId(recallAnaliseId);

            Session["ContaId"]         = contaSessao.Id;
            Session["RazaoSocial"]     = contaSessao.Descricao;
            Session["FontePagadoraId"] = contaSessao.Id;
            Session["Cnpj"]            = contaSessao.Documento;

            var analiseCreditoBusca = _analiseCreditoRepositorio.ObterConsultaSpc(recallAnaliseId);

            if (analiseCreditoBusca == null)
            {
                throw new Exception("Solicitação não encontrada ou já excluída");
            }

            if (!User.IsInRole("OportunidadesFichas:RecallFichaFaturamento"))
            {
                if (!_equipesService.ValidarEquipeOportunidade(analiseCreditoBusca.Id))
                {
                    return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Usuário não possui permissão para edição da Solicitacao (Equipes)"));
                }
            }

            var token = Autenticador.Autenticar();

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

            var ultimoProtocolo = _workflowRepositorio.UltimoProtocolo(analiseCreditoBusca.ContaId, Processo.ANALISE_DE_CREDITO);


            var workflow = new RecallService(token);

            var retorno = workflow.Recall(new CadastroRecall(ultimoProtocolo, User.ObterLogin(), User.ObterNome(), User.ObterEmail(), motivoRecallAnalise));

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

            if (retorno.sucesso)
            {
                if (analiseCreditoBusca.StatusAnaliseDeCredito == StatusAnaliseDeCredito.EM_APROVACAO)
                {
                    _analiseCreditoRepositorio.AtualizarSPC1(recallAnaliseId);
                }

                //var resultado = _analiseCreditoRepositorio
                //.ObterSolicitacoesLimiteDeCredito(solicitacaoBusca.ContaId);

                //return PartialView("_SolicitacoesLimiteCredito", resultado);
                return(Json(new
                {
                    Processo = Processo.ANALISE_DE_CREDITO,
                    RedirectUrl = $"/AnaliseCredito/{recallAnaliseId}",
                }, JsonRequestBehavior.AllowGet));
                //return RedirectToAction("Index", "AnaliseCredito", new { id = recallAnaliseId });
            }

            return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, retorno.mensagem));
        }
Ejemplo n.º 22
0
        private string  EnviarParaAprovacaocond(int processoId)
        {
            try
            {
                dynamic campos = null;
                var     analiseCreditoBusca = _analiseCreditoRepositorio.ObterConsultaSpc(processoId);

                var limiteCreditoCondPgtoBusca = _analiseCreditoRepositorio.ObterLimiteDeCreditoPorId(processoId);

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

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

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

                if (aprovacoes.Any() && limiteCreditoCondPgtoBusca.StatusLimiteCredito == StatusLimiteCredito.EM_APROVACAO)
                {
                    return("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
                };


                var token = Autenticador.Autenticar();

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

                var workflow = new WorkflowService(token);

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

                if (retornoWorkflow == null)
                {
                    return("Nenhuma resposta do serviço de Workflow");
                }

                if (retornoWorkflow.sucesso == false)
                {
                    return(retornoWorkflow.mensagem);
                }
                _analiseCreditoRepositorio.AtualizarlimiteDeCredito(processoId);

                var workFlowId = _workflowRepositorio.IncluirEnvioAprovacao(
                    new EnvioWorkflow(
                        processoId,
                        Processo.ANALISE_DE_CREDITO_COND_PGTO,
                        retornoWorkflow.protocolo,
                        retornoWorkflow.mensagem,
                        User.ObterId()));

                return("0");
            }
            catch (Exception ex)
            {
                throw new Exception(ex.ToString());
            }
        }
Ejemplo n.º 23
0
        public ActionResult RecallSolicitacaoComercial(int recallSolicitacaoId, string motivoRecall)
        {
            var solicitacaoBusca = _solicitacoesRepositorio.ObterSolicitacaoPorId(recallSolicitacaoId);

            if (solicitacaoBusca == null)
            {
                throw new Exception("Solicitação Comercial não encontrada ou já excluída");
            }

            var token = Autenticador.Autenticar();

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

            Processo processo = Processo.SOLICITACAO_CANCELAMENTO;

            switch (solicitacaoBusca.TipoSolicitacao)
            {
            case TipoSolicitacao.CANCELAMENTO_NF:
                processo = Processo.SOLICITACAO_CANCELAMENTO;
                break;

            case TipoSolicitacao.DESCONTO:
                processo = Processo.SOLICITACAO_DESCONTO;
                break;

            case TipoSolicitacao.PRORROGACAO_BOLETO:
                processo = Processo.SOLICITACAO_PRORROGACAO;
                break;

            case TipoSolicitacao.RESTITUICAO:
                processo = Processo.SOLICITACAO_RESTITUICAO;
                break;

            case TipoSolicitacao.OUTROS:
                processo = Processo.SOLICITACAO_OUTROS;
                break;
            }

            var ultimoProtocolo = _workflowRepositorio.UltimoProtocolo(solicitacaoBusca.Id, processo);

            var workflow = new RecallService(token);

            var retorno = workflow.Recall(new CadastroRecall(ultimoProtocolo, User.ObterLogin(), User.ObterNome(), User.ObterEmail(), motivoRecall));

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

            if (retorno.sucesso)
            {
                if (solicitacaoBusca.StatusSolicitacao == StatusSolicitacao.EM_APROVAVAO)
                {
                    _solicitacoesRepositorio.AtualizarStatusSolicitacao(StatusSolicitacao.NOVO, solicitacaoBusca.Id);
                }

                return(Json(new
                {
                    Processo = Processo.OPORTUNIDADE,
                    RedirectUrl = $"/Solicitacoes/Atualizar/{solicitacaoBusca.Id}"
                }, JsonRequestBehavior.AllowGet));
            }

            return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, retorno.mensagem));
        }
Ejemplo n.º 24
0
        public static void Main(string[] args)
        {
            string       cpf;
            string       opcaoPerfil;
            string       opcaoUsuario;
            string       opcaoCpf;
            string       empreendedorString;
            bool         finded = false;
            StreamReader Autenticador;

            Empreendedor          empreendedor          = new Empreendedor();
            Comprador             comprador             = new Comprador();
            EmpreendedorComprador empreendedorComprador = new EmpreendedorComprador();


            Console.WriteLine("Bem vindo ao InvestCity!");
            Console.WriteLine("Encontre ou Divulgue sua Startup!");
            Console.WriteLine("Qual o seu Perfil? ");
            Console.WriteLine("Digite: \n 1 - Empreendedor \n 2 - Investidor \n 0 - Sair");
            opcaoPerfil = Console.ReadLine();
            while (opcaoPerfil != "0" && opcaoPerfil != "1" && opcaoPerfil != "2")
            {
                Console.WriteLine("Digite: \n 1 - Empreendedor \n 2 - Investidor \n 0 - Sair");
                opcaoPerfil = Console.ReadLine();
            }

            if (opcaoPerfil == "1")
            {
                Console.WriteLine("Possui cadastro conosco? ");
                Console.WriteLine("Digite: \n 1 - SIM \n 2 - NÃO");
                opcaoUsuario = Console.ReadLine();
                while (opcaoUsuario != "1" && opcaoUsuario != "2")
                {
                    Console.WriteLine("Digite: \n 1 - SIM \n 2 - NÃO");
                    opcaoUsuario = Console.ReadLine();
                }
                if (opcaoUsuario == "1")
                {
                    Autenticador = File.OpenText("./BD/empreendedor.txt");
                    Console.WriteLine("Digite seu CPF (Sem pontos): ");
                    opcaoCpf = Console.ReadLine();
                    while (!empreendedor.ValidaCPF(opcaoCpf))
                    {
                        Console.WriteLine("CPF inválido! Digite novamente: ");
                        opcaoCpf = Console.ReadLine();
                    }

                    while (Autenticador.EndOfStream != true)
                    {
                        string linha = Autenticador.ReadLine();
                        if (linha.Contains(opcaoCpf))
                        {
                            finded = true;
                            Console.WriteLine("Usuário encontrado!");

                            Console.WriteLine("Seus Servicos:");
                            empreendedorComprador.listar(opcaoCpf);
                        }
                    }
                    Autenticador.Close();
                    if (!finded)
                    {
                        Console.WriteLine("Usuário não encontrado!");
                    }
                }
                else
                {
                    Console.WriteLine("Nome do Empreendedor: ");
                    empreendedor.setNome(Console.ReadLine());
                    Console.WriteLine("Cpf do Empreendedor: ");
                    cpf = Console.ReadLine();
                    while (!empreendedor.ValidaCPF(cpf))
                    {
                        Console.WriteLine("Cpf inválido, digite novamente: ");
                        cpf = Console.ReadLine();
                    }
                    empreendedor.setCpf(cpf);

                    Console.WriteLine("Telefone para Contato: ");
                    empreendedor.setTelefone(Console.ReadLine());
                    Console.WriteLine("Descrição Da Startup: ");
                    empreendedor.setTipoServico(Console.ReadLine());
                    Console.WriteLine("Cidade da sede: ");
                    empreendedor.setCidade(Console.ReadLine());
                    Console.WriteLine("Valor desejado para investimento: ");
                    empreendedor.setPreco(Double.Parse(Console.ReadLine()));

                    empreendedor.insert();
                    Console.WriteLine("Startup cadastrada com sucesso!");
                }
            }
            else if (opcaoPerfil == "2")
            {
                Console.WriteLine("Possui cadastro conosco? ");
                Console.WriteLine("Digite: \n 1 - SIM \n 2 - NÃO");
                opcaoUsuario = Console.ReadLine();
                if (opcaoUsuario == "1")
                {
                    Autenticador = File.OpenText("./BD/comprador.txt");
                    Console.WriteLine("Digite seu CPF (Sem pontos) ");
                    opcaoCpf = Console.ReadLine();
                    while (Autenticador.EndOfStream != true)
                    {
                        string linha = Autenticador.ReadLine();
                        if (linha.Contains(opcaoCpf))
                        {
                            finded = true;
                            Console.WriteLine("Usuário encontrado!");
                            Console.WriteLine("Serviços disponiveis:");
                            empreendedor.listar();
                        }
                    }
                    Autenticador.Close();
                    if (finded)
                    {
                        Console.WriteLine("Selecione uma Startup (Digite o cpf):");
                        cpf = Console.ReadLine();
                        while (empreendedor.selecionar(cpf) == "false")
                        {
                            Console.WriteLine("Cpf inválido, digite novamente: ");
                            cpf = Console.ReadLine();
                        }
                        empreendedorString = empreendedor.selecionar(cpf);
                        string[] empreendedorArray = empreendedorString.Split(";".ToCharArray());

                        empreendedorComprador.setCpfEmpreendedor(empreendedorArray[1]);
                        empreendedorComprador.setCpfComprador(opcaoCpf);
                        empreendedorComprador.setServico(empreendedorArray[4]);
                        empreendedorComprador.setValor(Double.Parse(empreendedorArray[6]));

                        empreendedorComprador.insert();
                        Console.WriteLine("Investimento feito!");
                    }
                    else
                    {
                        Console.WriteLine("Usuário não encontrado!");
                    }
                }
                else
                {
                    Console.WriteLine("Nome do investidor: ");
                    comprador.setNome(Console.ReadLine());
                    Console.WriteLine("Cpf do investidor: ");
                    cpf = Console.ReadLine();
                    while (!comprador.ValidaCPF(cpf))
                    {
                        Console.WriteLine("Cpf inválido, digite novamente: ");
                        cpf = Console.ReadLine();
                    }
                    comprador.setCpf(cpf);
                    Console.WriteLine("Telefone para Contato: ");
                    comprador.setTelefone(Console.ReadLine());
                    Console.WriteLine("Cidade: ");
                    comprador.setCidade(Console.ReadLine());
                    Console.WriteLine("Valor que deseja investir: ");
                    comprador.setValorInvestido(Double.Parse(Console.ReadLine()));

                    comprador.insert();
                    Console.WriteLine("Cadastro efetuado com sucesso. Parabéns!");
                }
            }
            else if (opcaoPerfil == "0")
            {
                Console.WriteLine("Obrigado!");
            }
        }
Ejemplo n.º 25
0
 public AutenticacaoController(Contexto db, ADService aD, Autenticador tiaIdentity)
 {
     this.db          = db;
     this.AD          = aD;
     this.tiaIdentity = tiaIdentity;
 }