コード例 #1
0
        public static SoapNode ToSoapObject(this Node node)
        {
            SoapNode soapNode = new SoapNode();

            if (node.DomainUid == null || !node.DomainUid.HasValue)
            {
                throw new NullReferenceException("There is no Domain ID for this node.");
            }

            soapNode.Domain = node.DomainUid.Value;
            soapNode.Id     = node.NodeUid;

            if (node.NodeTypeUid == null || !node.NodeTypeUid.HasValue)
            {
                throw new NullReferenceException("There is no Node Type for this node.");
            }

            soapNode.NodeType = (SoapNodeType)SoapTypeFactory.GetSoapType <SoapNodeType>(node.NodeTypeUid.Value);
            soapNode.Node     = node;

            var allMetadata = node.Metadatas.OrderBy(x => (x.RelationshipUid != null) ? x.RelationshipUid : Guid.Empty).OrderBy(x => (x.DescriptorTypeUid != null) ? x.DescriptorTypeUid : Guid.Empty);

            foreach (var datum in allMetadata)
            {
                MetadataContext key = new MetadataContext()
                {
                    MetadataName      = datum.MetadataName,
                    NodeUid           = datum.NodeUid,
                    RelationshipUid   = datum.RelationshipUid,
                    DescriptorTypeUid = datum.DescriptorTypeUid
                };

                SoapMetadata soapDatum = new SoapMetadata();
                soapDatum.MetadataName  = datum.MetadataName;
                soapDatum.MetadataValue = datum.MetadataValue;

                if (datum.MetadataTypeUid.HasValue)
                {
                    soapDatum.MetadataType = (SoapMetadataType)SoapTypeFactory.GetSoapType <SoapMetadataType>(datum.MetadataTypeUid.Value);
                }

                soapNode.Metadata[key] = soapDatum;
            }

            foreach (Descriptor localDescriptor in node.Descriptors)
            {
                SoapRelationship relationship = localDescriptor.Relationship.ToSoapObject();

                if (relationship != null && !soapNode.Relationships.ContainsKey(relationship.Id))
                {
                    soapNode.Relationships.Add(relationship.Id, relationship);
                }
            }

            return(soapNode);
        }
コード例 #2
0
        public static SoapRelationship ToSoapObject(this Relationship relationship)
        {
            if (relationship != null)
            {
                SoapRelationship soapRelationship = new SoapRelationship();

                soapRelationship.Id = relationship.RelationshipUid;

                if (relationship.RelationshipTypeUid == null || !relationship.RelationshipTypeUid.HasValue)
                {
                    throw new NullReferenceException("There is no Relationship Type for this relationship.");
                }

                soapRelationship.RelationshipType = (SoapRelationshipType)SoapTypeFactory.GetSoapType<SoapRelationshipType>(relationship.RelationshipTypeUid.Value);

                soapRelationship.Relationship = relationship;

                var allMetadata = relationship.Metadatas.OrderBy(x => (x.DescriptorTypeUid != null) ? x.DescriptorTypeUid : Guid.Empty);

                foreach (var datum in allMetadata)
                {
                    SoapMetadata soapDatum = new SoapMetadata();
                    soapDatum.MetadataName = datum.MetadataName;
                    soapDatum.MetadataValue = datum.MetadataValue;

                    if (datum.MetadataTypeUid.HasValue)
                    {
                        soapDatum.MetadataType = (SoapMetadataType)SoapTypeFactory.GetSoapType<SoapMetadataType>(datum.MetadataTypeUid.Value);
                    }

                    soapRelationship.Metadata[datum.MetadataName] = soapDatum;
                }

                foreach (var descriptor in relationship.Descriptors)
                {
                    SoapDescriptorType soapDescriptor = (SoapDescriptorType)SoapTypeFactory.GetSoapType<SoapDescriptorType>(descriptor.DescriptorTypeUid.Value);

                    soapRelationship.Nodes.Add(soapDescriptor, descriptor.NodeUid.Value);
                }

                return soapRelationship;
            }
            return null;
        }
