private static Task <PluginOutput <Schema> > ExecutePlugin(IPluginServices pluginServices, PluginData <IdentifyRequestTypeOutput> input)
{
Console.WriteLine(input.Data.Type.ToString());
var data = pluginServices.CreatePluginData <Schema>();
return(pluginServices.PluginCompleted(data));
}
private static Task <PluginOutput <T> > ExecutePlugin(IPluginServices pluginServices, PluginData <StringData> input)
{
var deserialized = JsonConvert.DeserializeObject <T>(input.Data.String);
var output = pluginServices.CreatePluginData(deserialized);
return(pluginServices.PluginCompleted(output));
}
private static async Task <PluginOutput <ExternalDataHandlerTaskOutput> > ExecutePlugin(
IPluginServices pluginServices,
PluginData <ExternalAnswerWorkflowInput> input)
{
var externalService = pluginServices.GetService("ExternalService") as ExternalService;
if (externalService == null)
{
throw new System.Exception("Failed to resolve service");
}
var result = externalService.GetResult(input.Data.Question);
var externalOutput = result == null ? null : pluginServices.CreatePluginData(result);
var externalDataHandlerTask = pluginServices.GetOrCreatePlugin <ExternalDataHandlerTask>();
var externalData = await externalDataHandlerTask.Execute <ExternalDataHandlerTaskOutput>(new PluginInputs { { "input", externalOutput } });
if (externalData != null)
{
var configOverride = pluginServices.GetConfig().Get("ExternalAnswerOverride");
if (!string.IsNullOrEmpty(configOverride))
{
externalData.Data.Answer = configOverride;
}
}
return(await pluginServices.PluginCompleted(externalData));
}
private static async Task <PluginOutput <TResponse> > ExecutePlugin(
IPluginServices pluginServices,
PluginData <JsonExternalWorkflowInput <TRequest> > input)
{
var serializeTask = pluginServices.GetOrCreatePlugin <SerializeJsonTask <TRequest> >();
var serializeTaskInput = pluginServices.CreatePluginData <TRequest>(input.Data.RequestObject);
var serializeOutput = await serializeTask.Execute <StringData>(new PluginInputs { { "input", serializeTaskInput } });
var externalService = pluginServices.GetService("ExternalService") as ExternalService;
if (externalService == null)
{
throw new System.Exception("Failed to resolve service");
}
var result = externalService.GetResult(serializeOutput.Data.String);
if (result == null)
{
return(await pluginServices.PluginIncomplete <TResponse>());
}
var externalOutput = pluginServices.CreatePluginData(result);
var deserializeTask = pluginServices.GetOrCreatePlugin <DeserializeJsonTask <TResponse> >();
var deserializeInput = pluginServices.CreatePluginData(externalOutput.Data.OutputData);
var deserializeOutput = await deserializeTask.Execute <TResponse>(new PluginInputs { { "input", deserializeInput } });
return(await pluginServices.PluginCompleted(deserializeOutput));
}
public ErrorLogger(IPluginServices pluginServices, string logNamePrefix, string logNamePostFix)
{
this._pluginServices = pluginServices;
var logFileName = string.Format("{0}_Errors_{1}.txt", logNamePrefix, logNamePostFix);
this._currentPath = Path.Combine(WrapperUtilities.LogDirectory, logFileName);
}
private static Task <PluginOutput <CancellableTaskOutput> > ExecutePlugin(IPluginServices pluginServices, PluginData <CancellationWorkflowInput> input)
{
var data = pluginServices.CreatePluginData <CancellableTaskOutput>();
data.Data.Cancelled = pluginServices.PluginCancelled();
return(pluginServices.PluginCompleted(data));
}
private static Task <PluginOutput <StringData> > ExecutePlugin(IPluginServices pluginServices, PluginData <T> input)
{
var output = pluginServices.CreatePluginData <StringData>();
output.Data.String = JsonConvert.SerializeObject(input.Data);
return(pluginServices.PluginCompleted(output));
}
private Task <PluginOutput <StatefulWorkflowState> > ExecutePlugin(IPluginServices pluginServices, PluginData <AInput> input)
{
if (_currentValue == null)
{
_currentValue = pluginServices.CreatePluginData <StatefulWorkflowState>();
}
return(++_currentValue.Data.CurrentValue == 3 ? pluginServices.PluginCompleted(_currentValue) : pluginServices.PluginIncomplete <StatefulWorkflowState>());
}
private static Task <PluginOutput <ExternalDataHandlerTaskOutput> > ExecutePlugin(
IPluginServices pluginServices,
PluginData <ExternalTaskOutput <StringData> > input)
{
var output = pluginServices.CreatePluginData <ExternalDataHandlerTaskOutput>();
output.Data.Answer = input.Data.OutputData.String;
return(pluginServices.PluginCompleted(output));
}
private static async Task <PluginOutput <AOutput> > ExecutePlugin(IPluginServices pluginServices, PluginData <AInput> input)
{
var aTask = pluginServices.GetOrCreatePlugin <SuccessfulTaskWithComment>();
var aOutput = await aTask.Execute <AOutput>(new PluginInputs { { "input", input } });
var bTask = pluginServices.GetOrCreatePlugin <FailingTaskWithComment>();
var bOutput = await bTask.Execute <AOutput>(new PluginInputs { { "input", input } });
return(await pluginServices.PluginCompleted(bOutput));
}
private static async Task <PluginOutput <FOutput> > ExecutePlugin(IPluginServices pluginServices, PluginData <AInput> input)
{
var aTask = pluginServices.GetOrCreatePlugin <ATask>();
var aOutput = await aTask.Execute <AOutput>(new PluginInputs { { "input", input } });
var fTask = pluginServices.GetOrCreatePlugin <FTask>();
var fOutput = await fTask.Execute <FOutput>(new PluginInputs { { "aOutput", aOutput }, { "bOutput", null } });
return(await pluginServices.PluginCompleted(fOutput));
}
public WrapperDebugWriter(IPluginServices pluginServices, string logNamePrefix, string logNamePostFix, string messagePrefix)
{
var logFileName = string.Format("{0}_Debug_{1}.txt", logNamePrefix, logNamePostFix);
this._currentPath = Path.Combine(WrapperUtilities.LogDirectory, logFileName);
this._messagePrefix = messagePrefix;
this._pluginServices = pluginServices;
this.LogLine("============================================================================");
this.LogLine(DateTime.Now.ToString());
this.LogLine("============================================================================");
}
private static async Task <PluginOutput <DOutput> > ExecutePlugin(IPluginServices pluginServices, PluginData <AInput> input)
{
var aTask = pluginServices.GetOrCreatePlugin <ATask>();
var aOutput = await aTask.Execute <AOutput>(new PluginInputs { { "input", input } });
var bTask = pluginServices.GetOrCreatePlugin <BTask>();
var bOutput = await bTask.Execute <BOutput>(new PluginInputs { { "input", aOutput } });
var dTask = pluginServices.GetOrCreatePlugin <DTask>();
var dOutput = await dTask.Execute <DOutput>(new PluginInputs { { "aOutput", aOutput }, { "bOutput", bOutput } });
return(await pluginServices.PluginCompleted(dOutput));
}
private static async Task <PluginOutput <COutput> > ExecutePlugin(IPluginServices pluginServices, PluginData <AInput> input)
{
var aTask = pluginServices.GetOrCreatePlugin <ATask>();
var aOutput = await aTask.Execute <AOutput>(new PluginInputs { { "input", input } });
var cTask = pluginServices.GetOrCreatePlugin <CTask>();
var cOutput = await cTask.Execute <COutput>(new PluginInputs { { "input", null } });
var bTask = pluginServices.GetOrCreatePlugin <BTask>();
var bOutput = await bTask.Execute <BOutput>(new PluginInputs { { "input", aOutput } });
return(cOutput != null ?
await pluginServices.PluginCompleted(cOutput) :
await pluginServices.PluginIncomplete <COutput>());
}
private static async Task <PluginOutput <ExternalDataHandlerTaskOutput> > ExecutePlugin(
IPluginServices pluginServices,
[Version(1, 5)] PluginData <ExternalAnswerWorkflowInput> input)
{
var externalService = pluginServices.GetService("ExternalService") as ExternalService;
if (externalService == null)
{
throw new System.Exception("Failed to resolve service");
}
var result = externalService.GetResult(input.Data.Question);
var externalOutput = result == null ? null : pluginServices.CreatePluginData(result);
var externalDataHandlerTask = pluginServices.GetOrCreatePlugin <ExternalDataHandlerTask>();
var externalData = await externalDataHandlerTask.Execute <ExternalDataHandlerTaskOutput>(new PluginInputs { { "input", externalOutput } });
return(await pluginServices.PluginCompleted(externalData));
}
private static async Task <PluginOutput <EOutput> > ExecutePlugin(IPluginServices pluginServices, PluginData <AInput> input)
{
var aTasks = pluginServices.GetOrCreatePlugins <ATask>(2);
var eTaskInput = pluginServices.CreatePluginDataList <AOutput>();
foreach (var aTask in aTasks)
{
var aTaskOutput = await aTask.Execute <AOutput>(new PluginInputs { { "input", input } });
eTaskInput.Add(aTaskOutput.Data);
}
var eTask = pluginServices.GetOrCreatePlugin <ETask>();
var eOutput = await eTask.Execute <EOutput>(new PluginInputs { { "aOutputs", eTaskInput } });
return(await pluginServices.PluginCompleted(eOutput));
}
public WrapperDebugWriter(IPluginServices pluginServices, string logNamePrefix, string messagePrefix)
: this(pluginServices, logNamePrefix, pluginServices.CoreManager.CharacterFilter.Name, messagePrefix)
{
}
public WorkflowContainer(IPluginServices pluginServices)
{
_pluginServices = pluginServices;
}
private static Task <PluginOutput <AOutput> > ExecutePlugin(IPluginServices pluginServices, PluginData <AInput> input)
{
var data = pluginServices.CreatePluginData <AOutput>();
return(pluginServices.PluginCompleted(data));
}
private static async Task <PluginOutput <CancellableTaskOutput> > ExecutePlugin(IPluginServices pluginServices, PluginData <CancellationWorkflowInput> input)
{
var cancellableTask = pluginServices.GetOrCreatePlugin <CancellableTask>();
if (input.Data.CancelExecution)
{
pluginServices.Cancel();
}
if (input.Data.CancelPlugin)
{
cancellableTask.Cancel();
}
var cancellableTaskOutput = await cancellableTask.Execute <CancellableTaskOutput>(new PluginInputs { { "input", input } });
return(await pluginServices.PluginCompleted(cancellableTaskOutput));
}
private static async Task <PluginOutput <IdentifyRequestTypeOutput> > ExecutePlugin(IPluginServices pluginServices, PluginData <IdentifyRequestTypeInput> input)
{
// First Plugin "Identify Request Type Task"
var identifyTask = pluginServices.GetOrCreatePlugin <IdentifyRequestTypeTask>();
var identifyTaskOutput = await identifyTask.Execute <IdentifyRequestTypeOutput>(new PluginInputs { { "input", input } });
// Second Plugin "Print Request Type to Console"
var printTask = pluginServices.GetOrCreatePlugin <PrintToConsoleTask>();
await printTask.Execute <Schema>(new PluginInputs { { "input", identifyTaskOutput } });
return(await pluginServices.PluginCompleted(identifyTaskOutput));
}
private static Task <PluginOutput <FOutput> > ExecutePlugin(IPluginServices pluginServices, PluginData <AOutput> aOutput, [Optional] PluginData <BOutput> bOutput)
{
var data = pluginServices.CreatePluginData <FOutput>();
return(pluginServices.PluginCompleted(data));
}
public ChatWriter(IPluginServices pluginServices, string messagePrefix)
: base(pluginServices, messagePrefix)
{
}
public DebugWriter(IPluginServices pluginServices, string logNamePrefix, string messagePrefix)
: base(pluginServices, logNamePrefix, messagePrefix)
{
}
private static Task <PluginOutput <IdentifyRequestTypeOutput> > ExecutePlugin(IPluginServices pluginServices, PluginData <IdentifyRequestTypeInput> input)
{
var data = pluginServices.CreatePluginData <IdentifyRequestTypeOutput>();
data.Data.Type = input != null && input.Data.Email.Contains("prefer")
? RequestType.Voting
: RequestType.Unknown;
return(pluginServices.PluginCompleted(data));
}
public ErrorLogger(IPluginServices pluginServices, string logNamePrefix)
: this(pluginServices, logNamePrefix, pluginServices.CoreManager.CharacterFilter.Name)
{
}
public WrapperChatWriter(IPluginServices pluginServices, string messagePrefix)
{
this._pluginServices = pluginServices;
this._messagePrefix = messagePrefix;
}
public void SetPluginServices(IPluginServices pluginServices)
{
PluginServices = pluginServices;
}
