SpmkController.java

package cn.timer.api.controller.spmk;

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

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.github.xiaoymin.knife4j.annotations.ApiOperationSupport;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.lang.Console;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONObject;
import cn.timer.api.aspect.lang.annotation.Log;
import cn.timer.api.aspect.lang.enums.BusinessType;
import cn.timer.api.bean.spmk.SpmkApprovalG;
import cn.timer.api.bean.spmk.SpmkApprovalTemplate;
import cn.timer.api.bean.spmk.SpmkApprovalTemplateG;
import cn.timer.api.bean.spmk.SpmkApproveDetail;
import cn.timer.api.bean.spmk.SpmkApproveExecuteRecord;
import cn.timer.api.bean.spmk.SpmkApproveSummary;
import cn.timer.api.bean.spmk.SpmkCustomApproval;
import cn.timer.api.bean.spmk.SpmkExecutor;
import cn.timer.api.bean.spmk.SpmkIcon;
import cn.timer.api.bean.spmk.SpmkInitiatorConfig;
import cn.timer.api.bean.yggl.YgglMainEmp;
import cn.timer.api.config.annotation.CurrentUser;
import cn.timer.api.config.annotation.UserBean;
import cn.timer.api.config.enuminterface.SpmkEnumInterface;
import cn.timer.api.config.enuminterface.SpmkEnumInterface.ApproveSummarySts;
import cn.timer.api.config.enuminterface.SpmkEnumInterface.ExecutorSts;
import cn.timer.api.config.enums.CommonEnum;
import cn.timer.api.config.exception.CustomException;
import cn.timer.api.config.validation.Insert;
import cn.timer.api.config.validation.Ranks;
import cn.timer.api.config.validation.Update;
import cn.timer.api.config.validation.ValidList;
import cn.timer.api.controller.spmk.service.SpmkService;
import cn.timer.api.controller.zzgl.service.ZzglBmgwMService;
import cn.timer.api.dao.spmk.SpmkApprovalGMapper;
import cn.timer.api.dao.spmk.SpmkApprovalTemplateGMapper;
import cn.timer.api.dao.spmk.SpmkApprovalTemplateMapper;
import cn.timer.api.dao.spmk.SpmkApproveDetailMapper;
import cn.timer.api.dao.spmk.SpmkApproveExecuteRecordMapper;
import cn.timer.api.dao.spmk.SpmkApproveSummaryMapper;
import cn.timer.api.dao.spmk.SpmkCustomApprovalMapper;
import cn.timer.api.dao.spmk.SpmkExecutorMapper;
import cn.timer.api.dao.spmk.SpmkInitiatorConfigMapper;
import cn.timer.api.dto.spmk.ApprovingDto;
import cn.timer.api.dto.spmk.FlowChildren;
import cn.timer.api.dto.spmk.FromData;
import cn.timer.api.dto.spmk.MySummaryQueryDto;
import cn.timer.api.dto.spmk.Relation;
import cn.timer.api.dto.spmk.Router;
import cn.timer.api.dto.spmk.SpmkApprovalTemplateDto;
import cn.timer.api.dto.spmk.SpmkApproveDetailDto;
import cn.timer.api.dto.spmk.SpmkApproveSummaryDto;
import cn.timer.api.dto.spmk.SpmkCustomApprovalDto;
import cn.timer.api.dto.spmk.SummaryQueryDto;
import cn.timer.api.dto.spmk.User;
import cn.timer.api.utils.Result;
import cn.timer.api.utils.ResultUtil;
import cn.timer.api.utils.router.RouterUtils;
import cn.timer.api.utils.router.business.SpmkAssoBusiness;
import cn.timer.api.utils.router.business.SpmkAssoBusinessFactory;
import cn.timer.api.utils.router.enums.ApproveEnum;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;

@Api(tags = "3.0审批模块")
@RestController
@Transactional
@RequestMapping(value = "/spmk",  
produces = { "application/json","multipart/form-data" })
public class SpmkController {

	@Autowired
	private SpmkService spmkService;
	@Autowired
	private ZzglBmgwMService zzglBmgwMService;
	
	@Autowired
    private SpmkApprovalTemplateGMapper spmkApprovalTemplateGMapper;
	@Autowired
    private SpmkApprovalTemplateMapper spmkApprovalTemplateMapper;
	@Autowired
    private SpmkApprovalGMapper spmkApprovalGMapper;
	@Autowired
    private SpmkCustomApprovalMapper spmkCustomApprovalMapper;
	@Autowired
	private SpmkApproveSummaryMapper spmkApproveSummaryMapper;
	@Autowired
	private SpmkApproveDetailMapper spmkApproveDetailMapper;
	@Autowired
	private SpmkApproveExecuteRecordMapper spmkApproveExecuteRecordMapper;
	@Autowired
	private SpmkExecutorMapper spmkExecutorMapper;
	@Autowired
	private SpmkInitiatorConfigMapper spmkInitiatorConfigMapper;
	