コード例 #3
0
        public static SoapRelationship ToSoapObject(this Relationship relationship)
        {
            if (relationship != null)
            {
                SoapRelationship soapRelationship = new SoapRelationship();

                soapRelationship.Id = relationship.RelationshipUid;

                if (relationship.RelationshipTypeUid == null || !relationship.RelationshipTypeUid.HasValue)
                {
                    throw new NullReferenceException("There is no Relationship Type for this relationship.");
                }

                soapRelationship.RelationshipType = (SoapRelationshipType)SoapTypeFactory.GetSoapType <SoapRelationshipType>(relationship.RelationshipTypeUid.Value);

                soapRelationship.Relationship = relationship;

                var allMetadata = relationship.Metadatas.OrderBy(x => (x.DescriptorTypeUid != null) ? x.DescriptorTypeUid : Guid.Empty);

                foreach (var datum in allMetadata)
                {
                    SoapMetadata soapDatum = new SoapMetadata();
                    soapDatum.MetadataName  = datum.MetadataName;
                    soapDatum.MetadataValue = datum.MetadataValue;

                    if (datum.MetadataTypeUid.HasValue)
                    {
                        soapDatum.MetadataType = (SoapMetadataType)SoapTypeFactory.GetSoapType <SoapMetadataType>(datum.MetadataTypeUid.Value);
                    }

                    soapRelationship.Metadata[datum.MetadataName] = soapDatum;
                }

                foreach (var descriptor in relationship.Descriptors)
                {
                    SoapDescriptorType soapDescriptor = (SoapDescriptorType)SoapTypeFactory.GetSoapType <SoapDescriptorType>(descriptor.DescriptorTypeUid.Value);

                    soapRelationship.Nodes.Add(soapDescriptor, descriptor.NodeUid.Value);
                }

                return(soapRelationship);
            }
            return(null);
        }
