• Home
• org.ow2.bonita
• bonita-server
• 5.9.1
• source code
• QueryRuntimeAPIImpl.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.ow2.bonita.facade.impl.QueryRuntimeAPIImpl Maven / Gradle / Ivy

/**
 * Copyright (C) 2007  Bull S. A. S.
 * Bull, Rue Jean Jaures, B.P.68, 78340, Les Clayes-sous-Bois
 * This library is free software; you can redistribute it and/or modify it under the terms
 * of the GNU Lesser General Public License as published by the Free Software Foundation
 * version 2.1 of the License.
 * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU Lesser General Public License for more details.
 * You should have received a copy of the GNU Lesser General Public License along with this
 * program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
 * Floor, Boston, MA  02110-1301, USA.
 * 
 * Modified by Charles Souillard, Matthieu Chaffotte, Nicolas Chabanoles, Elias Ricken de Medeiros
 *  - BonitaSoft S.A.
 **/
package org.ow2.bonita.facade.impl;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.logging.Level;

import javax.xml.parsers.ParserConfigurationException;
import javax.xml.xpath.XPath;
import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathExpressionException;
import javax.xml.xpath.XPathFactory;

import org.ow2.bonita.facade.QueryRuntimeAPI;
import org.ow2.bonita.facade.def.InternalProcessDefinition;
import org.ow2.bonita.facade.exception.ActivityNotFoundException;
import org.ow2.bonita.facade.exception.DocumentNotFoundException;
import org.ow2.bonita.facade.exception.EventNotFoundException;
import org.ow2.bonita.facade.exception.InstanceNotFoundException;
import org.ow2.bonita.facade.exception.TaskNotFoundException;
import org.ow2.bonita.facade.exception.VariableNotFoundException;
import org.ow2.bonita.facade.identity.impl.GroupImpl;
import org.ow2.bonita.facade.identity.impl.RoleImpl;
import org.ow2.bonita.facade.identity.impl.UserImpl;
import org.ow2.bonita.facade.paging.ActivityInstanceCriterion;
import org.ow2.bonita.facade.paging.ProcessInstanceCriterion;
import org.ow2.bonita.facade.privilege.Rule.RuleType;
import org.ow2.bonita.facade.runtime.ActivityInstance;
import org.ow2.bonita.facade.runtime.ActivityState;
import org.ow2.bonita.facade.runtime.AttachmentInstance;
import org.ow2.bonita.facade.runtime.CatchingEvent;
import org.ow2.bonita.facade.runtime.CatchingEvent.Position;
import org.ow2.bonita.facade.runtime.CatchingEvent.Type;
import org.ow2.bonita.facade.runtime.Comment;
import org.ow2.bonita.facade.runtime.Document;
import org.ow2.bonita.facade.runtime.InstanceState;
import org.ow2.bonita.facade.runtime.ProcessInstance;
import org.ow2.bonita.facade.runtime.TaskInstance;
import org.ow2.bonita.facade.runtime.VariableUpdate;
import org.ow2.bonita.facade.runtime.impl.ActivityInstanceImpl;
import org.ow2.bonita.facade.runtime.impl.AttachmentInstanceImpl;
import org.ow2.bonita.facade.runtime.impl.CaseImpl;
import org.ow2.bonita.facade.runtime.impl.CatchingEventImpl;
import org.ow2.bonita.facade.runtime.impl.InternalActivityInstance;
import org.ow2.bonita.facade.runtime.impl.InternalProcessInstance;
import org.ow2.bonita.facade.runtime.impl.ProcessInstanceImpl;
import org.ow2.bonita.facade.uuid.ActivityInstanceUUID;
import org.ow2.bonita.facade.uuid.CatchingEventUUID;
import org.ow2.bonita.facade.uuid.DocumentUUID;
import org.ow2.bonita.facade.uuid.ProcessDefinitionUUID;
import org.ow2.bonita.facade.uuid.ProcessInstanceUUID;
import org.ow2.bonita.light.LightActivityInstance;
import org.ow2.bonita.light.LightProcessDefinition;
import org.ow2.bonita.light.LightProcessInstance;
import org.ow2.bonita.light.LightTaskInstance;
import org.ow2.bonita.light.impl.LightActivityInstanceImpl;
import org.ow2.bonita.light.impl.LightProcessDefinitionImpl;
import org.ow2.bonita.light.impl.LightProcessInstanceImpl;
import org.ow2.bonita.runtime.event.EventConstants;
import org.ow2.bonita.runtime.event.Job;
import org.ow2.bonita.runtime.model.Execution;
import org.ow2.bonita.search.DocumentResult;
import org.ow2.bonita.search.DocumentSearchBuilder;
import org.ow2.bonita.search.SearchQueryBuilder;
import org.ow2.bonita.search.index.Index;
import org.ow2.bonita.services.DocumentationManager;
import org.ow2.bonita.services.EventService;
import org.ow2.bonita.services.Querier;
import org.ow2.bonita.util.BonitaRuntimeException;
import org.ow2.bonita.util.CopyTool;
import org.ow2.bonita.util.DateUtil;
import org.ow2.bonita.util.DocumentService;
import org.ow2.bonita.util.EnvTool;
import org.ow2.bonita.util.ExceptionManager;
import org.ow2.bonita.util.Misc;
import org.ow2.bonita.util.TransientData;
import org.xml.sax.SAXException;

/**
 * @author Pierre Vigneras
 */
public class QueryRuntimeAPIImpl implements QueryRuntimeAPI {

  private final String queryList;

  protected QueryRuntimeAPIImpl(final String queryList) {
    this.queryList = queryList;
  }

  private String getQueryList() {
    return queryList;
  }

  @Override
  public int getNumberOfParentProcessInstances() {
    final boolean access = EnvTool.isRestrictedApplicationAcces();
    int count = 0;
    if (access) {
      final String applicationName = EnvTool.getApplicationAccessName();
      final Set visibleProcessUUIDs = FacadeUtil.getAllowedProcessUUIDsFor(applicationName,
          RuleType.PROCESS_READ);
      if (visibleProcessUUIDs != null) {
        count = EnvTool.getAllQueriers(getQueryList()).getNumberOfParentProcessInstances(visibleProcessUUIDs);
      }
    } else {
      count = EnvTool.getAllQueriers(getQueryList()).getNumberOfParentProcessInstances();
    }
    return count;
  }

  @Override
  public int getNumberOfParentProcessInstances(final Set processDefinitionUUIDs) {
    if (processDefinitionUUIDs == null || processDefinitionUUIDs.isEmpty()) {
      return 0;
    }

    int count = 0;
    final boolean access = EnvTool.isRestrictedApplicationAcces();
    if (access) {
      final String applicationName = EnvTool.getApplicationAccessName();
      if (applicationName != null) {
        Set visibleProcessUUIDs = FacadeUtil.getAllowedProcessUUIDsFor(applicationName,
            RuleType.PROCESS_READ);
        if (visibleProcessUUIDs == null || visibleProcessUUIDs.isEmpty()) {
          visibleProcessUUIDs = new HashSet();
        }
        visibleProcessUUIDs.retainAll(processDefinitionUUIDs);
        if (visibleProcessUUIDs != null && !visibleProcessUUIDs.isEmpty()) {
          count = EnvTool.getAllQueriers(getQueryList()).getNumberOfParentProcessInstances(visibleProcessUUIDs);
        }
      }
    } else {
      count = EnvTool.getAllQueriers(getQueryList()).getNumberOfParentProcessInstances(processDefinitionUUIDs);
    }
    return count;
  }

  @Override
  public int getNumberOfParentProcessInstancesExcept(final Set exceptions) {
    if (exceptions == null || exceptions.isEmpty()) {
      return getNumberOfParentProcessInstances();
    }

    int count = 0;
    final boolean access = EnvTool.isRestrictedApplicationAcces();
    if (access) {
      final String applicationName = EnvTool.getApplicationAccessName();
      if (applicationName != null) {
        Set visibleProcessUUIDs = FacadeUtil.getAllowedProcessUUIDsFor(applicationName,
            RuleType.PROCESS_READ);
        if (visibleProcessUUIDs == null || visibleProcessUUIDs.isEmpty()) {
          visibleProcessUUIDs = new HashSet();
        }
        visibleProcessUUIDs.removeAll(exceptions);
        if (visibleProcessUUIDs != null && !visibleProcessUUIDs.isEmpty()) {
          count = EnvTool.getAllQueriers(getQueryList()).getNumberOfParentProcessInstances(visibleProcessUUIDs);
        }
      }
    } else {
      final Set visibleProcessUUIDs = EnvTool.getAllQueriers(getQueryList())
          .getAllProcessDefinitionUUIDsExcept(exceptions);
      if (visibleProcessUUIDs != null && !visibleProcessUUIDs.isEmpty()) {
        count = EnvTool.getAllQueriers(getQueryList()).getNumberOfParentProcessInstances(visibleProcessUUIDs);
      }
    }
    return count;
  }

  @Override
  public int getNumberOfProcessInstances() {
    final boolean access = EnvTool.isRestrictedApplicationAcces();
    int count = 0;
    if (access) {
      final String applicationName = EnvTool.getApplicationAccessName();
      final Set visibleProcessUUIDs = FacadeUtil.getAllowedProcessUUIDsFor(applicationName,
          RuleType.PROCESS_READ);
      if (visibleProcessUUIDs != null && !visibleProcessUUIDs.isEmpty()) {
        count = EnvTool.getAllQueriers(getQueryList()).getNumberOfProcessInstances(visibleProcessUUIDs);
      }
    } else {
      count = EnvTool.getAllQueriers(getQueryList()).getNumberOfProcessInstances();
    }
    return count;
  }

  @Override
  public ProcessInstance getProcessInstance(final ProcessInstanceUUID instanceUUID) throws InstanceNotFoundException {
    final InternalProcessInstance instance = getInternalProcessInstanceWithAttachments(instanceUUID);
    if (instance == null) {
      throw new InstanceNotFoundException("bai_QRAPII_1", instanceUUID);
    }
    return new ProcessInstanceImpl(instance);
  }

  @Override
  public LightProcessInstance getLightProcessInstance(final ProcessInstanceUUID instanceUUID)
      throws InstanceNotFoundException {
    final ProcessInstance result = getInternalProcessInstanceWithoutAttachements(instanceUUID);
    if (result == null) {
      throw new InstanceNotFoundException("bai_QRAPII_1", instanceUUID);
    }
    return new LightProcessInstanceImpl(result);
  }

  private InternalProcessInstance getInternalProcessInstanceWithAttachments(final ProcessInstanceUUID instanceUUID)
      throws InstanceNotFoundException {
    final InternalProcessInstance internalProcessInstance = getInternalProcessInstanceWithoutAttachements(instanceUUID);
    if (internalProcessInstance != null && internalProcessInstance.getNbOfAttachments() > 0) {
      bindAttachementsToInternalProcessInstance(internalProcessInstance);
    }
    return internalProcessInstance;
  }

  private void bindAttachementsToInternalProcessInstance(final InternalProcessInstance internalProcessInstance) {
    if (internalProcessInstance != null) {
      final int nbOfAttachments = internalProcessInstance.getNbOfAttachments();
      if (nbOfAttachments > 0) {
        final DocumentationManager manager = EnvTool.getDocumentationManager();
        final List allAttachmentVersions = DocumentService.getAllAttachmentVersions(manager,
            internalProcessInstance.getProcessInstanceUUID());
        for (final AttachmentInstance attachmentInstance : allAttachmentVersions) {
          internalProcessInstance.addAttachment(attachmentInstance);
        }
      }
    }
  }

  private InternalProcessInstance getInternalProcessInstanceWithoutAttachements(final ProcessInstanceUUID instanceUUID) {
    FacadeUtil.checkArgsNotNull(instanceUUID);
    final Querier querier = EnvTool.getAllQueriers(getQueryList());
    return querier.getProcessInstance(instanceUUID);
  }

  @Override
  public Set getProcessInstances() {
    final Set processes = getInternalProcessInstancesWithAttachements();
    final Set result = new HashSet();
    for (final ProcessInstance record : processes) {
      result.add(new ProcessInstanceImpl(record));
    }
    return result;
  }

