/// <summary>
/// this method is used for check if the user exist
/// </summary>
/// <param name="login"> get the username, password, rememberme</param>
/// <returns> Update User Detail</returns>
public NewPasswordModel NewPassword(NewPasswordModel pass)
{
User eUser = new User();
NewPasswordModel bPass = new NewPasswordModel();
using (obj = new MotorMechsEntities())
{
eUser = obj.Users.Where(l => l.ForgetPasswordCode == new Guid(pass.ForgetPassUniqueCode) && l.ForgetPasswordStatus == true).FirstOrDefault();
eUser.Password = pass.NewPassword;
eUser.LastPasswordChangedDate = DateTime.Now;
eUser.ForgetPasswordStatus = false;
obj.SaveChanges();
bPass.List = eUser;
bPass.Message = "Update Success";
bPass.Status = true;
}
return(bPass);
}
public ActionResult ResetPasswordCodeValidation(NewPasswordModel model)
{
var message = "";
TestDatabaseEntities context = new TestDatabaseEntities();
if (model.ResetCode != null)
{
string newPassword = Crypto.Hash(model.NewPassword);
context.ChangePassword(newPassword, model.ResetCode);
message = "Password successfully changed";
ViewBag.Message = message;
return(RedirectToAction("ProfilePage"));
}
else
{
message = "Something went wrong. Redirecting to login page. Please contact support.";
ViewBag.Message = message;
return(RedirectToAction("Login"));
}
}
public async Task <IActionResult> resetPassword(NewPasswordModel newPasswordModel)
{
try
{
InfoLog(ControllerContext.ActionDescriptor.DisplayName);
var result = await _userService.UpdateNewPassword(newPasswordModel);
if (result.isSuccess != null && result.isSuccess == true)
{
return(Ok(result));
}
else
{
return(Ok(result));
}
}
catch (Exception exception)
{
return(ErrorInternal(exception, $"{ControllerContext.ActionDescriptor.DisplayName} Exception Message : {exception.Message} - {exception.InnerException}"));
}
}
public SendingMailResult SendNewPassword(string userName, string email, string newPassword)
{
var model = new NewPasswordModel
{
UserName = userName,
NewPassword = newPassword,
};
var htmlText = _viewConvertor.RenderRazorViewToString(MVC.EmailTemplates.Views._NewPassword, model);
var result = Send(new MailDocument
{
Body = htmlText,
Subject = "کلمه عبور جدید",
ToEmail = email
});
return(result);
}
public bool ChangePassword(string accid, NewPasswordModel param)
{
if (param == null)
{
return(false);
}
Account acc = context.Accounts.Find(accid);
if (acc == null)
{
return(false);
}
if (param.OldPassword != acc.Password)
{
return(false);
}
acc.Password = param.NewPassword;
context.SaveChangesAsync();
return(true);
}
public async Task <IActionResult> SaveNewPassword([FromBody] NewPasswordModel model)
{
var user = await _userManager.FindByIdAsync(model.UserId);
if (user == null)
{
return(BadRequest());
}
var code = Encoding.Unicode.GetString(Convert.FromBase64String(model.Code));
var result = await _userManager.ResetPasswordAsync(user, code, model.NewPassword);
if (result.Succeeded)
{
return(Ok());
}
return(BadRequest());
}
public async Task <IActionResult> NewPassword(NewPasswordModel model)
{
var user = await _userManager.FindByNameAsync(model.UserName);
if (user == null)
{
ModelState.AddModelError("", "Bir hata oluştu lütfen tekrar deneyin");
}
var token = await _userManager.GeneratePasswordResetTokenAsync(user);
if (!ModelState.IsValid)
{
return(View(model));
}
var result = await _userManager.ResetPasswordAsync(user, token, model.Password);
if (result.Succeeded)
{
return(RedirectToAction("login", "Account"));
}
return(View());
}
//public async Task<AccountEditModel> Register(RegisterAccountModel param)
//{
// var model = new AccountEditModel();
// if (param == null)
// return null;
// if (string.IsNullOrWhiteSpace(param.Mail))
// return null;
// string mail = param.Mail.Trim().ToLower();
// Account acc = await context.Accounts.FirstOrDefaultAsync(d => d.Mail == mail);
// if (acc == null)
// {
// acc = new Account();
// acc.Id = GuidGen.NewGUID();
// acc.Name = param.Name;
// acc.Password = Md5.CalcString(param.Password);
// acc.Mail = mail;
// acc.Frozened = false;
// acc.ActivationTime = DataHelper.ParseDateTime(param.ActivationTime);
// acc.ExpireTime = DataHelper.ParseDateTime(param.ExpireTime);
// acc.Type = param.Type;
// acc.Location = param.Location;
// acc.Phone = param.Phone;
// acc.OrganizationId = param.OrganizationId;
// if (param.Type == AppConst.AccountType_BrandAdmin)
// acc.Organization = await context.Organizations.FirstOrDefaultAsync(x => x.Id == param.OrganizationId);
// acc.DepartmentId = param.DepartmentId;
// //acc.Department = await context.Departments.FirstOrDefaultAsync(x => x.Id == param.DepartmentId);
// context.Accounts.Add(acc);
// await context.SaveChangesAsync();
// }
// model.Name = param.Name;
// model.Id = acc.Id;
// model.Mail = acc.Mail;
// //model.Password = acc.Password;
// model.Phone = acc.Phone;
// model.Location = acc.Location;
// model.Type = acc.Type;
// model.ActivationTime = DataHelper.FormatDateTime(acc.ActivationTime);
// model.ExpireTime = DataHelper.FormatDateTime(acc.ExpireTime);
// return model;
//}
public async Task <bool> ChangePasswordAsync(string accid, NewPasswordModel param)
{
if (param == null)
{
return(false);
}
Account acc = await context.Accounts.FindAsync(accid);
if (acc == null)
{
return(false);
}
if (param.OldPassword != acc.Password)
{
return(false);
}
acc.Password = param.NewPassword;
await context.SaveChangesAsync();
return(true);
}
public async Task <AuthResponse <string> > UpdateNewPassword(NewPasswordModel newPasswordModel)
{
AuthResponse <string> baseResponse = new AuthResponse <string>();
var user = await _userManager.FindByEmailAsync(newPasswordModel.Email);
var result = await _userManager.ResetPasswordAsync(user, newPasswordModel.Token, newPasswordModel.NewPassword);
if (result.Succeeded)
{
baseResponse.Result = "Kullancı Parolası Başarıyla Değiştirildi";
baseResponse.isSuccess = true;
}
else
{
foreach (var item in result.Errors)
{
var errorItem = new ErrorModel(item.Code, item.Description);
baseResponse.Errors.Add(errorItem);
}
baseResponse.isSuccess = false;
}
return(baseResponse);
}
public async Task <IActionResult> NewPassword([FromBody] NewPasswordModel model)
{
var user = await _userManager.FindByEmailAsync(model.Email);
if (user == null)
{
return(Unauthorized());
}
if (_passwordHasher.VerifyHashedPassword(user, user.PasswordHash, model.Password)
!= PasswordVerificationResult.Success)
{
return(Unauthorized());
}
var token = await _userManager.GeneratePasswordResetTokenAsync(user);
var result = await _userManager.ResetPasswordAsync(user, token, model.NewPassword);
if (result.Succeeded)
{
return(Ok());
}
return(BadRequest());
}
public ActionResult NewPassword([Bind(Include = "OldPassword,NewPassword,ConfirmNewPassword")] NewPasswordModel npm, string id)
{
if (UsersHelper.LoggedInUserUsername(Session) == null)
{
return(null);
}
if (!ModelState.IsValid)
{
return(PartialView(npm));
}
var user = _usersRepository.GetUserByUsername(id);
if (user == null)
{
return(null);
}
if (npm.OldPassword != user.Pass)
{
ViewBag.Message = "Old password is incorrect";
return(PartialView(npm));
}
if (npm.NewPassword == npm.OldPassword)
{
ViewBag.Message = "New password can't be same as old password.";
return(PartialView(npm));
}
if (npm.NewPassword != npm.ConfirmNewPassword)
{
ViewBag.Message = "New passwords don't match.";
return(PartialView(npm));
}
user.Pass = npm.NewPassword;
_usersRepository.UpdateUser(user);
ViewBag.Message = "Password has been successfully changed.";
return(PartialView("MessageModal"));
}
/// <summary>
/// Login to Sigob System with user credentials (validate entries)
/// </summary>
private async Task ChangePasswordLogin()
{
#region Exists values in change password fields and match values
if (string.IsNullOrEmpty(NewPassword))
{
await Application.Current.MainPage.DisplayAlert(
title : Languages.Error,
message : Languages.NewPasswordValidationMsg,
cancel : Languages.Cancel);
return;
}
if (string.IsNullOrEmpty(VerifyNewPassword))
{
await Application.Current.MainPage.DisplayAlert(
title : Languages.Error,
message : Languages.RepeatNewPasswordValidationMsg,
cancel : Languages.Cancel);
return;
}
if (NewPassword != VerifyNewPassword)
{
await Application.Current.MainPage.DisplayAlert(
title : Languages.Error,
message : Languages.PasswordsMatchValidationMsg,
cancel : Languages.Cancel);
return;
}
#endregion
#region API - Get Security Parameters for change password
this.IsRunning = true;
this.IsEnabled = false;
//Connect using API
this.apiService = new ApiService();
// 1. Verify connection
var connection = await this.apiService.CheckConnection();
if (!connection.IsSuccess)
{
this.IsRunning = false;
await Application.Current.MainPage.DisplayAlert(
title : Languages.Error,
message : connection.Message,
cancel : Languages.Cancel);
return;
}
// 2. Get the security parameters for connection.
var response = await this.apiService.GetList <string>(
Settings.UrlBaseApiSigob,
App.PrefixApiSigob,
apiSecurityController
);
if (!response.IsSuccess)
{
this.IsRunning = false;
this.IsEnabled = true;
await Application.Current.MainPage.DisplayAlert(
title : Languages.Error,
message : response.Message,
cancel : Languages.Cancel);
return;
}
#endregion
// 3. Call API Login
try
{
#region API - Post for Change Password and assign token
var parameters = (List <string>)response.Result;
var newLoginCredentials =
new NewPasswordModel()
{
Password = this.NewPassword,
Ip = parameters[1],
UserAgent = parameters[0],
};
response = await this.apiService.Put <NewSessionSigob>(
Settings.UrlBaseApiSigob,
App.PrefixApiSigob,
apiUserController,
Settings.Token,
Settings.DbToken,
newLoginCredentials);
if (!response.IsSuccess)
{
this.IsRunning = false;
this.IsEnabled = true;
await Application.Current.MainPage.DisplayAlert(
title : Languages.Error,
message : Languages.InvalidCredentials,
cancel : Languages.Cancel);
return;
}
//Get Session Model (Token and DbToken for logged user).
var sucessLogin = (NewSessionSigob)response.Result;
App.ActiveSession.AuthToken = sucessLogin.AuthToken;
App.ActiveSession.DatabaseToken = sucessLogin.DatabaseToken;
App.ActiveSession.LoggedUser.Username = sucessLogin.LoggedUser;
App.ActiveSession.LoggedUser.Password = sucessLogin.Password;
//Save persist token access values
Settings.Token = sucessLogin.AuthToken;
Settings.DbToken = sucessLogin.DatabaseToken;
//Successful change alert
await Application.Current.MainPage.DisplayAlert(
title : Languages.ChangePasswordTitle,
message : Languages.Success,
cancel : Languages.Ok);
// Main View Model Access values
var mainViewModel = MainViewModel.GetInstance();
mainViewModel.Token = sucessLogin.AuthToken;
mainViewModel.DbToken = sucessLogin.DatabaseToken;
//Back to Main Page
await App.Navigator.PopToRootAsync();
#endregion
}
catch (Exception ex)
{
await Application.Current.MainPage.DisplayAlert(
title : Languages.Error,
message : ex.Message,
cancel : Languages.Cancel);
}
finally
{
//If sucessfuly then clean entries user / password
this.IsRunning = false;
this.IsEnabled = true;
this.NewPassword = this.VerifyNewPassword = string.Empty;
}
}
public async Task <IActionResult> ResetPassword([FromBody] NewPasswordModel model)
{
var result = await _userService.ResetPassword(model);
return(WrapResponse(result, HttpStatusCode.OK));
}
public Task <AuthResponse <object> > UpdateNewPassword(NewPasswordModel newPasswordModel)
{
throw new NotImplementedException();
}
public ActionResult NewPassword()
{
NewPasswordModel npm = new NewPasswordModel();
return(PartialView(npm));
}
