/// <summary>
/// Change user password
/// </summary>
/// <param name="current"></param>
/// <param name="next"></param>
/// <returns></returns>
public virtual async Task <ResultModel> ChangeUserPasswordAsync(string current, string next)
{
var resultModel = new ResultModel();
var currentUser = (await GetCurrentUserAsync()).Result;
if (currentUser == null)
{
resultModel.Errors.Add(new ErrorModel {
Key = string.Empty, Message = "User not found"
});
return(resultModel);
}
var result = await UserManager.ChangePasswordAsync(currentUser, current, next);
if (result.Succeeded)
{
resultModel.IsSuccess = true;
IdentityEvents.Users.UserPasswordChange(new UserChangePasswordEventArgs
{
Email = currentUser.Email,
UserName = currentUser.UserName,
UserId = currentUser.Id,
Password = next
});
return(resultModel);
}
resultModel.AppendIdentityErrors(result.Errors);
return(resultModel);
}
/// <summary>
/// Remove user photo
/// </summary>
/// <returns></returns>
public virtual async Task <ResultModel> RemoveUserPhotoAsync()
{
var resultModel = new ResultModel();
var currentUser = (await GetCurrentUserAsync()).Result;
if (currentUser == null)
{
resultModel.IsSuccess = false;
resultModel.Errors.Add(new ErrorModel {
Key = string.Empty, Message = "User not found"
});
return(resultModel);
}
currentUser.UserPhoto = null;
var result = await UserManager.UpdateAsync(currentUser);
if (result.Succeeded)
{
resultModel.IsSuccess = true;
return(resultModel);
}
resultModel.IsSuccess = false;
resultModel.AppendIdentityErrors(result.Errors);
return(resultModel);
}
/// <inheritdoc />
/// <summary>
/// Add roles to user
/// </summary>
/// <param name="user"></param>
/// <param name="roles"></param>
/// <returns></returns>
public virtual async Task <ResultModel> AddToRolesAsync(GearUser user, ICollection <string> roles)
{
var result = new ResultModel();
var defaultRoles = new Collection <string> {
GlobalResources.Roles.USER, GlobalResources.Roles.ANONIMOUS_USER
};
if (user == null || roles == null)
{
result.Errors.Add(new ErrorModel(string.Empty, "Bad parameters"));
return(result);
}
var exist = await UserManager.FindByEmailAsync(user.Email);
if (exist == null)
{
result.Errors.Add(new ErrorModel(string.Empty, "User not found"));
return(result);
}
foreach (var defaultRole in defaultRoles)
{
if (roles.Contains(defaultRole))
{
continue;
}
roles.Add(defaultRole);
}
var existentRoles = await UserManager.GetRolesAsync(exist);
var newRoles = roles.Where(x => !existentRoles.Contains(x)).ToList();
var serviceResult = await UserManager.AddToRolesAsync(exist, newRoles);
if (serviceResult.Succeeded)
{
result.IsSuccess = true;
}
else
{
result.AppendIdentityErrors(serviceResult.Errors);
}
return(result);
}
public virtual async Task <JsonResult> UploadUserPhoto([Required] IFormFile file)
{
var resultModel = new ResultModel();
if (file == null || file.Length == 0)
{
resultModel.IsSuccess = false;
resultModel.Errors.Add(new ErrorModel {
Key = string.Empty, Message = "Image not found"
});
return(Json(resultModel));
}
var currentUser = (await _userManager.GetCurrentUserAsync()).Result;
if (currentUser == null)
{
resultModel.IsSuccess = false;
resultModel.Errors.Add(new ErrorModel {
Key = string.Empty, Message = "User not found"
});
return(Json(resultModel));
}
using (var memoryStream = new MemoryStream())
{
await file.CopyToAsync(memoryStream);
currentUser.UserPhoto = memoryStream.ToArray();
}
var result = await _userManager.UserManager.UpdateAsync(currentUser);
if (result.Succeeded)
{
resultModel.IsSuccess = true;
return(Json(resultModel));
}
resultModel.IsSuccess = false;
resultModel.AppendIdentityErrors(result.Errors);
return(Json(resultModel));
}
/// <summary>
/// Logout user
/// </summary>
/// <param name="userId"></param>
/// <returns></returns>
public virtual async Task <ResultModel> SignOutUserOnAllDevicesAsync(Guid?userId)
{
if (userId == null)
{
return(new InvalidParametersResultModel());
}
var user = await _userManager.UserManager.FindByIdAsync(userId.ToString());
var result = await _userManager.UserManager.UpdateSecurityStampAsync(user);
if (result.Succeeded)
{
return(new SuccessResultModel <object>().ToBase());
}
var errResponse = new ResultModel();
errResponse.AppendIdentityErrors(result.Errors);
return(errResponse);
}
/// <summary>
/// Remove claims
/// </summary>
/// <param name="user"></param>
/// <returns></returns>
public async Task <ResultModel> ClearUserClaimsAsync(GearUser user)
{
var response = new ResultModel();
if (user == null)
{
return(response);
}
var claims = await _userManager.UserManager.GetClaimsAsync(user);
var identityResult = await _userManager.UserManager.RemoveClaimsAsync(user, claims);
if (identityResult.Succeeded)
{
response.IsSuccess = identityResult.Succeeded;
return(response);
}
response.AppendIdentityErrors(identityResult.Errors);
return(response);
}
/// <summary>
/// Update base user profile
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public virtual async Task <ResultModel> UpdateBaseUserProfileAsync(UserProfileEditViewModel model)
{
var modelState = ModelValidator.IsValid(model);
if (!modelState.IsSuccess)
{
return(modelState);
}
var resultModel = new ResultModel();
var currentUserRequest = await _userManager.GetCurrentUserAsync();
if (!currentUserRequest.IsSuccess)
{
resultModel.Errors.Add(new ErrorModel(string.Empty, "User not found!"));
return(resultModel);
}
var currentUser = currentUserRequest.Result;
var isUsed = await _userManager.UserManager
.Users.AnyAsync(x => !x.Id.Equals(currentUser.Id) &&
!x.Email.IsNullOrEmpty() &&
x.Email.ToLowerInvariant()
.Equals(model.Email.ToLowerInvariant()));
if (isUsed)
{
resultModel.AddError("Email is used by another user");
return(resultModel);
}
currentUser.FirstName = model.FirstName;
currentUser.LastName = model.LastName;
currentUser.Birthday = model.Birthday;
currentUser.AboutMe = model.AboutMe;
currentUser.PhoneNumber = model.PhoneNumber;
currentUser.EmailConfirmed = currentUser.EmailConfirmed && model.Email.Equals(currentUser.Email);
currentUser.Email = model.Email;
if (!currentUser.EmailConfirmed)
{
EmailEvents.Events.TriggerSendConfirmEmail(new SendConfirmEmailEventArgs
{
HttpContext = _accessor.HttpContext,
Email = model.Email
});
}
var result = await _userManager.UserManager.UpdateAsync(currentUser);
if (result.Succeeded)
{
resultModel.IsSuccess = true;
return(resultModel);
}
resultModel.AppendIdentityErrors(result.Errors);
return(resultModel);
}
public async Task <JsonResult> VerifyAndCompletePhoneRegistration(TokenVerificationModel tokenVerification)
{
var verificationRequest = HttpContext.Session.Get <PhoneVerificationRequestModel>("phone_verification_request");
if (verificationRequest == null)
{
var response = new ResultModel();
response.Errors.Add(new ErrorModel(string.Empty, "A request to send the token to the phone was not made"));
response.Errors.Add(new ErrorModel(string.Empty, $"To start, call: {nameof(StartRegisterBySendingVerificationRequest)}"));
return(Json(response));
}
if (!ModelState.IsValid)
{
return(JsonModelStateErrors());
}
var validationResult = await _authy.VerifyPhoneTokenAsync(
verificationRequest.PhoneNumber,
verificationRequest.CountryCode,
tokenVerification.Token
);
if (!validationResult.IsSuccess)
{
return(Json(validationResult));
}
var phone = _authy.NormalizePhoneNumber(verificationRequest.CountryCode, verificationRequest.PhoneNumber);
var addNewUserRequest = await _authy.RegisterUserAsync(new RegisterViewModel
{
CountryCode = verificationRequest.CountryCode,
PhoneNumber = verificationRequest.PhoneNumber,
Password = verificationRequest.Pin,
UserName = verificationRequest.PhoneNumber
});
if (!addNewUserRequest.IsSuccess)
{
return(Json(addNewUserRequest));
}
var user = new GearUser
{
PhoneNumber = phone,
UserName = phone,
IsEditable = true,
PhoneNumberConfirmed = true
};
var createRequest = await _userManager.CreateUserAsync(user, verificationRequest.Pin);
if (!createRequest.IsSuccess)
{
return(!createRequest.IsSuccess ? Json(createRequest) : Json(validationResult));
}
var setTokenResult = await _userManager
.UserManager
.SetAuthenticationTokenAsync(user, PhoneVerificationResources.LOGIN_PROVIDER_NAME, PhoneVerificationResources.AUTHY_TOKEN,
addNewUserRequest.Result);
if (setTokenResult.Succeeded)
{
return(!createRequest.IsSuccess ? Json(createRequest) : Json(validationResult));
}
var tokenResponse = new ResultModel();
tokenResponse.AppendIdentityErrors(setTokenResult.Errors);
return(Json(tokenResponse));
}