  @Override
  public Set getLightProcessInstances() {
    final Set processes = getInternalProcessInstancesWithoutAttachements();
    final Set result = new HashSet();
    for (final ProcessInstance record : processes) {
      result.add(new LightProcessInstanceImpl(record));
    }
    return result;
  }

  private Set getInternalProcessInstancesWithoutAttachements() {
    final boolean access = EnvTool.isRestrictedApplicationAcces();
    Set processes = new HashSet();
    if (access) {
      final String applicationName = EnvTool.getApplicationAccessName();
      if (applicationName != null) {
        final Set visibleProcessUUIDs = FacadeUtil.getAllowedProcessUUIDsFor(applicationName,
            RuleType.PROCESS_READ);
        if (visibleProcessUUIDs != null && !visibleProcessUUIDs.isEmpty()) {
          processes = EnvTool.getAllQueriers(getQueryList()).getProcessInstances(visibleProcessUUIDs);
        }
      }
    } else {
      processes = EnvTool.getAllQueriers(getQueryList()).getProcessInstances();
    }
    return processes;
  }

  private Set getInternalProcessInstancesWithAttachements() {
    final Set processes = getInternalProcessInstancesWithoutAttachements();
    bindAttachementsToInternalProcessInstances(processes);
    return processes;
  }

  private void bindAttachementsToInternalProcessInstances(final Set processes) {
    for (final InternalProcessInstance internalProcessInstance : processes) {
      bindAttachementsToInternalProcessInstance(internalProcessInstance);
    }
  }

  @Override
  public List getLightProcessInstances(final int fromIndex, final int pageSize) {
    final List result = new ArrayList();
    if (pageSize <= 0) {
      return result;
    }
    final boolean access = EnvTool.isRestrictedApplicationAcces();
    List processes = new ArrayList();
    if (access) {
      final String applicationName = EnvTool.getApplicationAccessName();
      if (applicationName != null) {
        final Set visibleProcessUUIDs = FacadeUtil.getAllowedProcessUUIDsFor(applicationName,
            RuleType.PROCESS_READ);
        if (visibleProcessUUIDs != null && !visibleProcessUUIDs.isEmpty()) {
          processes = EnvTool.getAllQueriers(getQueryList()).getProcessInstances(visibleProcessUUIDs, fromIndex,
              pageSize);
        }
      }
    } else {
      processes = EnvTool.getAllQueriers(getQueryList()).getProcessInstances(fromIndex, pageSize);
    }

    for (final ProcessInstance record : processes) {
      result.add(new LightProcessInstanceImpl(record));
    }
    return result;
  }

  @Override
  public List getLightProcessInstances(final int fromIndex, final int pageSize,
      final ProcessInstanceCriterion pagingCriterion) {
    final List result = new ArrayList();
    if (pageSize <= 0) {
      return result;
    }
    final boolean access = EnvTool.isRestrictedApplicationAcces();
    List processes = new ArrayList();
    if (access) {
      final String applicationName = EnvTool.getApplicationAccessName();
      if (applicationName != null) {
        final Set visibleProcessUUIDs = FacadeUtil.getAllowedProcessUUIDsFor(applicationName,
            RuleType.PROCESS_READ);
        if (visibleProcessUUIDs != null && !visibleProcessUUIDs.isEmpty()) {
          processes = EnvTool.getAllQueriers(getQueryList()).getProcessInstances(visibleProcessUUIDs, fromIndex,
              pageSize, pagingCriterion);
        }
      }
    } else {
      processes = EnvTool.getAllQueriers(getQueryList()).getProcessInstances(fromIndex, pageSize, pagingCriterion);
    }

    for (final ProcessInstance record : processes) {
      result.add(new LightProcessInstanceImpl(record));
    }
    return result;
  }

  @Override
  public List getLightParentProcessInstances(final int fromIndex, final int pageSize) {
    final List result = new ArrayList();
    if (pageSize <= 0) {
      return result;
    }
    final List records = EnvTool.getAllQueriers(getQueryList()).getParentProcessInstances(
        fromIndex, pageSize);
    for (final ProcessInstance record : records) {
      result.add(new LightProcessInstanceImpl(record));
    }
    return result;
  }

  @Override
  public List getLightParentProcessInstances(final Set processUUIDs,
      final int fromIndex, final int pageSize, final ProcessInstanceCriterion pagingCriterion) {
    Misc.checkArgsNotNull(processUUIDs);
    if (processUUIDs.isEmpty()) {
      return Collections.emptyList();
    }
    final List processes = getParentProcessInstances(processUUIDs, fromIndex, pageSize,
        pagingCriterion);

    final List result = new ArrayList();
    for (final ProcessInstance record : processes) {
      result.add(new LightProcessInstanceImpl(record));
    }
    return result;
  }

  private List getParentProcessInstances(final Set processUUIDs,
      final int startingIndex, final int pageSize, final ProcessInstanceCriterion pagingCriterion) {
    final boolean access = EnvTool.isRestrictedApplicationAcces();
    List processes = new ArrayList();
    if (access) {
      final String applicationName = EnvTool.getApplicationAccessName();
      if (applicationName != null) {
        Set visibleProcessUUIDs = FacadeUtil.getAllowedProcessUUIDsFor(applicationName,
            RuleType.PROCESS_READ);
        if (visibleProcessUUIDs == null || visibleProcessUUIDs.isEmpty()) {
          visibleProcessUUIDs = new HashSet();
        }
        visibleProcessUUIDs.retainAll(processUUIDs);
        if (visibleProcessUUIDs != null && !visibleProcessUUIDs.isEmpty()) {
          processes = EnvTool.getAllQueriers(getQueryList()).getParentProcessInstances(visibleProcessUUIDs,
              startingIndex, pageSize, pagingCriterion);
        }
      }
    } else {
      processes = EnvTool.getAllQueriers(getQueryList()).getParentProcessInstances(processUUIDs, startingIndex,
          pageSize, pagingCriterion);
    }
    return processes;
  }

  @Override
  public List getLightParentProcessInstancesExcept(final Set exceptions,
      final int fromIndex, final int pageSize, final ProcessInstanceCriterion pagingCriterion) {
    if (exceptions == null || exceptions.isEmpty()) {
      return getLightParentProcessInstances(fromIndex, pageSize, pagingCriterion);
    }

    final boolean access = EnvTool.isRestrictedApplicationAcces();
    List processes = new ArrayList();
    if (access) {
      final String applicationName = EnvTool.getApplicationAccessName();
      if (applicationName != null) {
        Set visibleProcessUUIDs = FacadeUtil.getAllowedProcessUUIDsFor(applicationName,
            RuleType.PROCESS_READ);
        if (visibleProcessUUIDs == null || visibleProcessUUIDs.isEmpty()) {
          visibleProcessUUIDs = new HashSet();
        }
        visibleProcessUUIDs.removeAll(exceptions);
        if (visibleProcessUUIDs != null && !visibleProcessUUIDs.isEmpty()) {
          processes = EnvTool.getAllQueriers(getQueryList()).getParentProcessInstances(visibleProcessUUIDs, fromIndex,
              pageSize, pagingCriterion);
        }
      }
    } else {
      processes = EnvTool.getAllQueriers(getQueryList()).getParentProcessInstancesExcept(exceptions, fromIndex,
          pageSize, pagingCriterion);
    }

    final List result = new ArrayList();
    for (final ProcessInstance record : processes) {
      result.add(new LightProcessInstanceImpl(record));
    }
    return result;
  }

  @Override
  public List getLightParentProcessInstances(final int fromIndex, final int pageSize,
      final ProcessInstanceCriterion pagingCriterion) {
    final List result = new ArrayList();
    if (pageSize <= 0) {
      return result;
    }
    final List records = EnvTool.getAllQueriers(getQueryList()).getParentProcessInstances(
        fromIndex, pageSize, pagingCriterion);
    for (final ProcessInstance record : records) {
      result.add(new LightProcessInstanceImpl(record));
    }
    return result;
  }

  @Override
  public Set getUserInstances() {
    final Set processes = getUserProcessInstances();
    // bind attachements from document service
    bindAttachementsToInternalProcessInstances(processes);

    final Set result = new HashSet();
    for (final ProcessInstance record : processes) {
      result.add(new ProcessInstanceImpl(record));
    }
    return result;
  }

  @Override
  public Set getLightUserInstances() {
    final Set processes = getUserProcessInstances();
    final Set result = new HashSet();
    for (final ProcessInstance record : processes) {
      result.add(new LightProcessInstanceImpl(record));
    }
    return result;
  }

  @Override
  public List getLightParentUserInstances(final int startingIndex, final int pageSize) {
    final List processes = getUserParentProcessInstances(startingIndex, pageSize);
    final List result = new ArrayList();
    for (final ProcessInstance record : processes) {
      result.add(new LightProcessInstanceImpl(record));
    }
    return result;
  }

  @Override
  public List getLightParentUserInstances(final int fromIndex, final int pageSize,
      final ProcessInstanceCriterion pagingCriterion) {
    final List processes = getUserParentProcessInstances(fromIndex, pageSize, pagingCriterion);
    final List result = new ArrayList();
    for (final ProcessInstance record : processes) {
      result.add(new LightProcessInstanceImpl(record));
    }
    return result;
  }

  @Override
  public List getLightParentProcessInstancesWithActiveUser(final String userId,
      final int fromIndex, final int pageSize) {
    final List processes = getParentProcessInstancesWithActiveUser(userId, fromIndex, pageSize);
    final List result = new ArrayList();
    for (final ProcessInstance record : processes) {
      result.add(new LightProcessInstanceImpl(record));
    }
    return result;
  }

  @Override
  public List getLightParentProcessInstancesWithActiveUser(final String userId,
      final int fromIndex, final int pageSize, final ProcessInstanceCriterion pagingCriterion) {
    final List processes = getParentProcessInstancesWithActiveUser(userId, fromIndex,
        pageSize, pagingCriterion);
    final List result = new ArrayList();
    for (final ProcessInstance record : processes) {
      result.add(new LightProcessInstanceImpl(record));
    }
    return result;
  }

  @Override
  public List getLightParentProcessInstancesWithActiveUserAndActivityInstanceExpectedEndDate(
      final String userId, final int remainingDays, final int fromIndex, final int pageSize) {
    final List processes = getParentProcessInstancesWithActiveUserAndActivityInstanceExpectedEndDate(
        userId, remainingDays, fromIndex, pageSize);
    final List result = new ArrayList();
    for (final ProcessInstance record : processes) {
      result.add(new LightProcessInstanceImpl(record));
    }
    return result;
  }

  @Override
  public List getLightParentProcessInstancesWithActiveUserAndActivityInstanceExpectedEndDate(
      final String userId, final int remainingDays, final int fromIndex, final int pageSize,
      final ProcessInstanceCriterion pagingCriterion) {
    final List processes = getParentProcessInstancesWithActiveUserAndActivityInstanceExpectedEndDate(
        userId, remainingDays, fromIndex, pageSize, pagingCriterion);
    final List result = new ArrayList();
    for (final ProcessInstance record : processes) {
      result.add(new LightProcessInstanceImpl(record));
    }
    return result;
  }

  @Override
  public List getLightParentProcessInstancesWithOverdueTasks(final String userId,
      final int fromIndex, final int pageSize) {
    final List processes = getParentProcessInstancesWithOverdueTasks(userId, fromIndex,
        pageSize, ProcessInstanceCriterion.DEFAULT);
    final List result = new ArrayList();
    for (final ProcessInstance record : processes) {
      result.add(new LightProcessInstanceImpl(record));
    }
    return result;
  }

  @Override
  public List getLightParentProcessInstancesWithOverdueTasks(final String userId,
      final int fromIndex, final int pageSize, final ProcessInstanceCriterion pagingCriterion) {
    final List processes = getParentProcessInstancesWithOverdueTasks(userId, fromIndex,
        pageSize, pagingCriterion);
    final List result = new ArrayList();
    for (final ProcessInstance record : processes) {
      result.add(new LightProcessInstanceImpl(record));
    }
    return result;
  }

