RouterUtils.java

package cn.timer.api.utils;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.lang.Console;
import cn.hutool.core.util.NumberUtil;
import cn.hutool.json.JSONObject;
import cn.timer.api.bean.spmk.SpmkApproveExecuteRecord;
import cn.timer.api.bean.spmk.SpmkApproveSummary;
import cn.timer.api.bean.spmk.SpmkExecutor;
import cn.timer.api.bean.yggl.YgglMainEmp;
import cn.timer.api.bean.zzgl.ZzglBmgwM;
import cn.timer.api.dto.spmk.Condition;
import cn.timer.api.dto.spmk.FlowChildren;
import cn.timer.api.dto.spmk.FromData;
import cn.timer.api.dto.spmk.Relation;
import cn.timer.api.dto.spmk.Router;
import cn.timer.api.dto.spmk.User;

/**
 * 流程节点工具类
 * 
 * @author Administrator
 *
 */
public class RouterUtils {
	
	private final static String UNEXECUTED = "0";
	private final static String EXECUTING = "1";
	private final static String EXECUTED = "2";
	private final static String CREATOR = "creator";
	private final static String RULES = "rules";
	private final static String AUDIT = "audit";
	private final static String COPY = "copy";
	private final static String RELATION_TYPE_DEPARTMENT = "department";
	private final static String RELATION_TYPE_USERS = "users";

	public static List<Router> NextNode(List<Router> listRouter,JSONObject obj, boolean isFirse) {
		return NextNode(listRouter, obj, isFirse, false);
	}

	// 执行下一个节点
	public static List<Router> NextNode(List<Router> listRouter,JSONObject obj, boolean isFirse, boolean isAuditNext) {
		
		Router router;
		if (listRouter != null && listRouter.size() != 0) {
			// 非条件节点
			if (listRouter.size() == 1) {
				router = listRouter.get(0);
				if (router.getExecute() == null) {
					System.out.println("默认UNEXECUTED");
					router.setExecute(UNEXECUTED);
				}
				// 0未执行 1执行中 2已执行
				switch (router.getExecute()) {
				case UNEXECUTED:
					switch (router.getClassName()) {
					case CREATOR:
						Console.log("发起人逻辑");
						router.setExecute(EXECUTED);
						router.setFlow(true);
						router.getRelation().get(0).setName(obj.get("initiator",FromData.class).getValue());
						
						NextNode(router.getChildren(),obj, isFirse, isAuditNext);
						break;
					case AUDIT:
						Console.log("审批人逻辑");
						router.setExecute(EXECUTING);
						router.setFlow(true);
						
						List<User> listUser = router.getRelation().get(0).getUsers();
						user:
							for (int i = 0; i < listUser.size(); i++) {
								String execute = listUser.get(i).getExecute();
								switch (execute) {
								case UNEXECUTED:
									listUser.get(i).setExecute(EXECUTING);
									// 首次发起申请时，写入 审批人名称 至 obj 中
									if (isFirse) {
										obj.put("current_approver", listUser.get(i).getName());
									}
									
									break user;
//								case EXECUTING:
//									listUser.get(i).setExecute(EXECUTED);
//									break;
								}
							}
						isAuditNext = true;
						NextNode(router.getChildren(), obj , isFirse, isAuditNext);
						break;
					case COPY:
						if (!isAuditNext) {
							router.setExecute(EXECUTED);
						}
						Console.log("抄送人逻辑");
						router.setFlow(true);
						List<Relation> listRelations = router.getRelation();
						for (int i = 0; i < listRelations.size(); i++) {
							// 装配 部门人员
							if (RELATION_TYPE_DEPARTMENT.equals(listRelations.get(i).getType())) {
								List<YgglMainEmp> listYgglMainEmp = selectOtherlistent(Integer.parseInt(obj.get("orgCode",FromData.class).getValue()), Integer.valueOf(listRelations.get(i).getDepartmentId()));
								
								System.out.println(listYgglMainEmp);
								
								if (listYgglMainEmp != null && listYgglMainEmp.size() > 0) {
									List<User> listUsers = new ArrayList<User>();
									for (YgglMainEmp emp : listYgglMainEmp) {
										User user = new User();
										user.setName(emp.getName());
										user.setId(String.valueOf(emp.getEmpNum()));
										listUsers.add(user);
									}
									listRelations.get(i).setUsers(listUsers);
								}else {
									listRelations.get(i).setUsers(null);
								}
								
								
							}else if (RELATION_TYPE_USERS.equals(listRelations.get(i).getType())) {

							}
						}
						NextNode(router.getChildren(), obj , isFirse, isAuditNext);
						break;
					}
					break;
				case EXECUTING:
					switch (router.getClassName()) {
					case AUDIT:
						router.setFlow(true);
						if (!isFirse) {
							Console.log("下一个审批人逻辑");
							boolean executeFlog = true;
							List<User> listUser = router.getRelation().get(0).getUsers();
							user:
								for (int i = 0; i < listUser.size(); i++) {
									String execute = listUser.get(i).getExecute();
									switch (execute) {
									case UNEXECUTED:
										listUser.get(i).setExecute(EXECUTING);
										executeFlog = false;
										break user;
									case EXECUTING:
										listUser.get(i).setExecute(EXECUTED);
										break;
									}
								}
							
							if (executeFlog) {
								router.setExecute(EXECUTED);
							}
							
						}
						NextNode(router.getChildren(),obj , isFirse, isAuditNext);
						break;
					}
					break;
				case EXECUTED:
					Console.log("下一个节点");
					NextNode(router.getChildren(),obj , isFirse, isAuditNext);
					break;
				}
				
			} else {
				// 条件节点
				rulefor:
				for (Router routerRule : listRouter) {
					switch (routerRule.getExecute()) {
					case UNEXECUTED:
						boolean condition_b = true;
						List<Condition> listCondition = routerRule.getCondition();
						if (listCondition == null || listCondition.size() == 0) {
							routerRule.setFlow(true);
						}else {
							for (Condition condition : listCondition) {
									for (String string : condition.getValues()) {
										// 判断条件
										if (!stringCompare(obj.get(condition.getKey(),FromData.class).getValue(), string , condition.getFormat())) {
											condition_b = false;
										}
									}
							}
						}
						
						routerRule.setFlow(condition_b);
						routerRule.setExecute(EXECUTED);
						if (routerRule.getFlow()) {
							Console.log("条件逻辑");
							NextNode(routerRule.getChildren(), obj , isFirse, isAuditNext);
						}
						break;
					case EXECUTED:
						if (routerRule.getFlow()) {
							NextNode(routerRule.getChildren(), obj , isFirse, isAuditNext);
						}
						break rulefor;
					}
					
				}
			
				Console.log("最后节点");
			}
		}

		return listRouter;

	};
	
	
	
