public async Task <IActionResult> ManageUserClaims([FromBody] UserClaimsDto model, CancellationToken ct) { var user = await _userManager.FindByIdAsync(model.UserId); // test ab#2 if (user == null) { return(NotFound()); } var existingClaims = await _userManager.GetClaimsAsync(user); var result = await _userManager.RemoveClaimsAsync(user, existingClaims); if (!result.Succeeded) { return(BadRequest()); // TDOD Bad request is not the best returned error } var claims = model.Claims.Select(c => new Claim(c.ClaimType, c.ClaimType)); result = await _userManager.AddClaimsAsync(user, claims); if (!result.Succeeded) { return(BadRequest()); // TDOD Bad request is not the best returned error } return(CreatedAtRoute("GetUserClaims", new { id = model.UserId }, model)); }
public async Task <IdentityResult> CreateUserClaimsAsync(UserClaimsDto claimsDto) { var userIdentityUserClaim = claimsDto.ToEntity(); var identityResult = await _identityRepository.CreateUserClaimsAsync(userIdentityUserClaim); return(HandleIdentityError(identityResult, _identityServiceResources.UserClaimsCreateFailed().Description, _identityServiceResources.IdentityErrorKey().Description, claimsDto)); }
public ActionResult UserLogin([Bind] Users user) { BillingSystemContext context = new BillingSystemContext(); Users userFromBase = context.Users.FirstOrDefault(u => u.UserName == user.UserName); if (userFromBase != null && SecurePasswordHasher.Verify(user.Password, userFromBase.Password)) { UsersBLL usersBLL = new UsersBLL(); UserClaimsDto userRoles = usersBLL.GetUserClaims(user.UserName); var userClaims = new List <Claim>() { new Claim(ClaimTypes.Name, userRoles.UserName), new Claim(ClaimTypes.Email, userRoles.Email) }; foreach (RoleMaster rm in userRoles.Roles) { userClaims.Add(new Claim(ClaimTypes.Role, rm.RollName)); } var grandmaIdentity = new ClaimsIdentity(userClaims, "User Identity"); var userPrincipal = new ClaimsPrincipal(new[] { grandmaIdentity }); HttpContext.SignInAsync(userPrincipal); return(RedirectToAction("Index", "Home")); } return(View(user)); }
public async Task <IActionResult> UserClaimsDelete(UserClaimsDto <TUserDtoKey> claim) { await _identityService.DeleteUserClaimsAsync(claim); return(Success(new { Id = claim.UserId })); }
public async Task <IActionResult> UserClaimsDelete(UserClaimsDto claim) { await _identityService.DeleteUserClaimsAsync(claim); SuccessNotification(_localizer["SuccessDeleteUserClaims"], _localizer["SuccessTitle"]); return(RedirectToAction(nameof(UserClaims), new { Id = claim.UserId })); }
public async Task <IActionResult> UserClaims(UserClaimsDto <TUserDtoKey> claim) { if (!ModelState.IsValid) { return(Success(claim)); } await _identityService.CreateUserClaimsAsync(claim); return(Success(new { Id = claim.UserId })); }
public async Task <IActionResult> UserClaims(UserClaimsDto claim) { if (!ModelState.IsValid) { return(View(claim)); } await _identityService.CreateUserClaimsAsync(claim); SuccessNotification(string.Format(_localizer["SuccessCreateUserClaims"], claim.ClaimType, claim.ClaimValue), _localizer["SuccessTitle"]); return(RedirectToAction(nameof(UserClaims), new { Id = claim.UserId })); }
public string BuildToken(UserClaimsDto userClaimsDto, DateTime expires) { Claim[] claims = new Claim[] { new Claim(ClaimTypes.NameIdentifier, userClaimsDto.UserId.ToString()), new Claim(ClaimTypes.Name, userClaimsDto.UserName), }; var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_configuration["Jwt:Key"])); var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256); var token = new JwtSecurityToken(_configuration["Jwt:Issuer"], _configuration["Jwt:Issuer"], claims, expires: expires, signingCredentials: creds); return(new JwtSecurityTokenHandler().WriteToken(token)); }
public UserClaimsDto GetUserClaims(string username) { UserClaimsDto userdto = new UserClaimsDto(); BillingSystemContext context = new BillingSystemContext(); Users user = context.Users.FirstOrDefault(u => u.UserName == username); userdto.UserName = user.UserName; userdto.Email = user.Email; userdto.Roles = context.RoleMasters .Where(r => context.UserRoleMappings .Any(urm => urm.RoleID == r.IDNumber && urm.UserID == user.IDNumber)).ToList(); return(userdto); }
public async Task <IActionResult> Register([FromBody] AddUserDto userDto) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } UserClaimsDto user = await _service.Register(userDto); if (user == null) { return(BadRequest(ModelState)); } await _service.SendVerificationLink(user.UserId); return(Ok(userDto.Username)); }
public async Task <IActionResult> GetUserClaims([FromRoute] string id, CancellationToken ct) { var user = await _userManager.FindByIdAsync(id); if (user == null) { return(NotFound()); } var existingClaims = await _userManager.GetClaimsAsync(user); var claims = existingClaims.Select(c => new UserClaimDto() { ClaimType = c.Type, IsSelected = true }); var result = new UserClaimsDto() { UserId = id, Claims = claims.ToList() }; return(Ok(result)); }
public async Task <IActionResult> Login([FromBody] AddUserDto userDto) { UserClaimsDto user = await _service.Login(userDto); if (user == null) { return(Unauthorized()); } if (!user.Verified) { return(Forbid()); } string tokenString = _tokenService.BuildToken(user, DateTime.Now.AddDays(1)); var userViewModel = new UserViewModel { Username = user.UserName, Token = tokenString }; return(Ok(userViewModel)); }
public async Task <IActionResult> GetUserClaims([FromRoute] string userId, CancellationToken ct) { var user = await _userManager.FindByIdAsync(userId); if (user == null) { return(NotFound()); } var existingUserClaims = await _userManager.GetClaimsAsync(user); var claimsDto = new List <UserClaimDto>(existingUserClaims.Select(claim => new UserClaimDto() { ClaimType = claim.Type, IsSelected = string.Equals(claim.Value, "true", StringComparison.OrdinalIgnoreCase) ? true : false })); foreach (Claim claim in ClaimsStore.AllClaims) { if (!existingUserClaims.Any(c => string.Equals(c.Type, claim.Type, StringComparison.OrdinalIgnoreCase))) { claimsDto.Add(new UserClaimDto() { ClaimType = claim.Type, IsSelected = string.Equals(claim.Value, "true", StringComparison.OrdinalIgnoreCase) ? true : false }); } } var result = new UserClaimsDto() { Claims = claimsDto.ToList() }; return(Ok(result)); }
public async Task <int> DeleteUserClaimsAsync(UserClaimsDto claim) { return(await _identityRepository.DeleteUserClaimsAsync(claim.UserId, claim.ClaimId)); }
private MailMessage CreateNotificationMessage(UserClaimsDto user, PageDto pageDto) { return(new MailMessage(_config["Gmail:email"], user.Email, "PageChecker Notification", $"Page named:{pageDto.Name}, URL: {pageDto.Url} has changed.")); }
public async Task <int> DeleteUserClaimsAsync(UserClaimsDto <TUserDtoKey> claim) { return(await _identityRepository.DeleteUserClaimsAsync(claim.UserId.ToString(), claim.ClaimId)); }
public async Task <IActionResult> ManageUserClaims([FromRoute] string userId, [FromBody] UserClaimsDto model, CancellationToken ct) { var user = await _userManager.FindByIdAsync(userId); if (user == null) { return(NotFound()); } var existingUserClaims = await _userManager.GetClaimsAsync(user); var result = await _userManager.RemoveClaimsAsync(user, existingUserClaims); if (!result.Succeeded) { return(BadRequest()); // TODO Bad request is not the best returned error } var claims = model.Claims.Select(c => new Claim(c.ClaimType, c.IsSelected ? "true" : "false")).ToList(); //var claims = model.Claims.Select(c => new Claim(c.ClaimType, c.ClaimValue)).ToList(); foreach (Claim claim in ClaimsStore.AllClaims) { if (!claims.Any(c => string.Equals(c.Type, claim.Type, StringComparison.OrdinalIgnoreCase))) { claims.Add(new Claim(claim.Type, claim.Value)); } } result = await _userManager.AddClaimsAsync(user, claims); if (!result.Succeeded) { return(BadRequest()); // TODO Bad request is not the best returned error } return(CreatedAtRoute("GetUserClaims", new { userId = userId }, model)); }
public static UserIdentityUserClaim ToEntity(this UserClaimsDto claim) { return(Mapper.Map <UserIdentityUserClaim>(claim)); }
public static IdentityUserClaim <string> ToEntity(this UserClaimsDto claim) { return(Mapper.Map <IdentityUserClaim <string> >(claim)); }