public async Task <PaginacaoResultadoDto <ComunicadoDto> > Handle(ObterComunicadosPaginadosQuery request, CancellationToken cancellationToken)
        {
            var filtro = new FiltroComunicadoDto
            {
                AnoLetivo     = request.AnoLetivo,
                CodigoDre     = request.CodigoDre,
                CodigoUe      = request.CodigoUe,
                DataEnvio     = request.DataEnvio,
                DataExpiracao = request.DataExpiracao,
                GruposId      = request.GruposId,
                Modalidade    = request.Modalidade,
                Semestre      = request.Semestre,
                Titulo        = request.Titulo,
                Turmas        = request.Turmas
            };

            var validacao = await ValidarAbrangenciaListagem(filtro);

            if (!validacao)
            {
                return(new PaginacaoResultadoDto <ComunicadoDto>());
            }

            var comunicados = await _repositorioComunicado.ListarPaginado(filtro, Paginacao);

            return(MapearParaDtoPaginado(comunicados));
        }
        public async Task <IActionResult> BuscarTodosAsync([FromQuery] FiltroComunicadoDto filtro, [FromServices] IObterComunicadosPaginadosEscolaAquiUseCase obterComunicadosPaginadosEscolaAquiUseCase)
        {
            var resultado = await obterComunicadosPaginadosEscolaAquiUseCase.Executar(filtro);

            if (!resultado.Items.Any())
            {
                return(NoContent());
            }

            return(Ok(resultado));
        }
        private string MontarConsultaPricipal(FiltroComunicadoDto filtro, Paginacao paginacao, bool ehContador = false)
        {
            var whereGrupo = filtro.GruposId?.Length > 0 ? "cgr.grupo_comunicado_id = ANY(@gruposId)" : "";

            var limite = paginacao.QuantidadeRegistros != 0 ? string.Format(" OFFSET {0} ROWS FETCH NEXT {1} ROWS ONLY ", paginacao.QuantidadeRegistrosIgnorados, paginacao.QuantidadeRegistros) : "";

            var whereTurma = (filtro.Turmas?.Any() ?? false) ? "ct.turma_codigo = Any(@Turmas)" : "";

            var where = MontaWhereListar(filtro, "co");

            return(ObterConsultaListagemPrincipal(whereGrupo, limite, where, whereTurma, ehContador));
        }
        public async Task <PaginacaoResultadoDto <ComunicadoDto> > ListarPaginado(FiltroComunicadoDto filtro)
        {
            var validacao = await ValidarAbrangenciaListagem(filtro);

            if (!validacao)
            {
                return(new PaginacaoResultadoDto <ComunicadoDto>());
            }

            var comunicados = await repositorio.ListarPaginado(filtro, Paginacao);

            return(MapearParaDtoPaginado(comunicados));
        }
