• Home
• org.ow2.bonita
• bonita-server
• 4.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.
 **/
package org.ow2.bonita.facade.impl;

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

import org.ow2.bonita.facade.exception.ActivityNotFoundException;
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.internal.InternalQueryRuntimeAPI;
import org.ow2.bonita.facade.runtime.ActivityBody;
import org.ow2.bonita.facade.runtime.ActivityFullInstance;
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.runtime.VariableUpdate;
import org.ow2.bonita.facade.runtime.impl.ActivityInstanceImpl;
import org.ow2.bonita.facade.runtime.impl.ProcessInstanceImpl;
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.facade.uuid.TaskUUID;
import org.ow2.bonita.services.Querier;
import org.ow2.bonita.util.EngineEnvTool;
import org.ow2.bonita.util.Misc;


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

  /*
  public QueryRuntimeAPIImpl(String CONF_NAME) {
    this.confName = CONF_NAME;
  }
   */
  protected QueryRuntimeAPIImpl() {
  }

  public ProcessInstance getProcessInstance(final ProcessInstanceUUID instanceUUID, 
      final String queryList) throws InstanceNotFoundException {
    FacadeUtil.checkArgsNotNull(instanceUUID);
    final ProcessInstance result = EngineEnvTool.getAllQueriers(queryList).getProcessInstance(instanceUUID);
    if (result == null) {
      throw new InstanceNotFoundException(instanceUUID);
    }
    return new ProcessInstanceImpl(result);
  }

  public Set getProcessInstances(final String queryList) {
    final Set result = new HashSet();
    for (final ProcessInstance record : EngineEnvTool.getAllQueriers(queryList).getProcessInstances()) {
      result.add(new ProcessInstanceImpl(record));
    }
    return result;
  }

  public Set getProcessInstances(final ProcessDefinitionUUID processUUID, final String queryList) {
    final Set result = new HashSet();
    for (final ProcessInstance record : EngineEnvTool.getAllQueriers(queryList).getProcessInstances(processUUID)) {
      result.add(new ProcessInstanceImpl(record));
    }
    return result;
  }

  public ActivityInstance getActivityInstance(final ProcessInstanceUUID instanceUUID, final String activityId,
      final String iterationId, final String activityInstanceId, 
      final String queryList) throws ActivityNotFoundException, InstanceNotFoundException {
    final ActivityInstance result =
      EngineEnvTool.getAllQueriers(queryList).getActivityInstance(instanceUUID, activityId, iterationId, activityInstanceId);
    if (result == null) {
      if (EngineEnvTool.getAllQueriers(queryList).getProcessInstance(instanceUUID) == null) {
        throw new InstanceNotFoundException(instanceUUID);
      }
      throw new ActivityNotFoundException(instanceUUID, activityId, iterationId);
    }
    return new ActivityInstanceImpl(result);
  }

  public Set> getActivityInstances(final ProcessInstanceUUID instanceUUID, 
      final String queryList) {
    final Set> result = new HashSet>();
    for (final ActivityInstance record 
        : EngineEnvTool.getAllQueriers(queryList).getActivityInstances(instanceUUID)) {
      result.add(new ActivityInstanceImpl(record));
    }
    return result;
  }

  public Set> getActivityInstances(final ProcessInstanceUUID instanceUUID,
      final String activityId, final String queryList) throws ActivityNotFoundException {
    final Set> result = new HashSet>();
    for (final ActivityInstance record 
        : EngineEnvTool.getAllQueriers(queryList).getActivityInstances(instanceUUID)) {
      if (record.getActivityId().equals(activityId)) {
        result.add(new ActivityInstanceImpl(record));
      }
    }
    if (result.isEmpty()) {
      throw new ActivityNotFoundException(instanceUUID, activityId);
    }
    return result;
  }

  public Set> getTasks(final ProcessInstanceUUID instanceUUID, final String queryList) {
    final Set> result = new HashSet>();
    for (final ActivityInstance< TaskInstance > record : EngineEnvTool.getAllQueriers(queryList).getTaskInstances(instanceUUID)) {
      result.add(new ActivityInstanceImpl< TaskInstance >(record));
    }
    return result;
  }

  public Collection> getTaskList(final ProcessInstanceUUID instanceUUID,
      final ActivityState taskState, final String queryList) throws InstanceNotFoundException {
    return getTaskListUser(instanceUUID, EngineEnvTool.getUserId(), taskState, queryList);
  }

  public Collection> getTaskList(final ActivityState taskState, final String queryList) {
    return getTaskListUser(EngineEnvTool.getUserId(), taskState, queryList);
  }

  public ActivityInstance< TaskInstance > getTask(final TaskUUID taskUUID, final String queryList) throws TaskNotFoundException {
    final ActivityInstance< TaskInstance > taskInstance = EngineEnvTool.getAllQueriers(queryList).getTaskInstance(taskUUID);
    if (taskInstance == null) {
      throw new TaskNotFoundException(taskUUID);
    }
    return new ActivityInstanceImpl< TaskInstance >(taskInstance);
  }

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

    final ActivityInstance activityInst =
      getActivityInstance(instanceUUID, activityId, iterationId, activityInstanceId, queryList);
    if (activityInst == null) {
      throw new ActivityNotFoundException(instanceUUID, activityId);
    }
    return activityInst.getLastKnownVariableValues();
  }

  public Object getActivityInstanceVariable(final ProcessInstanceUUID instanceUUID,
      final String activityId, final String iterationId,
      final String activityInstanceId, final String variableId, final String queryList) throws InstanceNotFoundException,
      ActivityNotFoundException, VariableNotFoundException {
    final Map variables = 
      getActivityInstanceVariables(instanceUUID, activityId, iterationId, activityInstanceId, queryList);
    if (variables == null || !variables.containsKey(variableId)) {
      throw new VariableNotFoundException(instanceUUID, activityId, variableId);
    }
    return variables.get(variableId);
  }

  public Map getProcessInstanceVariables(
      final ProcessInstanceUUID instanceUUID, final String queryList) throws InstanceNotFoundException {
    final ProcessInstance processInstance = getProcessInstance(instanceUUID, queryList);
    if (processInstance == null) {
      throw new InstanceNotFoundException(instanceUUID);
    }
    return processInstance.getLastKnownVariableValues();
  }

  private Map getProcessInstanceVariables(
      final ProcessInstanceUUID instanceUUID, final String queryList, final Date maxDate) throws InstanceNotFoundException {
    final ProcessInstance processInstance = getProcessInstance(instanceUUID, queryList);
    Map vars = processInstance.getInitialVariableValues();
    Map activityDateValue = new HashMap();
    VariableUpdate last = null;
    for (VariableUpdate varUpdate : processInstance.getVariableUpdates()) {
      last = activityDateValue.get(varUpdate.getName());
      if (varUpdate.getDate().getTime() <= maxDate.getTime()) {
        if (last == null || last.getDate().getTime() <= varUpdate.getDate().getTime()) {
          activityDateValue.put(varUpdate.getName(), varUpdate);
          vars.put(varUpdate.getName(), varUpdate.getValue());
        }
      }
    }
    return vars;
  }

  private Object getProcessInstanceVariable(final ProcessInstanceUUID instanceUUID,
      final String variableId, final String queryList, 
      final Date maxDate) throws InstanceNotFoundException, VariableNotFoundException {
    final Map variables = getProcessInstanceVariables(instanceUUID, queryList, maxDate);
    if (variables == null || !variables.containsKey(variableId)) {
      throw new VariableNotFoundException(instanceUUID, variableId);
    }
    return variables.get(variableId);
  }

  public Object getProcessInstanceVariable(final ProcessInstanceUUID instanceUUID,
      final String variableId, final String queryList) throws InstanceNotFoundException, VariableNotFoundException {
    final Map variables = getProcessInstanceVariables(instanceUUID, queryList);
    if (variables == null || !variables.containsKey(variableId)) {
      throw new VariableNotFoundException(instanceUUID, variableId);
    }
    return variables.get(variableId);
  }

  /*
  private Map getVariablesInitialValue(List variableDefinitions) {
    final Map values = new HashMap();
    if (variableDefinitions != null) {
      for (VariableDefinitionImpl variableDefinition : variableDefinitions) {
        final String variableId = variableDefinition.getKey();
        Object initialValue = null;
        if (variableDefinition.getSourceDescriptor() != null) {
          initialValue = variableDefinition.getSourceDescriptor().cget();
        }
        values.put(variableId, initialValue);
      }
    }
    return values;
  }

  @SuppressWarnings("unchecked")
  public Map getActivityVariableDefinitions(ProcessDefinitionUUID processId,
      String activityId) throws ProcessNotFoundException, ActivityNotFoundException {
    final XpdlProcess process  = EnvTool.getRepository().findXpdlProcessById(processId);
    if (process == null) {
      throw new ProcessNotFoundException(processId);
    }
    final NodeImpl node = process.getNode(activityId);
    if (node == null) {
      throw new ActivityNotFoundException(processId, activityId);
    }
    final AbstractActivity activity = (AbstractActivity) node.getBehaviour();
    final List variableDefinitions = new ArrayList();
    if (activity.getVariableDefinitions() != null) {
      variableDefinitions.addAll(activity.getVariableDefinitions());
    }
    if (process.getVariableDefinitions() != null) {
      variableDefinitions.addAll(process.getVariableDefinitions());
    }
    return getVariablesInitialValue((List) variableDefinitions);
  }

  @SuppressWarnings("unchecked")
  public Map getProcessVariableDefinitions(ProcessDefinitionUUID processId) throws ProcessNotFoundException {
    final XpdlProcess process  = EnvTool.getRepository().findXpdlProcessById(processId);
    if (process == null) {
      throw new ProcessNotFoundException(processId);
    }
    final List variableDefinitions = process.getVariableDefinitions();
    return getVariablesInitialValue((List) variableDefinitions);
  }

   */

  public ActivityInstance getActivityInstance(
      final ActivityInstanceUUID activityUUID, final String queryList) throws ActivityNotFoundException {
    final ActivityInstance activity = EngineEnvTool.getAllQueriers(queryList).getActivityInstance(activityUUID);
    if (activity == null) {
      throw new ActivityNotFoundException(activityUUID);
    }
    return new ActivityInstanceImpl(activity);
  }

  public Object getActivityInstanceVariable(final ActivityInstanceUUID activityUUID,
      final String variableId, final String queryList) throws ActivityNotFoundException,
      VariableNotFoundException {
    final ActivityInstance activity = getActivityInstance(activityUUID, queryList);
    final Map variableValues = activity.getLastKnownVariableValues();

    if (!variableValues.containsKey(variableId)) {
      throw new VariableNotFoundException(activityUUID, variableId);
    }
    return activity.getLastKnownVariableValues().get(variableId);
  }

  public Map getActivityInstanceVariables(
      final ActivityInstanceUUID activityUUID, final String queryList) throws ActivityNotFoundException {
    final ActivityInstance activity = getActivityInstance(activityUUID, queryList);
    return activity.getLastKnownVariableValues();
  }

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

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

  private Collection> getTaskListUser(final ProcessInstanceUUID instanceUUID, final String userId,
      final ActivityState taskState, final String queryList) throws InstanceNotFoundException {
    FacadeUtil.checkArgsNotNull(instanceUUID, taskState, userId);
    final ProcessInstance processInstance = getProcessInstance(instanceUUID, queryList);
    if (processInstance == null) {
      throw new InstanceNotFoundException(instanceUUID);
    }
    final Querier journal = EngineEnvTool.getAllQueriers(queryList);
    final Set> userInstanceTasks =
      journal.getUserInstanceTasks(userId, instanceUUID, taskState);

    final Collection> todos = new ArrayList>();
    for (final ActivityInstance taskActivity : userInstanceTasks) {
      todos.add(new ActivityInstanceImpl(taskActivity));
    }
    return todos;
  }
  private Collection> getTaskListUser(
      final String userId, final ActivityState taskState, final String queryList) {
    FacadeUtil.checkArgsNotNull(userId, taskState);
    final Collection> todos = new ArrayList>();
    final Querier querier = EngineEnvTool.getAllQueriers(queryList);
    final Set> taskActivities = querier.getUserTasks(userId, taskState);
    for (final ActivityFullInstance taskActivity : taskActivities) {
      todos.add(new ActivityInstanceImpl(taskActivity));
    }
    return todos;
  }


  public Object getVariable(final ActivityInstanceUUID activityUUID, final String variableId, 
      final String queryList) throws ActivityNotFoundException, VariableNotFoundException {
    try {
      return getActivityInstanceVariable(activityUUID, variableId, queryList);
    } catch (final VariableNotFoundException e) {
      final ActivityInstance activity = getActivityInstance(activityUUID, queryList);
      Date maxDate = getMaxDate(activity.getBody());

      try {
        return getProcessInstanceVariable(activity.getProcessInstanceUUID(), variableId, queryList, maxDate);
      } catch (final InstanceNotFoundException e1) {
        // If activity exists, the process instance must exist too.
        Misc.unreachableStatement();
        return null;
      }
    }
  }

  public Map getVariables(final ActivityInstanceUUID activityUUID, 
      final String queryList) throws ActivityNotFoundException {
    final ActivityFullInstance activity = EngineEnvTool.getAllQueriers(queryList).getActivityInstance(activityUUID);
    if (activity == null) {
      throw new ActivityNotFoundException(activityUUID);
    }
    Date maxDate = getMaxDate(activity.getBody());
    try {
      final Map allVariables = new HashMap();
      final Map localVariables = activity.getLastKnownVariableValues();
      final Map globalVariables = 
        getProcessInstanceVariables(activity.getProcessInstanceUUID(), queryList, 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(ActivityBody body) {
    Date maxDate = body.getEndedDate();
    if (maxDate == null) {
      for (StateUpdate stateUpdate : body.getStateUpdates()) {
        Date updateDate = stateUpdate.getUpdatedDate();
        if (maxDate == null || updateDate.getTime() >= maxDate.getTime()) {
          maxDate = updateDate;
        }
      }
    }
    return maxDate;

  }
}