工作流API

package com.hbsh.erpextend.finance.dao.impl;


import java.sql.Date;
import java.sql.Timestamp;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;


import com.chinasofti.ro.bizframework.core.libs.StringUtil;
import com.chinasofti.ro.bizframework.core.orm.DAO;
import com.chinasofti.ro.bizframework.modules.json.JSonUtil;
import com.hbsh.erpextend.basedata.dao.IRoOrgDao;
import com.hbsh.erpextend.basedata.util.Constants;
import com.hbsh.erpextend.finance.dao.IWorkFlowDao;
import com.hbsh.erpextend.finance.model.CommonUtil;
import com.hbsh.erpextend.finance.model.FiInddexAppendAudit;
import com.hbsh.erpextend.finance.model.ISBusinessException;
import com.hbsh.erpextend.finance.model.ISSysException;
import com.hbsh.erpextend.finance.model.Participant;
import com.hbsh.erpextend.finance.model.ProcessInfoVO;
import com.icss.j2ee.dao.DAOException;
import com.icss.resourceone.common.logininfo.UserInfo;
import com.icss.resourceone.sdk.framework.EntityException;
import com.icss.resourceone.sdk.framework.Organization;
import com.icss.resourceone.sdk.framework.Person;
import com.icss.ro.starflow.engine.exception.WfException;
import com.icss.ro.starflow.engine.impl.db.model.WeEffortVO;
import com.icss.starflow.sdk.WmActivityDefinition;
import com.icss.starflow.sdk.WmActivityInstance;
import com.icss.starflow.sdk.WmException;
import com.icss.starflow.sdk.WmFactory;
import com.icss.starflow.sdk.WmNote;
import com.icss.starflow.sdk.WmParticipant;
import com.icss.starflow.sdk.WmProcessDefinition;
import com.icss.starflow.sdk.WmProcessInstance;
import com.icss.starflow.sdk.WmTransitionDefinition;
import com.icss.starflow.sdk.WmWorkItem;
import com.icss.starflow.sdk.condition.ProcessDefinitionCondition;
import com.icss.starflow.sdk.condition.WorkItemCondition;


