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);
}
/// <summary>
/// Salva no banco os dados do item passado por parâmetro, retorna o item inserido.
/// </summary>
/// <param name="tra_idPrincipal">ID do tipo de responsável</param>
/// <param name="entAluno">Aluno</param>
/// <param name="item">Item a ser inserido</param>
/// <param name="tra_idProprio">Id padrão do tipo de responsável "O próprio"</param>
/// <param name="bancoCore">Transação do banco do Core</param>
/// <param name="tra_idMae">Id padrão do tipo de responsável "Mãe"</param>
/// <param name="tra_idPai">Id padrão do tipo de responsável "Pai"</param>
/// <param name="bancoGestao">Transação do banco do Gestão</param>
/// <param name="tdo_idCPF">ID padrão do tipo de documento CPF</param>
/// <param name="tdo_idRG">ID padrão do tipo de documento RG</param>
/// <param name="tdo_idNis">ID padrão do tipo de documento NIS</param>
/// <param name="pes_idMae">ref - id da Mãe do aluno</param>
/// <param name="pes_idPai">ref - id do Pai do aluno</param>
/// <param name="salvarMaiusculo">Indica se os nomes devem ser salvos em maiúsculos</param>
/// <param name="ListValidacoesDoc"></param>
/// <param name="ListSalvar">Lista de responsaveis que estao sendo salvos, para nao considerar o mesmo documento</param>
/// <param name="ent_id">Id da entidade do usuário logado.</param>
/// <returns>Os dados inseridos</returns>
private static StructCadastro SalvarResponsavel
(
Int32 tra_idPrincipal
, ACA_Aluno entAluno
, StructCadastro item
, int tra_idProprio
, TalkDBTransaction bancoCore
, int tra_idMae
, int tra_idPai
, TalkDBTransaction bancoGestao
, Guid tdo_idCPF
, Guid tdo_idRG
, Guid tdo_idNis
, ref Guid pes_idMae
, ref Guid pes_idPai
, bool salvarMaiusculo
, ref List <string> ListValidacoesDoc
, List <StructCadastro> ListSalvar
, Guid ent_id
)
{
// Salvar os responsáveis.
ACA_AlunoResponsavel entResp = item.entAlunoResp;
PES_Pessoa entPessoa = item.entPessoa;
List <PES_PessoaDocumento> lisDocResp;
entResp.alu_id = entAluno.alu_id;
if (entResp.tra_id == tra_idProprio)
{
// Se for o próprio, seta o id da Pessoa = o Id da pessoa do aluno.
entResp.pes_id = entAluno.pes_id;
// Salvar a integridade da pessoa.
if (entResp.IsNew)
{
PES_PessoaBO.IncrementaIntegridade(entAluno.pes_id, bancoCore);
}
}
else
{
if ((salvarMaiusculo) && (!String.IsNullOrEmpty(entPessoa.pes_nome)))
{
entPessoa.pes_nome = entPessoa.pes_nome.ToUpper();
}
// Só salva a pessoa se o nome estiver preenchido.
if (!String.IsNullOrEmpty(entPessoa.pes_nome))
{
// Faz a verificação caso exista a pessoa com o CPF passado por parâmetro.
Guid responsavel = Valida_Responsavel_CPF(item.listPessoaDoc, entResp.tra_id, ref ListValidacoesDoc, ent_id, entPessoa.pes_id, ListSalvar);
if (responsavel == new Guid())
{
// Se não existir, salva a entidade pessoa.
PES_PessoaBO.Save(entPessoa, bancoCore);
}
else
{
entPessoa.pes_id = responsavel;
entPessoa.IsNew = false;
#region Atualiza - Entidade Pessoa (Cria uma entidade auxiliar para atualizar apenas o nome)
//Atualiza apenas o nome do responsável, recebendo todas as informações ja cadastradas
PES_Pessoa pesAux = new PES_Pessoa
{
pes_id = entPessoa.pes_id
};
PES_PessoaBO.GetEntity(pesAux);
pesAux.pes_nome = entPessoa.pes_nome;
//// movimentado os valores por que esses campos não estavam sendo gravados
pesAux.pes_dataNascimento = entPessoa.pes_dataNascimento;
pesAux.pes_estadoCivil = entPessoa.pes_estadoCivil;
pesAux.tes_id = entPessoa.tes_id;
////
entPessoa = pesAux;
#endregion Atualiza - Entidade Pessoa (Cria uma entidade auxiliar para atualizar apenas o nome)
// Se for matricula
if (entAluno.IsNew)
{
#region Atualiza - Entidade Aluno Responsavel (Caso existir a informações referente a profissão e situação)
//Faz verificação se existe as informações referente a profissão e situação do responsável
byte situacao_responsavel;
string profissao_responsavel;
RetornaAlunoResponsavel_Situacao_Profissao(entPessoa.pes_id, out situacao_responsavel, out profissao_responsavel);
if (situacao_responsavel == Convert.ToByte(ACA_AlunoResponsavelSituacao.Falecido))
{
entResp.alr_situacao = Convert.ToByte(ACA_AlunoResponsavelSituacao.Falecido);
}
else
{
entResp.alr_situacao = Convert.ToByte(ACA_AlunoResponsavelSituacao.Ativo);
}
entResp.alr_profissao = profissao_responsavel;
#endregion Atualiza - Entidade Aluno Responsavel (Caso existir a informações referente a profissão e situação)
}
else
{
// Caso já exista o responsável, será atualizado os campos: situção (Quando for falecido = 4) e o campo profissão.
AtualizaResponsavel_Profissao_Situacao(entPessoa.pes_id, entResp.alr_profissao, entResp.alr_empresa, entResp.alr_situacao, bancoGestao);
}
PES_PessoaBO.Save(entPessoa, bancoCore);
}
}
else
{
entPessoa.pes_id = Guid.Empty;
}
if ((entPessoa.IsNew) || (entResp.IsNew))
{
PES_PessoaBO.IncrementaIntegridade(entPessoa.pes_id, bancoCore);
}
entResp.pes_id = entPessoa.pes_id;
// Seta o Id da mãe e do Pai para alterar na pessoa do aluno.
if (entResp.tra_id == tra_idMae)
{
pes_idMae = entPessoa.pes_id;
}
else if (entResp.tra_id == tra_idPai)
{
pes_idPai = entPessoa.pes_id;
}
}
// Seta responsável principal.
entResp.alr_principal = (entResp.tra_id == tra_idPrincipal);
Save(entResp, bancoGestao);
if (entResp.tra_id != tra_idProprio)
{
// Salva os documentos dos responsáveis
lisDocResp = SalvaDocumentoResponsavel(
item.listPessoaDoc
, entResp.pes_id
, tra_idProprio
, entResp.tra_id
, tdo_idCPF
, tdo_idRG
, tdo_idNis
, bancoCore
, ref ListValidacoesDoc);
}
else
{
lisDocResp = new List <PES_PessoaDocumento>();
}
// Retorna item inserido.
return(new StructCadastro
{
entAlunoResp = entResp,
entPessoa = entPessoa,
listPessoaDoc = lisDocResp
});
}
/// <summary>
/// Verifica se o item existia e deixou de existir, exclui caso positivo.
/// </summary>
/// <param name="listaInseridos">Lista de itens inseridos</param>
/// <param name="bancoCore">Transação do Core</param>
/// <param name="bancoGestao">Transação do Gestão</param>
/// <param name="cadastrado">Item a ser verificado</param>
/// <param name="tra_idProprio"></param>
private static void VerifcaItemCadastrado
(
List <StructCadastro> listaInseridos
, TalkDBTransaction bancoCore
, TalkDBTransaction bancoGestao
, StructCadastro cadastrado
, Int32 tra_idProprio
)
{
if (!listaInseridos.Exists
(p =>
p.entAlunoResp.tra_id == cadastrado.entAlunoResp.tra_id
))
{
// Se o tipo de responsável não existir mais, excluir.
ACA_AlunoResponsavel entResp = cadastrado.entAlunoResp;
PES_Pessoa entPessoa = new PES_Pessoa
{
pes_id = entResp.pes_id
};
PES_PessoaBO.GetEntity(entPessoa, bancoCore);
// Verificar documento.
if (cadastrado.listPessoaDoc.Count > 0)
{
// Caso tiver documento para o responsável, será decrementado a integridade.
foreach (PES_PessoaDocumento documento in cadastrado.listPessoaDoc)
{
DecrementaIntegridadeDocumentoPessoa(bancoCore, documento.tdo_id, entPessoa.pes_id);
}
}
// Decrementa integridade da pessoa.
DecrementaIntegridadePessoa(bancoCore, entPessoa);
Delete(entResp, bancoGestao);
}
else
{
StructCadastro inserido = listaInseridos.Find
(p =>
p.entAlunoResp.tra_id == cadastrado.entAlunoResp.tra_id
);
if ((inserido.listPessoaDoc.Count < cadastrado.listPessoaDoc.Count) &&
(inserido.entAlunoResp.tra_id != tra_idProprio))
{
// Se existia um documento e foi removido (quando for diferente do Próprio aluno), excluir o documento.
ExcluirDocumentoReponsavel(
cadastrado.listPessoaDoc
, inserido.listPessoaDoc
, cadastrado.entPessoa.pes_id
, bancoCore
);
}
if (inserido.entPessoa.pes_id != cadastrado.entPessoa.pes_id)
{
// Mudou a pessoa - decrementa integridade da pessoa anterior.
PES_Pessoa entPessoa = cadastrado.entPessoa;
// Decrementa integridade da pessoa.
DecrementaIntegridadePessoa(bancoCore, entPessoa);
if ((!inserido.entPessoa.IsNew) && (!inserido.entAlunoResp.IsNew))
{
// Se a pessoa não for nova, nem o responsável - incrementa
// integridade da pessoa inserida.
PES_PessoaBO.IncrementaIntegridade(inserido.entPessoa.pes_id, bancoCore);
}
}
}
}
