Sandra Renaud [https://community.jboss.org/people/joploya] created the discussion
<!-- jbpm -->
    <dependency>
              <groupId>org.drools</groupId>
                        <artifactId>drools-compiler</artifactId>
                        <version>5.4.0.Final</version>
                   </dependency>
                    <dependency>
                             <groupId>org.jbpm</groupId>
                             <artifactId>jbpm-bpmn2</artifactId>
                             <version>5.4.0.Final</version>
                             <exclusions>
                   <exclusion>
                         <groupId>dom4j</groupId>
                         <artifactId>dom4j</artifactId>
                   </exclusion>
             </exclusions>
                   </dependency>
                   <dependency>
                             <groupId>org.jbpm</groupId>
                             <artifactId>jbpm-flow</artifactId>
                             <version>5.4.0.Final</version>
                             <exclusions>
                   <exclusion>
                         <groupId>dom4j</groupId>
                         <artifactId>dom4j</artifactId>
                   </exclusion>
             </exclusions>
                   </dependency>
                   <dependency>
                             <groupId>org.jbpm</groupId>
                             <artifactId>jbpm-human-task-core</artifactId>
                             <version>5.4.0.Final</version>
                             <exclusions>
                   <exclusion>
                         <groupId>dom4j</groupId>
                         <artifactId>dom4j</artifactId>
                   </exclusion>
             </exclusions>
                   </dependency>
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import javax.annotation.PostConstruct;
import javax.ejb.LocalBean;
import javax.ejb.Stateless;
import javax.enterprise.context.ApplicationScoped;
import javax.enterprise.inject.Produces;
import javax.persistence.EntityManagerFactory;
import javax.persistence.PersistenceUnit;
import org.drools.KnowledgeBase;
import org.drools.SystemEventListenerFactory;
import org.drools.builder.KnowledgeBuilder;
import org.drools.builder.KnowledgeBuilderFactory;
import org.drools.builder.ResourceType;
import org.drools.io.Resource;
import org.drools.io.ResourceFactory;
import org.drools.logger.KnowledgeRuntimeLogger;
import org.drools.logger.KnowledgeRuntimeLoggerFactory;
import org.drools.runtime.EnvironmentName;
import org.drools.runtime.StatefulKnowledgeSession;
import org.jbpm.process.workitem.email.EmailWorkItemHandler;
import org.jbpm.task.Group;
import org.jbpm.task.User;
import org.jbpm.task.identity.UserGroupCallbackManager;
import org.jbpm.task.service.TaskService;
import org.jbpm.task.service.TaskServiceSession;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
//import static org.junit.Assert.*;
@Stateless
@LocalBean
public class KnowledgeSessionProducer implements Serializable{
         private static final long serialVersionUID = -4494168896880405667L;
         private Logger log = LoggerFactory.getLogger(KnowledgeSessionProducer.class);
         private KnowledgeRuntimeLogger logger;
   private EntityManagerFactory emf;
             log.debug("init of KnowledgeSessionProducer ...");
             TaskService taskService = new TaskService(emf, SystemEventListenerFactory.getSystemEventListener());
       TaskServiceSession taskSession = taskService.createSession();
       // Add users
                   Map vars = new HashMap();
       InputStream usersin = KnowledgeSessionProducer.class.getResourceAsStream( "/LoadUsers.mvel" );
       if(usersin != null) {
                 Reader reader = new InputStreamReader( usersin ); Â
                 Map<String, User> users = ( Map<String, User> ) TaskService.eval( reader, vars ); Â
                 log.debug("Users to load in db : ...");
                 for ( User user : users.values() ) {
                           taskSession.addUser( user );
                           log.debug(" - "+user);
                 }         Â
       }
       InputStream groupsin = KnowledgeSessionProducer.class.getResourceAsStream( "/LoadGroups.mvel" );
       if(groupsin != null) {
                 Reader reader = new InputStreamReader( groupsin ); Â
                 Map<String, Group> groups = ( Map<String, Group> ) TaskService.eval( reader, vars );   Â
                 log.debug("Groups to load in db : ...");
                 for ( Group group : groups.values() ) {
                           taskSession.addGroup( group );
                           log.debug(" - "+group);
                 }
       }
       // try to get the usergroup callback properties
       InputStream usergroupsin = KnowledgeSessionProducer.class.getResourceAsStream( "/jbpm.usergroup.callback.properties" );
       if(usergroupsin != null) {
                 Properties callbackproperties = new Properties();
                 try {
                    // Properties.load(Reader) is a JDK 6 method
                           callbackproperties.load(usergroupsin);
                           UserGroupCallbackManager.getInstance().setCallbackFromProperties(callbackproperties);
                           System.out.println("Task service registered usergroup callback ...");
                 } catch (Exception e) {
                           System.out.println("Task service unable to register usergroup callback ...");
                 }
       }
       taskSession.dispose();
       System.out.println("Task service started correctly!");
       System.out.println("Task service running ...");
   }
         public StatefulKnowledgeSession produceKnowledgeSession(){
                   log.debug("produce the KnowledgeSession ...");
                   //Create the knowledgeBase
                   /*This factory is used to build the knowledge base resources that are held collectively in KnowledgePackages.*/
                   KnowledgeBuilder kbuilder = KnowledgeBuilderFactory.newKnowledgeBuilder();
                   //Add all processes to the knowledgeBuilder
                   List<Resource> resources = getProcessDefinitionList();
                   for (Resource resource : resources) {
                             kbuilder.add(resource, ResourceType.BPMN2);
                   }
                   /*Create a new KnowledgeBase from the knowledge packages that have been added to this builder.
                   * An exception is thrown if there are any errors.*/
//Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â assertFalse( kbuilder.hasErrors() );
                   if ( kbuilder.hasErrors() ) {
                       log.error( kbuilder.getErrors().toString() );
                   }
                   KnowledgeBase kbase = kbuilder.newKnowledgeBase();
                   /*Create a new StatefulKnowledgeSession using the default session configuration.
                   * Don't forget to dispose() session when you are done.
                   *
                   * StatefulKnowledgeSession is the most common way to interact with the engine.
                   * A StatefulKnowledgeSession allows the application to establish an iterative conversation with the engine,
                   * where the state of the session is kept across invocations.*/
                   StatefulKnowledgeSession ksession = kbase.newStatefulKnowledgeSession();
       logger = KnowledgeRuntimeLoggerFactory.newThreadedFileLogger(ksession, "loggerFile", 1000);
       /*A work item manager is responsible for finding the right work item handler when a work item should be executed
        * and should be notified when this work item has been completed (or aborted).
        *
        * Register the given handler for all work items of the given type of work
        * This part is done in the LocalHumanTaskService*/
//Â Â Â Â Â Â Â ksession.getWorkItemManager().registerWorkItemHandler("Human Task", handler );
       ksession.getEnvironment().set(EnvironmentName.ENTITY_MANAGER_FACTORY, emf);
       /*
        * Register WorkItem Handler for Email
        */
       //EmailWorkItemHandler emailHandler = new EmailWorkItemHandler();
       //ksession.getWorkItemManager().registerWorkItemHandler("Email", emailHandler);
       return ksession;
         }
         public KnowledgeRuntimeLogger getLogger(){
                   return this.logger;
         }
         private List<Resource> getProcessDefinitionList(){
                   List<Resource> resourceList = new ArrayList<>();
                   resourceList.add(ResourceFactory.newClassPathResource("workflows/MyFlow.bpmn2"));
                   /**
                   * TODO
                   * add all other process here
                   */
                   return resourceList;
         }
}
import javax.annotation.PostConstruct;
import javax.enterprise.context.SessionScoped;
import javax.enterprise.event.Event;
import javax.faces.application.FacesMessage;
import javax.faces.context.FacesContext;
import javax.inject.Inject;
import org.drools.runtime.StatefulKnowledgeSession;
import org.jboss.seam.security.Identity;
import org.drools.runtime.process.ProcessInstance;
import org.jbpm.task.Status;
import org.jbpm.task.query.TaskSummary;
import org.jbpm.task.service.local.LocalHumanTaskService;
import org.jbpm.workflow.instance.WorkflowProcessInstance;
import com.st.ams.tools.ClaimEventListener;
import com.ste.ws.authentication.seam.api.UserLDAP;
/**
* Linked to the task management view
*
*/
         private static final long serialVersionUID = 7768657778155604411L;
         private List<Status> listStatus = new ArrayList<Status>();
         public org.jbpm.task.TaskService getTaskService(){
                   return LocalHumanTaskService.getTaskService(kSession);
         }
         private List<TaskSummary> userTaskList = new ArrayList<TaskSummary>();
         private Map<String, List<TaskSummary>> groupTaskMap = new HashMap<String, List<TaskSummary>>();
         private TaskSummary manageTask;
         private List<String> groups;
                   System.out.println("init task manager ...");
                   //Load user tasks
                   listStatus.clear();
                   listStatus.add(Status.Reserved);listStatus.add(Status.InProgress);
                   System.out.println("load task list for user : "+((UserLDAP)identity.getUser()).getUser().getLogin());
                   userTaskList = new ArrayList<TaskSummary>(getTaskService().getTasksAssignedAsPotentialOwnerByStatus(
                                                                               ((UserLDAP)identity.getUser()).getUser().getLogin(),
                                                                               listStatus,
                                                                               "en-UK"));
                   //Load groups and tasks for each group
                   groups = new ArrayList<String>();
                   for(String grp : ((UserLDAP)identity.getUser()).getUser().getGroups()){
                groups.add(grp);
                groupTaskMap.put(grp, getGroupTasks(grp));
                   }
         }
         public List<TaskSummary> getUserTaskList() {
                   if((userTaskList == null) || userTaskList.isEmpty()){
                             listStatus.clear();
                             listStatus.add(Status.Reserved);listStatus.add(Status.InProgress);
              //Trick because UserGroupCallBackImpl is not properly implemented
              //TODO correction
                             Set<TaskSummary> set = new HashSet<TaskSummary>(getTaskService().getTasksAssignedAsPotentialOwnerByStatus(
                                                                                                                                                     ((UserLDAP)identity.getUser()).getUser().getLogin(),
                                                                                                                                                     listStatus,
                                                                                                                                                     "en-UK"));
                             userTaskList = new ArrayList<TaskSummary>(set);
                   }
                   return userTaskList;
         }
         /**
         * In order to refresh the user task list
         * This function allow to clear the content of the list
         */
         public void clearUserTaskList(){
                   userTaskList.clear();
         }
         /**
         * In order to refresh the groups task list
         * This function allow to clear the content of all lists
         */
         public void clearAllGroupTaskList(){
                   List<String> keys = new ArrayList<>(groupTaskMap.keySet());
                   for(String grp : keys){
                             clearGroupTaskList(grp);
                   }
         }
         /**
         * In order to refresh the group task list
         * This function allow to clear the content of the list
         */
         public void clearGroupTaskList(String group){
                   groupTaskMap.put(group, null);
         }
         /**
         * return all group tasks available for the user
         */
         public List<TaskSummary> getAllGroupTaskList() {
                   List<TaskSummary> allGroupTask = new ArrayList<TaskSummary>();
                   Iterable<List<TaskSummary>> mapValues = groupTaskMap.values();
                   for(List<TaskSummary> entry : mapValues){
                             allGroupTask.addAll(entry);
                   }
                   return allGroupTask;
         }
         public List<String> getUserGroups(){
                   if((groups == null) || groups.isEmpty()){
                             groups = new ArrayList<String>();
                             for(String grp : ((UserLDAP)identity.getUser()).getUser().getGroups()){
groups.add(grp);
                             }
                   }
                   return groups;
         }
         /**
         * return tasks available for the group
         */
         public List<TaskSummary> getGroupTaskList(String group){
                   if((groupTaskMap.get(group) == null) || groupTaskMap.get(group).isEmpty()){
                             groupTaskMap.put(group, getGroupTasks(group));
                   }
                   return groupTaskMap.get(group);
         }
         /**
         * return tasks available for the group
         */
         public List<TaskSummary> getGroupTasks(String group){
                   listStatus.clear();
                   listStatus.add(Status.Ready);
         //Trick because UserGroupCallBackImpl is not properly implemented
         //TODO correction
         Set<TaskSummary> set = new HashSet<TaskSummary>(getTaskService().getTasksAssignedAsPotentialOwnerByStatus(group, listStatus, "en-UK"));
                   return new ArrayList<TaskSummary>(set);
         }
         public void removeGroup(String group){
                   groups.remove(group);
         }
         public void addGroup(String group){
                   if((group != null) && !group.isEmpty())
                             groups.add(group);
         }
         public void addGroupTask(String group){
                   groupTaskMap.put(group, getGroupTasks(group));
         }
         /**
         * Start a new processInstance of an existing Process
         * and set the variables of this instance
         */
         public ProcessInstance startProcess(String processId, Map<String, Object> parameters){
                   ProcessInstance p = kSession.startProcess(processId,parameters);
                   return p;
         }
         /**
         * Return the WorkflowProcessInstance associated to a Task
         * This instance allow to access the map of variables
         */
         public WorkflowProcessInstance getWorkflowProcessInstance(long processInstanceId){
                   return (WorkflowProcessInstance)kSession.getProcessInstance(processInstanceId);
         }
         /**
         * Start a new processInstance of an existing Process
         */
         public ProcessInstance startProcess(String processId){
                   return kSession.startProcess(processId);
         }
         /**
         * When a user claim a task, the task go to RESERVED state
         * Then we call start and the task goes to IN_PROGRESS state
         * and is not visible for others
         */
         public void claimTask(TaskSummary task){
                   addMessage("task "+task.getId()+" claimed");
                   setManageTask(task);
                   getTaskService().claim(task.getId(),
                                       ((UserLDAP)identity.getUser()).getUser().getLogin());
                   getTaskService().start(task.getId(), ((UserLDAP)identity.getUser()).getUser().getLogin());
                   event.fire(new ClaimEventListener());
         }
         /**
         * return a task to group task
         */
         public void revokeTask(TaskSummary task){
                   addMessage("task "+task.getId()+" revoked");
                   setManageTask(task);
                   getTaskService().release(task.getId(),
                                       ((UserLDAP)identity.getUser()).getUser().getLogin());
         }
         public void completeTask(TaskSummary task, Object results){
                   getTaskService().completeWithResults(task.getId(),
                                       ((UserLDAP)identity.getUser()).getUser().getLogin(), results);
         }
         /**
         * The current manage task
         */
         public TaskSummary getManageTask() {
                   return manageTask;
         }
         /**
         * Set the currently manage task
         * (save it during the session)
         */
         private void setManageTask(TaskSummary manageTask) {
                   this.manageTask = manageTask;
         }
         /**
         * faces message rendered
         */
         public void addMessage(String summary) {Â
       FacesMessage message = new FacesMessage(FacesMessage.SEVERITY_INFO, summary, null);Â
       FacesContext.getCurrentInstance().addMessage(null, message);Â
   }
}
You have to implement the UserGroupCallBackImpl. (See the doc for that : http://docs.jboss.org/jbpm/v5.4/userguide/ch.human-tasks.html#d0e5419 http://docs.jboss.org/jbpm/v5.4/userguide/ch.human-tasks.html#d0e5419)
You have to register your implementation of usergroupcallback by creating a file jbpm.usergroup.callback.properties in the folder resources.
[https://community.jboss.org/choose-container!input.jspa?contentType=1&containerType=14&container=2034]
