/// <summary>
/// Retorna os períodos que possuem a mesma quantidade de níveis da orientação curricular
/// </summary>
/// <param name="qtdeNiveis">Quantidade de níveis da orientação curricular</param>
/// <param name="cur_id">Id do curso</param>
/// <param name="crr_id">Id do currículo</param>
public void CarregarPorQtdeNivelOrientacaoCurricular(int qtdeNiveis, int cur_id, int crr_id, int cal_id, int tds_id, Guid ent_id)
{
odsDados.SelectParameters.Clear();
ddlCombo.Items.Clear();
ddlCombo.DataSourceID = "";
ddlCombo.AppendDataBoundItems = true;
ddlCombo.DataValueField = "cur_id_crr_id_crp_id";
ddlCombo.DataTextField = "crp_descricao";
DataTable dtCurriculoPeriodo = ACA_CurriculoPeriodoBO.SelecionaPorQtdeNiveisOrientacaoCurricular(cur_id, crr_id, cal_id, tds_id, ent_id, qtdeNiveis);
int aux = 0;
foreach (DataRow row in dtCurriculoPeriodo.Rows)
{
ddlCombo.Items.Insert(aux, new ListItem(row["crp_descricao"].ToString(), row["cur_id_crr_id_crp_id"].ToString(), true));
aux++;
}
if (ddlCombo.Items.IndexOf(ddlCombo.Items.FindByValue("-1;-1;-1")) == -1)
{
ddlCombo.Items.Insert(0, new ListItem("-- Selecione um(a) " + GestaoEscolarUtilBO.nomePadraoPeriodo(__SessionWEB.__UsuarioWEB.Usuario.ent_id).ToLower() + " --", "-1;-1;-1", true));
}
ddlCombo.SelectedValue = "-1;-1;-1";
}
private void UCCCursoCurriculo_IndexChanged()
{
if (UCCCursoCurriculo.Valor[0] != -1)
{
cblPeriodos.Items.Clear();
DataTable dt = ACA_CurriculoPeriodoBO.BuscaCurriculoPeriodoPorEntidadeCursoCurriculo(Ent_ID_UsuarioLogado, UCCCursoCurriculo.Valor[0], UCCCursoCurriculo.Valor[1]);
for (int i = 0; i < dt.Rows.Count; i++)
{
DataRow row = dt.Rows[i];
ListItem item = new ListItem();
item.Text = row["crp_descricao"].ToString();
item.Value = row["crp_id"].ToString();
cblPeriodos.Items.Add(item);
}
pnlPeriodos.Visible = true;
}
else
{
pnlPeriodos.Visible = false;
}
// Recarrega os tipos de disciplina
ddlTipoDisciplina.Items.Clear();
ddlTipoDisciplina.Items.Add(new ListItem(GetGlobalResourceObject("Configuracao", "ParametroResultado.Cadastro.ddlTipoDisciplina.valor0").ToString(), "-1"));
MostrarTiposDisciplina(ddlTipoLancamento.SelectedValue == ((byte)EnumTipoLancamento.Disciplinas).ToString());
}
public HttpResponseMessage GetPeriodos(int cursoId, int curriculoId, int cicloId = 0)
{
try
{
List <sComboPeriodo> lst = new List <sComboPeriodo>();
if (cicloId > 0)
{
lst = ACA_CurriculoPeriodoBO.Select_Por_TipoCiclo(cursoId, curriculoId, cicloId, __userLogged.Usuario.ent_id, ApplicationWEB.AppMinutosCacheLongo);
}
else
{
lst = ACA_CurriculoPeriodoBO.GetSelect(cursoId, curriculoId, __userLogged.Usuario.ent_id, ApplicationWEB.AppMinutosCacheLongo);
}
return(Request.CreateResponse(HttpStatusCode.OK,
lst.Select(p => new jsonObject
{
id = p.cur_id_crr_id_crp_id.Split(';')[2],
text = p.crp_descricao
})
));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, ex));
}
}
public static bool DeletarPorEletivasAlunos
(
ACA_CurriculoDisciplina entity
, TalkDBTransaction banco
, Guid ent_id
)
{
if (VerificaCurriculoDisciplina(entity.cur_id, entity.crr_id, entity.crp_id, entity.dis_id, banco))
{
ACA_CurriculoPeriodo crp = new ACA_CurriculoPeriodo {
cur_id = entity.cur_id, crr_id = entity.crr_id, crp_id = entity.crp_id
};
ACA_CurriculoPeriodoBO.GetEntity(crp, banco);
ACA_Disciplina dis = new ACA_Disciplina {
dis_id = entity.dis_id
};
ACA_DisciplinaBO.GetEntity(dis, banco);
throw new ValidationException("Não é possível excluir o(a) " + GestaoEscolarUtilBO.nomePadraoPeriodo(ent_id).ToLower() + " " + crp.crp_descricao + " do(a) " +
CustomResource.GetGlobalResourceObject("Mensagens", "MSG_DISCIPLINA") + " eletiva " + dis.dis_nome + ", pois possui outros registros ligados a ele(a).");
}
ACA_CurriculoDisciplinaDAO dao = new ACA_CurriculoDisciplinaDAO {
_Banco = banco
};
return(dao.Update_Situacao_By_EletivasAlunos(entity.cur_id, entity.crr_id, entity.crp_id, entity.dis_id));
}
/// <summary>
/// Carrega todos os cursos/periodos ativos.
/// </summary>
public void Carregar()
{
ddlCursoPeriodo.Items.Clear();
ddlCursoPeriodo.DataSource = ACA_CurriculoPeriodoBO.Select_Ativos(__SessionWEB.__UsuarioWEB.Usuario.ent_id);
ddlCursoPeriodo.Items.Insert(0, new ListItem("-- Selecione o(a) " + GestaoEscolarUtilBO.nomePadraoCurso(__SessionWEB.__UsuarioWEB.Usuario.ent_id).ToLower() + " / " + GestaoEscolarUtilBO.nomePadraoPeriodo(__SessionWEB.__UsuarioWEB.Usuario.ent_id).ToLower() + " --", "-1", true));
ddlCursoPeriodo.DataBind();
cpvCursoPeriodo.Visible = Obrigatorio;
}
/// <summary>
/// Valida dados necessários para salvar a entidade. Dispara um ValidationException caso não
/// esteja válida.
/// </summary>
/// <param name="entity">Entidade a validar</param>
/// <param name="banco">Transação com banco do Gestão - obrigatório</param>
/// <param name="ent_id">Id da entidade do usuário logado.</param>
private static void ValidaDados(ACA_AlunoCurriculo entity, TalkDBTransaction banco, Guid ent_id)
{
//Validação feita no BO devido a alteração de nome dos campos para os diferentes clientes
if (entity.cur_id <= 0)
{
throw new ACA_AlunoCurriculo_ValidationException(GestaoEscolarUtilBO.nomePadraoCurso(ent_id) + " é obrigatório.");
}
if (entity.crr_id <= 0)
{
throw new ACA_AlunoCurriculo_ValidationException(GestaoEscolarUtilBO.nomePadraoCurso(ent_id) + " é obrigatório.");
}
if (entity.crp_id <= 0)
{
throw new ACA_AlunoCurriculo_ValidationException(GestaoEscolarUtilBO.nomePadraoPeriodo(ent_id) + " é obrigatório.");
}
if (!string.IsNullOrEmpty(entity.alc_matriculaEstadual) && entity.alc_matriculaEstadual.Length > 50)
{
throw new ACA_AlunoCurriculo_ValidationException(GestaoEscolarUtilBO.nomePadraoMatriculaEstadual(ent_id) + " pode conter até 50 caracteres.");
}
//Se for uma nova matrícula e se a situação dela for 'Ativa' ou 'Em matrícula'
//Verifica se já existe uma matrícula cadastrada com os mesmos dados
if (entity.IsNew &&
(entity.alc_situacao == Convert.ToByte(ACA_AlunoCurriculoSituacao.Ativo) ||
entity.alc_situacao == Convert.ToByte(ACA_AlunoCurriculoSituacao.EmMatricula)))
{
if (Existe_AlunoCurriculo(entity.alu_id, entity.cur_id, entity.crr_id, entity.crp_id, banco))
{
ESC_Escola esc = new ESC_Escola {
esc_id = entity.esc_id
};
ESC_EscolaBO.GetEntity(esc, banco);
ACA_Curso cur = new ACA_Curso {
cur_id = entity.cur_id
};
ACA_CursoBO.GetEntity(cur, banco);
ACA_CurriculoPeriodo crp = new ACA_CurriculoPeriodo {
cur_id = entity.cur_id, crr_id = entity.crr_id, crp_id = entity.crp_id
};
ACA_CurriculoPeriodoBO.GetEntity(crp, banco);
throw new ACA_AlunoCurriculo_ValidationException("Já existe uma matrícula 'Ativa' ou 'Em matrícula' cadastrada com os mesmos dados: <BR/>" +
"Escola: " + esc.esc_nome + "<BR/>" +
GestaoEscolarUtilBO.nomePadraoCurso(ent_id) + ": " + cur.cur_nome + "<BR/>" +
GestaoEscolarUtilBO.nomePadraoPeriodo(ent_id) + ": " + crp.crp_descricao);
}
}
}
public void CarregarPorCursoDisciplina(int cur_id, int crr_id, int dis_id)
{
odsDados.SelectParameters.Clear();
ddlCombo.DataSourceID = "";
ddlCombo.Items.Clear();
ddlCombo.DataSource = ACA_CurriculoPeriodoBO.SelecionaPorCursoDisciplina(cur_id, crr_id, dis_id, __SessionWEB.__UsuarioWEB.Usuario.ent_id, ApplicationWEB.AppMinutosCacheLongo);
ddlCombo.Items.Insert(0, new ListItem("-- Selecione um(a) " + GestaoEscolarUtilBO.nomePadraoPeriodo(__SessionWEB.__UsuarioWEB.Usuario.ent_id).ToLower() + " --", "-1;-1;-1", true));
ddlCombo.AppendDataBoundItems = true;
ddlCombo.DataBind();
}
/// <summary>
/// Verifica se o curso da turma possui avaliação do tipo seriado.
/// </summary>
/// <param name="entTurma">Entidade da turma.</param>
/// <param name="EntFormatoAvaliacao">Entidade do formato de avaliação da turma.</param>
/// <param name="banco">Transação.</param>
/// <param name="entCurriculoPeriodo">Entidade do grupamento da turma (parâmatro de sáida)</param>
/// <param name="Seriado">Flag que indica se o curso ~possui avaliação do tipo seriado (parâmatro de sáida)</param>
/// <returns></returns>
public static bool ValidaCursoSeriadoAvaliacao(TUR_Turma entTurma, ACA_FormatoAvaliacao EntFormatoAvaliacao, TalkDBTransaction banco, out ACA_CurriculoPeriodo entCurriculoPeriodo, out bool Seriado)
{
Seriado = false;
List <TUR_TurmaCurriculo> listCurriculos = TUR_TurmaCurriculoBO.GetSelectBy_Turma(entTurma.tur_id, banco, GestaoEscolarUtilBO.MinutosCacheLongo);
if (listCurriculos.Count == 0)
{
throw new Exception("A turma (tur_id: " + entTurma.tur_id + ") não possui nenhum curriculoPeriodo cadastrado.");
}
ACA_Curriculo entCurriculo = new ACA_Curriculo
{
cur_id = listCurriculos[0].cur_id
,
crr_id = listCurriculos[0].crr_id
};
ACA_CurriculoBO.GetEntity(entCurriculo, banco);
// Se curso for seriado por avaliações - EJA.
if (entCurriculo.crr_regimeMatricula ==
(byte)ACA_CurriculoRegimeMatricula.SeriadoPorAvaliacoes)
{
Seriado = true;
if ((EntFormatoAvaliacao.fav_tipo != (byte)ACA_FormatoAvaliacaoTipo.ConceitoGlobal) &&
(EntFormatoAvaliacao.fav_tipo != (byte)ACA_FormatoAvaliacaoTipo.GlobalDisciplina))
{
// Curso do EJA não pode efetivar notas por disciplina - não possui ligação
// com lançamento por disciplina.
throw new ValidationException("O formato de avaliação \"" + EntFormatoAvaliacao.fav_nome +
"\" deve ser do tipo \"Conceito global\" ou " +
"\"Conceito global e nota por " + CustomResource.GetGlobalResourceObject("Mensagens", "MSG_DISCIPLINA") + "\", " +
"pois o curso da turma é seriado por avaliações.");
}
}
entCurriculoPeriodo = new ACA_CurriculoPeriodo
{
cur_id = entCurriculo.cur_id
,
crr_id = entCurriculo.crr_id
,
crp_id = listCurriculos[0].crp_id
};
ACA_CurriculoPeriodoBO.GetEntity(entCurriculoPeriodo, banco);
return(true);
}
/// <summary>
/// Carrega os curriculo período equivalentes ao currículo período informado
/// filtrados por curso, currículo, escola e curso/currículo/período equivalente
/// </summary>
/// <param name="cur_id">ID do curso</param>
/// <param name="crr_id">ID do currículo</param>
/// <param name="esc_id">ID da escola</param>
/// <param name="uni_id">ID da unidade da escola</param>
/// <param name="cur_idEquivalente">ID do curso equivalente</param>
/// <param name="crr_idEquivalente">ID do currículo equivalente</param>
/// <param name="crp_idEquivalente">ID do período equivalente</param>
public void CarregarPorCursoEscolaPeriodoEquivalente
(
int cur_id,
int crr_id,
int esc_id,
int uni_id,
int cur_idEquivalente,
int crr_idEquivalente,
int crp_idEquivalente
)
{
CarregarCombo(ACA_CurriculoPeriodoBO.Seleciona_Por_CursoEscola_PeriodoEquivalente(cur_id, crr_id, esc_id, uni_id,
cur_idEquivalente, crr_idEquivalente, crp_idEquivalente));
}
/// <summary>
/// Carrega no combo os currículoPeriodo cadastrados para o curso e escola informados, e filtra também
/// o currículoPeríodo que seja equivalente (mesmo crp_ordem) do crpEquivalente informado.
/// </summary>
/// <param name="cur_id">ID do curso</param>
/// <param name="crr_id">ID do currículo</param>
/// <param name="esc_id">ID da escola</param>
/// <param name="uni_id">ID da unidade da escola</param>
/// <param name="cur_idEquivalente">ID do curso equivalente</param>
/// <param name="crr_idEquivalente">ID do currículo equivalente</param>
/// <param name="crp_idEquivalente">ID do período equivalente</param>
/// <returns></returns>
public void Carregar_Por_CursoEscola_PeriodoEquivalente
(int cur_id, int crr_id, int esc_id, int uni_id, int cur_idEquivalente, int crr_idEquivalente, int crp_idEquivalente)
{
odsDados.SelectParameters.Clear();
ddlCombo.Items.Clear();
ddlCombo.DataSourceID = "";
ddlCombo.DataSource = ACA_CurriculoPeriodoBO.Seleciona_Por_CursoEscola_PeriodoEquivalente
(cur_id, crr_id, esc_id, uni_id, cur_idEquivalente, crr_idEquivalente, crp_idEquivalente);
ddlCombo.Items.Insert(0, new ListItem("-- Selecione um(a) " + GestaoEscolarUtilBO.nomePadraoPeriodo(__SessionWEB.__UsuarioWEB.Usuario.ent_id).ToLower() + " --", "-1;-1;-1", true));
ddlCombo.AppendDataBoundItems = true;
ddlCombo.DataBind();
}
/// <summary>
/// Retorna os períodos por curso e disciplina da turma
/// </summary>
/// <param name="dis_id">ID da disciplina</param>
/// <param name="cur_id">Id da tabela ACA_Curso do bd</param>
/// <param name="crr_id">Id da tabela ACA_Curriculo do bd</param>
public void CarregarPorDisciplina(int dis_id, int cur_id, int crr_id)
{
odsDados.SelectParameters.Clear();
ddlCombo.Items.Clear();
ddlCombo.DataSourceID = "";
ddlCombo.AppendDataBoundItems = true;
ddlCombo.DataSource = ACA_CurriculoPeriodoBO.Select_Por_Disciplina(dis_id, cur_id, crr_id);
ddlCombo.DataBind();
if (ddlCombo.Items.IndexOf(ddlCombo.Items.FindByValue("-1;-1;-1")) == -1)
{
ddlCombo.Items.Insert(0, new ListItem("-- Selecione um(a) " + GestaoEscolarUtilBO.nomePadraoPeriodo(__SessionWEB.__UsuarioWEB.Usuario.ent_id).ToLower() + " --", "-1;-1;-1", true));
}
ddlCombo.SelectedValue = "-1;-1;-1";
}
/// <summary>
/// Método que verifica se o turno selecionado é valido com o
/// currículo do curso.
/// </summary>
/// <param name="entTurmaCurriculo">entidade com dados Turma currículo</param>
/// <param name="trn_id">id do turno</param>
/// <param name="msgErro">Mensagem de erro</param>
/// <param name="ent_id">Id da entidade do usuário logado.</param>
/// <returns>True - caso é compatível o turno com Curriculo Período / False - caso não seja compatível</returns>
public static bool VerificaTurno(TUR_TurmaCurriculo entTurmaCurriculo, int trn_id, out string msgErro, Guid ent_id)
{
msgErro = "";
ACA_CurriculoPeriodo entity = new ACA_CurriculoPeriodo
{
cur_id = entTurmaCurriculo.cur_id
,
crr_id = entTurmaCurriculo.crr_id
,
crp_id = entTurmaCurriculo.crp_id
};
ACA_CurriculoPeriodoBO.GetEntity(entity);
if (ACA_TurnoHorarioBO.GetSelectDiasSemana(trn_id).Rows.Count !=
entity.crp_qtdeDiasSemana)
{
msgErro = "A quantidade de dias da semana que possui aula do(a) " + GestaoEscolarUtilBO.nomePadraoPeriodo(ent_id) + " deve ser o mesmo do turno.";
return(true);
}
// Verifica o tipo de controle de tempo (TemposAula/Horas).
if (entity.crp_controleTempo == Convert.ToInt32(ACA_CurriculoPeriodoControleTempo.TemposAula))
{
//Compara a quantidade de aulas lançadas no currículo período com a quantidades de aulas lançadas no turno.
if (!(entity.crp_qtdeTemposSemana == ACA_TurnoBO.QuantidadeTemposAulaTurno(trn_id)))
{
msgErro = "A quantidade de tempos de aula de uma semana do(a) " + GestaoEscolarUtilBO.nomePadraoPeriodo(ent_id) + " deve ser o mesmo do turno.";
return(true);
}
}
else
{
//Faz o calculo da horas de aula na semana definido no currículo período e compara com as horas lançadas no turno.
if (!((entity.crp_qtdeHorasDia * 60 + entity.crp_qtdeMinutosDia) * entity.crp_qtdeDiasSemana == ACA_TurnoBO.QuantidadeHorasTurno(trn_id)))
{
msgErro = "A quantidade de tempos de aula de uma semana do(a) " + GestaoEscolarUtilBO.nomePadraoPeriodo(ent_id) + " deve ser o mesmo do turno.";
return(true);
}
}
return(false);
}
/// <summary>
/// Seleciona por escola, curso, e ordem do período (apenas períodos com ordem igual ou superior)
/// </summary>
/// <param name="esc_id">ID da escola.</param>
/// <param name="uni_id">ID da unidade de escola.</param>
/// <param name="cur_id">ID do curso.</param>
/// <param name="crr_id">ID do currículo do curso.</param>
/// <param name="crp_ordem">Ordem de validação do período.</param>
public void CarregarPorEscolaCursoPeriodoOrdem(int esc_id, int uni_id, int cur_id, int crr_id, int crp_ordem)
{
odsDados.SelectParameters.Clear();
ddlCombo.Items.Clear();
ddlCombo.DataSourceID = "";
ddlCombo.AppendDataBoundItems = true;
ddlCombo.DataSource = ACA_CurriculoPeriodoBO.SelecionaPorEscolaCursoPeriodoOrdem(esc_id, uni_id, cur_id, crr_id, crp_ordem, ApplicationWEB.AppMinutosCacheLongo);
if (ddlCombo.Items.IndexOf(ddlCombo.Items.FindByValue("-1;-1;-1")) == -1)
{
ddlCombo.Items.Insert(0, new ListItem("-- Selecione um(a) " + GestaoEscolarUtilBO.nomePadraoPeriodo(__SessionWEB.__UsuarioWEB.Usuario.ent_id).ToLower() + " --", "-1;-1;-1", true));
}
ddlCombo.DataBind();
ddlCombo.SelectedValue = "-1;-1;-1";
}
/// <summary>
/// Verifica se o tipo de movimentação gera transferencia de matricula do aluno.
/// </summary>
/// <param name="tipoMovimento">Tipo do movimento</param>
/// <returns></returns>
public static bool VerificarMovimentacaoTransferenciaMatriculaAluno(MTR_Movimentacao_Cadastro cadMov)
{
MTR_MovimentacaoDAO daoMov = new MTR_MovimentacaoDAO();
TalkDBTransaction bancoGestao = daoMov._Banco;
MTR_TipoMovimentacao tmo;
if (cadMov.listasFechamentoMatricula.listTipoMovimentacao != null)
{
// Se os dados do fechamento de matrícula forem alimentados, pegar dados do fechamento.
tmo = cadMov.listasFechamentoMatricula.listTipoMovimentacao.
Find(p => p.tmo_id == cadMov.entMovimentacao.tmo_id) ?? new MTR_TipoMovimentacao();
}
else
{
tmo = new MTR_TipoMovimentacao {
tmo_id = cadMov.entMovimentacao.tmo_id
};
MTR_TipoMovimentacaoBO.GetEntity(tmo, daoMov._Banco);
}
switch ((MTR_TipoMovimentacaoTipoMovimento)tmo.tmo_tipoMovimento)
{
case MTR_TipoMovimentacaoTipoMovimento.MudancaTurma:
case MTR_TipoMovimentacaoTipoMovimento.MudancaBlocoPEJA:
case MTR_TipoMovimentacaoTipoMovimento.RenovacaoMatricula:
return(true);
case MTR_TipoMovimentacaoTipoMovimento.Adequacao:
bool isCurriculoPeriodoEJA = ACA_CurriculoPeriodoBO.VerificaCurriculoPeriodoEJA(new ACA_CurriculoPeriodo {
cur_id = cadMov.entAluCurNovo.cur_id, crr_id = cadMov.entAluCurNovo.crr_id, crp_id = cadMov.entAluCurNovo.crp_id
}, bancoGestao);
return(!(cadMov.entAluCurAnterior.cur_id == cadMov.entAluCurNovo.cur_id &&
cadMov.entAluCurAnterior.crr_id == cadMov.entAluCurNovo.crr_id &&
cadMov.entAluCurAnterior.crp_id == cadMov.entAluCurNovo.crp_id &&
isCurriculoPeriodoEJA) &&
cadMov.entAluCurAnterior.esc_id == cadMov.entAluCurNovo.esc_id &&
cadMov.entAluCurAnterior.uni_id == cadMov.entAluCurNovo.uni_id);
case MTR_TipoMovimentacaoTipoMovimento.MudancaModalidaeEnsino:
return(cadMov.entAluCurAnterior.esc_id == cadMov.entAluCurNovo.esc_id &&
cadMov.entAluCurAnterior.uni_id == cadMov.entAluCurNovo.uni_id);
case MTR_TipoMovimentacaoTipoMovimento.Reclassificacao:
ACA_CurriculoPeriodo entCurPerAnterior = new ACA_CurriculoPeriodo
{
cur_id = cadMov.entAluCurAnterior.cur_id,
crr_id = cadMov.entAluCurAnterior.crr_id,
crp_id = cadMov.entAluCurAnterior.crp_id
};
ACA_CurriculoPeriodoBO.GetEntity(entCurPerAnterior, bancoGestao);
ACA_CurriculoPeriodo entCurPerNovo = new ACA_CurriculoPeriodo
{
cur_id = cadMov.entAluCurNovo.cur_id,
crr_id = cadMov.entAluCurNovo.crr_id,
crp_id = cadMov.entAluCurNovo.crp_id
};
ACA_CurriculoPeriodoBO.GetEntity(entCurPerNovo, bancoGestao);
// Alterado para pegar os cursos/períodos equivalentes com o curso de destino.
List <ACA_CurriculoPeriodo> listPeriodosEquivalentes = ACA_CurriculoPeriodoBO.Seleciona_PeriodosRelacionados_Equivalentes(cadMov.entAluCurNovo.cur_id, cadMov.entAluCurNovo.crr_id, cadMov.entAluCurNovo.crp_id);
return(((entCurPerAnterior.cur_id == entCurPerNovo.cur_id && entCurPerAnterior.crr_id == entCurPerNovo.crr_id) ||
(listPeriodosEquivalentes.Count > 0 && listPeriodosEquivalentes.Exists(p => p.cur_id == entCurPerNovo.cur_id && p.crr_id == entCurPerNovo.crr_id))) &&
!(entCurPerAnterior.crp_ordem == entCurPerNovo.crp_ordem &&
ACA_CurriculoPeriodoBO.VerificaCurriculoPeriodoEJA(entCurPerNovo, bancoGestao) &&
entCurPerNovo.crp_turmaAvaliacao) &&
entCurPerAnterior.crp_ordem == entCurPerNovo.crp_ordem - 1 &&
cadMov.entAluCurAnterior.esc_id == cadMov.entAluCurNovo.esc_id &&
cadMov.entAluCurAnterior.uni_id == cadMov.entAluCurNovo.uni_id);
default:
return(false);
}
}
/// <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 ProcessaProtocoloPlanejamentoAnual(List <DCL_Protocolo> ltProtocolo, int tentativasProtocolo)
{
// DataTable de protocolos
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)
{
if (string.IsNullOrEmpty(protocolo.pro_versaoAplicativo))
{
throw new ValidationException("É necessário atualizar a versão do sistema.");
}
///*
// * na versão 44 o planejamento mudou e não mais podera mais processar
// * protocolos de planejamento antigos
// * */
//int minorVersion = int.Parse(protocolo.pro_versaoAplicativo.Split('.')[1]);
//if (minorVersion < 44)
// throw new ValidationException("É necessário atualizar a versão do sistema.");
#region Varável
List <CLS_TurmaDisciplinaPlanejamento> listaPlanejamento = new List <CLS_TurmaDisciplinaPlanejamento>();
#endregion
#region Informações do planejamento anual
// Objeto JSON de entrada.
JObject planejamento = JObject.Parse(protocolo.pro_pacote);
long tud_id = (long)planejamento.SelectToken("tud_id");
protocolo.tud_id = tud_id;
// 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!");
}
ACA_CurriculoPeriodo entCrp = ACA_CurriculoPeriodoBO.SelecionaPorTurmaDisciplina(tud_id, bancoSincronizacao).FirstOrDefault();
#endregion
// Todas as matrículas de aluno na disciplina.
List <MTR_MatriculaTurmaDisciplina> listaMatriculas = MTR_MatriculaTurmaDisciplinaBO.
SelecionaMatriculasPorTurmaDisciplina(tud_id.ToString(), bancoSincronizacao);
List <CLS_AlunoTurmaDisciplinaOrientacaoCurricular> listaAlunoTurmaDisciplinaOrientacao = new List <CLS_AlunoTurmaDisciplinaOrientacaoCurricular>();
List <CLS_PlanejamentoOrientacaoCurricular> listaPlanejamentoOrientacao = new List <CLS_PlanejamentoOrientacaoCurricular>();
List <CLS_PlanejamentoOrientacaoCurricularDiagnostico> listaPlanejamentoDiagnostico = new List <CLS_PlanejamentoOrientacaoCurricularDiagnostico>();
if (!ACA_ParametroAcademicoBO.ParametroValorBooleanoPorEntidade(eChaveAcademico.PLANEJAMENTO_ANUAL_CICLO, Guid.Empty))
{
#region Informações sobre alcance dos alunos nas orientações curriculares
JArray alunoLista = ((JArray)planejamento.SelectToken("AlunoTurmaDisciplinaOrientacaoCurricular") ?? new JArray());
List <CLS_AlunoTurmaDisciplinaOrientacaoCurricular> listaAlunoTurmaDisciplinaOrientacaoCadastrados =
CLS_AlunoTurmaDisciplinaOrientacaoCurricularBO.SelecionaAlunosPorTurmaDisciplina(tud_id, bancoSincronizacao);
listaAlunoTurmaDisciplinaOrientacao =
alunoLista.Count > 0 ?
(from JObject aluno in alunoLista
let alu_id = (long)aluno.SelectToken("alu_id")
let ocr_id = (long)aluno.SelectToken("ocr_id")
let tpc_id = (int)aluno.SelectToken("tpc_id")
let aha_alcancada = (bool)aluno.SelectToken("aha_alcancada")
let aha_efetivada = (bool)aluno.SelectToken("aha_efetivada")
let dataAlteracao = Convert.ToDateTime(aluno.SelectToken("DataAlteracao") ?? new DateTime())
let entMtd = listaMatriculas.Find(p => p.alu_id == alu_id)
where entMtd != null && !entMtd.IsNew
let entAlunoTurmaOrientacao = listaAlunoTurmaDisciplinaOrientacaoCadastrados.Any(p => p.alu_id == entMtd.alu_id &&
p.mtu_id == entMtd.mtu_id &&
p.mtd_id == entMtd.mtd_id &&
p.ocr_id == ocr_id &&
p.tpc_id == tpc_id) ?
listaAlunoTurmaDisciplinaOrientacaoCadastrados.Find(p => p.alu_id == entMtd.alu_id &&
p.mtu_id == entMtd.mtu_id &&
p.mtd_id == entMtd.mtd_id &&
p.ocr_id == ocr_id &&
p.tpc_id == tpc_id) :
new CLS_AlunoTurmaDisciplinaOrientacaoCurricular()
let aha_id = entAlunoTurmaOrientacao != null && entAlunoTurmaOrientacao.aha_id > 0 ?
entAlunoTurmaOrientacao.aha_id :
-1
select new CLS_AlunoTurmaDisciplinaOrientacaoCurricular
{
tud_id = tud_id
,
alu_id = alu_id
,
mtu_id = entMtd.mtu_id
,
mtd_id = entMtd.mtd_id
,
ocr_id = ocr_id
,
tpc_id = tpc_id
,
aha_id = aha_id
,
aha_alcancada = entAlunoTurmaOrientacao.aha_dataAlteracao > dataAlteracao ? entAlunoTurmaOrientacao.aha_alcancada : aha_alcancada
,
aha_efetivada = entAlunoTurmaOrientacao.aha_dataAlteracao > dataAlteracao ? entAlunoTurmaOrientacao.aha_efetivada : aha_efetivada
,
aha_situacao = 1
,
aha_dataAlteracao = dataAlteracao
,
IsNew = aha_id <= 0
}).ToList() :
new List <CLS_AlunoTurmaDisciplinaOrientacaoCurricular>();
#endregion
#region Informações sobre planejamento das orientações curriculares nos bimestre
JArray planejamentoOrientacaoLista = ((JArray)planejamento.SelectToken("PlanejamentoOrientacaoCurricular") ?? new JArray());
listaPlanejamentoOrientacao =
planejamentoOrientacaoLista.Count > 0 ?
(from JObject planejamentoOrientacao in planejamentoOrientacaoLista
select new CLS_PlanejamentoOrientacaoCurricular
{
tud_id = tud_id
,
ocr_id = (long)planejamentoOrientacao.SelectToken("ocr_id")
,
tpc_id = (int)planejamentoOrientacao.SelectToken("tpc_id")
,
poc_planejado = (bool)planejamentoOrientacao.SelectToken("poc_planejado")
,
poc_trabalhado = (bool)planejamentoOrientacao.SelectToken("poc_trabalhado")
,
poc_alcancado = (bool)planejamentoOrientacao.SelectToken("poc_alcancado")
,
tdt_posicao = (byte)(planejamentoOrientacao.SelectToken("tdt_posicao") ?? 1)
}).ToList() :
new List <CLS_PlanejamentoOrientacaoCurricular>();
#endregion
#region Informações sobre o planejamento das orientações curriculares no ano anterior
JArray planejamentoOrientacaoDiagLista = ((JArray)planejamento.SelectToken("PlanejamentoOrientacaoCurricularDiagnostico") ?? new JArray());
listaPlanejamentoDiagnostico =
planejamentoOrientacaoDiagLista.Count > 0 ?
(from JObject diagnostico in planejamentoOrientacaoDiagLista
select new CLS_PlanejamentoOrientacaoCurricularDiagnostico
{
tud_id = tud_id
,
ocr_id = (long)diagnostico.SelectToken("ocr_id")
,
pod_alcancado = (bool)diagnostico.SelectToken("pod_alcancado")
,
tdt_posicao = (byte)(diagnostico.SelectToken("tdt_posicao") ?? 1)
}).ToList() :
new List <CLS_PlanejamentoOrientacaoCurricularDiagnostico>();
#endregion
}
#region Informações sobre os planejamentos anuais e/ou bimestrais
JArray TudPlanejamentoLista = ((JArray)planejamento.SelectToken("TurmaDisciplinaPlanejamento") ?? new JArray());
List <CLS_TurmaDisciplinaPlanejamento> ltPlanejamentoBanco = SelecionaListaPorTurmaDisciplina(tud_id, bancoSincronizacao);
foreach (JObject turmaPlanejamento in TudPlanejamentoLista)
{
DateTime tdp_dataAlteracao = Convert.ToDateTime(turmaPlanejamento.SelectToken("tdp_dataAlteracao").ToString());
if (tdp_dataAlteracao > DateTime.Now.AddMinutes(10))
{
throw new ValidationException("A data de alteração do planejamento é maior que a data atual.");
}
int tpc_id = (int)(turmaPlanejamento.SelectToken("tpc_id") ?? -1);
int tdp_id = (int)turmaPlanejamento.SelectToken("tdp_id");
byte tdt_posicao = (byte)(turmaPlanejamento.SelectToken("tdt_posicao") ?? 1);
CLS_TurmaDisciplinaPlanejamento planejamentoBanco = ltPlanejamentoBanco.Any(p => p.tud_id == tud_id && p.tdp_id == tdp_id && p.tdt_posicao == tdt_posicao) ?
ltPlanejamentoBanco.Find(p => p.tud_id == tud_id && p.tdp_id == tdp_id && p.tdt_posicao == tdt_posicao) :
new CLS_TurmaDisciplinaPlanejamento();
planejamentoBanco.IsNew = planejamentoBanco.tdp_id <= 0;
string tdp_planejamento = (turmaPlanejamento.SelectToken("tdp_planejamento") ?? string.Empty).ToString();
string tdp_diagnostico = (turmaPlanejamento.SelectToken("tdp_diagnostico") ?? string.Empty).ToString();
string tdp_avaliacaoTrabalho = (turmaPlanejamento.SelectToken("tdp_avaliacaoTrabalho") ?? string.Empty).ToString();
string tdp_recursos = (turmaPlanejamento.SelectToken("tdp_recursos") ?? string.Empty).ToString();
string tdp_intervencoesPedagogicas = (turmaPlanejamento.SelectToken("tdp_intervencoesPedagogicas") ?? string.Empty).ToString();
string tdp_registroIntervencoes = (turmaPlanejamento.SelectToken("tdp_registroIntervencoes") ?? string.Empty).ToString();
CLS_TurmaDisciplinaPlanejamento entPlanejamento = new CLS_TurmaDisciplinaPlanejamento();
if (!planejamentoBanco.IsNew)
{
entPlanejamento = planejamentoBanco;
}
else
{
entPlanejamento = new CLS_TurmaDisciplinaPlanejamento
{
tud_id = tud_id
,
tdp_id = -1
,
tpc_id = tpc_id
,
tdt_posicao = (byte)(turmaPlanejamento.SelectToken("tdt_posicao") ?? 1)
,
tdp_situacao = 1
,
pro_id = protocolo.pro_id
};
}
entPlanejamento.tdp_planejamento = RetornaValorTextoSincronizacao(tdp_planejamento, tdp_dataAlteracao, planejamentoBanco.tdp_planejamento, planejamentoBanco.tdp_dataAlteracao);
entPlanejamento.tdp_diagnostico = RetornaValorTextoSincronizacao(tdp_diagnostico, tdp_dataAlteracao, planejamentoBanco.tdp_diagnostico, planejamentoBanco.tdp_dataAlteracao);
entPlanejamento.tdp_avaliacaoTrabalho = RetornaValorTextoSincronizacao(tdp_avaliacaoTrabalho, tdp_dataAlteracao, planejamentoBanco.tdp_avaliacaoTrabalho, planejamentoBanco.tdp_dataAlteracao);
entPlanejamento.tdp_recursos = RetornaValorTextoSincronizacao(tdp_recursos, tdp_dataAlteracao, planejamentoBanco.tdp_recursos, planejamentoBanco.tdp_dataAlteracao);
entPlanejamento.tdp_intervencoesPedagogicas = RetornaValorTextoSincronizacao(tdp_intervencoesPedagogicas, tdp_dataAlteracao, planejamentoBanco.tdp_intervencoesPedagogicas, planejamentoBanco.tdp_dataAlteracao);
entPlanejamento.tdp_registroIntervencoes = RetornaValorTextoSincronizacao(tdp_registroIntervencoes, tdp_dataAlteracao, planejamentoBanco.tdp_registroIntervencoes, planejamentoBanco.tdp_dataAlteracao);
entPlanejamento.cur_id = entCrp.cur_id;
entPlanejamento.crr_id = entCrp.crr_id;
entPlanejamento.crp_id = entCrp.crp_id;
entPlanejamento.tdp_dataAlteracao = tdp_dataAlteracao;
listaPlanejamento.Add(entPlanejamento);
}
#endregion
if (!ACA_ParametroAcademicoBO.ParametroValorBooleanoPorEntidade(eChaveAcademico.PLANEJAMENTO_ANUAL_CICLO, Guid.Empty))
{
#region Salvar alcance dos alunos nas orientações curriculares
processou = CLS_AlunoTurmaDisciplinaOrientacaoCurricularBO.Salvar(listaAlunoTurmaDisciplinaOrientacao, bancoSincronizacao, true);
#endregion
}
#region Salvar os planejamentos anuais e bimestrais
processou |= CLS_PlanejamentoOrientacaoCurricularBO.SalvaPlanejamentoTurmaDisciplina(listaPlanejamento, listaPlanejamentoOrientacao, listaPlanejamentoDiagnostico, bancoSincronizacao, true);
#endregion
}
if (processou)
{
// 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;
}
else
{
if (protocolo.pro_tentativa > tentativasProtocolo)
{
throw new ValidationException(String.Format("Número máximo ({0}) de tentativas de processamento deste protocolo foram excedidas. Erro: {1}"
, tentativasProtocolo, protocolo.pro_statusObservacao));
}
// Não processou sem erro - volta o protocolo para não processado.
protocolo.pro_statusObservacao = String.Format("Protocolo não processado ({0}).",
DateTime.Now.ToString("dd/MM/yyyy hh:mm"));
protocolo.tur_id = -1;
protocolo.tud_id = -1;
protocolo.tau_id = -1;
protocolo.pro_qtdeAlunos = -1;
protocolo.pro_status = (byte)DCL_ProtocoloBO.eStatus.NaoProcessado;
}
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);
}
/// <summary>
/// Carrega dados de lançamento de frequência na tela.
/// Só carrega caso a disciplina não seja do tipo
/// complementação da regência.
/// </summary>
public void Carregar(bool proximo
, bool anterior
, bool inalterado
, ControleTurmas entitiesControleTurma
, int tpcId
, DateTime capDataInicio
, DateTime capDataFim
, byte tdtPosicao
, EnumTipoDocente tipoDocente
, long tudIdRelacionada
, bool permiteVisualizarCompensacao
, List <sPermissaoDocente> ltPermissaoFrequencia
, bool permiteLancarFrequencia
, out int countAulas
, int situacaoTurmaDisciplina
, ref bool permiteEdicao
, bool usuarioPermissao
, bool periodoEfetivado
, bool periodoAberto
, ref bool esconderSalvar
, ref int paginaFreq
, int tne_id
, string tur_ids = null)
{
countAulas = 0;
long tudId = entitiesControleTurma.turmaDisciplina.tud_id;
long turId = entitiesControleTurma.turma.tur_id;
int qtdAulasSemana = ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.QUANTIDADE_AULAS_LISTAO_FREQUENCIA, __SessionWEB.__UsuarioWEB.Usuario.ent_id);
DateTime dtInicio = new DateTime();
DateTime dtFim = new DateTime();
if (proximo)
{
paginaFreq++;
}
else if (anterior && paginaFreq > 1)
{
paginaFreq--;
}
else if (!inalterado)
{
paginaFreq = 1;
}
// Carregar tabela com aulas e frequências das aulas para os alunos.
VS_Aulas_Alunos =
CLS_TurmaAulaAlunoBO.GetSelectBy_TurmaDisciplina(tudId, tpcId,
(__SessionWEB.__UsuarioWEB.Docente.doc_id > 0 ? __SessionWEB.__UsuarioWEB.Usuario.usu_id : Guid.Empty),
capDataInicio, capDataFim, tdtPosicao, __SessionWEB.__UsuarioWEB.Docente.doc_id == 0, tudIdRelacionada, tur_ids);
int qtdAlunos = VS_Aulas_Alunos.GroupBy(p => new { p.alu_id, p.mtu_id }).Count();
int skip = qtdAulasSemana * (paginaFreq - 1) * qtdAlunos;
while (proximo && VS_Aulas_Alunos.Count < skip)
{
paginaFreq--;
skip = (qtdAulasSemana * (paginaFreq - 1)) * qtdAlunos;
if (paginaFreq == 1)
{
break;
}
}
//Quando carrega pela primeira vez e o bimestre é ativo então abre a página que possui a data atual
if (!proximo && !anterior && !inalterado && paginaFreq == 1 &&
capDataInicio <= DateTime.Today && capDataFim >= DateTime.Today)
{
while (VS_Aulas_Alunos.Skip(skip).Take(qtdAulasSemana * qtdAlunos).ToList().LastOrDefault().tau_data < DateTime.Today &&
VS_Aulas_Alunos.Skip(skip).Count() > (qtdAulasSemana * qtdAlunos))
{
paginaFreq++;
skip = (qtdAulasSemana * (paginaFreq - 1)) * qtdAlunos;
}
}
lkbProximo.Visible = VS_Aulas_Alunos.Skip(skip).Count() > (qtdAulasSemana * qtdAlunos);
lkbAnterior.Visible = skip > 0;
VS_Aulas_Alunos = VS_Aulas_Alunos.Skip(skip).Take(qtdAulasSemana * qtdAlunos).ToList();
dtInicio = VS_Aulas_Alunos.Count > 0 ? VS_Aulas_Alunos.FirstOrDefault().tau_data : capDataInicio.Date;
dtFim = VS_Aulas_Alunos.Count > 0 ? VS_Aulas_Alunos.LastOrDefault().tau_data : capDataFim.Date;
lblInicio.Text = dtInicio == new DateTime() ? "" : dtInicio.ToShortDateString();
lblFim.Text = dtFim == new DateTime() ? "" : dtFim.ToShortDateString();
// Carregar repeater de alunos.
rptAlunosFrequencia.DataSource = MTR_MatriculaTurmaDisciplinaBO.SelecionaAlunosAtivosCOCPorTurmaDisciplina(tudId,
tpcId, tipoDocente, false, capDataInicio, capDataFim, ApplicationWEB.AppMinutosCacheMedio, tur_ids)
.Where(p => ((p.mtd_dataSaida > dtInicio) || (p.mtd_dataSaida == null)) && (p.mtd_dataMatricula <= dtFim));
if (entitiesControleTurma.turma.tur_tipo == (byte)TUR_TurmaTipo.Normal)
{
lstAlunosRelatorioRP = CLS_RelatorioPreenchimentoAlunoTurmaDisciplinaBO.SelecionaAlunoPreenchimentoPorPeriodoDisciplina(tpcId, turId, tudId, ApplicationWEB.AppMinutosCacheMedio);
}
this.tudTipo = entitiesControleTurma.turmaDisciplina.tud_tipo;
this.permiteVisualizarCompensacao = permiteVisualizarCompensacao;
this.ltPermissaoFrequencia = ltPermissaoFrequencia;
this.permiteLancarFrequencia = permiteLancarFrequencia;
this.permiteEdicao = false;
this.situacaoTurmaDisciplina = situacaoTurmaDisciplina;
this.posicaoDocente = tdtPosicao;
this.usuarioPermissao = usuarioPermissao;
this.periodoEfetivado = periodoEfetivado;
this.periodoAberto = periodoAberto;
ACA_CurriculoPeriodo entityCrp = ACA_CurriculoPeriodoBO.SelecionaPorTurmaTipoNormal(turId, ApplicationWEB.AppMinutosCacheLongo);
this.crpControleTempo = entityCrp.crp_controleTempo;
this.possuiRegencia = TUR_TurmaBO.VerificaPossuiDisciplinaPorTipo(turId, TurmaDisciplinaTipo.Regencia, ApplicationWEB.AppMinutosCacheLongo);
this.tipoApuracaoFrequencia = entitiesControleTurma.formatoAvaliacao.fav_tipoApuracaoFrequencia;
this.tne_id = tne_id;
this.ttn_tipo = entitiesControleTurma.tipoTurno.ttn_tipo;
rptAlunosFrequencia.DataBind();
// Limpa o hiddenfield do listão de frequência pra zerar a ordenação.
hdnOrdenacaoFrequencia.Value = "";
//Fazendo as validações após carregar os dados.
if (rptAlunosFrequencia.Items.Count == 0)
{
EscondeGridAlunosFrequencia("Não foram encontrados alunos na turma selecionada.");
esconderSalvar = true;
}
else
{
MostraPeriodo(true);
pnlLancamentoFrequencias.Visible = true;
RepeaterItem header = (RepeaterItem)rptAlunosFrequencia.Controls[0];
Repeater rptAulas = (Repeater)header.FindControl("rptAulas");
lblMsgParecer.Visible = rptAulas.Items.Count > 0;
_lblMsgRepeater.Visible = rptAulas.Items.Count == 0;
if (rptAulas.Items.Count == 0)
{
_lblMsgRepeater.Text = UtilBO.GetErroMessage(GetGlobalResourceObject("Academico", "ControleTurma.Listao.MensagemSemAulas").ToString(),
UtilBO.TipoMensagem.Alerta);
esconderSalvar = true;
}
countAulas = rptAulas.Items.Count;
rptAlunosFrequencia.Visible = true;
}
if (this.permiteEdicao && !periodoEfetivado)
{
permiteEdicao = true;
}
}
/// <summary>
/// Carrega repeaters do boletim do aluno.
/// </summary>
/// <param name="listaNotasEFaltas">Lista com os dados do boletim.</param>
private void CarregaBoletim(ACA_AlunoBO.BoletimDadosAluno dadosBoletimAluno)
{
BoletimDados = dadosBoletimAluno.listaNotasEFaltas;
int cur_id = dadosBoletimAluno.cur_id;
int crr_id = dadosBoletimAluno.crr_id;
int crp_id = dadosBoletimAluno.crp_id;
List <ACA_CurriculoPeriodo> lstCurriculoPeriodo = ACA_CurriculoPeriodoBO.Seleciona_PeriodosRelacionados_Equivalentes(cur_id, crr_id, crp_id);
mostraConceitoGlobal = BoletimDados.Count(p => p.tud_global && p.mtu_id > 0) > 0;
// Seta nota ou conceito com base no tipo da escala de avaliacao
nomeNota = BoletimDados.Any(p => p.esa_tipo == 1) ? "Nota" : "Conceito";
lblNotasFaltas.Text = nomeNota + "s e Faltas";
decimal variacao = BoletimDados.FirstOrDefault().fav_variacao;
VS_FormatacaoPorcentagemFrequencia =
GestaoEscolarUtilBO.CriaFormatacaoDecimal(variacao > 0 ? GestaoEscolarUtilBO.RetornaNumeroCasasDecimais(variacao) : 2);
divBoletim.Visible = true;
if (ExibeCompensacaoAusencia)
{
var thTotalComp = new HtmlTableCell();
thTotalComp = (HtmlTableCell)divBoletim.FindControl("thTotalComp");
thTotalComp.Visible = true;
var thFreqFinal = new HtmlTableCell();
thFreqFinal = (HtmlTableCell)divBoletim.FindControl("thFreqFinal");
thFreqFinal.Visible = true;
var thTotalCompEnriquecimento = new HtmlTableCell();
thTotalCompEnriquecimento = (HtmlTableCell)divBoletim.FindControl("thTotalCompEnriquecimento");
thTotalCompEnriquecimento.Visible = true;
var thFreqFinalEnriquecimento = new HtmlTableCell();
thFreqFinalEnriquecimento = (HtmlTableCell)divBoletim.FindControl("thFreqFinalEnriquecimento");
thFreqFinalEnriquecimento.Visible = true;
var thFreqFinalRecuperacao = new HtmlTableCell();
thFreqFinalRecuperacao = (HtmlTableCell)divBoletim.FindControl("thFreqFinalRecuperacao");
thFreqFinalRecuperacao.Visible = true;
}
#region Periodos / COCs / Bimestres
var periodos = from BoletimAluno item in BoletimDados
orderby item.tpc_ordem
group item by item.tpc_id
into g
select
new
{
tpc_id = g.Key
,
g.First().tpc_nome
,
g.First().tpc_ordem
,
g.First().ava_idRec
,
g.First().ava_nomeRec
,
MatriculaPeriodo =
g.First().mtu_id > 0
? "Responsável pelo lançamento no " + g.First().tpc_nome + ": Turma " +
g.First().tur_codigo + " (" +
(ACA_ParametroAcademicoBO.ParametroValorBooleanoPorEntidade(eChaveAcademico.ORDENAR_ESCOLAS_POR_CODIGO, __SessionWEB.__UsuarioWEB.Usuario.ent_id)
? g.First().esc_codigo + " - " + g.First().esc_nome
: g.First().esc_nome)
+ ")"
: "Aluno não matriculado no " + g.First().tpc_nome
};
rptPeriodosNomes.DataSource = periodos;
rptPeriodosColunasFixas.DataSource = periodos;
rptPeriodosNomesEnriquecimento.DataSource = periodos;
rptPeriodosColunasFixasEnriquecimento.DataSource = periodos;
rptPeriodosNomesRecuperacao.DataSource = periodos;
rptPeriodosColunasFixasRecuperacao.DataSource = periodos;
rptPeriodosNomes.DataBind();
rptPeriodosColunasFixas.DataBind();
rptPeriodosNomesEnriquecimento.DataBind();
rptPeriodosColunasFixasEnriquecimento.DataBind();
rptPeriodosNomesRecuperacao.DataBind();
rptPeriodosColunasFixasRecuperacao.DataBind();
#endregion Periodos / COCs / Bimestres
#region Disciplinas
bool controleOrdemDisciplinas = ACA_ParametroAcademicoBO.ParametroValorBooleanoPorEntidade(eChaveAcademico.CONTROLAR_ORDEM_DISCIPLINAS,
__SessionWEB.__UsuarioWEB.Usuario.ent_id);
decimal FrequenciaFinalAjustadaRegencia = BoletimDados.LastOrDefault(p => ((p.tud_tipo == (byte)TurmaDisciplinaTipo.ComponenteRegencia ||
p.tud_tipo == (byte)TurmaDisciplinaTipo.Regencia) &&
(p.FrequenciaFinalAjustada > 0 && p.tpc_id == VS_tpc_id))).FrequenciaFinalAjustada;
int tpc_ordem = BoletimDados.FirstOrDefault(p => p.tpc_id == VS_tpc_id).tpc_ordem;
bool ultimoBimestre = BoletimDados.OrderByDescending(i => i.tpc_ordem).FirstOrDefault().tpc_id.Equals(VS_tpc_id);
var todasDisciplinas = (from BoletimAluno item in BoletimDados
where item.tur_id > 0
orderby item.tud_tipo, item.tud_global descending, item.Disciplina
group item by item.Disciplina
into g
select
new
{
tud_id = g.First().tud_id
,
Disciplina = g.First().nomeDisciplina
,
tds_ordem = g.First().tds_ordem
,
totalFaltas = g.First().tud_tipo == (byte)ACA_CurriculoDisciplinaTipo.DocenciaCompartilhada || g.Any(p => p.naoExibirFrequencia) ? "-" :
g.Any(p => p.NotaID > 0) ? (g.Sum(p => (p.mostraFrequencia && !p.naoExibirFrequencia && (p.NotaID > 0 || tipoComponenteRegencia(p.tud_tipo)) &&
p.tpc_ordem <= tpc_ordem) ? p.numeroFaltas : 0)).ToString() : "-"
,
ausenciasCompensadas = g.First().tud_tipo == (byte)ACA_CurriculoDisciplinaTipo.DocenciaCompartilhada || g.Any(p => p.naoExibirFrequencia) ? "-" :
g.Any(p => p.NotaID > 0) ? (g.Sum(p => p.tpc_ordem <= tpc_ordem ? p.ausenciasCompensadas : 0)).ToString() : "-"
,
FrequenciaFinalAjustada = g.Any(p => p.naoExibirFrequencia) ? "-" :
g.Any(p => p.NotaID > 0 && p.tpc_id == VS_tpc_id) ? ((FrequenciaFinalAjustadaRegencia > 0) ? FrequenciaFinalAjustadaRegencia :
g.LastOrDefault(p => p.FrequenciaFinalAjustada > 0 && p.tpc_id == VS_tpc_id).FrequenciaFinalAjustada).ToString(VS_FormatacaoPorcentagemFrequencia) : "-"
,
tud_Tipo = g.First().tud_tipo
,
g.First().tud_global
,
mostrarDisciplina = g.Count(p => p.MostrarLinhaDisciplina)
,
NotaTotal = g.First().NotaTotal
,
MediaFinal = (g.Any(p => p.naoExibirNota) || !ultimoBimestre) ? "-" : (!string.IsNullOrEmpty(g.Last().NotaResultado) ? g.Last().NotaResultado : "-")
,
regencia = g.First().tud_tipo == (byte)TurmaDisciplinaTipo.Regencia ||
g.First().tud_tipo == (byte)TurmaDisciplinaTipo.ComponenteRegencia ||
(g.First().tud_tipo == (byte)TurmaDisciplinaTipo.DocenteEspecificoComplementacaoRegencia &&
controleOrdemDisciplinas) ? 1 : 2
,
enriquecimentoCurricular = g.First().EnriquecimentoCurricular
,
parecerFinal = g.First().tud_tipo == (byte)ACA_CurriculoDisciplinaTipo.DocenciaCompartilhada ? "-" :
// Se for experiência, vai exibir o menor resultado do aluno (F, NF e nulo nessa ordem)
g.First().tud_tipo == (byte)ACA_CurriculoDisciplinaTipo.Experiencia ? g.OrderBy(p => p.ParecerFinal ?? "z").FirstOrDefault().ParecerFinal :
// Caso contrário, mantem o parecer final atual
g.Last().ParecerFinal
,
parecerConclusivo = g.Last().ParecerConclusivo
,
recuperacao = g.First().Recuperacao
,
disRelacionadas = g.First().disRelacionadas
,
notas = (
from per in periodos.ToList()
orderby per.tpc_ordem
select new
{
per.tpc_id
,
nota = (
from BoletimAluno bNota in BoletimDados
where
bNota.Disciplina == g.Key &&
bNota.tpc_id == per.tpc_id
select new
{
Nota = (
//
bNota.dda_id > 0 ? "-"
:
//
!bNota.mostraNota || bNota.naoExibirNota || (VS_tpc_id > 0 && bNota.tpc_id > VS_tpc_id)
? "-"
: (bNota.NotaNumerica
? bNota.avaliacao ??
"-"
: (bNota.
NotaAdicionalNumerica
? bNota.
avaliacaoAdicional ??
"-"
: bNota.esa_tipo == (byte)EscalaAvaliacaoTipo.Pareceres
? bNota.avaliacao ?? "-"
: "-")
)
).Replace(".", ",")
,
Conceito =
(
//
bNota.dda_id > 0 ? "-"
:
//
bNota.mostraConceito
? (bNota.NotaNumerica
? "-"
: bNota.avaliacao)
: "-")
,
bNota.tpc_id
,
bNota.NotaRP
,
numeroFaltas = bNota.tud_tipo == (byte)ACA_CurriculoDisciplinaTipo.DocenciaCompartilhada ? "-" :
// Se for "Experiência", faz contagem específica
bNota.tud_tipo == (byte)ACA_CurriculoDisciplinaTipo.Experiencia ?
((((bNota.cur_id == cur_id && bNota.crr_id == crr_id && bNota.crp_id == crp_id) || lstCurriculoPeriodo.Any(p => p.cur_id == bNota.cur_id && p.crr_id == bNota.crr_id && p.crp_id == bNota.crp_id)) &&
bNota.mostraFrequencia && !bNota.naoExibirFrequencia && bNota.tpc_id <= VS_tpc_id && (bNota.NotaID > 0 || bNota.numeroFaltas > 0))
? (g.Sum(p => (p.tpc_id == bNota.tpc_id) ? p.numeroFaltas : 0)).ToString() : "-")
:
// Caso contrário, mantem a contagem atual
((((bNota.cur_id == cur_id && bNota.crr_id == crr_id && bNota.crp_id == crp_id) || lstCurriculoPeriodo.Any(p => p.cur_id == bNota.cur_id && p.crr_id == bNota.crr_id && p.crp_id == bNota.crp_id)) &&
bNota.mostraFrequencia && !bNota.naoExibirFrequencia && bNota.tpc_id <= VS_tpc_id && (bNota.NotaID > 0 || bNota.numeroFaltas > 0)) ? bNota.numeroFaltas.ToString() : "-")
,
tud_Tipo = g.First().tud_tipo
}).FirstOrDefault()
})
}).ToList();
var disciplinas = (from item in todasDisciplinas
where !item.enriquecimentoCurricular && //Retira as que são de enriquecimento curricular
!item.recuperacao //Retira as recuperacoes
select item
);
// Realiza uma ordenação posterior em que so importa se a disciplina é ou nao regencia/componente da regencia para manter o agrupamento
var dispOrdenadas = from item in disciplinas
orderby item.regencia, controleOrdemDisciplinas ? item.tds_ordem.ToString() : item.Disciplina
select item;
// "Agrupa" a frequência das disciplinas componentes e complementares à regência.
QtComponenteRegencia = dispOrdenadas.Count(p => (tipoComponenteRegencia(p.tud_Tipo)) && p.mostrarDisciplina > 0);
// "Agrupa" a frequência das disciplinas
QtComponentes = dispOrdenadas.Count(p => (p.mostrarDisciplina > 0));
rptDisciplinas.DataSource = dispOrdenadas.Where(p => p.mostrarDisciplina > 0);
rptDisciplinas.DataBind();
#endregion Disciplinas
#region Disciplinas de enriquecimento curricular
var disciplinasEnriquecimentoCurricular = (from item in todasDisciplinas
where item.enriquecimentoCurricular && //Verifica se são de enriquecimento curricular
!item.recuperacao //Retira as recuperacoes
select item
);
if (disciplinasEnriquecimentoCurricular.Count() > 0)
{
divEnriquecimentoCurricular.Visible = true;
// Realiza uma ordenação posterior em que so importa se a disciplina é ou nao regencia/componente da regencia para manter o agrupamento
var dispOrdenadasEnriquecimento = from item in disciplinasEnriquecimentoCurricular
orderby item.regencia, controleOrdemDisciplinas ? item.tds_ordem.ToString() : item.Disciplina
select item;
rptDisciplinasEnriquecimentoCurricular.DataSource = dispOrdenadasEnriquecimento.Where(p => p.mostrarDisciplina > 0);
rptDisciplinasEnriquecimentoCurricular.DataBind();
}
else
{
divEnriquecimentoCurricular.Visible = false;
}
#endregion Disciplinas de enriquecimento curricular
#region Território do saber
if (!string.IsNullOrEmpty(dadosBoletimAluno.territorioSaber))
{
divTerritorioSaber.Visible = true;
string[] linhasTS = dadosBoletimAluno.linhaTerritorioSaber.Split(';');
string[] itensTS = dadosBoletimAluno.territorioSaber.Split(';');
int qtdMaxColunas = 5;// itensTS.Max(i => i.Split(',').Length);//tamanho fixo de 5 colunas
thTerritorioSaber.ColSpan = qtdMaxColunas;
Dictionary <string, DataTable> dicLinhasOrdenadas = new Dictionary <string, DataTable>();
for (int i = 0; i < linhasTS.Length; i++)
{
List <string> itemAdd = itensTS[i].Split(',').ToList();
while (itemAdd.Count < qtdMaxColunas)
{
itemAdd.Add("-");
}
DataTable dtAdd = new DataTable();
dtAdd.Columns.Add("territorio");
foreach (string t in itemAdd)
{
DataRow rowAdd = dtAdd.NewRow();
rowAdd["territorio"] = t;
dtAdd.Rows.Add(rowAdd);
}
dicLinhasOrdenadas.Add(linhasTS[i], dtAdd);
}
rptLinhasTerritorio.DataSource = dicLinhasOrdenadas.Select(t => new { linha = t.Key, itemTerritorio = t.Value });
rptLinhasTerritorio.DataBind();
}
else
{
divTerritorioSaber.Visible = false;
}
#endregion Território do saber
#region Recuperacao
var disciplinasRecuperacao = (from item in todasDisciplinas
where item.recuperacao //Seleciona as recuperacoes
select item
);
if (disciplinasRecuperacao.Count() > 0)
{
divRecuperacao.Visible = true;
var dispOrdenadasRecuperacao = from item in disciplinasRecuperacao
orderby item.regencia, controleOrdemDisciplinas ? item.tds_ordem.ToString() : item.Disciplina
select item;
rptDisciplinasRecuperacao.DataSource = disciplinasRecuperacao.Where(p => p.mostrarDisciplina > 0);
rptDisciplinasRecuperacao.DataBind();
}
else
{
divRecuperacao.Visible = false;
}
// Exibe a linha do parecer conclusivo caso seja o último bimestre selecionado, e o parecer tenha sido lançado.
if (ultimoBimestre && !String.IsNullOrEmpty(todasDisciplinas
.Where(p => p.tud_Tipo != (byte)ACA_CurriculoDisciplinaTipo.DisciplinaEletivaAluno)
.Last().parecerConclusivo))
{
trParecerConclusivo.Visible = true;
lblParecerConclusivoResultado.Visible = true;
lblParecerConclusivoResultado.Text = todasDisciplinas
.Where(p => p.tud_Tipo != (byte)ACA_CurriculoDisciplinaTipo.DisciplinaEletivaAluno)
.Last().parecerConclusivo;
}
else
{
trParecerConclusivo.Visible = false;
}
#endregion Recuperacao
#region Docencia compartilhada
if (DocenciasCompartilhadas.Any())
{
divDocenciaCompartilhada.Visible = true;
rptTudDocenciaCompartilhada.DataSource = DocenciasCompartilhadas;
rptTudDocenciaCompartilhada.DataBind();
}
else
{
divDocenciaCompartilhada.Visible = false;
}
#endregion
//#region Disciplinas do tipo Eletiva
//CarregarDisciplinasEletivas(dadosBoletimAluno);
//#endregion
#region Linha de Faltas
//var linhaFaltas = (from per in periodos.ToList()
// orderby per.tpc_ordem
// select new
// {
// tpc_id = per.tpc_id,
// nota = (from f in BoletimDados
// where f.tpc_id == per.tpc_id
// group f by f.tpc_id into g
// select
// g.Count(p => p.mostraFrequencia && (p.NotaID > 0 || p.tud_tipo == tipoComponenteRegencia)) > 0 ?
// (g.Sum(p => (p.mostraFrequencia && p.NotaID > 0
// && p.tud_tipo != tipoComponenteRegencia
// ) ? p.numeroFaltas : 0)
// + g.FirstOrDefault
// (p => p.tud_tipo == tipoComponenteRegencia
// ).numeroFaltas).ToString() : "-"
// ).FirstOrDefault()
// }
// ).ToList();
//LINHA TOTALIZADORA
//litLinhaFaltasTotal.Text = linhaFaltas.Count(p => string.IsNullOrEmpty(p.nota)) == linhaFaltas.Count() ?
// "-"
// : linhaFaltas.Where(p => p.nota != "-").Sum(p => Convert.ToInt32(p.nota)).ToString();
//rptFaltasPeriodo.DataSource = linhaFaltas;
//rptFaltasPeriodo.DataBind();
#endregion Linha de Faltas
}
/// <summary>
/// Carrega os curriculo período não excluídos logicamente
/// filtrados por curso, currículo e escola
/// </summary>
/// <param name="cur_id">ID de curso</param>
/// <param name="crr_id">ID de curriculo</param>
/// <param name="esc_id">ID de escola</param>
/// <param name="uni_id">ID de unidade</param>
public void CarregaPorCursoCurriculoEscola(int cur_id, int crr_id, int esc_id, int uni_id)
{
CarregarCombo(ACA_CurriculoPeriodoBO.GetSelect(cur_id, crr_id, esc_id, uni_id, __SessionWEB.__UsuarioWEB.Usuario.ent_id, ApplicationWEB.AppMinutosCacheLongo));
}
/// <summary>
/// Carrega os curriculo período
/// filtrados por curso e currículo e disciplina
/// </summary>
/// <param name="dis_id">ID da disciplina</param>
/// <param name="cur_id">ID do curso</param>
/// <param name="crr_id">ID do currículo</param>
public void CarregarPorCursoCurriculoDisciplina(int cur_id, int crr_id, int dis_id)
{
CarregarCombo(ACA_CurriculoPeriodoBO.Select_Por_Disciplina(dis_id, cur_id, crr_id));
}
/// <summary>
/// Carrega os curriculo período
/// filtrados por curso e currículo e turma disciplina
/// </summary>
/// <param name="cur_id">ID do curso</param>
/// <param name="crr_id">ID do currículo</param>
/// <param name="tud_id">ID da turma disciplina</param>
public void CarregarPorCursoCurriculoTurmaDisciplina(int cur_id, int crr_id, long tud_id)
{
CarregarCombo(ACA_CurriculoPeriodoBO.SelecionaPorCursoTurmaDisciplina(cur_id, crr_id, tud_id, __SessionWEB.__UsuarioWEB.Usuario.ent_id));
}
/// <summary>
/// Carrega os curriculo período
/// filtrados por curso e currículo e tipo ciclo
/// </summary>
/// <param name="cur_id">ID do curso</param>
/// <param name="crr_id">ID do currículo</param>
/// <param name="tci_id">ID do tipo do ciclo</param>
public void CarregarPorCursoCurriculoTipoCiclo(int cur_id, int crr_id, int tci_id)
{
CarregarCombo(ACA_CurriculoPeriodoBO.Select_Por_TipoCiclo(cur_id, crr_id, tci_id, __SessionWEB.__UsuarioWEB.Usuario.ent_id, ApplicationWEB.AppMinutosCacheLongo));
}
public new static bool Delete
(
MTR_ParametroTipoMovimentacaoCurriculoPeriodo entity
, Data.Common.TalkDBTransaction banco
, Guid ent_id
)
{
MTR_ParametroTipoMovimentacaoCurriculoPeriodoDAO dao = new MTR_ParametroTipoMovimentacaoCurriculoPeriodoDAO();
if (banco == null)
{
dao._Banco.Open(IsolationLevel.ReadCommitted);
}
else
{
dao._Banco = banco;
}
try
{
// Verifica se o curso período do parâmetro de movimentação pode ser deletado
if (GestaoEscolarUtilBO.VerificaIntegridadaChaveDupla("tmo_id", "tmp_id", entity.tmo_id.ToString(), entity.tmp_id.ToString(), "MTR_TipoMovimentacaoCurriculoPeriodo,MTR_ParametroTipoMovimentacaoCurriculoPeriodo", dao._Banco))
{
MTR_TipoMovimentacaoCurriculoPeriodo tmp = new MTR_TipoMovimentacaoCurriculoPeriodo {
tmo_id = entity.tmo_id, tmp_id = entity.tmp_id
};
MTR_TipoMovimentacaoCurriculoPeriodoBO.GetEntity(tmp, dao._Banco);
ACA_Curso cur = new ACA_Curso {
cur_id = tmp.cur_id
};
ACA_CursoBO.GetEntity(cur, dao._Banco);
ACA_CurriculoPeriodo crp = new ACA_CurriculoPeriodo {
cur_id = tmp.cur_id, crr_id = tmp.crr_id, crp_id = tmp.crp_id
};
ACA_CurriculoPeriodoBO.GetEntity(crp, dao._Banco);
throw new ValidationException("Não é possível excluir o(a) " + GestaoEscolarUtilBO.nomePadraoCurso(ent_id).ToLower() + " " + cur.cur_nome + " e " + GestaoEscolarUtilBO.nomePadraoPeriodo(ent_id).ToLower() + " " + crp.crp_descricao + " pois possui outros registros ligados a ele(a).");
}
// Deleta logicamente o parâmetro do curso período para parâmetro de movimentação
dao.Delete(entity);
return(true);
}
catch (Exception err)
{
if (banco == null)
{
dao._Banco.Close(err);
}
throw;
}
finally
{
if (banco == null)
{
dao._Banco.Close();
}
}
}
/// <summary>
/// Valida e configura se a turma destino possui a mesma avaliação turma atual do aluno.
/// </summary>
/// <param name="cadMov">Estrutura de movimentação</param>
/// <param name="progressaoPEJA">Verifica se o método é chamado pela tela de progressão</param>
/// <param name="bancoGestao">Transação com banco Gestão - obrigatório</param>
public static void ConfiguraTurmaAvaliacao(MTR_Movimentacao_Cadastro cadMov, bool progressaoPEJA, TalkDBTransaction bancoGestao)
{
List <ACA_CurriculoPeriodo> listPeriodosEquivalentes = ACA_CurriculoPeriodoBO.
Seleciona_PeriodosRelacionados_Equivalentes(cadMov.entAluCurAnterior.cur_id, cadMov.entAluCurAnterior.crr_id, cadMov.entAluCurAnterior.crp_id);
// Apenas valida a avaliação da turma caso seja o mesmo Curso/Período.
// Também verifica se os cursos são equivalentes
if (
((cadMov.entAluCurAnterior.cur_id == cadMov.entAluCurNovo.cur_id) &&
(cadMov.entAluCurAnterior.crr_id == cadMov.entAluCurNovo.crr_id) &&
(cadMov.entAluCurAnterior.crp_id == cadMov.entAluCurNovo.crp_id)) ||
(listPeriodosEquivalentes.Count > 0 && listPeriodosEquivalentes.Exists(p => p.cur_id == cadMov.entAluCurNovo.cur_id &&
p.crr_id == cadMov.entAluCurNovo.crr_id &&
p.crp_id == cadMov.entAluCurNovo.crp_id)))
{
// Apenas valida a avaliação da turma caso definido a turma destino.
if (cadMov.entMatTurNovo.tur_id > 0)
{
ACA_CurriculoPeriodo entityCurriculoPeriodo = new ACA_CurriculoPeriodo {
cur_id = cadMov.entAluCurAnterior.cur_id, crr_id = cadMov.entAluCurAnterior.crr_id, crp_id = cadMov.entAluCurAnterior.crp_id
};
ACA_CurriculoPeriodoBO.GetEntity(entityCurriculoPeriodo, bancoGestao);
TUR_TurmaCurriculoAvaliacao entityTurmaCurriculoAvaliacaoAtual = new TUR_TurmaCurriculoAvaliacao {
tur_id = cadMov.entAluCurAvaAnterior.tur_id, cur_id = cadMov.entAluCurAvaAnterior.cur_id, crr_id = cadMov.entAluCurAvaAnterior.crr_id, crp_id = cadMov.entAluCurAvaAnterior.crp_id, tca_id = cadMov.entAluCurAvaAnterior.tca_id
};
TUR_TurmaCurriculoAvaliacaoBO.GetEntity(entityTurmaCurriculoAvaliacaoAtual, bancoGestao);
if (entityTurmaCurriculoAvaliacaoAtual.tca_id > 0)
{
TUR_TurmaCurriculoAvaliacao entityTurmaCurriculoAvaliacaoDestino;
string msg;
if (!progressaoPEJA)
{
// Verifica se a turma destino possui a avaliação da turma origem.
entityTurmaCurriculoAvaliacaoDestino =
TUR_TurmaCurriculoAvaliacaoBO.SelecionaAvaliacaoExistenteParaTurma(cadMov.entMatTurNovo.tur_id,
cadMov.entAluCurNovo.cur_id,
cadMov.entAluCurNovo.crr_id,
cadMov.entAluCurNovo.crp_id,
entityTurmaCurriculoAvaliacaoAtual.tca_numeroAvaliacao);
msg = "A turma destino do aluno deve possuir o(a) mesmo(a) " +
GestaoEscolarUtilBO.nomePadraoPeriodoAvaliacao(entityCurriculoPeriodo.crp_nomeAvaliacao) + " atual do aluno.";
}
else
{
entityTurmaCurriculoAvaliacaoDestino = new TUR_TurmaCurriculoAvaliacao
{
tur_id = cadMov.entMatTurNovo.tur_id
,
cur_id = cadMov.entAluCurAvaNovo.cur_id
,
crr_id = cadMov.entAluCurAvaNovo.crr_id
,
crp_id = cadMov.entAluCurAvaNovo.crp_id
,
tca_id = cadMov.entAluCurAvaNovo.tca_id
};
TUR_TurmaCurriculoAvaliacaoBO.GetEntity(entityTurmaCurriculoAvaliacaoDestino, bancoGestao);
msg = "A turma destino do aluno não possui o(a) " +
GestaoEscolarUtilBO.nomePadraoPeriodoAvaliacao(entityCurriculoPeriodo.crp_nomeAvaliacao) + " configurada para o aluno.";
}
if ((entityTurmaCurriculoAvaliacaoDestino != null) && (entityTurmaCurriculoAvaliacaoDestino.tca_id > 0))
{
// Configura o currículo avaliação novo com mesma avaliação, caso necessário.
if (cadMov.entAluCurAvaNovo.tca_id <= 0)
{
cadMov.entAluCurAvaNovo.alu_id = cadMov.entAluCurNovo.alu_id;
cadMov.entAluCurAvaNovo.tur_id = entityTurmaCurriculoAvaliacaoDestino.tur_id;
cadMov.entAluCurAvaNovo.cur_id = entityTurmaCurriculoAvaliacaoDestino.cur_id;
cadMov.entAluCurAvaNovo.crr_id = entityTurmaCurriculoAvaliacaoDestino.crr_id;
cadMov.entAluCurAvaNovo.crp_id = entityTurmaCurriculoAvaliacaoDestino.crp_id;
cadMov.entAluCurAvaNovo.tca_id = entityTurmaCurriculoAvaliacaoDestino.tca_id;
}
}
else
{
throw new ValidationException(msg);
}
}
else
{
throw new ValidationException("Não é possível realizar essa movimentação, pois o aluno não possui " +
GestaoEscolarUtilBO.nomePadraoPeriodoAvaliacao(entityCurriculoPeriodo.crp_nomeAvaliacao) + " ativo(a) na turma.");
}
}
}
}
/// <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>
/// Validar idade do aluno de acordo com o CurriculoPeriodo no qual ele está inserido.
/// Valida a idade máxima ideal + a amplitude do parâmetro acadêmico ou o valor informado
/// no parâmetro amplitude.
/// Valida a idade mínima ideal quando informado através da flag validarIdadeMinima - quando
/// informada sempre valida usando a amplitudo passada por parâmetro na função.
/// </summary>
/// <param name="entity">Entidade AlunoCurriculo carregada</param>
/// <param name="bancoGestao">Transação com banco Gestão - obrigatório</param>
/// <param name="bancoCore">Transação com banco CoreSSO - opcional</param>
/// <param name="validarIdadeMinima">Flag que indica se é pra validar idade mínima também</param>
/// <param name="amplitude">Amplitude, se > 0, substitui a amplitude do parâmetro acadêmico</param>
/// <param name="ent_id">Id da entidade do usuário logado.</param>
/// <returns>Se idade válida</returns>
internal static bool ValidarIdadeIdeal
(
ACA_AlunoCurriculo entity
, TalkDBTransaction bancoGestao
, TalkDBTransaction bancoCore
, bool validarIdadeMinima
, int amplitude
, Guid ent_id
)
{
ACA_Aluno entAluno = new ACA_Aluno {
alu_id = entity.alu_id
};
ACA_AlunoBO.GetEntity(entAluno, bancoGestao);
if (entAluno.alu_situacao != Convert.ToByte(ACA_AlunoSituacao.Inativo))
{
if (entity.alc_situacao == Convert.ToByte(ACA_AlunoCurriculoSituacao.Ativo) ||
entity.alc_situacao == Convert.ToByte(ACA_AlunoCurriculoSituacao.EmMatricula))
{
ACA_CurriculoPeriodo entCurPer = new ACA_CurriculoPeriodo {
cur_id = entity.cur_id, crr_id = entity.crr_id, crp_id = entity.crp_id
};
ACA_CurriculoPeriodoBO.GetEntity(entCurPer, bancoGestao);
PES_Pessoa entPessoa = new PES_Pessoa {
pes_id = entAluno.pes_id
};
if (bancoCore == null)
{
PES_PessoaBO.GetEntity(entPessoa);
}
else
{
PES_PessoaBO.GetEntity(entPessoa, bancoCore);
}
// Quantidade de meses da idade máxima da criança cadastrada no CurrPeriodo.
int idadeMaxima = (entCurPer.crp_idadeIdealAnoFim * 12) + entCurPer.crp_idadeIdealMesFim;
if (amplitude > 0)
{
idadeMaxima += amplitude;
}
else
{
int pac_valor = ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.AMPLITUDE_IDADE_ALERTA, ent_id);
// Soma quantidade em meses do parâmetro de amplitude.
idadeMaxima += (pac_valor > 0 ? (pac_valor * 12) : 0);
}
// Valida a quantidade de meses da idade da criança.
int anos, meses, dias;
GestaoEscolarUtilBO.CalculaAniversarioCompleto(DateTime.Now, entPessoa.pes_dataNascimento, out anos, out meses, out dias);
int idade = (anos * 12) + meses;
if (idade > idadeMaxima)
{
anos = idadeMaxima / 12;
meses = idadeMaxima % 12;
string sAnos = anos > 0 ? (anos + (anos > 1 ? " anos" : " ano")) : string.Empty;
string sMeses = meses > 0 ? (anos > 0 ? " e " : "") + meses + (meses > 1 ? " meses" : " mês") : string.Empty;
throw new ACA_Aluno_ValidationException("A idade do aluno não pode ser maior que " + sAnos + sMeses + ".");
}
ACA_Curriculo curso = ACA_CurriculoBO.GetEntity(new ACA_Curriculo {
cur_id = entity.cur_id, crr_id = entity.crr_id
});
if (validarIdadeMinima &&
curso.crr_regimeMatricula == 3 &&
ACA_ParametroAcademicoBO.ParametroValorBooleanoPorEntidade(eChaveAcademico.VALIDAR_IDADE_MINIMA_PEJA, ent_id))
{
// Quantidade de meses da idade máxima da criança cadastrada no CurrPeriodo.
int idadeMinima = (entCurPer.crp_idadeIdealAnoInicio * 12) + entCurPer.crp_idadeIdealMesInicio;
idadeMinima -= amplitude;
if (idade < idadeMinima)
{
anos = idadeMinima / 12;
meses = idadeMinima % 12;
string sAnos = anos > 0 ? (anos + (anos > 1 ? " anos" : " ano")) : string.Empty;
string sMeses = meses > 0 ? (anos > 0 ? " e " : "") + meses + (meses > 1 ? " meses" : " mês") : string.Empty;
throw new ACA_Aluno_ValidationException("A idade do aluno não pode ser menor que " + sAnos + sMeses + ".");
}
}
}
}
return(true);
}
