public async void Register_User_Fails_When_User_Already_Exists()
{
_userRepository.Setup(u => u.UserExists("*****@*****.**"))
.Returns(Task.FromResult(true));
var command = new UserRegisterCommand
{
Email = "*****@*****.**",
FirstName = "fname",
LastName = "lname",
Password = "******",
};
var commandHandler = new UserRegisterCommandHandler(
_userRepository.Object
, _hashGenerator.Object
, _jwtTokenGenerator.Object
, _placeHolderImageProvider.Object
, _unitOfWork.Object);
var result = await commandHandler.Handle(command, CancellationToken.None);
Assert.False(result.Success);
Assert.Equal("User already exists.", result.Message);
}
public async void User_Register_Succeeds_When_User_Does_Not_Already_Exists()
{
_userRepository.Setup(u => u.GetUserByEmail(It.IsAny <string>()))
.Returns(Task.FromResult <AppUser>(null));
_hashGenerator.Setup(h => h.ComputeHash(It.IsAny <string>()))
.Returns("password-hash");
_jwtTokenGenerator.Setup(t => t.GenerateToken(
It.IsAny <string>(), It.IsAny <string>(), It.IsAny <int>())).Returns("jwt-token");
var command = new UserRegisterCommand
{
Email = "*****@*****.**",
FirstName = "fname",
LastName = "lname",
Password = "******",
};
var commandHandler = new UserRegisterCommandHandler(
_userRepository.Object
, _hashGenerator.Object
, _jwtTokenGenerator.Object
, _placeHolderImageProvider.Object
, _unitOfWork.Object);
var result = await commandHandler.Handle(command, CancellationToken.None);
Assert.True(result.Success);
Assert.NotNull(result.AccessToken);
Assert.NotNull(result.User);
}
public async Task <IActionResult> Create([FromBody] UserRegister userRegister)
{
if (!ModelState.IsValid)
{
var errors = ModelState.GetErrors();
return(Json(new Respond {
IsSucceed = false, Message = string.Join(",", errors)
}));
}
var exist = await _userQuery.QueryByLoginAsync(userRegister.LoginName);
if (exist != null)
{
return(Json(new Respond {
IsSucceed = false, Message = $"登录名{userRegister.LoginName}已存在!"
}));
}
userRegister.Id = NewId.StringId();
userRegister.Password = userRegister.Password.CreatePassword();
var cmd = new UserRegisterCommand(userRegister)
{
Id = userRegister.Id
};
await _bus.SendAsync(cmd);
return(Json(Respond.Succeed));
}
public CommandResult Register(UserRegisterCommand command)
{
bool exist = _repository.ExistName(command.Username);
if (exist)
{
return(new CommandResult(false, "Este nome já está cadastrado! "));
}
exist = _repository.ExistEmail(command.Email);
if (exist)
{
return(new CommandResult(false, "Este email já está cadastrado! "));
}
var user = new User(command.Username, command.Email, command.Password);
if (user.Invalid)
{
return(new CommandResult(false, string.Join(". ", Notifications)));
}
// Add Hash and Salt
var salt = SaltGenerator.Generate();
var hash = HashGenerator.Generate(user.Password, salt);
user.AddHash(hash, Convert.ToBase64String(salt));
user.AddEmailToken();
_repository.Register(user);
user.HidePassword();
return(new CommandResult(true, "Cadastro realizado! Valide seu e-mail. ", user));
}
public UserPostResponseModel Post([FromBody] UserPostRequestModel request)
{
var command = new UserRegisterCommand(request.UserName);
var result = userApplicationService.Register(command);
return(new UserPostResponseModel(result.CreatedUserId));
}
public async Task <IActionResult> Register(UserRegisterCommand model)
{
if (ModelState.IsValid)
{
var userByEmail = await _queryBus.Send(new GetUserByEmailQuery(model.Email));
if (userByEmail != null)
{
return(BadRequest("Email already exists"));
}
var userByUsername = await _queryBus.Send(new GetUserByUserNameQuery(model.Username));
if (userByUsername != null)
{
return(BadRequest("Username already exists"));
}
model.Id = Guid.NewGuid();
var result = await _commandBus.Send(model);
if (result.Succeeded)
{
var res = await _commandBus.Send(new GenerateTokenJWTCommand(model.Id.Value, model.Fingerprint));
return(Ok(res));
}
else
{
return(BadRequest("Username or password invalid"));
}
}
else
{
return(BadRequest(ModelState));
}
}
public void UserCreateTest()
{
using (var lifetime = container.BeginLifetimeScope())
{
DefaultCommandBus commandBus = lifetime.Resolve <DefaultCommandBus>();
IMappingEngine mapper = lifetime.Resolve <IMappingEngine>();
User user = new User()
{
FirstName = "Test",
LastName = "User",
Email = "*****@*****.**",
DateCreated = DateTime.Now,
RoleId = 1,
Activated = true
};
UserRegisterCommand command = mapper.Map <UserRegisterCommand>(user);
command.Password = "******";
IValidationHandler <UserRegisterCommand> validationHandler = lifetime.Resolve <IValidationHandler <UserRegisterCommand> >();
IEnumerable <ValidationResult> validations = commandBus.Validate(command, validationHandler);
foreach (var val in validations)
{
Assert.IsNull(val, "Error: User creation did not validate " + val.Message);
}
ICommandHandler <UserRegisterCommand> commnadHandler = lifetime.Resolve <ICommandHandler <UserRegisterCommand> >();
ICommandResult result = commandBus.Submit(command, commnadHandler);
Assert.IsNotNull(result, "Error: User was not created by CommandBus");
Assert.IsTrue(result.Success, "Error: User was not created by CommandBus");
}
}
public void TestAlreadyExists()
{
var userFactory = new InMemoryUserFactory();
var userRepository = new InMemoryUserRepository();
var userService = new UserService(userRepository);
var userApplicationService = new UserApplicationService(userFactory, userRepository, userService);
var userName = "******";
userRepository.Save(new User(
new UserId("test-id"),
new UserName(userName),
UserType.Normal
));
bool exceptionOccured = false;
try
{
var command = new UserRegisterCommand(userName);
userApplicationService.Register(command);
}
catch
{
exceptionOccured = true;
}
Assert.IsTrue(exceptionOccured);
}
public static void Main(string[] args)
{
Startup();
while (true)
{
Console.WriteLine("Input user name");
Console.Write(">");
var input = Console.ReadLine();
var userApplicationService = serviceProvider.GetService <UserApplicationService>();
var command = new UserRegisterCommand(input);
userApplicationService.Register(command);
Console.WriteLine("-------------------------");
Console.WriteLine("user created:");
Console.WriteLine("-------------------------");
Console.WriteLine("user name:");
Console.WriteLine("- " + input);
Console.WriteLine("-------------------------");
Console.WriteLine("continue? (y/n)");
Console.Write(">");
var yesOrNo = Console.ReadLine();
if (yesOrNo == "n")
{
break;
}
}
}
public void Handle(UserRegisterCommand message)
{
ExecuteDomainCreate(message.AggregateId, aggregate =>
{
aggregate.Registe(message.UserName, message.Password);
});
}
public void Register(UserRegisterCommand command)
{
var userName = new UserName(command.Name);
var user = userFactory.Create(userName);
userRepository.Save(user);
}
public async Task <IActionResult> RegisterAsync([FromBody] UserRegisterCommand command)
{
await DispatchAsync(command);
var created = GetDto <UserDto>(command.Id);
return(Created(Endpoints.Users, created));
}
public async Task <IActionResult> CreateAsync([FromBody] UserRegisterCommand command)
{
await DispatchCommandAsync(command);
var user = GetCachedObject <UserDto>(command.Id);
return(Created($"api/users/{command.Id}", user));
}
public RegisterVM(IUserService userService)
{
_userService = userService;
Image = ImageSource.FromResource("FoodApp.Assets.Icons.icon_user.png");
CancelRegisterCommand = new CancelRegisterCommand(this);
UserRegisterCommand = new UserRegisterCommand(this);
User = new UserForRegisterDto();
}
public async Task Users_Should_SendMessages()
{
var command = new UserRegisterCommand
{
Id = Guid.NewGuid(),
Email = "*****@*****.**",
Password = "******",
Name = "Mirrabel",
Surname = "Ernest"
};
var command2 = new UserRegisterCommand
{
Id = new Guid("6759d0df-9838-4641-b332-f251b05fcd44"),
Email = "*****@*****.**",
Password = "******",
Name = "Mirrabel",
Surname = "Ernest"
};
// await _backendFixture.SendAsync<UserDto>(HttpMethod.Post, "api/users", command2);
await _backendFixture.LoginAsync(command.Email, command.Password);
var connection1 = _backendFixture.CreateHubConnection();
var message = new CreateMessageCommand
{
Id = Guid.NewGuid(),
Content = "Mario bross",
Receiver = new Guid("6759d0df-9838-4641-b332-f251b05fcd44")
};
await _backendFixture.LoginAsync(command2.Email, command2.Password);
var connection2 = _backendFixture.CreateHubConnection();
await connection2.StartAsync();
var tcs = new TaskCompletionSource <CreateMessageCommand>();
connection2.On(Channels.Chat.Messages, new[] { typeof(CreateMessageCommand) }, async(p1, p2) =>
{
tcs.SetResult(p1[0] as CreateMessageCommand);
},
new object());
await connection1.StartAsync();
await connection1.SendCoreAsync(Channels.Chat.Messages, new[] { message });
await tcs.Task;
tcs.Task.Result.Id.Should().Be(message.Id);
tcs.Task.Result.Content.Should().Be(message.Content);
tcs.Task.Result.Receiver.Should().Be(message.Receiver);
}
public async Task <IActionResult> Register([FromBody] UserRegisterCommand command)
{
if (!ModelState.IsValid)
{
return(StatusCode(400, ModelState));
}
var response = await _mediator.Send(command);
return(response.Success ? (IActionResult)Ok(response) : StatusCode(400, new { response.Errors, response.Success }));
}
public async Task <ActionResult> RegisterUser([FromBody] UserRegisterCommand register)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await Mediator.Send(register);
return(Ok(result));
}
public ApplicationUser(UserRegisterCommand command)
{
this.FirstName = command.FirstName;
this.LastName = command.LastName;
this.DateOfBirth = command.DateOfBirth;
this.UserName = command.UserName;
this.Email = command.Email;
this.NormalizedEmail = this.Email.ToUpper();
this.PasswordHash = new PasswordHasher <ApplicationUser>().HashPassword(this, command.Password);
}
public async Task api_users_should_can_register()
{
var cmd = new UserRegisterCommand
{
Id = Guid.NewGuid(),
Email = _usersGenerator.GetEmail(),
Password = _usersGenerator.GetPassword()
};
await _backendFixture.SendAsync <object>(HttpMethod.Post, Endpoints.Users, cmd);
}
public void Register(UserRegisterCommand command)
{
var name = new UserName(command.Name);
var user = new User(name);
if (userService.Exists(user))
{
throw new CanNotRegisterUserException(user, "ユーザは既に存在しています。");
}
userRepository.Save(user);
}
public void Register(UserRegisterCommand command)
{
var name = new UserName(command.Name);
var user = userFactory.Create(name);
if (userService.Exists(user))
{
throw new CanNotRegisterUserException(user, "이미 등록된 사용자임");
}
userRepository.Save(user);
}
public void Register(UserRegisterCommand command)
{
UserName userName = new UserName(command.getName());
User user = userFactory.create(userName);
if (userService.exists(user))
{
throw new CanNotRegisterUserException(user, "ユーザは既に存在しています。");
}
userRepository.save(user);
}
public void UserAuthHandler_Register_Pass_less_than_4_Characters_Invalid()
{
var repository = new FakeUserAuthRepository();
var logRepository = new FakeAccessLogRepository();
var handler = new UserAuthHandler(repository, logRepository);
var command = new UserRegisterCommand();
command.Username = "******";
command.Password = "******";
var result = handler.Register(command);
Assert.IsFalse(result.Success);
}
public void UserAuthHandler_Register_Valid()
{
var repository = new FakeUserAuthRepository();
var logRepository = new FakeAccessLogRepository();
var handler = new UserAuthHandler(repository, logRepository);
var command = new UserRegisterCommand();
command.Username = "******";
command.Password = "******";
var result = handler.Register(command);
Assert.IsTrue(result.Success);
}
// 略
public void Register(UserRegisterCommand command)
{
var userName = new UserName(command.Name);
var user = userFactory.Create(userName);
if (userService.Exists(user))
{
throw new CanNotRegisterUserException(user, "ユーザーは既に存在しています");
}
// アプリケーション側でのバリデーションのみでは
// 同時に登録処理を行った場合に同じ名前のユーザーが登録できてしまう
userRepository.Save(user);
}
public CommandResult Register(UserRegisterCommand command)
{
CommandResult result = _handler.Register(command);
if (result.Success)
{
var user = (User)result.Data;
_emailService.Send(user.Username, user.Email, user.EmailToken);
user.HideEmailToken();
result.Data = user;
}
return(result);
}
public void Register(UserRegisterCommand command)
{
using (var transaction = connection.BeginTransaction())
{
var userName = new UserName(command.Name);
var user = userFactory.Create(userName);
if (userService.Exists(user))
{
throw new CanNotRegisterUserException(user, "ユーザは既に存在しています");
}
userRepository.Save(user, transaction);
transaction.Commit();
}
}
public void Register(UserRegisterCommand command)
{
var userName = new UserName(command.Name);
var user = new User(
userRepository.NextIdentity(),
userName
);
if (userService.Exists(user))
{
throw new CanNotRegisterUserException(user);
}
userRepository.Save(user);
}
public User Create(User user, string password)
{
UserRegisterCommand command = new UserRegisterCommand();
command.UserDTO = new UserDTO
{
Id = user.Id,
DisplayName = user.DisplayName,
FirstName = user.FirstName,
LastName = user.LastName,
Password = password,
Username = user.Username
};
return(_mediator.Send(command).Result);
}
static void Main(string[] args)
{
Startup();
while (true)
{
Console.WriteLine("Input user name");
Console.Write(">");
var input = Console.ReadLine();
var userApplicationService = serviceProvider.GetService <userApplicationService>();
var command = new UserRegisterCommand(input);
userApplicationService.Register(command);
// ...略
}
}
