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 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); }
public long GetContentItemsCount(TermPart term, string fieldName = null) { return GetContentItemsQuery(term, fieldName).Count(); }