/// <summary>
/// Retorna os dados da CLS_AlunoAvaliacaoTurmaDisciplina que sejam pela
/// "chave" da matrícula do aluno na disciplina.
/// </summary>
/// <param name="tud_id">Id da turma disciplina - obrigatório</param>
/// <param name="alu_id">Id do aluno - obrigatório</param>
/// <param name="mtu_id">Id da matrícula do aluno na turma - obrigatório</param>
/// <param name="mtd_id">Id da matrícula do aluno na disciplina - obrigatório</param>
/// <returns>Lista de CLS_AlunoAvaliacaoTurma</returns>
public List <CLS_AlunoAvaliacaoTurmaDisciplina> SelectBy_Disciplina_Aluno
(
long tud_id
, long alu_id
, int mtu_id
, int mtd_id
)
{
List <CLS_AlunoAvaliacaoTurmaDisciplina> lista = new List <CLS_AlunoAvaliacaoTurmaDisciplina>();
QuerySelectStoredProcedure qs = new QuerySelectStoredProcedure("NEW_CLS_AlunoAvaliacaoTurmaDisciplina_SelectBy_Disciplina_Aluno", _Banco);
#region PARAMETROS
Param = qs.NewParameter();
Param.DbType = DbType.Int64;
Param.ParameterName = "@tud_id";
Param.Size = 8;
Param.Value = tud_id;
qs.Parameters.Add(Param);
Param = qs.NewParameter();
Param.DbType = DbType.Int64;
Param.ParameterName = "@alu_id";
Param.Size = 8;
Param.Value = alu_id;
qs.Parameters.Add(Param);
Param = qs.NewParameter();
Param.DbType = DbType.Int32;
Param.ParameterName = "@mtu_id";
Param.Size = 4;
Param.Value = mtu_id;
qs.Parameters.Add(Param);
Param = qs.NewParameter();
Param.DbType = DbType.Int32;
Param.ParameterName = "@mtd_id";
Param.Size = 4;
Param.Value = mtd_id;
qs.Parameters.Add(Param);
#endregion
qs.Execute();
DataTable dt = qs.Return;
foreach (DataRow dr in dt.Rows)
{
CLS_AlunoAvaliacaoTurmaDisciplina entity = new CLS_AlunoAvaliacaoTurmaDisciplina();
entity = DataRowToEntity(dr, entity);
lista.Add(entity);
}
return(lista);
}
/// <summary>
/// Parâmetros para efetuar a alteração preservando a data de criação
/// </summary>
/// <param name="qs"></param>
/// <param name="entity"></param>
protected override void ParamAlterar(QueryStoredProcedure qs, CLS_AlunoAvaliacaoTurmaDisciplina entity)
{
base.ParamAlterar(qs, entity);
// Verificação pq frequência pode ser igual a zero
if (entity.atd_frequencia > -1)
{
qs.Parameters["@atd_frequencia"].Value = entity.atd_frequencia;
}
else
{
qs.Parameters["@atd_frequencia"].Value = DBNull.Value;
}
// Verificação pq número de faltas pode ser igual a zero
if (entity.atd_numeroFaltas > -1)
{
qs.Parameters["@atd_numeroFaltas"].Value = entity.atd_numeroFaltas;
}
else
{
qs.Parameters["@atd_numeroFaltas"].Value = DBNull.Value;
}
if (entity.atd_numeroFaltasReposicao > -1)
{
qs.Parameters["@atd_numeroFaltasReposicao"].Value = entity.atd_numeroFaltasReposicao;
}
else
{
qs.Parameters["@atd_numeroFaltasReposicao"].Value = DBNull.Value;
}
if (entity.atd_numeroFaltasExterna > -1)
{
qs.Parameters["@atd_numeroFaltasExterna"].Value = entity.atd_numeroFaltasExterna;
}
else
{
qs.Parameters["@atd_numeroFaltasExterna"].Value = DBNull.Value;
}
qs.Parameters["@atd_relatorio"].DbType = DbType.String;
qs.Parameters["@atd_relatorio"].Size = Int32.MaxValue;
qs.Parameters.RemoveAt("@atd_dataCriacao");
qs.Parameters.RemoveAt("@atd_registroexterno");
qs.Parameters["@atd_dataAlteracao"].Value = DateTime.Now;
}
/// <summary>
/// Parâmetros para efetuar a exclusão lógica.
/// </summary>
/// <param name="qs"></param>
/// <param name="entity"></param>
protected override void ParamDeletar(QueryStoredProcedure qs, CLS_AlunoAvaliacaoTurmaDisciplina entity)
{
base.ParamDeletar(qs, entity);
Param = qs.NewParameter();
Param.DbType = DbType.Byte;
Param.ParameterName = "@atd_situacao";
Param.Size = 1;
Param.Value = 3;
qs.Parameters.Add(Param);
Param = qs.NewParameter();
Param.DbType = DbType.DateTime;
Param.ParameterName = "@atd_dataAlteracao";
Param.Size = 16;
Param.Value = DateTime.Now;
qs.Parameters.Add(Param);
}
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();
}
}
}
/// <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();
}
}
}
protected override bool ReceberAutoIncremento(QuerySelectStoredProcedure qs, CLS_AlunoAvaliacaoTurmaDisciplina entity)
{
entity.atd_id = Convert.ToInt32(qs.Return.Rows[0][0]);
return(entity.atd_id > 0);
}
/// <summary>
/// Retorna uma entidade carregada, buscando pela "chave" da avaliação do aluno
/// (parâmetros).
/// </summary>
/// <param name="tud_id">Id da turma disciplina - obrigatório</param>
/// <param name="alu_id">Id do aluno - obrigatório</param>
/// <param name="mtu_id">Id da matrícula do aluno na turma - obrigatório</param>
/// <param name="mtd_id">Id da matrícula do aluno na disciplina - obrigatório</param>
/// <param name="fav_id">Id do formato de avaliação - obrigatório</param>
/// <param name="ava_id">Id da avaliação - obrigatório</param>
/// <returns>Entidade CLS_AlunoAvaliacaoTurma</returns>
public CLS_AlunoAvaliacaoTurmaDisciplina LoadBy_ChaveAvaliacaoAluno
(
long tud_id
, long alu_id
, int mtu_id
, int mtd_id
, int fav_id
, int ava_id
)
{
CLS_AlunoAvaliacaoTurmaDisciplina entity = new CLS_AlunoAvaliacaoTurmaDisciplina();
QuerySelectStoredProcedure qs = new QuerySelectStoredProcedure("NEW_CLS_AlunoAvaliacaoTurmaDisciplina_LoadBy_ChaveAvaliacaoAluno", _Banco);
#region PARAMETROS
Param = qs.NewParameter();
Param.DbType = DbType.Int64;
Param.ParameterName = "@tud_id";
Param.Size = 8;
Param.Value = tud_id;
qs.Parameters.Add(Param);
Param = qs.NewParameter();
Param.DbType = DbType.Int64;
Param.ParameterName = "@alu_id";
Param.Size = 8;
Param.Value = alu_id;
qs.Parameters.Add(Param);
Param = qs.NewParameter();
Param.DbType = DbType.Int32;
Param.ParameterName = "@mtu_id";
Param.Size = 4;
Param.Value = mtu_id;
qs.Parameters.Add(Param);
Param = qs.NewParameter();
Param.DbType = DbType.Int32;
Param.ParameterName = "@mtd_id";
Param.Size = 4;
Param.Value = mtd_id;
qs.Parameters.Add(Param);
Param = qs.NewParameter();
Param.DbType = DbType.Int32;
Param.ParameterName = "@fav_id";
Param.Size = 4;
Param.Value = fav_id;
qs.Parameters.Add(Param);
Param = qs.NewParameter();
Param.DbType = DbType.Int32;
Param.ParameterName = "@ava_id";
Param.Size = 4;
Param.Value = ava_id;
qs.Parameters.Add(Param);
#endregion
qs.Execute();
if (qs.Return.Rows.Count > 0)
{
entity = DataRowToEntity(qs.Return.Rows[0], entity);
}
return(entity);
}
/// <summary>
/// Método alterado para que o delete não faça exclusão física e sim lógica (update).
/// </summary>
/// <param name="entity">Entidade CLS_AlunoAvaliacaoTurmaDisciplina</param>
/// <returns>true = sucesso | false = fracasso</returns>
public override bool Delete(CLS_AlunoAvaliacaoTurmaDisciplina entity)
{
__STP_DELETE = "NEW_CLS_AlunoAvaliacaoTurmaDisciplina_Update_Situacao";
return(base.Delete(entity));
}
/// <summary>
/// Método alterado para que o update não faça a alteração da data de criação
/// </summary>
/// <param name="entity">Entidade CLS_AlunoAvaliacaoTurmaDisciplina</param>
/// <returns>true = sucesso | false = fracasso</returns>
protected override bool Alterar(CLS_AlunoAvaliacaoTurmaDisciplina entity)
{
__STP_UPDATE = "NEW_CLS_AlunoAvaliacaoTurmaDisciplina_Update";
return(base.Alterar(entity));
}