	private boolean ISFIRST = true; // 第一次启动审批流程
	
	//TODO 审批模板组
	/**
	 * 新增或编辑-审批模板组
	 */
	@PostMapping(value = "/save_approval_template_g")
	@ApiOperation(value = "1.新增或编辑-审批模板组", httpMethod = "POST", notes = "新增或编辑-审批模板组")
	@ApiOperationSupport(order = 1)
	public Result<Object> saveAtg(@Validated({Insert.class,Update.class}) @RequestBody SpmkApprovalTemplateG spmkApprovalTemplateG){
		
		if (spmkApprovalTemplateG.selectCount(new QueryWrapper<SpmkApprovalTemplateG>().lambda()
				.ne(spmkApprovalTemplateG.getId() != null,SpmkApprovalTemplateG::getId, spmkApprovalTemplateG.getId())
				.eq(SpmkApprovalTemplateG::getName, spmkApprovalTemplateG.getName())) > 0) {
			return ResultUtil.error("审批模板组名重复!");
		}
		
        return spmkApprovalTemplateG.insertOrUpdate() ? 
        		ResultUtil.data(spmkApprovalTemplateG) : ResultUtil.error();

	}
	
	/**
	 * 删除-审批模板组
	 */
	@DeleteMapping(value = "/delete_approval_template_g/{id}")
	@ApiOperation(value = "2.删除-审批模板组", httpMethod = "DELETE", notes = "删除-审批模板组")
	@ApiOperationSupport(order = 2)
	public Result<Object> deleteAtgById(@PathVariable int id){
		
		if (spmkApprovalTemplateMapper.selectCount(new QueryWrapper<SpmkApprovalTemplate>().lambda().eq(SpmkApprovalTemplate::getApprovalTemplateGId, id)) > 0 ) 
			return ResultUtil.error("审批模板组存在 模板，不可直接删除!");
		
		
        return SpmkApprovalTemplateG.builder().id(id).build().deleteById() ? 
        		ResultUtil.success() : ResultUtil.error("没有找到该对象");
		
	}
	
	/**
	 * 查询列表-审批模板组
	 */
	@GetMapping(value = "/list_approval_template_g")
	@ApiOperation(value = "3.查询列表-审批模板组", httpMethod = "GET", notes = "查询列表-审批模板组")
	@ApiOperationSupport(order = 3)
	public Result<Object> selectListAtg(){
        
        return ResultUtil.data(spmkApprovalTemplateGMapper.selectListAtInAtg());
	}
	
	/**
	 * 排序-审批模板组
	 */
	@PutMapping(value = "/update_approval_template_g")
	@ApiOperation(value = "4.排序-审批模板组", httpMethod = "PUT", notes = "排序-审批模板组")
	@ApiOperationSupport(order = 4)
	public Result<Object> ranksAtg(@Validated(Ranks.class) @RequestBody ValidList<SpmkApprovalTemplateG> list){
		
		if (list == null || (list != null && list.size() <= 0)) {
			return ResultUtil.success();
		}
        return spmkApprovalTemplateGMapper.updateListRandsById(list) ? ResultUtil.success() : ResultUtil.error();
	}
	
	//TODO 审批模板
	/**
	 * 新增或编辑-审批模板
	 */
	@PostMapping(value = "/save_approval_template")
	@ApiOperation(value = "5.新增或编辑-审批模板", httpMethod = "POST", notes = "新增或编辑-审批模板")
	@ApiOperationSupport(order = 5)
	public Result<Object> saveAt(@Validated @RequestBody SpmkApprovalTemplateDto spmkApprovalTemplateDto){
		
		Integer approvalTemplateGId = spmkApprovalTemplateDto.getApprovalTemplateGId();
		if (ObjectUtil.isNull(approvalTemplateGId)) 
			return ResultUtil.error("审批模板ID不为空");

		SpmkApprovalTemplate at = SpmkApprovalTemplate.builder().build();

		// 克隆 SpmkApprovalTemplateDto对象 到 SpmkApprovalTemplate对象,排除属性froms,router
		BeanUtil.copyProperties(spmkApprovalTemplateDto, at , "froms","router");
		// 序列化 后 写入 SpmkApprovalTemplate对象
		at.setFroms(ObjectUtil.serialize((List<JSONObject>)spmkApprovalTemplateDto.getFroms()));
		at.setRouter(ObjectUtil.serialize(spmkApprovalTemplateDto.getRouter()));
		
		if (at.selectCount(new QueryWrapper<SpmkApprovalTemplate>().lambda()
				.ne(at.getId() != null, SpmkApprovalTemplate::getId, at.getId())
				.eq(SpmkApprovalTemplate::getName, at.getName())) > 0) {
			return ResultUtil.error("审批模板名重复!");
		}
		
		if (!at.insertOrUpdate()) 
			return ResultUtil.error("数据库操作失败");
		
		// 清空前端不需要的字段再返回,节省流量
		at.setFroms(null);
		at.setRouter(null);
		return  ResultUtil.data(at);
		
	}
	
