/// <summary>
/// Salva os tipos de documento do responsável
/// </summary>
/// <param name="pesRespDoc">entidade Pes_PessoaDocumento</param>
/// <param name="pes_id"></param>
/// <param name="bancoCore"></param>
private static void SalvaDocumento(PES_PessoaDocumento pesRespDoc, Guid pes_id, TalkDBTransaction bancoCore)
{
// Verifica se já existe esse documento para essa pessoa.
PES_PessoaDocumento docAux = new PES_PessoaDocumento
{
pes_id = pes_id,
tdo_id = pesRespDoc.tdo_id
};
PES_PessoaDocumentoBO.GetEntity(docAux, bancoCore);
// Salvar documento.
PES_PessoaDocumento doc = new PES_PessoaDocumento
{
pes_id = pes_id,
tdo_id = pesRespDoc.tdo_id,
psd_numero = pesRespDoc.psd_numero,
IsNew = docAux.IsNew,
psd_infoComplementares = docAux.psd_infoComplementares,
psd_orgaoEmissao = docAux.psd_orgaoEmissao,
psd_dataEmissao = docAux.psd_dataEmissao,
unf_idEmissao = docAux.unf_idEmissao,
psd_situacao = 1
};
PES_PessoaDocumentoBO.Save(doc, bancoCore);
if (doc.IsNew)
{
// Incrementar a integridade do tipo de documento.
SYS_TipoDocumentacaoBO.IncrementaIntegridade(doc.tdo_id, bancoCore);
}
}
/// <summary>
/// Método para carregar os documentos da pessoa no grid.
/// </summary>
/// <param name="pes_id"> Id da pessoa.</param>
public void _CarregarDocumento(Guid pes_id)
{
// Carrega dados dos documentos da pessoa.
var pessoaDocumentos = PES_PessoaDocumentoBO.GetSelect(pes_id, false, 1, 1);
if (pessoaDocumentos.Rows.Count > 0)
{
// Adiciona colunas banco e excluído.
pessoaDocumentos.Columns.Add("banco", typeof(Boolean));
pessoaDocumentos.Columns.Add("excluido", typeof(Boolean));
// Atribui a cada registro que ele veio do banco.
foreach (DataRow dr in pessoaDocumentos.Rows)
{
dr["banco"] = true;
dr["excluido"] = false;
}
_VS_documentos = pessoaDocumentos;
rptDocumento.DataSource = _VS_documentos;
rptDocumento.DataBind();
}
else
{
AdicionarLinhaRepeater();
}
_VS_pes_id = pes_id;
updGridDocumentos.Update();
}
/// <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>
/// Retorna ID da entidade de pessoa do responsável por CPF.
/// </summary>
/// <param name="cpf">Número de CPF.</param>
/// <returns></returns>
public static Guid RetornaIdPessoaResponsavelPorCPF(string cpf)
{
// Faz uma busca do id do tipo de documento (tdo_id).
string docPadraoCPF = SYS_ParametroBO.ParametroValor(SYS_ParametroBO.eChave.TIPO_DOCUMENTACAO_CPF);
Guid PadraoCPF = new Guid(docPadraoCPF);
// Verifica se existe uma pessoa cadastro com o número de CPF informado.
PES_PessoaDocumento pessoaResponsavel = PES_PessoaDocumentoBO.GetEntityBy_Documento(cpf, PadraoCPF);
return(pessoaResponsavel.pes_id);
}
/// <summary>
/// Retorna o documento do responsável
/// </summary>
/// <param name="pes_id">id da pessoa</param>
/// <param name="docPadrao">tipo de documento (RG ou CPF)</param>
/// <returns>número do documento</returns>
private string RetornaDocumentoResponsavel(Guid pes_id, string docPadrao)
{
PES_PessoaDocumento entityPessoaDocumento = new PES_PessoaDocumento
{
pes_id = pes_id
,
tdo_id = new Guid(docPadrao)
};
PES_PessoaDocumentoBO.GetEntity(entityPessoaDocumento);
return(entityPessoaDocumento.psd_numero);
}
/// <summary>
/// Valida o CPF do responsável
/// 1º verifica se o CPF é válido.
/// 2º verifica se já existe uma pessoa cadastra com mesmo número de CPF.
/// </summary>
/// <param name="responsavelCPF">numero do documento - CPF</param>
/// <param name="tra_id"></param>
/// <param name="ListValidacoesDoc">Lista das validações dos reponsáveis</param>
/// <param name="ent_id">Id da entidade do usuário logado.</param>
/// <param name="ListSalvar">Lista de responsaveis que estao sendo salvos, para nao considerar o mesmo documento</param>
/// <returns>
/// Retorna o pes_id novo caso não tenha uma pessoa cadastrada com número do CPF.
/// </returns>
private static Guid Valida_Responsavel_CPF(List <PES_PessoaDocumento> responsavelCPF, Int32 tra_id, ref List <string> ListValidacoesDoc, Guid ent_id, Guid pes_id, List <StructCadastro> ListSalvar)
{
// Faz uma busca do id do tipo de documento (tdo_id).
string docPadraoCPF = SYS_ParametroBO.ParametroValor(SYS_ParametroBO.eChave.TIPO_DOCUMENTACAO_CPF);
Guid PadraoCPF = new Guid(docPadraoCPF);
foreach (PES_PessoaDocumento item in responsavelCPF)
{
if (item.tdo_id == PadraoCPF)
{
// Faz a validação do número do Cpf
if (!UtilBO._ValidaCPF(item.psd_numero))
{
string msg;
Int32 tra_idMae = TipoResponsavelAlunoParametro.tra_idMae(ent_id);
Int32 tra_idPai = TipoResponsavelAlunoParametro.tra_idPai(ent_id);
if (!(tra_id == tra_idMae) && !(tra_id == tra_idPai))
{
msg = "O responsável ";
}
else
{
msg = (tra_id == tra_idMae) ? "A mãe " : "O pai ";
}
ListValidacoesDoc.Add(msg + "possui o número do CPF inválido.");
}
// Verifica se existe uma pessoa cadastrada com o número de CPF informado.
PES_PessoaDocumento pessoaResponsavel = PES_PessoaDocumentoBO.GetEntityBy_Documento(item.psd_numero, PadraoCPF);
// Se encontrou uma pessoa diferente com o mesmo numero de CPF
// e nao eh nenhuma das outras pessoas que tambem estao sendo salvas...
if (pessoaResponsavel.pes_id != Guid.Empty &&
pessoaResponsavel.pes_id != pes_id &&
!ListSalvar.Any(p => p.entPessoa.pes_id == pessoaResponsavel.pes_id))
{
// Retorna a pessoa cadastrada com o mesmo numero de CPF
return(pessoaResponsavel.pes_id);
}
else
{
// Retorno a propria pessoa
return(pes_id);
}
}
}
return(pes_id);
}
/// <summary>
/// Método para validar os campos a serem salvos.
/// </summary>
/// <param name="row">Linha a ser validada.</param>
/// <param name="msgErro">Mensagens de erros.</param>
/// <returns></returns>
private bool ValidarLinhaGrid(RepeaterItem row, out string msgErro)
{
try
{
string msg = "";
Guid tdo_id = new Guid(((DropDownList)row.FindControl("ddlTipoDoc")).SelectedValue);
//Valida o tipo de documento.
if (tdo_id != Guid.Empty)
{
SYS_TipoDocumentacao tdo = new SYS_TipoDocumentacao {
tdo_id = tdo_id
};
SYS_TipoDocumentacaoBO.GetEntity(tdo);
if (((TextBox)row.FindControl("tbNumDoc")).Visible == true &&
string.IsNullOrEmpty(((TextBox)row.FindControl("tbNumDoc")).Text))
{
//Valida o número do documento.
msg += "Número é obrigatório.</br>";
}
else
{
if (tdo.tdo_validacao == 1)
{
if (!UtilBO._ValidaCPF(((TextBox)row.FindControl("tbNumDoc")).Text))
{
msg += "Número inválido para CPF.</br>";
}
}
if (tdo.tdo_validacao == 2)
{
Regex regex = new Regex("^[0-9]+$");
if (!regex.IsMatch(((TextBox)row.FindControl("tbNumDoc")).Text))
{
msg += "Número inválido.</br>";
}
}
string docPadraoCPF = SYS_ParametroBO.ParametroValor(SYS_ParametroBO.eChave.TIPO_DOCUMENTACAO_CPF);
if (((DropDownList)row.FindControl("ddlTipoDoc")).SelectedValue == docPadraoCPF)
{
if (PES_PessoaDocumentoBO.VerificaDocumentoExistente(((TextBox)row.FindControl("tbNumDoc")).Text, _VS_pes_id))
{
msg += "Já existe uma pessoa cadastrada com esse documento. (" + ((DropDownList)row.FindControl("ddlTipoDoc")).SelectedItem + ")</br>";
}
}
}
}
else
{
msg += "Tipo de documento é obrigatório.</br>";
}
// Valida a data de emissão.
if (!string.IsNullOrEmpty(((TextBox)row.FindControl("tbDtEmissao")).Text.Trim()))
{
DateTime dt;
if (!DateTime.TryParse(((TextBox)row.FindControl("tbDtEmissao")).Text, out dt))
{
msg += "Data de emissão não está no formato dd/mm/aaaa ou é inexistente.</br>";
}
}
// Valida se já existe o documentos do mesmo tipo cadastrados.
var x = from RepeaterItem gvr in rptDocumento.Items
where
(((DropDownList)gvr.FindControl("ddlTipoDoc")).SelectedValue.Equals(((DropDownList)row.FindControl("ddlTipoDoc")).SelectedValue, StringComparison.OrdinalIgnoreCase)) &&
!string.IsNullOrEmpty((((TextBox)gvr.FindControl("tbNumDoc")).Text))
select gvr;
if (x.Count() > 1)
{
msg += "Existem documentos cadastrados com mesmo tipo.";
}
if (string.IsNullOrEmpty(msg))
{
_lblMessage.Visible = false;
msgErro = "";
return(true);
}
else
{
_lblMessage.Visible = true;
msgErro = msg;
return(false);
}
}
catch (Exception ex)
{
msgErro = "Não foi possível verificar o(s) documento(s).";
ApplicationWEB._GravaErro(ex);
return(false);
}
}
/// <summary>
/// Método utilizado via Web API para alteração de Usuários
/// </summary>
/// <param name="data">Parametros de entrada: Id Entidade, Id Grupo, ID Usuario, Nome,
/// CPF, Data de nascimento, E-mail, Senha</param>
/// <param name="entityUsuarioAPI">Usuário da API usado para gravar log de ação</param>
public static void Update(UsuarioEntradaDTO data, CFG_UsuarioAPI entityUsuarioAPI)
{
#region [ Validação de campos obrigatórios ]
if (data.ent_id == Guid.Empty || string.IsNullOrWhiteSpace(data.usu_login))
{
throw new ValidationException("Id da entidade e login do usuário são obrigatórios.");
}
#endregion
SYS_Usuario entity = new SYS_Usuario
{
ent_id = data.ent_id
,
usu_login = data.usu_login
};
SYS_UsuarioBO.GetSelectBy_ent_id_usu_login(entity);
PES_Pessoa entityPessoa = null;
if (!entity.IsNew)
{
//Validação de usuário padrão do sistema
if (entity.usu_situacao == (byte)SYS_UsuarioBO.eSituacao.Padrao_Sistema)
{
throw new ValidationException("Não é possível alterar dados do usuário padrão do sistema.");
}
//Se o usuário recuperado não possuir pessoa, pula os passos de update de Pessoa
if (entity.pes_id != Guid.Empty)
{
#region [Pessoa]
entityPessoa = new PES_Pessoa {
pes_id = entity.pes_id
};
PES_PessoaBO.GetEntity(entityPessoa);
if (!string.IsNullOrWhiteSpace(data.nome) && entityPessoa.pes_nome.ToLower() != data.nome.ToLower())
{
entityPessoa.pes_nome = data.nome;
}
if (data.dataNascimento != new DateTime() && entityPessoa.pes_dataNascimento != data.dataNascimento)
{
entityPessoa.pes_dataNascimento = data.dataNascimento;
}
if (data.sexo == 1 || data.sexo == 2)
{
entityPessoa.pes_sexo = data.sexo;
}
entityPessoa.pes_dataAlteracao = DateTime.Now;
#region [Validações CPF]
Guid?tdo_id = null;
bool criarCPF = false;
//Recupera os documentos da pessoa
DataTable documentosPessoa = PES_PessoaDocumentoBO.GetSelect(entityPessoa.pes_id, false, 1, 1);
//Se CPF existir, realiza validações
if (!string.IsNullOrWhiteSpace(data.CPF))
{
if (UtilBO._ValidaCPF(data.CPF))
{
//Recupera o tipo de documento CPF
string tipoDocCPF = SYS_ParametroBO.ParametroValor(SYS_ParametroBO.eChave.TIPO_DOCUMENTACAO_CPF);
if (!string.IsNullOrEmpty(tipoDocCPF))
{
tdo_id = Guid.Parse(tipoDocCPF);
criarCPF = true;
}
}
else
{
throw new ValidationException("CPF inválido.");
}
if (documentosPessoa.Rows.Count > 0)
{
//Recupera o indice da linha que contém o documento do tipo CPF
var indiceRowCPF = documentosPessoa.AsEnumerable()
.Select((row, index) => new { row, index })
.Where(item => item.row.Field <Guid>("tdo_id") == tdo_id)
.Select(item => item.index).ToArray();
//Se a pessoa possui um documento do tipo CPF, verifica se precisa alterar
if (indiceRowCPF.Count() > 0)
{
if (documentosPessoa.Rows[indiceRowCPF[0]]["numero"].ToString() != data.CPF)
{
documentosPessoa.Rows[indiceRowCPF[0]]["numero"] = data.CPF;
}
}
else
{
//Pessoa ainda não possue CPF, nesse caso cria usando o datatable recuperado
DataRow rowDoc = documentosPessoa.NewRow();
rowDoc["tdo_id"] = tdo_id;
rowDoc["unf_idEmissao"] = Guid.Empty.ToString();
rowDoc["unf_idAntigo"] = Guid.Empty.ToString();
rowDoc["numero"] = data.CPF;
rowDoc["dataemissao"] = string.Empty;
rowDoc["orgaoemissao"] = string.Empty;
rowDoc["info"] = string.Empty;
documentosPessoa.Rows.Add(rowDoc);
}
criarCPF = false;
}
if (criarCPF)
{
if (tdo_id != null)
{
//Cria o datatable na estrutura necessária com o CPF enviado
documentosPessoa = RetornaDocumento(data.CPF);
}
}
}
#endregion
PES_PessoaDeficiencia entityPessoaDeficiencia = new PES_PessoaDeficiencia
{
pes_id = Guid.Empty,
tde_id = Guid.Empty,
IsNew = true
};
PES_PessoaBO.Save(entityPessoa
, entityPessoaDeficiencia
, new DataTable() //dtEndereco
, new DataTable() //dtContato
, documentosPessoa //dtDocumento
, new DataTable() //dtCertidao
, Guid.Empty //pai_idAntigo
, Guid.Empty //cid_idAntigo
, Guid.Empty //pes_idPaiAntigo
, Guid.Empty //pes_idMaeAntigo
, Guid.Empty //tes_idAntigo
, Guid.Empty //tde_idAntigo
, null //arquivosPermitidos
, 0 //tamanhoMaximoKB
, null //entFoto
, false //ExcluirImagemAtual
);
#endregion
}
#region [Usuário]
//entity.usu_login = data.usu_login;
if (!string.IsNullOrWhiteSpace(data.email) && entity.usu_email != data.email)
{
entity.usu_email = data.email;
}
//Se não vier senha, seta a senha da entidade como vazia para o método do sistema
//não encriptar novamente o que já estava encriptado
if (string.IsNullOrWhiteSpace(data.senha))
{
entity.usu_senha = string.Empty;
}
else
{
entity.usu_senha = data.senha;
}
if (entityPessoa != null)
{
entity.pes_id = entityPessoa.pes_id;
}
entity.usu_criptografia = Convert.ToByte(eCriptografa.TripleDES);
entity.usu_dataAlteracao = DateTime.Now;
SortedDictionary <Guid, SYS_UsuarioBO.TmpGrupos> grupos = new SortedDictionary <Guid, SYS_UsuarioBO.TmpGrupos>();
SortedDictionary <Guid, List <SYS_UsuarioBO.TmpEntidadeUA> > entidadeUA = new SortedDictionary <Guid, List <SYS_UsuarioBO.TmpEntidadeUA> >();
//Se vier grupos cria a lista com base nesses grupos
if (data.gru_id.Count() > 0)
{
foreach (Guid gruId in data.gru_id)
{
SYS_UsuarioBO.AddTmpGrupo(gruId, grupos, 1);
}
}
else
{
//Senão, recupera os grupos do usuário para enviar ao método salvar
SYS_UsuarioBO.GetGruposUsuario(entity.usu_id, grupos, entidadeUA);
}
SYS_UsuarioBO.Save(entity, grupos, entidadeUA, false, data.nome, string.Empty, string.Empty, string.Empty, null);
#endregion
}
else
{
throw new ValidationException("Usuário não existe.");
}
#region [ Log de ação]
LOG_UsuarioAPIBO.Save
(
new LOG_UsuarioAPI
{
usu_id = entity.usu_id
,
uap_id = entityUsuarioAPI.uap_id
,
lua_dataHora = DateTime.Now
,
lua_acao = (byte)LOG_UsuarioAPIBO.eAcao.AlteracaoUsuario
}
);
#endregion
}
/// <summary>
/// Arruma a StructColaboradorFiliacao da mae, que vai retornar a estrutura com os dados necessários para salvar a pessoa no banco.
/// </summary>
public StructColaboradorFiliacao ArrumaStructMae()
{
if (ValidaCampoDocumento(false))
{
throw new ValidationException("Nome da mãe é obrigatório.");
}
StructColaboradorFiliacao colaborador = new StructColaboradorFiliacao();
// se a textbox estiver vazia, nao há dados da mãe
if (!string.IsNullOrEmpty(txtMae.Text))
{
PES_Pessoa entPessoa = new PES_Pessoa();
List <PES_PessoaDocumento> lstDocumento = new List <PES_PessoaDocumento>();
PES_PessoaDocumento cpf = new PES_PessoaDocumento
{
tdo_id = new Guid(SYS_ParametroBO.ParametroValor(SYS_ParametroBO.eChave.TIPO_DOCUMENTACAO_CPF))
};
PES_PessoaDocumento rg = new PES_PessoaDocumento
{
tdo_id = new Guid(SYS_ParametroBO.ParametroValor(SYS_ParametroBO.eChave.TIPO_DOCUMENTACAO_RG))
};
if (_VS_pes_idFiliacaoMae != Guid.Empty)
{
entPessoa.pes_id = _VS_pes_idFiliacaoMae;
PES_PessoaBO.GetEntity(entPessoa);
}
else
{
entPessoa.IsNew = true;
cpf.IsNew = true;
rg.IsNew = true;
}
entPessoa.pes_nome = txtMae.Text;
entPessoa.pes_situacao = 1;
// Adiciona dados do CPF
if (!string.IsNullOrEmpty(txtCPFMae.Text))
{
if (!UtilBO._ValidaCPF(txtCPFMae.Text))
{
throw new ValidationException("CPF da mãe é inválido.");
}
cpf.pes_id = _VS_pes_idFiliacaoMae;
PES_PessoaDocumentoBO.GetEntity(cpf);
cpf.psd_numero = txtCPFMae.Text;
cpf.psd_situacao = 1;
lstDocumento.Add(cpf);
}
// Adiciona dados do Rg
if (!string.IsNullOrEmpty(txtRGMae.Text))
{
rg.pes_id = _VS_pes_idFiliacaoMae;
PES_PessoaDocumentoBO.GetEntity(rg);
rg.psd_numero = txtRGMae.Text;
rg.psd_situacao = 1;
lstDocumento.Add(rg);
}
colaborador.listaDocumentos = lstDocumento;
colaborador.entPessoa = entPessoa;
}
return(colaborador);
}
