private async Task <Tuple <Employee, string> > CreateOrdinaryEmployeeAndPassword(Company company, Random randomizer, Employee manager = null) { string companyNormalizedName = GetCompanyNormalizedName(company.CompanyName); Employee candidate = null; string title, firstName, lastName, email; do { int nameIndex = randomizer.Next(_Names.Length); title = nameIndex < _FemaileNamesStartIndex ? _StringLocalizer["M"] : _StringLocalizer["Mme"]; firstName = _Names[nameIndex]; lastName = _Surname[randomizer.Next(_Surname.Length)]; email = $"{firstName[0]}.{lastName.ToLower()}@{companyNormalizedName.ToLower()}.com"; candidate = await _UnitOfWork.Employees.FindAsync(x => x.Email.Equals(email)); } while (candidate != null); var daysFromCreation = (company.CompanyCreationDate - DateTime.Now).TotalDays; Employee result = new Employee() { UserName = email, Email = email, Title = title, FirstName = firstName, LastName = lastName, Company = company, Manager = manager, EmploymentDate = DateTime.Now.AddDays(randomizer.NextDouble() * daysFromCreation), DateOfBirth = DateTime.Now.AddDays(-1D * Convert.ToDouble(randomizer.Next(19 * 365, 65 * 365))), TaxRate = randomizer.Next().ToString() }; string password = _PasswordGenerator.GeneratePassword(); return(Tuple.Create(result, password)); }
public async Task <IActionResult> CheckPassword([FromForm] AccountCheckPasswordRequest request) { if (request == null || string.IsNullOrWhiteSpace(request.UserName) || string.IsNullOrWhiteSpace(request.Password)) { return(BadRequest()); } var user = await _userManager.FindByNameAsync(request.UserName); // If the user does not exist, then return an empty result. if (user == null) { return(NoContent()); } // If the user does exist and they have not been migrated to the Azure Active Directory identity store with the SQL-managed // password, then... if (user.MigrationStatus == (int)MigrationStatus.New || user.MigrationStatus == (int)MigrationStatus.NotMigrated || user.MigrationStatus == (int)MigrationStatus.MigratedWithoutPassword) { var checkPasswordResult = await _userManager.CheckPasswordAsync(user, request.Password); if (user.MigrationStatus == (int)MigrationStatus.NotMigrated) { var userClaims = await _userManager.GetClaimsAsync(user); var displayNameClaim = userClaims.First(c => c.Type == DisplayNameClaimType); var playerTagClaim = userClaims.FirstOrDefault(c => c.Type == PlayerTagClaimType); // Create the user in the Azure Active Directory identity with either the SQL-managed password, if it is valid, // or a generated password, if it is not valid. await _graphService.CreateUserAsync( request.UserName, checkPasswordResult?request.Password : _passwordGenerator.GeneratePassword(), displayNameClaim.Value, "Activated", playerTagClaim?.Value, TermsOfServiceConsentedClaimValue); user.MigrationStatus = checkPasswordResult ? (int)MigrationStatus.MigratedWithPassword : (int)MigrationStatus.MigratedWithoutPassword; await _userManager.UpdateAsync(user); } else if (checkPasswordResult && (user.MigrationStatus == (int)MigrationStatus.New || user.MigrationStatus == (int)MigrationStatus.MigratedWithoutPassword)) { // Update the password for the user in the Azure Active Directory identity store with the SQL-managed password. await _graphService.SetUserPasswordAsync(request.UserName, request.Password); user.MigrationStatus = (int)MigrationStatus.MigratedWithPassword; await _userManager.UpdateAsync(user); } } return(Ok(user)); }
public async Task RegisterAdminAsync(ApplicationUser applicationUser) { await applicationUserRepository.AddAsync(applicationUser); await applicationUserRepository.SaveChangesAsync(); string password = passwordGenerator.GeneratePassword(); await AddUserPasswordAsync(applicationUser.User, password); await AddUserToRoleAsync(applicationUser.User, Roles.ADMIN); await emailService.SendEmailAsync(applicationUser.User.Email, password); }
public async Task <IActionResult> Activate(string id) { if (string.IsNullOrEmpty(id)) { throw new InvalidOperationException(); } var user = await _userManager.FindByIdAsync(id); if (user == null) { throw new InvalidOperationException(); } if (user.MigrationStatus == (int)MigrationStatus.NotMigrated) { throw new InvalidOperationException(); } await _graphService.SetUserActivationStatusAsync(user.UserName, "Pending"); var userClaims = await _userManager.GetClaimsAsync(user); var displayNameClaim = userClaims.First(c => c.Type == WingTipClaimTypes.DisplayNameClaimType); var nonce = _passwordGenerator.GeneratePassword(); var redeemUrl = GenerateSignedRedeemUrl(user.UserName, nonce); _smtpService.SendActivationEmail(user.UserName, displayNameClaim.Value, redeemUrl); var existingNonceClaim = userClaims.FirstOrDefault(c => c.Type == WingTipClaimTypes.NonceClaimType); if (existingNonceClaim != null) { var removeClaimResult = await _userManager.RemoveClaimAsync(user, existingNonceClaim); if (!removeClaimResult.Succeeded) { throw new InvalidOperationException(removeClaimResult.Errors.ToString()); } } var newNonceClaim = new Claim(WingTipClaimTypes.NonceClaimType, nonce); var addClaimResult = await _userManager.AddClaimAsync(user, newNonceClaim); if (!addClaimResult.Succeeded) { throw new InvalidOperationException(addClaimResult.Errors.ToString()); } return(RedirectToAction("Index")); }
public async Task <UniversityCreationResultDTO> CreateUniversityAsync(UniversityCreateRequestViewDTO createRequestDTO) { var university = new University { Name = createRequestDTO.UniversityName, }; await universityRepository.AddAsync(university); await universityRepository.SaveChangesAsync(); UniversityAdminRegistrationDTO adminRegisterRequest = new UniversityAdminRegistrationDTO { FirstName = createRequestDTO.SubmitterFirstName, LastName = createRequestDTO.SubmitterLastName, Email = createRequestDTO.Email, Password = passwordGenerator.GeneratePassword(), UniversityId = university.Id }; await authService.RegisterUniversityAdminAsync(adminRegisterRequest); return(new UniversityCreationResultDTO { UniversityId = university.Id, UniversityName = university.Name, AdminEmail = adminRegisterRequest.Email, AdminPassword = adminRegisterRequest.Password }); }
public async Task <string> CreateUser(UserViewModel userViewModel) { var user = new ApplicationUser { UserName = userViewModel.Email, Email = userViewModel.Email, FirstName = userViewModel.FirstName, LastName = userViewModel.LastName }; var password = _passwordGenerator.GeneratePassword(); var result = await _userManager.CreateAsync(user, password); if (result.Succeeded) { var code = await _userManager.GenerateEmailConfirmationTokenAsync(user); code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code)); var callbackUrl = $"Identity/Account/ConfirmEmail?userId={user.Id}&code={code}&returnUrl=~/"; await _emailSender.SendEmailAsync(user.Email, "Confirm your email", $"Please confirm your account by " + $"<a href='{_navigationManager.BaseUri + HtmlEncoder.Default.Encode(callbackUrl.ToString())}'>clicking here</a>." + $"Your automatically generated password: {password}"); if (!_userManager.Options.SignIn.RequireConfirmedAccount) { await _signInManager.SignInAsync(user, isPersistent : false); } } return(user.Id); }
public async Task <ActionResult <PasswordResponse> > ResetPassword(ResetPasswordRequest model) { var user = await _userManager.FindByNameAsync(model.UserName); if (user == null) { return(NotFound()); } var password = _passwordGenerator.GeneratePassword(); var result = await ChangePassword(user, password); if (!result.Succeeded) { foreach (var error in result.Errors) { ModelState.AddModelError(error.Code, error.Description); } return(BadRequest(ModelState)); } var response = new PasswordResponse { Id = user.Id, UserName = user.UserName, Password = password }; return(response); }
public async Task GeneratePassword() { if (appController.Busy) { return; } else { appController.EnableBusyState(); } var vm = viewModelsController.GetViewModel <CreateViewModel>(); if (string.IsNullOrEmpty(vm.Login) || string.IsNullOrEmpty(vm.Name)) { appController.DisableBusyState(); return; } try { vm.Password = await Task.Run(() => passwordGenerator.GeneratePassword(vm.UserLower, vm.UseUpper, vm.UseNumber, vm.UseSpecial, vm.UsePolish, vm.PasswordLenght)); } catch (Exception) { vm.Password = "******"; } finally { appController.DisableBusyState(); } }
public JsonResult GeneratePassword(GeneratePasswordViewModel model) { string password = _passwordGenerator.GeneratePassword(model.PasswordLength, model.MinUpperCaseCharLength, model.MinLowerCaseCharLength, model.MinSpecialCharLength, model.MinNumericCharLength); return(Json(password)); }
public ActionResult GeneratePassword(PasswordGeneration passwordGeneration) { var generatedPassword = new GeneratedPassword { Value = passwordGenerator.GeneratePassword(passwordGeneration.DomainName, passwordGeneration.MasterPassword, passwordGeneration.PasswordLength, passwordGeneration.HashFunction, passwordGeneration.CharacterSpace) }; return(Json(generatedPassword)); }
public async Task OnGetAsync(int id) { TenantId = _sessionTenantAccessor.TenantId; ApiResourceId = id; Input = new SecretModel { Value = _passwordGenerator.GeneratePassword(), SecretExpiration = "Never" }; }
// [Authorize(AuthenticationSchemes = "frontend")] public IActionResult Create() { List <IdentityRole> list = new List <IdentityRole>(); list = roleManager.Roles.ToList(); ViewBag.list = list; string generatedPassword = passwordGenerator.GeneratePassword(15); CreateAdminViewModel model = new CreateAdminViewModel(); model.Password = generatedPassword; return(View(model)); }
/// <summary> /// Resets the user's password and email's them a new password /// </summary> /// <param name="email">email address</param> public void ForgotPassword(string email) { var user = GetUserByEmail(email); if (user == null || user.Deleted || !user.Active) { return; } var password = _passwordGenerator.GeneratePassword(10); SetUserPassword(user, user.PasswordFormat, password); }
private void CreateNewEditorAccount(Request request) { if (WebSecurity.UserExists(request.Email)) { throw new Exception("Username taken"); } var user = Mapper.Map <Request, User>(request); var userProfile = Mapper.Map <Request, UserProfile>(request); user.UserName = userProfile.Email; userProfile.Status = 0; _registrationService.CreateUser(user, userProfile, _passwordGenerator.GeneratePassword(), RoleNames.Editor); }
public async Task <IActionResult> OnPostAsync(string returnUrl = null) { returnUrl = returnUrl ?? Url.Content("~/"); if (ModelState.IsValid) { string password = passwordGenerator.GeneratePassword(signInManager); var user = new ApplicationUser { UserName = Input.User.Email, Email = Input.User.Email, DisplayName = Input.User.Name, OrganizationID = Input.User.OrganizationID, EmailConfirmed = true }; var result = await userManager.CreateAsync(user, password); if (result.Succeeded) { logger.LogInformation("User created a new account with password."); var addToRoles = await userManager.AddToRolesAsync(user, Input.Roles.Where(r => r.IsAssigned).Select(r => r.Name).ToArray()); var code = await userManager.GeneratePasswordResetTokenAsync(user); var callbackUrl = Url.Page( "/Account/ResetPassword", pageHandler: null, values: new { code }, protocol: Request.Scheme); await emailSender.SendEmailAsync(Input.User.Email, "You have been registered for Onebeat", $"Please reset your password by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>."); //await signInManager.SignInAsync(user, isPersistent: false); return(LocalRedirect(returnUrl)); } foreach (var error in result.Errors) { ModelState.AddModelError(string.Empty, error.Description); } } else { } // If we got this far, something failed, redisplay form return(Page()); }
private async Task CreateAccountsForContacts(Contact[] contactsForSave) { foreach (var contact in contactsForSave) { foreach (var account in contact.SecurityAccounts) { account.MemberId = contact.Id; if (string.IsNullOrEmpty(account.Password)) { var generatedPassword = _passwordGenerator.GeneratePassword(); await _userManager.CreateAsync(account, generatedPassword); } else { await _userManager.CreateAsync(account, account.Password); } } } }
/// <summary> /// Resets a user password using the generated token. /// </summary> /// <param name="token">Token provided by the system</param> /// <returns>The new password generated.</returns> public string ResetPassword(string token) { string unencoded = _tokenizer.ValidateToken(token); string[] parameters = unencoded.Split(','); int siteAddressId = Convert.ToInt32(parameters[0]); string userName = parameters[1]; User u = FindUser(siteAddressId, userName); if (u != null) { string password = _passwordGenerator.GeneratePassword(PasswordGenerationLength); u.ChangePassword(password); _userRepository.SaveOrUpdate(u); return(password); } throw new InvalidCredentialsException(); }
public bool Create(User user) { if (!_repository.IsEmailAvailable(user.Email)) { return(false); } do { user.Id = Guid.NewGuid(); } while (!_repository.IsGuidAvailable(user.Id)); user.Secret = _transformer.Encrypt(user.Secret, out string key, out string iv); user.SecretIv = iv; user.SecretKey = key; user.Password = _hasher.Hash(_generator.GeneratePassword(), out string salt); user.Salt = salt; return(_repository.Create(user)); }
public Site RegisterUser(int siteId, string memberName, string firstName, string lastName, string emailAddress, string userName, string password) { User u = FindUser(userName); if (u != null) { throw new UserAlreadyExistException(); } Site c = _siteRepository.Get(siteId); var m = new User(); m.UserName = memberName; m.FirstName = firstName; m.LastName = lastName; if (!string.IsNullOrEmpty(password)) { m.SetPassword(password); } else { m.SetPassword(_passwordGenerator.GeneratePassword(10)); } m.Email = emailAddress.Trim().ToLower(); m.UserName = userName.Trim().ToLower(); c.AddUser(m); SendConfirmationToken(m); _siteRepository.SaveOrUpdate(c); return(c); }
public string Get(string username) { return(_passwordGenerator.GeneratePassword(username)); }
public bool ResetPasswordToGenerated(string userLogin, string email, string fullName) => ResetPassword(userLogin, _passwordGenerator.GeneratePassword(_passwordLength), email, fullName);
private static void GetPassword(IPasswordGenerator generator, List<Password> passwords) { string password = generator.GeneratePassword(); Console.WriteLine(password); passwords.Add(new Password(password)); }
public async Task <IActionResult> AddTeacher(AddTeacherViewModel model) { if (ModelState.IsValid) { IdentityUser user = new IdentityUser { UserName = passwordGenerator.GenerateUsernameFromEmail(model.EmailAddress), Email = model.EmailAddress, PhoneNumber = model.PhoneNumber }; IdentityResult result = await userManager.CreateAsync(user, passwordGenerator.GeneratePassword(15)); if (result.Succeeded) { Teacher teacher = new Teacher { Firstname = model.Firstname, Middlename = model.Middlename, Lastname = model.Lastname, Gender = model.Gender, DateOfBirth = model.DateOfBirth.ToString(), PhoneNumber = model.PhoneNumber, EmailAddress = model.EmailAddress, Religion = model.Religion, ProfilePhotoPath = processFileUpload.UploadImage(model.Photo, "uploads"), IdentityUserId = user.Id, DepartmentId = model.DepartmentId }; _teacherRepository.InsertAndSaveTeacherData(teacher); TeacherContactInformation contactInformation = new TeacherContactInformation { Address1 = model.Address1, Address2 = model.Address2, AlternateEmailAddress = model.AlternateEmailAddress, ZipCode = model.ZipCode, HomePhone = model.HomePhone, MobilePhone = model.MobilePhone, NextOfKinFirstname = model.NextOfKinFirstname, NextOfKinLastname = model.NextOfKinLastname, RelationToNextOfKin = model.RelationToNextOfKin, PhoneOfNextOfKin = model.PhoneOfNextOfKin, EmailOfNextOfKin = model.EmailOfNextOfKin, TeacherId = teacher.Id, CountryId = model.CountryId }; _teacherRepository.InsertContactData(contactInformation); TeacherHighestDegree highestDegree = new TeacherHighestDegree { NameOfInstitution = model.NameOfInstitution, YearEnrolled = model.YearEnrolled.ToString(), YearOfGraduation = model.YearOfGraduation.ToString(), DegreeAttained = model.DegreeAttained, CGPA = model.CGPA, TeacherContactInfoId = contactInformation.Id }; _teacherRepository.InsertAndSaveHighestDegree(highestDegree); TeacherOtherDegree otherDegree = new TeacherOtherDegree { NameOfInstitution = model.OtherNameOfInstitution, YearOfEnrollement = model.YearOfEnrollement.ToString(), YearOfGraduation = model.OtherYearOfGraduation.ToString(), DegreeAttained = model.OtherDegreeAttained, CGPA = model.OtherCGPA, TeacherHighestDegreeId = highestDegree.Id }; _teacherRepository.InsertAndSaveOtherDegree(otherDegree); return(RedirectToAction("allteachers")); } foreach (var error in result.Errors) { ModelState.AddModelError(string.Empty, error.Description); } } ListOfCountries(model); ListAllDepartments(model); return(View(model)); }
public string RegisterUser(string email) { return(_passwordGenerator.GeneratePassword(10)); }
public ResultMessage ResetPasswordToGenerated(Employee employee, int passwordLength) => ResetPassword(employee, passwordGenerator.GeneratePassword(passwordLength));
public bool ResetPasswordToGenerated(Employee employee) => ResetPassword(employee, passwordGenerator.GeneratePassword(passwordLength));
public async Task <IActionResult> AddStudent(AddStudentViewModel model) { if (ModelState.IsValid) { IdentityUser user = new IdentityUser { UserName = passwordGenerator.GenerateUsernameFromEmail(model.EmailAddress), Email = model.EmailAddress, PhoneNumber = model.PhoneNumber }; IdentityResult result = await userManager.CreateAsync(user, passwordGenerator.GeneratePassword(15)); string uniqueName = processFileUpload.UploadImage(model.Image, "uploads"); Student student = new Student { Firstname = model.Firstname, Middlename = model.Middlename, Lastname = model.Lastname, Gender = model.Gender, DateOfBirth = model.DateOfBirth.ToLongDateString(), PhoneNumber = model.PhoneNumber, AlternateEmailAddress = model.AlternateEmailAddress, EmailAddress = model.EmailAddress, Religion = model.Religion, MaritalStatus = model.MaritalStatus, ResidentialAddress = model.ResidentialAddress, ContactAddress = model.ContactAddress, AlternatePhoneNumber = model.AlternatePhoneNumber, IdentityUserId = user.Id, DepartmentId = model.DepartmentId, CourseYearId = SetStudentCurrentYear(model.PreviousLevel.Value.ToString()), ProfilePhotoPath = uniqueName, MatriculationNumber = SetMatriculationNumber(model.FacultyId, model.DepartmentId) }; studentRepository.InsertStudent(student); studentRepository.Save(); StudentAccademicInformation accademicInformation = new StudentAccademicInformation { NameOfInstitution = model.NameOfInstitution, YearEnrolled = model.YearEnrolled.ToLongDateString(), YearOfGraduation = model.YearOfGraduation.ToLongDateString(), PreviousLevel = model.PreviousLevel, StudentId = student.Id }; studentRepository.InsertStudentAccademicInformation(accademicInformation); studentRepository.Save(); StudentNextOfKinInformation nextOfKinInformation = new StudentNextOfKinInformation { NextOfKinFirstname = model.NextOfKinFirstname, NextOfKinLastname = model.NextOfKinLastname, RelationToNextOfKin = model.RelationToNextOfKin, PhoneOfNextOfKin = model.PhoneOfNextOfKin, EmailOfNextOfKin = model.EmailOfNextOfKin, StudentId = student.Id }; studentRepository.InsertStudentNextOfKin(nextOfKinInformation); studentRepository.Save(); StudentSponsor studentSponsor = new StudentSponsor { SponsorFirstname = model.SponsorFirstname, SponsorMiddlename = model.SponsorMiddlename, SponsorLastname = model.SponsorLastname, SponsorEmailAddress = model.SponsorEmailAddress, SponsorPhoneNumber = model.SponsorPhoneNumber, SponsorContactAddress = model.SponsorContactAddress, SponsorProffession = model.SponsorProffession, SponsorWorkAddress = model.SponsorWorkAddress, StudentId = student.Id }; SetStudentCourses(student.Id, student.DepartmentId, student.CourseYearId); studentRepository.InsertStudentSponsor(studentSponsor); studentRepository.Save(); return(Redirect("allstudents")); } ListAllFaculties(model); ListAllDepartments(model); return(View(model)); }
public async Task <IActionResult> CreateEmployee(EmployeeCreationVM employeeCreationVM) { string referer = employeeCreationVM.ReturnUrl; var currentPermissions = await GetEditionPermission(null); var currentUserData = await GetCurrentUserData(); //Validating access if (!ValidateCreationAccess(currentUserData.Item3)) { return(Forbid()); } //Validating duplicates await ValidateDuplicateMail(employeeCreationVM.Email); await ValidateDuplicateUserName(employeeCreationVM.UserName); //Validating contract ValidateContractAcceptence(employeeCreationVM.AcceptContract); //Validating is company and manager correctly assigned await ValidateEmployeeCreationVMState(employeeCreationVM); UserRoles employeeRoles = await ValidateAssignedRoles(UserManagerExtensions.ToUserRoles(employeeCreationVM.Roles), null); if (ModelState.ErrorCount > 0) { employeeCreationVM.RolesList = await GetListAllowedRoles(employeeRoles); } if (ModelState.ErrorCount == 0) { Employee employee = new Employee(); employeeCreationVM.Id = employee.Id; employee = (Employee)_Mapper.Map(employeeCreationVM, typeof(EmployeeCreationVM), typeof(Employee)); string password = _PasswordGenerator.GeneratePassword(); employee.LockoutEnabled = false; employee.EmailConfirmed = true; bool result = await _UnitOfWork.Employees.RegisterEmployeeAsync(_UserManager, employee, password); if (!result) { ModelState.AddModelError("", _DataLocalizer["Unabled to save employee into repository"]); } else { await SendMailWithCredentials(employee, password); } } //Validating user roles if (ModelState.ErrorCount == 0) { var employeeIdentityUser = await _UserManager.FindByEmailAsync(employeeCreationVM.Email); var newRoles = UserManagerExtensions.FromUserRoles(employeeRoles).ToList(); foreach (var role in newRoles) { var identityResult = await _UserManager.AddToRoleAsync(employeeIdentityUser, role); if (!identityResult.Succeeded) { ModelState.AddModelError("", _DataLocalizer["Unable to add this user to role {0}", role]); } } ; } if (ModelState.ErrorCount > 0) { employeeCreationVM = await SetEmployeeCompanyAndManagerState(employeeCreationVM, currentPermissions); employeeCreationVM.RolesListEnabled = currentPermissions.AllowEditAccess; employeeCreationVM.RolesList = await GetListAllowedRoles(currentUserData.Item3, self : currentPermissions.IsSelfEdition); ViewData["Referer"] = referer; ViewBag.Action = nameof(CreateEmployee); return(View(RegisterEmployeeView, employeeCreationVM)); } else { if (!String.IsNullOrEmpty(referer)) { return(Redirect(referer)); } else { return(RedirectToAction("Index", "Home")); } } }
private void AutoGeneratePassword_Click(object sender, RoutedEventArgs e) { CreateUserModel.SetAutoGenerateneratedPassword(passwordGenerator.GeneratePassword()); }
public async Task <UserModel> RegisterUser(TokenModel token, string userName) { var user = await userRepository.Register(new RegisterModel { Username = userName, Password = passwordGenerator.GeneratePassword(20, 30) }); if (user != null) { context.UserTokens.Add(new Microsoft.AspNetCore.Identity.EntityFrameworkCore.IdentityUserToken <string> { LoginProvider = socialAPI.ProviderName, Name = socialAPI.ProviderName, UserId = user.Id, Value = token.User_Id }); if (await context.SaveChangesAsync() <= 0) { return(null); } } return(user); }
public bool ResetPasswordToGenerated(string userLogin, string email) => ResetPassword(userLogin, passwordGenerator.GeneratePassword(passwordLength), email);