  private List getParentProcessInstancesWithOverdueTasks(final String userId,
      final int fromIndex, final int pageSize, final ProcessInstanceCriterion pagingCriterion) {
    final boolean access = EnvTool.isRestrictedApplicationAcces();
    List processes = new ArrayList();
    final Date currentDate = new Date();
    if (access) {
      final String applicationName = EnvTool.getApplicationAccessName();
      if (applicationName != null) {
        final Set visibleProcessUUIDs = FacadeUtil.getAllowedProcessUUIDsFor(applicationName,
            RuleType.PROCESS_READ);
        if (visibleProcessUUIDs != null && !visibleProcessUUIDs.isEmpty()) {
          processes = EnvTool.getAllQueriers(getQueryList()).getParentProcessInstancesWithOverdueTasks(userId,
              currentDate, fromIndex, pageSize, visibleProcessUUIDs, pagingCriterion);
        }
      }
    } else {
      processes = EnvTool.getAllQueriers(getQueryList()).getParentProcessInstancesWithOverdueTasks(userId, currentDate,
          fromIndex, pageSize, pagingCriterion);
    }
    return processes;
  }

  private List getParentProcessInstancesWithOverdueTasks(final String userId,
      final int fromIndex, final int pageSize, final Set processUUIDs,
      final ProcessInstanceCriterion pagingCriterion) {
    final boolean access = EnvTool.isRestrictedApplicationAcces();
    List processes = new ArrayList();
    final Date currentDate = new Date();
    if (access) {
      final String applicationName = EnvTool.getApplicationAccessName();
      if (applicationName != null) {
        Set visibleProcessUUIDs = FacadeUtil.getAllowedProcessUUIDsFor(applicationName,
            RuleType.PROCESS_READ);
        if (visibleProcessUUIDs == null) {
          visibleProcessUUIDs = new HashSet();
        }
        visibleProcessUUIDs.retainAll(processUUIDs);
        if (visibleProcessUUIDs != null && !visibleProcessUUIDs.isEmpty()) {
          processes = EnvTool.getAllQueriers(getQueryList()).getParentProcessInstancesWithOverdueTasks(userId,
              currentDate, fromIndex, pageSize, visibleProcessUUIDs, pagingCriterion);
        }
      }
    } else {
      processes = EnvTool.getAllQueriers(getQueryList()).getParentProcessInstancesWithOverdueTasks(userId, currentDate,
          fromIndex, pageSize, processUUIDs, pagingCriterion);
    }
    return processes;
  }

  private List getParentProcessInstancesWithActiveUserAndActivityInstanceExpectedEndDate(
      final String userId, final int remainingDays, final int startingIndex, final int pageSize) {
    final boolean access = EnvTool.isRestrictedApplicationAcces();
    List processes = new ArrayList();
    final Date currentDate = new Date();
    final Date beginningOfTheDay = DateUtil.getBeginningOfTheDay(currentDate);
    final Date atRisk = DateUtil.backTo(beginningOfTheDay, -(remainingDays + 1));
    if (access) {
      final String applicationName = EnvTool.getApplicationAccessName();
      if (applicationName != null) {
        final Set visibleProcessUUIDs = FacadeUtil.getAllowedProcessUUIDsFor(applicationName,
            RuleType.PROCESS_READ);
        if (visibleProcessUUIDs != null && !visibleProcessUUIDs.isEmpty()) {
          processes = EnvTool.getAllQueriers(getQueryList())
              .getParentProcessInstancesWithActiveUserAndActivityInstanceExpectedEndDate(userId, currentDate, atRisk,
                  startingIndex, pageSize, visibleProcessUUIDs);
        }
      }
    } else {
      processes = EnvTool.getAllQueriers(getQueryList())
          .getParentProcessInstancesWithActiveUserAndActivityInstanceExpectedEndDate(userId, currentDate, atRisk,
              startingIndex, pageSize);
    }
    return processes;
  }

  private List getParentProcessInstancesWithActiveUserAndActivityInstanceExpectedEndDate(
      final String userId, final int remainingDays, final int startingIndex, final int pageSize,
      final ProcessInstanceCriterion pagingCriterion) {
    final boolean access = EnvTool.isRestrictedApplicationAcces();
    List processes = new ArrayList();
    final Date currentDate = new Date();
    final Date beginningOfTheDay = DateUtil.getBeginningOfTheDay(currentDate);
    final Date atRisk = DateUtil.backTo(beginningOfTheDay, -(remainingDays + 1));
    if (access) {
      final String applicationName = EnvTool.getApplicationAccessName();
      if (applicationName != null) {
        final Set visibleProcessUUIDs = FacadeUtil.getAllowedProcessUUIDsFor(applicationName,
            RuleType.PROCESS_READ);
        if (visibleProcessUUIDs != null && !visibleProcessUUIDs.isEmpty()) {
          processes = EnvTool.getAllQueriers(getQueryList())
              .getParentProcessInstancesWithActiveUserAndActivityInstanceExpectedEndDate(userId, currentDate, atRisk,
                  startingIndex, pageSize, visibleProcessUUIDs, pagingCriterion);
        }
      }
    } else {
      processes = EnvTool.getAllQueriers(getQueryList())
          .getParentProcessInstancesWithActiveUserAndActivityInstanceExpectedEndDate(userId, currentDate, atRisk,
              startingIndex, pageSize, pagingCriterion);
    }
    return processes;
  }

  private List getParentProcessInstancesWithActiveUserAndActivityInstanceExpectedEndDate(
      final String userId, final int remainingDays, final int startingIndex, final int pageSize,
      final Set processUUIDs) {
    final boolean access = EnvTool.isRestrictedApplicationAcces();
    List processes = new ArrayList();
    final Date currentDate = new Date();
    final Date beginningOfTheDay = DateUtil.getBeginningOfTheDay(currentDate);
    final Date atRisk = DateUtil.backTo(beginningOfTheDay, -(remainingDays + 1));
    if (access) {
      final String applicationName = EnvTool.getApplicationAccessName();
      if (applicationName != null) {
        Set visibleProcessUUIDs = FacadeUtil.getAllowedProcessUUIDsFor(applicationName,
            RuleType.PROCESS_READ);
        if (visibleProcessUUIDs == null) {
          visibleProcessUUIDs = new HashSet();
        }
        visibleProcessUUIDs.retainAll(processUUIDs);
        if (visibleProcessUUIDs != null && !visibleProcessUUIDs.isEmpty()) {
          processes = EnvTool.getAllQueriers(getQueryList())
              .getParentProcessInstancesWithActiveUserAndActivityInstanceExpectedEndDate(userId, currentDate, atRisk,
                  startingIndex, pageSize, visibleProcessUUIDs);
        }
      }
    } else {
      processes = EnvTool.getAllQueriers(getQueryList())
          .getParentProcessInstancesWithActiveUserAndActivityInstanceExpectedEndDate(userId, currentDate, atRisk,
              startingIndex, pageSize, processUUIDs);
    }
    return processes;
  }

  private List getParentProcessInstancesWithActiveUserAndActivityInstanceExpectedEndDate(
      final String userId, final int remainingDays, final int startingIndex, final int pageSize,
      final Set processUUIDs, final ProcessInstanceCriterion pagingCriterion) {
    final boolean access = EnvTool.isRestrictedApplicationAcces();
    List processes = new ArrayList();
    final Date currentDate = new Date();
    final Date beginningOfTheDay = DateUtil.getBeginningOfTheDay(currentDate);
    final Date atRisk = DateUtil.backTo(beginningOfTheDay, -(remainingDays + 1));
    if (access) {
      final String applicationName = EnvTool.getApplicationAccessName();
      if (applicationName != null) {
        Set visibleProcessUUIDs = FacadeUtil.getAllowedProcessUUIDsFor(applicationName,
            RuleType.PROCESS_READ);
        if (visibleProcessUUIDs == null) {
          visibleProcessUUIDs = new HashSet();
        }
        visibleProcessUUIDs.retainAll(processUUIDs);
        if (visibleProcessUUIDs != null && !visibleProcessUUIDs.isEmpty()) {
          processes = EnvTool.getAllQueriers(getQueryList())
              .getParentProcessInstancesWithActiveUserAndActivityInstanceExpectedEndDate(userId, currentDate, atRisk,
                  startingIndex, pageSize, visibleProcessUUIDs, pagingCriterion);
        }
      }
    } else {
      processes = EnvTool.getAllQueriers(getQueryList())
          .getParentProcessInstancesWithActiveUserAndActivityInstanceExpectedEndDate(userId, currentDate, atRisk,
              startingIndex, pageSize, processUUIDs, pagingCriterion);
    }
    return processes;
  }

  @Override
  public List getLightParentProcessInstancesWithInvolvedUser(final String userId,
      final int fromIndex, final int pageSize) {
    final List processes = getParentProcessInstancesWithInvolvedUser(userId, fromIndex,
        pageSize);
    final List result = new ArrayList();
    for (final ProcessInstance record : processes) {
      result.add(new LightProcessInstanceImpl(record));
    }
    return result;
  }

  @Override
  public List getLightParentProcessInstancesWithInvolvedUser(final String userId,
      final int fromIndex, final int pageSize, final ProcessInstanceCriterion pagingCriterion) {
    final List processes = getParentProcessInstancesWithInvolvedUser(userId, fromIndex,
        pageSize, pagingCriterion);
    final List result = new ArrayList();
    for (final ProcessInstance record : processes) {
      result.add(new LightProcessInstanceImpl(record));
    }
    return result;
  }

  @Override
  public List getLightParentProcessInstancesWithInvolvedUser(final String userId,
      final int fromIndex, final int pageSize, final Set processUUIDs) {
    if (processUUIDs == null || processUUIDs.isEmpty()) {
      return Collections.emptyList();
    }
    final List internalProcesses = EnvTool.getAllQueriers(getQueryList())
        .getParentProcessInstancesWithInvolvedUser(userId, fromIndex, pageSize, processUUIDs);
    final List result = new ArrayList();
    for (final ProcessInstance record : internalProcesses) {
      result.add(new LightProcessInstanceImpl(record));
    }
    return result;
  }

  @Override
  public List getLightParentProcessInstancesWithInvolvedUser(final String userId,
      final int fromIndex, final int pageSize, final Set processUUIDs,
      final ProcessInstanceCriterion pagingCriterion) {
    if (processUUIDs == null || processUUIDs.isEmpty()) {
      return Collections.emptyList();
    }
    final List internalProcesses = EnvTool.getAllQueriers(getQueryList())
        .getParentProcessInstancesWithInvolvedUser(userId, fromIndex, pageSize, processUUIDs, pagingCriterion);

    final List result = new ArrayList();
    for (final ProcessInstance record : internalProcesses) {
      result.add(new LightProcessInstanceImpl(record));
    }
    return result;
  }

  @Override
  public Integer getNumberOfParentProcessInstancesWithActiveUser(final String userId) {
    final boolean access = EnvTool.isRestrictedApplicationAcces();
    if (access) {
      final String applicationName = EnvTool.getApplicationAccessName();
      if (applicationName != null) {
        final Set visibleProcessUUIDs = FacadeUtil.getAllowedProcessUUIDsFor(applicationName,
            RuleType.PROCESS_READ);
        if (visibleProcessUUIDs != null && !visibleProcessUUIDs.isEmpty()) {
          return EnvTool.getAllQueriers(getQueryList()).getNumberOfParentProcessInstancesWithActiveUser(userId,
              visibleProcessUUIDs);
        }
      }
      return 0;
    } else {
      return EnvTool.getAllQueriers(getQueryList()).getNumberOfParentProcessInstancesWithActiveUser(userId);
    }
  }

