JBPM-4646 - Case management - simplified use for case role assignment…

…s, assign correlation key for each process instance, store case data to audit log upon case instance start (#648)

jbpm-case-mgmt/jbpm-case-mgmt-api/src/main/java/org/jbpm/casemgmt/api/CaseService.java

@@ -27,7 +27,9 @@
 import org.jbpm.casemgmt.api.model.instance.CommentInstance;
 import org.jbpm.casemgmt.api.model.instance.CommentSortBy;
 import org.jbpm.services.api.ProcessInstanceNotFoundException;
+import org.kie.api.task.model.Group;
 import org.kie.api.task.model.OrganizationalEntity;
+import org.kie.api.task.model.User;
 import org.kie.internal.query.QueryContext;
 
 /**
@@ -401,4 +403,18 @@ public interface CaseService {
      * @return
      */
     TaskSpecification newTaskSpec(String nodeType, String nodeName, Map<String, Object> parameters);
+
+    /**
+     * Creates new user with given id;
+     * @param userId user id to be used when creating User instance
+     * @return new instance for userId
+     */
+    User newUser(String userId);
+
+    /**
+     * Creates new group with given id;
+     * @param groupId group id to be used when creating Group instance
+     * @return new instance for groupId
+     */
+    Group newGroup(String groupId);
 }

jbpm-case-mgmt/jbpm-case-mgmt-impl/src/main/java/org/jbpm/casemgmt/impl/CaseServiceImpl.java

@@ -66,12 +66,16 @@
 import org.kie.api.command.KieCommands;
 import org.kie.api.runtime.manager.RuntimeManager;
 import org.kie.api.runtime.process.ProcessInstance;
+import org.kie.api.task.model.Group;
 import org.kie.api.task.model.OrganizationalEntity;
+import org.kie.api.task.model.User;
 import org.kie.internal.KieInternalServices;
 import org.kie.internal.process.CorrelationKeyFactory;
 import org.kie.internal.query.QueryContext;
 import org.kie.internal.runtime.manager.context.CaseContext;
 import org.kie.internal.runtime.manager.context.ProcessInstanceIdContext;
