コード例 #1
0
        protected void DadosAutomaticosDefinicao(DefinicoesClienteAprovacao def, int codFilial)
        {
            if (codFilial == 4)
            {//Filial São Paulo

                def.CodGrupoContasAReceber = "45";

                def.IndAceitaFaturamentoParcialPedido = "S";
                def.RecJurosMoraMes = "9,99";
                def.TipJuros = "S";
                def.IndCobrarTaxaBanco = "N";
                def.CodCategoria = "9";
            }
            else if (codFilial == 1)//Filial Rio
            {
                def.CodGrupoContasAReceber = "02";
                def.IndAceitaFaturamentoParcialPedido = "S";
                def.RecJurosMoraMes = "9,99";
                def.TipJuros = "S";
                def.IndCobrarTaxaBanco = "S";
                def.CodCategoria = "9";

            }
            else if (codFilial == 11)//Filial Minas
            {
                def.CodGrupoContasAReceber = "43";
                def.IndAceitaFaturamentoParcialPedido = "S";
                def.RecJurosMoraMes = "9,99";
                def.TipJuros = "S";
                def.IndCobrarTaxaBanco = "S";
                def.CodCategoria = "9";
            }
            else if (codFilial == 7)//Filial Recife
            {
                def.CodGrupoContasAReceber = "44";
                def.IndAceitaFaturamentoParcialPedido = "S";
                def.RecJurosMoraMes = "9,99";
                def.TipJuros = "S";
                def.IndCobrarTaxaBanco = "S";
                def.CodCategoria = "9";
            }
            else if (codFilial == 10)//Filial Curitiba
            {
                def.CodGrupoContasAReceber = "36";
                def.IndAceitaFaturamentoParcialPedido = "S";
                def.RecJurosMoraMes = "9,99";
                def.TipJuros = "S";
                def.IndCobrarTaxaBanco = "S";
                def.CodCategoria = "9";
            }
            else if (codFilial == 8)//Filial DF
            {
                def.CodGrupoContasAReceber = "42";
                def.IndAceitaFaturamentoParcialPedido = "S";
                def.RecJurosMoraMes = "9,99";
                def.TipJuros = "S";
                def.IndCobrarTaxaBanco = "S";
                def.CodCategoria = "9";
            }
        }
コード例 #2
0
        public ActionResult SalvarDefinicoes(DefinicoesClienteAprovacao defCli)
        {
            //Autentica
            if (Session["ConexaoSapiens"] == null)
            {
                return RedirectToAction("Login", "Home");
            }
            //Autoriza
            if (!AutorizaUsuario(Helpers.ControlAccessConfig.AbrirAnalise))
            {
                return View("Erro", null, "Módulo não autorizado para este usuário. ");
            }

            try
            {
                var p = Session["Parecer"] as ParecerSolicitacao;
                using (var bll = new DefinicoesClienteAprovacaoBLL())
                {
                    var def = bll.ObterPorCodigo(defCli.CodDefinicoesClienteAprovacao);

                    if (!String.IsNullOrEmpty(defCli.VlrLimite))
                    {
                        if (defCli.VlrLimite.IndexOf("R$") == 0)
                        {
                            def.VlrLimite = defCli.VlrLimite.Substring(2);
                        }

                        def.VlrLimite = Regex.Replace(def.VlrLimite, @"(\s+)|(\\+)|(\.+)|(/+)|(\-+)|(\,+)", "");
                        def.VlrLimite = def.VlrLimite.Remove(def.VlrLimite.Length - 2, 2);
                    }
                    else
                    {
                        def.VlrLimite = "0";
                    }

                    if (!String.IsNullOrEmpty(defCli.VlrDescontoFinanceiro))
                    {
                        def.VlrDescontoFinanceiro = Regex.Replace(defCli.VlrDescontoFinanceiro, @"(\s+)|(\\+)|(\.+)|(/+)|(\-+)|(\,+)|(\%+)", "");
                    }

                    def.CodDefinicoesClienteAprovacao = defCli.CodDefinicoesClienteAprovacao;
                    def.CodCategoria = "9";
                    def.CodFormaDePagamento = defCli.CodFormaDePagamento;
                    def.CodGrupoContasAReceber = defCli.CodGrupoContasAReceber;
                    def.IndAceitaFaturamentoParcialPedido = "S";
                    def.IndLimiteAprovado = "N";
                    def.CodCondicaoPagamento = defCli.CodCondicaoPagamento;
                    def.CodRepresentante = defCli.CodRepresentante;
                    def.CodVendedor = defCli.CodVendedor;
                    def.IndEmiteBoleto = defCli.CodFormaDePagamento == "5" ? "S" : "N";
                    def.CodRegiaoDeVendas = p.DadosPrincipaisAprovacao.Last().UF;
                    def.RecJurosMoraMes = "9.99";
                    def.TipJuros = defCli.TipJuros;
                    def.IndCobrarTaxaBanco = defCli.CodRegiaoDeVendas.StartsWith("SP") ? "N" : "S";
                    def.IndDescontoFinanceiro = defCli.IndDescontoFinanceiro;
                    def.VlrDescontoFinanceiro = defCli.VlrDescontoFinanceiro;
                    def.CodFilial = Convert.ToInt32(Session["CodigoFilial"]);
                    def.IndicativoPresencial = "9";

                    switch (p.DadosPrincipaisAprovacao.Last().CodRamoAtividade)
                    {
                        case "001":
                        case "003":
                        case "006":
                        case "007":
                        case "011":
                        case "012":
                            def.ConsumidorFinal = "S";
                            break;
                        case "002":
                        case "004":
                            def.ConsumidorFinal = "N";
                            break;
                    }

                    bll.Atualizar(def);
                }
                Session["Parecer"] = p;

                return Json(new { msg = "Definição gravada com sucesso." }, JsonRequestBehavior.DenyGet);
            }

            catch (Exception ex)
            {
                return Json(new { msg = "Erro ao tentar gravar Definição: " + ex.Message }, JsonRequestBehavior.DenyGet);
            }
        }
