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

package org.enhydra.shark;

import java.io.Serializable;
import java.util.List;
import java.util.Map;

import org.enhydra.shark.api.client.wfmc.wapi.WMSessionHandle;
import org.enhydra.shark.api.client.wfmodel.InvalidRequester;
import org.enhydra.shark.api.client.wfmodel.NotEnabled;
import org.enhydra.shark.api.client.wfmodel.RequesterRequired;
import org.enhydra.shark.api.client.wfmodel.TransitionNotAllowed;
import org.enhydra.shark.api.client.wfmodel.WfProcess;
import org.enhydra.shark.api.client.wfmodel.WfProcessIterator;
import org.enhydra.shark.api.client.wfmodel.WfProcessMgr;
import org.enhydra.shark.api.client.wfmodel.WfRequester;
import org.enhydra.shark.api.client.wfmodel.process_mgr_stateType;
import org.enhydra.shark.api.internal.security.SecurityManager;
import org.enhydra.shark.api.internal.working.WfProcessInternal;
import org.enhydra.shark.api.internal.working.WfProcessMgrInternal;
import org.enhydra.shark.api.internal.working.WfRequesterInternal;
import org.enhydra.shark.xpdl.XPDLConstants;

/**
 * WfProcessMgrImplWrapper - Workflow Process Manager implementation
 * 
 * @author Sasa Bojanic
 * @author Vladimir Puskas
 */
public class WfProcessMgrWrapper implements WfProcessMgr, Serializable {

   protected WMSessionHandle shandle;

   protected String name;

   /**
    * Creates new WfProcessMgrImplWrapper
    * 
    * @param name Name of the package where process definition exists.
    */
   protected WfProcessMgrWrapper(WMSessionHandle shandle, String name) throws Exception {
      this.shandle = shandle;
      this.name = name;
   }

   public int how_many_process() throws Exception {
      long tStamp = SharkUtilities.methodStart(shandle,
                                               "WfProcessMgrWrapper.how_many_process");

      try {
         checkSecurity("how_many_process", null);
         return SharkEngineManager.getInstance()
            .getInstancePersistenceManager()
            .getAllProcessesForMgr(shandle, name)
            .size();
      } finally {
         SharkUtilities.methodEnd(shandle,
                                  tStamp,
                                  "WfProcessMgrWrapper.how_many_process",
                                  this);
      }
   }

   public WfProcessIterator get_iterator_process() throws Exception {
      long tStamp = SharkUtilities.methodStart(shandle,
                                               "WfProcessMgrWrapper.get_iterator_process");

      try {
         checkSecurity("get_iterator_process", null);
         return SharkEngineManager.getInstance()
            .getObjectFactory()
            .createProcessIteratorWrapper(shandle, name);
      } finally {
         SharkUtilities.methodEnd(shandle,
                                  tStamp,
                                  "WfProcessMgrWrapper.get_iterator_process",
                                  this);
      }
   }

   public WfProcess[] get_sequence_process(int max_number) throws Exception {
      long tStamp = SharkUtilities.methodStart(shandle,
                                               "WfProcessMgrWrapper.get_sequence_process");

      try {
         checkSecurity("get_sequence_process", null);
         List processes = SharkUtilities.createProcessMgrsProcessWrappers(shandle, name);
         if (max_number > processes.size() || max_number <= 0) {
            max_number = processes.size();
         }
         WfProcessWrapper[] procs = new WfProcessWrapper[max_number];
         processes.subList(0, max_number).toArray(procs);

         return procs;
      } finally {
         SharkUtilities.methodEnd(shandle,
                                  tStamp,
                                  "WfProcessMgrWrapper.get_sequence_process",
                                  this);
      }
   }

   public boolean is_member_of_process(WfProcess member) throws Exception {
      long tStamp = SharkUtilities.methodStart(shandle,
                                               "WfProcessMgrWrapper.is_member_of_process");

      try {
         checkSecurity("is_member_of_process", null);
         String mgrName = member.manager().name();

         return mgrName.equals(this.name);
      } finally {
         SharkUtilities.methodEnd(shandle,
                                  tStamp,
                                  "WfProcessMgrWrapper.is_member_of_process",
                                  this);
      }
   }

   public process_mgr_stateType process_mgr_state() throws Exception {
      long tStamp = SharkUtilities.methodStart(shandle,
                                               "WfProcessMgrWrapper.process_mgr_state");

      try {
         checkSecurity("process_mgr_state", null);
         return getProcessMgrImpl(name).process_mgr_state(shandle);
      } finally {
         SharkUtilities.methodEnd(shandle,
                                  tStamp,
                                  "WfProcessMgrWrapper.process_mgr_state",
                                  this);
      }
   }

   public void set_process_mgr_state(process_mgr_stateType new_state)
      throws Exception,
         TransitionNotAllowed {
      long tStamp = SharkUtilities.methodStart(shandle,
                                               "WfProcessMgrWrapper.set_process_mgr_state");

      try {
         checkSecurity("set_process_mgr_state", null);

         WfProcessMgrInternal mgrInternal = getProcessMgrImpl(name);
         mgrInternal.set_process_mgr_state(shandle, new_state);
      } finally {
         SharkUtilities.methodEnd(shandle,
                                  tStamp,
                                  "WfProcessMgrWrapper.set_process_mgr_state",
                                  this + ",newState=" + new_state.value());
      }
   }