	/**
	 * 删除-审批模板
	 */
	@DeleteMapping(value = "/delete_approval_template/{id}")
	@ApiOperation(value = "6.删除-审批模板", httpMethod = "DELETE", notes = "删除-审批模板")
	@ApiOperationSupport(order = 6)
	public Result<Object> deleteAtById(@PathVariable int id){
		
        return SpmkApprovalTemplate.builder().id(id).build().deleteById() ? ResultUtil.success() : ResultUtil.error("没有找到该对象");
		
	}

	/**
	 * id查询-审批模板
	 */
	@GetMapping(value = "/select_approval_template/{id}")
	@ApiOperation(value = "7.id查询-审批模板", httpMethod = "GET", notes = "id查询-审批模板")
	@ApiOperationSupport(order = 7)
	public Result<Object> selectAtById(@PathVariable int id){
		SpmkApprovalTemplate at = SpmkApprovalTemplate.builder().id(id).build().selectById();
		
		SpmkApprovalTemplateDto atd = SpmkApprovalTemplateDto.builder().build();
		BeanUtil.copyProperties(at, atd,"froms","router");
		atd.setFroms(ObjectUtil.deserialize(at.getFroms()));
		atd.setRouter(ObjectUtil.deserialize(at.getRouter()));
        return ResultUtil.data(atd);
        
	}
	
	/**
	 * 排序-审批模板
	 */
	@PutMapping(value = "/update_approval_template")
	@ApiOperation(value = "8.排序-审批模板", httpMethod = "PUT", notes = "查询列表-审批模板组")
	@ApiOperationSupport(order = 8)
	public Result<Object> ranksAt(@Validated({Ranks.class})@RequestBody ValidList<SpmkApprovalTemplate> list){

		if (list == null || (list != null && list.size() <= 0)) {
			return ResultUtil.success();
		}
		
        return spmkApprovalTemplateMapper.updateListRandsById(list) ? ResultUtil.success() : ResultUtil.error();
	
	}
	
	
	
	//TODO 审批组
	/**
	 * 新增或编辑-审批组
	 */
	@PostMapping(value = "/save_approval_g")
	@ApiOperation(value = "9.新增或编辑-审批组", httpMethod = "POST", notes = "新增或编辑-审批组")
	@ApiOperationSupport(order = 9)
	public Result<Object> saveAg(@CurrentUser UserBean userBean, @Validated({Insert.class,Update.class}) @RequestBody SpmkApprovalG spmkApprovalG){
		
		if (spmkApprovalG.selectCount(new QueryWrapper<SpmkApprovalG>().lambda()
				.ne(spmkApprovalG.getId() != null, SpmkApprovalG::getId, spmkApprovalG.getId())
				.eq(SpmkApprovalG::getName, spmkApprovalG.getName())
				.eq(SpmkApprovalG::getOrgCode, userBean.getOrgCode())) > 0) {
			return ResultUtil.error("审批组名重复!");
		}
		
		spmkApprovalG.setOrgCode(userBean.getOrgCode());
		return spmkApprovalG.insertOrUpdate() ? ResultUtil.data(spmkApprovalG) : ResultUtil.error();
		
	}
	
	/**
	 * 删除-审批组
	 */
	@DeleteMapping(value = "/delete_approval_g/{id}")
	@ApiOperation(value = "10.删除-审批组", httpMethod = "DELETE", notes = "删除-审批组")
	@ApiOperationSupport(order = 10)
	public Result<Object> deleteAgById(@PathVariable int id){
		
		if (spmkCustomApprovalMapper.selectCount(new QueryWrapper<SpmkCustomApproval>().lambda().eq(SpmkCustomApproval::getApprovalGId, id)) > 0 ) 
			return ResultUtil.error("审批组存在 自定义审批,不可直接删除!");
		
        return SpmkApprovalG.builder().id(id).build().deleteById() ? ResultUtil.success() : ResultUtil.error("没有找到该对象");
		
	}
	
	/**
	 * 查询列表-审批组-审批管理
	 */
	@GetMapping(value = "/all_approval_g")
	@ApiOperation(value = "11.查询列表-审批组-审批管理", httpMethod = "GET", notes = "查询列表-审批组-审批管理")
	@ApiOperationSupport(order = 11)
	public Result<Object> selectListAgByAdmin(@CurrentUser UserBean userBean){
		
		List<Integer> depts = zzglBmgwMService.empNumupGetDepts(userBean.getOrgCode(), userBean.getEmpNum());
		System.out.println(depts);
        return ResultUtil.data(spmkApprovalGMapper.selectListAgInCaByAdmin(userBean.getOrgCode(), userBean.getEmpNum(), depts));
	
	}
	
