/// <summary>
/// Sobrescrição do método salvar.
/// </summary>
/// <param name="entityCursoReunioes">Entidade de CursoReunioes.</param>
/// <param name="ent_id">Id da entidade do usuário logado.</param>
/// <returns>Verdadeiro se salvou com sucesso.</returns>
public static bool Salvar(ACA_CursoReunioes entityCursoReunioes, Guid ent_id)
{
TalkDBTransaction _bancoGestao = new ACA_EventoDAO()._Banco.CopyThisInstance();
_bancoGestao.Open(IsolationLevel.ReadCommitted);
try
{
// Verifica a validade dos atributos obrigatórios da tabela ACA_CursoReunioes
if (entityCursoReunioes.Validate())
{
bool cadastroReunioesPorPeriodo = ACA_ParametroAcademicoBO.ParametroValorBooleanoPorEntidade(eChaveAcademico.CADASTRAR_REUNIOES_POR_PERIODO_CALENDARIO, ent_id);
// Verifica se existem registros de frequência ligados ao calendário.
if (CLS_FrequenciaReuniaoResponsaveisBO.VerificaFrequenciaPorCalendario(entityCursoReunioes.cal_id, entityCursoReunioes.cap_id, entityCursoReunioes.cur_id, entityCursoReunioes.crr_id, cadastroReunioesPorPeriodo))
{
throw new ValidationException("Não é possível alterar a quantidade de reuniões por período do calendário pois possui outros registros ligados a ele.");
}
return(Save(entityCursoReunioes, _bancoGestao));
}
throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entityCursoReunioes));
}
catch (Exception ex)
{
_bancoGestao.Close(ex);
throw;
}
finally
{
_bancoGestao.Close();
}
}
/// <summary>
/// O método salva um registro CLS_AlunoAvaliacaoTurmaObservacao
/// </summary>
/// <param name="entity">Entidade CLS_AlunoAvaliacaoTurmaObservacao</param>
/// <returns></returns>
public static new bool Save(CLS_AlunoAvaliacaoTurmaObservacao entity)
{
if (entity.Validate())
{
CLS_AlunoAvaliacaoTurmaObservacao entAux = new CLS_AlunoAvaliacaoTurmaObservacao
{
tur_id = entity.tur_id
,
alu_id = entity.alu_id
,
mtu_id = entity.mtu_id
,
fav_id = entity.fav_id
,
ava_id = entity.ava_id
};
GetEntity(entAux);
entity.IsNew = entAux.IsNew;
if (string.IsNullOrEmpty(entity.ato_qualidade) &&
string.IsNullOrEmpty(entity.ato_desempenhoAprendizado) &&
string.IsNullOrEmpty(entity.ato_recomendacaoAluno) &&
string.IsNullOrEmpty(entity.ato_recomendacaoResponsavel))
{
return(entity.IsNew ? true : Delete(entity));
}
else
{
return(new CLS_AlunoAvaliacaoTurmaObservacaoDAO().Salvar(entity));
}
}
throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entity));
}
/// <summary>
/// O método salva um registro CLS_AlunoAvaliacaoTurmaObservacao
/// </summary>
/// <param name="entity">Entidade CLS_AlunoAvaliacaoTurmaObservacao</param>
/// <param name="banco"></param>
/// <returns></returns>
public static new bool Save(CLS_AlunoAvaliacaoTurmaObservacao entity, TalkDBTransaction banco)
{
if (entity.Validate())
{
CLS_AlunoAvaliacaoTurmaObservacao entAux = new CLS_AlunoAvaliacaoTurmaObservacao
{
tur_id = entity.tur_id
,
alu_id = entity.alu_id
,
mtu_id = entity.mtu_id
,
fav_id = entity.fav_id
,
ava_id = entity.ava_id
};
GetEntity(entAux, banco);
entity.IsNew = entAux.IsNew;
return(new CLS_AlunoAvaliacaoTurmaObservacaoDAO {
_Banco = banco
}.Salvar(entity));
}
throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entity));
}
public new static bool Save
(
ACA_AlunoEscolaOrigem entity
, TalkDBTransaction banco
)
{
// Verifica se os dados da pessoa serão sempre salvos em maiúsculo.
string sSalvarMaiusculo = SYS_ParametroBO.ParametroValor(SYS_ParametroBO.eChave.SALVAR_SEMPRE_MAIUSCULO);
bool Salvar_Sempre_Maiusculo = !string.IsNullOrEmpty(sSalvarMaiusculo) && Convert.ToBoolean(sSalvarMaiusculo);
if (Salvar_Sempre_Maiusculo)
{
if (!string.IsNullOrEmpty(entity.eco_nome))
{
entity.eco_nome = entity.eco_nome.ToUpper();
}
}
if (entity.Validate())
{
ACA_AlunoEscolaOrigemDAO dao = new ACA_AlunoEscolaOrigemDAO {
_Banco = banco
};
return(dao.Salvar(entity));
}
throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entity));
}
/// <summary>
/// Salva todas as entidades dentro da estrutura, para salvar um objetivo dos componentes curriculares.
/// </summary>
/// <param name="cadastro">Estrutura a ser salva.</param>
/// <returns></returns>
public static bool Save(ORC_Objetivo_Cadastro cadastro)
{
TalkDBTransaction banco = new ORC_ObjetivoDAO()._Banco.CopyThisInstance();
banco.Open(IsolationLevel.ReadCommitted);
try
{
ORC_Objetivo entity = cadastro.entObjetivo;
if (!entity.Validate())
{
throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entity));
}
Save(entity, banco);
// Salvar conteúdos.
ORC_ConteudoBO.SalvarConteudos(cadastro.listConteudos, entity, banco);
return(true);
}
catch (Exception ex)
{
banco.Close(ex);
throw;
}
finally
{
banco.Close();
}
}
public new static bool Save
(
CLS_TurmaNota entity,
TalkDBTransaction banco
)
{
if (entity.Validate())
{
CLS_TurmaNota entityAtividadeAuxiliar = new CLS_TurmaNota
{
tud_id = entity.tud_id,
tnt_id = entity.tnt_id
};
GetEntity(entityAtividadeAuxiliar, banco);
if (!entityAtividadeAuxiliar.IsNew)
{
entity.tdt_posicao = entityAtividadeAuxiliar.tdt_posicao;
entity.usu_id = entityAtividadeAuxiliar.usu_id;
//entity.usu_idDocenteAlteracao = entityAtividadeAuxiliar.usu_idDocenteAlteracao;
}
return(new CLS_TurmaNotaDAO {
_Banco = banco
}.Salvar(entity));
}
throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entity));
}
public new static bool Save
(
RHU_ColaboradorFuncao entity
, TalkDBTransaction banco
)
{
//Verifica se já existe algum outro colaborador responsável pela unidade administrativa
if (entity.cof_responsavelUa)
{
int cof_id = entity.IsNew ? -1 : entity.cof_id;
if (VerificaVigenciaResponsavelUA(entity.col_id, entity.fun_id, cof_id, entity.ent_id, entity.uad_id, entity.cof_vigenciaInicio, entity.cof_vigenciaFim))
{
throw new ArgumentException("Não pode existir mais de um colaborador responsável por uma mesma unidade administrativa ao mesmo tempo.");
}
}
if (entity.Validate())
{
RHU_ColaboradorFuncaoDAO dao = new RHU_ColaboradorFuncaoDAO {
_Banco = banco
};
return(dao.Salvar(entity));
}
throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entity));
}
/// <summary>
/// Salva uma lista de recursos de sala de aula.
/// </summary>
/// <param name="ltTurmaAulaRecurso"></param>
/// <param name="banco"></param>
/// <returns></returns>
public static bool SalvaRecursosAula
(
List <CLS_TurmaAulaRecurso> ltTurmaAulaRecurso,
TalkDBTransaction banco
)
{
DataTable dtTurmaAulaRecurso = CLS_TurmaAulaRecurso.TipoTabela_TurmaAulaRecurso();
ltTurmaAulaRecurso.ForEach(p =>
{
if (p.Validate())
{
dtTurmaAulaRecurso.Rows.Add(TurmaAulaRecursoToDataRow(p, dtTurmaAulaRecurso.NewRow()));
}
else
{
throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(p));
}
});
// Limpa o cache
ltTurmaAulaRecurso.ForEach(p => GestaoEscolarUtilBO.LimpaCache(retornarChave_GetSelectBy_Turma_Aula(p.tud_id, p.tau_id)));
return(banco == null ?
new CLS_TurmaAulaRecursoDAO().SalvaRecursosAula(dtTurmaAulaRecurso) :
new CLS_TurmaAulaRecursoDAO {
_Banco = banco
}.SalvaRecursosAula(dtTurmaAulaRecurso));
}
/// <summary>
/// Salva a entidade validando ela, e setando a situação de acordo com a vigência.
/// </summary>
/// <param name="entity">Entidade a ser salva</param>
/// <param name="banco">Transação com banco</param>
/// <returns></returns>
public static new bool Save(TUR_TurmaDocente entity, TalkDBTransaction banco)
{
// Validar entidade.
if (!entity.Validate())
{
throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entity));
}
if (entity.tdt_situacao != (byte)TUR_TurmaDocenteSituacao.Excluido)
{
// Colocar situação ativa ou inativa pro docente, de acordo com a vigência.
if (entity.tdt_vigenciaInicio.Date <= DateTime.Now.Date &&
(entity.tdt_vigenciaFim == new DateTime() || entity.tdt_vigenciaFim.Date >= DateTime.Now.Date)
)
{
entity.tdt_situacao = (byte)TUR_TurmaDocenteSituacao.Ativo;
}
else
{
entity.tdt_situacao = (byte)TUR_TurmaDocenteSituacao.Inativo;
}
}
LimpaCache(entity, Guid.Empty);
TUR_TurmaDocenteDAO dao = new TUR_TurmaDocenteDAO {
_Banco = banco
};
return(dao.Salvar(entity));
}
/// <summary>
/// Salva os dados do planejamento da disciplina. Considera a data de alteração do tablet.
/// </summary>
/// <param name="entity">Entidade CLS_TurmaDisciplinaPlanejamento</param>
/// <param name="banco">Transação</param>
public static bool SaveSincronizacaoDiarioClasse(CLS_TurmaDisciplinaPlanejamento entity, TalkDBTransaction banco)
{
if (entity.Validate())
{
// Se for uma inclusão de planejamento.
if (entity.IsNew)
{
// Verifica se já existe um planejamento cadastrado para a mesma disciplina e período do calendário.
int tdp_id = VerificaPlanejamentoExistente(entity.tud_id, entity.tpc_id, entity.tdt_posicao, banco);
// Se existir apenas atualiza o registro já existente.
if (tdp_id > 0)
{
entity.tdp_id = tdp_id;
entity.IsNew = false;
}
}
CLS_TurmaDisciplinaPlanejamentoDAO dao = new CLS_TurmaDisciplinaPlanejamentoDAO {
_Banco = banco
};
return(dao.SalvarSincronizacaoDiarioClasse(entity));
}
throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entity));
}
public static void Save(List <ACA_TipoDisciplinaRelacionada> lstRelacionadas)
{
if (lstRelacionadas.Count > 0)
{
ACA_TipoDisciplinaRelacionadaDAO dao = new ACA_TipoDisciplinaRelacionadaDAO();
TalkDBTransaction banco = dao._Banco.CopyThisInstance();
banco.Open(IsolationLevel.ReadCommitted);
try
{
dao.DeleteByTdsId(lstRelacionadas[0].tds_id);
lstRelacionadas.ForEach(p => { if (p.Validate())
{
Save(p, banco);
}
else
{
throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(p));
} });
}
catch (Exception err)
{
banco.Close(err);
throw;
}
finally
{
banco.Close();
}
}
}
/// <summary>
/// Salva os registros de habilidades para o conteúdo.
/// </summary>
/// <param name="entConteudo">Entidade conteúdo</param>
/// <param name="list">Lista de habilidades para salvar</param>
/// <param name="banco">Transação com banco - obrigatório</param>
internal static void SalvarHabilidadesConteudo(ORC_Conteudo entConteudo, List <ORC_Habilidades> list, TalkDBTransaction banco)
{
foreach (ORC_Habilidades entity in list)
{
entity.obj_id = entConteudo.obj_id;
entity.ctd_id = entConteudo.ctd_id;
entity.IsNew = entity.hbl_id <= 0;
if (!string.IsNullOrEmpty(entity.hbl_descricao))
{
if (!entity.Validate())
{
throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entity));
}
// Verifica se já existe uma habilidade cadastrada com a mesma descrição, no mesmo objetivo e conteúdo.
if (VerificaHabilidadePorNome_Objetivo_Conteudo(entity.obj_id, entity.ctd_id, entity.hbl_id, entity.hbl_descricao))
{
throw new ValidationException("Já existe uma habilidade cadastrada com a descrição " + entity.hbl_descricao + " no mesmo conteúdo.");
}
Save(entity, banco);
}
else
{
if (entity.hbl_id > 0)
{
Delete(entity, banco);
}
}
}
}
/// <summary>
/// O método salva um registro na tabela CLS_AlunoAvaliacaoTurmaDisciplinaRecomendacao.
/// </summary>
/// <param name="entity">Entidade CLS_AlunoAvaliacaoTurmaDisciplinaRecomendacao</param>
/// <returns></returns>
public static new bool Save(CLS_AlunoAvaliacaoTurmaDisciplinaRecomendacao entity)
{
if (entity.Validate())
{
return(new CLS_AlunoAvaliacaoTurmaDisciplinaRecomendacaoDAO().Salvar(entity));
}
throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entity));
}
/// <summary>
/// Salva a entidade de planejamento do ciclo.
/// </summary>
/// <param name="entity">Entidade de planejamento do ciclo.</param>
/// <returns></returns>
public static new bool Save(CLS_PlanejamentoCiclo entity)
{
if (entity.Validate())
{
return(new CLS_PlanejamentoCicloDAO().Salvar(entity));
}
throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entity));
}
/// <summary>
/// Salva uma entidade de turma horário.
/// </summary>
/// <param name="entity"></param>
/// <param name="banco"></param>
/// <returns></returns>
public static new bool Save(TUR_TurmaHorario entity, TalkDBTransaction banco)
{
if (entity.Validate())
{
return(new TUR_TurmaHorarioDAO {
_Banco = banco
}.Salvar(entity));
}
throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entity));
}
/// <summary>
/// Salva a entidade de planejamento do ciclo.
/// </summary>
/// <param name="entity">Entidade de planejamento do ciclo.</param>
/// <returns></returns>
public static new bool Save(CLS_PlanejamentoCiclo entity, TalkDBTransaction banco)
{
if (entity.Validate())
{
return(new CLS_PlanejamentoCicloDAO {
_Banco = banco
}.Salvar(entity));
}
throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entity));
}
/// <summary>
/// O método salva os dados da entidade CLS_AlunoPlanejamento.
/// </summary>
/// <param name="entity"></param>
/// <param name="banco"></param>
/// <returns></returns>
public new static bool Save(CLS_AlunoProjeto entity, TalkDBTransaction banco)
{
if (entity.Validate())
{
return(new CLS_AlunoProjetoDAO {
_Banco = banco
}.Salvar(entity));
}
throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entity));
}
public static new bool Save(CLS_AlunoFrequenciaExterna entity, TalkDBTransaction banco)
{
if (entity.Validate())
{
return(new CLS_AlunoFrequenciaExternaDAO {
_Banco = banco
}.Salvar(entity));
}
throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entity));
}
public static new bool Save(CLS_RelatorioPreenchimentoAlunoTurmaDisciplina entity, TalkDBTransaction banco)
{
if (entity.Validate())
{
return(new CLS_RelatorioPreenchimentoAlunoTurmaDisciplinaDAO {
_Banco = banco
}.Salvar(entity));
}
throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entity));
}
/// <summary>
/// Salva uma carga horária de atividade extraclasse.
/// </summary>
/// <param name="entity"></param>
/// <param name="banco"></param>
/// <returns></returns>
public static new bool Save(ACA_CargaHorariaExtraclasse entity, TalkDBTransaction banco)
{
if (entity.Validate())
{
return(new ACA_CargaHorariaExtraclasseDAO {
_Banco = banco
}.Salvar(entity));
}
throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entity));
}
/// <summary>
/// O método salva um registro na tabela CLS_AlunoAvaliacaoTurmaQualidade.
/// </summary>
/// <param name="entity">Entidade CLS_AlunoAvaliacaoTurmaQualidade</param>
/// <param name="banco"></param>
/// <returns></returns>
public static new bool Save(CLS_AlunoAvaliacaoTurmaQualidade entity, TalkDBTransaction banco)
{
if (entity.Validate())
{
return(new CLS_AlunoAvaliacaoTurmaQualidadeDAO {
_Banco = banco
}.Salvar(entity));
}
throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entity));
}
public static new bool Save(ACA_TipoAreaDocumento entity, TalkDBTransaction banco)
{
if (entity.Validate())
{
return(new ACA_TipoAreaDocumentoDAO {
_Banco = banco
}.Salvar(entity));
}
throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entity));
}
public static new bool Save(CLS_QuestionarioRespostaPreenchimento entity, TalkDBTransaction banco)
{
if (entity.Validate())
{
return(new CLS_QuestionarioRespostaPreenchimentoDAO {
_Banco = banco
}.Salvar(entity));
}
throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entity));
}
/// <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="banco">Transação com banco de dados aberta</param>
/// <returns></returns>
internal static bool Save
(
List <CLS_TurmaAulaAluno> listTurmaAulaAluno
, List <CLS_TurmaAula> listTurmaAula
, List <sDadosAulaProtocolo> ltDadosAulasValidacao
, List <CLS_TurmaAula> ltAulasBanco
, TalkDBTransaction banco
)
{
// Recupera a lista de entidades CLS_TurmaAulaAluno para verificar se ela já existe.
List <CLS_TurmaAulaAluno> listaTurmaAulaAluno = new List <CLS_TurmaAulaAluno>();
ltDadosAulasValidacao.ForEach(p => listaTurmaAulaAluno.AddRange(p.ltTurmaAulaAluno));
DataTable dtTurmaAulaAluno = CLS_TurmaAulaAluno.TipoTabela_TurmaAulaAluno();
foreach (CLS_TurmaAulaAluno entityTurmaAulaAluno in listTurmaAulaAluno)
{
// 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;
}
Validate(entityTurmaAulaAluno, listTurmaAula);
if (entityTurmaAulaAluno.Validate())
{
dtTurmaAulaAluno.Rows.Add(TurmaAulaAlunoToDataRow(entityTurmaAulaAluno, dtTurmaAulaAluno.NewRow()));
}
else
{
throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entityTurmaAulaAluno));
}
}
// Salva os dados de todos os alunos na tabela CLS_TurmaAulaAluno
SalvaFrequenciaAlunos(dtTurmaAulaAluno, banco);
CLS_TurmaAulaBO.SalvarAulas(listTurmaAula, ltDadosAulasValidacao, ltAulasBanco, banco);
return(true);
}
/// <summary>
/// Salva as entiades dentro da lista de conteúdos relacionados ao objetivo.
/// </summary>
/// <param name="listConteudos">Lista de conteúdos a serem salvos.</param>
/// <param name="entObjetivo">Objetivo</param>
/// <param name="banco">Transação com banco - obrigatório.</param>
internal static void SalvarConteudos(List <ORC_Conteudo_Cadastro> listConteudos, ORC_Objetivo entObjetivo, TalkDBTransaction banco)
{
if (listConteudos.Count == 0)
{
throw new ValidationException("Necessário cadastrar no mínimo um conteúdo para o objetivo.");
}
foreach (ORC_Conteudo_Cadastro conteudo in listConteudos)
{
ORC_Conteudo entity = conteudo.entConteudo;
// Verifica se o conteúdo já existe no banco
ORC_Conteudo aux = new ORC_Conteudo {
obj_id = entObjetivo.obj_id, ctd_id = entity.ctd_id
};
GetEntity(aux, banco);
entity.obj_id = entObjetivo.obj_id;
entity.IsNew = aux.IsNew;
if (!entity.Validate())
{
throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entity));
}
if (conteudo.listItensConteudo.Count == 0)
{
throw new ValidationException("Necessário cadastrar no mínimo um item para o conteúdo.");
}
if (conteudo.listHabilidades.Count == 0)
{
throw new ValidationException("Necessário cadastrar no mínimo uma habilidade para o conteúdo.");
}
// Salva somente se tiver sub-item cadastrado.
if ((conteudo.listItensConteudo.Count > 0) ||
(conteudo.listHabilidades.Count > 0) ||
(conteudo.listPeriodos.Count > 0))
{
if (entity.IsNew)
{
Save(entity, banco);
}
}
// Salvar sub-cadastros.
ORC_ConteudoItemBO.SalvarItensConteudo(entity, conteudo.listItensConteudo, banco);
ORC_HabilidadesBO.SalvarHabilidadesConteudo(entity, conteudo.listHabilidades, banco);
ORC_ConteudoTipoPeriodoCalendarioBO.SalvarPeriodos(entity, conteudo.listPeriodos, banco);
}
}
public static new bool Save(CLS_ConfiguracaoAtividadeQualificador entity, TalkDBTransaction banco)
{
if (!entity.Validate())
{
throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entity));
}
CLS_ConfiguracaoAtividadeQualificadorDAO dao = new CLS_ConfiguracaoAtividadeQualificadorDAO {
_Banco = banco
};
return(dao.Salvar(entity));
}
/// <summary>
/// Salva a entidade DCL_ProtocoloHistorico.
/// </summary>
/// <param name="entity">Entidade a ser salva</param>
/// <param name="banco">Transação com banco de dados</param>
/// <returns></returns>
public static new bool Save(DCL_ProtocoloHistorico entity, TalkDBTransaction banco)
{
if (!entity.Validate())
{
throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entity));
}
DCL_ProtocoloHistoricoDAO dao = new DCL_ProtocoloHistoricoDAO {
_Banco = banco
};
return(dao.Salvar(entity));
}
/// <summary>
/// Salva a avaliação para o aluno.
/// </summary>
/// <param name="banco">Transação com banco - obrigatório</param>
/// <param name="entity">Entidade para salvar</param>
public static new bool Save(ACA_AlunoCurriculoAvaliacao entity, TalkDBTransaction banco)
{
if (!entity.Validate())
{
throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entity));
}
ACA_AlunoCurriculoAvaliacaoDAO dao = new ACA_AlunoCurriculoAvaliacaoDAO
{
_Banco = banco
};
return(dao.Salvar(entity));
}
/// <summary>
/// O método realiza as validações necessárias e salva uma orientação curricular.
/// </summary>
/// <param name="entity">Entidade que representa uma orientação curricular.</param>
/// <returns></returns>
public static new bool Save(ORC_OrientacaoCurricularNivelAprendizado entity, TalkDBTransaction banco)
{
if (entity.Validate())
{
GestaoEscolarUtilBO.LimpaCache(string.Format(ORC_OrientacaoCurricularNivelAprendizadoBO.Cache_SelecionaPorOrientacaoNivelAprendizado));
ORC_OrientacaoCurricularNivelAprendizadoDAO dao = new ORC_OrientacaoCurricularNivelAprendizadoDAO {
_Banco = banco
};
return(dao.Salvar(entity));
}
throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entity));
}
public new static bool Save
(
ACA_CurriculoEscolaPeriodo entity
, TalkDBTransaction banco)
{
if (entity.Validate())
{
ACA_CurriculoEscolaPeriodoDAO dao = new ACA_CurriculoEscolaPeriodoDAO {
_Banco = banco
};
return(dao.Salvar(entity));
}
throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entity));
}