コード例 #3
0
        public ActionResult SalvarParecer(DadoPrincipalAprovacao dadPri, DefinicoesClienteAprovacao defCli, string Txtpar, string StatusParecer, string chkEncerra, string vlrLimAnalise, string cpgAnalise, string fpgAnalise)
        {
            using (ParecerSolicitacaoBLL parecerSolicitacaoBLL = new ParecerSolicitacaoBLL())
            {
                PerfilUsuarioBLL perfilBLL = new PerfilUsuarioBLL();
                ConfiguracaoWorkflowBLL configBLL = new ConfiguracaoWorkflowBLL();
                HistoricoSolicitacaoBLL historicoBLL = new HistoricoSolicitacaoBLL();

                ParecerSolicitacao p = Session["Parecer"] as ParecerSolicitacao;
                Solicitacao s = Session["Solicitacao"] as Solicitacao;

                var historico = new HistoricoSolicitacao();

                var usuario = Session["ConexaoSapiens"] as UsuarioSapiens;
                List<PerfilUsuario> perfisUsuarioLogado = null;

                if (usuario != null)
                {
                    perfisUsuarioLogado = perfilBLL.ObterGruposPorCodUsuario(usuario.Codusu);
                }

                // se algum dos perfis do usuário logado contém o perfil aprovador, pode salvar parecer.
                var queryPodeSalvarParecer = from meuPerfil in perfisUsuarioLogado
                                             where meuPerfil.CodPerfilUsuario == p.Codperusu
                                             select meuPerfil;

                var podeSalvar = queryPodeSalvarParecer.Count() > 0 ? true : false;

                // Se o usuário logado não tiver o perfil de aprovação, não pode salvar o parecer
                if (!podeSalvar)
                {
                    return Json(new { msg = "O perfil atual não tem permissão para aprovar este parecer." }, JsonRequestBehavior.DenyGet);
                }

                switch (StatusParecer)
                {
                    case "AP":
                        p.Codsitpar = Convert.ToDecimal(SituacaoParecer.Aprovada);
                        break;

                    case "RP":
                        p.Codsitpar = Convert.ToDecimal(SituacaoParecer.Reprovada);
                        p.Solicitacao.Situacao = "REPROVADA";
                        historico.CodSituacaoSolicitacao = Convert.ToInt32(SituacaoParecer.Reprovada);
                        historico.DatFinalizacao = DateTime.Now;

                        break;
                }

                #region atualiza o parecer atual com os dados que estão na tela.

                SalvarDadoPrincipal(dadPri);

                defCli.VlrLimite = vlrLimAnalise;
                defCli.CodCondicaoPagamento = cpgAnalise;
                defCli.CodFormaDePagamento = fpgAnalise;

                SalvarDefinicoes(defCli);

                #endregion

                // usando o SignalR para implementar atualização geral em tempo real.
                // (atualiza os grids de todos os usuários logados , sem necessidade do F5)
                var context = GlobalHost.ConnectionManager.GetHubContext<StatusHub>();

                //o parecer persistido ( pode gravar, atualizar, até excluir pelo BLL);
                var parecer = parecerSolicitacaoBLL.ObterPorCodigo(p.CodParecer);

                parecer.Codsitpar = p.Codsitpar; // O Novo parecer inicia como Aguardando Aprovação.
                parecer.Codusuapr = usuario.Codusu;
                parecer.Datpar = DateTime.Now;
                parecer.Solicitacao = p.Solicitacao;
                parecer.Txtpar = Txtpar;

                try
                {
                    if (!String.IsNullOrEmpty(Txtpar))
                    {
                        // se entrar aqui , está APROVADA e OK para Gravar.
                        if (parecer.Codsitpar == Convert.ToDecimal(SituacaoParecer.Aprovada))
                        {
                            // verificar na configuração de alçada se tem próximo nível e qual é esse nível.
                            // 21/08/2015 - verificar se o parecer que está sendo aprovado é o último necessário

                            // se o usuário aprovador corresponde ao nivel máximo, ou se está marcado para encerrar o parecer, pode enviar...
                            var prontaParaIntegrar = (((parecer.Codperusu - 2) == s.nivelMaximo) || chkEncerra == "S");
                            //(s.PareceresSolicitacao.Count - 1) == s.nivelMaximo || chkEncerra == "S"
                            if (prontaParaIntegrar)
                            {
                                try
                                {
                                    // muda status para Aguardando integração
                                    parecer.Codsitpar = Convert.ToDecimal(SituacaoParecer.AguardandoIntegracao);
                                    parecer.Solicitacao.CodSituacaoAtual = Convert.ToInt32(SituacaoSolicitacao.AguardandoIntegracao);
                                    parecerSolicitacaoBLL.Atualizar(parecer);

                                    s.CodSituacaoAtual = Convert.ToInt32(SituacaoSolicitacao.AguardandoIntegracao);

                                    Thread t = new Thread(_ =>
                                    {
                                        ServiceReferenceTeste.srvSicadSoapClient clienteTesteIntegracao = new ServiceReferenceTeste.srvSicadSoapClient();
                                        clienteTesteIntegracao.IntegrarDadosCliente(p.Solicitacao.Codigo);
                                    });

                                    t.Start();

                                    historico.DatEncaminhamento = DateTime.Now;
                                    historico.CodSituacaoSolicitacao = Convert.ToInt32(SituacaoSolicitacao.AguardandoIntegracao);
                                    historico.Solicitacao = s;
                                    if (chkEncerra == "S")
                                    {
                                        Txtpar += " ( Encerramento do workflow antecipado por " + usuario.Nomusu + " )";
                                    }
                                    historico.TxtHistorico = Txtpar;

                                    historicoBLL.Salvar(historico);
                                }
                                catch (Exception ex)
                                {
                                    // TODO: Retirar depois de validar a execução do webservice ( vai ficar aguardando Integração se for finalmente aprovado )
                                    parecer.Codsitpar = Convert.ToDecimal(SituacaoParecer.AguardandoAprovacao);
                                    parecerSolicitacaoBLL.Atualizar(parecer);

                                    throw ex;
                                }
                            }
                            else
                            {

                                int codPerfilAprovadorAtual = Convert.ToInt32(parecer.Codperusu);

                                // se não encerra, cria um novo parecer ...
                                var novoParecer = new ParecerSolicitacao();

                                novoParecer.Solicitacao = p.Solicitacao;

                                novoParecer.Codsitpar = Convert.ToDecimal(SituacaoParecer.AguardandoAprovacao);

                                novoParecer.Codhistsol = historico.CodHistoricoSolicitacao; // pegar o codhist OK
                                //novoParecer.Codperusu = ++p.Codperusu; // o perfil do analista de crédito. -> se o usuário não tiver perfil, avisar na tela.

                                int codPerfilProximoAprovador = 0;

                                switch (codPerfilAprovadorAtual)
                                {
                                    case 2: codPerfilProximoAprovador = 3; break;
                                    case 3: codPerfilProximoAprovador = 4; break;
                                    case 4: codPerfilProximoAprovador = 5; break;

                                    //case 5: return Json("", JsonRequestBehavior.DenyGet);

                                }

                                novoParecer.Codperusu = (decimal)codPerfilProximoAprovador;
                                //novoParecer.Codusuapr = s.CodUsuarioSolicitacao; // obter o codigo do usuario da aprovacao. OK
                                novoParecer.Codusuapr = usuario.Codusu;

                                // necessário definir o código como 0 para instruir o NHibernate que este é um novo objeto.
                                dadPri.CodigoDadoPrincipalAprovacao = 0;
                                dadPri.Parecer = parecer;

                                // salvar todos os dados do parecer anterior no novo parecer, e incluir as alterações feitas na tela.
                                novoParecer.DadosPrincipaisAprovacao.Add(dadPri);

                                defCli.CodDefinicoesClienteAprovacao = 0;
                                defCli.Parecer = parecer;
                                novoParecer.DefinicoesAprovacao.Add(defCli);

                                foreach (var ca in p.CaracteristicasAprovacao)
                                {
                                    ca.CodCaracteristicaClienteAprovacao = 0;
                                    novoParecer.CaracteristicasAprovacao.Add(ca);
                                }

                                foreach (var ec in p.EnderecosCobrancaAprovacao)
                                {
                                    ec.CodEnderecoCobrancaClienteApr = 0;
                                    novoParecer.EnderecosCobrancaAprovacao.Add(ec);
                                }

                                foreach (var ee in p.EnderecosEntregaAprovacao)
                                {
                                    ee.CodEnderecoEntregaClienteApr = 0;
                                    novoParecer.EnderecosEntregaAprovacao.Add(ee);
                                }

                                foreach (var r in p.ReferenciasAprovacao)
                                {
                                    r.CodReferenciaApr = 0;
                                    novoParecer.ReferenciasAprovacao.Add(r);
                                }

                                foreach (var c in p.ContatosAprovacao)
                                {
                                    c.CodContatoAprovacao = 0;
                                    novoParecer.ContatosAprovacao.Add(c);
                                }

                                foreach (var soc in p.SociosAprovacao)
                                {
                                    soc.CodSocioEmpresaAprovacao = 0;
                                    novoParecer.SociosAprovacao.Add(soc);
                                }

                                foreach (var doc in p.DocumentosAnexadosAprovacao)
                                {
                                    doc.CodDocumentoAnexadoApr = 0;
                                    novoParecer.DocumentosAnexadosAprovacao.Add(doc);
                                }

                                // EX: se estiver R$ 5.000,00 vai ficar 5000, se for nulo vai virar string vazia
                                novoParecer.DefinicoesAprovacao.Last().VlrLimite = String.IsNullOrEmpty(novoParecer.DefinicoesAprovacao.Last().VlrLimite) ? "" : Regex.Replace(novoParecer.DefinicoesAprovacao.Last().VlrLimite, @"(\s+)|(\\+)|(\.+)|(/+)|(\-+)|(\,+)|(R+)|(\$+)", "");
                                novoParecer.DefinicoesAprovacao.Last().VlrLimite = novoParecer.DefinicoesAprovacao.Last().VlrLimite != "" ? novoParecer.DefinicoesAprovacao.Last().VlrLimite.Substring(0, novoParecer.DefinicoesAprovacao.Last().VlrLimite.Length - 2) : "";

                                // EX: se estiver R$ 5.000,00 vai ficar 5000, se for nulo vai virar string vazia
                                novoParecer.DefinicoesAprovacao.Last().VlrDescontoFinanceiro = String.IsNullOrEmpty(novoParecer.DefinicoesAprovacao.Last().VlrDescontoFinanceiro) ? "" : Regex.Replace(novoParecer.DefinicoesAprovacao.Last().VlrDescontoFinanceiro, @"(\s+)|(\\+)|(\.+)|(/+)|(\-+)|(\,+)|(R+)|(\$+)", ""); // .Substring(0, novoParecer.DefinicoesAprovacao.Last().VlrDescontoFinanceiro.Length - 2) estava assim pois inicialmente esse campo foi entendido como monetário, mas é um valor percentual,como em '33%' ou '02%'

                                // salva o novo parecer e os objetos associados.
                                parecerSolicitacaoBLL.Salvar(novoParecer);

                                // atualiza o parecer existente para aprovado
                                parecerSolicitacaoBLL.Atualizar(parecer);

                                historico.Solicitacao = p.Solicitacao;
                                historico.TxtHistorico = p.Txtpar;
                                historico.CodSituacaoSolicitacao = Convert.ToInt32(SituacaoSolicitacao.AguardandoAprovacao);
                                historicoBLL.Salvar(historico);
                            } // fim do "se não encerra"

                        } // fim do "se aprova"
                        else // se não aprova.
                        {
                            historico.DatFinalizacao = DateTime.Now;
                            historico.CodSituacaoSolicitacao = Convert.ToInt32(SituacaoSolicitacao.Reprovada);
                            p.Solicitacao.CodSituacaoAtual = Convert.ToInt32(SituacaoSolicitacao.Reprovada);
                            s.CodSituacaoAtual = Convert.ToInt32(SituacaoSolicitacao.Reprovada);
                            historico.Solicitacao = p.Solicitacao;
                            historico.TxtHistorico = Txtpar; // MOTIVO DA REPROVAÇÃO.
                            historicoBLL.SalvarOuAtualizar(historico);

                            //TODO: atualizar o código da situação da solicitação.
                            new SolicitacaoBLL().AtualizarSituacao(s.Codigo, Convert.ToInt32(SituacaoSolicitacao.Reprovada));

                            parecerSolicitacaoBLL.Atualizar(parecer);

                            context.Clients.All.AtualizarGrid();
                            return Json(new { msg = "Parecer Atualizado." }, JsonRequestBehavior.DenyGet);

                        } // fim do "se não aprova"

                        context.Clients.All.AtualizarGrid();
                        return Json(new { msg = "Parecer Atualizado." }, JsonRequestBehavior.DenyGet);
                    }
                    else
                    {
                        throw new Exception("Não foi possível obter o texto do parecer.");
                    }
                } // Fim do try

                catch (Exception ex)
                {
                    historico.Solicitacao = p.Solicitacao;
                    historico.CodSituacaoIntegracaoSolicitacao = Convert.ToInt32(SituacaoIntegracaoSolicitacao.Erro);
                    historico.CodSituacaoSolicitacao = Convert.ToInt32(SituacaoSolicitacao.AguardandoAprovacao);
                    historico.TxtHistorico = ex.Message;
                    historico.DatFinalizacao = DateTime.Now;
                    historicoBLL.Salvar(historico);

                    return Json(new { erro = "Não foi possível salvar o parecer. Detalhes : " + ex.Message }, JsonRequestBehavior.DenyGet);
                }
            }
        }
