/// <summary>
/// Salva as entidades turmaAula e TurmaAulaAluno nas listas - com transação.
/// </summary>
/// <param name="listTurmaAulaAluno">Lista de entidades CLS_TurmaAulaAluno</param>
/// <param name="listTurmaAula">LIsta de entidades CLS_TurmaAula</param>
/// <param name="tur_id">ID da turma</param>
/// <param name="tud_id">ID da disciplina que está sendo salva as frequências</param>
/// <param name="tdt_posicao">Posição do docente logado no sistema</param>
/// <param name="entityTurma">Turma.</param>
/// <param name="entityFormatoAvaliacao">Formato de avaliação.</param>
/// <param name="entityCurriculoPeriodo">CurriculoPeriodo.</param>
/// <param name="banco">Transação com banco de dados aberta</param>
/// <returns></returns>
internal static bool Save
(
List <CLS_TurmaAulaAluno> listTurmaAulaAluno
, List <CLS_TurmaAula> listTurmaAula
, long tur_id
, long tud_id
, byte tdt_posicao
, TUR_Turma entityTurma
, ACA_FormatoAvaliacao entityFormatoAvaliacao
, ACA_CurriculoPeriodo entityCurriculoPeriodo
, TalkDBTransaction banco
, Guid usu_id = new Guid()
, byte origemLogAula = 0
, byte tipoLogAula = 0
, Guid ent_id = new Guid()
)
{
string tau_ids = string.Join(",",
(from CLS_TurmaAula item in listTurmaAula select item.tau_id.ToString()).
ToArray());
// Recupera a lista de entidades CLS_TurmaAulaAluno para verificar se ela já existe.
List <CLS_TurmaAulaAluno> listaTurmaAulaAluno = new CLS_TurmaAulaAlunoDAO {
_Banco = banco
}
.SelectBy_Disciplina_Aulas(tud_id, tau_ids);
DataTable dtTurmaAulaAluno = CLS_TurmaAulaAluno.TipoTabela_TurmaAulaAluno();
List <LOG_TurmaAula_Alteracao> listLogAula = new List <LOG_TurmaAula_Alteracao>();
object lockObject = new object();
Parallel.ForEach
(
listTurmaAulaAluno,
entityTurmaAulaAluno =>
{
// Busca se a entidade já existe na lista.
CLS_TurmaAulaAluno entAux =
listaTurmaAulaAluno.Find(p =>
p.tud_id == entityTurmaAulaAluno.tud_id &&
p.tau_id == entityTurmaAulaAluno.tau_id &&
p.alu_id == entityTurmaAulaAluno.alu_id &&
p.mtu_id == entityTurmaAulaAluno.mtu_id &&
p.mtd_id == entityTurmaAulaAluno.mtd_id
);
if (entAux != null)
{
entityTurmaAulaAluno.IsNew = entAux.IsNew;
entityTurmaAulaAluno.taa_anotacao = entAux.taa_anotacao;
entityTurmaAulaAluno.usu_idDocenteAlteracao = entAux.usu_idDocenteAlteracao;
}
Validate(entityTurmaAulaAluno, listTurmaAula);
if (entityTurmaAulaAluno.Validate())
{
lock (lockObject)
{
DataRow dr = dtTurmaAulaAluno.NewRow();
dtTurmaAulaAluno.Rows.Add(TurmaAulaAlunoToDataRow(entityTurmaAulaAluno, dr));
}
}
else
{
throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entityTurmaAulaAluno));
}
}
);
// Salva os dados de todos os alunos na tabela CLS_TurmaAulaAluno
SalvaFrequenciaAlunos(dtTurmaAulaAluno, banco);
// Verifica se a entidade recebida por parâmetro foi alimentada, se não foi, dá o GetEntity.
TUR_Turma turma = entityTurma ?? TUR_TurmaBO.GetEntity(new TUR_Turma {
tur_id = tur_id
}, banco);
ACA_FormatoAvaliacao formatoAvaliacao = entityFormatoAvaliacao ?? ACA_FormatoAvaliacaoBO.GetEntity(new ACA_FormatoAvaliacao {
fav_id = turma.fav_id
}, banco);
ACA_CurriculoPeriodo entityCrp = entityCurriculoPeriodo ?? ACA_CurriculoPeriodoBO.SelecionaPorTurmaTipoNormal(turma.tur_id, GestaoEscolarUtilBO.MinutosCacheLongo);
List <TUR_TurmaDisciplina> listaDisciplinas = TUR_TurmaDisciplinaBO.GetSelectBy_Turma(tur_id, banco, GestaoEscolarUtilBO.MinutosCacheLongo);
TUR_TurmaDisciplina entDisciplinarincipal =
listaDisciplinas.Find(p => p.tud_tipo == (byte)TurmaDisciplinaTipo.DisciplinaPrincipal);
// Se não for para lançar na disciplina global, e a turma possuir uma disc. principal,
// só poderá salvar na disciplina principal.
bool validarDiscPrincipal =
(!(turma.tur_docenteEspecialista && formatoAvaliacao.fav_planejamentoAulasNotasConjunto)) &&
(entDisciplinarincipal != null) && (formatoAvaliacao.fav_tipoApuracaoFrequencia != (byte)ACA_FormatoAvaliacaoTipoApuracaoFrequencia.Dia &&
entityCrp.crp_controleTempo != (byte)ACA_CurriculoPeriodoControleTempo.Horas);
DateTime dataLogAula = DateTime.Now;
foreach (CLS_TurmaAula entityTurmaAula in listTurmaAula)
{
// Se for pra validar a disc. principal, só pode lançar frequência nela.
if (validarDiscPrincipal && (entDisciplinarincipal.tud_id != entityTurmaAula.tud_id))
{
throw new ValidationException("A frequência dessa turma só pode ser lançada para o(a) " + CustomResource.GetGlobalResourceObject("Mensagens", "MSG_DISCIPLINA") + entDisciplinarincipal.tud_nome + ".");
}
if (origemLogAula > 0)
{
LOG_TurmaAula_Alteracao entLogAula = new LOG_TurmaAula_Alteracao
{
tud_id = entityTurmaAula.tud_id,
tau_id = entityTurmaAula.tau_id,
usu_id = usu_id,
lta_origem = origemLogAula,
lta_tipo = tipoLogAula,
lta_data = dataLogAula
};
listLogAula.Add(entLogAula);
}
}
//Salva os logs de alteração de aula
LOG_TurmaAula_AlteracaoBO.SalvarEmLote(listLogAula, banco);
// Atualiza o campo efetivado da aula.
CLS_TurmaAulaBO.AtualizarEfetivado(listTurmaAula, banco);
// Caso o fechamento seja automático, grava na fila de processamento.
if (formatoAvaliacao.fav_fechamentoAutomatico && listTurmaAula.Count > 0 && listTurmaAula[0].tpc_id != ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, ent_id))
{
CLS_AlunoFechamentoPendenciaBO.SalvarFilaFrequencia(tud_id, listTurmaAula[0].tpc_id, banco);
}
if (listTurmaAula.Any() && dtTurmaAulaAluno.Rows.Count > 0 && HttpContext.Current != null)
{
// Limpa o cache do fechamento
try
{
string chave = string.Empty;
int tpc_id = listTurmaAula[0].tpc_id;
List <ACA_Avaliacao> avaliacao = ACA_AvaliacaoBO.GetSelectBy_FormatoAvaliacaoPeriodo(turma.fav_id, tpc_id);
if (avaliacao.Any())
{
int ava_id = avaliacao.First().ava_id;
if (tud_id > 0)
{
chave = MTR_MatriculaTurmaDisciplinaBO.RetornaChaveCache_GetSelectBy_TurmaDisciplinaPeriodo(tud_id, turma.fav_id, ava_id, string.Empty);
CacheManager.Factory.RemoveByPattern(chave);
chave = MTR_MatriculaTurmaDisciplinaBO.RetornaChaveCache_GetSelectBy_TurmaDisciplinaPeriodoFiltroDeficiencia(tud_id, turma.fav_id, ava_id, string.Empty);
CacheManager.Factory.RemoveByPattern(chave);
}
else
{
chave = MTR_MatriculaTurmaBO.RetornaChaveCache_GetSelectBy_Turma_Periodo(tur_id, turma.fav_id, ava_id);
HttpContext.Current.Cache.Remove(chave);
}
}
}
catch
{ }
}
return(true);
}
/// <summary>
/// Salva os dados da média dos alunos.
/// </summary>
/// <param name="ltAlunoAvaliacaoTurmaDisciplinaMedia">Lista de médias dos alunos.</param>
/// <param name="banco">Transação.</param>
/// <returns>True em caso de sucesso.</returns>
public static bool SalvarEmLote(long tur_id, long tud_id, int tpc_id, int fav_id, List <CLS_AlunoAvaliacaoTurmaDisciplinaMedia> ltAlunoAvaliacaoTurmaDisciplinaMedia, TalkDBTransaction banco)
{
DataTable dtAlunoAvaliacaoTurmaDisciplinaMedia = CLS_AlunoAvaliacaoTurmaDisciplinaMedia.TipoTabela_AlunoAvaliacaoTurmaDisciplinaMedia();
if (ltAlunoAvaliacaoTurmaDisciplinaMedia != null && ltAlunoAvaliacaoTurmaDisciplinaMedia.Any())
{
object lockObject = new object();
Parallel.ForEach
(
ltAlunoAvaliacaoTurmaDisciplinaMedia,
alunoAvaliacaoTurmaDisciplinaMedia =>
{
lock (lockObject)
{
DataRow dr = dtAlunoAvaliacaoTurmaDisciplinaMedia.NewRow();
dtAlunoAvaliacaoTurmaDisciplinaMedia.Rows.Add(AlunoAvaliacaoTurmaDisciplinaMediaToDataRow(alunoAvaliacaoTurmaDisciplinaMedia, dr));
}
}
);
bool retorno = banco == null ?
new CLS_AlunoAvaliacaoTurmaDisciplinaMediaDAO().SalvarEmLote(dtAlunoAvaliacaoTurmaDisciplinaMedia) :
new CLS_AlunoAvaliacaoTurmaDisciplinaMediaDAO {
_Banco = banco
}.SalvarEmLote(dtAlunoAvaliacaoTurmaDisciplinaMedia);
if (retorno && HttpContext.Current != null)
{
// Limpa o cache do fechamento
try
{
string chave = string.Empty;
List <ACA_Avaliacao> avaliacao = ACA_AvaliacaoBO.GetSelectBy_FormatoAvaliacaoPeriodo(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, fav_id, ava_id, string.Empty);
CacheManager.Factory.RemoveByPattern(chave);
chave = MTR_MatriculaTurmaDisciplinaBO.RetornaChaveCache_GetSelectBy_TurmaDisciplinaPeriodoFiltroDeficiencia(tud_id, fav_id, ava_id, string.Empty);
CacheManager.Factory.RemoveByPattern(chave);
chave = MTR_MatriculaTurmaDisciplinaBO.RetornaChaveCache_GetSelect_ComponentesRegencia_By_TurmaFormato(tur_id, fav_id, ava_id);
CacheManager.Factory.Remove(chave);
}
else
{
chave = MTR_MatriculaTurmaBO.RetornaChaveCache_GetSelectBy_Turma_Periodo(tur_id, fav_id, ava_id);
HttpContext.Current.Cache.Remove(chave);
}
// Recupero o id da avaliacao final para limpar o cache
DataTable avaFinal = ACA_AvaliacaoBO.GetSelectBy_TipoAvaliacao(AvaliacaoTipo.Final, fav_id);
ava_id = avaFinal.Rows.Count == 0 ? -1 : Convert.ToInt32(avaFinal.Rows[0]["ava_id"]);
// Limpa o cache da efetivacao final
if (ava_id > 0)
{
if (tud_id > 0)
{
chave = MTR_MatriculaTurmaDisciplinaBO.RetornaChaveCache_GetSelectBy_TurmaDisciplinaFinal(tud_id, fav_id, ava_id, string.Empty);
CacheManager.Factory.RemoveByPattern(chave);
chave = MTR_MatriculaTurmaDisciplinaBO.RetornaChaveCache_GetSelectBy_TurmaDisciplinaFinalFiltroDeficiencia(tud_id, fav_id, ava_id, string.Empty);
CacheManager.Factory.RemoveByPattern(chave);
chave = MTR_MatriculaTurmaDisciplinaBO.RetornaChaveCache_GetSelect_ComponentesRegencia_By_TurmaFormato_Final(tur_id, fav_id, ava_id);
CacheManager.Factory.Remove(chave);
}
else
{
chave = MTR_MatriculaTurmaBO.RetornaChaveCache_GetSelectBy_Turma_Final(tur_id, fav_id, ava_id);
HttpContext.Current.Cache.Remove(chave);
}
}
}
}
catch
{ }
}
return(retorno);
}
return(true);
}
/// <summary>
/// O método salva as observações para conselho pedagógico.
/// </summary>
/// <param name="tur_id">ID da turma.</param>
/// <param name="alu_id">ID do aluno.</param>
/// <param name="mtu_id">ID da matrícula turma do aluno.</param>
/// <param name="fav_id">ID do formato de avaliação.</param>
/// <param name="ava_id">ID da avaliação.</param>
/// <param name="ltObservacao">Lista de observações.</param>
/// <param name="banco">Banco</param>
/// <param name="ent_id">Id da entidade do usuário logado.</param>
/// <returns></returns>
public static bool SalvarObservacao
(
long tur_id,
long alu_id,
int mtu_id,
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();
}
}
}