	public static List<YgglMainEmp> selectOtherlistent(Integer orgCode, Integer id){
		ArrayList<Integer> list = new ArrayList<Integer>();
		QueryWrapper<ZzglBmgwM> queryWrapper = new QueryWrapper<ZzglBmgwM>();
		queryWrapper.eq("org_code", orgCode);
		List<ZzglBmgwM> zzglBmgwMs = ZzglBmgwM.builder().build().selectList(queryWrapper);
		list.add(id);
		ZzglBmgwM.getDepts(list, id, zzglBmgwMs);

		if (list == null || list.size() == 0) {
			return null;
		} else {
			LambdaQueryWrapper<YgglMainEmp> ygglMainEmpsLambdaQueryWrapper = new LambdaQueryWrapper<>();
			ygglMainEmpsLambdaQueryWrapper
					.select(YgglMainEmp::getId, YgglMainEmp::getEmpNum, YgglMainEmp::getName, YgglMainEmp::getPhone,
							YgglMainEmp::getBmgwId)
					.eq(YgglMainEmp::getOrgCode, orgCode).and(i -> i.in(YgglMainEmp::getBmgwId, list.toArray()));
			List<YgglMainEmp> ygglMainEmps = YgglMainEmp.builder().build().selectList(ygglMainEmpsLambdaQueryWrapper);
			return ygglMainEmps;
		}

	}
	
