public async Task <IActionResult> Create([FromBody] CreateUserModel userModel,
[FromServices] IValidatorFactory validatorFactory,
[FromServices] ICreateUserCommand createUserCommand)
{
try
{
if (userModel == null)
{
return(BadRequest(new Message("Something bad happened. Try again.")));
}
IValidator validator = validatorFactory.Create();
string accountId = await createUserCommand.Execute(userModel.AccountId, userModel, validator);
if (validator.HasErrors)
{
return(BadRequest(validator.Errors));
}
else
{
return(Created("", accountId));
}
}
catch (Exception ex)
{
//Log error
_logger.LogError("UserController.Create", "Exception was thrown", new
{
UserModel = userModel,
Exception = ex
});
return(BadRequest(new Message("Something bad happened. Try again")));
}
}
private void SetDomainValues(ICreateUserCommand command)
{
if (!string.IsNullOrEmpty(command.Name))
{
this.Name = command.Name;
}
//if (!string.IsNullOrEmpty(command.Email))
// this.Email = command.Email;
if (!string.IsNullOrEmpty(command.Password))
{
this.PasswordHash = command.Password;
}
if (!string.IsNullOrEmpty(command.Country))
{
this.Country = command.Country;
}
if (!string.IsNullOrEmpty(command.Phone))
{
this.Phone = command.Phone;
}
if (command.Characters != null && command.Characters.Count() > 0)
{
this.Characters = command.Characters;
}
}
public UserModule(IUserRepository userRepo, ICreateUserCommand createUserCommand, IUpdateUserPasswordCommand updateUserPasswordCommand, IDeleteUserCommand deleteUserCommand) : base()
{
_userRepo = userRepo;
_createUserCommand = createUserCommand;
_updateUserPasswordCommand = updateUserPasswordCommand;
_deleteUserCommand = deleteUserCommand;
Get[Actions.User.Default] = (x) =>
{
AddScript(Scripts.UserView);
return(Default());
};
Post[Actions.User.Delete] = (x) =>
{
this.RequiresClaims(new[] { Claims.UserDelete });
return(DeleteUser());
};
Get[Actions.User.List] = (x) =>
{
this.RequiresClaims(new[] { Claims.UserList });
return(List());
};
Post[Actions.User.ChangePassword] = (x) =>
{
return(ChangePassword());
};
Post[Actions.User.Save] = (x) =>
{
this.RequiresClaims(new[] { Claims.UserAdd });
return(Save());
};
}
public UserController(IGetUsersCommand getCommand, IGetUserCommand getOneCommand, ICreateUserCommand createUserCommand, IEditUserCommand editUserCommand, IDeleteUserCommand deleteUserCommand)
{
_getCommand = getCommand;
_getOneCommand = getOneCommand;
_createUserCommand = createUserCommand;
_editUserCommand = editUserCommand;
_deleteUserCommand = deleteUserCommand;
}
public UsersController(ICreateUserCommand userCreate, IEditUserCommand userEdit, IGetUserCommand userGet, IGetUsersPaginatedCommand usersGet, IDeleteUserCommand deleteUser)
{
_userCreate = userCreate;
_userEdit = userEdit;
_userGet = userGet;
_usersGet = usersGet;
_deleteUser = deleteUser;
}
public UsersController(ICreateUserCommand createUser, IGetUsersCommand getUsers, IEditUserCommand editUser, IDeleteUserCommand deleteUser, Context baza)
{
this.createUser = createUser;
this.getUsers = getUsers;
this.editUser = editUser;
this.deleteUser = deleteUser;
this.baza = baza;
}
public UserController(IGetOneUserCommand getOneUser, ICreateUserCommand createUser, IGetUserCommand getUser, IDeleteUserCommand deleteUser, IUpdateUserCommand updateUser)
{
_getOneUser = getOneUser;
_createUser = createUser;
_getUser = getUser;
_deleteUser = deleteUser;
_updateUser = updateUser;
}
public UsersController(IGetUserCommand getUser, IGetUsersCommand getUsers, ICreateUserCommand createUser, IEditUserCommand editUser, IDeleteUserCommand deleteUser)
{
_getUser = getUser;
_getUsers = getUsers;
_createUser = createUser;
_editUser = editUser;
_deleteUser = deleteUser;
}
public void CreateUserCommandTest_SetUp()
{
_dbContext = Substitute.For <IDbContext>();
_userValidator = Substitute.For <IUserValidator>();
_passwordProvider = Substitute.For <IPasswordProvider>();
_createUserCommand = new CreateUserCommand(_dbContext, _userValidator, _passwordProvider);
}
public UsersController(IGetUsersCommand searchUsersCommand, IGetUserCommand getOneUserCommand, ICreateUserCommand createUserCommand, IEditUserCommand editUserCommand, IDeleteUserCommand deleteUserCommand, WebNewsContext context)
{
_searchUsersCommand = searchUsersCommand;
_getOneUserCommand = getOneUserCommand;
_createUserCommand = createUserCommand;
_editUserCommand = editUserCommand;
_deleteUserCommand = deleteUserCommand;
_context = context;
}
public UsersController(
IOptions <AppSettings> appSettings,
ICreateUserCommand createUserCommand,
IAuthenticateUserQuery authenticateUserQuery)
{
_appSettings = appSettings.Value;
_createUserCommand = createUserCommand;
_authenticateUserQuery = authenticateUserQuery;
}
public UsersController(ICreateUserCommand createUser, IActivateUserCommand activateUser, IGetUsersCommand getUsers, IDeleteUserCommand deleteUser, IEditUserEmailCommand editUserEmail, IEditUserPasswordCommand editUserPassword, IAuthenticateUserCommand authUser)
{
_createUser = createUser;
_activateUser = activateUser;
_getUsers = getUsers;
_deleteUser = deleteUser;
_editUserEmail = editUserEmail;
_editUserPassword = editUserPassword;
_authUser = authUser;
}
public CreateUserApplicationKernalService(
ITransactionManager transactionManager,
ICommandRepository <User> commandRepository,
IQueryRepository <Identity> queryRepository,
ICreateUserCommand createUserCommand)
{
_transactionManager = transactionManager;
_commandRepository = commandRepository;
_queryRepository = queryRepository;
_createUserCommand = createUserCommand;
}
public IActionResult Register([FromBody] CreateUserModel user, [FromServices] ICreateUserCommand createUserCommand)
{
if (ModelState.IsValid)
{
var storedUser = createUserCommand.Execute(user);
return(Created(Request.Path.Value + "/" + storedUser.Id, storedUser));
}
else
{
return(BadRequest("User data error"));
}
}
public IActionResult Post([FromBody] AddUser dto, [FromServices] ICreateUserCommand command)
{
try
{
executor.ExecuteCommand(command, dto);
return(StatusCode(202, "User added"));
}
catch (EntityAllreadyExists)
{
return(StatusCode(422, "Fail"));
}
}
public AccountUseCase(
Lazy <IDbTransactionManager> dbTransationManagerLazy,
IMapper mapper,
ICreateUserCommand createUserCommand,
ICreateTokenCommand createTokenCommand,
IUserQuery userQuery)
{
this.dbTransationManagerLazy = dbTransationManagerLazy;
this.mapper = mapper;
this.createUserCommand = createUserCommand;
this.createTokenCommand = createTokenCommand;
this.userQuery = userQuery;
}
public void UserModuleTest_SetUp()
{
_userRepo = Substitute.For <IUserRepository>();
_userValidator = Substitute.For <IUserValidator>();
_passwordProvider = Substitute.For <IPasswordProvider>();
_createUserCommand = Substitute.For <ICreateUserCommand>();
_updateUserPasswordCommand = Substitute.For <IUpdateUserPasswordCommand>();
_deleteUserCommand = Substitute.For <IDeleteUserCommand>();
Mapper.Initialize((cfg) =>
{
cfg.CreateMap <UserViewModel, UserModel>();
});
}
public UserService(IDeleteUserCommand deleteUserCommand,
IUpdateUserCommand updateUserCommand,
ICreateUserCommand createUserCommand,
IGetUserByIdQuery getUserByIdQuery,
IGetAllNonDeletedUsersQuery getAllNonDeletedUsersQuery,
IGetUserByUsernameQuery getUserByUsernameQuery,
IGetUserByEmailQuery getUserByEmailQuery)
{
_deleteUserCommand = deleteUserCommand;
_updateUserCommand = updateUserCommand;
_createUserCommand = createUserCommand;
_getUserByIdQuery = getUserByIdQuery;
_getAllNonDeletedUsersQuery = getAllNonDeletedUsersQuery;
_getUserByUsernameQuery = getUserByUsernameQuery;
_getUserByEmailQuery = getUserByEmailQuery;
}
public UsersController(
ILogger <UsersController> logger,
ICreateUserCommand createUserCommand,
IUpdateUserCommand updateUserCommand,
IDeleteUserCommand deleteUserCommand,
IGetUserQuery getUserQuery,
IGetAllUsersQuery getAllUsersQuery
)
{
this.logger = logger;
this.createUserCommand = createUserCommand;
this.updateUserCommand = updateUserCommand;
this.deleteUserCommand = deleteUserCommand;
this.getUserQuery = getUserQuery;
this.getAllUsersQuery = getAllUsersQuery;
}
public async Task <IActionResult> Register(CreateUserRequest user, [FromServices] ICreateUserCommand command)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
UserResponse response = await command.ExecuteAsync(user);
return(CreatedAtRoute("GetSingleUser", new { userId = response.Id }, response));
}
catch (CannotCreateUserExeption exception)
{
foreach (var error in exception.Errors)
{
ModelState.AddModelError(exception.Message, error.Description);
}
return(BadRequest(ModelState));
}
}
public UserController(ICreateUserCommand createUserCommand, IUserExistsQuery userExistsQuery)
{
_createUserCommand = createUserCommand;
_userExistsQuery = userExistsQuery;
}
public CreateUser(ICreateUserCommand createUserCommand)
{
_createUserCommand = createUserCommand;
}
public void UserServiceTest_SetUp()
{
_userRepo = Substitute.For <IUserRepository>();
_createUserCommand = Substitute.For <ICreateUserCommand>();
_userService = new UserService(_userRepo, _createUserCommand);
}
public IActionResult Post([FromBody] UserCreateDto dto, [FromServices] ICreateUserCommand command)
{
_executor.ExecuteCommand(command, dto);
return(Ok("uneto"));
}
public void Setup()
{
_fixture = new Fixture();
_fixture.Customize(new AutoNSubstituteCustomization());
_userByEmailQuery = _fixture.Freeze<IUserByEmailQuery>();
_createUserCommand = _fixture.Freeze<ICreateUserCommand>();
}
public void Post([FromBody] UserDto dto,
[FromServices] ICreateUserCommand command)
{
_executor.ExecuteCommand(command, dto);
}
public void Create(ICreateUserCommand command, IEnumerable <Role> roles)
{
this.SetDomainValues(command);
this.AddRoles(roles);
}
public IActionResult Post([FromBody] UserDto dto, [FromServices] ICreateUserCommand command)
{
executor.ExecuteCommand(command, dto);
return(StatusCode(StatusCodes.Status201Created));
}
public IActionResult Post([FromBody] UserDto dto,
[FromServices] ICreateUserCommand createUserCommand)
{
_dispatcher.DispatchCommand(createUserCommand, dto);
return(StatusCode(StatusCodes.Status201Created));
}
public ActionResult Post([FromBody] UserDto dto,
[FromServices] ICreateUserCommand command)
{
executor.ExecuteCommand(command, dto);
return(NoContent());
}
public void Setup()
{
_userByEmailQuery = Substitute.For<IUserByEmailQuery>();
_createUserCommand = Substitute.For<ICreateUserCommand>();
_deleteUserCommand = Substitute.For<IDeleteUserCommand>();
}
public UserService(IUserRepository userRepo, ICreateUserCommand createUserCommand)
{
_userRepo = userRepo;
_createUserCommand = createUserCommand;
}
public RegistrationCompletedHandler(ICreateUserCommand createUserCommand)
{
this.createUserCommand = createUserCommand;
}