コード例 #4
0
        public Dictionary<Guid, SoapNode> GetAllNodes(Guid domainId)
        {
            Dictionary<Guid, SoapNode> nodes = new Dictionary<Guid, SoapNode>();
            SPSecurity.RunWithElevatedPrivileges(delegate()
            {
                using (MappingToolDatabaseDataContext mappingDb = new MappingToolDatabaseDataContext())
                {
                    var matchingNodes = from dbNode
                                        in mappingDb.Nodes
                                        where dbNode.DomainUid == domainId
                                        select dbNode;

                    foreach (var node in matchingNodes)
                    {
                        SoapNode soapNode = new SoapNode();
                        soapNode.Domain = domainId;
                        soapNode.Id = node.NodeUid;
                        soapNode.NodeType = (SoapNodeType)SoapTypeFactory.GetSoapType<SoapNodeType>(node.NodeTypeUid.Value);

                        /// Get the relationships for the node
                        /// 

                        foreach (var originatingDescriptor in node.Descriptors)
                        {
                            Relationship relationship = originatingDescriptor.Relationship;

                            var relationshipMetadata = from dbDatum
                                              in relationship.Metadatas
                                                       where !dbDatum.NodeUid.HasValue && !dbDatum.DescriptorTypeUid.HasValue
                                                       select dbDatum;

                            SoapRelationship soapRelationship = new SoapRelationship();
                            soapRelationship.Id = relationship.RelationshipUid;
                            soapRelationship.RelationshipType = (SoapRelationshipType)SoapTypeFactory.GetSoapType<SoapRelationshipType>(relationship.RelationshipTypeUid.Value);

                            foreach (var datum in relationshipMetadata)
                            {
                                SoapMetadata soapDatum = new SoapMetadata();
                                soapDatum.MetadataName = datum.MetadataName;
                                soapDatum.MetadataValue = datum.MetadataValue;

                                if (datum.MetadataTypeUid.HasValue)
                                {
                                    soapDatum.MetadataType = (SoapMetadataType)SoapTypeFactory.GetSoapType<SoapMetadataType>(datum.MetadataTypeUid.Value);
                                }

                                soapRelationship.Metadata.Add(datum.MetadataName, soapDatum);
                            }

                            foreach (var destinationDescriptor in relationship.Descriptors)
                            {
                                if (destinationDescriptor.DescriptorUid == originatingDescriptor.DescriptorUid)
                                {
                                    continue;
                                }

                                if (nodes.ContainsKey(destinationDescriptor.Node.NodeUid))
                                {
                                    continue;
                                }

                                Node childNode = destinationDescriptor.Node;

                                /// Connect the node to the relationships.
                                /// 

                                if (!destinationDescriptor.DescriptorTypeUid.HasValue)
                                {
                                    throw new NotSupportedException("The descriptor doesn't have a type ID.");
                                }

                                SoapDescriptorType soapDescriptorType = (SoapDescriptorType)SoapTypeFactory.GetSoapType<SoapDescriptorType>(destinationDescriptor.DescriptorTypeUid.Value);
                                soapRelationship.Nodes.Add(soapDescriptorType, childNode.NodeUid);
                            }

                            soapNode.Relationships.Add(soapRelationship.Id, soapRelationship);
                        }

                        /// Get the metadata for the node according to the current context.
                        /// 
                        var metadata = from dbDatum in node.Metadatas select dbDatum;

                        foreach (var datum in metadata.OrderBy(x => (x.RelationshipUid != null) ? x.RelationshipUid : Guid.Empty).OrderBy(x => (x.DescriptorTypeUid != null) ? x.DescriptorTypeUid : Guid.Empty))
                        {
                            MetadataContext key = new MetadataContext()
                            {
                                MetadataName = datum.MetadataName,
                                NodeUid = datum.NodeUid,
                                RelationshipUid = datum.RelationshipUid,
                                DescriptorTypeUid = datum.DescriptorTypeUid
                            };

                            SoapMetadata soapDatum = new SoapMetadata();
                            soapDatum.MetadataName = datum.MetadataName;
                            soapDatum.MetadataValue = datum.MetadataValue;

                            if (datum.MetadataTypeUid.HasValue)
                            {
                                soapDatum.MetadataType = (SoapMetadataType)SoapTypeFactory.GetSoapType<SoapMetadataType>(datum.MetadataTypeUid.Value);
                            }

                            soapNode.Metadata.Add(key, soapDatum);
                        }
                        /// End getting metadata.
                        /// 

                        nodes.Add(soapNode.Id, soapNode);
                    }
                }
            });
            return nodes;
        }