	/**
	 * 查询列表-审批组-个人审批
	 */
	@GetMapping(value = "/list_approval_g")
	@ApiOperation(value = "11.查询列表-审批组-个人审批", httpMethod = "GET", notes = "查询列表-审批组-个人审批")
	@ApiOperationSupport(order = 11)
	public Result<Object> selectListAg(@CurrentUser UserBean userBean){
		
		return ResultUtil.data(spmkService.selectListAg(userBean));
	}
	
	/**
	 * 排序-审批组
	 */
	@PutMapping(value = "/update_approval_g")
	@ApiOperation(value = "12.排序-审批组", httpMethod = "PUT", notes = "排序-审批组")
	@ApiOperationSupport(order = 12)
	public Result<Object> ranksAg(@Validated({Ranks.class}) @RequestBody ValidList<SpmkApprovalG> list){
		
		if (list == null || list.size() <= 0) {
			return ResultUtil.success();
		}
		
        return spmkApprovalGMapper.updateListRandsById(list) ? ResultUtil.success() : ResultUtil.error();
	}
	
	//TODO 自定义审批
	
	/**
	 * 新增或编辑-自定义审批
	 */
	@PostMapping(value = "/save_custom_approval")
	@ApiOperation(value = "13.新增或编辑-自定义审批", httpMethod = "POST", notes = "新增或编辑-自定义审批")
	@ApiOperationSupport(order = 13)
	@Transactional(rollbackFor = Exception.class)
	public Result<Object> saveCa(@CurrentUser UserBean userBean,@Validated @RequestBody SpmkCustomApprovalDto spmkCustomApprovalDto) throws Exception{

		SpmkCustomApproval ca = SpmkCustomApproval.builder().build();

		BeanUtil.copyProperties(spmkCustomApprovalDto, ca , "froms","router","initiatorConfigs");
		
		if (ca.selectCount(new QueryWrapper<SpmkCustomApproval>().lambda()
				.ne(ca.getId() != null, SpmkCustomApproval::getId, ca.getId())
				.eq(SpmkCustomApproval::getName, ca.getName())
				.eq(SpmkCustomApproval::getOrgCode, userBean.getOrgCode())) > 0) {
			return ResultUtil.error("自定义审批名重复!");
		}
		
		ca.setFroms(ObjectUtil.serialize(spmkCustomApprovalDto.getFroms()));
		ca.setRouter(ObjectUtil.serialize(spmkCustomApprovalDto.getRouter()));
		
		//1.新增 SpmkCustomApproval-自定义审批
		if (!ca.insertOrUpdate())
			return ResultUtil.error("新增自定义审批 失败!");
		
		
		Integer id = ca.getId();
		// 2.删除	历史的  SpmkInitiatorConfig-审批发起人配置,
		SpmkInitiatorConfig.builder().build().delete(new QueryWrapper<SpmkInitiatorConfig>().lambda().eq(SpmkInitiatorConfig::getCustomApprovalId, id));
		Console.log("自定义审批id: " + id);
		List<SpmkInitiatorConfig> listIc = spmkCustomApprovalDto.getInitiatorConfigs();

		if (listIc != null && listIc.size() > 0) {
			for (int i = 0, n = listIc.size(); i < n; i++) {
				listIc.get(i).setCustomApprovalId(id);
			}
			// 3.新增	最新的 SpmkInitiatorConfig-审批发起人配置,
			if (!spmkInitiatorConfigMapper.insertList(listIc)) {
				// 手动抛出异常，事务回滚
				throw new Exception();
			}
			
		}
		
		//  
		/**
		 * 注意: 为保证该api的原子性 要加 事务处理 回滚(方法注解-@Transactional(rollbackFor = Exception.class))
		 * 1.新增 SpmkCustomApproval-自定义审批
		 * 2.删除	历史的  SpmkInitiatorConfig-审批发起人配置,
		 * 3.新增	最新的 SpmkInitiatorConfig-审批发起人配置,
		 */

		// 清空前端不需要的字段再返回,节省流量
		ca.setFroms(null);
		ca.setRouter(null);
		return ResultUtil.data(ca);
		
	}
	
	/**
	 * 删除-自定义审批
	 * @throws Exception 
	 */
	@DeleteMapping(value = "/delete_custom_approval/{id}")
	@ApiOperation(value = "14.删除-自定义审批", httpMethod = "DELETE", notes = "删除-自定义审批")
	@Transactional(rollbackFor = Exception.class)
	@ApiOperationSupport(order = 14)
	public Result<Object> deleteCaById(@PathVariable int id) throws Exception{
		SpmkInitiatorConfig.builder().build().delete(new QueryWrapper<SpmkInitiatorConfig>().lambda().eq(SpmkInitiatorConfig::getCustomApprovalId, id));
        
		if (!SpmkCustomApproval.builder().id(id).build().deleteById()) {
			throw new Exception();
		}
		
		return  ResultUtil.success();
	}

