/// <summary>
 /// Bloqueio automatico dos usuarios que ja estao com documentos com prazos atrasados
 /// </summary>
 /// <param name="db">Contexto</param>
 /// <param name="fornecedor">Id do Fornecedor</param>
 private static void InserirSolicitacaoBloqueioAtrasoDocumento(WebForLinkContexto db, int contratante, int fornecedor)
 {
     try
     {
         var         FluxoId     = db.WFL_FLUXO.FirstOrDefault(x => x.CONTRATANTE_ID == contratante && x.FLUXO_TP_ID == 110).ID;
         SOLICITACAO solicitacao = new SOLICITACAO()
         {
             CONTRATANTE_ID        = contratante,
             FLUXO_ID              = FluxoId,
             SOLICITACAO_DT_CRIA   = DateTime.Now,
             SOLICITACAO_STATUS_ID = 5,
             PJPF_ID = fornecedor,
         };
         SOLICITACAO_BLOQUEIO bloqueio = new SOLICITACAO_BLOQUEIO()
         {
             BLQ_COMPRAS_TODAS_ORG_COMPRAS = false,
             BLQ_LANCAMENTO_EMP            = true,
             BLQ_QUALIDADE_FUNCAO_BQL_ID   = 2,
             WFD_SOLICITACAO = solicitacao,
             BLQ_MOTIVO_DSC  = "Bloqueio gerado automaticamente."
         };
         db.Entry(solicitacao).State = EntityState.Added;
         db.Entry(bloqueio).State    = EntityState.Added;
         db.SaveChanges();
     }
     catch (Exception ex)
     {
         throw new WebForLinkException("Erro ao tentar inserir a solicitação de bloqueio. ", ex);
     }
 }
        private void EnviaEmailSolicitante(int solicitacaoId)
        {
            SOLICITACAO objSolicitacao =
                db.WFD_SOLICITACAO
                .Include("WFD_USUARIO")
                .Include("Fluxo")
                .FirstOrDefault(x => x.ID == solicitacaoId);

            if (objSolicitacao != null)
            {
                if (objSolicitacao.Usuario != null)
                {
                    string assunto = string.Empty;
                    if (objSolicitacao.SOLICITACAO_STATUS_ID == (int)EnumStatusTramite.Reprovado)
                    {
                        assunto = "Reprovação da solicitação";
                    }
                    if (objSolicitacao.SOLICITACAO_STATUS_ID == (int)EnumStatusTramite.Concluido)
                    {
                        assunto = "Finalização da solicitação";
                    }

                    bool envioEmail = _metodosGerais.EnviarEmail(objSolicitacao.Usuario.EMAIL, assunto, LayoutMensagemEmailSolicitante(objSolicitacao));
                    if (!envioEmail)
                    {
                        throw new Exception();
                    }
                }
            }
        }
Example #3
0
 public AprovacaoVM(int idSolicitacao, int fluxoId, string fluxoNome)
 {
     Solicitacao          = new SOLICITACAO();
     Fornecedor           = new SolicitacaoCadastroFornecedor();
     Solicitacao_Tramite  = new SOLICITACAO_TRAMITE();
     FornecedorFinalizado = new Fornecedor();
     IdSolicitacao        = idSolicitacao;
     FluxoId         = fluxoId;
     NomeSolicitacao = fluxoNome;
 }
        public ActionResult AprovacaoFrm(FichaCadastralWebForLinkVM model, int ContratanteID, int SolicitacaoID, int FluxoID, int PapelID, string btnAcao, int[] DocumentoID, string[] Documento, HttpPostedFileBase[] file, string[] DataValidade, bool[] ExigeValidade, int[] Banco, string[] Agencia, string[] Digito, string[] ContaCorrente, string[] ContaCorrenteDigito, int[] ContatoID, string[] NomeContato, string[] Email, string[] Telefone, string[] Celular, string NomeEmpresa, string Estilo, bool?SolicitaFichaCadastral, bool?SolicitaDocumentos, string motivoReprovao, string ccCliente, string ccGrupoEmpresa)
        {
            try
            {
                SOLICITACAO solicitacao = _solicitacaoService.BuscarPorIdIncluindoFluxo(SolicitacaoID);

                int usuarioId = (int)Geral.PegaAuthTicket("UsuarioId");
                ViewBag.Bancos = _bancoService.ListarTodosPorNome();
                ViewBag.BloqueioMotivoQualidade = _tipoBloqueioRoboService.ListarTodosPorCodigoFuncaoBloqueio();
                ViewBag.TipoEndereco            = new SelectList(_enderecoService.ListarTodosTiposEnderecosPorNome(), "ID", "NM_TP_ENDERECO");
                ViewBag.UF = new SelectList(_enderecoService.ListarTodosPorNome(), "UF_SGL", "UF_NM");

                switch (btnAcao)
                {
                case "modificar":
                    var motivoReprovacao = string.IsNullOrEmpty(motivoReprovao) ? string.Empty : motivoReprovao;
                    _solicitacaoService.AlterarAprovacao(SolicitacaoID, ContratanteID, FluxoID, motivoReprovacao, usuarioId);
                    return(RedirectToAction("AprovacaoLst", "Aprovacao", new
                    {
                        MensagemSucesso = string.Format("Modificação da solicitação Nº {0} realizada com sucesso!", SolicitacaoID)
                    }));

                case "aprovar":
                    _tramite.AtualizarTramite(ContratanteID, SolicitacaoID, FluxoID, PapelID, 2, usuarioId);
                    return(RedirectToAction("AprovacaoLst", "Aprovacao", new
                    {
                        MensagemSucesso = string.Format("Aprovação da solicitação Nº {0} realizada com sucesso!", SolicitacaoID)
                    }));

                case "executado":
                    int?grupoId = (int?)Geral.PegaAuthTicket("Grupo");
                    _aprovacaoService.FinalizarSolicitacao(grupoId, solicitacao.Fluxo.FLUXO_TP_ID, SolicitacaoID);
                    _tramite.AtualizarTramite(ContratanteID, SolicitacaoID, FluxoID, PapelID, 2, usuarioId);
                    return(RedirectToAction("AprovacaoLst", "Aprovacao", new
                    {
                        MensagemSucesso = string.Format("Aprovação da solicitação {0} realizada com sucesso!", SolicitacaoID)
                    }));

                case "reprovar":
                    _tramite.AtualizarTramite(ContratanteID, SolicitacaoID, FluxoID, PapelID, 3, usuarioId);
                    return(RedirectToAction("AprovacaoLst", "Aprovacao", new
                    {
                        MensagemSucesso = string.Format("Reprovação da solicitação Nº {0} realizada com sucesso!", SolicitacaoID)
                    }));
                }

                return(View(model));
            }
            catch (Exception ex)
            {
                ModelState.AddModelError("", ex.Message);
                return(View(model));
            }
        }
Example #5
0
        public ActionResult ReenviarFicha(string TipoFuncionalidade, int idSolicitacao, string CNPJ, string EmailContato, FichaCadastralWebForLinkVM ficha)
        {
            try
            {
                CNPJ = CNPJ.Replace(".", "").Replace("-", "").Replace("/", "");

                int usuarioId = (int)Geral.PegaAuthTicket("UsuarioId");

                SOLICITACAO solicitacao = _solicitacaoService.BuscarPorIdControleSolicitacoes(idSolicitacao);
                ficha.ContratanteID        = solicitacao.CONTRATANTE_ID;
                ficha.Solicitacao.Fluxo.ID = solicitacao.FLUXO_ID;


                var papelFornecedor = _papelService.BuscarPorContratanteETipoPapel(ficha.ContratanteID, (int)EnumTiposPapel.Fornecedor).ID;
                var tramites        = _solicitacaoTramite.BuscarTramitePorSolicitacaoIdPapelId(idSolicitacao, papelFornecedor);

                if (tramites == null)
                {
                    var papelSolicitante = _papelService.BuscarPorContratanteETipoPapel(ficha.ContratanteID, (int)EnumTiposPapel.Solicitante).ID;
                    _tramite.AtualizarTramite(ficha.ContratanteID, idSolicitacao, ficha.Solicitacao.Fluxo.ID, papelSolicitante, (int)EnumStatusTramite.Aprovado, usuarioId);
                }

                //se não for primeiro acesso enviar para tela de acesso
                string url = Url.Action("Index", "Home", new
                {
                    chaveurl = Cripto.Criptografar(string.Format("SolicitacaoID={0}&Login={1}&TravaLogin=1", idSolicitacao, CNPJ), Key)
                }, Request.Url.Scheme);

                //se for primeiro acesso enviar para criação de usuário
                #region BuscarPorEmail
                //validar se o e-mail já existe na tabela de Usuarios
                if (!_usuarioBP.ValidarPorCnpj(CNPJ))
                {
                    url = Url.Action("CadastrarUsuarioFornecedor", "Home", new
                    {
                        chaveurl = Cripto.Criptografar(string.Format("Login={0}&SolicitacaoID={1}&Email={2}",
                                                                     CNPJ,
                                                                     idSolicitacao,
                                                                     EmailContato), Key)
                    }, Request.Url.Scheme);
                }

                #endregion

                string mensagemLink           = string.Concat(ficha.Mensagem, "<p><a href='", url, "'>Link</a>:", url, "</p>");
                bool   emailEnviadoComSucesso = _metodosGerais.EnviarEmail(EmailContato, ficha.Assunto, mensagemLink);
            }
            catch (Exception ex)
            {
                Log.Error(ex);
            }

            return(RedirectToAction("FornecedoresControleSolicitacoesLst", "ControleSolicitacao"));
        }
        private SOLICITACAO CriarSolicitacao(FichaCadastralWebForLinkVM model, int tipoFluxoId)
        {
            SOLICITACAO solicitacao = new SOLICITACAO();

            PopularSolicitacaoEmAprovacao(model.ContratanteID,
                                          model.ID,
                                          (int)Geral.PegaAuthTicket("UsuarioId"),
                                          _fluxoService.BuscarPorTipoEContratante(tipoFluxoId, model.ContratanteID).ID,
                                          solicitacao);

            return(_solicitacaoService.InserirSolicitacao(solicitacao));
        }
