public async Task CreateUserBadRequest()
{
var iUserServiceMock = new Mock <IUserService>();
var name = Faker.Name.FullName();
var email = Faker.Internet.Email();
iUserServiceMock.Setup(m => m.Post(It.IsAny <UserCreateDto>())).ReturnsAsync(
new UserDto
{
Id = Guid.NewGuid(),
Name = name,
Email = email,
CreatedAt = DateTime.UtcNow
}
);
_controller = new UsersController(iUserServiceMock.Object);
_controller.ModelState.AddModelError("Name", "is required");
var url = new Mock <IUrlHelper>();
url.Setup(m => m.Link(It.IsAny <string>(), It.IsAny <object>())).Returns("http://localhost:5000");
_controller.Url = url.Object;
var userCreateDto = new UserCreateDto
{
Name = name,
Email = email
};
var result = await _controller.Post(userCreateDto);
Assert.True(result is BadRequestObjectResult);
}
public async Task <IActionResult> CreateUser(UserCreateDto newUser)
{
var entityUser = Mapper.Map <USER>(newUser);
var result = await _userManager.CreateAsync(entityUser, newUser.Password);
if (!result.Succeeded)
{
var errors = string.Join(".", result.Errors.Select(x => x.Description));
foreach (var err in result.Errors)
{
ModelState.AddModelError(err.Code, err.Description);
}
return(BadRequest(ModelState));
}
else
{
await _userService.SaveUserRoles(entityUser.Id, newUser.RoleIds);
// Must log manually if not using BaseService
Logger.Log(Microsoft.Extensions.Logging.LogLevel.Information, default(EventId), new ExtraPropertyLogger("User {username} added new {entity} {identifier}", UserIdentity.Username, typeof(USER).Name, entityUser.ToString()).AddProp("data", entityUser), null, ExtraPropertyLogger.Formatter);
}
return(Ok(entityUser.Id));
}
public async Task <IdentityResult> CreateAsync(UserCreateDto userCreate)
{
var applicationUser = new ApplicationUser(userCreate.Email, userCreate.UserName);
var result = await _usernaManager.CreateAsync(applicationUser, userCreate.Password);
return(result);
}
public ActionResult <UserReadDto> CreateUser(UserCreateDto userCreateDto)
{
try
{
var userModel = _mapper.Map <User>(userCreateDto);
var user = _userService.GetUserByEmail(userCreateDto.Email);
if (user != null)
{
return(Conflict());
}
_authService.CreateUser(userModel);
var tmpUser = _userService.GetUserByEmail(userCreateDto.Email);
var vModel = _authService.AddVerificationInfo(tmpUser, Request.Headers["origin"]);
var userReadDto = _mapper.Map <UserReadDto>(tmpUser);
_emailService.SendVerificationEmail(vModel, tmpUser, Request.Headers["origin"]);
return(CreatedAtRoute(nameof(UsersController.GetUserById), new { Id = userReadDto.Id }, userReadDto));
}
catch (Exception e)
{
return(StatusCode(500, e.Message));
}
}
public async Task Should_Be_Able_To_Create_A_Super_Admin()
{
var userCreateDto = new UserCreateDto
{
Name = "SuperAdminOne",
Surname = "SuperAdmin",
EmailAddress = "*****@*****.**",
PhoneNumber = "0760000000",
UserName = "******",
Password = "******"
};
await SuperAdminAccountAppService.RegisterAsync(userCreateDto);
var userDto = await IdentityUserAppService.FindByUsernameAsync(userCreateDto.UserName);
userDto.ShouldNotBeNull();
var roles = (await IdentityUserAppService.GetRolesAsync(userDto.Id)).Items;
roles.ShouldContain(role => role.Name == RolesConsts.SuperAdmin);
userDto.Name.ShouldBe(userCreateDto.Name);
userDto.Surname.ShouldBe(userCreateDto.Surname);
userDto.Email.ShouldBe(userCreateDto.EmailAddress);
userDto.PhoneNumber.ShouldBe(userCreateDto.PhoneNumber);
}
public async Task Register(UserCreateDto userCreateDto)
{
if (userCreateDto == null)
{
throw new ArgumentNullException(nameof(userCreateDto));
}
var desiredUserName = userCreateDto.Username;
var user = await _userManager.FindByNameAsync(desiredUserName);
if (user != null)
{
throw new Exception("User already exists");
}
else
{
var password = userCreateDto.Password;
var userToAdd = _mapper.Map <ApplicationUser>(userCreateDto);
var result = await _userManager.CreateAsync(userToAdd, password);
if (!result.Succeeded)
{
throw new Exception("Password not strong enough");
}
}
}
public ActionResult <UserReadDto> CreateUser(UserCreateDto userCreateDto)
{
if (userCreateDto == null)
{
return(NoContent());
}
userCreateDto.Username = Regex.Replace(userCreateDto.Username, @" ", "");
userCreateDto.Password = HashPassword(userCreateDto.Password);
var user = _mapper.Map <User>(userCreateDto);
try
{
_repository.CreateUser(user);
}
catch (DuplicateUserException e)
{
var message = e.Message;
return(BadRequest(new { message = $"{message} is already in use." }));
}
_repository.SaveChanges();
var userReadDto = _mapper.Map <UserReadDto>(user);
return(CreatedAtRoute(nameof(GetUserById), new { userReadDto.Id }, userReadDto));
}
public async Task <string> CreateToken(UserCreateDto user)
{
var payload1 = new Dictionary <string, string>
{
{ $"{user.Email}addvals", user.Password },
};
using (var httpClient = new HttpClient())
{
var authString = Convert.ToBase64String(Encoding.UTF8.GetBytes($"{user.Email}addvals:{user.Password}"));
//Console.WriteLine("lors de la creation du token : MAIL + MDP " + $"{user.Email}addvals:{user.Password}");
httpClient.DefaultRequestHeaders.Clear();
httpClient.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", authString);
StringContent content1 = new StringContent(JsonConvert.SerializeObject(payload1), Encoding.UTF8, "application/json");
using (var response = await httpClient.PostAsync("https://cloud.skytap.com/v2/account/api_tokens.json", null))
{
string apiResponse = await response.Content.ReadAsStringAsync();
Console.WriteLine("creation du token" + apiResponse);
}
}
return("ok");
}
public async Task <string> GetTemplateSkytap(UserCreateDto user)
{
//SkytapDataEnviroModel skytapDataEnviroModel;
String templateId = "";
//Console.WriteLine("IDSKY " + user.idSkytap);
using (var httpClient = new HttpClient())
{
//Console.WriteLine( user.Email + " " + user.Password);
var authString2 = Convert.ToBase64String(Encoding.UTF8.GetBytes($"{user.Email}:{user.Password}"));
httpClient.DefaultRequestHeaders.Clear();
httpClient.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", authString2);
httpClient.DefaultRequestHeaders.Add("Accept", "application/json");
//StringContent content = new StringContent(JsonConvert.SerializeObject(payload1), Encoding.UTF8, "application/json");
using (var response = await httpClient.GetAsync("https://cloud.skytap.com/projects/" + user.Group + "/templates"))
{
//Console.WriteLine( response.StatusCode);
string apiResponse = await response.Content.ReadAsStringAsync();
//Console.WriteLine( apiResponse);
var lalistIdTemplate = JsonConvert.DeserializeObject <List <EnviroIdModel> >(apiResponse);
foreach (var template in lalistIdTemplate)
{
templateId = template.id;
break;
}
}
}
return(templateId);
}
public async Task <SkytapModelDeux> addSkytap(UserCreateDto user)
{
SkytapModel skytapModel = new SkytapModel
{
account_role = "admin",
login_name = user.Email + "Addvals",
email = "*****@*****.**",
};
SkytapModelDeux SkyRep;
using (var httpClient = new HttpClient())
{
var authString = Convert.ToBase64String(Encoding.UTF8.GetBytes("[email protected]:karim1302"));
httpClient.DefaultRequestHeaders.Clear();
httpClient.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", authString);
httpClient.DefaultRequestHeaders.Add("Accept", "application/json");
StringContent content = new StringContent(JsonConvert.SerializeObject(skytapModel), Encoding.UTF8, "application/json");
using (var response = await httpClient.PostAsync("https://cloud.skytap.com/users.json", content))
{
string apiResponse = await response.Content.ReadAsStringAsync();
SkyRep = JsonConvert.DeserializeObject <SkytapModelDeux>(apiResponse);
}
}
return(SkyRep);
}
public async Task <SkytapModelToken> GetToken(UserCreateDto user)
{
SkytapModelToken skytapModelToken;
using (var httpClient = new HttpClient())
{
var authString = Convert.ToBase64String(Encoding.UTF8.GetBytes($"{user.Email}addvals:{user.Password}"));
Console.WriteLine("lors de la recup du token MAIL + MDP " + user.Email + "addvals : " + user.Password);
httpClient.DefaultRequestHeaders.Clear();
httpClient.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", authString);
httpClient.DefaultRequestHeaders.Add("Accept", "application/json");
using (var response = await httpClient.GetAsync("https://cloud.skytap.com/account/api_token"))
{
string apiResponse = await response.Content.ReadAsStringAsync();
skytapModelToken = JsonConvert.DeserializeObject <SkytapModelToken>(apiResponse);
Console.WriteLine("Apres creation la recup" + apiResponse);
}
}
return(skytapModelToken);
}
public async Task DeleteUserWithManagerRole_Returns204NoContentOnSuccess()
{
var jwtToken = MockJWTTokens.CreateRoleJWTToken("Manager", "manageruser");
_client.DefaultRequestHeaders.Add("Authorization", $"Bearer {jwtToken}");
var userName = Guid.NewGuid().ToString();
var password = Guid.NewGuid().ToString();
var email = $"{Guid.NewGuid()}@gmail.com";
var requestBody = new UserCreateDto
{
FirstName = "someUser",
LastName = "someUserLastName",
UserName = userName,
Password = password,
Email = email,
Roles = new List <string>()
{
"Jogger"
}
};
var users = await _client.GetFromJsonAsync <IEnumerable <UserDto> >("/api/users");
if (users.Count() > 4)
{
var newlyCreatedUser = users.LastOrDefault();
var deleteResponse = await _client.DeleteAsync($"/api/users/{newlyCreatedUser.Id}");
Assert.Equal(204, (int)deleteResponse.StatusCode);
}
}
public async Task <ActionResult <User> > CreateUser(UserCreateDto user)
{
var type = new Type {
Id = user.TypeId
};
_context.Type.Attach(type);
var newUser = new User()
{
Id = user.Id,
FirstName = user.FirstName,
LastName = user.LastName,
Password = user.Password ?? _randomService.RandomPassword(6),
Type = type,
};
_context.User.Add(newUser);
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (await UserExists(user.Id))
{
return(Conflict());
}
throw;
}
return(CreatedAtAction("GetUser", new { id = user.Id }, newUser));
}
public async Task <IdentityManagerResult <CreateResult> > CreateUserAsync(IEnumerable <PropertyValue> properties)
{
var userName = properties.FirstOrDefault(x => (x.Type == Core.Constants.ClaimTypes.Name || x.Type == Core.Constants.ClaimTypes.Username))?.Value ?? string.Empty;
var password = properties.FirstOrDefault(x => x.Type == Core.Constants.ClaimTypes.Password)?.Value ?? string.Empty;
var claims = properties.Where(x => x.Type != Core.Constants.ClaimTypes.Password).Select(x => new ClaimDto {
Type = x.Type, Value = x.Value
});
var userCreateDto = new UserCreateDto {
Username = userName, Password = password, Claims = claims
};
using (var client = await CreateClientAsync())
{
using (var postResponse = await client.PostAsync($"/api/users", new StringContent(JsonConvert.SerializeObject(userCreateDto), Encoding.Unicode, "text/json")))
{
if (!postResponse.IsSuccessStatusCode)
{
return(new IdentityManagerResult <CreateResult>($"Error creating user, returned status code {postResponse.StatusCode}"));
}
}
}
return(new IdentityManagerResult <CreateResult>(new CreateResult {
Subject = userName
}));
}
public ActionResult <ApplicationUser> PostApplicationUser(UserCreateDto user)
{
try
{
var pass = user.Password;
var userEntity = _mapper.Map <ApplicationUser>(user);
switch (user.UserType.ToLower())
{
case "corporate":
return(_userService.CreateCorporateUser(userEntity, user.CorporateUserDetailsDto, pass));
case "personal":
return(_userService.CreatePersonalUser(userEntity, user.UserDetails, pass));
case "admin":
return(_userService.CreateAdminUser(userEntity, user.UserDetails, pass));
default:
return(StatusCode(StatusCodes.Status500InternalServerError, "Invalid user type (Corporate, Personal or Admin)"));
}
}
catch (Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError, ex.Message));
}
}
public async Task <string> CreateSharingSkytap(UserCreateDto user, string enviro)
{
CreateSharing createSharing = new CreateSharing
{
name = $"Machine de {user.Email}",
};
using (var httpClient = new HttpClient())
{
var authString = Convert.ToBase64String(Encoding.UTF8.GetBytes($"{user.Email}:{user.Password}"));
httpClient.DefaultRequestHeaders.Clear();
httpClient.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", authString);
httpClient.DefaultRequestHeaders.Add("Accept", "application/json");
StringContent content = new StringContent(JsonConvert.SerializeObject(createSharing), Encoding.UTF8, "application/json");
using (var response = await httpClient.PostAsync($"https://cloud.skytap.com/v2/configurations/{enviro}/publish_sets.json", content))
{
// Console.WriteLine("Create sharing = " + response.StatusCode);
string apiResponse = await response.Content.ReadAsStringAsync();
//SkyRep = JsonConvert.DeserializeObject<SkytapModelDeux>(apiResponse);
}
}
return("Ok");
}
public static void Main(string[] args)
{
var userServiceClient = new UserServiceClient(NET_NAMED_PIPE_ENDPOINT_NAME);
var userListItemDtos = userServiceClient.GetAll();
var userCreateDto = new UserCreateDto
{
UserName = Guid.NewGuid().ToString().Substring(0, 10),
FirstName = "b",
Lastname = "c",
Notes = new List <NoteCreateDto>
{
new NoteCreateDto
{
Text = "Salala",
Title = Guid.NewGuid().ToString().Substring(0, 10)
},
new NoteCreateDto
{
Text = "Salala",
Title = Guid.NewGuid().ToString().Substring(0, 10)
}
}
};
var userDto = userServiceClient.Create(userCreateDto);
var userDtoagain = userServiceClient.Get(userDto.Id);
}
public async Task <SharingUrl> GetSharing(UserCreateDto user, string enviro)
{
//SkytapDataSharingModel skytapDataSharingModel;
SharingUrl sharingUrl = new SharingUrl();
using (var httpClient = new HttpClient())
{
var authString = Convert.ToBase64String(Encoding.UTF8.GetBytes($"{user.Email}:{user.Password}"));
httpClient.DefaultRequestHeaders.Clear();
httpClient.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", authString);
httpClient.DefaultRequestHeaders.Add("Accept", "application/json");
using (var response = await httpClient.GetAsync($"https://cloud.skytap.com/configurations/{enviro}/publish_sets.json"))
{
string apiResponse = await response.Content.ReadAsStringAsync();
var list = JsonConvert.DeserializeObject <List <SkytapDataSharingModel> >(apiResponse);
foreach (var sha in list)
{
sharingUrl.id = sha.id;
Console.WriteLine("VM SHARING : " + sharingUrl.id);
foreach (var lis in sha.vms)
{
sharingUrl.url = lis.desktop_url;
break;
}
break;
}
}
}
return(sharingUrl);
}
public UserGetDto CreateUser(UserCreateDto userCreateDto)
{
var passwordHash = new PasswordHash(userCreateDto.Password);
var user = new User
{
FirstName = userCreateDto.FirstName,
LastName = userCreateDto.LastName,
Username = userCreateDto.Username,
Email = userCreateDto.Email,
Role = Constants.Users.Roles.User,
PasswordSalt = passwordHash.Salt,
PasswordHash = passwordHash.Hash
};
_context.Set <User>().Add(user);
_context.SaveChanges();
var userGetDto = new UserGetDto
{
Id = user.Id,
FirstName = user.FirstName,
LastName = user.LastName,
Username = user.Username,
Email = user.Email,
Role = user.Role
};
return(userGetDto);
}
public async Task <SkytapModelDeux> UpdateAccesSharingSkytap(UserCreateDto user, string enviro, string vm, string sharingId)
{
var vmss = new Dictionary <string, string>
{
{ "access", "run_and_use" },
{ "vm_ref", $"https://cloud.skytap.com/vms/{vm}" }
};
UpdateAcces updateAcces = new UpdateAcces
{
vms = new Dictionary <string, string>[] { vmss }
};
using (var httpClient = new HttpClient())
{
var authString = Convert.ToBase64String(Encoding.UTF8.GetBytes($"{user.Email}:{user.Password}"));
httpClient.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", authString);
httpClient.DefaultRequestHeaders.Add("Accept", "application/json");
StringContent content = new StringContent(JsonConvert.SerializeObject(updateAcces), Encoding.UTF8, "application/json");
using (var response = await httpClient.PutAsync($"https://cloud.skytap.com/configurations/{enviro}/publish_sets/{sharingId}.json", content))
{
//Console.WriteLine(response.StatusCode);
string apiResponse = await response.Content.ReadAsStringAsync();
//Console.WriteLine(apiResponse);
// SkyRep = JsonConvert.DeserializeObject<SkytapModelDeux>(apiResponse);
}
}
return(null);
}
public async Task <IActionResult> CreateAsync([FromBody] UserCreateDto user, ApiVersion version)
{
Logger.LogDebug(nameof(CreateAsync));
if (await _repositoryFactory.UserRepository.ExistsAsync(u => u.EmployeeId == user.EmployeeId).ConfigureAwait(false))
{
return(BadRequest(new { message = $"The User with EmployeeId {user.EmployeeId} already exists" }));
}
if (!await _repositoryFactory.EmployeeRepository.ExistsAsync(u => u.EmployeeId == user.EmployeeId).ConfigureAwait(false))
{
return(NotFound(new { message = $"The Employee with EmployeeId {user.EmployeeId} was not found" }));
}
var newUser = new User
{
EmployeeId = user.EmployeeId,
Username = user.Username,
Password = user.Password
};
var repoUser = await _repositoryFactory.UserRepository.AddUserAsync(newUser).ConfigureAwait(false);
var result = _userToDtoConverter.Convert(repoUser);
var createdResult = new ObjectResult(result)
{
StatusCode = StatusCodes.Status201Created
};
return(createdResult);
}
public async Task <EnviroVmUrl> GetEnviroSkytap(UserCreateDto user)
{
//SkytapDataEnviroModel skytapDataEnviroModel;
EnviroIdModel enviro = new EnviroIdModel();
String enviroId = "";
//Console.WriteLine("IDSKY " + user.idSkytap);
using (var httpClient = new HttpClient())
{
//Console.WriteLine( user.Email + " " + user.Password);
var authString2 = Convert.ToBase64String(Encoding.UTF8.GetBytes($"{user.Email}:{user.Password}"));
httpClient.DefaultRequestHeaders.Clear();
httpClient.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", authString2);
using (var response = await httpClient.GetAsync("https://cloud.skytap.com/configurations.json"))
{
//Console.WriteLine( response.StatusCode);
string apiResponse = await response.Content.ReadAsStringAsync();
//Console.WriteLine( apiResponse);
var lalistIdEnviro = JsonConvert.DeserializeObject <List <EnviroIdModel> >(apiResponse);
foreach (var envir in lalistIdEnviro)
{
enviroId = envir.id;
break;
}
}
}
EnviroVmUrl enviroVmUrl = await GetVmsSkytap(user, enviroId);
return(enviroVmUrl);
}
public async Task CanCreateAndDeleteUsers()
{
var newEmployee = new EmployeeCreateDto()
{
CompanyId = 1,
DepartmentId = 1,
FirstName = "TestFirstName",
LastName = "TestLastName",
BirthDate = new DateTime(1991, 8, 7),
Address = "TestAddress"
};
// Save test employee
var employee = await _httpClientHelper.PostAsync <EmployeeCreateDto, EmployeeDto>(_employeesBaseUrl + "create", newEmployee).ConfigureAwait(false);
// Create test user
var newUser = new UserCreateDto()
{
EmployeeId = employee.EmployeeId,
Username = "******",
Password = "******"
};
var user = await _httpClientHelper.PostAsync <UserCreateDto, UserDto>(_usersBaseUrl + "create", newUser).ConfigureAwait(false);
Assert.Equal("testuser", user.Username);
// Delete test user
await _httpClientHelper.DeleteAsync(_usersBaseUrl + $"DeleteUserByEmployeeIdAsync{API_VERSION}/{user.EmployeeId}").ConfigureAwait(false);
// Delete test employee
await _httpClientHelper.DeleteAsync(_employeesBaseUrl + $"DeleteEmployeeById{API_VERSION}/{employee.EmployeeId}").ConfigureAwait(false);
}
public async Task <SkytapModelDeux> shutdown_on_idle(UserCreateDto user, String enviro)
{
string dat1 = new DateTime().ToString();
var payload1 = new Dictionary <string, int>
{
{ "shutdown_on_idle", 300 },
//{"shutdown_at_time", "2020/05/29 13:25:00" },
};
using (var httpClient = new HttpClient())
{
var authString = Convert.ToBase64String(Encoding.UTF8.GetBytes($"{user.Email}:{user.Password}"));
httpClient.DefaultRequestHeaders.Clear();
httpClient.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", authString);
httpClient.DefaultRequestHeaders.Add("Accept", "application/json");
StringContent content = new StringContent(JsonConvert.SerializeObject(payload1), Encoding.UTF8, "application/json");
using (var response = await httpClient.PutAsync($"https://cloud.skytap.com/configurations/{enviro}.json", content))
{
string apiResponse = await response.Content.ReadAsStringAsync();
}
}
return(null);
}
public async Task <IActionResult> PutASync(Guid id, UserCreateDto userUpdate)
{
var userFromDB = _userService.GetById(id);
if (userFromDB == null)
{
return(NotFound(
new GlobalResponse
{
RequestData = userUpdate,
ResponseData = null,
Status = System.Net.HttpStatusCode.NotFound,
Message = $"There is no user with Id {id}"
}
));
}
_mapper.Map(userUpdate, userFromDB);
_userService.Update(userFromDB);
try
{
await Task.Run(() =>
{
_userService.SaveChanges();
});
}
catch (DbUpdateConcurrencyException)
{
throw;
}
return(Ok(userUpdate));
}
public async Task AddAsync_WhenUsersBankNotFoud_ShouldReturnNotFound()
{
//arrange
var mockBankRepository = new Mock <IGenericRepository <Bank> >();
mockBankRepository.Setup(m => m.GetAllAsync(It.IsAny <Expression <Func <Bank, bool> > >()))
.ReturnsAsync(Enumerable.Empty <Bank>().AsQueryable());
var mockUow = new Mock <IBankUow>();
mockUow.SetupGet(p => p.Banks)
.Returns(() => mockBankRepository.Object);
var userService = new UserService(mockUow.Object, null);
var userDto = new UserCreateDto {
BankAccount = new BankAccountCreateDto {
BankName = "Bank"
}
};
//act
var result = await userService.AddAsync(userDto);
//assert
Assert.IsTrue(
result.ErrorCategory == Models.ErrorCategory.NotFound);
}
public async Task CreateUser_Returns201StatusResultOnSuccess()
{
// Arrange
var user = new ClaimsPrincipal(new ClaimsIdentity(new Claim[]
{ new Claim(ClaimTypes.Name, "adminuser"), new Claim(ClaimTypes.Role, "Admin") }));
_controller.ControllerContext = new ControllerContext();
_controller.ControllerContext.HttpContext = new DefaultHttpContext {
User = user
};
var userCreateDto = new UserCreateDto
{
FirstName = "New User",
LastName = "new User lastName",
UserName = "******",
Password = "******",
Email = "*****@*****.**",
Roles = new List <string>()
{
"Manager"
}
};
// Act
var result = await _controller.CreateUser(userCreateDto) as StatusCodeResult;
//Assert
Assert.Equal(201, result.StatusCode);
}
public async Task <ActionResult <CommonResponse <UserDto> > > PostUser(UserCreateDto user)
{
// Create response object
CommonResponse <UserDto> respons = new CommonResponse <UserDto>();
if (!ModelState.IsValid)
{
respons.Error = new Error
{
Status = 400,
Message = "The user did not pass validation, ensure it is in the correct format."
};
return(BadRequest(respons));
}
User userModel = _mapper.Map <User>(user);
// Try catch
try
{
_context.Users.Add(userModel);
await _context.SaveChangesAsync();
}
catch (Exception e)
{
respons.Error = new Error {
Status = 500, Message = e.Message
};
return(StatusCode(StatusCodes.Status500InternalServerError, respons));
}
// Map to dto
respons.Data = _mapper.Map <UserDto>(userModel);
return(CreatedAtAction("GetUser", new { userId = respons.Data.UserId }, respons));
}
public async Task <IActionResult> Put(string id, [FromBody] UserCreateDto model)
{
if (model == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = await _accountRepository.Get(id);
if (user == null)
{
return(NotFound());
}
Mapper.Map(model, user);
var result = await _accountRepository.Update(user);
if (!result.Succeeded)
{
return(BadRequest(result));
}
return(Ok(Mapper.Map <UserCreateDto>(user)));
}
/// <summary>
/// Create the user.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='body'>
/// The user.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <UserDto> CreateUserAsync(this IUser operations, UserCreateDto body = default(UserCreateDto), CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.CreateUserWithHttpMessagesAsync(body, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}