Projects >> jbpm >>3518bf8522e8f8c71bd16d17f11f48ea3d121ba9

Chunk
Conflicting content 
 * @author salaboy
 */
@ApplicationScoped
<<<<<<< HEAD:jbpm-services/droolsjbpm-knowledge-services/src/main/java/org/droolsjbpm/services/impl/SessionManagerImpl.java
public class SessionManagerImpl implements SessionManager {
=======
public class CDISessionManager implements ServicesSessionManager {
>>>>>>> e1a8bd63124a5e1723cf2861d338155dc249e7ce:jbpm-services/droolsjbpm-knowledge-services/src/main/java/org/droolsjbpm/services/impl/CDISessionManager.java

    @Inject
    private JbpmServicesPersistenceManager pm;
Solution content 
 * @author salaboy
 */
@ApplicationScoped
public class SessionManagerImpl implements ServicesSessionManager {

    @Inject
    private JbpmServicesPersistenceManager pm;
File
SessionManagerImpl.java
Developer's decision
Manual
Kind of conflict
Class signature
Chunk
Conflicting content 
    
    @Inject
    private IdentityProvider identity;
<<<<<<< HEAD
=======

    private String domainName;
    
    private ServicesSessionManager sessionManager;
>>>>>>> e1a8bd63124a5e1723cf2861d338155dc249e7ce
  
    public CDIBAMProcessEventListener() {
    }
Solution content 
    
    @Inject
    private IdentityProvider identity;

    private String domainName;
    
    private ServicesSessionManager sessionManager;
  
    public CDIBAMProcessEventListener() {
    }
File
CDIBAMProcessEventListener.java
Developer's decision
Version 2
Kind of conflict
Attribute
Chunk
Conflicting content 
        this.pm = pm;
    }

<<<<<<< HEAD
    public void setIdentity(IdentityProvider identity) {
        this.identity = identity;
=======
    public void setSessionManager(ServicesSessionManager sessionManager) {
        this.sessionManager = sessionManager;
>>>>>>> e1a8bd63124a5e1723cf2861d338155dc249e7ce
    }
Solution content 
        this.pm = pm;
    }
    public void setSessionManager(ServicesSessionManager sessionManager) {
        this.sessionManager = sessionManager;
    }
File
CDIBAMProcessEventListener.java
Developer's decision
Version 2
Kind of conflict
Attribute
Method signature
Chunk
Conflicting content 
import org.kie.runtime.process.NodeInstance;
import org.kie.runtime.process.ProcessInstance;

<<<<<<< HEAD
import javax.enterprise.context.ApplicationScoped;
import javax.inject.Inject;
import org.jbpm.shared.services.api.JbpmServicesPersistenceManager;

=======
>>>>>>> e1a8bd63124a5e1723cf2861d338155dc249e7ce
/**
 *
 * @author salaboy
Solution content 
import org.kie.runtime.process.NodeInstance;
import org.kie.runtime.process.ProcessInstance;

import javax.enterprise.context.ApplicationScoped;
import javax.inject.Inject;
import org.jbpm.shared.services.api.JbpmServicesPersistenceManager;

/**
 *
 * @author salaboy
File
CDIProcessEventListener.java
Developer's decision
Version 1
Kind of conflict
Import
Chunk
Conflicting content 
    private ServicesSessionManager sessionManager;
    private String name;

<<<<<<< HEAD:jbpm-services/droolsjbpm-knowledge-services/src/main/java/org/droolsjbpm/services/impl/helpers/KieSessionDelegate.java
    public KieSessionDelegate(String name, KieSession ksession, SessionManager sessionManager) {
=======
    public StatefulKnowledgeSessionDelegate(String name, KieSession ksession, ServicesSessionManager sessionManager) {
>>>>>>> e1a8bd63124a5e1723cf2861d338155dc249e7ce:jbpm-services/droolsjbpm-knowledge-services/src/main/java/org/droolsjbpm/services/impl/helpers/StatefulKnowledgeSessionDelegate.java
        this.name = name;
        this.ksession = ksession;
        this.sessionManager = sessionManager;
Solution content 
    private ServicesSessionManager sessionManager;
    private String name;

    public KieSessionDelegate(String name, KieSession ksession, ServicesSessionManager sessionManager) {
        this.name = name;
        this.ksession = ksession;
        this.sessionManager = sessionManager;
File
KieSessionDelegate.java
Developer's decision
Manual
Kind of conflict
Method signature
Chunk
Conflicting content 
    @Inject
    protected FileService fs;
    @Inject
<<<<<<< HEAD
    protected SessionManager sessionManager;
=======
    private ServicesSessionManager sessionManager;
>>>>>>> e1a8bd63124a5e1723cf2861d338155dc249e7ce
Solution content 
    @Inject
    protected FileService fs;
    @Inject
    protected ServicesSessionManager sessionManager;
File
SupportProcessBaseTest.java
Developer's decision
Manual
Kind of conflict
Attribute
Chunk
Conflicting content 
    private void scheduleDeadlinesForTask(final Task task) {
        final long now = System.currentTimeMillis();
<<<<<<< HEAD
        if( task.getDeadlines() != null ){
            final List startDeadlines = task.getDeadlines().getStartDeadlines();

            if (startDeadlines != null) {
                scheduleDeadlines(startDeadlines, now, task.getId());
            }

            final List endDeadlines = task.getDeadlines().getEndDeadlines();

            if (endDeadlines != null) {
                scheduleDeadlines(endDeadlines, now, task.getId());
=======
        Deadlines deadlines = task.getDeadlines();
        
        if (deadlines != null) {
            final List startDeadlines = deadlines.getStartDeadlines();
    
            if (startDeadlines != null) {
                scheduleDeadlines(startDeadlines, now, task.getId(), DeadlineType.START);
            }
    
            final List endDeadlines = deadlines.getEndDeadlines();
    
            if (endDeadlines != null) {
                scheduleDeadlines(endDeadlines, now, task.getId(), DeadlineType.END);
>>>>>>> e1a8bd63124a5e1723cf2861d338155dc249e7ce
            }
        }
    }
Solution content 
    private void scheduleDeadlinesForTask(final Task task) {
        final long now = System.currentTimeMillis();

        Deadlines deadlines = task.getDeadlines();
        
        if (deadlines != null) {
            final List startDeadlines = deadlines.getStartDeadlines();
    
            if (startDeadlines != null) {
                scheduleDeadlines(startDeadlines, now, task.getId(), DeadlineType.START);
            }
    
            final List endDeadlines = deadlines.getEndDeadlines();
    
            if (endDeadlines != null) {
                scheduleDeadlines(endDeadlines, now, task.getId(), DeadlineType.END);
            }
        }
    }
File
DeadlinesDecorator.java
Developer's decision
Version 2
Kind of conflict
If statement
Method invocation
Variable
Chunk
Conflicting content 
        }

        Iterator it = null;
<<<<<<< HEAD
        if (task.getDeadlines().getStartDeadlines() != null) {
            it = task.getDeadlines().getStartDeadlines().iterator();
            while (it.hasNext()) {
                pm.remove(it.next());
                it.remove();
            }
        }

        if (task.getDeadlines().getEndDeadlines() != null) {
            it = task.getDeadlines().getEndDeadlines().iterator();
            while (it.hasNext()) {
                pm.remove(it.next());
                it.remove();
=======
        if (removeStart) {
            if (task.getDeadlines().getStartDeadlines() != null) {
                it = task.getDeadlines().getStartDeadlines().iterator();
                while (it.hasNext()) {
                    deadlineService.unschedule(taskId, DeadlineType.START);
                    em.remove(it.next());
                    it.remove();
                }
            }
        }

        if (removeEnd) {
            if (task.getDeadlines().getEndDeadlines() != null) {
                it = task.getDeadlines().getEndDeadlines().iterator();
                while (it.hasNext()) {
                    deadlineService.unschedule(taskId, DeadlineType.END);
                    em.remove(it.next());
                    it.remove();
                }
>>>>>>> e1a8bd63124a5e1723cf2861d338155dc249e7ce
            }
        }
    }
Solution content 
        }

        Iterator it = null;

        if (removeStart) {
            if (task.getDeadlines().getStartDeadlines() != null) {
                it = task.getDeadlines().getStartDeadlines().iterator();
                while (it.hasNext()) {
                    deadlineService.unschedule(taskId, DeadlineType.START);
                    pm.remove(it.next());
                    it.remove();
                }
            }
        }

        if (removeEnd) {
            if (task.getDeadlines().getEndDeadlines() != null) {
                it = task.getDeadlines().getEndDeadlines().iterator();
                while (it.hasNext()) {
                    deadlineService.unschedule(taskId, DeadlineType.END);
                    pm.remove(it.next());
                    it.remove();
                }

            }
        }
    }
File
DeadlinesDecorator.java
Developer's decision
Combination
Kind of conflict
If statement
Method invocation
Variable
While statement
Chunk
Conflicting content 
import javax.decorator.Decorator;
import javax.decorator.Delegate;
import javax.inject.Inject;
<<<<<<< HEAD
import org.drools.core.util.StringUtils;
import org.jbpm.shared.services.api.JbpmServicesPersistenceManager;
=======
>>>>>>> e1a8bd63124a5e1723cf2861d338155dc249e7ce

import org.jbpm.task.Operation;
import org.jbpm.task.annotations.Mvel;
Solution content 
import javax.decorator.Decorator;
import javax.decorator.Delegate;
import javax.inject.Inject;


import org.jbpm.task.Operation;
import org.jbpm.task.annotations.Mvel;
File
UserGroupLifeCycleManagerDecorator.java
Developer's decision
Version 2
Kind of conflict
Import
Chunk
Conflicting content 
 *
 */
@Decorator
<<<<<<< HEAD
public class UserGroupLifeCycleManagerDecorator implements LifeCycleManager {
=======
public abstract class UserGroupLifeCycleManagerDecorator extends AbstractUserGroupCallbackDecorator implements LifeCycleManager {
>>>>>>> e1a8bd63124a5e1723cf2861d338155dc249e7ce

