/// <summary>
/// Salva uma lista de recursos de sala de aula.
/// </summary>
/// <param name="ltTurmaAulaRecurso"></param>
/// <param name="banco"></param>
/// <returns></returns>
public static bool SalvaRecursosAula
(
List <CLS_TurmaAulaRecurso> ltTurmaAulaRecurso,
TalkDBTransaction banco
)
{
DataTable dtTurmaAulaRecurso = CLS_TurmaAulaRecurso.TipoTabela_TurmaAulaRecurso();
ltTurmaAulaRecurso.ForEach(p =>
{
if (p.Validate())
{
dtTurmaAulaRecurso.Rows.Add(TurmaAulaRecursoToDataRow(p, dtTurmaAulaRecurso.NewRow()));
}
else
{
throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(p));
}
});
// Limpa o cache
ltTurmaAulaRecurso.ForEach(p => GestaoEscolarUtilBO.LimpaCache(retornarChave_GetSelectBy_Turma_Aula(p.tud_id, p.tau_id)));
return(banco == null ?
new CLS_TurmaAulaRecursoDAO().SalvaRecursosAula(dtTurmaAulaRecurso) :
new CLS_TurmaAulaRecursoDAO {
_Banco = banco
}.SalvaRecursosAula(dtTurmaAulaRecurso));
}
/// <summary>
/// Método que grava no banco a inclusao ou alteração
/// </summary>
/// <param name="entity">entidade a ser salva/alterada</param>
/// <param name="lista">lista de series que estao ligadas ao tipo de resultado</param>
/// <returns></returns>
public static bool Save(ACA_TipoResultado entity, IList <ACA_TipoResultadoCurriculoPeriodo> lista)
{
ACA_TipoResultadoDAO dao = new ACA_TipoResultadoDAO();
dao._Banco.Open(IsolationLevel.ReadCommitted);
try
{
if (Save(entity, dao._Banco))
{
DataTable dtCP = ACA_TipoResultadoCurriculoPeriodoBO.SelectBy_tpr_id(entity.tpr_id, dao._Banco);
// Busca e exclui os relacionamentos existentes
for (int i = 0; i < dtCP.Rows.Count; i++)
{
ACA_TipoResultadoCurriculoPeriodo entityCP = new ACA_TipoResultadoCurriculoPeriodo
{
cur_id = Convert.ToInt32(dtCP.Rows[i]["cur_id"]),
crr_id = Convert.ToInt32(dtCP.Rows[i]["crr_id"]),
crp_id = Convert.ToInt32(dtCP.Rows[i]["crp_id"]),
tpr_id = Convert.ToInt32(dtCP.Rows[i]["tpr_id"])
};
ACA_TipoResultadoCurriculoPeriodoBO.Delete(entityCP, dao._Banco);
GestaoEscolarUtilBO.LimpaCache(String.Format("{0}_{1}_{2}_{3}", ACA_TipoResultadoCurriculoPeriodoBO.Cache_TipoResultado, entityCP.cur_id, entityCP.crr_id, entityCP.crp_id));
}
// Valida se o mesmo curriculoperiodo ja esta cadastrado em outro tipo de resultado
foreach (ACA_TipoResultadoCurriculoPeriodo item in lista)
{
List <Struct_TipoResultado> listaTiposResultados = ACA_TipoResultadoCurriculoPeriodoBO.SelecionaTipoResultado(item.cur_id, item.crr_id, item.crp_id, (EnumTipoLancamento)entity.tpr_tipoLancamento, entity.tds_id);
if (listaTiposResultados.Count > 0)
{
Struct_TipoResultado tipoResultado = listaTiposResultados.FirstOrDefault(p => p.tpr_resultado == entity.tpr_resultado && p.tpr_id != entity.tpr_id);
if (tipoResultado.tpr_id > 0)
{
throw new ValidationException("A série " + tipoResultado.crp_descricao + " já esta cadastrada em outro tipo de resultado.");
}
}
item.tpr_id = entity.tpr_id;
ACA_TipoResultadoCurriculoPeriodoBO.Save(item, dao._Banco);
GestaoEscolarUtilBO.LimpaCache(String.Format("{0}_{1}_{2}_{3}", ACA_TipoResultadoCurriculoPeriodoBO.Cache_TipoResultado, item.cur_id, item.crr_id, item.crp_id));
}
}
}
catch (Exception err)
{
dao._Banco.Close(err);
throw err;
}
finally
{
if (dao._Banco.ConnectionIsOpen)
{
dao._Banco.Close();
}
}
return(true);
}
/// <summary>
/// Remove do cache a entidade.
/// </summary>
/// <param name="entity"></param>
public static void LimpaCache_PeloCurso(ACA_Curso entity)
{
if (HttpContext.Current != null)
{
GestaoEscolarUtilBO.LimpaCache(string.Format("ACA_Curriculo_GetEntity_{0}_", entity.cur_id));
}
}
/// <summary>
/// O método salva as observações por disciplina.
/// </summary>
/// <param name="tud_id">ID da turma disciplina.</param>
/// <param name="alu_id">ID do aluno.</param>
/// <param name="mtu_id">ID da matrícula turma do aluno.</param>
/// <param name="mtd_id">ID da matrícula turma disciplina do aluno.</param>
/// <param name="fav_id">ID do formato de avaliação.</param>
/// <param name="ava_id">ID da avaliação.</param>
/// <param name="ltObservacao">Lista de observações.</param>
/// <param name="banco"></param>
/// <returns></returns>
public static bool SalvarObservacao(long tud_id, long alu_id, int mtu_id, int mtd_id, int fav_id, int ava_id, CLS_AlunoAvaliacaoTurDis_Observacao observacao)
{
TalkDBTransaction banco = new CLS_AlunoAvaliacaoTurmaDisciplinaObservacaoDAO()._Banco.CopyThisInstance();
banco.Open(IsolationLevel.ReadCommitted);
try
{
if (observacao.entityObservacao != null && observacao.entityObservacao != new CLS_AlunoAvaliacaoTurmaDisciplinaObservacao())
{
Save(observacao.entityObservacao, banco);
}
// Limpa cache do fechamento, para atualizar o check.
GestaoEscolarUtilBO.LimpaCache(MTR_MatriculaTurmaDisciplinaBO.RetornaChaveCache_GetSelectBy_TurmaDisciplinaPeriodo(tud_id, fav_id, ava_id, string.Empty));
GestaoEscolarUtilBO.LimpaCache(MTR_MatriculaTurmaDisciplinaBO.RetornaChaveCache_GetSelectBy_TurmaDisciplinaPeriodoFiltroDeficiencia(tud_id, fav_id, ava_id, string.Empty));
return(true);
}
catch (ValidationException ex)
{
banco.Close(ex);
throw;
}
catch (Exception ex)
{
banco.Close(ex);
throw;
}
finally
{
if (banco.ConnectionIsOpen)
{
banco.Close();
}
}
}
public static bool AtualizaObjetoAprendizagem(int tci_id, bool tci_objetoAprendizagem)
{
ACA_TipoCicloDAO dao = new ACA_TipoCicloDAO();
GestaoEscolarUtilBO.LimpaCache(RetornaChaveCache_SelecionaTipoCicloAtivos());
GestaoEscolarUtilBO.LimpaCache("Cache_SelecionaTipoCicloAtivosEscola_");
return(dao.AtualizaObjetoAprendizagem(tci_id, tci_objetoAprendizagem));
}
/// <summary>
/// Remove todas tipo disciplinas relacionadas ao planejamento do projeto
/// </summary>
/// <param name="esc_id">ID da escola</param>
/// <param name="uni_id">ID da unidade escolar</param>
/// <param name="cal_id">ID do calendario</param>
/// <param name="cur_id">ID do curso</param>
/// <param name="plp_id">ID do planejamento do projeto</param>
/// <param name="banco">Transação do banco</param>
public static void LimparRelacionadas(int esc_id, int uni_id, int cal_id, int cur_id, int plp_id, TalkDBTransaction banco)
{
GestaoEscolarUtilBO.LimpaCache(string.Format(Cache_Seleciona_CursosRelacionados_Por_Escola + "_{0}_{1}_{2}_{3}", esc_id, uni_id, cal_id, cur_id));
CLS_PlanejamentoProjetoRelacionadaDAO dao = new CLS_PlanejamentoProjetoRelacionadaDAO();
dao._Banco = banco;
dao.LimparRelacionadas(esc_id, uni_id, cal_id, cur_id, plp_id);
}
/// <summary>
/// Salva as justificativas de pendencia em lote.
/// </summary>
/// <param name="dtFechamentoJustificativaPendencia">Tabela com os dados das justificativas.</param>
/// <returns></returns>
public static bool SalvarEmLote(List <CLS_FechamentoJustificativaPendencia> lstFechamentoJustificativaPendencia)
{
CLS_FechamentoJustificativaPendenciaDAO dao = new CLS_FechamentoJustificativaPendenciaDAO();
TalkDBTransaction banco = dao._Banco.CopyThisInstance();
banco.Open(IsolationLevel.ReadCommitted);
try
{
DataTable dtFechamentoJustificativaPendencia = CLS_FechamentoJustificativaPendencia.TipoTabela_FechamentoJustificativaPendencia();
lstFechamentoJustificativaPendencia.ForEach(p =>
{
DataRow drFechamentoJustificativaPendencia = dtFechamentoJustificativaPendencia.NewRow();
dtFechamentoJustificativaPendencia.Rows.Add(EntityToDataRow(p, drFechamentoJustificativaPendencia));
});
if (new CLS_FechamentoJustificativaPendenciaDAO {
_Banco = banco
}.SalvarEmLote(dtFechamentoJustificativaPendencia)
// Se tiver registro de inserção na tabela, atualizo a lista de pendências no fechamento.
&& lstFechamentoJustificativaPendencia.Any(p => p.fjp_id <= 0))
{
CLS_AlunoFechamentoPendenciaBO.SalvarFilaPendencias(
lstFechamentoJustificativaPendencia
.Select(p => new AlunoFechamentoPendencia
{
tud_id = p.tud_id,
tpc_id = p.tpc_id,
afp_frequencia = false,
afp_nota = false,
afp_processado = 2
})
.ToList()
, banco);
}
// Limpa o cache.
try
{
if (lstFechamentoJustificativaPendencia.Count > 0 && HttpContext.Current != null)
{
lstFechamentoJustificativaPendencia.ForEach(p => GestaoEscolarUtilBO.LimpaCache(string.Format(ModelCache.FECHAMENTO_JUSTIFICATIVA_PENDENCIA_MODEL_KEY, p.tud_id, p.cal_id, p.tpc_id)));
}
}
catch
{ }
return(true);
}
catch (Exception err)
{
banco.Close(err);
throw;
}
finally
{
banco.Close();
}
}
/// <summary>
/// Salva a entidade e realiza exclusão de possíves caches.
/// </summary>
/// <param name="entity">CLS_TurmaAulaRecursoRegencia</param>
/// <param name="banco">Conexão banco de dados</param>
/// <returns></returns>
public static bool Salvar(CLS_TurmaAulaRecursoRegencia entity, TalkDBTransaction banco)
{
string chave = retornarChave_GetSelectBy_Turma_Aula(entity.tud_id, entity.tau_id);
if (HttpContext.Current.Cache[chave] != null)
{
GestaoEscolarUtilBO.LimpaCache(chave);
}
return(Save(entity, banco));
}
/// <summary>
/// Deleta todos os relacionamentos da turma disciplina com objetos de aprendizagem
/// </summary>
/// <param name="tud_id">ID da turma disciplina</param>
/// <param name="banco">Transação do banco</param>
public static void DeletarObjTud(long tud_id, TalkDBTransaction banco = null)
{
GestaoEscolarUtilBO.LimpaCache("Cache_SelecionaTipoDisciplinaObjetosAprendizagem");
CLS_ObjetoAprendizagemTurmaDisciplinaDAO dao = new CLS_ObjetoAprendizagemTurmaDisciplinaDAO();
if (banco != null)
{
dao._Banco = banco;
}
dao.DeletarObjTud(tud_id);
}
/// <summary>
/// O método realiza as validações necessárias e salva uma orientação curricular.
/// </summary>
/// <param name="entity">Entidade que representa uma orientação curricular.</param>
/// <returns></returns>
public static new bool Save(ORC_OrientacaoCurricularNivelAprendizado entity, TalkDBTransaction banco)
{
if (entity.Validate())
{
GestaoEscolarUtilBO.LimpaCache(string.Format(ORC_OrientacaoCurricularNivelAprendizadoBO.Cache_SelecionaPorOrientacaoNivelAprendizado));
ORC_OrientacaoCurricularNivelAprendizadoDAO dao = new ORC_OrientacaoCurricularNivelAprendizadoDAO {
_Banco = banco
};
return(dao.Salvar(entity));
}
throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entity));
}
public static bool Excluir(CLS_FechamentoJustificativaPendencia fechamentoJustificativaPendencia)
{
CLS_FechamentoJustificativaPendenciaDAO dao = new CLS_FechamentoJustificativaPendenciaDAO();
TalkDBTransaction banco = dao._Banco.CopyThisInstance();
banco.Open(IsolationLevel.ReadCommitted);
try
{
if (CLS_FechamentoJustificativaPendenciaBO.Delete(fechamentoJustificativaPendencia, banco))
{
// Atualizo a lista de pendências no fechamento.
CLS_AlunoFechamentoPendenciaBO.SalvarFilaPendencias(
new List <AlunoFechamentoPendencia> {
new AlunoFechamentoPendencia
{
tud_id = fechamentoJustificativaPendencia.tud_id,
tpc_id = fechamentoJustificativaPendencia.tpc_id,
afp_frequencia = false,
afp_nota = false,
afp_processado = 2
}
}
, banco);
}
// Limpa o cache.
try
{
if (HttpContext.Current != null)
{
GestaoEscolarUtilBO.LimpaCache(string.Format(ModelCache.FECHAMENTO_JUSTIFICATIVA_PENDENCIA_MODEL_KEY, fechamentoJustificativaPendencia.tud_id, fechamentoJustificativaPendencia.cal_id, fechamentoJustificativaPendencia.tpc_id));
}
}
catch
{ }
return(true);
}
catch (Exception err)
{
banco.Close(err);
throw;
}
finally
{
banco.Close();
}
}
/// <summary>
/// Deleta recursos que foram desmarcados no cadastro
/// </summary>
/// <returns>True em caso de sucesso</returns>
public static bool Delete_Byrsa_id(long tud_id, int tau_id, int rsa_id, TalkDBTransaction banco)
{
string chave = retornarChave_GetSelectBy_Turma_Aula(tud_id, tau_id);
if (HttpContext.Current.Cache[chave] != null)
{
GestaoEscolarUtilBO.LimpaCache(chave);
}
CLS_TurmaAulaRecursoDAO dao = new CLS_TurmaAulaRecursoDAO()
{
_Banco = banco
};
return(dao.DeleteBy_rsa_id(tud_id, tau_id, rsa_id));
}
/// <summary>
///Altera recursos já existentes no banco
/// </summary>
/// <returns>True em caso de sucesso</returns>
public static bool Update_Byrsa_id(CLS_TurmaAulaRecurso entity, TalkDBTransaction banco)
{
string chave = retornarChave_GetSelectBy_Turma_Aula(entity.tud_id, entity.tau_id);
if (HttpContext.Current.Cache[chave] != null)
{
GestaoEscolarUtilBO.LimpaCache(chave);
}
CLS_TurmaAulaRecursoDAO dao = new CLS_TurmaAulaRecursoDAO()
{
_Banco = banco
};
return(dao.UpdateBy_rsa_id(entity));
}
/// <summary>
/// Salva o nivel de aprendizado
/// </summary>
/// <param name="entity">Entidade ORC_NivelAprendizado</param>
/// <param name="banco">Conexão aberta com o banco de dados</param>
/// <returns>True = incluído/alterado | False = não incluído/alterado</returns>
public new static bool Save(ORC_NivelAprendizado entity)
{
if (HttpContext.Current != null)
{
// Chave padrão do cache - nome do método + parâmetros.
HttpContext.Current.Cache.Remove(RetornaChaveCache_SelectNiveisAprendizadoAtivos(entity.cur_id, entity.crr_id, entity.crp_id));
HttpContext.Current.Cache.Remove(RetornaChaveCache_SelectNiveisAprendizadoAtivos(0, 0, 0));
}
GestaoEscolarUtilBO.LimpaCache(string.Format(ORC_OrientacaoCurricularNivelAprendizadoBO.Cache_SelecionaPorOrientacaoNivelAprendizado + "_{0}", entity.nap_id));
if (entity.Validate())
{
ORC_NivelAprendizadoDAO dao = new ORC_NivelAprendizadoDAO();
return(dao.Salvar(entity));
}
throw new ValidationException(entity.PropertiesErrorList[0].Message);
}
/// <summary>
/// O método realiza as validações necessárias e salva uma orientação curricular.
/// </summary>
/// <param name="entity">Entidade que representa uma orientação curricular.</param>
/// <returns></returns>
public static new bool Save(ORC_OrientacaoCurricular entity)
{
if (entity.Validate())
{
if (VerificaCodigoExistente(entity))
{
throw new DuplicateNameException("Já existe uma orientação curricular cadastrada com esse código.");
}
if (VerificaDescricaoExistente(entity))
{
throw new DuplicateNameException("Já existe uma orientação curricular cadastrada com essa descrição.");
}
GestaoEscolarUtilBO.LimpaCache(string.Format(ORC_OrientacaoCurricularNivelAprendizadoBO.Cache_SelecionaPorOrientacaoNivelAprendizado));
return(new ORC_OrientacaoCurricularDAO().Salvar(entity));
}
throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entity));
}
/// <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>
/// Remove do cache a entidade.
/// </summary>
/// <param name="entity"></param>
public static void LimpaCache(TUR_TurmaDocente entity, Guid ent_id, Int64 tur_id = 0)
{
if (HttpContext.Current != null)
{
// Chave padrão do cache - nome do método + parâmetros.
HttpContext.Current.Cache.Remove(RetornaChaveCache_SelecionaPosicaoPorDocenteTurma(entity.doc_id, entity.tud_id));
HttpContext.Current.Cache.Remove(RetornaChaveCache_SelecionaPosicaoPorDocenteTurma_ComInativos(entity.doc_id, entity.tud_id));
GestaoEscolarUtilBO.LimpaCache(TUR_TurmaDisciplinaBO.Cache_SelecionaDisciplinaPorTurmaDocente, entity.doc_id.ToString());
GestaoEscolarUtilBO.LimpaCache(TUR_TurmaDisciplinaBO.Cache_SelecionaDisciplinaPorTurmaDocente);
GestaoEscolarUtilBO.LimpaCache(TUR_TurmaDisciplinaBO.RetornaChaveCache_SelectRelacionadaVigenteBy_DisciplinaCompartilhada(entity.tud_id, entity.doc_id.ToString()));
CacheManager.Factory.RemoveByPattern(ModelCache.TURMA_DISCIPLINA_SELECIONA_DISCIPLINA_POR_TURMADOCENTE_SEM_VIGENCIA_PATTERN_KEY);
GestaoEscolarUtilBO.LimpaCache(TUR_TurmaBO.RetornaChaveCache_SelecionaPorDocenteControleTurma(ent_id.ToString(), entity.doc_id.ToString()));
GestaoEscolarUtilBO.LimpaCache(TUR_TurmaDisciplinaBO.RetornaChaveCache_SelectRelacionadaVigenteBy_DisciplinaCompartilhada(entity.tud_id, entity.doc_id.ToString()));
TUR_TurmaBO.RemoveCacheDocenteControleTurma(ent_id, entity.doc_id);
if (tur_id > 0)
{
TUR_TurmaBO.RemoveCacheDocente_TurmaDisciplina(tur_id, entity.doc_id, ent_id);
}
else
{
GestaoEscolarUtilBO.LimpaCache(TUR_TurmaDisciplinaBO.Cache_GetSelectBy_TurmaDocente, entity.doc_id.ToString());
}
GestaoEscolarUtilBO.LimpaCache(TUR_TurmaDisciplinaBO.RetornaChaveCache_SelectRelacionadaVigenteBy_DisciplinaCompartilhada(entity.tud_id, ""));
GestaoEscolarUtilBO.LimpaCache(TUR_TurmaDisciplinaBO.RetornaChaveCache_SelectRelacionadaVigenteBy_DisciplinaCompartilhada(entity.tud_id, entity.doc_id.ToString()));
GestaoEscolarUtilBO.LimpaCache(TUR_TurmaBO.RetornaChaveCache_DocenteControleTurmas(ent_id, entity.doc_id));
CacheManager.Factory.RemoveByPattern(string.Format("{0}_{1}_{2}",
ModelCache.TURMA_DISCIPLINA_SELECIONA_DISCIPLINA_POR_TURMADOCENTE_SEM_VIGENCIA_PATTERN_KEY,
tur_id, entity.doc_id));
if (ent_id != Guid.Empty)
{
GestaoEscolarUtilBO.LimpaCache(ESC_UnidadeEscolaBO.RetornaChaveCache_SelectEscolas_VisaoIndividual(entity.doc_id, ent_id, 1));
GestaoEscolarUtilBO.LimpaCache(ESC_UnidadeEscolaBO.RetornaChaveCache_SelectEscolas_VisaoIndividual(entity.doc_id, ent_id, 0));
}
}
}
public new static bool Save
(
ACA_TipoPeriodoCalendario entity
)
{
if (entity.IsNew)
{
entity.tpc_ordem = SelecionaMaiorOrdem() + 1;
}
if (entity.Validate())
{
if (VerificaTipoPeriodoCalendarioExistente(entity.tpc_id, entity.tpc_nome))
{
throw new DuplicateNameException("Já existe um tipo de período calendário cadastrado com este nome.");
}
if (!string.IsNullOrEmpty(entity.tpc_nomeAbreviado) && VerificaTipoPeriodoCalendarioExistenteAbreviado(entity.tpc_id, entity.tpc_nomeAbreviado))
{
throw new DuplicateNameException("Já existe um tipo de período calendário cadastrado com este nome abreviado.");
}
List <int> lstCalIds = SelecionaCalendarioPorTipoPeriodoCalendario(entity.tpc_id);
foreach (int cal in lstCalIds)
{
GestaoEscolarUtilBO.LimpaCache(string.Format(chaveCache_SelecionaPor_PeriodoVigente_EventoEfetivacaoVigente + "_{0}", cal.ToString()));
}
GestaoEscolarUtilBO.LimpaCache(TUR_TurmaDisciplinaBO.Cache_SelecionaDisciplinaPorTurmaDocente);
CacheManager.Factory.RemoveByPattern(ModelCache.TURMA_DISCIPLINA_SELECIONA_DISCIPLINA_POR_TURMADOCENTE_SEM_VIGENCIA_PATTERN_KEY);
ACA_TipoPeriodoCalendarioDAO dao = new ACA_TipoPeriodoCalendarioDAO();
return(dao.Salvar(entity));
}
throw new ValidationException(entity.PropertiesErrorList[0].Message);
}
/// <summary>
/// Remove do cache a entidade.
/// </summary>
/// <param name="entity"></param>
private static void LimpaCache(ACA_EscalaAvaliacaoParecer entity)
{
CacheManager.Factory.Remove(RetornaChaveCache_GetEntity(entity));
CacheManager.Factory.Remove(RetornaChaveCache_GetSelectBy_Escala(entity.esa_id));
GestaoEscolarUtilBO.LimpaCache(ModelCache.ESCALA_AVALIACAO_RETORNA_ORDEM_PARECER_MODEL_KEY, entity.esa_id.ToString());
}
/// <summary>
/// Salva os objetos de aprendizagem da turma disciplina
/// </summary>
/// <param name="listObjTudDis">Lista de objetos selecionados</param>
/// <param name="tud_ids">IDs da turma disciplina</param>
/// <param name="cal_id">ID do calendário</param>
/// <param name="banco">Transação do banco</param>
public static void SalvarLista(List <CLS_ObjetoAprendizagemTurmaDisciplina> listObjTudDis, List <long> tud_ids, int cal_id, TalkDBTransaction banco = null, long tud_idRegencia = -1)
{
CLS_ObjetoAprendizagemTurmaDisciplinaDAO dao = new CLS_ObjetoAprendizagemTurmaDisciplinaDAO();
if (banco != null)
{
dao._Banco = banco;
}
else
{
dao._Banco.Open(IsolationLevel.ReadCommitted);
}
try
{
foreach (long tud_id in tud_ids)
{
DeletarObjTud(tud_id, dao._Banco);
}
foreach (CLS_ObjetoAprendizagemTurmaDisciplina oad in listObjTudDis)
{
Save(oad, dao._Banco);
}
GestaoEscolarUtilBO.LimpaCache("Cache_SelecionaTipoDisciplinaObjetosAprendizagem");
if (ACA_FormatoAvaliacaoBO.CarregarPorTud(tud_ids.First(), dao._Banco).fav_fechamentoAutomatico)
{
List <int> lstTpc = ACA_TipoPeriodoCalendarioBO.CarregarPeriodosAteDataAtual(cal_id, tud_ids.First())
.AsEnumerable().Select(p => new { tpc_id = Convert.ToInt32(p["tpc_id"]) })
.GroupBy(p => p.tpc_id).Select(p => p.Key).ToList();
foreach (int tpc_id in lstTpc)
{
foreach (long tud_id in tud_ids)
{
CLS_AlunoFechamentoPendenciaBO.SalvarFilaPendencias(tud_id, tpc_id, dao._Banco);
}
if (tud_idRegencia > 0)
{
CLS_AlunoFechamentoPendenciaBO.SalvarFilaPendencias(tud_idRegencia, tpc_id, dao._Banco);
}
}
}
}
catch (Exception ex)
{
if (banco == null)
{
dao._Banco.Close(ex);
}
throw;
}
finally
{
if (banco == null)
{
dao._Banco.Close();
}
}
}
/// <summary>
/// Salva o objeto de aprendizagem
/// </summary>
/// <param name="entity">Entidade do objeto de aprendizagem</param>
/// <param name="listTci_ids">Lista de ciclos</param>
public static void Save(ACA_ObjetoAprendizagem entity, List <int> listTci_ids)
{
ACA_ObjetoAprendizagemDAO dao = new ACA_ObjetoAprendizagemDAO();
dao._Banco.Open(IsolationLevel.ReadCommitted);
try
{
if (entity.Validate())
{
bool isNew = entity.oap_id <= 0;
if (VerificaObjetoMesmoNome(entity.oap_id, entity.tds_id, entity.cal_ano, entity.oae_id, entity.oap_descricao, dao._Banco))
{
throw new ValidationException("Já existe um objeto de conhecimento cadastrado com a mesma descrição no eixo.");
}
Save(entity, dao._Banco);
List <ACA_ObjetoAprendizagemTipoCiclo> list = listTci_ids.Select(x => new ACA_ObjetoAprendizagemTipoCiclo
{
oap_id = entity.oap_id,
tci_id = x
}).ToList();
if (isNew)
{
Dictionary <int, string> lstCiclosEmUso = ACA_ObjetoAprendizagemTipoCicloBO.CiclosEmUso(entity.oap_id, dao._Banco);
if (lstCiclosEmUso.Any(c => !list.Any(p => p.tci_id == c.Key)))
{
if (lstCiclosEmUso.Where(c => !list.Any(p => p.tci_id == c.Key)).Count() > 1)
{
throw new ValidationException("Ciclos " + lstCiclosEmUso.Where(c => !list.Any(p => p.tci_id == c.Key)).Select(p => p.Value).Aggregate((a, b) => a + ", " + b) +
" estão em uso e não podem ser removidos.");
}
else
{
throw new ValidationException("Ciclo " + lstCiclosEmUso.Where(c => !list.Any(p => p.tci_id == c.Key)).First().Value +
" está em uso e não pode ser removido.");
}
}
}
ACA_ObjetoAprendizagemTipoCicloBO.DeleteNew(entity.oap_id, dao._Banco);
foreach (ACA_ObjetoAprendizagemTipoCiclo item in list)
{
ACA_ObjetoAprendizagemTipoCicloBO.Save(item, dao._Banco);
}
}
else
{
throw new ValidationException(UtilBO.ErrosValidacao(entity));
}
GestaoEscolarUtilBO.LimpaCache("Cache_SelecionaTipoDisciplinaObjetosAprendizagem");
GestaoEscolarUtilBO.LimpaCache("Cache_SelecionaTipoCicloAtivosEscola");
}
catch (Exception ex)
{
dao._Banco.Close(ex);
throw;
}
finally
{
dao._Banco.Close();
}
}
/// <summary>
/// O método salva as observações para conselho pedagógico.
/// </summary>
/// <param name="tur_id">ID da turma.</param>
/// <param name="alu_id">ID do aluno.</param>
/// <param name="mtu_id">ID da matrícula turma do aluno.</param>
/// <param name="fav_id">ID do formato de avaliação.</param>
/// <param name="ava_id">ID da avaliação.</param>
/// <param name="ltObservacao">Lista de observações.</param>
/// <param name="banco">Banco</param>
/// <param name="ent_id">Id da entidade do usuário logado.</param>
/// <returns></returns>
public static bool SalvarObservacao
(
long tur_id,
long alu_id,
int mtu_id,
int fav_id,
int ava_id,
CLS_AlunoAvaliacaoTur_Observacao observacao,
Guid usu_idLogado,
byte resultado,
string justificativaResultado,
DateTime dataUltimaAlteracaoObservacao,
DateTime dataUltimaAlteracaoNotaFinal,
ACA_FormatoAvaliacao entFormatoAvaliacao,
List <CLS_AvaliacaoTurDisc_Cadastro> listaDisciplina,
List <MTR_MatriculaTurmaDisciplina> listaMatriculaTurmaDisciplina,
int tamanhoMaximoKB,
string[] TiposArquivosPermitidos,
ref List <CLS_AlunoAvaliacaoTurmaDisciplina> listaAtualizacaoEfetivacao,
Guid ent_id,
int tpc_id
)
{
TalkDBTransaction banco = new CLS_AlunoAvaliacaoTurmaObservacaoDAO()._Banco.CopyThisInstance();
banco.Open(IsolationLevel.ReadCommitted);
List <AlunoFechamentoPendencia> FilaProcessamento = new List <AlunoFechamentoPendencia>();
try
{
if (observacao.entityObservacao != null && observacao.entityObservacao != new CLS_AlunoAvaliacaoTurmaObservacao())
{
Save(observacao.entityObservacao, banco);
}
int tpc_idUtilizado = -1;
List <CLS_AvaliacaoTurDisc_Cadastro> listaDisciplinasUltimoPeriodo = new List <CLS_AvaliacaoTurDisc_Cadastro>();
listaDisciplinasUltimoPeriodo = listaDisciplina.Where(d => d.entity.ava_id != ava_id).ToList();
if (listaDisciplinasUltimoPeriodo.Count > 0)
{
tpc_idUtilizado = ACA_AvaliacaoBO.SelecionaMaiorBimestre_ByFormatoAvaliacao(entFormatoAvaliacao.fav_id, banco);
}
CLS_AlunoAvaliacaoTurmaDisciplinaBO.SaveAvaliacaoFinal(
tur_id
, entFormatoAvaliacao
, listaDisciplina
, tamanhoMaximoKB
, TiposArquivosPermitidos
, dataUltimaAlteracaoNotaFinal
, listaMatriculaTurmaDisciplina
, ref listaAtualizacaoEfetivacao
, banco);
tpc_idUtilizado = tpc_idUtilizado > 0 ? tpc_idUtilizado : tpc_id;
if (entFormatoAvaliacao.fav_fechamentoAutomatico && listaMatriculaTurmaDisciplina.Any())
{
FilaProcessamento.AddRange(listaMatriculaTurmaDisciplina
.Select(p => new AlunoFechamentoPendencia {
tud_id = p.tud_id,
tpc_id = tpc_idUtilizado,
afp_frequencia = true,
afp_nota = true,
afp_processado = (Byte)(p.mtd_id <= 0 ? 0 : 2)
}).ToList());
}
// Se for passado o resultado, salva na MTR_MatriculaTurma.
if (!usu_idLogado.Equals(Guid.Empty))
{
MTR_MatriculaTurma entMatr = new MTR_MatriculaTurma
{
alu_id = alu_id
,
mtu_id = mtu_id
};
MTR_MatriculaTurmaBO.GetEntity(entMatr, banco);
// Se o registro foi alterado depois da data da alteração mais recente no momento em que os dados foram carregados,
// interrompe o salvamento e alerta o usuário de que é necessário atualizar os dados
if (entMatr != null && !entMatr.IsNew && Convert.ToDateTime(entMatr.mtu_dataAlteracao.ToString()) > dataUltimaAlteracaoObservacao)
{
throw new ValidationException("Existe registro alterado mais recentemente, é necessário atualizar os dados.");
}
else
{
entMatr.usu_idResultado = usu_idLogado;
entMatr.mtu_resultado = resultado;
entMatr.mtu_relatorio = justificativaResultado;
MTR_MatriculaTurmaBO.Save(entMatr, banco);
if (ACA_ParametroAcademicoBO.ParametroValorBooleanoPorEntidade(eChaveAcademico.GERAR_HISTORICO_SALVAR_PARECER_CONCLUSIVO, ent_id))
{
ACA_AlunoHistoricoBO.GeracaoHistoricoPedagogicoPorAluno(entMatr.alu_id, entMatr.mtu_id, banco);
}
if (entFormatoAvaliacao.fav_fechamentoAutomatico)
{
FilaProcessamento.Add(new AlunoFechamentoPendencia {
tud_id = listaMatriculaTurmaDisciplina.FirstOrDefault().tud_id,
tpc_id = tpc_id,
afp_frequencia = true,
afp_nota = true,
afp_processado = (Byte)(entMatr.IsNew == true ? 0 : 2)
});
}
}
}
// Limpa cache do fechamento, para atualizar o check.
GestaoEscolarUtilBO.LimpaCache(MTR_MatriculaTurmaBO.RetornaChaveCache_GetSelectBy_Turma_Periodo(tur_id, fav_id, ava_id));
List <TUR_TurmaDisciplina> listaDisciplinas = TUR_TurmaDisciplinaBO.GetSelectBy_Turma(tur_id, null, GestaoEscolarUtilBO.MinutosCacheLongo);
listaDisciplinas.ForEach(p =>
{
GestaoEscolarUtilBO.LimpaCache(MTR_MatriculaTurmaDisciplinaBO.RetornaChaveCache_GetSelectBy_TurmaDisciplinaPeriodo(p.tud_id, fav_id, ava_id, string.Empty));
GestaoEscolarUtilBO.LimpaCache(MTR_MatriculaTurmaDisciplinaBO.RetornaChaveCache_GetSelectBy_TurmaDisciplinaPeriodoFiltroDeficiencia(p.tud_id, fav_id, ava_id, string.Empty));
// Chaves do fechamento automatico
string chave = string.Empty;
chave = String.Format(ModelCache.FECHAMENTO_AUTO_BIMESTRE_MODEL_KEY, p.tud_id, tpc_id);
CacheManager.Factory.RemoveByPattern(chave);
chave = String.Format(ModelCache.FECHAMENTO_AUTO_BIMESTRE_FILTRO_DEFICIENCIA_MODEL_KEY, p.tud_id, tpc_id);
CacheManager.Factory.RemoveByPattern(chave);
chave = String.Format(ModelCache.FECHAMENTO_AUTO_FINAL_MODEL_KEY, p.tud_id);
CacheManager.Factory.RemoveByPattern(chave);
chave = String.Format(ModelCache.FECHAMENTO_AUTO_FINAL_FILTRO_DEFICIENCIA_MODEL_KEY, p.tud_id);
CacheManager.Factory.RemoveByPattern(chave);
chave = String.Format(ModelCache.FECHAMENTO_AUTO_BIMESTRE_COMPONENTES_REGENCIA_MODEL_KEY, tur_id, tpc_id);
CacheManager.Factory.RemoveByPattern(chave);
chave = String.Format(ModelCache.FECHAMENTO_AUTO_FINAL_COMPONENTES_REGENCIA_MODEL_KEY, tur_id, tpc_id);
CacheManager.Factory.RemoveByPattern(chave);
//
});
if (entFormatoAvaliacao.fav_fechamentoAutomatico && FilaProcessamento.Any(a => a.tpc_id > 0))
{
CLS_AlunoFechamentoPendenciaBO.SalvarFilaPendencias(
FilaProcessamento
.GroupBy(g => new { g.tud_id, g.tpc_id })
.Select(p => new AlunoFechamentoPendencia {
tud_id = p.FirstOrDefault().tud_id,
tpc_id = p.FirstOrDefault().tpc_id,
afp_frequencia = p.FirstOrDefault().afp_frequencia,
afp_nota = p.FirstOrDefault().afp_nota,
afp_processado = FilaProcessamento
.Where(w => w.tud_id == p.FirstOrDefault().tud_id&& w.tpc_id == p.FirstOrDefault().tpc_id)
.Min(m => m.afp_processado)
})
.Where(w => w.tpc_id > 0 && w.tpc_id != ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, ent_id))
.ToList()
, banco);
}
return(true);
}
catch (ValidationException ex)
{
banco.Close(ex);
throw;
}
catch (Exception ex)
{
banco.Close(ex);
throw;
}
finally
{
if (banco.ConnectionIsOpen)
{
banco.Close();
}
}
}
/// <summary>
/// Salva as notas das atividades dos alunos e a propriedade "tnt_efetivado" das
/// atividades.
/// <param name="fechamentoAutomatico">Indica se o fechamento é automático.</param>
/// <param name="origemLogMedia">Se enviar a origem do log então será salvo o LOG_AvaliacaoMedia_Alteracao</param>
/// <param name="origemLogNota">Se enviar a origem do log então será salvo o LOG_TurmaNota_Alteracao</param>
/// </summary>
internal 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
, TalkDBTransaction banco
, Guid ent_id
, bool fechamentoAutomatico
, Guid usu_id = new Guid()
, byte origemLogMedia = 0
, byte origemLogNota = 0
, byte tipoLogNota = 0
, long tud_idRegencia = -1
)
{
string errorMSG = string.Empty;
if (!ValidaParticipantesAvaliacao(listTurmaNota, listTurmaNotaAluno, out errorMSG, ent_id))
{
throw new ValidationException(errorMSG);
}
object lockObject = new object();
// Salva os dados de todos os alunos na tabela CLS_TurmaNotaAluno.
DataTable dtTurmaNotaAluno = CLS_TurmaNotaAluno.TipoTabela_TurmaNotaAluno();
if (listTurmaNotaAluno.Any())
{
Parallel.ForEach
(
listTurmaNotaAluno,
turmaNotaAluno =>
{
lock (lockObject)
{
DataRow dr = dtTurmaNotaAluno.NewRow();
dtTurmaNotaAluno.Rows.Add(TurmaNotaAlunoToDataRow(turmaNotaAluno, dr));
}
}
);
}
SalvaNotaAlunos(dtTurmaNotaAluno, banco);
GestaoEscolarUtilBO.LimpaCache(String.Format(ModelCache.FECHAMENTO_AUTO_BIMESTRE_COMPONENTES_REGENCIA_MODEL_KEY, tur_id, tpc_id));
GestaoEscolarUtilBO.LimpaCache(ModelCache.FECHAMENTO_BIMESTRE_COMPONENTES_REGENCIA_PATTERN_KEY, tur_id.ToString());
string tnt_ids = string.Join(",", (from CLS_TurmaNota item in listTurmaNota select item.tnt_id.ToString()).ToArray());
List <CLS_TurmaNota> listaTurmaNota;
List <LOG_TurmaNota_Alteracao> listLogNota = new List <LOG_TurmaNota_Alteracao>();
// Recupera a lista de entidades CLS_TurmaNotaAluno para verificar se ela já existe.
CLS_TurmaNotaAlunoDAO tnaDao = new CLS_TurmaNotaAlunoDAO {
_Banco = banco
};
tnaDao.SelectBy_Disciplina_Atividades(tud_id, tnt_ids, out listaTurmaNota);
DateTime dataLogNota = DateTime.Now;
foreach (CLS_TurmaNota entTurNota in listTurmaNota)
{
// Busca registro - deve existir.
CLS_TurmaNota entAux = listaTurmaNota.Find
(p => p.tud_id == entTurNota.tud_id &&
p.tnt_id == entTurNota.tnt_id);
if (entAux != null)
{
// Só altera o tnt_efetivado.
entAux.tnt_efetivado = entTurNota.tnt_efetivado;
entAux.usu_idDocenteAlteracao = entTurNota.usu_idDocenteAlteracao;
if (!entAux.Validate())
{
throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entAux));
}
if ((tdt_posicao <= 0) || (tdt_posicao == entTurNota.tdt_posicao))
{
CLS_TurmaNotaBO.Save(entAux, banco);
if (origemLogNota > 0)
{
LOG_TurmaNota_Alteracao entLogNota = new LOG_TurmaNota_Alteracao
{
tud_id = entAux.tud_id,
tnt_id = entAux.tnt_id,
usu_id = usu_id,
ltn_origem = origemLogNota,
ltn_tipo = tipoLogNota,
ltn_data = dataLogNota
};
listLogNota.Add(entLogNota);
}
}
}
}
//Salva os logs de alteração de nota
LOG_TurmaNota_AlteracaoBO.SalvarEmLote(listLogNota, banco);
// Salva os dados da média.
if (listAlunoAvaliacaoTurmaDisciplinaMedia != null)
{
List <CLS_AlunoAvaliacaoTurmaDisciplinaMedia> listaMediasBimestreBD = CLS_AlunoAvaliacaoTurmaDisciplinaMediaBO.BuscaNotasFinaisTurma(tud_id, tpc_id, banco);
bool alteracaoMedia = listAlunoAvaliacaoTurmaDisciplinaMedia.Exists(media =>
listaMediasBimestreBD.Any() ?
!listaMediasBimestreBD.Any
(
p => p.tud_id == media.tud_id &&
p.alu_id == media.alu_id &&
p.mtu_id == media.mtu_id &&
p.mtd_id == media.mtd_id &&
(string.IsNullOrEmpty(p.atm_media) ? "" : p.atm_media) == (string.IsNullOrEmpty(media.atm_media) ? "" : media.atm_media)
) :
!string.IsNullOrEmpty(media.atm_media));
CLS_AlunoAvaliacaoTurmaDisciplinaMediaBO.SalvarEmLote(tur_id, tud_id, tpc_id, fav_id, listAlunoAvaliacaoTurmaDisciplinaMedia, banco);
// Salva na fila de processamento e o log caso exista alguma alteração.
if (alteracaoMedia && listAlunoAvaliacaoTurmaDisciplinaMedia.Count > 0)
{
// Caso o fechamento seja automático, grava na fila de processamento.
if (fechamentoAutomatico && tpc_id != ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, ent_id))
{
CLS_AlunoFechamentoPendenciaBO.SalvarFilaNota(tud_id, tpc_id, banco);
if (tud_idRegencia > 0)
{
CLS_AlunoFechamentoPendenciaBO.SalvarFilaNota(tud_idRegencia, tpc_id, banco);
}
}
if (origemLogMedia > 0)
{
LOG_AvaliacaoMedia_Alteracao log = new LOG_AvaliacaoMedia_Alteracao
{
tud_id = tud_id,
tpc_id = tpc_id,
usu_id = usu_id,
lam_data = DateTime.Now,
lam_tipo = (byte)LOG_AvaliacaoMedia_Alteracao_Tipo.AlteracaoMedia,
lam_origem = origemLogMedia
};
LOG_AvaliacaoMedia_AlteracaoBO.Save(log, banco);
}
}
}
return(true);
}
/// <summary>
/// Salva a lista de aulas previstas, validando as entidades.
/// </summary>
/// <param name="lista"></param>
/// <returns></returns>
public static bool SalvarAulasPrevistas(List <TUR_TurmaDisciplinaAulaPrevista> lista, List <TUR_TurmaDisciplinaAulaPrevista> listaProcessarPend, Guid ent_id, int esc_id, long doc_id, bool fechamentoAutomatico)
{
TalkDBTransaction banco = new TUR_TurmaDisciplinaAulaPrevistaDAO()._Banco.CopyThisInstance();
try
{
banco.Open();
bool ret = true;
foreach (TUR_TurmaDisciplinaAulaPrevista entity in lista)
{
if (!entity.Validate())
{
throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entity));
}
ret &= Save(entity, banco);
}
foreach (var listaTudTpc in listaProcessarPend.Select(tap => new { tap.tud_id, tap.tud_tipo, tap.tpc_id }).Distinct())
{
// Caso o fechamento seja automático, grava na fila de processamento.
if (fechamentoAutomatico && listaProcessarPend.Count > 0 && listaTudTpc.tud_tipo != (byte)TurmaDisciplinaTipo.DocenteEspecificoComplementacaoRegencia && listaTudTpc.tpc_id != ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, ent_id))
{
CLS_AlunoFechamentoPendenciaBO.SalvarFilaFrequencia(listaTudTpc.tud_id, listaTudTpc.tpc_id, banco);
}
}
if (lista.Count > 0 && ret && HttpContext.Current != null)
{
try
{
// Limpa o cache da lista de turmas, para atualizar o check
string chave = TUR_TurmaBO.RetornaChaveCache_GestorMinhaEscola(ent_id, esc_id);
HttpContext.Current.Cache.Remove(chave);
if (doc_id > 0)
{
chave = TUR_TurmaBO.RetornaChaveCache_DocenteControleTurmas(ent_id, doc_id);
HttpContext.Current.Cache.Remove(chave);
}
else
{
GestaoEscolarUtilBO.LimpaCache(string.Format("{0}_{1}", TUR_TurmaDisciplinaBO.Cache_SelecionaPorDocenteControleTurma, ent_id));
}
// Limpa o cache do fechamento
long tud_id = lista[0].tud_id;
GestaoEscolarUtilBO.LimpaCache(ModelCache.FECHAMENTO_BIMESTRE_PATTERN_KEY, tud_id.ToString());
GestaoEscolarUtilBO.LimpaCache(ModelCache.FECHAMENTO_BIMESTRE_FILTRO_DEFICIENCIA_PATTERN_KEY, tud_id.ToString());
GestaoEscolarUtilBO.LimpaCache(string.Format(ModelCache.TURMA_DISCIPLINA_AULA_PREVISTA_MODEL_KEY, tud_id));
GestaoEscolarUtilBO.LimpaCache(string.Format(ModelCache.TURMA_SELECIONA_POR_DOCENTE_CONTROLE_TURMA_MODEL_KEY, ent_id.ToString(), doc_id.ToString()));
}
catch
{ }
}
return(ret);
}
catch (Exception ex)
{
banco.Close(ex);
throw ex;
}
finally
{
banco.Close();
}
}
/// <summary>
/// Remove do cache a entidade.
/// </summary>
/// <param name="entity"></param>
private static void LimpaCache(ACA_TipoDisciplina entity)
{
CacheManager.Factory.Remove(RetornaChaveCache_GetEntity(entity));
GestaoEscolarUtilBO.LimpaCache("Cache_SelecionaTipoDisciplinaObjetosAprendizagem");
}