/// <summary>
/// 分页获取数据列表
/// </summary>
/// <param name="tableName">表名</param>
/// <param name="where">查询条件</param>
/// <param name="order">排序</param>
/// <param name="pageIndex">页下标</param>
/// <param name="pageSize">页显示数</param>
/// <param name="fields">查询字段</param>
/// <returns></returns>
public PagerSet GetList(string tableName, string where, string order, int pageIndex, int pageSize, string[] fields = null)
{
PagerParameters pagerPrams = new PagerParameters(tableName, where, order, pageIndex, pageSize, fields);
return(GetPagerSet(pagerPrams));
}
public ActionResult Index(ListContentsViewModel model, PagerParameters pagerParameters, string part, string field, string types)
{
var menuItems = _navigationManager.BuildMenu("content-picker").ToList();
var contentPickerMenuItem = menuItems.FirstOrDefault();
if (contentPickerMenuItem == null)
{
return(HttpNotFound());
}
if (contentPickerMenuItem.Items.All(x => x.Text.TextHint != "Recent Content"))
{
// the default tab should not be displayed, redirect to the next one
var root = menuItems.FirstOrDefault();
if (root == null)
{
return(HttpNotFound());
}
var firstChild = root.Items.First();
if (firstChild == null)
{
return(HttpNotFound());
}
var routeData = new RouteValueDictionary(firstChild.RouteValues);
var queryString = Request.QueryString;
foreach (var key in queryString.AllKeys)
{
if (!String.IsNullOrEmpty(key))
{
routeData[key] = queryString[key];
}
}
return(RedirectToRoute(routeData));
}
ContentPickerFieldSettings settings = null;
// if the picker is loaded for a specific field, apply custom settings
if (!String.IsNullOrEmpty(part) && !String.IsNullOrEmpty(field))
{
var definition = _contentDefinitionManager.GetPartDefinition(part).Fields.FirstOrDefault(x => x.Name == field);
if (definition != null)
{
settings = definition.Settings.GetModel <ContentPickerFieldSettings>();
}
}
if (settings != null && !String.IsNullOrEmpty(settings.DisplayedContentTypes))
{
types = settings.DisplayedContentTypes;
}
IEnumerable <ContentTypeDefinition> contentTypes;
if (!String.IsNullOrEmpty(types))
{
var rawTypes = types.Split(new[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries).ToList();
contentTypes = _contentDefinitionManager
.ListTypeDefinitions()
.Where(x => x.Parts.Any(p => rawTypes.Contains(p.PartDefinition.Name)) || rawTypes.Contains(x.Name))
.ToArray();
}
else
{
contentTypes = GetListableTypes(false).ToList();
}
var pager = new Pager(_siteService.GetSiteSettings(), pagerParameters);
var query = Services.ContentManager.Query(VersionOptions.Latest, contentTypes.Select(ctd => ctd.Name).ToArray());
if (!string.IsNullOrEmpty(model.Options.SelectedFilter))
{
var contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(model.Options.SelectedFilter);
if (contentTypeDefinition == null)
{
return(HttpNotFound());
}
model.TypeDisplayName = !string.IsNullOrWhiteSpace(contentTypeDefinition.DisplayName)
? contentTypeDefinition.DisplayName
: contentTypeDefinition.Name;
query = query.ForType(model.Options.SelectedFilter);
}
switch (model.Options.OrderBy)
{
case ContentsOrder.Modified:
query = query.OrderByDescending <CommonPartRecord>(cr => cr.ModifiedUtc);
break;
case ContentsOrder.Published:
query = query.OrderByDescending <CommonPartRecord>(cr => cr.PublishedUtc);
break;
case ContentsOrder.Created:
query = query.OrderByDescending <CommonPartRecord>(cr => cr.CreatedUtc);
break;
}
if (!String.IsNullOrWhiteSpace(model.Options.SelectedCulture))
{
query = _cultureFilter.FilterCulture(query, model.Options.SelectedCulture);
}
model.Options.FilterOptions = contentTypes
.Select(ctd => new KeyValuePair <string, string>(ctd.Name, ctd.DisplayName))
.ToList().OrderBy(kvp => kvp.Value);
model.Options.Cultures = _cultureManager.ListCultures();
var pagerShape = Services.New.Pager(pager).TotalItemCount(query.Count());
var pageOfContentItems = query.Slice(pager.GetStartIndex(), pager.PageSize).ToList();
var list = Services.New.List();
list.AddRange(pageOfContentItems.Select(ci => Services.ContentManager.BuildDisplay(ci, "SummaryAdmin")));
foreach (IShape item in list.Items)
{
item.Metadata.Type = "ContentPicker";
}
var tab = Services.New.RecentContentTab()
.ContentItems(list)
.Pager(pagerShape)
.Options(model.Options)
.TypeDisplayName(model.TypeDisplayName ?? "");
// retain the parameter in the pager links
RouteData.Values["Options.SelectedFilter"] = model.Options.SelectedFilter;
RouteData.Values["Options.OrderBy"] = model.Options.OrderBy.ToString();
RouteData.Values["Options.ContentsStatus"] = model.Options.ContentsStatus.ToString();
return(new ShapeResult(this, Services.New.ContentPicker().Tab(tab)));
}
public async Task <IActionResult> Index(WorkflowTypeIndexOptions options, PagerParameters pagerParameters)
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageWorkflows))
{
return(Forbid());
}
var siteSettings = await _siteService.GetSiteSettingsAsync();
var pager = new Pager(pagerParameters, siteSettings.PageSize);
if (options == null)
{
options = new WorkflowTypeIndexOptions();
}
var query = _session.Query <WorkflowType, WorkflowTypeIndex>();
switch (options.Filter)
{
case WorkflowTypeFilter.All:
default:
break;
}
if (!string.IsNullOrWhiteSpace(options.Search))
{
query = query.Where(w => w.Name.Contains(options.Search));
}
switch (options.Order)
{
case WorkflowTypeOrder.Name:
query = query.OrderBy(u => u.Name);
break;
}
var count = await query.CountAsync();
var workflowTypes = await query
.Skip(pager.GetStartIndex())
.Take(pager.PageSize)
.ListAsync();
var workflowTypeIds = workflowTypes.Select(x => x.WorkflowTypeId).ToList();
var workflowGroups = (await _session.QueryIndex <WorkflowIndex>(x => x.WorkflowTypeId.IsIn(workflowTypeIds))
.ListAsync())
.GroupBy(x => x.WorkflowTypeId)
.ToDictionary(x => x.Key);
// 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 model = new WorkflowTypeIndexViewModel
{
WorkflowTypes = workflowTypes
.Select(x => new WorkflowTypeEntry
{
WorkflowType = x,
Id = x.Id,
WorkflowCount = workflowGroups.ContainsKey(x.WorkflowTypeId) ? workflowGroups[x.WorkflowTypeId].Count() : 0,
Name = x.Name
})
.ToList(),
Options = options,
Pager = pagerShape
};
model.Options.WorkflowTypesBulkAction = new List <SelectListItem>()
{
new SelectListItem()
{
Text = S["Delete"].Value, Value = nameof(WorkflowTypeBulkAction.Delete)
}
};
return(View(model));
}
public ActionResult Index(ListContentsViewModel model, PagerParameters pagerParameters)
{
var pager = new Pager(_siteService.GetSiteSettings(), pagerParameters);
var query = Services.ContentManager.Query(VersionOptions.Latest, GetCreatableTypes(false).Select(ctd => ctd.Name).ToArray());
if (!string.IsNullOrEmpty(model.Options.SelectedFilter))
{
var contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(model.Options.SelectedFilter);
if (contentTypeDefinition == null)
{
return(HttpNotFound());
}
model.TypeDisplayName = !string.IsNullOrWhiteSpace(contentTypeDefinition.DisplayName)
? contentTypeDefinition.DisplayName
: contentTypeDefinition.Name;
query = query.ForType(model.Options.SelectedFilter);
}
switch (model.Options.OrderBy)
{
case ContentsOrder.Modified:
query = query.OrderByDescending <CommonPartRecord>(cr => cr.ModifiedUtc);
break;
case ContentsOrder.Published:
query = query.OrderByDescending <CommonPartRecord>(cr => cr.PublishedUtc);
break;
case ContentsOrder.Created:
query = query.OrderByDescending <CommonPartRecord>(cr => cr.CreatedUtc);
break;
}
model.Options.FilterOptions = GetCreatableTypes(false)
.Select(ctd => new KeyValuePair <string, string>(ctd.Name, ctd.DisplayName))
.ToList().OrderBy(kvp => kvp.Value);
var pagerShape = Services.New.Pager(pager).TotalItemCount(query.Count());
var pageOfContentItems = query.Slice(pager.GetStartIndex(), pager.PageSize).ToList();
var list = Services.New.List();
list.AddRange(pageOfContentItems.Select(ci => Services.ContentManager.BuildDisplay(ci, "SummaryAdmin")));
foreach (IShape item in list.Items)
{
item.Metadata.Type = "ContentPicker";
}
dynamic tab = Services.New.RecentContentTab()
.ContentItems(list)
.Pager(pagerShape)
.Options(model.Options)
.TypeDisplayName(model.TypeDisplayName ?? "");
// retain the parameter in the pager links
RouteData.Values["Options.SelectedFilter"] = model.Options.SelectedFilter;
RouteData.Values["Options.OrderBy"] = model.Options.OrderBy.ToString();
return(new ShapeResult(this, Services.New.ContentPicker().Tab(tab)));
}
public async Task <IActionResult> Index(SearchIndexOptions options, PagerParameters pagerParameters)
{
if (!await _authorizationService.AuthorizeAsync(User, Intelli.Comments.Permissions.ManageComments))
{
return(Unauthorized());
}
var siteSettings = await _siteService.GetSiteSettingsAsync();
var pager = new Pager(pagerParameters, siteSettings.PageSize);
if (options == null)
{
options = new SearchIndexOptions();
}
//var query = _session.Query<WorkflowType, WorkflowTypeIndex>();
// switch (options.Filter)
// {
// case WorkflowTypeFilter.All:
// default:
// break;
// }
// if (!string.IsNullOrWhiteSpace(options.Search))
// {
// query = query.Where(w => w.Name.Contains(options.Search));
// }
// switch (options.Order)
// {
// case WorkflowTypeOrder.Name:
// query = query.OrderBy(u => u.Name);
// break;
// }
// var count = await query.CountAsync();
// var workflowTypes = await query
// .Skip(pager.GetStartIndex())
// .Take(pager.PageSize)
// .ListAsync();
var comments = await _commentsRepository.FindAllAsync();// GetAllAsync();
var currentCommentList = comments
// .Where(c => (currentUserGroupIds.Contains(c.GroupId) || c.GroupId == currentUserId) && c.Parent == null && c.CommentGroupTypeId != CommentGroupType.GroupChat)
.OrderByDescending(c => c.CreatedUtc).ToList();
// var workflowTypeIds = workflowTypes.Select(x => x.WorkflowTypeId).ToList();
// var workflowGroups = (await _session.QueryIndex<WorkflowIndex>(x => x.WorkflowTypeId.IsIn(workflowTypeIds))
// .ListAsync())
// .GroupBy(x => x.WorkflowTypeId)
// .ToDictionary(x => x.Key);
// 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(currentCommentList.Count).RouteData(routeData);
var model = new CommentsIndexViewModel
{
Comments = currentCommentList,
Options = options,
Pager = pagerShape
};
return(View(model));
}
public PagerSet GetNewsList(int pageIndex, int pageSize, string condition, string orderby)
{
PagerParameters prams = new PagerParameters("News", orderby, condition, pageIndex, pageSize);
return(this.GetPagerSet2(prams));
}
public async Task <IActionResult> List(AdminMenuListOptions options, PagerParameters pagerParameters)
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageAdminMenu))
{
return(Unauthorized());
}
var siteSettings = await _siteService.GetSiteSettingsAsync();
var pager = new Pager(pagerParameters, siteSettings.PageSize);
// default options
if (options == null)
{
options = new AdminMenuListOptions();
}
var adminMenuList = (await _adminMenuService.GetMainMenuListAsync()).AdminMenu;
if (!string.IsNullOrWhiteSpace(options.Search))
{
adminMenuList = adminMenuList.Where(dp => dp.Name.Contains(options.Search)).ToList();
}
var count = adminMenuList.Count();
var startIndex = pager.GetStartIndex();
var pageSize = pager.PageSize;
IEnumerable <Models.AdminMenu> results = new List <Models.AdminMenu>();
//todo: handle the case where there is a deserialization exception on some of the presets.
// load at least the ones without error. Provide a way to delete the ones on error.
try
{
results = adminMenuList
.Skip(startIndex)
.Take(pageSize)
.ToList();
}
catch (Exception ex)
{
_logger.LogError(ex, "Error when retrieving the list of admin menus");
_notifier.Error(H["Error when retrieving the list of admin menus"]);
}
// Maintain previous route data when generating page links
var routeData = new RouteData();
routeData.Values.Add("Options.Search", options.Search);
var pagerShape = (await New.Pager(pager)).TotalItemCount(count).RouteData(routeData);
var model = new AdminMenuListViewModel
{
AdminMenu = results.Select(x => new AdminMenuEntry {
AdminMenu = x
}).ToList(),
Options = options,
Pager = pagerShape
};
return(View(model));
}
public async Task <ActionResult> Index(UserIndexOptions options, PagerParameters pagerParameters)
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageUsers))
{
return(Forbid());
}
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
{
UserId = user.UserId,
Shape = await _userDisplayManager.BuildDisplayAsync(user, updater: _updateModelAccessor.ModelUpdater, displayType: "SummaryAdmin")
}
);
}
var model = new UsersIndexViewModel
{
Users = userEntries,
Options = options,
Pager = pagerShape
};
model.Options.UserFilters = new List <SelectListItem>()
{
new SelectListItem()
{
Text = S["All"], Value = nameof(UsersFilter.All)
},
//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) }
};
model.Options.UserSorts = new List <SelectListItem>()
{
new SelectListItem()
{
Text = S["Name"], Value = nameof(UsersOrder.Name)
},
new SelectListItem()
{
Text = S["Email"], Value = nameof(UsersOrder.Email)
},
//new SelectListItem() { Text = S["Created date"], Value = nameof(UsersOrder.CreatedUtc) },
//new SelectListItem() { Text = S["Last Login date"], Value = nameof(UsersOrder.LastLoginUtc) }
};
model.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)
}
};
return(View(model));
}
public async Task <UsersListResponse> ListInOrganizationAsync(long organizationId, PagerParameters pager = null)
{
using (_loggerScope(_logger, $"ListInOrganizationAsync({organizationId})"))
using (var client = _apiClient.CreateClient())
{
var response = await client.GetAsync(string.Format(OrganizationsUsersResourceUriFormat, organizationId), pager).ConfigureAwait(false);
if (response.StatusCode == HttpStatusCode.NotFound)
{
_logger.LogInformation("Users in organization {0} not found", organizationId);
return(null);
}
if (!response.IsSuccessStatusCode)
{
throw await new ZendeskRequestExceptionBuilder()
.WithResponse(response)
.WithHelpDocsLink("core/users#list-users")
.Build();
}
return(await response.Content.ReadAsAsync <UsersListResponse>());
}
}
public ActionResult Index(AdminIndexOptions options, PagerParameters pagerParameters)
{
if (!Services.Authorizer.Authorize(Permissions.ManageQueries, T("Not authorized to list queries")))
{
return(new HttpUnauthorizedResult());
}
var pager = new Pager(_siteService.GetSiteSettings(), pagerParameters);
// default options
if (options == null)
{
options = new AdminIndexOptions();
}
var queries = Services.ContentManager.Query("Query");
switch (options.Filter)
{
case QueriesFilter.All:
break;
default:
throw new ArgumentOutOfRangeException();
}
if (!String.IsNullOrWhiteSpace(options.Search))
{
queries = queries.Join <TitlePartRecord>().Where(r => r.Title.Contains(options.Search));
}
var pagerShape = Shape.Pager(pager).TotalItemCount(queries.Count());
switch (options.Order)
{
case QueriesOrder.Name:
queries = queries.Join <TitlePartRecord>().OrderBy(u => u.Title);
break;
}
var results = queries
.Slice(pager.GetStartIndex(), pager.PageSize)
.ToList();
var model = new AdminIndexViewModel {
Queries = results.Select(x => new QueryEntry {
Query = x.As <QueryPart>().Record,
QueryId = x.Id,
Name = x.As <QueryPart>().Name
}).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 <UsersListResponse> ListByExternalIdsAsync(string[] externalIds, PagerParameters pager = null)
{
using (_loggerScope(_logger, $"ListByExternalIdsAsync({ZendeskFormatter.ToCsv(externalIds)})"))
using (var client = _apiClient.CreateClient(ResourceUri))
{
var response = await client.GetAsync($"show_many?external_ids={ZendeskFormatter.ToCsv(externalIds)}", pager).ConfigureAwait(false);
if (!response.IsSuccessStatusCode)
{
throw await new ZendeskRequestExceptionBuilder()
.WithResponse(response)
.WithHelpDocsLink("core/users#show-many-users")
.Build();
}
return(await response.Content.ReadAsAsync <UsersListResponse>());
}
}
public ActionResult Index(UserIndexOptions options, PagerParameters pagerParameters)
{
if (!Services.Authorizer.Authorize(Permissions.ManageUsers, 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;
case UsersOrder.CreatedUtc:
users = users.OrderBy(u => u.CreatedUtc);
break;
case UsersOrder.LastLoginUtc:
users = users.OrderBy(u => u.LastLoginUtc);
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 <IActionResult> Index(string id, string q, PagerParameters pagerParameters)
{
var siteSettings = await _siteService.GetSiteSettingsAsync();
var pager = new Pager(pagerParameters, siteSettings.PageSize);
var indexName = "Search";
if (!string.IsNullOrWhiteSpace(id))
{
indexName = id;
}
if (!await _elasticIndexProvider.ExistsAsync(indexName))
{
return(NotFound());
}
if (string.IsNullOrWhiteSpace(q))
{
return(View(new SearchIndexViewModel
{
Pager = pager, IndexName = id, ContentItems = Enumerable.Empty <ContentItem>()
}));
}
var luceneSettings = await _elasticIndexingService.GetElasticSettingsAsync();
if (luceneSettings == null) // || luceneSettings? .DefaultSearchFields == null)
{
Logger.LogInformation("Couldn't execute search. No Elastic settings was defined.");
return(View(new SearchIndexViewModel
{
HasMoreResults = false,
Query = q,
Pager = pager,
IndexName = id,
ContentItems = Enumerable.Empty <ContentItem>()
}));
}
//todo
// var queryParser = new MultiFieldQueryParser(LuceneSettings.DefaultVersion, luceneSettings.DefaultSearchFields, new StandardAnalyzer(LuceneSettings.DefaultVersion));
// var query = queryParser.Parse(QueryParser.Escape(q));
object query = null;
int start = pager.GetStartIndex(),
size = pager.PageSize,
end = size + 1; // Fetch one more result than PageSize to generate "More" links
var contentItemIds = await _searchQueryService.ExecuteQueryAsync(query, indexName, start, end);
var contentItems = new List <ContentItem>();
foreach (var contentItemId in contentItemIds.Take(size))
{
var contentItem = await _contentManager.GetAsync(contentItemId);
if (contentItem != null)
{
contentItems.Add(contentItem);
}
}
var model = new SearchIndexViewModel
{
HasMoreResults = contentItemIds.Count > size,
Query = q,
Pager = pager,
IndexName = id,
ContentItems = contentItems
};
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))
{
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.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 model = new UsersIndexViewModel
{
Users = await Task.WhenAll(
results.Select(async x =>
new UserEntry {
Shape = await _userDisplayManager.BuildDisplayAsync(x, this, "SummaryAdmin")
})),
Options = options,
Pager = pagerShape
};
return(View(model));
}
public async Task <IPagination <JobStatusResponse> > GetAsync(string[] statusIds, PagerParameters pagerParameters = null)
{
using (_loggerScope(_logger, $"GetAsync({ZendeskFormatter.ToCsv(statusIds)})"))
using (var client = _apiClient.CreateClient(ResourceUri))
{
var response = await client.GetAsync($"show_many?ids={ZendeskFormatter.ToCsv(statusIds)}", pagerParameters)
.ConfigureAwait(false);
if (!response.IsSuccessStatusCode)
{
throw await new ZendeskRequestExceptionBuilder()
.WithResponse(response)
.WithHelpDocsLink("support/job_statuses#show-many-job-statuses")
.Build();
}
return(await response.Content.ReadAsAsync <JobStatusListResponse>());
}
}
public async Task <IActionResult> List(
[ModelBinder(BinderType = typeof(ContentItemFilterEngineModelBinder), Name = "q")] QueryFilterResult <ContentItem> queryFilterResult,
ContentOptionsViewModel options,
PagerParameters pagerParameters,
string contentTypeId = "")
{
var context = _httpContextAccessor.HttpContext;
var contentTypeDefinitions = _contentDefinitionManager.ListTypeDefinitions()
.Where(ctd => ctd.GetSettings <ContentTypeSettings>().Creatable)
.OrderBy(ctd => ctd.DisplayName);
if (!await _authorizationService.AuthorizeContentTypeDefinitionsAsync(User, CommonPermissions.EditContent, contentTypeDefinitions, _contentManager))
{
return(Forbid());
}
var siteSettings = await _siteService.GetSiteSettingsAsync();
var pager = new Pager(pagerParameters, siteSettings.PageSize);
// This is used by the AdminMenus so needs to be passed into the options.
if (!String.IsNullOrEmpty(contentTypeId))
{
options.SelectedContentType = contentTypeId;
}
// The filter is bound seperately and mapped to the options.
// The options must still be bound so that options that are not filters are still bound
options.FilterResult = queryFilterResult;
// Populate the creatable types.
if (!String.IsNullOrEmpty(options.SelectedContentType))
{
// When the selected content type is provided via the route or options a placeholder node is used to apply a filter.
options.FilterResult.TryAddOrReplace(new ContentTypeFilterNode(options.SelectedContentType));
var contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(options.SelectedContentType);
if (contentTypeDefinition == null)
{
return(NotFound());
}
var creatableList = new List <SelectListItem>();
// Allows non creatable types to be created by another admin page.
if (contentTypeDefinition.GetSettings <ContentTypeSettings>().Creatable || options.CanCreateSelectedContentType)
{
var contentItem = await _contentManager.NewAsync(contentTypeDefinition.Name);
contentItem.Owner = context.User.FindFirstValue(ClaimTypes.NameIdentifier);
if (await _authorizationService.AuthorizeAsync(context.User, CommonPermissions.EditContent, contentItem))
{
creatableList.Add(new SelectListItem(contentTypeDefinition.DisplayName, contentTypeDefinition.Name));
}
}
options.CreatableTypes = creatableList;
}
if (options.CreatableTypes == null)
{
var creatableList = new List <SelectListItem>();
if (contentTypeDefinitions.Any())
{
foreach (var contentTypeDefinition in contentTypeDefinitions)
{
var contentItem = await _contentManager.NewAsync(contentTypeDefinition.Name);
contentItem.Owner = context.User.FindFirstValue(ClaimTypes.NameIdentifier);
if (await _authorizationService.AuthorizeAsync(context.User, CommonPermissions.EditContent, contentItem))
{
creatableList.Add(new SelectListItem(contentTypeDefinition.DisplayName, contentTypeDefinition.Name));
}
}
}
options.CreatableTypes = creatableList;
}
// We populate the remaining SelectLists.
options.ContentStatuses = new List <SelectListItem>()
{
new SelectListItem()
{
Text = S["Latest"], Value = nameof(ContentsStatus.Latest), Selected = (options.ContentsStatus == ContentsStatus.Latest)
},
new SelectListItem()
{
Text = S["Published"], Value = nameof(ContentsStatus.Published), Selected = (options.ContentsStatus == ContentsStatus.Published)
},
new SelectListItem()
{
Text = S["Unpublished"], Value = nameof(ContentsStatus.Draft), Selected = (options.ContentsStatus == ContentsStatus.Draft)
},
new SelectListItem()
{
Text = S["All versions"], Value = nameof(ContentsStatus.AllVersions), Selected = (options.ContentsStatus == ContentsStatus.AllVersions)
}
};
if (await _authorizationService.AuthorizeAsync(context.User, Permissions.ListContent))
{
options.ContentStatuses.Insert(1, new SelectListItem()
{
Text = S["Owned by me"], Value = nameof(ContentsStatus.Owner)
});
}
options.ContentSorts = new List <SelectListItem>()
{
new SelectListItem()
{
Text = S["Recently created"], Value = nameof(ContentsOrder.Created), Selected = (options.OrderBy == ContentsOrder.Created)
},
new SelectListItem()
{
Text = S["Recently modified"], Value = nameof(ContentsOrder.Modified), Selected = (options.OrderBy == ContentsOrder.Modified)
},
new SelectListItem()
{
Text = S["Recently published"], Value = nameof(ContentsOrder.Published), Selected = (options.OrderBy == ContentsOrder.Published)
},
new SelectListItem()
{
Text = S["Title"], Value = nameof(ContentsOrder.Title), Selected = (options.OrderBy == ContentsOrder.Title)
},
};
options.ContentsBulkAction = new List <SelectListItem>()
{
new SelectListItem()
{
Text = S["Publish Now"], Value = nameof(ContentsBulkAction.PublishNow)
},
new SelectListItem()
{
Text = S["Unpublish"], Value = nameof(ContentsBulkAction.Unpublish)
},
new SelectListItem()
{
Text = S["Delete"], Value = nameof(ContentsBulkAction.Remove)
}
};
if ((String.IsNullOrEmpty(options.SelectedContentType) || String.IsNullOrEmpty(contentTypeId)) && options.ContentTypeOptions == null)
{
var listableTypes = new List <ContentTypeDefinition>();
var userNameIdentifier = context.User.FindFirstValue(ClaimTypes.NameIdentifier);
foreach (var ctd in _contentDefinitionManager.ListTypeDefinitions())
{
if (ctd.GetSettings <ContentTypeSettings>().Listable)
{
var contentItem = await _contentManager.NewAsync(ctd.Name);
contentItem.Owner = userNameIdentifier;
var authorized = await _authorizationService.AuthorizeAsync(User, CommonPermissions.EditContent, contentItem);
if (authorized)
{
listableTypes.Add(ctd);
}
}
}
var contentTypeOptions = listableTypes
.Select(ctd => new KeyValuePair <string, string>(ctd.Name, ctd.DisplayName))
.ToList().OrderBy(kvp => kvp.Value);
options.ContentTypeOptions = new List <SelectListItem>
{
new SelectListItem()
{
Text = S["All content types"], Value = ""
}
};
foreach (var option in contentTypeOptions)
{
options.ContentTypeOptions.Add(new SelectListItem()
{
Text = option.Value, Value = option.Key, Selected = (option.Value == options.SelectedContentType)
});
}
}
// If ContentTypeOptions is not initialized by query string or by the code above, initialize it
if (options.ContentTypeOptions == null)
{
options.ContentTypeOptions = new List <SelectListItem>();
}
// With the options populated we filter the query, allowing the filters to alter the options.
var query = await _contentsAdminListQueryService.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 maxPagedCount = siteSettings.MaxPagedCount;
if (maxPagedCount > 0 && pager.PageSize > maxPagedCount)
{
pager.PageSize = maxPagedCount;
}
var pagerShape = (await New.Pager(pager)).TotalItemCount(maxPagedCount > 0 ? maxPagedCount : await query.CountAsync()).RouteData(routeData);
// Load items so that loading handlers are invoked.
var pageOfContentItems = await query.Skip(pager.GetStartIndex()).Take(pager.PageSize).ListAsync(_contentManager);
// We prepare the content items SummaryAdmin shape
var contentItemSummaries = new List <dynamic>();
foreach (var contentItem in pageOfContentItems)
{
contentItemSummaries.Add(await _contentItemDisplayManager.BuildDisplayAsync(contentItem, _updateModelAccessor.ModelUpdater, "SummaryAdmin"));
}
// Populate options pager summary values.
var startIndex = (pagerShape.Page - 1) * (pagerShape.PageSize) + 1;
options.StartIndex = startIndex;
options.EndIndex = startIndex + contentItemSummaries.Count - 1;
options.ContentItemsCount = contentItemSummaries.Count;
options.TotalItemCount = pagerShape.TotalItemCount;
var header = await _contentOptionsDisplayManager.BuildEditorAsync(options, _updateModelAccessor.ModelUpdater, false);
var shapeViewModel = await _shapeFactory.CreateAsync <ListContentsViewModel>("ContentsAdminList", viewModel =>
{
viewModel.ContentItems = contentItemSummaries;
viewModel.Pager = pagerShape;
viewModel.Options = options;
viewModel.Header = header;
});
return(View(shapeViewModel));
}
public async Task <IActionResult> Index(TenantIndexOptions options, PagerParameters pagerParameters)
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageTenants))
{
return(Forbid());
}
if (!IsDefaultShell())
{
return(Forbid());
}
var allSettings = _shellHost.GetAllSettings().OrderBy(s => s.Name);
var dataProtector = _dataProtectorProvider.CreateProtector("Tokens").ToTimeLimitedDataProtector();
var siteSettings = await _siteService.GetSiteSettingsAsync();
var pager = new Pager(pagerParameters, siteSettings.PageSize);
// default options
if (options == null)
{
options = new TenantIndexOptions();
}
var entries = allSettings.Select(x =>
{
var entry = new ShellSettingsEntry
{
Description = x["Description"],
Name = x.Name,
ShellSettings = x,
IsDefaultTenant = string.Equals(x.Name, ShellHelper.DefaultShellName, StringComparison.OrdinalIgnoreCase)
};
if (x.State == TenantState.Uninitialized && !string.IsNullOrEmpty(x["Secret"]))
{
entry.Token = dataProtector.Protect(x["Secret"], _clock.UtcNow.Add(new TimeSpan(24, 0, 0)));
}
return(entry);
}).ToList();
if (!string.IsNullOrWhiteSpace(options.Search))
{
entries = entries.Where(t => t.Name.IndexOf(options.Search, StringComparison.OrdinalIgnoreCase) > -1 ||
(t.ShellSettings != null &&
((t.ShellSettings.RequestUrlHost != null && t.ShellSettings.RequestUrlHost.IndexOf(options.Search, StringComparison.OrdinalIgnoreCase) > -1) ||
(t.ShellSettings.RequestUrlPrefix != null && t.ShellSettings.RequestUrlPrefix.IndexOf(options.Search, StringComparison.OrdinalIgnoreCase) > -1)))).ToList();
}
switch (options.Filter)
{
case TenantsFilter.Disabled:
entries = entries.Where(t => t.ShellSettings.State == TenantState.Disabled).ToList();
break;
case TenantsFilter.Running:
entries = entries.Where(t => t.ShellSettings.State == TenantState.Running).ToList();
break;
case TenantsFilter.Uninitialized:
entries = entries.Where(t => t.ShellSettings.State == TenantState.Uninitialized).ToList();
break;
}
switch (options.OrderBy)
{
case TenantsOrder.Name:
entries = entries.OrderBy(t => t.Name).ToList();
break;
case TenantsOrder.State:
entries = entries.OrderBy(t => t.ShellSettings?.State).ToList();
break;
default:
entries = entries.OrderByDescending(t => t.Name).ToList();
break;
}
var count = entries.Count();
var results = entries
.Skip(pager.GetStartIndex())
.Take(pager.PageSize).ToList();
// 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.OrderBy", options.OrderBy);
var pagerShape = (await New.Pager(pager)).TotalItemCount(count).RouteData(routeData);
var model = new AdminIndexViewModel
{
ShellSettingsEntries = results,
Options = options,
Pager = pagerShape
};
// We populate the SelectLists
model.Options.TenantsStates = new List <SelectListItem>()
{
new SelectListItem()
{
Text = S["All states"], Value = nameof(TenantsFilter.All)
},
new SelectListItem()
{
Text = S["Running"], Value = nameof(TenantsFilter.Running)
},
new SelectListItem()
{
Text = S["Disabled"], Value = nameof(TenantsFilter.Disabled)
},
new SelectListItem()
{
Text = S["Uninitialized"], Value = nameof(TenantsFilter.Uninitialized)
}
};
model.Options.TenantsSorts = new List <SelectListItem>()
{
new SelectListItem()
{
Text = S["Name"], Value = nameof(TenantsOrder.Name)
},
new SelectListItem()
{
Text = S["State"], Value = nameof(TenantsOrder.State)
}
};
model.Options.TenantsBulkAction = new List <SelectListItem>()
{
new SelectListItem()
{
Text = S["Disable"], Value = nameof(TenantsBulkAction.Disable)
},
new SelectListItem()
{
Text = S["Enable"], Value = nameof(TenantsBulkAction.Enable)
}
};
return(View(model));
}
public ActionResult Index(SpamIndexOptions options, PagerParameters pagerParameters)
{
if (!Services.Authorizer.Authorize(Permissions.ManageAntiSpam, T("Not authorized to manage spam")))
{
return(new HttpUnauthorizedResult());
}
var pager = new Pager(_siteService.GetSiteSettings(), pagerParameters);
// default options
if (options == null)
{
options = new SpamIndexOptions();
}
var query = Services.ContentManager.Query().ForPart <SpamFilterPart>();
switch (options.Filter)
{
case SpamFilter.Spam:
query = query.Where <SpamFilterPartRecord>(x => x.Status == SpamStatus.Spam);
break;
case SpamFilter.Ham:
query = query.Where <SpamFilterPartRecord>(x => x.Status == SpamStatus.Ham);
break;
case SpamFilter.All:
break;
default:
throw new ArgumentOutOfRangeException();
}
var pagerShape = Shape.Pager(pager).TotalItemCount(query.Count());
switch (options.Order)
{
case SpamOrder.Creation:
query = query.Join <CommonPartRecord>().OrderByDescending(u => u.CreatedUtc);
break;
}
var results = query
.Slice(pager.GetStartIndex(), pager.PageSize);
var model = new SpamIndexViewModel {
Spams = results.Select(x => new SpamEntry {
Spam = x.As <SpamFilterPart>(),
Shape = Services.ContentManager.BuildDisplay(x, "SummaryAdmin")
}).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 ActionResult Rewriter(RewriterViewModel rewriterViewModel, PagerParameters pagerParameters)
{
if (!IsAuthorized())
{
return(new HttpUnauthorizedResult());
}
if (rewriterViewModel.TypeName == "Dynamic")
{
return(DynamicPageRewriter(new DynamicPageRewriterViewModel {
RewriterType = rewriterViewModel.RewriterType
}));
}
var siteSettings = _workContext.CurrentSite;
var pager = new Pager(siteSettings, pagerParameters);
var seoContentTypes = _seoService.ListSeoContentTypes();
if (string.IsNullOrEmpty(rewriterViewModel.TypeName))
{
return(HttpNotFound());
}
var typeDefinition = seoContentTypes.SingleOrDefault(t => t.Name == rewriterViewModel.TypeName);
if (typeDefinition == null)
{
return(HttpNotFound());
}
rewriterViewModel.TypeDisplayName = typeDefinition.DisplayName;
_orchardServices.WorkContext.Layout.Title = TitleForRewriter(rewriterViewModel.RewriterType, typeDefinition.DisplayName);
var query = _contentManager.Query(VersionOptions.Latest, rewriterViewModel.TypeName);
if (!String.IsNullOrEmpty(rewriterViewModel.Q))
{
IPageOfItems <ISearchHit> searchHits = new PageOfItems <ISearchHit>(new ISearchHit[] { });
try
{
///TODO 1.9: make sure this to array function actually works
var searchSettings = siteSettings.As <SearchSettingsPart>();
searchHits = _searchService.Query(rewriterViewModel.Q, pager.Page, pager.PageSize, false,
searchSettings.SearchIndex, searchSettings.SearchFields.Keys.ToArray <string>(),
//searchSettings.SearchIndex, SearchSettingsHelper.GetSearchFields(searchSettings),
searchHit => searchHit);
// Could use this: http://orchard.codeplex.com/workitem/18664
// Converting to List, because the expression should contain an ICollection
var hitIds = searchHits.Select(hit => hit.ContentItemId).ToList();
query.Where <CommonPartRecord>(record => hitIds.Contains(record.Id));
}
catch (Exception ex) {
if (ex.IsFatal())
{
throw;
}
_orchardServices.Notifier.Error(T("Invalid search query: {0}", ex.Message));
}
}
switch (rewriterViewModel.Options.OrderBy)
{
case ContentsOrder.Modified:
query = query.OrderByDescending <CommonPartRecord>(cr => cr.ModifiedUtc);
break;
case ContentsOrder.Published:
query = query.OrderByDescending <CommonPartRecord>(cr => cr.PublishedUtc);
break;
case ContentsOrder.Created:
query = query.OrderByDescending <CommonPartRecord>(cr => cr.CreatedUtc);
break;
}
rewriterViewModel.Options.SelectedFilter = rewriterViewModel.TypeName;
var pagerShape = _shapeFactory.Pager(pager).TotalItemCount(query.Count());
var pageOfContentItems = query.Slice(pager.GetStartIndex(), pager.PageSize).ToList();
var list = _shapeFactory.List();
list.AddRange(
pageOfContentItems.Select(
item => _prefixedEditorManager.BuildShape(item, (content => _contentManager.BuildDisplay(content, "SeoSummaryAdmin-" + rewriterViewModel.RewriterType)))
)
);
dynamic viewModel = _shapeFactory.ViewModel()
.ContentItems(list)
.Options(rewriterViewModel.Options)
.Pager(pagerShape);
// Casting to avoid invalid (under medium trust) reflection over the protected View method and force a static invocation, despite
// being it highly unlikely with Onestop, just in case...
return(View((object)viewModel));
}
public PagerSet GetGameMatchUserInfoList(int pageIndex, int pageSize, string condition, string orderby)
{
PagerParameters prams = new PagerParameters("GameMatchUserInfo", orderby, condition, pageIndex, pageSize);
return(this.GetPagerSet2(prams));
}
public async Task <IActionResult> List(ListContentsViewModel model, PagerParameters pagerParameters)
{
var siteSettings = await _siteService.GetSiteSettingsAsync();
Pager pager = new Pager(pagerParameters, siteSettings.PageSize);
var query = _session.QueryAsync <ContentItem, ContentItemIndex>();
switch (model.Options.ContentsStatus)
{
case ContentsStatus.Published:
query = query.With <ContentItemIndex>(x => x.Published);
break;
case ContentsStatus.Draft:
query = query.With <ContentItemIndex>(x => x.Latest && !x.Published);
break;
case ContentsStatus.AllVersions:
query = query.With <ContentItemIndex>(x => x.Latest);
break;
default:
query = query.With <ContentItemIndex>(x => x.Latest);
break;
}
if (!string.IsNullOrEmpty(model.TypeName))
{
var contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(model.TypeName);
if (contentTypeDefinition == null)
{
return(NotFound());
}
model.TypeDisplayName = contentTypeDefinition.ToString();
// We display a specific type even if it's not listable so that admin pages
// can reuse the Content list page for specific types.
query = query.With <ContentItemIndex>(x => x.ContentType == model.TypeName);
}
else
{
var listableTypes = (await GetListableTypesAsync()).Select(t => t.Name).ToArray();
if (listableTypes.Any())
{
query = query.With <ContentItemIndex>(x => x.ContentType.IsIn(listableTypes));
}
}
switch (model.Options.OrderBy)
{
case ContentsOrder.Modified:
query = query.OrderByDescending(x => x.ModifiedUtc);
break;
case ContentsOrder.Published:
query = query.OrderByDescending(cr => cr.PublishedUtc);
break;
case ContentsOrder.Created:
query = query.OrderByDescending(cr => cr.CreatedUtc);
break;
default:
query = query.OrderByDescending(cr => cr.ModifiedUtc);
break;
}
//if (!String.IsNullOrWhiteSpace(model.Options.SelectedCulture))
//{
// query = _cultureFilter.FilterCulture(query, model.Options.SelectedCulture);
//}
//if (model.Options.ContentsStatus == ContentsStatus.Owner)
//{
// query = query.Where<CommonPartRecord>(cr => cr.OwnerId == Services.WorkContext.CurrentUser.Id);
//}
model.Options.SelectedFilter = model.TypeName;
model.Options.FilterOptions = (await GetListableTypesAsync())
.Select(ctd => new KeyValuePair <string, string>(ctd.Name, ctd.DisplayName))
.ToList().OrderBy(kvp => kvp.Value);
//model.Options.Cultures = _cultureManager.ListCultures();
// Invoke any service that could alter the query
await _contentAdminFilters.InvokeAsync(x => x.FilterAsync(query, model, pagerParameters, this), Logger);
var maxPagedCount = siteSettings.MaxPagedCount;
if (maxPagedCount > 0 && pager.PageSize > maxPagedCount)
{
pager.PageSize = maxPagedCount;
}
var pagerShape = New.Pager(pager).TotalItemCount(maxPagedCount > 0 ? maxPagedCount : await query.Count());
var pageOfContentItems = await query.Skip(pager.GetStartIndex()).Take(pager.PageSize).List();
var contentItemSummaries = new List <dynamic>();
foreach (var contentItem in pageOfContentItems)
{
contentItemSummaries.Add(await _contentItemDisplayManager.BuildDisplayAsync(contentItem, this, "SummaryAdmin"));
}
var viewModel = New.ViewModel()
.ContentItems(contentItemSummaries)
.Pager(pagerShape)
.Options(model.Options)
.TypeDisplayName(model.TypeDisplayName ?? "");
return(View(viewModel));
}
public PagerSet GetList(string tableName, int pageIndex, int pageSize, string condition, string orderby)
{
PagerParameters prams = new PagerParameters(tableName, orderby, condition, pageIndex, pageSize);
return(this.GetPagerSet2(prams));
}
public async Task <IPagination <TicketResponse> > ListRequestedByAsync(long userId, PagerParameters pager = null)
{
using (_loggerScope(_logger, $"ListRequestedByAsync({userId})"))
using (var client = _apiClient.CreateClient(string.Format(UserResourceUriFormat, userId)))
{
var response = await client.GetAsync("requested", pager).ConfigureAwait(false);
if (response.StatusCode == HttpStatusCode.NotFound)
{
_logger.LogInformation("Requested ticketsResponse for user {0} not found", userId);
return(null);
}
if (!response.IsSuccessStatusCode)
{
throw await new ZendeskRequestExceptionBuilder()
.WithResponse(response)
.WithHelpDocsLink("core/tickets#list-tickets")
.Build();
}
return(await response.Content.ReadAsAsync <TicketsListResponse>());
}
}
public ActionResult Index(PagerParameters pagerParameters, string part, string field, string searchText = "")
{
var pager = new Pager(_siteService.GetSiteSettings(), pagerParameters);
var searchSettingsPart = Services.WorkContext.CurrentSite.As <SearchSettingsPart>();
var totalCount = 0;
var foundIds = new int[0];
if (!String.IsNullOrWhiteSpace(searchText))
{
ContentPickerSearchFieldSettings settings = null;
// if the picker is loaded for a specific field, apply custom settings
if (!String.IsNullOrEmpty(part) && !String.IsNullOrEmpty(field))
{
var definition = _contentDefinitionManager.GetPartDefinition(part).Fields.FirstOrDefault(x => x.Name == field);
if (definition != null)
{
settings = definition.Settings.GetModel <ContentPickerSearchFieldSettings>();
}
}
if (!_indexManager.HasIndexProvider())
{
return(View("NoIndex"));
}
var searchIndex = searchSettingsPart.SearchIndex;
if (settings != null && !String.IsNullOrEmpty(settings.SearchIndex))
{
searchIndex = settings.SearchIndex;
}
var searchFields = searchSettingsPart.GetSearchFields(searchIndex);
var builder = _indexManager.GetSearchIndexProvider().CreateSearchBuilder(searchIndex);
try {
builder.Parse(searchFields, searchText);
if (settings != null && !String.IsNullOrEmpty(settings.DisplayedContentTypes))
{
var rawTypes = settings.DisplayedContentTypes.Split(new[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries).ToList();
var contentTypes = _contentDefinitionManager
.ListTypeDefinitions()
.Where(x => x.Parts.Any(p => rawTypes.Contains(p.PartDefinition.Name)) || rawTypes.Contains(x.Name))
.ToArray();
foreach (string type in contentTypes.Select(x => x.Name))
{
builder.WithField("type", type).NotAnalyzed().AsFilter();
}
}
totalCount = builder.Count();
builder = builder.Slice((pager.Page > 0 ? pager.Page - 1 : 0) * pager.PageSize, pager.PageSize);
var searchResults = builder.Search();
foundIds = searchResults.Select(searchHit => searchHit.ContentItemId).ToArray();
}
catch (Exception exception) {
Logger.Error(T("Invalid search query: {0}", exception.Message).Text);
Services.Notifier.Error(T("Invalid search query: {0}", exception.Message));
}
}
var list = Services.New.List();
foreach (var contentItem in Services.ContentManager.GetMany <IContent>(foundIds, VersionOptions.Published, QueryHints.Empty))
{
// ignore search results which content item has been removed or unpublished
if (contentItem == null)
{
totalCount--;
continue;
}
list.Add(Services.ContentManager.BuildDisplay(contentItem, "SummaryAdmin"));
}
var pagerShape = Services.New.Pager(pager).TotalItemCount(totalCount);
foreach (IShape item in list.Items)
{
item.Metadata.Type = "ContentPicker";
}
// retain the parameter in the pager links
RouteData.Values["searchText"] = searchText;
dynamic tab = Services.New.SearchContentTab()
.ContentItems(list)
.Pager(pagerShape)
.SearchText(searchText);
return(new ShapeResult(this, Services.New.ContentPicker().Tab(tab)));
}
public async Task <IActionResult> Index(string id, string q, PagerParameters pagerParameters)
{
var siteSettings = await _siteService.GetSiteSettingsAsync();
Pager pager = new Pager(pagerParameters, siteSettings.PageSize);
var indexName = "Search";
if (!String.IsNullOrWhiteSpace(id))
{
indexName = id;
}
if (!_luceneIndexProvider.Exists(indexName))
{
return(NotFound());
}
if (String.IsNullOrWhiteSpace(q))
{
return(View(new SearchIndexViewModel
{
Pager = pager,
IndexName = id,
ContentItems = Enumerable.Empty <ContentItem>()
}));
}
var luceneSettings = await _luceneIndexingService.GetLuceneSettingsAsync();
if (luceneSettings == null)
{
Logger.LogInformation("Couldn't execute search. No Lucene settings was defined.");
return(View(new SearchIndexViewModel
{
HasMoreResults = false,
Query = q,
Pager = pager,
IndexName = id,
ContentItems = Enumerable.Empty <ContentItem>()
}));
}
var queryParser = new MultiFieldQueryParser(LuceneSettings.DefaultVersion, luceneSettings.DefaultSearchFields, new StandardAnalyzer(LuceneSettings.DefaultVersion));
var query = queryParser.Parse(QueryParser.Escape(q));
var contentItemIds = new List <string>();
await _luceneIndexProvider.SearchAsync(indexName, searcher =>
{
// Fetch one more result than PageSize to generate "More" links
TopScoreDocCollector collector = TopScoreDocCollector.Create(pager.PageSize + 1, true);
searcher.Search(query, collector);
TopDocs hits = collector.TopDocs(pager.GetStartIndex(), pager.PageSize + 1);
foreach (var hit in hits.ScoreDocs)
{
var d = searcher.Doc(hit.Doc, IdSet);
contentItemIds.Add(d.GetField("ContentItemId").StringValue);
}
return(Task.CompletedTask);
});
var contentItems = new List <ContentItem>();
foreach (var contentItemId in contentItemIds.Take(pager.PageSize))
{
var contentItem = await _contentManager.GetAsync(contentItemId);
if (contentItem != null)
{
contentItems.Add(contentItem);
}
}
var model = new SearchIndexViewModel
{
HasMoreResults = contentItemIds.Count > pager.PageSize,
Query = q,
Pager = pager,
IndexName = id,
ContentItems = contentItems
};
return(View(model));
}
public ActionResult Index(AdminIndexOptions options, PagerParameters pagerParameters)
{
if (!Services.Authorizer.Authorize(StandardPermissions.SiteOwner, T("Not authorized to list workflows")))
{
return(new HttpUnauthorizedResult());
}
var pager = new Pager(_siteService.GetSiteSettings(), pagerParameters);
// default options
if (options == null)
{
options = new AdminIndexOptions();
}
var queries = _workflowDefinitionRecords.Table;
switch (options.Filter)
{
case WorkflowDefinitionFilter.All:
break;
default:
throw new ArgumentOutOfRangeException();
}
if (!String.IsNullOrWhiteSpace(options.Search))
{
queries = queries.Where(w => w.Name.Contains(options.Search));
}
var pagerShape = New.Pager(pager).TotalItemCount(queries.Count());
switch (options.Order)
{
case WorkflowDefinitionOrder.Name:
queries = queries.OrderBy(u => u.Name);
break;
}
if (pager.GetStartIndex() > 0)
{
queries = queries.Skip(pager.GetStartIndex());
}
if (pager.PageSize > 0)
{
queries = queries.Take(pager.PageSize);
}
var results = queries.ToList();
var model = new AdminIndexViewModel {
WorkflowDefinitions = results.Select(x => new WorkflowDefinitionEntry {
WorkflowDefinitionRecord = x,
WokflowDefinitionId = x.Id,
Name = x.Name
}).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 ActionResult ModulesUpdates(int?reportId, PagerParameters pagerParameters)
{
return(PackageUpdate("ModulesUpdates", DefaultExtensionTypes.Module, reportId, pagerParameters));
}
/// <summary>
/// 分页获取数据列表
/// </summary>
/// <param name="where">查询条件</param>
/// <param name="order">排序</param>
/// <param name="pageIndex">页下标</param>
/// <param name="pageSize">页显示数</param>
/// <returns></returns>
public PagerSet GetPageGroupList(string where, string order, int pageIndex, int pageSize)
{
PagerParameters pagerPrams = new PagerParameters("IMGroupProperty", where, order, pageIndex, pageSize, null, "WEB_PageView_Group");
return(GetPagerSet(pagerPrams));
}
private ActionResult PackageUpdate(string view, string extensionType, int?reportId, PagerParameters pagerParameters)
{
if (_shellSettings.Name != ShellSettings.DefaultName || !Services.Authorizer.Authorize(StandardPermissions.SiteOwner, T("Not authorized to add sources")))
{
return(new HttpUnauthorizedResult());
}
Pager pager = new Pager(Services.WorkContext.CurrentSite, pagerParameters);
if (!_packagingSourceManager.GetSources().Any())
{
Services.Notifier.Error(T("No Gallery feed configured"));
return(View(view, new PackagingListViewModel {
Entries = new List <UpdatePackageEntry>()
}));
}
// Get status from background task state or directly
_backgroundPackageUpdateStatus.Value =
_backgroundPackageUpdateStatus.Value ??
_packageUpdateService.GetPackagesStatus(_packagingSourceManager.GetSources());
foreach (var error in _backgroundPackageUpdateStatus.Value.Errors)
{
for (var scan = error; scan != null; scan = scan.InnerException)
{
Services.Notifier.Warning(T("Package retrieve error: {0}", scan.Message));
}
}
IEnumerable <UpdatePackageEntry> updatedPackages = _backgroundPackageUpdateStatus.Value.Entries
.Where(updatePackageEntry =>
updatePackageEntry.ExtensionsDescriptor.ExtensionType.Equals(extensionType) &&
updatePackageEntry.NewVersionToInstall != null);
int totalItemCount = updatedPackages.Count();
if (pager.PageSize != 0)
{
updatedPackages = updatedPackages.Skip((pager.Page - 1) * pager.PageSize).Take(pager.PageSize);
}
return(View(view, new PackagingListViewModel {
Entries = updatedPackages,
Pager = Shape.Pager(pager).TotalItemCount(totalItemCount)
}));
}
/// <summary>
/// Constructs a new pager.
/// </summary>
/// <param name="site">The site settings.</param>
/// <param name="pagerParameters">The pager parameters.</param>
public Pager(PagerParameters pagerParameters, int defaultPageSize)
: this(pagerParameters.Page, pagerParameters.PageSize, defaultPageSize)
{
}
public static Task <HttpResponseMessage> GetAsync(this HttpClient client, string requestUri, PagerParameters parameters = null, CancellationToken cancellationToken = default(CancellationToken))
{
var pager = new Pager(parameters?.Page, parameters?.PageSize, 100);
var pagination = $"per_page={pager.PageSize}&page={pager.Page}";
if (requestUri.Contains("?"))
{
requestUri += "&" + pagination;
}
else
{
requestUri += "?" + pagination;
}
return(client.GetAsync(requestUri, cancellationToken));
}
