/// <summary>
/// Create user in system.
/// </summary>
/// <param name="userDto">UserDto from front-end</param>
/// <returns> new client</returns>
/// <exception cref="InvalidOperationException">User not create</exception>
public async Task <CreatedUserDto> CreateUser(CreatedUserDto userDto)
{
if (userDto == null)
{
Log.Error(LogResources.EmptyArgument, nameof(userDto));
throw new ArgumentNullException();
}
if (this.userRepository.GetByEmail(userDto.Email) != null)
{
Log.Error("This email ==> {Email} <== is registered in the system ", userDto.Email);
throw new ArgumentException(Resources.EmailExistent);
}
var user = this.mapper.Map <AccauntDbModel>(userDto);
user.AccauntSettings = new AccauntSettingsDbModel();
var result = await this.userRepository.AddAsync(user);
if (result == null)
{
Log.Error("User not created");
throw new InvalidOperationException();
}
Log.Information("{User} has be created", result.Loggin);
return(this.mapper.Map <CreatedUserDto>(result));
}
public async Task UpdateUserEmailAsync(UpdateEmailDto dto, string replayId)
{
CreatedUserDto user = await GetResultAsync <CreatedUserDto>($"v1/users/{Uri.EscapeDataString(dto.UserId)}");
user.EmailAddress = dto.EmailAddress;
await PutWithNoReturnTypeAsync($"v1/users/{dto.UserId}", user, replayId);
}
public void CreateUserTest()
{
var userDto = new CreatedUserDto()
{
Email = "*****@*****.**", Loggin = "test", Password = "******"
};
var result = this._userService.CreateUser(userDto);
Assert.IsNotNull(result);
}
public int?CreateUser(CreatedUserDto userDto)
{
return(UnitOfWork.Do(uow =>
{
var found = uow.Repo <User>().AsQueryable().FirstOrDefault(t => t.Name == userDto.Email);
if (found == null)
{
var user = new User {
Name = userDto.Name, Email = userDto.Email
};
return (int)uow.Repo <User>().Insert <decimal>(user);
}
return (int?)null;
}));
}
public IActionResult CreateUser([FromBody] CreatedUserDto user)
{
if (user == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(new UnprocessableEntityObjectResult(ModelState));
}
var createdUser = Mapper.Map <UserEntity>(user);
createdUser = userRepository.Insert(createdUser);
return(CreatedAtRoute(nameof(GetUserById), new { userId = createdUser.Id }, createdUser.Id));
}
public async Task <IActionResult> CreateUser([FromBody] CreatedUserDto user)
{
if (!this.ModelState.IsValid)
{
return(this.BadRequest(Resources.InValidData));
}
try
{
Log.Information($"Attempt to creat new user");
return(this.Ok(await this.userService.CreateUser(user)));
}
catch (Exception e)
{
return(this.BadRequest(e.Message));
}
}
public void GetUser_Test_Returns_Result_of_Proxy()
{
CreatedUserDto user = new CreatedUserDto()
{
Company = 1,
EmailAddress = "*****@*****.**",
LowellReference = "123456789",
IsSuccessful = true,
MessageForUser = "******"
};
string userId = Guid.NewGuid().ToString();
_mockProxy.Setup(x => x.GetUserAsync(userId)).Returns(Task.FromResult(user));
CreatedUserDto result = _process.GetUser(userId).Result;
Assert.AreEqual(user, result);
//Check that the proxy was called once
_mockProxy.Verify(x => x.GetUserAsync(userId), Times.Once);
_mockProxy.VerifyNoOtherCalls();
}
public async Task <IActionResult> GetUser([FromBody] string userId)
{
CreatedUserDto result = await _usersService.Get(userId);
return(Ok(result));
}
