/// <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();
}
}
}
private void UCCPeriodoCalendario_IndexChanged()
{
rptAlunos.DataSource = null;
bool possuiAlunos = false;
if (UCCPeriodoCalendario.Valor[0] != -1 && UCCPeriodoCalendario.Valor[1] != -1)
{
long tur_id = Convert.ToInt64(ddlTurma.SelectedValue);
TUR_Turma tur = new TUR_Turma();
tur.tur_id = tur_id;
TUR_TurmaBO.GetEntity(tur);
TUR_TurmaDisciplina tud = new TUR_TurmaDisciplina();
tud.tud_id = UCCTurmaDisciplina1.Valor;
TUR_TurmaDisciplinaBO.GetEntity(tud);
DateTime cap_dataInicio, cap_dataFim;
ACA_CalendarioPeriodoBO.RetornaDatasPeriodoPor_FormatoAvaliacaoTurmaDisciplina(UCCPeriodoCalendario.Valor[0], string.Empty, UCCTurmaDisciplina1.Valor, tur.fav_id, out cap_dataInicio, out cap_dataFim);
DataTable dt = _VS_doc_id > 0 && VS_DisciplinaEspecial?
MTR_MatriculaTurmaDisciplinaBO.SelecionaAtivosCompensacaoAusenciaFiltroDeficiencia(tur_id, UCCTurmaDisciplina1.Valor, UCCPeriodoCalendario.Valor[0], 0, VS_tipoDocente, VS_cpa_id, false, true) :
MTR_MatriculaTurmaDisciplinaBO.SelecionaAtivosCompensacaoAusencia(UCCTurmaDisciplina1.Valor, UCCPeriodoCalendario.Valor[0], 0, VS_cpa_id, false, true);
rptAlunos.DataSource = dt;
possuiAlunos = dt.Rows.Count > 0;
rptAlunos.DataBind();
lblMessage.Text = "";
if (tud.tud_tipo == (byte)TurmaDisciplinaTipo.Experiencia &&
!TUR_TurmaDisciplinaTerritorioBO.VerificaOferecimentoExperienciaBimestre(UCCTurmaDisciplina1.Valor, UCComboCalendario.Valor, UCCPeriodoCalendario.Valor[0]))
{
mostraSalvar = false;
lblMessage.Text += UtilBO.GetErroMessage("A experiência não possui territórios vigentes no bimestre.", UtilBO.TipoMensagem.Alerta);
}
if (VS_cpa_id <= 0)
{
if (possuiAlunos)
{
btnSalvar.Visible = __SessionWEB.__UsuarioWEB.GrupoPermissao.grp_inserir && mostraSalvar;
}
else
{
btnSalvar.Visible = false;
lblMessage.Text += UtilBO.GetErroMessage("Não existem alunos com ausências para serem compensadas.", UtilBO.TipoMensagem.Alerta);
}
}
}
fdsAlunos.Visible = possuiAlunos;
}
/// <summary>
/// Carrega dados de lançamento de frequência na tela.
/// Só carrega caso a disciplina não seja do tipo
/// complementação da regência.
/// </summary>
public void Carregar(bool proximo
, bool anterior
, bool inalterado
, ControleTurmas entitiesControleTurma
, int tpcId
, DateTime capDataInicio
, DateTime capDataFim
, byte tdtPosicao
, EnumTipoDocente tipoDocente
, long tudIdRelacionada
, bool permiteVisualizarCompensacao
, List <sPermissaoDocente> ltPermissaoFrequencia
, bool permiteLancarFrequencia
, out int countAulas
, int situacaoTurmaDisciplina
, ref bool permiteEdicao
, bool usuarioPermissao
, bool periodoEfetivado
, bool periodoAberto
, ref bool esconderSalvar
, ref int paginaFreq
, int tne_id
, string tur_ids = null)
{
countAulas = 0;
long tudId = entitiesControleTurma.turmaDisciplina.tud_id;
long turId = entitiesControleTurma.turma.tur_id;
int qtdAulasSemana = ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.QUANTIDADE_AULAS_LISTAO_FREQUENCIA, __SessionWEB.__UsuarioWEB.Usuario.ent_id);
DateTime dtInicio = new DateTime();
DateTime dtFim = new DateTime();
if (proximo)
{
paginaFreq++;
}
else if (anterior && paginaFreq > 1)
{
paginaFreq--;
}
else if (!inalterado)
{
paginaFreq = 1;
}
// Carregar tabela com aulas e frequências das aulas para os alunos.
VS_Aulas_Alunos =
CLS_TurmaAulaAlunoBO.GetSelectBy_TurmaDisciplina(tudId, tpcId,
(__SessionWEB.__UsuarioWEB.Docente.doc_id > 0 ? __SessionWEB.__UsuarioWEB.Usuario.usu_id : Guid.Empty),
capDataInicio, capDataFim, tdtPosicao, __SessionWEB.__UsuarioWEB.Docente.doc_id == 0, tudIdRelacionada, tur_ids);
int qtdAlunos = VS_Aulas_Alunos.GroupBy(p => new { p.alu_id, p.mtu_id }).Count();
int skip = qtdAulasSemana * (paginaFreq - 1) * qtdAlunos;
while (proximo && VS_Aulas_Alunos.Count < skip)
{
paginaFreq--;
skip = (qtdAulasSemana * (paginaFreq - 1)) * qtdAlunos;
if (paginaFreq == 1)
{
break;
}
}
//Quando carrega pela primeira vez e o bimestre é ativo então abre a página que possui a data atual
if (!proximo && !anterior && !inalterado && paginaFreq == 1 &&
capDataInicio <= DateTime.Today && capDataFim >= DateTime.Today)
{
while (VS_Aulas_Alunos.Skip(skip).Take(qtdAulasSemana * qtdAlunos).ToList().LastOrDefault().tau_data < DateTime.Today &&
VS_Aulas_Alunos.Skip(skip).Count() > (qtdAulasSemana * qtdAlunos))
{
paginaFreq++;
skip = (qtdAulasSemana * (paginaFreq - 1)) * qtdAlunos;
}
}
lkbProximo.Visible = VS_Aulas_Alunos.Skip(skip).Count() > (qtdAulasSemana * qtdAlunos);
lkbAnterior.Visible = skip > 0;
VS_Aulas_Alunos = VS_Aulas_Alunos.Skip(skip).Take(qtdAulasSemana * qtdAlunos).ToList();
dtInicio = VS_Aulas_Alunos.Count > 0 ? VS_Aulas_Alunos.FirstOrDefault().tau_data : capDataInicio.Date;
dtFim = VS_Aulas_Alunos.Count > 0 ? VS_Aulas_Alunos.LastOrDefault().tau_data : capDataFim.Date;
lblInicio.Text = dtInicio == new DateTime() ? "" : dtInicio.ToShortDateString();
lblFim.Text = dtFim == new DateTime() ? "" : dtFim.ToShortDateString();
// Carregar repeater de alunos.
rptAlunosFrequencia.DataSource = MTR_MatriculaTurmaDisciplinaBO.SelecionaAlunosAtivosCOCPorTurmaDisciplina(tudId,
tpcId, tipoDocente, false, capDataInicio, capDataFim, ApplicationWEB.AppMinutosCacheMedio, tur_ids)
.Where(p => ((p.mtd_dataSaida > dtInicio) || (p.mtd_dataSaida == null)) && (p.mtd_dataMatricula <= dtFim));
if (entitiesControleTurma.turma.tur_tipo == (byte)TUR_TurmaTipo.Normal)
{
lstAlunosRelatorioRP = CLS_RelatorioPreenchimentoAlunoTurmaDisciplinaBO.SelecionaAlunoPreenchimentoPorPeriodoDisciplina(tpcId, turId, tudId, ApplicationWEB.AppMinutosCacheMedio);
}
this.tudTipo = entitiesControleTurma.turmaDisciplina.tud_tipo;
this.permiteVisualizarCompensacao = permiteVisualizarCompensacao;
this.ltPermissaoFrequencia = ltPermissaoFrequencia;
this.permiteLancarFrequencia = permiteLancarFrequencia;
this.permiteEdicao = false;
this.situacaoTurmaDisciplina = situacaoTurmaDisciplina;
this.posicaoDocente = tdtPosicao;
this.usuarioPermissao = usuarioPermissao;
this.periodoEfetivado = periodoEfetivado;
this.periodoAberto = periodoAberto;
ACA_CurriculoPeriodo entityCrp = ACA_CurriculoPeriodoBO.SelecionaPorTurmaTipoNormal(turId, ApplicationWEB.AppMinutosCacheLongo);
this.crpControleTempo = entityCrp.crp_controleTempo;
this.possuiRegencia = TUR_TurmaBO.VerificaPossuiDisciplinaPorTipo(turId, TurmaDisciplinaTipo.Regencia, ApplicationWEB.AppMinutosCacheLongo);
this.tipoApuracaoFrequencia = entitiesControleTurma.formatoAvaliacao.fav_tipoApuracaoFrequencia;
this.tne_id = tne_id;
this.ttn_tipo = entitiesControleTurma.tipoTurno.ttn_tipo;
rptAlunosFrequencia.DataBind();
// Limpa o hiddenfield do listão de frequência pra zerar a ordenação.
hdnOrdenacaoFrequencia.Value = "";
//Fazendo as validações após carregar os dados.
if (rptAlunosFrequencia.Items.Count == 0)
{
EscondeGridAlunosFrequencia("Não foram encontrados alunos na turma selecionada.");
esconderSalvar = true;
}
else
{
MostraPeriodo(true);
pnlLancamentoFrequencias.Visible = true;
RepeaterItem header = (RepeaterItem)rptAlunosFrequencia.Controls[0];
Repeater rptAulas = (Repeater)header.FindControl("rptAulas");
lblMsgParecer.Visible = rptAulas.Items.Count > 0;
_lblMsgRepeater.Visible = rptAulas.Items.Count == 0;
if (rptAulas.Items.Count == 0)
{
_lblMsgRepeater.Text = UtilBO.GetErroMessage(GetGlobalResourceObject("Academico", "ControleTurma.Listao.MensagemSemAulas").ToString(),
UtilBO.TipoMensagem.Alerta);
esconderSalvar = true;
}
countAulas = rptAulas.Items.Count;
rptAlunosFrequencia.Visible = true;
}
if (this.permiteEdicao && !periodoEfetivado)
{
permiteEdicao = true;
}
}
/// <summary>
/// Processa os protocolos informados.
/// </summary>
/// <param name="ltProtocolo">Lista de protocolos em processamento.</param>
/// <param name="tentativasProtocolo">Quantidade máxima de tentativas para processar protocolos.</param>
/// <returns></returns>
public static bool ProcessaProtocoloPlanejamentoAnual(List <DCL_Protocolo> ltProtocolo, int tentativasProtocolo)
{
// DataTable de protocolos
DataTable dtProtocolo = DCL_Protocolo.TipoTabela_Protocolo();
foreach (DCL_Protocolo protocolo in ltProtocolo.Where(pro => pro.pro_tentativa > tentativasProtocolo))
{
protocolo.pro_statusObservacao = String.Format("Número máximo ({0}) de tentativas de processamento deste protocolo foram excedidas. Erro: {1}"
, tentativasProtocolo, protocolo.pro_statusObservacao);
protocolo.pro_status = (byte)DCL_ProtocoloBO.eStatus.ProcessadoComErrosValidacao;
protocolo.tur_id = -1;
protocolo.tud_id = -1;
protocolo.tau_id = -1;
protocolo.pro_qtdeAlunos = -1;
dtProtocolo.Rows.Add(DCL_ProtocoloBO.ProtocoloToDataRow(protocolo, dtProtocolo.NewRow()));
}
foreach (DCL_Protocolo protocolo in ltProtocolo.Where(pro => pro.pro_tentativa <= tentativasProtocolo))
{
// Abre uma transação para cada protocolo dentro do laço.
// Assim é possível processar o próximo protocolo, mesmo que o atual esteja com erro.
TalkDBTransaction bancoSincronizacao = new CLS_TurmaAulaDAO()._Banco.CopyThisInstance();
bancoSincronizacao.Open(IsolationLevel.ReadCommitted);
bool processou = false;
try
{
if (protocolo.pro_tentativa <= tentativasProtocolo)
{
if (string.IsNullOrEmpty(protocolo.pro_versaoAplicativo))
{
throw new ValidationException("É necessário atualizar a versão do sistema.");
}
///*
// * na versão 44 o planejamento mudou e não mais podera mais processar
// * protocolos de planejamento antigos
// * */
//int minorVersion = int.Parse(protocolo.pro_versaoAplicativo.Split('.')[1]);
//if (minorVersion < 44)
// throw new ValidationException("É necessário atualizar a versão do sistema.");
#region Varável
List <CLS_TurmaDisciplinaPlanejamento> listaPlanejamento = new List <CLS_TurmaDisciplinaPlanejamento>();
#endregion
#region Informações do planejamento anual
// Objeto JSON de entrada.
JObject planejamento = JObject.Parse(protocolo.pro_pacote);
long tud_id = (long)planejamento.SelectToken("tud_id");
protocolo.tud_id = tud_id;
// apenas protocolos de turmas ativas e do ano letivo corrente podem ser processados
if (!DCL_ProtocoloBO.PodeProcessarProtocolo(0, tud_id))
{
throw new ValidationException("O protocolo pertence a uma turma que não esta ativa ou de um ano letivo diferente do corrente, não pode ser processado!");
}
ACA_CurriculoPeriodo entCrp = ACA_CurriculoPeriodoBO.SelecionaPorTurmaDisciplina(tud_id, bancoSincronizacao).FirstOrDefault();
#endregion
// Todas as matrículas de aluno na disciplina.
List <MTR_MatriculaTurmaDisciplina> listaMatriculas = MTR_MatriculaTurmaDisciplinaBO.
SelecionaMatriculasPorTurmaDisciplina(tud_id.ToString(), bancoSincronizacao);
List <CLS_AlunoTurmaDisciplinaOrientacaoCurricular> listaAlunoTurmaDisciplinaOrientacao = new List <CLS_AlunoTurmaDisciplinaOrientacaoCurricular>();
List <CLS_PlanejamentoOrientacaoCurricular> listaPlanejamentoOrientacao = new List <CLS_PlanejamentoOrientacaoCurricular>();
List <CLS_PlanejamentoOrientacaoCurricularDiagnostico> listaPlanejamentoDiagnostico = new List <CLS_PlanejamentoOrientacaoCurricularDiagnostico>();
if (!ACA_ParametroAcademicoBO.ParametroValorBooleanoPorEntidade(eChaveAcademico.PLANEJAMENTO_ANUAL_CICLO, Guid.Empty))
{
#region Informações sobre alcance dos alunos nas orientações curriculares
JArray alunoLista = ((JArray)planejamento.SelectToken("AlunoTurmaDisciplinaOrientacaoCurricular") ?? new JArray());
List <CLS_AlunoTurmaDisciplinaOrientacaoCurricular> listaAlunoTurmaDisciplinaOrientacaoCadastrados =
CLS_AlunoTurmaDisciplinaOrientacaoCurricularBO.SelecionaAlunosPorTurmaDisciplina(tud_id, bancoSincronizacao);
listaAlunoTurmaDisciplinaOrientacao =
alunoLista.Count > 0 ?
(from JObject aluno in alunoLista
let alu_id = (long)aluno.SelectToken("alu_id")
let ocr_id = (long)aluno.SelectToken("ocr_id")
let tpc_id = (int)aluno.SelectToken("tpc_id")
let aha_alcancada = (bool)aluno.SelectToken("aha_alcancada")
let aha_efetivada = (bool)aluno.SelectToken("aha_efetivada")
let dataAlteracao = Convert.ToDateTime(aluno.SelectToken("DataAlteracao") ?? new DateTime())
let entMtd = listaMatriculas.Find(p => p.alu_id == alu_id)
where entMtd != null && !entMtd.IsNew
let entAlunoTurmaOrientacao = listaAlunoTurmaDisciplinaOrientacaoCadastrados.Any(p => p.alu_id == entMtd.alu_id &&
p.mtu_id == entMtd.mtu_id &&
p.mtd_id == entMtd.mtd_id &&
p.ocr_id == ocr_id &&
p.tpc_id == tpc_id) ?
listaAlunoTurmaDisciplinaOrientacaoCadastrados.Find(p => p.alu_id == entMtd.alu_id &&
p.mtu_id == entMtd.mtu_id &&
p.mtd_id == entMtd.mtd_id &&
p.ocr_id == ocr_id &&
p.tpc_id == tpc_id) :
new CLS_AlunoTurmaDisciplinaOrientacaoCurricular()
let aha_id = entAlunoTurmaOrientacao != null && entAlunoTurmaOrientacao.aha_id > 0 ?
entAlunoTurmaOrientacao.aha_id :
-1
select new CLS_AlunoTurmaDisciplinaOrientacaoCurricular
{
tud_id = tud_id
,
alu_id = alu_id
,
mtu_id = entMtd.mtu_id
,
mtd_id = entMtd.mtd_id
,
ocr_id = ocr_id
,
tpc_id = tpc_id
,
aha_id = aha_id
,
aha_alcancada = entAlunoTurmaOrientacao.aha_dataAlteracao > dataAlteracao ? entAlunoTurmaOrientacao.aha_alcancada : aha_alcancada
,
aha_efetivada = entAlunoTurmaOrientacao.aha_dataAlteracao > dataAlteracao ? entAlunoTurmaOrientacao.aha_efetivada : aha_efetivada
,
aha_situacao = 1
,
aha_dataAlteracao = dataAlteracao
,
IsNew = aha_id <= 0
}).ToList() :
new List <CLS_AlunoTurmaDisciplinaOrientacaoCurricular>();
#endregion
#region Informações sobre planejamento das orientações curriculares nos bimestre
JArray planejamentoOrientacaoLista = ((JArray)planejamento.SelectToken("PlanejamentoOrientacaoCurricular") ?? new JArray());
listaPlanejamentoOrientacao =
planejamentoOrientacaoLista.Count > 0 ?
(from JObject planejamentoOrientacao in planejamentoOrientacaoLista
select new CLS_PlanejamentoOrientacaoCurricular
{
tud_id = tud_id
,
ocr_id = (long)planejamentoOrientacao.SelectToken("ocr_id")
,
tpc_id = (int)planejamentoOrientacao.SelectToken("tpc_id")
,
poc_planejado = (bool)planejamentoOrientacao.SelectToken("poc_planejado")
,
poc_trabalhado = (bool)planejamentoOrientacao.SelectToken("poc_trabalhado")
,
poc_alcancado = (bool)planejamentoOrientacao.SelectToken("poc_alcancado")
,
tdt_posicao = (byte)(planejamentoOrientacao.SelectToken("tdt_posicao") ?? 1)
}).ToList() :
new List <CLS_PlanejamentoOrientacaoCurricular>();
#endregion
#region Informações sobre o planejamento das orientações curriculares no ano anterior
JArray planejamentoOrientacaoDiagLista = ((JArray)planejamento.SelectToken("PlanejamentoOrientacaoCurricularDiagnostico") ?? new JArray());
listaPlanejamentoDiagnostico =
planejamentoOrientacaoDiagLista.Count > 0 ?
(from JObject diagnostico in planejamentoOrientacaoDiagLista
select new CLS_PlanejamentoOrientacaoCurricularDiagnostico
{
tud_id = tud_id
,
ocr_id = (long)diagnostico.SelectToken("ocr_id")
,
pod_alcancado = (bool)diagnostico.SelectToken("pod_alcancado")
,
tdt_posicao = (byte)(diagnostico.SelectToken("tdt_posicao") ?? 1)
}).ToList() :
new List <CLS_PlanejamentoOrientacaoCurricularDiagnostico>();
#endregion
}
#region Informações sobre os planejamentos anuais e/ou bimestrais
JArray TudPlanejamentoLista = ((JArray)planejamento.SelectToken("TurmaDisciplinaPlanejamento") ?? new JArray());
List <CLS_TurmaDisciplinaPlanejamento> ltPlanejamentoBanco = SelecionaListaPorTurmaDisciplina(tud_id, bancoSincronizacao);
foreach (JObject turmaPlanejamento in TudPlanejamentoLista)
{
DateTime tdp_dataAlteracao = Convert.ToDateTime(turmaPlanejamento.SelectToken("tdp_dataAlteracao").ToString());
if (tdp_dataAlteracao > DateTime.Now.AddMinutes(10))
{
throw new ValidationException("A data de alteração do planejamento é maior que a data atual.");
}
int tpc_id = (int)(turmaPlanejamento.SelectToken("tpc_id") ?? -1);
int tdp_id = (int)turmaPlanejamento.SelectToken("tdp_id");
byte tdt_posicao = (byte)(turmaPlanejamento.SelectToken("tdt_posicao") ?? 1);
CLS_TurmaDisciplinaPlanejamento planejamentoBanco = ltPlanejamentoBanco.Any(p => p.tud_id == tud_id && p.tdp_id == tdp_id && p.tdt_posicao == tdt_posicao) ?
ltPlanejamentoBanco.Find(p => p.tud_id == tud_id && p.tdp_id == tdp_id && p.tdt_posicao == tdt_posicao) :
new CLS_TurmaDisciplinaPlanejamento();
planejamentoBanco.IsNew = planejamentoBanco.tdp_id <= 0;
string tdp_planejamento = (turmaPlanejamento.SelectToken("tdp_planejamento") ?? string.Empty).ToString();
string tdp_diagnostico = (turmaPlanejamento.SelectToken("tdp_diagnostico") ?? string.Empty).ToString();
string tdp_avaliacaoTrabalho = (turmaPlanejamento.SelectToken("tdp_avaliacaoTrabalho") ?? string.Empty).ToString();
string tdp_recursos = (turmaPlanejamento.SelectToken("tdp_recursos") ?? string.Empty).ToString();
string tdp_intervencoesPedagogicas = (turmaPlanejamento.SelectToken("tdp_intervencoesPedagogicas") ?? string.Empty).ToString();
string tdp_registroIntervencoes = (turmaPlanejamento.SelectToken("tdp_registroIntervencoes") ?? string.Empty).ToString();
CLS_TurmaDisciplinaPlanejamento entPlanejamento = new CLS_TurmaDisciplinaPlanejamento();
if (!planejamentoBanco.IsNew)
{
entPlanejamento = planejamentoBanco;
}
else
{
entPlanejamento = new CLS_TurmaDisciplinaPlanejamento
{
tud_id = tud_id
,
tdp_id = -1
,
tpc_id = tpc_id
,
tdt_posicao = (byte)(turmaPlanejamento.SelectToken("tdt_posicao") ?? 1)
,
tdp_situacao = 1
,
pro_id = protocolo.pro_id
};
}
entPlanejamento.tdp_planejamento = RetornaValorTextoSincronizacao(tdp_planejamento, tdp_dataAlteracao, planejamentoBanco.tdp_planejamento, planejamentoBanco.tdp_dataAlteracao);
entPlanejamento.tdp_diagnostico = RetornaValorTextoSincronizacao(tdp_diagnostico, tdp_dataAlteracao, planejamentoBanco.tdp_diagnostico, planejamentoBanco.tdp_dataAlteracao);
entPlanejamento.tdp_avaliacaoTrabalho = RetornaValorTextoSincronizacao(tdp_avaliacaoTrabalho, tdp_dataAlteracao, planejamentoBanco.tdp_avaliacaoTrabalho, planejamentoBanco.tdp_dataAlteracao);
entPlanejamento.tdp_recursos = RetornaValorTextoSincronizacao(tdp_recursos, tdp_dataAlteracao, planejamentoBanco.tdp_recursos, planejamentoBanco.tdp_dataAlteracao);
entPlanejamento.tdp_intervencoesPedagogicas = RetornaValorTextoSincronizacao(tdp_intervencoesPedagogicas, tdp_dataAlteracao, planejamentoBanco.tdp_intervencoesPedagogicas, planejamentoBanco.tdp_dataAlteracao);
entPlanejamento.tdp_registroIntervencoes = RetornaValorTextoSincronizacao(tdp_registroIntervencoes, tdp_dataAlteracao, planejamentoBanco.tdp_registroIntervencoes, planejamentoBanco.tdp_dataAlteracao);
entPlanejamento.cur_id = entCrp.cur_id;
entPlanejamento.crr_id = entCrp.crr_id;
entPlanejamento.crp_id = entCrp.crp_id;
entPlanejamento.tdp_dataAlteracao = tdp_dataAlteracao;
listaPlanejamento.Add(entPlanejamento);
}
#endregion
if (!ACA_ParametroAcademicoBO.ParametroValorBooleanoPorEntidade(eChaveAcademico.PLANEJAMENTO_ANUAL_CICLO, Guid.Empty))
{
#region Salvar alcance dos alunos nas orientações curriculares
processou = CLS_AlunoTurmaDisciplinaOrientacaoCurricularBO.Salvar(listaAlunoTurmaDisciplinaOrientacao, bancoSincronizacao, true);
#endregion
}
#region Salvar os planejamentos anuais e bimestrais
processou |= CLS_PlanejamentoOrientacaoCurricularBO.SalvaPlanejamentoTurmaDisciplina(listaPlanejamento, listaPlanejamentoOrientacao, listaPlanejamentoDiagnostico, bancoSincronizacao, true);
#endregion
}
if (processou)
{
// Processou com sucesso.
protocolo.pro_statusObservacao = String.Format("Protocolo processado com sucesso ({0}).",
DateTime.Now.ToString("dd/MM/yyyy HH:mm"));
protocolo.pro_status = (byte)DCL_ProtocoloBO.eStatus.ProcessadoComSucesso;
}
else
{
if (protocolo.pro_tentativa > tentativasProtocolo)
{
throw new ValidationException(String.Format("Número máximo ({0}) de tentativas de processamento deste protocolo foram excedidas. Erro: {1}"
, tentativasProtocolo, protocolo.pro_statusObservacao));
}
// Não processou sem erro - volta o protocolo para não processado.
protocolo.pro_statusObservacao = String.Format("Protocolo não processado ({0}).",
DateTime.Now.ToString("dd/MM/yyyy hh:mm"));
protocolo.tur_id = -1;
protocolo.tud_id = -1;
protocolo.tau_id = -1;
protocolo.pro_qtdeAlunos = -1;
protocolo.pro_status = (byte)DCL_ProtocoloBO.eStatus.NaoProcessado;
}
dtProtocolo.Rows.Add(DCL_ProtocoloBO.ProtocoloToDataRow(protocolo, dtProtocolo.NewRow()));
}
catch (ArgumentException ex)
{
// Se ocorrer uma excessão de validação, guardar novo status.
protocolo.pro_status = (byte)DCL_ProtocoloBO.eStatus.ProcessadoComErrosValidacao;
protocolo.pro_statusObservacao = ex.Message;
protocolo.tur_id = -1;
protocolo.tud_id = -1;
protocolo.tau_id = -1;
protocolo.pro_qtdeAlunos = -1;
dtProtocolo.Rows.Add(DCL_ProtocoloBO.ProtocoloToDataRow(protocolo, dtProtocolo.NewRow()));
bancoSincronizacao.Close(ex);
}
catch (ValidationException ex)
{
// Se ocorrer uma excessão de validação, guardar novo status.
protocolo.pro_status = (byte)DCL_ProtocoloBO.eStatus.ProcessadoComErrosValidacao;
protocolo.pro_statusObservacao = ex.Message;
protocolo.tur_id = -1;
protocolo.tud_id = -1;
protocolo.tau_id = -1;
protocolo.pro_qtdeAlunos = -1;
dtProtocolo.Rows.Add(DCL_ProtocoloBO.ProtocoloToDataRow(protocolo, dtProtocolo.NewRow()));
bancoSincronizacao.Close(ex);
}
catch (Exception ex)
{
// Se ocorrer uma excessão de erro, guardar novo status.
protocolo.pro_status = (byte)DCL_ProtocoloBO.eStatus.ProcessadoComErro;
protocolo.pro_statusObservacao = ex.Message;
protocolo.tur_id = -1;
protocolo.tud_id = -1;
protocolo.tau_id = -1;
protocolo.pro_qtdeAlunos = -1;
dtProtocolo.Rows.Add(DCL_ProtocoloBO.ProtocoloToDataRow(protocolo, dtProtocolo.NewRow()));
bancoSincronizacao.Close(ex);
}
finally
{
if (bancoSincronizacao.ConnectionIsOpen)
{
bancoSincronizacao.Close();
}
}
}
DCL_ProtocoloBO.AtualizaProtocolos(dtProtocolo);
return(true);
}
/// <summary>
/// Salva as notas das atividades extraclasse
/// </summary>
/// <param name="lstTurmaAtividadeExtraClasseAluno"></param>
/// <returns></returns>
public static bool SalvarEmLote(List <CLS_TurmaAtividadeExtraClasseAluno> lstTurmaAtividadeExtraClasseAluno, long tud_id, int tpc_id, byte tud_tipo, bool fechamentoAutomatico, Guid ent_id, List <CLS_TurmaAtividadeExtraClasse> lstRelacionamento, long tur_id)
{
TalkDBTransaction banco = new CLS_TurmaAtividadeExtraClasseAlunoDAO()._Banco.CopyThisInstance();
banco.Open(IsolationLevel.ReadCommitted);
try
{
List <long> lstTudId = new List <long>();
foreach (CLS_TurmaAtividadeExtraClasse atividade in lstRelacionamento)
{
List <CLS_TurmaAtividadeExtraClasse> lstRelacionadas = CLS_TurmaAtividadeExtraClasseBO.SelecionaAtividadeExtraclasseRelacionada(atividade.taer_id);
List <CLS_TurmaAtividadeExtraClasseAluno> lstLancamento = lstTurmaAtividadeExtraClasseAluno.FindAll(p => p.tud_id == atividade.tud_id && p.tae_id == atividade.tae_id);
List <MTR_MatriculaTurmaDisciplina> lstMatriculaDisciplina = new List <MTR_MatriculaTurmaDisciplina>();
lstRelacionadas.FindAll(p => p.tud_id != atividade.tud_id || p.tae_id != atividade.tae_id).ForEach(p =>
{
if (!lstMatriculaDisciplina.Any(m => m.tud_id == p.tud_id))
{
lstMatriculaDisciplina.AddRange(MTR_MatriculaTurmaDisciplinaBO.SelecionaMatriculasPorTurmaDisciplina(p.tud_id.ToString(), banco));
}
lstLancamento.ForEach(a =>
{
CLS_TurmaAtividadeExtraClasseAluno ent = new CLS_TurmaAtividadeExtraClasseAluno
{
tud_id = p.tud_id,
tae_id = p.tae_id,
alu_id = a.alu_id,
mtu_id = a.mtu_id,
mtd_id = lstMatriculaDisciplina.Find(m => m.alu_id == a.alu_id && m.mtu_id == a.mtu_id && m.tud_id == p.tud_id).mtd_id,
aea_avaliacao = a.aea_avaliacao,
aea_relatorio = a.aea_relatorio,
aea_entregue = a.aea_entregue,
aea_dataAlteracao = a.aea_dataAlteracao,
aea_situacao = 1
};
lstTurmaAtividadeExtraClasseAluno.Add(ent);
});
if (!lstTudId.Any(t => t == p.tud_id))
{
lstTudId.Add(p.tud_id);
}
});
}
using (DataTable dt = lstTurmaAtividadeExtraClasseAluno.Select(p => new TipoTabela_TurmaAtividadeExtraClasseALuno(p).ToDataRow()).CopyToDataTable())
{
CLS_TurmaAtividadeExtraClasseAlunoDAO dao = new CLS_TurmaAtividadeExtraClasseAlunoDAO();
dao._Banco = banco;
if (dao.SalvarEmLote(dt))
{
// Caso o fechamento seja automático, grava na fila de processamento.
if (fechamentoAutomatico && 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);
}
if (lstTudId.Any())
{
List <TUR_TurmaDisciplina> turmaDisciplina = TUR_TurmaDisciplinaBO.GetSelectBy_Turma(tur_id, null, GestaoEscolarUtilBO.MinutosCacheLongo);
lstTudId.ForEach(p =>
{
if (fechamentoAutomatico && turmaDisciplina.Find(t => t.tud_id == p).tud_tipo != (byte)TurmaDisciplinaTipo.DocenteEspecificoComplementacaoRegencia && tpc_id != ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, ent_id))
{
CLS_AlunoFechamentoPendenciaBO.SalvarFilaFrequencia(p, tpc_id, banco);
}
}
);
}
return(true);
}
return(false);
}
}
catch (Exception ex)
{
banco.Close(ex);
throw;
}
finally
{
if (banco.ConnectionIsOpen)
{
banco.Close();
}
}
}
/// <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>
/// 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>
/// Processa os protocolos informados.
/// </summary>
/// <param name="ltProtocolo">Lista de protocolos em processamento.</param>
/// <param name="tentativasProtocolo">Quantidade máxima de tentativas para processar protocolos.</param>
/// <returns></returns>
public static bool ProcessarProtocoloCompensacao(List <DCL_Protocolo> ltProtocolo, int tentativasProtocolo)
{
DataTable dtProtocolo = DCL_Protocolo.TipoTabela_Protocolo();
foreach (DCL_Protocolo protocolo in ltProtocolo.Where(pro => pro.pro_tentativa > tentativasProtocolo))
{
protocolo.pro_statusObservacao = String.Format("Número máximo ({0}) de tentativas de processamento deste protocolo foram excedidas. Erro: {1}"
, tentativasProtocolo, protocolo.pro_statusObservacao);
protocolo.pro_status = (byte)DCL_ProtocoloBO.eStatus.ProcessadoComErrosValidacao;
protocolo.tur_id = -1;
protocolo.tud_id = -1;
protocolo.tau_id = -1;
protocolo.pro_qtdeAlunos = -1;
dtProtocolo.Rows.Add(DCL_ProtocoloBO.ProtocoloToDataRow(protocolo, dtProtocolo.NewRow()));
}
foreach (DCL_Protocolo protocolo in ltProtocolo.Where(pro => pro.pro_tentativa <= tentativasProtocolo))
{
// Abre uma transação para cada protocolo dentro do laço.
// Assim é possível processar o próximo protocolo, mesmo que o atual esteja com erro.
TalkDBTransaction bancoSincronizacao = new CLS_TurmaAulaDAO()._Banco.CopyThisInstance();
bancoSincronizacao.Open(IsolationLevel.ReadCommitted);
bool processou = false;
try
{
if (protocolo.pro_tentativa <= tentativasProtocolo)
{
JObject json = JObject.Parse(protocolo.pro_pacote);
JArray compensacoes = ((JArray)json.SelectToken("CompensacaoFalta") ?? new JArray());
foreach (JObject compensacao in compensacoes)
{
long tud_id = Convert.ToInt64(compensacao.SelectToken("tud_id"));
ACA_FormatoAvaliacao formatoAvaliacao = ACA_FormatoAvaliacaoBO.CarregarPorTud(tud_id);
ACA_CalendarioAnual cal = ACA_CalendarioAnualBO.SelecionaPorTurmaDisciplina(tud_id, bancoSincronizacao);
// apenas protocolos de turmas ativas e do ano letivo corrente podem ser processados
if (!DCL_ProtocoloBO.PodeProcessarProtocolo(0, tud_id))
{
throw new ValidationException("O protocolo pertence a uma turma que não esta ativa ou de um ano letivo diferente do corrente, não pode ser processado!");
}
int cpa_id = Convert.ToInt32(compensacao.SelectToken("cpa_id"));
int quantidadeAulasCompensadas = Convert.ToInt32(compensacao.SelectToken("cpa_quantidadeAulasCompensadas"));
DateTime cpa_dataAlteracao = Convert.ToDateTime(compensacao.SelectToken("cpa_dataAlteracao"));
CLS_CompensacaoAusencia compensacaoAusencia;
long pro_protocoloCriacao = (long)(compensacao.GetValue("pro_protocolo", StringComparison.OrdinalIgnoreCase) ?? "0");
if (cpa_id > 0 || pro_protocoloCriacao <= 0)
{
compensacaoAusencia = new CLS_CompensacaoAusencia
{
tud_id = tud_id,
cpa_id = cpa_id
};
GetEntity(compensacaoAusencia, bancoSincronizacao);
}
else
{
List <DCL_Protocolo> protocoloCriacaoCompensacao = DCL_ProtocoloBO.SelectBy_Protocolos(pro_protocoloCriacao.ToString());
Guid pro_idCriacao = protocoloCriacaoCompensacao.Count() > 0 ? protocoloCriacaoCompensacao[0].pro_id : Guid.Empty;
compensacaoAusencia = SelectByDisciplinaProtocolo(tud_id, pro_idCriacao);
if (!compensacaoAusencia.IsNew)
{
compensacaoAusencia.pro_id = protocolo.pro_id;
}
}
if (compensacaoAusencia.IsNew)
{
compensacaoAusencia.cpa_id = -1;
compensacaoAusencia.cpa_dataCriacao = DateTime.Now;
compensacaoAusencia.pro_id = protocolo.pro_id;
}
else if (!compensacaoAusencia.IsNew && (cpa_dataAlteracao < compensacaoAusencia.cpa_dataAlteracao))
{
throw new ValidationException("Compensação existe e foi alterada mais recentemente.");
}
compensacaoAusencia.tpc_id = Convert.ToInt32(compensacao.SelectToken("tpc_id"));
compensacaoAusencia.cpa_quantidadeAulasCompensadas = quantidadeAulasCompensadas;
compensacaoAusencia.cpa_atividadesDesenvolvidas = Convert.ToString(compensacao.SelectToken("cpa_atividadesDesenvolvidas"));
compensacaoAusencia.cpa_situacao = Convert.ToInt16(compensacao.SelectToken("cpa_situacao"));
compensacaoAusencia.cpa_dataAlteracao = DateTime.Now;
if (compensacaoAusencia.cpa_situacao != 3)
{
JArray arrayAlunos = ((JArray)compensacao.SelectToken("AlunosCompensados") ?? new JArray());
List <CLS_CompensacaoAusenciaAluno> listaAlunos = new List <CLS_CompensacaoAusenciaAluno>();
foreach (JObject jsonAluno in arrayAlunos)
{
int alu_id = Convert.ToInt32(jsonAluno.SelectToken("alu_id"));
MTR_MatriculaTurmaDisciplina matricula = MTR_MatriculaTurmaDisciplinaBO.BuscarPorAlunoTurmaDisciplina(alu_id, tud_id, bancoSincronizacao);
CLS_CompensacaoAusenciaAluno compensacaoAluno = new CLS_CompensacaoAusenciaAluno
{
tud_id = tud_id,
cpa_id = compensacaoAusencia.cpa_id,
alu_id = alu_id,
mtu_id = matricula.mtu_id,
mtd_id = matricula.mtd_id
};
CLS_CompensacaoAusenciaAlunoBO.GetEntity(compensacaoAluno);
if (compensacaoAluno.IsNew)
{
compensacaoAluno.caa_dataCriacao = DateTime.Now;
}
compensacaoAluno.caa_situacao = 1;
compensacaoAluno.caa_dataAlteracao = DateTime.Now;
listaAlunos.Add(compensacaoAluno);
}
processou = Save(compensacaoAusencia, listaAlunos, formatoAvaliacao.fav_fechamentoAutomatico, cal.cal_id, bancoSincronizacao);
}
else
{
// persistindo os dados.
processou = true;
// Caso o fechamento seja automático, grava na fila de processamento.
if (formatoAvaliacao.fav_fechamentoAutomatico && compensacaoAusencia.tpc_id != ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, new Guid()))
{
processou &= CLS_AlunoFechamentoPendenciaBO.SalvarFilaFrequencia(compensacaoAusencia.tud_id, compensacaoAusencia.tpc_id, bancoSincronizacao);
}
processou &= Delete(compensacaoAusencia, bancoSincronizacao);
}
}
}
// Processou com sucesso.
protocolo.pro_statusObservacao = String.Format("Protocolo processado com sucesso ({0}).",
DateTime.Now.ToString("dd/MM/yyyy HH:mm"));
protocolo.pro_status = (byte)DCL_ProtocoloBO.eStatus.ProcessadoComSucesso;
dtProtocolo.Rows.Add(DCL_ProtocoloBO.ProtocoloToDataRow(protocolo, dtProtocolo.NewRow()));
}
catch (ArgumentException ex)
{
// Se ocorrer uma excessão de validação, guardar novo status.
protocolo.pro_status = (byte)DCL_ProtocoloBO.eStatus.ProcessadoComErrosValidacao;
protocolo.pro_statusObservacao = ex.Message;
protocolo.tur_id = -1;
protocolo.tud_id = -1;
protocolo.tau_id = -1;
protocolo.pro_qtdeAlunos = -1;
dtProtocolo.Rows.Add(DCL_ProtocoloBO.ProtocoloToDataRow(protocolo, dtProtocolo.NewRow()));
bancoSincronizacao.Close(ex);
}
catch (ValidationException ex)
{
// Se ocorrer uma excessão de validação, guardar novo status.
protocolo.pro_status = (byte)DCL_ProtocoloBO.eStatus.ProcessadoComErrosValidacao;
protocolo.pro_statusObservacao = ex.Message;
protocolo.tur_id = -1;
protocolo.tud_id = -1;
protocolo.tau_id = -1;
protocolo.pro_qtdeAlunos = -1;
dtProtocolo.Rows.Add(DCL_ProtocoloBO.ProtocoloToDataRow(protocolo, dtProtocolo.NewRow()));
bancoSincronizacao.Close(ex);
}
catch (Exception ex)
{
// Se ocorrer uma excessão de erro, guardar novo status.
protocolo.pro_status = (byte)DCL_ProtocoloBO.eStatus.ProcessadoComErro;
protocolo.pro_statusObservacao = ex.Message;
protocolo.tur_id = -1;
protocolo.tud_id = -1;
protocolo.tau_id = -1;
protocolo.pro_qtdeAlunos = -1;
dtProtocolo.Rows.Add(DCL_ProtocoloBO.ProtocoloToDataRow(protocolo, dtProtocolo.NewRow()));
bancoSincronizacao.Close(ex);
}
finally
{
if (bancoSincronizacao.ConnectionIsOpen)
{
bancoSincronizacao.Close();
}
}
}
DCL_ProtocoloBO.AtualizaProtocolos(dtProtocolo);
return(true);
}
/// <summary>
/// Override do Save passando o banco - salva tambem a tabela CLS_CompensacaoAusenciaAluno
/// </summary>
/// <param name="entity">Entidade a ser salva</param>
/// <param name="lista">Lista de CLS_CompensacaoAusenciaAluno a ser salva</param>
/// <param name="fechamentoAutomatico">Indica se o fechamento é automático.</param>
/// <param name="banco">Transação com banco</param>
/// <returns>Se salvou com sucesso</returns>
public static bool Save(CLS_CompensacaoAusencia entity, List <CLS_CompensacaoAusenciaAluno> lista, bool fechamentoAutomatico, int cal_id, TalkDBTransaction banco)
{
// permite cadatrar compensacao apenas para o ultimo periodo aberto,
// o metodo ja retorna os periodos abertos ordenados do mais recente para o mais antigo
List <sComboPeriodoCalendario> dtPeriodos = ACA_TipoPeriodoCalendarioBO.SelecionaPor_PeriodoVigente_EventoEfetivacaoVigente(-1, entity.tud_id, -1, Guid.Empty, true);
if (dtPeriodos.Count > 0 && dtPeriodos.Any(p => p.tpc_id == entity.tpc_id))
{
//validacoes
DataTable dt = MTR_MatriculaTurmaDisciplinaBO.SelecionaAtivosCompensacaoAusencia(
entity.tud_id,
entity.tpc_id,
0,
entity.cpa_id
);
dt.PrimaryKey = new DataColumn[1] {
dt.Columns["alu_id"]
};
TUR_TurmaDisciplina turmaDisciplina = TUR_TurmaDisciplinaBO.GetEntity(new TUR_TurmaDisciplina {
tud_id = entity.tud_id
});
// se for disciplina especial
if (turmaDisciplina.tud_disciplinaEspecial
// e o docente do tipo especial tem permissao de editar a compensacao
&& CFG_PermissaoDocenteBO.SelecionaPermissaoModulo((byte)EnumTipoDocente.Especial, (byte)EnumModuloPermissao.Compensacoes).Any(p => p.pdc_permissaoEdicao))
{
// adiciono na lista de validacao os aluno especiais
DataTable dtEspecial = MTR_MatriculaTurmaDisciplinaBO.SelecionaAtivosCompensacaoAusenciaFiltroDeficiencia(
-1,
entity.tud_id,
entity.tpc_id,
0,
EnumTipoDocente.Especial,
entity.cpa_id);
dt.Merge(dtEspecial, false, MissingSchemaAction.AddWithKey);
}
bool valida = true;
string msgValidacao = "";
if (turmaDisciplina.tud_tipo == (byte)TurmaDisciplinaTipo.Experiencia)
{
if (!TUR_TurmaDisciplinaTerritorioBO.VerificaOferecimentoExperienciaBimestre(turmaDisciplina.tud_id, cal_id, entity.tpc_id))
{
valida = false;
msgValidacao += "A experiência não possui territórios vigentes no bimestre.";
}
}
// caso exista alguma compensação já criada pro aluno
// valida se pode existir alguma outra.
foreach (CLS_CompensacaoAusenciaAluno cpaa in lista)
{
var results = from row in dt.AsEnumerable()
where row.Field <Int64>("alu_id") == cpaa.alu_id
select row;
if (results.Count() > 0)
{
DataTable aux = results.CopyToDataTable();
int totalFaltasCompensar = Convert.ToInt32(aux.Rows[0]["TotalFaltasCompensar"]);
if (entity.cpa_quantidadeAulasCompensadas > totalFaltasCompensar)
{
valida = false;
msgValidacao += String.Format("Aluno(a) {0} não pode ter essa quantidade de ausências compensadas. </br>", aux.Rows[0]["pes_nome"].ToString());
}
}
else
{
valida = false;
ACA_Aluno aluno = ACA_AlunoBO.GetEntity(new ACA_Aluno {
alu_id = cpaa.alu_id
});
PES_Pessoa pes = PES_PessoaBO.GetEntity(new PES_Pessoa {
pes_id = aluno.pes_id
});
msgValidacao += String.Format("Aluno(a) {0} não pode ter ausências compensadas nos bimestres em que não estava na turma. </br>", pes.pes_nome);
}
}
if (!valida)
{
throw new ValidationException(msgValidacao);
}
// Salva CLS_CompensacaoAusencia
if (!Save(entity, banco))
{
throw new Exception("Erro ao tentar salvar compensação de ausência.");
}
// Caso o fechamento seja automático, grava na fila de processamento.
if (fechamentoAutomatico && entity.tpc_id != ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, new Guid()))
{
CLS_AlunoFechamentoPendenciaBO.SalvarFilaFrequencia(entity.tud_id, entity.tpc_id, banco);
}
List <CLS_CompensacaoAusenciaAluno> listaBanco = CLS_CompensacaoAusenciaAlunoBO.SelectByCpa_id(entity.cpa_id, entity.tud_id);
foreach (CLS_CompensacaoAusenciaAluno item in lista)
{
CLS_CompensacaoAusenciaAluno ent = listaBanco.Find(p => p.tud_id == item.tud_id &&
p.cpa_id == entity.cpa_id &&
p.alu_id == item.alu_id &&
p.mtd_id == item.mtd_id &&
p.mtu_id == item.mtu_id);
if (ent != null)
{
// Achou na lista que vem no banco, altera.
ent.IsNew = false;
CLS_CompensacaoAusenciaAlunoBO.Save(ent, banco);
// Remove o registro da lista do banco para restar somente os que serao excluidos.
listaBanco.Remove(ent);
}
else
{
// Não achou na lista do banco, inclui.
item.cpa_id = entity.cpa_id;
CLS_CompensacaoAusenciaAlunoBO.GetEntity(item, banco);
if (item.caa_situacao == 3)
{
item.caa_situacao = 1;
item.IsNew = false;
}
else
{
item.IsNew = true;
}
CLS_CompensacaoAusenciaAlunoBO.Save(item, banco);
}
}
if (listaBanco.Count > 0)
{
foreach (CLS_CompensacaoAusenciaAluno item in listaBanco)
{
CLS_CompensacaoAusenciaAlunoBO.Delete(item, banco);
}
}
}
else
{
throw new ValidationException("Não existe evento de fechamento do bimestre aberto para realizar o lançamento.");
}
return(true);
}
/// <summary>
/// O método salva as observações para conselho pedagógico.
/// </summary>
/// <param name="tur_id">ID da turma.</param>
/// <param name="alu_id">ID do aluno.</param>
/// <param name="mtu_id">ID da matrícula turma do aluno.</param>
/// <param name="fav_id">ID do formato de avaliação.</param>
/// <param name="ava_id">ID da avaliação.</param>
/// <param name="ltObservacao">Lista de observações.</param>
/// <param name="banco">Banco</param>
/// <param name="ent_id">Id da entidade do usuário logado.</param>
/// <returns></returns>
public static bool SalvarObservacao
(
long tur_id,
long alu_id,
int mtu_id,
long[] tud_ids,
List <CLS_AlunoAvaliacaoTurmaObservacao> listaObservacao,
List <CLS_AlunoAvaliacaoTurma> listaAlunoAvaliacaoTurma,
List <CLS_AlunoAvaliacaoTurmaDisciplina> listaAlunoAvaliacaoTurmaDisciplina,
List <ACA_AlunoAnotacao> listaAlunoAnotacao,
bool permiteEditarResultadoFinal,
Guid usu_idLogado,
byte resultado,
DateTime dataUltimaAlteracaoObservacao,
DateTime dataUltimaAlteracaoNotaFinal,
ACA_FormatoAvaliacao entFormatoAvaliacao,
List <CLS_AvaliacaoTurDisc_Cadastro> listaDisciplina,
List <MTR_MatriculaTurmaDisciplina> listaMatriculaTurmaDisciplina,
int tamanhoMaximoKB,
string[] TiposArquivosPermitidos,
ref List <CLS_AlunoAvaliacaoTurmaDisciplina> listaAtualizacaoEfetivacao,
Guid ent_id,
IDictionary <int, int> dicAvaTpc,
List <CLS_AlunoAvaliacaoTurmaObservacaoBO.DadosAlunoObservacao> listaDadosPeriodo
)
{
TalkDBTransaction banco = new CLS_AlunoAvaliacaoTurmaObservacaoDAO()._Banco.CopyThisInstance();
banco.Open(IsolationLevel.ReadCommitted);
List <AlunoFechamentoPendencia> FilaProcessamento = new List <AlunoFechamentoPendencia>();
int tpc_idUltimoPeriodo = (dicAvaTpc.Count() > 0 ? dicAvaTpc.Max(p => p.Value) : 0);
try
{
foreach (CLS_AlunoAvaliacaoTurmaObservacao observacao in listaObservacao)
{
observacao.usu_idAlteracao = usu_idLogado;
Save(observacao, banco);
}
foreach (CLS_AlunoAvaliacaoTurma alunoAvaliacaoTurma in listaAlunoAvaliacaoTurma)
{
CLS_AlunoAvaliacaoTurmaBO.Save(alunoAvaliacaoTurma, banco);
}
object lockObject = new object();
DataTable dtAlunoAvaliacaoTurmaDisciplina = CLS_AlunoAvaliacaoTurmaDisciplina.TipoTabela_AlunoAvaliacaoTurmaDisciplina();
if (listaAlunoAvaliacaoTurmaDisciplina.Any())
{
Parallel.ForEach
(
listaAlunoAvaliacaoTurmaDisciplina,
alunoAvaliacaoTurmaDisciplina =>
{
lock (lockObject)
{
DataRow drAlunoAvaliacaoTurmaDisciplina = dtAlunoAvaliacaoTurmaDisciplina.NewRow();
dtAlunoAvaliacaoTurmaDisciplina.Rows.Add(
CLS_AlunoAvaliacaoTurmaDisciplinaBO.EntityToDataRow(alunoAvaliacaoTurmaDisciplina, drAlunoAvaliacaoTurmaDisciplina));
}
}
);
}
if (dtAlunoAvaliacaoTurmaDisciplina.Rows.Count > 0)
{
CLS_AlunoAvaliacaoTurmaDisciplinaBO.SalvarEmLotePosConselho(dtAlunoAvaliacaoTurmaDisciplina, banco);
if (entFormatoAvaliacao.fav_fechamentoAutomatico && listaAlunoAvaliacaoTurmaDisciplina.Any())
{
FilaProcessamento.AddRange(listaAlunoAvaliacaoTurmaDisciplina
.Select(p => new AlunoFechamentoPendencia {
tud_id = p.tud_id,
tpc_id = (p.tpc_id > 0 ? p.tpc_id : tpc_idUltimoPeriodo),
afp_frequencia = true,
afp_nota = true,
afp_processado = (Byte)(p.atd_id <= 0 ? 0 : 2)
}).ToList());
}
}
foreach (ACA_AlunoAnotacao alunoAnotacao in listaAlunoAnotacao)
{
ACA_AlunoAnotacaoBO.Save(alunoAnotacao, banco);
}
CLS_AlunoAvaliacaoTurmaDisciplinaBO.SaveAvaliacaoFinal(
tur_id
, entFormatoAvaliacao
, listaDisciplina
, tamanhoMaximoKB
, TiposArquivosPermitidos
, dataUltimaAlteracaoNotaFinal
, listaMatriculaTurmaDisciplina
, ref listaAtualizacaoEfetivacao
, banco);
if (entFormatoAvaliacao.fav_fechamentoAutomatico && listaMatriculaTurmaDisciplina.Any() && (tpc_idUltimoPeriodo > 0))
{
FilaProcessamento.AddRange(listaMatriculaTurmaDisciplina
.Select(p => new AlunoFechamentoPendencia {
tud_id = p.tud_id,
tpc_id = tpc_idUltimoPeriodo,
afp_frequencia = true,
afp_nota = true,
afp_processado = (Byte)(p.mtd_id <= 0 ? 0 : 2)
}).ToList());
}
if (permiteEditarResultadoFinal)
{
// Se for passado o resultado, salva na MTR_MatriculaTurma.
MTR_MatriculaTurma entMatr = new MTR_MatriculaTurma
{
alu_id = alu_id
,
mtu_id = mtu_id
};
MTR_MatriculaTurmaBO.GetEntity(entMatr, banco);
// So registra a alteracao do parecer conclusivo (resultado)
// se for um registro novo e tem valor selecionado, ou se houve alteracao do valor.
if ((entMatr.IsNew && entMatr.mtu_resultado > 0) || entMatr.mtu_resultado != resultado)
{
// Se o registro foi alterado depois da data da alteração mais recente no momento em que os dados foram carregados,
// interrompe o salvamento e alerta o usuário de que é necessário atualizar os dados
if (entMatr != null && !entMatr.IsNew && Convert.ToDateTime(entMatr.mtu_dataAlteracao.ToString()) > dataUltimaAlteracaoObservacao)
{
throw new ValidationException("Existe registro alterado mais recentemente, é necessário atualizar os dados.");
}
else
{
entMatr.usu_idResultado = usu_idLogado;
entMatr.mtu_resultado = resultado;
MTR_MatriculaTurmaBO.Save(entMatr, banco);
if (ACA_ParametroAcademicoBO.ParametroValorBooleanoPorEntidade(eChaveAcademico.GERAR_HISTORICO_SALVAR_PARECER_CONCLUSIVO, ent_id))
{
ACA_AlunoHistoricoBO.GeracaoHistoricoPedagogicoPorAluno(entMatr.alu_id, entMatr.mtu_id, banco);
}
if (entFormatoAvaliacao.fav_fechamentoAutomatico)
{
FilaProcessamento.Add(new AlunoFechamentoPendencia {
tud_id = tud_ids.FirstOrDefault(),
tpc_id = tpc_idUltimoPeriodo,
afp_frequencia = true,
afp_nota = true,
afp_processado = (Byte)(entMatr.IsNew == true ? 0 : 2)
});
}
}
}
}
// Limpa cache do fechamento, para atualizar o check, as notas pos-conselho, o parecer e a sintese final.
string chave = string.Empty;
int tpcId = -1;
listaDadosPeriodo.ForEach(q =>
{
// Fechamento de bimestre
chave = MTR_MatriculaTurmaBO.RetornaChaveCache_GetSelectBy_Turma_Periodo(tur_id, entFormatoAvaliacao.fav_id, q.ava_id);
if (HttpContext.Current != null)
{
HttpContext.Current.Cache.Remove(chave);
}
chave = MTR_MatriculaTurmaDisciplinaBO.RetornaChaveCache_GetSelect_ComponentesRegencia_By_TurmaFormato(tur_id, entFormatoAvaliacao.fav_id, q.ava_id);
CacheManager.Factory.Remove(chave);
// Fechamento final
chave = MTR_MatriculaTurmaBO.RetornaChaveCache_GetSelectBy_Turma_Final(tur_id, entFormatoAvaliacao.fav_id, q.ava_id);
if (HttpContext.Current != null)
{
HttpContext.Current.Cache.Remove(chave);
}
chave = MTR_MatriculaTurmaDisciplinaBO.RetornaChaveCache_GetSelect_ComponentesRegencia_By_TurmaFormato_Final(tur_id, entFormatoAvaliacao.fav_id, q.ava_id);
CacheManager.Factory.Remove(chave);
// Fechamento automatico de bimestre
if (dicAvaTpc.TryGetValue(q.ava_id, out tpcId))
{
chave = String.Format(ModelCache.FECHAMENTO_AUTO_BIMESTRE_COMPONENTES_REGENCIA_MODEL_KEY, tur_id, tpcId);
CacheManager.Factory.Remove(chave);
}
// Fechamento automatico final
chave = String.Format(ModelCache.FECHAMENTO_AUTO_FINAL_COMPONENTES_REGENCIA_MODEL_KEY, tur_id);
CacheManager.Factory.Remove(chave);
});
List <TUR_TurmaDisciplina> listaDisciplinas = TUR_TurmaDisciplinaBO.GetSelectBy_Turma(tur_id, null, GestaoEscolarUtilBO.MinutosCacheLongo);
listaDisciplinas.ForEach(p =>
{
// Fechamento de bimestre
chave = String.Format("{0}_{1}_{2}", ModelCache.FECHAMENTO_BIMESTRE_PATTERN_KEY, p.tud_id, entFormatoAvaliacao.fav_id);
CacheManager.Factory.RemoveByPattern(chave);
chave = String.Format("{0}_{1}_{2}", ModelCache.FECHAMENTO_BIMESTRE_FILTRO_DEFICIENCIA_PATTERN_KEY, p.tud_id, entFormatoAvaliacao.fav_id);
CacheManager.Factory.RemoveByPattern(chave);
// Fechamento final
chave = String.Format("{0}_{1}_{2}", ModelCache.FECHAMENTO_FINAL_PATTERN_KEY, p.tud_id, entFormatoAvaliacao.fav_id);
CacheManager.Factory.RemoveByPattern(chave);
chave = String.Format("{0}_{1}_{2}", ModelCache.FECHAMENTO_FINAL_FILTRO_DEFICIENCIA_PATTERN_KEY, p.tud_id, entFormatoAvaliacao.fav_id);
CacheManager.Factory.RemoveByPattern(chave);
// Fechamento automatico final
chave = String.Format(ModelCache.FECHAMENTO_AUTO_FINAL_MODEL_KEY, p.tud_id);
CacheManager.Factory.Remove(chave);
chave = String.Format(ModelCache.FECHAMENTO_AUTO_FINAL_FILTRO_DEFICIENCIA_MODEL_KEY, p.tud_id);
CacheManager.Factory.Remove(chave);
listaDadosPeriodo.ForEach(q =>
{
// Fechamento automatico de bimestre
if (dicAvaTpc.TryGetValue(q.ava_id, out tpcId))
{
chave = String.Format(ModelCache.FECHAMENTO_AUTO_BIMESTRE_MODEL_KEY, p.tud_id, tpcId);
CacheManager.Factory.Remove(chave);
chave = String.Format(ModelCache.FECHAMENTO_AUTO_BIMESTRE_FILTRO_DEFICIENCIA_MODEL_KEY, p.tud_id, tpcId);
CacheManager.Factory.Remove(chave);
}
});
});
//
//Adiciona tuds para processamento de pendência de notas (quando salva o parecer final
foreach (long tud in tud_ids.Where(t => !FilaProcessamento.Any(f => f.tud_id == t)))
{
FilaProcessamento.Add(new AlunoFechamentoPendencia
{
tud_id = tud,
tpc_id = tpc_idUltimoPeriodo,
afp_frequencia = false,
afp_frequenciaExterna = false,
afp_nota = true,
afp_processado = (byte)2
});
}
if (entFormatoAvaliacao.fav_fechamentoAutomatico && FilaProcessamento.Any(a => a.tpc_id > 0))
{
CLS_AlunoFechamentoPendenciaBO.SalvarFilaPendencias(
FilaProcessamento
.GroupBy(g => new { g.tud_id, g.tpc_id })
.Select(p => new AlunoFechamentoPendencia {
tud_id = p.FirstOrDefault().tud_id,
tpc_id = p.FirstOrDefault().tpc_id,
afp_frequencia = p.FirstOrDefault().afp_frequencia,
afp_nota = p.FirstOrDefault().afp_nota,
afp_processado = FilaProcessamento
.Where(w => w.tud_id == p.FirstOrDefault().tud_id&& w.tpc_id == p.FirstOrDefault().tpc_id)
.Min(m => m.afp_processado)
})
.Where(w => w.tpc_id > 0 && w.tpc_id != ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, ent_id))
.ToList()
, banco);
}
return(true);
}
catch (ValidationException ex)
{
banco.Close(ex);
throw;
}
catch (Exception ex)
{
banco.Close(ex);
throw;
}
finally
{
if (banco.ConnectionIsOpen)
{
banco.Close();
}
}
}
/// <summary>
/// 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();
}
}
}
