public EntityNodeLink(EntityNode node,EntityLink link,int weight)
{
Target = node;
Weight = weight;
Link = link;
}
private static int GetSize(EntityNode node)
{
Entity entity = ((Entity)node.SourceData);
int size = 0;
switch (entity.LogicalName)
{
case "account":
size = 15;
break;
case "contact":
size = 10;
break;
default:
size = 20;
break;
}
// Make bigger if the root node
size = size + (node.Root ? 2 : 0);
return size;
}
public EntityNodeLink(EntityNode node, EntityLink link, int weight)
{
Target = node;
Weight = weight;
Link = link;
}
public string GetXY(EntityNode node, decimal multipler)
{
int size = 0;
Entity entity = ((Entity)node.SourceData);
size = GetSize(node);
return "-" + (size * multipler).ToString() + "px";
}
private static string GetFilter(EntityNode d)
{
if (d.Root)
return "url(#root-node-glow)";
else
return "";
}
private PendingLink AddPendingLink(EntityNode newNode, EntityReference pendingEntity)
{
Trace("Add Pending Link {0} {1} -> {2} {3}", new object[] { ((Entity)newNode.SourceData).LogicalName, newNode.Name, pendingEntity.LogicalName, pendingEntity.Id });
PendingLink pending = new PendingLink();
pending.Source = newNode;
pending.Target = pendingEntity;
if (!pendingLinks.ContainsKey(pendingEntity.LogicalName))
{
pendingLinks[pendingEntity.LogicalName] = new Dictionary<string, PendingLink>();
}
if (!IsAlsoAUserFromEntityReference(pendingEntity))
{
pendingLinks[pendingEntity.LogicalName][pendingEntity.Id.ToString()] = pending;
}
return pending;
}
public string GetHeightWidth(EntityNode node, decimal multipler)
{
int size = 0;
Entity entity = ((Entity)node.SourceData);
size = GetSize(node) * 2;
return (size * multipler).ToString() + "px";
}
/// <summary>
/// Adds a link from one entity to another
/// </summary>
/// <param name="delayAdd">creates the link but doesn't add it to the model yet</param>
/// <returns></returns>
private EntityLink AddLink(EntityNode target, EntityNode source, bool delayAdd)
{
Entity sourceEntity = (Entity)source.SourceData;
Entity targetEntity = (Entity)target.SourceData;
if ((target.LinkedToIds != null) && (source.LinkedToIds != null))
{
if (target.LinkedToIds.ContainsKey(sourceEntity.Id) && source.LinkedToIds.ContainsKey(targetEntity.Id))
{
// return the current link
return target.LinkedToIds[sourceEntity.Id].Link;
}
}
EntityLink link = new EntityLink();
link.Source = source;
link.Target = target;
SetLinkedIds(link.Target, link.Source, sourceEntity, targetEntity, link);
// If either side has an overflow - then set it to that instead
if (!source.IsActivity && link.Source.ParentNode != null && link.Source.ParentNode.OverflowNode != null)
{
link.Source = link.Source.ParentNode.OverflowNode;
link.Source.Links.Add(link);
}
else if (source.IsActivity && link.Source.OverflowNode != null)
{
link.Source = link.Source.OverflowNode;
link.Source.Links.Add(link);
}
if (!target.IsActivity && link.Target.ParentNode != null && link.Target.ParentNode.OverflowNode != null)
{
link.Target = link.Target.ParentNode.OverflowNode;
}
else if (target.IsActivity && link.Target.OverflowNode != null)
{
link.Target = link.Target.OverflowNode;
link.Target.Links.Add(link);
}
link.Id = GetLinkId(sourceEntity.Id, targetEntity.Id);
if (!linkIndex.ContainsKey(link.Id))
{
if (!delayAdd)
{
linkIndex[link.Id] = link;
Links.Add(link);
}
}
return link;
}
private EntityLink AddLinkIfLoaded(EntityNode target, EntityReference source, bool delayAdd)
{
EntityNode sourceNode = GetEntityFromReference(source);
if (sourceNode != null)
{
// Create Link
EntityLink link = AddLink(sourceNode, target, delayAdd);
return link;
}
return null;
}
private bool AddEntity(Entity record, EntityNode newNode, EntitySetting settings, bool delayAdd)
{
if (((Nodes.Count + 1) % 40) == 0)
{
// Zoom out the more nodes there are - maybe better to use the extent of the layout...
OnZoom.Invoke(this, -1);
}
string key = GetIdIndexKey(record);
idIndex[key] = newNode;
if (settings != null)
{
if (!newNode.LoadedActivities && settings.LoadActivities)
{
idIndexActivityLoad[key] = newNode;
newNode.LoadedActivities = true;
}
if (!newNode.LoadedConnections && settings.LoadConnections)
{
idIndexConnectionLoad[key] = newNode;
newNode.LoadedConnections = true;
}
}
if (!delayAdd)
{
Nodes.Add(newNode);
}
return true;
}
private static void SetLinkedIds(EntityNode target, EntityNode source, Entity sourceEntity, Entity targetEntity, EntityLink link)
{
if (source.LinkedToIds == null) source.LinkedToIds = new Dictionary<string, EntityNodeLink>();
if (target.LinkedToIds == null) target.LinkedToIds = new Dictionary<string, EntityNodeLink>();
source.LinkedToIds[targetEntity.Id] = new EntityNodeLink(target, link, 1);
target.LinkedToIds[sourceEntity.Id] = new EntityNodeLink(source, link, 1);
}
public void ExpandOverflow(EntityNode entityNode)
{
// Clear the selected user
SelectedUserId.SetValue(null);
SelectedConnectionRoles.RemoveAll();
UnselectAll();
OnSelectedNodesAdded(this, null);
OnSelectedLinksAdded(this, null);
if (entityNode.Children != null)
{
// Add any overflow nodes
int expandedCount = 0;
foreach (EntityNode node in entityNode.Children)
{
node.X = entityNode.X;
node.Y = entityNode.Y;
node.Fixed = false;
if (!Nodes.Contains(node))
Nodes.Add(node);
node.ReplacedByOverflow = null;
expandedCount++;
// Add the links
foreach (KeyValuePair<string, EntityNodeLink> linkedTo in node.LinkedToIds)
{
EntityLink link = new EntityLink(); ;
link.Source = node;
link.Target = linkedTo.Value.Target;
link.Id = GetLinkId(((Entity)node.SourceData).Id, ((Entity)link.Target.SourceData).Id);
if (linkIndex.ContainsKey(link.Id))
{
link = linkIndex[link.Id];
}
else
{
linkIndex[link.Id] = link;
Links.Add(link);
}
}
if (expandedCount == OverflowMax && entityNode.Children.Count > (OverflowMax + 1))
{
break;
}
}
entityNode.Children.RemoveRange(0, expandedCount);
entityNode.ParentNode.ActivityCount = entityNode.Children.Count;
if (entityNode.Children.Count == 0)
{
entityNode.Children = null;
// Remove the overflow links and node
Nodes.Remove(entityNode);
foreach (EntityLink link in entityNode.Links)
{
linkIndex.Remove(link.Id);
Links.Remove(link);
}
}
RaiseOnNodesChangedWithNoFastForward();
}
}
private void ProcessQueryResults(QueuedLoad load, EntityCollection rootResults)
{
int total = rootResults.Entities.Count;
int index = 0;
List<string> ids = new List<string>();
foreach (Entity record in rootResults.Entities)
{
if (IsCancelRequested())
return;
SetMessage(ResourceStrings.Processing, load.Entity.DisplayName, index, total);
// Check if this is a pending load - and remove it
RemovePendingID(record.LogicalName, record.Id);
index++;
ids.Add(record.Id);
string name = record.GetAttributeValueString(load.Entity.NameAttribute == null ? "name" : load.Entity.NameAttribute);
// If this is the root entity then set the window title
bool rootNode = (RootEntityId.Value.ToLowerCase().Substr(1, 36) == record.Id.ToLowerCase());
if (rootNode)
{
Window.Document.Title = name;
}
if (!IsAlsoAUser(record) && !IndexContainsEntity(record))
{
EntityNode newNode = new EntityNode(name, 100);
newNode.Root = rootNode;
newNode.X = _startX;
newNode.Y = _startY;
newNode.SourceData = record;
if (!AddEntity(record, newNode, load.Entity, false))
return;
// Add User reference for owner
EntityReference owner = record.GetAttributeValueEntityReference("ownerid");
if (owner != null)
{
UserOrTeam user = GetUserOrTeamReference(owner);
user.Parties[record.Id.ToString()] = record.ToEntityReference();
}
}
}
Trace("Linking to Parents {0} {1} records", new object[] { load.Entity.LogicalName, rootResults.Entities.Count });
index = 0;
// Add the parent links
foreach (Entity record in rootResults.Entities)
{
if (IsCancelRequested())
return;
SetMessage(ResourceStrings.Linking, load.Entity.DisplayName, index, total);
EntityNode thisNode = GetEntity(record);
if (thisNode == null)
continue;
// Add the heiarchical links
EntityNode parentNode = GetParentEntity(record, load.Entity.ParentAttributeId, load.Entity.LogicalName);
if (parentNode != null)
{
// Create Link
AddLink(thisNode, parentNode, false);
}
// Add the backlinks
// e.g. if this is a contact then back link via the parentcustomerid field
if (load.Join != null)
{
Trace("Adding backlinks {0}->{1}", new object[] { load.Entity.LogicalName, load.Join.RightEntity });
EntityNode joinedNode = GetParentEntity(record, load.Join.RightAttribute, load.Join.RightEntity);
if (joinedNode != null)
{
AddLink(thisNode, joinedNode, false);
}
else
{
// Add pending link
}
}
}
if (ids.Count > 0)
{
// add links
if (load.Entity.Joins != null)
{
Trace("Adding Joins to {0}", new object[] { ids.Count });
foreach (JoinSetting join in load.Entity.Joins)
{
EntitySetting joinedTo = Config.Entities[join.RightEntity];
if (joinedTo != null)
{
Trace("Queing Join {0}.{1} -> {2}.{3} {4}", new object[] { join.LeftEntity, join.LeftAttribute, join.RightEntity, join.RightAttribute, join.Name });
Queue.Enqueue(new QueuedLoad(ids, joinedTo, join));
}
}
}
if (load.Entity.LoadActivities)
{
Queue.Enqueue(new QueuedLoad(ids, load.Entity, NewJoinSetting(load.Entity.LogicalName, "activity")));
}
if (load.Entity.LoadConnections)
{
Queue.Enqueue(new QueuedLoad(ids, load.Entity, NewJoinSetting(load.Entity.LogicalName, "connection")));
}
}
_currentLoad = null;
CallNextProcessQueue();
}
private void ProcessActivity(EntityCollection rootResults2, int index, int total)
{
Entity record = rootResults2.Entities[index];
SetMessage(ResourceStrings.Processing, ResourceStrings.Activities, index, total);
EntityNode newNode;
record.LogicalName = record.GetAttributeValueString("activitytypecode");
bool alreadyAdded = false;
if (!IndexContainsEntity(record))
{
newNode = new EntityNode(record.GetAttributeValueString("name"), 100);
newNode.IsActivity = true;
newNode.X = _startX;
newNode.Y = _startY;
newNode.SourceData = record;
if (!AddEntity(record, newNode, null, true))
return;
}
else
{
newNode = GetEntity(record);
alreadyAdded = true;
}
// Go through the activity parties and link to the records
EntityCollection allParties = (EntityCollection)record.GetAttributeValue("allparties");
int i = 0;
bool overflow = false;
foreach (Entity item in allParties.Entities)
{
if (IsCancelRequested())
return;
if ((index % 20) == 0)
{
SetMessage(ResourceStrings.Processing, ResourceStrings.ActivityLinks, index, total);
}
i++;
ActivityParty party = (ActivityParty)item;
EntityReference partyid = party.PartyId;
if (partyid != null) // Only load resolved parties
{
//Trace(String.Format("Party {0} {1} {2}",partyid.LogicalName, partyid.Name,partyid.Id));
// Do we have it?
// We must have at least one since the activity has been loaded in the first place!
EntityLink linkToExisting = AddLinkIfLoaded(newNode, partyid, true);
if (linkToExisting == null)
{
// Any records not loaded - add a pending link
if (party.PartyId.LogicalName == "systemuser" || party.PartyId.LogicalName == "team")
{
party.ActivityID.LogicalName = ((Entity)newNode.SourceData).LogicalName;
UserOrTeam user = GetUserOrTeamReference(party.PartyId);
user.Parties[party.ActivityID.Id.ToString()] = party.ActivityID;
}
else
{
AddPendingLink(newNode, partyid);
}
}
else
{
if (newNode.ParentNode == null)
{
// Allocate each entity a single parent - which is the first found party
newNode.ParentNode = linkToExisting.Target;
newNode.ParentNode.ActivityCount++;
}
// Check the count of activities
bool overflowAlreadyAdded = false;
bool overflowed = newNode.ParentNode.ActivityCount > OverflowMax && newNode.ParentNode == linkToExisting.Target;
// If the linked to source activity is already load then don't overflow it
if (alreadyAdded)
{
overflow = false;
}
if (overflowed)
{
if (newNode.ParentNode.OverflowNode == null)
{
// Create overflow node if not already
EntityNode overflowNode = new EntityNode(ResourceStrings.DoubleClickToExpand, 1);
overflowNode.Id = "overflow" + partyid.Id.Value;
overflowNode.ParentNode = newNode.ParentNode;
overflowNode.X = _startX;
overflowNode.Y = _startY;
Entity overflowEntity = new Entity("overflow");
overflowEntity.Id = "overflow" + ((Entity)newNode.SourceData).Id;
overflowNode.SourceData = overflowEntity;
Nodes.Add(overflowNode);
newNode.ParentNode.OverflowNode = overflowNode;
newNode.ReplacedByOverflow = overflowNode;
}
else if (linkToExisting.Source.ParentNode == linkToExisting.Target && !alreadyAdded)
{
overflowAlreadyAdded = true;
linkToExisting.Source.ReplacedByOverflow = linkToExisting.Target.OverflowNode;
}
if (newNode.ReplacedByOverflow != null)
{
if (newNode.ReplacedByOverflow.Children == null)
newNode.ReplacedByOverflow.Children = new List<EntityNode>();
if (!newNode.ReplacedByOverflow.Children.Contains(newNode))
newNode.ReplacedByOverflow.Children.Add(newNode);
}
}
if (!overflowAlreadyAdded)
{
if (linkToExisting.Source.ReplacedByOverflow != null)
{
linkToExisting.Source = linkToExisting.Source.ReplacedByOverflow;
linkToExisting.Source.Links.Add(linkToExisting);
if (!linkToExisting.Id.StartsWith("overflow"))
linkToExisting.Id = "overflow" + linkToExisting.Id;
}
if (!linkIndex.ContainsKey(linkToExisting.Id))
{
linkIndex[linkToExisting.Id] = linkToExisting;
Links.Add(linkToExisting);
}
else
{
}
}
}
}
}
if (newNode.ReplacedByOverflow == null)
{
if (!alreadyAdded)
{
Nodes.Add(newNode);
}
}
}
