Esempio n. 1
0
        private static async Task ConfirmarLeituraSME(IMediator mediator, UsuarioNotificacaoDto usuarioMensagem, string cpfUsuario, IEnumerable <ListaEscola> listaEscolas, NotificacaoResposta notificacao)
        {
            List <Dominio.Entidades.Aluno> alunos = new List <Dominio.Entidades.Aluno>();

            listaEscolas.ForEach(escola =>
            {
                var alunosAdicionar = notificacao.GruposId.Any(grupo => grupo.Equals(escola.CodigoGrupo.ToString())) ? escola.Alunos : default;

                if (alunosAdicionar == null || !alunosAdicionar.Any())
                {
                    return;
                }

                alunos.AddRange(alunosAdicionar);
            });

            if (alunos == null || !alunos.Any())
            {
                throw new NegocioException("Nenhum aluno deste usuário está matriculado no grupo desta Notificação");
            }

            foreach (var aluno in alunos)
            {
                await ConfirmarLeitura(mediator, usuarioMensagem, cpfUsuario, aluno);
            }
        }
Esempio n. 2
0
        private static async Task ConfirmarLeituraUE(IMediator mediator, UsuarioNotificacaoDto usuarioMensagem, string cpfUsuario, IEnumerable <ListaEscola> listaEscolas, NotificacaoResposta notificacao)
        {
            List <Dominio.Entidades.Aluno> alunos = new List <Dominio.Entidades.Aluno>();

            listaEscolas.ForEach(escola =>
            {
                var alunosAdicionar = escola.Alunos.Where(x => x.CodigoEscola.Equals(notificacao.CodigoUe.ToString()));

                if (alunosAdicionar == null || !alunosAdicionar.Any())
                {
                    return;
                }

                alunos.AddRange(alunosAdicionar);
            });

            if (alunos == null || !alunos.Any())
            {
                throw new NegocioException("Nenhum Aluno está matriculado na escola da notificação");
            }

            foreach (var aluno in alunos)
            {
                await ConfirmarLeitura(mediator, usuarioMensagem, cpfUsuario, aluno);
            }
        }
Esempio n. 3
0
        private static async Task ConfirmarLeituraUEMOD(IMediator mediator, UsuarioNotificacaoDto usuarioMensagem, string cpfUsuario, IEnumerable <ListaEscola> listaEscolas, NotificacaoResposta notificacao)
        {
            List <Dominio.Entidades.Aluno> alunos = new List <Dominio.Entidades.Aluno>();

            listaEscolas.ForEach(escola =>
            {
                if (notificacao.GruposId != null && notificacao.GruposId.Length > 0 && !notificacao.GruposId.Any(grupo => grupo.Equals(escola.CodigoGrupo.ToString())))
                {
                    return;
                }

                var alunosEscolaMod = escola.Alunos.Where(aluno => aluno.CodigoEscola.Equals(notificacao.CodigoUe.ToString()));

                if (alunosEscolaMod == null || !alunosEscolaMod.Any())
                {
                    return;
                }

                alunos.AddRange(alunosEscolaMod);
            });

            if (alunos == null || !alunos.Any())
            {
                throw new NegocioException("Nenhum Aluno está matriculado na modalidade da escola da notificação");
            }

            foreach (var aluno in alunos)
            {
                await ConfirmarLeitura(mediator, usuarioMensagem, cpfUsuario, aluno);
            }
        }
