public async Task<ActionResult> Login(LoginViewModel model, string returnUrl)
        {
            if (!this.ModelState.IsValid)
            {
                return this.View(model);
            }

            if (model.Email.Contains("@"))
            {
                var user = this.UserManager.FindByEmail(model.Email);
                if (user != null)
                {
                    model.Email = user.UserName;
                }
            }

            var result = await this.SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout: false);
            switch (result)
            {
                case SignInStatus.Success:
                    return this.RedirectToLocal(returnUrl);
                case SignInStatus.LockedOut:
                    return this.View("Lockout");
                case SignInStatus.RequiresVerification:
                    return this.RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = model.RememberMe });
                case SignInStatus.Failure:
                default:
                    this.ModelState.AddModelError(string.Empty, "Invalid login attempt.");
                    return this.View(model);
            }
        }

 public string GetUserDetails(string userName)
 {
     string isCaptchaDisplay = null;
     var loginType = CheckInputType(userName);
     var loginViewModel = new LoginViewModel();
     var user = _wcfService.InvokeService<IUserService, User>(svc => svc.GetUserByUsername(userName, loginType));
     if (user != null)
     {
         var ipAddress = GetClientIpAddress();
         var userHistory = user.UserLogins.Select(x => x.UserHistories.FirstOrDefault(y => y.IpAddress == ipAddress)).ToList();
         if (userHistory == null)
         {
             isCaptchaDisplay = "False";
             loginViewModel.IsCaptchaDisplay = isCaptchaDisplay.AsBool();
             return isCaptchaDisplay;
         }
         else
         {
             isCaptchaDisplay = "True";
             loginViewModel.IsCaptchaDisplay = isCaptchaDisplay.AsBool();
             return isCaptchaDisplay;
         }
     }
     //ModelState.AddModelError("UserName", "The user name is not correct.");
     return isCaptchaDisplay;
 }

        public async Task<IActionResult> Login(LoginViewModel model, string returnUrl = null)
        {
            EnsureDatabaseCreated(_applicationDbContext);
            ViewData["ReturnUrl"] = returnUrl;
            if (ModelState.IsValid)
            {
                // This doesn't count login failures towards account lockout
                // To enable password failures to trigger account lockout, set lockoutOnFailure: true
                var result = await _signInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, lockoutOnFailure: false);
                if (result.Succeeded)
                {
                    return RedirectToLocal(returnUrl);
                }
                if (result.RequiresTwoFactor)
                {
                    return RedirectToAction(nameof(SendCode), new { ReturnUrl = returnUrl, RememberMe = model.RememberMe });
                }
                if (result.IsLockedOut)
                {
                    return View("Lockout");
                }
                else
                {
                    ModelState.AddModelError(string.Empty, "Invalid login attempt.");
                    return View(model);
                }
            }

            // If we got this far, something failed, redisplay form
            return View(model);
        }

        public ActionResult LogIn(LoginViewModel model)
        {
            if (ModelState.IsValid)
            {

                bool temp = true;
                try
                {
                    temp = model.Email == "[email protected]";
                    temp = model.Password == "123";

                    temp = Membership.ValidateUser(model.Email, model.Password);

                }
                catch (Exception e)
                {

                    System.Console.WriteLine("Error");
                }

                return RedirectToAction("Index", "Home");

            }

            return RedirectToAction("LogIn", "Account");
        }

        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 result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout: false);
            switch (result)
            {
                case SignInStatus.Success:
                    {
                        var visitor = new Visitor();
                        var userTemp = db.Users.FirstOrDefault(x => x.Email == model.Email);
                        visitor.UserId = userTemp.Id;
                        visitor.Time = DateTime.Now.ToString();
                        visitor.VisitorIP = GetIPAdress(Request);
                        visitor.VisitorCountry = "";// await GetCountryFromIp(visitor.VisitorIP);
                        myContext.Visitors.Add(visitor);
                        myContext.Entry(visitor).State = System.Data.Entity.EntityState.Added;
                        myContext.SaveChanges();
                        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);
            }
        }

        public async Task<ActionResult> SignIn(LoginViewModel model, string returnUrl)
        {
            if (!ModelState.IsValid)
            {
                //return PartialView("_Login", model);
                //return PartialView();
                return View("Error");
            }

            // This doesn't count login failures towards account lockout
            // To enable password failures to trigger account lockout, change to shouldLockout: true
            var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout: false);
            switch (result)
            {
                case SignInStatus.Success:
                    var user = await UserManager.FindAsync(model.Email, model.Password);
                    await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false);
                    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 RedirectToAction("Index", "Home");
                    //return View("_LoginPartial");
                    //return PartialView("_Login",model);
                    return View("Error");
            }
        }

    public async Task<IActionResult> Login(LoginViewModel model, string returnUrl = null)
    {
        ViewBag.ReturnUrl = returnUrl;
        if (ModelState.IsValid)
        {
            // This doesn't count login failures towards account lockout
            // To enable password failures to trigger account lockout, set shouldLockout: true
            var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, false);
            if (result.Succeeded)
            {
                return RedirectToLocal(returnUrl);
            }
            if (result.RequiresTwoFactor)
            {
                return RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = model.RememberMe });
            }
            if (result.IsLockedOut)
            {
                return View("Lockout");
            }
            else
            {
                ModelState.AddModelError(string.Empty, "Invalid login attempt.");
                return View(model);
            }
        }

        // If we got this far, something failed, redisplay form
        return View(model);
    }

        public async Task<ActionResult> Login(LoginViewModel model, string returnUrl)
        {
            if (ModelState.IsValid)
            {
                var user = await UserManager.FindAsync(model.UserName, model.Password);
                if (user != null)
                {
                    var identity = await UserManager.CreateIdentityAsync(user, DefaultAuthenticationTypes.ApplicationCookie);
                    identity.AddClaim(new Claim("FirstName", user.FirstName));
                    identity.AddClaim(new Claim("LastName", user.LastName));
                    identity.AddClaim(new Claim("Email", user.Email));
                    identity.AddClaim(new Claim("Role", user.role.ToString()));

                    await SignInAsync(user, model.RememberMe);
                    return RedirectToLocal(returnUrl);
                }
                else
                {
                    ModelState.AddModelError("", "Invalid username or password.");
                }
            }

            // If we got this far, something failed, redisplay form
            return View(model);
        }

        public void TestLoginIngresoFallido()
        {
            var userStore = new Mock<IUserStore<ApplicationUser>>();
            var userManager = new Mock<ApplicationUserManager>(userStore.Object);
            var authenticationManager = new Mock<IAuthenticationManager>();
            var signInManager = new Mock<ApplicationSignInManager>(userManager.Object, authenticationManager.Object);


            signInManager.Setup(s => s.PasswordSignInAsync(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<bool>(), It.IsAny<bool>()))
                .Returns<string, string, bool, bool>(MockPasswordSignInAsync);


            var controller = new AccountController(userManager.Object, signInManager.Object);


            var contextMock = new Mock<HttpContextBase>();
            controller.Url = new UrlHelper(new RequestContext(contextMock.Object, new RouteData()));

            var loginViewmodel = new LoginViewModel
            {
                Email = "[email protected]",
                Password = "[email protected]",
                RememberMe = false
            };
            var returnUrl = "/Home/Index";

            //Act
            var result = controller.Login(loginViewmodel, returnUrl);

            //Assert

            Assert.IsInstanceOfType(result.Result, typeof(ViewResult));
            Assert.AreEqual("Usuario o Clave incorrectos", (result.Result as ViewResult).ViewData.ModelState[""].Errors[0].ErrorMessage);

        }

        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 result =
                await SignInManager.PasswordSignInAsync(model.UserName, model.Password, model.RememberMe, false);
            switch (result)
            {
                case SignInStatus.Success:
                     //var hubContext = GlobalHost.ConnectionManager.GetHubContext<BaseHub>();
            
                    var user = await UserManager.FindAsync(model.UserName, model.Password);
                    //hubContext.Clients.AllExcept(user.UserName).kur("qjhui");
                    if (UserManager.IsInRole(user.Id, "Administrator"))
                    {
                        return RedirectToAction("Index", "Home");
                    }
                    return RedirectToLocal(returnUrl);
                case SignInStatus.LockedOut:
                    return View("Lockout");
                case SignInStatus.RequiresVerification:
                    return RedirectToAction("SendCode", new {ReturnUrl = returnUrl, model.RememberMe});
                case SignInStatus.Failure:
                default:
                    ModelState.AddModelError("", "Invalid login attempt.");
                    return View(model);
            }
        }

        public ActionResult Logar(LoginViewModel model)
        {
            if (!ModelState.IsValid)
            {
                return View("Index", model);
            }

            AutenticacaoService service = new AutenticacaoService();

            Stopwatch sw = Stopwatch.StartNew();

            bool resultado = service.Autenticar(model.Usuario, model.Senha);

            sw.Stop();

            Trace.WriteLine("Autenticar em " + sw.ElapsedMilliseconds);

            if (!resultado)
            {
                ModelState.AddModelError("Usuario",
                    "Usuário ou senha inválidos");

                return View("Index", model);
            }

            return Content("TOP SECRET!");
        }

 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 result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout: false);
     
     switch (result)
     {
         case SignInStatus.Success:
             {
                 //SessionHelper.UserSessionID = "TEMPSESSIONID";
                 AspNetUsersController aspUserCon = new AspNetUsersController();
                 var user = aspUserCon.GetUser(model.Email);
                 //SessionHelper.UserSessionID = user.Id;
                 SessionHelper.LoggedInUser<AspNetUser>(user, user.UserName);
                 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);
     }
 }

        public async Task<ActionResult> Login(LoginViewModel model, string returnUrl)
        {
            if (ModelState.IsValid)
            {
                var user = await UserManager.FindAsync(model.UserName, model.Password);
                if (user != null)
                {
                    // Put in the session the logged user.
                    Session["user"] = user;
                    TempData["userName"] = user.UserName;

                    // Define if the user is Administrator. If not I need go get his ID to use in the query.
                    if (user.UserName.Equals("Admin"))
                        TempData["userId"] = null;
                    else
                        TempData["userId"] = user.Id;
                    
                    TempData.Keep();

                    await SignInAsync(user, model.RememberMe);
                    return RedirectToLocal(returnUrl);
                }
                else
                    ModelState.AddModelError(string.Empty, "The User Name and/or Password entered is invalid. Please try again.");
            }

            // If we got this far, something failed, redisplay form
            return View(model);
        }

        public async Task<ActionResult> Login(LoginViewModel model, string returnUrl)
        {
           // var user = new ApplicationUser { UserName = "[email protected]", Email = "[email protected]" };
           // var re = await UserManager.CreateAsync(user, "[email protected]");

            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 result = await SignInManager.PasswordSignInAsync(model.Email, 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);
            }
        }

        public async Task<ActionResult> Main(string LID)
        {
            if (LID != null)
            {
                var db = getDB0();
                var getItem = db.Apply_User.Where(x => x.userid == LID).FirstOrDefault();
                if (getItem != null)
                {
                    LoginViewModel md = new LoginViewModel() { account = "user", password = "4257386-", lang = "zh-TW", rememberme = false };
                    var getResult = await ajax_Login(md);

                    LoginResult trnResult = Newtonsoft.Json.JsonConvert.DeserializeObject<LoginResult>(getResult);
                    if (trnResult.result)
                    {
                        Response.Cookies.Add(new HttpCookie("user_id", Server.UrlEncode(EncryptString.desEncryptBase64(getItem.userid))));
                        Response.Cookies.Add(new HttpCookie("user_name", Server.UrlEncode(getItem.username)));
                        Response.Cookies.Add(new HttpCookie("user_login", Server.UrlEncode(EncryptString.desEncryptBase64("Y"))));

                        return Redirect(trnResult.url + "/Users");
                    }
                }
            }

            HttpContext.GetOwinContext().Authentication.SignOut();
            ViewData["username"] = "";
            ViewData["password"] = "";

#if DEBUG
            ViewData["username"] = CommWebSetup.AutoLoginUser;
            ViewData["password"] = CommWebSetup.AutoLoginPassword;
#endif
            return View("Index");
        }

        public async Task<ActionResult> Login(LoginViewModel model, string returnUrl)
        {
            if (ModelState.IsValid)
            {
                var user = await UserManager.FindAsync(model.UserName, model.Password);


                // // Insert a new user into the database
                //using (var db = new ApplicationDbContext())
                //{

                //    db.Results.Add(new Result { TeamName = model.} )
                //}






                if (user != null)
                {
                    await SignInAsync(user, model.RememberMe);
                    return RedirectToLocal(returnUrl);
                }
                else
                {
                    ModelState.AddModelError("", "Invalid username or password.");
                }
            }

            // If we got this far, something failed, redisplay form
            return View(model);
        }

        public async Task<ActionResult> Login(LoginViewModel model, string returnUrl)
        {
            model.RememberMe = true;

            if (!ModelState.IsValid)
            {
                return View(model);
            }

            SignInStatus result;
            try
            {
                result = await _signInManager.PasswordEmailSignInAsync(model.Email, model.Password
                    , model.RememberMe, shouldLockout: IdentitySettings.ShouldLockOut);
            }
            catch(Exception exception)
            {
                _logger.Exception(exception);
                result = SignInStatus.Failure;
            }
            
            switch (result)
            {
                case SignInStatus.Success:
                    return RedirectToLocal(returnUrl);
                case SignInStatus.LockedOut:
                    return View("Lockout");               
                case SignInStatus.Failure:
                default:
                    string invalidMessage = IdentityResourceHelper.Load(IdentitySettings.IdentityResource, "AccountController_Login_Invalid");
                    ModelState.AddModelError("", invalidMessage);
                    
                    return View(model);
            }
        }

        public async Task<ActionResult> Login(LoginViewModel model, string returnUrl)
        {
            if (ModelState.IsValid)
            {
                var user = await UserManager.FindAsync(model.GaTechId, model.Password);
                if (user != null)
                {
                    if (user.EmailConfirmed)
                    {
                        await SignInAsync(user, model.RememberMe);
                        return RedirectToLocal(returnUrl);
                    }
                    else
                    {
                        ModelState.AddModelError("", "Account activiation is awaiting email confirmation.");
                    }
                }
                else
                {
                    ModelState.AddModelError("", "Invalid username or password.");
                }
            }

            // If we got this far, something failed, redisplay form
            return View(model);
        }

        public async Task<ActionResult> Login(LoginViewModel model, string returnUrl)
        {
            if (ModelState.IsValid)
            {
                try
                {
                    var user = await UserManager.FindAsync(model.Email, model.Password);

                    if (user != null)
                    {
                        await SignInAsync(user, model.RememberMe);

                        return Json(new { success = true, url = returnUrl });
                    }
                    else
                    {
                        ModelState.AddModelError("", "Invalid username or password.");
                    }
                    //await experiment(user);
                }
                catch (DbEntityValidationException dbx)
                {
                    foreach(var item in dbx.EntityValidationErrors)
                    {
                        foreach(var thisThing in item.ValidationErrors)
                        {
                            Trace.TraceInformation("Property: {0} Error: {1}", thisThing.PropertyName, thisThing.ErrorMessage);
                        }
                    }
                }
            }
            return PartialView(model);
        }

        public async Task<ActionResult> Login(LoginViewModel model, string returnUrl)
        {
            if (ModelState.IsValid)
            {
                // Validate the password
                IdentityResult result =
                    await
                    this.IdentityManager.Authentication.CheckPasswordAndSignInAsync(
                       this.AuthenticationManager,
                        model.UserName,
                        model.Password,
                        model.RememberMe);
                if (result.Success)
                {
                    return this.RedirectToLocal(returnUrl);
                }
                else
                {
                    this.AddErrors(result);
                }
            }

            // If we got this far, something failed, redisplay form
            return this.View(model);
        }