public ActionResult PassRecovery(PassRecoveryViewModel model)
{
try
{
var user = _userManager.GetUserByEmail(model.Email);
if (user == null)
{
throw new Exception(Resource.EmailNotRegistered);
}
var rand = new Random();
var newPass = Convert.ToString(rand.Next(100000, 999999));
var salt = PasswordHashing.GenerateSaltValue();
var pass = PasswordHashing.HashPassword(newPass, salt);
user.passwordSalt = salt;
user.password = pass;
_userManager.Update(user);
_userManager.SendPassRecovery(user, newPass);
return(RedirectToRoute("EndPassRecovery"));
}
catch (Exception e)
{
model.Error = e.Message;
return(View(model));
}
}
public void PasswordIsHashedTest()
{
string input = "Password";
string output = PasswordHashing.HashPassword(input);
Assert.AreNotEqual(input, output);
}
public ActionResult LogIn(LoginViewModel model)
{
try
{
var user = _userManager.GetUserByEmail(model.EmailLogin);
if (user == null)
{
throw new Exception(Resource.EmailNotRegistered);
}
var passLogin = PasswordHashing.HashPassword(model.PasswordLogin, user.passwordSalt);
if (user.password != passLogin)
{
throw new Exception(Resource.WrongPassword);
}
if (!user.isActivated)
{
throw new Exception(Resource.NotActived);
}
FormsAuthentication.SetAuthCookie(user.email, false);
return(RedirectToAction("UserPage", "Profile", user.id));
}
catch (Exception e)
{
model.Error = e.Message;
return(View(model));
}
}
public IHttpActionResult PutUser(string username, User user)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var dbUser = db.User.SingleOrDefault(a => a.Username == username);
if (dbUser != null)
{
if (dbUser.Password != user.Password)
{
dbUser.Password = PasswordHashing.HashPassword(user.Password);
}
if (dbUser.OsuId != user.OsuId)
{
dbUser.OsuId = user.OsuId;
}
if (dbUser.Email != user.Email)
{
dbUser.Email = user.Email;
}
if (dbUser.Avatar != user.Avatar)
{
dbUser.Avatar = user.Avatar;
}
db.SaveChanges();
return(StatusCode(HttpStatusCode.NoContent));
}
return(NotFound());
}
public async Task <ActionResult <Guid> > POST([FromBody] RegisterTeamViewModel registerTeamViewModel)
{
// Generate a unique playerID
var player = new Player(registerTeamViewModel.TeamName);
var hashedPassword = _passwordHashing.HashPassword(registerTeamViewModel.Password);
await _database.SavePlayer(player, hashedPassword);
// Reload the player
var reloadedPlayer = await _database.LoadPlayer(player.ID);
if (reloadedPlayer == null)
{
var details = new ValidationProblemDetails {
Detail = $"No player with the ID {player.ID} exists"
};
return(ValidationProblem(details));
}
if (!_passwordHashing.CompareHashes(registerTeamViewModel.Password, reloadedPlayer.Password))
{
return(Forbid());
}
// Create them a game for them to develop against
if (!reloadedPlayer.CurrentGameID.HasValue)
{
await _gameCreator.CreateInitialGame(reloadedPlayer.ID);
}
return(reloadedPlayer.ID);
}
public ActionResult EditPassword(EditPasswordViewModel model, long id)
{
try
{
if (!ModelState.IsValid)
{
return(View(model));
}
var user = _userManager.GetById(id);
if (user.password != PasswordHashing.HashPassword
(model.Password, user.passwordSalt))
{
throw new Exception(Resource.WrongPassword);
}
var newSalt = PasswordHashing.GenerateSaltValue();
user.passwordSalt = newSalt;
user.password = PasswordHashing.HashPassword(model.NewPassword, newSalt);
_userManager.Update(user);
return(RedirectToRoute("UserPage"));
}
catch (Exception e)
{
model.Error = e.Message;
return(View(model));
}
}
public static UserEntity ToUserEntity(this UserCreateModel usercreateModel)
{
return(new UserEntity {
PartitionKey = Global.UserPartitionKey,
RowKey = usercreateModel.Id,
Id = usercreateModel.Id,
PasswordHash = PasswordHashing.HashPassword(usercreateModel.Password),
UserName = usercreateModel.UserName
});
}
public void GenerateHashFromPasswordAndSaltTest()
{
_employeeController = new EmployeeController();
Employee employee = _employeeController.GetEmployeeByUsername("TobiAs");
string salt = employee.Salt;
string password = "******";
string hashedPassword = PasswordHashing.HashPassword(salt + password);
string hashedPasswordFromDb = employee.Password;
Assert.AreEqual(hashedPassword, hashedPasswordFromDb);
}
private Account _ValidateLogin(string accountName, string passwordInput)
{
var account = new Account();
var thread = new Thread(() =>
{
account = Execution_ValidateLogin(accountName, PasswordHashing.HashPassword(passwordInput));
});
thread.Start();
thread.Join(); //By doing join it will wait for the method to finish
return(account);
}
public Task CreateAsync(IdentityUser user)
{
using (LogWrapper logger = new LogWrapper())
{
if (user == null)
{
logger.Error("Пользователь не может быть null.");
throw new ArgumentNullException(nameof(user), "Пользователь не может быть null.");
}
try
{
return(Task.Factory.StartNew(() =>
{
using (var connection = new SqlConnection(_connectionString))
{
connection.Open();
user.Id = Guid.NewGuid();
user.RegDate = DateTimeOffset.Now;
user.PasswordHash = PasswordHashing.HashPassword(user.PasswordHash);
connection.Execute("upCreate_new_user",
new
{
user.Id,
user.UserName,
user.PasswordHash,
user.Email,
user.EmailConfirmed,
user.FirstName,
user.SecondName,
user.RegDate,
user.City,
user.BirthDate,
user.SecurityStamp
},
commandType: CommandType.StoredProcedure);
}
}));
}
catch (Exception e)
{
logger.Error(e.Message);
return(null);
}
}
}
//Async method. Below will call upon a private corresponding method in another thread.
private void _Register(User inputUser, SpaceShip inputShip, string accountName, string password)
{
var dbHandler = new StarWarsContext {
ConnectionString = ConnectionString
};
var outputAccount = new Account
{
AccountName = accountName,
Password = PasswordHashing.HashPassword(password),
User = inputUser,
SpaceShip = inputShip
};
inputUser.Homeplanet = dbHandler.Homeworlds.FirstOrDefault(g => g.Name == inputUser.Homeplanet.Name) ??
inputUser.Homeplanet;
dbHandler.Accounts.Add(outputAccount);
dbHandler.SaveChanges();
}
public ActionResult Registration(RegisterViewModel model)
{
try
{
var entity = Mapper.Map <RegisterViewModel, User>(model);
var user = _userManager.GetUserByEmail(model.Email);
if (user != null)
{
throw new Exception("лваолв");
}
var salt = PasswordHashing.GenerateSaltValue();
var pass = PasswordHashing.HashPassword(entity.password, salt);
entity.passwordSalt = salt;
entity.password = pass;
entity.photo = "/images/Account/account.jpg";
_userManager.Add(entity);
entity.roles = new List <UserInRoles>()
{
new UserInRoles()
{
id_roles = 2, id_user = entity.id
}
};
_userManager.Update(entity);
var url = Url.Action("ConfirmEmail", "Account", new { token = entity.id, email = entity.email },
Request.Url.Scheme);
_userManager.SentConfirmMail(entity, url);
return(RedirectToRoute("AfterRegistration"));
}
catch (Exception e)
{
model.Error = e.Message;
return(View(model));
}
}
public async Task <IHttpActionResult> PostUser(User user)
{
string json;
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var dbUser = db.User.Where(a => a.Username.Equals(user.Username) || a.Email.Equals(user.Email)).FirstOrDefault();
if (dbUser == null)
{
user.Password = PasswordHashing.HashPassword(user.Password);
db.User.Add(user);
await db.SaveChangesAsync();
json = JsonConvert.SerializeObject(new { userExists = true });
return(Ok(json));
}
json = JsonConvert.SerializeObject(new { userExists = false });
return(Ok(json));
}
public string HashPassword(string password)
{
return(PasswordHashing.HashPassword(password));
}
public static void Initialize(diaryContext context)
{
if (context.Users.Any())
{
return;
}
var passwordhash = new PasswordHashing();
var users = new User[]
{
new User
{
Id = "1",
FirstName = "Khoa",
LastName = "Nguyen Anh",
Email = "*****@*****.**",
Brithday = DateTime.Parse("1/1/1998"),
UserName = "******",
NormalizedUserName = "******",
PasswordHash = passwordhash.HashPassword(null, "12345678"),
SecurityStamp = "randomestring"
},
new User
{
Id = "2",
FirstName = "Khoi",
LastName = "Tran Dang",
Email = "*****@*****.**",
Brithday = DateTime.Parse("2/2/1998"),
UserName = "******",
NormalizedUserName = "******",
PasswordHash = passwordhash.HashPassword(null, "12345678"),
SecurityStamp = "randomestring"
},
new User
{
Id = "3",
FirstName = "Duy",
LastName = "Ung Van",
Email = "*****@*****.**",
Brithday = DateTime.Parse("3/3/1998"),
UserName = "******",
NormalizedUserName = "******",
PasswordHash = passwordhash.HashPassword(null, "12345678"),
SecurityStamp = "randomestring"
},
new User
{
Id = "4",
FirstName = "Chi",
LastName = "Le Vinh",
Email = "*****@*****.**",
Brithday = DateTime.Parse("4/4/1998"),
UserName = "******",
NormalizedUserName = "******",
PasswordHash = passwordhash.HashPassword(null, "12345678"),
SecurityStamp = "randomestring"
}
};
var events = new Event[]
{
new Event
{
ID = 1,
User = users[0],
Info = "Birthday",
StartDate = DateTime.Parse("1/1/2017"),
EndDate = DateTime.Parse("2/1/2017"),
Occurrence = Occurrency.once_a_year
},
new Event
{
ID = 2,
User = users[1],
Info = "Birthday",
StartDate = DateTime.Parse("2/2/2017"),
EndDate = DateTime.Parse("3/2/2017"),
Occurrence = Occurrency.once_a_year
},
new Event
{
ID = 3,
User = users[2],
Info = "Birthday",
StartDate = DateTime.Parse("3/3/2017"),
EndDate = DateTime.Parse("4/3/2017"),
Occurrence = Occurrency.once_a_year
},
new Event
{
ID = 4,
User = users[3],
Info = "Birthday",
StartDate = DateTime.Parse("4/4/2017"),
EndDate = DateTime.Parse("5/4/2017"),
Occurrence = Occurrency.once_a_year
}
};
var entries = new Entry[]
{
new Entry
{
ID = 1,
User = users[0],
Title = "Cong tac xa hoi",
Content = "Di cong tac xa hoi",
Date = DateTime.Parse("11/11/2017"),
Mood = Mood.happy
},
new Entry
{
ID = 2,
User = users[1],
Title = "OOP",
Content = "Hoc oop",
Date = DateTime.Parse("11/11/2017"),
Mood = Mood.normal
},
new Entry
{
ID = 3,
User = users[2],
Title = "Late night",
Content = "On fackbook khuya",
Date = DateTime.Parse("11/11/2017"),
Mood = Mood.normal
},
new Entry
{
ID = 4,
User = users[3],
Title = "????",
Content = "Mat tieu",
Date = DateTime.Parse("11/11/2017"),
Mood = Mood.normal
}
};
/*
* foreach (User u in users)
* {
* u.Entries = new Collection<Entry>();
* u.Events = new Collection<Event>();
* }
*
* for (int i = 0; i < users.Length; ++i)
* {
* users[i].Entries.Add(entries[i]);
* users[i].Events.Add(events[i]);
* }
*/
// add user to database
foreach (User u in users)
{
context.Add(u);
}
context.SaveChanges();
foreach (Event e in events)
{
context.Add(e);
}
context.SaveChanges();
foreach (Entry e in entries)
{
context.Add(e);
}
context.SaveChanges();
}