Exemple #1
0
        private void TrataListarCpfIrregular(IEnumerable <AlunoResponsavelAdesaoAEDto> alunosResponsaveisParaTratar, IEnumerable <UsuarioAEDto> usuariosDoApp, TurmaResumoDto turma, AdesaoAETurmaDto turmaParaAdicionar)
        {
            var alunosResponsaveisDaTurma = alunosResponsaveisParaTratar.Where(a => a.TurmaCodigo == long.Parse(turma.Codigo) &&
                                                                               !UtilCPF.Valida(a.ResponsavelCpf)).OrderBy(a => a.NomeAlunoParaVisualizar());

            foreach (var alunoResponsaveisDaTurma in alunosResponsaveisDaTurma)
            {
                var alunoResponsavelParaAdicionar = new AdesaoAEUeAlunoDto()
                {
                    Contato        = alunoResponsaveisDaTurma.ResponsavelCelularFormatado(),
                    CpfResponsavel = alunoResponsaveisDaTurma.ResponsavelCpf?.ToString(),
                    Responsavel    = alunoResponsaveisDaTurma.ResponsavelNome?.Trim(),
                    Estudante      = alunoResponsaveisDaTurma.NomeAlunoParaVisualizar(),
                    Numero         = alunoResponsaveisDaTurma.AlunoNumeroChamada
                };
                turmaParaAdicionar.Alunos.Add(alunoResponsavelParaAdicionar);
            }
        }
Exemple #2
0
        private void TrataListarTodosCpf(IEnumerable <AlunoResponsavelAdesaoAEDto> alunosResponsaveisParaTratar, IEnumerable <UsuarioAEDto> usuariosDoApp, TurmaResumoDto turma, AdesaoAETurmaDto turmaParaAdicionar)
        {
            var alunosResponsaveisDaTurma = alunosResponsaveisParaTratar.Where(a => a.TurmaCodigo == long.Parse(turma.Codigo)).OrderBy(a => a.NomeAlunoParaVisualizar());

            foreach (var alunoResponsaveisDaTurma in alunosResponsaveisDaTurma)
            {
                var usuarioApp = usuariosDoApp.FirstOrDefault(a => a.Cpf == alunoResponsaveisDaTurma.ResponsavelCpf);

                var alunoResponsavelParaAdicionar = new AdesaoAEUeAlunoDto()
                {
                    Contato        = alunoResponsaveisDaTurma.ResponsavelCelularFormatado(),
                    CpfResponsavel = alunoResponsaveisDaTurma.ResponsavelCpf?.ToString(),
                    Responsavel    = alunoResponsaveisDaTurma.ResponsavelNome.Trim(),
                    Estudante      = alunoResponsaveisDaTurma.NomeAlunoParaVisualizar(),
                    Numero         = alunoResponsaveisDaTurma.AlunoNumeroChamada?.Trim(),
                    UltimoAcesso   = usuarioApp?.UltimoLogin.ToString("dd/MM/yyyy HH:mm"),
                    SituacaoNoApp  = ObtemSituacaoApp(usuarioApp, alunoResponsaveisDaTurma)
                };

                turmaParaAdicionar.Alunos.Add(alunoResponsavelParaAdicionar);
            }
        }
