protected override DriverResult Display(TermPart part, string displayType, dynamic shapeHelper)
{
return(Combined(
ContentShape("Parts_TermPart_Feed", () => {
// generates a link to the RSS feed for this term
_feedManager.Register(part.Name, "rss", new RouteValueDictionary {
{ "term", part.Id }
});
return null;
}),
ContentShape("Parts_TermPart", () => {
var pagerParameters = new PagerParameters();
var httpContext = _httpContextAccessor.Current();
if (httpContext != null)
{
pagerParameters.Page = Convert.ToInt32(httpContext.Request.QueryString["page"]);
}
var pager = new Pager(_siteService.GetSiteSettings(), pagerParameters);
var taxonomy = _taxonomyService.GetTaxonomy(part.TaxonomyId);
var totalItemCount = _taxonomyService.GetContentItemsCount(part);
var partSettings = part.Settings.GetModel <TermPartSettings>();
if (partSettings != null && partSettings.OverrideDefaultPagination)
{
pager.PageSize = partSettings.PageSize;
}
var childDisplayType = partSettings != null &&
!String.IsNullOrWhiteSpace(partSettings.ChildDisplayType)
? partSettings.ChildDisplayType
: "Summary";
// asign Taxonomy and Term to the content item shape (Content) in order to provide
// alternates when those content items are displayed when they are listed on a term
var termContentItems = _taxonomyService.GetContentItems(part, pager.GetStartIndex(), pager.PageSize)
.Select(c => _contentManager.BuildDisplay(c, childDisplayType).Taxonomy(taxonomy).Term(part));
var list = shapeHelper.List();
list.AddRange(termContentItems);
var pagerShape = pager.PageSize == 0
? null
: shapeHelper.Pager(pager)
.TotalItemCount(totalItemCount)
.Taxonomy(taxonomy)
.Term(part);
return shapeHelper.Parts_TermPart(ContentItems: list, Taxonomy: taxonomy, Pager: pagerShape);
})));
}
public ActionResult Item(string termPath, PagerParameters pagerParameters)
{
var pager = new Pager(_siteService.GetSiteSettings(), pagerParameters);
var correctedPath = _termPathConstraint.FindPath(termPath);
if (correctedPath == null)
{
return(HttpNotFound());
}
var termPart = _taxonomyService.GetTermByPath(correctedPath);
if (termPart == null)
{
return(HttpNotFound());
}
var taxonomy = _taxonomyService.GetTaxonomy(termPart.TaxonomyId);
var totalItemCount = _taxonomyService.GetContentItemsCount(termPart);
var termContentItems = _taxonomyService.GetContentItems(termPart, pager.GetStartIndex(), pager.PageSize)
.Select(c => _contentManager.BuildDisplay(c, "Summary").Taxonomy(taxonomy).Term(termPart));
dynamic term = _contentManager.BuildDisplay(termPart);
var list = Shape.List();
list.AddRange(termContentItems);
term.Content.Add(
Shape.Taxonomies_TermContentItems_List(ContentItems: list)
.Taxonomy(taxonomy)
.Term(termPart), "5");
term.Content.Add(
Shape.Pager(pager)
.TotalItemCount(totalItemCount)
.Taxonomy(taxonomy)
.Term(termPart), "Content:after");
// generates a link to the RSS feed for this term
_feedManager.Register(termPart.Name, "rss", new RouteValueDictionary {
{ "term", termPart.Id }
});
return(new ShapeResult(this, term));
}
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 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());
}
}
}
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 void Execute(FeedContext context)
{
var termParthId = context.ValueProvider.GetValue("term");
if (termParthId == null)
{
return;
}
var limitValue = context.ValueProvider.GetValue("limit");
var limit = 20;
if (limitValue != null)
{
limit = (int)limitValue.ConvertTo(typeof(int));
}
var containerId = (int)termParthId.ConvertTo(typeof(int));
var container = _contentManager.Get <TermPart>(containerId);
if (container == null)
{
return;
}
var inspector = new ItemInspector(container, _contentManager.GetItemMetadata(container));
if (context.Format == "rss")
{
var link = new XElement("link");
context.Response.Element.SetElementValue("title", inspector.Title);
context.Response.Element.Add(link);
context.Response.Element.SetElementValue("description", inspector.Description);
context.Response.Contextualize(requestContext => {
var urlHelper = new UrlHelper(requestContext);
var uriBuilder = new UriBuilder(urlHelper.MakeAbsolute("/"))
{
Path = urlHelper.RouteUrl(inspector.Link)
};
link.Add(uriBuilder.Uri.OriginalString);
});
}
else
{
context.Builder.AddProperty(context, null, "title", inspector.Title);
context.Builder.AddProperty(context, null, "description", inspector.Description);
context.Response.Contextualize(requestContext => {
var urlHelper = new UrlHelper(requestContext);
context.Builder.AddProperty(context, null, "link", urlHelper.RouteUrl(inspector.Link));
});
}
var items = _taxonomyService.GetContentItems(container, 0, limit);
foreach (var item in items)
{
// call item.ContentItem to force a cast to ContentItem, and
// thus use CorePartsFeedItemBuilder
context.Builder.AddItem(context, item.ContentItem);
}
}
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 includeAssociatedContent = ((BooleanField)taxonomyNavigationPart.Get(typeof(BooleanField), "IncludeAssociatedContent"))?.Value == true;
var rootTerm = mTaxonomyService.GetTerm(taxonomyNavigationPart.TermId);
TermPart[] allTerms;
if (rootTerm != null)
{
// if DisplayRootTerm is specified add it to the menu items to render
allTerms = mTaxonomyService.GetChildren(rootTerm, taxonomyNavigationPart.DisplayRootTerm).ToArray();
}
else
{
allTerms = mTaxonomyService.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 term in allTerms)
{
if (term != null)
{
var part = term;
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 termMetadata = mContentManager.GetItemMetadata(part);
var termMenuText = termMetadata.DisplayText;
var termRoutes = termMetadata.DisplayRouteValues;
if (taxonomyNavigationPart.DisplayContentCount)
{
termMenuText += " (" + part.Count + ")";
}
// Create.
var positions = term.FullPath.Substring(rootPath.Length)
.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries)
.Select(p => Array.FindIndex(allTerms, t => t.Id == Int32.Parse(p)))
.ToArray();
var termMenuPosition = menuPosition + ":" + String.Join(".", positions.Select(x => x.ToString(CultureInfo.InvariantCulture)).ToArray());
var termMenuItem = new MenuItem
{
Text = new LocalizedString(termMenuText),
IdHint = item.IdHint,
Classes = item.Classes,
Url = item.Url,
Href = item.Href,
LinkToFirstChild = false,
RouteValues = termRoutes,
LocalNav = item.LocalNav,
Items = new MenuItem[0],
Position = termMenuPosition,
Permissions = item.Permissions,
Content = part
};
// Include associated content?
if (includeAssociatedContent)
{
var contentItems = mTaxonomyService.GetContentItems(term).ToList();
var contentMenuItems = new List <MenuItem>(contentItems.Count);
var contentMenuPosition = 0;
foreach (var contentItem in contentItems)
{
var metadata = mContentManager.GetItemMetadata(contentItem);
var menuText = metadata.DisplayText;
var routes = metadata.DisplayRouteValues;
var menuItem = 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 = termMenuPosition + "." + contentMenuPosition++,
Permissions = item.Permissions,
Content = contentItem
};
contentMenuItems.Add(menuItem);
}
termMenuItem.Items = contentMenuItems;
}
yield return(termMenuItem);
}
}
}
else
{
yield return(item);
}
}
}