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