Exemple #3
0
        private async Task TrataUe(ObterListaRelatorioAdessaoAEQuery request, AdesaoAERetornoDto retorno)
        {
            retorno.MostraUe = true;

            var registroUeParaTratar = request.ListaConsolida.FirstOrDefault(a => a.TurmaCodigo == 0 && !string.IsNullOrEmpty(a.UeCodigo));

            var nomeDaUe = await mediator.Send(new ObterUePorCodigoQuery(request.RelatorioFiltros.UeCodigo));

            var valoresDaUe = new AdesaoAEValoresDto()
            {
                NaoRealizaram            = registroUeParaTratar.SemAppInstalado,
                SemCpfOuCpfInvalido      = registroUeParaTratar.CpfsInvalidos,
                PrimeiroAcessoIncompleto = registroUeParaTratar.PrimeiroAcessoIncompleto,
                Validos = registroUeParaTratar.Validos,
                Nome    = nomeDaUe?.NomeComTipoEscola
            };

            var UeParaAdicionar = new AdesaoAeUeRetornoDto()
            {
                Valores = valoresDaUe
            };

            var turmasCodigos = request.ListaConsolida.Select(a => a.TurmaCodigo.ToString()).Distinct().ToArray();

            var turmasEModalidades = await mediator.Send(new ObterTurmasEModalidadesPorCodigoTurmasQuery(turmasCodigos));

            var turmasAgrupadasPorModalidade = turmasEModalidades
                                               .GroupBy(a => a.Modalidade)
                                               .ToList();

            var devePreencherModalidade = turmasAgrupadasPorModalidade.Count > 1;

            foreach (var turmaAgrupadasPorModalidade in turmasAgrupadasPorModalidade)
            {
                var valoresDaMolidade = new AdesaoAEValoresDto();

                var codigosTurmasDaModalidade = turmaAgrupadasPorModalidade.Select(a => long.Parse(a.Codigo)).Distinct();


                var turmasEValoresDaModalidade = request.ListaConsolida
                                                 .Where(a => codigosTurmasDaModalidade.Contains(a.TurmaCodigo))
                                                 .ToList();

                if (devePreencherModalidade)
                {
                    valoresDaMolidade.NaoRealizaram            = turmasEValoresDaModalidade.Sum(a => a.SemAppInstalado);
                    valoresDaMolidade.Nome                     = turmaAgrupadasPorModalidade.Key.Name();
                    valoresDaMolidade.PrimeiroAcessoIncompleto = turmasEValoresDaModalidade.Sum(a => a.PrimeiroAcessoIncompleto);
                    valoresDaMolidade.SemCpfOuCpfInvalido      = turmasEValoresDaModalidade.Sum(a => a.CpfsInvalidos);
                    valoresDaMolidade.Validos                  = turmasEValoresDaModalidade.Sum(a => a.Validos);
                }

                var modalidadeParaAdicionar = new AdesaoAEModalidadeDto()
                {
                    Valores = valoresDaMolidade
                };

                var alunosResponsaveisParaTratar = await mediator.Send(new ObterAlunosResponsaveisPorTurmasCodigoRelatorioAdesaoQuery(codigosTurmasDaModalidade.ToArray()));

                var cpfsDosResponsaveis = alunosResponsaveisParaTratar.Select(a => a.ResponsavelCpf).Distinct().ToArray();

                var usuariosDoApp = await mediator.Send(new ObterUsuariosAePorCpfsQuery(cpfsDosResponsaveis));

                foreach (var turma in turmaAgrupadasPorModalidade)
                {
                    var turmaParaTratar          = turmasEValoresDaModalidade.FirstOrDefault(a => a.TurmaCodigo == long.Parse(turma.Codigo));
                    var valoresDaTurmaParaTratar = new AdesaoAEValoresDto();

                    valoresDaTurmaParaTratar.NaoRealizaram            = turmaParaTratar.SemAppInstalado;
                    valoresDaTurmaParaTratar.Nome                     = $"{turmaAgrupadasPorModalidade.Key.ShortName()}-{turma.Nome}";
                    valoresDaTurmaParaTratar.PrimeiroAcessoIncompleto = turmaParaTratar.PrimeiroAcessoIncompleto;
                    valoresDaTurmaParaTratar.SemCpfOuCpfInvalido      = turmaParaTratar.CpfsInvalidos;
                    valoresDaTurmaParaTratar.Validos                  = turmaParaTratar.Validos;

                    var turmaParaAdicionar = new AdesaoAETurmaDto()
                    {
                        Valores = valoresDaTurmaParaTratar
                    };

                    switch (request.RelatorioFiltros.OpcaoListaUsuarios)
                    {
                    case FiltroRelatorioAEAdesaoEnum.ListarUsuariosNao:
                        UeParaAdicionar.MostraColunaSituacao = false;
                        break;

                    case FiltroRelatorioAEAdesaoEnum.ListarUsuariosValidos:
                        UeParaAdicionar.MostraColunaSituacao = false;
                        TrataListarCpfValidos(alunosResponsaveisParaTratar, usuariosDoApp, turma, turmaParaAdicionar);
                        break;

                    case FiltroRelatorioAEAdesaoEnum.ListarUsuariosCPFIrregular:
                        TrataListarCpfIrregular(alunosResponsaveisParaTratar, usuariosDoApp, turma, turmaParaAdicionar);
                        UeParaAdicionar.MostraColunaSituacao = false;
                        break;

                    case FiltroRelatorioAEAdesaoEnum.ListarUsuariosCPFTodos:
                        UeParaAdicionar.MostraColunaSituacao = true;
                        TrataListarTodosCpf(alunosResponsaveisParaTratar, usuariosDoApp, turma, turmaParaAdicionar);
                        break;

                    default:
                        break;
                    }
                    modalidadeParaAdicionar.Turmas.Add(turmaParaAdicionar);
                }
                modalidadeParaAdicionar.Turmas = modalidadeParaAdicionar.Turmas.OrderBy(a => a.Valores.Nome).ToList();

                UeParaAdicionar.Modalidades.Add(modalidadeParaAdicionar);
            }

            UeParaAdicionar.Modalidades = UeParaAdicionar.Modalidades.OrderBy(a => a.Valores.Nome).ToList();


            retorno.UE = UeParaAdicionar;
        }