  @Override
  public Integer getNumberOfParentProcessInstancesWithActiveUserAndActivityInstanceExpectedEndDate(final String userId,
      final int remainingDays) {
    final boolean access = EnvTool.isRestrictedApplicationAcces();
    final Date currentDate = new Date();
    final Date beginningOfTheDay = DateUtil.getBeginningOfTheDay(currentDate);
    final Date atRisk = DateUtil.backTo(beginningOfTheDay, -(remainingDays + 1));
    if (access) {
      final String applicationName = EnvTool.getApplicationAccessName();
      if (applicationName != null) {
        final Set visibleProcessUUIDs = FacadeUtil.getAllowedProcessUUIDsFor(applicationName,
            RuleType.PROCESS_READ);
        if (visibleProcessUUIDs != null && !visibleProcessUUIDs.isEmpty()) {
          return EnvTool.getAllQueriers(getQueryList())
              .getNumberOfParentProcessInstancesWithActiveUserAndActivityInstanceExpectedEndDate(userId, currentDate,
                  atRisk, visibleProcessUUIDs);
        }
      }
      return 0;
    } else {
      return EnvTool.getAllQueriers(getQueryList())
          .getNumberOfParentProcessInstancesWithActiveUserAndActivityInstanceExpectedEndDate(userId, currentDate,
              atRisk);
    }
  }

  @Override
  public Integer getNumberOfParentProcessInstancesWithOverdueTasks(final String userId) {
    final boolean access = EnvTool.isRestrictedApplicationAcces();
    final Date currentDate = new Date();
    if (access) {
      final String applicationName = EnvTool.getApplicationAccessName();
      if (applicationName != null) {
        final Set visibleProcessUUIDs = FacadeUtil.getAllowedProcessUUIDsFor(applicationName,
            RuleType.PROCESS_READ);
        if (visibleProcessUUIDs != null && !visibleProcessUUIDs.isEmpty()) {
          return EnvTool.getAllQueriers(getQueryList()).getNumberOfParentProcessInstancesWithOverdueTasks(userId,
              currentDate, visibleProcessUUIDs);
        }
      }
      return 0;
    } else {
      return EnvTool.getAllQueriers(getQueryList()).getNumberOfParentProcessInstancesWithOverdueTasks(userId,
          currentDate);
    }
  }

  @Override
  public Integer getNumberOfParentProcessInstancesWithInvolvedUser(final String userId) {
    final boolean access = EnvTool.isRestrictedApplicationAcces();
    if (access) {
      final String applicationName = EnvTool.getApplicationAccessName();
      if (applicationName != null) {
        final Set visibleProcessUUIDs = FacadeUtil.getAllowedProcessUUIDsFor(applicationName,
            RuleType.PROCESS_READ);
        if (visibleProcessUUIDs != null && !visibleProcessUUIDs.isEmpty()) {
          return EnvTool.getAllQueriers(getQueryList()).getNumberOfParentProcessInstancesWithInvolvedUser(userId,
              visibleProcessUUIDs);
        }
      }
      return 0;
    } else {
      return EnvTool.getAllQueriers(getQueryList()).getNumberOfParentProcessInstancesWithInvolvedUser(userId);
    }
  }

  @Override
  public Integer getNumberOfParentProcessInstancesWithInvolvedUserAndCategory(final String userId, final String category) {
    final boolean access = EnvTool.isRestrictedApplicationAcces();
    final Set targetedProcesses = EnvTool.getAllQueriers(getQueryList())
        .getProcessUUIDsFromCategory(category);
    if (access) {
      final String applicationName = EnvTool.getApplicationAccessName();
      if (applicationName != null) {
        final Set visibleProcessUUIDs = FacadeUtil.getAllowedProcessUUIDsFor(applicationName,
            RuleType.PROCESS_READ);
        visibleProcessUUIDs.retainAll(targetedProcesses);
        if (!visibleProcessUUIDs.isEmpty()) {
          return EnvTool.getAllQueriers(getQueryList()).getNumberOfParentProcessInstancesWithInvolvedUser(userId,
              visibleProcessUUIDs);
        }
      }
      return 0;
    } else {
      return EnvTool.getAllQueriers(getQueryList()).getNumberOfParentProcessInstancesWithInvolvedUser(userId,
          targetedProcesses);
    }
  }

  @Override
  public Integer getNumberOfParentProcessInstancesWithStartedBy(final String userId) {
    final boolean access = EnvTool.isRestrictedApplicationAcces();
    if (access) {
      final String applicationName = EnvTool.getApplicationAccessName();
      if (applicationName != null) {
        final Set visibleProcessUUIDs = FacadeUtil.getAllowedProcessUUIDsFor(applicationName,
            RuleType.PROCESS_READ);
        if (visibleProcessUUIDs != null && !visibleProcessUUIDs.isEmpty()) {
          return EnvTool.getAllQueriers(getQueryList()).getNumberOfParentProcessInstancesWithStartedBy(userId,
              visibleProcessUUIDs);
        }
      }
      return 0;
    } else {
      return EnvTool.getAllQueriers(getQueryList()).getNumberOfParentProcessInstancesWithStartedBy(userId);
    }
  }

  private List getParentProcessInstancesWithActiveUser(final String userId,
      final int startingIndex, final int pageSize) {
    final boolean access = EnvTool.isRestrictedApplicationAcces();
    List processes = new ArrayList();
    if (access) {
      final String applicationName = EnvTool.getApplicationAccessName();
      if (applicationName != null) {
        final Set visibleProcessUUIDs = FacadeUtil.getAllowedProcessUUIDsFor(applicationName,
            RuleType.PROCESS_READ);
        if (visibleProcessUUIDs != null && !visibleProcessUUIDs.isEmpty()) {
          processes = EnvTool.getAllQueriers(getQueryList()).getParentProcessInstancesWithActiveUser(userId,
              startingIndex, pageSize, visibleProcessUUIDs);
        }
      }
    } else {
      processes = EnvTool.getAllQueriers(getQueryList()).getParentProcessInstancesWithActiveUser(userId, startingIndex,
          pageSize);
    }
    return processes;
  }

  private List getParentProcessInstancesWithActiveUser(final String userId,
      final int startingIndex, final int pageSize, final ProcessInstanceCriterion pagingCriterion) {
    final boolean access = EnvTool.isRestrictedApplicationAcces();
    List processes = new ArrayList();
    if (access) {
      final String applicationName = EnvTool.getApplicationAccessName();
      if (applicationName != null) {
        final Set visibleProcessUUIDs = FacadeUtil.getAllowedProcessUUIDsFor(applicationName,
            RuleType.PROCESS_READ);
        if (visibleProcessUUIDs != null && !visibleProcessUUIDs.isEmpty()) {
          processes = EnvTool.getAllQueriers(getQueryList()).getParentProcessInstancesWithActiveUser(userId,
              startingIndex, pageSize, visibleProcessUUIDs, pagingCriterion);
        }
      }
    } else {
      processes = EnvTool.getAllQueriers(getQueryList()).getParentProcessInstancesWithActiveUser(userId, startingIndex,
          pageSize, pagingCriterion);
    }
    return processes;
  }

  private List getParentProcessInstancesWithActiveUser(final String userId,
      final int startingIndex, final int pageSize, final Set processUUIDs) {
    final boolean access = EnvTool.isRestrictedApplicationAcces();
    List processes = new ArrayList();
    if (access) {
      final String applicationName = EnvTool.getApplicationAccessName();
      if (applicationName != null) {
        Set visibleProcessUUIDs = FacadeUtil.getAllowedProcessUUIDsFor(applicationName,
            RuleType.PROCESS_READ);
        if (visibleProcessUUIDs == null || visibleProcessUUIDs.isEmpty()) {
          visibleProcessUUIDs = new HashSet();
        }
        visibleProcessUUIDs.retainAll(processUUIDs);
        if (visibleProcessUUIDs != null && !visibleProcessUUIDs.isEmpty()) {
          processes = EnvTool.getAllQueriers(getQueryList()).getParentProcessInstancesWithActiveUser(userId,
              startingIndex, pageSize, visibleProcessUUIDs);
        }
      }
    } else {
      processes = EnvTool.getAllQueriers(getQueryList()).getParentProcessInstancesWithActiveUser(userId, startingIndex,
          pageSize, processUUIDs);
    }
    return processes;
  }

  private List getParentProcessInstancesWithActiveUser(final String userId,
      final int startingIndex, final int pageSize, final Set processUUIDs,
      final ProcessInstanceCriterion pagingCriterion) {
    final boolean access = EnvTool.isRestrictedApplicationAcces();
    List processes = new ArrayList();
    if (access) {
      final String applicationName = EnvTool.getApplicationAccessName();
      if (applicationName != null) {
        Set visibleProcessUUIDs = FacadeUtil.getAllowedProcessUUIDsFor(applicationName,
            RuleType.PROCESS_READ);
        if (visibleProcessUUIDs == null || visibleProcessUUIDs.isEmpty()) {
          visibleProcessUUIDs = new HashSet();
        }
        visibleProcessUUIDs.retainAll(processUUIDs);
        if (visibleProcessUUIDs != null && !visibleProcessUUIDs.isEmpty()) {
          processes = EnvTool.getAllQueriers(getQueryList()).getParentProcessInstancesWithActiveUser(userId,
              startingIndex, pageSize, visibleProcessUUIDs, pagingCriterion);
        }
      }
    } else {
      processes = EnvTool.getAllQueriers(getQueryList()).getParentProcessInstancesWithActiveUser(userId, startingIndex,
          pageSize, processUUIDs, pagingCriterion);
    }
    return processes;
  }

  private List getParentProcessInstancesWithInvolvedUser(final String userId,
      final int startingIndex, final int pageSize) {
    final boolean access = EnvTool.isRestrictedApplicationAcces();
    List processes = new ArrayList();
    if (access) {
      final String applicationName = EnvTool.getApplicationAccessName();
      if (applicationName != null) {
        final Set visibleProcessUUIDs = FacadeUtil.getAllowedProcessUUIDsFor(applicationName,
            RuleType.PROCESS_READ);
        if (visibleProcessUUIDs != null && !visibleProcessUUIDs.isEmpty()) {
          processes = EnvTool.getAllQueriers(getQueryList()).getParentProcessInstancesWithInvolvedUser(userId,
              startingIndex, pageSize, visibleProcessUUIDs);
        }
      }
    } else {
      processes = EnvTool.getAllQueriers(getQueryList()).getParentProcessInstancesWithInvolvedUser(userId,
          startingIndex, pageSize);
    }
    return processes;
  }

  private List getParentProcessInstancesWithInvolvedUser(final String userId,
      final int startingIndex, final int pageSize, final ProcessInstanceCriterion pagingCriterion) {
    final boolean access = EnvTool.isRestrictedApplicationAcces();
    List processes = new ArrayList();
    if (access) {
      final String applicationName = EnvTool.getApplicationAccessName();
      if (applicationName != null) {
        final Set visibleProcessUUIDs = FacadeUtil.getAllowedProcessUUIDsFor(applicationName,
            RuleType.PROCESS_READ);
        if (visibleProcessUUIDs != null && !visibleProcessUUIDs.isEmpty()) {
          processes = EnvTool.getAllQueriers(getQueryList()).getParentProcessInstancesWithInvolvedUser(userId,
              startingIndex, pageSize, visibleProcessUUIDs, pagingCriterion);
        }
      }
    } else {
      processes = EnvTool.getAllQueriers(getQueryList()).getParentProcessInstancesWithInvolvedUser(userId,
          startingIndex, pageSize, pagingCriterion);
    }
    return processes;
  }

  private List getUserParentProcessInstances(final int startingIndex, final int pageSize) {
    final boolean access = EnvTool.isRestrictedApplicationAcces();
    List processes = new ArrayList();
    if (access) {
      final String applicationName = EnvTool.getApplicationAccessName();
      if (applicationName != null) {
        final Set visibleProcessUUIDs = FacadeUtil.getAllowedProcessUUIDsFor(applicationName,
            RuleType.PROCESS_READ);
        if (visibleProcessUUIDs != null && !visibleProcessUUIDs.isEmpty()) {
          processes = EnvTool.getAllQueriers(getQueryList()).getParentUserInstances(EnvTool.getUserId(), startingIndex,
              pageSize, visibleProcessUUIDs);
        }
      }
    } else {
      processes = EnvTool.getAllQueriers(getQueryList()).getParentUserInstances(EnvTool.getUserId(), startingIndex,
          pageSize);
    }
    return processes;
  }