コード例 #4
0
        public void PreencheDependencias(DefinicoesClienteAprovacao d, int codCliente)
        {
            using (var categoriaDAL = new CategoriaClienteDAL())
            {
                Task t1 = Task.Factory.StartNew(() =>
                {

                    var categorias = from c in categoriaDAL.ListarTodos()
                                     select c;

                    d.CategoriasCliente = new List<CategoriaCliente>();
                    foreach (var cat in categorias)
                    {
                        d.CategoriasCliente.Add(cat);
                    }
                    categorias = null;
                });

                Task t2 = Task.Factory.StartNew(() =>
                {
                    var formaPagamentoDAL = new FormaPagamentoDAL();
                    var formasPagamento = from f in formaPagamentoDAL.ListarTodos()
                                          select f;

                    d.FormasPagamento = new List<FormaPagamento>();

                    foreach (var forma in formasPagamento)
                    {
                        d.FormasPagamento.Add(forma);
                    }

                    formasPagamento = null;
                });

                Task t3 = Task.Factory.StartNew(() =>
                {
                    var grupoContasAReceberDAL = new GrupoContasAReceberDAL();

                    var grupoContasReceber = from ct in grupoContasAReceberDAL.ListarTodos()
                                             select ct;

                    d.GruposContasReceber = new List<GrupoContasAReceber>();

                    foreach (var grupo in grupoContasReceber)
                    {
                        d.GruposContasReceber.Add(grupo);
                    }
                    grupoContasReceber = null;
                });

                Task t4 = Task.Factory.StartNew(() =>
                {

                    var representanteDAL = new RepresentanteDAL();

                    var representantes = from rep in representanteDAL.ListarTodos().Where(r => r.sitrep == "A")
                                         select rep;

                    d.Representantes = new List<Representante>();

                    foreach (var representante in representantes)
                    {
                        d.Representantes.Add(representante);
                    }

                    representantes = null;
                }).ContinueWith(_ =>
                {
                    var repBLL = new RepresentanteBLL();
                    d.Vendedores = repBLL.ListarVendedores(0, d.Representantes);

                });

                Task t5 = Task.Factory.StartNew(() =>
                {
                    var regiaoVendasDAL = new RegiaoVendasDAL();

                    var regioesVendas = from reg in regiaoVendasDAL.ListarTodos()
                                        select reg;

                    d.RegioesVendas = new List<RegiaoVendas>();

                    foreach (var regiao in regioesVendas)
                    {
                        d.RegioesVendas.Add(regiao);
                    }

                    regioesVendas = null;
                });

                Task t6 = Task.Factory.StartNew(() =>
                {

                    var prazoDAL = new CondicaoPagamentoDAL();

                    var prazos = prazoDAL.ListarTodos().Where(p => p.usuSitsicad == "A").ToList();

                    d.CondicoesPagamento = prazos;

                });

                Task.WaitAll(t1, t2, t3, t4, t5, t6);
            }
        }