    @Inject
    @Delegate
Solution content 
 *
 */
@Decorator
public class UserGroupLifeCycleManagerDecorator extends AbstractUserGroupCallbackDecorator implements LifeCycleManager {


    @Inject
    @Delegate
File
UserGroupLifeCycleManagerDecorator.java
Developer's decision
Manual
Kind of conflict
Class signature
Chunk
Conflicting content 
    @Inject 
    @Delegate
    @Mvel
    private LifeCycleManager manager;
<<<<<<< HEAD
    private JbpmServicesPersistenceManager pm;
    @Inject
    private UserGroupCallback userGroupCallback;
    private Map userGroupsMap = new HashMap();
=======

>>>>>>> e1a8bd63124a5e1723cf2861d338155dc249e7ce

    public UserGroupLifeCycleManagerDecorator() {
    }
Solution content 
    @Delegate
    @Mvel
    private LifeCycleManager manager;

    public UserGroupLifeCycleManagerDecorator() {
    }
File
UserGroupLifeCycleManagerDecorator.java
Developer's decision
Version 2
Kind of conflict
Annotation
Attribute
Method invocation
Chunk
Conflicting content 
        manager.taskOperation(operation, taskId, userId, targetEntityId, data, groupIds);

    }
<<<<<<< HEAD

    private List doUserGroupCallbackOperation(String userId, List groupIds) {

        doCallbackUserOperation(userId);
        doCallbackGroupsOperation(userId, groupIds);

        return userGroupCallback.getGroupsForUser(userId, groupIds, null);

    }

    private boolean doCallbackUserOperation(String userId) {

        if (userId != null && userGroupCallback.existsUser(userId)) {
            addUserFromCallbackOperation(userId);
            return true;
        }
        return false;

    }

    private boolean doCallbackGroupOperation(String groupId) {

        if (groupId != null && userGroupCallback.existsGroup(groupId)) {
            addGroupFromCallbackOperation(groupId);
            return true;
        }
        return false;

    }

    private void addUserFromCallbackOperation(String userId) {
        try {
            boolean userExists = pm.find(User.class, userId) != null;
            if (!StringUtils.isEmpty(userId) && !userExists) {
                User user = new User(userId);
                pm.persist(user);
            }
        } catch (Throwable t) {
            //logger.log(Level.SEVERE, "Unable to add user " + userId);
        }
    }

    private void doCallbackGroupsOperation(String userId, List groupIds) {

        if (userId != null) {

            if (groupIds != null && groupIds.size() > 0) {

                List userGroups = userGroupCallback.getGroupsForUser(userId, groupIds, null);
                for (String groupId : groupIds) {

                    if (userGroupCallback.existsGroup(groupId) && userGroups != null && userGroups.contains(groupId)) {
                        addGroupFromCallbackOperation(groupId);
                    }
                }
            } else {
                if (!(userGroupsMap.containsKey(userId) && userGroupsMap.get(userId).booleanValue())) {
                    List userGroups = userGroupCallback.getGroupsForUser(userId, null, null);
                    if (userGroups != null && userGroups.size() > 0) {
                        for (String group : userGroups) {
                            addGroupFromCallbackOperation(group);
                        }
                        userGroupsMap.put(userId, true);
                    }
                }
            }
        } else {
            if (groupIds != null) {
                for (String groupId : groupIds) {
                    addGroupFromCallbackOperation(groupId);
                }
            }
        }

    }

    private void addGroupFromCallbackOperation(String groupId) {
        try {
            boolean groupExists = pm.find(Group.class, groupId) != null;
            if (!StringUtils.isEmpty(groupId) && !groupExists) {
                Group group = new Group(groupId);
                pm.persist(group);
            }
        } catch (Throwable t) {
            //logger.log(Level.WARNING, "UserGroupCallback has not been registered.");
        }
    }
=======
>>>>>>> e1a8bd63124a5e1723cf2861d338155dc249e7ce
}
Solution content 
        manager.taskOperation(operation, taskId, userId, targetEntityId, data, groupIds);

    }

}
File
UserGroupLifeCycleManagerDecorator.java
Developer's decision
Version 2
Kind of conflict
Method declaration
Chunk
Conflicting content 
import javax.decorator.Decorator;
import javax.decorator.Delegate;
import javax.inject.Inject;
<<<<<<< HEAD
import org.drools.core.util.StringUtils;
import org.jbpm.shared.services.api.JbpmServicesPersistenceManager;
=======

>>>>>>> e1a8bd63124a5e1723cf2861d338155dc249e7ce
import org.jbpm.task.Attachment;
import org.jbpm.task.Content;
import org.jbpm.task.api.TaskAttachmentService;
Solution content 
import javax.decorator.Decorator;
import javax.decorator.Delegate;
import javax.inject.Inject;
import org.jbpm.task.Attachment;
import org.jbpm.task.Content;
import org.jbpm.task.api.TaskAttachmentService;
File
UserGroupTaskAttachmentDecorator.java
Developer's decision
Version 2
Kind of conflict
Import
Chunk
Conflicting content 
    @Inject
    @Delegate
    private TaskAttachmentService attachmentService;
<<<<<<< HEAD

