processworkflow.java

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

      throws Exception{
    //提交当前工作项，应用到工作流引擎
    long startTime=System.currentTimeMillis();
    long procInstId=0;
    long actiInstId=0;

    logger.info("begin checkInWorkItem");
    logger.info("workItemId is:"+workItemId);
    SunflowClient sunflowClient=WorkflowSession.getSunflowClient(userInfo);
    try{
      logger.info("Execution getSunflowClient time: "+(System.currentTimeMillis()-
          startTime)+" ms.");
      sunflowClient.checkInWorkItem(workItemId);

      //
      WorkItemContext workitemContext=sunflowClient.findWorkItem(workItemId);
      procInstId=workitemContext.getProInstanceID();
      actiInstId=workitemContext.getActivityInstanceID();
      //
      logger.info("Execution sunflowClient.checkInWorkItem time: "+
          (System.currentTimeMillis()-startTime)+" ms.");
    }
    finally{
      WorkflowSession.deleteSunflowClient(userInfo);
    }

    //提交处理
    List workItemRelList=new ArrayList();
    List afterAutoNodeActiList=new ArrayList();

    for(int i=0;i<actParticipator.size();i++){
      Activity act=(Activity)actParticipator.get(i);
      NextActivityInfo nextInfo=this.getActivityInfoById(act.getActId(),
          nextActInfo);

      //==========为当前手工接点后续的自动接点、路由接点执行后的手工接点建立关联 =======
      if(nextInfo.getActType()==3||nextInfo.getActType()==4){
        getNextActiInstDef(nextInfo,afterAutoNodeActiList,actiInstId,procInstId);

        for(int actiNum=0;actiNum<afterAutoNodeActiList.size();actiNum++){
          NextActivityInfo nextActi=(NextActivityInfo)afterAutoNodeActiList.get(
              actiNum);

          workItemRelList.addAll(establishRelation(nextActi,businessId,
              workItemId,workItemTimeList,nextActi.getActivityID(),null));
        }
      }
      else{

        workItemRelList=establishRelation(nextInfo,businessId,workItemId,
            workItemTimeList,act.getActId(),act.getParticipatorList());

       //保存传递给后续活动的活动变量的值
        saveActivityVariable(workItemId,act);
      }

      //================== end ================


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

  private void saveActivityVariable(long workitemId,Activity act)
      throws Exception{
    List variableList=act.getVariablesList();
    long activityId=act.getActId(),maxActInstId=0;

    SunflowClient sunflowClient=WorkflowSession.getSunflowClient(userInfo);

    try{
      //取得当前工作项信息
      WorkItemContext workItemCtx=sunflowClient.findWorkItem(workitemId);
      if(workItemCtx==null){
        throw new CannotFindPreferWorkItemInfoException("找不到指定的工作项信息。");
      }
      //取得指定活动定义id的实例id
      ActivityInstanceContextCollection actInsCxtClt=sunflowClient.
          listActivityInstanceByProInsID(workItemCtx.getProInstanceID());
      if (actInsCxtClt!=null){
        for(int i=0;i<actInsCxtClt.size();i++){
          ActivityInstanceContext actInsCxt=actInsCxtClt.get(i);
          //取出目标活动的状态为2的最新实例
          if(actInsCxt.getState()==2){
            if(actInsCxt.getActivityID()==activityId&&
                actInsCxt.getActivityInstanceID()>maxActInstId){
              maxActInstId=actInsCxt.getActivityInstanceID();
            }
          }
        }
      }
    }
    catch(Exception ex){
      ex.printStackTrace();
      throw ex;
    }
    finally{
      WorkflowSession.deleteSunflowClient(userInfo);
    }
    new WorkItemReleDataDAO().updateWKIReleData(variableList,maxActInstId);
  }

  private List establishRelation(NextActivityInfo nextInfo,String businessId,
      long workItemId,List workItemTimeList,long actiId,List participatorList)
      throws Exception{
    List workItemRelList=null;

    int actMethod=nextInfo.getActMethod();
    int actType=nextInfo.getActType();
    int tranType=nextInfo.getTranType();

    //如果是推的方式，则要根据已经选择的人员设定工作项的参与者
    if(tranType!=1&&actType!=2&&actType!=6){
      workItemRelList=this.modifyWorkItemActivityId(businessId,workItemId,
          actiId,actMethod,participatorList,workItemTimeList);
    }
    //如果下一活动对应的变迁的“是否循环”为“是”，则该类型流向为返回方式,承办人为前次该活动的承办人
    else if(tranType==1&&actType!=2&&actType!=6){
      workItemRelList=this.modifyReturnWorkItem(businessId,workItemId,actiId,
          actMethod,workItemTimeList,participatorList);
    }
    //如果下一活动为嵌套子流程方式
    else if(actType==2&&tranType!=1&&actType!=6){
      //取得第一个节点的类型
      actMethod=nextInfo.getFirstNestingActivity().getActMethod();
      logger.info("actMethod is:"+actMethod);
      workItemRelList=this.modifySubflowWorkItem(businessId,workItemId,actiId,
          actMethod,participatorList,workItemTimeList);
    }
    //其它：结束节点
    else if(actType==6){
      workItemRelList=this.doEndNode(businessId,workItemId,actiId,actMethod,
          workItemTimeList);
    }

    return workItemRelList;
  }

  /**
   * 提交子流程，修改子流程的承办人
   * @param workItemId long 工作项id
   * @param toActId String 要启动的流向活动id
   * @param nextActInfo NextActivityInfo
   * @param toActMethod int  选定的活动办理方式（1推，2拉）
   * @param actParticipator 活动参与者
   * @return List 由LaWorkItemRel组成的list
   */
  private List modifySubflowWorkItem(String businessId,long workItemId,
      long toActId,int toActMethod,List actParticipator,List workItemTimeList)
      throws Exception{
    logger.info("begin modifySubflowWorkItem...");
    SunflowClient sunflowClient=WorkflowSession.getSunflowClient(userInfo);
    List relList=null;
    try{
      //取得当前工作项信息
      WorkItemContext workItemCtx=sunflowClient.findWorkItem(workItemId);
      if(workItemCtx==null){
        throw new CannotFindPreferWorkItemInfoException("找不指定的工作项信息。");
      }
      //取得当前流程实例id
      long currProInstId=workItemCtx.getProInstanceID();
      //取得toActId活动实例id

      logger.info("currProInstId is:"+currProInstId);
      logger.info("toActId is:"+toActId);
      //取得指定活动定义id的实例id
      ActivityInstanceContextCollection actInsCxtClt=sunflowClient.
          listActivityInstanceByProInsID(workItemCtx.getProInstanceID());
      long maxActInstId=0;
      for(int i=0;i<actInsCxtClt.size();i++){
        ActivityInstanceContext actInsCxt=actInsCxtClt.get(i);
        logger.info("actInsCxt.getActivityInstanceID is:"+
            actInsCxt.getActivityInstanceID());
        //取出目标活动的状态为4的最新实例
        //if(actInsCxt.getState()==4 ){
        if(actInsCxt.getActivityID()==toActId&&
            actInsCxt.getActivityInstanceID()>maxActInstId){
          maxActInstId=actInsCxt.getActivityInstanceID();
        }
        //}
      }
      logger.info("maxActInstId is:"+maxActInstId);
      if(maxActInstId>0){
        //取得toActId子流程实例id
        Vector vector=this.getSubflowInstIdByActInstId(sunflowClient,
            maxActInstId);
        if(vector!=null&&vector.size()>0){
          for(int k=0;k<vector.size();k++){
            long subProInstId=Long.parseLong((String)vector.get(k));
            logger.info("subProInstId is:"+subProInstId);

            //取得子流程的活动实例id
            long subMaxActInstId=0;
            ActivityInstanceContextCollection subActInstCtxClt=sunflowClient.
                listActivityInstanceByProInsID(subProInstId);
            if(subActInstCtxClt!=null&&subActInstCtxClt.size()>0){
              //取出目标活动的状态为2的最新实例
              for(int i=0;i<subActInstCtxClt.size();i++){
                ActivityInstanceContext subActInsCxt=subActInstCtxClt.get(i);
                if(subActInsCxt.getState()==2&&
                    subActInsCxt.getActivityInstanceID()>subMaxActInstId){
                  subMaxActInstId=subActInsCxt.getActivityInstanceID();
                }
              }
            }
            logger.info("subMaxActInstId is:"+subMaxActInstId);
            List tempActList=new ArrayList();
            if(actParticipator!=null&&actParticipator.size()>k){
              tempActList.add(actParticipator.get(k));
            }
            //修改指定活动实例id所产生工作项的得参与者，并取得要保存的工作项关联信息
            if(subMaxActInstId>0){
              List tempList=this.modifyWorkItemParticipator(sunflowClient,
                  businessId,workItemCtx.getWorkItemName(),workItemId,
                  workItemCtx.getProInstanceID(),subMaxActInstId,toActMethod,
                  tempActList,workItemTimeList);
              relList=addToWorkitemRelList(relList,tempList);
            }
          }
        }
      }
      return relList;
    }
    finally{
      WorkflowSession.deleteSunflowClient(userInfo);
    }
  }

  private List addToWorkitemRelList(List targetList,List srcList){
    if(targetList==null){
      targetList=new ArrayList();
    }
    if(srcList!=null&&srcList.size()>0){
      for(int i=0;i<srcList.size();i++){
        int iTag=0;
        WfWorkItemRel rel1=(WfWorkItemRel)srcList.get(i);
        for(int j=0;j<targetList.size();j++){
          WfWorkItemRel rel2=(WfWorkItemRel)targetList.get(j);
          if(rel1.getFromItemId()==rel2.getFromItemId()&&
              rel1.getToItemId()==rel2.getToItemId()){
            iTag=1;
            break;
          }
        }
        if(iTag!=1){
          targetList.add(rel1);
        }
      }
    }
    return targetList;
  }

  /**
   * 根据由WfWorkItemRel组成的list，将信息保存到表wf_workitem_rel中
   * @param list List
   * @return 返回由WfProcessBusinessRel组成的list;
   */
  public List saveWorkItemRel(String businessId,List list)
      throws Exception{
    long startTime=System.currentTimeMillis();
    logger.info("begin saveWorkItemRel...");
    List infoList=new ArrayList();
    if(list!=null){
      //取得返回结果
      for(int i=0;i<list.size();i++){
        WfWorkItemRel rel=(WfWorkItemRel)list.get(i);
        if(!checkExistInList(businessId,rel.getFromProInstId(),
            rel.getToProInstId(),infoList)){
          WfProcessBusinessRel info=new WfProcessBusinessRel();
          info.setProjectId(projectId);
          info.setBusinessId(businessId);
          if(rel.getFromProInstId()==rel.getToProInstId()){
            info.setFlowType("0");
            info.setParentProInstId(0);
            //是辅助子流程，则设置辅助子流程标记
            if(aidSubflowTag!=null&&aidSubflowTag.equals("1")&&parentProInstId!=null&&
                !parentProInstId.equals("")){
              info.setFlowType("2");
              info.setParentProInstId(Long.parseLong(this.parentProInstId));
            }
          }
          else{
            info.setFlowType("1"); //嵌套子流程
            info.setParentProInstId(rel.getFromProInstId());
          }
          info.setProInstId(rel.getToProInstId());
          infoList.add(info);
        }
      }
      //保存wf_workitem_rel信息
      WfWorkItemRelDAO dao=new WfWorkItemRelDAO();
      dao.insert(list);
    }
    logger.info("Execution saveWorkItemRel time: "+(System.currentTimeMillis()-
        startTime)+" ms.");
    return infoList;
  }

  /**
   * 检查是否在由WfProcessBusinessRel组成的lst存在由businessId，parentnstId，Id确定的记录
   * @param businessId String
   * @param parentInstId long
   * @param intId long
   * @param list List
   * @return boolean
   */
  private boolean checkExistInList(String businessId,long parentInstId,
      long instId,List list){
    boolean b=false;
    for(int i=0;i<list.size();i++){
      WfProcessBusinessRel info=(WfProcessBusinessRel)list.get(i);
      if(info.getBusinessId().equals(businessId)&&
          info.getParentProInstId()==parentInstId&&info.getProInstId()==instId){
        b=true;
        break;
      }
    }
    return b;
  }

  /**
   * 根据由WfProcessBusinessRel组成的list，将信息保存到表wf_process_business_rel中
   * @param list List
   */
  public void saveProcessBusinessRel(List list)
      throws Exception{
    //保存wf_process_business_rel信息
    long startTime=System.currentTimeMillis();
    logger.info("begin saveProcessBusinessRel...");
    WfProcessBusinessRelDAO dao=new WfProcessBusinessRelDAO();
    dao.insert(list);
    logger.info("Execution saveProcessBusinessRel time: "+
        (System.currentTimeMillis()-startTime)+" ms.");
  }

  /**
   *  修改由活动定义产生的工作项的参与者
   * @param currWorkItemId 当前工作项id
   * @param toActId 产生工作项的活动定义id
   * @param actParticipator 活动参与者
   * @param actMethod int  选定的活动办理方式（1推，2拉）
   * @return List 由LaWorkItemRel组成的list
   */
  private List modifyWorkItemActivityId(String businessId,long currWorkItemId,
      long toActId,int actMethod,List actParticipator,List workItemTimeList)
      throws Exception{
    logger.info("begin modifyWorkItemActivityId...");
    SunflowClient sunflowClient=WorkflowSession.getSunflowClient(userInfo);
    List relList=new ArrayList();
    try{
      //取得当前工作项信息
      WorkItemContext workItemCtx=sunflowClient.findWorkItem(currWorkItemId);
      if(workItemCtx==null){
        throw new CannotFindPreferWorkItemInfoException("找不到指定的工作项信息。");
      }
      //取得指定活动定义id的实例id
      ActivityInstanceContextCollection actInsCxtClt=sunflowClient.
          listActivityInstanceByProInsID(workItemCtx.getProInstanceID());
      long maxActInstId=0;
      for(int i=0;i<actInsCxtClt.size();i++){
        ActivityInstanceContext actInsCxt=actInsCxtClt.get(i);
        //取出目标活动的状态为2的最新实例
        if(actInsCxt.getState()==2){
          if(actInsCxt.getActivityID()==toActId&&
              actInsCxt.getActivityInstanceID()>maxActInstId){
            maxActInstId=actInsCxt.getActivityInstanceID();
          }
        }
      }
      logger.info("maxActInstId is:"+maxActInstId);
      if(maxActInstId>0){
        //修改指定活动实例id所产生工作项的得参与者，并取得要保存的工作项关联信息
        relList=this.modifyWorkItemParticipator(sunflowClient,businessId,
            workItemCtx.getWorkItemName(),currWorkItemId,
            workItemCtx.getProInstanceID(),maxActInstId,actMethod,
            actParticipator,workItemTimeList);