Example #7
0
        public ActionResult Salvar(FichaCadastralWebForLinkVM model)
        {
            try
            {
                SOLICITACAO solicitacao = new SOLICITACAO();
                solicitacao.FLUXO_ID              = _fluxoService.BuscarPorTipoEContratante((int)EnumTiposFluxo.ModificacaoEndereco, model.ContratanteID).ID;
                solicitacao.SOLICITACAO_DT_CRIA   = DateTime.Now;
                solicitacao.SOLICITACAO_STATUS_ID = (int)EnumStatusTramite.EmAprovacao; // EM APROVACAO
                solicitacao.USUARIO_ID            = (int)Geral.PegaAuthTicket("UsuarioId");
                solicitacao.PJPF_ID = model.ID;

                if (model.ContratanteID != 0)
                {
                    solicitacao.CONTRATANTE_ID = model.ContratanteID;
                }

                var solicitacoesModEndereco = Mapper.Map <List <DadosEnderecosVM>, List <SOLICITACAO_MODIFICACAO_ENDERECO> >(model.DadosEnderecos.ToList());

                if (solicitacoesModEndereco.Any())
                {
                    _solicitacaoModificacaoEnderecoService.InserirSolicitacoes(solicitacoesModEndereco, solicitacao);
                }

                var papelAtual = _papelService.BuscarPorContratanteETipoPapel(solicitacao.CONTRATANTE_ID, (int)EnumTiposPapel.Solicitante).ID;

                int usuarioId = (int)Geral.PegaAuthTicket("UsuarioId");
                _tramiteService.AtualizarTramite(solicitacao.CONTRATANTE_ID, solicitacao.ID, solicitacao.FLUXO_ID, papelAtual, (int)EnumStatusTramite.Aprovado, usuarioId);

                PersistirDadosEnderecoEmMemoria();

                string chaveUrl = "";

                if (model.ControllerOrigem == "Fornecedores")
                {
                    chaveUrl = Cripto.Criptografar(String.Format("FornecedorID={0}&ContratanteID={1}&RetSucessoEnderecos=1", model.PJPFID, model.ContratanteID), Key);
                }

                return(RedirectToAction(model.ActionOrigem, model.ControllerOrigem, new { chaveurl = chaveUrl }));
            }
            catch (Exception ex)
            {
                Log.Error(ex);
                string chaveUrl = "";

                if (model.ControllerOrigem == "Fornecedores")
                {
                    chaveUrl = Cripto.Criptografar(String.Format("FornecedorID={0}&ContratanteID={1}&RetSucessoEnderecos=-1", model.PJPFID, model.ContratanteID), Key);
                }

                return(RedirectToAction(model.ActionOrigem, model.ControllerOrigem, new { chaveurl = chaveUrl }));
            }
        }
Example #8
0
        private static Fornecedor RetornaFornecedor(SOLICITACAO solicitacao)
        {
            int pjpfId = 0;

            if (solicitacao.PJPF_ID != null)
            {
                pjpfId = (int)solicitacao.PJPF_ID;
            }

            Fornecedor fornecedor = PJpFbp.BuscarPorId(pjpfId);

            return(fornecedor);
        }
        public ActionResult FornecedoresEstrangeiroFrm(string chaveurl)
        {
            int solicitacaoID = 0;

            if (!string.IsNullOrEmpty(chaveurl))
            {
                List <ParametroCriptografia> param = Cripto.DescriptografarUrl(chaveurl, Key);
                Int32.TryParse(param.First(p => p.Name == "SolicitacaoID").Value, out solicitacaoID);
            }

            try
            {
                if (solicitacaoID > 0)
                {
                    SOLICITACAO solicitacao = _solicitacaoService.BuscarPorIdComFornecedoresDireto(solicitacaoID);

                    FichaCadastralWebForLinkVM ficha = new FichaCadastralWebForLinkVM();

                    if (solicitacao != null)
                    {
                        PreencherFichaCadastral(solicitacao, ficha, 10);

                        #region Preenchimento Específico
                        ficha.TipoFornecedor    = (int)EnumTiposFornecedor.EmpresaEstrangeira;
                        ficha.TipoPreenchimento = (int)EnumTiposPreenchimento.Contratante;
                        #endregion

                        PersistirDadosEmMemoria();
                        PersistirDadosEnderecoEmMemoria();

                        return(View(ficha));
                    }
                }
                else
                {
                    return(RedirectToAction("Alerta", "Home"));
                }
            }
            catch (Exception ex)
            {
                Log.Error(ex);
            }

            return(View());
        }
        private string LayoutMensagemEmailSolicitante(SOLICITACAO Solicitacao)
        {
            string mensagem = "";

            // Finalizado
            if (Solicitacao.SOLICITACAO_STATUS_ID == (int)EnumStatusTramite.Concluido)
            {
                mensagem += "<p style='text-align: center;'><span style='font-size: 130%;'><b>" + ConfigurationManager.AppSettings["NomeSistema"] + "</b></span></p>";
                mensagem += "Sua solicitação de " + Solicitacao.Fluxo.FLUXO_NM + " de número " + Solicitacao.ID + " foi finalizada.<br>";
            }

            // Reprovado
            if (Solicitacao.SOLICITACAO_STATUS_ID == (int)EnumStatusTramite.Reprovado)
            {
                mensagem += "<p style='text-align: center;'><span style='font-size: 130%;'><b>" + ConfigurationManager.AppSettings["NomeSistema"] + "</b></span></p>";
                mensagem += "A solicitação de " + Solicitacao.Fluxo.FLUXO_NM + " de número " + Solicitacao.ID + ", criado por " + Solicitacao.Usuario.NOME + " em " + Solicitacao.SOLICITACAO_DT_CRIA + " foi reprovada.<br>";
            }

            return(mensagem);
        }
        private SOLICITACAO CriarSolicitacaoDocumentos(FichaCadastralWebForLinkVM model, int tipoFluxoId)
        {
            var solicitacao = new SOLICITACAO
            {
                CONTRATANTE_ID        = model.ContratanteID,
                FLUXO_ID              = _fluxoService.BuscarPorTipoEContratante(tipoFluxoId, model.ContratanteID).ID,
                USUARIO_ID            = (int)Geral.PegaAuthTicket("UsuarioId"),
                SOLICITACAO_STATUS_ID = (int)EnumStatusTramite.Aguardando,
                PJPF_ID = model.PJPFID,
            };

            List <SolicitacaoDeDocumentos> documentosList = new List <SolicitacaoDeDocumentos>();

            model.SolicitacaoFornecedor.Documentos
            .ForEach(x =>
            {
                if (!string.IsNullOrEmpty(x.ArquivoSubido))
                {
                    var arquivoId = _fornecedorArquivoService.GravarArquivoSolicitacao(model.ContratanteID, x.ArquivoSubido, x.TipoArquivoSubido);

                    SolicitacaoDeDocumentos solicitacaoDeDocumentos = new SolicitacaoDeDocumentos()
                    {
                        DATA_UPLOAD            = DateTime.Now,
                        NOME_ARQUIVO           = _fornecedorArquivoService.PegaNomeArquivoSubido(x.ArquivoSubido),
                        EXTENSAO_ARQUIVO       = x.TipoArquivoSubido,
                        ARQUIVO_ID             = arquivoId,
                        DATA_VENCIMENTO        = x.PorValidade != null ? ((bool)x.PorValidade ? x.DataValidade : null) : null,
                        DESCRICAO_DOCUMENTO_ID = x.DescricaoDocumentoId,
                        LISTA_DOCUMENTO_ID     = x.ListaDocumentosID
                    };
                    documentosList.Add(solicitacaoDeDocumentos);
                }
            });

            SOLICITACAO soldocumentos = _solicitacaoService.InserirSolicitacaoDocumentos(solicitacao, documentosList);

            var papelAtual = _papelService.BuscarPorContratanteETipoPapel(model.ContratanteID, (int)EnumTiposPapel.Solicitante).ID;

            _tramiteService.AtualizarTramite(model.ContratanteID, soldocumentos.ID, soldocumentos.FLUXO_ID, papelAtual, 2, soldocumentos.USUARIO_ID);
            return(soldocumentos);
        }
        public JsonResult SimplesNacional(string cnpj, int solicitacaoID)
        {
            string      path        = Server.MapPath("~/");
            RoboSimples roboSimples = new RoboSimples();

            try
            {
                roboSimples = roboSimples.CarregaSimplesCNPJ(cnpj, path);

                if (roboSimples.Code < 100)
                {
                    SOLICITACAO solicitacao = _solicitacaoService.BuscarPorId(solicitacaoID);
                    var         robo        = solicitacao.ROBO.FirstOrDefault();
                    roboSimples.GravaRoboSimples(roboSimples, ref robo);
                    solicitacao.WFD_PJPF_ROBO_LOG.Add(new ROBO_LOG()
                    {
                        DATA           = DateTime.Now,
                        ROBO           = EnumRobo.SimplesNacional.ToString(),
                        COD_RETORNO    = roboSimples.Code,
                        MENSAGEM       = roboSimples.Data.Message,
                        SOLICITACAO_ID = solicitacao.ID,
                        CONTRATANTE_ID = solicitacao.CONTRATANTE_ID,
                    });
                    //solicitacaoRoboBP.Alterar(solicitacao);

                    //solicitacao.WFD_PJPF_ROBO_LOG.Add(entityLog);
                    _solicitacaoService.Alterar(solicitacao);
                    //_solicitacaoService.Dispose();
                }
            }
            catch (Exception ex)
            {
                Log.Error(string.Format("Error ao executar o método SimplesNacional: {0}", ex));
            }

            return(Json(roboSimples, JsonRequestBehavior.AllowGet));
        }
 private string LayoutMensagemEmailAprovacao(string mensagem, SOLICITACAO Solicitacao)
 {
     return(mensagem.Replace("^NomeFLuxo^", Solicitacao.Fluxo.FLUXO_NM).Replace("^SolicitacaoId^", Solicitacao.ID.ToString()).Replace("^DataSolicitacao^", Solicitacao.SOLICITACAO_DT_CRIA.ToString("dd/MM/yyyy")));
 }
