processworkflow.java

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

      oldDataList.add(oldData);
      newDataList.add(newData);
    }
    if(orgIds!=null&&orgIds.length()>0){
      oldData.setAirAtiId(toActInstId);
      oldData.setAirVariableName("actOrgActor");
      newData.setAirStringValue(orgIds);
      oldDataList.add(oldData);
      newDataList.add(newData);

    }
    if(roleIds!=null&&roleIds.length()>0){
      oldData.setAirAtiId(toActInstId);
      oldData.setAirVariableName("actRoleActor");
      newData.setAirStringValue(roleIds);
      oldDataList.add(oldData);
      newDataList.add(newData);
    }
  }

  /**
   * 封装组合更新数据
   * @param toActInstId long
   * @param areaId String
   * @param userIds String
   * @param orgIds String
   * @param roleIds String
   * @param workItemCtxClt WorkItemContextCollection
   * @param newDataList List
   * @param oldDataList List
   */
  private void assembleWorkItemInsReleUpdateData(String areaId,String userIds,
      String orgIds,String roleIds,WorkItemContextCollection workItemCtxClt,
      List newDataList,List oldDataList)
      throws Exception{
    logger.info("begin AssembleWorkItemInsReleUpdateData...");
    //设置变量值，格式为：varActor;[user,role,org];areaId;[id1:parentid1,id2:parentid2,id3:parentid3]
    if(workItemCtxClt!=null&&workItemCtxClt.size()>0){
      for(int i=0;i<workItemCtxClt.size();i++){
        WorkItemReleData oldData=new WorkItemReleData();
        WorkItemReleData newData=new WorkItemReleData();
        WorkItemContext workItemCtx=workItemCtxClt.get(i);
        if(userIds!=null&&userIds.length()>0){
          oldData.setWkrWkiId(workItemCtx.getWorkItemID());
          oldData.setWkrVariableName("actUserActor");
          newData.setWkrStringValue(userIds);
          oldDataList.add(oldData);
          newDataList.add(newData);
        }
        if(orgIds!=null&&orgIds.length()>0){
          oldData.setWkrWkiId(workItemCtx.getWorkItemID());
          oldData.setWkrVariableName("actOrgActor");
          newData.setWkrStringValue(orgIds);
          oldDataList.add(oldData);
          newDataList.add(newData);
        }
        if(roleIds!=null&&roleIds.length()>0){
          oldData.setWkrWkiId(workItemCtx.getWorkItemID());
          oldData.setWkrVariableName("actRoleActor");
          newData.setWkrStringValue(roleIds);
          oldDataList.add(oldData);
          newDataList.add(newData);
        }
      }
    }
  }

  /**
   * 设定活动办理方式为推方式，由WorkItemContextCollection确定的工作项的参与者
   * @param sunflowClient SunflowClient
   * @param workItemCtxClt WorkItemContextCollection
   * @param actParticipator List
   * @return HashMap 返回每个工作项的委托人信息
   */
  private HashMap modifyPushTypeWorkitemParticipator(SunflowClient
      sunflowClient,WorkItemContextCollection workItemCtxClt,
      List actParticipator)
      throws Exception{
    logger.info("begin modifyPushTypeWorkitemParticipator...");
    if((workItemCtxClt==null&&workItemCtxClt.size()<=0)||(actParticipator==null||
        actParticipator.size()<1)){
      return null;
    }
    HashMap map=new HashMap();
    for(int i=0;i<actParticipator.size();i++){
      Participator actor=(Participator)actParticipator.get(i);
      if(actor.getType().equals("user")){
        if(workItemCtxClt.size()>i){
          WorkItemContext toWorkItemCtx=workItemCtxClt.get(i);
          WMTWflParticipant targetUser=new WMTWflParticipant();
          targetUser.setParticipantID(actor.getId());
          targetUser.setParticipantName(actor.getName());
          //修改参与者
          logger.info("modifyWorkItemExecutor userId is:"+actor.getId()+":"+
              actor.getName()+" workItemId is:"+toWorkItemCtx.getWorkItemID());
          sunflowClient.modifyWorkItemExecutor(toWorkItemCtx.getWorkItemID(),
              targetUser);
          //是否是代理人
          if(actor.isIfAgen()){
            //取得委托人
            map.put(Long.toString(toWorkItemCtx.getWorkItemID()),
                actor.getConsignUserId());
          }
        }
      }
    }
    return map;
  }

  /**
   * 从nextActInfo取出指定actId活动的参数值信息
   * @param nextActInfo NextActivityInfo
   * @return List 由ActivityParameterValue组成的list
   */
  private List getActivityParameterById(long actId,NextActivityInfo nextActInfo){
    //取得活动参数属性值
    NextActivityInfo nextAct=getActivityInfoById(actId,nextActInfo);
    return nextAct.getActivityParametervalue();
  }

  /**
   * 从nextActInfo取出活动指定actId的属性信息
   * @param actId long
   * @param nextActInfo NextActivityInfo
   * @return NextActivityInfo
   */
  private NextActivityInfo getActivityInfoById(long actId,
      NextActivityInfo nextActInfo){
    NextActivityInfo nextAct=null;
    //取得活动属性值
    if(nextActInfo.getNextActivity()!=null){
      for(int i=0;i<nextActInfo.getNextActivity().size();i++){
        NextActivityInfo tempInfo=(NextActivityInfo)nextActInfo.getNextActivity().
            get(i);
        if(tempInfo.getActivityID()==actId){
          nextAct=tempInfo;
        }
      }
    }
    return nextAct;
  }

  /**
   * 从nextActInfo取出活动指定actId的sendMode
   * @param actId long
   * @param nextActInfo NextActivityInfo
   * @return String
   */
  private String getActivitySendModeById(long actId,
      NextActivityInfo nextActInfo){
    NextActivityInfo actInfo=getActivityInfoById(actId,nextActInfo);
    List actParamList=null;
    //嵌套节点
    if(actInfo!=null&&actInfo.getActType()==2){
      if(actInfo.getFirstNestingActivity()!=null){
        actParamList=actInfo.getFirstNestingActivity().
            getActivityParametervalue();
      }
    }
    else{
      actParamList=actInfo.getActivityParametervalue();;
    }
    String sendMode="";
    if(actParamList!=null&&actParamList.size()>0){
      for(int i=0;i<actParamList.size();i++){
        ActivityParameterValue actParamValue=(ActivityParameterValue)
            actParamList.get(i);
        if(actParamValue.getAtr_variablename().equals("senderMode")){
          sendMode=actParamValue.getAtr_stringvalue();
        }
      }
    }
    logger.info("sendMode is:"+sendMode);
    return sendMode;
  }

  /**
   * 从nextActInfo取出活动指定actId的分裂方式
   * @param actId long
   * @param nextActInfo NextActivityInfo
   * @return long
   */
  private long getActivitySplitTypeById(long actId,NextActivityInfo nextActInfo){
    NextActivityInfo nextAct=getActivityInfoById(actId,nextActInfo);
    return nextAct.getAtd_split();
  }

  /**
   * 从nextActInfo取出活动指定actId的Method
   * @param actId long
   * @param nextActInfo NextActivityInfo
   * @return long
   */
  private int getActivityMethodById(long actId,NextActivityInfo nextActInfo){
    NextActivityInfo nextAct=getActivityInfoById(actId,nextActInfo);
    return nextAct.getActMethod();
  }

  /**
   * 从nextActInfo取出活动指定actId的TranType
   * @param actId long
   * @param nextActInfo NextActivityInfo
   * @return int
   */
  private int getActivityTranTypeById(long actId,NextActivityInfo nextActInfo){
    NextActivityInfo nextAct=getActivityInfoById(actId,nextActInfo);
    return nextAct.getTranType();
  }

  /**
   * 通过子流程类型的活动实例ID找到其生成的所有的流程实例(目前只取得处于激活状态的流程实例)。
   * @param actInstId long
   * @return Vector
   */
  public Vector getSubflowInstIdByActInstId(SunflowClient sunflowClient,
      long actInstId)
      throws Exception{
    Vector vector=new Vector();
    //long proId=0;
    logger.info("begin getSubflowInstIdByActInstId...");
    //取得当前工作项信息
    ProcessInstanceContextCollection proInstCtxClt=sunflowClient.
        listProcessInstancesBySubflowActInstID(actInstId);
    if(proInstCtxClt!=null&&proInstCtxClt.size()>0){
      for(int i=0;i<proInstCtxClt.size();i++){
        ProcessInstanceContext proInstCtx=proInstCtxClt.get(i);
        //处于激活状态的流程实例
        if(proInstCtx.getInstanceState()==1){
          vector.add(Long.toString(proInstCtx.getProInstanceID()));
        }
      }
    }
    logger.info("proInstId vector is:"+vector.toString());
    return vector;
  }

  /**
   * 创建工作流后对工作流进行保存，将业务与工作流建立起关联
   * @param userInfo 用户信息
   * @param workitemId 工作项id
   * @param businessId 业务id
   * @throws Exception
   */
  public void newAndSaveWorkflow(UserInfo userInfo,long workitemId,
      String businessId)
      throws Exception{
    logger.info("begin newAndSaveWorkflow...");
    SunflowClient sunflowClient=WorkflowSession.getSunflowClient(userInfo);
    WorkItemContext workItemCtx=null;
    try{
      //取得当前工作项信息
      workItemCtx=sunflowClient.findWorkItem(workitemId);
      if(workItemCtx==null){
        throw new WorkflowException("找不到id号为:"+workitemId+"的工作项。");
      }
    }
    finally{
      WorkflowSession.deleteSunflowClient(userInfo);
    }
    List relList=new ArrayList();
    WfWorkItemRel itemRel=new WfWorkItemRel();
    itemRel.setFromActivityName("");
    itemRel.setFromItemId(0);
    itemRel.setFromProInstId(workItemCtx.getProInstanceID());
    itemRel.setFromUserId(userInfo.getUserId());
    itemRel.setToActivityName(workItemCtx.getWorkItemName());
    itemRel.setToItemId(workitemId);
    itemRel.setToProInstId(workItemCtx.getProInstanceID());
    relList.add(itemRel);
    //将信息保存到表wf_workitem_rel中
    List proList=this.saveWorkItemRel(businessId,relList);
    //将信息保存到表wf_process_business_rel中
    this.saveProcessBusinessRel(proList);
    //保存工作项办理期限信息
    List processTimeList=new ArrayList();
    WfWorkitemProcessTime processTime=new WfWorkitemProcessTime();
    processTime.setWorkitemId(workitemId);
    processTimeList.add(processTime);
    this.saveWorkitemProcessTime(processTimeList);
  }

  /**
   * 根据流程实例ID，获得自动、路由节点的所有后继节点
   *
   * @param autoNode NextActivityInfo 自动、路由节点
   * @param actiList List 被激活的后继节点列表
   * @param procInstId long 流程实例ID
   */
  private void getNextActiInstDef(NextActivityInfo autoNode,List actiList,
      long baseActiInstId,long procInstId){
    long actiId=autoNode.getActivityID();
    long procDefId=autoNode.getProcDefID();
    long actiInstId=0;

    //等待当前实例执行完毕，因为实例执行完成时，会激活所有可能的后继节点
    while(!waitFinishExec(autoNode.getActivityID(),procInstId)){
      ;
    }

    //获取自动、路由节点的后继节点定义
    List autoNodeNextActiList=getAutoNextActi(actiId,procDefId);
    for(int i=0;i<autoNodeNextActiList.size();i++){
      NextActivityInfo nextActi=(NextActivityInfo)autoNodeNextActiList.get(i);

      //检查活动节点是否被激活
      actiInstId=ActivityTransferDAO.checkActivityHasActived(nextActi.
          getActivityID(),baseActiInstId,procInstId);
      if(actiInstId>0){
        //若后继节点是自动节点或路由节点，则递归，直至找到后继节点是手工节点
        if(nextActi.getActType()==3||nextActi.getActType()==4){
          getNextActiInstDef(nextActi,actiList,actiInstId,procInstId);
        }
        else{
          actiList.add(nextActi);
        }
      }
    }
  }

  /**
   * 获取自动、路由节点才的被激活的后继节点
   *
   * @param actiId long 活动定义ID
   * @param procDefId long 流程定义ID
   * @return List
   */
  private List getAutoNextActi(long actiId,long procDefId){
    List actiList=new ActivityTransferDAO().getActiByTranFromIdAndProcDefId(
        actiId,procDefId);

    return actiList;
  }

  /**
   * 检查活动实例是否已经执行完毕
   *
   * @param actiId long  活动定义ID
   * @param procInstId long 流程实例ID
   * @return boolean
   */
  private boolean waitFinishExec(long actiId,long procInstId){
    ActivityTransferDAO transDao=new ActivityTransferDAO();
    int status=transDao.getActiInstStatus(actiId,procInstId);

    while(status!=4){ //循环检查，直到状态为完成状态
      try{
        Thread.currentThread().sleep(800);
      }
      catch(Exception e){}

      status=transDao.getActiInstStatus(actiId,procInstId);
    }

    return true;
  }

  public static void main(String[] args)
      throws Exception{

    UserInfo userInfo=new UserInfo();
    userInfo.setHostName("10.21.106.75");
    userInfo.setPortName(1093);
    userInfo.setUserId("1000000007");
    userInfo.setPassword("123");
    userInfo.setLoginName("xiesl");
    //ProcessWorkFlow flow=new ProcessWorkFlow(userInfo);
    //flow.checkInWorkItem(22,null,null,null,null);
    //flow.modifySubflowWorkItem(null,207,85,1,null);

    //SunflowClient sunflowClient=WorkflowSession.getSunflowClient(userInfo);
    // sunflowClient.checkInWorkItem(335);
  }

}