C# TermPart类代码示例

 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);
 }

 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 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 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 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 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 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> 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 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<TermPart> GetDirectChildren(TermPart term) {
            var directChildren = GetContainables(term.Record.ContentItemRecord);

            return directChildren.List();
        }

 public IEnumerable<TermPart> GetParents(TermPart term) {
     return term.Path.Split(new [] {'/'}, StringSplitOptions.RemoveEmptyEntries).Select(id => GetTerm(int.Parse(id)));
 }

 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>()));
        }