/// <summary>
/// Carrega os grids de disciplinas da turma
/// </summary>
/// <param name="cur_id">id do curso</param>
/// <param name="crr_id">id do currículo</param>
/// <param name="crp_id">id do currículo período</param>
/// <param name="tipo">tipo de disciplina (ex: 1–Obrigatória,3–Optativa...)</param>
/// <param name="tur_id">id da turma</param>
/// <param name="esc_id">Id da escola</param>
/// <param name="uni_id">Id da unidade da escola</param>
/// <param name="ProfessorEspecialista">Professor especialista</param>
/// <param name="dtDocentes">Tabela de docentes da escola</param>
/// <param name="dtAvaliacoesFormato">Tabela com avaliações periódicas do formato - será mostrada na coluna controle semestral</param>
/// <param name="dtDisciplinaNaoAvaliado">Tabela de disciplinas não avaliadas - todas as disciplinas da turma</param>
/// <param name="bloqueioAtribuicaoDocente">Flag que indica se é pra bloquear a atribuição de docente para a escola</param>
public void CarregaGridDisciplinas
(
int cur_id
, int crr_id
, int crp_id
, ACA_CurriculoDisciplinaTipo tipo
, long tur_id
, int esc_id
, int uni_id
, bool ProfessorEspecialista
, ref DataTable dtDocentes
, DataTable dtAvaliacoesFormato
, ref DataTable dtDisciplinaNaoAvaliado
, bool bloqueioAtribuicaoDocente
, ref DataTable dtVigenciasDocentes
, bool aplicarNovaRegraDocenciaCompartilhada
)
{
dtDocentesEscola = dtDocentes;
DtAvaliacoesFormato = dtAvaliacoesFormato;
DtDisciplinaNaoAvaliado = dtDisciplinaNaoAvaliado;
DtVigenciasDocentes = dtVigenciasDocentes;
if ((DtDisciplinaNaoAvaliado == null) && (tur_id > 0))
{
// Carregar avaliações que devem ser desconsideradas para a disciplina.
DtDisciplinaNaoAvaliado = TUR_TurmaDisciplinaNaoAvaliadoBO.GetSelectBy_Turma(tur_id);
}
bool mostraAvaliacoes = (DtAvaliacoesFormato != null) && (DtAvaliacoesFormato.Rows.Count > 0) && TUR_TurmaBO.VerificaAcessoControleSemestral(tur_id);
gvDisciplina.Columns[indiceColunaAvaliacoesPeriodicas].Visible = mostraAvaliacoes;
// Variáveis que carregam o combo de professor.
escola_esc_id = esc_id;
escola_uni_id = uni_id;
escola_bloqueioAtribuicaoDocente = bloqueioAtribuicaoDocente;
professorEspecialista = ProfessorEspecialista;
gvDisciplina.Columns[indiceColunaQtAulasSemanais].Visible =
tipo != ACA_CurriculoDisciplinaTipo.DisciplinaPrincipal;
// Carregando as disciplinas de acordo como o tipo dado.
DataTable dtDisciplina = ACA_CurriculoDisciplinaBO.GetSelectBy_Curso_Tipo(cur_id, crr_id, crp_id, tipo, tur_id);
lblMensagemControleSemestral.Visible = mostraAvaliacoes && dtDisciplina.Rows.Count > 0;
lblMensagemControleSemestral.Text = TextoControleSemestral;
// Guarda todas as disciplinas da turma
string tud_ids = string.Join(",", (from DataRow dr in dtDisciplina.Rows
select dr["tud_id"].ToString()).ToArray());
listTurmaDocentes = TUR_TurmaDocenteBO.SelecionaDocentesDisciplina(tud_ids);
// Caso o não tenho o tipo de disciplina aparece seguinte mensagem.
gvDisciplina.EmptyDataText = (dtDisciplina == null)
? string.Format("É necessário selecionar o(a) {0} e o(a) {1}.",
GestaoEscolarUtilBO.nomePadraoCurso(__SessionWEB.__UsuarioWEB.Usuario.ent_id).ToLower(),
GestaoEscolarUtilBO.nomePadraoPeriodo(__SessionWEB.__UsuarioWEB.Usuario.ent_id).ToLower())
: string.Format("Não foram encontrados(as) " + GetGlobalResourceObject("Mensagens", "MSG_DISCIPLINA_PLURAL_MIN") + " para o(a) {0} e o(a) {1} selecionado(a).",
GestaoEscolarUtilBO.nomePadraoCurso(__SessionWEB.__UsuarioWEB.Usuario.ent_id).ToLower(),
GestaoEscolarUtilBO.nomePadraoPeriodo(__SessionWEB.__UsuarioWEB.Usuario.ent_id).ToLower());
this.aplicarNovaRegraDocenciaCompartilhada = aplicarNovaRegraDocenciaCompartilhada;
gvDisciplina.DataSource = dtDisciplina;
gvDisciplina.DataBind();
// Volta o valor das tabelas (caso tenham sido carregados no DataBind do grid).
dtDocentes = dtDocentesEscola;
dtDisciplinaNaoAvaliado = DtDisciplinaNaoAvaliado;
}
/// <summary>
/// Carrega dados da turma na tela para alteração.
/// </summary>
/// <param name="tur_id">ID da turma</param>
private void CarregarDadosAlteracao(long tur_id)
{
try
{
VS_tur_id = tur_id;
// Carregar entidades.
TUR_Turma entTurma = new TUR_Turma {
tur_id = tur_id
};
TUR_TurmaBO.GetEntity(entTurma);
ESC_Escola entEscola = new ESC_Escola {
esc_id = entTurma.esc_id
};
ESC_EscolaBO.GetEntity(entEscola);
if (!ValidaDadosTurma(entTurma, entEscola))
{
return;
}
uccFiltroEscola.Uad_ID = entEscola.uad_idSuperiorGestao;
uccFiltroEscola_IndexChangedUA();
uccFiltroEscola.SelectedValueEscolas = new[] { entTurma.esc_id, entTurma.uni_id };
uccFiltroEscola_IndexChangedUnidadeEscola();
uccCalendario.Valor = entTurma.cal_id;
DtVigenciasDocentes = TUR_TurmaDocenteBO.SelecionaVigenciasDocentesPorDisciplina(tur_id);
VS_ListaCurriculoDisciplina = new List <ACA_CurriculoDisciplina>();
DataTable dt = TUR_TurmaDisciplinaBO.SelecionarTurmaDisciplina_CurriculoDisciplina_By_Turma(tur_id);
for (int row = 0; row < dt.Rows.Count; row++)
{
ACA_CurriculoDisciplina obj = new ACA_CurriculoDisciplina();
obj.dis_nome = dt.Rows[row]["dis_nome"].ToString();
obj.cur_nome = dt.Rows[row]["cur_nome"].ToString();
obj.crp_descricao = dt.Rows[row]["crp_descricao"].ToString();
obj.crp_id = (int)dt.Rows[row]["crp_id"];
obj.crr_id = (int)dt.Rows[row]["crr_id"];
obj.cur_id = (int)dt.Rows[row]["cur_id"];
obj.dis_id = (int)dt.Rows[row]["dis_id"];
obj.tds_id = (int)dt.Rows[row]["tds_id"];
obj.IsNew = false;
VS_ListaCurriculoDisciplina.Add(obj);
}
divDiciplinas.Visible = true;
AdicionaVazio();
grvDiciplinas.DataSource = VS_ListaCurriculoDisciplina;
grvDiciplinas.DataBind();
uccFormatoAvaliacao.CarregarFormatoPorFormatoPadraoAtivo(entTurma.fav_id);
uccFormatoAvaliacao.Valor = entTurma.fav_id;
txtCodigoTurma.Text = entTurma.tur_codigo;
txtCodigoInep.Text = entTurma.tur_codigoInep;
txtCapacidade.Text = entTurma.tur_vagas.ToString();
if (dt.Rows.Count > 0)
{
// Carga horária semanal da disciplina.
txtAulasSemanais.Text = dt.Rows[0]["tud_cargaHorariaSemanal"].ToString();
string nomeDocente = string.Empty;
if (!string.IsNullOrEmpty(dt.Rows[0]["doc_id"].ToString()))
{
DataTable informacoesDocente =
ACA_DocenteBO.SelecionaPorColaboradorDocente(
Convert.ToInt64(dt.Rows[0]["col_id"]),
Convert.ToInt64(dt.Rows[0]["doc_id"]));
nomeDocente = informacoesDocente.Rows[0]["pes_nome"].ToString();
}
VS_tud_id = Convert.ToInt64(dt.Rows[0]["tud_id"]);
//VS_tdt_id = (int)dt.Rows[0]["tdt_id"];
divDocente.Visible = true;
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++)
{
DataRow dr = dtDocentes.NewRow();
dr["posicao"] = i;
dr["tud_id"] = VS_tud_id;
dr["qtdedocentes"] = QtdeDocentes;
dr["tds_id"] = Convert.ToInt32(dt.Rows[0]["tds_id"]);
dtDocentes.Rows.Add(dr);
}
bloqueioAtribuicao = false;
esc_id = entTurma.esc_id;
uni_id = entTurma.uni_id;
tds_id = Convert.ToInt32(dt.Rows[0]["tds_id"]);
buscaDocente = true;
tur_docenteEspecialista = entTurma.tur_docenteEspecialista;
rptDocentes.DataSource = dtDocentes;
rptDocentes.DataBind();
}
uccTurno.Valor = entTurma.trn_id;
if (entTurma.tur_participaRodizio)
{
chkRodizio.Checked = true;
}
ddlSituacao.SelectedValue = entTurma.tur_situacao.ToString();
DesabilitaDadosAlteracao();
RegistraScriptConfirmacao(entTurma);
}
catch (Exception ex)
{
ApplicationWEB._GravaErro(ex);
lblMessage.Text = UtilBO.GetErroMessage("Erro ao tentar carregar a turma multisseriada.", UtilBO.TipoMensagem.Erro);
}
}
/// <summary>
/// Carrega todas as posições de docente permitidas pelo parâmetro.
/// </summary>
/// <param name="tud_id">Id da disciplina.</param>
/// <param name="doc_id">Id do docente.</param>
/// <param name="carregarDocentesComAtrib">Verifica se é pra carregar somente os docentes com atribuição.</param>
public void CarregarPorParametro(long tud_id = -1, long doc_id = -1)
{
try
{
int qtdPosicoes = ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.QUANTIDADE_DOCENTES_VIGENTES_DISCIPLINA, __SessionWEB.__UsuarioWEB.Usuario.ent_id);
bool carregarDocentesComAtrib = ACA_ParametroAcademicoBO.ParametroValorBooleanoPorEntidade(eChaveAcademico.NAO_MOSTRAR_POSICAO_DOCENTES_PLANEJAMENTO, __SessionWEB.__UsuarioWEB.Usuario.ent_id);
ddlCombo.Items.Clear();
if (tud_id > 0)
{
if (doc_id > 0)
{
List <KeyValuePair <int, string> > docentePosicao = TUR_TurmaDocenteBO.SelecionaDocentesPosicaoPorDisciplina(tud_id)
.Where(p => VS_ltPermissao.Any(q => q.tdt_posicaoPermissao == (byte)p.Key && q.pdc_permissaoConsulta)).ToList();
string nomeDocente;
foreach (int i in docentePosicao.Select(p => p.Key))
{
nomeDocente = docentePosicao.Find(p => p.Key == i).Value;
if (carregarDocentesComAtrib && (!string.IsNullOrEmpty(nomeDocente)))
{
ddlCombo.Items.Insert(0, new ListItem(nomeDocente, i.ToString(), true));
}
else if (!carregarDocentesComAtrib)
{
ddlCombo.Items.Insert(0, new ListItem(
string.IsNullOrEmpty(nomeDocente) ? string.Format("Docente {0}", i.ToString()) : nomeDocente,
i.ToString(),
true));
}
}
}
else
{
List <KeyValuePair <int, string> > docentePosicao = TUR_TurmaDocenteBO.SelecionaDocentesPosicaoPorDisciplina(tud_id);;
string nomeDocente;
for (int i = qtdPosicoes; i > 0; i--)
{
nomeDocente = docentePosicao.Find(p => p.Key == i).Value;
if (carregarDocentesComAtrib && (!string.IsNullOrEmpty(nomeDocente)))
{
ddlCombo.Items.Insert(0, new ListItem(nomeDocente, i.ToString(), true));
}
else if (!carregarDocentesComAtrib)
{
ddlCombo.Items.Insert(0, new ListItem(
string.IsNullOrEmpty(nomeDocente) ? string.Format("Docente {0}", i.ToString()) : nomeDocente,
i.ToString(),
true));
}
}
}
}
else
{
for (int i = qtdPosicoes; i > 0; i--)
{
ddlCombo.Items.Insert(0, new ListItem(
string.Format("Docente {0}", i.ToString()),
i.ToString(),
true));
}
}
IncluirOpcaoTodos();
CarregarMensagemSelecione();
ddlCombo.AppendDataBoundItems = true;
}
catch (Exception)
{
lblMessage.Text = "Erro ao tentar carregar " + lblTitulo.Text.Replace('*', ' ').ToLower() + ".";
lblMessage.Visible = true;
}
}
/// <summary>
/// Carrega dados da turma na tela para alteração.
/// </summary>
/// <param name="tur_id">ID da turma</param>
private void CarregarDadosAlteracao(long tur_id)
{
try
{
VS_tur_id = tur_id;
// Carregar entidades.
TUR_Turma entTurma = new TUR_Turma {
tur_id = tur_id
};
TUR_TurmaBO.GetEntity(entTurma);
ESC_Escola entEscola = new ESC_Escola {
esc_id = entTurma.esc_id
};
ESC_EscolaBO.GetEntity(entEscola);
DtVigenciasDocentes = TUR_TurmaDocenteBO.SelecionaVigenciasDocentesPorDisciplina(entTurma.tur_id);
List <TUR_TurmaCurriculo> listaCurriculos = TUR_TurmaCurriculoBO.GetSelectBy_Turma(entTurma.tur_id, ApplicationWEB.AppMinutosCacheLongo);
List <CadastroTurmaDisciplina> listaDisciplinas = TUR_TurmaDisciplinaBO.GetSelectCadastradosBy_Turma(tur_id);
if (!ValidaDadosTurma(entTurma, entEscola, listaCurriculos, listaDisciplinas))
{
return;
}
uccFiltroEscola.Uad_ID = entEscola.uad_idSuperior;
uccFiltroEscola_IndexChangedUA();
uccFiltroEscola.SelectedValueEscolas = new[] { entTurma.esc_id, entTurma.uni_id };
uccFiltroEscola_IndexChangedUnidadeEscola();
int cur_id = listaCurriculos[0].cur_id;
int crr_id = listaCurriculos[0].crr_id;
uccCursoCurriculo.Valor = new[] { cur_id, crr_id };
UCComboCursoCurriculo1_IndexChanged();
uccCalendario.Valor = entTurma.cal_id;
UCComboCalendario1_IndexChanged();
VS_tud_id = listaDisciplinas[0].entTurmaDisciplina.tud_id;
VS_tdt_id = listaDisciplinas[0].entTurmaDocente.tdt_id;
uccDisciplina.Valor = listaDisciplinas[0].entTurmaDiscRelDisciplina.dis_id;
UCComboDisciplina1_OnSelectedIndexChanged();
uccFormatoAvaliacao.CarregarFormatoPorFormatoPadraoAtivo(entTurma.fav_id);
uccFormatoAvaliacao.Valor = entTurma.fav_id;
UCComboFormatoAvaliacao1_IndexChanged();
txtCodigoTurma.Text = entTurma.tur_codigo;
txtCodigoInep.Text = entTurma.tur_codigoInep;
txtCapacidade.Text = entTurma.tur_vagas.ToString();
txtMinimoMatriculados.Text = entTurma.tur_minimoMatriculados.ToString();
// Carga horária semanal da disciplina.
txtAulasSemanais.Text = listaDisciplinas[0].entTurmaDisciplina.tud_cargaHorariaSemanal.ToString();
foreach (ListItem item in chkPeriodosCurso.Items)
{
int crp_id = Convert.ToInt32(item.Value);
item.Selected = listaCurriculos.Exists(p => p.crp_id == crp_id);
}
foreach (ListItem item in chkPeriodosCalendario.Items)
{
int tpc_id = Convert.ToInt32(item.Value);
item.Selected = listaDisciplinas[0].entTurmaCalendario.Exists(p => p.tpc_id == tpc_id);
}
ACA_Disciplina entDis = new ACA_Disciplina
{
dis_id = listaDisciplinas[0].entTurmaDiscRelDisciplina.dis_id
};
ACA_DisciplinaBO.GetEntity(entDis);
DataTable informacoesDocente =
ACA_DocenteBO.SelecionaPorColaboradorDocente(
listaDisciplinas[0].entTurmaDocente.col_id,
listaDisciplinas[0].entTurmaDocente.doc_id);
bool bloqueioAtribuicao = false;
divDocente.Visible = true;
if (informacoesDocente.Rows.Count > 0)
{
UCControleVigenciaDocentes.CarregarDocente(
informacoesDocente.Rows[0]["pes_nome"].ToString(),
1,
1,
VS_tud_id,
ref dtDocentes,
entDis.tds_id,
entTurma.esc_id,
entTurma.uni_id,
entTurma.tur_docenteEspecialista
, bloqueioAtribuicao
, ref DtVigenciasDocentes);
}
// Verifica se possui parametros de formacao
MTR_ParametroFormacaoTurma entityFormacao = MTR_ParametroFormacaoTurmaBO.SelecionaParametroPorAnoCurso(cur_id, crr_id, __SessionWEB.__UsuarioWEB.Usuario.ent_id);
if (entityFormacao != null)
{
uccTurno.CarregarTurnoPorParametroPeriodo(entityFormacao);
}
else
{
uccTurno.CarregarTurnoPorTurnoAtivo(entTurma.trn_id);
}
uccTurno.Valor = entTurma.trn_id;
if (entTurma.tur_participaRodizio)
{
chkRodizio.Checked = true;
}
if (entTurma.tur_situacao == (byte)TUR_TurmaSituacao.Aguardando)
{
ddlSituacao.Items.Add(new ListItem("Aguardando", ((byte)TUR_TurmaSituacao.Aguardando).ToString()));
}
ddlSituacao.SelectedValue = entTurma.tur_situacao.ToString();
DesabilitaDadosAlteracao(entityFormacao);
RegistraScriptConfirmacao(entTurma);
}
catch (ValidationException ex)
{
lblMessage.Text = UtilBO.GetErroMessage(ex.Message, UtilBO.TipoMensagem.Alerta);
}
catch (Exception ex)
{
ApplicationWEB._GravaErro(ex);
lblMessage.Text = UtilBO.GetErroMessage("Erro ao tentar carregar a turma de eletiva.", UtilBO.TipoMensagem.Erro);
}
}
/// <summary>
/// Carrega no repeater de disciplinas eletivas da turma
/// </summary>
/// <param name="cur_id">id do curso</param>
/// <param name="crr_id">id do currículo</param>
/// <param name="crp_id">id do currículo período</param>
/// <param name="tipo">tipo de disciplina (ex: 1–Obrigatória,3–Optativa...)</param>
/// <param name="tur_id">id da turma</param>
/// <param name="cal_id">Calendário</param>
/// <param name="esc_id">Id da escola</param>
/// <param name="uni_id">Unidade da escola</param>
/// <param name="ProfessorEspecialista">Flag que indica se turma é para professor especialista</param>
/// <param name="dtDocentes">Tabela de docentes da escola</param>
/// <param name="dtAvaliacoesFormato">Tabela com avaliações periódicas do formato - será mostrada na coluna controle semestral</param>
/// <param name="dtDisciplinaNaoAvaliado">Tabela de disciplinas não avaliadas - todas as disciplinas da turma</param>
/// <param name="bloqueioAtribuicaoDocente">Flag que indica se é pra bloquear a atribuição de docente para a escola</param>
/// <param name="tabelaPeriodosCalendario">Tabela com períodos do calendário da turma</param>
public bool CarregaRepeaterDisciplinas
(
Int32 cur_id
, Int32 crr_id
, Int32 crp_id
, ACA_CurriculoDisciplinaTipo tipo
, Int64 tur_id
, Int32 cal_id
, Int32 esc_id
, Int32 uni_id
, bool ProfessorEspecialista
, ref DataTable dtDocentes
, DataTable dtAvaliacoesFormato
, ref DataTable dtDisciplinaNaoAvaliado
, bool bloqueioAtribuicaoDocente
, DataTable tabelaPeriodosCalendario
, ref DataTable dtVigenciasDocentes
, bool aplicarNovaRegraDocenciaCompartilhada
)
{
dtDocentesEscola = dtDocentes;
DtAvaliacoesFormato = dtAvaliacoesFormato;
DtDisciplinaNaoAvaliado = dtDisciplinaNaoAvaliado;
dtPeriodosCalendario = tabelaPeriodosCalendario;
DtVigenciasDocentes = dtVigenciasDocentes;
if ((DtDisciplinaNaoAvaliado == null) && (tur_id > 0))
{
// Carregar avaliações que devem ser desconsideradas para a disciplina.
DtDisciplinaNaoAvaliado = TUR_TurmaDisciplinaNaoAvaliadoBO.GetSelectBy_Turma(tur_id);
}
// Variáveis que carregam o combo de professor.
escola_esc_id = esc_id;
escola_uni_id = uni_id;
escola_bloqueioAtribuicaoDocente = bloqueioAtribuicaoDocente;
professorEspecialista = ProfessorEspecialista;
VS_AcessoControleSemestral = TUR_TurmaBO.VerificaAcessoControleSemestral(tur_id);
bool mostraAvaliacoes = (DtAvaliacoesFormato != null && DtAvaliacoesFormato.Rows.Count > 0) && VS_AcessoControleSemestral;
// Carregando as disciplinas de acordo como o tipo dado.
DataTable dtDisciplina = ACA_CurriculoDisciplinaBO.GetSelectBy_Curso_Tipo
(
cur_id
, crr_id
, crp_id
, tipo
, tur_id
);
lblMensagemControleSemestral.Visible = mostraAvaliacoes && dtDisciplina.Rows.Count > 0;
lblMensagemControleSemestral.Text = TextoControleSemestral;
// Guarda todas as disciplinas da turma
string tud_ids = string.Join(",", (from DataRow dr in dtDisciplina.Rows
select dr["tud_id"].ToString()).ToArray());
listTurmaDocentes = TUR_TurmaDocenteBO.SelecionaDocentesDisciplina(tud_ids);
// Se existir disciplina eletiva
if (dtDisciplina.Rows.Count > 0)
{
lblSemDisciplinasEletivas.Visible = false;
rptDisciplinasEletivas.Visible = true;
this.aplicarNovaRegraDocenciaCompartilhada = aplicarNovaRegraDocenciaCompartilhada;
rptDisciplinasEletivas.DataSource = dtDisciplina;
rptDisciplinasEletivas.DataBind();
foreach (string id in periodosIds)
{
Script += "setaCheckBoxPeriodo('." + id + "');";
}
return(true);
}
lblSemDisciplinasEletivas.Visible = true;
rptDisciplinasEletivas.Visible = false;
// Volta o valor das tabelas (caso tenham sido carregados no DataBind do grid).
dtDocentes = dtDocentesEscola;
dtDisciplinaNaoAvaliado = DtDisciplinaNaoAvaliado;
return(false);
}
private void UCComboTurmaDisciplina_IndexChanged()
{
try
{
UCCPeriodoCalendario.Valor = new[] { -1, -1 };
UCCPeriodoCalendario.PermiteEditar = false;
// utilizado para evitar chamar o evento de alteracao do calendario periodo duas vezes seguidas.
bool selecionouComboPeriodos = false;
if (UCCTurmaDisciplina1.Valor > -1)
{
long tur_id = Convert.ToInt64(ddlTurma.SelectedValue);
TUR_Turma entTurma = new TUR_Turma {
tur_id = tur_id
};
TUR_TurmaBO.GetEntity(entTurma);
ACA_CalendarioAnual entCalendario = new ACA_CalendarioAnual {
cal_id = entTurma.cal_id
};
ACA_CalendarioAnualBO.GetEntity(entCalendario);
ACA_FormatoAvaliacao entFormatoAvaliacao = new ACA_FormatoAvaliacao {
fav_id = entTurma.fav_id
};
ACA_FormatoAvaliacaoBO.GetEntity(entFormatoAvaliacao);
VS_FechamentoAutomatico = entFormatoAvaliacao.fav_fechamentoAutomatico;
TUR_TurmaDisciplina entityTurmaDisciplina = new TUR_TurmaDisciplina {
tud_id = UCCTurmaDisciplina1.Valor
};
TUR_TurmaDisciplinaBO.GetEntity(entityTurmaDisciplina);
if (entityTurmaDisciplina.tud_naoLancarFrequencia)
{
lblMessage.Text = UtilBO.GetErroMessage(GetGlobalResourceObject("Mensagens", "MSG_DISCIPLINA") + " não pode lançar frequência na turma.", UtilBO.TipoMensagem.Alerta);
UCCTurmaDisciplina1.Valor = -1;
}
else
{
bool sucessoProcessarPendenciaFechamento = true;
if (VS_FechamentoAutomatico)
{
var pendencias = CLS_AlunoFechamentoPendenciaBO.SelecionarAguardandoProcessamento(tur_id, entityTurmaDisciplina.tud_id, entityTurmaDisciplina.tud_tipo, 0);
if ((pendencias != null) && (pendencias.Rows.Count > 0))
{
try
{
// limpa cache desta turma
string pattern;
pattern = String.Format("{0}_{1}", ModelCache.FECHAMENTO_AUTO_BIMESTRE_PATTERN_KEY, entityTurmaDisciplina.tud_id);
CacheManager.Factory.RemoveByPattern(pattern);
pattern = String.Format("{0}_{1}", ModelCache.FECHAMENTO_AUTO_BIMESTRE_FILTRO_DEFICIENCIA_PATTERN_KEY, entityTurmaDisciplina.tud_id);
CacheManager.Factory.RemoveByPattern(pattern);
pattern = String.Format("{0}_{1}", ModelCache.FECHAMENTO_AUTO_BIMESTRE_COMPONENTES_REGENCIA_PATTERN_KEY, tur_id);
CacheManager.Factory.RemoveByPattern(pattern);
pattern = String.Format("{0}_{1}", ModelCache.FECHAMENTO_AUTO_FINAL_PATTERN_KEY, entityTurmaDisciplina.tud_id);
CacheManager.Factory.RemoveByPattern(pattern);
pattern = String.Format("{0}_{1}", ModelCache.FECHAMENTO_AUTO_FINAL_FILTRO_DEFICIENCIA_PATTERN_KEY, entityTurmaDisciplina.tud_id);
CacheManager.Factory.RemoveByPattern(pattern);
pattern = String.Format("{0}_{1}", ModelCache.FECHAMENTO_AUTO_FINAL_COMPONENTES_REGENCIA_PATTERN_KEY, tur_id);
CacheManager.Factory.RemoveByPattern(pattern);
pattern = String.Format(ModelCache.PENDENCIAS_DISCIPLINA_MODEL_KEY, entTurma.esc_id, entTurma.uni_id, entCalendario.cal_ano, entityTurmaDisciplina.tud_id);
CacheManager.Factory.Remove(pattern);
CLS_AlunoFechamentoPendenciaBO.Processar(entityTurmaDisciplina.tud_id, (byte)AvaliacaoTipo.Final, pendencias);
}
catch (Exception ex)
{
sucessoProcessarPendenciaFechamento = false;
ApplicationWEB._GravaErro(ex);
lblMessage.Text = UtilBO.GetErroMessage(GetGlobalResourceObject("Classe", "CompensacaoAusencia.Cadastro.MensagemErroProcessarPendenciaFechamento").ToString(), UtilBO.TipoMensagem.Erro);
}
}
}
if (sucessoProcessarPendenciaFechamento)
{
UCCPeriodoCalendario.CarregarPorPeriodoEventoEfetivacaoVigentes(entTurma.cal_id, UCCTurmaDisciplina1.Valor, entTurma.tur_id, true);
selecionouComboPeriodos = UCCPeriodoCalendario.Valor[0] != -1 && UCCPeriodoCalendario.Valor[1] != -1;
UCCPeriodoCalendario.SetarFoco();
UCCPeriodoCalendario.PermiteEditar = true;
}
VS_DisciplinaEspecial = entityTurmaDisciplina.tud_disciplinaEspecial;
VS_posicao = TUR_TurmaDocenteBO.SelecionaPosicaoPorDocenteTurma(_VS_doc_id, UCCTurmaDisciplina1.Valor, ApplicationWEB.AppMinutosCacheLongo);
VS_tipoDocente = ACA_TipoDocenteBO.SelecionaTipoDocentePorPosicao(VS_posicao, ApplicationWEB.AppMinutosCacheLongo);
}
}
if (!selecionouComboPeriodos)
{
UCCPeriodoCalendario_IndexChanged();
}
}
catch (Exception ex)
{
ApplicationWEB._GravaErro(ex);
lblMessage.Text = UtilBO.GetErroMessage("Erro ao tentar carregar os dados.", UtilBO.TipoMensagem.Erro);
}
}
/// <summary>
/// Método para salvar um informativo.
/// </summary>
private void Salvar()
{
try
{
bool permiteEditar = true;
if (__SessionWEB.__UsuarioWEB.Docente.doc_id > 0)
{
long tud_id = UCCTurmaDisciplina1.Valor;
byte tdt_posicao = TUR_TurmaDocenteBO.SelecionaPosicaoPorDocenteTurma(__SessionWEB.__UsuarioWEB.Docente.doc_id, tud_id, ApplicationWEB.AppMinutosCacheLongo);
permiteEditar = CFG_PermissaoDocenteBO.SelecionaPermissaoModulo(tdt_posicao, (byte)EnumModuloPermissao.Compensacoes)
.Any(p => p.pdc_permissaoEdicao);
}
if (permiteEditar)
{
if (Convert.ToInt32(txtQtAulas.Text) == 0)
{
throw new ValidationException("Quantidade de aulas compensadas deve ser um número maior do que zero.");
}
CLS_CompensacaoAusencia entCompensacao = new CLS_CompensacaoAusencia();
entCompensacao.cpa_id = VS_cpa_id;
entCompensacao.tud_id = UCCTurmaDisciplina1.Valor;
entCompensacao.tpc_id = UCCPeriodoCalendario.Valor[0];
entCompensacao.cpa_atividadesDesenvolvidas = txtAtividades.Text;
entCompensacao.cpa_quantidadeAulasCompensadas = Convert.ToInt32(txtQtAulas.Text);
entCompensacao.pro_id = VS_pro_id;
entCompensacao.cpa_situacao = 1;
entCompensacao.IsNew = VS_cpa_id < 0;
List <CLS_CompensacaoAusenciaAluno> listCompensacaoAluno = new List <CLS_CompensacaoAusenciaAluno>();
foreach (RepeaterItem item in rptAlunos.Items)
{
CheckBox ckbAluno = (CheckBox)item.FindControl("ckbAluno");
if (ckbAluno != null && ckbAluno.Checked)
{
HiddenField hdnId = (HiddenField)item.FindControl("hdnId");
if (hdnId != null)
{
string[] valor = hdnId.Value.Split(';');
CLS_CompensacaoAusenciaAluno compAluno = new CLS_CompensacaoAusenciaAluno
{
tud_id = Convert.ToInt64(valor[0]),
cpa_id = Convert.ToInt32(entCompensacao.cpa_id),
alu_id = Convert.ToInt64(valor[1]),
mtu_id = Convert.ToInt32(valor[2]),
mtd_id = Convert.ToInt32(valor[3])
};
listCompensacaoAluno.Add(compAluno);
}
}
}
if (listCompensacaoAluno.Count == 0)
{
throw new ValidationException("É necessário selecionar pelo menos um aluno para realizar a compensação.");
}
if (CLS_CompensacaoAusenciaBO.Save(entCompensacao, listCompensacaoAluno, VS_FechamentoAutomatico, UCComboCalendario.Valor))
{
ApplicationWEB._GravaLogSistema(VS_cpa_id > 0 ? LOG_SistemaTipo.Update : LOG_SistemaTipo.Insert, "cpa_id: " + entCompensacao.cpa_id + " tud_id: " + entCompensacao.tud_id);
__SessionWEB.PostMessages = UtilBO.GetErroMessage("Compensação de ausência " + (VS_cpa_id > 0 ? "alterada" : "incluída") + " com sucesso.", UtilBO.TipoMensagem.Sucesso);
VS_QtAulasComp = 0;
VerificaPaginaRedirecionar();
}
}
else
{
string msg = String.Format("O docente não possui permissão para incluir compensações de ausência para o(a) {0} selecionado(a).", GetGlobalResourceObject("Mensagens", "MSG_DISCIPLINA_MIN"));
lblMessage.Text = UtilBO.GetErroMessage(msg, UtilBO.TipoMensagem.Alerta);
}
}
catch (ValidationException e)
{
lblMessage.Text = UtilBO.GetErroMessage(e.Message, UtilBO.TipoMensagem.Alerta);
}
catch (ArgumentException e)
{
lblMessage.Text = UtilBO.GetErroMessage(e.Message, UtilBO.TipoMensagem.Alerta);
}
catch (Exception ex)
{
ApplicationWEB._GravaErro(ex);
lblMessage.Text = UtilBO.GetErroMessage("Erro ao tentar salvar compensação de ausência.", UtilBO.TipoMensagem.Erro);
}
}
/// <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);
}
}