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; }