/// <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="banco">Transação com banco de dados aberta</param>
/// <returns></returns>
internal static bool Save
(
List <CLS_TurmaAulaAluno> listTurmaAulaAluno
, List <CLS_TurmaAula> listTurmaAula
, List <sDadosAulaProtocolo> ltDadosAulasValidacao
, List <CLS_TurmaAula> ltAulasBanco
, TalkDBTransaction banco
)
{
// Recupera a lista de entidades CLS_TurmaAulaAluno para verificar se ela já existe.
List <CLS_TurmaAulaAluno> listaTurmaAulaAluno = new List <CLS_TurmaAulaAluno>();
ltDadosAulasValidacao.ForEach(p => listaTurmaAulaAluno.AddRange(p.ltTurmaAulaAluno));
DataTable dtTurmaAulaAluno = CLS_TurmaAulaAluno.TipoTabela_TurmaAulaAluno();
foreach (CLS_TurmaAulaAluno entityTurmaAulaAluno in listTurmaAulaAluno)
{
// 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;
}
Validate(entityTurmaAulaAluno, listTurmaAula);
if (entityTurmaAulaAluno.Validate())
{
dtTurmaAulaAluno.Rows.Add(TurmaAulaAlunoToDataRow(entityTurmaAulaAluno, dtTurmaAulaAluno.NewRow()));
}
else
{
throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entityTurmaAulaAluno));
}
}
// Salva os dados de todos os alunos na tabela CLS_TurmaAulaAluno
SalvaFrequenciaAlunos(dtTurmaAulaAluno, banco);
CLS_TurmaAulaBO.SalvarAulas(listTurmaAula, ltDadosAulasValidacao, ltAulasBanco, banco);
return(true);
}
/// <summary>
/// Salva o plano de aula
/// </summary>
/// <param name="lstTurmaAula"></param>
/// <param name="lstTurmaAulaPlanoDisc"></param>
/// <param name="lstTurmaAulaPlanoDiscDeletar"></param>
/// <returns></returns>
public static bool SalvarEmLote(List <CLS_TurmaAula> lstTurmaAula
, List <CLS_TurmaAulaPlanoDisciplina> lstTurmaAulaPlanoDisc
, List <CLS_TurmaAulaPlanoDisciplina> lstTurmaAulaPlanoDiscDeletar)
{
CLS_TurmaAulaPlanoDisciplinaDAO dao = new CLS_TurmaAulaPlanoDisciplinaDAO();
dao._Banco.Open(IsolationLevel.ReadCommitted);
try
{
DataTable dtTurmaAula = CLS_TurmaAula.TipoTabela_TurmaAula();
DataTable dtTurmaAulaPlanoDeletar = CLS_TurmaAulaPlanoDisciplina.TipoTabela_TurmaAulaPlanoDisciplina();
DataTable dtTurmaAulaPlanoSalvar = CLS_TurmaAulaPlanoDisciplina.TipoTabela_TurmaAulaPlanoDisciplina();
lstTurmaAula.ForEach(p =>
{
if (CLS_TurmaAulaBO.ValidarAula(p, new List <sDadosAulaProtocolo>(), new List <CLS_TurmaAula>()))
{
dtTurmaAula.Rows.Add(CLS_TurmaAulaBO.TurmaAulaToDataRow(p, dtTurmaAula.NewRow()));
}
});
if (lstTurmaAulaPlanoDisc != null)
{
lstTurmaAulaPlanoDiscDeletar.ForEach(p =>
{
dtTurmaAulaPlanoDeletar.Rows.Add(CLS_TurmaAulaPlanoDisciplinaBO.TurmaAulaToDataRow(p, dtTurmaAulaPlanoDeletar.NewRow()));
});
lstTurmaAulaPlanoDisc.ForEach(p =>
{
dtTurmaAulaPlanoSalvar.Rows.Add(CLS_TurmaAulaPlanoDisciplinaBO.TurmaAulaToDataRow(p, dtTurmaAulaPlanoSalvar.NewRow()));
});
}
bool retorno = dao.SalvarEmLote(dtTurmaAula, dtTurmaAulaPlanoDeletar, dtTurmaAulaPlanoSalvar);
return(retorno);
}
catch (Exception err)
{
dao._Banco.Close(err);
throw;
}
finally
{
dao._Banco.Close();
}
}
/// <summary>
/// Executa a sincronização dos dados alterados no diário de classe. (Aulas)
/// </summary>
public static void ExecJobAtualizaAulasDiarioClasse()
{
List <DCL_Protocolo> ltProtocolo = DCL_ProtocoloBO.SelecionaNaoProcessadosPorTipo
(DCL_ProtocoloBO.eTipo.Aula,
ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.QUANTIDADE_MAXIMA_BUSCA_PROTOCOLO_AULA, new Guid()));
ltProtocolo.ForEach(protocolo =>
{
// Marca o protocolo como "Em processamento".
protocolo.pro_status = (byte)DCL_ProtocoloBO.eStatus.EmProcessamento;
protocolo.pro_tentativa++;
});
DCL_ProtocoloBO.AtualizaListaProtocolos(ltProtocolo);
CLS_TurmaAulaBO.ProcessaProtocoloAulas(ltProtocolo, TENTATIVAS_PROCESSAMENTO_PROTOCOLO);
}
/// <summary>
/// Salva as notas das atividades dos alunos e a propriedade "tnt_efetivado" das
/// atividades.
/// <param name="ent_id">Id da entidade do usuário logado.</param>
/// <param name="fechamentoAutomatico">Indica se o fechamento é automático.</param>
/// </summary>
public static bool Save
(
List <CLS_TurmaNotaAluno> listTurmaNotaAluno
, List <CLS_TurmaNota> listTurmaNota
, List <CLS_AlunoAvaliacaoTurmaDisciplinaMedia> listAlunoAvaliacaoTurmaDisciplinaMedia
, long tur_id
, long tud_id
, int tpc_id
, int fav_id
, int tdt_posicao
, Guid ent_id
, List <CLS_TurmaAula> listTurmaAula
, bool fechamentoAutomatico
, Guid usu_id = new Guid()
, byte origemLogMedia = 0
, byte origemLogNota = 0
, byte tipoLogNota = 0
, long tud_idRegencia = -1
)
{
TalkDBTransaction banco = new CLS_TurmaNotaAlunoDAO()._Banco.CopyThisInstance();
banco.Open(IsolationLevel.ReadCommitted);
try
{
if (!CLS_TurmaAulaBO.AtualizarStatusAtividadeAvaliativa(listTurmaAula, banco))
{
throw new ValidationException("Erro ao salvar as notas.");
}
return(Save(listTurmaNotaAluno, listTurmaNota, listAlunoAvaliacaoTurmaDisciplinaMedia, tur_id, tud_id, tpc_id, fav_id, tdt_posicao, banco, ent_id, fechamentoAutomatico, usu_id, origemLogMedia, origemLogNota, tipoLogNota, tud_idRegencia));
}
catch (Exception err)
{
banco.Close(err);
throw;
}
finally
{
banco.Close();
}
}
public static bool SalvarAulaAnotacoesRecursos
(
CLS_TurmaAulaRegencia entity
, List <CLS_TurmaAulaRecursoRegencia> listTurmaAulaRecursoRegencia
, Guid ent_id
, bool turmaIntegral
, bool fechamentoAutomatico
, List <VigenciaCriacaoAulas> vigenciasCriacaoAulas
, CLS_TurmaAula entityTurmaAula = null
, List <CLS_TurmaAulaOrientacaoCurricular> listOriCurTurAula = null
, Guid usu_id = new Guid()
, byte origemLogAula = 0
, byte tipoLogAula = 0
)
{
CLS_TurmaAulaRecursoDAO dao = new CLS_TurmaAulaRecursoDAO();
dao._Banco.Open(IsolationLevel.ReadCommitted);
try
{
if (entityTurmaAula != null && !CLS_TurmaAulaBO.Save(entityTurmaAula, dao._Banco))
{
return(false);
}
if (listOriCurTurAula != null)
{
CLS_TurmaAulaOrientacaoCurricularBO.Salvar(listOriCurTurAula, dao._Banco);
}
return(SalvarAulaAnotacoesRecursos(entity, listTurmaAulaRecursoRegencia, dao._Banco, ent_id, turmaIntegral, fechamentoAutomatico, vigenciasCriacaoAulas, false, null, usu_id, origemLogAula, tipoLogAula));
}
catch (Exception err)
{
dao._Banco.Close(err);
throw;
}
finally
{
dao._Banco.Close();
}
}
/// <summary>
/// Exclusão de uma atribuição esporádica, verificando se tem aula criada na data de sua atribuição.
/// </summary>
/// <param name="entidade"></param>
/// <returns></returns>
public static bool ExcluirAtribuicaoEsporadica
(RHU_ColaboradorCargo entidade, long doc_id, Guid ent_id)
{
DataTable dtAulas = CLS_TurmaAulaBO.PesquisaPor_AtribuicaoEsporadica(entidade.col_id, entidade.crg_id, entidade.coc_id, null);
if (dtAulas.Rows.Count > 0)
{
throw new ValidationException("Não é possível excluir essa atribuição esporádica, pois o(a) docente fez registros de aula neste período.");
}
if (Delete(entidade))
{
// Limpar cache para a tela de atribuição de docentes.
GestaoEscolarUtilBO.LimpaCache(ESC_UnidadeEscolaBO.RetornaChaveCache_SelectEscolas_VisaoIndividual(doc_id, ent_id, 1));
GestaoEscolarUtilBO.LimpaCache(ESC_UnidadeEscolaBO.RetornaChaveCache_SelectEscolas_VisaoIndividual(doc_id, ent_id, 0));
GestaoEscolarUtilBO.LimpaCache(ESC_UnidadeEscolaBO.RetornaChaveCache_SelectEscolas_VisaoIndividual(doc_id, ent_id, 2));
return(true);
}
return(false);
}
/// <summary>
/// Salva no banco as frequências.
/// </summary>
public bool Salvar(out string msg
, bool periodoEfetivado
, bool periodoAberto
, ref List <int> lstTauSalvas
, ControleTurmas entitiesControleTurma
, DateTime dataUltimaAlteracao
, ref bool recarregarDataAula
, int tpc_id
, byte posicaoDocente
, bool permiteLancarFrequencia
, int situacaoTurmaDisciplina)
{
msg = "";
this.periodoEfetivado = periodoEfetivado;
if (ValidaFrequencias())
{
if (!periodoAberto)
{
throw new ValidationException(
String.Format(GetGlobalResourceObject("WebControls", "UCLancamentoFrequencia.FrequenciaDisponivelApenasConsulta").ToString(),
GestaoEscolarUtilBO.nomePadraoPeriodo_Calendario(__SessionWEB.__UsuarioWEB.Usuario.ent_id)));
}
List <CLS_TurmaAulaAluno> listTurmaAulaAluno = new List <CLS_TurmaAulaAluno>();
List <CLS_TurmaAula> listTurmaAula = new List <CLS_TurmaAula>();
RepeaterItem header = (RepeaterItem)rptAlunosFrequencia.Controls[0];
Repeater rptAulasEfetivado = (Repeater)header.FindControl("rptAulasEfetivado");
lstTauSalvas = new List <int>();
List <CLS_TurmaAula> listaTurmaAulaBD = new List <CLS_TurmaAula>();
if (rptAulasEfetivado.Items.Count > 0)
{
List <string> lstTauIdsSalvar = (from RepeaterItem item in rptAulasEfetivado.Items
select((Label)item.FindControl("lbltau_id")).Text).ToList();
listaTurmaAulaBD = CLS_TurmaAulaBO.SelecionarListaAulasPorIds(entitiesControleTurma.turmaDisciplina.tud_id, string.Join(",", lstTauIdsSalvar));
}
// Adiciona itens na lista de TurmaAula - só pra alterar o tau_efetivado.
foreach (RepeaterItem itemAtividade in rptAulasEfetivado.Items)
{
CheckBox chkEfetivado = (CheckBox)itemAtividade.FindControl("chkEfetivado");
int tau_id = Convert.ToInt32(((Label)itemAtividade.FindControl("lbltau_id")).Text);
DateTime tau_data = Convert.ToDateTime(((Label)itemAtividade.FindControl("lbltnt_data")).Text);
Guid usu_id_criou_aula = Guid.Empty;
Label lblUsuId = (Label)itemAtividade.FindControl("lblUsuId");
if (lblUsuId != null && !string.IsNullOrEmpty(lblUsuId.Text))
{
usu_id_criou_aula = new Guid(lblUsuId.Text);
}
bool permissaoAlteracao = permiteLancarFrequencia && Convert.ToBoolean(((HiddenField)itemAtividade.FindControl("hdnPermissaoAlteracao")).Value);
if (permissaoAlteracao && __SessionWEB.__UsuarioWEB.Docente.doc_id > 0)
{
permissaoAlteracao = (situacaoTurmaDisciplina == 1 || (situacaoTurmaDisciplina != 1 && __SessionWEB.__UsuarioWEB.Usuario.usu_id == usu_id_criou_aula));
}
permissaoAlteracao &= !periodoEfetivado;
if (permissaoAlteracao)
{
if ((entitiesControleTurma.turma.tur_situacao == (byte)TUR_TurmaSituacao.Encerrada ||
entitiesControleTurma.turma.tur_situacao == (byte)TUR_TurmaSituacao.Extinta) &&
entitiesControleTurma.turma.tur_dataEncerramento != new DateTime() &&
tau_data > entitiesControleTurma.turma.tur_dataEncerramento)
{
throw new ValidationException("Existem aulas com data maior que a data de encerramento da turma.");
}
CLS_TurmaAula ent = listaTurmaAulaBD.FirstOrDefault(p => p.tud_id == entitiesControleTurma.turmaDisciplina.tud_id && p.tau_id == tau_id);
if (!ent.IsNew && ent.tau_dataAlteracao > dataUltimaAlteracao)
{
recarregarDataAula = false;
throw new ValidationException(GetGlobalResourceObject("Academico", "ControleTurma.Listao.Validacao_Data_TurmaFrequencia").ToString());
}
lstTauSalvas.Add(tau_id);
ent.tau_efetivado = chkEfetivado.Checked;
ent.tau_statusFrequencia = (byte)(chkEfetivado.Checked ? CLS_TurmaAulaStatusFrequencia.Efetivada
: CLS_TurmaAulaStatusFrequencia.Preenchida);
ent.usu_idDocenteAlteracao = __SessionWEB.__UsuarioWEB.Usuario.usu_id;
ent.tpc_id = tpc_id;
listTurmaAula.Add(ent);
}
}
foreach (RepeaterItem itemAluno in rptAlunosFrequencia.Items)
{
rptAulasEfetivado = (Repeater)itemAluno.FindControl("rptAulas");
Int64 alu_id = Convert.ToInt64(((Label)itemAluno.FindControl("lblalu_id")).Text);
Int32 mtu_id = Convert.ToInt32(((Label)itemAluno.FindControl("lblmtu_id")).Text);
Int32 mtd_id = Convert.ToInt32(((Label)itemAluno.FindControl("lblmtd_id")).Text);
// Adiciona itens na lista de TurmaNota - só pra alterar o tnt_efetivado.
foreach (RepeaterItem itemAtividadeAluno in rptAulasEfetivado.Items)
{
Guid usu_id_criou_aula = Guid.Empty;
Label lblUsuId = (Label)itemAtividadeAluno.FindControl("lblUsuId");
if (lblUsuId != null && !string.IsNullOrEmpty(lblUsuId.Text))
{
usu_id_criou_aula = new Guid(lblUsuId.Text);
}
bool permiteAlteracao;
Boolean.TryParse(((HiddenField)itemAtividadeAluno.FindControl("hdnPermissaoAlteracao")).Value, out permiteAlteracao);
bool permissaoAlteracao = permiteLancarFrequencia && permiteAlteracao;
if (permissaoAlteracao && __SessionWEB.__UsuarioWEB.Docente.doc_id > 0)
{
permissaoAlteracao = (situacaoTurmaDisciplina == 1 || (situacaoTurmaDisciplina != 1 && __SessionWEB.__UsuarioWEB.Usuario.usu_id == usu_id_criou_aula));
}
permissaoAlteracao &= !periodoEfetivado;
if (permissaoAlteracao)
{
int tau_id = Convert.ToInt32(((Label)itemAtividadeAluno.FindControl("lbltau_id")).Text);
CheckBoxList cblFrequencia = (CheckBoxList)itemAtividadeAluno.FindControl("cblFrequencia");
int frequencia = 0;
string bitmap = "";
for (int i = 0; i < cblFrequencia.Items.Count; i++)
{
frequencia += cblFrequencia.Items[i].Selected ? 1 : 0;
bitmap += cblFrequencia.Items[i].Selected ? "1" : "0";
}
CLS_TurmaAulaAluno ent = new CLS_TurmaAulaAluno
{
tud_id = entitiesControleTurma.turmaDisciplina.tud_id
,
tau_id = tau_id
,
alu_id = alu_id
,
mtu_id = mtu_id
,
mtd_id = mtd_id
,
taa_frequencia = frequencia
,
taa_situacao = 1
,
taa_frequenciaBitMap = bitmap
};
listTurmaAulaAluno.Add(ent);
}
}
}
CLS_TurmaAulaAlunoBO.Save(listTurmaAulaAluno, listTurmaAula, entitiesControleTurma.turma.tur_id,
entitiesControleTurma.turmaDisciplina.tud_id, posicaoDocente,
entitiesControleTurma.turma, entitiesControleTurma.formatoAvaliacao,
entitiesControleTurma.curriculoPeriodo, __SessionWEB.__UsuarioWEB.Usuario.usu_id,
(byte)LOG_TurmaAula_Alteracao_Origem.WebListao, (byte)LOG_TurmaAula_Alteracao_Tipo.AlteracaoFreq, __SessionWEB.__UsuarioWEB.Usuario.ent_id);
try
{
ApplicationWEB._GravaLogSistema(LOG_SistemaTipo.Update, string.Concat(GetGlobalResourceObject("WebControls", "UCLancamentoFrequencia.Frequencia").ToString(),
"cal_id: ", entitiesControleTurma.turma.cal_id, " | tpc_id: ", tpc_id,
" | tur_id: ", entitiesControleTurma.turma.tur_id, "; tud_id: ", entitiesControleTurma.turmaDisciplina.tud_id));
}
catch (Exception ex)
{
ApplicationWEB._GravaErro(ex);
}
if (this.Recarregar != null)
{
this.Recarregar(false, false, false, true);
}
msg = UtilBO.GetErroMessage(GetGlobalResourceObject("WebControls", "UCLancamentoFrequencia.FrequanciaSalva").ToString(), UtilBO.TipoMensagem.Sucesso);
}
return(true);
}
public static bool Save
(
CLS_TurmaNota entity,
TUR_Turma entTurma,
DateTime cal_dataInicio,
DateTime cal_dataFim,
DateTime cap_dataInicio,
DateTime cap_dataFim,
Guid ent_id,
List <CLS_TurmaNotaOrientacaoCurricular> lstHabilidades,
bool fav_permiteRecuperacaoForaPeriodo,
CLS_TurmaAula entityTurmaAula = null,
CLS_TurmaNotaRegencia entityTurmaNotaRegencia = null,
bool validarDataAula = true,
Guid usu_id = new Guid(),
byte origemLogNota = 0,
byte tipoLogNota = 0
)
{
TalkDBTransaction banco = new CLS_TurmaNotaDAO()._Banco.CopyThisInstance();
banco.Open(IsolationLevel.ReadCommitted);
try
{
bool bRetorno = false;
// Caso tenha selecionado uma aula para vincular à atividade.
if (validarDataAula && entity.tnt_data == new DateTime())
{
CLS_TurmaAula entityAula = new CLS_TurmaAula
{
tud_id = entity.tud_id,
tau_id = entity.tau_id
};
CLS_TurmaAulaBO.GetEntity(entityAula, banco);
// Verifica se o usuário logado tem uma posição compatível à da aula.
if ((entity.tdt_posicao > 0) && (entity.tdt_posicao != entityAula.tdt_posicao))
{
throw new ValidationException("Você não tem permissão para vincular a nova atividade à esta data da aula.");
}
// Caso o usuário logado tenha selecionado uma aula para vincular e
// não seja um docente, copia a posição da aula.
entity.tdt_posicao = entityAula.tdt_posicao;
entity.usu_id = entityAula.usu_id;
}
// Caso o usuário logado não seja um docente, grava como posição 1.
if (entity.tdt_posicao < 1)
{
entity.tdt_posicao = 1;
}
if (entity.Validate())
{
// Verifica se a atividade foi alterada/excluída por outra pessoa enquanto o usuário tentava alterar a mesma.
CLS_TurmaNota entityAtividadeAuxiliar = new CLS_TurmaNota
{
tud_id = entity.tud_id,
tnt_id = entity.tnt_id
};
GetEntity(entityAtividadeAuxiliar, banco);
if (!entityAtividadeAuxiliar.IsNew)
{
entity.tdt_posicao = entityAtividadeAuxiliar.tdt_posicao;
entity.usu_id = entityAtividadeAuxiliar.usu_id;
}
if (entityAtividadeAuxiliar.tnt_dataAlteracao != entity.tnt_dataAlteracao)
{
throw new EditarAtividade_ValidationException("Esta atividade já foi alterada recentemente.");
}
string nomeAtividade = GestaoEscolarUtilBO.nomePadraoAtividadeAvaliativa(ent_id);
if (entity.tav_id <= 0 && string.IsNullOrEmpty(entity.tnt_nome) && ACA_ParametroAcademicoBO.ParametroValorPorEntidade(eChaveAcademico.NOME_TODAS_ATIVIDADES_AVALIATIVAS, ent_id) == "False")
{
throw new ArgumentException(string.Format("Outro tipo de {0} é obrigatório.", nomeAtividade.ToLower()));
}
CLS_TipoAtividadeAvaliativa entityAtividade = new CLS_TipoAtividadeAvaliativa();
if (entity.tav_id <= 0)
{
if (entity.tnt_nome.Length > 100)
{
throw new ArgumentException(nomeAtividade + " pode conter até 100 caracteres.");
}
}
else
{
entityAtividade.tav_id = entity.tav_id;
CLS_TipoAtividadeAvaliativaBO.GetEntity(entityAtividade, banco);
}
if (entity.tnt_situacao != Convert.ToByte(CLS_TurmaNotaSituacao.AtividadeCancelada) || (entityAtividadeAuxiliar.tnt_situacao == entity.tnt_situacao))
{
if ((entityAtividade.tav_situacao == Convert.ToByte(CLS_TipoAtividadeAvaliativaSituacao.Inativo)) && (entityAtividade.tav_id != entityAtividadeAuxiliar.tav_id))
{
throw new ArgumentException(string.Format("Tipo de {0} está inativo.", nomeAtividade.ToLower()));
}
}
CLS_TurmaNota avaRecuperacao = CLS_TurmaNotaBO.GetSelectRelacionadaFilho(entity.tud_id, entity.tnt_id, banco);
if (entity.tnt_data != new DateTime())
{
if (entTurma.tur_id <= 0)
{
entTurma = new TUR_Turma {
tur_id = entity.tur_id
};
TUR_TurmaBO.GetEntity(entTurma, banco);
}
// Compara as datas das avaliacoes relacionadas
bool relacionadaPai = false;
CLS_TurmaNota avaRelacionada = CLS_TurmaNotaBO.GetSelectRelacionadaFilho(entity.tud_id, entity.tnt_id, banco);
if (avaRelacionada.tnt_id > 0)
{
// se a data da recuperacao filho eh menor que a data da avaliacao pai...
if (avaRecuperacao.tnt_data != new DateTime() && avaRecuperacao.tnt_data < entity.tnt_data)
{
throw new ArgumentException(CustomResource.GetGlobalResourceObject("Academico", "LancamentoAvaliacao.UCCadastroAvaliacao.lblMessageAtividade.ValidacaoDataFilho").ToString());
}
}
else
{
avaRelacionada = CLS_TurmaNotaBO.GetSelectRelacionadaPai(entity.tud_id, entity.tnt_id);
relacionadaPai = avaRelacionada.tnt_id > 0;
avaRelacionada = CLS_TurmaNotaBO.GetSelectRelacionadaPai(entity.tud_id, entity.tnt_id, banco);
// se a data da avaliacao pai eh maior que a data da recuperacao filho...
if (avaRelacionada.tnt_id > 0 && avaRelacionada.tnt_data != new DateTime() && avaRelacionada.tnt_data > entity.tnt_data)
{
throw new ArgumentException(CustomResource.GetGlobalResourceObject("Academico", "LancamentoAvaliacao.UCCadastroAvaliacao.lblMessageAtividade.ValidacaoDataPai").ToString());
}
}
if (!(fav_permiteRecuperacaoForaPeriodo && relacionadaPai) &&
(entity.tnt_data > cal_dataFim || entity.tnt_data < cal_dataInicio))
{
throw new ArgumentException("A data da atividade deve estar dentro do período do calendário escolar (" + cal_dataInicio.ToString("dd/MM/yyyy") + " - " + cal_dataFim.ToString("dd/MM/yyyy") + ").");
}
if (!(fav_permiteRecuperacaoForaPeriodo && relacionadaPai) &&
(entity.tnt_data > cap_dataFim || entity.tnt_data < cap_dataInicio))
{
throw new ArgumentException("A data da atividade deve estar dentro do período do calendário (" + cap_dataInicio.ToString("dd/MM/yyyy") + " - " + cap_dataFim.ToString("dd/MM/yyyy") + ").");
}
}
// Valida se existe aluno com habilidade nao selecionada na avaliacao
if (entity.tnt_id > 0 && !CLS_TurmaNotaAlunoOrientacaoCurricularBO.ValidarHabilidadesAvaliacao(lstHabilidades, banco))
{
throw new ArgumentException(CustomResource.GetGlobalResourceObject("Academico", "LancamentoAvaliacao.UCCadastroAvaliacao.lblMessageAtividade.ValidaHabilidadesAluno").ToString());
}
// Valida se existe aluno na avaliacao de recuperacao, com habilidade
// que nao esta mais selecionada na avaliacao normal
if (avaRecuperacao.tnt_id > 0 && !CLS_TurmaNotaAlunoOrientacaoCurricularBO.ValidarHabilidadesAvaliacao(lstHabilidades, banco, avaRecuperacao.tnt_id))
{
throw new ArgumentException(CustomResource.GetGlobalResourceObject("Academico", "LancamentoAvaliacao.UCCadastroAvaliacao.lblMessageAtividade.ValidaHabilidadesAlunoRecuperacao").ToString());
}
CLS_ConfiguracaoAtividadeQualificador configQualificador = new CLS_ConfiguracaoAtividadeQualificador();
CLS_TurmaNotaDAO dao = new CLS_TurmaNotaDAO {
_Banco = banco
};
if (entity.IsNew && entity.tav_id > 0 && entityAtividade.qat_id > 0)
{
CLS_ConfiguracaoAtividadeQualificadorDAO configQualificadorDao = new CLS_ConfiguracaoAtividadeQualificadorDAO();
configQualificadorDao._Banco = banco;
configQualificador = configQualificadorDao.GetSelectByTudQualificador(entity.tud_id, entityAtividade.qat_id);
// Valida a quantidade configurada para o qualificador
if (configQualificador.caa_id > 0 && configQualificador.caq_quantidade >= 0)
{
if (dao.ValidaQuantidadeMaxima(entity.tud_id, entityAtividade.qat_id, entity.tpc_id, configQualificador.caq_quantidade))
{
throw new ArgumentException(CustomResource.GetGlobalResourceObject("Academico", "LancamentoAvaliacao.UCCadastroAvaliacao.lblMessageAtividade.ValidacaoQuantidade").ToString());
}
}
}
bRetorno = dao.Salvar(entity);
if (entity.IsNew &&
configQualificador.caa_id > 0 &&
configQualificador.caq_possuiRecuperacao)
{
int tavIdRelacionado = CLS_TipoAtividadeAvaliativaBO.SelecionaTipoAtividadeAvaliativaRelacionado(configQualificador.caa_id, configQualificador.qat_id, banco);
if (tavIdRelacionado > 0)
{
CLS_TurmaNota entityRelacionada = new CLS_TurmaNota();
entityRelacionada.tud_id = entity.tud_id;
entityRelacionada.IsNew = true;
entityRelacionada.tpc_id = entity.tpc_id;
entityRelacionada.tnt_situacao = 1;
entityRelacionada.tav_id = tavIdRelacionado;
entityRelacionada.tdt_posicao = entity.tdt_posicao;
entityRelacionada.tnt_exclusiva = false;
entityRelacionada.usu_id = entity.usu_id;
entityRelacionada.usu_idDocenteAlteracao = entity.usu_idDocenteAlteracao;
dao.Salvar(entityRelacionada);
CLS_TurmaNotaRelacionada entityRelacionamento = new CLS_TurmaNotaRelacionada();
entityRelacionamento.IsNew = true;
entityRelacionamento.tud_id = entity.tud_id;
entityRelacionamento.tnt_id = entity.tnt_id;
entityRelacionamento.tud_idRelacionada = entityRelacionada.tud_id;
entityRelacionamento.tnt_idRelacionada = entityRelacionada.tnt_id;
CLS_TurmaNotaRelacionadaBO.Save(entityRelacionamento, banco);
avaRecuperacao = entityRelacionada;
}
}
#region Salva as Orientacoes curriculares ligadas a avaliacao
if (bRetorno && lstHabilidades.Any())
{
lstHabilidades.ForEach(x => x.tnt_id = entity.tnt_id);
bRetorno = CLS_TurmaNotaOrientacaoCurricularBO.SalvarEmLote(lstHabilidades, banco);
// Copia as habilidades na avaliacao de recuperacao
if (avaRecuperacao.tnt_id > 0)
{
// Salva as Orientacoes curriculares ligadas a avaliacao - específico para recuperação.
lstHabilidades.ForEach(x => x.tnt_id = avaRecuperacao.tnt_id);
CLS_TurmaNotaOrientacaoCurricularBO.SalvarEmLote(lstHabilidades, banco);
}
}
#endregion Salva as Orientacoes curriculares ligadas a avaliacao
#region Salva a turma Aula
if (entityTurmaAula != null)
{
bRetorno = CLS_TurmaAulaBO.Save(entityTurmaAula, banco);
}
#endregion Salva a turma Aula
// Salva o vinculo com a aula, caso seja regência
if (entityTurmaNotaRegencia != null)
{
entityTurmaNotaRegencia.tnt_id = entity.tnt_id;
bRetorno = CLS_TurmaNotaRegenciaBO.Save(entityTurmaNotaRegencia, banco);
}
if (origemLogNota > 0 && tipoLogNota > 0)
{
DateTime dataLogNota = DateTime.Now;
LOG_TurmaNota_Alteracao entLogNota = new LOG_TurmaNota_Alteracao
{
tud_id = entity.tud_id,
tnt_id = entity.tnt_id,
usu_id = usu_id,
ltn_origem = origemLogNota,
ltn_tipo = tipoLogNota,
ltn_data = dataLogNota
};
LOG_TurmaNota_AlteracaoBO.Save(entLogNota, banco);
}
return(bRetorno);
}
throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entity));
}
catch (Exception err)
{
banco.Close(err);
throw;
}
finally
{
banco.Close();
}
}
/// <summary>
/// Salva anotações e recursos para os alunos.
/// </summary>
/// <param name="entity"></param>
/// <param name="listTurmaAulaRecursoRegencia"></param>
/// <param name="banco"></param>
/// <param name="ent_id">Id da entidade do usuário logado.</param>
/// <param name="turmaIntegral">Indica se a turma é integral.</param>
/// <param name="fechamentoAutomatico">Indica se o fechamento é automático.</param>
/// <param name="salvarFaltasAlunos"></param>
/// <returns></returns>
private static bool SalvarAulaAnotacoesRecursos
(
CLS_TurmaAulaRegencia entity
, List <CLS_TurmaAulaRecursoRegencia> listTurmaAulaRecursoRegencia
, TalkDBTransaction banco
, Guid ent_id
, bool turmaIntegral
, bool fechamentoAutomatico
, List <VigenciaCriacaoAulas> vigenciasCriacaoAulas
, bool salvarFaltasAlunos = false
, List <CLS_TurmaAulaOrientacaoCurricular> listOriCurTurAula = null
, Guid usu_id = new Guid()
, byte origemLogAula = 0
, byte tipoLogAula = 0
)
{
string mensagemInfo;
if (entity.tuf_data == new DateTime())
{
throw new ValidationException("Data da aula é obrigatório.");
}
// Chama método padrão para salvar a aula
if (entity.Validate())
{
Save(entity, banco);
}
else
{
throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entity));
}
if (origemLogAula > 0)
{
DateTime dataLogAula = DateTime.Now;
LOG_TurmaAula_Alteracao entLogAula = new LOG_TurmaAula_Alteracao
{
tud_id = entity.tud_id,
tau_id = entity.tau_id,
usu_id = usu_id,
lta_origem = origemLogAula,
lta_tipo = tipoLogAula,
lta_data = dataLogAula
};
LOG_TurmaAula_AlteracaoBO.Save(entLogAula, banco);
}
// regravo a CLS_TurmaAula apenas para atualizar o campo usu_idDocenteAlteracao, quando preenchido
if (entity.usu_idDocenteAlteracao != null)
{
CLS_TurmaAula entityAula = new CLS_TurmaAula
{
tud_id = entity.tud_id
,
tau_id = entity.tau_id
};
CLS_TurmaAulaBO.GetEntity(entityAula);
if (!entityAula.IsNew)
{
entityAula.usu_idDocenteAlteracao = entity.usu_idDocenteAlteracao;
CLS_TurmaAulaBO.Save(entityAula, banco, out mensagemInfo, ent_id, turmaIntegral, fechamentoAutomatico, vigenciasCriacaoAulas);
}
}
//Carrega Recursos gravados no banco
List <CLS_TurmaAulaRecursoRegencia> listaBanco = CLS_TurmaAulaRecursoRegenciaBO.GetSelectBy_Turma_Aula_DisciplinaComponente(entity.tud_id
, entity.tau_id
, entity.tud_idFilho);
//busca registros que devem ser excluidos
IEnumerable <Int32> dadosTela =
(from CLS_TurmaAulaRecursoRegencia dr in listTurmaAulaRecursoRegencia.AsEnumerable()
orderby dr.rsa_id descending
select dr.rsa_id).AsEnumerable();
IEnumerable <Int32> dadosExcluir =
(from CLS_TurmaAulaRecursoRegencia t in listaBanco.AsEnumerable()
orderby t.rsa_id descending
select t.rsa_id).Except(dadosTela);
IList <Int32> dadosDif = dadosExcluir.ToList();
//deleta registros que foram desmarcados
for (int i = 0; i < dadosDif.Count; i++)
{
CLS_TurmaAulaRecursoRegenciaBO.Delete_Byrsa_id(entity.tud_id, entity.tau_id, dadosDif[i]);
}
//busca registro que devem ser alterados
IEnumerable <Int32> dadosBanco =
(from CLS_TurmaAulaRecursoRegencia t in listaBanco.AsEnumerable()
orderby t.rsa_id descending
select t.rsa_id).AsEnumerable();
IEnumerable <Int32> dadosAlterar =
(from CLS_TurmaAulaRecursoRegencia t in listTurmaAulaRecursoRegencia.AsEnumerable()
orderby t.rsa_id descending
select t.rsa_id).Intersect(dadosBanco);
IList <Int32> dadosAlte = dadosAlterar.ToList();
CLS_TurmaAulaRecursoRegencia entityAltera;
for (int i = 0; i < dadosAlte.Count; i++)
{
entityAltera = listTurmaAulaRecursoRegencia.Find(p => p.rsa_id == dadosAlte[i]);
entityAltera.trr_dataAlteracao = DateTime.Now;
CLS_TurmaAulaRecursoRegenciaBO.Update_Byrsa_id(entityAltera);
listTurmaAulaRecursoRegencia.Remove(entityAltera);
}
// Salva as recursos utilizados na aula
foreach (CLS_TurmaAulaRecursoRegencia aux in listTurmaAulaRecursoRegencia)
{
aux.tau_id = entity.tau_id;
if (aux.Validate())
{
CLS_TurmaAulaRecursoRegenciaBO.Salvar(aux, banco);
}
else
{
throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(aux));
}
}
return(true);
}
/// <summary>
/// Gera as aulas do planejamento diário.
/// </summary>
/// <param name="tagsSalvar">Lista de CLS_TurmaAulaGerada para gravar</param>
/// <param name="doc_id">Docente para quem devem ser geradas as CLS_TurmaAula correspondentes</param>
/// <param name="usu_id">ID do usuário logado.</param>
/// <param name="ent_id">ID da entidade do usuário logado</param>
/// <param name="gerouTodasAulas">Flag que indica se todas as aulas foram salvas.</param>
/// <param name="ultrapassouCargaHorariaSemanal">Lista de alertas para os itens que não foram plenamente atendidos.</param>
/// <returns></returns>
public static bool GerarAulasPlanejamentoDiario
(
List <CLS_TurmaAulaGerada> tagsSalvar,
int tpc_id,
long doc_id,
DateTime?dataInicial,
DateTime?dataFinal,
Guid usu_id,
Guid ent_id,
Dictionary <long, string> dicTurmasDisciplinas,
out bool gerouTodasAulas,
out Dictionary <long, string> ultrapassouCargaHorariaSemanal,
out Dictionary <long, string> semVigencia,
out Dictionary <long, string> semAulasPrevistas,
out Dictionary <long, Exception> outrosErros,
byte origemLogAula = 0
)
{
gerouTodasAulas = true;
ultrapassouCargaHorariaSemanal = new Dictionary <long, string>();
semVigencia = new Dictionary <long, string>();
semAulasPrevistas = new Dictionary <long, string>();
outrosErros = new Dictionary <long, Exception>();
Dictionary <long, string> ultrapassouCargaHorariaSemanalTerritorio = new Dictionary <long, string>();
// armazenará os períodos de cada calendário
var dicPeriodosCalendario = new Dictionary <int, DataTable>();
// armazenará os dias não-úteis de cada escola
var dicDiasNaoUteis = new Dictionary <int, List <DateTime> >();
DateTime dataLimiteLancamento = new DateTime();
string dataBloqueio = ACA_ParametroAcademicoBO.ParametroValorPorEntidade(eChaveAcademico.DATA_VALIDADE_BLOQUEIO_ACESSO_MINHAS_TURMAS, ent_id);
if (!string.IsNullOrEmpty(dataBloqueio))
{
if (!DateTime.TryParse(dataBloqueio, out dataLimiteLancamento))
{
dataLimiteLancamento = new DateTime();
}
//throw new ValidationException("A data de bloqueio informada no parâmetro não é válida.");
}
#region Valida itens que bloqueiam toda a execução e preenche listas de calendários
// utilizadas na verificação de carga horária semanal, cuja soma precisa ser verificada por tud_id
long tud_id_anterior = 0;
int tud_cargaHorariaSemanal = 0;
foreach (var tag in tagsSalvar.OrderBy(tag => tag.tud_id))
{
if (tud_id_anterior != tag.tud_id)
{
tud_id_anterior = tag.tud_id;
tud_cargaHorariaSemanal = 0;
}
tud_cargaHorariaSemanal += tag.tag_numeroAulas;
if (tud_cargaHorariaSemanal > tag.tud_cargaHorariaSemanal)
{
throw new ValidationException(string.Format("{0} excede a carga horária semanal permitida.", dicTurmasDisciplinas[tag.tud_id]));
}
var cap_dataInicio = new DateTime();
var cap_dataFim = new DateTime();
#region Preenche as listas de calendários, cap_dataInicio e cap_dataFim
DataTable cal = null;
if (dicPeriodosCalendario.Any(i => i.Key == tag.cal_id))
{
cal = dicPeriodosCalendario.First(i => i.Key == tag.cal_id).Value;
}
else
{
cal = ACA_TipoPeriodoCalendarioBO.SelecionaTipoPeriodoCalendarioPorTipoPeriodoCalendario(tpc_id, tag.cal_id);
dicPeriodosCalendario.Add(tag.cal_id, cal);
}
cap_dataInicio = Convert.ToDateTime(cal.Rows[0]["cap_dataInicio"]);
cap_dataFim = Convert.ToDateTime(cal.Rows[0]["cap_dataFim"]);
if (!dicDiasNaoUteis.Any(i => i.Key == tag.esc_id))
{
dicDiasNaoUteis.Add(tag.esc_id, ACA_CalendarioPeriodoBO.SelecionaDiasNaoUteis(tag.esc_id, tag.uni_id, tag.cal_id, cap_dataInicio, cap_dataFim, ent_id));
}
#endregion
if (dataInicial.HasValue &&
(dataInicial < cap_dataInicio || dataInicial > cap_dataFim))
{
throw new ArgumentException(String.Format(CustomResource.GetGlobalResourceObject("BLL", "TurmaAula.ValidaDataInicioBimestre"),
cap_dataInicio.ToShortDateString(),
cap_dataFim.ToShortDateString()));
}
if (dataFinal.HasValue &&
(dataFinal < cap_dataInicio || dataFinal > cap_dataFim))
{
throw new ArgumentException(String.Format(CustomResource.GetGlobalResourceObject("BLL", "TurmaAula.ValidaDataFimBimestre"),
cap_dataInicio.ToShortDateString(),
cap_dataFim.ToShortDateString()));
}
}
#endregion
var dao = new CLS_TurmaAulaGeradaDAO();
foreach (var tud_id in tagsSalvar.Select(tag => tag.tud_id).Distinct())
{
var banco = dao._Banco.CopyThisInstance();
try
{
banco.Open(IsolationLevel.ReadCommitted);
#region Busca dados iniciais do tud.
var tagsByTud = tagsSalvar.Where(t => t.tud_id == tud_id).ToList();
var tud_tipo = tagsByTud.First().tud_tipo;
var fav_tipoApuracaoFrequencia = tagsByTud.First().fav_tipoApuracaoFrequencia;
var ttn_tipo = tagsByTud.First().ttn_tipo;
if (((tud_tipo == (byte)TurmaDisciplinaTipo.Regencia && fav_tipoApuracaoFrequencia != (byte)ACA_FormatoAvaliacaoTipoApuracaoFrequencia.TemposAula) ||
(tud_tipo == (byte)TurmaDisciplinaTipo.DisciplinaPrincipal && ttn_tipo != (byte)ACA_TipoTurnoBO.TipoTurno.Integral)) && tagsByTud.Any(tag => tag.tag_numeroAulas > 1))
{
throw new ValidationException(string.Format("A carga horária diária do componente {0} não deve ser maior que 1.", dicTurmasDisciplinas[tud_id]));
}
if (tud_tipo == (byte)TurmaDisciplinaTipo.DisciplinaPrincipal && ttn_tipo == (byte)ACA_TipoTurnoBO.TipoTurno.Integral && tagsByTud.Any(tag => tag.tag_numeroAulas > 2))
{
throw new ValidationException(string.Format("A carga horária diária do componente {0} não deve ser maior que 2.", dicTurmasDisciplinas[tud_id]));
}
tud_cargaHorariaSemanal = tagsByTud.First().tud_cargaHorariaSemanal;
var cal = dicPeriodosCalendario.First(i => i.Key == tagsByTud.First().cal_id).Value;
var inicio = dataInicial.GetValueOrDefault(Convert.ToDateTime(cal.Rows[0]["cap_dataInicio"]));
var fim = dataFinal.GetValueOrDefault(Convert.ToDateTime(cal.Rows[0]["cap_dataFim"]));
var cap_dataInicio = dataInicial.GetValueOrDefault(Convert.ToDateTime(cal.Rows[0]["cap_dataInicio"]));
var cap_dataFim = dataFinal.GetValueOrDefault(Convert.ToDateTime(cal.Rows[0]["cap_dataFim"]));
string tud_ids = tud_id.ToString();
List <TUR_TurmaDisciplinaTerritorio> territorios = null;
if (tagsByTud.First().tud_tipo == (byte)TurmaDisciplinaTipo.Experiencia)
{
territorios = TUR_TurmaDisciplinaTerritorioBO.SelecionaVigentesPorExperienciaPeriodo(tud_id, inicio, fim);
tud_ids = territorios.Aggregate(tud_ids, (a, i) => string.Format("{0};{1}", a, i.tud_idTerritorio));
// Quantidade de aulas máxima da experiência: quantidade de territórios ligados à ela.
tud_cargaHorariaSemanal = territorios.Count;
//if (tagsByTud.Sum(p => p.tag_numeroAulas) > tud_cargaHorariaSemanal)
//{
// throw new ValidationException(string.Format("A carga horária semanal do componente {0} não deve ser maior que {1}."
// , dicTurmasDisciplinas[tud_id], tud_cargaHorariaSemanal));
//}
}
// Recupera as CLS_TurmaAula que já existem no banco para o docente na turma e período informado
// Territórios do saber: se tud_id for relativo a uma experiência, buscará as aulas também dos territórios
var aulasBanco = CLS_TurmaAulaBO.SelecionaAulasAtividadesPor_DisicplinasDocentePeriodo(tud_ids, tpc_id, doc_id, banco).Rows.OfType <DataRow>().ToList();
// Recupera as disciplinas compartilhadas vigentes para o docente na turma
var lstDisciplinaCompartilhada = TUR_TurmaDisciplinaBO.SelectRelacionadaVigenteBy_DisciplinaCompartilhada(tud_id, 0, false, doc_id, banco);
var diasNaoUteis = dicDiasNaoUteis.First(i => i.Key == tagsByTud.First().esc_id).Value;
var aulasSalvar = new Dictionary <long[], CLS_TurmaAula>();
var aulasExcluir = new List <CLS_TurmaAula>();
// esta lista totalizará as aulas que *permanecerão* na semana
// (considerando também as que permanecerão inalteradas no banco)
// após as gravações das listas aulasSalvar e aulasExcluir
var aulasSemana = new List <CLS_TurmaAula>();
// variáveis usadas na geração de msgs de erro de vigência dos territórios do saber
bool temTerritorioVigente = true;
bool temTerritorioVigenteDiaAnterior = true;
DateTime vigenciaInicio = inicio;
DateTime vigenciaFim = inicio;
#endregion
while (inicio <= fim)
{
foreach (var tag in tagsByTud.Where(t => inicio.DayOfWeek == RetornaDiaSemana(t.tag_diaSemana)))
{
#region Percorre os dias da semana configurado com aula na agenda
if (!diasNaoUteis.Any(d => d.Date == inicio.Date))
{
#region Territórios do Saber - Recupera dados para verificações
//guarda os territórios que efetivamente estão vigentes para a experiência na data em questão
var territoriosVigentes = (territorios == null)
? null
: territorios.Where(t => t.tte_vigenciaInicio.Date <= inicio.Date && (t.tte_vigenciaFim == new DateTime() || t.tte_vigenciaFim.Date >= inicio.Date)).ToList();
//guarda as aulas que já estão criadas no banco para os territórios vigentes na data em questão
var aulasTerritoriosBanco = (territorios == null)
? null
: aulasBanco.Where(dr =>
territoriosVigentes.Select(t => t.tud_idTerritorio).Contains(Convert.ToInt64(dr["tud_id"])) &&
Convert.ToInt16(dr["tdt_posicao"]) == tag.tdt_posicao &&
Convert.ToDateTime(dr["tau_data"]) == inicio)
.Select(dr =>
new
{
PermiteAlterar = Convert.ToBoolean(dr["PermiteAlterar"]),
Aula = new CLS_TurmaAulaDAO().DataRowToEntity(dr, new CLS_TurmaAula())
})
.ToList();
#endregion
#region Recupera aulas existentes no banco de dados
var aulaBanco = aulasBanco
.Where(dr =>
Convert.ToInt64(dr["tud_id"]) == tag.tud_id &&
Convert.ToInt16(dr["tdt_posicao"]) == tag.tdt_posicao &&
Convert.ToDateTime(dr["tau_data"]) == inicio &&
(tag.tud_idRelacionada <= 0 || Convert.ToInt64(dr["tud_idRelacionada"]) == tag.tud_idRelacionada))
.Select(dr =>
new
{
/* Territórios do saber:
* só poderá editar a aula da experiência se ela E as aulas
* correspondentes de TODOS os territórios vigentes na data
* da aula puderem ser editadas também */
PermiteAlterar = Convert.ToBoolean(dr["PermiteAlterar"]) &&
(territorios == null ||
!aulasTerritoriosBanco.Any(a => !a.PermiteAlterar)),
Aula = new CLS_TurmaAulaDAO().DataRowToEntity(dr, new CLS_TurmaAula())
})
.FirstOrDefault();
#endregion
temTerritorioVigente = (territorios == null || territoriosVigentes.Count > 0);
if (tag.tag_numeroAulas > 0)
{
// Há aulas previstas para esse dia da semana
if (aulaBanco == null)
{
#region Cria aula
if (temTerritorioVigente)
{
var nova = new CLS_TurmaAula
{
tud_id = tag.tud_id,
tau_id = -1,
tur_id = tag.tur_id,
tpc_id = tpc_id,
tau_data = inicio,
tau_sequencia = -1,
tau_numeroAulas = tag.tag_numeroAulas,
tau_situacao = 1,
tdt_posicao = Convert.ToByte(tag.tdt_posicao > 0 ? tag.tdt_posicao : 1),
usu_id = usu_id,
IsNew = true,
tud_tipo = tag.tud_tipo
};
aulasSalvar.Add(new long[] { tag.tud_id, tag.tud_idRelacionada }, nova);
aulasSemana.Add(nova);
}
#endregion
}
else
{
if (aulaBanco.PermiteAlterar)
{
#region Altera aula existente
if (temTerritorioVigente)
{
aulaBanco.Aula.tau_numeroAulas = tag.tag_numeroAulas;
aulaBanco.Aula.tau_sequencia = -1;
aulaBanco.Aula.tur_id = tag.tur_id;
aulaBanco.Aula.IsNew = false;
aulaBanco.Aula.tud_tipo = tag.tud_tipo;
aulasSalvar.Add(new long[] { tag.tud_id, tag.tud_idRelacionada }, aulaBanco.Aula);
}
#endregion
}
else
{
gerouTodasAulas = false;
}
aulasSemana.Add(aulaBanco.Aula);
}
}
// Não há aulas previstas para esse dia da semana
// Exclui as aulas que já estão no calendário (quando possível)
else if (aulaBanco != null)
{
if (aulaBanco.PermiteAlterar)
{
if (territorios == null || territoriosVigentes.Count > 0)
{
aulaBanco.Aula.tur_id = tag.tur_id;
aulasExcluir.Add(aulaBanco.Aula);
}
else
{
// Se não vai excluir a aula, coloca na lista da semana para contabilizar quantidade de aulas.
aulasSemana.Add(aulaBanco.Aula);
}
}
else
{
gerouTodasAulas = false;
// Se não vai excluir a aula, coloca na lista da semana para contabilizar quantidade de aulas.
aulasSemana.Add(aulaBanco.Aula);
}
}
#region Territorios do saber - msg de vigência
if (temTerritorioVigente && !temTerritorioVigenteDiaAnterior)
{
string inicioFimTxt = "";
if (territorios != null && (territorios.Any(t => t.tte_vigenciaInicio.Date <= vigenciaInicio.Date) ||
territorios.Any(t => t.tte_vigenciaFim != new DateTime() && t.tte_vigenciaFim.Date < vigenciaFim.Date)))
{
if (!territorios.Any(t => t.tte_vigenciaInicio.Date <= vigenciaInicio.Date))
{
inicioFimTxt = vigenciaInicio.ToString("dd/MM/yyyy") + " - " +
territorios.Where(t => t.tte_vigenciaInicio.Date > vigenciaInicio.Date)
.OrderBy(t => t.tte_vigenciaInicio).First()
.tte_vigenciaInicio.ToString("dd/MM/yyyy");
}
if (territorios.Any(t => t.tte_vigenciaFim != new DateTime() && t.tte_vigenciaFim.Date < vigenciaFim.Date))
{
foreach (TUR_TurmaDisciplinaTerritorio tte in territorios.Where(t => t.tte_vigenciaFim != new DateTime() && t.tte_vigenciaFim.Date < vigenciaFim.Date)
.OrderBy(t => t.tte_vigenciaInicio))
{
inicioFimTxt += string.IsNullOrEmpty(inicioFimTxt) ? "" : " e ";
if (tte.tte_vigenciaFim.Date < vigenciaFim.Date)
{
inicioFimTxt += tte.tte_vigenciaFim.AddDays(1).ToString("dd/MM/yyyy") + " - " +
(territorios.Any(t => t.tte_vigenciaInicio > tte.tte_vigenciaFim.Date) ?
territorios.Where(t => t.tte_vigenciaInicio > tte.tte_vigenciaFim.Date)
.OrderBy(t => t.tte_vigenciaInicio).First()
.tte_vigenciaInicio.AddDays(-1).ToString("dd/MM/yyyy") :
vigenciaFim.ToString("dd/MM/yyyy"));
}
}
}
}
else
{
inicioFimTxt = vigenciaInicio.ToString("dd/MM/yyyy") + " - " + vigenciaFim.ToString("dd/MM/yyyy");
}
// mostra msg
if (semVigencia.ContainsKey(tud_id))
{
semVigencia[tud_id] = String.Format("{0}, {1}", semVigencia[tud_id], inicioFimTxt);
}
else
{
semVigencia.Add(tud_id, String.Format("{0}: {1}", dicTurmasDisciplinas[tud_id], inicioFimTxt));
}
}
if (temTerritorioVigente != temTerritorioVigenteDiaAnterior)
{
// reinicia contagem
vigenciaInicio = inicio;
}
temTerritorioVigenteDiaAnterior = temTerritorioVigente;
vigenciaFim = inicio;
#endregion
}
#endregion
}
// Ao final da semana ou do intervalo informado
if (inicio.DayOfWeek == DayOfWeek.Sunday || inicio == fim)
{
#region Grava os dados da semana
DateTime dataIniSemana;
DateTime dataFimSemana;
#region Calcula datas de início e final da semana em questão
if (inicio.DayOfWeek == DayOfWeek.Sunday)
{
dataIniSemana = inicio.AddDays(-7);
dataFimSemana = inicio.AddDays(-1);
}
else
{
dataIniSemana = inicio.AddDays((int)inicio.DayOfWeek * (-1));
dataFimSemana = fim.AddDays(((int)fim.DayOfWeek - (int)DayOfWeek.Saturday) * (-1));
}
#endregion
int quantidadeAulasDaSemana = aulasSalvar.Sum(p => p.Value.tau_numeroAulas);
if (dataIniSemana.Date < cap_dataInicio.Date)
{
// Somar com as aulas que estiverem cadastradas fora do tpc_id.
quantidadeAulasDaSemana += CLS_TurmaAulaBO.VerificaSomaNumeroAulasSemana
(tud_id, dataIniSemana, cap_dataInicio.Date.AddDays(-1),
banco, Convert.ToByte(tagsByTud.FirstOrDefault().tdt_posicao));
}
if (dataFimSemana.Date > cap_dataFim.Date)
{
// Somar com as aulas que estiverem cadastradas fora do tpc_id.
quantidadeAulasDaSemana += CLS_TurmaAulaBO.VerificaSomaNumeroAulasSemana
(tud_id, cap_dataFim.Date.AddDays(1), dataFimSemana,
banco, Convert.ToByte(tagsByTud.FirstOrDefault().tdt_posicao));
}
if ((aulasSalvar.Any() || aulasExcluir.Any()) &&
DateTime.Today >= dataLimiteLancamento &&
tud_tipo != (byte)ACA_CurriculoDisciplinaTipo.DocenciaCompartilhada &&
tud_tipo != (byte)ACA_CurriculoDisciplinaTipo.Experiencia &&
!semAulasPrevistas.ContainsKey(tud_id) &&
!TUR_TurmaDisciplinaAulaPrevistaBO.VerificaLancamento(tud_id, doc_id, tagsByTud.First().tur_id, tagsByTud.First().cal_id))
{
semAulasPrevistas.Add(tud_id, dicTurmasDisciplinas[tud_id]);
}
// Se extrapolou a qtde de horas na semana...
else if (quantidadeAulasDaSemana > tud_cargaHorariaSemanal)
{
// ... e há itens nas listas para gravar...
if (aulasSalvar.Any() || aulasExcluir.Any())
{
// ... gera mensagem de alerta ao usuário
if (ultrapassouCargaHorariaSemanal.ContainsKey(tud_id))
{
ultrapassouCargaHorariaSemanal[tud_id] = String.Format("{0}, {1} - {2}", ultrapassouCargaHorariaSemanal[tud_id], dataIniSemana.ToString("dd/MM/yyyy"), dataFimSemana.ToString("dd/MM/yyyy"));
}
else
{
ultrapassouCargaHorariaSemanal.Add(tud_id, String.Format("{0}: {1} - {2}", dicTurmasDisciplinas[tud_id], dataIniSemana.ToString("dd/MM/yyyy"), dataFimSemana.ToString("dd/MM/yyyy")));
}
}
}
else
{
bool gravouTodasTurmaAula = gerouTodasAulas;
bool ultrapassouTerritorios = false;
if (aulasExcluir.Any())
{
aulasExcluir.ForEach(tau => gravouTodasTurmaAula &= CLS_TurmaAulaBO.Delete(tau, banco, origemLogAula, (byte)LOG_TurmaAula_Alteracao_Tipo.ExclusaoAula, usu_id));
}
if (aulasSalvar.Any())
{
// Ligação da experiência com territórios nas aulas da semana.
List <TurmaAulaTerritorioDados> aulasTerritorios = new List <TurmaAulaTerritorioDados>();
Dictionary <long, int> dicTerritorios = new Dictionary <long, int>();
if (tagsByTud.FirstOrDefault().tud_tipo == (byte)TurmaDisciplinaTipo.Experiencia && territorios != null && territorios.Count > 0)
{
// Territórios vigentes dentro da semana.
var territoriosVigentes = territorios.Where
(t => t.tte_vigenciaInicio.Date <= dataFimSemana.Date &&
(t.tte_vigenciaFim == new DateTime() || t.tte_vigenciaFim.Date >= dataIniSemana.Date)).ToList();
if (aulasSalvar.Any(tau => tau.Value.tau_numeroAulas > territoriosVigentes.Count))
{
ultrapassouTerritorios = true;
if (ultrapassouCargaHorariaSemanal.ContainsKey(tud_id))
{
ultrapassouCargaHorariaSemanal[tud_id] = String.Format("{0}, {1} - {2}", ultrapassouCargaHorariaSemanal[tud_id], dataIniSemana.ToString("dd/MM/yyyy"), dataFimSemana.ToString("dd/MM/yyyy"));
}
else
{
ultrapassouCargaHorariaSemanal.Add(tud_id, String.Format("{0}: {1} - {2}", dicTurmasDisciplinas[tud_id], dataIniSemana.ToString("dd/MM/yyyy"), dataFimSemana.ToString("dd/MM/yyyy")));
}
}
}
if (!ultrapassouTerritorios)
{
ultrapassouCargaHorariaSemanalTerritorio = ultrapassouCargaHorariaSemanal;
aulasSalvar.ToList()
.ForEach(tau =>
{
gravouTodasTurmaAula &= /*(tau.Value.tud_tipo == (byte)TurmaDisciplinaTipo.Experiencia ? CLS_TurmaAulaBO.SalvarAulaTerritorio(tau.Value, banco): */
tau.Key[1] > 0
? CLS_TurmaAulaBO.Save(tau.Value, banco, lstDisciplinaCompartilhada.First(tdr => tdr.tud_id == tau.Key[1]), origemLogAula, (byte)LOG_TurmaAula_Alteracao_Tipo.AlteracaoAula, usu_id)
: CLS_TurmaAulaBO.Save(tau.Value, banco, origemLogAula, (byte)LOG_TurmaAula_Alteracao_Tipo.AlteracaoAula, usu_id);
if (tagsByTud.FirstOrDefault().tud_tipo == (byte)TurmaDisciplinaTipo.Experiencia && territorios != null && territorios.Count > 0)
{
// Territórios vigentes dentro da semana.
var territoriosVigentes = territorios.Where
(t => t.tte_vigenciaInicio.Date <= dataFimSemana.Date &&
(t.tte_vigenciaFim == new DateTime() || t.tte_vigenciaFim.Date >= dataIniSemana.Date)).ToList();
// Ligação da experiência com territórios nas aulas da semana.
aulasTerritorios = CLS_TurmaAulaTerritorioBO.SelecionaAulasTerritorioPorExperiencia
(tud_id, dataIniSemana, dataFimSemana, banco);
dicTerritorios =
(from TUR_TurmaDisciplinaTerritorio item in
territoriosVigentes.Where(t => !aulasTerritorios.Any(a => a.tud_idTerritorio == t.tud_idTerritorio &&
a.tau_idExperiencia != tau.Value.tau_id))
select new
{
tud_id = item.tud_idTerritorio
,
tud_nomeTerritorio = item.tud_nomeTerritorio
,
qtAulas = (from TurmaAulaTerritorioDados iAula in aulasTerritorios
where
iAula.tud_idExperiencia == item.tud_idExperiencia &&
iAula.tud_idTerritorio == item.tud_idTerritorio
select iAula.tud_idTerritorio).Count()
}).OrderBy(p => p.tud_nomeTerritorio).ToDictionary(p => p.tud_id, p => p.qtAulas);
//Se for uma edição de aula então pega apenas as aulas ligadas à ela
aulasTerritorios = aulasTerritorios.Where(a => a.tud_idExperiencia == tau.Value.tud_id &&
a.tau_idExperiencia == tau.Value.tau_id).ToList();
//Valida a carga horária da experiência
if (!dicTerritorios.Any() && !aulasTerritorios.Any())
{
gravouTodasTurmaAula &= false;
// ... gera mensagem de alerta ao usuário
if (ultrapassouCargaHorariaSemanalTerritorio.ContainsKey(tud_id))
{
ultrapassouCargaHorariaSemanalTerritorio[tud_id] = String.Format("{0}, {1} - {2}", ultrapassouCargaHorariaSemanalTerritorio[tud_id], dataIniSemana.ToString("dd/MM/yyyy"), dataFimSemana.ToString("dd/MM/yyyy"));
}
else
{
ultrapassouCargaHorariaSemanalTerritorio.Add(tud_id, String.Format("{0}: {1} - {2}", dicTurmasDisciplinas[tud_id], dataIniSemana.ToString("dd/MM/yyyy"), dataFimSemana.ToString("dd/MM/yyyy")));
}
}
else
{
// Verifica ligações com territórios quando a aula é de experiência.
CLS_TurmaAulaBO.CriaLigacoesTerritorios(usu_id, origemLogAula, tau.Value, banco, aulasTerritorios, dicTerritorios);
}
}
});
ultrapassouCargaHorariaSemanal = ultrapassouCargaHorariaSemanalTerritorio;
}
}
gerouTodasAulas &= gravouTodasTurmaAula;
}
aulasSalvar.Clear();
aulasExcluir.Clear();
aulasSemana.Clear();
#endregion
}
inicio = inicio.AddDays(1);
}
#region Territorios do saber - msg de vigência
if (!temTerritorioVigente)
{
string inicioFimTxt = "";
if (territorios != null && (territorios.Any(t => t.tte_vigenciaInicio.Date <= vigenciaInicio.Date) ||
territorios.Any(t => t.tte_vigenciaFim != new DateTime() && t.tte_vigenciaFim.Date < vigenciaFim.Date)))
{
if (!territorios.Any(t => t.tte_vigenciaInicio.Date <= vigenciaInicio.Date))
{
inicioFimTxt = vigenciaInicio.ToString("dd/MM/yyyy") + " - " +
territorios.Where(t => t.tte_vigenciaInicio.Date > vigenciaInicio.Date)
.OrderBy(t => t.tte_vigenciaInicio).First()
.tte_vigenciaInicio.ToString("dd/MM/yyyy");
}
if (territorios.Any(t => t.tte_vigenciaFim != new DateTime() && t.tte_vigenciaFim.Date < vigenciaFim.Date))
{
foreach (TUR_TurmaDisciplinaTerritorio tte in territorios.Where(t => t.tte_vigenciaFim != new DateTime() && t.tte_vigenciaFim.Date < vigenciaFim.Date)
.OrderBy(t => t.tte_vigenciaInicio))
{
inicioFimTxt += string.IsNullOrEmpty(inicioFimTxt) ? "" : " e ";
if (tte.tte_vigenciaFim.Date < vigenciaFim.Date)
{
inicioFimTxt += tte.tte_vigenciaFim.AddDays(1).ToString("dd/MM/yyyy") + " - " +
(territorios.Any(t => t.tte_vigenciaInicio > tte.tte_vigenciaFim.Date) ?
territorios.Where(t => t.tte_vigenciaInicio > tte.tte_vigenciaFim.Date)
.OrderBy(t => t.tte_vigenciaInicio).First()
.tte_vigenciaInicio.AddDays(-1).ToString("dd/MM/yyyy") :
vigenciaFim.ToString("dd/MM/yyyy"));
}
}
}
}
else
{
inicioFimTxt = vigenciaInicio.ToString("dd/MM/yyyy") + " - " + vigenciaFim.ToString("dd/MM/yyyy");
}
// Entra aqui somente qdo não há vigência na última data com aula para gerar
if (semVigencia.ContainsKey(tud_id))
{
semVigencia[tud_id] = String.Format("{0}, {1}", semVigencia[tud_id], inicioFimTxt);
}
else
{
semVigencia.Add(tud_id, String.Format("{0}: {1}", dicTurmasDisciplinas[tud_id], inicioFimTxt));
}
}
#endregion
bool gravouTodas = gerouTodasAulas;
tagsByTud.ForEach(tag => gravouTodas &= Save(tag, banco));
gerouTodasAulas &= gravouTodas;
CLS_TurmaAulaBO.AtualizarSequenciaAulasPorTurmaDisciplina(tud_id, banco);
// Caso o fechamento seja automático, grava na fila de processamento.
if (tagsByTud.First().fav_fechamentoAutomatico&& tagsByTud.First().tud_tipo != (byte)TurmaDisciplinaTipo.DocenteEspecificoComplementacaoRegencia && tpc_id != ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, ent_id))
{
CLS_AlunoFechamentoPendenciaBO.SalvarFilaFrequencia(tud_id, tpc_id, banco);
}
}
catch (Exception ex)
{
outrosErros.Add(tud_id, ex);
banco.Close(ex);
}
finally
{
if (banco.ConnectionIsOpen)
{
banco.Close();
}
}
}
return(true);
}
/// <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);
}