Esempio n. 4
0
        public async Task <NotificacaoResposta> Executar(IMediator mediator, UsuarioNotificacaoDto usuarioMensagem, string cpfUsuario)
        {
            RespostaApi resposta = await mediator.Send(new DadosAlunoCommand(cpfUsuario));

            if (resposta.Data == null)
            {
                throw new NegocioException("Não foi possivel obter os alunos por escola");
            }

            var listaEscolas = (IEnumerable <ListaEscola>)resposta.Data;

            var notificacao = await mediator.Send(new ObterNotificacaoPorIdQuery(usuarioMensagem.NotificacaoId));

            if (notificacao == null)
            {
                throw new NegocioException("Não foi possivel localizar a notificação.");
            }

            switch (notificacao.TipoComunicado)
            {
            case TipoComunicado.SME:
                await ConfirmarLeituraSME(mediator, usuarioMensagem, cpfUsuario, listaEscolas, notificacao);

                break;

            case TipoComunicado.DRE:
                await ConfirmarLeituraDRE(mediator, usuarioMensagem, cpfUsuario, listaEscolas, notificacao);

                break;

            case TipoComunicado.UE:
                await ConfirmarLeituraUE(mediator, usuarioMensagem, cpfUsuario, listaEscolas, notificacao);

                break;

            case TipoComunicado.UEMOD:
                await ConfirmarLeituraUEMOD(mediator, usuarioMensagem, cpfUsuario, listaEscolas, notificacao);

                break;

            case TipoComunicado.TURMA:
                await ConfirmarLeituraTurma(mediator, usuarioMensagem, cpfUsuario, listaEscolas, notificacao);

                break;

            case TipoComunicado.ALUNO:
                await ConfirmarLeituraAlunoEspecifico(mediator, usuarioMensagem, cpfUsuario, listaEscolas);

                break;

            default:
                throw new NegocioException("Não identificado o Tipo desta notificação");
            }
            ;

            notificacao.MensagemVisualizada = usuarioMensagem.MensagemVisualizada;
            return(notificacao);
        }
Esempio n. 5
0
        private static async Task ConfirmarLeitura(IMediator mediator, UsuarioNotificacaoDto usuarioMensagem, string cpfUsuario, Dominio.Entidades.Aluno aluno)
        {
            var usuarioNotificacao = new UsuarioNotificacao
            {
                UsuarioCpf          = cpfUsuario,
                NotificacaoId       = usuarioMensagem.NotificacaoId,
                DreCodigoEol        = long.Parse(aluno.CodigoDre),
                UeCodigoEol         = aluno.CodigoEscola,
                CodigoEolAluno      = aluno.CodigoEol,
                UsuarioId           = usuarioMensagem.UsuarioId,
                MensagemVisualizada = usuarioMensagem.MensagemVisualizada,
            };

            await IncluiConfirmacaoDeLeitura(mediator, usuarioNotificacao);
        }
Esempio n. 6
0
        private async Task <RelatorioNotificacaoDto> MapearNotificacoesDto(IEnumerable <NotificacaoDto> notificacoes)
        {
            RelatorioNotificacaoDto relatorioNotificacaoDto = new RelatorioNotificacaoDto();
            var dres = notificacoes.Select(n => n.DreId).Distinct();

            foreach (var dre in dres)
            {
                DreNotificacaoDto dreNotificacaoDto = new DreNotificacaoDto();
                dreNotificacaoDto.Nome = notificacoes.FirstOrDefault(c => c.DreId == dre).DreNome;

                var ues = notificacoes.Where(c => c.DreId == dre).Select(c => c.UeId).Distinct();

                foreach (var ue in ues)
                {
                    UeNotificacaoDto ueNotificacaoDto = new UeNotificacaoDto();

                    ueNotificacaoDto.Nome = notificacoes.FirstOrDefault(c => c.UeId == ue).UeNome;

                    var usuarios = notificacoes.Where(c => c.UeId == ue && c.DreId == dre).Select(c => c.UsuarioRf).Distinct();

                    foreach (var usuario in usuarios)
                    {
                        UsuarioNotificacaoDto usuarioNotificacaoDto = new UsuarioNotificacaoDto();
                        var nome = notificacoes.FirstOrDefault(c => c.UsuarioRf == usuario).UsuarioNome;
                        if (String.IsNullOrEmpty(nome))
                        {
                            var usuarioCoreSSO = await mediator.Send(new ObterDadosUsuarioCoreSSOPorRfQuery(usuario));

                            if (usuarioCoreSSO != null)
                            {
                                nome = usuarioCoreSSO.Nome;
                            }
                        }
                        usuarioNotificacaoDto.Nome = nome != null ? $"{nome} ({usuario})"  : usuario;
                        usuarioNotificacaoDto.Notificacoes.AddRange(notificacoes.Where(c => c.UeId == ue && c.DreId == dre && c.UsuarioRf == usuario).OrderBy(n => n.Codigo));
                        ueNotificacaoDto.Usuarios.Add(usuarioNotificacaoDto);
                    }

                    dreNotificacaoDto.UEs.Add(ueNotificacaoDto);
                }

                relatorioNotificacaoDto.DREs.Add(dreNotificacaoDto);
            }

            return(relatorioNotificacaoDto);
        }
        private static async Task ConfirmarLeituraSME_ANO(IMediator mediator, UsuarioNotificacaoDto usuarioMensagem, string cpfUsuario, IEnumerable <ListaEscola> listaEscolas, NotificacaoResposta notificacao)
        {
            var seriesResumidas           = notificacao.SeriesResumidas.ToStringEnumerable();
            var seriesResumidasNaoExistem = !seriesResumidas.Any();
            var alunos =
                listaEscolas
                .Where(escola => notificacao.ModalidadesId.Contains(escola.ModalidadeCodigo.ToString()))
                .SelectMany(escola => escola.Alunos)
                .Where(alunos => (seriesResumidasNaoExistem || seriesResumidas.Contains(alunos.SerieResumida)));

            if (alunos == null || !alunos.Any())
            {
                throw new NegocioException("Nenhum aluno deste usuário está matriculado no grupo/ano desta Notificação");
            }

            foreach (var aluno in alunos)
            {
                await ConfirmarLeitura(mediator, usuarioMensagem, cpfUsuario, aluno);
            }
        }