  private List getUserParentProcessInstances(final int startingIndex, final int pageSize,
      final ProcessInstanceCriterion pagingCriterion) {
    final boolean access = EnvTool.isRestrictedApplicationAcces();
    List processes = new ArrayList();
    if (access) {
      final String applicationName = EnvTool.getApplicationAccessName();
      if (applicationName != null) {
        final Set visibleProcessUUIDs = FacadeUtil.getAllowedProcessUUIDsFor(applicationName,
            RuleType.PROCESS_READ);
        if (visibleProcessUUIDs != null && !visibleProcessUUIDs.isEmpty()) {
          processes = EnvTool.getAllQueriers(getQueryList()).getParentUserInstances(EnvTool.getUserId(), startingIndex,
              pageSize, visibleProcessUUIDs, pagingCriterion);
        }
      }
    } else {
      processes = EnvTool.getAllQueriers(getQueryList()).getParentUserInstances(EnvTool.getUserId(), startingIndex,
          pageSize, pagingCriterion);
    }
    return processes;
  }

  private List getUserParentProcessInstances(final int startingIndex, final int pageSize,
      final Set processUUIDs) {
    final boolean access = EnvTool.isRestrictedApplicationAcces();
    List processes = new ArrayList();
    if (access) {
      final String applicationName = EnvTool.getApplicationAccessName();
      if (applicationName != null) {
        Set visibleProcessUUIDs = FacadeUtil.getAllowedProcessUUIDsFor(applicationName,
            RuleType.PROCESS_READ);
        if (visibleProcessUUIDs == null) {
          visibleProcessUUIDs = new HashSet();
        }
        visibleProcessUUIDs.retainAll(processUUIDs);
        if (visibleProcessUUIDs != null && !visibleProcessUUIDs.isEmpty()) {
          processes = EnvTool.getAllQueriers(getQueryList()).getParentUserInstances(EnvTool.getUserId(), startingIndex,
              pageSize, visibleProcessUUIDs);
        }
      }
    } else {
      processes = EnvTool.getAllQueriers(getQueryList()).getParentUserInstances(EnvTool.getUserId(), startingIndex,
          pageSize, processUUIDs);
    }
    return processes;
  }

  private List getUserParentProcessInstances(final int startingIndex, final int pageSize,
      final Set processUUIDs, final ProcessInstanceCriterion pagingCriterion) {
    final boolean access = EnvTool.isRestrictedApplicationAcces();
    List processes = new ArrayList();
    if (access) {
      final String applicationName = EnvTool.getApplicationAccessName();
      if (applicationName != null) {
        Set visibleProcessUUIDs = FacadeUtil.getAllowedProcessUUIDsFor(applicationName,
            RuleType.PROCESS_READ);
        if (visibleProcessUUIDs == null) {
          visibleProcessUUIDs = new HashSet();
        }
        visibleProcessUUIDs.retainAll(processUUIDs);
        if (visibleProcessUUIDs != null && !visibleProcessUUIDs.isEmpty()) {
          processes = EnvTool.getAllQueriers(getQueryList()).getParentUserInstances(EnvTool.getUserId(), startingIndex,
              pageSize, visibleProcessUUIDs, pagingCriterion);
        }
      }
    } else {
      processes = EnvTool.getAllQueriers(getQueryList()).getParentUserInstances(EnvTool.getUserId(), startingIndex,
          pageSize, processUUIDs, pagingCriterion);
    }
    return processes;
  }

  private Set getUserProcessInstances() {
    final boolean access = EnvTool.isRestrictedApplicationAcces();
    Set processes = new HashSet();
    if (access) {
      final String applicationName = EnvTool.getApplicationAccessName();
      if (applicationName != null) {
        final Set visibleProcessUUIDs = FacadeUtil.getAllowedProcessUUIDsFor(applicationName,
            RuleType.PROCESS_READ);
        if (visibleProcessUUIDs != null && !visibleProcessUUIDs.isEmpty()) {
          processes = EnvTool.getAllQueriers(getQueryList()).getUserInstances(EnvTool.getUserId(), visibleProcessUUIDs);
        }
      }
    } else {
      processes = EnvTool.getAllQueriers(getQueryList()).getUserInstances(EnvTool.getUserId());
    }
    return processes;
  }

  @Override
  public Set getProcessInstances(final Collection instanceUUIDs) {
    final Set result = new HashSet();
    if (instanceUUIDs == null || instanceUUIDs.isEmpty()) {
      return result;
    }
    for (final InternalProcessInstance record : EnvTool.getAllQueriers(getQueryList()).getProcessInstances(
        instanceUUIDs)) {
      bindAttachementsToInternalProcessInstance(record);
      result.add(new ProcessInstanceImpl(record));
    }
    return result;
  }

  @Override
  public Set getLightProcessInstances(final Collection instanceUUIDs) {
    final Set result = new HashSet();
    if (instanceUUIDs == null || instanceUUIDs.isEmpty()) {
      return result;
    }
    for (final ProcessInstance record : EnvTool.getAllQueriers(getQueryList()).getProcessInstances(instanceUUIDs)) {
      result.add(new LightProcessInstanceImpl(record));
    }
    return result;
  }

  @Override
  public List getLightProcessInstances(final Collection instanceUUIDs,
      final int fromIndex, final int pageSize) {
    final List result = new ArrayList();
    if (pageSize <= 0) {
      return result;
    }
    if (instanceUUIDs == null || instanceUUIDs.isEmpty()) {
      return result;
    }
    for (final ProcessInstance record : EnvTool.getAllQueriers(getQueryList()).getProcessInstances(instanceUUIDs,
        fromIndex, pageSize)) {
      result.add(new LightProcessInstanceImpl(record));
    }
    return result;
  }

  @Override
  public List getLightProcessInstances(final Set instanceUUIDs,
      final int fromIndex, final int pageSize, final ProcessInstanceCriterion pagingCriterion) {
    final List result = new ArrayList();
    if (pageSize <= 0) {
      return result;
    }
    if (instanceUUIDs == null || instanceUUIDs.isEmpty()) {
      return result;
    }
    for (final ProcessInstance record : EnvTool.getAllQueriers(getQueryList()).getProcessInstancesWithInstanceUUIDs(
        instanceUUIDs, fromIndex, pageSize, pagingCriterion)) {
      result.add(new LightProcessInstanceImpl(record));
    }
    return result;
  }

  @Override
  public Set getProcessInstancesWithTaskState(final Collection activityStates) {
    final Set result = new HashSet();
    if (activityStates == null || activityStates.isEmpty()) {
      return result;
    }

    final boolean access = EnvTool.isRestrictedApplicationAcces();
    Set processes = new HashSet();
    if (access) {
      final String applicationName = EnvTool.getApplicationAccessName();
      if (applicationName != null) {
        final Set visibleProcessUUIDs = FacadeUtil.getAllowedProcessUUIDsFor(applicationName,
            RuleType.PROCESS_READ);
        if (visibleProcessUUIDs != null && !visibleProcessUUIDs.isEmpty()) {
          processes = EnvTool.getAllQueriers(getQueryList()).getProcessInstancesWithTaskState(activityStates,
              visibleProcessUUIDs);
        }
      }
    } else {
      processes = EnvTool.getAllQueriers(getQueryList()).getProcessInstancesWithTaskState(activityStates);
    }
    for (final InternalProcessInstance record : processes) {
      bindAttachementsToInternalProcessInstance(record);
      result.add(new ProcessInstanceImpl(record));
    }
    return result;
  }

  @Override
  public Set getProcessInstancesWithInstanceStates(final Collection instanceStates) {
    Misc.checkArgsNotNull(instanceStates);
    if (instanceStates.isEmpty()) {
      throw new IllegalArgumentException(ExceptionManager.getInstance().getMessage("bai_QRAPII_15"));
    }
    final Set result = new HashSet();
    final boolean access = EnvTool.isRestrictedApplicationAcces();
    Set processes = new HashSet();
    if (access) {
      final String applicationName = EnvTool.getApplicationAccessName();
      if (applicationName != null) {
        final Set visibleProcessUUIDs = FacadeUtil.getAllowedProcessUUIDsFor(applicationName,
            RuleType.PROCESS_READ);
        if (visibleProcessUUIDs != null && !visibleProcessUUIDs.isEmpty()) {
          processes = EnvTool.getAllQueriers(getQueryList()).getProcessInstancesWithInstanceStates(instanceStates,
              visibleProcessUUIDs);
        }
      }
    } else {
      processes = EnvTool.getAllQueriers(getQueryList()).getProcessInstancesWithInstanceStates(instanceStates);
    }
    for (final InternalProcessInstance record : processes) {
      bindAttachementsToInternalProcessInstance(record);
      result.add(new ProcessInstanceImpl(record));
    }
    return result;
  }

  @Override
  public Set getProcessInstances(final ProcessDefinitionUUID processUUID) {
    final Set result = new HashSet();
    for (final InternalProcessInstance record : EnvTool.getAllQueriers(getQueryList()).getProcessInstances(processUUID)) {
      bindAttachementsToInternalProcessInstance(record);
      result.add(new ProcessInstanceImpl(record));
    }
    return result;
  }

  @Override
  public Set getLightProcessInstances(final ProcessDefinitionUUID processUUID) {
    final Set result = new HashSet();
    for (final ProcessInstance record : EnvTool.getAllQueriers(getQueryList()).getProcessInstances(processUUID)) {
      result.add(new LightProcessInstanceImpl(record));
    }
    return result;
  }

  @Override
  public Set getLightWeightProcessInstances(final Set processUUIDs) {
    final Set result = new HashSet();
    for (final ProcessInstance record : EnvTool.getAllQueriers(getQueryList()).getProcessInstances(processUUIDs)) {
      result.add(new LightProcessInstanceImpl(record));
    }
    return result;
  }

  public ActivityInstance getActivityInstance(final ProcessInstanceUUID instanceUUID, final String activityId,
      final String iterationId, final String activityInstanceId, final String loopId) throws ActivityNotFoundException,
      InstanceNotFoundException {
    final ActivityInstance result = EnvTool.getAllQueriers(getQueryList()).getActivityInstance(instanceUUID,
        activityId, iterationId, activityInstanceId, loopId);
    if (result == null) {
      if (EnvTool.getAllQueriers(getQueryList()).getProcessInstance(instanceUUID) == null) {
        throw new InstanceNotFoundException("bai_QRAPII_2", instanceUUID);
      }
      throw new ActivityNotFoundException("bai_QRAPII_3", instanceUUID, activityId, iterationId);
    }
    return new ActivityInstanceImpl(result);
  }

  @Override
  public boolean canExecuteTask(final ActivityInstanceUUID taskUUID) throws TaskNotFoundException {
    final TaskInstance task = getTask(taskUUID);
    if (!task.getState().equals(ActivityState.READY)) {
      return false;
    }
    final String userId = EnvTool.getUserId();
    if (task.isTaskAssigned()) {
      return task.getTaskUser().equals(userId);
    }
    return task.getTaskCandidates().contains(userId);
  }

  @Override
  public Set getActivityInstances(final ProcessInstanceUUID instanceUUID) {
    final Set result = new HashSet();
    for (final ActivityInstance record : EnvTool.getAllQueriers(getQueryList()).getActivityInstances(instanceUUID)) {
      result.add(new ActivityInstanceImpl(record));
    }
    return result;
  }

  @Override
  public List getLightActivityInstancesFromRoot(final ProcessInstanceUUID rootInstanceUUID) {
    final List result = new ArrayList();
    final List activities = EnvTool.getAllQueriers(getQueryList())
        .getActivityInstancesFromRoot(rootInstanceUUID);
    for (final InternalActivityInstance record : activities) {
      result.add(new LightActivityInstanceImpl(record));
    }
    return result;
  }

