public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
        {
            var serializer = new Dev2JsonSerializer();

            try
            {
                var pluginSource = serializer.Deserialize <ComPluginSourceDefinition>(values["source"]);
                var ns           = serializer.Deserialize <INamespaceItem>(values["namespace"]);
                // ReSharper disable MaximumChainedReferences
                ComPluginServices services = new ComPluginServices();
                var src = ResourceCatalog.Instance.GetResource <ComPluginSource>(GlobalConstants.ServerWorkspaceID, pluginSource.Id);
                //src.AssemblyName = ns.FullName;
                ComPluginService svc = new ComPluginService();
                if (ns != null)
                {
                    svc.Namespace = ns.FullName; svc.Source = src;
                }
                else
                {
                    svc.Source = src;
                }
                var serviceMethodList = services.Methods(svc, Guid.Empty, Guid.Empty);
                var methods           = serviceMethodList.Select(a => new PluginAction
                {
                    FullName = ns?.FullName,
                    Inputs   = a.Parameters.Select(x =>
                                                   new ServiceInput(x.Name, x.DefaultValue ?? "")
                    {
                        Name = BuildServiceInputName(x.Name, x.TypeName)
                        ,
                        EmptyIsNull = x.EmptyToNull
                        ,
                        RequiredField = x.IsRequired
                        ,
                        TypeName = x.TypeName
                    } as IServiceInput).ToList(),
                    Method    = a.Name,
                    Variables = a.Parameters.Select(x => new NameValue()
                    {
                        Name = x.Name + " (" + x.TypeName + ")", Value = ""
                    } as INameValue).ToList(),
                } as IPluginAction).ToList();
                return(serializer.SerializeToBuilder(new ExecuteMessage()
                {
                    HasError = false,
                    Message = serializer.SerializeToBuilder(methods)
                }));
            }
            catch (Exception e)
            {
                return(serializer.SerializeToBuilder(new ExecuteMessage()
                {
                    HasError = true,
                    Message = new StringBuilder(e.Message)
                }));
            }
        }
Exemplo n.º 2
0
        public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
        {
            ExecuteMessage     msg        = new ExecuteMessage();
            Dev2JsonSerializer serializer = new Dev2JsonSerializer();

            try
            {
                Dev2Logger.Info("Test ComPlugin Service");
                StringBuilder resourceDefinition;

                values.TryGetValue("ComPluginService", out resourceDefinition);
                IComPluginService src = serializer.Deserialize <IComPluginService>(resourceDefinition);

                // ReSharper disable MaximumChainedReferences
                var parameters = src.Inputs?.Select(a => new MethodParameter {
                    EmptyToNull = a.EmptyIsNull, IsRequired = a.RequiredField, Name = a.Name, Value = a.Value, TypeName = a.TypeName
                }).ToList() ?? new List <MethodParameter>();
                // ReSharper restore MaximumChainedReferences
                var pluginsrc = ResourceCatalog.Instance.GetResource <ComPluginSource>(GlobalConstants.ServerWorkspaceID, src.Source.Id);
                var res       = new ComPluginService
                {
                    Method       = new ServiceMethod(src.Action.Method, src.Name, parameters, new OutputDescription(), new List <MethodOutput>(), "test"),
                    Namespace    = src.Action.FullName,
                    ResourceName = src.Name,
                    ResourceID   = src.Id,
                    Source       = pluginsrc
                };

                string serializedResult;
                var    result = _pluginServices.Value.Test(serializer.SerializeToBuilder(res).ToString(), out serializedResult);

                if (serializedResult.StartsWith("Exception: "))
                {
                    msg.HasError = true;
                    msg.Message  = new StringBuilder(serializedResult);
                    Dev2Logger.Error(serializedResult);
                }
                else
                {
                    msg.HasError = false;
                    msg.Message  = serializer.SerializeToBuilder(new RecordsetListWrapper {
                        Description = result.Description, RecordsetList = result, SerializedResult = serializedResult
                    });
                }
            }
            catch (Exception err)
            {
                msg.HasError = true;
                msg.Message  = new StringBuilder(err.Message);
                Dev2Logger.Error(err);
            }

            return(serializer.SerializeToBuilder(msg));
        }
Exemplo n.º 3
0
        protected virtual RecordsetList FetchRecordset(ComPluginService pluginService, bool addFields)
        {
            if (pluginService == null)
            {
                throw new ArgumentNullException(nameof(pluginService));
            }
            var broker            = new ComPluginBroker();
            var outputDescription = broker.TestPlugin(pluginService);
            var dataSourceShape   = outputDescription.DataSourceShapes[0];
            var recSet            = outputDescription.ToRecordsetList(pluginService.Recordsets, GlobalConstants.PrimitiveReturnValueTag);

            if (recSet != null)
            {
                foreach (var recordset in recSet)
                {
                    foreach (var field in recordset.Fields)
                    {
                        if (string.IsNullOrEmpty(field.Name))
                        {
                            continue;
                        }
                        var path    = field.Path;
                        var rsAlias = string.IsNullOrEmpty(field.RecordsetAlias) ? "" : field.RecordsetAlias.Replace("()", "");

                        var value = string.Empty;
                        if (!string.IsNullOrEmpty(field.Alias))
                        {
                            value = string.IsNullOrEmpty(rsAlias)
                                        ? $"[[{field.Alias}]]"
                                : $"[[{rsAlias}().{field.Alias}]]";
                        }

                        if (path != null)
                        {
                            path.OutputExpression = value;
                            var foundPath = dataSourceShape.Paths.FirstOrDefault(path1 => path1.OutputExpression == path.OutputExpression);
                            if (foundPath == null)
                            {
                                dataSourceShape.Paths.Add(path);
                            }
                            else
                            {
                                foundPath.OutputExpression = path.OutputExpression;
                            }
                        }
                    }
                }
            }
            return(recSet);
        }
        public static ComPluginService CreatePluginService(ServiceMethod method)
        {
            var source  = CreatePluginSource();
            var service = new ComPluginService
            {
                ResourceID   = Guid.NewGuid(),
                ResourceName = "DummyPluginService",
                ResourceType = "ComPluginService",
                Namespace    = "Namespace",
                Method       = method,
                Source       = source,
            };

            return(service);
        }
        static ComPluginService CreatePluginService(ServiceMethod method)
        {
            var type = typeof(DummyClassForPluginTest);

            var source = CreateComPluginSource();
            var service = new ComPluginService
            {
                ResourceID = Guid.NewGuid(),
                ResourceName = "DummyPluginService",
                ResourceType = "PluginService",
                Namespace = type.FullName,
                Method = method,
                Source = source,
            };
            return service;
        }
