/// <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());
}
/// <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));
}
/// <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));
}
/// <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");
}
}
