Example #1
0
        static StringBuilder GetExistingResource(IResource resource, StringBuilder contents, string reason, List <IResource> resources)
        {
            var res            = resources.FirstOrDefault(p => p.ResourceID == resource.ResourceID);
            var Outputcontents = contents;

            if (res != null && res.ResourceName != resource.ResourceName)//Found Existing resource
            {
                var resourceXml = contents.ToXElement();
                if (!reason?.Equals(GlobalConstants.SaveReasonForDeploy) ?? true)
                {
                    resourceXml.SetAttributeValue("Name", res.ResourceName);
                    resourceXml.SetElementValue("DisplayName", res.ResourceName);
                    var actionElement = resourceXml.Element("Action");
                    var xamlElement   = actionElement?.Element("XamlDefinition");
                    if (xamlElement != null)
                    {
                        var xamlContent = xamlElement.Value;
                        xamlElement.Value = xamlContent.
                                            Replace("x:Class=\"" + resource.ResourceName + "\"", "x:Class=\"" + res.ResourceName + "\"")
                                            .Replace("Flowchart DisplayName=\"" + resource.ResourceName + "\"", "Flowchart DisplayName=\"" + res.ResourceName + "\"");
                    }
                    resource.ResourceName = res.ResourceName;
                    Outputcontents        = resourceXml.ToStringBuilder();
                }
            }

            return(Outputcontents);
        }
Example #2
0
        public ResourceCatalogResult SaveResource(Guid workspaceID, StringBuilder resourceXml, string savedPath, string reason, string user)
        {
            try
            {
                if (resourceXml == null || resourceXml.Length == 0)
                {
                    throw new ArgumentNullException(nameof(resourceXml));
                }

                var @lock = Common.GetWorkspaceLock(workspaceID);
                lock (@lock)
                {
                    var xml = resourceXml.ToXElement();

                    var resource = new Resource(xml);
                    GlobalConstants.InvalidateCache(resource.ResourceID);
                    Dev2Logger.Info("Save Resource." + resource, GlobalConstants.WarewolfInfo);
                    _serverVersionRepository.StoreVersion(resource, user, reason, workspaceID, savedPath);

                    resource.UpgradeXml(xml, resource);

                    var result = xml.ToStringBuilder();

                    return(CompileAndSave(workspaceID, resource, result, savedPath, reason));
                }
            }
            catch (Exception err)
            {
                Dev2Logger.Error("Save Error", err, GlobalConstants.WarewolfError);
                throw;
            }
        }
        public static string ExtractOutputMapping(StringBuilder serviceDef)
        {
            string result = string.Empty;

            var xe = serviceDef.ToXElement();

            // could have service as its root ;(
            var tmpB = xe.Elements().FirstOrDefault(c => c.Name == GlobalConstants.ActionsRootTag);

            var tmpA = xe.Elements().FirstOrDefault(c => c.Name == GlobalConstants.ActionRootTag);

            if (tmpB != null)
            {
                tmpA = tmpB.Elements().FirstOrDefault(c => c.Name == GlobalConstants.ActionRootTag);
            }


            if (tmpA != null)
            {
                var dl = tmpA.Elements().FirstOrDefault(c => c.Name == GlobalConstants.OutputRootTag);

                if (dl != null)
                {
                    result = dl.ToString();
                }
            }


            return(result);
        }
Example #4
0
        XElement SaveToDisk(IResource resource, StringBuilder contents, string directoryName, TxFileManager fileManager)
        {
            if (!Directory.Exists(directoryName))
            {
                Directory.CreateDirectory(directoryName);
            }

            if (_dev2FileWrapper.Exists(resource.FilePath))
            {
                // Remove readonly attribute if it is set
                var attributes = _dev2FileWrapper.GetAttributes(resource.FilePath);
                if ((attributes & FileAttributes.ReadOnly) == FileAttributes.ReadOnly)
                {
                    _dev2FileWrapper.SetAttributes(resource.FilePath, attributes ^ FileAttributes.ReadOnly);
                }
            }

            var xml = contents.ToXElement();

            xml = resource.UpgradeXml(xml, resource);
            var result = xml.ToStringBuilder();

            var signedXml = HostSecurityProvider.Instance.SignXml(result);

            lock (Common.GetFileLock(resource.FilePath))
            {
                signedXml.WriteToFile(resource.FilePath, Encoding.UTF8, fileManager);
            }
            return(xml);
        }
Example #5
0
        static void UpdateXmlToDisk(IResource resource, IList <ICompileMessageTO> compileMessagesTO, StringBuilder resourceContents)
        {
            var resourceElement = resourceContents.ToXElement();

            if (compileMessagesTO.Count > 0)
            {
                SetErrors(resourceElement, compileMessagesTO);
                UpdateIsValid(resourceElement);
            }
            else
            {
                UpdateIsValid(resourceElement);
            }

            var result = resourceElement.ToStringBuilder();

            var signedXml = HostSecurityProvider.Instance.SignXml(result);

            lock (GetFileLock(resource.FilePath))
            {
                var fileManager = new TxFileManager();
                using (TransactionScope tx = new TransactionScope())
                {
                    try
                    {
                        signedXml.WriteToFile(resource.FilePath, Encoding.UTF8, fileManager);
                        tx.Complete();
                    }
                    catch (Exception ex)
                    {
                        Transaction.Current.Rollback();
                    }
                }
            }
        }
