public async Task <IActionResult> Login(LoginDTO model) { if (!IsValidApiRequest()) { return(ApiBadRequest("Invalid Headers!")); } var user = await UserManager.FindByEmailAsync(model.Email); if (user == null) { return(ApiBadRequest("User does not exist.")); } if (await UserManager.CheckPasswordAsync(user, model.Password)) { return(Ok(new { token = _jwt.GenerateSecurityToken(new JwtUser() { Email = user.Email, roleId = user.Department }) })); } return(ApiBadRequest("Bad password")); }
public string Get() { var jwt = new JwtService(_config); var token = jwt.GenerateSecurityToken("*****@*****.**"); return(token); }
public string GetRandomToken(string userName) { var jwt = new JwtService(_config); var token = jwt.GenerateSecurityToken(userName); return(token); }
public IActionResult Post([FromBody] Login login) { try { var userGot = _userRepository.GetUserByEmail(login.email); if (userGot != null) { if (_userRepository.CheckMatch(userGot.passhash_user, login.password)) { var jwt = new JwtService(_config); var token = jwt.GenerateSecurityToken(userGot); return(Ok(token)); } else { return(Content("Invalid Password")); } } else { return(Content("User not found!")); } } catch (Exception) { return(new StatusCodeResult(500)); } }
public string GetRandomToken() { var jwt = new JwtService(_config); var token = jwt.GenerateSecurityToken("*****@*****.**"); return(token); }
[HttpGet(nameof(FetchToken))] // Get TOKEN - MARK VANZ public async Task <IActionResult> FetchToken(string email) { var jwt = new JwtService(_config); var token = jwt.GenerateSecurityToken(email); return(Ok(token)); // Return Token }
public string GetToken() { var jwtService = new JwtService(_config); var token = jwtService.GenerateSecurityToken("*****@*****.**"); return(token); }
public async Task <IActionResult> CheckCustomerToken() { var customer = await _workContext.GetCurrentCustomerAsync(); if (customer == null) { return(Ok(new { success = false, message = await _localizationService.GetResourceAsync("Customer.Not.Found") })); } var jwt = new JwtService(_config); var token = jwt.GenerateSecurityToken(customer.Email, customer.Id); var shippingAddress = customer.ShippingAddressId.HasValue ? await _addressService.GetAddressByIdAsync(customer.ShippingAddressId.Value) : null; var firstName = await _genericAttributeService.GetAttributeAsync <string>(customer, NopCustomerDefaults.FirstNameAttribute); var lastName = await _genericAttributeService.GetAttributeAsync <string>(customer, NopCustomerDefaults.LastNameAttribute); return(Ok(new { success = true, token, pushToken = customer.PushToken, shippingAddress, firstName, lastName, RemindMeNotification = customer.RemindMeNotification, RateReminderNotification = customer.RateReminderNotification, OrderStatusNotification = customer.OrderStatusNotification, avatar = await _pictureService.GetPictureUrlAsync(await _genericAttributeService.GetAttributeAsync <int>(customer, NopCustomerDefaults.AvatarPictureIdAttribute), _mediaSettings.AvatarPictureSize, true) })); }
public static string GetToken(IConfiguration config, string email) { var jwt = new JwtService(config); var token = jwt.GenerateSecurityToken(email); return(token); }
public async Task <ActionResult <string> > Login() { var jwt = new JwtService(_config); var token = jwt.GenerateSecurityToken("*****@*****.**"); return(token); }
public async Task <ActionResult> GetRandomToken(string username, string password) { var person = await _personRepository.GetPersonAsync(username); if (person == null || string.IsNullOrEmpty(person.HashedPassword)) { return(Ok()); } if (person.EmailConfirmed.ToLower() == "false") { return(Ok("Confirm Email Address")); } if (person.ChangePassword.ToLower() == "true") { // 60 min time limit from when the email was sent return(Ok("User must change password")); } if (person.HashedPassword.Equals(password)) { var jwt = new JwtService(_config); var token = jwt.GenerateSecurityToken(username); return(Ok(token)); } return(Ok()); }
public IActionResult GetRandomToken() { var jwt = new JwtService(_config); var token = jwt.GenerateSecurityToken("*****@*****.**"); return(Ok(new { Token = token })); }
public IActionResult Login(LoginVM loginVM) { Account account = myContext.Accounts.Where(acc => acc.Employee.Email == loginVM.Email).FirstOrDefault(); try { bool isValidPassword = BCrypt.Net.BCrypt.Verify(loginVM.Password, account.Password); if (isValidPassword) { var result = accountRepository.Login(loginVM); if (result == null) { return(NotFound(new { status = HttpStatusCode.NotFound, result, message = "Login Unsuccessful", Token = "" })); } var jwt = new JwtService(configuration); var token = jwt.GenerateSecurityToken(result); return(Ok(new { status = HttpStatusCode.OK, message = "Login Success", result, Token = token })); } return(BadRequest(new { status = HttpStatusCode.BadRequest, result = "", message = "Login Unsuccessful" })); } catch (Exception) { return(BadRequest(new { status = HttpStatusCode.BadRequest, result = "", message = "Login Unsuccessful" })); } }
public User Register([FromBody] User model) { try { // create user model.Password = HashPassword(model.Password); model.JWT = _authService.GenerateSecurityToken(model); _context.Add(model); _context.SaveChanges(); model.Password = null; return(model); } catch (Exception) { return(null); } }
public ActionResult GetToken([FromHeader] string Authorization = null) { var jwt = new JwtService(_config); var token = jwt.GenerateSecurityToken(Authorization); Response.Headers.Add("Authorization", token); return(Ok()); }
public ActionResult <string> Login([FromBody] LoginDTO value) { EmployeeDetails obj = _employeeService.ValidateLoginCredentials(value.orcId, value.password); if (obj != null) { return(_jwtService.GenerateSecurityToken(obj.AccessToken, obj.OrcId)); } return(BadRequest("Invalid Username or Password")); }
private string GetRandomToken(string email) { if (string.IsNullOrEmpty(email)) { throw new ArgumentNullException(); } var token = _jwtService.GenerateSecurityToken(email); return(token); }
public void GenerateSecurityToken_Test() { // Arrange var rand = new Random(); var emailId = rand.Next(); var newEmail = $"randomemail{emailId}@google.com"; // Act var token = _jwtService.GenerateSecurityToken(newEmail); // Assert Assert.True(token != null); }
/// <summary> /// Generate Token according to User information /// </summary> /// <param name="u">User Object, to user ID,EMail,Status </param> /// <returns>New Token</returns> private JWT_Bearer GenToken(SM.User u) { JWT_Bearer JWTB = new JWT_Bearer(); if (u != null) { JwtService jwt = new JwtService(_config); JWTB.id = u.Id; JWTB.ExpirationDateTime = DateTime.Now.AddMinutes(double.Parse(_config.GetSection("JwtConfig").GetSection("expirationInMinutes").Value)); JWTB.BearerJWT = jwt.GenerateSecurityToken(u.Email, u.Status.ToString(), u.Id. ToString());; } return(JWTB); }
public ActionResult GetRandomToken([FromBody] LoginRequest login) { var user = GetUserFromEmail(login.Email); if (user == null || !user.CheckPassword(login.Password)) { return(Unauthorized()); } var jwt = new JwtService(_config); var token = jwt.GenerateSecurityToken(user); return(new JsonResult(new { token })); }
public void GenerateSecurityToken_InputEmailUsername_EqualsClaim() { var jwt = new JwtService(Configuration); var token = jwt.GenerateSecurityToken(new User { Email = "*****@*****.**", Username = "******" }); var handler = new JwtSecurityTokenHandler(); var jsonToken = handler.ReadToken(token); var tokenS = handler.ReadToken(token) as JwtSecurityToken; Assert.Equal("*****@*****.**", tokenS.Claims.First(claim => claim.Type == "email").Value); Assert.Equal("foo", tokenS.Claims.First(claim => claim.Type == "unique_name").Value); }
public ActionResult <string> GetRandomToken([FromBody] UserDTO content) { content.Password = SecurityUtils.HashFunction(content.Password); if (_context.User.Any(u => u.Email == content.Email && u.Password == content.Password)) { var jwt = new JwtService(_config); var token = jwt.GenerateSecurityToken(content.Email); return(token); } return(StatusCode(401)); }
public async Task <IActionResult> Signup(AuthDTO model) { if (!IsValidApiRequest()) { return(ApiBadRequest("Invalid headers!")); } var user = new UserDTO { UserName = model.Username ?? model.Email, Email = model.Email }; foreach (var validator in _userManager.PasswordValidators) { var res = await validator.ValidateAsync(_userManager, null, model.Password); if (!res.Succeeded) { return(ApiBadRequest(res.Errors.First().Description)); } } var result = await _userManager.CreateAsync(user, model.Password); if (!result.Succeeded) { return(ApiBadRequest(result.Errors.First().Description)); } return(Created("", new { token = _jwt.GenerateSecurityToken(new User() { Username = user.UserName, Email = user.Email }) })); }
public IActionResult Login(LoginDataIn data) { (RetornoDataOut retorno, LoginOut loginOut) = _userData.Login(data); if (retorno.Result == Retorno.Error) { return(StatusCode(200, retorno)); } RetornoDataOut DataRetorno = new RetornoDataOut { Data = new { Token = _jwtServices.GenerateSecurityToken(loginOut.Email, loginOut.Username, loginOut.Id.ToString()) } }; return(StatusCode(200, DataRetorno)); }
public static void LoginTokenAutoridad(IConfiguration _config, Models.Autoridad autoridad, ResultResponse <LoginAutoridadResponse> response) { var jwt = new JwtService(_config); var token = jwt.GenerateSecurityToken(autoridad.Email); LoginAutoridadResponse loginResponse = new LoginAutoridadResponse { Token = token, Id = autoridad.Id, Name = autoridad.Name, LastName = autoridad.Lastname }; response.Data = loginResponse; response.Error = false; response.Message = "Inicio de Sesion Satisfactorio"; }
public static void LoginTokenCustomer(IConfiguration _config, Models.Customer customer, ResultResponse <LoginCustomerResponse> response) { var jwt = new JwtService(_config); var token = jwt.GenerateSecurityToken(customer.Email); LoginCustomerResponse loginResponse = new LoginCustomerResponse { Token = token, CustomerId = customer.CustomerId, Names = customer.Names, LastNames = customer.LastNames }; response.Data = loginResponse; response.Error = false; response.Message = "Inicio de sesión satisfactorio"; }
public async Task <ActionResult <User> > LoginPostUser(UserLoginInfo user) { var tUser = _context.User .Where(x => x.Email == user.UsernameEmail || x.Username == user.UsernameEmail) .Where(x => x.Token == BCrypt.Net.BCrypt.HashPassword(user.Password, _configuration["salt"])).FirstOrDefault(); if (tUser == null) { return(NotFound(tUser)); } var Jwt = new JwtService(_configuration); var token = Jwt.GenerateSecurityToken(tUser.Email); return(CreatedAtAction("Login", new { Token = token }, "new token")); }
public IActionResult GetUtilisateurs(string Login, string MotDePasse) { try { Utilisateur utilisateurATrouver = _context.Utilisateurs.Where(c => (c.Login.Equals(Login) && c.MotDePasse.Equals(Utilitaire.HashPassword(MotDePasse)))).FirstOrDefault(); if (utilisateurATrouver == null) { return(NoContent()); } string type; switch (utilisateurATrouver.GetType().ToString()) { case "GestionClientAPI.Models.Client": type = "Client"; break; case "GestionClientAPI.Models.Gestionnaire": type = "Gestionnaire"; break; case "GestionClientAPI.Models.Administrateur": type = "Administrateur"; break; default: type = "Utilisateur"; break; } var jwt = new JwtService(_config); var token = jwt.GenerateSecurityToken(utilisateurATrouver.Login); ResultConnexion resultConnexion = new ResultConnexion() { Token = token, Type = type, Id = utilisateurATrouver.UtilisateurId }; return(Ok(resultConnexion)); } catch (Exception) { } return(BadRequest()); }