public bool IsRegisterModelValid(RegisterUserBindingModel model) { if (!model.Email.Contains('@') || !model.Email.Contains('.')) { return(false); } if (model.Password.Length < 6 || !model.Password.Any(char.IsUpper) || !model.Password.Any(char.IsLower) || !model.Password.Any(char.IsDigit)) { return(false); } if (model.Password != model.ConfirmPassword) { return(false); } if (string.IsNullOrEmpty(model.FullName)) { return(false); } return(true); }
public IActionResult Register(RegisterUserBindingModel model) { if (!this.IsValidModel(model)) { this.Model["message"] = this.GetErrors(); return(this.View()); } using (var db = new KittenWebDbContext()) { string passwordHash = PasswordUtilities.GetPasswordHash(model.Password); User user = new User() { Username = model.Username, PasswordHash = passwordHash, Email = model.Email }; db.Users.Add(user); db.SaveChanges(); this.Model["message"] = "<p>Successful registration!</p>"; } return(this.View()); }
public async Task <ActionResult> Login(RegisterUserBindingModel userModel) { var userFromDb = this.context.Users .SingleOrDefault(u => u.Username == userModel.Username && u.Password == userModel.Password); if (userFromDb == null) { return(this.BadRequest("Username or password is invalid!")); } var tokenHandler = new JwtSecurityTokenHandler(); var key = Encoding.ASCII.GetBytes(this.jwtSettings.Value.Secret); var tokenDescriptor = new SecurityTokenDescriptor { Subject = new ClaimsIdentity(new Claim[] { new Claim(ClaimTypes.NameIdentifier, userFromDb.Username) }), Expires = DateTime.UtcNow.AddDays(7), SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature) }; var token = tokenHandler.CreateToken(tokenDescriptor); return(this.Ok(token)); }
public IActionResult Register(RegisterUserBindingModel model) { if (!this.IsValidModel(model)) { this.Model["message"] = "Invalid data in the fields!"; return(this.View()); } string username = model.Username; string passHash = PasswordUtilities.GetHash(model.Password); User user = new User(username, passHash); using (var db = new SimpleMVCDbContext()) { if (!db.Users.Select(u => u.Username).Contains(username)) { db.Users.Add(user); db.SaveChanges(); return(this.Login("Successful registration!")); } this.Model["message"] = "Username is allready taken!"; } return(this.View()); }
public bool IsRegisterViewModelValid(RegisterUserBindingModel bind) { if (!bind.Email.Contains("@") || !bind.Email.Contains(".")) { return(false); } if (this.Context.Users.Any(u => u.Email == bind.Email)) { return(false); } Regex regexForPass = new Regex(@"(?=.*\d)(?=.*[a-z])(?=.*[A-Z]).{6,}"); if (bind.Password.Length < 6 || !regexForPass.IsMatch(bind.Password)) { return(false); } if (bind.Password != bind.ConfirmPassword) { return(false); } if (string.IsNullOrEmpty(bind.FullName)) { return(false); } return(true); }
public IActionResult Register(RegisterUserBindingModel model) { if (this.User.IsAuthenticated) { return(RedirectToHome()); } // Validator checks for password and confirm-password match itself if (!this.IsValidModel(model)) { SetValidatorErrors(); return(this.View()); } //if (model.Password != model.ConfirmPassword) //{ // ShowError(ConfirmPasswordError); // return View(); //} var userId = this.users.Create(model.Username, model.Password, model.Email); if (userId == null) { ShowError(Constants.UnsuccessfullRegistrationMessage); return(View()); } SignIn(model.Username, userId.Value); return(RedirectToHome()); }
public async Task <IHttpActionResult> RegisterUser(RegisterUserBindingModel model) { if (!ModelState.IsValid) { return(this.BadRequest(this.ModelState)); } var user = new ApplicationUser { UserName = model.Username, Name = model.Name, Email = model.Email, PhoneNumber = model.Phone, TownId = model.TownId }; IdentityResult result = await this.UserManager.CreateAsync(user, model.Password); if (!result.Succeeded) { return(this.GetErrorResult(result)); } return(this.Ok( new { message = "User " + model.Username + " registered successfully.", userId = user.Id } )); }
public AccountCredentialsViewModel CreateNewUserAccount(RegisterUserBindingModel bm) { try { var passwordHashAndSalt = this.GenerateSaltedHash(bm.Password); // Returns byte[][] array of 2 elements(hashed password and salt) User newUser = new User(); newUser.Name = bm.Name; newUser.Email = bm.Email; newUser.PasswordHash = Convert.ToBase64String(passwordHashAndSalt[0]); newUser.Salt = Convert.ToBase64String(passwordHashAndSalt[1]); this.Context.Users.Add(newUser); this.Context.SaveChanges(); } catch (Exception) { return(null); } // After user has been created login the user (return token) LoginUserBindingModel loginBm = new LoginUserBindingModel() { Email = bm.Email, Password = bm.Password }; var tokenBearer = LoginUser(loginBm); return(tokenBearer); }
public IActionResult Register( [FromBody] RegisterUserBindingModel model ) { // get the user to verifty var userToVerify = _userManager.FindByNameAsync(model.UserName); if (userToVerify.Result != null) { throw new Exception(AlreadyexistUser); } App.DataAccess.Identity.AspNetUsers user = new App.DataAccess.Identity.AspNetUsers { FirstName = "Ali", UserName = "******" }; //// App.DataAccess.Identity.AspNetUsers userIdentity = _mapper.Map<App.DataAccess.Identity.AspNetUsers>(model); IdentityResult result = _userManager.CreateAsync(user, model.Password).Result; if (result.Succeeded == false) { throw new Exception(AlreadyexistUserName); } var rModel = new SuccessViewModel { Detail = RegisterSuccessDetail }; return(Success(rModel)); }
public void CreateNewUserAccount_CalledWithCorrectInputData_ShouldReturnTrueAndUserCreated() { // Arrange var createdUser = new User(); var db = this.GetDatabase(); var service = new AccountService(db); RegisterUserBindingModel bm = new RegisterUserBindingModel() { Name = "Gosho", Email = "*****@*****.**", Password = "******", ConfirmPassword = "******" }; // Act var tokenResponse = service.CreateNewUserAccount(bm); if (tokenResponse != null) { // Check if user is created. createdUser = db.Users.Single(); } // Assert Assert.NotNull(createdUser); var userId = tokenResponse.UserId; Assert.IsType <Guid>(userId); Assert.NotEqual(0, userId.ToString().Length); }
public IActionResult Register(RegisterUserBindingModel bindingModel) { UserRole role = new UserRole(); if (!context.Users.Any()) { role = context.UserRoles.FirstOrDefault(r => r.Name == "Admin"); } else { role = context.UserRoles.FirstOrDefault(r => r.Name == "User"); } User user = new User() { Username = bindingModel.username, Password = bindingModel.password, Email = bindingModel.email, IsValid = true, Role = role, }; context.Users.Add(user); context.SaveChanges(); Login(new LoginUserBindingModel() { username = user.Username, password = user.Password }); return RedirectToAction("/"); }
public IActionResult Register(RegisterUserBindingModel model) { if (this.User.IsAuthenticated) { return(RedirectToHome()); } // Validator checks for password and confirm-password match itself if (!this.IsValidModel(model)) { SetValidatorErrors(); return(this.View()); } var user = this.users.Create(model.Username, model.Password, model.FullName, model.Email); if (user == null) { ShowError(Constants.UnsuccessfullRegistrationMessage); return(View()); } this.SignIn(model.Username, user.Id, new List <string>() { user.RoleName }); return(RedirectToHome()); }
public static bool IsValid(RegisterUserBindingModel user) { if (string.IsNullOrEmpty(user.FullName)) { return(false); } if (!user.Email.Contains("@")) { return(false); } var containsUppercase = user.Password.Any(char.IsUpper); var containsLowercase = user.Password.Any(char.IsLower); var containsDigit = user.Password.Any(char.IsDigit); if (!containsUppercase || !containsLowercase || !containsDigit) { return(false); } if (user.Password != user.ConfirmPassword) { return(false); } return(true); }
public IActionResult Register(RegisterUserBindingModel model, HttpResponse response) { // var registerModel = this.service.Register(model); this.Redirect(response, "/home/login"); return(this.View()); }
public async Task <IActionResult> Register(RegisterUserBindingModel model) { if (this.ModelState.IsValid) { var user = new User { UserName = model.Username, Email = model.Email, FirstName = model.FirstName, LastName = model.LastName, UniqueCitizenNumber = model.UCN }; IdentityResult result = await this.signInManager .UserManager .CreateAsync(user, model.Password); if (result.Succeeded) { await this.signInManager.UserManager.AddToRoleAsync(user, "USER"); await this.signInManager.SignInAsync(user, false); return(this.RedirectToAction("Index", "Home")); } } return(this.View()); }
public void RegisterUser(RegisterUserBindingModel bind) { User model = Mapper.Map <RegisterUserBindingModel, User>(bind); this.Context.Users.Add(model); this.Context.SaveChanges(); }
public async Task <HttpResponseMessage> RegisterUser(RegisterUserBindingModel model) { if (!ModelState.IsValid) { return(await this.BadRequest(this.ModelState).ExecuteAsync(new CancellationToken())); } var user = new ApplicationUser { UserName = model.Username, Name = model.Name, Email = model.Email, PhoneNumber = model.Phone, TownId = model.TownId }; IdentityResult result = await this.UserManager.CreateAsync(user, model.Password); if (!result.Succeeded) { return(await this.GetErrorResult(result).ExecuteAsync(new CancellationToken())); } // Auto login after register (successful user registration should return access_token) var loginResult = this.LoginUser(new LoginUserBindingModel() { Username = model.Username, Password = model.Password }); return(await loginResult); }
public async Task <IHttpActionResult> Register(RegisterUserBindingModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var user = new User() { UserName = model.Username, Email = model.Email }; IdentityResult result = await UserManager.CreateAsync(user, model.Password); if (!result.Succeeded) { return(GetErrorResult(result)); } var rolesForUser = new[] { "User" }; var resultOfAddingToRoles = await SafelyAddUserToRole(rolesForUser, user.Id); if (resultOfAddingToRoles == false) { return(InternalServerError(new Exception("Adding user to role failed."))); } return(Ok(user.Id)); }
public bool IsRegisterModelValid(RegisterUserBindingModel model) { if (model.Username.Length < 5 || model.Username.Length > 30) { return(false); } if (model.Fullname.Length < 5) { return(false); } //Regex regex = new Regex(@"^[!@#$%^&*,.]$"); //if (!regex.IsMatch(model.Password)) //{ // return false; //} if (model.Password.Length < 8 || !model.Password.Any(char.IsUpper) || !model.Password.Any(char.IsDigit)) { return(false); } if (model.Password != model.ConfirmPassword) { return(false); } return(true); }
public IActionResult Register(RegisterUserBindingModel model) { if (!this.IsValidModel(model) || model.Password != model.ConfirmPassword) { this.ViewData["error"] = "Invalid credentials"; return(this.View()); } using (this.Context) { if (this.Context.Users.Any(u => u.Username == model.Username)) { this.ViewData["error"] = "User already exist"; return(this.View()); } if (!this.Context.Users.Any()) { this.roleId = 1; } var user = new User() { Username = model.Username, Email = model.Email, FullName = model.FullName, PasswordHash = PasswordUtilities.GetPasswordHash(model.Password), RoleId = this.roleId }; this.Context.Add(user); this.Context.SaveChanges(); } return(this.RedirectToAction("/")); }
public IActionResult Register(RegisterUserBindingModel model) { if (!this.IsValidModel(model)) { this.Model.Data[ErrorKey] = ShowMessageValue; this.Model.Data[ErrorMessageKey] = RegisterErrorMessage; return(View()); } string hashedPassword = PasswordUtilities.GenerateHash(model.Password); User userToAdd = new User() { Email = model.Email, Password = hashedPassword, Username = model.Username }; using (this.Context) { var users = this.Context.Users.ToList(); if (users.Any(x => x.Email == userToAdd.Email || x.Username == userToAdd.Username)) { this.Model.Data[ErrorKey] = ShowMessageValue; this.Model.Data[ErrorMessageKey] = RegisterErrorMessage; return(View()); } this.Context.Users.Add(userToAdd); this.Context.SaveChanges(); } this.SignIn(userToAdd.Username); return(this.RedirectToHome()); }
public async Task <IHttpActionResult> RegisterUser(RegisterUserBindingModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var user = new ApplicationUser { FirstName = model.FirstName, LastName = model.LastName, UserName = model.Email, Email = model.Email, Organization = model.Organization }; var userExist = await UserManager.FindByEmailAsync(user.Email); if (userExist == null) { IdentityResult result = await UserManager.CreateAsync(user, model.Password); UserManager.AddToRole(user.Id, "admin"); if (!result.Succeeded) { return(GetErrorResult(result)); } } else { return(BadRequest("Email Already Exist!")); } return(Ok()); }
public IActionResult RegisterAndLogin([FromBody] RegisterUserBindingModel bm) { if (!ModelState.IsValid) { logger.LogError("invalid model state on registrations"); return(BadRequest(ModelState)); } if (bm.Password != bm.ConfirmPassword) { logger.LogError("incorrect password and confirm password on registrations"); return(BadRequest("Invalid credentials!")); } var userAlreadyExist = this.service.CheckIfUserExist(bm); if (userAlreadyExist) { logger.LogError($"registration fail the user already exist"); return(BadRequest("User with this email already exist!")); } var userCredentials = this.service.CreateNewUserAccount(bm); // User created, will return token(loged-in automaticaly) if (userCredentials == null) { logger.LogError("Error on registration token has been not returned"); return(new BadRequestResult()); } logger.LogSuccess("User has been registered!"); // created! return(Ok(userCredentials)); }
public bool IsValidUserToRegister(RegisterUserBindingModel model) { if (!model.Email.Contains(".") || !model.Email.Contains("@")) { return(false); } if (uow.Users.Any(u => u.Email == model.Email)) { return(false); } if (!model.Password.Any(char.IsUpper) || !model.Password.Any(char.IsLower) || !model.Password.Any(char.IsDigit)) { return(false); } if (model.Password.Length < 6) { return(false); } if (model.Password != model.ConfirmPassword) { return(false); } if (string.IsNullOrEmpty(model.FullName)) { return(false); } return(true); }
public bool IsRegisterModelValid(RegisterUserBindingModel rubm) { if (!Regex.IsMatch(rubm.Email, @"[a-zA-Z]+@[a-z]+.[a-z]+")) { return(false); } if (!Regex.IsMatch(rubm.Password, @"(?=.*\d)(?=.*[a-z])(?=.*[A-Z]).{6,}")) { return(false); } if (!Regex.IsMatch(rubm.FullName, @"^[a-zA-Z -.]+$")) { return(false); } if (rubm.Password != rubm.ConfirmPassword) { return(false); } if (this.Context.Users.Any(user => user.Email == rubm.Email)) { return(false); } return(!string.IsNullOrEmpty(rubm.FullName)); }
public bool CheckIfRegisterModelIsValid(RegisterUserBindingModel model) { if (this.IsValidUsername(model.Username) && this.IsValidFullname(model.FullName) && this.IsValidPassword(model.Password) && this.DoPasswordMatch(model.Password, model.ConfirmPassword)) { bool isAnyone = this.IsAnyoneRegistered(); var user = new User(); if (!isAnyone) { user.Username = model.Username; user.FullName = model.FullName; user.Password = model.Password; user.RoleId = (int)UserRoleTypes.Administrator; this.data.User.Add(user); } if (isAnyone) { user.Username = model.Username; user.FullName = model.FullName; user.Password = model.Password; user.RoleId = (int)UserRoleTypes.Regular; this.data.User.Add(user); } this.data.SaveChanges(); return(true); } else { throw new Exception("Not a valid binding model"); } }
public IActionResult Register(RegisterUserBindingModel model) { // Validate model if (!this.IsValidModel(model)) { return(View()); } // Add user to db using (var context = new NotesDbContext()) { var user = new User { Username = model.Username, Password = model.Password }; context.Users.Add(user); context.SaveChanges(); } // SignIn user this.SignIn(model.Username); return(Redirect(HomePath)); }
public void RegisterUser(RegisterUserBindingModel bind) { var user1 = this.Context.Users.Where(u => u.Username == "pesho").Select(u => u.Email); //User user = Mapper.Map<RegisterUserBindingModel, User>(bind); //this.Context.Users.Add(user); //this.Context.SaveChanges(); }
public IActionResult Register(RegisterUserBindingModel model) { if (!this.IsValidModel(model)) { this.Model.Data[ErrorKey] = InvalidRegisterDetails; return(this.View()); } using (this.Context) { bool userExists = CheckForExistingUser(model); if (userExists) { return(this.View()); } string passwordHash = PasswordUtilities.GenerateHash(model.Password); User user = new User() { Username = model.Username, Email = model.Email, Password = passwordHash, }; this.Context.Users.Add(user); this.Context.SaveChanges(); this.SignIn(user.Username); return(RedirectToHome()); } }
public string RegisterUser(RegisterUserBindingModel userModel) { if (this.users.All().Any(u => u.Email == userModel.Email)) { return("/store/login"); } if (!RegisterUserValidator.IsValid(userModel)) { return("/store/register"); } var newUser = new User() { FullName = userModel.FullName, Email = userModel.Email, Password = userModel.Password }; if (!this.users.All().Any()) { newUser.IsAdministrator = true; } this.users.Add(newUser); this.users.SaveChanges(); return("/store/login"); }
public async Task<IHttpActionResult> RegisterUser(RegisterUserBindingModel model) { if (this.User.Identity.GetUserId() != null) { return this.BadRequest(UserAlreadyLoggedInMessage); } if (model == null) { return this.BadRequest(InvalidUserDataMessage); } if (!this.ModelState.IsValid) { return this.BadRequest(this.ModelState); } var emailExists = this.Data.Users.GetAll().Any(u => u.Email == model.Email); if (emailExists) { return this.BadRequest(EmailAlreadyTakenMessage); } var usernameExists = this.Data.Users.GetAll().Any(u => u.UserName == model.Username); if (usernameExists) { return this.BadRequest(UsernameAlreadyTakenMessage); } var user = new User { UserName = model.Username, Email = model.Email }; var identityResult = await this.UserManager.CreateAsync(user, model.Password); if (!identityResult.Succeeded) { return this.GetErrorResult(identityResult); } this.Data.SaveChanges(); var loginResult = await this.LoginUser(new LoginUserBindingModel { Username = model.Username, Password = model.Password }); return loginResult; }
public async Task<IHttpActionResult> RegisterUser(RegisterUserBindingModel bindingModel) { if (this.UserIdProvider.GetUserId() != null) { return this.BadRequest("User is already logged in."); } if (bindingModel == null) { return this.BadRequest("Invalid user data"); } if (!this.ModelState.IsValid) { return this.BadRequest(this.ModelState); } var existingEmail = this.Data .Users .All() .FirstOrDefault(u => u.Email == bindingModel.Email); if (existingEmail != null) { return this.BadRequest("A user with the same email already exists."); } var newUser = new ApplicationUser { UserName = bindingModel.Username, Name = bindingModel.Name, Email = bindingModel.Email, Age = bindingModel.Age, Gender = bindingModel.Gender }; var identityResult = await this.UserManager.CreateAsync(newUser, bindingModel.Password); if (!identityResult.Succeeded) { return this.GetErrorResult(identityResult); } var loginResult = await this.LoginUser(new LoginUserBindingModel { Username = bindingModel.Username, Password = bindingModel.Password }); return loginResult; }
public async Task<IHttpActionResult> RegisterUser(RegisterUserBindingModel model) { if (this.User.Identity.GetUserId() != null) { return this.BadRequest("User is already logged in."); } if (model == null) { return this.BadRequest("Invalid user data"); } if (!ModelState.IsValid) { return this.BadRequest(this.ModelState); } if (this.Data.Users.GetAll().Any(u => u.Email == model.Email)) { return this.BadRequest("That email is already used by another user"); } var user = new ApplicationUser { UserName = model.Username, Email = model.Email, PhoneNumber = model.Phone }; var identityResult = await this.UserManager.CreateAsync(user, model.Password); if (!identityResult.Succeeded) { return this.GetErrorResult(identityResult); } // Auto login after registration (successful user registration should return access_token) var loginResult = await this.LoginUser(new LoginUserBindingModel() { Username = model.Username, Password = model.Password }); return loginResult; }