public async Task <IActionResult> Register(UserForRegisterDto userForRegisterDto)
{
userForRegisterDto.UserName = userForRegisterDto.UserName.ToLower();
if (await _repo.UserExists(userForRegisterDto.UserName))
{
return(BadRequest("Username already exists"));
}
var UserToCreate = new User
{
UserName = userForRegisterDto.UserName,
CompanyName = userForRegisterDto.CompanyName,
ContactNumber = userForRegisterDto.ContactNumber,
Email = userForRegisterDto.Email
};
var createdUser = await _repo.Register(UserToCreate, userForRegisterDto.Password);
return(StatusCode(201));
}
public ActionResult Register(UserForRegisterDto userForRegisterDto)
{
var userExists = _authService.UserExists(userForRegisterDto.Email);
if (!userExists.Success)
{
return(BadRequest(userExists.Message));
}
var registerResult = _authService.Register(userForRegisterDto, userForRegisterDto.Password);
var result = _authService.CreateAccessToken(registerResult.Data);
if (result.Success)
{
return(Ok(result.Data));
System.Console.WriteLine(Messages.RegisterSuccess);
}
return(BadRequest(result.Message));
}
public async Task <IActionResult> Register([FromBody] UserForRegisterDto userForRegisterDto)
{
var userExist = await _authService.UserExistAsync(userForRegisterDto.Email);
if (!userExist.Success)
{
return(BadRequest(userExist.Message));
}
var registerResult = await _authService.RegisterAsync(userForRegisterDto);
//TODO After register redirect to login
var result = await _authService.CreateAccessTokenAsync(registerResult.Data);
if (result.Success)
{
return(Ok(result.Data));
}
return(BadRequest(result.Message));
}
public async Task <IActionResult> Register([FromBody] UserForRegisterDto userForRegisterDto) // Receive the username & password as a json serialized object
{
// Validate request
userForRegisterDto.Username = userForRegisterDto.Username.ToLower();
if (await _repo.UserExists(userForRegisterDto.Username))
{
return(BadRequest("Username already exists"));
}
// Create a user
var userToCreate = _mapper.Map <User>(userForRegisterDto);
// Pass the user object and password to the Register method in the _repo
var createdUser = _repo.Register(userToCreate, userForRegisterDto.Password);
var userToReturn = _mapper.Map <UserForDetailedDto>(createdUser);
return(CreatedAtRoute("GetUser", new { controller = "Users", id = createdUser.Id }, userToReturn));
}
public async Task <IActionResult> Register(UserForRegisterDto userForRegisterDto)
{
//Before registering our user, determine if the username exists in our database:
userForRegisterDto.Username = userForRegisterDto.Username.ToLower();
if (await _repo.UserExists(userForRegisterDto.Username))
{
return(BadRequest("Username already exists"));
}
//Now create our user:
var userToCreate = new User
{
Username = userForRegisterDto.Username,
PhotoUrl = "https://res.cloudinary.com/jbakeacake/image/upload/v1591390502/Default_Photo_qgxjgl.png"
};
var createdUser = await _repo.Register(userToCreate, userForRegisterDto.Password);
return(StatusCode(201)); // send up a success code
}
public async Task <IActionResult> Register(UserForRegisterDto userForRegisterDto)
{
if (!ModelState.IsValid)
{
return(BadRequest("The user name or the password are not valid."));
}
userForRegisterDto.Username = userForRegisterDto.Username.ToLower();
if (await repo.UserExists(userForRegisterDto.Username))
{
return(BadRequest("Username already exists"));
}
var user = mapper.Map <User>(userForRegisterDto);
user = await repo.Register(user, userForRegisterDto.Password);
var userToReturn = mapper.Map <UserForDetailedDto>(user);
return(CreatedAtRoute("GetUser", new { controller = "Users", id = user.Id }, userToReturn));
}
public IDataResult <User> Register(UserForRegisterDto userForRegisterDto, string password)
{
if (UserExits(userForRegisterDto.Email).Success)
{
byte[] passwordHash, passwordSalt;
HashingHelper.CreatePasswordHash(password, out passwordHash, out passwordSalt);
var user = new User
{
Email = userForRegisterDto.Email,
Firstname = userForRegisterDto.FirstName,
Lastname = userForRegisterDto.LastName,
PasswordHash = passwordHash,
PasswordSalt = passwordSalt,
Status = true
};
_userService.Add(user);
return(new SuccessDataResult <User>(user, Messages.UserRegistered));
}
return(new ErrorDataResult <User>(Messages.EmailUse));
}
public async Task <IActionResult> Register(UserForRegisterDto userForRegisterDto)
{
userForRegisterDto.Username = userForRegisterDto.Username.ToLower();
if (await _repo.UserAlreadyExist(userForRegisterDto.Username))
{
return(BadRequest("User already exist"));
}
var userToCreate = new User
{
Username = userForRegisterDto.Username,
Name = userForRegisterDto.Name,
Surname = userForRegisterDto.Surname,
Email = userForRegisterDto.Email,
Department = userForRegisterDto.Department,
};
var createdUser = await _repo.Register(userToCreate, userForRegisterDto.Password);
return(StatusCode(201));
}
public async Task <IActionResult> SuperVisorRegister(UserForRegisterDto userForRegisterDto)
{
userForRegisterDto.Username = userForRegisterDto.Username.ToLower();
if (await _repo.SuperVisorExists(userForRegisterDto.Username))
{
return(BadRequest("User alerady regaistred SuperVisor"));
}
var SuperVisorCreation = new SuperVisor
{
Username = userForRegisterDto.Username,
Email = userForRegisterDto.Email,
BirthDate = userForRegisterDto.BirthDate,
JobNumber = userForRegisterDto.JobNumber,
NationalId = userForRegisterDto.NationalId,
};
var createdUser = await _repo.SuperVisorReg(SuperVisorCreation, userForRegisterDto.Password);
return(Ok(new { createdUser = "******" }));
}
public async Task <IActionResult> Register(UserForRegisterDto userForRegisterDto)
{
//Used if ApiController is removed
// if(!ModelState.IsValid)
// return BadRequest(ModelState);
userForRegisterDto.Username = userForRegisterDto.Username.ToLower();
if (await _repo.UserExists(userForRegisterDto.Username))
{
return(BadRequest("Username already exists!"));
}
var userToCreate = _mapper.Map <User>(userForRegisterDto);
var createdUser = await _repo.Register(userToCreate, userForRegisterDto.Password);
var userToReturn = _mapper.Map <UserForDetailedDto>(createdUser);
return(CreatedAtRoute("GetUser", new { controller = "Users", id = createdUser.Id }, userToReturn));
}
public async Task <IActionResult> Register(UserForRegisterDto userForRegisterDto)
{
var userToCreate = _mapper.Map <User>(userForRegisterDto);
var result = await _userManager.CreateAsync(userToCreate, userForRegisterDto.Password);
var userToReturn = _mapper.Map <UserToReturnDto>(userToCreate);
if (result.Succeeded)
{
var user = await _userManager.FindByNameAsync(userForRegisterDto.UserName);
return(Ok(new
{
token = GenerateJwtToken(user).Result,
user = userToReturn
}));;
}
return(BadRequest(result.Errors));
}
public async Task <ActionResult> Register(UserForRegisterDto userForRegisterDto)
{
// request validation
// convert to lowercase
userForRegisterDto.Username = userForRegisterDto.Username.ToLower();
if (await _repo.UserExists(userForRegisterDto.Username))
{
return(BadRequest("Username already exists."));
}
// Create the new user
var userToCreate = _mapper.Map <User>(userForRegisterDto);
var createdUser = await _repo.Register(userToCreate, userForRegisterDto.Password);
var userToReturn = _mapper.Map <UserForDetailedDto>(createdUser);
return(CreatedAtRoute("GetUser", new { controller = "Users", id = createdUser.Id }, userToReturn));
}
public async Task <IActionResult> Register([FromBody] UserForRegisterDto userForRegisterDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
userForRegisterDto.Username = userForRegisterDto.Username.ToLower();
if (await _repo.UserExists(userForRegisterDto.Username))
{
return(BadRequest("UserName Alrady Exist"));
}
var userToCreate = new User
{
Username = userForRegisterDto.Username
};
var CreatedUser = await _repo.Register(userToCreate, userForRegisterDto.Password);
return(StatusCode(201));
}
public ActionResult Register(UserForRegisterDto userForRegisterDto)
{
//TODO:there is an error during userexist check....
var userExists = _authService.UserExists(userForRegisterDto.Email);
if (!userExists.IsSuccess)
{
return(BadRequest(userExists.Message));
}
var registerResult = _authService.Register(userForRegisterDto, userForRegisterDto.Password);
var result = _authService.CreateAccessToken(registerResult.Data);
if (result.IsSuccess)
{
return(Ok(result.Data));
}
return(BadRequest(result.Message));
}
public async Task <IActionResult> Register(UserForRegisterDto userForRegisterDto)
{
//validate request - below code is required when ApiController attribute is not added
//public async Task<IActionResult> Register([FromBody]UserForRegisterDto userForRegisterDto)
//if(!ModelState.IsValid)
//return BadRequest(ModelState);
userForRegisterDto.UserName = userForRegisterDto.UserName.ToLower();
if (await _repo.UserExists(userForRegisterDto.UserName))
{
return(BadRequest("Username already exists."));
}
var userToCreate = new User {
UserName = userForRegisterDto.UserName
};
var createdUser = await _repo.Register(userToCreate, userForRegisterDto.Password);
return(StatusCode(201));
}
public async Task <IActionResult> Register(UserForRegisterDto userForRegisterDto)
{
var username = userForRegisterDto.Username;
var password = userForRegisterDto.Password;
username = username.ToLower();
if (await _repo.UserExists(username))
{
return(BadRequest("Username already exists"));
}
var userToCreate = new User
{
Username = username
};
var createdUser = await _repo.Register(userToCreate, password);
return(StatusCode(201));
}
public Result Register(UserForRegisterDto userForRegisterDto, string password)
{
byte[] passwordHash, passwordSalt;
HashingHelper.CreatePasswordHash(password, out passwordHash, out passwordSalt);
var user = new User
{
Email = userForRegisterDto.Email,
FirstName = userForRegisterDto.FirstName,
LastName = userForRegisterDto.LastName,
PasswordHash = passwordHash,
PasswordSalt = passwordSalt,
Status = true
};
_userService.Add(user);
return(new Result
{
Message = "Kullanıcı başarıyla kaydedildi",
Success = true
});
}
public async Task <IActionResult> Register(UserForRegisterDto userForRegisterDto) // ApiController annotation automatically tells this method to infer that this param is in the body of the request
{
// ApiController also adds for this functionality for us
// if (!ModelState.IsValid) return BadRequest(ModelState)
// Which runs the model validation and returns the error messages
// Validate request
var username = userForRegisterDto.Username.ToLower();
if (await _authRepository.UserExists(username))
{
return(BadRequest("User already exists"));
}
var userToCreate = _mapper.Map <User>(userForRegisterDto);
var createdUser = await _authRepository.Register(userToCreate, userForRegisterDto.Password);
var userToReturn = _mapper.Map <UserForDetailDto>(createdUser);
return(CreatedAtRoute("GetUser", new { controller = "Users", id = createdUser.Id }, userToReturn));
}
public async Task <IActionResult> Register(UserForRegisterDto registerDto)
{
//validad la request
//validar usaurio y lowercas
registerDto.Username = registerDto.Username.ToLower();
//verificar si existe
if (await _repo.UserExits(registerDto.Username))
{
return(BadRequest("El usaurio ya existe"));
}
var UserToCreate = new User {
Username = registerDto.Username
};
var createdUser = await _repo.Register(UserToCreate, registerDto.Password);
// return CreatedAtRoute();
return(StatusCode(201));
}
public async Task <IActionResult> Register(UserForRegisterDto userForRegisterDto)
{
//validate request
userForRegisterDto.Username = userForRegisterDto.Username.ToLower(); // zeby wszystkie litery byly male
if (await _repo.UserExists(userForRegisterDto.Username))
{
return(BadRequest("Username already exists"));
}
var userToCreate = new User
{
Username = userForRegisterDto.Username
};
var createdUser = await _repo.Register(userToCreate, userForRegisterDto.Password);
return(StatusCode(201));
}
public async Task <bool> ChangePassword(UserForRegisterDto user, string password)
{
bool exists = await UserExists(user.Username);
if (!exists)
{
return(false);
}
var foundUser = await _context.Users.Where(u => u.Username == user.Username).FirstAsync();
byte[] passwordHash, passwordSalt;
CreatePasswordHash(password, out passwordHash, out passwordSalt);
foundUser.PasswordHash = passwordHash;
foundUser.PasswordSalt = passwordSalt;
await _context.SaveChangesAsync();
return(true);
}
public async Task <IActionResult> Register(UserForRegisterDto userForRegisterDto)
{
//validate requests
string username = userForRegisterDto.Username;
string password = userForRegisterDto.Password;
username = username.ToLower();
if (await _repo.UserExists(username))
{
return(BadRequest("Username already exists"));
}
var userToCreate = _mapper.Map <User>(userForRegisterDto);
var createdUser = await _repo.Register(userToCreate, password);
var userToReturn = _mapper.Map <UserForDetailedDto>(createdUser);
return(CreatedAtRoute("GetUser", new { controller = "users", id = createdUser.Id }, userToReturn));
}
public async Task <IActionResult> Register(UserForRegisterDto userForRegisterDto)
{
//validate input
userForRegisterDto.Name = userForRegisterDto.Name.ToLower();
if (await _repo.UserExists(userForRegisterDto.Name))
{
return(BadRequest("Username already exists"));
}
var userToCreate = new User()
{
Name = userForRegisterDto.Name
};
var userCreated = await _repo.Register(userToCreate, userForRegisterDto.Password);
//return CreatedAtRoute(...);
return(StatusCode(201));
}
//public async Task<IActionResult> Signup([FromBody]UserForRegisterDto userForRegisterDto)
public async Task <IActionResult> Register([FromBody] UserForRegisterDto userForRegisterDto)
{
// username equal to first Email that the user
userForRegisterDto.Username = userForRegisterDto.Email.ToLower();
userForRegisterDto.Email = userForRegisterDto.Email.ToLower();
if (await _repo.UserExists(userForRegisterDto.Username.ToLower()))
{
return(BadRequest("user already exists"));
}
var userToCreate = _mapper.Map <User>(userForRegisterDto);
var createdUser = await _repo.Register(userToCreate, userForRegisterDto.Password);
return(StatusCode(201)); // status for createdRoute
// return CreatedAtRoute("GetUser", new {controller = "Users", id = createdUser.Id}, userToReturn);
}
public async Task <IActionResult> Register(UserForRegisterDto userForRegisterDto)
{
userForRegisterDto.Username = userForRegisterDto.Username.ToLower();
if (await repo.UserExists(userForRegisterDto.Username))
{
return(BadRequest("Username already exists"));
}
User userToCreate = mapper.Map <User>(userForRegisterDto);
User createdUser = await repo.Register(userToCreate, userForRegisterDto.Password);
UserForRegisterDto userToReturn = mapper.Map <UserForRegisterDto>(createdUser);
return(CreatedAtRoute("GetUser", new {
controller = "Users",
id = createdUser.Id
},
userToReturn));
}
public async Task <IActionResult> Register(UserForRegisterDto userForRegisterDto)
{
//validar request
userForRegisterDto.Username = userForRegisterDto.Username.ToLower();
if (await userService.ExistUserByName(userForRegisterDto.Username))
{
return(BadRequest("Username already exists"));
}
var createdUsed = await authService.RegisterUser(userForRegisterDto);
if (createdUsed != null)
{
return(StatusCode(201));
}
else
{
return(BadRequest());
}
}
public async Task <IActionResult> Register(UserForRegisterDto userForRegisterDto)
{
// validate request
// if(!ModelState.IsValid) return BadRequest(ModelState);
userForRegisterDto.Username = userForRegisterDto.Username.ToLower();
if (await _repo.UserExists(userForRegisterDto.Username))
{
return(BadRequest("Username already exists"));
}
var userToCreate = new User
{
Username = userForRegisterDto.Username
};
var createdUser = await _repo.Register(userToCreate, userForRegisterDto.Password);
return(StatusCode(201));
}
public async Task <IActionResult> Register(UserForRegisterDto userForRegisterDto)
{
userForRegisterDto.UserName = userForRegisterDto.UserName.ToLower();
if (await _repo.UserExists(userForRegisterDto.UserName))
{
return(BadRequest("User Name already exists"));
}
// var UserToCreate = new User
// {
// Username = userForRegisterDto.UserName
// };
var UserToCreate = _mapper.Map <User>(userForRegisterDto);
var createdUser = await _repo.Register(UserToCreate, userForRegisterDto.Password);
var userToReturn = _mapper.Map <UserForDetailedDto>(createdUser);
return(CreatedAtRoute("GetUsers", new { Controller = "Users",
id = createdUser.Id }, userToReturn));
}
public async Task <IActionResult> Register([FromBody] UserForRegisterDto userForRegisterDto)
{
if (await _authRepository.UserExists(userForRegisterDto.UserName))
{
ModelState.AddModelError("UserName", "Username already exists.");
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var useToCreate = new User
{
Username = userForRegisterDto.UserName
};
var createdUser = await _authRepository.Register(useToCreate, userForRegisterDto.Password);
return(StatusCode(201));
}
public async Task <IActionResult> Register(UserForRegisterDto userForRegisterDto)
{//Register([FromBody]UserForRegisterDto userForRegisterDto)
//[FromBody] generate "" to "" if don't had it generate "" to null
//no need [FromBody] if you declare [ApiController] on this class
/* if(!ModelState.IsValid) //no need this if you declare [ApiController] on this class
* return BadRequest(ModelState);*/
var userToCreate = _mapper.Map <User>(userForRegisterDto);
var result = await _userManager.CreateAsync(userToCreate, userForRegisterDto.Password);
var resultAddRole = await _userManager.AddToRoleAsync(userToCreate, "Member");
var userToReturn = _mapper.Map <UserForDetailedDto>(userToCreate);
if (result.Succeeded && resultAddRole.Succeeded)
{
return(CreatedAtRoute("GetUser", new { controller = "Users", id = userToCreate.Id }, userToReturn));
}
return(BadRequest(result.Errors));
}