  @Override
  public Map> getLightActivityInstancesFromRoot(
      final Set rootInstanceUUIDs, final ActivityState state) {
    final Map> result = new HashMap>();
    final List activities = EnvTool.getAllQueriers(getQueryList())
        .getActivityInstancesFromRoot(rootInstanceUUIDs, state);
    for (final InternalActivityInstance activity : activities) {
      final ProcessInstanceUUID instanceUUID = activity.getRootInstanceUUID();
      if (!result.containsKey(instanceUUID)) {
        result.put(instanceUUID, new ArrayList());
      }
      result.get(instanceUUID).add(new LightActivityInstanceImpl(activity));
    }
    return result;
  }

  @Override
  public Map> getLightActivityInstancesFromRoot(
      final Set rootInstanceUUIDs) {
    final Map> result = new HashMap>();
    final List activities = EnvTool.getAllQueriers(getQueryList())
        .getActivityInstancesFromRoot(rootInstanceUUIDs);
    for (final InternalActivityInstance activity : activities) {
      final ProcessInstanceUUID instanceUUID = activity.getRootInstanceUUID();
      if (!result.containsKey(instanceUUID)) {
        result.put(instanceUUID, new ArrayList());
      }
      result.get(instanceUUID).add(new LightActivityInstanceImpl(activity));
    }
    return result;
  }

  @Override
  public Map getLightLastUpdatedActivityInstanceFromRoot(
      final Set rootInstanceUUIDs, final boolean considerSystemTaks) {
    final Map result = new HashMap();
    final Map temp = EnvTool.getAllQueriers(getQueryList())
        .getLastUpdatedActivityInstanceFromRoot(rootInstanceUUIDs, considerSystemTaks);
    for (final Map.Entry entry : temp.entrySet()) {
      result.put(entry.getKey(), new LightActivityInstanceImpl(entry.getValue()));
    }
    return result;
  }

  @Override
  public List getLightTaskInstancesFromRoot(final ProcessInstanceUUID rootInstanceUUID) {
    final List result = new ArrayList();
    for (final InternalActivityInstance record : EnvTool.getAllQueriers(getQueryList()).getActivityInstancesFromRoot(
        rootInstanceUUID)) {
      if (record.isTask()) {
        result.add(new LightActivityInstanceImpl(record));
      }
    }
    return result;
  }

  @Override
  public Map> getLightTaskInstancesFromRoot(
      final Set rootInstanceUUIDs) {
    final Map> result = new HashMap>();
    for (final ProcessInstanceUUID instanceUUID : rootInstanceUUIDs) {
      result.put(instanceUUID, getLightTaskInstancesFromRoot(instanceUUID));
    }
    return result;
  }

  @Override
  public Set getLightActivityInstances(final ProcessInstanceUUID instanceUUID)
      throws InstanceNotFoundException {
    final Set result = new HashSet();
    final Set activities = EnvTool.getAllQueriers(getQueryList()).getActivityInstances(
        instanceUUID);
    for (final ActivityInstance record : activities) {
      result.add(new LightActivityInstanceImpl(record));
    }
    return result;
  }

  @Override
  public List getLightActivityInstances(final ProcessInstanceUUID instanceUUID,
      final int fromIdex, final int pageSize, final ActivityInstanceCriterion pagingCriterion)
      throws InstanceNotFoundException {
    final List result = new ArrayList();
    final List activities = EnvTool.getAllQueriers(getQueryList()).getActivityInstances(
        instanceUUID, fromIdex, pageSize, pagingCriterion);
    for (final ActivityInstance record : activities) {
      result.add(new LightActivityInstanceImpl(record));
    }
    return result;
  }

  @Override
  public Set getActivityInstances(final ProcessInstanceUUID instanceUUID, final String activityId)
      throws ActivityNotFoundException {
    final Set result = new HashSet();
    for (final ActivityInstance record : EnvTool.getAllQueriers(getQueryList()).getActivityInstances(instanceUUID)) {
      if (record.getActivityName().equals(activityId)) {
        result.add(new ActivityInstanceImpl(record));
      }
    }
    if (result.isEmpty()) {
      throw new ActivityNotFoundException("bai_QRAPII_4", instanceUUID, activityId);
    }
    return result;
  }

  @Override
  public Set getLightActivityInstances(final ProcessInstanceUUID instanceUUID,
      final String activityName) throws InstanceNotFoundException, ActivityNotFoundException {
    final Set result = new HashSet();
    final Set activities = EnvTool.getAllQueriers(getQueryList()).getActivityInstances(
        instanceUUID);
    for (final InternalActivityInstance record : activities) {
      if (record.getActivityName().equals(activityName)) {
        result.add(new LightActivityInstanceImpl(record));
      }
    }
    if (result.isEmpty()) {
      throw new ActivityNotFoundException("bai_QRAPII_4", instanceUUID, activityName);
    }
    return result;
  }

  @Override
  public Set getLightActivityInstances(final ProcessInstanceUUID instanceUUID,
      final String activityName, final String iterationId) {
    final Set result = new HashSet();
    final Set activities = EnvTool.getAllQueriers(getQueryList()).getActivityInstances(
        instanceUUID, activityName, iterationId);
    for (final ActivityInstance record : activities) {
      result.add(new LightActivityInstanceImpl(record));
    }
    return result;
  }

  @Override
  public Set getTasks(final ProcessInstanceUUID instanceUUID) {
    final Set result = new HashSet();
    for (final TaskInstance record : EnvTool.getAllQueriers(getQueryList()).getTaskInstances(instanceUUID)) {
      result.add(new ActivityInstanceImpl(record));
    }
    return result;
  }

  @Override
  public Set getLightTasks(final ProcessInstanceUUID instanceUUID) throws InstanceNotFoundException {
    final Set result = new HashSet();
    for (final TaskInstance record : EnvTool.getAllQueriers(getQueryList()).getTaskInstances(instanceUUID)) {
      result.add(new LightActivityInstanceImpl(record));
    }
    return result;
  }

  @Override
  public Set getLightTasks(final ProcessInstanceUUID instanceUUID, final Set taskNames) {
    final Set result = new HashSet();
    if (taskNames != null && !taskNames.isEmpty()) {
      for (final TaskInstance record : EnvTool.getAllQueriers(getQueryList()).getTaskInstances(instanceUUID, taskNames)) {
        result.add(new LightActivityInstanceImpl(record));
      }
    }
    return result;
  }

  @Override
  public Collection getTaskList(final ProcessInstanceUUID instanceUUID, final ActivityState taskState)
      throws InstanceNotFoundException {
    return getTaskListUser(instanceUUID, EnvTool.getUserId(), taskState);
  }

  @Override
  public Collection getLightTaskList(final ProcessInstanceUUID instanceUUID,
      final ActivityState taskState) throws InstanceNotFoundException {
    return getLightTaskListUser(instanceUUID, EnvTool.getUserId(), taskState);
  }

  @Override
  public Collection getTaskList(final ProcessInstanceUUID instanceUUID,
      final Collection taskStates) throws InstanceNotFoundException {
    FacadeUtil.checkArgsNotNull(instanceUUID, taskStates);
    final Collection todos = new HashSet();
    for (final ActivityState taskState : taskStates) {
      final Collection tasks = getTaskListUser(instanceUUID, EnvTool.getUserId(), taskState);
      if (tasks != null) {
        todos.addAll(tasks);
      }
    }
    return todos;
  }

  @Override
  public Collection getLightTaskList(final ProcessInstanceUUID instanceUUID,
      final Collection taskStates) throws InstanceNotFoundException {
    FacadeUtil.checkArgsNotNull(instanceUUID, taskStates);
    final Collection todos = new HashSet();
    for (final ActivityState taskState : taskStates) {
      final Collection tasks = getLightTaskListUser(instanceUUID, EnvTool.getUserId(), taskState);
      if (tasks != null) {
        todos.addAll(tasks);
      }
    }
    return todos;
  }

  @Override
  public Collection getTaskList(final ActivityState taskState) {
    return getTaskListUser(EnvTool.getUserId(), taskState);
  }

  @Override
  public Collection getLightTaskList(final ActivityState taskState) {
    return getLightTaskListUser(EnvTool.getUserId(), taskState);
  }

  @Override
  public TaskInstance getTask(final ActivityInstanceUUID taskUUID) throws TaskNotFoundException {
    final TaskInstance taskInstance = EnvTool.getAllQueriers(getQueryList()).getTaskInstance(taskUUID);
    if (taskInstance == null) {
      throw new TaskNotFoundException("bai_QRAPII_5", taskUUID);
    }
    return new ActivityInstanceImpl(taskInstance);
  }

  @Override
  public Set getTaskCandidates(final ActivityInstanceUUID taskUUID) throws TaskNotFoundException {
    final TaskInstance taskInstance = EnvTool.getAllQueriers(getQueryList()).getTaskInstance(taskUUID);
    if (taskInstance == null) {
      throw new TaskNotFoundException("bai_QRAPII_5", taskUUID);
    }
    return CopyTool.copy(taskInstance.getTaskCandidates());
  }

  @Override
  public Map> getTaskCandidates(final Set taskUUIDs)
      throws TaskNotFoundException {
    final Map> result = new HashMap>();
    for (final ActivityInstanceUUID taskUUID : taskUUIDs) {
      final TaskInstance taskInstance = EnvTool.getAllQueriers(getQueryList()).getTaskInstance(taskUUID);
      if (taskInstance == null) {
        throw new TaskNotFoundException("bai_QRAPII_5", taskUUID);
      }
      result.put(taskUUID, CopyTool.copy(taskInstance.getTaskCandidates()));
    }
    return result;
  }

  public Map getActivityInstanceVariables(final ProcessInstanceUUID instanceUUID,
      final String activityId, final String iterationId, final String activityInstanceId, final String loopId)
      throws ActivityNotFoundException, InstanceNotFoundException {

    final ActivityInstance activityInst = EnvTool.getAllQueriers().getActivityInstance(instanceUUID, activityId,
        iterationId, activityInstanceId, loopId);

    if (activityInst == null) {
      throw new ActivityNotFoundException("bai_QRAPII_6", instanceUUID, activityId);
    }
    return activityInst.getLastKnownVariableValues();
  }

  public Object getActivityInstanceVariable(final ProcessInstanceUUID instanceUUID, final String activityId,
      final String iterationId, final String activityInstanceId, final String loopId, final String variableId)
      throws InstanceNotFoundException, ActivityNotFoundException, VariableNotFoundException {

    final Map variables = getActivityInstanceVariables(instanceUUID, activityId, iterationId,
        activityInstanceId, loopId);
    if (variables == null || !variables.containsKey(variableId)) {
      throw new VariableNotFoundException("bai_QRAPII_7", instanceUUID, activityId, variableId);
    }
    return variables.get(variableId);
  }

  @Override
  public Map getProcessInstanceVariables(final ProcessInstanceUUID instanceUUID)
      throws InstanceNotFoundException {
    final ProcessInstance processInstance = getInternalProcessInstanceWithoutAttachements(instanceUUID);
    if (processInstance == null) {
      throw new InstanceNotFoundException("bai_QRAPII_8", instanceUUID);
    }
    return processInstance.getLastKnownVariableValues();
  }

  @Override
  public Map getProcessInstanceVariables(final ProcessInstanceUUID instanceUUID, final Date maxDate)
      throws InstanceNotFoundException {
    // take all initial instance var and for each varupdate being proceed before
    // max date, replace the initial value by
    // the new one
    final ProcessInstance processInstance = getInternalProcessInstanceWithoutAttachements(instanceUUID);
    final Map instanceInitialVars = processInstance.getInitialVariableValues();
    final Map instanceVarBeforeMaxDate = new HashMap();
    instanceVarBeforeMaxDate.putAll(instanceInitialVars);
    final Map maxVarUpdates = new HashMap();

    for (final VariableUpdate varUpdate : processInstance.getVariableUpdates()) {
      if (varUpdate.getDate().getTime() <= maxDate.getTime()) {
        final VariableUpdate currentMax = maxVarUpdates.get(varUpdate.getName());
        if (currentMax == null || currentMax.getDate().getTime() <= varUpdate.getDate().getTime()) {
          maxVarUpdates.put(varUpdate.getName(), varUpdate);
          instanceVarBeforeMaxDate.put(varUpdate.getName(), varUpdate.getValue());
        }
      }
    }
    return instanceVarBeforeMaxDate;
  }

