enginecontrol.java

公司自己开发的工作流引擎

package cn.com.iaspec.workflow.engine.business;

/**
 * <p>Title: 获取启动流程列表</p>
 * <p>Description: 深圳市劳动仲裁信息管理系统</p>
 * <p>Copyright: Copyright (c) 2005</p>
 * <p>Company: 永泰软件工程有限公司</p>
 * @author syj
 * @version 1.0
 */

import java.util.*;
import org.apache.log4j.*;
import cn.com.iaspec.workflow.engine.*;
import cn.com.iaspec.workflow.engine.dao.*;
import cn.com.iaspec.workflow.exception.*;
import cn.com.iaspec.workflow.vo.db.*;
import cn.com.iaspec.workflow.vo.workflow.*;
import com.sunyard.sunflow.client.*;
import com.sunyard.sunflow.engine.context.*;
import com.sunyard.sunflow.engine.dataclass.*;
import cn.com.iaspec.workflow.util.WorkflowUtil;
import cn.com.iaspec.workflow.db.WorkflowDBConnectionManager;

public class EngineControl{
  private static Logger logger=Logger.getLogger(EngineControl.class);
  public String hostName=null;
  public int portName;
  public String processDefineName=null;
  private UserInfo userinfo=null;
  ProcessDefinitionContext pic=null; //返回工作流实例

  public EngineControl(){
  }

  /**
   *根据用户ID取得,用户可以启动的流程ProcessDefine对象集合
   * @param userInfo UserInfo
   * @throws SQLException
   * @return ArrayList
   */
  public ArrayList getStartableProcessList(UserInfo userInfo)
      throws CannotGetSunFlowProcessNameException,Exception{

    this.userinfo=userInfo;
    ArrayList ProcessDefineList=new ArrayList();
    try{
      ProcessDefineList=WfStartableProcessDAO.getStartableProcessListDAO(
          userInfo.getUserId());
    }
    catch(Exception e){
      e.printStackTrace();
      throw new CannotGetSunFlowProcessNameException(
          "根据user_id调用DAO取得流程ID列表异常出错");
    }
    return ProcessDefineList;
  }

  /**
   *根据流程ID取得流程名称
   * @param proDefID long
   * @throws RemoteException
   * @throws CannotLinkToSunflowServerException
   * @throws Exception
   * @return String
   */
  public String ProcessDefinitionContextfindProcessDefinition(long proDefID)
      throws java.rmi.RemoteException,CannotLinkToSunflowServerException,
      Exception{
    String ProcessDefinitionName=null;
    SunflowClient sfClient=WorkflowSession.getSunflowClient(this.userinfo);
    try{
      if(sfClient!=null){
        ProcessDefinitionName=sfClient.findProcessDefinition(proDefID).
            getDefinitionName();
      }
    }
    catch(Exception e){
      e.printStackTrace();
      throw new CannotGetSunFlowProcessNameException("根据工作流程ID取流程名字异常出错");
    }
    finally{
      WorkflowSession.deleteSunflowClient(userinfo); //操作完成断开连接
    }
    return ProcessDefinitionName;
  }

  /**
   * 通过取得由流程类别代码指定的可启动流程
   * @param userinfo UserInfo
   * @param processTypeCode String
   * @return ArrayList
   */
  public ArrayList getStartableProcessListByType(UserInfo userinfo,
      String processTypeCode)
      throws CannotLinkToSunflowServerException,Exception{
    this.userinfo=userinfo;
    ArrayList arraylist=null;
    String process=null;
    ArrayList ProcessDefineList=new ArrayList();
    ProcessDefine prodefine=null;
    SunflowClient sfClient=WorkflowSession.getSunflowClient(this.userinfo);
    try{
      arraylist=WfStartableProcessDAO.getStartableProcessListDAO(userinfo.
          getUserId());
      //Iterator it =rraylist.iterator();
      Iterator it=arraylist.iterator();
      while(it.hasNext()){
        // prodefine=new ProcessDefin();LaStartableProcessUser lastartableprocesstartableProcessUser)it.next();
        prodefine=new ProcessDefine();
        WfStartableProcessUser lastartableprocess=(WfStartableProcessUser)it.
            next();
        //System.out.println("lastartableprocess.getProcessDefineId()"+lastartableprocess.getProcessDefineId());
        this.processDefineName=ProcessDefinitionContextfindProcessDefinition(
            Long.parseLong(lastartableprocess.getProcessDefineId())); //得到一个流程定义Name
        logger.info("-----根据流程ID取得流程名称成功,返回processDefineName---");

        WMTAttribute[] instAttribute=sfClient.getProcessDefinitionRelevantData(
            Long.parseLong(lastartableprocess.getProcessDefineId()),null); //得到一个流程定义的全部相关数据或部分相关数据

        for(int i=0;i<instAttribute.length;i++){
          process=instAttribute[i].getAttributeName();
          if(process.equals("processType")){
            String processTypeValue=instAttribute[i].getStringValue();
            if(processTypeValue.equals(processTypeCode)){
              prodefine.setProcessDefineId(Long.parseLong(lastartableprocess.
                  getProcessDefineId()));
              prodefine.setProcessDefineName(processDefineName);
              prodefine.setProcessTypeCode(processTypeValue);
              ProcessDefineList.add(prodefine);
            }

          }
        }

      }

    }
    catch(Exception e){
      e.printStackTrace();
      throw new CannotGetSunFlowProcessNameException("根据工作流程ID取流程名字异常出错");
    }
    finally{
      WorkflowSession.deleteSunflowClient(userinfo);
    }
    return ProcessDefineList;
  }

