qq1988627
- 浏览: 107343 次
- 性别:
- 来自: 深圳
-
最新评论
-
qq1988627：
gaolegao2008 写道说的是个啥。有冲突怎么办呢。也不 ...
xfire与spring组合创建webservice -
gaolegao2008：
说的是个啥。有冲突怎么办呢。也不说个解决的办法。唉
xfire与spring组合创建webservice -
xiaoliefengfeng：
加油，为码农争光啊
我要的其实并不多 你为什么拒绝我 -
qq1988627：
huchaoqqqq 写道用的ext几版本做的呢，有没有相关资 ...
第一次使用Ext写系统 -
huchaoqqqq：
用的ext几版本做的呢，有没有相关资料，我也想最近弄下ext ...
第一次使用Ext写系统
package com.byd.mes.plugins.workFlow;
import java.util.List;
import java.util.Map;
import com.byd.mes.bussiness.bo.main.OperationBO;
import com.byd.mes.bussiness.bo.main.ResourceBO;
import com.byd.mes.bussiness.bo.main.RouterBO;
import com.byd.mes.bussiness.bo.siteoperation.sfc.SfcInfoBO;
import com.byd.mes.bussiness.bo.system.UserBO;
import com.bydwf.vo.NodeVo;
public interface BydWorkFlowService{
public interface Event{
void execute(SfcInfoBO sfc,RouterBO routerBo,OperationBO operation,ResourceBO resource,NodeVo nodeVo,UserBO userBo,WFContext wfContext);
}
public class WFContext{
private BydWorkFlowService s;
public WFContext(BydWorkFlowService s){
this.s = s;
}
public NodeVo getFirstNode(RouterBO routerBo){
return this.s.getFirstNode(routerBo);
}
public List<NodeVo> getAllNodes(RouterBO router){
return this.s.getAllNodes(router);
}
public List<NodeVo> getNextNodes(SfcInfoBO sfcInfoBo,String paramNodeId,Map contextproperties){
return this.s.getNextNodes(sfcInfoBo, paramNodeId, contextproperties);
}
public List<NodeVo> getNextNodes(RouterBO routerBo,String paramNodeId){
return this.s.getNextNodes(routerBo, paramNodeId);
}
public NodeVo getNodeById(RouterBO routerBo,String nodeId){
return this.s.getNodeById(routerBo, nodeId);
}
public RouterBO getPreviousRouter(SfcInfoBO sfcInfoBo){
return this.s.getPreviousRouter(sfcInfoBo);
}
public boolean isFirstOperation (OperationBO operation,RouterBO routerBo){
return this.s.isFirstOperation(operation, routerBo);
}
public boolean isNodeOperation(OperationBO operation,NodeVo nodeVo){
return this.s.isNodeOperation(operation, nodeVo);
}
public boolean isCurOperation(SfcInfoBO sfcInfoBo,OperationBO operationBo){
return this.s.isCurOperation(sfcInfoBo, operationBo);
}
}
/**
* 发起工作流,生成工序步骤信息
* @param parameter
* @return
*/
void load(SfcInfoBO sfcInfoBo,RouterBO routerBo,UserBO userBo,String beforeLoadClass,String afterLoadClass,Map map);
/**
* 将SFC状态由排队改为活动，如果传入的工艺路线是特殊工艺路线，如果之前没有走过，则发起工作流，生成工序步骤信息，
* 如果走过，则清空之前的工序步骤信息，然后到首工序活动
* @param sfcInfoBo
* @param routerBo
* @param sfcOperationBO
*/
void start(SfcInfoBO sfcInfoBo,OperationBO operationBO,ResourceBO resourceBo,RouterBO routerBo,UserBO userBo,String beforeStartClass,String afterStartClass,Map map);
/**
* 跳到到下一节点
* @param sfcInfoBo
* @param fromNodeId
* @param toNodeId
* @return
*/
void approve(SfcInfoBO sfcInfoBo,RouterBO routerBo,String toNodeId,UserBO userBo,String beforeApproveClass,String afterApproveClass,Map map);
/**
* 获取第一个节点
* @param sfcInfoBo
* @return
*/
@Deprecated
NodeVo getFirstNode(RouterBO routerBo);
/**
* 获取所有节点
* @param RouterBO
* @return List<NodeVo>
*/
List<NodeVo> getAllNodes(RouterBO router);
/**
* 获取下一下节点集
* @param sfcInfoBo
* @return
*/
List<NodeVo> getNextNodes(SfcInfoBO sfcInfoBo,String paramNodeId,Map contextproperties);
/**
* 获取下一下节点集
* @param sfcInfoBo
* @return
*/
List<NodeVo> getNextNodes(RouterBO routerBo,String paramNodeId);
/**
* 获取节点流程定义信息
* @param routerBo
* @param nodeId
* @return
*/
NodeVo getNodeById(RouterBO routerBo,String nodeId);
/**
* 获取上一步工艺路线
* @param sfcInfoBo
* @return
*/
RouterBO getPreviousRouter(SfcInfoBO sfcInfoBo);
/**
* 校验工序是否是工艺路线的首工序
* @param operation
* @param routerBo
* @return
*/
boolean isFirstOperation (OperationBO operation,RouterBO routerBo);
/**
* 校验工序是否是步骤的工序
* @param operation
* @param nodeVo
* @return
*/
boolean isNodeOperation(OperationBO operation,NodeVo nodeVo);
/**
* 校验工序是否是SFC当前所在工序
* @param sfcInfoBo
* @param operationBo
* @return
*/
boolean isCurOperation(SfcInfoBO sfcInfoBo,OperationBO operationBo);
}
/**
* *CreateTime:2010-12-2 下午04:35:17
*Description:MES功能点已工作流对接接口默认实现类
*/
package com.byd.mes.plugins.workFlow.impl;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.script.Invocable;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import com.byd.mes.bussiness.bo.main.OperationBO;
import com.byd.mes.bussiness.bo.main.ResourceBO;
import com.byd.mes.bussiness.bo.main.RouterBO;
import com.byd.mes.bussiness.bo.main.StatusBO;
import com.byd.mes.bussiness.bo.siteoperation.podmanager.ActivityInfoBO;
import com.byd.mes.bussiness.bo.siteoperation.sfc.SfcInfoBO;
import com.byd.mes.bussiness.bo.siteoperation.sfc.SfcOperationBO;
import com.byd.mes.bussiness.bo.siteoperation.sfc.SfcRouterBO;
import com.byd.mes.bussiness.bo.system.UserBO;
import com.byd.mes.bussiness.service.ServiceException;
import com.byd.mes.bussiness.service.activity.ExecuteActivityService;
import com.byd.mes.bussiness.service.main.OperationService;
import com.byd.mes.bussiness.service.main.ResourceService;
import com.byd.mes.bussiness.service.main.RouterService;
import com.byd.mes.bussiness.service.main.StatusService;
import com.byd.mes.bussiness.service.siteoperation.podmanager.ActivityInfoService;
import com.byd.mes.bussiness.service.siteoperation.sfc.SfcInfoService;
import com.byd.mes.bussiness.service.siteoperation.sfc.SfcOperationService;
import com.byd.mes.bussiness.service.siteoperation.sfc.SfcRouterService;
import com.byd.mes.plugins.workFlow.BydWorkFlowService;
import com.byd.mes.util.BeanFactory;
import com.bydwf.util.MesWfutil;
import com.bydwf.vo.NodeVo;
import com.ibatis.sqlmap.client.SqlMapClient;
public class BydWorkFlowServiceImpl implements BydWorkFlowService{
private static final Log log = LogFactory.getLog(BydWorkFlowServiceImpl.class);
private SfcInfoService sfcInfoService;
private StatusService statusService;
private SfcOperationService sfcOperationService;
private SfcRouterService sfcRouterService;
private RouterService routerService;
private OperationService operationService;
private SqlMapClient sqlMapClient;
private ResourceService resourceService;
private ExecuteActivityService executeActivityService;
private ActivityInfoService activityInfoService;
static private final String EVENT_BEFORE_LOAD = "BEFORE_LOAD";
static private final String EVENT_AFTER_LOAD = "AFTER_LOAD";
static private final String EVENT_BEFORE_APPROVE = "BEFORE_APPROVE";
static private final String EVENT_AFTER_APPROVE = "AFTER_APPROVE";
static private final String EVENT_BEFORE_START = "BEFORE_START";
static private final String EVENT_AFTER_START = "AFTER_START";
private Map<String,String[]> listener;
@Override
public void start(SfcInfoBO sfcInfoBo,OperationBO operationBO,ResourceBO resourceBo,RouterBO routerBo,UserBO userBo,String beforeStartClass,String afterStartClass,Map map) {
Date curDate = new Date();
//校验SfcInfo是否为空
if(sfcInfoBo == null){
throw new ServiceException("2001","调用MES工作流方法[START]时，传入的SfcInfoBO对象为空!");
}
if(StringUtils.isEmpty(sfcInfoBo.getId())){
throw new ServiceException("2002","调用MES工作流方法[START]时，传入的SfcInfoBO对象的ID属性值为空!");
}
//校验OperationBO是否为空
if(operationBO == null){
throw new ServiceException("2003","调用MES工作流方法[START]时，传入的OperationBO对象为空!");
}
if(StringUtils.isEmpty(operationBO.getId())){
throw new ServiceException("2004","调用MES工作流方法[START]时，传入的OperationBO对象的ID属性值为空!");
}
//校验ResourceBO是否为空
if(resourceBo == null){
throw new ServiceException("2005","调用MES工作流方法[START]时，传入的ResourceBO对象为空!");
}
if(StringUtils.isEmpty(resourceBo.getId())){
throw new ServiceException("2006","调用MES工作流方法[START]时，传入的ResourceBO对象的ID属性值为空!");
}
//校验RouterBO是否为空
if(routerBo == null){
throw new ServiceException("2005","调用MES工作流方法[START]时，传入的RouterBO对象为空!");
}
if(StringUtils.isEmpty(routerBo.getId())){
throw new ServiceException("2006","调用MES工作流方法[START]时，传入的RouterBO对象的ID属性值为空!");
}
//校验UserBO是否为空
if(userBo == null){
throw new ServiceException("2007","调用MES工作流方法[START]时，传入的UserBO对象为空!");
}
if(StringUtils.isEmpty(userBo.getId())){
throw new ServiceException("2008","调用MES工作流方法[START]时，传入的UserBO对象的ID属性值为空!");
}
//查询Sfc基本信息
try{
sfcInfoBo = sfcInfoService.findByPk(sfcInfoBo.getId());
}catch(Exception ex){
throw new ServiceException("2100","执行MES工作流方法[START]时,根据SFC ID["+sfcInfoBo.getId()+"]查询SFC 基本信息失败!",ex);
}
if(sfcInfoBo == null){
throw new ServiceException("2101","执行MES工作流方法[START]时，SFC无效!");
}
//查询工艺路线信息
try{
routerBo = routerService.findByPk(routerBo.getId());
}catch(Exception ex){
throw new ServiceException("2103","SFC["+sfcInfoBo.getSfcNo()+"]在开始之前根据工艺路线 ID["+routerBo.getId()+"]查询工艺路线基本信息失败!",ex);
}
if(routerBo == null){
throw new ServiceException("2104","执行MES工作流方法[START]时,工艺路线无效!");
}
//查询资源
try{
resourceBo = resourceService.findByPk(resourceBo.getId());
}catch(Exception ex){
throw new ServiceException("2105","SFC["+sfcInfoBo.getSfcNo()+"]在开始之前根据资源 ID["+resourceBo.getId()+"]查询资源基本信息失败!",ex);
}
if(resourceBo == null){
throw new ServiceException("2106","执行MES工作流方法[START]时,资源(ResourceBO)无效!");
}
//查询工序
try{
operationBO=this.operationService.findByPk(operationBO.getId());
}catch(Exception ex){
throw new ServiceException("2107","SFC["+sfcInfoBo.getSfcNo()+"]在开始之前根据 工序ID["+operationBO.getId()+"]查询 工序基本信息失败!",ex);
}
if(operationBO == null){
throw new ServiceException("2108","执行MES工作流方法[START]时,工序无效!");
}
//查询SFC"活动"状态对象
StatusBO statusActiveBo=statusService.findByUK(BeanFactory.getSystemParamters().get("mes.siteoperation.sfc.status"),
BeanFactory.getSystemParamters().get("mes.siteoperation.sfc.status.active"));
//查询SFC工序步骤"活动"状态对象
StatusBO operationActiveStatus=statusService.findByUK(BeanFactory.getSystemParamters().get("mes.siteoperation.operationstatus"),
BeanFactory.getSystemParamters().get("mes.siteoperation.operationstatus.active"));
MesWfutil mesWfUtil =null;
NodeVo firstNode=null;
List<NodeVo> allNodes=null;
//获取工艺路线上的所有节点
try{
mesWfUtil = new MesWfutil(sqlMapClient);
allNodes = mesWfUtil.getAllNodes(routerBo.getNo(), routerBo.getVersion());
}catch(Exception ex){
throw new ServiceException("3003","调用工作流方法[getAllNodes]根据工艺路线["+routerBo.getNo()+"]["+routerBo.getVersion()+"]查询工艺路线所有工序步骤失败!",ex);
}
if(allNodes == null || allNodes.size() <= 0){
throw new ServiceException("3004","工艺路线["+routerBo.getNo()+"]["+routerBo.getVersion()+"]没有工序步骤!");
}
//获取工艺路线上的第一个节点
try{
firstNode =this.getFirstNode(routerBo);
}catch(Exception ex){
throw new ServiceException("3002","调用工作流方法[getFirsetNode]根据工艺路线["+routerBo.getNo()+"]["+routerBo.getVersion()+"]查询工艺路线第一个工序步骤失败!",ex);
}
if(firstNode == null){
throw new ServiceException("3005","工艺路线["+routerBo.getNo()+"]["+routerBo.getVersion()+"]没有首工序步骤!");
}
//BeforeLoad:执行二次开发接口业务处理类
log.debug(">>>>>>>>>>>>>>>>>>>>>>Execute Before Start Listener ");
this.executeEvent(this.EVENT_BEFORE_START, sfcInfoBo, routerBo, operationBO, resourceBo, null, userBo);
//A:校验SFC当前是否在传入的工艺路线上，是则校验SFC当前排队工序是否是传入的工序，是则将排队改为活动
if(sfcInfoBo.getSfcRouter()!= null &&
StringUtils.isNotEmpty(sfcInfoBo.getSfcRouter().getId()) &&
sfcInfoBo.getRouter().getId().equals(routerBo.getId())){
//校验SFC当前是否是排队状态
if(this.sfcInfoService.isQuence(sfcInfoBo)){
//查询SFC当前工艺路线信息（SfcRouterBO）
SfcRouterBO sfcRouterBO= null;
try {
sfcRouterBO=this.sfcRouterService.findByUk(sfcInfoBo.getSite().getId(), sfcInfoBo.getId(), routerBo.getId());
} catch (Exception ex) {
throw new ServiceException("2118","根据SFC["+sfcInfoBo.getSfcNo()+"]工艺路线["+routerBo.getNo()+"]["+routerBo.getVersion()+"]查询SFC工艺路线(SfcRouterBO)信息失败!",ex);
}
//A1:如果是步骤组：如果步骤类型是"SIMULTANEITY",则将开始变为活动，如果是"RANDOM",则将当前传入的工序步骤变为活动，将步骤中的其他步骤清空
if( sfcRouterBO != null &&
StringUtils.isNotEmpty(sfcRouterBO.getNodeGroup())){
NodeVo nodeGroup = null;
//查询步骤组代表节点信息
try{
nodeGroup = mesWfUtil.getNodeById(routerBo.getNo(),routerBo.getVersion(), sfcRouterBO.getNodeGroup());
}catch(Exception ex){
throw new ServiceException("3001","调用工作流方法[getNodeById]根据工艺路线["+routerBo.getNo()+"]["+routerBo.getVersion()+"]工序步骤ID["+sfcRouterBO.getNodeGroup()+"]查询工序步骤基本信息失败!",ex);
}
if(nodeGroup == null){
throw new ServiceException("3006","在工艺路线["+routerBo.getNo()+"]["+routerBo.getVersion()+"]上没有找到工序步骤["+sfcRouterBO.getNodeGroup()+"]!");
}
//查询步骤组中的所有工序步骤
List<SfcOperationBO> sfcOperations = null;
SfcOperationBO sfcOperationBo = new SfcOperationBO();
sfcOperationBo.setSite(sfcRouterBO.getSite());
sfcOperationBo.setSfcRouter(sfcRouterBO);
sfcOperationBo.setStepGroup(sfcRouterBO.getNodeGroup());
try {
sfcOperations = sfcOperationService.find(sfcOperationBo );
} catch (Exception ex) {
throw new ServiceException("2310","查询SFC["+sfcInfoBo.getSfcNo()+"]在工艺路线RouterBo["+routerBo.getNo()+"]["+routerBo.getVersion()+"]上的工序步骤信息失败!",ex);
}
if(sfcOperations == null || sfcOperations.size() <= 0 ){
throw new ServiceException("2318","SFC["+sfcInfoBo.getSfcNo()+"]在工艺路线RouterBo["+routerBo.getNo()+"]["+routerBo.getVersion()+"]上的步骤组["+sfcRouterBO.getNodeGroup()+"]中的步骤信息为空!");
}
//校验SFC是否是在步骤组上排队
boolean isInNodeGroup = false;
for(SfcOperationBO sob : sfcOperations){
if(StringUtils.equals(operationBO.getId(), sob.getOperation().getId())){
isInNodeGroup = true;
}
}
if(!isInNodeGroup){
throw new ServiceException("2319","SFC["+sfcInfoBo.getSfcNo()+"]不在工序["+operationBO.getNo()+"]上排队,它在步骤组["+nodeGroup.getNodeId()+"]上排队");
}
for(SfcOperationBO sob : sfcOperations){
//如果传入工序在步骤组中，则将传入工序的步骤状态改为活动
if(StringUtils.equals(operationBO.getId(), sob.getOperation().getId())){
//更改SFC(SfcInfoBO)相关信息
sfcInfoBo.setOriginalStatus(sfcInfoBo.getStatus());
sfcInfoBo.setStatus(statusActiveBo);
sfcInfoBo.setOperationStepStatus(operationActiveStatus);
sfcInfoBo.setLastHandleUser(userBo);
sfcInfoBo.setLastHandleTime(curDate);
sfcInfoBo.setCurrentResource(resourceBo);
sfcInfoBo.setOperation(operationBO);
sfcInfoBo.setSfcOperation(sob);
try {
this.sfcInfoService.update(sfcInfoBo);
} catch (Exception ex) {
throw new ServiceException("2110","更新SFC["+sfcInfoBo.getSfcNo()+"]基本信息(SfcInfoBO)信息失败!",ex);
}
//更新SfcRouter信息
try {
sfcRouterBO.setLastSfcOperationStep(sob);
this.sfcRouterService.update(sfcRouterBO);
} catch (Exception ex) {
throw new ServiceException("4004","更新SFC["+sfcInfoBo.getSfcNo()+"]的SFC工艺路线(SfcRouterBO)["+sfcRouterBO.getId()+"]中的当前工序步骤失败!",ex);
}
//更新SfcOperation信息
try {
sob.setStatus(operationActiveStatus);
sob.setTriggerUser(userBo);
sob.setActiveDate(curDate);
sob.setActiveNum(sob.getActiveNum()+1);
this.sfcOperationService.update(sob);
} catch (Exception ex) {
throw new ServiceException("2112","更新SFC["+sfcInfoBo.getSfcNo()+"]SFC工序步骤(sfcOperationBO)信息失败!",ex);
}
}else{
//“RANDOM” 步骤组，任意步骤组，如果在一个步骤上开始了，则必须清空步骤组中的其他步骤的状态
if(StringUtils.equals("RANDOM", nodeGroup.getNodeGroupType())){
try {
StatusBO operationDoneStatus=statusService.findByUK(BeanFactory.getSystemParamters().get("mes.siteoperation.operationstatus"),
BeanFactory.getSystemParamters().get("mes.siteoperation.operationstatus.complete"));
if(sob.getStatus() != null &&
StringUtils.isNotEmpty(sob.getStatus().getId()) &&
!StringUtils.equals(sob.getStatus().getId(), operationDoneStatus.getId())){
sob.setSfcQty(0);
sob.setStatus(null);
sob.setActiveDate(curDate);
sob.setTriggerUser(userBo);
sob.setPreviousOperation(null);
this.sfcOperationService.update(sob);
}
} catch (Exception ex) {
throw new ServiceException("2112","更新SFC["+sfcInfoBo.getSfcNo()+"]SFC工序步骤(sfcOperationBO)信息失败!",ex);
}
}
}
}
}else{//A2:不是步骤组
//校验SFC当前所在工序是否是传入的工序
if(sfcInfoBo.getOperation().equals(operationBO)){
//更改SFC(SfcInfoBO)相关信息
sfcInfoBo.setOriginalStatus(sfcInfoBo.getStatus());
sfcInfoBo.setStatus(statusActiveBo);
sfcInfoBo.setOperationStepStatus(operationActiveStatus);
sfcInfoBo.setLastHandleUser(userBo);
sfcInfoBo.setLastHandleTime(curDate);
sfcInfoBo.setCurrentResource(resourceBo);
try {
this.sfcInfoService.update(sfcInfoBo);
} catch (Exception ex) {
throw new ServiceException("2110","更新SFC["+sfcInfoBo.getSfcNo()+"]基本信息(SfcInfoBO)信息失败!",ex);
}
//更改SFC SFC工序步骤(SfcOperationBO)相关信息
SfcOperationBO sfcOperationBO = null;
try{
sfcOperationBO=sfcOperationService.findByPk(sfcInfoBo.getSfcOperation().getId());
}catch(Exception ex){
throw new ServiceException("2111","SFC["+sfcInfoBo.getSfcNo()+"]在开始之前根据 SFC当前工序步骤ID["+sfcInfoBo.getSfcOperation().getId()+"]查询 SFC工序步骤(sfcOperationBO)信息失败!",ex);
}
sfcOperationBO.setStatus(operationActiveStatus);
sfcOperationBO.setTriggerUser(userBo);
sfcOperationBO.setActiveDate(curDate);
sfcOperationBO.setActiveNum(sfcOperationBO.getActiveNum()+1);
try {
this.sfcOperationService.update(sfcOperationBO);
} catch (Exception ex) {
throw new ServiceException("2112","更新SFC["+sfcInfoBo.getSfcNo()+"]SFC工序步骤(sfcOperationBO)信息失败!",ex);
}
}else{
throw new ServiceException("2113","SFC["+sfcInfoBo.getSfcNo()+"]不在工序["+operationBO.getNo()+"]上排队,它在工序["+sfcInfoBo.getOperation().getNo()+"]上排队");
}
}
}else{
StatusBO Status=this.statusService.findByPk(sfcInfoBo.getStatus().getId());
throw new ServiceException("2114","SFC["+sfcInfoBo.getSfcNo()+"]不在工序["+operationBO.getNo()+"]上排队,它在工序["+sfcInfoBo.getOperation().getNo()+"]"+Status.getNo() );
}
}else{
//B:SFC当前不在传入的工艺路线上,校验传入工序是否是传入工艺路线的首工序，是则校验传入工艺路线之前有没有走过，没有走过，则生成工序步骤信息，走过，则清空之前的工艺路线信息，重新再走；
if(isNodeOperation(operationBO,firstNode) ){
SfcRouterBO sfcRouterBO= null;
try {
sfcRouterBO=this.sfcRouterService.findByUk(sfcInfoBo.getSite().getId(), sfcInfoBo.getId(), routerBo.getId());
} catch (Exception ex) {
throw new ServiceException("2115","根据SFC["+sfcInfoBo.getSfcNo()+"]工艺路线["+routerBo.getNo()+"]["+routerBo.getVersion()+"]查询SFC工艺路线(SfcRouterBO)信息失败!",ex);
}
//B1:传入工艺路线之前走过
if(sfcRouterBO!=null){
//清空SFC工序步骤信息
List<SfcOperationBO> sfcOperations = null;
SfcOperationBO sfcOperation = new SfcOperationBO();
sfcOperation.setSite(sfcRouterBO.getSite());
sfcOperation.setSfcRouter(sfcRouterBO);
try {
sfcOperations = sfcOperationService.find(sfcOperation );
} catch (Exception ex) {
throw new ServiceException("2310","查询SFC["+sfcInfoBo.getSfcNo()+"]在工艺路线RouterBo["+routerBo.getNo()+"]["+routerBo.getVersion()+"]上的工序步骤信息失败!",ex);
}
for(SfcOperationBO sob:sfcOperations){
sfcInfoBo = clearSfcOperationInfo(sfcInfoBo,sob,userBo,firstNode,operationActiveStatus,curDate,operationBO);
}
//Update SfcRouter
sfcRouterBO.setPreviousRouter(sfcInfoBo.getSfcRouter());
sfcRouterBO.setLastSfcOperationStep(sfcInfoBo.getSfcOperation());
if(StringUtils.equals("NODEGROUP", firstNode.getExNodeType())){
sfcRouterBO.setNodeGroup(firstNode.getNodeId());
}
try {
this.sfcRouterService.update(sfcRouterBO);
} catch (Exception ex) {
throw new ServiceException("2116","更新SFC["+sfcInfoBo.getSfcNo()+"]SFC工艺路线(SfcRouterBO)["+routerBo.getNo()+"]["+routerBo.getVersion()+"]中的当前工序步骤失败!",ex);
}
//update SfcInfo
sfcInfoBo.setOriginalStatus(sfcInfoBo.getStatus());
sfcInfoBo.setStatus(statusActiveBo);
sfcInfoBo.setOperationStepStatus(operationActiveStatus);
sfcInfoBo.setSfcRouter(sfcRouterBO);
sfcInfoBo.setRouter(routerBo);
sfcInfoBo.setOperation(operationBO);
sfcInfoBo.setLastHandleUser(userBo);
sfcInfoBo.setLastHandleTime(curDate);
sfcInfoBo.setCurrentResource(resourceBo);
try {
this.sfcInfoService.update(sfcInfoBo);
} catch (Exception ex) {
throw new ServiceException("2117","更新SFC["+sfcInfoBo.getSfcNo()+"]基本信息(SfcInfoBO)信息失败!",ex);
}
//B2:传入工艺路线之前没走过
}else{
//生成SFC工艺路线信息(SfcRouter), 更改它的上一工艺路线
createSfcRouterOperationInfo( sfcInfoBo, routerBo, userBo , allNodes,statusActiveBo,operationActiveStatus,firstNode,operationBO,curDate,resourceBo);
}
}else{
throw new ServiceException("2122","工序["+operationBO.getNo()+"]不是工艺路线["+routerBo.getNo()+"]["+routerBo.getVersion()+"]的首工序,不能开始!");
}
}
//AfterLoad:执行二次开发接口业务处理类
log.debug(">>>>>>>>>>>>>>>>>>>>>>Execute After Start Listener");
this.executeEvent(this.EVENT_AFTER_START, sfcInfoBo, routerBo, operationBO, resourceBo, null, userBo);
}
@Override
public void load(SfcInfoBO sfcInfoBo,RouterBO routerBo,UserBO userBo,String beforeLoadClass,String afterLoadClass,Map mapParam){
Date curDate = new Date();
// TODO Auto-generated method stub
//校验SfcInfo是否为空
if(sfcInfoBo == null){
throw new ServiceException("2009","调用MES工作流方法[LOAD]时，传入的SfcInfoBO对象为空!");
}
if(StringUtils.isEmpty(sfcInfoBo.getId())){
throw new ServiceException("2010","调用MES工作流方法[LOAD]时，传入的SfcInfoBO对象的ID属性值为空!");
}
//校验RouterBO是否为空
if(routerBo == null){
throw new ServiceException("2011","调用MES工作流方法[LOAD]时，传入的RouterBO对象为空!");
}
if(StringUtils.isEmpty(routerBo.getId())){
throw new ServiceException("2012","调用MES工作流方法[LOAD]时，传入的RouterBO对象的ID属性值为空!");
}
//校验UserBO是否为空
if(userBo == null){
throw new ServiceException("2013","调用MES工作流方法[LOAD]时，传入的UserBO对象为空!");
}
if(StringUtils.isEmpty(userBo.getId())){
throw new ServiceException("2014","调用MES工作流方法[LOAD]时，传入的UserBO对象的ID属性值为空!");
}
//根据SFC ID查询SFC(SfcInfoBO)基本信息
try{
sfcInfoBo = sfcInfoService.findByPk(sfcInfoBo.getId());
}catch(Exception ex){
throw new ServiceException("2200","生成SFC工序步骤之前根据SFC ID["+sfcInfoBo.getId()+"]查询SFC 基本信息失败!",ex);
}
if(sfcInfoBo == null){
throw new ServiceException("2201","SFC为空,不能生成工序步骤!");
}
//根据ROUTER ID查询ROUTER 基本信息
try{
routerBo = routerService.findByPk(routerBo.getId());
}catch(Exception ex){
throw new ServiceException("2203","SFC["+sfcInfoBo.getSfcNo()+"]在生成工序步骤之前根据工艺路线 ID["+routerBo.getId()+"]查询工艺路线基本信息失败!",ex);
}
if(routerBo == null){
throw new ServiceException("2204","工艺路线为空,不能生成工序步骤!");
}
//查询SFC"排队"状态对象
StatusBO statusBo=statusService.findByUK(BeanFactory.getSystemParamters().get("mes.siteoperation.sfc.status"),
BeanFactory.getSystemParamters().get("mes.siteoperation.sfc.status.queue"));
//查询SFC工序步骤"排队"状态对象
StatusBO operationStepStatus=statusService.findByUK(BeanFactory.getSystemParamters().get("mes.siteoperation.operationstatus"),
BeanFactory.getSystemParamters().get("mes.siteoperation.operationstatus.queue"));
MesWfutil mesWfUtil =null;
//生成工序步骤信息
//获取工艺路线上的所有节点
List<NodeVo> allNodes = null;
NodeVo firstNode = null;
OperationBO firstOperation = null;
try{
mesWfUtil = new MesWfutil(sqlMapClient);
allNodes = mesWfUtil.getAllNodes(routerBo.getNo(), routerBo.getVersion());
}catch(Exception ex){
throw new ServiceException("3003","调用工作流方法[getAllNodes]根据工艺路线["+routerBo.getNo()+"]["+routerBo.getVersion()+"]查询工艺路线所有工序步骤失败!",ex);
}
//获取工艺路线的第一个节点
try{
firstNode = mesWfUtil.getFirstNode(routerBo.getNo(), routerBo.getVersion());
}catch(Exception ex){
throw new ServiceException("3002","调用工作流方法[getFirsetNode]根据工艺路线["+routerBo.getNo()+"]["+routerBo.getVersion()+"]查询工艺路线第一个工序步骤失败!",ex);
}
//如果第一节点的类型是"OPERATION",则获取其工序
if(StringUtils.equals("OPERATION", firstNode.getExNodeType())){
//获取工艺路线的第一个工序
try{
firstOperation = operationService.findByPk(firstNode.getOperationId());
}catch(Exception ex){
throw new ServiceException("2206","根据工序 ID["+firstNode.getOperationId()+"]查询工序基本信息失败!",ex);
}
}
//BeforeLoad:执行二次开发接口业务处理类
log.debug(">>>>>>>>>>>>>>>>>>>>>>Execute Before Load Listener ");
this.executeEvent(this.EVENT_BEFORE_LOAD, sfcInfoBo, routerBo, firstOperation, null, firstNode, userBo);
if(allNodes != null && allNodes.size()>0){
createSfcRouterOperationInfo( sfcInfoBo, routerBo, userBo , allNodes,statusBo,operationStepStatus,firstNode,firstOperation,curDate,sfcInfoBo.getCurrentResource());
}else{
throw new ServiceException("2207","工艺路线["+routerBo.getNo()+"]["+routerBo.getVersion()+"]中没有工序步骤,不能开始!");
}
//AfterLoad:执行二次开发接口业务处理类
log.debug(">>>>>>>>>>>>>>>>>>>>>>Execute After Load Listener ");
this.executeEvent(this.EVENT_AFTER_LOAD, sfcInfoBo, routerBo, firstOperation, null, firstNode, userBo);
}
@Override
public void approve(SfcInfoBO sfcInfoBo,RouterBO toRouter,String toNodeId,UserBO userBo,String beforeApproveClass,String afterApproveClass,Map map) {
Date curDate = new Date();
// TODO Auto-generated method stub
//校验SfcInfo是否为空
if(sfcInfoBo == null){
throw new ServiceException("2015","调用MES工作流方法[APPROVE]时，传入的SFC对象为空!");
}
if(StringUtils.isEmpty(sfcInfoBo.getId())){
throw new ServiceException("2016","调用MES工作流方法[APPROVE]时，传入的SfcInfoBO对象ID为空!");
}
//校验RouterBO是否为空
if(toRouter == null){
throw new ServiceException("2017","调用MES工作流方法[APPROVE]时，传入的RouterBO对象为空!");
}
if(StringUtils.isEmpty(toRouter.getId())){
throw new ServiceException("2018","调用MES工作流方法[APPROVE]时，传入的RouterBO对象的ID属性值为空!");
}
//校验UserBO是否为空
if(userBo == null){
throw new ServiceException("2019","调用MES工作流方法[APPROVE]时，传入的UserBO对象为空!");
}
if(StringUtils.isEmpty(userBo.getId())){
throw new ServiceException("2020","调用MES工作流方法[APPROVE]时，传入的UserBO对象的ID属性值为空!");
}
//校验toNodeId是否为空值
if(StringUtils.isEmpty(toNodeId)){
throw new ServiceException("2300","调用MES工作流方法[APPROVE]时，传入的下一步骤ID为空值!");
}
//查询SFC基本信息
try{
sfcInfoBo = sfcInfoService.findByPk(sfcInfoBo.getId());
}catch(Exception ex){
throw new ServiceException("2301","执行MES工作流方法[APPROVE]时，根据SFC ID["+sfcInfoBo.getId()+"]查询SFC基本信息失败!",ex);
}
try{
toRouter = routerService.findByPk(toRouter.getId());
}catch(Exception ex){
throw new ServiceException("2303","执行MES工作流APPROVE时根据工艺路线 ID["+toRouter.getId()+"]查询工艺路线基本信息失败!",ex);
}
MesWfutil mesWfUtil =null;
List<NodeVo> toRouterAllNodes=null;
NodeVo toNode = null;
//获取即将跳转到的节点基本信息
try{
mesWfUtil = new MesWfutil(sqlMapClient);
toNode = mesWfUtil.getNodeById(toRouter.getNo(),toRouter.getVersion(), toNodeId);
}catch(Exception ex){
throw new ServiceException("3001","调用工作流方法[getNodeById]根据工艺路线["+sfcInfoBo.getRouter().getNo()+"]["+sfcInfoBo.getRouter().getVersion()+"]工序步骤ID["+toNodeId+"]查询工序步骤基本信息失败!",ex);
}
if(toNode == null){
throw new ServiceException("2324","即将跳转到的步骤["+toNodeId+"]不在即将跳转到的工艺路线上["+toRouter.getNo()+"]["+toRouter.getVersion()+"]!");
}
//获取工艺路线上的所有节点
try{
toRouterAllNodes = mesWfUtil.getAllNodes(toRouter.getNo(),toRouter.getVersion());
}catch(Exception ex){
throw new ServiceException("3003","调用工作流方法[getAllNodes]根据工艺路线["+toRouter.getNo()+"]["+toRouter.getVersion()+"]查询工艺路线所有工序步骤失败!",ex);
}
//BeforeApprove:执行二次开发接口业务处理类
log.debug(">>>>>>>>>>>>>>>>>>>>>>Execute Before Approve Listener ");
this.executeEvent(this.EVENT_BEFORE_APPROVE, sfcInfoBo, toRouter, null, null, toNode, userBo);
//O:公共操作=>>将当前工序步骤状态改为完成
//查询SFC“排队”状态对象
StatusBO statusQueueBo=statusService.findByUK(BeanFactory.getSystemParamters().get("mes.siteoperation.sfc.status"),
BeanFactory.getSystemParamters().get("mes.siteoperation.sfc.status.queue"));
//查询SFC工序步骤"排队"状态对象
StatusBO operationQueueBoStatus=statusService.findByUK(BeanFactory.getSystemParamters().get("mes.siteoperation.operationstatus"),
BeanFactory.getSystemParamters().get("mes.siteoperation.operationstatus.queue"));
//查询工序步骤“完成”状态对象
StatusBO operationDoneStatus=statusService.findByUK(BeanFactory.getSystemParamters().get("mes.siteoperation.operationstatus"),
BeanFactory.getSystemParamters().get("mes.siteoperation.operationstatus.complete"));
SfcRouterBO curSfcRouterBo = null;
SfcOperationBO curSfcOperationBo = null;
//查询SFC当前工艺路线信息
try{
curSfcRouterBo = sfcRouterService.findByPk(sfcInfoBo.getSfcRouter().getId());
}catch(Exception ex){
throw new ServiceException("2305","SFC["+sfcInfoBo.getSfcNo()+"]执行Complete时根据SfcRouter ID["+sfcInfoBo.getSfcRouter().getId()+"]查询SFC工艺路线信息失败!",ex);
}
//判断是否是步骤组
if(curSfcRouterBo.getLastSfcOperationStep()==null||curSfcRouterBo.getLastSfcOperationStep().getId()==null||StringUtils.isEmpty(curSfcRouterBo.getLastSfcOperationStep().getId()) ){
throw new ServiceException("2306","SFC["+sfcInfoBo.getSfcNo()+"]在工艺路线["+toRouter.getNo()+"]["+toRouter.getVersion()+"]步骤组["+curSfcRouterBo.getNodeGroup()+"]排队，不能跳转!");
}
//查询当前工序步骤信息
try{
curSfcOperationBo = sfcOperationService.findByPk(curSfcRouterBo.getLastSfcOperationStep().getId());
}catch(Exception ex){
throw new ServiceException("2306","SFC["+sfcInfoBo.getSfcNo()+"]执行Complete时根据SfcOperation ID["+curSfcRouterBo.getLastSfcOperationStep().getId()+"]查询SFC工序步骤信息失败!",ex);
}
curSfcOperationBo.setActiveDate(curDate);
curSfcOperationBo.setTriggerUser(userBo);
curSfcOperationBo.setStatus(operationDoneStatus);
curSfcOperationBo.setThroughNum(curSfcOperationBo.getThroughNum()+1 );
//更新当前工序步骤状态为完成
try {
sfcOperationService.update(curSfcOperationBo);
} catch (Exception ex) {
throw new ServiceException("2307","更新SFC["+sfcInfoBo.getSfcNo()+"]的SFC工序步骤(SfcOperationBO)["+curSfcOperationBo.getId()+"]信息失败!",ex);
}
//A.判断节点类型是否是工序，是则跳转到下一节点
if(StringUtils.equals("OPERATION", toNode.getExNodeType())){
//查询传入进来的工艺路线的SfcRouterBO
SfcRouterBO toSfcRouterBo = null;
OperationBO toOperation = null;
try{
toSfcRouterBo = sfcRouterService.findByUk(sfcInfoBo.getSite().getId(), sfcInfoBo.getId(), toRouter.getId());
}catch(Exception ex){
throw new ServiceException("2308","根据SFC["+sfcInfoBo.getSfcNo()+"]工艺路线["+toRouter.getNo()+"]["+toRouter.getVersion()+"]查询SFC工艺路线信息(SfcRouterBO)失败!",ex);
}
//获取即将跳转到的工序基本信息
try{
toOperation = operationService.findByPk(toNode.getOperationId());
}catch(Exception ex){
throw new ServiceException("2310","根据工序ID["+toNode.getOperationId()+"]查询工序信息失败!",ex);
}
//如果工艺路线之前没有走过，并且传入的节点是传入工艺路线的首节点，则发起工作流程，生成步骤信息;否则抛出异常
if(toSfcRouterBo == null){
//throw new ServiceException("2309","SFC["+sfcInfoBo.getSfcNo()+"]没有走过工艺路线["+routerBo.getNo()+"]["+routerBo.getVersion()+"],不能跳转!");
NodeVo toRouterFirstNode = null;
try{
toRouterFirstNode = mesWfUtil.getFirstNode(toRouter.getNo(),toRouter.getVersion());
}catch(Exception ex){
throw new ServiceException("3002","调用工作流方法[getFirsetNode]根据工艺路线["+toRouter.getNo()+"]["+toRouter.getVersion()+"]查询工艺路线第一个工序步骤失败!",ex);
}
if(StringUtils.equals(toRouterFirstNode.getNodeId(), toNode.getNodeId())){
this.createSfcRouterOperationInfo(sfcInfoBo, toRouter, userBo, toRouterAllNodes,statusQueueBo , operationQueueBoStatus,toNode,toOperation,curDate,sfcInfoBo.getCurrentResource());
}else{
throw new ServiceException("2309","SFC["+sfcInfoBo.getSfcNo()+"]没有走过工艺路线["+toRouter.getNo()+"]["+toRouter.getVersion()+"],步骤["+toNode.getNodeId()+"]不是工艺路线["+toRouter.getNo()+"]["+toRouter.getVersion()+"]的首步骤,不能跳转!");
}
}else{
//如果工艺路线之前走过，则直接跳转指定的节点上
List<SfcOperationBO> sfcOperationBOs=null;
SfcOperationBO sfcOperationBO= new SfcOperationBO();
sfcOperationBO.setSfcRouter(toSfcRouterBo);
sfcOperationBO.setSite(sfcInfoBo.getSite());
//获取传入工艺路线的所有工序步骤信息
try {
sfcOperationBOs = sfcOperationService.find(sfcOperationBO );
} catch (Exception ex) {
throw new ServiceException("2310","查询SFC["+sfcInfoBo.getSfcNo()+"]在工艺路线RouterBo["+toRouter.getNo()+"]["+toRouter.getVersion()+"]上的工序步骤信息失败!",ex);
}
//查找需要调整的工序步骤
for (SfcOperationBO bean : sfcOperationBOs) {
if(StringUtils.equals(bean.getStepId(), toNodeId)){
bean.setStatus(operationQueueBoStatus);
bean.setSfcQty(sfcInfoBo.getQty());
bean.setActiveDate(curDate);
bean.setTriggerUser(userBo);
bean.setPreviousOperation(curSfcOperationBo);
bean.setQueueNum(bean.getQueueNum()+1);
//如果即将跳去的节点是SFC当前所在的节点，则将循环次数加1
if(StringUtils.equals(bean.getId(), curSfcOperationBo.getId())){
bean.setLoopNum(bean.getLoopNum() + 1);
}
try {
sfcOperationService.update(bean);
} catch (Exception ex) {
throw new ServiceException("2311","更新SFC["+sfcInfoBo.getSfcNo()+"]的SFC工序步骤(SfcOperationBO)["+bean.getId()+"]信息失败!",ex);
}
//判断传入的工艺路线是否与当前工艺路线相同
if(!toRouter.equals(sfcInfoBo.getRouter())){
toSfcRouterBo.setPreviousRouter(sfcInfoBo.getSfcRouter());
}
toSfcRouterBo.setLastSfcOperationStep(bean);
if(StringUtils.isEmpty(bean.getStepGroup())){
toSfcRouterBo.setNodeGroup(null);
sfcInfoBo.setStepGroup(null);
}
try {
this.sfcRouterService.update(toSfcRouterBo);
} catch (Exception ex) {
throw new ServiceException("2312","更新SFC["+sfcInfoBo.getSfcNo()+"]的SFC工艺路线(SfcRouterBO)["+curSfcRouterBo.getId()+"]中的当前工序步骤失败!",ex);
}
sfcInfoBo.setOriginalStatus(sfcInfoBo.getStatus());
sfcInfoBo.setStatus(statusQueueBo );
sfcInfoBo.setOperationStepStatus(operationQueueBoStatus);
sfcInfoBo.setRouter(toRouter);
sfcInfoBo.setOperation(toOperation);
sfcInfoBo.setSfcRouter(toSfcRouterBo);
sfcInfoBo.setSfcOperation(bean);
sfcInfoBo.setLastHandleTime(curDate);
sfcInfoBo.setLastHandleUser(userBo);
sfcInfoBo.setStepId(toNodeId );
try {
this.sfcInfoService.update(sfcInfoBo);
} catch (Exception ex) {
throw new ServiceException("2313","更新SFC["+sfcInfoBo.getSfcNo()+"]基本信息(SfcInfoBO)信息失败!",ex);
}
}else{
//将循环次数清零
if(StringUtils.equals(bean.getId(), curSfcOperationBo.getId()) && curSfcOperationBo.getLoopNum() > 0){
bean.setLoopNum(0);
try {
sfcOperationService.update(bean);
} catch (Exception ex) {
throw new ServiceException("2323","将SFC["+sfcInfoBo.getSfcNo()+"]的SFC工序步骤(SfcOperationBO)["+bean.getId()+"]的循环次数清零失败!",ex);
}
}
}
}
}
}
//B.判断节点的类型是处置功能HANDFUNCTION，是则执行节点上的处置功能
if(StringUtils.equals("HANDFUNCTION", toNode.getExNodeType())){
//获取处置功能功能点，执行处置功能
ActivityInfoBO activityBo = new ActivityInfoBO(toNode.getHandFunction());
try{
activityBo = activityInfoService.findByPk(toNode.getHandFunction());
}catch(Exception ex){
throw new ServiceException("2322","根据功能点ID["+toNode.getHandFunction()+"]查询功能点信息失败!",ex);
}
try{
executeActivityService.executeSingle(sfcInfoBo.getSite(),sfcInfoBo, sfcInfoBo.getOperation(),
sfcInfoBo.getCurrentResource(), activityBo, userBo, null);
}catch(Exception ex){
throw new ServiceException("2314","执行Complete时执行下一工序步骤上设置的处置功能上配置的活动["+activityBo.getActivityNo()+"]失败!",ex);
}
}
//C.判断节点类型是否是子工艺路线，是则判断该子工艺路线之前有没有走过，有则清空之前的工序步骤信息，然后到子工艺路线的首工序排队，没有生成子工艺路线步骤信息
if(StringUtils.equals("CHILDROUTER", toNode.getExNodeType())){
//抓取子工艺路线
NodeVo toChildRouterFirstNode=null;
List<NodeVo> toChildAllNodes = null;
RouterBO toChildRouter = null;
OperationBO toChildOperation = null;
//查询子工艺路线
try{
toChildRouter = routerService.findByPk(toNode.getChildRouterId());
}catch(Exception ex){
throw new ServiceException("2315","执行Complete之前根据子工艺路线 ID["+toNode.getOperationId()+"]查询子工艺路线基本信息失败!",ex);
}
//查询子工艺路线上的所有节点
try{
toChildAllNodes = mesWfUtil.getAllNodes(toChildRouter.getNo(),toChildRouter.getVersion());
}catch(Exception ex){
throw new ServiceException("3003","调用工作流方法[getAllNodes]根据工艺路线["+toRouter.getNo()+"]["+toRouter.getVersion()+"]查询工艺路线所有工序步骤失败!",ex);
}
//查询子工艺路线第一个步骤
try{
toChildRouterFirstNode = mesWfUtil.getFirstNode(toChildRouter.getNo(), toChildRouter.getVersion());
}catch(Exception ex){
throw new ServiceException("2316","调用工作流方法[getFirsetNode]根据工艺路线["+toChildRouter.getNo()+"]["+toChildRouter.getVersion()+"]查询工艺路线第一个工序步骤失败!",ex);
}
//查询子工艺路线首工序
if(StringUtils.equals("NODEGROUP", toChildRouterFirstNode.getExNodeType())){
try{
toChildOperation = operationService.findByPk(toChildRouterFirstNode.getOperationId());
}catch(Exception ex){
throw new ServiceException("2317","根据工序 ID["+toNode.getOperationId()+"]查询工序基本信息失败!",ex);
}
}
//查询SFC 子工艺路线步骤信息(SfcRouter),校验传入工艺路线之前走过
SfcRouterBO sfcRouterBO= null;
try {
sfcRouterBO=this.sfcRouterService.findByUk(sfcInfoBo.getSite().getId(), sfcInfoBo.getId(), toChildRouter.getId());
} catch (Exception ex) {
throw new ServiceException("2318","根据SFC["+sfcInfoBo.getSfcNo()+"]工艺路线["+toRouter.getNo()+"]["+toRouter.getVersion()+"]查询SFC工艺路线(SfcRouterBO)信息是否存在失败!",ex);
}
if(sfcRouterBO!=null){
//清空SFC工序步骤信息
List<SfcOperationBO> sfcOperations = null;
try{
SfcOperationBO sfcOperation = new SfcOperationBO();
sfcOperation.setSite(sfcRouterBO.getSite());
sfcOperation.setSfcRouter(sfcRouterBO);
try {
sfcOperations = sfcOperationService.find(sfcOperation );
} catch (Exception ex) {
throw new ServiceException("2310","查询SFC["+sfcInfoBo.getSfcNo()+"]在工艺路线RouterBo["+toChildRouter.getNo()+"]["+toChildRouter.getVersion()+"]上的工序步骤信息失败!",ex);
}
}catch(Exception ex){
}
for(SfcOperationBO sob:sfcOperations){
sfcInfoBo =clearSfcOperationInfo(sfcInfoBo,sob,userBo,toChildRouterFirstNode,operationQueueBoStatus,curDate,toChildOperation);
}
//Update SfcRouter
sfcRouterBO.setPreviousRouter(sfcInfoBo.getSfcRouter());
sfcRouterBO.setLastSfcOperationStep(sfcInfoBo.getSfcOperation());
try {
this.sfcRouterService.update(sfcRouterBO);
} catch (Exception ex) {
throw new ServiceException("2319","更新SFC["+sfcInfoBo.getSfcNo()+"]工艺路线(SfcRouterBO)工艺路线["+toRouter.getNo()+"]["+toRouter.getVersion()+"]的信息中的当前工序步骤失败!",ex);
}
//update SfcInfo
sfcInfoBo.setOriginalStatus(sfcInfoBo.getStatus());
sfcInfoBo.setStatus(statusQueueBo);
sfcInfoBo.setOperationStepStatus(operationQueueBoStatus);
sfcInfoBo.setRouter(toChildRouter);
sfcInfoBo.setOperation(toChildOperation);
sfcInfoBo.setSfcRouter(sfcRouterBO);
sfcInfoBo.setLastHandleUser(userBo);
sfcInfoBo.setLastHandleTime(curDate);
try {
this.sfcInfoService.update(sfcInfoBo);
} catch (Exception ex) {
throw new ServiceException("2320","更新SFC["+sfcInfoBo.getSfcNo()+"]基本信息(SfcInfoBO)信息失败!",ex);
}
//传入工艺路线之前没走过
}else{
this.createSfcRouterOperationInfo(sfcInfoBo, toChildRouter, userBo, toChildAllNodes,statusQueueBo , operationQueueBoStatus,toChildRouterFirstNode,toChildOperation,curDate,sfcInfoBo.getCurrentResource());
}
}
//D.判断节点类型是否是步骤组
if(StringUtils.equals("NODEGROUP", toNode.getExNodeType())){
//查询传入进来的工艺路线的SfcRouterBO
SfcRouterBO toSfcRouterBo = null;
OperationBO toOperation = null;
try{
toSfcRouterBo = sfcRouterService.findByUk(sfcInfoBo.getSite().getId(), sfcInfoBo.getId(), toRouter.getId());
}catch(Exception ex){
throw new ServiceException("2308","根据SFC["+sfcInfoBo.getSfcNo()+"]工艺路线["+toRouter.getNo()+"]["+toRouter.getVersion()+"]查询SFC工艺路线信息(SfcRouterBO)失败!",ex);
}
//如果工艺路线之前没有走过，并且传入的节点是传入工艺路线的首节点，则发起工作流程，生成步骤信息;否则抛出异常
if(toSfcRouterBo == null){
NodeVo toRouterFirstNode = null;
try{
toRouterFirstNode = mesWfUtil.getFirstNode(toRouter.getNo(),toRouter.getVersion());
}catch(Exception ex){
throw new ServiceException("3002","调用工作流方法[getFirsetNode]根据工艺路线["+toRouter.getNo()+"]["+toRouter.getVersion()+"]查询工艺路线第一个工序步骤失败!",ex);
}
if(StringUtils.equals(toRouterFirstNode.getNodeId(), toNode.getNodeId())){
this.createSfcRouterOperationInfo(sfcInfoBo, toRouter, userBo, toRouterAllNodes,statusQueueBo , operationQueueBoStatus,toNode,toOperation,curDate,sfcInfoBo.getCurrentResource());
}else{
throw new ServiceException("2309","SFC["+sfcInfoBo.getSfcNo()+"]没有走过工艺路线["+toRouter.getNo()+"]["+toRouter.getVersion()+"],步骤["+toNode.getNodeId()+"]不是工艺路线["+toRouter.getNo()+"]["+toRouter.getVersion()+"]的首步骤,不能跳转!");
}
}else{
//如果之前走过，则直接跳转过去
List<SfcOperationBO> sfcOperationBOs=null;
SfcOperationBO sfcOperationBO= new SfcOperationBO();
sfcOperationBO.setSfcRouter(toSfcRouterBo);
sfcOperationBO.setSite(sfcInfoBo.getSite());
sfcOperationBO.setStepGroup(toNode.getNodeId());
//获取传入步骤组中的所有工序步骤信息
try {
sfcOperationBOs = sfcOperationService.find(sfcOperationBO );
} catch (Exception ex) {
throw new ServiceException("2310","查询SFC["+sfcInfoBo.getSfcNo()+"]在工艺路线RouterBo["+toRouter.getNo()+"]["+toRouter.getVersion()+"]上的工序步骤信息失败!",ex);
}
//Update SfcOperationBO
for (SfcOperationBO bean : sfcOperationBOs) {
bean.setStatus(operationQueueBoStatus);
bean.setSfcQty(sfcInfoBo.getQty());
bean.setActiveDate(curDate);
bean.setTriggerUser(userBo);
bean.setPreviousOperation(curSfcOperationBo);
bean.setQueueNum(bean.getQueueNum()+1);
try {
sfcOperationService.update(bean);
} catch (Exception ex) {
throw new ServiceException("2311","更新SFC["+sfcInfoBo.getSfcNo()+"]的SFC工序步骤(SfcOperationBO)["+bean.getId()+"]信息失败!",ex);
}
}
//Update SfcRouterBO
//判断传入的工艺路线是否与当前工艺路线相同
if(!toRouter.equals(sfcInfoBo.getRouter())){
toSfcRouterBo.setPreviousRouter(sfcInfoBo.getSfcRouter());
}
toSfcRouterBo.setLastSfcOperationStep(null);
toSfcRouterBo.setNodeGroup(toNode.getNodeId());
try {
this.sfcRouterService.update(toSfcRouterBo);
} catch (Exception ex) {
throw new ServiceException("2312","更新SFC["+sfcInfoBo.getSfcNo()+"]的SFC工艺路线(SfcRouterBO)["+curSfcRouterBo.getId()+"]中的当前工序步骤失败!",ex);
}
//Update SfcInfoBO
sfcInfoBo.setOriginalStatus(sfcInfoBo.getStatus());
sfcInfoBo.setStatus(statusQueueBo );
sfcInfoBo.setOperationStepStatus(operationQueueBoStatus);
sfcInfoBo.setRouter(toRouter);
sfcInfoBo.setOperation(toOperation);
sfcInfoBo.setSfcRouter(toSfcRouterBo);
sfcInfoBo.setSfcOperation(null);
sfcInfoBo.setLastHandleTime(curDate);
sfcInfoBo.setLastHandleUser(userBo);
sfcInfoBo.setStepGroup(toNode.getNodeId());
sfcInfoBo.setStepId(toNode.getNodeId());
try {
this.sfcInfoService.update(sfcInfoBo);
} catch (Exception ex) {
throw new ServiceException("2313","更新SFC["+sfcInfoBo.getSfcNo()+"]基本信息(SfcInfoBO)信息失败!",ex);
}
}
}
//AfterApprove:执行二次开发接口业务处理类
log.debug(">>>>>>>>>>>>>>>>>>>>>>Execute After Approve Listener ");
this.executeEvent(this.EVENT_AFTER_APPROVE, sfcInfoBo, toRouter, null, null, toNode, userBo);
}
@Override
public NodeVo getFirstNode(RouterBO routerBo){
// TODO Auto-generated method stub
//校验RouterBO是否为空
if(routerBo == null){
throw new ServiceException("2021","调用MES工作流getFirstNode时，传入的RouterBO为空!");
}
if(StringUtils.isEmpty(routerBo.getId())){
throw new ServiceException("2022","调用MES工作流getFirstNode时，传入的RouterBO对象ID为空!");
}
try{
routerBo = routerService.findByPk(routerBo.getId());
}catch(Exception ex){
throw new ServiceException("2050","获取工艺路线首工序时根据ROUTER ID["+routerBo.getId()+"]查询工艺路线基本信息异常!",ex);
}
MesWfutil mesWfUtil =null;
NodeVo nv = null;
try{
mesWfUtil = new MesWfutil(sqlMapClient);
nv = mesWfUtil.getFirstNode(routerBo.getNo(), routerBo.getVersion());
}catch(Exception ex){
throw new ServiceException("3002","调用工作流方法[getFirsetNode]根据工艺路线["+routerBo.getNo()+"]["+routerBo.getVersion()+"]查询工艺路线第一个工序步骤失败!",ex);
}
return nv;
}
@Override
public List<NodeVo> getAllNodes(RouterBO router) {
// TODO Auto-generated method stub
//校验RouterBO是否为空
if(router == null){
throw new ServiceException("2023","调用MES工作流getAllNodes时，传入的RouterBO为空!");
}
if(StringUtils.isEmpty(router.getId())){
throw new ServiceException("2024","调用MES工作流getAllNodes时，传入的RouterBO对象ID为空!");
}
try{
router = routerService.findByPk(router.getId());
}catch(Exception ex){
throw new ServiceException("2050","获取工艺路线所有工序步骤时根据ROUTER ID["+router.getId()+"]查询工艺路线基本信息异常!",ex);
}
MesWfutil mesWfUtil =null;
List<NodeVo> nv = null;
try{
mesWfUtil = new MesWfutil(sqlMapClient);
nv = mesWfUtil.getAllNodes(router.getNo(), router.getVersion());
}catch(Exception ex){
throw new ServiceException("3003","调用工作流方法[getAllNodes]根据工艺路线["+router.getNo()+"]["+router.getVersion()+"]查询工艺路线所有工序步骤失败!",ex);
}
return nv;
}
@Override
public List<NodeVo> getNextNodes(RouterBO routerBo, String paramNodeId) {
MesWfutil mesWfUtil =null;
List<NodeVo> canToNodes = null;
mesWfUtil = new MesWfutil(sqlMapClient);
try {
canToNodes = mesWfUtil.getNextNodes(routerBo.getNo(), routerBo.getVersion(),paramNodeId);
} catch (SQLException ex) {
throw new ServiceException("3004","调用工作流方法[getNextNodes]根据工艺路线["+routerBo.getNo()+"]["+routerBo.getVersion()+"]工序步骤ID["+paramNodeId+"]获取一下工序步骤集失败!",ex);
}
return canToNodes;
}
@Override
public List<NodeVo> getNextNodes(SfcInfoBO sfcInfoBo,String paramNodeId,Map contextproperties) {
// TODO Auto-generated method stub
//校验SfcInfoBO是否为空
if(sfcInfoBo == null){
throw new ServiceException("2025","调用MES工作流getNextNodes时，传入的SfcInfoBO为空!");
}
if(StringUtils.isEmpty(sfcInfoBo.getId())){
throw new ServiceException("2026","调用MES工作流getNextNodes时，传入的SfcInfoBO对象ID为空!");
}
//校验paramNodeId是否为空
if(paramNodeId == null){
throw new ServiceException("2027","调用MES工作流getNextNodes时，传入的步骤ID为空!");
}
if(StringUtils.isEmpty(sfcInfoBo.getId())){
throw new ServiceException("2028","调用MES工作流getNextNodes时，传入的步骤ID为空!");
}
//查询SFC基本信息
try{
sfcInfoBo = sfcInfoService.findByPk(sfcInfoBo.getId());
}catch(Exception ex){
throw new ServiceException("2011","获取下一工序步骤时根据SFC ID["+sfcInfoBo.getId()+"]查询SFC基本信息(SfcInfoBO)失败!",ex);
}
SfcRouterBO curSfcRouterBo = null;
//查询SFC当前工艺路线(SfcRouterBO)信息
try{
curSfcRouterBo = sfcRouterService.findByPk(sfcInfoBo.getSfcRouter().getId());
}catch(Exception ex){
throw new ServiceException("2012","获取SFC["+sfcInfoBo.getSfcNo()+"]下一工序步骤时根据SfcRouter ID["+sfcInfoBo.getSfcRouter().getId()+"]查询SFC当前工艺路线信息(SfcRouterBO)失败!",ex);
}
MesWfutil mesWfUtil =null;
List<NodeVo> returnNodes = new ArrayList<NodeVo>();
List<NodeVo> canToNodes = null;
NodeVo curNode = null;
NodeVo paramNode = null;
Object excuteJsResult = null;
//获取传入的节点信息
try{
mesWfUtil = new MesWfutil(sqlMapClient);
paramNode = mesWfUtil.getNodeById(sfcInfoBo.getRouter().getNo(), sfcInfoBo.getRouter().getVersion(), paramNodeId);
}catch(Exception ex){
throw new ServiceException("3001","调用工作流方法[getNodeById]根据工艺路线["+sfcInfoBo.getRouter().getNo()+"]["+sfcInfoBo.getRouter().getVersion()+"]工序步骤ID["+paramNodeId+"]查询工序步骤基本信息失败!",ex);
}
if(paramNode == null){
throw new ServiceException("2014","在工艺路线["+sfcInfoBo.getRouter().getNo()+"]["+sfcInfoBo.getRouter().getVersion()+"]中没有找到工序步骤["+paramNodeId+"]!");
}
//A:传入节点是返回步骤RETURN,则计算原来工艺路线上可以去的节点
if(StringUtils.equals(paramNode.getExNodeType(), "RETURN") ){
//获取SFC当前工艺路线的上一工艺路线，如果没有则抛出异常,如果有则计算上一工艺路线上可以Return的工序
if(curSfcRouterBo.getPreviousRouter() == null){
throw new ServiceException("2014","SFC["+sfcInfoBo.getSfcNo()+"]所走的工艺路线只有["+sfcInfoBo.getRouter().getNo()+"]["+sfcInfoBo.getRouter().getVersion()+"]一条,不能执行返回步骤!");
}
if(StringUtils.isEmpty(curSfcRouterBo.getPreviousRouter().getId())){
throw new ServiceException("2015","SFC["+sfcInfoBo.getSfcNo()+"]所走的工艺路线只有["+sfcInfoBo.getRouter().getNo()+"]["+sfcInfoBo.getRouter().getVersion()+"]一条,不能执行返回步骤!");
}
SfcRouterBO preSfcRouterBo = null;
SfcOperationBO preSfcOperationBo = null;
RouterBO preRouterBo = null;
//获取SFC原工艺路线(SfcRouterBO)的信息
try{
preSfcRouterBo = sfcRouterService.findByPk(curSfcRouterBo.getPreviousRouter().getId());
}catch(Exception ex){
throw new ServiceException("2016","获取SFC["+sfcInfoBo.getSfcNo()+"]下一工序步骤时根据SfcRouter ID["+curSfcRouterBo.getPreviousRouter().getId()+"]查询SFC原工艺路线基本信息失败!",ex);
}
//获取SFC原工艺路线上的最后工序步骤(SfcOperationBO)信息
try{
preSfcOperationBo = sfcOperationService.findByPk(preSfcRouterBo.getLastSfcOperationStep().getId());
}catch(Exception ex){
throw new ServiceException("2017","获取SFC["+sfcInfoBo.getSfcNo()+"]下一工序步骤时根据SfcOperation ID["+preSfcRouterBo.getLastSfcOperationStep().getId()+"]查询SFC原工序步骤基本信息失败!",ex);
}
//获取原工艺路线的基本信息
try{
preRouterBo = routerService.findByPk(preSfcRouterBo.getRouter().getId());
}catch(Exception ex){
throw new ServiceException("2018","获取SFC["+sfcInfoBo.getSfcNo()+"]下一工序步骤时根据工艺路线 ID["+preSfcRouterBo.getRouter().getId()+"]查询工艺路线基本信息失败!",ex);
}
//获取SFC原工艺路线上的最后工序步骤的节点信息
NodeVo preNodeVo = null;
try{
preNodeVo = mesWfUtil.getNodeById(preRouterBo.getNo(), preRouterBo.getVersion(), preSfcOperationBo.getStepId());
}catch(Exception ex){
throw new ServiceException("3001","调用工作流方法[getNodeById]根据工艺路线["+preRouterBo.getNo()+"]["+preRouterBo.getVersion()+"]工序步骤ID["+preSfcOperationBo.getStepId()+"]查询工序步骤基本信息失败!",ex);
}
//B1:ReturnAny:获取原工艺路线的所有节点
if(StringUtils.equals("ReturnAny", paramNode.getReturnFunction())){
List<NodeVo> preAllNodes = null;
try{
preAllNodes = mesWfUtil.getAllNodes(preRouterBo.getNo(), preRouterBo.getVersion());
}catch(Exception ex){
throw new ServiceException("3003","调用工作流方法[getAllNodes]根据工艺路线["+preRouterBo.getNo()+"]["+preRouterBo.getVersion()+"]查询工艺路线所有工序步骤失败!",ex);
}
if(preAllNodes != null && preAllNodes.size()>0 ){
for(int i=0;i<preAllNodes.size();i++){
if(preAllNodes.get(i).getExNodeType().equals("START") ||
preAllNodes.get(i).getExNodeType().equals("END")||
preAllNodes.get(i).getExNodeType().equals("NODEGROUP")||
preAllNodes.get(i).getExNodeType().equals("RETURN")
){
preAllNodes.remove(i);
}
}
returnNodes = preAllNodes;
}
return returnNodes;
}
//B2:ReturnBack:获取原工艺路线的原节点
if(StringUtils.equals("ReturnBack", paramNode.getReturnFunction())){
returnNodes.add(preNodeVo);
return returnNodes;
}
//B3:ReturnNext:获取原工艺路线的原节点的下一个节点集
if(StringUtils.equals("ReturnNext", paramNode.getReturnFunction())){
List<NodeVo> preNextNodes = null;
try{
preNextNodes = mesWfUtil.getNextNodes(preRouterBo.getNo(), preRouterBo.getVersion(), preNodeVo.getNodeId());
}catch(Exception ex){
throw new ServiceException("3004","调用工作流方法[getNextNodes]根据工艺路线["+preRouterBo.getNo()+"]["+preRouterBo.getVersion()+"]工序步骤ID["+preNodeVo.getNodeId()+"]获取一下工序步骤失败!",ex);
}
returnNodes = preNextNodes;
return returnNodes;
}
//B4:ReturnPrevious:获取原工艺路线的原节点的上一个节点
if(StringUtils.equals("ReturnPrevious", paramNode.getReturnFunction())){
if(preSfcOperationBo.getPreviousOperation() == null){
throw new ServiceException("2017","SFC["+sfcInfoBo.getSfcNo()+"]原工艺路线["+preRouterBo.getNo()+"]["+preRouterBo.getVersion()+"]的原工序步骤没有上一工序,不能执行ReturnPrevious!");
}
if(StringUtils.isEmpty(preSfcOperationBo.getPreviousOperation().getId())){
throw new ServiceException("2018","SFC["+sfcInfoBo.getSfcNo()+"]原工艺路线["+preRouterBo.getNo()+"]["+preRouterBo.getVersion()+"]的原工序步骤没有上一工序,不能执行ReturnPrevious!");
}
SfcOperationBO prePreviousSfcOperation = null;
//获取SFC原工艺路线上的最后工序步骤信息的上一工序步骤
try{
prePreviousSfcOperation = sfcOperationService.findByPk(preSfcOperationBo.getPreviousOperation().getId());
}catch(Exception ex){
throw new ServiceException("2019","根据SfcOperation ID["+preSfcRouterBo.getLastSfcOperationStep().getId()+"]查询SFC["+sfcInfoBo.getSfcNo()+"]工序步骤基本信息失败!",ex);
}
NodeVo prePreviousNodeVo = null;
try{
preNodeVo = mesWfUtil.getNodeById(preRouterBo.getNo(), preRouterBo.getVersion(), prePreviousSfcOperation.getStepId());
}catch(Exception ex){
throw new ServiceException("3001","调用工作流方法[getNodeById]根据工艺路线["+preRouterBo.getNo()+"]["+preRouterBo.getVersion()+"]工序步骤ID["+prePreviousSfcOperation.getStepId()+"]查询工序步骤基本信息失败!",ex);
}
if(prePreviousNodeVo != null){
returnNodes.add(prePreviousNodeVo);
}
return returnNodes;
}
}
//B:不是返回步骤
//执行JS脚本，如果返回值为空值或"-1",则让用户选择去哪个工序
if(StringUtils.isNotEmpty(paramNode.getExecutionRules())){
excuteJsResult = this.excuteJS(paramNode.getExecutionRules(), "getNextNode", contextproperties);
}
//如果执行JS后返回-2，则抛出异常
if(excuteJsResult != null && excuteJsResult.equals("-2")){
throw new ServiceException("2020","JS语法错误,请检查节点["+paramNode.getNodeId()+"]上设置的执行规则JS脚本!");
}
//如果执行JS后返回一个节点号，则将返回的节点返回
if(excuteJsResult != null && !excuteJsResult.equals("-1")){
//获取执行JS脚本后返回的节点信息
NodeVo nv = null;
try{
nv = mesWfUtil.getNodeById(sfcInfoBo.getRouter().getNo(), sfcInfoBo.getRouter().getVersion(), excuteJsResult.toString().trim());
}catch(Exception ex){
throw new ServiceException("3001","调用工作流方法[getNodeById]根据工艺路线["+sfcInfoBo.getRouter().getNo()+"]["+sfcInfoBo.getRouter().getVersion()+"]工序步骤["+excuteJsResult.toString()+"]查询节点基本信息失败!",ex);
}
if(nv == null ){
throw new ServiceException("3010","在工艺路线["+sfcInfoBo.getRouter().getNo()+"]["+sfcInfoBo.getRouter().getVersion()+"]中没有找到工序步骤["+excuteJsResult.toString()+"],请检查工序步骤["+curNode.getNodeId()+"]上设置的执行规则JS脚本!");
}
returnNodes.add(nv);
return returnNodes;
}
//没有JS 或是 执行JS返回-1，则获取所有可以去的工序步骤
try{
canToNodes = mesWfUtil.getNextNodes(sfcInfoBo.getRouter().getNo(), sfcInfoBo.getRouter().getVersion(), paramNode.getNodeId());
returnNodes.addAll(canToNodes);
}catch(Exception ex){
throw new ServiceException("3004","调用工作流方法[getNextNodes]根据工艺路线["+sfcInfoBo.getRouter().getNo()+"]["+sfcInfoBo.getRouter().getVersion()+"]工序步骤ID["+paramNode.getNodeId()+"]获取一下工序步骤集失败!",ex);
}
//如果传入节点是步骤组
if( paramNode.getNodeId().indexOf(".")>0 ){
String nodeGroupId = paramNode.getNodeId().subSequence(0, paramNode.getNodeId().indexOf(".")).toString();
List<SfcOperationBO> sfcOperations = null;
SfcOperationBO sfcOperationBo = new SfcOperationBO();
sfcOperationBo.setSite(curSfcRouterBo.getSite());
sfcOperationBo.setSfcRouter(curSfcRouterBo);
sfcOperationBo.setStepGroup(nodeGroupId);
try {
sfcOperations = sfcOperationService.find(sfcOperationBo );
} catch (Exception ex) {
throw new ServiceException("2310","查询SFC["+sfcInfoBo.getSfcNo()+"]在工艺路线RouterBo["+sfcInfoBo.getRouter().getNo()+"]["+sfcInfoBo.getRouter().getVersion()+"]上的工序步骤信息失败!",ex);
}
//查询工序步骤“完成”状态对象
StatusBO operationDoneStatus=statusService.findByUK(BeanFactory.getSystemParamters().get("mes.siteoperation.operationstatus"),
BeanFactory.getSystemParamters().get("mes.siteoperation.operationstatus.complete"));
int doneNodesInNodeGroup = 0;
for(SfcOperationBO sob : sfcOperations){
if(StringUtils.equals(sob.getStatus().getId(), operationDoneStatus.getId())){
doneNodesInNodeGroup = doneNodesInNodeGroup + 1;
}
}
//查询步骤组节点信息
NodeVo nodeGroup = null;
try{
nodeGroup = mesWfUtil.getNodeById(sfcInfoBo.getRouter().getNo(), sfcInfoBo.getRouter().getVersion(), nodeGroupId);
}catch(Exception ex){
throw new ServiceException("3001","调用工作流方法[getNodeById]根据工艺路线["+sfcInfoBo.getRouter().getNo()+"]["+sfcInfoBo.getRouter().getVersion()+"]工序步骤ID["+nodeGroupId+"]查询工序步骤信息失败!",ex);
}
if(nodeGroup.getMustExeNum() != null && doneNodesInNodeGroup >= nodeGroup.getMustExeNum().intValue()){
try{
canToNodes = mesWfUtil.getNextNodes(sfcInfoBo.getRouter().getNo(), sfcInfoBo.getRouter().getVersion(),nodeGroupId);
returnNodes.addAll(canToNodes);
}catch(Exception ex){
throw new ServiceException("3004","调用工作流方法[getNextNodes]根据工艺路线["+sfcInfoBo.getRouter().getNo()+"]["+sfcInfoBo.getRouter().getVersion()+"]工序步骤ID["+nodeGroupId+"]获取一下工序步骤集失败!",ex);
}
}
}
return returnNodes;
}
@Override
public NodeVo getNodeById(RouterBO routerBo, String nodeId) {
// TODO Auto-generated method stub
if(routerBo == null){
throw new ServiceException("2029","获取节点基本信息时传入的工艺路线对象为空!");
}
if(StringUtils.isEmpty(routerBo.getId())){
throw new ServiceException("2030","获取节点基本信息时传入的工艺路线ID为空值!");
}
if(StringUtils.isEmpty(nodeId)){
throw new ServiceException("2031","获取节点基本信息时传入的节点ID为空值!");
}
try{
routerBo = routerService.findByPk(routerBo.getId());
}catch(Exception ex){
throw new ServiceException("2064","获取节点基本信息时根据工艺路线ID["+routerBo.getId()+"]查询工艺路线基本信息失败!",ex);
}
MesWfutil mesWfUtil =null;
NodeVo nv = null;
try{
mesWfUtil = new MesWfutil(sqlMapClient);
nv = mesWfUtil.getNodeById(routerBo.getNo(), routerBo.getVersion(), nodeId);
}catch(Exception ex){
throw new ServiceException("3001","调用工作流方法[getNodeById]根据工艺路线["+routerBo.getNo()+"]["+routerBo.getVersion()+"]工序步骤ID["+nodeId+"]查询工序步骤基本信息失败!",ex);
}
return nv;
}
/**
* JS脚本执行方法
* @param jsfun
* @param funname
* @param contextproperties
* @return
*/
public Object excuteJS(String jsfun,String funname,Map contextproperties){
if(contextproperties == null){
contextproperties = new HashMap();
contextproperties.put("NCCODE",null);
contextproperties.put("LOOPCOUNT",null);
}
if(contextproperties.get("NCCODE") != null && StringUtils.isEmpty(contextproperties.get("NCCODE").toString())){
contextproperties.put("NCCODE",null);
}
if(contextproperties.get("LOOPCOUNT") != null && StringUtils.isEmpty(contextproperties.get("LOOPCOUNT").toString())){
contextproperties.put("LOOPCOUNT",null);
}
String beforeJsFun = " function getNextNode(param){try{var NCCODE = param.get(\"NCCODE\");var LOOPCOUNT = param.get(\"LOOPCOUNT\"); ";
String afterJsFun = " return \"-1\";}catch(ex){return \"-2\";}return \"-1\";}";
jsfun = beforeJsFun + jsfun + afterJsFun ;
//初始化返回对象
Object returnObject = null;
//获取脚本引擎
ScriptEngineManager sem = new ScriptEngineManager();
ScriptEngine se = null;
se = sem.getEngineByExtension("js");
try {
se.eval(jsfun);
if (se instanceof Invocable) {
Invocable invoke = (Invocable) se;
//执行指定的JS方法
returnObject = invoke.invokeFunction(funname,contextproperties);
}
} catch (NoSuchMethodException ex) {
throw new ServiceException("4000","执行JS脚本失败!",ex);
} catch (ScriptException ex) {
throw new ServiceException("4001","执行JS脚本失败!",ex);
}
//返回
return returnObject;
}
@Override
public RouterBO getPreviousRouter(SfcInfoBO sfcInfoBo) {
RouterBO routerBo=null;
SfcRouterBO sfcRouterBo=null ,PreviousRouter=null;
//校验SFC是否为空
if(sfcInfoBo == null){
throw new ServiceException("2032","调用MES工作流getPreviousRouter时，传入的SfcInfoBO为空!");
}
if(StringUtils.isEmpty(sfcInfoBo.getId())){
throw new ServiceException("2033","调用MES工作流getPreviousRouter时，传入的SfcInfoBO对象ID为空!");
}
//获取sfc基本信息
try{
sfcInfoBo = sfcInfoService.findByPk(sfcInfoBo.getId());
}catch(Exception ex){
throw new ServiceException("2500","根据SFC ID["+sfcInfoBo.getId()+"]查询SFC 基本信息失败!",ex);
}
if(sfcInfoBo == null){
throw new ServiceException("2501","SfcInfoBO对象为空,不能开始!");
}
if(StringUtils.isNotEmpty(sfcInfoBo.getSfcRouter().getId())){
try{
//获取当前sfc工艺路线
sfcRouterBo = this.sfcRouterService.findByPk(sfcInfoBo.getSfcRouter().getId());
}catch(Exception ex){
throw new ServiceException("2502","根据SFC["+sfcInfoBo.getSfcNo()+"]工艺路线["+sfcInfoBo.getSfcRouter().getId()+"]查询SFC 工艺路线信息失败!",ex);
}
if(sfcRouterBo!=null&&StringUtils.isNotEmpty(sfcRouterBo.getPreviousRouter().getId())){
try{
//获取上一步sfc工艺路线
PreviousRouter = this.sfcRouterService.findByPk(sfcRouterBo.getPreviousRouter().getId());
if(PreviousRouter!=null && PreviousRouter.getRouter()!=null){
routerBo=PreviousRouter.getRouter();
}
}catch(Exception ex){
throw new ServiceException("2503","根据SFC["+sfcInfoBo.getSfcNo()+"]上一步工艺路线["+PreviousRouter.getId()+"]查询SFC工艺路线信息失败!",ex);
}
}
}
return routerBo;
}
//清除sfc工序步骤信息
private SfcInfoBO clearSfcOperationInfo(SfcInfoBO sfcInfoBo,SfcOperationBO sfcOperation,UserBO userBo,NodeVo firstNode,StatusBO status,Date curDate,OperationBO operation){
//查询SFC工序步骤"排队"状态对象
StatusBO operationStepQueueStatus=statusService.findByUK(BeanFactory.getSystemParamters().get("mes.siteoperation.operationstatus"),
BeanFactory.getSystemParamters().get("mes.siteoperation.operationstatus.queue"));
sfcOperation.setSfcQty(0);
sfcOperation.setStatus(null);
sfcOperation.setActiveDate(curDate);
sfcOperation.setTriggerUser(userBo);
sfcOperation.setPreviousOperation(null);
if(StringUtils.equals("NODEGROUP", firstNode.getExNodeType())){
if(StringUtils.equals(sfcOperation.getStepGroup(), firstNode.getNodeId())){
sfcOperation.setSfcQty(sfcInfoBo.getQty());
sfcOperation.setStatus(status);
sfcOperation.setPreviousOperation(sfcInfoBo.getSfcOperation());
sfcInfoBo.setStepGroup(sfcOperation.getStepGroup());
if( operation!= null &&
StringUtils.isNotEmpty(operation.getId()) &&
operation.getId() != null &&
StringUtils.equals(operation.getId(), sfcOperation.getOperation().getId())){
sfcInfoBo.setOperation(operation);
sfcInfoBo.setSfcOperation(sfcOperation);
sfcInfoBo.setStepId(sfcOperation.getStepId() );
if(StringUtils.equals(operationStepQueueStatus.getId(), status.getId())){
sfcOperation.setActiveNum(sfcOperation.getActiveNum()+1);
}else{
sfcOperation.setQueueNum(sfcOperation.getQueueNum()+1);
}
}else{
sfcOperation.setStatus(operationStepQueueStatus);
sfcOperation.setQueueNum(sfcOperation.getQueueNum()+1);
}
}
}else{
if(sfcOperation.getStepId().equals(firstNode.getNodeId())){
sfcOperation.setSfcQty(sfcInfoBo.getQty());
sfcOperation.setStatus(status);
sfcOperation.setPreviousOperation(sfcInfoBo.getSfcOperation());
sfcInfoBo.setSfcOperation(sfcOperation);
sfcInfoBo.setStepGroup(null);
sfcInfoBo.setStepId(firstNode.getNodeId() );
if(StringUtils.equals(operationStepQueueStatus.getId(), status.getId())){
sfcOperation.setActiveNum(sfcOperation.getActiveNum()+1);
}else{
sfcOperation.setQueueNum(sfcOperation.getQueueNum()+1);
}
}
}
try {
this.sfcOperationService.update(sfcOperation);
} catch (Exception ex) {
throw new ServiceException("4001","更新SFC["+sfcInfoBo.getSfcNo()+"]工序步骤工艺路线["+sfcInfoBo.getRouter().getNo()+"]["+sfcInfoBo.getRouter().getVersion()+"]步骤["+sfcOperation.getStepId()+"]信息失败!",ex);
}
return sfcInfoBo;
}
//创建sfc工艺路线以及工序步骤相关信息
private void createSfcRouterOperationInfo(SfcInfoBO sfcInfoBo,RouterBO routerBo,UserBO userBo ,List<NodeVo> allNodes,StatusBO statusBO,StatusBO operationStatusBO,NodeVo firstNode,OperationBO firstOperation,Date curDate,ResourceBO resource){
if(!( StringUtils.equals("OPERATION",firstNode.getExNodeType()) ||
StringUtils.equals("NODEGROUP",firstNode.getExNodeType()) )
){
throw new ServiceException("4006","工艺路线["+routerBo.getNo()+"]["+routerBo.getVersion()+"]首工序步骤不能是‘"+firstNode.getExNodeType()+"’类型!");
}
//查询SFC工序步骤"排队"状态对象
StatusBO operationStepQueueStatus=statusService.findByUK(BeanFactory.getSystemParamters().get("mes.siteoperation.operationstatus"),
BeanFactory.getSystemParamters().get("mes.siteoperation.operationstatus.queue"));
//创建SfcRouterBO实例并对属性赋值
SfcRouterBO sfcRouterBo = new SfcRouterBO();
sfcRouterBo.setSite(sfcInfoBo.getSite());
sfcRouterBo.setSfc(sfcInfoBo);
sfcRouterBo.setRouter(routerBo);
sfcRouterBo.setPreviousRouter(sfcInfoBo.getSfcRouter());
sfcRouterBo.setCreateUser(userBo);
sfcRouterBo.setCreateDate(curDate);
try {
sfcRouterBo.setId(this.sfcRouterService.save(sfcRouterBo));
} catch (Exception ex) {
throw new ServiceException("4002","保存SFC["+sfcInfoBo.getSfcNo()+"]工艺路线SfcRouterBO["+sfcRouterBo.getId()+"]信息失败!",ex);
}
for(int i=0;i<allNodes.size();i++){
//普通工序
if(StringUtils.equals("OPERATION", allNodes.get(i).getExNodeType().trim()) ){
SfcOperationBO sob = new SfcOperationBO();
sob.setSite(sfcRouterBo.getSite());
sob.setSfcRouter(sfcRouterBo);
sob.setOperation(operationService.findByPk(allNodes.get(i).getOperationId()));
sob.setStepId(allNodes.get(i).getNodeId());
sob.setSfcQty(0);
sob.setThroughNum(0);
sob.setActiveNum(0);
sob.setQueueNum(0);
sob.setLoopNum(0);
sob.setActiveDate(curDate);
sob.setTriggerUser(userBo);
if(allNodes.get(i).getNodeId().equals(firstNode.getNodeId())){
sob.setSfcQty(sfcInfoBo.getQty());
sob.setStatus(operationStatusBO);
sob.setPreviousOperation(sfcInfoBo.getSfcOperation());
if(!StringUtils.equals(operationStepQueueStatus.getId(), operationStatusBO.getId())){
sob.setStatus(operationStatusBO);
sob.setActiveNum(1);
}else{
sob.setStatus(operationStepQueueStatus);
sob.setQueueNum(1);
}
}
try {
sob.setId(this.sfcOperationService.save(sob));
if(allNodes.get(i).getNodeId().equals(firstNode.getNodeId())){
sfcRouterBo.setLastSfcOperationStep(sob);
}
} catch (Exception ex) {
throw new ServiceException("4003","生成SFC["+sfcInfoBo.getSfcNo()+"]的工序步骤信息(sfcOperationBO)["+sob.getId()+"]信息失败!",ex);
}
}
//步骤组
if(StringUtils.equals("NODEGROUP", allNodes.get(i).getExNodeType().trim()) ){
List<NodeVo> groupNodes = allNodes.get(i).getGroupList();
for(int j=0;j<groupNodes.size();j++){
SfcOperationBO sob = new SfcOperationBO();
sob.setSite(sfcRouterBo.getSite());
sob.setSfcRouter(sfcRouterBo);
sob.setOperation(operationService.findByPk(allNodes.get(i).getOperationId()));
sob.setStepId(groupNodes.get(j).getNodeId());
sob.setSfcQty(0);
sob.setThroughNum(0);
sob.setActiveNum(0);
sob.setQueueNum(0);
sob.setLoopNum(0);
sob.setActiveDate(curDate);
sob.setTriggerUser(userBo);
sob.setStepGroup(allNodes.get(i).getNodeId());
if(allNodes.get(i).getNodeId().equals(firstNode.getNodeId())){
sob.setSfcQty(sfcInfoBo.getQty());
sob.setPreviousOperation(sfcInfoBo.getSfcOperation());
if(firstOperation != null &&
StringUtils.isNotEmpty(firstOperation.getId())&&
firstOperation.getId() != null &&
StringUtils.equals(firstOperation.getId(), allNodes.get(i).getOperationId())){
//不是排队状态
if(!StringUtils.equals(operationStepQueueStatus.getId(), operationStatusBO.getId())){
sob.setStatus(operationStatusBO);
sob.setActiveNum(1);
}else{
sob.setStatus(operationStepQueueStatus);
sob.setQueueNum(1);
}
}else{
sob.setStatus(operationStepQueueStatus);
sob.setQueueNum(1);
}
}
try {
sob.setId(this.sfcOperationService.save(sob));
} catch (Exception ex) {
throw new ServiceException("4003","生成SFC["+sfcInfoBo.getSfcNo()+"]的工序步骤信息(sfcOperationBO)["+sob.getId()+"]信息失败!",ex);
}
}
//如果步骤组是首工序，则设置SfcRouter的步骤组
if(allNodes.get(i).getNodeId().equals(firstNode.getNodeId())){
sfcRouterBo.setNodeGroup(allNodes.get(i).getNodeId());
sfcInfoBo.setStepGroup(allNodes.get(i).getNodeId());
}
}
}
//更新SfcRouter信息
try {
this.sfcRouterService.update(sfcRouterBo);
} catch (Exception ex) {
throw new ServiceException("4004","更新SFC["+sfcInfoBo.getSfcNo()+"]的SFC工艺路线(SfcRouterBO)["+sfcRouterBo.getId()+"]中的当前工序步骤失败!",ex);
}
//更新SfcInfo 信息
sfcInfoBo.setOriginalStatus(sfcInfoBo.getStatus());
sfcInfoBo.setStatus(statusBO);
sfcInfoBo.setOperationStepStatus(operationStatusBO);
sfcInfoBo.setRouter(routerBo);
sfcInfoBo.setOperation(firstOperation);
sfcInfoBo.setSfcRouter(sfcRouterBo);
sfcInfoBo.setSfcOperation(sfcRouterBo.getLastSfcOperationStep());
sfcInfoBo.setLastHandleTime(curDate);
sfcInfoBo.setLastHandleUser(userBo);
sfcInfoBo.setCurrentResource(resource);
sfcInfoBo.setStepId(firstNode.getNodeId());
try {
this.sfcInfoService.update(sfcInfoBo);
} catch (Exception ex) {
throw new ServiceException("4005","更新SfcInfo基本信息失败!",ex);
}
}
@Override
public boolean isFirstOperation(OperationBO operation, RouterBO routerBo) {
//校验OperationBO是否为空
if(operation == null){
throw new ServiceException("2034","调用MES工作流isFirstOperation时，传入的OperationBO为空!");
}
if(StringUtils.isEmpty(operation.getId())){
throw new ServiceException("2035","调用MES工作流isFirstOperation时，传入的OperationBO对象ID为空!");
}
//校验RouterBO是否为空
if(routerBo == null){
throw new ServiceException("2036","调用MES工作流isFirstOperation时，传入的RouterBO为空!");
}
if(StringUtils.isEmpty(routerBo.getId())){
throw new ServiceException("2037","调用MES工作流isFirstOperation时，传入的RouterBO ID为空!");
}
NodeVo firstNode=null;
firstNode=this.getFirstNode(routerBo);
boolean flag=false;
if(firstNode!=null){
flag= this.isNodeOperation(operation, firstNode);
}
return flag;
}
public boolean isNodeOperation(OperationBO operation,NodeVo nodeVo){
//校验OperationBO是否为空
if(operation == null){
throw new ServiceException("2038","调用MES工作流isNodeOperation时，传入的OperationBO为空!");
}
if(StringUtils.isEmpty(operation.getId())){
throw new ServiceException("2039","调用MES工作流isNodeOperation时，传入的OperationBO对象ID为空!");
}
//校验NodeVo是否为空
if(nodeVo == null){
throw new ServiceException("2040","调用MES工作流isNodeOperation时，传入的步骤ID为空!");
}
if(StringUtils.isEmpty(nodeVo.getNodeId())){
throw new ServiceException("2041","调用MES工作流isNodeOperation时，传入的步骤ID为空!");
}
if(StringUtils.equals("NODEGROUP", nodeVo.getExNodeType())){
for(NodeVo nv:nodeVo.getGroupList()){
if(StringUtils.equals(operation.getId(),nv.getOperationId())){
return true;
}
}
}
if(StringUtils.equals("OPERATION", nodeVo.getExNodeType())){
if(StringUtils.equals(operation.getId(),nodeVo.getOperationId())){
return true;
}
}
return false;
}
public boolean isCurOperation(SfcInfoBO sfcInfoBo,OperationBO operationBo){
//校验OperationBO是否为空
if(operationBo == null){
throw new ServiceException("2042","调用MES工作流isCurOperation时，传入的OperationBO为空!");
}
if(StringUtils.isEmpty(operationBo.getId())){
throw new ServiceException("2043","调用MES工作流isCurOperation时，传入的OperationBO对象ID为空!");
}
//校验SfcInfo是否为空
if(sfcInfoBo == null){
throw new ServiceException("2044","调用MES工作流isCurOperation时，传入的SfcInfoBO为空!");
}
if(StringUtils.isEmpty(sfcInfoBo.getId())){
throw new ServiceException("2045","调用MES工作流isCurOperation时，传入的SfcInfoBO对象ID为空!");
}
//查询Sfc基本信息
try{
sfcInfoBo = sfcInfoService.findByPk(sfcInfoBo.getId());
}catch(Exception ex){
throw new ServiceException("2100","根据SFC ID["+sfcInfoBo.getId()+"]查询SFC 基本信息失败!",ex);
}
if(sfcInfoBo == null){
throw new ServiceException("2101","SFC无效!");
}
if(sfcInfoBo.getOperation() != null && StringUtils.isNotEmpty(sfcInfoBo.getOperation().getId())){
if(StringUtils.equals(sfcInfoBo.getOperation().getId(), operationBo.getId())){
return true;
}else{
return false;
}
}
if(sfcInfoBo.getStepGroup() != null && StringUtils.isNotEmpty(sfcInfoBo.getStepGroup())){
NodeVo nv = this.getNodeById(sfcInfoBo.getRouter(), sfcInfoBo.getStepGroup());
return this.isNodeOperation(operationBo, nv);
}
return false;
}
/**
* 监听事件执行方法
* @param event
* @param sfc
* @param routerBo
* @param operationBo
* @param resourceBo
* @param toNodeId
* @param userBo
*/
private void executeEvent(String event,SfcInfoBO sfcInfoBo,RouterBO routerBo,OperationBO operationBo,ResourceBO resourceBo,NodeVo nodeVo,UserBO userBo){
String[] clazzes = getListener().get(event);
if(clazzes == null || clazzes.length == 0) return;
for(String clazz : clazzes){
try{
Event e = (Event) BeanFactory.getClazzIns(clazz, BeanFactory.INSTANCE_SINGLETON);
e.execute(sfcInfoBo,routerBo,operationBo,resourceBo,nodeVo,userBo,new WFContext(this));
}catch(Exception ex){
throw new ServiceException("2109","SFC["+sfcInfoBo.getSfcNo()+"]"+event+"执行MES业务功能代码["+clazz+"]异常!",ex);
}
}
}
public void setSfcInfoService(SfcInfoService sfcInfoService){
this.sfcInfoService = sfcInfoService;
}
public void setStatusService(StatusService statusService) {
this.statusService = statusService;
}
public void setSfcOperationService(SfcOperationService sfcOperationService) {
this.sfcOperationService = sfcOperationService;
}
public void setSfcRouterService(SfcRouterService sfcRouterService) {
this.sfcRouterService = sfcRouterService;
}
public void setRouterService(RouterService routerService) {
this.routerService = routerService;
}
public void setOperationService(OperationService operationService) {
this.operationService = operationService;
}
public void setSqlMapClient(SqlMapClient sqlMapClient) {
this.sqlMapClient = sqlMapClient;
}
public void setResourceService(ResourceService resourceService) {
this.resourceService = resourceService;
}
public void setExecuteActivityService(
ExecuteActivityService executeActivityService) {
this.executeActivityService = executeActivityService;
}
public void setActivityInfoService(ActivityInfoService activityInfoService) {
this.activityInfoService = activityInfoService;
}
public void setListener(Map<String,String[]> listener) {
this.listener = listener;
}
public Map<String,String[]> getListener() {
return listener;
}
}
package com.byd.mes.plugins.workFlow;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang.StringUtils;
import com.byd.mes.plugins.workFlow.impl.BydWorkFlowServiceImpl;
public class Test {
public static void main(String[] args) {
File file = new File("d:/js.txt");
try {
String str = IOUtils.toString(new FileReader(file));
System.out.println(str);
BydWorkFlowServiceImpl bw = new BydWorkFlowServiceImpl();
Map mp = new HashMap();
mp.put("NcCode1", "2");
mp.put("LoopCount2",3);
String rl = bw.excuteJS(str, "getNextNode", mp).toString();
System.out.println(rl);
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
分享到：
发表评论
-
进制转换
2014-08-29 18:55 976package com.byd.core; imp ... -
Java发送Email
2011-11-07 13:57 1040package byd.core; import java. ... -
天干地支算法
2011-10-10 11:44 1166/** * <url>http://en.w ... -
MD5
2011-09-27 09:34 758public class Encryptor { ... -
java运行可以执行文件
2011-08-15 10:44 766# package com.yymt.pf.rpc.loadb ... -
随记生成验证码
2011-08-06 09:28 990package com.hrm.houfei.utils; ... -
TLD生成
2011-08-06 09:16 1030package j2ee.util; import ja ... -
页面解析
2011-08-06 09:13 872package com.atom.util; impor ... -
StringUtils 工具类
2011-08-06 09:11 1095package com.atom.util; impor ... -
重构HashTable
2011-08-06 09:03 916package com.atom.util; impor ... -
文件解析
2011-08-06 08:52 566package com.byd.portal.pagedesi ... -
缓存处理工具类
2011-08-06 08:20 1package com.byd.mes.util.cache; ... -
缓存处理工具类
2011-08-06 08:20 1205package com.byd.mes.util.cache; ... -
Java执行javascript
2011-08-06 08:17 930package com.byd.mes.util.script ... -
文件处理工具类
2011-08-05 17:12 910/* * MyUtils.java * * */ ... -
Struts2文件上传下载
2011-08-05 16:42 1190package com.byd.action; impo ... -
对于不同数据库分页分查询析
2011-08-05 16:32 1079package zxc.utils; /** * 这 ... -
类转换
2011-08-05 16:30 843package zxc.utils; import ja ... -
数字转中文
2011-08-05 16:28 837package zxc.utils; import ja ... -
生成唯一流水码
2011-08-05 09:50 1072package com.byd.mes.util; im ...
相关推荐
在"OA工作流WorkFlow版本(前台JS实现)"中，重点是使用JavaScript在前端实现工作流的相关功能。JavaScript作为客户端脚本语言，使得用户可以在浏览器中直接交互，提高用户体验，同时也减轻了服务器端的压力。 1. **...
1. **工作流定义（workflow define）**：这是工作流的基础，定义了任务的顺序、条件、参与者以及如何在这些元素之间转移。在提供的"workflowdefine"中，可能包含了定义工作流逻辑的JavaScript源代码。开发者可以...
springboot整合activiti工作流Workflow 安装本机java环境 用idea打开本项目文件 启动项目 即可生成activiti工作流的相应配置，基本环境 act_evt_log.sql里是新建activiti工作流所需要的表列表
工作流（WorkFlow）是一种自动化业务流程的技术，它在IT领域中扮演着至关重要的角色，帮助组织提升效率、规范操作并实现跨部门协同工作。WF（Workflow）是工作流的缩写，通常指的是.NET框架下Microsoft提供的工作流...
工作流（Workflow）是信息化系统中的一个重要组成部分，它在web应用中扮演着不可或缺的角色。工作流是指在组织内部，按照一定的规则和流程，对业务活动进行自动化管理的过程。这一概念涵盖了任务分配、审批、协作、...
Mac上最好用的用的搜索扩展Alfred 2的工作流workflow，知乎
**JBPM指南：深入理解工作流（workflow）** 工作流（Workflow）是现代企业信息化建设中的关键组成部分，它帮助企业高效地管理和协调业务流程，确保各项任务的顺利进行。JBPM，全称为Java Business Process ...
标题中提到的“疯狂Workflow讲义 基于Activiti的工作流应用开发.pdf”，表明本书是关于Activiti工作流引擎的学习资料。Activiti是一个使用Java编写的轻量级工作流和业务流程管理(BPM)平台。该引擎遵循BPMN 2.0标准，...
现代工作流，通常简称为workflow，是信息化管理中的重要组成部分，尤其在企业级应用中扮演着不可或缺的角色。工作流指的是将一个复杂的任务分解为一系列可操作的步骤，由多个参与者协同完成，以此提高工作效率和管理...
"WorkFlow C++ 工作流图形"是一个专注于在C++环境中实现工作流管理的图形化库。工作流，简单来说，就是一系列按照特定顺序执行的任务或活动，它在企业管理、软件开发、流程自动化等领域中广泛应用。C++作为一门强大...
工作流框架，通常被称为Workflow，是软件开发中的一个重要概念，它涉及到流程自动化、任务管理和业务规则的执行。在本文中，我们将深入探讨工作流框架的核心原理、应用领域以及如何使用和选择适合的工作流框架。 一...
workflow工作流workflow工作流workflow工作流workflow工作流workflow工作流workflow工作流workflow工作流workflow工作流workflow工作流workflow工作流workflow工作流
工作流（Workflow）是软件系统中用于自动化处理一系列任务或业务流程的技术，它允许开发者将复杂的业务逻辑分解为可管理的步骤。在Windows Forms（WinForms）应用中集成Workflow，可以构建用户友好的图形界面，同时...
工作流（Workflow）是一种自动化业务过程的技术，它用于管理和控制信息在组织内部的流动，确保任务按照预定的规则和步骤有序进行。工作流实例则是这种技术的具体应用，它描述了一个具体的工作流程，包括各个任务的...
8. **工作流术语**：了解工作流容器、工作流代理、组织计划、事件和工作项等基本概念是深入使用SAP Workflow的前提。每个术语都有其特定的含义和作用，它们共同构成了工作流的运作基础。 总结起来，SAP Workflow是...
工作流（Workflow）是一种自动化处理任务的技术，它在IT领域被广泛应用，特别是在企业管理、项目协作和数据处理等方面。工作流的核心在于定义并管理业务过程，确保任务按照预设的规则和顺序有效地执行。在这个“请假...
Fire Workflow是一款由国内知名开源社区联盟成员非也同志开发的工作流管理系统，专注于为企业提供灵活、高效的工作流程自动化解决方案。这款系统基于PT网构建，旨在帮助开发者和企业实现业务流程的标准化、可视化...
工作流（WorkflowService）WebService接口使用说明文档详细阐述了如何在泛微E8和E9版本的Ecology8、Ecology9系统中进行接口开发。这些接口主要用于企业级的工作流管理，提供了一套完整的Web服务解决方案，使得不同...
微软工作流（Workflow）是微软技术栈中一个关键的概念，它是一种自动化业务流程的设计和执行方式，用于模拟和实现组织内的各种工作流程。在本Demo中，我们可以深入理解这一技术的应用和实现细节。 工作流（Workflow...
工作流WorkflowMonitor.rar实例 WorkflowMonitor是工作流示例库的一部分，它由Windows SDK承载。把WFSample.zip文件复制到本章解决方案的目录下并进行解压。WFSamples.zip文件在下面的位置可找到（声明：本人未在...