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 Login(LoginUserBindingModel model)
{
this.SetupLayoutHtml();
if (!IsValidModel(model))
{
this.Model["message"] = "Invalid data in the fields!";
}
using (var db = new FDMCDbContext())
{
string passwordHash = PasswordUtilities.GetHash(model.Password);
bool userIsValid = db.Users.Any(u => u.Username == model.Username && u.Password == passwordHash);
if (!userIsValid)
{
this.Model["message"] = "Invalid username or password!";
return(View());
}
this.SignIn(model.Username);
return(new RedirectResult("/home/wellcome"));
}
}
public User GetUserFromLoginBind(LoginUserBindingModel lubm)
{
return(this.Context.Users.FirstOrDefault(
user =>
(user.Username == lubm.Credential || user.Email == lubm.Credential) &&
user.Password == lubm.Password));
}
public IActionResult Login(LoginUserBindingModel model, HttpSession session, HttpResponse response)
{
string username = model.Username;
string password = model.Password;
string sessionId = session.Id;
using (NotesAppContext context = new NotesAppContext())
{
User user = context.Users.FirstOrDefault(u => u.Username == username && u.Password == password);
if (user != null)
{
Login login = new Login()
{
User = user,
SessionId = sessionId,
IsActive = true
};
context.Logins.Add(login);
context.SaveChanges();
Redirect(response, "/home/index");
return(null);
}
}
return(View());
}
public IHttpActionResult LoginUser(LoginUserBindingModel model)
{
try
{
if (!ModelState.IsValid)
{
return(Conflict());
}
var currentUser = _userService.GetUserInfo(model.Email);
var passwordRegForm = model.Password;
var isPasswordEqual = Hashing.VerifyPassword(passwordRegForm, currentUser.Password);
if (isPasswordEqual)
{
return(Ok(currentUser));
}
else
{
return(Unauthorized());
}
}
catch (Exception)
{
return(Unauthorized());
}
}
public IActionResult Login(LoginUserBindingModel bindingModel)
{
var user = this.context
.Users
.Select(u => new
{
Username = u.Username,
Password = u.Password,
Email = u.Email,
Role = context.UserRoles.FirstOrDefault(r => r.Id == u.RoleId)
})
.FirstOrDefault(u => u.Username == bindingModel.username && u.Password == bindingModel.password);
if (user != null)
{
this.SignIn(new IdentityUser()
{
Username = user.Username,
Password = user.Password,
Email = user.Email,
Roles = new List<string>() {user.Role.Name}
});
}
else
{
RedirectToAction("/users/register");
}
return RedirectToAction("/");
}
public async Task <HttpResponseMessage> LoginUser(LoginUserBindingModel model)
{
// Invoke the "token" OWIN service to perform the login: /api/token
// Ugly hack: I use a server-side HTTP POST because I cannot directly invoke the service (it is deeply hidden in the OAuthAuthorizationServerHandler class)
var request = HttpContext.Current.Request;
var tokenServiceUrl = request.Url.GetLeftPart(UriPartial.Authority) + request.ApplicationPath + "/Token";
using (var client = new HttpClient())
{
var requestParams = new List <KeyValuePair <string, string> >
{
new KeyValuePair <string, string>("grant_type", "password"),
new KeyValuePair <string, string>("username", model.Username),
new KeyValuePair <string, string>("password", model.Password)
};
var requestParamsFormUrlEncoded = new FormUrlEncodedContent(requestParams);
var tokenServiceResponse = await client.PostAsync(tokenServiceUrl, requestParamsFormUrlEncoded);
var responseString = await tokenServiceResponse.Content.ReadAsStringAsync();
var responseCode = tokenServiceResponse.StatusCode;
var responseMsg = new HttpResponseMessage(responseCode)
{
Content = new StringContent(responseString, Encoding.UTF8, "application/json")
};
return(responseMsg);
}
}
public IActionResult Login(LoginUserBindingModel model)
{
if (this.User.IsAuthenticated)
{
return(this.RedirectToHome());
}
if (!this.IsValidModel(model))
{
this.ShowError("All fields required.");
return(this.View());
}
var username = model.Username;
var password = PasswordUtilities.GetPasswordHash(model.Password);
var user = this.Context
.Users
.FirstOrDefault(u => u.Username == username && u.Password == password);
if (user == null)
{
this.ShowError("Username or password invalid!");
return(this.View());
}
var roles = this.Context
.Roles
.Where(r => r.UserId == user.Id)
.Select(r => r.Name);
this.SignIn(user.Username, user.Id, roles);
return(this.RedirectToHome());
}
public bool IsLoginModelValid(LoginUserBindingModel lubm)
{
return(this.Context.Users.Any(
user =>
(user.Username == lubm.Credential || user.Email == lubm.Credential) &&
user.Password == lubm.Password));
}
public IActionResult Login(LoginUserBindingModel loginUserBindingModel)
{
if (loginUserBindingModel.Username == "" || loginUserBindingModel.Password == "")
{
this.Model["message"] = "Empty input fields !";
return(View());
}
using (var context = new NotesDbContext())
{
var foundUser = context
.Users
.FirstOrDefault(u => u.Username == loginUserBindingModel.Username &&
u.Password == PasswordUtilities.GenerateHash256(loginUserBindingModel.Password));
if (foundUser == null)
{
this.Model["message"] = "Invalid Username or password !";
return(View());
}
context.SaveChanges();
this.SignIn(foundUser.Username);
}
return(RedirectToAction("/home/index"));
}
public IActionResult Login(LoginUserBindingModel model)
{
if (!this.IsValidModel(model))
{
this.Model.Data[ErrorKey] = ShowMessageValue;
this.Model.Data[ErrorMessageKey] = InvalidCredentialsMessage;
return(View());
}
string hashedPass = PasswordUtilities.GenerateHash(model.Password);
using (this.Context)
{
var user = this.Context.Users.FirstOrDefault(x => x.Username == model.Username && x.Password == hashedPass);
if (user == null)
{
this.Model.Data[ErrorKey] = ShowMessageValue;
this.Model.Data[ErrorMessageKey] = InvalidCredentialsMessage;
return(this.View());
}
else
{
this.SignIn(user.Username);
return(RedirectToHome());
}
}
}
public IActionResult Login(LoginUserBindingModel loginUserBindingModel)
{
if (loginUserBindingModel.Username == "" || loginUserBindingModel.Password == "")
{
this.Model["error"] = "<h1 class=\"message\">Empty input fields !</h1>";
return(View());
}
var foundUser = this.Context
.Users
.FirstOrDefault(u => u.Username == loginUserBindingModel.Username &&
u.Password == PasswordUtilities.GenerateHash256(loginUserBindingModel.Password));
if (foundUser == null)
{
this.Model["error"] = "<h1 class=\"message\">Invalid Username or password !</h1>";
return(View());
}
this.SignIn(foundUser.Username);
this.User = new Authentication(foundUser.Username);
Context.SaveChanges();
return(RedirectToAction("/home/index"));
}
public User GetCorrespondingUser(LoginUserBindingModel model)
{
var user = Data.Data.Context.Users
.FirstOrDefault(x => x.Username == model.Username &&
x.Password == model.Password);
return(user);
}
public bool IsLoginModelValid(LoginUserBindingModel bind)
{
if (!this.Context.Users.Any(u => (u.Email == bind.Email) && u.Password == bind.Password))
{
return(false);
}
return(true);
}
public User GetCorrespondingUser(LoginUserBindingModel lubm)
{
var user = Data.Data.Context.Users.FirstOrDefault(
user1 => user1.Username == lubm.Username &&
user1.Password == lubm.Password);
return(user);
}
public User GetCorrespondingLoginUser(LoginUserBindingModel lubm)
{
var user = this.Context.Users.FirstOrDefault(
u => u.Username == lubm.Username &&
u.Password == lubm.Password);
return(user);
}
public IActionResult Login(LoginUserBindingModel model, HttpSession session, HttpResponse response)
{
if (this.service.IsUserValid(model))
{
this.service.LoginUser(model, session);
this.Redirect(response, "/categories/all");
}
return(null);
}
public IActionResult Login(HttpSession session, HttpResponse response, LoginUserBindingModel lubm)
{
if (this.service.LoginUser(session, lubm))
{
this.Redirect(response, "/home/index");
return(null);
}
return(this.View());
}
public bool IsUserValid(LoginUserBindingModel model)
{
if (this.Context.Users.Any(u => (u.Username == model.UsernameOrEmail ||
u.Email == model.UsernameOrEmail) && u.Password == model.Password))
{
return(true);
}
return(false);
}
public IActionResult Login(LoginUserBindingModel lubm, HttpSession session, HttpResponse response)
{
if (this.usersService.LoginUser(lubm, session.Id))
{
Redirect(response, "/home/index");
return(null);
}
return(this.View());
}
public IActionResult Login(HttpResponse response, HttpSession session, LoginUserBindingModel bindingModel)
{
service.LoginUser(session, bindingModel);
if (!this.signInManager.IsAuthenticated(session))
{
return(this.View());
}
Redirect(response, "/games/all");
return(null);
}
public async Task <HttpResponseMessage> LoginUser(LoginUserBindingModel model)
{
// Invoke the "token" OWIN service to perform the login: /api/token
// Ugly hack: I use a server-side HTTP POST because I cannot directly invoke the service (it is deeply hidden in the OAuthAuthorizationServerHandler class)
var request = HttpContext.Current.Request;
//To use locally
//var tokenServiceUrl = "http://127.0.0.1:61902/Token";
var tokenServiceUrl = request.Url.GetLeftPart(UriPartial.Authority) + request.ApplicationPath + "/Token";
using (var client = new HttpClient())
{
var requestParams = new List <KeyValuePair <string, string> >
{
new KeyValuePair <string, string>("grant_type", "password"),
new KeyValuePair <string, string>("username", model.Username),
new KeyValuePair <string, string>("password", model.Password)
};
var requestParamsFormUrlEncoded = new FormUrlEncodedContent(requestParams);
var tokenServiceResponse = await client.PostAsync(tokenServiceUrl, requestParamsFormUrlEncoded);
var responseString = await tokenServiceResponse.Content.ReadAsStringAsync();
var responseCode = tokenServiceResponse.StatusCode;
var responseMsg = new HttpResponseMessage(responseCode)
{
Content = new StringContent(responseString, Encoding.UTF8, "application/json")
};
if (responseCode == HttpStatusCode.OK)
{
MitBudDBEntities mitBudDB = new MitBudDBEntities();
var Bodyresponse = mitBudDB.AspNetUsers.FirstOrDefault(X => X.Email == model.Username);
// Get the roles associated with that user
var userRoles = await UserManager.GetRolesAsync(Bodyresponse.Id.ToString());
// Setup a RoleViewModel list of roles and iterate through userRoles adding them to the list
List <RoleViewModel> roleList = new List <RoleViewModel>();
foreach (var role in userRoles)
{
var item = new RoleViewModel {
Role = role
};
roleList.Add(item);
//return Ok(item);
var res = responseMsg;
}
}
return(responseMsg);
}
}
public void Login(LoginUserBindingModel loginModel, HttpResponse responce, HttpSession session)
{
if (this.RedirectLoggedUserToHome(responce, session))
{
return;
}
var location = this.usersService.LoginUser(loginModel, session, responce);
this.Redirect(responce, location);
}
public AccountCredentialsViewModel LoginUser(LoginUserBindingModel bm)
{
string tokenBearer = string.Empty;
Guid userId = Guid.Empty;
string name = string.Empty;
string email = string.Empty;
try
{
var user = this.Context
.Users
.Where(u => u.Email == bm.Email)
.First();
// taking the user data to send it to the client
userId = user.Id;
name = user.Name;
email = user.Email;
var passwordHash = GenerateHashOfPassword(bm.Password, user.Salt);
if (user.PasswordHash == passwordHash)
{
tokenBearer = GenerateToken();
TokenManager newToken = new TokenManager()
{
Value = tokenBearer,
CreatedOn = DateTime.Now,
};
newToken.User = user;
this.Context.Tokens.Add(newToken);
this.Context.SaveChanges();
}
else
{
return(null);
}
}
catch (Exception)
{
return(null);
}
AccountCredentialsViewModel viewModel = new AccountCredentialsViewModel()
{
UserId = userId,
Token = tokenBearer,
Name = name,
Email = email
};
return(viewModel);
}
public IActionResult Login(HttpResponse response, HttpSession session, LoginUserBindingModel model)
{
User user = new UserService(this.context).LoginUser(model, response, session);
if (user != null)
{
new SessionService(this.context).AddUserSession(user, session);
return(View("Home", "Feedsigned"));
}
return(View());
}
public void LoginUser(LoginUserBindingModel model, HttpSession session)
{
this.Context.Logins.Add(new Login()
{
SessionId = session.Id,
IsActive = true,
User = this.Context.Users.FirstOrDefault(u => (u.Username == model.UsernameOrEmail ||
u.Email == model.UsernameOrEmail) && u.Password == model.Password)
});
this.Context.SaveChanges();
}
public IHttpActionResult SendEmailForResettingPassword(LoginUserBindingModel model)
{
try
{
_userService.SendEmailForResettingPassword(model.Email);
return(Ok());
}
catch (Exception)
{
return(BadRequest());
}
}
public IActionResult Login(HttpResponse response, HttpSession session, LoginUserBindingModel model)
{
bool isLoginSuccessfull = new HomeService().LoginUser(model, session);
if (!isLoginSuccessfull)
{
Redirect(response, "/home/login");
return(null);
}
Redirect(response, "/users/home");
return(null);
}
public IActionResult Login(HttpResponse response, HttpSession session, LoginUserBindingModel lubm)
{
var user = this.data.UsersRepository.FindUserByUserName(lubm.Username);
if (user != null && user.Password == lubm.Password)
{
this.data.LoginRepository.CreateLogin(session.Id, user);
this.data.SaveChanges();
this.Redirect(response, "/home/feedSigned");
return(null);
}
return(this.View());
}
public IActionResult Login(HttpResponse response, HttpSession session, LoginUserBindingModel model)
{
if (this.service.ContainsUser(model))
{
this.service.LoginUser(session, model);
this.Redirect(response, "/home/all");
}
else
{
this.Redirect(response, "/users/login");
}
return(null);
}
public async Task<HttpResponseMessage> LoginUser(LoginUserBindingModel model)
{
// Invoke the "token" OWIN service to perform the login: /api/token
// Ugly hack: I use a server-side HTTP POST because I cannot directly invoke the service (it is deeply hidden in the OAuthAuthorizationServerHandler class)
var request = HttpContext.Current.Request;
var tokenServiceUrl = request.Url.GetLeftPart(UriPartial.Authority) + request.ApplicationPath + "api/Account/Login";
using (var client = new HttpClient())
{
var requestParams = new List<KeyValuePair<string, string>>
{
new KeyValuePair<string, string>("grant_type", "password"),
new KeyValuePair<string, string>("username", model.Username),
new KeyValuePair<string, string>("password", model.Password)
};
var requestParamsFormUrlEncoded = new FormUrlEncodedContent(requestParams);
var tokenServiceResponse = await client.PostAsync(tokenServiceUrl, requestParamsFormUrlEncoded);
var responseString = await tokenServiceResponse.Content.ReadAsStringAsync();
var responseCode = tokenServiceResponse.StatusCode;
var responseMsg = new HttpResponseMessage(responseCode)
{
Content = new StringContent(responseString, Encoding.UTF8, "application/json")
};
return responseMsg;
}
}
public async Task<IHttpActionResult> LoginUser(LoginUserBindingModel model)
{
if (this.User.Identity.GetUserId() != null)
{
return this.BadRequest(UserAlreadyLoggedInMessage);
}
if (model == null)
{
return this.BadRequest(InvalidUserDataMessage);
}
var testServer = TestServer.Create<Startup>();
var requestParams = new List<KeyValuePair<string, string>>
{
new KeyValuePair<string, string>("grant_type", "password"),
new KeyValuePair<string, string>("username", model.Username),
new KeyValuePair<string, string>("password", model.Password)
};
var requestParamsFormUrlEncoded = new FormUrlEncodedContent(requestParams);
var tokenServiceResponse = await testServer.HttpClient.PostAsync(
Startup.TokenEndpointPath, requestParamsFormUrlEncoded);
if (tokenServiceResponse.StatusCode == HttpStatusCode.OK)
{
var responseString = await tokenServiceResponse.Content.ReadAsStringAsync();
var jsSerializer = new JavaScriptSerializer();
var responseData =
jsSerializer.Deserialize<Dictionary<string, string>>(responseString);
var authToken = responseData["access_token"];
var username = responseData["userName"];
var owinContext = this.Request.GetOwinContext();
var userSessionManager = new UserSessionManager(owinContext);
userSessionManager.CreateUserSession(username, authToken);
userSessionManager.DeleteExpiredSessions();
}
return this.ResponseMessage(tokenServiceResponse);
}
public async Task<IHttpActionResult> LoginUser(LoginUserBindingModel model)
{
if (model == null)
{
return this.BadRequest("Invalid user data");
}
// Invoke the "token" OWIN service to perform the login (POST /api/token)
// Use Microsoft.Owin.Testing.TestServer to perform in-memory HTTP POST request
var testServer = TestServer.Create<Startup>();
var requestParams = new List<KeyValuePair<string, string>>
{
new KeyValuePair<string, string>("grant_type", "password"),
new KeyValuePair<string, string>("username", model.Username),
new KeyValuePair<string, string>("password", model.Password)
};
var requestParamsFormUrlEncoded = new FormUrlEncodedContent(requestParams);
var tokenServiceResponse = await testServer.HttpClient.PostAsync(
Startup.TokenEndpointPath, requestParamsFormUrlEncoded);
if (tokenServiceResponse.StatusCode == HttpStatusCode.OK)
{
// Sucessful login --> create user session in the database
var responseString = await tokenServiceResponse.Content.ReadAsStringAsync();
var jsSerializer = new JavaScriptSerializer();
var responseData =
jsSerializer.Deserialize<Dictionary<string, string>>(responseString);
var authToken = responseData["access_token"];
var username = responseData["userName"];
var owinContext = this.Request.GetOwinContext();
var userSessionManager = new UserSessionManager(owinContext);
userSessionManager.CreateUserSession(username, authToken);
// Cleanup: delete expired sessions from the database
userSessionManager.DeleteExpiredSessions();
}
return this.ResponseMessage(tokenServiceResponse);
}