Example #14
0
 public void ExibirFichaCadastral(int solicitacaoId)
 {
     int         tpFluxoId   = _solicitacaoRepository.BuscarTipoFluxoId(solicitacaoId);
     SOLICITACAO solicitacao = _solicitacaoRepository.BuscarPorIdControleSolicitacoes(solicitacaoId);
 }
        private static void GeraBloqueioAutomatico(WebForLinkContexto db, FORNECEDORBASE pjpf, SOLICITACAO solicitacao, SOLICITACAO_BLOQUEIO bloq)
        {
            solicitacao.CONTRATANTE_ID        = pjpf.CONTRATANTE_ID;
            solicitacao.FLUXO_ID              = db.WFL_FLUXO.FirstOrDefault(x => x.CONTRATANTE_ID == pjpf.CONTRATANTE_ID && x.FLUXO_TP_ID == 110).ID;
            solicitacao.PJPF_BASE_ID          = pjpf.ID;
            solicitacao.SOLICITACAO_DT_CRIA   = DateTime.Now;
            solicitacao.SOLICITACAO_STATUS_ID = 5;

            bloq.BLQ_COMPRAS_TODAS_ORG_COMPRAS = false;
            bloq.BLQ_LANCAMENTO_EMP            = true;
            bloq.BLQ_QUALIDADE_FUNCAO_BQL_ID   = 2;
            bloq.WFD_SOLICITACAO = solicitacao;
            bloq.BLQ_MOTIVO_DSC  = "Bloqueio gerado automaticamente.";

            db.Entry(solicitacao).State = EntityState.Added;
            db.Entry(bloq).State        = EntityState.Added;
        }
        static void ChamaRobo(int pjpfId)
        {
            try
            {
                WebForLinkContexto db = new WebForLinkContexto();

                var pjpf = BuscarFonecedorBaseParaRobo(db, pjpfId);

                RoboReceitaCNPJ roboReceita    = new RoboReceitaCNPJ();
                RoboSintegra    roboSintegra   = new RoboSintegra();
                RoboSimples     roboSimples    = new RoboSimples();
                RoboReceitaCPF  roboReceitaCpf = new RoboReceitaCPF();

                if (pjpf.ROBO == null)
                {
                    pjpf.ROBO = new ROBO();
                }

                bool validaReceita  = (pjpf.ROBO.ID == 0 || pjpf.ROBO.RF_CONSULTA_DTHR == null);
                bool validaSintegra = (pjpf.ROBO.ID == 0 || pjpf.ROBO.SINT_CONSULTA_DTHR == null);
                bool validaSimples  = (pjpf.ROBO.ID == 0 || pjpf.ROBO.SN_CONSULTA_DTHR == null);

                if (pjpf.PJPF_TIPO == 1)
                {
                    if (validaReceita && pjpf.CNPJ != null)
                    {
                        roboReceita = roboReceita.CarregaRoboCNPJ(pjpf.CNPJ, path);

                        var             robo            = pjpf.ROBO;
                        RoboReceitaCNPJ roboReceitaCnpj = new RoboReceitaCNPJ();
                        roboReceitaCnpj.GravaRoboReceita(roboReceita, ref robo);

                        GravaLog(db, roboReceita.Code, roboReceita.Data.Message, EnumRobo.ReceitaFederal.ToString(), pjpf.CONTRATANTE_ID, pjpf.ID);
                    }

                    if (validaSintegra && pjpf.ROBO.RF_UF != null)
                    {
                        roboSintegra = roboSintegra.CarregaSintegra(pjpf.ROBO.RF_UF, pjpf.CNPJ, path);

                        var          robo            = pjpf.ROBO;
                        RoboSintegra roboSintegraObj = new RoboSintegra();
                        roboSintegraObj.GravaRoboSintegra(roboSintegra, ref robo);

                        GravaLog(db, roboSintegra.Code, roboSintegra.Data.Message, EnumRobo.Sintegra.ToString(), pjpf.CONTRATANTE_ID, pjpf.ID);
                    }

                    if (validaSimples && pjpf.CNPJ != null)
                    {
                        roboSimples = roboSimples.CarregaSimplesCNPJ(pjpf.CNPJ, path);

                        var         robo           = pjpf.ROBO;
                        RoboSimples roboSimplesObj = new RoboSimples();
                        roboSimplesObj.GravaRoboSimples(roboSimples, ref robo);

                        GravaLog(db, roboSimples.Code, roboSimples.Data.Message, EnumRobo.SimplesNacional.ToString(), pjpf.CONTRATANTE_ID, pjpf.ID);
                    }
                }

                // Pessoa Fisica
                if (pjpf.PJPF_TIPO == 3)
                {
                    if (validaReceita && pjpf.CPF != null)
                    {
                        DateTime nasc = (DateTime)pjpf.DT_NASCIMENTO;
                        roboReceitaCpf = roboReceitaCpf.CarregaRoboCPF(pjpf.CPF, nasc.ToString("dd/MM/yyyy"), path);

                        var            robo       = pjpf.ROBO;
                        RoboReceitaCPF roboCpfObj = new RoboReceitaCPF();
                        roboCpfObj.GravaRoboCpf(roboReceitaCpf, ref robo);

                        GravaLog(db, roboReceitaCpf.Code, roboReceitaCpf.Data.Message, EnumRobo.ReceitaFederalPF.ToString(), pjpf.CONTRATANTE_ID, pjpf.ID);
                    }
                }

                #region BLOQUEIO

                bool ReceitaIrregular = false, ReceitaInativa = false, SintegraNaoHabilitado = false;

                if (pjpf.PJPF_TIPO == 1)
                {
                    ReceitaInativa        = (!String.IsNullOrEmpty(roboReceita.Data.SituacaoCadastral) && roboReceita.Data.SituacaoCadastral.ToUpper() != "ATIVA");
                    SintegraNaoHabilitado = (!String.IsNullOrEmpty(roboSintegra.Data.SituacaoCadastral) && roboSintegra.Data.SituacaoCadastral == "HABILITADO ATIVO" && roboSintegra.Data.SituacaoCadastral == "HABILITADO");
                }
                else
                {
                    ReceitaIrregular = (!String.IsNullOrEmpty(roboReceitaCpf.Data.SituacaoCadastral) && roboReceitaCpf.Data.SituacaoCadastral.ToUpper() != "REGULAR");
                }

                SOLICITACAO          solicitacao = new SOLICITACAO();
                SOLICITACAO_BLOQUEIO bloq        = new SOLICITACAO_BLOQUEIO();

                if (ReceitaInativa || SintegraNaoHabilitado || ReceitaIrregular)
                {
                    var BloqManual = db.WFD_CONTRATANTE_CONFIG.FirstOrDefault(x => x.CONTRATANTE_ID == pjpf.CONTRATANTE_ID).BLOQUEIO_MANUAL;
                    if (!BloqManual)
                    {
                        GeraBloqueioAutomatico(db, pjpf, solicitacao, bloq);
                    }
                }

                #endregion

                if (pjpf.ROBO.RF_CONSULTA_DTHR != null && pjpf.ROBO.SINT_CONSULTA_DTHR != null && pjpf.ROBO.SN_CONSULTA_DTHR != null)
                {
                    pjpf.ROBO_EXECUTADO = true;
                }
                if (pjpf.ROBO.RF_CONTADOR_TENTATIVA >= 3 && pjpf.ROBO.SINT_CONTADOR_TENTATIVA >= 3 && pjpf.ROBO.SN_CONTADOR_TENTATIVA >= 3)
                {
                    pjpf.ROBO_TENTATIVAS_EXCEDIDAS = true;
                }

                ContratanteId   = pjpf.CONTRATANTE_ID;
                DataSolicitacao = (DateTime)pjpf.DT_SOLICITACAO_ROBO;

                atualizaPJPFBase(db, pjpf);

                db.Entry(pjpf).State = EntityState.Modified;
                db.SaveChanges();

                //ATUALIZA TRAMITE SE HOUVER CRIAÇÃO DE BLOQUEIO
                if (ReceitaInativa || SintegraNaoHabilitado)
                {
                    int papel = db.WFL_PAPEL.FirstOrDefault(x => x.CONTRATANTE_ID == pjpf.CONTRATANTE_ID && x.PAPEL_TP_ID == 10).ID;
                    _tramite.AtualizarTramite(pjpf.CONTRATANTE_ID, solicitacao.ID, solicitacao.FLUXO_ID, papel, 2, null);
                }
            }
            catch (DbEntityValidationException e)
            {
                foreach (var eve in e.EntityValidationErrors)
                {
                    foreach (var ve in eve.ValidationErrors)
                    {
                    }
                }
            }
            catch (Exception ex)
            {
                Log.Error(string.Format("Error ao percorrer a lista 'lstFornecedorRobo' exception: {0}", ex));
            }
        }