  /**
   * 工作流启动功能(根据流程id生成流程实例，并启动流程实例,并返回状态为1的工作项ID)
   * @param userinfo UserInfo
   * @param processDefineId String
   * @param title String
   * @param desc String
   * @return long
   */
  public synchronized ProcessDefine startPorcessDefine(UserInfo userinfo,
      long processDefineId,String procInstName,String desc)
      throws CreateInstanceException,Exception{
    this.userinfo=userinfo;
    SunflowClient sunflowClient=WorkflowSession.getSunflowClient(userinfo);
    long procInstID=0;
    long workItemID=0;
    WorkItemContextCollection workItemCollection=null;
    ProcessDefine prodefine=new ProcessDefine();
    try{
      procInstID=sunflowClient.createProcessInstance(processDefineId,
          procInstName,desc); //通过指定的流程定义ID来创建一个流程实例，返回一个流程实例ID
      sunflowClient.startProcess(procInstID); //启动流程实例
      workItemCollection=sunflowClient.listWorkitemByProInstID(procInstID);
      //根据流程实例ID取得当前实例的所有工作项成功/
      for(int i=0;i<workItemCollection.size();i++){
        WorkItemContext workItem=(WorkItemContext)workItemCollection.get(i);
        if(workItem.getState()==1){
          workItemID=workItem.getWorkItemID(); //取得状态为1的工作项ID
          // sunflowClient.checkOutWorkItem(workItemID);
        }
      }
      //取得当前工作项信息
      WorkItemContext workItemCtx=sunflowClient.findWorkItem(workItemID);
      prodefine.setProcessDefineId(processDefineId);
      prodefine.setProInstanceID(procInstID);
      prodefine.setWorkItemID(workItemID);
      prodefine.setWorkitemName(workItemCtx.getWorkItemName());
      prodefine.setWorkItemURL(workItemCtx.getDescription());
    }
    catch(java.rmi.RemoteException e){
      e.printStackTrace();
      throw new CreateInstanceException("创建流程实例异常。");

    }
    catch(Exception e){
      e.printStackTrace();
      throw new Exception("创建流程实例失败。");
    }
    finally{
      WorkflowSession.deleteSunflowClient(userinfo);
    }
    return prodefine;
  }

  /**
   * 根据工作状态查询用户的满足条件的工作(取待办任务)
   * @param userinfo UserInfo
   * @param querytask QueryTask
   * @param pageinfo PageInfo
   * @return ArrayList
   * @throws GetTaskBaseInfoException
   */
  public ArrayList getTaskListByUser(UserInfo userinfo)
      throws GetTaskBaseInfoException{
    ArrayList arraylist=new ArrayList();
    WfStartableProcessDAO lastartableprocessDAO=new WfStartableProcessDAO();
    arraylist=lastartableprocessDAO.getTaskListla_baseinfoDAO(userinfo);
    return arraylist;
  }

  /**
   *检出的工作项
   * @param workItemID long
   * @return boolean
   */
  public void checkOutWorkItem(UserInfo userInfo,long workItemId)
      throws Exception{
    SunflowClient sunflowClient=WorkflowSession.getSunflowClient(userInfo);
    try{
      //取得当前工作项信息
      WorkItemContext workItemCtx=sunflowClient.findWorkItem(workItemId);
      if(workItemCtx==null){
        throw new CannotFindPreferWorkItemInfoException("找不到指定的工作项信息。");
      }
      //如果当前用户与工作项的参与者相同，且状态为1，则checkout工作项
      if(workItemCtx.getExecutorID()!=null&&
          workItemCtx.getExecutorID().equals(userInfo.getUserId())&&
          workItemCtx.getState()==1){
        sunflowClient.checkOutWorkItem(workItemId);
      }
    }
    finally{
      WorkflowSession.deleteSunflowClient(userInfo);
    }
  }

  /**
   * 取得待办任务个数
   * @param proInstanceID long
   * @return Task
   * @throws GetTaskBaseInfoException
   */
  public long getTaskListCount(UserInfo userInfo)
      throws Exception{
    WfStartableProcessDAO dao=new WfStartableProcessDAO();
    return dao.getTaskListCount(userInfo);
  }

  /**
   * 重新分配工作项给某人
   *
   * @param workitemId long  工作项ID
   * @param newExecutor String 工作项新的执行者
   * @param userInfo UserInfo
   * @throws Exception
   */
  public void reassignWorkitem(long workitemId,String newExecutor,UserInfo userInfo)
      throws Exception{
    SunflowClient sunflowClient=WorkflowSession.getSunflowClient(userInfo);

    try{
      sunflowClient.reassignWorkItem(workitemId,newExecutor);
    }
    finally{
      WorkflowSession.deleteSunflowClient(userInfo);
    }
  }

  /**
   * 查询所有有效的流程定义
   *
   * @return List
   * @throws Exception
   */
  public List getAllProcesses()throws Exception{
    ProcessWorkflowDAO processDao = new ProcessWorkflowDAO();
    List processList = processDao.getAllProcesses();

    return processList;
  }

  public void setEngineConnectInfo(String hostName,String portName,String dbType)
      throws Exception{
    WorkflowUtil workflowUtil = new WorkflowUtil(hostName,Integer.parseInt(portName));
    if(dbType != null && !"".equals(dbType.trim())){
      WorkflowDBConnectionManager.getInstance().setDataBaseType(dbType);
    }
  }
}