public TaxonomyFieldQueryObjectType()
{
Name = nameof(TaxonomyField);
Field <ListGraphType <StringGraphType>, IEnumerable <string> >()
.Name("termContentItemIds")
.Description("term content item ids")
.PagingArguments()
.Resolve(x =>
{
return(x.Page(x.Source.TermContentItemIds));
});
Field <StringGraphType, string>()
.Name("taxonomyContentItemId")
.Description("taxonomy content item id")
.Resolve(x =>
{
return(x.Source.TaxonomyContentItemId);
});
Field <ListGraphType <ContentItemInterface>, IEnumerable <ContentItem> >()
.Name("termContentItems")
.Description("the term content items")
.PagingArguments()
.ResolveAsync(async x =>
{
var ids = x.Page(x.Source.TermContentItemIds);
var context = (GraphQLContext)x.UserContext;
var contentManager = context.ServiceProvider.GetService <IContentManager>();
var taxonomy = await contentManager.GetAsync(x.Source.TaxonomyContentItemId);
if (taxonomy == null)
{
return(null);
}
var terms = new List <ContentItem>();
foreach (var termContentItemId in ids)
{
var term = TaxonomyOrchardHelperExtensions.FindTerm(taxonomy.Content.TaxonomyPart.Terms as JArray, termContentItemId);
terms.Add(term);
}
return(terms);
});
Field <ContentItemInterface, ContentItem>()
.Name("taxonomyContentItem")
.Description("the taxonomy content item")
.ResolveAsync(async x =>
{
var context = (GraphQLContext)x.UserContext;
var contentManager = context.ServiceProvider.GetService <IContentManager>();
return(await contentManager.GetAsync(x.Source.TaxonomyContentItemId));
});
}
public async Task <IActionResult> Index(string id, string taxonomyid)
{
var taxonomyContentItem = await _contentManager.GetAsync(taxonomyid);
var termContentItem = TaxonomyOrchardHelperExtensions.FindTerm(taxonomyContentItem.Content.TaxonomyPart.Terms as JArray, id);
// This part is added automatically to all terms
// termContentItem.Weld(new TermPart());
var model = await _contentItemDisplayManager.BuildDisplayAsync(termContentItem, this, "Detail");
//https://english.orchardproject.hu/blog/the-orchard-dynamic-page-pattern
return(View(model));
}
public async ValueTask <FluidValue> ProcessAsync(FluidValue input, FilterArguments arguments, TemplateContext ctx)
{
if (!ctx.AmbientValues.TryGetValue("Services", out var services))
{
throw new ArgumentException("Services missing while invoking 'inherited_terms'");
}
ContentItem taxonomy = null;
string termContentItemId = null;
var contentManager = ((IServiceProvider)services).GetRequiredService <IContentManager>();
if (input.Type == FluidValues.Object && input.ToObjectValue() is ContentItem term)
{
termContentItemId = term.ContentItemId;
}
else
{
termContentItemId = input.ToStringValue();
}
var firstArg = arguments.At(0);
if (firstArg.Type == FluidValues.Object && input.ToObjectValue() is ContentItem contentItem)
{
taxonomy = contentItem;
}
else
{
taxonomy = await contentManager.GetAsync(firstArg.ToStringValue());
}
if (taxonomy == null)
{
return(null);
}
var terms = new List <ContentItem>();
TaxonomyOrchardHelperExtensions.FindTermHierarchy(taxonomy.Content.TaxonomyPart.Terms as JArray, termContentItemId, terms);
return(FluidValue.Create(terms));
}
public override async Task <IDisplayResult> UpdateAsync(TaxonomyField field, IUpdateModel updater, UpdateFieldEditorContext context)
{
var model = new EditTagTaxonomyFieldViewModel();
if (await updater.TryUpdateModelAsync(model, Prefix, f => f.TermContentItemIds))
{
var settings = context.PartFieldDefinition.GetSettings <TaxonomyFieldSettings>();
field.TaxonomyContentItemId = settings.TaxonomyContentItemId;
field.TermContentItemIds = model.TermContentItemIds == null
? Array.Empty <string>() : model.TermContentItemIds.Split(',', StringSplitOptions.RemoveEmptyEntries);
if (settings.Required && field.TermContentItemIds.Length == 0)
{
updater.ModelState.AddModelError(
nameof(EditTagTaxonomyFieldViewModel.TermContentItemIds),
S["A value is required for '{0}'", context.PartFieldDefinition.DisplayName()]);
}
// Update display text for tags.
var taxonomy = await _contentManager.GetAsync(settings.TaxonomyContentItemId, VersionOptions.Latest);
if (taxonomy == null)
{
return(null);
}
var terms = new List <ContentItem>();
foreach (var termContentItemId in field.TermContentItemIds)
{
var term = TaxonomyOrchardHelperExtensions.FindTerm(taxonomy.Content.TaxonomyPart.Terms as JArray, termContentItemId);
terms.Add(term);
}
field.SetTagNames(terms.Select(t => t.DisplayText).ToArray());
}
return(Edit(field, context));
}
private ContentItem GetTermContentItem(TermEntry entry, ContentItem taxonomy)
{
// var term = default(TermPart);
var termContentItem = default(ContentItem);
if (taxonomy == null)
{
return(null);
}
if (!string.IsNullOrEmpty(entry.ContentItemId))
{
termContentItem =
TaxonomyOrchardHelperExtensions.FindTerm(taxonomy.Content.TaxonomyPart.Terms as JArray,
entry.ContentItemId);
}
return(termContentItem);
}
public async ValueTask <FluidValue> ProcessAsync(FluidValue input, FilterArguments arguments, LiquidTemplateContext ctx)
{
ContentItem taxonomy = null;
string termContentItemId = null;
if (input.Type == FluidValues.Object && input.ToObjectValue() is ContentItem term)
{
termContentItemId = term.ContentItemId;
}
else
{
termContentItemId = input.ToStringValue();
}
var firstArg = arguments.At(0);
if (firstArg.Type == FluidValues.Object && input.ToObjectValue() is ContentItem contentItem)
{
taxonomy = contentItem;
}
else
{
taxonomy = await _contentManager.GetAsync(firstArg.ToStringValue());
}
if (taxonomy == null)
{
return(null);
}
var terms = new List <ContentItem>();
TaxonomyOrchardHelperExtensions.FindTermHierarchy(taxonomy.Content.TaxonomyPart.Terms as JArray, termContentItemId, terms);
return(FluidValue.Create(terms, ctx.Options));
}
public override async Task BuildIndexAsync(TaxonomyField field, BuildFieldIndexContext context)
{
// TODO: Also add the parents of each term, probably as a separate field
var options = context.Settings.ToOptions();
options |= DocumentIndexOptions.Store;
// Directly selected term ids are added to the default field name
foreach (var contentItemId in field.TermContentItemIds)
{
foreach (var key in context.Keys)
{
context.DocumentIndex.Set(key, contentItemId, options);
}
}
// Inherited term ids are added to a distinct field, prefixed with "Inherited"
var contentManager = _serviceProvider.GetRequiredService <IContentManager>();
var taxonomy = await contentManager.GetAsync(field.TaxonomyContentItemId);
var inheritedContentItems = new List <ContentItem>();
foreach (var contentItemId in field.TermContentItemIds)
{
TaxonomyOrchardHelperExtensions.FindTermHierarchy(taxonomy.Content.TaxonomyPart.Terms as JArray, contentItemId, inheritedContentItems);
}
foreach (var key in context.Keys)
{
foreach (var contentItem in inheritedContentItems)
{
context.DocumentIndex.Set(key + ".Inherited", contentItem.ContentItemId, options);
}
}
}
