public RegisterUserResponseDto RegisterUser(RegisterUserRequestDto registerUserRequestDto)
{
ValidateRegisterUserRequestDto(registerUserRequestDto);
var registerUserResponseDto = new RegisterUserResponseDto();
var userMapCM = new UserInfoCommandModel
{
CreatedBy = registerUserRequestDto.UserGuid,
CreatedDateTime = DateTime.UtcNow,
Email = registerUserRequestDto.Email,
FirstName = registerUserRequestDto.FirstName,
LastName = registerUserRequestDto.LastName,
Password = registerUserRequestDto.Password, //TODO: change it
PasswordSalt = "", //TODO: change it
PhoneNumber = registerUserRequestDto.PhoneNumber,
UpdatedBy = registerUserRequestDto.UserGuid,
UpdatedDateTime = DateTime.UtcNow,
UserGuid = registerUserRequestDto.UserGuid,
UserName = registerUserRequestDto.UserName,
UserType = registerUserRequestDto.UserType
};
var response = registrationRepository.InsertUserInfo(userMapCM);
return(new RegisterUserResponseDto {
UserId = response.UserId
});
}
public void RegistrationTestPositive()
{
// Arrange
const string UserGuid = "78ea60de-6f95-4d45-a0a6-aaca228debd2";
var registrationRequestDto = new RegisterUserRequestDto
{
UserGuid = Guid.Parse(UserGuid),
Email = "*****@*****.**",
FirstName = "user20",
LastName = "user20",
Password = "******",
PhoneNumber = "9012345678",
UserName = "******",
UserType = 2
// TempPassword = "******"
};
// Act
var registrationProvider = Factory.RegistrationBusinessProvider();
var responseDto = registrationProvider.RegisterUser(registrationRequestDto);
// Assert
Assert.AreEqual(responseDto.ServiceResponseStatus, 1);
}
public RegisterUserResponseDto RegisterUser(RegisterUserRequestDto registerUserRequestDto)
{
RegisterUserResponseDto registerUserResponseDto;
try
{
registerUserResponseDto = registrationProvider.RegisterUser(registerUserRequestDto);
registerUserResponseDto.ServiceResponseStatus = 1;
}
catch (SSException applicationException)
{
registerUserResponseDto = new RegisterUserResponseDto
{
ServiceResponseStatus = 0,
ErrorMessage = applicationException.Message,
ErrorCode = applicationException.ExceptionCode
};
}
catch (Exception exception)
{
registerUserResponseDto = new RegisterUserResponseDto
{
ServiceResponseStatus = 0,
ErrorCode = ExceptionAttributes.ExceptionCodes.InternalServerError,
ErrorMessage = exception.Message
};
}
return(registerUserResponseDto);
}
public async Task <IActionResult> Register([FromBody] RegisterUserRequestDto registration)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
ApplicationUser newUser = new ApplicationUser
{
Email = registration.Email,
UserName = registration.Email,
City = registration.City
};
IdentityResult result = await _userManager.CreateAsync(newUser, registration.Password);
if (!result.Succeeded)
{
foreach (var error in result.Errors)
{
ModelState.AddModelError(error.Code, error.Description);
}
return(BadRequest(ModelState));
}
newUser = await _userManager.FindByEmailAsync(registration.Email);
await _userManager.AddClaimAsync(newUser, new Claim("registration-date", DateTime.UtcNow.ToString("yy-MM-dd")));
await _userManager.AddClaimAsync(newUser, new Claim("city", registration.City));
return(Ok());
}
public IActionResult RegisterUser([FromBody] RegisterUserRequestDto message)
{
return(Ok(new RegisterUserResponseDto()
{
Valid = false,
Error = "CU-110"
}));
}
private static void ValidateRegisterUserRequestDto(RegisterUserRequestDto registerUserRequestDto)
{
if (registerUserRequestDto == null || string.IsNullOrWhiteSpace(registerUserRequestDto.Email) ||
registerUserRequestDto.UserGuid == Guid.Empty ||
string.IsNullOrEmpty(registerUserRequestDto.FirstName) ||
string.IsNullOrEmpty(registerUserRequestDto.LastName))
{
throw new SSException(
ExceptionAttributes.ExceptionCodes.InvalidInput,
ExceptionAttributes.ExceptionMessages.InvalidInput);
}
}
public async Task <IActionResult> Register(RegisterUserRequestDto registerRequestDto)
{
var registerRequest = _mapper.Map <RegisterUserRequest>(registerRequestDto);
var response = await _users.RegisterAsync(registerRequest);
if (!response.Success)
{
return(BadRequest(response.ErrorMessage));
}
return(StatusCode(StatusCodes.Status201Created));
}
public async Task <IActionResult> RegisterUser([FromBody] RegisterUserRequestDto message)
{
if (await message.IsValid())
{
var response = await _policy.ExecuteAsync(async() => await _registerUserClient.Request(message));
if (response != null)
{
return(Ok(response));
}
}
return(BadRequest());
}
public async Task RegisterUserAsync_Should_Return_NotFound_With_Message_If_BaseBusinessLogicException(
RegisterUserRequestDto registerUserRequestDto,
UsernameExistException usernameExistException)
{
_userService.CreateAsync(registerUserRequestDto.Username, registerUserRequestDto.Password,
registerUserRequestDto.Email).Throws(usernameExistException);
var result = await _userControllerInstance.RegisterUserAsync(registerUserRequestDto);
var response = result as NotFoundObjectResult;
Assert.NotNull(response);
var responseObject = response.Value as string;
Assert.NotNull(responseObject);
Assert.AreEqual(usernameExistException.Message, responseObject);
}
public async Task RegisterUserAsync_Should_Return_InternalServerError_With_Message_If_Exception(
RegisterUserRequestDto registerUserRequestDto,
Exception exception)
{
_userService.CreateAsync(registerUserRequestDto.Username, registerUserRequestDto.Password,
registerUserRequestDto.Email).Throws(exception);
var result = await _userControllerInstance.RegisterUserAsync(registerUserRequestDto);
var response = result as ObjectResult;
Assert.NotNull(response);
Assert.AreEqual(500, response.StatusCode);
var responseObject = response.Value as string;
Assert.NotNull(responseObject);
Assert.AreEqual(exception.Message, responseObject);
}
public async Task <IActionResult> RegisterUserAsync([FromBody] RegisterUserRequestDto dto)
{
try
{
var user = await _userService.CreateAsync(dto.Username, dto.Password, dto.Email);
var response = _mapper.Map <RegisterUserResponseDto>(user);
response.Token = _jwtTokenService.CreateToken(user);
return(Ok(response));
}
catch (BaseBusinessLogicException e)
{
return(NotFound(e.Message));
}
catch (Exception e)
{
return(StatusCode((int)HttpStatusCode.InternalServerError, e.Message));
}
}
public async Task <IActionResult> Create([FromBody] RegisterUserRequestDto model)
{
if (!ModelState.IsValid)
{
return(BadRequest(new ManagedErrorResponse(ManagedErrorCode.Validation, "Hay errores de validación", ModelState)));
}
var user = new AppUser {
UserName = model.Email.Trim(), Email = model.Email.Trim()
};
var result = await _userManager.CreateAsync(user, model.Password.Trim());
if (result.Succeeded)
{
return(Ok(_mapper.Map <RegisterUserResponseDto>(user)));
}
else
{
var errors = result.Errors.Select(x => x.Description).ToList();
return(BadRequest(new ManagedErrorResponse(ManagedErrorCode.Validation, "Identity validation errors", errors)));
}
}
public async Task SQLInjectionValidatorTest()
{
SQLInjectionValidator <RegisterUserRequestDto> validator = new SQLInjectionValidator <RegisterUserRequestDto>();
RegisterUserRequestDto message = new RegisterUserRequestDto()
{
UserName = null,
Email = ";DROP TABLE test;",
Password = null,
PhoneNumber = null
};
bool result = await validator.IsValid(message);
result.Should().BeFalse();
message.Email = "*****@*****.**";
result = await validator.IsValid(message);
result.Should().BeTrue();
}
public async Task RegisterUserAsync_Should_Return_Correct_Result_If_No_Exceptions(RegisterUserRequestDto registerUserRequestDto,
UserModel userModel, string token, RegisterUserResponseDto registerUserResponseDto)
{
_userService.CreateAsync(registerUserRequestDto.Username, registerUserRequestDto.Password,
registerUserRequestDto.Email).Returns(userModel);
_mapper.Map <RegisterUserResponseDto>(userModel).Returns(registerUserResponseDto);
_jwtTokenService.CreateToken(userModel).Returns(token);
var result = await _userControllerInstance.RegisterUserAsync(registerUserRequestDto);
var response = result as OkObjectResult;
Assert.NotNull(response);
var responseObject = response.Value as RegisterUserResponseDto;
Assert.NotNull(responseObject);
Assert.AreEqual(registerUserResponseDto.Username, responseObject.Username);
Assert.AreEqual(token, responseObject.Token);
}
public void RegisterUserRequestDto_To_UserModel_Mapping_Should_Work_Correctly(RegisterUserRequestDto registerUserRequestDto)
{
var userModel = _mapper.Map <UserModel>(registerUserRequestDto);
Assert.IsTrue(Guid.TryParse(userModel.Id.ToString(), out _) && !userModel.Id.Equals(Guid.Empty));
Assert.That(userModel.Created, Is.EqualTo(DateTime.UtcNow).Within(1).Seconds);
Assert.That(userModel.Updated, Is.EqualTo(DateTime.UtcNow).Within(1).Seconds);
Assert.AreEqual(registerUserRequestDto.Email, userModel.Email);
Assert.AreEqual(registerUserRequestDto.Username, userModel.Username);
}
public async Task <IActionResult> Register([FromBody] RegisterUserRequestDto request)
{
var authResult = await AccountService.RegisterAsync(request.Username, request.Password);
return(GetResponseFrom(authResult));
}
public void RegisterUserRequestDto_To_UserModel_Mapping_Should_Generate_New_Fields(RegisterUserRequestDto registerUserRequestDto1,
RegisterUserRequestDto registerUserRequestDto2)
{
var userModel1 = _mapper.Map <UserModel>(registerUserRequestDto1);
var userModel2 = _mapper.Map <UserModel>(registerUserRequestDto2);
Assert.AreNotEqual(userModel1.Id, userModel2.Id);
Assert.AreNotEqual(userModel1.Created, userModel2.Created);
Assert.AreNotEqual(userModel1.Updated, userModel2.Updated);
}