	/**
	 * id查询-自定义审批
	 */
	@GetMapping(value = "/select_custom_approval/{id}")
	@ApiOperation(value = "15.id查询-自定义审批", httpMethod = "GET", notes = "id查询-自定义审批")
	@ApiOperationSupport(order = 15)
	public Result<Object> selectCaById(@PathVariable int id){
		SpmkCustomApproval ca = SpmkCustomApproval.builder().id(id).build().selectById();
		List<SpmkInitiatorConfig> listIc = SpmkInitiatorConfig.builder().build().selectList(new QueryWrapper<SpmkInitiatorConfig>().lambda().eq(SpmkInitiatorConfig::getCustomApprovalId, id));
		SpmkCustomApprovalDto caD = SpmkCustomApprovalDto.builder()
				.froms(ObjectUtil.deserialize(ca.getFroms()))
				.router(ObjectUtil.deserialize(ca.getRouter()))
				.build();
		BeanUtil.copyProperties(ca, caD,"froms","router");
		caD.setInitiatorConfigs(listIc);
        return ResultUtil.data(caD);
	}
	
	/**
	 * 排序-自定义审批
	 */
	@PutMapping(value = "/update_custom_approval")
	@ApiOperation(value = "16.排序-自定义审批", httpMethod = "PUT", notes = "排序-自定义审批")
	@ApiOperationSupport(order = 16)
	public Result<Object> ranksCa(@Validated({Ranks.class}) @RequestBody ValidList<SpmkCustomApproval> list){
		
		if (list == null || (list != null && list.size() <= 0)) {
			return ResultUtil.success();
		}
		
        return spmkCustomApprovalMapper.updateListRandsById(list) ? ResultUtil.success() : ResultUtil.error();
	}
	
	// TODO 审批汇总(发起审批)
	/**
	 * 发起审批
	 * @throws Exception 
	 */
	@PostMapping(value = "/start_approval")
	@ApiOperation(value = "17.发起审批", httpMethod = "POST", notes = "发起审批")
	@ApiOperationSupport(order = 17)
	@Transactional(rollbackFor = Exception.class)
	@Log(title = "审批-发起审批", businessType = BusinessType.INSERT)
	public Result<Object> saveA(@CurrentUser UserBean userBean,@Validated @RequestBody SpmkApproveSummaryDto spmkApproveSummaryDto) throws Exception{
			YgglMainEmp ygglMainEmp = YgglMainEmp.builder().build().selectOne(new QueryWrapper<YgglMainEmp>()
					.lambda()
					.select(YgglMainEmp::getHeadUrl,YgglMainEmp::getName)
					.eq(YgglMainEmp::getEmpNum, userBean.getEmpNum()));
			
			if (ygglMainEmp == null) 
				return ResultUtil.error("发起人不存在!");
			
//			List<SpmkApprovalG> saG = spmkService.selectListAg(userBean);
			
			Router router = spmkApproveSummaryDto.getRouter();
			List<Router> routers = router.getChildren();
			if (routers != null && routers.size() > 0) {
				List<Relation> relations = routers.get(0).getRelation();
				if (relations == null || relations.size() < 1) {
					return ResultUtil.error("无法发起，请完善审批流程");
				}
				List<User> users = relations.get(0).getUsers();
				if (users == null || users.size() < 1) {
					return ResultUtil.error("无法发起，请完善审批流程");
				}
				
			}else {
				return ResultUtil.error("无法发起，请完善审批流程");
			}
			
			List<Router> listRouter = new ArrayList<Router>();
			listRouter.add(router);
			
			JSONObject jSONObject = spmkApproveSummaryDto.getRequestData()
					.set("orgCode", FromData.builder().value(String.valueOf(userBean.getOrgCode())).build())
					.set("initiator", FromData.builder().value(ygglMainEmp.getName()).build())
					.set("headUrl", FromData.builder().value(ygglMainEmp.getHeadUrl()).build())
					.set("id", FromData.builder().value(StrUtil.toString(userBean.getEmpNum())).build());
			RouterUtils.NextNode(listRouter, jSONObject, ISFIRST);
			List<FlowChildren> listFlowChildren = new ArrayList<FlowChildren>();
			RouterUtils.getIsFlowChildren(listRouter,listFlowChildren);
			
			// 当前审批人
			String currentApprover = jSONObject.getStr("current_approver");
			// 封装 审批汇总
			SpmkApproveSummary as = SpmkApproveSummary
					.builder()
					.orgCode(userBean.getOrgCode())
					.empNum(userBean.getEmpNum())
					.title(spmkApproveSummaryDto.getTitle())
					.initiator(spmkApproveSummaryDto.getInitiator())
					.approveName(spmkApproveSummaryDto.getApproveName())
					.assoType(spmkApproveSummaryDto.getAssoType())
					.sts(ApproveSummarySts.IN.ordinal())
					.currentApprover(currentApprover).build();
			
			if (!as.insert()) {
				throw new CustomException("审批汇总-新增异常");
			}
			
			// 插入记录
			RouterUtils.insertogExecuteRecord(listFlowChildren, as.getId());
			
			// 封装 审批详情
			SpmkApproveDetail ad = SpmkApproveDetail.builder().build();
			ad.setApproveSummaryId(as.getId());
			ad.setName(spmkApproveSummaryDto.getTitle());
			ad.setRequestData(ObjectUtil.serialize(spmkApproveSummaryDto.getRequestData()));
			ad.setFroms(ObjectUtil.serialize((List<JSONObject>)spmkApproveSummaryDto.getFroms()));
			ad.setRouter(ObjectUtil.serialize(listRouter.get(0)));
			ad.setFlowChildren(ObjectUtil.serialize(listFlowChildren));
			
			if (!ad.insert()) 
				throw new CustomException("审批详情-新增异常");
			
			return ResultUtil.success();
			
	}
	