+import org.kie.internal.task.api.TaskModelFactory;
+import org.kie.internal.task.api.TaskModelProvider;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -82,6 +86,7 @@ public class CaseServiceImpl implements CaseService {
 
     private CorrelationKeyFactory correlationKeyFactory = KieInternalServices.Factory.get().newCorrelationKeyFactory();
     private KieCommands commandsFactory = KieServices.Factory.get().getCommands();
+    private TaskModelFactory factory = TaskModelProvider.getFactory();
 
     private CaseIdGenerator caseIdGenerator;
 
@@ -144,7 +149,7 @@ public String startCase(String deploymentId, String caseDefinitionId, CaseFileIn
 
     @Override
     public CaseFileInstance getCaseFileInstance(String caseId) throws CaseNotFoundException {
-        ProcessInstanceDesc pi = verifyCaseIdExists(caseId);
+        ProcessInstanceDesc pi = verifyCaseIdExisted(caseId);
 
         return internalGetCaseFileInstance(caseId, pi);
     }
@@ -194,7 +199,7 @@ public void cancelCase(String caseId) throws CaseNotFoundException {
     @Override
     public void destroyCase(String caseId) throws CaseNotFoundException {
         logger.debug("About to destroy permanently case {}", caseId);  
-        ProcessInstanceDesc pi = verifyCaseIdExists(caseId);        
+        ProcessInstanceDesc pi = verifyCaseIdExisted(caseId);        
         processService.execute(pi.getDeploymentId(), ProcessInstanceIdContext.get(pi.getId()), new CancelCaseCommand(caseId, processService, runtimeDataService, true));
     }
 
@@ -461,6 +466,16 @@ public TaskSpecification newHumanTaskSpec(String taskName, String description, S
     public TaskSpecification newTaskSpec(String nodeType, String nodeName, Map<String, Object> parameters) {
         return new WorkItemTaskSpecification(nodeType, nodeName, parameters);
     }
+
+    @Override
+    public User newUser(String userId) {
+        return factory.newUser(userId);
+    }
+
+    @Override
+    public Group newGroup(String groupId) {
+        return factory.newGroup(groupId);
+    }
 
     /*
      * internal methods
@@ -470,7 +485,9 @@ public TaskSpecification newTaskSpec(String nodeType, String nodeName, Map<Strin
     protected CaseFileInstance internalGetCaseFileInstance(String caseId, ProcessInstanceDesc pi) {
         logger.debug("Retrieving case file from working memory for case " + caseId);
         Collection<CaseFileInstance> caseFiles = (Collection<CaseFileInstance>) processService.execute(pi.getDeploymentId(), CaseContext.get(caseId), commandsFactory.newGetObjects(new ClassObjectFilter(CaseFileInstance.class)));
-        if (caseFiles.size() == 1) {
+        if (caseFiles.size() == 0) {
+            throw new CaseNotFoundException("Case with id " + caseId + " was not found");
+        } else if (caseFiles.size() == 1) {
             CaseFileInstance caseFile =  caseFiles.iterator().next();
             logger.debug("Single case file {} found in working memory", caseFile);
             return caseFile;
@@ -496,6 +513,15 @@ protected ProcessInstanceDesc verifyCaseIdExists(String caseId) throws CaseNotFo
 
         return pi;
     }
+
+    protected ProcessInstanceDesc verifyCaseIdExisted(String caseId) throws CaseNotFoundException {
+        Collection<ProcessInstanceDesc> instances = runtimeDataService.getProcessInstancesByCorrelationKey(correlationKeyFactory.newCorrelationKey(caseId), new org.kie.api.runtime.query.QueryContext(0, 1));
+        if (instances.isEmpty()) {
+            throw new CaseNotFoundException("Case with id " + caseId + " was not found"); 
+        }
+
+        return instances.iterator().next();
+    }
 
 
     protected CaseEventSupport getCaseEventSupport(String deploymentId) {
@@ -509,4 +535,5 @@ protected CaseEventSupport getCaseEventSupport(String deploymentId) {
         return emptyCaseEventSupport;
     }
 
+
 }

jbpm-case-mgmt/jbpm-case-mgmt-impl/src/main/java/org/jbpm/casemgmt/impl/command/StartCaseCommand.java

@@ -18,17 +18,26 @@
 
 import java.util.HashMap;
 import java.util.Map;
+import java.util.Map.Entry;
 
+import org.drools.core.command.impl.GenericCommand;
+import org.drools.core.command.impl.KnowledgeCommandContext;
+import org.drools.core.common.InternalKnowledgeRuntime;
+import org.drools.core.event.ProcessEventSupport;
 import org.jbpm.casemgmt.api.model.instance.CaseFileInstance;
 import org.jbpm.casemgmt.impl.event.CaseEventSupport;
+import org.jbpm.process.instance.InternalProcessRuntime;
+import org.jbpm.process.instance.ProcessInstance;
 import org.jbpm.services.api.ProcessService;
 import org.kie.api.KieServices;
 import org.kie.api.command.KieCommands;
 import org.kie.api.runtime.EnvironmentName;
+import org.kie.api.runtime.KieSession;
 import org.kie.internal.KieInternalServices;
 import org.kie.internal.command.Context;
 import org.kie.internal.process.CorrelationKey;
 import org.kie.internal.process.CorrelationKeyFactory;
+import org.kie.internal.runtime.KnowledgeRuntime;
 import org.kie.internal.runtime.manager.context.CaseContext;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -72,8 +81,35 @@ public Void execute(Context context) {
         Map<String, Object> params = new HashMap<>();
         // set case id to allow it to use CaseContext when creating runtime engine
         params.put(EnvironmentName.CASE_ID, caseId);
-        long processInstanceId = processService.startProcess(deploymentId, caseDefinitionId, correlationKey, params);
+        final long processInstanceId = processService.startProcess(deploymentId, caseDefinitionId, correlationKey, params);
         logger.debug("Case {} successfully started (process instance id {})", caseId, processInstanceId);
+
+        final Map<String, Object> caseData = caseFile.getData();
+        if (caseData != null && !caseData.isEmpty()) {
+            processService.execute(deploymentId, CaseContext.get(caseId), new GenericCommand<Void>() {
+
+                private static final long serialVersionUID = -7093369406457484236L;
+
+                @Override
+                public Void execute(Context context) {
+                    KieSession ksession = ((KnowledgeCommandContext) context).getKieSession();
+                    ProcessInstance pi = (ProcessInstance) ksession.getProcessInstance(processInstanceId);
+                    if (pi != null) {
+                        ProcessEventSupport processEventSupport = ((InternalProcessRuntime) ((InternalKnowledgeRuntime) ksession).getProcessRuntime()).getProcessEventSupport();
+                        for (Entry<String, Object> entry : caseData.entrySet()) {  
+                            String name = "caseFile_" + entry.getKey();
+                            processEventSupport.fireAfterVariableChanged(
+                                name,
+                                name,
+                                null, entry.getValue(), 
+                                pi,
+                                (KnowledgeRuntime) ksession);
+                        }
+                    }
+                    return null;
+                }
+            });
+        }
         caseEventSupport.fireAfterCaseStarted(caseId, deploymentId, caseDefinitionId, caseFile, processInstanceId);
         return null;
     }

jbpm-case-mgmt/jbpm-case-mgmt-impl/src/main/java/org/jbpm/casemgmt/impl/model/instance/CaseFileInstanceImpl.java

@@ -34,6 +34,8 @@
 import org.jbpm.casemgmt.api.model.instance.CommentInstance;
 import org.kie.api.runtime.process.CaseAssignment;
 import org.kie.api.task.model.OrganizationalEntity;
+import org.kie.internal.task.api.TaskModelFactory;
+import org.kie.internal.task.api.TaskModelProvider;
 
 /*
  * Implementation note: since the CaseFileInstanceImpl will be marshalled/unmarshalled by 
@@ -55,6 +57,8 @@ public class CaseFileInstanceImpl implements CaseFileInstance, CaseAssignment, S
     private Map<String, CaseRoleInstance> roles = new HashMap<>();    
     private List<CommentInstance> comments = new ArrayList<>();
 
+    private TaskModelFactory factory = TaskModelProvider.getFactory();
+
     public CaseFileInstanceImpl() {
 
     }
@@ -169,6 +173,19 @@ public void remove(String roleName, OrganizationalEntity entity) {
         }      
     }
 
+
+    @Override
+    public void assignUser(String roleName, String userId) {
+       assign(roleName, factory.newUser(userId));
+
+    }
+
+    @Override
+    public void assignGroup(String roleName, String groupId) {
+        assign(roleName, factory.newGroup(groupId));
+
+    }
+
     @Override
     public Collection<OrganizationalEntity> getAssignments(String roleName) {
         String[] roleNames = roleName.split(separator);