public async Task <IActionResult> RegisterAdminAsync(UserToRegisterDto userToRegister)
{
if (ModelState.IsValid)
{
UserModel user = new AdminModel
{
UserName = userToRegister.Username,
Email = userToRegister.EmailAddress
};
IServiceResult <UserModel> registerResult = await _authService.RegisterAsync(user, userToRegister.Password, Url);
if (registerResult.Result == ResultType.Created)
{
return(Ok());
}
else
{
return(BadRequest(registerResult.Errors));
}
}
else
{
return(BadRequest(ModelState.Values));
}
}
public async Task <IActionResult> Register([FromBody] UserToRegisterDto userToRegister)
{
if (!string.IsNullOrEmpty(userToRegister.UserName))
{
userToRegister.UserName = userToRegister.UserName.ToLowerInvariant();
}
if (await _repo.UserExists(userToRegister.UserName))
{
ModelState.AddModelError("UserName", "User name already exists");
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var userToCreate = new User
{
UserName = userToRegister.UserName
};
var createUser = await _repo.Register(userToCreate, userToRegister.Password);
return(StatusCode(201));
}
public async Task <IActionResult> SignUp(UserToRegisterDto userToRegister)
{
if (string.IsNullOrEmpty(userToRegister.Email))
{
return(Problem("User email address is missing!", null, 404));
}
var user = await _userManager.FindByEmailAsync(userToRegister.Email);
if (user != null)
{
return(Problem("User already exists, please try with a different email address!", null, 500));
}
user = new User
{
Id = Guid.NewGuid().ToString(),
Email = userToRegister.Email,
UserName = userToRegister.Email,
};
var userCreateResult = await _userManager.CreateAsync(user, userToRegister.Password);
if (userCreateResult.Succeeded)
{
var userToReturn = _mapper.Map <UserAuthDto>(user);
return(CreatedAtRoute("GetUserRoute", new { id = user.Id },
new { Status = StatusCode(201), User = userToReturn, token = GenerateJwt(user) }));
}
return(Problem(userCreateResult.Errors.First().Description, null, 500));
}
public async Task <IActionResult> Register(UserToRegisterDto userForRegister)
{
//validate request
string usernameFormatted = userForRegister.Username.ToLower();
bool userExists = await this.authRepository.UserExists(userForRegister.Username);
//Check if user exists
if (userExists)
{
return(BadRequest("Username Already Exists"));
}
//Create new User Instance
var userToCreate = new User {
Username = userForRegister.Username
};
//Create User
var createdUser = await this.authRepository.Register(userToCreate, userForRegister.Password);
//Check if user exists
if (createdUser == null)
{
return(Unauthorized());
}
var userContext = this.mapper.Map <UserContextDTO>(createdUser);
userContext.Token = GenerateAuthToken(createdUser);
//Write token into response sent to client
return(Ok(userContext));
}
public async Task <ActionResult <UserToReturnDto> > Register(UserToRegisterDto registerDto)
{
if (CheckEmailExistsAsync(registerDto.Email).Result.Value)
{
return(new BadRequestObjectResult(new ApiValidationErrorResponse {
Errors = new[] { "Пользователь уже существует" }
}));
}
var user = new AppUser
{
DisplayName = registerDto.DisplayName,
Email = registerDto.Email,
UserName = registerDto.Email
};
var result = await _userManager.CreateAsync(user, registerDto.Password);
if (!result.Succeeded)
{
return(BadRequest(new ApiResponse(400)));
}
return(new UserToReturnDto
{
Email = user.Email,
Token = _tokenService.CreateToken(user),
DisplayName = user.DisplayName
});
}
public async Task <IActionResult> RegisterUser(UserToRegisterDto userToRegister)
{
if (!await _userService.FindUserAsync(userToRegister.Name))
{
await _userService.RegisterUserAsync(userToRegister);
return(Ok());
}
return(BadRequest("Username already exists"));
}
public async Task <IActionResult> register(UserToRegisterDto userToRegisterDto)
{
User user = await _userRepo.createUser(userToRegisterDto.username, userToRegisterDto.password, userToRegisterDto.email);
if (user == null)
{
return(BadRequest("User with duplicated data allready exists"));
}
await _userRepo.SaveAll();
return(Ok("Registration completed"));
}
public async Task <IActionResult> Register(UserToRegisterDto userToRegisterDto)
{
var userToCreate = _mapper.Map <User>(userToRegisterDto);
var result = await _userManager.CreateAsync(userToCreate, userToRegisterDto.Password);
if (result.Succeeded)
{
return(StatusCode(201));
}
return(BadRequest(result.Errors));
}
public async Task <ActionResult <UserWithTokenDto> > Register([FromForm] UserToRegisterDto userToRegister)
{
var registeredUser = await _userService.RegisterUserAsync(userToRegister);
if (registeredUser.HasError)
{
// Showing modal view message
ViewData["modalMessage"] = registeredUser.Message;
return(View());
}
return(View("UserCreatedSuccesfully"));
}
public async Task <IActionResult> Register(UserToRegisterDto userToRegisterDto)
{
userToRegisterDto.UserName = userToRegisterDto.UserName.ToLower();
if (await _repo.UserExists(userToRegisterDto.UserName))
{
return(BadRequest("User already exists"));
}
var userToCreate = new User()
{
UserName = userToRegisterDto.UserName
};
var user = await _repo.Register(userToCreate, userToRegisterDto.Password);
return(Ok());
}
public async Task <IActionResult> Register(UserToRegisterDto dto)
{
dto.Username = dto.Username.ToLower();
if (await _authRepository.UserExists(dto.Username))
{
return(BadRequest("Username already exists"));
}
var userToRegister = _mapper.Map <User>(dto);
var registeredUser = await _authRepository.Register(userToRegister, dto.Password);
var userToReturn = _mapper.Map <UserForDetailedDto>(registeredUser);
return(CreatedAtRoute("GetUser", new { controller = "Users", id = registeredUser.Id }, userToReturn));
}
public async Task <IActionResult> Register(UserToRegisterDto userToRegisterDto)
{
var userToCreate = _mapper.Map <User>(userToRegisterDto);
var result = await _userManager.CreateAsync(userToCreate, userToRegisterDto.Password);
var userToReturn = _mapper.Map <UserForDetailedDto>(userToCreate);
if (result.Succeeded)
{
return(CreatedAtRoute("GetUser", new { controller = "User", id = userToCreate.Id }, userToReturn)); //Getuser from user controller
}
return(BadRequest(result.Errors));
}
public IActionResult Register(UserToRegisterDto userToRegister)
{
if (_repo.UserExists(userToRegister.username))
{
return(BadRequest("username already exists"));
}
var registeredUser = _repo.Register(userToRegister);
if (registeredUser == null)
{
return(BadRequest("unable to register user"));
}
return(Ok(registeredUser));
}
public async Task <IActionResult> Register(UserToRegisterDto userToRegisterDto)
{
userToRegisterDto.Username = userToRegisterDto.Username.ToLower();
if (await _repo.UserExists(userToRegisterDto.Username))
{
return(BadRequest("User with that username already exists"));
}
var userToCreate = _mapper.Map <User>(userToRegisterDto);
var createdUser = await _repo.Register(userToCreate, userToRegisterDto.Password);
var userToReturn = _mapper.Map <UserForDetailedDto>(createdUser);
return(CreatedAtRoute("GetUser", new { controller = "Users", id = createdUser.Id }, userToReturn));
}
public async Task <IActionResult> Register(UserToRegisterDto userToRegisterDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
userToRegisterDto.Username = userToRegisterDto.Username.ToLower();
if (await _repo.UserExist(userToRegisterDto.Username))
{
return(BadRequest("User Name already Exists"));
}
var userToCreate = _mapper.Map <User>(userToRegisterDto);
var Createduser = await _repo.Register(userToCreate, userToRegisterDto.Password);
return(StatusCode(201));
}
public async Task <IActionResult> Register(UserToRegisterDto user)
{
User userToCreate = _mapper.Map <User>(user);
var result = await _userManager.CreateAsync(userToCreate, user.Password);
var userToReturn = _mapper.Map <UserToReturn>(userToCreate);
if (result.Succeeded)
{
return(CreatedAtRoute("GetUser", new {
Controller = "Users", id = userToCreate.Id
}, userToReturn));
}
return(BadRequest(result.Errors));
}
public async Task <IActionResult> Register(UserToRegisterDto userToRegister)
{
userToRegister.Login = userToRegister.Login.ToLower();
if (await _repo.UserExists(userToRegister.Login))
{
return(BadRequest("This user alreade exists!"));
}
var userToCreateBlueprint = new User {
Login = userToRegister.Login, IsAdmin = false
};
var createdUser = await _repo.Register(userToCreateBlueprint, userToRegister.Password);
return(StatusCode(201));
}
public async Task <IActionResult> Register(UserToRegisterDto userToRegisterDto)
{
userToRegisterDto.Login = userToRegisterDto.Login.ToLower();
if (await _repository.UserExists(userToRegisterDto.Login))
{
return(BadRequest("Użytkownik już istnieje!"));
}
var userToCreate = new UserEntity {
Login = userToRegisterDto.Login, IsAdmin = false
};
await _repository.Register(userToCreate, userToRegisterDto.Password);
return(StatusCode(201));
}
public async Task <IActionResult> Register([FromBody] UserToRegisterDto userToRegisterDto)
{
userToRegisterDto.Username = userToRegisterDto.Username.ToLower();
if (await _authRepository.UserExists(userToRegisterDto.Username))
{
return(BadRequest("Username already registered"));
}
var user = new User {
Username = userToRegisterDto.Username
};
var CreatedUser = await _authRepository.Register(user, userToRegisterDto.Password);
return(StatusCode(201));
}
public async Task <IActionResult> Register(UserToRegisterDto userToRegisterDto)
{
userToRegisterDto.Username = userToRegisterDto.Username.ToLower();
if (await _authRepository.UserExist(userToRegisterDto.Username))
{
return(BadRequest("User exists"));
}
var userToCreate = new User()
{
Name = userToRegisterDto.Username
};
var createdUser = await _authRepository.Register(userToCreate, userToRegisterDto.Password);
return(StatusCode(201));
}
public async Task <UserActionResult> RegisterUserAsync(UserToRegisterDto userToRegister, ERoles role = ERoles.User)
{
// Checking if user exist
if (await CheckUserExistAync(userToRegister.Email))
{
string messageFailed = $"User with email '{userToRegister.Email}'";
_logger.LogWarning(messageFailed);
return(InitResult(0, null, true, messageFailed));
}
// Adding crypto service to generate salt and use hashing
using var hmac = new HMACSHA512();
var user = new EUser
{
FirstName = userToRegister.FirstName,
LastName = userToRegister.LastName,
Email = userToRegister.Email.ToLower(),
PasswordSalt = hmac.Key,
PasswordHash = hmac.ComputeHash(Encoding.UTF8.GetBytes(userToRegister.Password)),
CreatedUTC = DateTime.UtcNow
};
// Create user
await _dbcontext.Users.AddAsync(user);
await _dbcontext.SaveChangesAsync();
var userRole = new ERole
{
EUserId = user.id,
Role = userToRegister.Email == "admin@localhost" ? ERoles.Administrator : ERoles.User,
EUser = user
};
// Assign user role
await _dbcontext.Roles.AddAsync(userRole);
await _dbcontext.SaveChangesAsync();
string messageSeccess = $"User '{userToRegister.Email}' has been registered.";
_logger.LogInformation(messageSeccess);
return(InitResult(user.id, null, false, messageSeccess));
}
public async Task <IActionResult> Register(UserToRegisterDto userForRegisterDto)
{
//validate request
userForRegisterDto.Username = userForRegisterDto.Username.ToLower();
if (await _repo.UserExists(userForRegisterDto.Username))
{
return(BadRequest("Username Already Exist"));
}
var userToCreate = new User
{
Username = userForRegisterDto.Username
};
var createdUser = await _repo.Register(userToCreate, userForRegisterDto.password);
return(StatusCode(201));
}
public async Task <IActionResult> Register(UserToRegisterDto usertoregister)
{
usertoregister.Username = usertoregister.Username.ToLower();
if (await _repo.UserExists(usertoregister.Username))
{
return(BadRequest("Username already exists"));
}
var UserToCreate = new User {
Username = usertoregister.Username
};
var createdUser = await _repo.Register(UserToCreate, usertoregister.Password);
return(StatusCode(201));
}
public async Task <IActionResult> RegisterAsync(UserToRegisterDto userToRegister)
{
if (ModelState.IsValid)
{
IServiceResult registrationResult = await _authService.RegisterAsync(userToRegister);
if (registrationResult.Result == ResultType.Correct)
{
return(Ok());
}
else
{
return(BadRequest(registrationResult.Errors));
}
}
return(BadRequest());
}
public async Task <IActionResult> Register(UserToRegisterDto userToRegisterDto)
{
userToRegisterDto.UserName = userToRegisterDto.UserName.ToLower();
if (await _authRepository.UserExists(userToRegisterDto.UserName))
{
return(BadRequest("Username already exists"));
}
var userToRegister = _mapper.Map <User>(userToRegisterDto);
var createdUser = await _authRepository.Register(userToRegister, userToRegisterDto.Password);
var userToReturn = _mapper.Map <UserDto>(createdUser);
return(Created("", userToReturn));
//return CreatedAtRoute("GetUser", new { ControllerContext = "Users", id = userToReturn.Id }, userToReturn);
}
public async Task <IActionResult> Register(UserToRegisterDto userToRegisterDto)
{
//We dont need ModelState.IsValid() because [ApiController] takes care of validation
userToRegisterDto.Username = userToRegisterDto.Username.ToLower();
if (await _repo.UserExists(userToRegisterDto.Username))
{
return(BadRequest("User already Exists."));
}
var userToCreate = _mapper.Map <User>(userToRegisterDto);
var createdUser = await _repo.Register(userToCreate, userToRegisterDto.Password);
var userToReturn = _mapper.Map <UserForDetailedDto>(userToCreate);
return(CreatedAtRoute("GetUser", new { controller = "Users", id = createdUser.Id }, userToReturn));
}
public async Task <IActionResult> Register(UserToRegisterDto userToRegisterDto)
{
userToRegisterDto.Username = userToRegisterDto.Username.ToLower();
if (await _auth.UserExists(userToRegisterDto.Username))
{
return(BadRequest("User already exists"));
}
var userToCreate = new User
{
Name = userToRegisterDto.Username
};
var userCreated = await _auth.Register(userToCreate, userToRegisterDto.Password);
return(await Login(new
UserToLoginDto { UserName = userToCreate.Name, Password = userToRegisterDto.Password }
));
}
public async Task <IActionResult> Register([FromBody] UserToRegisterDto userToRegisterDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
userToRegisterDto.Username = userToRegisterDto.Username.ToLower();
if (await _repo.UserExists(userToRegisterDto.Username))
{
return(BadRequest("user already exists"));
}
//var userToCreate = new User() { Username = userToRegisterDto.Username };
var userToCreate = _mapper.Map <User>(userToRegisterDto);
var createdUser = await _repo.Register(userToCreate, userToRegisterDto.Password);
var userToReturn = _mapper.Map <UserForDetailedDto>(createdUser);
return(CreatedAtRoute("GetUser", new { controller = "Users", id = createdUser.Id }, userToReturn));
}
public async Task <IActionResult> Register(UserToRegisterDto userToRegisterDto)
{
//To validate
userToRegisterDto.Username = userToRegisterDto.Username.ToLower();
if (await _repo.UserExists(userToRegisterDto.Username))
{
return(BadRequest("User already exists"));
}
var toCreateUser = new User()
{
Username = userToRegisterDto.Username
};
var createdUser = await _repo.Register(toCreateUser, userToRegisterDto.Password);
return(StatusCode(201));
}
public async Task <IActionResult> Register(UserToRegisterDto userToRegisterDto)
{
// jeżeli nie było by [ApiController] w celu validacji należy dodać do parametru atrybut [FromBody]
// a w obsłudze validacji
// if (!ModelState.IsValid)
// return BadRequest(ModelState);
userToRegisterDto.UserName = userToRegisterDto.UserName.ToLower();
if (await repo.UserExist(userToRegisterDto.UserName))
{
return(BadRequest("Uzytkownik o takim loginie już istnieje"));
}
var userToCreate = new User
{
UserName = userToRegisterDto.UserName
};
var createUser = await repo.Register(userToCreate, userToRegisterDto.Password);
return(StatusCode(201));
}
