public async Task <IActionResult> Register(UserForRegister userforRegister)
{
// if (!ModelState.IsValid) return BadRequest(ModelState);
// userforRegister.UserName = userforRegister.UserName.ToLower();
// if (await _repo.UserExists(userforRegister.UserName))
// return BadRequest("UserName already Exists");
// var UserToCreate = new User
// {
// UserName = userforRegister.UserName
// };
var UserToCreate = _mapper.Map <User>(userforRegister);
var result = await _userManager.CreateAsync(UserToCreate,
userforRegister.Password);
// var createdUser = await _repo.Register(UserToCreate, userforRegister.Password);
var usertoreturn = _mapper.Map <UserForDetaileddto>(UserToCreate);
if (result.Succeeded)
{
return(CreatedAtRoute("GetUser", new { controller = "Users",
id = UserToCreate.Id }, usertoreturn));
}
return(BadRequest(result.Errors));
}
public IActionResult Register([FromBody] UserForRegister userForRegister)//
{
try
{
_authenticationService.Register(userForRegister);
return(Ok(new { Success = true }));
}
catch (InvalidOperationException invalidOperationException)
{
return(BadRequest(new
{
Success = false,
Error = invalidOperationException.Message
}));
}
catch (ArgumentNullException argumentNullException)
{
return(BadRequest(new
{
Success = false,
Error = argumentNullException.Message
}));
}
catch (Exception exception)
{
return(new ObjectResult(new
{
Success = false,//
Error = exception.Message
})
{
StatusCode = StatusCodes.Status500InternalServerError
});
}
}
public async Task <IActionResult> Register([FromBody] UserForRegister userForResister)
{
if (!string.IsNullOrEmpty(userForResister.Username))
{
userForResister.Username = userForResister.Username.ToLower();
}
if (await Repo.UserExistsAsync(userForResister.Username))
{
ModelState.AddModelError("Username", "User is already taken");
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
userForResister.Username = userForResister.Username.ToLower();
var userToCreate = new User()
{
Username = userForResister.Username
};
var createUser = await Repo.Register(userToCreate, userForResister.Password);
return(StatusCode(201));
}
public IDataResult <User> Register(UserForRegister userForRegister, string password)
{
byte[] passwordHash, passwordSalt;
var result = UserExists(userForRegister.Email);
if (!result.Success)
{
return(new ErrorDataResult <User>(result.Message));
}
HashingHelper.CreatePasswordHash(password, out passwordHash, out passwordSalt);
User user = new User
{
Email = userForRegister.Email,
FirstName = userForRegister.FirstName,
LastName = userForRegister.LastName,
CreatedAt = DateTime.Now,
PasswordHash = passwordHash,
PasswordSalt = passwordSalt
};
_userService.SignupUser(user);
return(new SuccessDataResult <User>(user, Messages.UserRegistered));
}
public IActionResult Register(UserForRegister userForRegister)
{
var userExists = _authService.UserExists(userForRegister.Email);
if (!userExists.Success)
{
return(BadRequest(userExists.Message));
}
var registerResult = _authService.Register(userForRegister, userForRegister.Password);
_basketService.Add(new Basket {
UserId = registerResult.Data.Id
});
_favoriteService.Add(new Favorite {
UserId = registerResult.Data.Id
});
var result = _authService.CreateAccessToken(registerResult.Data);
if (result.Success)
{
return(Ok(result.Data));
}
return(BadRequest(result.Message));
}
public async Task <IActionResult> Register(UserForRegister userDto)
{
//IS NOT NECESSRYYYYYY por que herada de apicontroller
//if(!ModelState.IsValid)
//{
// return BadRequest(new Error(HttpStatusCode.BadRequest.ToString(), "Los datos ingresados tienen un formato incorrecto"));
//}
if (await _authRepository.UserExists(userDto.UserName))
{
return(BadRequest(new Error(HttpStatusCode.BadRequest.ToString(), "User " + userDto.UserName + "already exists")));
}
var userToCreate = _mapper.Map <UserApplication>(userDto);
var registerdUser = await this._authRepository.RegisterUser(userToCreate, userDto.Password);
UserPhoto photo = new UserPhoto
{
IsMain = true,
UserApplicationId = registerdUser.Id,
PublicId = "i0qwn3iomugvu4ps04p8",
DateAdded = DateTime.Now,
user = registerdUser,
Url = "http://res.cloudinary.com/dapyqzhn4/image/upload/v1591522415/i0qwn3iomugvu4ps04p8.png"
};
registerdUser.Photos = new List <UserPhoto>();
registerdUser.Photos.Add(photo);
await _authRepository.SaveAll();
var userToReturn = _mapper.Map <UserDetailsDTO>(userToCreate);
return(CreatedAtRoute("GetUser", new { controller = "users", id = userToCreate.Id }, userToReturn));
}
public async Task <IActionResult> register([FromBody] UserForRegister userForRegister)
{
// User Exist ??
if (string.IsNullOrEmpty(userForRegister.username))
{
return(BadRequest(ModelState));
}
userForRegister.username = userForRegister.username.ToLower();
if (await _repo.UserExist(userForRegister.username))
{
ModelState.AddModelError("Username", "Taki user już istnieje");
return(BadRequest("Taki user juz istnieje"));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// create user
var userToCreate = _mapper.Map <User>(userForRegister);
var createUser = await _repo.Register(userToCreate, userForRegister.password);
var userForReturn = _mapper.Map <UserForDetailsDto>(createUser);
// return StatusCode(201);
return(CreatedAtRoute("GetUser", new { controller = "UserData", id = createUser.Id }, userForReturn));
}
public async Task RegisterLoginAlreadyExistsBadRequestStatus()
{
//Arrange
var userForRegister = new UserForRegister {
Username = "******", Password = "******", RepeatPassword = "******"
};
var userManager = MockIdentity.GetMockUserManager();
var signInManager = MockIdentity.GetMockSignInManager();
var user = new User {
UserName = "******"
};
AuthController controller = new AuthController(userManager.Object,
signInManager.Object, configMock.Object, mapperMock.Object,
wrapperMock.Object);
userManager.Setup(um => um.CreateAsync(user, "test"))
.Returns(Task.FromResult(IdentityResult.Failed()));
wrapperMock.Setup(u => u.UserRepository.GetLastUser())
.Returns(Task.FromResult(new User {
Id = 1
}));
mapperMock.Setup(m => m.Map <User>(userForRegister)).Returns(user);
//Act
var action = await controller.Register(userForRegister) as BadRequestObjectResult;
//Assert
Assert.Equal(400, action.StatusCode);
Assert.NotNull(action.Value);
}
public async Task RegisterOkStatus()
{
//Arrange
var userForRegister = new UserForRegister {
Username = "******", Password = "******", RepeatPassword = "******"
};
var userManager = MockIdentity.GetMockUserManager();
var signInManager = MockIdentity.GetMockSignInManager();
var user = new User {
UserName = "******"
};
AuthController controller = new AuthController(userManager.Object,
signInManager.Object, configMock.Object, mapperMock.Object,
wrapperMock.Object);
userManager.Setup(um => um.CreateAsync(user, "test"))
.Returns(Task.FromResult(IdentityResult.Success));
wrapperMock.Setup(u => u.UserRepository.GetLastUser()).Returns(Task.FromResult(user));
mapperMock.Setup(m => m.Map <User>(userForRegister)).Returns(user);
//Act
var action = await controller.Register(userForRegister) as OkResult;
//Assert
Assert.Equal(200, action.StatusCode);
}
protected override void SaveData()
{
var userReg = new UserForRegister
{
FirstName = txtFirst.Text,
LastName = txtLast.Text,
Password = txtPassword.Text,
UserId = txtUserID.Text,
Roles = Convert.ToInt32(cboGroup.SelectedValue.ToString())
};
var result = _authBLL.Register(userReg);
if (result == 1)
{
LoadData();
InitGrid();
LockButton(true, false);
LockField(false, false);
LoadRole();
MessageBox.Show("User Has Been Created");
}
else if (result == 2)
{
MessageBox.Show("User Already Exists");
}
else
{
MessageBox.Show("User Has Been Failed");
}
}
public async Task <IActionResult> Register(UserForRegister userForRegister)
{
userForRegister.DateOfBirth = userForRegister.DateOfBirth.AddHours(3);
if (userForRegister.DateOfBirth.CalculateAge() < 16)
{
return(BadRequest("You should have at least 16 years old!"));
}
var user = await _userManager.FindByNameAsync(userForRegister.Username);
if (user != null)
{
return(BadRequest("Username already taken"));
}
;
var userToCreate = _mapper.Map <User>(userForRegister);
userToCreate.Created = DateTime.Now;
userToCreate.LastActive = DateTime.Now;
var result = await _userManager.CreateAsync(userToCreate, userForRegister.Password);
var userToReturn = _mapper.Map <UserProfileDetails>(userToCreate);
if (result.Succeeded)
{
return(Ok(userToReturn));
}
return(BadRequest(result.Errors));
}
public async static Task Initialize(AuthContext _context)
{
AuthRepository repository = new AuthRepository(_context);
_context.Database.EnsureCreated();
if (_context.Users.Any())
{
return;
}
UserForRegister user1 = new UserForRegister()
{
Username = "******", Role = "Admin", Password = "******"
};
UserForRegister user2 = new UserForRegister()
{
Username = "******", Role = "User", Password = "******"
};
UserForRegister user3 = new UserForRegister()
{
Username = "******", Role = "User", Password = "******"
};
List <UserForRegister> users = new List <UserForRegister>()
{
user1, user2, user3
};
await repository.CreateMany(users);
}
public async Task <IActionResult> Register(UserForRegister user)
{
//VALIDATE REQUES!
if (await _repo.UserNameExists(user.Username))
{
return(BadRequest("Username Exists"));
}
if (await _repo.PhoneExists(user.Phone))
{
return(BadRequest("Phone Exists"));
}
var result = "approved"; //await _phone.CheckCode(user.Phone, user.Code);
if (result != "approved")
{
return(BadRequest("Wrong Code"));
}
var userToCreate = new User
{
UserName = user.Username,
Phone = user.Phone
};
var createdUser = await _repo.Register(userToCreate, user.Password);
var token = CreateToken(createdUser);
return(Ok(new { token }));
}
public async Task <IActionResult> Register(UserForRegister userForRegister)
{
// validate request
userForRegister.username = userForRegister.username.ToLower();
if (await _repo.UserExists(userForRegister.username))
{
return(BadRequest("Username already exists"));
}
// This code was used before we automapped the RegisterForUser DTO to the User Database
//var userToCreate = new Users
// {
// Username = userForRegister.username
// };
// Now we can use the auto mapper for this function
var userToCreate = _mapper.Map <Users>(userForRegister);
var createdUser = await _repo.Register(userToCreate, userForRegister.password);
// Creates a user to return that does not contain the password.
var userToReturn = _mapper.Map <UserForDetailedDto>(createdUser);
// This was a security workaround that was used as a cheat during early stages of development
// return StatusCode(201);
// This is the final solution which uses a location header
return(CreatedAtRoute("GetUser", new { controller = "Users", id = createdUser.ID }, userToReturn));
}
public async Task <IActionResult> Register(UserForRegister userForRegisterDto)
{
if (userForRegisterDto.Password != userForRegisterDto.RepeatPassword)
{
return(BadRequest("The password repeat is incorrect."));
}
var userToCreate = mapper.Map <User>(userForRegisterDto);
var lastUser = await repositoryWrapper.UserRepository.GetLastUser();
if (lastUser == null)
{
userToCreate.Nickname = "user" + 1;
}
userToCreate.Nickname = "user" + lastUser.Id;
userToCreate.PhotoId = random.Next(1, 9);
var result = await userManager.CreateAsync(userToCreate, userForRegisterDto.Password);
if (result.Succeeded)
{
return(Ok());
}
return(BadRequest("User with this login already exists."));
}
public async Task <IActionResult> Register([FromBody] UserForRegister userForRegister)
{
//validate input ,, [apicontroller] olduğu için aşağıdaki kontrole gerek yok
if (!ModelState.IsValid)
{
return(BadRequest("girmiş olduğunuz şifre veya username hatalı"));
}
userForRegister.Username = userForRegister.Username.ToLower();
if (await _repo.UserExists(userForRegister.Username))
{
return(BadRequest("username already exists"));
}
var userToCreate = new User()
{
username = userForRegister.Username
};
var cereatedUsed = _repo.Register(userToCreate, userForRegister.Password);
return(StatusCode(201));
}
public async Task <IActionResult> Register([FromBody] UserForRegister userForRegisterDto)
{
if (await _authRepository.UserExists(userForRegisterDto.UserName))
{
ModelState.AddModelError("UserName", "Username already exists");
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var userToCreate = new User
{
Username = userForRegisterDto.UserName,
};
var studentCreate = new Student
{
name = userForRegisterDto.name,
surname = userForRegisterDto.surname,
tcNo = userForRegisterDto.tcNo
};
var getStudentId = await _authRepository.StudentRegister(studentCreate);
var createdUser = await _authRepository.Register(userToCreate, userForRegisterDto.Password, getStudentId.id);
return(StatusCode(201));
}
public async Task <IActionResult> Register([FromBody] UserForRegister UserForRegister)
{
//convert username to lowercase string if there is one
if (!string.IsNullOrEmpty(UserForRegister.UserName))
{
UserForRegister.UserName = UserForRegister.UserName.ToLower();
}
if (await _repo.UserExists(UserForRegister.UserName))
{
ModelState.AddModelError("UserName", "Username Already Exists");
}
// validate request
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var userToCreate = _mapper.Map <User>(UserForRegister);
var createdUser = await _repo.Register(userToCreate, UserForRegister.Password);
var userToReturn = _mapper.Map <UserForDetailedDto>(createdUser);
return(CreatedAtRoute("GetUser", new { controller = "Users", id = createdUser.Id }, userToReturn));
}
public async Task <IActionResult> Register(UserForRegister registerDTO)
{
//validate the username
registerDTO.Username = registerDTO.Username.ToLower();
if (await _auth.UserExists(registerDTO.Username))
{
return(BadRequest("Username already exist"));
}
User user = new User()
{
Username = registerDTO.Username
};
try
{
//save to database
user = await _auth.Register(user, registerDTO.Password);
}catch (Exception e)
{
return(BadRequest("cannot register to database, please try again"));
}
return(StatusCode(201));
}
public async Task <IActionResult> Register([FromBody] UserForRegister userForRegister)
{
if (!string.IsNullOrEmpty(userForRegister.Username))
{
userForRegister.Username = userForRegister.Username.ToLower();
}
if (await _authService.UserExists(userForRegister.Username))
{
ModelState.AddModelError("Username", "Username already exists");
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
userForRegister.Username = userForRegister.Username.ToLower();
if (await _authService.UserExists(userForRegister.Username))
{
return(BadRequest("Username is already taken"));
}
var userToCreate = new User
{
Username = userForRegister.Username
};
var createUser = await _authService.Register(userToCreate, userForRegister.Password);
return(StatusCode(201)); // we'll improve this later
}
public int Register(UserForRegister userForRegister)
{
try
{
if (_uow.AuthRepository.UserExists(userForRegister.UserId))
{
return(2); // user telah ada
}
var userToCreate = new User
{
firstName = userForRegister.FirstName,
lastName = userForRegister.LastName,
roles = userForRegister.Roles,
userId = userForRegister.UserId
};
_uow.AuthRepository.Register(userToCreate, userForRegister.Password);
_uow.Commit();
return(1);
}
catch (Exception)
{
_uow.Rollback();
return(0);
throw;
}
}
public async Task <IActionResult> Register(UserForRegister user, string ReturnUrl)
{
if (!ModelState.IsValid)
{
return(View(user));
}
ResultModel result = new ResultModel();
var data = JsonConvert.SerializeObject(user);
result = await _callApi.CallAPI(data, new Uri(_config["api"].ToString() + "/auth/register"), "POST");
TempData["IsSuccess"] = result.IsSuccess;
TempData["msg"] = result.Message;
if (!result.IsSuccess)
{
return(View(user));
}
if (!string.IsNullOrEmpty(ReturnUrl) && Url.IsLocalUrl(ReturnUrl))
{
return(Redirect(ReturnUrl));//導到原始要求網址
}
return(RedirectToAction(nameof(Register)));
}
public async Task <ActionResult <dynamic> > Create([FromBody] UserForRegister model)
{
AuthRepository repository = new AuthRepository(_context);
User userToBeAdded = new User(model.Username, model.Role);
User newUser = await repository.Create(userToBeAdded, model.Password);
return(newUser);
}
public async Task <IActionResult> Register([FromBody] UserForRegister userForRegister)
{
if (!string.IsNullOrEmpty(userForRegister.username))
{
userForRegister.username = userForRegister.username.ToLower();
}
if (await _authService.UserExists(userForRegister.username))
{
ModelState.AddModelError("Username", "Username already exists");
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
userForRegister.username = userForRegister.username.ToLower();
if (await _authService.UserExists(userForRegister.username))
{
return(BadRequest("Username is already taken"));
}
var userToCreate = new User
{
email = userForRegister.email,
name = userForRegister.name,
username = userForRegister.username,
createdAt = DateTime.Now,
avatarBackground = userForRegister.avatarBackground
};
var createUser = await _authService.Register(userToCreate, userForRegister.password);
// GENERATE TOKEN
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(_config.GetSection("AppSettings:Token").Value);
var tokenDescriptor = new SecurityTokenDescriptor // Describes information we want to include in token
{
Subject = new ClaimsIdentity(new Claim[] // Payload
{
new Claim(ClaimTypes.NameIdentifier, createUser.Id.ToString()),
new Claim(ClaimTypes.Name, createUser.username)
}),
Expires = DateTime.Now.AddDays(1),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key),
SecurityAlgorithms.HmacSha512Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor); // Create token
var tokenString = tokenHandler.WriteToken(token); // to string (from byte[])
return(Ok(new { token = tokenString, user = createUser }));
}
public async Task <IdentityResult> Register(UserForRegister userForRegister)
{
var user = new User()
{
UserName = userForRegister.Username,
EmployeeId = userForRegister.EmployeeId
};
var userToReturn = await _unitOfWork.Authentication.Register(user, userForRegister.Password);
return(userToReturn);
}
public async Task <IActionResult> Register(UserForRegister userForRegister)
{
byte[] passwordHash;
byte[] passwordSalt;
var userFound = await _authRepository.GetUserByUserName(userForRegister.Username);
if (userFound == null)
{
userFound = await _authRepository.GetUserByEmail(userForRegister.Email);
if (userFound != null)
{
return(BadRequest(new { message = "Email already exists!" }));
}
}
else
{
return(BadRequest(new { message = "Username Already exists!" }));
}
Utilities.CreatePasswordHash(userForRegister.Password, out passwordHash, out passwordSalt);
User user = _mapper.Map <User>(userForRegister);
user.PasswordHash = passwordHash;
user.PasswordSalt = passwordSalt;
_playAppRepository.Add(user);
await _playAppRepository.SaveAll();
List <Claim> claims = new List <Claim>();
claims.Add(new Claim(ClaimTypes.NameIdentifier, user.Id.ToString()));
claims.Add(new Claim(ClaimTypes.Name, user.Username));
var accessToken = GenerateToken(claims);
var refreshToken = GenerateRefreshToken();
user.RefreshToken = refreshToken;
await _authRepository.SaveRefreshToken(user);
return(Ok(new
{
accessToken = accessToken.Token,
expirationDate = accessToken.ExpirationDate.ToString("s"),
refreshToken = refreshToken.Replace("+", "%2B")
}));
}
public async Task <IActionResult> Register(UserForRegister userForRegister)
{
var user = mapper.Map <User>(userForRegister);
var result = await userManager.CreateAsync(user, userForRegister.Password);
if (result.Succeeded)
{
return(StatusCode(201));
}
return(BadRequest(result.Errors));
}
public void Register_ValidUser_IsSuccessful()
{
UserForRegister userForRegister = new UserForRegister();
var authenticationServiceMock = new Mock <IAuthenticationService>();
authenticationServiceMock.Setup(x => x.Register(userForRegister));
var authenticationController = new AuthenticationController(authenticationServiceMock.Object);
var result = (OkObjectResult)authenticationController.Register(userForRegister);
var json = JsonConvert.SerializeObject(result.Value);
var dictionary = JsonConvert.DeserializeObject <Dictionary <string, object> >(json);
Assert.IsTrue((bool)dictionary["Success"] == true);
}
public async Task <IActionResult> Register(UserForRegister userForRegister)
{
var userToCreate = this.mapper.Map <User>(userForRegister);
var result = await this.userManager.CreateAsync(userToCreate, userForRegister.Password);
if (result.Succeeded)
{
await this.userManager.AddToRoleAsync(userToCreate, userForRegister.Role);
return(Ok());
}
return(BadRequest(result.Errors));
}
public async Task <IActionResult> Register(UserForRegister ufr)
{
ufr.username = ufr.username.ToLower();
if (await _repo.UserExists(ufr.username))
{
return(BadRequest("User already exists ..."));
}
User test = new User {
Username = ufr.username
};
var createdUser = await _repo.Register(test, ufr.password);
return(StatusCode(201));
}