コード例 #5
0
        public ConnectedNodesResult ConnectNodes(Guid domainId, Dictionary<SoapDescriptorType, Guid> nodes, SoapRelationshipType relationshipType, string originalId)
        {
            ConnectedNodesResult connectedNodesResult = null;
            if (nodes.Values.Distinct().Count() > 1)
            {
                SPSecurity.RunWithElevatedPrivileges(delegate()
                {
                    using (MappingToolDatabaseDataContext mappingDb = new MappingToolDatabaseDataContext())
                    {
                        List<SoapNode> updatedNodes = new List<SoapNode>();

                        var domains = from dbDomain in mappingDb.Domains where dbDomain.DomainUid == domainId select dbDomain;

                        var domain = domains.First();

                        Relationship relationship = new Relationship();
                        relationship.RelationshipUid = Guid.NewGuid();
                        relationship.RelationshipOriginalId = originalId;
                        relationship.RelationshipTypeUid = relationshipType.Id;

                        SoapRelationship soapRelationship = new SoapRelationship();
                        soapRelationship.Id = relationship.RelationshipUid;
                        soapRelationship.RelationshipType = relationshipType;

                        foreach (KeyValuePair<SoapDescriptorType, Guid> keyValuePair in nodes)
                        {
                            Descriptor descriptor = new Descriptor();
                            descriptor.DescriptorUid = Guid.NewGuid();
                            descriptor.RelationshipUid = relationship.RelationshipUid;
                            descriptor.DescriptorTypeUid = keyValuePair.Key.Id;

                            Node node = domain.Nodes.Single(x => x.NodeUid == keyValuePair.Value);
                            node.Domain = domain;
                            node.Descriptors.Add(descriptor);

                            soapRelationship.Nodes.Add(keyValuePair.Key, node.NodeUid);
                            SoapNode soapNode = node.ToSoapObject();
                            soapNode.Relationships.Add(soapRelationship.Id, soapRelationship);
                            updatedNodes.Add(soapNode);

                            domain.Relationships.Add(relationship);
                        }

                        mappingDb.SubmitChanges();

                        connectedNodesResult = new ConnectedNodesResult();
                        connectedNodesResult.Relationship = soapRelationship;
                        connectedNodesResult.Nodes = new Dictionary<Guid, SoapNode>();
                        foreach (SoapNode soapNode in updatedNodes)
                        {
                            if (!connectedNodesResult.Nodes.ContainsKey(soapNode.Id))
                            {
                                connectedNodesResult.Nodes.Add(soapNode.Id, soapNode);
                            }
                        }
                    }
                });
            }
            else
            {
                LoggingService.WriteTrace(LoggingService.Categories.WcfServices, TraceSeverity.Unexpected, "ConnectNodes() failed: There must be at least 2 distinct nodes connected.");
                //This will cause an error to be returned on the WFC event, over SOAP it won't contain the fault contract.
                throw new FaultException<ConnectNodesFailureFault>(new ConnectNodesFailureFault(), "There must be at least 2 distinct nodes connected.");
            }

            return connectedNodesResult;
        }
