• Home
• org.ow2.bonita
• bonita-server
• 5.0.M4
• source code
• AbstractDbQuerier.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.persistence.db.AbstractDbQuerier Maven / Gradle / Ivy

/**
 * Copyright (C) 2006  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 - BonitaSoft S.A.
 * Modified by Matthieu Chaffotte - BonitaSoft S.A.
 **/
package org.ow2.bonita.persistence.db;

import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import org.ow2.bonita.facade.def.majorElement.ActivityDefinition;
import org.ow2.bonita.facade.def.majorElement.ProcessDefinition;
import org.ow2.bonita.facade.def.majorElement.ProcessDefinition.ProcessState;
import org.ow2.bonita.facade.runtime.ActivityInstance;
import org.ow2.bonita.facade.runtime.ActivityState;
import org.ow2.bonita.facade.runtime.ProcessInstance;
import org.ow2.bonita.facade.runtime.StateUpdate;
import org.ow2.bonita.facade.runtime.TaskInstance;
import org.ow2.bonita.facade.uuid.ActivityDefinitionUUID;
import org.ow2.bonita.facade.uuid.ActivityInstanceUUID;
import org.ow2.bonita.facade.uuid.ProcessDefinitionUUID;
import org.ow2.bonita.facade.uuid.ProcessInstanceUUID;
import org.ow2.bonita.persistence.QuerierDbSession;
import org.ow2.bonita.persistence.QuerierUtil;
import org.ow2.bonita.services.Querier;
import org.ow2.bonita.util.EnvTool;
import org.ow2.bonita.util.Misc;

public class AbstractDbQuerier implements Querier {

  private String persistenceServiceName;
  protected DbQuerierBuffer buffer;

  public AbstractDbQuerier(String persistenceServiceName, DbQuerierBuffer buffer) {
    super();
    this.persistenceServiceName = persistenceServiceName;
    this.buffer = buffer;
  }

  protected QuerierDbSession getQuerierDbSession() {
    return EnvTool.getQuerierDbSession(persistenceServiceName);
  }

  public ActivityDefinition getActivity(ActivityDefinitionUUID activityDefinitionUUID) {
    Misc.checkArgsNotNull(activityDefinitionUUID);
    for (ProcessDefinition process : buffer.getProcesses().values()) {

      Set activities = process.getActivities();
      if (activities != null) {
        for (ActivityDefinition activity : activities) {
          if (activity.getUUID().equals(activityDefinitionUUID)) {
            return activity;
          }
        }
      }
    }

    ActivityDefinition dbAD = getQuerierDbSession().getActivityDefinition(activityDefinitionUUID);
    if (dbAD == null || buffer.isProcessRemoved(dbAD.getProcessDefinitionUUID())) {
      return null;
    }
    return dbAD;
  }

  public ActivityInstance getActivityInstance(ProcessInstanceUUID instanceUUID, String activityName, String iterationId, String activityInstanceId) {

    Misc.checkArgsNotNull(instanceUUID, activityName, iterationId, activityInstanceId);
    if (buffer.isInstanceRemoved(instanceUUID)) {
      return null;
    }
    ProcessInstance instance = buffer.getInstance(instanceUUID);
    if (instance != null) {
      return instance.getActivity(activityName, iterationId, activityInstanceId);
    }
    return getQuerierDbSession().getActivityInstance(instanceUUID, activityName, iterationId, activityInstanceId);
  }

  public ActivityState getActivityInstanceState(ActivityInstanceUUID activityInstanceUUID) {
    Misc.checkArgsNotNull(activityInstanceUUID);

    ProcessInstanceUUID instanceUUID = activityInstanceUUID.getProcessInstanceUUID();
    if (buffer.isInstanceRemoved(instanceUUID)) {
      return null;
    }
    ProcessInstance instance = buffer.getInstance(instanceUUID);
    if (instance != null) {
      ActivityInstance activity = instance.getActivity(activityInstanceUUID);
      if (activity != null) {
        return activity.getState();
      }
    }
    return getQuerierDbSession().getActivityInstanceState(activityInstanceUUID);
  }

