/// <summary>
/// customized insert behavior for HistoricVariableUpdateEventEntity </summary>
protected internal virtual void insertHistoricVariableUpdateEntity(HistoricVariableUpdateEventEntity historyEvent)
{
DbEntityManager dbEntityManager = DbEntityManager;
// insert update only if history level = FULL
if (shouldWriteHistoricDetail(historyEvent))
{
// insert byte array entity (if applicable)
sbyte[] byteValue = historyEvent.ByteValue;
if (byteValue != null)
{
ByteArrayEntity byteArrayEntity = new ByteArrayEntity(historyEvent.VariableName, byteValue, ResourceTypes.HISTORY);
byteArrayEntity.RootProcessInstanceId = historyEvent.RootProcessInstanceId;
byteArrayEntity.RemovalTime = historyEvent.RemovalTime;
Context.CommandContext.ByteArrayManager.insertByteArray(byteArrayEntity);
historyEvent.ByteArrayId = byteArrayEntity.Id;
}
dbEntityManager.insert(historyEvent);
}
// always insert/update HistoricProcessVariableInstance
if (historyEvent.isEventOfType(HistoryEventTypes.VARIABLE_INSTANCE_CREATE))
{
HistoricVariableInstanceEntity persistentObject = new HistoricVariableInstanceEntity(historyEvent);
dbEntityManager.insert(persistentObject);
}
else if (historyEvent.isEventOfType(HistoryEventTypes.VARIABLE_INSTANCE_UPDATE) || historyEvent.isEventOfType(HistoryEventTypes.VARIABLE_INSTANCE_MIGRATE))
{
HistoricVariableInstanceEntity historicVariableInstanceEntity = dbEntityManager.selectById(typeof(HistoricVariableInstanceEntity), historyEvent.VariableInstanceId);
if (historicVariableInstanceEntity != null)
{
historicVariableInstanceEntity.updateFromEvent(historyEvent);
historicVariableInstanceEntity.State = org.camunda.bpm.engine.history.HistoricVariableInstance_Fields.STATE_CREATED;
}
else
{
// #CAM-1344 / #SUPPORT-688
// this is a FIX for process instances which were started in camunda fox 6.1 and migrated to camunda BPM 7.0.
// in fox 6.1 the HistoricVariable instances were flushed to the DB when the process instance completed.
// Since fox 6.2 we populate the HistoricVariable table as we go.
HistoricVariableInstanceEntity persistentObject = new HistoricVariableInstanceEntity(historyEvent);
dbEntityManager.insert(persistentObject);
}
}
else if (historyEvent.isEventOfType(HistoryEventTypes.VARIABLE_INSTANCE_DELETE))
{
HistoricVariableInstanceEntity historicVariableInstanceEntity = dbEntityManager.selectById(typeof(HistoricVariableInstanceEntity), historyEvent.VariableInstanceId);
if (historicVariableInstanceEntity != null)
{
historicVariableInstanceEntity.State = org.camunda.bpm.engine.history.HistoricVariableInstance_Fields.STATE_DELETED;
}
}
}
/// <summary>
/// general history event insert behavior </summary>
protected internal virtual void insertOrUpdate(HistoryEvent historyEvent)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.camunda.bpm.engine.impl.db.entitymanager.DbEntityManager dbEntityManager = getDbEntityManager();
DbEntityManager dbEntityManager = DbEntityManager;
if (isInitialEvent(historyEvent))
{
dbEntityManager.insert(historyEvent);
}
else
{
if (dbEntityManager.getCachedEntity(historyEvent.GetType(), historyEvent.Id) == null)
{
if (historyEvent is HistoricScopeInstanceEvent)
{
// if this is a scope, get start time from existing event in DB
HistoricScopeInstanceEvent existingEvent = (HistoricScopeInstanceEvent)dbEntityManager.selectById(historyEvent.GetType(), historyEvent.Id);
if (existingEvent != null)
{
HistoricScopeInstanceEvent historicScopeInstanceEvent = (HistoricScopeInstanceEvent)historyEvent;
historicScopeInstanceEvent.StartTime = existingEvent.StartTime;
}
}
if (string.ReferenceEquals(historyEvent.Id, null))
{
// dbSqlSession.insert(historyEvent);
}
else
{
dbEntityManager.merge(historyEvent);
}
}
}
}
public override Void execute(CommandContext commandContext)
{
DbEntityManagerFactory dbEntityManagerFactory = new DbEntityManagerFactory(Context.ProcessEngineConfiguration.IdGenerator);
DbEntityManager newEntityManager = dbEntityManagerFactory.openSession();
HistoricProcessInstanceEventEntity hpi = new HistoricProcessInstanceEventEntity();
hpi.Id = id;
hpi.ProcessInstanceId = id;
hpi.ProcessDefinitionId = "someProcDefId";
hpi.StartTime = DateTime.Now;
hpi.State = org.camunda.bpm.engine.history.HistoricProcessInstance_Fields.STATE_ACTIVE;
newEntityManager.insert(hpi);
newEntityManager.flush();
monitor.sync();
DbEntityManager cmdEntityManager = commandContext.DbEntityManager;
cmdEntityManager.createHistoricProcessInstanceQuery().list();
monitor.sync();
return(null);
}
protected internal virtual void insertHistoricDecisionInstance(HistoricDecisionInstanceEntity historicDecisionInstance)
{
DbEntityManager.insert(historicDecisionInstance);
insertHistoricDecisionInputInstances(historicDecisionInstance.Inputs, historicDecisionInstance.Id);
insertHistoricDecisionOutputInstances(historicDecisionInstance.Outputs, historicDecisionInstance.Id);
}
public virtual IdentityOperationResult saveUser(User user)
{
UserEntity userEntity = (UserEntity)user;
// encrypt password
userEntity.encryptPassword();
string operation = null;
if (userEntity.Revision == 0)
{
operation = IdentityOperationResult.OPERATION_CREATE;
checkAuthorization(Permissions.CREATE, Resources.USER, null);
DbEntityManager.insert(userEntity);
createDefaultAuthorizations(userEntity);
}
else
{
operation = IdentityOperationResult.OPERATION_UPDATE;
checkAuthorization(Permissions.UPDATE, Resources.USER, user.Id);
DbEntityManager.merge(userEntity);
}
return(new IdentityOperationResult(userEntity, operation));
}
public virtual void insertJob(JobEntity job)
{
job.CreateTime = ClockUtil.CurrentTime;
DbEntityManager.insert(job);
HistoricJobLogManager.fireJobCreatedEvent(job);
}
public Void execute(CommandContext commandContext)
{
DbEntityManagerFactory dbEntityManagerFactory = new DbEntityManagerFactory(Context.ProcessEngineConfiguration.IdGenerator);
DbEntityManager newEntityManager = dbEntityManagerFactory.openSession();
newEntityManager.insert(outerInstance.dummySchemaLogEntry);
newEntityManager.flush();
return(null);
}
public virtual void setUserInfo(string userId, string userPassword, string type, string key, string value, string accountPassword, IDictionary <string, string> accountDetails)
{
sbyte[] storedPassword = null;
if (!string.ReferenceEquals(accountPassword, null))
{
storedPassword = encryptPassword(accountPassword, userPassword);
}
IdentityInfoEntity identityInfoEntity = findUserInfoByUserIdAndKey(userId, key);
if (identityInfoEntity != null)
{
// update
identityInfoEntity.Value = value;
identityInfoEntity.PasswordBytes = storedPassword;
if (accountDetails == null)
{
accountDetails = new Dictionary <string, string>();
}
ISet <string> newKeys = new HashSet <string>(accountDetails.Keys);
IList <IdentityInfoEntity> identityInfoDetails = findIdentityInfoDetails(identityInfoEntity.Id);
foreach (IdentityInfoEntity identityInfoDetail in identityInfoDetails)
{
string detailKey = identityInfoDetail.Key;
newKeys.remove(detailKey);
string newDetailValue = accountDetails[detailKey];
if (string.ReferenceEquals(newDetailValue, null))
{
deleteIdentityInfo(identityInfoDetail);
}
else
{
// update detail
identityInfoDetail.Value = newDetailValue;
}
}
insertAccountDetails(identityInfoEntity, accountDetails, newKeys);
}
else
{
// insert
identityInfoEntity = new IdentityInfoEntity();
identityInfoEntity.UserId = userId;
identityInfoEntity.Type = type;
identityInfoEntity.Key = key;
identityInfoEntity.Value = value;
identityInfoEntity.PasswordBytes = storedPassword;
DbEntityManager.insert(identityInfoEntity);
if (accountDetails != null)
{
insertAccountDetails(identityInfoEntity, accountDetails, accountDetails.Keys);
}
}
}
protected internal virtual void insertHistoricDecisionInputInstances(IList <HistoricDecisionInputInstance> inputs, string decisionInstanceId)
{
foreach (HistoricDecisionInputInstance input in inputs)
{
HistoricDecisionInputInstanceEntity inputEntity = (HistoricDecisionInputInstanceEntity)input;
inputEntity.DecisionInstanceId = decisionInstanceId;
DbEntityManager.insert(inputEntity);
}
}
protected internal virtual void insertHistoricDecisionOutputInstances(IList <HistoricDecisionOutputInstance> outputs, string decisionInstanceId)
{
foreach (HistoricDecisionOutputInstance output in outputs)
{
HistoricDecisionOutputInstanceEntity outputEntity = (HistoricDecisionOutputInstanceEntity)output;
outputEntity.DecisionInstanceId = decisionInstanceId;
DbEntityManager.insert(outputEntity);
}
}
private void insertAccountDetails(IdentityInfoEntity identityInfoEntity, IDictionary <string, string> accountDetails, ISet <string> keys)
{
foreach (string newKey in keys)
{
// insert detail
IdentityInfoEntity identityInfoDetail = new IdentityInfoEntity();
identityInfoDetail.ParentId = identityInfoEntity.Id;
identityInfoDetail.Key = newKey;
identityInfoDetail.Value = accountDetails[newKey];
DbEntityManager.insert(identityInfoDetail);
}
}
// membership //////////////////////////////////////////////////////
public virtual IdentityOperationResult createMembership(string userId, string groupId)
{
checkAuthorization(Permissions.CREATE, Resources.GROUP_MEMBERSHIP, groupId);
UserEntity user = findUserById(userId);
GroupEntity group = findGroupById(groupId);
MembershipEntity membership = new MembershipEntity();
membership.User = user;
membership.Group = group;
DbEntityManager.insert(membership);
createDefaultMembershipAuthorizations(userId, groupId);
return(new IdentityOperationResult(null, IdentityOperationResult.OPERATION_CREATE));
}
public virtual void insertDeployment(DeploymentEntity deployment)
{
DbEntityManager.insert(deployment);
createDefaultAuthorizations(deployment);
foreach (ResourceEntity resource in deployment.Resources.Values)
{
resource.DeploymentId = deployment.Id;
resource.Type = ResourceTypes.REPOSITORY.Value;
resource.CreateTime = ClockUtil.CurrentTime;
ResourceManager.insertResource(resource);
}
Context.ProcessEngineConfiguration.DeploymentCache.deploy(deployment);
}
public virtual IdentityOperationResult createTenantGroupMembership(string tenantId, string groupId)
{
checkAuthorization(Permissions.CREATE, Resources.TENANT_MEMBERSHIP, tenantId);
TenantEntity tenant = findTenantById(tenantId);
GroupEntity group = findGroupById(groupId);
ensureNotNull("No tenant found with id '" + tenantId + "'.", "tenant", tenant);
ensureNotNull("No group found with id '" + groupId + "'.", "group", group);
TenantMembershipEntity membership = new TenantMembershipEntity();
membership.Tenant = tenant;
membership.Group = group;
DbEntityManager.insert(membership);
createDefaultTenantMembershipAuthorizations(tenant, group);
return(new IdentityOperationResult(null, IdentityOperationResult.OPERATION_CREATE));
}
public virtual IdentityOperationResult saveGroup(Group group)
{
GroupEntity groupEntity = (GroupEntity)group;
string operation = null;
if (groupEntity.Revision == 0)
{
operation = IdentityOperationResult.OPERATION_CREATE;
checkAuthorization(Permissions.CREATE, Resources.GROUP, null);
DbEntityManager.insert(groupEntity);
createDefaultAuthorizations(group);
}
else
{
operation = IdentityOperationResult.OPERATION_UPDATE;
checkAuthorization(Permissions.UPDATE, Resources.GROUP, group.Id);
DbEntityManager.merge(groupEntity);
}
return(new IdentityOperationResult(groupEntity, operation));
}
public virtual IdentityOperationResult saveTenant(Tenant tenant)
{
TenantEntity tenantEntity = (TenantEntity)tenant;
string operation = null;
if (tenantEntity.Revision == 0)
{
operation = IdentityOperationResult.OPERATION_CREATE;
checkAuthorization(Permissions.CREATE, Resources.TENANT, null);
DbEntityManager.insert(tenantEntity);
createDefaultAuthorizations(tenant);
}
else
{
operation = IdentityOperationResult.OPERATION_UPDATE;
checkAuthorization(Permissions.UPDATE, Resources.TENANT, tenant.Id);
DbEntityManager.merge(tenantEntity);
}
return(new IdentityOperationResult(tenantEntity, operation));
}
public virtual IdentityOperationResult createTenantUserMembership(string tenantId, string userId)
{
checkAuthorization(Permissions.CREATE, Resources.TENANT_MEMBERSHIP, tenantId);
TenantEntity tenant = findTenantById(tenantId);
UserEntity user = findUserById(userId);
ensureNotNull("No tenant found with id '" + tenantId + "'.", "tenant", tenant);
ensureNotNull("No user found with id '" + userId + "'.", "user", user);
TenantMembershipEntity membership = new TenantMembershipEntity();
membership.Tenant = tenant;
membership.User = user;
DbEntityManager.insert(membership);
createDefaultTenantMembershipAuthorizations(tenant, user);
return(new IdentityOperationResult(null, IdentityOperationResult.OPERATION_CREATE));
}
public virtual Filter insertOrUpdateFilter(Filter filter)
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: org.camunda.bpm.engine.impl.AbstractQuery<?, ?> query = filter.getQuery();
AbstractQuery <object, ?> query = filter.Query;
query.validate(StoredQueryValidator.get());
if (string.ReferenceEquals(filter.Id, null))
{
checkAuthorization(CREATE, FILTER, ANY);
DbEntityManager.insert((FilterEntity)filter);
createDefaultAuthorizations(filter);
}
else
{
checkAuthorization(UPDATE, FILTER, filter.Id);
DbEntityManager.merge((FilterEntity)filter);
}
return(filter);
}
public virtual void insertResource(ResourceEntity resource)
{
DbEntityManager.insert(resource);
}
public virtual void insert(MeterLogEntity meterLogEntity)
{
DbEntityManager.insert(meterLogEntity);
}
public virtual void insert(DbEntity dbEntity)
{
DbEntityManager.insert(dbEntity);
}
public virtual Attachment execute(CommandContext commandContext)
{
if (!string.ReferenceEquals(taskId, null))
{
task = commandContext.TaskManager.findTaskById(taskId);
}
else
{
ensureNotNull("taskId or processInstanceId has to be provided", this.processInstanceId);
IList <ExecutionEntity> executionsByProcessInstanceId = commandContext.ExecutionManager.findExecutionsByProcessInstanceId(processInstanceId);
processInstance = executionsByProcessInstanceId[0];
}
AttachmentEntity attachment = new AttachmentEntity();
attachment.Name = attachmentName;
attachment.Description = attachmentDescription;
attachment.Type = attachmentType;
attachment.TaskId = taskId;
attachment.ProcessInstanceId = processInstanceId;
attachment.Url = url;
attachment.CreateTime = ClockUtil.CurrentTime;
if (task != null)
{
ExecutionEntity execution = task.getExecution();
if (execution != null)
{
attachment.RootProcessInstanceId = execution.RootProcessInstanceId;
}
}
else if (processInstance != null)
{
attachment.RootProcessInstanceId = processInstance.RootProcessInstanceId;
}
if (HistoryRemovalTimeStrategyStart)
{
provideRemovalTime(attachment);
}
DbEntityManager dbEntityManger = commandContext.DbEntityManager;
dbEntityManger.insert(attachment);
if (content != null)
{
sbyte[] bytes = IoUtil.readInputStream(content, attachmentName);
ByteArrayEntity byteArray = new ByteArrayEntity(bytes, ResourceTypes.HISTORY);
byteArray.RootProcessInstanceId = attachment.RootProcessInstanceId;
byteArray.RemovalTime = attachment.RemovalTime;
commandContext.ByteArrayManager.insertByteArray(byteArray);
attachment.ContentId = byteArray.Id;
}
PropertyChange propertyChange = new PropertyChange("name", null, attachmentName);
if (task != null)
{
commandContext.OperationLogManager.logAttachmentOperation(org.camunda.bpm.engine.history.UserOperationLogEntry_Fields.OPERATION_TYPE_ADD_ATTACHMENT, task, propertyChange);
}
else if (processInstance != null)
{
commandContext.OperationLogManager.logAttachmentOperation(org.camunda.bpm.engine.history.UserOperationLogEntry_Fields.OPERATION_TYPE_ADD_ATTACHMENT, processInstance, propertyChange);
}
return(attachment);
}
// insert ///////////////////////////////////////////////////////////
public virtual void insertProcessDefinition(ProcessDefinitionEntity processDefinition)
{
DbEntityManager.insert(processDefinition);
createDefaultAuthorizations(processDefinition);
}
public virtual void insertByteArray(ByteArrayEntity arr)
{
arr.CreateTime = ClockUtil.CurrentTime;
DbEntityManager.insert(arr);
}
public virtual void insertCaseSentryPart(CaseSentryPartEntity caseSentryPart)
{
DbEntityManager.insert(caseSentryPart);
}
public virtual void insert(ExternalTaskEntity externalTask)
{
DbEntityManager.insert(externalTask);
fireExternalTaskAvailableEvent();
}
public virtual void insertTask(TaskEntity task)
{
DbEntityManager.insert(task);
createDefaultAuthorizations(task);
}
public virtual void insertHistoricCaseActivityInstance(HistoricCaseActivityInstanceEntity historicCaseActivityInstance)
{
DbEntityManager.insert(historicCaseActivityInstance);
}
public virtual void insertDecisionDefinition(DecisionDefinitionEntity decisionDefinition)
{
DbEntityManager.insert(decisionDefinition);
createDefaultAuthorizations(decisionDefinition);
}
public override void insert(DbEntity authorization)
{
checkAuthorization(CREATE, AUTHORIZATION, null);
DbEntityManager.insert(authorization);
}
