コード例 #1
0
        private async Task EnviarEmail(Guid pactoTrabalhoId, Int64 pessoaId, Int64 unidadeId)
        {
            try
            {
                if (Configuration.Value.Notificacoes == null ||
                    Configuration.Value.Notificacoes.EnviarEmail)
                {
                    //Obtem os destinatários dos emails
                    var destinatarios = new List <string>();

                    var servidor = await PessoaQuery.ObterPorChaveAsync(pessoaId);

                    destinatarios.Add(servidor.Result.Email);

                    var unidade = await UnidadeQuery.ObterPessoasAsync(unidadeId);

                    var chefes = unidade.Result.Where(u => u.UnidadeId == unidadeId && u.TipoFuncaoId.HasValue);
                    foreach (var chefe in chefes)
                    {
                        if (!string.IsNullOrEmpty(chefe.Email))
                        {
                            destinatarios.Add(chefe.Email);
                        }
                    }

                    //Envia os emails
                    EnviarEmail(pactoTrabalhoId, Configuration.Value.Notificacoes.EmailPactoSolicitacaoAlteracaoPrazo, destinatarios.ToArray());
                }
            }
            catch { }
        }
コード例 #2
0
        public async Task <IActionResult> Handle(CadastrarPlanoTrabalhoCommand request, CancellationToken cancellationToken)
        {
            ApplicationResult <Guid> result = new ApplicationResult <Guid>(request);

            var unidade = await UnidadeQuery.ObterPorChaveAsync(request.UnidadeId);

            //Monta o objeto com os dados do item de catalogo
            Domain.AggregatesModel.PlanoTrabalhoAggregate.PlanoTrabalho item =
                Domain.AggregatesModel.PlanoTrabalhoAggregate.PlanoTrabalho.Criar(
                    request.UnidadeId,
                    request.DataInicio,
                    request.DataFim,
                    request.TempoComparecimento,
                    request.TempoFaseHabilitacao,
                    unidade.Result.QuantidadeServidores,
                    request.UsuarioLogadoId.ToString(),
                    request.TermoAceite);

            //Adiciona o catalogo no banco de dados
            await PlanoTrabalhoRepository.AdicionarAsync(item);

            UnitOfWork.Commit(false);

            result.Result = item.PlanoTrabalhoId;
            result.SetHttpStatusToOk("Plano de trabalho cadastrado com sucesso.");
            return(result);
        }
        public async Task <IActionResult> Handle(CadastrarPlanoTrabalhoCommand request, CancellationToken cancellationToken)
        {
            ApplicationResult <Guid> result = new ApplicationResult <Guid>(request);

            try
            {
                var unidade = await UnidadeQuery.ObterQuantidadeServidoresPorChaveAsync(request.UnidadeId);

                var tempoComparecimento = request.TempoComparecimento;
                var termosAceite        = request.TermoAceite;

                if (Configuration.Value.TempoComparecimento > 0)
                {
                    tempoComparecimento = Configuration.Value.TempoComparecimento;
                }

                if (!String.IsNullOrEmpty(Configuration.Value.TermoAceite))
                {
                    termosAceite = Configuration.Value.TermoAceite;
                }

                //Monta o objeto com os dados do item de catalogo
                Domain.AggregatesModel.PlanoTrabalhoAggregate.PlanoTrabalho item =
                    Domain.AggregatesModel.PlanoTrabalhoAggregate.PlanoTrabalho.Criar(
                        request.UnidadeId,
                        request.DataInicio,
                        request.DataFim,
                        tempoComparecimento,
                        request.TempoFaseHabilitacao,
                        unidade.Result.QuantidadeServidores,
                        request.UsuarioLogadoId.ToString(),
                        termosAceite);

                //Adiciona o catalogo no banco de dados
                await PlanoTrabalhoRepository.AdicionarAsync(item);

                UnitOfWork.Commit(false);

                result.Result = item.PlanoTrabalhoId;
                result.SetHttpStatusToOk("Plano de trabalho cadastrado com sucesso.");
            }
            catch (SISRHDomainException ex)
            {
                result.Validations = new List <string>()
                {
                    ex.Message
                };
                result.SetHttpStatusToBadRequest(ex.Message);
            }

            return(result);
        }
        private async Task <string[]> ObterChefesUnidade(string siglaCompletaUnidade)
        {
            var chefes = await UnidadeQuery.ObterChefesAsync(siglaCompletaUnidade);

            return(chefes.Result.Where(p => !String.IsNullOrEmpty(p.Email)).Select(p => p.Email).ToArray());
        }
        private async Task EnviarEmails(Susep.SISRH.Domain.AggregatesModel.PlanoTrabalhoAggregate.PlanoTrabalho item)
        {
            try
            {
                if (Configuration.Value.Notificacoes == null ||
                    Configuration.Value.Notificacoes.EnviarEmail)
                {
                    switch (item.SituacaoId)
                    {
                    case (int)SituacaoPlanoTrabalhoEnum.EnviadoAprovacao:
                        //Obtém o chefe, o CG e o diretor da unidade
                        var destsAprovacao = await ObterChefesUnidade(item.Unidade.SiglaCompleta);

                        EnviarEmailPlanoEnviadoAprovacao(item.PlanoTrabalhoId, Configuration.Value.Notificacoes.EmailPlanoParaAprovacao, destsAprovacao);
                        break;

                    case (int)SituacaoPlanoTrabalhoEnum.Aprovado:
                        //Obtém o chefe, o CG e o diretor da unidade
                        var destsAprovado = await ObterChefesUnidade(item.Unidade.SiglaCompleta);

                        EnviarEmailPlanoAprovado(item.PlanoTrabalhoId, Configuration.Value.Notificacoes.EmailPlanoAprovado, destsAprovado);
                        break;


                    case (int)SituacaoPlanoTrabalhoEnum.Rejeitado:
                        //Obtém o chefe, o CG e o diretor da unidade
                        var destsRejeitado = await ObterChefesUnidade(item.Unidade.SiglaCompleta);

                        EnviarEmailPlanoRejeitado(item.PlanoTrabalhoId, Configuration.Value.Notificacoes.EmailPlanoRejeitado, destsRejeitado);
                        break;

                    case (int)SituacaoPlanoTrabalhoEnum.Habilitacao:

                        //Obtém as pessoas da unidade
                        var pessoasUnidade = await UnidadeQuery.ObterPessoasAsync(item.UnidadeId);

                        var pessoasEnviarEmail = pessoasUnidade.Result;
                        //Se o tipo de notificação não incluir as pessoas da subunidade,
                        //  Deve adicionar apenas as pessoas que estão diretamente lotadas na unidade OU
                        //  que tem função em unidades inferiores
                        if (Configuration.Value.Notificacoes == null ||
                            Configuration.Value.Notificacoes.AberturaFaseHabilitacao != "IncluirSubunidades")
                        {
                            pessoasEnviarEmail = pessoasEnviarEmail.Where(p => p.UnidadeId == item.UnidadeId || (p.Chefe.HasValue && p.Chefe.Value)).ToList();
                        }
                        EnviarEmailHabilitacao(item.PlanoTrabalhoId, Configuration.Value.Notificacoes.EmailPlanoEmHabilitacao, pessoasEnviarEmail.Where(p => !String.IsNullOrEmpty(p.Email)).Select(p => p.Email).ToArray());
                        break;


                    //Conclusão da fase de habilitação
                    case (int)SituacaoPlanoTrabalhoEnum.ProntoParaExecucao:

                        //Obtém as pessoas que tiveram a candidatura aprovada
                        var aprovados = from a in item.Atividades
                                        from c in a.Candidatos
                                        where c.SituacaoId == (int)SituacaoCandidaturaPlanoTrabalhoEnum.Aprovada
                                        select c.Pessoa;

                        //Obtém as pessoas que não foram aprovadas
                        var rejeitados = from a in item.Atividades
                                         from c in a.Candidatos
                                         where c.SituacaoId != (int)SituacaoCandidaturaPlanoTrabalhoEnum.Aprovada
                                         select c.Pessoa;
                        rejeitados = rejeitados.Where(r => !aprovados.Any(a => a.PessoaId == r.PessoaId));

                        //Envia email aos aprovados e aos rejeitados
                        EnviarEmailCandidaturaAprovada(item.PlanoTrabalhoId, Configuration.Value.Notificacoes.EmailPlanoCandidaturaAprovada, aprovados.Where(p => !String.IsNullOrEmpty(p.Email)).Select(p => p.Email).ToArray());
                        EnviarEmailCandidaturaRejeitada(item.PlanoTrabalhoId, Configuration.Value.Notificacoes.EmailPlanoCandidaturaRejeitada, rejeitados.Where(p => !String.IsNullOrEmpty(p.Email)).Select(p => p.Email).ToArray());

                        break;
                    }
                }
            }
            catch { }
        }