  public ActivityInstance getActivityInstance(
      ActivityInstanceUUID activityInstanceUUID) {

    Misc.checkArgsNotNull(activityInstanceUUID);
    for (ProcessInstance instance : buffer.getInstances().values()) {
      Set activities = instance.getActivities();
      if (activities != null) {
        for (ActivityInstance activity : activities) {
          if (activity.getUUID().equals(activityInstanceUUID)) {
            return activity;
          }
        }
      }
    }
    ActivityInstance aFI = 
      getQuerierDbSession().getActivityInstance(activityInstanceUUID);
    if (aFI == null || buffer.isInstanceRemoved(aFI.getProcessInstanceUUID())) {
      return null;
    }
    return aFI;
  }

  public Set getActivityInstances(
      ProcessInstanceUUID instanceUUID) {

    Misc.checkArgsNotNull(instanceUUID);

    if (buffer.isInstanceRemoved(instanceUUID)) {
      return new HashSet();
    }
    Set activityInstances = null;
    ProcessInstance instance = buffer.getInstance(instanceUUID);
    if (instance != null) {
      return instance.getActivities();
    }

    activityInstances = getQuerierDbSession().getActivityInstances(instanceUUID);
    if (activityInstances != null) {
      return activityInstances;
    }
    return new HashSet();
  }


  public ProcessInstance getProcessInstance(ProcessInstanceUUID instanceUUID) {
    Misc.checkArgsNotNull(instanceUUID);

    if (buffer.isInstanceRemoved(instanceUUID)) {
      return null;
    }
    ProcessInstance instance = buffer.getInstance(instanceUUID);
    if (instance != null) {
      return instance;
    }
    instance = getQuerierDbSession().getProcessInstance(instanceUUID);
    if (instance != null) {
      buffer.addInstance(instance);
    }
    return instance;
  }

  public Set getProcessInstances() {
    Set dbInstances = getQuerierDbSession().getProcessInstances();
    for (ProcessInstance instance : dbInstances) {
      if (!buffer.containsInstance(instance.getUUID()) && !buffer.isInstanceRemoved(instance.getUUID())) {
        buffer.addInstance(instance);
      }
    }
    return buffer.getInstancesSet();
  }

  public Set getProcessInstances(
      Collection instanceUUIDs) {
    Set dbInstances = getQuerierDbSession().getProcessInstances(instanceUUIDs);
    for (ProcessInstance instance : dbInstances) {
      if (!buffer.containsInstance(instance.getUUID()) && !buffer.isInstanceRemoved(instance.getUUID())) {
        buffer.addInstance(instance);
      }
    }
    return buffer.getInstancesSet();
  }

  public Set getUserInstances(String userId) {
    Set dbInstances = getQuerierDbSession().getUserInstances(userId);
    for (ProcessInstance instance : dbInstances) {
      if (!buffer.containsInstance(instance.getUUID()) && !buffer.isInstanceRemoved(instance.getUUID())) {
        buffer.addInstance(instance);
      }
    }

    Set instances = new HashSet();
    instances.addAll(dbInstances);
    for (ProcessInstance instance : buffer.getInstances().values()) {
      if (!dbInstances.contains(instance)) {
        if (instance.getStartedBy().equals(userId) || isInTodoDoneList(instance, userId)) {
          instances.add(instance);
        }
      }
    }
    return instances;
  }

  private boolean isInTodoDoneList(ProcessInstance instance, String userId) {
    for (TaskInstance activity : instance.getTasks()) {
      if (activity.isTask()) {
        StateUpdate su = activity.getLastStateUpdate();
        if (su.getUpdatedBy().equals(userId)) {
          return true;
        } else if (activity.isTaskAssigned() && activity.getTaskUser().equals(userId)) {
          return true;
        } else if (!activity.isTaskAssigned() && activity.getTaskCandidates().contains(userId)) {
          return true;
        } 
      }
    }
    return false;
  }
  public Set getProcessInstancesWithTaskState(Collection activityStates) {
    Set dbInstances = getQuerierDbSession().getProcessInstancesWithTaskState(activityStates);
    for (ProcessInstance instance : dbInstances) {
      if (!buffer.containsInstance(instance.getUUID()) && !buffer.isInstanceRemoved(instance.getUUID())) {
        buffer.addInstance(instance);
      }
    }
    return buffer.getInstancesSet();
  }