    @Inject
    private UserGroupCallback userGroupCallback;
    
    @Inject
    private JbpmServicesPersistenceManager pm;
=======
>>>>>>> e1a8bd63124a5e1723cf2861d338155dc249e7ce
    
    public long addAttachment(long taskId, Attachment attachment, Content content) {
        doCallbackOperationForAttachment(attachment);
Solution content 
    @Inject
    @Delegate
    private TaskAttachmentService attachmentService;

    
    public long addAttachment(long taskId, Attachment attachment, Content content) {
        doCallbackOperationForAttachment(attachment);
File
UserGroupTaskAttachmentDecorator.java
Developer's decision
Version 2
Kind of conflict
Annotation
Attribute
Chunk
Conflicting content 
            }
        }
    }
<<<<<<< HEAD

    private boolean doCallbackUserOperation(String userId) {

        if (userId != null && userGroupCallback.existsUser(userId)) {
            addUserFromCallbackOperation(userId);
            return true;
        }
        return false;

    }
    
    private void addUserFromCallbackOperation(String userId) {
        try {
            boolean userExists = pm.find(User.class, userId) != null;
            if (!StringUtils.isEmpty(userId) && !userExists) {
                User user = new User(userId);
                pm.persist(user);
            }
        } catch (Throwable t) {
            //logger.log(Level.SEVERE, "Unable to add user " + userId);
        }
    }
=======
>>>>>>> e1a8bd63124a5e1723cf2861d338155dc249e7ce
}
Solution content 
            }
        }
    }
}
File
UserGroupTaskAttachmentDecorator.java
Developer's decision
Version 2
Kind of conflict
Method declaration
Chunk
Conflicting content 
import javax.decorator.Decorator;
import javax.decorator.Delegate;
import javax.inject.Inject;
<<<<<<< HEAD
import javax.persistence.EntityManager;
import org.drools.core.util.StringUtils;
import org.jbpm.shared.services.api.JbpmServicesPersistenceManager;
import org.jbpm.task.Deadline;
import org.jbpm.task.Deadlines;
import org.jbpm.task.Escalation;
import org.jbpm.task.Group;
import org.jbpm.task.Notification;
=======

>>>>>>> e1a8bd63124a5e1723cf2861d338155dc249e7ce
import org.jbpm.task.OrganizationalEntity;
import org.jbpm.task.Task;
import org.jbpm.task.annotations.CommandBased;
Solution content 
import javax.decorator.Decorator;
import javax.decorator.Delegate;
import javax.inject.Inject;

import org.jbpm.task.OrganizationalEntity;
import org.jbpm.task.Task;
import org.jbpm.task.annotations.CommandBased;
File
UserGroupTaskCommandExecutorDecorator.java
Developer's decision
Version 2
Kind of conflict
Import
Chunk
Conflicting content 
    @Delegate
    @CommandBased
    private TaskCommandExecutor executor;
<<<<<<< HEAD
    @Inject 
    private JbpmServicesPersistenceManager pm;
    @Inject
    private UserGroupCallback userGroupCallback;
    private Map userGroupsMap = new HashMap();
=======
    
