processbatchcase.java

来自「公司自己开发的工作流引擎」· Java 代码 · 共 366 行

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.exception.CannotFindActivityException;
import cn.com.iaspec.workflow.util.*;
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.*;

/**
 *
 * <p>Title:批量分案处理 </p>
 * <p>Description: </p>
 * <p>Copyright: Copyright (c) 2005</p>
 * <p>Company: IASPEC Technologies</p>
 * @author xiesonglin
 * @version 1.0
 */
public class ProcessBatchCase{
  private static Logger logger=Logger.getLogger(ProcessWorkFlow.class);
  private UserInfo userInfo;
  public ProcessBatchCase(UserInfo user){
    this.userInfo=user;
  }

  /**
   * 批量分案处理
   * @param workItemIds String[] 需要批量提交处理的工作项
   * @param registerId String 申诉登记号
   * @param orgId String 处理部门
   * @param nextActName 下一活动的名称
   */
  public void processBatchCaseByNextActName(String[] workItemIds,
      String registerId,String orgId,String nextActName)
      throws Exception{
    for(int i=0;i<workItemIds.length;i++){
      processBatchCaseByNextActName(Long.parseLong(workItemIds[i]),registerId,
          orgId,nextActName);
    }
  }

  /**
   * 批量分案处理
   * @param list List 需要批量处理的案件信息list，由BatchCaseInfo组成
   * @param nextActName 下一活动的名称
   */
  public void processBatchCaseByNextActName(List list,String nextActName)
      throws Exception{
    if(list!=null&&list.size()>0){
      for(int i=0;i<list.size();i++){
        BatchCaseInfo info=(BatchCaseInfo)list.get(i);
        this.processBatchCaseByNextActName(info.getWorkItemId(),
            info.getRegisterId(),info.getOrgId(),nextActName);
      }
    }
  }

