private JArray SerializeScopes(WorkflowTokenizationContext context, IDictionary <WorkflowExecutionScope, int> scopeIdLookup)
{
var scopeModels = new JArray();
foreach (var scopeEntry in scopeIdLookup)
{
var scope = scopeEntry.Key;
var scopeModel = new JObject();
var lastResultModel = tokenizerInvoker.Tokenize(context, scope.LastResult);
var variableModels = new JArray();
foreach (var variable in scope.Variables)
{
var variableValueModel = tokenizerInvoker.Tokenize(context, variable.Value);
variableModels.Add(new JObject
{
{ "name", variable.Key },
{ "value", variableValueModel }
});
}
scopeModel.Add("id", scopeEntry.Value);
scopeModel.Add("variables", variableModels);
scopeModel.Add("lastResult", lastResultModel);
scopeModels.Add(scopeModel);
}
return(scopeModels);
}
public async Task <JToken> TokenizeWorkflowAsync(Workflow value, CancellationToken cancellationToken)
{
var workflow = value;
var activityTuples = workflow.Activities.Select(x => new { Activity = x, Id = x.Id }).ToList();
var context = new WorkflowTokenizationContext
{
ActivityIdLookup = activityTuples.ToDictionary(x => x.Activity, x => x.Id),
ActivityLookup = activityTuples.ToDictionary(x => x.Id, x => x.Activity),
};
var scopeIdLookup = workflow.Scopes.Select((x, i) => new { Id = i + 1, Scope = x }).ToDictionary(x => x.Scope, x => x.Id);
var token = new JObject
{
{ "metadata", JToken.FromObject(workflow.Metadata, jsonSerializer) },
{ "status", workflow.Status.ToString() },
{ "createdAt", SerializeInstant(workflow.CreatedAt) },
{ "startedAt", SerializeInstant(workflow.StartedAt) },
{ "finishedAt", SerializeInstant(workflow.FinishedAt) },
{ "haltedAt", SerializeInstant(workflow.HaltedAt) },
{ "activities", await SerializeActivitiesAsync(context, cancellationToken) },
{ "connections", SerializeConnections(context, workflow) },
{ "blockingActivities", SerializeBlockingActivities(context, workflow) },
{ "executionLog", SerializeExecutionLog(workflow) },
{ "scopes", SerializeScopes(context, scopeIdLookup) },
{ "currentScope", SerializeCurrentScope(workflow, scopeIdLookup) },
};
return(token);
}
public async Task <Workflow> DetokenizeWorkflowAsync(JToken token, CancellationToken cancellationToken)
{
var activityDictionary = await DeserializeActivitiesAsync(token, cancellationToken);
var serializationContext = new WorkflowTokenizationContext
{
ActivityIdLookup = activityDictionary.ToDictionary(x => x.Value, x => x.Key),
ActivityLookup = activityDictionary,
};
var scopeLookup = DeserializeScopes(token, serializationContext);
var workflow = new Workflow
{
Metadata = token["metadata"].ToObject <WorkflowMetadata>(jsonSerializer),
Status = (WorkflowStatus)Enum.Parse(typeof(WorkflowStatus), token["status"].Value <string>()),
Activities = activityDictionary.Values.ToList(),
Connections = DeserializeConnections(token, activityDictionary).ToList(),
BlockingActivities = DeserializeHaltedActivities(token, activityDictionary).ToList(),
Scopes = new Stack <WorkflowExecutionScope>(scopeLookup.Values)
};
if (!workflow.Scopes.Any())
{
workflow.CurrentScope = new WorkflowExecutionScope();
workflow.Scopes.Push(workflow.CurrentScope);
}
else
{
var currentScopeId = token["currentScope"].Value <int>();
workflow.CurrentScope = scopeLookup[currentScopeId];
}
return(workflow);
}
private JArray SerializeBlockingActivities(WorkflowTokenizationContext context, Workflow workflow)
{
var haltedActivityModels = new JArray();
foreach (var activity in workflow.BlockingActivities)
{
var activityId = context.ActivityIdLookup[activity];
haltedActivityModels.Add(activityId);
}
return(haltedActivityModels);
}
private async Task <JArray> SerializeActivitiesAsync(WorkflowTokenizationContext context, CancellationToken cancellationToken)
{
var activityModels = new JArray();
foreach (var item in context.ActivityIdLookup)
{
var activity = item.Key;
var activityModel = await TokenizeActivityAsync(activity, cancellationToken);
activityModels.Add(activityModel);
}
return(activityModels);
}
private JArray SerializeConnections(WorkflowTokenizationContext context, Workflow workflow)
{
var connectionModels = new JArray();
foreach (var connection in workflow.Connections)
{
var sourceId = context.ActivityIdLookup[connection.Source.Activity];
var targetId = context.ActivityIdLookup[connection.Target.Activity];
connectionModels.Add(JObject.FromObject(new
{
source = new { activityId = sourceId, name = connection.Source.Name },
target = new { activityId = targetId }
}));
}
return(connectionModels);
}
protected override JToken Tokenize(WorkflowTokenizationContext context, object value)
{
return(JToken.FromObject(value, new JsonSerializer {
TypeNameHandling = TypeNameHandling.All
}));
}
protected override object Detokenize(WorkflowTokenizationContext context, JToken value)
{
return(value.ToObject <object>(new JsonSerializer {
TypeNameHandling = TypeNameHandling.All
}));
}
private IDictionary <int, WorkflowExecutionScope> DeserializeScopes(JToken token, WorkflowTokenizationContext context)
{
var scopeLookup = new Dictionary <int, WorkflowExecutionScope>();
var scopeModels = token["scopes"] ?? new JArray();
foreach (var scopeModel in scopeModels)
{
var scope = new WorkflowExecutionScope();
var scopeId = scopeModel["id"].Value <int>();
var variableModels = (JArray)scopeModel["variables"];
var lastResultModel = scopeModel["lastResult"];
var lastResult = tokenizerInvoker.Detokenize(context, lastResultModel);
foreach (var variableModel in variableModels)
{
var variableName = variableModel["name"].Value <string>();
var variableValueModel = variableModel["value"];
var variableValue = tokenizerInvoker.Detokenize(context, variableValueModel);
scope.Variables.Add(variableName, variableValue);
}
scope.LastResult = lastResult;
scopeLookup.Add(scopeId, scope);
}
return(scopeLookup);
}
protected abstract JToken Tokenize(WorkflowTokenizationContext context, T value);
object ITokenizer.Detokenize(WorkflowTokenizationContext context, JToken value) => Detokenize(context, value);
JToken ITokenizer.Tokenize(WorkflowTokenizationContext context, object value) => Tokenize(context, (T)value);
protected abstract T Detokenize(WorkflowTokenizationContext context, JToken value);
public object Detokenize(WorkflowTokenizationContext context, JToken token)
{
var tokenizer = tokenizers.First(x => x.Supports(token));
return(tokenizer.Detokenize(context, token));
}
public JToken Tokenize(WorkflowTokenizationContext context, object value)
{
var tokenizer = tokenizers.FirstOrDefault(x => x.Supports(value));
return(tokenizer?.Tokenize(context, value));
}
