public void CreateNewUser_Authorized_201()
{
var controller = new UserManagementController();
var admin = _ut.CreateUserObject();
admin.IsAdministrator = true;
var adminSession = _ut.CreateSessionObject(admin);
_ut.CreateSessionInDb(adminSession);
// modify user
var newUser = new {
username = Guid.NewGuid() + "@mail.com",
city = "Long Beach",
state = "California",
country = "USA",
manager = "",
isadmin = false,
disabled = false,
};
// mock payload
var mock_payload = new CreateUserRequestDTO
{
Username = newUser.username,
City = newUser.city,
State = newUser.state,
Country = newUser.country,
Manager = newUser.manager,
IsAdmin = newUser.isadmin,
Disabled = newUser.disabled
};
var expectedStatusCode = HttpStatusCode.Created;
var endpoint = API_Route_Local + "/user/update";
controller.Request = new HttpRequestMessage
{
RequestUri = new Uri(endpoint)
};
controller.Request.Headers.Add("token", adminSession.Token);
IHttpActionResult actionresult = controller.CreateNewUser(mock_payload);
Assert.IsInstanceOfType(actionresult, typeof(NegotiatedContentResult <string>));
var contentresult = actionresult as NegotiatedContentResult <string>;
Assert.AreEqual(expectedStatusCode, contentresult.StatusCode);
// persistence test
using (var _db = _ut.CreateDataBaseContext())
{
var _userManager = new UserManagementManager(_db);
var getUser = _userManager.GetUser(newUser.username);
Assert.AreNotEqual(newUser, getUser);
Assert.AreEqual(newUser.isadmin, getUser.IsAdministrator);
}
}
public IHttpActionResult Create(CreateUserRequestDTO dto)
{
dto.Password = _passwordHasher.GenerateIdentityV3Hash(dto.Password);
this.Servicio.Create(dto);
return(Ok());
}
public async Task <IActionResult> Create([FromBody] CreateUserRequestDTO dto)
{
await _commandDispatcher.DispatchAsync(
new CreateUserCommandHandler.Command(dto.AuthId, dto.Name)
);
return(Ok());
}
public IHttpActionResult CreateNewUser([FromBody, Required] CreateUserRequestDTO payload)
{
using (var _db = new DatabaseContext())
{
try
{
// Throws ExceptionService.NoTokenProvidedException
// Throws ExceptionService.SessionNotFoundException
var session = ControllerHelpers.ValidateAndUpdateSession(Request);
// Throws ExceptionService.InvalidModelPayloadException
ControllerHelpers.ValidateModelAndPayload(ModelState, payload);
var _userManager = new UserManagementManager(_db);
var user = _userManager.GetUser(session.UserId);
if (user.IsAdministrator)
{
// Throws exception, invalid username, invalid manager guid
var newUser = _userManager.CreateUser(payload);
_db.SaveChanges();
var responseCreated = Content(HttpStatusCode.Created, "User created.");
return(responseCreated);
}
return(Content(HttpStatusCode.Unauthorized, "Non-administrators cannot delete users."));
}
catch (Exception e) when(e is UserNotFoundException)
{
return(Content(HttpStatusCode.NotFound, e.Message));
}
catch (Exception e) when(e is InvalidGuidException ||
e is InvalidEmailException)
{
return(Content(HttpStatusCode.BadRequest, e.Message));
}
catch (Exception e) when(e is NoTokenProvidedException ||
e is SessionNotFoundException)
{
return(Content(HttpStatusCode.Unauthorized, e.Message));
}
catch (Exception e) when(e is InvalidModelPayloadException)
{
return(Content(HttpStatusCode.PreconditionFailed, e.Message));
}
catch (Exception e) when(e is UserAlreadyExistsException)
{
return(Content(HttpStatusCode.Conflict, e.Message));
}
catch (Exception e)
{
if (e is DbUpdateException ||
e is DbEntityValidationException)
{
_db.RevertDatabaseChanges(_db);
}
return(InternalServerError());
}
}
}
public static CreateUserRequest FromDTO(this CreateUserRequestDTO requestDTO)
{
return(new CreateUserRequest
{
Name = requestDTO.Name,
Email = requestDTO.Email,
Provider = requestDTO.Provider,
ProviderId = requestDTO.ProviderId,
});
}
public static User ToUser(this CreateUserRequestDTO request)
{
return(new User
{
FirstName = request.FirstName,
LastName = request.LastName,
Username = request.Username,
Email = request.Email,
Password = request.Password
});
}
public ActionResult <ReadUserDTO> Create(CreateUserRequestDTO model)
{
try
{
var user = _userService.Create(model);
return(Ok(user));
}
catch (AppException ex)
{
return(BadRequest(new { message = ex.Message }));
}
}
public IActionResult Register([FromBody] CreateUserRequestDTO userRequest)
{
var Result = _userService.Register(userRequest);
if (Result)
{
return(Ok());
}
else
{
return(Conflict());
}
}
public void Create(CreateUserRequestDTO dto)
{
User newUser = AutoMapper.Mapper.Map <User>(dto);
newUser.IdRoles.ToList().ForEach(x =>
{
newUser.Roles.Add(this.UnitOfWork.RoleRepository.FindById(x));
});
this.UnitOfWork.UserRepository.Add(newUser);
this.UnitOfWork.SaveChanges();
}
public List <Role> Resolve(CreateUserRequestDTO source, User destination, List <Role> destMember, ResolutionContext context)
{
var rolesArr = source.Roles;
var roleList = new List <Role>();
foreach (var role in rolesArr)
{
roleList.Add(new Role {
RoleKey = role
});
}
return(roleList);
}
public void CreateNewUser_NonexistingManager_404()
{
var controller = new UserManagementController();
var admin = _ut.CreateUserObject();
admin.IsAdministrator = true;
var adminSession = _ut.CreateSessionObject(admin);
_ut.CreateSessionInDb(adminSession);
var nonexistingdManagerId = Guid.NewGuid();
// modify user
var newUser = new
{
username = Guid.NewGuid() + "@mail.com",
city = "Long Beach",
state = "California",
country = "USA",
manager = nonexistingdManagerId.ToString(),
isadmin = false,
disabled = false,
};
// mock payload
var mock_payload = new CreateUserRequestDTO
{
Username = newUser.username,
City = newUser.city,
State = newUser.state,
Country = newUser.country,
Manager = newUser.manager,
IsAdmin = newUser.isadmin,
Disabled = newUser.disabled
};
var expectedStatusCode = HttpStatusCode.NotFound;
var endpoint = API_Route_Local + "/user/update";
controller.Request = new HttpRequestMessage
{
RequestUri = new Uri(endpoint)
};
controller.Request.Headers.Add("token", adminSession.Token);
NegotiatedContentResult <string> actionresult = (NegotiatedContentResult <string>)controller.CreateNewUser(mock_payload);
Assert.AreEqual(expectedStatusCode, actionresult.StatusCode);
}
public object Post(CreateUserRequestDTO createUserRequestDTO)
{
try
{
MessageFormat <UserDTO> result = this.UserBusinessLogic.Add(createUserRequestDTO.UserDTO);
return(new CreateUserResponseDTO {
Result = result
});
}
catch (Exception exception)
{
throw exception;
}
}
public void TestMethod1()
{
//string payload = @"{
// ""name"":""abdel"",
// ""job"":""leader""
// }";
var payload = new CreateUserRequestDTO();
payload.job = "leder"; //TestContext.DataRow["job"].ToString();
payload.name = "abdel"; //TestContext.DataRow["name"].ToString();
var handler = new APIHandler <CreateUserDTO>();
var response = handler.PostRequest(EndPoints.USERS_ENDPOINT, payload);
Assert.AreEqual("abdel", response.Name);
Assert.AreEqual(response.Response.StatusCode, HttpStatusCode.Created);
}
public ReadUserDTO Create(CreateUserRequestDTO model)
{
// validate
if (_userData.GetByUsername(model.Username) != null)
{
throw new AppException($"Username '{model.Username}' is already registered");
}
if (_userData.GetByEmail(model.Email) != null)
{
throw new AppException($"Email '{model.Email}' is already registered");
}
if (model.Roles.Length == 0)
{
List <RoleKey> defaultRole = new List <RoleKey>();
defaultRole.Add(RoleKey.superuser);
// Default Role
model.Roles = defaultRole.ToArray();
}
// map model to new account object
var user = _mapper.Map <User>(model);
user.AcceptTerms = true;
user.IsVerified = true;
user.VerifiedAt = DateTime.UtcNow;
user.Password = BC.HashPassword(model.Password);
var userId = _userData.Add(user);
if (userId > 0)
{
foreach (var role in user.Roles)
{
var roleDetails = this._roleData.GetByKey(role.RoleKey.ToString());
if (roleDetails != null)
{
var userRole = new UserRole {
UserId = userId, RoleId = roleDetails.Id
};
this._userRoleData.Add(userRole);
}
}
}
return(_mapper.Map <ReadUserDTO>(user));
}
public User Create(CreateUserRequestDTO requestDTO)
{
// Checking if the user with provided email already exists
this.ThrowExceptionIfEmailExists(requestDTO.email);
User user = new User()
{
email = requestDTO.email,
phone = requestDTO.phone,
name = requestDTO.name,
surname = requestDTO.surname,
password = BCrypt.Net.BCrypt.HashPassword(requestDTO.password),
role = this._roleService.FindOneByName(requestDTO.roleName)
};
user = this._queryExecutor.Execute <User>(DatabaseConsts.USER_SCHEMA, this._sqlCommands.CREATE_USER(user), this._modelMapper.MapToUserAfterInsert);
return(user);
}
public bool Register(CreateUserRequestDTO model)
{
try {
var existingUser = _userRepository.GetAllAsQuerable()
.Where(u => (u.Email == model.Email || u.Username == model.Username))
.FirstOrDefault();
if (existingUser != null)
{
return(false);
}
_userRepository.Create(model.ToUser());
return(_userRepository.Save());
}
catch (Exception ex)
{
_logger.LogWarning($"{ex.Message}\r\n{ex.StackTrace}");
return(false);
}
}
public User CreateUser(CreateUserRequestDTO user)
{
// update user with given values
try
{
var newUserUsername = new System.Net.Mail.MailAddress(user.Username);
var newUserId = Guid.NewGuid();
var newUser = CreateUser(user.Username, newUserId);
if (user.Manager != "")
{
try
{
var managerId = Guid.Parse(user.Manager);
var manager = _userService.GetUser(managerId);
if (manager == null)
{
throw new UserNotFoundException("Manager does not exist.");
}
newUser.ManagerId = managerId;
}
catch (FormatException e)
{
throw new InvalidGuidException("Invalid Manager ID.", e);
}
}
newUser.IsAdministrator = user.IsAdmin;
newUser.City = user.City;
newUser.Country = user.Country;
newUser.State = user.State;
newUser.Disabled = user.Disabled;
// update new user with changes
_userService.CreateUser(newUser);
return(newUser);
}
catch (FormatException)
{
throw new InvalidEmailException("Invalid Username.");
}
}
public void CreateNewUser()
{
//String payload = @"{
// ""name"": ""Mike"",
// ""job"": ""Team leader""
// }";
//var user = new APIHelper<CreateUserDTO>();
//var url = user.SetUrl("api/users");
//var request = user.CreatePostRequest(payload);
//var reponse = user.GetResponse(url, request);
//CreateUserDTO content = user.GetContent<CreateUserDTO>(reponse);
var users = new CreateUserRequestDTO();
users.Name = TestContext.DataRow["name"].ToString();
users.Job = TestContext.DataRow["job"].ToString();
var demo = new Demo <CreateUserDTO>();
var user = demo.CreateUser("api/users", users);
//###################################
Assert.AreEqual("Mike", user.Name);
Assert.AreEqual("Lead", user.Job);
}
public OperationResult <User> Post(CreateUserRequestDTO request)
{
return(this.UserBusinessLogic.AddUser(request.User));
}
public async Task <ActionResult> Post([FromBody] CreateUserRequestDTO dto)
{
var createdUser = await service.CreateUser(dto.FromDTO());
return(CreatedAtRoute("GetUser", new { id = createdUser.Id }, createdUser.ToDTO()));
}
public UserResponseDTO Create(CreateUserRequestDTO requestDTO)
{
// todo
return(new UserResponseDTO());
}
