public void ResetPassword()
{
string passwordToken = "qefh2FdMZAgMg0g7dcqbmUn8XOaTEJYFop3D1V7cSMX2J1LeXZ";
string password = "******";
KeyVaultClient KeyVault;
try
{
var azureServiceTokenProvider = new AzureServiceTokenProvider();
var _token = azureServiceTokenProvider.GetAccessTokenAsync("https://vault.azure.net").Result;
KeyVault = new KeyVaultClient(new KeyVaultClient.AuthenticationCallback(azureServiceTokenProvider.KeyVaultTokenCallback));
}
catch (Exception e)
{
throw e;
}
var bundle = KeyVault.GetSecretAsync("https://pr-kv-uks-dev.vault.azure.net/secrets/AppConnectionKey").Result;
string appAccessToken = bundle.Value;
ResetPasswordRequest request = new ResetPasswordRequest(connection, appAccessToken, passwordToken, password);
ResetPasswordResponse response = request.Send();
Assert.AreEqual(response.StatusCode, System.Net.HttpStatusCode.OK);
}
public async Task <IActionResult> ResetPassword([FromRoute] Guid activationCode,
[FromBody] ResetPasswordRequest request)
{
ResetPasswordResponse response = await _accountService.ResetPasswordAsync(request);
return(Result(response));
}
public ResetPasswordResponse ResetPassword(ResetPasswordRequest request)
{
var response = new ResetPasswordResponse();
response = this.GenerateToken(request);
return(response);
}
private ResetPasswordResponse GenerateToken(ResetPasswordRequest request)
{
var response = new ResetPasswordResponse();
///Try to save token to database
try
{
response.Salt = crypto.Salt != null ? crypto.Salt : crypto.GenerateSalt(crypto.HashIterations, crypto.SaltSize);
response.Email = request.Email;
response.ExpireDate = DateTime.Now.AddDays(3);
response.Token = crypto.Compute(request.Email, response.Salt);
//var entity = new ResetPassword { Email = response.Email, Token = response.Token, Salt = response.Salt, ExpireDate = response.ExpireDate };
var entity = response.MapTo <ResetPassword>();
DataContext.ResetPasswords.Add(entity);
DataContext.SaveChanges();
response.IsSuccess = true;
response.Message = "Password Token Successfully Created";
}
catch (System.InvalidOperationException x)
{
return(new ResetPasswordResponse
{
IsSuccess = false,
Message = x.Message
});
}
return(response);
}
public ResetPasswordResponse ResetPassword(ResetPasswordRequest request)
{
ResetPasswordResponse response = new ResetPasswordResponse();
response.Errors = new List <BusinessRule>();
User user = _repository
.FindAll().Where(u => u.Email == request.Email).FirstOrDefault();
if (user != null)
{
try
{
user.Status = 1;
_repository.Save(user);
_uow.Commit();
response.Result = true;
}
catch (Exception ex)
{
response.Errors.Add(new BusinessRule("Error", ex.Message));
response.Result = false;
}
}
else
{
response.Result = false;
}
return(response);
}
void HandleResetPasswordResponse(ResetPasswordResponse response)
{
resetPassword.Invoke(new Action(() =>
{
resetPassword.HandleResetPasswordResponse(response.Payload);
}));
}
public ResetPasswordResponse ResetPassword(ResetPasswordRequest request)
{
ResetPasswordResponse response = new ResetPasswordResponse();
try
{
Common.Helpers.ValidationHelper.ValidateRequiredField(request.Username, "User name");
Common.Helpers.ValidationHelper.ValidateUsername(request.Username);
UserController.SendPasswordResetEmail(request.Username);
}
catch (AuthenticationException ex)
{
throw new WebFaultException <string>(ex.Message, System.Net.HttpStatusCode.BadRequest);
}
catch (Common.Exceptions.ValidationException ex)
{
throw new WebFaultException <string>(ex.Message, System.Net.HttpStatusCode.BadRequest);
}
catch (Exception ex)
{
ExceptionHelper.Log(ex, string.Empty);
throw new WebFaultException <string>("An unknown error has occurred.", System.Net.HttpStatusCode.InternalServerError);
}
return(response);
}
public ActionResult Password(Password model)
{
if (ModelState.IsValid)
{
string connection = ConfigurationManager.AppSettings["InternalAPIURL"];
var appAccessToken = WebUtils.GetVaultSecret("AppConnectionKey");
ResetPasswordRequest resetRequest = new ResetPasswordRequest(connection, appAccessToken, model.token, model.password1);
ResetPasswordResponse resetResponse = resetRequest.Send();
if (resetResponse.StatusCode == System.Net.HttpStatusCode.OK)
{
TempData["Success"] = "Your password was changed!";
return(RedirectToAction("Login", "Account"));
}
else
{
TempData["Errors"] = "There was an error processing your request";
return(View(model));
}
}
else
{
return(View(model));
}
}
/// <summary>
/// Unmarshaller the response from the service to the response class.
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
{
ResetPasswordResponse response = new ResetPasswordResponse();
return(response);
}
public object Any(ResetPassword request)
{
var res = new ResetPasswordResponse();
var user = UserAuthRepository.GetUserAuthByUserName(request.Email);
if (null == user)
{
res.Success = false;
res.Message = "Invalid email address.";
return(res);
}
var secret = Cache.Get <string>($"password:secret:{user.Email}");
if (secret.IsNullOrEmpty() || !secret.Equals(request.Token))
{
res.Success = false;
res.Message = "Reset window expired.";
return(res);
}
UserAuthRepository.UpdateUserAuth(user, user, request.Password);
Cache.Remove($"password:secret:{user.Email}");
using (var service = ResolveService <AuthenticateService>())
{
return(service.Authenticate(new Authenticate
{
provider = AuthenticateService.CredentialsProvider,
UserName = user.Email,
Password = request.Password
}));
}
}
public ResetPasswordResponse ResetPassword(ResetPasswordRequest request)
{
var response = new ResetPasswordResponse().LinkTo(request)
.WithProcessResult(_userUowFactory.ResetPassword(request.UserKey, VerificationPurpose.ResetPassword,
request.PlainTextVerificationCode, request.NewPlainTextPassword));
return(response);
}
public ResetPasswordResponse GetUserByToken(ResetPasswordTokenRequest request)
{
var response = new ResetPasswordResponse();
response = this.GetResetPasswordDetail(new ResetPasswordTokenRequest {
Token = request.Token
});
return(response);
}
private async void XFBtnResetPassword_Clicked(object sender, EventArgs e)
{
// Navigation.PushAsync(new RegisterStepOnePage());
if (IsBusy)
{
return;
}
IsBusy = true;
try
{
if (!CrossConnectivity.Current.IsConnected)
{
await DisplayAlert("", "No Network Connection!", "(X)");
}
else
{
if (string.IsNullOrEmpty(_objResetPasswordRequest.otp) ||
string.IsNullOrEmpty(_objResetPasswordRequest.newPassword) ||
string.IsNullOrEmpty(_objResetPasswordRequest.confirmPassword))
{
await DisplayAlert("", "please fill all field first!", "(X)");
}
else
{
if (_objResetPasswordRequest.newPassword != _objResetPasswordRequest.confirmPassword)
{
await DisplayAlert("", "Confirm Password did not match!", "(X)");
}
else
{
_objResetPasswordResponse = await _apiService.ResetPasswordAsync(new Get_API_Url().CommonBaseApi(_baseUrl), false, new HeaderModel(), _objResetPasswordRequest);
var Response = _objResetPasswordResponse.response;
if (Response.statusCode == 200)
{
await DisplayAlert("", " Password Chnaged Successfully!!", "(X)");
await App.NavigationPage.Navigation.PushAsync(new LoginPage());
}
else
{
await DisplayAlert("", "Please try again!", "(X)");
}
}
}
}
}
catch (Exception ex)
{
var msg = ex.Message;
}
finally
{
IsBusy = false;
}
}
public async Task <ActionResult> ResetPassword([FromBody] Models.Request.ResetPasswordRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
ResetPasswordResponse response = await _mediator.Send(new ResetPasswordCommand(request.Id, request.NewPassword));
return(_mapper.Map <JsonContentResult>(response));
}
public ConfirmOTPPage()
{
InitializeComponent();
NavigationPage.SetHasNavigationBar(this, false);
_objResetPasswordRequest = new ResetPasswordRequest();
_objResetPasswordResponse = new ResetPasswordResponse();
BindingContext = _objResetPasswordRequest;
_apiServices = new RestApi();
_baseUrl = Settings.Url + Domain.ResetPasswordApiConstant;
}
public async Task <ResetPasswordResponse> ResetPasswordAsync(ResetPasswordRequest request)
{
var response = new ResetPasswordResponse();
var user = await _users.FirstOrDefaultAsync(d => d.UserName == request.UserName);
if (user == null)
{
return(response.ReturnWithCode(AuthenticationMessageHelper.Code.ResetPasswordFailedInvalidUser.Value(), AuthenticationMessageHelper.ResponseMessages));
}
var passwordBanedList = _options.Value.PasswordsBanList;
if (passwordBanedList.Any(d => d == request.NewPassword))
{
return(response.ReturnWithCode(AuthenticationMessageHelper.Code.ResetPasswordSimplePass.Value(),
AuthenticationMessageHelper.ResponseMessages));
}
switch (user.UserStatus)
{
case UserStatus.Fired:
return(response.ReturnWithCode(AuthenticationMessageHelper.Code.ResetPasswordFailedYouAreFired.Value(), AuthenticationMessageHelper.ResponseMessages));
case UserStatus.Inactive:
return(response.ReturnWithCode(AuthenticationMessageHelper.Code.ResetPasswordFailedYouAreInactive.Value(), AuthenticationMessageHelper.ResponseMessages));
}
if (!user.EmailTokenLifespanDateTimeOn.HasValue || string.IsNullOrEmpty(user.EmailToken))
{
user.CleanEmailToken();
await _unitOfWork.SaveChangesAsync();
return(response.ReturnWithCode(AuthenticationMessageHelper.Code.ResetPasswordFailedInvalidTokenData.Value(), AuthenticationMessageHelper.ResponseMessages));
}
var decryptEmailToken = _stringEncryption.Decrypt(user.EmailToken);
if (decryptEmailToken != request.ResetPasswordToken)
{
user.CleanEmailToken();
await _unitOfWork.SaveChangesAsync();
return(response.ReturnWithCode(AuthenticationMessageHelper.Code.ResetPasswordFailedInvalidTokenCode.Value(), AuthenticationMessageHelper.ResponseMessages));
}
if (user.EmailTokenLifespanDateTimeOn.Value <= DateTimeOffset.UtcNow.IranStandardTimeNow())
{
user.CleanEmailToken();
await _unitOfWork.SaveChangesAsync();
return(response.ReturnWithCode(AuthenticationMessageHelper.Code.ResetPasswordFailedExpiredTokenCode.Value(), AuthenticationMessageHelper.ResponseMessages));
}
user.PasswordHash = _securityService.GetSha256Hash(request.NewPassword);
user.CleanEmailToken();
await _unitOfWork.SaveChangesAsync();
return(response.ReturnWithCode(AuthenticationMessageHelper.Code.ResetPasswordSuccess.Value(), AuthenticationMessageHelper.ResponseMessages));
}
public async void ResetPassword()
{
IsResettingPassword = true;
try
{
var email = Email.Trim();
var username = Username.Trim();
ResetPasswordResponse resp = await WebHelper.Download <ResetPasswordRequest, ResetPasswordResponse>(
Website.URL + "resetpasswordmodern",
new ResetPasswordRequest()
{
Username = username, Email = email
},
Website.ApiKey);
if (resp == null)
{
return;
}
if (resp.Error != null)
{
var dontWait = new PortableMessageDialog(resp.Error, PowerPlannerResources.GetString("ResetPassword_String_ErrorResettingPassword")).ShowAsync();
}
else
{
IsResettingPassword = false;
var loginViewModel = Parent.GetPopupViewModelHost()?.Popups.OfType <LoginViewModel>().FirstOrDefault();
if (loginViewModel != null)
{
loginViewModel.Username = username;
}
await new PortableMessageDialog(resp.Message, PowerPlannerResources.GetString("ResetPassword_String_ResetSuccessHeader")).ShowAsync();
base.RemoveViewModel();
}
}
catch (OperationCanceledException) { }
catch (Exception ex)
{
TelemetryExtension.Current?.TrackException(ex);
var dontWait = new PortableMessageDialog(PowerPlannerResources.GetStringOfflineExplanation(), PowerPlannerResources.GetString("ResetPassword_String_ErrorResettingPassword")).ShowAsync();
}
finally
{
IsResettingPassword = false;
}
}
public ResetPasswordPage()
{
InitializeComponent();
NavigationPage.SetBackButtonTitle(this, "");
//NavigationPage.SetHasNavigationBar(this, false);
_objResetPasswordRequest = new ResetPasswordRequest();
this.BindingContext = _objResetPasswordRequest;
_objResetPasswordResponse = new ResetPasswordResponse();
_apiService = new RestApi();
_baseUrl = Domain.Url + Domain.ResetPasswordApiConstant;
}
public async Task <ResetPasswordResponse> ResetPassword(ResetPasswordRequest request)
{
var response = new ResetPasswordResponse();
using (var uow = _uowFactory.GetUnitOfWork())
{
var userToken = await uow.UserRepo.GetUserTokenByGuid(new Repositories.DatabaseRepos.UserRepo.Models.GetUserTokenByGuidRequest()
{
Guid = new Guid(request.Token)
});
if (userToken == null)
{
response.Notifications.AddError("Token does not exist");
return(response);
}
if (userToken.Type_Id != TokenTypeEnum.ResetPassword)
{
response.Notifications.AddError("Invalid token provided");
return(response);
}
if (userToken.Processed)
{
response.Notifications.AddError($"This account has already performed a password reset");
return(response);
}
await uow.UserRepo.UpdateUserPassword(new Repositories.DatabaseRepos.UserRepo.Models.UpdateUserPasswordRequest()
{
User_Id = userToken.User_Id,
Password_Hash = PasswordHelper.HashPassword(request.NewPassword),
Updated_By = ApplicationConstants.SystemUserId
});
await uow.UserRepo.ProcessUserToken(new Repositories.DatabaseRepos.UserRepo.Models.ProcessUserTokenRequest()
{
Guid = userToken.Guid,
Updated_By = ApplicationConstants.SystemUserId
});
uow.Commit();
}
await _sessionManager.WriteSessionLogEvent(new Models.ManagerModels.Session.CreateSessionLogEventRequest()
{
EventKey = SessionEventKeys.PasswordUpdated
});
response.Notifications.Add($"Your password has been reset", NotificationTypeEnum.Success);
return(response);
}
public ResetPasswordResponse ResetPassword(ResetPasswordRequest request)
{
var response = new ResetPasswordResponse {
Success = true
};
return(response);
// var user = UserRepository.GetUserByUsername(request.Username);
// if (user == null)
// {
// response.Success = false;
// response.FailureInformation = "Invalid username.";
// }
// else
// {
// string password = DataUtils.GenerateUniqueId(10);
// user.Password = password;
// UserRepository.SaveUser(user);
// // TODO: Use Code Framework Configuration Settings and Email Sending?
// // or Westwind.Utilities.Configuration?
// string appName = ConfigurationManager.AppSettings["AppName"] ?? "Wikinome";
// var smtp = new SmtpClientNative();
// smtp.MailServer = ConfigurationManager.AppSettings["MailServer"];
// smtp.Username = ConfigurationManager.AppSettings["MailUsername"];
// smtp.Password = ConfigurationManager.AppSettings["MailPassword"];
// string useSsl = ConfigurationManager.AppSettings["MailUseSsl"];
// smtp.SenderEmail = ConfigurationManager.AppSettings["MailSenderEmail"];
// if (!string.IsNullOrEmpty(useSsl) && useSsl.ToLower() == "true")
// smtp.UseSsl = true;
// smtp.Subject = appName + " Password Recovery";
// smtp.Recipient = user.Username;
// smtp.Message = $@"This message contains a temporary password so you can reset your password
//Please use this temporary password to sign in, then access your account profile and change
//the password to something you can remember.
//Your temporary password is: {password}
//The {appName} Team";
// if (!smtp.SendMail())
// {
// response.Success = false;
// response.FailureInformation = "Failed to send password reset email: " + smtp.ErrorMessage;
// }
// }
// return response;
}
public void ResetPassword_Success(string name)
{
RunInitSql(name, "ConnectionStringAccounts");
// 1. resetting password
ResetPassword updateReq = base.PrepareRequest <ResetPassword>(name);
ResetPasswordResponse updateRes = Post <ResetPassword, ResetPasswordResponse>("ResetPassword", updateReq);
RunFinalizeSql(name, "ConnectionStringAccounts");
Assert.True(updateRes.Success, "Password was not updated - success = false");
Assert.IsEmpty(updateRes.Errors, "Unexpected errors returned");
}
private async void BtnSendpassword_Clicked(object sender, EventArgs e)
{
try
{
if (!CrossConnectivity.Current.IsConnected)
{
DependencyService.Get <IToast>().Show("No Network Connection!!");
}
else
{
if (string.IsNullOrEmpty(_objResetPasswordRequest.Password) || string.IsNullOrEmpty(_objResetPasswordRequest.ConfirmPassword) || _objResetPasswordRequest.OTP <= 0)
{
DependencyService.Get <IToast>().Show("Email is Required!!");
}
else
{
if (_objResetPasswordRequest.Password == _objResetPasswordRequest.ConfirmPassword)
{
await Navigation.PushPopupAsync(new LoadingPopPage());
_objResetPasswordResponse = await _apiServices.ResetPasswordAsync(new Get_API_Url().CommonBaseApi(_baseUrl), false, new HeaderModel(), _objResetPasswordRequest);
var Response = _objResetPasswordResponse;
if (Response.StatusCode == 200)
{
DependencyService.Get <IToast>().Show(Response.Message);
await Navigation.PopAllPopupAsync();
await App.NavigationPage.Navigation.PushAsync(new ConfirmOTPPage());
}
else
{
await Navigation.PopAllPopupAsync();
DependencyService.Get <IToast>().Show(Response.Message);
}
}
else
{
DependencyService.Get <IToast>().Show("New Password & Confirm Password didn't Match!! ");
}
}
}
}
catch (Exception ex)
{
var msg = ex.Message;
}
}
private void OnPasswordRequestResponse(ResetPasswordResponse response, ErrorResponse error)
{
m_LoginCanvasGroup.interactable = true;
if (error == null)
{
InfoDialog.Create("Request Sent!", "Reset password email has been sent!", OnCloseInfoDialog);
}
else
{
// Error occurred
Debug.LogError(error.ToDeveloperMessage(true));
InfoDialog.Create("", error.ToString(), OnCloseInfoDialog);
}
}
public async Task <UserManagerResponse> ResetPasswordAsync(ResetPasswordResponse model)
{
var user = await _userManger.FindByEmailAsync(model.Email);
if (user == null)
{
return new UserManagerResponse
{
IsSuccess = false,
Message = "No user associated with email",
}
}
;
if (model.NewPassword != model.ConfirmPassword)
{
return new UserManagerResponse
{
IsSuccess = false,
Message = "Password doesn't match its confirmation",
}
}
;
var decodedToken = WebEncoders.Base64UrlDecode(model.Token);
string normalToken = Encoding.UTF8.GetString(decodedToken);
var result = await _userManger.ResetPasswordAsync(user, normalToken, model.NewPassword);
if (result.Succeeded)
{
return new UserManagerResponse
{
Message = "Password has been reset successfully!",
IsSuccess = true,
}
}
;
return(new UserManagerResponse
{
Message = "Something went wrong",
IsSuccess = false,
Errors = result.Errors.Select(e => e.Description),
});
}
}
}
public Task <bool> ResetPasswordAsync(string targetEmail, CancellationTokenSource cancellationTokenSource) =>
Task <bool> .Run(async() => {
bool completion = false;
if (!CrossConnectivity.Current.IsConnected)
{
throw new InvalidOperationException(AppConsts.ERROR_INTERNET_CONNECTION);
}
ResetPasswordRequest resetPasswordRequest = new ResetPasswordRequest()
{
Data = new ResetPasswordDataModel()
{
Identificator = targetEmail
},
Url = GlobalSettings.Instance.Endpoints.AuthenticationEndpoints.ResetPassword
};
ResetPasswordResponse resetPasswordResponse = null;
try {
resetPasswordResponse = await _requestProvider.PostAsync <ResetPasswordRequest, ResetPasswordResponse>(resetPasswordRequest);
completion = resetPasswordResponse != null;
}
catch (ServiceAuthenticationException exc) {
_identityUtilService.RefreshToken();
completion = false;
throw exc;
}
catch (Exception ex) {
Crashes.TrackError(ex);
ResetPasswordResponse badResetPasswordResponse = JsonConvert.DeserializeObject <ResetPasswordResponse>(ex.Message);
string output = string.Format("{0} {1}",
badResetPasswordResponse.Identificator?.FirstOrDefault(),
badResetPasswordResponse.Errors?.FirstOrDefault());
output = (string.IsNullOrWhiteSpace(output) || string.IsNullOrEmpty(output)) ? COMMON_RESET_PASSWORD_ERROR : output;
completion = false;
throw new InvalidOperationException(output.Trim());
}
return(completion);
}, cancellationTokenSource.Token);
public async Task <IActionResult> ResetPassword([FromForm] ResetPasswordResponse model)
{
if (ModelState.IsValid)
{
var result = await _userService.ResetPasswordAsync(model);
if (result.IsSuccess)
{
return(Ok(result));
}
return(BadRequest(result));
}
return(BadRequest("Some properties are not valid"));
}
public void Handle_GivenSuccessfulUseCaseResponse_SetsId()
{
// arrange
var presenter = new ResetPasswordPresenter();
// act
presenter.Handle(new UseCaseResponseMessage("1234", true));
// assert
ResetPasswordResponse response = Serialization.JsonSerializer.DeSerializeObject <ResetPasswordResponse>(presenter.ContentResult.Content);
Assert.Equal((int)HttpStatusCode.OK, presenter.ContentResult.StatusCode);
Assert.NotNull(response);
Assert.Null(response.Errors);
Assert.True(response.Success);
}
public async Task <ResetPasswordResponse> ResetPasswordAsync(ResetPassword peticion)
{
Contrasenia = new ResetPasswordResponse();
try
{
var solicitud = await EGuardianAPI.PostAsync(Constants.Endpoint_Auth_ResetPassword + peticion.parametros, null);
solicitud.EnsureSuccessStatusCode();
string respuesta = await solicitud.Content.ReadAsStringAsync();
Contrasenia = JsonConvert.DeserializeObject <ResetPasswordResponse>(respuesta);
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine("ERROR: " + e.Message);
}
return(Contrasenia);
}
public IActionResult ForgotPassword(ForgotPasswordViewModel model)
{
var _user = new AuthenticateResponse
{
MembershipKey = 1006979, //1007435,
EmailAddress = "*****@*****.**", //"*****@*****.**",
FirstName = "Tolulope",
LastName = "Olusakin",
FullName = "Olusakin Tolulope S"//"Funmilayo Ruth Adeyemi",
};
ResetPasswordResponse response = new ResetPasswordResponse();
try
{
var resetRequest = new ResetPasswordRequest
{
Username = model.Username,
EmailAddress = model.EmailAddress
};
response = _clientService.ResetPassword(resetRequest);
if (response.ResponseCode == "00" || response.ResponseCode == "0")
{
var msg = "Success: " + response.ResponseMessage;
ViewBag.message = msg;
return(View(model));
}
else
{
ViewBag.message = response.ResponseMessage;
}
}
catch (Exception ex)
{
ViewBag.message = ex.Message;
Utilities.ProcessError(ex, _contentRootPath);
_logger.LogError(null, ex, ex.Message);
}
return(View(model));
}
public ResetPasswordResponse SendResetPasswordMail(ResetPasswordRequest req)
{
User user = _context.Users.Where(p => p.Email == req.Email && p.Active)
.Select(s => s).FirstOrDefault();
UserActivation usersActivation = new UserActivation();
usersActivation.User = user;
usersActivation.StartTime = DateTime.Now;
usersActivation.ActivationCode = GenerateActivationCode();
usersActivation.ActivationType = ActivationType.PasswordReset;
_mailService.SetActivation(usersActivation.Adapt <Activation>());
_mailService.SetEmailType(EmailType.PasswordReset);
_mailService.SetMailBoxes = ConvertUserToMailBoxesArray(user);
_mailService.SetEmailMessage();
_mailService.SendEmailAsync();
_context.UserActivations.Add(usersActivation);
_context.SaveChangesAsync();
ResetPasswordResponse res = new ResetPasswordResponse();
res.isResetMailSent = true;
return(res);
}
public ResetPasswordResponse ResetPassword(ResetPasswordRequest request)
{
ResetPasswordResponse response = new ResetPasswordResponse();
try
{
Common.Helpers.ValidationHelper.ValidateRequiredField(request.Username, "User name");
Common.Helpers.ValidationHelper.ValidateUsername(request.Username);
UserController.SendPasswordResetEmail(request.Username);
}
catch (AuthenticationException ex)
{
throw new WebFaultException<string>(ex.Message, System.Net.HttpStatusCode.BadRequest);
}
catch (Common.Exceptions.ValidationException ex)
{
throw new WebFaultException<string>(ex.Message, System.Net.HttpStatusCode.BadRequest);
}
catch (Exception ex)
{
ExceptionHelper.Log(ex, string.Empty);
throw new WebFaultException<string>("An unknown error has occurred.", System.Net.HttpStatusCode.InternalServerError);
}
return response;
}
public ResetPasswordResponse ResetPassword(ResetPasswordRequest request)
{
var response = new ResetPasswordResponse();
try
{
if (WebSecurity.ResetPassword(request.ResetPasswordToken, request.NewPassword))
{
response.Status = StatusCode.OK;
}
else
{
response.Status = StatusCode.Unauthorized;
}
}
catch (Exception ex)
{
response.Status = StatusCode.InternalServerError;
this.exceptionHandler.HandleException(ex);
}
return response;
}
