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 <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)
{
var dbUser = await _userRepository.GetUserByEmail(requestModel.Email);
if (dbUser != null && string.Equals(dbUser.Email, requestModel.Email, StringComparison.CurrentCultureIgnoreCase))
{
throw new Exception("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
};
return(response);
}
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 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> 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 UserRegisterResponseModel registerEmployee(RegisterEmployeeRequestModel employeeRegisterModel, out ErrorModel errorModel)
{
errorModel = null;
UserRegisterResponseModel userRegisterResponse = null;
SqlConnection connection = null;
try
{
using (connection = new SqlConnection(Database.getConnectionString()))
{
SqlCommand command = new SqlCommand(SqlCommands.SP_registerEmployee, connection);
command.CommandType = System.Data.CommandType.StoredProcedure;
#region Commands Parameters
command.Parameters.AddWithValue("email", employeeRegisterModel.email);
command.Parameters.AddWithValue("password", employeeRegisterModel.email);
command.Parameters.AddWithValue("fname", employeeRegisterModel.firstName);
command.Parameters.AddWithValue("lname", employeeRegisterModel.lastName);
command.Parameters.AddWithValue("phone", employeeRegisterModel.phone);
command.Parameters.AddWithValue("userTypeId", employeeRegisterModel.userType);
command.Parameters.AddWithValue("gender", employeeRegisterModel.gender);
#endregion
connection.Open();
SqlDataReader reader = command.ExecuteReader();
userRegisterResponse = new UserRegisterResponseModel();
if (reader.Read())
{
if (reader.isColumnExists("ErrorCode"))
{
errorModel = new ErrorModel();
errorModel.ErrorCode = reader["ErrorCode"].ToString();
errorModel.ErrorMessage = reader["ErrorMessage"].ToString();
}
else
{
userRegisterResponse.Email = reader["email"].ToString();
userRegisterResponse.UserId = reader["userId"].ToString();
}
}
command.Dispose();
return(userRegisterResponse);
}
}
catch (Exception exception)
{
errorModel = new ErrorModel();
errorModel.ErrorMessage = exception.Message;
return(null);
}
finally
{
if (connection != null)
{
connection.Close();
}
}
}
public async Task <UserRegisterResponseModel> GetUserDetails(int id)
{
var user = await _userRepository.GetByIdAsync(id);
var details = new UserRegisterResponseModel();
PropertyCopy.Copy(details, user);
return(details);
}
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)
{
throw new ConflictException("user already exists, please login");
//throw new Exception("user already exists, please login");
}
// continue with our hashing
// create a salt and add salt to the user entered password and create user object and save it to db
//Generate Salt
var salt = CreateSalt();
//var saltExistsDb = await _userRepository.SaltExists(salt);
//if (!saltExistsDb)
//{
// //continue
//}
//Hash password
var hashedPassword = HashPassword(registerRequestModel.Password, salt);
//Save user Entity in DB
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> GetUserDetails(int id)
{
var user = await _userRepository.GetByIdAsync(id);
var model = new UserRegisterResponseModel {
Id = user.Id,
Email = user.Email,
FirstName = user.FirstName,
LastName = user.LastName
};
return(model);
}
public UserRegisterResponseModel register(UserRegisterRequestModel userRegister, out ErrorModel errorModel)
{
errorModel = null;
try
{
User userProvider = new User();
UserRegisterResponseModel userRegisterResponse = userProvider.register(userRegister.Email, userRegister.Password, userRegister.FirstName, userRegister.lastName, userRegister.Phone, userRegister.UserType, out errorModel);
return(userRegisterResponse);
}
catch (Exception e)
{
return(null);
}
}
private UserRegisterResponseModel UserToUserRegResponse(User user)
{
if (user == null)
{
return(null);
}
var userRegiResponseModel = new UserRegisterResponseModel();
userRegiResponseModel.Id = user.Id;
userRegiResponseModel.Email = user.Email;
userRegiResponseModel.FirstName = user.FirstName;
userRegiResponseModel.LastName = user.LastName;
return(userRegiResponseModel);
}
public async Task <UserRegisterResponseModel> GetUserProfile(string email)
{
var dbuser = await _userRepository.GetUserByEmail(email);
if (dbuser == null)
{
return(null);
}
var user = new UserRegisterResponseModel {
Id = dbuser.Id, Email = dbuser.Email, FirstName = dbuser.FirstName, LastName = dbuser.LastName
};
return(user);
}
public async Task <UserRegisterResponseModel> Register(UserRegisterRequestModel newPlayer)
{
UserRegisterResponseModel returnValue = new UserRegisterResponseModel {
IsSuccess = true, PlayerId = -1
};
if (_context.PlayerIdentity.AnyAsync(t => t.Login == newPlayer.Login || t.Nick == newPlayer.NickName || t.Email == newPlayer.Email).Result)
{
returnValue.IsSuccess = false;
returnValue.StatusCode = 456;
return(returnValue);
}
List <SqlParameter> parameters = new List <SqlParameter>();
StringBuilder hashPassword = new StringBuilder(_encrypter.Encrypted(newPlayer.Password));
string generateString = default;
string salt = _encrypter.Encrypted(generateString.GenerateRandomString(40));
hashPassword.Append(salt);
var playerHash = newPlayer.GetHashCode();
var loginParam = newPlayer.Login.ToSqlParameter("Login");
var passwordParam = hashPassword.ToString().ToSqlParameter("Password");
var nickNameParam = newPlayer.NickName.ToSqlParameter("NickName");
var emailParam = newPlayer.Email.ToSqlParameter("Email");
var saltHashParam = salt.ToSqlParameter("SaltHash");
var retValParam = true.ToSqlParameter("ReturnValue");
var playerHashParam = playerHash.ToString().ToSqlParameter("PlayerHash");
parameters.Add(loginParam);
parameters.Add(passwordParam);
parameters.Add(nickNameParam);
parameters.Add(emailParam);
parameters.Add(saltHashParam);
parameters.Add(retValParam);
parameters.Add(playerHashParam);
var dataSet = await _sqlManager.ExecuteDataCommand("[Common].[RegisterNewPlayer]", CommandType.StoredProcedure, null, parameters.ToArray());
var id = dataSet.Elements.First().Rows.First().Elements.First();
returnValue.NickName = newPlayer.NickName;
returnValue.PlayerId = (int)id;
//await _emailService.SendEmailToUser(newPlayer.Email,"",EmailType.Welcome, new EmailData(){NickName = returnValue.NickName, PlayerId = returnValue.PlayerId, PlayerHash = playerHash .ToString()});
// return error code
return(returnValue);
}
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)
{
throw new ConflictException("user already exists, please login");
}
// continue with our hashing
// generate salt randomly
var salt = CreateSalt();
var hashedPassword = HashPassword(registerRequestModel.Password, salt);
// save user Entity to database
// create a salt and add salt to the user entered password and create user object and
// save it to database
// make new user
var user = new User
{
FirstName = registerRequestModel.FirstName,
LastName = registerRequestModel.LastName,
Email = registerRequestModel.Email,
Salt = salt,
HashedPassword = hashedPassword,
//DateOfBirth = registerRequestModel.dateOfBirth
};
// add new user to database
var createdUser = await _userRepository.AddAsync(user);
//make response model to return back to view
var createdUserResponseModel = new UserRegisterResponseModel
{
Id = createdUser.Id,
Email = createdUser.Email,
FirstName = createdUser.FirstName,
LastName = createdUser.LastName
};
return(createdUserResponseModel);
}
public async Task <UserRegisterResponseModel> GetUserDetails(int id)
{
var user = await _userRepository.GetByIdAsync(id);
if (user == null)
{
throw new NotFoundException("User", id);
}
var response = new UserRegisterResponseModel
{
Id = user.Id, Email = user.Email, FirstName = user.FirstName, LastName = user.LastName
};
return(response);
}
public async Task <UserRegisterResponseModel> RegisterUser(UserRegisterRequestModel requestModel)
{
// Step 1 : Check whether this user already exists in the database
var dbUser = await _userRepository.GetUserByEmail(requestModel.Email);
if (dbUser != null)
{
// we already have this user(email) in our table
// return or throw an exception saying Conflict user
throw new Exception("User already registered, Please try to Login");
}
// Step 2: genereate a random unique salt.
var salt = _cryptoService.GenreateSalt();
// Step 3: never ever create your own hasing algorithm, always use industry tested/tried hashing algorithm
// hash password with salt
var hashedPassword = _cryptoService.HashPassword(requestModel.Password, salt);
// create User object so that we can save it to User Table
var user = new User
{
Email = requestModel.Email,
Salt = salt,
HashedPassword = hashedPassword,
FirstName = requestModel.FirstName,
LastName = requestModel.LastName
};
//setp 4: save it to database
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 <UserRegisterResponseModel> GetUserById(int id)
{
var user = await _userRepository.GetByIdAsync(id);
if (user == null)
{
return(null);
}
var cur = new UserRegisterResponseModel
{
Email = user.Email,
FirstName = user.FirstName,
LastName = user.LastName,
Id = user.Id
};
return(cur);
}
public async Task <UserRegisterResponseModel> GetUserDetails(int id)
{
var dbUser = await _userRepository.GetByIdAsync(id);
if (dbUser == null)
{
return(null);
}
var resp = new UserRegisterResponseModel()
{
Id = dbUser.Id,
Email = dbUser.Email,
FirstName = dbUser.FirstName,
LastName = dbUser.LastName,
};
return(resp);
}
public async Task <UserRegisterResponseModel> RegisterUser(UserRegisterRequestModel userRegisterRequestModel)
{
// first we need to check the email does not exists in our database
var dbUser = await _userRepository.GetUserByEmail(userRegisterRequestModel.Email);
if (dbUser != null)
{
// email exists in db
throw new Exception("User already exists, please try to login");
}
// generate a unique Salt
var salt = CreateSalt();
// hash the password with userRegisterRequestModel.Password + salt from above step
var hashedPassword = CreateHashedPassword(userRegisterRequestModel.Password, salt);
// call the user repository to save the user Info
var user = new User
{
FirstName = userRegisterRequestModel.FirstName,
LastName = userRegisterRequestModel.LastName,
Email = userRegisterRequestModel.Email,
DateOfBirth = userRegisterRequestModel.DateOfBirth,
Salt = salt,
HashedPassword = hashedPassword
};
var createdUser = await _userRepository.Add(user);
// convert the returned user entity to UserRegisterResponseModel
var response = new UserRegisterResponseModel
{
Id = createdUser.Id,
FirstName = createdUser.FirstName,
LastName = createdUser.LastName,
Email = createdUser.Email
};
return(response);
}
public async Task <UserRegisterResponseModel> GetUserDetailsByEmail(string email)
{
var user = await _userRepository.GetUserByEmail(email);
if (user == null)
{
throw new NotFoundException("User", email);
}
var result = new UserRegisterResponseModel
{
Id = user.Id,
Email = user.Email,
FirstName = user.FirstName,
LastName = user.LastName
};
return(result);
}
public async Task <UserRegisterResponseModel> RegisterUser(UserRegisterRequestModel registerRequest)
{
//first check if user registered
var dbuser = await _userRepository.GetUserByEmail(registerRequest.Email);
if (dbuser != null)
{
throw new ConflictException("User Already exists,please try to login");
}
//generate a unique salt
var salt = CreateSalt();
//hash the password with salt
var hashedPassword = CreateHashedPassword(registerRequest.Password, salt);
// then create User Object and save it to database with UserRepository
var user = new User()
{
FirstName = registerRequest.FirstName,
LastName = registerRequest.LastName,
Email = registerRequest.Email,
Salt = salt,
HashedPassword = hashedPassword,
DateOfBirth = registerRequest.DateTime,
};
// 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,
FirstName = createdUser.FirstName,
LastName = createdUser.LastName
};
return(createdUserResponse);
}
public async Task <UserRegisterResponseModel> CreateUser(UserRegisterRequestModel requestModel)
{
// 1. Call GetUserByEmail with requestModel.Email to check if the email exists in the User Table or not
// if user/email exists return Email already exists and throw an Conflict exception
// if email does not exists then we can proceed in creating the User record
// 1. var salt = Genreate a random salt
// 2. var hashedPassword = we take requestModel.Password and add Salt from above step and Hash them to generate Unique Hash
// 3. Save Email, Salt, hashedPassword along with other details that user sent like FirstName, LastName etc
// 4. return the UserRegisterResponseModel object with newly craeted Id for the User
var dbUser = await _userRepository.GetUserByEmail(requestModel.Email);
if (dbUser != null)
{
throw new Exception("Email alreadyy exists");
}
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 = requestModel.Email,
FirstName = requestModel.FirstName,
LastName = requestModel.LastName
};
return(response);
}
public async Task <UserRegisterResponseModel> GetUserById(int id)
{
var user = await _userRepository.GetByIdAsync(id);
if (user == null)
{
throw new
NotFoundException("User not found!");
}
var response = new UserRegisterResponseModel
{
Id = user.Id,
Email = user.Email,
Password = user.Password,
FullName = user.FullName,
};
return(response);
}
public async Task <UserRegisterResponseModel> RegisterUser(UserRegisterRequestModel requestModel)
{
/*
* 1. check if the user is already exists
* 2. create random salt
* 3. hash password with salt, using industry tested/tried hashing algorithm
* 4. Create user object
* 5. Store to database
* 6. Generate response
*/
var dbUser = await _userRepository.GetUserByEmailAsync(requestModel.Email);
if (dbUser != null)
{
// ToDo [refactor ]
// Throw an exception if user exists.
// throw new Exception("Email address already exists. Please try to login");
return(null);
}
var salt = _cryptoService.GenerateSalt();
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 <UserRegisterResponseModel> CreateUser(UserRegisterRequestModel requestModel)
{
//step1: check whether this user already exists in the db
var dbuser = await _userRepository.GetUserByEmail(requestModel.Email);
if (dbuser != null)
{
//we already have this user(email) in our db
throw new Exception("User already registered, Please try to login");
}
//step 2: create a random unique salt, always use industry hashing algorithm
var salt = _cryptoService.CreateSalt();
//step 3: We hash the password with the salt created by the above step
var hashedPassword = _cryptoService.HashPassword(requestModel.Password, salt);
//step 4: create user object so that we can save it to User Table
var user = new User
{
Email = requestModel.Email,
Salt = salt,
HashedPassword = hashedPassword,
FirstName = requestModel.FirstName,
LastName = requestModel.LastName
};
//Step 5 : Save it to db
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 <UserRegisterResponseModel> CreateUser(UserRegisterRequestModel requestModel)
{
//step1: create an user
//step2: add the created user to the userRepository
//step3: send the response back to the controller. (important)
//make sure email does not exist in the database
//we need to send email to our User repository and see if the data exists for the email
var dbUser = await _userRepository.GetUserByEmail(requestModel.Email);
//if the user exists and there's an email that matches it.
if (dbUser != null && string.Equals(dbUser.Email, requestModel.Email, StringComparison.CurrentCultureIgnoreCase))
{
throw new Exception("Email Already Exits");
}
//First step is to create a unique 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 async Task <UserRegisterResponseModel> CreateUser(UserRegisterRequestModel requestModel)
{
//1.call getuserbyemail to check if user has already existed
//if existed, return email already exists and throw an exception
//else proceed to create user
//1. generate random salt
//2. take requesModel.Password together with salt generate unique hashing
//3. save essential information except for the password it self(save salt also)
//4. return responseModel
var dbUser = await _userRepository.GetUserByEmail(requestModel.Email);
if (dbUser != null)
{
throw new Exception("Email has already existed.");
}
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 <UserRegisterResponseModel> RegisterUser(UserRegisterRequestModel registerRequestModel)
{
// 1. check whether email exists in db
var dbUser = await _userRepository.GetUserByEmail(registerRequestModel.Email); //wait from UI
// 2.1 if exists
if (dbUser != null)
{
throw new ConflictException("user already exists, please login");
}
// 2.2 new user, continue with hashing
// create a salt, add salt to the user entered password
var salt = CreateSalt();
var hashedPassword = HashPassword(registerRequestModel.Password, salt);
// create user object, save to db
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);
}