Example #6
0
        public void ExtensionMethods_ToStreamForXmlLoad_WhenLoadingXElement_ExpectException()
        {
            //------------Setup for test--------------------------
            const string  val   = "<x><y>1</y>.</</x>";
            StringBuilder value = new StringBuilder(val);

            //------------Execute Test---------------------------
            value.ToXElement();
        }
        public StringBuilder GetResourceDefinition(bool prepairForDeployment, Guid resourceId, StringBuilder contents)
        {
            var serializer = new Dev2JsonSerializer();
            var res        = new ExecuteMessage();

            try
            {
                if (!contents.IsNullOrEmpty())
                {
                    var assembly = Assembly.Load("Dev2.Data");
                    var type     = assembly.GetType("Dev2.Runtime.ServiceModel.Data.Resource");
                    var instance = Activator.CreateInstance(type, contents.ToXElement());

                    var resource = (IResource)instance;
                    if (resource.ResourceType == @"DbSource")
                    {
                        res.Message.Append(contents);
                    }
                    else
                    {
                        DoWorkflowServiceMessage(contents, res);
                    }
                }
            }
            catch (ServiceNotAuthorizedException ex)
            {
                res.Message  = ex.Message.ToStringBuilder();
                res.HasError = true;
                return(serializer.SerializeToBuilder(res));
            }
            catch (Exception e)
            {
                Dev2Logger.Error(string.Format(ErrorResource.ErrorGettingResourceDefinition, resourceId), e, GlobalConstants.WarewolfError);
            }

            if (!res.Message.IsNullOrEmpty())
            {
                var dev2XamlCleaner = new Dev2XamlCleaner();
                res.Message = dev2XamlCleaner.StripNaughtyNamespaces(res.Message);
            }
            if (prepairForDeployment)
            {
                try
                {
                    res.Message = DecryptAllPasswords(res.Message);
                }
                catch (CryptographicException e)
                {
                    Dev2Logger.Error(@"Encryption had issues.", e, GlobalConstants.WarewolfError);
                }
            }


            return(serializer.SerializeToBuilder(res));
        }
        private static T GetResource <T>(StringBuilder resourceContents) where T : Resource, new()
        {
            if (resourceContents == null)
            {
                return(default(T));
            }
            var elm = resourceContents.ToXElement();

            object[] args = { elm };
            return((T)Activator.CreateInstance(typeof(T), args));
        }
Example #9
0
        static T GetResource <T>(StringBuilder resourceContents) where T : Resource, new()
        {
            if (resourceContents == null || string.IsNullOrEmpty(resourceContents.ToString()) || resourceContents.Length == 0)
            {
                return(default(T));
            }

            var elm = resourceContents.ToXElement();

            object[] args = { elm };
            return((T)Activator.CreateInstance(typeof(T), args));
        }
Example #10
0
        public void ExtensionMethods_AttributeSafe_WhenAttributeExist_ExpectAttributeValue()
        {
            //------------Setup for test--------------------------
            const string msg = "<x foo=\"bar\">test message</x>";
            var          sb  = new StringBuilder(msg);

            //------------Execute Test---------------------------

            var xe     = sb.ToXElement();
            var result = xe.AttributeSafe("foo");

            //------------Assert Results-------------------------
            StringAssert.Contains(result, "bar");
        }
Example #11
0
        public void ExtensionMethods_ToStreamForXmlLoad_WhenLoadingXElement_ExpectValidXElement()
        {
            //------------Setup for test--------------------------
            const string  val   = "<x><y>1</y></x>";
            StringBuilder value = new StringBuilder(val);

            //------------Execute Test---------------------------
            var xe = value.ToXElement();

            string result = xe.ToString(SaveOptions.DisableFormatting);

            //------------Assert Results-------------------------
            Assert.AreEqual(val, result);
        }
Example #12
0
        public void ExtensionMethods_ElementSafe_WhenElementDoesNotExist_ExpectEmptyString()
        {
            //------------Setup for test--------------------------
            const string msg = "<x><y>y value</y></x>";
            var          sb  = new StringBuilder(msg);

            //------------Execute Test---------------------------

            var xe     = sb.ToXElement();
            var result = xe.ElementSafe("q");

            //------------Assert Results-------------------------
            Assert.AreEqual(result, string.Empty);
        }
Example #13
0
        public void ExtensionMethods_ElementSafe_WhenElementExist_ExpectElement()
        {
            //------------Setup for test--------------------------
            const string msg = "<x><y>y value</y></x>";
            var          sb  = new StringBuilder(msg);

            //------------Execute Test---------------------------

            var xe     = sb.ToXElement();
            var result = xe.ElementSafe("y");

            //------------Assert Results-------------------------
            StringAssert.Contains(result, "y");
        }
Example #14
0
        public void ExtensionMethods_AttributeSafe_WhenAttributeDoesNotExist_ExpectEmptyString()
        {
            //------------Setup for test--------------------------
            const string msg = "<x foo=\"bar\">test message</x>";
            var          sb  = new StringBuilder(msg);

            //------------Execute Test---------------------------

            var xe     = sb.ToXElement();
            var result = xe.AttributeSafe("foo2");

            //------------Assert Results-------------------------
            Assert.AreEqual(result, string.Empty);
        }
