/// <summary>
/// Carrega o repeater com a quantidade de docentes definida no parâmetro acadêmico,
/// com o controle de vigência de cada um deles.
/// </summary>
/// <param name="Row">Linha do grid de disciplinas</param>
/// <param name="tud_id">Id da disciplina</param>
/// <param name="tds_id">Id do tipo de disciplina para carregar o docente por especialidade</param>
private void CarregarControleDocentes(GridViewRow Row, long tud_id, int tds_id)
{
int qtdeDocentes = ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.QUANTIDADE_DOCENTES_VIGENTES_DISCIPLINA, __SessionWEB.__UsuarioWEB.Usuario.ent_id);
DataTable dtDocentes = new DataTable();
dtDocentes.Columns.Add("posicao");
dtDocentes.Columns.Add("tud_id");
dtDocentes.Columns.Add("qtdedocentes");
dtDocentes.Columns.Add("tds_id");
for (int i = 1; i <= qtdeDocentes; i++)
{
EnumTipoDocente tipoDocente = ACA_TipoDocenteBO.SelecionaTipoDocentePorPosicao((byte)i, ApplicationWEB.AppMinutosCacheLongo);
if (!aplicarNovaRegraDocenciaCompartilhada ||
(tipoDocente != EnumTipoDocente.Compartilhado && tipoDocente != EnumTipoDocente.Projeto))
{
DataRow dr = dtDocentes.NewRow();
dr["posicao"] = i;
dr["tud_id"] = tud_id;
dr["qtdedocentes"] = qtdeDocentes;
dr["tds_id"] = tds_id;
dtDocentes.Rows.Add(dr);
}
}
Repeater rptDocentes = (Repeater)Row.FindControl("rptDocentes");
if (rptDocentes != null)
{
rptDocentes.DataSource = dtDocentes;
rptDocentes.DataBind();
}
}
public static DataTable GetSelectBy_TurmaDisciplina_PeriodoFiltroDeficiencia
(
long tud_id
, int tpc_id
, EnumTipoDocente tipoDocente
)
{
return(GetSelectBy_TurmaDisciplina_PeriodoFiltroDeficiencia(tud_id, tpc_id, tipoDocente, Guid.Empty, 0));
}
public static DataTable GetSelectBy_TurmaDisciplina_PeriodoFiltroDeficiencia
(
long tud_id
, int tpc_id
, EnumTipoDocente tipoDocente
, Guid usu_id
, byte tdt_posicao
)
{
return(new CLS_TurmaNotaDAO().SelectBy_TurmaDisciplina_Periodo_NotaAlunoFiltroDeficiencia(tud_id, tpc_id, (byte)tipoDocente, usu_id, tdt_posicao));
}
public static DataTable SelecionaFrequenciaPorAulaTurmaDisciplinaFiltroDeficiencia
(
long tud_id
, int tau_id
, EnumTipoDocente tipoDocente
, Guid ent_id
, byte ordenacao
)
{
return(new CLS_TurmaAulaAlunoDAO().SelectBy_TurmaDisciplinaFiltroDeficiencia(tud_id, tau_id, (byte)tipoDocente, ent_id, ordenacao));
}
public static DataTable SelecionaFrequenciaPorNotaTurmaDisciplinaPeriodoFiltroDeficiencia
(
long tud_id
, int tnt_id
, int tpc_id
, EnumTipoDocente tipoDocente
, Guid ent_id
, byte ordenacao
, bool trazerInativos
)
{
return(new CLS_TurmaNotaAlunoDAO().SelectBy_TurmaDisciplinaPeriodoFiltroDeficiencia(tud_id, tnt_id, tpc_id, (byte)tipoDocente, ent_id, ordenacao, trazerInativos));
}
/// <summary>
/// Retorna a posição do tipo de docente.
/// </summary>
/// <param name="tipoDocente">Tipo de docente (enum).</param>
/// <param name="appMinutosCacheLongo">Minutos de cache configurados para o cache longo.</param>
/// <returns>Posição do docente.</returns>
public static byte SelecionaPosicaoPorTipoDocenteCache(EnumTipoDocente tipoDocente, int appMinutosCacheLongo)
{
byte posicao;
Func <byte> retorno = delegate()
{
return(new ACA_TipoDocenteDAO().SelecionaPosicaoPorTipoDocente((byte)tipoDocente));
};
if (appMinutosCacheLongo > 0)
{
posicao = CacheManager.Factory.Get(
String.Format(ModelCache.TIPO_DOCENTE_POSICAO_POR_TIPO_DOCENTE_MODEL_KEY, (byte)tipoDocente),
retorno,
appMinutosCacheLongo
);
}
else
{
posicao = retorno();
}
return(posicao);
}
/// <summary>
/// Carrega dados de lançamento de frequência na tela.
/// Só carrega caso a disciplina não seja do tipo
/// complementação da regência.
/// </summary>
public void Carregar(bool proximo
, bool anterior
, bool inalterado
, ControleTurmas entitiesControleTurma
, int tpcId
, DateTime capDataInicio
, DateTime capDataFim
, byte tdtPosicao
, EnumTipoDocente tipoDocente
, long tudIdRelacionada
, bool permiteVisualizarCompensacao
, List <sPermissaoDocente> ltPermissaoFrequencia
, bool permiteLancarFrequencia
, out int countAulas
, int situacaoTurmaDisciplina
, ref bool permiteEdicao
, bool usuarioPermissao
, bool periodoEfetivado
, bool periodoAberto
, ref bool esconderSalvar
, ref int paginaFreq
, int tne_id
, string tur_ids = null)
{
countAulas = 0;
long tudId = entitiesControleTurma.turmaDisciplina.tud_id;
long turId = entitiesControleTurma.turma.tur_id;
int qtdAulasSemana = ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.QUANTIDADE_AULAS_LISTAO_FREQUENCIA, __SessionWEB.__UsuarioWEB.Usuario.ent_id);
DateTime dtInicio = new DateTime();
DateTime dtFim = new DateTime();
if (proximo)
{
paginaFreq++;
}
else if (anterior && paginaFreq > 1)
{
paginaFreq--;
}
else if (!inalterado)
{
paginaFreq = 1;
}
// Carregar tabela com aulas e frequências das aulas para os alunos.
VS_Aulas_Alunos =
CLS_TurmaAulaAlunoBO.GetSelectBy_TurmaDisciplina(tudId, tpcId,
(__SessionWEB.__UsuarioWEB.Docente.doc_id > 0 ? __SessionWEB.__UsuarioWEB.Usuario.usu_id : Guid.Empty),
capDataInicio, capDataFim, tdtPosicao, __SessionWEB.__UsuarioWEB.Docente.doc_id == 0, tudIdRelacionada, tur_ids);
int qtdAlunos = VS_Aulas_Alunos.GroupBy(p => new { p.alu_id, p.mtu_id }).Count();
int skip = qtdAulasSemana * (paginaFreq - 1) * qtdAlunos;
while (proximo && VS_Aulas_Alunos.Count < skip)
{
paginaFreq--;
skip = (qtdAulasSemana * (paginaFreq - 1)) * qtdAlunos;
if (paginaFreq == 1)
{
break;
}
}
//Quando carrega pela primeira vez e o bimestre é ativo então abre a página que possui a data atual
if (!proximo && !anterior && !inalterado && paginaFreq == 1 &&
capDataInicio <= DateTime.Today && capDataFim >= DateTime.Today)
{
while (VS_Aulas_Alunos.Skip(skip).Take(qtdAulasSemana * qtdAlunos).ToList().LastOrDefault().tau_data < DateTime.Today &&
VS_Aulas_Alunos.Skip(skip).Count() > (qtdAulasSemana * qtdAlunos))
{
paginaFreq++;
skip = (qtdAulasSemana * (paginaFreq - 1)) * qtdAlunos;
}
}
lkbProximo.Visible = VS_Aulas_Alunos.Skip(skip).Count() > (qtdAulasSemana * qtdAlunos);
lkbAnterior.Visible = skip > 0;
VS_Aulas_Alunos = VS_Aulas_Alunos.Skip(skip).Take(qtdAulasSemana * qtdAlunos).ToList();
dtInicio = VS_Aulas_Alunos.Count > 0 ? VS_Aulas_Alunos.FirstOrDefault().tau_data : capDataInicio.Date;
dtFim = VS_Aulas_Alunos.Count > 0 ? VS_Aulas_Alunos.LastOrDefault().tau_data : capDataFim.Date;
lblInicio.Text = dtInicio == new DateTime() ? "" : dtInicio.ToShortDateString();
lblFim.Text = dtFim == new DateTime() ? "" : dtFim.ToShortDateString();
// Carregar repeater de alunos.
rptAlunosFrequencia.DataSource = MTR_MatriculaTurmaDisciplinaBO.SelecionaAlunosAtivosCOCPorTurmaDisciplina(tudId,
tpcId, tipoDocente, false, capDataInicio, capDataFim, ApplicationWEB.AppMinutosCacheMedio, tur_ids)
.Where(p => ((p.mtd_dataSaida > dtInicio) || (p.mtd_dataSaida == null)) && (p.mtd_dataMatricula <= dtFim));
if (entitiesControleTurma.turma.tur_tipo == (byte)TUR_TurmaTipo.Normal)
{
lstAlunosRelatorioRP = CLS_RelatorioPreenchimentoAlunoTurmaDisciplinaBO.SelecionaAlunoPreenchimentoPorPeriodoDisciplina(tpcId, turId, tudId, ApplicationWEB.AppMinutosCacheMedio);
}
this.tudTipo = entitiesControleTurma.turmaDisciplina.tud_tipo;
this.permiteVisualizarCompensacao = permiteVisualizarCompensacao;
this.ltPermissaoFrequencia = ltPermissaoFrequencia;
this.permiteLancarFrequencia = permiteLancarFrequencia;
this.permiteEdicao = false;
this.situacaoTurmaDisciplina = situacaoTurmaDisciplina;
this.posicaoDocente = tdtPosicao;
this.usuarioPermissao = usuarioPermissao;
this.periodoEfetivado = periodoEfetivado;
this.periodoAberto = periodoAberto;
ACA_CurriculoPeriodo entityCrp = ACA_CurriculoPeriodoBO.SelecionaPorTurmaTipoNormal(turId, ApplicationWEB.AppMinutosCacheLongo);
this.crpControleTempo = entityCrp.crp_controleTempo;
this.possuiRegencia = TUR_TurmaBO.VerificaPossuiDisciplinaPorTipo(turId, TurmaDisciplinaTipo.Regencia, ApplicationWEB.AppMinutosCacheLongo);
this.tipoApuracaoFrequencia = entitiesControleTurma.formatoAvaliacao.fav_tipoApuracaoFrequencia;
this.tne_id = tne_id;
this.ttn_tipo = entitiesControleTurma.tipoTurno.ttn_tipo;
rptAlunosFrequencia.DataBind();
// Limpa o hiddenfield do listão de frequência pra zerar a ordenação.
hdnOrdenacaoFrequencia.Value = "";
//Fazendo as validações após carregar os dados.
if (rptAlunosFrequencia.Items.Count == 0)
{
EscondeGridAlunosFrequencia("Não foram encontrados alunos na turma selecionada.");
esconderSalvar = true;
}
else
{
MostraPeriodo(true);
pnlLancamentoFrequencias.Visible = true;
RepeaterItem header = (RepeaterItem)rptAlunosFrequencia.Controls[0];
Repeater rptAulas = (Repeater)header.FindControl("rptAulas");
lblMsgParecer.Visible = rptAulas.Items.Count > 0;
_lblMsgRepeater.Visible = rptAulas.Items.Count == 0;
if (rptAulas.Items.Count == 0)
{
_lblMsgRepeater.Text = UtilBO.GetErroMessage(GetGlobalResourceObject("Academico", "ControleTurma.Listao.MensagemSemAulas").ToString(),
UtilBO.TipoMensagem.Alerta);
esconderSalvar = true;
}
countAulas = rptAulas.Items.Count;
rptAlunosFrequencia.Visible = true;
}
if (this.permiteEdicao && !periodoEfetivado)
{
permiteEdicao = true;
}
}
public static DataTable SelectByPesquisaFiltroDeficiencia(Guid uad_idSuperior, int esc_id, int uni_id, int cur_id, int crr_id, int cap_id, long tud_id, Guid gru_id, Guid usu_id, bool adm, long tur_id, EnumTipoDocente tipoDocente, Guid ent_id)
{
// Tipo de evento de efetivação de notas, configurado nos parâmetros.
int tev_idEfetivacao = ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_EVENTO_EFETIVACAO_NOTAS, ent_id);
return(new CLS_CompensacaoAusenciaDAO().SelectByPesquisaFiltroDeficiencia(uad_idSuperior, esc_id, uni_id, cur_id, crr_id, cap_id, tud_id, gru_id, usu_id, adm, tur_id, tev_idEfetivacao, (byte)tipoDocente, out totalRecords));
}
/// <summary>
/// Realiza a consulta pelos filtros informados.
/// </summary>
private void Pesquisar()
{
try
{
Dictionary <string, string> filtros = new Dictionary <string, string>();
bool permiteConsultar = true;
List <sPermissaoDocente> ltPermissao = new List <sPermissaoDocente>();
EnumTipoDocente tipoDocente = EnumTipoDocente.Titular;
if (_VS_doc_id > 0)
{
long tud_id = UCCTurmaDisciplina1.Valor;
bool AtribuicaoAtiva;
// Traz a última atribuição que o docente teve naquela disciplina, sendo ativa ou inativa.
byte tdt_posicao = TUR_TurmaDocenteBO.SelecionaPosicaoPorDocenteTurma_ComInativos
(_VS_doc_id, tud_id, out AtribuicaoAtiva, ApplicationWEB.AppMinutosCacheLongo);
VS_AtribuicaoAtiva = AtribuicaoAtiva;
ltPermissao = CFG_PermissaoDocenteBO.SelecionaPermissaoModulo(tdt_posicao, (byte)EnumModuloPermissao.Compensacoes);
permiteConsultar = ltPermissao.Any(p => p.pdc_permissaoConsulta);
TUR_TurmaDisciplina entityTurmaDisciplina = new TUR_TurmaDisciplina {
tud_id = tud_id
};
TUR_TurmaDisciplinaBO.GetEntity(entityTurmaDisciplina);
VS_DisciplinaEspecial = entityTurmaDisciplina.tud_disciplinaEspecial;
tipoDocente = ACA_TipoDocenteBO.SelecionaTipoDocentePorPosicao(tdt_posicao, ApplicationWEB.AppMinutosCacheLongo);
}
else
{
VS_AtribuicaoAtiva = true;
}
if (permiteConsultar)
{
gvCompAusencia.EmptyDataText = GetGlobalResourceObject("Classe", "CompensacaoAusencia.Busca.SemCompensacaoAusencia").ToString();
gvCompAusencia.PageIndex = 0;
odsCompAusencia.SelectMethod = _VS_doc_id > 0 && VS_DisciplinaEspecial ? "SelectByPesquisaFiltroDeficiencia" : "SelectByPesquisa";
odsCompAusencia.SelectParameters.Clear();
odsCompAusencia.SelectParameters.Add("uad_idSuperior", DbType.Guid, UCComboUAEscola.Uad_ID.ToString());
odsCompAusencia.SelectParameters.Add("esc_id", DbType.Int32, UCComboUAEscola.Esc_ID.ToString());
odsCompAusencia.SelectParameters.Add("uni_id", DbType.Int32, UCComboUAEscola.Uni_ID.ToString());
odsCompAusencia.SelectParameters.Add("cur_id", DbType.Int32, UCCCursoCurriculo.Valor[0].ToString());
odsCompAusencia.SelectParameters.Add("crr_id", DbType.Int32, UCCCursoCurriculo.Valor[1].ToString());
odsCompAusencia.SelectParameters.Add("cap_id", DbType.Int32, UCCPeriodoCalendario.Valor[1].ToString());
odsCompAusencia.SelectParameters.Add("tud_id", DbType.Int64, UCCTurmaDisciplina1.Valor.ToString());
odsCompAusencia.SelectParameters.Add("tur_id", DbType.Int64, ddlTurma.SelectedValue);
// Filtra pela visão do usuário.
odsCompAusencia.SelectParameters.Add("gru_id", __SessionWEB.__UsuarioWEB.Grupo.gru_id.ToString());
odsCompAusencia.SelectParameters.Add("usu_id", __SessionWEB.__UsuarioWEB.Usuario.usu_id.ToString());
odsCompAusencia.SelectParameters.Add("adm", (__SessionWEB.__UsuarioWEB.Grupo.vis_id == SysVisaoID.Administracao || __SessionWEB.__UsuarioWEB.Grupo.vis_id == SysVisaoID.Individual).ToString());
odsCompAusencia.SelectParameters.Add("ent_id", __SessionWEB.__UsuarioWEB.Usuario.ent_id.ToString());
if (_VS_doc_id > 0 && VS_DisciplinaEspecial)
{
odsCompAusencia.SelectParameters.Add("tipoDocente", tipoDocente.ToString());
}
odsCompAusencia.DataBind();
// quantidade de itens por página
string qtItensPagina = SYS_ParametroBO.ParametroValor(SYS_ParametroBO.eChave.QT_ITENS_PAGINACAO);
int itensPagina = string.IsNullOrEmpty(qtItensPagina) ? ApplicationWEB._Paginacao : Convert.ToInt32(qtItensPagina);
gvCompAusencia.Sort(VS_Ordenacao, VS_SortDirection);
#region Salvar busca realizada com os parâmetros do ODS.
foreach (Parameter param in odsCompAusencia.SelectParameters)
{
filtros.Add(param.Name, param.DefaultValue);
}
filtros.Add("tpc_id", UCCPeriodoCalendario.Valor[0].ToString());
filtros.Add("cal_id", UCComboCalendario.Valor.ToString());
__SessionWEB.BuscaRealizada = new BuscaGestao
{
PaginaBusca = PaginaGestao.CompensacaoAusencia
,
Filtros = filtros
};
#endregion
// mostra essa quantidade no combobox
UCComboQtdePaginacao1.Valor = itensPagina;
// atribui essa quantidade para o grid
gvCompAusencia.PageSize = itensPagina;
// atualiza o grid
gvCompAusencia.DataBind();
fdsResultados.Visible = true;
if (_VS_doc_id > 0)
{
gvCompAusencia.Columns[gvCompAusenciaIndiceAlterar].Visible =
gvCompAusencia.Columns[gvCompAusenciaIndiceExcluir].Visible = ltPermissao.Any(p => p.pdc_permissaoEdicao);
}
else
{
gvCompAusencia.Columns[gvCompAusenciaIndiceAlterar].Visible = __SessionWEB.__UsuarioWEB.GrupoPermissao.grp_alterar;
gvCompAusencia.Columns[gvCompAusenciaIndiceExcluir].Visible = __SessionWEB.__UsuarioWEB.GrupoPermissao.grp_excluir;
}
}
else
{
string msg = String.Format("O docente não possui permissão para consultar compensações de ausência do(a) {0} selecionado(a).", GetGlobalResourceObject("Mensagens", "MSG_DISCIPLINA_MIN"));
lblMessage.Text = UtilBO.GetErroMessage(msg, UtilBO.TipoMensagem.Alerta);
}
}
catch (Exception ex)
{
ApplicationWEB._GravaErro(ex);
lblMessage.Text = UtilBO.GetErroMessage("Erro ao tentar carregar as compensações de ausências.", UtilBO.TipoMensagem.Erro);
}
}