public async Task <ActionResult> changePassword(ChangePasswordRequestModel user)
{
Users userToChange = await userGymMovesRepository.getUser(user.username);
if (userToChange == null)
{
return(NotFound("This user doesn't exist."));
}
/* Verifies the old password matches the one in the db. */
if (verifyHash(SHA256.Create(), user.oldPassword + userToChange.Salt, userToChange.Password))
{
/* Hash new password.*/
string hash = getHash(SHA256.Create(), user.newPassword + userToChange.Salt);
/* Try change password in db.*/
bool changed = await userGymMovesRepository.changePassword(userToChange.Username, hash);
if (changed)
{
return(Ok("Successully changed your password."));
}
else
{
return(StatusCode(500, "This is already your password."));
}
}
else
{
return(Unauthorized("The password you entered is not correct."));
}
}
public void ChangePassword(int memberId, ChangePasswordRequestModel model)
{
using (OrgCommEntities dbc = new OrgCommEntities(DBConfigs.OrgCommConnectionString))
{
OrgComm.Data.Models.Member member = dbc.Members.SingleOrDefault(r => (!r.DelFlag) && r.Id.Equals(memberId));
if (member == null)
{
throw new OrgException("Invalid profile");
}
if (!member.PasswordHash.Equals(GenerateHash(member.Salt, model.CurrentPassword)))
{
throw new OrgException("Incorrect password");
}
string password = model.NewPassword;
member.Salt = SecurityHelper.GenerateBase64SaltString();
member.PasswordHash = this.GenerateHash(member.Salt, password);
member.UpdatedDate = DateTime.Now;
dbc.SaveChanges();
}
}
public string ChangePassword(ChangePasswordRequestModel changePasswordRequestModel)
{
var changePasswordResult = this.loginService.ChangePassword(changePasswordRequestModel, this.ActionContext.Request.Headers.Host);
_nLogLogger.Info(changePasswordResult);
return(changePasswordResult);
}
public async Task <HttpResponseMessage> ChangePassword(ChangePasswordRequestModel model)
{
if (string.IsNullOrEmpty(model.OldPass) || string.IsNullOrEmpty(model.NewPass) || string.IsNullOrEmpty(model.ReNewPass))
{
return(Request.CreateResponse(HttpStatusCode.BadGateway, "Yêu cầu nhập đủ thông tin."));
}
if (model.NewPass != model.ReNewPass)
{
return(Request.CreateResponse(HttpStatusCode.BadGateway, "Nhập lại mật khẩu không khớp."));
}
var userManager = Request.GetOwinContext().GetUserManager <ApplicationUserManager>();
ApplicationUser user = userManager.Find(this.RequestContext.Principal.Identity.Name, model.OldPass);
if (user == null)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, "Mật khẩu cũ không chính xác."));
}
if (model.OldPass == model.NewPass)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, "Mật khẩu mới không được trùng với mật khẩu cũ."));
}
var result = await userManager.ChangePasswordAsync(user.Id, model.OldPass, model.NewPass);
if (!result.Succeeded)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, "Mật khẩu yêu cầu 8 ký tự, bao gồm: số, chữ hoa, chữ thường, ký tự đặc biệt."));
}
return(Request.CreateResponse(HttpStatusCode.OK, "OK"));
}
public async Task <bool> UpdatePassword(ChangePasswordRequestModel model)
{
try
{
bool success = false;
DynamicParameters ObjParm = new DynamicParameters();
ObjParm.Add("@Password", model.NewPassword);
ObjParm.Add("@UserId", model.UserId);
ObjParm.Add("@Success", dbType: DbType.Boolean, direction: ParameterDirection.Output);
using (IDbConnection con = new SqlConnection(_connectionString))
{
await con.QueryAsync("dbo.SSP_ChangePassword", ObjParm, commandType : CommandType.StoredProcedure);
success = ObjParm.Get <bool>("@Success");
}
if (success)
{
return(true);
}
else
{
return(false);
}
}
catch (Exception ex)
{
throw;
}
}
public async Task <bool> ChangePassword(ChangePasswordRequestModel model)
{
var user = await _context.PlayerIdentity.FirstOrDefaultAsync(t => t.Email == model.Email);
if (user == null)
{
return(false);
}
user.PasswordChanging = true;
var dbResult = _context.PlayerIdentity.Update(user);
if (dbResult.State == EntityState.Modified)
{
await _context.SaveChangesAsync();
await _emailService.SendEmailToUser(user.Email, "", EmailType.ChangePassword,
new EmailData()
{
NickName = user.Nick, PlayerHash = user.PlayerHash, PlayerId = user.Id
});
return(true);
}
return(false);
}
public async Task ChangePassword()
{
//Logueamos para que tenga access_token
var request = new LoginRequestModel()
{
UserName = TestConstants.VALID_USERNAME,
Password = TestConstants.VALID_PASWORD
};
await Locator.LogService.Login(request);
// Cambiamos la clave
var changePasswordRequestModel = new ChangePasswordRequestModel()
{
usuario = TestConstants.VALID_USERNAME,
contraseniaActual = TestConstants.VALID_PASWORD,
contraseniaNueva = TestConstants.NEWVALID_PASWORD
};
await Locator.LogService.ChangePassword(changePasswordRequestModel);
// La devolvemos a lo mismo
var changePasswordRequestModelComback = new ChangePasswordRequestModel()
{
usuario = TestConstants.VALID_USERNAME,
contraseniaActual = TestConstants.NEWVALID_PASWORD,
contraseniaNueva = TestConstants.VALID_PASWORD
};
await Locator.LogService.ChangePassword(changePasswordRequestModelComback);
}
public async Task <IdentityResult> ChangePasswordAsync(ChangePasswordRequestModel model)
{
try
{
if (model is null)
{
throw new Exception("The model to change the password can not be null");
}
ApplicationUser user = await CustomFindUserAsync("id", model.UserId);
var result = await _userManager.ChangePasswordAsync(user, model.OldPassword, model.NewPassword);
if (!result.Succeeded)
{
throw new Exception(result.Errors.ToList()[0].Description);
}
return(result);
}
catch (Exception)
{
throw;
}
}
public async Task <ChangePasswordResponseModel> ChangePassword(ChangePasswordRequestModel changePasswordRequestModel)
{
ChangePasswordRequestContract changePasswordRequestContract = _mapper.Map <ChangePasswordRequestContract>(changePasswordRequestModel);
ChangePasswordResponseContract changePasswordResponseContract = await _LoginRepository.ChangePassword(changePasswordRequestContract);
return(_mapper.Map <ChangePasswordResponseModel>(changePasswordResponseContract));
}
public virtual async Task <AuthResponse> ChangePassword(ChangePasswordRequestModel model, CancellationToken cancellationToken = default(CancellationToken))
{
HttpResponseMessage httpResponse = await this.Client.PostAsJsonAsync($"api/auth/changepassword", model, cancellationToken).ConfigureAwait(false);
this.HandleResponseCode(httpResponse);
return(JsonConvert.DeserializeObject <AuthResponse>(httpResponse.Content.ContentToString()));
}
public IActionResult ChangePW([FromBody] ChangePasswordRequestModel changePasswordRequest)
{
var userId = HttpContext?.User?.Claims?.Where(c => c.Type == "sub").FirstOrDefault()?.Value ?? "";
var result = _usersHelper.ChangePassword(userId, changePasswordRequest.OldPassword, changePasswordRequest.NewPassword);
return(AGSResponseFactory.GetAGSResponseJsonResult(result));
}
public async Task <ResultModel> ChangePasswordAsync(ChangePasswordRequestModel requestModel)
{
var model = _mapper.Map <ChangePasswordModel>(requestModel);
model.ID = GetLoginUserID();
await _userService.ChangePasswordAsync(model);
return(ResultModel.Success("修改成功"));
}
public async Task <ChangePasswordResponseModel> ChangePasswordAsync([FromBody] ChangePasswordRequestModel request)
{
var authModel = await _authService.UpdatePasswordAsync(request.Email, request.CurrentPassword, request.NewPassword);
return(new ChangePasswordResponseModel
{
Error = _mapper.Map <ChangePasswordErrorCodes>(authModel)
});
}
public async Task <IActionResult> ChangePassword([FromBody] ChangePasswordRequestModel request)
{
var phoneNumber = User.FindFirst(ClaimTypes.NameIdentifier).Value;
request.PhoneNumber = phoneNumber;
var responseModel = await _identityService.ChangePasswordAsync(request);
return(new CustomActionResult(responseModel));
}
public async Task <IActionResult> ChangePassword([FromBody] ChangePasswordRequestModel objModel)
{
JsonResponse <string> objResultList = new JsonResponse <string>();
if (objModel != null)
{
try
{
bool matched = await this._authService.MatchSecretKey(objModel.SecretKey);
if (!matched)
{
objResultList.Data = StaticResource.UnauthorizedMessage;
objResultList.Status = StaticResource.UnauthorizedStatusCode;
objResultList.Message = StaticResource.UnauthorizedMessage;
return(new OkObjectResult(objResultList));
}
else
{
ResetPasswordResponseType objCommonStatusResponse = await this._settingService.ChangePassword(objModel);
if (objCommonStatusResponse == ResetPasswordResponseType.Success)
{
objResultList.Data = StaticResource.PasswordUpdated;
//Read dynamic msg deom enum
ResetPasswordResponseType obj_enum = (ResetPasswordResponseType)objCommonStatusResponse;
objResultList.Message = CommonConversions.ToEnumDescription(obj_enum);
objResultList.Status = StaticResource.SuccessStatusCode;
}
else
{
objResultList.Data = StaticResource.PassNotMatch;
ResetPasswordResponseType obj_enum = (ResetPasswordResponseType)objCommonStatusResponse;
objResultList.Message = CommonConversions.ToEnumDescription(obj_enum);
objResultList.Status = StaticResource.FailStatusCode;
}
}
}
catch (Exception ex)
{
HttpContext.RiseError(ex);
objResultList.Data = "";
objResultList.Status = StaticResource.FailStatusCode;
objResultList.Message = StaticResource.FailMessage;
throw;
}
}
else
{
objResultList.Data = "";
objResultList.Status = StaticResource.FailStatusCode;
objResultList.Message = StaticResource.InvalidMessage;
}
return(new OkObjectResult(objResultList));
}
public async Task <IActionResult> ChangePassword(ChangePasswordRequestModel requestModel)
{
return(await ExecuteFunction(async (user) =>
{
if (string.Compare(requestModel.NewPassword, requestModel.ConfirmPassword) != 0)
{
throw new ArgumentException($"Mật khẩu không trùng khớp");
}
return await _authenticationService.ChangePassword(user.Id, requestModel.OldPassword, requestModel.NewPassword);
}));
}
public HttpResponseMessage changePassword(ChangePasswordRequestModel changePasswordRequest)
{
ErrorModel errorModel = null;
UserProvider userProvider = new UserProvider();
var result = userProvider.changePassword(changePasswordRequest, out errorModel);
APIResponseModel aPIResponseModel = new APIResponseModel();
aPIResponseModel.Response = result;
aPIResponseModel.Error = errorModel;
return(Request.CreateResponse(HttpStatusCode.OK, aPIResponseModel));
}
public async Task <ChangePasswordResponseModel> ChangePassword(ChangePasswordRequestModel model)
{
var player = await GetPlayerById(model.PlayerId);
if (player == null)
{
return new ChangePasswordResponseModel()
{
IsSuccess = false, BadPassword = false
}
}
;
var passwordSb = new StringBuilder();
passwordSb.Append(_encrypter.Encrypted(model.Password));
var salt = await _context.PlayerSalt.FirstOrDefaultAsync(t => t.PlayerId == model.PlayerId);
passwordSb.Append(salt.Salt);
if (passwordSb.ToString() != player.Password)
{
return new ChangePasswordResponseModel()
{
IsSuccess = false, BadPassword = true
}
}
;
var newPassword = _encrypter.Encrypted(model.NewPassword);
player.Password = newPassword;
player.PlayerHash = player.GetHashCode().ToString();
var dbResult = _context.PlayerIdentity.Update(player);
if (dbResult.State == EntityState.Modified)
{
await _context.SaveChangesAsync();
return(new ChangePasswordResponseModel()
{
IsSuccess = true, BadPassword = false
});
}
return(new ChangePasswordResponseModel()
{
IsSuccess = false, BadPassword = false
});
}
public async Task <ActionResult> ChangePassword(ChangePasswordRequestModel model)
{
string userId = this.User.GetId();
Result result = await this.identityService.ChangePassword(userId, model.CurrentPassword, model.NewPassword);
if (!result.Succeeded)
{
return(BadRequest(result.Error));
}
return(Ok());
}
public async Task <IActionResult> ChangePassword(ChangePasswordRequestModel model)
{
model.Validate();
var result = await _authManager.ChangePassword(model.CurrentPassword, model.NewPassword);
return(Ok(new ResponseModel <object>
{
RequestSuccessful = true,
ResponseCode = ResponseCodes.Successful,
Message = "Your password has been reset successfully",
ResponseData = result
}));
}
public void ChangePasswordRequestIsMade_InvalidPassword_ValidationShouldFail(string inputPassword)
{
var validatorService = new PasswordValidator(CreateDefaultValidationRules());
var request = new ChangePasswordRequestModel()
{
Password = inputPassword
};
var validator = new ChangePasswordRequestValidator(validatorService);
var result = validator.Validate(request);
Assert.False(result.IsValid);
}
public virtual async Task <IActionResult> ChangePassword([FromBody] ChangePasswordRequestModel model)
{
AuthResponse result = await this.authService.ChangePassword(model, this.User.Claims.First(x => x.Type == ClaimTypes.Email).Value);
if (result.Success)
{
return(this.Ok(result));
}
else
{
return(this.StatusCode(StatusCodes.Status400BadRequest, result));
}
}
public ActionResult ChangePassword(ChangePasswordRequestModel changePasswordRequestModel)
{
var result = _mediator.Send(changePasswordRequestModel);
if (result.Result.Success)
{
return(RedirectToAction("Login", "Home"));
}
else
{
return(View());
}
}
public void ChangePasswordRequestIsMade_EverythingValid_ValidationShouldSucceed()
{
var validatorService = new PasswordValidator(CreateDefaultValidationRules());
var request = new ChangePasswordRequestModel
{
Password = "******"
};
var validator = new ChangePasswordRequestValidator(validatorService);
var result = validator.Validate(request);
Assert.True(result.IsValid);
}
public async Task <ActionResult> ChangePassword(ChangePasswordRequestModel model)
{
var result = await this.identityService.ChangePassword(
this.User.GetId(),
model.Password,
model.NewPassword);
if (result.Succeeded)
{
return(Ok());
}
return(BadRequest(result.Errors));
}
public async Task <ActionResult> ChangePassword(ChangePasswordRequestModel changePasswordModel)
{
var user = await userManager
.GetUserAsync(this.User);
var result = await this.userManager
.ChangePasswordAsync(user, changePasswordModel.Password, changePasswordModel.NewPassword);
if (result.Succeeded)
{
return(Ok());
}
return(BadRequest(result.Errors));
}
public ChangeOrderStatusResponseModel changePassword(ChangePasswordRequestModel changePasswordRequest, out ErrorModel errorModel)
{
errorModel = null;
User user = new User();
try
{
return(user.changePassword(changePasswordRequest, out errorModel));
}
catch
{
return(null);
}
}
public async Task <ResultModel> ChangePassword(ChangePasswordRequestModel requestModel)
{
try
{
var model = _mapper.Map <ChangePasswordModel>(requestModel);
model.ID = GetLoginUserID();
await _userService.ChangePasswordAsync(model);
return(ResultModel.Success("修改成功"));
}
catch (MateralConDepException ex)
{
return(ResultModel.Fail(ex.Message));
}
}
public async Task ChangePassword(ChangePasswordRequestModel model, int userId)
{
if (model.OldPassword == model.Password)
{
throw new CustomException(HttpStatusCode.BadRequest, "password", "New password matches old password");
}
var user = await _userManager.FindByIdAsync(userId.ToString());
var result = await _userManager.ChangePasswordAsync(user, model.OldPassword, model.Password);
if (!result.Succeeded)
{
throw new CustomException(HttpStatusCode.BadRequest, "general", "Current password doesn’t match password");
}
}
public async Task <object> ChangePassword(string id, [FromBody] ChangePasswordRequestModel model)
{
var currUser = await GetLoginUserAsync();
var requestedUser = await repository.GetUserByEmailAsync(id);
if (currUser.Email != requestedUser.Email)
{
return(Forbid());
}
requestedUser.Password = model.NewPassword;
requestedUser.RequirePasswordChange = false;
await repository.UpdateAsync(requestedUser);
return(Ok());
}