Esempio n. 8
0
        private static async Task ConfirmarLeituraTurma(IMediator mediator, UsuarioNotificacaoDto usuarioMensagem, string cpfUsuario, IEnumerable <ListaEscola> listaEscolas, NotificacaoResposta notificacao)
        {
            List <Dominio.Entidades.Aluno> alunos = new List <Dominio.Entidades.Aluno>();

            listaEscolas.ForEach(x =>
            {
                var alunosturma = x.Alunos.Where(z => notificacao.Turmas.Any(y => y.CodigoTurma.Equals(z.CodigoTurma.ToString())));

                if (alunosturma != null && alunosturma.Any())
                {
                    alunos.AddRange(alunosturma);
                }
            });

            if (alunos == null || !alunos.Any())
            {
                throw new NegocioException("Nenhum Aluno está matriculado na turma notificada");
            }

            foreach (var aluno in alunos)
            {
                await ConfirmarLeitura(mediator, usuarioMensagem, cpfUsuario, aluno);
            }
        }
Esempio n. 9
0
        private static async Task ConfirmarLeituraAlunoEspecifico(IMediator mediator, UsuarioNotificacaoDto usuarioMensagem, string cpfUsuario, IEnumerable <ListaEscola> listaEscolas)
        {
            List <Dominio.Entidades.Aluno> alunos = new List <Dominio.Entidades.Aluno>();

            listaEscolas.ForEach(escola =>
            {
                var alunosAdicionar = escola.Alunos.Where(x => x.CodigoEol.Equals(usuarioMensagem.CodigoAlunoEol.ToString()));

                if (alunosAdicionar == null || !alunosAdicionar.Any())
                {
                    return;
                }

                alunos.AddRange(alunosAdicionar);
            });

            var alunoEol = alunos.FirstOrDefault();

            if (alunoEol == null)
            {
                throw new NegocioException($"Não encontrado aluno com o codigo {usuarioMensagem.CodigoAlunoEol}");
            }

            await ConfirmarLeitura(mediator, usuarioMensagem, cpfUsuario, alunoEol);
        }
Esempio n. 10
0
 public async Task <ActionResult> MarcarMensagemLida([FromBody] UsuarioNotificacaoDto usuarioMensagem, [FromServices] IMarcarMensagemLidaUseCase marcarMensagemLidaUseCase)
 {
     return(Ok(await marcarMensagemLidaUseCase.Executar(Mediator, usuarioMensagem, User.Identity.Name)));
 }