processworkflow.java

来自「公司自己开发的工作流引擎」· Java 代码 · 共 1,509 行 · 第 1/4 页

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

import java.util.*;
import org.apache.log4j.*;
import cn.com.iaspec.workflow.*;
import cn.com.iaspec.workflow.engine.*;
import cn.com.iaspec.workflow.engine.dao.*;
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.exception.WorkflowException;

/**
 *
 * <p>Title:提交处理工作流 </p>
 * <p>Description: </p>
 * <p>Copyright: Copyright (c) 2005</p>
 * <p>Company: IASPEC Technologies</p>
 * @author xiesonglin
 * @version 1.0
 */
public class ProcessWorkFlow{
  private UserInfo userInfo;
  private String parentProInstId;
  private String aidSubflowTag;
  private long projectId;
  private static Logger logger=Logger.getLogger(ProcessWorkFlow.class);
  public ProcessWorkFlow(UserInfo user,String parentProInstId,
      String aidSubflowTag,long projectId){
    this.userInfo=user;
    this.aidSubflowTag=aidSubflowTag;
    this.parentProInstId=parentProInstId;
    this.projectId=projectId;
  }

  /**
   * 工作流提交处理
   * @param businessId String 申诉登记号
   * @param actVar ActivityVariable 活动变量
   * @param actParticipator Activity 活动参与者
   * @param nextActInfo NextActivityInfo 活动信息
   */
  public void processWorkflow(long workItemId,String businessId,
      ActivityVariable[] actVar,List actParticipator,
      NextActivityInfo nextActInfo)
      throws Exception{
    long startTime=System.currentTimeMillis();
    logger.info("begin processWorkflow...");
    logger.info("workItemId is:"+workItemId+" businessId is"+businessId);
    //如果为拉的方式，则申请工作项
    applyWorkItem(workItemId);
    //保存活动变量
    saveActivityVariable(businessId,workItemId,actVar,actParticipator,
        nextActInfo);
    //提交工作项
    List workItemTimeList=new ArrayList();
    List relList=checkInWorkItem(workItemId,businessId,actVar,actParticipator,
        nextActInfo,workItemTimeList);
    //将信息保存到表wf_workitem_rel中
    List infoList=this.saveWorkItemRel(businessId,relList);
    //将信息保存到表wf_process_business_rel中
    this.saveProcessBusinessRel(infoList);
    // 保存工作项办理期限信息(老的办理时限处理)
    this.saveWorkitemProcessTime(workItemTimeList);
    //更新当前工作项id对应的流程及活动实例完成所用的时间
    updateProcessAndActivityInstancePassTime(workItemId);
    //插入活动实例办理期限信息
    insertTimeLimitInfo(relList,workItemId,actParticipator);

    logger.info("Execution processWorkflow time: "+(System.currentTimeMillis()-
        startTime)+" ms.");
  }

  /**
   * 插入活动实例办理期限信息
   * @param relList 工作项关联列表，由WfWorkItemRel组成
   * @param workItemId 当前工作项id
   * @param actParticipator 已选活动设置信息
   */
  private void insertTimeLimitInfo(List relList,long workItemId,
      List actParticipator)
      throws Exception{
    if(relList!=null&&relList.size()>0){
      for(int i=0;i<relList.size();i++){
        WfWorkItemRel rel=(WfWorkItemRel)relList.get(i);
        if(rel.getToItemId()==workItemId){
          //当前工作项的办理期限信息已经在前一步骤设置，因此不需要再设置
          relList.remove(i);
          break;
        }
      }
      TimeLimitControl timeControl=new TimeLimitControl();
      timeControl.insertTimeLimitInfo(relList,actParticipator);
    }
  }

  /**
   * 更新工作项id对应的流程及活动实例完成所用的时间
   * @param workItemId 工作项id
   * @throws Exception
   */
  public void updateProcessAndActivityInstancePassTime(long workItemId)
      throws Exception{
    SunflowClient sunflow=WorkflowSession.getSunflowClient(userInfo);;
    try{
      TimeLimitControl timeConttrol=new TimeLimitControl();
      WorkItemContext workItem=sunflow.findWorkItem(workItemId);

      //活动实例已经办完，则更新活动实例的已用时间
      if(workItem.getActivityInstanceState()==4){
        timeConttrol.updateActivityInstancePassTime(workItem.
            getActivityInstanceID());
      }
      //流程实例已经办完，则更新流程实例的已用时间
      if(workItem.getProInstanceState()==5){
        timeConttrol.updateProcessInstancePassTime(workItem.getProInstanceID());
      }
    }
    finally{
      WorkflowSession.deleteSunflowClient(userInfo);
    }
  }