  public Set getProcessInstances(
      ProcessDefinitionUUID processUUID) {
    Misc.checkArgsNotNull(processUUID);
    Set dbInstances = getQuerierDbSession().getProcessInstances(processUUID);
    for (ProcessInstance instance : dbInstances) {
      if (!buffer.containsInstance(instance.getUUID()) && !buffer.isInstanceRemoved(instance.getUUID())) {
        buffer.addInstance(instance);
      }
    }
    Set instances = new HashSet();
    for (ProcessInstance instance : buffer.getInstances().values()) {
      if (instance.getProcessDefinitionUUID().equals(processUUID)) {
        instances.add(instance);
      }
    }
    return instances;
  }

  public Set getWebProcessInstances(String labelId) {
    return getQuerierDbSession().getWebProcessInstances(labelId);
  }
  
  public Set getNewWebProcessInstances(String userId) {
    return getQuerierDbSession().getNewWebProcessInstances(userId);
  }
  
  public ProcessDefinition getProcess(String processId, String version) {
    Misc.checkArgsNotNull(processId, version);

    for (ProcessDefinition process : buffer.getProcesses(processId).values()) {
      if (process.getVersion().equals(version)) {
        return process;
      }
    }
    ProcessDefinition process = getQuerierDbSession().getProcess(processId, version);
    if (process == null || buffer.isProcessRemoved(process.getUUID())) {
      return null;
    }
    return process;
  }

  public ProcessDefinition getProcess(ProcessDefinitionUUID processUUID) {
    Misc.checkArgsNotNull(processUUID);
    for (ProcessDefinition process : buffer.getProcesses().values()) {
      if (process.getUUID().equals(processUUID)) {
        return process;
      }
    }
    ProcessDefinition process = getQuerierDbSession().getProcess(processUUID);
    if (process == null || buffer.isProcessRemoved(process.getUUID())) {
      return null;
    }
    return process;

  }

  public Set getProcesses() {
    Set processes = getQuerierDbSession().getProcesses();
    return mergeBuffer(processes);
  }

  public Set getProcesses(String processId) {
    Misc.checkArgsNotNull(processId);
    Set processes = getQuerierDbSession().getProcesses(processId);
    return mergeBuffer(processes);
  }

  public Set getProcesses(ProcessDefinition.ProcessState processState) {
    Misc.checkArgsNotNull(processState);
    Set processes = getQuerierDbSession().getProcesses(processState);
    return mergeBuffer(processes);
  }

  public Set getProcesses(String processId, ProcessDefinition.ProcessState processState) {
    Misc.checkArgsNotNull(processId, processState);
    Set processes = getQuerierDbSession().getProcesses(processId, processState);
    return mergeBuffer(processes);
  }

  public TaskInstance getTaskInstance(ActivityInstanceUUID taskUUID) {
    Misc.checkArgsNotNull(taskUUID);

    for (ProcessInstance instance : buffer.getInstances().values()) {
      Set activities = instance.getActivities();
      if (activities != null) {
        for (ActivityInstance activity : activities) {
          if (activity.getUUID().equals(taskUUID) && activity.isTask()) {
            return (TaskInstance) activity;
          }
        }
      }
    }
    TaskInstance aFI = 
      getQuerierDbSession().getTaskInstance(taskUUID);
    if (aFI == null || buffer.isInstanceRemoved(aFI.getProcessInstanceUUID())) {
      return null;
    }
    return aFI;
  }

  public Set getTaskInstances(
      ProcessInstanceUUID instanceUUID) {
    Misc.checkArgsNotNull(instanceUUID);
    if (buffer.isInstanceRemoved(instanceUUID)) {
      return new HashSet();
    }
    SettaskActivities = new HashSet();
    ProcessInstance instance = buffer.getInstance(instanceUUID);
    if (instance != null) {
      Set activities = instance.getActivities();
      if (activities != null) {
        for (ActivityInstance activity : activities) {
          if (activity.isTask()) {
            taskActivities.add(activity.getTask());
          }
        }
      }
      return taskActivities;
    }
    return getQuerierDbSession().getTaskInstances(instanceUUID);
  }

  public Set getUserInstanceTasks(
      String userId, ProcessInstanceUUID instanceUUID, ActivityState taskState) {
    Misc.checkArgsNotNull(userId, instanceUUID, taskState);

    if (buffer.isInstanceRemoved(instanceUUID)) {
      return new HashSet();
    }

    Set taskActivities = new HashSet();
    ProcessInstance instance = buffer.getInstance(instanceUUID);
    if (instance != null) {
      taskActivities.addAll(QuerierUtil.getUserTasks(instance.getActivities(), userId, taskState));
      return taskActivities;
    }
    return getQuerierDbSession().getUserInstanceTasks(userId, instanceUUID, taskState);
  }