Example #15
0
        public List <DynamicServiceObjectBase> GenerateServiceGraph(StringBuilder serviceData)
        {
            if (serviceData == null || serviceData.Length == 0)
            {
                throw new ArgumentException("serviceData");
            }
            var result = new List <DynamicServiceObjectBase>();
            var xe     = serviceData.ToXElement();

            if (IsSource(serviceData))
            {
                var src = new Source();
                var tmp = src as DynamicServiceObjectBase;
                ServiceMetaData.ExtractMetaData(xe, ref tmp);

                var typeOf = xe.AttributeSafe("ResourceType");

                src.Type = !Enum.TryParse(typeOf, out enSourceType sourceType) ? enSourceType.Unknown : sourceType;

                src.ConnectionString = xe.AttributeSafe("ConnectionString");
                src.AssemblyName     = xe.AttributeSafe("AssemblyName");
                src.AssemblyLocation = xe.AttributeSafe("AssemblyLocation");

                // PBI 6597: TWR - added source ID check
                var id = ServiceMetaData.SetID(ref xe);
                src.ID = id;
                src.ResourceDefinition = serviceData;

                result.Add(src);
            }
            else
            {
                var ds  = new DynamicService();
                var tmp = ds as DynamicServiceObjectBase;
                ServiceMetaData.ExtractMetaData(xe, ref tmp);

                // set the resource def ;)
                ds.ResourceDefinition = serviceData;

                var actions = xe.Element("Actions");
                var action  = actions != null?actions.Element("Action") : xe.Element("Action");

                if (action != null)
                {
                    xe = AddServiceAction(serviceData, result, xe, ds, action);
                }
            }
            return(result);
        }
        /// <summary>
        /// Extracts the data list.
        /// </summary>
        /// <param name="serviceDef">The service def.</param>
        /// <returns></returns>
        public static string ExtractDataList(StringBuilder serviceDef)
        {
            string result = string.Empty;

            var xe = serviceDef.ToXElement();

            var dl = xe.Elements().FirstOrDefault(c => c.Name == GlobalConstants.DataListRootTag);

            if (dl != null)
            {
                result = dl.ToString(SaveOptions.DisableFormatting);
            }
            
            return result;
        }
Example #17
0
        /// <summary>
        /// Extracts the data list.
        /// </summary>
        /// <param name="serviceDef">The service def.</param>
        /// <returns></returns>
        public static string ExtractDataList(StringBuilder serviceDef)
        {
            var result = string.Empty;

            var xe = serviceDef.ToXElement();

            var dl = xe.Elements().FirstOrDefault(c => c.Name == GlobalConstants.DataListRootTag);

            if (dl != null)
            {
                result = dl.ToString(SaveOptions.DisableFormatting);
            }

            return(result);
        }
        public IGraph BuildGraph(StringBuilder xmlData, string modelName, double width, double height, int nestingLevel)
        {
            if (xmlData == null || xmlData.Length == 0)
            {
                return(new Graph(ErrorResource.DependencyMissing));
            }

            var xe = xmlData.ToXElement();

            // Create a graph.
            var graphElem = xe.AncestorsAndSelf("graph").FirstOrDefault();

            if (graphElem == null)
            {
                return(new Graph(ErrorResource.DependencyInormationMalformed));
            }

            try
            {
                var    title = graphElem.Attribute("title").Value;
                var    graph = new Graph(title);
                double count = 0;

                var nodeElems = graphElem.Elements("node").ToList();

                // Create all of the nodes and add them to the graph.
                foreach (var nodeElem in nodeElems)
                {
                    count = BuildGraphPositionData(modelName, width, height, graph, count, nodeElem);
                }

                // Associate each node with its dependencies.
                AssociateEachNodeWithItsDependencies(nestingLevel, graph, nodeElems);

                // Tell the graph to inspect itself for circular dependencies.
                graph.CheckForCircularDependencies();

                return(graph);
            }
            catch (Exception ex)
            {
                return(new Graph(ErrorResource.DependencyInormationMalformed));
            }
        }
Example #19
0
 public Guid GetResourceID(Dictionary <string, StringBuilder> requestArgs)
 {
     if (requestArgs != null && requestArgs.Count > 0)
     {
         requestArgs.TryGetValue("ResourceXml", out StringBuilder resourceDefinition);
         if (resourceDefinition != null && resourceDefinition.Length > 0)
         {
             var serializer = new Dev2JsonSerializer();
             resourceDefinition = new StringBuilder(serializer.Deserialize <CompressedExecuteMessage>(resourceDefinition).GetDecompressedMessage());
             var xml      = resourceDefinition.ToXElement();
             var resource = new Resource(xml);
             var res      = ResourceCatalog.Instance.GetResource(GlobalConstants.ServerWorkspaceID, resource.ResourceID);
             if (res != null)
             {
                 return(res.ResourceID);
             }
         }
     }
     return(Guid.Empty);
 }
Example #20
0
        public void ExtensionMethods_CleanEncodingHeaderForXmlSave_WhenSavingXElement_ExpectEncodingHeaderRemoved()
        {
            //------------Setup for test--------------------------
            StringBuilder value = new StringBuilder("<x><y>1</y></x>");

            //------------Execute Test---------------------------
            var xe = value.ToXElement();

            var sb = new StringBuilder();

            using (var sw = new StringWriter(sb))
            {
                xe.Save(sw, SaveOptions.DisableFormatting);
            }

            var res = sb.CleanEncodingHeaderForXmlSave();

            //------------Assert Results-------------------------
            var result = res.Contains("encoding=");

            Assert.IsFalse(result, "Encoding Header Not Removed");
        }
