public async Task <IActionResult> DisplayByAliasSlug(string contentitemalias = "")
{
string contentItemId = "NotFound";
if (!string.IsNullOrEmpty(contentitemalias))
{
contentItemId = !string.IsNullOrEmpty(contentitemalias)
? await _contentHandleManager.GetContentItemIdAsync("slug:" + contentitemalias)
: "NotFound";
}
if (contentItemId == "NotFound")
{
return(NotFound($"Action:DisplayByAliasSlug-Contentitemalias:{contentitemalias}"));
}
var contentItem = await _contentManager.GetAsync(contentItemId, VersionOptions.Latest);
if (contentItem == null)
{
return(NotFound());
}
if (!await _authorizationService.AuthorizeAsync(User, OrchardCore.Contents.Permissions.ViewContent, contentItem))
{
return(User.Identity.IsAuthenticated ? (IActionResult)Forbid() : Challenge());
}
var model = await _contentItemDisplayManager.BuildDisplayAsync(contentItem, _updateModelAccessor.ModelUpdater, "Detail");
return(View(model));
}
public async Task <ActionResult <IEnumerable <object> > > GetFolders(string contentitemid,
string contentitemalias = "") //path
{
// if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageOwnMedia))
// {
// return Unauthorized();
// }
// if (string.IsNullOrEmpty(contentitemid))
// {
// contentitemid = "";
// }
string actualcontentItemId = !string.IsNullOrEmpty(contentitemalias)
? await _contentAliasManager.GetContentItemIdAsync("alias:" + contentitemalias)
: contentitemid;
if (actualcontentItemId == null)
{
return(NotFound());
}
var contentItem = await _contentManager.GetAsync(actualcontentItemId);
if (contentItem == null)
{
return(NotFound());
}
IEnumerable <ContentItem> queryResults = null;
if (!String.IsNullOrEmpty(contentitemalias))
{
var realcontentItemId = await _contentAliasManager.GetContentItemIdAsync("alias:" + contentitemalias);
queryResults = await _listContainerService.GetChildContentItems(realcontentItemId);
}
else if (!String.IsNullOrEmpty(contentitemid))
{
queryResults = await _listContainerService.GetChildContentItems(contentitemid);
}
var directoryItems = queryResults
?.Where(x => x.ContentType == "Folder" || x.ContentType == "MaterialLibraryFolder").ToList();
return(directoryItems?.Select(CreateContentItemResult).ToArray());
}
public async Task <IActionResult> ListBinderTemplates()
{
string alias = "binder-templates";
string contentItemId = alias != null
? await _contentAliasManager.GetContentItemIdAsync("alias:" + alias)
: "NotFound";
if (contentItemId == "NotFound")
{
return(NotFound());
}
var contentItem = await _contentManager.GetAsync(contentItemId, VersionOptions.Latest);
if (contentItem == null)
{
return(NotFound());
}
if (!await _authorizationService.AuthorizeAsync(User, OrchardCore.Contents.Permissions.ViewContent,
contentItem))
{
return(Unauthorized());
}
var model = await _contentItemDisplayManager.BuildDisplayAsync(contentItem, this, "DetailAdmin");
return(View("DisplayByAlias", model));
}
public async Task <IActionResult> DisplayByAlias(string alias, string displayType)
{
string contentItemId = !string.IsNullOrEmpty(alias) ? await _contentAliasManager.GetContentItemIdAsync("alias:" + alias)
: "NotFound";
if (contentItemId == "NotFound")
{
return(NotFound());
}
// ContentItem menuContentItem = await contentManager.GetAsync(contentItemId);
var contentItem = await _contentManager.GetAsync(contentItemId, VersionOptions.Latest);
if (contentItem == null)
{
return(NotFound());
}
if (!await _authorizationService.AuthorizeAsync(User, OrchardCore.Contents.Permissions.ViewContent, contentItem))
{
return(Unauthorized());
}
var model = await _contentItemDisplayManager.BuildDisplayAsync(contentItem, this, displayType);
return(View("DisplayByAlias", model));
}
public async Task <IActionResult> Render()
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageTemplates))
{
return(this.ChallengeOrForbid());
}
// Mark request as a `Preview` request so that drivers / handlers or underlying services can be aware of an active preview mode.
HttpContext.Features.Set(new ContentPreviewFeature());
var name = Request.Form["Name"];
var content = Request.Form["Content"];
if (!string.IsNullOrEmpty(name) && !string.IsNullOrEmpty(content))
{
HttpContext.Items["OrchardCore.PreviewTemplate"] = new TemplateViewModel {
Name = name, Content = content
};
}
var handle = Request.Form["Handle"].ToString();
string contentItemId;
if (string.IsNullOrEmpty(handle) || handle == _homeUrl)
{
var homeRoute = (await _siteService.GetSiteSettingsAsync()).HomeRoute;
contentItemId = homeRoute["contentItemId"]?.ToString();
}
else
{
var index = handle.IndexOf(_homeUrl, StringComparison.Ordinal);
handle = (index < 0) ? handle : handle.Substring(_homeUrl.Length);
contentItemId = await _contentHandleManager.GetContentItemIdAsync("slug:" + handle);
}
if (string.IsNullOrEmpty(contentItemId))
{
return(NotFound());
}
var contentItem = await _contentManager.GetAsync(contentItemId, VersionOptions.Published);
if (contentItem == null)
{
return(NotFound());
}
var model = await _contentItemDisplayManager.BuildDisplayAsync(contentItem, _updateModelAccessor.ModelUpdater, "Detail");
return(View(model));
}
private async Task <ContentItem> GetContentItemByAlias(string contentItemAlias = null)
{
ContentItem contentItem = null;
if (contentItemAlias != null)
{
var contentItemId = await _contentAliasManager.GetContentItemIdAsync(contentItemAlias);
contentItem = await _contentManager.GetAsync(contentItemId, VersionOptions.Latest);
}
return(contentItem);
}
private async Task <FluidValue> GetContentByHandleAsync(string handle, bool latest = false)
{
var contentItemId = await _contentHandleManager.GetContentItemIdAsync(handle);
if (contentItemId == null)
{
return(NilValue.Instance);
}
var contentItem = await _contentManager.GetAsync(contentItemId, latest?VersionOptions.Latest : VersionOptions.Published);
return(FluidValue.Create(contentItem));
}
public async Task <IActionResult> List(string part, string field, string contentitemalias, string query = "")
{
if (string.IsNullOrWhiteSpace(part) || string.IsNullOrWhiteSpace(field))
{
return(BadRequest("Part and field are required parameters"));
}
var partFieldDefinition = _contentDefinitionManager.GetPartDefinition(part)?.Fields
.FirstOrDefault(f => f.Name == field);
var fieldSettings = partFieldDefinition?.GetSettings <ContentPickerFieldSettings>();
if (fieldSettings == null)
{
return(BadRequest("Unable to find field definition"));
}
var editor = partFieldDefinition.Editor() ?? "Default";
var resultProvider = _resultProviders.FirstOrDefault(p => p.Name == editor);
if (resultProvider == null)
{
return(new ObjectResult(new List <ContentPickerResult>()));
}
//get all items of specific type
// IEnumerable<ContentItem> pageOfContentItems =
// IEnumerable<ContentItem> pageOfContentItems = (await QueryListItemsAsync(part.ContentItem, pager, true)).ToArray();
/*
* string contentItemId = "123";
*
* var query1 = _session.Query<ContentItem>()
* .With<ContainedPartIndex>(x => x.ListContentItemId == contentItemId)
* .With<ContentItemIndex>(x => x.Latest)
* .OrderByDescending(x => x.CreatedUtc);
* // .Take(pager.PageSize + 1);
*
* IEnumerable<ContentItem> containedItems = await query1.ListAsync();
*
* var treeModel = await _contentTreeService.BuildTree(containedItems);
* var showRootNode = false;
* var rootTreeModel = await GetRootTreeItem(contentItemId, showRootNode);
*
* //populate elements to root
* foreach (var contentTreeItem in treeModel)
* {
* rootTreeModel.Children.Add(contentTreeItem);
* }
*
*
*
* var trvItemCollection= MapToTreeSpecificCollection(rootTreeModel);
*
* JArray results0 = JArray.FromObject(trvItemCollection);
*
*/
string actualcontentItemId = !string.IsNullOrEmpty(contentitemalias)
? await _contentAliasManager.GetContentItemIdAsync("alias:" + contentitemalias)
: null;
if (actualcontentItemId == null)
{
return(NotFound());
}
// var rootContentItem = await _contentManager.GetAsync(actualcontentItemId);
//
// if (rootContentItem == null)
// {
// return NotFound();
// }
// var items = await _listContainerService.GetChildContentItems(rootContentItem);
var tree = await _contentTreeService.BuildContentTreeAsync(actualcontentItemId, "");
return(new ObjectResult(tree.Children));
/*
* string json = @"[{
* id: '4bc24x7t7wyb90q76xy4vx7gmy',
* label: 'Δαχτυλίδια',
* children: [ {
* id: '4atpe7a6y7nnp3wa9dp3ss5w4n',
* label: 'test product1',
*
* }, {
* id: '4gxnpabax2sgc171c4pcepkj4m',
* label: 'test product 2',
* }, {
* id: 'pear',
* label: 'Pear',
* }, {
* id: 'strawberry',
* label: 'Strawberry',
* }, {
* id: 'watermelon',
* label: 'Watermelon',
* } ],
* }, {
* id: '4tff1vpt5j2f5s4eayxnafpkxw',
* label: 'Βραχιόλα',
* children: [ {
* id: 'corn',
* label: 'Corn',
* }, {
* id: 'carrot',
* label: 'Carrot',
* }, {
* id: 'eggplant',
* label: 'Eggplant',
* }, {
* id: 'tomato',
* label: 'Tomato',
* } ],
* }] ";
*
* JArray results= new JArray();
* await Task.Run(() =>
* {
* results = JArray.Parse(json);
* });
*
* // var results = await resultProvider.Search(new ContentPickerSearchContext
* // {
* // Query = query,
* // ContentTypes = fieldSettings.DisplayedContentTypes,
* // PartFieldDefinition = partFieldDefinition
* // });
*
*
*
*
* return new ObjectResult(results);
*/
}
// public Localizer T { get; set; }
public async Task <IEnumerable <TreeNode> > GetChildren(string nodeType, string nodeId)
{
var actionContext = _serviceProvider.GetService <IActionContextAccessor>()?.ActionContext;
if (actionContext != null)
{
var urlHelperFactory = _serviceProvider.GetRequiredService <IUrlHelperFactory>();
_urlHelper = urlHelperFactory.GetUrlHelper(actionContext);
}
switch (nodeType)
{
case "root":
//Policy 1
//var item =await _contentManager.GetAsync("4v0m888rmkx0w38j95jcaa6x59");
//var rootItem= await GetContentItemNode(item);
//return new[]
//{
// rootItem
//};
var siteSettings = await _siteService.GetSiteSettingsAsync();
var contentItemAliasSettings = siteSettings.As <TreeItemAliasSettings>();
if (String.IsNullOrEmpty(contentItemAliasSettings?.ContentTypes))
{
return(new TreeNode[0]);
}
IEnumerable <string> contentItemAliases = new List <string>();
if (!String.IsNullOrEmpty(contentItemAliasSettings?.ContentTypes))
{
contentItemAliases = contentItemAliasSettings.ContentTypes
.Split(new[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries).ToList();
}
//get content itemids by alias name
List <String> contentItemIds = new List <string>();
foreach (var contentItemAliase in contentItemAliases)
{
string contentItemId = contentItemAliase != null ? await _contentAliasManager.GetContentItemIdAsync("alias:" + contentItemAliase) : "NotFound";
if (contentItemId != "NotFound")
{
contentItemIds.Add(contentItemId);
}
}
var contentItems = await _session.Query <ContentItem, ContentItemIndex>().Where(x => x.ContentItemId.IsIn(contentItemIds) && x.Latest).ListAsync();
return(contentItems.Select(async contentitem => await GetContentItemNode(contentitem)).Select(t => t.Result).OrderBy(g => g.Title));
//case "list-content-types":
// return _contentManager.GetContentTypeDefinitions()
// .Where(d => d.Parts.Any(c => c.PartDefinition.Name == "ContainerPart"))
// // .Where(d => d.Settings.GetModel<ContentTypeSettings>().Creatable)
// .OrderBy(d => d.DisplayName)
// .Select(GetContentTypeNode);
//case "list-content-type":
// return _contentManager
// .Query(VersionOptions.Latest, nodeId)
// .List()
// .Where(i => !i.Has<CommonPart>() || i.As<CommonPart>().Container == null)
// .Select(GetContentItemNode)
// .OrderBy(i => i.Title);
}
if (nodeType.StartsWith("listspecific-content-item-"))
{
// var containerId = int.Parse(nodeId);
//https://stackoverflow.com/questions/35011656/async-await-in-linq-select
var contentItem = await _contentManager.GetAsync(nodeId);
var items = await _listContainerService.GetChildContentItems(contentItem.ContentItemId);
return(items.Select(async contentitem => await GetContentItemNode(contentitem)).Select(t => t.Result).OrderBy(g => g.Title));
//return ( _session
// .Query<ContentItem>()
// .With<ContainedPartIndex>(x => x.ListContentItemId == nodeId)
// .With<ContentItemIndex>(x => x.Latest)
// .ListAsync()).Result
// .Select(GetContentItemNode)
// .OrderBy(x => x.Title);
//return _contentManager
// .Query<CommonPart, CommonPartRecord>(VersionOptions.Latest)
// .Where(i => i.Container.Id == containerId)
// .List()
// .Select(i => GetContentItemNode(i.ContentItem))
// .OrderBy(i => i.Title);
}
return(new TreeNode[0]);
}
