protected override string BuildId()
{
return(CaseEltInstance.BuildId(CasePlanInstanceId, EltId, Version));
}
protected abstract Task <bool> Process(CMMNExecutionContext executionContext, CaseEltInstance elt, CancellationToken cancellationToken);
protected override Task ProtectedProcess(CMMNExecutionContext executionContext, CaseEltInstance elt, CancellationToken cancellationToken)
{
executionContext.Instance.MakeTransition(elt, CMMNTransitions.Occur);
return(Task.CompletedTask);
}
protected override async Task <bool> Process(CMMNExecutionContext executionContext, CaseEltInstance elt, CancellationToken cancellationToken)
{
Subscription sub = null;
var terminate = await TrySubscribe(executionContext, elt, CMMNConstants.ExternalTransitionNames.Terminate, cancellationToken);
var manualStart = await TrySubscribe(executionContext, elt, CMMNConstants.ExternalTransitionNames.ManualStart, cancellationToken);
var disable = await TrySubscribe(executionContext, elt, CMMNConstants.ExternalTransitionNames.Disable, cancellationToken);
var reenable = await TrySubscribe(executionContext, elt, CMMNConstants.ExternalTransitionNames.Reenable, cancellationToken);
if (elt.TakeStageState == null)
{
executionContext.Instance.MakeTransition(elt, CMMNTransitions.Create);
}
if (elt.TakeStageState == TaskStageStates.Available)
{
if (elt.ManualActivationRule != null && elt.IsManualActivationRuleSatisfied(executionContext.Instance.ExecutionContext))
{
executionContext.Instance.MakeTransition(elt, CMMNTransitions.Enable);
return(false);
}
executionContext.Instance.MakeTransition(elt, CMMNTransitions.Start);
}
if (elt.TakeStageState == TaskStageStates.Enabled)
{
if (disable.IsCaptured)
{
sub = await TryReset(executionContext, elt, CMMNConstants.ExternalTransitionNames.Disable, cancellationToken);
executionContext.Instance.MakeTransition(elt, CMMNTransitions.Disable, incomingTokens: MergeParameters(executionContext, sub.Parameters));
return(false);
}
if (!manualStart.IsCaptured)
{
return(false);
}
sub = await TryReset(executionContext, elt, CMMNConstants.ExternalTransitionNames.ManualStart, cancellationToken);
executionContext.Instance.MakeTransition(elt, CMMNTransitions.ManualStart, incomingTokens: MergeParameters(executionContext, sub.Parameters));
}
if (elt.TakeStageState == TaskStageStates.Disabled)
{
if (reenable.IsCaptured)
{
sub = await TryReset(executionContext, elt, CMMNConstants.ExternalTransitionNames.Reenable, cancellationToken);
executionContext.Instance.MakeTransition(elt, CMMNTransitions.Reenable, incomingTokens: MergeParameters(executionContext, sub.Parameters));
}
return(false);
}
if (elt.TakeStageState == TaskStageStates.Active)
{
try
{
if (terminate.IsCaptured)
{
sub = await TryReset(executionContext, elt, CMMNConstants.ExternalTransitionNames.Terminate, cancellationToken);
executionContext.Instance.MakeTransition(elt, CMMNTransitions.Terminate, incomingTokens: MergeParameters(executionContext, sub.Parameters));
return(true);
}
return(await ProtectedProcess(executionContext, elt, cancellationToken));
}
catch (Exception ex)
{
executionContext.Instance.MakeTransition(elt, CMMNTransitions.Fault, ex.ToString());
return(false);
}
}
return(false);
}
protected override async Task <bool> Process(CMMNExecutionContext executionContext, CaseEltInstance elt, CancellationToken token)
{
var terminateSubscription = await TrySubscribe(executionContext, elt, CMMNConstants.ExternalTransitionNames.Terminate, token);
if (elt.MilestoneState == MilestoneEventStates.Available)
{
await ProtectedProcess(executionContext, elt, token);
if (terminateSubscription.IsCaptured)
{
var sub = await TryReset(executionContext, elt, CMMNConstants.ExternalTransitionNames.Terminate, token);
executionContext.Instance.MakeTransition(elt, CMMNTransitions.Terminate, incomingTokens: MergeParameters(executionContext, sub.Parameters));
}
return(true);
}
return(false);
}
public async Task <string> Create(CMMNExecutionContext executionContext, CaseEltInstance humanTaskElt, CancellationToken token)
{
using (var httpClient = _httpClientFactory.Build())
{
var operationParameters = new JObject
{
{ "nameIdentifier", executionContext.Instance.NameIdentifier }
};
var inputParameters = humanTaskElt.GetInputParameters();
if (inputParameters != null && inputParameters.Any())
{
foreach (var inputParameter in inputParameters)
{
if (string.IsNullOrWhiteSpace(inputParameter.Value))
{
continue;
}
var value = ExpressionParser.GetString(inputParameter.Value, executionContext.Instance.ExecutionContext);
operationParameters.Add(inputParameter.Key, value);
}
}
var tokenResponse = await httpClient.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
{
Address = _options.OAuthTokenEndpoint,
ClientId = _options.ClientId,
ClientSecret = _options.ClientSecret,
Scope = "create_humantaskinstance"
}, token);
if (tokenResponse.IsError)
{
throw new CMMNProcessorException(tokenResponse.Error);
}
var jArr = new JArray();
var link = _options.CallbackUrl.Replace("{id}", executionContext.Instance.AggregateId);
link = link.Replace("{eltId}", humanTaskElt.Id);
jArr.Add(link);
var obj = new JObject
{
{ "humanTaskName", humanTaskElt.GetFormId() },
{ "operationParameters", operationParameters },
{ "callbackUrls", jArr }
};
var content = new StringContent(obj.ToString(), Encoding.UTF8, "application/json");
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
Content = content,
RequestUri = new Uri($"{_options.WSHumanTaskAPI}/humantaskinstances")
};
request.Headers.Add("Authorization", $"Bearer {tokenResponse.AccessToken}");
var httpResult = await httpClient.SendAsync(request, token);
var str = await httpResult.Content.ReadAsStringAsync();
var o = JObject.Parse(str);
var humanTaskInstancId = o["id"].ToString();
return(humanTaskInstancId);
}
}
protected override async Task <bool> ProtectedProcess(CMMNExecutionContext executionContext, CaseEltInstance elt, CancellationToken cancellationToken)
{
var handler = _humanTaskHandlers.FirstOrDefault(_ => _.Implementation == elt.GetImplementation());
if (handler != null)
{
if (!executionContext.Instance.WorkerTaskExists(elt.Id))
{
var workerTaskId = await handler.Create(executionContext, elt, cancellationToken);
executionContext.Instance.TryAddWorkerTask(elt.Id, workerTaskId);
}
}
var completeSubscription = await TrySubscribe(executionContext, elt, CMMNConstants.ExternalTransitionNames.Complete, cancellationToken);
if (completeSubscription.IsCaptured)
{
var sub = await TryReset(executionContext, elt, CMMNConstants.ExternalTransitionNames.Complete, cancellationToken);
executionContext.Instance.MakeTransition(elt, CMMNTransitions.Complete, incomingTokens: MergeParameters(executionContext, completeSubscription.Parameters));
return(true);
}
return(false);
}