Example #21
0
        public void AppServer_Update_Resource_Correctly()
        {
            CommunicationController coms = new CommunicationController {
                ServiceName = "SaveResourceService"
            };

            var tmp = new StringBuilder(TestResource.Service_Update_Request_String);
            var xe  = tmp.ToXElement();
            var xml = xe.Element("ResourceXml");

            var wtf = xml.ToStringBuilder().Unescape();

            wtf = wtf.Replace("<XmlData>", "").Replace("</XmlData>", "").Replace("<ResourceXml>", "").Replace("</ResourceXml>", "");

            coms.AddPayloadArgument("ResourceXml", wtf);
            coms.AddPayloadArgument("WorkspaceID", Guid.Empty.ToString());

            const string expected = @"Updated WorkflowService 'ServiceToBindFrom'";

            var result = coms.ExecuteCommand <ExecuteMessage>(_connection, Guid.Empty);

            StringAssert.Contains(result.Message.ToString(), expected);
        }
        public void ExtensionMethods_ToStreamForXmlLoad_WhenLoadingXElement_ExpectException()
        {
            //------------Setup for test--------------------------
            const string val = "<x><y>1</y>.</</x>";
            StringBuilder value = new StringBuilder(val);

            //------------Execute Test---------------------------
            value.ToXElement();
        }
        public void ExtensionMethods_AttributeSafe_WhenAttributeDoesNotExist_ExpectEmptyString()
        {
            //------------Setup for test--------------------------
            const string msg = "<x foo=\"bar\">test message</x>";
            var sb = new StringBuilder(msg);

            //------------Execute Test---------------------------

            var xe = sb.ToXElement();
            var result = xe.AttributeSafe("foo2");

            //------------Assert Results-------------------------
            Assert.AreEqual(result, string.Empty);
        }
        public void ExtensionMethods_CleanEncodingHeaderForXmlSave_WhenSavingXElement_ExpectEncodingHeaderRemoved()
        {
            //------------Setup for test--------------------------
            StringBuilder value = new StringBuilder("<x><y>1</y></x>");

            //------------Execute Test---------------------------
            var xe = value.ToXElement();

            var sb = new StringBuilder();
            using(var sw = new StringWriter(sb))
            {
                xe.Save(sw, SaveOptions.DisableFormatting);
            }

            var res = sb.CleanEncodingHeaderForXmlSave();

            //------------Assert Results-------------------------
            var result = res.Contains("encoding=");

            Assert.IsFalse(result, "Encoding Header Not Removed");
        }
        public void ExtensionMethods_ElementSafe_WhenElementDoesNotExist_ExpectEmptyString()
        {
            //------------Setup for test--------------------------
            const string msg = "<x><y>y value</y></x>";
            var sb = new StringBuilder(msg);

            //------------Execute Test---------------------------

            var xe = sb.ToXElement();
            var result = xe.ElementSafe("q");

            //------------Assert Results-------------------------
            Assert.AreEqual(result, string.Empty);
        }
        public void ExtensionMethods_AttributeSafe_WhenAttributeExist_ExpectAttributeValue()
        {
            //------------Setup for test--------------------------
            const string msg = "<x foo=\"bar\">test message</x>";
            var sb = new StringBuilder(msg);

            //------------Execute Test---------------------------

            var xe = sb.ToXElement();
            var result = xe.AttributeSafe("foo");

            //------------Assert Results-------------------------
            StringAssert.Contains(result, "bar");
        }
        public void AppServer_Update_Resource_Correctly()
        {
            CommunicationController coms = new CommunicationController { ServiceName = "SaveResourceService" };

            var tmp = new StringBuilder(TestResource.Service_Update_Request_String);
            var xe = tmp.ToXElement();
            var xml = xe.Element("ResourceXml");

            var wtf = xml.ToStringBuilder().Unescape();
            wtf = wtf.Replace("<XmlData>", "").Replace("</XmlData>", "").Replace("<ResourceXml>", "").Replace("</ResourceXml>", "");

            coms.AddPayloadArgument("ResourceXml", wtf);
            coms.AddPayloadArgument("WorkspaceID", Guid.Empty.ToString());

            const string expected = @"Updated WorkflowService 'ServiceToBindFrom'";

            var result = coms.ExecuteCommand<ExecuteMessage>(_connection, Guid.Empty);

            StringAssert.Contains(result.Message.ToString(), expected);

        }
        public void ExtensionMethods_ElementSafe_WhenElementExist_ExpectElement()
        {
            //------------Setup for test--------------------------
            const string msg = "<x><y>y value</y></x>";
            var sb = new StringBuilder(msg);

            //------------Execute Test---------------------------

            var xe = sb.ToXElement();
            var result = xe.ElementSafe("y");

            //------------Assert Results-------------------------
            StringAssert.Contains(result, "y");
        }