  /**
   * 批量分案处理
   * @param workItemIds String 需要批量提交处理的工作项
   * @param registerId String 申诉登记号
   * @param orgId String 处理部门
   * @param nextActName 下一活动的名称
   */
  private void processBatchCaseByNextActName(long workItemId,String registerId,
      String orgId,String nextActName)
      throws Exception{
    logger.info("begin processBatchCase...");
    logger.info("workItemId is:"+workItemId+" registerId is:"+registerId+
        " orgId is:"+orgId+" nextActName is:"+nextActName);
    SunflowClient sunflowClient=WorkflowSession.getSunflowClient(userInfo);
    try{
      ProcessWorkFlow flow=new ProcessWorkFlow(userInfo,null,null,0L);
      //设置工作项变量
      WMTAttribute[] attr=sunflowClient.getWorkItemRelevantData(workItemId,null);
      if(attr!=null&&attr.length>0){
        //取得当前工作项信息
        WorkItemContext workItemCtx=sunflowClient.findWorkItem(workItemId);
        if(workItemCtx==null){
          throw new CannotFindPreferWorkItemInfoException("找不指定的工作项信息。");
        }
        if(workItemCtx.getState()==4&&
            !workItemCtx.getExecutorID().equals(userInfo.getUserId())){
          logger.info("批量分案处理异常：申诉登记号为“"+registerId+"”，工作项为“"+workItemId+
              "”的任务已经被用户“"+workItemCtx.getExecutorID()+"”签收，不能为该工作项进行批量分案。");
        }
        if(workItemCtx.getState()==6){
          logger.info("批量分案处理异常：申诉登记号为“"+registerId+"”，工作项为“"+workItemId+
              "”的任务已经办结，不能为该工作项进行批量分案。");
        }
        //检入工作项
        if(workItemCtx.getState()==1){
          try{
            sunflowClient.checkOutWorkItem(workItemId);
            workItemCtx=sunflowClient.findWorkItem(workItemId);
          }
          catch(Exception ex){
            ex.printStackTrace();
            logger.info(ex);
            logger.info("批量分案处理异常：申诉登记号为“"+registerId+"”，工作项为“"+workItemId+
                "”的任务检入工作项时出现异常，不能为该工作项进行批量分案。");
          }
        }
        //检入工作项
        if(workItemCtx.getState()==2){
          try{
            sunflowClient.applyWorkItem(workItemId);
            workItemCtx=sunflowClient.findWorkItem(workItemId);
          }
          catch(Exception ex){
            ex.printStackTrace();
            logger.info(ex);
            logger.info("批量分案处理异常：申诉登记号为“"+registerId+"”，工作项为“"+workItemId+
                "”的任务申请工作项时出现异常，不能为该工作项进行批量分案。");
          }
        }

        ActivityContextCollection actCtxClt=sunflowClient.
            listActivityByProDefID(workItemCtx.getProDefinitionID());
        long actId=0;
        long maxActInstId=0;
        long toActId=0;
        long currActType=0;
        if(actCtxClt!=null&&actCtxClt.size()>0){
          for(int i=0;i<actCtxClt.size();i++){
            ActivityContext actCtx=actCtxClt.get(i);
            if(actCtx.getActivityName().equals(nextActName)){
              actId=actCtx.getActivityID();
              toActId=actId;
              currActType=actCtx.getType();
              if(currActType==2){ //如果时嵌套子流程，则取得子流程的第一个活动定义id
                toActId=getSubflowFirstActId(actId);
              }
              break;
            }
          }
        }
        logger.info("actId is:"+actId);
        //封装设定参与者
        List actPartiList=getOrgRoleActor(toActId,orgId);
        Activity activity=new Activity();
        List activityList=new ArrayList();
        activity.setActId(actId);
        activity.setParticipatorList(actPartiList);
        activityList.add(activity);
        //修改流程流向变量
        for(int i=0;i<attr.length;i++){
          if(attr[i].getAttributeName().equals("flowPath")){
            attr[i].setStringValue(nextActName);
          }
        }
        //修改工作项的actUserActor(或者actOrgActor,actRoleActor)变量值
        flow.modifyPullTypeVariable(attr,registerId,activityList);
        //保存变量值
        sunflowClient.modifyWorkItemRelevantData(workItemId,attr);
        //提交工作项
        logger.info("checkInWorkItem workItemId is:"+workItemId);
        sunflowClient.checkInWorkItem(workItemId);

        if(actId==0){
          throw new CannotFindActivityException("找不到名称为“"+nextActName+"的活动。");
        }
        else{
          //取得指定活动定义id的实例id
          maxActInstId=getActInstId(sunflowClient,workItemCtx.getProInstanceID(),
              actId,currActType,flow);
        }
        if(maxActInstId>0){
          //修改指定活动实例id所产生工作项的得参与者，并取得要保存的工作项关联信息
          List workItemTimeList=new ArrayList();
          List relList=flow.modifyWorkItemParticipator(sunflowClient,registerId,
              workItemCtx.getWorkItemName(),workItemId,
              workItemCtx.getProInstanceID(),maxActInstId,
              WorkflowConstant.ACTIVITY_METHOD_PULL,actPartiList,
              workItemTimeList);
          //将信息保存到表wf_workitem_rel中
          List proList=flow.saveWorkItemRel(registerId,relList);
          //将信息保存到表wf_process_case_info中
          flow.saveProcessBusinessRel(proList);
          // 保存工作项办理期限信息
          flow.saveWorkitemProcessTime(workItemTimeList);
        }
      }
    }
    finally{
      WorkflowSession.deleteSunflowClient(userInfo);
    }
  }