	private static boolean stringCompare(String s1,String s2,String symbol) {
		double d1;
		double d2;
		switch (symbol) {
		case "<":
			d1 = Double.parseDouble(s1);
			d2 = Double.parseDouble(s2);
			if (NumberUtil.compare(d1,d2) == -1) return true;
			break;
		case "<=":
			d1 = Double.parseDouble(s1);
			d2 = Double.parseDouble(s2);
			if (NumberUtil.compare(d1,d2) == -1 || NumberUtil.compare(d1,d2) == 0) return true;
			break;
		case "=":
			if (s2.equals(s1)) return true;
			break;
		case ">":
			d1 = Double.parseDouble(s1);
			d2 = Double.parseDouble(s2);
			if (NumberUtil.compare(d1,d2) == 1) return true;
			break;
		case ">=":
			d1 = Double.parseDouble(s1);
			d2 = Double.parseDouble(s2);
			if (NumberUtil.compare(d1,d2) == 0 || NumberUtil.compare(d1,d2) == 1) return true;
			break;
		}
		return false;

	}

	
	public static void getIsFlowChildren(List<Router> listRouter, List<FlowChildren> listFlowChildren) {
		// TODO Auto-generated method stub
		Router router;
		if (listRouter != null && listRouter.size() == 1) {
			router = listRouter.get(0);
			if (router.getFlow()) {
				FlowChildren fc = FlowChildren.builder().build();
				BeanUtil.copyProperties(router, fc, "condition","children");
				listFlowChildren.add(fc);
				getIsFlowChildren(router.getChildren(), listFlowChildren);
			}
			
		}else if (listRouter.size() > 1) {
			for (Router router2 : listRouter) {
				if (router2.getFlow()) {
//					FlowChildren fc = FlowChildren.builder().build();
//					BeanUtil.copyProperties(router2, fc, "condition","children");
//					listFlowChildren.add(fc);
					getIsFlowChildren(router2.getChildren(), listFlowChildren);
				}
			}
		}

	};
	
	
	
	
	// 审批执行记录 持久化
	public static void insertogExecuteRecord(List<FlowChildren> listFlowChildren,Integer asId) {

		for (int i = 0,m = listFlowChildren.size() ; i < m; i++) {
			if (UNEXECUTED.equals(listFlowChildren.get(i).getExecute())) {
				i++;
				continue;
			}
				
			
			switch (listFlowChildren.get(i).getClassName()) {
			case CREATOR:
				SpmkApproveExecuteRecord aer = SpmkApproveExecuteRecord
						.builder()
						.approveSummaryId(asId)
						.name("发起申请")
						.type(0)
						.sts(2)
						.build();
				// 新增 审批执行记录
				aer.insert();
				
				// 新增 执行人
				User user = listFlowChildren.get(i).getRelation().get(0).getUsers().get(0);
				SpmkExecutor.builder()
				.approveExecuteRecordId(aer.getId())
				.empNum(Integer.parseInt(user.getId()))
				.executorName(user.getName())
				.sts(2)
				.build()
				.insert();
				break;
			case AUDIT:
				SpmkApproveExecuteRecord aer2 = SpmkApproveExecuteRecord
				.builder()
				.approveSummaryId(asId)
				.name("审批人")
				.type(2)
				.sts(1)
				.build();
				// 新增 审批执行记录
				aer2.insert();

				// 新增 执行人
				List<User> listUser = listFlowChildren.get(i).getRelation().get(0).getUsers();
				
				executor: 
				for (User user2 : listUser) {
					SpmkExecutor executor = SpmkExecutor.builder()
					.approveExecuteRecordId(aer2.getId())
					.empNum(Integer.parseInt(user2.getId()))
					.executorName(user2.getName())
					.build();
					switch (user2.getExecute()) {
					case EXECUTING:
						executor.setSts(1);
						executor.insert();
						break executor;
					case EXECUTED:
						executor.setSts(2);
						executor.insert();
						break;
					}
					
					
				}
				break;
			case COPY:
				SpmkApproveExecuteRecord aer3 = SpmkApproveExecuteRecord
				.builder()
				.approveSummaryId(asId)
				.name("抄送人")
				.type(1)
				.sts(2)
				.build();
				// 新增 审批执行记录
				aer3.insert();

				List<Relation> listRelation = listFlowChildren.get(i).getRelation();
				
				for (Relation relation : listRelation) {
					List<User> listUser2 = relation.getUsers();
					
					// 新增 执行人
					for (User user2 : listUser2) {
						SpmkExecutor executor = SpmkExecutor.builder()
						.approveExecuteRecordId(aer3.getId())
						.empNum(Integer.parseInt(user2.getId()))
						.executorName(user2.getName())
						.sts(2)
						.build();
						executor.insert();
					}
				}
				break;
			}
		}
	}
	
