protected void Page_Load(object sender, EventArgs e)
{
//var usuarios = new UsuarioDomain().GetList(new APP.Model.dataShape.Usuario() { iid = 134 });
var usuarios = new UsuarioDomain().GetList(new APP.Model.dataShape.Usuario());
dataGrid1.DataSource = usuarios;
dataGrid1.DataBind();
}
public async Task<IHttpActionResult> Post([FromBody] UsuarioPostModel viewModel)
{
var domainModel = Mapper.Map<UsuarioPostModel, Usuario>(viewModel);
var domain = new UsuarioDomain();
await domain.CreateAsync(domainModel);
viewModel.Id = domainModel.Id;
return Created(Request.RequestUri, viewModel);
}
public async Task<IHttpActionResult> Put(long? id, [FromBody] UsuarioPutModel viewModel)
{
var domailModel = Mapper.Map<UsuarioPutModel, Usuario>(viewModel);
var domain = new UsuarioDomain();
domailModel.Id = id.Value;
await domain.UpdateAsync(domailModel);
return Ok();
}
public async Task<IHttpActionResult> Get(long? id)
{
var domain = new UsuarioDomain();
var domainModel = await domain.FindByIdAsync(id.Value);
if (domainModel == null)
return NotFound();
var viewModel = Mapper.Map<Usuario, UsuarioGetModel>(domainModel);
return Ok(viewModel);
}
public async Task<IHttpActionResult> Ativar(long? id, string token)
{
var domain = new UsuarioDomain();
var identityResult = await domain.ConfirmEmailAsync(id.Value, token);
if (!identityResult.Succeeded)
return GetErrorResult(identityResult);
await domain.EnviarNotificacaoAtivacaoConta(id.Value);
return Ok();
}
public void Cadastrar(UsuarioDomain novoUsuario)
{
using (SqlConnection con = new SqlConnection(stringConexao))
{
string queryInsert = "INSERT INTO Usuario(idTipoUsuario, email,senha) VALUES (@idTipoUsuario, @email, @senha)";
using (SqlCommand cmd = new SqlCommand(queryInsert, con))
{
cmd.Parameters.AddWithValue("@idTipoUsuario", novoUsuario.idTipoUsuario);
cmd.Parameters.AddWithValue("@email", novoUsuario.email);
cmd.Parameters.AddWithValue("@senha", novoUsuario.senha);
con.Open();
cmd.ExecuteNonQuery();
}
}
}
public static string getHash(UsuarioDomain usuario)
{
string sal = "protegendoseucodigo";
var salt = Encoding.ASCII.GetBytes(sal);
string hash = Convert.ToBase64String(KeyDerivation.Pbkdf2(
password: usuario.Senha,
salt: salt,
prf: KeyDerivationPrf.HMACSHA256,
iterationCount: 10000,
numBytesRequested: 256 / 8
));
return(hash);
}
public IActionResult Post(LoginViewModel login)
{
try
{
UsuarioDomain usuario = UsuarioRepository.BuscarPorEmailSenha(login.Email, login.Senha);
if (usuario == null)
{
return(NotFound(new
{
mensagem = "Usuário não encontrado...",
}
));
}
var claims = new[]
{
new Claim(JwtRegisteredClaimNames.Email, usuario.Email),
new Claim(JwtRegisteredClaimNames.Jti, usuario.Id.ToString()),
new Claim(ClaimTypes.Role, usuario.TipoUsuario)
};
var key = new SymmetricSecurityKey(System.Text.Encoding.UTF8.GetBytes("svigufo-chave-autenticacao"));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var token = new JwtSecurityToken(
issuer: "Svigufo.WebApi",
audience: "Svigufo.WebApi",
claims: claims,
expires: DateTime.Now.AddMinutes(30),
signingCredentials: creds
);
return(Ok(new
{
token = new JwtSecurityTokenHandler().WriteToken(token)
}));
}
catch
{
return(BadRequest(new
{
mensagem = "Deu Bug, aqui é possível deixar uma mensagem sobre o BadRequest."
}
));
}
}
public IActionResult Post(LoginViewModel login)
{
try
{
// UsuarioDomain usuario = UsuarioRepository.BuscarPorEmailESenha(login);
UsuarioDomain usuario = UsuarioRepository.BuscarPorEmailESenha(login.Email, login.Senha);
if (usuario == null)
{
return(NotFound(
new
{
mensagem = "Usuário ou senha inválidos."
}
));
}
var claims = new[]
{
new Claim(JwtRegisteredClaimNames.Email, login.Email),
new Claim(JwtRegisteredClaimNames.Jti, usuario.Id.ToString()),
new Claim(ClaimTypes.Role, usuario.TipoUsuario),
};
//recebe uma instancia da classe SymmetricSecurityKey
//armazenando a chave de criptografia usada na criação do token
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("svigufo-chave-autenticacao"));
//recebe um objeto do tipo SigninCredentials contendo a chave de
//criptografia e o algoritmo de segurança empregados na geração
// de assinaturas digitais para tokens
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var token = new JwtSecurityToken(
issuer: "Svigufo.WebApi",
audience: "Svigufo.WebApi",
claims: claims,
expires: DateTime.Now.AddMinutes(30),
signingCredentials: creds);
return(Ok(new
{
token = new JwtSecurityTokenHandler().WriteToken(token)
}));
}
catch (Exception ex)
{
return(BadRequest(new { mensagem = ex.Message }));
}
}
public void Atualizar(int id, UsuarioDomain usuario)
{
using (SqlConnection con = new SqlConnection(stringConexao))
{
string query = "update Usuarios set Email = @Email, Senha = @Senha where IdUsuario = @Id";
using (SqlCommand cmd = new SqlCommand(query, con))
{
cmd.Parameters.AddWithValue("@Id", id);
string verificar = "select Usuarios.Email, Usuarios.Senha from Usuarios where IdUsuario = @Id";
using (SqlCommand verificarUser = new SqlCommand(verificar, con))
{
verificarUser.Parameters.AddWithValue("@Id", id);
con.Open();
SqlDataReader rdrVerificar = verificarUser.ExecuteReader();
if (rdrVerificar.Read())
{
UsuarioDomain userBackup = new UsuarioDomain();
userBackup.Email = rdrVerificar["Email"].ToString();
userBackup.Senha = rdrVerificar["Senha"].ToString();
userBackup.NomeUsuario = rdrVerificar["NomeUsuario"].ToString();
if (String.IsNullOrEmpty(usuario.Email))
{
cmd.Parameters.AddWithValue("@Email", userBackup.Email);
cmd.Parameters.AddWithValue("@Senha", usuario.Senha);
cmd.Parameters.AddWithValue("@NomeUsuario", usuario.NomeUsuario);
}
else if (String.IsNullOrEmpty(usuario.Senha))
{
cmd.Parameters.AddWithValue("@Email", usuario.Email);
cmd.Parameters.AddWithValue("@Senha", userBackup.Senha);
cmd.Parameters.AddWithValue("@NomeUsuario", usuario.NomeUsuario);
}
rdrVerificar.Close();
cmd.ExecuteNonQuery();
}
}
}
}
}
/// <summary>
/// Gera o token de login com informações de usuário e permissões
/// </summary>
/// <param name="usuario"> informações de usuario</param>
/// <param name="signingConfigurations">configurações de assinatura</param>
/// <param name="tokenConfigurations">configurações de token</param>
/// <returns></returns>
public object GerarToken(UsuarioDomain usuario, int empresaId, string setor, SigningConfigurations signingConfigurations,
TokenConfigurations tokenConfigurations)
{
ClaimsIdentity identity = new ClaimsIdentity(
new GenericIdentity(usuario.Id.ToString(), "Login"),
new[] {
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString("N")),
new Claim(JwtRegisteredClaimNames.UniqueName, usuario.Id.ToString()),
new Claim("Nome", usuario.Id.ToString()),
new Claim("EmpresaId", empresaId.ToString()),
new Claim("Setor", setor),
new Claim(ClaimTypes.Email, usuario.Email)
}
);
foreach (var usuarioPermissao in usuario.Permissoes)
{
identity.AddClaim(new Claim(ClaimTypes.Role, usuarioPermissao.Permissao.Permissao));
}
DateTime dataCriacao = DateTime.Now;
DateTime dataExpiracao = dataCriacao.AddMonths(6);
//gerar token JWT
var tokenHandler = new JwtSecurityTokenHandler();
var securityToken = tokenHandler.CreateToken(new SecurityTokenDescriptor
{
Issuer = tokenConfigurations.Issuer,
Audience = tokenConfigurations.Audience,
SigningCredentials = signingConfigurations.SigningCredentials,
Subject = identity,
NotBefore = dataCriacao,
Expires = dataExpiracao
});
var token = tokenHandler.WriteToken(securityToken);
var retorno = new
{
authenticated = true,
created = dataCriacao.ToString("yyyy-MM-dd HH:mm:ss"),
expiration = dataExpiracao.ToString("yyyy-MM-dd HH:mm:ss"),
accessToken = token,
message = "OK"
};
return(retorno);
}
public IActionResult Cadastrar([FromBody] UsuarioDomain usuario)
{
try
{
if (ModelState.IsValid)
{
UsuarioDomain retornoUsuario = _usuarioRepository.BuscarPorEmail(usuario.Email);
if (retornoUsuario != null)
{
return(BadRequest("Email já cadastrado"));
}
_usuarioRepository.Inserir(usuario);
return(Ok(usuario));
}
var errors = ModelState.Select(x => x.Value.Errors)
.Where(y => y.Count > 0)
.ToList();
if (errors.Any())
{
return(BadRequest(errors));
}
else
{
var retornoUsuarios = new {
id = usuario.UsuarioId,
email = usuario.Email,
role = usuario.Role,
ativo = usuario.Ativo,
perfil = new {
id = usuario.Perfil.PerfilId,
usuarioId = usuario.UsuarioId,
nome = usuario.Perfil.Nome,
miniBio = usuario.Perfil.MiniBio,
cep = usuario.Perfil.Cep,
sedeId = usuario.Perfil.SedeId
}
};
}
return(Ok(usuario));
}
catch (System.Exception e)
{
return(BadRequest(e.Message));
}
}
public IActionResult Login(UsuarioDomain login)
{
//Busca o usuário pelo e-mail e senha
UsuarioDomain usuarioBuscado = _usuarioRepository.BuscarPorEmailSenha(login.email, login.senha);
//caso não encontre nenhum usuário irá retornar um status code Not Found
if (usuarioBuscado == null)
{
return(NotFound("E-mail ou senha invalidos"));
}
//caso encontre prossegue a criação do token
//Define os dados que serão fornecidos no Token - Payload
var claims = new[]
{
//TipoDaClaim, ValorDaClaim
new Claim(JwtRegisteredClaimNames.Email, usuarioBuscado.email),
new Claim(JwtRegisteredClaimNames.Jti, usuarioBuscado.idUsuario.ToString()),
new Claim(ClaimTypes.Role, usuarioBuscado.permissao),
new Claim("Claim Personalizada", "Valor Teste")
};
//chave de acesso ao Token
var key = new SymmetricSecurityKey(System.Text.Encoding.UTF8.GetBytes("filmes-chave-autenticação"));
//Define as credenciais do token- Header
var cred = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
//gera token
var token = new JwtSecurityToken
(
issuer: "Filmes.WebApi", //definindo o emissor do token
audience: "Filmes.WebApi", //destinatário do token
claims: claims, //dados definidos na linha 47
expires: DateTime.Now.AddMinutes(30), //tempo de expiração
signingCredentials: cred //credenciais do token
);
//retorna um Status code - 200(OK)
return(Ok
(
new
{
token = new JwtSecurityTokenHandler().WriteToken(token)
}
));
}
public async Task<IHttpActionResult> Post([FromBody] ContaPostModel viewModel)
{
var domainModel = Mapper.Map<ContaPostModel, Usuario>(viewModel);
var domain = new UsuarioDomain();
var identityResult = await domain.CreateAsync(domainModel, domainModel.Senha);
if (!identityResult.Succeeded)
return GetErrorResult(identityResult);
viewModel.Id = domainModel.Id;
await domain.EnviarSolicitacaoAtivacaoConta(domainModel);
return Created(Request.RequestUri, viewModel);
}
public void Register(UsuarioDomain newTEntity)
{
using (SqlConnection con = new SqlConnection(connectionString)) {
string queryInsert = "INSERT INTO Usuario(email, senha, idTipoUsuario) VALUES(@email, @senha, @idTipoUsuario)";
using (SqlCommand cmd = new SqlCommand(queryInsert, con)) {
cmd.Parameters.AddWithValue("@email", newTEntity.email);
cmd.Parameters.AddWithValue("@senha", newTEntity.senha);
cmd.Parameters.AddWithValue("@idTipoUsuario", newTEntity.idTipoUsuario);
con.Open();
cmd.ExecuteNonQuery();
}
}
}
/// <summary>
/// MéTODO PARA DELETAR USUÁRIOS NO BANCO DE DADOS
/// </summary>
/// <param name="domain"> Deletar os dados de um usuário</param>
/// <returns> Retorna true se o usuário for excluido e false, caso ocorra algum erro </returns>
public bool Deletar(UsuarioDomain domain)
{
var usuario = _contexto.Usuarios.Single(o => o.Id == domain.Id);
_contexto.Usuarios.Remove(usuario);
int linhasExcluidas = _contexto.SaveChanges();
if (linhasExcluidas > 0)
{
return(true);
}
else
{
return(false);
}
}
// O POST SERVE PARA CADASTRAR UM NOVO ITEM
public IActionResult Cadastrar(UsuarioDomain usuario)
{
try
{
if (usuario.IdTipoUsuario == 2)
{
return(BadRequest(new { mensagem = "Erro: Você não possui a autorização necessária para cadastrar este tipo de usuário." }));
}
UsuarioRepository.Cadastrar(usuario);
return(Ok());
}
catch (Exception ex)
{
return(BadRequest(new { mensagem = "Erro: " + ex.Message }));
}
}
/// <summary>
/// Lista todos os usuários
/// </summary>
/// <returns>Retorna uma lista de usuários</returns>
public List <UsuarioDomain> Listar()
{
// Cria uma lista usuários onde serão armazenados os dados
List <UsuarioDomain> usuarios = new List <UsuarioDomain>();
// Declara a SqlConnection passando a string de conexão
using (SqlConnection con = new SqlConnection(stringConexao))
{
// Declara a instrução a ser executada
string querySelectAll = "SELECT IdUsuario, Email, Senha, IdTipoUsuario FROM Usuarios";
// Abre a conexão com o banco de dados
con.Open();
// Declara o SqlDataReader para receber os dados do banco de dados
SqlDataReader rdr;
// Declara o SqlCommand passando o comando a ser executado e a conexão
using (SqlCommand cmd = new SqlCommand(querySelectAll, con))
{
// Executa a query e armazena os dados no rdr
rdr = cmd.ExecuteReader();
// Enquanto houver registros para serem lidos no rdr, o laço se repete
while (rdr.Read())
{
// Instancia um objeto usuario
UsuarioDomain usuario = new UsuarioDomain
{
// Atribui às propriedades os valores das colunas da tabela do banco
IdUsuario = Convert.ToInt32(rdr[0]),
Email = rdr["Email"].ToString(),
Senha = rdr["Senha"].ToString(),
IdTipoUsuario = Convert.ToInt32(rdr[0]),
};
// Adiciona o usuario criado à lista usuarios
usuarios.Add(usuario);
}
}
}
// Retorna a lista de usuários
return(usuarios);
}
/// <summary>
/// Valida o usuário
/// </summary>
/// <param name="email">E-mail do usuário</param>
/// <param name="senha">Senha do usuário</param>
/// <returns>Retorna um usuário validado</returns>
public UsuarioDomain BuscarPorEmailSenha(string email, string senha)
{
// Define a conexão passando a string
using (SqlConnection con = new SqlConnection(stringConexao))
{
// Define a query a ser executada no banco
string querySelect = "SELECT U.IdUsuario, U.Email, U.IdTipoUsuario, TU.Titulo FROM Usuarios U INNER JOIN TiposUsuario TU ON U.IdTipoUsuario = TU.IdTipoUsuario WHERE Email = @Email AND Senha = @Senha";
// Define o comando passando a query e a conexão
using (SqlCommand cmd = new SqlCommand(querySelect, con))
{
// Define o valor dos parâmetros
cmd.Parameters.AddWithValue("@Email", email);
cmd.Parameters.AddWithValue("@Senha", senha);
// Abre a conexão com o banco
con.Open();
// Executa o comando e armazena os dados no objeto rdr
SqlDataReader rdr = cmd.ExecuteReader();
// Caso o resultado da query possua registro
if (rdr.Read())
{
// Instancia um objeto usuario
UsuarioDomain usuario = new UsuarioDomain
{
// Atribui às propriedades os valores das colunas da tabela do banco
IdUsuario = Convert.ToInt32(rdr["IdUsuario"])
, Email = rdr["Email"].ToString()
, IdTipoUsuario = Convert.ToInt32(rdr["IdTipoUsuario"])
, TipoUsuario = new TipoUsuarioDomain
{
IdTipoUsuario = Convert.ToInt32(rdr["IdTipoUsuario"])
, Titulo = rdr["Titulo"].ToString()
}
};
// Retorna o usuario buscado
return(usuario);
}
}
// Caso não encontre um email e senha correspondente, retorna null
return(null);
}
}
public ActionResult AlterarSenha(AlterarSenhaViewModel senha)
{
try
{
if (!ModelState.IsValid)
{
ViewBag.Erro = "Dados inválidos. Verifique!";
return(View());
}
//Obtêm as Claims do usuário logado
var identity = User.Identity as ClaimsIdentity;
//Pega o valor do Id do usuário
var id = identity.Claims.FirstOrDefault(x => x.Type == ClaimTypes.NameIdentifier).Value;
//Obtêm o valor de uma Claim nâo definida
var telefone = identity.Claims.FirstOrDefault(x => x.Type == "Telefone").Value;
//Cria uma instancia de UsuarioRepositorio
using (UsuarioRepositorio objRepoUsuario = new UsuarioRepositorio())
{
//Busca o usuário pelo seu Id
UsuarioDomain objUsuario = objRepoUsuario.BuscarPorId(new Guid(id));
//Verifico se a senha informada é igual a Atual
if (Hash.GerarHash(senha.SenhaAtual) != objUsuario.Senha)
{
//Senha inválida eu informo ao usuário
ModelState.AddModelError("SenhaAtual", "Senha incorreta");
return(View());
}
//Atribuimos o valor da nova senha ao objeto usuário
objUsuario.Senha = Hash.GerarHash(senha.NovaSenha);
//Alteramos o usuário no banco
objRepoUsuario.Alterar(objUsuario);
//Definimos a mensagem que irá aparecer na tela
TempData["Sucesso"] = "Senha Alterada";
//Retornamos ao Controller Usuário, Index
return(RedirectToAction("Index", "Usuario"));
}
}
catch (System.Exception ex)
{
ViewBag.Erro = "Ocorreu um erro " + ex.Message;
return(View());
}
}
public void Update(UsuarioDomain newTEntity)
{
using (SqlConnection con = new SqlConnection(connectionString)) {
string queryUpdateBody = "UPDATE Usuario SET email = @email, senha = @senha, idTipoUsuario = @idTipoUsuario WHERE idUsuario = @id";
using (SqlCommand cmd = new SqlCommand(queryUpdateBody, con)) {
cmd.Parameters.AddWithValue("@id", newTEntity.idUsuario);
cmd.Parameters.AddWithValue("@email", newTEntity.email);
cmd.Parameters.AddWithValue("@senha", newTEntity.senha);
cmd.Parameters.AddWithValue("@idTipoUsuario", newTEntity.idTipoUsuario);
con.Open();
cmd.ExecuteNonQuery();
}
}
}
public void Cadastrar(UsuarioDomain usuario)
{
using (SqlConnection con = new SqlConnection(stringConexao))
{
string queryInsert = "INSERT INTO Usuarios VALUES(@Email, @Senha, @NomeUsuario";
using (SqlCommand cmd = new SqlCommand(queryInsert, con))
{
cmd.Parameters.AddWithValue("@Email", usuario.Email);
cmd.Parameters.AddWithValue("@Senha", usuario.Senha);
cmd.Parameters.AddWithValue("@NomeUsuario", usuario.NomeUsuario);
con.Open();
cmd.ExecuteNonQuery();
}
}
}
public UsuarioDomain BuscarPorId(int id)
{
using (SqlConnection con = new SqlConnection(stringConexao))
{
string querySelectById = "SELECT IdtipoUsuario,Email,Senha FROM Usuario" +
"WHERE Idusuario = @ID";
con.Open();
SqlDataReader rdr;
using (SqlCommand cmd = new SqlCommand(querySelectById, con))
{
cmd.Parameters.AddWithValue("@ID", id);
rdr = cmd.ExecuteReader();
if (rdr.Read())
{
// Instancia um objeto usuario
UsuarioDomain usuario = new UsuarioDomain
{
// Atribui às propriedades os valores das colunas da tabela do banco
IdUsuario = Convert.ToInt32(rdr["IdUsuario"])
,
Email = rdr["Email"].ToString()
,
IdTipoUsuario = Convert.ToInt32(rdr["IdTipoUsuario"])
,
TipoUsuario = new TipoUsuarioDomain
{
IdTipoUsuario = Convert.ToInt32(rdr["IdTipoUsuario"])
,
Titulo = rdr["Titulo"].ToString()
}
};
// Retorna o usuario buscado
return(usuario);
}
// Caso o resultado da query não possua registros, retorna null
return(null);
}
}
}
public IActionResult Post(UsuarioDomain usuario)
{
try
{
//Chama o repositorio para efetuar o cadastro do usuário
UsuarioRepository.Cadastrar(usuario);
//Retorna um status code 200 informando que o usuário foi cadastrado
return(Ok(new {
mensagem = "Usuário Cadastrado"
}));
}
catch
{
return(BadRequest());
}
}
public UsuarioDomain LoginUsuario(string nomeUsuario, string password)
{
UsuarioDomain usuario = AcharUsuario(nomeUsuario.ToLower());
if (usuario == null)
{
return(null);
}
//verifica a validade da senha
if (!VerificarPassword(password, usuario.PasswordHash, usuario.PasswordSalt))
{
return(null);
}
return(usuario);
}
public IActionResult Login(UsuarioDomain login)
{
// Busca o usuário pelo e-mail e senha
UsuarioDomain usuarioBuscado = _usuarioRepository.BuscarPorEmailSenha(login.email, login.senha);
// Caso não encontre nenhum usuário com o e-mail e senha informados
if (usuarioBuscado == null)
{
// retorna NotFound com uma mensagem personalizada
return(NotFound("E-mail ou senha inválidos!"));
}
// Caso encontre, prossegue para a criação do token
// Define os dados que serão fornecidos no token - Payload
var claims = new[]
{
// TipoDaClaim, ValorDaClaim
new Claim(JwtRegisteredClaimNames.Email, usuarioBuscado.email),
new Claim(JwtRegisteredClaimNames.Jti, usuarioBuscado.idUsuario.ToString()),
new Claim(ClaimTypes.Role, usuarioBuscado.idTipoUsuario.ToString()),
new Claim("Claim personalizada", "Valor teste")
};
// Define a chave de acesso ao token
var key = new SymmetricSecurityKey(System.Text.Encoding.UTF8.GetBytes("peoples-chave-autenticacao"));
// Define as credenciais do token - Header
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
// Define a composição do token
var token = new JwtSecurityToken(
issuer: "T_Peoples.webApi", // emissor do token
audience: "T_Peoples.webApi", // destinatário do token
claims: claims, // dados definidos acima (linha 59)
expires: DateTime.Now.AddMinutes(5), // tempo de expiração
signingCredentials: creds // credenciais do token
);
// Retorna um status code 200 - Ok com o token criado
return(Ok(new
{
token = new JwtSecurityTokenHandler().WriteToken(token)
}));
}
public IActionResult GetById(int id)
{
// cria um objeto "funcionarioBuscado" que irá receber o "funcionarioBuscado" no banco de dados
UsuarioDomain usuarioBuscado = _usuarioRepository.BuscarPorId(id);
// um "=" é atribuição, um "==" é uma comparação
// verifica se nenhum funcionário foi encontrado
if (usuarioBuscado == null)
{
// caso não seja encontrado, retorna um status code 404 - Not Found com uma mensagem personalizada
return(NotFound("Nenhum usuário encontrado!"));
}
// caso seja encontrado, retorna o funcionário buscado com um status code 200 - Ok
return(Ok(usuarioBuscado));
}
// O POST SERVE PARA CADASTRAR UM NOVO ITEM
public IActionResult Login(LoginViewModel login)
{
try
{
UsuarioDomain Usuario = UsuarioRepository.BuscarPorEmailESenha(login);
if (Usuario == null)
{
return(NotFound(new { mensagem = "Email ou senha inválidos." }));
}
// SÃO AS INFORMAÇÕES DO USUARIO
var claims = new[]
{
// EMAIL DO USUARIO
new Claim(JwtRegisteredClaimNames.Email, Usuario.Email),
// ID DO USUARIO
new Claim(JwtRegisteredClaimNames.Jti,
Usuario.IdUsuario.ToString()),
// ESSE É O TIPO DO USUÁRIO
new Claim(ClaimTypes.Role, Usuario.IdTipoUsuarioNavigation.Nome),
};
// ESSA CHAVE ESTA CONFIGURADA NO STARTUP
var key = new SymmetricSecurityKey
(System.Text.Encoding.UTF8.GetBytes("opflix-chave-autenticacao"));
// CRIPTOGRAFIA
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var token = new JwtSecurityToken(
// QUEM ESTA MANDANDO E QUEM ESTA VALIDANDO
issuer: "OpFlix.WebApi",
audience: "OpFlix.WebApi",
// ESSA É A DATA DE EXPIRAÇÃO
claims: claims, expires: DateTime.Now.AddMinutes(30),
// ESSA É A CHAVE
signingCredentials: creds);
// SERVE PARA GERAR AS CHAVES
return(Ok(new
{
token = new JwtSecurityTokenHandler().WriteToken(token)
}));
}
catch (Exception ex)
{
return(BadRequest(new { mensagem = "Erro." + ex.Message }));
}
}
public void Cadastrar(UsuarioDomain usuario)
{
using (SqlConnection con = new SqlConnection(stringConexao))
{
string query = "INSERT INTO Usuarios (Email, Senha, IdTipoUsuario)VALUES (@Email, @Senha, @IdTipoUsuario)";
SqlCommand cmd = new SqlCommand(query, con);
cmd.Parameters.AddWithValue("@Email", usuario.Email);
cmd.Parameters.AddWithValue("@Senha", usuario.Senha);
cmd.Parameters.AddWithValue("@IdTipoUsuario", usuario.IdTipoUsuario);
con.Open();
cmd.ExecuteNonQuery();
}
}
public UsuarioDomain BuscarPorEmailSenha(string email, string senha)
{
using (SqlConnection con = new SqlConnection(stringConexao))
{
string querySelect = "SELECT U.IdUsuario, U.Email, U.IdTipoUsuario, TU.Titulo FROM Usuarios U INNER JOIN TipoUsuario TU ON U.IdTipoUsuario = TU.IdTipoUsuario WHERE Email = @Email AND Senha = @Senha";
using (SqlCommand cmd = new SqlCommand(querySelect, con))
{
cmd.Parameters.AddWithValue("@Email", email);
cmd.Parameters.AddWithValue("@Senha", senha);
con.Open();
SqlDataReader rdr = cmd.ExecuteReader();
if (rdr.Read())
{
UsuarioDomain usuario = new UsuarioDomain
{
IdUsuario = Convert.ToInt32(rdr["IdUsuario"]),
Email = rdr["Email"].ToString(),
IdTipoUsuario = Convert.ToInt32(rdr["IdTipoUsuario"]),
TipoUsuario = new TipoUsuarioDomain
{
IdTipoUsuario = Convert.ToInt32(rdr["IdTipoUsuario"]),
Titulo = rdr["Titulo"].ToString()
}
};
return(usuario);
}
}
return(null);
}
}
public IActionResult Cadastrar(UsuarioDomain user)
{
try
{
if ((user.Email == "") || (user.Senha == "") || (user.IdTipoUsuario == 0))
{
return(BadRequest("Preecha todos os campos!"));
}
_usuarioRepository.Cadastrar(user);
return(StatusCode(201));
}
catch (Exception erro)
{
return(BadRequest(erro));
}
}
public IActionResult Post(LoginViewModel login)
{
try
{
UsuarioDomain usuarioBuscado = _repository.Login(login.Email, login.Senha);
if (usuarioBuscado == null)
{
return(NotFound());
}
var claims = new[]
{
new Claim(JwtRegisteredClaimNames.Email, usuarioBuscado.Email),
new Claim(JwtRegisteredClaimNames.Jti, usuarioBuscado.Id)
};
var key = new SymmetricSecurityKey(System.Text.Encoding.UTF8.GetBytes("Churrasco-chave-autenticacao"));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var token = new JwtSecurityToken(
issuer: "ChurrascoApi",
audience: "ChurrascoApi",
claims: claims,
expires: DateTime.Now.AddMinutes(30),
signingCredentials: creds
);
return(Ok(new
{
token = new JwtSecurityTokenHandler().WriteToken(token)
}));
}
catch (Exception error)
{
return(BadRequest(new
{
mensagem = "Não foi possível gerar o token",
error
}));
}
}
public IActionResult Post(UsuarioDomain usuario)
{
try
{
usuario = UsuarioRepository.BuscarPorEmailSenha(usuario.Email, usuario.Senha);
if (usuario == null)
{
return(NotFound(new
{
mensagem = "Usuario não encontrado"
}
));
}
//SENTA QUE LÁ VEM MERDA 2.0
var claims = new[]
{
new Claim(JwtRegisteredClaimNames.Email, usuario.Email),
new Claim(JwtRegisteredClaimNames.Jti, usuario.UsuarioId.ToString()),
new Claim(ClaimTypes.Role, usuario.TipoUsuario)
};
var key = new SymmetricSecurityKey(System.Text.Encoding.UTF8.GetBytes("InLockGames-authenticacao"));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var token = new JwtSecurityToken(
//Nome do Issuer, de onde esta vindo
issuer: "InLockGames.WebApi",
//Nome da Audience, de onde está vindo
audience: "InLockGames.WebApi",
claims: claims,
expires: DateTime.Now.AddMinutes(30),
signingCredentials: creds
);
return(Ok(new
{
token = new JwtSecurityTokenHandler().WriteToken(token)
}));
}
catch
{
return(BadRequest());
}
}
/// <summary>
/// Busca um usuário através do ID
/// </summary>
/// <param name="id">ID do usuário que será buscado</param>
/// <returns>Retorna um usuário buscado</returns>
public UsuarioDomain BuscarPorId(int id)
{
// Declara a conexão passando a string de conexão
using (SqlConnection con = new SqlConnection(stringConexao))
{
// Declara a query que será executada
string querySelectById = "SELECT IdUsuario, Email, Senha, IdTipoUsuario FROM Usuarios WHERE IdUsuario = @ID";
// Abre a conexão com o banco de dados
con.Open();
// Declara o SqlDataReader para receber os dados do banco de dados
SqlDataReader rdr;
// Declara o SqlCommand passando o comando a ser executado e a conexão
using (SqlCommand cmd = new SqlCommand(querySelectById, con))
{
// Passa o valor do parâmetro
cmd.Parameters.AddWithValue("@ID", id);
// Executa a query e armazena os dados no rdr
rdr = cmd.ExecuteReader();
// Caso o resultado da query possua registro
if (rdr.Read())
{
// Instancia um objeto usuario
UsuarioDomain usuario = new UsuarioDomain
{
// Atribui às propriedades os valores das colunas da tabela do banco
IdUsuario = Convert.ToInt32(rdr["IdUsuario"]),
Email = rdr["Email"].ToString(),
Senha = rdr["Senha"].ToString(),
IdTipoUsuario = Convert.ToInt32(rdr["IdTipoUsuario"]),
};
// Retorna o usuario buscado
return(usuario);
}
// Caso o resultado da query não possua registros, retorna null
return(null);
}
}
}
public ActionResult AlterarSenha(AlterarSenhaViewModel senha)
{
try
{
if (!ModelState.IsValid)
{
ViewBag.Erro = "Ocorreu um erro. Verifique digite uma senha válida!";
return(View());
}
//obtem claims do usuario
var identity = User.Identity as ClaimsIdentity;
// pega valor do id do Usuario
var id = identity.Claims.FirstOrDefault(x => x.Type == ClaimTypes.NameIdentifier).Value;
// obtem o valor de uma clais não definica anteriormente em contaController
var telefomne = identity.Claims.FirstOrDefault(x => x.Type == "Telefone").Value;
using (UsuarioRepositorio objRepUsuario = new UsuarioRepositorio())
{
// verifica se a senha ionformada é igual a atual
UsuarioDomain objUsuario = objRepUsuario.BuscarPorId(new Guid(id));
if (Hash.GerarHash(senha.SenhaAtual) != objUsuario.Senha)
{
// senha invalida informo o usuario
ModelState.AddModelError("Senha Atual", "Senha incorreta");
return(View());
}
// atribue o valor da nova senha ao objeto usuario
objUsuario.Senha = Hash.GerarHash(senha.NovaSenha);
// altera o usuario no bando
objRepUsuario.Alterar(objUsuario);
// Defimos a mensagem que ira aparecer na tela
TempData["Sucesso"] = "Senha Altereda";
// retornamos ao controller Usuario , Index
return(RedirectToAction("Index", "Usuario"));
}
}
catch (Exception ex)
{
ViewBag.message = "Ocorreu um erro" + ex.Message;
return(View());
}
return(RedirectToAction("Index", "Usuario"));
}
public int Deletar(int id)
{
try{
//encontrar funcionario pelo id
FuncionarioDomain funcionario = _context.Funcionarios.FirstOrDefault(x => x.Id == id);
UsuarioDomain usuario = _context.Usuarios.FirstOrDefault(y => y.Id == funcionario.UsuarioId);
//remover funcionario e usuario
_context.Funcionarios.Remove(funcionario);
_context.Usuarios.Remove(usuario);
return(_context.SaveChanges());
}
catch (Exception e) {
throw new Exception(e.Message);
}
throw new System.NotImplementedException();
}
public override async Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context)
{
// 1. Reading the allowed origin value for this client from the Owin context, then we use this value
// to add the header “Access-Control-Allow-Origin” to Owin context response, by doing this and for
// any JavaScript application we’ll prevent using the same client id to build another JavaScript
// application hosted on another domain; because the origin for all requests coming from this app will be
// from a different domain and the back-end API will return 405 status.
var allowedOrigin = context.OwinContext.Get<string>("as:clientAllowedOrigin") ?? "*";
context.OwinContext.Response.Headers.Add("Access-Control-Allow-Origin", new[] { allowedOrigin });
// 2. We’ll check the username/password for the resource owner if it is valid, and if this is the case
// we’ll generate set of claims for this user along with authentication properties which contains the client
// id and userName, those properties are needed for the next steps.
var usuarioDomain = new UsuarioDomain();
var usuario = await usuarioDomain.FindAsync(context.UserName, context.Password);
if (usuario == null)
{
context.SetError("invalid_grant", "The user name or password is incorrect.");
return;
}
// 3. Retorna Claims do usuário
var claimsCollection = await usuarioDomain.GetClaimsByUsernameAsync(usuario.UserName);
var identity = new ClaimsIdentity(context.Options.AuthenticationType);
if (claimsCollection != null)
identity.AddClaims(claimsCollection);
// MOCKING START
identity.AddClaim(new Claim(ClaimTypes.Name, usuario.UserName));
// MOCKING END
var props = new AuthenticationProperties(new Dictionary<string, string>
{
{"as:client_id", context.ClientId ?? string.Empty},
{"userName", context.UserName}
});
// 4. Now the access token will be generated behind the scenes when we call “context.Validated(ticket)”
var ticket = new AuthenticationTicket(identity, props);
context.Validated(ticket);
}
public override async Task GrantRefreshToken(OAuthGrantRefreshTokenContext context)
{
// pega o id do cliente gravado no ticket e o id do cliente da requisição
var originalClient = context.Ticket.Properties.Dictionary["as:client_id"];
var currentClient = context.ClientId;
// se os ID forem diferentes
if (originalClient != currentClient)
{
// invalida o cliente
context.SetError("invalid_clientId", "Refresh token is issued to a different clientId.");
return;
}
// adiciona ou remove novas claims setadas para este determinado usuário
var newIdentity = new ClaimsIdentity(context.Options.AuthenticationType);
var usuarioDomain = new UsuarioDomain();
var claimsCollection = await usuarioDomain.GetClaimsByUsernameAsync(context.Ticket.Identity.Name);
if (claimsCollection != null)
newIdentity.AddClaims(claimsCollection);
// MOCKING START
newIdentity.AddClaim(new Claim(ClaimTypes.Name, context.Ticket.Identity.Name));
// MOCKING END
// gera um novo ticket e valida o contexto fazendo gerar um novo token de acesso
// e retorná-lo na resposta da requisição
var newTicket = new AuthenticationTicket(newIdentity, context.Ticket.Properties);
context.Validated(newTicket);
}
public async Task<IHttpActionResult> SolicitarRedefinicaoSenha(
[FromBody] ContaSolicitarRedefinicaoSenhaModel viewModel)
{
var domain = new UsuarioDomain();
await domain.EnviarSolicitacaoRedefinicaoSenha(viewModel.Email);
return Ok();
}
public async Task<IHttpActionResult> RedefinirSenha([FromUri] long? id, [FromUri] string token,
[FromBody] ContaRedefinirSenhaViewModel viewModel)
{
var domain = new UsuarioDomain();
var identityResult = await domain.ResetPasswordAsync(id.Value, token, viewModel.Senha);
if (!identityResult.Succeeded)
return GetErrorResult(identityResult);
await domain.EnviarNotificacaoRedefinicaoSenha(id.Value);
return Ok();
}