  /**
   * 申请工作项
   * @param userinfo UserInfo
   * @param workItemID long
   */
  public void applyWorkItem(long workItemID)
      throws Exception{
    SunflowClient sunflow=WorkflowSession.getSunflowClient(userInfo);;
    try{
      WorkItemContext workItem=sunflow.findWorkItem(workItemID);
      //如果为拉的方式，则申请工作项
      if(workItem.getState()==2){
        sunflow.applyWorkItem(workItemID);
      }
      else if(workItem.getState()>3){
        //工作流已经被申请，而且不是本人
        if(!userInfo.getUserId().equals(workItem.getExecutorID())){
          throw new WorkflowException("该任务已经被其它用户办理，提交失败。");
        }
      }
    }
    catch(Exception e){
      e.printStackTrace();
      throw new ApplyWorkItemException("申请任务出现异常。");
    }
    finally{
      WorkflowSession.deleteSunflowClient(userInfo);
    }
  }

  /**
   * 保存工作项办理期限信息
   * @param workItemTimeList List
   */
  public void saveWorkitemProcessTime(List workItemTimeList)
      throws Exception{
    long startTime=System.currentTimeMillis();
    logger.info("begin saveWorkitemProcessTime...");
    WfWorkitemProcessTimeDAO dao=new WfWorkitemProcessTimeDAO();
    dao.insertByIds(workItemTimeList);
    logger.info("Execution saveWorkitemProcessTime time: "+
        (System.currentTimeMillis()-startTime)+" ms.");
  }

  /**
   * 保存活动变量
   * @param actVar ActivityVariable 活动变量
   * @param actParticipator Activity 活动参与者
   * @param nextActInfo NextActivityInfo 活动信息
   */
  private void saveActivityVariable(String businessId,long workItemId,
      ActivityVariable[] actVar,List actParticipator,
      NextActivityInfo nextActInfo)
      throws Exception{
    long startTime=System.currentTimeMillis();
    logger.info("begin saveActivityVariable...");
    //转换类型
    WMTAttribute[] attr=GetWorkItemVariable.convertToWMTAttribute(actVar);

    //设置流向变量flowPath
    //单选方式
    if(nextActInfo.getAtd_split()==WorkflowConstant.ACTIVITY_XOR||
        nextActInfo.getAtd_split()==WorkflowConstant.ACTIVITY_NONE){
      for(int i=0;i<attr.length;i++){
        String flowShowStyle=nextActInfo.getActParamValueByName("flowShowStyle");
        //如果流向隐藏，并且有多个流向，则不对flowPath赋值
        if(flowShowStyle!=null&&flowShowStyle.equals("hide")&&actParticipator!=null&&
            actParticipator.size()>1){
          break;
        }
        if(attr[i].getAttributeName().equals("flowPath")){
          Activity act=(Activity)actParticipator.get(0);
          //设置为迁移名称
          logger.info("act.getTransName() is:"+act.getTransName());
          attr[i].setStringValue(act.getTransName());
        }
      }
    }
    //多选方式
    else if(nextActInfo.getAtd_split()==WorkflowConstant.ACTIVITY_AND){

      //如果流向隐藏，并且有多个流向，则不对flowPath赋值
      String flowShowStyle=nextActInfo.getActParamValueByName("flowShowStyle");
      if(flowShowStyle!=null&&flowShowStyle.equals("hide")&&actParticipator!=null&&
          actParticipator.size()>1){

      }
      //如果流向不隐藏则对flowPath赋值
      else{
        String sTemp="";
        //将多个流向的迁移名称相加
        for(int i=0;i<actParticipator.size();i++){
          Activity act=(Activity)actParticipator.get(i);
          sTemp=sTemp+","+act.getTransName();
        }
        //去掉“,”
        if(sTemp!=null&&!sTemp.equals("")){
          sTemp=sTemp.substring(1);
        }
        for(int i=0;i<attr.length;i++){
          if(attr[i].getAttributeName().equals("flowPath")){
            //设置为迁移名称
            logger.info("sTemp is:"+sTemp);
            attr[i].setStringValue(sTemp);
          }
        }
      }
    }

    //根据活动属性设置工作项个数的参数值
    for(int i=0;i<actParticipator.size();i++){
      Activity act=(Activity)actParticipator.get(i);
      int itemCountByUser=0;
      if(act.getParticipatorList()!=null){
        itemCountByUser=act.getParticipatorList().size();
      }
      //取得活动属性值
      NextActivityInfo nextAct=this.getActivityInfoById(act.getActId(),
          nextActInfo);
      //嵌套节点，则取得子流程第一个节点的信息
      if(nextAct.getActType()==2){
        nextAct=nextAct.getFirstNestingActivity();
      }
      //取得活动参数变量值
      String sendMode=this.getActivitySendModeById(act.getActId(),nextActInfo);

      //如果活动为“推”方式，sendMode值为“multi”时,活动的工作项个数由名称为itemCountByUser指定
      if(nextAct!=null&&
          nextAct.getActMethod()==WorkflowConstant.ACTIVITY_METHOD_PUSH&&
          sendMode!=null&&
          sendMode.equals(WorkflowConstant.ACTIVITY_SENDMODE_MULTI)){
        for(int m=0;m<attr.length;m++){
          if(attr[m].getAttributeName().equals("itemCountByUser")){
            //设置itemCountByUser的值为已选人数
            logger.info("itemCountByUser is:"+itemCountByUser);
            attr[m].setIntValue(itemCountByUser);
          }
        }
      }
      //如果活动为“拉”方式，则修改工作项的actUserActor(或者actOrgActor,actRoleActor)变量值
      else if(nextAct!=null&&
          nextAct.getActMethod()==WorkflowConstant.ACTIVITY_METHOD_PULL){
        //如果为返回方式，且为拉的方式
        if(nextAct.getActMethod()==WorkflowConstant.ACTIVITY_METHOD_PULL&&
            nextAct.getTranType()==1){
          String returnUserId="";
          //如果参与者不为空
          if(act.getParticipatorList()!=null&&
              act.getParticipatorList().size()>0){
            Participator participator=(Participator)act.getParticipatorList().
                get(0);
            if(participator!=null){
              returnUserId=participator.getId();
            }
          }
          //
          else{
            //设置返回活动的参与者为当前活动的发送者
            returnUserId=getReturnActor(nextAct.getProcInstID(),
                nextAct.getActivityID());
          }
          logger.info("begin asemble return actor...");
          Activity activity=new Activity();
          List actPartiList=new ArrayList();
          List activityList=new ArrayList();
          activity.setActId(nextAct.getActivityID());
          activity.setParticipatorList(actPartiList);
          Participator actor=new Participator();
          actor.setId(returnUserId);
          actor.setName("");
          actor.setParentId("");
          actor.setType("user");
          actPartiList.add(actor);
          activityList.add(activity);
          actParticipator=activityList;
        }
        this.modifyPullTypeVariable(attr,businessId,actParticipator);
      }
    }
    //修改参数值，应用到工作流引擎
    SunflowClient sunflowClient=WorkflowSession.getSunflowClient(userInfo);
    try{
      sunflowClient.modifyWorkItemRelevantData(workItemId,attr);
    }
    finally{
      WorkflowSession.deleteSunflowClient(userInfo);
      logger.info("Execution saveActivityVariable time: "+
          (System.currentTimeMillis()-startTime)+" ms.");
    }
  }