Example #17
0
        public ActionResult Index(int solicitacaoID)
        {
            try
            {
                //TODO: Nelson Neto - RETIRAR OS COMENTÁRIOS
                //int idSolicitacao = 124;
                int solicitacaoTipoID = 1;
                int papelID           = 1;
                var contratanteID     = (int)Geral.PegaAuthTicket("ContratanteId");

                ViewBag.Fluxo  = solicitacaoTipoID;
                ViewBag.Bancos = _bancoBP.ListarTodosPorNome();

                #region Ficha Cadastral

                FichaCadastralWebForLinkVM modelo = new FichaCadastralWebForLinkVM
                {
                    DadosBancarios        = new List <DadosBancariosVM>(),
                    DadosContatos         = new List <DadosContatoVM>(),
                    SolicitacaoFornecedor =
                        new SolicitacaoFornecedorVM {
                        Documentos = new List <SolicitacaoDocumentosVM>()
                    },
                    Aprovacao   = new AprovacaoVM(),
                    Solicitacao = new SolicitacaoVM {
                        Fluxo = new FluxoVM()
                    },
                    DadosBloqueio      = new DadosBloqueioVM(),
                    FornecedorRobo     = new FornecedorRoboVM(),
                    FornecedoresUnspsc = new List <FornecedorUnspscVM>()
                };

                #region BPs

                SOLICITACAO solicitacao = _solicitacaoService.BuscarPorSolicitacaoId(solicitacaoID);
                if (solicitacao == null)
                {
                    throw new Exception(string.Format("Solicitação com id {0} inexistente.", solicitacaoID));
                }
                SolicitacaoCadastroFornecedor cadastroPJPF = solicitacao.SolicitacaoCadastroFornecedor.FirstOrDefault();
                List <SolicitacaoModificacaoDadosBancario> cadastroBanco    = solicitacao.SolicitacaoModificacaoDadosBancario.ToList();
                List <SolicitacaoModificacaoDadosContato>  cadastroContatos = solicitacao.SolicitacaoModificacaoDadosContato.ToList();

                #endregion

                FichaCadastralWebForLinkVM fichaCadastralVM = new FichaCadastralWebForLinkVM()
                {
                    ID                      = solicitacao.ID,
                    ContratanteID           = solicitacao.CONTRATANTE_ID,
                    ContratanteFornecedorID = 0,
                    NomeEmpresa             = cadastroPJPF != null
                        ? cadastroPJPF.RAZAO_SOCIAL
                        : string.Empty,
                    RazaoSocial  = cadastroPJPF.RAZAO_SOCIAL,
                    NomeFantasia = cadastroPJPF.NOME_FANTASIA,
                    //CNAE = cadastroPJPF.CNAE,
                    CNPJ_CPF           = cadastroPJPF.CNPJ ?? cadastroPJPF.CPF,
                    InscricaoEstadual  = cadastroPJPF.INSCR_ESTADUAL,
                    InscricaoMunicipal = cadastroPJPF.INSCR_MUNICIPAL,
                    TipoLogradouro     = cadastroPJPF.TP_LOGRADOURO,
                    Endereco           = cadastroPJPF.ENDERECO,
                    Numero             = cadastroPJPF.NUMERO,
                    Complemento        = cadastroPJPF.COMPLEMENTO,
                    Cep            = cadastroPJPF.CEP,
                    Bairro         = cadastroPJPF.BAIRRO,
                    Cidade         = cadastroPJPF.CIDADE,
                    Estado         = cadastroPJPF.UF,
                    Pais           = cadastroPJPF.PAIS,
                    Observacao     = cadastroPJPF.OBSERVACAO,
                    TipoFornecedor = cadastroPJPF.PJPF_TIPO,
                    DadosBancarios = cadastroBanco.Select(x => new DadosBancariosVM()
                    {
                        Agencia             = x.AGENCIA,
                        Digito              = x.AG_DV,
                        Banco               = x.BANCO_ID,
                        ContaCorrente       = x.CONTA,
                        ContaCorrenteDigito = x.CONTA_DV,
                        NomeBanco           = x.T_BANCO.BANCO_NM,
                    }).ToList(),
                    DadosContatos = cadastroContatos.Select(x => new DadosContatoVM()
                    {
                        Celular      = x.CELULAR,
                        ContatoID    = x.CONTATO_PJPF_ID ?? 0,
                        EmailContato = x.EMAIL,
                        NomeContato  = x.NOME,
                        Telefone     = x.TELEFONE
                    }).ToList()
                };

                #endregion


                List <QUESTIONARIO> questionarioList = _cadastroUnicoBP.BuscarPorIdContratante(contratanteID);
                foreach (QUESTIONARIO questionario in questionarioList)
                {
                    List <QUESTIONARIO_ABA> abasQuestionario = questionario
                                                               .QIC_QUEST_ABA
                                                               .OrderBy(x => x.ORDEM)
                                                               .ToList();
                    List <AbaVM> questionarioAbas = new List <AbaVM>();
                    foreach (QUESTIONARIO_ABA aba in abasQuestionario)
                    {
                        List <QUESTIONARIO_PERGUNTA> perguntasAba = aba
                                                                    .QIC_QUEST_ABA_PERG
                                                                    .OrderBy(x => x.ORDEM)
                                                                    .ToList();
                        List <PerguntaVM> abaPerguntas = new List <PerguntaVM>();
                        foreach (QUESTIONARIO_PERGUNTA pergunta in perguntasAba)
                        {
                            QUESTIONARIO_PAPEL papelPergunta = pergunta
                                                               .QIC_QUEST_ABA_PERG_PAPEL
                                                               .FirstOrDefault(x => x.PAPEL_ID == papelID);
                            WFD_INFORM_COMPL resposta = pergunta
                                                        .WFD_INFORM_COMPL
                                                        .FirstOrDefault(x => x.PERG_ID == pergunta.ID);
                            if (papelPergunta.LEITURA)
                            {
                                PerguntaVM perguntaVM = Mapper.Map <PerguntaVM>(pergunta);
                                Mapper.Map <PerguntaVM>(papelPergunta);

                                if (pergunta.TP_DADO == "DOMINIO" && pergunta.DOMINIO == true)
                                {
                                    perguntaVM.DominioList =
                                        Mapper.Map <List <QUESTIONARIO_RESPOSTA>, List <SelectListItem> >(pergunta
                                                                                                          .QIC_QUEST_ABA_PERG_RESP
                                                                                                          .OrderBy(x => x.ORDEM).ToList());

                                    perguntaVM.DominioList.Insert(0,
                                                                  new SelectListItem()
                                    {
                                        Value    = "0",
                                        Text     = "--Selecione",
                                        Selected = true
                                    });
                                    perguntaVM.DominioListId = !string.IsNullOrEmpty(perguntaVM.Resposta)
                                        ? int.Parse(perguntaVM.Resposta)
                                        : 0;
                                }

                                if (pergunta.PERG_PAI != null)
                                {
                                    int pergPai = pergunta.PERG_PAI ?? 0;
                                    WFD_INFORM_COMPL informaCompl = _informacaoComplementarBP.BuscarPorPerguntaId(pergPai);

                                    //TODO: Validar LEITURA
                                    ///Validar se pode ser desbloqueado por resposta do pai
                                    /// pelo papel
                                    /// pela resposta anterior
                                    perguntaVM.Leitura = informaCompl != null;

                                    perguntaVM.PaiRespondido = informaCompl != null
                                        ? informaCompl.PERG_ID
                                        : 0;
                                }

                                //perguntaVM.Leitura = papelPergunta.
                                abaPerguntas.Add(perguntaVM);
                            }
                        }
                        //Mapear Lista de aba com Modelo de aba
                        AbaVM abaModelo = Mapper.Map <QUESTIONARIO_ABA, AbaVM>(aba);
                        abaModelo.PerguntaList = abaPerguntas;
                        questionarioAbas.Add(abaModelo);
                    }
                    //Mapear Lista de Questionários com Modelo de Questionários
                    QuestionarioVM questionarioModelo = Mapper.Map <QUESTIONARIO, QuestionarioVM>(questionario);
                    questionarioModelo.AbaList = questionarioAbas;
                    fichaCadastralVM.Questionarios.QuestionarioDinamicoList.Add(questionarioModelo);
                }
                return(View(fichaCadastralVM));
            }
            catch (Exception ex)
            {
                Log.Error(ex);
                ViewBag.Message = ex.Message;
                return(View(new FichaCadastralWebForLinkVM()));
            }
        }