  /**
   * 将部门组装成参与者
   * @param toActId long
   * @param orgId String
   * @throws Exception
   * @return List
   */
  private List getOrgRoleActor(long toActId,String orgId)
      throws Exception{
    List actPartiList=new ArrayList();

    logger.info("begin getOrgRoleActor...");
    //取得活动的固定参与者
    ActiParticipantDAO dao=new ActiParticipantDAO();
    ActiParticipant parti=new ActiParticipant();
    parti.setAtpAtdId(toActId);
    parti.setAtpDesc("fixedRole");
    //按角色类型
    parti.setAtpPartiType(2);
    //设定类型为直接指定
    parti.setAtpSettingMode(0);
    List list=dao.query(parti);
    //如果有固定角色参与者，则将参与者转换为角色类型的参与者
    if(list!=null&&list.size()>0){
      for(int i=0;i<list.size();i++){
        Participator actor=new Participator();
        ActiParticipant actParti=(ActiParticipant)list.get(i);
        actor.setId(Long.toString(actParti.getAtpParticipantId()));
        actor.setName("");
        actor.setParentId(orgId);
        actor.setType("role");
        actPartiList.add(actor);
      }
    }
    //否则转换为部门类型的参与者
    else{
      Participator actor=new Participator();
      actor.setId(orgId);
      actor.setName("");
      actor.setParentId("0");
      actor.setType("org");
      actPartiList.add(actor);
    }
    return actPartiList;
  }

  /**
   * 取得活动定义id为activityId的变量名称为“firstActName”的值
   * @param activityId long
   * @return String
   */
  private String getFistActName(long activityId)
      throws Exception{
    logger.info("begin getFistActName...");
    String value="";
    List list=ActivityTransferDAO.getActivityParameterValue(activityId);
    if(list!=null&&list.size()>0){
      for(int i=0;i<list.size();i++){
        ActivityParameterValue pram=(ActivityParameterValue)list.get(i);
        if(pram.getAtr_variablename().equals("firstActName")){
          value=pram.getAtr_stringvalue();
        }
      }
    }
    logger.info("value is:"+value);
    return value;
  }

  /**
   * 根据父类型的嵌套活动类型节点id取得子流程第一节点的id
   * @param activityId long
   * @throws Exception
   * @return long
   */
  private long getSubflowFirstActId(long activityId)
      throws Exception{
    logger.info("begin getSubflowFirstActInfo...");
    long subActId=0;
    NextActivityInfo info=NestingFlowControl.getNestingFirstActivity(userInfo,
        activityId,getFistActName(activityId));
    if(info!=null){
      subActId=info.getActivityID();
    }
    return subActId;
  }

  /**
   * 取得流程实例id中活动定义id对应的活动实例id
   * @param activityId long
   * @return long
   */
  private long getActInstId(SunflowClient sunflowClient,long proInstId,
      long activityId,long currActType,ProcessWorkFlow flow)
      throws Exception{
    logger.info("begin getActInstId...");
    long maxActInstId=0;
    //取得指定活动定义id的实例id
    ActivityInstanceContextCollection actInsCxtClt=sunflowClient.
        listActivityInstanceByProInsID(proInstId);
    //如果当前活动类型为嵌套子节点类型，则取得子流程第一个节点的活动实例id.

    //如果当前活动类型为嵌套子节点类型，则取得子流程第一个节点的活动实例id.
    if(currActType==2){
      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()==activityId&&
            actInsCxt.getActivityInstanceID()>maxActInstId){
          maxActInstId=actInsCxt.getActivityInstanceID();
        }
        //}
      }
      //取得toActId子流程实例id，暂时只支持单个子流程
      Vector vector=flow.getSubflowInstIdByActInstId(sunflowClient,
          maxActInstId);
      long subProInstId=0;
      if (vector!=null&&vector.size()>0){
        subProInstId=Long.parseLong ((String)vector.get(0));
      }
      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);
      maxActInstId=subMaxActInstId;
    }
    else{
      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();
          }
        }
      }
    }
    logger.info("maxActInstId is:"+maxActInstId);
    return maxActInstId;
  }

  public static void main(String[] args)
      throws Exception{
    WorkflowUtil.hostName="10.21.106.168";
    WorkflowUtil.portName=1093;
    UserInfo userInfo=new UserInfo();
    userInfo.setLoginName("zhoual");
    userInfo.setPassword("123");
    userInfo.setHostName("10.21.106.168");
    userInfo.setPortName(1093);
    ProcessBatchCase batch=new ProcessBatchCase(userInfo);
    batch.processBatchCaseByNextActName(1927,"20051310","30011","庭内分案");
  }

}