/// <summary>
/// Retorna as aulas que os alunos tiveram dentro do bimestre em matrículas diferentes das enviadas no filtro.
/// </summary>
/// <param name="tbAlunosPeriodos"></param>
/// <returns></returns>
public static List <sQuantidadeAulaFaltaAdicional> ConsultaPor_Por_DiferentesMatriculas_Periodo(List <sAlunosDisciplinasPeriodos> listaAlunosFiltro, TalkDBTransaction banco = null)
{
CLS_TurmaAulaAlunoDAO dao = banco == null ? new CLS_TurmaAulaAlunoDAO() : new CLS_TurmaAulaAlunoDAO {
_Banco = banco
};
if (banco == null)
{
dao._Banco.Open(IsolationLevel.ReadCommitted);
}
try
{
DataTable dt = MTR_MatriculaTurmaDisciplina.TipoTabela_MatriculaTurmaDisciplinaPeriodo();
listaAlunosFiltro.ForEach(
p =>
{
DataRow dr = dt.NewRow();
dr["tud_id"] = p.tud_id;
dr["alu_id"] = p.alu_id;
dr["mtu_id"] = p.mtu_id;
dr["mtd_id"] = p.mtd_id;
dr["tpc_id"] = p.tpc_id;
dr["tur_id"] = p.tur_id;
dr["cap_dataInicio"] = p.cap_dataInicio;
dr["cap_dataFim"] = p.cap_dataFim;
dt.Rows.Add(dr);
}
);
DataTable dtRet = dao.SelecionaPor_Por_DiferentesMatriculas_Periodo(dt);
List <sQuantidadeAulaFaltaAdicional> ret = new List <sQuantidadeAulaFaltaAdicional>();
foreach (DataRow dr in dtRet.Rows)
{
ret.Add((sQuantidadeAulaFaltaAdicional)GestaoEscolarUtilBO.DataRowToEntity(dr, new sQuantidadeAulaFaltaAdicional()));
}
return(ret);
}
catch (Exception ex)
{
dao._Banco.Close(ex);
throw;
}
finally
{
if (banco == null && dao._Banco.ConnectionIsOpen)
{
dao._Banco.Close();
}
}
}
/// <summary>
/// Retorna os lançamentos de frequência externa para os alunos da tabela de mts, no tpc informado
/// </summary>
/// <param name="listaMtds"></param>
/// <param name="tpc_id"></param>
/// <returns></returns>
public static List <CLS_AlunoFrequenciaExterna> SelecionaPor_MatriculasDisciplinaPeriodo(List <MTR_MatriculaTurmaDisciplina> listaMtds, int tpc_id)
{
//CLS_AlunoFrequenciaExternaDAO dao = new CLS_AlunoFrequenciaExternaDAO();
DataTable dt = MTR_MatriculaTurmaDisciplina.TipoTabela_AlunoMatriculaTurmaDisciplina();
foreach (MTR_MatriculaTurmaDisciplina item in listaMtds)
{
DataRow dr = GestaoEscolarUtilBO.EntityToDataRow(dt, item);
dt.Rows.Add(dr);
}
DataTable dtRet = new CLS_AlunoFrequenciaExternaDAO().SelecionaPor_MatriculasDisciplinaPeriodo(dt, tpc_id);
return(GestaoEscolarUtilBO.DataTableToListEntity <CLS_AlunoFrequenciaExterna>(dtRet));
}
/// <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);
}
public static bool SalvarFechamentoAutomaticoEmLote(List <CLS_AlunoAvaliacaoTurmaDisciplina> ltAlunoAvaliacaoTurmaDisciplina,
List <CLS_AlunoFechamento> ltAlunoFechamento,
List <MTR_MatriculaTurmaDisciplina> ltMatriculaTurmaDisciplinaResultado,
TalkDBTransaction banco = null)
{
CLS_AlunoFechamentoDAO dao = new CLS_AlunoFechamentoDAO();
if (banco == null)
{
dao._Banco.Open(IsolationLevel.ReadCommitted);
}
else
{
dao._Banco = banco;
}
try
{
using (DataTable dtAlunoAvaliacaoTurmaDisciplina = CLS_AlunoAvaliacaoTurmaDisciplina.TipoTabela_AlunoAvaliacaoTurmaDisciplina(),
dtAlunoFechamento = CLS_AlunoFechamento.TipoTabela_AlunoFechamento(),
dtMatriculaTurmaDisciplinaResultado = MTR_MatriculaTurmaDisciplina.TipoTabela_MatriculaTurmaDisciplinaResultado())
{
if (ltAlunoAvaliacaoTurmaDisciplina.Any())
{
ltAlunoAvaliacaoTurmaDisciplina.ForEach
(
p =>
{
DataRow dr = dtAlunoAvaliacaoTurmaDisciplina.NewRow();
dtAlunoAvaliacaoTurmaDisciplina.Rows.Add(CLS_AlunoAvaliacaoTurmaDisciplinaBO.EntityToDataRow(p, dr));
}
);
}
if (ltAlunoFechamento.Any())
{
ltAlunoFechamento.ForEach
(
p =>
{
DataRow dr = dtAlunoFechamento.NewRow();
dtAlunoFechamento.Rows.Add(EntityToDataRow(p, dr));
}
);
}
if (ltMatriculaTurmaDisciplinaResultado.Any())
{
ltMatriculaTurmaDisciplinaResultado.ForEach
(
p =>
{
DataRow dr = dtMatriculaTurmaDisciplinaResultado.NewRow();
dr["alu_id"] = p.alu_id;
dr["mtu_id"] = p.mtu_id;
dr["mtd_id"] = p.mtd_id;
dr["mtd_avaliacao"] = DBNull.Value;
dr["mtd_relatorio"] = DBNull.Value;
dr["mtd_frequencia"] = DBNull.Value;
dr["mtd_resultado"] = p.mtd_resultado;
dr["apenasResultado"] = p.apenasResultado;
dtMatriculaTurmaDisciplinaResultado.Rows.Add(dr);
}
);
}
return(dao.SalvarFechamentoAutomaticoEmLote(dtAlunoAvaliacaoTurmaDisciplina, dtAlunoFechamento, dtMatriculaTurmaDisciplinaResultado));
}
}
catch (Exception ex)
{
dao._Banco.Close(ex);
throw;
}
finally
{
if (banco == null && dao._Banco.ConnectionIsOpen)
{
dao._Banco.Close();
}
}
}
