Пример #1
0
        /// <inheritdoc />
        public object Invoke(IVariableProvider variables, params object[] arguments)
        {
            if (!(variables.GetProvider("log")?["log"] is WorkableLogger logger))
            {
                throw new ScriptRuntimeException($"Calling a workflow as method requires an existing logger of type '{nameof(WorkableLogger)}' accessible under variable 'log'", null);
            }

            if (!(arguments.FirstOrDefault() is IDictionary scriptarguments))
            {
                throw new InvalidOperationException($"Parameters for a workflow call need to be a dictionary ('{arguments.FirstOrDefault()?.GetType()}')");
            }

            if (!(scriptarguments is IDictionary <string, object> parameters))
            {
                parameters = new Dictionary <string, object>();
                foreach (object key in scriptarguments.Keys)
                {
                    parameters[key.ToString() ?? string.Empty] = scriptarguments[key];
                }
            }

            return(Task.Run(async() => {
                IScript script = await LoadScript();
                return await script.ExecuteAsync(new StateVariableProvider(parameters, new Variable("log", logger)));
            }).GetAwaiter().GetResult());
        }
Пример #2
0
        /// <inheritdoc />
        public object Invoke(IVariableProvider variables, params object[] arguments)
        {
            if (!(variables.GetProvider("log")?["log"] is WorkableLogger logger))
            {
                throw new WorkflowException($"Calling a workflow as method requires an existing logger of type '{nameof(WorkableLogger)}' accessible under variable 'log'");
            }

            if (!(arguments.FirstOrDefault() is IDictionary scriptarguments))
            {
                throw new InvalidOperationException($"Parameters for a workflow call need to be a dictionary ('{arguments.FirstOrDefault()?.GetType()}')");
            }

            if (!(scriptarguments is IDictionary <string, object> parameters))
            {
                parameters = new Dictionary <string, object>();
                foreach (object key in scriptarguments.Keys)
                {
                    parameters[key.ToString() ?? string.Empty] = scriptarguments[key];
                }
            }

            return(Task.Run(async() => {
                WorkflowDetails workflow = await LoadWorkflow();
                WorkflowInstance instance = await compiler.BuildWorkflow(workflow);
                return await executor.Execute(instance, logger, parameters, false, CancellationToken.None);
            }).GetAwaiter().GetResult());
        }
 /// <summary>
 /// get provider in chain which contains a variable with the specified name
 /// </summary>
 /// <param name="variable">name of variable to check for</param>
 /// <returns>this if this provider contains this variable, null otherwise</returns>
 public IVariableProvider GetProvider(string variable)
 {
     if (ContainsVariable(variable))
     {
         return(this);
     }
     return(parentprovider?.GetProvider(variable));
 }
Пример #4
0
        /// <inheritdoc />
        public object Execute(IVariableProvider variables = null)
        {
            Dictionary <string, object> dic = new Dictionary <string, object>();

            if (variables != null)
            {
                foreach (string key in variables.Variables)
                {
                    dic[key] = variables.GetProvider(key).GetVariable(key);
                }
            }

            return(Execute(dic));
        }
Пример #5
0
        /// <inheritdoc />
        public object Execute(IVariableProvider variables)
        {
            if (variables == null)
            {
                throw new InvalidOperationException("Javascript execution needs global variables");
            }

            Engine engine = new Engine {
                ClrTypeConverter = new JavascriptTypeConverter()
            };

            WorkableLogger logger = variables.GetProvider("log").GetVariable("log") as WorkableLogger;

            engine.SetValue("load", importservice.Clone(logger));
            engine.SetValue("await", (Func <Task, object>)Helpers.Tasks.AwaitTask);

            foreach (string name in variables.Variables)
            {
                object hostobject = variables[name];
                if (hostobject == null)
                {
                    // v8 doesn't like null host objects
                    continue;
                }
                engine.SetValue(name, hostobject);
            }

            switch (language)
            {
            case ScriptLanguage.JavaScript:
                script ??= new JavaScriptParser(code).ParseScript();
                return(engine.Execute(script).GetCompletionValue().ToObject());

            case ScriptLanguage.TypeScript:
                string transpiled = ReactEnvironment.Current.Babel.Transform($"function main():any{{{code}}}\nvar _result=main();", "unknown.ts");
                script ??= new JavaScriptParser(transpiled).ParseScript();
                engine.Execute(script);
                return(engine.GetValue("_result").ToObject());

            default:
                throw new ArgumentException($"Unsupported language '{language}' as JavaScript");
            }
        }