Merge branch 'master' of https://github.com/flowable/flowable-engine

modules/flowable-cmmn-api/pom.xml

@@ -26,6 +26,10 @@
             <groupId>org.flowable</groupId>
             <artifactId>flowable-variable-service-api</artifactId>
         </dependency>
+        <dependency>
+            <groupId>org.flowable</groupId>
+            <artifactId>flowable-task-service-api</artifactId>
+        </dependency>
     </dependencies>
 
 </project>
\ No newline at end of file

modules/flowable-cmmn-api/src/main/java/org/flowable/cmmn/engine/CmmnHistoryService.java

@@ -15,6 +15,7 @@ package org.flowable.cmmn.engine;
 import org.flowable.cmmn.engine.history.HistoricCaseInstanceQuery;
 import org.flowable.cmmn.engine.history.HistoricMilestoneInstanceQuery;
 import org.flowable.cmmn.engine.history.HistoricVariableInstanceQuery;
+import org.flowable.task.service.history.HistoricTaskInstanceQuery;
 
 /**
  * @author Joram Barrez
@@ -26,6 +27,8 @@ public interface CmmnHistoryService {
     HistoricMilestoneInstanceQuery createHistoricMilestoneInstanceQuery();
     
     HistoricVariableInstanceQuery createHistoricVariableInstanceQuery();
+    
+    HistoricTaskInstanceQuery createHistoricTaskInstanceQuery();
 
     void deleteHistoricCaseInstance(String caseInstanceId);
 }

modules/flowable-cmmn-api/src/main/java/org/flowable/cmmn/engine/CmmnTaskService.java

+/* Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.flowable.cmmn.engine;
+
+import java.util.Map;
+
+import org.flowable.task.service.TaskQuery;
+
+/**
+ * @author Joram Barrez
+ */
+public interface CmmnTaskService {
+
+    void complete(String taskId);
+    
+    void complete(String taskId, Map<String, Object> variables);
+    
+    void complete(String taskId, Map<String, Object> variables, Map<String, Object> transientVariables);
+    
+    TaskQuery createTaskQuery();
+    
+}

modules/flowable-cmmn-converter/src/main/java/org/flowable/cmmn/converter/CmmnXmlConstants.java

@@ -94,6 +94,15 @@ public interface CmmnXmlConstants {
     String ELEMENT_FIELD_STRING = "string";
     String ELEMENT_FIELD_EXPRESSION = "expression";
     
+    String ATTRIBUTE_ASSIGNEE = "assignee";
+    String ATTRIBUTE_OWNER = "owner";
+    String ATTRIBUTE_PRIORITY = "priority";
+    String ATTRIBUTE_FORM_KEY = "formKey";
+    String ATTRIBUTE_DUE_DATE = "dueDate";
+    String ATTRIBUTE_CATEGORY = "category";
+    String ATTRIBUTE_USER_CANDIDATEUSERS = "candidateUsers";
+    String ATTRIBUTE_USER_CANDIDATEGROUPS = "candidateGroups";
+    
     String ELEMENT_DI_CMMN = "CMMNDI";
     String ELEMENT_DI_DIAGRAM = "CMMNDiagram";
     String ELEMENT_DI_SHAPE = "CMMNShape";

modules/flowable-cmmn-converter/src/main/java/org/flowable/cmmn/converter/HumanTaskXmlConverter.java

@@ -14,6 +14,7 @@ package org.flowable.cmmn.converter;
 
 import javax.xml.stream.XMLStreamReader;
 
+import org.apache.commons.lang3.StringUtils;
 import org.flowable.cmmn.model.CmmnElement;
 import org.flowable.cmmn.model.HumanTask;
 
@@ -31,6 +32,30 @@ public class HumanTaskXmlConverter extends TaskXmlConverter {
     protected CmmnElement convert(XMLStreamReader xtr, ConversionHelper conversionHelper) {
         HumanTask task = new HumanTask();
         convertCommonTaskAttributes(xtr, task);
+        
+        task.setAssignee(xtr.getAttributeValue(CmmnXmlConstants.FLOWABLE_EXTENSIONS_NAMESPACE, CmmnXmlConstants.ATTRIBUTE_ASSIGNEE));
+        task.setOwner(xtr.getAttributeValue(CmmnXmlConstants.FLOWABLE_EXTENSIONS_NAMESPACE, CmmnXmlConstants.ATTRIBUTE_OWNER));
+        task.setPriority(xtr.getAttributeValue(CmmnXmlConstants.FLOWABLE_EXTENSIONS_NAMESPACE, CmmnXmlConstants.ATTRIBUTE_PRIORITY));
+        task.setFormKey(xtr.getAttributeValue(CmmnXmlConstants.FLOWABLE_EXTENSIONS_NAMESPACE, CmmnXmlConstants.ATTRIBUTE_FORM_KEY));
+        task.setDueDate(xtr.getAttributeValue(CmmnXmlConstants.FLOWABLE_EXTENSIONS_NAMESPACE, CmmnXmlConstants.ATTRIBUTE_DUE_DATE));
+        task.setCategory(xtr.getAttributeValue(CmmnXmlConstants.FLOWABLE_EXTENSIONS_NAMESPACE, CmmnXmlConstants.ATTRIBUTE_CATEGORY));
+        
+        String candidateUsersString =  xtr.getAttributeValue(CmmnXmlConstants.FLOWABLE_EXTENSIONS_NAMESPACE, CmmnXmlConstants.ATTRIBUTE_USER_CANDIDATEUSERS);
+        if (StringUtils.isNotEmpty(candidateUsersString)) {
+            String[] candidateUsers = candidateUsersString.split(",");
+            for (String candidateUser : candidateUsers) {
+                task.getCandidateUsers().add(candidateUser);
+            }
+        }
+        
+        String candidateGroupsString =  xtr.getAttributeValue(CmmnXmlConstants.FLOWABLE_EXTENSIONS_NAMESPACE, CmmnXmlConstants.ATTRIBUTE_USER_CANDIDATEGROUPS);
+        if (StringUtils.isNotEmpty(candidateGroupsString)) {
+            String[] candidateGroups = candidateGroupsString.split(",");
+            for (String candidateGroup : candidateGroups) {
+                task.getCandidateUsers().add(candidateGroup);
+            }
+        }
+        
         return task;
     }
 

modules/flowable-cmmn-engine-configurator/src/main/java/org/flowable/cmmn/engine/configurator/CmmnEngineConfigurator.java

@@ -65,6 +65,10 @@ public class CmmnEngineConfigurator extends AbstractEngineConfigurator {
         initialiseCommonProperties(processEngineConfiguration, cmmnEngineConfiguration);
         initProcessInstanceService(processEngineConfiguration);
         initProcessInstanceStateChangedCallbacks(processEngineConfiguration);
+        
+        cmmnEngineConfiguration.setEnableTaskRelationshipCounts(processEngineConfiguration.getPerformanceSettings().isEnableTaskRelationshipCounts());
+        cmmnEngineConfiguration.setTaskQueryLimit(processEngineConfiguration.getTaskQueryLimit());
+        cmmnEngineConfiguration.setHistoricTaskQueryLimit(processEngineConfiguration.getHistoricTaskQueryLimit());
 
         initCmmnEngine();
     }

modules/flowable-cmmn-engine-configurator/src/test/java/org/flowable/cmmn/test/AbstractProcessEngineIntegrationTest.java

@@ -17,6 +17,7 @@ import org.flowable.cmmn.engine.CmmnHistoryService;
 import org.flowable.cmmn.engine.CmmnManagementService;
 import org.flowable.cmmn.engine.CmmnRepositoryService;
 import org.flowable.cmmn.engine.CmmnRuntimeService;
+import org.flowable.cmmn.engine.CmmnTaskService;
 import org.flowable.cmmn.engine.test.impl.CmmnTestRunner;
 import org.flowable.engine.ProcessEngine;
 import org.flowable.engine.ProcessEngineConfiguration;
@@ -41,6 +42,7 @@ public abstract class AbstractProcessEngineIntegrationTest {
 
     protected CmmnRepositoryService cmmnRepositoryService;
     protected CmmnRuntimeService cmmnRuntimeService;
+    protected CmmnTaskService cmmnTaskService;
     protected CmmnHistoryService cmmnHistoryService;
     protected CmmnManagementService cmmnManagementService;
 
@@ -53,7 +55,7 @@ public abstract class AbstractProcessEngineIntegrationTest {
         if (processEngine == null) {
             processEngine = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("flowable.cfg.xml").buildProcessEngine();
             cmmnEngineConfiguration = (CmmnEngineConfiguration) processEngine.getProcessEngineConfiguration()
-                            .getEngineConfigurations().get(EngineConfigurationConstants.KEY_CMMN_ENGINE_CONFIG);
+                    .getEngineConfigurations().get(EngineConfigurationConstants.KEY_CMMN_ENGINE_CONFIG);
             CmmnTestRunner.setCmmnEngineConfiguration(cmmnEngineConfiguration);
         }
     }
@@ -62,6 +64,7 @@ public abstract class AbstractProcessEngineIntegrationTest {
     public void setupServices() {
         this.cmmnRepositoryService = cmmnEngineConfiguration.getCmmnRepositoryService();
         this.cmmnRuntimeService = cmmnEngineConfiguration.getCmmnRuntimeService();
+        this.cmmnTaskService = cmmnEngineConfiguration.getCmmnTaskService();
         this.cmmnHistoryService = cmmnEngineConfiguration.getCmmnHistoryService();
         this.cmmnManagementService = cmmnEngineConfiguration.getCmmnManagementService();
 

modules/flowable-cmmn-engine/src/main/java/org/flowable/cmmn/engine/CmmnEngine.java

@@ -30,6 +30,8 @@ public interface CmmnEngine {
     
     CmmnRuntimeService getCmmnRuntimeService();
     
+    CmmnTaskService getCmmnTaskService();
+    
     CmmnManagementService getCmmnManagementService();
     
     CmmnRepositoryService getCmmnRepositoryService();

modules/flowable-cmmn-engine/src/main/java/org/flowable/cmmn/engine/CmmnEngineConfiguration.java

@@ -28,6 +28,7 @@ import org.flowable.cmmn.engine.impl.CmmnEngineImpl;
 import org.flowable.cmmn.engine.impl.CmmnHistoryServiceImpl;
 import org.flowable.cmmn.engine.impl.CmmnManagementServiceImpl;
 import org.flowable.cmmn.engine.impl.CmmnRepositoryServiceImpl;
+import org.flowable.cmmn.engine.impl.CmmnTaskServiceImpl;
 import org.flowable.cmmn.engine.impl.ServiceImpl;
 import org.flowable.cmmn.engine.impl.agenda.CmmnEngineAgendaFactory;
 import org.flowable.cmmn.engine.impl.agenda.CmmnEngineAgendaSessionFactory;
@@ -44,6 +45,7 @@ import org.flowable.cmmn.engine.impl.deployer.CmmnDeploymentManager;
 import org.flowable.cmmn.engine.impl.deployer.Deployer;
 import org.flowable.cmmn.engine.impl.el.CmmnExpressionManager;
 import org.flowable.cmmn.engine.impl.history.CmmnHistoryManager;
+import org.flowable.cmmn.engine.impl.history.CmmnHistoryTaskManager;
 import org.flowable.cmmn.engine.impl.history.CmmnHistoryVariableManager;
 import org.flowable.cmmn.engine.impl.history.DefaultCmmnHistoryManager;
 import org.flowable.cmmn.engine.impl.interceptor.CmmnCommandInvoker;
@@ -94,6 +96,7 @@ import org.flowable.cmmn.engine.impl.process.ProcessInstanceService;
 import org.flowable.cmmn.engine.impl.runtime.CaseInstanceHelper;
 import org.flowable.cmmn.engine.impl.runtime.CaseInstanceHelperImpl;
 import org.flowable.cmmn.engine.impl.runtime.CmmnRuntimeServiceImpl;
+import org.flowable.cmmn.engine.impl.task.DefaultCmmnTaskVariableScopeResolver;
 import org.flowable.engine.common.AbstractEngineConfiguration;
 import org.flowable.engine.common.api.delegate.FlowableFunctionDelegate;
 import org.flowable.engine.common.impl.callback.RuntimeInstanceStateChangeCallback;
@@ -110,6 +113,11 @@ import org.flowable.engine.common.impl.persistence.cache.EntityCacheImpl;
 import org.flowable.engine.common.impl.persistence.deploy.DefaultDeploymentCache;
 import org.flowable.engine.common.impl.persistence.deploy.DeploymentCache;
 import org.flowable.engine.common.impl.persistence.entity.Entity;
+import org.flowable.identitylink.service.IdentityLinkServiceConfiguration;
+import org.flowable.identitylink.service.impl.db.IdentityLinkDbSchemaManager;
+import org.flowable.task.service.InternalTaskVariableScopeResolver;
+import org.flowable.task.service.TaskServiceConfiguration;
+import org.flowable.task.service.history.InternalHistoryTaskManager;
 import org.flowable.task.service.impl.db.TaskDbSchemaManager;
 import org.flowable.variable.service.VariableServiceConfiguration;
 import org.flowable.variable.service.history.InternalHistoryVariableManager;
@@ -150,6 +158,7 @@ public class CmmnEngineConfiguration extends AbstractEngineConfiguration impleme
     protected CmmnEngineAgendaFactory cmmnEngineAgendaFactory;
 
     protected CmmnRuntimeService cmmnRuntimeService = new CmmnRuntimeServiceImpl();
+    protected CmmnTaskService cmmnTaskService = new CmmnTaskServiceImpl();
     protected CmmnManagementService cmmnManagementService = new CmmnManagementServiceImpl();
     protected CmmnRepositoryService cmmnRepositoryService = new CmmnRepositoryServiceImpl();
     protected CmmnHistoryService cmmnHistoryService = new CmmnHistoryServiceImpl();
@@ -207,9 +216,22 @@ public class CmmnEngineConfiguration extends AbstractEngineConfiguration impleme
      */
     protected DelegateExpressionFieldInjectionMode delegateExpressionFieldInjectionMode = DelegateExpressionFieldInjectionMode.MIXED;
 
-    // Variable support
+    protected DbSchemaManager identityLinkDbSchemaManager;
     protected DbSchemaManager variableDbSchemaManager;
     protected DbSchemaManager taskDbSchemaManager;
+    
+    // Identitylink support
+    protected IdentityLinkServiceConfiguration identityLinkServiceConfiguration;
+    
+    // Task support
+    protected TaskServiceConfiguration taskServiceConfiguration;
+    protected InternalHistoryTaskManager internalHistoryTaskManager;
+    protected InternalTaskVariableScopeResolver internalTaskVariableScopeResolver;
+    protected boolean isEnableTaskRelationshipCounts;
+    protected int taskQueryLimit;
+    protected int historicTaskQueryLimit;
+    
+    // Variable support
     protected VariableTypes variableTypes;
     protected List<VariableType> customPreVariableTypes;
     protected List<VariableType> customPostVariableTypes;
@@ -285,7 +307,9 @@ public class CmmnEngineConfiguration extends AbstractEngineConfiguration impleme
         initHistoryManager();
         initCaseInstanceCallbacks();
         initClock();
+        initIdentityLinkServiceConfiguration();
         initVariableServiceConfiguration();
+        initTaskServiceConfiguration();
     }
 
     @Override
@@ -293,6 +317,7 @@ public class CmmnEngineConfiguration extends AbstractEngineConfiguration impleme
     public void initDbSchemaManager() {
         super.initDbSchemaManager();
         initCmmnDbSchemaManager();
+        initIdentityLinkDbSchemaManager();
         initVariableDbSchemaManager();
         initTaskDbSchemaManager();
     }
@@ -314,6 +339,12 @@ public class CmmnEngineConfiguration extends AbstractEngineConfiguration impleme
             this.taskDbSchemaManager = new TaskDbSchemaManager();
         }
     }
+    
+    protected void initIdentityLinkDbSchemaManager() {
+        if (this.identityLinkDbSchemaManager == null) {
+            this.identityLinkDbSchemaManager = new IdentityLinkDbSchemaManager();
+        }
+    }
 
     @Override
     public void initMybatisTypeHandlers(Configuration configuration) {
@@ -369,6 +400,7 @@ public class CmmnEngineConfiguration extends AbstractEngineConfiguration impleme
 
     protected void initServices() {
         initService(cmmnRuntimeService);
+        initService(cmmnTaskService);;
         initService(cmmnManagementService);
         initService(cmmnRepositoryService);
         initService(cmmnHistoryService);
@@ -623,6 +655,46 @@ public class CmmnEngineConfiguration extends AbstractEngineConfiguration impleme
 
         addServiceConfiguration(EngineConfigurationConstants.KEY_VARIABLE_SERVICE_CONFIG, this.variableServiceConfiguration);
     }
+    
+    public void initTaskServiceConfiguration() {
+        this.taskServiceConfiguration = new TaskServiceConfiguration();
+        this.taskServiceConfiguration.setHistoryLevel(this.historyLevel);
+        this.taskServiceConfiguration.setClock(this.clock);
+        this.taskServiceConfiguration.setObjectMapper(this.objectMapper);
+        this.taskServiceConfiguration.setEventDispatcher(this.eventDispatcher);
+
+        if (this.internalHistoryTaskManager != null) {
+            this.taskServiceConfiguration.setInternalHistoryTaskManager(this.internalHistoryTaskManager);
+        } else {
+            this.taskServiceConfiguration.setInternalHistoryTaskManager(new CmmnHistoryTaskManager(cmmnHistoryManager));
+        }
+
+        if (this.internalTaskVariableScopeResolver != null) {
+            this.taskServiceConfiguration.setInternalTaskVariableScopeResolver(this.internalTaskVariableScopeResolver);
+        } else {
+            this.taskServiceConfiguration.setInternalTaskVariableScopeResolver(new DefaultCmmnTaskVariableScopeResolver(this));
+        }
+
+        this.taskServiceConfiguration.setEnableTaskRelationshipCounts(this.isEnableTaskRelationshipCounts);
+        this.taskServiceConfiguration.setTaskQueryLimit(this.taskQueryLimit);
+        this.taskServiceConfiguration.setHistoricTaskQueryLimit(this.historicTaskQueryLimit);
+
+        this.taskServiceConfiguration.init();
+
+        addServiceConfiguration(EngineConfigurationConstants.KEY_TASK_SERVICE_CONFIG, this.taskServiceConfiguration);
+    }
+    
+    public void initIdentityLinkServiceConfiguration() {
+        this.identityLinkServiceConfiguration = new IdentityLinkServiceConfiguration();
+        this.identityLinkServiceConfiguration.setHistoryLevel(this.historyLevel);
+        this.identityLinkServiceConfiguration.setClock(this.clock);
+        this.identityLinkServiceConfiguration.setObjectMapper(this.objectMapper);
+        this.identityLinkServiceConfiguration.setEventDispatcher(this.eventDispatcher);
+
+        this.identityLinkServiceConfiguration.init();
+
+        addServiceConfiguration(EngineConfigurationConstants.KEY_IDENTITY_LINK_SERVICE_CONFIG, this.identityLinkServiceConfiguration);
+    }
 
     @Override
     public String getEngineName() {
@@ -638,6 +710,7 @@ public class CmmnEngineConfiguration extends AbstractEngineConfiguration impleme
         return this;
     }
 
+    @Override
     public CmmnRuntimeService getCmmnRuntimeService() {
         return cmmnRuntimeService;
     }
@@ -646,7 +719,17 @@ public class CmmnEngineConfiguration extends AbstractEngineConfiguration impleme
         this.cmmnRuntimeService = cmmnRuntimeService;
         return this;
     }
+    
+    public CmmnTaskService getCmmnTaskService() {
+        return cmmnTaskService;
+    }
+
+    public CmmnEngineConfiguration setCmmnTaskService(CmmnTaskService cmmnTaskService) {
+        this.cmmnTaskService = cmmnTaskService;
+        return this;
+    }
 
+    @Override
     public CmmnManagementService getCmmnManagementService() {
         return cmmnManagementService;
     }
@@ -656,6 +739,7 @@ public class CmmnEngineConfiguration extends AbstractEngineConfiguration impleme
         return this;
     }
 
+    @Override
     public CmmnRepositoryService getCmmnRepositoryService() {
         return cmmnRepositoryService;
     }
@@ -665,6 +749,7 @@ public class CmmnEngineConfiguration extends AbstractEngineConfiguration impleme
         return this;
     }
 
+    @Override
     public CmmnHistoryService getCmmnHistoryService() {
         return cmmnHistoryService;
     }
@@ -1039,6 +1124,15 @@ public class CmmnEngineConfiguration extends AbstractEngineConfiguration impleme
         this.customFlowableFunctionDelegates = customFlowableFunctionDelegates;
         return this;
     }
+    
+    public DbSchemaManager getIdentityLinkDbSchemaManager() {
+        return identityLinkDbSchemaManager;
+    }
+
+    public CmmnEngineConfiguration setIdentityLinkDbSchemaManager(DbSchemaManager identityLinkDbSchemaManager) {
+        this.identityLinkDbSchemaManager = identityLinkDbSchemaManager;
+        return this;
+    }
 
     public DbSchemaManager getVariableDbSchemaManager() {
         return variableDbSchemaManager;
@@ -1084,6 +1178,15 @@ public class CmmnEngineConfiguration extends AbstractEngineConfiguration impleme
         this.customPostVariableTypes = customPostVariableTypes;
         return this;
     }
+    
+    public IdentityLinkServiceConfiguration getIdentityLinkServiceConfiguration() {
+        return identityLinkServiceConfiguration;
+    }
+
+    public CmmnEngineConfiguration setIdentityLinkServiceConfiguration(IdentityLinkServiceConfiguration identityLinkServiceConfiguration) {
+        this.identityLinkServiceConfiguration = identityLinkServiceConfiguration;
+        return this;
+    }
 
     public VariableServiceConfiguration getVariableServiceConfiguration() {
         return variableServiceConfiguration;
@@ -1094,6 +1197,60 @@ public class CmmnEngineConfiguration extends AbstractEngineConfiguration impleme
         return this;
     }
     
+    public TaskServiceConfiguration getTaskServiceConfiguration() {
+        return taskServiceConfiguration;
+    }
+
+    public CmmnEngineConfiguration setTaskServiceConfiguration(TaskServiceConfiguration taskServiceConfiguration) {
+        this.taskServiceConfiguration = taskServiceConfiguration;
+        return this;
+    }
+    
+    public InternalHistoryTaskManager getInternalHistoryTaskManager() {
+        return internalHistoryTaskManager;
+    }
+
+    public CmmnEngineConfiguration setInternalHistoryTaskManager(InternalHistoryTaskManager internalHistoryTaskManager) {
+        this.internalHistoryTaskManager = internalHistoryTaskManager;
+        return this;
+    }
+    
+    public InternalTaskVariableScopeResolver getInternalTaskVariableScopeResolver() {
+        return internalTaskVariableScopeResolver;
+    }
+
+    public CmmnEngineConfiguration setInternalTaskVariableScopeResolver(InternalTaskVariableScopeResolver internalTaskVariableScopeResolver) {
+        this.internalTaskVariableScopeResolver = internalTaskVariableScopeResolver;
+        return this;
+    }
+
+    public boolean isEnableTaskRelationshipCounts() {
+        return isEnableTaskRelationshipCounts;
+    }
+
+    public CmmnEngineConfiguration setEnableTaskRelationshipCounts(boolean isEnableTaskRelationshipCounts) {
+        this.isEnableTaskRelationshipCounts = isEnableTaskRelationshipCounts;
+        return this;
+    }
+
+    public int getTaskQueryLimit() {
+        return taskQueryLimit;
+    }
+
+    public CmmnEngineConfiguration setTaskQueryLimit(int taskQueryLimit) {
+        this.taskQueryLimit = taskQueryLimit;
+        return this;
+    }
+
+    public int getHistoricTaskQueryLimit() {
+        return historicTaskQueryLimit;
+    }
+
+    public CmmnEngineConfiguration setHistoricTaskQueryLimit(int historicTaskQueryLimit) {
+        this.historicTaskQueryLimit = historicTaskQueryLimit;
+        return this;
+    }
+
     public InternalHistoryVariableManager getInternalHistoryVariableManager() {
         return internalHistoryVariableManager;
     }

modules/flowable-cmmn-engine/src/main/java/org/flowable/cmmn/engine/impl/CmmnEngineImpl.java

@@ -18,6 +18,7 @@ import org.flowable.cmmn.engine.CmmnHistoryService;
 import org.flowable.cmmn.engine.CmmnManagementService;
 import org.flowable.cmmn.engine.CmmnRepositoryService;
 import org.flowable.cmmn.engine.CmmnRuntimeService;
+import org.flowable.cmmn.engine.CmmnTaskService;
 import org.flowable.cmmn.engine.impl.cmd.SchemaOperationsCmmnEngineBuild;
 import org.flowable.engine.common.impl.interceptor.CommandExecutor;
 import org.slf4j.Logger;
