public ActionResult Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new CreateUserContract
{
UserName = model.UserName,
Email = model.Email,
FirstName = model.FirstName,
LastName = model.LastName,
NewPassword = model.Password,
};
try
{
var client = GetUserClient();
client.CreateNewUser(user);
return(RedirectToAction(nameof(SuccessfulRegistration)));
}
catch (HttpErrorCodeException e)
{
AddErrors(e);
}
catch (MainServiceException e)
{
AddErrors(e);
}
}
return(View(model));
}
public HttpResponseMessage CreateUser(CreateUserContract contract)
{
try
{
var settings = new RegisterationDetails
{
PortalSettings = PortalSettings,
Email = contract.Email,
FirstName = contract.FirstName,
LastName = contract.LastName,
UserName = contract.UserName,
Password = contract.Password,
Question = contract.Question,
Answer = contract.Answer,
Notify = contract.Notify,
Authorize = contract.Authorize,
RandomPassword = contract.RandomPassword,
IgnoreRegistrationMode = true
};
var userInfo = RegisterController.Instance.Register(settings);
return(Request.CreateResponse(HttpStatusCode.OK, userInfo != null
? UserBasicDto.FromUserDetails(Components.UsersController.Instance.GetUserDetail(PortalId,
userInfo.UserId))
: null));
}
catch (Exception ex)
{
Logger.Error(ex);
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex.Message));
}
}
public int CreateNewUser(CreateUserContract data)
{
if (m_registrationOption.ReservedUsernames.Contains(data.UserName.ToLower()))
{
throw new MainServiceException(MainServiceErrorCode.ReservedUsernameError, $"Username '{data.UserName}' is reserved, cannot be used.", HttpStatusCode.BadRequest, data.UserName);
}
var userId = new CreateNewUserWork(m_userRepository, m_communicationProvider, data, m_codeGenerator).Execute();
return(userId);
}
public IActionResult CreateNewUser([FromBody] CreateUserContract data)
{
try
{
var userId = m_userManager.CreateNewUser(data);
return(Ok(userId));
}
catch (HttpErrorCodeException exception)
{
return(StatusCode(exception.StatusCode, exception.Message));
}
}
public void ShouldBeAbleToGetUserById()
{
var sut = new UserService(context, mapper, mockAuthService);
var user1 = new CreateUserContract()
{
Name = "User1", Email = "*****@*****.**", Password = "******"
};
var createdUser = sut.CreateUser(user1);
var user = sut.GetUser(createdUser.Id);
Assert.NotNull(user);
Assert.Equal(user1.Name, user.Name);
Assert.Equal(user1.Email, user.Email);
Assert.Equal(Security.SecurityHelper.GenerateHash(user1.Password), user.Password);
}
public int CreateNewUser(CreateUserContract data)
{
try
{
//EnsureSecuredClient();
var result = m_client.Post <int>("user", data);
return(result);
}
catch (HttpRequestException e)
{
if (m_logger.IsErrorEnabled())
{
m_logger.LogError("{0} failed with {1}", m_client.GetCurrentMethod(), e);
}
throw;
}
}
public IHttpActionResult SignUp(CreateUserContract user)
{
UserContract newUser;
try
{
newUser = _userService.CreateUser(user);
}
catch (ValidationException e) {
throw new HttpResponseException(
Request.CreateErrorResponse(e.Code, e.Message));
}
catch (Exception)
{
throw;
}
return(Created(string.Empty, newUser));
}
public async Task <ActionResult> CreateUser([FromBody][Required] CreateUserContract createUserContract)
{
if (m_logger.IsEnabled(LogLevel.Information))
{
var passwordBackup = createUserContract.Password;
createUserContract.Password = "******"; // Password can not be logged!
m_logger.LogInformation(GetMethodCalledLoggingString(null, createUserContract));
createUserContract.Password = passwordBackup;
}
var userModel = Mapper.Map <UserModel>(createUserContract.User);
userModel.Username = string.IsNullOrEmpty(createUserContract.UserName)
? m_userManager.GenerateUsername().Result
: createUserContract.UserName;
var appUser = Mapper.Map <ApplicationUser>(userModel);
appUser.EmailConfirmCode = await m_identityUserManager.GenerateEmailConfirmationTokenAsync(appUser);
appUser.PhoneNumberConfirmCode = await m_identityUserManager.GeneratePhoneConfirmationTokenAsync(appUser);
var result = await m_identityUserManager.CreateAsync(appUser, createUserContract.Password);
if (!result.Succeeded)
{
var error = result.Errors.FirstOrDefault();
return(Error(error?.Description, error?.Code));
}
var user = m_identityUserManager.FindByNameAsync(appUser.UserName).Result;
_ = m_identityUserManager.SendConfirmContactsCodesAsync(user); //Ignore error, user can use Resend button
m_userManager.AddRoleToUser(user.Id, RoleNames.RegisteredUser);
var userResult = m_userManager.GetUserByUsername(appUser.UserName);
var userContract = Mapper.Map <UserContract>(userResult.Result);
return(Json(userContract));
}
public void ShouldNotBeAbleToCreateAnUserWithDuplicateEmail()
{
var sut = new UserService(context, mapper, mockAuthService);
var user1 = new CreateUserContract()
{
Name = "User1", Email = "*****@*****.**", Password = "******"
};
sut.CreateUser(user1);
var user2 = new CreateUserContract()
{
Name = "User2", Email = user1.Email, Password = "******"
};
var exception = Record.Exception(() => sut.CreateUser(user2));
Assert.NotNull(exception);
Assert.IsType <ValidationException>(exception);
}
public UserContract CreateUser(CreateUserContract user)
{
if (_context.Users.Any(x => string.Equals(x.Email, user.Email)))
{
throw new ValidationException(System.Net.HttpStatusCode.NoContent, ApiResources.DuplicateEmail);
}
var newUser = _mapper.Map <CreateUserContract, User>(user);
newUser.Password = Security.SecurityHelper.GenerateHash(user.Password);
var token = _authenticationService.RequestToken(newUser);
newUser.AccessToken = token;
newUser.LastLogin = DateTime.UtcNow;
var ee = _context.Add(newUser);
_context.SaveChanges();
return(_mapper.Map <User, UserContract>(ee.Entity));
}
/// <inheritdoc />
public async Task <User> CreateUser(CreateUserContract createUserContract)
{
var user = await _userRepository.CreateUser(createUserContract);
}
///<inheritdoc />
public Task <User> CreateUser(CreateUserContract createUserContract)
{
throw new NotImplementedException();
}
public IActionResult CreateUser([FromBody] CreateUserContract createUserContract)
{
var user = await _userService.CreateUser(createUserContract);
return(Ok(user));
}
public async Task <UserContract> CreateUserAsync(CreateUserContract contract)
{
var fullPath = $"{BasePath}create";
return(await m_authorizationServiceHttpClient.SendRequestAsync <UserContract>(HttpMethod.Post, fullPath, contract));
}
public async Task <IActionResult> CreateUser(CreateUserContract model)
{
await _userManager.CreateByAdmin(new UserDto { Email = model.Email, UserName = model.UserName, Password = model.Password, Role = model.Role });
return(Ok(model));
}
