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));
}