Example #29
0
        public IGraph BuildGraph(StringBuilder xmlData, string modelName, double width, double height, int nestingLevel)
        {
            if (xmlData == null || xmlData.Length == 0)
            {
                return(new Graph(ErrorResource.DependencyMissing));
            }

            var xe = xmlData.ToXElement();

            // Create a graph.
            var graphElem = xe.AncestorsAndSelf("graph").FirstOrDefault();

            if (graphElem == null)
            {
                return(new Graph(ErrorResource.DependencyInormationMalformed));
            }

            try
            {
                var    title = graphElem.Attribute("title").Value;
                var    graph = new Graph(title);
                double count = 0;

                var nodeElems = graphElem.Elements("node").ToList();

                // Create all of the nodes and add them to the graph.
                foreach (var nodeElem in nodeElems)
                {
                    // build the graph position data
                    var id   = nodeElem.Attribute("id").Value;
                    var node = CreateNode(nodeElem, modelName, width, height, ref count);

                    var alreadyAdded = false;
                    foreach (var n in graph.Nodes)
                    {
                        if (n.ID == id)
                        {
                            alreadyAdded = true;
                        }
                    }

                    if (!alreadyAdded)
                    {
                        graph.Nodes.Add(node);
                    }
                }

                // Associate each node with its dependencies.
                var graphCount = graph.Nodes.Count - 1;
                if (nestingLevel > 0)
                {
                    for (var i = 0; i <= nestingLevel; i++)
                    {
                        if (nestingLevel < graphCount)
                        {
                            graph.Nodes.RemoveAt(graphCount);
                            graphCount = graph.Nodes.Count - 1;
                        }
                    }
                }
                foreach (var node in graph.Nodes)
                {
                    var nodeElem        = nodeElems.First(elem => elem.Attribute("id").Value == node.ID);
                    var dependencyElems = nodeElem.Elements("dependency");
                    foreach (var dependencyElem in dependencyElems)
                    {
                        var depID = dependencyElem.Attribute("id").Value;

                        var dependency = graph.Nodes.FirstOrDefault(n => n.ID == depID);
                        if (dependency != null)
                        {
                            node.NodeDependencies.Add(dependency);
                        }
                    }

                    //Now adjust position according to nodesize
                    node.LocationX = node.LocationX - node.NodeWidth;
                    node.LocationY = node.LocationY - node.NodeHeight / 2;
                }

                // Tell the graph to inspect itself for circular dependencies.
                graph.CheckForCircularDependencies();

                return(graph);
            }
            catch
            {
                return(new Graph(ErrorResource.DependencyInormationMalformed));
            }
        }
        public static string ExtractOutputMapping(StringBuilder serviceDef)
        {
            string result = string.Empty;

            var xe = serviceDef.ToXElement();

            // could have service as its root ;(
            var tmpB = xe.Elements().FirstOrDefault(c => c.Name == GlobalConstants.ActionsRootTag);

            var tmpA = xe.Elements().FirstOrDefault(c => c.Name == GlobalConstants.ActionRootTag);

            if (tmpB != null)
            {
                tmpA = tmpB.Elements().FirstOrDefault(c => c.Name == GlobalConstants.ActionRootTag);
            }


            if (tmpA != null)
            {
                var dl = tmpA.Elements().FirstOrDefault(c => c.Name == GlobalConstants.OutputRootTag);

                if (dl != null)
                {
                    result = dl.ToString();
                }
            }


            return result;
        }
Example #31
0
 void UpdateResourceDependencies(IResource resource, StringBuilder contents)
 {
     resource.LoadDependencies(contents.ToXElement());
 }
        /// <summary>
        /// Builds the graph.
        /// </summary>
        /// <param name="xmlData">The XML data.</param>
        /// <param name="modelName">Name of the model.</param>
        /// <param name="width">The width.</param>
        /// <param name="height">The height.</param>
        /// <returns></returns>
        public Graph BuildGraph(StringBuilder xmlData, string modelName, double width, double height)
        {

            if(xmlData == null || xmlData.Length == 0)
            {
                return new Graph("Dependency information could not be retrieved");
            }

            XElement xe = xmlData.ToXElement();

            // Create a graph.
            var graphElem = xe.AncestorsAndSelf("graph").FirstOrDefault();
            if(graphElem == null)
            {
                return new Graph("Dependency information is malformed");
            }

            try
            {
                string title = graphElem.Attribute("title").Value;
                var graph = new Graph(title);
                double count = 0;

                var nodeElems = graphElem.Elements("node").ToList();

                // Create all of the nodes and add them to the graph.
                foreach(XElement nodeElem in nodeElems)
                {
                    // build the graph position data
                    string id = nodeElem.Attribute("id").Value;
                    var node = CreateNode(nodeElem, modelName, width, height, ref count);

                    bool alreadyAdded = false;
                    foreach(Node n in graph.Nodes)
                    {
                        if(n.ID == id)
                        {
                            alreadyAdded = true;
                        }
                    }

                    if(!alreadyAdded)
                    {
                        graph.Nodes.Add(node);
                    }
                }

                // Associate each node with its dependencies.
                foreach(Node node in graph.Nodes)
                {
                    var nodeElem = nodeElems.First(elem => elem.Attribute("id").Value == node.ID);
                    var dependencyElems = nodeElem.Elements("dependency");
                    foreach(XElement dependencyElem in dependencyElems)
                    {
                        string depID = dependencyElem.Attribute("id").Value;

                        var dependency = graph.Nodes.FirstOrDefault(n => n.ID == depID);
                        if(dependency != null)
                            node.NodeDependencies.Add(dependency);
                    }

                    //Now adjust position according to nodesize
                    node.LocationX = node.LocationX - node.NodeWidth;
                    node.LocationY = node.LocationY - node.NodeHeight / 2;
                }

                // Tell the graph to inspect itself for circular dependencies.
                graph.CheckForCircularDependencies();

                return graph;
            }
            catch
            {
                return new Graph("Dependency information is malformed");
            }
        }
