public TermPartHandler(
IRepository<TermPartRecord> repository,
ITaxonomyService taxonomyService,
ITermPathConstraint termPathConstraint ) {
Filters.Add(StorageFilter.For(repository));
OnRemoved<IContent>(
(context, tags) =>
taxonomyService.DeleteAssociatedTerms(context.ContentItem)
);
OnInitializing<TermPart>(
(context, part) =>
part.Selectable = true
);
OnPublished<TermPart>(
(context, part) => {
termPathConstraint.AddPath(part.Slug);
foreach (var child in taxonomyService.GetChildren(part)) {
termPathConstraint.AddPath(child.Slug);
}
});
OnUnpublishing<TermPart>(
(context, part) =>
termPathConstraint.RemovePath(part.Slug)
);
}
public IEnumerable <TreeNode> GetChildren(string nodeType, string nodeId)
{
switch (nodeType)
{
case "root":
return(new[] {
GetTaxonomiesNode()
});
case "taxonomies":
return(_taxonomyService.GetTaxonomies()
.Select(GetTaxonomyNode)
.OrderBy(n => n.Title)
.ToList());
case "taxonomy":
var taxonomyId = int.Parse(nodeId);
return(_taxonomyService.GetTerms(taxonomyId)
.Where(t => t.Path.Trim('/') == "")
.Select(
t => new TreeNode {
Title = t.Name,
Type = "taxonomy-term",
Id = t.Id.ToString(CultureInfo.InvariantCulture),
Url = _url.ItemEditUrl(t)
}
)
.OrderBy(n => n.Title)
.ToList());
case "taxonomy-term":
var termId = int.Parse(nodeId);
var term = _taxonomyService.GetTerm(termId);
var childTermNodes = _taxonomyService
.GetChildren(term)
.Select(GetTermNode)
.OrderBy(n => n.Title);
var childItems = _taxonomyService
.GetContentItemsQuery(term)
.Where(i => i.Terms.Any(tr => tr.TermRecord.Id == term.Id))
.List()
.Select(GetContentItemNode)
.OrderBy(n => n.Title);
return(childTermNodes
.Union(childItems)
.ToList());
}
return(new TreeNode[0]);
}
public void ApplyFilter(dynamic context)
{
var termIds = (string)context.State.TermIds;
if (!String.IsNullOrEmpty(termIds))
{
var ids = termIds.Split(new[] { ',' }).Select(Int32.Parse).ToArray();
if (ids.Length == 0)
{
return;
}
int op = Convert.ToInt32(context.State.Operator);
var terms = ids.Select(_taxonomyService.GetTerm).ToList();
var allChildren = new List <TermPart>();
foreach (var term in terms)
{
allChildren.AddRange(_taxonomyService.GetChildren(term));
allChildren.Add(term);
}
allChildren = allChildren.Distinct().ToList();
var allIds = allChildren.Select(x => x.Id).ToList();
switch (op)
{
case 0:
// is one of
Action <IAliasFactory> s = alias => alias.ContentPartRecord <TermsPartRecord>().Property("Terms", "terms").Property("TermRecord", "termRecord");
Action <IHqlExpressionFactory> f = x => x.InG("Id", allIds);
context.Query.Where(s, f);
break;
case 1:
// is all of
foreach (var id in allIds)
{
var termId = id;
Action <IAliasFactory> selector =
alias => alias.ContentPartRecord <TermsPartRecord>().Property("Terms", "terms" + termId);
Action <IHqlExpressionFactory> filter = x => x.Eq("TermRecord.Id", termId);
context.Query.Where(selector, filter);
}
break;
}
}
}
public JObject Terms(IContent content, int maxLevel = 10)
{
JObject json;
_maxLevel = maxLevel;
dynamic contentToSerialize = null, termPart = null;
try {
if (content.ContentItem.ContentType.EndsWith("Taxonomy"))
{
contentToSerialize = content;
json = new JObject(SerializeObject(content, 0, 0, new string[] { "TaxonomyPart" }));
var terms = content.As <TaxonomyPart>().Terms;
var resultArray = new JArray();
foreach (var resulted in terms)
{
resultArray.Add(new JObject(SerializeObject(resulted.ContentItem, 0, content.Id)));
}
JObject taxonomy = json.First.First as JObject; //The Taxonomy node
taxonomy.Add("Terms", resultArray);
//NormalizeSingleProperty(json);
return(json);
}
else if (content.ContentItem.ContentType.EndsWith("Term") || !string.IsNullOrWhiteSpace(content.ContentItem.TypeDefinition.Settings["Taxonomy"]))
{
termPart = ((dynamic)content.ContentItem).TermPart;
if (termPart != null)
{
json = new JObject(SerializeObject(content, 0, 0));
contentToSerialize = _taxonomyService.GetChildren(termPart, false);
var resultArray = new JArray();
foreach (var resulted in contentToSerialize)
{
resultArray.Add(new JObject(SerializeObject(resulted.ContentItem, 0, termPart.Id)));
}
JObject rootTerm = json.First.First as JObject; //The first term node
rootTerm.Add("SubTerms", resultArray);
return(json);
}
}
}
catch {
}
return(null);
}
private IEnumerable <TermPart> GetTerms(int termId, bool andChildren)
{
var term = _taxonomyService.GetTerm(termId);
if (term == null)
{
return(Enumerable.Empty <TermPart>());
}
var ts = new List <TermPart>()
{
term
};
if (andChildren)
{
ts.AddRange(_taxonomyService.GetChildren(term));
}
return(ts);
}
protected override DriverResult Editor(TermPart termPart, IUpdateModel updater, dynamic shapeHelper)
{
updater.TryUpdateModel(termPart, Prefix, null, null);
StringBuilder fullWeightBuilder = new StringBuilder();
string parentOldFullWeight = termPart.FullWeight == null ? termPart.FullWeight : "";
TermPart containerTerm = termPart;
for (int i = 0; i < termPart.Path.Count(x => x == '/') - 1; i++)
{
containerTerm = containerTerm.Container.As <TermPart>();
fullWeightBuilder.Insert(0, containerTerm.Weight.ToString("D6") + "." + containerTerm.Id.ToString() + "/");
}
fullWeightBuilder.Append(termPart.Weight.ToString("D6") + "." + "/");
termPart.FullWeight = fullWeightBuilder.ToString();
foreach (var childTerm in _taxonomyService.GetChildren(termPart))
{
childTerm.FullWeight = _taxonomyService.ProcessChildrenFullWeight(childTerm.FullWeight, termPart.FullWeight, parentOldFullWeight);
}
return(Editor(termPart, shapeHelper));
}
public JObject Terms(IContent content, int maxLevel = 10)
{
JObject json;
_maxLevel = maxLevel;
dynamic contentToSerialize = null, termPart = null;
try {
if (content.ContentItem.ContentType.EndsWith("Taxonomy"))
{
contentToSerialize = content;
json = new JObject(SerializeObject(content, 0));
//NormalizeSingleProperty(json);
return(json);
}
else if (content.ContentItem.ContentType.EndsWith("Term") || !String.IsNullOrWhiteSpace(content.ContentItem.TypeDefinition.Settings["Taxonomy"]))
{
termPart = ((dynamic)content.ContentItem).TermPart;
if (termPart != null)
{
json = new JObject(SerializeObject(content, 0));
contentToSerialize = _taxonomyService.GetChildren(termPart, false);
var resultArray = new JArray();
foreach (var resulted in contentToSerialize)
{
resultArray.Add(new JObject(SerializeObject(resulted, 0)));
}
json.Add("SubTerms", resultArray);
//NormalizeSingleProperty(json);
return(json);
}
}
} catch {
}
return(null);
}
public void DumpList(DumperServiceContext context)
{
if (ShouldDoSomething(context.Content.ContentItem))
{
var part = context.Content
.ContentItem
.As <TermPart>();
if (part != null)
{
var mainSb = new StringBuilder();
mainSb.Append("{");
Func <IContent, int, XElement> dumpFunc;
if (context.ResultTarget == ResultTarget.Contents)
{
mainSb.AppendFormat("\"n\": \"{0}\"", "TaxonomyTermList");
mainSb.AppendFormat(", \"v\": \"{0}\"", "ContentItem[]");
dumpFunc = (item, index) => context.GetDumper()
.Dump(item.ContentItem, string.Format("[{0}]", index));
}
else
{
mainSb.AppendFormat("\"n\": \"{0}\"", "TermPartList");
mainSb.AppendFormat(", \"v\": \"{0}\"", "TermPart[]");
dumpFunc = (item, index) => context.GetDumper()
.Dump(item, "TermPart");
}
mainSb.Append(", \"m\": [");
IEnumerable <IContent> termContentItems;
if (context.ResultTarget == ResultTarget.Terms)
{
termContentItems = _taxonomyService
.GetChildren(part, true);
}
else if (context.ResultTarget == ResultTarget.SubTerms)
{
termContentItems = _taxonomyService
.GetChildren(part, false);
}
else
{
termContentItems = _taxonomyService
.GetContentItems(part, (context.Page - 1) * context.PageSize, context.PageSize);
}
if (termContentItems.Any())
{
mainSb.Append(
string.Join(",", termContentItems
.Select((ci, index) => {
var sb = new StringBuilder();
sb.Append("{");
context.ConvertToJson(dumpFunc(ci, index), sb);
sb.Append("}");
return(sb.ToString());
}))
);
}
mainSb.Append("]");
mainSb.Append("}");
// Add the serialization to the results
context.ContentLists.Add(mainSb.ToString());
}
}
}
public void ApplyFilter(dynamic context)
{
var httpContext = _orchardServices.WorkContext.HttpContext;
var path = httpContext.Request.AppRelativeCurrentExecutionFilePath.Replace("~/", string.Empty);
var routeValues = _aliasService.Get(path);
if (routeValues == null)
{
return;
}
object id;
if (routeValues.TryGetValue("id", out id))
{
var castedId = Convert.ToInt32(id);
var ids = _taxonomyService.GetTermsForContentItem(castedId).Select(o => o.Id).ToList();
if (ids.Any())
{
int op = Convert.ToInt32(context.State.Operator);
int?taxonomyId = context.State.TaxonomyId != null?Convert.ToInt32(context.State.TaxonomyId) : default(int?);
var terms = ids.Select(_taxonomyService.GetTerm);
var allChildren = new List <TermPart>();
if (taxonomyId != null)
{
var selectedTerm = _taxonomyService.GetTermsForContentItem(castedId).FirstOrDefault(x => x.TaxonomyId == taxonomyId);
if (selectedTerm != null)
{
terms = terms.Where(x => x.Id == selectedTerm.Id);
}
}
foreach (var term in terms)
{
allChildren.AddRange(_taxonomyService.GetChildren(term));
allChildren.Add(term);
}
allChildren = allChildren.Distinct().ToList();
var predicates = allChildren.Select(localTerm => (Action <IHqlExpressionFactory>)(a => a.Eq("Id", localTerm.Id))).ToList();
switch (op)
{
case 0:
// is one of
Action <IAliasFactory> selector1 = alias => alias.ContentPartRecord <TermsPartRecord>().Property("Terms", "terms").Property("TermRecord", "termRecord");
Action <IHqlExpressionFactory> filterA = x => x.Disjunction(predicates.Take(1).Single(), predicates.Skip(1).ToArray());
context.Query.Where(selector1, filterA);
if (context.State.IncludeSelf == null)
{
Action <IAliasFactory> selector2 = alias => alias.ContentItem();
Action <IHqlExpressionFactory> filter2 = x => x.Eq("Id", castedId);
Action <IHqlExpressionFactory> filter2Not = x => x.Not(filter2);
context.Query.Where(selector2, filter2Not);
}
break;
case 1:
// is not one of
Action <IAliasFactory> selector = alias => alias.ContentPartRecord <TermsPartRecord>().Property("Terms", "terms").Property("TermRecord", "termRecord");
Action <IHqlExpressionFactory> filterB = x => x.Disjunction(predicates.Take(1).Single(), predicates.Skip(1).ToArray());
context.Query.Where(selector, filterB);
break;
case 2:
// is all of
break;
}
}
}
}
private ActionResult GetContent(IContent content, SourceTypes sourceType = SourceTypes.ContentItem, ResultTarget resultTarget = ResultTarget.Contents, string fieldspartsFilter = "", int page = 1, int pageSize = 10, bool tinyResponse = true, bool minified = false, bool realformat = false, int deeplevel = 10, string[] complexBehaviour = null)
{
var result = new ContentResult {
ContentType = "application/json"
};
var jsonString = "{}";
var _filterContentFieldsParts = fieldspartsFilter.ToLower().Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
XElement dump;
XElement projectionDump = null;
// il dump dell'oggetto principale non filtra per field
ObjectDumper dumper = new ObjectDumper(deeplevel, null, false, tinyResponse, complexBehaviour);
dynamic shape; //, specificShape;
var sb = new StringBuilder();
List <XElement> listContent = new List <XElement>();
// verifico se l'oggetto è soggetto all'accettazione delle policies
var policy = content.As <Policy.Models.PolicyPart>();
//if (policy != null) {
// if ((String.IsNullOrWhiteSpace(_orchardServices.WorkContext.HttpContext.Request.QueryString["v"]))) {// E' soggetto a privacy, quindi faccio sempre il redirect se manca il parametro in querystring v=
// if (policy.HasPendingPolicies ?? false) { // se ha delle pending policies deve restituire le policy text, legate al contenuto, qui ndi non deve mai servire cache
// var redirectUrl = String.Format("{0}{1}v={2}", _orchardServices.WorkContext.HttpContext.Request.RawUrl, (_orchardServices.WorkContext.HttpContext.Request.RawUrl.Contains("?") ? "&" : "?"), Guid.NewGuid());
// _orchardServices.WorkContext.HttpContext.Response.Redirect(redirectUrl, true);
// } else {// se NON ha delle pending policies deve restituire un url non cacheato (quindi aggiungo v=),
// var redirectUrl = String.Format("{0}{1}v={2}", _orchardServices.WorkContext.HttpContext.Request.RawUrl, (_orchardServices.WorkContext.HttpContext.Request.RawUrl.Contains("?") ? "&" : "?"), "cached-content");
// _orchardServices.WorkContext.HttpContext.Response.Redirect(redirectUrl, true);
// //_orchardServices.WorkContext.HttpContext.Response.Redirect(redirectUrl, true);
// }
// return null; // in entrambi i casi ritorno null come risultato della current request
// }
//}
if (policy != null && (_policyServices.HasPendingPolicies(content.ContentItem) ?? false)) // Se l'oggetto ha delle pending policies allora devo serivre la lista delle pending policies
//policy.PendingPolicies
{
sb.Insert(0, "{");
sb.AppendFormat("\"n\": \"{0}\"", "Model");
sb.AppendFormat(", \"v\": \"{0}\"", "VirtualContent");
sb.Append(", \"m\": [{");
sb.AppendFormat("\"n\": \"{0}\"", "VirtualId"); // Unused property for mobile mapper needs
sb.AppendFormat(", \"v\": \"{0}\"", "0");
sb.Append("}]");
sb.Append(", \"l\":[");
int i = 0;
sb.Append("{");
sb.AppendFormat("\"n\": \"{0}\"", "PendingPolicies");
sb.AppendFormat(", \"v\": \"{0}\"", "ContentItem[]");
sb.Append(", \"m\": [");
foreach (var item in _policyServices.PendingPolicies(content.ContentItem))
{
if (i > 0)
{
sb.Append(",");
}
sb.Append("{");
dumper = new ObjectDumper(deeplevel, _filterContentFieldsParts, false, tinyResponse, complexBehaviour);
projectionDump = dumper.Dump(item, String.Format("[{0}]", i));
JsonConverter.ConvertToJSon(projectionDump, sb, minified, realformat);
sb.Append("}");
i++;
}
sb.Append("]");
sb.Append("}");
sb.Append("]"); // l : [
sb.Append("}");
}
else // Se l'oggetto NON ha delle pending policies allora posso servire l'oggetto stesso
{
shape = _orchardServices.ContentManager.BuildDisplay(content);
if (sourceType == SourceTypes.ContentItem)
{
dump = dumper.Dump(content, "Model");
}
else
{
dump = dumper.Dump(shape, "Model");
}
//dump.XPathSelectElements("");
//var filteredDump = dump.Descendants();
//ConvertToJSon(dump, sb);
JsonConverter.ConvertToJSon(dump, sb, minified, realformat);
sb.Insert(0, "{");
sb.Append(", \"l\":[");
// Dopo avere convertito il contentItem in JSON aggiungo i Json delle eventuali liste
dynamic part = null;
var firstList = true;
var listDumpedContentIds = new List <int>();
#region [ProjectionPart ]
try {
part = shape.ContentItem.ProjectionPart;
} catch {
part = null;
}
if (part != null)
{
if (!firstList)
{
sb.Append(",");
}
firstList = false;
var queryId = part.Record.QueryPartRecord.Id;
var queryItems = _projectionManager.GetContentItems(queryId, (page - 1) * pageSize, pageSize);
int i = 0;
sb.Append("{");
sb.AppendFormat("\"n\": \"{0}\"", "ProjectionList");
sb.AppendFormat(", \"v\": \"{0}\"", "ContentItem[]");
sb.Append(", \"m\": [");
foreach (var item in queryItems)
{
if (i > 0)
{
sb.Append(",");
}
sb.Append("{");
dumper = new ObjectDumper(deeplevel, _filterContentFieldsParts, false, tinyResponse, complexBehaviour);
projectionDump = dumper.Dump(item, String.Format("[{0}]", i));
JsonConverter.ConvertToJSon(projectionDump, sb, minified, realformat);
sb.Append("}");
i++;
}
sb.Append("]");
sb.Append("}");
}
part = null;
#endregion [ProjectionPart ]
#region [CalendarPart ]
try {
part = shape.ContentItem.CalendarPart;
} catch {
part = null;
}
if (part != null)
{
if (!firstList)
{
sb.Append(",");
}
firstList = false;
if (_orchardServices.WorkContext.TryResolve <IEventsService>(out _eventsService)) // non sempre questo modulo è attivo quindi se non riesce a risolvere il servizio, bypassa la chiamata
{
var queryItems = _eventsService.GetAggregatedList(part, page, pageSize);
int i = 0;
sb.Append("{");
sb.AppendFormat("\"n\": \"{0}\"", "EventList");
sb.AppendFormat(", \"v\": \"{0}\"", "ContentItem[]");
sb.Append(", \"m\": [");
foreach (var item in queryItems)
{
if (i > 0)
{
sb.Append(",");
}
sb.Append("{");
dumper = new ObjectDumper(deeplevel, _filterContentFieldsParts, false, tinyResponse, complexBehaviour);
projectionDump = dumper.Dump(item, String.Format("[{0}]", i));
JsonConverter.ConvertToJSon(projectionDump, sb);
sb.Append("}");
i++;
}
sb.Append("]");
sb.Append("}");
}
}
part = null;
#endregion [CalendarPart ]
#region [ExernalField]
var ExtertalFields = (dynamic)
(from parte in ((ContentItem)shape.ContentItem).Parts
from field in parte.Fields
where (field.GetType().Name == "FieldExternal" && ((dynamic)field).Setting.GenerateL)
select field).FirstOrDefault();
if (ExtertalFields != null)
{
if (!firstList)
{
sb.Append(",");
}
firstList = false;
//sb.Append("{");
//sb.AppendFormat("\"n\": \"{0}\"", "ExternalContent");
//sb.AppendFormat(", \"v\": \"{0}\"", "ExternalContent");
//sb.Append(", \"m\": [");
sb.Append("{");
dumper = new ObjectDumper(deeplevel, _filterContentFieldsParts, false, tinyResponse, complexBehaviour);
//nameDynamicJsonArray = "List<generic>";
if (ExtertalFields.ContentObject != null)
{
if (ExtertalFields.ContentObject.GetType() == typeof(ExternalFieldRemoteException))
{
throw new ExternalFieldRemoteException();
}
projectionDump = dumper.Dump(cleanobj(ExtertalFields.ContentObject), ExtertalFields.Name, "List<generic>");
JsonConverter.ConvertToJSon(projectionDump, sb, minified, realformat);
}
// sb.Append("}]}");
sb.Append("}");
}
#endregion [ExernalField]
#region [ WidgetsContainerPart ]
try {
part = shape.ContentItem.WidgetsContainerPart;
} catch {
part = null;
}
if (part != null)
{
//var queryId = part.Record.QueryPartRecord.Id;
if (_orchardServices.WorkContext.TryResolve <IWidgetManager>(out _widgetManager)) // non semepre questo modulo è attivo quindi se non riesce a risolvere il servizio, bypassa la chiamata
{
if (!firstList)
{
sb.Append(",");
}
firstList = false;
var queryItems = _widgetManager.GetWidgets(part.Id);
int i = 0;
sb.Append("{");
sb.AppendFormat("\"n\": \"{0}\"", "WidgetList");
sb.AppendFormat(", \"v\": \"{0}\"", "ContentItem[]");
sb.Append(", \"m\": [");
foreach (var item in queryItems)
{
if (i > 0)
{
sb.Append(",");
}
sb.Append("{");
dumper = new ObjectDumper(deeplevel, _filterContentFieldsParts, false, tinyResponse, complexBehaviour);
projectionDump = dumper.Dump(item, String.Format("[{0}]", i));
JsonConverter.ConvertToJSon(projectionDump, sb, minified, realformat);
sb.Append("}");
i++;
}
sb.Append("]");
sb.Append("}");
}
}
#endregion [ WidgetsContainerPart ]
#region [ Taxonomy/TermsPart ]
part = null;
try {
if (shape.ContentItem.ContentType.EndsWith("Term") || !String.IsNullOrWhiteSpace(shape.ContentItem.TypeDefinition.Settings["Taxonomy"]))
{
part = shape.ContentItem.TermPart;
}
} catch {
part = null;
}
if (part != null)
{
if (!firstList)
{
sb.Append(",");
}
firstList = false;
dynamic termContentItems;
if (resultTarget == ResultTarget.Terms)
{
termContentItems = _taxonomyService.GetChildren(part, true);
}
else if (resultTarget == ResultTarget.SubTerms)
{
termContentItems = _taxonomyService.GetChildren(part, false);
}
else
{
termContentItems = _taxonomyService.GetContentItems(part, (page - 1) * pageSize, pageSize);
}
int i = 0;
sb.Append("{");
if (resultTarget == ResultTarget.Contents)
{
sb.AppendFormat("\"n\": \"{0}\"", "TaxonomyTermList");
sb.AppendFormat(", \"v\": \"{0}\"", "ContentItem[]");
}
else
{
sb.AppendFormat("\"n\": \"{0}\"", "TermPartList");
sb.AppendFormat(", \"v\": \"{0}\"", "TermPart[]");
}
sb.Append(", \"m\": [");
foreach (var item in termContentItems)
{
if (i > 0)
{
sb.Append(",");
}
sb.Append("{");
dumper = new ObjectDumper(deeplevel, _filterContentFieldsParts, false, tinyResponse, complexBehaviour);
if (resultTarget == ResultTarget.Contents)
{
projectionDump = dumper.Dump(item.ContentItem, String.Format("[{0}]", i));
JsonConverter.ConvertToJSon(projectionDump, sb, minified, realformat);
}
else
{
var dumperForPart = new ObjectDumper(deeplevel, _filterContentFieldsParts, true, tinyResponse, complexBehaviour);
projectionDump = dumperForPart.Dump(item, "TermPart");
JsonConverter.ConvertToJSon(projectionDump, sb, minified, realformat);
}
sb.Append("}");
i++;
}
sb.Append("]");
sb.Append("}");
}
part = null;
#endregion [ Taxonomy/TermsPart ]
sb.Append("]"); // l : [
sb.Append("}");
}
jsonString = sb.ToString().Replace("\t", " ");
result.Content = jsonString;
return(result);
}
public IEnumerable <MenuItem> Filter(IEnumerable <MenuItem> items)
{
foreach (var item in items)
{
if (item.Content != null && item.Content.ContentItem.ContentType == "TaxonomyNavigationMenuItem")
{
var taxonomyNavigationPart = item.Content.As <TaxonomyNavigationPart>();
var rootTerm = _taxonomyService.GetTerm(taxonomyNavigationPart.TermId);
TermPart[] allTerms;
if (rootTerm != null)
{
// if DisplayRootTerm is specified add it to the menu items to render
allTerms = _taxonomyService.GetChildren(rootTerm, taxonomyNavigationPart.DisplayRootTerm).ToArray();
}
else
{
allTerms = _taxonomyService.GetTerms(taxonomyNavigationPart.TaxonomyId).ToArray();
}
var rootLevel = rootTerm != null
? rootTerm.GetLevels()
: 0;
var menuPosition = item.Position;
var rootPath = rootTerm == null || taxonomyNavigationPart.DisplayRootTerm ? "" : rootTerm.FullPath;
var startLevel = rootLevel + 1;
if (rootTerm == null || taxonomyNavigationPart.DisplayRootTerm)
{
startLevel = rootLevel;
}
var endLevel = Int32.MaxValue;
if (taxonomyNavigationPart.LevelsToDisplay > 0)
{
endLevel = startLevel + taxonomyNavigationPart.LevelsToDisplay - 1;
}
foreach (var contentItem in allTerms)
{
if (contentItem != null)
{
var part = contentItem;
var level = part.GetLevels();
// filter levels ?
if (level < startLevel || level > endLevel)
{
continue;
}
// ignore menu item if there are no content items associated to the term
if (taxonomyNavigationPart.HideEmptyTerms && part.Count == 0)
{
continue;
}
var menuText = _contentManager.GetItemMetadata(part).DisplayText;
var routes = _contentManager.GetItemMetadata(part).DisplayRouteValues;
if (taxonomyNavigationPart.DisplayContentCount)
{
menuText += " (" + part.Count + ")";
}
// create
var positions = contentItem.FullPath.Substring(rootPath.Length)
.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries)
.Select(p => Array.FindIndex(allTerms, t => t.Id == Int32.Parse(p)))
.ToArray();
var inserted = new MenuItem {
Text = new LocalizedString(menuText),
IdHint = item.IdHint,
Classes = item.Classes,
Url = item.Url,
Href = item.Href,
LinkToFirstChild = false,
RouteValues = routes,
LocalNav = item.LocalNav,
Items = new MenuItem[0],
Position = menuPosition + ":" + String.Join(".", positions.Select(x => x.ToString(CultureInfo.InvariantCulture)).ToArray()),
Permissions = item.Permissions,
Content = part
};
yield return(inserted);
}
}
}
else
{
yield return(item);
}
}
}
public IEnumerable <MenuItem> Filter(IEnumerable <MenuItem> items)
{
foreach (var item in items)
{
if (item.Content != null && item.Content.ContentItem.ContentType == "TaxonomyNavigationMenuItem")
{
// expand query
var taxonomyNavigationPart = item.Content.As <TaxonomyNavigationPart>();
var rootTerm = _taxonomyService.GetTerm(taxonomyNavigationPart.TermId);
List <int> positionList = new List <int>();
var allTerms = rootTerm != null
? _taxonomyService.GetChildren(rootTerm).ToArray()
: _taxonomyService.GetTerms(taxonomyNavigationPart.TaxonomyId).ToArray();
var rootlevel = rootTerm == null ? 0 : rootTerm.GetLevels();
positionList.Add(0);
var menuPosition = item.Position;
int parentLevel = rootlevel;
foreach (var contentItem in allTerms)
{
if (contentItem != null)
{
var part = contentItem;
if (taxonomyNavigationPart.HideEmptyTerms == true && part.Count == 0)
{
continue;
}
string termPosition = "";
if (part.GetLevels() - rootlevel > parentLevel)
{
positionList.Add(0);
parentLevel = positionList.Count - 1;
}
else
if ((part.GetLevels() - rootlevel) == parentLevel)
{
positionList[parentLevel]++;
}
else
{
positionList.RemoveRange(1, positionList.Count - 1);
parentLevel = positionList.Count - 1;
positionList[parentLevel]++;
}
termPosition = positionList.First().ToString();
foreach (var position in positionList.Skip(1))
{
termPosition = termPosition + "." + position.ToString();
}
var menuText = _contentManager.GetItemMetadata(part).DisplayText;
var routes = _contentManager.GetItemMetadata(part).DisplayRouteValues;
if (taxonomyNavigationPart.DisplayContentCount)
{
menuText = String.Format(menuText + " ({0})", part.Count.ToString());
}
var inserted = new MenuItem {
Text = new LocalizedString(menuText),
IdHint = item.IdHint,
Classes = item.Classes,
Url = item.Url,
Href = item.Href,
LinkToFirstChild = false,
RouteValues = routes,
LocalNav = item.LocalNav,
Items = new MenuItem[0],
Position = menuPosition + ":" + termPosition,
Permissions = item.Permissions,
Content = part
};
yield return(inserted);
}
}
}
else
{
yield return(item);
}
}
}
