public static DataTable GetSelect
(
long col_id
, bool paginado
, int currentPage
, int pageSize
, Guid ent_id
, TalkDBTransaction banco = null
)
{
if (pageSize == 0)
{
pageSize = 1;
}
totalRecords = 0;
bool MostraCodigoEscola = ACA_ParametroAcademicoBO.ParametroValorBooleanoPorEntidade(eChaveAcademico.ORDENAR_ESCOLAS_POR_CODIGO, ent_id);
RHU_ColaboradorCargoDAO dao = new RHU_ColaboradorCargoDAO();
if (banco != null)
{
dao._Banco = banco;
}
return(dao.SelectBy_Pesquisa(col_id, MostraCodigoEscola, paginado, currentPage / pageSize, pageSize, out totalRecords));
}
/// <summary>
/// Excluindo documento do responsável
/// </summary>
/// <param name="listaRespDocumento">Busca do banco os documentos anteriores</param>
/// <param name="listaDocumentoInseridos">Documentos atuais</param>
/// <param name="pes_id">pes_id do responsável</param>
/// <param name="bancoCore"></param>
private static void ExcluirDocumentoReponsavel
(
List <PES_PessoaDocumento> listaRespDocumento
, List <PES_PessoaDocumento> listaDocumentoInseridos
, Guid pes_id
, TalkDBTransaction bancoCore
)
{
foreach (PES_PessoaDocumento item in listaRespDocumento)
{
if (!listaDocumentoInseridos.Exists
(p =>
p.tdo_id == item.tdo_id
))
{
// Se o tipo de documento não existir mais, excluir.
PES_PessoaDocumento doc = new PES_PessoaDocumento {
pes_id = pes_id, tdo_id = item.tdo_id
};
PES_PessoaDocumentoBO.Delete(doc, bancoCore);
// Decrementa integridade do tipo de documento.
SYS_TipoDocumentacaoBO.DecrementaIntegridade(doc.tdo_id, bancoCore);
}
}
}
/// <summary>
/// Verifica se existe o cargo na classificação da escola.
/// </summary>
/// <param name="esc_id">Id da escola</param>
/// <param name="crg_id">Id do cargo</param>
/// <returns></returns>
public static bool VerificaExisteCargoClassificacao(int esc_id, int crg_id, TalkDBTransaction banco = null)
{
ESC_EscolaClassificacaoDAO dao = banco == null ? new ESC_EscolaClassificacaoDAO() : new ESC_EscolaClassificacaoDAO {
_Banco = banco
};
try
{
if (banco == null)
{
dao._Banco.Open(IsolationLevel.ReadCommitted);
}
return(dao.VerificaExisteCargoClassificacao(esc_id, crg_id));
}
catch (Exception ex)
{
if (banco == null)
{
dao._Banco.Close(ex);
}
throw;
}
finally
{
if (banco == null && dao._Banco.ConnectionIsOpen)
{
dao._Banco.Close();
}
}
}
public new static bool Save
(
SYS_ModuloSiteMap entity
, TalkDBTransaction banco
)
{
if (entity.Validate())
{
if (VerificaURLExistente(entity))
{
throw new ValidationException("Já existe um SiteMap cadastrado com a URL '" + entity.msm_url + "' no sistema.");
}
SYS_ModuloSiteMapDAO dao = new SYS_ModuloSiteMapDAO {
_Banco = banco
};
dao.Salvar(entity);
}
else
{
throw new ValidationException(entity.PropertiesErrorList[0].Message);
}
return(true);
}
/// <summary>
/// Salva os dados do planejamento da disciplina
/// </summary>
/// <param name="entity">Entidade CLS_TurmaDisciplinaPlanejamento</param>
/// <param name="banco">Transação</param>
public new static bool Save(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.Salvar(entity));
}
throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entity));
}
/// <summary>
/// Salva os dados em lote
/// </summary>
/// <param name="list">Lista de dados.</param>
/// <param name="banco">Transação.</param>
/// <returns>True em caso de sucesso.</returns>
public static bool SalvarEmLote(List <CLS_FrequenciaReuniao> list, TalkDBTransaction banco = null)
{
if (list.Any())
{
List <CLS_FrequenciaReuniao_SalvarEmLote> listFrequenciaReuniao =
list.Select(p => new CLS_FrequenciaReuniao_SalvarEmLote
{
tur_id = p.tur_id,
cal_id = p.cal_id,
cap_id = p.cap_id,
frp_id = p.frp_id,
frr_efetivado = p.frr_efetivado
}).ToList();
DataTable dtFrequenciaReuniao = GestaoEscolarUtilBO.EntityToDataTable <CLS_FrequenciaReuniao_SalvarEmLote>(listFrequenciaReuniao);
return(banco == null ?
new CLS_FrequenciaReuniaoDAO().SalvarEmLote(dtFrequenciaReuniao) :
new CLS_FrequenciaReuniaoDAO {
_Banco = banco
}.SalvarEmLote(dtFrequenciaReuniao));
}
return(true);
}
/// <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));
}
public static List <TUR_TurmaCurriculoAvaliacao> SelecionaAvaliacaoPorTurma
(
long tur_id
, TalkDBTransaction banco
)
{
List <TUR_TurmaCurriculoAvaliacao> lista = new List <TUR_TurmaCurriculoAvaliacao>();
TUR_TurmaCurriculoAvaliacaoDAO dao = new TUR_TurmaCurriculoAvaliacaoDAO
{
_Banco = banco
};
DataTable dt = dao.SelectBy_Turma(tur_id);
foreach (DataRow dr in dt.Rows)
{
TUR_TurmaCurriculoAvaliacao entity = new TUR_TurmaCurriculoAvaliacao();
entity = dao.DataRowToEntity(dr, entity);
lista.Add(entity);
}
return(lista);
}
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>
/// Retorna a quantidade de aulas e faltas do aluno por período do calendário
/// </summary>
/// <param name="tur_id">ID da turma</param>
/// <param name="alu_id">ID do aluno</param>
/// <param name="mtu_id">ID da matricula na turma do aluno</param>
/// <param name="tpc_id">ID do período do calendário</param>
/// <param name="tipoLancamento">Tipo de lançamento de frequência</param>
/// <param name="dataInicial">Data inicial</param>
/// <param name="dataFinal">Data final</param>
/// <param name="qtdeAulas">Retorna a quantidade total de aulas do período do calendário</param>
/// <param name="qtdeFaltas">Retorna a quantidade total de faltas do período do calendário </param>
/// <param name="banco">Transação com banco - opcional</param>
public static void CalcularFrequenciaGlobal
(
long tur_id
, long alu_id
, int mtu_id
, int tpc_id
, byte tipoLancamento
, DateTime dataInicial
, DateTime dataFinal
, out int qtdeAulas
, out int qtdeFaltas
, TalkDBTransaction banco
)
{
MTR_MovimentacaoDAO dao = new MTR_MovimentacaoDAO();
if (banco != null)
{
dao._Banco = banco;
}
DataTable dt = dao.CalcularFrequenciaGlobal(tur_id, alu_id, mtu_id, tpc_id, tipoLancamento, dataInicial, dataFinal);
if (dt.Rows.Count > 0)
{
qtdeAulas = Convert.ToInt32(dt.Rows[0]["qtAulas"]);
qtdeFaltas = Convert.ToInt32(dt.Rows[0]["qtFaltas"]);
}
else
{
qtdeAulas = 0;
qtdeFaltas = 0;
}
}
public new static bool Save
(
PES_PessoaEndereco entity
, TalkDBTransaction banco
)
{
PES_PessoaEnderecoDAO dal = new PES_PessoaEnderecoDAO {
_Banco = banco
};
try
{
if (entity.Validate())
{
dal.Salvar(entity);
}
else
{
throw new ValidationException(entity.PropertiesErrorList[0].Message);
}
return(true);
}
catch
{
throw;
}
}
/// <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));
}
public new static bool Save(ACA_CalendarioPeriodo entityCalPeriodo, TalkDBTransaction banco)
{
try
{
if (entityCalPeriodo.Validate())
{
ACA_CalendarioPeriodoDAO CalPeriodoDAO = new ACA_CalendarioPeriodoDAO {
_Banco = banco
};
// Removendo o cache
RemoveCacheCalendarioPeriodo(entityCalPeriodo.cal_id, entityCalPeriodo.tpc_id);
CalPeriodoDAO.Salvar(entityCalPeriodo);
}
else
{
throw new ValidationException(entityCalPeriodo.PropertiesErrorList[0].Message);
}
return(true);
}
catch (Exception ex)
{
throw (ex);
}
}
/// <summary>
/// Retorna a data de início e fim do período do calendário do tipo informado
/// (quando informado o tpc_id).
/// Quando não informado o tpc_id, retorna o primeiro período de acordo
/// com as avaliações relacionadas.
/// </summary>
/// <param name="tpc_id">ID do tipo de período do calendário</param>
/// <param name="tur_id">ID da turma</param>
/// <param name="fav_id">ID do formato de avaliação</param>
/// <param name="banco">Transação com banco - obrigatório</param>
/// <param name="cap_dataInicio">Data de início do período</param>
/// <param name="cap_dataFim">Data de fim do período</param>
/// <param name="UltimoPeriodo">Flag que indica se o período do calendário é o último cadastrado para o calendário</param>
/// <returns></returns>
public static void RetornaDatasPeriodoPor_FormatoAvaliacaoTurma
(
int tpc_id
, long tur_id
, int fav_id
, TalkDBTransaction banco
, out DateTime cap_dataInicio
, out DateTime cap_dataFim
, out bool UltimoPeriodo
)
{
ACA_CalendarioPeriodoDAO dao = banco == null ? new ACA_CalendarioPeriodoDAO() : new ACA_CalendarioPeriodoDAO {
_Banco = banco
};
DataTable dt = dao.SelectBy_FormatoAvaliacaoTurma(tpc_id, string.Empty, tur_id, fav_id);
if (dt.Rows.Count > 0)
{
cap_dataInicio = Convert.ToDateTime(dt.Rows[0]["cap_dataInicio"]);
cap_dataFim = Convert.ToDateTime(dt.Rows[0]["cap_dataFim"]);
UltimoPeriodo = Convert.ToBoolean(dt.Rows[0]["UltimoPeriodo"]);
}
else
{
cap_dataInicio = new DateTime();
cap_dataFim = new DateTime();
UltimoPeriodo = false;
}
}
/// <summary>
/// Verifica se j� existe um tema com o mesmo nome.
/// </summary>
/// <param name="tep_id">ID do tema.</param>
/// <param name="tep_nome">Nome do tema.</param>
/// <returns></returns>
public static bool VerificaExistePorNome(int tep_id, string tep_nome, TalkDBTransaction banco = null)
{
TalkDBTransaction bancoCore = banco == null ? new CFG_TemaPadraoDAO()._Banco.CopyThisInstance() : banco;
if (banco == null || (!bancoCore.ConnectionIsOpen))
{
bancoCore.Open(IsolationLevel.ReadCommitted);
}
try
{
return(new CFG_TemaPadraoDAO {
_Banco = bancoCore
}.VerificaExistePorNome(tep_id, tep_nome));
}
catch (Exception ex)
{
if (banco == null)
{
bancoCore.Close(ex);
}
throw;
}
finally
{
if (banco == null && bancoCore.ConnectionIsOpen)
{
bancoCore.Close();
}
}
}
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));
}
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));
}
/// <summary>
/// Override do GetEntity que guarda em Cache a entidade retornada.
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public new static ACA_TipoDisciplina GetEntity(ACA_TipoDisciplina entity, TalkDBTransaction banco = null)
{
string chave = RetornaChaveCache_GetEntity(entity);
ACA_TipoDisciplinaDAO dao = new ACA_TipoDisciplinaDAO();
if (banco != null)
{
dao._Banco = banco;
}
GestaoEscolarUtilBO.CopiarEntity
(
CacheManager.Factory.Get
(
chave,
() =>
{
dao.Carregar(entity);
return(entity);
},
GestaoEscolarUtilBO.MinutosCacheMedio
),
entity
);
return(entity);
}
/// <summary>
/// Override do GetEntity que guarda em Cache a entidade retornada.
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public new static ACA_EscalaAvaliacao GetEntity(ACA_EscalaAvaliacao entity, TalkDBTransaction banco = null)
{
// Chave padrão do cache - nome do método + parâmetros.
string chave = RetornaChaveCache_GetEntity(entity);
ACA_EscalaAvaliacaoDAO dao = new ACA_EscalaAvaliacaoDAO();
if (banco != null)
{
dao._Banco = banco;
}
GestaoEscolarUtilBO.CopiarEntity
(
CacheManager.Factory.Get
(
chave,
() =>
{
dao.Carregar(entity);
return(entity);
},
GestaoEscolarUtilBO.MinutosCacheMedio
),
entity
);
return(entity);
}
/// <summary>
/// Salva a lista de log de nota em lote
/// </summary>
/// <param name="listLogNota">Lista de log de notas</param>
/// <param name="banco">Transação do banco</param>
public static bool SalvarEmLote(List <LOG_TurmaNota_Alteracao> listLogNota, TalkDBTransaction banco)
{
DataTable dtLOGTurmaNotaAlteracao = LOG_TurmaNota_Alteracao.TipoTabela_LOG_TurmaNota_Alteracao();
if (listLogNota != null && listLogNota.Any())
{
object lockObject = new object();
Parallel.ForEach
(
listLogNota,
logNota =>
{
lock (lockObject)
{
DataRow dr = dtLOGTurmaNotaAlteracao.NewRow();
dtLOGTurmaNotaAlteracao.Rows.Add(LOGTurmaNotaAlteracaoToDataRow(logNota, dr));
}
}
);
bool retorno = banco == null ?
new LOG_TurmaNota_AlteracaoDAO().SalvarEmLote(dtLOGTurmaNotaAlteracao) :
new LOG_TurmaNota_AlteracaoDAO {
_Banco = banco
}.SalvarEmLote(dtLOGTurmaNotaAlteracao);
return(retorno);
}
return(true);
}
/// <summary>
/// Override do GetEntity que guarda em Cache a entidade retornada.
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public new static ACA_Curriculo GetEntity(ACA_Curriculo entity, TalkDBTransaction banco = null)
{
ACA_CurriculoDAO dao = banco == null ? new ACA_CurriculoDAO() : new ACA_CurriculoDAO {
_Banco = banco
};
if (HttpContext.Current != null)
{
// Chave padrão do cache - nome do método + parâmetros.
string chave = RetornaChaveCache_GetEntity(entity);
object cache = HttpContext.Current.Cache[chave];
if (cache == null)
{
dao.Carregar(entity);
// Adiciona cache com validade de 6h.
HttpContext.Current.Cache.Insert(chave, entity, null, DateTime.Now.AddMinutes(GestaoEscolarUtilBO.MinutosCacheMedio)
, System.Web.Caching.Cache.NoSlidingExpiration);
}
else
{
GestaoEscolarUtilBO.CopiarEntity(cache, entity);
}
return(entity);
}
dao.Carregar(entity);
return(entity);
}
/// <summary>
/// Seleciona o formato de avaliação de acordo com a turma.
/// </summary>
/// <param name="tur_id">Id da turma.</param>
/// <returns>Formato de avaliação.</returns>
public new static ACA_FormatoAvaliacao CarregarPorTur(long tur_id, TalkDBTransaction banco = null)
{
ACA_FormatoAvaliacao entity = new ACA_FormatoAvaliacao();
string chave = string.Format(ModelCache.FORMATO_AVALIACAO_POR_TURMA_MODEL_KEY, tur_id);
ACA_FormatoAvaliacaoDAO dao = new ACA_FormatoAvaliacaoDAO();
if (banco != null)
{
dao._Banco = banco;
}
GestaoEscolarUtilBO.CopiarEntity
(
CacheManager.Factory.Get
(
chave,
() =>
{
entity = dao.SelecionarPorTur(tur_id);
return(entity);
},
GestaoEscolarUtilBO.MinutosCacheMedio
),
entity
);
return(entity);
}
public int SelectCursoPeriodoBy_nap_id(int nap_id, int nvl_id, TalkDBTransaction banco)
{
QuerySelectStoredProcedure qs = new QuerySelectStoredProcedure("NEW_ORC_NivelAprendizado_SelectCursoPeriodoBy_nap_id", banco);
try
{
#region Parâmetros
Param = qs.NewParameter();
Param.DbType = DbType.Int32;
Param.ParameterName = "@nap_id";
Param.Size = 4;
Param.Value = nap_id;
qs.Parameters.Add(Param);
Param = qs.NewParameter();
Param.DbType = DbType.Int32;
Param.ParameterName = "@nvl_id";
Param.Size = 4;
Param.Value = nvl_id;
qs.Parameters.Add(Param);
#endregion
qs.Execute();
return(qs.Return.Rows.Count > 0 ? Convert.ToInt32(qs.Return.Rows[0]["nap_id"]) : 0);
}
finally
{
qs.Parameters.Clear();
}
}
/// <summary>
/// Remove todas turmadisciplinas relacionadas ao planejamento do aluno
/// </summary>
/// <param name="alu_id">ID do aluno</param>
/// <param name="tud_id">ID da turmadisciplina</param>
/// <param name="apl_id">ID do planejamento do aluno</param>
public static void LimparRelacionadas(long alu_id, long tud_id, int apl_id, TalkDBTransaction banco)
{
CLS_AlunoPlanejamentoRelacionadaDAO dao = new CLS_AlunoPlanejamentoRelacionadaDAO();
dao._Banco = banco;
dao.LimparRelacionadas(alu_id, tud_id, apl_id);
}
/// <summary>
/// Atualiza a profissão e a situação da pessoa (Responsável).
/// Caso for alterado a profissão de um responsável
/// Caso for do tipo 4 - (Falecido) situação será atualizado
/// As atualizações serão feitas para todos a alunos no qual o mesmo é responsável
/// </summary>
/// <param name="pes_id">pes_id do responsável do aluno</param>
/// <param name="alr_profissao">profissão do responsável</param>
/// <param name="alr_empresa">empresa do responsável</param>
/// <param name="alr_situacao">situação do responsável</param>
/// <param name="banco"></param>
/// <returns></returns>
public static bool AtualizaResponsavel_Profissao_Situacao
(
Guid pes_id
, string alr_profissao
, string alr_empresa
, byte alr_situacao
, TalkDBTransaction banco
)
{
ACA_AlunoResponsavelDAO dao = new ACA_AlunoResponsavelDAO();
if (banco != null)
{
dao._Banco = banco;
}
try
{
return(dao.Update_ProfissaoSituacao_AlunoResponsavel(pes_id, alr_profissao, alr_empresa, alr_situacao));
}
catch
{
throw;
}
}
/// <summary>
/// Retorna os períodos da disciplina eletiva do aluno
/// </summary>
/// <param name="cur_id">Id do curso</param>
/// <param name="crr_id">Id do curriculo</param>
/// <param name="dis_id">Id da disciplina</param>
/// <param name="banco">Conexão aberta com o banco de dados</param>
public static List <ACA_CurriculoDisciplina> SelecionaListaPeriodosDisciplinasEletivasAlunos
(
int cur_id
, int crr_id
, int dis_id
, TalkDBTransaction banco
)
{
List <ACA_CurriculoDisciplina> list = new List <ACA_CurriculoDisciplina>();
ACA_CurriculoDisciplinaDAO dao = new ACA_CurriculoDisciplinaDAO {
_Banco = banco
};
DataTable dt = dao.SelectBy_EletivasAlunos(cur_id, crr_id, dis_id);
foreach (DataRow dr in dt.Rows)
{
ACA_CurriculoDisciplina ent = new ACA_CurriculoDisciplina();
ent = dao.DataRowToEntity(dr, ent);
list.Add(ent);
}
// Retorna a lista de períodos da disciplina eletiva do aluno
return(list);
}
public static List <StructCadastro> RetornaResponsaveisAluno
(
long alu_id
, TalkDBTransaction banco
)
{
List <StructCadastro> lista = new List <StructCadastro>();
ACA_AlunoResponsavelDAO dao = new ACA_AlunoResponsavelDAO();
if (banco != null)
{
dao._Banco = banco;
}
DataTable dt = dao.SelectBy_Aluno(alu_id);
foreach (DataRow dr in dt.Rows)
{
StructCadastro item = new StructCadastro();
item.entAlunoResp = dao.DataRowToEntity(dr, new ACA_AlunoResponsavel());
item.entPessoa = new PES_PessoaDAO().DataRowToEntity(dr, new PES_Pessoa());
item.listPessoaDoc = InserirListDocumentoResp(dr, item.entPessoa.pes_id);
lista.Add(item);
}
return(lista);
}
public static bool DeletarPorEletivasAlunos
(
ACA_CurriculoDisciplina entity
, TalkDBTransaction banco
, Guid ent_id
)
{
if (VerificaCurriculoDisciplina(entity.cur_id, entity.crr_id, entity.crp_id, entity.dis_id, banco))
{
ACA_CurriculoPeriodo crp = new ACA_CurriculoPeriodo {
cur_id = entity.cur_id, crr_id = entity.crr_id, crp_id = entity.crp_id
};
ACA_CurriculoPeriodoBO.GetEntity(crp, banco);
ACA_Disciplina dis = new ACA_Disciplina {
dis_id = entity.dis_id
};
ACA_DisciplinaBO.GetEntity(dis, banco);
throw new ValidationException("Não é possível excluir o(a) " + GestaoEscolarUtilBO.nomePadraoPeriodo(ent_id).ToLower() + " " + crp.crp_descricao + " do(a) " +
CustomResource.GetGlobalResourceObject("Mensagens", "MSG_DISCIPLINA") + " eletiva " + dis.dis_nome + ", pois possui outros registros ligados a ele(a).");
}
ACA_CurriculoDisciplinaDAO dao = new ACA_CurriculoDisciplinaDAO {
_Banco = banco
};
return(dao.Update_Situacao_By_EletivasAlunos(entity.cur_id, entity.crr_id, entity.crp_id, entity.dis_id));
}
public new static bool Save
(
PES_PessoaDeficiencia entity
, TalkDBTransaction banco
)
{
PES_PessoaDeficienciaDAO dao = new PES_PessoaDeficienciaDAO();
dao._Banco = banco;
try
{
if (entity.Validate())
{
dao.Salvar(entity);
}
else
{
throw new ValidationException(entity.PropertiesErrorList[0].Message);
}
return(true);
}
catch
{
throw;
}
}
public new static bool Save
(
PES_CertidaoCivil entity
, TalkDBTransaction banco
)
{
PES_CertidaoCivilDAO dal = new PES_CertidaoCivilDAO {
_Banco = banco
};
try
{
if (entity.Validate())
{
return(dal.Salvar(entity));
}
throw new ValidationException(entity.PropertiesErrorList[0].Message);
}
catch
{
throw;
}
}