public class WorkFlowDaoImpl extends DAO implements IWorkFlowDao {
private IRoOrgDao roOrgDao;

public IRoOrgDao getRoOrgDao() {
return roOrgDao;
}
public void setRoOrgDao(IRoOrgDao roOrgDao) {
this.roOrgDao = roOrgDao;
}
/**
* 获取全部流程
*/
@Override
public List<WmProcessDefinition> getWorkFlow() throws WmException {
ProcessDefinitionCondition processCondition=new ProcessDefinitionCondition();
processCondition.setPackageId("Budget");
List<WmProcessDefinition> processcons=(List<WmProcessDefinition>)WmFactory
.getInstance(null, null)
.getProcessDefinitions(processCondition);
return processcons;
}
/**
* 流程启动
* @throws WmException 
*/
public void startFlow(String uuid,String person,ProcessInfoVO processInfo) throws WmException{
WmFactory factory =WmFactory.getInstance(processInfo.getPackageId(), null);
UserInfo userInfo = CommonUtil.getUserInfo();
// person="[{'partyId':'8a569c8e3b3f61a2013b3f61a2620000','partyName':'wyz','activityId':'DirectorExamine'}]";
        List<Participant> lParticipants= JSonUtil.paserJsonArray(Participant.class, person);
        Map<String,List<WmParticipant>> result = new HashMap<String, List<WmParticipant>>();
for(Participant par:lParticipants){
WmParticipant wmp = new WmParticipant(par.getPartyId(),par.getPartyName(),WmParticipant.HUMAN);
List<WmParticipant> parList = result.get(par.getActivityId());
if(parList == null){
parList = new ArrayList<WmParticipant>();
result.put(par.getActivityId(), parList);
}
parList.add(wmp);
}
ProcessInfoVO processInfoVO = null ;
processInfoVO = new ProcessInfoVO();
processInfoVO.setProcessDefineId(processInfo.getProcessDefineId());
processInfoVO.setProcessDefineName(processInfo.getProcessDefineName());
processInfoVO.setPackageId(processInfo.getPackageId());
processInfoVO.setPackageVersion(processInfo.getPackageVersion());
processInfoVO.setPartyId(userInfo.getPersonUuid());
processInfoVO.setDynamicAssignments(result);

WmProcessInstance processInstance=factory.getInstance(processInfoVO.getPackageId(), processInfoVO.getPackageVersion())
.createProcessInstance(processInfoVO.getProcessDefineId(), processInfoVO.getWorkEffortId(),processInfoVO.getPartyId() , processInfoVO.getContext());
Map<String,Object> context3 = processInfoVO.getContext();

try {

if(!context3.isEmpty()){
processInstance.addContextValues(context3);
}
processInstance.setAppDataUuid(uuid);
WeEffortVO evo=processInstance.getEffortVO();
//获得拟稿节点
WmActivityDefinition activityDefinition = processInstance.getDefinition().getDraftActivityDefinition();
//活动IDs
List<String> activityIds = new ArrayList<String>();
//获得拟稿节点离开的边
List<WmTransitionDefinition> transitionDefinitions = activityDefinition.getNextTransitionDefinitions();
activityIds = getActivityIdsByTransition(transitionDefinitions,activityIds,context3);
//保存统一代办
saveProcessDate(uuid);

/**
* 动态设置参与者，前台选择人
*/
Map<String,List<WmParticipant>> participant = processInfoVO.getDynamicAssignments();
for(Map.Entry<String, List<WmParticipant>> entry : participant.entrySet()){
processInstance.setDynamicAssignments(entry.getKey(), entry.getValue());
}

processInstance.start();  //流程启动    processInstance 工作流流程实例 WmProcessInstance
// processInstance.getWorkEffortId(); //获得当前启动流程流程实例ID
}
catch(Exception e){
try {
throw e;
} catch (Exception e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
}
}

/**
* 保存统一代办信息
*/
public void saveProcessDate(String uuid){
String orgName = ""; //部门名称
String orgCode = ""; //部门编号
String partyId = ""; //参与者id
String username = ""; //参与者名称
UserInfo userInfo = CommonUtil.getUserInfo(); //获取当前参与者
username = userInfo.getCnName();
partyId = userInfo.getPersonUuid();
Person person = CommonUtil.getCurrentPerson();
List orgs = new ArrayList();
try {
orgs= person.getOrganization();
Organization org = (Organization)orgs.get(0);
orgName = org.getName();
orgCode = org.getOrgcode();
} catch (EntityException e) {
logger.error("获取当前用户所在的组织机构失败!",e);
throw new ISSysException("获取当前用户所在的组织机构失败!");
}
//当前日期
java.util.Date date1=new java.util.Date();
Date date=new Date(date1.getTime());
//流水号
SimpleDateFormat formatter = new SimpleDateFormat("yyMMddHHmmss");
String serialnumber = formatter.format(date1);
/**
* 保存业务扩展表数据
*/
//保存审计信息
StringBuilder sql=new StringBuilder("insert into is_process_data@hbshflow values"); //通过dblink插入图一代办数据
sql.append("(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)");
Object[] param={null,null,orgCode,orgName,null,null,null,null,null,uuid,null,partyId,date,serialnumber,"10.214.28.14","8080","erpextend"};
int num= this.execute(sql.toString(), param);

}

/**
* 获取最终参与者列表
* @throws WmException 
* @throws DAOException 
*/
public List getPerson(ProcessInfoVO processInfoVO) throws WmException, DAOException{
WmProcessInstance processInstance =null;
Map context = new HashMap();
UserInfo userInfo = CommonUtil.getUserInfo(); //获取当前参与者
WmActivityDefinition activityDefinition=null;
//判断流程是否新启动
if(processInfoVO!=null && processInfoVO.getActivityId()!=null && !processInfoVO.getActivityId().equals("")){
// processInfoVO.setPartyId(userInfo.getPersonUuid());
WmWorkItem workItem=this.getWmWorkItem(processInfoVO); //获得工作项活动实例

processInstance=workItem.getProcessInstance(); //获取流程活动实例
List ls=processInstance.getDefinition().getActivityDefinitions();  //获取全部流程节点信息
Iterator itr=ls.iterator();
//得到下一节点实例
while(itr.hasNext()){
WmActivityDefinition str=(WmActivityDefinition)itr.next();
String[] sp=str.toString().split("/");
for(String ss:sp){
if(ss.equals(processInfoVO.getActivityId())){
activityDefinition=str;
break;
}
}
}
}else{
//获取下一节点实例
WmFactory factory =WmFactory.getInstance(processInfoVO.getPackageId(), null);
String workEffortName = processInfoVO.getWorkEffortId();
       context.put("workEffortName", workEffortName);
       //processId 流程ID, processVersion 流程版本, workEffortName 工作项名称, personUuid 人员uuid,context 初始上下文
processInstance =factory.createProcessInstance(processInfoVO.getProcessDefineId(), workEffortName, userInfo.getUserID(), context);
activityDefinition = processInstance.getDefinition().getDraftActivityDefinition();
}
//获取迁移线集合
List<WmTransitionDefinition> transitionDefinitions = activityDefinition.getNextTransitionDefinitions();
WmActivityDefinition ad=null;
//判断下一步流程走哪个节点
if(processInfoVO.getActivityId()!=null && processInfoVO.getActivityId().equals("FinanceApp")){
ad = transitionDefinitions.get(1).getToActivityDefinition();
}else{
ad = transitionDefinitions.get(0).getToActivityDefinition();
}
//获取流程节点参与者
List particioants= ad.getParticipants(context);
List ss=null;
        for (Iterator it = particioants .iterator(); it.hasNext();) {
        WmParticipant participant = (WmParticipant) it.next();
        //获取最终参与者集合
        ss= participant.getFinalParticipant();
        }
        
        return ss;
}

/**
* 获取工作项实例
* @param processInfoVO
* @return
*/
public WmWorkItem getWmWorkItem(ProcessInfoVO processInfoVO) {
WmWorkItem wmWorkItem;
if(StringUtil.isBlank(processInfoVO.getPackageId())){
throw new ISBusinessException("流程包的ID不能为空!");
}
if(StringUtil.isBlank(processInfoVO.getPackageVersion())){
throw new ISBusinessException("流程包的版本不能为空!");
}
if(StringUtil.isBlank(processInfoVO.getWorkEffortId())){
throw new ISBusinessException("工作项的ID不能为空!");
}
// if(StringUtil.isBlank(processInfoVO.getPartyId())){
// throw new ISBusinessException("当前登陆用户的ID不能为空!");
// }
try {
WmFactory factory=WmFactory.getInstance(processInfoVO.getPackageId(),processInfoVO.getPackageVersion());
wmWorkItem = factory.getWorkItem(processInfoVO.getWorkEffortId(),null);
} catch (WmException e) {
logger.error("获得指定活动实例ID: "+processInfoVO.getWorkEffortId()+"和参与者的ID:"+processInfoVO.getPartyId()+"的工作项!",e);
throw new ISSysException("获得指定活动实例ID: "+processInfoVO.getWorkEffortId()+"和参与者的ID:"+processInfoVO.getPartyId()+"的工作项!");
}
return wmWorkItem;
}


public List<String> getActivityIdsByTransition(List<WmTransitionDefinition> transitionDefinitions,List<String> activityIds,Map<String,Object> map){
for (WmTransitionDefinition transitionDefinition : transitionDefinitions) {
try {
WmActivityDefinition ad = transitionDefinition.getToActivityDefinition();
//获得的ID
String activityId = "";
//获得的类型
String activityType = ad.getActivityTypeEnumId();
if("TYPE_ROUTE".equals(activityType)){
//获得迁移汇合类型
String joinType = ad.getJoinTypeEnumId();
if("JOIN_TYPE_AND".equals(joinType)){
//并行
List<WmTransitionDefinition> tds = ad.getNextTransitionDefinitions();
activityIds.addAll(getActivityIdsByTransition(tds,activityIds,map));
}else if("JOIN_TYPE_XOR".equals(joinType)){
//分支
List<WmTransitionDefinition> tds  = ad.getNextTransitionDefinitions(map);
activityIds.addAll(getActivityIdsByTransition(tds,activityIds,map));
}
}else{
activityId = ad.getActivityId();
activityIds.add(activityId);
}
} catch (WmException e) {
logger.error("获得活动定义失败!");
//throw new ISBusinessException("获得活动定义失败!");
}
}
return activityIds;
}
/**
* 待办工作
*/
public List toDoWork() throws WmException{
WorkItemCondition condition=new WorkItemCondition();
UserInfo userInfo = CommonUtil.getUserInfo();
condition.setPartyId(userInfo.getPersonUuid());
// condition.setPartyId("8a569c8e3b3f61a2013b3f61a2620000");
List TODO_STATES=new ArrayList();
TODO_STATES.add(WmWorkItem.CAL_ACCEPTED);
condition.setCurrentStates(TODO_STATES);
return WmFactory.getInstance(null,null).getWorkItems(condition);
}
/**
* 已办工作
*/
public List doneWork() throws WmException{
WorkItemCondition condition=new WorkItemCondition();
UserInfo userInfo = CommonUtil.getUserInfo();
condition.setPartyId(userInfo.getPersonUuid());
// condition.setPartyId("8a569c8e3b3f61a2013b3f61a2620000");
condition.setCurrentStates(WorkItemCondition.DEAD_STATES);
condition.setNormal(true);
return WmFactory.getInstance(null,null).getWorkItems(condition);
}
/**
* 流程启动下一步
* @param processInfoVO
*/
public void submitToDynamicAssignments(String relationTable,ProcessInfoVO processInfoVO,String person) {
UserInfo userInfo = CommonUtil.getUserInfo(); //获取当前参与者
if(!person.equals("end")){ //判断下一节点是否是结束节点
//格式化前台选择参与者格式
List<Participant> lParticipants= JSonUtil.paserJsonArray(Participant.class, person);
       Map<String,List<WmParticipant>> result = new HashMap<String, List<WmParticipant>>(); 
       
for(Participant par:lParticipants){
WmParticipant wmp = new WmParticipant(par.getPartyId(),par.getPartyName(),WmParticipant.HUMAN);
List<WmParticipant> parList = result.get(par.getActivityId());
if(parList == null){
parList = new ArrayList<WmParticipant>();
result.put(par.getActivityId(), parList);
}
parList.add(wmp);
}
processInfoVO.setDynamicAssignments(result);
}else{
//下一节点是结束节点的时候，设置先一步规则
List<Participant> lParticipants= JSonUtil.paserJsonArray(Participant.class, "[{'partyId':' ','partyName':' ','activityId':'end'}]");
       Map<String,List<WmParticipant>> result = new HashMap<String, List<WmParticipant>>();
       
for(Participant par:lParticipants){
WmParticipant wmp = new WmParticipant(par.getPartyId(),par.getPartyName(),WmParticipant.HUMAN);
List<WmParticipant> parList = result.get(par.getActivityId());
if(parList == null){
parList = new ArrayList<WmParticipant>();
result.put(par.getActivityId(), parList);
}
parList.add(wmp);
}
processInfoVO.setDynamicAssignments(result);
}
//设置当前办理人
processInfoVO.setPartyId(userInfo.getPersonUuid());
//获取活动工作项实例
WmWorkItem wmWorkItem = this.getWmWorkItem(processInfoVO);

Map<String,Object> context = processInfoVO.getContext();
try {
/**
* 判断锁定人是不是当前操作人
*/
String praryId = wmWorkItem.getPartyId();     //获得当前工作项的操作人
if(StringUtil.isBlank(praryId)){
logger.error("当前操作人不能为空!");
throw new ISBusinessException("当前操作人不能为空!");
}
WmActivityInstance ai = wmWorkItem.getActivityInstance();
String lockedPartyId = ai.getLockedPartyId();
if(!StringUtil.isBlank(lockedPartyId)){
if(!praryId.equals(lockedPartyId)){
logger.error("任务锁定人不是操作人!");
throw new ISBusinessException("任务锁定人不是操作人!");
}
}
//初始化流程变量
if(!context.isEmpty()){
wmWorkItem.setContext(context);
}
//初始化审批意见
takeNote(wmWorkItem,Constants.APP_DEFAULT_OK+processInfoVO.getWorkNote());
//保存审批记录
saveRecord( relationTable,Constants.APP_DEFAULT_OK+processInfoVO.getWorkNote(),wmWorkItem);
//提交前解锁
if(wmWorkItem.isLocked()){
if(wmWorkItem.canUnLock()){
wmWorkItem.unLock();
}
}
/**
* 动态设置参与者，前台选择人
*/
Map<String,List<WmParticipant>> participant = processInfoVO.getDynamicAssignments();
for(Map.Entry<String, List<WmParticipant>> entry : participant.entrySet()){
ai.getParent().setDynamicAssignments(entry.getKey(), entry.getValue());
}
//启动流程下一步（当前方式为自由流转）
wmWorkItem.complete(WmWorkItem.START_ACTIVITY_TYPE_RANDOM);

} catch (WmException e) {
logger.error("提交流程失败!",e);
// throw new ISSysException("提交流程失败!");
}
}

//保存审批意见
public void takeNote(WmWorkItem wmWorkItem,String workNote){
if(workNote.equals(Constants.APP_DEFAULT_OK)){
workNote += "无意见";
}
if(workNote != null || !"".equals(workNote)){
try {
wmWorkItem.takeNote(workNote, new Timestamp(System.currentTimeMillis()), "NormalNote");
} catch (WmException e) {
logger.error("保存审批意见失败!",e);
throw new ISSysException("保存审批意见失败!");
}
}
}
/**
* 回退
* @throws WmException 
*/
public void goBack(String relationTable,ProcessInfoVO processInfoVO) throws WmException{
UserInfo userInfo = CommonUtil.getUserInfo();
processInfoVO.setPartyId(userInfo.getPersonUuid());
String packageId = processInfoVO.getPackageId();             //流程包的ID
String packageVersion = processInfoVO.getPackageVersion();   //流程包的版本
String partyId = processInfoVO.getPartyId();                 //参与者的ID
if(StringUtil.isBlank(packageId)){
throw new ISBusinessException("流程包的ID不能为空!");
}
if(StringUtil.isBlank(packageVersion)){
throw new ISBusinessException("流程包的版本不能为空!");
}
if(StringUtil.isBlank(partyId)){
throw new ISBusinessException("参与者的ID不能为空!");
}
String activiryId = "";
WmWorkItem wmWorkItem = this.getWmWorkItem(processInfoVO);
//保存审批意见
takeNote(wmWorkItem,Constants.APP_DEFAULT_NO+processInfoVO.getWorkNote());
//保存审批记录
saveRecord(relationTable,Constants.APP_DEFAULT_NO+processInfoVO.getWorkNote(),wmWorkItem);
try {
WmActivityInstance ai = wmWorkItem.getActivityInstance();
activiryId = ai.getParent().getDefinition().getDraftActivityDefinition().getActivityId();
ai.sendToTarget(activiryId, null);
} catch (WmException e) {
logger.error("驳回申请人失败!");
throw new ISBusinessException("驳回申请人失败失败!");
}
}
/**
* 获取审批意见
* @throws WmException 
*/
public List getWorkNote(ProcessInfoVO processInfoVO) throws WmException{
UserInfo userInfo = CommonUtil.getUserInfo();
processInfoVO.setPartyId(userInfo.getPersonUuid());
//根据办理人，流程实例id获取活动实例id
WmWorkItem wmWorkItem = this.getWmWorkItem(processInfoVO);
//获取审批意见集合
List<WmNote> notes=wmWorkItem.getHistoryNotes("NormalNote");
return notes;
}

/**
* 初始化本部门参与者
* @throws WfException 
*/
public List getOrgPers(ProcessInfoVO processInfoVO) throws WfException{
UserInfo userInfo = CommonUtil.getUserInfo();
    List<WmParticipant> particioants=new ArrayList();
    //获取当前办理人部门
         String orgId = userInfo.getPrimaryOrguuid();
         orgId=roOrgDao.findRoOrgParentTree(Constants.ORG_ORGLEVEL_TWO, userInfo.getPrimaryOrguuid()).getOrgUuid();
         WmParticipant applyerorg = new WmParticipant(orgId+"01", WmParticipant.ORG); 
         //获取最终参与者列表
         particioants = applyerorg.getFinalParticipant();
         List<Participant> pars=new ArrayList<Participant>();
         //格式化最终参与者列表
         for(WmParticipant particioant:particioants){
        Participant par=new Participant();
        par.setPartyId(particioant.getParticipantId());
        par.setPartyName(particioant.getParticipantName());
        pars.add(par);
         }
    return pars;
}

/**
* 保存审批记录
*/
public void saveRecord(String relationTable,String workNote,WmWorkItem wmWorkItem){
UserInfo userInfo = CommonUtil.getUserInfo();
//获取办理时间
java.util.Date date1=new java.util.Date();
Date date=new Date(date1.getTime());
//新建审批记录实体
FiInddexAppendAudit audit=new FiInddexAppendAudit();
audit.setAppId(wmWorkItem.getAppDataUuid());
audit.setRelationTable(relationTable);
audit.setCurrentProcessId(wmWorkItem.getWorkflowProcessId());
//对是哪条流程的判定
if(wmWorkItem.getWorkflowProcessId().equals("objPerAdd"))
audit.setCurrentProcessName(Constants.STARFLOW_PACKAGE_NAME_OBJPERADD);
if(wmWorkItem.getWorkflowProcessId().equals("yearBudget"))
audit.setCurrentProcessName(Constants.STARFLOW_PACKAGE_NAME_YEARBUDGET);
if(wmWorkItem.getWorkflowProcessId().equals("materialOrderAppeal"))
audit.setCurrentProcessName(Constants.STARFLOW_PACKAGE_NAME_MATER);
audit.setCurrentSuggest(workNote);
audit.setCurrentProcessStep(wmWorkItem.getWorkflowActivityName());
audit.setCurrentUserid(userInfo.getUserID());
audit.setCurrentUserName(userInfo.getCnName());
audit.setCurrentTime(date);
audit.setCurrentStatus("0");
updateRe(wmWorkItem.getAppDataUuid());
this.save(audit);
}

/**
* 修改已有记录状态
*/
public void updateRe(String uuid){
StringBuilder sql=new StringBuilder("");
sql.append("update fi_inddex_append_audit set current_status='1' ");
sql.append("where app_id='"+uuid+"'");
this.execute(sql.toString(), new String[] {});
}

/**
* 收回工作项
* @throws WmException 
*/
public boolean getDoneWork(ProcessInfoVO processInfoVO) throws WmException{
UserInfo userInfo = CommonUtil.getUserInfo();
processInfoVO.setPartyId(userInfo.getUserID());
WmWorkItem workItem=getWmWorkItem(processInfoVO);
if(workItem.canCallback()){
workItem.callback("false");
return true;
}else
return false;
}
/**
* 终止流程
*/
public void endFlow(ProcessInfoVO processInfoVO){
try {
this.getWmWorkItem(processInfoVO).getProcessInstance().terminate(false);
} catch (WmException e1) {
logger.error("terminate error:",e1);
throw new ISSysException("无法终止流程!");
}
}
}