public async Task <UserModelItem> GetUserByIdAsync(long id)
{
var user = await _userRepository.FindByIdAsync(id);
var userModel = new UserModelItem();
if (user == null)
{
userModel.Errors.Add(Constants.Errors.UserNotExistsError);
return(userModel);
}
if (user.LockoutEnabled)
{
userModel.Errors.Add(Constants.Errors.UserLockError);
return(userModel);
}
userModel = user.MapToModel();
userModel.Role = await _userRepository.GetUserRolesAsync(user.Id);
if (userModel.Role == null)
{
userModel.Errors.Add(Constants.Errors.UserNotInAnyRoleError);
}
return(userModel);
}
public async Task <UserModelItem> CreateAsync(RegistrationModel createModel)
{
var resultModel = new UserModelItem();
var existingUser = await _userRepository.FindByEmailAsync(createModel.Email);
if (existingUser != null)
{
resultModel.Errors.Add(UserIsExist);
return(resultModel);
}
var user = _mapper.RegisterModelToEntity(createModel);
var result = await _userRepository.CreateAsync(user, createModel.Password);
if (!result)
{
resultModel.Errors.Add(UserCantBeRegistered);
return(resultModel);
}
result = await _userRepository.AddToRoleAsync(user, RoleUser);
if (!result)
{
resultModel.Errors.Add(UserCantBeAddedToRole);
}
resultModel.Id = user.Id;
return(resultModel);
}
public async Task <BaseModel> UpdateAsync(UserModelItem userModel)
{
var resultModel = new BaseModel();
if (userModel == null)
{
resultModel.Errors.Add(ModelIsNotValid);
}
var user = _mapper.ModelItemToEntity(userModel);
if (user == null)
{
resultModel.Errors.Add(UserIsExist);
return(resultModel);
}
if (!string.IsNullOrWhiteSpace(userModel.Pasword))
{
await _userRepository.ResetPasswordAsync(user, userModel.Pasword);
}
var result = await _userRepository.UpdateAsync(user);
if (!result)
{
resultModel.Errors.Add(FailedToUpdateUser);
}
return(resultModel);
}
public async Task <TokenModel> GenerateTokenModel(UserModelItem user)
{
if (user == null)
{
return(null);
}
var claimsAccess = new List <Claim>
{
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
new Claim(ClaimTypes.NameIdentifier, user.Id.ToString()),
new Claim(ClaimTypes.Role, user.Role),
new Claim(ClaimTypes.Name, user.UserName),
};
var claimsRefresh = new List <Claim>
{
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
new Claim(ClaimTypes.NameIdentifier, user.Id.ToString())
};
var accessToken = await GenerateToken(claimsAccess, 1);
var refreshToken = await GenerateToken(claimsRefresh, 60);
return(new TokenModel
{
AccessToken = new JwtSecurityTokenHandler().WriteToken(accessToken),
RefreshToken = new JwtSecurityTokenHandler().WriteToken(refreshToken)
});
}
public ApplicationUser ModelItemToEntity(UserModelItem userModel)
{
var user = new ApplicationUser();
user.Id = userModel.Id;
user.FirstName = userModel.FirstName;
user.LastName = userModel.LastName;
return(user);
}
private List <Claim> GenerateAccessClaims(UserModelItem model)
{
var claims = GenerateClaims(model.Id);
claims.Add(new Claim(ClaimTypes.Role, model.Role));
claims.Add(new Claim(ClaimTypes.Name, model.Email.ToString()));
return(claims);
}
public UserModelItem EntityToModelITem(ApplicationUser user)
{
var modelItem = new UserModelItem();
modelItem.Email = user.Email;
modelItem.Id = user.Id;
modelItem.FirstName = user.FirstName;
modelItem.LastName = user.LastName;
return(modelItem);
}
public async Task <IActionResult> EditProfileAsync(UserModelItem model)
{
var token = HttpContext.Request.Headers
.Where(x => x.Key == JwtConstants.RefreshToken)
.Select(x => x.Value).FirstOrDefault();
var adminId = _jwtHelper.GetIdFromToken(token);
var result = await _userService.EditAsync(model, adminId);
return(Ok(result));
}
public async Task <UserModelItem> FindByEmailAsync(string email)
{
var resultModel = new UserModelItem();
var user = await _userRepository.FindByEmailAsync(email);
if (user == null)
{
resultModel.Errors.Add(EmailConstants.ErrorConstants.UserNotFoundError);
}
return(user.Mapping());
}
public async Task <UserModelItem> GetByIdAsync(long id)
{
var response = new UserModelItem();
var applicationUser = await _userRepository.GetByIdAsync(id);
if (applicationUser == null)
{
response.Errors.Add(ErrorConstants.ImpossibleToFindUser);
return(response);
}
return(UserMapper.MapEntityToModel(applicationUser));
}
public async Task <IActionResult> SetPhotoAsync(UserModelItem model)
{
var token = HttpContext.Request.Headers
.Where(x => x.Key == JwtConstants.RefreshToken)
.Select(x => x.Value).FirstOrDefault();
var userId = _jwtHelper.GetIdFromToken(token);
model.Id = userId;
var result = await _userService.SetPhotoAsync(model);
return(Ok((UserModelItem)result));
}
private ICollection <Claim> GetRefreshClaims(UserModelItem userModel)
{
var claims = new List <Claim>();
var claim = new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString());
claims.Add(claim);
claim = new Claim(ClaimTypes.NameIdentifier, userModel.Id.ToString());
claims.Add(claim);
return(claims);
}
private ICollection <Claim> GetAccessClaims(UserModelItem userModel)
{
var claims = GetRefreshClaims(userModel);
var claim = new Claim(ClaimTypes.Email, userModel.Email);
claims.Add(claim);
claim = new Claim(ClaimTypes.Role, userModel.Role);
claims.Add(claim);
return(claims);
}
public async Task <BaseModel> SetPhotoAsync(UserModelItem model)
{
var user = await _userRepository.GetByIdAsync(model.Id);
user.Avatar = model.Avatar;
var result = await _userRepository.UpdateAsync(user);
if (!result)
{
model.Errors.Add(ErrorConstants.ImpossibleToSetPhoto);
}
return(model);
}
public static UserModelItem MapResponseModelToModelItem(UserResponseModel responseModel)
{
var modelItem = new UserModelItem()
{
Email = responseModel.User.Email,
FirstName = responseModel.User.FirstName,
LastName = responseModel.User.LastName,
Id = responseModel.User.Id,
EmailConfirmed = responseModel.User.EmailConfirmed
};
return(modelItem);
}
public async Task <UserModelItem> GetUserByIdAsync(long id)
{
var response = new UserModelItem();
var existingUser = await _userRepository.GetByIdAsync(id);
if (existingUser == null)
{
response.Errors.Add(ErrorConstants.ImpossibleToFindUser);
return(response);
}
var userModel = await MapUserAndGetRoleAsync(id);
return(userModel);
}
public static UserModelItem MapEntityToModel(ApplicationUser applicationUser)
{
var model = new UserModelItem()
{
Avatar = applicationUser.Avatar,
Email = applicationUser.Email,
Id = applicationUser.Id,
EmailConfirmed = applicationUser.EmailConfirmed,
FirstName = applicationUser.FirstName,
LastName = applicationUser.LastName
};
return(model);
}
public async Task <BaseModel> SetLockingStatus(string email, bool enabled)
{
var result = enabled
? await _userRepository.LockAsync(email)
: await _userRepository.UnlockAsync(email);
var userModel = new UserModelItem();
if (!result)
{
userModel.Errors.Add(Constants.Errors.UnlockUserError);
}
return(userModel);
}
public static UserModelItem MapToModel(this DataAccess.Entities.User entity)
{
var model = new UserModelItem();
model.Id = entity.Id;
model.FirstName = entity.FirstName;
model.LastName = entity.LastName;
model.Email = entity.Email;
model.IsLocked = entity.LockoutEnabled;
model.Avatar = string.IsNullOrWhiteSpace(entity.Avatar)
? Constants.Constants.Images.DefaultUserAvatar
: entity.Avatar;
return(model);
}
public async Task <BaseModel> EditAsync(UserModelItem model, long adminId)
{
var response = new BaseModel();
var existingUser = await _userRepository.GetByIdAsync(model.Id);
if (existingUser == null)
{
response.Errors.Add(ErrorConstants.ImpossibleToFindUser);
return(response);
}
var admin = await _userRepository.GetByIdAsync(adminId);
if (admin == null)
{
response.Errors.Add(ErrorConstants.ImpossibleToFindUser);
return(response);
}
var adminRole = await _userRepository.GetRoleAsync(admin);
var userRole = await _userRepository.GetRoleAsync(existingUser);
var updatedUser = new ApplicationUser();
if (adminRole == RoleConstants.Admin)
{
updatedUser = UserMapper.EditEntityByAdminRole(existingUser, model);
}
if (adminRole == userRole)
{
updatedUser = UserMapper.EditEntityByUserRole(existingUser, model);
}
var result = await _userRepository.UpdateAsync(updatedUser);
if (!result)
{
response.Errors.Add(ErrorConstants.ImpossibleToUpdateUser);
return(response);
}
if (!string.IsNullOrWhiteSpace(model.NewPassword) && adminRole == userRole)
{
result = await _userRepository.ChangePasswordAsync(updatedUser, model.OldPassword, model.NewPassword);
}
if (!result)
{
response.Errors.Add(ErrorConstants.ImpossibleToChangeUserPassword);
}
return(response);
}
public static ApplicationUser MapModelToEntity(UserModelItem model)
{
var applicationUser = new ApplicationUser()
{
Avatar = model.Avatar,
Email = model.Email,
Id = model.Id,
EmailConfirmed = model.EmailConfirmed,
FirstName = model.FirstName,
LastName = model.LastName,
UserName = $"{model.FirstName} {model.LastName}",
LockoutEnabled = true
};
return(applicationUser);
}
public async Task <BaseModel> IsLockedOutAsync(UserModelItem model)
{
var response = new BaseModel();
if (model == null)
{
response.Errors.Add(ErrorConstants.ModelIsNull);
return(response);
}
var user = UserMapper.MapModelToEntity(model);
var result = await _userRepository.IsLockedOutAsync(user);
if (result)
{
response.Errors.Add(ErrorConstants.UserIsLocked);
}
return(response);
}
public async Task <UserModelItem> LogInAsync(LogInModel model, string password)
{
var response = new UserModelItem();
if (model == null)
{
response.Errors.Add(ErrorConstants.ModelIsNull);
return(response);
}
var existingUser = await _userRepository.GetByEmailAsync(model.Email);
if (existingUser == null)
{
response.Errors.Add(ErrorConstants.IncorrectEmail);
return(response);
}
var result = await _userRepository.IsEmailConfirmedAsync(existingUser);
if (!result)
{
response.Errors.Add(ErrorConstants.DontConfirmEmail);
return(response);
}
var role = await _userRepository.GetRoleAsync(existingUser);
response = UserMapper.MapEntityToModel(existingUser);
response.Role = role;
result = await _userRepository.IsLockedOutAsync(existingUser);
if (result)
{
response.Errors.Add(ErrorConstants.UserIsLocked);
return(response);
}
result = await _userRepository.LogInAsync(existingUser, password);
if (!result)
{
response.Errors.Add(ErrorConstants.IncorrectPassword);
}
return(response);
}
public string GenerateToken(UserModelItem userModel, double expirationTime, string secretKey, bool isAccess)
{
var tokenHandler = new JwtSecurityTokenHandler();
var claims = isAccess
? GetAccessClaims(userModel)
: GetRefreshClaims(userModel);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(claims),
Expires = DateTime.UtcNow.AddMinutes(expirationTime),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(Encoding.ASCII.GetBytes(secretKey)),
SecurityAlgorithms.HmacSha256)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
return(tokenHandler.WriteToken(token));
}
public async Task <UserModelItem> FindByNameAsync(string userName)
{
var resultModel = new UserModelItem();
var user = await _userRepository.FindByNameAsync(userName);
if (user == null)
{
resultModel.Errors.Add(EmailConstants.ErrorConstants.UserNotFoundError);
}
/*var result = await CheckUserAsync(user, "pass");
* if (!result)
* {
* //resturn errors
* }*/
var role = await CheckRoleAsync(user.Id);
resultModel.Role = role.Name;
return(user.Mapping());
}
public async Task <BaseModel> DeleteUserAsync(long id)
{
var user = await _userRepository.FindByIdAsync(id);
var userModel = new UserModelItem();
if (user == null)
{
userModel.Errors.Add(Constants.Errors.UserNotExistsError);
return(userModel);
}
user.isRemoved = true;
var result = await _userRepository.UpdateAsync(user, null, null);
if (!result)
{
userModel.Errors.Add(Constants.Errors.DeleteUserError);
}
return(userModel);
}
public TokensModel RefreshOldTokens(UserModelItem model, string refreshToken)
{
var responce = new BaseModel();
var newRefreshToken = new JwtSecurityTokenHandler().ReadJwtToken(refreshToken);
if (newRefreshToken.ValidTo <= DateTime.Now)
{
return(GenerateTokens(model));
}
var accessToken = GenerateAccessToken(model);
if (accessToken == null)
{
responce.Errors.Add(ErrorConstants.AccessProblems);
return((TokensModel)responce);
}
return(new TokensModel()
{
AccessToken = accessToken,
RefreshToken = refreshToken
});
}
public async Task <UserModelItem> SignInAsync(SignInModel signInModel)
{
var user = await _userRepository.FindByEmailAsync(signInModel.Email);
var userModel = new UserModelItem();
if (user == null)
{
userModel.Errors.Add(Constants.Errors.UserNotExistsError);
return(userModel);
}
if (!user.EmailConfirmed)
{
userModel.Errors.Add(Constants.Errors.EmailConfirmationError);
return(userModel);
}
if (user.LockoutEnabled && user.isRemoved)
{
userModel.Errors.Add(Constants.Errors.UserLockError);
return(userModel);
}
userModel = user.MapToModel();
userModel.Role = await _userRepository.GetUserRolesAsync(user.Id);
var result = await _userRepository.CheckSignInAsync(signInModel.Email, signInModel.Password);
if (!result)
{
userModel.Errors.Add(Constants.Errors.WrongCredentialsError);
}
return(userModel);
}
public async Task <BaseModel> UpdateUserAsync(SignUpModel signUpModel)
{
var user = await _userRepository.FindByIdAsync(signUpModel.Id);
var userModel = new UserModelItem();
if (user == null)
{
userModel.Errors.Add(Constants.Errors.UserNotExistsError);
return(userModel);
}
user = signUpModel.MapToEntity(user);
var result = await _userRepository.UpdateAsync(user, signUpModel.Password, signUpModel.NewPassword);
if (!result)
{
userModel.Errors.Add(Constants.Errors.EditUserError);
}
return(userModel);
}
public TokensModel GenerateTokens(UserModelItem model)
{
var responce = new BaseModel();
var accessToken = GenerateAccessToken(model);
if (accessToken == null)
{
responce.Errors.Add(ErrorConstants.AccessProblems);
return((TokensModel)responce);
}
var refreshToken = GenerateRefreshToken(model);
if (refreshToken == null)
{
responce.Errors.Add(ErrorConstants.AccessProblems);
return((TokensModel)responce);
}
return(new TokensModel()
{
AccessToken = accessToken,
RefreshToken = refreshToken
});
}
