public static RoboSimples ModelToViewModel(ROBO robo)
        {
            RoboSimples roboSimples = new RoboSimples();

            roboSimples.Data = new DataSimples();

            if (robo != null)
            {
                roboSimples.DataConsulta = robo.SN_CONSULTA_DTHR;
                roboSimples.Code         = robo.SN_CODE_ROBO;
                roboSimples.Data.SituacaoSimplesNacional           = robo.SIMPLES_NACIONAL_SITUACAO;
                roboSimples.Data.SimplesNacionalPeriodosAnteriores = robo.SN_PERIODOS_ANTERIORES;
                roboSimples.Data.SIMEIPeriodosAnteriores           = robo.SN_SIMEI_PERIODOS_ANTERIORES;
                roboSimples.Data.SituacaoSIMEI = robo.SN_SITUACAO_SIMEI;
                roboSimples.Data.RazaoSocial   = robo.SN_RAZAO_SOCIAL;
                roboSimples.MontaCssMessagem();
                return(roboSimples);
            }

            return(null);
        }
Example #2
0
 public void MontaCssMessagem(RoboSimples roboSimples)
 {
     if (roboSimples.Code == null)
     {
         roboSimples.cssCor       = "default";
         roboSimples.Data.Message = roboSimples.Code + " - Consulta Realizada com sucesso. (Situação Cadastral: " + roboSimples.Data.SituacaoSimplesNacional + ") &nbsp;&nbsp;&nbsp;<i class='fa fa-arrow-circle-down'></i>";
     }
     else if (roboSimples.Code == 1)
     {
         roboSimples.cssCor       = "success";
         roboSimples.Data.Message = roboSimples.Code + " - Consulta Realizada com sucesso. (Situação Cadastral: " + roboSimples.Data.SituacaoSimplesNacional + ") &nbsp;&nbsp;&nbsp;<i class='fa fa-arrow-circle-down'></i>";
     }
     else if (roboSimples.Code == 2)
     {
         roboSimples.cssCor       = "warning";
         roboSimples.Data.Message = roboSimples.Code + " - " + roboSimples.Data.Message;
     }
     else
     {
         roboSimples.cssCor       = "danger";
         roboSimples.Data.Message = roboSimples.Code + " - " + roboSimples.Data.Message;
     }
 }
        private void MontaRobo(RoboSimples roboSimples, ROBO robo)
        {
            if (roboSimples != null)
            {
                if (roboSimples.Code == 1)
                {
                    robo.SN_CODE_ROBO = roboSimples.Code;
                    robo.SIMPLES_NACIONAL_SITUACAO    = (!string.IsNullOrEmpty(roboSimples.Data.SituacaoSimplesNacional)) ? roboSimples.Data.SituacaoSimplesNacional : string.Empty;
                    robo.SN_PERIODOS_ANTERIORES       = roboSimples.Data.SimplesNacionalPeriodosAnteriores;
                    robo.SN_SIMEI_PERIODOS_ANTERIORES = roboSimples.Data.SIMEIPeriodosAnteriores;
                    robo.SN_SITUACAO_SIMEI            = roboSimples.Data.SituacaoSIMEI;
                    robo.SN_RAZAO_SOCIAL  = roboSimples.Data.RazaoSocial;
                    robo.SN_CONSULTA_DTHR = DateTime.Now;
                }
                else
                {
                    int?contador = robo.SN_CONTADOR_TENTATIVA;
                    if (!contador.HasValue)
                    {
                        contador = 0;
                    }

                    if (roboSimples.Code == 2 || roboSimples.Code == 3)
                    {
                        robo.SN_CODE_ROBO = roboSimples.Code;
                        robo.SIMPLES_NACIONAL_SITUACAO = roboSimples.Data.Message;
                        robo.SN_CONSULTA_DTHR          = DateTime.Now;
                        robo.SN_CONTADOR_TENTATIVA     = 0;
                    }
                    else
                    {
                        contador += 1;
                        robo.SN_CONTADOR_TENTATIVA = contador;
                    }
                }
            }
        }
        public RoboSimples CarregaSimplesCNPJ(string cnpj, string path)
        {
            RoboSimples roboSimples = new RoboSimples();

            try
            {
                var    ativarConsultasRobo = Convert.ToBoolean(ConfigurationManager.AppSettings["AtivarConsultasRobo"]);
                string textResult          = string.Empty;

                if (!ativarConsultasRobo)
                {
                    textResult = Simples_fake(path);
                }
                else
                {
                    string          token           = ConfigurationManager.AppSettings["SintegraToken"];
                    string          cont            = "7";
                    string          url             = string.Format("http://webservice.keyconsultas.net/receita/simples/?cnpj={0}&token={1}&cont={2}", cnpj, token, cont);
                    var             requestSimples  = (HttpWebRequest)WebRequest.Create(url);
                    HttpWebResponse responseSimples = requestSimples.GetResponse() as HttpWebResponse;
                    Stream          streamSimples   = responseSimples.GetResponseStream();
                    StreamReader    readerSimples   = new StreamReader(streamSimples);
                    textResult = readerSimples.ReadToEnd();
                }

                roboSimples = JsonConvert.DeserializeObject <RoboSimples>(textResult);

                return(roboSimples);
            }
            catch
            {
                roboSimples.Code         = 0;
                roboSimples.Data         = new DataSimples();
                roboSimples.Data.Message = "Não foi possível acessar o serviço de consulta dos Orgãos Públicos! Tente novamente.";
                return(roboSimples);
            }
        }
        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));
            }
        }
 public void GravaRoboSimples(RoboSimples roboSimples, ref ROBO robo)
 {
     MontaRobo(roboSimples, robo);
 }
        static void ChamaRobo(int solicitacaoId)
        {
            try
            {
                WebForLinkContexto db = new WebForLinkContexto();

                var solicitacao = BuscarsolicitacaoParaRobo(db, solicitacaoId);

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

                var robo    = solicitacao.ROBO.FirstOrDefault();
                var solForn = solicitacao.SolicitacaoCadastroFornecedor.FirstOrDefault();

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

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

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

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

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

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

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

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

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

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

                // Pessoa Fisica
                if (solForn.PJPF_TIPO == 3)
                {
                    if (validaReceita && solForn.CPF != null)
                    {
                        roboReceitaCpf = roboReceitaCpf.CarregaRoboCPF(solForn.CPF, solForn.DT_NASCIMENTO.ToString(), path);

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

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

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

                ContratanteId   = solicitacao.CONTRATANTE_ID;
                DataSolicitacao = (DateTime)solicitacao.SOLICITACAO_DT_CRIA;

                db.Entry(solicitacao).State = EntityState.Modified;
                db.SaveChanges();
            }
            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));
            }
        }