public async Task Run(Database dc, Workflow wf, ActivityInWorkflow activity, ActivityInWorkflow preActivity)
{
var template = activity.GetOptionValue("Template");
if (engine == null)
{
engine = new RazorLightEngineBuilder()
.UseFilesystemProject(AppDomain.CurrentDomain.GetData("ContentRootPath").ToString() + "\\App_Data")
.UseMemoryCachingProvider()
.Build();
}
var model = CleanJObject(activity);
string result = "";
var cacheResult = engine.TemplateCache.RetrieveTemplate(template);
if (cacheResult.Success)
{
result = await engine.RenderTemplateAsync(cacheResult.Template.TemplatePageFactory(), model);
}
else
{
result = await engine.CompileRenderAsync(template, model);
}
activity.Output.Data = JObject.Parse(result);
}
public async Task Run(Database dc, Workflow wf, ActivityInWorkflow activity, ActivityInWorkflow preActivity)
{
var configuration = (IConfiguration)AppDomain.CurrentDomain.GetData("Configuration");
EmailRequestModel model = new EmailRequestModel();
model.Subject = activity.GetOptionValue("Subject");
model.ToAddresses = activity.GetOptionValue("ToAddresses");
model.Body = activity.GetOptionValue("Body");
model.Template = activity.GetOptionValue("Template");
model.Bcc = activity.GetOptionValue("Bcc");
model.Cc = activity.GetOptionValue("Cc");
if (!String.IsNullOrEmpty(model.Template))
{
var engine = new RazorLightEngineBuilder()
.UseFilesystemProject(AppDomain.CurrentDomain.GetData("ContentRootPath").ToString() + "\\App_Data")
.UseMemoryCachingProvider()
.Build();
model.Body = await engine.CompileRenderAsync(model.Template, activity.Input.Data);
}
var ses = new SesEmailConfig
{
VerifiedEmail = configuration.GetSection("AWS:SESVerifiedEmail").Value,
AWSSecretKey = configuration.GetSection("AWS:AWSSecretKey").Value,
AWSAccessKey = configuration.GetSection("AWS:AWSAccessKey").Value
};
activity.Output.Data = await Send(model, ses);
}
public async Task Run(Database dc, Workflow wf, ActivityInWorkflow activity, ActivityInWorkflow preActivity)
{
// find a first TURE statement
bool decision = false;
for (int i = 0; i < activity.Options.Count; i++)
{
var option = activity.Options[i];
var cc = new CompiledExpression()
{
StringToParse = option.Value
};
object input = JObject.FromObject(activity.Input.Data).ToObject <ExpandoObject>();
cc.RegisterType("Input", input);
cc.RegisterDefaultTypes();
decision = (bool)cc.Eval();
if (decision)
{
activity.NextActivityId = option.Key;
activity.Output = activity.Input;
break;
}
}
}
public Task Run(Database dc, Workflow wf, ActivityInWorkflow activity, ActivityInWorkflow preActivity)
{
var bundle = dc.Table <Bundle>().Include(x => x.Fields).FirstOrDefault(x => x.Id == activity.GetOptionValue("bundleId"));
var entity = bundle.AddRecord(dc, JObject.FromObject(activity.Input.Data));
activity.Output.Data = entity.ToBusinessObject(dc, bundle.EntityName);
return(Task.CompletedTask);
}
public async Task Run(Database dc, Workflow wf, ActivityInWorkflow activity, ActivityInWorkflow preActivity)
{
string baseUrl = activity.GetOptionValue("baseUrl");
string resource = activity.GetOptionValue("resource");
string method = activity.GetOptionValue("method")?.ToUpper() ?? "GET";
string querys = activity.GetOptionValue("query");
string json = JsonConvert.SerializeObject(activity.Input.Data);
var request = new RestRequest(resource);
var jObject = JObject.FromObject(activity.Input.Data);
// add url segment
resource.Split('/').ToList().ForEach(seg =>
{
if (!String.IsNullOrEmpty(seg) && seg.StartsWith("{"))
{
string name = seg.Substring(1, seg.Length - 2);
request.AddUrlSegment(name, jObject[name]);
}
});
// add query parameter
querys.Split('&').ToList().ForEach(seg =>
{
var query = seg.Split('=');
if (query.Length == 2)
{
if (query[1].StartsWith("{"))
{
string name = query[1].Substring(1, query[1].Length - 2);
request.AddQueryParameter(query[0], jObject[name].ToString());
}
else
{
request.AddQueryParameter(query[0], query[1]);
}
}
});
request.AddParameter("application/json; charset=utf-8", json, ParameterType.RequestBody);
request.RequestFormat = DataFormat.Json;
request.Method = (Method)Enum.Parse(typeof(Method), method);
var client = new RestClient(baseUrl);
IRestResponse response = client.Execute(request);
activity.Output.ErrorMessage = response.ErrorMessage;
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
activity.Output.Data = JsonConvert.DeserializeObject(response.Content);
}
else
{
activity.Output.ErrorMessage = activity.Output.ErrorMessage ?? response.StatusDescription;
}
}
public static string GetOptionValue(this ActivityInWorkflow activity, string key)
{
String text = activity.Options.Find(x => x.Key.Equals(key, StringComparison.CurrentCultureIgnoreCase))?.Value;
if (!String.IsNullOrEmpty(text))
{
text = Tokener.Replace(activity.Input.Data, text);
}
return(text);
}
public Task Run(Database dc, Workflow wf, ActivityInWorkflow activity, ActivityInWorkflow preActivity)
{
string startActivityId = activity.GetOptionValue("startActivityId");
string endActivityId = activity.GetOptionValue("endActivityId");
// reset input
activity.Input = activity.OriginInput;
// track output
if (!OutputData.ContainsKey(activity.Id))
{
OutputData[activity.Id] = new List <Object>();
}
if (activity.Flag > 0)
{
OutputData[activity.Id].Add(preActivity.Output.Data);
}
if (activity.Input.Data.GetType() == typeof(JArray))
{
var list = (activity.Input.Data as JArray).ToList();
// loop item
if (activity.Flag < list.Count)
{
Console.WriteLine($"loop index: {activity.Flag}");
wf.Activities.Find(x => x.Id == endActivityId).NextActivityId = activity.Id;
activity.NextActivityId = startActivityId;
activity.Output.Data = list[activity.Flag];
activity.Flag++;
}
// return to main flow
else
{
Console.WriteLine($"looped total {activity.Flag}");
activity.Flag = 0;
activity.NextActivityId = activity.OriginNextActivityId;
activity.Output.Data = OutputData[activity.Id];
OutputData.Remove(activity.Id);
}
}
return(Task.CompletedTask);
}
public async Task Run(Database dc, Workflow wf, ActivityInWorkflow activity, ActivityInWorkflow preActivity)
{
string json = "{" + activity.GetOptionValue("values") + "}";
var values = JObject.Parse(json);
var dic = JObject.FromObject(activity.Input.Data).ToDictionary();
dic.ToList().ForEach(p => values[p.Key] = JToken.FromObject(p.Value));
var paramters = new List <Object>();
var createIfNotExists = bool.Parse(activity.GetOptionValue("createIfNotExists") ?? "false");
var patch = new DbPatchModel
{
Table = activity.GetOptionValue("table"),
Where = activity.GetOptionValue("where"),
Values = dic
};
var tableType = TypeHelper.GetType(patch.Table, (string[])AppDomain.CurrentDomain.GetData("Assemblies"));
JObject.FromObject(activity.Input.Data).Properties()
.ToList()
.ForEach(d =>
{
if (patch.Where.Contains("{" + d.Name + "}"))
{
patch.Where = patch.Where.Replace("{" + d.Name + "}", "@" + paramters.Count());
var propertType = tableType.GetProperty(d.Name).PropertyType;
paramters.Add(d.Value.ToObject(propertType));
}
});
patch.Params = paramters.ToArray();
// check if exists
if (dc.Table(patch.Table).Any(patch.Where, patch.Params))
{
dc.Patch <IDbRecord>(patch);
}
else
{
dc.Add(values.ToObject(tableType));
}
activity.Output = activity.Input;
}
private JObject CleanJObject(ActivityInWorkflow activity)
{
// convert illegal variable name
var jObject = JObject.FromObject(activity.Input.Data);
jObject.Properties().ToList().ForEach(p => {
char letter = p.Name[0];
int i = letter - '0';
if (i >= 0 && i <= 9)
{
jObject.Add('n' + p.Name, p.Value);
jObject.Remove(p.Name);
}
});
return(jObject);
}
public async Task Run(Database dc, Workflow wf, ActivityInWorkflow activity, ActivityInWorkflow preActivity)
{
activity.Output.Data = activity.Input.Data;
Console.WriteLine(activity.GetOptionValue("text"));
Console.WriteLine(JsonConvert.SerializeObject(activity.Output.Data));
}
public async Task <ActivityResult> Run <TInput>(Database dc, TInput input)
{
Stopwatch watch = new Stopwatch();
watch.Start();
var workflow = dc.Table <Workflow>()
.Include(x => x.Activities).ThenInclude(x => x.Options)
.FirstOrDefault(x => x.Id == WorkflowId);
if (workflow == null)
{
Console.WriteLine($"Can't find workflow {WorkflowId}");
return(null);
}
Console.WriteLine("");
Console.WriteLine("");
var style = new Colorful.StyleSheet(Color.White);
style.AddStyle(TransactionId, Color.Green);
Console.WriteLineStyled($"------ {workflow.Name.ToUpper()}, TRACEID: {TransactionId} ------", style);
Console.WriteLine($"{workflow.Description}");
Console.WriteLine("");
ConstructActivityLinkedlist(workflow);
var types = TypeHelper.GetClassesWithInterface <IWorkflowActivity>((string[])AppDomain.CurrentDomain.GetData("Assemblies"));
ActivityInWorkflow preActivity = null;
ActivityInWorkflow activity = workflow.Activities.First();
activity.Input = new ActivityResult {
Data = input
};
int step = 0;
while (activity != null)
{
step++;
Console.WriteLine("");
style = new Colorful.StyleSheet(Color.White);
style.AddStyle($"STEP {step}", Color.Green);
Console.WriteLineStyled($"--- STEP {step}: {activity.ActivityName} ---", style);
Console.WriteLine($"{String.Join("", activity?.Options)}");
DateTime start = DateTime.Now;
var type = types.FirstOrDefault(x => x.Name.Equals(activity.ActivityName, StringComparison.CurrentCultureIgnoreCase));
if (type == null)
{
Console.WriteLine($"Can't find activity: {activity.ActivityName}");
}
var instance = (IWorkflowActivity)Activator.CreateInstance(type);
activity.Output = new ActivityResult();
// Keep original NextActivityId
if (String.IsNullOrEmpty(activity.OriginNextActivityId))
{
activity.OriginNextActivityId = activity.NextActivityId;
}
try
{
instance.SignalHub = SignalHub;
await instance.Run(dc, workflow, activity, preActivity);
}
catch (Exception ex)
{
if (String.IsNullOrEmpty(activity.Output.ErrorMessage))
{
activity.Output.ErrorMessage = ex.Message;
}
}
// Halt workflow
if (!String.IsNullOrEmpty(activity.Output.ErrorMessage))
{
activity.NextActivityId = "";
Console.WriteLine($"{activity.Output.ErrorMessage}");
throw new Exception($"{activity.Output.ErrorMessage}");
}
Console.WriteLine("");
Console.WriteLine($"{activity.ActivityName} spent {(DateTime.Now - start).TotalMilliseconds}ms");
if (Verbose)
{
Console.WriteLine($"{JsonConvert.SerializeObject(activity.Output.Data)}");
}
preActivity = activity;
activity = workflow.Activities.FirstOrDefault(x => x.Id == activity.NextActivityId);
if (activity != null)
{
activity.Input = preActivity.Output;
// keep original input
if (activity.OriginInput == null)
{
activity.OriginInput = activity.Input;
}
}
}
watch.Stop();
Console.WriteLine($"------ {workflow.Name.ToUpper()} Completed in {watch.ElapsedMilliseconds} ms ------");
return(preActivity?.Output);
}
public async Task Run(Database dc, Workflow wf, ActivityInWorkflow activity, ActivityInWorkflow preActivity)
{
await SignalHub.All.SendCoreAsync("ReceiveMessage", new object[] { preActivity.Output.Data });
}
