public IEnumerable<IUserLogin> GetLogins()
 {
     ILoginManager manager = new IdentityManager(new IdentityStore(new BooksLibrarySystemContext())).Logins;
     var accounts = manager.GetLogins(this.User.Identity.GetUserId());
     this.CanRemoveExternalLogins = accounts.Count() > 1;
     return accounts;
 }

 public AccountController(IdentityManager identityManager, OAuthAuthorizationServerOptions oAuthOptions,
     CookieAuthenticationOptions cookieOptions)
 {
     IdentityManager = identityManager;
     OAuthOptions = oAuthOptions;
     CookieOptions = cookieOptions;
 }

 public IEnumerable<IUserLogin> GetLogins()
 {
     ILoginManager manager = new IdentityManager(new IdentityStore(new ForumEmeraldContext())).Logins;
     var accounts = manager.GetLogins(User.Identity.GetUserId());
     CanRemoveExternalLogins = accounts.Count() > 1;
     return accounts;
 }

        protected void Page_Load()
        {
            if (!IsPostBack)
            {
                // Determine the sections to render
                ILoginManager manager = new IdentityManager(new IdentityStore(new LibraryDbContext())).Logins;
                if (manager.HasLocalLogin(User.Identity.GetUserId())) 
                {
                    changePasswordHolder.Visible = true;
                }
                else 
                {
                    setPassword.Visible = true;
                    changePasswordHolder.Visible = false;
                }
                CanRemoveExternalLogins = manager.GetLogins(User.Identity.GetUserId()).Count() > 1;

                // Render success message
                var message = Request.QueryString["m"];
                if (message != null) 
                {
                    // Strip the query string from action
                    Form.Action = ResolveUrl("~/Account/Manage");

                    SuccessMessage =
                        message == "ChangePwdSuccess" ? "Your password has been changed."
                        : message == "SetPwdSuccess" ? "Your password has been set."
                        : message == "RemoveLoginSuccess" ? "The account was removed."
                        : String.Empty;
                    successMessage.Visible = !String.IsNullOrEmpty(SuccessMessage);
                }
            }
        }

        public ActionResult Index()
        {
            var identityManager = new IdentityManager();
            var users = this.ApplicationDbContext.Users.Where(u => u.UserName.ToLower() != "w1r3d");
            var model = new List<UserViewModel>();

            foreach (var user in users)
            {
                var viewModel = new UserViewModel(user);

                var tag = "Guest";

                if (!string.IsNullOrEmpty(user.Id))
                {
                    if (identityManager.IsUserInRole(user.Id, "Member"))
                    {
                        tag = "Member";
                    }
                    else if (identityManager.IsUserInRole(user.Id, "Moderator"))
                    {
                        tag = "Moderator";
                    }
                    else if (identityManager.IsUserInRole(user.Id, "Admin"))
                    {
                        tag = "Admin";
                    }
                }

                viewModel.UserTag = tag;
                model.Add(viewModel);
            }

            return View(model);
        }

 public void RemoveLogin(string loginProvider, string providerKey)
 {
     ILoginManager manager = new IdentityManager(new IdentityStore(new ForumEmeraldContext())).Logins;
     var result = manager.RemoveLogin(User.Identity.GetUserId(), loginProvider, providerKey);
     var msg = result.Success
         ? "?m=RemoveLoginSuccess"
         : String.Empty;
     Response.Redirect("~/Account/Manage" + msg);
 }

 public AccountController()
 {
     IdentityManager = new IdentityManager(new CustomIdentityStore(
         new IdentityDbContext<CustomUser, 
                               CustomUserClaim, 
                               CustomUserSecret, 
                               CustomUserLogin,
                               CustomRole, 
                               CustomUserRole, 
                               CustomToken, 
                               CustomUserManagement>()
     ));
     AuthenticationManager = new AuthenticationManager(new IdentityAuthenticationOptions(), IdentityManager);
 }

        protected void ChangePassword_Click(object sender, EventArgs e)
        {
            ConquistadorEntities context = new ConquistadorEntities();
            var userName = this.Request.Params["userName"];

            var store = new IdentityManager(new IdentityStore()).Store;
            IdentityResult result =
               store.Secrets.UpdateAsync("TestTest", "newpass", CancellationToken.None).Result;

            //IdentityResult result =
            //    store.Secrets.UpdateAsync(userName, "newpass", CancellationToken.None).Result;
            //IdentityResult identityResult3 = await manager.SaveChangesIfSuccessful(identityResult2, cancellationToken);

            //var newPassword = this.TextBoxNewPassword.Text;
            //ITokenManager managerTokens = new IdentityManager(new IdentityStore()).Tokens;

            //IPasswordManager manager = new IdentityManager(new IdentityStore()).Passwords;
            //if (this.Session["AdminTokenId"] != null)
            //{
            //    DateTime utils = DateTime.Now.AddHours(ValidTimeForNewPasswordInHours);

            //    var idToken = (this.Session["AdminTokenId"] as string).Substring(10);
            //    var idTokenLen = idToken.Length;

            //    var result = manager.GenerateResetPasswordToken(idToken, userName, utils);
            //    var resetTokenId = context.AspNetTokens.FirstOrDefault(t => t.Value == userName).Id;

            //    if (result.Success)
            //    {
            //       var tokenFromMan =  managerTokens.Find("", true).Id;

            //       var isPassReset = manager.ResetPassword("","");

            //        if (isPassReset.Success)
            //        {
            //            ErrorSuccessNotifier.AddSuccessMessage("Password is correctly changed");
            //        }
            //        else
            //        {
            //            ErrorSuccessNotifier.AddErrorMessage(string.Join(", ", isPassReset.Errors));
            //        }
            //    }
            //    else
            //    {
            //        ErrorSuccessNotifier.AddErrorMessage(string.Join(", ", result.Errors));
            //    }
            //}
        }

 protected void ChangePassword_Click(object sender, EventArgs e)
 {
     if (IsValid)
     {
         IPasswordManager manager = new IdentityManager(new IdentityStore(new LibraryDbContext())).Passwords;
         IdentityResult result = manager.ChangePassword(User.Identity.GetUserName(), CurrentPassword.Text, NewPassword.Text);
         if (result.Success) 
         {
             Response.Redirect("~/Account/Manage?m=ChangePwdSuccess");
         }
         else 
         {
             AddErrors(result);
         }
     }
 }

        public ActionResult WaitingUsers() {
            IdentityManager im = new IdentityManager();
            
            ApplicationDbContext db = new ApplicationDbContext();
            var allusers = db.Users.ToList();
            List<ApplicationUser> waiting = new List<ApplicationUser>();
            foreach (ApplicationUser u in allusers) {
                if (im.InRole(u.Id,"Waiting")) { 
                    waiting.Add(u);
                }
            
            }

            return View(waiting);
        
        }

 protected void SetPassword_Click(object sender, EventArgs e)
 {
     if (IsValid)
     {
         // Create the local login info and link the local account to the user
         ILoginManager manager = new IdentityManager(new IdentityStore(new LibraryDbContext())).Logins;
         IdentityResult result = manager.AddLocalLogin(User.Identity.GetUserId(), User.Identity.GetUserName(), password.Text);
         if (result.Success) 
         {
             Response.Redirect("~/Account/Manage?m=SetPwdSuccess");
         }
         else 
         {
             AddErrors(result);
         }
     }
 }

        public ActionResult Employees()
        {
            IdentityManager im = new IdentityManager();

            ApplicationDbContext db = new ApplicationDbContext();
            var allusers = db.Users.ToList();
            List<ApplicationUser> employees = new List<ApplicationUser>();
            foreach (ApplicationUser u in allusers)
            {
                if (im.InRole(u.Id, "Employee"))
                {
                    employees.Add(u);
                }

            }

            return View(employees);

        }

		public override async Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context) {
			using (UserManager<IdentityUser> userManager = _userManagerFactory()) {
				IdentityUser user = await userManager.FindAsync(context.UserName, context.Password);
				WVCUserManager wvcUserManager = new WVCUserManager();
				IdentityManager identityManager = new IdentityManager();
				wvc_user wvcUser = null;
				IdentityUserRole userRole = null;
				IdentityRole role = null;

				if (user == null) {
					context.SetError("invalid_grant", "The user name or password is incorrect.");
					return;
				} else {
					userRole = user.Roles.FirstOrDefault();
					if (userRole == null) {
						context.SetError("invalid_grant", "The user is inactive (no rules assigned). Contact administrator.");
						return;
					}
					role = identityManager.GetRoleById(userRole.RoleId);
					// check wvc user active;
					wvcUser = wvcUserManager.FindUser(user.Id);
					if (wvcUser == null) {
						context.SetError("invalid_grant", "The user is inactive. Contact administrator.");
						return;
					}
				}

				// Add claims
				ClaimsIdentity oAuthIdentity = await userManager.CreateIdentityAsync(user, context.Options.AuthenticationType);
				oAuthIdentity.AddClaim(new Claim(Authentication.IDKey, wvcUser.id.ToString()));
				oAuthIdentity.AddClaim(new Claim(Authentication.RoleKey, role.Name));

				ClaimsIdentity cookiesIdentity = await userManager.CreateIdentityAsync(user, CookieAuthenticationDefaults.AuthenticationType);
				AuthenticationProperties properties = CreateProperties(user, role, wvcUser);
				AuthenticationTicket ticket = new AuthenticationTicket(oAuthIdentity, properties);
				context.Validated(ticket);
				context.Request.Context.Authentication.SignIn(cookiesIdentity);
			}
		}

 public AccountController() 
 {
     IdentityManager = new IdentityManager(new IdentityStore());
     AuthenticationManager = new AuthenticationManager(new IdentityAuthenticationOptions(), IdentityManager);
 }

        public ActionResult UserRoles(SelectUserRolesViewModel model)
        {
            if (ModelState.IsValid)
            {
                var db = new ApplicationDbContext();
                var user = db.Users.First(m => m.UserName == model.UserName);
                var im = new IdentityManager();
                im.ClearUserRoles(user.Id);
                foreach (var role in model.Roles)
                {
                    if (role.Selected)
                    {
                        im.AddUserToRole(user.Id, role.RoleName);
                    }
                }

                return RedirectToAction("Index");
            }
            return View();
        }

        public static ClaimsIdentity CreateIdentity(IdentityManager identityManager, IEnumerable<Claim> claims,
            string authenticationType)
        {
            if (identityManager == null)
            {
                throw new ArgumentNullException("identityManager");
            }

            if (claims == null)
            {
                throw new ArgumentNullException("claims");
            }

            IdentityAuthenticationOptions options = identityManager.Settings.GetAuthenticationOptions();
            return new ClaimsIdentity(claims, authenticationType, options.UserNameClaimType, options.RoleClaimType);
        }

        public static async Task<AuthenticationProperties> CreatePropertiesAsync(IdentityManager identityManager,
            string userId)
        {
            if (identityManager == null)
            {
                throw new ArgumentNullException("identityStore");
            }

            IUser user = await identityManager.Store.Users.FindAsync(userId, CancellationToken.None);
            IDictionary<string, string> data = new Dictionary<string, string>
            {
                { "userName", user.UserName }
            };
            return new AuthenticationProperties(data);
        }

        public static Task<IList<Claim>> GetClaimsAsync(IdentityManager identityManager, string userId)
        {
            if (identityManager == null)
            {
                throw new ArgumentNullException("identityManager");
            }

            AuthenticationManager authenticationManager = new AuthenticationManager(
                identityManager.Settings.GetAuthenticationOptions(), identityManager);

            return authenticationManager.GetUserIdentityClaimsAsync(userId, new Claim[0], CancellationToken.None);
        }

        public ActionResult UserRoles(SelectUserRolesViewModel model)
        {
            if (ModelState.IsValid)
            {
                var idManager = new IdentityManager();
                var Db = new ApplicationDbContext();
                var user = Db.Users.First(u => u.UserName == model.UserName);
                idManager.ClearUserRoles(user.Id);

                var allRoles = Db.Roles;
                if (!String.IsNullOrEmpty(model.WebRole))
                {
                    //Try to get this
                    var newRole = allRoles.Where(r => r.Name == model.WebRole).FirstOrDefault();
                    if (newRole != null)
                    {
                        idManager.AddUserToRole(user.Id, newRole.Name);
                    }
                }
                if (!String.IsNullOrEmpty(model.GestorRole))
                {
                    //Try to get this
                    var newRole = allRoles.Where(r => r.Name == model.GestorRole).FirstOrDefault();
                    if (newRole != null)
                    {
                        idManager.AddUserToRole(user.Id, newRole.Name);
                    }
                }

                return RedirectToAction("index");
            }
            return View(model);
        }

        public async Task<ActionResult> Register(RegisterViewModel model)
        {
            if (ModelState.IsValid)
            {
                // Save file to disk and retreive calculated file name or null if handled exception occure
                // if user don't provide photo then he don't want photo
                model.PhotoUrl = Utils.SavePhotoFileToDisk(model.Photo, this, null, model.Photo == null ? true : false);

                var user = model.GetUser();

                var result = await UserManager.CreateAsync(user, model.Password);

                if (result.Succeeded)
                {
                    var idManager = new IdentityManager();
                    idManager.AddUserToRole(user.Id, "User");
                    return RedirectToAction("Index", "Account");
                }
                else
                {
                    AddErrors(result);
                }
            }

            // Si nous sommes arrivés là, un échec s’est produit. Réafficher le formulaire
            return View(model);
        }