	//TODO 审批汇总
	/**
	 * 审批汇总
	 * @param summaryQueryDto
	 * @return
	 * @throws  
	 */
	@PostMapping(value = "/select_approve_summary")
	@ApiOperation(value = "18.审批汇总", httpMethod = "POST", notes = "审批汇总")
	@ApiOperationSupport(order = 18)
	@Log(title = "审批-审批汇总", businessType = BusinessType.OTHER)
	public Result<Object> selectAs(@CurrentUser UserBean userBean, @RequestBody SummaryQueryDto summaryQueryDto) {

			IPage<SpmkApproveSummary> page = new Page<SpmkApproveSummary>(
				summaryQueryDto.getCurrentPage() == null ? 1 : summaryQueryDto.getCurrentPage(),
				summaryQueryDto.getTotalPage() == null ? 10 : summaryQueryDto.getTotalPage());
			summaryQueryDto.setOrgCode(userBean.getOrgCode());
			
			Integer deptId = summaryQueryDto.getDeptId();
			List<YgglMainEmp> listYgglMainEmp = zzglBmgwMService.selectOtherlistent(userBean.getOrgCode(), deptId);

			if (deptId != null && (listYgglMainEmp == null || listYgglMainEmp.size() == 0)) {
				return ResultUtil.data(new ArrayList<SpmkApproveSummary>());
			}
			
			List<Integer> empNums = new ArrayList<Integer>();
			for (YgglMainEmp ygglMainEmp : listYgglMainEmp) {
				empNums.add(ygglMainEmp.getEmpNum());
			}
			summaryQueryDto.setEmpNums(empNums);

			// 缺-部门id 搜索
			IPage<SpmkApproveSummary> pageAs = spmkApproveSummaryMapper.selectPageByQuery(page, summaryQueryDto);
			
			List<SpmkApproveSummary> listAs = pageAs.getRecords();
			
			return ResultUtil.data(pageAs, listAs);
	}
	
	//TODO 审批详情
	/**
	 * 审批详情
	 */
	@GetMapping(value = "/select_approve_detail/{id}")
	@ApiOperation(value = "19.审批详情", httpMethod = "GET", notes = "审批详情")
	@ApiOperationSupport(order = 19)
	@Log(title = "审批-审批详情", businessType = BusinessType.OTHER)
	public Result<Object> selectAd(@PathVariable(required = true) Integer id) {
		
		SpmkApproveDetailDto adD = spmkService.selectApproveDetailByAsId(id);
		
		return ResultUtil.data(adD);
	}
	