Exemplo n.º 6
0
        // POST: Service/PluginServices/Methods
        public ServiceMethodList Methods(ComPluginService args, Guid workspaceId, Guid dataListId)
        {
            var result = new ServiceMethodList();

            try
            {
                var broker          = new ComPluginBroker();
                var comPluginSource = (ComPluginSource)args.Source;
                result = broker.GetMethods(comPluginSource.ClsId, comPluginSource.Is32Bit);
                return(result);
            }
            catch (Exception ex)
            {
                RaiseError(ex);
            }
            return(result);
        }
        public void ComPluginServicesDeserializeServiceWithValidJsonExpectedReturnsPluginService()
        {
            var xml     = XmlResource.Fetch("ComPluginService");
            var service = new ComPluginService(xml);

            var services = new ComPluginServicesMock();
            var result   = services.DeserializeService(service.ToString());

            Assert.AreEqual(Guid.Parse("89098b76-ac11-40b2-b3e8-b175314cb3bb"), service.ResourceID);
            Assert.AreEqual("ComPluginService", service.ResourceType);
            Assert.AreEqual(Guid.Parse("00746beb-46c1-48a8-9492-e2d20817fcd5"), service.Source.ResourceID);
            Assert.AreEqual("ComPluginTesterSource", service.Source.ResourceName);
            Assert.AreEqual("Dev2.Terrain.Mountain", service.Namespace);
            Assert.AreEqual("Echo", service.Method.Name);

            Assert.AreEqual("<root>hello</root>", service.Method.Parameters.First(p => p.Name == "text").DefaultValue);

            Assert.AreEqual("reverb", service.Recordsets[0].Fields.First(f => f.Name == "echo").Alias);
        }
Exemplo n.º 8
0
        protected virtual RecordsetList FetchRecordset(ComPluginService pluginService, bool addFields)
        {
            if (pluginService == null)
            {
                throw new ArgumentNullException(nameof(pluginService));
            }
            var broker            = new ComPluginBroker();
            var outputDescription = broker.TestPlugin(pluginService);
            var dataSourceShape   = outputDescription.DataSourceShapes[0];
            var recSet            = outputDescription.ToRecordsetList(pluginService.Recordsets, GlobalConstants.PrimitiveReturnValueTag);

            if (recSet != null)
            {
                foreach (var recordset in recSet)
                {
                    FetchRecordsetFields_ComPluginService(dataSourceShape, recordset);
                }
            }
            return(recSet);
        }
Exemplo n.º 9
0
        public override StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
        {
            var serializer = new Dev2JsonSerializer();

            try
            {
                var pluginSource = serializer.Deserialize <ComPluginSourceDefinition>(values["source"]);
                var ns           = serializer.Deserialize <INamespaceItem>(values["namespace"]);

                var services = new ComPluginServices();
                var src      = ResourceCatalog.Instance.GetResource <ComPluginSource>(GlobalConstants.ServerWorkspaceID, pluginSource.Id);
                var svc      = new ComPluginService();
                if (ns != null)
                {
                    svc.Namespace = ns.FullName;
                    svc.Source    = src;
                }
                else
                {
                    svc.Source = src;
                }


                var serviceMethodList = new ServiceMethodList();
                var task = Task.Run(() =>
                {
                    return(serviceMethodList = services.Methods(svc, Guid.Empty, Guid.Empty));
                });
                try
                {
                    var timeoutAfter = task.TimeoutAfter(TimeSpan.FromSeconds(3));
                    serviceMethodList = timeoutAfter.Result;
                }
                catch (Exception e)
                {
                    Dev2Logger.Error(e, GlobalConstants.WarewolfError);
                }


                var methods = serviceMethodList.Select(a => new PluginAction
                {
                    FullName = ns?.FullName,
                    Inputs   = a.Parameters.Select(x =>
                                                   new ServiceInput(x.Name, x.DefaultValue ?? "")
                    {
                        Name = BuildServiceInputName(x.Name, x.TypeName)
                        ,
                        EmptyIsNull = x.EmptyToNull
                        ,
                        RequiredField = x.IsRequired
                        ,
                        TypeName = x.TypeName
                    } as IServiceInput).ToList(),
                    Method    = a.Name,
                    Variables = a.Parameters.Select(x => new NameValue {
                        Name = x.Name + " (" + x.TypeName + ")", Value = ""
                    } as INameValue).ToList(),
                } as IPluginAction).ToList();
                return(serializer.SerializeToBuilder(new ExecuteMessage
                {
                    HasError = false,
                    Message = serializer.SerializeToBuilder(methods)
                }));
            }
            catch (Exception e)
            {
                return(serializer.SerializeToBuilder(new ExecuteMessage()
                {
                    HasError = true,
                    Message = new StringBuilder(e.Message)
                }));
            }
        }