private async Task <Guid?> CreateWorkflowIfNotExists(Document document)
{
if (!string.IsNullOrEmpty(document.Scheme) && document.ProcessId == null)
{
Guid processId = Guid.NewGuid();
var createInstanceParams = new CreateInstanceParams(document.Scheme, processId)
{
InitialProcessParameters = new Dictionary <string, object>()
{
{ "objectId", document.Id },
{ "objectType", "Document" }
},
};
await WorkflowManager.Runtime.CreateInstanceAsync(createInstanceParams);
var pi = await WorkflowManager.Runtime.GetProcessInstanceAndFillProcessParametersAsync(processId);
foreach (var param in createInstanceParams.InitialProcessParameters)
{
pi.SetParameter(param.Key, param.Value, ParameterPurpose.Persistence);
}
WorkflowManager.Runtime.PersistenceProvider.SavePersistenceParameters(pi);
return(processId);
}
return(null);
}
public Guid StartFlow(string SchemeCode)
{
Guid guid = Guid.NewGuid();
var createInstanceParameters = new CreateInstanceParams(SchemeCode, guid);
//.AddPersistentParameter("StringParameter", "Some String")
//.AddPersistentParameter("ObjectParameter", "1");
workflowModel.Runtime.CreateInstance(createInstanceParameters);
return(guid);
}
protected async Task CreateWorkflowProcessInstance(Product product, WorkflowDefinition workflowDefinition)
{
var parms = new CreateInstanceParams(workflowDefinition.WorkflowScheme, product.Id)
{
IdentityId = product.Project.Owner.WorkflowUserId.Value.ToString()
};
SetProcessProperties(parms, product.ProductDefinition, workflowDefinition);
await WorkflowInit.Runtime.CreateInstanceAsync(parms);
BackgroundJobClient.Enqueue <WorkflowProjectService>(service => service.UpdateProjectActive(product.ProjectId));
}
private void SetProcessProperties(CreateInstanceParams parms, ProductDefinition productDefinition, WorkflowDefinition workflowDefinition)
{
var workflowProperties = DeserializePropertiers(workflowDefinition.Properties);
var productProperties = DeserializePropertiers(productDefinition.Properties);
var properties = JsonUtils.MergeProperties(productProperties, workflowProperties);
// ProcessParameters are Dictionary<string,object>
// The values are expected to be strings (our decision, not a DWKit limitation)
// The result of the deserialize is a Newtonsoft.Json.Linq.JObject and I didn't want to specify that as the datatype in DWKit
// This converts the value back into JSON
var parameters = properties.ToDictionary(kv => kv.Key, kv => (object)kv.Value.ToString());
parms.InitialProcessParameters = parameters;
}
public async Task <ActionResult> ExecuteCommand(string name, string id, string command, string data)
{
try
{
var processId = GetProcessIdFromString(id, name);
var userId = GetUserId();
if (!await WorkflowInit.Runtime.IsProcessExistsAsync(processId))
{
var wfCommand = (await GetInitialCommands(name, userId)).FirstOrDefault(c => c.Value.Equals(command));
if (wfCommand == null)
{
return(Json(new FailResponse("Command not found.")));
}
var createParams = new CreateInstanceParams(wfCommand.Scheme, processId)
{
IdentityId = DWKitRuntime.Security.CurrentUser?.Id.ToString(),
ImpersonatedIdentityId = userId.ToString()
};
createParams.AddPersistentParameter("ObjectId", id)
.AddPersistentParameter("InitialForm", name);
await WorkflowInit.Runtime.CreateInstanceAsync(createParams);
}
var commandObject = (await WorkflowInit.Runtime.GetAvailableCommandsAsync(processId, userId.ToString())).FirstOrDefault(c => c.CommandName.Equals(command));
if (commandObject == null)
{
return(Json(new FailResponse("Command not found.")));
}
var instance = await WorkflowInit.Runtime.GetProcessInstanceAndFillProcessParametersAsync(processId);
var scheme = WorkflowInit.Runtime.Builder.GetProcessScheme(instance.SchemeCode);
if (!string.IsNullOrWhiteSpace(data))
{
var json = JObject.Parse(data);
foreach (var t in json.Properties())
{
if (t.Name == "__id")
{
continue;
}
var parameter = scheme.Parameters.FirstOrDefault(p => p.Name == t.Name);
if (parameter != null)
{
commandObject.SetParameter(t.Name, t.ToObject(parameter.Type));
}
else
{
commandObject.SetParameter(t.Name, t.Value.ToObject <object>());
}
}
}
await WorkflowInit.Runtime.ExecuteCommandAsync(commandObject, DWKitRuntime.Security.CurrentUser?.Id.ToString(), userId.ToString());
return(Json(new SuccessResponse()));
}
catch (Exception e)
{
return(Json(new FailResponse(e)));
}
}
public async Task <Response> WorkflowApiProcessing(RequestContext ctx)
{
object data = string.Empty;
string error = string.Empty;
try
{
string operation = ctx.Request.HttpParams.QueryString["operation"];
if (string.IsNullOrWhiteSpace(operation))
{
throw new Exception("Parameter 'operation' is required!");
}
Guid processid;
if (!Guid.TryParse(ctx.Request.HttpParams.QueryString["processid"], out processid))
{
throw new Exception("Parameter 'processid' is required and must be is GUID!");
}
var identityid = ctx.Request.HttpParams.QueryString["identityid"];
var impersonatedIdentityId = ctx.Request.HttpParams.QueryString["impersonatedIdentityId"];
var value = ctx.Request.HttpParams.QueryString["parameters"];
var parameters = !string.IsNullOrWhiteSpace(value) ? JsonConvert.DeserializeObject <Dictionary <string, object> >(value) : null;
CultureInfo culture = CultureInfo.CurrentUICulture;
if (!string.IsNullOrWhiteSpace(ctx.Request.HttpParams.QueryString["culture"]))
{
culture = new CultureInfo(ctx.Request.HttpParams.QueryString["culture"]);
}
switch (operation.ToLower())
{
case "createinstance":
var schemacode = ctx.Request.HttpParams.QueryString["schemacode"];
if (string.IsNullOrWhiteSpace(schemacode))
{
throw new Exception("Parameter 'schemacode' is required!");
}
if (parameters == null)
{
parameters = new Dictionary <string, object>();
}
var initialPrameters = await GetInitialProcessParameters(ctx, schemacode);
var createInstanceParams = new CreateInstanceParams(schemacode, processid)
{
IdentityId = identityid,
ImpersonatedIdentityId = impersonatedIdentityId,
InitialProcessParameters = initialPrameters,
SchemeCreationParameters = parameters
};
await _runtime.CreateInstanceAsync(createInstanceParams);
break;
case "getavailablecommands":
var availableCommands = await _runtime.GetAvailableCommandsAsync(processid, new List <string>() { identityid }, null, impersonatedIdentityId);
data = JsonConvert.SerializeObject(availableCommands);
break;
case "executecommand":
var command = ctx.Request.HttpParams.QueryString["command"];
var wfcommands = await _runtime.GetAvailableCommandsAsync(processid, new List <string>() { identityid }, command, impersonatedIdentityId);
var wfcommand = wfcommands.FirstOrDefault();
if (wfcommand == null)
{
throw new Exception(string.Format("Command {0} is not found", command));
}
FillCommandParameters(ctx, wfcommand);
await _runtime.ExecuteCommandAsync(wfcommand, identityid, impersonatedIdentityId);
break;
case "getavailablestatetoset":
var availableStateToSet = await _runtime.GetAvailableStateToSetAsync(processid, culture);
data = JsonConvert.SerializeObject(availableStateToSet);
break;
case "setstate":
var state = ctx.Request.HttpParams.QueryString["state"];
if (parameters == null)
{
parameters = new Dictionary <string, object>();
}
await _runtime.SetStateAsync(processid, identityid, impersonatedIdentityId, state, parameters);
break;
case "isexistprocess":
var isProcessExists = await _runtime.IsProcessExistsAsync(processid);
data = JsonConvert.SerializeObject(isProcessExists);
break;
default:
throw new Exception(string.Format("operation={0} is not suported!", operation));
}
}
catch (Exception ex)
{
error = string.Format("{0}{1}",
ex.Message, ex.InnerException == null
? string.Empty
: string.Format(". InnerException: {0}", ex.InnerException.Message));
}
var res = JsonConvert.SerializeObject(new
{
data = data,
success = error.Length == 0,
error = error
});
return(new StringResponse(res));
}
public async Task <ActionResult> ExecuteCommand(string name, string id, string command, string data, string schemeName)
{
try
{
if (!DWKitRuntime.Security.CheckAnonymousFormAccess(name))
{
return(new JsonResult(new FailResponse("Access denied!"))
{
StatusCode = 401
});
}
var processId = GetProcessIdFromString(id, name, schemeName);
var userId = GetUserId();
var culture = DWKitRuntime.Security.CurrentUser?.GetCulture() ?? CultureInfo.CurrentCulture;
if (!await WorkflowInit.Runtime.IsProcessExistsAsync(processId))
{
var wfCommand = (await GetInitialCommands(name, userId, culture, schemeName)).FirstOrDefault(c => c.Value.Equals(command));
if (wfCommand == null)
{
return(Json(new FailResponse("Command not found.")));
}
var createParams = new CreateInstanceParams(wfCommand.Scheme, processId)
{
IdentityId = DWKitRuntime.Security.CurrentUser?.Id.ToString(),
ImpersonatedIdentityId = userId.ToString()
};
createParams.AddPersistentParameter("ObjectId", processId.ToString())
.AddPersistentParameter("InitialForm", name);
await WorkflowInit.Runtime.CreateInstanceAsync(createParams);
}
var commandObject = (await WorkflowInit.Runtime.GetAvailableCommandsAsync(processId, userId.ToString(), culture)).FirstOrDefault(c => c.CommandName.Equals(command));
if (commandObject == null)
{
return(Json(new FailResponse("Command not found.")));
}
var instance = await WorkflowInit.Runtime.GetProcessInstanceAndFillProcessParametersAsync(processId);
var scheme = await WorkflowInit.Runtime.Builder.GetProcessSchemeAsync(instance.SchemeCode).ConfigureAwait(false);
if (!string.IsNullOrWhiteSpace(data))
{
var json = JObject.Parse(data);
foreach (var t in json.Properties())
{
if (t.Name == "__id")
{
continue;
}
var parameter = scheme.Parameters.FirstOrDefault(p => p.Name == t.Name);
if (parameter != null)
{
commandObject.SetParameter(t.Name, t.ToObject(parameter.Type));
}
else
{
commandObject.SetParameter(t.Name, t.Value.ToObject <object>());
}
}
}
var executionResult = await WorkflowInit.Runtime.ExecuteCommandAsync(commandObject, DWKitRuntime.Security.CurrentUser?.Id.ToString(), userId.ToString());
var res = new
{
EntityId = executionResult.ProcessInstance.ProcessId,
Entity = executionResult.ProcessInstance.ProcessParameters
.ToDictionary(c => c.Name,
v => v.Value)
};
return(Json(new ItemSuccessResponse <object>(res)));
}
catch (Exception e)
{
return(Json(new FailResponse(e)));
}
}