  /**
   * 修改办理方式为“拉”方式工作项actUserActor(或者actOrgActor,actRoleActor)变量值
   * @param attr WMTAttribute[]
   * @param businessId String
   * @param actParticipator List
   * @throws Exception
   */
  public void modifyPullTypeVariable(WMTAttribute[] attr,String businessId,
      List actParticipator)
      throws Exception{
    logger.info("begin modifyPullTypeVariable...");
    StringBuffer sbUser=new StringBuffer();
    StringBuffer sbOrg=new StringBuffer();
    StringBuffer sbRole=new StringBuffer();
    //封装组合参与者字符串
    //当前暂时只设置第一个流向的的参与者
    Activity act=(Activity)actParticipator.get(0);
    List partiList=act.getParticipatorList();
    assembleActorString(businessId,partiList,sbUser,sbOrg,sbRole);
    if(attr!=null&&attr.length>0){
      for(int i=0;i<attr.length;i++){
        if(attr[i].getAttributeName().equals("actUserActor")){
          if(sbUser.length()<=0){
            attr[i].setStringValue("null");
          }
          else{
            attr[i].setStringValue(sbUser.toString());
          }
        }
        if(attr[i].getAttributeName().equals("actOrgActor")){
          if(sbOrg.length()<=0){
            attr[i].setStringValue("null");
          }
          else{
            attr[i].setStringValue(sbOrg.toString());
          }
        }
        if(attr[i].getAttributeName().equals("actRoleActor")){
          if(sbRole.length()<=0){
            attr[i].setStringValue("null");
          }
          else{
            attr[i].setStringValue(sbRole.toString());
          }
        }
      }
    }
  }

  /**
   * 提交工作项
   * @param workItemId long
   * @param businessId String
   * @param actVar ActivityVariable[]
   * @param actParticipator List
   * @param nextActInfo NextActivityInfo
   * @throws Exception
   * @return List 由LaWorkItemRel组成的list;
   */
  private List checkInWorkItem(long workItemId,String businessId,
      ActivityVariable[] actVar,List actParticipator,
      NextActivityInfo nextActInfo,List workItemTimeList)