public async Task SignUp(SignUpRequestDto signUpRequest, CancellationToken cancellationToken)
{
var existingUser = await _userManager.FindByNameAsync(signUpRequest.UserName);
var userToAdd = _mapper.Map <User>(signUpRequest);
if (existingUser is not null)
{
if (await _userManager.IsEmailConfirmedAsync(existingUser))
{
throw new BadRequestException(nameof(ErrorStrings.DuplicateEmail));
}
else
{
await _userManager.DeleteAsync(existingUser);
userToAdd.ConfirmationEmailRequestedOn = existingUser.ConfirmationEmailRequestedOn;
}
}
var result = await _userManager.CreateAsync(userToAdd, signUpRequest.Password);
if (result.Succeeded is false)
{
throw new ResourceValidationException(result.Errors.Select(e => e.Code).ToArray());
}
await SendConfirmationEmail(new() { Email = userToAdd.Email }, userToAdd, cancellationToken);
}
public bool SignUp(SignUpRequestDto signUpRequest)
{
var user = _repository.Get <AppUser>(x => x.Username == signUpRequest.Username || x.Email == signUpRequest.Email);
if (user == null)
{
string salt = PasswordHasher.CreateSalt();
string hash = PasswordHasher.CreateHashedPassword(signUpRequest.Password, salt);
_repository.Insert <AppUser>(
new AppUser
{
Email = signUpRequest.Email,
Username = signUpRequest.Username,
Salt = salt,
Password = hash
});
_repository.SaveChanges();
return(true);
}
else
{
return(false);
}
}
public async Task <ActionResult> SignUp([FromBody] SignUpRequestDto signUpRequest)
{
if (ModelState.IsValid)
{
var created = _loginService.SignUp(signUpRequest);
if (created)
{
return(Ok());
}
}
return(BadRequest());
}
public async Task <ActionResult> SingUpUserForCourseAsync([FromBody] SignUpRequestDto signUpRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var(courseId, user) = signUpRequest;
await _asyncSignUpService.SignUpAsync(courseId, user);
return(Accepted());
}
public async Task <IActionResult> Register([FromBody] SignUpRequestDto model)
{
try
{
var user = await _userService.Create(model);
return(Ok(user));
}
catch (Exception ex)
{
return(BadRequest(new { error = _localizer[ex.Message].Value }));
}
}
public async Task <ActionResult <ExchangeRefreshTokenResponseDto> > Register([FromBody] SignUpRequestDto request)
{
await _mediator.Publish(new RegisterUserCommand(
request.FirstName,
request.LastName,
request.Email,
request.Street,
request.State,
request.City,
request.Country,
request.BirthDate,
request.PhoneNumber,
request.Password));
return(Ok());
}
public async Task <ActionResult> SingUpUserForCourse([FromBody] SignUpRequestDto signUpRequest)
{
//Can be moved to filter. Removes duplication.
if (!ModelState.IsValid)
{
return(BadRequest());
}
var(courseId, user) = signUpRequest;
var result = await _syncSignUpService.SignUpAsync(courseId, user);
if (result.Success)
{
return(Ok());
}
//then only way our logic can return fail - if there is no empty places
return(new StatusCodeResult(StatusCodes.Status410Gone));
}
public async Task <UserDto> Create(SignUpRequestDto userDto)
{
if (await _unitOfWork.Users.UserNameIsTaken(userDto.Username))
{
throw new ArgumentException("UsernameTaken");
}
CreatePasswordHash(userDto.Password, out byte[] passwordHash, out byte[] passwordSalt);
var user = _mapper.Map <User>(userDto);
user.PasswordHash = passwordHash;
user.PasswordSalt = passwordSalt;
await _unitOfWork.Users.AddAsync(user);
await _unitOfWork.CommitAsync();
return(_mapper.Map <UserDto>(user));
}
public void Execute(SignUpRequestDto request)
{
var userSignUpRequestCreationResult = UserSignUpRequest.Create(
email: request.Email,
password: request.Password
);
if (!userSignUpRequestCreationResult.IsValid)
{
PrintErrors();
}
else
{
ExecuteCommand();
}
void PrintErrors()
{
foreach (var error in userSignUpRequestCreationResult.Errors)
{
consoleLogger.LogInfo(error.FieldId);
consoleLogger.LogInfo(error.Error.ToString());
}
}
void ExecuteCommand()
{
var request = userSignUpRequestCreationResult.Result;
var commandResult = command.Execute(request);
if (!commandResult.IsValid)
{
consoleLogger.LogInfo(commandResult.Error.ToString());
}
else
{
consoleLogger.LogInfo("User registered successfuly!");
}
}
}
public async Task <bool> UserExistsAsync(string email)
{
try
{
var signUpRequestDto = new SignUpRequestDto {
Email = email
};
var isUserExists = await httpService.PostAsync <SignUpRequestDto, SignUpResponseDto>(
AuthorizeEndpoint.CheckUserExists, signUpRequestDto);
return(isUserExists.Succeeded);
}
catch (System.Net.WebException ex)
{
throw new Exceptions.WebException("Server exception", ex);
}
catch (SocketException ex)
{
throw new Exceptions.WebException("Server exception", ex);
}
}