	//TODO 审批人审批
	/**
	 * 审批人审批
	 */
	@PostMapping(value = "/approving")
	@ApiOperation(value = "20.审批人审批", httpMethod = "POST", notes = "审批人审批")
	@Transactional(rollbackFor = Exception.class)
	@ApiOperationSupport(order = 20)
	@Log(title = "审批-审批流程", businessType = BusinessType.UPDATE)
//	@BindingResultCtrol(title = "审批人审批")
	public Result<Object> approving(@CurrentUser UserBean userBean,@Validated @RequestBody ApprovingDto approvingDto) throws Exception {
		
		SpmkApproveDetail ad = SpmkApproveDetail.builder().build().selectOne(new QueryWrapper<SpmkApproveDetail>()
				.lambda()
				.select(SpmkApproveDetail::getId,
						SpmkApproveDetail::getRequestData,
						SpmkApproveDetail::getFlowChildren)
				.eq(SpmkApproveDetail::getApproveSummaryId, approvingDto.getAsId()));
		
		// 查询 SpmkApproveSummary 状态
		SpmkApproveSummary aSummary = spmkApproveSummaryMapper.selectOne(new QueryWrapper<SpmkApproveSummary>().lambda()
				.select(SpmkApproveSummary::getSts)
				.eq(SpmkApproveSummary::getId, approvingDto.getAsId()));
		
		if (aSummary.getSts() > SpmkEnumInterface.ApproveSummarySts.IN.ordinal()) {
			return ResultUtil.error("该审批已结束!");
		}
		
		// 查询该 审批的状态 是否为 1 审批中 
		Integer count = SpmkExecutor.builder().build().selectCount(new QueryWrapper<SpmkExecutor>().lambda()
				.eq(SpmkExecutor::getId, approvingDto.getExecutorId())
				.eq(SpmkExecutor::getSts, ExecutorSts.IN_EXECUTION.ordinal()));
		
		if (count == 0) {
			return ResultUtil.error("您已审批过!");
		}
		
		if ( spmkExecutorMapper.selectCount(new QueryWrapper<SpmkExecutor>().lambda()
				.eq(SpmkExecutor::getId, approvingDto.getExecutorId())
				.eq(SpmkExecutor::getEmpNum, userBean.getEmpNum())
				.eq(SpmkExecutor::getSts, SpmkEnumInterface.ExecutorSts.IN_EXECUTION.ordinal())) == 0) {
			return ResultUtil.error("非当前审批人,无法审批!");
		}
		
		if (aSummary.getSts() == 0) {
			List<FlowChildren> listFlowChildren = ObjectUtil.deserialize(ad.getFlowChildren());
			// 审批逻辑
			RouterUtils.approving(
					listFlowChildren, 
					approvingDto.getAsId(), 
					approvingDto.getExecuteRecordId(), 
					approvingDto.getExecutorId(), 
					approvingDto.getOpinion(),
					approvingDto.getSts(),
					approvingDto.getUser()
					);
			
			System.out.println(listFlowChildren);
			// 更新 flowChildren
			SpmkApproveDetail.builder().id(ad.getId()).flowChildren(ObjectUtil.serialize(listFlowChildren)).build().updateById();
			FlowChildren fc = CollUtil.getLast(listFlowChildren);
			if (fc.getExecute() == "2") {
				// 查询 SpmkApproveSummary 状态
				aSummary = spmkApproveSummaryMapper.selectOne(new QueryWrapper<SpmkApproveSummary>().lambda()
						.select(SpmkApproveSummary::getSts,SpmkApproveSummary::getAssoType)
						.eq(SpmkApproveSummary::getId, approvingDto.getAsId()));
				
				if (aSummary.getSts() != SpmkEnumInterface.ApproveSummarySts.REFUSE.ordinal()) {
					SpmkApproveSummary.builder().id(approvingDto.getAsId()).currentApprover(CommonEnum.NULL_STR.getDesc()).endTime(new Date()).sts(ApproveSummarySts.FINISH.ordinal()).build().updateById();
						
					JSONObject jSONObject = ObjectUtil.deserialize(ad.getRequestData());
					jSONObject.set("approveId", approvingDto.getAsId());
					//审批完成后 业务
					SpmkAssoBusiness sab = SpmkAssoBusinessFactory.createSpmkAssoType(ApproveEnum.getEnums(aSummary.getAssoType()));
					if (sab != null)
						sab.handleApprove(jSONObject);
				}
			}
			
		}else {
			return ResultUtil.error("该审批已结束!");
		}
		return ResultUtil.success();
	}
	
	//TODO 我发起的/我审批的/抄送我的
	/**
	 * 查询列表-我发起的/我审批的/抄送我的-分页
	 */
	@PostMapping(value = "/select_my_approve")
	@ApiOperation(value = "21.查询列表-我发起的/我审批的/抄送我的-分页", httpMethod = "POST", notes = "查询列表-我审批的-关键字、审批状态、发起时间-分页")
	@ApiOperationSupport(order = 21)
	@Log(title = "审批-我发起的/我审批的/抄送我的", businessType = BusinessType.OTHER)
	public Result<Object> selectMyAs(@CurrentUser UserBean userBean, @Validated @RequestBody MySummaryQueryDto mySummaryQueryDto) throws MethodArgumentNotValidException{
			IPage<SpmkApproveSummary> page = new Page<SpmkApproveSummary>(
				mySummaryQueryDto.getCurrentPage() == null ? 1 : mySummaryQueryDto.getCurrentPage(),
				mySummaryQueryDto.getTotalPage() == null ? 10 : mySummaryQueryDto.getTotalPage());
			mySummaryQueryDto.setOrgCode(userBean.getOrgCode());
			mySummaryQueryDto.setEmpNum(userBean.getEmpNum());
			// 缺-部门id 搜索
			IPage<SpmkApproveSummary> pageAs = spmkApproveSummaryMapper.selectPageByQueryForEmpNum(page, mySummaryQueryDto);
			
			List<SpmkApproveSummary> listAs = pageAs.getRecords();
			return ResultUtil.data(pageAs, listAs);
	}
	
