public void EnviarEmailRecusaIndicado(IndicadoModel model) //quando o indicado nega
        {
            string path  = ConfiguracaoAppUtil.GetPath(enumConfiguracaoLib.emailTemplateDiretorio, "IndicadorRecusa.cshtml");
            string email = RazorUtil.Render(path, EmailModel.GetModel(model.Historia));

            EmailUtil.Send(model.Historia.IndicadorEmail, "Bradesco | Tocha Olímpica | Indicação recusada", email);
        }
Esempio n. 2
0
        public void EnviarEmailsAdicionadoNaGaleria(IndicadoModel entidade)
        {
            string path  = ConfiguracaoAppUtil.GetPath(enumConfiguracaoLib.emailTemplateDiretorio, "AvisoAdicionadoGaleriaParaIndicador.cshtml");
            string email = RazorUtil.Render(path, EmailModel.GetModel(entidade));

            EmailUtil.Send(entidade.Historia.IndicadorEmail, "Bradesco | Tocha Olímpica | Adicionado a galeria", email);

            path  = ConfiguracaoAppUtil.GetPath(enumConfiguracaoLib.emailTemplateDiretorio, "AvisoAdicionadoGaleriaParaIndicado.cshtml");
            email = RazorUtil.Render(path, EmailModel.GetModel(entidade.Indicado));
            EmailUtil.Send(entidade.Indicado.Email, "Bradesco | Tocha Olímpica | Adicionado a galeria", email);
        }
        private void EnviarEmailsConfirmacaoResponsavel(IndicadoModel model)
        {
            string path  = ConfiguracaoAppUtil.GetPath(enumConfiguracaoLib.emailTemplateDiretorio, "ConfirmacaoResponsavelParaIndicado.cshtml");
            string email = RazorUtil.Render(path, EmailModel.GetModel(model));

            EmailUtil.Send(model.Historia.IndicadoEmail, "Bradesco | Tocha Olímpica | Indicação autorizada", email);

            path  = ConfiguracaoAppUtil.GetPath(enumConfiguracaoLib.emailTemplateDiretorio, "ConfirmacaoResponsavelParaIndicador.cshtml");
            email = RazorUtil.Render(path, EmailModel.GetModel(model));
            EmailUtil.Send(model.Historia.IndicadorEmail, "Bradesco | Tocha Olímpica | Indicação autorizada", email);
        }
        public void EnviarEmailRecusaResponsavel(IndicadoModel model) //quando o responsavel nega
        {
            string path  = ConfiguracaoAppUtil.GetPath(enumConfiguracaoLib.emailTemplateDiretorio, "RecusaResponsavelParaIndicador.cshtml");
            string email = RazorUtil.Render(path, EmailModel.GetModel(model));

            EmailUtil.Send(model.Historia.IndicadorEmail, "Bradesco | Tocha Olímpica | Autorização recusada", email);

            path  = ConfiguracaoAppUtil.GetPath(enumConfiguracaoLib.emailTemplateDiretorio, "RecusaResponsavelParaIndicado.cshtml");
            email = RazorUtil.Render(path, EmailModel.GetModel(model));
            EmailUtil.Send(model.Historia.IndicadoEmail, "Bradesco | Tocha Olímpica | Autorização recusada", email);
        }
        public void EnviarEmailsRecusaHistoria(IndicadoModel entidade)
        {
            string path  = ConfiguracaoAppUtil.GetPath(enumConfiguracaoLib.emailTemplateDiretorio, "AvisoRecusaTriagemParaIndicador.cshtml");
            string email = RazorUtil.Render(path, EmailModel.GetModel(entidade));

            EmailUtil.Send(entidade.Historia.IndicadorEmail, "Bradesco | Tocha Olímpica | História recusada", email);

            path  = ConfiguracaoAppUtil.GetPath(enumConfiguracaoLib.emailTemplateDiretorio, "AvisoRecusaTriagemParaIndicado.cshtml");
            email = RazorUtil.Render(path, EmailModel.GetModel(entidade));
            EmailUtil.Send(entidade.Indicado.Email, "Bradesco | Tocha Olímpica | História recusada", email);
        }
        public RetornoModel RecusarIndicacao(IndicadoModel model)
        {
            HistoriaService historiaService = new HistoriaService();
            Historia        historiaTela    = model.Historia;
            Indicado        indicadoTela    = model.Indicado;

            model.Historia = historiaService.Carregar(model.Codigo);
            model.Indicado = dal.Carregar(model.Historia.IndicadoID ?? 0);
            if (model.Historia.ID != historiaTela.ID)
            {
                return(new RetornoModel()
                {
                    Sucesso = false, Mensagem = "Você não pode manipular um ID diferente do seu código."
                });
            }


            //se for responsavel
            if (model.Historia.CodigoIndicadoResponsavel == model.Codigo)
            {
                model.Historia.IndicadoAprovacaoResponsavel = enumAprovacao.naoAprovado;
                model.Historia.IndicadoAprovacao            = enumAprovacao.naoAprovado;

                EnviarEmailRecusaResponsavel(model);
            }
            else
            {
                model.Historia.IndicadoAprovacao         = enumAprovacao.naoAprovado;
                model.Historia.IndicadoAprovacaoOriginal = enumAprovacao.naoAprovado;
                EnviarEmailRecusaIndicado(model);
            }
            model.Historia.IndicadoID = null;
            HistoriaService service = new HistoriaService();

            service.Salvar(model.Historia);

            return(new RetornoModel()
            {
                Sucesso = true, Mensagem = "OK!"
            });
        }
        private void EnviarEmailsConfirmacaoIndicado(IndicadoModel model)
        {
            if (!MenorIdade(model.Indicado))
            {
                string path  = ConfiguracaoAppUtil.GetPath(enumConfiguracaoLib.emailTemplateDiretorio, "IndicadorConfirmacao.cshtml");
                string email = RazorUtil.Render(path, EmailModel.GetModel(model));
                EmailUtil.Send(model.Historia.IndicadorEmail, "Bradesco | Tocha Olímpica | Indicação aceita", email);
            }
            else
            {
                string path  = ConfiguracaoAppUtil.GetPath(enumConfiguracaoLib.emailTemplateDiretorio, "Autorizacao.cshtml");
                string email = RazorUtil.Render(path, EmailModel.GetModel(model));
                EmailUtil.Send(model.Indicado.ResponsavelEmail, "Bradesco | Tocha Olímpica | Autorização", email);

                path  = ConfiguracaoAppUtil.GetPath(enumConfiguracaoLib.emailTemplateDiretorio, "IndicadoAguardandoResponsavelParaIndicado.cshtml");
                email = RazorUtil.Render(path, EmailModel.GetModel(model.Indicado));
                EmailUtil.Send(model.Historia.IndicadoEmail, "Bradesco | Tocha Olímpica | Aguardando autorização", email);

                path  = ConfiguracaoAppUtil.GetPath(enumConfiguracaoLib.emailTemplateDiretorio, "IndicadoMenorConfirmacaoParaIndicador.cshtml");
                email = RazorUtil.Render(path, EmailModel.GetModel(model));
                EmailUtil.Send(model.Historia.IndicadorEmail, "Bradesco | Tocha Olímpica | Aguardando autorização", email);
            }
        }
        private RetornoModel ValidaDados(IndicadoModel model)
        {
            if ((model != null) && (model.Indicado != null) && (model.Historia != null))
            {
                if (!model.Estrangeiro || model.Indicado.DocumentoTipoID == enumDocumentoTipoNome.cpf)
                {
                    model.Indicado.DocumentoNumero = model.Indicado.DocumentoNumero.Replace(new string[] { "-", "." }, "");
                }
                if (string.IsNullOrEmpty(model.Indicado.Nome))
                {
                    return(new RetornoModel {
                        Mensagem = "Nome inválido", Sucesso = false
                    });
                }
                if (string.IsNullOrEmpty(model.Indicado.Genero))
                {
                    return(new RetornoModel {
                        Mensagem = "Selecione um gênero", Sucesso = false
                    });
                }
                if (model.Indicado.CidadeID <= 0)
                {
                    return(new RetornoModel {
                        Mensagem = "Selecione uma cidade", Sucesso = false
                    });
                }
                if (!EmailUtil.IsValidMailAdress(model.Indicado.Email))
                {
                    return(new RetornoModel {
                        Mensagem = "Email inválido", Sucesso = false
                    });
                }

                var value      = ConfiguracaoAppUtil.Get(enumConfiguracaoGeral.dataEvento);
                var dataEvento = DateTime.Parse(value);

                // ------------------- VALIDAÇÃO IDADE ------------------
                if (model.Indicado.DataNascimento == DateTime.MinValue)
                {
                    return(new RetornoModel {
                        Mensagem = "Você precisa informar sua data de nascimento.", Sucesso = false
                    });
                }
                if (model.Indicado.DataNascimento.AddYears(12) > dataEvento)
                {
                    return(new RetornoModel {
                        Mensagem = "O participante deve ter no mínimo 12 anos.", Sucesso = false
                    });
                }
                if (MenorIdade(model.Indicado))
                {
                    if (model.Indicado.ParentescoID <= 0)
                    {
                        return new RetornoModel {
                                   Mensagem = "Você precisa selecionar um parentesco.", Sucesso = false
                        }
                    }
                    ;

                    RetornoModel retorno = ValidaResponsavel(model.Indicado.ResponsavelEmail, model.Indicado.ResponsavelNome, model.Indicado.ResponsavelTelefone);
                    if (!retorno.Sucesso)
                    {
                        return(retorno);
                    }
                }
                if (model.Estrangeiro)
                {
                    if (String.IsNullOrEmpty(model.Indicado.DocumentoNumeroComplemento))
                    {
                        return new RetornoModel {
                                   Mensagem = "Número de Passaporte inválido.", Sucesso = false
                        }
                    }
                    ;
                    if (String.IsNullOrEmpty(model.Indicado.DocumentoNumero))
                    {
                        return new RetornoModel {
                                   Mensagem = "Número do Registro Nacional de Estrangeiros inválido.", Sucesso = false
                        }
                    }
                    ;
                }
                else if (!model.Indicado.DocumentoNumero.IsValidCPF())
                {
                    return(new RetornoModel {
                        Mensagem = "Número de CPF inválido.", Sucesso = false
                    });
                }
            }
            else
            {
                return(new RetornoModel {
                    Mensagem = "Dados obrigatórios não foram preenchidos.", Sucesso = false
                });
            }
            return(new RetornoModel {
                Mensagem = "OK!", Sucesso = true
            });
        }
        public RetornoModel ConfirmarIndicacao(IndicadoModel model)
        {
            RetornoModel retorno = new RetornoModel();

            retorno = ValidaDados(model);
            if (retorno.Sucesso)
            {
                HistoriaService      historiaService      = new HistoriaService();
                HistoriaMidiaService historiaMidiaService = new HistoriaMidiaService();
                Historia             historiaTela         = model.Historia;
                Indicado             indicadoTela         = model.Indicado;
                model.Historia        = historiaService.Carregar(model.Codigo);
                model.Historia.Midias = historiaMidiaService.Listar(model.Historia.ID, true);
                model.Responsavel     = (model.Historia.CodigoIndicadoResponsavel == model.Codigo);

                if (model.Historia.ID != historiaTela.ID)
                {
                    return(new RetornoModel()
                    {
                        Sucesso = false, Mensagem = "Você não pode manipular um ID diferente do seu código."
                    });
                }
                model.Historia.ComentarioIndicado = historiaTela.ComentarioIndicado;
                if (model.Responsavel)
                {
                    if ((model.Historia.IndicadoAprovacaoOriginal != enumAprovacao.aprovado) || (model.Historia.IndicadoAprovacaoResponsavel != enumAprovacao.pendente))
                    {
                        return(new RetornoModel {
                            Mensagem = "Não existe nenhuma pendência vinculada a este código.", Sucesso = false
                        });
                    }
                    model.Historia.ComentarioIndicadoResponsavel = historiaTela.ComentarioIndicado;
                }
                else
                {
                    if (model.Historia.IndicadoAprovacaoOriginal != enumAprovacao.pendente)
                    {
                        return(new RetornoModel {
                            Mensagem = "Não existe nenhuma pendência vinculada a este código.", Sucesso = false
                        });
                    }
                    model.Historia.ComentarioIndicadoOriginal = historiaTela.ComentarioIndicado;
                }
                if (historiaTela.Midias != null)
                {
                    if (model.Historia.Midias == null)
                    {
                        model.Historia.Midias = new List <HistoriaMidia>();
                    }
                    foreach (var htm in historiaTela.Midias)
                    {
                        if (htm.ID == 0)
                        {
                            htm.AdicionadoOrigem = ((model.Responsavel) ? enumAlteracaoOrigem.IndicadoResponsavel : enumAlteracaoOrigem.Indicado);
                            htm.InativoOrigem    = enumAlteracaoOrigem.Nenhum;
                            htm.DataCadastro     = DateTime.Now;
                            htm.HistoriaID       = model.Historia.ID;
                            htm.ArquivoTipo      = htm.ArquivoTipo;
                            model.Historia.Midias.Add(htm);
                            historiaMidiaService.Salvar(htm);
                        }
                        else if (htm.Inativo)
                        {
                            var midia = model.Historia.Midias.FirstOrDefault(t => t.ID == htm.ID);
                            if (midia != null)
                            {
                                midia.InativoOrigem = ((model.Responsavel) ? enumAlteracaoOrigem.IndicadoResponsavel : enumAlteracaoOrigem.Indicado);
                                midia.Inativo       = true;
                                historiaMidiaService.Salvar(midia);
                                model.Historia.Midias.Remove(midia);
                            }
                        }
                    }
                }
                if (model.Responsavel)
                {
                    model.Indicado = dal.Carregar(model.Historia.IndicadoID.Value);

                    if (model.Indicado.ID != indicadoTela.ID)
                    {
                        return(new RetornoModel()
                        {
                            Sucesso = false, Mensagem = "Você não pode manipular um ID diferente do seu código"
                        });
                    }

                    ConfirmarIndicacaoUpdateIndicado(indicadoTela, model.Indicado);

                    model.Historia.TriagemAprovacao             = enumAprovacao.pendente;
                    model.Historia.TriagemAprovacaoNormal       = enumAprovacao.pendente;
                    model.Historia.IndicadoAprovacaoResponsavel = enumAprovacao.aprovado;
                    model.Historia.IndicadoAprovacao            = enumAprovacao.aprovado;
                    model.Historia.AlteracaoOrigem = enumAlteracaoOrigem.IndicadoResponsavel;

                    model.Indicado.AlteracaoOrigem = enumAlteracaoOrigem.IndicadoResponsavel;
                }
                else
                {
                    if (model.Estrangeiro)
                    {
                        // Salva o RNE no DocumentoNumero e o Passaport no DocumentoNumeroComplemento
                        indicadoTela.DocumentoTipoID = enumDocumentoTipoNome.outro;
                    }
                    else
                    {
                        indicadoTela.DocumentoTipoID = enumDocumentoTipoNome.cpf;
                    }

                    model.Indicado = CarregarIndicadoPorDocumento(indicadoTela);
                    model.Historia.AlteracaoOrigem = enumAlteracaoOrigem.Indicado;

                    if (model.Indicado == null)
                    {
                        model.Indicado = indicadoTela;
                        model.Indicado.DataCadastro = DateTime.Now;
                    }
                    else
                    {
                        ConfirmarIndicacaoUpdateIndicado(indicadoTela, model.Indicado);
                    }

                    model.Indicado.AlteracaoOrigem = enumAlteracaoOrigem.Indicado;

                    if (MenorIdade(model.Indicado))
                    {
                        model.Historia.TriagemAprovacao             = enumAprovacao.semNecessidade;
                        model.Historia.TriagemAprovacaoNormal       = enumAprovacao.semNecessidade;
                        model.Historia.IndicadoAprovacaoResponsavel = enumAprovacao.pendente;
                        model.Historia.IndicadoAprovacaoOriginal    = enumAprovacao.aprovado;
                        model.Historia.IndicadoAprovacao            = enumAprovacao.pendente;
                        model.Historia.CodigoIndicadoResponsavel    = historiaService.GeraCodigo();
                        //zera os dados do robo para disparo para o responsavel
                        model.Historia.DataEmailAguardandoAprovacao       = DateTime.Now;
                        model.Historia.QuantidadeEmailAguardandoAprovacao = 0;
                    }
                    else // indicado maior de idade
                    {
                        model.Historia.TriagemAprovacao             = enumAprovacao.pendente;
                        model.Historia.TriagemAprovacaoNormal       = enumAprovacao.pendente;
                        model.Historia.IndicadoAprovacaoResponsavel = enumAprovacao.semNecessidade;
                        model.Historia.IndicadoAprovacaoOriginal    = enumAprovacao.aprovado;
                        model.Historia.IndicadoAprovacao            = enumAprovacao.aprovado;
                    }
                }

                //calculando cidade onde irá carregar a tocha
                CidadeParticipanteService cpService = new CidadeParticipanteService();
                model.Indicado.CidadeParticipanteID = cpService.CarregarPorCidade(model.Indicado.CidadeID).ID;
                model.Indicado.DataModificacao      = DateTime.Now;
                model.Historia.DataModificacao      = DateTime.Now;

                if (!String.IsNullOrEmpty(model.Indicado.FotoArquivoNome))
                {
                    model.IndicadoFotoInfo.file    = model.Indicado.FotoArquivoNome;
                    model.Indicado.FotoArquivoNome = GerarFotoArquivoNome(model.IndicadoFotoInfo);
                }

                //insere Indicado no banco se nao existir com mesmo documento senao atualiza
                if (model.Responsavel)
                {
                    SalvarResponsavelAprovacao(model.Indicado);
                }
                else
                {
                    model.Indicado.ID = SalvarConfirmarIndicacaoIndicado(model.Indicado);
                }
                model.Historia.IndicadoID = model.Indicado.ID;
                historiaService.Salvar(model.Historia);

                try
                {
                    //enviar emails
                    if (model.Responsavel)
                    {
                        EnviarEmailsConfirmacaoResponsavel(model);
                    }
                    else
                    {
                        EnviarEmailsConfirmacaoIndicado(model);
                    }
                }
                catch (Exception ex)
                {
                    LogUtil.Error(ex);
                }
            }
            else
            {
                return(retorno);
            }

            return(new RetornoModel {
                Sucesso = true, Mensagem = "Ok"
            });
        }
        public RetornoModel <IndicadoModel> CarregarConfirmarIndicacao(string Codigo)
        {
            IndicadoModel        model   = new IndicadoModel();
            HistoriaService      sc      = new HistoriaService();
            HistoriaMidiaService scMidia = new HistoriaMidiaService();

            model.Codigo   = Codigo;
            model.Historia = sc.Carregar(Codigo); //buscando historia a partir do codigo do indicado OU RESPONSAVEL
            if (model.Historia == null)           // se a historia existe, monta o model
            {
                return(new RetornoModel <IndicadoModel> {
                    Mensagem = "Código inválido!", Sucesso = false
                });
            }
            model.Historia.Midias = scMidia.Listar(model.Historia.ID, true);
            model.Responsavel     = (Codigo == model.Historia.CodigoIndicadoResponsavel);
            if (model.Responsavel)
            {
                if ((model.Historia.IndicadoAprovacaoOriginal != enumAprovacao.aprovado) || (model.Historia.IndicadoAprovacaoResponsavel != enumAprovacao.pendente))
                {
                    string mensagem = "Não existe nenhuma pendência vinculada a este código.";
                    if (model.Historia.IndicadoAprovacaoResponsavel == enumAprovacao.aprovado)
                    {
                        mensagem = "Essa indicação já foi aprovada.";
                    }
                    else if (model.Historia.IndicadoAprovacaoResponsavel == enumAprovacao.naoAprovado)
                    {
                        mensagem = "Essa indicação já foi recusada.";
                    }
                    return(new RetornoModel <IndicadoModel> {
                        Mensagem = mensagem, Sucesso = false
                    });
                }
                model.Indicado           = dal.Carregar(model.Historia.IndicadoID.Value);
                model.Estrangeiro        = (model.Indicado.DocumentoTipoID != enumDocumentoTipoNome.cpf);
                model.Indicado.UsuarioID = 0;
            }
            else
            {
                if (model.Historia.IndicadoAprovacaoOriginal != enumAprovacao.pendente)
                {
                    string mensagem = "Não existe nenhuma pendência vinculada a este código.";
                    if (model.Historia.IndicadoAprovacaoOriginal == enumAprovacao.aprovado)
                    {
                        mensagem = "Essa indicação já foi aprovada.";
                    }
                    else if (model.Historia.IndicadoAprovacaoOriginal == enumAprovacao.naoAprovado)
                    {
                        mensagem = "Essa indicação já foi recusada.";
                    }
                    return(new RetornoModel <IndicadoModel> {
                        Mensagem = mensagem, Sucesso = false
                    });
                }
                model.Indicado       = new Indicado();
                model.Indicado.Nome  = model.Historia.IndicadoNome;
                model.Indicado.Email = model.Historia.IndicadoEmail;
            }
            model.Historia.CodigoIndicado            = null;
            model.Historia.CodigoIndicadoResponsavel = null;

            HistoriaCategoriaService categoriaService = new HistoriaCategoriaService();

            model.Categoria = categoriaService.Carregar(model.Historia.HistoriaCategoriaID);
            //buscando os estados
            EstadoService service = new EstadoService();

            model.Estados = service.Listar();

            ParentescoService parentescoService = new ParentescoService();

            model.Parentesco = parentescoService.Listar(true);

            model.IndicadoFotoInfo = CarregarFotoInfo(model.Indicado.FotoArquivoNome);
            if (model.IndicadoFotoInfo == null)
            {
                model.IndicadoFotoInfo = new UploadFotoModel();
            }

            return(new RetornoModel <IndicadoModel> {
                Retorno = model, Mensagem = "Código confirmado com sucesso!", Sucesso = true
            });
        }