SpmkServiceImpl.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.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.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
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.ArrayUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONObject;
import cn.timer.api.bean.dzht.DzhtAssoHtmb;
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.spmk.SpmkJqgz;
import cn.timer.api.bean.spmk.SpmkLcjd;
import cn.timer.api.bean.spmk.SpmkLcjdEmpAsso;
import cn.timer.api.bean.spmk.SpmkMb;
import cn.timer.api.bean.spmk.SpmkSpcz;
import cn.timer.api.bean.spmk.SpmkSpgl;
import cn.timer.api.bean.spmk.SpmkSpz;
import cn.timer.api.bean.spmk.SpmkSxpz;
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.enums.CommonEnum;
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.dao.spmk.SpmkSpglMapper;
import cn.timer.api.dao.spmk.SpmkSpzMapper;
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.Router;
import cn.timer.api.dto.spmk.Spmk;
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.SpmkMbKjDto;
import cn.timer.api.dto.spmk.SpmkSpglDto;
import cn.timer.api.dto.spmk.SpmkSpglMoveDto;
import cn.timer.api.dto.spmk.SpmkSpglSortDto;
import cn.timer.api.dto.spmk.SpmkSpzDto;
import cn.timer.api.dto.spmk.SpmkSpzSortDto;
import cn.timer.api.dto.spmk.SpmkSpzSpglDto;
import cn.timer.api.dto.spmk.SummaryQueryDto;
import cn.timer.api.utils.Result;
import cn.timer.api.utils.ResultUtil;
import cn.timer.api.utils.RouterUtils;
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 SpmkServiceImpl {

	@Autowired
	private SpmkSpglMapper spmkSpglMapper;
	@Autowired
	private SpmkSpzMapper spmkSpzMapper;

	/**
	 * 审批组-列表
	 */
	@GetMapping(value = "/spzs")
	@ApiOperation(value = "审批组-列表",httpMethod = "GET")
	public Result<List<SpmkSpzSpglDto>> selectListspz(@CurrentUser UserBean userBean) {
		Integer orgCode = userBean.getOrgCode();

		List<SpmkSpzSpglDto> spmkSpzSpglDtos = spmkSpzMapper.selectSpglListByOrgCode(orgCode);

		return ResultUtil.data(spmkSpzSpglDtos, "获取审批组列表成功");
	}
	
	/**
	 * 审批组-新增
	 */
	@PostMapping(value = "/spzs")
	@ApiOperation(value = "审批组-新建",httpMethod = "POST")
	public Result<SpmkSpz> addspz(@CurrentUser UserBean userBean ,@RequestBody SpmkSpz spmkSpz) {
		Integer orgCode = userBean.getOrgCode();
		
		if (spmkSpz == null || spmkSpz.getName() == null) return ResultUtil.error("请填入审批组名");
		
		SpmkSpz one = spmkSpz.selectOne(new QueryWrapper<SpmkSpz>().eq("org_code", orgCode).eq("name", spmkSpz.getName()));
		
		if (one != null) return ResultUtil.error("新增失败，换个审批组名试一试~");
		
		List<SpmkSpz> spmkSpzs = SpmkSpz.builder().build().selectList(new QueryWrapper<SpmkSpz>().eq("org_code", orgCode));
		Integer maxSort = 0;
		if (spmkSpzs != null && spmkSpzs.size() > 0) {
			for (SpmkSpz spz : spmkSpzs) {
				Integer i = spz.getSort() == null ? 0 : spz.getSort();
				// 999999 是 【其他】 审批组 ,固定排最后
				if (maxSort < i && i < CommonEnum.SPZ_OTHER.getType()) maxSort = i;
			}
		}
		
		spmkSpz.setOrgCode(orgCode);
		spmkSpz.setIsEditable(0);
		spmkSpz.setSort(maxSort+1);
		spmkSpz.insert();
		
		return ResultUtil.data(spmkSpz, "审批组-新建成功");
	}
	
	/**
	 * 审批组-删除
	 */
	@DeleteMapping(value = "/spzs/{id}")
	@ApiOperation(value = "审批组-删除",httpMethod = "DELETE")
	public Result<SpmkSpz> delspz(@CurrentUser UserBean userBean ,@PathVariable("id") Integer id){
		Integer orgCode = userBean.getOrgCode();
		SpmkSpz spmkSpz = SpmkSpz.builder().build();
		
		SpmkSpz thisSpz = spmkSpz.selectById(id);
		if ("其他".equals(thisSpz.getName())) return ResultUtil.error("该审批组无法删除");
		
		SpmkSpz  otherSpz = spmkSpz.selectOne((new QueryWrapper<SpmkSpz>().eq("org_code", orgCode).eq("sort", CommonEnum.SPZ_OTHER.getType())));
		
		SpmkSpgl one = SpmkSpgl.builder().build().selectOne(new QueryWrapper<SpmkSpgl>().eq("spz_id", "").orderByDesc("sort").last("limit 1"));
		Integer max = (one == null || one.getSort() == null) ? 1 : one.getSort();
		List<SpmkSpgl> spmkSpgls = SpmkSpgl.builder().build().selectList(new QueryWrapper<SpmkSpgl>().eq("spz_id", id));
		if (spmkSpgls != null && spmkSpgls.size() > 0) {
			for (SpmkSpgl spmkSpgl : spmkSpgls) {
				spmkSpgl.setSort(max);
				spmkSpgl.setSpzId(otherSpz.getId());
				spmkSpgl.updateById();
				max++;
			}
		}
		
		boolean b = spmkSpz.deleteById(id);
		if(b) return ResultUtil.success("审批组-删除成功");
		return ResultUtil.error("审批组-删除失败");
	}

	/**
	 * 审批管理-编辑
	 */
	@PutMapping(value = "/spgl")
	@ApiOperation(value = "审批管理-编辑", httpMethod = "PUT", notes = "接口发布说明")
	public Result<SpmkSpgl> updateSpgl(@CurrentUser UserBean userBean,@RequestBody SpmkSpglDto spmkSpglDto){
		@SuppressWarnings("unused")
		Integer orgCode = userBean.getOrgCode();
		
		SpmkSpgl spmkSpgl = SpmkSpgl.builder().build();
		BeanUtil.copyProperties(spmkSpglDto, spmkSpgl, "lcjd","spyj");
		
		spmkSpgl.setMbId(null);
		spmkSpgl.setSpzId(null);
		spmkSpgl.setOrgCode(null);
		spmkSpgl.setSpyj(ArrayUtil.join(spmkSpglDto.getSpyj(),","));
		spmkSpgl.setLcjd(ObjectUtil.serialize(spmkSpglDto.getLcjd()));
		
		boolean b = spmkSpgl.updateById();
		if (!b) return ResultUtil.error("编辑管理员列失败");
		return ResultUtil.success("编辑管理员列成功");
	}
	
	/**
	 * 审批模版-新增/编辑
	 */
	@PutMapping(value = "/mb")
	@ApiOperation(value = "审批模版-新增/编辑", httpMethod = "PUT", notes = "接口发布说明")
	public Result<SpmkSpgl> updateMb(@CurrentUser UserBean userBean,@RequestBody SpmkMbKjDto spmkMbKjDto) {
		// TODO Auto-generated method stub

		SpmkMb spmkMb = SpmkMb.builder().build();
		BeanUtil.copyProperties(spmkMbKjDto, spmkMb, "kj");
		spmkMb.setKj(ObjectUtil.serialize(spmkMbKjDto.getKj()));
		
		boolean b = spmkMb.insertOrUpdate();
		if (!b) return ResultUtil.error("审批模版-新增/编辑失败");
		return ResultUtil.success("审批模版-新增/编辑成功");
	}
	

	/**
	 * 审批组-重命名
	 */
	@PutMapping(value = "/updatespz")
	@ApiOperation(value = "审批组-重命名", httpMethod = "PUT", notes = "接口发布说明")
	public Result<SpmkSpzDto> updatespz(@CurrentUser UserBean userBean,@RequestBody SpmkSpzDto spmkSpzDto) {
		// TODO Auto-generated method stub
		
		Integer orgCode = userBean.getOrgCode();
		
		if (spmkSpzDto == null || spmkSpzDto.getName() == null) return ResultUtil.error("请填入审批组名");
		
		SpmkSpz one = SpmkSpz.builder().build().selectOne(new QueryWrapper<SpmkSpz>().eq("org_code", orgCode).eq("name", spmkSpzDto.getName()));
		
		if (one != null) return ResultUtil.error("新增失败，换个审批组名试一试~");
		
		Integer id = spmkSpzDto.getId();
		String name = spmkSpzDto.getName();
		SpmkSpz.builder().id(id).name(name).build().updateById();
		return ResultUtil.data(spmkSpzDto, "审批组重命名成功");
	}

	/**
	 * 审批组-批量排序
	 */
	@PutMapping(value = "/updatespzsort")
	@ApiOperation(value = "审批组-排序", httpMethod = "PUT", notes = "接口发布说明")
	public Result<Void> updatespzsort(@CurrentUser UserBean userBean,@RequestBody List<SpmkSpzSortDto> spmkSpzSortDtos) {
		Integer orgCode = userBean.getOrgCode();
		SpmkSpz.builder().sort(CommonEnum.SPZ_OTHER.getType()).build().update(new UpdateWrapper<SpmkSpz>().eq("org_code", orgCode).eq("name", "其他"));
		
		Integer count = spmkSpzMapper.updateListSortById(spmkSpzSortDtos);
		System.out.println(count);
		return ResultUtil.success("审批组批量排序成功");
	}

	/**
	 * 审批管理-批量排序
	 */
	@PutMapping(value = "/updatespglsort")
	@ApiOperation(value = "审批管理-排序", httpMethod = "PUT", notes = "接口发布说明")
	public Result<Void> updatespglsort(@CurrentUser UserBean userBean,@RequestBody List<SpmkSpglSortDto> spmkSpglSortDtos) {
		Integer count = spmkSpglMapper.updateListSortById(spmkSpglSortDtos);
		System.out.println(count);
		return ResultUtil.success("审批管理批量排序成功");
	}

	/**
	 * 审批管理-查询
	 */
	@GetMapping(value = "/spgl/{id}")
	@ApiOperation(value = "审批管理-查询", httpMethod = "GET", notes = "接口发布说明")
	public Result<SpmkSpglDto> selectspgl(@CurrentUser UserBean userBean,@PathVariable("id") Integer id) {
		SpmkSpgl spmkSpgl = spmkSpglMapper.selectSpglById2(id);
		
		if (spmkSpgl == null) {
			return ResultUtil.success();
		}
		
		SpmkSpglDto spmkSpglDto = SpmkSpglDto.builder().build();
		SpmkMbKjDto spmkMbKjDto = SpmkMbKjDto.builder().build();
		
		BeanUtil.copyProperties(spmkSpgl,spmkSpglDto, "lcjd","spmkMb");
		if (spmkSpgl.getLcjd() != null && spmkSpgl.getLcjd().length > 0) {
			spmkSpglDto.setSpyj(StrUtil.splitToInt(spmkSpgl.getSpyj(), ","));
			spmkSpglDto.setLcjd(ObjectUtil.unserialize(spmkSpgl.getLcjd()));
		}
		
		BeanUtil.copyProperties(spmkSpgl.getSpmkMb(),spmkMbKjDto, "kj");
		if (spmkSpgl.getSpmkMb() != null && spmkSpgl.getSpmkMb().getKj() != null && spmkSpgl.getSpmkMb().getKj().length > 0) {
			System.out.println(spmkSpgl.getSpmkMb().getKj());
			spmkMbKjDto.setKj(ObjectUtil.unserialize(spmkSpgl.getSpmkMb().getKj()));
		}
		
		spmkSpglDto.setSpmkMbKjDto(spmkMbKjDto);
		
		
		return ResultUtil.data(spmkSpglDto, "审批管理查询成功");
	}

	public void addlcjd(SpmkLcjd spmkLcjd, Integer upId) {
		if (spmkLcjd != null) {
			spmkLcjd.setUpId(upId);
			spmkLcjd.insert();
			System.out.println("spmkLcjdId" + spmkLcjd);
			List<SpmkSxpz> spmkSxpzs = spmkLcjd.getSpmkSxpzs();
			Integer spmkLcjdId = spmkLcjd.getId();
			if (spmkSxpzs != null && spmkSxpzs.size() > 0) {
				for (SpmkSxpz spmkSxpz : spmkSxpzs) {
					spmkSxpz.setLcjdId(spmkLcjdId);
					spmkSxpz.insert();
				}
			}

			List<SpmkLcjdEmpAsso> spmkLcjdEmpAssos = spmkLcjd.getSpmkLcjdEmpAssos();
			if (spmkLcjdEmpAssos != null && spmkLcjdEmpAssos.size() > 0) {
				for (SpmkLcjdEmpAsso spmkLcjdEmpAsso : spmkLcjdEmpAssos) {
					spmkLcjdEmpAsso.setLcjdId(spmkLcjdId);
					spmkLcjdEmpAsso.insert();
				}
			}

			List<SpmkLcjd> spmkLcjds = spmkLcjd.getSpmkLcjds();
			if (spmkLcjds != null && spmkLcjds.size() > 0) {
				for (SpmkLcjd spmkLcjd2 : spmkLcjds) {
					this.addlcjd(spmkLcjd2, spmkLcjdId);
				}
			}
		}
	}

	/**
	 * 审批管理-流程节点-批量添加/更新
	 */
	@Transactional
	@PostMapping(value = "/lcjd")
	@ApiOperation(value = "流程节点-批量添加/更新", httpMethod = "POST", notes = "接口发布说明")
	public Result<Void> addlistlcjd(@CurrentUser UserBean userBean,@RequestBody SpmkLcjd spmkLcjd) {
		return null;
	}

	/**
	 * 审批操作-发起审批
	 */
	@PostMapping(value = "/spcz")
	@ApiOperation(value = "审批操作-发起审批", httpMethod = "POST", notes = "接口发布说明")
	public Result<Void> addspcz(@CurrentUser UserBean userBean,@RequestBody SpmkSpcz spmkSpcz) {
			return ResultUtil.success("审批操作-发起审批成功");
	}

	/**
	 * 审批总汇-流程
	 */
	@PostMapping(value = "/sphz")
	@ApiOperation(value = "审批汇总-流程", httpMethod = "POST", notes = "接口发布说明")
	public Result<Void> sphz(@CurrentUser UserBean userBean) {

		return null;
	}

	/**
	 * 移动到
	 */
	@PutMapping(value = "/movespgl")
	@ApiOperation(value = "移动到", httpMethod = "PUT", notes = "接口发布说明")
	public Result<SpmkSpgl> moveSpgl(@CurrentUser UserBean userBean,@RequestBody SpmkSpglMoveDto spmkSpglMoveDto) {

		Integer id = spmkSpglMoveDto.getId();
		Integer spzId = spmkSpglMoveDto.getSpzId();

		List<SpmkSpgl> spgls = SpmkSpgl.builder().build().selectList(new QueryWrapper<SpmkSpgl>().eq("spz_id", spzId));
		Integer maxSort = 0;
		if (spgls != null && spgls.size() > 0) {
			for (SpmkSpgl spmkSpgl : spgls) {
				Integer i = spmkSpgl.getSort() == null ? 0 : spmkSpgl.getSort();
				if (maxSort < i)
					maxSort = i;
			}
		}
		boolean b = SpmkSpgl.builder().id(id).spzId(spzId).sort(maxSort + 1).build().updateById();

		if (!b)
			return ResultUtil.error("移动审批失败");
		return ResultUtil.success("移动审批成功");
	}

	/**
	 * 假期规则列表
	 */
	@GetMapping(value = "/jqgz")
	@ApiOperation(value = "假期规则列表", httpMethod = "GET", notes = "接口发布说明")
	public Result<Object> selectListjqgz(
			@RequestParam(defaultValue = "1") Integer currentPage,
			@RequestParam(defaultValue = "10") Integer totalPage, @RequestParam Integer id,
			@CurrentUser UserBean userBean){
		
		Page<SpmkJqgz> p = new Page<SpmkJqgz>(currentPage, totalPage);
		Integer orgCode = userBean.getOrgCode();
		IPage<SpmkJqgz> sPage = SpmkJqgz.builder().build().selectPage(p, new QueryWrapper<SpmkJqgz>().eq("org_code",orgCode));
		List<SpmkJqgz> spmkJqgzs = sPage.getRecords();
		return ResultUtil.data(sPage, spmkJqgzs, "获取假期规则列表成功");
	}
	
	
	
	
	
	
	
	
	
	
	/**
	 * 流程节点解析
	 */
//	@PostMapping(value = "/jsonparse")
//	@ApiOperation(value = "流程节点解析", httpMethod = "POST", notes = "流程节点解析")
//	@ApiOperationSupport(order = 1)
//	public Result<Object> jsonToObj(@RequestBody Object jsonObj){
//
//		JSONObject obj = JSONUtil.parseObj(jsonObj, false, true);
//		
//		Router Router = obj.get("router", Router.class);
//
//		Console.log("obj:" + obj.toStringPretty());
//		Console.log("Router:" + Router.toPrettyString());
//		Console.log("Router:" + Router.toJSONString());
//		
//		return ResultUtil.success("解析成功!");
//	}
	
	/**
	 * 部门id 查询 员工
	 */
	@PostMapping(value = "/deptSelectEmp")
	@ApiOperation(value = "部门id 查询 员工", httpMethod = "POST", notes = "流程节点解析_plus")
	public Result<Object> selectEmpBydept(@RequestParam Integer id){
		List<YgglMainEmp> ygglMainEmp = RouterUtils.selectOtherlistent(117,id);
		return ResultUtil.data(ygglMainEmp, "解析成功!");
	}
	
	
	
	
	
	/**
	 * 流程节点解析123
	 */
	@PostMapping(value = "/jsonparse_plus_plus")
	@ApiOperation(value = "jsonparse_plus_plus", httpMethod = "POST", notes = "流程节点解析_plus")
	public Result<Object> jsonToObj123(@CurrentUser UserBean userBean, @RequestBody Spmk spmk){
		
		List<Router> listRouter = new ArrayList<Router>();
		listRouter.add(spmk.getRouter());
		
		JSONObject jSONObject = spmk.getData();
		jSONObject.put("orgCode", userBean.getOrgCode());
		
		return ResultUtil.data(RouterUtils.NextNode(listRouter, jSONObject, ISNOTFIRST), "解析成功!");
	}
	
	@Autowired
    private SpmkApprovalTemplateGMapper spmkApprovalTemplateGMapper;
	
	@Autowired
    private SpmkApprovalTemplateMapper spmkApprovalTemplateMapper;
	
	@Autowired
    private SpmkApprovalGMapper spmkApprovalGMapper;
	
	@Autowired
    private SpmkCustomApprovalMapper spmkCustomApprovalMapper;
	
	/**
	 * 图标列表
	 */
	@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 审批模板组
	
	/**
	 * 新增或编辑-审批模板组
	 */
	@PostMapping(value = "/save_approval_template_g")
	@ApiOperation(value = "1.新增或编辑-审批模板组", httpMethod = "POST", notes = "新增或编辑-审批模板组")
	@ApiOperationSupport(order = 1)
	public Result<Object> saveAtg(@RequestBody SpmkApprovalTemplateG spmkApprovalTemplateG){
		
        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(@RequestBody List<SpmkApprovalTemplateG> list){

        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(@RequestBody SpmkApprovalTemplateDto spmkApprovalTemplateDto){
		Integer approvalTemplateGId = spmkApprovalTemplateDto.getApprovalTemplateGId();
		if (ObjectUtil.isNull(approvalTemplateGId)) 
			return ResultUtil.error("操作失败!-1");

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

		// 克隆 SpmkApprovalTemplateDto对象 到 SpmkApprovalTemplate对象,排除属性froms,router
		BeanUtil.copyProperties(spmkApprovalTemplateDto, at , "froms","router");
		// 序列化 后 写入 SpmkApprovalTemplate对象
		at.setFroms(ObjectUtil.serialize(spmkApprovalTemplateDto.getFroms()));
		at.setRouter(ObjectUtil.serialize(spmkApprovalTemplateDto.getRouter()));
		
		if (!at.insertOrUpdate()) 
			return ResultUtil.error("操作失败!-2");
		
		// 清空前端不需要的字段再返回,节省流量
		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")
	@ApiOperation(value = "7.id查询-审批模板", httpMethod = "GET", notes = "id查询-审批模板")
	@ApiOperationSupport(order = 7)
	public Result<Object> selectAtById(@PathVariable int id){
        
        return ResultUtil.data(SpmkApprovalTemplate.builder().id(id).build().selectById(),"操作成功!");
        
	}
	
	/**
	 * 排序-审批模板
	 */
	@PutMapping(value = "/update_approval_template")
	@ApiOperation(value = "8.查询列表-审批模板组", httpMethod = "PUT", notes = "查询列表-审批模板组")
	@ApiOperationSupport(order = 8)
	public Result<Object> ranksAt(@RequestBody List<SpmkApprovalTemplate> list){

        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,@RequestBody SpmkApprovalG spmkApprovalG){
		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 = "/list_approval_g")
	@ApiOperation(value = "11.查询列表-审批组", httpMethod = "GET", notes = "查询列表-审批组")
	@ApiOperationSupport(order = 11)
	public Result<Object> selectListAg(@CurrentUser UserBean userBean){
		
        return ResultUtil.data(spmkApprovalGMapper.selectListAgInCa(userBean.getOrgCode(), userBean.getEmpNum()),"操作成功!");
	
	}
	
	/**
	 * 排序-审批组
	 */
	@PutMapping(value = "/update_approval_g")
	@ApiOperation(value = "12.排序-审批组", httpMethod = "PUT", notes = "排序-审批组")
	@ApiOperationSupport(order = 12)
	public Result<Object> ranksAg(@RequestBody List<SpmkApprovalG> list){
        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(@RequestBody SpmkCustomApprovalDto spmkCustomApprovalDto) throws Exception{
		Integer approvalGId = spmkCustomApprovalDto.getApprovalGId();
		if (ObjectUtil.isNull(approvalGId)) 
			return ResultUtil.error("操作失败!-1");

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

		BeanUtil.copyProperties(spmkCustomApprovalDto, ca , "froms","router","initiatorConfigs");
		ca.setFroms(ObjectUtil.serialize(spmkCustomApprovalDto.getFroms()));
		ca.setRouter(ObjectUtil.serialize(spmkCustomApprovalDto.getRouter()));
		
		if (!ca.insertOrUpdate())
			return ResultUtil.error("操作失败!-2");
		
		Integer id = ca.getId();
		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);
			}
			if (!spmkInitiatorConfigMapper.insertList(listIc)) {
				// 手动抛出异常，事务回滚
				throw new Exception();
			}
			
		}
		
		SpmkInitiatorConfig.builder().build().delete(new QueryWrapper<SpmkInitiatorConfig>().lambda().eq(SpmkInitiatorConfig::getCustomApprovalId, id));

		//  
		/**
		 * 注意: 为保证该api的原子性 要加 事务处理 回滚(方法注解-@Transactional(rollbackFor = Exception.class))
		 * 1.删除	历史的  SpmkInitiatorConfig-审批发起人配置,
		 * 2.新增	最新的 SpmkInitiatorConfig-审批发起人配置,
		 * 3.新增 SpmkCustomApproval-自定义审批
		 */

		// 清空前端不需要的字段再返回,节省流量
		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();
		SpmkCustomApprovalDto caD = SpmkCustomApprovalDto.builder()
				.froms((List<JSONObject>)ObjectUtil.unserialize(ca.getFroms()))
				.router(ObjectUtil.unserialize(ca.getRouter()))
				.build();
		BeanUtil.copyProperties(ca, caD,"froms","router");
		
        return ResultUtil.data(caD,"操作成功!");
        
	}
	
	/**
	 * 排序-自定义审批
	 */
	@PutMapping(value = "/update_custom_approval")
	@ApiOperation(value = "16.排序-自定义审批", httpMethod = "PUT", notes = "排序-自定义审批")
	@ApiOperationSupport(order = 16)
	public Result<Object> ranksCa(@RequestBody List<SpmkCustomApproval> list){

        return spmkCustomApprovalMapper.updateListRandsById(list) ? ResultUtil.success("操作成功!") : ResultUtil.error("操作失败!");
	
	}
	
	@Autowired
	private SpmkApproveSummaryMapper spmkApproveSummaryMapper;
	@Autowired
	private SpmkApproveDetailMapper spmkApproveDetailMapper;
	@Autowired
	private SpmkApproveExecuteRecordMapper spmkApproveExecuteRecordMapper;
	@Autowired
	private SpmkExecutorMapper spmkExecutorMapper;
	@Autowired
	private SpmkInitiatorConfigMapper spmkInitiatorConfigMapper;
	
	private boolean ISFIRST = true; // 第一次启动审批流程
	private boolean ISNOTFIRST = false;
	
	// TODO 审批汇总(发起审批)
	/**
	 * 发起审批
	 * @throws Exception 
	 */
	@PostMapping(value = "/start_approval")
	@ApiOperation(value = "17.发起审批", httpMethod = "POST", notes = "发起审批")
	@ApiOperationSupport(order = 17)
	@Transactional(rollbackFor = Exception.class)
	public Result<Object> saveCa(@CurrentUser UserBean userBean, @RequestBody SpmkApproveSummaryDto spmkApproveSummaryDto) throws Exception{
			
			List<Router> listRouter = new ArrayList<Router>();
			listRouter.add(spmkApproveSummaryDto.getRouter());
			JSONObject jSONObject = spmkApproveSummaryDto.getRequestData()
					.put("orgCode", FromData.builder().value(String.valueOf(userBean.getOrgCode())).build())
					.put("initiator", FromData.builder().value(spmkApproveSummaryDto.getInitiator()).build());
			RouterUtils.NextNode(listRouter, jSONObject, ISFIRST);
			List<FlowChildren> listFlowChildren = new ArrayList<FlowChildren>();
			RouterUtils.getIsFlowChildren(listRouter,listFlowChildren);
			
//			System.out.println(jSONObject);
//			System.out.println(listRouter);
//			System.out.println(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())
					.sts(0)
					.currentApprover(currentApprover).build();
			
			if (!as.insert()) {
				return ResultUtil.error("操作失败!");
			}
			
			// 插入记录
			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 Exception();
			
			return ResultUtil.success("操作成功!");
			
	}
	
	//TODO 审批汇总
	/**
	 * 审批汇总
	 */
	@PostMapping(value = "/select_approve_summary")
	@ApiOperation(value = "18.审批汇总", httpMethod = "POST", notes = "审批汇总")
	@ApiOperationSupport(order = 18)
	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());
			// 缺-部门id 搜索
			List<SpmkApproveSummary> listAs = spmkApproveSummaryMapper.selectPageByQuery(page, summaryQueryDto);
			
			return ResultUtil.data(listAs, "操作成功!");
	}
	
	//TODO 审批详情
	/**
	 * 审批详情
	 */
	@GetMapping(value = "/select_approve_detail/{id}")
	@ApiOperation(value = "19.审批详情", httpMethod = "GET", notes = "审批详情")
	@ApiOperationSupport(order = 19)
	public Result<Object> selectAd(@PathVariable Integer id) {
		
		SpmkApproveDetail ad = spmkApproveDetailMapper.selectOne(new QueryWrapper<SpmkApproveDetail>().lambda().eq(SpmkApproveDetail::getApproveSummaryId, id));
		SpmkApproveDetailDto adD = SpmkApproveDetailDto.builder().build();
		
		List<SpmkApproveExecuteRecord> listAer = spmkApproveExecuteRecordMapper.selectListByAsId(id);
		
		BeanUtil.copyProperties(ad, adD, "requestData","froms","router","spmkApproveExecuteRecord");
		adD.setRequestData(ObjectUtil.unserialize(ad.getRequestData()));
		adD.setFroms(ObjectUtil.unserialize(ad.getFroms()));
		adD.setRouter((Router)ObjectUtil.unserialize(ad.getRouter()));
		adD.setListFlowChildren((List<FlowChildren>)ObjectUtil.unserialize(ad.getFlowChildren()));
		adD.setListSpmkApproveExecuteRecord(listAer);
		
		return ResultUtil.data(adD, "操作成功!");
	}
	
	//TODO 审批人审批
	/**
	 * 审批人审批
	 */
	@PostMapping(value = "/approving")
	@ApiOperation(value = "20.审批人审批", httpMethod = "POST", notes = "审批人审批")
	@ApiOperationSupport(order = 19)
	public Result<Object> approving(@RequestBody ApprovingDto approvingDto) {
		SpmkApproveDetail ad = SpmkApproveDetail.builder().build()
		.selectOne(new QueryWrapper<SpmkApproveDetail>()
				.lambda()
				.eq(SpmkApproveDetail::getApproveSummaryId, approvingDto.getAsId()));
		
		Integer count = SpmkExecutor.builder().build().selectCount(new QueryWrapper<SpmkExecutor>().lambda()
				.eq(SpmkExecutor::getId, approvingDto.getExecutorId())
				.eq(SpmkExecutor::getSts, "1"));
		
		if (count == 0) {
			return ResultUtil.error("您已审批过!");
		}
		
		SpmkApproveSummary aSummary = spmkApproveSummaryMapper.selectById(approvingDto.getAsId());
		if (aSummary.getSts() == 0) {
			List<FlowChildren> listFlowChildren = (List<FlowChildren>)ObjectUtil.unserialize(ad.getFlowChildren());
			RouterUtils.approving(
					listFlowChildren, 
					approvingDto.getAsId(), 
					approvingDto.getExecuteRecordId(), 
					approvingDto.getExecutorId(), 
					approvingDto.getOpinion(),
					approvingDto.getSts());
			
			System.out.println(listFlowChildren);
			// 更新 flowChildren
			SpmkApproveDetail.builder().id(ad.getId()).flowChildren(ObjectUtil.serialize(listFlowChildren)).build().updateById();
			
			if (CollUtil.getLast(listFlowChildren).getExecute() == "2") {
				// 更新 审批汇总 状态
				SpmkApproveSummary.builder().id(approvingDto.getAsId()).endTime(new Date()).sts(2).build().updateById();
			}
			
		}else {
			return ResultUtil.error("该审批已结束!");
		}
		
		
		return ResultUtil.data(null, "操作成功!");
	}
	
	
	

}