Beispiel #5
0
 public async Task <PaginacaoResultadoDto <ComunicadoDto> > Executar(FiltroComunicadoDto filtro)
 {
     return(await mediator.Send(new ObterComunicadosPaginadosQuery(filtro.DataEnvio,
                                                                   filtro.DataExpiracao,
                                                                   filtro.GruposId,
                                                                   filtro.Titulo,
                                                                   filtro.AnoLetivo,
                                                                   filtro.CodigoDre,
                                                                   filtro.CodigoUe,
                                                                   filtro.Modalidade,
                                                                   filtro.Semestre,
                                                                   filtro.Turmas)));
 }
        private async Task <bool> ValidarAbrangenciaListagem(FiltroComunicadoDto filtroDto)
        {
            try
            {
                ComunicadoDto comunicado = MapearFiltroDtoValidacao(filtroDto);
                await ValidarAbrangenciaUsuario(comunicado);

                return(true);
            }
            catch (NegocioException)
            {
                return(false);
            }
        }
        public async Task <PaginacaoResultadoDto <Comunicado> > ListarPaginado(FiltroComunicadoDto filtro, Paginacao paginacao)
        {
            StringBuilder query = new StringBuilder();

            var queryPrincipal = MontarConsultaPricipal(filtro, paginacao, ehContador: false);

            var queryCount = MontarConsultaPricipal(filtro, paginacao, ehContador: true);

            if (paginacao == null)
            {
                paginacao = new Paginacao(1, 10);
            }

            query.AppendFormat(queryComunicadoListagem(), ObterCamposListagem("c", "g", "t"), queryPrincipal);

            var parametros = new
            {
                filtro.DataEnvio,
                filtro.DataExpiracao,
                filtro.Titulo,
                filtro.GruposId,
                filtro.AnoLetivo,
                filtro.Modalidade,
                filtro.Semestre,
                filtro.CodigoDre,
                filtro.CodigoUe,
                filtro.Turmas
            };

            var retornoPaginado = new PaginacaoResultadoDto <Comunicado>()
            {
                Items = await database.Conexao.QueryAsync <Comunicado, GrupoComunicacao, Comunicado>(query.ToString(), (comunicado, grupo) =>
                {
                    comunicado.GruposComunicacao.Add(grupo);

                    return(comunicado);
                },
                                                                                                     parametros,
                                                                                                     splitOn : "id,GrupoId")
            };

            retornoPaginado.TotalRegistros = (await database.Conexao.QueryAsync <int>(queryCount.ToString(), parametros)).Sum();

            retornoPaginado.TotalPaginas = (int)Math.Ceiling((double)retornoPaginado.TotalRegistros / paginacao.QuantidadeRegistros);

            return(retornoPaginado);
        }
 private static ComunicadoDto MapearFiltroDtoValidacao(FiltroComunicadoDto filtroDto)
 {
     return(new ComunicadoDto
     {
         AnoLetivo = filtroDto.AnoLetivo,
         CodigoDre = filtroDto.CodigoDre,
         CodigoUe = filtroDto.CodigoUe,
         DataEnvio = filtroDto.DataEnvio ?? DateTime.Now,
         DataExpiracao = filtroDto.DataExpiracao,
         Modalidade = filtroDto.Modalidade,
         Titulo = filtroDto.Titulo,
         Turmas = filtroDto.Turmas?.Select(x => new ComunicadoTurmaDto {
             CodigoTurma = x
         }),
         Semestre = filtroDto.Semestre
     });
 }
        private string MontaWhereListar(FiltroComunicadoDto filtro, string prefixo)
        {
            var where = new StringBuilder();

            where.AppendLine($"AND {prefixo}.ano_letivo = @AnoLetivo");

            if (!string.IsNullOrEmpty(filtro.Titulo))
            {
                filtro.Titulo = $"%{filtro.Titulo.ToUpperInvariant()}%";
                where.AppendLine($"AND (upper(f_unaccent({prefixo}.titulo)) LIKE @titulo)");
            }

            if (filtro.DataEnvio.HasValue)
            {
                where.AppendLine($"AND (date({prefixo}.data_envio) = @DataEnvio)");
            }

            if (filtro.DataExpiracao.HasValue)
            {
                where.AppendLine($"AND (date({prefixo}.data_expiracao) = @DataExpiracao)");
            }

            if (!string.IsNullOrWhiteSpace(filtro.CodigoDre) && !filtro.CodigoDre.Equals("todas"))
            {
                where.AppendLine($"AND {prefixo}.codigo_dre = @CodigoDre");
            }

            if (!string.IsNullOrWhiteSpace(filtro.CodigoUe) && !filtro.CodigoUe.Equals("todas"))
            {
                where.AppendLine($"AND {prefixo}.codigo_ue = @CodigoUe");
            }

            if (filtro.Modalidade > 0)
            {
                where.AppendLine($"AND {prefixo}.modalidade = @Modalidade");
            }

            if (filtro.Semestre > 0)
            {
                where.AppendLine($"AND {prefixo}.semestre = @Semestre");
            }

            return(where.ToString());
        }