public TermPart CreateChildTermFor(TaxonomyPart taxonomy, TermPart parent, string termName, string termSlug)
{
var existingTerm = _taxonomyService.GetTermByName(taxonomy.Id, termName);
if (existingTerm != null)
{
return(existingTerm);
}
var term = _taxonomyService.NewTerm(taxonomy, parent);
_contentManager.Create(term, VersionOptions.Draft);
term.Weight = 0;
term.Name = termName.Trim();
if (!string.IsNullOrEmpty(termSlug) || !string.IsNullOrWhiteSpace(termSlug))
{
term.Slug = termSlug.Trim();
}
_contentManager.Publish(term.ContentItem);
return(term);
}
private void CreateTerm(TaxonomyPart taxonomyPart, string name)
{
var term = _taxonomyService.NewTerm(taxonomyPart);
term.Name = name;
_contentManager.Create(term, VersionOptions.Published);
}
private static TaxonomyEntry CreateTaxonomyEntry(TaxonomyPart taxonomy)
{
return(new TaxonomyEntry {
Taxonomy = taxonomy,
IsChecked = false,
});
}
public TermPart NewTerm(TaxonomyPart taxonomy, IContent parent)
{
if (taxonomy == null)
{
throw new ArgumentNullException("taxonomy");
}
if (parent != null)
{
var parentAsTaxonomy = parent.As <TaxonomyPart>();
if (parentAsTaxonomy != null && parentAsTaxonomy != taxonomy)
{
throw new ArgumentException("The parent of a term can't be a different taxonomy", "parent");
}
var parentAsTerm = parent.As <TermPart>();
if (parentAsTerm != null && parentAsTerm.TaxonomyId != taxonomy.Id)
{
throw new ArgumentException("The parent of a term can't be a from a different taxonomy", "parent");
}
}
var term = _contentManager.New <TermPart>(taxonomy.TermTypeName);
term.Container = parent ?? taxonomy;
term.TaxonomyId = taxonomy.Id;
ProcessPath(term);
return(term);
}
public async Task <TaxonomyValidationResult> Validate(TaxonomyPart part)
{
if (part.TermContentType != ContentTypes.PageLocation)
{
return(new TaxonomyValidationResult(true, null));
}
List <string> errors = new List <string>();
//make sure nothing has moved that has associated pages anywhere down the tree
List <ContentItem> allPages = await _contentItemsService.GetActive(ContentTypes.Page);
JArray?terms = _taxonomyHelper.GetAllTerms(JObject.FromObject(part.ContentItem));
if (terms != null)
{
foreach (JObject term in terms)
{
dynamic?originalParent = _taxonomyHelper.FindParentTaxonomyTerm(term, JObject.FromObject(part.ContentItem));
dynamic?newParent = _taxonomyHelper.FindParentTaxonomyTerm(term, JObject.FromObject(part));
if (originalParent == null || newParent == null)
{
throw new InvalidOperationException($"Could not find {(originalParent == null ? "original" : "new")} parent taxonomy term for {term}");
}
if (newParent?.ContentItemId != null && newParent?.ContentItemId != originalParent?.ContentItemId)
{
//find all child terms down the taxonomy tree
var childTermsFromTree = _taxonomyHelper.GetAllTerms(term);
if (allPages.Any(x => (string)x.Content.Page.PageLocations.TermContentItemIds[0] == (string)term["ContentItemId"] ! || childTermsFromTree.Any(t => (string)t["ContentItemId"] ! == (string)x.Content.Page.PageLocations.TermContentItemIds[0])))
{
errors.Add("You cannot move a Page Location which has associated Pages linked to it, or any of its children.");
}
foreach (var validator in _validators)
{
(bool validated, string errorMessage) =
await validator.ValidateUpdate(term, JObject.FromObject(part));
if (!validated)
{
errors.Add(errorMessage);
}
}
//make sure display text doesn't clash with any other term at this level
JArray parentTerms = _taxonomyHelper.GetTerms(JObject.FromObject(newParent));
if (parentTerms?.Any(x => (string)x["ContentItemId"] ! != (string)term["ContentItemId"] ! && (string)x["DisplayText"] ! == (string)term["DisplayText"] !) ?? false)
{
errors.Add("Terms at the same hierarchical position must have unique titles.");
}
}
}
}
return(new TaxonomyValidationResult(!errors.Any(), errors));
}
private void CreateTerm(TaxonomyPart tax, string termName)
{
var term = _taxonomyService.NewTerm(tax);
term.Name = termName;
term.Selectable = true;
_contentManager.Create(term, VersionOptions.Published);
}
private ContentPart CreateTaxonomyPart(TaxonomyPartDto taxonomyPartDto)
{
var taxonomyPart = new TaxonomyPart();
taxonomyPart.Terms = CreateTaxonomyItems(taxonomyPartDto.Terms);
return(taxonomyPart);
}
public TermPart NewTerm(TaxonomyPart taxonomy)
{
var term = _contentManager.New <TermPart>(taxonomy.TermTypeName);
term.TaxonomyId = taxonomy.Id;
return(term);
}
public void CreateLocalizedTermContentType(TaxonomyPart taxonomy)
{
_taxonomyService.CreateTermContentType(taxonomy);
_contentDefinitionManager.AlterTypeDefinition(taxonomy.TermTypeName,
cfg => cfg
.WithPart("LocalizationPart")
);
}
public void EditTaxonomy(TaxonomyPart taxonomy, string oldName)
{
// rename term definition
_contentDefinitionManager.AlterTypeDefinition(taxonomy.TermTypeName,
cfg => cfg
.WithSetting("Taxonomy", taxonomy.Name)
.DisplayedAs(taxonomy.Name + " Term")
);
}
private static TaxonomyEntry CreateTaxonomyEntry(TaxonomyPart taxonomy)
{
return(new TaxonomyEntry {
Id = taxonomy.Id,
Name = taxonomy.Name,
IsInternal = taxonomy.IsInternal,
ContentItem = taxonomy.ContentItem,
IsChecked = false,
});
}
public TermPart CreateTermFor(TaxonomyPart taxonomy, string termName, string termSlug)
{
var existingTerm = _taxonomyService.GetTermByName(taxonomy.Id, termName);
if (existingTerm != null)
{
return(existingTerm);
}
return(CreateChildTermFor(taxonomy, null, termName, termSlug));
}
public RegisteredPackageIdGetter(IUserkeyPackageService userkeyPackageService, IPackageService packageService, IOrchardServices orchardServices,
IUserkeyService userkeyService, IGalleryPackageService galleryPackageService, ITaxonomyService taxonomyService) {
_userkeyPackageService = userkeyPackageService;
_packageService = packageService;
_orchardServices = orchardServices;
_userkeyService = userkeyService;
_galleryPackageService = galleryPackageService;
_taxonomyService = taxonomyService;
_taxonomy = _taxonomyService.GetTaxonomyBySlug("PackageTypes");
}
public void DeleteTaxonomy(TaxonomyPart taxonomy)
{
_contentManager.Remove(taxonomy.ContentItem);
// Removing terms
foreach (var term in GetTerms(taxonomy.Id))
{
DeleteTerm(term);
}
_contentDefinitionManager.DeleteTypeDefinition(taxonomy.TermTypeName);
}
private IEnumerable <TermPart> GetTaxonomyTerms(TaxonomyField tf)
{
IEnumerable <TermPart> result = null;
var taxoSettings = tf.PartFieldDefinition.Settings;
string taxoName = taxoSettings.Where(x => x.Key == "TaxonomyFieldSettings.Taxonomy").Select(x => x.Value).FirstOrDefault();
TaxonomyPart taxoPart = _taxonomyService.GetTaxonomyByName(taxoName);
if (taxoPart != null)
{
result = taxoPart.Terms;
}
return(result);
}
private void ImportLocalizedTerms(PublishContentContext context, TaxonomyPart part)
{
// When saving a Taxonomy translation I automatically move to the taxonomy any term in the corresponding language associated to the other translations
bool termsMoved = false;
if (context.ContentItem.Has <LocalizationPart>())
{
var taxonomyCulture = context.ContentItem.As <LocalizationPart>().Culture;
if (taxonomyCulture != null)
{
var taxonomyIds = _localizationService.GetLocalizations(context.ContentItem).Select(x => x.Id);
foreach (var taxonomyId in taxonomyIds)
{
var parentTaxonomyCulture = _taxonomyService.GetTaxonomy(taxonomyId).As <LocalizationPart>().Culture;
var termIds = _taxonomyService.GetTerms(taxonomyId).Select(x => x.Id);
foreach (var termId in termIds)
{
var term = _taxonomyService.GetTerm(termId);
var parentTerm = _taxonomyExtensionsService.GetParentTerm(term);
if (term.Has <LocalizationPart>())
{
var termCulture = term.As <LocalizationPart>().Culture;
if (termCulture != null && termCulture != parentTaxonomyCulture && termCulture == taxonomyCulture)
{
term.TaxonomyId = context.ContentItem.Id;
term.Path = parentTerm != null?parentTerm.As <TermPart>().FullPath + "/" : "/";
if (parentTerm == null)
{
term.Container = context.ContentItem;
}
_taxonomyExtensionsService.RegenerateAutoroute(term.ContentItem);
termsMoved = true;
}
}
}
}
}
}
if (termsMoved)
{
_notifier.Add(NotifyType.Information, T("Terms in the chosen language have been automatically moved from the other translations."));
}
}
private TreeNode GetTaxonomyNode(TaxonomyPart taxonomy)
{
return(new TreeNode {
Title = taxonomy.Name,
Type = "taxonomy",
Id = taxonomy.Id.ToString(CultureInfo.InvariantCulture),
Url = _url.Action(
"Index", "TermAdmin",
new RouteValueDictionary {
{ "area", "Contrib.Taxonomies" },
{ "taxonomyId", taxonomy.Id }
})
});
}
public void DeleteTaxonomy(TaxonomyPart taxonomy)
{
_contentManager.Remove(taxonomy.ContentItem);
// Removing terms
foreach (var term in GetRootTerms(taxonomy.Id))
{
DeleteTerm(term);
}
if (_contentManager.Query <TaxonomyPart, TaxonomyPartRecord>().Where(x => x.Id != taxonomy.Id && x.TermTypeName == taxonomy.TermTypeName).Count() == 0)
{
_contentDefinitionManager.DeleteTypeDefinition(taxonomy.TermTypeName);
}
}
public TermPart CreateTermFor(TaxonomyPart taxonomy, string termName, string termSlug) {
var term = _taxonomyService.NewTerm(taxonomy);
term.Weight = 0;
term.Container = taxonomy.ContentItem;
term.Name = termName.Trim();
if (!string.IsNullOrEmpty(termSlug) || !string.IsNullOrWhiteSpace(termSlug))
term.Slug = termSlug.Trim();
//TODO: Commented this one - not sure if it's necessary or not
//_routableService.ProcessSlug(term.As<IRoutableAspect>());
_taxonomyService.ProcessPath(term);
_contentManager.Create(term, VersionOptions.Published);
return term;
}
public void CreateTermContentType(TaxonomyPart taxonomy)
{
// create the associated term's content type
taxonomy.TermTypeName = GenerateTermTypeName(taxonomy.Name);
_contentDefinitionManager.AlterTypeDefinition(taxonomy.TermTypeName,
cfg => cfg
.WithSetting("Taxonomy", taxonomy.Name)
.WithPart("TermPart")
.WithPart("TitlePart")
.WithPart("AutoroutePart", builder => builder
.WithSetting("AutorouteSettings.AllowCustomPattern", "true")
.WithSetting("AutorouteSettings.AutomaticAdjustmentOnEdit", "false")
.WithSetting("AutorouteSettings.PatternDefinitions", "[{Name:'Taxonomy and Title', Pattern: '{Content.Container.Path}/{Content.Slug}', Description: 'my-taxonomy/my-term/sub-term'}]"))
.WithPart("CommonPart")
.DisplayedAs(taxonomy.Name + " Term")
);
}
public void CreateTermContentType(TaxonomyPart taxonomy) {
// create the associated term's content type
taxonomy.TermTypeName = GenerateTermTypeName(taxonomy.Name);
_contentDefinitionManager.AlterTypeDefinition(taxonomy.TermTypeName,
cfg => cfg
.WithSetting("Taxonomy", taxonomy.Name)
.WithPart("TermPart")
.WithPart("TitlePart")
.WithPart("AutoroutePart", builder => builder
.WithSetting("AutorouteSettings.AllowCustomPattern", "true")
.WithSetting("AutorouteSettings.AutomaticAdjustmentOnEdit", "false")
.WithSetting("AutorouteSettings.PatternDefinitions", "[{Name:'Taxonomy and Title', Pattern: '{Content.Container.Path}/{Content.Slug}', Description: 'my-taxonomy/my-term/sub-term'}]")
.WithSetting("AutorouteSettings.DefaultPatternIndex", "0"))
.WithPart("CommonPart")
.DisplayedAs(taxonomy.Name + " Term")
);
}
public void MoveTerm(TaxonomyPart taxonomy, TermPart term, TermPart parentTerm)
{
var children = GetChildren(term);
term.Container = parentTerm == null ? taxonomy.ContentItem : parentTerm.ContentItem;
ProcessPath(term);
var contentItem = _contentManager.Get(term.ContentItem.Id, VersionOptions.DraftRequired);
_contentManager.Publish(contentItem);
foreach (var childTerm in children)
{
ProcessPath(childTerm);
contentItem = _contentManager.Get(childTerm.ContentItem.Id, VersionOptions.DraftRequired);
_contentManager.Publish(contentItem);
}
}
public TermPart CreateChildTermFor(TaxonomyPart taxonomy, TermPart parent, string termName, string termSlug)
{
var existingTerm = _taxonomyService.GetTermByName(taxonomy.Id, termName);
if (existingTerm != null)
return existingTerm;
var term = _taxonomyService.NewTerm(taxonomy, parent);
_contentManager.Create(term, VersionOptions.Draft);
term.Weight = 0;
term.Name = termName.Trim();
if (!string.IsNullOrEmpty(termSlug) || !string.IsNullOrWhiteSpace(termSlug))
term.Slug = termSlug.Trim();
_contentManager.Publish(term.ContentItem);
return term;
}
public TermPart CreateTermFor(TaxonomyPart taxonomy, string termName, string termSlug)
{
var term = _taxonomyService.NewTerm(taxonomy);
term.Weight = 0;
term.Container = taxonomy.ContentItem;
term.Name = termName.Trim();
if (!string.IsNullOrEmpty(termSlug) || !string.IsNullOrWhiteSpace(termSlug))
{
term.Slug = termSlug.Trim();
}
//TODO: Commented this one - not sure if it's necessary or not
//_routableService.ProcessSlug(term.As<IRoutableAspect>());
_taxonomyService.ProcessPath(term);
_contentManager.Create(term, VersionOptions.Published);
return(term);
}
private void CreateTerm(TaxonomyPart taxonomyPart, string name)
{
var term = _taxonomyService.NewTerm(taxonomyPart);
term.Name = name;
_contentManager.Create(term, VersionOptions.Published);
}
public void Discover(ShapeTableBuilder builder)
{
builder.Describe("Taxonomy")
.OnDisplaying(displaying => {
var shape = displaying.Shape;
var metadata = displaying.ShapeMetadata;
TaxonomyPart taxonomy = shape.ContentPart;
shape.Classes.Add("taxonomy-" + taxonomy.Slug.HtmlClassify());
shape.Classes.Add("taxonomy");
metadata.Alternates.Add("Taxonomy__" + FormatAlternate(taxonomy.Slug));
});
builder.Describe("TaxonomyItem")
.OnDisplaying(displaying => {
var shape = displaying.Shape;
var metadata = displaying.ShapeMetadata;
IContent content = shape.Taxonomy;
var taxonomy = content.As <TaxonomyPart>();
metadata.Alternates.Add("TaxonomyItem__" + FormatAlternate(taxonomy.Slug));
TermPart term = shape.ContentPart;
foreach (var alternate in GetHierarchyAlternates(term).Reverse())
{
metadata.Alternates.Add("TaxonomyItem__" + FormatAlternate(alternate));
}
});
builder.Describe("TaxonomyItemLink")
.OnDisplaying(displaying => {
var shape = displaying.Shape;
var metadata = displaying.ShapeMetadata;
IContent content = shape.Taxonomy;
var taxonomy = content.As <TaxonomyPart>();
metadata.Alternates.Add("TaxonomyItemLink__" + FormatAlternate(taxonomy.Slug));
TermPart term = shape.ContentPart;
foreach (var alternate in GetHierarchyAlternates(term).Reverse())
{
metadata.Alternates.Add("TaxonomyItemLink__" + FormatAlternate(alternate));
}
});
builder.Describe("Content")
.OnDisplaying(displaying => {
// add specific alternates for customizing a Content item when
// it is associated to a term or taxonomy
var shape = displaying.Shape;
var metadata = displaying.ShapeMetadata;
// use TermsPart to detect if the content item has a TermPart attached
// in conjunction with its field name
ContentItem contentItem = shape.ContentItem;
var termsPart = contentItem.As <TermsPart>();
if (termsPart == null)
{
return;
}
var taxonomy = displaying.Shape.Taxonomy as TaxonomyPart;
// Content__[ContentType]__[Field]__[Slug]
// Content-Image-MainColor-Blue.cshtml
// Content-Image-MainColor-Blue-Light-Blue.cshtml
// Content_[DisplayType]__[ContentType]__[Field]__[Slug]
// Content-Image-MainColor-Blue.Summary.cshtml
// Content-Image-MainColor-Blue-Light-Blue.Summary.cshtml
foreach (var termContentItem in termsPart.TermParts)
{
var field = termContentItem.Field;
var termPart = termContentItem.TermPart;
foreach (var parent in GetHierarchyAlternates(termPart).Reverse())
{
var formatted = FormatAlternate(parent);
metadata.Alternates.Add(String.Concat("Content__", contentItem.ContentType, "__", field, "__", formatted));
metadata.Alternates.Add(String.Concat("Content_", metadata.DisplayType, "__", contentItem.ContentType, "__", field, "__", formatted));
}
}
});
}
public void EditTaxonomy(TaxonomyPart taxonomy, string oldName)
{
// rename term definition
_contentDefinitionManager.AlterTypeDefinition(taxonomy.TermTypeName,
cfg => cfg
.WithSetting("Taxonomy", taxonomy.Name)
.DisplayedAs(taxonomy.Name + " Term")
);
}
public TermPart NewTerm(TaxonomyPart taxonomy) {
return NewTerm(taxonomy, null);
}
private TreeNode GetTaxonomyNode(TaxonomyPart taxonomy) {
return new TreeNode {
Title = taxonomy.Name,
Type = "taxonomy",
Id = taxonomy.Id.ToString(CultureInfo.InvariantCulture),
Url = _url.Action(
"Index", "TermAdmin",
new RouteValueDictionary {
{"area", "Contrib.Taxonomies"},
{"taxonomyId", taxonomy.Id}
})
};
}
public void MoveTerm(TaxonomyPart taxonomy, TermPart term, TermPart parentTerm) {
var children = GetChildren(term);
term.Container = parentTerm == null ? taxonomy.ContentItem : parentTerm.ContentItem;
ProcessPath(term);
var contentItem = _contentManager.Get(term.ContentItem.Id, VersionOptions.DraftRequired);
_contentManager.Publish(contentItem);
foreach (var childTerm in children) {
ProcessPath(childTerm);
contentItem = _contentManager.Get(childTerm.ContentItem.Id, VersionOptions.DraftRequired);
_contentManager.Publish(contentItem);
}
}
public TermPart NewTerm(TaxonomyPart taxonomy) {
var term = _contentManager.New<TermPart>(taxonomy.TermTypeName);
term.TaxonomyId = taxonomy.Id;
return term;
}
public TermPart CreateTermFor(TaxonomyPart taxonomy, string termName, string termSlug)
{
var existingTerm = _taxonomyService.GetTermByName(taxonomy.Id, termName);
if (existingTerm != null)
return existingTerm;
return CreateChildTermFor(taxonomy, null, termName, termSlug);
}
public TermPart NewTerm(TaxonomyPart taxonomy)
{
return(NewTerm(taxonomy, null));
}
public TermPart NewTerm(TaxonomyPart taxonomy, IContent parent) {
if (taxonomy == null) {
throw new ArgumentNullException("taxonomy");
}
if (parent != null) {
var parentAsTaxonomy = parent.As<TaxonomyPart>();
if (parentAsTaxonomy != null && parentAsTaxonomy != taxonomy) {
throw new ArgumentException("The parent of a term can't be a different taxonomy", "parent");
}
var parentAsTerm = parent.As<TermPart>();
if (parentAsTerm != null && parentAsTerm.TaxonomyId != taxonomy.Id) {
throw new ArgumentException("The parent of a term can't be a from a different taxonomy", "parent");
}
}
var term = _contentManager.New<TermPart>(taxonomy.TermTypeName);
term.Container = parent ?? taxonomy;
term.TaxonomyId = taxonomy.Id;
ProcessPath(term);
return term;
}
private void CreateTerm(TaxonomyPart taxonomyPart, string termName, int order) {
if (taxonomyPart != null && termName != null)
{
var term = _taxonomyService.NewTerm(taxonomyPart);
term.Container = taxonomyPart.ContentItem;
term.Name = termName.Trim();
term.Weight = order;
term.Selectable = true;
_taxonomyService.ProcessPath(term);
_contentManager.Create(term, VersionOptions.Published);
}
}
public void DeleteTaxonomy(TaxonomyPart taxonomy) {
_contentManager.Remove(taxonomy.ContentItem);
// Removing terms
foreach (var term in GetTerms(taxonomy.Id)) {
DeleteTerm(term);
}
_contentDefinitionManager.DeleteTypeDefinition(taxonomy.TermTypeName);
}
private void CreateTerm(TaxonomyPart genre, string genreName) {
var term = _taxonomyService.NewTerm(genre);
term.Name = genreName;
_contentManager.Create(term, VersionOptions.Published);
}
public void CreateCategory(TaxonomyPart taxonomy, string category, string parent = null, bool selectable = false) {
var term = _taxonomyService.GetTermByName(taxonomy.Id, category);
if (term == null)
{
if (parent == null)
{
term = _taxonomyService.NewTerm(taxonomy);
}
else
{
var parentTerm = _taxonomyService.GetTermByName(taxonomy.Id, parent);
// If parent doesnt exist, create it
if (parentTerm == null)
{
CreateCategory(taxonomy, parent);
}
term = _taxonomyService.NewTerm(taxonomy, parentTerm);
}
term.Name = category;
term.Selectable = selectable;
_contentManager.Create(term);
}
}
