public virtual void deleteOperationLogEntryById(string entryId)
{
if (HistoryEventProduced)
{
DbEntityManager.delete(typeof(UserOperationLogEntryEventEntity), "deleteUserOperationLogEntryById", entryId);
}
}
public virtual void deleteHistoricIncidentsByJobDefinitionId(string jobDefinitionId)
{
if (HistoryEventProduced)
{
DbEntityManager.delete(typeof(HistoricIncidentEntity), "deleteHistoricIncidentsByJobDefinitionId", jobDefinitionId);
}
}
public virtual void deleteHistoricIdentityLinksLogByProcessDefinitionId(string processDefId)
{
if (HistoryEventProduced)
{
DbEntityManager.delete(typeof(HistoricIdentityLinkLogEntity), "deleteHistoricIdentityLinksByProcessDefinitionId", processDefId);
}
}
public virtual void deleteHistoricIncidentsByBatchId(IList <string> historicBatchIds)
{
if (HistoryEventProduced)
{
DbEntityManager.delete(typeof(HistoricIncidentEntity), "deleteHistoricIncidentsByBatchIds", historicBatchIds);
}
}
public virtual void deleteHistoricIdentityLinksLogByTaskId(string taskId)
{
if (HistoryEventProduced)
{
DbEntityManager.delete(typeof(HistoricIdentityLinkLogEntity), "deleteHistoricIdentityLinksByTaskId", taskId);
}
}
public virtual void deleteHistoricCaseActivityInstancesByCaseInstanceIds(IList <string> historicCaseInstanceIds)
{
if (HistoryEnabled)
{
DbEntityManager.delete(typeof(HistoricCaseActivityInstanceEntity), "deleteHistoricCaseActivityInstancesByCaseInstanceIds", historicCaseInstanceIds);
}
}
// byte array delete ////////////////////////////////////////////////////////
protected internal virtual void deleteExceptionByteArrayByParameterMap(string key, object value)
{
EnsureUtil.ensureNotNull(key, value);
IDictionary <string, object> parameterMap = new Dictionary <string, object>();
parameterMap[key] = value;
DbEntityManager.delete(typeof(ByteArrayEntity), "deleteExceptionByteArraysByIds", parameterMap);
}
public virtual void deleteExecution(ExecutionEntity execution)
{
DbEntityManager.delete(execution);
if (execution.ProcessInstanceExecution)
{
deleteAuthorizations(Resources.PROCESS_INSTANCE, execution.ProcessInstanceId);
}
}
public override void delete()
{
DbEntityManager dbEntityManger = Context.CommandContext.DbEntityManager;
dbEntityManger.delete(this);
byteArrayField.deleteByteArrayValue();
}
public virtual void deleteHistoricJobLogByBatchIds(IList <string> historicBatchIds)
{
if (HistoryEnabled)
{
deleteExceptionByteArrayByParameterMap("historicBatchIdIn", historicBatchIds);
DbEntityManager.delete(typeof(HistoricJobLogEventEntity), "deleteHistoricJobLogByBatchIds", historicBatchIds);
}
}
public Void execute(CommandContext commandContext)
{
DbEntityManager dbEntityManager = commandContext.DbEntityManager;
dbEntityManager.delete(outerInstance.dummySchemaLogEntry);
dbEntityManager.flush();
return(null);
}
public virtual void deleteHistoricJobLogsByDeploymentId(string deploymentId)
{
if (HistoryEnabled)
{
deleteExceptionByteArrayByParameterMap("deploymentId", deploymentId);
DbEntityManager.delete(typeof(HistoricJobLogEventEntity), "deleteHistoricJobLogByDeploymentId", deploymentId);
}
}
public virtual void deleteHistoricJobLogsByJobDefinitionId(string jobDefinitionId)
{
if (HistoryEnabled)
{
deleteExceptionByteArrayByParameterMap("jobDefinitionId", jobDefinitionId);
DbEntityManager.delete(typeof(HistoricJobLogEventEntity), "deleteHistoricJobLogByJobDefinitionId", jobDefinitionId);
}
}
public virtual void deleteHistoricJobLogsByHandlerType(string handlerType)
{
if (HistoryEnabled)
{
deleteExceptionByteArrayByParameterMap("handlerType", handlerType);
DbEntityManager.delete(typeof(HistoricJobLogEventEntity), "deleteHistoricJobLogByHandlerType", handlerType);
}
}
public virtual void deleteJob(JobEntity job, bool fireDeleteEvent)
{
DbEntityManager.delete(job);
if (fireDeleteEvent)
{
HistoricJobLogManager.fireJobDeletedEvent(job);
}
}
public virtual void deleteIdentityInfo(IdentityInfoEntity identityInfo)
{
DbEntityManager.delete(identityInfo);
if (IdentityInfoEntity.TYPE_USERACCOUNT.Equals(identityInfo.Type))
{
foreach (IdentityInfoEntity identityInfoDetail in findIdentityInfoDetails(identityInfo.Id))
{
DbEntityManager.delete(identityInfoDetail);
}
}
}
public object execute(CommandContext commandContext)
{
DbEntityManager dbEntityManager = commandContext.DbEntityManager;
PropertyEntity historyLevelProperty = dbEntityManager.selectById(typeof(PropertyEntity), "historyLevel");
if (historyLevelProperty != null)
{
dbEntityManager.delete(historyLevelProperty);
}
return(null);
}
public virtual void deleteByTimestampAndReporter(DateTime timestamp, string reporter)
{
IDictionary <string, object> parameters = new Dictionary <string, object>();
if (timestamp != null)
{
parameters["milliseconds"] = timestamp.Ticks;
}
parameters["reporter"] = reporter;
DbEntityManager.delete(typeof(MeterLogEntity), DELETE_ALL_METER_BY_TIMESTAMP_AND_REPORTER, parameters);
}
public virtual void deleteFilter(string filterId)
{
checkAuthorization(DELETE, FILTER, filterId);
FilterEntity filter = findFilterByIdInternal(filterId);
ensureNotNull("No filter found for filter id '" + filterId + "'", "filter", filter);
// delete all authorizations for this filter id
deleteAuthorizations(FILTER, filterId);
// delete the filter itself
DbEntityManager.delete(filter);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @SuppressWarnings("unchecked") public void deleteAttachmentsByTaskId(String taskId)
public virtual void deleteAttachmentsByTaskId(string taskId)
{
checkHistoryEnabled();
IList <AttachmentEntity> attachments = DbEntityManager.selectList("selectAttachmentsByTaskId", taskId);
foreach (AttachmentEntity attachment in attachments)
{
string contentId = attachment.ContentId;
if (!string.ReferenceEquals(contentId, null))
{
ByteArrayManager.deleteByteArrayById(contentId);
}
DbEntityManager.delete(attachment);
}
}
public virtual IdentityOperationResult deleteTenant(string tenantId)
{
checkAuthorization(Permissions.DELETE, Resources.TENANT, tenantId);
TenantEntity tenant = findTenantById(tenantId);
if (tenant != null)
{
deleteTenantMembershipsOfTenant(tenantId);
deleteAuthorizations(Resources.TENANT, tenantId);
DbEntityManager.delete(tenant);
return(new IdentityOperationResult(null, IdentityOperationResult.OPERATION_DELETE));
}
return(new IdentityOperationResult(null, IdentityOperationResult.OPERATION_NONE));
}
public virtual IdentityOperationResult deleteMembership(string userId, string groupId)
{
checkAuthorization(Permissions.DELETE, Resources.GROUP_MEMBERSHIP, groupId);
if (existsMembership(userId, groupId))
{
deleteAuthorizations(Resources.GROUP_MEMBERSHIP, groupId);
IDictionary <string, object> parameters = new Dictionary <string, object>();
parameters["userId"] = userId;
parameters["groupId"] = groupId;
DbEntityManager.delete(typeof(MembershipEntity), "deleteMembership", parameters);
return(new IdentityOperationResult(null, IdentityOperationResult.OPERATION_DELETE));
}
return(new IdentityOperationResult(null, IdentityOperationResult.OPERATION_NONE));
}
// delete authorizations //////////////////////////////////////////////////
public virtual void deleteAuthorizationsByResourceId(Resource resource, string resourceId)
{
if (string.ReferenceEquals(resourceId, null))
{
throw new System.ArgumentException("Resource id cannot be null");
}
if (AuthorizationEnabled)
{
IDictionary <string, object> deleteParams = new Dictionary <string, object>();
deleteParams["resourceType"] = resource.resourceType();
deleteParams["resourceId"] = resourceId;
DbEntityManager.delete(typeof(AuthorizationEntity), "deleteAuthorizationsForResourceId", deleteParams);
}
}
public virtual void deleteHistoricCaseInstancesByIds(IList <string> historicCaseInstanceIds)
{
if (HistoryEnabled)
{
HistoricDetailManager.deleteHistoricDetailsByCaseInstanceIds(historicCaseInstanceIds);
HistoricVariableInstanceManager.deleteHistoricVariableInstancesByCaseInstanceIds(historicCaseInstanceIds);
HistoricCaseActivityInstanceManager.deleteHistoricCaseActivityInstancesByCaseInstanceIds(historicCaseInstanceIds);
HistoricTaskInstanceManager.deleteHistoricTaskInstancesByCaseInstanceIds(historicCaseInstanceIds);
DbEntityManager.delete(typeof(HistoricCaseInstanceEntity), "deleteHistoricCaseInstancesByIds", historicCaseInstanceIds);
}
}
public virtual void deleteEventSubscription(EventSubscriptionEntity persistentObject)
{
DbEntityManager.delete(persistentObject);
if (persistentObject.isSubscriptionForEventType(EventType.SIGNAL))
{
createdSignalSubscriptions.Remove(persistentObject);
}
// if the event subscription has been triggered asynchronously but not yet executed
IList <JobEntity> asyncJobs = JobManager.findJobsByConfiguration(ProcessEventJobHandler.TYPE,persistentObject.Id,persistentObject.TenantId);
foreach (JobEntity asyncJob in asyncJobs)
{
asyncJob.delete();
}
}
public virtual IdentityOperationResult deleteTenantUserMembership(string tenantId, string userId)
{
checkAuthorization(Permissions.DELETE, Resources.TENANT_MEMBERSHIP, tenantId);
if (existsTenantMembership(tenantId, userId, null))
{
deleteAuthorizations(Resources.TENANT_MEMBERSHIP, userId);
deleteAuthorizationsForUser(Resources.TENANT, tenantId, userId);
IDictionary <string, object> parameters = new Dictionary <string, object>();
parameters["tenantId"] = tenantId;
parameters["userId"] = userId;
DbEntityManager.delete(typeof(TenantMembershipEntity), "deleteTenantMembership", parameters);
return(new IdentityOperationResult(null, IdentityOperationResult.OPERATION_DELETE));
}
return(new IdentityOperationResult(null, IdentityOperationResult.OPERATION_NONE));
}
//JAVA TO C# CONVERTER WARNING: 'final' parameters are not available in .NET:
//ORIGINAL LINE: public org.camunda.bpm.engine.impl.identity.IdentityOperationResult deleteGroup(final String groupId)
public virtual IdentityOperationResult deleteGroup(string groupId)
{
checkAuthorization(Permissions.DELETE, Resources.GROUP, groupId);
GroupEntity group = findGroupById(groupId);
if (group != null)
{
deleteMembershipsByGroupId(groupId);
deleteTenantMembershipsOfGroup(groupId);
deleteAuthorizations(Resources.GROUP, groupId);
Context.CommandContext.runWithoutAuthorization(new CallableAnonymousInnerClass2(this, groupId));
DbEntityManager.delete(group);
return(new IdentityOperationResult(null, IdentityOperationResult.OPERATION_DELETE));
}
return(new IdentityOperationResult(null, IdentityOperationResult.OPERATION_NONE));
}
//JAVA TO C# CONVERTER WARNING: 'final' parameters are not available in .NET:
//ORIGINAL LINE: public org.camunda.bpm.engine.impl.identity.IdentityOperationResult deleteUser(final String userId)
public virtual IdentityOperationResult deleteUser(string userId)
{
checkAuthorization(Permissions.DELETE, Resources.USER, userId);
UserEntity user = findUserById(userId);
if (user != null)
{
deleteMembershipsByUserId(userId);
deleteTenantMembershipsOfUser(userId);
deleteAuthorizations(Resources.USER, userId);
Context.CommandContext.runWithoutAuthorization(new CallableAnonymousInnerClass(this, userId));
DbEntityManager.delete(user);
return(new IdentityOperationResult(null, IdentityOperationResult.OPERATION_DELETE));
}
return(new IdentityOperationResult(null, IdentityOperationResult.OPERATION_NONE));
}
public virtual void deleteTask(TaskEntity task, string deleteReason, bool cascade, bool skipCustomListeners)
{
if (!task.Deleted)
{
task.Deleted = true;
CommandContext commandContext = Context.CommandContext;
string taskId = task.Id;
IList <Task> subTasks = findTasksByParentTaskId(taskId);
foreach (Task subTask in subTasks)
{
((TaskEntity)subTask).delete(deleteReason, cascade, skipCustomListeners);
}
task.deleteIdentityLinks(false);
commandContext.VariableInstanceManager.deleteVariableInstanceByTask(task);
if (cascade)
{
commandContext.HistoricTaskInstanceManager.deleteHistoricTaskInstanceById(taskId);
}
else
{
commandContext.HistoricTaskInstanceManager.markTaskInstanceEnded(taskId, deleteReason);
if (TaskEntity.DELETE_REASON_COMPLETED.Equals(deleteReason))
{
task.createHistoricTaskDetails(org.camunda.bpm.engine.history.UserOperationLogEntry_Fields.OPERATION_TYPE_COMPLETE);
}
else
{
task.createHistoricTaskDetails(org.camunda.bpm.engine.history.UserOperationLogEntry_Fields.OPERATION_TYPE_DELETE);
}
}
deleteAuthorizations(Resources.TASK, taskId);
DbEntityManager.delete(task);
}
}
//JAVA TO C# CONVERTER WARNING: 'final' parameters are not available in .NET:
//ORIGINAL LINE: public void deleteHistoricTaskInstanceById(final String taskId)
public virtual void deleteHistoricTaskInstanceById(string taskId)
{
if (HistoryEnabled)
{
HistoricTaskInstanceEntity historicTaskInstance = findHistoricTaskInstanceById(taskId);
if (historicTaskInstance != null)
{
CommandContext commandContext = Context.CommandContext;
commandContext.HistoricDetailManager.deleteHistoricDetailsByTaskId(taskId);
commandContext.HistoricVariableInstanceManager.deleteHistoricVariableInstancesByTaskId(taskId);
commandContext.CommentManager.deleteCommentsByTaskId(taskId);
commandContext.AttachmentManager.deleteAttachmentsByTaskId(taskId);
commandContext.HistoricIdentityLinkManager.deleteHistoricIdentityLinksLogByTaskId(taskId);
DbEntityManager.delete(historicTaskInstance);
}
}
}
