public object UpdateUserPassword([FromBody] UpdateUserPasswordModel um)
{
try
{
var addr = Server.GetUserIp(Request.HttpContext);
if (Server.IpHandle(addr) == 0)
{
return(new[] { "your ip can't using our api , please contact administrator" });
}
var account = HttpContext.Session.GetString("user_account");
if (account == null)
{
return(new
{
result = 401,
msg = "not login"
});
}
var re = UserServer.UpdateUserPassword(um);
return(re);
}
catch (Exception e)
{
return(new
{
result = e.HResult,
msg = e.Message
});
}
}
public async Task <IActionResult> SetUserPassword(
string username,
[FromBody] UpdateUserPasswordModel model)
{
var entity = await _repo.Users.FindOneAsync(username);
if (entity == null)
{
return(NotFound());
}
var requirement = new SetUserPasswordRequirement();
if (model.OldPassword.HasValue)
{
requirement.OldPassword = model.OldPassword.Value;
}
var authResult = await _authorization.AuthorizeAsync(User, entity, requirement);
if (!authResult.Succeeded)
{
return(Forbid());
}
await _repo.Users.UpdatePasswordAsync(username, model.NewPassword);
return(Ok());
}
public async Task <IActionResult> UpdateLoginInfo(UpdateUserPasswordModel model, string email)
{
if (ModelState.IsValid)
{
User user = await userManager.FindByEmailAsync(email);
// Replace current password with new password
IdentityResult result = await userManager.ChangePasswordAsync(user, model.CurrentPassword, model.NewPassword);
if (result.Succeeded)
{
User updatedUser = await userManager.FindByEmailAsync(email);
TokenCreatorService tokenService = new TokenCreatorService(_context, _configure);
var isAdmin = false;
var payload = tokenService.CreateToken(updatedUser, isAdmin, true);
return(Ok(payload));
}
}
return(Unauthorized(new APIPayload()));
}
public IActionResult UpdateUserPassword(UpdateUserPasswordModel updateUserModel)
{
try
{
if (ModelState.IsValid)
{
updateUserModel.oldPassword = EncryptDecryptHelper.Encrypt(updateUserModel.oldPassword);
updateUserModel.newPassword = EncryptDecryptHelper.Encrypt(updateUserModel.newPassword);
var isUpdated = iUser.UpdatePassword(updateUserModel.oldPassword, updateUserModel.newPassword, updateUserModel.userId);
if (isUpdated > 0)
{
return(Ok(ResponseHelper.Success(MessageConstants.PasswordUpdated)));
}
else if (isUpdated == ReturnCode.NotMatching.GetHashCode())
{
return(Ok(ResponseHelper.Error(MessageConstants.OldPasswordNotMatching)));
}
else
{
return(Ok(ResponseHelper.Error(MessageConstants.PasswordNotUpdated)));
}
}
else
{
return(Ok(ResponseHelper.Error(MessageConstants.CompulsoryData)));
}
}
catch (Exception ex)
{
LogHelper.ExceptionLog(ex.Message + " ::::: " + ex.StackTrace);
return(Ok(ResponseHelper.Error(ex.Message)));
}
}
public async Task <IHttpActionResult> EditUserPasswordAsync(int profileId, UpdateUserPasswordModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
await _usersService.UpdateUserPasswordAsync(profileId, model.OldPassword, model.NewPassword);
return(Ok());
}
/// <summary>
/// 用户修改密码
/// </summary>
/// <param name="um">用户</param>
/// <returns>修改密码结果</returns>
public static object UpdateUserPassword(UpdateUserPasswordModel um)
{
using (var con = new SqlConnection(Server.SqlConString))
{
con.Open();
var sqlCom = new SqlCommand("sp_UpdateUser", con)
{
CommandType = CommandType.StoredProcedure
};
sqlCom.Parameters.AddRange(new []
{
new SqlParameter
{
ParameterName = "@userId",
Direction = ParameterDirection.Input,
SqlDbType = SqlDbType.Int,
Value = um.Id
},
new SqlParameter
{
ParameterName = "@newPassword",
Direction = ParameterDirection.Input,
SqlDbType = SqlDbType.NVarChar,
Size = 15,
Value = um.Password
},
new SqlParameter
{
ParameterName = "@message",
Direction = ParameterDirection.Output,
Size = 30,
SqlDbType = SqlDbType.VarChar
},
new SqlParameter
{
ParameterName = "@return",
Direction = ParameterDirection.ReturnValue,
SqlDbType = SqlDbType.Int
}
});
sqlCom.ExecuteNonQuery();
return(new
{
result = (int)sqlCom.Parameters["@return"].Value,
msg = (string)sqlCom.Parameters["@message"].Value
});
}
}
public IActionResult UpdatePasswordUser([FromBody] UpdateUserPasswordModel model)
{
try
{
var userPassDto = new UserUpdatePasswordDto
{
UserId = model.UserId,
Password = model.Password
};
var data = _serviceUser.UpdatePasswordUser(userPassDto);
return(Ok(data));
}
catch (ValidationException ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <Object> UpdateUserPassword([FromBody] UpdateUserPasswordModel model)
{
//var user = await _userManager.GetUserAsync(HttpContext.User); //works 2
string userId = User.Claims.First(c => c.Type == "UserID").Value;
var user = await _userManager.FindByIdAsync(userId);
if (user != null && await _userManager.CheckPasswordAsync(user, model.CurrentPassword))
{
user.PassChanged = true;
var result = await _userManager.ChangePasswordAsync(user, model.CurrentPassword, model.NewPassword);
return(Ok(result));
}
else
{
return(BadRequest(new { message = "Wrong password" }));
}
}
public async Task <ActionResult> UpdateLogin([Bind] UpdateUserPasswordModel model)
{
if (ModelState.IsValid)
{
var apiResult = await webAPI.UpdateAsync <UpdateUserPasswordModel>(model, ApiURL.USERS_LOGIN_UPDATE + User.Identity.Name);
if (apiResult.Status.IsSuccessStatusCode)
{
await SetAuthCookie(apiResult.APIPayload);
TempData["PasswordSuccess"] = "Lösenordet har uppdaterats!";
return(RedirectToAction(nameof(UpdateLogin)));
}
else
{
ModelState.AddModelError("CurrentPassword", "Felaktigt lösenord");
}
}
return(View(model));
}
public async Task <IActionResult> UpdatePassword(Guid tenantId, string userPrincipalName, [FromBody] UpdateUserPasswordModel updateUsermodel)
{
BearerToken(tenantId.ToString());
var model = _mapper.Map <UpdateUserModel>(updateUsermodel);
await _azureAdUserService.UpdateAsync(_httpClient, userPrincipalName, model);
return(Ok());
}
