public async Task <ActionResult> AddPassword([FromBody] SetPasswordRequest model)
{
var user = await _usersService.FindUserByIdAsync(CurrentUserId);
if (user == null)
{
return(NotFound());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
string password = model.Password.Trim();
if (password.Length < 6)
{
ModelState.AddModelError("password", "密碼長度不能小於6個字元");
return(BadRequest(ModelState));
}
await _usersService.AddPasswordAsync(user, password);
return(Ok());
}
public async Task <IActionResult> SetPassword([FromBody] SetPasswordRequest request)
{
return(await Action <SetPasswordCommand, SetPasswordCommandParameter>(new SetPasswordCommandParameter
{
Data = request
}));
}
public async Task <SignInResponse> SetPassword([FromBody] SetPasswordRequest model)
{
var user = await _userManager.FindByIdAsync(model.UserId);
if (user == null)
{
throw new BadRequestException("USER_NOT_FOUND");
}
if (user.SecurityUser.IsInvitationAccepted)
{
throw new BadRequestException("ALREADY_ACCEPTED");
}
var resetPasswordResult = await _userManager.SetPassworForInvitationdAsync(user, model.Code, model.Password);
if (!resetPasswordResult.Succeeded)
{
throw new BadRequestException("TOKEN_IS_INVALID");
}
var result = _signInResponseProvider.Get(user, false);
await _userToSService.AcceptAsync(user.SecurityUser.Id);
await _setInvitationAcceptedService.SetInvitationAccepted(user.SecurityUser.Id);
return(result);
}
public async Task <IActionResult> SetPassword([FromBody] SetPasswordRequest request, CancellationToken cancellationToken = default)
{
var(response, token) = await Mediator.Send(request, cancellationToken);
Response.Cookies.Append("jwt", token);
return(Ok(response));
}
public async Task <IHttpActionResult> SetPassword(SetPasswordRequest model)
{
model.UserId = User.Identity.GetUserId();
var result = await _userService.SetPasswordAsync(model);
// Response
return(Ok(result));
}
internal void SetPassword(string partitionDN, string accountDN, string newPassword)
{
this.Init();
SetPasswordRequest setPasswordRequest = new SetPasswordRequest();
setPasswordRequest.PartitionDN = partitionDN;
setPasswordRequest.AccountDN = accountDN;
setPasswordRequest.NewPassword = newPassword;
this._acctMgmt.SetPassword(this._sessionHandle, setPasswordRequest);
}
public ActionResult SetPassword(
[FromRoute] Guid userId,
[FromBody] SetPasswordRequest setPassword)
{
_userService.SetPassword(
userId,
setPassword.NewPassword);
return(Ok());
}
public async Task <Response> SetPassword(string oldPassword, string newPassword)
{
SetPasswordRequest setPassword = new SetPasswordRequest
{
OldPassword = oldPassword,
NewPassword = newPassword
};
string content = JsonConvert.SerializeObject(setPassword);
return(await _apiService.Put <Response>(Urls.SET_PASSWORD, content));
}
/// <summary>
/// Set Password Async.
/// </summary>
/// <param name="request">The <see cref="SetPasswordRequest"/>.</param>
/// <param name="cancellationToken">The <see cref="CancellationToken"/>.</param>
/// <returns>Void.</returns>
public virtual async Task SetPasswordAsync(SetPasswordRequest request, CancellationToken cancellationToken = default)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
request.Controller = BaseIdentityApi <TUser, TIdentity> .IdentityController;
await this.InvokeAsync(request, cancellationToken);
}
/// <summary>
/// 本接口(SetPassword)用于设置云数据库账户的密码。
///
/// </summary>
/// <param name="req"><see cref="SetPasswordRequest"/></param>
/// <returns><see cref="SetPasswordResponse"/></returns>
public SetPasswordResponse SetPasswordSync(SetPasswordRequest req)
{
JsonResponseModel <SetPasswordResponse> rsp = null;
try
{
var strResp = this.InternalRequestSync(req, "SetPassword");
rsp = JsonConvert.DeserializeObject <JsonResponseModel <SetPasswordResponse> >(strResp);
}
catch (JsonSerializationException e)
{
throw new TencentCloudSDKException(e.Message);
}
return(rsp.Response);
}
public async Task <IHttpActionResult> SetPassword(SetPasswordRequest model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
IdentityResult result = await UserManager.AddPasswordAsync(User.Identity.GetUserId(), model.NewPassword);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
return(Ok());
}
public async Task <ChangePasswordResponse> SetPasswordAsync(SetPasswordRequest request)
{
if (request == null)
{
return(ChangePasswordResponse.Fail("Bad request"));
}
if (!request.NewPassword.Equals(request.ConfirmPassword))
{
return(ChangePasswordResponse.Fail("Passwords was not equal"));
}
var result = await _userRepository.SetPassword(request.UserId, request.NewPassword);
return(result.Succeeded ? ChangePasswordResponse.Success()
: ChangePasswordResponse.Fail(result.Errors.FirstOrDefault()));
}
public BaseResponse Post(SetPasswordRequest request)
{
_log.StartLog(request);
try
{
_credentialStore.SetPassword(this.GetSession().UserAuthName, request.NewPassword);
return(new BaseResponse());
}
catch (Exception e)
{
_log.Fatal("error", e);
Errors.Add(e.Message + " " + e.StackTrace);
return(new CreateUserResponse {
Errors = Errors
});
}
}
public bool SetUserPassword(string userId, string username, string password, CloudIdentity identity)
{
var urlPath = string.Format("v2.0/users/{0}/OS-KSADM/credentials", userId);
var request = new SetPasswordRequest
{
PasswordCredencial =
new PasswordCredencial {
Username = username, Password = password
}
};
var response = ExecuteRESTRequest <PasswordCredencialResponse>(identity, urlPath, HttpMethod.POST, request);
if (response == null || response.StatusCode != 201 || response.Data == null)
{
return(false);
}
return(response.Data.PasswordCredencial.Password.Equals(password));
}
public void SetPassword(string phone, string password)
{
if (string.IsNullOrWhiteSpace(phone))
{
throw new ArgumentException("Телефон должен быть указан", nameof(phone));
}
if (string.IsNullOrWhiteSpace(password))
{
throw new ArgumentException("Пароль должен быть указан", nameof(password));
}
var client = new LkUserManager.LkUserManagerClient(Channel);
var request = new SetPasswordRequest
{
Phone = phone,
Password = password
};
client.SetPassword(request, Headers);
}
/// <inheritdoc/>
public virtual bool SetUserPassword(string userId, string username, string password, CloudIdentity identity)
{
if (userId == null)
{
throw new ArgumentNullException("userId");
}
if (username == null)
{
throw new ArgumentNullException("username");
}
if (password == null)
{
throw new ArgumentNullException("password");
}
if (string.IsNullOrEmpty(userId))
{
throw new ArgumentException("userId cannot be empty");
}
if (string.IsNullOrEmpty(username))
{
throw new ArgumentException("username cannot be empty");
}
if (string.IsNullOrEmpty(password))
{
throw new ArgumentException("password cannot be empty");
}
CheckIdentity(identity);
var urlPath = string.Format("v2.0/users/{0}/OS-KSADM/credentials", userId);
var request = new SetPasswordRequest(username, password);
var response = ExecuteRESTRequest <PasswordCredentialResponse>(identity, new Uri(UrlBase, urlPath), HttpMethod.POST, request);
if (response == null || response.StatusCode != HttpStatusCode.Created || response.Data == null)
{
return(false);
}
return(response.Data.PasswordCredential.Password.Equals(password));
}
public async Task <ActionResult> SetPassword(string userName, SetPasswordRequest model)
{
var user = await this.userManager.FindByNameAsync(userName);
if (user == null)
{
return(this.NotFound());
}
var userId = await this.userManager.GetUserIdAsync(user);
if (string.IsNullOrEmpty(userId))
{
return(this.NotFound());
}
var currentUserId = this.userManager.GetUserId(this.User);
if (!userId.Equals(currentUserId, StringComparison.OrdinalIgnoreCase) &&
!this.User.IsInRole("Admin"))
{
return(this.Forbid());
}
var result = await this.userManager.AddPasswordAsync(user, model.NewPassword);
if (!result.Succeeded)
{
foreach (var error in result.Errors)
{
this.ModelState.AddModelError(string.Empty, error.Description);
}
return(this.BadRequest(this.ModelState));
}
return(this.Ok());
}
public async Task <IActionResult> SetPassword([FromBody] SetPasswordRequest model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = await _userManager.FindByIdAsync(User.FindFirst("id")?.Value);
if (user == null)
{
return(BadRequest(new string[] { "Could not find user!" }));
}
var addPasswordResult = await _userManager.AddPasswordAsync(user, model.NewPassword);
if (addPasswordResult.Succeeded)
{
return(Ok(addPasswordResult));
}
return(BadRequest(addPasswordResult.Errors.Select(x => x.Description)));
}
public async Task <IActionResult> SetPassword([FromRoute] string userId, [FromBody] SetPasswordRequest request)
{
var user = await _dbContext.Users.SingleOrDefaultAsync(x => x.Id == userId);
if (user == null)
{
return(NotFound());
}
var result = await _userManager.ResetPasswordAsync(user, request.Password, validatePassword : !request.BypassPasswordValidation.GetValueOrDefault());
if (!result.Succeeded)
{
return(BadRequest(result.Errors.ToValidationProblemDetails()));
}
var @event = new PasswordChangedEvent(SingleUserInfo.FromUser(user));
await _eventService.Publish(@event);
if (request.ChangePasswordAfterFirstSignIn == true)
{
await _userManager.SetPasswordExpiredAsync(user, true);
}
return(NoContent());
}
public Task SetPasswordAsync(SetPasswordRequest request)
{
return(SendAsync <SetPasswordRequest, object>(HttpMethod.Post, "/accounts/set-password", request, true,
false));
}
public List <string> ValidateChangePassword(SetPasswordRequest passwordValidationRequest)
{
return(_passwordQueryService.GetPolicyViolations(passwordValidationRequest.UserId, passwordValidationRequest.Password));
}
public async Task <Response <UserProfileResponse> > SetPasswordProfile(SetPasswordRequest setPasswordRequest, string access_token)
{
string json = JsonConvert.SerializeObject(setPasswordRequest);
return(await _apiService.Patch <Response <UserProfileResponse> >(Urls.SET_PASSWORD, json, access_token));
}
public async Task <Response> SetPassword(SetPasswordRequest password)
{
return(await _apiService.Patch <Response>(Urls.SET_PASSWORD, password));
}
SetPasswordResponse Microsoft.ActiveDirectory.Management.IADAccountManagement.SetPassword(ADSessionHandle handle, SetPasswordRequest request)
{
SetPasswordResponse setPasswordResponse = null;
ADDirectoryServiceConnection internalHandle = this.GetInternalHandle(handle);
if (internalHandle != null)
{
setPasswordResponse = internalHandle.SetPassword(request);
}
return(setPasswordResponse);
}
public BaseResponse Post(SetPasswordRequest request)
{
_log.StartLog(request);
try
{
_authProvider.SetPassword(this.GetSession().UserAuthName, request.NewPassword);
return new BaseResponse();
}
catch (Exception e)
{
_log.Fatal("error", e);
Errors.Add(e.Message + " " + e.StackTrace);
return new CreateUserResponse { Errors = Errors };
}
}
