public void AttachElements()
{
foreach (Descriptor descriptor in Descriptors.Values)
{
if (Relationships.ContainsKey(descriptor.RelationshipUid))
{
Relationship relationship = Relationships[descriptor.RelationshipUid];
relationship.AddNode(descriptor);
}
}
foreach (Metadata metadata in Metadata.Values)
{
MetadataContext metadataContext = new MetadataContext(metadata);
if (metadataContext.GetContextType() == MetadataContextType.Node && Nodes.ContainsKey(metadata.NodeUid.Value))
{
Node node = Nodes[metadata.NodeUid.Value];
node.Metadata.Add(metadataContext, metadata);
}
else if (metadataContext.GetContextType() == MetadataContextType.Relationship && Relationships.ContainsKey(metadata.RelationshipUid.Value))
{
Relationship relationship = Relationships[metadata.RelationshipUid.Value];
relationship.Metadata.Add(metadataContext, metadata);
}
}
}
private PackageRelationship CreateRelationship(Uri targetUri, TargetMode targetMode, string relationshipType, string id, bool loading)
{
if (!loading)
{
Package.CheckIsReadOnly();
}
Check.TargetUri(targetUri);
Check.RelationshipTypeIsValid(relationshipType);
Check.IdIsValid(id);
if (id == null)
{
id = NextId();
}
if (Relationships.ContainsKey(id))
{
throw new XmlException("A relationship with this ID already exists");
}
PackageRelationship r = new PackageRelationship(id, Package, relationshipType, Uri, targetMode, targetUri);
Relationships.Add(r.Id, r);
if (!loading)
{
WriteRelationships();
}
return(r);
}
public void FindNodeIdsByRelationshipType(Guid nodeId, ref HashSet <Guid> relatedMapsNodeList, Guid ignoreNodeId, Guid descriptorTypeId, params Guid[] relationshipTypes)
{
if (DescriptorsByNode.ContainsKey(nodeId))
{
Dictionary <Guid, List <QueryMapDescriptor> > descriptorsByType = DescriptorsByNode[nodeId];
foreach (List <QueryMapDescriptor> descriptorList in descriptorsByType.Values)
{
foreach (QueryMapDescriptor descriptor in descriptorList)
{
if (Relationships.ContainsKey(descriptor.RelationshipUid.Value))
{
QueryMapRelationship relationship = Relationships[descriptor.RelationshipUid.Value];
foreach (Guid relationshipType in relationshipTypes)
{
if (relationship.RelationshipTypeUid == relationshipType)
{
var descriptors = DescriptorsByRelationship[relationship.RelationshipUid][descriptorTypeId];
foreach (QueryMapDescriptor opposingDescriptor in descriptors)
{
if (opposingDescriptor.NodeUid.Value != null && (ignoreNodeId == Guid.Empty || opposingDescriptor.NodeUid != ignoreNodeId))
{
relatedMapsNodeList.Add(opposingDescriptor.NodeUid.Value);
}
}
}
}
}
}
}
}
}
public IEnumerable <QueryMapRelationship> GetRelationshipsByRelationshipType(Guid nodeId, params Guid[] relationshipTypes)
{
if (DescriptorsByNode.ContainsKey(nodeId))
{
Dictionary <Guid, List <QueryMapDescriptor> > descriptorsByType = DescriptorsByNode[nodeId];
foreach (List <QueryMapDescriptor> descriptorList in descriptorsByType.Values)
{
foreach (QueryMapDescriptor descriptor in descriptorList)
{
if (Relationships.ContainsKey(descriptor.RelationshipUid.Value))
{
QueryMapRelationship relationship = Relationships[descriptor.RelationshipUid.Value];
foreach (Guid relationshipType in relationshipTypes)
{
if (relationship.RelationshipTypeUid == relationshipType)
{
yield return(relationship);
}
}
}
}
}
}
}
public XrmFakedRelationship GetRelationship(string schemaName)
{
if (Relationships.ContainsKey(schemaName))
{
return(Relationships[schemaName]);
}
return(null);
}
string NextId()
{
while (true)
{
string s = "Re" + RelationshipId.ToString();
if (!Relationships.ContainsKey(s))
{
return(s);
}
RelationshipId++;
}
}
public IEnumerable <QueryMapRelationship> GetRelationshipsByDescriptorType(Guid nodeId, Guid descriptorType)
{
if (DescriptorsByNode.ContainsKey(nodeId))
{
if (DescriptorsByNode[nodeId].ContainsKey(descriptorType))
{
foreach (var descriptor in DescriptorsByNode[nodeId][descriptorType])
{
if (Relationships.ContainsKey(descriptor.RelationshipUid.Value))
{
yield return(Relationships[descriptor.RelationshipUid.Value]);
}
}
}
}
}
public RelationshipCollection GetRelationships(Type type)
{
if (!Relationships.ContainsKey(type))
{
lock (_relationshipsLock)
{
if (!Relationships.ContainsKey(type))
{
RelationshipCollection relationships = GetMapStrategy(type).MapRelationships(type);
Relationships.Add(type, relationships);
return(relationships);
}
}
}
return(Relationships[type]);
}
public IEnumerable <QueryMapRelationship> GetRelationships(QueryMapNode node, params Guid[] relationshipTypes)
{
if (relationshipTypes.Length <= 0)
{
foreach (QueryMapDescriptor descriptor in Descriptors)
{
if (descriptor.NodeUid == node.NodeUid)
{
if (descriptor.RelationshipUid.HasValue)
{
if (Relationships.ContainsKey(descriptor.RelationshipUid.Value))
{
yield return(Relationships[descriptor.RelationshipUid.Value]);
}
}
}
}
}
else
{
HashSet <Guid> relationshipTypesHashSet = new HashSet <Guid>(relationshipTypes);
foreach (QueryMapDescriptor descriptor in Descriptors)
{
if (descriptor.NodeUid == node.NodeUid)
{
if (descriptor.RelationshipUid.HasValue)
{
QueryMapRelationship relationship = Relationships[descriptor.RelationshipUid.Value];
if (relationship.RelationshipTypeUid.HasValue && relationshipTypesHashSet.Contains(relationship.RelationshipTypeUid.Value))
{
yield return(relationship);
}
}
}
}
}
}
public static void Equal(Relationships expected, Relationships actual)
{
if (expected == null)
{
Assert.Null(actual);
return;
}
Assert.NotNull(actual);
Assert.Equal(expected.Count, actual.Count);
foreach (var key in expected.Keys)
{
Assert.True(actual.ContainsKey(key));
var expectedRelationship = expected[key];
Assert.IsAssignableFrom <Relationship>(expectedRelationship);
var actualRelationship = actual[key];
Assert.IsAssignableFrom <Relationship>(actualRelationship);
RelationshipAssert.Equal(expectedRelationship, actualRelationship);
}
}
public bool RelationshipExists(string id)
{
return(Relationships.ContainsKey(id));
}
public bool RelationshipExists(string id)
{
CheckIsRelationship();
return(Relationships.ContainsKey(id));
}
