public async Task <UserRegisterResponseModel> RegisterUser(UserRegisterRequestModel registerRequestModel)
{
// first check whether email exists in database
var dbUser = await _userRepository.GetUserByEmail(registerRequestModel.Email);
// user exists in database
if (dbUser != null)
{
//try
//{
//}
//catch (Exception ex)
//{
//ex.Data.Add("Id", dbUser.Id);
//ex.Data.Add("Email", dbUser.Email);
//ex.Data.Add("FullName", dbUser.FirstName + dbUser.LastName);
//throw new ConflictException("user already exists, please login");
throw new ConflictException("user already exists, please login");
throw new Exception("user already exists, please login");
//}
}
//if user doesn't exist in database
var salt = CreateSalt();
var hashedPassword = HashPassword(registerRequestModel.Password, salt);
var user = new User
{
FirstName = registerRequestModel.FirstName,
LastName = registerRequestModel.LastName,
Email = registerRequestModel.Email,
Salt = salt,
HashedPassword = hashedPassword,
DateOfBirth = registerRequestModel.DateOfBirth
};
var createdUser = await _userRepository.AddAsync(user);
var createdUserResponseModel = new UserRegisterResponseModel
{
Id = createdUser.Id,
Email = createdUser.Email,
FirstName = createdUser.FirstName,
LastName = createdUser.LastName
};
return(createdUserResponseModel);
}
public async Task <UserRegisterResponseModel> CreateUser(UserRegisterRequestModel reqeust)
{
var dbUser = await _userRepository.GetUserByEmail(reqeust.Email);
if (dbUser != null)
{
throw new Exception("Email already exists");
}
var salt = _cryptoService.GetSalt();
var hashingpsw = _cryptoService.HashingPassword(reqeust.Password, salt);
var user = new User
{
Email = reqeust.Email,
FirstName = reqeust.FirstName,
LastName = reqeust.LastName,
Salt = salt,
HashedPassword = hashingpsw
};
var createdUser = await _userRepository.AddAsync(user);
var response = new UserRegisterResponseModel
{
Id = createdUser.Id,
FirstName = createdUser.FirstName,
LastName = createdUser.LastName,
Email = createdUser.Email
};
return(response);
}
public async Task <UserRegisterResponseModel> CreateUser(UserRegisterRequestModel requestModel)
{
//Make sure email does not exist in DB
var dbUser = await _userRepository.GetUserByEmail(requestModel.Email);
if (dbUser != null &&
string.Equals(dbUser.Email, requestModel.Email, StringComparison.CurrentCultureIgnoreCase))
{
throw new Exception("Email Already Exist");
}
//Create unique salt and hash the pw
var salt = _cryptoService.CreateSalt();
var hashedPassWord = _cryptoService.HashPassword(requestModel.Password, salt);
var user = new User
{
Email = requestModel.Email,
Salt = salt,
HashedPassword = hashedPassWord,
FirstName = requestModel.FirstName,
LastName = requestModel.LastName
};
var createdUser = await _userRepository.AddAsync(user);
var response = new UserRegisterResponseModel
{
Id = createdUser.Id,
Email = createdUser.Email,
FirstName = createdUser.FirstName,
LastName = createdUser.LastName
};
return(response);
}
public async Task <IActionResult> RegisterUserAsync([FromBody] UserRegisterRequestModel user)
{
var createdUser = await _userService.CreateUser(user);
_logger.LogInformation("User Registred", createdUser.Id);
return(Ok(createdUser));
}
public async Task <UserRegisterResponseModel> CreateUser(UserRegisterRequestModel requestModel)
{
var dbUser = await _userRepository.GetUserByEmail(requestModel.Email);
if (dbUser != null &&
string.Equals(dbUser.Email, requestModel.Email, StringComparison.CurrentCultureIgnoreCase))
{
throw new ConflictException("Email Already Exits");
}
var salt = _encryptionService.CreateSalt();
var hashedPassword = _encryptionService.HashPassword(requestModel.Password, salt);
var user = new User
{
Email = requestModel.Email,
Salt = salt,
HashedPassword = hashedPassword,
FirstName = requestModel.FirstName,
LastName = requestModel.LastName
};
var createdUser = await _userRepository.AddAsync(user);
//var response = new UserRegisterResponseModel
//{
// Id = createdUser.Id, Email = createdUser.Email, FirstName = createdUser.FirstName,
// LastName = createdUser.LastName
//};
var response = _mapper.Map <UserRegisterResponseModel>(createdUser);
return(response);
}
public async Task <ApiResponse <UserRegisterResponseModel> > Register([FromBody] UserRegisterRequestModel model)
{
if (model == null || !this.ModelState.IsValid)
{
return(this.ModelStateErrors <UserRegisterResponseModel>());
}
var user = new ApplicationUser {
Email = model.Email, UserName = model.Email
};
user.Playlists.Add(new Playlist {
IsSystem = true, Name = PlaylistsConstants.CurrentPlaylistName
});
user.Playlists.Add(new Playlist {
IsSystem = true, Name = PlaylistsConstants.LikesPlaylistName
});
var result = await this.userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
return(this.GetIdentityApiErrors <UserRegisterResponseModel>(result));
}
return(new UserRegisterResponseModel {
Id = user.Id
}.ToApiResponse());
}
public async Task RegisterAsync([FromBody] UserRegisterRequestModel userRegisterRequestModel)
{
if (ModelState.IsValid)
{
var user = new User
{
Email = userRegisterRequestModel.Email,
UserName = userRegisterRequestModel.Email,
Role = userRegisterRequestModel.Role
};
var result = await _userManager.CreateAsync(user, userRegisterRequestModel.Password);
if (result.Succeeded)
{
await Login(new AuthModel
{
Email = userRegisterRequestModel.Email,
Password = userRegisterRequestModel.Password
});
}
else
{
Response.StatusCode = 400; // Bad Request
await Response.WriteAsync(string.Join("\n", result.Errors.Select(x => x.Description)));
}
}
}
public async Task <UserRegisterResponseModel> RegisterUser(UserRegisterRequestModel registerRequest)
{
//first check if user registered
var dbuser = await _userRepository.GetUserByEmail(registerRequest.Email);
if (dbuser != null)
{
throw new Exception("User Already exist");
}
// then create User Object and save it to database with UserRepository
var user = new Users()
{
Fullname = registerRequest.FullName,
Email = registerRequest.Email,
Password = registerRequest.Password,
JoinedOn = registerRequest.JoinedOn
};
// call repository to save User info that included salt and hashed password
var createdUser = await _userRepository.AddAsync(user);
// map user object to UserRegisterResponseModel object
var createdUserResponse = new UserRegisterResponseModel
{
Id = createdUser.Id,
Email = createdUser.Email,
FullName = createdUser.Fullname
};
return(createdUserResponse);
}
public async Task <UserRegisterResponseModel> RegisterUser(UserRegisterRequestModel userRegisterRequestModel)
{
var dbUser = await _userRepository.GetUserByEmail(userRegisterRequestModel.Email);
if (dbUser != null)
{
throw new ConflictException("User Already exists, please try to login");
}
var user = new User
{
Email = userRegisterRequestModel.Email,
Password = userRegisterRequestModel.Password,
FullName = userRegisterRequestModel.FullName,
JoinedOn = userRegisterRequestModel.JoinedOn
};
var createdUser = await _userRepository.AddAsync(user);
var response = new UserRegisterResponseModel
{
Id = user.Id,
Email = user.Email,
Password = user.Password,
FullName = user.FullName,
};
return(response);
}
public async Task <ActionResult> RegisterUserAsync(UserRegisterRequestModel user)
{
var createdUser = await _userService.RegisterUser(user);
//return CreatedAtRoute("GetUser", new {id = createdUser.Id}, createdUser);
return(Ok());
}
public async Task <UserRegisterResponseModel> CreateUser(UserRegisterRequestModel requestModel)
{
var dbUser = await _userRepository.GetUserByEmail(requestModel.Email);//make sure the user exist or not
if (dbUser != null &&
string.Equals(dbUser.Email, requestModel.Email, StringComparison.CurrentCultureIgnoreCase))
{
throw new ConflictException("Email Already Exits"); //if user already exist, cannot create user ccount
}
var salt = _encryptionService.CreateSalt();
var hashedPassword = _encryptionService.HashPassword(requestModel.Password, salt);
var user = new User
{
Email = requestModel.Email,
Salt = salt,
HashedPassword = hashedPassword,
FirstName = requestModel.FirstName,
LastName = requestModel.LastName
}; //create new user information
var createdUser = await _userRepository.AddAsync(user); //add those information to DB
var response = new UserRegisterResponseModel
{
Id = createdUser.Id,
Email = createdUser.Email,
FirstName = createdUser.FirstName,
LastName = createdUser.LastName
};
return(response);
}//manully mapping
public async Task <UserRegisterResponseModel> CreateUser(UserRegisterRequestModel requestModel)
{
//make sure email not in db
//we need to send email to our User Repo and see if the data exists for the email
var dbUser = await _userRepository.GetUserByEmail(requestModel.Email);
if (dbUser != null && string.Equals(dbUser.Email, requestModel.Email, StringComparison.CurrentCultureIgnoreCase))
{
throw new Exception("Email Already Exits");
}
//first step is to create a random salt
var salt = _encryptionService.CreateSalt();
var hashedPassword = _encryptionService.HashPassword(requestModel.Password, salt);
var user = new User
{
Email = requestModel.Email,
Salt = salt,
HashedPassword = hashedPassword,
FirstName = requestModel.FirstName,
LastName = requestModel.LastName
};
var createdUser = await _userRepository.AddAsync(user);
var response = new UserRegisterResponseModel
{
Id = createdUser.Id,
Email = createdUser.Email,
FirstName = createdUser.FirstName,
LastName = createdUser.LastName
};
return(response);
}
public void Register(UserRegisterRequestModel userRegisterRequestModel)
{
var user = _userRepository.GetByUsername(userRegisterRequestModel.Username);
if (user != null)
{
throw new Exception($"User with username: '******' already exists.");
}
user = _userRepository.GetByEmail(userRegisterRequestModel.Email);
if (user != null)
{
throw new Exception($"User with email: '{ userRegisterRequestModel.Email }' already exists.");
}
var activationId = Guid.NewGuid();
user = new User(userRegisterRequestModel.Username,
userRegisterRequestModel.FirstName,
userRegisterRequestModel.SecondName,
userRegisterRequestModel.Email,
activationId);
if (userRegisterRequestModel.Password.Empty())
{
throw new Exception(nameof(userRegisterRequestModel.Password));
}
user.SetPassword(userRegisterRequestModel.Password, _encrypter);
var message = ActivateMessageFactory.CreateActivationMessage(userRegisterRequestModel.Email, activationId);
_emailSender.SendEmail(message);
_userRepository.Add(user);
}
public async Task <bool> RegisterUser(UserRegisterRequestModel userRequestModel)
{
var dbUser = await _repository.GetUserByEmail(userRequestModel.Email);
if (dbUser != null)
{
throw new ConflictException("Email already exists");
}
var salt = _cryptoService.GenerateRandomSalt();
var hashedPassword = _cryptoService.HashPasswordWithSalt(userRequestModel.Password, salt);
// save user to the database
var user = new User
{
Email = userRequestModel.Email,
Salt = salt,
HashedPassword = hashedPassword,
FirstName = userRequestModel.FirstName,
LastName = userRequestModel.LastName,
DateOfBirth = userRequestModel.DateOfBirth
};
var createdUser = _repository.AddAsync(user);
if (createdUser != null && createdUser.Id > 0)
{
return(true);
}
return(false);
}
/// <summary>
/// Register
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task <UserRegisterRequestModel> Register(UserRegisterRequestModel request)
{
IReliableDictionary <string, UserState> myDictionary = await this.StateManager.GetOrAddAsync <IReliableDictionary <string, UserState> >("Users");
using (ITransaction tx = this.StateManager.CreateTransaction())
{
ConditionalValue <UserState> result = await myDictionary.TryGetValueAsync(tx, request.CellPhone);
if (!result.HasValue)
{
UserState state = new UserState
{
CellPhone = request.CellPhone,
PassWord = request.PassWord,
RealName = request.RealName,
UserIdentifier = Guid.NewGuid()
};
bool isSuc = await myDictionary.TryAddAsync(tx, state.CellPhone, state);
await tx.CommitAsync();
if (!isSuc)
{
return(null);
}
request.UserIdentifier = state.UserIdentifier;
return(request);
}
request.UserIdentifier = result.Value.UserIdentifier;
return(request);
}
}
public async Task <bool> RegisterUser(UserRegisterRequestModel userRegisterRequestModel)
{
// we need to check whether that email exists or not
var dbUser = await _userRepository.GetUserByEmail(userRegisterRequestModel.Email);
if (dbUser != null)
{
throw new ConfilictException("Email already exists");
}
// first generate salt
var salt = _cryptoService.GenerateRandomSalt();
// hash the password with salt and save the salt and hased password to the database
var hashedPassword = _cryptoService.HashPassword(userRegisterRequestModel.Password, salt);
var user = new User {
Email = userRegisterRequestModel.Email,
Salt = salt,
HashedPassword = hashedPassword,
FirstName = userRegisterRequestModel.FirstName,
LastName = userRegisterRequestModel.LastName,
DateOfBirth = userRegisterRequestModel.DateOfBirth
};
var createdUser = await _userRepository.AddAsync(user);
// if the limitation exceed the max length in the database then
// id will be set to negative
if (createdUser != null && createdUser.Id > 0)
{
return(true);
}
return(false);
}
public async Task <IActionResult> Register(UserRegisterRequestModel model)
{
var user = await _userService.RegisterUser(model);
// 201
return(Ok(user));
}
public async Task <IActionResult> Register(UserRegisterRequestModel model)
{
var user = await _userService.RegisterUser(model);
// 201
return(CreatedAtRoute("GetUser", new { id = user.Id }, user));
}
public async Task RegisterAsync([FromBody] UserRegisterRequestModel userRegisterRequestModel)
{
if (ModelState.IsValid)
{
var user = new User
{
Email = userRegisterRequestModel.Email,
UserName = userRegisterRequestModel.Email,
Role = userRegisterRequestModel.Role
};
var result = await _userManager.CreateAsync(user, userRegisterRequestModel.Password);
if (result.Succeeded)
{
await Login(new AuthModel
{
Email = userRegisterRequestModel.Email,
Password = userRegisterRequestModel.Password
});
}
else
{
await Response.WriteAsync("Result validation failed!");
}
}
}
public async Task <IActionResult> Register(UserRegisterRequestModel model)
{
if (ModelState.IsValid)
{
await _userService.CreateUser(model);
}
return(View());
}
public IActionResult RegisterUser(UserRegisterRequestModel userRegisterRequest)
{
if (ModelState.IsValid)
{
return(Ok(userRegisterRequest));
}
return(BadRequest(new { message = "please correct the input information" }));
}
public async Task <IActionResult> RegisterUser(UserRegisterRequestModel userRegisterRequestModel)
{
if (ModelState.IsValid)
{
return(Ok(userRegisterRequestModel));
}
return(BadRequest(new { message = "Please correct the input inforrmation" }));
}
public async Task <IActionResult> RegisterUser(UserRegisterRequestModel userRegisterRequest)
{
if (ModelState.IsValid)
{
// calll user servce
return(Ok(await _userService.CreateUser(userRegisterRequest)));
}
return(BadRequest(new { message = "please correct the input infomation" }));
}
public async Task <IActionResult> Register(UserRegisterRequestModel userRegisterRequest)
{
if (ModelState.IsValid)
{
//Call user service
return(Ok());
}
return(BadRequest(new { message = "please correct the input information" }));
}
public async Task <IActionResult> Register(UserRegisterRequestModel model)
{
if (ModelState.IsValid)
{
var createdUser = await _userService.CreateUser(model);
return(Redirect("Login"));
}
return(View());
}
public async Task <IActionResult> RegisterUser(UserRegisterRequestModel requestModel)
{
if (!ModelState.IsValid)
{
return(BadRequest("Please check data"));
}
var registeredUser = await _userService.RegisterUser(requestModel);
return(Ok(registeredUser));
}
public async Task <IActionResult> Register(UserRegisterRequestModel userRegisterRequestModel)
{
// only when all the validation are true can we proceed further
if (ModelState.IsValid)
{
// we need to send the userRegisterRequestModel to our service
await _userService.CreateUser(userRegisterRequestModel);
}
return(View());
}
//when user hits submit button
public async Task <IActionResult> Register(UserRegisterRequestModel model)
{
//true when all validations in the model are passed
if (ModelState.IsValid)
{
//send the model to our service
await _userService.CreateUser(model);
}
return(View());
}
public async Task <IActionResult> RegisterUser(UserRegisterRequestModel req)
{
if (ModelState.IsValid)
{
await _userService.CreateUser(req);
return(Ok());
}
return(BadRequest(new { message = "Please correct the input information" }));
}
public async Task <IActionResult> Register(UserRegisterRequestModel userRegisterRequestModel)
{
//only wehn each and every validation in our is true we need to proceed further
if (ModelState.IsValid)
{
//we need to sen the userRModel to our service
await _userService.CreateUser(userRegisterRequestModel);
}
return(View());
}
