private static IEnumerable <EntityReference> RetrieveDisassociatedIntersectEntities(CrmDbContext context, ContentMap map, EntityReference target, Relationship relationship, IEnumerable <EntityReference> relatedEntities)
{
var solution = map.Solution;
// retrieve the intersect entity definition
ManyRelationshipDefinition mrd;
EntityDefinition ed;
if (solution.ManyRelationships != null &&
solution.ManyRelationships.TryGetValue(relationship.SchemaName, out mrd) &&
solution.Entities.TryGetValue(mrd.IntersectEntityname, out ed))
{
// retrieve the target node
EntityNode targetNode;
if (map.TryGetValue(target, out targetNode))
{
// retrieve the set of existing relationships for validation purposes
var entities = RetrieveIntersectEntities(context, map, target, relationship, relatedEntities).Select(e => e.ToEntityReference()).ToList();
// reflexive N:N relationships are not supported
var targetRelationship = ed.Relationships.Single(r => r.ForeignEntityLogicalname == target.LogicalName && r.ToMany != null);
// retrieve the intersect nodes that point to the target
var intersects = targetRelationship.ToMany(targetNode).ToList();
foreach (var related in relatedEntities)
{
EntityNode relatedNode;
if (map.TryGetValue(related, out relatedNode))
{
var relatedRelationship = ed.Relationships.Single(r => r.ForeignEntityLogicalname == related.LogicalName && r.ToOne != null);
// filter the intersect nodes that point to the related node (as well as the target)
// ensure that the intersect does not exist in the collection of retrieved intersects
var intersectsToRemove = intersects
.Where(i => Equals(relatedRelationship.ToOne(i), relatedNode))
.Select(i => i.ToEntityReference())
.Where(i => entities.All(e => !Equals(e, i)));
foreach (var intersect in intersectsToRemove)
{
yield return(intersect);
}
}
}
}
}
}
/// <summary> The try get page node from site marker node. </summary>
/// <param name="siteMarkerName"> The site marker name. </param>
/// <param name="contentMap"> The content map. </param>
/// <param name="targetNode"> The target node. </param>
/// <returns> The <see cref="bool"/>. </returns>
private bool TryGetPageNodeFromSiteMarkerNode(string siteMarkerName, ContentMap contentMap, out WebPageNode targetNode)
{
var website = HttpContext.Current.GetWebsite().Entity;
IDictionary <EntityReference, EntityNode> siteMarkers;
targetNode = null;
if (!contentMap.TryGetValue("adx_sitemarker", out siteMarkers))
{
ADXTrace.Instance.TraceInfo(TraceCategory.Application, "No Sitemarkers found on Content Map");
return(false);
}
var siteMarkerNode = siteMarkers.Values
.Cast <SiteMarkerNode>()
.FirstOrDefault(e => e.Website.Id == website.Id && e.Name == siteMarkerName);
if (siteMarkerNode == null || siteMarkerNode.WebPage == null)
{
return(false);
}
if (!contentMap.TryGetValue(siteMarkerNode.WebPage, out targetNode))
{
ADXTrace.Instance.TraceInfo(TraceCategory.Application, string.Format("No WebPage found on Sitemarker:{0}", siteMarkerNode.Id));
return(false);
}
if (!this.Language.IsCrmMultiLanguageEnabled)
{
ADXTrace.Instance.TraceInfo(TraceCategory.Application, string.Format("WebPage found for Sitemarker:{0} Page:{1}", siteMarkerNode.Id, targetNode.Id));
return(true);
}
// MLP - Find the content webpage for the current language from the target page
var contentWebPage = targetNode.LanguageContentPages.FirstOrDefault(p => p.WebPageLanguage == this.Language.ContextLanguage.WebsiteLanguageNode);
if (contentWebPage != null)
{
ADXTrace.Instance.TraceInfo(TraceCategory.Application, string.Format("WebPage found for Sitemarker:{0} Language:{1}", siteMarkerNode.Id, this.Language.ContextLanguage.Lcid));
targetNode = contentWebPage;
return(true);
}
ADXTrace.Instance.TraceInfo(TraceCategory.Application, string.Format("No WebPage found for Sitemarker:{0} Language:{1}", siteMarkerNode.Id, this.Language.ContextLanguage.Lcid));
return(false);
}
protected override bool TryAssert(OrganizationServiceContext context, Entity entity, CrmEntityRight right, CrmEntityCacheDependencyTrace dependencies, ContentMap map)
{
switch (entity.LogicalName)
{
case "adx_weblink":
WebLinkNode link;
if (map.TryGetValue(entity, out link))
{
return(TryAssert(link) || UserCanPreview(context, entity));
}
break;
case "adx_webpage":
WebPageNode page;
if (map.TryGetValue(entity, out page))
{
return(TryAssert(page.PublishingState) || UserCanPreview(context, entity));
}
break;
case "adx_weblinkset":
WebLinkSetNode linkset;
if (map.TryGetValue(entity, out linkset))
{
return(TryAssert(linkset.PublishingState) || UserCanPreview(context, entity));
}
break;
case "adx_webfile":
WebFileNode file;
if (map.TryGetValue(entity, out file))
{
return(TryAssert(file.PublishingState) || UserCanPreview(context, entity));
}
break;
case "adx_shortcut":
ShortcutNode shortcut;
if (map.TryGetValue(entity, out shortcut))
{
return(TryAssert(shortcut) || UserCanPreview(context, entity));
}
break;
case "adx_communityforum":
ForumNode forum;
if (map.TryGetValue(entity, out forum))
{
return(TryAssert(forum.PublishingState) || UserCanPreview(context, entity));
}
break;
}
return(this.TryAssert(context, entity, right, dependencies));
}
/// <summary>
/// Test whether or not an Entity's published dates are visible in the current context.
/// </summary>
/// <param name="context">OrganizationServiceContext</param>
/// <param name="entity">CRM Entity</param>
/// <param name="right">Entity Right</param>
/// <param name="dependencies">Cache Dependency Trace</param>
/// <param name="map">Content Map</param>
/// <returns></returns>
protected override bool TryAssert(OrganizationServiceContext context, Entity entity, CrmEntityRight right, CrmEntityCacheDependencyTrace dependencies, ContentMap map)
{
if (entity == null || right == CrmEntityRight.Change)
{
return(false);
}
dependencies.AddEntityDependency(entity);
dependencies.AddEntitySetDependency("adx_webrole");
dependencies.AddEntitySetDependency("adx_websiteaccess");
var entityName = entity.LogicalName;
var releaseDate = DateTime.MinValue;
var expiryDate = DateTime.MaxValue;
if (entityName == "adx_webpage" ||
entityName == "adx_webfile" ||
entityName == "adx_event" ||
entityName == "adx_survey" ||
entityName == "adx_ad")
{
releaseDate = entity.GetAttributeValue <DateTime?>("adx_releasedate").GetValueOrDefault(DateTime.MinValue);
expiryDate = entity.GetAttributeValue <DateTime?>("adx_expirationdate").GetValueOrDefault(DateTime.MaxValue);
}
else if (entityName == "adx_weblink")
{
if (!entity.GetAttributeValue <bool?>("adx_disablepagevalidation").GetValueOrDefault(false))
{
var pageReference = entity.GetAttributeValue <EntityReference>("adx_pageid");
if (pageReference != null)
{
WebPageNode rootPage;
if (map.TryGetValue(pageReference, out rootPage))
{
var weblinkWebPage = HttpContext.Current.GetContextLanguageInfo().FindLanguageSpecificWebPageNode(rootPage, false);
if (weblinkWebPage != null)
{
return(TryAssert(context, weblinkWebPage.ToEntity(), right, dependencies));
}
}
}
}
return(true);
}
else if (entityName == "adx_shortcut")
{
if (!entity.GetAttributeValue <bool?>("adx_disabletargetvalidation").GetValueOrDefault(false))
{
var pageReference = entity.GetAttributeValue <EntityReference>("adx_webpageid");
var webFileReference = entity.GetAttributeValue <EntityReference>("adx_webfileid");
if (pageReference != null)
{
WebPageNode rootPage;
if (map.TryGetValue(pageReference, out rootPage))
{
var shortcutWebPage = HttpContext.Current.GetContextLanguageInfo().FindLanguageSpecificWebPageNode(rootPage, false);
if (shortcutWebPage != null)
{
return(TryAssert(context, shortcutWebPage.ToEntity(), right, dependencies));
}
}
}
else if (webFileReference != null)
{
WebFileNode webFile;
if (map.TryGetValue(webFileReference, out webFile))
{
return(TryAssert(context, webFile.ToEntity(), right, dependencies));
}
}
}
var parentPageReference = entity.GetAttributeValue <EntityReference>("adx_parentpage_webpageid");
if (parentPageReference != null)
{
WebPageNode rootPage;
if (map.TryGetValue(parentPageReference, out rootPage))
{
var parentPage = HttpContext.Current.GetContextLanguageInfo().FindLanguageSpecificWebPageNode(rootPage, false);
return(TryAssert(context, parentPage.ToEntity(), right, dependencies));
}
}
return(true);
}
return(UserCanPreview(context, entity) || InnerTryAssert(releaseDate, expiryDate));
}