Example #18
0
        public static void PopularAcompanhamentoPreencheStatusRobo(this ControleSolicitacaoController controller, FichaCadastralWebForLinkVM modelo, SOLICITACAO solicitacao, int tpFluxoId)
        {
            ROBO fornecedorRobo;

            modelo.RoboReceita  = "Aguardando...";
            modelo.RoboSintegra = "Aguardando...";
            modelo.RoboSimples  = "Aguardando...";

            switch (tpFluxoId)
            {
            case (int)EnumTiposFluxo.CadastroFornecedorNacional:
            case (int)EnumTiposFluxo.CadastroFornecedorNacionalDireto:
                fornecedorRobo = solicitacao.PJPF_BASE_ID != null ? solicitacao.FORNECEDORBASE.ROBO : solicitacao.ROBO.FirstOrDefault();
                if (fornecedorRobo != null)
                {
                    modelo.RoboReceita  = (fornecedorRobo.RF_CONSULTA_DTHR != null) ? fornecedorRobo.RF_SIT_CADASTRAL_CNPJ : "Aguardando...";
                    modelo.RoboSintegra = (fornecedorRobo.SINT_CONSULTA_DTHR != null) ? fornecedorRobo.SINT_IE_SITU_CADASTRAL : "Aguardando...";
                    modelo.RoboSimples  = (fornecedorRobo.RF_CONSULTA_DTHR != null) ? fornecedorRobo.SIMPLES_NACIONAL_SITUACAO : "Aguardando...";

                    modelo.FornecedorRobo.SimplesNacionalSituacao = fornecedorRobo.SIMPLES_NACIONAL_SITUACAO == null ? "" : fornecedorRobo.SIMPLES_NACIONAL_SITUACAO;
                }
                break;

            case (int)EnumTiposFluxo.CadastroFornecedorPF:
            case (int)EnumTiposFluxo.CadastroFornecedorPFDireto:
                fornecedorRobo = solicitacao.PJPF_BASE_ID != null ? solicitacao.FORNECEDORBASE.ROBO : solicitacao.ROBO.FirstOrDefault();
                if (fornecedorRobo != null)
                {
                    modelo.RoboReceita  = (fornecedorRobo.RF_CONSULTA_DTHR != null) ? fornecedorRobo.RF_SIT_CADASTRAL_CNPJ : "Aguardando...";
                    modelo.RoboSintegra = "---";
                    modelo.RoboSimples  = "---";

                    modelo.FornecedorRobo.SimplesNacionalSituacao = fornecedorRobo.SIMPLES_NACIONAL_SITUACAO == null ? "" : fornecedorRobo.SIMPLES_NACIONAL_SITUACAO;
                }
                break;

            case (int)EnumTiposFluxo.CadastroFornecedorEstrangeiro:
                modelo.RoboReceita  = "---";
                modelo.RoboSintegra = "---";
                modelo.RoboSimples  = "---";
                break;

            case (int)EnumTiposFluxo.AmpliacaoFornecedor:
            case (int)EnumTiposFluxo.BloqueioFornecedor:
            case (int)EnumTiposFluxo.DesbloqueioFornecedor:
            case (int)EnumTiposFluxo.ModificacaoDadosBancarios:
            case (int)EnumTiposFluxo.ModificacaoDadosContato:
            case (int)EnumTiposFluxo.ModificacoesGerais:
            case (int)EnumTiposFluxo.ModificacaoQuestionarioDinamico:

                //robo = solicitacao.Fornecedor != null? solicitacao.Fornecedor.ROBO: solicitacao.ROBO.FirstOrDefault();
                fornecedorRobo = solicitacao.PJPF_BASE_ID != null ? solicitacao.FORNECEDORBASE.ROBO : solicitacao.Fornecedor.ROBO;

                if (fornecedorRobo != null)
                {
                    modelo.RoboReceita  = (fornecedorRobo.RF_CONSULTA_DTHR != null) ? fornecedorRobo.RF_SIT_CADASTRAL_CNPJ : "Aguardando...";
                    modelo.RoboSintegra = (fornecedorRobo.SINT_CONSULTA_DTHR != null) ? fornecedorRobo.SINT_IE_SITU_CADASTRAL : "Aguardando...";
                    modelo.RoboSimples  = (fornecedorRobo.RF_CONSULTA_DTHR != null) ? fornecedorRobo.SIMPLES_NACIONAL_SITUACAO : "Aguardando...";

                    modelo.FornecedorRobo.SimplesNacionalSituacao = fornecedorRobo.SIMPLES_NACIONAL_SITUACAO == null ? "" : fornecedorRobo.SIMPLES_NACIONAL_SITUACAO;
                }
                break;
            }
        }
Example #19
0
        public static void PopularAcompanhamentoBloqueio(this ControleSolicitacaoController controller, FichaCadastralWebForLinkVM modelo, SOLICITACAO solicitacao)
        {
            Fornecedor fornecedor = solicitacao.Fornecedor;

            if (solicitacao.SOLICITACAO_BLOQUEIO != null && solicitacao.SOLICITACAO_BLOQUEIO.Count > 0)
            {
                foreach (var item in solicitacao.SOLICITACAO_BLOQUEIO)
                {
                    string lanc = item.BLQ_LANCAMENTO_TODAS_EMP != null ? (bool)item.BLQ_LANCAMENTO_TODAS_EMP ? "1" : "2" : null;
                    modelo.DadosBloqueio = new DadosBloqueioVM
                    {
                        ID                = item.ID,
                        Compra            = (bool)item.BLQ_COMPRAS_TODAS_ORG_COMPRAS,
                        ContratanteID     = solicitacao.CONTRATANTE_ID,
                        FornecedorID      = solicitacao.PJPF_ID,
                        Lancamento        = lanc,
                        Motivo            = item.BLQ_QUALIDADE_FUNCAO_BQL_ID,
                        MotivoQualidade   = item.TipoDeFuncaoDuranteBloqueio != null ? item.TipoDeFuncaoDuranteBloqueio.FUNCAO_BLOQ_DSC : string.Empty,
                        MotivoSolicitacao = item.BLQ_MOTIVO_DSC,
                        SolicitacaoID     = solicitacao.ID
                    };
                }

                modelo.ContratanteID        = solicitacao.CONTRATANTE_ID;
                modelo.Solicitacao.Fluxo.ID = solicitacao.FLUXO_ID;

                if (fornecedor != null)
                {
                    modelo.CategoriaNome = fornecedor
                                           .WFD_CONTRATANTE_PJPF.First(x => x.CONTRATANTE_ID == solicitacao.CONTRATANTE_ID)
                                           .WFD_PJPF_CATEGORIA.DESCRICAO;
                    Mapeamento.PopularDadosReceita(modelo, fornecedor);
                    modelo.TipoFornecedor = (int)fornecedor.TIPO_PJPF_ID;
                }
                else
                {
                    FORNECEDORBASE fornecedorBase = solicitacao.FORNECEDORBASE;
                    modelo.CategoriaNome = fornecedorBase.WFD_PJPF_CATEGORIA.DESCRICAO;
                    modelo.CNPJ_CPF      = fornecedorBase.PJPF_TIPO == 3
                        ? Convert.ToUInt64(fornecedorBase.CPF).ToString(@"000\.000\.000\-00")
                        : Convert.ToUInt64(fornecedorBase.CNPJ).ToString(@"00\.000\.000\/0000\-00");
                    modelo.RazaoSocial = fornecedorBase.PJPF_TIPO == 3
                        ? fornecedorBase.NOME
                        : fornecedorBase.RAZAO_SOCIAL;
                    modelo.NomeFantasia = fornecedorBase.NOME_FANTASIA;
                    //modelo.CNAE = fornecedorBase.CNAE;
                    modelo.InscricaoEstadual  = fornecedorBase.INSCR_ESTADUAL;
                    modelo.InscricaoMunicipal = fornecedorBase.INSCR_MUNICIPAL;
                    modelo.TipoFornecedor     = fornecedorBase.PJPF_TIPO;
                }
            }

            if (fornecedor != null)
            {
                controller.FornecedorRobo(modelo, RetornaFornecedor(solicitacao));
            }
        }
Example #20
0
        public ActionResult FornecedoresBloqueioFrm(FichaCadastralWebForLinkVM model, string rdLancamento, string rdCompras, string txtAreaMotivoBloqueio, int ContratanteID, int ContratanteFornecedorID, int?ID, int?bloqueioMotivoQualidade)
        {
            if (rdLancamento == null)
            {
                ModelState.AddModelError("FornecedoresBloqueioValidation", "Informe ao menos um bloqueio de lançamento!");
            }

            if (ContratanteID == 0)
            {
                ModelState.AddModelError("FornecedoresBloqueioValidation", "Ocorreu um error ao tentar salvar o bloqueio. Por favor, tente mais tarde.");
            }

            if (ContratanteFornecedorID == 0)
            {
                ModelState.AddModelError("FornecedoresBloqueioValidation", "Ocorreu um error ao tentar salvar o bloqueio. Por favor, tente mais tarde.");
            }

            if (ID == 0 || ID == null)
            {
                ModelState.AddModelError("FornecedoresBloqueioValidation", "Ocorreu um error ao tentar salvar o bloqueio. Por favor, tente mais tarde.");
            }

            if (ModelState.IsValid)
            {
                int         contratanteId = (int)Geral.PegaAuthTicket("ContratanteId");
                int         UsuarioId     = (int)Geral.PegaAuthTicket("UsuarioId");
                SOLICITACAO solicitacao   = new SOLICITACAO();

                try
                {
                    int FluxoId = 8;

                    if (contratanteId != 0)
                    {
                        solicitacao.CONTRATANTE_ID = contratanteId;
                    }
                    solicitacao.USUARIO_ID = UsuarioId;
                    solicitacao.PJPF_ID    = model.ID;

                    SOLICITACAO_BLOQUEIO bloqueio = new SOLICITACAO_BLOQUEIO
                    {
                        SOLICITACAO_ID                = solicitacao.ID,
                        BLQ_LANCAMENTO_TODAS_EMP      = rdLancamento == "1",
                        BLQ_LANCAMENTO_EMP            = rdLancamento == "2",
                        BLQ_COMPRAS_TODAS_ORG_COMPRAS = !string.IsNullOrEmpty(rdCompras),
                        BLQ_QUALIDADE_FUNCAO_BQL_ID   = bloqueioMotivoQualidade,
                        BLQ_MOTIVO_DSC                = txtAreaMotivoBloqueio,
                    };
                    _solicitacaoBP.CriarSolicitacaoBloqueio(solicitacao, bloqueio);
                    _tramite.AtualizarTramite(model.ContratanteID, solicitacao.ID, FluxoId, 1, 2, UsuarioId);
                }
                catch (Exception ex)
                {
                    if (solicitacao.ID != 0)
                    {
                        Db.WFD_SOLICITACAO.Remove(solicitacao);
                        Db.SaveChanges();
                        Log.Error(ex);
                        return(RedirectToAction("FornecedoresLst", "Fornecedores", new { MensagemSucesso = "Ocorreu um error para realizar o bloqueio solicitado. Por favor, tente mais tarde." }));
                    }
                }
                return(RedirectToAction("FornecedoresLst", "Fornecedores", new { MensagemSucesso = string.Format("Solicitação {0} de Bloqueio realizado com Sucesso!", solicitacao.ID) }));
            }
            return(View());
        }
