/// <summary>
/// Valida dados da turma e permissão de usuário necessários para alteração.
/// </summary>
/// <param name="entTurma">Turma a ser validada</param>
/// <param name="entEscola">Escola da turma</param>
/// <param name="listaCurriculos">Curriculos da turma</param>
/// <param name="listaDisciplinas">Disciplinas da turma</param>
/// <returns></returns>
private bool ValidaDadosTurma(TUR_Turma entTurma, ESC_Escola entEscola, List <TUR_TurmaCurriculo> listaCurriculos, List <CadastroTurmaDisciplina> listaDisciplinas)
{
// Verifica se usuário logado pertence à mesma entidade da turma, caso não seja, não é permitido editar.
if (entEscola.ent_id != __SessionWEB.__UsuarioWEB.Usuario.ent_id)
{
__SessionWEB.PostMessages = UtilBO.GetErroMessage("A turma não pertence à entidade na qual você está logado.", UtilBO.TipoMensagem.Alerta);
Response.Redirect("~/Turma/TurmaEletivaAluno/Busca.aspx", false);
HttpContext.Current.ApplicationInstance.CompleteRequest();
return(false);
}
if (entTurma.tur_tipo != (byte)TUR_TurmaTipo.EletivaAluno)
{
__SessionWEB.PostMessages = UtilBO.GetErroMessage("Não é permitido editar essa turma.", UtilBO.TipoMensagem.Alerta);
Response.Redirect("~/Turma/TurmaEletivaAluno/Busca.aspx", false);
HttpContext.Current.ApplicationInstance.CompleteRequest();
return(false);
}
if (listaCurriculos.Count == 0)
{
throw new ValidationException("A turma selecionada não possui nenhum currículo.");
}
if (listaDisciplinas.Count < 1)
{
throw new ValidationException("A turma não possui " + GetGlobalResourceObject("Mensagens", "MSG_DISCIPLINA_PLURAL_MIN") + " cadastrados.");
}
return(true);
}
/// <summary>
/// Registra scripts necessários para colocar a mensagem de validação no botão salvar só
/// quando alterar o combo de situação para 5-Encerrada.
/// </summary>
/// <param name="entTurma">Entidade da turma que está sendo editada</param>
private void RegistraScriptConfirmacao(TUR_Turma entTurma)
{
if (entTurma == null)
{
try
{
// Recuperar entidade da turma.
entTurma = new TUR_Turma
{
tur_id = VS_tur_id
};
TUR_TurmaBO.GetEntity(entTurma);
}
catch (Exception ex)
{
ApplicationWEB._GravaErro(ex);
lblMessage.Text = UtilBO.GetErroMessage("Erro ao tentar carregar o sistema.", UtilBO.TipoMensagem.Erro);
}
}
else
{
if ((!entTurma.IsNew) && (entTurma.tur_situacao == (byte)TUR_TurmaSituacao.Ativo))
{
ScriptManager sm = ScriptManager.GetCurrent(this);
if (sm != null)
{
string script = "var idDdlSituacao = '#" + ddlSituacao.ClientID + "';";
Page.ClientScript.RegisterClientScriptBlock(typeof(Page), "ids", script, true);
}
}
}
}
/// <summary>
/// Retorna a lista de TurmaCurriculo que será necessária para salvar.
/// </summary>
/// <param name="entTurma">Entidade da turma que será salva</param>
/// <returns></returns>
private List <TUR_TurmaCurriculo> RetornaListaCurriculos(TUR_Turma entTurma)
{
List <TUR_TurmaCurriculo> listaCurriculos = new List <TUR_TurmaCurriculo>();
foreach (ListItem item in chkPeriodosCurso.Items)
{
// Adicionar um TurmaCurriculo para cada item checado.
if (item.Selected)
{
TUR_TurmaCurriculo entTurCurriculo = new TUR_TurmaCurriculo
{
cur_id = uccCursoCurriculo.Valor[0],
crr_id = uccCursoCurriculo.Valor[1],
crp_id = Convert.ToInt32(item.Value),
tur_id = entTurma.tur_id,
tcr_prioridade = 1,
tcr_situacao = 1
};
listaCurriculos.Add(entTurCurriculo);
}
}
return(listaCurriculos);
}
/// <summary>
/// Remove os caches do fechamento automatico.
/// </summary>
/// <param name="tud_id">Id da disciplina na turma.</param>
private static void RemoveCacheFechamentoAutomatico(long tud_id)
{
string chave = ModelCache.FECHAMENTO_AUTO_BIMESTRE_PATTERN_KEY + "_" + tud_id;
CacheManager.Factory.RemoveByPattern(chave);
chave = ModelCache.FECHAMENTO_AUTO_BIMESTRE_FILTRO_DEFICIENCIA_PATTERN_KEY + "_" + tud_id;
CacheManager.Factory.RemoveByPattern(chave);
chave = String.Format(ModelCache.FECHAMENTO_AUTO_FINAL_MODEL_KEY, tud_id);
CacheManager.Factory.RemoveByPattern(chave);
chave = String.Format(ModelCache.FECHAMENTO_AUTO_FINAL_FILTRO_DEFICIENCIA_MODEL_KEY, tud_id);
CacheManager.Factory.RemoveByPattern(chave);
TUR_TurmaDisciplina turmaDisciplina = TUR_TurmaDisciplinaBO.GetEntity(new TUR_TurmaDisciplina {
tud_id = tud_id
});
if (turmaDisciplina.tud_tipo == (byte)TurmaDisciplinaTipo.Regencia)
{
TUR_Turma turma = TUR_TurmaRelTurmaDisciplinaBO.SelecionarTurmaPorTurmaDisciplina(tud_id);
chave = ModelCache.FECHAMENTO_AUTO_BIMESTRE_COMPONENTES_REGENCIA_PATTERN_KEY + "_" + turma.tur_id;
CacheManager.Factory.RemoveByPattern(chave);
chave = String.Format(ModelCache.FECHAMENTO_AUTO_FINAL_COMPONENTES_REGENCIA_MODEL_KEY, turma.tur_id);
CacheManager.Factory.RemoveByPattern(chave);
}
}
/// <summary>
/// Valida dados da turma e permissão de usuário necessários para alteração.
/// </summary>
/// <param name="entTurma">Turma a ser validada</param>
/// <param name="entEscola">Escola da turma</param>
/// <param name="listaCurriculos">Curriculos da turma</param>
/// <param name="listaDisciplinas">Disciplinas da turma</param>
/// <returns></returns>
private bool ValidaDadosTurma(TUR_Turma entTurma, ESC_Escola entEscola)
{
// Verifica se usuário logado pertence à mesma entidade da turma, caso não seja, não é permitido editar.
if (entEscola.ent_id != __SessionWEB.__UsuarioWEB.Usuario.ent_id)
{
__SessionWEB.PostMessages = UtilBO.GetErroMessage("A turma não pertence à entidade na qual você está logado.", UtilBO.TipoMensagem.Alerta);
Response.Redirect("~/Turma/TurmaMultisseriada/Busca.aspx", false);
HttpContext.Current.ApplicationInstance.CompleteRequest();
return(false);
}
if (entTurma.tur_tipo != (byte)TUR_TurmaTipo.Multisseriada)
{
__SessionWEB.PostMessages = UtilBO.GetErroMessage("Não é permitido editar essa turma.", UtilBO.TipoMensagem.Alerta);
Response.Redirect("~/Turma/TurmaMultisseriada/Busca.aspx", false);
HttpContext.Current.ApplicationInstance.CompleteRequest();
return(false);
}
//if (VS_ListaCurriculoDisciplina.Count < 1)
//{
// throw new Exception("A turma (tur_id: " + entTurma.tur_id +
// ") não possui [MSG_DISCIPLINAS] cadastrados(as).");
//}
return(true);
}
public static DataTable GetSelectBy_TurmaDisciplina_PeriodoTodos
(
long tud_id
, int tpc_id
, Guid usu_id
, byte tdt_posicao
, long tud_idRelacionada
, bool usuario_superior
, bool trazerAvaSecretaria = true
, bool ausenteTurmaNota = false
, string tur_ids = null
)
{
CLS_TurmaNotaDAO dao = new CLS_TurmaNotaDAO();
DataTable dtTurmas = TUR_Turma.TipoTabela_Turma();
if (!string.IsNullOrEmpty(tur_ids))
{
tur_ids.Split(';').ToList().ForEach
(
p =>
{
DataRow dr = dtTurmas.NewRow();
dr["tur_id"] = p.ToString();
dtTurmas.Rows.Add(dr);
}
);
}
return(dao.SelectBy_TurmaDisciplina_Periodo_NotaAlunoTodos(tud_id, tpc_id, usu_id, tdt_posicao, tud_idRelacionada, usuario_superior, trazerAvaSecretaria, ausenteTurmaNota, dtTurmas));
}
public static DataTable GetSelectBy_TurmaDisciplina_Periodo
(
long tud_id
, int tpc_id
, Guid usu_id
, byte tdt_posicao
, string tur_ids = null
)
{
CLS_TurmaNotaDAO dao = new CLS_TurmaNotaDAO();
DataTable dtTurmas = TUR_Turma.TipoTabela_Turma();
if (!string.IsNullOrEmpty(tur_ids))
{
tur_ids.Split(';').ToList().ForEach
(
p =>
{
DataRow dr = dtTurmas.NewRow();
dr["tur_id"] = p.ToString();
dtTurmas.Rows.Add(dr);
}
);
}
return(dao.SelectBy_TurmaDisciplina_Periodo_NotaAluno(tud_id, tpc_id, usu_id, tdt_posicao, dtTurmas));
}
/// <summary>
/// Salva as entidades turmaAula e TurmaAulaAluno nas listas.
/// </summary>
/// <param name="listTurmaAulaAluno">Lista de entidades CLS_TurmaAulaAluno</param>
/// <param name="listTurmaAula">LIsta de entidades CLS_TurmaAula</param>
/// <param name="tur_id">ID da turma</param>
/// <param name="tud_id">ID da disciplina que está sendo salva as frequências</param>
/// <param name="tdt_posicao">Posição do docente logado no sistema</param>
/// <param name="entityTurma">Turma.</param>
/// <param name="entityFormatoAvaliacao">Formato de avaliação.</param>
/// <param name="entityCurriculoPeriodo">CurriculoPeriodo.</param>
/// <returns></returns>
public static bool Save
(
List <CLS_TurmaAulaAluno> listTurmaAulaAluno
, List <CLS_TurmaAula> listTurmaAula
, long tur_id
, long tud_id
, byte tdt_posicao
, TUR_Turma entityTurma = null
, ACA_FormatoAvaliacao entityFormatoAvaliacao = null
, ACA_CurriculoPeriodo entityCurriculoPeriodo = null
, Guid usu_id = new Guid()
, byte origemLogAula = 0
, byte tipoLogAula = 0
, Guid ent_id = new Guid()
)
{
TalkDBTransaction banco = new CLS_TurmaAulaAlunoDAO()._Banco.CopyThisInstance();
banco.Open(IsolationLevel.ReadCommitted);
try
{
return(Save(listTurmaAulaAluno, listTurmaAula, tur_id, tud_id, tdt_posicao, entityTurma, entityFormatoAvaliacao, entityCurriculoPeriodo, banco, usu_id, origemLogAula, tipoLogAula, ent_id));
}
catch (Exception err)
{
banco.Close(err);
throw;
}
finally
{
banco.Close();
}
}
/// <summary>
/// Seleciona os alunos matriculados na turma para lançamento de alcance das habilidades na disciplina.
/// </summary>
/// <param name="tud_id">ID da turma disciplina.</param>
/// <param name="ocr_id">ID da orientação curricular.</param>
/// <param name="tpc_id">ID do tipo de período do calendário.</param>
/// <param name="cal_id">ID do calendário.</param>
/// <param name="tur_ids">ID das turmas normais de matricula dos alunos matriculados em turmas multisseriadas.</param>
/// <returns></returns>
public static DataTable SelecionaAlunosPorTurmaDisciplinaPeriodo
(
long tud_id,
long ocr_id,
int tpc_id,
int cal_id,
string tur_ids = null
)
{
DataTable dtTurma = TUR_Turma.TipoTabela_Turma();
if (!string.IsNullOrEmpty(tur_ids))
{
string[] ltTurIds = tur_ids.Split(';');
ltTurIds.ToList().ForEach
(
tur_id =>
{
DataRow dr = dtTurma.NewRow();
dr["tur_id"] = tur_id;
dtTurma.Rows.Add(dr);
}
);
}
return(new CLS_AlunoTurmaDisciplinaOrientacaoCurricularDAO().SelecionaAlunosPorTurmaDisciplinaPeriodo
(
tud_id,
ocr_id,
tpc_id,
cal_id,
dtTurma
));
}
public static DataTable SelecionaAnotacaoPorAulaTurmaDisciplina
(
long tud_id
, int tau_id
, Guid ent_id
, string tur_ids = null
)
{
CLS_TurmaAulaAlunoDAO dao = new CLS_TurmaAulaAlunoDAO();
DataTable dtTurmas = TUR_Turma.TipoTabela_Turma();
if (!string.IsNullOrEmpty(tur_ids))
{
tur_ids.Split(';').ToList().ForEach
(
p =>
{
DataRow dr = dtTurmas.NewRow();
dr["tur_id"] = p.ToString();
dtTurmas.Rows.Add(dr);
}
);
}
return(dao.SelectBy_tud_id_Return_anotacao(tud_id, tau_id, ent_id, dtTurmas));
}
public static List <sTurmaAulaAluno> SelecionaFrequenciaAulaTurmaDisciplina
(
long tud_id
, int tau_id
, string tur_ids = null
)
{
CLS_TurmaAulaAlunoDAO dao = new CLS_TurmaAulaAlunoDAO();
DataTable dtTurmas = TUR_Turma.TipoTabela_Turma();
if (!string.IsNullOrEmpty(tur_ids))
{
tur_ids.Split(';').ToList().ForEach
(
p =>
{
DataRow dr = dtTurmas.NewRow();
dr["tur_id"] = p.ToString();
dtTurmas.Rows.Add(dr);
}
);
}
return(dao.SelectBy_FrequenciaTurmaDisciplina(tud_id, tau_id, dtTurmas)
.Select()
.Select(p => (sTurmaAulaAluno)GestaoEscolarUtilBO.DataRowToEntity(p, new sTurmaAulaAluno()))
.ToList());
}
private void UCComboTurmaDisciplina_IndexChanged()
{
try
{
UCCPeriodoCalendario.Valor = new[] { -1, -1 };
UCCPeriodoCalendario.PermiteEditar = false;
if (UCCTurmaDisciplina1.Valor > -1)
{
long tur_id = Convert.ToInt64(ddlTurma.SelectedValue);
TUR_Turma entTur = new TUR_Turma {
tur_id = tur_id
};
TUR_TurmaBO.GetEntity(entTur);
UCCPeriodoCalendario.CarregarPorCalendario(entTur.cal_id);
UCCPeriodoCalendario.SetarFoco();
UCCPeriodoCalendario.PermiteEditar = true;
}
}
catch (Exception ex)
{
ApplicationWEB._GravaErro(ex);
lblMessage.Text = UtilBO.GetErroMessage("Erro ao tentar carregar os dados.", UtilBO.TipoMensagem.Erro);
}
}
/// <summary>
/// Retorna a lista com a estrutura necessária para salvar a TurmaDisciplina.
/// </summary>
/// <param name="entTurma">Entidade da turma que será salva</param>
/// <returns></returns>
private List <CadastroTurmaDisciplina> RetornaTurmaDisciplina(TUR_Turma entTurma)
{
List <CadastroTurmaDisciplina> listaTurmaDisciplina = new List <CadastroTurmaDisciplina>();
TUR_TurmaDisciplina entTurmaDisciplina = new TUR_TurmaDisciplina
{
tud_codigo = entTurma.tur_codigo,
tud_vagas = entTurma.tur_vagas,
tud_minimoMatriculados = entTurma.tur_minimoMatriculados,
tud_duracao = entTurma.tur_duracao,
tud_cargaHorariaSemanal = Convert.ToInt32(txtAulasSemanais.Text),
tud_aulaForaPeriodoNormal = false,
tud_global = false,
tud_nome = RetornaNomeDisciplina(),
tud_situacao = (byte)TurmaDisciplinaSituacao.Ativo,
tud_tipo = (byte)TurmaDisciplinaTipo.DisciplinaEletivaAluno,
tud_modo = (byte)TurmaDisciplinaModo.Normal,
tud_multiseriado = false,
tud_id = VS_tud_id,
IsNew = entTurma.IsNew
};
TUR_TurmaDisciplinaRelDisciplina entRelDis = new TUR_TurmaDisciplinaRelDisciplina
{
dis_id = uccDisciplina.Valor,
tud_id = entTurmaDisciplina.tud_id
};
List <TUR_Turma_Docentes_Disciplina> listaDocentes = UCControleVigenciaDocentes.RetornaDadosGrid();
listaDocentes.ForEach(p => p.entDocente.tdt_posicao = 1);
List <TUR_TurmaDisciplinaCalendario> listaCalendario = new List <TUR_TurmaDisciplinaCalendario>();
foreach (ListItem item in chkPeriodosCalendario.Items)
{
if (item.Selected)
{
TUR_TurmaDisciplinaCalendario ent = new TUR_TurmaDisciplinaCalendario
{
tpc_id = Convert.ToInt32(item.Value),
tud_id = entTurmaDisciplina.tud_id
};
listaCalendario.Add(ent);
}
}
CadastroTurmaDisciplina entCadTurmaDisciplina = new CadastroTurmaDisciplina
{
listaTurmaDocente = listaDocentes,
entTurmaCalendario = listaCalendario,
entTurmaDisciplina = entTurmaDisciplina,
entTurmaDiscRelDisciplina = entRelDis
};
listaTurmaDisciplina.Add(entCadTurmaDisciplina);
return(listaTurmaDisciplina);
}
private void UCCPeriodoCalendario_IndexChanged()
{
rptAlunos.DataSource = null;
bool possuiAlunos = false;
if (UCCPeriodoCalendario.Valor[0] != -1 && UCCPeriodoCalendario.Valor[1] != -1)
{
long tur_id = Convert.ToInt64(ddlTurma.SelectedValue);
TUR_Turma tur = new TUR_Turma();
tur.tur_id = tur_id;
TUR_TurmaBO.GetEntity(tur);
TUR_TurmaDisciplina tud = new TUR_TurmaDisciplina();
tud.tud_id = UCCTurmaDisciplina1.Valor;
TUR_TurmaDisciplinaBO.GetEntity(tud);
DateTime cap_dataInicio, cap_dataFim;
ACA_CalendarioPeriodoBO.RetornaDatasPeriodoPor_FormatoAvaliacaoTurmaDisciplina(UCCPeriodoCalendario.Valor[0], string.Empty, UCCTurmaDisciplina1.Valor, tur.fav_id, out cap_dataInicio, out cap_dataFim);
DataTable dt = _VS_doc_id > 0 && VS_DisciplinaEspecial?
MTR_MatriculaTurmaDisciplinaBO.SelecionaAtivosCompensacaoAusenciaFiltroDeficiencia(tur_id, UCCTurmaDisciplina1.Valor, UCCPeriodoCalendario.Valor[0], 0, VS_tipoDocente, VS_cpa_id, false, true) :
MTR_MatriculaTurmaDisciplinaBO.SelecionaAtivosCompensacaoAusencia(UCCTurmaDisciplina1.Valor, UCCPeriodoCalendario.Valor[0], 0, VS_cpa_id, false, true);
rptAlunos.DataSource = dt;
possuiAlunos = dt.Rows.Count > 0;
rptAlunos.DataBind();
lblMessage.Text = "";
if (tud.tud_tipo == (byte)TurmaDisciplinaTipo.Experiencia &&
!TUR_TurmaDisciplinaTerritorioBO.VerificaOferecimentoExperienciaBimestre(UCCTurmaDisciplina1.Valor, UCComboCalendario.Valor, UCCPeriodoCalendario.Valor[0]))
{
mostraSalvar = false;
lblMessage.Text += UtilBO.GetErroMessage("A experiência não possui territórios vigentes no bimestre.", UtilBO.TipoMensagem.Alerta);
}
if (VS_cpa_id <= 0)
{
if (possuiAlunos)
{
btnSalvar.Visible = __SessionWEB.__UsuarioWEB.GrupoPermissao.grp_inserir && mostraSalvar;
}
else
{
btnSalvar.Visible = false;
lblMessage.Text += UtilBO.GetErroMessage("Não existem alunos com ausências para serem compensadas.", UtilBO.TipoMensagem.Alerta);
}
}
}
fdsAlunos.Visible = possuiAlunos;
}
/// <summary>
/// Verifica se as regras do curso estão sendo cumpridas.
/// Quando o regime de matrícula é Seriado por avaliações, o formato tem que
/// ser do tipo Conceito Global e a avaliação selecionada tem que ser do tipo
/// Periódica ou Periódica + Final.
/// </summary>
private void VerificaRegrasCurso(TUR_Turma entityTurma, ACA_FormatoAvaliacao entityFormatoAvaliacao)
{
ACA_CurriculoPeriodo entCurPeriodo;
bool Seriado;
if (TUR_TurmaCurriculoBO.ValidaCursoSeriadoAvaliacao(entityTurma, entityFormatoAvaliacao, out entCurPeriodo, out Seriado) && Seriado)
{
VS_crp_nomeAvaliacao = GestaoEscolarUtilBO.nomePadraoPeriodoAvaliacao(entCurPeriodo.crp_nomeAvaliacao);
}
VS_CursoSeriadoAvaliacoes = Seriado && entCurPeriodo.crp_turmaAvaliacao;
}
/// <summary>
/// Verifica se o curso da turma possui avaliação do tipo seriado.
/// </summary>
/// <param name="entTurma">Entidade da turma.</param>
/// <param name="EntFormatoAvaliacao">Entidade do formato de avaliação da turma.</param>
/// <param name="banco">Transação.</param>
/// <param name="entCurriculoPeriodo">Entidade do grupamento da turma (parâmatro de sáida)</param>
/// <param name="Seriado">Flag que indica se o curso ~possui avaliação do tipo seriado (parâmatro de sáida)</param>
/// <returns></returns>
public static bool ValidaCursoSeriadoAvaliacao(TUR_Turma entTurma, ACA_FormatoAvaliacao EntFormatoAvaliacao, TalkDBTransaction banco, out ACA_CurriculoPeriodo entCurriculoPeriodo, out bool Seriado)
{
Seriado = false;
List <TUR_TurmaCurriculo> listCurriculos = TUR_TurmaCurriculoBO.GetSelectBy_Turma(entTurma.tur_id, banco, GestaoEscolarUtilBO.MinutosCacheLongo);
if (listCurriculos.Count == 0)
{
throw new Exception("A turma (tur_id: " + entTurma.tur_id + ") não possui nenhum curriculoPeriodo cadastrado.");
}
ACA_Curriculo entCurriculo = new ACA_Curriculo
{
cur_id = listCurriculos[0].cur_id
,
crr_id = listCurriculos[0].crr_id
};
ACA_CurriculoBO.GetEntity(entCurriculo, banco);
// Se curso for seriado por avaliações - EJA.
if (entCurriculo.crr_regimeMatricula ==
(byte)ACA_CurriculoRegimeMatricula.SeriadoPorAvaliacoes)
{
Seriado = true;
if ((EntFormatoAvaliacao.fav_tipo != (byte)ACA_FormatoAvaliacaoTipo.ConceitoGlobal) &&
(EntFormatoAvaliacao.fav_tipo != (byte)ACA_FormatoAvaliacaoTipo.GlobalDisciplina))
{
// Curso do EJA não pode efetivar notas por disciplina - não possui ligação
// com lançamento por disciplina.
throw new ValidationException("O formato de avaliação \"" + EntFormatoAvaliacao.fav_nome +
"\" deve ser do tipo \"Conceito global\" ou " +
"\"Conceito global e nota por " + CustomResource.GetGlobalResourceObject("Mensagens", "MSG_DISCIPLINA") + "\", " +
"pois o curso da turma é seriado por avaliações.");
}
}
entCurriculoPeriodo = new ACA_CurriculoPeriodo
{
cur_id = entCurriculo.cur_id
,
crr_id = entCurriculo.crr_id
,
crp_id = listCurriculos[0].crp_id
};
ACA_CurriculoPeriodoBO.GetEntity(entCurriculoPeriodo, banco);
return(true);
}
/// <summary>
/// Valida os dados necessários para realizar qualquer movimentação.
/// Dispara uma ValidationException caso haja algum problema.
/// </summary>
/// <param name="cadMov">Entidade de cadastro de movimentação</param>
/// <param name="alu">Entidade do aluno</param>
/// <param name="tmo">Entidade tipo de movimentação</param>
/// <param name="bancoGestao">Transação com banco - obrigatório</param>
private static void ValidaDadosMovimentacao(MTR_Movimentacao_Cadastro cadMov, MTR_TipoMovimentacao tmo, ACA_Aluno alu, TalkDBTransaction bancoGestao)
{
bool isValidInicioMovimentacao;
bool isValidFechamentoMovimentacao;
// Valida se está no momento configurado na movimentação.
MTR_TipoMovimentacaoBO.VerificaPeriodoValidoMovimentacao(cadMov.entMatTurAnterior,
cadMov.entAluCurAnterior,
cadMov.entMovimentacao.tmo_id,
bancoGestao,
cadMov.entMovimentacao.mov_dataRealizacao,
out isValidInicioMovimentacao,
out isValidFechamentoMovimentacao,
cadMov.listasFechamentoMatricula);
if (!isValidInicioMovimentacao)
{
throw new ValidationException("Não é possível realizar esse tipo de movimentação nesse momento do calendário escolar.");
}
if ((cadMov.entMatTurNovo != null) && (cadMov.entMatTurNovo.tur_id > 0))
{
// Verificar se a turma que o aluno vai entrar é do tipo 1-Normal.
TUR_Turma entTurmaDestino = null;
if (cadMov.listasFechamentoMatricula.listTurma != null)
{
// Se a lista de fechamento foi alimentada, buscar entidade da lista.
entTurmaDestino = cadMov.listasFechamentoMatricula.listTurma.Find(p => p.tur_id == cadMov.entMatTurNovo.tur_id);
}
if (entTurmaDestino == null)
{
entTurmaDestino = new TUR_Turma
{
tur_id = cadMov.entMatTurNovo.tur_id
};
TUR_TurmaBO.GetEntity(entTurmaDestino, bancoGestao);
}
if (entTurmaDestino.tur_tipo != (byte)TUR_TurmaTipo.Normal)
{
throw new ValidationException("Não é possível movimentar o aluno para a turma " +
entTurmaDestino.tur_codigo + ".");
}
}
}
protected void CarregarBoletim(long alu_id, int mtu_id)
{
try
{
string mtuId = "";
if (mtu_id > 0)
{
mtuId = Convert.ToString(mtu_id);
}
int tpc_id = 0;
MTR_MatriculaTurma matriculaTurma = MTR_MatriculaTurmaBO.GetEntity(new MTR_MatriculaTurma {
alu_id = __SessionWEB.__UsuarioWEB.alu_id, mtu_id = mtu_id
});
TUR_Turma turma = TUR_TurmaBO.GetEntity(new TUR_Turma {
tur_id = matriculaTurma.tur_id
});
DataTable dtAvaliacao = ACA_AvaliacaoBO.GetSelectBy_FormatoAvaliacao(turma.fav_id);
tpc_id = (from DataRow row in dtAvaliacao.Rows
orderby Convert.ToInt32(row["tpc_ordem"])
select Convert.ToInt32(row["tpc_id"])).FirstOrDefault();
List <ACA_AlunoBO.BoletimDadosAluno> lBoletimAluno = ACA_AlunoBO.BuscaBoletimAlunos(Convert.ToString(alu_id), mtuId, tpc_id, __SessionWEB.__UsuarioWEB.Usuario.ent_id);
if (lBoletimAluno != null && lBoletimAluno.Any())
{
UCAlunoBoletimEscolar.ExibeBoletim(lBoletimAluno.FirstOrDefault());
}
else
{
throw new ValidationException("O aluno não possui dados para o boletim.");
}
}
catch (ValidationException ex)
{
lblMensagem.Text = UtilBO.GetErroMessage(ex.Message, UtilBO.TipoMensagem.Alerta);
}
catch (Exception ex)
{
ApplicationWEB._GravaErro(ex);
lblMensagem.Text = UtilBO.GetErroMessage("Erro ao exibir o Boletim Online do aluno.", UtilBO.TipoMensagem.Erro);
}
}
/// <summary>
/// Retorna se a escola de origem vai ser responsável pelo lançamento de notas
/// </summary>
/// <param name="tur_id"></param>
/// <param name="dataMovimentacao"></param>
/// <param name="ent_id"></param>
/// <returns>
/// True: Lançamento de notas será pela escola de origem
/// False: Lançamento de notas será definido pelo usuário
/// </returns>
public static bool VerificaEfetivacaoEscolaOrigem(long tur_id, DateTime dataMovimentacao, Guid ent_id)
{
TUR_Turma tur = new TUR_Turma {
tur_id = tur_id
};
TUR_TurmaBO.GetEntity(tur);
int tmo_id = MTR_TipoMovimentacaoBO.Retorna_TipoMovimentacaoId((byte)MTR_TipoMovimentacaoTipoMovimento.TransferenciaPropriaRede, ent_id);
string sPrazoDias = MTR_ParametroTipoMovimentacaoBO.SelecionaValorParametroTipoMovimentacao(tmo_id, ChaveParametroTipoMovimentacao.PrazoDiasEfetivacaoEscolaOrigem);
int PrazoDias = string.IsNullOrEmpty(sPrazoDias) ? 0 : Convert.ToInt32(sPrazoDias);
DateTime dataFimPeriodoCalendario = ACA_TipoPeriodoCalendarioBO.SelecionaDataFinalPeriodoCalendarioAtual(tur.cal_id, dataMovimentacao);
return(dataFimPeriodoCalendario != new DateTime() &&
dataFimPeriodoCalendario.AddDays(PrazoDias * -1).Date <= dataMovimentacao);
}
/// <summary>
/// Retorna as todas as Atividades extraclasse(por disciplina) com as notas do aluno
/// </summary>
/// <param name="tud_id"></param>
/// <param name="tpc_id"></param>
/// <param name="dtTurmas"></param>
/// <returns></returns>
public static DataTable SelecionaPorPeriodoDisciplina_Alunos(long tud_id, int tpc_id, bool usuario_superior, byte tdt_posicao, string tur_ids = null)
{
using (DataTable dtTurmas = TUR_Turma.TipoTabela_Turma())
{
if (!string.IsNullOrEmpty(tur_ids))
{
tur_ids.Split(';').ToList().ForEach
(
p =>
{
DataRow dr = dtTurmas.NewRow();
dr["tur_id"] = p.ToString();
dtTurmas.Rows.Add(dr);
}
);
}
return(new CLS_TurmaAtividadeExtraClasseDAO().SelecionaPorPeriodoDisciplina_Alunos(tud_id, tpc_id, usuario_superior, tdt_posicao, dtTurmas));
}
}
/// <summary>
/// Retorna a lista de TurmaCurriculo que será necessária para salvar.
/// </summary>
/// <param name="entTurma">Entidade da turma que será salva</param>
/// <returns></returns>
private List <TUR_TurmaCurriculo> RetornaListaCurriculos(TUR_Turma entTurma)
{
List <TUR_TurmaCurriculo> listaCurriculos = new List <TUR_TurmaCurriculo>();
foreach (ACA_CurriculoDisciplina item in VS_ListaCurriculoDisciplina.Where(p => p.dis_id > 0))
{
TUR_TurmaCurriculo entTurCurriculo = new TUR_TurmaCurriculo
{
cur_id = item.cur_id,
crr_id = item.crr_id,
crp_id = item.crp_id,
tur_id = entTurma.tur_id,
tcr_prioridade = 1,
tcr_situacao = 1,
IsNew = item.IsNew
};
listaCurriculos.Add(entTurCurriculo);
}
return(listaCurriculos);
}
/// <summary>
/// Carrega as informações de qual escola, qual turma e qual bimestre deve ser importado
/// </summary>
private void CarregarDados()
{
TUR_Turma tur = new TUR_Turma {
tur_id = VS_tur_id
};
TUR_TurmaBO.GetEntity(tur);
ACA_CalendarioPeriodo tpc = ACA_CalendarioPeriodoBO.SelecionaPor_Calendario_TipoPeriodo(VS_cal_id, VS_tpc_id, ApplicationWEB.AppMinutosCacheLongo);
ESC_Escola esc = new ESC_Escola
{
esc_id = tur.esc_id,
ent_id = __SessionWEB.__UsuarioWEB.Usuario.ent_id
};
ESC_EscolaBO.GetEntity(esc);
lblEscola.Text = "Escola: " + esc.esc_nome;
lblTurma.Text = "Turma: " + tur.tur_codigo;
lblBimestre.Text = (string)GetGlobalResourceObject("Mensagens", "MSG_EFETIVACAO") + ": " + tpc.cap_descricao;
}
/// <summary>
/// Seleciona os alunos pelo turmadisciplina
/// </summary>
/// <param name="tud_id">ID da turmadisciplina</param>
/// <returns></returns>
public static DataTable SelecionaAlunosPorTud(long tud_id, bool documentoOficial, string tur_ids = null)
{
CLS_AlunoPlanejamentoDAO dao = new CLS_AlunoPlanejamentoDAO();
DataTable dtTurma = TUR_Turma.TipoTabela_Turma();
if (!string.IsNullOrEmpty(tur_ids))
{
string[] ltTurIds = tur_ids.Split(';');
ltTurIds.ToList().ForEach
(
tur_id =>
{
DataRow dr = dtTurma.NewRow();
dr["tur_id"] = tur_id;
dtTurma.Rows.Add(dr);
}
);
}
return(dao.SelecionaAlunosPorTud(tud_id, documentoOficial, dtTurma));
}
/// <summary>
/// Verifica se o curso da turma possui avaliação do tipo seriado.
/// </summary>
/// <param name="entTurma">Entidade da turma.</param>
/// <param name="EntFormatoAvaliacao">Entidade do formato de avaliação da turma.</param>
/// <param name="entCurriculoPeriodo">Entidade do grupamento da turma (parâmatro de sáida)</param>
/// <param name="Seriado">Flag que indica se o curso ~possui avaliação do tipo seriado (parâmatro de sáida)</param>
/// <returns></returns>
public static bool ValidaCursoSeriadoAvaliacao(TUR_Turma entTurma, ACA_FormatoAvaliacao EntFormatoAvaliacao, out ACA_CurriculoPeriodo entCurriculoPeriodo, out bool Seriado)
{
TalkDBTransaction banco = new CLS_AlunoAvaliacaoTurmaDAO()._Banco.CopyThisInstance();
banco.Open(IsolationLevel.ReadCommitted);
try
{
return(ValidaCursoSeriadoAvaliacao(entTurma, EntFormatoAvaliacao, banco, out entCurriculoPeriodo, out Seriado));
}
catch (Exception ex)
{
banco.Close(ex);
throw;
}
finally
{
if (banco.ConnectionIsOpen)
{
banco.Close();
}
}
}
/// <summary>
/// Verifica se o botão de frequência será exibido ou não
/// Se a turma existir disciplina principal, só exibe o botão de frequência para essa disciplina
/// </summary>
/// <param name="tud_id">Id da disciplina da turma</param>
/// <param name="TelaInicial">Tela inicial a ser carregada.</param>
/// <param name="entityTurma">The entity turma.</param>
/// <param name="entityFormato">The entity formato.</param>
public void ExibirFrequencia(long tud_id, PaginaGestao TelaInicial, TUR_Turma entityTurma, ACA_FormatoAvaliacao entityFormato)
{
bool BtnVisible = (TelaInicial != PaginaGestao.Lancamento_Frequencia) && (entityFormato.fav_tipoLancamentoFrequencia != Convert.ToByte(ACA_FormatoAvaliacaoTipoLancamentoFrequencia.Mensal));
if (tud_id > 0)
{
List <TUR_TurmaDisciplina> lista = TUR_TurmaDisciplinaBO.GetSelectBy_Turma(entityTurma.tur_id, null, GestaoEscolarUtilBO.MinutosCacheLongo);
// Se a turma possui disciplina principal e tem lançamento em conjunto.
if (lista.Exists(p => p.tud_tipo == (byte)TurmaDisciplinaTipo.DisciplinaPrincipal) &&
(!(entityFormato.fav_planejamentoAulasNotasConjunto && entityTurma.tur_docenteEspecialista)))
{
// Esconde o botão de lançamento de frequência caso a disciplina não seja a principal.
btnLancamentoFrequencia.Visible =
(lista.Find(p => p.tud_tipo == (byte)TurmaDisciplinaTipo.DisciplinaPrincipal).tud_id == tud_id) &&
BtnVisible;
}
else if (lista.Exists
(p =>
p.tud_id == tud_id &&
p.tud_tipo == (byte)TurmaDisciplinaTipo.DocenteEspecificoComplementacaoRegencia
))
{
// Se for a disciplina do tipo Complementação de regência, não exibe o botão de frequência.
btnLancamentoFrequencia.Visible = false;
}
else
{
btnLancamentoFrequencia.Visible = BtnVisible;
}
}
else
{
btnLancamentoFrequencia.Visible = BtnVisible;
}
}
public static bool Save
(
CLS_TurmaNota entity,
TUR_Turma entTurma,
DateTime cal_dataInicio,
DateTime cal_dataFim,
DateTime cap_dataInicio,
DateTime cap_dataFim,
Guid ent_id,
bool fav_permiteRecuperacaoForaPeriodo
)
{
return(Save(
entity,
entTurma,
cal_dataInicio,
cal_dataFim,
cap_dataInicio,
cap_dataFim,
ent_id,
new List <CLS_TurmaNotaOrientacaoCurricular>(),
fav_permiteRecuperacaoForaPeriodo
));
}
/// <summary>
/// Seleciona o planejamento dos alunos na turmadisciplina com os relacionados
/// </summary>
/// <param name="tud_id">ID da turmadisciplina</param>
/// <returns></returns>
public static List <AlunoPlanejamento> SelecionaPlanejamentoAlunoRelacionados(long tud_id, TalkDBTransaction banco = null, string tur_ids = null)
{
CLS_AlunoPlanejamentoDAO dao = new CLS_AlunoPlanejamentoDAO();
if (banco != null)
{
dao._Banco = banco;
}
DataTable dtTurma = TUR_Turma.TipoTabela_Turma();
if (!string.IsNullOrEmpty(tur_ids))
{
string[] ltTurIds = tur_ids.Split(';');
ltTurIds.ToList().ForEach
(
tur_id =>
{
DataRow dr = dtTurma.NewRow();
dr["tur_id"] = tur_id;
dtTurma.Rows.Add(dr);
}
);
}
DataTable dtAlunoPlanejamento = dao.SelecionaPlanejamentoAlunoRelacionados(tud_id, dtTurma);
return((from DataRow dr in dtAlunoPlanejamento.Rows
group dr by Convert.ToInt32(dr["alu_id"]) into grupo
select new AlunoPlanejamento
{
alu_id = Convert.ToInt64(grupo.First()["alu_id"])
,
tud_id = Convert.ToInt64(grupo.First()["tud_id"])
,
apl_id = Convert.ToInt32(grupo.First()["apl_id"])
,
apl_planejamento = grupo.First()["apl_planejamento"].ToString()
,
AlunoPlanejamentoRelacionada = !string.IsNullOrEmpty(grupo.First()["Relacionado"].ToString()) ?
(from DataRow drr in dtAlunoPlanejamento.Rows
where Convert.ToInt64(drr["alu_id"]) == Convert.ToInt64(grupo.First()["alu_id"])
where Convert.ToInt64(drr["tud_id"]) == Convert.ToInt64(grupo.First()["tud_id"])
where Convert.ToInt32(drr["apl_id"]) == Convert.ToInt32(grupo.First()["apl_id"])
select new AlunoPlanejamentoRelacionada
{
alu_id = Convert.ToInt64(drr["alu_id"])
,
tud_id = Convert.ToInt64(drr["tud_id"])
,
apl_id = Convert.ToInt32(drr["apl_id"])
,
Relacionado = Convert.ToBoolean(drr["Relacionado"])
,
tud_idRelacionado = Convert.ToInt64(drr["tud_idRelacionado"])
,
dis_nome = drr["dis_nome"].ToString()
,
alterado = false
}).ToList() :
new List <AlunoPlanejamentoRelacionada>()
,
alterado = false
}).ToList());
}
private void xrAtividadeAvaliativaEfetivacao_BeforePrint(object sender, System.Drawing.Printing.PrintEventArgs e)
{
TUR_Turma tur = new TUR_Turma
{
tur_id = Convert.ToInt64(TURID.Value)
};
TUR_TurmaBO.GetEntity(tur);
ACA_FormatoAvaliacao fav = new ACA_FormatoAvaliacao
{
fav_id = tur.fav_id
};
ACA_FormatoAvaliacaoBO.GetEntity(fav);
ACA_EscalaAvaliacao esa = new ACA_EscalaAvaliacao
{
esa_id = fav.esa_idPorDisciplina
};
ACA_EscalaAvaliacaoBO.GetEntity(esa);
xrBarra.Visible = (esa.esa_tipo == Convert.ToByte(1));
xrPizza.Visible = (esa.esa_tipo == Convert.ToByte(2));
List <string> lstCoresRelatorio = new List <string>();
//Carrega as faixas da turma com as cores
var lstFaixas = (from dadosGeral in dsGestaoEscolar2.NEW_RelatorioAvaliacao_Efetivacao_Grafico.AsEnumerable()
group dadosGeral by new
{
far_ordenar = dadosGeral.Field <object>("far_ordenar") != null
? dadosGeral.Field <object>("far_ordenar").ToString() : "",
far_cor = dadosGeral.Field <object>("far_cor") != null
? dadosGeral.Field <object>("far_cor").ToString() : ""
} into faixas
orderby faixas.Key.far_ordenar
select faixas.Key);
//Se todas as faixas tiverem cores então vai usar as cores das faixas
if (!lstFaixas.Any(p => string.IsNullOrEmpty(p.far_cor)))
{
lstCoresRelatorio = lstFaixas.Select(p => p.far_cor).ToList();
}
//Se não carregou nenhuma cor das faixas então usa as cores configuradas para o relatório
if (lstCoresRelatorio.Count == 0)
{
lstCoresRelatorio = RelatoriosDevUtil.SelecionaCoresRelatorio((int)ReportNameGestaoAcademicaDocumentosDocente.DocDctGraficoAtividadeAvaliativa).Select(p => p.cor_corPaleta).ToList();
}
Palette paletaCores = RelatoriosDevUtil.CarregarPaletaCoresRelatorio(lstCoresRelatorio);
if (paletaCores.Count > 0)
{
if (xrPizza.Visible)
{
xrPizza.PaletteRepository.Add("Gestao", paletaCores);
xrPizza.PaletteName = "Gestao";
}
if (xrBarra.Visible)
{
xrBarra.PaletteRepository.Add("Gestao", paletaCores);
xrBarra.PaletteName = "Gestao";
}
}
}
/// <summary>
/// Retorna nas 2 variáveis se a movimentação está no período válido, para o curso e ano letivo
/// informados (através da matrícula do aluno).
/// </summary>
/// <param name="tur_id">ID da turma</param>
/// <param name="cur_id">ID do curso</param>
/// <param name="crr_id">ID do curriculo do curso</param>
/// <param name="tmo_id">ID do tipo de movimentação</param>
/// <param name="dataComparar">Data para comparação do momento</param>
/// <param name="bancoGestao">Transação com banco - obrigatório</param>
/// <param name="estaInicioMovimentacao">OUT - retorna se está no período de início de movimentação</param>
/// <param name="estaFechamentoMovimentacao">OUT - retorna se está no período de fechamento de movimentação</param>
/// <param name="listasFechamentoMatricula">Listas carregadas com dados do fechamento de matrícula</param>
public static void VerificaPeriodoValidoMovimentacao
(
long tur_id
, int cur_id
, int crr_id
, int tmo_id
, DateTime dataComparar
, TalkDBTransaction bancoGestao
, out bool estaInicioMovimentacao
, out bool estaFechamentoMovimentacao
, FormacaoTurmaBO.ListasFechamentoMatricula listasFechamentoMatricula = null
)
{
TUR_Turma entTur = null;
if (listasFechamentoMatricula != null && listasFechamentoMatricula.listTurma != null)
{
// Busca a entidade da lista de fechamento de matrícula.
entTur = listasFechamentoMatricula.listTurma.Find(p => p.tur_id == tur_id);
}
if (entTur == null)
{
entTur = new TUR_Turma
{
tur_id = tur_id
};
TUR_TurmaBO.GetEntity(entTur, bancoGestao);
}
ACA_CalendarioAnual entCalendario = null;
if (listasFechamentoMatricula != null && listasFechamentoMatricula.listCalendarios != null)
{
// Busca a entidade da lista de fechamento de matrícula.
entCalendario = listasFechamentoMatricula.listCalendarios.Find(p => p.cal_id == entTur.cal_id);
}
if (entCalendario == null)
{
entCalendario = new ACA_CalendarioAnual
{
cal_id = entTur.cal_id
};
ACA_CalendarioAnualBO.GetEntity(entCalendario, bancoGestao);
}
int mom_ano = entCalendario.cal_ano;
MTR_TipoMovimentacaoDAO dao = new MTR_TipoMovimentacaoDAO {
_Banco = bancoGestao
};
DataTable dt = dao.SelectBy_PeriodoValido_Curso(cur_id, crr_id, tmo_id, mom_ano, dataComparar);
if (dt.Rows.Count > 0)
{
if (!String.IsNullOrEmpty(dt.Rows[0]["IsPeriodoInicioProcesso"].ToString()))
{
estaInicioMovimentacao = Convert.ToBoolean(dt.Rows[0]["IsPeriodoInicioProcesso"]);
}
else
{
estaInicioMovimentacao = false;
}
if (!String.IsNullOrEmpty(dt.Rows[0]["IsPeriodoFimProcesso"].ToString()))
{
estaFechamentoMovimentacao = Convert.ToBoolean(dt.Rows[0]["IsPeriodoFimProcesso"]);
}
else
{
estaFechamentoMovimentacao = false;
}
}
else
{
estaInicioMovimentacao = false;
estaFechamentoMovimentacao = false;
}
}
protected void Page_Load(object sender, EventArgs e)
{
try
{
UCEfetivacaoNotas1.VisibleNavegacao = false;
UCEfetivacaoNotas1.VisibleBotaoCancelar = false;
if (!IsPostBack)
{
string message = __SessionWEB.PostMessages;
if (!String.IsNullOrEmpty(message))
{
lblMessage.Text = message;
}
if (PreviousPage == null && Session["DadosPaginaRetorno"] == null && Session["tud_id"] == null)
{
// Se não carregou nenhuma turma, redireciona pra busca.
__SessionWEB.PostMessages = UtilBO.GetErroMessage("É necessário selecionar uma turma.", UtilBO.TipoMensagem.Alerta);
if (__SessionWEB.__UsuarioWEB.Grupo.vis_id == SysVisaoID.Gestao ||
__SessionWEB.__UsuarioWEB.Grupo.vis_id == SysVisaoID.UnidadeAdministrativa)
{
RedirecionarPagina("~/Academico/ControleTurma/MinhaEscolaGestor.aspx");
}
else
{
RedirecionarPagina("~/Academico/ControleTurma/Busca.aspx");
}
}
else
{
List <Struct_MinhasTurmas> dadosTodasTurmas = new List <Struct_MinhasTurmas>();
long tud_idCompartilhada = -1;
if (Session["Historico"] != null)
{
VS_historico = Convert.ToBoolean(Session["Historico"]) && __SessionWEB.__UsuarioWEB.Docente.doc_id > 0;
Session.Remove("Historico");
}
if (Session["TudIdCompartilhada"] != null)
{
tud_idCompartilhada = Convert.ToInt64(Session["TudIdCompartilhada"]);
Session.Remove("TudIdCompartilhada");
}
if (Session["tud_id"] != null && Session["tdt_posicao"] != null && Session["PaginaRetorno"] != null)
{
UCControleTurma1.VS_tud_id = Convert.ToInt64(Session["tud_id"]);
UCControleTurma1.VS_tdt_posicao = Convert.ToByte(Session["tdt_posicao"]);
UCNavegacaoTelaPeriodo.VS_paginaRetorno = Session["PaginaRetorno"].ToString();
if (Session["tur_tipo"] != null && Session["tur_idNormal"] != null && Session["tud_idAluno"] != null)
{
UCControleTurma1.VS_tur_tipo = Convert.ToByte(Session["tur_tipo"]);
UCControleTurma1.VS_tur_idNormal = Convert.ToInt64(Session["tur_idNormal"]);
UCControleTurma1.VS_tud_idAluno = Convert.ToInt64(Session["tud_idAluno"]);
}
if (VS_EntitiesControleTurma.escola == null)
{
ViewState["VS_EntitiesControleTurma"] = null;
}
UCControleTurma1.VS_esc_id = VS_EntitiesControleTurma.escola.esc_id;
UCControleTurma1.VS_uni_id = VS_EntitiesControleTurma.turma.uni_id;
UCControleTurma1.VS_tur_id = VS_EntitiesControleTurma.turma.tur_id;
UCControleTurma1.VS_tud_naoLancarNota = VS_EntitiesControleTurma.turmaDisciplina.tud_naoLancarNota;
UCControleTurma1.VS_tud_naoLancarFrequencia = VS_EntitiesControleTurma.turmaDisciplina.tud_naoLancarFrequencia;
UCControleTurma1.VS_tur_dataEncerramento = VS_EntitiesControleTurma.turma.tur_dataEncerramento;
UCNavegacaoTelaPeriodo.VS_cal_id = VS_EntitiesControleTurma.turma.cal_id;
UCControleTurma1.VS_tciIds = VS_EntitiesControleTurma.tciIds;
if (Session["VS_TpcId"] != null)
{
UCNavegacaoTelaPeriodo.VS_tpc_id = Convert.ToInt32(Session["VS_TpcId"]);
}
if (Session["VS_TpcOrdem"] != null)
{
UCNavegacaoTelaPeriodo.VS_tpc_ordem = Convert.ToInt32(Session["VS_TpcOrdem"]);
}
}
else if (PreviousPage != null && PreviousPage.IsCrossPagePostBack)
{
UCControleTurma1.VS_tud_id = PreviousPage.Edit_tud_id;
UCControleTurma1.VS_tdt_posicao = PreviousPage.Edit_tdt_posicao;
UCNavegacaoTelaPeriodo.VS_paginaRetorno = PreviousPage.PaginaRetorno;
if (VS_EntitiesControleTurma.escola == null)
{
ViewState["VS_EntitiesControleTurma"] = null;
}
UCControleTurma1.VS_esc_id = VS_EntitiesControleTurma.escola.esc_id;
UCControleTurma1.VS_uni_id = VS_EntitiesControleTurma.turma.uni_id;
UCControleTurma1.VS_tur_id = VS_EntitiesControleTurma.turma.tur_id;
UCControleTurma1.VS_tud_naoLancarNota = VS_EntitiesControleTurma.turmaDisciplina.tud_naoLancarNota;
UCControleTurma1.VS_tud_naoLancarFrequencia = VS_EntitiesControleTurma.turmaDisciplina.tud_naoLancarFrequencia;
UCControleTurma1.VS_tur_dataEncerramento = VS_EntitiesControleTurma.turma.tur_dataEncerramento;
UCNavegacaoTelaPeriodo.VS_cal_id = VS_EntitiesControleTurma.turma.cal_id;
UCControleTurma1.VS_tciIds = VS_EntitiesControleTurma.tciIds;
UCControleTurma1.VS_tur_tipo = VS_EntitiesControleTurma.turma.tur_tipo;
}
else if (Session["DadosPaginaRetorno"] != null)
{
Dictionary <string, string> listaDados = (Dictionary <string, string>)Session["DadosPaginaRetorno"];
UCControleTurma1.VS_tud_id = Convert.ToInt64(listaDados["Tud_idRetorno_ControleTurma"]);
UCControleTurma1.VS_tdt_posicao = Convert.ToByte(listaDados["Edit_tdt_posicao"]);
UCNavegacaoTelaPeriodo.VS_paginaRetorno = listaDados["PaginaRetorno"].ToString();
UCControleTurma1.VS_esc_id = Convert.ToInt32(listaDados["Edit_esc_id"]);
UCControleTurma1.VS_uni_id = Convert.ToInt32(listaDados["Edit_uni_id"]);
UCControleTurma1.VS_tur_id = Convert.ToInt64(listaDados["Edit_tur_id"]);
UCControleTurma1.VS_tud_naoLancarNota = Convert.ToBoolean(listaDados["Edit_tud_naoLancarNota"]);
UCControleTurma1.VS_tud_naoLancarFrequencia = Convert.ToBoolean(listaDados["Edit_tud_naoLancarFrequencia"]);
UCControleTurma1.VS_tur_dataEncerramento = Convert.ToDateTime(listaDados["Edit_tur_dataEncerramento"]);
UCNavegacaoTelaPeriodo.VS_cal_id = Convert.ToInt32(listaDados["Edit_cal_id"]);
UCControleTurma1.VS_tciIds = listaDados["Edit_tciIds"];
UCControleTurma1.VS_tur_tipo = Convert.ToByte(listaDados["Edit_tur_tipo"]);
UCControleTurma1.VS_tud_idAluno = Convert.ToInt64(listaDados["Edit_tud_idAluno"]);
UCControleTurma1.VS_tur_idNormal = Convert.ToInt64(listaDados["Edit_tur_idNormal"]);
UCNavegacaoTelaPeriodo.VS_tpc_id = Convert.ToInt32(listaDados["Edit_tpc_id"]);
UCNavegacaoTelaPeriodo.VS_tpc_ordem = Convert.ToInt32(listaDados["Edit_tpc_ordem"]);
UCControleTurma1.VS_tur_tud_ids = (List <string>)(Session["tur_tud_ids"] ?? new List <string>());
UCControleTurma1.LabelTurmas = listaDados["TextoTurmas"];
}
int tpcIdPendencia = -1;
if (Session["tpcIdPendencia"] != null)
{
tpcIdPendencia = Convert.ToInt32(Session["tpcIdPendencia"]);
}
// Remove os dados que possam estar na sessao
Session.Remove("tud_id");
Session.Remove("tdt_posicao");
Session.Remove("PaginaRetorno");
Session.Remove("DadosPaginaRetorno");
Session.Remove("VS_DadosTurmas");
Session.Remove("VS_TpcId");
Session.Remove("tur_tipo");
Session.Remove("tur_idNormal");
Session.Remove("tud_idAluno");
Session.Remove("tur_tud_ids");
Session.Remove("tipoPendencia");
Session.Remove("tpcIdPendencia");
Session.Remove("tudIdPendencia");
//
List <Struct_MinhasTurmas.Struct_Turmas> dadosTurma = new List <Struct_MinhasTurmas.Struct_Turmas>();
// Se for perfil Administrador
if (__SessionWEB.__UsuarioWEB.Docente.doc_id == 0)
{
dadosTodasTurmas.Add
(
new Struct_MinhasTurmas
{
Turmas = TUR_TurmaBO.SelecionaMinhasTurmasComboPorTurId
(
VS_EntitiesControleTurma.turmaDisciplina.tud_tipo == (byte)TurmaDisciplinaTipo.MultisseriadaDocente
? UCControleTurma1.VS_tur_idNormal : UCControleTurma1.VS_tur_id,
ApplicationWEB.AppMinutosCacheCurto
)
}
);
// Não busca pela posição
dadosTodasTurmas.All(p =>
{
dadosTurma.AddRange(p.Turmas.Where(t => t.tud_id == UCControleTurma1.VS_tud_id));
return(true);
});
UCControleTurma1.LabelTurmas = dadosTurma.FirstOrDefault().TurmaDisciplinaEscola;
}
else
{
dadosTodasTurmas = TUR_TurmaBO.SelecionaPorDocenteControleTurma(__SessionWEB.__UsuarioWEB.Usuario.ent_id, __SessionWEB.__UsuarioWEB.Docente.doc_id, ApplicationWEB.AppMinutosCacheCurto, false);
dadosTodasTurmas.All(p =>
{
dadosTurma.AddRange(p.Turmas.Where(t => t.tud_id == UCControleTurma1.VS_tud_id && t.tdt_posicao == UCControleTurma1.VS_tdt_posicao));
return(true);
});
VS_situacaoTurmaDisciplina = dadosTurma.FirstOrDefault().tdt_situacao;
UCControleTurma1.LabelTurmas = dadosTurma.FirstOrDefault().TurmaDisciplinaEscola;
}
VS_turmasAnoAtual = dadosTurma.FirstOrDefault().turmasAnoAtual;
UCNavegacaoTelaPeriodo.VS_opcaoAbaAtual = eOpcaoAbaMinhasTurmas.Efetivacao;
// Carrega o combo de disciplinas e seta o valor selecionado.
List <Struct_MinhasTurmas.Struct_Turmas> dadosTurmas = new List <Struct_MinhasTurmas.Struct_Turmas>();
dadosTodasTurmas.All(p =>
{
dadosTurmas.AddRange(p.Turmas);
return(true);
});
// Carrega combo de turmas
if (__SessionWEB.__UsuarioWEB.Docente.doc_id == 0)
{
List <Struct_MinhasTurmas.Struct_Turmas> dadosTurmasCombo = TUR_TurmaBO.SelecionaMinhasTurmasComboPorTurId
(
VS_EntitiesControleTurma.turmaDisciplina.tud_tipo == (byte)TurmaDisciplinaTipo.MultisseriadaDocente
? UCControleTurma1.VS_tur_idNormal : UCControleTurma1.VS_tur_id,
ApplicationWEB.AppMinutosCacheCurto
);
UCControleTurma1.CarregaTurmas(dadosTurmasCombo, UCNavegacaoTelaPeriodo.VS_cal_id, VS_EntitiesControleTurma.turmaDisciplina.tud_tipo, VS_EntitiesControleTurma.formatoAvaliacao.fav_fechamentoAutomatico, true);
}
else
{
List <Struct_MinhasTurmas.Struct_Turmas> dadosTurmasCombo = new List <Struct_MinhasTurmas.Struct_Turmas>();
if (VS_EntitiesControleTurma.turma.tur_situacao == (byte)TUR_TurmaSituacao.Ativo && VS_situacaoTurmaDisciplina == 1)
{
// dadosTurmasAtivas
dadosTurmasCombo = TUR_TurmaBO.SelecionaTurmasAtivasDocente(dadosTodasTurmas, 0);
}
else
{
dadosTurmasCombo = dadosTurmas;
}
UCControleTurma1.CarregaTurmas(dadosTurmasCombo, UCNavegacaoTelaPeriodo.VS_cal_id, VS_EntitiesControleTurma.turmaDisciplina.tud_tipo, VS_EntitiesControleTurma.formatoAvaliacao.fav_fechamentoAutomatico, true);
}
TUR_Turma turma = new TUR_Turma();
turma.tur_id = UCControleTurma1.VS_tur_id;
turma = TUR_TurmaBO.GetEntity(turma);
ACA_FormatoAvaliacao formatoAvaliacao = new ACA_FormatoAvaliacao();
formatoAvaliacao.fav_id = turma.fav_id;
formatoAvaliacao = ACA_FormatoAvaliacaoBO.GetEntity(formatoAvaliacao);
UCNavegacaoTelaPeriodo.VS_IncluirPeriodoFinal = formatoAvaliacao.fav_avaliacaoFinalAnalitica;
TUR_TurmaDisciplina entDisciplinaRelacionada = null;
if (VS_EntitiesControleTurma.turmaDisciplina.tud_tipo == (byte)ACA_CurriculoDisciplinaTipo.DocenciaCompartilhada)
{
List <sTurmaDisciplinaRelacionada> lstDisciplinaCompartilhada = VS_historico ? TUR_TurmaDisciplinaBO.SelectRelacionadaVigenteBy_DisciplinaCompartilhada(VS_EntitiesControleTurma.turmaDisciplina.tud_id, ApplicationWEB.AppMinutosCacheLongo, false, __SessionWEB.__UsuarioWEB.Docente.doc_id)
: TUR_TurmaDisciplinaBO.SelectRelacionadaVigenteBy_DisciplinaCompartilhada(VS_EntitiesControleTurma.turmaDisciplina.tud_id, ApplicationWEB.AppMinutosCacheLongo);
bool docenciaCompartilhadaOk = false;
if (lstDisciplinaCompartilhada.Count > 0)
{
if (tud_idCompartilhada <= 0 || !lstDisciplinaCompartilhada.Any(p => p.tud_id == tud_idCompartilhada))
{
tud_idCompartilhada = lstDisciplinaCompartilhada[0].tud_id;
}
if (tud_idCompartilhada > 0)
{
docenciaCompartilhadaOk = true;
entDisciplinaRelacionada = TUR_TurmaDisciplinaBO.GetEntity(new TUR_TurmaDisciplina {
tud_id = tud_idCompartilhada
});
VS_turmaDisciplinaRelacionada = lstDisciplinaCompartilhada.Find(p => p.tud_id == tud_idCompartilhada);
//UCControleTurma1.CarregarDisciplinaCompartilhada(lstDisciplinaCompartilhada, VS_turmaDisciplinaRelacionada.tud_id, VS_turmaDisciplinaRelacionada.tdr_id);
}
}
if (!docenciaCompartilhadaOk)
{
__SessionWEB.PostMessages = UtilBO.GetErroMessage(String.Format("{0} {1} - {2}.",
GetGlobalResourceObject("Mensagens", "MSG_SEM_RELACIONAMENTO_DOCENCIA_COMPARTILHADA").ToString()
, VS_EntitiesControleTurma.turma.tur_codigo
, VS_EntitiesControleTurma.turmaDisciplina.tud_nome)
, UtilBO.TipoMensagem.Alerta);
RedirecionarPagina(UCNavegacaoTelaPeriodo.VS_paginaRetorno);
}
}
UCNavegacaoTelaPeriodo.CarregarPeriodos(VS_ltPermissaoFrequencia, VS_ltPermissaoEfetivacao,
VS_ltPermissaoPlanejamentoAnual, VS_ltPermissaoAvaliacao,
entDisciplinaRelacionada, UCControleTurma1.VS_esc_id,
VS_EntitiesControleTurma.turmaDisciplina.tud_tipo, UCControleTurma1.VS_tdt_posicao, turma.tur_id, VS_EntitiesControleTurma.turmaDisciplina.tud_id, false, tpcIdPendencia);
if (UCNavegacaoTelaPeriodo.VS_tpc_id <= 0 && !formatoAvaliacao.fav_avaliacaoFinalAnalitica)
{
__SessionWEB.PostMessages = UtilBO.GetErroMessage("Escola não permite lançar dados.", UtilBO.TipoMensagem.Alerta);
RedirecionarPagina(UCNavegacaoTelaPeriodo.VS_paginaRetorno);
}
CarregarTela();
}
hdnProcessarFilaFechamentoTela.Value = ACA_ParametroAcademicoBO.ParametroValorBooleanoPorEntidade(eChaveAcademico.PROCESSAR_FILA_FECHAMENTO_TELA, __SessionWEB.__UsuarioWEB.Usuario.ent_id) ? "true" : "false";
}
ScriptManager sm = ScriptManager.GetCurrent(this);
if (sm != null)
{
sm.Scripts.Add(new ScriptReference("~/Includes/jsControleTurma_Efetivacao.js"));
sm.Scripts.Add(new ScriptReference("~/Includes/jsUCSelecaoDisciplinaCompartilhada.js"));
}
UCNavegacaoTelaPeriodo.OnCarregaDadosTela += CarregaSessionPaginaRetorno;
UCControleTurma1.IndexChanged = uccTurmaDisciplina_IndexChanged;
UCNavegacaoTelaPeriodo.OnAlteraPeriodo += CarregarTela;
UCSelecaoDisciplinaCompartilhada1.SelecionarDisciplina += UCSelecaoDisciplinaCompartilhada1_SelecionarDisciplina;
UCControleTurma1.chkTurmasNormaisMultisseriadasIndexChanged += UCControleTurma_chkTurmasNormaisMultisseriadasIndexChanged;
if ((__SessionWEB.__UsuarioWEB.Grupo.vis_id != SysVisaoID.Individual)
&&
(__SessionWEB.__UsuarioWEB.GrupoPermissao.grp_consultar && // somente permissão consulta
(!__SessionWEB.__UsuarioWEB.GrupoPermissao.grp_inserir) &&
(!__SessionWEB.__UsuarioWEB.GrupoPermissao.grp_excluir) &&
(!__SessionWEB.__UsuarioWEB.GrupoPermissao.grp_alterar)))
{
UCEfetivacaoNotas1.HabilitaBoletimAluno = true;
}
bool mudaCorTitulo = VS_cal_ano < DateTime.Now.Year && VS_turmasAnoAtual && VS_EntitiesControleTurma.turma.tur_situacao == 1;
UCControleTurma1.CorTituloTurma = mudaCorTitulo ? System.Drawing.ColorTranslator.FromHtml("#A52A2A") : System.Drawing.Color.Black;
divMessageTurmaAnterior.Visible = mudaCorTitulo;
}
catch (ThreadAbortException)
{
}
catch (Exception ex)
{
ApplicationWEB._GravaErro(ex);
lblMessage.Text = UtilBO.GetErroMessage("Erro ao tentar carregar os dados.", UtilBO.TipoMensagem.Erro);
}
}
