public IHttpActionResult SignUp([FromBody] NewUser newUser)
{
if (newUser == null)
{
return(BadRequest());
}
var command = new RegisterNewUserCommand(newUser);
if (!command.IsValidCommand())
{
return(BadRequest());
}
_registerUserUseCase.Handle(command);
var query = new GetUserQuery(command.Login);
var createdUser = _getUserUseCase.Handle(query);
if (createdUser == null)
{
return(NotFound());
}
var newUserUrl = createdUser.Links.Single(x => x.Rel == "self").Href;
return(Created(newUserUrl, createdUser));
}
public async Task Register(string email, string password)
{
var command = new RegisterNewUserCommand
{
Email = email,
Password = _sha512Service.Calculate(password)
};
await CommandBus.Execute(command);
}
public void register_new_user()
{
var command = new RegisterNewUserCommand()
{
Email = "*****@*****.**",
Password = "******"
};
_handler.Execute(command);
Assert.IsTrue(_repo.FindBy(x => x.Email == command.Email).FirstOrDefault() != null);
}
public async Task <bool> Handle(RegisterNewUserCommand request, CancellationToken cancellationToken)
{
if (!request.IsValid())
{
NotifyValidationErrors(request);
return(false);
}
var uid = _idGenerator.CreateId();
var avatar = GetAvatar(uid);
var user = new ApplicationUser
{
Id = Guid.NewGuid(),
Email = request.Email,
UserName = request.UserName,
Nickname = request.Nickname,
PhoneNumber = request.PhoneNumber,
Uid = uid,
Avatar = avatar
};
var emailAlreadyExist = await _userManager.FindByEmailAsync(user.Email);
if (emailAlreadyExist != null)
{
await _bus.RaiseEvent(new DomainNotification("email_already_existed", "E-mail already exist. If you don't remember your passwork, reset it."));
return(false);
}
var usernameAlreadyExist = await _userManager.FindByNameAsync(user.UserName);
if (usernameAlreadyExist != null)
{
await _bus.RaiseEvent(new DomainNotification("username_already_existed", "Username already exist. If you don't remember your passwork, reset it."));
return(false);
}
var result = await _userManager.CreateAsync(user, request.Password);
if (result.Succeeded)
{
await _bus.RaiseEvent(new UserRegisteredEvent(user.Id.ToString(), user.UserName, user.Email));
await SendComfirmEmailAsync(user);
return(true);
}
return(false);
}
public async Task <ValidateableResponse <ApiResponse <int> > > Handle(RegisterNewUserCommand request,
CancellationToken cancellationToken)
{
// normally there would be code here which calls a service to persist the new user.
// For demo purposes, I will just return the Id of 10 for the new imaginary user.
return(await Task.FromResult(
new ValidateableResponse <ApiResponse <int> >(
new ApiResponse <int>
{
Data = 10,
Outcome = OperationOutcome.SuccessfulOutcome
}
)
));
}
private async Task <ApplicationUser> CreateAndLoginNewUser(RegisterNewUserCommand request)
{
var newUser = new ApplicationUser {
Name = request.Name,
UserName = request.Email,
Email = request.Email
};
var createUser = await _userManager.CreateAsync(newUser, request.Password);
if (!createUser.Succeeded)
{
return(null);
}
return(newUser);
}
public async Task OnGet(string publicName, string code = null)
{
var newUserCommand = new RegisterNewUserCommand();
// if publicName is NOT empty, then this is a student registration with a specific instructor
if (!string.IsNullOrEmpty(publicName))
{
if (publicName.Trim().ToUpper() == "INSTRUCTOR")
{
// code should be passed from the invitation email link
if (code != null)
{
newUserCommand.EntryCode = code;
}
}
else
{
// check if publicName maps to instructor profile
Instructor = await GetInstructorDetails(publicName);
// if yes
if (Instructor != null)
{
// code should be passed from the invitation email link
if (code != null)
{
newUserCommand.EntryCode = code;
}
newUserCommand.InstructorId = Instructor.ProfileId;
}
else
{
// instructor doesn't exist so user is going to be registered as an invited instructor or uninvited user
// do nothing
}
}
}
else
{
// this is could be an invited instructor registering
// or it's an uninvited user who found the registration page and is attempting to register
// do nothing
}
Data = newUserCommand;
}
public async Task <IActionResult> RegisterNewUser([FromBody] RegisterNewUserCommand command)
{
if (command == null)
{
return(BadRequest());
}
var response = await _mediator.Send(command);
if (response.HasError)
{
return(BadRequest(new { errors = response.Errors.Select(x => x) }));
}
return(Created("", new
{
response.UserId,
response.UserName,
response.Email,
response.DocumentNumber
}));
}
public async Task <Result <UserAndTokenDto> > Handle(RegisterNewUserCommand request, CancellationToken cancellationToken)
{
if (await _context.Users.AnyAsync(x => x.Email == request.Email))
{
return(Result <UserAndTokenDto> .Failure("Email already exists."));
}
var newUser = await CreateAndLoginNewUser(request);
if (newUser is null)
{
return(Result <UserAndTokenDto> .Failure("Unable to create new user."));
}
var refreshToken = await CreateAndSaveRefreshToken(newUser);
if (refreshToken is null)
{
return(Result <UserAndTokenDto> .Failure("Unable to save new refresh token."));
}
return(FinishRegister(newUser, refreshToken));
}
public Task <AccountResult?> CreateUserWithPass(RegisterNewUserCommand command, string password)
{
var user = _userFactory.Create(command);
return(CreateUser(user, command, password, null, null));
}
public async Task <IActionResult> Register([FromBody] RegisterNewUserCommand command)
{
return(HandleResult(await Mediator.Send(command)));
}
public IHttpActionResult Register(RegisterNewUserCommand command)
{
this._commandDispatcher.Dispatch(command);
return(this.Ok());
}
