protected internal virtual HistoryEvent CreateHistoricJobLogEvt(IJob job, HistoryEventTypes eventType)
{
HistoricJobLogEventEntity @event = NewHistoricJobLogEntity(job);
InitHistoricJobLogEvent(@event, job, eventType);
return(@event);
}
// helper /////////////////////////////////////////////////////////
protected internal virtual bool IsHistoryEventProduced(HistoryEventTypes eventType, IJob job)
{
var configuration = context.Impl.Context.ProcessEngineConfiguration;
var historyLevel = configuration.HistoryLevel;
return(historyLevel.IsHistoryEventProduced(eventType, job));
}
// helper /////////////////////////////////////////////////////////
protected internal virtual bool IsHistoryEventProduced(HistoryEventTypes eventType, IExternalTask externalTask)
{
ProcessEngineConfigurationImpl configuration = context.Impl.Context.ProcessEngineConfiguration;
IHistoryLevel historyLevel = configuration.HistoryLevel;
return(historyLevel.IsHistoryEventProduced(eventType, externalTask));
}
protected internal virtual HistoryEvent CreateBatchEvent(BatchEntity batch, HistoryEventTypes eventType)
{
HistoricBatchEntity @event = new HistoricBatchEntity();
@event.Id = batch.Id;
@event.Type = batch.Type;
@event.TotalJobs = batch.TotalJobs;
@event.BatchJobsPerSeed = batch.BatchJobsPerSeed;
@event.InvocationsPerBatchJob = batch.InvocationsPerBatchJob;
@event.SeedJobDefinitionId = batch.SeedJobDefinitionId;
@event.MonitorJobDefinitionId = batch.MonitorJobDefinitionId;
@event.BatchJobDefinitionId = batch.BatchJobDefinitionId;
@event.TenantId = batch.TenantId;
@event.EventType = eventType.EventName;
if (HistoryEventTypes.BatchStart.Equals(eventType))
{
@event.StartTime = ClockUtil.CurrentTime;
}
if (HistoryEventTypes.BatchEnd.Equals(eventType))
{
@event.EndTime = ClockUtil.CurrentTime;
}
return(@event);
}
public virtual bool IsHistoryEventProduced(HistoryEventTypes eventType, object entity)
{
if (recordedHistoryEventTypes.Count == 0 || recordedHistoryEventTypes.Contains(eventType))
{
producedHistoryEvents.Add(new ProducedHistoryEvent(eventType, entity));
}
return(true);
}
public override bool IsHistoryEventProduced(HistoryEventTypes eventType, object entity)
{
return(base.IsHistoryEventProduced(eventType, entity) ||
(HistoryEventTypes.VariableInstanceCreate == eventType) ||
(HistoryEventTypes.VariableInstanceUpdate == eventType) ||
(HistoryEventTypes.VariableInstanceMigrate == eventType) ||
(HistoryEventTypes.VariableInstanceDelete == eventType) ||
(HistoryEventTypes.FormPropertyUpdate == eventType));
}
protected internal virtual void FireHistoricIncidentEvent(HistoryEventTypes eventType)
{
ProcessEngineConfigurationImpl processEngineConfiguration = context.Impl.Context.ProcessEngineConfiguration;
IHistoryLevel historyLevel = processEngineConfiguration.HistoryLevel;
if (historyLevel.IsHistoryEventProduced(eventType, this))
{
HistoryEventProcessor.ProcessHistoryEvents(new HistoryEventCreatorAnonymousInnerClassHelper(this, eventType));
}
}
public virtual void FireHistoricIdentityLinkEvent(HistoryEventTypes eventType)
{
var processEngineConfiguration = Context.ProcessEngineConfiguration;
var historyLevel = processEngineConfiguration.HistoryLevel;
if (historyLevel.IsHistoryEventProduced(eventType, this))
{
HistoryEventProcessor.ProcessHistoryEvents(new HistoryEventCreatorAnonymousInnerClassHelper(this,
eventType));
}
}
protected internal virtual void Remove(bool resolved)
{
ExecutionEntity execution = Execution;
if (execution != null)
{
// Extract possible super execution of the assigned execution
ExecutionEntity superExecution = null;
if (execution.Id == execution.ProcessInstanceId)
{
superExecution = (ExecutionEntity)execution.SuperExecution;
}
else
{
//superExecution = execution.getProcessInstance().getSuperExecution();
superExecution = (ExecutionEntity)execution.ProcessInstance.SuperExecution;
}
if (superExecution != null)
{
// get the incident, where this incident is the cause
IncidentEntity parentIncident = superExecution.GetIncidentByCauseIncidentId(Id);
if (parentIncident != null)
{
// remove the incident
parentIncident.Remove(resolved);
}
}
// remove link to execution
execution.RemoveIncident(this);
}
// always delete the incident
context.Impl.Context.CommandContext.IncidentManager.Delete(this);//.DbEntityManager.Delete(this);
// update historic incident
HistoryEventTypes eventType = resolved ? HistoryEventTypes.IncidentResolve : HistoryEventTypes.IncidentDelete;
FireHistoricIncidentEvent(eventType);
}
public override bool IsHistoryEventProduced(HistoryEventTypes eventType, object entity)
{
return((HistoryEventTypes.ProcessInstanceStart == eventType) ||
(HistoryEventTypes.ProcessInstanceUpdate == eventType) ||
(HistoryEventTypes.ProcessInstanceMigrate == eventType) ||
(HistoryEventTypes.ProcessInstanceEnd == eventType) ||
(HistoryEventTypes.TaskInstanceCreate == eventType) ||
(HistoryEventTypes.TaskInstanceUpdate == eventType) ||
(HistoryEventTypes.TaskInstanceMigrate == eventType) ||
(HistoryEventTypes.TaskInstanceComplete == eventType) ||
(HistoryEventTypes.TaskInstanceDelete == eventType) ||
(HistoryEventTypes.ActivityInstanceStart == eventType) ||
(HistoryEventTypes.ActivityInstanceUpdate == eventType) ||
(HistoryEventTypes.ActivityInstanceMigrate == eventType) ||
(HistoryEventTypes.ActivityInstanceEnd == eventType) ||
(HistoryEventTypes.CaseInstanceCreate == eventType) ||
(HistoryEventTypes.CaseInstanceUpdate == eventType) ||
(HistoryEventTypes.CaseInstanceClose == eventType) ||
(HistoryEventTypes.CaseActivityInstanceCreate == eventType) ||
(HistoryEventTypes.CaseActivityInstanceUpdate == eventType) ||
(HistoryEventTypes.CaseActivityInstanceEnd == eventType));
}
protected internal virtual void InitDecisionInstanceEvent(HistoricDecisionInstanceEntity @event,
IDmnDecisionLogicEvaluationEvent evaluationEvent, HistoryEventTypes eventType)
{
throw new NotImplementedException();
//@event.EventType = eventType.EventName;
//var decision = (IDecisionDefinition) evaluationEvent.Decision;
//@event.DecisionDefinitionId = decision.Id;
//@event.DecisionDefinitionKey = decision.Key;
//@event.DecisionDefinitionName = decision.Name;
//if (!ReferenceEquals(decision.DecisionRequirementsDefinitionId, null))
//{
// @event.DecisionRequirementsDefinitionId = decision.DecisionRequirementsDefinitionId;
// @event.DecisionRequirementsDefinitionKey = decision.DecisionRequirementsDefinitionKey;
//}
//if (evaluationEvent is DmnDecisionTableEvaluationEvent)
// InitDecisionInstanceEventForDecisionTable(@event, (DmnDecisionTableEvaluationEvent) evaluationEvent);
//else if (evaluationEvent is DmnDecisionLiteralExpressionEvaluationEvent)
// InitDecisionInstanceEventForDecisionLiteralExpression(@event,
// (DmnDecisionLiteralExpressionEvaluationEvent) evaluationEvent);
}
protected internal virtual HistoryEvent CreateHistoricIdentityLinkEvt(IIdentityLink identityLink, HistoryEventTypes eventType)
{
// create historic identity link event
HistoricIdentityLinkLogEventEntity evt = NewIdentityLinkEventEntity();
// Mapping all the values of identity link to HistoricIdentityLinkEvent
InitHistoricIdentityLinkEvent(evt, identityLink, eventType);
return(evt);
}
// helper /////////////////////////////////////////////////////////////////
protected internal virtual IList <HistoryLevel> setCustomHistoryLevel(HistoryEventTypes eventType)
{
((CustomHistoryLevelRemovalTime)customHistoryLevel).EventTypes = eventType;
return(Collections.singletonList(customHistoryLevel));
}
public HistoryEventArgs(HistoryEventTypes type) : base()
{
this.type = type;
}
public HistoryEventArgs(HistoryEventTypes type)
: base()
{
this.type = type;
}
public HistoryEventCreatorAnonymousInnerClassHelper(IncidentEntity outerInstance, HistoryEventTypes eventType)
{
this._outerInstance = outerInstance;
this._eventType = eventType;
}
public override bool IsHistoryEventProduced(HistoryEventTypes eventType, object entity)
{
return(false);
}
public VATRPCallEventArgs(HistoryEventTypes nType)
{
historyEventType = nType;
}
public abstract bool IsHistoryEventProduced(HistoryEventTypes eventType, object entity);
protected internal virtual void InitHistoricJobLogEvent(HistoricJobLogEventEntity evt, IJob job, HistoryEventTypes eventType)
{
evt.TimeStamp = ClockUtil.CurrentTime;
JobEntity jobEntity = (JobEntity)job;
evt.JobId = jobEntity.Id;
evt.JobDueDate = jobEntity.Duedate;
evt.JobRetries = jobEntity.Retries;
evt.JobPriority = jobEntity.Priority;
IJobDefinition jobDefinition = jobEntity.JobDefinition;
if (jobDefinition != null)
{
evt.JobDefinitionId = jobDefinition.Id;
evt.JobDefinitionType = jobDefinition.JobType;
evt.JobDefinitionConfiguration = jobDefinition.JobConfiguration;
}
else
{
// in case of async signal there does not exist a job definition
// but we use the jobHandlerType as jobDefinitionType
evt.JobDefinitionType = jobEntity.JobHandlerType;
}
evt.ActivityId = jobEntity.ActivityId;
evt.ExecutionId = jobEntity.ExecutionId;
evt.ProcessInstanceId = jobEntity.ProcessInstanceId;
evt.ProcessDefinitionId = jobEntity.ProcessDefinitionId;
evt.ProcessDefinitionKey = jobEntity.ProcessDefinitionKey;
evt.DeploymentId = jobEntity.DeploymentId;
evt.TenantId = jobEntity.TenantId;
// initialize sequence counter
InitSequenceCounter(jobEntity, evt);
IJobState state = null;
if (HistoryEventTypes.JobCreate.Equals(eventType))
{
state = JobStateFields.Created;
}
else if (HistoryEventTypes.JobFail.Equals(eventType))
{
state = JobStateFields.Failed;
}
else if (HistoryEventTypes.JobSuccess.Equals(eventType))
{
state = JobStateFields.Successful;
}
else if (HistoryEventTypes.JobDelete.Equals(eventType))
{
state = JobStateFields.Deleted;
}
evt.State = state.StateCode;
}
protected internal virtual void initDecisionInstanceEvent(HistoricDecisionInstanceEntity @event, DmnDecisionLogicEvaluationEvent evaluationEvent, HistoryEventTypes eventType, HistoricDecisionInstanceEntity rootDecisionInstance)
{
@event.EventType = eventType.EventName;
DecisionDefinition decision = (DecisionDefinition)evaluationEvent.Decision;
@event.DecisionDefinitionId = decision.Id;
@event.DecisionDefinitionKey = decision.Key;
@event.DecisionDefinitionName = decision.Name;
if (!string.ReferenceEquals(decision.DecisionRequirementsDefinitionId, null))
{
@event.DecisionRequirementsDefinitionId = decision.DecisionRequirementsDefinitionId;
@event.DecisionRequirementsDefinitionKey = decision.DecisionRequirementsDefinitionKey;
}
// set current time as evaluation time
@event.EvaluationTime = ClockUtil.CurrentTime;
if (string.ReferenceEquals(@event.RootProcessInstanceId, null) && string.ReferenceEquals(@event.CaseInstanceId, null))
{
if (rootDecisionInstance != null)
{
@event.RemovalTime = rootDecisionInstance.RemovalTime;
}
else
{
DateTime removalTime = calculateRemovalTime(@event, decision);
@event.RemovalTime = removalTime;
}
}
if (evaluationEvent is DmnDecisionTableEvaluationEvent)
{
initDecisionInstanceEventForDecisionTable(@event, (DmnDecisionTableEvaluationEvent)evaluationEvent);
}
else if (evaluationEvent is DmnDecisionLiteralExpressionEvaluationEvent)
{
initDecisionInstanceEventForDecisionLiteralExpression(@event, (DmnDecisionLiteralExpressionEvaluationEvent)evaluationEvent);
}
else
{
@event.Inputs = System.Linq.Enumerable.Empty <HistoricDecisionInputInstance> ();
@event.Outputs = System.Linq.Enumerable.Empty <HistoricDecisionOutputInstance> ();
}
}
public HistoryEventCreatorAnonymousInnerClassHelper(IdentityLinkEntity outerInstance,
HistoryEventTypes eventType)
{
_outerInstance = outerInstance;
_eventType = eventType;
}
public ProducedHistoryEvent(HistoryEventTypes eventType, object entity)
{
EventType = eventType;
Entity = entity;
}
protected internal virtual HistoryEvent CreateHistoricIncidentEvt(IIncident incident, HistoryEventTypes eventType)
{
// create event
Event.HistoricIncidentEntity evt = LoadIncidentEvent(incident);
// initialize
InitHistoricIncidentEvent(evt, incident, eventType);
if (HistoryEventTypes.IncidentCreate != eventType)
{
evt.EndTime = ClockUtil.CurrentTime;
}
return(evt);
}
protected internal virtual HistoryEvent CreateHistoricVariableEvent(VariableInstanceEntity variableInstance, IVariableScope sourceVariableScope, HistoryEventTypes eventType)
{
string scopeActivityInstanceId = null;
string sourceActivityInstanceId = null;
if (variableInstance.ExecutionId != null)
{
//ExecutionEntity scopeExecution = Context.CommandContext.DbEntityManager.SelectById(typeof(ExecutionEntity), variableInstance.ExecutionId);
ExecutionEntity scopeExecution = Context.CommandContext.ExecutionManager.FindExecutionById(variableInstance.ExecutionId);
if (variableInstance.TaskId == null && !variableInstance.IsConcurrentLocal)
{
scopeActivityInstanceId = scopeExecution.ParentActivityInstanceId;
}
else
{
scopeActivityInstanceId = scopeExecution.ActivityInstanceId;
}
}
else if (!string.ReferenceEquals(variableInstance.CaseExecutionId, null))
{
scopeActivityInstanceId = variableInstance.CaseExecutionId;
}
ExecutionEntity sourceExecution = null;
//CaseExecutionEntity sourceCaseExecution = null;
if (sourceVariableScope is ExecutionEntity)
{
sourceExecution = (ExecutionEntity)sourceVariableScope;
sourceActivityInstanceId = sourceExecution.ActivityInstanceId;
}
else if (sourceVariableScope is TaskEntity)
{
sourceExecution = ((TaskEntity)sourceVariableScope).GetExecution();
if (sourceExecution != null)
{
sourceActivityInstanceId = sourceExecution.ActivityInstanceId;
}
else
{
//sourceCaseExecution = ((TaskEntity)sourceVariableScope).GetCaseExecution();
//if (sourceCaseExecution != null)
//{
// sourceActivityInstanceId = sourceCaseExecution.Id;
//}
}
}
//else if (sourceVariableScope is CaseExecutionEntity)
//{
// sourceCaseExecution = (CaseExecutionEntity)sourceVariableScope;
// sourceActivityInstanceId = sourceCaseExecution.Id;
//}
// create event
HistoricVariableUpdateEventEntity evt = NewVariableUpdateEventEntity(sourceExecution);
// initialize
InitHistoricVariableUpdateEvt(evt, variableInstance, eventType);
// initialize sequence counter
InitSequenceCounter(variableInstance, evt);
// set scope activity instance id
evt.ScopeActivityInstanceId = scopeActivityInstanceId;
// set source activity instance id
evt.ActivityInstanceId = sourceActivityInstanceId;
return(evt);
}
public VATRPCallEventArgs(HistoryEventTypes nType)
{
historyEventType = nType;
}
protected internal virtual void InitHistoricIdentityLinkEvent(HistoricIdentityLinkLogEventEntity evt, IIdentityLink identityLink, HistoryEventTypes eventType)
{
if (!string.ReferenceEquals(identityLink.TaskId, null))
{
TaskEntity task = Context.CommandContext.TaskManager.FindTaskById(identityLink.TaskId);
evt.ProcessDefinitionId = task.ProcessDefinitionId;
if (task.ProcessDefinition != null)
{
evt.ProcessDefinitionKey = task.ProcessDefinition.Key;
}
}
if (!string.ReferenceEquals(identityLink.ProcessDefId, null))
{
evt.ProcessDefinitionId = identityLink.ProcessDefId;
ProcessDefinitionEntity definition = Context.ProcessEngineConfiguration.DeploymentCache.FindProcessDefinitionFromCache(identityLink.ProcessDefId);
evt.ProcessDefinitionKey = definition.Key;
}
evt.Time = ClockUtil.CurrentTime;
evt.Type = identityLink.Type;
evt.UserId = identityLink.UserId;
evt.GroupId = identityLink.GroupId;
evt.TaskId = identityLink.TaskId;
evt.TenantId = identityLink.TenantId;
// There is a conflict in HistoryEventTypes for 'delete' keyword,
// So HistoryEventTypes.IDENTITY_LINK_ADD /
// HistoryEventTypes.IDENTITY_LINK_DELETE is provided with the event name
// 'add-identity-link' /'delete-identity-link'
// and changed to 'add'/'delete' (While inserting it into the database) on
// Historic identity link add / delete event
string operationType = "add";
if (eventType.EventName.Equals(HistoryEventTypes.IdentityLinkDelete.EventName))
{
operationType = "delete";
}
evt.OperationType = operationType;
evt.EventType = eventType.EventName;
evt.AssignerId = Context.CommandContext.AuthenticatedUserId;
}
public virtual bool IsHistoryEventProduced(HistoryEventTypes eventType, object entity)
{
return(true);
}
protected internal virtual void initDecisionInstanceEvent(HistoricDecisionInstanceEntity @event, DmnDecisionLogicEvaluationEvent evaluationEvent, HistoryEventTypes eventType)
{
initDecisionInstanceEvent(@event, evaluationEvent, eventType, null);
}
