private async Task <UserIndexViewModel> GetIndexViewModel(UserIndexOptions options, PagerOptions pager)
{
// Get results
var results = await _userService
.ConfigureQuery(q =>
{
// We are not within edit mode
// Hide spam and banned users
if (!options.EnableEdit)
{
q.HideSpam.True();
q.HideBanned.True();
}
})
.GetResultsAsync(options, pager);
// Set total on pager
pager.SetTotal(results?.Total ?? 0);
// Return view model
return(new UserIndexViewModel
{
Results = results,
Options = options,
Pager = pager
});
}
public async Task <ActionResult> IndexPOST(UserIndexOptions options, IEnumerable <int> itemIds)
{
if (itemIds?.Count() > 0)
{
var checkedContentItems = await _session.Query <User, UserIndex>().Where(x => x.DocumentId.IsIn(itemIds)).ListAsync();
switch (options.BulkAction)
{
case UsersBulkAction.None:
break;
case UsersBulkAction.Approve:
foreach (var item in checkedContentItems)
{
var token = await _userManager.GenerateEmailConfirmationTokenAsync(item);
await _userManager.ConfirmEmailAsync(item, token);
_notifier.Success(TH["User {0} successfully approved.", item.UserName]);
}
break;
case UsersBulkAction.Delete:
foreach (var item in checkedContentItems)
{
await _userManager.DeleteAsync(item);
_notifier.Success(TH["User {0} successfully deleted.", item.UserName]);
}
break;
case UsersBulkAction.Disable:
foreach (var item in checkedContentItems)
{
item.IsEnabled = false;
await _userManager.UpdateAsync(item);
_notifier.Success(TH["User {0} successfully disabled.", item.UserName]);
}
break;
case UsersBulkAction.Enable:
foreach (var item in checkedContentItems)
{
item.IsEnabled = true;
await _userManager.UpdateAsync(item);
_notifier.Success(TH["User {0} successfully enabled.", item.UserName]);
}
break;
default:
throw new ArgumentOutOfRangeException();
}
}
return(RedirectToAction("Index"));
}
public async Task <IQuery <User> > QueryAsync(UserIndexOptions options, IUpdateModel updater)
{
// Because admin filters can add a different index to the query this must be added as a Query<User>()
var query = _session.Query <User>();
query = await options.FilterResult.ExecuteAsync(new UserQueryContext(_serviceProvider, query));
return(query);
}
public async Task <IViewComponentResult> InvokeAsync(UserIndexOptions options, PagerOptions pager)
{
if (options == null)
{
options = new UserIndexOptions();
}
if (pager == null)
{
pager = new PagerOptions();
}
return(View(await GetIndexViewModel(options, pager)));
}
public async Task <IPagedResults <TModel> > GetResultsAsync(
UserIndexOptions options,
PagerOptions pager)
{
return(await _platoUserStore.QueryAsync()
.Configure(_configureDb)
.Take(pager.Page, pager.Size)
.Select <UserQueryParams>(q =>
{
switch (options.Filter)
{
case FilterBy.Confirmed:
q.ShowConfirmed.True();
break;
case FilterBy.Unconfirmed:
q.HideConfirmed.True();
break;
case FilterBy.Verified:
q.ShowVerified.True();
break;
case FilterBy.Staff:
q.ShowStaff.True();
break;
case FilterBy.Spam:
q.ShowSpam.True();
break;
case FilterBy.Banned:
q.ShowBanned.True();
break;
}
if (!string.IsNullOrEmpty(options.Search))
{
q.Keywords.Like(options.Search);
}
// ----------------
// Additional parameter configuration
// ----------------
_configureParams?.Invoke(q);
})
.OrderBy(options.Sort.ToString(), options.Order)
.ToList());
}
public async Task <ActionResult> IndexFilterPOST(UserIndexOptions options)
{
// When the user has typed something into the search input no further evaluation of the form post is required.
if (!String.Equals(options.SearchText, options.OriginalSearchText, StringComparison.OrdinalIgnoreCase))
{
return(RedirectToAction(nameof(Index), new RouteValueDictionary {
{ "q", options.SearchText }
}));
}
// Evaluate the values provided in the form post and map them to the filter result and route values.
await _userOptionsDisplayManager.UpdateEditorAsync(options, _updateModelAccessor.ModelUpdater, false);
// The route value must always be added after the editors have updated the models.
options.RouteValues.TryAdd("q", options.FilterResult.ToString());
return(RedirectToAction(nameof(Index), options.RouteValues));
}
private async Task <UserIndexViewModel> GetIndexViewModel(UserIndexOptions options, PagerOptions pager)
{
var results = await _userService
.ConfigureQuery(async q =>
{
// Hide unconfirmed?
if (!await _authorizationService.AuthorizeAsync(HttpContext.User,
Permissions.ViewUnconfirmedUsers))
{
q.HideUnconfirmed.True();
}
// Hide SPAM?
if (!await _authorizationService.AuthorizeAsync(HttpContext.User,
Permissions.ViewSpamUsers))
{
q.HideSpam.True();
}
// Hide Banned?
if (!await _authorizationService.AuthorizeAsync(HttpContext.User,
Permissions.ViewBannedUsers))
{
q.HideBanned.True();
}
})
.GetResultsAsync(options, pager);
// Set total on pager
pager.SetTotal(results?.Total ?? 0);
// Return view model
return(new UserIndexViewModel
{
SortColumns = _defaultSortColumns,
SortOrder = _defaultSortOrder,
Filters = _defaultFilters,
Results = results,
Options = options,
Pager = pager
});
}
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(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));
}
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));
}
// --------------
// Manage Users
// --------------
public async Task <IActionResult> Index(int offset, UserIndexOptions opts, PagerOptions pager)
{
// Ensure we have permission
if (!await _authorizationService.AuthorizeAsync(HttpContext.User,
Permissions.ManageUsers))
{
return(Unauthorized());
}
// default options
if (opts == null)
{
opts = new UserIndexOptions();
}
// default pager
if (pager == null)
{
pager = new PagerOptions();
}
// Set pager call back Url
pager.Url = _contextFacade.GetRouteUrl(pager.Route(RouteData));
// Get default options
var defaultViewOptions = new UserIndexOptions();
var defaultPagerOptions = new PagerOptions();
// Add non default route data for pagination purposes
if (opts.Search != defaultViewOptions.Search)
{
RouteData.Values.Add("opts.search", opts.Search);
}
if (opts.Sort != defaultViewOptions.Sort)
{
RouteData.Values.Add("opts.sort", opts.Sort);
}
if (opts.Order != defaultViewOptions.Order)
{
RouteData.Values.Add("opts.order", opts.Order);
}
if (pager.Page != defaultPagerOptions.Page)
{
RouteData.Values.Add("pager.page", pager.Page);
}
if (pager.Size != defaultPagerOptions.Size)
{
RouteData.Values.Add("pager.size", pager.Size);
}
// Enable edit options for admin view
opts.EnableEdit = true;
var viewModel = new UserIndexViewModel()
{
Options = opts,
Pager = pager
};
// Add view options to context for use within view adapters
HttpContext.Items[typeof(UserIndexViewModel)] = viewModel;
// If we have a pager.page querystring value return paged results
if (int.TryParse(HttpContext.Request.Query["pager.page"], out var page))
{
if (page > 0)
{
return(View("GetUsers", viewModel));
}
}
// Build breadcrumb
_breadCrumbManager.Configure(builder =>
{
builder.Add(S["Home"], home => home
.Action("Index", "Admin", "Plato.Admin")
.LocalNav()
).Add(S["Users"]);
});
// Return view
return(View((LayoutViewModel)await _viewProvider.ProvideIndexAsync(new User(), this)));
}
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));
}
public ActionResult Index(int?role, string username, UserIndexOptions options, PagerParameters pagerParameters)
{
var pager = new Pager(_siteService.GetSiteSettings(), pagerParameters);
var userItems = new List <UserItemViewModel>();
int userTotal;
var skip = pager.Page > 0 ? (pager.Page - 1) * pager.PageSize : 0;
var take = pager.PageSize == 0 ? int.MaxValue : pager.PageSize;
using (var connection = new SqlConnection(_shellSettings.DataConnectionString))
{
connection.Open();
using (var transaction = connection.BeginTransaction())
{
using (var command = connection.CreateCommand())
{
command.Transaction = transaction;
command.CommandType = CommandType.StoredProcedure;
command.CommandText = "GetUsers";
if (role.HasValue)
{
var roleIdParameter = new SqlParameter("@RoleId", SqlDbType.Int)
{
Value = role.Value
};
command.Parameters.Add(roleIdParameter);
}
if (!string.IsNullOrWhiteSpace(username))
{
var usernameParameter = new SqlParameter("@UserName", SqlDbType.NVarChar)
{
Value = username
};
command.Parameters.Add(usernameParameter);
}
var skipParameter = new SqlParameter("@Skip", SqlDbType.Int)
{
Value = skip
};
var takeParameter = new SqlParameter("@Take", SqlDbType.Int)
{
Value = take
};
command.Parameters.Add(skipParameter);
command.Parameters.Add(takeParameter);
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
var userItemViewModel = new UserItemViewModel
{
Email = (!(reader["UserName"] is DBNull)) ? (string)reader["UserName"] : "",
UserId = (!(reader["UserId"] is DBNull)) ? (int)reader["UserId"] : 0,
IsTeeyootUser = (!(reader["IsTeeyootUser"] is DBNull)) ? (bool)reader["IsTeeyootUser"] : false
};
if (reader["CurrencyName"] != DBNull.Value)
{
userItemViewModel.Currency = (reader["CurrencyName"] is DBNull) ? (string)reader["CurrencyName"] : "";
}
userItems.Add(userItemViewModel);
}
}
}
using (var command = connection.CreateCommand())
{
command.Transaction = transaction;
command.CommandType = CommandType.StoredProcedure;
command.CommandText = "GetUsersCount";
if (role.HasValue)
{
var roleIdParameter = new SqlParameter("@RoleId", SqlDbType.Int)
{
Value = role.Value
};
command.Parameters.Add(roleIdParameter);
}
userTotal = (int)command.ExecuteScalar();
}
FillUsersWithRoles(userItems, transaction);
transaction.Commit();
}
}
var pagerShape = Shape.Pager(pager).TotalItemCount(userTotal);
var roles = _roleRepository.Table
.Select(r => new RoleItemViewModel
{
Id = r.Id,
Name = r.Name
})
.ToList();
var viewModel = new AdminUserIndexViewModel
{
Roles = roles,
SelectedRoleId = role,
Users = userItems,
Pager = pagerShape
};
return(View(viewModel));
}
public async Task <ActionResult> Index([ModelBinder(BinderType = typeof(UserFilterEngineModelBinder), Name = "q")] QueryFilterResult <User> queryFilterResult, PagerParameters pagerParameters)
{
// Check a dummy user account to see if the current user has permission to view users.
var authUser = new User();
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ViewUsers, authUser))
{
return(Forbid());
}
var options = new UserIndexOptions();
// Populate route values to maintain previous route data when generating page links
// await _userOptionsDisplayManager.UpdateEditorAsync(options, _updateModelAccessor.ModelUpdater, false);
options.FilterResult = queryFilterResult;
options.FilterResult.MapTo(options);
// With the options populated we filter the query, allowing the filters to alter the options.
var users = await _usersAdminListQueryService.QueryAsync(options, _updateModelAccessor.ModelUpdater);
// The search text is provided back to the UI.
options.SearchText = options.FilterResult.ToString();
options.OriginalSearchText = options.SearchText;
// Populate route values to maintain previous route data when generating page links.
options.RouteValues.TryAdd("q", options.FilterResult.ToString());
var routeData = new RouteData(options.RouteValues);
var siteSettings = await _siteService.GetSiteSettingsAsync();
var pager = new Pager(pagerParameters, siteSettings.PageSize);
var count = await users.CountAsync();
var results = await users
.Skip(pager.GetStartIndex())
.Take(pager.PageSize)
.ListAsync();
var pagerShape = (await New.Pager(pager)).TotalItemCount(count).RouteData(routeData);
var userEntries = new List <UserEntry>();
foreach (var user in results)
{
userEntries.Add(new UserEntry
{
UserId = user.UserId,
Shape = await _userDisplayManager.BuildDisplayAsync(user, updater: _updateModelAccessor.ModelUpdater, displayType: "SummaryAdmin")
}
);
}
options.UserFilters = new List <SelectListItem>()
{
new SelectListItem()
{
Text = S["All Users"], Value = nameof(UsersFilter.All), Selected = (options.Filter == UsersFilter.All)
},
new SelectListItem()
{
Text = S["Enabled Users"], Value = nameof(UsersFilter.Enabled), Selected = (options.Filter == UsersFilter.Enabled)
},
new SelectListItem()
{
Text = S["Disabled Users"], Value = nameof(UsersFilter.Disabled), Selected = (options.Filter == UsersFilter.Disabled)
}
//new SelectListItem() { Text = S["Approved"], Value = nameof(UsersFilter.Approved) },
//new SelectListItem() { Text = S["Email pending"], Value = nameof(UsersFilter.EmailPending) },
//new SelectListItem() { Text = S["Pending"], Value = nameof(UsersFilter.Pending) }
};
options.UserSorts = new List <SelectListItem>()
{
new SelectListItem()
{
Text = S["Name"], Value = nameof(UsersOrder.Name), Selected = (options.Order == UsersOrder.Name)
},
new SelectListItem()
{
Text = S["Email"], Value = nameof(UsersOrder.Email), Selected = (options.Order == UsersOrder.Email)
},
//new SelectListItem() { Text = S["Created date"], Value = nameof(UsersOrder.CreatedUtc) },
//new SelectListItem() { Text = S["Last Login date"], Value = nameof(UsersOrder.LastLoginUtc) }
};
options.UsersBulkAction = new List <SelectListItem>()
{
new SelectListItem()
{
Text = S["Approve"], Value = nameof(UsersBulkAction.Approve)
},
new SelectListItem()
{
Text = S["Enable"], Value = nameof(UsersBulkAction.Enable)
},
new SelectListItem()
{
Text = S["Disable"], Value = nameof(UsersBulkAction.Disable)
},
new SelectListItem()
{
Text = S["Delete"], Value = nameof(UsersBulkAction.Delete)
}
};
var allRoles = (await _roleService.GetRoleNamesAsync())
.Except(new[] { "Anonymous", "Authenticated" }, StringComparer.OrdinalIgnoreCase);
options.UserRoleFilters = new List <SelectListItem>()
{
new SelectListItem()
{
Text = S["All roles"], Value = String.Empty, Selected = (options.SelectedRole == String.Empty)
},
new SelectListItem()
{
Text = S["Authenticated (no roles)"], Value = "Authenticated", Selected = (String.Equals(options.SelectedRole, "Authenticated", StringComparison.OrdinalIgnoreCase))
}
};
// TODO Candidate for dynamic localization.
options.UserRoleFilters.AddRange(allRoles.Select(x => new SelectListItem {
Text = x, Value = x, Selected = (String.Equals(options.SelectedRole, x, StringComparison.OrdinalIgnoreCase))
}));
// Populate options pager summary values.
var startIndex = (pagerShape.Page - 1) * (pagerShape.PageSize) + 1;
options.StartIndex = startIndex;
options.EndIndex = startIndex + userEntries.Count - 1;
options.UsersCount = userEntries.Count;
options.TotalItemCount = pagerShape.TotalItemCount;
var header = await _userOptionsDisplayManager.BuildEditorAsync(options, _updateModelAccessor.ModelUpdater, false);
var shapeViewModel = await _shapeFactory.CreateAsync <UsersIndexViewModel>("UsersAdminList", viewModel =>
{
viewModel.Users = userEntries;
viewModel.Pager = pagerShape;
viewModel.Options = options;
viewModel.Header = header;
});
return(View(shapeViewModel));
}
public async Task <ActionResult> IndexPOST(UserIndexOptions options, IEnumerable <string> itemIds)
{
// Check a dummy user account to see if the current user has permission to manage it.
var authUser = new User();
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageUsers, authUser))
{
return(Forbid());
}
if (itemIds?.Count() > 0)
{
var checkedUsers = await _session.Query <User, UserIndex>().Where(x => x.UserId.IsIn(itemIds)).ListAsync();
// Bulk actions require the ManageUsers permission on all the checked users.
// To prevent html injection we authorize each user before performing any operations.
foreach (var user in checkedUsers)
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageUsers, user))
{
return(Forbid());
}
}
switch (options.BulkAction)
{
case UsersBulkAction.None:
break;
case UsersBulkAction.Approve:
foreach (var user in checkedUsers)
{
if (!await _userManager.IsEmailConfirmedAsync(user))
{
var token = await _userManager.GenerateEmailConfirmationTokenAsync(user);
await _userManager.ConfirmEmailAsync(user, token);
await _notifier.SuccessAsync(H["User {0} successfully approved.", user.UserName]);
}
}
break;
case UsersBulkAction.Delete:
foreach (var user in checkedUsers)
{
if (String.Equals(user.UserId, User.FindFirstValue(ClaimTypes.NameIdentifier), StringComparison.OrdinalIgnoreCase))
{
continue;
}
await _userManager.DeleteAsync(user);
await _notifier.SuccessAsync(H["User {0} successfully deleted.", user.UserName]);
}
break;
case UsersBulkAction.Disable:
foreach (var user in checkedUsers)
{
if (String.Equals(user.UserId, User.FindFirstValue(ClaimTypes.NameIdentifier), StringComparison.OrdinalIgnoreCase))
{
continue;
}
user.IsEnabled = false;
await _userManager.UpdateAsync(user);
await _notifier.SuccessAsync(H["User {0} successfully disabled.", user.UserName]);
}
break;
case UsersBulkAction.Enable:
foreach (var user in checkedUsers)
{
if (String.Equals(user.UserId, User.FindFirstValue(ClaimTypes.NameIdentifier), StringComparison.OrdinalIgnoreCase))
{
continue;
}
user.IsEnabled = true;
await _userManager.UpdateAsync(user);
await _notifier.SuccessAsync(H["User {0} successfully enabled.", user.UserName]);
}
break;
default:
throw new ArgumentOutOfRangeException();
}
}
return(RedirectToAction(nameof(Index)));
}
// -----------------
// User List
// -----------------
public async Task <IActionResult> Index(UserIndexOptions opts, PagerOptions pager)
{
// Ensure we have permission
if (!await _authorizationService.AuthorizeAsync(User,
Permissions.ViewUsers))
{
return(Unauthorized());
}
// default options
if (opts == null)
{
opts = new UserIndexOptions();
}
// default pager
if (pager == null)
{
pager = new PagerOptions();
}
// Set pager call back Url
pager.Url = _contextFacade.GetRouteUrl(pager.Route(RouteData));
// Get default options
var defaultViewOptions = new UserIndexOptions();
var defaultPagerOptions = new PagerOptions();
// Add non default route data for pagination purposes
if (opts.Search != defaultViewOptions.Search)
{
this.RouteData.Values.Add("opts.search", opts.Search);
}
if (opts.Sort != defaultViewOptions.Sort)
{
this.RouteData.Values.Add("opts.sort", opts.Sort);
}
if (opts.Order != defaultViewOptions.Order)
{
this.RouteData.Values.Add("opts.order", opts.Order);
}
if (pager.Page != defaultPagerOptions.Page)
{
this.RouteData.Values.Add("pager.page", pager.Page);
}
if (pager.Size != defaultPagerOptions.Size)
{
this.RouteData.Values.Add("pager.size", pager.Size);
}
// Build view model
var viewModel = new UserIndexViewModel()
{
Options = opts,
Pager = pager
};
// Add view model to context
HttpContext.Items[typeof(UserIndexViewModel)] = viewModel;
// If we have a pager.page querystring value return paged results
if (int.TryParse(HttpContext.Request.Query["pager.page"], out var page))
{
if (page > 0)
{
return(View("GetUsers", viewModel));
}
}
// Return Url for authentication & canonical url purposes
ViewData["ReturnUrl"] = _contextFacade.GetRouteUrl(new RouteValueDictionary()
{
["area"] = "Plato.Users",
["controller"] = "Home",
["action"] = "Index"
});
// Breadcrumb
_breadCrumbManager.Configure(builder =>
{
builder.Add(S["Home"], home => home
.Action("Index", "Home", "Plato.Core")
.LocalNav()
).Add(S["Users"]);
});
// Return view
return(View((LayoutViewModel)await _viewProvider.ProvideIndexAsync(new ProfilePage(), this)));
}
