/// <summary>
/// Verifica se a data esta dentro de um evento de atividade diversificada
/// </summary>
/// <param name="dia">Dia do ano</param>
/// <returns>Verdadeiro se ele pertencer a um evento de atividade diversificada.</returns>
private bool DiaAtividadeDiversificada(DateTime dia)
{
int parametroAtivDiversificada = ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(
eChaveAcademico.TIPO_EVENTO_ATIVIDADE_DIVERSIFICADA
, __SessionWEB.__UsuarioWEB.Usuario.ent_id);
// altera a cor da célula referente a data de cada evento
DateTime dateAux;
return((
from DataRow row in Eventos.Rows
where
DateTime.TryParse(row["evt_dataInicio"].ToString(), out dateAux) &&
DateTime.TryParse(row["evt_dataFim"].ToString(), out dateAux) &&
DateTime.Parse(row["evt_dataInicio"].ToString()) <= dia &&
dia <= DateTime.Parse(row["evt_dataFim"].ToString())
//Possui atividade discente
&& !bool.Parse(row["evt_semAtividadeDiscente"].ToString())
//For atividade diversificada
&& Convert.ToInt32(row["tev_id"]) == parametroAtivDiversificada
select new
{
evt_dataInicio = DateTime.Parse(row["evt_dataInicio"].ToString()),
evt_dataFim = DateTime.Parse(row["evt_dataFim"].ToString()),
esc_nome = row["esc_nome"].ToString()
}
).Any());
}
protected void Page_Load(object sender, EventArgs e)
{
UCCCursoCurriculo.IndexChanged += UCCCursoCurriculo_IndexChanged;
UCCCalendario.IndexChanged += UCCCalendario_IndexChanged;
UCCCurriculoPeriodo.IndexChanged += UCCCurriculoPeriodo_IndexChanged;
try
{
ScriptManager sm = ScriptManager.GetCurrent(this);
if (sm != null)
{
sm.Scripts.Add(new ScriptReference(ArquivoJS.JQueryValidation));
sm.Scripts.Add(new ScriptReference(ArquivoJS.JqueryMask));
sm.Scripts.Add(new ScriptReference(ArquivoJS.MascarasCampos));
}
if (!IsPostBack)
{
string msg = __SessionWEB.PostMessages;
if (!string.IsNullOrEmpty(msg))
{
lblMensagem.Text = msg;
}
UCCCursoCurriculo.CarregarPorModalidadeEnsino(ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_MODALIDADE_CIEJA, Ent_ID_UsuarioLogado));
}
}
catch (Exception ex)
{
ApplicationWEB._GravaErro(ex);
lblMensagem.Text = UtilBO.GetErroMessage("Erro ao tentar carregar o sistema.", UtilBO.TipoMensagem.Erro);
}
}
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>
/// O método gera o relatório de alunos abaixo da frequência
/// </summary>
private void GerarRelatorio()
{
string report, parametros;
report = ((int)ReportNameGestaoAcademicaDocumentosDocente.DocDctAlunosPendenciaEfetivacao).ToString();
parametros = "uad_idSuperiorGestao=" + UCBuscaDocenteTurma.ComboEscola.Uad_ID +
"&esc_id=" + UCBuscaDocenteTurma.ComboEscola.Esc_ID +
"&uni_id=" + UCBuscaDocenteTurma.ComboEscola.Uni_ID +
"&cal_id=" + UCBuscaDocenteTurma.ComboCalendario.Valor +
"&cal_ano=" + UCBuscaDocenteTurma.ComboCalendario.Cal_ano.ToString() +
"&cur_id=" + UCBuscaDocenteTurma.ComboCursoCurriculo.Valor[0] +
"&crr_id=" + UCBuscaDocenteTurma.ComboCursoCurriculo.Valor[1] +
"&crp_id=" + UCBuscaDocenteTurma.ComboCurriculoPeriodo.Valor[2] +
"&tur_id=" + UCBuscaDocenteTurma.ComboTurma.Valor[0] +
"&ent_id=" + __SessionWEB.__UsuarioWEB.Usuario.ent_id +
"&doc_id=" + __SessionWEB.__UsuarioWEB.Docente.doc_id +
"&tud_ids=" + "" +
"&tev_EfetivacaoNotas=" + ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_EVENTO_EFETIVACAO_NOTAS, __SessionWEB.__UsuarioWEB.Usuario.ent_id) +
"&tev_EfetivacaoFinal=" + ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_EVENTO_EFETIVACAO_FINAL, __SessionWEB.__UsuarioWEB.Usuario.ent_id) +
"&nomeParecerConclusivo=" + GetGlobalResourceObject("Mensagens", "MSG_RESULTADOEFETIVACAO") +
"&nomePeriodoCalendario=" + GestaoEscolarUtilBO.nomePadraoPeriodo_Calendario(__SessionWEB.__UsuarioWEB.Usuario.ent_id) +
"&nomeComponenteCurricular=" + GetGlobalResourceObject("Mensagens", "MSG_DISCIPLINA") +
"&mostraCodigoEscola=" + ACA_ParametroAcademicoBO.ParametroValorBooleanoPorEntidade(eChaveAcademico.ORDENAR_ESCOLAS_POR_CODIGO, __SessionWEB.__UsuarioWEB.Usuario.ent_id) +
"&nomeMunicipio=" + GetGlobalResourceObject("Reporting", "Reporting.DocDctSubCabecalhoRetrato.Municipio") +
"&nomeSecretaria=" + GetGlobalResourceObject("Reporting", "Reporting.DocDctSubCabecalhoRetrato.Secretaria") +
"&logo=" + String.Concat(MSTech.GestaoEscolar.BLL.CFG_ServidorRelatorioBO.CarregarServidorRelatorioPorEntidade(__SessionWEB.__UsuarioWEB.Usuario.ent_id, ApplicationWEB.AppMinutosCacheLongo).srr_pastaRelatorios.ToString()
, ApplicationWEB.LogoRelatorioSSRS);
CFG_RelatorioBO.CallReport("Relatorios", report, parametros, HttpContext.Current);
}
public static List <sTipoPeriodoCalendario> SelecionaTipoPeriodoCalendario(int AppMinutosCacheLongo = 0, bool removerRecesso = true, Guid ent_id = new Guid())
{
List <sTipoPeriodoCalendario> lista = null;
if (AppMinutosCacheLongo > 0 && HttpContext.Current != null)
{
string chave = "Cache_SelecionaTipoPeriodoCalendario";
object cache = HttpContext.Current.Cache[chave];
if (cache == null)
{
lista = (from dr in new ACA_TipoPeriodoCalendarioDAO().SelectBy_Pesquisa(false, 1, 1, out totalRecords).AsEnumerable()
select(sTipoPeriodoCalendario) GestaoEscolarUtilBO.DataRowToEntity(dr, new sTipoPeriodoCalendario())).ToList();
HttpContext.Current.Cache.Insert(chave, lista, null, DateTime.Now.AddMinutes(AppMinutosCacheLongo), System.Web.Caching.Cache.NoSlidingExpiration);
}
else
{
lista = (List <sTipoPeriodoCalendario>)cache;
}
}
else
{
lista = (from dr in new ACA_TipoPeriodoCalendarioDAO().SelectBy_Pesquisa(false, 1, 1, out totalRecords).AsEnumerable()
select(sTipoPeriodoCalendario) GestaoEscolarUtilBO.DataRowToEntity(dr, new sTipoPeriodoCalendario())).ToList();
}
if (removerRecesso && lista.Any())
{
return(lista.Where(p => p.tpc_id != ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, ent_id)).ToList());
}
return(lista);
}
/// <summary>
/// Carrega todos os tipos de período calendário não excluídos logicamente
/// filtrando por calendário
/// </summary>
/// <param name="cal_id">ID do calendário</param>
public void CarregarPorCalendario(int cal_id, bool adicionarRecesso = false)
{
sTipoPeriodoCalendario sTpc = new sTipoPeriodoCalendario();
ddlCombo.DataTextField = "cap_descricao";
List <sTipoPeriodoCalendario> dt = ACA_TipoPeriodoCalendarioBO.SelecionaTipoPeriodoCalendarioPorCalendario(cal_id, ApplicationWEB.AppMinutosCacheLongo);
if (adicionarRecesso)
{
int tpc_id = ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, __SessionWEB.__UsuarioWEB.Usuario.ent_id);
if (tpc_id > 0)
{
ACA_TipoPeriodoCalendario tpc = new ACA_TipoPeriodoCalendario {
tpc_id = tpc_id
};
ACA_TipoPeriodoCalendarioBO.GetEntity(tpc);
sTpc.tpc_id = tpc_id;
sTpc.tpc_nome = sTpc.cap_descricao = tpc.tpc_nome;
sTpc.tpc_cap_id = string.Format("{0};-1", tpc_id);
dt.Add(sTpc);
}
}
CarregarCombo(dt);
CarregarPeriodoAtual(dt, SelecionaPeriodoAtualAoCarregar);
if (sTpc.tpc_id > 0)
{
dt.Remove(sTpc);
}
}
/// <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 SelecionaTipoNivelEnsinoSemInfantil(Guid ent_id)
{
int tne_idInfantil = ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_NIVEL_ENSINO_EDUCACAO_INFANTIL, ent_id);
DataTable dt = SelecionaTipoNivelEnsino();
if (dt.Select(string.Format("tne_id <> {0}", tne_idInfantil)).Length > 0)
{
return(dt.Select(string.Format("tne_id <> {0}", tne_idInfantil)).CopyToDataTable());
}
return(new DataTable());
}
public static DataTable SelecionaTipoNivelEnsinoDocenteEventoSemInfantil(long doc_id, string eventosAbertos, Guid ent_id)
{
int tne_idInfantil = ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_NIVEL_ENSINO_EDUCACAO_INFANTIL, ent_id);
DataTable dt = new ACA_TipoNivelEnsinoDAO().SelecionaTipoNivelEnsinoDocenteEvento(doc_id, eventosAbertos, 0);
if (dt.Select(string.Format("tne_id <> {0}", tne_idInfantil)).Length > 0)
{
return(dt.Select(string.Format("tne_id <> {0}", tne_idInfantil)).CopyToDataTable());
}
return(new DataTable());
}
/// <summary>
/// Verifica se o período está fechado para o fechamento de bimestre.
/// </summary>
/// <returns></returns>
private bool VerificaPeriodoFechado(int cal_id, int tpc_id, int esc_id, int uni_id)
{
ACA_CalendarioPeriodo entityCap = ACA_CalendarioPeriodoBO.SelecionaPor_Calendario_TipoPeriodo(cal_id, tpc_id, ApplicationWEB.AppMinutosCacheLongo);
List <ACA_Evento> ltEventos = ACA_EventoBO.SelecionaEventosEfetivacaoPeriodoCalendario(cal_id, entityCap.cap_id, __SessionWEB.__UsuarioWEB.Grupo.gru_id, esc_id, uni_id, __SessionWEB.__UsuarioWEB.Usuario.ent_id);
DateTime dataAtual = DateTime.Now;
int tev_EfetivacaoNotas = ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_EVENTO_EFETIVACAO_NOTAS, __SessionWEB.__UsuarioWEB.Usuario.ent_id);
return((dataAtual > entityCap.cap_dataFim && dataAtual < entityCap.cap_dataInicio) ||
(!ltEventos.Exists(p => p.tpc_id == tpc_id && p.tev_id == tev_EfetivacaoNotas)));
}
/// <summary>
/// Busca se o calendario tem algum evento do tipo determinado
/// vigente no momento da consulta
/// </summary>
/// <param name="cal_id">ID do calendário</param>
/// <param name="dataVigencia">Data da consulta</param>
/// <param name="ent_id">Id da entidade do usuário logado.</param>
/// <returns>Datatable com tpc_id encontrado</returns>
public static DataTable GetTipoCalendario(int cal_id, DateTime dataVigencia, Guid ent_id)
{
totalRecords = 0;
// Validar parâmetro necessário para a busca.
int valor = ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_EVENTO_EFETIVACAO_RECUPERACAO, ent_id);
ACA_CalendarioEventoDAO daoEvento = new ACA_CalendarioEventoDAO();
if (valor <= 0)
{
return(new DataTable());
}
return(daoEvento.Select_TipoEvento(cal_id, valor, dataVigencia));
}
public new static bool Delete(CLS_CompensacaoAusencia entity)
{
CLS_CompensacaoAusenciaDAO dao = new CLS_CompensacaoAusenciaDAO();
dao._Banco.Open(IsolationLevel.ReadCommitted);
try
{
ACA_FormatoAvaliacao formatoAvaliacao = ACA_FormatoAvaliacaoBO.CarregarPorTud(entity.tud_id);
// Caso o fechamento seja automático, grava na fila de processamento.
if (formatoAvaliacao.fav_fechamentoAutomatico && entity.tpc_id != ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, new Guid()))
{
CLS_AlunoFechamentoPendenciaBO.SalvarFilaFrequencia(entity.tud_id, entity.tpc_id, dao._Banco);
}
CLS_CompensacaoAusenciaAlunoDAO daoAluno = new CLS_CompensacaoAusenciaAlunoDAO {
_Banco = dao._Banco
};
List <CLS_CompensacaoAusenciaAluno> listaBanco = daoAluno.SelectByCpa_id(entity.cpa_id, entity.tud_id);
foreach (CLS_CompensacaoAusenciaAluno item in listaBanco)
{
if (!daoAluno.Delete(item))
{
throw new Exception("Erro ao tentar excluir compensação de ausência do aluno.");
}
}
// Exclui CLS_CompensacaoAusencia
if (!dao.Delete(entity))
{
throw new Exception("Erro ao tentar excluir compensação de ausência.");
}
return(true);
}
catch (Exception err)
{
dao._Banco.Close(err);
throw err;
}
finally
{
//Fechamento da transação
dao._Banco.Close();
}
}
/// <summary>
/// Carrega os campos de busca com a configuração padrão para uma nova busca para visão individual
/// </summary>
/// <param name="esc_id">Id da escola</param>
private void InicializaCamposBuscaVisaoIndividual(int esc_id)
{
//Carrega os campos
int posicaoDocenteCompatilhado = ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.POSICAO_DOCENCIA_COMPARTILHADA, __SessionWEB.__UsuarioWEB.Usuario.ent_id);
ddlTurma.Items.Clear();
ddlTurma.DataTextField = "tur_esc_nome";
ddlTurma.Items.Insert(0, new ListItem("-- Selecione uma turma --", "-1", true));
ddlTurma.DataSource = TUR_TurmaBO.GetSelectBy_Docente_TodosTipos_Posicao(__SessionWEB.__UsuarioWEB.Usuario.ent_id, _VS_doc_id, posicaoDocenteCompatilhado, esc_id, UCComboCalendario.Valor, false, false, ApplicationWEB.AppMinutosCacheLongo)
.GroupBy(p => new { tur_id = p.tur_id, tur_esc_nome = p.tur_esc_nome }).Select(p => p.Key).ToList();
ddlTurma.DataBind();
//if (UCComboUAEscola.VisibleUA)
ddlTurma_SelectedIndexChanged(null, null);
}
/// <summary>
/// Executa a sincronização dos dados alterados no diário de classe. (Compensacao de ausência)
/// </summary>
public static void ExecJobAtualizaCompensacaoDiarioClasse()
{
List <DCL_Protocolo> ltProtocolo = DCL_ProtocoloBO.SelecionaNaoProcessadosPorTipo
(DCL_ProtocoloBO.eTipo.CompensacaoDeAula,
ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.QUANTIDADE_MAXIMA_BUSCA_PROTOCOLO_COMPENSACAO, new Guid()));
ltProtocolo.ForEach(protocolo =>
{
// Marca o protocolo como "Em processamento".
protocolo.pro_status = (byte)DCL_ProtocoloBO.eStatus.EmProcessamento;
protocolo.pro_tentativa++;
});
DCL_ProtocoloBO.AtualizaListaProtocolos(ltProtocolo);
CLS_CompensacaoAusenciaBO.ProcessarProtocoloCompensacao(ltProtocolo, TENTATIVAS_PROCESSAMENTO_PROTOCOLO);
}
/// <summary>
/// Executa a sincronização dos dados alterados no diário de classe. (Justificativa de faltas)
/// </summary>
public static void ExecJobAtualizaJustificativaDiarioClasse()
{
List <DCL_Protocolo> ltProtocolo = DCL_ProtocoloBO.SelecionaNaoProcessadosPorTipo
(DCL_ProtocoloBO.eTipo.JustificativaFaltaAluno,
ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.QUANTIDADE_MAXIMA_BUSCA_PROTOCOLO_JUSTIFICATIVA, new Guid()));
ltProtocolo.ForEach(protocolo =>
{
// Marca o protocolo como "Em processamento".
protocolo.pro_status = (byte)DCL_ProtocoloBO.eStatus.EmProcessamento;
protocolo.pro_tentativa++;
});
DCL_ProtocoloBO.AtualizaListaProtocolos(ltProtocolo);
ACA_AlunoJustificativaFaltaBO.ProcessaProtocoloJustificativaFalta(ltProtocolo, TENTATIVAS_PROCESSAMENTO_PROTOCOLO);
}
/// <summary>
/// Executa a sincronização dos dados alterados no diário de classe. (Planejamento anual e bimestral)
/// </summary>
public static void ExecJobAtualizaPlanejamentoDiarioClasse()
{
List <DCL_Protocolo> ltProtocolo = DCL_ProtocoloBO.SelecionaNaoProcessadosPorTipo
(DCL_ProtocoloBO.eTipo.PlanejamentoAnual,
ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.QUANTIDADE_MAXIMA_BUSCA_PROTOCOLO_PLANEJAMENTO, new Guid()));
ltProtocolo.ForEach(protocolo =>
{
// Marca o protocolo como "Em processamento".
protocolo.pro_status = (byte)DCL_ProtocoloBO.eStatus.EmProcessamento;
protocolo.pro_tentativa++;
});
DCL_ProtocoloBO.AtualizaListaProtocolos(ltProtocolo);
CLS_TurmaDisciplinaPlanejamentoBO.ProcessaProtocoloPlanejamentoAnual(ltProtocolo, TENTATIVAS_PROCESSAMENTO_PROTOCOLO);
}
private void Pesquisar()
{
var lstLimite = ACA_EventoLimiteBO.GetSelectByCalendario(VS_cal_id);
var tblTipoEvento = ACA_TipoEventoBO.SelecionaTipoEvento(0, Guid.Empty);
var lstTipoPeriodo = ACA_TipoPeriodoCalendarioBO.SelecionaTipoPeriodoCalendarioPorCalendario(VS_cal_id, ApplicationWEB.AppMinutosCacheLongo);
int tpc_idRecesso = ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, __SessionWEB.__UsuarioWEB.Usuario.ent_id);
string tcp_nomeRecesso = string.Empty;
if (tpc_idRecesso > 0)
{
ACA_TipoPeriodoCalendario tpc = new ACA_TipoPeriodoCalendario {
tpc_id = tpc_idRecesso
};
ACA_TipoPeriodoCalendarioBO.GetEntity(tpc);
tcp_nomeRecesso = tpc.tpc_nome;
}
var source = lstLimite.Join(tblTipoEvento.Rows.Cast <DataRow>(),
evl => evl.tev_id,
tev => Convert.ToInt32(tev["tev_id"]),
(evl, tev) => new sLimite()
{
tev_nome = tev["tev_nome"].ToString(),
tpc_nome = (evl.tpc_id > 0
? (evl.tpc_id == tpc_idRecesso ? tcp_nomeRecesso : lstTipoPeriodo.First(tpc => tpc.tpc_id == evl.tpc_id).tpc_nome)
: string.Empty),
tev_id = evl.tev_id,
evl_id = evl.evl_id,
evl = evl
})
.GroupBy(evl => string.Format("{0}{1}{2}",
evl.tev_nome,
(string.IsNullOrEmpty(evl.tpc_nome) ? string.Empty : " - "),
evl.tpc_nome))
.Select(grp => new
{
TipoEventoBimestre = grp.Key,
Limites = grp.ToList()
})
.OrderBy(grp => grp.TipoEventoBimestre);
rptLimitesCalendario.DataSource = source;
rptLimitesCalendario.DataBind();
}
/// <summary>
/// Informa se o período já foi fechado (evento de fechamento já acabou) e não há nenhum evento de fechamento por vir.
/// Se o período ainda estiver ativo então não verifica o evento de fechamento
/// </summary>
/// <param name="tpc_id">ID do período do calendário</param>
/// <param name="cal_id">ID do calendário</param>
/// <param name="tur_id">ID da turma</param>
/// <param name="cap_dataFim">Data fim do período</param>
/// <returns></returns>
private bool VS_PeriodoEfetivado(int tpc_id, int cal_id, long tur_id, DateTime cap_dataFim)
{
bool efetivado = false;
//Se o bimestre está ativo ou nem começou então não bloqueia pelo evento de fechamento
if (DateTime.Today <= cap_dataFim)
{
return(false);
}
List <ACA_Evento> lstEventos = ACA_EventoBO.GetEntity_Efetivacao_List(cal_id, tur_id, __SessionWEB.__UsuarioWEB.Grupo.gru_id, __SessionWEB.__UsuarioWEB.Usuario.ent_id, ApplicationWEB.AppMinutosCacheLongo, false, __SessionWEB.__UsuarioWEB.Docente.doc_id);
//Só permite editar o bimestre se tiver evento ativo
efetivado = !lstEventos.Exists(p => p.tpc_id == tpc_id && p.tev_id == ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_EVENTO_EFETIVACAO_NOTAS, __SessionWEB.__UsuarioWEB.Usuario.ent_id) &&
DateTime.Today >= p.evt_dataInicio && DateTime.Today <= p.evt_dataFim);
return(efetivado);
}
public static DataTable SelecionaTodosPor_EventoEfetivacao
(
int cal_id
, long tud_id
, long tur_id
, Guid ent_id
, TalkDBTransaction banco = null
, long doc_id = -1
)
{
// 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(banco == null ?
new ACA_TipoPeriodoCalendarioDAO().SelecionaTodos_EventoEfetivacao(cal_id, tud_id, tev_idEfetivacao, tur_id, doc_id) :
new ACA_TipoPeriodoCalendarioDAO {
_Banco = banco
}.SelecionaTodos_EventoEfetivacao(cal_id, tud_id, tev_idEfetivacao, tur_id, doc_id));
}
public static DataTable Seleciona_cal_id(int cal_id, bool paginado, int currentPage, int pageSize, bool removerRecesso = true, Guid ent_id = new Guid())
{
if (pageSize == 0)
{
pageSize = 1;
}
totalRecords = 0;
ACA_CalendarioPeriodoDAO dao = new ACA_CalendarioPeriodoDAO();
DataTable retorno = dao.SelectBy_cal_id(cal_id, paginado, currentPage / pageSize, pageSize, out totalRecords);
if (removerRecesso && retorno.Rows.Count > 0)
{
retorno = retorno.AsEnumerable().Where(p => (int)p["tpc_id"] != ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, ent_id)).CopyToDataTable();
}
return(retorno);
}
protected void btnGerar_Click(object sender, EventArgs e)
{
if (Page.IsValid)
{
SalvarBusca();
string report, parameter;
parameter = string.Empty;
report = ((int)ReportNameGestaoAcademica.GraficoConsolidadoAtividadeAvaliativa).ToString();
XtraReport DevReport = null;
SymmetricAlgorithm sa = new SymmetricAlgorithm(SymmetricAlgorithm.Tipo.TripleDES);
DevReport = new RelGrafConsolidadoAtivAvaliada
(UCBuscaDocenteTurma.ComboEscola.Esc_ID,
UCBuscaDocenteTurma.ComboEscola.Uni_ID,
UCBuscaDocenteTurma.ComboEscola.Uad_ID,
UCBuscaDocenteTurma.ComboCalendario.Valor,
UCBuscaDocenteTurma.ComboCursoCurriculo.Valor[0],
UCBuscaDocenteTurma.ComboCursoCurriculo.Valor[1],
UCBuscaDocenteTurma.ComboCurriculoPeriodo.Valor[2],
UCBuscaDocenteTurma.ComboTurma.Valor[0],
UCCPeriodoCalendario.Valor[0],
UCCPeriodoCalendario.Valor[1],
UCComboTipoDisciplina.Valor,
__SessionWEB.__UsuarioWEB.Usuario.usu_id,
__SessionWEB.__UsuarioWEB.Grupo.gru_id,
GestaoEscolarUtilBO.nomePadraoPeriodo_Calendario(__SessionWEB.__UsuarioWEB.Usuario.ent_id),
ACA_ParametroAcademicoBO.ParametroValorPorEntidade(eChaveAcademico.MATRICULA_ESTADUAL, __SessionWEB.__UsuarioWEB.Usuario.ent_id),
GestaoEscolarUtilBO.nomePadraoCurso(__SessionWEB.__UsuarioWEB.Usuario.ent_id),
GestaoEscolarUtilBO.nomePadraoPeriodo_Calendario(__SessionWEB.__UsuarioWEB.Usuario.ent_id),
ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_NIVEL_ENSINO_EDUCACAO_INFANTIL, __SessionWEB.__UsuarioWEB.Usuario.ent_id),
(__SessionWEB.__UsuarioWEB.Grupo.vis_id == SysVisaoID.Administracao),
__SessionWEB.__UsuarioWEB.Usuario.ent_id,
GetGlobalResourceObject("Reporting", "Reporting.DocDctSubCabecalhoRetrato.Municipio").ToString(),
GetGlobalResourceObject("Reporting", "Reporting.DocDctSubCabecalhoRetrato.Secretaria").ToString(),
ApplicationWEB.LogoRelatorioDB);
GestaoEscolarUtilBO.SendParametersToReport(DevReport);
Response.Redirect(String.Format("~/Documentos/RelatorioDev.aspx?dummy='{0}'", HttpUtility.UrlEncode(sa.Encrypt(report))), false);
HttpContext.Current.ApplicationInstance.CompleteRequest();
}
}
/// <summary>
/// Carrega as turmas em que o docente da aula.
/// </summary>
/// <param name="doc_id">Código do docente</param>
/// <param name="esc_id">Código da escola</param>
/// <param name="mostrarCodigoNome">True - Exibe o código e nome da turma | False - Exibe apenas o código da turma</param>
public void CarregarPorDocente(long doc_id, int esc_id, int cal_id, bool mostrarCodigoNome, bool turmasNormais = false, bool mostraEletivas = true)
{
int posicaoDocenteCompatilhado = ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.POSICAO_DOCENCIA_COMPARTILHADA, __SessionWEB.__UsuarioWEB.Usuario.ent_id);
try
{
ddlCombo.Items.Clear();
ddlCombo.DataSource = TUR_TurmaBO.GetSelectBy_Docente_TodosTipos_Posicao(__SessionWEB.__UsuarioWEB.Usuario.ent_id, doc_id, posicaoDocenteCompatilhado, esc_id, cal_id, mostrarCodigoNome, turmasNormais, mostraEletivas, ApplicationWEB.AppMinutosCacheLongo);
ddlCombo.DataTextField = "tur_esc_nome";
CarregarMensagemSelecione();
ddlCombo.DataBind();
SelecionaPrimeiroItem();
}
catch (Exception)
{
lblMessage.Text = "Erro ao tentar carregar " + lblTitulo.Text.Replace('*', ' ').ToLower() + ".";
lblMessage.Visible = true;
}
}
/// <summary>
/// Carrega os dados do aluno
/// </summary>
public void CarregarDadosAluno()
{
int tev_idFechamento = ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_EVENTO_EFETIVACAO_NOTAS, __SessionWEB.__UsuarioWEB.Usuario.ent_id);
VS_ListaDadosPeriodo = MTR_MatriculaTurmaBO.SelecionarDadosAlunoEntradaRede(VS_alu_id, VS_mtu_id, tev_idFechamento, false);
if (VS_ListaDadosPeriodo.Any())
{
DadosAlunoEntradaRede dados = VS_ListaDadosPeriodo.First();
#region Cabeçalho - dados do aluno
// Carrega os dados do aluno.
lblNomeAluno.Text = dados.pes_nome;
lblTurma.Text = dados.tur_codigo;
if (dados.mtu_numeroChamada > 0)
{
lblNumeroChamada.Text = Convert.ToString(dados.mtu_numeroChamada);
}
else
{
lblNumeroChamada.Text = "-";
}
lblCodigoEol.Text = dados.alc_matricula;
if (dados.arq_idFoto > 0)
{
imgFotoAluno.ImageUrl = string.Format("~/WebControls/BoletimCompletoAluno/Imagem.ashx?idfoto={0}", dados.arq_idFoto);
}
else
{
imgFotoAluno.ImageUrl = __SessionWEB._AreaAtual._DiretorioImagens + "imgsAreaAluno/fotoAluno.png";
}
#endregion
CarregarLancamento();
}
}
/// <summary>
/// Retorna o período do calendário.
/// </summary>
/// <param name="cal_id">ID do calendário</param>
/// <param name="AppMinutosCacheLongo">Quantidade de minutos da configuração de cache longo</param>
/// <returns>List<Struct_CalendarioPeriodos></returns>
public static List <Struct_CalendarioPeriodos> SelecionaPor_Calendario
(
int cal_id
, int AppMinutosCacheLongo = 0
, bool removerRecesso = true
, Guid ent_id = new Guid()
)
{
List <Struct_CalendarioPeriodos> dados = null;
if (AppMinutosCacheLongo > 0)
{
string chave = RetornaChaveCache_PeriodosCalendario(cal_id);
dados = CacheManager.Factory.Get
(
chave,
() =>
{
return((from DataRow dr in new ACA_CalendarioPeriodoDAO().SelectBy_Calendario(cal_id).Rows
select(Struct_CalendarioPeriodos) GestaoEscolarUtilBO.DataRowToEntity(dr, new Struct_CalendarioPeriodos())).ToList());
},
AppMinutosCacheLongo
);
}
else
{
dados = (from DataRow dr in new ACA_CalendarioPeriodoDAO().SelectBy_Calendario(cal_id).Rows
select(Struct_CalendarioPeriodos) GestaoEscolarUtilBO.DataRowToEntity(dr, new Struct_CalendarioPeriodos())).ToList();
}
if (removerRecesso && dados.Any())
{
return(dados.Where(p => p.tpc_id != ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, ent_id)).ToList());
}
return(dados);
}
/// <summary>
/// Seleciona as pendências das disciplinas.
/// </summary>
/// <param name="listaTurmaDisciplina">lista de turmas disciplinas</param>
/// <param name="tev_EfetivacaoNotas">Tipo de evento de efetivação de notas.</param>
/// <returns></returns>
public static List <REL_TurmaDisciplinaSituacaoFechamento_Pendencia> SelecionaPendencias(List <sTurmaDisciplinaEscolaCalendario> listaTurmaDisciplina, Guid ent_id, int appMinutosCacheLongo = 0)
{
List <REL_TurmaDisciplinaSituacaoFechamento_Pendencia> dados = new List <REL_TurmaDisciplinaSituacaoFechamento_Pendencia>();
DataTable dt = new DataTable();
dt.Columns.Add("tud_id", typeof(Int64));
if (listaTurmaDisciplina.Any())
{
if (appMinutosCacheLongo > 0)
{
var listaCache = from sTurmaDisciplinaEscolaCalendario tud in listaTurmaDisciplina
select new
{
tud_id = tud.tud_id
,
tud_tipo = tud.tud_tipo
,
esc_id = tud.esc_id
,
uni_id = tud.uni_id
,
cal_ano = tud.cal_ano
,
cacheIsSet = CacheManager.Factory.IsSet(String.Format(ModelCache.PENDENCIAS_DISCIPLINA_MODEL_KEY, tud.esc_id, tud.uni_id, tud.cal_ano, tud.tud_id))
};
listaCache.Where(p => !p.cacheIsSet).ToList().ForEach
(
p =>
{
DataRow dr = dt.NewRow();
dr["tud_id"] = p.tud_id;
if (!dt.AsEnumerable().Any(d => Convert.ToInt64(d["tud_id"]) == p.tud_id))
{
dt.Rows.Add(dr);
}
}
);
if (dt.Rows.Count > 0)
{
DataTable dtPendencias = new REL_TurmaDisciplinaSituacaoFechamentoDAO().SelecionaPendencias(dt, ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_EVENTO_EFETIVACAO_NOTAS, ent_id));
dados = dtPendencias.Rows.Cast <DataRow>().Select(p => (REL_TurmaDisciplinaSituacaoFechamento_Pendencia)GestaoEscolarUtilBO.DataRowToEntity(p, new REL_TurmaDisciplinaSituacaoFechamento_Pendencia())).ToList();
var dadosDisciplina = from REL_TurmaDisciplinaSituacaoFechamento_Pendencia pend in dados
where pend.tud_tipo != (byte)TurmaDisciplinaTipo.ComponenteRegencia
group pend by pend.tud_id into grupo
select new
{
tud_id = grupo.Key
,
listaPendencias = grupo.ToList()
};
dadosDisciplina.ToList()
.ForEach
(
p =>
{
sTurmaDisciplinaEscolaCalendario turmaDisciplina = listaTurmaDisciplina.FirstOrDefault(t => t.tud_id == p.tud_id);
CacheManager.Factory.Set
(
String.Format(ModelCache.PENDENCIAS_DISCIPLINA_MODEL_KEY, turmaDisciplina.esc_id, turmaDisciplina.uni_id, turmaDisciplina.cal_ano, turmaDisciplina.tud_id)
,
p.listaPendencias
,
appMinutosCacheLongo
);
}
);
var dadosRegencia = from REL_TurmaDisciplinaSituacaoFechamento_Pendencia pend in dados
where pend.tud_tipo == (byte)TurmaDisciplinaTipo.ComponenteRegencia
group pend by pend.tud_idRegencia into grupo
select new
{
tud_idRegencia = grupo.Key
,
listaComponentes = grupo.ToList()
};
dadosRegencia.ToList()
.ForEach
(
p =>
{
sTurmaDisciplinaEscolaCalendario turmaDisciplina = listaTurmaDisciplina.FirstOrDefault(t => t.tud_id == p.tud_idRegencia);
CacheManager.Factory.Set
(
String.Format(ModelCache.PENDENCIAS_DISCIPLINA_MODEL_KEY, turmaDisciplina.esc_id, turmaDisciplina.uni_id, turmaDisciplina.cal_ano, turmaDisciplina.tud_id)
,
p.listaComponentes
,
appMinutosCacheLongo
);
}
);
}
dados.AddRange
(
listaCache.Where(p => p.cacheIsSet).SelectMany(p => CacheManager.Factory.Get <List <REL_TurmaDisciplinaSituacaoFechamento_Pendencia> >(String.Format(ModelCache.PENDENCIAS_DISCIPLINA_MODEL_KEY, p.esc_id, p.uni_id, p.cal_ano, p.tud_id)))
);
}
else
{
listaTurmaDisciplina.ForEach
(
p =>
{
DataRow dr = dt.NewRow();
dr["tud_id"] = p.tud_id;
if (!dt.AsEnumerable().Any(d => Convert.ToInt64(d["tud_id"]) == p.tud_id))
{
dt.Rows.Add(dr);
}
}
);
DataTable dtPendencias = new REL_TurmaDisciplinaSituacaoFechamentoDAO().SelecionaPendencias(dt, ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_EVENTO_EFETIVACAO_NOTAS, ent_id));
dados = dtPendencias.Rows.Cast <DataRow>().Select(p => (REL_TurmaDisciplinaSituacaoFechamento_Pendencia)GestaoEscolarUtilBO.DataRowToEntity(p, new REL_TurmaDisciplinaSituacaoFechamento_Pendencia())).ToList();
}
if (appMinutosCacheLongo > 0)
{
dt.Clear();
listaTurmaDisciplina.ForEach
(
p =>
{
DataRow dr = dt.NewRow();
dr["tud_id"] = p.tud_id;
if (!dt.AsEnumerable().Any(d => Convert.ToInt64(d["tud_id"]) == p.tud_id))
{
dt.Rows.Add(dr);
}
}
);
}
// Adiciona a pendência do plano de aula separado, porque ela aparece de acordo com a data atual,
// então não fica em cache.
DataTable dtPendenciasPlanoAula = new CLS_TurmaAulaPendenciaDAO().SelecionaPendencias(dt);
dados.AddRange(dtPendenciasPlanoAula.Rows.Cast <DataRow>().Select(p => (REL_TurmaDisciplinaSituacaoFechamento_Pendencia)GestaoEscolarUtilBO.DataRowToEntity(p, new REL_TurmaDisciplinaSituacaoFechamento_Pendencia())).ToList());
}
return(dados);
}
/// <summary>
/// Realiza as validações necessárias e salva a atividade extraclasse.
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public static bool Salvar(CLS_TurmaAtividadeExtraClasse entity, int cal_id, bool fechamentoAutomatico, Guid ent_id, List <long> lstDisciplinas, Guid usu_id, long tur_id)
{
TalkDBTransaction banco = new CLS_TurmaAtividadeExtraClasseDAO()._Banco.CopyThisInstance();
banco.Open(IsolationLevel.ReadCommitted);
try
{
List <CLS_TurmaAtividadeExtraClasse> lstEntities = new List <CLS_TurmaAtividadeExtraClasse>();
bool isNew = entity.IsNew;
if (lstDisciplinas.Count > 0)
{
if (isNew)
{
CLS_TurmaAtividadeExtraClasseRelacionada relacionada = new CLS_TurmaAtividadeExtraClasseRelacionada();
relacionada.IsNew = true;
relacionada.usu_id = usu_id;
if (CLS_TurmaAtividadeExtraClasseRelacionadaBO.Save(relacionada, banco))
{
entity.taer_id = relacionada.taer_id;
lstDisciplinas.ForEach(p =>
{
if (p != entity.tud_id)
{
lstEntities.Add(new CLS_TurmaAtividadeExtraClasse {
tud_id = p, tae_id = -1, taer_id = entity.taer_id, IsNew = true
});
}
});
}
else
{
throw new Exception("Erro ao tentar salvar componente curricular relacionado.");
}
}
else
{
List <CLS_TurmaAtividadeExtraClasse> lstRelacionadas = SelecionaAtividadeExtraclasseRelacionada(entity.taer_id);
if (lstRelacionadas.Count > 0)
{
lstEntities.AddRange(lstRelacionadas.FindAll(p => p.tud_id != entity.tud_id));
}
}
lstEntities.ForEach(p =>
{
p.tpc_id = entity.tpc_id;
p.tav_id = entity.tav_id;
p.tae_nome = entity.tae_nome;
p.tae_descricao = entity.tae_descricao;
p.tae_cargaHoraria = entity.tae_cargaHoraria;
p.tdt_posicao = entity.tdt_posicao;
p.IsNew = p.tae_id <= 0;
});
}
lstEntities.Add(entity);
List <TUR_TurmaDisciplina> turmaDisciplina = TUR_TurmaDisciplinaBO.GetSelectBy_Turma(tur_id, null, GestaoEscolarUtilBO.MinutosCacheLongo);
CLS_TurmaAtividadeExtraClasseDAO dao = new CLS_TurmaAtividadeExtraClasseDAO();
dao._Banco = banco;
foreach (CLS_TurmaAtividadeExtraClasse atividade in lstEntities)
{
if (atividade.Validate())
{
if (VerificaExistePorDisciplinaNomeTipoBimestre(atividade))
{
throw new ValidationException(string.Format("Já existe uma atividade extraclasse com o mesmo nome e tipo para o componente curricular '{0}' no bimestre.", TUR_TurmaDisciplinaBO.GetEntity(new TUR_TurmaDisciplina {
tud_id = atividade.tud_id
}).tud_nome));
}
decimal dis_cargaHorariaExtraClasse = 0, cargaAtividadeExtraTotal = 0;
if (VerificaCargaHorariaCursoCalendario(atividade, cal_id, out dis_cargaHorariaExtraClasse, out cargaAtividadeExtraTotal))
{
throw new ValidationException(string.Format("A soma de carga horária de atividades extraclasse ({0}) está acima da máxima permitida pelo componente curricular '{1}' ({2}).", cargaAtividadeExtraTotal, TUR_TurmaDisciplinaBO.GetEntity(new TUR_TurmaDisciplina {
tud_id = atividade.tud_id
}).tud_nome, dis_cargaHorariaExtraClasse));
}
if (dao.Salvar(atividade))
{
// Caso o fechamento seja automático, grava na fila de processamento.
if (!isNew && fechamentoAutomatico &&
turmaDisciplina.Find(t => t.tud_id == atividade.tud_id).tud_tipo != (byte)TurmaDisciplinaTipo.DocenteEspecificoComplementacaoRegencia &&
atividade.tpc_id != ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, ent_id))
{
CLS_AlunoFechamentoPendenciaBO.SalvarFilaFrequencia(atividade.tud_id, atividade.tpc_id, banco);
}
}
}
}
return(true);
}
catch (Exception ex)
{
banco.Close(ex);
throw;
}
finally
{
if (banco.ConnectionIsOpen)
{
banco.Close();
}
}
throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entity));
}
/// <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;
}
}
/// <summary>
/// Carrega os alunos da turma.
/// </summary>
/// <param name="tur_id">Id da turma.</param>
private void CarregarAlunosTurma(long tur_id)
{
VS_ListaAlunos = CLS_AlunoAvaliacaoTurmaDisciplinaBO.SelecionarAlunosTurma(tur_id, OrdenacaoDados, ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_EVENTO_EFETIVACAO_NOTAS, __SessionWEB.__UsuarioWEB.Usuario.ent_id), true);
rptAlunos.DataSource = VS_ListaAlunos;
rptAlunos.DataBind();
updDadosAluno.Update();
}
/// <summary>
/// Retorno dos dados.
/// </summary>
protected void UCAlunoEfetivacaoObservacaoGeral_ReturnValues(CLS_AlunoAvaliacaoTurmaObservacao entityObservacaoSelecionada, List <CLS_AlunoAvaliacaoTurmaDisciplina> listaAtualizacaoEfetivacao, byte resultado, List <MTR_MatriculaTurmaDisciplina> listaMatriculaTurmaDisciplina)
{
try
{
// Carrega os alunos da turma.
List <CLS_AlunoAvaliacaoTurDis_DadosAlunos> listaAlunos = VS_ListaAlunos;
CLS_AlunoAvaliacaoTurDis_DadosAlunos dadoAlunoSelecionado = CLS_AlunoAvaliacaoTurmaDisciplinaBO.SelecionarAlunosTurma(VS_tur_id, OrdenacaoDados, ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_EVENTO_EFETIVACAO_NOTAS, __SessionWEB.__UsuarioWEB.Usuario.ent_id), true, VS_alu_idSelecionado).FirstOrDefault();
if (listaAlunos.Any(p => p.alu_id == VS_alu_idSelecionado))
{
int i = listaAlunos.FindIndex(p => p.alu_id == VS_alu_idSelecionado);
listaAlunos[i] = dadoAlunoSelecionado;
}
rptAlunos.DataSource = listaAlunos;
rptAlunos.DataBind();
updDadosAluno.Update();
VS_ListaAlunos = listaAlunos;
foreach (RepeaterItem item in rptAlunos.Items)
{
HiddenField hdnAluId = (HiddenField)item.FindControl("hdnAluId");
if (Convert.ToInt64(hdnAluId.Value) == VS_alu_idSelecionado)
{
// Adiciona o estilo ao item selecionado.
HtmlTableRow trNomeAlunoAtivo = (HtmlTableRow)item.FindControl("trNomeAluno");
trNomeAlunoAtivo.Attributes.Add("class", "aluno-selecionado");
}
}
updDadosAluno.Update();
}
catch (Exception ex)
{
divResultados.Visible = false;
ApplicationWEB._GravaErro(ex);
lblMensagem.Text = UtilBO.GetErroMessage(RetornaValorResource("ErroCarregarSistema"), UtilBO.TipoMensagem.Erro);
}
}
protected void lblNomeAluno_Click(object sender, EventArgs e)
{
try
{
foreach (RepeaterItem item in rptAlunos.Items)
{
// Remove o estilo das outras linhas.
HtmlTableRow trNomeAluno = (HtmlTableRow)item.FindControl("trNomeAluno");
trNomeAluno.Attributes.Remove("class");
}
LinkButton lkbNomeAluno = (LinkButton)sender;
RepeaterItem rpiAluno = (RepeaterItem)((lkbNomeAluno).NamingContainer);
// Adiciona o estilo ao item selecionado.
HtmlTableRow trNomeAlunoAtivo = (HtmlTableRow)rpiAluno.FindControl("trNomeAluno");
trNomeAlunoAtivo.Attributes.Add("class", "aluno-selecionado");
HiddenField hdnAluId = (HiddenField)rpiAluno.FindControl("hdnAluId");
HiddenField hdnMtuId = (HiddenField)rpiAluno.FindControl("hdnMtuId");
VS_alu_idSelecionado = Convert.ToInt64(hdnAluId.Value);
UCAlunoEfetivacaoObservacaoGeral1.SelectedTab = 0;
spanMensagemSelecionarAluno.Visible = false;
UCAlunoEfetivacaoObservacaoGeral1.CarregarDadosAluno(Convert.ToInt64(hdnAluId.Value), Convert.ToInt32(hdnMtuId.Value), VS_tur_id, VS_esc_id, ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_EVENTO_EFETIVACAO_NOTAS, __SessionWEB.__UsuarioWEB.Usuario.ent_id), true);
UCAlunoEfetivacaoObservacaoGeral1.AnotacoesAlunoVisible = true;
UCAlunoEfetivacaoObservacaoGeral1.ObservacaoVisible = true;
updDadosAluno.Update();
}
catch (Exception ex)
{
UCAlunoEfetivacaoObservacaoGeral1.ObservacaoVisible = false;
ApplicationWEB._GravaErro(ex);
lblMensagem.Text = UtilBO.GetErroMessage(RetornaValorResource("ErroCarregarSistema"), UtilBO.TipoMensagem.Erro);
}
}