Example #33
0
        /// <summary>
        /// Builds the graph.
        /// </summary>
        /// <param name="xmlData">The XML data.</param>
        /// <param name="modelName">Name of the model.</param>
        /// <param name="width">The width.</param>
        /// <param name="height">The height.</param>
        /// <returns></returns>
        public Graph BuildGraph(StringBuilder xmlData, string modelName, double width, double height)
        {
            if (xmlData == null || xmlData.Length == 0)
            {
                return(new Graph("Dependency information could not be retrieved"));
            }

            XElement xe = xmlData.ToXElement();

            // Create a graph.
            var graphElem = xe.AncestorsAndSelf("graph").FirstOrDefault();

            if (graphElem == null)
            {
                return(new Graph("Dependency information is malformed"));
            }

            try
            {
                string title = graphElem.Attribute("title").Value;
                var    graph = new Graph(title);
                double count = 0;

                var nodeElems = graphElem.Elements("node").ToList();

                // Create all of the nodes and add them to the graph.
                foreach (XElement nodeElem in nodeElems)
                {
                    // build the graph position data
                    string id   = nodeElem.Attribute("id").Value;
                    var    node = CreateNode(nodeElem, modelName, width, height, ref count);

                    bool alreadyAdded = false;
                    foreach (Node n in graph.Nodes)
                    {
                        if (n.ID == id)
                        {
                            alreadyAdded = true;
                        }
                    }

                    if (!alreadyAdded)
                    {
                        graph.Nodes.Add(node);
                    }
                }

                // Associate each node with its dependencies.
                foreach (Node node in graph.Nodes)
                {
                    var nodeElem        = nodeElems.First(elem => elem.Attribute("id").Value == node.ID);
                    var dependencyElems = nodeElem.Elements("dependency");
                    foreach (XElement dependencyElem in dependencyElems)
                    {
                        string depID = dependencyElem.Attribute("id").Value;

                        var dependency = graph.Nodes.FirstOrDefault(n => n.ID == depID);
                        if (dependency != null)
                        {
                            node.NodeDependencies.Add(dependency);
                        }
                    }

                    //Now adjust position according to nodesize
                    node.LocationX = node.LocationX - node.NodeWidth;
                    node.LocationY = node.LocationY - node.NodeHeight / 2;
                }

                // Tell the graph to inspect itself for circular dependencies.
                graph.CheckForCircularDependencies();

                return(graph);
            }
            catch
            {
                return(new Graph("Dependency information is malformed"));
            }
        }
        public List<DynamicServiceObjectBase> GenerateServiceGraph(StringBuilder serviceData)
        {
            if(serviceData == null || serviceData.Length == 0)
            {
                throw new ArgumentException("serviceData");
            }

            List<DynamicServiceObjectBase> result = new List<DynamicServiceObjectBase>();
            var xe = serviceData.ToXElement();

            if(IsSource(serviceData))
            {
                Source src = new Source();
                var tmp = src as DynamicServiceObjectBase;
                ServiceMetaData.ExtractMetaData(xe, ref tmp);

                var typeOf = xe.AttributeSafe("ResourceType");

                enSourceType sourceType;
                src.Type = !Enum.TryParse(typeOf, out sourceType) ? enSourceType.Unknown : sourceType;

                src.ConnectionString = xe.AttributeSafe("ConnectionString");
                var tmpUri = xe.AttributeSafe("Uri");
                if(!string.IsNullOrEmpty(tmpUri))
                {
                    src.WebServiceUri = new Uri(tmpUri);
                }

                src.AssemblyName = xe.AttributeSafe("AssemblyName");
                src.AssemblyLocation = xe.AttributeSafe("AssemblyLocation");

                // PBI 6597: TWR - added source ID check
                var id = ServiceMetaData.SetID(ref xe);
                src.ID = id;
                src.ResourceDefinition = serviceData;

                result.Add(src);

            }
            else
            {
                DynamicService ds = new DynamicService();
                var tmp = ds as DynamicServiceObjectBase;
                ServiceMetaData.ExtractMetaData(xe, ref tmp);

                // set the resource def ;)
                ds.ResourceDefinition = serviceData;

                var actions = xe.Element("Actions");
                XElement action = actions != null ? actions.Element("Action") : xe.Element("Action");

                if(action != null)
                {
                    ServiceAction sa = new ServiceAction { Name = action.AttributeSafe("Name"), ResourceDefinition = serviceData };

                    // Set service action ;)
                    enActionType actionType;
                    var typeOf = action.AttributeSafe("Type");
                    if(Enum.TryParse(typeOf, out actionType))
                    {
                        sa.ActionType = actionType;
                    }

                    var element = action.Element("Outputs");
                    if(element != null)
                    {
                        sa.OutputSpecification = element.Value;
                    }

                    // set name and id ;)
                    sa.ServiceName = ds.Name;
                    var id = ServiceMetaData.SetID(ref xe);
                    ds.ID = id;

                    if(IsWorkflow(serviceData))
                    {
                        // Convert to StringBuilder
                        var xElement = action.Element("XamlDefinition");
                        if(xElement != null)
                        {
                            var def = xElement.ToStringBuilder();
                            def = def.Replace("<XamlDefinition>", "").Replace("</XamlDefinition>", "");
                            sa.XamlDefinition = def.Unescape();
                        }

                        var dataList = xe.Element("DataList");
                        if(dataList != null)
                        {
                            ds.DataListSpecification = dataList.ToStringBuilder();
                        }
                    }
                    else
                    {
                        if(sa.ActionType == enActionType.InvokeStoredProc)
                        {
                            int timeout;
                            Int32.TryParse(action.AttributeSafe("CommandTimeout"), out timeout);
                            sa.CommandTimeout = timeout;
                        }

                        var xElement = action.Element("OutputDescription");
                        if(xElement != null)
                        {
                            sa.OutputDescription = xElement.Value;
                        }

                        // process inputs and outputs ;)
                        var inputs = action.Element("Inputs");

                        if(inputs != null)
                        {
                            var inputCollection = inputs.Elements("Input");

                            foreach(var inputItem in inputCollection)
                            {
                                bool emptyToNull;
                                bool.TryParse(inputItem.AttributeSafe("EmptyToNull"), out emptyToNull);

                                ServiceActionInput sai = new ServiceActionInput
                                {
                                    Name = inputItem.AttributeSafe("Name"),
                                    Source = inputItem.AttributeSafe("Source"),
                                    DefaultValue = inputItem.AttributeSafe("DefaultValue"),
                                    EmptyToNull = emptyToNull,
                                    NativeType = inputItem.AttributeSafe("NativeType")
                                };

                                if(string.IsNullOrEmpty(sai.NativeType))
                                {
                                    sai.NativeType = "object";
                                }

                                // handle validators ;)
                                var validators = inputItem.Elements("Validator");
                                foreach(var validator in validators)
                                {
                                    Validator v = new Validator();

                                    enValidationType validatorType;
                                    v.ValidatorType = !Enum.TryParse(validator.AttributeSafe("Type"), out validatorType) ? enValidationType.Required : validatorType;

                                    sai.Validators.Add(v);
                                }

                                sa.ServiceActionInputs.Add(sai);
                            }
                        }
                    }

                    // add the action
                    ds.Actions.Add(sa);
                    result.Add(ds);
                }

            }

            return result;
        }
        public void ExtensionMethods_ToStreamForXmlLoad_WhenLoadingXElement_ExpectValidXElement()
        {
            //------------Setup for test--------------------------
            const string val = "<x><y>1</y></x>";
            StringBuilder value = new StringBuilder(val);

            //------------Execute Test---------------------------
            var xe = value.ToXElement();

            string result = xe.ToString(SaveOptions.DisableFormatting);

            //------------Assert Results-------------------------
            Assert.AreEqual(val, result);
        }
