public void ChangePassword(ChangePasswordReq request)
{
Repository.Update(u => u.Account == request.Account, user => new User
{
Password = request.Password
});
}
public override async Task <ChangePasswordResp> ChangePassword(ChangePasswordReq request,
ServerCallContext context)
{
var options = request.Options;
var user = context.GetHttpContext().User;
var changePasswordSource = new TaskCompletionSource <bool>();
var envelope = new CallbackEnvelope(OnMessage);
_queue.Publish(new UserManagementMessage.ChangePassword(envelope, user, options.LoginName,
options.CurrentPassword,
options.NewPassword));
await changePasswordSource.Task.ConfigureAwait(false);
return(new ChangePasswordResp());
void OnMessage(Message message)
{
if (HandleErrors(options.LoginName, message, changePasswordSource))
{
return;
}
changePasswordSource.TrySetResult(true);
}
}
public string ChangePassword(ChangePasswordReq request)
{
try
{
_app.ChangePassword(request);
}
catch (Exception ex)
{
Result.Code = 500;
Result.Message = ex.InnerException?.Message ?? ex.Message;
}
return(JsonHelper.Instance.Serialize(Result));
}
public IHttpActionResult ChangePassword(ChangePasswordReq changePasswordDto)
{
long userId = GetUserIdFromContext();
IdentityResult identityResult = AppUserManager.ChangePassword(changePasswordDto, userId);
if (identityResult.Succeeded)
{
var response = new BaseResponseDto();
response.Message = Responses.ChangePasswordResponseMessage;
return(Ok(response));
}
return(BadRequestWithIdentityErrors(identityResult));
}
public Response ChangePassword(ChangePasswordReq request)
{
var result = new Response();
try
{
_app.ChangePassword(request);
}
catch (Exception ex)
{
result.Code = 500;
result.Message = ex.InnerException?.Message ?? ex.Message;
}
return(result);
}
public async Task <IActionResult> ChangePassword(long id, [FromBody] ChangePasswordReq req)
{
var user = await userRepository.WithId(id);
var result = passwordHasher.VerifyHashedPassword(user, user.Password, req.OldPassword);
if (result == PasswordVerificationResult.Failed)
{
return(BadRequest());
}
var hashedPass = passwordHasher.HashPassword(user, req.NewPassword);
var cmd = new ChangePasswordCmd(hashedPass, id);
var changed = await userRepository.ChangePassword(cmd);
if (changed)
{
return(Ok());
}
return(BadRequest());
}
public override async Task <ChangePasswordResp> ChangePassword(ChangePasswordReq request,
ServerCallContext context)
{
var options = request.Options;
var user = context.GetHttpContext().User;
var changePasswordOperation = ChangePasswordOperation;
if (user?.Identity?.Name != null)
{
changePasswordOperation =
changePasswordOperation.WithParameter(
Plugins.Authorization.Operations.Users.Parameters.User(user.Identity.Name));
}
if (!await _authorizationProvider.CheckAccessAsync(user, changePasswordOperation, context.CancellationToken).ConfigureAwait(false))
{
throw RpcExceptions.AccessDenied();
}
var changePasswordSource = new TaskCompletionSource <bool>();
var envelope = new CallbackEnvelope(OnMessage);
_publisher.Publish(new UserManagementMessage.ChangePassword(envelope, user, options.LoginName,
options.CurrentPassword,
options.NewPassword));
await changePasswordSource.Task.ConfigureAwait(false);
return(new ChangePasswordResp());
void OnMessage(Message message)
{
if (HandleErrors(options.LoginName, message, changePasswordSource))
{
return;
}
changePasswordSource.TrySetResult(true);
}
}
private bool Validate(ChangePasswordReq data, out string errorCode, out string errorMess)
{
errorCode = null;
errorMess = null;
try
{
if (data == null)
{
errorCode = ErrorCodeEnum.DataInputWrong.ToString();
return(false);
}
if (string.IsNullOrEmpty(data.Username))
{
errorMess = "Username is null";
errorCode = ErrorCodeEnum.Error_UsernameIsNull.ToString();
return(false);
}
if (data.Password == null)
{
errorMess = "Password is null";
errorCode = ErrorCodeEnum.Error_PasswordIsNull.ToString();
return(false);
}
if (data.Password == data.NewPassword)
{
errorMess = "New Password is same password";
errorCode = ErrorCodeEnum.Error_NewPasswordIsSamePassword.ToString();
return(false);
}
}
catch (Exception ex)
{
Logger.Write(ex.ToString());
throw;
}
return(true);
}
public async Task <IActionResult> ChangePassword(ChangePasswordReq model)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var user = _userDbContext.Users.FirstOrDefault(x => x.Email == model.Email);
if (user == null)
{
return(NotFound());
}
if (!model.CurrentPassword.Verify(user.PasswordHash))
{
return(BadRequest());
}
user.PasswordHash = model.NewPassword.Hash();
await _userDbContext.SaveChangesAsync();
return(Ok());
}
public async Task <IHttpActionResult> Post([FromBody] ChangePasswordReq req)
{
try
{
string errorMessage = "UnknowError";
string errorCode = ErrorCodeEnum.UnknownError.ToString();
#region token
var header = Request.Headers;
if (header.Authorization == null)
{
return(StatusCode(HttpStatusCode.Unauthorized));
}
var token = header.Authorization.Parameter;
UserInfo userInfo;
if (string.IsNullOrWhiteSpace(token) || !TokenManager.ValidateToken(token, out userInfo))
{
return(StatusCode(HttpStatusCode.Unauthorized));
}
// chi co admin moi co quyen tao tai khoan khac
if (!Operator.HasPermision(userInfo.IdUserLogin, RoleDefinitionEnum.CreateUser))
{
return(Ok(new RequestErrorCode(false, ErrorCodeEnum.Error_NotHavePermision.ToString(), "Khong co quyen tao user")));
}
#endregion
#region Validate
if (!Validate(req, out errorCode, out errorMessage))
{
return(Ok(new RequestErrorCode(false, errorCode, errorMessage)));
}
#endregion
#region Process
// lay ra userInfo tuong ung
var userChange = MemoryInfo.GetListUserLoginByField(req.Username, UserLogin.UserLoginFields.Username)
.FirstOrDefault();
if (userChange == null)
{
return(Ok(new RequestErrorCode(false, ErrorCodeEnum.Error_UserNotExist.ToString(), "Khong ton tai user")));
}
// check password
var oldPassEncrypt = PasswordGenerator.EncodePassword(req.Password);
if (userChange.Password != oldPassEncrypt)
{
return(Ok(new RequestErrorCode(false, ErrorCodeEnum.Error_PasswordWrong.ToString(), "Sai password")));
}
var newPassEncrypt = PasswordGenerator.EncodePassword(req.NewPassword);
userChange.Password = newPassEncrypt;
UpdateEntitySql updateEntitySql = new UpdateEntitySql();
var lstCommand = new List <EntityCommand>();
lstCommand.Add(new EntityCommand {
BaseEntity = new Entity.Entity(userChange), EntityAction = EntityAction.Update
});
bool isOkDone = updateEntitySql.UpdateDefault(lstCommand);
if (!isOkDone)
{
return(Ok(new RequestErrorCode(false, errorCode, errorMessage)));
}
#endregion
// update memory
MemorySet.UpdateAndInsertEntity(userChange);
var result = new RequestErrorCode(true);
return(Ok(result));
}
catch (Exception ex)
{
Logger.Write(ex.ToString());
}
Logger.Write("--------------------ErrorCodeEnum.Unknow---------------------------------");
return(BadRequest("Unknow"));
}
public static IdentityResult ChangePassword(this AppUserManager appUserManager, ChangePasswordReq changePasswordDto, long userId)
{
IdentityResult identityResult = appUserManager.ChangePassword(userId,
changePasswordDto.OldPassword,
changePasswordDto.NewPassword);
return(identityResult);
}