Example #21
0
        public static void PopularAcompanhamentoDesbloqueio(this ControleSolicitacaoController controller, FichaCadastralWebForLinkVM modelo, SOLICITACAO solicitacao)
        {
            Fornecedor fornecedor = solicitacao.Fornecedor;

            if (solicitacao.WFD_SOL_DESBLOQ != null && solicitacao.WFD_SOL_DESBLOQ.Count > 0)
            {
                foreach (var item in solicitacao.WFD_SOL_DESBLOQ)
                {
                    string lanc = item.BLQ_LANCAMENTO_TODAS_EMP != null ? (bool)item.BLQ_LANCAMENTO_TODAS_EMP ? "1" : "2" : null;
                    modelo.DadosBloqueio = new DadosBloqueioVM
                    {
                        ID                = item.ID,
                        Compra            = (bool)item.BLQ_COMPRAS_TODAS_ORG_COMPRAS,
                        ContratanteID     = solicitacao.CONTRATANTE_ID,
                        FornecedorID      = solicitacao.PJPF_ID,
                        Lancamento        = lanc,
                        Motivo            = item.BLQ_QUALIDADE_FUNCAO_BQL_ID,
                        MotivoQualidade   = item.WFD_T_FUNCAO_BLOQUEIO != null ? item.WFD_T_FUNCAO_BLOQUEIO.FUNCAO_BLOQ_DSC : string.Empty,
                        MotivoSolicitacao = item.BLQ_MOTIVO_DSC,
                        SolicitacaoID     = solicitacao.ID
                    };
                }

                modelo.ContratanteID        = solicitacao.CONTRATANTE_ID;
                modelo.Solicitacao.Fluxo.ID = solicitacao.FLUXO_ID;

                if (fornecedor != null)
                {
                    modelo.CategoriaNome = fornecedor
                                           .WFD_CONTRATANTE_PJPF.First(x => x.CONTRATANTE_ID == solicitacao.CONTRATANTE_ID)
                                           .WFD_PJPF_CATEGORIA.DESCRICAO;

                    Mapeamento.PopularDadosReceita(modelo, fornecedor);

                    modelo.TipoFornecedor = (int)fornecedor.TIPO_PJPF_ID;
                }
            }

            if (fornecedor != null)
            {
                controller.FornecedorRobo(modelo, RetornaFornecedor(solicitacao));
            }
        }
Example #22
0
        public static void PopularAcompanhamentoModificacaoUnspsc(this ControleSolicitacaoController controller, FichaCadastralWebForLinkVM modelo, SOLICITACAO solicitacao)
        {
            Fornecedor fornecedor = solicitacao.Fornecedor;

            modelo.CategoriaNome = solicitacao.Fornecedor.WFD_CONTRATANTE_PJPF
                                   .First(x => x.CONTRATANTE_ID == solicitacao.CONTRATANTE_ID)
                                   .WFD_PJPF_CATEGORIA.DESCRICAO;
            modelo.ContratanteID        = solicitacao.CONTRATANTE_ID;
            modelo.Solicitacao.Fluxo.ID = solicitacao.FLUXO_ID;
            Mapeamento.PopularDadosReceita(modelo, fornecedor);
            controller.FornecedorRobo(modelo, RetornaFornecedor(solicitacao));
        }
Example #23
0
        public static void PopularAcompanhamentoQuestionarioDinamico(this ControleSolicitacaoController controller, FichaCadastralWebForLinkVM modelo, SOLICITACAO solicitacao)
        {
            Fornecedor fornecedor = solicitacao.Fornecedor;

            modelo.CategoriaNome          = solicitacao.Fornecedor.WFD_CONTRATANTE_PJPF.First(x => x.CONTRATANTE_ID == solicitacao.CONTRATANTE_ID).WFD_PJPF_CATEGORIA.DESCRICAO;
            modelo.CategoriaId            = fornecedor.WFD_CONTRATANTE_PJPF.FirstOrDefault(x => x.CONTRATANTE_ID == solicitacao.CONTRATANTE_ID).CATEGORIA_ID ?? 0;
            modelo.Solicitacao.Fluxo.ID   = solicitacao.FLUXO_ID;
            modelo.Solicitacao.Fluxo.Nome = solicitacao.Fluxo.FLUXO_NM;
            modelo.TipoFornecedor         = (int)fornecedor.TIPO_PJPF_ID;
            Mapeamento.PopularDadosReceita(modelo, fornecedor);
            Mapeamento.PopularEndereco(modelo, fornecedor);
        }
        public void IncluirFornecedorIndividual(string documento)
        {
            SolicitacaoCadastroFornecedor solicitacaoCadastroFornecedor = _solicitacaoCadastroRepository.Buscar(x => x.CNPJ == documento || x.CPF == documento);
            SOLICITACAO solicitacao    = solicitacaoCadastroFornecedor.WFD_SOLICITACAO;
            ROBO        roboFornecedor = solicitacaoCadastroFornecedor.WFD_PJPF_ROBO;

            Domain.Models.Fornecedor fornecedor = new Domain.Models.Fornecedor
            {
                CONTRATANTE_ID  = solicitacao.CONTRATANTE_ID,
                TIPO_PJPF_ID    = solicitacaoCadastroFornecedor.PJPF_TIPO,
                RAZAO_SOCIAL    = solicitacaoCadastroFornecedor.RAZAO_SOCIAL,
                NOME_FANTASIA   = solicitacaoCadastroFornecedor.NOME_FANTASIA,
                NOME            = solicitacaoCadastroFornecedor.NOME,
                CNPJ            = solicitacaoCadastroFornecedor.CNPJ,
                CPF             = solicitacaoCadastroFornecedor.CPF,
                CNAE            = solicitacaoCadastroFornecedor.CNAE,
                INSCR_ESTADUAL  = solicitacaoCadastroFornecedor.INSCR_ESTADUAL,
                INSCR_MUNICIPAL = solicitacaoCadastroFornecedor.INSCR_MUNICIPAL,
                ENDERECO        = solicitacaoCadastroFornecedor.ENDERECO,
                NUMERO          = solicitacaoCadastroFornecedor.NUMERO,
                COMPLEMENTO     = solicitacaoCadastroFornecedor.COMPLEMENTO,
                BAIRRO          = solicitacaoCadastroFornecedor.BAIRRO,
                CIDADE          = solicitacaoCadastroFornecedor.CIDADE,
                UF    = solicitacaoCadastroFornecedor.UF,
                CEP   = solicitacaoCadastroFornecedor.CEP,
                PAIS  = solicitacaoCadastroFornecedor.PAIS,
                ATIVO = true,
            };
            if (roboFornecedor != null && solicitacaoCadastroFornecedor.PJPF_TIPO != 2)
            {
                fornecedor.ROBO_ID = roboFornecedor.ID;
            }

            #region Unspsc
            foreach (var item in solicitacao.WFD_SOL_UNSPSC)
            {
                fornecedor.FornecedorServicoMaterialList.Add(new FORNECEDOR_UNSPSC
                {
                    SOLICITACAO_ID = solicitacao.ID,
                    UNSPSC_ID      = item.UNSPSC_ID,
                    DT_INCLUSAO    = DateTime.Now,
                    WFD_PJPF       = fornecedor
                });
            }
            #endregion

            WFD_CONTRATANTE_PJPF contratanteFornecedor = new WFD_CONTRATANTE_PJPF
            {
                CATEGORIA_ID       = solicitacaoCadastroFornecedor.CATEGORIA_ID,
                CONTRATANTE_ID     = solicitacao.CONTRATANTE_ID,
                PJPF_ID            = fornecedor.ID,
                PJPF_COD_ERP       = solicitacaoCadastroFornecedor.COD_PJPF_ERP,
                PJPF_STATUS_ID     = 1,
                PJPF_STATUS_ID_SOL = solicitacao.ID,
                TP_PJPF            = 2
            };

            #region Bancos
            foreach (var item in solicitacao.WFD_SOL_MOD_BANCO)
            {
                contratanteFornecedor.WFD_PJPF_BANCO.Add(new FORNECEDOR_BANCO
                {
                    CONTRATANTE_PJPF_ID = contratanteFornecedor.ID,
                    BANCO_ID            = item.BANCO_ID,
                    AGENCIA             = item.AGENCIA,
                    AG_DV        = item.AG_DV,
                    CONTA        = item.CONTA,
                    CONTA_DV     = item.CONTA_DV,
                    ATIVO        = true,
                    DATA_UPLOAD  = item.DATA_UPLOAD,
                    NOME_ARQUIVO = item.NOME_ARQUIVO,
                    ARQUIVO_ID   = item.ARQUIVO_ID
                });
            }
            #endregion

            #region Endereços
            foreach (var solicitacaoModificacaoEndereco in solicitacao.WFD_SOL_MOD_ENDERECO)
            {
                contratanteFornecedor.WFD_PJPF_ENDERECO.Add(new FORNECEDOR_ENDERECO
                {
                    BAIRRO              = solicitacaoModificacaoEndereco.BAIRRO,
                    CEP                 = solicitacaoModificacaoEndereco.CEP,
                    CIDADE              = solicitacaoModificacaoEndereco.CIDADE,
                    COMPLEMENTO         = solicitacaoModificacaoEndereco.COMPLEMENTO,
                    ENDERECO            = solicitacaoModificacaoEndereco.ENDERECO,
                    NUMERO              = solicitacaoModificacaoEndereco.NUMERO,
                    PAIS                = solicitacaoModificacaoEndereco.PAIS,
                    T_UF                = solicitacaoModificacaoEndereco.T_UF,
                    TP_ENDERECO_ID      = solicitacaoModificacaoEndereco.TP_ENDERECO_ID,
                    UF                  = solicitacaoModificacaoEndereco.UF,
                    CONTRATANTE_PJPF_ID = contratanteFornecedor.ID
                });
            }
            #endregion

            #region Contatos

            foreach (var item in solicitacao.WFD_SOL_MOD_CONTATO)
            {
                contratanteFornecedor.WFD_PJPF_CONTATOS.Add(new FORNECEDOR_CONTATOS
                {
                    CONTRAT_ORG_COMPRAS_ID = solicitacao.WFD_CONTRATANTE.WFD_CONTRATANTE_ORG_COMPRAS.First().ID,
                    CONTRATANTE_PJPF_ID    = contratanteFornecedor.ID,
                    NOME     = item.NOME,
                    EMAIL    = item.EMAIL,
                    CELULAR  = item.CELULAR,
                    TELEFONE = item.TELEFONE
                });
            }

            #endregion

            #region Documentos
            if (solicitacaoCadastroFornecedor.PJPF_TIPO != 2)
            {
                foreach (SOLICITACAO_DOCUMENTOS item in solicitacao.WFD_SOL_DOCUMENTOS)
                {
                    if (item.ARQUIVO_ID != null)
                    {
                        contratanteFornecedor.WFD_PJPF_DOCUMENTOS.Add(new FORNECEDOR_DOCUMENTOS
                        {
                            CONTRATANTE_PJPF_ID    = contratanteFornecedor.ID,
                            ARQUIVO_ID             = item.ARQUIVO_ID,
                            DATA_VENCIMENTO        = item.DATA_VENCIMENTO,
                            DESCRICAO_DOCUMENTO_ID = item.DESCRICAO_DOCUMENTO_ID,
                            LISTA_DOCUMENTO_ID     = item.LISTA_DOCUMENTO_ID,
                            OBRIGATORIO            = item.OBRIGATORIO,
                            EXIGE_VALIDADE         = item.EXIGE_VALIDADE,
                            PERIODICIDADE_ID       = item.PERIODICIDADE_ID,
                            SOLICITACAO_ID         = solicitacao.ID,
                            PJPF_ID = fornecedor.ID
                        });
                    }
                }
            }
            #endregion

            #region Informações Complementares
            foreach (var item in solicitacao.WFD_INFORM_COMPL)
            {
                contratanteFornecedor.WFD_PJPF_INFORM_COMPL.Add(new FORNECEDOR_INFORM_COMPL
                {
                    PERG_ID             = item.PERG_ID,
                    RESPOSTA            = item.RESPOSTA,
                    CONTRATANTE_PJPF_ID = contratanteFornecedor.ID
                });
            }
            #endregion


            CONTRATANTE contratanteAncora = CriarContratante(documento, solicitacaoCadastroFornecedor);

            fornecedor.WFD_CONTRATANTE_PJPF.Add(contratanteFornecedor);
            contratanteAncora.WFD_CONTRATANTE_PJPF.Add(contratanteFornecedor);

            _fornecedorRepository.Inserir(fornecedor);
            _contratanteRepository.Inserir(contratanteAncora);
            _unitOfWork.Finalizar();
            CriacaoUsuarioPadrao(documento, solicitacao.WFD_SOL_MOD_CONTATO.FirstOrDefault().EMAIL);
        }