  public Set getUserTasks(String userId, ActivityState taskState) {
    Collection taskStates = new HashSet();
    taskStates.add(taskState);
    return getUserTasks(userId, taskStates);
  }

  public Set getUserTasks(String userId, Collection taskStates) {
    Misc.checkArgsNotNull(userId, taskStates);

    Set bufferTaskActivities =  new HashSet();
    for (ProcessInstance instance : buffer.getInstances().values()) {
      bufferTaskActivities.addAll(QuerierUtil.getUserTasks(instance.getActivities(), userId, taskStates));
    }

    Map taskActivities =  new HashMap();

    for (TaskInstance taskActivity : bufferTaskActivities) {
      taskActivities.put(taskActivity.getUUID(), taskActivity);
    }

    Set dbTaskActivities = getQuerierDbSession().getUserTasks(userId, taskStates);
    if (dbTaskActivities != null) {
      for (TaskInstance activity : dbTaskActivities) {
        if (!buffer.isInstanceRemoved(activity.getProcessInstanceUUID()) && !taskActivities.containsKey(activity.getUUID())) {
          taskActivities.put(activity.getUUID(), activity);
        }
      }
    }

    Set result =  new HashSet();
    result.addAll(taskActivities.values());
    return result;
  }

  /*
   *SPECIFIC
   */
  public Set getDependentProcesses(ProcessDefinitionUUID processUUID) {
    Misc.checkArgsNotNull(processUUID);
    Set uuidDeps = new HashSet();
    Set deps = getQuerierDbSession().getDependentProcesses(processUUID);
    if (deps != null) {
      for (ProcessDefinition process : deps) {
        uuidDeps.add(process.getUUID());
        if (buffer.isProcessRemoved(process.getUUID())) {
          deps.remove(process);
        }
      }
    }

    if (deps == null) {
      deps = new HashSet();
    }
    for (ProcessDefinition proc : buffer.getProcesses().values()) {
      boolean isDep = !proc.getUUID().equals(processUUID)
      && proc.getProcessDependencies() != null && proc.getProcessDependencies().contains(processUUID.getProcessName());
      if (isDep && !uuidDeps.contains(proc.getUUID())) {
        uuidDeps.add(proc.getUUID());
        deps.add(proc);

      }
    }
    return deps;
  }

  public Set getDependentProcesses(final String className) {
    Misc.checkArgsNotNull(className);

    Set deps = getQuerierDbSession().getDependentProcesses(className);
    if (deps != null) {
      for (ProcessDefinitionUUID processUUID : deps) {
        if (buffer.isProcessRemoved(processUUID)) {
          deps.remove(processUUID);
        }
      }
    }

    if (deps == null) {
      deps = new HashSet();
    }
    for (ProcessDefinition proc : buffer.getProcesses().values()) {
      if (proc.getClassDependencies() != null && proc.getClassDependencies().contains(className)
      		&& proc.getState().equals(ProcessState.ENABLED)) {
        deps.add(proc.getUUID());
      }
    }

    return deps;
  }

  public ProcessDefinition getLastDeployedProcess(String processId, ProcessDefinition.ProcessState processState) {
    Misc.checkArgsNotNull(processId, processState);

    ProcessDefinition lastProcess = getQuerierDbSession().getLastProcess(processId, processState);

    for (ProcessDefinition process : buffer.getProcesses().values()) {
      boolean match = false;
      if (process.getName().equals(processId)) {
        if (ProcessState.ENABLED.equals(processState) && process.getUndeployedBy() == null) {
          match = true;
        } else if (ProcessState.DISABLED.equals(processState)) {
          match = true;
        }
      }
      if (match && (lastProcess == null || process.getDeployedDate().after(lastProcess.getDeployedDate()))) {
        lastProcess = process;
      }
    }

    return lastProcess;
  }

  private Set mergeBuffer(Set processes) {
    if (processes == null) {
      return new HashSet();
    }
    for (ProcessDefinition process : processes) {
      if (buffer.isProcessRemoved(process.getUUID())) {
        processes.remove(process);
      }
    }
    return processes;
  }
}