WfAssignmentIteratorWrapper.java :  » Workflow-Engines » shark » org » enhydra » shark » Java Open Source

package org.enhydra.shark;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.enhydra.shark.api.client.wfmc.wapi.WMSessionHandle;
import org.enhydra.shark.api.client.wfmodel.WfAssignment;
import org.enhydra.shark.api.client.wfmodel.WfAssignmentIterator;
import org.enhydra.shark.api.common.SharkConstants;
import org.enhydra.shark.api.internal.instancepersistence.ActivityPersistenceObject;
import org.enhydra.shark.api.internal.instancepersistence.AssignmentPersistenceObject;
import org.enhydra.shark.api.internal.instancepersistence.PersistentManagerInterface;
import org.enhydra.shark.api.internal.instancepersistence.ProcessPersistenceObject;
import org.enhydra.shark.api.internal.scripting.Evaluator;
import org.enhydra.shark.utilities.MiscUtilities;

/**
 * Iterator for assignments of activity. The following names may be used in queries:
 * processId, resourceUsername, accepted, packageId, packageVersion, processDefinitionId,
 * activitySetDefinitionId, activityDefinitionId.
 * 
 * @author Sasa Bojanic
 * @version 1.0
 */
public class WfAssignmentIteratorWrapper extends BaseIteratorWrapper implements
                                                                    WfAssignmentIterator {

   protected String procId;

   protected String actId;

   protected String username;

   protected WfAssignmentIteratorWrapper(WMSessionHandle shandle,
                                         String procId,
                                         String actId) throws Exception {
      super(shandle);
      this.procId = procId;
      this.actId = actId;
   }

   protected WfAssignmentIteratorWrapper(WMSessionHandle shandle, String username) throws Exception {
      super(shandle);
      this.username = username;
   }

   public WfAssignment get_next_object() throws Exception {
      long tStamp = SharkUtilities.methodStart(shandle,"WfAssignmentIteratorWrapper.get_next_object");
      try {
         checkSecurity("get_next_object", null);
         return (WfAssignment) super.getNextObject();
      } finally {
         SharkUtilities.methodEnd(shandle,tStamp,
                                  "WfAssignmentIteratorWrapper.get_next_object",
                                  this);
      }
   }

   public WfAssignment get_previous_object() throws Exception {
      long tStamp = SharkUtilities.methodStart(shandle,"WfAssignmentIteratorWrapper.get_previous_object");
      try {
         checkSecurity("get_previous_object", null);
         return (WfAssignment) super.getPreviousObject();
      } finally {
         SharkUtilities.methodEnd(shandle,tStamp,
                                  "WfAssignmentIteratorWrapper.get_previous_object",
                                  this);
      }
   }

   public WfAssignment[] get_next_n_sequence(int max_number) throws Exception {
      long tStamp = SharkUtilities.methodStart(shandle,"WfAssignmentIteratorWrapper.get_next_n_sequence");
      try {
         checkSecurity("get_next_n_sequence", null);

         WfAssignment[] ret = null;
         List l = super.getNextNSequence(max_number);
         ret = new WfAssignment[l.size()];
         l.toArray(ret);
         return ret;
      } finally {
         SharkUtilities.methodEnd(shandle,tStamp,
                                  "WfAssignmentIteratorWrapper.get_next_n_sequence",
                                  this);
      }
   }

   public WfAssignment[] get_previous_n_sequence(int max_number) throws Exception {
      long tStamp = SharkUtilities.methodStart(shandle,"WfAssignmentIteratorWrapper.get_previous_n_sequence");
      try {
         checkSecurity("get_previous_n_sequence", null);

         WfAssignment[] ret = null;
         List l = super.getPreviousNSequence(max_number);
         ret = new WfAssignment[l.size()];
         l.toArray(ret);
         return ret;
      } finally {
         SharkUtilities.methodEnd(shandle,tStamp,
                                  "WfAssignmentIteratorWrapper.get_previous_n_sequence",
                                  this);
      }
   }

   protected void fillObjectList() throws Exception {
      if (objectList != null)
         return;

      List assignments = new ArrayList();

      PersistentManagerInterface ipm = SharkEngineManager.getInstance()
         .getInstancePersistenceManager();
      ActivityPersistenceObject apo = null;
      ProcessPersistenceObject ppo = null;
      List l = new ArrayList();
      boolean createNewPOs = true;
      if (sqlWhere != null) {
         l = ipm.getAssignmentsWhere(shandle, sqlWhere, startAt, limit);
      } else if (username != null) {
         l.addAll(ipm.getAllValidAssignmentsForResource(shandle, username));
      } else if (procId != null && actId != null) {
         l.addAll(ipm.getAllValidAssignmentsForActivity(shandle, procId, actId));
         ppo = ipm.restoreProcess(shandle, procId);
         apo = ipm.restoreActivity(shandle, procId, actId);
         createNewPOs = false;
      }

      Evaluator evaluator = SharkEngineManager.getInstance()
         .getScriptingManager()
         .getEvaluator(shandle,queryGrammar);
      // boolean eval=queryExpression!=null &&
      // queryExpression.trim().length()>0;
      for (int i = 0; i < l.size(); i++) {
         AssignmentPersistenceObject po = (AssignmentPersistenceObject) l.get(i);
         boolean toAdd = true;
         if (eval) {
            Map context = new HashMap();
            context.put(SharkConstants.ASS_PROCESS_ID, po.getProcessId());
            context.put(SharkConstants.ASS_RESOURCE_USERNAME, po.getResourceUsername());
            if (createNewPOs) {
               ppo = ipm.restoreProcess(shandle, po.getProcessId());
               apo = ipm.restoreActivity(shandle, po.getProcessId(), po.getActivityId());
            }
            String mgrName = ppo.getProcessMgrName();
            String pkgId = MiscUtilities.getProcessMgrPkgId(mgrName);
            String pDefId = MiscUtilities.getProcessMgrProcDefId(mgrName);
            String ver = MiscUtilities.getProcessMgrVersion(mgrName);
            context.put(SharkConstants.ASS_ACCEPTED,
                        new Boolean(apo.getResourceUsername() != null));
            context.put(SharkConstants.ASS_PACKAGE_ID, pkgId);
            context.put(SharkConstants.ASS_PACKAGE_VERSION, ver);
            context.put(SharkConstants.ASS_PROCESS_DEFINITION_ID, pDefId);
            context.put(SharkConstants.ASS_ACTIVITY_SET_DEFINITION_ID,
                        apo.getActivitySetDefinitionId());
            context.put(SharkConstants.ASS_ACTIVITY_DEFINITION_ID,
                        apo.getActivityDefinitionId());
            context.put(SharkConstants.ASS_ACTIVITY_ID, po.getActivityId());
            toAdd = evaluator.evaluateCondition(shandle, po.getProcessId(), po.getActivityId(), queryExpression, context);
         }
         if (toAdd) {
            assignments.add(SharkEngineManager.getInstance()
               .getObjectFactory()
               .createAssignmentWrapper(shandle,
                                        po.getProcessMgrName(),
                                        po.getProcessId(),
                                        po.getActivityId(),
                                        po.getResourceUsername()));
         }

      }
      setObjectList(assignments);
   }

}