Example #25
0
        public static void PopularAcompanhamentoModificacaoEndereco(this ControleSolicitacaoController controller, FichaCadastralWebForLinkVM modelo, SOLICITACAO solicitacao)
        {
            Fornecedor fornecedor = solicitacao.Fornecedor;

            modelo.DadosEnderecos = Mapper.Map <List <SOLICITACAO_MODIFICACAO_ENDERECO>, List <DadosEnderecosVM> >(solicitacao.WFD_SOL_MOD_ENDERECO.ToList());

            modelo.SolicitacaoFornecedor.Solicitacao = true;

            // Popula a view model FichaCadastralVM
            if (fornecedor != null)
            {
                modelo.Solicitacao.Fluxo.ID   = solicitacao.FLUXO_ID;
                modelo.Solicitacao.Fluxo.Nome = solicitacao.Fluxo.FLUXO_NM;
                Mapeamento.PopularDadosReceita(modelo, fornecedor);
                Mapeamento.PopularEndereco(modelo, fornecedor);
                modelo.TipoFornecedor = (int)fornecedor.TIPO_PJPF_ID;
            }
            controller.FornecedorRobo(modelo, solicitacao);
        }
Example #26
0
        public static void PopularAcompanhamentoAtualizacaoDocumento(this ControleSolicitacaoController controller, FichaCadastralWebForLinkVM modelo, SOLICITACAO solicitacao)
        {
            modelo.SolicitacaoFornecedor.Solicitacao = true;

            //Mapear os Documentos
            modelo.SolicitacaoFornecedor.Documentos =
                Mapper.Map <List <SolicitacaoDeDocumentos>, List <SolicitacaoDocumentosVM> >(solicitacao.SolicitacaoDeDocumentos.Where(x => x.ARQUIVO_ID != null).ToList());

            Fornecedor fornecedor = solicitacao.Fornecedor;

            modelo.CategoriaNome        = solicitacao.Fornecedor.WFD_CONTRATANTE_PJPF.First(x => x.CONTRATANTE_ID == solicitacao.CONTRATANTE_ID).WFD_PJPF_CATEGORIA.DESCRICAO;
            modelo.ContratanteID        = solicitacao.CONTRATANTE_ID;
            modelo.Solicitacao.Fluxo.ID = solicitacao.FLUXO_ID;

            Mapeamento.PopularDadosReceita(modelo, fornecedor);

            modelo.TipoFornecedor = fornecedor.TIPO_PJPF_ID ?? 0;

            controller.FornecedorRobo(modelo, RetornaFornecedor(solicitacao));
        }
Example #27
0
        private void PopularSolicitacaoEmAprovacao(int contratanteId, int fornecedorId, int?usuarioId, int fluxoId, SOLICITACAO solicitacao)
        {
            if (contratanteId != 0)
            {
                solicitacao.CONTRATANTE_ID = contratanteId;
            }

            solicitacao.FLUXO_ID              = fluxoId;                            // Bloqueio
            solicitacao.SOLICITACAO_DT_CRIA   = DateTime.Now;
            solicitacao.SOLICITACAO_STATUS_ID = (int)EnumStatusTramite.EmAprovacao; // EM APROVACAO
            solicitacao.USUARIO_ID            = usuarioId;
            solicitacao.PJPF_ID = fornecedorId;
        }
Example #28
0
        public static void PopularAcompanhamentoNovoFornecedor(this ControleSolicitacaoController controller, FichaCadastralWebForLinkVM modelo, SOLICITACAO solicitacao)
        {
            SolicitacaoCadastroFornecedor solicitacaoCadastroFornecedorNacional = solicitacao.SolicitacaoCadastroFornecedor.FirstOrDefault();

            modelo.DadosEnderecos = Mapper.Map <List <SOLICITACAO_MODIFICACAO_ENDERECO>, List <DadosEnderecosVM> >(solicitacao.WFD_SOL_MOD_ENDERECO.ToList());
            modelo.DadosBancarios = Mapper.Map <List <SolicitacaoModificacaoDadosBancario>, List <DadosBancariosVM> >(solicitacao.SolicitacaoModificacaoDadosBancario.ToList());
            modelo.DadosContatos  = Mapper.Map <List <SolicitacaoModificacaoDadosContato>, List <DadosContatoVM> >(solicitacao.SolicitacaoModificacaoDadosContato.ToList());
            modelo.SolicitacaoFornecedor.Solicitacao = true;

            //Mapear os Documentos
            modelo.SolicitacaoFornecedor.Documentos =
                Mapper.Map <List <SolicitacaoDeDocumentos>, List <SolicitacaoDocumentosVM> >(solicitacao.SolicitacaoDeDocumentos.Where(x => x.ARQUIVO_ID != null).ToList());

            // Popula a view model FichaCadastralVM
            if (solicitacaoCadastroFornecedorNacional != null)
            {
                modelo.CategoriaId            = solicitacaoCadastroFornecedorNacional.CATEGORIA_ID;
                modelo.Solicitacao.Fluxo.ID   = solicitacao.FLUXO_ID;
                modelo.Solicitacao.Fluxo.Nome = solicitacao.Fluxo.FLUXO_NM;
                if (solicitacaoCadastroFornecedorNacional != null)
                {
                    modelo.CategoriaNome = solicitacaoCadastroFornecedorNacional.WFD_PJPF_CATEGORIA.DESCRICAO;
                }
                else
                {
                    modelo.CategoriaNome = solicitacao.Fornecedor.WFD_CONTRATANTE_PJPF.First(x => x.CONTRATANTE_ID == solicitacao.CONTRATANTE_ID).WFD_PJPF_CATEGORIA.DESCRICAO;
                }
                modelo.RazaoSocial = solicitacaoCadastroFornecedorNacional.PJPF_TIPO != 3
                    ? solicitacaoCadastroFornecedorNacional.RAZAO_SOCIAL
                    : solicitacaoCadastroFornecedorNacional.NOME;
                modelo.NomeFantasia = solicitacaoCadastroFornecedorNacional.NOME_FANTASIA;
                //modelo.CNAE = solicitacaoCadastroFornecedorNacional.CNAE;
                modelo.CNPJ_CPF = solicitacaoCadastroFornecedorNacional.PJPF_TIPO == 3
                    ? Convert.ToUInt64(solicitacaoCadastroFornecedorNacional.CPF).ToString(@"000\.000\.000\-00")
                    : Convert.ToUInt64(solicitacaoCadastroFornecedorNacional.CNPJ).ToString(@"00\.000\.000\/0000\-00");
                modelo.InscricaoEstadual  = solicitacaoCadastroFornecedorNacional.INSCR_ESTADUAL;
                modelo.InscricaoMunicipal = solicitacaoCadastroFornecedorNacional.INSCR_MUNICIPAL;
                modelo.TipoFornecedor     = solicitacaoCadastroFornecedorNacional.PJPF_TIPO;
                modelo.Observacao         = solicitacaoCadastroFornecedorNacional.OBSERVACAO;
                modelo.TipoLogradouro     = solicitacaoCadastroFornecedorNacional.TP_LOGRADOURO;
                modelo.Endereco           = solicitacaoCadastroFornecedorNacional.ENDERECO;
                modelo.Numero             = solicitacaoCadastroFornecedorNacional.NUMERO;
                modelo.Complemento        = solicitacaoCadastroFornecedorNacional.COMPLEMENTO;
                modelo.Cep    = solicitacaoCadastroFornecedorNacional.CEP;
                modelo.Bairro = solicitacaoCadastroFornecedorNacional.BAIRRO;
                modelo.Cidade = solicitacaoCadastroFornecedorNacional.CIDADE;
                modelo.Estado = solicitacaoCadastroFornecedorNacional.UF;
                modelo.Pais   = solicitacaoCadastroFornecedorNacional.PAIS;
            }

            // this.FornecedorRobo(modelo, solicitacao);

            if (solicitacaoCadastroFornecedorNacional.WFD_PJPF_ROBO != null)
            {
                modelo.FornecedorRobo.SimplesNacionalSituacao = solicitacaoCadastroFornecedorNacional.WFD_PJPF_ROBO.SIMPLES_NACIONAL_SITUACAO == null
                    ? ""
                    : solicitacaoCadastroFornecedorNacional.WFD_PJPF_ROBO.SIMPLES_NACIONAL_SITUACAO;
            }
        }
