private async Task <object> GenerateJwtToken(string email, UserClaimDto user)
{
var claims = new List <Claim>
{
new Claim(JwtRegisteredClaimNames.Sub, email),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
new Claim(ClaimTypes.NameIdentifier, user.Id),
new Claim("school_id", user.SchoolId.ToString()),
new Claim("PERMISSION", "1"),
new Claim("UserID", user.Id),
new Claim("year_id", user.year_Id.ToString()),
new Claim("Timezone", user.TimeZone)
};
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_configuration["JwtKey"]));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var expires = DateTime.Now.AddDays(Convert.ToDouble(_configuration["JwtExpireDays"]));
var token = new JwtSecurityToken(
_configuration["JwtIssuer"],
_configuration["JwtIssuer"],
claims,
expires: expires,
signingCredentials: creds
);
return(new JwtSecurityTokenHandler().WriteToken(token));
}
public async Task <IActionResult> CreateClaim(UserClaimDto model)
{
if (!ModelState.IsValid || model.UserId == Guid.Empty)
{
return(BadRequest(ModelState));
}
var item = Mapper.Map <UserClaimDto, UserClaim>(model);
var validation = ValidationCatalog.Validate(item);
if (validation.IsValid)
{
await _administrationManager.Create(model.UserId, new List <UserClaim> {
item
});
return(new JsonResult(true));
}
// Add the errors
foreach (var error in validation.Errors)
{
foreach (var allErrorMessage in error.AllErrorMessages())
{
ModelState.AddModelError("Error(s): ", allErrorMessage);
}
}
return(BadRequest(ModelState));
}
public Result <bool> UpdateUser([FromBody] UserDto userDto)
{
try
{
if (CanUpdateUserValidation(userDto, out var failResult))
{
return(failResult);
}
var roleName = "";
if (userDto.Role != null)
{
var roleNameResult = Executor.GetQuery <GetRoleByIdQuery>().Process(q => q.Execute(userDto.Role.Id));
if (roleNameResult.IsFailure)
{
return(Result <bool> .Fail(false, "Выбранная роль не найдена"));
}
roleName = roleNameResult.Value.Name;
}
Executor.CommandChain()
.AddCommand <UpdateUserCommand>(c => c.Execute(userDto))
.AddCommand <UpdateUserClaimCommand>(c => c.Execute(UserClaimDto.UserNameClaim(userDto)))
.AddCommand <UpdateUserClaimCommand>(c => c.Execute(UserClaimDto.UserRoleClaim(roleName, userDto.Id)))
.AddCommand <UpdateUserClaimCommand>(c => c.Execute(UserClaimDto.UserGenderClaim(userDto)))
.ExecuteAllWithTransaction();
return(Result <bool> .Ok(true));
}
catch (Exception exception)
{
return(Result <bool> .Fail(false, $"{exception.Message}, {exception.StackTrace}"));
}
}
public void Execute(UserClaimDto userClaimDto)
{
var userClaimsRepository = Uow.GetRepository <UserClaim>();
userClaimsRepository.Create(userClaimDto.ToUserClaim);
Uow.SaveChanges();
}
public async Task <IActionResult> DeleteClaim(UserClaimDto model)
{
if (!ModelState.IsValid || model.UserId == Guid.Empty)
{
return(BadRequest(ModelState));
}
var item = Mapper.Map <UserClaimDto, UserClaim>(model);
var result = await _administrationManager.Delete(item);
return(new JsonResult(result));
}
public void Execute(UserClaimDto userClaimDto)
{
var userClaimsRepository = Uow.GetRepository <UserClaim>();
var claim = userClaimsRepository
.AsQueryable()
.FirstOrDefault(c => c.UserId == userClaimDto.UserId && c.ClaimType == userClaimDto.ClaimName && c.IsDeleted == false);
if (claim == null)
{
claim = userClaimDto.ToUserClaim;
userClaimsRepository.Create(claim);
}
else
{
userClaimDto.UpdateUserClaim(claim);
userClaimsRepository.Update(claim);
}
Uow.SaveChanges();
}
public async Task <ActionResult <UserClaimDto> > PostUserClaim(UserClaimDto userClaim)
{
if (!ModelState.IsValid)
{
ModelState.AddModelError("InvalidModel", "Properties not in valid state");
return(userClaim);
}
await _userClaimRepository.AddAsync(_mapper.Map <UserClaim>(userClaim));
try
{
await _unitOfworkUserClaim.CommitAsync(_cancellationToken);;
return(CreatedAtAction("GetUserClaim", new { id = userClaim.Id }, userClaim));
}
catch (Exception ex)
{
var errMsg = ex.Message;
throw;
}
}
public async Task <IActionResult> Login([FromBody] LoginDto model, [FromServices] RedisService redisService, int?school_id = 0)
{
//Checking if user is activated
var result = await _signInManager.PasswordSignInAsync(model.Email, model.Password, false, false);
if (result.Succeeded)
{
if (school_id == 0)
{
var appUser = _userManager.Users.SingleOrDefault(r => r.Email == model.Email);
if (appUser.role_id == -1)
{
return(Json("admin"));
}
var checkUser = _context.schoo_Users.ToList().Where(o => o.user_Id == appUser.Id).Select(o => o.school_Id).ToList();
if (checkUser.Count > 1)
{
var list = _context.schools.Where(o => checkUser.Contains(o.id)).ToList();
return(Json(new
{
list
}));
}
else if (checkUser.Count == 1)
{
var data = _context.school_Years.FirstOrDefault(o => checkUser.Contains(o.school_ID));
if (data == null)
{
return(Unauthorized());
}
// User.AddUpdateClaim("key1", "value1");
UserClaimDto claimDto = new UserClaimDto()
{
Id = appUser.Id,
Email = appUser.Email,
TimeZone = appUser.Timezone,
SchoolId = checkUser.FirstOrDefault(),
year_Id = data.id
};
return(new JsonResult(new
{
token = await GenerateJwtToken(model.Email, claimDto)
}));
}
else
{
return(new JsonResult("Unauthorized"
));
}
}
else
{
var appUser = _userManager.Users.SingleOrDefault(r => r.Email == model.Email);
var checkUser = _context.schoo_Users.Where(o => o.user_Id == appUser.Id && o.school_Id == school_id).Select(o => o.school_Id).ToList();
if (checkUser.Count > 1)
{
var list = _context.schools.Where(o => checkUser.Contains(o.id)).ToList();
return(Json(new
{
list
}));
}
else if (checkUser.Count == 1)
{
var year_Id = _context.school_Years.FirstOrDefault();
UserClaimDto claimDto = new UserClaimDto()
{
Id = appUser.Id,
Email = appUser.Email,
TimeZone = appUser.Timezone,
SchoolId = checkUser.FirstOrDefault(),
year_Id = year_Id.id
};
return(new JsonResult(new
{
token = await GenerateJwtToken(model.Email, claimDto)
}));
}
else
{
return(new JsonResult("Unauthorized"
));
}
}
}
return(new JsonResult("Unauthorized"
));
}
public AutoMapperProfiles()
{
CreateMap <Role, RoleDto>();
CreateMap <ClaimForSaveDto, Claim>();
CreateMap <Claim, ClaimDto>();
CreateMap <RegisterDto, User>();
CreateMap <User, UserForListDto>();
CreateMap <UserForUpdateDto, User>()
.AfterMap((src, dest) =>
{
// remove roles
var rolesToRemove = dest.UserRoles.Where(x => !src.RoleIds.Contains(x.RoleId)).ToList();
foreach (var roleToRemove in rolesToRemove)
{
dest.UserRoles.Remove(roleToRemove);
}
// add roles
var rolesToAdd = src.RoleIds.Where(id => !dest.UserRoles.Any(x => x.RoleId == id)).ToList()
.Select(id => new UserRole {
RoleId = id
});
foreach (var roleToAdd in rolesToAdd)
{
dest.UserRoles.Add(roleToAdd);
}
// remove claims
var claimsToRemove = dest.UserClaims
.Where(x => !src.Claims.Select(x => x.ClaimId).Contains(x.ClaimId)).ToList();
foreach (var claimToRemove in claimsToRemove)
{
dest.UserClaims.Remove(claimToRemove);
}
// update claims
foreach (var claim in dest.UserClaims.Where(x => src.Claims.Select(x => x.ClaimId).Contains(x.ClaimId)))
{
var claimFromRequest = src.Claims.FirstOrDefault(x => x.ClaimId == claim.ClaimId);
if (claimFromRequest != null)
{
claim.ClaimValue = claimFromRequest.ClaimValue;
}
}
// add claims
var claimsToAdd = src.Claims.Where(c => !dest.UserClaims.Any(x => x.ClaimId == c.ClaimId)).ToList()
.Select(c => new UserClaim {
ClaimId = c.ClaimId, ClaimValue = c.ClaimValue
});
foreach (var claimToAdd in claimsToAdd)
{
dest.UserClaims.Add(claimToAdd);
}
});
CreateMap <User, UserForDetailedDto>()
.ForMember(x => x.Roles, opt =>
opt.MapFrom(x => x.UserRoles.Select(x => new RoleDto {
Id = x.Role.Id, Name = x.Role.Name
})))
.AfterMap((src, dest) =>
{
var claimsToAdd = new List <UserClaimDto>();
if (src.UserClaims.Count > 0)
{
foreach (var claim in src.UserClaims)
{
var claimDto = new UserClaimDto
{
Id = claim.Claim.Id,
Claim = claim.Claim.Name,
ClaimValue = claim.ClaimValue
};
claimsToAdd.Add(claimDto);
}
dest.Claims.AddRange(claimsToAdd);
}
});
}
