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()); }