Example #29
0
        public void AlterarSolicitacaoParaFinalizado(int solicitacaoId, int solicitacaotatusId)
        {
            SOLICITACAO solicitacao = _solicitacaoRepository.BuscarPorId(solicitacaoId);

            solicitacao.SOLICITACAO_STATUS_ID = solicitacaotatusId;
        }
        public void PreencherFichaCadastral(SOLICITACAO solicitacao, FichaCadastralWebForLinkVM ficha, int TpPapel)
        {
            Contratante contratante = solicitacao.Contratante;
            SolicitacaoCadastroFornecedor solicitacaoCadastroPJPF = solicitacao.SolicitacaoCadastroFornecedor.First();
            SolicitacaoFornecedorVM       solicitacaoFornecedorVM = new SolicitacaoFornecedorVM();

            ficha.TipoFornecedor          = solicitacaoCadastroPJPF.PJPF_TIPO;
            ficha.ContratanteID           = contratante.ID;
            ficha.CategoriaId             = solicitacaoCadastroPJPF.CATEGORIA_ID;
            ficha.ContratanteFornecedorID = solicitacao.CONTRATANTE_ID;
            ficha.SolicitacaoID           = solicitacao.ID;

            ficha.Categoria = new CategoriaFichaVM
            {
                Id   = solicitacaoCadastroPJPF.CATEGORIA_ID,
                Nome = solicitacaoCadastroPJPF.WFD_PJPF_CATEGORIA.CODIGO,
            };

            ficha.Solicitacao = new SolicitacaoVM
            {
                ID    = solicitacao.ID,
                Fluxo = new FluxoVM
                {
                    ID = solicitacao.FLUXO_ID
                }
            };

            switch ((EnumTiposFornecedor)solicitacaoCadastroPJPF.PJPF_TIPO)
            {
            case EnumTiposFornecedor.EmpresaNacional:
                ficha.CNPJ_CPF    = Convert.ToUInt64(solicitacaoCadastroPJPF.CNPJ).ToString(@"00\.000\.000\/0000\-00");
                ficha.RazaoSocial = solicitacaoCadastroPJPF.RAZAO_SOCIAL;
                break;

            case EnumTiposFornecedor.EmpresaEstrangeira:
                ficha.RazaoSocial = solicitacaoCadastroPJPF.RAZAO_SOCIAL;
                break;

            case EnumTiposFornecedor.PessoaFisica:
                ficha.CNPJ_CPF    = Convert.ToUInt64(solicitacaoCadastroPJPF.CPF).ToString(@"000\.000\.000\-00");
                ficha.RazaoSocial = solicitacaoCadastroPJPF.NOME;
                break;
            }

            ficha.NomeFantasia = solicitacaoCadastroPJPF.NOME_FANTASIA;
            //ficha.CNAE = solicitacaoCadastroPJPF.CNAE;
            ficha.InscricaoEstadual  = solicitacaoCadastroPJPF.INSCR_ESTADUAL;
            ficha.InscricaoMunicipal = solicitacaoCadastroPJPF.INSCR_MUNICIPAL;
            ficha.TipoLogradouro     = solicitacaoCadastroPJPF.TP_LOGRADOURO;
            ficha.Endereco           = solicitacaoCadastroPJPF.ENDERECO;
            ficha.Numero             = solicitacaoCadastroPJPF.NUMERO;
            ficha.Complemento        = solicitacaoCadastroPJPF.COMPLEMENTO;
            ficha.Cep        = solicitacaoCadastroPJPF.CEP;
            ficha.Bairro     = solicitacaoCadastroPJPF.BAIRRO;
            ficha.Cidade     = solicitacaoCadastroPJPF.CIDADE;
            ficha.Estado     = solicitacaoCadastroPJPF.UF;
            ficha.Pais       = solicitacaoCadastroPJPF.PAIS;
            ficha.Observacao = solicitacaoCadastroPJPF.OBSERVACAO;

            //Mapear Dados Bancários
            var solicitacoesModBanco = solicitacao.SolicitacaoModificacaoDadosBancario.ToList();

            ficha.DadosBancarios = solicitacoesModBanco.Any()
                ? Mapper.Map <List <SolicitacaoModificacaoDadosBancario>, List <DadosBancariosVM> >(solicitacoesModBanco)
                : new List <DadosBancariosVM>();

            //Mapear Dados de Endereço
            var solicitacoesModEndereco = solicitacao.WFD_SOL_MOD_ENDERECO.ToList();

            if (solicitacaoCadastroPJPF.PJPF_TIPO == 1)
            {
                ficha.DadosEnderecos = solicitacoesModEndereco.Any()
                    ? Mapper.Map <List <SOLICITACAO_MODIFICACAO_ENDERECO>, List <DadosEnderecosVM> >(solicitacoesModEndereco)
                    : new List <DadosEnderecosVM>();
            }
            else
            {
                ficha.DadosEnderecos = solicitacoesModEndereco.Any()
                    ? Mapper.Map <List <SOLICITACAO_MODIFICACAO_ENDERECO>, List <DadosEnderecosVM> >(solicitacoesModEndereco)
                    : new List <DadosEnderecosVM> {
                    new DadosEnderecosVM {
                    }
                };
            }

            //Mapear Dados Contatos
            var solicitacoesModContato = solicitacao.SolicitacaoModificacaoDadosContato.ToList();

            ficha.DadosContatos = solicitacoesModContato.Any()
                ? Mapper.Map <List <SolicitacaoModificacaoDadosContato>, List <DadosContatoVM> >(solicitacoesModContato)
                : new List <DadosContatoVM> {
                new DadosContatoVM()
            };

            if (solicitacao.WFD_SOL_MENSAGEM.Any())
            {
                solicitacaoFornecedorVM.Assunto  = solicitacao.WFD_SOL_MENSAGEM.First().ASSUNTO;
                solicitacaoFornecedorVM.Mensagem = solicitacao.WFD_SOL_MENSAGEM.First().MENSAGEM;
            }

            solicitacaoFornecedorVM.Fornecedores         = new List <SolicitacaoFornecedoresVM>();
            solicitacaoFornecedorVM.SolicitacaoCriacaoID = solicitacao.ID;

            solicitacaoFornecedorVM.Fornecedores = solicitacao.SolicitacaoCadastroFornecedor.Select(x => new SolicitacaoFornecedoresVM
            {
                NomeFornecedor = x.RAZAO_SOCIAL,
                CNPJ           = x.CNPJ
            }).ToList();

            ficha.SolicitacaoFornecedor = solicitacaoFornecedorVM;

            //Mapear os Documentos
            solicitacaoFornecedorVM.Documentos =
                Mapper.Map <List <SolicitacaoDeDocumentos>, List <SolicitacaoDocumentosVM> >(solicitacao.SolicitacaoDeDocumentos.ToList());

            //Mapear UNSPSC
            ficha.FornecedoresUnspsc =
                Mapper.Map <List <SOLICITACAO_UNSPSC>, List <FornecedorUnspscVM> >(solicitacao.WFD_SOL_UNSPSC.ToList());

            var papel = _papelService.BuscarPorContratanteETipoPapel(contratante.ID, TpPapel).ID;

            //Mapear Questionários
            ficha.Questionarios = new RetornoQuestionario <QuestionarioVM>
            {
                QuestionarioDinamicoList =
                    Mapper.Map <List <QuestionarioDinamico>, List <QuestionarioVM> >(
                        _cadastroUnicoBP.BuscarQuestionarioDinamico(new QuestionarioDinamicoFiltrosDTO()
                {
                    //PapelId = papelAtual,
                    UF            = "RJ",
                    ContratanteId = contratante.ID,
                    PapelId       = papel,
                    CategoriaId   = solicitacaoCadastroPJPF.CATEGORIA_ID,
                    Alteracao     = true,
                    SolicitacaoId = solicitacao.ID
                })
                        )
            };

            ficha.ProrrogacaoPrazo = new ProrrogacaoPrazoVM();
            if (solicitacao.WFD_SOLICITACAO_PRORROGACAO.Count > 0)
            {
                //Busca a ultima solicitacao de prorrogação, ou seja a ativa.
                ficha.ProrrogacaoPrazo =
                    Mapper.Map <SOLICITACAO_PRORROGACAO, ProrrogacaoPrazoVM>(solicitacao.WFD_SOLICITACAO_PRORROGACAO.OrderBy(o => o.ID).LastOrDefault());
            }
            ficha.ProrrogacaoPrazo.PrazoPreenchimento = _contratanteConfiguracaoService.BuscarPrazo(solicitacao);
            if (ficha.ProrrogacaoPrazo.Aprovado != null)
            {
                if ((bool)ficha.ProrrogacaoPrazo.Aprovado)
                {
                    ficha.ProrrogacaoPrazo.Status = "Aprovado";
                }
                else
                {
                    ficha.ProrrogacaoPrazo.Status = "Reprovado";
                }
            }
            else
            {
                ficha.ProrrogacaoPrazo.Status = "Aguardando Aprovação...";
            }
        }