private static TermPartNode CreateNode(TermPart part)
{
return(new TermPartNode {
TermPart = part,
Level = part.Path.Count(x => x == '/')
});
}
public new IEnumerable <IContent> GetContentItems(TermPart term, int skip = 0, int count = 0, string fieldName = null)
{
var taxonomy = _taxonomyService.GetTaxonomy(term.TaxonomyId);
var baseQuery = GetContentItemsQuery(term, fieldName);
IEnumerable <IContent> termContentItems;
if (taxonomy.ContentItem.As <TaxonomyExtensionPart>().OrderBy == OrderType.PublishedUtc)
{
termContentItems = baseQuery
.Join <CommonPartRecord>()
.OrderByDescending(x => x.PublishedUtc)
.Slice(skip, count);
}
else if (taxonomy.ContentItem.As <TaxonomyExtensionPart>().OrderBy == OrderType.Title)
{
termContentItems = baseQuery
.Join <TitlePartRecord>()
.OrderBy(x => x.Title)
.Slice(skip, count);
}
else
{
termContentItems = baseQuery
.Join <CommonPartRecord>()
.OrderByDescending(x => x.CreatedUtc)
.Slice(skip, count);
}
return(termContentItems);
}
public IEnumerable <IContent> GetContentItems(TermPart term, int skip = 0, int count = 0, string fieldName = null)
{
return(GetContentItemsQuery(term, fieldName)
.Join <CommonPartRecord>()
.OrderByDescending(x => x.CreatedUtc)
.Slice(skip, count));
}
private void CreateTerm(TaxonomyPart taxonomyPart, string name)
{
TermPart term = _taxonomyService.NewTerm(taxonomyPart);
term.Name = name;
_contentManager.Create(term, VersionOptions.Published);
}
public ActionResult Index(int taxonomyId, PagerParameters pagerParameters)
{
var pager = new Pager(_siteService.GetSiteSettings(), pagerParameters);
var taxonomy = _taxonomyService.GetTaxonomy(taxonomyId);
var allTerms = TermPart.Sort(_taxonomyService.GetTermsQuery(taxonomyId).List());
var termsPage = pager.PageSize > 0 ? allTerms.Skip(pager.GetStartIndex()).Take(pager.PageSize) : allTerms;
var pagerShape = Shape.Pager(pager).TotalItemCount(allTerms.Count());
var entries = termsPage
.Select(term => term.CreateTermEntry())
.ToList();
var model = new TermAdminIndexViewModel {
Terms = entries,
Taxonomy = taxonomy,
TaxonomyId = taxonomyId,
Pager = pagerShape
};
return(View(model));
}
public IEnumerable<IContent> GetDirectContentItems(TermPart term, int skip = 0, int count = 0, string fieldName = null)
{
return GetDirectContentItemsQuery(term, fieldName)
.Join<CommonPartRecord>()
.OrderByDescending(x => x.CreatedUtc)
.Slice(skip, count);
}
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 IContentQuery <TermsPart, TermsPartRecord> GetContentItemsQuery(TermPart term, string fieldName = null)
{
var rootPath = term.FullPath + "/";
var query = _contentManager
.Query <TermsPart, TermsPartRecord>()
.WithQueryHints(new QueryHints().ExpandRecords <AutoroutePartRecord, TitlePartRecord, CommonPartRecord>());
if (String.IsNullOrWhiteSpace(fieldName))
{
query = query.Where(
tpr => tpr.Terms.Any(tr =>
tr.TermRecord.Id == term.Id ||
tr.TermRecord.Path.StartsWith(rootPath)));
}
else
{
query = query.Where(
tpr => tpr.Terms.Any(tr =>
tr.Field == fieldName &&
(tr.TermRecord.Id == term.Id || tr.TermRecord.Path.StartsWith(rootPath))));
}
return(query);
}
public IEnumerable <TermPart> GetAllTerms()
{
var result = _contentManager
.Query <TermPart, TermPartRecord>()
.List();
return(TermPart.Sort(result));
}
new public IEnumerable <TermPart> GetAllTerms()
{
var result = _contentManager
.Query <TermPart, TermPartRecord>().ForVersion(VersionOptions.Latest)
.List();
return(TermPart.Sort(result));
}
private static Tag BuildTag(TermPart term, bool leavesOnly, IEnumerable<TermPart> terms) {
return new Tag {
Value = term.Id,
Label = term.Name,
Disabled = !term.Selectable || (leavesOnly && terms.Any(t => t.Path.Contains(term.Path + term.Id))),
Levels = term.GetLevels()
};
}
public IEnumerable <TermPart> GetTerms(int taxonomyId)
{
var result = _contentManager.Query <TermPart, TermPartRecord>()
.Where(x => x.TaxonomyId == taxonomyId)
.List();
return(TermPart.Sort(result));
}
private TreeNode GetTermNode(TermPart term)
{
return(new TreeNode {
Title = term.Name,
Type = "taxonomy-term",
Id = term.Id.ToString(CultureInfo.InvariantCulture),
Url = _url.ItemEditUrl(term)
});
}
public IEnumerable <string> GetHierarchyAlternates(TermPart part)
{
var parent = part;
do
{
yield return(parent.Slug);
} while (null != (parent = parent.Container.As <TermPart>()));
}
public IEnumerable <TermPart> GetAllTerms()
{
var result = _contentManager
.Query <TermPart, TermPartRecord>()
.WithQueryHints(new QueryHints().ExpandRecords <AutoroutePartRecord, TitlePartRecord, CommonPartRecord>())
.List();
return(TermPart.Sort(result));
}
public IEnumerable <TermPart> GetChildren(TermPart term)
{
var rootPath = term.FullPath + "/";
return(_contentManager.Query <TermPart, TermPartRecord>()
.Where(x => x.Path.StartsWith(rootPath))
.List()
.OrderBy(t => t));
}
private static Tag BuildTag(TermPart term, bool leavesOnly, IEnumerable <TermPart> terms)
{
return(new Tag {
Value = term.Id,
Label = term.Name,
Disabled = !term.Selectable || (leavesOnly && terms.Any(t => t.Path.Contains(term.Path + term.Id))),
Levels = term.GetLevels()
});
}
private ContentPart CreateTermPart(TermPartDto termPartDto)
{
var termPart = new TermPart();
foreach (var contentItemDto in termPartDto.ContentItems)
{
termPart.ContentItems.Add(Create(contentItemDto));
}
return(termPart);
}
public IEnumerable <TermPart> GetChildren(TermPart term)
{
var rootPath = term.FullPath + "/";
var result = _contentManager.Query <TermPart, TermPartRecord>()
.WithQueryHints(new QueryHints().ExpandRecords <AutoroutePartRecord, TitlePartRecord, CommonPartRecord>())
.Where(x => x.Path.StartsWith(rootPath))
.List();
return(TermPart.Sort(result));
}
public ContentItem GetParentTaxonomy(TermPart part)
{
var container = _contentManager.Get(part.Container.Id);
ContentItem parentTaxonomy = container;
while (parentTaxonomy != null && parentTaxonomy.ContentType != "Taxonomy")
{
parentTaxonomy = _contentManager.Get(parentTaxonomy.As <TermPart>().Container.Id);
}
return(parentTaxonomy);
}
public void CreateTerm(TermPart termPart)
{
if (GetTermByName(termPart.TaxonomyId, termPart.Name) == null) {
_authorizationService.CheckAccess(Permissions.CreateTerm, _services.WorkContext.CurrentUser, null);
termPart.As<ICommonPart>().Container = GetTaxonomy(termPart.TaxonomyId).ContentItem;
_contentManager.Create(termPart);
}
else {
_notifier.Warning(T("The term {0} already exists in this taxonomy", termPart.Name));
}
}
public ContentItem GetParentTerm(TermPart part)
{
var container = _contentManager.Get(part.Container.Id);
if (container.ContentType != "Taxonomy")
{
return(container);
}
else
{
return(null);
}
}
public static TermEntry CreateTermEntry(this TermPart term)
{
return(new TermEntry {
Id = term.Id,
Name = term.Name,
Selectable = term.Selectable,
Count = term.Count,
Path = term.Path,
Weight = term.Weight,
IsChecked = false,
ContentItem = term.ContentItem
});
}
private List <int> GetTermsToEvict(TermPart termPart)
{
List <int> termIds = new List <int>();
// evict term
termIds.Add(termPart.Id);
// evict parents
foreach (var parent in _taxonomyService.GetParents(termPart))
{
termIds.Add(parent.Id);
}
return(termIds);
}
private void ProcessTerm(TermPart termPart, ICollection<int> processedTermPartRecordIds)
{
termPart.Count = (int)_taxonomyService.GetContentItemsCount(termPart);
processedTermPartRecordIds.Add(termPart.Id);
// Look for a parent term that has not yet been processed
if (termPart.Container != null) {
var parentTerm = termPart.Container.As<TermPart>();
if (parentTerm != null && !processedTermPartRecordIds.Contains(parentTerm.Id)) {
ProcessTerm(parentTerm, processedTermPartRecordIds);
}
}
}
public List<string> GetCategoriesWithAssociatedContentItems(TermPart packageTypeTerm) {
var categoriesList = new List<string>();
//TODO:Check
var categories = _taxonomyService.GetChildren(packageTypeTerm)
.Where(ct => _taxonomyService.GetContentItems(ct).Any())
.Select(c => c.Name).OrderBy(c => c);
if (categories.Count() > 0)
{
categoriesList.Add("All Categories");
categoriesList.AddRange(categories);
}
return categoriesList;
}
public void CreateTerm(TermPart termPart)
{
if (GetTermByName(termPart.TaxonomyId, termPart.Name) == null)
{
_authorizationService.CheckAccess(Permissions.CreateTerm, _services.WorkContext.CurrentUser, null);
termPart.As <ICommonPart>().Container = GetTaxonomy(termPart.TaxonomyId).ContentItem;
_contentManager.Create(termPart);
}
else
{
_notifier.Warning(T("The term {0} already exists in this taxonomy", termPart.Name));
}
}
private void ProcessTerm(TermPart termPart, ICollection <int> processedTermPartRecordIds)
{
termPart.Count = (int)_taxonomyService.GetContentItemsCount(termPart);
processedTermPartRecordIds.Add(termPart.Id);
// Look for a parent term that has not yet been processed
if (termPart.Container != null)
{
var parentTerm = termPart.Container.As <TermPart>();
if (parentTerm != null && !processedTermPartRecordIds.Contains(parentTerm.Id))
{
ProcessTerm(parentTerm, processedTermPartRecordIds);
}
}
}
public IEnumerable <TermPart> GetChildren(TermPart term, bool includeParent)
{
var rootPath = term.FullPath + "/";
var result = _contentManager.Query <TermPart, TermPartRecord>()
.Where(x => x.Path.StartsWith(rootPath))
.List();
if (includeParent)
{
result = result.Concat(new [] { term });
}
return(TermPart.Sort(result));
}
private void GetValueCompletoTerms(TermPart term, ref string valueTerm)
{
valueTerm = "/" + term.Name.Replace('/', '\\').Replace(";", ".,") + valueTerm;
string padre = term.FullPath.Split('/')[term.FullPath.Split('/').Length - 2];
if (padre != "")
{
// Metodo ricorsivo
TermPart termFather = _taxonomyService.GetTerm(Convert.ToInt32(padre));
GetValueCompletoTerms(termFather, ref valueTerm);
}
else
{
// Rimuovo primo carattere '/'
valueTerm = valueTerm.Substring(1);
}
}
public void DeleteTerm(TermPart termPart)
{
_contentManager.Remove(termPart.ContentItem);
foreach (var childTerm in GetChildren(termPart))
{
_contentManager.Remove(childTerm.ContentItem);
}
// delete termContentItems
var termContentItems = _termContentItemRepository
.Fetch(t => t.TermRecord == termPart.Record)
.ToList();
foreach (var termContentItem in termContentItems)
{
_termContentItemRepository.Delete(termContentItem);
}
}
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);
}
}
private void PopulateContentItems(TermPart part, MenuItem parentMenu)
{
var contentItems = _taxonomyService.GetContentItems(part);
int menuPositionIndex = 1;
var contentMenuItems = (from item in contentItems
let menuText = _contentManager.GetItemMetadata(item).DisplayText
let routes = _contentManager.GetItemMetadata(item).DisplayRouteValues
select new MenuItem
{
Text = new LocalizedString(menuText),
LinkToFirstChild = false,
RouteValues = routes,
LocalNav = true,
Items = new MenuItem[0],
Position = parentMenu.Position + "." + (menuPositionIndex++),
Content = item
}).ToList();
parentMenu.Items = contentMenuItems;
}
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 IContentQuery<TermsPart, TermsPartRecord> GetDirectContentItemsQuery(TermPart term, string fieldName = null)
{
var query = _contentManager
.Query<TermsPart, TermsPartRecord>();
if (String.IsNullOrWhiteSpace(fieldName))
{
query = query.Where(
tpr => tpr.Terms.Any(tr =>
tr.TermRecord.Id == term.Id));
}
else
{
query = query.Where(
tpr => tpr.Terms.Any(tr =>
tr.Field == fieldName
&& (tr.TermRecord.Id == term.Id)));
}
return query;
}
public JsonResult MigrateTerms(int id)
{
var lastContentItemId = id;
foreach (var taxonomy in _taxonomyService.GetTaxonomies())
{
foreach (var term in TermPart.SortObsolete(_taxonomyService.GetTerms(taxonomy.Id)))
{
term.FullWeight = "";
var container = term.Container.As <TermPart>();
for (int i = 0; i < term.Path.Count(x => x == '/') - 1; i++)
{
term.FullWeight = container.Weight.ToString("D6") + "." + container.Id + "/" + term.FullWeight;
container = container.Container.As <TermPart>();
}
term.FullWeight = term.FullWeight + term.Weight.ToString("D6") + "." + term.Id + "/";
lastContentItemId = term.Id;
}
}
return(new JsonResult {
Data = lastContentItemId
});
}
public IEnumerable<TermPart> GetDirectChildren(TermPart term) {
var directChildren = GetContainables(term.Record.ContentItemRecord);
return directChildren.List();
}
public IEnumerable<TermPart> GetChildren(TermPart term){
var rootPath = term.FullPath + "/";
return _contentManager.Query<TermPart, TermPartRecord>()
.Where(x => x.Path.StartsWith(rootPath))
.List()
.OrderBy(t => t);
}
private MediaFolder CreateMediaFolder(TermPart termPart) {
if (termPart == null) {
return null;
}
return new MediaFolder{
Name = termPart.Name,
MediaPath = termPart.FullPath,
TermId = termPart.Id,
ParentTermId = termPart.Container != null ? termPart.Container.Id : default(int?)
};
}
internal ClassMap()
{
_termPart = new TermPart<ClassMap>(this);
}
private TermPart GetPackageCategoryTerm(TermPart packageTypeTerm, string packageCategory) {
return _taxonomyService.GetChildren(packageTypeTerm).Where(t => t.Name == packageCategory).FirstOrDefault();
}
private TreeNode GetTermNode(TermPart term) {
return new TreeNode {
Title = term.Name,
Type = "taxonomy-term",
Id = term.Id.ToString(CultureInfo.InvariantCulture),
Url = _url.ItemEditUrl(term)
};
}
public void ProcessPath(TermPart term) {
var parentTerm = term.Container.As<TermPart>();
term.Path = parentTerm != null ? parentTerm.FullPath + "/": "/";
}
public void DeleteTerm(TermPart termPart) {
_contentManager.Remove(termPart.ContentItem);
foreach(var childTerm in GetChildren(termPart)) {
_contentManager.Remove(childTerm.ContentItem);
}
// delete termContentItems
var termContentItems = _termContentItemRepository
.Fetch(t => t.TermRecord == termPart.Record)
.ToList();
foreach (var termContentItem in termContentItems) {
_termContentItemRepository.Delete(termContentItem);
}
}
public IEnumerable<TermPart> GetParents(TermPart term) {
return term.Path.Split(new [] {'/'}, StringSplitOptions.RemoveEmptyEntries).Select(id => GetTerm(int.Parse(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 IEnumerable<TermPart> GetChildren(TermPart term) {
var rootPath = term.FullPath + "/";
var result = _contentManager.Query<TermPart, TermPartRecord>()
.WithQueryHints(new QueryHints().ExpandRecords<AutoroutePartRecord, TitlePartRecord, CommonPartRecord>())
.List()
.Where(x => x.Path.StartsWith(rootPath));
return TermPart.Sort(result);
}
public IEnumerable<TermPart> GetChildren(TermPart term) {
return GetChildren(term, false);
}
public void ProcessPath(TermPart term)
{
var parentTerm = term.Container.As <TermPart>();
term.Path = parentTerm != null ? parentTerm.FullPath + "/": "/";
}
public IEnumerable<string> GetHierarchyAlternates(TermPart part)
{
TermPart parent = part;
do {
yield return parent.Slug;
} while (null != (parent = parent.Container.As<TermPart>()));
}
private static TermPartNode CreateNode(TermPart part) {
return new TermPartNode {
TermPart = part,
Level = part.Path.Count(x => x == '/')
};
}
public IContentQuery<TermsPart, TermsPartRecord> GetContentItemsQuery(TermPart term, string fieldName = null) {
var rootPath = term.FullPath + "/";
var query = _contentManager
.Query<TermsPart, TermsPartRecord>()
.WithQueryHints(new QueryHints().ExpandRecords<AutoroutePartRecord, TitlePartRecord, CommonPartRecord>());
if (String.IsNullOrWhiteSpace(fieldName)) {
query = query.Where(
tpr => tpr.Terms.Any(tr =>
tr.TermRecord.Id == term.Id
|| tr.TermRecord.Path.StartsWith(rootPath)));
} else {
query = query.Where(
tpr => tpr.Terms.Any(tr =>
tr.Field == fieldName
&& (tr.TermRecord.Id == term.Id || tr.TermRecord.Path.StartsWith(rootPath))));
}
return query;
}
public IEnumerable<TermPart> GetChildren(TermPart term, bool includeParent) {
var rootPath = term.FullPath + "/";
var result = _contentManager.Query<TermPart, TermPartRecord>()
.Where(x => x.Path.StartsWith(rootPath))
.List();
if (includeParent) {
result = result.Concat(new[] { term });
}
return TermPart.Sort(result);
}
private void PopulateContentItems(TermPart part, MenuItem parentMenu)
{
var contentItems = _taxonomyService.GetContentItems(part);
int menuPositionIndex = 1;
var contentMenuItems = (from item in contentItems
let menuText = _contentManager.GetItemMetadata(item).DisplayText
let routes = _contentManager.GetItemMetadata(item).DisplayRouteValues
select new MenuItem
{
Text = new LocalizedString(menuText),
LinkToFirstChild = false,
RouteValues = routes,
LocalNav = true,
Items = new MenuItem[0],
Position = parentMenu.Position + "." + (menuPositionIndex++),
Content = item
}).ToList();
parentMenu.Items = contentMenuItems;
}
public long GetContentItemsCount(TermPart term, string fieldName = null) {
return GetContentItemsQuery(term, fieldName).Count();
}
