public IActionResult Reset(ResetPasswordViewModel resetPasswordViewModel)
{
if (ModelState.IsValid)
{
var userid = Convert.ToString(HttpContext.Session.GetString("VerificationUserId"));
var getuserdetails = _userRepository.GetUserbyUserId(Convert.ToInt64(userid));
if (!string.Equals(resetPasswordViewModel.Password, resetPasswordViewModel.ConfirmPassword, StringComparison.Ordinal))
{
TempData["Reset_Error_Message"] = "Password Does not Match";
return(View(resetPasswordViewModel));
}
else
{
var salt = GenerateRandomNumbers.RandomNumbers(20);
var saltedpassword = GenerateHashSha512.Sha512(resetPasswordViewModel.Password, salt);
var result = _userRepository.UpdatePasswordandHistory(getuserdetails.UserId, saltedpassword, salt, "R");
if (result > 0)
{
var updateresult = _verificationRepository.UpdateResetVerification(getuserdetails.UserId);
return(RedirectToAction("Login", "Portal"));
}
else
{
TempData["Reset_Error_Message"] = "Something Went Wrong Please try again!";
return(View(resetPasswordViewModel));
}
}
}
return(View(resetPasswordViewModel));
}
// GET: PasswordReset
public ActionResult Reset(ResetPasswordModel resetPasswordModel)
{
if (ModelState.IsValid)
{
var userId = Convert.ToInt64(Session["VerificationUserId"]);
if (!string.Equals(resetPasswordModel.Password, resetPasswordModel.ConfirmPassword, StringComparison.Ordinal))
{
TempData["Reset_Error_Message"] = "Password Does not Match";
return(View(resetPasswordModel));
}
else
{
var salt = GenerateRandomNumbers.RandomNumbers(20);
var saltedpassword = GenerateHashSha512.Sha512(resetPasswordModel.Password, salt);
var result = _iPassword.UpdatePasswordandHistory(userId, saltedpassword, salt, "R");
if (result)
{
var updateresult = _verification.UpdateResetVerification(userId);
Session["VerificationUserId"] = null;
return(RedirectToAction("Login", "Login"));
}
else
{
TempData["Reset_Error_Message"] = "Something Went Wrong Please try again!";
return(View(resetPasswordModel));
}
}
}
return(View(resetPasswordModel));
}
private void Send(User user)
{
var emailVerficationToken = GenerateHashSha256.ComputeSha256Hash((GenerateRandomNumbers.RandomNumbers(6)));
_verificationRepository.SendResetVerificationToken(user.UserId, emailVerficationToken);
MailMessage message = new MailMessage();
SmtpClient smtpClient = new SmtpClient();
try
{
MailAddress fromAddress = new MailAddress(_appSettings.EmailFrom);
message.From = fromAddress;
message.To.Add(user.Email);
message.Subject = "Welcome to Web Secure";
message.IsBodyHtml = true;
message.Body = SendVerificationEmail(user, emailVerficationToken);
smtpClient.Host = _appSettings.Host;
smtpClient.Port = Convert.ToInt32(_appSettings.Port);
smtpClient.EnableSsl = true;
smtpClient.UseDefaultCredentials = false;
smtpClient.Credentials = new System.Net.NetworkCredential(_appSettings.EmailFrom, _appSettings.Password);
smtpClient.Send(message);
}
catch (Exception)
{
throw;
}
}
public IActionResult ForgotPassword(ForgotPasswordViewModel forgotPasswordViewModel)
{
if (!_userMasterQueries.CheckUserExists(forgotPasswordViewModel.UserName))
{
ModelState.AddModelError("", "Entered Username or Password is Invalid");
}
else
{
var userdetails = _userMasterQueries.GetUserbyUserName(forgotPasswordViewModel.UserName);
var token = HashHelper.CreateHashSHA256((GenerateRandomNumbers.GenerateRandomDigitCode(6)));
var body = _emailSender.CreateVerificationEmail(userdetails, token);
_unitOfWorkEntityFramework.VerificationCommand.SendResetVerificationToken(userdetails.UserId, token);
_unitOfWorkEntityFramework.Commit();
MessageTemplate messageTemplate = new MessageTemplate()
{
ToAddress = userdetails.EmailId,
Subject = "Welcome to Frapper",
Body = body
};
_emailSender.SendMailusingSmtp(messageTemplate);
TempData["ForgotPasswordMessage"] = "An email has been sent to the address you have registered." +
"Please follow the link in the email to complete your password reset request";
return(RedirectToAction("ForgotPassword", "Portal"));
}
return(View());
}
public void TestGetRandomIntThrowsExceptionWithBadInput()
{
var objectUnderTest = new GenerateRandomNumbers();
Action actionThatShouldThowException = () => objectUnderTest.GetRandomInt(1, 0);
actionThatShouldThowException.ShouldThrow <ArgumentOutOfRangeException>();
}
public IActionResult Register(RegisterViewModel registerViewModel)
{
if (ModelState.IsValid)
{
if (_userRepository.CheckUserExists(registerViewModel.UserName))
{
ModelState.AddModelError("", "Entered Username Already Exists");
return(View(registerViewModel));
}
if (_userRepository.CheckUserExists(registerViewModel.Email))
{
ModelState.AddModelError("", "Entered EmailId Already Exists");
return(View(registerViewModel));
}
if (_userRepository.CheckUserExists(registerViewModel.Phoneno))
{
ModelState.AddModelError("", "Entered Phoneno Already Exists");
return(View(registerViewModel));
}
if (!string.Equals(registerViewModel.Password, registerViewModel.ConfirmPassword,
StringComparison.Ordinal))
{
TempData["Registered_Error_Message"] = "Password Does not Match";
return(View(registerViewModel));
}
var salt = GenerateRandomNumbers.RandomNumbers(20);
var saltedpassword = GenerateHashSha512.Sha512(registerViewModel.Password, salt);
User user = new User()
{
FullName = registerViewModel.FullName,
CreatedDate = DateTime.Now,
PasswordHash = saltedpassword,
Status = true,
UserId = 0,
Username = registerViewModel.UserName,
Email = registerViewModel.Email,
Phoneno = registerViewModel.Phoneno
};
var userId = _userRepository.RegisterUser(user, salt);
if (userId > 0)
{
Send(userId, registerViewModel);
TempData["Registered_Success_Message"] = "User Registered Successfully";
}
else
{
TempData["Registered_Error_Message"] = "Error While Registrating User Successfully";
}
}
return(RedirectToAction("Register", "Registration"));
}
public void Any(GenerateRandomNumbers request)
{
Task.Run(async() =>
{
for (var counter = 0; counter < request.Count; counter++)
{
await Task.Delay(request.DelayInMs);
//ServerEvents.NotifySubscription(request.RequestId.ToString(), "", new Random().NextDouble());
ServerEvents.NotifyChannel(request.RequestId.ToString(), "", new Random().NextDouble());
}
});
}
public ActionResult Create(CreateUserViewModel createUserViewModel)
{
try
{
if (ModelState.IsValid)
{
if (_iUserMaster.CheckEmailIdExists(createUserViewModel.EmailId))
{
TempData["MessageCreateUsersErrors"] = "EmailId Already Exists";
}
else if (_iUserMaster.CheckMobileNoExists(createUserViewModel.MobileNo))
{
TempData["MessageCreateUsersErrors"] = "MobileNo Already Exists";
}
else if (_iUserMaster.CheckUsernameExists(createUserViewModel.UserName))
{
ModelState.AddModelError("", "Username already exists");
}
else
{
createUserViewModel.FirstName = UppercaseFirst(createUserViewModel.FirstName);
createUserViewModel.LastName = UppercaseFirst(createUserViewModel.LastName);
var usermaster = AutoMapper.Mapper.Map <Usermaster>(createUserViewModel);
usermaster.Status = true;
usermaster.CreateDate = DateTime.Now;
usermaster.UserId = 0;
usermaster.CreatedBy = Convert.ToInt32(_sessionHandler.UserId);
var salt = GenerateRandomNumbers.RandomNumbers(20);
var saltedpassword = GenerateHashSha512.Sha512(createUserViewModel.Password, salt);
var userId = _iUserMaster.AddUser(usermaster, saltedpassword, salt, createUserViewModel.RoleId);
if (userId != -1)
{
TempData["MessageCreateUsers"] = "User Created Successfully";
}
return(RedirectToAction("Create", "CreateUsers"));
}
createUserViewModel.ListRole = _iRole.GetAllActiveRolesNotAgent();
return(View("Create", createUserViewModel));
}
else
{
createUserViewModel.ListRole = _iRole.GetAllActiveRolesNotAgent();
return(View("Create", createUserViewModel));
}
}
catch
{
throw;
}
}
public ActionResult ChangePassword(ChangePasswordFirstLoginModel changePassword)
{
if (ModelState.IsValid)
{
var storedUserpassword = _password.GetPasswordbyUserId(Convert.ToInt64(Session["ChangePasswordUserId"]));
var usersalt = _userMaster.GetUserSaltbyUserid(Convert.ToInt64(Session["ChangePasswordUserId"]));
var userrole = Session["ChangeRoleId"];
var generatehash = GenerateHashSha512.Sha512(changePassword.CurrentPassword, usersalt.PasswordSalt);
var rolesModel = _savedAssignedRoles.GetAssignedRolesbyUserId(Convert.ToInt64(Session["ChangePasswordUserId"]));
if (changePassword.CurrentPassword == changePassword.NewPassword)
{
ModelState.AddModelError("", @"New Password Cannot be same as Old Password");
return(View(changePassword));
}
if (!string.Equals(storedUserpassword, generatehash, StringComparison.Ordinal))
{
ModelState.AddModelError("", "Current Password Entered is InValid");
return(View(changePassword));
}
if (!string.Equals(changePassword.NewPassword, changePassword.ConfirmPassword, StringComparison.Ordinal))
{
TempData["ChangePasswordErrorMessage"] = "Something Went Wrong Please Try Again!";
return(View(changePassword));
}
else
{
var userid = Convert.ToInt64(Session["ChangePasswordUserId"]);
var usermasterModel = _userMaster.GetUserById(userid);
var salt = GenerateRandomNumbers.RandomNumbers(20);
var saltedpassword = GenerateHashSha512.Sha512(changePassword.NewPassword, salt);
var result = _password.UpdatePasswordandHistory(userid, saltedpassword, salt, "C");
var resultIsFirstLogin = _userMaster.UpdateIsFirstLogin(userid);
if (result && resultIsFirstLogin > 0)
{
TempData["ChangePasswordMessage"] = "Password Changed Successfully You might need to sign in again";
AssignSessionValues(usermasterModel, rolesModel);
return(RedirectionManager(usermasterModel, rolesModel));
}
else
{
TempData["ChangePasswordErrorMessage"] = "Something Went Wrong Please Try Again!";
return(View(changePassword));
}
}
}
return(View(changePassword));
}
public IActionResult Changepassword(ChangePasswordViewModel changePasswordViewModel)
{
if (ModelState.IsValid)
{
var userid = Convert.ToString(HttpContext.Session.GetString(AllSessionKeys.UserId));
var getuserdetails = _userMasterQueries.GetUserDetailsbyUserId(Convert.ToInt64(userid));
var usersalt = _userTokensQueries.GetUserSaltbyUserid(getuserdetails.UserId);
var generatehash = HashHelper.CreateHashSHA512(changePasswordViewModel.CurrentPassword, usersalt.PasswordSalt);
if (changePasswordViewModel.CurrentPassword == changePasswordViewModel.Password)
{
ModelState.AddModelError("", @"New Password Cannot be same as Old Password");
return(View(changePasswordViewModel));
}
if (!string.Equals(getuserdetails.PasswordHash, generatehash, StringComparison.Ordinal))
{
ModelState.AddModelError("", "Current Password Entered is InValid");
return(View(changePasswordViewModel));
}
if (!string.Equals(changePasswordViewModel.Password, changePasswordViewModel.ConfirmPassword, StringComparison.Ordinal))
{
_notificationService.DangerNotification("Message", "Password Does not Match!");
return(View(changePasswordViewModel));
}
else
{
var salt = GenerateRandomNumbers.GenerateRandomDigitCode(20);
var saltedpassword = HashHelper.CreateHashSHA512(changePasswordViewModel.Password, salt);
_unitOfWorkEntityFramework.UserMasterCommand.UpdatePasswordandHistory(getuserdetails.UserId, saltedpassword, salt, "C");
var result = _unitOfWorkEntityFramework.Commit();
if (result)
{
_notificationService.SuccessNotification("Message", "Your Password Changed Successfully!");
var registerVerificationobj = _verificationQueries.GetRegistrationGeneratedToken(getuserdetails.UserId);
_unitOfWorkEntityFramework.VerificationCommand.UpdateRegisterVerification(registerVerificationobj);
return(RedirectToAction("Changepassword", "UserDashboard"));
}
else
{
_notificationService.DangerNotification("Message", "Something Went Wrong Please try again!");
return(View(changePasswordViewModel));
}
}
}
return(View(changePasswordViewModel));
}
public ActionResult Create(CreateNewUserViewModel createUserViewModel)
{
try
{
if (ModelState.IsValid)
{
if (_iUserMaster.CheckEmailIdExists(createUserViewModel.EmailId))
{
TempData["MessageCreateUsersErrors"] = "EmailId Already Exists";
}
else if (_iUserMaster.CheckMobileNoExists(createUserViewModel.MobileNo))
{
TempData["MessageCreateUsersErrors"] = "MobileNo Already Exists";
}
else
{
string username = GenerateUserName(createUserViewModel);
Usermaster usermaster = new Usermaster();
usermaster.Status = true;
usermaster.CreateDate = DateTime.Now;
usermaster.UserId = 0;
usermaster.FirstName = createUserViewModel.FirstName;
usermaster.LastName = createUserViewModel.LastName;
usermaster.EmailId = createUserViewModel.EmailId;
usermaster.MobileNo = createUserViewModel.MobileNo;
usermaster.UserName = username;
usermaster.CreatedBy = Convert.ToInt32(_sessionHandler.UserId);
usermaster.Gender = createUserViewModel.Gender;
var salt = GenerateRandomNumbers.RandomNumbers(20);
var password = GeneratePassword(createUserViewModel, salt);
var userId = _iUserMaster.AddUser(usermaster, password, salt, Convert.ToInt16(StatusMain.Roles.User));
if (userId != -1)
{
TempData["MessageCreateUsers"] = $"User Created Successfully Username :- {usermaster.UserName}";
}
return(RedirectToAction("Create", "CreateNewUser"));
}
return(View("Create", createUserViewModel));
}
else
{
return(View("Create", createUserViewModel));
}
}
catch
{
throw;
}
}
public IActionResult Process(ChangePasswordViewModel changePasswordViewModel)
{
if (ModelState.IsValid)
{
var userid = Convert.ToString(HttpContext.Session.GetString("UserId"));
var getuserdetails = _userRepository.GetUserbyUserId(Convert.ToInt64(userid));
var usersalt = _userRepository.GetUserSaltbyUserid(getuserdetails.UserId);
var generatehash = GenerateHashSha512.Sha512(changePasswordViewModel.CurrentPassword, usersalt.PasswordSalt);
if (changePasswordViewModel.CurrentPassword == changePasswordViewModel.Password)
{
ModelState.AddModelError("", @"New Password Cannot be same as Old Password");
return(View(changePasswordViewModel));
}
if (!string.Equals(getuserdetails.PasswordHash, generatehash, StringComparison.Ordinal))
{
ModelState.AddModelError("", "Current Password Entered is InValid");
return(View(changePasswordViewModel));
}
if (!string.Equals(changePasswordViewModel.Password, changePasswordViewModel.ConfirmPassword, StringComparison.Ordinal))
{
TempData["Reset_Error_Message"] = "Password Does not Match";
return(View(changePasswordViewModel));
}
else
{
var salt = GenerateRandomNumbers.RandomNumbers(20);
var saltedpassword = GenerateHashSha512.Sha512(changePasswordViewModel.Password, salt);
var result = _userRepository.UpdatePasswordandHistory(getuserdetails.UserId, saltedpassword, salt, "C");
if (result > 0)
{
//
TempData["ChangePassword_Success_Message"] = "Password Changed Successfully";
var updateresult = _verificationRepository.UpdateRegisterVerification(getuserdetails.UserId);
return(RedirectToAction("Process", "ChangePassword"));
}
else
{
TempData["Reset_Error_Message"] = "Something Went Wrong Please try again!";
return(View(changePasswordViewModel));
}
}
}
return(View(changePasswordViewModel));
}
public ActionResult Changepassword(ChangePasswordViewModel changePasswordViewModel)
{
try
{
if (ModelState.IsValid)
{
var storedUserpassword = _password.GetPasswordbyUserId(Convert.ToInt64(_sessionHandler.UserId));
var usersalt = _userMaster.GetUserSaltbyUserid(Convert.ToInt64(_sessionHandler.UserId));
var generatehash = GenerateHashSha512.Sha512(changePasswordViewModel.ExistingPassword, usersalt.PasswordSalt);
if (changePasswordViewModel.ExistingPassword == changePasswordViewModel.NewPassword)
{
ModelState.AddModelError("", @"New Password Cannot be same as Old Password");
return(View(changePasswordViewModel));
}
if (!string.Equals(storedUserpassword, generatehash, StringComparison.Ordinal))
{
ModelState.AddModelError("", "Current Password Entered is InValid");
return(View(changePasswordViewModel));
}
if (!string.Equals(changePasswordViewModel.NewPassword, changePasswordViewModel.ConfirmPassword, StringComparison.Ordinal))
{
TempData["Reset_Error_Message"] = "Password Does not Match";
return(View(changePasswordViewModel));
}
else
{
var salt = GenerateRandomNumbers.RandomNumbers(20);
var saltedpassword = GenerateHashSha512.Sha512(changePasswordViewModel.NewPassword, salt);
var result = _password.UpdatePasswordandHistory(Convert.ToInt64(_sessionHandler.UserId), saltedpassword, salt, "C");
TempData["MessageChangePassword"] = "******";
return(RedirectToAction("Changepassword", "Admin"));
}
}
return(View(changePasswordViewModel));
}
catch (Exception)
{
throw;
}
}
public IActionResult Reset(ResetPasswordViewModel resetPasswordViewModel)
{
if (ModelState.IsValid)
{
var userid = Convert.ToString(HttpContext.Session.GetString("VerificationUserId"));
var getuserdetails = _userMasterQueries.GetUserDetailsbyUserId(Convert.ToInt64(userid));
if (!string.Equals(resetPasswordViewModel.Password, resetPasswordViewModel.ConfirmPassword, StringComparison.Ordinal))
{
TempData["Reset_Error_Message"] = "Password Does not Match";
return(View(resetPasswordViewModel));
}
else
{
var salt = GenerateRandomNumbers.GenerateRandomDigitCode(20);
var saltedpassword = HashHelper.CreateHashSHA512(resetPasswordViewModel.Password, salt);
_unitOfWorkEntityFramework.UserMasterCommand.UpdatePasswordandHistory(getuserdetails.UserId, saltedpassword, salt, "R");
var result = _unitOfWorkEntityFramework.Commit();
if (result)
{
var resetPasswordVerificationobj = _verificationQueries.GetResetGeneratedToken(getuserdetails.UserId);
_unitOfWorkEntityFramework.VerificationCommand.UpdateResetVerification(resetPasswordVerificationobj);
var updateresult = _unitOfWorkEntityFramework.Commit();
if (updateresult)
{
TempData["Reset_Success_Message"] = "Password Reset Successfully!";
}
return(RedirectToAction("Login", "Portal"));
}
else
{
TempData["Reset_Error_Message"] = "Something Went Wrong Please try again!";
return(View(resetPasswordViewModel));
}
}
}
return(View(resetPasswordViewModel));
}
// GET: PasswordReset
public async Task <ActionResult> Process(ForgotPasswordModel resetPasswordModel)
{
try
{
if (ModelState.IsValid)
{
var result = _verify.ValidateEmailIdExists(resetPasswordModel.EmailId);
if (!result)
{
TempData["PasswordResetMessage"] = "In Valid EmailId";
}
else
{
SendingEmailhelper sendingEmailhelper = new SendingEmailhelper();
var generatecode = GenerateHashSha256.ComputeSha256Hash(GenerateRandomNumbers.RandomNumbers(6));
var userId = _userMaster.GetUserIdbyEmailId(Convert.ToString(resetPasswordModel.EmailId));
var count = _verification.GetSentResetPasswordVerificationCount(userId);
var sentEmailCount = Convert.ToInt32(ConfigurationManager.AppSettings["MaxResetEmailCount"]);
if (count == sentEmailCount)
{
TempData["PasswordResetMessage"] = "You Have exceed Limit for Resetting Password";
}
else
{
_verification.SendResetVerificationToken(userId, generatecode);
TempData["PasswordResetMessage"] = "Email Sent to your Account";
await sendingEmailhelper.SendForgotPasswordVerificationEmailasync(resetPasswordModel.EmailId, generatecode, "ForgotPassword", userId.ToString());
}
}
}
return(View(resetPasswordModel));
}
catch (Exception)
{
throw;
}
}
public void TestGetRandomIntGetsAllNumbersInRangeEventually(int max)
{
var maxTimeToRun = TimeSpan.FromSeconds(1); // don't let the test churn for more than a second
var stopWatch = new Stopwatch();
var objectUnderTest = new GenerateRandomNumbers();
bool[] found = new bool[max + 1];
bool done;
stopWatch.Start();
do
{
var randomInt = objectUnderTest.GetRandomInt(inclusiveMin: 0, inclusiveMax: max);
found[randomInt] = true;
//assume we're done until we're proven otherwise
done = true;
for (int i = 0; i <= max; i++)
{
if (found[i])
{
continue;
}
done = false;
break;
}
if (stopWatch.Elapsed > maxTimeToRun)
{
throw new Exception("Test took too long to succeed");
}
} while (done == false);
//if we get here, we've succeeded
stopWatch.Stop();
}
public async Task <ActionResult> Register(UsermasterView usermaster)
{
try
{
if (ModelState.IsValid)
{
if (!this.IsCaptchaValid("Captcha is not valid"))
{
ModelState.AddModelError("", "Error: captcha is not valid.");
return(View(usermaster));
}
if (_iUserMaster.CheckUsernameExists(usermaster.UserName))
{
ModelState.AddModelError("", "UserName already exists");
return(View(usermaster));
}
if (_iUserMaster.CheckEmailIdExists(usermaster.EmailId))
{
ModelState.AddModelError("", "EmailId already exists");
return(View(usermaster));
}
if (_iUserMaster.CheckMobileNoExists(usermaster.MobileNo))
{
TempData["MessageCreateUsersErrors"] = "MobileNo Already Exists";
}
var autoUsermaster = AutoMapper.Mapper.Map <Usermaster>(usermaster);
var salt = GenerateRandomNumbers.RandomNumbers(20);
var saltedpassword = GenerateHashSha512.Sha512(usermaster.Password, salt);
var userId = _iUserMaster.AddUser(autoUsermaster, saltedpassword, salt, Convert.ToInt16(StatusMain.Roles.User));
if (userId != -1)
{
var emailVerficationToken = GenerateHashSha256.ComputeSha256Hash((GenerateRandomNumbers.RandomNumbers(6)));
_verification.SendRegistrationVerificationToken(userId, emailVerficationToken);
SendingEmailhelper sendingEmailhelper = new SendingEmailhelper();
var name = string.Concat(usermaster.FirstName, usermaster.LastName);
await sendingEmailhelper.SendVerificationEmailasync(usermaster.EmailId, name, emailVerficationToken, "Registration", Convert.ToString(userId));
TempData["MessageRegistration"] = "Thank you. Your Registration has been completed successfully.";
}
else
{
TempData["ErrorRegistration"] = "Something Went Wrong While you are registering.Please try after sometime.";
}
return(RedirectToAction("Register", "Registration"));
}
else
{
return(View("Register", usermaster));
}
}
catch
{
throw;
}
}
public ActionResult Create(CreateAgentViewModel createAgentViewModel)
{
try
{
if (ModelState.IsValid)
{
var isUser = _iUserMaster.CheckUsernameExists(createAgentViewModel.UserName);
if (createAgentViewModel.CategoryId == null)
{
ModelState.AddModelError("", "Select Category");
}
else if (isUser)
{
ModelState.AddModelError("", "Username already exists");
}
else
{
var usermaster = AutoMapper.Mapper.Map <Usermaster>(createAgentViewModel);
usermaster.Status = true;
usermaster.CreateDate = DateTime.Now;
usermaster.UserId = 0;
usermaster.CreatedBy = Convert.ToInt32(_sessionHandler.UserId);
usermaster.IsFirstLogin = true;
var salt = GenerateRandomNumbers.RandomNumbers(20);
var saltedpassword = GenerateHashSha512.Sha512(createAgentViewModel.Password, salt);
var savedAssignedRoles = new SavedAssignedRoles()
{
RoleId = Convert.ToInt16(StatusMain.Roles.Agent),
AssignedRoleId = 0,
Status = true,
CreateDate = DateTime.Now
};
var result = _iUserMaster.AddAgent(usermaster, saltedpassword, savedAssignedRoles, createAgentViewModel.CategoryId, salt);
if (result > 0)
{
TempData["MessageCreateUsers"] = "Agent Created Successfully";
return(RedirectToAction("Create", "CreateAgent"));
}
else
{
return(View(createAgentViewModel));
}
}
createAgentViewModel.ListofCategory = _category.GetAllActiveSelectListItemCategory();
return(View("Create", createAgentViewModel));
}
else
{
createAgentViewModel.ListofCategory = _category.GetAllActiveSelectListItemCategory();
return(View("Create", createAgentViewModel));
}
}
catch
{
throw;
}
}
public void TestGetRandomIntWorksWithNoRange(int min)
{
var objectUnderTest = new GenerateRandomNumbers();
objectUnderTest.GetRandomInt(inclusiveMin: min, inclusiveMax: min).Should().Be(min);
}
private void CheckIsPasswordAlreadyExists(ResetPasswordViewModel resetPasswordViewModel)
{
var salt = GenerateRandomNumbers.RandomNumbers(20);
var saltedpassword = GenerateHashSha512.Sha512(resetPasswordViewModel.Password, salt);
}
private void CheckIsPasswordAlreadyExists(ResetPasswordViewModel resetPasswordViewModel)
{
var salt = GenerateRandomNumbers.GenerateRandomDigitCode(20);
var saltedpassword = HashHelper.CreateHashSHA512(resetPasswordViewModel.Password, salt);
}
public IActionResult Create([FromBody] CreateUserRequest createUserRequest)
{
if (_userMasterQueries.CheckUserExists(createUserRequest.UserName))
{
return(BadRequest(new BadRequestResponse("Entered Username Already Exists")));
}
if (_userMasterQueries.CheckEmailExists(createUserRequest.EmailId))
{
return(BadRequest(new BadRequestResponse("Entered EmailId Already Exists")));
}
if (_userMasterQueries.CheckMobileNoExists(createUserRequest.MobileNo))
{
return(BadRequest(new BadRequestResponse("Entered MobileNo Already Exists")));
}
if (!string.Equals(createUserRequest.Password, createUserRequest.ConfirmPassword,
StringComparison.Ordinal))
{
return(BadRequest(new BadRequestResponse("Password Does not Match")));
}
var generatepasswordhash = HashHelper.CreateHashSHA512(createUserRequest.Password).ToLower();
var salt = GenerateRandomNumbers.GenerateRandomDigitCode(20);
var saltedpassword = HashHelper.CreateHashSHA512(generatepasswordhash, salt);
var userMappedobject = new UserMaster()
{
UserId = 0,
Status = true,
CreatedOn = DateTime.Now,
CreatedBy = Convert.ToInt32(1),
PasswordHash = saltedpassword,
FirstName = createUserRequest.FirstName,
EmailId = createUserRequest.EmailId,
Gender = createUserRequest.Gender,
MobileNo = createUserRequest.MobileNo,
IsFirstLogin = false,
LastName = createUserRequest.LastName,
UserName = createUserRequest.UserName
};
AssignedRoles assignedRoles = new AssignedRoles()
{
AssignedRoleId = 0,
CreateDate = DateTime.Now,
Status = true,
RoleId = Convert.ToInt32(RolesHelper.Roles.User),
UserMaster = userMappedobject
};
UserTokens userTokens = new UserTokens()
{
UserMaster = userMappedobject,
CreatedOn = DateTime.Now,
HashId = 0,
PasswordSalt = salt
};
_unitOfWorkEntityFramework.UserMasterCommand.Add(userMappedobject);
_unitOfWorkEntityFramework.AssignedRolesCommand.Add(assignedRoles);
_unitOfWorkEntityFramework.UserTokensCommand.Add(userTokens);
var result = _unitOfWorkEntityFramework.Commit();
if (result)
{
return(Ok(new OkResponse("User Registered Successfully !")));
}
else
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Something Went Wrong"));
}
}
public IActionResult Create(CreateUserViewModel createModel)
{
createModel.ListRole = _roleQueries.ListofRoles();
if (!ModelState.IsValid)
{
return(View(createModel));
}
if (_userMasterQueries.CheckUserExists(createModel.UserName))
{
ModelState.AddModelError("", "Entered Username Already Exists");
return(View(createModel));
}
if (_userMasterQueries.CheckEmailExists(createModel.EmailId))
{
ModelState.AddModelError("", "Entered EmailId Already Exists");
return(View(createModel));
}
if (_userMasterQueries.CheckMobileNoExists(createModel.MobileNo))
{
ModelState.AddModelError("", "Entered MobileNo Already Exists");
return(View(createModel));
}
if (!string.Equals(createModel.Password, createModel.ConfirmPassword,
StringComparison.Ordinal))
{
TempData["Registered_Error_Message"] = "Password Does not Match";
return(View(createModel));
}
var salt = GenerateRandomNumbers.GenerateRandomDigitCode(20);
var saltedpassword = HashHelper.CreateHashSHA512(createModel.Password, salt);
var userMappedobject = _mapper.Map <UserMaster>(createModel);
userMappedobject.Status = true;
userMappedobject.CreatedOn = DateTime.Now;
userMappedobject.CreatedBy = Convert.ToInt32(HttpContext.Session.GetString(AllSessionKeys.UserId));
userMappedobject.PasswordHash = saltedpassword;
AssignedRoles assignedRoles = new AssignedRoles()
{
AssignedRoleId = 0,
CreateDate = DateTime.Now,
Status = true,
RoleId = createModel.RoleId,
UserMaster = userMappedobject
};
UserTokens userTokens = new UserTokens()
{
UserMaster = userMappedobject,
CreatedOn = DateTime.Now,
HashId = 0,
PasswordSalt = salt
};
_unitOfWorkEntityFramework.UserMasterCommand.Add(userMappedobject);
_unitOfWorkEntityFramework.AssignedRolesCommand.Add(assignedRoles);
_unitOfWorkEntityFramework.UserTokensCommand.Add(userTokens);
var result = _unitOfWorkEntityFramework.Commit();
if (result)
{
_notificationService.SuccessNotification("Message", "User Registered Successfully !");
return(RedirectToAction("Index"));
}
else
{
_notificationService.DangerNotification("Message", "Something went wrong Please Try Once Again !");
return(View(createModel));
}
}
public IActionResult Form(RegistrationViewModel registerViewModel)
{
if (ModelState.IsValid)
{
if (_userMasterQueries.CheckUserExists(registerViewModel.UserName))
{
ModelState.AddModelError("", "Entered Username Already Exists");
return(View(registerViewModel));
}
if (_userMasterQueries.CheckUserExists(registerViewModel.EmailId))
{
ModelState.AddModelError("", "Entered EmailId Already Exists");
return(View(registerViewModel));
}
if (_userMasterQueries.CheckUserExists(registerViewModel.MobileNo))
{
ModelState.AddModelError("", "Entered Phoneno Already Exists");
return(View(registerViewModel));
}
if (!string.Equals(registerViewModel.Password, registerViewModel.ConfirmPassword,
StringComparison.Ordinal))
{
TempData["Registered_Error_Message"] = "Password Does not Match";
return(View(registerViewModel));
}
var salt = GenerateRandomNumbers.GenerateRandomDigitCode(20);
var saltedpassword = HashHelper.CreateHashSHA512(registerViewModel.Password, salt);
var userMappedobject = _mapper.Map <UserMaster>(registerViewModel);
userMappedobject.Status = true;
userMappedobject.CreatedOn = DateTime.Now;
userMappedobject.CreatedBy = Convert.ToInt32(HttpContext.Session.GetString(AllSessionKeys.UserId));
userMappedobject.PasswordHash = saltedpassword;
AssignedRoles assignedRoles = new AssignedRoles()
{
AssignedRoleId = 0,
CreateDate = DateTime.Now,
Status = true,
RoleId = Convert.ToInt32(RolesHelper.Roles.User),
UserMaster = userMappedobject
};
UserTokens userTokens = new UserTokens()
{
UserMaster = userMappedobject,
CreatedOn = DateTime.Now,
HashId = 0,
PasswordSalt = salt
};
_unitOfWorkEntityFramework.UserMasterCommand.Add(userMappedobject);
_unitOfWorkEntityFramework.AssignedRolesCommand.Add(assignedRoles);
_unitOfWorkEntityFramework.UserTokensCommand.Add(userTokens);
var result = _unitOfWorkEntityFramework.Commit();
if (result)
{
var userdetails = _userMasterQueries.GetUserbyUserName(registerViewModel.UserName);
var token = HashHelper.CreateHashSHA256((GenerateRandomNumbers.GenerateRandomDigitCode(6)));
var body = _emailSender.CreateRegistrationVerificationEmail(userdetails, token);
_unitOfWorkEntityFramework.VerificationCommand.SendRegistrationVerificationToken(userdetails.UserId, token);
_unitOfWorkEntityFramework.Commit();
MessageTemplate messageTemplate = new MessageTemplate()
{
ToAddress = userdetails.EmailId,
Subject = "Welcome to Frapper",
Body = body
};
_emailSender.SendMailusingSmtp(messageTemplate);
TempData["Registered_Success_Message"] = "User Registered Successfully";
}
else
{
TempData["Registered_Error_Message"] = "Error While Registrating User Successfully";
}
}
return(RedirectToAction("Form", "Registration"));
}