Example #36
0
        public List <DynamicServiceObjectBase> GenerateServiceGraph(StringBuilder serviceData)
        {
            if (serviceData == null || serviceData.Length == 0)
            {
                throw new ArgumentException("serviceData");
            }

            List <DynamicServiceObjectBase> result = new List <DynamicServiceObjectBase>();
            var xe = serviceData.ToXElement();

            if (IsSource(serviceData))
            {
                Source src = new Source();
                var    tmp = src as DynamicServiceObjectBase;
                ServiceMetaData.ExtractMetaData(xe, ref tmp);

                var typeOf = xe.AttributeSafe("ResourceType");

                enSourceType sourceType;
                src.Type = !Enum.TryParse(typeOf, out sourceType) ? enSourceType.Unknown : sourceType;

                src.ConnectionString = xe.AttributeSafe("ConnectionString");
                var tmpUri = xe.AttributeSafe("Uri");
                if (!string.IsNullOrEmpty(tmpUri))
                {
                    src.WebServiceUri = new Uri(tmpUri);
                }

                src.AssemblyName     = xe.AttributeSafe("AssemblyName");
                src.AssemblyLocation = xe.AttributeSafe("AssemblyLocation");

                // PBI 6597: TWR - added source ID check
                var id = ServiceMetaData.SetID(ref xe);
                src.ID = id;
                src.ResourceDefinition = serviceData;

                result.Add(src);
            }
            else
            {
                DynamicService ds  = new DynamicService();
                var            tmp = ds as DynamicServiceObjectBase;
                ServiceMetaData.ExtractMetaData(xe, ref tmp);

                // set the resource def ;)
                ds.ResourceDefinition = serviceData;

                var      actions = xe.Element("Actions");
                XElement action  = actions != null?actions.Element("Action") : xe.Element("Action");

                if (action != null)
                {
                    ServiceAction sa = new ServiceAction {
                        Name = action.AttributeSafe("Name"), ResourceDefinition = serviceData
                    };

                    // Set service action ;)
                    enActionType actionType;
                    var          typeOf = action.AttributeSafe("Type");
                    if (Enum.TryParse(typeOf, out actionType))
                    {
                        sa.ActionType = actionType;
                    }

                    var element = action.Element("Outputs");
                    if (element != null)
                    {
                        sa.OutputSpecification = element.Value;
                    }

                    // set name and id ;)
                    sa.ServiceName = ds.Name;
                    var id = ServiceMetaData.SetID(ref xe);
                    ds.ID = id;

                    if (IsWorkflow(serviceData))
                    {
                        // Convert to StringBuilder
                        var xElement = action.Element("XamlDefinition");
                        if (xElement != null)
                        {
                            var def = xElement.ToStringBuilder();
                            def = def.Replace("<XamlDefinition>", "").Replace("</XamlDefinition>", "");
                            sa.XamlDefinition = def.Unescape();
                        }

                        var dataList = xe.Element("DataList");
                        if (dataList != null)
                        {
                            ds.DataListSpecification = dataList.ToStringBuilder();
                        }
                    }
                    else
                    {
                        if (sa.ActionType == enActionType.InvokeStoredProc)
                        {
                            int timeout;
                            Int32.TryParse(action.AttributeSafe("CommandTimeout"), out timeout);
                            sa.CommandTimeout = timeout;
                        }

                        var xElement = action.Element("OutputDescription");
                        if (xElement != null)
                        {
                            sa.OutputDescription = xElement.Value;
                        }

                        // process inputs and outputs ;)
                        var inputs = action.Element("Inputs");

                        if (inputs != null)
                        {
                            var inputCollection = inputs.Elements("Input");

                            foreach (var inputItem in inputCollection)
                            {
                                bool emptyToNull;
                                bool.TryParse(inputItem.AttributeSafe("EmptyToNull"), out emptyToNull);

                                ServiceActionInput sai = new ServiceActionInput
                                {
                                    Name         = inputItem.AttributeSafe("Name"),
                                    Source       = inputItem.AttributeSafe("Source"),
                                    DefaultValue = inputItem.AttributeSafe("DefaultValue"),
                                    EmptyToNull  = emptyToNull,
                                    NativeType   = inputItem.AttributeSafe("NativeType")
                                };

                                if (string.IsNullOrEmpty(sai.NativeType))
                                {
                                    sai.NativeType = "object";
                                }

                                // handle validators ;)
                                var validators = inputItem.Elements("Validator");
                                foreach (var validator in validators)
                                {
                                    Validator v = new Validator();

                                    enValidationType validatorType;
                                    v.ValidatorType = !Enum.TryParse(validator.AttributeSafe("Type"), out validatorType) ? enValidationType.Required : validatorType;

                                    sai.Validators.Add(v);
                                }

                                sa.ServiceActionInputs.Add(sai);
                            }
                        }
                    }

                    // add the action
                    ds.Actions.Add(sa);
                    result.Add(ds);
                }
            }

            return(result);
        }
        private void PerformSaveResult(out ResourceCatalogResult saveResult, Guid workspaceID, IResource resource, StringBuilder contents, bool overwriteExisting, string savedPath)
        {
            var fileManager = new TxFileManager();

            using (TransactionScope tx = new TransactionScope())
            {
                try
                {
                    var resources   = _resourceCatalog.GetResources(workspaceID);
                    var conflicting = resources.FirstOrDefault(r => resource.ResourceID != r.ResourceID && r.GetResourcePath(workspaceID) != null && r.GetResourcePath(workspaceID).Equals(savedPath + "\\" + resource.ResourceName, StringComparison.InvariantCultureIgnoreCase) && r.ResourceName.Equals(resource.ResourceName, StringComparison.InvariantCultureIgnoreCase));
                    if (conflicting != null && !conflicting.IsNewResource || conflicting != null && !overwriteExisting)
                    {
                        saveResult = ResourceCatalogResultBuilder.CreateDuplicateMatchResult(string.Format(ErrorResource.TypeConflict, conflicting.ResourceType));
                        return;
                    }
                    var res = resources.FirstOrDefault(p => p.ResourceID == resource.ResourceID);
                    if (res != null)                                   //Found Existing resource
                    {
                        if (res.ResourceName != resource.ResourceName) // Renamed while open
                        {
                            var resourceXml = contents.ToXElement();
                            resourceXml.SetAttributeValue("Name", res.ResourceName);
                            resourceXml.SetElementValue("DisplayName", res.ResourceName);
                            var actionElement = resourceXml.Element("Action");
                            var xamlElement   = actionElement?.Element("XamlDefinition");
                            if (xamlElement != null)
                            {
                                var xamlContent = xamlElement.Value;
                                xamlElement.Value = xamlContent.
                                                    Replace("x:Class=\"" + resource.ResourceName + "\"", "x:Class=\"" + res.ResourceName + "\"")
                                                    .Replace("Flowchart DisplayName=\"" + resource.ResourceName + "\"", "Flowchart DisplayName=\"" + res.ResourceName + "\"");
                            }
                            resource.ResourceName = res.ResourceName;
                            contents = resourceXml.ToStringBuilder();
                        }
                    }
                    var directoryName = SetResourceFilePath(workspaceID, resource, ref savedPath);

                    #region Save to disk

                    var xml = SaveToDisk(resource, contents, directoryName, fileManager);

                    #endregion

                    #region Add to catalog

                    var updated = AddToCatalog(resource, resources, fileManager, xml);

                    #endregion
                    Dev2Logger.Debug($"Removing Execution Plan for {resource.ResourceID} for workspace {workspaceID}");
                    ((ResourceCatalog)_resourceCatalog).RemoveFromResourceActivityCache(workspaceID, resource);
                    Dev2Logger.Debug($"Removed Execution Plan for {resource.ResourceID} for workspace {workspaceID}");
                    Dev2Logger.Debug($"Adding Execution Plan for {resource.ResourceID} for workspace {workspaceID}");
                    ((ResourceCatalog)_resourceCatalog).Parse(workspaceID, resource.ResourceID);
                    Dev2Logger.Debug($"Added Execution Plan for {resource.ResourceID} for workspace {workspaceID}");
                    tx.Complete();
                    saveResult = ResourceCatalogResultBuilder.CreateSuccessResult($"{(updated ? "Updated" : "Added")} {resource.ResourceType} '{resource.ResourceName}'");
                }
                catch (Exception)
                {
                    Transaction.Current.Rollback();
                    throw;
                }
            }
        }