  private Object getProcessInstanceVariable(final ProcessInstanceUUID instanceUUID, final String variableId,
      final Date maxDate) throws InstanceNotFoundException, VariableNotFoundException {
    final String variableName = Misc.getVariableName(variableId);
    final String xpath = Misc.getXPath(variableId);

    final Map variables = getProcessInstanceVariables(instanceUUID, maxDate);
    if (variables == null || !variables.containsKey(variableName)) {
      throw new VariableNotFoundException("bai_QRAPII_9", instanceUUID, variableName);
    }
    final Object value = variables.get(variableName);
    if (xpath != null && xpath.length() > 0) {
      try {
        return evaluateXPath(xpath, (org.w3c.dom.Document) value);
      } catch (final Exception ex) {
        throw new VariableNotFoundException("bai_QRAPII_17", instanceUUID, variableName);
      }
    } else {
      return value;
    }
  }

  @Override
  public Object getProcessInstanceVariable(final ProcessInstanceUUID instanceUUID, final String variableId)
      throws InstanceNotFoundException, VariableNotFoundException {
    final String variableName = Misc.getVariableName(variableId);
    final String xpath = Misc.getXPath(variableId);
    final Map variables = getProcessInstanceVariables(instanceUUID);
    if (variables == null || !variables.containsKey(variableName)) {
      throw new VariableNotFoundException("bai_QRAPII_10", instanceUUID, variableName);
    }
    final Object value = variables.get(variableName);
    if (xpath != null && xpath.length() > 0) {
      try {
        return evaluateXPath(xpath, (org.w3c.dom.Document) value);
      } catch (final Exception ex) {
        ex.printStackTrace();
        throw new VariableNotFoundException("bai_QRAPII_17", instanceUUID, variableId);
      }
    } else {
      return value;
    }
  }

  @Override
  public ActivityInstance getActivityInstance(final ActivityInstanceUUID activityUUID) throws ActivityNotFoundException {
    final ActivityInstance activity = EnvTool.getAllQueriers(getQueryList()).getActivityInstance(activityUUID);
    if (activity == null) {
      throw new ActivityNotFoundException("bai_QRAPII_11", activityUUID);
    }
    return new ActivityInstanceImpl(activity);
  }

  @Override
  public ActivityState getActivityInstanceState(final ActivityInstanceUUID activityUUID)
      throws ActivityNotFoundException {
    FacadeUtil.checkArgsNotNull(activityUUID);
    final Querier querier = EnvTool.getAllQueriers(getQueryList());
    final ActivityState state = querier.getActivityInstanceState(activityUUID);
    if (state == null) {
      final ActivityInstance activity = querier.getActivityInstance(activityUUID);
      throw new ActivityNotFoundException("bai_QRAPII_3", activity.getProcessInstanceUUID(), activity.getActivityName());
    }
    return state;
  }

  @Override
  public Object getActivityInstanceVariable(final ActivityInstanceUUID activityUUID, final String variableId)
      throws ActivityNotFoundException, VariableNotFoundException {
    // search in transient variables
    final Map transientVariables = TransientData.getActivityTransientVariables(activityUUID);
    if (transientVariables != null && transientVariables.containsKey(variableId)) {
      return transientVariables.get(variableId);
    }
    // search in the database persisted variables
    final String variableName = Misc.getVariableName(variableId);
    final String xpath = Misc.getXPath(variableId);
    final ActivityInstance activity = EnvTool.getAllQueriers().getActivityInstance(activityUUID);
    if (activity == null) {
      throw new ActivityNotFoundException("bai_QRAPII_11", activityUUID);
    }
    final Map variableValues = activity.getLastKnownVariableValues();

    if (!variableValues.containsKey(variableName)) {
      throw new VariableNotFoundException("bai_QRAPII_12", activityUUID, variableName);
    }
    final Object value = activity.getLastKnownVariableValues().get(variableName);
    if (xpath != null && xpath.length() > 0) {
      try {
        return evaluateXPath(xpath, (org.w3c.dom.Document) value);
      } catch (final Exception ex) {
        throw new VariableNotFoundException("bai_QRAPII_16", activityUUID, variableName);
      }
    } else {
      return value;
    }
  }

  private Object evaluateXPath(final String xpath, final org.w3c.dom.Document doc) throws ParserConfigurationException,
      SAXException, IOException, XPathExpressionException {
    final XPath xpathEval = XPathFactory.newInstance().newXPath();
    if (isTextExpected(xpath)) {
      return xpathEval.evaluate(xpath, doc);
    } else {
      return xpathEval.evaluate(xpath, doc, XPathConstants.NODE);
    }
  }

  private boolean isTextExpected(final String xpath) {
    final String[] segments = xpath.split("/");
    final String lastSegment = segments[segments.length - 1];
    return "text()".equals(lastSegment) || lastSegment.startsWith("@");
  }

  @Override
  public Map getActivityInstanceVariables(final ActivityInstanceUUID activityUUID)
      throws ActivityNotFoundException {
    final Map variables = new HashMap();
    final Map transientVariables = TransientData.getActivityTransientVariables(activityUUID);
    if (transientVariables != null) {
      variables.putAll(transientVariables);
    }
    final ActivityInstance activity = EnvTool.getAllQueriers().getActivityInstance(activityUUID);
    if (activity == null) {
      throw new ActivityNotFoundException("bai_QRAPII_11", activityUUID);
    }
    final Map lastKnownVariables = activity.getLastKnownVariableValues();
    if (lastKnownVariables != null) {
      variables.putAll(lastKnownVariables);
    }
    return variables;
  }

  @Override
  public Collection getTaskList(final ProcessInstanceUUID instanceUUID, final String userId,
      final ActivityState taskState) throws InstanceNotFoundException {
    return getTaskListUser(instanceUUID, userId, taskState);
  }

  @Override
  public Collection getLightTaskList(final ProcessInstanceUUID instanceUUID, final String userId,
      final ActivityState taskState) throws InstanceNotFoundException {
    return getLightTaskListUser(instanceUUID, userId, taskState);
  }

  @Override
  public Collection getTaskList(final String userId, final ActivityState taskState) {
    return getTaskListUser(userId, taskState);
  }

  @Override
  public Collection getLightTaskList(final String userId, final ActivityState taskState) {
    return getLightTaskListUser(userId, taskState);
  }

  @Override
  public ActivityInstanceUUID getOneTask(final ActivityState taskState) {
    final Querier journal = EnvTool.getJournalQueriers(getQueryList());

    final boolean access = EnvTool.isRestrictedApplicationAcces();
    TaskInstance task = null;
    if (access) {
      final String applicationName = EnvTool.getApplicationAccessName();
      if (applicationName != null) {
        final Set visibleProcessUUIDs = FacadeUtil.getAllowedProcessUUIDsFor(applicationName,
            RuleType.PROCESS_READ);
        if (visibleProcessUUIDs != null && !visibleProcessUUIDs.isEmpty()) {
          task = journal.getOneTask(EnvTool.getUserId(), taskState, visibleProcessUUIDs);
        }
      }
    } else {
      task = journal.getOneTask(EnvTool.getUserId(), taskState);
    }
    if (task == null) {
      return null;
    }
    return new ActivityInstanceUUID(task.getUUID());
  }

  @Override
  public ActivityInstanceUUID getOneTask(final ProcessInstanceUUID instanceUUID, final ActivityState taskState) {
    final Querier journal = EnvTool.getJournalQueriers(getQueryList());
    final TaskInstance task = journal.getOneTask(EnvTool.getUserId(), instanceUUID, taskState);
    if (task == null) {
      return null;
    }
    return new ActivityInstanceUUID(task.getUUID());
  }

  @Override
  public ActivityInstanceUUID getOneTask(final ProcessDefinitionUUID processUUID, final ActivityState taskState) {
    final Querier journal = EnvTool.getJournalQueriers(getQueryList());
    final TaskInstance task = journal.getOneTask(EnvTool.getUserId(), processUUID, taskState);
    if (task == null) {
      return null;
    }
    return new ActivityInstanceUUID(task.getUUID());
  }

  private Collection getTaskListUser(final ProcessInstanceUUID instanceUUID, final String userId,
      final ActivityState taskState) throws InstanceNotFoundException {
    final Collection todos = new ArrayList();
    for (final TaskInstance taskActivity : getInternalTaskListUser(instanceUUID, userId, taskState)) {
      todos.add(new ActivityInstanceImpl(taskActivity));
    }
    return todos;
  }

  private Collection getLightTaskListUser(final ProcessInstanceUUID instanceUUID,
      final String userId, final ActivityState taskState) throws InstanceNotFoundException {
    final Collection todos = new ArrayList();
    for (final TaskInstance taskActivity : getInternalTaskListUser(instanceUUID, userId, taskState)) {
      todos.add(new LightActivityInstanceImpl(taskActivity));
    }
    return todos;
  }

  private Collection getInternalTaskListUser(final ProcessInstanceUUID instanceUUID, final String userId,
      final ActivityState taskState) throws InstanceNotFoundException {
    FacadeUtil.checkArgsNotNull(instanceUUID, taskState, userId);
    final ProcessInstance processInstance = getInternalProcessInstanceWithoutAttachements(instanceUUID);
    if (processInstance == null) {
      throw new InstanceNotFoundException("bai_QRAPII_13", instanceUUID);
    }
    final Querier journal = EnvTool.getAllQueriers(getQueryList());
    return journal.getUserInstanceTasks(userId, instanceUUID, taskState);
  }

  private Collection getTaskListUser(final String userId, final ActivityState taskState) {
    final Collection result = new HashSet();
    for (final TaskInstance taskInstance : getInternalTaskListUser(userId, taskState)) {
      result.add(new ActivityInstanceImpl(taskInstance));
    }
    return result;
  }

  private Collection getLightTaskListUser(final String userId, final ActivityState taskState) {
    final Collection result = new HashSet();
    for (final TaskInstance taskInstance : getInternalTaskListUser(userId, taskState)) {
      result.add(new LightActivityInstanceImpl(taskInstance));
    }
    return result;
  }

  private Collection getInternalTaskListUser(final String userId, final ActivityState taskState) {
    FacadeUtil.checkArgsNotNull(userId, taskState);

    final boolean access = EnvTool.isRestrictedApplicationAcces();
    Collection tasks = new HashSet();
    if (access) {
      final String applicationName = EnvTool.getApplicationAccessName();
      if (applicationName != null) {
        final Set visibleProcessUUIDs = FacadeUtil.getAllowedProcessUUIDsFor(applicationName,
            RuleType.PROCESS_READ);
        if (visibleProcessUUIDs != null && !visibleProcessUUIDs.isEmpty()) {
          tasks = EnvTool.getAllQueriers(getQueryList()).getUserTasks(userId, taskState, visibleProcessUUIDs);
        }
      }
    } else {
      tasks = EnvTool.getAllQueriers(getQueryList()).getUserTasks(userId, taskState);
    }
    return tasks;
  }

  @Override
  public Object getVariable(final ActivityInstanceUUID activityUUID, final String variableId)
      throws ActivityNotFoundException, VariableNotFoundException {
    try {
      return getActivityInstanceVariable(activityUUID, variableId);
    } catch (final Throwable e) {
      final ActivityInstance activity = EnvTool.getAllQueriers().getActivityInstance(activityUUID);
      if (activity == null) {
        throw new ActivityNotFoundException("bai_QRAPII_11", activityUUID);
      }
      final Date maxDate = getMaxDate(activity);
      try {
        return getProcessInstanceVariable(activity.getProcessInstanceUUID(), variableId, maxDate);
      } catch (final InstanceNotFoundException e1) {
        // If activity exists, the process instance must exist too.
        Misc.unreachableStatement();
        return null;
      }
    }
  }