   public String name() throws Exception {
      long tStamp = SharkUtilities.methodStart(shandle, "WfProcessMgrWrapper.name");

      try {
         checkSecurity("name", null);
         return name;
      } finally {
         SharkUtilities.methodEnd(shandle, tStamp, "WfProcessMgrWrapper.name", this);
      }
   }

   public String description() throws Exception {
      long tStamp = SharkUtilities.methodStart(shandle, "WfProcessMgrWrapper.description");

      try {
         checkSecurity("description", null);
         return getProcessMgrImpl(name).description(shandle);
      } finally {
         SharkUtilities.methodEnd(shandle,
                                  tStamp,
                                  "WfProcessMgrWrapper.description",
                                  this);
      }
   }

   public String category() throws Exception {
      long tStamp = SharkUtilities.methodStart(shandle, "WfProcessMgrWrapper.category");

      try {
         checkSecurity("category", null);
         return getProcessMgrImpl(name).category(shandle);
      } finally {
         SharkUtilities.methodEnd(shandle, tStamp, "WfProcessMgrWrapper.category", this);
      }
   }

   public String version() throws Exception {
      long tStamp = SharkUtilities.methodStart(shandle, "WfProcessMgrWrapper.version");

      try {
         checkSecurity("version", null);
         return getProcessMgrImpl(name).version(shandle);
      } finally {
         SharkUtilities.methodEnd(shandle, tStamp, "WfProcessMgrWrapper.version", this);
      }
   }

   public Map context_signature() throws Exception {
      long tStamp = SharkUtilities.methodStart(shandle,
                                               "WfProcessMgrWrapper.context_signature");

      try {
         checkSecurity("context_signature", null);
         return getProcessMgrImpl(name).context_signature(shandle);
      } finally {
         SharkUtilities.methodEnd(shandle,
                                  tStamp,
                                  "WfProcessMgrWrapper.context_signature",
                                  this);
      }
   }

   public Map result_signature() throws Exception {
      long tStamp = SharkUtilities.methodStart(shandle,
                                               "WfProcessMgrWrapper.result_signature");

      try {
         checkSecurity("result_signature", null);
         return getProcessMgrImpl(name).result_signature(shandle);
      } finally {
         SharkUtilities.methodEnd(shandle,
                                  tStamp,
                                  "WfProcessMgrWrapper.result_signature",
                                  this);
      }
   }

   /**
    * Create a WfProcess object
    */
   public WfProcess create_process(WfRequester requester)
      throws Exception,
         NotEnabled,
         InvalidRequester,
         RequesterRequired {
      long tStamp = SharkUtilities.methodStart(shandle,
                                               "WfProcessMgrWrapper.create_process");

      try {
         checkSecurity("create_process", null);

         WfProcessMgrInternal mgr = getProcessMgrImpl(name);
         // check if this process is allowed to be created only internally
         if (mgr.category(shandle).equalsIgnoreCase(XPDLConstants.ACCESS_LEVEL_PRIVATE)) {
            throw new NotEnabled("The process definition defines only PRIVATE access!");
         }

         WfRequesterInternal req = SharkEngineManager.getInstance()
            .getObjectFactory()
            .createDefaultRequester(shandle,
                                    SharkEngineManager.getInstance()
                                       .getCallbackUtilities()
                                       .getUserId(shandle),
                                    requester);

         WfProcessInternal procInternal = mgr.create_process(shandle, req);
         WfProcess proc = SharkEngineManager.getInstance()
            .getObjectFactory()
            .createProcessWrapper(shandle,
                                  procInternal.manager_name(shandle),
                                  procInternal.key(shandle));
         return proc;
      } finally {
         SharkUtilities.methodEnd(shandle,
                                  tStamp,
                                  "WfProcessMgrWrapper.create_process",
                                  this);
      }
   }

   public String toString() {
      return "[name=" + name + "]";
   }

   /**
    * It is assumed that there can't be two or more processes mgrs having the same name.
    */
   public boolean equals(Object obj) {
      if (!(obj instanceof WfProcessMgr))
         return false;

      WfProcessMgr mgr = (WfProcessMgr) obj;
      try {
         if (obj instanceof WfProcessMgrWrapper) {
            return ((WfProcessMgrWrapper) obj).name.equals(name);
         }

         return mgr.name().equals(name);
      } catch (Exception ex) {
         return false;
      }
   }

   public int hashCode() {
      return this.name.hashCode();
   }

   protected void checkSecurity(String methodName, Map d) throws Exception {
      SecurityManager sm = SharkEngineManager.getInstance().getSecurityManager();
      if (sm != null) {
         sm.check_processmgr(shandle, name, methodName, d);
      }
   }

   protected WfProcessMgrInternal getProcessMgrImpl(String nme) throws Exception {
      WfProcessMgrInternal mgr = SharkUtilities.getProcessMgr(shandle, nme);
      if (mgr == null)
         throw new Exception("ProcessMgr " + nme + " does not exist");
      return mgr;
   }
}