	/**
	 * 审批持久化
	 * @param listFlowChildren	节点
	 * @param asId				审批汇总Id
	 * @param executorId		执行人记录Id
	 * @param opinion			意见
	 * @param sts				状态 1执行中 2通过 3拒绝
	 */
	public static void approving(List<FlowChildren> listFlowChildren,Integer asId,Integer executeRecordId, Integer executorId, String opinion,Integer sts ) {
		
		boolean hasNextApprover = false;
		
		for (int i = 0,n = listFlowChildren.size(); i < n; i++) {

			// 新增 执行人
			List<User> listUser = listFlowChildren.get(i).getRelation().get(0).getUsers();
			if (EXECUTED.equals(listFlowChildren.get(i).getExecute())) {

			}else if (EXECUTING.equals(listFlowChildren.get(i).getExecute())) {
				
				// 新增 执行人
//				listUser = flowChildren.getRelation().get(0).getUsers();
				for (int i_user = 0, n_user = listUser.size(); i_user < n_user; i_user++) {
					if (EXECUTED.equals(listUser.get(i_user).getExecute())) {
						
					}else if (EXECUTING.equals(listUser.get(i_user).getExecute())) {
						SpmkExecutor.builder()
							.id(executorId)
							.opinion(opinion)
							.empNum(Integer.parseInt(listUser.get(i_user).getId()))
							.executorName(listUser.get(i_user).getName())
							.sts(sts)
							.build()
						.updateById();
						listUser.get(i_user).setExecute(EXECUTED);
						
						// 历史审批人
						SpmkApproveSummary.builder().id(asId).historyApprover(listUser.get(i_user).getName()).build().updateById();
						// 0未执行 1执行中 2同意 3拒绝
						if (sts == 3) {
							// 更新 审批汇总 状态
							SpmkApproveSummary.builder().id(asId).endTime(new Date()).sts(sts).build().updateById();
							return;
						}
					}else if (UNEXECUTED.equals(listUser.get(i_user).getExecute())) {
						SpmkExecutor.builder()
							.approveExecuteRecordId(executeRecordId)
							.empNum(Integer.parseInt(listUser.get(i_user).getId()))
							.executorName(listUser.get(i_user).getName())
							.sts(1)
							.build()
							.insert();
						hasNextApprover = true;
						listUser.get(i_user).setExecute(EXECUTING);
						
						// 当前审批人
						SpmkApproveSummary.builder().id(asId).currentApprover(listUser.get(i_user).getName()).build().updateById();
					}
				}
				
				if (!hasNextApprover) {
					SpmkApproveExecuteRecord aer = SpmkApproveExecuteRecord
							.builder()
							.id(executeRecordId)
							.sts(2)
							.build();
							// 更新 审批执行记录
							aer.updateById();
					listFlowChildren.get(i).setExecute(EXECUTED);
				}
				
			}else if (UNEXECUTED.equals(listFlowChildren.get(i).getExecute())) {
				if (!hasNextApprover) {
					switch (listFlowChildren.get(i).getClassName()) {
					case CREATOR:
						SpmkApproveExecuteRecord aer = SpmkApproveExecuteRecord
								.builder()
								.approveSummaryId(asId)
								.name("发起申请")
								.type(0)
								.sts(2)
								.build();
						// 新增 审批执行记录
						aer.insert();
						
						// 新增 执行人
						User user = listFlowChildren.get(i).getRelation().get(0).getUsers().get(0);
						SpmkExecutor.builder()
						.approveExecuteRecordId(aer.getId())
						.empNum(Integer.parseInt(user.getId()))
						.executorName(user.getName())
						.sts(2)
						.build()
						.insert();
						
						listFlowChildren.get(i).setExecute(EXECUTED);
						break;
					case AUDIT:
						SpmkApproveExecuteRecord aer2 = SpmkApproveExecuteRecord
						.builder()
						.approveSummaryId(asId)
						.name("审批人")
						.type(2)
						.sts(1)
						.build();
						// 新增 审批执行记录
						aer2.insert();

						// 新增 执行人
//						listUser = flowChildren.getRelation().get(0).getUsers();
						for (int i_user2 = 0,n_user2 = listUser.size(); i_user2 < n_user2; i_user2++) {
							User u = listUser.get(i_user2);
							SpmkExecutor executor = SpmkExecutor.builder()
									.approveExecuteRecordId(aer2.getId())
									.empNum(Integer.parseInt(listUser.get(i_user2).getId()))
									.executorName(listUser.get(i_user2).getName())
									.sts(1)
									.build();
									executor.insert();
									
									listUser.get(i_user2).setExecute(EXECUTING);
						}
						
						listFlowChildren.get(i).setExecute(EXECUTING);
						break;
					case COPY:
						SpmkApproveExecuteRecord aer3 = SpmkApproveExecuteRecord
						.builder()
						.approveSummaryId(asId)
						.name("抄送人")
						.type(1)
						.sts(2)
						.build();
						// 新增 审批执行记录
						aer3.insert();

						List<Relation> listRelation = listFlowChildren.get(i).getRelation();
						
						for (Relation relation : listRelation) {
							List<User> listUser2 = relation.getUsers();
							
							// 新增 执行人
							for (User user2 : listUser2) {
								SpmkExecutor executor = SpmkExecutor.builder()
								.approveExecuteRecordId(aer3.getId())
								.empNum(Integer.parseInt(user2.getId()))
								.executorName(user2.getName())
								.sts(2)
								.build();
								executor.insert();
							}
						}
						
						listFlowChildren.get(i).setExecute(EXECUTED);
						break;
					}
				}
			}
		}
		
	}

}