public HistoricDecisionInstanceSupplierAnonymousInnerClass(DefaultDmnHistoryEventProducer outerInstance,
IDelegateExecution execution, IDmnDecisionEvaluationEvent evaluationEvent)
{
this._outerInstance = outerInstance;
this._execution = execution;
this._evaluationEvent = evaluationEvent;
}
protected internal virtual void PerformNotification(IDelegateExecution execution, Action notification)
{
//IProcessApplicationReference processApp = ProcessApplicationContextUtil.GetTargetProcessApplication(execution);
//if (processApp == null)
//{
// // ignore silently
// LOG.NoTargetProcessApplicationForExecution(execution);
//}
//else
//{
// if (ProcessApplicationContextUtil.RequiresContextSwitch(processApp))
// {
// // this should not be necessary since context switch is already performed by OperationContext and / or DelegateInterceptor
// //Context.ExecuteWithinProcessApplication(notification, processApp, new InvocationContext(execution));
// }
// else
// {
// // context switch already performed
// notification();
// }
//}
}
// Implementation ////////////////////////////////
public virtual HistoryEvent CreateProcessInstanceStartEvt(IDelegateExecution execution)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.camunda.bpm.persistence.entity.ExecutionEntity executionEntity = (org.camunda.bpm.persistence.entity.ExecutionEntity) execution;
ExecutionEntity executionEntity = (ExecutionEntity)execution;
// create event instance
HistoricProcessInstanceEventEntity evt = NewProcessInstanceEventEntity(executionEntity);
// initialize event
InitProcessInstanceEvent(evt, executionEntity, HistoryEventTypes.ActivityInstanceStart);
evt.StartActivityId = executionEntity.ActivityId;
evt.StartTime = ClockUtil.CurrentTime;
// set super process instance id
ExecutionEntity superExecution = (ExecutionEntity)executionEntity.SuperExecution;
if (superExecution != null)
{
evt.SuperProcessInstanceId = superExecution.ProcessInstanceId;
}
//state
evt.State = HistoricProcessInstanceFields.StateActive;
// set start user Id
evt.StartUserId = Context.CommandContext.AuthenticatedUserId;
return(evt);
}
public virtual HistoryEvent CreateProcessInstanceEndEvt(IDelegateExecution execution)
{
ExecutionEntity executionEntity = (ExecutionEntity)execution;
// create event instance
HistoricProcessInstanceEventEntity evt = LoadProcessInstanceEventEntity(executionEntity);
// initialize event
InitProcessInstanceEvent(evt, executionEntity, HistoryEventTypes.ProcessInstanceEnd);
DetermineEndState(executionEntity, evt);
// set end activity id
evt.EndActivityId = executionEntity.ActivityId;
evt.EndTime = ClockUtil.CurrentTime;
if (evt.StartTime != null)
{
evt.DurationInMillis = ((DateTime)evt.EndTime).Ticks - ((DateTime)evt.StartTime).Ticks;
}
// set delete reason (if applicable).
if (!string.ReferenceEquals(executionEntity.DeleteReason, null))
{
evt.DeleteReason = executionEntity.DeleteReason;
}
return(evt);
}
public virtual string assignTask(IDelegateExecution execution)
{
logAuthentication(execution);
logInstancesCount(execution);
return("demo");
}
public virtual IList <string> resolveCollection(IDelegateExecution delegateExecution)
{
DelegateEvent.RecordEventFor(delegateExecution);
return(new List <string> {
"1"
});
}
public virtual void DoAssert(IDelegateExecution execution)
{
IIdentityService identityService = execution.ProcessEngineServices.IdentityService;
Authentication currentAuthentication = identityService.CurrentAuthentication;
Assert.That(currentAuthentication, Is.EqualTo(null));
}
public virtual bool TryEvaluate(IDelegateExecution execution)
{
if (Condition != null)
{
return(Condition.TryEvaluate(execution, execution));
}
throw new InvalidOperationException("Condtional event must have a condition!");
}
public virtual bool Evaluate(IVariableScope scope, IDelegateExecution execution)
{
var result = Expression.GetValue(scope, execution);
EnsureUtil.EnsureNotNull("condition expression returns null", "result", result);
EnsureUtil.EnsureInstanceOf("condition expression returns non-Boolean", "result", result, typeof(bool));
return((bool)result);
}
protected internal override HistoryEvent CreateHistoryEvent(IDelegateExecution execution)
{
if (HistoryLevel.IsHistoryEventProduced(HistoryEventTypes.ProcessInstanceUpdate, execution))
{
return(EventProducer.CreateProcessInstanceUpdateEvt(execution));
}
return(null);
}
public virtual void Notify(IDelegateExecution execution)
{
if (WaitingListener.Monitor != null)
{
ThreadControl localMonitor = WaitingListener.Monitor;
WaitingListener.Monitor = null;
localMonitor.Sync();
}
}
protected internal virtual bool ShouldPerformPaContextSwitch(IDelegateExecution execution)
{
throw new NotImplementedException();
//if (execution == null)
// return false;
//var targetPa =
// ProcessApplicationContextUtil.getTargetProcessApplication((ExecutionEntity) execution);
//return (targetPa != null) && !targetPa.Equals(Context.CurrentProcessApplication);
}
protected internal virtual void MigrateHistory(IDelegateExecution execution)
{
if (activityInstance.Id.Equals(activityInstance.ProcessInstanceId))
{
MigrateProcessInstanceHistory(execution);
}
else
{
MigrateActivityInstanceHistory(execution);
}
}
//JAVA TO C# CONVERTER WARNING: 'final' parameters are not available in .NET:
//ORIGINAL LINE: protected void migrateActivityInstanceHistory(final org.camunda.bpm.engine.delegate.DelegateExecution execution)
protected internal virtual void MigrateActivityInstanceHistory(IDelegateExecution execution)
{
var historyLevel = Context.ProcessEngineConfiguration.HistoryLevel;
if (!historyLevel.IsHistoryEventProduced(HistoryEventTypes.ActivityInstanceMigrate, this))
{
return;
}
HistoryEventProcessor.ProcessHistoryEvents(new HistoryEventCreatorAnonymousInnerClass2(this));
}
public virtual void DoAssert(IDelegateExecution execution)
{
IIdentityService identityService = execution.ProcessEngineServices.IdentityService;
Authentication currentAuthentication = identityService.CurrentAuthentication;
Assert.That(currentAuthentication != null);
Assert.Contains(currentAuthentication.TenantIds, new List <string>()
{
expectedTenantId
});
}
public virtual void testDelegateExecutionContext()
{
// given
IProcessDefinition definition = testHelper.DeployAndGetDefinition(DELEGATION_PROCESS);
// a process instance with a service task and a java delegate
IProcessInstance instance = engineRule.RuntimeService.StartProcessInstanceById(definition.Id);
//then delegation execution context is no more available
IDelegateExecution execution = DelegateExecutionContext.CurrentDelegationExecution;
Assert.IsNull(execution);
}
protected internal virtual string GetStringFromField(IExpression expression, IDelegateExecution execution)
{
if (expression != null)
{
var value = expression.GetValue(execution);
if (value != null)
{
return(value.ToString());
}
}
return(null);
}
protected internal override HistoryEvent CreateHistoryEvent(IDelegateExecution execution)
{
if (HistoryLevel.IsHistoryEventProduced(HistoryEventTypes.ActivityInstanceEnd, execution))
{
// Todo: IHistoryEventProducer 实现
if (EventProducer != null)
{
return(EventProducer.CreateActivityInstanceEndEvt(execution));
}
}
return(null);
}
public virtual HistoryEvent CreateProcessInstanceMigrateEvt(IDelegateExecution execution)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.camunda.bpm.persistence.entity.ExecutionEntity executionEntity = (org.camunda.bpm.persistence.entity.ExecutionEntity) execution;
ExecutionEntity executionEntity = (ExecutionEntity)execution;
// create event instance
HistoricProcessInstanceEventEntity evt = NewProcessInstanceEventEntity(executionEntity);
// initialize event
InitProcessInstanceEvent(evt, executionEntity, HistoryEventTypes.ProcessInstanceMigrate);
return(evt);
}
public virtual void Notify(IDelegateTask delegateTask)
{
// get mapping table from variable
IDelegateExecution execution = delegateTask.Execution;
IDictionary <string, string> assigneeMappingTable = (IDictionary <string, string>)execution.GetVariable("assigneeMappingTable");
// get assignee from process
string assigneeFromProcessDefinition = delegateTask.Assignee;
// overwrite assignee if there is an entry in the mapping table
if (assigneeMappingTable.ContainsKey(assigneeFromProcessDefinition))
{
string assigneeFromMappingTable = assigneeMappingTable[assigneeFromProcessDefinition];
delegateTask.Assignee = assigneeFromMappingTable;
}
}
public virtual bool TryEvaluate(IVariableScope scope, IDelegateExecution execution)
{
var result = false;
try
{
result = Evaluate(scope, execution);
}
catch (ProcessEngineException pee)
{
if (!(pee.InnerException is PropertyNotFoundException))
{
throw pee;
}
}
return(result);
}
public virtual HistoryEvent CreateActivityInstanceStartEvt(IDelegateExecution execution)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.camunda.bpm.persistence.entity.ExecutionEntity executionEntity = (org.camunda.bpm.persistence.entity.ExecutionEntity) execution;
ExecutionEntity executionEntity = (ExecutionEntity)execution;
// create event instance
HistoricActivityInstanceEventEntity evt = NewActivityInstanceEventEntity(executionEntity);
// initialize event
InitActivityInstanceEvent(evt, executionEntity, HistoryEventTypes.ActivityInstanceStart);
// initialize sequence counter
InitSequenceCounter(executionEntity, evt);
evt.StartTime = ClockUtil.CurrentTime;
return(evt);
}
public virtual HistoryEvent CreateActivityInstanceUpdateEvt(IDelegateExecution execution, IDelegateTask task)
{
ExecutionEntity executionEntity = (ExecutionEntity)execution;
// create event instance
HistoricActivityInstanceEventEntity evt = LoadActivityInstanceEventEntity(executionEntity);
// initialize event
InitActivityInstanceEvent(evt, executionEntity, HistoryEventTypes.ActivityInstanceUpdate);
// update ITask assignment
if (task != null)
{
evt.TaskId = task.Id;
evt.TaskAssignee = task.Assignee;
}
return(evt);
}
public static DelegateEvent FromExecution(IDelegateExecution delegateExecution)
{
var @event = new DelegateEvent();
@event.ActivityInstanceId = delegateExecution.ActivityInstanceId;
@event.BusinessKey = delegateExecution.BusinessKey;
@event.currentActivityId = delegateExecution.CurrentActivityId;
@event.currentActivityName = delegateExecution.CurrentActivityName;
@event.currentTransitionId = delegateExecution.CurrentTransitionId;
@event.EventName = delegateExecution.EventName;
@event.Id = delegateExecution.Id;
@event.parentActivityInstanceId = delegateExecution.ParentActivityInstanceId;
@event.parentId = delegateExecution.ParentId;
@event.ProcessBusinessKey = delegateExecution.ProcessBusinessKey;
@event.ProcessDefinitionId = delegateExecution.ProcessDefinitionId;
@event.ProcessInstanceId = delegateExecution.ProcessInstanceId;
@event.TenantId = delegateExecution.TenantId;
@event.VariableScopeKey = delegateExecution.VariableScopeKey;
return(@event);
}
public virtual HistoryEvent CreateActivityInstanceEndEvt(IDelegateExecution execution)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.camunda.bpm.persistence.entity.ExecutionEntity executionEntity = (org.camunda.bpm.persistence.entity.ExecutionEntity) execution;
ExecutionEntity executionEntity = (ExecutionEntity)execution;
// create event instance
HistoricActivityInstanceEventEntity evt = LoadActivityInstanceEventEntity(executionEntity);
evt.ActivityInstanceState = executionEntity.ActivityInstanceState;
// initialize event
InitActivityInstanceEvent(evt, (ExecutionEntity)execution, HistoryEventTypes.ActivityInstanceEnd);
evt.EndTime = ClockUtil.CurrentTime;
if (evt.StartTime != null)
{
evt.DurationInMillis = ((DateTime)evt.EndTime).Ticks - ((DateTime)evt.StartTime).Ticks;
}
return(evt);
}
public virtual HistoryEvent CreateProcessInstanceUpdateEvt(IDelegateExecution execution)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.camunda.bpm.persistence.entity.ExecutionEntity executionEntity = (org.camunda.bpm.persistence.entity.ExecutionEntity) execution;
ExecutionEntity executionEntity = (ExecutionEntity)execution;
// create event instance
HistoricProcessInstanceEventEntity evt = NewProcessInstanceEventEntity(executionEntity);
// initialize event
InitProcessInstanceEvent(evt, executionEntity, HistoryEventTypes.ActivityInstanceUpdate);
if (executionEntity.IsSuspended)
{
evt.State = HistoricProcessInstanceFields.StateSuspended;
}
else
{
evt.State = HistoricProcessInstanceFields.StateActive;
}
return(evt);
}
protected internal virtual void NotifyExecutionListener(IDelegateExecution execution)
{
var processApp = Context.CurrentProcessApplication;
try
{
var processApplication = processApp.ProcessApplication;
var executionListener = processApplication.ExecutionListener;
if (executionListener != null)
{
executionListener.Notify(execution);
}
else
{
LOG.PaDoesNotProvideExecutionListener(processApp.Name);
}
}
catch (ProcessApplicationUnavailableException e)
{
// Process Application unavailable => ignore silently
LOG.CannotInvokeListenerPaUnavailable(processApp.Name, e);
}
}
public void MapInputVariables(IDelegateExecution superExecution, IVariableMap subVariables)
{
throw new ProcessEngineException("New process engine exception.");
}
public void MapOutputVariables(IDelegateExecution superExecution, IVariableScope subInstance)
{
throw new ProcessEngineException("New process engine exception.");
}
public TenantIdProviderHistoricDecisionInstanceContext(IDecisionDefinition decisionDefinition,
IDelegateExecution execution) : this(decisionDefinition)
{
this.execution = execution;
}
