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); }