コード例 #6
0
        private void RecurseThroughLevels(Dictionary<Guid, SoapNode> nodes, Guid domainId, Node currentNode, Node initialSearchNode, int depth, List<Condition> conditions)
        {
            SoapNode currentSoapNode;

            if (!nodes.ContainsKey(currentNode.NodeUid))
            {
                currentSoapNode = new SoapNode();
                currentSoapNode.Id = currentNode.NodeUid;
                currentSoapNode.Domain = domainId;

                if (!currentNode.NodeTypeUid.HasValue)
                {
                    throw new NotSupportedException("The node doesn't have a type ID.");
                }

                currentSoapNode.NodeType = (SoapNodeType)SoapTypeFactory.GetSoapType<SoapNodeType>(currentNode.NodeTypeUid.Value);

                if (currentSoapNode.NodeType.Name != "DomainNode")
                {
                    /// Get the metadata for the child node according to the current context.
                    var currentNodeMetadata = from dbDatum in currentNode.Metadatas select dbDatum;

                    foreach (var datum in currentNodeMetadata.OrderBy(x => (x.RelationshipUid != null) ? x.RelationshipUid : Guid.Empty).OrderBy(x => (x.DescriptorTypeUid != null) ? x.DescriptorTypeUid : Guid.Empty))
                    {
                        MetadataContext key = new MetadataContext()
                        {
                            MetadataName = datum.MetadataName,
                            NodeUid = datum.NodeUid,
                            RelationshipUid = datum.RelationshipUid,
                            DescriptorTypeUid = datum.DescriptorTypeUid
                        };

                        SoapMetadata soapDatum = new SoapMetadata();
                        soapDatum.MetadataName = datum.MetadataName;
                        soapDatum.MetadataValue = datum.MetadataValue;

                        if (datum.MetadataTypeUid.HasValue)
                        {
                            soapDatum.MetadataType = (SoapMetadataType)SoapTypeFactory.GetSoapType<SoapMetadataType>(datum.MetadataTypeUid.Value);
                        }

                        currentSoapNode.Metadata[key] = soapDatum;
                    }
                    /// End getting metadata.

                    //let the conditions determine if the node is added or not.
                    if (conditions == null)
                    {
                        nodes.Add(currentSoapNode.Id, currentSoapNode);
                    }
                }
            }
            else
            {
                currentSoapNode = nodes[currentNode.NodeUid];
            }

            foreach (var originatingDescriptor in currentNode.Descriptors)
            {
                Relationship relationship = originatingDescriptor.Relationship;

                var relationshipMetadata = from dbDatum
                                           in relationship.Metadatas
                                           where !dbDatum.NodeUid.HasValue && !dbDatum.DescriptorTypeUid.HasValue
                                           select dbDatum;

                SoapRelationship soapRelationship = new SoapRelationship();
                soapRelationship.Id = relationship.RelationshipUid;
                soapRelationship.RelationshipType = (SoapRelationshipType)SoapTypeFactory.GetSoapType<SoapRelationshipType>(relationship.RelationshipTypeUid.Value);

                foreach (var datum in relationshipMetadata)
                {
                    SoapMetadata soapDatum = new SoapMetadata();
                    soapDatum.MetadataName = datum.MetadataName;
                    soapDatum.MetadataValue = datum.MetadataValue;

                    if (datum.MetadataTypeUid.HasValue)
                    {
                        soapDatum.MetadataType = (SoapMetadataType)SoapTypeFactory.GetSoapType<SoapMetadataType>(datum.MetadataTypeUid.Value);
                    }

                    soapRelationship.Metadata.Add(datum.MetadataName, soapDatum);
                }

                SoapDescriptorType soapOriginatingDescriptorType = (SoapDescriptorType)SoapTypeFactory.GetSoapType<SoapDescriptorType>(originatingDescriptor.DescriptorTypeUid.Value);
                soapRelationship.Nodes.Add(soapOriginatingDescriptorType, currentNode.NodeUid);

                if (!currentSoapNode.Relationships.ContainsKey(soapRelationship.Id))
                {
                    currentSoapNode.Relationships.Add(soapRelationship.Id, soapRelationship);
                }

                foreach (var destinationDescriptor in relationship.Descriptors)
                {
                    if (destinationDescriptor.DescriptorUid == originatingDescriptor.DescriptorUid)
                    {
                        continue; //original end of the relationship
                    }

                    if (nodes.ContainsKey(destinationDescriptor.Node.NodeUid))
                    {
                        continue; //already know about this node
                    }

                    Node childNode = destinationDescriptor.Node;

                    /// Connect the parent node to the relationships.
                    if (!destinationDescriptor.DescriptorTypeUid.HasValue)
                    {
                        throw new NotSupportedException("The descriptor doesn't have a type ID.");
                    }

                    SoapDescriptorType soapDestinationDescriptorType = (SoapDescriptorType)SoapTypeFactory.GetSoapType<SoapDescriptorType>(destinationDescriptor.DescriptorTypeUid.Value);
                    soapRelationship.Nodes.Add(soapDestinationDescriptorType, childNode.NodeUid);

                    SoapNode soapNode = new SoapNode();
                    soapNode.Id = childNode.NodeUid;
                    soapNode.Domain = domainId;

                    if (!soapNode.Relationships.ContainsKey(soapRelationship.Id))
                    {
                        soapNode.Relationships.Add(soapRelationship.Id, soapRelationship);
                    }

                    if (!childNode.NodeTypeUid.HasValue)
                    {
                        throw new NotSupportedException("The node doesn't have a type ID.");
                    }

                    soapNode.NodeType = (SoapNodeType)SoapTypeFactory.GetSoapType<SoapNodeType>(childNode.NodeTypeUid.Value);

                    /// Get the metadata for the child or parent node according to the current context.
                    /// 

                    var metadata = from dbDatum in childNode.Metadatas select dbDatum;

                    foreach (var datum in metadata.OrderBy(x => (x.RelationshipUid != null) ? x.RelationshipUid : Guid.Empty).OrderBy(x => (x.DescriptorTypeUid != null) ? x.DescriptorTypeUid : Guid.Empty))
                    {
                        MetadataContext key = new MetadataContext()
                        {
                            MetadataName = datum.MetadataName,
                            NodeUid = datum.NodeUid,
                            RelationshipUid = datum.RelationshipUid,
                            DescriptorTypeUid = datum.DescriptorTypeUid
                        };

                        SoapMetadata soapDatum = new SoapMetadata();
                        soapDatum.MetadataName = datum.MetadataName;
                        soapDatum.MetadataValue = datum.MetadataValue;

                        if (datum.MetadataTypeUid.HasValue)
                        {
                            soapDatum.MetadataType = (SoapMetadataType)SoapTypeFactory.GetSoapType<SoapMetadataType>(datum.MetadataTypeUid.Value);
                        }

                        soapNode.Metadata[key] = soapDatum;
                    }

                    /// End getting metadata.
                    /// 

                    if (depth >= 0 && conditions == null)
                    {
                        // Add the child or parent node to the collection
                        nodes.Add(destinationDescriptor.Node.NodeUid, soapNode);

                        if (depth > 0) //don't recurse any further
                        {
                            int nextDepthLevel = depth - 1;

                            RecurseThroughLevels(nodes, domainId, destinationDescriptor.Node, initialSearchNode, nextDepthLevel, conditions);
                        }
                    }
                    else if (conditions != null)
                    {
                        //Map equality test code for debugging - doesn't work correctly
                        //MapEqualityMatch mapMatch = new MapEqualityMatch();
                        //mapMatch.Evaluate(initialSearchNode, destinationDescriptor.Node, destinationDescriptor.Relationship, destinationDescriptor);
                        bool nodeAlreadyAdded = false;
                        bool nodeExcludedAlready = false;
                        if (!evaluatedNodes.Contains(destinationDescriptor.Node.NodeUid.ToString()))
                        {
                            foreach (Condition conditionRule in conditions)
                            {
                                //no need to evaluate already excluded nodes against any conditions
                                if (!excludedNodes.Contains(destinationDescriptor.Node.NodeUid.ToString()))
                                {
                                    ConditionResult conditionResult = conditionRule.Evaluate(initialSearchNode, destinationDescriptor.Node, destinationDescriptor.Relationship, destinationDescriptor);
                                    if (!evaluatedNodes.Contains(destinationDescriptor.Node.NodeUid.ToString()))
                                    {
                                        evaluatedNodes.Add(destinationDescriptor.Node.NodeUid.ToString());
                                    }
                                    if (conditionResult.Value)
                                    {
                                        if (!conditionResult.IncludeNode)
                                        {
                                            //if the node isn't to be included and the rule matches remove it
                                            excludedNodes.Add(destinationDescriptor.Node.NodeUid.ToString());
                                            nodeExcludedAlready = true;
                                            if (nodeAlreadyAdded)
                                            {
                                                nodes.Remove(destinationDescriptor.Node.NodeUid);
                                            }
                                        }
                                        if (conditionResult.IncludeNode && !nodeAlreadyAdded && !nodeExcludedAlready && soapNode.NodeType.Name != "DomainNode")
                                        {
                                            //if the node is to be included, hasn't matched an exclusion rule and isn't the domain node add it
                                            nodes.Add(destinationDescriptor.Node.NodeUid, soapNode);
                                            nodeAlreadyAdded = true;
                                        }
                                        if (conditionResult.Action == Action.Continue)
                                        {
                                            //keep looking through the related nodes
                                            RecurseThroughLevels(nodes, domainId, destinationDescriptor.Node, initialSearchNode, -1, conditions);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }