public async Task <PaginacaoResultadoDto <AtribuicaoEsporadica> > ListarPaginada(Paginacao paginacao, int anoLetivo, string dreId, string ueId, string codigoRF)
{
var retorno = new PaginacaoResultadoDto <AtribuicaoEsporadica>();
var sql = MontaQueryCompleta(paginacao, codigoRF);
var parametros = new { inicioAno = new DateTime(anoLetivo, 1, 1), fimAno = new DateTime(anoLetivo, 12, 31), dreId, ueId, codigoRF };
using (var multi = await database.Conexao.QueryMultipleAsync(sql, parametros))
{
retorno.Items = multi.Read <AtribuicaoEsporadica>().ToList();
retorno.TotalRegistros = multi.ReadFirst <int>();
}
retorno.TotalPaginas = (int)Math.Ceiling((double)retorno.TotalRegistros / paginacao.QuantidadeRegistros);
return(retorno);
}
public async Task <PaginacaoResultadoDto <AtribuicaoEsporadicaDto> > Listar(FiltroAtribuicaoEsporadicaDto filtro)
{
var retornoConsultaPaginada = await repositorioAtribuicaoEsporadica.ListarPaginada(Paginacao, filtro.AnoLetivo, filtro.DreId, filtro.UeId, filtro.ProfessorRF);
var retorno = new PaginacaoResultadoDto <AtribuicaoEsporadicaDto>
{
TotalPaginas = retornoConsultaPaginada.TotalPaginas,
TotalRegistros = retornoConsultaPaginada.TotalRegistros
};
bool nenhumItemEncontrado = retornoConsultaPaginada.Items == null ||
!retornoConsultaPaginada.Items.Any() ||
retornoConsultaPaginada.Items.ElementAt(0).Id == 0;
retorno.Items = !nenhumItemEncontrado?ListaEntidadeParaListaDto(retornoConsultaPaginada.Items) : null;
return(retorno);
}
public async Task <PaginacaoResultadoDto <EventoTipo> > ListarTipos(EventoLocalOcorrencia eventoLocalOcorrencia, EventoLetivo eventoLetivo, string descricao, Paginacao paginacao)
{
var retorno = new PaginacaoResultadoDto <EventoTipo>();
StringBuilder sql = MontaQueryCompleta(eventoLocalOcorrencia, eventoLetivo, descricao, paginacao);
var parametros = new { local_ocorrencia = eventoLocalOcorrencia, letivo = eventoLetivo, descricao = $"%{descricao?.ToLowerInvariant()}%" };
using (var multi = await database.Conexao.QueryMultipleAsync(sql.ToString(), parametros))
{
retorno.Items = multi.Read <EventoTipo>().ToList();
retorno.TotalRegistros = multi.ReadFirst <int>();
}
retorno.TotalPaginas = (int)Math.Ceiling((double)retorno.TotalRegistros / paginacao.QuantidadeRegistros);
return(retorno);
}
public async Task <PaginacaoResultadoDto <RegistroPoa> > ListarPaginado(string codigoRf, string dreId, int bimestre, string ueId, string titulo, int anoLetivo, Paginacao paginacao)
{
var retorno = new PaginacaoResultadoDto <RegistroPoa>();
var sql = MontaQueryCompleta(paginacao, titulo, bimestre);
var parametros = new { codigoRf, bimestre, ueId, dreId, titulo = $"%{titulo?.ToLower()}%", anoLetivo };
using (var multi = await database.Conexao.QueryMultipleAsync(sql, parametros))
{
retorno.Items = multi.Read <RegistroPoa>().ToList();
retorno.TotalRegistros = multi.ReadFirst <int>();
}
retorno.TotalPaginas = (int)Math.Ceiling((double)retorno.TotalRegistros / paginacao.QuantidadeRegistros);
return(retorno);
}
public async Task <PaginacaoResultadoDto <UsuarioInativoDto> > ObterUsuariosInativosPorTipo(Paginacao paginacao, UsuarioTipo usuarioTipo)
{
var query = new StringBuilder(@"SELECT
ui.id as Id,
ui.usuario_id UsuarioId,
ui.usuario_tipo UsuarioTipo,
ui.inativado_em InativadoEm,
u.nome,
u.email,
u.organization_path as UnidadeOrganizacional,
u.google_classroom_id as GoogleClassroomId
FROM usuario_inativo ui
inner join usuarios u on u.indice = ui.usuario_id
WHERE ui.usuario_tipo = @usuarioTipo ");
var queryCount = new StringBuilder("SELECT count(*) from usuario_inativo ui WHERE ui.usuario_tipo = @usuarioTipo ");
if (paginacao.QuantidadeRegistros > 0)
{
query.AppendLine($" OFFSET @quantidadeRegistrosIgnorados ROWS FETCH NEXT @quantidadeRegistros ROWS ONLY ");
}
query.AppendLine(";");
query.AppendLine(queryCount.ToString());
var retorno = new PaginacaoResultadoDto <UsuarioInativoDto>();
var parametros = new
{
paginacao.QuantidadeRegistrosIgnorados,
paginacao.QuantidadeRegistros,
usuarioTipo
};
using var conn = ObterConexao();
using var registros = await conn.QueryMultipleAsync(query.ToString(), parametros);
retorno.Items = registros.Read <UsuarioInativoDto>();
retorno.TotalRegistros = registros.ReadFirst <int>();
retorno.TotalPaginas = (int)Math.Ceiling((double)retorno.TotalRegistros / paginacao.QuantidadeRegistros);
return(retorno);
}
public async Task <PaginacaoResultadoDto <DocumentoDto> > ObterPorUeTipoEClassificacaoPaginada(long ueId, long tipoDocumentoId,
long classificacaoId, Paginacao paginacao)
{
var retorno = new PaginacaoResultadoDto <DocumentoDto>();
var sql = MontaQueryCompleta(paginacao, tipoDocumentoId, classificacaoId);
var parametros = new { ueId, tipoDocumentoId, classificacaoId };
using (var multi = await database.Conexao.QueryMultipleAsync(sql, parametros))
{
retorno.Items = multi.Read <DocumentoDto>().ToList();
retorno.TotalRegistros = multi.ReadFirst <int>();
}
retorno.TotalPaginas = (int)Math.Ceiling((double)retorno.TotalRegistros / paginacao.QuantidadeRegistros);
return(retorno);
}
public async Task <RegistrosIndividuaisPeriodoDto> Handle(ObterRegistrosIndividuaisPorAlunoPeriodoQuery request, CancellationToken cancellationToken)
{
var registrosIndividuais = await repositorioRegistroIndividual.ObterPorAlunoPeriodoPaginado(request.TurmaId, request.ComponenteCurricularId, request.AlunoCodigo, request.DataInicio, request.DataFim, Paginacao);
PaginacaoResultadoDto <RegistroIndividualDto> registrosDto = null;
if (registrosIndividuais != null && registrosIndividuais.Items.Any())
{
registrosDto = MapearParaDto(registrosIndividuais);
}
var turma = await mediator.Send(new ObterTurmaPorIdQuery(request.TurmaId));
return(new RegistrosIndividuaisPeriodoDto()
{
PodeRealizarNovoRegistro = !turma.EhTurmaHistorica,
RegistrosIndividuais = registrosDto
});
}
public async Task <PaginacaoResultadoDto <AlunoGoogle> > ObterAlunosPaginadoPorCodigos(Paginacao paginacao, long[] codigosAluno)
{
var query = new StringBuilder(@"SELECT
u.indice,
u.nome,
u.id as Codigo,
u.usuario_tipo as usuariotipo,
u.email,
u.organization_path as organizationpath,
u.data_inclusao as datainclusao,
u.data_atualizacao as dataatualizacao,
u.google_classroom_id as GoogleClassroomId
FROM usuarios u
WHERE usuario_tipo = @tipo
and id = any(@codigosAluno)");
if (paginacao.QuantidadeRegistros > 0)
{
query.AppendLine($" OFFSET @quantidadeRegistrosIgnorados ROWS FETCH NEXT @quantidadeRegistros ROWS ONLY ;");
}
query.AppendLine("SELECT count(*) from usuarios u WHERE usuario_tipo = @tipo and id = any(@codigosAluno)");
var retorno = new PaginacaoResultadoDto <AlunoGoogle>();
var parametros = new
{
paginacao.QuantidadeRegistrosIgnorados,
paginacao.QuantidadeRegistros,
codigosAluno,
tipo = UsuarioTipo.Aluno
};
using var conn = ObterConexao();
using var professores = await conn.QueryMultipleAsync(query.ToString(), parametros);
retorno.Items = professores.Read <AlunoGoogle>();
retorno.TotalRegistros = professores.ReadFirst <int>();
retorno.TotalPaginas = (int)Math.Ceiling((double)retorno.TotalRegistros / paginacao.QuantidadeRegistros);
return(retorno);
}
public async Task <PaginacaoResultadoDto <EventoTipoDto> > Listar(FiltroEventoTipoDto Filtro)
{
var retornoQueryPaginada = await repositorioEventoTipo.ListarTipos(Filtro.LocalOcorrencia, Filtro.Letivo, Filtro.Descricao, Paginacao);
var retornoConsultaPaginada = new PaginacaoResultadoDto <EventoTipoDto>
{
TotalPaginas = retornoQueryPaginada.TotalPaginas,
TotalRegistros = retornoQueryPaginada.TotalRegistros
};
bool nenhumItemEncontrado = retornoQueryPaginada.Items == null ||
!retornoQueryPaginada.Items.Any() ||
retornoQueryPaginada.Items.ElementAt(0).Id == 0;
retornoConsultaPaginada.Items = nenhumItemEncontrado
? null
: retornoQueryPaginada.Items.Select(x => EntidadeParaDto(x)).ToList();
return(retornoConsultaPaginada);
}
public async Task DeveListarEventos()
{
var listaEventos = new List <Evento>
{
new Evento
{
Id = 1
}
};
var paginado = new PaginacaoResultadoDto <Evento>();
paginado.Items = listaEventos;
repositorioEvento.Setup(c => c.Listar(It.IsAny <long?>(), It.IsAny <long?>(), It.IsAny <string>(), It.IsAny <DateTime?>(), It.IsAny <DateTime?>(), It.IsAny <Paginacao>()))
.Returns(Task.FromResult(paginado));
var eventosPaginados = await consultaEventos.Listar(new FiltroEventosDto());
Assert.NotNull(eventosPaginados);
Assert.Contains(eventosPaginados.Items, c => c.Id == 1);
repositorioEvento.Verify(c => c.Listar(It.IsAny <long?>(), It.IsAny <long?>(), It.IsAny <string>(), It.IsAny <DateTime?>(), It.IsAny <DateTime?>(), It.IsAny <Paginacao>()), Times.Once);
}
public async Task <PaginacaoResultadoDto <CompensacaoAusencia> > Listar(Paginacao paginacao, string turmaId, string disciplinaId, int bimestre, string nomeAtividade)
{
var retorno = new PaginacaoResultadoDto <CompensacaoAusencia>();
var query = new StringBuilder(MontaQuery(paginacao, disciplinaId, bimestre, nomeAtividade));
query.AppendLine(";");
query.AppendLine(MontaQuery(paginacao, disciplinaId, bimestre, nomeAtividade, true));
var nomeAtividadeTratado = $"%{(nomeAtividade ?? "").ToLower()}%";
using (var multi = await database.Conexao.QueryMultipleAsync(query.ToString(), new { turmaId, disciplinaId, bimestre, nomeAtividade = nomeAtividadeTratado }))
{
retorno.Items = multi.Read <CompensacaoAusencia>().ToList();
retorno.TotalRegistros = multi.ReadFirst <int>();
}
retorno.TotalPaginas = (int)Math.Ceiling((double)retorno.TotalRegistros / paginacao.QuantidadeRegistros);
return(retorno);
}
public async Task <PaginacaoResultadoDto <Notificacao> > Obter(string dreId, string ueId, int statusId,
string turmaId, string usuarioRf, int tipoId, int categoriaId, string titulo, long codigo, int anoLetivo, Paginacao paginacao)
{
var query = new StringBuilder();
MontaQueryObterCompleta(dreId, ueId, statusId, turmaId, usuarioRf, tipoId, categoriaId, titulo, codigo, anoLetivo, paginacao, query,
paginacao.QuantidadeRegistros, paginacao.QuantidadeRegistrosIgnorados);
MontaQueryObterCount(dreId, ueId, statusId, turmaId, usuarioRf, tipoId, categoriaId, titulo, codigo, anoLetivo, query);
var retornoPaginado = new PaginacaoResultadoDto <Notificacao>();
if (!string.IsNullOrEmpty(titulo))
{
titulo = $"%{titulo}%";
}
using (var multi = await database.Conexao.QueryMultipleAsync(query.ToString(), new
{
dreId,
ueId,
turmaId,
statusId,
tipoId,
usuarioRf,
categoriaId,
titulo,
codigo,
anoLetivo
}))
{
retornoPaginado.Items = multi.Read <Notificacao>().ToList();
retornoPaginado.TotalRegistros = multi.ReadFirst <int>();
}
retornoPaginado.TotalPaginas = (int)Math.Ceiling((double)retornoPaginado.TotalRegistros / paginacao.QuantidadeRegistros);
return(retornoPaginado);
}
private PaginacaoResultadoDto <RegistroIndividualDto> MapearParaDto(PaginacaoResultadoDto <RegistroIndividual> registros)
{
return(new PaginacaoResultadoDto <RegistroIndividualDto>()
{
Items = registros.Items.Select(registro =>
{
return new RegistroIndividualDto()
{
Id = registro.Id,
AlunoCodigo = registro.AlunoCodigo,
Auditoria = (AuditoriaDto)registro,
ComponenteCurricularId = registro.ComponenteCurricularId,
Data = registro.DataRegistro,
Excluido = registro.Excluido,
Migrado = registro.Migrado,
Registro = registro.Registro,
TurmaId = registro.TurmaId
};
}),
TotalPaginas = registros.TotalPaginas,
TotalRegistros = registros.TotalRegistros
});
}
private PaginacaoResultadoDto <OcorrenciaListagemDto> MapearParaDto(PaginacaoResultadoDto <Ocorrencia> ocorrencias, IEnumerable <AlunoPorTurmaResposta> alunos)
{
return(new PaginacaoResultadoDto <OcorrenciaListagemDto>()
{
Items = ocorrencias.Items.Select(ocorrencia =>
{
var alunoOcorrencia = ocorrencia.Alunos.Count > 1
? $"{ocorrencia.Alunos.Count} crianças"
: DefinirDescricaoOcorrenciaAluno(alunos, ocorrencia);
return new OcorrenciaListagemDto()
{
AlunoOcorrencia = alunoOcorrencia,
DataOcorrencia = ocorrencia.DataOcorrencia.ToString("dd/MM/yyyy"),
Id = ocorrencia.Id,
Titulo = ocorrencia.Titulo,
TurmaId = ocorrencia.TurmaId
};
}),
TotalRegistros = ocorrencias.TotalRegistros,
TotalPaginas = ocorrencias.TotalPaginas
});
}
public async Task <PaginacaoResultadoDto <FuncionarioIndiretoEol> > ObterFuncionariosIndiretosParaInclusaoAsync(DateTime dataReferencia, Paginacao paginacao, string cpf)
{
using var conn = ObterConexao();
var aplicarPaginacao = paginacao.QuantidadeRegistros > 0;
var query = MontaQueryFuncionariosIndiretosParaInclusao(aplicarPaginacao, cpf);
var parametros = new
{
dataReferencia = dataReferencia.Date,
paginacao.QuantidadeRegistros,
paginacao.QuantidadeRegistrosIgnorados,
cpf
};
using var multi = await conn.QueryMultipleAsync(query, parametros);
var retorno = new PaginacaoResultadoDto <FuncionarioIndiretoEol>();
retorno.Items = multi.Read <FuncionarioIndiretoEol>();
retorno.TotalRegistros = multi.ReadFirst <int>();
retorno.TotalPaginas = aplicarPaginacao ? (int)Math.Ceiling((double)retorno.TotalRegistros / paginacao.QuantidadeRegistros) : 1;
return(retorno);
}
public async Task <PaginacaoResultadoDto <UsuarioParaAtualizacaoGoogleClassroomIdDto> > ObterAtualizacaoUsuarioGoogleClassroomIdAsync(Paginacao paginacao)
{
const string queryBase = @"
SELECT
u.usuario_id AS UsuarioId,
u.email
FROM __atualizacao_usuario_googleclassroom_id u ";
var realizarPaginacao = paginacao.QuantidadeRegistros > 0;
var query = new StringBuilder(queryBase);
query.AppendLine(realizarPaginacao
? "OFFSET @quantidadeRegistrosIgnorados ROWS FETCH NEXT @quantidadeRegistros ROWS ONLY; "
: "; ");
query.AppendLine("SELECT count(*) FROM __atualizacao_usuario_googleclassroom_id;");
var parametros = new
{
paginacao.QuantidadeRegistrosIgnorados,
paginacao.QuantidadeRegistros
};
using var conn = ObterConexao();
using var usuarios = await conn.QueryMultipleAsync(query.ToString(), parametros);
var retorno = new PaginacaoResultadoDto <UsuarioParaAtualizacaoGoogleClassroomIdDto>();
retorno.Items = usuarios.Read <UsuarioParaAtualizacaoGoogleClassroomIdDto>();
retorno.TotalRegistros = usuarios.ReadFirst <int>();
retorno.TotalPaginas = realizarPaginacao ? (int)Math.Ceiling((double)retorno.TotalRegistros / paginacao.QuantidadeRegistros) : default;
return(retorno);
}
private PaginacaoResultadoDto <FechamentoReaberturaListagemDto> MapearListaEntidadeParaDto(PaginacaoResultadoDto <FechamentoReabertura> listaEntidades)
{
var retorno = new PaginacaoResultadoDto <FechamentoReaberturaListagemDto>();
retorno.TotalPaginas = listaEntidades.TotalPaginas;
retorno.TotalRegistros = listaEntidades.TotalRegistros;
retorno.Items = MapearListaEntidadeParaDto(listaEntidades.Items);
return(retorno);
}
public async Task <PaginacaoResultadoDto <AlunoEol> > ObterAlunosQueSeraoRemovidosPorAnoLetivoETurma(ParametrosCargaInicialDto parametrosCargaInicialDto, Paginacao paginacao, int anoLetivo, long turmaId, DateTime dataReferencia, bool ehDataReferenciaPrincipal)
{
using var conn = ObterConexao();
var querySelectDados = @"
SELECT
DISTINCT a.cd_aluno AS Codigo,
a.nm_aluno AS NomePessoa,
a.nm_social_aluno AS NomeSocial,
a.dt_nascimento_aluno AS DataNascimento,
te.cd_turma_escola AS TurmaId,
mte.cd_situacao_aluno as SituacaoMatricula,
mte.dt_situacao_aluno as DataSituacao " ;
var querySelectCount = "SELECT COUNT(DISTINCT a.cd_aluno) ";
var queryFrom = new StringBuilder(@"
FROM
v_aluno_cotic aluno (NOLOCK)
INNER JOIN
aluno a
ON aluno.cd_aluno = a.cd_aluno
INNER JOIN
v_matricula_cotic matr (NOLOCK)
ON aluno.cd_aluno = matr.cd_aluno
INNER JOIN
matricula_turma_escola mte (NOLOCK)
ON matr.cd_matricula = mte.cd_matricula
INNER JOIN
turma_escola te (NOLOCK)
ON mte.cd_turma_escola = te.cd_turma_escola
INNER JOIN
escola esc (NOLOCK)
ON te.cd_escola = esc.cd_escola
WHERE
mte.cd_situacao_aluno IN (2,3,4,7,8,11,12,14,15)
AND matr.an_letivo = @anoLetivo
AND te.an_letivo = @anoLetivo " );
if (turmaId > 0)
{
queryFrom.AppendLine("AND te.cd_turma_escola = @turmaId ");
}
if (ehDataReferenciaPrincipal)
{
queryFrom.AppendLine("AND mte.dt_situacao_aluno = @dataReferencia ");
}
else
{
queryFrom.AppendLine("AND mte.dt_situacao_aluno <= @dataReferencia ");
}
queryFrom.AppendLine(@"and mte.dt_situacao_aluno = (select max(mte2.dt_situacao_aluno) from v_matricula_cotic matr2(NOLOCK)
inner join matricula_turma_escola mte2 (NOLOCK) on mte2.cd_matricula = matr2.cd_matricula
where matr2.cd_aluno = a.cd_aluno
and matr2.an_letivo = te.an_letivo
and mte2.cd_turma_escola = te.cd_turma_escola) " );
queryFrom.AdicionarCondicaoIn(parametrosCargaInicialDto.TiposUes, "esc.tp_escola", nameof(parametrosCargaInicialDto.TiposUes));
queryFrom.AdicionarCondicaoIn(parametrosCargaInicialDto.Ues, "te.cd_escola", nameof(parametrosCargaInicialDto.Ues));
queryFrom.AdicionarCondicaoIn(parametrosCargaInicialDto.Turmas, "te.cd_turma_escola", nameof(parametrosCargaInicialDto.Turmas));
var queryPaginacao = @"order by mte.dt_situacao_aluno desc
offset @quantidadeRegistrosIgnorados rows fetch next @quantidadeRegistros rows only;" ;
var query = new StringBuilder(querySelectDados);
query.Append(queryFrom);
query.Append(queryPaginacao);
query.Append(querySelectCount);
query.Append(queryFrom);
using var multi = await conn.QueryMultipleAsync(query.ToString(),
new
{
quantidadeRegistros = paginacao.QuantidadeRegistros,
quantidadeRegistrosIgnorados = paginacao.QuantidadeRegistrosIgnorados,
anoLetivo,
dataReferencia,
turmaId
}, commandTimeout : 6000);
var retorno = new PaginacaoResultadoDto <AlunoEol>
{
Items = multi.Read <AlunoEol>(),
TotalRegistros = multi.ReadFirst <int>()
};
retorno.TotalPaginas = paginacao.QuantidadeRegistros > 0 ? (int)Math.Ceiling((double)retorno.TotalRegistros / paginacao.QuantidadeRegistros) : 1;
return(retorno);
}
public async Task <PaginacaoResultadoDto <AlunoEol> > ObterAlunosQueSeraoInativosPorAnoLetivo(Paginacao paginacao, int anoLetivo, DateTime dataReferencia)
{
var querySelectDados = @" SELECT
DISTINCT a.cd_aluno AS Codigo,
a.nm_aluno AS NomePessoa,
a.nm_social_aluno AS NomeSocial,
a.dt_nascimento_aluno AS DataNascimento,
te.cd_turma_escola AS TurmaId,
mte.cd_situacao_aluno as SituacaoMatricula,
mte.dt_situacao_aluno as DataSituacao" ;
var querySelectCount = "SELECT COUNT(DISTINCT a.cd_aluno) ";
var queryFrom = new StringBuilder(@" FROM
v_aluno_cotic aluno (NOLOCK)
INNER JOIN
aluno a
ON aluno.cd_aluno = a.cd_aluno
INNER JOIN
v_matricula_cotic matr (NOLOCK)
ON aluno.cd_aluno = matr.cd_aluno
INNER JOIN
matricula_turma_escola mte (NOLOCK)
ON matr.cd_matricula = mte.cd_matricula
INNER JOIN
turma_escola te (NOLOCK)
ON mte.cd_turma_escola = te.cd_turma_escola
INNER JOIN
escola esc (NOLOCK)
ON te.cd_escola = esc.cd_escola
WHERE
mte.cd_situacao_aluno IN (2,3,4,5,7,8,11,12,14,15)
AND matr.an_letivo = @anoLetivo
AND te.an_letivo = @anoLetivo
AND matr.dt_status_matricula >= @dataReferencia
AND NOT EXISTS (select 1
from v_matricula_cotic v2
inner join matricula_turma_escola m2 ON
v2.cd_matricula = m2.cd_matricula
where v2.an_letivo >= matr.an_letivo
and v2.cd_aluno = a.cd_aluno
and m2.cd_situacao_aluno IN(1,6,10,13) )
" );
var queryPaginacao = @"order by a.cd_aluno
offset @quantidadeRegistrosIgnorados rows fetch next @quantidadeRegistros rows only;" ;
var query = new StringBuilder(querySelectDados);
query.Append(queryFrom);
query.Append(queryPaginacao);
query.Append(querySelectCount);
query.Append(queryFrom);
using var conn = ObterConexao();
using var multi = await conn.QueryMultipleAsync(query.ToString(),
new
{
quantidadeRegistros = paginacao.QuantidadeRegistros,
quantidadeRegistrosIgnorados = paginacao.QuantidadeRegistrosIgnorados,
anoLetivo,
dataReferencia
}, commandTimeout : 6000);
var retorno = new PaginacaoResultadoDto <AlunoEol>
{
Items = multi.Read <AlunoEol>(),
TotalRegistros = multi.ReadFirst <int>()
};
retorno.TotalPaginas = paginacao.QuantidadeRegistros > 0 ? (int)Math.Ceiling((double)retorno.TotalRegistros / paginacao.QuantidadeRegistros) : 1;
return(retorno);
}
private PaginacaoResultadoDto <RecuperacaoParalelaTotalResultadoDto> MapearResultadoPaginadoParaDto(PaginacaoResultadoDto <RetornoRecuperacaoParalelaTotalResultadoDto> totalResumo)
{
return(new PaginacaoResultadoDto <RecuperacaoParalelaTotalResultadoDto>
{
Items = MapearResultadoParaDto(totalResumo.Items),
TotalPaginas = totalResumo.TotalPaginas,
TotalRegistros = totalResumo.TotalRegistros
});
}
private PaginacaoResultadoDto <TipoAvaliacaoCompletaDto> MapearParaDtoComPaginacao(PaginacaoResultadoDto <TipoAvaliacao> tipoAvaliacaoPaginado)
{
if (tipoAvaliacaoPaginado == null)
{
tipoAvaliacaoPaginado = new PaginacaoResultadoDto <TipoAvaliacao>();
}
return(new PaginacaoResultadoDto <TipoAvaliacaoCompletaDto>
{
Items = MapearTipoAvaliacaoDtoaParaDto(tipoAvaliacaoPaginado.Items),
TotalPaginas = tipoAvaliacaoPaginado.TotalPaginas,
TotalRegistros = tipoAvaliacaoPaginado.TotalRegistros
});
}
private PaginacaoResultadoDto <AtividadeAvaliativaCompletaDto> MapearParaDtoComPaginacao(PaginacaoResultadoDto <AtividadeAvaliativa> atividadeAvaliativaPaginado)
{
if (atividadeAvaliativaPaginado == null)
{
atividadeAvaliativaPaginado = new PaginacaoResultadoDto <AtividadeAvaliativa>();
}
return(new PaginacaoResultadoDto <AtividadeAvaliativaCompletaDto>
{
Items = MapearAtividadeAvaliativaParaDto(atividadeAvaliativaPaginado.Items),
TotalPaginas = atividadeAvaliativaPaginado.TotalPaginas,
TotalRegistros = atividadeAvaliativaPaginado.TotalRegistros
});
}
private PaginacaoResultadoDto <RegistroPoaDto> MapearListagem(PaginacaoResultadoDto <RegistroPoa> retornoquery, PaginacaoResultadoDto <RegistroPoaDto> retornoPaginado, bool nenhumItemEncontrado, IEnumerable <ProfessorResumoDto> nomes)
{
retornoPaginado.Items = nenhumItemEncontrado ? null : retornoquery.Items.Select(registro =>
{
var professor = nomes.FirstOrDefault(resumo => resumo.CodigoRF.Equals(registro.CodigoRf));
return(MapearParaDto(registro, professor == null ? "Professor não encontrado" : professor.Nome));
});
return(retornoPaginado);
}
private async Task <PaginacaoResultadoDto <PendenciaDto> > MapearParaDtoPaginado(PaginacaoResultadoDto <Pendencia> pendenciasPaginadas)
{
return(new PaginacaoResultadoDto <PendenciaDto>()
{
Items = await MapearParaDto(pendenciasPaginadas.Items),
TotalPaginas = pendenciasPaginadas.TotalPaginas,
TotalRegistros = pendenciasPaginadas.TotalRegistros
});
}
public async Task <PaginacaoResultadoDto <ProfessorCursosCadastradosDto> > ObterProfessoresCursosAsync(Paginacao paginacao, long?rf, long?turmaId, long?componenteCurricularId)
{
try
{
var query = new StringBuilder(@"DROP TABLE IF EXISTS professorTemp;
DROP TABLE IF EXISTS professorTempPaginado;
select distinct
u.indice,
u.google_classroom_id AS googleclassroomid,
u.id AS rf,
u.nome AS nome,
u.email AS email
into temporary table professorTemp
from usuarios u
inner join cursos_usuarios cu on cu.usuario_id = u.indice
inner join cursos c on c.id = cu.curso_id
where u.usuario_tipo = @tipo
and not cu.excluido");
if (rf.HasValue && rf > 0)
{
query.AppendLine(" and u.id = @rf");
}
if (turmaId.HasValue && turmaId > 0)
{
query.AppendLine(" and c.turma_id = @turmaId");
}
if (componenteCurricularId.HasValue && componenteCurricularId > 0)
{
query.AppendLine(" and c.componente_curricular_id = @componenteCurricularId");
}
query.AppendLine(";");
query.AppendLine(" select * into temporary professorTempPaginado from professorTemp");
if (paginacao.QuantidadeRegistros > 0)
{
query.AppendLine($" OFFSET @quantidadeRegistrosIgnorados ROWS FETCH NEXT @quantidadeRegistros ROWS ONLY;");
}
query.AppendLine(@"select t1.rf,
cu.Id as CursoUsuarioId,
t1.indice,
t1.nome,
t1.email,
t1.googleclassroomid,
c.id,
c.id as CursoId,
c.nome,
c.email,
c.secao,
c.turma_id as TurmaId,
c.componente_curricular_id as ComponenteCurricularId
from cursos c
inner join cursos_usuarios cu on cu.curso_id = c.id
inner join professorTempPaginado t1 on t1.indice = cu.usuario_id ");
if (rf.HasValue && rf > 0)
{
query.AppendLine(" and t1.rf = @rf");
}
if (turmaId.HasValue && turmaId > 0)
{
query.AppendLine(" and c.turma_id = @turmaId");
}
if (componenteCurricularId.HasValue && componenteCurricularId > 0)
{
query.AppendLine(" and c.componente_curricular_id = @componenteCurricularId");
}
query.AppendLine(";");
query.AppendLine("select count(*) from professorTemp");
var retorno = new PaginacaoResultadoDto <ProfessorCursosCadastradosDto>();
var parametros = new
{
paginacao.QuantidadeRegistrosIgnorados,
paginacao.QuantidadeRegistros,
tipo = UsuarioTipo.Professor,
rf,
turmaId,
componenteCurricularId
};
using var conn = ObterConexao();
var multiResult = await conn.QueryMultipleAsync(query.ToString(), parametros);
var dic = new Dictionary <long, ProfessorCursosCadastradosDto>();
var Result = multiResult.Read <ProfessorCursosCadastradosDto, CursoDto, ProfessorCursosCadastradosDto>(
(professor, curso) =>
{
if (!dic.TryGetValue(professor.Rf, out var professorResultado))
{
professor.Cursos.Add(curso);
dic.Add(professor.Rf, professor);
return(professor);
}
professorResultado.Cursos.Add(curso);
return(professorResultado);
}
);
retorno.Items = dic.Values;
retorno.TotalRegistros = multiResult.ReadFirst <int>();
retorno.TotalPaginas = (int)Math.Ceiling((double)retorno.TotalRegistros / paginacao.QuantidadeRegistros);
return(retorno);
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <PaginacaoResultadoDto <FuncionarioCursosCadastradosDto> > ObterFuncionariosCursosAsync(Paginacao paginacao, long?rf, long?turmaId, long?componenteCurricularId)
{
var query = new StringBuilder(@"DROP TABLE IF EXISTS funcionarioTemp;
DROP TABLE IF EXISTS funcionarioTempPaginado;
select distinct
u.indice,
u.id AS rf,
u.nome AS nome,
u.email AS email,
u.organization_path AS organizationPath
into temporary table funcionarioTemp
from usuarios u
inner join cursos_usuarios cu on cu.usuario_id = u.indice
inner join cursos c on c.id = cu.curso_id
where u.usuario_tipo = @tipo
and not cu.excluido");
if (rf.HasValue && rf > 0)
{
query.AppendLine(" and u.id = @rf");
}
if (turmaId.HasValue && turmaId > 0)
{
query.AppendLine(" and c.turma_id = @turmaId");
}
if (componenteCurricularId.HasValue && componenteCurricularId > 0)
{
query.AppendLine(" and c.componente_curricular_id = @componenteCurricularId");
}
query.AppendLine(";");
query.AppendLine(" select * into temporary funcionarioTempPaginado from funcionarioTemp");
if (paginacao.QuantidadeRegistros > 0)
{
query.AppendLine($" OFFSET @quantidadeRegistrosIgnorados ROWS FETCH NEXT @quantidadeRegistros ROWS ONLY;");
}
query.AppendLine(@"select t1.rf,
t1.nome,
t1.email,
t1.organizationPath,
c.id,
c.id as cursoId,
c.nome,
c.secao,
c.turma_id as turmaId,
c.componente_curricular_id as componenteCurricularId
from cursos c
inner join cursos_usuarios cu on cu.curso_id = c.id
inner join funcionarioTempPaginado t1 on t1.indice = cu.usuario_id");
if (rf.HasValue && rf > 0)
{
query.AppendLine(" and t1.rf = @rf");
}
if (turmaId.HasValue && turmaId > 0)
{
query.AppendLine(" and c.turma_id = @turmaId");
}
if (componenteCurricularId.HasValue && componenteCurricularId > 0)
{
query.AppendLine(" and c.componente_curricular_id = @componenteCurricularId");
}
query.AppendLine(";");
query.AppendLine("select count(*) from funcionarioTemp");
var retorno = new PaginacaoResultadoDto <FuncionarioCursosCadastradosDto>();
var parametros = new
{
paginacao.QuantidadeRegistrosIgnorados,
paginacao.QuantidadeRegistros,
tipo = UsuarioTipo.Funcionario,
rf,
turmaId,
componenteCurricularId
};
using var conn = ObterConexao();
var multiResult = await conn.QueryMultipleAsync(query.ToString(), parametros);
var dic = new Dictionary <long, FuncionarioCursosCadastradosDto>();
var Result = multiResult.Read <FuncionarioCursosCadastradosDto, CursoDto, FuncionarioCursosCadastradosDto>(
(funcionario, curso) =>
{
if (!dic.TryGetValue(funcionario.Rf, out var funcionarioResultado))
{
funcionario.Cursos.Add(curso);
dic.Add(funcionario.Rf, funcionario);
return(funcionario);
}
funcionarioResultado.Cursos.Add(curso);
return(funcionarioResultado);
}
);
retorno.Items = dic.Values;
retorno.TotalRegistros = multiResult.ReadFirst <int>();
retorno.TotalPaginas = (int)Math.Ceiling((double)retorno.TotalRegistros / paginacao.QuantidadeRegistros);
return(retorno);
}
private async Task ValidaProximaExecucaoAsync(AtualizacaoUsuarioGoogleClassroomIdPaginadoDto dto, PaginacaoResultadoDto <UsuarioParaAtualizacaoGoogleClassroomIdDto> resultadoPaginacao)
{
if (DeveBuscarAProximaPagina(dto, resultadoPaginacao))
{
await PublicaProximaPaginaAsync(dto);
return;
}
await mediator.Send(new FinalizarAtualizacaoUsuarioGoogleClassroomIdCommand());
}
private bool DeveBuscarAProximaPagina(AtualizacaoUsuarioGoogleClassroomIdPaginadoDto dto, PaginacaoResultadoDto <UsuarioParaAtualizacaoGoogleClassroomIdDto> resultadoPaginacao) => resultadoPaginacao.TotalPaginas > (dto.Pagina + 1);
