public async Task <IdentityResult> RegisterUserAsync(RegisterViewModel model) { if (await _userManager.FindByEmailAsync(model.Email).ConfigureAwait(false) != null) { return(IdentityResults.UserExists); } var user = _mapper.Map <User>(model); user.UserName = user.Email.Split('@')[0]; var result = await _userManager.CreateAsync(user, model.Password) .Then(() => _userManager.AddToRoleAsync(user, Roles.StudentRole)) .Then(() => { user.EmailConfirmed = true; return(_userManager.UpdateAsync(user)); }).ConfigureAwait(false); if (result.Succeeded) { var newUser = await _userManager.FindByEmailAsync(model.Email).ConfigureAwait(false); var registerEvent = new StudentRegisterEvent(newUser.Id, newUser.Email, newUser.Name, newUser.Surname, newUser.MiddleName); _eventBus.Publish(registerEvent); } return(result); }
public async Task <ActionResult> Register(RegisterClientViewModel model) { if (ModelState.IsValid) { UserDTO user = _mapper.Map <RegisterClientViewModel, UserDTO>(model); IdentityResult result; try { result = await _userManager.CreateAsync(user, user.Password); } catch (ArgumentNullException exception) { return(Content(exception.Message)); } if (result.Succeeded) { var currentUser = await _userManager.FindByNameAsync(model.UserName); var addToRoleResult = await _userManager.AddToRoleAsync(currentUser.Id, "User"); if (addToRoleResult.Succeeded) { return(View("SuccessRegistration")); } ModelState.AddModelError("", @"Неудачная попытка регистрации."); return(View(model)); } } return(View(model)); }
public async Task <AuthResult <Token> > SignUp(SignUpDTO signUpDto) { if (signUpDto == null || string.IsNullOrEmpty(signUpDto.Username) || string.IsNullOrEmpty(signUpDto.Password) || string.IsNullOrEmpty(signUpDto.ConfirmPassword) || string.IsNullOrEmpty(signUpDto.FullName) || string.IsNullOrEmpty(signUpDto.Email) || signUpDto.Password != signUpDto.ConfirmPassword ) { return(AuthResult <Token> .UnvalidatedResult); } var newUser = new TUser { Username = signUpDto.Username, Email = signUpDto.Email, FullName = signUpDto.FullName }; var succeeded = await userManager.CreateAsync(newUser, signUpDto.Password); if (succeeded) { if (newUser.Id > 0) { await userManager.AddToRoleAsync(newUser.Id, Roles.User); var token = jwtManager.GenerateToken(newUser); return(AuthResult <Token> .TokenResult(token)); } } return(AuthResult <Token> .UnauthorizedResult); }
public async Task InitializeAsync() { if (_roleManager.Roles.Count() == 0) { List <ApplicationRole> roles = new List <ApplicationRole> { new ApplicationRole("Admin"), new ApplicationRole("User") }; foreach (var role in roles) { await _roleManager.CreateAsync(role); } } if (await _userManager.FindByNameAsync("admin") == null) { await _userManager.CreateAsync(new ApplicationUser { Email = "*****@*****.**", FirstName = "Admin", LastName = "Admin", JoinDate = DateTime.UtcNow, UserName = "******", EmailConfirmed = true }, "Stl21598z!"); var user = await _userManager.FindByNameAsync("admin"); await _userManager.AddToRoleAsync(user.Id, "Admin"); } }
public async Task <IActionResult> Register(RegisterViewModel model) { if (this.ModelState.IsValid) { var user = new User { UserName = model.Username, Email = model.Email, DateOfBirth = model.DateOfBirth, CreatedOn = DateTime.Now }; var result = await this.userManager.CreateAsync(user, model.Password); if (result.Succeeded) { await userServices.CreateUserInitialBalances(user.Id, model.CurrencyName); await userManager.AddToRoleAsync(user, UserRoles.User.ToString()); await this.signinManager.SignInAsync(user, isPersistent : false); return(this.RedirectToAction("", "", new { @area = "" })); } this.AddErrors(result); } // If we got this far, something failed, redisplay form model.Currencies = await GetCurrenciesSelectListItemsCached(); return(this.View(model)); }
public async Task <IHttpActionResult> Save([FromBody] CreateUserDto model) { var repeated = _userRepository.GetUserByName(model.UserName); if (repeated != null) { return(BadRequest("User already exists!")); } var user = new User { UserName = model.UserName, Email = model.Email, IsEmailConfirmed = model.IsEmailConfirmed }; var result = await _userManager.CreateAsync(user, model.Password); if (result.Succeeded) { result = await _userManager.AddToRoleAsync(user.Id, Role.Client); if (result.Succeeded) { return(Ok()); } var createdUser = _userRepository.GetUserByName(model.UserName); if (createdUser != null) { await _userManager.DeleteAsync(createdUser); } } return(BadRequest(result.Errors.FirstOrDefault())); }
public async Task AddNewUniversity(AddUniRequest request) { User user = new User { Email = request.Email, UserName = request.Email }; var success = await userManager.CreateAsync(user, request.Password); if (success.Succeeded == true) { await userManager.AddToRoleAsync(user, "Administrator"); //await signInManager.PasswordSignInAsync(request.Email, request.Password, false, false); } University university = new University() { Name = request.UniversityName, //User = user, UserId = user.Id }; await unitOfWork.UniversityRepository.CreateAsync(university); await unitOfWork.Commit(); }
public async Task AddToRoleShouldSuccess() { _userManagerFacade.Setup(x => x.AddToRoleAsync(It.IsAny <string>(), It.IsAny <string>())) .Returns(Task.FromResult(IdentityResult.Success)); var result = await _userManager.AddToRoleAsync(null, null); Assert.That(result.Succeeded, Is.EqualTo(true)); }
private async Task <User> CheckUserAsync(string email, string firstName, string lastName, string password, string role) { var user = await userManager.FindByEmailAsync(email); if (user == null) { user = await AddUser(email, firstName, lastName, password, role); } var isInRole = await userManager.IsInRoleAsync(user, role); if (!isInRole) { await userManager.AddToRoleAsync(user, role); } return(user); }
public async Task SeedDevelopmentEnvironmentAsync() { await _roleManager.AddRoleAsync(ApplicationRole.Admin); await _roleManager.AddRoleAsync(ApplicationRole.User); var(_, benUserId) = await _userManager.CreateAsync("*****@*****.**", "hunter2", 1); await _userManager.AddToRoleAsync(benUserId, ApplicationRole.Admin); }
public async Task <IActionResult> Register(RegisterNewUserViewModel model) { if (ModelState.IsValid) { var user = await userHelper.FindByEmailAsync(model.Username); if (user == null) { user = new User { FirstName = model.FirstName, LastName = model.LastName, Email = model.Username, UserName = model.Username, }; var result = await userHelper.CreateAsync(user, model.Password); if (result != IdentityResult.Success) { ModelState.AddModelError(string.Empty, "La cuenta no pudo crearse correctamente"); return(View(model)); } await userHelper.AddToRoleAsync(user, model.UserRoles); ViewBag.Message = "La cuenta ha sido creada correctamente. Debe habilitarla para iniciar sesión."; return(RedirectToAction("Index", "Users")); } ModelState.AddModelError(string.Empty, "El correo electrónico ya ha sido asociado"); ViewBag.Name = roleManager.GetRolesSelectList(); } return(View(model)); }
public async Task <IActionResult> PromoteUser(string userId) { var user = userManager.Users.Where(u => u.Id == userId).FirstOrDefault(); if (user is null) { return(PartialView("_StatusMessage", "Error: User not found!")); } var result = await userManager.AddToRoleAsync(user, "Administrator"); if (!result.Succeeded) { return(PartialView("_StatusMessage", "Error: Could not promote user!")); } return(PartialView("_StatusMessage", "The user has been successfully promoted!")); }
public async Task <IdentityResult> RegisterUser(UserRegisterDTO registerUserModel) { User usr = null; if (registerUserModel.RoleName == "User") { usr = new Person() { UserName = registerUserModel.Email, Email = registerUserModel.Email, FullName = registerUserModel.Name, PhoneNumber = registerUserModel.PhoneNumber }; } else { usr = new Administrator() { UserName = registerUserModel.Email, Email = registerUserModel.Email, FullName = registerUserModel.Name, PhoneNumber = registerUserModel.PhoneNumber }; } using (var context = provider.Context) { IUserManager manager = provider.GetUserManager(context); IdentityResult result = null; try { result = await manager.CreateAsync(usr, registerUserModel.Password); } catch (Exception ex) { throw ex; } if (result.Succeeded) { result = await manager.AddToRoleAsync(usr.Id, registerUserModel.RoleName); } return(result); } }
public async Task <ServiceResponse> AddToRoleAsync(string email, Roles role) { var user = await _userManager.FindByEmailAsync(_cryptoProvider.EncryptPrivate(email)).ConfigureAwait(false); if (user == null) { return(new ServiceResponse("User not found.")); } var result = await _userManager.AddToRoleAsync(user, role.ToString()).ConfigureAwait(false); if (!result.Succeeded) { return(new ServiceResponse(string.Join(", ", result.Errors.Select(e => e.Description)))); } return(new ServiceResponse()); }
public async Task Register(string email, string password) { var user = new User() { Email = email, UserName = email, }; IdentityResult res = await _userManager.CreateAsync(user, password); if (res.Succeeded) { await _userManager.AddToRoleAsync(user.Id, Roles.Byuer); return; } else { throw new RegisterFailedException(res.Errors.First()); } }
public async Task <IActionResult> Register(RegisterViewModel model, string returnUrl = null) { ViewData["ReturnUrl"] = returnUrl; if (ModelState.IsValid) { var user = new User() { UserName = model.Email, Email = model.Email, FirstName = model.FirstName, LastName = model.LastName, PatrName = model.PatrName, RegistrationDate = DateTimeOffset.Now }; var result = await _userManager.CreateAsync(user, model.Password); if (result.Succeeded) { _logger.LogInformation("User created a new account with password."); var code = await _userManager.GenerateEmailConfirmationTokenAsync(user); var callbackUrl = Url.EmailConfirmationLink(user.Id.ToString(), code, Request.Scheme); await _emailSender.SendEmailConfirmationAsync(model.Email, callbackUrl); await _userManager.AddToRoleAsync(user, "user"); await _signInManager.SignInAsync(user, isPersistent : false); return(RedirectToLocal(returnUrl)); } AddErrors(result); } // If we got this far, something failed, redisplay form return(View(model)); }
public async Task <NewStudentResultDTO> AddStudentAsync(CreateStudentDTO studentDTO) { var createResult = new NewStudentResultDTO { Created = false, Student = null }; var user = new ApplicationUser() { UserName = studentDTO.Email, Email = studentDTO.Email, CreatedDate = DateTime.Now, FirstName = studentDTO.FirstName, LastName = studentDTO.LastName, EmailConfirmed = true }; var result = await _userManager.CreateAsync(user, studentDTO.Pesel.ToString() + studentDTO.LastName.ToLower().Substring(0, Math.Min(studentDTO.LastName.Length, 3))); //var saveUserResult = _store.Context.SaveChanges(); var roleResult = await _userManager.AddToRoleAsync(user.Id, "student"); if (!result.Succeeded || !roleResult.Succeeded) { return(createResult); } var student = Mapper.Map <Student>(studentDTO); student.UserId = user.Id; var createdStudent = _repository.InsertStudent(student); if (_repository.Save()) { createResult.Created = true; createResult.Student = Mapper.Map <GetStudentDTO>(createdStudent); return(createResult); } return(createResult); }
private async Task BuildForInternalAsync(Tenant tenant) { //Create Organization Units var organizationUnits = new List <OrganizationUnit>(); var producing = await CreateAndSaveOrganizationUnit(organizationUnits, tenant, "Producing"); var researchAndDevelopment = await CreateAndSaveOrganizationUnit(organizationUnits, tenant, "Research & Development", producing); var ivrProducts = await CreateAndSaveOrganizationUnit(organizationUnits, tenant, "IVR Related Products", researchAndDevelopment); var voiceTech = await CreateAndSaveOrganizationUnit(organizationUnits, tenant, "Voice Technologies", researchAndDevelopment); var inhouseProjects = await CreateAndSaveOrganizationUnit(organizationUnits, tenant, "Inhouse Projects", researchAndDevelopment); var qualityManagement = await CreateAndSaveOrganizationUnit(organizationUnits, tenant, "Quality Management", producing); var testing = await CreateAndSaveOrganizationUnit(organizationUnits, tenant, "Testing", producing); var selling = await CreateAndSaveOrganizationUnit(organizationUnits, tenant, "Selling"); var marketing = await CreateAndSaveOrganizationUnit(organizationUnits, tenant, "Marketing", selling); var sales = await CreateAndSaveOrganizationUnit(organizationUnits, tenant, "Sales", selling); var custRelations = await CreateAndSaveOrganizationUnit(organizationUnits, tenant, "Customer Relations", selling); var supporting = await CreateAndSaveOrganizationUnit(organizationUnits, tenant, "Supporting"); var buying = await CreateAndSaveOrganizationUnit(organizationUnits, tenant, "Buying", supporting); var humanResources = await CreateAndSaveOrganizationUnit(organizationUnits, tenant, "Human Resources", supporting); //Create users var users = _randomUserGenerator.GetRandomUsers(RandomHelper.GetRandom(12, 26), tenant.Id); foreach (var user in users) { //Create the user await _userManager.CreateAsync(user); await CurrentUnitOfWork.SaveChangesAsync(); //Add to roles await _userManager.AddToRoleAsync(user, StaticRoleNames.Tenants.User); //Add to OUs var randomOus = RandomHelper.GenerateRandomizedList(organizationUnits).Take(RandomHelper.GetRandom(0, 3)); foreach (var ou in randomOus) { await _userManager.AddToOrganizationUnitAsync(user, ou); } //Set profile picture if (RandomHelper.GetRandom(100) < 70) //A user will have a profile picture in 70% probability. { await SetRandomProfilePictureAsync(user); } } //Set a picture to admin! var admin = await _userManager.FindByNameAsync(AbpUserBase.AdminUserName); await SetRandomProfilePictureAsync(admin); //Create Friendships var friends = RandomHelper.GenerateRandomizedList(users).Take(3).ToList(); foreach (var friend in friends) { await _friendshipManager.CreateFriendshipAsync( new Friendship( admin.ToUserIdentifier(), friend.ToUserIdentifier(), tenant.TenancyName, friend.UserName, friend.ProfilePictureId, FriendshipState.Accepted) ); await _friendshipManager.CreateFriendshipAsync( new Friendship( friend.ToUserIdentifier(), admin.ToUserIdentifier(), tenant.TenancyName, admin.UserName, admin.ProfilePictureId, FriendshipState.Accepted) ); } //Create chat message var friendWithMessage = RandomHelper.GenerateRandomizedList(friends).First(); _chatMessageRepository.InsertAndGetId( new ChatMessage( friendWithMessage.ToUserIdentifier(), admin.ToUserIdentifier(), ChatSide.Sender, L("Demo_SampleChatMessage"), ChatMessageReadState.Read ) ); _chatMessageRepository.InsertAndGetId( new ChatMessage( admin.ToUserIdentifier(), friendWithMessage.ToUserIdentifier(), ChatSide.Receiver, L("Demo_SampleChatMessage"), ChatMessageReadState.Unread ) ); }
public async Task <IdentityResult> AddToRoleAsync(User user, string role) { return(await _userManager.AddToRoleAsync(user, role)); }
public async Task ApproveAsync(int userId) { await _userManager.AddToRoleAsync(userId, DefaultRole.ApprovedUser.ToString()); }
public async Task <int> CreateWithAdminUserAsync( string tenancyName, string name, string adminPassword, string adminEmailAddress, string connectionString, bool isActive, int?editionId, bool shouldChangePasswordOnNextLogin, bool sendActivationEmail, DateTime?subscriptionEndDate, bool isInTrialPeriod, string emailActivationLink, string tenantUrl) { int newTenantId; long newAdminId; await CheckEditionAsync(editionId, isInTrialPeriod); using (var uow = _unitOfWorkManager.Begin(TransactionScopeOption.RequiresNew)) { if (tenantUrl.IsNullOrEmpty()) { throw new UserFriendlyException("You forgot to enter Tenant URL"); } //Create tenant var tenant = new Tenant(tenancyName, name) { IsActive = isActive, EditionId = editionId, SubscriptionEndDateUtc = subscriptionEndDate?.ToUniversalTime(), IsInTrialPeriod = isInTrialPeriod, ConnectionString = connectionString.IsNullOrWhiteSpace() ? null : SimpleStringCipher.Instance.Encrypt(connectionString), TenantUrl = tenantUrl }; await CreateAsync(tenant); await _unitOfWorkManager.Current.SaveChangesAsync(); //To get new tenant's id. //Create tenant database _abpZeroDbMigrator.CreateOrMigrateForTenant(tenant); //We are working entities of new tenant, so changing tenant filter using (_unitOfWorkManager.Current.SetTenantId(tenant.Id)) { //Create static roles for new tenant CheckErrors(await _roleManager.CreateStaticRoles(tenant.Id)); await _unitOfWorkManager.Current.SaveChangesAsync(); //To get static role ids //grant all permissions to admin role var adminRole = _roleManager.Roles.Single(r => r.Name == StaticRoleNames.Tenants.Admin); await _roleManager.GrantAllPermissionsAsync(adminRole); //User role should be default var userRole = _roleManager.Roles.Single(r => r.Name == StaticRoleNames.Tenants.User); userRole.IsDefault = true; CheckErrors(await _roleManager.UpdateAsync(userRole)); //Create admin user for the tenant if (adminPassword.IsNullOrEmpty()) { adminPassword = User.CreateRandomPassword(); } var adminUser = User.CreateTenantAdminUser(tenant.Id, adminEmailAddress); adminUser.Password = _passwordHasher.HashPassword(adminUser, adminPassword); adminUser.ShouldChangePasswordOnNextLogin = shouldChangePasswordOnNextLogin; adminUser.IsActive = true; CheckErrors(await _userManager.CreateAsync(adminUser)); await _unitOfWorkManager.Current.SaveChangesAsync(); //To get admin user's id //Assign admin user to admin role! CheckErrors(await _userManager.AddToRoleAsync(adminUser, adminRole.Name)); //Notifications await _appNotifier.WelcomeToTheApplicationAsync(adminUser); //Send activation email if (sendActivationEmail) { adminUser.SetNewEmailConfirmationCode(); await _userEmailer.SendEmailActivationLinkAsync(adminUser, emailActivationLink, adminPassword); } await _unitOfWorkManager.Current.SaveChangesAsync(); await _demoDataBuilder.BuildForAsync(tenant); newTenantId = tenant.Id; newAdminId = adminUser.Id; } await uow.CompleteAsync(); } //Used a second UOW since UOW above sets some permissions and _notificationSubscriptionManager.SubscribeToAllAvailableNotificationsAsync needs these permissions to be saved. using (var uow = _unitOfWorkManager.Begin(TransactionScopeOption.RequiresNew)) { using (_unitOfWorkManager.Current.SetTenantId(newTenantId)) { await _notificationSubscriptionManager.SubscribeToAllAvailableNotificationsAsync(new UserIdentifier(newTenantId, newAdminId)); await _unitOfWorkManager.Current.SaveChangesAsync(); await uow.CompleteAsync(); } } return(newTenantId); }