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
}
});
}
}