	//TODO 撤销审批
	/**
	 * 撤销审批
	 */
	@PutMapping(value = "/revoke_approval/{id}")
	@ApiOperation(value = "22.撤销审批", httpMethod = "PUT", notes = "撤销审批")
	@Transactional(rollbackFor = Exception.class)
	@ApiOperationSupport(order = 22)
	@Log(title = "审批-撤销审批", businessType = BusinessType.UPDATE)
	public Result<Object> revokeApproval(@PathVariable Integer id) throws Exception {
		
		SpmkApproveSummary as = spmkApproveSummaryMapper.selectOne(new QueryWrapper<SpmkApproveSummary>()
				.lambda()
				.select(SpmkApproveSummary::getSts)
				.eq(SpmkApproveSummary::getId, id));
		
		return as != null && as.getSts() != ApproveSummarySts.FINISH.ordinal() ? (SpmkApproveSummary.builder().id(id).endTime(new Date()).sts(ApproveSummarySts.UNDONE.ordinal()).build().updateById() ? 
				ResultUtil.success() : ResultUtil.error("撤销异常")) : ResultUtil.error("审批已结束，无法撤销!");
	}
	
	/**
	 * 删除-审批(发起的审批)-根据审批汇总id
	 */
	@DeleteMapping(value = "/delete_approval/{id}")
	@ApiOperation(value = "23.删除-审批(发起的审批)-根据审批汇总id", httpMethod = "DELETE", notes = "删除-审批(发起的审批)-根据审批汇总id")
	@ApiOperationSupport(order = 23)
	@Log(title = "审批-删除审批", businessType = BusinessType.DELETE)
	public Result<Object> deleteApprovalData(@PathVariable Integer id){
		List<SpmkApproveExecuteRecord> listAer = spmkApproveExecuteRecordMapper.selectList(new QueryWrapper<SpmkApproveExecuteRecord>()
				.lambda()
				.select(SpmkApproveExecuteRecord::getId)
				.eq(SpmkApproveExecuteRecord::getApproveSummaryId, id));
		if (listAer != null && listAer.size() > 0) {
			for (SpmkApproveExecuteRecord aer : listAer) {
				spmkExecutorMapper.delete(new QueryWrapper<SpmkExecutor>().lambda().eq(SpmkExecutor::getApproveExecuteRecordId, aer.getId()));
			}
		}
		
		spmkApproveExecuteRecordMapper.delete(new QueryWrapper<SpmkApproveExecuteRecord>().lambda().eq(SpmkApproveExecuteRecord::getApproveSummaryId, id));
		
		spmkApproveDetailMapper.delete(new QueryWrapper<SpmkApproveDetail>().lambda().eq(SpmkApproveDetail::getApproveSummaryId, id));
		
		spmkApproveSummaryMapper.delete(new QueryWrapper<SpmkApproveSummary>().lambda().eq(SpmkApproveSummary::getId, id));
		
		return ResultUtil.success();
	}
	
	/**
	 * 删除-审批组、自定义审批、审批汇总、审批详情、审批执行记录、审批执行人记录 所有数据
	 */
	@DeleteMapping(value = "/delete_approval_data")
	@ApiOperation(value = "90.(开发使用)删除-审批数据", httpMethod = "DELETE", notes = "审批组、自定义审批、审批汇总、审批详情、审批执行记录、审批执行人记录 所有数据")
	@ApiOperationSupport(order = 90)
	public Result<Object> deleteApprovalData(@CurrentUser UserBean userBean){
		spmkApprovalGMapper.delete(null);
		spmkCustomApprovalMapper.delete(null);
		spmkApproveSummaryMapper.delete(null);
		spmkApproveDetailMapper.delete(null);
		spmkApproveExecuteRecordMapper.delete(null);
		spmkExecutorMapper.delete(null);
		System.out.println("删除-审批组、自定义审批、审批汇总、审批详情、审批执行记录、审批执行人记录 所有数据 完成！");
		return ResultUtil.success();
	}
	
	//TODO 审批图标列表
	@GetMapping(value = "/icon")
	@ApiOperation(value = "99.图标列表", httpMethod = "GET", notes = "接口发布说明")
	@ApiOperationSupport(order = 99)
	public Result<List<SpmkIcon>> selectListIcon(@CurrentUser UserBean userBean){
		
		List<SpmkIcon> spmkIcons = SpmkIcon.builder().build().selectAll();
		
		return ResultUtil.data(spmkIcons,"获取图标列表成功");
	}
	
	//TODO 测试-生成 审批组 和 自定义审批
	@GetMapping(value = "/test")
	@ApiOperation(value = "98.测试-生成 审批组 和 自定义审批", httpMethod = "GET", notes = "测试-生成 审批组 和 自定义审批")
	@ApiOperationSupport(order = 98)
	public Result<List<SpmkIcon>> createCustomApproval(@RequestParam Integer orgCode){
		
		spmkService.createCustomApproval(orgCode);
		
		List<SpmkIcon> spmkIcons = SpmkIcon.builder().build().selectAll();
		
		return ResultUtil.data(spmkIcons,"生成 审批组 和 自定义审批成功");
	}
}