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