예제 #1
0
        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);
                }
            }
        }
예제 #2
0
        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);
        }
예제 #3
0
        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);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
예제 #4
0
        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);
        }
예제 #6
0
        string NextId()
        {
            while (true)
            {
                string s = "Re" + RelationshipId.ToString();
                if (!Relationships.ContainsKey(s))
                {
                    return(s);
                }

                RelationshipId++;
            }
        }
예제 #7
0
 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]);
                 }
             }
         }
     }
 }
예제 #8
0
        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]);
        }
예제 #9
0
        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);
            }
        }
예제 #11
0
 public bool RelationshipExists(string id)
 {
     return(Relationships.ContainsKey(id));
 }
예제 #12
0
 public bool RelationshipExists(string id)
 {
     CheckIsRelationship();
     return(Relationships.ContainsKey(id));
 }