public static void SetWorkflow(Guid workflowId)
{
List <Guid> roleIds = Utils.GetRolesIds();
WorkflowDetails workflowDetails = new WorkflowDetails
{
IsActive = true,
Activities = new List <IActivity>()
{
new Submit()
{
IsVisible = true, Text = "Submit"
},
new Review()
{
RoleIds = roleIds, Text = "Role", RejectionTarget = RejectionTarget.ReportingOfficer
},
new Notify()
{
EmailMessage = "This is a Updated Test",
Text = "Updated Notify",
RoleIds = roleIds,
UserIds = new List <Guid>(),
NotificationType = NotificationType.Email
}
}
};
var workflowCommandService = DependencyContainer.Resolve <IWorkflowCommandService>();
workflowCommandService.Instance.UpdateWorkflow(workflowId, workflowDetails);
}
/// <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());
}
async Task <WorkflowInstance> GetWorkflowInstance(string name)
{
WorkflowDetails workflow = await workflowservice.GetWorkflow(name);
WorkflowInstance instance = await workflowcompiler.BuildWorkflow(workflow);
return(instance);
}
/// <inheritdoc />
public object Execute(IDictionary <string, object> arguments)
{
return(Task.Run(async() => {
WorkflowDetails workflow = await workflowservice.GetWorkflow(name, revision);
WorkflowInstance instance = await compiler.BuildWorkflow(workflow);
return await executor.Execute(instance, logger, arguments, false, CancellationToken.None);
}).GetAwaiter().GetResult());
}
/// <inheritdoc />
public async Task <WorkflowStructure> ExportWorkflow(long workflowid, int?revision = null)
{
WorkflowDetails workflow = await workflowservice.GetWorkflow(workflowid, revision);
return(new WorkflowStructure {
Name = workflow.Name,
Nodes = workflow.Nodes.Cast <NodeData>().ToArray(),
Transitions = workflow.Transitions.Select(t => Translate(t, workflow.Nodes)).ToArray()
});
}
/// <inheritdoc />
public async Task <WorkflowInstance> BuildWorkflow(WorkflowDetails workflow)
{
WorkflowInstance instance = cacheservice.GetObject <WorkflowInstance, long>(workflow.Id, workflow.Revision);
if (instance != null)
{
return(instance);
}
logger.LogInformation("Rebuilding workflow '{name}'", workflow.Name);
int startcount = workflow.Nodes.Count(n => n.Type == NodeType.Start);
if (startcount == 0)
{
throw new ArgumentException("Workflow has no start node");
}
if (startcount > 1)
{
throw new ArgumentException("Workflow has more than one start node");
}
StartNode startnode = null;
Dictionary <Guid, IInstanceNode> nodes = new Dictionary <Guid, IInstanceNode>();
foreach (NodeDetails node in workflow.Nodes)
{
IInstanceNode nodeinstance = await BuildNode(workflow.Language, node, node.Id);
nodes[node.Id] = nodeinstance;
if (nodeinstance is StartNode startinstance)
{
startnode = startinstance;
}
}
foreach (TransitionData transition in workflow.Transitions)
{
await BuildTransition(workflow, transition.OriginId, transition.TargetId, transition, id => nodes[id]);
}
instance = new WorkflowInstance {
Id = workflow.Id,
Revision = workflow.Revision,
Name = workflow.Name,
Language = workflow.Language,
StartNode = startnode
};
cacheservice.StoreObject(workflow.Id, workflow.Revision, instance);
return(instance);
}
public void MapWorkflowData(WorkflowDetails source)
{
if (source == null)
{
return;
}
StatusId = source.StatusId;
StatusDescription = source.StatusDescription;
StatusRequiredRoles = source.StatusRequiredRoles;
WorkflowStartDate = source.StartDate;
WorkflowEndDate = source.EndDate;
}
async Task <WorkflowDetails> FillWorkflow(WorkflowDetails workflow)
{
workflow.Nodes = (await loadnodes.ExecuteTypesAsync(r => new NodeDetails {
Id = r.GetValue <Guid>(0),
Name = r.GetValue <string>(1),
Group = r.GetValue <string>(2),
Type = r.GetValue <NodeType>(3),
Parameters = r.GetValue <string>(4).Deserialize <IDictionary <string, object> >(),
Variable = r.GetValue <string>(5)
}, workflow.Id)).ToArray();
workflow.Transitions = (await loadtransitions.ExecuteTypesAsync(r => new TransitionData {
OriginId = r.GetValue <Guid>(0),
TargetId = r.GetValue <Guid>(1),
Condition = r.GetValue <string>(2),
Type = r.GetValue <TransitionType>(3),
Log = r.GetValue <string>(4)
}, workflow.Id)).ToArray();
return(workflow);
}
public async Task GetWorkflowByName()
{
IEntityManager database = TestSetup.CreateMemoryDatabase();
IWorkflowService service = new DatabaseWorkflowService(database, new Mock <IArchiveService>().Object);
await service.CreateWorkflow(new WorkflowStructure {
Name = "Test"
});
await service.CreateWorkflow(new WorkflowStructure {
Name = "Plum"
});
await service.CreateWorkflow(new WorkflowStructure {
Name = "Sollbestand"
});
WorkflowDetails workflow = await service.GetWorkflow("Plum");
Assert.NotNull(workflow);
Assert.AreEqual("Plum", workflow.Name);
}
/// <summary>
/// Compiles the activity and adds it to the cache before returning it.
/// </summary>
/// <param name="definition">WorkflowJobDefinition defined to represent a compiled activity.</param>
/// <param name="activityTree">Activity Tree used for external activities</param>
/// <param name="requiredAssemblies"></param>
/// <param name="windowsWorkflow">indicates if the specified xaml is a Windows workflow</param>
/// <param name="rootWorkflowName">Optional, once assigned, only root Workflow will be compiled</param>
/// <returns>Activity compiled from xaml given, or retrieved from cache.
/// Null if not found.</returns>
internal Activity CompileActivityAndSaveInCache(WorkflowJobDefinition definition, Activity activityTree, Dictionary <string, string> requiredAssemblies, out bool windowsWorkflow, string rootWorkflowName = null)
{
WorkflowDetails workflowDetail = new WorkflowDetails();
Activity activity = null;
// initialize windows workflow to false
windowsWorkflow = false;
string resultingCompiledAssemblyPath = definition.DependentAssemblyPath;
string modulePath = definition.ModulePath;
string[] dependentWorkflows = definition.DependentWorkflows.ToArray();
Assembly resultingCompiledAssembly = null;
string resultingCompiledAssemblyName = null;
string xaml = definition.Xaml;
if (activityTree != null)
{
_tracer.WriteMessage(string.Format(CultureInfo.InvariantCulture,
"DefinitionCache: Caching activity for definition with instance ID: {0}. The activity Tree is passed.",
definition.InstanceId));
workflowDetail.ActivityTree = activityTree;
activity = activityTree;
}
else if (!String.IsNullOrEmpty(xaml))
{
// we need to read the xaml from the specified path and compile the same
_tracer.WriteMessage(string.Format(CultureInfo.InvariantCulture,
"DefinitionCache: Caching activity for definition with instance ID: {0}. Xaml is passed",
definition.InstanceId));
workflowDetail.ActivityTree = null;
// check if specified workflow is a windows workflow
if (!string.IsNullOrEmpty(modulePath))
{
string resolvedPath = Environment.ExpandEnvironmentVariables(modulePath);
string resolvedWindowsPath = Environment.ExpandEnvironmentVariables(WindowsPath);
if (resolvedPath.IndexOf(resolvedWindowsPath, StringComparison.CurrentCultureIgnoreCase) != -1)
{
windowsWorkflow = true;
}
}
if (definition.DependentAssemblyPath == null && dependentWorkflows.Length == 0)
{
activity = ImportWorkflowCommand.ConvertXamlToActivity(xaml);
}
else
{
if (rootWorkflowName == null || (definition.Command == rootWorkflowName))
{
activity = ImportWorkflowCommand.ConvertXamlToActivity(xaml, dependentWorkflows,
requiredAssemblies,
ref resultingCompiledAssemblyPath,
ref resultingCompiledAssembly,
ref resultingCompiledAssemblyName);
}
else
{
activity = ImportWorkflowCommand.ConvertXamlToActivity(xaml);
}
}
}
if (activity != null)
{
workflowDetail.IsWindowsActivity = windowsWorkflow;
workflowDetail.CompiledAssemblyPath = resultingCompiledAssemblyPath;
workflowDetail.CompiledAssemblyName = resultingCompiledAssemblyName;
lock (_syncObject)
{
WorkflowJobDefinition definitionToRemove =
_workflowDetailsCache.Keys.FirstOrDefault(item => item.InstanceId == definition.InstanceId);
if (definitionToRemove != null)
{
_workflowDetailsCache.Remove(definition);
}
_workflowDetailsCache.Add(definition, workflowDetail);
}
// If cached activity count reaches _cacheSize,
// Removing the cached activity at index 0 and adding the new activity to the activity cache,
// Old logic was to clear 1000 cached activities and recompiling them again when needed.
//
if (_cachedActivities.Count == _cacheSize)
{
Activity removedActivity;
_cachedActivities.TryRemove(_cachedActivities.Keys.ElementAt <WorkflowJobDefinition>(0), out removedActivity);
}
_cachedActivities.TryAdd(definition, activity);
return(activity);
}
// we should never hit this point under normal course of operations
return(null);
}
static internal WorkflowDetails GetConvertResultToWfDetails(string result)
{
WorkflowDetails workflowDetails = new WorkflowDetails();
var arrayresult = ResultTreatment.ResultToArray(result);
char[] trimChars = new char[] { ' ', '[', ']' };
workflowDetails.Service = IntegrationServiceAdapter.GetConvertedResultIntSerivce(arrayresult);
foreach (var row in arrayresult)
{
if (row.Contains("Folder"))
{
workflowDetails.Folder = ResultTreatment.GetRowValue(row, ":", trimChars);
continue;
}
if (row.Contains("Workflow: "))
{
var baseResult = row.Substring(row.IndexOf('['));
var completeResult = baseResult.Split(']')[0];
workflowDetails.WorkflowName = completeResult.Trim(trimChars);
workflowDetails.Version = ResultTreatment.ResultToInt32(ResultTreatment.GetRowValue(row, "version", trimChars));
continue;
}
if (row.Contains("Workflow run status:"))
{
workflowDetails.RunStatus = ResultTreatment.GetRowValue(row, ":", trimChars);
continue;
}
if (row.Contains("Workflow run error code"))
{
workflowDetails.ErrorCode = ResultTreatment.ResultToInt32(row);
continue;
}
if (row.Contains("Workflow run id"))
{
workflowDetails.WorkflowRunId = ResultTreatment.ResultToInt32(row);
continue;
}
if (row.Contains("Start time:"))
{
workflowDetails.StartTime = ResultTreatment.GetRowValue(row, "Start time:", trimChars);
continue;
}
if (row.Contains("End time:"))
{
workflowDetails.EndTime = ResultTreatment.GetRowValue(row, "End time:", trimChars);
continue;
}
if (row.Contains("Workflow log file"))
{
workflowDetails.LogFile = ResultTreatment.GetRowValue(row, ":", trimChars);
continue;
}
if (row.Contains("Workflow run type"))
{
workflowDetails.RunType = ResultTreatment.GetRowValue(row, ":", trimChars);
continue;
}
if (row.Contains("Run workflow as user"))
{
workflowDetails.RunUser = ResultTreatment.GetRowValue(row, ":", trimChars);
continue;
}
if (row.Contains("Run workflow with "))
{
workflowDetails.OsProfile = ResultTreatment.GetRowValue(row, ":", trimChars);
continue;
}
}
return(workflowDetails);
}
async Task ArchiveWorkflow(Transaction transaction, long workflowid)
{
WorkflowDetails old = await GetWorkflow(workflowid);
await archiveservice.ArchiveObject(transaction, workflowid, old.Revision, old, ArchiveTypes.Workflow);
}
