public async Task <(List <ValidationResult> Result, AddUserDto User)> CreateUser(AddUserDto vm) { results.Clear(); try { var user = AppUser.Create(vm.FirstName, vm.LastName, vm.Email, vm.Gender, vm.PhoneNumber, vm.NIN); bool isValid = Validator.TryValidateObject(user, new ValidationContext(user, null, null), results, false); if (!isValid || results.Count > 0) { return(results, null); } user.UserName = vm.Email; user.EmailConfirmed = true; user.FullName = vm.FirstName + " " + vm.LastName; user.Activated = true; user.IsDisabled = false; user.CreatedOnUtc = DateTime.Now.GetDateUtcNow(); user.LockoutEnabled = false; var createResult = await _userManager.CreateAsync(user, vm.Password); createResult = await _userManager.AddToRolesAsync(user, vm.Roles); } catch (Exception ex) { results.Add(new ValidationResult($"User couldn't be created! \n {ex.Message}")); } return(results, vm); }
public async Task <IActionResult> Register([FromBody] RegisterForDto model) { ApiResponse <RegisterForDto> response = new ApiResponse <RegisterForDto>(); try { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (string.IsNullOrEmpty(model.Password) || string.IsNullOrEmpty(model.RTPassword)) { return(BadRequest(new { error = "Password & Repeat password is required." })); } if (model.Password != model.RTPassword) { return(BadRequest(new { error = "Password & Repeat password does not match." })); } if (await _userSrv.UserExists(model.Email)) { ModelState.AddModelError("Email", "Email already taken"); } var IsPhoneAlreadyRegistered = _userManager.Users.Any(item => item.PhoneNumber == model.PhoneNumber); if (IsPhoneAlreadyRegistered == true) { return(BadRequest(new { error = $"{model.PhoneNumber} Already exist!" })); } var user = AppUser.Create(model.FirstName, model.LastName, model.Email, model.Gender, model.PhoneNumber, model.NIN); user.UserName = model.Email; user.EmailConfirmed = true; user.FullName = model.FirstName + " " + model.LastName; user.Activated = true; user.IsDisabled = false; user.CreatedOnUtc = DateTime.Now.GetDateUtcNow(); user.LockoutEnabled = false; var createResult = await _userManager.CreateAsync(user, model.Password); if (!createResult.Succeeded) { return(BadRequest(new { error = $"{createResult.Errors.FirstOrDefault().Description}" })); } createResult = await _userManager.AddToRoleAsync(user, "USER"); if (!createResult.Succeeded) { return(BadRequest(new { error = $"{createResult.Errors.FirstOrDefault().Description}" })); } response.Code = ApiResponseCodes.OK; response.Description = $"Registration Successful"; return(Ok(response)); } catch (Exception ex) { return(BadRequest(ex.Message)); } }
public void AppUser_ShouldNotCreate_A_User_With_EmptyValues(string name, string email) { // ARRANGE // ACT var appUser = AppUser.Create(email, name); // ASSERT Assert.True(appUser.Invalid); }
// POST: api/User public async Task <InsertId> Post([FromBody] AppUserMutate value) { AppUser newUser = AppUser.Create(value.UserName, value.Email, this.GetCurrentGroup()); IdentityResult result = await this._appUserManager.CreateAsync(newUser, value.NewPassword); this.EnsureSucceeded(result); return(newUser.Id); }
private async Task ExecuteCore(SetupUserModel data) { AppUser user = AppUser.Create(data.UserName, data.Email, new AppOwner("Administrator")); IdentityResult result = await this._userManager.CreateAsync(user, data.Password); EnsureSuccess(result); result = await this._userManager.AddToRoleAsync(user, AppRole.KnownRoles.Administrator); EnsureSuccess(result); }
public void AppUser_ShouldCreate_A_User() { // ARRANGE var name = "name"; var email = "email"; // ACT var appUser = AppUser.Create(email, name); // ASSERT Assert.Equal(name, appUser.Name); Assert.Equal(email, appUser.Email); }
private static void SeedAccounts(AppDbContext context) { DbSet <AppOwner> appOwners = context.Set <AppOwner>(); // add initial user var owner = new AppOwner("Initial"); appOwners.Add(owner); AppUser user = AppUser.Create("User", "*****@*****.**", owner); var svc = new AppUserManager(new AppUserStore(context)); svc.Create(user, "welcome01"); context.SaveChanges(); }
public async Task <UserLoginViewModel> Handle(UserRegisterCommand request, CancellationToken cancellationToken) { var userExists = await _userRepository.UserExists(request.Email); if (userExists) { return new UserLoginViewModel { Success = false, Message = "User already exists." } } ; var passwordHash = _hashGenerator.ComputeHash(request.Password); var user = AppUser.Create( firstname: request.FirstName, lastname: request.LastName, email: request.Email, passwordHash: passwordHash); await _userRepository.AddAsync(user); await _unitOfWork.SaveChangesAsync(CancellationToken.None); var accessToken = _tokenGenerator.GenerateToken(user.LastName, user.Email, user.Id); return(new UserLoginViewModel { Success = true, AccessToken = accessToken, User = new UserInfo { FirstName = user.FirstName, LastName = user.LastName, Email = user.Email, UserId = user.Id, Image = user.ProfilePicture ?? _placeholderImageProvider.GetProfileImagePlaceHolder() } }); } }
public async Task <AppUser> RegisterAsync(IRegisterUserDto user) { if (user is null) { throw new ArgumentNullException(nameof(user)); } byte[] passwordHash, passwordSalt; CreatePasswordHash(user.Password, out passwordHash, out passwordSalt); AppUser appUser = AppUser.Create(user.UserName); appUser.PasswordHash = passwordHash; appUser.PasswordSalt = passwordSalt; appUser.CreatedDate = DateTimeOffset.UtcNow; await _dbContext.Users.AddAsync(appUser).ConfigureAwait(false); await _dbContext.SaveChangesAsync().ConfigureAwait(false); return(appUser); }
public async Task <IActionResult> Post([FromBody] AppUserMutate value) { AppUser newUser = AppUser.Create(value.UserName, value.Email, this.GetCurrentGroup()); await this.ValidatePasswordInformation(value, newUser); if (!this.ModelState.IsValid) { return(this.BadRequest(this.ModelState)); } IdentityResult result = await this._appUserManager.CreateAsync(newUser, value.NewPassword); if (!result.Succeeded) { this.ModelState.AppendIdentityResult(result, _ => nameof(value.UserName)); return(this.BadRequest(this.ModelState)); } return(this.CreatedAtRoute("User-Get", new { id = newUser.Id }, await this.Get(newUser.Id))); }
public async Task <Unit> Handle(CreateAppUserCommand request, CancellationToken cancellationToken) { if (await _unitOfWork.Users.GetByEmailAsync(request.Email, cancellationToken) != null) { _appNotificationHandler.AddNotification(Keys.APPUSER, Messages.EMAIL_EXISTS); return(Unit.Value); } var appUser = AppUser.Create(request.Name, request.Email); if (appUser.Invalid) { _appNotificationHandler.AddNotifications(appUser.ValidationResult); return(Unit.Value); } var passwordHash = _passwordHasher.HashPassword(appUser, request.Password); appUser.UpdatePassword(passwordHash); await _unitOfWork.Users.AddAsync(appUser, cancellationToken); var @event = _mapper.Map <AppUser, AppUserCreatedEvent>(appUser); @event.UserId = appUser.Id; var success = await _unitOfWork.SaveChangesAndCommitAsync(@event); if (success) { await _distributedCache.RemoveAsync(CacheKeys.LIST_ALL_USERS); return(Unit.Value); } throw new AppException(HttpStatusCode.InternalServerError); }
public async Task <IActionResult> Register([FromBody] RegisterModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var existingUser = _dbContext.Users.FirstOrDefault(x => x.Email.Equals(model.Email, StringComparison.InvariantCultureIgnoreCase)); if (existingUser != null) { return(BadRequest(BaseResponse.Error("user already exists."))); } var passwordHash = GetHash(model.Password); var user = AppUser.Create( firstname: model.FirstName, lastname: model.LastName, email: model.Email, passwordHash: passwordHash); try { await _dbContext.Users.AddAsync(user); await _dbContext.SaveChangesAsync(); var tokenResponse = GenerateToken(user); return(Ok(BaseResponse.Ok(tokenResponse))); } catch (Exception ex) { return(BadRequest(BaseResponse.Error("error processing request."))); } }
public async Task <UserLoginViewModel> Handle(UserExternalLoginQuery request, CancellationToken cancellationToken) { var user = await _externalAuthProvider.LoginExternal(request.Provider, request.AccessToken); if (user.Error != null) { return new UserLoginViewModel { Success = false, Message = user.Error } } ; var existingUser = await _userRepository.GetUserByEmail(user.Email); string accesstoken = string.Empty; if (existingUser == null) { var newUser = AppUser.Create( firstname: user.FirstName, lastname: user.LastName, email: user.Email, passwordHash: "" ); newUser.ProfilePicture = user.Picture; await _userRepository.AddAsync(newUser); await _unitOfWork.SaveChangesAsync(CancellationToken.None); accesstoken = _tokenGenerator.GenerateToken(newUser.LastName, newUser.Email, newUser.Id); return(new UserLoginViewModel { Success = true, AccessToken = accesstoken, User = new UserInfo { FirstName = newUser.FirstName, LastName = newUser.LastName, Email = newUser.Email, UserId = newUser.Id, Image = newUser.ProfilePicture } }); } if (existingUser.ProfilePicture == null && user.Picture != null) { existingUser.ProfilePicture = user.Picture; _userRepository.Update(existingUser); await _unitOfWork.SaveChangesAsync(CancellationToken.None); } accesstoken = _tokenGenerator.GenerateToken(existingUser.LastName, existingUser.Email, existingUser.Id); return(new UserLoginViewModel { Success = true, AccessToken = accesstoken, User = new UserInfo { FirstName = existingUser.FirstName, LastName = existingUser.LastName, Email = existingUser.Email, UserId = existingUser.Id, Image = existingUser.ProfilePicture } }); } }