>>>>>>> e1a8bd63124a5e1723cf2861d338155dc249e7ce

    public  T executeTaskCommand(TaskCommand command) {
        if (command instanceof AddTaskCommand) {
Solution content 
    @Delegate
    @CommandBased
    private TaskCommandExecutor executor;

    public  T executeTaskCommand(TaskCommand command) {
        if (command instanceof AddTaskCommand) {
File
UserGroupTaskCommandExecutorDecorator.java
Developer's decision
Version 2
Kind of conflict
Annotation
Attribute
Method invocation
Chunk
Conflicting content 
        return executor.executeTaskCommand(command);
    }

<<<<<<< HEAD
    private List doUserGroupCallbackOperation(String userId, List groupIds) {

        doCallbackUserOperation(userId);
        doCallbackGroupsOperation(userId, groupIds);
        List allGroupIds = null;

        return userGroupCallback.getGroupsForUser(userId, groupIds, allGroupIds);

    }

    private boolean doCallbackUserOperation(String userId) {

        if (userId != null && userGroupCallback.existsUser(userId)) {
            addUserFromCallbackOperation(userId);
            return true;
        }
        return false;

    }

    private boolean doCallbackGroupOperation(String groupId) {

        if (groupId != null && userGroupCallback.existsGroup(groupId)) {
            addGroupFromCallbackOperation(groupId);
            return true;
        }
        return false;

    }

    private void addUserFromCallbackOperation(String userId) {
        try {
            boolean userExists = pm.find(User.class, userId) != null;
            if (!StringUtils.isEmpty(userId) && !userExists) {
                User user = new User(userId);
                pm.persist(user);
            }
        } catch (Throwable t) {
            //logger.log(Level.SEVERE, "Unable to add user " + userId);
        }
    }

    private void doCallbackGroupsOperation(String userId, List groupIds) {

        if (userId != null) {

            if (groupIds != null && groupIds.size() > 0) {

                List userGroups = userGroupCallback.getGroupsForUser(userId, groupIds, null);
                for (String groupId : groupIds) {

                    if (userGroupCallback.existsGroup(groupId) && userGroups != null && userGroups.contains(groupId)) {
                        addGroupFromCallbackOperation(groupId);
                    }
                }
            } else {
            }

                if (!(userGroupsMap.containsKey(userId) && userGroupsMap.get(userId).booleanValue())) {
                    List userGroups = userGroupCallback.getGroupsForUser(userId, null, null);
                    if (userGroups != null && userGroups.size() > 0) {
                        for (String group : userGroups) {
                            addGroupFromCallbackOperation(group);
                        }
                        userGroupsMap.put(userId, true);
                    }
                }
            }
        } else {
            if (groupIds != null) {
                for (String groupId : groupIds) {
                    addGroupFromCallbackOperation(groupId);
                }
            }
        }

    }

    private void addGroupFromCallbackOperation(String groupId) {
        try {
            boolean groupExists = pm.find(Group.class, groupId) != null;
            if (!StringUtils.isEmpty(groupId) && !groupExists) {
                Group group = new Group(groupId);
                pm.persist(group);
            }
        } catch (Throwable t) {
            //logger.log(Level.WARNING, "UserGroupCallback has not been registered.");
        }
    }

    private void doCallbackOperationForTaskData(TaskData data) {

        if (data.getActualOwner() != null) {
            boolean userExists = doCallbackUserOperation(data.getActualOwner().getId());
            if (!userExists) {
                // remove it from the task to avoid foreign key constraint exception
                data.setActualOwner(null);
                data.setStatus(Status.Ready);
            }
        }

        if (data.getCreatedBy() != null) {
            boolean userExists = doCallbackUserOperation(data.getCreatedBy().getId());
            if (!userExists) {
                // remove it from the task to avoid foreign key constraint exception
                data.setCreatedBy(null);
            }
        }

    }

    private void doCallbackOperationForPotentialOwners(List potentialOwners) {

        List nonExistingEntities = new ArrayList();

        for (OrganizationalEntity orgEntity : potentialOwners) {
            if (orgEntity instanceof User) {
                boolean userExists = doCallbackUserOperation(orgEntity.getId());
                if (!userExists) {
                    nonExistingEntities.add(orgEntity);
                }
            }
            if (orgEntity instanceof Group) {
                boolean groupExists = doCallbackGroupOperation(orgEntity.getId());
                if (!groupExists) {
                    nonExistingEntities.add(orgEntity);
                }
            }
        }
        if (!nonExistingEntities.isEmpty()) {
            potentialOwners.removeAll(nonExistingEntities);
        }

    }

    private void doCallbackOperationForPeopleAssignments(PeopleAssignments assignments) {

        List nonExistingEntities = new ArrayList();

        if (assignments != null) {
            List businessAdmins = assignments.getBusinessAdministrators();
            if (businessAdmins != null) {
                for (OrganizationalEntity admin : businessAdmins) {
                    if (admin instanceof User) {
                        boolean userExists = doCallbackUserOperation(admin.getId());
                        if (!userExists) {
                            nonExistingEntities.add(admin);
                        }
                    }
                    if (admin instanceof Group) {
                        boolean groupExists = doCallbackGroupOperation(admin.getId());
                        if (!groupExists) {
                            nonExistingEntities.add(admin);
                        }
                    }
                }

                if (!nonExistingEntities.isEmpty()) {
                    businessAdmins.removeAll(nonExistingEntities);
                    nonExistingEntities.clear();
                }
            }

            if (businessAdmins == null || businessAdmins.isEmpty()) {
                // throw an exception as it should not be allowed to create task without administrator
                throw new CannotAddTaskException("There are no known Business Administrators, task cannot be created according to WS-HT specification");
            }

            List potentialOwners = assignments.getPotentialOwners();
            if (potentialOwners != null) {
                for (OrganizationalEntity powner : potentialOwners) {
                    if (powner instanceof User) {
                        boolean userExists = doCallbackUserOperation(powner.getId());
                        if (!userExists) {
                            nonExistingEntities.add(powner);
                        }
                    }
                    if (powner instanceof Group) {
                        boolean groupExists = doCallbackGroupOperation(powner.getId());
                        if (!groupExists) {
                            nonExistingEntities.add(powner);
                        }
                    }
                }
                if (!nonExistingEntities.isEmpty()) {
                    potentialOwners.removeAll(nonExistingEntities);
                    nonExistingEntities.clear();
                }
            }

            if (assignments.getTaskInitiator() != null && assignments.getTaskInitiator().getId() != null) {
                doCallbackUserOperation(assignments.getTaskInitiator().getId());
            }

            List excludedOwners = assignments.getExcludedOwners();
            if (excludedOwners != null) {
                for (OrganizationalEntity exowner : excludedOwners) {
                    if (exowner instanceof User) {
                        boolean userExists = doCallbackUserOperation(exowner.getId());
                        if (!userExists) {
                            nonExistingEntities.add(exowner);
                        }
                    }
                    if (exowner instanceof Group) {
                        boolean groupExists = doCallbackGroupOperation(exowner.getId());
                        if (!groupExists) {
                            nonExistingEntities.add(exowner);
                        }
                    }
                }
                if (!nonExistingEntities.isEmpty()) {
                    excludedOwners.removeAll(nonExistingEntities);
                    nonExistingEntities.clear();
                }
            }

            List recipients = assignments.getRecipients();
            if (recipients != null) {
                for (OrganizationalEntity recipient : recipients) {
                    if (recipient instanceof User) {
                        boolean userExists = doCallbackUserOperation(recipient.getId());
                        if (!userExists) {
                            nonExistingEntities.add(recipient);
                        }
                    }
                    if (recipient instanceof Group) {
                        boolean groupExists = doCallbackGroupOperation(recipient.getId());
                        if (!groupExists) {
                            nonExistingEntities.add(recipient);
                        }
                    }
                }
                if (!nonExistingEntities.isEmpty()) {
                    recipients.removeAll(nonExistingEntities);
                    nonExistingEntities.clear();
                }
            List stakeholders = assignments.getTaskStakeholders();
            if (stakeholders != null) {
                for (OrganizationalEntity stakeholder : stakeholders) {
                    if (stakeholder instanceof User) {
                        boolean userExists = doCallbackUserOperation(stakeholder.getId());
                        if (!userExists) {
                            nonExistingEntities.add(stakeholder);
                        }
                    }
                    if (stakeholder instanceof Group) {
                        boolean groupExists = doCallbackGroupOperation(stakeholder.getId());
                        if (!groupExists) {
                            nonExistingEntities.add(stakeholder);
                        }
                    }
                }
                if (!nonExistingEntities.isEmpty()) {
                    stakeholders.removeAll(nonExistingEntities);
                    nonExistingEntities.clear();
                }
            }
        }


    }
     private void doCallbackOperationForTaskDeadlines(Deadlines deadlines) {
        if(deadlines != null) {
            if(deadlines.getStartDeadlines() != null) {
                List startDeadlines = deadlines.getStartDeadlines();
                for(Deadline startDeadline : startDeadlines) {
                    List escalations = startDeadline.getEscalations();
                    if(escalations != null) {
                        for(Escalation escalation : escalations) {
                            List notifications = escalation.getNotifications();
                            List ressignments = escalation.getReassignments();
                            if(notifications != null) {
                                for(Notification notification : notifications) {
                                    List recipients = notification.getRecipients();
                                    if(recipients != null) {
                                        for(OrganizationalEntity recipient : recipients) {
                                            if(recipient instanceof User) {
                                                doCallbackUserOperation(recipient.getId());
                                            }
                                            if(recipient instanceof Group) {
                                                doCallbackGroupOperation(recipient.getId());
                                            }
                                        }
                                    }
                                    List administrators = notification.getBusinessAdministrators();
                                    if(administrators != null) {
                                        for(OrganizationalEntity administrator : administrators) {
                                            if(administrator instanceof User) {
                                                doCallbackUserOperation(administrator.getId());
                                            }
                                            if(administrator instanceof Group) {
                                                doCallbackGroupOperation(administrator.getId());
                                            }
                                        }
                                    }
                                }
                            }
                            if(ressignments != null) {
                                for(Reassignment reassignment : ressignments) {
                                    List potentialOwners = reassignment.getPotentialOwners();
                                    if(potentialOwners != null) {
                                        for(OrganizationalEntity potentialOwner : potentialOwners) {
                                            if(potentialOwner instanceof User) {
                                                doCallbackUserOperation(potentialOwner.getId());
                                            }
                                            if(potentialOwner instanceof Group) {
                                                doCallbackGroupOperation(potentialOwner.getId());
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            
            if(deadlines.getEndDeadlines() != null) {
                List endDeadlines = deadlines.getEndDeadlines();
                for(Deadline endDeadline : endDeadlines) {
                    List escalations = endDeadline.getEscalations();
                    if(escalations != null) {
                        for(Escalation escalation : escalations) {
                            List notifications = escalation.getNotifications();
                            List ressignments = escalation.getReassignments();
                            if(notifications != null) {
                                for(Notification notification : notifications) {
                                    List recipients = notification.getRecipients();
                                    if(recipients != null) {
                                        for(OrganizationalEntity recipient : recipients) {
                                            if(recipient instanceof User) {
                                                doCallbackUserOperation(recipient.getId());
                                            }
                                            if(recipient instanceof Group) {
                                                doCallbackGroupOperation(recipient.getId());
                                            }
                                        }
                                    }
                                    List administrators = notification.getBusinessAdministrators();
                                    if(administrators != null) {
                                        for(OrganizationalEntity administrator : administrators) {
                                            if(administrator instanceof User) {
                                                doCallbackUserOperation(administrator.getId());
                                            }
                                            if(administrator instanceof Group) {
                                                doCallbackGroupOperation(administrator.getId());
                                            }
                                        }
                                    }
                                }
                            }
                            if(ressignments != null) {
                                for(Reassignment reassignment : ressignments) {
                                    List potentialOwners = reassignment.getPotentialOwners();
                                    if(potentialOwners != null) {
                                        for(OrganizationalEntity potentialOwner : potentialOwners) {
                                            if(potentialOwner instanceof User) {
                                                doCallbackUserOperation(potentialOwner.getId());
                                            }
                                            if(potentialOwner instanceof Group) {
                                                doCallbackGroupOperation(potentialOwner.getId());
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
=======
    
>>>>>>> e1a8bd63124a5e1723cf2861d338155dc249e7ce
}
Solution content 
        return executor.executeTaskCommand(command);
    }


}
File
UserGroupTaskCommandExecutorDecorator.java
Developer's decision
Version 2
Kind of conflict
Method declaration
Chunk
Conflicting content 
import javax.decorator.Decorator;
import javax.decorator.Delegate;
import javax.inject.Inject;
<<<<<<< HEAD
import javax.persistence.EntityManager;
import org.drools.core.util.StringUtils;
import org.jbpm.shared.services.api.JbpmServicesPersistenceManager;
=======

>>>>>>> e1a8bd63124a5e1723cf2861d338155dc249e7ce
import org.jbpm.task.Comment;
import org.jbpm.task.api.TaskCommentService;
Solution content 
import javax.decorator.Decorator;
import javax.decorator.Delegate;
import javax.inject.Inject;

import org.jbpm.task.Comment;
import org.jbpm.task.api.TaskCommentService;
File
UserGroupTaskCommentDecorator.java
Developer's decision
Version 2
Kind of conflict
Import
Chunk
Conflicting content 
    @Inject
    @Inject
    @Delegate
    private TaskCommentService commentService;
<<<<<<< HEAD
    @Inject
    private UserGroupCallback userGroupCallback;
    private JbpmServicesPersistenceManager pm;
=======
>>>>>>> e1a8bd63124a5e1723cf2861d338155dc249e7ce

    public long addComment(long taskId, Comment comment) {
        doCallbackOperationForComment(comment);
Solution content 
    @Inject
    @Delegate
    private TaskCommentService commentService;


    public long addComment(long taskId, Comment comment) {
        doCallbackOperationForComment(comment);
File
UserGroupTaskCommentDecorator.java
Developer's decision
Version 2
Kind of conflict
Annotation
Attribute
Chunk
Conflicting content 
            }
        }
    }
<<<<<<< HEAD

    private boolean doCallbackUserOperation(String userId) {

        if (userId != null && userGroupCallback.existsUser(userId)) {
            addUserFromCallbackOperation(userId);
            return true;
        }
        return false;

    }

    private void addUserFromCallbackOperation(String userId) {
        try {
            boolean userExists = pm.find(User.class, userId) != null;
            if (!StringUtils.isEmpty(userId) && !userExists) {
                User user = new User(userId);
                pm.persist(user);
            }
        } catch (Throwable t) {
            //logger.log(Level.SEVERE, "Unable to add user " + userId);
        }
    }
=======
>>>>>>> e1a8bd63124a5e1723cf2861d338155dc249e7ce
}
Solution content 
            }
        }
    }

}
File
UserGroupTaskCommentDecorator.java
Developer's decision
Version 2
Kind of conflict
Method declaration
Chunk
Conflicting content 
import javax.enterprise.context.ContextNotActiveException;
import javax.enterprise.event.Event;
import javax.inject.Inject;
<<<<<<< HEAD
import org.jboss.seam.transaction.Transactional;
import org.jbpm.shared.services.api.JbpmServicesPersistenceManager;
=======
import javax.naming.InitialContext;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.transaction.UserTransaction;

import org.jboss.seam.transaction.Transactional;
import org.jbpm.shared.services.cdi.Startup;
>>>>>>> e1a8bd63124a5e1723cf2861d338155dc249e7ce
import org.jbpm.task.Content;
import org.jbpm.task.Deadline;
import org.jbpm.task.Escalation;
Solution content 
import javax.enterprise.context.ContextNotActiveException;
import javax.enterprise.event.Event;
import javax.inject.Inject;
import org.jbpm.shared.services.impl.JbpmServicesPersistenceManagerImpl;
import javax.naming.InitialContext;
import javax.persistence.EntityManager;
import javax.transaction.UserTransaction;
import org.jboss.seam.transaction.Transactional;
import org.jbpm.shared.services.api.JbpmServicesPersistenceManager;
import org.jbpm.shared.services.cdi.Startup;
import org.jbpm.task.Content;
import org.jbpm.task.Deadline;
import org.jbpm.task.Escalation;
File
TaskDeadlinesServiceImpl.java
Developer's decision
Manual
Kind of conflict
Import
Chunk
Conflicting content 
    @PostConstruct
    public void init() {
<<<<<<< HEAD
        setValidStatuses();
//        long now = System.currentTimeMillis();
//        List resultList = em.createNamedQuery("UnescalatedDeadlines").getResultList();
//        for (DeadlineSummary summary : resultList) {
//            long delay = summary.getDate().getTime() - now;
//            schedule(summary.getTaskId(), summary.getDeadlineId(), delay);
//        }
    }

    private void executeEscalatedDeadline(long taskId, long deadlineId) {
        Task task = (Task) pm.find(Task.class, taskId);
        Deadline deadline = (Deadline) pm.find(Deadline.class, deadlineId);

        TaskData taskData = task.getTaskData();
        Content content = null;
        if (taskData != null) {
            content = (Content) pm.find(Content.class, taskData.getDocumentContentId());
=======
        UserTransaction ut = setupEnvironment();
        EntityManager entityManager = getEntityManager();
        long now = System.currentTimeMillis();
        List resultList = entityManager.createNamedQuery("UnescalatedStartDeadlines").getResultList();
        for (DeadlineSummary summary : resultList) {
            long delay = summary.getDate().getTime() - now;
            schedule(summary.getTaskId(), summary.getDeadlineId(), delay, DeadlineType.START);
>>>>>>> e1a8bd63124a5e1723cf2861d338155dc249e7ce
        }
        
        resultList = entityManager.createNamedQuery("UnescalatedEndDeadlines").getResultList();
Solution content 
    @PostConstruct
    public void init() {

       // UserTransaction ut = setupEnvironment();
        
        long now = System.currentTimeMillis();
        List resultList = (List)pm.queryInTransaction("UnescalatedStartDeadlines");
        for (DeadlineSummary summary : resultList) {
            long delay = summary.getDate().getTime() - now;
            schedule(summary.getTaskId(), summary.getDeadlineId(), delay, DeadlineType.START);

        }
File
TaskDeadlinesServiceImpl.java
Developer's decision
Manual
Kind of conflict
Cast expression
Comment
For statement
If statement
Method invocation
Method signature
Variable
Chunk
Conflicting content 
import javax.enterprise.event.Event;
import javax.enterprise.util.AnnotationLiteral;
import javax.inject.Inject;
<<<<<<< HEAD
import org.drools.core.util.StringUtils;
import org.jbpm.task.internals.lifecycle.LifeCycleManager;
import org.jbpm.task.annotations.Mvel;
=======
import javax.persistence.EntityManager;

>>>>>>> e1a8bd63124a5e1723cf2861d338155dc249e7ce
import org.jboss.seam.transaction.Transactional;
import org.jbpm.shared.services.api.JbpmServicesPersistenceManager;
import org.jbpm.task.Content;
Solution content 
import javax.enterprise.event.Event;
import javax.enterprise.util.AnnotationLiteral;
import javax.inject.Inject;
import org.drools.core.util.StringUtils;
import org.jbpm.task.internals.lifecycle.LifeCycleManager;
import org.jbpm.task.annotations.Mvel;

import org.jboss.seam.transaction.Transactional;
import org.jbpm.shared.services.api.JbpmServicesPersistenceManager;
import org.jbpm.task.Content;
File
TaskInstanceServiceImpl.java
Developer's decision
Version 1
Kind of conflict
Import
Chunk
Conflicting content 
import org.jbpm.task.OrganizationalEntity;
import org.jbpm.task.SubTasksStrategy;
import org.jbpm.task.Task;
<<<<<<< HEAD
import org.jbpm.task.TaskData;
import org.jbpm.task.User;
import org.jbpm.task.api.TaskInstanceService;
import org.jbpm.task.api.TaskQueryService;
import org.jbpm.task.events.AfterTaskAddedEvent;
import org.jbpm.task.exception.CannotAddTaskException;
import org.jbpm.task.identity.UserGroupCallback;
import org.jbpm.task.identity.UserGroupLifeCycleManagerDecorator;
=======
import org.jbpm.task.TaskDef;
import org.jbpm.task.annotations.Mvel;
import org.jbpm.task.api.TaskDefService;
import org.jbpm.task.api.TaskInstanceService;
import org.jbpm.task.api.TaskQueryService;
import org.jbpm.task.events.AfterTaskAddedEvent;
import org.jbpm.task.impl.factories.TaskFactory;
import org.jbpm.task.internals.lifecycle.LifeCycleManager;
>>>>>>> e1a8bd63124a5e1723cf2861d338155dc249e7ce
import org.jbpm.task.internals.lifecycle.MVELLifeCycleManager;
import org.jbpm.task.query.TaskSummary;
import org.jbpm.task.utils.ContentMarshallerHelper;
Solution content 
import org.jbpm.task.OrganizationalEntity;
import org.jbpm.task.SubTasksStrategy;
import org.jbpm.task.Task;

import org.jbpm.task.TaskData;
import org.jbpm.task.User;
import org.jbpm.task.api.TaskInstanceService;
import org.jbpm.task.api.TaskQueryService;
import org.jbpm.task.events.AfterTaskAddedEvent;
import org.jbpm.task.exception.CannotAddTaskException;
import org.jbpm.task.identity.UserGroupCallback;
import org.jbpm.task.identity.UserGroupLifeCycleManagerDecorator;

import org.jbpm.task.internals.lifecycle.MVELLifeCycleManager;
import org.jbpm.task.query.TaskSummary;
import org.jbpm.task.utils.ContentMarshallerHelper;
File
TaskInstanceServiceImpl.java
Developer's decision
Version 1
Kind of conflict
Import
Chunk
Conflicting content 
    }

    public long addTask(Task task, ContentData contentData) {
<<<<<<< HEAD
        doCallbackOperationForPeopleAssignments(task.getPeopleAssignments());
        doCallbackOperationForTaskData(task.getTaskData());
        doCallbackOperationForTaskDeadlines(task.getDeadlines());
        pm.persist(task);
=======
        em.persist(task);
>>>>>>> e1a8bd63124a5e1723cf2861d338155dc249e7ce
        if (contentData != null) {
            Content content = new Content(contentData.getContent());
            pm.persist(content);
Solution content 
    }
    public long addTask(Task task, ContentData contentData) {

        pm.persist(task);

        if (contentData != null) {
            Content content = new Content(contentData.getContent());
            pm.persist(content);
File
TaskInstanceServiceImpl.java
Developer's decision
Combination
Kind of conflict
Method invocation
Chunk
Conflicting content 
    //@TODO: WHY THE HELL THIS IS NOT AN OPERATION???
    public void nominate(long taskId, String userId, List potentialOwners) {
<<<<<<< HEAD
        doCallbackOperationForPotentialOwners(potentialOwners);
        if(lifeCycleManager instanceof UserGroupLifeCycleManagerDecorator){
            ((MVELLifeCycleManager)((UserGroupLifeCycleManagerDecorator) lifeCycleManager).getManager()).nominate(taskId, userId, potentialOwners);
        } else if(lifeCycleManager instanceof MVELLifeCycleManager){
            ((MVELLifeCycleManager)lifeCycleManager).nominate(taskId, userId, potentialOwners);
        }
=======
        ((MVELLifeCycleManager) lifeCycleManager).nominate(taskId, userId, potentialOwners);
>>>>>>> e1a8bd63124a5e1723cf2861d338155dc249e7ce
    }

    public void setSubTaskStrategy(long taskId, SubTasksStrategy strategy) {
Solution content 
    //@TODO: WHY THE HELL THIS IS NOT AN OPERATION???
    public void nominate(long taskId, String userId, List potentialOwners) {
        if(lifeCycleManager instanceof UserGroupLifeCycleManagerDecorator){
            ((MVELLifeCycleManager)((UserGroupLifeCycleManagerDecorator) lifeCycleManager).getManager()).nominate(taskId, userId, potentialOwners);
        } else if(lifeCycleManager instanceof MVELLifeCycleManager){
            ((MVELLifeCycleManager)lifeCycleManager).nominate(taskId, userId, potentialOwners);
        }

    }

    public void setSubTaskStrategy(long taskId, SubTasksStrategy strategy) {
File
TaskInstanceServiceImpl.java
Developer's decision
Combination
Kind of conflict
If statement
Method invocation
Chunk
Conflicting content 
        task.getTaskData().setSkipable(skipable);
    }

<<<<<<< HEAD
    private List doUserGroupCallbackOperation(String userId, List groupIds) {

        doCallbackUserOperation(userId);
        doCallbackGroupsOperation(userId, groupIds);

        return userGroupCallback.getGroupsForUser(userId, groupIds, null);

    }

    private boolean doCallbackUserOperation(String userId) {

        if (userId != null && userGroupCallback.existsUser(userId)) {
            addUserFromCallbackOperation(userId);
            return true;
        }
        return false;

    }

    private boolean doCallbackGroupOperation(String groupId) {

        if (groupId != null && userGroupCallback.existsGroup(groupId)) {
            addGroupFromCallbackOperation(groupId);
            return true;
        }
        return false;

    }

    private void addUserFromCallbackOperation(String userId) {
        try {
            boolean userExists = pm.find(User.class, userId) != null;
            if (orgEntity instanceof Group) {
            if (!StringUtils.isEmpty(userId) && !userExists) {
                User user = new User(userId);
                pm.persist(user);
            }
        } catch (Throwable t) {
            logger.log(Level.SEVERE, "Unable to add user " + userId);
        }
    }
   
    // ALL THIS CODE SHOULD NOT BE HERE>> THIS IS PLACED HERE TO DEMONSTRATE THAT IS WRONG
    @Inject
    private UserGroupCallback userGroupCallback;
    private Map userGroupsMap = new HashMap();
    
    private void doCallbackGroupsOperation(String userId, List groupIds) {

        if (userId != null) {

            if (groupIds != null && groupIds.size() > 0) {

                List userGroups = userGroupCallback.getGroupsForUser(userId, groupIds, null);
                for (String groupId : groupIds) {

                    if (userGroupCallback.existsGroup(groupId) && userGroups != null && userGroups.contains(groupId)) {
                        addGroupFromCallbackOperation(groupId);
                    }
                }
            } else {
                if (!(userGroupsMap.containsKey(userId) && userGroupsMap.get(userId).booleanValue())) {
                    List userGroups = userGroupCallback.getGroupsForUser(userId, null, null);
                    if (userGroups != null && userGroups.size() > 0) {
                        for (String group : userGroups) {
                            addGroupFromCallbackOperation(group);
                        }
                        userGroupsMap.put(userId, true);
                    }
                }
            }
        } else {
            if (groupIds != null) {
                for (String groupId : groupIds) {
                    addGroupFromCallbackOperation(groupId);
                }
            }
        }

    }

    private void addGroupFromCallbackOperation(String groupId) {
        try {
            boolean groupExists = pm.find(Group.class, groupId) != null;
            if (!StringUtils.isEmpty(groupId) && !groupExists) {
                Group group = new Group(groupId);
                pm.persist(group);
            }
        } catch (Throwable t) {
            logger.log(Level.WARNING, "UserGroupCallback has not been registered.");
        }
    }

    private void doCallbackOperationForPeopleAssignments(PeopleAssignments assignments) {

        List nonExistingEntities = new ArrayList();

        if (assignments != null) {
            List businessAdmins = assignments.getBusinessAdministrators();
            if (businessAdmins != null) {
                for (OrganizationalEntity admin : businessAdmins) {
                    if (admin instanceof User) {
                        boolean userExists = doCallbackUserOperation(admin.getId());
                        if (!userExists) {
                            nonExistingEntities.add(admin);
                        }
                    }
                    if (admin instanceof Group) {
                        boolean groupExists = doCallbackGroupOperation(admin.getId());
                        if (!groupExists) {
                            nonExistingEntities.add(admin);
                        }
                    }
                }

                if (!nonExistingEntities.isEmpty()) {
                    businessAdmins.removeAll(nonExistingEntities);
                    nonExistingEntities.clear();
                }
            }

            if (businessAdmins == null || businessAdmins.isEmpty()) {
                // throw an exception as it should not be allowed to create task without administrator
                        if (!groupExists) {
                throw new CannotAddTaskException("There are no known Business Administrators, task cannot be created according to WS-HT specification");
            }

            List potentialOwners = assignments.getPotentialOwners();
            if (potentialOwners != null) {
                for (OrganizationalEntity powner : potentialOwners) {
                    if (powner instanceof User) {
                        boolean userExists = doCallbackUserOperation(powner.getId());
                        if (!userExists) {
                            nonExistingEntities.add(powner);
                        }
                    }
                    if (powner instanceof Group) {
                        boolean groupExists = doCallbackGroupOperation(powner.getId());
                        if (!groupExists) {
                            nonExistingEntities.add(powner);
                        }
                    }
                }
                if (!nonExistingEntities.isEmpty()) {
                    potentialOwners.removeAll(nonExistingEntities);
                    nonExistingEntities.clear();
                }
            }

            if (assignments.getTaskInitiator() != null && assignments.getTaskInitiator().getId() != null) {
                doCallbackUserOperation(assignments.getTaskInitiator().getId());
            }

            List excludedOwners = assignments.getExcludedOwners();
            if (excludedOwners != null) {
                for (OrganizationalEntity exowner : excludedOwners) {
                    if (exowner instanceof User) {
                        boolean userExists = doCallbackUserOperation(exowner.getId());
                        if (!userExists) {
                            nonExistingEntities.add(exowner);
                        }
                    }
                    if (exowner instanceof Group) {
                        boolean groupExists = doCallbackGroupOperation(exowner.getId());
                        if (!groupExists) {
                            nonExistingEntities.add(exowner);
                        }
                    }
                }
                if (!nonExistingEntities.isEmpty()) {
                    excludedOwners.removeAll(nonExistingEntities);
                    nonExistingEntities.clear();
                }
            }

            List recipients = assignments.getRecipients();
            if (recipients != null) {
                for (OrganizationalEntity recipient : recipients) {
                    if (recipient instanceof User) {
                        boolean userExists = doCallbackUserOperation(recipient.getId());
                        if (!userExists) {
                            nonExistingEntities.add(recipient);
                        }
                    }
                    if (recipient instanceof Group) {
                        boolean groupExists = doCallbackGroupOperation(recipient.getId());
                        if (!groupExists) {
                            nonExistingEntities.add(recipient);
                        }
                    }
                }
                if (!nonExistingEntities.isEmpty()) {
                    recipients.removeAll(nonExistingEntities);
                    nonExistingEntities.clear();
                }
            }

            List stakeholders = assignments.getTaskStakeholders();
            if (stakeholders != null) {
                for (OrganizationalEntity stakeholder : stakeholders) {
                    if (stakeholder instanceof User) {
                        boolean userExists = doCallbackUserOperation(stakeholder.getId());
                        if (!userExists) {
                            nonExistingEntities.add(stakeholder);
                        }
                    }
                    if (stakeholder instanceof Group) {
                        boolean groupExists = doCallbackGroupOperation(stakeholder.getId());
                            nonExistingEntities.add(stakeholder);
                        }
                    }
                }
                if (!nonExistingEntities.isEmpty()) {
                    stakeholders.removeAll(nonExistingEntities);
                    nonExistingEntities.clear();
                }
            }
        }


    }

    private void doCallbackOperationForTaskDeadlines(Deadlines deadlines) {
        if (deadlines != null) {
            if (deadlines.getStartDeadlines() != null) {
                List startDeadlines = deadlines.getStartDeadlines();
                for (Deadline startDeadline : startDeadlines) {
                    List escalations = startDeadline.getEscalations();
                    if (escalations != null) {
                        for (Escalation escalation : escalations) {
                            List notifications = escalation.getNotifications();
                            List ressignments = escalation.getReassignments();
                            if (notifications != null) {
                                for (Notification notification : notifications) {
                                    List recipients = notification.getRecipients();
                                    if (recipients != null) {
                                        for (OrganizationalEntity recipient : recipients) {
                                            if (recipient instanceof User) {
                                                doCallbackUserOperation(recipient.getId());
                                            }
                            }
                                            if (recipient instanceof Group) {
                                                doCallbackGroupOperation(recipient.getId());
                                            }
                                        }
                                    }
                                    List administrators = notification.getBusinessAdministrators();
                                    if (administrators != null) {
                                        for (OrganizationalEntity administrator : administrators) {
                                            if (administrator instanceof User) {
                                                doCallbackUserOperation(administrator.getId());
                                            }
                                            if (administrator instanceof Group) {
                                                doCallbackGroupOperation(administrator.getId());
                                            }
                                        }
                                    }
                                }
                            }
                            if (ressignments != null) {
                                for (Reassignment reassignment : ressignments) {
                                    List potentialOwners = reassignment.getPotentialOwners();
                                    if (potentialOwners != null) {
                                        for (OrganizationalEntity potentialOwner : potentialOwners) {
                                            if (potentialOwner instanceof User) {
                                                doCallbackUserOperation(potentialOwner.getId());
                                            }
                                            if (potentialOwner instanceof Group) {
                                                doCallbackGroupOperation(potentialOwner.getId());
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }

            if (deadlines.getEndDeadlines() != null) {
                List endDeadlines = deadlines.getEndDeadlines();
                for (Deadline endDeadline : endDeadlines) {
                    List escalations = endDeadline.getEscalations();
                    if (escalations != null) {
                        for (Escalation escalation : escalations) {
                            List notifications = escalation.getNotifications();
                            if (ressignments != null) {
                            List ressignments = escalation.getReassignments();
                            if (notifications != null) {
                                for (Notification notification : notifications) {
                                    List recipients = notification.getRecipients();
                                    if (recipients != null) {
                                        for (OrganizationalEntity recipient : recipients) {
                                            if (recipient instanceof User) {
                                                doCallbackUserOperation(recipient.getId());
                                            }
                                            if (recipient instanceof Group) {
                                                doCallbackGroupOperation(recipient.getId());
                                            }
                                        }
                                    }
                                    List administrators = notification.getBusinessAdministrators();
                                    if (administrators != null) {
                                        for (OrganizationalEntity administrator : administrators) {
                                            if (administrator instanceof User) {
                                                doCallbackUserOperation(administrator.getId());
                                            }
                                            if (administrator instanceof Group) {
                                                doCallbackGroupOperation(administrator.getId());
                                            }
                                        }
                                    }
                                }
                                for (Reassignment reassignment : ressignments) {
                                    List potentialOwners = reassignment.getPotentialOwners();
                                    if (potentialOwners != null) {
                                        for (OrganizationalEntity potentialOwner : potentialOwners) {
                                            if (potentialOwner instanceof User) {
                                                doCallbackUserOperation(potentialOwner.getId());
                                            }
                                            if (potentialOwner instanceof Group) {
                                                doCallbackGroupOperation(potentialOwner.getId());
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }

    private void doCallbackOperationForTaskData(TaskData data) {

        if (data.getActualOwner() != null) {
            boolean userExists = doCallbackUserOperation(data.getActualOwner().getId());
            if (!userExists) {
                // remove it from the task to avoid foreign key constraint exception
                data.setActualOwner(null);
                data.setStatus(Status.Ready);
            }
        }

        if (data.getCreatedBy() != null) {
            boolean userExists = doCallbackUserOperation(data.getCreatedBy().getId());
            if (!userExists) {
                // remove it from the task to avoid foreign key constraint exception
                data.setCreatedBy(null);
            }
        }

    }

    private void doCallbackOperationForPotentialOwners(List potentialOwners) {

        List nonExistingEntities = new ArrayList();

        for (OrganizationalEntity orgEntity : potentialOwners) {
            if (orgEntity instanceof User) {
                boolean userExists = doCallbackUserOperation(orgEntity.getId());
                if (!userExists) {
                    nonExistingEntities.add(orgEntity);
                }
            }
                boolean groupExists = doCallbackGroupOperation(orgEntity.getId());
                if (!groupExists) {
                    nonExistingEntities.add(orgEntity);
                }
            }
        }
        if (!nonExistingEntities.isEmpty()) {
            potentialOwners.removeAll(nonExistingEntities);
        }

    }

=======
>>>>>>> e1a8bd63124a5e1723cf2861d338155dc249e7ce
    public int getPriority(long taskId) {
        Task task = pm.find(Task.class, taskId);
        return task.getPriority();
Solution content 
        task.getTaskData().setSkipable(skipable);
    }

    public int getPriority(long taskId) {
        Task task = pm.find(Task.class, taskId);
        return task.getPriority();
File
TaskInstanceServiceImpl.java
Developer's decision
Version 2
Kind of conflict
Annotation
Attribute
Comment
Method declaration
Method invocation
Chunk
Conflicting content 
import javax.enterprise.event.Observes;
import javax.enterprise.event.Reception;
import javax.inject.Inject;
<<<<<<< HEAD:jbpm-services/droolsjbpm-knowledge-services/src/main/java/org/jbpm/task/wih/CDIHTWorkItemHandler.java
import org.droolsjbpm.services.api.SessionManager;
import org.droolsjbpm.services.impl.SessionManagerImpl;
import org.jboss.seam.transaction.Transactional;


import org.jbpm.task.utils.OnErrorAction;
import org.jbpm.task.Task;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.kie.runtime.process.WorkItem;
import org.kie.runtime.process.WorkItemManager;
=======
>>>>>>> e1a8bd63124a5e1723cf2861d338155dc249e7ce:jbpm-services/jbpm-human-task-workitems/src/main/java/org/jbpm/task/wih/CDIHTWorkItemHandler.java

import org.jboss.seam.transaction.Transactional;
import org.jbpm.shared.services.api.SessionManager;
Solution content 
import javax.inject.Inject;

import org.jboss.seam.transaction.Transactional;
import org.jbpm.shared.services.api.ServicesSessionManager;
import org.jbpm.shared.services.api.SessionManager;
File
CDIHTWorkItemHandler.java
Developer's decision
Version 2
Kind of conflict
Import
Chunk
Conflicting content 
import org.jbpm.task.impl.factories.TaskFactory;
import org.jbpm.task.utils.OnErrorAction;
import org.kie.runtime.KieSession;
<<<<<<< HEAD:jbpm-services/droolsjbpm-knowledge-services/src/main/java/org/jbpm/task/wih/CDIHTWorkItemHandler.java
=======
import org.kie.runtime.process.WorkItem;
import org.kie.runtime.process.WorkItemManager;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
>>>>>>> e1a8bd63124a5e1723cf2861d338155dc249e7ce:jbpm-services/jbpm-human-task-workitems/src/main/java/org/jbpm/task/wih/CDIHTWorkItemHandler.java


@ApplicationScoped
Solution content 
import org.jbpm.task.impl.factories.TaskFactory;
import org.jbpm.task.utils.OnErrorAction;
import org.kie.runtime.KieSession;
import org.kie.runtime.process.WorkItem;
import org.kie.runtime.process.WorkItemManager;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


@ApplicationScoped
File
CDIHTWorkItemHandler.java
Developer's decision
Version 2
Kind of conflict
Import