public static void AutenticarUsuarioDaRespostaDoSaml(string nameIdValue)
{
var dadosUsuario = nameIdValue.Split('\\');
Guid entidadeId;
string login;
if (dadosUsuario.Length == 2)
{
entidadeId = Guid.Parse(dadosUsuario[0]);
login = dadosUsuario[1];
var usuarioCore = new SYS_Usuario {
ent_id = entidadeId, usu_login = login
};
if (SYS_UsuarioBO.GetSelectBy_ent_id_usu_login(usuarioCore))
{
AutenticarUsuario(usuarioCore);
}
else
{
throw new Exception("Usuário(Saml) não encontrado");
}
}
else
{
throw new Exception("Nome de Usuário inválido! Usuario(saml): " + nameIdValue);
}
}
private void LoadSession(SYS_Usuario entityUsuario)
{
__SessionWEB.__UsuarioWEB.Usuario = entityUsuario;
__SessionWEB.__UsuarioWEB.responsavel = RadioButtonList1.SelectedIndex == 1;
if (__SessionWEB.__UsuarioWEB.responsavel)
{
SYS_Usuario entityUsuarioAluno = new SYS_Usuario
{
ent_id = UCComboEntidade1.Valor
,
usu_login = ACA_ParametroAcademicoBO.ParametroValorPorEntidade(eChaveAcademico.PREFIXO_LOGIN_ALUNO_AREA_ALUNO, __SessionWEB.__UsuarioWEB.Usuario.ent_id) + txtLogin.Text
};
SYS_UsuarioBO.GetSelectBy_ent_id_usu_login(entityUsuarioAluno);
__SessionWEB.__UsuarioWEB.pes_idAluno = entityUsuarioAluno.pes_id;
}
// Carrega grupos do usuário
IList <SYS_Grupo> list = SYS_GrupoBO.GetSelectBySis_idAndUsu_id(__SessionWEB.__UsuarioWEB.Usuario.usu_id, ApplicationWEB.AreaAlunoSistemaID);
// Verifica se foi carregado os grupos do usuário
if (list.Count > 0)
{
__SessionWEB.__UsuarioWEB.Grupo = list[0];
}
else
{
throw new ValidationException("Não foi possível atender a solicitação, nenhum grupo de usuário encontrado.");
}
// Armazena o cid_id referente a entidade do usuário na Session
Guid ene_id = SYS_EntidadeEnderecoBO.Select_ene_idBy_ent_id(__SessionWEB.__UsuarioWEB.Usuario.ent_id);
SYS_EntidadeEndereco entityEntidadeEndereco = new SYS_EntidadeEndereco {
ent_id = __SessionWEB.__UsuarioWEB.Usuario.ent_id, ene_id = ene_id
};
SYS_EntidadeEnderecoBO.GetEntity(entityEntidadeEndereco);
END_Endereco entityEndereco = new END_Endereco {
end_id = entityEntidadeEndereco.end_id
};
END_EnderecoBO.GetEntity(entityEndereco);
__SessionWEB._cid_id = entityEndereco.cid_id;
// Armazena o nome da pessoa ou o login do usuário na Session
PES_Pessoa EntityPessoa = new PES_Pessoa {
pes_id = __SessionWEB.__UsuarioWEB.Usuario.pes_id
};
PES_PessoaBO.GetEntity(EntityPessoa);
__SessionWEB.UsuarioLogado = string.IsNullOrEmpty(EntityPessoa.pes_nome) ? __SessionWEB.__UsuarioWEB.Usuario.usu_login : EntityPessoa.pes_nome;
}
/// <summary>
/// Método utilizado via Web API para alteração de login de um usuário
/// </summary>
/// <param name="data">Parametros de entrada: Id Entidade, login antigo, login novo</param>
/// <param name="entityUsuarioAPI">Usuário da API usado para gravar log de ação</param>
public static void UpdateLogin(AlterarLoginEntradaDTO data, CFG_UsuarioAPI entityUsuarioAPI)
{
if (data.ent_id == Guid.Empty || string.IsNullOrWhiteSpace(data.usu_login_antigo) || string.IsNullOrWhiteSpace(data.usu_login_novo))
{
throw new ValidationException("Todos os campos são obrigatórios.");
}
SYS_Usuario entity = new SYS_Usuario
{
ent_id = data.ent_id,
usu_login = data.usu_login_antigo
};
SYS_UsuarioBO.GetSelectBy_ent_id_usu_login(entity);
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.");
}
entity.usu_login = data.usu_login_novo;
}
else
{
throw new ValidationException("Usuário não existe.");
}
SYS_UsuarioBO.Save(entity);
#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.AlteracaoLogin
}
);
#endregion
}
protected virtual void LoadUser(AuthenticationIdentity user, HttpActionContext actionContext)
{
if (HttpContext.Current != null)
{
BaseApiController baseApiController = actionContext.ControllerContext.Controller as BaseApiController;
if (baseApiController != null)
{
// Chave padrão do cache - nome do método + parâmetros.
string chave = RetornaChaveCache_LoadUser(user);
object cache = HttpContext.Current.Cache[chave];
if (cache == null)
{
#region Load user values
UsuarioWEB userLogged = new UsuarioWEB();
// Carrega usuário na session através do ticket de authenticação
userLogged.Usuario = new SYS_Usuario
{
ent_id = user.Entity
,
usu_login = user.Login
};
SYS_UsuarioBO.GetSelectBy_ent_id_usu_login(userLogged.Usuario);
userLogged.Grupo = SYS_GrupoBO.GetEntity(new SYS_Grupo {
gru_id = user.Group
});
baseApiController.__userLogged = userLogged;
#endregion
HttpContext.Current.Cache.Insert(chave, userLogged, null, DateTime.Now.AddMinutes(GestaoEscolarUtilBO.MinutosCacheMedio)
, System.Web.Caching.Cache.NoSlidingExpiration);
}
else
{
baseApiController.__userLogged = cache as UsuarioWEB;
}
}
}
}
public HttpResponseMessage UpdatePassword([FromBody] RedefinirSenhaEntradaDTO data)
{
RedefinirSenhaSaidaDTO retorno = new RedefinirSenhaSaidaDTO();
try
{
SYS_Usuario entity = new SYS_Usuario
{
ent_id = data.ent_id
,
usu_login = data.usu_login
};
SYS_UsuarioBO.GetSelectBy_ent_id_usu_login(entity);
// Verifica se o id do usuário enviado existe na base de dados.
if (entity.IsNew)
{
retorno.Message = "Usuário não encontrado.";
retorno.statusCode = (int)HttpStatusCode.NotFound;
return(Request.CreateResponse <RedefinirSenhaSaidaDTO>(HttpStatusCode.NotFound, retorno));
}
// Configura criptografia da senha
eCriptografa criptografia = (eCriptografa)Enum.Parse(typeof(eCriptografa), Convert.ToString(entity.usu_criptografia), true);
if (!Enum.IsDefined(typeof(eCriptografa), criptografia))
{
criptografia = eCriptografa.TripleDES;
}
if (!UtilBO.EqualsSenha(entity.usu_senha, data.senhaAtual, criptografia))
{
retorno.Message = "Senha atual inválida.";
retorno.statusCode = (int)HttpStatusCode.Unauthorized;
return(Request.CreateResponse <RedefinirSenhaSaidaDTO>(HttpStatusCode.Unauthorized, retorno));
}
if (data.senhaAtual.Equals(data.senhaNova))
{
retorno.Message = "Senha nova deve ser diferente da atual.";
retorno.statusCode = (int)HttpStatusCode.BadRequest;
return(Request.CreateResponse <RedefinirSenhaSaidaDTO>(HttpStatusCode.BadRequest, retorno));
}
entity.usu_senha = data.senhaNova;
SYS_UsuarioBO.AlterarSenhaUsuario(entity, false);
retorno.Message = "Senha alterada com sucesso.";
retorno.statusCode = (int)HttpStatusCode.OK;
CFG_UsuarioAPI entityUsuarioAPI = CFG_UsuarioAPIBO.SelecionaPorUsername(data.uap_username);
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.AlteracaoSenha
}
);
return(Request.CreateResponse <RedefinirSenhaSaidaDTO>(HttpStatusCode.OK, retorno));
}
catch (Exception ex)
{
retorno.Message = ex.Message;
retorno.statusCode = (int)HttpStatusCode.InternalServerError;
Util.GravarErro(ex);
return(Request.CreateResponse <RedefinirSenhaSaidaDTO>(HttpStatusCode.InternalServerError, retorno));
}
}
/// <summary>
/// Método utilizado via Web API para deleção de um usuário
/// </summary>
/// <param name="data">Parametros de entrada: Id Entidade, login, senha</param>
/// <param name="entityUsuarioAPI">Usuário da API usado para gravar log de ação</param>
public static HttpResponseMessage Delete(DeletarUsuarioDTO data, CFG_UsuarioAPI entityUsuarioAPI, HttpRequestMessage request)
{
try
{
//Verifica se todos os dados vieram
if (data.ent_id == Guid.Empty || string.IsNullOrWhiteSpace(data.usu_login) || string.IsNullOrWhiteSpace(data.senha))
{
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, "Todos os campos são obrigatórios."));
}
SYS_Usuario entity = new SYS_Usuario
{
ent_id = data.ent_id,
usu_login = data.usu_login
};
SYS_UsuarioBO.GetSelectBy_ent_id_usu_login(entity);
//Validação de usuário padrão do sistema
if (entity.usu_situacao == (byte)SYS_UsuarioBO.eSituacao.Padrao_Sistema)
{
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, "Não é possível alterar um usuário padrão do sistema."));
}
// Verifica se o id do usuário enviado existe na base de dados.
if (entity.IsNew)
{
return(request.CreateErrorResponse(HttpStatusCode.NotFound, "Usuário não encontrado."));
}
var senhaDescriptografada = new SymmetricAlgorithm(SymmetricAlgorithm.Tipo.TripleDES).Decrypt(entity.usu_senha);
if (data.senha != senhaDescriptografada)
{
return(request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Não foi possível excluir usuário. Acesso negado."));
}
SYS_UsuarioBO.Delete(entity, null);
#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.DelecaoUsuario
}
);
#endregion
return(request.CreateResponse(HttpStatusCode.OK, "Usuário excluído com sucesso."));
}
catch (Exception ex)
{
Util.GravarErro(ex);
return(request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex.Message));
}
}
/// <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>
/// Método utilizado via Web API para criação de Usuários
/// OBSERVACAO: Este metodo faz uma busca por nome, data de nascimento e CPF
/// para tentar vincular uma pessoa já existente com estes dados ao usuario
/// que esta sendo criado, sendo que apenas nome e data de nascimento são requeridos.
/// </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 Create(UsuarioEntradaDTO data, CFG_UsuarioAPI entityUsuarioAPI)
{
#region [ Validação de campos obrigatórios ]
if (data.ent_id == Guid.Empty)
{
throw new ValidationException("Id da entidade é obrigatório.");
}
if (string.IsNullOrWhiteSpace(data.usu_login))
{
throw new ValidationException("Login do usuário é obrigatório.");
}
if (data.gru_id.Count() == 0)
{
throw new ValidationException("Ao menos um grupo deve ser informado.");
}
if (data.dataNascimento == new DateTime())
{
throw new ValidationException("Data de nascimento é obrigatória.");
}
if (data.sexo != null && data.sexo > 2)
{
throw new ValidationException("Para o sexo informe: 1 - masculino ou 2 - feminino");
}
#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);
// Verifica se o id do usuário enviado existe na base de dados.
if (entity.IsNew)
{
Guid? tdo_id = null;
bool savePessoaReturn = false;
PES_Pessoa entityPessoa = null;
//Se não for informado nome e data de nascimento não cria a pessoa
if (!string.IsNullOrWhiteSpace(data.nome) && data.dataNascimento != null)
{
#region [Validações CPF]
//Se CPF existir, realiza validações
if (!string.IsNullOrWhiteSpace(data.CPF))
{
if (UtilBO._ValidaCPF(data.CPF))
{
//Recupera o tipo de documento CPF, utilizado para recuperar a pessoa
string tipoDocCPF = SYS_ParametroBO.ParametroValor(SYS_ParametroBO.eChave.TIPO_DOCUMENTACAO_CPF);
if (!string.IsNullOrEmpty(tipoDocCPF))
{
tdo_id = Guid.Parse(tipoDocCPF);
}
}
else
{
throw new ValidationException("CPF inválido.");
}
}
#endregion
//Recupera a pessoa
entityPessoa = PES_PessoaBO.SelecionaPorNomeNascimentoDocumento(data.nome, data.dataNascimento, tdo_id, data.CPF);
//Se pessoa não existir, faz o cadastro com as informações básicas
if (entityPessoa.pes_id == Guid.Empty)
{
#region [Cria Pessoa]
//Adiciona valores na entidade de pessoa
entityPessoa.pes_id = Guid.Empty;
entityPessoa.pes_nome = data.nome;
entityPessoa.pes_sexo = data.sexo;
entityPessoa.pes_nome_abreviado = string.Empty;
entityPessoa.pai_idNacionalidade = Guid.Empty;
entityPessoa.pes_naturalizado = false;
entityPessoa.cid_idNaturalidade = Guid.Empty;
entityPessoa.pes_dataNascimento = (String.IsNullOrEmpty(data.dataNascimento.ToString()) ? new DateTime() : Convert.ToDateTime(data.dataNascimento.ToString()));
entityPessoa.pes_racaCor = Convert.ToByte(null);
entityPessoa.pes_idFiliacaoPai = Guid.Empty;
entityPessoa.pes_idFiliacaoMae = Guid.Empty;
entityPessoa.tes_id = Guid.Empty;
entityPessoa.pes_estadoCivil = Convert.ToByte(null);
entityPessoa.pes_situacao = 1;
PES_PessoaDeficiencia entityPessoaDeficiencia = new PES_PessoaDeficiencia
{
pes_id = Guid.Empty,
tde_id = Guid.Empty,
IsNew = true
};
savePessoaReturn = PES_PessoaBO.Save(entityPessoa
, entityPessoaDeficiencia
, new DataTable() //dtEndereco
, new DataTable() //dtContato
, RetornaDocumento(data.CPF) //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 [ Cria usuário ]
entity.ent_id = data.ent_id;
entity.usu_id = Guid.Empty;
entity.usu_login = data.usu_login;
entity.usu_email = string.IsNullOrEmpty(data.email) ? string.Empty : data.email;
entity.usu_senha = string.IsNullOrEmpty(data.senha) ? string.Empty : data.senha;
//Se foi recuperado ou criado uma pessoa, vincula o pes_id
if (entityPessoa != null)
{
entity.pes_id = entityPessoa.pes_id;
}
entity.usu_criptografia = Convert.ToByte(eCriptografa.TripleDES);
entity.usu_situacao = 1;
entity.usu_dataAlteracao = DateTime.Now;
entity.usu_dataCriacao = DateTime.Now;
entity.usu_dominio = string.Empty;
entity.usu_integracaoAD = (byte)SYS_UsuarioBO.eIntegracaoAD.NaoIntegrado;
entity.IsNew = true;
SortedDictionary <Guid, SYS_UsuarioBO.TmpGrupos> grupos = new SortedDictionary <Guid, SYS_UsuarioBO.TmpGrupos>();
foreach (Guid gruId in data.gru_id)
{
SYS_UsuarioBO.AddTmpGrupo(gruId, grupos, 1);
}
SortedDictionary <Guid, List <SYS_UsuarioBO.TmpEntidadeUA> > entidadeUA = new SortedDictionary <Guid, List <SYS_UsuarioBO.TmpEntidadeUA> >();
SYS_UsuarioBO.Save(entity, grupos, entidadeUA, false, data.nome, string.Empty, string.Empty, string.Empty, null);
#endregion
}
else
{
throw new ValidationException("Usuário já 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.CriacaoUsuario
}
);
#endregion
}
public HttpResponseMessage PostLogin(Usuario usuario)
{
try
{
var user = new SYS_Usuario {
usu_login = usuario.login, usu_senha = usuario.senha, ent_id = usuario.entidade
};
LoginStatus status = SYS_UsuarioBO.ValidarLogin(user);
if (status == LoginStatus.Sucesso)
{
if (SYS_UsuarioBO.GetSelectBy_ent_id_usu_login(user))
{
var grupos = SYS_GrupoBO.GetSelectBySis_idAndUsu_id(user.usu_id, ApplicationWEB.SistemaID);
if (grupos.Count > 0)
{
var grupo = grupos.First();
Dictionary <string, object> dic = new Dictionary <string, object>();
dic.Add("login", user.usu_login);
dic.Add("entity", user.ent_id);
dic.Add("group", grupo.gru_id);
var jwtKey = System.Configuration.ConfigurationManager.AppSettings["jwtKey"];
SymmetricAlgorithm sa = new SymmetricAlgorithm(SymmetricAlgorithm.Tipo.TripleDES);
PES_Pessoa entityPessoa = new PES_Pessoa {
pes_id = user.pes_id
};
PES_PessoaBO.GetEntity(entityPessoa);
bool docente = false;
if (grupo.vis_id == SysVisaoID.Individual)
{
// Carrega a entidade docente de acordo com a pessoa do usuário logado.
ACA_Docente entityDocente;
ACA_DocenteBO.GetSelectBy_Pessoa(user.ent_id, user.pes_id, out entityDocente);
docente = entityDocente.doc_id > 0;
}
UsuarioLogado usuarioLogado = new UsuarioLogado {
grupo = grupos.First().gru_nome,
nome = (string.IsNullOrEmpty(entityPessoa.pes_nome) ? user.usu_login : entityPessoa.pes_nome),
docente = docente,
token = JWT.JsonWebToken.Encode(dic, sa.Decrypt(jwtKey), JWT.JwtHashAlgorithm.HS256)
};
return(Request.CreateResponse(HttpStatusCode.OK, usuarioLogado));
}
else
{
return(Request.CreateResponse(HttpStatusCode.Unauthorized, "Usuário não está vinculado a um grupo"));
}
}
return(Request.CreateResponse(HttpStatusCode.Unauthorized, "Usuário não encontrado"));
}
else
{
return(Request.CreateResponse(HttpStatusCode.Unauthorized, "Usuário ou senha inválidos"));
}
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, ex));
}
}
protected void _btnSalvar_Click(object sender, EventArgs e)
{
if (ValidarAlterarSenha())
{
try
{
SYS_Usuario entityUsuario = new SYS_Usuario
{
ent_id = new Guid(UCComboEntidade1._Combo.SelectedValue)
,
usu_login = _txtLogin.Text
};
SYS_UsuarioBO.GetSelectBy_ent_id_usu_login(entityUsuario);
eCriptografa criptografia = (eCriptografa)Enum.Parse(typeof(eCriptografa), Convert.ToString(entityUsuario.usu_criptografia), true);
if (!Enum.IsDefined(typeof(eCriptografa), criptografia))
{
criptografia = eCriptografa.SHA512;
}
if (!UtilBO.EqualsSenha(entityUsuario.usu_senha, UtilBO.CriptografarSenha(_txtSenhaAtual.Text, criptografia), criptografia))
{
string mensagemSenhaAtualInvalida = SYS_MensagemSistemaBO.RetornaValor(SYS_MensagemSistemaChave.MeusDadosMensagemSenhaAtualIncorreta);
_lblMessageAlterarSenha.Text = UtilBO.GetErroMessage(string.IsNullOrEmpty(mensagemSenhaAtualInvalida) ? "Senha atual inválida." : mensagemSenhaAtualInvalida, UtilBO.TipoMensagem.Erro);
_updAlterarSenha.Update();
ApplicationWEB._GravaLogSistema(LOG_SistemaTipo.Login, "Erro ao alterar senha. Senha atual inválida.");
}
else
{
entityUsuario.usu_situacao = 1;
entityUsuario.usu_senha = _txtNovaSenha.Text;
entityUsuario.usu_dataAlteracao = DateTime.Now;
entityUsuario.usu_criptografia = (byte)eCriptografa.SHA512;
SYS_UsuarioBO.AlterarSenhaAtualizarUsuario(entityUsuario, entityUsuario.usu_integracaoAD == (byte)SYS_UsuarioBO.eIntegracaoAD.IntegradoADReplicacaoSenha);
LoadSession(entityUsuario);
ApplicationWEB._GravaLogSistema(LOG_SistemaTipo.Login, "Senha alterada com sucesso.");
string mensagemSenhaAlterada = SYS_MensagemSistemaBO.RetornaValor(SYS_MensagemSistemaChave.LoginMensagemSenhaAlteradaSucesso);
__SessionWEB.PostMessages = UtilBO.GetErroMessage(string.IsNullOrEmpty(mensagemSenhaAlterada) ? "Senha alterada com sucesso." : mensagemSenhaAlterada, UtilBO.TipoMensagem.Sucesso);
SYS_UsuarioFalhaAutenticacaoBO.ZeraFalhaAutenticacaoUsuario(entityUsuario.usu_id);
ApplicationWEB._GravaLogSistema(LOG_SistemaTipo.Login, "Login efetuado com sucesso.");
SignHelper.AutenticarUsuario(entityUsuario);
LoadSession(entityUsuario);
RedirecionarLogin(entityUsuario.usu_id);
}
}
catch (DuplicateNameException ex)
{
_lblMessage.Text = UtilBO.GetErroMessage(ex.Message, UtilBO.TipoMensagem.Alerta);
ScriptManager.RegisterClientScriptBlock(this, GetType(), "AlterarSenhaErro", "$('#divAlterarSenha').dialog('close');", true);
}
catch (ArgumentException ex)
{
_lblMessage.Text = UtilBO.GetErroMessage(ex.Message, UtilBO.TipoMensagem.Alerta);
ScriptManager.RegisterClientScriptBlock(this, GetType(), "AlterarSenhaErro", "$('#divAlterarSenha').dialog('close');", true);
}
catch (ValidationException ex)
{
_lblMessage.Text = UtilBO.GetErroMessage(ex.Message, UtilBO.TipoMensagem.Alerta);
ScriptManager.RegisterClientScriptBlock(this, GetType(), "AlterarSenhaErro", "$('#divAlterarSenha').dialog('close');", true);
}
catch (Exception ex)
{
ApplicationWEB._GravaErro(ex);
_lblMessage.Text = UtilBO.GetErroMessage("Erro ao tentar alterar a senha do usuário.", UtilBO.TipoMensagem.Erro);
ScriptManager.RegisterClientScriptBlock(this, GetType(), "AlterarSenhaErro", "$('#divAlterarSenha').dialog('close');", true);
}
}
else
{
_updAlterarSenha.Update();
}
}
protected void _btnSalvar_Click(object sender, EventArgs e)
{
if (ValidarAlterarSenha())
{
try
{
// Carrega os dados do usuário
SYS_Usuario entityUsuario = new SYS_Usuario
{
ent_id = UCComboEntidade1.Valor
,
usu_login = (RadioButtonList1.SelectedIndex == 0
? ACA_ParametroAcademicoBO.ParametroValorPorEntidade(eChaveAcademico.PREFIXO_LOGIN_ALUNO_AREA_ALUNO, Guid.Empty)
: ACA_ParametroAcademicoBO.ParametroValorPorEntidade(eChaveAcademico.PREFIXO_LOGIN_RESPONSAVEL_AREA_ALUNO, Guid.Empty)) + txtLogin.Text
};
SYS_UsuarioBO.GetSelectBy_ent_id_usu_login(entityUsuario);
// Configura criptografia da senha
eCriptografa criptografia = (eCriptografa)Enum.Parse(typeof(eCriptografa), Convert.ToString(entityUsuario.usu_criptografia), true);
if (!Enum.IsDefined(typeof(eCriptografa), criptografia))
{
criptografia = eCriptografa.TripleDES;
}
// Verifica a senha do usuário comparando com a senha atual
if (!UtilBO.EqualsSenha(entityUsuario.usu_senha, UtilBO.CriptografarSenha(_txtSenhaAtual.Text, criptografia), criptografia))
{
string mensagemSenhaAtualInvalida = SYS_MensagemSistemaBO.RetornaValor(SYS_MensagemSistemaChave.MeusDadosMensagemSenhaAtualIncorreta);
_lblMessageAlterarSenha.Text = UtilBO.GetErroMessage(string.IsNullOrEmpty(mensagemSenhaAtualInvalida) ? "Senha atual inválida." : mensagemSenhaAtualInvalida, UtilBO.TipoMensagem.Erro);
_updAlterarSenha.Update();
ApplicationWEB._GravaLogSistema(LOG_SistemaTipo.Login, "Erro ao alterar senha. Senha atual inválida.");
}
else
{
// Atualiza dados do usuário
entityUsuario.usu_situacao = 1;
entityUsuario.usu_senha = _txtNovaSenha.Text;
entityUsuario.usu_dataAlteracao = DateTime.Now;
SYS_UsuarioBO.AlterarSenhaAtualizarUsuario(entityUsuario, entityUsuario.usu_integracaoAD == (byte)SYS_UsuarioBO.eIntegracaoAD.IntegradoADReplicacaoSenha);
// Configura usuário na Session
LoadSession(entityUsuario);
ApplicationWEB._GravaLogSistema(LOG_SistemaTipo.Login, "Senha alterada com sucesso.");
string mensagemSenhaAlterada = SYS_MensagemSistemaBO.RetornaValor(SYS_MensagemSistemaChave.LoginMensagemSenhaAlteradaSucesso);
__SessionWEB.PostMessages = UtilBO.GetErroMessage(string.IsNullOrEmpty(mensagemSenhaAlterada) ? "Senha alterada com sucesso." : mensagemSenhaAlterada, UtilBO.TipoMensagem.Sucesso);
// Autenticação SAML.
SYS_UsuarioBO.AutenticarUsuario(entityUsuario);
// Configura usuário na Session
LoadSession(entityUsuario);
// Se selecionou para logar como responsável, verifica se esse ele é responsável por um aluno só,
// ou caso tenha mais, redireciona para uma tela de selação de alunos
if (RadioButtonList1.SelectedIndex == 1)
{
DataTable dtAlunosDoResponsavel = ACA_AlunoResponsavelBO.SelecionaAlunosPorResponsavel(entityUsuario.pes_id);
Session["Pes_Id_Responsavel"] = entityUsuario.pes_id.ToString();
Session["Qtde_Filhos_Responsavel"] = dtAlunosDoResponsavel.Rows.Count;
if (dtAlunosDoResponsavel.Rows.Count > 1)
{
//Session["Pes_Id_Responsavel"] = entityUsuario.pes_id.ToString();
RedirecionarLogin(true);
return;
}
}
RedirecionarLogin(false);
}
}
catch (DuplicateNameException ex)
{
lblMessage.Text = UtilBO.GetErroMessage(ex.Message, UtilBO.TipoMensagem.Alerta);
ScriptManager.RegisterClientScriptBlock(this, GetType(), "AlterarSenhaErro", "$('#divAlterarSenha').dialog('close');", true);
}
catch (ArgumentException ex)
{
lblMessage.Text = UtilBO.GetErroMessage(ex.Message, UtilBO.TipoMensagem.Alerta);
ScriptManager.RegisterClientScriptBlock(this, GetType(), "AlterarSenhaErro", "$('#divAlterarSenha').dialog('close');", true);
}
catch (ValidationException ex)
{
lblMessage.Text = UtilBO.GetErroMessage(ex.Message, UtilBO.TipoMensagem.Alerta);
ScriptManager.RegisterClientScriptBlock(this, GetType(), "AlterarSenhaErro", "$('#divAlterarSenha').dialog('close');", true);
}
catch (Exception ex)
{
ApplicationWEB._GravaErro(ex);
lblMessage.Text = UtilBO.GetErroMessage("Erro ao tentar alterar a senha do usuário.", UtilBO.TipoMensagem.Erro);
ScriptManager.RegisterClientScriptBlock(this, GetType(), "AlterarSenhaErro", "$('#divAlterarSenha').dialog('close');", true);
}
}
else
{
_updAlterarSenha.Update();
}
}
public Senha AlterarSenha(string login, string senha, string ativo)
{
Senha structSenha = new Senha();
try
{
// Verifica Autenticação de acesso
if (!VerificarAuthentication())
{
throw new ValidationException("Sem autorização de acesso ao Web Service.");
}
SYS_Usuario entityUsuario = new SYS_Usuario();
entityUsuario.ent_id = new Guid(SYS_ParametroBO.ParametroValor(SYS_ParametroBO.eChave.ENTIDADE_PADRAO));
entityUsuario.usu_login = login;
// Carrega usuário apartir do email e entidade padrão
if (SYS_UsuarioBO.GetSelectBy_ent_id_usu_login(entityUsuario))
{
// Configura senha do usuário
entityUsuario.usu_criptografia = Convert.ToByte(eCriptografa.MD5);
entityUsuario.usu_senha = senha;
// Configura situação do usuário
if ((entityUsuario.usu_situacao != Convert.ToByte(SYS_UsuarioBO.eSituacao.Bloqueado)) &&
(entityUsuario.usu_situacao != Convert.ToByte(SYS_UsuarioBO.eSituacao.Excluido)) &&
(entityUsuario.usu_situacao != Convert.ToByte(SYS_UsuarioBO.eSituacao.Padrao_Sistema)))
{
if (Convert.ToByte(ativo) == Convert.ToByte(eAtivo.Ativo))
{
entityUsuario.usu_situacao = Convert.ToByte(SYS_UsuarioBO.eSituacao.Ativo);
}
else
{
entityUsuario.usu_situacao = Convert.ToByte(SYS_UsuarioBO.eSituacao.Senha_Expirada);
}
}
// Salva alterações do usuário
if (!SYS_UsuarioBO.AlterarSenhaAtualizarUsuario(entityUsuario, false, false))
{
throw new Exception("Não foi possível atualizar usuário.");
}
}
else
{
throw new Exception("Não foi possível encontrar usuário.");
}
// Configura Resposta
structSenha.senha = senha;
structSenha.ativo = ativo;
structSenha.status = Convert.ToByte(eStatus.Sucess).ToString();
structSenha.erro = string.Empty;
// Grava Log
ApplicationWEB._GravaLogSistema(LOG_SistemaTipo.Update, String.Format("usu_id: {0}, alteração de senha via Web Service.", entityUsuario.usu_id));
return(structSenha);
}
catch (Exception ex)
{
ApplicationWEB._GravaErro(ex);
// Configura Resposta
structSenha.senha = senha;
structSenha.ativo = ativo;
structSenha.status = Convert.ToByte(eStatus.Error).ToString();
structSenha.erro = ex.Message;
return(structSenha);
}
}
protected void Page_Load(object sender, EventArgs e)
{
try
{
if (!HttpContext.Current.User.Identity.IsAuthenticated)
{
string provider = IdentitySettingsConfig.IDSSettings.AuthenticationType;
Context.GetOwinContext().Authentication.Challenge(provider);
}
else
{
if (!UserIsAuthenticated())
{
throw new Exception("Usuário não encontrado!");
}
string prefixoRESP = ACA_ParametroAcademicoBO.ParametroValorPorEntidade(eChaveAcademico.PREFIXO_LOGIN_RESPONSAVEL_AREA_ALUNO, __SessionWEB.__UsuarioWEB.Usuario.ent_id);
bool responsavel = __SessionWEB.__UsuarioWEB.Usuario.usu_login.Contains(prefixoRESP);
// Se selecionou para logar como responsável, verifica se esse ele é responsável por um aluno só,
// ou caso tenha mais, redireciona para uma tela de selação de alunos
if (responsavel)
{
__SessionWEB.__UsuarioWEB.responsavel = true;
string prefixoAluno = ACA_ParametroAcademicoBO.ParametroValorPorEntidade(eChaveAcademico.PREFIXO_LOGIN_ALUNO_AREA_ALUNO, __SessionWEB.__UsuarioWEB.Usuario.ent_id);
//Troca o prefixo de responsável por aluno
var regex = new Regex(Regex.Escape(prefixoRESP));
var loginAluno = regex.Replace(__SessionWEB.__UsuarioWEB.Usuario.usu_login, prefixoAluno, 1);
SYS_Usuario entityUsuarioAluno = new SYS_Usuario
{
ent_id = __SessionWEB.__UsuarioWEB.Usuario.ent_id,
usu_login = loginAluno
};
SYS_UsuarioBO.GetSelectBy_ent_id_usu_login(entityUsuarioAluno);
__SessionWEB.__UsuarioWEB.pes_idAluno = entityUsuarioAluno.pes_id;
DataTable dtAlunosDoResponsavel = ACA_AlunoResponsavelBO.SelecionaAlunosPorResponsavel(__SessionWEB.__UsuarioWEB.Usuario.pes_id);
Session["Pes_Id_Responsavel"] = __SessionWEB.__UsuarioWEB.Usuario.pes_id.ToString();
Session["Qtde_Filhos_Responsavel"] = dtAlunosDoResponsavel.Rows.Count;
if (dtAlunosDoResponsavel.Rows.Count > 1)
{
RedirecionarLogin(true);
return;
}
}
RedirecionarLogin(false);
return;
}
}
catch (ValidationException ex)
{
lblMessage.Text = UtilBO.GetErroMessage(ex.Message, UtilBO.TipoMensagem.Alerta);
}
catch (Exception ex)
{
ApplicationWEB._GravaErro(ex);
lblMessage.Text = UtilBO.GetErroMessage("Erro ao tentar entrar no sistema.", UtilBO.TipoMensagem.Erro);
}
}
/// <summary>
/// Verifica se a Session do usuário está nula,
/// se estiver verifica o FormsIdentity e carrega a Session
/// </summary>
private void GetFormsIdentityLoadSession()
{
try
{
if (HttpContext.Current.User.Identity.IsAuthenticated)
{
//var identity = HttpContext.Current.User.Identity as FormsIdentity;
//if (identity != null)
//{
var identity = HttpContext.Current.User.Identity;
var entityId = identity.GetEntityId();
var usuLogin = identity.GetUsuLogin();
if (identity != null && entityId != null && usuLogin != null)
{
// // Recupera Ticket de autenticação gravado em Cookie
// FormsIdentity id = identity;
//FormsAuthenticationTicket ticket = id.Ticket;
// Carrega usuário na session através do ticket de authenticação
__SessionWEB.__UsuarioWEB.Usuario = new SYS_Usuario
{
ent_id = new Guid(entityId),
usu_login = usuLogin
};
SYS_UsuarioBO.GetSelectBy_ent_id_usu_login(__SessionWEB.__UsuarioWEB.Usuario);
// Carrega grupo na session através do ticket de autenticação
var gru_id = identity.GetGrupoId();
if (!string.IsNullOrEmpty(gru_id))
{
__SessionWEB.__UsuarioWEB.Grupo = SYS_GrupoBO.GetEntity(new SYS_Grupo {
gru_id = new Guid(gru_id)
});
}
else
{
// Carrega grupos do usuário
IList <SYS_Grupo> list = SYS_GrupoBO.GetSelectBySis_idAndUsu_id(
__SessionWEB.__UsuarioWEB.Usuario.usu_id
, ApplicationWEB.SistemaID);
// Verifica se foi carregado os grupos do usuário
if (list.Count > 0)
{
// Seleciona o primeiro grupo do usuário logado para carregar na Session
__SessionWEB.__UsuarioWEB.Grupo = list[0];
DataTable dtUaPermissao = ESC_EscolaBO.RetornaUAPermissaoUsuarioGrupo(__SessionWEB.__UsuarioWEB.Usuario.usu_id, ApplicationWEB._EntidadeID, __SessionWEB.__UsuarioWEB.Grupo.gru_id);
if (dtUaPermissao.Rows.Count > 0)
{
int esc_id;
Int32.TryParse(dtUaPermissao.Rows[0]["esc_id"].ToString(), out esc_id);
__SessionWEB.__UsuarioWEB.Esc_idPermissao = esc_id;
//Caso não tenha escola, significa que o usuário possui permissão de Gestão
if (esc_id == 0)
{
if (!string.IsNullOrEmpty(dtUaPermissao.Rows[0]["uad_idSuperior"].ToString()))
{
__SessionWEB.__UsuarioWEB.Uad_idSuperiorPermissao = new Guid(dtUaPermissao.Rows[0]["uad_idSuperior"].ToString());
}
}
}
}
}
// Carrega o cid_id na session referente a entidade do usuário autenticado
Guid ent_id = __SessionWEB.__UsuarioWEB.Usuario.ent_id;
Guid ene_id = SYS_EntidadeEnderecoBO.Select_ene_idBy_ent_id(ent_id);
SYS_EntidadeEndereco entityEntidadeEndereco = new SYS_EntidadeEndereco {
ent_id = ent_id, ene_id = ene_id
};
SYS_EntidadeEnderecoBO.GetEntity(entityEntidadeEndereco);
END_Endereco entityEndereco = new END_Endereco {
end_id = entityEntidadeEndereco.end_id
};
END_EnderecoBO.GetEntity(entityEndereco);
__SessionWEB._cid_id = entityEndereco.cid_id;
// Carrega nome ou login na session do usuário autenticado
PES_Pessoa entityPessoa = new PES_Pessoa {
pes_id = __SessionWEB.__UsuarioWEB.Usuario.pes_id
};
PES_PessoaBO.GetEntity(entityPessoa);
__SessionWEB.UsuarioLogado = string.IsNullOrEmpty(entityPessoa.pes_nome) ? __SessionWEB.__UsuarioWEB.Usuario.usu_login : entityPessoa.pes_nome;
LoadSessionSistema();
}
}
}
catch (Exception ex)
{
ApplicationWEB._GravaErro(ex);
}
}
