public RegisterAuth(ILoginRepository loginRepository, IUserRepository userRepository,
UserRegistrationInput userRegistrationInput)
{
this.loginRepository = loginRepository;
this.userRepository = userRepository;
this.UserRegistrationInput = userRegistrationInput;
}
public async Task <IActionResult> OnPost(UserRegistrationInput input)
{
if ((input.Login != null) && (input.Password != null))
{
var user = new User(input.Login);
if (await UserExists(user.Login))
{
return(BadRequest("Login exists"));
}
byte[] passwordHash, passwordSalt;
CreatePasswordhash(input.Password, out passwordHash, out passwordSalt);
user.PasswordHash = passwordHash;
user.PasswordSalt = passwordSalt;
await _context.Users.AddAsync(user);
await _context.SaveChangesAsync();
return(Redirect("/Offers/offers"));
}
return(Redirect("/error"));
}
public void RegisterUser(UserRegistrationData userData)
{
var userRegistrationInput = new UserRegistrationInput()
{
UserName = userData.UserName,
Password = userData.Password
};
_repository.AddUser(userRegistrationInput);
}
public ActionResult Register([FromBody] UserRegistrationInput registrationInput)
{
if (registrationInput == null)
{
return(BadRequest("Wrong input parameters"));
}
new CreateUserCommand(registrationInput)
.Execute(_userRepository);
return(Ok());
}
public dynamic AddUser(UserRegistrationInput userInput)
{
IUserRepository objUserRepository = new UserRepository();
User user = new User();
user.emailId = userInput.emailId;
user.name = userInput.name;
user.pwd = userInput.password;
user.role = 1;
user.status = "active";
var result = objUserRepository.Add(user);
return(result);
}
public void AddUser(UserRegistrationInput input)
{
var userName = input.UserName;
var password = input.Password;
if (_users.Find(u => u.Name == userName) != null)
{
throw new DuplicateNameException();
}
int newId = _users.Count;
var newUser = new User()
{
Id = newId, Name = userName, PasswordHash = password
};
_users.Add(newUser);
}
public async Task <IHttpActionResult> Register(UserRegistrationInput userModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
UserRegistrationResult result = await _authenticationService.RegisterUser(userModel);
IHttpActionResult errorResult = GetErrorResult(result);
if (errorResult != null)
{
return(errorResult);
}
return(Ok(result));
}
public async Task <UserRegistrationResult> RegisterUser(UserRegistrationInput userModel)
{
ApplicationUser user = new ApplicationUser
{
UserName = userModel.Email,
Email = userModel.Email
};
var identityResult = await _userManager.CreateAsync(user, userModel.Password);
if (identityResult != null)
{
return(identityResult.Succeeded
? new UserRegistrationResult(succeeded: true)
: new UserRegistrationResult(identityResult.Errors));
}
return(new UserRegistrationResult(succeeded: false));
}
public void AddUser(UserRegistrationInput input)
{
try {
using (var conn = new SqlConnection(cnnString)) {
using (var command = new SqlCommand("AddUser", conn)
{
CommandType = CommandType.StoredProcedure
}) {
command.Parameters.Add(new SqlParameter("@userName", input.UserName));
command.Parameters.Add(new SqlParameter("@passwordHash", input.Password));
conn.Open();
command.ExecuteNonQuery();
}
}
} catch (SqlException e) {
if (e.Message.Contains("duplicate key"))
{
throw new DuplicateNameException();
}
throw e;
}
}
public void ShouldRegisterAuth()
{
var user = new User(0, "alexandre", "felix", true, UserType.User);
var registration = new UserRegistrationInput()
{
Email = "*****@*****.**", Password = "******", User = user
};
var mockLoginRepo = new Mock <ILoginRepository>();
mockLoginRepo.Setup(mock => mock.Create(It.IsAny <Login>())).Returns(0);
var mockUserRepo = new Mock <IUserRepository>();
mockUserRepo.Setup(mock => mock.Create(It.IsAny <User>())).Returns(0);
mockUserRepo.Setup(mock => mock.DeleteById(0)).Returns(true);
var res = new RegisterAuth(mockLoginRepo.Object, mockUserRepo.Object, registration).Execute();
Assert.AreEqual("alexandre", res.User.FirstName);
Assert.AreEqual("felix", res.User.LastName);
Assert.AreEqual(true, res.User.IsAStudent);
Assert.AreEqual(UserType.User, res.User.Type);
}
public CreateUserCommand(UserRegistrationInput userInput)
{
Guard.IsNotNull(userInput, nameof(userInput));
_userInput = userInput;
}
public IActionResult Register([FromBody] UserRegistrationInput userRegistrationInput)
{
return(Ok(new RegisterAuth(loginRepository, Repository, userRegistrationInput).Execute()));
}
