private HashSet <string> GetUsedEntitiesFromPath(string relativePath, ConnectionIntellisenseData intellisenseData)
{
if (intellisenseData == null)
{
return(null);
}
relativePath = relativePath ?? string.Empty;
relativePath = relativePath.Trim();
IEnumerable <string> fields = relativePath.Split(new char[] { '.' }, StringSplitOptions.RemoveEmptyEntries).Select(s => s.Trim()).ToArray();
var sourceEntityName = fields.FirstOrDefault();
fields = fields.Skip(1);
var result = new HashSet <string>(StringComparer.InvariantCultureIgnoreCase)
{
sourceEntityName
};
GetUsedEntitiesByRelativePathRecursive(result, sourceEntityName, fields, intellisenseData);
return(result);
}
private void FillMultiLinkForEntity(IList <CompletionSet> completionSets, ITrackingSpan applicableTo, ConnectionIntellisenseData intellisenseData, EntityIntellisenseData entityData)
{
TupleList <string, string> childEntities = new TupleList <string, string>();
if (entityData.OneToManyRelationships != null)
{
foreach (var item in entityData.OneToManyRelationships.Values)
{
childEntities.Add(item.ChildEntityName, item.ChildEntityAttributeName);
}
}
if (!entityData.IsIntersectEntity.GetValueOrDefault() && entityData.ManyToManyRelationships != null)
{
foreach (var item in entityData.ManyToManyRelationships.Values)
{
if (string.Equals(entityData.EntityLogicalName, item.Entity1Name, StringComparison.InvariantCultureIgnoreCase))
{
childEntities.Add(item.IntersectEntityName, item.Entity1IntersectAttributeName);
}
else if (string.Equals(entityData.EntityLogicalName, item.Entity2Name, StringComparison.InvariantCultureIgnoreCase))
{
childEntities.Add(item.IntersectEntityName, item.Entity2IntersectAttributeName);
}
}
}
List <CrmCompletion> list = new List <CrmCompletion>();
foreach (var relation in childEntities.OrderBy(e => e.Item1).ThenBy(e => e.Item2))
{
if (intellisenseData.Entities.ContainsKey(relation.Item1))
{
var childEntityData = intellisenseData.Entities[relation.Item1];
if (childEntityData.Attributes != null && childEntityData.Attributes.ContainsKey(relation.Item2))
{
var childAttribute = childEntityData.Attributes[relation.Item2];
List <string> compareValues = CrmIntellisenseCommon.GetCompareValuesForEntity(childEntityData);
compareValues.Add(relation.Item2);
var insertText = string.Format("multi {0} {1}", relation.Item2, relation.Item1);
list.Add(CreateCompletion(CrmIntellisenseCommon.GetDisplayTextEntityAndAttribute(childEntityData, childAttribute), insertText, CrmIntellisenseCommon.CreateEntityAndAttributeDescription(childEntityData, childAttribute), _defaultGlyph, compareValues));
}
}
}
if (list.Count > 0)
{
completionSets.Add(new CrmCompletionSet(SourceNameMoniker, "Child Entities", applicableTo, list, Enumerable.Empty <CrmCompletion>()));
}
}
private void FillMultiLinkEntityForAll(IList <CompletionSet> completionSets, ITrackingSpan applicableTo, ConnectionIntellisenseData intellisenseData)
{
var entitiesList = intellisenseData.Entities.Values.Where(e => !string.IsNullOrEmpty(e.EntityPrimaryIdAttribute)).OrderBy(e => e.IsIntersectEntity).ThenBy(e => e.EntityLogicalName).ToList();
FillAttributeReferencedEntities(completionSets, applicableTo, entitiesList);
}
private void FillMultiLinkEntityForEntities(IList <CompletionSet> completionSets, ITrackingSpan applicableTo, HashSet <string> entityNameHash, ConnectionIntellisenseData intellisenseData)
{
List <CrmCompletion> list = new List <CrmCompletion>();
var entitiesList = intellisenseData.Entities.Values.Where(e => entityNameHash.Contains(e.EntityLogicalName)).OrderBy(e => e.IsIntersectEntity).ThenBy(e => e.EntityLogicalName).ToList();
FillAttributeReferencedEntities(completionSets, applicableTo, entitiesList);
}
private void FillEntityNamesInList(IList <CompletionSet> completionSets, ITrackingSpan applicableTo, ConnectionIntellisenseData intellisenseData, bool isObjectTypeCode)
{
List <CrmCompletion> list = new List <CrmCompletion>();
var entityList = intellisenseData.Entities.Values.OrderBy(e => e.IsIntersectEntity).ThenBy(e => e.EntityLogicalName).ToList();
foreach (var entityData in entityList)
{
string entityDescription = CrmIntellisenseCommon.GetDisplayTextEntity(entityData);
List <string> compareValues = CrmIntellisenseCommon.GetCompareValuesForEntity(entityData);
var insertionText = entityData.EntityLogicalName;
if (isObjectTypeCode)
{
insertionText = entityData.ObjectTypeCode.ToString();
}
list.Add(CreateCompletion(entityDescription, insertionText, CrmIntellisenseCommon.CreateEntityDescription(entityData), _defaultGlyph, compareValues));
}
if (list.Count > 0)
{
completionSets.Add(new CrmCompletionSet(SourceNameMoniker, "All Entities", applicableTo, list, Enumerable.Empty <CrmCompletion>()));
}
}
private void GetUsedEntitiesByRelativePathRecursive(HashSet <string> result, string sourceEntityName, IEnumerable <string> fields, ConnectionIntellisenseData intellisenseData)
{
if (!fields.Any())
{
if (!string.IsNullOrEmpty(sourceEntityName))
{
result.Add(sourceEntityName);
}
return;
}
var attributeName = fields.First();
fields = fields.Skip(1);
if (attributeName.StartsWith("multi ", StringComparison.InvariantCultureIgnoreCase))
{
attributeName = attributeName.Substring(6).Trim();
string[] split = attributeName.Split(new[] { ' ' });
if (split.Length == 2)
{
string referenceAttribute = split[0];
string logicalName = split[1];
var nextEntityName = GetNextEntityName(logicalName, referenceAttribute, intellisenseData);
if (!string.IsNullOrEmpty(nextEntityName))
{
result.Add(nextEntityName);
}
GetUsedEntitiesByRelativePathRecursive(result, nextEntityName, fields, intellisenseData);
}
}
else
{
if (!string.IsNullOrEmpty(sourceEntityName) && intellisenseData.Entities.ContainsKey(sourceEntityName))
{
var sourceEntity = intellisenseData.Entities[sourceEntityName];
if (sourceEntity.Attributes.ContainsKey(attributeName))
{
var attribute = sourceEntity.Attributes[attributeName];
if (attribute.AttributeType == Microsoft.Xrm.Sdk.Metadata.AttributeTypeCode.Lookup ||
attribute.AttributeType == Microsoft.Xrm.Sdk.Metadata.AttributeTypeCode.Customer ||
attribute.AttributeType == Microsoft.Xrm.Sdk.Metadata.AttributeTypeCode.Owner
)
{
if (attribute.Targets != null && attribute.Targets.Count > 0)
{
foreach (var nextEntityName in attribute.Targets)
{
result.Add(nextEntityName);
GetUsedEntitiesByRelativePathRecursive(result, nextEntityName, fields, intellisenseData);
}
}
}
else if (attribute.AttributeType == Microsoft.Xrm.Sdk.Metadata.AttributeTypeCode.Uniqueidentifier)
{
if (sourceEntity.IsIntersectEntity.GetValueOrDefault())
{
var rel = sourceEntity?.ManyToManyRelationships?.Values?.FirstOrDefault(r => string.Equals(r.IntersectEntityName, sourceEntity.EntityLogicalName, StringComparison.InvariantCultureIgnoreCase));
if (rel != null)
{
result.Add(rel.Entity1Name);
result.Add(rel.Entity2Name);
GetUsedEntitiesByRelativePathRecursive(result, rel.Entity1Name, fields, intellisenseData);
GetUsedEntitiesByRelativePathRecursive(result, rel.Entity2Name, fields, intellisenseData);
return;
}
}
GetUsedEntitiesByRelativePathRecursive(result, null, fields, intellisenseData);
}
}
}
}
}
private string GetNextEntityName(string logicalName, string referenceAttribute, ConnectionIntellisenseData intellisenseData)
{
if (!intellisenseData.Entities.ContainsKey(logicalName))
{
return(null);
}
var entityData = intellisenseData.Entities[logicalName];
if (entityData.Attributes == null ||
!entityData.Attributes.ContainsKey(referenceAttribute)
)
{
return(null);
}
var attribute = entityData.Attributes[referenceAttribute];
if (attribute.AttributeType == Microsoft.Xrm.Sdk.Metadata.AttributeTypeCode.Customer ||
attribute.AttributeType == Microsoft.Xrm.Sdk.Metadata.AttributeTypeCode.Uniqueidentifier ||
attribute.AttributeType == Microsoft.Xrm.Sdk.Metadata.AttributeTypeCode.Lookup ||
attribute.AttributeType == Microsoft.Xrm.Sdk.Metadata.AttributeTypeCode.Owner
)
{
return(logicalName);
}
return(null);
}
