public bool Login(string login, string senha, bool permacenerLogado, int timeout, string hostName)
{
if (string.IsNullOrEmpty(login))
{
throw new ArgumentNullException("login");
}
if (string.IsNullOrEmpty(senha))
{
throw new ArgumentNullException("senha");
}
var usuario = usuarioRepository.ObterPeloLogin(login);
if (usuario != null && CryptographyHelper.VerifyHashedPassword(senha, usuario.Senha))
{
var customPrincipal = new CustomPrincipalSerializeModel();
customPrincipal.Id = usuario.Id;
customPrincipal.Nome = usuario.Nome;
customPrincipal.Login = usuario.Login;
customPrincipal.HostName = hostName;
var serializer = new JavaScriptSerializer();
var dadosUsuario = serializer.Serialize(customPrincipal);
AuthenticationService.Login(customPrincipal.Nome, permacenerLogado, dadosUsuario, timeout);
GravarLogAcesso(hostName, login, "IN");
return(true);
}
messageQueue.Add(Resource.Admin.ErrorMessages.UsuarioOuSenhaIncorretos, TypeMessage.Error);
return(false);
}
private void LogIn(string login)
{
UserEntity user = userService.GetByLogin(login);
CustomPrincipalSerializeModel serializeModel = new CustomPrincipalSerializeModel();
serializeModel.Id = user.Id;
serializeModel.Email = user.Email;
serializeModel.Login = user.Login;
JavaScriptSerializer serializer = new JavaScriptSerializer();
string userData = serializer.Serialize(serializeModel);
FormsAuthenticationTicket authTicket = new FormsAuthenticationTicket(
1,
serializeModel.Login,
DateTime.Now,
DateTime.Now.AddDays(1),
true,
userData);
string encTicket = FormsAuthentication.Encrypt(authTicket);
HttpCookie faCookie = new HttpCookie(FormsAuthentication.FormsCookieName, encTicket);
Response.Cookies.Add(faCookie);
}
public void CreateCookie(CustomMembershipUser user, bool remebmerMe)
{
CustomPrincipalSerializeModel serializeModel = new CustomPrincipalSerializeModel();
serializeModel.UserId = user.UserId;
serializeModel.UserName = user.UserName;
serializeModel.FirstName = user.FirstName;
serializeModel.LastName = user.LastName;
JavaScriptSerializer serializer = new JavaScriptSerializer();
string userData = serializer.Serialize(serializeModel);
FormsAuthenticationTicket authTicket = new FormsAuthenticationTicket(
0,
user.UserName,
DateTime.Now,
DateTime.Now.AddMinutes(3000),
remebmerMe,
userData,
FormsAuthentication.FormsCookiePath);
string encTicket = FormsAuthentication.Encrypt(authTicket);
HttpCookie faCookie = new HttpCookie(FormsAuthentication.FormsCookieName, encTicket);
Response.Cookies.Add(faCookie);
}
// GET: Catalog
public ActionResult Index()
{
GalaryViewModel galary = new GalaryViewModel();
galary.VideoTypes = new List <VideoTypes>();
galary.Videos = new List <Videos>();
if (Session["User"] != null)
{
CustomPrincipalSerializeModel currentUser = (CustomPrincipalSerializeModel)Session["User"];
foreach (int role in currentUser.CurrentRoles)
{
var videoType = db.VideoTypes.Where(v => v.AssignedRoles.Any(r => r.RoleID == role)).ToList();
if (videoType != null)
{
galary.VideoTypes.AddRange(videoType);
galary.VideoTypes = galary.VideoTypes.Where(i => i.VideoTypeID > 0).Distinct().ToList();
}
if (galary.VideoTypes.Count > 0)
{
galary.SelectedVideoType = galary.VideoTypes[0].VideoTypeID;
galary.Videos = db.Videos.Where(v => v.VideoTypeID.Equals(galary.SelectedVideoType)).ToList();
}
}
}
else
{
return(RedirectToAction("Logout", "Authentication"));
}
return(View(galary));
}
public static void Set(this HttpResponseBase response, UserModel loginInfo, CustomPrincipalSerializeModel serializeModel = null)
{
if (serializeModel == null)
{
var token = loginInfo.Token;
var sessionGuid = Guid.NewGuid();
serializeModel = new CustomPrincipalSerializeModel
{
UserId = loginInfo.Id,
Login = loginInfo.Login,
Token = token,
//UserGuid = loginInfo.UserGuid,
UserType = loginInfo.UserType,
SessionGuid = sessionGuid,
};
}
int timeout = 30;
var serializer = new JavaScriptSerializer();
var userData = serializer.Serialize(serializeModel);
var ticket = new FormsAuthenticationTicket(1, serializeModel.UserId.ToString(), DateTime.Now, DateTime.Now.AddMinutes(timeout), true, userData);
var encryptTicket = FormsAuthentication.Encrypt(ticket);
var cookie = new HttpCookie(AuthCookieName, encryptTicket);
response.Cookies.Set(cookie);
}
/// <summary>
/// Application_PostAuthenticateRequest
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void Application_PostAuthenticateRequest(Object sender, EventArgs e)
{
try
{
HttpCookie authCookie = Request.Cookies[FormsAuthentication.FormsCookieName];
if (authCookie != null)
{
FormsAuthenticationTicket authTicket = FormsAuthentication.Decrypt(authCookie.Value);
var serializer = new JavaScriptSerializer();
CustomPrincipalSerializeModel serializeModel = serializer.Deserialize <CustomPrincipalSerializeModel>(authTicket.UserData);
CustomPrincipal novoUsuario = new CustomPrincipal(authTicket.Name);
HttpContext.Current.User = novoUsuario;
}
}
catch (CryptographicException)
{
FormsAuthentication.SignOut();
}
catch (Exception ex)
{
var msgErro = ex.Message;
}
}
public static HttpCookie Create(Models.User user, IList <string> roles)
{
// var user = userRepository.Users.Where(u => u.Email == viewModel.Email).First();
CustomPrincipalSerializeModel serializeModel = new CustomPrincipalSerializeModel();
serializeModel.Id = user.Id;
serializeModel.FName = user.FName;
serializeModel.AvatarPath = user.AvatarPath;
serializeModel.Roles = roles;
JavaScriptSerializer serializer = new JavaScriptSerializer();
string userData = serializer.Serialize(serializeModel);
FormsAuthenticationTicket authTicket = new FormsAuthenticationTicket(
1,
user.Email,
DateTime.Now,
DateTime.Now.AddMinutes(15),
false,
userData);
string encTicket = FormsAuthentication.Encrypt(authTicket);
HttpCookie faCookie = new HttpCookie(FormsAuthentication.FormsCookieName, encTicket);
return(faCookie);
}
//public ActionResult AuthenticateUser(User model)
//{
// if (ModelState.IsValid)
// {
// // Check if user name and password not enter
// if (string.IsNullOrWhiteSpace(model.Email) && string.IsNullOrWhiteSpace(model.Password))
// {
// TempData["UserStatus"] = "User name and password invalid please try again!!";
// return RedirectToAction("Index");
// }
// // Check if user name not enter
// if (string.IsNullOrWhiteSpace(model.Email))
// {
// TempData["UserStatus"] = "Please enter user name!!";
// return RedirectToAction("Index");
// }
// // Check if password not enter
// if (string.IsNullOrWhiteSpace(model.Password))
// {
// TempData["UserStatus"] = "Please enter password!!";
// return RedirectToAction("Index");
// }
// // Check status user status
// string userStatus = ((UserLoginMessage)_IFrontEndUserService.AuthenticateUser(model.Email, model.Password, ref model)).ToString();
// if (userStatus == UserLoginMessage.ValidUser.ToString())
// {
// //Create Authorized Cookies
// CreateAuthorizedCookiesFronEndUser(model);
// return RedirectToAction("Index", "Home", new { @Area = "User" });
// }
// else
// {
// if (userStatus == "NotExits")
// TempData["UserStatus"] = "User name and password invalid please try again!!";
// return RedirectToAction("Index");
// }
// }
//}
/// <summary>
/// Create cookie for authentication
/// </summary>
/// <param name="model"></param>
private void CreateAuthorizedCookiesFronEndUser(User model)
{
CustomPrincipalSerializeModel serializeModel = new CustomPrincipalSerializeModel();
serializeModel.UserId = model.UserId;
serializeModel.FirstName = model.FirstName;
serializeModel.Email = model.Email;
JavaScriptSerializer serializer = new JavaScriptSerializer();
//serialize user data and add to cookie
string userData = serializer.Serialize(serializeModel);
FormsAuthenticationTicket authTicket = new FormsAuthenticationTicket(
1,
model.Email,
DateTime.Now,
DateTime.Now.AddMinutes(30),
false, userData);
string encTicket = FormsAuthentication.Encrypt(authTicket);
HttpCookie faCookie = new HttpCookie(FormsAuthentication.FormsCookieName, encTicket);
Response.Cookies.Add(faCookie);
}
protected void Application_PostAuthenticateRequest(Object sender, EventArgs e)
{
HttpCookie authCookie = Request.Cookies[FormsAuthentication.FormsCookieName];
if (authCookie != null)
{
FormsAuthenticationTicket authTicket = FormsAuthentication.Decrypt(authCookie.Value);
JavaScriptSerializer serializer = new JavaScriptSerializer();
CustomPrincipalSerializeModel serializeModel = serializer.Deserialize <CustomPrincipalSerializeModel>(authTicket.UserData);
if (serializeModel == null)
{
HttpContext.Current.User = null;
}
else
{
CustomPrincipal newUser = new CustomPrincipal(authTicket.Name);
newUser.Id = serializeModel.Id;
newUser.FirstName = serializeModel.FirstName;
newUser.LastName = serializeModel.LastName;
newUser.Adress = serializeModel.Adress;
newUser.LaunderyAdress = serializeModel.LaunderyAdress;
newUser.Role = serializeModel.Role;
HttpContext.Current.User = newUser;
}
}
}
public ActionResult Login(LoginViewModel model, string returnUrl = "")
{
if (ModelState.IsValid)
{
if (authprovider.Authenticate(model.Username, model.Password))
{
CustomPrincipalSerializeModel serializeModel = new CustomPrincipalSerializeModel();
serializeModel.Username = model.Username;
string userData = JsonConvert.SerializeObject(serializeModel);
FormsAuthenticationTicket authTicket = new FormsAuthenticationTicket(
1,
model.Username,
DateTime.Now,
DateTime.Now.AddMinutes(15),
false,
userData);
string encTicket = FormsAuthentication.Encrypt(authTicket);
HttpCookie faCookie = new HttpCookie(FormsAuthentication.FormsCookieName, encTicket);
if (Response != null)
{
Response.Cookies.Add(faCookie);
}
return(Redirect(returnUrl ?? Url.Action("Index", "Home")));
}
ModelState.AddModelError("", "Incorrect username and/or password");
}
return(View(model));
}
public ActionResult Login(LoginModlView login)
{
//if (Membership.ValidateUser(login.Email, login.Password))
//{
CustomPrincipalSerializeModel serializeModel = new CustomPrincipalSerializeModel();
serializeModel.Id = 4334673;
serializeModel.FirstName = login.Email;
serializeModel.LastName = "JC";
JavaScriptSerializer serializer = new JavaScriptSerializer();
string userData = serializer.Serialize(serializeModel);
FormsAuthenticationTicket authTicket = new FormsAuthenticationTicket(
1,
"*****@*****.**",
DateTime.Now,
DateTime.Now.AddMinutes(15),
false,
userData);
string encTicket = FormsAuthentication.Encrypt(authTicket);
HttpCookie faCookie = new HttpCookie(FormsAuthentication.FormsCookieName, encTicket);
Response.Cookies.Add(faCookie);
return(RedirectToAction("Index", "Home"));
//}
//return View();
}
protected void Application_PostAuthenticateRequest(Object sender, EventArgs e)
{//get user from cookie
HttpCookie authCookie = Request.Cookies[FormsAuthentication.FormsCookieName];
if (authCookie != null)
{
FormsAuthenticationTicket authTicket = FormsAuthentication.Decrypt(authCookie.Value);
JavaScriptSerializer serializer = new JavaScriptSerializer();
CustomPrincipalSerializeModel serializeModel = serializer.Deserialize <CustomPrincipalSerializeModel>(authTicket.UserData);
CustomPrincipal newUser = new CustomPrincipal(authTicket.Name);
newUser.Id = serializeModel.Id;
newUser.FirstName = serializeModel.FirstName;
newUser.LastName = serializeModel.LastName;
HttpContext.User = newUser;
/*
* @((User as CustomPrincipal).Id)
* @((User as CustomPrincipal).FirstName)
* @((User as CustomPrincipal).LastName)
*
* (User as CustomPrincipal).Id
* (User as CustomPrincipal).FirstName
* (User as CustomPrincipal).LastName
*
* Hash hash = new Hash("SHA256");
* if(u.Password == hash.Encrypt(EnteredTyped))
*
* else {HttpContext.Current.User = new CustomPrincipal(""); };if (authCookie != null) { //.. }
*/
}
}
protected void Application_PostAuthenticateRequest(Object sender, EventArgs e)
{
HttpCookie authCookie = Request.Cookies[FormsAuthentication.FormsCookieName];
if (authCookie != null)
{
try
{
FormsAuthenticationTicket authTicket = FormsAuthentication.Decrypt(authCookie.Value);
JavaScriptSerializer serializer = new JavaScriptSerializer();
CustomPrincipalSerializeModel serializeModel = serializer.Deserialize <CustomPrincipalSerializeModel>(authTicket.UserData);
CustomPrincipal newUser = new CustomPrincipal(authTicket.Name);
newUser.Id = serializeModel.Id;
newUser.FirstName = serializeModel.FirstName;
newUser.LastName = serializeModel.LastName;
newUser.Email = serializeModel.Email;
newUser.RoleId = serializeModel.RoleId;
newUser.OrgId = serializeModel.OrgId;
newUser.OrgName = serializeModel.OrgName;
newUser.UserId = serializeModel.UserId;
newUser.UserName = serializeModel.UserName;
newUser.ISApplicant = serializeModel.ISApplicant;
HttpContext.Current.User = (System.Security.Principal.IPrincipal)newUser;
}
catch (Exception ex)
{
FormsAuthentication.SignOut();
}
}
}
public HttpCookie CreateEncryptedAuthenticationCookie(string username, string password)
{
CustomPrincipalSerializeModel serializeModel = new CustomPrincipalSerializeModel();
serializeModel.Id = 1;
serializeModel.FirstName = username;
serializeModel.LastName = password;
JavaScriptSerializer serializer = new JavaScriptSerializer();
string userData = serializer.Serialize(serializeModel);
FormsAuthenticationTicket authTicket = new FormsAuthenticationTicket(
1,
username,
DateTime.Now,
DateTime.Now.AddMinutes(15),
false,
userData);
string encTicket = FormsAuthentication.Encrypt(authTicket);
HttpCookie faCookie = new HttpCookie(FormsAuthentication.FormsCookieName, encTicket);
return(faCookie);
}
protected void Application_AuthenticateRequest(object sender, EventArgs e)
{
HttpCookie authCookie = Request.Cookies[FormsAuthentication.FormsCookieName];
if (authCookie != null)
{
FormsAuthenticationTicket authTicket = FormsAuthentication.Decrypt(authCookie.Value);
JavaScriptSerializer serializer = new JavaScriptSerializer();
CustomPrincipalSerializeModel serializeModel = serializer.Deserialize <CustomPrincipalSerializeModel>(authTicket.UserData);
CustomPrincipal newUser = new CustomPrincipal(authTicket.Name);
////newUser.UserGuid = serializeModel.UserGuid;
////newUser.FirstName = serializeModel.FirstName;
////newUser.LastName = serializeModel.LastName;
//newUser.UserGuid = Guid.Parse("67C919E2-8DF4-476A-B312-C26F82A36CFB");
//newUser.FirstName = "Can";
//newUser.LastName = "Akcan";
HttpContext.Current.User = newUser;
}
}
public ActionResult Register(UserAdmin user)
{
_userRepository.Add(user);
var serializeModel = new CustomPrincipalSerializeModel
{
ID = user.ID,
Username = user.UserName,
FullName = user.FullName,
Email = user.Email,
GroupUser = user.GroupUserID,
UserType = user.UserType,
isAdmin = user.isAdmin,
};
var serializer = new JavaScriptSerializer();
var userData = serializer.Serialize(serializeModel);
var authTicket = new FormsAuthenticationTicket(
1,
user.UserName,
DateTime.Now,
DateTime.Now.AddYears(1),
false,
userData);
var encTicket = FormsAuthentication.Encrypt(authTicket);
var faCookie = new HttpCookie(FormsAuthentication.FormsCookieName, encTicket);
Response.Cookies.Add(faCookie);
return(View());
}
/*
* protected void Application_Start()
* {
* AreaRegistration.RegisterAllAreas();
* WebApiConfig.Register(GlobalConfiguration.Configuration);
* RegisterGlobalFilters(GlobalFilters.Filters);
* RouteConfig.RegisterRoutes(RouteTable.Routes);
* BundleConfig.RegisterBundles(BundleTable.Bundles);
* AuthConfig.RegisterAuth();
* }*/
protected void Application_PostAuthenticateRequest(Object sender, EventArgs e)
{
HttpCookie authCookie = Request.Cookies[FormsAuthentication.FormsCookieName];
if (authCookie != null)
{
FormsAuthenticationTicket authTicket = FormsAuthentication.Decrypt(authCookie.Value);
CustomPrincipalSerializeModel serializeModel = JsonConvert.DeserializeObject <CustomPrincipalSerializeModel>(authTicket.UserData);
CustomPrincipal newUser = new CustomPrincipal(authTicket.Name);
if (serializeModel.roles == MyRoles.Admin)
{
newUser.AdminID = serializeModel.AdminID;
newUser.roles = serializeModel.roles;
}
else
{
newUser.MemberID = serializeModel.MemberID;
newUser.UserId = serializeModel.UserId;
newUser.ApplicantID = serializeModel.ApplicantID;
newUser.EmployerID = serializeModel.EmployerID;
newUser.ProfileID = serializeModel.ProfileID;
}
newUser.FirstName = serializeModel.FirstName;
newUser.LastName = serializeModel.LastName;
newUser.roles = serializeModel.roles;
newUser.UserName = newUser.UserName;
HttpContext.Current.User = newUser;
}
}
public object CreateCookie(ViewModel viewModel)
{
if (true /*Membership.ValidateUser(viewModel.Email, viewModel.Password)*/)
{
CustomPrincipal user = default;//userRepository.Users.Where(u => u.Email == viewModel.Email).First();
CustomPrincipalSerializeModel serializeModel = new CustomPrincipalSerializeModel();
serializeModel.Id = user.Id;
serializeModel.FirstName = user.FirstName;
serializeModel.LastName = user.LastName;
//JavaScriptSerializer serializer = new JavaScriptSerializer();
//string userData = serializer.Serialize(serializeModel);
string userData = Newtonsoft.Json.JsonConvert.SerializeObject(serializeModel);
//FormsAuthenticationTicket authTicket = new FormsAuthenticationTicket(
// 1,
// viewModel.Email,
// DateTime.Now,
// DateTime.Now.AddMinutes(15),
// false,
// userData);
//string encTicket = FormsAuthentication.Encrypt(authTicket);
//HttpCookie faCookie = new HttpCookie(FormsAuthentication.FormsCookieName, encTicket);
//Response.Cookies.Add(faCookie);
//return RedirectToAction("Index", "Home");
}
return(default);
public async Task <ActionResult> Register(RegisterCustomerViewModel customer)
{
if (ModelState.IsValid)
{
if (await client.AddCustomer(new Customer()
{
Id = Guid.NewGuid().ToString(), Email = customer.Email, Name = customer.Name, Password = customer.Password, AddressLine1 = customer.AddressLine1, AddressLine2 = customer.AddressLine2, PinCode = customer.PinCode
}))
{
LoginViewModel loginModel = new LoginViewModel();
loginModel.Email = customer.Email;
loginModel.Password = customer.Password;
var authcustomer = await client.AuthenticateCustomer(new Customer()
{
Email = customer.Email, Password = customer.Password
});
if (authcustomer != null)
{
CustomPrincipalSerializeModel serializeModel = new CustomPrincipalSerializeModel();
serializeModel.CustomerID = authcustomer.Id;
serializeModel.FirstName = authcustomer.Name;
serializeModel.Email = authcustomer.Email;
Response.Cookies.Add(Utility.Utility.EncryptAndSet(serializeModel));
return(RedirectToAction("Index", "Home"));
}
}
}
return(View(customer));
}
// RAMESH: 2016-06-25 - creates authentication ticket for logged in user; can be accessible through "User" object in all controllers/views
public void CreateAuthenticationTicket(string username)
{
var user = UserManager.Users.Where(u => u.UserName == username).First();
var customer = this._db.Customer.Where(m => m.Email == username).FirstOrDefault();
CustomPrincipalSerializeModel serializeModel = new CustomPrincipalSerializeModel();
serializeModel.Id = user.Id;
serializeModel.Email = user.Email;
serializeModel.CustomerId = customer.Id;
serializeModel.FirstName = customer.FirstName;
serializeModel.LastName = customer.LastName;
var userRoles = UserManager.GetRoles(user.Id);
if (userRoles.Count() > 0)
{
serializeModel.Role = userRoles[0];
}
JavaScriptSerializer serializer = new JavaScriptSerializer();
string userData = serializer.Serialize(serializeModel);
FormsAuthenticationTicket authTicket = new FormsAuthenticationTicket(
1, username, DateTime.Now, DateTime.Now.AddHours(8), false, userData);
string encTicket = FormsAuthentication.Encrypt(authTicket);
HttpCookie faCookie = new HttpCookie(FormsAuthentication.FormsCookieName, encTicket);
Response.Cookies.Add(faCookie);
}
protected void Application_PostAuthenticateRequest(object sender, EventArgs e)
{
HttpCookie authCookie = Request.Cookies[FormsAuthentication.FormsCookieName];
if (authCookie != null)
{
FormsAuthenticationTicket authTicket = FormsAuthentication.Decrypt(authCookie.Value);
CustomPrincipalSerializeModel serializeModel = JsonConvert.DeserializeObject <CustomPrincipalSerializeModel>(authTicket.UserData);
CustomPrincipal obUser = new CustomPrincipal(authTicket.Name)
{
Id = serializeModel.Id,
Name = serializeModel.Name,
Email = serializeModel.Email,
Mobile = serializeModel.Mobile,
Gender = serializeModel.Gender,
Avatar = serializeModel.Avatar,
UserTypeId = serializeModel.UserTypeId,
UserTypeName = serializeModel.UserTypeName,
Roles = serializeModel.Roles,
ManagerGroupId = serializeModel.ManagerGroupId,
TraceUserActivity = serializeModel.TraceUserActivity
};
HttpContext.Current.User = obUser;
}
}
protected void Application_PostAuthenticateRequest(Object sender, EventArgs e)
{
HttpCookie authCookie = Request.Cookies[FormsAuthentication.FormsCookieName];
if (authCookie != null)
{
try
{
FormsAuthenticationTicket authTicket = FormsAuthentication.Decrypt(authCookie.Value);
JavaScriptSerializer serializer = new JavaScriptSerializer();
CustomPrincipalSerializeModel serializeModel = serializer.Deserialize <CustomPrincipalSerializeModel>(authTicket.UserData);
CustomPrincipal newUser = new CustomPrincipal(authTicket.Name);
newUser.Modules = serializeModel.Modules;
HttpContext.Current.User = newUser;
}
catch
{
FormsAuthentication.SignOut();
Response.Redirect(FormsAuthentication.LoginUrl, true);
}
}
}
public CustomPrincipalSerializeModel AuthenticateUser(string username, string password)
{
var aUser = _unitOfWork.UserRepository.GetFirst(x => x.UserName == username && x.Password == password);
if (aUser != null)
{
var member = _unitOfWork.MemberRepository.GetByID(aUser.MemberId);
var appUser = new CustomPrincipalSerializeModel()
{
LastName = member.LastName,
FirstName = member.FirstName,
Email = member.Email,
UserId = aUser.UserId,
Username = aUser.UserName,
MemberId = member.MemberId,
Roles = new List <string>()
{
"Admin"
}
};
return(appUser);
}
return(null);
}
public bool login(Login loginModel)
{
bool correctLogin = false;
if (loginModel.UserName == "akosatrap" && loginModel.Password == "123456")
{
Session["token"] = "";
CustomPrincipalSerializeModel serializeModel = new CustomPrincipalSerializeModel();
serializeModel.UserId = 1;
serializeModel.FirstName = "محسن";
serializeModel.LastName = "جعفری";
serializeModel.FullName = "محسن جعفری";
serializeModel.PartnerId = 1;
serializeModel.EmployeeID = 1;
JavaScriptSerializer serializer = new JavaScriptSerializer();
string userData = serializer.Serialize(serializeModel);
FormsAuthenticationTicket authTicket = new FormsAuthenticationTicket(
1,
serializeModel.UserId.ToString(),
DateTime.Now,
DateTime.Now.AddMinutes(30),
false,
userData);
string encTicket = FormsAuthentication.Encrypt(authTicket);
HttpCookie faCookie = new HttpCookie(FormsAuthentication.FormsCookieName, encTicket);
//faCookie.Expires = authTicket.Expiration;
Response.Cookies.Add(faCookie);
correctLogin = true;
}
return(correctLogin);
}
protected void Application_PostAuthenticateRequest(Object sender, EventArgs e)
{
HttpCookie authCookie = Request.Cookies[FormsAuthentication.FormsCookieName];
if (authCookie != null)
{
try
{
FormsAuthenticationTicket authTicket = FormsAuthentication.Decrypt(authCookie.Value);
CustomPrincipalSerializeModel serializeModel = JsonConvert.DeserializeObject <CustomPrincipalSerializeModel>(authTicket.UserData);
CustomPrincipal newUser = new CustomPrincipal(authTicket.Name);
newUser.Id = serializeModel.ID;
newUser.Name = serializeModel.Name;
newUser.Email = serializeModel.Email;
newUser.roles = serializeModel.roles;
HttpContext.Current.User = newUser;
}
catch
{
FormsAuthentication.SignOut();
Response.Redirect("/Account/Login");
}
}
System.Web.HttpContext.Current.SetSessionStateBehavior(
SessionStateBehavior.Required);
}
// GET: Videos
public ActionResult Index()
{
GalaryViewModel galary = new GalaryViewModel();
galary.VideoTypes = new List <VideoTypes>();
galary.Videos = new List <Videos>();
CustomPrincipalSerializeModel currentUser = (CustomPrincipalSerializeModel)Session["User"];
List <VideoTypes> lstVideoType = db.VideoTypes.OrderBy(r => r.VideoTypeName).ToList();
foreach (VideoTypes videoType in lstVideoType)
{
if (videoType.AssignedRoles.Where(r => currentUser.CurrentRoles.Contains(r.RoleID)).FirstOrDefault() != null)
{
galary.VideoTypes.Add(videoType);
galary.Videos.AddRange(videoType.VideosCollection);
}
}
/*
* foreach (int role in currentUser.CurrentRoles)
* {
* var videoType = db.VideoTypes.Where(v => v.AssignedRoles.Any(r => r.RoleID == role)).ToList();
* if (videoType != null)
* {
* galary.VideoTypes.AddRange(videoType);
* foreach (VideoTypes video in videoType)
* {
* galary.Videos.AddRange(video.VideosCollection);
* }
* }
* }
*/
return(View(galary));
}
protected void Application_PostAuthenticateRequest(Object sender, EventArgs e)
{
HttpCookie authCookie = Request.Cookies["TSI-LOGIN"];
if (authCookie != null)
{
try
{
FormsAuthenticationTicket authTicket = FormsAuthentication.Decrypt(authCookie.Value);
JavaScriptSerializer serializer = new JavaScriptSerializer();
CustomPrincipalSerializeModel serializeModel = serializer.Deserialize <CustomPrincipalSerializeModel>(authTicket.UserData);
Custom2IPrincipal newUser = new Custom2IPrincipal(authTicket.Name);
newUser.UserId = serializeModel.UserID;
newUser.UserName = serializeModel.UserName;
newUser.RoleId = serializeModel.RoleId;
HttpContext.Current.User = newUser;
}
catch
{
FormsAuthentication.SignOut();
}
}
}
public void updateLogin(UserModel user)
{
CustomPrincipalSerializeModel serializeModel = new CustomPrincipalSerializeModel
{
Id = user.User_ID,
FirstName = user.First_Name,
LastName = user.Last_Name,
Email = user.Email,
TeamId = user.Team_ID
};
JavaScriptSerializer serializer = new JavaScriptSerializer();
string userData = serializer.Serialize(serializeModel);
FormsAuthenticationTicket authTicket = new FormsAuthenticationTicket(
1,
user.Email,
DateTime.Now,
DateTime.Now.AddMinutes(15),
false,
userData);
string encTicket = FormsAuthentication.Encrypt(authTicket);
HttpCookie faCookie = new HttpCookie(FormsAuthentication.FormsCookieName, encTicket);
Response.Cookies.Add(faCookie);
}
public virtual ActionResult Login(LoginViewModel user, string returnUrl = "")
{
if (ModelState.IsValid)
{
bool isValid = um.LoginUserIsValid(user);
if (isValid)
{
if (um.ChangeActiveAccount(user))
{
var modelUser = um.getUser(user.Username, user.Password);
var operations = modelUser.Operations.Select(m => m.Name).ToArray();
var groups = modelUser.OperationGroups.Select(g => g.Name).ToArray();
CustomPrincipalSerializeModel serializeModel = new CustomPrincipalSerializeModel();
serializeModel.UserId = modelUser.Id;
serializeModel.Username = modelUser.Username;
serializeModel.operations = operations;
serializeModel.groups = groups;
string userData = JsonConvert.SerializeObject(serializeModel);
FormsAuthenticationTicket authTicket = new FormsAuthenticationTicket(
1,
modelUser.Username,
DateTime.Now,
DateTime.Now.AddMinutes(15),
false,
userData);
string encTicket = FormsAuthentication.Encrypt(authTicket);
HttpCookie faCookie = new HttpCookie(FormsAuthentication.FormsCookieName, encTicket);
Response.Cookies.Add(faCookie);
if (operations.Contains("admin"))
{
return(RedirectToAction("Index", "User"));
}
//FormsAuthentication.SetAuthCookie(user.Username, true);
return(RedirectToAction("Index", "Home"));
}
else
{
ModelState.AddModelError("", "Your account is not active! ");
}
}
else
{
ModelState.AddModelError("", "Login data is incorrect! ");
}
}
else
{
ModelState.AddModelError("", "Error");
}
return(View());
}
public ActionResult LoginView(LoginViewModel model, string returnUrl = "")
{
try
{
LoginManager loginDetails = new LoginManager();
if (ModelState.IsValid)
{
var Details = loginDetails.GetloginUsers();
var user = Details.Where(u => u.Username.ToLower() == model.Username.ToLower() && u.Password.ToLower() == model.Password.ToLower()).FirstOrDefault();
if (user != null)
{
var roles = user.Roles.Select(m => m.RoleName).ToArray();
CustomPrincipalSerializeModel serializeModel = new CustomPrincipalSerializeModel();
serializeModel.UserId = user.UserId;
serializeModel.FirstName = user.FirstName;
serializeModel.LastName = user.LastName;
serializeModel.roles = roles;
string userData = JsonConvert.SerializeObject(serializeModel);
FormsAuthenticationTicket authTicket = new FormsAuthenticationTicket(
1,
user.Email,
DateTime.Now,
DateTime.Now.AddMinutes(15),
false,
userData);
string encTicket = FormsAuthentication.Encrypt(authTicket);
HttpCookie faCookie = new HttpCookie(FormsAuthentication.FormsCookieName, encTicket);
Response.Cookies.Add(faCookie);
if (roles.Contains("HR"))
{
return(RedirectToAction("RegisterExamination", "Admin"));
}
else if (roles.Contains("Technical panelist"))
{
return(RedirectToAction("AssignPanelToExam", "Admin"));
}
else
{
return(RedirectToAction("Registration", "Exam"));
}
}
ViewBag.error = "Incorrect username or password";
}
}
catch (Exception ex)
{
throw ex;
}
return(View(model));
}
public async Task<AccountModel> Login(HttpResponse httpResponse, LoginModel loginModel)
{
AccountModel accountModel = await _accountService.Get(loginModel.Login, loginModel.Password);
if (accountModel != null)
{
var principalModel = new CustomPrincipalSerializeModel
{
FirstName = accountModel.FirstName,
LastName = accountModel.LastName,
UserId = accountModel.AccountId,
Roles = accountModel.Roles.Select(role => role.Name).ToArray(),
Login = accountModel.Login
};
ProlongateUserSession(httpResponse, principalModel);
}
return accountModel;
}
public void ProlongateUserSession(HttpResponse httpResponse, CustomPrincipalSerializeModel principalModel)
{
string userData = JsonConvert.SerializeObject(principalModel);
var expirationTime = DateTime.Now.AddMinutes(15);
var authTicket = new FormsAuthenticationTicket(
1,
principalModel.Login,
DateTime.Now,
expirationTime,
false, // pass here true, if you want to implement remember me functionality
userData);
string encryptedTicket = FormsAuthentication.Encrypt(authTicket);
var cookie = new HttpCookie(FormsAuthentication.FormsCookieName, encryptedTicket);
httpResponse.Cookies.Remove(FormsAuthentication.FormsCookieName);
httpResponse.SetCookie(cookie);
}
public ActionResult Login(User model, string returnUrl)
{
// Lets first check if the Model is valid or not
if (ModelState.IsValid)
{
User user = db.Users.Where(x => x.Name == model.Name && x.Password == model.Password).FirstOrDefault();
if (user != null)
{
CustomPrincipalSerializeModel serializeModel = new CustomPrincipalSerializeModel();
serializeModel.Id = user.Id;
serializeModel.RoleId = user.RoleId;
serializeModel.Name = user.Name;
string userData = SerializerHelper.JavaScriptSerialize(serializeModel);
FormsAuthenticationTicket authTicket = new FormsAuthenticationTicket(1, user.Name, DateTime.Now, DateTime.Now.AddMinutes(15), false, userData);
string encTicket = FormsAuthentication.Encrypt(authTicket);
HttpCookie faCookie = new HttpCookie(FormsAuthentication.FormsCookieName, encTicket);
Response.Cookies.Add(faCookie);
if (Url.IsLocalUrl(returnUrl) && returnUrl.Length > 1 && returnUrl.StartsWith("/") && !returnUrl.StartsWith("//") && !returnUrl.StartsWith("/\\"))
{
return Redirect(returnUrl);
}
else
{
return RedirectToAction("Index", "Home");
}
}
else
{
ModelState.AddModelError("", "The user name or password provided is incorrect.");
}
}
// If we got this far, something failed, redisplay form
return View();
}
public ActionResult Login(LoginViewModel model)
{
if (ModelState.IsValid)
{
try
{
PlayerService ps = new PlayerService(FILENAME);
Player p = ps.GetPlayer(model.UserName, model.Password);
CustomPrincipalSerializeModel serializeModel = new CustomPrincipalSerializeModel();
serializeModel.IsAdmin = p.IsAdmin;
JavaScriptSerializer serializer = new JavaScriptSerializer();
string userData = serializer.Serialize(serializeModel);
FormsAuthenticationTicket authTicket = new FormsAuthenticationTicket(
1,
model.UserName,
DateTime.Now,
DateTime.Now.AddHours(10),
false,
userData);
string encTicket = FormsAuthentication.Encrypt(authTicket);
HttpCookie faCookie = new HttpCookie(FormsAuthentication.FormsCookieName, encTicket);
Response.Cookies.Add(faCookie);
return RedirectToAction("Index", "Home");
}
catch (Exception e)
{
ModelState.AddModelError("", e.Message);
}
}
return View(model);
}
public ActionResult Logout()
{
/* FormsAuthentication.SignOut();
Session.Abandon();
// clear authentication cookie
HttpCookie cookie1 = new HttpCookie(FormsAuthentication.FormsCookieName, "");
cookie1.Expires = DateTime.Now.AddYears(-1);
cookie1.Path = FormsAuthentication.FormsCookiePath;
Response.Cookies.Add(cookie1);
// clear session cookie (not necessary for your current problem but i would recommend you do it anyway)
HttpCookie cookie2 = new HttpCookie("ASP.NET_SessionId", "");
cookie2.Expires = DateTime.Now.AddYears(-1);
Response.Cookies.Add(cookie2);*/
UserEntity user = userService.GetByLogin(SessionPersister.Username);
CustomPrincipalSerializeModel serializeModel = new CustomPrincipalSerializeModel();
serializeModel.Id = user.Id;
serializeModel.Email = user.Email;
serializeModel.Login = user.Login;
JavaScriptSerializer serializer = new JavaScriptSerializer();
string userData = serializer.Serialize(serializeModel);
FormsAuthenticationTicket authTicket = new FormsAuthenticationTicket(
1,
serializeModel.Login,
DateTime.Now,
DateTime.Now.AddDays(-1),
false,
userData);
string encTicket = FormsAuthentication.Encrypt(authTicket);
HttpCookie faCookie = new HttpCookie(FormsAuthentication.FormsCookieName, encTicket);
Response.Cookies.Add(faCookie);
SessionPersister.Username = "";
return Redirect("/Home/Index");
}
public ActionResult Checklogin(LoginViewModel model, string returnUrl)
{
ViewBag.Title = Resources.LoginResource.PageTitle;
if (!ModelState.IsValid)
{
return View(model);
}
// No cuenta los errores de inicio de sesión para el bloqueo de la cuenta
// Para permitir que los errores de contraseña desencadenen el bloqueo de la cuenta, cambie a shouldLockout: true
//var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout: false);
Encriptador Encrypt = new Encriptador();
using (SeguricelEntities db = new SeguricelEntities())
{
Encrypt.InicioClaves("53gur1cel!n37", "4LC_C0MUN1C4C10N35@S3GUR1C3L!N37", "53gur1c3l!4lcC0mun1c4c10n35@s3gur1c3lgm41l!c0m", 5);
string encryptedPassword = Encrypt.Encriptar(model.Password, Encriptador.HasAlgorimt.SHA1, Encriptador.Keysize.KS256);
Usuario dataUsuario = (from u in db.Usuario
where (u.CodigoUsuario == model.Email | u.Email == model.Email) && u.ClaveUsuario == encryptedPassword
select u).FirstOrDefault();
if (dataUsuario != null)
{
switch ((eEstadoUsuario)dataUsuario.IdEstadoUsuario)
{
case eEstadoUsuario.Conectado:
case eEstadoUsuario.Activo:
string[] utz = model.UserTimeZone.Split(':');
int hourZone;
int minZone;
if (utz.Length <= 0)
{
hourZone = 0;
minZone = 0;
}
else
{
hourZone = int.Parse(utz[0]);
minZone = int.Parse(utz[1]);
}
CustomPrincipalSerializeModel serializeModel = new CustomPrincipalSerializeModel()
{
Email = dataUsuario.Email,
Estado = (eEstadoUsuario)dataUsuario.IdEstadoUsuario,
Id = dataUsuario.IdUsuario,
FechaUltimaConexion = DateTime.UtcNow,
Name = dataUsuario.Nombre,
IdTipoUsuario = dataUsuario.IdTipoUsuario,
HoursTimeZone = hourZone,
MinutesTimeZone = minZone,
Culture = Request.UserLanguages[0],
DefaultCulture = "es-VE"
};
string _jsonUserData = JsonConvert.SerializeObject(serializeModel);
FormsAuthenticationTicket authTicket =
new FormsAuthenticationTicket(1, serializeModel.Email,
DateTime.UtcNow.AddHours(-4).AddMinutes(-30),
DateTime.UtcNow.AddHours(-4).AddMinutes(-15),
false, _jsonUserData);
string encTicket = FormsAuthentication.Encrypt(authTicket);
HttpCookie faCookie = new HttpCookie(FormsAuthentication.FormsCookieName, encTicket);
bool PrimeraVez = false;
/*if (dataUsuario.FechaUltimaConexion == null)
PrimeraVez = true;*/
PrimeraVez = dataUsuario.PrimeraVez;
Response.Cookies.Add(faCookie);
Session["user"] = encTicket;
if (PrimeraVez)
return RedirectToAction("Perfil", "Account");
else
{
return ConectarUsuario(dataUsuario, db);
}
case eEstadoUsuario.Inactivo:
ModelState.AddModelError("", Resources.LoginResource.LoginFailedMessageInactivo);
break;
case eEstadoUsuario.Bloqueado:
ModelState.AddModelError("", Resources.LoginResource.LoginFailedMessageBloqueado);
break;
default:
ModelState.AddModelError("", Resources.LoginResource.LoginFailedMessage);
break;
}
}
else
{
ModelState.AddModelError("", Resources.LoginResource.LoginFailedMessage);
}
}
return View(model);
}
private void LogIn(string login)
{
UserEntity user = userService.GetByLogin(login);
CustomPrincipalSerializeModel serializeModel = new CustomPrincipalSerializeModel();
serializeModel.Id = user.Id;
serializeModel.Email = user.Email;
serializeModel.Login = user.Login;
JavaScriptSerializer serializer = new JavaScriptSerializer();
string userData = serializer.Serialize(serializeModel);
FormsAuthenticationTicket authTicket = new FormsAuthenticationTicket(
1,
serializeModel.Login,
DateTime.Now,
DateTime.Now.AddDays(1),
true,
userData);
string encTicket = FormsAuthentication.Encrypt(authTicket);
HttpCookie faCookie = new HttpCookie(FormsAuthentication.FormsCookieName, encTicket);
Response.Cookies.Add(faCookie);
}
public async Task<ActionResult> Login(LoginViewModel model, string returnUrl)
{
if (!ModelState.IsValid)
{
return View(model);
}
// This doesn't count login failures towards account lockout
// To enable password failures to trigger account lockout, change to shouldLockout: true
var user = db.Users.Where(l => l.Login == model.Login)
.Where(l => l.Password == model.Password )
.FirstOrDefault();
if (user == null)
{
ModelState.AddModelError("", "Invalid login attempt");
return View(model);
}
else
{
if (user.LockoutFlag == true)
{
ModelState.AddModelError("", "User locked out. Please contact administrator.");
return View(model);
}
else
{
CustomPrincipalSerializeModel serializeModel = new CustomPrincipalSerializeModel();
serializeModel.Id = user.UserID;
serializeModel.FirstName = user.FirstName;
serializeModel.LastName = user.LastName;
JavaScriptSerializer serializer = new JavaScriptSerializer();
string userData = serializer.Serialize(serializeModel);
FormsAuthenticationTicket authTicket = new FormsAuthenticationTicket(
1,
user.Login,
DateTime.Now,
DateTime.Now.AddMinutes(15),
false,
userData);
string encTicket = FormsAuthentication.Encrypt(authTicket);
HttpCookie faCookie = new HttpCookie(FormsAuthentication.FormsCookieName, encTicket);
Response.Cookies.Add(faCookie);
Session["User"] = user;
//Session["user"] = user.DisplayName;
return RedirectToLocal("Home");
}
}
//var foo = "hello";
//var result = await SignInManager.PasswordSignInAsync(model.Login, model.Password, model.RememberMe, shouldLockout: false);
//switch (result)
//{
// case SignInStatus.Success:
// return RedirectToLocal(returnUrl);
// case SignInStatus.LockedOut:
// return View("Lockout");
// case SignInStatus.RequiresVerification:
// return RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = model.RememberMe });
// case SignInStatus.Failure:
// default:
// ModelState.AddModelError("", "Invalid login attempt.");
// return View(model);
//}
}
