/// <summary>
/// Seleciona o formato de avaliação de acordo com a disciplina da turma.
/// </summary>
/// <param name="tud_id">Id da disciplina da turma.</param>
/// <returns>Formato de avaliação.</returns>
public ACA_FormatoAvaliacao SelecionarPorTur(long tur_id)
{
QuerySelectStoredProcedure qs = new QuerySelectStoredProcedure("NEW_ACA_FormatoAvaliacao_SelecionaPorTur", _Banco);
try
{
#region PARAMETROS
Param = qs.NewParameter();
Param.DbType = DbType.Int64;
Param.Size = 8;
Param.ParameterName = "@tur_id";
Param.Value = tur_id;
qs.Parameters.Add(Param);
#endregion
qs.Execute();
ACA_FormatoAvaliacao entity = new ACA_FormatoAvaliacao();
if (qs.Return.Rows.Count > 0)
{
entity = DataRowToEntity(qs.Return.Rows[0], entity);
}
return(entity);
}
finally
{
qs.Parameters.Clear();
}
}
/// <summary>
/// Inicializa o user control, setando a visibilidade os botões
/// conforme a página inicial.
/// </summary>
/// <param name="TelaInicial">Tela inicial a ser carregada.</param>
/// <param name="fav">Formato de avaliação</param>
/// <param name="tipo">Tipo de turma</param>
public void Inicializar
(
PaginaGestao TelaInicial
, ACA_FormatoAvaliacao fav
, TUR_TurmaTipo tipo
, TUR_TurmaDisciplina entTurmaDisciplina
)
{
lblInfoLancamentoFrequenciaMensal.Text = UtilBO.GetErroMessage("Para lançar a frequência mensal dessa turma, acessar a frequência mensal das turmas regulares dos alunos.", UtilBO.TipoMensagem.Informacao);
divInfoLancamentoFrequenciaMensal.Visible = (tipo == TUR_TurmaTipo.EletivaAluno);
btnEfetivacao.Visible = (TelaInicial != PaginaGestao.EfetivacaoNotas);
btnLancamentoFrequencia.Visible =
(TelaInicial != PaginaGestao.Lancamento_Frequencia) &&
(fav.fav_tipoLancamentoFrequencia !=
Convert.ToByte(ACA_FormatoAvaliacaoTipoLancamentoFrequencia.Mensal))
// Se a disciplina for do tipo Complementação de regência, não exibe o botão frequência.
&& (entTurmaDisciplina == null ||
entTurmaDisciplina.tud_tipo != (byte)TurmaDisciplinaTipo.DocenteEspecificoComplementacaoRegencia);
btnLancamentoAvaliacao.Visible = (TelaInicial != PaginaGestao.Lancamento_Avaliacoes);
btnLancamentoFrequenciaMensal.Visible = (TelaInicial != PaginaGestao.Lancamento_FrequenciaMensal) &&
(tipo != TUR_TurmaTipo.EletivaAluno) &&
((fav.fav_tipoLancamentoFrequencia == Convert.ToByte(ACA_FormatoAvaliacaoTipoLancamentoFrequencia.Mensal) ||
fav.fav_tipoLancamentoFrequencia == Convert.ToByte(ACA_FormatoAvaliacaoTipoLancamentoFrequencia.AulasPlanejadasMensal)) &&
__SessionWEB.__UsuarioWEB.Grupo.vis_id != SysVisaoID.Individual);
}
/// <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();
}
}
protected void btnLancamentoFrequenciaMensal_Click(object sender, EventArgs e)
{
try
{
SetaPeriodoSelecionado();
ACA_FormatoAvaliacao fav = new ACA_FormatoAvaliacao
{
fav_id = _VS_fav_id
};
ACA_FormatoAvaliacaoBO.GetEntity(fav);
if (fav.fav_tipoLancamentoFrequencia == Convert.ToByte(ACA_FormatoAvaliacaoTipoLancamentoFrequencia.Mensal) ||
fav.fav_tipoLancamentoFrequencia == Convert.ToByte(ACA_FormatoAvaliacaoTipoLancamentoFrequencia.AulasPlanejadasMensal))
{
Session["tur_idFrequencia"] = _VS_tur_id.ToString();
RedirecionaPagina("~/Classe/LancamentoFrequencia/LancamentoMensal.aspx");
}
}
catch (Exception ex)
{
ApplicationWEB._GravaErro(ex);
__SessionWEB.PostMessages = UtilBO.GetErroMessage("Erro ao tentar carregar o sistema.", UtilBO.TipoMensagem.Erro);
Response.Redirect("~/Classe/LancamentoFrequencia/Busca.aspx", false);
HttpContext.Current.ApplicationInstance.CompleteRequest();
}
}
/// <summary>
/// Pesquisa os dados da turma.
/// </summary>
private void Pesquisar()
{
fdsSemAlunos.Visible = false;
divResultados.Visible = false;
UCAlunoEfetivacaoObservacaoGeral1.Mensagem = string.Empty;
UCAlunoEfetivacaoObservacaoGeral1.ObservacaoVisible = false;
spanMensagemSelecionarAluno.Visible = false;
#region Salvar busca realizada com os parâmetros
Dictionary <string, string> filtros = new Dictionary <string, string>();
filtros.Add("uad_idSuperior", UCComboUAEscola1.Uad_ID.ToString());
filtros.Add("esc_id", UCComboUAEscola1.Esc_ID.ToString());
filtros.Add("uni_id", UCComboUAEscola1.Uni_ID.ToString());
filtros.Add("cal_id", UCComboCalendario1.Valor.ToString());
filtros.Add("tur_id", UCComboTurma1.Valor[0].ToString());
filtros.Add("crp_idTurma", UCComboTurma1.Valor[1].ToString());
filtros.Add("ttn_id", UCComboTurma1.Valor[2].ToString());
filtros.Add("turmaExtinta", chkTurmaExtinta.Checked.ToString());
__SessionWEB.BuscaRealizada = new BuscaGestao
{
PaginaBusca = PaginaGestao.EfetivacaoGestor
,
Filtros = filtros
};
#endregion Salvar busca realizada com os parâmetros
VS_esc_id = UCComboUAEscola1.Esc_ID;
VS_tur_id = UCComboTurma1.Valor[0];
CarregarAlunosTurma(VS_tur_id);
if (rptAlunos.Items.Count > 0)
{
divResultados.Visible = true;
spanMensagemSelecionarAluno.Visible = true;
fdsSemAlunos.Visible = false;
}
else
{
divResultados.Visible = false;
fdsSemAlunos.Visible = true;
lblMensagemSemAlunos.Text = UtilBO.GetErroMessage(RetornaValorResource("lblMensagemSemAlunos.Text"), UtilBO.TipoMensagem.Informacao);
}
// Formatacao da nota numerica
string arredondamento = ACA_ParametroAcademicoBO.ParametroValorBooleanoPorEntidade(eChaveAcademico.ARREDONDAMENTO_NOTA_AVALIACAO, __SessionWEB.__UsuarioWEB.Usuario.ent_id).ToString();
ACA_FormatoAvaliacao formatoAvaliacao = TUR_TurmaBO.SelecionaFormatoAvaliacao(VS_tur_id);
ACA_EscalaAvaliacaoNumerica escalaNum = new ACA_EscalaAvaliacaoNumerica {
esa_id = formatoAvaliacao.esa_idPorDisciplina
};
ACA_EscalaAvaliacaoNumericaBO.GetEntity(escalaNum);
hdnFormatacaoNota.Value = RetornaNumeroCasasDecimais(escalaNum) + ";"
+ arredondamento.ToString().ToLower() + ";"
+ escalaNum.ean_variacao.ToString().Replace(',', '.');
//
}
public void Carregar(int anoLetivo, int tcp_id, int tne_id)
{
try
{
dtDados = ACA_AlunoHistoricoBO.Seleciona_TipoCurriculoPeriodoAnoLetivo(tcp_id, anoLetivo, tne_id);
dtDados.Columns.Add("ahd_id");
dtDados.Columns.Add("grade", typeof(bool));
dtDados.Columns.Add("alu_id", typeof(int));
dtDados.Columns.Add("ahd_avaliacao", typeof(string));
dtDados.Columns.Add("ahd_frequencia", typeof(int));
foreach (DataRow row in dtDados.Rows)
{
if (Convert.ToInt32(row["tds_id"]) > 0)
{
row["grade"] = true;
}
else
{
row["grade"] = false;
}
}
if (dtDados.Rows.Count == 0)
{
lblMessage.Text = UtilBO.GetErroMessage((string)GetGlobalResourceObject("UserControl", "UCAddResultadoFinal.NenhumDadoParaInserir"),
UtilBO.TipoMensagem.Informacao);
}
else
{
ACA_FormatoAvaliacao fav = new ACA_FormatoAvaliacao {
fav_id = Convert.ToInt32(dtDados.Rows[0]["fav_id"])
};
ACA_FormatoAvaliacaoBO.GetEntity(fav);
VS_fav_tipo = fav.fav_tipo;
esa_id = fav.esa_idPorDisciplina > 0 ? fav.esa_idPorDisciplina : fav.esa_idConceitoGlobal;
ACA_EscalaAvaliacao esa = new ACA_EscalaAvaliacao {
esa_id = esa_id
};
ACA_EscalaAvaliacaoBO.GetEntity(esa);
tipo = esa.esa_tipo;
}
}
catch (Exception ex)
{
ApplicationWEB._GravaErro(ex);
lblMessage.Text = UtilBO.GetErroMessage((string)GetGlobalResourceObject("UserControl", "UCAddResultadoFinal.ErroCarregar"),
UtilBO.TipoMensagem.Erro);
}
}
/// <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);
}
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>
/// 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();
}
}
}
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);
}
}
public static bool Salvar(List <CLS_AlunoFrequenciaExterna> lstAlunoFrequenciaExterna, int fav_id, Guid ent_id)
{
TalkDBTransaction banco = new CLS_AlunoFrequenciaExternaDAO()._Banco.CopyThisInstance();
List <AlunoFechamentoPendencia> FilaProcessamento = new List <AlunoFechamentoPendencia>();
try
{
if (lstAlunoFrequenciaExterna.Aggregate(true, (salvou, freq) => salvou & Save(freq, banco)))
{
ACA_FormatoAvaliacao entFormatoAvaliacao = new ACA_FormatoAvaliacao {
fav_id = fav_id
};
ACA_FormatoAvaliacaoBO.GetEntity(entFormatoAvaliacao, banco);
if (entFormatoAvaliacao.fav_fechamentoAutomatico)
{
FilaProcessamento.AddRange
(lstAlunoFrequenciaExterna.GroupBy(p => new { p.tud_id, p.tpc_id })
.Select(p => new AlunoFechamentoPendencia
{
tud_id = p.Key.tud_id
,
tpc_id = p.Key.tpc_id
,
afp_frequencia = false
,
afp_nota = false
,
afp_frequenciaExterna = true
,
afp_processado = 0
})
);
if (FilaProcessamento.Any())
{
CLS_AlunoFechamentoPendenciaBO.SalvarFilaFrequenciaExterna(
FilaProcessamento
.GroupBy(g => new { g.tud_id, g.tpc_id })
.Select(p => new AlunoFechamentoPendencia
{
tud_id = p.FirstOrDefault().tud_id,
tpc_id = p.FirstOrDefault().tpc_id,
afp_frequencia = p.FirstOrDefault().afp_frequencia,
afp_nota = p.FirstOrDefault().afp_nota,
afp_frequenciaExterna = p.FirstOrDefault().afp_frequenciaExterna,
afp_processado = FilaProcessamento
.Where(w => w.tud_id == p.FirstOrDefault().tud_id&& w.tpc_id == p.FirstOrDefault().tpc_id)
.Min(m => m.afp_processado)
})
.Where(w => w.tpc_id > 0 && w.tpc_id != ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, ent_id))
.ToList()
, banco);
}
}
return(true);
}
return(false);
}
catch (Exception ex)
{
banco.Close(ex);
throw;
}
finally
{
if (banco.ConnectionIsOpen)
{
banco.Close();
}
}
}
protected void Page_Load(object sender, EventArgs e)
{
lblMsgParecer.Text = "Marque apenas as reuniões em que o responsável esteve presente.<br>";
//"Marque a opção Efetivado para indicar que o lançamento de frequência do " +
//"dia foi finalizado e todas as ausências foram apontadas.";
lblMsgParecer.Text = UtilBO.GetErroMessage(lblMsgParecer.Text, UtilBO.TipoMensagem.Informacao);
ScriptManager sm = ScriptManager.GetCurrent(this);
if (sm != null)
{
sm.Scripts.Add(new ScriptReference(ArquivoJS.JqueryFixer));
RegistrarParametrosMensagemSair(true, (__SessionWEB.__UsuarioWEB.Docente.doc_id > 0));
sm.Scripts.Add(new ScriptReference(ArquivoJS.ExitPageConfirm));
sm.Scripts.Add(new ScriptReference("~/Includes/jsSetExitPageConfirmer.js"));
sm.Scripts.Add(new ScriptReference(ArquivoJS.MsgConfirmBtn));
// A ordem dos 2 scripts abaixo não deve ser alterada - se for, as máscaras
// dos campos não vai funcionar, pois no primeiro script ele "refaz" as tabelas
// com o JQuery.Fixer, e por isso não adianta setar as máscaras antes.
sm.Scripts.Add(new ScriptReference(ArquivoJS.JQueryValidation));
sm.Scripts.Add(new ScriptReference(ArquivoJS.JqueryMask));
sm.Scripts.Add(new ScriptReference(ArquivoJS.MascarasCampos));
sm.Scripts.Add(new ScriptReference(ArquivoJS.CamposData));
sm.Scripts.Add(new ScriptReference("~/Includes/jsCadastroFrequenciaReuniaoResponsaveis.js"));
if (ACA_ParametroAcademicoBO.ParametroValorBooleanoPorEntidade(eChaveAcademico.BOTAO_SALVAR_PERMANECE_TELA, __SessionWEB.__UsuarioWEB.Usuario.ent_id))
{
if (!Convert.ToString(_btnCancelar.CssClass).Contains("btnMensagemUnload"))
{
_btnCancelar.CssClass += " btnMensagemUnload";
}
if (!Convert.ToString(_btnCancelar2.CssClass).Contains("btnMensagemUnload"))
{
_btnCancelar2.CssClass += " btnMensagemUnload";
}
}
}
HabilitarControlesTela(__SessionWEB.__UsuarioWEB.GrupoPermissao.grp_alterar);
if (!IsPostBack)
{
string message = __SessionWEB.PostMessages;
if (!string.IsNullOrEmpty(message))
{
_lblMessage.Text = message;
}
_carregaComboHora();
_carregaComboMinuto();
if (Session["tur_idFrequencia"] != null)
{
VS_tur_id = Convert.ToInt32(Session["tur_idFrequencia"]);
Session.Remove("tur_idFrequencia");
TUR_Turma tur = new TUR_Turma
{
tur_id = VS_tur_id
};
TUR_TurmaBO.GetEntity(tur);
ACA_FormatoAvaliacao fav = new ACA_FormatoAvaliacao
{
fav_id = tur.fav_id
};
ACA_FormatoAvaliacaoBO.GetEntity(fav);
ESC_Escola entEscola = ESC_EscolaBO.GetEntity(
new ESC_Escola {
esc_id = tur.esc_id
});
List <TUR_TurmaCurriculo> crrTur = TUR_TurmaCurriculoBO.GetSelectBy_Turma(VS_tur_id, ApplicationWEB.AppMinutosCacheLongo);
ACA_Curso cur = new ACA_Curso
{
cur_id = crrTur[0].cur_id
};
ACA_CursoBO.GetEntity(cur);
VS_cal_id = tur.cal_id;
if (Session["cap_idFrequencia"] != null && cadastroReunioesPorPeriodo)
{
VS_cap_id = Convert.ToInt32(Session["cap_idFrequencia"]);
Session.Remove("tur_idFrequencia");
}
ACA_CursoReunioes crn = ACA_CursoReunioesBO.SelecionaPorCursoCalendarioPeriodo
(
cur.cur_id
,
crrTur[0].crr_id
,
VS_cal_id
,
cadastroReunioesPorPeriodo ? VS_cap_id : -1
);
VS_qtd_reunioes = crn.crn_qtde;
string esc_nome = entEscola.esc_nome;
if (ACA_ParametroAcademicoBO.ParametroValorBooleanoPorEntidade(eChaveAcademico.ORDENAR_ESCOLAS_POR_CODIGO, __SessionWEB.__UsuarioWEB.Usuario.ent_id))
{
esc_nome = entEscola.esc_codigo + " - " + esc_nome;
}
lblTurma.Text = "Escola: <b>" + esc_nome + "</b><br />";
lblTurma.Text += "Turma: <b>" + tur.tur_codigo + "</b>";
lblCurso.Text = GestaoEscolarUtilBO.nomePadraoCurso(__SessionWEB.__UsuarioWEB.Usuario.ent_id) + ": <b>" + cur.cur_nome + "</b>";
if (cadastroReunioesPorPeriodo)
{
ACA_CalendarioPeriodo cap = new ACA_CalendarioPeriodo {
cal_id = VS_cal_id, cap_id = VS_cap_id
};
ACA_CalendarioPeriodoBO.GetEntity(cap);
lblPeriodoCalendario.Text = GestaoEscolarUtilBO.nomePadraoPeriodo_Calendario(__SessionWEB.__UsuarioWEB.Usuario.ent_id) + ": <b>" + cap.cap_descricao + (periodoAberto ? " (aberto)" : string.Empty) + "</b>";
UCComboPeriodoCalendario1.Visible = false;
lblPeriodoCalendario.Visible = true;
}
else
{
lblPeriodoCalendario.Visible = false;
UCComboPeriodoCalendario1.Visible = true;
// Carregar combo de período do calendário.
UCComboPeriodoCalendario1.CarregarTodosPor_EventoEfetivacao(VS_cal_id, -1, VS_tur_id, __SessionWEB.__UsuarioWEB.Docente.doc_id);
}
VerificaRegrasCurso(tur, fav);
CarregarTelaLancametoFrequencia();
}
else
{
Response.Redirect("~/Classe/ReunioesResponsaveisFrequencia/Busca.aspx", false);
HttpContext.Current.ApplicationInstance.CompleteRequest();
}
}
_UCComboOrdenacao1._OnSelectedIndexChange += CarregarTelaLancametoFrequencia;
UCComboPeriodoCalendario1.IndexChanged += UCComboPeriodoCalendario1_IndexChanged;
}
/// <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;
}
}
protected void grvTurmas_RowDataBound(object sender, GridViewRowEventArgs e)
{
if (e.Row.RowType == DataControlRowType.DataRow && PreCarregarFechamentoCache)
{
long tur_id = Convert.ToInt64(DataBinder.Eval(e.Row.DataItem, "tur_id"));
int fav_id = Convert.ToInt32(DataBinder.Eval(e.Row.DataItem, "fav_id"));
int esc_id = Convert.ToInt32(DataBinder.Eval(e.Row.DataItem, "esc_id"));
int cal_id = Convert.ToInt32(DataBinder.Eval(e.Row.DataItem, "cal_id"));
byte tur_tipo = Convert.ToByte(DataBinder.Eval(e.Row.DataItem, "tur_tipo"));
long tud_id = Convert.ToInt64(DataBinder.Eval(e.Row.DataItem, "tud_id"));
byte tud_tipo = Convert.ToByte(DataBinder.Eval(e.Row.DataItem, "tud_tipo"));
bool tud_disciplinaEspecial = Convert.ToBoolean(DataBinder.Eval(e.Row.DataItem, "tud_disciplinaEspecial"));
byte tdt_posicao = Convert.ToByte(DataBinder.Eval(e.Row.DataItem, "tdt_posicao"));
ACA_FormatoAvaliacao entityFormatoAvaliacao = new ACA_FormatoAvaliacao {
fav_id = fav_id
};
ACA_FormatoAvaliacaoBO.GetEntity(entityFormatoAvaliacao);
ACA_EscalaAvaliacao entityEscalaAvaliacao = new ACA_EscalaAvaliacao {
esa_id = entityFormatoAvaliacao.esa_idPorDisciplina
};
ACA_EscalaAvaliacaoBO.GetEntity(entityEscalaAvaliacao);
ACA_EscalaAvaliacao entityEscalaAvaliacaoDocente = new ACA_EscalaAvaliacao {
esa_id = entityFormatoAvaliacao.esa_idDocente
};
ACA_EscalaAvaliacaoBO.GetEntity(entityEscalaAvaliacaoDocente);
double notaMinimaAprovacao = 0;
int ordemParecerMinimo = 0;
// Valor do conceito global ou por disciplina.
string valorMinimo = tud_id > 0 ?
entityFormatoAvaliacao.valorMinimoAprovacaoPorDisciplina :
entityFormatoAvaliacao.valorMinimoAprovacaoConceitoGlobal;
if (entityEscalaAvaliacao.esa_tipo == (byte)EscalaAvaliacaoTipo.Numerica)
{
notaMinimaAprovacao = Convert.ToDouble(valorMinimo.Replace(',', '.'));
}
else if (entityEscalaAvaliacao.esa_tipo == (byte)EscalaAvaliacaoTipo.Pareceres)
{
ordemParecerMinimo = ACA_EscalaAvaliacaoParecerBO.RetornaOrdem_Parecer(entityEscalaAvaliacao.esa_id, valorMinimo, ApplicationWEB.AppMinutosCacheLongo);
}
bool incluirFinal = entityFormatoAvaliacao.fav_avaliacaoFinalAnalitica;
List <Struct_CalendarioPeriodos> tabelaPeriodos = ACA_CalendarioPeriodoBO.SelecionaPor_Calendario(cal_id, ApplicationWEB.AppMinutosCacheLongo);
List <ESC_EscolaCalendarioPeriodo> lstEscCalPeriodo = ESC_EscolaCalendarioPeriodoBO.SelectEscolasCalendarioCache(cal_id, ApplicationWEB.AppMinutosCacheCurto);
List <Struct_CalendarioPeriodos> listaCalendarioPeriodo = tabelaPeriodos.Where(calP => (lstEscCalPeriodo.Where(escP => (escP.esc_id == esc_id && escP.tpc_id == calP.tpc_id)).Count() == 0)).ToList();
int tpc_idUltimoPerido = tabelaPeriodos.Count > 0 ? tabelaPeriodos.Last().tpc_id : -1;
int tpc_ordemUltimoPeriodo = tabelaPeriodos.Count > 0 ? tabelaPeriodos.Last().tpc_ordem : 0;
//Busca o bimestre corrente
Struct_CalendarioPeriodos periodoCorrente = listaCalendarioPeriodo.Where(x => (x.cap_dataInicio.Date <= DateTime.Now.Date && x.cap_dataFim.Date >= DateTime.Now.Date)).FirstOrDefault();
int tpc_id = periodoCorrente.tpc_id;
int tpc_ordem = periodoCorrente.tpc_ordem;
}
}
/// <summary>
/// O método salva as observações para conselho pedagógico.
/// </summary>
/// <param name="tur_id">ID da turma.</param>
/// <param name="alu_id">ID do aluno.</param>
/// <param name="mtu_id">ID da matrícula turma do aluno.</param>
/// <param name="fav_id">ID do formato de avaliação.</param>
/// <param name="ava_id">ID da avaliação.</param>
/// <param name="ltObservacao">Lista de observações.</param>
/// <param name="banco">Banco</param>
/// <param name="ent_id">Id da entidade do usuário logado.</param>
/// <returns></returns>
public static bool SalvarObservacao
(
long tur_id,
long alu_id,
int mtu_id,
int fav_id,
int ava_id,
CLS_AlunoAvaliacaoTur_Observacao observacao,
Guid usu_idLogado,
byte resultado,
string justificativaResultado,
DateTime dataUltimaAlteracaoObservacao,
DateTime dataUltimaAlteracaoNotaFinal,
ACA_FormatoAvaliacao entFormatoAvaliacao,
List <CLS_AvaliacaoTurDisc_Cadastro> listaDisciplina,
List <MTR_MatriculaTurmaDisciplina> listaMatriculaTurmaDisciplina,
int tamanhoMaximoKB,
string[] TiposArquivosPermitidos,
ref List <CLS_AlunoAvaliacaoTurmaDisciplina> listaAtualizacaoEfetivacao,
Guid ent_id,
int tpc_id
)
{
TalkDBTransaction banco = new CLS_AlunoAvaliacaoTurmaObservacaoDAO()._Banco.CopyThisInstance();
banco.Open(IsolationLevel.ReadCommitted);
List <AlunoFechamentoPendencia> FilaProcessamento = new List <AlunoFechamentoPendencia>();
try
{
if (observacao.entityObservacao != null && observacao.entityObservacao != new CLS_AlunoAvaliacaoTurmaObservacao())
{
Save(observacao.entityObservacao, banco);
}
int tpc_idUtilizado = -1;
List <CLS_AvaliacaoTurDisc_Cadastro> listaDisciplinasUltimoPeriodo = new List <CLS_AvaliacaoTurDisc_Cadastro>();
listaDisciplinasUltimoPeriodo = listaDisciplina.Where(d => d.entity.ava_id != ava_id).ToList();
if (listaDisciplinasUltimoPeriodo.Count > 0)
{
tpc_idUtilizado = ACA_AvaliacaoBO.SelecionaMaiorBimestre_ByFormatoAvaliacao(entFormatoAvaliacao.fav_id, banco);
}
CLS_AlunoAvaliacaoTurmaDisciplinaBO.SaveAvaliacaoFinal(
tur_id
, entFormatoAvaliacao
, listaDisciplina
, tamanhoMaximoKB
, TiposArquivosPermitidos
, dataUltimaAlteracaoNotaFinal
, listaMatriculaTurmaDisciplina
, ref listaAtualizacaoEfetivacao
, banco);
tpc_idUtilizado = tpc_idUtilizado > 0 ? tpc_idUtilizado : tpc_id;
if (entFormatoAvaliacao.fav_fechamentoAutomatico && listaMatriculaTurmaDisciplina.Any())
{
FilaProcessamento.AddRange(listaMatriculaTurmaDisciplina
.Select(p => new AlunoFechamentoPendencia {
tud_id = p.tud_id,
tpc_id = tpc_idUtilizado,
afp_frequencia = true,
afp_nota = true,
afp_processado = (Byte)(p.mtd_id <= 0 ? 0 : 2)
}).ToList());
}
// Se for passado o resultado, salva na MTR_MatriculaTurma.
if (!usu_idLogado.Equals(Guid.Empty))
{
MTR_MatriculaTurma entMatr = new MTR_MatriculaTurma
{
alu_id = alu_id
,
mtu_id = mtu_id
};
MTR_MatriculaTurmaBO.GetEntity(entMatr, banco);
// Se o registro foi alterado depois da data da alteração mais recente no momento em que os dados foram carregados,
// interrompe o salvamento e alerta o usuário de que é necessário atualizar os dados
if (entMatr != null && !entMatr.IsNew && Convert.ToDateTime(entMatr.mtu_dataAlteracao.ToString()) > dataUltimaAlteracaoObservacao)
{
throw new ValidationException("Existe registro alterado mais recentemente, é necessário atualizar os dados.");
}
else
{
entMatr.usu_idResultado = usu_idLogado;
entMatr.mtu_resultado = resultado;
entMatr.mtu_relatorio = justificativaResultado;
MTR_MatriculaTurmaBO.Save(entMatr, banco);
if (ACA_ParametroAcademicoBO.ParametroValorBooleanoPorEntidade(eChaveAcademico.GERAR_HISTORICO_SALVAR_PARECER_CONCLUSIVO, ent_id))
{
ACA_AlunoHistoricoBO.GeracaoHistoricoPedagogicoPorAluno(entMatr.alu_id, entMatr.mtu_id, banco);
}
if (entFormatoAvaliacao.fav_fechamentoAutomatico)
{
FilaProcessamento.Add(new AlunoFechamentoPendencia {
tud_id = listaMatriculaTurmaDisciplina.FirstOrDefault().tud_id,
tpc_id = tpc_id,
afp_frequencia = true,
afp_nota = true,
afp_processado = (Byte)(entMatr.IsNew == true ? 0 : 2)
});
}
}
}
// Limpa cache do fechamento, para atualizar o check.
GestaoEscolarUtilBO.LimpaCache(MTR_MatriculaTurmaBO.RetornaChaveCache_GetSelectBy_Turma_Periodo(tur_id, fav_id, ava_id));
List <TUR_TurmaDisciplina> listaDisciplinas = TUR_TurmaDisciplinaBO.GetSelectBy_Turma(tur_id, null, GestaoEscolarUtilBO.MinutosCacheLongo);
listaDisciplinas.ForEach(p =>
{
GestaoEscolarUtilBO.LimpaCache(MTR_MatriculaTurmaDisciplinaBO.RetornaChaveCache_GetSelectBy_TurmaDisciplinaPeriodo(p.tud_id, fav_id, ava_id, string.Empty));
GestaoEscolarUtilBO.LimpaCache(MTR_MatriculaTurmaDisciplinaBO.RetornaChaveCache_GetSelectBy_TurmaDisciplinaPeriodoFiltroDeficiencia(p.tud_id, fav_id, ava_id, string.Empty));
// Chaves do fechamento automatico
string chave = string.Empty;
chave = String.Format(ModelCache.FECHAMENTO_AUTO_BIMESTRE_MODEL_KEY, p.tud_id, tpc_id);
CacheManager.Factory.RemoveByPattern(chave);
chave = String.Format(ModelCache.FECHAMENTO_AUTO_BIMESTRE_FILTRO_DEFICIENCIA_MODEL_KEY, p.tud_id, tpc_id);
CacheManager.Factory.RemoveByPattern(chave);
chave = String.Format(ModelCache.FECHAMENTO_AUTO_FINAL_MODEL_KEY, p.tud_id);
CacheManager.Factory.RemoveByPattern(chave);
chave = String.Format(ModelCache.FECHAMENTO_AUTO_FINAL_FILTRO_DEFICIENCIA_MODEL_KEY, p.tud_id);
CacheManager.Factory.RemoveByPattern(chave);
chave = String.Format(ModelCache.FECHAMENTO_AUTO_BIMESTRE_COMPONENTES_REGENCIA_MODEL_KEY, tur_id, tpc_id);
CacheManager.Factory.RemoveByPattern(chave);
chave = String.Format(ModelCache.FECHAMENTO_AUTO_FINAL_COMPONENTES_REGENCIA_MODEL_KEY, tur_id, tpc_id);
CacheManager.Factory.RemoveByPattern(chave);
//
});
if (entFormatoAvaliacao.fav_fechamentoAutomatico && FilaProcessamento.Any(a => a.tpc_id > 0))
{
CLS_AlunoFechamentoPendenciaBO.SalvarFilaPendencias(
FilaProcessamento
.GroupBy(g => new { g.tud_id, g.tpc_id })
.Select(p => new AlunoFechamentoPendencia {
tud_id = p.FirstOrDefault().tud_id,
tpc_id = p.FirstOrDefault().tpc_id,
afp_frequencia = p.FirstOrDefault().afp_frequencia,
afp_nota = p.FirstOrDefault().afp_nota,
afp_processado = FilaProcessamento
.Where(w => w.tud_id == p.FirstOrDefault().tud_id&& w.tpc_id == p.FirstOrDefault().tpc_id)
.Min(m => m.afp_processado)
})
.Where(w => w.tpc_id > 0 && w.tpc_id != ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, ent_id))
.ToList()
, banco);
}
return(true);
}
catch (ValidationException ex)
{
banco.Close(ex);
throw;
}
catch (Exception ex)
{
banco.Close(ex);
throw;
}
finally
{
if (banco.ConnectionIsOpen)
{
banco.Close();
}
}
}
/// <summary>
/// Carregar os períodos e seta a visibilidade dos botões de acordo com a permissão do usuário.
/// </summary>
public void CarregarPeriodos
(
List <sPermissaoDocente> VS_ltPermissaoFrequencia
, List <sPermissaoDocente> VS_ltPermissaoEfetivacao
, List <sPermissaoDocente> VS_ltPermissaoPlanejamentoAnual
, List <sPermissaoDocente> VS_ltPermissaoAvaliacao
, TUR_TurmaDisciplina VS_turmaDisciplinaRelacionada
, int esc_id
, byte tud_tipo
, byte tdt_posicao = 0
, Int64 tur_id = -1
, Int64 tud_id = -1
, bool incluirPeriodoRecesso = false
, int tpcIdPendencia = -1
)
{
// Habilita a visibilidade dos botões alunos e voltar
VisibleAlunos = !ACA_ParametroAcademicoBO.ParametroValorBooleanoPorEntidade(eChaveAcademico.MINHAS_TURMAS_ESCONDER_BOTAO_ALUNO, __SessionWEB.__UsuarioWEB.Usuario.ent_id);
VisibleVoltar = !ACA_ParametroAcademicoBO.ParametroValorBooleanoPorEntidade(eChaveAcademico.MINHAS_TURMAS_ESCONDER_BOTAO_VOLTAR, __SessionWEB.__UsuarioWEB.Usuario.ent_id);
int fav_id = -1;
if (tur_id > 0 && tud_id > 0 && ACA_ParametroAcademicoBO.ParametroValorBooleanoPorEntidade(eChaveAcademico.PRE_CARREGAR_CACHE_EFETIVACAO, __SessionWEB.__UsuarioWEB.Usuario.ent_id))
{
TUR_Turma entityTurma = new TUR_Turma {
tur_id = tur_id
};
TUR_TurmaBO.GetEntity(entityTurma);
ACA_FormatoAvaliacao entityFormato = new ACA_FormatoAvaliacao {
fav_id = entityTurma.fav_id
};
ACA_FormatoAvaliacaoBO.GetEntity(entityFormato);
ACA_EscalaAvaliacao entityEscala = new ACA_EscalaAvaliacao {
esa_id = entityFormato.esa_idPorDisciplina
};
ACA_EscalaAvaliacaoBO.GetEntity(entityEscala);
ACA_EscalaAvaliacao entityEscalaDocente = new ACA_EscalaAvaliacao {
esa_id = entityFormato.esa_idDocente
};
ACA_EscalaAvaliacaoBO.GetEntity(entityEscalaDocente);
TUR_TurmaDisciplina entityTurmaDisciplina = new TUR_TurmaDisciplina {
tud_id = tud_id
};
TUR_TurmaDisciplinaBO.GetEntity(entityTurmaDisciplina);
// Valor do conceito global ou por disciplina.
string valorMinimo = tud_id > 0 ?
entityFormato.valorMinimoAprovacaoPorDisciplina :
entityFormato.valorMinimoAprovacaoConceitoGlobal;
double notaMinimaAprovacao = 0;
int ordemParecerMinimo = 0;
EscalaAvaliacaoTipo tipoEscala = (EscalaAvaliacaoTipo)entityEscala.esa_tipo;
if (tipoEscala == EscalaAvaliacaoTipo.Numerica)
{
notaMinimaAprovacao = Convert.ToDouble(valorMinimo.Replace(',', '.'));
}
else if (tipoEscala == EscalaAvaliacaoTipo.Pareceres)
{
ordemParecerMinimo = ACA_EscalaAvaliacaoParecerBO.RetornaOrdem_Parecer(entityEscala.esa_id, valorMinimo, ApplicationWEB.AppMinutosCacheLongo);
}
hdnTudId.Value = tud_id.ToString();
hdnTurId.Value = entityTurma.tur_id.ToString();
hdnFavId.Value = entityTurma.fav_id.ToString();
hdnEsaId.Value = entityEscala.esa_id.ToString();
hdnTipoEscala.Value = entityEscala.esa_tipo.ToString();
hdnTipoEscalaDocente.Value = entityEscalaDocente.esa_tipo.ToString();
hdnNotaMinima.Value = notaMinimaAprovacao.ToString();
hdnParecerMinimo.Value = ordemParecerMinimo.ToString();
hdnTipoLancamento.Value = entityFormato.fav_tipoLancamentoFrequencia.ToString();
hdnCalculoQtAulasDadas.Value = entityFormato.fav_calculoQtdeAulasDadas.ToString();
hdnTurTipo.Value = entityTurma.tur_tipo.ToString();
hdnCalId.Value = entityTurma.cal_id.ToString();
hdnTudTipo.Value = entityTurmaDisciplina.tud_tipo.ToString();
hdnVariacao.Value = entityFormato.fav_variacao.ToString();
hdnTipoDocente.Value = (__SessionWEB.__UsuarioWEB.Docente.doc_id > 0 ?
(byte)ACA_TipoDocenteBO.SelecionaTipoDocentePorPosicao(tdt_posicao, ApplicationWEB.AppMinutosCacheLongo) : (byte)0).ToString();
hdnDisciplinaEspecial.Value = entityTurmaDisciplina.tud_disciplinaEspecial ? "true" : "false";
hdnFechamentoAutomatico.Value = entityFormato.fav_fechamentoAutomatico ? "true" : "false";
hdnProcessarFilaFechamentoTela.Value = ACA_ParametroAcademicoBO.ParametroValorBooleanoPorEntidade(eChaveAcademico.PROCESSAR_FILA_FECHAMENTO_TELA, __SessionWEB.__UsuarioWEB.Usuario.ent_id) ? "true" : "false";
fav_id = entityFormato.fav_id;
}
if (ACA_ParametroAcademicoBO.ParametroValorBooleanoPorEntidade(eChaveAcademico.TELA_UNICA_LANCAMENTO_FREQUENCIA_AVALIACAO, __SessionWEB.__UsuarioWEB.Usuario.ent_id))
{
VisibleListao = VS_ltPermissaoFrequencia.Any(p => p.pdc_permissaoConsulta) || VS_ltPermissaoAvaliacao.Any(p => p.pdc_permissaoConsulta);
btnFrequencia.Visible = btnAvaliacao.Visible = false;
}
else
{
VisibleListao = false;
btnFrequencia.Visible = VS_ltPermissaoFrequencia.Any(p => p.pdc_permissaoConsulta);
btnAvaliacao.Visible = VS_ltPermissaoAvaliacao.Any(p => p.pdc_permissaoConsulta);
}
VisibleEfetivacao = tud_tipo != (byte)ACA_CurriculoDisciplinaTipo.DocenciaCompartilhada &&
VS_ltPermissaoEfetivacao.Any(p => p.pdc_permissaoConsulta) &&
!ACA_ParametroAcademicoBO.ParametroValorBooleanoPorEntidade(eChaveAcademico.MINHAS_TURMAS_ESCONDER_BOTAO_EFETIVACAO, __SessionWEB.__UsuarioWEB.Usuario.ent_id);
VisiblePlanejamentoAnual = tud_tipo == (byte)ACA_CurriculoDisciplinaTipo.DocenciaCompartilhada ?
VS_turmaDisciplinaRelacionada != null && VS_turmaDisciplinaRelacionada.tud_naoLancarPlanejamento == false
: VS_ltPermissaoPlanejamentoAnual.Any(p => p.pdc_permissaoConsulta);
List <Struct_CalendarioPeriodos> lstCalendarioPeriodos = ACA_CalendarioPeriodoBO.SelecionaPor_Calendario(VS_cal_id, ApplicationWEB.AppMinutosCacheLongo, false, __SessionWEB.__UsuarioWEB.Usuario.ent_id);
if (incluirPeriodoRecesso)
{
VS_CalendarioPeriodo = lstCalendarioPeriodos;
}
else
{
VS_CalendarioPeriodo = lstCalendarioPeriodos.FindAll(p => p.tpc_id != ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, __SessionWEB.__UsuarioWEB.Usuario.ent_id));
// Se o período selecionado for de recesso,
// seleciono o bimestre anterior.
if (VS_tpc_id == ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, __SessionWEB.__UsuarioWEB.Usuario.ent_id))
{
int indiceRecesso = lstCalendarioPeriodos.FindIndex(p => p.tpc_id == VS_tpc_id);
if (indiceRecesso > 0)
{
Struct_CalendarioPeriodos periodo = lstCalendarioPeriodos[indiceRecesso - 1];
VS_tpc_id = periodo.tpc_id;
VS_tpc_ordem = periodo.tpc_ordem;
}
}
}
VS_cal_ano = VS_CalendarioPeriodo.Find(p => p.cal_id == VS_cal_id).cal_ano;
List <ESC_EscolaCalendarioPeriodo> lstEscCalPeriodo = ESC_EscolaCalendarioPeriodoBO.SelectEscolasCalendarioCache(VS_cal_id, ApplicationWEB.AppMinutosCacheCurto);
VS_CalendarioPeriodo = VS_CalendarioPeriodo.Where(calP => (lstEscCalPeriodo.Where(escP => (escP.esc_id == esc_id && escP.tpc_id == calP.tpc_id)).Count() == 0)).ToList();
if (VS_IncluirPeriodoFinal)
{
Struct_CalendarioPeriodos[] calendarioPeriodosCopy = new Struct_CalendarioPeriodos[VS_CalendarioPeriodo.Count() + 1];
VS_CalendarioPeriodo.CopyTo(calendarioPeriodosCopy, 0);
Struct_CalendarioPeriodos periodoFinal = new Struct_CalendarioPeriodos();
periodoFinal.cap_descricao = periodoFinal.tpc_nomeAbreviado = GetGlobalResourceObject("UserControl", "NavegacaoTelaPeriodo.UCNavegacaoTelaPeriodo.PeriodoFinal").ToString();
periodoFinal.tpc_id = -1;
calendarioPeriodosCopy[VS_CalendarioPeriodo.Count()] = periodoFinal;
rptPeriodo.DataSource = calendarioPeriodosCopy;
}
else
{
rptPeriodo.DataSource = VS_CalendarioPeriodo;
}
if (fav_id > 0)
{
string tpc_id = string.Join(",", VS_CalendarioPeriodo.Select(p => p.tpc_id.ToString()).ToArray());
ltAvaliacao = ACA_AvaliacaoBO.ConsultaPor_Periodo_Relacionadas(fav_id, tpc_id, ApplicationWEB.AppMinutosCacheLongo);
if (VS_IncluirPeriodoFinal)
{
ltAvaliacao.AddRange(ACA_AvaliacaoBO.SelectAvaliacaoFinal_PorFormato(fav_id, ApplicationWEB.AppMinutosCacheLongo));
}
}
rptPeriodo.DataBind();
//Seleciona o ultimo bimestre
List <Struct_CalendarioPeriodos> tabelaPeriodos = ACA_CalendarioPeriodoBO.SelecionaPor_Calendario(VS_cal_id, ApplicationWEB.AppMinutosCacheLongo);
int tpc_idUltimoPeriodo = tabelaPeriodos.Count > 0 ? tabelaPeriodos.Last().tpc_id : -1;
int tpc_ordemUltimoPeriodo = tabelaPeriodos.Count > 0 ? tabelaPeriodos.Last().tpc_ordem : 0;
if (tpcIdPendencia > 0)
{
//Busca o bimestre pendente
Struct_CalendarioPeriodos periodo = VS_CalendarioPeriodo.Where(x => x.tpc_id == tpcIdPendencia).FirstOrDefault();
VS_tpc_id = periodo.tpc_id;
VS_tpc_ordem = periodo.tpc_ordem;
}
if (VS_tpc_id <= 0 && !VS_IncluirPeriodoFinal)
{
//Busca o bimestre corrente
Struct_CalendarioPeriodos periodo = VS_CalendarioPeriodo.Where(x => (x.cap_dataInicio.Date <= DateTime.Now.Date && x.cap_dataFim.Date >= DateTime.Now.Date)).FirstOrDefault();
VS_tpc_id = periodo.tpc_id;
VS_tpc_ordem = periodo.tpc_ordem;
if (VS_tpc_id <= 0)
{
//Se não tem bimestre selecionado e nem bimestre corrente então seleciona o próximo corrente
periodo = VS_CalendarioPeriodo.Where(x => (x.cap_dataInicio.Date >= DateTime.Now.Date)).FirstOrDefault();
VS_tpc_id = periodo.tpc_id;
VS_tpc_ordem = periodo.tpc_ordem;
if (VS_tpc_id <= 0)
{
//Se não tem bimestre selecionado então seleciona o ultimo
VS_tpc_id = tpc_idUltimoPeriodo;
VS_tpc_ordem = tpc_ordemUltimoPeriodo;
}
}
}
if (VS_tpc_id >= 0 && VS_IncluirPeriodoFinal)
{
if (VS_tpc_id == tpc_idUltimoPeriodo)
{
// Se for o ultimo periodo e a avaliacao final estiver aberta,
// selecionar a avaliacao final
List <ACA_Evento> listaEventos = ACA_EventoBO.GetEntity_Efetivacao_List(VS_cal_id, tur_id, __SessionWEB.__UsuarioWEB.Grupo.gru_id, __SessionWEB.__UsuarioWEB.Usuario.ent_id, ApplicationWEB.AppMinutosCacheLongo, true, __SessionWEB.__UsuarioWEB.Docente.doc_id);
if (listaEventos.Exists(p => p.tev_id == ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_EVENTO_EFETIVACAO_FINAL, __SessionWEB.__UsuarioWEB.Usuario.ent_id)))
{
VS_tpc_id = -1;
VS_tpc_ordem = 0;
}
}
if (VS_tpc_id == 0)
{
//Se não tem bimestre selecionado e nem bimestre corrente então seleciona o próximo corrente
Struct_CalendarioPeriodos periodo = VS_CalendarioPeriodo.Where(x => (x.cap_dataInicio.Date >= DateTime.Now.Date)).FirstOrDefault();
VS_tpc_id = periodo.tpc_id;
VS_tpc_ordem = periodo.tpc_ordem;
if (VS_tpc_id <= 0)
{
//Se não tem bimestre selecionado então seleciona o final
VS_tpc_id = -1;
VS_tpc_ordem = 0;
}
}
}
if (VS_tpc_ordem < 0)
{
VS_tpc_ordem = 0;
}
// Seleciona o botão do bimestre informado (VS_tpc_id)
rptPeriodo.Items.Cast <RepeaterItem>().ToList()
.Select(p => (Button)p.FindControl("btnPeriodo"))
.ToList().ForEach(p => RemoveClass(p, "periodo_selecionado"));
rptPeriodo.Items.Cast <RepeaterItem>().ToList()
.Where(p => Convert.ToInt32(((HiddenField)p.FindControl("hdnPeriodo")).Value) == VS_tpc_id &&
Convert.ToInt32(((HiddenField)p.FindControl("hdnPeriodoOrdem")).Value) == VS_tpc_ordem)
.Select(p => (Button)p.FindControl("btnPeriodo"))
.ToList()
.ForEach
(
p =>
{
AddClass(p, "periodo_selecionado");
HiddenField hdn = (HiddenField)p.FindControl("hdnIdAvaliacao");
if (!string.IsNullOrEmpty(hdn.Value))
{
hdnAvaId.Value = hdn.Value;
}
hdn = (HiddenField)p.FindControl("hdnAvaliacaoTipo");
if (!string.IsNullOrEmpty(hdn.Value))
{
hdnTipoAvaliacao.Value = hdn.Value;
}
hdnTpcId.Value = VS_tpc_id.ToString();
hdn = (HiddenField)p.FindControl("hdnPeriodoOrdem");
if (!string.IsNullOrEmpty(hdn.Value))
{
hdnTpcOrdem.Value = hdn.Value;
}
}
);
}
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>
/// Salva as entidades turmaAula e TurmaAulaAluno nas listas - com transação.
/// </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>
/// <param name="banco">Transação com banco de dados aberta</param>
/// <returns></returns>
internal static bool Save
(
List <CLS_TurmaAulaAluno> listTurmaAulaAluno
, List <CLS_TurmaAula> listTurmaAula
, long tur_id
, long tud_id
, byte tdt_posicao
, TUR_Turma entityTurma
, ACA_FormatoAvaliacao entityFormatoAvaliacao
, ACA_CurriculoPeriodo entityCurriculoPeriodo
, TalkDBTransaction banco
, Guid usu_id = new Guid()
, byte origemLogAula = 0
, byte tipoLogAula = 0
, Guid ent_id = new Guid()
)
{
string tau_ids = string.Join(",",
(from CLS_TurmaAula item in listTurmaAula select item.tau_id.ToString()).
ToArray());
// Recupera a lista de entidades CLS_TurmaAulaAluno para verificar se ela já existe.
List <CLS_TurmaAulaAluno> listaTurmaAulaAluno = new CLS_TurmaAulaAlunoDAO {
_Banco = banco
}
.SelectBy_Disciplina_Aulas(tud_id, tau_ids);
DataTable dtTurmaAulaAluno = CLS_TurmaAulaAluno.TipoTabela_TurmaAulaAluno();
List <LOG_TurmaAula_Alteracao> listLogAula = new List <LOG_TurmaAula_Alteracao>();
object lockObject = new object();
Parallel.ForEach
(
listTurmaAulaAluno,
entityTurmaAulaAluno =>
{
// Busca se a entidade já existe na lista.
CLS_TurmaAulaAluno entAux =
listaTurmaAulaAluno.Find(p =>
p.tud_id == entityTurmaAulaAluno.tud_id &&
p.tau_id == entityTurmaAulaAluno.tau_id &&
p.alu_id == entityTurmaAulaAluno.alu_id &&
p.mtu_id == entityTurmaAulaAluno.mtu_id &&
p.mtd_id == entityTurmaAulaAluno.mtd_id
);
if (entAux != null)
{
entityTurmaAulaAluno.IsNew = entAux.IsNew;
entityTurmaAulaAluno.taa_anotacao = entAux.taa_anotacao;
entityTurmaAulaAluno.usu_idDocenteAlteracao = entAux.usu_idDocenteAlteracao;
}
Validate(entityTurmaAulaAluno, listTurmaAula);
if (entityTurmaAulaAluno.Validate())
{
lock (lockObject)
{
DataRow dr = dtTurmaAulaAluno.NewRow();
dtTurmaAulaAluno.Rows.Add(TurmaAulaAlunoToDataRow(entityTurmaAulaAluno, dr));
}
}
else
{
throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entityTurmaAulaAluno));
}
}
);
// Salva os dados de todos os alunos na tabela CLS_TurmaAulaAluno
SalvaFrequenciaAlunos(dtTurmaAulaAluno, banco);
// Verifica se a entidade recebida por parâmetro foi alimentada, se não foi, dá o GetEntity.
TUR_Turma turma = entityTurma ?? TUR_TurmaBO.GetEntity(new TUR_Turma {
tur_id = tur_id
}, banco);
ACA_FormatoAvaliacao formatoAvaliacao = entityFormatoAvaliacao ?? ACA_FormatoAvaliacaoBO.GetEntity(new ACA_FormatoAvaliacao {
fav_id = turma.fav_id
}, banco);
ACA_CurriculoPeriodo entityCrp = entityCurriculoPeriodo ?? ACA_CurriculoPeriodoBO.SelecionaPorTurmaTipoNormal(turma.tur_id, GestaoEscolarUtilBO.MinutosCacheLongo);
List <TUR_TurmaDisciplina> listaDisciplinas = TUR_TurmaDisciplinaBO.GetSelectBy_Turma(tur_id, banco, GestaoEscolarUtilBO.MinutosCacheLongo);
TUR_TurmaDisciplina entDisciplinarincipal =
listaDisciplinas.Find(p => p.tud_tipo == (byte)TurmaDisciplinaTipo.DisciplinaPrincipal);
// Se não for para lançar na disciplina global, e a turma possuir uma disc. principal,
// só poderá salvar na disciplina principal.
bool validarDiscPrincipal =
(!(turma.tur_docenteEspecialista && formatoAvaliacao.fav_planejamentoAulasNotasConjunto)) &&
(entDisciplinarincipal != null) && (formatoAvaliacao.fav_tipoApuracaoFrequencia != (byte)ACA_FormatoAvaliacaoTipoApuracaoFrequencia.Dia &&
entityCrp.crp_controleTempo != (byte)ACA_CurriculoPeriodoControleTempo.Horas);
DateTime dataLogAula = DateTime.Now;
foreach (CLS_TurmaAula entityTurmaAula in listTurmaAula)
{
// Se for pra validar a disc. principal, só pode lançar frequência nela.
if (validarDiscPrincipal && (entDisciplinarincipal.tud_id != entityTurmaAula.tud_id))
{
throw new ValidationException("A frequência dessa turma só pode ser lançada para o(a) " + CustomResource.GetGlobalResourceObject("Mensagens", "MSG_DISCIPLINA") + entDisciplinarincipal.tud_nome + ".");
}
if (origemLogAula > 0)
{
LOG_TurmaAula_Alteracao entLogAula = new LOG_TurmaAula_Alteracao
{
tud_id = entityTurmaAula.tud_id,
tau_id = entityTurmaAula.tau_id,
usu_id = usu_id,
lta_origem = origemLogAula,
lta_tipo = tipoLogAula,
lta_data = dataLogAula
};
listLogAula.Add(entLogAula);
}
}
//Salva os logs de alteração de aula
LOG_TurmaAula_AlteracaoBO.SalvarEmLote(listLogAula, banco);
// Atualiza o campo efetivado da aula.
CLS_TurmaAulaBO.AtualizarEfetivado(listTurmaAula, banco);
// Caso o fechamento seja automático, grava na fila de processamento.
if (formatoAvaliacao.fav_fechamentoAutomatico && listTurmaAula.Count > 0 && listTurmaAula[0].tpc_id != ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, ent_id))
{
CLS_AlunoFechamentoPendenciaBO.SalvarFilaFrequencia(tud_id, listTurmaAula[0].tpc_id, banco);
}
if (listTurmaAula.Any() && dtTurmaAulaAluno.Rows.Count > 0 && HttpContext.Current != null)
{
// Limpa o cache do fechamento
try
{
string chave = string.Empty;
int tpc_id = listTurmaAula[0].tpc_id;
List <ACA_Avaliacao> avaliacao = ACA_AvaliacaoBO.GetSelectBy_FormatoAvaliacaoPeriodo(turma.fav_id, tpc_id);
if (avaliacao.Any())
{
int ava_id = avaliacao.First().ava_id;
if (tud_id > 0)
{
chave = MTR_MatriculaTurmaDisciplinaBO.RetornaChaveCache_GetSelectBy_TurmaDisciplinaPeriodo(tud_id, turma.fav_id, ava_id, string.Empty);
CacheManager.Factory.RemoveByPattern(chave);
chave = MTR_MatriculaTurmaDisciplinaBO.RetornaChaveCache_GetSelectBy_TurmaDisciplinaPeriodoFiltroDeficiencia(tud_id, turma.fav_id, ava_id, string.Empty);
CacheManager.Factory.RemoveByPattern(chave);
}
else
{
chave = MTR_MatriculaTurmaBO.RetornaChaveCache_GetSelectBy_Turma_Periodo(tur_id, turma.fav_id, ava_id);
HttpContext.Current.Cache.Remove(chave);
}
}
}
catch
{ }
}
return(true);
}
/// <summary>
/// O método salva as observações para conselho pedagógico.
/// </summary>
/// <param name="tur_id">ID da turma.</param>
/// <param name="alu_id">ID do aluno.</param>
/// <param name="mtu_id">ID da matrícula turma do aluno.</param>
/// <param name="fav_id">ID do formato de avaliação.</param>
/// <param name="ava_id">ID da avaliação.</param>
/// <param name="ltObservacao">Lista de observações.</param>
/// <param name="banco">Banco</param>
/// <param name="ent_id">Id da entidade do usuário logado.</param>
/// <returns></returns>
public static bool SalvarObservacao
(
long tur_id,
long alu_id,
int mtu_id,
long[] tud_ids,
List <CLS_AlunoAvaliacaoTurmaObservacao> listaObservacao,
List <CLS_AlunoAvaliacaoTurma> listaAlunoAvaliacaoTurma,
List <CLS_AlunoAvaliacaoTurmaDisciplina> listaAlunoAvaliacaoTurmaDisciplina,
List <ACA_AlunoAnotacao> listaAlunoAnotacao,
bool permiteEditarResultadoFinal,
Guid usu_idLogado,
byte resultado,
DateTime dataUltimaAlteracaoObservacao,
DateTime dataUltimaAlteracaoNotaFinal,
ACA_FormatoAvaliacao entFormatoAvaliacao,
List <CLS_AvaliacaoTurDisc_Cadastro> listaDisciplina,
List <MTR_MatriculaTurmaDisciplina> listaMatriculaTurmaDisciplina,
int tamanhoMaximoKB,
string[] TiposArquivosPermitidos,
ref List <CLS_AlunoAvaliacaoTurmaDisciplina> listaAtualizacaoEfetivacao,
Guid ent_id,
IDictionary <int, int> dicAvaTpc,
List <CLS_AlunoAvaliacaoTurmaObservacaoBO.DadosAlunoObservacao> listaDadosPeriodo
)
{
TalkDBTransaction banco = new CLS_AlunoAvaliacaoTurmaObservacaoDAO()._Banco.CopyThisInstance();
banco.Open(IsolationLevel.ReadCommitted);
List <AlunoFechamentoPendencia> FilaProcessamento = new List <AlunoFechamentoPendencia>();
int tpc_idUltimoPeriodo = (dicAvaTpc.Count() > 0 ? dicAvaTpc.Max(p => p.Value) : 0);
try
{
foreach (CLS_AlunoAvaliacaoTurmaObservacao observacao in listaObservacao)
{
observacao.usu_idAlteracao = usu_idLogado;
Save(observacao, banco);
}
foreach (CLS_AlunoAvaliacaoTurma alunoAvaliacaoTurma in listaAlunoAvaliacaoTurma)
{
CLS_AlunoAvaliacaoTurmaBO.Save(alunoAvaliacaoTurma, banco);
}
object lockObject = new object();
DataTable dtAlunoAvaliacaoTurmaDisciplina = CLS_AlunoAvaliacaoTurmaDisciplina.TipoTabela_AlunoAvaliacaoTurmaDisciplina();
if (listaAlunoAvaliacaoTurmaDisciplina.Any())
{
Parallel.ForEach
(
listaAlunoAvaliacaoTurmaDisciplina,
alunoAvaliacaoTurmaDisciplina =>
{
lock (lockObject)
{
DataRow drAlunoAvaliacaoTurmaDisciplina = dtAlunoAvaliacaoTurmaDisciplina.NewRow();
dtAlunoAvaliacaoTurmaDisciplina.Rows.Add(
CLS_AlunoAvaliacaoTurmaDisciplinaBO.EntityToDataRow(alunoAvaliacaoTurmaDisciplina, drAlunoAvaliacaoTurmaDisciplina));
}
}
);
}
if (dtAlunoAvaliacaoTurmaDisciplina.Rows.Count > 0)
{
CLS_AlunoAvaliacaoTurmaDisciplinaBO.SalvarEmLotePosConselho(dtAlunoAvaliacaoTurmaDisciplina, banco);
if (entFormatoAvaliacao.fav_fechamentoAutomatico && listaAlunoAvaliacaoTurmaDisciplina.Any())
{
FilaProcessamento.AddRange(listaAlunoAvaliacaoTurmaDisciplina
.Select(p => new AlunoFechamentoPendencia {
tud_id = p.tud_id,
tpc_id = (p.tpc_id > 0 ? p.tpc_id : tpc_idUltimoPeriodo),
afp_frequencia = true,
afp_nota = true,
afp_processado = (Byte)(p.atd_id <= 0 ? 0 : 2)
}).ToList());
}
}
foreach (ACA_AlunoAnotacao alunoAnotacao in listaAlunoAnotacao)
{
ACA_AlunoAnotacaoBO.Save(alunoAnotacao, banco);
}
CLS_AlunoAvaliacaoTurmaDisciplinaBO.SaveAvaliacaoFinal(
tur_id
, entFormatoAvaliacao
, listaDisciplina
, tamanhoMaximoKB
, TiposArquivosPermitidos
, dataUltimaAlteracaoNotaFinal
, listaMatriculaTurmaDisciplina
, ref listaAtualizacaoEfetivacao
, banco);
if (entFormatoAvaliacao.fav_fechamentoAutomatico && listaMatriculaTurmaDisciplina.Any() && (tpc_idUltimoPeriodo > 0))
{
FilaProcessamento.AddRange(listaMatriculaTurmaDisciplina
.Select(p => new AlunoFechamentoPendencia {
tud_id = p.tud_id,
tpc_id = tpc_idUltimoPeriodo,
afp_frequencia = true,
afp_nota = true,
afp_processado = (Byte)(p.mtd_id <= 0 ? 0 : 2)
}).ToList());
}
if (permiteEditarResultadoFinal)
{
// Se for passado o resultado, salva na MTR_MatriculaTurma.
MTR_MatriculaTurma entMatr = new MTR_MatriculaTurma
{
alu_id = alu_id
,
mtu_id = mtu_id
};
MTR_MatriculaTurmaBO.GetEntity(entMatr, banco);
// So registra a alteracao do parecer conclusivo (resultado)
// se for um registro novo e tem valor selecionado, ou se houve alteracao do valor.
if ((entMatr.IsNew && entMatr.mtu_resultado > 0) || entMatr.mtu_resultado != resultado)
{
// Se o registro foi alterado depois da data da alteração mais recente no momento em que os dados foram carregados,
// interrompe o salvamento e alerta o usuário de que é necessário atualizar os dados
if (entMatr != null && !entMatr.IsNew && Convert.ToDateTime(entMatr.mtu_dataAlteracao.ToString()) > dataUltimaAlteracaoObservacao)
{
throw new ValidationException("Existe registro alterado mais recentemente, é necessário atualizar os dados.");
}
else
{
entMatr.usu_idResultado = usu_idLogado;
entMatr.mtu_resultado = resultado;
MTR_MatriculaTurmaBO.Save(entMatr, banco);
if (ACA_ParametroAcademicoBO.ParametroValorBooleanoPorEntidade(eChaveAcademico.GERAR_HISTORICO_SALVAR_PARECER_CONCLUSIVO, ent_id))
{
ACA_AlunoHistoricoBO.GeracaoHistoricoPedagogicoPorAluno(entMatr.alu_id, entMatr.mtu_id, banco);
}
if (entFormatoAvaliacao.fav_fechamentoAutomatico)
{
FilaProcessamento.Add(new AlunoFechamentoPendencia {
tud_id = tud_ids.FirstOrDefault(),
tpc_id = tpc_idUltimoPeriodo,
afp_frequencia = true,
afp_nota = true,
afp_processado = (Byte)(entMatr.IsNew == true ? 0 : 2)
});
}
}
}
}
// Limpa cache do fechamento, para atualizar o check, as notas pos-conselho, o parecer e a sintese final.
string chave = string.Empty;
int tpcId = -1;
listaDadosPeriodo.ForEach(q =>
{
// Fechamento de bimestre
chave = MTR_MatriculaTurmaBO.RetornaChaveCache_GetSelectBy_Turma_Periodo(tur_id, entFormatoAvaliacao.fav_id, q.ava_id);
if (HttpContext.Current != null)
{
HttpContext.Current.Cache.Remove(chave);
}
chave = MTR_MatriculaTurmaDisciplinaBO.RetornaChaveCache_GetSelect_ComponentesRegencia_By_TurmaFormato(tur_id, entFormatoAvaliacao.fav_id, q.ava_id);
CacheManager.Factory.Remove(chave);
// Fechamento final
chave = MTR_MatriculaTurmaBO.RetornaChaveCache_GetSelectBy_Turma_Final(tur_id, entFormatoAvaliacao.fav_id, q.ava_id);
if (HttpContext.Current != null)
{
HttpContext.Current.Cache.Remove(chave);
}
chave = MTR_MatriculaTurmaDisciplinaBO.RetornaChaveCache_GetSelect_ComponentesRegencia_By_TurmaFormato_Final(tur_id, entFormatoAvaliacao.fav_id, q.ava_id);
CacheManager.Factory.Remove(chave);
// Fechamento automatico de bimestre
if (dicAvaTpc.TryGetValue(q.ava_id, out tpcId))
{
chave = String.Format(ModelCache.FECHAMENTO_AUTO_BIMESTRE_COMPONENTES_REGENCIA_MODEL_KEY, tur_id, tpcId);
CacheManager.Factory.Remove(chave);
}
// Fechamento automatico final
chave = String.Format(ModelCache.FECHAMENTO_AUTO_FINAL_COMPONENTES_REGENCIA_MODEL_KEY, tur_id);
CacheManager.Factory.Remove(chave);
});
List <TUR_TurmaDisciplina> listaDisciplinas = TUR_TurmaDisciplinaBO.GetSelectBy_Turma(tur_id, null, GestaoEscolarUtilBO.MinutosCacheLongo);
listaDisciplinas.ForEach(p =>
{
// Fechamento de bimestre
chave = String.Format("{0}_{1}_{2}", ModelCache.FECHAMENTO_BIMESTRE_PATTERN_KEY, p.tud_id, entFormatoAvaliacao.fav_id);
CacheManager.Factory.RemoveByPattern(chave);
chave = String.Format("{0}_{1}_{2}", ModelCache.FECHAMENTO_BIMESTRE_FILTRO_DEFICIENCIA_PATTERN_KEY, p.tud_id, entFormatoAvaliacao.fav_id);
CacheManager.Factory.RemoveByPattern(chave);
// Fechamento final
chave = String.Format("{0}_{1}_{2}", ModelCache.FECHAMENTO_FINAL_PATTERN_KEY, p.tud_id, entFormatoAvaliacao.fav_id);
CacheManager.Factory.RemoveByPattern(chave);
chave = String.Format("{0}_{1}_{2}", ModelCache.FECHAMENTO_FINAL_FILTRO_DEFICIENCIA_PATTERN_KEY, p.tud_id, entFormatoAvaliacao.fav_id);
CacheManager.Factory.RemoveByPattern(chave);
// Fechamento automatico final
chave = String.Format(ModelCache.FECHAMENTO_AUTO_FINAL_MODEL_KEY, p.tud_id);
CacheManager.Factory.Remove(chave);
chave = String.Format(ModelCache.FECHAMENTO_AUTO_FINAL_FILTRO_DEFICIENCIA_MODEL_KEY, p.tud_id);
CacheManager.Factory.Remove(chave);
listaDadosPeriodo.ForEach(q =>
{
// Fechamento automatico de bimestre
if (dicAvaTpc.TryGetValue(q.ava_id, out tpcId))
{
chave = String.Format(ModelCache.FECHAMENTO_AUTO_BIMESTRE_MODEL_KEY, p.tud_id, tpcId);
CacheManager.Factory.Remove(chave);
chave = String.Format(ModelCache.FECHAMENTO_AUTO_BIMESTRE_FILTRO_DEFICIENCIA_MODEL_KEY, p.tud_id, tpcId);
CacheManager.Factory.Remove(chave);
}
});
});
//
//Adiciona tuds para processamento de pendência de notas (quando salva o parecer final
foreach (long tud in tud_ids.Where(t => !FilaProcessamento.Any(f => f.tud_id == t)))
{
FilaProcessamento.Add(new AlunoFechamentoPendencia
{
tud_id = tud,
tpc_id = tpc_idUltimoPeriodo,
afp_frequencia = false,
afp_frequenciaExterna = false,
afp_nota = true,
afp_processado = (byte)2
});
}
if (entFormatoAvaliacao.fav_fechamentoAutomatico && FilaProcessamento.Any(a => a.tpc_id > 0))
{
CLS_AlunoFechamentoPendenciaBO.SalvarFilaPendencias(
FilaProcessamento
.GroupBy(g => new { g.tud_id, g.tpc_id })
.Select(p => new AlunoFechamentoPendencia {
tud_id = p.FirstOrDefault().tud_id,
tpc_id = p.FirstOrDefault().tpc_id,
afp_frequencia = p.FirstOrDefault().afp_frequencia,
afp_nota = p.FirstOrDefault().afp_nota,
afp_processado = FilaProcessamento
.Where(w => w.tud_id == p.FirstOrDefault().tud_id&& w.tpc_id == p.FirstOrDefault().tpc_id)
.Min(m => m.afp_processado)
})
.Where(w => w.tpc_id > 0 && w.tpc_id != ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, ent_id))
.ToList()
, banco);
}
return(true);
}
catch (ValidationException ex)
{
banco.Close(ex);
throw;
}
catch (Exception ex)
{
banco.Close(ex);
throw;
}
finally
{
if (banco.ConnectionIsOpen)
{
banco.Close();
}
}
}
/// <summary>
/// Processa os protocolos informados.
/// </summary>
/// <param name="ltProtocolo">Lista de protocolos em processamento.</param>
/// <param name="tentativasProtocolo">Quantidade máxima de tentativas para processar protocolos.</param>
/// <returns></returns>
public static bool ProcessarProtocoloCompensacao(List <DCL_Protocolo> ltProtocolo, int tentativasProtocolo)
{
DataTable dtProtocolo = DCL_Protocolo.TipoTabela_Protocolo();
foreach (DCL_Protocolo protocolo in ltProtocolo.Where(pro => pro.pro_tentativa > tentativasProtocolo))
{
protocolo.pro_statusObservacao = String.Format("Número máximo ({0}) de tentativas de processamento deste protocolo foram excedidas. Erro: {1}"
, tentativasProtocolo, protocolo.pro_statusObservacao);
protocolo.pro_status = (byte)DCL_ProtocoloBO.eStatus.ProcessadoComErrosValidacao;
protocolo.tur_id = -1;
protocolo.tud_id = -1;
protocolo.tau_id = -1;
protocolo.pro_qtdeAlunos = -1;
dtProtocolo.Rows.Add(DCL_ProtocoloBO.ProtocoloToDataRow(protocolo, dtProtocolo.NewRow()));
}
foreach (DCL_Protocolo protocolo in ltProtocolo.Where(pro => pro.pro_tentativa <= tentativasProtocolo))
{
// Abre uma transação para cada protocolo dentro do laço.
// Assim é possível processar o próximo protocolo, mesmo que o atual esteja com erro.
TalkDBTransaction bancoSincronizacao = new CLS_TurmaAulaDAO()._Banco.CopyThisInstance();
bancoSincronizacao.Open(IsolationLevel.ReadCommitted);
bool processou = false;
try
{
if (protocolo.pro_tentativa <= tentativasProtocolo)
{
JObject json = JObject.Parse(protocolo.pro_pacote);
JArray compensacoes = ((JArray)json.SelectToken("CompensacaoFalta") ?? new JArray());
foreach (JObject compensacao in compensacoes)
{
long tud_id = Convert.ToInt64(compensacao.SelectToken("tud_id"));
ACA_FormatoAvaliacao formatoAvaliacao = ACA_FormatoAvaliacaoBO.CarregarPorTud(tud_id);
ACA_CalendarioAnual cal = ACA_CalendarioAnualBO.SelecionaPorTurmaDisciplina(tud_id, bancoSincronizacao);
// apenas protocolos de turmas ativas e do ano letivo corrente podem ser processados
if (!DCL_ProtocoloBO.PodeProcessarProtocolo(0, tud_id))
{
throw new ValidationException("O protocolo pertence a uma turma que não esta ativa ou de um ano letivo diferente do corrente, não pode ser processado!");
}
int cpa_id = Convert.ToInt32(compensacao.SelectToken("cpa_id"));
int quantidadeAulasCompensadas = Convert.ToInt32(compensacao.SelectToken("cpa_quantidadeAulasCompensadas"));
DateTime cpa_dataAlteracao = Convert.ToDateTime(compensacao.SelectToken("cpa_dataAlteracao"));
CLS_CompensacaoAusencia compensacaoAusencia;
long pro_protocoloCriacao = (long)(compensacao.GetValue("pro_protocolo", StringComparison.OrdinalIgnoreCase) ?? "0");
if (cpa_id > 0 || pro_protocoloCriacao <= 0)
{
compensacaoAusencia = new CLS_CompensacaoAusencia
{
tud_id = tud_id,
cpa_id = cpa_id
};
GetEntity(compensacaoAusencia, bancoSincronizacao);
}
else
{
List <DCL_Protocolo> protocoloCriacaoCompensacao = DCL_ProtocoloBO.SelectBy_Protocolos(pro_protocoloCriacao.ToString());
Guid pro_idCriacao = protocoloCriacaoCompensacao.Count() > 0 ? protocoloCriacaoCompensacao[0].pro_id : Guid.Empty;
compensacaoAusencia = SelectByDisciplinaProtocolo(tud_id, pro_idCriacao);
if (!compensacaoAusencia.IsNew)
{
compensacaoAusencia.pro_id = protocolo.pro_id;
}
}
if (compensacaoAusencia.IsNew)
{
compensacaoAusencia.cpa_id = -1;
compensacaoAusencia.cpa_dataCriacao = DateTime.Now;
compensacaoAusencia.pro_id = protocolo.pro_id;
}
else if (!compensacaoAusencia.IsNew && (cpa_dataAlteracao < compensacaoAusencia.cpa_dataAlteracao))
{
throw new ValidationException("Compensação existe e foi alterada mais recentemente.");
}
compensacaoAusencia.tpc_id = Convert.ToInt32(compensacao.SelectToken("tpc_id"));
compensacaoAusencia.cpa_quantidadeAulasCompensadas = quantidadeAulasCompensadas;
compensacaoAusencia.cpa_atividadesDesenvolvidas = Convert.ToString(compensacao.SelectToken("cpa_atividadesDesenvolvidas"));
compensacaoAusencia.cpa_situacao = Convert.ToInt16(compensacao.SelectToken("cpa_situacao"));
compensacaoAusencia.cpa_dataAlteracao = DateTime.Now;
if (compensacaoAusencia.cpa_situacao != 3)
{
JArray arrayAlunos = ((JArray)compensacao.SelectToken("AlunosCompensados") ?? new JArray());
List <CLS_CompensacaoAusenciaAluno> listaAlunos = new List <CLS_CompensacaoAusenciaAluno>();
foreach (JObject jsonAluno in arrayAlunos)
{
int alu_id = Convert.ToInt32(jsonAluno.SelectToken("alu_id"));
MTR_MatriculaTurmaDisciplina matricula = MTR_MatriculaTurmaDisciplinaBO.BuscarPorAlunoTurmaDisciplina(alu_id, tud_id, bancoSincronizacao);
CLS_CompensacaoAusenciaAluno compensacaoAluno = new CLS_CompensacaoAusenciaAluno
{
tud_id = tud_id,
cpa_id = compensacaoAusencia.cpa_id,
alu_id = alu_id,
mtu_id = matricula.mtu_id,
mtd_id = matricula.mtd_id
};
CLS_CompensacaoAusenciaAlunoBO.GetEntity(compensacaoAluno);
if (compensacaoAluno.IsNew)
{
compensacaoAluno.caa_dataCriacao = DateTime.Now;
}
compensacaoAluno.caa_situacao = 1;
compensacaoAluno.caa_dataAlteracao = DateTime.Now;
listaAlunos.Add(compensacaoAluno);
}
processou = Save(compensacaoAusencia, listaAlunos, formatoAvaliacao.fav_fechamentoAutomatico, cal.cal_id, bancoSincronizacao);
}
else
{
// persistindo os dados.
processou = true;
// Caso o fechamento seja automático, grava na fila de processamento.
if (formatoAvaliacao.fav_fechamentoAutomatico && compensacaoAusencia.tpc_id != ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, new Guid()))
{
processou &= CLS_AlunoFechamentoPendenciaBO.SalvarFilaFrequencia(compensacaoAusencia.tud_id, compensacaoAusencia.tpc_id, bancoSincronizacao);
}
processou &= Delete(compensacaoAusencia, bancoSincronizacao);
}
}
}
// Processou com sucesso.
protocolo.pro_statusObservacao = String.Format("Protocolo processado com sucesso ({0}).",
DateTime.Now.ToString("dd/MM/yyyy HH:mm"));
protocolo.pro_status = (byte)DCL_ProtocoloBO.eStatus.ProcessadoComSucesso;
dtProtocolo.Rows.Add(DCL_ProtocoloBO.ProtocoloToDataRow(protocolo, dtProtocolo.NewRow()));
}
catch (ArgumentException ex)
{
// Se ocorrer uma excessão de validação, guardar novo status.
protocolo.pro_status = (byte)DCL_ProtocoloBO.eStatus.ProcessadoComErrosValidacao;
protocolo.pro_statusObservacao = ex.Message;
protocolo.tur_id = -1;
protocolo.tud_id = -1;
protocolo.tau_id = -1;
protocolo.pro_qtdeAlunos = -1;
dtProtocolo.Rows.Add(DCL_ProtocoloBO.ProtocoloToDataRow(protocolo, dtProtocolo.NewRow()));
bancoSincronizacao.Close(ex);
}
catch (ValidationException ex)
{
// Se ocorrer uma excessão de validação, guardar novo status.
protocolo.pro_status = (byte)DCL_ProtocoloBO.eStatus.ProcessadoComErrosValidacao;
protocolo.pro_statusObservacao = ex.Message;
protocolo.tur_id = -1;
protocolo.tud_id = -1;
protocolo.tau_id = -1;
protocolo.pro_qtdeAlunos = -1;
dtProtocolo.Rows.Add(DCL_ProtocoloBO.ProtocoloToDataRow(protocolo, dtProtocolo.NewRow()));
bancoSincronizacao.Close(ex);
}
catch (Exception ex)
{
// Se ocorrer uma excessão de erro, guardar novo status.
protocolo.pro_status = (byte)DCL_ProtocoloBO.eStatus.ProcessadoComErro;
protocolo.pro_statusObservacao = ex.Message;
protocolo.tur_id = -1;
protocolo.tud_id = -1;
protocolo.tau_id = -1;
protocolo.pro_qtdeAlunos = -1;
dtProtocolo.Rows.Add(DCL_ProtocoloBO.ProtocoloToDataRow(protocolo, dtProtocolo.NewRow()));
bancoSincronizacao.Close(ex);
}
finally
{
if (bancoSincronizacao.ConnectionIsOpen)
{
bancoSincronizacao.Close();
}
}
}
DCL_ProtocoloBO.AtualizaProtocolos(dtProtocolo);
return(true);
}
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);
}
}
public static bool Delete(CLS_RelatorioPreenchimentoAlunoTurmaDisciplina entity, int rea_id)
{
CLS_RelatorioPreenchimentoAlunoTurmaDisciplinaDAO dao = new CLS_RelatorioPreenchimentoAlunoTurmaDisciplinaDAO();
dao._Banco.Open(IsolationLevel.ReadCommitted);
try
{
bool sucesso = Delete(entity, dao._Banco);
if (sucesso)
{
CLS_RelatorioAtendimento relatorioAtendimento = CLS_RelatorioAtendimentoBO.GetEntity(new CLS_RelatorioAtendimento {
rea_id = rea_id
});
if (relatorioAtendimento.rea_tipo == (byte)CLS_RelatorioAtendimentoTipo.RP)
{
ACA_CalendarioAnual calendario = ACA_CalendarioAnualBO.SelecionaPorTurma(entity.tur_id);
List <MTR_MatriculaTurma> matriculasAno = MTR_MatriculaTurmaBO.GetSelectMatriculasAlunoAno(entity.alu_id, calendario.cal_ano);
matriculasAno.ForEach(p => LimpaCache_AlunoPreenchimentoPorPeriodoDisciplina(entity.tpc_id, p.tur_id));
ACA_FormatoAvaliacao fav = TUR_TurmaBO.SelecionaFormatoAvaliacao(entity.tur_id, dao._Banco);
if (fav != null && fav.fav_fechamentoAutomatico)
{
CLS_AlunoFechamentoPendenciaBO.SalvarFilaPendencias(entity.tud_id, entity.tpc_id, dao._Banco);
}
}
else if (relatorioAtendimento.rea_tipo == (byte)CLS_RelatorioAtendimentoTipo.NAAPA)
{
List <AlunoFechamentoPendencia> FilaProcessamento = new List <AlunoFechamentoPendencia>();
ACA_CalendarioAnual cal = ACA_CalendarioAnualBO.SelecionaPorTurma(entity.tur_id, dao._Banco);
var periodos = ACA_CalendarioPeriodoBO.SelecionaPor_Calendario(cal.cal_id, GestaoEscolarUtilBO.MinutosCacheLongo);
FilaProcessamento.AddRange(TUR_TurmaDisciplinaBO.GetSelectBy_Turma(entity.tur_id, dao._Banco, GestaoEscolarUtilBO.MinutosCacheLongo)
.SelectMany
(
tud =>
periodos.Select
(
tpc =>
new AlunoFechamentoPendencia
{
tud_id = tud.tud_id
,
tpc_id = tpc.tpc_id
,
afp_frequencia = true
,
afp_nota = true
,
afp_processado = 2
}
).ToList()
));
if (FilaProcessamento.Any())
{
CLS_AlunoFechamentoPendenciaBO.SalvarFilaPendencias(FilaProcessamento, dao._Banco);
}
}
}
return(sucesso);
}
catch (Exception ex)
{
dao._Banco.Close(ex);
throw;
}
finally
{
if (dao._Banco.ConnectionIsOpen)
{
dao._Banco.Close();
}
}
}
protected void _dgvTurma_RowCommand(object sender, GridViewCommandEventArgs e)
{
if (e.CommandName == "Selecionar")
{
try
{
VS_cancelSelect = false;
GridViewRow row = (GridViewRow)((LinkButton)e.CommandSource).NamingContainer;
int index = row.RowIndex;
_VS_tur_id = Convert.ToInt32(_dgvTurma.DataKeys[index].Values["tur_id"]);
// Utilizado para verificar se é turma eletiva do aluno
TUR_Turma tur = new TUR_Turma {
tur_id = _VS_tur_id
};
TUR_TurmaBO.GetEntity(tur);
// verifica se existe evento de efetivacao ligado ao calendário da turma
int cal_id = Convert.ToInt32(_dgvTurma.DataKeys[index].Values["cal_id"]);
// Busca o evento ligado ao calendário, que seja do tipo definido
// no parâmetro como de efetivação.
List <ACA_Evento> listEvento = ACA_EventoBO.GetEntity_Efetivacao_List(cal_id, _VS_tur_id, __SessionWEB.__UsuarioWEB.Grupo.gru_id, __SessionWEB.__UsuarioWEB.Usuario.ent_id, ApplicationWEB.AppMinutosCacheLongo, true, __SessionWEB.__UsuarioWEB.Docente.doc_id);
if (string.IsNullOrEmpty(_dgvTurma.DataKeys[index].Values["fav_id"].ToString()))
{
_lblMessage.Text = UtilBO.GetErroMessage("É necessário selecionar uma turma que possua um formato de avaliação.", UtilBO.TipoMensagem.Alerta);
}
else
{
_VS_fav_id = Convert.ToInt32(_dgvTurma.DataKeys[index].Values["fav_id"]);
int valor = ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_EVENTO_EFETIVACAO_NOTAS, __SessionWEB.__UsuarioWEB.Usuario.ent_id);
int valorRecuperacao = ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_EVENTO_EFETIVACAO_RECUPERACAO, __SessionWEB.__UsuarioWEB.Usuario.ent_id);
int valorFinal = ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_EVENTO_EFETIVACAO_FINAL, __SessionWEB.__UsuarioWEB.Usuario.ent_id);
int valorRecuperacaoFinal = ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_EVENTO_EFETIVACAO_RECUPERACAO_FINAL, __SessionWEB.__UsuarioWEB.Usuario.ent_id);
// verifica se existe evento do tipo Efetivação Nota
string listaTpcIdPeriodicaPeriodicaFinal = string.Empty;
IEnumerable <ACA_Evento> dadoNota =
(from ACA_Evento item in listEvento
where item.tev_id == valor
select item);
// se existir, pega os tpc_id's
List <ACA_Evento> lt = dadoNota.ToList();
if (lt.Count > 0)
{
var x = from ACA_Evento evt in listEvento
where evt.tev_id == valor
select evt.tpc_id;
foreach (int tpc_id in x.ToList())
{
if (string.IsNullOrEmpty(listaTpcIdPeriodicaPeriodicaFinal))
{
listaTpcIdPeriodicaPeriodicaFinal += Convert.ToString(tpc_id);
}
else
{
listaTpcIdPeriodicaPeriodicaFinal += "," + Convert.ToString(tpc_id);
}
}
}
// verifica se existe evento do tipo efetivação recuperacao
string listaTpcIdRecuperacao = string.Empty;
IEnumerable <ACA_Evento> dadoRecuperacao =
(from ACA_Evento item in listEvento
where
item.tev_id == valorRecuperacao
select item);
List <ACA_Evento> ltRe = dadoRecuperacao.ToList();
// se existir, pega os tpc_id's
if (ltRe.Count > 0)
{
var x = from ACA_Evento evt in listEvento
where
evt.tev_id == valorRecuperacao
select evt.tpc_id;
foreach (int tpc_id in x.ToList())
{
if (string.IsNullOrEmpty(listaTpcIdRecuperacao))
{
listaTpcIdRecuperacao += Convert.ToString(tpc_id);
}
else
{
listaTpcIdRecuperacao += "," + Convert.ToString(tpc_id);
}
}
}
// verifica se existe evento do tipo efetivação final
bool existeFinal = false;
IEnumerable <ACA_Evento> dadoFinal =
(from ACA_Evento item in listEvento
where
item.tev_id == valorFinal
select item);
List <ACA_Evento> ltFinal = dadoFinal.ToList();
// se existir, marca para trazer as avaliações do tipo final
if (ltFinal.Count > 0)
{
existeFinal = true;
}
// verifica se existe evento do tipo recuperação final
bool existeRecuperacaoFinal = false;
IEnumerable <ACA_Evento> dadoRecuperacaoFinal =
(from ACA_Evento item in listEvento
where
item.tev_id == valorRecuperacaoFinal
select item);
List <ACA_Evento> ltRecuperacaoFinal = dadoRecuperacaoFinal.ToList();
// se existir, marca para trazer as avaliações do tipo recuperação final
if (ltRecuperacaoFinal.Count > 0)
{
existeRecuperacaoFinal = true;
}
DataTable dtAvaliacoes;
// Se for turma eletiva do aluno, carrega apenas os períodos do calendário em que
// a turma é oferecida
if ((TUR_TurmaTipo)tur.tur_tipo == TUR_TurmaTipo.EletivaAluno)
{
List <CadastroTurmaDisciplina> listaDisciplinas = TUR_TurmaDisciplinaBO.GetSelectCadastradosBy_Turma(_VS_tur_id);
dtAvaliacoes = ACA_AvaliacaoBO.ConsultaPor_Periodo_Efetivacao_TurmaDisciplinaCalendario(_VS_tur_id, listaDisciplinas[0].entTurmaDisciplina.tud_id, _VS_fav_id, listaTpcIdPeriodicaPeriodicaFinal, listaTpcIdRecuperacao, existeFinal, false, true);
}
else
{
dtAvaliacoes = ACA_AvaliacaoBO.ConsultaPor_Periodo_Efetivacao(_VS_tur_id, _VS_fav_id, 0, listaTpcIdPeriodicaPeriodicaFinal, listaTpcIdRecuperacao, existeFinal, existeRecuperacaoFinal, false, true, -1, ApplicationWEB.AppMinutosCacheLongo);
}
var avaliacoes = (from DataRow dr in dtAvaliacoes.Rows
let fechado = Convert.ToBoolean(dr["ava_tpc_fechado"])
let cap_dataInicio = Convert.ToDateTime(string.IsNullOrEmpty(dr["cap_dataInicio"].ToString()) ? new DateTime().ToString() : dr["cap_dataInicio"])
where !(fechado && cap_dataInicio > DateTime.Now)
select dr);
dtAvaliacoes = avaliacoes.Any() ? avaliacoes.CopyToDataTable() : new DataTable();
if (dtAvaliacoes.Rows.Count == 0)
{
_lblMessage.Text = UtilBO.GetErroMessage("Turma fora do período de " + NomeModulo + ".", UtilBO.TipoMensagem.Alerta);
}
else if (dtAvaliacoes.Rows.Count == 1)
{
ACA_FormatoAvaliacao ent = new ACA_FormatoAvaliacao {
fav_id = _VS_fav_id
};
ACA_FormatoAvaliacaoBO.GetEntity(ent);
_VS_ava_id = Convert.ToInt32(dtAvaliacoes.Rows[0]["ava_id"]);
RedirecionaCadastro();
}
else if (dtAvaliacoes.Rows.Count > 1)
{
// Carregar Avaliações.
gvAvaliacoes.DataSource = dtAvaliacoes;
gvAvaliacoes.DataBind();
ScriptManager.RegisterStartupScript(this, typeof(Page), "abreAvaliacoes", "$(document).ready(function(){$('#divAvaliacoes').dialog('open'); });", true);
}
}
}
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 as avaliações.", UtilBO.TipoMensagem.Erro);
}
}
}
