public DeserializedObject(SerializableType type, object deserializedObject, byte[] serializedBytes, IVariableInstanceEntity variableInstanceEntity)
{
this.type = type;
this.deserializedObject = deserializedObject;
this.originalBytes = serializedBytes;
this.variableInstanceEntity = variableInstanceEntity;
}
protected internal virtual void UpdateVariableInstance(IVariableInstanceEntity variableInstance, object value, IExecutionEntity sourceActivityExecution)
{
// Always check if the type should be altered. It's possible that the
// previous type is lower in the type
// checking chain (e.g. serializable) and will return true on
// isAbleToStore(), even though another type
// higher in the chain is eligible for storage.
IVariableTypes variableTypes = Context.ProcessEngineConfiguration.VariableTypes;
IVariableType newType = variableTypes.FindVariableType(value);
if (newType != null && !newType.Equals(variableInstance.Type))
{
variableInstance.Value = null;
variableInstance.Type = newType;
variableInstance.ForceUpdate();
variableInstance.Value = value;
}
else
{
variableInstance.Value = value;
}
Context.CommandContext.HistoryManager.RecordHistoricDetailVariableCreate(variableInstance, sourceActivityExecution, ActivityIdUsedForDetails);
Context.CommandContext.HistoryManager.RecordVariableUpdate(variableInstance);
}
// Variables related history
/// <summary>
///
/// </summary>
/// <param name="variable"></param>
public virtual void RecordVariableCreate(IVariableInstanceEntity variable)
{
// Historic variables
if (IsHistoryLevelAtLeast(HistoryLevel.ACTIVITY))
{
HistoricVariableInstanceEntityManager.CopyAndInsert(variable);
}
}
public virtual object SetVariableLocal(string variableName, object value, IExecutionEntity sourceActivityExecution, bool fetchAllVariables)
{
if (fetchAllVariables == true)
{
// If it's in the cache, it's more recent
if (usedVariablesCache.ContainsKey(variableName))
{
UpdateVariableInstance(usedVariablesCache[variableName], value, sourceActivityExecution);
}
EnsureVariableInstancesInitialized();
variableInstances.TryGetValue(variableName, out IVariableInstanceEntity variableInstance);
if (variableInstance == null)
{
usedVariablesCache.TryGetValue(variableName, out variableInstance);
}
if (variableInstance == null)
{
CreateVariableLocal(variableName, value);
}
else
{
UpdateVariableInstance(variableInstance, value, sourceActivityExecution);
}
return(null);
}
else
{
if (usedVariablesCache.ContainsKey(variableName))
{
UpdateVariableInstance(usedVariablesCache[variableName], value, sourceActivityExecution);
}
else if (variableInstances != null && variableInstances.ContainsKey(variableName))
{
UpdateVariableInstance(variableInstances[variableName], value, sourceActivityExecution);
}
else
{
IVariableInstanceEntity variable = GetSpecificVariable(variableName);
if (variable != null)
{
UpdateVariableInstance(variable, value, sourceActivityExecution);
}
else
{
variable = CreateVariableInstance(variableName, value, sourceActivityExecution);
}
usedVariablesCache[variableName] = variable;
}
return(null);
}
}
public virtual IVariableInstance GetVariableInstance(string variableName, bool fetchAllVariables)
{
// Transient variable
if (transientVariabes != null && transientVariabes.ContainsKey(variableName))
{
return(transientVariabes[variableName]);
}
// Check the local single-fetch cache
if (usedVariablesCache.ContainsKey(variableName))
{
return(usedVariablesCache[variableName]);
}
if (fetchAllVariables == true)
{
EnsureVariableInstancesInitialized();
variableInstances.TryGetValue(variableName, out IVariableInstanceEntity variableInstance);
if (variableInstance != null)
{
return(variableInstance);
}
// Go up the hierarchy
IVariableScope parentScope = ParentVariableScope;
if (parentScope != null)
{
return(parentScope.GetVariableInstance(variableName, true));
}
return(null);
}
else
{
if (variableInstances != null && variableInstances.ContainsKey(variableName))
{
return(variableInstances[variableName]);
}
IVariableInstanceEntity variable = GetSpecificVariable(variableName);
if (variable != null)
{
usedVariablesCache[variableName] = variable;
return(variable);
}
// Go up the hierarchy
IVariableScope parentScope = ParentVariableScope;
if (parentScope != null)
{
return(parentScope.GetVariableInstance(variableName, false));
}
return(null);
}
}
protected internal virtual void DeleteVariableInstanceForExplicitUserCall(IVariableInstanceEntity variableInstance, IExecutionEntity sourceActivityExecution)
{
Context.CommandContext.VariableInstanceEntityManager.Delete(variableInstance);
variableInstance.Value = null;
// Record historic variable deletion
Context.CommandContext.HistoryManager.RecordVariableRemoved(variableInstance);
// Record historic detail
Context.CommandContext.HistoryManager.RecordHistoricDetailVariableCreate(variableInstance, sourceActivityExecution, ActivityIdUsedForDetails);
}
/// <summary>
///
/// </summary>
/// <param name="variableInstance"></param>
/// <param name="value"></param>
/// <param name="sourceActivityExecution"></param>
protected internal override void UpdateVariableInstance(IVariableInstanceEntity variableInstance, object value, IExecutionEntity sourceActivityExecution)
{
base.UpdateVariableInstance(variableInstance, value, sourceActivityExecution);
// Dispatch event, if needed
ProcessEngineConfigurationImpl processEngineConfiguration = Context.ProcessEngineConfiguration;
if (processEngineConfiguration is object && processEngineConfiguration.EventDispatcher.Enabled)
{
processEngineConfiguration.EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateVariableEvent(ActivitiEventType.VARIABLE_UPDATED, variableInstance.Name, value, variableInstance.Type, variableInstance.TaskId, variableInstance.ExecutionId, ProcessInstanceId, ProcessDefinitionId));
}
}
// VariableScopeImpl methods //////////////////////////////////////////////////////////////////
/// <summary>
///
/// </summary>
// TODO: this should ideally move to another place
protected internal override void InitializeVariableInstanceBackPointer(IVariableInstanceEntity variableInstance)
{
if (processInstanceId is object)
{
variableInstance.ProcessInstanceId = processInstanceId;
}
else
{
variableInstance.ProcessInstanceId = Id;
}
variableInstance.ExecutionId = Id;
}
/// <summary>
///
/// </summary>
/// <param name="variableName"></param>
/// <returns></returns>
protected internal override IVariableInstanceEntity GetSpecificVariable(string variableName)
{
ICommandContext commandContext = Context.CommandContext;
if (commandContext == null)
{
throw new ActivitiException("lazy loading outside command context");
}
IVariableInstanceEntity variableInstance = commandContext.VariableInstanceEntityManager.FindVariableInstanceByExecutionAndName(Id, variableName);
return(variableInstance);
}
/// <summary>
///
/// </summary>
/// <param name="variableName"></param>
/// <param name="value"></param>
/// <param name="sourceActivityExecution"></param>
/// <returns></returns>
protected internal override IVariableInstanceEntity CreateVariableInstance(string variableName, object value, IExecutionEntity sourceActivityExecution)
{
IVariableInstanceEntity result = base.CreateVariableInstance(variableName, value, sourceActivityExecution);
// Dispatch event, if needed
ProcessEngineConfigurationImpl processEngineConfiguration = Context.ProcessEngineConfiguration;
if (processEngineConfiguration is object && processEngineConfiguration.EventDispatcher.Enabled)
{
processEngineConfiguration.EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateVariableEvent(ActivitiEventType.VARIABLE_CREATED, variableName, value, result.Type, result.TaskId, result.ExecutionId, ProcessInstanceId, ProcessDefinitionId));
}
return(result);
}
public virtual void RecordVariableRemoved(IVariableInstanceEntity variable)
{
if (variable != null && IsHistoryLevelAtLeast(HistoryLevel.ACTIVITY))
{
if (!(EntityCache.FindInCache(variable.GetType(), variable.Id) is IHistoricVariableInstanceEntity historicProcessVariable))
{
historicProcessVariable = HistoricVariableInstanceEntityManager.FindHistoricVariableInstanceByVariableInstanceId(variable.Id);
}
if (historicProcessVariable != null)
{
HistoricVariableInstanceEntityManager.Delete(historicProcessVariable);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="variable"></param>
/// <param name="sourceActivityExecution"></param>
/// <param name="useActivityId"></param>
public virtual void RecordHistoricDetailVariableCreate(IVariableInstanceEntity variable, IExecutionEntity sourceActivityExecution, bool useActivityId)
{
if (IsHistoryLevelAtLeast(HistoryLevel.FULL))
{
IHistoricDetailVariableInstanceUpdateEntity historicVariableUpdate = HistoricDetailEntityManager.CopyAndInsertHistoricDetailVariableInstanceUpdateEntity(variable);
if (useActivityId && sourceActivityExecution != null)
{
IHistoricActivityInstanceEntity historicActivityInstance = FindActivityInstance(sourceActivityExecution, false, false);
if (historicActivityInstance != null)
{
historicVariableUpdate.ActivityInstanceId = historicActivityInstance.Id;
}
}
}
}
public virtual IVariableInstance GetVariableInstanceLocal(string variableName, bool fetchAllVariables)
{
if (transientVariabes != null && transientVariabes.ContainsKey(variableName))
{
return(transientVariabes[variableName]);
}
if (usedVariablesCache.ContainsKey(variableName))
{
return(usedVariablesCache[variableName]);
}
if (fetchAllVariables == true)
{
EnsureVariableInstancesInitialized();
variableInstances.TryGetValue(variableName, out IVariableInstanceEntity variableInstance);
if (variableInstance != null)
{
return(variableInstance);
}
return(null);
}
else
{
if (variableInstances != null && variableInstances.ContainsKey(variableName))
{
IVariableInstanceEntity v = variableInstances[variableName];
if (v != null)
{
return(variableInstances[variableName]);
}
}
IVariableInstanceEntity variable = GetSpecificVariable(variableName);
if (variable != null)
{
usedVariablesCache[variableName] = variable;
return(variable);
}
return(null);
}
}
public virtual IHistoricVariableInstanceEntity CopyAndInsert(IVariableInstanceEntity variableInstance)
{
IHistoricVariableInstanceEntity historicVariableInstance = historicVariableInstanceDataManager.Create();
historicVariableInstance.Id = variableInstance.Id;
historicVariableInstance.ProcessInstanceId = variableInstance.ProcessInstanceId;
historicVariableInstance.ExecutionId = variableInstance.ExecutionId;
historicVariableInstance.TaskId = variableInstance.TaskId;
historicVariableInstance.Revision = variableInstance.Revision;
historicVariableInstance.Name = variableInstance.Name;
historicVariableInstance.VariableType = variableInstance.Type;
CopyVariableValue(historicVariableInstance, variableInstance);
DateTime time = Clock.CurrentTime;
historicVariableInstance.CreateTime = time;
historicVariableInstance.LastUpdatedTime = time;
Insert(historicVariableInstance);
return(historicVariableInstance);
}
public virtual void Initialize(IVariableTypes types)
{
if (variableInstanceEntity == null)
{
IVariableType type = types.FindVariableType(value);
if (type is ByteArrayType)
{
throw new ActivitiIllegalArgumentException("Variables of type ByteArray cannot be used to query");
}
else if (type is IEntityVariableType && @operator != QueryOperator.EQUALS)
{
throw new ActivitiIllegalArgumentException("JPA entity variables can only be used in 'variableValueEquals'");
}
else if (type is IEntityListVariableType)
{
throw new ActivitiIllegalArgumentException("Variables containing a list of JPA entities cannot be used to query");
}
else
{
// Type implementation determines which fields are set on the entity
variableInstanceEntity = Context.CommandContext.VariableInstanceEntityManager.Create(name, type, value);
}
}
}
protected internal virtual IVariableInstanceEntity CreateVariableInstance(string variableName, object value, IExecutionEntity sourceActivityExecution)
{
IVariableTypes variableTypes = Context.ProcessEngineConfiguration.VariableTypes;
IVariableType type = variableTypes.FindVariableType(value);
IVariableInstanceEntity variableInstance = Context.CommandContext.VariableInstanceEntityManager.Create(variableName, type, value);
InitializeVariableInstanceBackPointer(variableInstance);
Context.CommandContext.VariableInstanceEntityManager.Insert(variableInstance);
if (variableInstances != null)
{
variableInstances[variableName] = variableInstance;
}
// Record historic variable
Context.CommandContext.HistoryManager.RecordVariableCreate(variableInstance);
// Record historic detail
Context.CommandContext.HistoryManager.RecordHistoricDetailVariableCreate(variableInstance, sourceActivityExecution, ActivityIdUsedForDetails);
return(variableInstance);
}
protected internal override void InitializeVariableInstanceBackPointer(IVariableInstanceEntity variableInstance)
{
variableInstance.TaskId = id;
variableInstance.ExecutionId = executionId;
variableInstance.ProcessInstanceId = processInstanceId;
}
/// <summary>
/// Sets a variable as high as possible (highest parent).
/// </summary>
/// <param name="sourceExecution"> The execution where the variable was originally set, used for history data. </param>
/// <param name="fetchAllVariables"> If true, all existing variables will be fetched when setting the variable. </param>
protected internal virtual void SetVariable(string variableName, object value, IExecutionEntity sourceExecution, bool fetchAllVariables)
{
if (fetchAllVariables == true)
{
// If it's in the cache, it's more recent
if (usedVariablesCache.ContainsKey(variableName))
{
UpdateVariableInstance(usedVariablesCache[variableName], value, sourceExecution);
}
// If the variable exists on this scope, replace it
if (HasVariableLocal(variableName))
{
SetVariableLocal(variableName, value, sourceExecution, true);
return;
}
// Otherwise, go up the hierarchy (we're trying to put it as high as possible)
VariableScopeImpl parentVariableScope = ParentVariableScope;
if (parentVariableScope != null)
{
if (sourceExecution == null)
{
parentVariableScope.SetVariable(variableName, value);
}
else
{
parentVariableScope.SetVariable(variableName, value, sourceExecution, true);
}
return;
}
// We're as high as possible and the variable doesn't exist yet, so
// we're creating it
if (sourceExecution != null)
{
CreateVariableLocal(variableName, value, sourceExecution);
}
else
{
CreateVariableLocal(variableName, value);
}
}
else
{
// Check local cache first
if (usedVariablesCache.ContainsKey(variableName))
{
UpdateVariableInstance(usedVariablesCache[variableName], value, sourceExecution);
}
else if (variableInstances != null && variableInstances.ContainsKey(variableName))
{
UpdateVariableInstance(variableInstances[variableName], value, sourceExecution);
}
else
{
// Not in local cache, check if defined on this scope
// Create it if it doesn't exist yet
IVariableInstanceEntity variable = GetSpecificVariable(variableName);
if (variable != null)
{
UpdateVariableInstance(variable, value, sourceExecution);
usedVariablesCache[variableName] = variable;
}
else
{
VariableScopeImpl parent = ParentVariableScope;
if (parent != null)
{
if (sourceExecution == null)
{
parent.SetVariable(variableName, value, fetchAllVariables);
}
else
{
parent.SetVariable(variableName, value, sourceExecution, fetchAllVariables);
}
return;
}
variable = CreateVariableInstance(variableName, value, sourceExecution);
usedVariablesCache[variableName] = variable;
}
}
}
}
protected internal abstract void InitializeVariableInstanceBackPointer(IVariableInstanceEntity variableInstance);
// VariableScopeImpl methods //////////////////////////////////////////////////////////////////
// TODO: this should ideally move to another place
protected internal override void InitializeVariableInstanceBackPointer(IVariableInstanceEntity variableInstance)
{
if (!(processInstanceId is null))
{
variableInstance.ProcessInstanceId = processInstanceId;
}
public virtual void CopyVariableValue(IHistoricVariableInstanceEntity historicVariableInstance, IVariableInstanceEntity variableInstance)
{
historicVariableInstance.TextValue = variableInstance.TextValue;
historicVariableInstance.TextValue2 = variableInstance.TextValue2;
historicVariableInstance.DoubleValue = variableInstance.DoubleValue;
historicVariableInstance.LongValue = variableInstance.LongValue;
historicVariableInstance.VariableType = variableInstance.Type;
if (variableInstance.ByteArrayRef != null)
{
historicVariableInstance.Bytes = variableInstance.Bytes;
}
historicVariableInstance.LastUpdatedTime = Clock.CurrentTime;
}
public virtual IHistoricDetailVariableInstanceUpdateEntity CopyAndInsertHistoricDetailVariableInstanceUpdateEntity(IVariableInstanceEntity variableInstance)
{
IHistoricDetailVariableInstanceUpdateEntity historicVariableUpdate = historicDetailDataManager.CreateHistoricDetailVariableInstanceUpdate();
historicVariableUpdate.ProcessInstanceId = variableInstance.ProcessInstanceId;
historicVariableUpdate.ExecutionId = variableInstance.ExecutionId;
historicVariableUpdate.TaskId = variableInstance.TaskId;
historicVariableUpdate.Time = Clock.CurrentTime;
historicVariableUpdate.Revision = variableInstance.Revision;
historicVariableUpdate.Name = variableInstance.Name;
historicVariableUpdate.VariableType = variableInstance.Type;
historicVariableUpdate.TextValue = variableInstance.TextValue;
historicVariableUpdate.TextValue2 = variableInstance.TextValue2;
historicVariableUpdate.DoubleValue = variableInstance.DoubleValue;
historicVariableUpdate.LongValue = variableInstance.LongValue;
if (variableInstance.Bytes != null)
{
historicVariableUpdate.Bytes = variableInstance.Bytes;
}
Insert(historicVariableUpdate);
return(historicVariableUpdate);
}