  @Override
  public Map getVariables(final ActivityInstanceUUID activityUUID) throws ActivityNotFoundException {
    final ActivityInstance activity = EnvTool.getAllQueriers(getQueryList()).getActivityInstance(activityUUID);
    if (activity == null) {
      throw new ActivityNotFoundException("bai_QRAPII_14", activityUUID);
    }
    final Date maxDate = getMaxDate(activity);
    try {
      final Map allVariables = new HashMap();
      final Map localVariables = activity.getLastKnownVariableValues();
      final Map globalVariables = getProcessInstanceVariables(activity.getProcessInstanceUUID(),
          maxDate);
      // add global first because if some variables are in both local and global
      // we want to keep local value
      allVariables.putAll(globalVariables);
      allVariables.putAll(localVariables);
      return allVariables;
    } catch (final InstanceNotFoundException e) {
      // If activity exists, the process instance must exist too.
      Misc.unreachableStatement();
      return null;
    }
  }

  private Date getMaxDate(final ActivityInstance activity) {
    final Date endedDate = activity.getEndedDate();
    if (endedDate == null) {
      return new Date();
    }
    return endedDate;
  }

  @Override
  public Set getAttachmentNames(final ProcessInstanceUUID instanceUUID) {
    FacadeUtil.checkArgsNotNull(instanceUUID);
    try {
      final InternalProcessInstance instance = getInternalProcessInstanceWithAttachments(instanceUUID);
      final Set attachmentNames = new HashSet();
      final List attachments = instance.getAttachments();
      for (final AttachmentInstance attachment : attachments) {
        attachmentNames.add(attachment.getName());
      }
      return attachmentNames;
    } catch (final InstanceNotFoundException e) {
      throw new BonitaRuntimeException(e);
    }
  }

  @Override
  public AttachmentInstance getLastAttachment(final ProcessInstanceUUID instanceUUID, final String attachmentName) {
    FacadeUtil.checkArgsNotNull(instanceUUID, attachmentName);
    final StringBuilder stringBuilder = new StringBuilder();
    stringBuilder.append("getLastAttachment for process instance ");
    stringBuilder.append(instanceUUID);
    stringBuilder.append(" and name ");
    stringBuilder.append(attachmentName);
    Misc.log(Level.FINE, stringBuilder.toString());
    final DocumentationManager manager = EnvTool.getDocumentationManager();
    final List documents = DocumentService.getDocuments(manager, instanceUUID,
        attachmentName);
    if (documents.isEmpty()) {
      Misc.log(Level.FINE, "getLastAttachment end (no document found)");
      return null;
    } else {
      final AttachmentInstance attachmentFromDocument = DocumentService.getAttachmentFromDocument(manager,
          documents.get(0));
      Misc.log(Level.FINE, "getLastAttachment end");
      return attachmentFromDocument;
    }
  }
  
  @Override
  public AttachmentInstance getLastAttachment(final ProcessInstanceUUID instanceUUID, final String attachmentName,
      final ActivityInstanceUUID activityUUID) throws ActivityNotFoundException {
    final Date date = getLastUpdateDate(activityUUID);
    return getLastAttachment(instanceUUID, attachmentName, date);
  }

  private Date getLastUpdateDate(final ActivityInstanceUUID activityUUID) throws ActivityNotFoundException {
    final StringBuilder stringBuilder = new StringBuilder();
    stringBuilder.append("getActivity for getLastAttachment ");
    stringBuilder.append(activityUUID);
    Misc.log(Level.FINE, stringBuilder.toString());
    final ActivityInstance activity = getActivityInstance(activityUUID);
    Date date = null;
    if (!activity.getState().equals(ActivityState.READY) && !activity.getState().equals(ActivityState.SUSPENDED)
        && !activity.getState().equals(ActivityState.EXECUTING)) {
      date = activity.getLastStateUpdate().getUpdatedDate();
    } else {
      date = new Date();
    }
    return date;
  }
  
  @Override
  public Document getLastDocument(final ProcessInstanceUUID instanceUUID, final String documentName,
      final ActivityInstanceUUID activityUUID) throws ActivityNotFoundException {
    final Date date = getLastUpdateDate(activityUUID);
    return getLastDocument(instanceUUID, documentName, date);
  }

  @Override
  public AttachmentInstance getLastAttachment(final ProcessInstanceUUID instanceUUID, final String attachmentName,
      final Date date) {
    final DocumentationManager manager = EnvTool.getDocumentationManager();
    final org.ow2.bonita.services.Document doc = getLastServiceDocument(instanceUUID, attachmentName, date, manager);
    if (doc == null) {
      Misc.log(Level.FINE, "getLastDocument end (no document found)");
      return null;
    }
    final AttachmentInstance attachmentFromDocument = DocumentService.getAttachmentFromDocument(manager, doc);
    Misc.log(Level.FINE, "getLastAttachment end");
    return attachmentFromDocument;
  }
  
  @Override
  public Document getLastDocument(final ProcessInstanceUUID instanceUUID, final String documentName, final Date date) {
    final DocumentationManager manager = EnvTool.getDocumentationManager();
   final org.ow2.bonita.services.Document doc = getLastServiceDocument(instanceUUID, documentName, date, manager);
    if (doc == null) {
      Misc.log(Level.FINE, "getLastDocument end (no document found)");
      return null;
    }
    return DocumentService.getClientDocument(manager, doc);
  }

  private org.ow2.bonita.services.Document getLastServiceDocument(final ProcessInstanceUUID instanceUUID, final String documentName, final Date date, final DocumentationManager manager) {
    FacadeUtil.checkArgsNotNull(instanceUUID, documentName, date);
    
    final StringBuilder stringBuilder = new StringBuilder();
    stringBuilder.append("getLastDocument for process instance ");
    stringBuilder.append(instanceUUID);
    stringBuilder.append(" and name ");
    stringBuilder.append(documentName);
    stringBuilder.append(" and date ");
    stringBuilder.append(date);
    Misc.log(Level.FINE, stringBuilder.toString());
    final List documents = DocumentService.getDocuments(manager, instanceUUID,
        documentName);
    final List allDocuments = new ArrayList();
    for (final org.ow2.bonita.services.Document document : documents) {
      List documentVersions;
      try {
        documentVersions = manager.getVersionsOfDocument(document.getId());
        allDocuments.addAll(documentVersions);
      } catch (final DocumentNotFoundException e) {
        throw new BonitaRuntimeException(e);
      }
    }
    org.ow2.bonita.services.Document doc = null;
    for (int i = 0; i < allDocuments.size(); i++) {
      final org.ow2.bonita.services.Document tmp = allDocuments.get(i);
      final long tmpDate = tmp.getCreationDate().getTime();
      if (tmpDate <= date.getTime()) {
        if (doc == null) {
          doc = tmp;
        } else if (doc.getCreationDate().getTime() <= tmpDate) {
          doc = tmp;
        }
      }
    }
    return doc;
  }

  @Override
  public Collection getLastAttachments(final ProcessInstanceUUID instanceUUID,
      final Set attachmentNames) {
    FacadeUtil.checkArgsNotNull(instanceUUID, attachmentNames);
    final Set result = new HashSet();
    for (final String attachmentName : attachmentNames) {
      final AttachmentInstance attachmentInstance = getLastAttachment(instanceUUID, attachmentName);
      if (attachmentInstance != null) {
        result.add(attachmentInstance);
      }
    }
    return result;
  }

  @Override
  public Collection getLastAttachments(final ProcessInstanceUUID instanceUUID, final String regex) {
    FacadeUtil.checkArgsNotNull(instanceUUID, regex);
    final DocumentationManager manager = EnvTool.getDocumentationManager();
    final List matchingAttachments = DocumentService
        .getAllAttachmentVersions(manager, instanceUUID);
    final Map result = new HashMap();
    for (final AttachmentInstance attachmentInstance : matchingAttachments) {
      if (attachmentInstance.getName().matches(regex)) {
        result.put(attachmentInstance.getName(), new AttachmentInstanceImpl(attachmentInstance));
      }
    }
    return result.values();
  }

  @Override
  public List getAttachments(final ProcessInstanceUUID instanceUUID, final String attachmentName) {
    FacadeUtil.checkArgsNotNull(instanceUUID, attachmentName);
    final DocumentationManager manager = EnvTool.getDocumentationManager();
    return DocumentService.getAllAttachmentVersions(manager, instanceUUID, attachmentName);
  }

  @Override
  public byte[] getAttachmentValue(final AttachmentInstance attachmentInstance) {
    final DocumentationManager manager = EnvTool.getDocumentationManager();
    try {
      final org.ow2.bonita.services.Document document = manager.getDocument(attachmentInstance.getUUID().getValue());
      return manager.getContent(document);
    } catch (final DocumentNotFoundException e) {
      throw new BonitaRuntimeException(e);
    }
  }

  @Override
  public List getCommentFeed(final ProcessInstanceUUID instanceUUID) {
    final List comments = EnvTool.getAllQueriers(getQueryList()).getCommentFeed(instanceUUID);
    return new ArrayList(comments);
  }

  @Override
  public List getActivityInstanceCommentFeed(final ActivityInstanceUUID activityUUID) {
    FacadeUtil.checkArgsNotNull(activityUUID);
    final List comments = EnvTool.getAllQueriers(getQueryList()).getActivityInstanceCommentFeed(activityUUID);
    return new ArrayList(comments);
  }

  @Override
  public int getNumberOfActivityInstanceComments(final ActivityInstanceUUID activityUUID) {
    return EnvTool.getAllQueriers(getQueryList()).getNumberOfActivityInstanceComments(activityUUID);
  }

  @Override
  public Map getNumberOfActivityInstanceComments(
      final Set activityUUIDs) {
    if (activityUUIDs == null || activityUUIDs.isEmpty()) {
      return Collections.emptyMap();
    }
    return EnvTool.getAllQueriers(getQueryList()).getNumberOfActivityInstanceComments(activityUUIDs);
  }

  @Override
  public int getNumberOfComments(final ProcessInstanceUUID instanceUUID) throws InstanceNotFoundException {
    return EnvTool.getAllQueriers(getQueryList()).getNumberOfComments(instanceUUID);
  }

  @Override
  public int getNumberOfProcessInstanceComments(final ProcessInstanceUUID instanceUUID) {
    return EnvTool.getAllQueriers(getQueryList()).getNumberOfProcessInstanceComments(instanceUUID);
  }

  @Override
  public List getProcessInstanceCommentFeed(final ProcessInstanceUUID instanceUUID) {
    FacadeUtil.checkArgsNotNull(instanceUUID);
    final List comments = EnvTool.getAllQueriers(getQueryList()).getProcessInstanceCommentFeed(instanceUUID);
    return new ArrayList(comments);
  }

  @Override
  public LightTaskInstance getLightTaskInstance(final ActivityInstanceUUID taskUUID) throws TaskNotFoundException {
    final TaskInstance taskInstance = EnvTool.getAllQueriers(getQueryList()).getTaskInstance(taskUUID);
    if (taskInstance == null) {
      throw new TaskNotFoundException("bai_QRAPII_5", taskUUID);
    }
    return new LightActivityInstanceImpl(taskInstance);
  }

  @Override
  public LightActivityInstance getLightActivityInstance(final ActivityInstanceUUID activityInstanceUUID)
      throws ActivityNotFoundException {
    final ActivityInstance activityInstance = EnvTool.getAllQueriers(getQueryList()).getActivityInstance(
        activityInstanceUUID);
    if (activityInstance == null) {
      throw new ActivityNotFoundException("bai_QRAPII_11", activityInstanceUUID);
    }
    return new LightActivityInstanceImpl(activityInstance);
  }

  @Override
  public int search(final SearchQueryBuilder query) {
    final Class indexClass = getIndexedClass(query);
    return EnvTool.getAllQueriers(getQueryList()).search(query, indexClass);
  }

  @Override
  @SuppressWarnings("unchecked")
  public  List search(final SearchQueryBuilder query, final int firstResult, final int maxResults) {
    final Index index = query.getIndex();
    final Class resultClass = index.getResultClass();
    final Class indexClass = getIndexedClass(query);
    final List