@@ -33,6 +34,7 @@ public class CmmnEngineImpl implements CmmnEngine {
     protected String name;
     protected CmmnEngineConfiguration cmmnEngineConfiguration;
     protected CmmnRuntimeService cmmnRuntimeService;
+    protected CmmnTaskService cmmnTaskService;
     protected CmmnManagementService cmmnManagementService;
     protected CmmnRepositoryService cmmnRepositoryService;
     protected CmmnHistoryService cmmnHistoryService;
@@ -41,6 +43,7 @@ public class CmmnEngineImpl implements CmmnEngine {
         this.cmmnEngineConfiguration = cmmnEngineConfiguration;
         this.name = cmmnEngineConfiguration.getEngineName();
         this.cmmnRuntimeService = cmmnEngineConfiguration.getCmmnRuntimeService();
+        this.cmmnTaskService = cmmnEngineConfiguration.getCmmnTaskService();
         this.cmmnManagementService = cmmnEngineConfiguration.getCmmnManagementService();
         this.cmmnRepositoryService = cmmnEngineConfiguration.getCmmnRepositoryService();
         this.cmmnHistoryService = cmmnEngineConfiguration.getCmmnHistoryService();
@@ -53,6 +56,7 @@ public class CmmnEngineImpl implements CmmnEngine {
         LOGGER.info("CmmnEngine {} created", name);
     }
     
+    @Override
     public String getName() {
         return name;
     }
@@ -74,6 +78,7 @@ public class CmmnEngineImpl implements CmmnEngine {
         this.cmmnEngineConfiguration = cmmnEngineConfiguration;
     }
     
+    @Override
     public CmmnRuntimeService getCmmnRuntimeService() {
         return cmmnRuntimeService;
     }
@@ -81,7 +86,17 @@ public class CmmnEngineImpl implements CmmnEngine {
     public void setCmmnRuntimeService(CmmnRuntimeService cmmnRuntimeService) {
         this.cmmnRuntimeService = cmmnRuntimeService;
     }
+    
+    @Override
+    public CmmnTaskService getCmmnTaskService() {
+        return cmmnTaskService;
+    }
 
+    public void setCmmnTaskService(CmmnTaskService cmmnTaskService) {
+        this.cmmnTaskService = cmmnTaskService;
+    }
+
+    @Override
     public CmmnManagementService getCmmnManagementService() {
         return cmmnManagementService;
     }
@@ -90,6 +105,7 @@ public class CmmnEngineImpl implements CmmnEngine {
         this.cmmnManagementService = cmmnManagementService;
     }
 
+    @Override
     public CmmnRepositoryService getCmmnRepositoryService() {
         return cmmnRepositoryService;
     }
@@ -98,6 +114,7 @@ public class CmmnEngineImpl implements CmmnEngine {
         this.cmmnRepositoryService = cmmnRepositoryService;
     }
 
+    @Override
     public CmmnHistoryService getCmmnHistoryService() {
         return cmmnHistoryService;
     }

modules/flowable-cmmn-engine/src/main/java/org/flowable/cmmn/engine/impl/CmmnHistoryServiceImpl.java

@@ -18,6 +18,8 @@ import org.flowable.cmmn.engine.history.HistoricMilestoneInstanceQuery;
 import org.flowable.cmmn.engine.history.HistoricVariableInstanceQuery;
 import org.flowable.cmmn.engine.impl.cmd.DeleteHistoricCaseInstanceCmd;
 import org.flowable.cmmn.engine.impl.history.CmmnHistoricVariableInstanceQueryImpl;
+import org.flowable.task.service.history.HistoricTaskInstanceQuery;
+import org.flowable.task.service.impl.HistoricTaskInstanceQueryImpl;
 
 /**
  * @author Joram Barrez
@@ -39,8 +41,15 @@ public class CmmnHistoryServiceImpl extends ServiceImpl implements CmmnHistorySe
         return new CmmnHistoricVariableInstanceQueryImpl(commandExecutor);
     }
 
+    
     @Override
     public void deleteHistoricCaseInstance(String caseInstanceId) {
         commandExecutor.execute(new DeleteHistoricCaseInstanceCmd(caseInstanceId));
     }
+
+    @Override
+    public HistoricTaskInstanceQuery createHistoricTaskInstanceQuery() {
+        return new HistoricTaskInstanceQueryImpl(commandExecutor);
+    }
+    
 }

modules/flowable-cmmn-engine/src/main/java/org/flowable/cmmn/engine/impl/CmmnTaskServiceImpl.java

+/* Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.flowable.cmmn.engine.impl;
+
+import java.util.Map;
+
+import org.flowable.cmmn.engine.CmmnTaskService;
+import org.flowable.cmmn.engine.impl.cmd.CompleteTaskCmd;
+import org.flowable.task.service.TaskQuery;
+import org.flowable.task.service.impl.TaskQueryImpl;
+
+/**
+ * @author Joram Barrez
+ */
+public class CmmnTaskServiceImpl extends ServiceImpl implements CmmnTaskService {
+
+    @Override
+    public void complete(String taskId) {
+        commandExecutor.execute(new CompleteTaskCmd(taskId, null, null));
+    }
+
+    @Override
+    public void complete(String taskId, Map<String, Object> variables) {
+        commandExecutor.execute(new CompleteTaskCmd(taskId, variables, null));        
+    }
+
+    @Override
+    public void complete(String taskId, Map<String, Object> variables, Map<String, Object> transientVariables) {
+        commandExecutor.execute(new CompleteTaskCmd(taskId, variables, transientVariables));        
+    }
+    
+    @Override
+    public TaskQuery createTaskQuery() {
+        return new TaskQueryImpl(commandExecutor);
+    }
+
+}

modules/flowable-cmmn-engine/src/main/java/org/flowable/cmmn/engine/impl/behavior/impl/CaseTaskActivityBehavior.java

@@ -55,7 +55,7 @@ public class CaseTaskActivityBehavior extends TaskActivityBehavior implements Pl
         planItemInstanceEntity.setReferenceType(PlanItemInstanceCallbackType.CHILD_CASE);
         planItemInstanceEntity.setReferenceId(caseInstanceEntity.getId());
         
-        if (!determineIsBlocking(planItemInstanceEntity)) {
+        if (!evaluateIsBlocking(planItemInstanceEntity)) {
             CommandContextUtil.getAgenda(commandContext).planCompletePlanItemInstance((PlanItemInstanceEntity) planItemInstanceEntity);
         }
     }

modules/flowable-cmmn-engine/src/main/java/org/flowable/cmmn/engine/impl/behavior/impl/HumanTaskActivityBehavior.java

+/* Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.flowable.cmmn.engine.impl.behavior.impl;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Date;
+import java.util.List;
+
+import org.apache.commons.lang3.StringUtils;
+import org.flowable.cmmn.engine.impl.persistence.entity.PlanItemInstanceEntity;
+import org.flowable.cmmn.engine.impl.util.CommandContextUtil;
+import org.flowable.cmmn.engine.runtime.PlanItemInstanceState;
+import org.flowable.cmmn.model.HumanTask;
+import org.flowable.engine.common.api.FlowableException;
+import org.flowable.engine.common.api.FlowableIllegalArgumentException;
+import org.flowable.engine.common.api.delegate.Expression;
+import org.flowable.engine.common.impl.el.ExpressionManager;
+import org.flowable.engine.common.impl.interceptor.CommandContext;
+import org.flowable.identitylink.service.impl.persistence.entity.IdentityLinkEntity;
+import org.flowable.task.service.TaskService;
+import org.flowable.task.service.impl.persistence.CountingTaskEntity;
+import org.flowable.task.service.impl.persistence.entity.TaskEntity;
+import org.flowable.variable.service.type.VariableScopeType;
+import org.joda.time.DateTime;
+import org.joda.time.Period;
+
+/**
+ * @author Joram Barrez
+ */
+public class HumanTaskActivityBehavior extends TaskActivityBehavior {
+    
+    protected HumanTask humanTask;
+    
+    public HumanTaskActivityBehavior(HumanTask humanTask) {
+        super(humanTask);
+        this.humanTask = humanTask;
+    }
+
+    @Override
+    public void execute(CommandContext commandContext, PlanItemInstanceEntity planItemInstanceEntity) {
+        if (evaluateIsBlocking(planItemInstanceEntity)) { 
+            
+            TaskService taskService = CommandContextUtil.getTaskService(commandContext);
+            ExpressionManager expressionManager = CommandContextUtil.getExpressionManager(commandContext);
+            
+            TaskEntity taskEntity = taskService.createTask();
+            
+            taskEntity.setScopeId(planItemInstanceEntity.getCaseInstanceId());
+            taskEntity.setSubScopeId(planItemInstanceEntity.getId());
+            taskEntity.setScopeDefinitionId(planItemInstanceEntity.getCaseDefinitionId());
+            taskEntity.setScopeType(VariableScopeType.CMMN);
+            
+            taskEntity.setTaskDefinitionKey(humanTask.getId());
+            
+            handleAssignee(planItemInstanceEntity, taskService, expressionManager, taskEntity);
+            handleOwner(planItemInstanceEntity, taskService, expressionManager, taskEntity);
+            handlePrioroty(planItemInstanceEntity, expressionManager, taskEntity);
+            handleFormKey(planItemInstanceEntity, expressionManager, taskEntity);
+            handleDueDate(commandContext, planItemInstanceEntity, expressionManager, taskEntity);
+            handleCategory(planItemInstanceEntity, expressionManager, taskEntity);
+            handleCandidateUsers(commandContext, planItemInstanceEntity, expressionManager, taskEntity);
+            handleCandidateGroups(commandContext, planItemInstanceEntity, expressionManager, taskEntity);
+            
+            taskService.insertTask(taskEntity, true);
+            CommandContextUtil.getCmmnHistoryManager(commandContext).recordTaskCreated(taskEntity);
+            
+        } else {
+            // if not blocking, treat as a manual task. No need to create a task entry.
+            CommandContextUtil.getAgenda(commandContext).planCompletePlanItemInstance((PlanItemInstanceEntity) planItemInstanceEntity);
+            
+        }
+    }
+
+    protected void handleAssignee(PlanItemInstanceEntity planItemInstanceEntity, TaskService taskService,
+            ExpressionManager expressionManager, TaskEntity taskEntity) {
+        if (StringUtils.isNotEmpty(humanTask.getAssignee())) {
+            Object assigneeExpressionValue = expressionManager.createExpression(humanTask.getAssignee()).getValue(planItemInstanceEntity);
+            String assigneeValue = null;
+            if (assigneeExpressionValue != null) {
+                assigneeValue = assigneeExpressionValue.toString();
+            }
+
+            taskService.changeTaskAssignee(taskEntity, assigneeValue);
+        }
+    }
+
+    protected void handleOwner(PlanItemInstanceEntity planItemInstanceEntity, TaskService taskService,
+            ExpressionManager expressionManager, TaskEntity taskEntity) {
+        if (StringUtils.isNotEmpty(humanTask.getOwner())) {
+            Object ownerExpressionValue = expressionManager.createExpression(humanTask.getOwner()).getValue(planItemInstanceEntity);
+            String ownerValue = null;
+            if (ownerExpressionValue != null) {
+                ownerValue = ownerExpressionValue.toString();
+            }
+
+            taskService.changeTaskOwner(taskEntity, ownerValue);
+        }
+    }
+
+    protected void handlePrioroty(PlanItemInstanceEntity planItemInstanceEntity, ExpressionManager expressionManager,
+            TaskEntity taskEntity) {
+        if (StringUtils.isNotEmpty(humanTask.getPriority())) {
+            Object priority = expressionManager.createExpression(humanTask.getPriority()).getValue(planItemInstanceEntity);
+            if (priority != null) {
+                if (priority instanceof String) {
+                    try {
+                        taskEntity.setPriority(Integer.valueOf((String) priority));
+                    } catch (NumberFormatException e) {
+                        throw new FlowableIllegalArgumentException("Priority does not resolve to a number: " + humanTask.getPriority(), e);
+                    }
+                } else if (priority instanceof Number) {
+                    taskEntity.setPriority(((Number) priority).intValue());
+                } else {
+                    throw new FlowableIllegalArgumentException("Priority expression does not resolve to a number: " + humanTask.getPriority());
+                }
+            }
+        }
+    }
+
+    protected void handleFormKey(PlanItemInstanceEntity planItemInstanceEntity, ExpressionManager expressionManager,
+            TaskEntity taskEntity) {
+        if (StringUtils.isNotEmpty(humanTask.getFormKey())) {
+            Object formKey = expressionManager.createExpression(humanTask.getFormKey()).getValue(planItemInstanceEntity);
+            if (formKey != null) {
+                if (formKey instanceof String) {
+                    taskEntity.setFormKey((String) formKey);
+                } else {
+                    throw new FlowableIllegalArgumentException("FormKey expression does not resolve to a string: " + humanTask.getFormKey());
+                }
+            }
+        }
+    }
+
+    protected void handleDueDate(CommandContext commandContext, PlanItemInstanceEntity planItemInstanceEntity,
+            ExpressionManager expressionManager, TaskEntity taskEntity) {
+        if (StringUtils.isNotEmpty(humanTask.getDueDate())) {
+            Object dueDate = expressionManager.createExpression(humanTask.getDueDate()).getValue(planItemInstanceEntity);
+            if (dueDate != null) {
+                if (dueDate instanceof Date) {
+                    taskEntity.setDueDate((Date) dueDate);
+                } else if (dueDate instanceof String) {
+                    
+                    String dueDateString = (String) dueDate;
+                    if (dueDateString.startsWith("P")) {
+                        taskEntity.setDueDate(new DateTime(CommandContextUtil.getCmmnEngineConfiguration(commandContext).getClock().getCurrentTime())
+                                .plus(Period.parse(dueDateString)).toDate());
+                    } else {
+                        taskEntity.setDueDate(DateTime.parse(dueDateString).toDate());
+                    }
+                    
+                } else {
+                    throw new FlowableIllegalArgumentException("Due date expression does not resolve to a Date or Date string: " + humanTask.getDueDate());
+                }
+            }
+        }
+    }
+
+    protected void handleCategory(PlanItemInstanceEntity planItemInstanceEntity, ExpressionManager expressionManager,
+            TaskEntity taskEntity) {
+        if (StringUtils.isNotEmpty(humanTask.getCategory())) {
+            final Object category = expressionManager.createExpression(humanTask.getCategory()).getValue(planItemInstanceEntity);
+            if (category != null) {
+                if (category instanceof String) {
+                    taskEntity.setCategory((String) category);
+                } else {
+                    throw new FlowableIllegalArgumentException("Category expression does not resolve to a string: " + humanTask.getCategory());
+                }
+            }
+        }
+    }
+
+    protected void handleCandidateUsers(CommandContext commandContext, PlanItemInstanceEntity planItemInstanceEntity,
+            ExpressionManager expressionManager, TaskEntity taskEntity) {
+        List<String> candidateUsers = humanTask.getCandidateUsers();
+        if (candidateUsers != null && !candidateUsers.isEmpty()) {
+            for (String candidateUser : candidateUsers) {
+                Expression userIdExpr = expressionManager.createExpression(candidateUser);
+                Object value = userIdExpr.getValue(planItemInstanceEntity);
+                if (value instanceof String) {
+                    List<String> candidates = extractCandidates((String) value);
+                    handleIdentityLinks(commandContext, taskEntity, CommandContextUtil.getIdentityLinkService().addCandidateUsers(taskEntity.getId(), candidates));
+                    
+                } else if (value instanceof Collection) {
+                    handleIdentityLinks(commandContext, taskEntity, CommandContextUtil.getIdentityLinkService().addCandidateUsers(taskEntity.getId(), (Collection) value));
+                    
+                } else {
+                    throw new FlowableException("Expression did not resolve to a string or collection of strings");
+                }
+            }
+        }
+    }
+
+    protected void handleCandidateGroups(CommandContext commandContext, PlanItemInstanceEntity planItemInstanceEntity,
+            ExpressionManager expressionManager, TaskEntity taskEntity) {
+        List<String> candidateGroups = humanTask.getCandidateGroups();
+        if (candidateGroups != null && !candidateGroups.isEmpty()) {
+            for (String candidateGroup : candidateGroups) {
+                Expression groupIdExpr = expressionManager.createExpression(candidateGroup);
+                Object value = groupIdExpr.getValue(planItemInstanceEntity);
+                if (value instanceof String) {
+                    List<String> candidates = extractCandidates((String) value);
+                    handleIdentityLinks(commandContext, taskEntity, CommandContextUtil.getIdentityLinkService().addCandidateGroups(taskEntity.getId(), candidates));
+                    
+                } else if (value instanceof Collection) {
+                    handleIdentityLinks(commandContext, taskEntity, CommandContextUtil.getIdentityLinkService().addCandidateGroups(taskEntity.getId(), (Collection) value));
+                    
+                } else {
+                    throw new FlowableIllegalArgumentException("Expression did not resolve to a string or collection of strings");
+                }
+            }
+        }
+    }
+    
+    protected void handleIdentityLinks(CommandContext commandContext, TaskEntity taskEntity, List<IdentityLinkEntity> identityLinkEntities) {
+        for (IdentityLinkEntity identityLinkEntity : identityLinkEntities) {
+            if (CommandContextUtil.getCmmnEngineConfiguration().isEnableTaskRelationshipCounts()) {
+                CountingTaskEntity countingTaskEntity = (CountingTaskEntity) taskEntity;
+                if (countingTaskEntity.isCountEnabled()) {
+                    countingTaskEntity.setIdentityLinkCount(countingTaskEntity.getIdentityLinkCount() + 1);
+                }
+            }
+            taskEntity.getIdentityLinks().add(identityLinkEntity);
+        }
+    }
+    
+    protected List<String> extractCandidates(String str) {
+        return Arrays.asList(str.split("[\\s]*,[\\s]*"));
+    }
+    
+    @Override
+    public void trigger(CommandContext commandContext, PlanItemInstanceEntity planItemInstance) {
+        if (!PlanItemInstanceState.ACTIVE.equals(planItemInstance.getState())) {
+            throw new FlowableException("Can only trigger a human task plan item that is in the ACTIVE state");
+        }
+        
+        TaskService taskService = CommandContextUtil.getTaskService(commandContext);
+        List<TaskEntity> taskEntities = taskService.findTasksBySubScopeIdScopeType(planItemInstance.getId(), VariableScopeType.CMMN);
+        if (taskEntities == null || taskEntities.isEmpty()) {
+            throw new FlowableException("No task entity found for plan item instance " + planItemInstance.getId());
+        }
+        
+        // Should be only one
+        for (TaskEntity taskEntity : taskEntities) {
+            if (!taskEntity.isDeleted()) {
+                taskService.deleteTask(taskEntity, true);
+                CommandContextUtil.getCmmnHistoryManager(commandContext).recordTaskEnd(taskEntity, null);
+            }
+        }
+        
+        CommandContextUtil.getAgenda(commandContext).planCompletePlanItemInstance((PlanItemInstanceEntity) planItemInstance);
+    }
+
+}

modules/flowable-cmmn-engine/src/main/java/org/flowable/cmmn/engine/impl/behavior/impl/ProcessTaskActivityBehavior.java

@@ -63,7 +63,7 @@ public class ProcessTaskActivityBehavior extends TaskActivityBehavior implements
         }
         
         String processInstanceId = null;
-        boolean blocking = determineIsBlocking(planItemInstanceEntity);
+        boolean blocking = evaluateIsBlocking(planItemInstanceEntity);
         if (blocking) {
             processInstanceId = processInstanceService.startProcessInstanceByKey(externalRef, planItemInstanceEntity.getId());
         } else {

modules/flowable-cmmn-engine/src/main/java/org/flowable/cmmn/engine/impl/behavior/impl/TaskActivityBehavior.java

@@ -38,12 +38,12 @@ public class TaskActivityBehavior extends CoreCmmnTriggerableActivityBehavior {
     
     @Override
     public void execute(CommandContext commandContext, PlanItemInstanceEntity planItemInstanceEntity) {
-        if (!determineIsBlocking(planItemInstanceEntity)) {
+        if (!evaluateIsBlocking(planItemInstanceEntity)) {
             CommandContextUtil.getAgenda(commandContext).planCompletePlanItemInstance((PlanItemInstanceEntity) planItemInstanceEntity);
         }
     }
 
-    protected boolean determineIsBlocking(DelegatePlanItemInstance planItemInstance) {
+    protected boolean evaluateIsBlocking(DelegatePlanItemInstance planItemInstance) {
         boolean blocking = isBlocking;
         if (StringUtils.isNotEmpty(isBlockingExpression)) {
             Expression expression = CommandContextUtil.getExpressionManager().createExpression(isBlockingExpression);

modules/flowable-cmmn-engine/src/main/java/org/flowable/cmmn/engine/impl/cmd/CompleteTaskCmd.java

+/* Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.flowable.cmmn.engine.impl.cmd;
+
+import java.util.Map;
+
+import org.flowable.cmmn.engine.impl.persistence.entity.PlanItemInstanceEntity;
+import org.flowable.cmmn.engine.impl.util.CommandContextUtil;
+import org.flowable.engine.common.api.FlowableException;
+import org.flowable.engine.common.api.FlowableIllegalArgumentException;
+import org.flowable.engine.common.api.FlowableObjectNotFoundException;
+import org.flowable.engine.common.impl.interceptor.Command;
+import org.flowable.engine.common.impl.interceptor.CommandContext;
+import org.flowable.task.service.impl.persistence.entity.TaskEntity;
+
+/**
+ * @author Joram Barrez
+ */
+public class CompleteTaskCmd implements Command<Void> {
+    
+    protected String taskId;
+    protected Map<String, Object> variables;
+    protected Map<String, Object> transientVariables;
+    
+    public CompleteTaskCmd(String taskId, Map<String, Object> variables, Map<String, Object> transientVariables) {
+        this.taskId = taskId;
+        this.variables = variables;
+        this.transientVariables = transientVariables;
+    }
+    
+    @Override
+    public Void execute(CommandContext commandContext) {
+        
+        if (taskId == null) {
+            throw new FlowableIllegalArgumentException("Null task id");
+        }
+        
+        TaskEntity taskEntity = CommandContextUtil.getTaskService(commandContext).getTask(taskId);
+        if (taskEntity == null) {
+            throw new FlowableObjectNotFoundException("Could not find task entity for id " + taskId, TaskEntity.class);
+        }
+        
+        String planItemInstanceId = taskEntity.getSubScopeId();
+        PlanItemInstanceEntity planItemInstanceEntity = CommandContextUtil.getPlanItemInstanceEntityManager(commandContext).findById(planItemInstanceId);
+        if (planItemInstanceEntity == null) {
+            throw new FlowableException("Could not find plan item instance for task " + taskId);
+        }
+        
+        if (variables != null) {
+            taskEntity.setVariables(variables);
+        }
+        if (transientVariables != null) {
+            taskEntity.setTransientVariables(transientVariables);
+        }
+        
+        CommandContextUtil.getAgenda(commandContext).planTriggerPlanItemInstance(planItemInstanceEntity);
+        
+        return null;
+    }
+
+}

modules/flowable-cmmn-engine/src/main/java/org/flowable/cmmn/engine/impl/cmd/GetVariableCmd.java

@@ -13,11 +13,11 @@
 package org.flowable.cmmn.engine.impl.cmd;
 
 import org.flowable.cmmn.engine.impl.util.CommandContextUtil;
-import org.flowable.cmmn.engine.impl.variable.VariableScopeType;
 import org.flowable.engine.common.api.FlowableIllegalArgumentException;
 import org.flowable.engine.common.impl.interceptor.Command;
 import org.flowable.engine.common.impl.interceptor.CommandContext;
 import org.flowable.variable.service.impl.persistence.entity.VariableInstanceEntity;
+import org.flowable.variable.service.type.VariableScopeType;
 
 /**
  * @author Joram Barrez

modules/flowable-cmmn-engine/src/main/java/org/flowable/cmmn/engine/impl/cmd/GetVariablesCmd.java

@@ -17,11 +17,11 @@ import java.util.List;
 import java.util.Map;
 
 import org.flowable.cmmn.engine.impl.util.CommandContextUtil;
-import org.flowable.cmmn.engine.impl.variable.VariableScopeType;
 import org.flowable.engine.common.api.FlowableIllegalArgumentException;
 import org.flowable.engine.common.impl.interceptor.Command;
 import org.flowable.engine.common.impl.interceptor.CommandContext;
 import org.flowable.variable.service.impl.persistence.entity.VariableInstanceEntity;
+import org.flowable.variable.service.type.VariableScopeType;
 
 /**
  * @author Joram Barrez

modules/flowable-cmmn-engine/src/main/java/org/flowable/cmmn/engine/impl/db/CmmnDbSchemaManager.java

@@ -119,6 +119,7 @@ public class CmmnDbSchemaManager implements DbSchemaManager {
         try {
             
             getCommonDbSchemaManager().dbSchemaCreate();
+            getIdentityLinkDbSchemaManager().dbSchemaCreate();
             getTaskDbSchemaManager().dbSchemaCreate();
             getVariableDbSchemaManager().dbSchemaCreate();
             
@@ -150,6 +151,13 @@ public class CmmnDbSchemaManager implements DbSchemaManager {
             LOGGER.info("Error dropping task tables", e);
         }
         
+        try {
+            getIdentityLinkDbSchemaManager().dbSchemaDrop();
+        } catch (Exception e) {
+            LOGGER.info("Error dropping identity link tables", e);
+        }
+        
+        
         try {
             getCommonDbSchemaManager().dbSchemaDrop();
         } catch (Exception e) {
@@ -162,6 +170,7 @@ public class CmmnDbSchemaManager implements DbSchemaManager {
         try {
             
             getCommonDbSchemaManager().dbSchemaUpdate();
+            getIdentityLinkDbSchemaManager().dbSchemaUpdate();
             getTaskDbSchemaManager().dbSchemaUpdate();
             getVariableDbSchemaManager().dbSchemaUpdate();
             
@@ -178,6 +187,10 @@ public class CmmnDbSchemaManager implements DbSchemaManager {
         return CommandContextUtil.getCmmnEngineConfiguration().getCommonDbSchemaManager();
     }
     
+    protected DbSchemaManager getIdentityLinkDbSchemaManager() {
+        return CommandContextUtil.getCmmnEngineConfiguration().getIdentityLinkDbSchemaManager();
+    }
+    
     protected DbSchemaManager getVariableDbSchemaManager() {
         return CommandContextUtil.getCmmnEngineConfiguration().getVariableDbSchemaManager();
     }

modules/flowable-cmmn-engine/src/main/java/org/flowable/cmmn/engine/impl/history/CmmnHistoricVariableInstanceQueryImpl.java

@@ -16,11 +16,11 @@ import java.util.List;
 import java.util.Set;
 
 import org.flowable.cmmn.engine.history.HistoricVariableInstanceQuery;
-import org.flowable.cmmn.engine.impl.variable.VariableScopeType;
 import org.flowable.engine.common.api.query.QueryProperty;
 import org.flowable.engine.common.impl.interceptor.CommandExecutor;
 import org.flowable.variable.service.history.HistoricVariableInstance;
 import org.flowable.variable.service.impl.HistoricVariableInstanceQueryImpl;
+import org.flowable.variable.service.type.VariableScopeType;
 
 /**
  * Wrapper class around the {@link HistoricVariableInstanceQueryImpl} from the variable service,

modules/flowable-cmmn-engine/src/main/java/org/flowable/cmmn/engine/impl/history/CmmnHistoryManager.java

@@ -14,6 +14,7 @@ package org.flowable.cmmn.engine.impl.history;
 
 import org.flowable.cmmn.engine.impl.persistence.entity.CaseInstanceEntity;
 import org.flowable.cmmn.engine.runtime.MilestoneInstance;
+import org.flowable.task.service.impl.persistence.entity.TaskEntity;
 import org.flowable.variable.service.impl.persistence.entity.VariableInstanceEntity;
 
 /**
@@ -34,5 +35,11 @@ public interface CmmnHistoryManager {
     void recordVariableUpdate(VariableInstanceEntity variable);
 
     void recordVariableRemoved(VariableInstanceEntity variable);
+    
+    void recordTaskCreated(TaskEntity task);
+
+    void recordTaskEnd(TaskEntity task, String deleteReason);
+    
+    void recordTaskInfoChange(TaskEntity taskEntity);
 
 }

modules/flowable-cmmn-engine/src/main/java/org/flowable/cmmn/engine/impl/history/CmmnHistoryTaskManager.java

+/* Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.flowable.cmmn.engine.impl.history;
+
+import org.flowable.cmmn.engine.impl.util.CommandContextUtil;
+import org.flowable.task.service.history.InternalHistoryTaskManager;
+import org.flowable.task.service.impl.persistence.entity.TaskEntity;
+
+/**
+ * @author Joram Barrez
+ */
+public class CmmnHistoryTaskManager implements InternalHistoryTaskManager {
+    
+    protected CmmnHistoryManager cmmnHistoryManager;
+    
+    public CmmnHistoryTaskManager(CmmnHistoryManager cmmnHistoryManager) {
+        this.cmmnHistoryManager = cmmnHistoryManager;
+    }
+
+    @Override
+    public void recordTaskInfoChange(TaskEntity taskEntity) {
+        CommandContextUtil.getHistoricTaskService().recordTaskInfoChange(taskEntity);
+    }
+
+}

modules/flowable-cmmn-engine/src/main/java/org/flowable/cmmn/engine/impl/history/DefaultCmmnHistoryManager.java

@@ -24,8 +24,7 @@ import org.flowable.cmmn.engine.impl.persistence.entity.HistoricMilestoneInstanc
 import org.flowable.cmmn.engine.impl.util.CommandContextUtil;
 import org.flowable.cmmn.engine.runtime.MilestoneInstance;
 import org.flowable.engine.common.impl.history.HistoryLevel;
-import org.flowable.engine.common.impl.interceptor.CommandContext;
-import org.flowable.variable.service.impl.persistence.entity.HistoricVariableInstanceEntity;
+import org.flowable.task.service.impl.persistence.entity.TaskEntity;
 import org.flowable.variable.service.impl.persistence.entity.VariableInstanceEntity;
 
 /**
@@ -109,28 +108,37 @@ public class DefaultCmmnHistoryManager implements CmmnHistoryManager {
     }
 
     @Override
-    public void recordVariableUpdate(VariableInstanceEntity variable) {
+    public void recordVariableUpdate(VariableInstanceEntity variableInstanceEntity) {
         if (cmmnEngineConfiguration.getHistoryLevel().isAtLeast(HistoryLevel.AUDIT)) {
-            CommandContext commandContext = CommandContextUtil.getCommandContext();
-            HistoricVariableInstanceEntity historicProcessVariable = CommandContextUtil
-                    .getHistoricVariableService(commandContext).getHistoricVariableInstance(variable.getId());
-            if (historicProcessVariable != null) {
-                CommandContextUtil.getHistoricVariableService(commandContext).copyVariableValue(historicProcessVariable, variable);
-            } else {
-                CommandContextUtil.getHistoricVariableService(commandContext).createAndInsert(variable);
-            }
+            CommandContextUtil.getHistoricVariableService().recordVariableUpdate(variableInstanceEntity);
         }
     }
 
     @Override
-    public void recordVariableRemoved(VariableInstanceEntity variable) {
+    public void recordVariableRemoved(VariableInstanceEntity variableInstanceEntity) {
         if (cmmnEngineConfiguration.getHistoryLevel().isAtLeast(HistoryLevel.AUDIT)) {
-            CommandContext commandContext = CommandContextUtil.getCommandContext();
-            HistoricVariableInstanceEntity historicProcessVariable = CommandContextUtil
-                    .getHistoricVariableService(commandContext).getHistoricVariableInstance(variable.getId());
-            if (historicProcessVariable != null) {
-                CommandContextUtil.getHistoricVariableService(commandContext).deleteHistoricVariableInstance(historicProcessVariable);
-            }
+            CommandContextUtil.getHistoricVariableService().recordVariableRemoved(variableInstanceEntity);
+        }
+    }
+
+    @Override
+    public void recordTaskCreated(TaskEntity task) {
+        if (cmmnEngineConfiguration.getHistoryLevel().isAtLeast(HistoryLevel.AUDIT)) {
+            CommandContextUtil.getHistoricTaskService().recordTaskCreated(task);
+        }
+    }
+
+    @Override
+    public void recordTaskEnd(TaskEntity task, String deleteReason) {
+        if (cmmnEngineConfiguration.getHistoryLevel().isAtLeast(HistoryLevel.AUDIT)) {
+            CommandContextUtil.getHistoricTaskService().recordTaskEnd(task, deleteReason);
+        }
+    }
+
+    @Override
+    public void recordTaskInfoChange(TaskEntity taskEntity) {
+        if (cmmnEngineConfiguration.getHistoryLevel().isAtLeast(HistoryLevel.AUDIT)) {
+            CommandContextUtil.getHistoricTaskService().recordTaskInfoChange(taskEntity);
         }
     }
 

modules/flowable-cmmn-engine/src/main/java/org/flowable/cmmn/engine/impl/parser/CmmnActivityBehaviorFactory.java

@@ -13,6 +13,7 @@
 package org.flowable.cmmn.engine.impl.parser;
 
 import org.flowable.cmmn.engine.impl.behavior.impl.CaseTaskActivityBehavior;
+import org.flowable.cmmn.engine.impl.behavior.impl.HumanTaskActivityBehavior;
 import org.flowable.cmmn.engine.impl.behavior.impl.MilestoneActivityBehavior;
 import org.flowable.cmmn.engine.impl.behavior.impl.PlanItemDelegateExpressionActivityBehavior;
 import org.flowable.cmmn.engine.impl.behavior.impl.PlanItemExpressionActivityBehavior;
@@ -21,6 +22,7 @@ import org.flowable.cmmn.engine.impl.behavior.impl.StageActivityBehavior;
 import org.flowable.cmmn.engine.impl.behavior.impl.TaskActivityBehavior;
 import org.flowable.cmmn.engine.impl.delegate.CmmnClassDelegate;
 import org.flowable.cmmn.model.CaseTask;
+import org.flowable.cmmn.model.HumanTask;
 import org.flowable.cmmn.model.Milestone;
 import org.flowable.cmmn.model.PlanItem;
 import org.flowable.cmmn.model.ProcessTask;
@@ -39,6 +41,8 @@ public interface CmmnActivityBehaviorFactory {
     
     TaskActivityBehavior createTaskActivityBehavior(PlanItem planItem, Task task);
     
+    HumanTaskActivityBehavior createHumanTaskActivityBehavior(PlanItem planItem, HumanTask humanTask);
+    
     CaseTaskActivityBehavior createCaseTaskActivityBehavior(PlanItem planItem, CaseTask caseTask);
     
     ProcessTaskActivityBehavior createProcessTaskActivityBehavior(PlanItem planItem, ProcessTask processTask);

modules/flowable-cmmn-engine/src/main/java/org/flowable/cmmn/engine/impl/parser/CmmnParserImpl.java

@@ -29,6 +29,7 @@ import org.flowable.cmmn.engine.impl.util.CommandContextUtil;
 import org.flowable.cmmn.model.Case;
 import org.flowable.cmmn.model.CaseTask;
 import org.flowable.cmmn.model.CmmnModel;
+import org.flowable.cmmn.model.HumanTask;
 import org.flowable.cmmn.model.ImplementationType;
 import org.flowable.cmmn.model.Milestone;
 import org.flowable.cmmn.model.PlanFragment;
@@ -119,6 +120,10 @@ public class CmmnParserImpl implements CmmnParser {
                 Stage stage = (Stage) planItemDefinition;
                 planItem.setBehavior(activityBehaviorFactory.createStageActivityBehavoir(planItem, stage));
                 
+            } else if (planItemDefinition instanceof HumanTask) { 
+                HumanTask humanTask = (HumanTask) planItemDefinition;
+                planItem.setBehavior(activityBehaviorFactory.createHumanTaskActivityBehavior(planItem, humanTask));
+                
             } else if (planItemDefinition instanceof CaseTask) {
                 CaseTask caseTask = (CaseTask) planItemDefinition;
                 planItem.setBehavior(activityBehaviorFactory.createCaseTaskActivityBehavior(planItem, caseTask));

modules/flowable-cmmn-engine/src/main/java/org/flowable/cmmn/engine/impl/parser/DefaultCmmnActivityBehaviorFactory.java

@@ -14,6 +14,7 @@ package org.flowable.cmmn.engine.impl.parser;
 
 import org.apache.commons.lang3.StringUtils;
 import org.flowable.cmmn.engine.impl.behavior.impl.CaseTaskActivityBehavior;
+import org.flowable.cmmn.engine.impl.behavior.impl.HumanTaskActivityBehavior;
 import org.flowable.cmmn.engine.impl.behavior.impl.MilestoneActivityBehavior;
 import org.flowable.cmmn.engine.impl.behavior.impl.PlanItemDelegateExpressionActivityBehavior;
 import org.flowable.cmmn.engine.impl.behavior.impl.PlanItemExpressionActivityBehavior;
@@ -23,6 +24,7 @@ import org.flowable.cmmn.engine.impl.behavior.impl.TaskActivityBehavior;
 import org.flowable.cmmn.engine.impl.delegate.CmmnClassDelegate;
 import org.flowable.cmmn.engine.impl.delegate.CmmnClassDelegateFactory;
 import org.flowable.cmmn.model.CaseTask;
+import org.flowable.cmmn.model.HumanTask;
 import org.flowable.cmmn.model.Milestone;
 import org.flowable.cmmn.model.PlanItem;
 import org.flowable.cmmn.model.ProcessTask;
@@ -61,6 +63,11 @@ public class DefaultCmmnActivityBehaviorFactory implements CmmnActivityBehaviorF
         return new TaskActivityBehavior(task);
     }
     
+    @Override
+    public HumanTaskActivityBehavior createHumanTaskActivityBehavior(PlanItem planItem, HumanTask humanTask) {
+        return new HumanTaskActivityBehavior(humanTask);
+    }
+    
     @Override
     public CaseTaskActivityBehavior createCaseTaskActivityBehavior(PlanItem planItem, CaseTask caseTask) {
         return new CaseTaskActivityBehavior(expressionManager.createExpression(caseTask.getCaseRef()), caseTask);

modules/flowable-cmmn-engine/src/main/java/org/flowable/cmmn/engine/impl/persistence/entity/CaseDefinitionEntityManagerImpl.java

@@ -19,13 +19,13 @@ import org.flowable.cmmn.engine.CmmnEngineConfiguration;
 import org.flowable.cmmn.engine.impl.persistence.entity.data.CaseDefinitionDataManager;
 import org.flowable.cmmn.engine.impl.repository.CaseDefinitionQueryImpl;
 import org.flowable.cmmn.engine.impl.runtime.CaseInstanceQueryImpl;
-import org.flowable.cmmn.engine.impl.variable.VariableScopeType;
 import org.flowable.cmmn.engine.repository.CaseDefinition;
 import org.flowable.cmmn.engine.repository.CaseDefinitionQuery;
 import org.flowable.cmmn.engine.runtime.CaseInstance;
 import org.flowable.engine.common.impl.persistence.entity.data.DataManager;
 import org.flowable.variable.service.impl.persistence.entity.HistoricVariableInstanceEntity;
 import org.flowable.variable.service.impl.persistence.entity.HistoricVariableInstanceEntityManager;
+import org.flowable.variable.service.type.VariableScopeType;
 
 
 /**

modules/flowable-cmmn-engine/src/main/java/org/flowable/cmmn/engine/impl/persistence/entity/CaseInstanceEntityImpl.java

@@ -20,9 +20,9 @@ import java.util.Map;
 
 import org.flowable.cmmn.engine.CmmnEngineConfiguration;
 import org.flowable.cmmn.engine.impl.util.CommandContextUtil;
-import org.flowable.cmmn.engine.impl.variable.VariableScopeType;
 import org.flowable.variable.service.impl.persistence.entity.VariableInstanceEntity;
 import org.flowable.variable.service.impl.persistence.entity.VariableScopeImpl;
+import org.flowable.variable.service.type.VariableScopeType;
 
 /**
  * @author Joram Barrez

modules/flowable-cmmn-engine/src/main/java/org/flowable/cmmn/engine/impl/persistence/entity/CaseInstanceEntityManagerImpl.java

@@ -19,13 +19,15 @@ import org.flowable.cmmn.engine.CmmnEngineConfiguration;
 import org.flowable.cmmn.engine.impl.persistence.entity.data.CaseInstanceDataManager;
 import org.flowable.cmmn.engine.impl.runtime.CaseInstanceQueryImpl;
 import org.flowable.cmmn.engine.impl.util.CommandContextUtil;
-import org.flowable.cmmn.engine.impl.variable.VariableScopeType;
 import org.flowable.cmmn.engine.runtime.CaseInstance;
 import org.flowable.cmmn.engine.runtime.CaseInstanceQuery;
 import org.flowable.engine.common.impl.interceptor.CommandContext;
 import org.flowable.engine.common.impl.persistence.entity.data.DataManager;
+import org.flowable.task.service.impl.persistence.entity.TaskEntity;
+import org.flowable.task.service.impl.persistence.entity.TaskEntityManager;
 import org.flowable.variable.service.impl.persistence.entity.VariableInstanceEntity;
 import org.flowable.variable.service.impl.persistence.entity.VariableInstanceEntityManager;
+import org.flowable.variable.service.type.VariableScopeType;
 
 /**
  * @author Joram Barrez
@@ -76,14 +78,21 @@ public class CaseInstanceEntityManagerImpl extends AbstractCmmnEntityManager<Cas
         CommandContext commandContext = CommandContextUtil.getCommandContext();
 
         // Variables
-        CommandContextUtil.getVariableServiceConfiguration(commandContext).getVariableInstanceEntityManager();
-        VariableInstanceEntityManager variableInstanceEntityManager = getVariableInstanceEntityManager();
+        VariableInstanceEntityManager variableInstanceEntityManager 
+            = CommandContextUtil.getVariableServiceConfiguration(commandContext).getVariableInstanceEntityManager();
         List<VariableInstanceEntity> variableInstanceEntities = variableInstanceEntityManager
                 .findVariableInstanceByScopeIdAndScopeType(caseInstanceId, VariableScopeType.CMMN);
         for (VariableInstanceEntity variableInstanceEntity : variableInstanceEntities) {
             variableInstanceEntityManager.delete(variableInstanceEntity);
         }
         
+        // Tasks
+        TaskEntityManager taskEntityManager = CommandContextUtil.getTaskServiceConfiguration(commandContext).getTaskEntityManager();
+        List<TaskEntity> taskEntities = taskEntityManager.findTasksByScopeIdAndScopeType(caseInstanceId, VariableScopeType.CMMN);
+        for (TaskEntity taskEntity : taskEntities) {
+            taskEntityManager.delete(taskEntity);
+        }
+        
         // Sentry part instances
         List<SentryPartInstanceEntity> sentryPartInstances = caseInstanceEntity.getSatisfiedSentryPartInstances();
         for (SentryPartInstanceEntity sentryPartInstanceEntity : sentryPartInstances) {

modules/flowable-cmmn-engine/src/main/java/org/flowable/cmmn/engine/impl/persistence/entity/PlanItemInstanceEntityImpl.java

@@ -21,11 +21,11 @@ import java.util.Map;
 import org.flowable.cmmn.engine.CmmnEngineConfiguration;
 import org.flowable.cmmn.engine.impl.repository.CaseDefinitionUtil;
 import org.flowable.cmmn.engine.impl.util.CommandContextUtil;
-import org.flowable.cmmn.engine.impl.variable.VariableScopeType;
 import org.flowable.cmmn.model.Case;
 import org.flowable.cmmn.model.PlanItem;
 import org.flowable.variable.service.impl.persistence.entity.VariableInstanceEntity;
 import org.flowable.variable.service.impl.persistence.entity.VariableScopeImpl;
+import org.flowable.variable.service.type.VariableScopeType;
 
 /**
  * @author Joram Barrez

modules/flowable-cmmn-engine/src/main/java/org/flowable/cmmn/engine/impl/task/DefaultCmmnTaskVariableScopeResolver.java

+/* Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.flowable.cmmn.engine.impl.task;
+
+import org.flowable.cmmn.engine.CmmnEngineConfiguration;
+import org.flowable.task.service.InternalTaskVariableScopeResolver;
+import org.flowable.task.service.impl.persistence.entity.TaskEntity;
+import org.flowable.variable.service.impl.persistence.entity.VariableScopeImpl;
+import org.flowable.variable.service.type.VariableScopeType;
+
+/**
+ * @author Joram Barrez
+ */
+public class DefaultCmmnTaskVariableScopeResolver implements InternalTaskVariableScopeResolver {
+    
+    protected CmmnEngineConfiguration cmmnEngineConfiguration;
+    
+    public DefaultCmmnTaskVariableScopeResolver(CmmnEngineConfiguration cmmnEngineConfiguration) {
+        this.cmmnEngineConfiguration = cmmnEngineConfiguration;
+    }
+
+    @Override
+    public VariableScopeImpl resolveParentVariableScope(TaskEntity taskEntity) {
+        if (VariableScopeType.CMMN.equals(taskEntity.getScopeType())) {
+            if (taskEntity.getSubScopeId() != null) {
+                return (VariableScopeImpl) cmmnEngineConfiguration.getPlanItemInstanceEntityManager().findById(taskEntity.getSubScopeId());
+            } else if (taskEntity.getScopeId() != null) {
+                return  (VariableScopeImpl) cmmnEngineConfiguration.getCaseInstanceEntityManager().findById(taskEntity.getScopeId());
+            }
+        }
+        return null;
+    }
+
+}

modules/flowable-cmmn-engine/src/main/java/org/flowable/cmmn/engine/impl/util/CommandContextUtil.java

@@ -37,6 +37,11 @@ import org.flowable.engine.common.impl.el.ExpressionManager;
 import org.flowable.engine.common.impl.interceptor.CommandContext;
 import org.flowable.engine.common.impl.interceptor.EngineConfigurationConstants;
 import org.flowable.engine.common.impl.persistence.cache.EntityCache;
+import org.flowable.identitylink.service.IdentityLinkService;
+import org.flowable.identitylink.service.IdentityLinkServiceConfiguration;
+import org.flowable.task.service.HistoricTaskService;
+import org.flowable.task.service.TaskService;
+import org.flowable.task.service.TaskServiceConfiguration;
 import org.flowable.variable.service.HistoricVariableService;
 import org.flowable.variable.service.VariableService;
 import org.flowable.variable.service.VariableServiceConfiguration;
@@ -187,6 +192,22 @@ public class CommandContextUtil {
         return historicVariableService;
     }
     
+    public static IdentityLinkServiceConfiguration getIdentityLinkServiceConfiguration() { 
+        return getIdentityLinkServiceConfiguration(getCommandContext());
+    }
+    
+    public static IdentityLinkServiceConfiguration getIdentityLinkServiceConfiguration(CommandContext commandContext) {
+        return (IdentityLinkServiceConfiguration) commandContext.getServiceConfigurations().get(EngineConfigurationConstants.KEY_IDENTITY_LINK_SERVICE_CONFIG);
+    }
+    
+    public static IdentityLinkService getIdentityLinkService() {
+        return getIdentityLinkService(getCommandContext());
+    }
+    
+    public static IdentityLinkService getIdentityLinkService(CommandContext commandContext) {
+        return getIdentityLinkServiceConfiguration(commandContext).getIdentityLinkService();
+    }
+    
     public static VariableServiceConfiguration getVariableServiceConfiguration() {
         return getVariableServiceConfiguration(getCommandContext());
     }
@@ -195,6 +216,30 @@ public class CommandContextUtil {
         return (VariableServiceConfiguration) commandContext.getServiceConfigurations().get(EngineConfigurationConstants.KEY_VARIABLE_SERVICE_CONFIG);
     }
     
+    public static TaskService getTaskService() {
+        return getTaskService(getCommandContext());
+    }
+    
+    public static TaskService getTaskService(CommandContext commandContext) {
+        return getTaskServiceConfiguration(commandContext).getTaskService();
+    }
+    
+    public static HistoricTaskService getHistoricTaskService() {
+        return getHistoricTaskService(getCommandContext());
+    }
+    
+    public static HistoricTaskService getHistoricTaskService(CommandContext commandContext) {
+        return getTaskServiceConfiguration(commandContext).getHistoricTaskService();
+    }
+    
+    public static TaskServiceConfiguration getTaskServiceConfiguration() {
+        return getTaskServiceConfiguration(getCommandContext());
+    }
+    
+    public static TaskServiceConfiguration getTaskServiceConfiguration(CommandContext commandContext) {
+        return (TaskServiceConfiguration) commandContext.getServiceConfigurations().get(EngineConfigurationConstants.KEY_TASK_SERVICE_CONFIG);
+    }
+    
     public static CmmnEngineAgenda getAgenda() {
         return getAgenda(getCommandContext());
     }

modules/flowable-cmmn-engine/src/main/java/org/flowable/cmmn/engine/test/FlowableCmmnRule.java

@@ -23,6 +23,7 @@ import org.flowable.cmmn.engine.CmmnHistoryService;
 import org.flowable.cmmn.engine.CmmnManagementService;
 import org.flowable.cmmn.engine.CmmnRepositoryService;
 import org.flowable.cmmn.engine.CmmnRuntimeService;
+import org.flowable.cmmn.engine.CmmnTaskService;
 import org.flowable.cmmn.engine.test.impl.CmmnTestHelper;
 import org.flowable.engine.common.api.FlowableException;
 import org.junit.internal.AssumptionViolatedException;
@@ -77,6 +78,7 @@ public class FlowableCmmnRule implements TestRule {
     protected CmmnEngine cmmnEngine;
     protected CmmnRepositoryService cmmnRepositoryService;
     protected CmmnRuntimeService cmmnRuntimeService;
+    protected CmmnTaskService cmmnTaskService;
     protected CmmnHistoryService cmmnHistoryService;
     protected CmmnManagementService cmmnManagementService;
 
@@ -202,6 +204,7 @@ public class FlowableCmmnRule implements TestRule {
         cmmnEngineConfiguration = cmmnEngine.getCmmnEngineConfiguration();
         cmmnRepositoryService = cmmnEngine.getCmmnRepositoryService();
         cmmnRuntimeService = cmmnEngine.getCmmnRuntimeService();
+        cmmnTaskService = cmmnEngine.getCmmnTaskService();
         cmmnHistoryService = cmmnEngine.getCmmnHistoryService();
         cmmnManagementService = cmmnEngine.getCmmnManagementService();
     }

modules/flowable-cmmn-engine/src/main/java/org/flowable/cmmn/engine/test/FlowableCmmnTestCase.java

@@ -23,6 +23,7 @@ import org.flowable.cmmn.engine.CmmnHistoryService;
 import org.flowable.cmmn.engine.CmmnManagementService;
 import org.flowable.cmmn.engine.CmmnRepositoryService;
 import org.flowable.cmmn.engine.CmmnRuntimeService;
+import org.flowable.cmmn.engine.CmmnTaskService;
 import org.flowable.cmmn.engine.runtime.CaseInstance;
 import org.flowable.cmmn.engine.test.impl.CmmnTestRunner;
 import org.junit.After;
@@ -44,6 +45,7 @@ public class FlowableCmmnTestCase {
     protected CmmnManagementService cmmnManagementService;
     protected CmmnRepositoryService cmmnRepositoryService;
     protected CmmnRuntimeService cmmnRuntimeService;
+    protected CmmnTaskService cmmnTaskService;
     protected CmmnHistoryService cmmnHistoryService;
     
     protected String deploymentId;
@@ -71,6 +73,7 @@ public class FlowableCmmnTestCase {
         this.cmmnRepositoryService = cmmnEngineConfiguration.getCmmnRepositoryService();
         this.cmmnManagementService = cmmnEngineConfiguration.getCmmnManagementService();
         this.cmmnRuntimeService = cmmnEngineConfiguration.getCmmnRuntimeService();
+        this.cmmnTaskService = cmmnEngineConfiguration.getCmmnTaskService();
         this.cmmnHistoryService = cmmnEngineConfiguration.getCmmnHistoryService();
     }
     
@@ -81,6 +84,13 @@ public class FlowableCmmnTestCase {
         }
     }
     
+    protected void deployOneHumanTaskCaseModel() {
+        deploymentId = cmmnRepositoryService.createDeployment()
+                .addClasspathResource("org/flowable/cmmn/test/one-human-task-model.cmmn")
+                .deploy()
+                .getId();
+    }
+    
     protected void deployOneTaskCaseModel() {
         deploymentId = cmmnRepositoryService.createDeployment()
                 .addClasspathResource("org/flowable/cmmn/test/one-task-model.cmmn")

modules/flowable-cmmn-engine/src/main/resources/org/flowable/cmmn/db/mapping/mappings.xml

@@ -31,5 +31,15 @@
     <mapper resource="org/flowable/variable/db/mapping/entity/ByteArray.xml" />
     <mapper resource="org/flowable/variable/db/mapping/entity/VariableInstance.xml" />
     <mapper resource="org/flowable/variable/db/mapping/entity/HistoricVariableInstance.xml" />
+    
+    <!-- Identity link support -->
+    <mapper resource="org/flowable/identitylink/db/mapping/entity/IdentityLink.xml" />
+    <mapper resource="org/flowable/identitylink/db/mapping/entity/HistoricIdentityLink.xml" />
+    
+    <!-- Task support -->
+    <mapper resource="org/flowable/task/db/mapping/common.xml" />
+    <mapper resource="org/flowable/task/db/mapping/entity/Task.xml" />
+    <mapper resource="org/flowable/task/db/mapping/entity/HistoricTaskInstance.xml" />
+    
   </mappers>
 </configuration>

modules/flowable-cmmn-engine/src/test/java/org/flowable/cmmn/test/persistence/EntitiesTest.java

@@ -99,7 +99,7 @@ public class EntitiesTest {
             for (int i = 0; i < nodeList.getLength(); i++) {
                 Node node = nodeList.item(i);
                 String resource = node.getAttributes().getNamedItem("resource").getTextContent();
-                if (resource.startsWith("org/flowable/cmmn")) {
+                if (resource.startsWith("org/flowable/cmmn") && !resource.contains("common.xml")) {
                     resource = resource.replaceAll("org/flowable/cmmn/db/mapping/entity/", "");
                     resource = resource.replaceAll(".xml", "");
                     resources.add(resource);

modules/flowable-cmmn-engine/src/test/java/org/flowable/cmmn/test/runtime/VariablesTest.java

@@ -25,12 +25,12 @@ import java.util.Map;
 import org.flowable.cmmn.engine.delegate.DelegatePlanItemInstance;
 import org.flowable.cmmn.engine.delegate.PlanItemJavaDelegate;
 import org.flowable.cmmn.engine.history.HistoricMilestoneInstance;
-import org.flowable.cmmn.engine.impl.variable.VariableScopeType;
 import org.flowable.cmmn.engine.runtime.CaseInstance;
 import org.flowable.cmmn.engine.runtime.PlanItemInstance;
 import org.flowable.cmmn.engine.test.CmmnDeployment;
 import org.flowable.cmmn.engine.test.FlowableCmmnTestCase;
 import org.flowable.variable.service.history.HistoricVariableInstance;
+import org.flowable.variable.service.type.VariableScopeType;
 import org.junit.Test;
 
 /**

modules/flowable-cmmn-engine/src/test/java/org/flowable/cmmn/test/task/CmmnTaskQueryTest.java

+/* Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.flowable.cmmn.test.task;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+import java.util.List;
+
+import org.flowable.cmmn.engine.repository.CaseDefinition;
+import org.flowable.cmmn.engine.repository.CmmnDeployment;
+import org.flowable.cmmn.engine.runtime.CaseInstance;
+import org.flowable.cmmn.engine.runtime.PlanItemInstance;
+import org.flowable.cmmn.engine.test.FlowableCmmnTestCase;
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * @author Joram Barrez
+ */
+public class CmmnTaskQueryTest extends FlowableCmmnTestCase {
+    
+    private static final int NR_CASE_INSTANCES = 5;
+    
+    @Before
+    public void createCaseInstance() {
+        deployOneHumanTaskCaseModel();
+        
+        for (int i=0; i<NR_CASE_INSTANCES; i++) {
+            cmmnRuntimeService.createCaseInstanceBuilder().caseDefinitionKey("oneTaskCase").variable("index", i).start();
+        }
+    }
+    
+    @Test
+    public void testNoParams() {
+        assertEquals(NR_CASE_INSTANCES, cmmnTaskService.createTaskQuery().count());
+        assertEquals(NR_CASE_INSTANCES, cmmnTaskService.createTaskQuery().list().size());
+    }
+    
+    @Test
+    public void testQueryByCaseInstanceId() {
+        List<CaseInstance> caseInstances = cmmnRuntimeService.createCaseInstanceQuery().list();
+        assertEquals(5, caseInstances.size());
+        for (CaseInstance caseInstance : caseInstances) {
+            assertEquals(1, cmmnTaskService.createTaskQuery().caseInstanceId(caseInstance.getId()).list().size());
+        }
+    }
+    
+    @Test
+    public void testQueryByPlanItemInstanceId() {
+        List<CaseInstance> caseInstances = cmmnRuntimeService.createCaseInstanceQuery().list();
+        assertEquals(5, caseInstances.size());
+        for (CaseInstance caseInstance : caseInstances) {
+            List<PlanItemInstance> planItemInstances = cmmnRuntimeService.createPlanItemInstanceQuery().planItemInstanceStateActive().caseInstanceId(caseInstance.getId()).list();
+            assertEquals(1, planItemInstances.size());
+            assertNotNull(cmmnTaskService.createTaskQuery().planItemInstanceId(planItemInstances.get(0).getId()));
+            assertNotNull(cmmnTaskService.createTaskQuery()
+                    .caseInstanceId(caseInstance.getId())
+                    .planItemInstanceId(planItemInstances.get(0).getId()));
+            assertNotNull(cmmnTaskService.createTaskQuery()
+                    .caseInstanceId(caseInstance.getId())
+                    .caseDefinitionId(caseInstance.getCaseDefinitionId())
+                    .planItemInstanceId(planItemInstances.get(0).getId()));
+        }
+    }
+    
+    @Test
+    public void testQueryByCaseDefinitionId() {
+        CaseDefinition caseDefinition = cmmnRepositoryService.createCaseDefinitionQuery().singleResult();
+        assertNotNull(caseDefinition);
+        assertEquals(NR_CASE_INSTANCES, cmmnTaskService.createTaskQuery().caseDefinitionId(caseDefinition.getId()).list().size());
+    }
+    
+    @Test
+    public void testQueryByCmmnDeploymentId() {
+        CmmnDeployment deployment = cmmnRepositoryService.createDeploymentQuery().singleResult();
+        assertNotNull(deployment);
+        assertEquals(NR_CASE_INSTANCES, cmmnTaskService.createTaskQuery().cmmnDeploymentId(deployment.getId()).list().size());
+    }
+    
+    @Test
+    public void testQueryByAssignee() {
+        assertEquals(NR_CASE_INSTANCES, cmmnTaskService.createTaskQuery().taskAssignee("johnDoe").list().size());
+    }
+    
+    @Test
+    public void testQueryByVariableValueEquals() {
+        for (int i=0; i<NR_CASE_INSTANCES; i++) {
+            assertNotNull(cmmnTaskService.createTaskQuery().taskVariableValueEquals(i));
+        }
+    }
+
+}

modules/flowable-cmmn-engine/src/test/java/org/flowable/cmmn/test/task/CmmnTaskServiceTest.java

+/* Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.flowable.cmmn.test.task;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+
+import org.flowable.cmmn.engine.runtime.CaseInstance;
+import org.flowable.cmmn.engine.runtime.PlanItemInstance;
+import org.flowable.cmmn.engine.test.CmmnDeployment;
+import org.flowable.cmmn.engine.test.FlowableCmmnTestCase;
+import org.flowable.engine.common.impl.history.HistoryLevel;
+import org.flowable.task.service.Task;
+import org.flowable.task.service.history.HistoricTaskInstance;
+import org.flowable.variable.service.type.VariableScopeType;
+import org.junit.Test;
+
+/**
+ * @author Joram Barrez
+ */
+public class CmmnTaskServiceTest extends FlowableCmmnTestCase {
+    
+    @Test
+    @CmmnDeployment
+    public void testOneHumanTaskCase() {
+        CaseInstance caseInstance = cmmnRuntimeService.createCaseInstanceBuilder().caseDefinitionKey("oneHumanTaskCase").start();
+        Task task = cmmnTaskService.createTaskQuery().caseInstanceId(caseInstance.getId()).singleResult();
+        assertNotNull(task);
+        assertEquals("johnDoe", task.getAssignee());
+        
+        if (cmmnEngineConfiguration.getHistoryLevel().isAtLeast(HistoryLevel.ACTIVITY)) {
+            HistoricTaskInstance historicTaskInstance = cmmnHistoryService.createHistoricTaskInstanceQuery().caseInstanceId(caseInstance.getId()).singleResult();
+            assertNotNull(historicTaskInstance);
+            assertNull(historicTaskInstance.getEndTime());
+        }
+        
+        cmmnTaskService.complete(task.getId());
+        assertCaseInstanceEnded(caseInstance);
+        
+        if (cmmnEngineConfiguration.getHistoryLevel().isAtLeast(HistoryLevel.ACTIVITY)) {
+            HistoricTaskInstance historicTaskInstance = cmmnHistoryService.createHistoricTaskInstanceQuery().caseInstanceId(caseInstance.getId()).singleResult();
+            assertNotNull(historicTaskInstance);
+            assertNotNull(historicTaskInstance.getEndTime());
+        }
+    }
+    
+    @Test
+    @CmmnDeployment
+    public void testTriggerOneHumanTaskCaseProgrammatically() {
+        CaseInstance caseInstance = cmmnRuntimeService.createCaseInstanceBuilder().caseDefinitionKey("oneHumanTaskCase").start();
+        Task task = cmmnTaskService.createTaskQuery().caseInstanceId(caseInstance.getId()).singleResult();
+        
+        PlanItemInstance planItemInstance = cmmnRuntimeService.createPlanItemInstanceQuery().planItemInstanceStateActive().singleResult();
+        assertEquals(planItemInstance.getId(), task.getSubScopeId());
+        assertEquals(planItemInstance.getCaseInstanceId(), task.getScopeId());
+        assertEquals(planItemInstance.getCaseDefinitionId(), task.getScopeDefinitionId());
+        assertEquals(VariableScopeType.CMMN, task.getScopeType());
+        
+        cmmnRuntimeService.triggerPlanItemInstance(planItemInstance.getId());
+        assertEquals(0, cmmnTaskService.createTaskQuery().count());
+        assertCaseInstanceEnded(caseInstance);
+    }
+
+}

modules/flowable-cmmn-engine/src/test/resources/org/flowable/cmmn/test/one-human-task-model.cmmn

+<?xml version="1.0" encoding="UTF-8"?>
+<definitions xmlns="http://www.omg.org/spec/CMMN/20151109/MODEL" 
+    xmlns:dc="http://www.omg.org/spec/CMMN/20151109/DC" 
+    xmlns:di="http://www.omg.org/spec/CMMN/20151109/DI"
+    xmlns:cmmndi="http://www.omg.org/spec/CMMN/20151109/CMMNDI" 
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
+    xmlns:flowable="http://flowable.org/cmmn"
+    targetNamespace="http://flowable.org/cmmn">
+    <case id="oneTaskCase">
+        <casePlanModel id="myPlanModel" name="My CasePlanModel">
+            <planItem id="planItem1" name="The task" definitionRef="theTask" />
+            <humanTask id="theTask" name="The Task" flowable:assignee="johnDoe" />
+        </casePlanModel>
+    </case>
+</definitions>

modules/flowable-cmmn-engine/src/test/resources/org/flowable/cmmn/test/task/CmmnTaskServiceTest.testOneHumanTaskCase.cmmn

+<?xml version="1.0" encoding="UTF-8"?>
+<definitions xmlns="http://www.omg.org/spec/CMMN/20151109/MODEL" 
+    xmlns:dc="http://www.omg.org/spec/CMMN/20151109/DC" 
+    xmlns:di="http://www.omg.org/spec/CMMN/20151109/DI"
+    xmlns:cmmndi="http://www.omg.org/spec/CMMN/20151109/CMMNDI" 
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
+    xmlns:flowable="http://flowable.org/cmmn"
+    targetNamespace="http://flowable.org/cmmn">
+
+    <case id="oneHumanTaskCase">
+        <casePlanModel id="myPlanModel" name="My CasePlanModel">
+            <planItem id="planItem1" name="The Task" definitionRef="theTask" />
+            <humanTask id="theTask" name="The Task" isBlocking="true" flowable:assignee="johnDoe" />
+        </casePlanModel>
+    </case>
+
+</definitions>

modules/flowable-cmmn-engine/src/test/resources/org/flowable/cmmn/test/task/CmmnTaskServiceTest.testTriggerOneHumanTaskCaseProgrammatically.cmmn

+<?xml version="1.0" encoding="UTF-8"?>
+<definitions xmlns="http://www.omg.org/spec/CMMN/20151109/MODEL" 
+    xmlns:dc="http://www.omg.org/spec/CMMN/20151109/DC" 
+    xmlns:di="http://www.omg.org/spec/CMMN/20151109/DI"
+    xmlns:cmmndi="http://www.omg.org/spec/CMMN/20151109/CMMNDI" 
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
+    xmlns:flowable="http://flowable.org/cmmn"
+    targetNamespace="http://flowable.org/cmmn">
+
+    <case id="oneHumanTaskCase">
+        <casePlanModel id="myPlanModel" name="My CasePlanModel">
+            <planItem id="planItem1" name="The Task" definitionRef="theTask" />
+            <humanTask id="theTask" name="The Task" isBlocking="true" flowable:assignee="johnDoe" />
+        </casePlanModel>
+    </case>
+
+</definitions>

modules/flowable-cmmn-model/src/main/java/org/flowable/cmmn/model/HumanTask.java

@@ -25,9 +25,7 @@ public class HumanTask extends Task {
     protected String priority;
     protected String formKey;
     protected String dueDate;
-    protected String businessCalendarName;
     protected String category;
-    protected String extensionId;
     protected List<String> candidateUsers = new ArrayList<>();
     protected List<String> candidateGroups = new ArrayList<>();
 
@@ -71,14 +69,6 @@ public class HumanTask extends Task {
         this.dueDate = dueDate;
     }
 
-    public String getBusinessCalendarName() {
-        return businessCalendarName;
-    }
-
-    public void setBusinessCalendarName(String businessCalendarName) {
-        this.businessCalendarName = businessCalendarName;
-    }
-
     public String getCategory() {
         return category;
     }
@@ -87,18 +77,6 @@ public class HumanTask extends Task {
         this.category = category;
     }
 
-    public String getExtensionId() {
-        return extensionId;
-    }
-
-    public void setExtensionId(String extensionId) {
-        this.extensionId = extensionId;
-    }
-
-    public boolean isExtended() {
-        return extensionId != null && !extensionId.isEmpty();
-    }
-
     public List<String> getCandidateUsers() {
         return candidateUsers;
     }
@@ -129,7 +107,6 @@ public class HumanTask extends Task {
         setDueDate(otherElement.getDueDate());
         setPriority(otherElement.getPriority());
         setCategory(otherElement.getCategory());
-        setExtensionId(otherElement.getExtensionId());
         
         setCandidateGroups(new ArrayList<>(otherElement.getCandidateGroups()));
         setCandidateUsers(new ArrayList<>(otherElement.getCandidateUsers()));

modules/flowable-engine-common/src/main/java/org/flowable/engine/common/impl/db/AbstractSqlScriptBasedDbSchemaManager.java

@@ -138,7 +138,7 @@ public abstract class AbstractSqlScriptBasedDbSchemaManager implements DbSchemaM
     public String getProperty(String propertyName) {
         PreparedStatement statement = null;
         try {
-            String tableName = PROPERTY_TABLE;
+            String tableName = getPropertyTable();
             if (!getDbSqlSession().getDbSqlSessionFactory().isTablePrefixIsSchema()) {
                 tableName = prependDatabaseTablePrefix(tableName);
             }
@@ -167,7 +167,7 @@ public abstract class AbstractSqlScriptBasedDbSchemaManager implements DbSchemaM
         PreparedStatement statement = null;
         PreparedStatement statement2 = null;
         try {
-            String tableName = PROPERTY_TABLE;
+            String tableName = getPropertyTable();
             if (!getDbSqlSession().getDbSqlSessionFactory().isTablePrefixIsSchema()) {
                 tableName = prependDatabaseTablePrefix(tableName);
             }
@@ -202,6 +202,10 @@ public abstract class AbstractSqlScriptBasedDbSchemaManager implements DbSchemaM
         }
     }
     
+    protected String getPropertyTable() {
+        return PROPERTY_TABLE;
+    }
+    
     public String getResourceForDbOperation(String directory, String operation, String component, String databaseType) {
         return getResourcesRootDirectory() + directory + "/flowable." + databaseType + "." + operation + "." + component + ".sql";
     }
@@ -219,7 +223,7 @@ public abstract class AbstractSqlScriptBasedDbSchemaManager implements DbSchemaM
             inputStream = ReflectUtil.getResourceAsStream(resourceName);
             if (inputStream == null) {
                 if (isOptional) {
-                    LOGGER.info("no schema resource {} for {}", resourceName, operation);
+                    LOGGER.debug("no schema resource {} for {}", resourceName, operation);
                 } else {
                     throw new FlowableException("resource '" + resourceName + "' is not available");
                 }

modules/flowable-engine-common/src/main/java/org/flowable/engine/common/impl/db/ServiceSqlScriptBasedDbSchemaManager.java

@@ -12,6 +12,7 @@
  */
 package org.flowable.engine.common.impl.db;
 
+import org.flowable.engine.common.api.FlowableException;
 import org.flowable.engine.common.api.FlowableWrongDbException;
 import org.flowable.engine.common.impl.FlowableVersions;
 
@@ -40,10 +41,14 @@ public abstract class ServiceSqlScriptBasedDbSchemaManager extends AbstractSqlSc
                 throw new FlowableWrongDbException(FlowableVersions.CURRENT_VERSION, dbVersion);
             }
         } else {
-            executeMandatorySchemaResource("create", schemaComponent);
-            if (isHistoryUsed()) {
-                executeMandatorySchemaResource("create", schemaComponentHistory);
-            }
+            internalDbSchemaCreate();
+        }
+    }
+
+    protected void internalDbSchemaCreate() {
+        executeMandatorySchemaResource("create", schemaComponent);
+        if (isHistoryUsed()) {
+            executeMandatorySchemaResource("create", schemaComponentHistory);
         }
     }
 
@@ -92,9 +97,18 @@ public abstract class ServiceSqlScriptBasedDbSchemaManager extends AbstractSqlSc
     }
 
     protected String getSchemaVersion() {
-        // The service schema version properties were introduced in 6.2.0.
+        if (schemaVersionProperty == null) {
+            throw new FlowableException("Schema version property is not set");
+        }
         String dbVersion = getProperty(schemaVersionProperty);
+        if (dbVersion == null) {
+            return getUpgradeStartVersion();
+        }
         return dbVersion;
     }
+    
+    protected String getUpgradeStartVersion() {
+        return "6.1.2.0"; // last version before most services were separated. Start upgrading from this point.
+    }
 
 }

modules/flowable-engine/src/main/java/org/flowable/engine/impl/cfg/ProcessEngineConfigurationImpl.java

@@ -272,6 +272,7 @@ import org.flowable.engine.impl.scripting.VariableScopeResolverFactory;
 import org.flowable.engine.impl.util.ProcessInstanceHelper;
 import org.flowable.engine.parse.BpmnParseHandler;
 import org.flowable.identitylink.service.IdentityLinkServiceConfiguration;
+import org.flowable.identitylink.service.impl.db.IdentityLinkDbSchemaManager;
 import org.flowable.idm.engine.IdmEngineConfiguration;
 import org.flowable.image.impl.DefaultProcessDiagramGenerator;
 import org.flowable.job.service.HistoryJobHandler;
@@ -285,6 +286,7 @@ import org.flowable.job.service.impl.asyncexecutor.DefaultAsyncJobExecutor;
 import org.flowable.job.service.impl.asyncexecutor.ExecuteAsyncRunnableFactory;
 import org.flowable.job.service.impl.asyncexecutor.FailedJobCommandFactory;
 import org.flowable.job.service.impl.asyncexecutor.JobManager;
+import org.flowable.job.service.impl.db.JobDbSchemaManager;
 import org.flowable.task.service.InternalTaskLocalizationManager;
 import org.flowable.task.service.InternalTaskVariableScopeResolver;
 import org.flowable.task.service.TaskServiceConfiguration;
@@ -739,8 +741,10 @@ public abstract class ProcessEngineConfigurationImpl extends ProcessEngineConfig
     // agenda factory
     protected FlowableEngineAgendaFactory agendaFactory;
     
+    protected DbSchemaManager identityLinkDbSchemaManager;
     protected DbSchemaManager variableDbSchemaManager;
     protected DbSchemaManager taskDbSchemaManager;
+    protected DbSchemaManager jobDbSchemaManager;
 
     // Backwards compatibility //////////////////////////////////////////////////////////////
 
@@ -918,8 +922,10 @@ public abstract class ProcessEngineConfigurationImpl extends ProcessEngineConfig
     public void initDbSchemaManagers() {
         super.initDbSchemaManager();
         initProcessDbSchemaManager();
+        initIdentityLinkDbSchemaManager();
         initVariableDbSchemaManager();
         initTaskDbSchemaManager();
+        initJobDbSchemaManager();
     }
 
     protected void initProcessDbSchemaManager() {
@@ -939,6 +945,18 @@ public abstract class ProcessEngineConfigurationImpl extends ProcessEngineConfig
             this.taskDbSchemaManager = new TaskDbSchemaManager();
         }
     }
+    
+    protected void initIdentityLinkDbSchemaManager() {
+        if (this.identityLinkDbSchemaManager == null) {
+            this.identityLinkDbSchemaManager = new IdentityLinkDbSchemaManager();
+        }
+    }
+    
+    protected void initJobDbSchemaManager() {
+        if (this.jobDbSchemaManager == null) {
+            this.jobDbSchemaManager = new JobDbSchemaManager();
+        }
+    }
 
     public void initMybatisTypeHandlers(Configuration configuration) {
         configuration.getTypeHandlerRegistry().register(VariableType.class, JdbcType.VARCHAR, new IbatisVariableTypeHandler(variableTypes));
@@ -3420,6 +3438,24 @@ public abstract class ProcessEngineConfigurationImpl extends ProcessEngineConfig
         this.taskDbSchemaManager = taskDbSchemaManager;
         return this;
     }
+    
+    public DbSchemaManager getIdentityLinkDbSchemaManager() {
+        return identityLinkDbSchemaManager;
+    }
+
+    public ProcessEngineConfigurationImpl setIdentityLinkDbSchemaManager(DbSchemaManager identityLinkDbSchemaManager) {
+        this.identityLinkDbSchemaManager = identityLinkDbSchemaManager;
+        return this;
+    }
+    
+    public DbSchemaManager getJobDbSchemaManager() {
+        return jobDbSchemaManager;
+    }
+
+    public ProcessEngineConfigurationImpl setJobDbSchemaManager(DbSchemaManager jobDbSchemaManager) {
+        this.jobDbSchemaManager = jobDbSchemaManager;
+        return this;
+    }
 
     // Flowable 5
 

modules/flowable-engine/src/main/java/org/flowable/engine/impl/db/ProcessDbSchemaManager.java

@@ -89,8 +89,10 @@ public class ProcessDbSchemaManager extends AbstractSqlScriptBasedDbSchemaManage
     public void dbSchemaCreate() {
         
         getCommonDbSchemaManager().dbSchemaCreate();
+        getIdentityLinkDbSchemaManager().dbSchemaCreate();
         getTaskDbSchemaManager().dbSchemaCreate();
         getVariableDbSchemaManager().dbSchemaCreate();
+        getJobDbSchemaManager().dbSchemaCreate();
         
         if (isEngineTablePresent()) {
             String dbVersion = getDbVersion();
@@ -126,6 +128,12 @@ public class ProcessDbSchemaManager extends AbstractSqlScriptBasedDbSchemaManage
         } catch (Exception e) {
             LOGGER.info("Error dropping engine tables", e);
         }
+        
+        try {
+            getJobDbSchemaManager().dbSchemaDrop();
+        } catch (Exception e) {
+            LOGGER.info("Error dropping job tables", e);
+        }
      
         try {
             getVariableDbSchemaManager().dbSchemaDrop();
@@ -139,6 +147,12 @@ public class ProcessDbSchemaManager extends AbstractSqlScriptBasedDbSchemaManage
             LOGGER.info("Error dropping task tables", e);
         }
         
+        try {
+            getIdentityLinkDbSchemaManager().dbSchemaDrop();
+        } catch (Exception e) {
+            LOGGER.info("Error dropping identity link tables", e);
+        }
+        
         try {
             getCommonDbSchemaManager().dbSchemaDrop();
         } catch (Exception e) {
@@ -156,8 +170,10 @@ public class ProcessDbSchemaManager extends AbstractSqlScriptBasedDbSchemaManage
     public String dbSchemaUpdate() {
         
         getCommonDbSchemaManager().dbSchemaUpdate();
+        getIdentityLinkDbSchemaManager().dbSchemaUpdate();
         getTaskDbSchemaManager().dbSchemaUpdate();
         getVariableDbSchemaManager().dbSchemaUpdate();
+        getJobDbSchemaManager().dbSchemaUpdate();
 
         String feedback = null;
         boolean isUpgradeNeeded = false;
@@ -311,6 +327,10 @@ public class ProcessDbSchemaManager extends AbstractSqlScriptBasedDbSchemaManage
         return CommandContextUtil.getProcessEngineConfiguration().getCommonDbSchemaManager();
     }
     
+    protected DbSchemaManager getIdentityLinkDbSchemaManager() {
+        return CommandContextUtil.getProcessEngineConfiguration().getIdentityLinkDbSchemaManager();
+    }
+    
     protected DbSchemaManager getVariableDbSchemaManager() {
         return CommandContextUtil.getProcessEngineConfiguration().getVariableDbSchemaManager();
     }
@@ -319,6 +339,10 @@ public class ProcessDbSchemaManager extends AbstractSqlScriptBasedDbSchemaManage
         return CommandContextUtil.getProcessEngineConfiguration().getTaskDbSchemaManager();
     }
     
+    protected DbSchemaManager getJobDbSchemaManager() {
+        return CommandContextUtil.getProcessEngineConfiguration().getJobDbSchemaManager();
+    }
+    
     @Override
     protected String getResourcesRootDirectory() {
         return "org/flowable/db/";

modules/flowable-engine/src/main/java/org/flowable/engine/impl/history/DefaultHistoryManager.java

@@ -13,7 +13,6 @@
 
 package org.flowable.engine.impl.history;
 
-import java.util.Date;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
@@ -31,13 +30,11 @@ import org.flowable.engine.impl.persistence.entity.HistoricProcessInstanceEntity
 import org.flowable.engine.impl.util.CommandContextUtil;
 import org.flowable.engine.impl.util.TaskHelper;
 import org.flowable.identitylink.service.HistoricIdentityLinkService;
-import org.flowable.identitylink.service.IdentityLinkType;
 import org.flowable.identitylink.service.impl.persistence.entity.HistoricIdentityLinkEntity;
 import org.flowable.identitylink.service.impl.persistence.entity.IdentityLinkEntity;
 import org.flowable.task.service.HistoricTaskService;
 import org.flowable.task.service.impl.persistence.entity.HistoricTaskInstanceEntity;
 import org.flowable.task.service.impl.persistence.entity.TaskEntity;
-import org.flowable.variable.service.impl.persistence.entity.HistoricVariableInstanceEntity;
 import org.flowable.variable.service.impl.persistence.entity.VariableInstanceEntity;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -226,7 +223,6 @@ public class DefaultHistoryManager extends AbstractHistoryManager {
     @Override
     public void recordTaskCreated(TaskEntity task, ExecutionEntity execution) {
         if (isHistoryLevelAtLeast(HistoryLevel.AUDIT)) {
-            HistoricTaskService historicTaskService = CommandContextUtil.getHistoricTaskService();
             if (execution != null) {
                 task.setExecutionId(execution.getId());
                 task.setProcessInstanceId(execution.getProcessInstanceId());
@@ -236,14 +232,12 @@ public class DefaultHistoryManager extends AbstractHistoryManager {
                     task.setTenantId(execution.getTenantId());
                 }
             }
-            HistoricTaskInstanceEntity historicTaskInstance = historicTaskService.createHistoricTask(task);
+            HistoricTaskInstanceEntity historicTaskInstance = CommandContextUtil.getHistoricTaskService().recordTaskCreated(task);
             historicTaskInstance.setLastUpdateTime(processEngineConfiguration.getClock().getCurrentTime());
 
             if (execution != null) {
                 historicTaskInstance.setExecutionId(execution.getId());
             }
-
-            historicTaskService.insertHistoricTask(historicTaskInstance, false);
         }
 
         if (isHistoryLevelAtLeast(HistoryLevel.ACTIVITY)) {
@@ -259,9 +253,8 @@ public class DefaultHistoryManager extends AbstractHistoryManager {
     @Override
     public void recordTaskEnd(TaskEntity task, ExecutionEntity execution, String deleteReason) {
         if (isHistoryLevelAtLeast(HistoryLevel.AUDIT)) {
-            HistoricTaskInstanceEntity historicTaskInstance = CommandContextUtil.getHistoricTaskService().getHistoricTask(task.getId());
+            HistoricTaskInstanceEntity historicTaskInstance = CommandContextUtil.getHistoricTaskService().recordTaskEnd(task, deleteReason);
             if (historicTaskInstance != null) {
-                historicTaskInstance.markEnded(deleteReason);
                 historicTaskInstance.setLastUpdateTime(processEngineConfiguration.getClock().getCurrentTime());
             }
         }
@@ -269,35 +262,21 @@ public class DefaultHistoryManager extends AbstractHistoryManager {
 
     @Override
     public void recordTaskInfoChange(TaskEntity taskEntity) {
+        
+        HistoricTaskService historicTaskService = CommandContextUtil.getHistoricTaskService();
+        HistoricTaskInstanceEntity originalHistoricTaskInstanceEntity = historicTaskService.getHistoricTask(taskEntity.getId());
+        String originalAssignee = null;
+        if (originalHistoricTaskInstanceEntity != null) {
+            originalAssignee = originalHistoricTaskInstanceEntity.getAssignee();
+        }
+        
         boolean assigneeChanged = false;
         if (isHistoryLevelAtLeast(HistoryLevel.AUDIT)) {
-            HistoricTaskInstanceEntity historicTaskInstance = CommandContextUtil.getHistoricTaskService().getHistoricTask(taskEntity.getId());
+            HistoricTaskInstanceEntity historicTaskInstance = historicTaskService.recordTaskInfoChange(taskEntity);
             if (historicTaskInstance != null) {
-                historicTaskInstance.setName(taskEntity.getName());
-                historicTaskInstance.setDescription(taskEntity.getDescription());
-                historicTaskInstance.setDueDate(taskEntity.getDueDate());
-                historicTaskInstance.setPriority(taskEntity.getPriority());
-                historicTaskInstance.setCategory(taskEntity.getCategory());
-                historicTaskInstance.setFormKey(taskEntity.getFormKey());
-                historicTaskInstance.setParentTaskId(taskEntity.getParentTaskId());
-                historicTaskInstance.setTaskDefinitionKey(taskEntity.getTaskDefinitionKey());
-                historicTaskInstance.setProcessDefinitionId(taskEntity.getProcessDefinitionId());
-                historicTaskInstance.setClaimTime(taskEntity.getClaimTime());
-                
-                if (!Objects.equals(historicTaskInstance.getAssignee(), taskEntity.getAssignee())) {
-                    historicTaskInstance.setAssignee(taskEntity.getAssignee());
+                if (!Objects.equals(originalAssignee, taskEntity.getAssignee())) {
                     assigneeChanged = true;
-                    
-                    createHistoricIdentityLink(historicTaskInstance.getId(), IdentityLinkType.ASSIGNEE, historicTaskInstance.getAssignee());
-                }
-                
-                if (!Objects.equals(historicTaskInstance.getOwner(), taskEntity.getOwner())) {
-                    historicTaskInstance.setOwner(taskEntity.getOwner());
-                    
-                    createHistoricIdentityLink(historicTaskInstance.getId(), IdentityLinkType.OWNER, historicTaskInstance.getOwner());
                 }
-                
-                historicTaskInstance.setLastUpdateTime(processEngineConfiguration.getClock().getCurrentTime());
             }
         }
         
@@ -312,22 +291,10 @@ public class DefaultHistoryManager extends AbstractHistoryManager {
         }
     }
     
-    protected void createHistoricIdentityLink(String taskId, String type, String userId) {
-        HistoricIdentityLinkService historicIdentityLinkService = CommandContextUtil.getHistoricIdentityLinkService();
-        HistoricIdentityLinkEntity historicIdentityLinkEntity = historicIdentityLinkService.createHistoricIdentityLink();
-        historicIdentityLinkEntity.setTaskId(taskId);
-        historicIdentityLinkEntity.setType(type);
-        historicIdentityLinkEntity.setUserId(userId);
-        Date time = getClock().getCurrentTime();
-        historicIdentityLinkEntity.setCreateTime(time);
-        historicIdentityLinkService.insertHistoricIdentityLink(historicIdentityLinkEntity, false);
-    }
-
     // Variables related history
 
     @Override
     public void recordVariableCreate(VariableInstanceEntity variable) {
-        // Historic variables
         if (isHistoryLevelAtLeast(HistoryLevel.ACTIVITY)) {
             CommandContextUtil.getHistoricVariableService().createAndInsert(variable);
         }
@@ -349,18 +316,16 @@ public class DefaultHistoryManager extends AbstractHistoryManager {
     }
 
     @Override
-    public void recordVariableUpdate(VariableInstanceEntity variable) {
+    public void recordVariableUpdate(VariableInstanceEntity variableInstanceEntity) {
         if (isHistoryLevelAtLeast(HistoryLevel.ACTIVITY)) {
-            HistoricVariableInstanceEntity historicProcessVariable = getEntityCache().findInCache(HistoricVariableInstanceEntity.class, variable.getId());
-            if (historicProcessVariable == null) {
-                historicProcessVariable = CommandContextUtil.getHistoricVariableService().getHistoricVariableInstance(variable.getId());
-            }
+            CommandContextUtil.getHistoricVariableService().recordVariableUpdate(variableInstanceEntity);
+        }
+    }
 
-            if (historicProcessVariable != null) {
-                CommandContextUtil.getHistoricVariableService().copyVariableValue(historicProcessVariable, variable);
-            } else {
-                CommandContextUtil.getHistoricVariableService().createAndInsert(variable);
-            }
+    @Override
+    public void recordVariableRemoved(VariableInstanceEntity variableInstanceEntity) {
+        if (isHistoryLevelAtLeast(HistoryLevel.ACTIVITY)) {
+            CommandContextUtil.getHistoricVariableService().recordVariableRemoved(variableInstanceEntity);
         }
     }
 
@@ -415,20 +380,4 @@ public class DefaultHistoryManager extends AbstractHistoryManager {
         }
     }
 
-    @Override
-    public void recordVariableRemoved(VariableInstanceEntity variable) {
-        if (isHistoryLevelAtLeast(HistoryLevel.ACTIVITY)) {
-            HistoricVariableInstanceEntity historicProcessVariable = getEntityCache()
-                    .findInCache(HistoricVariableInstanceEntity.class, variable.getId());
-            
-            if (historicProcessVariable == null) {
-                historicProcessVariable = CommandContextUtil.getHistoricVariableService().getHistoricVariableInstance(variable.getId());
-            }
-
-            if (historicProcessVariable != null) {
-                CommandContextUtil.getHistoricVariableService().deleteHistoricVariableInstance(historicProcessVariable);
-            }
-        }
-    }
-
 }

modules/flowable-engine/src/main/resources/org/flowable/db/create/flowable.db2.create.engine.sql

@@ -63,105 +63,6 @@ create table ACT_RU_EXECUTION (
     primary key (ID_)
 );
 
-create table ACT_RU_JOB (
-    ID_ varchar(64) not null,
-    REV_ integer,
-    TYPE_ varchar(255) not null,
-    LOCK_EXP_TIME_ timestamp,
-    LOCK_OWNER_ varchar(255),
-    EXCLUSIVE_ smallint check(EXCLUSIVE_ in (1,0)),
-    EXECUTION_ID_ varchar(64),
-    PROCESS_INSTANCE_ID_ varchar(64),
-    PROC_DEF_ID_ varchar(64),
-    RETRIES_ integer,
-    EXCEPTION_STACK_ID_ varchar(64),
-    EXCEPTION_MSG_ varchar(4000),
-    DUEDATE_ timestamp,
-    REPEAT_ varchar(255),
-    HANDLER_TYPE_ varchar(255),
-    HANDLER_CFG_ varchar(4000),
-    CREATE_TIME_ timestamp,
-    TENANT_ID_ varchar(255) default '',
-    primary key (ID_)
-);
-
-create table ACT_RU_TIMER_JOB (
-    ID_ varchar(64) not null,
-    REV_ integer,
-    TYPE_ varchar(255) not null,
-    LOCK_EXP_TIME_ timestamp,
-    LOCK_OWNER_ varchar(255),
-    EXCLUSIVE_ smallint check(EXCLUSIVE_ in (1,0)),
-    EXECUTION_ID_ varchar(64),
-    PROCESS_INSTANCE_ID_ varchar(64),
-    PROC_DEF_ID_ varchar(64),
-    RETRIES_ integer,
-    EXCEPTION_STACK_ID_ varchar(64),
-    EXCEPTION_MSG_ varchar(4000),
-    DUEDATE_ timestamp,
-    REPEAT_ varchar(255),
-    HANDLER_TYPE_ varchar(255),
-    HANDLER_CFG_ varchar(4000),
-    CREATE_TIME_ timestamp,
-    TENANT_ID_ varchar(255) default '',
-    primary key (ID_)
-);
-
-create table ACT_RU_SUSPENDED_JOB (
-    ID_ varchar(64) not null,
-    REV_ integer,
-    TYPE_ varchar(255) not null,
-    EXCLUSIVE_ smallint check(EXCLUSIVE_ in (1,0)),
-    EXECUTION_ID_ varchar(64),
-    PROCESS_INSTANCE_ID_ varchar(64),
-    PROC_DEF_ID_ varchar(64),
-    RETRIES_ integer,
-    EXCEPTION_STACK_ID_ varchar(64),
-    EXCEPTION_MSG_ varchar(4000),
-    DUEDATE_ timestamp,
-    REPEAT_ varchar(255),
-    HANDLER_TYPE_ varchar(255),
-    HANDLER_CFG_ varchar(4000),
-    CREATE_TIME_ timestamp,
-    TENANT_ID_ varchar(255) default '',
-    primary key (ID_)
-);
-
-create table ACT_RU_DEADLETTER_JOB (
-    ID_ varchar(64) not null,
-    REV_ integer,
-    TYPE_ varchar(255) not null,
-    EXCLUSIVE_ smallint check(EXCLUSIVE_ in (1,0)),
-    EXECUTION_ID_ varchar(64),
-    PROCESS_INSTANCE_ID_ varchar(64),
-    PROC_DEF_ID_ varchar(64),
-    EXCEPTION_STACK_ID_ varchar(64),
-    EXCEPTION_MSG_ varchar(4000),
-    DUEDATE_ timestamp,
-    REPEAT_ varchar(255),
-    HANDLER_TYPE_ varchar(255),
-    HANDLER_CFG_ varchar(4000),
-    CREATE_TIME_ timestamp,
-    TENANT_ID_ varchar(255) default '',
-    primary key (ID_)
-);
-
-create table ACT_RU_HISTORY_JOB (
-    ID_ varchar(64) NOT NULL,
-    REV_ integer,
-    LOCK_EXP_TIME_ timestamp,
-    LOCK_OWNER_ varchar(255),
-    RETRIES_ integer,
-    EXCEPTION_STACK_ID_ varchar(64),
-    EXCEPTION_MSG_ varchar(4000),
-    HANDLER_TYPE_ varchar(255),
-    HANDLER_CFG_ varchar(4000),
-    ADV_HANDLER_CFG_ID_ varchar(64),
-    CREATE_TIME_ timestamp,
-    TENANT_ID_ varchar(255) default '',
-    primary key (ID_)
-);
-
 create table ACT_RE_PROCDEF (
     ID_ varchar(64) not null,
     REV_ integer,
@@ -181,18 +82,6 @@ create table ACT_RE_PROCDEF (
     primary key (ID_)
 );
 
-create table ACT_RU_IDENTITYLINK (
-    ID_ varchar(64) not null,
-    REV_ integer,
-    GROUP_ID_ varchar(255),
-    TYPE_ varchar(255),
-    USER_ID_ varchar(255),
-    TASK_ID_ varchar(64),
-    PROC_INST_ID_ varchar(64),
-    PROC_DEF_ID_ varchar(64),
-    primary key (ID_)
-);
-
 create table ACT_RU_EVENT_SUBSCR (
     ID_ varchar(64) not null,
     REV_ integer,
@@ -234,8 +123,6 @@ create table ACT_PROCDEF_INFO (
 
 create index ACT_IDX_EXEC_BUSKEY on ACT_RU_EXECUTION(BUSINESS_KEY_);
 create index ACT_IDC_EXEC_ROOT on ACT_RU_EXECUTION(ROOT_PROC_INST_ID_);
-create index ACT_IDX_IDENT_LNK_USER on ACT_RU_IDENTITYLINK(USER_ID_);
-create index ACT_IDX_IDENT_LNK_GROUP on ACT_RU_IDENTITYLINK(GROUP_ID_);
 create index ACT_IDX_EVENT_SUBSCR_CONFIG_ on ACT_RU_EVENT_SUBSCR(CONFIGURATION_);
 create index ACT_IDX_VARIABLE_TASK_ID on ACT_RU_VARIABLE(TASK_ID_);
 create index ACT_IDX_ATHRZ_PROCEDEF on ACT_RU_IDENTITYLINK(PROC_DEF_ID_);
@@ -255,19 +142,15 @@ create index ACT_IDX_EVENT_SUBSCR_EXEC_ID on ACT_RU_EVENT_SUBSCR(EXECUTION_ID_);
 create index ACT_IDX_JOB_EXECUTION_ID on ACT_RU_JOB(EXECUTION_ID_);
 create index ACT_IDX_JOB_PROCESS_INSTANCE_ID on ACT_RU_JOB(PROCESS_INSTANCE_ID_);
 create index ACT_IDX_JOB_PROC_DEF_ID on ACT_RU_JOB(PROC_DEF_ID_);
-create index ACT_IDX_JOB_EXCEPTION_STACK_ID on ACT_RU_JOB(EXCEPTION_STACK_ID_);
 create index ACT_IDX_TIMER_JOB_EXECUTION_ID on ACT_RU_TIMER_JOB(EXECUTION_ID_);
 create index ACT_IDX_TIMER_JOB_PROCESS_INSTANCE_ID on ACT_RU_TIMER_JOB(PROCESS_INSTANCE_ID_);
 create index ACT_IDX_TIMER_JOB_PROC_DEF_ID on ACT_RU_TIMER_JOB(PROC_DEF_ID_);
-create index ACT_IDX_TIMER_JOB_EXCEPTION_STACK_ID on ACT_RU_TIMER_JOB(EXCEPTION_STACK_ID_);
 create index ACT_IDX_SUSPENDED_JOB_EXECUTION_ID on ACT_RU_SUSPENDED_JOB(EXECUTION_ID_);
 create index ACT_IDX_SUSPENDED_JOB_PROCESS_INSTANCE_ID on ACT_RU_SUSPENDED_JOB(PROCESS_INSTANCE_ID_);
 create index ACT_IDX_SUSPENDED_JOB_PROC_DEF_ID on ACT_RU_SUSPENDED_JOB(PROC_DEF_ID_);
-create index ACT_IDX_SUSPENDED_JOB_EXCEPTION_STACK_ID on ACT_RU_SUSPENDED_JOB(EXCEPTION_STACK_ID_);
 create index ACT_IDX_DEADLETTER_JOB_EXECUTION_ID on ACT_RU_DEADLETTER_JOB(EXECUTION_ID_);
 create index ACT_IDX_DEADLETTER_JOB_PROCESS_INSTANCE_ID on ACT_RU_DEADLETTER_JOB(PROCESS_INSTANCE_ID_);
 create index ACT_IDX_DEADLETTER_JOB_PROC_DEF_ID on ACT_RU_DEADLETTER_JOB(PROC_DEF_ID_);
-create index ACT_IDX_DEADLETTER_JOB_EXCEPTION_STACK_ID on ACT_RU_DEADLETTER_JOB(EXCEPTION_STACK_ID_);
 create index ACT_IDX_INFO_PROCDEF on ACT_PROCDEF_INFO(PROC_DEF_ID_);
 
 alter table ACT_GE_BYTEARRAY
@@ -354,11 +237,6 @@ alter table ACT_RU_JOB
     foreign key (PROC_DEF_ID_) 
     references ACT_RE_PROCDEF (ID_);
 
-alter table ACT_RU_JOB 
-    add constraint ACT_FK_JOB_EXCEPTION 
-    foreign key (EXCEPTION_STACK_ID_) 
-    references ACT_GE_BYTEARRAY (ID_);
-    
 alter table ACT_RU_TIMER_JOB 
     add constraint ACT_FK_TIMER_JOB_EXECUTION 
     foreign key (EXECUTION_ID_) 
@@ -374,11 +252,6 @@ alter table ACT_RU_TIMER_JOB
     foreign key (PROC_DEF_ID_) 
     references ACT_RE_PROCDEF (ID_);
     
-alter table ACT_RU_TIMER_JOB 
-    add constraint ACT_FK_TIMER_JOB_EXCEPTION 
-    foreign key (EXCEPTION_STACK_ID_) 
-    references ACT_GE_BYTEARRAY (ID_);
-    
 alter table ACT_RU_SUSPENDED_JOB 
     add constraint ACT_FK_SUSPENDED_JOB_EXECUTION 
     foreign key (EXECUTION_ID_) 
@@ -394,11 +267,6 @@ alter table ACT_RU_SUSPENDED_JOB
     foreign key (PROC_DEF_ID_) 
     references ACT_RE_PROCDEF (ID_);
     
-alter table ACT_RU_SUSPENDED_JOB 
-    add constraint ACT_FK_SUSPENDED_JOB_EXCEPTION 
-    foreign key (EXCEPTION_STACK_ID_) 
-    references ACT_GE_BYTEARRAY (ID_);
-    
 alter table ACT_RU_DEADLETTER_JOB 
     add constraint ACT_FK_DEADLETTER_JOB_EXECUTION 
     foreign key (EXECUTION_ID_) 
@@ -414,11 +282,6 @@ alter table ACT_RU_DEADLETTER_JOB
     foreign key (PROC_DEF_ID_) 
     references ACT_RE_PROCDEF (ID_);
     
-alter table ACT_RU_DEADLETTER_JOB 
-    add constraint ACT_FK_DEADLETTER_JOB_EXCEPTION 
-    foreign key (EXCEPTION_STACK_ID_) 
-    references ACT_GE_BYTEARRAY (ID_);
-    
 alter table ACT_RU_EVENT_SUBSCR
     add constraint ACT_FK_EVENT_EXEC
     foreign key (EXECUTION_ID_)

modules/flowable-engine/src/main/resources/org/flowable/db/create/flowable.db2.create.history.sql

@@ -89,17 +89,6 @@ create table ACT_HI_ATTACHMENT (
     primary key (ID_)
 );
 
-create table ACT_HI_IDENTITYLINK (
-    ID_ varchar(64) not null,
-    GROUP_ID_ varchar(255),
-    TYPE_ varchar(255),
-    USER_ID_ varchar(255),
-    TASK_ID_ varchar(64),
-    CREATE_TIME_ timestamp,
-    PROC_INST_ID_ varchar(64),
-    primary key (ID_)
-);
-
 create index ACT_IDX_HI_PRO_INST_END on ACT_HI_PROCINST(END_TIME_);
 create index ACT_IDX_HI_PRO_I_BUSKEY on ACT_HI_PROCINST(BUSINESS_KEY_);
 create index ACT_IDX_HI_ACT_INST_START on ACT_HI_ACTINST(START_TIME_);
@@ -114,7 +103,6 @@ create index ACT_IDX_HI_PROCVAR_TASK_ID on ACT_HI_VARINST(TASK_ID_);
 create index ACT_IDX_HI_PROCVAR_EXE on ACT_HI_VARINST(EXECUTION_ID_);
 create index ACT_IDX_HI_ACT_INST_PROCINST on ACT_HI_ACTINST(PROC_INST_ID_, ACT_ID_);
 create index ACT_IDX_HI_ACT_INST_EXEC on ACT_HI_ACTINST(EXECUTION_ID_, ACT_ID_);
-create index ACT_IDX_HI_IDENT_LNK_USER on ACT_HI_IDENTITYLINK(USER_ID_);
 create index ACT_IDX_HI_IDENT_LNK_TASK on ACT_HI_IDENTITYLINK(TASK_ID_);
 create index ACT_IDX_HI_IDENT_LNK_PROCINST on ACT_HI_IDENTITYLINK(PROC_INST_ID_);
 create index ACT_IDX_HI_TASK_INST_PROCINST on ACT_HI_TASKINST(PROC_INST_ID_);

modules/flowable-engine/src/main/resources/org/flowable/db/create/flowable.h2.create.engine.sql

@@ -63,105 +63,6 @@ create table ACT_RU_EXECUTION (
     primary key (ID_)
 );
 
-create table ACT_RU_JOB (
-    ID_ varchar(64) NOT NULL,
-    REV_ integer,
-    TYPE_ varchar(255) NOT NULL,
-    LOCK_EXP_TIME_ timestamp,
-    LOCK_OWNER_ varchar(255),
-    EXCLUSIVE_ boolean,
-    EXECUTION_ID_ varchar(64),
-    PROCESS_INSTANCE_ID_ varchar(64),
-    PROC_DEF_ID_ varchar(64),
-    RETRIES_ integer,
-    EXCEPTION_STACK_ID_ varchar(64),
-    EXCEPTION_MSG_ varchar(4000),
-    DUEDATE_ timestamp,
-    REPEAT_ varchar(255),
-    HANDLER_TYPE_ varchar(255),
-    HANDLER_CFG_ varchar(4000),
-    CREATE_TIME_ timestamp,
-    TENANT_ID_ varchar(255) default '',
-    primary key (ID_)
-);
-
-create table ACT_RU_TIMER_JOB (
-    ID_ varchar(64) NOT NULL,
-    REV_ integer,
-    TYPE_ varchar(255) NOT NULL,
-    LOCK_EXP_TIME_ timestamp,
-    LOCK_OWNER_ varchar(255),
-    EXCLUSIVE_ boolean,
-    EXECUTION_ID_ varchar(64),
-    PROCESS_INSTANCE_ID_ varchar(64),
-    PROC_DEF_ID_ varchar(64),
-    RETRIES_ integer,
-    EXCEPTION_STACK_ID_ varchar(64),
-    EXCEPTION_MSG_ varchar(4000),
-    DUEDATE_ timestamp,
-    REPEAT_ varchar(255),
-    HANDLER_TYPE_ varchar(255),
-    HANDLER_CFG_ varchar(4000),
-    CREATE_TIME_ timestamp,
-    TENANT_ID_ varchar(255) default '',
-    primary key (ID_)
-);
-
-create table ACT_RU_SUSPENDED_JOB (
-    ID_ varchar(64) NOT NULL,
-    REV_ integer,
-    TYPE_ varchar(255) NOT NULL,
-    EXCLUSIVE_ boolean,
-    EXECUTION_ID_ varchar(64),
-    PROCESS_INSTANCE_ID_ varchar(64),
-    PROC_DEF_ID_ varchar(64),
-    RETRIES_ integer,
-    EXCEPTION_STACK_ID_ varchar(64),
-    EXCEPTION_MSG_ varchar(4000),
-    DUEDATE_ timestamp,
-    REPEAT_ varchar(255),
-    HANDLER_TYPE_ varchar(255),
-    HANDLER_CFG_ varchar(4000),
-    CREATE_TIME_ timestamp,
-    TENANT_ID_ varchar(255) default '',
-    primary key (ID_)
-);
-
-create table ACT_RU_DEADLETTER_JOB (
-    ID_ varchar(64) NOT NULL,
-    REV_ integer,
-    TYPE_ varchar(255) NOT NULL,
-    EXCLUSIVE_ boolean,
-    EXECUTION_ID_ varchar(64),
-    PROCESS_INSTANCE_ID_ varchar(64),
-    PROC_DEF_ID_ varchar(64),
-    EXCEPTION_STACK_ID_ varchar(64),
-    EXCEPTION_MSG_ varchar(4000),
-    DUEDATE_ timestamp,
-    REPEAT_ varchar(255),
-    HANDLER_TYPE_ varchar(255),
-    HANDLER_CFG_ varchar(4000),
-    CREATE_TIME_ timestamp,
-    TENANT_ID_ varchar(255) default '',
-    primary key (ID_)
-);
-
-create table ACT_RU_HISTORY_JOB (
-    ID_ varchar(64) NOT NULL,
-    REV_ integer,
-    LOCK_EXP_TIME_ timestamp,
-    LOCK_OWNER_ varchar(255),
-    RETRIES_ integer,
-    EXCEPTION_STACK_ID_ varchar(64),
-    EXCEPTION_MSG_ varchar(4000),
-    HANDLER_TYPE_ varchar(255),
-    HANDLER_CFG_ varchar(4000),
-    ADV_HANDLER_CFG_ID_ varchar(64),
-    CREATE_TIME_ timestamp,
-    TENANT_ID_ varchar(255) default '',
-    primary key (ID_)
-);
-
 create table ACT_RE_PROCDEF (
     ID_ varchar(64) NOT NULL,
     REV_ integer,
@@ -181,18 +82,6 @@ create table ACT_RE_PROCDEF (
     primary key (ID_)
 );
 
-create table ACT_RU_IDENTITYLINK (
-    ID_ varchar(64),
-    REV_ integer,
-    GROUP_ID_ varchar(255),
-    TYPE_ varchar(255),
-    USER_ID_ varchar(255),
-    TASK_ID_ varchar(64),
-    PROC_INST_ID_ varchar(64) null,
-    PROC_DEF_ID_ varchar(64),
-    primary key (ID_)
-);
-
 create table ACT_RU_EVENT_SUBSCR (
     ID_ varchar(64) not null,
     REV_ integer,
@@ -233,8 +122,6 @@ create table ACT_PROCDEF_INFO (
 
 create index ACT_IDX_EXEC_BUSKEY on ACT_RU_EXECUTION(BUSINESS_KEY_);
 create index ACT_IDC_EXEC_ROOT on ACT_RU_EXECUTION(ROOT_PROC_INST_ID_);
-create index ACT_IDX_IDENT_LNK_USER on ACT_RU_IDENTITYLINK(USER_ID_);
-create index ACT_IDX_IDENT_LNK_GROUP on ACT_RU_IDENTITYLINK(GROUP_ID_);
 create index ACT_IDX_EVENT_SUBSCR_CONFIG_ on ACT_RU_EVENT_SUBSCR(CONFIGURATION_);
 create index ACT_IDX_VARIABLE_TASK_ID on ACT_RU_VARIABLE(TASK_ID_);
 create index ACT_IDX_ATHRZ_PROCEDEF on ACT_RU_IDENTITYLINK(PROC_DEF_ID_);
@@ -324,11 +211,6 @@ alter table ACT_RU_JOB
     foreign key (PROC_DEF_ID_)
     references ACT_RE_PROCDEF;
     
-alter table ACT_RU_JOB
-    add constraint ACT_FK_JOB_EXCEPTION
-    foreign key (EXCEPTION_STACK_ID_)
-    references ACT_GE_BYTEARRAY;
-    
 alter table ACT_RU_TIMER_JOB
     add constraint ACT_FK_TIMER_JOB_EXECUTION
     foreign key (EXECUTION_ID_)
@@ -344,11 +226,6 @@ alter table ACT_RU_TIMER_JOB
     foreign key (PROC_DEF_ID_)
     references ACT_RE_PROCDEF;    
     
-alter table ACT_RU_TIMER_JOB
-    add constraint ACT_FK_TIMER_JOB_EXCEPTION
-    foreign key (EXCEPTION_STACK_ID_)
-    references ACT_GE_BYTEARRAY;
-
 alter table ACT_RU_SUSPENDED_JOB
     add constraint ACT_FK_SUSPENDED_JOB_EXECUTION
     foreign key (EXECUTION_ID_)
@@ -364,11 +241,6 @@ alter table ACT_RU_SUSPENDED_JOB
     foreign key (PROC_DEF_ID_)
     references ACT_RE_PROCDEF;
     
-alter table ACT_RU_SUSPENDED_JOB
-    add constraint ACT_FK_SUSPENDED_JOB_EXCEPTION
-    foreign key (EXCEPTION_STACK_ID_)
-    references ACT_GE_BYTEARRAY;
-
 alter table ACT_RU_DEADLETTER_JOB
     add constraint ACT_FK_DEADLETTER_JOB_EXECUTION
     foreign key (EXECUTION_ID_)
@@ -384,11 +256,6 @@ alter table ACT_RU_DEADLETTER_JOB
     foreign key (PROC_DEF_ID_)
     references ACT_RE_PROCDEF;
 
-alter table ACT_RU_DEADLETTER_JOB
-    add constraint ACT_FK_DEADLETTER_JOB_EXCEPTION
-    foreign key (EXCEPTION_STACK_ID_)
-    references ACT_GE_BYTEARRAY;
-
 alter table ACT_RU_EVENT_SUBSCR
     add constraint ACT_FK_EVENT_EXEC
     foreign key (EXECUTION_ID_)

modules/flowable-engine/src/main/resources/org/flowable/db/create/flowable.h2.create.history.sql

@@ -86,16 +86,6 @@ create table ACT_HI_ATTACHMENT (
     TIME_ timestamp,
     primary key (ID_)
 );
-create table ACT_HI_IDENTITYLINK (
-    ID_ varchar(64),
-    GROUP_ID_ varchar(255),
-    TYPE_ varchar(255),
-    USER_ID_ varchar(255),
-    TASK_ID_ varchar(64),
-    CREATE_TIME_ timestamp,
-    PROC_INST_ID_ varchar(64) null,
-    primary key (ID_)
-);
 
 create index ACT_IDX_HI_PRO_INST_END on ACT_HI_PROCINST(END_TIME_);
 create index ACT_IDX_HI_PRO_I_BUSKEY on ACT_HI_PROCINST(BUSINESS_KEY_);
@@ -110,7 +100,6 @@ create index ACT_IDX_HI_PROCVAR_PROC_INST on ACT_HI_VARINST(PROC_INST_ID_);
 create index ACT_IDX_HI_PROCVAR_TASK_ID on ACT_HI_VARINST(TASK_ID_);
 create index ACT_IDX_HI_PROCVAR_EXE on ACT_HI_VARINST(EXECUTION_ID_);
 create index ACT_IDX_HI_ACT_INST_PROCINST on ACT_HI_ACTINST(PROC_INST_ID_, ACT_ID_);
-create index ACT_IDX_HI_IDENT_LNK_USER on ACT_HI_IDENTITYLINK(USER_ID_);
 create index ACT_IDX_HI_IDENT_LNK_TASK on ACT_HI_IDENTITYLINK(TASK_ID_);
 create index ACT_IDX_HI_IDENT_LNK_PROCINST on ACT_HI_IDENTITYLINK(PROC_INST_ID_);
 

modules/flowable-engine/src/main/resources/org/flowable/db/create/flowable.hsql.create.engine.sql

@@ -63,105 +63,6 @@ create table ACT_RU_EXECUTION (
     primary key (ID_)
 );
 
-create table ACT_RU_JOB (
-    ID_ varchar(64) NOT NULL,
-    REV_ integer,
-    TYPE_ varchar(255) NOT NULL,
-    LOCK_EXP_TIME_ timestamp,
-    LOCK_OWNER_ varchar(255),
-    EXCLUSIVE_ boolean,
-    EXECUTION_ID_ varchar(64),
-    PROCESS_INSTANCE_ID_ varchar(64),
-    PROC_DEF_ID_ varchar(64),
-    RETRIES_ integer,
-    EXCEPTION_STACK_ID_ varchar(64),
-    EXCEPTION_MSG_ varchar(4000),
-    DUEDATE_ timestamp,
-    REPEAT_ varchar(255),
-    HANDLER_TYPE_ varchar(255),
-    HANDLER_CFG_ varchar(4000),
-    CREATE_TIME_ timestamp,
-    TENANT_ID_ varchar(255) default '',
-    primary key (ID_)
-);
-
-create table ACT_RU_TIMER_JOB (
-    ID_ varchar(64) NOT NULL,
-    REV_ integer,
-    TYPE_ varchar(255) NOT NULL,
-    LOCK_EXP_TIME_ timestamp,
-    LOCK_OWNER_ varchar(255),
-    EXCLUSIVE_ boolean,
-    EXECUTION_ID_ varchar(64),
-    PROCESS_INSTANCE_ID_ varchar(64),
-    PROC_DEF_ID_ varchar(64),
-    RETRIES_ integer,
-    EXCEPTION_STACK_ID_ varchar(64),
-    EXCEPTION_MSG_ varchar(4000),
-    DUEDATE_ timestamp,
-    REPEAT_ varchar(255),
-    HANDLER_TYPE_ varchar(255),
-    HANDLER_CFG_ varchar(4000),
-    CREATE_TIME_ timestamp,
-    TENANT_ID_ varchar(255) default '',
-    primary key (ID_)
-);
-
-create table ACT_RU_SUSPENDED_JOB (
-    ID_ varchar(64) NOT NULL,
-    REV_ integer,
-    TYPE_ varchar(255) NOT NULL,
-    EXCLUSIVE_ boolean,
-    EXECUTION_ID_ varchar(64),
-    PROCESS_INSTANCE_ID_ varchar(64),
-    PROC_DEF_ID_ varchar(64),
-    RETRIES_ integer,
-    EXCEPTION_STACK_ID_ varchar(64),
-    EXCEPTION_MSG_ varchar(4000),
-    DUEDATE_ timestamp,
-    REPEAT_ varchar(255),
-    HANDLER_TYPE_ varchar(255),
-    HANDLER_CFG_ varchar(4000),
-    CREATE_TIME_ timestamp,
-    TENANT_ID_ varchar(255) default '',
-    primary key (ID_)
-);
-
-create table ACT_RU_DEADLETTER_JOB (
-    ID_ varchar(64) NOT NULL,
-    REV_ integer,
-    TYPE_ varchar(255) NOT NULL,
-    EXCLUSIVE_ boolean,
-    EXECUTION_ID_ varchar(64),
-    PROCESS_INSTANCE_ID_ varchar(64),
-    PROC_DEF_ID_ varchar(64),
-    EXCEPTION_STACK_ID_ varchar(64),
-    EXCEPTION_MSG_ varchar(4000),
-    DUEDATE_ timestamp,
-    REPEAT_ varchar(255),
-    HANDLER_TYPE_ varchar(255),
-    HANDLER_CFG_ varchar(4000),
-    CREATE_TIME_ timestamp,
-    TENANT_ID_ varchar(255) default '',
-    primary key (ID_)
-);
-
-create table ACT_RU_HISTORY_JOB (
-    ID_ varchar(64) NOT NULL,
-    REV_ integer,
-    LOCK_EXP_TIME_ timestamp,
-    LOCK_OWNER_ varchar(255),
-    RETRIES_ integer,
-    EXCEPTION_STACK_ID_ varchar(64),
-    EXCEPTION_MSG_ varchar(4000),
-    HANDLER_TYPE_ varchar(255),
-    HANDLER_CFG_ varchar(4000),
-    ADV_HANDLER_CFG_ID_ varchar(64),
-    CREATE_TIME_ timestamp,
-    TENANT_ID_ varchar(255) default '',
-    primary key (ID_)
-);
-
 create table ACT_RE_PROCDEF (
     ID_ varchar(64) NOT NULL,
     REV_ integer,
@@ -181,18 +82,6 @@ create table ACT_RE_PROCDEF (
     primary key (ID_)
 );
 
-create table ACT_RU_IDENTITYLINK (
-    ID_ varchar(64),
-    REV_ integer,
-    GROUP_ID_ varchar(255),
-    TYPE_ varchar(255),
-    USER_ID_ varchar(255),
-    TASK_ID_ varchar(64),
-    PROC_INST_ID_ varchar(64) null,
-    PROC_DEF_ID_ varchar(64),
-    primary key (ID_)
-);
-
 create table ACT_RU_EVENT_SUBSCR (
     ID_ varchar(64) not null,
     REV_ integer,
@@ -233,8 +122,6 @@ create table ACT_PROCDEF_INFO (
 
 create index ACT_IDX_EXEC_BUSKEY on ACT_RU_EXECUTION(BUSINESS_KEY_);
 create index ACT_IDX_EXE_ROOT on ACT_RU_EXECUTION(ROOT_PROC_INST_ID_);
-create index ACT_IDX_IDENT_LNK_USER on ACT_RU_IDENTITYLINK(USER_ID_);
-create index ACT_IDX_IDENT_LNK_GROUP on ACT_RU_IDENTITYLINK(GROUP_ID_);
 create index ACT_IDX_EVENT_SUBSCR_CONFIG_ on ACT_RU_EVENT_SUBSCR(CONFIGURATION_);
 create index ACT_IDX_VARIABLE_TASK_ID on ACT_RU_VARIABLE(TASK_ID_);
 create index ACT_IDX_ATHRZ_PROCEDEF on ACT_RU_IDENTITYLINK(PROC_DEF_ID_);
@@ -324,11 +211,6 @@ alter table ACT_RU_JOB
     foreign key (PROC_DEF_ID_)
     references ACT_RE_PROCDEF;
     
-alter table ACT_RU_JOB
-    add constraint ACT_FK_JOB_EXCEPTION
-    foreign key (EXCEPTION_STACK_ID_)
-    references ACT_GE_BYTEARRAY;
-    
 alter table ACT_RU_TIMER_JOB
     add constraint ACT_FK_TIMER_JOB_EXECUTION
     foreign key (EXECUTION_ID_)
@@ -344,11 +226,6 @@ alter table ACT_RU_TIMER_JOB
     foreign key (PROC_DEF_ID_)
     references ACT_RE_PROCDEF;    
     
-alter table ACT_RU_TIMER_JOB
-    add constraint ACT_FK_TIMER_JOB_EXCEPTION
-    foreign key (EXCEPTION_STACK_ID_)
-    references ACT_GE_BYTEARRAY;
-
 alter table ACT_RU_SUSPENDED_JOB
     add constraint ACT_FK_SUSPENDED_JOB_EXECUTION
     foreign key (EXECUTION_ID_)
@@ -364,11 +241,6 @@ alter table ACT_RU_SUSPENDED_JOB
     foreign key (PROC_DEF_ID_)
     references ACT_RE_PROCDEF;
     
-alter table ACT_RU_SUSPENDED_JOB
-    add constraint ACT_FK_SUSPENDED_JOB_EXCEPTION
-    foreign key (EXCEPTION_STACK_ID_)
-    references ACT_GE_BYTEARRAY;
-
 alter table ACT_RU_DEADLETTER_JOB
     add constraint ACT_FK_DEADLETTER_JOB_EXECUTION
     foreign key (EXECUTION_ID_)
@@ -384,11 +256,6 @@ alter table ACT_RU_DEADLETTER_JOB
     foreign key (PROC_DEF_ID_)
     references ACT_RE_PROCDEF;
 
-alter table ACT_RU_DEADLETTER_JOB
-    add constraint ACT_FK_DEADLETTER_JOB_EXCEPTION
-    foreign key (EXCEPTION_STACK_ID_)
-    references ACT_GE_BYTEARRAY;
-
 alter table ACT_RU_EVENT_SUBSCR
     add constraint ACT_FK_EVENT_EXEC
     foreign key (EXECUTION_ID_)

modules/flowable-engine/src/main/resources/org/flowable/db/create/flowable.hsql.create.history.sql

@@ -86,16 +86,6 @@ create table ACT_HI_ATTACHMENT (
   TIME_ timestamp,
   primary key (ID_)
 );
-create table ACT_HI_IDENTITYLINK (
-  ID_ varchar(64),
-  GROUP_ID_ varchar(255),
-  TYPE_ varchar(255),
-  USER_ID_ varchar(255),
-  TASK_ID_ varchar(64),
-  CREATE_TIME_ timestamp,
-  PROC_INST_ID_ varchar(64) null,
-  primary key (ID_)
-);
 
 create index ACT_IDX_HI_PRO_INST_END on ACT_HI_PROCINST(END_TIME_);
 create index ACT_IDX_HI_PRO_I_BUSKEY on ACT_HI_PROCINST(BUSINESS_KEY_);
@@ -110,7 +100,6 @@ create index ACT_IDX_HI_PROCVAR_PROC_INST on ACT_HI_VARINST(PROC_INST_ID_);
 create index ACT_IDX_HI_PROCVAR_TASK_ID on ACT_HI_VARINST(TASK_ID_);
 create index ACT_IDX_HI_PROCVAR_EXE on ACT_HI_VARINST(EXECUTION_ID_);
 create index ACT_IDX_HI_ACT_INST_PROCINST on ACT_HI_ACTINST(PROC_INST_ID_, ACT_ID_);
-create index ACT_IDX_HI_IDENT_LNK_USER on ACT_HI_IDENTITYLINK(USER_ID_);
 create index ACT_IDX_HI_IDENT_LNK_TASK on ACT_HI_IDENTITYLINK(TASK_ID_);
 create index ACT_IDX_HI_IDENT_LNK_PROCINST on ACT_HI_IDENTITYLINK(PROC_INST_ID_);
 

modules/flowable-engine/src/main/resources/org/flowable/db/create/flowable.mssql.create.engine.sql

@@ -63,105 +63,6 @@ create table ACT_RU_EXECUTION (
     primary key (ID_)
 );
 
-create table ACT_RU_JOB (
-    ID_ nvarchar(64) NOT NULL,
-  	REV_ int,
-    TYPE_ nvarchar(255) NOT NULL,
-    LOCK_EXP_TIME_ datetime,
-    LOCK_OWNER_ nvarchar(255),
-    EXCLUSIVE_ bit,
-    EXECUTION_ID_ nvarchar(64),
-    PROCESS_INSTANCE_ID_ nvarchar(64),
-    PROC_DEF_ID_ nvarchar(64),
-    RETRIES_ int,
-    EXCEPTION_STACK_ID_ nvarchar(64),
-    EXCEPTION_MSG_ nvarchar(4000),
-    DUEDATE_ datetime NULL,
-    REPEAT_ nvarchar(255),
-    HANDLER_TYPE_ nvarchar(255),
-    HANDLER_CFG_ nvarchar(4000),
-    CREATE_TIME_ datetime2 NULL,
-    TENANT_ID_ nvarchar(255) default '',
-    primary key (ID_)
-);
-
-create table ACT_RU_TIMER_JOB (
-    ID_ nvarchar(64) NOT NULL,
-  	REV_ int,
-    TYPE_ nvarchar(255) NOT NULL,
-    LOCK_EXP_TIME_ datetime,
-    LOCK_OWNER_ nvarchar(255),
-    EXCLUSIVE_ bit,
-    EXECUTION_ID_ nvarchar(64),
-    PROCESS_INSTANCE_ID_ nvarchar(64),
-    PROC_DEF_ID_ nvarchar(64),
-    RETRIES_ int,
-    EXCEPTION_STACK_ID_ nvarchar(64),
-    EXCEPTION_MSG_ nvarchar(4000),
-    DUEDATE_ datetime NULL,
-    REPEAT_ nvarchar(255),
-    HANDLER_TYPE_ nvarchar(255),
-    HANDLER_CFG_ nvarchar(4000),
-    CREATE_TIME_ datetime2 NULL,
-    TENANT_ID_ nvarchar(255) default '',
-    primary key (ID_)
-);
-
-create table ACT_RU_SUSPENDED_JOB (
-    ID_ nvarchar(64) NOT NULL,
-  	REV_ int,
-    TYPE_ nvarchar(255) NOT NULL,
-    EXCLUSIVE_ bit,
-    EXECUTION_ID_ nvarchar(64),
-    PROCESS_INSTANCE_ID_ nvarchar(64),
-    PROC_DEF_ID_ nvarchar(64),
-    RETRIES_ int,
-    EXCEPTION_STACK_ID_ nvarchar(64),
-    EXCEPTION_MSG_ nvarchar(4000),
-    DUEDATE_ datetime NULL,
-    REPEAT_ nvarchar(255),
-    HANDLER_TYPE_ nvarchar(255),
-    HANDLER_CFG_ nvarchar(4000),
-    CREATE_TIME_ datetime2 NULL,
-    TENANT_ID_ nvarchar(255) default '',
-    primary key (ID_)
-);
-
-create table ACT_RU_DEADLETTER_JOB (
-    ID_ nvarchar(64) NOT NULL,
-  	REV_ int,
-    TYPE_ nvarchar(255) NOT NULL,
-    EXCLUSIVE_ bit,
-    EXECUTION_ID_ nvarchar(64),
-    PROCESS_INSTANCE_ID_ nvarchar(64),
-    PROC_DEF_ID_ nvarchar(64),
-    EXCEPTION_STACK_ID_ nvarchar(64),
-    EXCEPTION_MSG_ nvarchar(4000),
-    DUEDATE_ datetime NULL,
-    REPEAT_ nvarchar(255),
-    HANDLER_TYPE_ nvarchar(255),
-    HANDLER_CFG_ nvarchar(4000),
-    CREATE_TIME_ datetime2 NULL,
-    TENANT_ID_ nvarchar(255) default '',
-    primary key (ID_)
-);
-
-create table ACT_RU_HISTORY_JOB (
-    ID_ nvarchar(64) NOT NULL,
-    REV_ int,
-    LOCK_EXP_TIME_ datetime NULL,
-    LOCK_OWNER_ nvarchar(255),
-    RETRIES_ int,
-    EXCEPTION_STACK_ID_ nvarchar(64),
-    EXCEPTION_MSG_ nvarchar(4000),
-    HANDLER_TYPE_ nvarchar(255),
-    HANDLER_CFG_ nvarchar(4000),
-    ADV_HANDLER_CFG_ID_ nvarchar(64),
-    CREATE_TIME_ datetime2 NULL,
-    TENANT_ID_ nvarchar(255) default '',
-    primary key (ID_)
-);
-
 create table ACT_RE_PROCDEF (
     ID_ nvarchar(64) not null,
     REV_ int,
@@ -181,18 +82,6 @@ create table ACT_RE_PROCDEF (
     primary key (ID_)
 );
 
-create table ACT_RU_IDENTITYLINK (
-    ID_ nvarchar(64),
-    REV_ int,
-    GROUP_ID_ nvarchar(255),
-    TYPE_ nvarchar(255),
-    USER_ID_ nvarchar(255),
-    TASK_ID_ nvarchar(64),
-    PROC_INST_ID_ nvarchar(64),
-    PROC_DEF_ID_ nvarchar(64),
-    primary key (ID_)
-);
-
 create table ACT_RU_EVENT_SUBSCR (
     ID_ nvarchar(64) not null,
     REV_ int,
@@ -234,8 +123,6 @@ create table ACT_PROCDEF_INFO (
 
 create index ACT_IDX_EXEC_BUSKEY on ACT_RU_EXECUTION(BUSINESS_KEY_);
 create index ACT_IDX_EXEC_ROOT on ACT_RU_EXECUTION(ROOT_PROC_INST_ID_);
-create index ACT_IDX_IDENT_LNK_USER on ACT_RU_IDENTITYLINK(USER_ID_);
-create index ACT_IDX_IDENT_LNK_GROUP on ACT_RU_IDENTITYLINK(GROUP_ID_);
 create index ACT_IDX_EVENT_SUBSCR_CONFIG_ on ACT_RU_EVENT_SUBSCR(CONFIGURATION_);
 create index ACT_IDX_VARIABLE_TASK_ID on ACT_RU_VARIABLE(TASK_ID_);
 create index ACT_IDX_ATHRZ_PROCEDEF on ACT_RU_IDENTITYLINK(PROC_DEF_ID_);
@@ -255,19 +142,15 @@ create index ACT_IDX_EVENT_SUBSCR_EXEC_ID on ACT_RU_EVENT_SUBSCR(EXECUTION_ID_);
 create index ACT_IDX_JOB_EXECUTION_ID on ACT_RU_JOB(EXECUTION_ID_);
 create index ACT_IDX_JOB_PROCESS_INSTANCE_ID on ACT_RU_JOB(PROCESS_INSTANCE_ID_);
 create index ACT_IDX_JOB_PROC_DEF_ID on ACT_RU_JOB(PROC_DEF_ID_);
-create index ACT_IDX_JOB_EXCEPTION_STACK_ID on ACT_RU_JOB(EXCEPTION_STACK_ID_);
 create index ACT_IDX_TIMER_JOB_EXECUTION_ID on ACT_RU_TIMER_JOB(EXECUTION_ID_);
 create index ACT_IDX_TIMER_JOB_PROCESS_INSTANCE_ID on ACT_RU_TIMER_JOB(PROCESS_INSTANCE_ID_);
 create index ACT_IDX_TIMER_JOB_PROC_DEF_ID on ACT_RU_TIMER_JOB(PROC_DEF_ID_);
-create index ACT_IDX_TIMER_JOB_EXCEPTION_STACK_ID on ACT_RU_TIMER_JOB(EXCEPTION_STACK_ID_);
 create index ACT_IDX_SUSPENDED_JOB_EXECUTION_ID on ACT_RU_SUSPENDED_JOB(EXECUTION_ID_);
 create index ACT_IDX_SUSPENDED_JOB_PROCESS_INSTANCE_ID on ACT_RU_SUSPENDED_JOB(PROCESS_INSTANCE_ID_);
 create index ACT_IDX_SUSPENDED_JOB_PROC_DEF_ID on ACT_RU_SUSPENDED_JOB(PROC_DEF_ID_);
-create index ACT_IDX_SUSPENDED_JOB_EXCEPTION_STACK_ID on ACT_RU_SUSPENDED_JOB(EXCEPTION_STACK_ID_);
 create index ACT_IDX_DEADLETTER_JOB_EXECUTION_ID on ACT_RU_DEADLETTER_JOB(EXECUTION_ID_);
 create index ACT_IDX_DEADLETTER_JOB_PROCESS_INSTANCE_ID on ACT_RU_DEADLETTER_JOB(PROCESS_INSTANCE_ID_);
 create index ACT_IDX_DEADLETTER_JOB_PROC_DEF_ID on ACT_RU_DEADLETTER_JOB(PROC_DEF_ID_);
-create index ACT_IDX_DEADLETTER_JOB_EXCEPTION_STACK_ID on ACT_RU_DEADLETTER_JOB(EXCEPTION_STACK_ID_);
 create index ACT_IDX_INFO_PROCDEF on ACT_PROCDEF_INFO(PROC_DEF_ID_);
 
 alter table ACT_GE_BYTEARRAY
@@ -349,11 +232,6 @@ alter table ACT_RU_JOB
     foreign key (PROC_DEF_ID_) 
     references ACT_RE_PROCDEF (ID_);
 
-alter table ACT_RU_JOB 
-    add constraint ACT_FK_JOB_EXCEPTION 
-    foreign key (EXCEPTION_STACK_ID_) 
-    references ACT_GE_BYTEARRAY (ID_);
-    
 alter table ACT_RU_TIMER_JOB 
     add constraint ACT_FK_TIMER_JOB_EXECUTION 
     foreign key (EXECUTION_ID_) 
@@ -369,11 +247,6 @@ alter table ACT_RU_TIMER_JOB
     foreign key (PROC_DEF_ID_) 
     references ACT_RE_PROCDEF (ID_);
     
-alter table ACT_RU_TIMER_JOB 
-    add constraint ACT_FK_TIMER_JOB_EXCEPTION 
-    foreign key (EXCEPTION_STACK_ID_) 
-    references ACT_GE_BYTEARRAY (ID_);
-    
 alter table ACT_RU_SUSPENDED_JOB 
     add constraint ACT_FK_SUSPENDED_JOB_EXECUTION 
     foreign key (EXECUTION_ID_) 
@@ -389,11 +262,6 @@ alter table ACT_RU_SUSPENDED_JOB
     foreign key (PROC_DEF_ID_) 
     references ACT_RE_PROCDEF (ID_);
     
-alter table ACT_RU_SUSPENDED_JOB 
-    add constraint ACT_FK_SUSPENDED_JOB_EXCEPTION 
-    foreign key (EXCEPTION_STACK_ID_) 
-    references ACT_GE_BYTEARRAY (ID_);
-    
 alter table ACT_RU_DEADLETTER_JOB 
     add constraint ACT_FK_DEADLETTER_JOB_EXECUTION 
     foreign key (EXECUTION_ID_) 
@@ -409,11 +277,6 @@ alter table ACT_RU_DEADLETTER_JOB
     foreign key (PROC_DEF_ID_) 
     references ACT_RE_PROCDEF (ID_);
     
-alter table ACT_RU_DEADLETTER_JOB 
-    add constraint ACT_FK_DEADLETTER_JOB_EXCEPTION 
-    foreign key (EXCEPTION_STACK_ID_) 
-    references ACT_GE_BYTEARRAY (ID_);
-    
 alter table ACT_RU_EVENT_SUBSCR
     add constraint ACT_FK_EVENT_EXEC
     foreign key (EXECUTION_ID_)

modules/flowable-engine/src/main/resources/org/flowable/db/create/flowable.mssql.create.history.sql

@@ -87,17 +87,6 @@ create table ACT_HI_ATTACHMENT (
     primary key (ID_)
 );
 
-create table ACT_HI_IDENTITYLINK (
-    ID_ nvarchar(64),
-    GROUP_ID_ nvarchar(255),
-    TYPE_ nvarchar(255),
-    USER_ID_ nvarchar(255),
-    TASK_ID_ nvarchar(64),
-    CREATE_TIME_ datetime,
-    PROC_INST_ID_ nvarchar(64),
-    primary key (ID_)
-);
-
 
 create index ACT_IDX_HI_PRO_INST_END on ACT_HI_PROCINST(END_TIME_);
 create index ACT_IDX_HI_PRO_I_BUSKEY on ACT_HI_PROCINST(BUSINESS_KEY_);
@@ -113,7 +102,6 @@ create index ACT_IDX_HI_PROCVAR_TASK_ID on ACT_HI_VARINST(TASK_ID_);
 create index ACT_IDX_HI_PROCVAR_EXE on ACT_HI_VARINST(EXECUTION_ID_);
 create index ACT_IDX_HI_ACT_INST_PROCINST on ACT_HI_ACTINST(PROC_INST_ID_, ACT_ID_);
 create index ACT_IDX_HI_ACT_INST_EXEC on ACT_HI_ACTINST(EXECUTION_ID_, ACT_ID_);
-create index ACT_IDX_HI_IDENT_LNK_USER on ACT_HI_IDENTITYLINK(USER_ID_);
 create index ACT_IDX_HI_IDENT_LNK_TASK on ACT_HI_IDENTITYLINK(TASK_ID_);
 create index ACT_IDX_HI_IDENT_LNK_PROCINST on ACT_HI_IDENTITYLINK(PROC_INST_ID_);
 create index ACT_IDX_HI_TASK_INST_PROCINST on ACT_HI_TASKINST(PROC_INST_ID_);

modules/flowable-engine/src/main/resources/org/flowable/db/create/flowable.mysql.create.engine.sql

@@ -63,105 +63,6 @@ create table ACT_RU_EXECUTION (
     primary key (ID_)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
 
-create table ACT_RU_JOB (
-    ID_ varchar(64) NOT NULL,
-    REV_ integer,
-    TYPE_ varchar(255) NOT NULL,
-    LOCK_EXP_TIME_ timestamp(3) NULL,
-    LOCK_OWNER_ varchar(255),
-    EXCLUSIVE_ boolean,
-    EXECUTION_ID_ varchar(64),
-    PROCESS_INSTANCE_ID_ varchar(64),
-    PROC_DEF_ID_ varchar(64),
-    RETRIES_ integer,
-    EXCEPTION_STACK_ID_ varchar(64),
-    EXCEPTION_MSG_ varchar(4000),
-    DUEDATE_ timestamp(3) NULL,
-    REPEAT_ varchar(255),
-    HANDLER_TYPE_ varchar(255),
-    HANDLER_CFG_ varchar(4000),
-    CREATE_TIME_ timestamp(3) NULL,
-    TENANT_ID_ varchar(255) default '',
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-create table ACT_RU_TIMER_JOB (
-    ID_ varchar(64) NOT NULL,
-    REV_ integer,
-    TYPE_ varchar(255) NOT NULL,
-    LOCK_EXP_TIME_ timestamp(3) NULL,
-    LOCK_OWNER_ varchar(255),
-    EXCLUSIVE_ boolean,
-    EXECUTION_ID_ varchar(64),
-    PROCESS_INSTANCE_ID_ varchar(64),
-    PROC_DEF_ID_ varchar(64),
-    RETRIES_ integer,
-    EXCEPTION_STACK_ID_ varchar(64),
-    EXCEPTION_MSG_ varchar(4000),
-    DUEDATE_ timestamp(3) NULL,
-    REPEAT_ varchar(255),
-    HANDLER_TYPE_ varchar(255),
-    HANDLER_CFG_ varchar(4000),
-    CREATE_TIME_ timestamp(3) NULL,
-    TENANT_ID_ varchar(255) default '',
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-create table ACT_RU_SUSPENDED_JOB (
-    ID_ varchar(64) NOT NULL,
-    REV_ integer,
-    TYPE_ varchar(255) NOT NULL,
-    EXCLUSIVE_ boolean,
-    EXECUTION_ID_ varchar(64),
-    PROCESS_INSTANCE_ID_ varchar(64),
-    PROC_DEF_ID_ varchar(64),
-    RETRIES_ integer,
-    EXCEPTION_STACK_ID_ varchar(64),
-    EXCEPTION_MSG_ varchar(4000),
-    DUEDATE_ timestamp(3) NULL,
-    REPEAT_ varchar(255),
-    HANDLER_TYPE_ varchar(255),
-    HANDLER_CFG_ varchar(4000),
-    CREATE_TIME_ timestamp(3) NULL,
-    TENANT_ID_ varchar(255) default '',
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-create table ACT_RU_DEADLETTER_JOB (
-    ID_ varchar(64) NOT NULL,
-    REV_ integer,
-    TYPE_ varchar(255) NOT NULL,
-    EXCLUSIVE_ boolean,
-    EXECUTION_ID_ varchar(64),
-    PROCESS_INSTANCE_ID_ varchar(64),
-    PROC_DEF_ID_ varchar(64),
-    EXCEPTION_STACK_ID_ varchar(64),
-    EXCEPTION_MSG_ varchar(4000),
-    DUEDATE_ timestamp(3) NULL,
-    REPEAT_ varchar(255),
-    HANDLER_TYPE_ varchar(255),
-    HANDLER_CFG_ varchar(4000),
-    CREATE_TIME_ timestamp(3) NULL,
-    TENANT_ID_ varchar(255) default '',
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-create table ACT_RU_HISTORY_JOB (
-    ID_ varchar(64) NOT NULL,
-    REV_ integer,
-    LOCK_EXP_TIME_ timestamp(3) NULL,
-    LOCK_OWNER_ varchar(255),
-    RETRIES_ integer,
-    EXCEPTION_STACK_ID_ varchar(64),
-    EXCEPTION_MSG_ varchar(4000),
-    HANDLER_TYPE_ varchar(255),
-    HANDLER_CFG_ varchar(4000),
-    ADV_HANDLER_CFG_ID_ varchar(64),
-    CREATE_TIME_ timestamp(3) NULL,
-    TENANT_ID_ varchar(255) default '',
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
 create table ACT_RE_PROCDEF (
     ID_ varchar(64) not null,
     REV_ integer,
@@ -181,18 +82,6 @@ create table ACT_RE_PROCDEF (
     primary key (ID_)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
 
-create table ACT_RU_IDENTITYLINK (
-    ID_ varchar(64),
-    REV_ integer,
-    GROUP_ID_ varchar(255),
-    TYPE_ varchar(255),
-    USER_ID_ varchar(255),
-    TASK_ID_ varchar(64),
-    PROC_INST_ID_ varchar(64),
-    PROC_DEF_ID_ varchar(64),    
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
 create table ACT_RU_EVENT_SUBSCR (
     ID_ varchar(64) not null,
     REV_ integer,
@@ -234,8 +123,6 @@ create table ACT_PROCDEF_INFO (
 
 create index ACT_IDX_EXEC_BUSKEY on ACT_RU_EXECUTION(BUSINESS_KEY_);
 create index ACT_IDC_EXEC_ROOT on ACT_RU_EXECUTION(ROOT_PROC_INST_ID_);
-create index ACT_IDX_IDENT_LNK_USER on ACT_RU_IDENTITYLINK(USER_ID_);
-create index ACT_IDX_IDENT_LNK_GROUP on ACT_RU_IDENTITYLINK(GROUP_ID_);
 create index ACT_IDX_EVENT_SUBSCR_CONFIG_ on ACT_RU_EVENT_SUBSCR(CONFIGURATION_);
 create index ACT_IDX_VARIABLE_TASK_ID on ACT_RU_VARIABLE(TASK_ID_);
 create index ACT_IDX_ATHRZ_PROCEDEF on ACT_RU_IDENTITYLINK(PROC_DEF_ID_);
@@ -325,11 +212,6 @@ alter table ACT_RU_JOB
     foreign key (PROC_DEF_ID_) 
     references ACT_RE_PROCDEF (ID_);
 
-alter table ACT_RU_JOB 
-    add constraint ACT_FK_JOB_EXCEPTION 
-    foreign key (EXCEPTION_STACK_ID_) 
-    references ACT_GE_BYTEARRAY (ID_);
-    
 alter table ACT_RU_TIMER_JOB 
     add constraint ACT_FK_TIMER_JOB_EXECUTION 
     foreign key (EXECUTION_ID_) 
@@ -345,11 +227,6 @@ alter table ACT_RU_TIMER_JOB
     foreign key (PROC_DEF_ID_) 
     references ACT_RE_PROCDEF (ID_);
     
-alter table ACT_RU_TIMER_JOB 
-    add constraint ACT_FK_TIMER_JOB_EXCEPTION 
-    foreign key (EXCEPTION_STACK_ID_) 
-    references ACT_GE_BYTEARRAY (ID_);
-    
 alter table ACT_RU_SUSPENDED_JOB 
     add constraint ACT_FK_SUSPENDED_JOB_EXECUTION 
     foreign key (EXECUTION_ID_) 
@@ -365,11 +242,6 @@ alter table ACT_RU_SUSPENDED_JOB
     foreign key (PROC_DEF_ID_) 
     references ACT_RE_PROCDEF (ID_);
     
-alter table ACT_RU_SUSPENDED_JOB 
-    add constraint ACT_FK_SUSPENDED_JOB_EXCEPTION 
-    foreign key (EXCEPTION_STACK_ID_) 
-    references ACT_GE_BYTEARRAY (ID_);
-    
 alter table ACT_RU_DEADLETTER_JOB 
     add constraint ACT_FK_DEADLETTER_JOB_EXECUTION 
     foreign key (EXECUTION_ID_) 
@@ -385,11 +257,6 @@ alter table ACT_RU_DEADLETTER_JOB
     foreign key (PROC_DEF_ID_) 
     references ACT_RE_PROCDEF (ID_);
     
-alter table ACT_RU_DEADLETTER_JOB 
-    add constraint ACT_FK_DEADLETTER_JOB_EXCEPTION 
-    foreign key (EXCEPTION_STACK_ID_) 
-    references ACT_GE_BYTEARRAY (ID_);
-
 alter table ACT_RU_EVENT_SUBSCR
     add constraint ACT_FK_EVENT_EXEC
     foreign key (EXECUTION_ID_)

modules/flowable-engine/src/main/resources/org/flowable/db/create/flowable.mysql.create.history.sql

@@ -87,17 +87,6 @@ create table ACT_HI_ATTACHMENT (
     primary key (ID_)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
 
-create table ACT_HI_IDENTITYLINK (
-    ID_ varchar(64),
-    GROUP_ID_ varchar(255),
-    TYPE_ varchar(255),
-    USER_ID_ varchar(255),
-    TASK_ID_ varchar(64),
-    CREATE_TIME_ datetime(3),
-    PROC_INST_ID_ varchar(64),
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
 
 create index ACT_IDX_HI_PRO_INST_END on ACT_HI_PROCINST(END_TIME_);
 create index ACT_IDX_HI_PRO_I_BUSKEY on ACT_HI_PROCINST(BUSINESS_KEY_);
@@ -113,7 +102,6 @@ create index ACT_IDX_HI_PROCVAR_TASK_ID on ACT_HI_VARINST(TASK_ID_);
 create index ACT_IDX_HI_PROCVAR_EXE on ACT_HI_VARINST(EXECUTION_ID_);
 create index ACT_IDX_HI_ACT_INST_PROCINST on ACT_HI_ACTINST(PROC_INST_ID_, ACT_ID_);
 create index ACT_IDX_HI_ACT_INST_EXEC on ACT_HI_ACTINST(EXECUTION_ID_, ACT_ID_);
-create index ACT_IDX_HI_IDENT_LNK_USER on ACT_HI_IDENTITYLINK(USER_ID_);
 create index ACT_IDX_HI_IDENT_LNK_TASK on ACT_HI_IDENTITYLINK(TASK_ID_);
 create index ACT_IDX_HI_IDENT_LNK_PROCINST on ACT_HI_IDENTITYLINK(PROC_INST_ID_);
 create index ACT_IDX_HI_TASK_INST_PROCINST on ACT_HI_TASKINST(PROC_INST_ID_);

modules/flowable-engine/src/main/resources/org/flowable/db/create/flowable.mysql55.create.engine.sql

@@ -62,105 +62,6 @@ create table ACT_RU_EXECUTION (
     primary key (ID_)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
 
-create table ACT_RU_JOB (
-    ID_ varchar(64) NOT NULL,
-    REV_ integer,
-    TYPE_ varchar(255) NOT NULL,
-    LOCK_EXP_TIME_ timestamp NULL,
-    LOCK_OWNER_ varchar(255),
-    EXCLUSIVE_ boolean,
-    EXECUTION_ID_ varchar(64),
-    PROCESS_INSTANCE_ID_ varchar(64),
-    PROC_DEF_ID_ varchar(64),
-    RETRIES_ integer,
-    EXCEPTION_STACK_ID_ varchar(64),
-    EXCEPTION_MSG_ varchar(4000),
-    DUEDATE_ timestamp NULL,
-    REPEAT_ varchar(255),
-    HANDLER_TYPE_ varchar(255),
-    HANDLER_CFG_ varchar(4000),
-    CREATE_TIME_ timestamp NULL,
-    TENANT_ID_ varchar(255) default '',
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-create table ACT_RU_TIMER_JOB (
-    ID_ varchar(64) NOT NULL,
-    REV_ integer,
-    TYPE_ varchar(255) NOT NULL,
-    LOCK_EXP_TIME_ timestamp NULL,
-    LOCK_OWNER_ varchar(255),
-    EXCLUSIVE_ boolean,
-    EXECUTION_ID_ varchar(64),
-    PROCESS_INSTANCE_ID_ varchar(64),
-    PROC_DEF_ID_ varchar(64),
-    RETRIES_ integer,
-    EXCEPTION_STACK_ID_ varchar(64),
-    EXCEPTION_MSG_ varchar(4000),
-    DUEDATE_ timestamp NULL,
-    REPEAT_ varchar(255),
-    HANDLER_TYPE_ varchar(255),
-    HANDLER_CFG_ varchar(4000),
-    CREATE_TIME_ timestamp NULL,
-    TENANT_ID_ varchar(255) default '',
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-create table ACT_RU_SUSPENDED_JOB (
-    ID_ varchar(64) NOT NULL,
-    REV_ integer,
-    TYPE_ varchar(255) NOT NULL,
-    EXCLUSIVE_ boolean,
-    EXECUTION_ID_ varchar(64),
-    PROCESS_INSTANCE_ID_ varchar(64),
-    PROC_DEF_ID_ varchar(64),
-    RETRIES_ integer,
-    EXCEPTION_STACK_ID_ varchar(64),
-    EXCEPTION_MSG_ varchar(4000),
-    DUEDATE_ timestamp NULL,
-    REPEAT_ varchar(255),
-    HANDLER_TYPE_ varchar(255),
-    HANDLER_CFG_ varchar(4000),
-    CREATE_TIME_ timestamp NULL,
-    TENANT_ID_ varchar(255) default '',
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-create table ACT_RU_DEADLETTER_JOB (
-    ID_ varchar(64) NOT NULL,
-    REV_ integer,
-    TYPE_ varchar(255) NOT NULL,
-    EXCLUSIVE_ boolean,
-    EXECUTION_ID_ varchar(64),
-    PROCESS_INSTANCE_ID_ varchar(64),
-    PROC_DEF_ID_ varchar(64),
-    EXCEPTION_STACK_ID_ varchar(64),
-    EXCEPTION_MSG_ varchar(4000),
-    DUEDATE_ timestamp NULL,
-    REPEAT_ varchar(255),
-    HANDLER_TYPE_ varchar(255),
-    HANDLER_CFG_ varchar(4000),
-    CREATE_TIME_ timestamp NULL,
-    TENANT_ID_ varchar(255) default '',
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-create table ACT_RU_HISTORY_JOB (
-    ID_ varchar(64) NOT NULL,
-    REV_ integer,
-    LOCK_EXP_TIME_ timestamp NULL,
-    LOCK_OWNER_ varchar(255),
-    RETRIES_ integer,
-    EXCEPTION_STACK_ID_ varchar(64),
-    EXCEPTION_MSG_ varchar(4000),
-    HANDLER_TYPE_ varchar(255),
-    HANDLER_CFG_ varchar(4000),
-    ADV_HANDLER_CFG_ID_ varchar(64),
-    TENANT_ID_ varchar(255) default '',
-    CREATE_TIME_ timestamp NULL,
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
 create table ACT_RE_PROCDEF (
     ID_ varchar(64) not null,
     REV_ integer,
@@ -180,18 +81,6 @@ create table ACT_RE_PROCDEF (
     primary key (ID_)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
 
-create table ACT_RU_IDENTITYLINK (
-    ID_ varchar(64),
-    REV_ integer,
-    GROUP_ID_ varchar(255),
-    TYPE_ varchar(255),
-    USER_ID_ varchar(255),
-    TASK_ID_ varchar(64),
-    PROC_INST_ID_ varchar(64),
-    PROC_DEF_ID_ varchar(64),    
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
 create table ACT_RU_EVENT_SUBSCR (
     ID_ varchar(64) not null,
     REV_ integer,
@@ -233,8 +122,6 @@ create table ACT_PROCDEF_INFO (
 
 create index ACT_IDX_EXEC_BUSKEY on ACT_RU_EXECUTION(BUSINESS_KEY_);
 create index ACT_IDX_EXEC_ROOT on ACT_RU_EXECUTION(ROOT_PROC_INST_ID_);
-create index ACT_IDX_IDENT_LNK_USER on ACT_RU_IDENTITYLINK(USER_ID_);
-create index ACT_IDX_IDENT_LNK_GROUP on ACT_RU_IDENTITYLINK(GROUP_ID_);
 create index ACT_IDX_EVENT_SUBSCR_CONFIG_ on ACT_RU_EVENT_SUBSCR(CONFIGURATION_);
 create index ACT_IDX_VARIABLE_TASK_ID on ACT_RU_VARIABLE(TASK_ID_);
 create index ACT_IDX_ATHRZ_PROCEDEF on ACT_RU_IDENTITYLINK(PROC_DEF_ID_);
@@ -324,11 +211,6 @@ alter table ACT_RU_JOB
     foreign key (PROC_DEF_ID_) 
     references ACT_RE_PROCDEF (ID_);
 
-alter table ACT_RU_JOB 
-    add constraint ACT_FK_JOB_EXCEPTION 
-    foreign key (EXCEPTION_STACK_ID_) 
-    references ACT_GE_BYTEARRAY (ID_);
-    
 alter table ACT_RU_TIMER_JOB 
     add constraint ACT_FK_TIMER_JOB_EXECUTION 
     foreign key (EXECUTION_ID_) 
@@ -344,11 +226,6 @@ alter table ACT_RU_TIMER_JOB
     foreign key (PROC_DEF_ID_) 
     references ACT_RE_PROCDEF (ID_);
     
-alter table ACT_RU_TIMER_JOB 
-    add constraint ACT_FK_TIMER_JOB_EXCEPTION 
-    foreign key (EXCEPTION_STACK_ID_) 
-    references ACT_GE_BYTEARRAY (ID_);
-    
 alter table ACT_RU_SUSPENDED_JOB 
     add constraint ACT_FK_SUSPENDED_JOB_EXECUTION 
     foreign key (EXECUTION_ID_) 
@@ -364,11 +241,6 @@ alter table ACT_RU_SUSPENDED_JOB
     foreign key (PROC_DEF_ID_) 
     references ACT_RE_PROCDEF (ID_);
     
-alter table ACT_RU_SUSPENDED_JOB 
-    add constraint ACT_FK_SUSPENDED_JOB_EXCEPTION 
-    foreign key (EXCEPTION_STACK_ID_) 
-    references ACT_GE_BYTEARRAY (ID_);
-    
 alter table ACT_RU_DEADLETTER_JOB 
     add constraint ACT_FK_DEADLETTER_JOB_EXECUTION 
     foreign key (EXECUTION_ID_) 
@@ -384,11 +256,6 @@ alter table ACT_RU_DEADLETTER_JOB
     foreign key (PROC_DEF_ID_) 
     references ACT_RE_PROCDEF (ID_);
     
-alter table ACT_RU_DEADLETTER_JOB 
-    add constraint ACT_FK_DEADLETTER_JOB_EXCEPTION 
-    foreign key (EXCEPTION_STACK_ID_) 
-    references ACT_GE_BYTEARRAY (ID_);
-
 alter table ACT_RU_EVENT_SUBSCR
     add constraint ACT_FK_EVENT_EXEC
     foreign key (EXECUTION_ID_)

modules/flowable-engine/src/main/resources/org/flowable/db/create/flowable.mysql55.create.history.sql

@@ -87,18 +87,6 @@ create table ACT_HI_ATTACHMENT (
     primary key (ID_)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
 
-create table ACT_HI_IDENTITYLINK (
-    ID_ varchar(64),
-    GROUP_ID_ varchar(255),
-    TYPE_ varchar(255),
-    USER_ID_ varchar(255),
-    TASK_ID_ varchar(64),
-    CREATE_TIME_ datetime,
-    PROC_INST_ID_ varchar(64),
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-
 create index ACT_IDX_HI_PRO_INST_END on ACT_HI_PROCINST(END_TIME_);
 create index ACT_IDX_HI_PRO_I_BUSKEY on ACT_HI_PROCINST(BUSINESS_KEY_);
 create index ACT_IDX_HI_ACT_INST_START on ACT_HI_ACTINST(START_TIME_);
@@ -113,7 +101,6 @@ create index ACT_IDX_HI_PROCVAR_TASK_ID on ACT_HI_VARINST(TASK_ID_);
 create index ACT_IDX_HI_PROCVAR_EXE on ACT_HI_VARINST(EXECUTION_ID_);
 create index ACT_IDX_HI_ACT_INST_PROCINST on ACT_HI_ACTINST(PROC_INST_ID_, ACT_ID_);
 create index ACT_IDX_HI_ACT_INST_EXEC on ACT_HI_ACTINST(EXECUTION_ID_, ACT_ID_);
-create index ACT_IDX_HI_IDENT_LNK_USER on ACT_HI_IDENTITYLINK(USER_ID_);
 create index ACT_IDX_HI_IDENT_LNK_TASK on ACT_HI_IDENTITYLINK(TASK_ID_);
 create index ACT_IDX_HI_IDENT_LNK_PROCINST on ACT_HI_IDENTITYLINK(PROC_INST_ID_);
 create index ACT_IDX_HI_TASK_INST_PROCINST on ACT_HI_TASKINST(PROC_INST_ID_);

modules/flowable-engine/src/main/resources/org/flowable/db/create/flowable.oracle.create.engine.sql

@@ -63,105 +63,6 @@ create table ACT_RU_EXECUTION (
     primary key (ID_)
 );
 
-create table ACT_RU_JOB (
-    ID_ NVARCHAR2(64) NOT NULL,
-    REV_ INTEGER,
-    TYPE_ NVARCHAR2(255) NOT NULL,
-    LOCK_EXP_TIME_ TIMESTAMP(6),
-    LOCK_OWNER_ NVARCHAR2(255),
-    EXCLUSIVE_ NUMBER(1,0) CHECK (EXCLUSIVE_ IN (1,0)),
-    EXECUTION_ID_ NVARCHAR2(64),
-    PROCESS_INSTANCE_ID_ NVARCHAR2(64),
-    PROC_DEF_ID_ NVARCHAR2(64),
-    RETRIES_ INTEGER,
-    EXCEPTION_STACK_ID_ NVARCHAR2(64),
-    EXCEPTION_MSG_ NVARCHAR2(2000),
-    DUEDATE_ TIMESTAMP(6),
-    REPEAT_ NVARCHAR2(255),
-    HANDLER_TYPE_ NVARCHAR2(255),
-    HANDLER_CFG_ NVARCHAR2(2000),
-    CREATE_TIME_ TIMESTAMP(6),
-    TENANT_ID_ NVARCHAR2(255) DEFAULT '',
-    primary key (ID_)
-);
-
-create table ACT_RU_TIMER_JOB (
-    ID_ NVARCHAR2(64) NOT NULL,
-    REV_ INTEGER,
-    TYPE_ NVARCHAR2(255) NOT NULL,
-    LOCK_EXP_TIME_ TIMESTAMP(6),
-    LOCK_OWNER_ NVARCHAR2(255),
-    EXCLUSIVE_ NUMBER(1,0) CHECK (EXCLUSIVE_ IN (1,0)),
-    EXECUTION_ID_ NVARCHAR2(64),
-    PROCESS_INSTANCE_ID_ NVARCHAR2(64),
-    PROC_DEF_ID_ NVARCHAR2(64),
-    RETRIES_ INTEGER,
-    EXCEPTION_STACK_ID_ NVARCHAR2(64),
-    EXCEPTION_MSG_ NVARCHAR2(2000),
-    DUEDATE_ TIMESTAMP(6),
-    REPEAT_ NVARCHAR2(255),
-    HANDLER_TYPE_ NVARCHAR2(255),
-    HANDLER_CFG_ NVARCHAR2(2000),
-    CREATE_TIME_ TIMESTAMP(6),
-    TENANT_ID_ NVARCHAR2(255) DEFAULT '',
-    primary key (ID_)
-);
-
-create table ACT_RU_SUSPENDED_JOB (
-    ID_ NVARCHAR2(64) NOT NULL,
-    REV_ INTEGER,
-    TYPE_ NVARCHAR2(255) NOT NULL,
-    EXCLUSIVE_ NUMBER(1,0) CHECK (EXCLUSIVE_ IN (1,0)),
-    EXECUTION_ID_ NVARCHAR2(64),
-    PROCESS_INSTANCE_ID_ NVARCHAR2(64),
-    PROC_DEF_ID_ NVARCHAR2(64),
-    RETRIES_ INTEGER,
-    EXCEPTION_STACK_ID_ NVARCHAR2(64),
-    EXCEPTION_MSG_ NVARCHAR2(2000),
-    DUEDATE_ TIMESTAMP(6),
-    REPEAT_ NVARCHAR2(255),
-    HANDLER_TYPE_ NVARCHAR2(255),
-    HANDLER_CFG_ NVARCHAR2(2000),
-    CREATE_TIME_ TIMESTAMP(6),
-    TENANT_ID_ NVARCHAR2(255) DEFAULT '',
-    primary key (ID_)
-);
-
-create table ACT_RU_DEADLETTER_JOB (
-    ID_ NVARCHAR2(64) NOT NULL,
-    REV_ INTEGER,
-    TYPE_ NVARCHAR2(255) NOT NULL,
-    EXCLUSIVE_ NUMBER(1,0) CHECK (EXCLUSIVE_ IN (1,0)),
-    EXECUTION_ID_ NVARCHAR2(64),
-    PROCESS_INSTANCE_ID_ NVARCHAR2(64),
-    PROC_DEF_ID_ NVARCHAR2(64),
-    EXCEPTION_STACK_ID_ NVARCHAR2(64),
-    EXCEPTION_MSG_ NVARCHAR2(2000),
-    DUEDATE_ TIMESTAMP(6),
-    REPEAT_ NVARCHAR2(255),
-    HANDLER_TYPE_ NVARCHAR2(255),
-    HANDLER_CFG_ NVARCHAR2(2000),
-    CREATE_TIME_ TIMESTAMP(6),
-    TENANT_ID_ NVARCHAR2(255) DEFAULT '',
-    primary key (ID_)
-);
-
-create table ACT_RU_HISTORY_JOB (
-    ID_ NVARCHAR2(64) NOT NULL,
-    REV_ INTEGER,
-    LOCK_EXP_TIME_ TIMESTAMP(6),
-    LOCK_OWNER_ NVARCHAR2(255),
-    RETRIES_ INTEGER,
-    EXCEPTION_STACK_ID_ NVARCHAR2(64),
-    EXCEPTION_MSG_ NVARCHAR2(2000),
-    HANDLER_TYPE_ NVARCHAR2(255),
-    HANDLER_CFG_ NVARCHAR2(2000),
-    ADV_HANDLER_CFG_ID_ NVARCHAR2(64),
-    CREATE_TIME_ TIMESTAMP(6),
-    TENANT_ID_ NVARCHAR2(255) DEFAULT '',
-    primary key (ID_)
-);
-
 create table ACT_RE_PROCDEF (
     ID_ NVARCHAR2(64) NOT NULL,
     REV_ INTEGER,
@@ -181,18 +82,6 @@ create table ACT_RE_PROCDEF (
     primary key (ID_)
 );
 
-create table ACT_RU_IDENTITYLINK (
-    ID_ NVARCHAR2(64),
-    REV_ INTEGER,
-    GROUP_ID_ NVARCHAR2(255),
-    TYPE_ NVARCHAR2(255),
-    USER_ID_ NVARCHAR2(255),
-    TASK_ID_ NVARCHAR2(64),
-    PROC_INST_ID_ NVARCHAR2(64),
-    PROC_DEF_ID_ NVARCHAR2(64),
-    primary key (ID_)
-);
-
 create table ACT_RU_EVENT_SUBSCR (
     ID_ NVARCHAR2(64) not null,
     REV_ integer,
@@ -236,8 +125,6 @@ create table ACT_PROCDEF_INFO (
 
 create index ACT_IDX_EXEC_BUSKEY on ACT_RU_EXECUTION(BUSINESS_KEY_);
 create index ACT_IDX_EXEC_ROOT on ACT_RU_EXECUTION(ROOT_PROC_INST_ID_);
-create index ACT_IDX_IDENT_LNK_USER on ACT_RU_IDENTITYLINK(USER_ID_);
-create index ACT_IDX_IDENT_LNK_GROUP on ACT_RU_IDENTITYLINK(GROUP_ID_);
 create index ACT_IDX_EVENT_SUBSCR_CONFIG_ on ACT_RU_EVENT_SUBSCR(CONFIGURATION_);
 create index ACT_IDX_VARIABLE_TASK_ID on ACT_RU_VARIABLE(TASK_ID_);
 
@@ -341,12 +228,6 @@ alter table ACT_RU_JOB
     foreign key (PROC_DEF_ID_) 
     references ACT_RE_PROCDEF (ID_);
 
-create index ACT_IDX_JOB_EXCEPTION on ACT_RU_JOB(EXCEPTION_STACK_ID_);
-alter table ACT_RU_JOB 
-    add constraint ACT_FK_JOB_EXCEPTION 
-    foreign key (EXCEPTION_STACK_ID_) 
-    references ACT_GE_BYTEARRAY (ID_);
-
 create index ACT_IDX_TJOB_EXECUTION_ID on ACT_RU_TIMER_JOB(EXECUTION_ID_);
 alter table ACT_RU_TIMER_JOB 
     add constraint ACT_FK_TJOB_EXECUTION 
@@ -365,12 +246,6 @@ alter table ACT_RU_TIMER_JOB
     foreign key (PROC_DEF_ID_) 
     references ACT_RE_PROCDEF (ID_);
 
-create index ACT_IDX_TJOB_EXCEPTION on ACT_RU_TIMER_JOB(EXCEPTION_STACK_ID_);    
-alter table ACT_RU_TIMER_JOB 
-    add constraint ACT_FK_TJOB_EXCEPTION 
-    foreign key (EXCEPTION_STACK_ID_) 
-    references ACT_GE_BYTEARRAY (ID_);
-
 create index ACT_IDX_SJOB_EXECUTION_ID on ACT_RU_SUSPENDED_JOB(EXECUTION_ID_);    
 alter table ACT_RU_SUSPENDED_JOB 
     add constraint ACT_FK_SJOB_EXECUTION 
@@ -389,12 +264,6 @@ alter table ACT_RU_SUSPENDED_JOB
     foreign key (PROC_DEF_ID_) 
     references ACT_RE_PROCDEF (ID_);
 
-create index ACT_IDX_SJOB_EXCEPTION on ACT_RU_SUSPENDED_JOB(EXCEPTION_STACK_ID_);    
-alter table ACT_RU_SUSPENDED_JOB 
-    add constraint ACT_FK_SJOB_EXCEPTION 
-    foreign key (EXCEPTION_STACK_ID_) 
-    references ACT_GE_BYTEARRAY (ID_);
-
 create index ACT_IDX_DJOB_EXECUTION_ID on ACT_RU_DEADLETTER_JOB(EXECUTION_ID_);      
 alter table ACT_RU_DEADLETTER_JOB 
     add constraint ACT_FK_DJOB_EXECUTION 
@@ -413,12 +282,6 @@ alter table ACT_RU_DEADLETTER_JOB
     foreign key (PROC_DEF_ID_) 
     references ACT_RE_PROCDEF (ID_);
     
-create index ACT_IDX_DJOB_EXCEPTION on ACT_RU_DEADLETTER_JOB(EXCEPTION_STACK_ID_);    
-alter table ACT_RU_DEADLETTER_JOB 
-    add constraint ACT_FK_DJOB_EXCEPTION 
-    foreign key (EXCEPTION_STACK_ID_) 
-    references ACT_GE_BYTEARRAY (ID_);
-    
 create index ACT_IDX_EVENT_SUBSCR on ACT_RU_EVENT_SUBSCR(EXECUTION_ID_);
 alter table ACT_RU_EVENT_SUBSCR
     add constraint ACT_FK_EVENT_EXEC

modules/flowable-engine/src/main/resources/org/flowable/db/create/flowable.oracle.create.history.sql

@@ -87,17 +87,6 @@ create table ACT_HI_ATTACHMENT (
     primary key (ID_)
 );
 
-create table ACT_HI_IDENTITYLINK (
-    ID_ NVARCHAR2(64),
-    GROUP_ID_ NVARCHAR2(255),
-    TYPE_ NVARCHAR2(255),
-    USER_ID_ NVARCHAR2(255),
-    TASK_ID_ NVARCHAR2(64),
-    CREATE_TIME_ TIMESTAMP(6),
-    PROC_INST_ID_ NVARCHAR2(64),
-    primary key (ID_)
-);
-
 create index ACT_IDX_HI_PRO_INST_END on ACT_HI_PROCINST(END_TIME_);
 create index ACT_IDX_HI_PRO_I_BUSKEY on ACT_HI_PROCINST(BUSINESS_KEY_);
 create index ACT_IDX_HI_ACT_INST_START on ACT_HI_ACTINST(START_TIME_);
@@ -110,7 +99,6 @@ create index ACT_IDX_HI_DETAIL_TASK_ID on ACT_HI_DETAIL(TASK_ID_);
 create index ACT_IDX_HI_PROCVAR_PROC_INST on ACT_HI_VARINST(PROC_INST_ID_);
 create index ACT_IDX_HI_PROCVAR_TASK_ID on ACT_HI_VARINST(TASK_ID_);
 create index ACT_IDX_HI_PROCVAR_EXE on ACT_HI_VARINST(EXECUTION_ID_);
-create index ACT_IDX_HI_IDENT_LNK_USER on ACT_HI_IDENTITYLINK(USER_ID_);
 create index ACT_IDX_HI_IDENT_LNK_TASK on ACT_HI_IDENTITYLINK(TASK_ID_);
 create index ACT_IDX_HI_IDENT_LNK_PROCINST on ACT_HI_IDENTITYLINK(PROC_INST_ID_);
 

modules/flowable-engine/src/main/resources/org/flowable/db/create/flowable.postgres.create.engine.sql

@@ -63,105 +63,6 @@ create table ACT_RU_EXECUTION (
     primary key (ID_)
 );
 
-create table ACT_RU_JOB (
-    ID_ varchar(64) NOT NULL,
-    REV_ integer,
-    TYPE_ varchar(255) NOT NULL,
-    LOCK_EXP_TIME_ timestamp,
-    LOCK_OWNER_ varchar(255),
-    EXCLUSIVE_ boolean,
-    EXECUTION_ID_ varchar(64),
-    PROCESS_INSTANCE_ID_ varchar(64),
-    PROC_DEF_ID_ varchar(64),
-    RETRIES_ integer,
-    EXCEPTION_STACK_ID_ varchar(64),
-    EXCEPTION_MSG_ varchar(4000),
-    DUEDATE_ timestamp,
-    REPEAT_ varchar(255),
-    HANDLER_TYPE_ varchar(255),
-    HANDLER_CFG_ varchar(4000),
-    CREATE_TIME_ timestamp,
-    TENANT_ID_ varchar(255) default '',
-    primary key (ID_)
-);
-
-create table ACT_RU_TIMER_JOB (
-    ID_ varchar(64) NOT NULL,
-    REV_ integer,
-    TYPE_ varchar(255) NOT NULL,
-    LOCK_EXP_TIME_ timestamp,
-    LOCK_OWNER_ varchar(255),
-    EXCLUSIVE_ boolean,
-    EXECUTION_ID_ varchar(64),
-    PROCESS_INSTANCE_ID_ varchar(64),
-    PROC_DEF_ID_ varchar(64),
-    RETRIES_ integer,
-    EXCEPTION_STACK_ID_ varchar(64),
-    EXCEPTION_MSG_ varchar(4000),
-    DUEDATE_ timestamp,
-    REPEAT_ varchar(255),
-    HANDLER_TYPE_ varchar(255),
-    HANDLER_CFG_ varchar(4000),
-    CREATE_TIME_ timestamp,
-    TENANT_ID_ varchar(255) default '',
-    primary key (ID_)
-);
-
-create table ACT_RU_SUSPENDED_JOB (
-    ID_ varchar(64) NOT NULL,
-    REV_ integer,
-    TYPE_ varchar(255) NOT NULL,
-    EXCLUSIVE_ boolean,
-    EXECUTION_ID_ varchar(64),
-    PROCESS_INSTANCE_ID_ varchar(64),
-    PROC_DEF_ID_ varchar(64),
-    RETRIES_ integer,
-    EXCEPTION_STACK_ID_ varchar(64),
-    EXCEPTION_MSG_ varchar(4000),
-    DUEDATE_ timestamp,
-    REPEAT_ varchar(255),
-    HANDLER_TYPE_ varchar(255),
-    HANDLER_CFG_ varchar(4000),
-    CREATE_TIME_ timestamp,
-    TENANT_ID_ varchar(255) default '',
-    primary key (ID_)
-);
-
-create table ACT_RU_DEADLETTER_JOB (
-    ID_ varchar(64) NOT NULL,
-    REV_ integer,
-    TYPE_ varchar(255) NOT NULL,
-    EXCLUSIVE_ boolean,
-    EXECUTION_ID_ varchar(64),
-    PROCESS_INSTANCE_ID_ varchar(64),
-    PROC_DEF_ID_ varchar(64),
-    EXCEPTION_STACK_ID_ varchar(64),
-    EXCEPTION_MSG_ varchar(4000),
-    DUEDATE_ timestamp,
-    REPEAT_ varchar(255),
-    HANDLER_TYPE_ varchar(255),
-    HANDLER_CFG_ varchar(4000),
-    CREATE_TIME_ timestamp,
-    TENANT_ID_ varchar(255) default '',
-    primary key (ID_)
-);
-
-create table ACT_RU_HISTORY_JOB (
-    ID_ varchar(64) NOT NULL,
-    REV_ integer,
-    LOCK_EXP_TIME_ timestamp,
-    LOCK_OWNER_ varchar(255),
-    RETRIES_ integer,
-    EXCEPTION_STACK_ID_ varchar(64),
-    EXCEPTION_MSG_ varchar(4000),
-    HANDLER_TYPE_ varchar(255),
-    HANDLER_CFG_ varchar(4000),
-    ADV_HANDLER_CFG_ID_ varchar(64),
-    CREATE_TIME_ timestamp,
-    TENANT_ID_ varchar(255) default '',
-    primary key (ID_)
-);
-
 create table ACT_RE_PROCDEF (
     ID_ varchar(64) NOT NULL,
     REV_ integer,
@@ -181,18 +82,6 @@ create table ACT_RE_PROCDEF (
     primary key (ID_)
 );
 
-create table ACT_RU_IDENTITYLINK (
-    ID_ varchar(64),
-    REV_ integer,
-    GROUP_ID_ varchar(255),
-    TYPE_ varchar(255),
-    USER_ID_ varchar(255),
-    TASK_ID_ varchar(64),
-    PROC_INST_ID_ varchar(64),
-    PROC_DEF_ID_ varchar (64),
-    primary key (ID_)
-);
-
 create table ACT_RU_EVENT_SUBSCR (
     ID_ varchar(64) not null,
     REV_ integer,
@@ -233,8 +122,6 @@ create table ACT_PROCDEF_INFO (
 
 create index ACT_IDX_EXEC_BUSKEY on ACT_RU_EXECUTION(BUSINESS_KEY_);
 create index ACT_IDX_EXE_ROOT on ACT_RU_EXECUTION(ROOT_PROC_INST_ID_);
-create index ACT_IDX_IDENT_LNK_USER on ACT_RU_IDENTITYLINK(USER_ID_);
-create index ACT_IDX_IDENT_LNK_GROUP on ACT_RU_IDENTITYLINK(GROUP_ID_);
 create index ACT_IDX_EVENT_SUBSCR_CONFIG_ on ACT_RU_EVENT_SUBSCR(CONFIGURATION_);
 create index ACT_IDX_VARIABLE_TASK_ID on ACT_RU_VARIABLE(TASK_ID_);
 
@@ -340,12 +227,6 @@ alter table ACT_RU_JOB
     foreign key (PROC_DEF_ID_) 
     references ACT_RE_PROCDEF (ID_);
 
-create index ACT_IDX_JOB_EXCEPTION on ACT_RU_JOB(EXCEPTION_STACK_ID_);
-alter table ACT_RU_JOB 
-    add constraint ACT_FK_JOB_EXCEPTION 
-    foreign key (EXCEPTION_STACK_ID_) 
-    references ACT_GE_BYTEARRAY (ID_);
-
 create index ACT_IDX_TIMER_JOB_EXECUTION_ID on ACT_RU_TIMER_JOB(EXECUTION_ID_);
 alter table ACT_RU_TIMER_JOB 
     add constraint ACT_FK_TIMER_JOB_EXECUTION 
@@ -364,12 +245,6 @@ alter table ACT_RU_TIMER_JOB
     foreign key (PROC_DEF_ID_) 
     references ACT_RE_PROCDEF (ID_);
 
-create index ACT_IDX_TIMER_JOB_EXCEPTION on ACT_RU_TIMER_JOB(EXCEPTION_STACK_ID_);    
-alter table ACT_RU_TIMER_JOB 
-    add constraint ACT_FK_TIMER_JOB_EXCEPTION 
-    foreign key (EXCEPTION_STACK_ID_) 
-    references ACT_GE_BYTEARRAY (ID_);
-
 create index ACT_IDX_SUSPENDED_JOB_EXECUTION_ID on ACT_RU_SUSPENDED_JOB(EXECUTION_ID_);    
 alter table ACT_RU_SUSPENDED_JOB 
     add constraint ACT_FK_SUSPENDED_JOB_EXECUTION 
@@ -388,12 +263,6 @@ alter table ACT_RU_SUSPENDED_JOB
     foreign key (PROC_DEF_ID_) 
     references ACT_RE_PROCDEF (ID_);
 
-create index ACT_IDX_SUSPENDED_JOB_EXCEPTION on ACT_RU_SUSPENDED_JOB(EXCEPTION_STACK_ID_);    
-alter table ACT_RU_SUSPENDED_JOB 
-    add constraint ACT_FK_SUSPENDED_JOB_EXCEPTION 
-    foreign key (EXCEPTION_STACK_ID_) 
-    references ACT_GE_BYTEARRAY (ID_);
-
 create index ACT_IDX_DEADLETTER_JOB_EXECUTION_ID on ACT_RU_DEADLETTER_JOB(EXECUTION_ID_);      
 alter table ACT_RU_DEADLETTER_JOB 
     add constraint ACT_FK_DEADLETTER_JOB_EXECUTION 
@@ -412,12 +281,6 @@ alter table ACT_RU_DEADLETTER_JOB
     foreign key (PROC_DEF_ID_) 
     references ACT_RE_PROCDEF (ID_);
     
-create index ACT_IDX_DEADLETTER_JOB_EXCEPTION on ACT_RU_DEADLETTER_JOB(EXCEPTION_STACK_ID_);    
-alter table ACT_RU_DEADLETTER_JOB 
-    add constraint ACT_FK_DEADLETTER_JOB_EXCEPTION 
-    foreign key (EXCEPTION_STACK_ID_) 
-    references ACT_GE_BYTEARRAY (ID_);
-
 create index ACT_IDX_EVENT_SUBSCR on ACT_RU_EVENT_SUBSCR(EXECUTION_ID_);
 alter table ACT_RU_EVENT_SUBSCR
     add constraint ACT_FK_EVENT_EXEC

modules/flowable-engine/src/main/resources/org/flowable/db/create/flowable.postgres.create.history.sql

@@ -87,18 +87,6 @@ create table ACT_HI_ATTACHMENT (
     primary key (ID_)
 );
 
-create table ACT_HI_IDENTITYLINK (
-    ID_ varchar(64),
-    GROUP_ID_ varchar(255),
-    TYPE_ varchar(255),
-    USER_ID_ varchar(255),
-    TASK_ID_ varchar(64),
-    CREATE_TIME_ timestamp,
-    PROC_INST_ID_ varchar(64),
-    primary key (ID_)
-);
-
-
 create index ACT_IDX_HI_PRO_INST_END on ACT_HI_PROCINST(END_TIME_);
 create index ACT_IDX_HI_PRO_I_BUSKEY on ACT_HI_PROCINST(BUSINESS_KEY_);
 create index ACT_IDX_HI_ACT_INST_START on ACT_HI_ACTINST(START_TIME_);
@@ -113,7 +101,6 @@ create index ACT_IDX_HI_PROCVAR_TASK_ID on ACT_HI_VARINST(TASK_ID_);
 create index ACT_IDX_HI_PROCVAR_EXE on ACT_HI_VARINST(EXECUTION_ID_);
 create index ACT_IDX_HI_ACT_INST_PROCINST on ACT_HI_ACTINST(PROC_INST_ID_, ACT_ID_);
 create index ACT_IDX_HI_ACT_INST_EXEC on ACT_HI_ACTINST(EXECUTION_ID_, ACT_ID_);
-create index ACT_IDX_HI_IDENT_LNK_USER on ACT_HI_IDENTITYLINK(USER_ID_);
 create index ACT_IDX_HI_IDENT_LNK_TASK on ACT_HI_IDENTITYLINK(TASK_ID_);
 create index ACT_IDX_HI_IDENT_LNK_PROCINST on ACT_HI_IDENTITYLINK(PROC_INST_ID_);
 create index ACT_IDX_HI_TASK_INST_PROCINST on ACT_HI_TASKINST(PROC_INST_ID_);

modules/flowable-engine/src/main/resources/org/flowable/db/drop/flowable.db2.drop.engine.sql

 drop index ACT_IDX_EXEC_BUSKEY;
-drop index ACT_IDX_IDENT_LNK_USER;
-drop index ACT_IDX_IDENT_LNK_GROUP;
 drop index ACT_IDX_VARIABLE_TASK_ID;
 
 alter table ACT_GE_BYTEARRAY 
@@ -20,6 +18,9 @@ alter table ACT_RU_EXECUTION
 
 alter table ACT_RU_IDENTITYLINK
     drop foreign key ACT_FK_TSKASS_TASK;
+    
+alter table ACT_RU_IDENTITYLINK
+    drop foreign key ACT_FK_IDL_PROCINST;  
 
 alter table ACT_RU_IDENTITYLINK
     drop foreign key ACT_FK_ATHRZ_PROCEDEF;
@@ -48,9 +49,6 @@ alter table ACT_RU_JOB
 alter table ACT_RU_JOB 
     drop foreign key ACT_FK_JOB_PROC_DEF;
 
-alter table ACT_RU_JOB 
-    drop foreign key ACT_FK_JOB_EXCEPTION;
-    
 alter table ACT_RU_TIMER_JOB 
     drop foreign key ACT_FK_TIMER_JOB_EXECUTION;
     
@@ -60,9 +58,6 @@ alter table ACT_RU_TIMER_JOB
 alter table ACT_RU_TIMER_JOB 
     drop foreign key ACT_FK_TIMER_JOB_PROC_DEF;
     
-alter table ACT_RU_TIMER_JOB 
-    drop foreign key ACT_FK_TIMER_JOB_EXCEPTION;
-    
 alter table ACT_RU_SUSPENDED_JOB 
     drop foreign key ACT_FK_SUSPENDED_JOB_EXECUTION;
     
@@ -72,9 +67,6 @@ alter table ACT_RU_SUSPENDED_JOB
 alter table ACT_RU_SUSPENDED_JOB 
     drop foreign key ACT_FK_SUSPENDED_JOB_PROC_DEF;
     
-alter table ACT_RU_SUSPENDED_JOB 
-    drop foreign key ACT_FK_SUSPENDED_JOB_EXCEPTION;
-    
 alter table ACT_RU_DEADLETTER_JOB 
     drop foreign key ACT_FK_DEADLETTER_JOB_EXECUTION;
     
@@ -84,9 +76,6 @@ alter table ACT_RU_DEADLETTER_JOB
 alter table ACT_RU_DEADLETTER_JOB 
     drop foreign key ACT_FK_DEADLETTER_JOB_PROC_DEF;
     
-alter table ACT_RU_DEADLETTER_JOB 
-    drop foreign key ACT_FK_DEADLETTER_JOB_EXCEPTION;
-    
 alter table ACT_RU_EVENT_SUBSCR
     drop foreign key ACT_FK_EVENT_EXEC;
 
@@ -111,13 +100,7 @@ drop index ACT_IDX_ATHRZ_PROCEDEF;
 drop table ACT_RE_DEPLOYMENT;
 drop table ACT_RE_MODEL;
 drop table ACT_RE_PROCDEF;
-drop table ACT_RU_IDENTITYLINK;
 drop table ACT_RU_EXECUTION;
-drop table ACT_RU_JOB;
-drop table ACT_RU_TIMER_JOB;
-drop table ACT_RU_SUSPENDED_JOB;
-drop table ACT_RU_DEADLETTER_JOB;
-drop table ACT_RU_HISTORY_JOB;
 drop table ACT_RU_EVENT_SUBSCR;
 drop table ACT_EVT_LOG;
 drop table ACT_PROCDEF_INFO;

modules/flowable-engine/src/main/resources/org/flowable/db/drop/flowable.db2.drop.history.sql

@@ -11,7 +11,6 @@ drop index ACT_IDX_HI_PROCVAR_PROC_INST;
 drop index ACT_IDX_HI_PROCVAR_TASK_ID;
 drop index ACT_IDX_HI_PROCVAR_EXE;
 drop index ACT_IDX_HI_ACT_INST_PROCINST;
-drop index ACT_IDX_HI_IDENT_LNK_USER;
 drop index ACT_IDX_HI_IDENT_LNK_TASK;
 drop index ACT_IDX_HI_IDENT_LNK_PROCINST;
 drop index ACT_IDX_HI_TASK_INST_PROCINST;
@@ -21,4 +20,3 @@ drop table ACT_HI_ACTINST;
 drop table ACT_HI_DETAIL;
 drop table ACT_HI_COMMENT;
 drop table ACT_HI_ATTACHMENT;
-drop table ACT_HI_IDENTITYLINK;

modules/flowable-engine/src/main/resources/org/flowable/db/drop/flowable.h2.drop.engine.sql

 drop table if exists ACT_RE_DEPLOYMENT cascade constraints;
 drop table if exists ACT_RE_MODEL cascade constraints;
 drop table if exists ACT_RU_EXECUTION cascade constraints;
-drop table if exists ACT_RU_JOB cascade constraints;
-drop table if exists ACT_RU_TIMER_JOB cascade constraints;
-drop table if exists ACT_RU_SUSPENDED_JOB cascade constraints;
-drop table if exists ACT_RU_DEADLETTER_JOB cascade constraints;
-drop table if exists ACT_RU_HISTORY_JOB cascade constraints;
 drop table if exists ACT_RE_PROCDEF cascade constraints;
-drop table if exists ACT_RU_IDENTITYLINK cascade constraints;
 drop table if exists ACT_RU_EVENT_SUBSCR cascade constraints;
 drop table if exists ACT_EVT_LOG cascade constraints;
 drop table if exists ACT_PROCDEF_INFO cascade constraints;
 
 drop index if exists ACT_IDX_EXEC_BUSKEY;
-drop index if exists ACT_IDX_IDENT_LNK_USER;
-drop index if exists ACT_IDX_IDENT_LNK_GROUP;
 drop index if exists ACT_IDX_VARIABLE_TASK_ID;
 drop index if exists ACT_IDX_EVENT_SUBSCR_CONFIG_;
 drop index if exists ACT_IDX_ATHRZ_PROCEDEF;

modules/flowable-engine/src/main/resources/org/flowable/db/drop/flowable.h2.drop.history.sql

@@ -3,7 +3,6 @@ drop table if exists ACT_HI_ACTINST cascade constraints;
 drop table if exists ACT_HI_DETAIL cascade constraints;
 drop table if exists ACT_HI_COMMENT cascade constraints;
 drop table if exists ACT_HI_ATTACHMENT cascade constraints;
-drop table if exists ACT_HI_IDENTITYLINK cascade constraints;
 
 drop index if exists ACT_IDX_HI_PRO_INST_END;
 drop index if exists ACT_IDX_HI_PRO_I_BUSKEY;
@@ -18,7 +17,6 @@ drop index if exists ACT_IDX_HI_PROCVAR_PROC_INST;
 drop index if exists ACT_IDX_HI_PROCVAR_TASK_ID;
 drop index if exists ACT_IDX_HI_PROCVAR_EXE;
 drop index if exists ACT_IDX_HI_ACT_INST_PROCINST;
-drop index if exists ACT_IDX_HI_IDENT_LNK_USER;
 drop index if exists ACT_IDX_HI_IDENT_LNK_TASK;
 drop index if exists ACT_IDX_HI_IDENT_LNK_PROCINST;
 drop index if exists ACT_IDX_HI_TASK_INST_PROCINST;

modules/flowable-engine/src/main/resources/org/flowable/db/drop/flowable.hsql.drop.engine.sql

 drop table if exists ACT_RE_DEPLOYMENT cascade;
 drop table if exists ACT_RE_MODEL cascade;
 drop table if exists ACT_RU_EXECUTION cascade;
-drop table if exists ACT_RU_JOB cascade;
-drop table if exists ACT_RU_TIMER_JOB cascade;
-drop table if exists ACT_RU_SUSPENDED_JOB cascade;
-drop table if exists ACT_RU_DEADLETTER_JOB cascade;
-drop table if exists ACT_RU_HISTORY_JOB cascade;
 drop table if exists ACT_RE_PROCDEF cascade;
-drop table if exists ACT_RU_IDENTITYLINK cascade;
 drop table if exists ACT_RU_EVENT_SUBSCR cascade;
 drop table if exists ACT_EVT_LOG cascade;
 drop table if exists ACT_PROCDEF_INFO cascade;
 
 drop index if exists ACT_IDX_EXEC_BUSKEY;
-drop index if exists ACT_IDX_IDENT_LNK_USER;
-drop index if exists ACT_IDX_IDENT_LNK_GROUP;
 drop index if exists ACT_IDX_VARIABLE_TASK_ID;
 drop index if exists ACT_IDX_EVENT_SUBSCR_CONFIG_;
 drop index if exists ACT_IDX_ATHRZ_PROCEDEF;

modules/flowable-engine/src/main/resources/org/flowable/db/drop/flowable.hsql.drop.history.sql

@@ -3,7 +3,6 @@ drop table if exists ACT_HI_ACTINST cascade;
 drop table if exists ACT_HI_DETAIL cascade;
 drop table if exists ACT_HI_COMMENT cascade;
 drop table if exists ACT_HI_ATTACHMENT cascade;
-drop table if exists ACT_HI_IDENTITYLINK cascade;
 
 drop index if exists ACT_IDX_HI_PRO_INST_END;
 drop index if exists ACT_IDX_HI_PRO_I_BUSKEY;
@@ -18,6 +17,5 @@ drop index if exists ACT_IDX_HI_PROCVAR_PROC_INST;
 drop index if exists ACT_IDX_HI_PROCVAR_TASK_ID;
 drop index if exists ACT_IDX_HI_PROCVAR_EXE;
 drop index if exists ACT_IDX_HI_ACT_INST_PROCINST;
-drop index if exists ACT_IDX_HI_IDENT_LNK_USER;
 drop index if exists ACT_IDX_HI_IDENT_LNK_TASK;
 drop index if exists ACT_IDX_HI_IDENT_LNK_PROCINST;

modules/flowable-engine/src/main/resources/org/flowable/db/drop/flowable.mssql.drop.engine.sql

 IF EXISTS (SELECT name FROM sysindexes WHERE name = 'ACT_IDX_EXEC_BUSKEY') drop index ACT_RU_EXECUTION.ACT_IDX_EXEC_BUSKEY;
-IF EXISTS (SELECT name FROM sysindexes WHERE name = 'ACT_IDX_IDENT_LNK_USER') drop index ACT_RU_IDENTITYLINK.ACT_IDX_IDENT_LNK_USER;
-IF EXISTS (SELECT name FROM sysindexes WHERE name = 'ACT_IDX_IDENT_LNK_GROUP') drop index ACT_RU_IDENTITYLINK.ACT_IDX_IDENT_LNK_GROUP;
 IF EXISTS (SELECT name FROM sysindexes WHERE name = 'ACT_IDX_VARIABLE_TASK_ID') drop index ACT_RU_VARIABLE.ACT_IDX_VARIABLE_TASK_ID;
 IF EXISTS (SELECT name FROM sysindexes WHERE name = 'ACT_IDX_EVENT_SUBSCR_CONFIG_') drop index ACT_RU_EVENT_SUBSCR.ACT_IDX_EVENT_SUBSCR_CONFIG_;
 IF EXISTS (SELECT name FROM sysindexes WHERE name = 'ACT_IDX_INFO_PROCDEF') drop index ACT_PROCDEF_INFO.ACT_IDX_INFO_PROCDEF;
@@ -11,6 +9,7 @@ if exists (select TABLE_NAME from INFORMATION_SCHEMA.TABLES where TABLE_NAME = '
 if exists (select TABLE_NAME from INFORMATION_SCHEMA.TABLES where TABLE_NAME = 'ACT_RU_EXECUTION') alter table ACT_RU_EXECUTION drop constraint ACT_FK_EXE_PARENT;
 if exists (select TABLE_NAME from INFORMATION_SCHEMA.TABLES where TABLE_NAME = 'ACT_RU_EXECUTION') alter table ACT_RU_EXECUTION drop constraint ACT_FK_EXE_SUPER;  
 if exists (select TABLE_NAME from INFORMATION_SCHEMA.TABLES where TABLE_NAME = 'ACT_RU_IDENTITYLINK') alter table ACT_RU_IDENTITYLINK drop constraint ACT_FK_TSKASS_TASK;
+if exists (select TABLE_NAME from INFORMATION_SCHEMA.TABLES where TABLE_NAME = 'ACT_RU_IDENTITYLINK') alter table ACT_RU_IDENTITYLINK drop constraint ACT_FK_IDL_PROCINST;
 if exists (select TABLE_NAME from INFORMATION_SCHEMA.TABLES where TABLE_NAME = 'ACT_RU_IDENTITYLINK') alter table ACT_RU_IDENTITYLINK drop constraint ACT_FK_ATHRZ_PROCEDEF;
 if exists (select TABLE_NAME from INFORMATION_SCHEMA.TABLES where TABLE_NAME = 'ACT_RU_TASK') alter table ACT_RU_TASK drop constraint ACT_FK_TASK_EXE;
 if exists (select TABLE_NAME from INFORMATION_SCHEMA.TABLES where TABLE_NAME = 'ACT_RU_TASK') alter table ACT_RU_TASK drop constraint ACT_FK_TASK_PROCINST;
@@ -20,19 +19,15 @@ if exists (select TABLE_NAME from INFORMATION_SCHEMA.TABLES where TABLE_NAME = '
 if exists (select TABLE_NAME from INFORMATION_SCHEMA.TABLES where TABLE_NAME = 'ACT_RU_JOB') alter table ACT_RU_JOB drop constraint ACT_FK_JOB_EXECUTION;
 if exists (select TABLE_NAME from INFORMATION_SCHEMA.TABLES where TABLE_NAME = 'ACT_RU_JOB') alter table ACT_RU_JOB drop constraint ACT_FK_JOB_PROCESS_INSTANCE;
 if exists (select TABLE_NAME from INFORMATION_SCHEMA.TABLES where TABLE_NAME = 'ACT_RU_JOB') alter table ACT_RU_JOB drop constraint ACT_FK_JOB_PROC_DEF;
-if exists (select TABLE_NAME from INFORMATION_SCHEMA.TABLES where TABLE_NAME = 'ACT_RU_JOB') alter table ACT_RU_JOB drop constraint ACT_FK_JOB_EXCEPTION;
 if exists (select TABLE_NAME from INFORMATION_SCHEMA.TABLES where TABLE_NAME = 'ACT_RU_TIMER_JOB') alter table ACT_RU_TIMER_JOB drop constraint ACT_FK_TIMER_JOB_EXECUTION;
 if exists (select TABLE_NAME from INFORMATION_SCHEMA.TABLES where TABLE_NAME = 'ACT_RU_TIMER_JOB') alter table ACT_RU_TIMER_JOB drop constraint ACT_FK_TIMER_JOB_PROCESS_INSTANCE;
 if exists (select TABLE_NAME from INFORMATION_SCHEMA.TABLES where TABLE_NAME = 'ACT_RU_TIMER_JOB') alter table ACT_RU_TIMER_JOB drop constraint ACT_FK_TIMER_JOB_PROC_DEF;
-if exists (select TABLE_NAME from INFORMATION_SCHEMA.TABLES where TABLE_NAME = 'ACT_RU_TIMER_JOB') alter table ACT_RU_TIMER_JOB drop constraint ACT_FK_TIMER_JOB_EXCEPTION;
 if exists (select TABLE_NAME from INFORMATION_SCHEMA.TABLES where TABLE_NAME = 'ACT_RU_SUSPENDED_JOB') alter table ACT_RU_SUSPENDED_JOB drop constraint ACT_FK_SUSPENDED_JOB_EXECUTION;
 if exists (select TABLE_NAME from INFORMATION_SCHEMA.TABLES where TABLE_NAME = 'ACT_RU_SUSPENDED_JOB') alter table ACT_RU_SUSPENDED_JOB drop constraint ACT_FK_SUSPENDED_JOB_PROCESS_INSTANCE;
 if exists (select TABLE_NAME from INFORMATION_SCHEMA.TABLES where TABLE_NAME = 'ACT_RU_SUSPENDED_JOB') alter table ACT_RU_SUSPENDED_JOB drop constraint ACT_FK_SUSPENDED_JOB_PROC_DEF;
-if exists (select TABLE_NAME from INFORMATION_SCHEMA.TABLES where TABLE_NAME = 'ACT_RU_SUSPENDED_JOB') alter table ACT_RU_SUSPENDED_JOB drop constraint ACT_FK_SUSPENDED_JOB_EXCEPTION;
 if exists (select TABLE_NAME from INFORMATION_SCHEMA.TABLES where TABLE_NAME = 'ACT_RU_DEADLETTER_JOB') alter table ACT_RU_DEADLETTER_JOB drop constraint ACT_FK_DEADLETTER_JOB_EXECUTION;
 if exists (select TABLE_NAME from INFORMATION_SCHEMA.TABLES where TABLE_NAME = 'ACT_RU_DEADLETTER_JOB') alter table ACT_RU_DEADLETTER_JOB drop constraint ACT_FK_DEADLETTER_JOB_PROCESS_INSTANCE;
 if exists (select TABLE_NAME from INFORMATION_SCHEMA.TABLES where TABLE_NAME = 'ACT_RU_DEADLETTER_JOB') alter table ACT_RU_DEADLETTER_JOB drop constraint ACT_FK_DEADLETTER_JOB_PROC_DEF;
-if exists (select TABLE_NAME from INFORMATION_SCHEMA.TABLES where TABLE_NAME = 'ACT_RU_DEADLETTER_JOB') alter table ACT_RU_DEADLETTER_JOB drop constraint ACT_FK_DEADLETTER_JOB_EXCEPTION;
 if exists (select TABLE_NAME from INFORMATION_SCHEMA.TABLES where TABLE_NAME = 'ACT_RU_EVENT_SUBSCR') alter table ACT_RU_EVENT_SUBSCR drop constraint ACT_FK_EVENT_EXEC;
 if exists (select TABLE_NAME from INFORMATION_SCHEMA.TABLES where TABLE_NAME = 'ACT_RE_MODEL') alter table ACT_RE_MODEL drop constraint ACT_FK_MODEL_SOURCE;
 if exists (select TABLE_NAME from INFORMATION_SCHEMA.TABLES where TABLE_NAME = 'ACT_RE_MODEL') alter table ACT_RE_MODEL drop constraint ACT_FK_MODEL_SOURCE_EXTRA;
@@ -45,13 +40,7 @@ IF EXISTS (SELECT name FROM sysindexes WHERE name = 'ACT_IDX_ATHRZ_PROCEDEF') dr
 if exists (select TABLE_NAME from INFORMATION_SCHEMA.TABLES where TABLE_NAME = 'ACT_RE_PROCDEF') drop table ACT_RE_PROCDEF;
 if exists (select TABLE_NAME from INFORMATION_SCHEMA.TABLES where TABLE_NAME = 'ACT_RE_DEPLOYMENT') drop table ACT_RE_DEPLOYMENT;
 if exists (select TABLE_NAME from INFORMATION_SCHEMA.TABLES where TABLE_NAME = 'ACT_RE_MODEL') drop table ACT_RE_MODEL;
-if exists (select TABLE_NAME from INFORMATION_SCHEMA.TABLES where TABLE_NAME = 'ACT_RU_IDENTITYLINK') drop table ACT_RU_IDENTITYLINK;
 if exists (select TABLE_NAME from INFORMATION_SCHEMA.TABLES where TABLE_NAME = 'ACT_RU_EXECUTION') drop table ACT_RU_EXECUTION;
 if exists (select TABLE_NAME from INFORMATION_SCHEMA.TABLES where TABLE_NAME = 'ACT_RU_EVENT_SUBSCR') drop table ACT_RU_EVENT_SUBSCR;
-if exists (select TABLE_NAME from INFORMATION_SCHEMA.TABLES where TABLE_NAME = 'ACT_RU_JOB') drop table ACT_RU_JOB;
-if exists (select TABLE_NAME from INFORMATION_SCHEMA.TABLES where TABLE_NAME = 'ACT_RU_TIMER_JOB') drop table ACT_RU_TIMER_JOB;
-if exists (select TABLE_NAME from INFORMATION_SCHEMA.TABLES where TABLE_NAME = 'ACT_RU_SUSPENDED_JOB') drop table ACT_RU_SUSPENDED_JOB;
-if exists (select TABLE_NAME from INFORMATION_SCHEMA.TABLES where TABLE_NAME = 'ACT_RU_DEADLETTER_JOB') drop table ACT_RU_DEADLETTER_JOB;
-if exists (select TABLE_NAME from INFORMATION_SCHEMA.TABLES where TABLE_NAME = 'ACT_RU_HISTORY_JOB') drop table ACT_RU_HISTORY_JOB;
 if exists (select TABLE_NAME from INFORMATION_SCHEMA.TABLES where TABLE_NAME = 'ACT_EVT_LOG') drop table ACT_EVT_LOG;
 if exists (select TABLE_NAME from INFORMATION_SCHEMA.TABLES where TABLE_NAME = 'ACT_PROCDEF_INFO') drop table ACT_PROCDEF_INFO;
\ No newline at end of file

modules/flowable-engine/src/main/resources/org/flowable/db/drop/flowable.mssql.drop.history.sql

@@ -11,7 +11,7 @@ IF EXISTS (SELECT name FROM sysindexes WHERE name = 'ACT_IDX_HI_PROCVAR_PROC_INS
 IF EXISTS (SELECT name FROM sysindexes WHERE name = 'ACT_IDX_HI_PROCVAR_TASK_ID') drop index ACT_HI_VARINST.ACT_IDX_HI_PROCVAR_TASK_ID;
 IF EXISTS (SELECT name FROM sysindexes WHERE name = 'ACT_IDX_HI_PROCVAR_EXE') drop index ACT_HI_VARINST.ACT_IDX_HI_PROCVAR_EXE;
 IF EXISTS (SELECT name FROM sysindexes WHERE name = 'ACT_IDX_HI_ACT_INST_PROCINST') drop index ACT_HI_ACTINST.ACT_IDX_HI_ACT_INST_PROCINST;
-IF EXISTS (SELECT name FROM sysindexes WHERE name = 'ACT_IDX_HI_IDENT_LNK_USER') drop index ACT_HI_IDENTITYLINK.ACT_IDX_HI_IDENT_LNK_USER;
+
 IF EXISTS (SELECT name FROM sysindexes WHERE name = 'ACT_IDX_HI_IDENT_LNK_TASK') drop index ACT_HI_IDENTITYLINK.ACT_IDX_HI_IDENT_LNK_TASK;
 IF EXISTS (SELECT name FROM sysindexes WHERE name = 'ACT_IDX_HI_IDENT_LNK_PROCINST') drop index ACT_HI_IDENTITYLINK.ACT_IDX_HI_IDENT_LNK_PROCINST;
 IF EXISTS (SELECT name FROM sysindexes WHERE name = 'ACT_IDX_HI_TASK_INST_PROCINST') drop index ACT_HI_TASKINST.ACT_IDX_HI_TASK_INST_PROCINST;
@@ -21,4 +21,3 @@ if exists (select TABLE_NAME from INFORMATION_SCHEMA.TABLES where TABLE_NAME = '
 if exists (select TABLE_NAME from INFORMATION_SCHEMA.TABLES where TABLE_NAME = 'ACT_HI_DETAIL') drop table ACT_HI_DETAIL;
 if exists (select TABLE_NAME from INFORMATION_SCHEMA.TABLES where TABLE_NAME = 'ACT_HI_COMMENT') drop table ACT_HI_COMMENT;
 if exists (select TABLE_NAME from INFORMATION_SCHEMA.TABLES where TABLE_NAME = 'ACT_HI_ATTACHMENT') drop table ACT_HI_ATTACHMENT;
-if exists (select TABLE_NAME from INFORMATION_SCHEMA.TABLES where TABLE_NAME = 'ACT_HI_IDENTITYLINK') drop table ACT_HI_IDENTITYLINK;

modules/flowable-engine/src/main/resources/org/flowable/db/drop/flowable.mysql.drop.engine.sql

 drop index ACT_IDX_EXEC_BUSKEY on ACT_RU_EXECUTION;
-drop index ACT_IDX_IDENT_LNK_USER on ACT_RU_IDENTITYLINK;
-drop index ACT_IDX_IDENT_LNK_GROUP on ACT_RU_IDENTITYLINK;
 drop index ACT_IDX_VARIABLE_TASK_ID on ACT_RU_VARIABLE;
 drop index ACT_IDX_INFO_PROCDEF on ACT_PROCDEF_INFO;
 
@@ -21,6 +19,9 @@ alter table ACT_RU_EXECUTION
 
 alter table ACT_RU_IDENTITYLINK
     drop FOREIGN KEY ACT_FK_TSKASS_TASK;
+    
+alter table ACT_RU_IDENTITYLINK
+    drop FOREIGN KEY ACT_FK_IDL_PROCINST;    
 
 alter table ACT_RU_IDENTITYLINK
     drop FOREIGN KEY ACT_FK_ATHRZ_PROCEDEF;
@@ -49,9 +50,6 @@ alter table ACT_RU_JOB
 alter table ACT_RU_JOB 
     drop foreign key ACT_FK_JOB_PROC_DEF;
 
-alter table ACT_RU_JOB 
-    drop foreign key ACT_FK_JOB_EXCEPTION;
-    
 alter table ACT_RU_TIMER_JOB 
     drop foreign key ACT_FK_TIMER_JOB_EXECUTION;
     
@@ -61,9 +59,6 @@ alter table ACT_RU_TIMER_JOB
 alter table ACT_RU_TIMER_JOB 
     drop foreign key ACT_FK_TIMER_JOB_PROC_DEF;
     
-alter table ACT_RU_TIMER_JOB 
-    drop foreign key ACT_FK_TIMER_JOB_EXCEPTION;
-    
 alter table ACT_RU_SUSPENDED_JOB 
     drop foreign key ACT_FK_SUSPENDED_JOB_EXECUTION;
     
@@ -73,9 +68,6 @@ alter table ACT_RU_SUSPENDED_JOB
 alter table ACT_RU_SUSPENDED_JOB 
     drop foreign key ACT_FK_SUSPENDED_JOB_PROC_DEF;
     
-alter table ACT_RU_SUSPENDED_JOB 
-    drop foreign key ACT_FK_SUSPENDED_JOB_EXCEPTION;
-    
 alter table ACT_RU_DEADLETTER_JOB 
     drop foreign key ACT_FK_DEADLETTER_JOB_EXECUTION;
     
@@ -85,9 +77,6 @@ alter table ACT_RU_DEADLETTER_JOB
 alter table ACT_RU_DEADLETTER_JOB 
     drop foreign key ACT_FK_DEADLETTER_JOB_PROC_DEF;
     
-alter table ACT_RU_DEADLETTER_JOB 
-    drop foreign key ACT_FK_DEADLETTER_JOB_EXCEPTION;
-    
 alter table ACT_RU_EVENT_SUBSCR
     drop FOREIGN KEY ACT_FK_EVENT_EXEC;
 
@@ -111,14 +100,8 @@ drop index ACT_IDX_EVENT_SUBSCR_CONFIG_ on ACT_RU_EVENT_SUBSCR;
     
 drop table if exists ACT_RE_DEPLOYMENT;
 drop table if exists ACT_RE_MODEL;
-drop table if exists ACT_RU_IDENTITYLINK;
 drop table if exists ACT_RE_PROCDEF;
 drop table if exists ACT_RU_EXECUTION;
-drop table if exists ACT_RU_JOB;
-drop table if exists ACT_RU_TIMER_JOB;
-drop table if exists ACT_RU_SUSPENDED_JOB;
-drop table if exists ACT_RU_DEADLETTER_JOB;
-drop table if exists ACT_RU_HISTORY_JOB;
 drop table if exists ACT_RU_EVENT_SUBSCR;
 drop table if exists ACT_EVT_LOG;
 drop table if exists ACT_PROCDEF_INFO;
\ No newline at end of file

modules/flowable-engine/src/main/resources/org/flowable/db/drop/flowable.mysql.drop.history.sql

@@ -11,7 +11,6 @@ drop index ACT_IDX_HI_PROCVAR_PROC_INST on ACT_HI_VARINST;
 drop index ACT_IDX_HI_PROCVAR_TASK_ID on ACT_HI_VARINST;
 drop index ACT_IDX_HI_PROCVAR_EXE on ACT_HI_VARINST;
 drop index ACT_IDX_HI_ACT_INST_PROCINST on ACT_HI_ACTINST;
-drop index ACT_IDX_HI_IDENT_LNK_USER on ACT_HI_IDENTITYLINK;
 drop index ACT_IDX_HI_IDENT_LNK_TASK on ACT_HI_IDENTITYLINK;
 drop index ACT_IDX_HI_IDENT_LNK_PROCINST on ACT_HI_IDENTITYLINK;
 drop index ACT_IDX_HI_TASK_INST_PROCINST on ACT_HI_TASKINST;
@@ -21,4 +20,3 @@ drop table if exists ACT_HI_ACTINST;
 drop table if exists ACT_HI_DETAIL;
 drop table if exists ACT_HI_COMMENT;
 drop table if exists ACT_HI_ATTACHMENT;
-drop table if exists ACT_HI_IDENTITYLINK;

modules/flowable-engine/src/main/resources/org/flowable/db/drop/flowable.oracle.drop.engine.sql

@@ -11,27 +11,21 @@ drop index ACT_IDX_VAR_PROCINST;
 drop index ACT_IDX_JOB_EXECUTION_ID;
 drop index ACT_IDX_JOB_PROC_INST_ID;
 drop index ACT_IDX_JOB_PROC_DEF_ID;
-drop index ACT_IDX_JOB_EXCEPTION;
 drop index ACT_IDX_TJOB_EXECUTION_ID;
 drop index ACT_IDX_TJOB_PROC_INST_ID;
 drop index ACT_IDX_TJOB_PROC_DEF_ID;
-drop index ACT_IDX_TJOB_EXCEPTION;    
 drop index ACT_IDX_SJOB_EXECUTION_ID;    
 drop index ACT_IDX_SJOB_PROC_INST_ID;    
 drop index ACT_IDX_SJOB_PROC_DEF_ID;    
-drop index ACT_IDX_SJOB_EXCEPTION;    
 drop index ACT_IDX_DJOB_EXECUTION_ID;      
 drop index ACT_IDX_DJOB_PROC_INST_ID;        
 drop index ACT_IDX_DJOB_PROC_DEF_ID;    
-drop index ACT_IDX_DJOB_EXCEPTION;
 drop index ACT_IDX_MODEL_SOURCE;
 drop index ACT_IDX_MODEL_SOURCE_EXTRA;
 drop index ACT_IDX_MODEL_DEPLOYMENT;
 drop index ACT_IDX_PROCDEF_INFO_JSON;
 
 drop index ACT_IDX_EXEC_BUSKEY;
-drop index ACT_IDX_IDENT_LNK_USER;
-drop index ACT_IDX_IDENT_LNK_GROUP;
 drop index ACT_IDX_VARIABLE_TASK_ID;
 
 alter table ACT_GE_BYTEARRAY 
@@ -51,6 +45,9 @@ alter table ACT_RU_EXECUTION
     
 alter table ACT_RU_IDENTITYLINK
     drop CONSTRAINT ACT_FK_TSKASS_TASK;
+    
+alter table ACT_RU_IDENTITYLINK
+    drop CONSTRAINT ACT_FK_IDL_PROCINST;      
 
 alter table ACT_RU_IDENTITYLINK
     drop CONSTRAINT ACT_FK_ATHRZ_PROCEDEF;
@@ -79,9 +76,6 @@ alter table ACT_RU_JOB
 alter table ACT_RU_JOB 
     drop CONSTRAINT ACT_FK_JOB_PROC_DEF;
 
-alter table ACT_RU_JOB 
-    drop CONSTRAINT ACT_FK_JOB_EXCEPTION;
-    
 alter table ACT_RU_TIMER_JOB 
     drop CONSTRAINT ACT_FK_TJOB_EXECUTION;
     
@@ -91,9 +85,6 @@ alter table ACT_RU_TIMER_JOB
 alter table ACT_RU_TIMER_JOB 
     drop CONSTRAINT ACT_FK_TJOB_PROC_DEF;
     
-alter table ACT_RU_TIMER_JOB 
-    drop CONSTRAINT ACT_FK_TJOB_EXCEPTION;
-    
 alter table ACT_RU_SUSPENDED_JOB 
     drop CONSTRAINT ACT_FK_SJOB_EXECUTION;
     
@@ -103,9 +94,6 @@ alter table ACT_RU_SUSPENDED_JOB
 alter table ACT_RU_SUSPENDED_JOB 
     drop CONSTRAINT ACT_FK_SJOB_PROC_DEF;
     
-alter table ACT_RU_SUSPENDED_JOB 
-    drop CONSTRAINT ACT_FK_SJOB_EXCEPTION;
-    
 alter table ACT_RU_DEADLETTER_JOB 
     drop CONSTRAINT ACT_FK_DJOB_EXECUTION;
     
@@ -115,9 +103,6 @@ alter table ACT_RU_DEADLETTER_JOB
 alter table ACT_RU_DEADLETTER_JOB 
     drop CONSTRAINT ACT_FK_DJOB_PROC_DEF;
     
-alter table ACT_RU_DEADLETTER_JOB 
-    drop CONSTRAINT ACT_FK_DJOB_EXCEPTION;
-    
 alter table ACT_RU_EVENT_SUBSCR
     drop CONSTRAINT ACT_FK_EVENT_EXEC;
 
@@ -150,13 +135,7 @@ drop index ACT_IDX_PROCDEF_INFO_PROC;
 drop table ACT_RE_DEPLOYMENT;
 drop table ACT_RE_MODEL;
 drop table ACT_RE_PROCDEF;
-drop table ACT_RU_IDENTITYLINK;
 drop table ACT_RU_EXECUTION;
-drop table ACT_RU_JOB;
-drop table ACT_RU_TIMER_JOB;
-drop table ACT_RU_SUSPENDED_JOB;
-drop table ACT_RU_DEADLETTER_JOB;
-drop table ACT_RU_HISTORY_JOB;
 drop table ACT_RU_EVENT_SUBSCR;
 
 drop sequence act_evt_log_seq;

modules/flowable-engine/src/main/resources/org/flowable/db/drop/flowable.oracle.drop.history.sql

@@ -11,7 +11,6 @@ drop index ACT_IDX_HI_PROCVAR_PROC_INST;
 drop index ACT_IDX_HI_PROCVAR_TASK_ID;
 drop index ACT_IDX_HI_PROCVAR_EXE;
 drop index ACT_IDX_HI_ACT_INST_PROCINST;
-drop index ACT_IDX_HI_IDENT_LNK_USER;
 drop index ACT_IDX_HI_IDENT_LNK_TASK;
 drop index ACT_IDX_HI_IDENT_LNK_PROCINST;
 drop index ACT_IDX_HI_TASK_INST_PROCINST;
@@ -21,4 +20,3 @@ drop table ACT_HI_ACTINST;
 drop table ACT_HI_DETAIL;
 drop table ACT_HI_COMMENT;
 drop table ACT_HI_ATTACHMENT;
-drop table ACT_HI_IDENTITYLINK;

modules/flowable-engine/src/main/resources/org/flowable/db/drop/flowable.postgres.drop.engine.sql

@@ -2,12 +2,6 @@ drop table if exists ACT_RE_DEPLOYMENT cascade;
 drop table if exists ACT_RE_MODEL cascade;
 drop table if exists ACT_RE_PROCDEF cascade;
 drop table if exists ACT_RU_EXECUTION cascade;
-drop table if exists ACT_RU_JOB cascade;
-drop table if exists ACT_RU_TIMER_JOB cascade;
-drop table if exists ACT_RU_SUSPENDED_JOB cascade;
-drop table if exists ACT_RU_DEADLETTER_JOB cascade;
-drop table if exists ACT_RU_HISTORY_JOB cascade;
-drop table if exists ACT_RU_IDENTITYLINK cascade;
 drop table if exists ACT_RU_EVENT_SUBSCR cascade;
 drop table if exists ACT_EVT_LOG cascade;
 drop table if exists ACT_PROCDEF_INFO cascade;
\ No newline at end of file

modules/flowable-engine/src/main/resources/org/flowable/db/drop/flowable.postgres.drop.history.sql

@@ -3,4 +3,3 @@ drop table if exists ACT_HI_ACTINST cascade;
 drop table if exists ACT_HI_DETAIL cascade;
 drop table if exists ACT_HI_COMMENT cascade;
 drop table if exists ACT_HI_ATTACHMENT cascade;
-drop table if exists ACT_HI_IDENTITYLINK cascade;

modules/flowable-engine/src/main/resources/org/flowable/db/mapping/mappings.xml

@@ -49,6 +49,7 @@
     <mapper resource="org/flowable/db/mapping/entity/Resource.xml" />
     <mapper resource="org/flowable/job/db/mapping/entity/SuspendedJob.xml" />
     <mapper resource="org/flowable/db/mapping/entity/TableData.xml" />
+    <mapper resource="org/flowable/task/db/mapping/common.xml" />
     <mapper resource="org/flowable/task/db/mapping/entity/Task.xml" />
     <mapper resource="org/flowable/job/db/mapping/entity/TimerJob.xml" />
     <mapper resource="org/flowable/variable/db/mapping/entity/VariableInstance.xml" />

modules/flowable-engine/src/test/java/org/flowable/examples/mgmt/ManagementServiceTest.java

@@ -50,7 +50,7 @@ public class ManagementServiceTest extends PluggableFlowableTestCase {
             
         });
 
-        assertEquals(new Long(8), tableCount.get(tablePrefix + "ACT_GE_PROPERTY"));
+        assertEquals(new Long(10), tableCount.get(tablePrefix + "ACT_GE_PROPERTY"));
         assertEquals(new Long(0), tableCount.get(tablePrefix + "ACT_GE_BYTEARRAY"));
         assertEquals(new Long(0), tableCount.get(tablePrefix + "ACT_RE_DEPLOYMENT"));
         assertEquals(new Long(0), tableCount.get(tablePrefix + "ACT_RU_EXECUTION"));

modules/flowable-identitylink-service-api/pom.xml

+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+
+	<modelVersion>4.0.0</modelVersion>
+
+	<name>Flowable - Identity Link Service API</name>
+	<artifactId>flowable-identitylink-service-api</artifactId>
+
+	<parent>
+		<groupId>org.flowable</groupId>
+		<artifactId>flowable-root</artifactId>
+		<relativePath>../..</relativePath>
+		<version>6.2.0-SNAPSHOT</version>
+	</parent>
+
+	<dependencies>
+		<dependency>
+			<groupId>org.flowable</groupId>
+			<artifactId>flowable-engine-common-api</artifactId>
+		</dependency>
+	</dependencies>
+
+	<properties>
+		<flowable.artifact>
+			org.flowable.identitylink
+		</flowable.artifact>
+		<flowable.osgi.export.additional>
+			org.flowable.identitylink.db.mapping.entity
+		</flowable.osgi.export.additional>
+	</properties>
+
+	<build>
+		<plugins>
+			<plugin>
+				<artifactId>maven-surefire-plugin</artifactId>
+				<configuration>
+					<runOrder>alphabetical</runOrder>
+				</configuration>
+			</plugin>
+			<plugin>
+				<artifactId>maven-jar-plugin</artifactId>
+				<configuration>
+					<archive>
+						<manifestFile>${project.build.outputDirectory}/META-INF/MANIFEST.MF</manifestFile>
+					</archive>
+				</configuration>
+			</plugin>
+			<plugin>
+				<groupId>org.apache.felix</groupId>
+				<artifactId>maven-bundle-plugin</artifactId>
+				<executions>
+					<execution>
+						<phase>generate-sources</phase>
+						<goals>
+							<goal>cleanVersions</goal>
+						</goals>
+					</execution>
+					<execution>
+						<id>bundle-manifest</id>
+						<phase>process-classes</phase>
+						<goals>
+							<goal>manifest</goal>
+						</goals>
+					</execution>
+				</executions>
+			</plugin>
+		</plugins>
+		<pluginManagement>
+			<plugins>
+				<!--This plugin's configuration is used to store Eclipse m2e settings 
+					only. It has no influence on the Maven build itself. -->
+				<plugin>
+					<groupId>org.eclipse.m2e</groupId>
+					<artifactId>lifecycle-mapping</artifactId>
+					<version>1.0.0</version>
+					<configuration>
+						<lifecycleMappingMetadata>
+							<pluginExecutions>
+								<pluginExecution>
+									<pluginExecutionFilter>
+										<groupId>org.apache.felix</groupId>
+										<artifactId>
+											maven-bundle-plugin
+										</artifactId>
+										<versionRange>
+											[2.1.0,)
+										</versionRange>
+										<goals>
+											<goal>cleanVersions</goal>
+											<goal>manifest</goal>
+										</goals>
+									</pluginExecutionFilter>
+									<action>
+										<ignore></ignore>
+									</action>
+								</pluginExecution>
+							</pluginExecutions>
+						</lifecycleMappingMetadata>
+					</configuration>
+				</plugin>
+			</plugins>
+		</pluginManagement>
+	</build>
+
+</project>

modules/flowable-identitylink-service/pom.xml

@@ -14,6 +14,10 @@
 	</parent>
 
 	<dependencies>
+        <dependency>
+            <groupId>org.flowable</groupId>
+            <artifactId>flowable-identitylink-service-api</artifactId>
+        </dependency>
 		<dependency>
 			<groupId>org.flowable</groupId>
 			<artifactId>flowable-engine-common-api</artifactId>

modules/flowable-identitylink-service/src/main/java/org/flowable/identitylink/service/impl/db/IdentityLinkDbSchemaManager.java

+/* Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.flowable.identitylink.service.impl.db;
+
+import org.flowable.engine.common.impl.db.ServiceSqlScriptBasedDbSchemaManager;
+
+/**
+ * @author Joram Barrez
+ */
+public class IdentityLinkDbSchemaManager extends ServiceSqlScriptBasedDbSchemaManager {
+    
+    private static final String TABLE = "ACT_RU_IDENTITYLINK";
+    private static final String VERSION_PROPERTY = "identitylink.schema.version";
+    private static final String SCHEMA_COMPONENT = "identitylink";
+    private static final String SCHEMA_COMPONENT_HISTORY = "identitylink.history";
+    
+    public IdentityLinkDbSchemaManager() {
+        super(TABLE, SCHEMA_COMPONENT, SCHEMA_COMPONENT_HISTORY, VERSION_PROPERTY);
+    }
+
+    @Override
+    protected String getResourcesRootDirectory() {
+        return "org/flowable/identitylink/db/";
+    }
+
+}

modules/flowable-identitylink-service/src/main/resources/org/flowable/identitylink/db/create/flowable.db2.create.identitylink.history.sql

+create table ACT_HI_IDENTITYLINK (
+    ID_ varchar(64) not null,
+    GROUP_ID_ varchar(255),
+    TYPE_ varchar(255),
+    USER_ID_ varchar(255),
+    TASK_ID_ varchar(64),
+    CREATE_TIME_ timestamp,
+    PROC_INST_ID_ varchar(64),
+    primary key (ID_)
+);
+
+create index ACT_IDX_HI_IDENT_LNK_USER on ACT_HI_IDENTITYLINK(USER_ID_);
\ No newline at end of file

modules/flowable-identitylink-service/src/main/resources/org/flowable/identitylink/db/create/flowable.db2.create.identitylink.sql

+create table ACT_RU_IDENTITYLINK (
+    ID_ varchar(64) not null,
+    REV_ integer,
+    GROUP_ID_ varchar(255),
+    TYPE_ varchar(255),
+    USER_ID_ varchar(255),
+    TASK_ID_ varchar(64),
+    PROC_INST_ID_ varchar(64),
+    PROC_DEF_ID_ varchar(64),
+    primary key (ID_)
+);
+
+create index ACT_IDX_IDENT_LNK_USER on ACT_RU_IDENTITYLINK(USER_ID_);
+create index ACT_IDX_IDENT_LNK_GROUP on ACT_RU_IDENTITYLINK(GROUP_ID_);
+
+insert into ACT_GE_PROPERTY values ('identitylink.schema.version', '6.2.0.0', 1);
\ No newline at end of file

modules/flowable-identitylink-service/src/main/resources/org/flowable/identitylink/db/create/flowable.h2.create.identitylink.history.sql

+create table ACT_HI_IDENTITYLINK (
+    ID_ varchar(64),
+    GROUP_ID_ varchar(255),
+    TYPE_ varchar(255),
+    USER_ID_ varchar(255),
+    TASK_ID_ varchar(64),
+    CREATE_TIME_ timestamp,
+    PROC_INST_ID_ varchar(64) null,
+    primary key (ID_)
+);
+
+create index ACT_IDX_HI_IDENT_LNK_USER on ACT_HI_IDENTITYLINK(USER_ID_);
\ No newline at end of file

modules/flowable-identitylink-service/src/main/resources/org/flowable/identitylink/db/create/flowable.h2.create.identitylink.sql

+create table ACT_RU_IDENTITYLINK (
+    ID_ varchar(64),
+    REV_ integer,
+    GROUP_ID_ varchar(255),
+    TYPE_ varchar(255),
+    USER_ID_ varchar(255),
+    TASK_ID_ varchar(64),
+    PROC_INST_ID_ varchar(64) null,
+    PROC_DEF_ID_ varchar(64),
+    primary key (ID_)
+);
+
+create index ACT_IDX_IDENT_LNK_USER on ACT_RU_IDENTITYLINK(USER_ID_);
+create index ACT_IDX_IDENT_LNK_GROUP on ACT_RU_IDENTITYLINK(GROUP_ID_);
+
+insert into ACT_GE_PROPERTY values ('identitylink.schema.version', '6.2.0.0', 1);
\ No newline at end of file

modules/flowable-identitylink-service/src/main/resources/org/flowable/identitylink/db/create/flowable.hsql.create.identitylink.history.sql

+create table ACT_HI_IDENTITYLINK (
+  ID_ varchar(64),
+  GROUP_ID_ varchar(255),
+  TYPE_ varchar(255),
+  USER_ID_ varchar(255),
+  TASK_ID_ varchar(64),
+  CREATE_TIME_ timestamp,
+  PROC_INST_ID_ varchar(64) null,
+  primary key (ID_)
+);
+
+
+create index ACT_IDX_HI_IDENT_LNK_USER on ACT_HI_IDENTITYLINK(USER_ID_);
\ No newline at end of file

modules/flowable-identitylink-service/src/main/resources/org/flowable/identitylink/db/create/flowable.hsql.create.identitylink.sql

+create table ACT_RU_IDENTITYLINK (
+    ID_ varchar(64),
+    REV_ integer,
+    GROUP_ID_ varchar(255),
+    TYPE_ varchar(255),
+    USER_ID_ varchar(255),
+    TASK_ID_ varchar(64),
+    PROC_INST_ID_ varchar(64) null,
+    PROC_DEF_ID_ varchar(64),
+    primary key (ID_)
+);
+
+create index ACT_IDX_IDENT_LNK_USER on ACT_RU_IDENTITYLINK(USER_ID_);
+create index ACT_IDX_IDENT_LNK_GROUP on ACT_RU_IDENTITYLINK(GROUP_ID_);
+
+insert into ACT_GE_PROPERTY values ('identitylink.schema.version', '6.2.0.0', 1);
\ No newline at end of file

modules/flowable-identitylink-service/src/main/resources/org/flowable/identitylink/db/create/flowable.mssql.create.identitylink.history.sql

+create table ACT_HI_IDENTITYLINK (
+    ID_ nvarchar(64),
+    GROUP_ID_ nvarchar(255),
+    TYPE_ nvarchar(255),
+    USER_ID_ nvarchar(255),
+    TASK_ID_ nvarchar(64),
+    CREATE_TIME_ datetime,
+    PROC_INST_ID_ nvarchar(64),
+    primary key (ID_)
+);
+
+create index ACT_IDX_HI_IDENT_LNK_USER on ACT_HI_IDENTITYLINK(USER_ID_);
\ No newline at end of file

modules/flowable-identitylink-service/src/main/resources/org/flowable/identitylink/db/create/flowable.mssql.create.identitylink.sql

+create table ACT_RU_IDENTITYLINK (
+    ID_ nvarchar(64),
+    REV_ int,
+    GROUP_ID_ nvarchar(255),
+    TYPE_ nvarchar(255),
+    USER_ID_ nvarchar(255),
+    TASK_ID_ nvarchar(64),
+    PROC_INST_ID_ nvarchar(64),
+    PROC_DEF_ID_ nvarchar(64),
+    primary key (ID_)
+);
+
+create index ACT_IDX_IDENT_LNK_USER on ACT_RU_IDENTITYLINK(USER_ID_);
+create index ACT_IDX_IDENT_LNK_GROUP on ACT_RU_IDENTITYLINK(GROUP_ID_);
+
+insert into ACT_GE_PROPERTY values ('identitylink.schema.version', '6.2.0.0', 1);
\ No newline at end of file

modules/flowable-identitylink-service/src/main/resources/org/flowable/identitylink/db/create/flowable.mysql.create.identitylink.history.sql

+create table ACT_HI_IDENTITYLINK (
+    ID_ varchar(64),
+    GROUP_ID_ varchar(255),
+    TYPE_ varchar(255),
+    USER_ID_ varchar(255),
+    TASK_ID_ varchar(64),
+    CREATE_TIME_ datetime(3),
+    PROC_INST_ID_ varchar(64),
+    primary key (ID_)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
+
+create index ACT_IDX_HI_IDENT_LNK_USER on ACT_HI_IDENTITYLINK(USER_ID_);
\ No newline at end of file

modules/flowable-identitylink-service/src/main/resources/org/flowable/identitylink/db/create/flowable.mysql.create.identitylink.sql

+create table ACT_RU_IDENTITYLINK (
+    ID_ varchar(64),
+    REV_ integer,
+    GROUP_ID_ varchar(255),
+    TYPE_ varchar(255),
+    USER_ID_ varchar(255),
+    TASK_ID_ varchar(64),
+    PROC_INST_ID_ varchar(64),
+    PROC_DEF_ID_ varchar(64),    
+    primary key (ID_)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
+
+create index ACT_IDX_IDENT_LNK_USER on ACT_RU_IDENTITYLINK(USER_ID_);
+create index ACT_IDX_IDENT_LNK_GROUP on ACT_RU_IDENTITYLINK(GROUP_ID_);
+
+insert into ACT_GE_PROPERTY values ('identitylink.schema.version', '6.2.0.0', 1);
\ No newline at end of file

modules/flowable-identitylink-service/src/main/resources/org/flowable/identitylink/db/create/flowable.mysql55.create.identitylink.history.sql

+create table ACT_HI_IDENTITYLINK (
+    ID_ varchar(64),
+    GROUP_ID_ varchar(255),
+    TYPE_ varchar(255),
+    USER_ID_ varchar(255),
+    TASK_ID_ varchar(64),
+    CREATE_TIME_ datetime,
+    PROC_INST_ID_ varchar(64),
+    primary key (ID_)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
+
+create index ACT_IDX_HI_IDENT_LNK_USER on ACT_HI_IDENTITYLINK(USER_ID_);
\ No newline at end of file

modules/flowable-identitylink-service/src/main/resources/org/flowable/identitylink/db/create/flowable.mysql55.create.identitylink.sql

+create table ACT_RU_IDENTITYLINK (
+    ID_ varchar(64),
+    REV_ integer,
+    GROUP_ID_ varchar(255),
+    TYPE_ varchar(255),
+    USER_ID_ varchar(255),
+    TASK_ID_ varchar(64),
+    PROC_INST_ID_ varchar(64),
+    PROC_DEF_ID_ varchar(64),    
+    primary key (ID_)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
+
+create index ACT_IDX_IDENT_LNK_USER on ACT_RU_IDENTITYLINK(USER_ID_);
+create index ACT_IDX_IDENT_LNK_GROUP on ACT_RU_IDENTITYLINK(GROUP_ID_);
+
+insert into ACT_GE_PROPERTY values ('identitylink.schema.version', '6.2.0.0', 1);
\ No newline at end of file

modules/flowable-identitylink-service/src/main/resources/org/flowable/identitylink/db/create/flowable.oracle.create.identitylink.history.sql

+create table ACT_HI_IDENTITYLINK (
+    ID_ NVARCHAR2(64),
+    GROUP_ID_ NVARCHAR2(255),
+    TYPE_ NVARCHAR2(255),
+    USER_ID_ NVARCHAR2(255),
+    TASK_ID_ NVARCHAR2(64),
+    CREATE_TIME_ TIMESTAMP(6),
+    PROC_INST_ID_ NVARCHAR2(64),
+    primary key (ID_)
+);
+
+create index ACT_IDX_HI_IDENT_LNK_USER on ACT_HI_IDENTITYLINK(USER_ID_);
\ No newline at end of file