public async Task<ActionResult> Edit(EditUserViewModel model)
        {
            var Db = new ApplicationDbContext();
            var user = Db.Users.First(u => u.UserName == model.UserName);
            if (ModelState.IsValid)
            {
                model.PhotoUrl = Utils.SavePhotoFileToDisk(model.Photo, this, user.PhotoUrl, model.IsNoPhotoChecked);
                user.PhotoUrl = model.PhotoUrl;

                // Update the user data:
                user.FirstName = model.FirstName;
                user.LastName = model.LastName;
                user.Email = model.Email;
                Db.Entry(user).State = System.Data.Entity.EntityState.Modified;
                await Db.SaveChangesAsync();

                if (HttpContext.User.IsInRole("Admin"))
                {
                    return RedirectToAction("Index");
                }
                else
                {
                    return RedirectToAction("Edit", new { id = user.UserName, Message = ManageMessageId.RegisterSuccess });
                }
            }
            model.PhotoUrl = user.PhotoUrl;
            // If we got this far, something failed, redisplay form
            return View(model);
        }

 public ActionResult Edit(string id, ManageMessageId? Message = null)
 {
     var Db = new ApplicationDbContext();
     var user = Db.Users.First(u => u.UserName == id);
     var model = new EditUserViewModel(user);
     ViewBag.MessageId = Message;
     return View(model);
 }

        public ActionResult EditUser(string name, ManageMessageId? Message = null)
        {
            var user = this.ApplicationDbContext.Users.First(u => u.UserName == name);
            var model = new EditUserViewModel(user);

            ViewBag.MessageId = Message;
            ViewBag.Title = "Edit User";

            return View(model);
        }

        /// <summary>
        /// Saves the user.
        /// </summary>
        /// <param name="model">The model.</param>
        /// <returns>Json status result.</returns>
        public ActionResult SaveUser(EditUserViewModel model)
        {
            var response = GetCommand<SaveUserCommand>().ExecuteCommand(model);
            if (response != null)
            {
                Messages.AddSuccess(UsersGlobalization.SaveUser_CreatedSuccessfully_Message);
                return Json(new WireJson { Success = true, Data = response });
            }

            return Json(new WireJson { Success = false });
        }

 public ActionResult Delete(string id = null)
 {
     var Db = new ApplicationDbContext();
     var user = Db.Users.First(u => u.UserName == id);
     var model = new EditUserViewModel(user);
     if (user == null)
     {
         return HttpNotFound();
     }
     return View(model);
 }

 /// <summary>
 /// Returns a view model to show all accounts.
 /// </summary>
 /// <returns></returns>
 public ActionResult Index()
 {
     var Db = new ApplicationDbContext();
     var users = Db.Users;
     var model = new List<EditUserViewModel>();
     foreach (var user in users)
     {
         var u = new EditUserViewModel(user);
         model.Add(u);
     }
     return View(model);
 }

 public ActionResult Index()
 {
     //var users = UserManager.Users.Cast<List<EditUserViewModel>>().ToList();
     var db = new ApplicationDbContext();
     var users = db.Users;
     var model = new List<EditUserViewModel>();
     foreach (var user in users)
     {
         var u = new EditUserViewModel(user);
         model.Add(u);
     }
     return View(model);
 }

        public async Task<IActionResult> EditUser(EditUserViewModel viewModel)
        {
            if (!ModelState.IsValid)
            {
                return View(viewModel);
            }

            //Skill associations
            var user = GetUser(viewModel.UserId);
            user.AssociatedSkills.RemoveAll(usk => viewModel.AssociatedSkills == null || !viewModel.AssociatedSkills.Any(msk => msk.SkillId == usk.SkillId));

            if (viewModel.AssociatedSkills != null)
            {
                user.AssociatedSkills.AddRange(viewModel.AssociatedSkills.Where(msk => !user.AssociatedSkills.Any(usk => usk.SkillId == msk.SkillId)));
            }

            if (user.AssociatedSkills != null && user.AssociatedSkills.Count > 0)
            {
                user.AssociatedSkills.ForEach(usk => usk.UserId = user.Id);
            }

            await _mediator.SendAsync(new UpdateUser { User = user });

            var organizationAdminClaim = new Claim(Security.ClaimTypes.UserType, "OrgAdmin");
            if (viewModel.IsOrganizationAdmin)
            {
                //add organization admin claim
                var result = await _userManager.AddClaimAsync(user, organizationAdminClaim);
                if (result.Succeeded)
                {
                    //mgmccarthy: there is no Login action method on the AdminController. The only login method I could find is on the AccountController. Not too sure what to do here
                    var callbackUrl = Url.Action(new UrlActionContext { Action = "Login", Controller = "Admin", Values = new { Email = user.Email }, Protocol = HttpContext.Request.Scheme });
                    await _mediator.SendAsync(new SendAccountApprovalEmail { Email = user.Email, CallbackUrl = callbackUrl });
                }
                else
                {
                    return Redirect("Error");
                }
            }
            else if (user.IsUserType(UserType.OrgAdmin))
            {
                //remove organization admin claim
                var result = await _userManager.RemoveClaimAsync(user, organizationAdminClaim);
                if (!result.Succeeded)
                {
                    return Redirect("Error");
                }
            }

            return RedirectToAction(nameof(Index));
        }

        public ActionResult Index()
        {
            var companies = companyService.GetCompanies();
            var roles = roleService.GetRoles();
            EditUserViewModel editUser = new EditUserViewModel()
            {
                Roles = roles.ToList(),
                CompanyList = companies.ToList()
            };
            ViewData["companies"] = companies;
            ViewData["EditUser"] = editUser;
            return View();

        }

        public ActionResult Edit(string id, ManageMessageId? Message = null)
        {
            var Db = new ApplicationDbContext();
            var user = Db.Users.First(u => u.UserName == id);
            var model = new EditUserViewModel(user);
            ViewBag.MessageId = Message;
            
            var userprefer = Db.UserPreferences.Where(a => a.UserName == id).Select(x=> new {x.SchoolRefID,x.AcademicYearRefID}).FirstOrDefault();
            
            ViewBag.SchoolID = new SelectList(Db.Schools.AsNoTracking().Select(x => new { x.SchoolID, x.SchoolName }), "SchoolID", "SchoolName",userprefer.SchoolRefID);
            ViewBag.AcademicYearID = new SelectList(Db.AcademicYears.AsNoTracking().Where(a => a.SchoolRefID ==userprefer.SchoolRefID).Select(x => new { x.AcademicYearID, x.DisplayYear }), "AcademicYearID", "DisplayYear",userprefer.AcademicYearRefID);

            return View(model);
        }

        public ActionResult Index(string sortOrder, string searchString)
        {
            ViewBag.UsernameSortParam = String.IsNullOrEmpty(sortOrder) ? "username_asc" : "";
            ViewBag.NameSortParam = sortOrder == "first_asc" ? "first_desc" : "first_asc";
            ViewBag.LastSortParam = sortOrder == "last_asc" ? "last_desc" : "last_asc";

            var db = new ApplicationDbContext();
            var users = from u in db.Users
                        where u.Status != ApplicationUser.AccountStatus.Disabled
                        select u;

            if (!String.IsNullOrEmpty(searchString))
            {
                users = users.Where(u => u.LastName.Contains(searchString)
                                       || u.FirstName.Contains(searchString)
                                       && u.Status != ApplicationUser.AccountStatus.Disabled);
            }
            switch (sortOrder)
            {
                case "username_asc":
                    users = users.OrderBy(u => u.UserName);
                    break;
                case "first_desc":
                    users = users.OrderByDescending(u => u.FirstName);
                    break;
                case "last_desc":
                    users = users.OrderByDescending(u => u.LastName);
                    break;
                case "first_asc":
                    users = users.OrderBy(u => u.FirstName);
                    break;
                case "last_asc":
                    users = users.OrderBy(u => u.LastName);
                    break;
            }

            var model = new System.Collections.Generic.List<EditUserViewModel>();

            foreach (var user in users)
            {
                var u = new EditUserViewModel(user);
                model.Add(u);
            }
            return View(model);
        }

        public ActionResult Index(string userrole = null)
        {
            List<ApplicationUser> users;
            if (userrole != null)
            {
                users = _accountService.GetUsersByRole(userrole);
            }
            else
            {
                users = _accountService.GetAllUsers();
            }

            var model = new List<EditUserViewModel>();
            foreach (ApplicationUser user in users)
            {
                var u = new EditUserViewModel(user);
                model.Add(u);
            }
            return View(model);
        }

        public ActionResult Update([DataSourceRequest]DataSourceRequest request, EditUserViewModel user)
        {
            if (!ModelState.IsValid)
            {
                return this.View();
            }

            var currentUser = this.UserService.GetById(user.Id)
                                              .FirstOrDefault();

            if (currentUser == null)
            {
                return this.View();
            }

            currentUser.FirstName = user.FirstName;
            currentUser.LastName = user.LastName;
            currentUser.Email = user.Email;
            currentUser.UserName = user.UserName;

            this.UserService.UpdateUser(currentUser);
            return Json(new[] { user }.ToDataSourceResult(request, ModelState));
        }

        public ActionResult Edit(string id)
        {
            if (id == null)
            {
                return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
            }
            ViewBag.ALUMNOS = new SelectList(new PersonasRepository().GetAlumnos(), "ID", "PERSONA_NOMBRE_COMPLETO");
            ApplicationUser user = _repo.GetUser(id);

            var roleStore = new RoleStore<IdentityRole>(context);
            var roleManager = new RoleManager<IdentityRole>(roleStore);
            var userRoles = UserManager.GetRoles(id);
            ViewBag.USER_ROLES = roleStore.Roles.ToList().Select(x => new SelectListItem()
            {
                Selected = userRoles.Contains(x.Name),
                Text = x.Name,
                Value = x.Name
            });
            EditUserViewModel vm = new EditUserViewModel
            {
                Email = user.Email,
                UserName = user.UserName,
                USER_PERSONA_ID = user.USER_PERSONA_ID != null ? user.USER_PERSONA_ID.Value : 0,
            };

            return View(vm);
        }

 public ActionResult CreateUser()
 {
     var model = new EditUserViewModel { IsNewUser = true };
     return PartialView("EditUser", model);
 }

        //
        // GET: /Users/Edit/1
        public async Task<ActionResult> Edit(int id)
        {
            if (id == 0)
            {
                return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
            }
            var user = await UserManager.FindByIdAsync(id);
            if (user == null)
            {
                return HttpNotFound();
            }

            var userRoles = await UserManager.GetRolesAsync(user.Id);
           
            var model = new EditUserViewModel()
            {
                Id = user.Id,
                Email = user.Email,
                // Include the Addresss info:
                Address = user.Address,
                City = user.City,
                State = user.State,
                PostalCode = user.PostalCode,
                RolesList = RoleManager.Roles.Count() > 0 ? RoleManager.Roles.ToList().Select(x => new SelectListItem()
                {
                    Selected = userRoles.Contains(x.Name),
                    Text = x.Name,
                    Value = x.Name
                }) : null

            };

            return View(model);
        }

 public virtual ActionResult Delete(string id = null)
 {
     var user = _db.Users.First(u => u.UserName == id);
     var model = new EditUserViewModel(user);
     if (user == null)
     {
         return HttpNotFound();
     }
     return View(model);
 }

        public virtual async Task<ActionResult> Edit(EditUserViewModel model)
        {
            if (ModelState.IsValid)
            {
                var user = _db.Users.First(u => u.UserName == model.UserName);
                user.FirstName = model.FirstName;
                user.LastName = model.LastName;
                user.Email = model.Email;
                _db.Entry(user).State = System.Data.Entity.EntityState.Modified;
                await _db.SaveChangesAsync();
                return RedirectToAction("Index");
            }

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

 public virtual ActionResult Index()
 {
     var users = _db.Users;
     var model = new List<EditUserViewModel>();
     foreach (var user in users)
     {
         var u = new EditUserViewModel(user);
         model.Add(u);
     }
     return View(model);
 }

        //
        // GET: /Users/Edit/1
        public async Task<ActionResult> Edit(string id)
        {
            if (id == null)
            {
                return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
            }
            var user = await UserManager.FindByIdAsync(id);
            if (user == null)
            {
                return HttpNotFound();
            }

            var userRoles = await UserManager.GetRolesAsync(user.Id);

            var rlist = RoleManager.Roles.ToList().Select(x => new SelectListItem()
                        {
                            Selected = userRoles.Contains(x.Name),
                            Text = x.Name,
                            Value = x.Name
                        });

            var editModel = new EditUserViewModel(user.Id)
            {
                Id = user.Id,
                Email = user.Email,
                wNumber = user.wNumber,
                RolesList = RoleManager.Roles.ToList().Select(x => new SelectListItem()
                {
                    Selected = userRoles.Contains(x.Name),
                    Text = x.Name,
                    Value = x.Name
                })
            };

            return View(editModel);
        }