public async Task<ActionResult> Index(UsersIndexViewModel viewModel)
{
if(GetUserRole() != "Admin")
{
return new HttpStatusCodeResult(HttpStatusCode.Forbidden);
}
var userRole = GetUserRole(viewModel.UserName);
if(viewModel.UserName == null)
{
userRole = null;
}
switch(userRole)
{
case "Admin":
return RedirectToAction("Index", "Users", new { msg = "err-admin" });
case "Creator":
return RedirectToAction("Index", "Users", new { msg = "err-no-promote" });
case "User":
var user = _userManager.Users.Where(u => u.UserName == viewModel.UserName).SingleOrDefault();
await _userManager.RemoveFromRoleAsync(user.Id, "User");
await _userManager.AddToRoleAsync(user.Id, "Creator");
return RedirectToAction("Index", "Users", new { msg = "msg-promote-success" });
default:
return RedirectToAction("Index", "Users", new { msg = "err-no-user" });
}
}
public async Task <IActionResult> Index(int page = 1, string filteredName = null, string filteredClientID = null, string filteredEmail = null)
{
int pageSize = 10;
IQueryable <ApplicationUser> source = db.Users;
if (!String.IsNullOrEmpty(filteredName))
{
source = source.Where(p => p.UserName.Contains(filteredName));
}
if (!String.IsNullOrEmpty(filteredClientID))
{
source = source.Where(p => p.ClientID.Contains(filteredClientID));
}
if (!String.IsNullOrEmpty(filteredEmail))
{
source = source.Where(p => p.Email.Contains(filteredEmail));
}
var count = await source.CountAsync();
var items = await source.Skip((page - 1) *pageSize).Take(pageSize).ToListAsync();
UsersIndexViewModel viewModel = new UsersIndexViewModel
{
PageViewModel = new PageViewModel(count, page, pageSize),
UsersFilterViewModel = new UsersFilterViewModel(filteredName, filteredClientID, filteredEmail),
Users = items
};
return(View(viewModel));
}
public async Task <IActionResult> Index(int page = 1, string PageFilter = "")
{
int pageSize = 5;
IQueryable <User> users = null;
if (!String.IsNullOrEmpty(PageFilter))
{
users = _userManager.Users.Where(x => x.Email.Contains(PageFilter));
}
else
{
users = _userManager.Users;
}
var count = await users.CountAsync();
var items = await users.Skip((page - 1) *pageSize).Take(pageSize).ToListAsync();
PageViewModel pageViewModel = new PageViewModel(count, page, pageSize);
UsersIndexViewModel viewModel = new UsersIndexViewModel
{
PageViewModel = pageViewModel,
Users = items,
FilterName = PageFilter
};
return(View(viewModel));
}
public async Task <ViewResult> Index()
{
var users = _appDbContext.Users.ToList();
var orders = _orderRepository.GetAll();
var ordersWithoutUsers = orders.Where(x => x.Registration == null);
var ordersWithUsers = orders.Where(x => x.Registration != null);
var usersThatOrdered = ordersWithUsers.Select(x => x.Registration).Distinct();
List <ApplicationUser> nonAdminUsers = new List <ApplicationUser>();
foreach (var user in users)
{
var isNonAdmin = !await _userManager.IsInRoleAsync(user, "Administrator");
if (isNonAdmin)
{
nonAdminUsers.Add(user);
}
}
var usersThatDidntOrder = nonAdminUsers.Where(x => usersThatOrdered.Count(y => y == x) == 0);
var vm = new UsersIndexViewModel
{
OrdersWithoutUsers = ordersWithoutUsers,
OrdersWithUsers = ordersWithUsers,
UsersThatOrdered = usersThatOrdered,
UsersThatDidntOrder = usersThatDidntOrder
};
return(View(vm));
}
// GET: Users
public IActionResult Index(UsersIndexViewModel model)
{
if (GlobalVar.LoggedOnUserId == -1)
{
return(RedirectToAction("LogInRequired", "Users"));
}
model.Pager ??= new PagerViewModel();
model.Pager.CurrentPage = model.Pager.CurrentPage <= 0 ? 1 : model.Pager.CurrentPage;
var allUsers = context.Users.ToList();
var contextDb = Filter(allUsers, model.Filter);
List <UsersViewModel> items = contextDb.Skip((model.Pager.CurrentPage - 1) * this.PageSize).Take(this.PageSize).Select(c => new UsersViewModel()
{
Id = c.Id,
Username = c.Username,
Password = c.Password,
FirstName = c.FirstName,
MiddleName = c.MiddleName,
LastName = c.LastName,
EGN = c.EGN,
Email = c.Email,
TelephoneNumber = c.TelephoneNumber,
DateOfBeingFired = c.DateOfBeingFired,
DateOfBeingHired = c.DateOfBeingHired
}).ToList();
model.Items = items;
model.Pager.PagesCount = Math.Max(1, (int)Math.Ceiling(contextDb.Count() / (double)this.PageSize));
return(View(model));
}
public ActionResult IndexFilterPOST(UsersIndexViewModel model)
{
return(RedirectToAction("Index", new RouteValueDictionary {
{ "Options.Filter", model.Options.Filter },
{ "Options.Order", model.Options.Order },
{ "Options.Search", model.Options.Search }
}));
}
public async Task <IActionResult> TableLockUser(UsersIndexViewModel model, string id)
{
await this.userService.LockUser(id);
this.TempData["Locked"] = "You Lock this user";
return(RedirectToAction("Index", "UserAdministration", model));
}
public async Task <IActionResult> Index()
{
var model = new UsersIndexViewModel()
{
Students = await GetBaseNonAdmins(), Admins = await GetBaseAdmins()
};
return(View(model));
}
public IActionResult Index()
{
var users = _userManager.Users;
var roles = _roleManager.Roles;
UsersIndexViewModel viewModel = new UsersIndexViewModel(users, roles);
return(View(viewModel));
}
public async Task <IActionResult> Index()
{
var vm = new UsersIndexViewModel
{
Users = await userRepository.GetAll()
};
return(View(vm));
}
public ActionResult Index()
{
var model = new UsersIndexViewModel();
var users = _managementUsersRepository.GetAll();
model.Users = users.Select(user => BuildUserViewModel(user)).ToList();
return(View(model));
}
public async Task <IActionResult> Index()
{
var users = await this.userService.GetAllUsers();
var userModels = users.Select(us => new UserViewModel(us));
var model = new UsersIndexViewModel()
{
Users = userModels
};
return(View(model));
}
// GET: /users
public ActionResult Index()
{
var model = new UsersIndexViewModel();
var response = this.userService.GetUsers(null);
if (response.Status == StatusCode.OK)
{
model.Users = response.Users.OrderBy(x => x.FirstName).ThenBy(x => x.LastName).ToList();
}
return(View(model));
}
// GET: /users
public ActionResult Index()
{
var model = new UsersIndexViewModel();
var response = this.userService.GetUsers(null);
if (response.Status == StatusCode.OK)
{
model.Users = response.Users.OrderBy(x => x.FirstName).ThenBy(x => x.LastName).ToList();
}
return View(model);
}
public IActionResult Index()
{
if (!this.User.Identity.IsAuthenticated)
{
return(this.Redirect("/Identity/Account/Login"));
}
var viewModel = new UsersIndexViewModel
{
People = this.profilesService.GetAll <IndexUserViewModel>(),
};
return(this.View(viewModel));
}
public ActionResult Index(FormCollection input)
{
if (!Services.Authorizer.Authorize(StandardPermissions.SiteOwner, T("Not authorized to manage users")))
{
return(new HttpUnauthorizedResult());
}
var viewModel = new UsersIndexViewModel {
Users = new List <UserEntry>(), Options = new UserIndexOptions()
};
UpdateModel(viewModel);
var checkedEntries = viewModel.Users.Where(c => c.IsChecked);
switch (viewModel.Options.BulkAction)
{
case UsersBulkAction.None:
break;
case UsersBulkAction.Approve:
foreach (var entry in checkedEntries)
{
Approve(entry.User.Id);
}
break;
case UsersBulkAction.Disable:
foreach (var entry in checkedEntries)
{
Moderate(entry.User.Id);
}
break;
case UsersBulkAction.ChallengeEmail:
foreach (var entry in checkedEntries)
{
SendChallengeEmail(entry.User.Id);
}
break;
case UsersBulkAction.Delete:
foreach (var entry in checkedEntries)
{
Delete(entry.User.Id);
}
break;
}
return(RedirectToAction("Index", ControllerContext.RouteData.Values));
}
public ActionResult Add(UsersIndexViewModel inputModel)
{
var model = new UsersIndexViewModel();
if (ModelState.IsValid)
{
Execute(new AddUserCommand(inputModel.Login, inputModel.Email, inputModel.Password));
ModelState.Clear();
}
model.Users = Execute(new GetUsersQuery());
ViewData.Model = model;
return RedirectToAction("Index");
}
public ActionResult Index()
{
var users = UserManager.Users.Select(x => new { x.Id, x.UserName, x.PhoneNumber, x.Email }).ToList();
var model = new UsersIndexViewModel()
{
Users = users.Select(x => new UserViewModel()
{
UserId = x.Id, UserName = x.UserName, Email = x.Email, PhoneNumber = x.PhoneNumber
}).ToList(),
UserResetPassword = new UserResetPasswordViewModel()
};
return(View(model));
}
public IActionResult Index(int?id)
{
if (id.HasValue)
{
return(RedirectToAction("Details", id.Value));
}
var users = _usersService.GetAllUsers();
var model = new UsersIndexViewModel
{
Users = users
};
return(View(model));
}
public IActionResult Index()
{
UsersIndexViewModel model = new UsersIndexViewModel()
{
Users = userService.GetAll().Select(u => new UserIndexViewModel()
{
Id = u.Id,
FirstName = u.FirstName,
LastName = u.LastName,
UserName = u.UserName,
IsAdmin = userService.IsAdmin(u)
}).ToList()
};
return(View(model));
}
public UsersIndex()
{
this.InitializeComponent();
usersIndexViewModel = new UsersIndexViewModel();
PageHelper.DoAsync(overlay, Dispatcher, () =>
{
usersIndexViewModel.LoadAllUsers();
PageHelper.MainUI(Dispatcher, () =>
{
this.DataGrid.DataContext = this.usersIndexViewModel.Users;
});
});
}
// GET: Users
public async Task <IActionResult> Index(UsersIndexViewModel model)
{
model.Pager = new PagerViewModel();
model.Pager.CurrentPage = model.Pager.CurrentPage <= 0 ? 1 : model.Pager.CurrentPage;
List <User> items = await _context.Users.Skip((model.Pager.CurrentPage - 1) *PageSize).
Take(PageSize).Select(u => new User()
{
Id = u.Id,
Email = u.Email,
FirstName = u.FirstName,
LastName = u.LastName,
Role = u.Role,
Team = u.Team
}).ToListAsync();
model.Items = items;
model.Pager.PagesCount = (int)Math.Ceiling(await _context.Users.CountAsync() / (double)PageSize);
return(View(model));
}
/// <summary>
/// Determina quais os utilizadores que serão mostrados ao user, dependendo do seu Role.
/// </summary>
/// <param name="users">Lista dos utilizadores a serem filtrados</param>
/// <returns>UsersIndexViewModel</returns>
private async Task <UsersIndexViewModel> PrepareIndexResponse(List <IdentityUser> users)
{
UsersIndexViewModel response = new UsersIndexViewModel()
{
AdminEmail = _appSettings.Email,
Users = new List <UserWithRoleViewModel>()
};
// Prencher os utilizadores e os seus roles
foreach (var user in users)
{
var roles = await _userManager.GetRolesAsync(user);
// Caso o utilizador seja admin, são mostrados todos os utilizadores
if (User.IsInRole("Admin"))
{
response.Users.Add(new UserWithRoleViewModel
{
User = user,
Roles = roles.ToList()
});
}
else
{
// Caso o utilizador não seja admin, não mostrar os administradores
if (!roles.Contains("Admin"))
{
response.Users.Add(new UserWithRoleViewModel
{
User = user,
Roles = roles.ToList()
});
}
}
}
return(response);
}
//GET : Users
public async Task <IActionResult> Index(UsersIndexViewModel model)
{
model.Pager ??= new PagerViewModel();
model.Pager.CurrentPage = model.Pager.CurrentPage <= 0 ? 1 : model.Pager.CurrentPage;
List <UsersViewModel> items = await _context.Users.Skip((model.Pager.CurrentPage - 1) *PageSize).Take(PageSize).Select(c => new UsersViewModel()
{
UserName = c.UserName,
Password = c.Password,
Email = c.Email,
FirstName = c.FirstName,
LastName = c.LastName,
EGN = c.EGN,
Address = c.Address,
PhoneNumber = c.PhoneNumber,
Role = c.Role
}).ToListAsync();
model.Items = items;
model.Pager.PagesCount = (int)Math.Ceiling(await _context.Users.CountAsync() / (double)PageSize);
return(View(model));
}
public IActionResult Index(string searchTerm, int page = 1)
{
UsersIndexViewModel viewModel = new UsersIndexViewModel();
int PageSize = settings.ItemsPerPage;
viewModel.Rows = db.Users.Where(x => x.Name.Contains(searchTerm) || x.Email.Contains(searchTerm) || string.IsNullOrEmpty(searchTerm)).Select(x => new UsersIndexViewModel.Row()
{
UserId = x.Id,
Email = x.Email,
Name = x.Name,
Age = x.Age,
NumberOfBlogsCreated = (int?)db.Blogs.Where(b => b.UserId == x.Id).Count() ?? 0
}).OrderBy(x => x.Name).Skip((page - 1) * PageSize).Take(PageSize).ToList();
viewModel.PaginationHelper = new Pagination()
{
ItemsPerPage = PageSize,
CurrentPage = page,
TotalItems = db.Users.Where(x => x.Name.Contains(searchTerm) || x.Email.Contains(searchTerm) || string.IsNullOrEmpty(searchTerm)).Count()
};
return(View(viewModel));
}
public async Task <ActionResult> Index(UserIndexOptions options, PagerParameters pagerParameters)
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageUsers))
{
return(Unauthorized());
}
var siteSettings = await _siteService.GetSiteSettingsAsync();
var pager = new Pager(pagerParameters, siteSettings.PageSize);
// default options
if (options == null)
{
options = new UserIndexOptions();
}
var users = _session.Query <User, UserIndex>();
switch (options.Filter)
{
case UsersFilter.Approved:
//users = users.Where(u => u.RegistrationStatus == UserStatus.Approved);
break;
case UsersFilter.Pending:
//users = users.Where(u => u.RegistrationStatus == UserStatus.Pending);
break;
case UsersFilter.EmailPending:
//users = users.Where(u => u.EmailStatus == UserStatus.Pending);
break;
}
if (!string.IsNullOrWhiteSpace(options.Search))
{
var normalizedSearchUserName = _userManager.NormalizeName(options.Search);
var normalizedSearchEMail = _userManager.NormalizeEmail(options.Search);
users = users.Where(u => u.NormalizedUserName.Contains(normalizedSearchUserName) || u.NormalizedEmail.Contains(normalizedSearchEMail));
}
switch (options.Order)
{
case UsersOrder.Name:
users = users.OrderBy(u => u.NormalizedUserName);
break;
case UsersOrder.Email:
users = users.OrderBy(u => u.NormalizedEmail);
break;
case UsersOrder.CreatedUtc:
//users = users.OrderBy(u => u.CreatedUtc);
break;
case UsersOrder.LastLoginUtc:
//users = users.OrderBy(u => u.LastLoginUtc);
break;
}
var count = await users.CountAsync();
var results = await users
.Skip(pager.GetStartIndex())
.Take(pager.PageSize)
.ListAsync();
// Maintain previous route data when generating page links
var routeData = new RouteData();
routeData.Values.Add("Options.Filter", options.Filter);
routeData.Values.Add("Options.Search", options.Search);
routeData.Values.Add("Options.Order", options.Order);
var pagerShape = (await New.Pager(pager)).TotalItemCount(count).RouteData(routeData);
var userEntries = new List <UserEntry>();
foreach (var user in results)
{
userEntries.Add(new UserEntry
{
Id = user.Id,
Shape = await _userDisplayManager.BuildDisplayAsync(user, updater: this, displayType: "SummaryAdmin")
}
);
}
var model = new UsersIndexViewModel
{
Users = userEntries,
Options = options,
Pager = pagerShape
};
model.Options.UserFilters = new List <SelectListItem>()
{
new SelectListItem()
{
Text = TH["All"].Value, Value = nameof(UsersFilter.All)
},
//new SelectListItem() { Text = TH["Approved"].Value, Value = nameof(UsersFilter.Approved) },
//new SelectListItem() { Text = TH["Email pending"].Value, Value = nameof(UsersFilter.EmailPending) },
//new SelectListItem() { Text = TH["Pending"].Value, Value = nameof(UsersFilter.Pending) }
};
model.Options.UserSorts = new List <SelectListItem>()
{
new SelectListItem()
{
Text = TH["Name"].Value, Value = nameof(UsersOrder.Name)
},
new SelectListItem()
{
Text = TH["Email"].Value, Value = nameof(UsersOrder.Email)
},
//new SelectListItem() { Text = TH["Created date"].Value, Value = nameof(UsersOrder.CreatedUtc) },
//new SelectListItem() { Text = TH["Last Login date"].Value, Value = nameof(UsersOrder.LastLoginUtc) }
};
model.Options.UsersBulkAction = new List <SelectListItem>()
{
new SelectListItem()
{
Text = TH["Approve"].Value, Value = nameof(UsersBulkAction.Approve)
},
new SelectListItem()
{
Text = TH["Enable"].Value, Value = nameof(UsersBulkAction.Enable)
},
new SelectListItem()
{
Text = TH["Disable"].Value, Value = nameof(UsersBulkAction.Disable)
},
new SelectListItem()
{
Text = TH["Delete"].Value, Value = nameof(UsersBulkAction.Delete)
}
};
return(View(model));
}
public IActionResult Index(int?page, string filter, int pageSize = 10)
{
int pageNumber = (page ?? 1);
UsersIndexViewModel model = new UsersIndexViewModel()
{
Users = userService.GetAllUsers().Select(u => new UserIndexViewModel
{
UserId = u.Id,
Address = u.Address,
FirstName = u.FirstName,
LastName = u.LastName,
Email = u.Email,
PhoneNumber = u.PhoneNumber,
SSN = u.SSN,
Username = u.UserName
}).ToList(),
Filter = filter,
PageNumber = pageNumber,
PageSize = pageSize,
PagesCount = (int)(Math.Ceiling(userService.GetUsersCount() / (double)pageSize))
};
switch (filter)
{
case "email":
model.Users = model.Users.OrderBy(u => u.Email).ToList();
break;
case "emailReversed":
model.Users = model.Users.OrderByDescending(u => u.Email).ToList();
break;
case "username":
model.Users = model.Users.OrderBy(u => u.Username).ToList();
break;
case "usernameReversed":
model.Users = model.Users.OrderByDescending(u => u.Username).ToList();
break;
case "firstName":
model.Users = model.Users.OrderBy(u => u.FirstName).ToList();
break;
case "firstNameReversed":
model.Users = model.Users.OrderByDescending(u => u.FirstName).ToList();
break;
case "lastName":
model.Users = model.Users.OrderBy(u => u.LastName).ToList();
break;
case "lastNameReversed":
model.Users = model.Users.OrderByDescending(u => u.LastName).ToList();
break;
}
model.Users = model.Users.Skip((pageNumber - 1) * pageSize).Take(pageSize).ToList();
return(View(model));
}
public ActionResult Index(UserIndexOptions options, PagerParameters pagerParameters)
{
if (!Services.Authorizer.Authorize(StandardPermissions.SiteOwner, T("Not authorized to list users")))
{
return(new HttpUnauthorizedResult());
}
var pager = new Pager(_siteService.GetSiteSettings(), pagerParameters);
// default options
if (options == null)
{
options = new UserIndexOptions();
}
var users = Services.ContentManager
.Query <UserPart, UserPartRecord>();
switch (options.Filter)
{
case UsersFilter.Approved:
users = users.Where(u => u.RegistrationStatus == UserStatus.Approved);
break;
case UsersFilter.Pending:
users = users.Where(u => u.RegistrationStatus == UserStatus.Pending);
break;
case UsersFilter.EmailPending:
users = users.Where(u => u.EmailStatus == UserStatus.Pending);
break;
}
if (!String.IsNullOrWhiteSpace(options.Search))
{
users = users.Where(u => u.UserName.Contains(options.Search) || u.Email.Contains(options.Search));
}
var pagerShape = Shape.Pager(pager).TotalItemCount(users.Count());
switch (options.Order)
{
case UsersOrder.Name:
users = users.OrderBy(u => u.UserName);
break;
case UsersOrder.Email:
users = users.OrderBy(u => u.Email);
break;
}
var results = users
.Slice(pager.GetStartIndex(), pager.PageSize)
.ToList();
var model = new UsersIndexViewModel {
Users = results
.Select(x => new UserEntry {
User = x.Record
})
.ToList(),
Options = options,
Pager = pagerShape
};
// maintain previous route data when generating page links
var routeData = new RouteData();
routeData.Values.Add("Options.Filter", options.Filter);
routeData.Values.Add("Options.Search", options.Search);
routeData.Values.Add("Options.Order", options.Order);
pagerShape.RouteData(routeData);
return(View(model));
}
// GET: Users
public async Task <IActionResult> Index(UsersIndexViewModel model)
{
if (GetCookie("LoggedIn") != "true")
{
return(Redirect("/"));
}
else
{
if (GetCookie("Username") != "HotelSysAdmin")
{
return(Redirect("/Menu/User_Menu"));
}
model.Pager ??= new PagerViewModel();
StringValues value = StringValues.Empty;
Request.Query.TryGetValue("page", out value);
model.Pager.CurrentPage = StringValues.IsNullOrEmpty(value) ? 1 : int.Parse(value);
value = StringValues.Empty;
Request.Query.TryGetValue("pagesize", out value);
model.Pager.PageSize = StringValues.IsNullOrEmpty(value) ? 10 : int.Parse(value);
model.Pager.PagesCount = (int)Math.Ceiling((double)_context.Users.ToArray().Length / (double)model.Pager.PageSize);
value = StringValues.Empty;
Request.Query.TryGetValue("sort", out value);
model.CurrentSort = StringValues.IsNullOrEmpty(value) ? 0 : int.Parse(value);
List <UsersViewModel> items = await _context.Users.Skip((model.Pager.CurrentPage - 1) *model.Pager.PageSize).Take(model.Pager.PageSize).Select(u => new UsersViewModel()
{
Id = u.Id,
Username = u.Username,
FirstName = u.FirstName,
MiddleName = u.MiddleName,
LastName = u.LastName,
PersonalID = u.PersonalID,
PhoneNumber = u.PhoneNumber,
DateAppointment = u.DateAppointment,
DateDismissal = u.DateDismissal,
Active = u.Active,
Email = u.Email
}).ToListAsync();
switch (model.CurrentSort)
{
case 1: //FirstName
model.Items = items.OrderBy(i => i.FirstName).ToList();
break;
case 2: //MiddleName
model.Items = items.OrderBy(i => i.MiddleName).ToList();
break;
case 3: //FamilyName
model.Items = items.OrderBy(i => i.LastName).ToList();
break;
case 4: //Email
model.Items = items.OrderBy(i => i.Email).ToList();
break;
default: //Usernames
model.Items = items.OrderBy(i => i.Username).ToList();
break;
}
return(View(model));
}
}
public async Task <IActionResult> Index(string searchString, string roleType)
{
if (!GetAuthorization(1, 'r'))
{
return(NotFound());
}
ViewBag.Permission = getPermissions();
var query = from usersJ in _context.Users
join rolesJ in _context.Roles on usersJ.RoleID equals rolesJ.RoleID
select new
{
UserID = usersJ.UserID,
Name = usersJ.Name,
Email = usersJ.Email,
ConfirmedEmail = usersJ.ConfirmedEmail,
RoleName = rolesJ.RoleName,
RoleID = rolesJ.RoleID,
CustomerID = usersJ.CustomerId
};
if (!String.IsNullOrEmpty(searchString))
{
query = query.Where(user => user.Name.Contains(searchString));
}
if (!String.IsNullOrEmpty(roleType))
{
query = query.Where(user => user.RoleName.Contains(roleType));
}
var result = query.ToList().Select(e => new Users
{
UserID = e.UserID,
Name = e.Name,
Email = e.Email,
ConfirmedEmail = e.ConfirmedEmail,
RoleName = e.RoleName,
RoleID = e.RoleID,
CustomerId = e.CustomerID
}).ToList();
var rolesTypesQuery = from roles in _context.Roles
orderby roles.RoleName
select roles.RoleName;
var usersIndexVM = new UsersIndexViewModel
{
Users = result,
RolesType = new SelectList(rolesTypesQuery.Distinct().ToList()),
};
Dictionary <int, string> dict = new Dictionary <int, string>();
StripeLib stripeLib = new StripeLib();
foreach (Users user in result)
{
try
{
dict.Add(user.UserID, stripeLib.GetSubscription(user.CustomerId));
}
catch (Exception ex)
{
dict.Add(user.UserID, "N/A");
}
}
ViewBag.Subscriptions = dict;
return(View(usersIndexVM));
}
public async Task <ActionResult> Index(UserIndexOptions options, PagerParameters pagerParameters)
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageUsers))
{
return(Unauthorized());
}
var siteSettings = await _siteService.GetSiteSettingsAsync();
var pager = new Pager(pagerParameters, siteSettings.PageSize);
// default options
if (options == null)
{
options = new UserIndexOptions();
}
var users = _session.QueryAsync <User, UserIndex>();
switch (options.Filter)
{
case UsersFilter.Approved:
//users = users.Where(u => u.RegistrationStatus == UserStatus.Approved);
break;
case UsersFilter.Pending:
//users = users.Where(u => u.RegistrationStatus == UserStatus.Pending);
break;
case UsersFilter.EmailPending:
//users = users.Where(u => u.EmailStatus == UserStatus.Pending);
break;
}
if (!string.IsNullOrWhiteSpace(options.Search))
{
users = users.Where(u => u.NormalizedUserName.Contains(options.Search) || u.NormalizedEmail.Contains(options.Search));
}
switch (options.Order)
{
case UsersOrder.Name:
users = users.OrderBy(u => u.NormalizedUserName);
break;
case UsersOrder.Email:
users = users.OrderBy(u => u.NormalizedEmail);
break;
case UsersOrder.CreatedUtc:
//users = users.OrderBy(u => u.CreatedUtc);
break;
case UsersOrder.LastLoginUtc:
//users = users.OrderBy(u => u.LastLoginUtc);
break;
}
var count = await users.Count();
var results = await users
.Skip(pager.GetStartIndex())
.Take(pager.PageSize)
.List();
// Maintain previous route data when generating page links
var routeData = new RouteData();
routeData.Values.Add("Options.Filter", options.Filter);
routeData.Values.Add("Options.Search", options.Search);
routeData.Values.Add("Options.Order", options.Order);
var pagerShape = New.Pager(pager).TotalItemCount(count).RouteData(routeData);
var model = new UsersIndexViewModel
{
Users = results
.Select(x => new UserEntry {
User = x
})
.ToList(),
Options = options,
Pager = pagerShape
};
return(View(model));
}
public ActionResult Index(UserIndexOptions options, PagerParameters pagerParameters)
{
if (!Services.Authorizer.Authorize(Permissions.ManageUsers, "Not authorized to list users"))
{
return(new HttpUnauthorizedResult());
}
var pager = new Pager(_siteService.GetSiteSettings(), pagerParameters);
// default options
if (options == null)
{
options = new UserIndexOptions();
}
var users = _userRepository.Table;
switch (options.Filter)
{
case UsersFilter.Approved:
users = users.Where(u => u.RegistrationStatus == UserStatus.Approved);
break;
case UsersFilter.Pending:
users = users.Where(u => u.RegistrationStatus == UserStatus.Pending);
break;
case UsersFilter.EmailPending:
users = users.Where(u => u.EmailStatus == UserStatus.Pending);
break;
}
if (!String.IsNullOrWhiteSpace(options.Search))
{
users = users.Where(u => u.UserName.Contains(options.Search) || u.Email.Contains(options.Search));
}
switch (options.Order)
{
case UsersOrder.Name:
users = users.OrderBy(u => u.UserName);
break;
case UsersOrder.Email:
users = users.OrderBy(u => u.Email);
break;
}
pager.Total = users.Count();
var results = users.Skip((pager.Page - 1) * pager.PageSize).Take(pager.PageSize)
.ToList();
var model = new UsersIndexViewModel
{
Users = results
.Select(x => new UserEntry {
User = x
})
.ToList(),
Options = options,
Pager = pager
};
// maintain previous route data when generating page links
var routeData = new RouteData();
routeData.Values.Add("Options.Filter", options.Filter);
routeData.Values.Add("Options.Search", options.Search);
routeData.Values.Add("Options.Order", options.Order);
pager.RouteData = routeData;
return(View(model));
}
