async Task <EntityIndexViewModel <Entity> > GetViewModel(
EntityIndexOptions options,
PagerOptions pager)
{
// Get results
var results = await _entityService
.ConfigureDb(o =>
{
if (_searchSettings != null)
{
o.SearchType = _searchSettings.SearchType;
}
}).GetResultsAsync(options, pager);
// Set total on pager
pager.SetTotal(results?.Total ?? 0);
// Return view model
return(new EntityIndexViewModel <Entity>()
{
Results = results,
Options = options,
Pager = pager
});
}
async Task <EntityIndexViewModel <Entity> > GetIndexViewModelAsync(EntityIndexOptions options, PagerOptions pager)
{
// Set default sort column if auto is specified
if (options.Sort == SortBy.LastReply)
{
// Get search settings
var searchSettings = await _searchSettingsStore.GetAsync();
if (searchSettings != null)
{
options.Sort = searchSettings.SearchType == SearchTypes.Tsql
? SortBy.LastReply
: SortBy.Rank;
}
else
{
options.Sort = SortBy.LastReply;
}
}
// Set pager call back Url
pager.Url = _contextFacade.GetRouteUrl(pager.Route(this.RouteData));
// Return updated model
return(new EntityIndexViewModel <Entity>()
{
Options = options,
Pager = pager
});
}
public async Task <IViewComponentResult> InvokeAsync(
EntityIndexOptions options,
PagerOptions pager)
{
if (options == null)
{
options = new EntityIndexOptions();
}
if (pager == null)
{
pager = new PagerOptions();
}
// Get view model
var model = await GetIndexViewModel(options, pager);
// If full text is enabled add rank to sort options
if (options.Sort == SortBy.Rank)
{
var sortColumns = new List <SortColumn>()
{
new SortColumn()
{
Text = "Relevancy",
Value = SortBy.Rank
}
};
sortColumns.AddRange(model.SortColumns);
model.SortColumns = sortColumns;
}
// Return view model
return(View(model));
}
private async Task <IPagedResults <Doc> > GetEntities(EntityIndexOptions options)
{
// Get feature
var feature = await _featureFacade.GetFeatureByIdAsync("Plato.Docs");
// Ensure we found the feature
if (feature == null)
{
throw new Exception("The feature Plato.Docs could not be found");
}
if (options.FeatureId <= 0)
{
options.FeatureId = feature.Id;
}
options.Sort = SortBy.SortOrder;
options.Order = OrderBy.Asc;
// Get results
return(await _entityService
.ConfigureQuery(async q =>
{
// Hide private?
if (!await _authorizationService.AuthorizeAsync(HttpContext.User,
Permissions.ViewPrivateDocs))
{
q.HidePrivate.True();
}
// Hide hidden?
if (!await _authorizationService.AuthorizeAsync(HttpContext.User,
Permissions.ViewHiddenDocs))
{
q.HideHidden.True();
}
// Hide spam?
if (!await _authorizationService.AuthorizeAsync(HttpContext.User,
Permissions.ViewSpamDocs))
{
q.HideSpam.True();
}
// Hide deleted?
if (!await _authorizationService.AuthorizeAsync(HttpContext.User,
Permissions.ViewDeletedDocs))
{
q.HideDeleted.True();
}
})
.GetResultsAsync(options, new PagerOptions()
{
Page = 1,
Size = int.MaxValue
}));
}
async Task <EntityIndexViewModel <Entity> > GetIndexViewModelAsync(EntityIndexOptions options, PagerOptions pager)
{
// Build results
var results = await _entityService
.ConfigureDb(o =>
{
if (_searchOptions != null)
{
o.SearchType = _searchOptions.SearchType;
}
})
.ConfigureQuery(async q =>
{
// Hide hidden?
if (!await _authorizationService.AuthorizeAsync(HttpContext.User,
Permissions.SearchHidden))
{
q.HideHidden.True();
}
// Hide spam?
if (!await _authorizationService.AuthorizeAsync(HttpContext.User,
Permissions.SearchSpam))
{
q.HideSpam.True();
}
// Hide deleted?
if (!await _authorizationService.AuthorizeAsync(HttpContext.User,
Permissions.SearchDeleted))
{
q.HideDeleted.True();
}
// Hide private?
if (!await _authorizationService.AuthorizeAsync(HttpContext.User,
Permissions.SearchPrivate))
{
q.HidePrivate.True();
}
})
.GetResultsAsync(options, pager);
// Set pager total
pager.SetTotal(results?.Total ?? 0);
// Return view model
return(new EntityIndexViewModel <Entity>
{
Results = results,
Options = options,
Pager = pager,
SortColumns = _defaultSortColumns,
SortOrder = _defaultSortOrder,
Filters = _defaultFilters
});
}
public Task <IViewComponentResult> InvokeAsync(
EntityIndexOptions options)
{
if (options == null)
{
options = new EntityIndexOptions();
}
return(Task.FromResult((IViewComponentResult)View(options)));
}
EntityIndexViewModel <Entity> GetIndexViewModel(EntityIndexOptions options, PagerOptions pager)
{
// Set pager call back Url
pager.Url = _contextFacade.GetRouteUrl(pager.Route(RouteData));
// Return updated model
return(new EntityIndexViewModel <Entity>()
{
Options = options,
Pager = pager
});
}
async Task <EntityIndexViewModel <Doc> > GetViewModel(
EntityIndexOptions options,
PagerOptions pager)
{
// Get results
var results = await _entityService
.ConfigureQuery(async q =>
{
// Hide private?
if (!await _authorizationService.AuthorizeAsync(HttpContext.User,
Permissions.ViewPrivateDocs))
{
q.HidePrivate.True();
}
// Hide hidden?
if (!await _authorizationService.AuthorizeAsync(HttpContext.User,
Permissions.ViewHiddenDocs))
{
q.HideHidden.True();
}
// Hide spam?
if (!await _authorizationService.AuthorizeAsync(HttpContext.User,
Permissions.ViewSpamDocs))
{
q.HideSpam.True();
}
// Hide deleted?
if (!await _authorizationService.AuthorizeAsync(HttpContext.User,
Permissions.ViewDeletedDocs))
{
q.HideDeleted.True();
}
})
.GetResultsAsync(options, pager);
// Set total on pager
pager.SetTotal(results?.Total ?? 0);
// Return view model
return(new EntityIndexViewModel <Doc>
{
SortColumns = _defaultSortColumns,
SortOrder = _defaultSortOrder,
Filters = _defaultFilters,
Results = results,
Options = options,
Pager = pager
});
}
public async Task <IViewComponentResult> InvokeAsync(EntityIndexOptions options, PagerOptions pager)
{
if (options == null)
{
options = new EntityIndexOptions();
}
if (pager == null)
{
pager = new PagerOptions();
}
return(View(await GetViewModel(options, pager)));
}
async Task <EntityIndexViewModel <Issue> > GetViewModel(
EntityIndexOptions options,
PagerOptions pager)
{
// Get results
var results = await _articleService
.ConfigureQuery(async q =>
{
// Hide private?
if (!await _authorizationService.AuthorizeAsync(HttpContext.User,
Permissions.ViewPrivateIssues))
{
q.HidePrivate.True();
}
// Hide private?
if (!await _authorizationService.AuthorizeAsync(HttpContext.User,
Permissions.ViewHiddenIssues))
{
q.HideHidden.True();
}
// Hide spam?
if (!await _authorizationService.AuthorizeAsync(HttpContext.User,
Permissions.ViewSpamIssues))
{
q.HideSpam.True();
}
// Hide deleted?
if (!await _authorizationService.AuthorizeAsync(HttpContext.User,
Permissions.ViewDeletedIssues))
{
q.HideDeleted.True();
}
})
.GetResultsAsync(options, pager);
// Set total on pager
pager.SetTotal(results?.Total ?? 0);
// Return view model
return(new EntityIndexViewModel <Issue>()
{
Results = results,
Options = options,
Pager = pager
});
}
async Task <EntityIndexViewModel <Issue> > GetDisplayViewModelAsync(EntityIndexOptions options, PagerOptions pager)
{
// Get feature
options.FeatureId = await GetFeatureIdAsync();
// Set pager call back Url
pager.Url = _contextFacade.GetRouteUrl(pager.Route(RouteData));
// Return updated model
return(new EntityIndexViewModel <Issue>()
{
Options = options,
Pager = pager
});
}
async Task <FeatureEntityCounts> GetFeatureEntityCountsAsync(EntityIndexOptions options)
{
return(new FeatureEntityCounts()
{
Features = await _featureEntityCountService
.ConfigureDb(o =>
{
if (_searchOptions != null)
{
o.SearchType = _searchOptions.SearchType;
}
})
.ConfigureQuery(async q =>
{
// Hide hidden?
if (!await _authorizationService.AuthorizeAsync(HttpContext.User,
Permissions.SearchHidden))
{
q.HideHidden.True();
}
// Hide spam?
if (!await _authorizationService.AuthorizeAsync(HttpContext.User,
Permissions.SearchSpam))
{
q.HideSpam.True();
}
// Hide deleted?
if (!await _authorizationService.AuthorizeAsync(HttpContext.User,
Permissions.SearchDeleted))
{
q.HideDeleted.True();
}
// Hide private?
if (!await _authorizationService.AuthorizeAsync(HttpContext.User,
Permissions.SearchPrivate))
{
q.HidePrivate.True();
}
})
.GetResultsAsync(options)
});
}
public async Task <IViewComponentResult> InvokeAsync(
EntityIndexOptions options,
PagerOptions pager)
{
if (options == null)
{
options = new EntityIndexOptions();
}
if (pager == null)
{
pager = new PagerOptions();
}
// Get search settings
//_searchSettings = await _searchSettingsStore.GetAsync();
return(View(await GetViewModel(options, pager)));
}
async Task <EntityIndexViewModel <Topic> > GetDisplayViewModelAsync(EntityIndexOptions options, PagerOptions pager)
{
// Get current feature
var feature = await _featureFacade.GetFeatureByIdAsync("Plato.Discuss");
// Restrict results to current feature
if (feature != null)
{
options.FeatureId = feature.Id;
}
// Set pager call back Url
pager.Url = _contextFacade.GetRouteUrl(pager.Route(RouteData));
return(new EntityIndexViewModel <Topic>()
{
Options = options,
Pager = pager
});
}
public async Task <IViewComponentResult> InvokeAsync(
EntityIndexOptions options,
PagerOptions pager)
{
if (options == null)
{
options = new EntityIndexOptions();
}
if (pager == null)
{
pager = new PagerOptions();
}
// Get results
var model = await GetIndexViewModelAsync(options, pager);
// Get metrics (results per feature)
var metrics = await GetFeatureEntityCountsAsync(options);
// Add metrics to context for use later within navigation builders
ViewContext.HttpContext.Items[typeof(FeatureEntityCounts)] = metrics;
// If full text is enabled add rank to sort options
if (options.Sort == SortBy.Rank)
{
var sortColumns = new List <SortColumn>()
{
new SortColumn()
{
Text = "Relevancy",
Value = SortBy.Rank
}
};
sortColumns.AddRange(model.SortColumns);
model.SortColumns = sortColumns;
}
// Return view model
return(View(model));
}
async Task <EntityIndexViewModel <Article> > GetIndexViewModelAsync(EntityIndexOptions options, PagerOptions pager)
{
// Get current feature
var feature = await _featureFacade.GetFeatureByIdAsync(RouteData.Values["area"].ToString());
// Restrict results to current feature
if (feature != null)
{
options.FeatureId = feature.Id;
}
// Set pager call back Url
pager.Url = _contextFacade.GetRouteUrl(pager.Route(RouteData));
// Return updated model
return(new EntityIndexViewModel <Article>()
{
Options = options,
Pager = pager
});
}
public async Task <IActionResult> Index(EntityIndexOptions opts, PagerOptions pager)
{
// Build options
if (opts == null)
{
opts = new EntityIndexOptions();
}
// Build pager
if (pager == null)
{
pager = new PagerOptions();
}
// Get category
var category = await _categoryStore.GetByIdAsync(opts.CategoryId);
// If supplied ensure category exists
if (category == null && opts.CategoryId > 0)
{
return(NotFound());
}
// Get default options
var defaultViewOptions = new EntityIndexOptions();
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 (opts.Filter != defaultViewOptions.Filter)
{
this.RouteData.Values.Add("opts.filter", opts.Filter);
}
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 = await GetIndexViewModelAsync(category, opts, pager);
// Add view model to context
HttpContext.Items[typeof(EntityIndexViewModel <Topic>)] = 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 && !pager.Enabled)
{
return(View("GetTopics", viewModel));
}
}
// Return Url for authentication purposes
ViewData["ReturnUrl"] = _contextFacade.GetRouteUrl(new RouteValueDictionary()
{
["area"] = "Plato.Discuss.Categories",
["controller"] = "Home",
["action"] = "Index",
["opts.categoryId"] = category != null ? category.Id.ToString() : "",
["opts.alias"] = category != null ? category.Alias.ToString() : ""
});
// Build page title
if (category != null)
{
_pageTitleBuilder.AddSegment(S[category.Name], int.MaxValue);
}
// Build breadcrumb
_breadCrumbManager.Configure(async builder =>
{
builder.Add(S["Home"], home => home
.Action("Index", "Home", "Plato.Core")
.LocalNav()
).Add(S["Discuss"], home => home
.Action("Index", "Home", "Plato.Discuss")
.LocalNav()
);
// Build breadcrumb
var parents = category != null
? await _categoryStore.GetParentsByIdAsync(category.Id)
: null;
if (parents == null)
{
builder.Add(S["Categories"]);
}
else
{
builder.Add(S["Categories"], c => c
.Action("Index", "Home", "Plato.Discuss.Categories", new RouteValueDictionary()
{
["opts.categoryId"] = null,
["opts.alias"] = null
})
.LocalNav()
);
foreach (var parent in parents)
{
if (parent.Id != category.Id)
{
builder.Add(S[parent.Name], channel => channel
.Action("Index", "Home", "Plato.Discuss.Categories", new RouteValueDictionary
{
["opts.categoryId"] = parent.Id,
["opts.alias"] = parent.Alias,
})
.LocalNav()
);
}
else
{
builder.Add(S[parent.Name]);
}
}
}
});
// Return view
return(View((LayoutViewModel)await _categoryViewProvider.ProvideIndexAsync(category, this)));
}
async Task <EntityIndexViewModel <Topic> > GetIndexViewModelAsync(Category category, EntityIndexOptions options, PagerOptions pager)
{
// Get current feature
var feature = await _featureFacade.GetFeatureByIdAsync("Plato.Discuss");
// Restrict results to current feature
if (feature != null)
{
options.FeatureId = feature.Id;
}
// Include child categories
if (category != null)
{
if (category.Children.Any())
{
// Convert child ids to list and add current id
var ids = category
.Children
.Select(c => c.Id).ToList();
ids.Add(category.Id);
options.CategoryIds = ids.ToArray();
}
else
{
options.CategoryId = category.Id;
}
}
// Ensure pinned entities appear first
if (options.Sort == SortBy.LastReply)
{
options.SortColumns.Add(SortBy.IsPinned.ToString(), OrderBy.Desc);
}
// Set pager call back Url
pager.Url = _contextFacade.GetRouteUrl(pager.Route(RouteData));
// Return updated model
return(new EntityIndexViewModel <Topic>()
{
Options = options,
Pager = pager
});
}
public async Task <IActionResult> Index(EntityIndexOptions opts, PagerOptions pager)
{
// Default options
if (opts == null)
{
opts = new EntityIndexOptions();
}
// Default pager
if (pager == null)
{
pager = new PagerOptions();
}
// Get user
var user = await _platoUserStore.GetByIdAsync(opts.CreatedByUserId);
// Ensure user exists
if (user == null)
{
return(NotFound());
}
// Get default options
var defaultViewOptions = new EntityIndexOptions();
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 (opts.Filter != defaultViewOptions.Filter)
{
this.RouteData.Values.Add("opts.filter", opts.Filter);
}
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 = await GetIndexViewModelAsync(opts, pager);
// Add view model to context
HttpContext.Items[typeof(EntityIndexViewModel <Article>)] = 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("GetArticles", viewModel));
}
}
// Build page title
_pageTitleBuilder
.AddSegment(S["Users"])
.AddSegment(S[user.DisplayName])
.AddSegment(S["Articles"]);
// Build breadcrumb
_breadCrumbManager.Configure(builder =>
{
builder.Add(S["Home"], home => home
.Action("Index", "Home", "Plato.Core")
.LocalNav()
).Add(S["Users"], users => users
.Action("Index", "Home", "Plato.Users")
.LocalNav()
).Add(S[user.DisplayName], name => name
.Action("Display", "Home", "Plato.Users", new RouteValueDictionary()
{
["opts.id"] = user.Id,
["opts.alias"] = user.Alias
})
.LocalNav()
).Add(S["Articles"]);
});
//// Return view
return(View((LayoutViewModel)await _userViewProvider.ProvideDisplayAsync(new UserIndex()
{
Id = user.Id
}, this)));
}
public override async Task <IViewProviderResult> BuildDisplayAsync(ProfilePage profile, IViewProviderContext context)
{
// Get user
var user = await _platoUserStore.GetByIdAsync(profile.Id);
// Ensure user exists
if (user == null)
{
return(await BuildIndexAsync(profile, context));
}
var indexOptions = new EntityIndexOptions()
{
CreatedByUserId = user.Id
};
var featureEntityMetrics = new FeatureEntityCounts()
{
Features = await _featureEntityCountService
.ConfigureQuery(async q =>
{
// Hide private?
if (!await _authorizationService.AuthorizeAsync(context.Controller.HttpContext.User,
Permissions.ViewPrivateEntities))
{
q.HidePrivate.True();
}
// Hide hidden?
if (!await _authorizationService.AuthorizeAsync(context.Controller.HttpContext.User,
Permissions.ViewHiddenEntities))
{
q.HideHidden.True();
}
// Hide spam?
if (!await _authorizationService.AuthorizeAsync(context.Controller.HttpContext.User,
Permissions.ViewSpamEntities))
{
q.HideSpam.True();
}
// Hide deleted?
if (!await _authorizationService.AuthorizeAsync(context.Controller.HttpContext.User,
Permissions.ViewDeletedEntities))
{
q.HideDeleted.True();
}
})
.GetResultsAsync(indexOptions)
};
var viewModel = new UserDisplayViewModel <Entity>()
{
User = user,
Counts = featureEntityMetrics,
IndexViewModel = new EntityIndexViewModel <Entity>()
{
Options = indexOptions,
Pager = new PagerOptions()
{
Page = 1,
Size = 10,
Enabled = false
}
}
};
// Return view
return(Views(
View <UserDisplayViewModel <Entity> >("Profile.Entities.Display.Content", model => viewModel)
.Zone("content")
.Order(int.MaxValue - 100)
));
}
public async Task <IActionResult> Display(EntityIndexOptions opts, PagerOptions pager)
{
// Get label
var label = await _labelStore.GetByIdAsync(opts.LabelId);
// Ensure label exists
if (label == null)
{
return(NotFound());
}
// Get default options
var defaultViewOptions = new EntityIndexOptions();
var defaultPagerOptions = new PagerOptions();
// Add non default route data for pagination purposes
if (opts.Search != defaultViewOptions.Search && !this.RouteData.Values.ContainsKey("opts.search"))
{
this.RouteData.Values.Add("opts.search", opts.Search);
}
if (opts.Sort != defaultViewOptions.Sort && !this.RouteData.Values.ContainsKey("opts.sort"))
{
this.RouteData.Values.Add("opts.sort", opts.Sort);
}
if (opts.Order != defaultViewOptions.Order && !this.RouteData.Values.ContainsKey("opts.order"))
{
this.RouteData.Values.Add("opts.order", opts.Order);
}
if (pager.Page != defaultPagerOptions.Page && !this.RouteData.Values.ContainsKey("pager.page"))
{
this.RouteData.Values.Add("pager.page", pager.Page);
}
if (pager.Size != defaultPagerOptions.Size && !this.RouteData.Values.ContainsKey("pager.size"))
{
this.RouteData.Values.Add("pager.size", pager.Size);
}
// Build view model
var viewModel = await GetDisplayViewModelAsync(opts, pager);
// Add view model to context
this.HttpContext.Items[typeof(EntityIndexViewModel <Issue>)] = 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 && !pager.Enabled)
{
return(View("GetIssues", viewModel));
}
}
// Return Url for authentication purposes
ViewData["ReturnUrl"] = _contextFacade.GetRouteUrl(new RouteValueDictionary()
{
["area"] = "Plato.Issues.Labels",
["controller"] = "Home",
["action"] = "Display",
["opts.labelId"] = label != null ? label.Id.ToString() : "",
["opts.alias"] = label != null ? label.Alias.ToString() : ""
});
// Build page title
_pageTitleBuilder.AddSegment(S[label.Name], int.MaxValue);
// Build breadcrumb
_breadCrumbManager.Configure(builder =>
{
builder.Add(S["Home"], home => home
.Action("Index", "Home", "Plato.Core")
.LocalNav()
).Add(S["Issues"], issues => issues
.Action("Index", "Home", "Plato.Issues")
.LocalNav()
).Add(S["Labels"], labels => labels
.Action("Index", "Home", "Plato.Issues.Labels")
.LocalNav()
).Add(S[label.Name]);
});
// Return view
return(View((LayoutViewModel)await _labelViewProvider.ProvideDisplayAsync(label, this)));
}
public async Task <IActionResult> Display(EntityIndexOptions opts, PagerOptions pager)
{
// Default options
if (opts == null)
{
opts = new EntityIndexOptions();
}
// Default pager
if (pager == null)
{
pager = new PagerOptions();
}
// Get tag
var tag = await _tagStore.GetByIdAsync(opts.TagId);
// Ensure tag exists
if (tag == null)
{
return(NotFound());
}
// Get default options
var defaultViewOptions = new EntityIndexOptions();
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 (opts.Filter != defaultViewOptions.Filter)
{
this.RouteData.Values.Add("opts.filter", opts.Filter);
}
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 = await GetDisplayViewModelAsync(opts, pager);
// Add view model to context
HttpContext.Items[typeof(EntityIndexViewModel <Question>)] = 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("GetQuestions", viewModel));
}
}
// Build page title
_pageTitleBuilder.AddSegment(S[tag.Name], int.MaxValue);
// Breadcrumb
_breadCrumbManager.Configure(builder =>
{
builder.Add(S["Home"], home => home
.Action("Index", "Home", "Plato.Core")
.LocalNav()
).Add(S["Questions"], questions => questions
.Action("Index", "Home", "Plato.Questions")
.LocalNav()
).Add(S["Tags"], labels => labels
.Action("Index", "Home", "Plato.Questions.Tags")
.LocalNav()
).Add(S[tag.Name]);
});
// Return view
return(View((LayoutViewModel)await _tagViewProvider.ProvideDisplayAsync(new Tag(tag), this)));
}
public async Task <IActionResult> Index(EntityIndexOptions opts, PagerOptions pager)
{
// Default options
if (opts == null)
{
opts = new EntityIndexOptions();
}
// Default pager
if (pager == null)
{
pager = new PagerOptions();
}
// Get default options
var defaultViewOptions = new EntityIndexOptions();
var defaultPagerOptions = new PagerOptions();
// Add non default route data for pagination purposes
if (opts.Search != defaultViewOptions.Search && !this.RouteData.Values.ContainsKey("opts.search"))
{
this.RouteData.Values.Add("opts.search", opts.Search);
}
if (opts.Sort != defaultViewOptions.Sort && !this.RouteData.Values.ContainsKey("opts.sort"))
{
this.RouteData.Values.Add("opts.sort", opts.Sort);
}
if (opts.Order != defaultViewOptions.Order && !this.RouteData.Values.ContainsKey("opts.order"))
{
this.RouteData.Values.Add("opts.order", opts.Order);
}
if (opts.Filter != defaultViewOptions.Filter && !this.RouteData.Values.ContainsKey("opts.filter"))
{
this.RouteData.Values.Add("opts.filter", opts.Filter);
}
if (opts.FeatureId != defaultViewOptions.FeatureId && !this.RouteData.Values.ContainsKey("opts.featureId"))
{
this.RouteData.Values.Add("opts.featureId", opts.FeatureId);
}
if (pager.Page != defaultPagerOptions.Page && !this.RouteData.Values.ContainsKey("pager.page"))
{
this.RouteData.Values.Add("pager.page", pager.Page);
}
if (pager.Size != defaultPagerOptions.Size && !this.RouteData.Values.ContainsKey("pager.size"))
{
this.RouteData.Values.Add("pager.size", pager.Size);
}
// Build view model
var viewModel = await GetIndexViewModelAsync(opts, pager);
// Add view model to context
this.HttpContext.Items[typeof(EntityIndexViewModel <Entity>)] = 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("GetEntities", viewModel));
}
}
// Return Url for authentication purposes
ViewData["ReturnUrl"] = _contextFacade.GetRouteUrl(new RouteValueDictionary()
{
["area"] = "Plato.Search",
["controller"] = "Home",
["action"] = "Index"
});
// Build breadcrumb
if (string.IsNullOrEmpty(opts.Search))
{
_breadCrumbManager.Configure(builder =>
{
builder.Add(S["Home"], home => home
.Action("Index", "Home", "Plato.Core")
.LocalNav()
).Add(S["Search"]);
});
}
else
{
_breadCrumbManager.Configure(builder =>
{
builder.Add(S["Home"], home => home
.Action("Index", "Home", "Plato.Core")
.LocalNav()
).Add(S["Search"], home => home
.Action("Index", "Home", "Plato.Search")
.LocalNav())
.Add(S["Results"]);
});
}
// Return view
return(View((LayoutViewModel)await _viewProvider.ProvideIndexAsync(new SearchResult(), this)));
}
// -----------------
// Index
// -----------------
public async Task <IActionResult> Index(EntityIndexOptions opts, PagerOptions pager)
{
// Build options
if (opts == null)
{
opts = new EntityIndexOptions();
}
// Build pager
if (pager == null)
{
pager = new PagerOptions();
}
// Get default options
var defaultViewOptions = new EntityIndexOptions();
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 (opts.Filter != defaultViewOptions.Filter)
{
this.RouteData.Values.Add("opts.filter", opts.Filter);
}
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 = await GetIndexViewModelAsync(null, opts, pager);
// Add view model to context
HttpContext.Items[typeof(EntityIndexViewModel <Doc>)] = viewModel;
// If we have a pager.page query string value return paged results
if (int.TryParse(HttpContext.Request.Query["pager.page"], out var page))
{
if (page > 0 && !pager.Enabled)
{
return(View("GetDocs", viewModel));
}
}
// Return Url for authentication purposes
ViewData["ReturnUrl"] = _contextFacade.GetRouteUrl(new RouteValueDictionary()
{
["area"] = "Plato.Docs.Categories",
["controller"] = "Home",
["action"] = "Index"
//["opts.categoryId"] = category != null ? category.Id.ToString() : string.Empty,
//["opts.alias"] = category != null ? category.Alias.ToString() : string.Empty
});
//// Build page title
//if (category != null)
//{
// _pageTitleBuilder.AddSegment(S[category.Name], int.MaxValue);
//}
// Build breadcrumb
_breadCrumbManager.Configure(async builder =>
{
builder
.Add(S["Home"], home => home
.Action("Index", "Home", "Plato.Core")
.LocalNav()
).Add(S["Docs"], docs => docs
.Action("Index", "Home", "Plato.Docs")
.LocalNav()
).Add(S["Categories"]);
});
// Return view
return(View((LayoutViewModel)await _categoryViewProvider.ProvideIndexAsync(new Category(), this)));
}
public async Task <IActionResult> Display(EntityIndexOptions opts, PagerOptions pager)
{
// Default options
if (opts == null)
{
opts = new EntityIndexOptions();
}
// Default pager
if (pager == null)
{
pager = new PagerOptions();
}
// Get tag
var tag = await _tagStore.GetByIdAsync(opts.TagId);
// Ensure tag exists
if (tag == null)
{
return(NotFound());
}
// Get default options
var defaultViewOptions = new EntityIndexOptions();
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 (opts.Filter != defaultViewOptions.Filter)
{
this.RouteData.Values.Add("opts.filter", opts.Filter);
}
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 = await GetDisplayViewModelAsync(opts, pager);
// Add view model to context
HttpContext.Items[typeof(EntityIndexViewModel <Topic>)] = 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("GetTopics", viewModel));
}
}
// Return Url for authentication purposes
ViewData["ReturnUrl"] = _contextFacade.GetRouteUrl(new RouteValueDictionary()
{
["area"] = "Plato.Discuss.Tags",
["controller"] = "Home",
["action"] = "Display",
["opts.tagId"] = tag != null ? tag.Id.ToString() : "",
["opts.alias"] = tag != null ? tag.Alias.ToString() : ""
});
// Build page title
_pageTitleBuilder.AddSegment(S[tag.Name], int.MaxValue);
// Breadcrumb
_breadCrumbManager.Configure(builder =>
{
builder.Add(S["Home"], home => home
.Action("Index", "Home", "Plato.Core")
.LocalNav()
).Add(S["Discuss"], discuss => discuss
.Action("Index", "Home", "Plato.Discuss")
.LocalNav()
).Add(S["Tags"], tags => tags
.Action("Index", "Home", "Plato.Discuss.Tags")
.LocalNav()
).Add(S[tag.Name]);
});
// Return view
return(View((LayoutViewModel)await _tagViewProvider.ProvideDisplayAsync(new Tag(tag), this)));
}
public Task <IPagedResults <TModel> > GetResultsAsync(EntityIndexOptions options)
{
return(GetResultsAsync(options, new PagerOptions()));
}
public async Task <IPagedResults <TModel> > GetResultsAsync(EntityIndexOptions options, PagerOptions pager)
{
if (options == null)
{
options = new EntityIndexOptions();
}
if (pager == null)
{
pager = new PagerOptions();
}
// Special edge case for popular entities
if (options.Sort == SortBy.Popular)
{
options.AddSortColumn(SortBy.Participants.ToString(), options.Order);
options.AddSortColumn(SortBy.Replies.ToString(), options.Order);
options.AddSortColumn(SortBy.Views.ToString(), options.Order);
options.AddSortColumn(SortBy.LastReply.ToString(), options.Order);
}
else
{
options.AddSortColumn(options.Sort.ToString(), options.Order);
}
// Get authenticated user
var user = await _contextFacade.GetAuthenticatedUserAsync();
// Return tailored results
return(await _entityStore.QueryAsync()
.Take(pager.Page, pager.Size, pager.CountTotal)
.Configure(_configureDb)
.Select <SimpleEntityQueryParams>(q =>
{
// ----------------
// Set current authenticated user id
// This is required for various security checks
// i.e. Role based security & displaying private entities
// ----------------
q.UserId.Equals(user?.Id ?? 0);
// ----------------
// Basic parameters
// ----------------
if (options.FeatureId != null && options.FeatureId.Value > 0)
{
q.FeatureId.Equals(options.FeatureId.Value);
}
if (!string.IsNullOrEmpty(options.Search))
{
q.Keywords.Like(options.Search);
}
// Multiple categories
if (options.CategoryIds != null)
{
q.CategoryId.IsIn(options.CategoryIds);
}
else
{
// A single category
if (options.CategoryId >= 0)
{
q.CategoryId.Equals(options.CategoryId);
}
}
if (options.LabelId > 0)
{
q.LabelId.Equals(options.LabelId);
}
if (options.TagId > 0)
{
q.TagId.Equals(options.TagId);
}
if (options.CreatedByUserId > 0)
{
q.CreatedUserId.Equals(options.CreatedByUserId);
}
// ----------------
// Filters
// ----------------
switch (options.Filter)
{
case FilterBy.Started:
if (user != null)
{
q.CreatedUserId.Equals(user.Id);
}
break;
case FilterBy.Participated:
if (user != null)
{
q.ParticipatedUserId.Equals(user.Id);
}
break;
case FilterBy.Following:
if (user != null)
{
q.FollowUserId.Equals(user.Id);
}
break;
case FilterBy.Starred:
if (user != null)
{
q.StarUserId.Equals(user.Id);
}
break;
case FilterBy.NoReplies:
q.TotalReplies.Equals(0);
break;
}
// ----------------
// Additional parameter configuration
// ----------------
_configureParams?.Invoke(q);
})
.OrderBy(options.SortColumns)
.ToList());
}
public async Task <IEnumerable <FeatureEntityCount> > GetResultsAsync(EntityIndexOptions options = null)
{
if (options == null)
{
options = new EntityIndexOptions();
}
// Get authenticated user
var user = await _contextFacade.GetAuthenticatedUserAsync();
// Return tailored results
var results = await _featureEntityCountStore.QueryAsync()
.Configure(_configureDb)
.Select <FeatureEntityCountQueryParams>(q =>
{
// ----------------
// Required for role based security checks
// ----------------
q.UserId.Equals(user?.Id ?? 0);
// ----------------
// Basic parameters
// ----------------
if (!string.IsNullOrEmpty(options.Search))
{
q.Keywords.Like(options.Search);
}
// Multiple categories
if (options.CategoryIds != null)
{
q.CategoryId.IsIn(options.CategoryIds);
}
else
{
// A single category
if (options.CategoryId >= 0)
{
q.CategoryId.Equals(options.CategoryId);
}
}
if (options.LabelId > 0)
{
q.LabelId.Equals(options.LabelId);
}
if (options.TagId > 0)
{
q.TagId.Equals(options.TagId);
}
if (options.CreatedByUserId > 0)
{
q.CreatedUserId.Equals(options.CreatedByUserId);
}
// ----------------
// Additional parameter configuration
// ----------------
_configureParams?.Invoke(q);
})
.OrderBy(options.SortColumns)
.ToList();
return(results?.Data);
}
