2022-08-25 化学品申购相关代码。

zd-common/zd-common-core/src/main/java/com/zd/common/core/domain/per/PerFun.java

@@ -184,4 +184,11 @@ public class PerFun {
      */
     public static final String JOINCABINET = "joinCabinet";
 
+
+
+    /**
+     * 草稿箱列表
+     */
+    public static final String DRAFTSLIST = "draftsList";
+
 }

zd-common/zd-common-core/src/main/java/com/zd/common/core/domain/per/PerPrefix.java

@@ -675,4 +675,21 @@ public class PerPrefix {
 
     public static final String HPX_HOMEPAGE = "chemical:hxpHomePage:";
 
+    /**   ================================================化学品申请流程的权限=====================================     */
+    public static final String ACT_HXP_APPLY = "chemical:hxpapply:";
+
+    public static final String ACT_HXP_APPLYAUDIT = "chemical:hxpapplyaudit:";
+
+    public static final String ACT_HXP_MYAPPLY = "chemical:myhxpapply:";
+
+    public static final String ACT_HXP_APPLYTASK = "chemical:applytask:";
+
+    public static final String ACT_HXP_REFUSEAPPLYTASK = "chemical:refuseApplytask:";
+
+    public static final String ACT_HXP_REVOKEAPPLYTASK = "chemical:revokeApplytask:";
+
+    public static final String ACT_HXP_MYREVOKEAPPLYTASK = "chemical:myrevokeApplytask:";
+
+    public static final String ACT_HXP_AUDITCONFIG = "chemical:auditconfig:";
+
 }

zd-modules/zd-chemical/src/main/java/com/zd/chemical/controller/ActApplytaskController.java

@@ -0,0 +1,170 @@
+package com.zd.chemical.controller;
+
+import java.util.List;
+import java.io.IOException;
+import javax.servlet.http.HttpServletResponse;
+
+import com.zd.chemical.domain.vo.ActApplytaskVo;
+import com.zd.common.core.domain.per.PerFun;
+import com.zd.common.core.domain.per.PerPrefix;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import com.zd.common.response.ResultData;
+import com.zd.common.log.annotation.Log;
+import com.zd.common.log.enums.BusinessType;
+import com.zd.common.security.annotation.PreAuthorize;
+import com.zd.chemical.domain.ActApplytask;
+import com.zd.chemical.service.IActApplytaskService;
+import com.zd.common.core.web.controller.BaseController;
+import com.zd.common.core.web.domain.AjaxResult;
+import com.zd.common.core.utils.poi.ExcelUtil;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+
+import com.zd.common.core.web.page.TableDataInfo;
+
+/**
+ * 化学品申购任务Controller
+ *
+ * @author zd
+ * @date 2022-08-17
+ */
+@RestController
+@Api(tags = "【化学品申购任务】")
+@RequestMapping("/applytask")
+public class ActApplytaskController extends BaseController<ActApplytask>
+{
+    @Autowired
+    private IActApplytaskService actApplytaskService;
+
+    /**
+     * 查询化学品申购任务列表
+     */
+//    @PreAuthorize(hasPermi = "laboratory:applytask:list")
+    @GetMapping("/list")
+    @ApiOperation(value = "查询化学品申购任务列表")
+    public TableDataInfo<ActApplytask> list(ActApplytask actApplytask)
+    {
+        startPage();
+        List<ActApplytask> list = actApplytaskService.selectActApplytaskList(actApplytask);
+        return getDataTable(list);
+    }
+
+    /**
+     * 导出化学品申购任务列表
+     */
+    @ApiOperation(value = "导出化学品申购任务列表")
+//    @PreAuthorize(hasPermi = "laboratory:applytask:export")
+    @Log(title = "化学品申购任务", businessType = BusinessType.EXPORT)
+    @PostMapping("/export")
+    public void export(HttpServletResponse response, ActApplytask actApplytask) throws IOException
+    {
+        List<ActApplytask> list = actApplytaskService.selectActApplytaskList(actApplytask);
+        ExcelUtil<ActApplytask> util = new ExcelUtil<ActApplytask>(ActApplytask.class);
+        util.exportExcel(response, list, "化学品申购任务数据");
+    }
+
+    /**
+     * 获取化学品申购任务详细信息
+     */
+    @ApiOperation(value = "获取化学品申购任务详细信息")
+//    @PreAuthorize(hasPermi = "laboratory:applytask:query")
+    @GetMapping(value = "/{id}")
+    public ResultData<ActApplytask> getInfo(@PathVariable("id") Long id)
+    {
+        return ResultData.success(actApplytaskService.selectActApplytaskById(id));
+    }
+
+    /**
+     * 新增化学品申购任务
+     */
+    @ApiOperation(value = "新增化学品申购任务")
+//    @PreAuthorize(hasPermi = "laboratory:applytask:add")
+    @Log(title = "化学品申购任务", businessType = BusinessType.INSERT)
+    @PostMapping
+    public ResultData add(@RequestBody ActApplytask actApplytask)
+    {
+        return ResultData.result(actApplytaskService.insertActApplytask(actApplytask));
+    }
+
+    /**
+     * 修改化学品申购任务
+     */
+    @ApiOperation(value = "修改化学品申购任务")
+//    @PreAuthorize(hasPermi = "laboratory:applytask:edit")
+    @Log(title = "化学品申购任务", businessType = BusinessType.UPDATE)
+    @PutMapping
+    public ResultData edit(@RequestBody ActApplytask actApplytask)
+    {
+        return  ResultData.result(actApplytaskService.updateActApplytask(actApplytask));
+    }
+
+    /**
+     * 删除化学品申购任务
+     */
+    @ApiOperation(value = "删除化学品申购任务")
+//    @PreAuthorize(hasPermi = "laboratory:applytask:remove")
+    @Log(title = "化学品申购任务", businessType = BusinessType.DELETE)
+	@DeleteMapping("/{ids}")
+    public ResultData remove(@PathVariable Long[] ids)
+    {
+        return ResultData.result(actApplytaskService.deleteActApplytaskByIds(ids));
+    }
+
+
+    /**
+     * 工作流节点审批（审批通过）
+     */
+    @ApiOperation(value = "工作流节点审批")
+    @PreAuthorize(hasPermi = PerPrefix.ACT_HXP_APPLYTASK+ PerFun.EDIT)
+    @Log(title = "工作流节点审批任务", businessType = BusinessType.UPDATE)
+    @PutMapping("/approvalTask")
+    public ResultData approvalTask(@RequestBody ActApplytaskVo actApplytaskVo)
+    {
+        return  ResultData.result(actApplytaskService.approvalTask(actApplytaskVo));
+    }
+
+    /**
+     * 工作流节点审批(拒绝)
+     */
+    @ApiOperation(value = "工作流节点审批(拒绝)")
+    @PreAuthorize(hasPermi = PerPrefix.ACT_HXP_REFUSEAPPLYTASK+ PerFun.EDIT)
+    @Log(title = "工作流节点审批任务(拒绝)", businessType = BusinessType.UPDATE)
+    @PutMapping("/approvalRefuse")
+    public ResultData approvalRefuse(@RequestBody ActApplytask actApplytask)
+    {
+        return  ResultData.result(actApplytaskService.approvalRefuse(actApplytask));
+    }
+
+    /**
+     * 工作流节点审批(撤销)
+     */
+    @ApiOperation(value = "工作流节点审批(撤销)")
+    @PreAuthorize(hasPermi = PerPrefix.ACT_HXP_REVOKEAPPLYTASK+ PerFun.EDIT)
+    @Log(title = "工作流节点审批任务(撤销)", businessType = BusinessType.UPDATE)
+    @PutMapping("/approvalRevoke")
+    public ResultData approvalRevoke(@RequestBody ActApplytask actApplytask)
+    {
+        return  ResultData.result(actApplytaskService.approvalRevoke(actApplytask));
+    }
+
+
+    /**
+     * 工作流节点审批(撤销学生端用)
+     */
+    @ApiOperation(value = "工作流节点审批(撤销)")
+    @PreAuthorize(hasPermi = PerPrefix.ACT_HXP_MYREVOKEAPPLYTASK+ PerFun.EDIT)
+    @Log(title = "工作流节点审批任务(撤销)", businessType = BusinessType.UPDATE)
+    @PutMapping("/myApprovalRevoke")
+    public ResultData myApprovalRevoke(@RequestBody ActApplytask actApplytask)
+    {
+        return  ResultData.result(actApplytaskService.approvalRevoke(actApplytask));
+    }
+}

zd-modules/zd-chemical/src/main/java/com/zd/chemical/controller/ActApplytaskNodeController.java

@@ -0,0 +1,116 @@
+package com.zd.chemical.controller;
+
+import java.util.List;
+import java.io.IOException;
+import javax.servlet.http.HttpServletResponse;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import com.zd.common.response.ResultData;
+import com.zd.common.log.annotation.Log;
+import com.zd.common.log.enums.BusinessType;
+import com.zd.common.security.annotation.PreAuthorize;
+import com.zd.chemical.domain.ActApplytaskNode;
+import com.zd.chemical.service.IActApplytaskNodeService;
+import com.zd.common.core.web.controller.BaseController;
+import com.zd.common.core.web.domain.AjaxResult;
+import com.zd.common.core.utils.poi.ExcelUtil;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+
+import com.zd.common.core.web.page.TableDataInfo;
+
+/**
+ * 化学品申购任务节点Controller
+ *
+ * @author zd
+ * @date 2022-08-17
+ */
+@RestController
+@Api(tags = "【化学品申购任务节点】")
+@RequestMapping("/applytaskNode")
+public class ActApplytaskNodeController extends BaseController<ActApplytaskNode>
+{
+    @Autowired
+    private IActApplytaskNodeService actApplytaskNodeService;
+
+    /**
+     * 查询化学品申购任务节点列表
+     */
+//    @PreAuthorize(hasPermi = "laboratory:node:list")
+    @GetMapping("/list")
+    @ApiOperation(value = "查询化学品申购任务节点列表")
+    public TableDataInfo<ActApplytaskNode> list(ActApplytaskNode actApplytaskNode)
+    {
+        startPage();
+        List<ActApplytaskNode> list = actApplytaskNodeService.selectActApplytaskNodeList(actApplytaskNode);
+        return getDataTable(list);
+    }
+
+    /**
+     * 导出化学品申购任务节点列表
+     */
+    @ApiOperation(value = "导出化学品申购任务节点列表")
+//    @PreAuthorize(hasPermi = "laboratory:node:export")
+    @Log(title = "化学品申购任务节点", businessType = BusinessType.EXPORT)
+    @PostMapping("/export")
+    public void export(HttpServletResponse response, ActApplytaskNode actApplytaskNode) throws IOException
+    {
+        List<ActApplytaskNode> list = actApplytaskNodeService.selectActApplytaskNodeList(actApplytaskNode);
+        ExcelUtil<ActApplytaskNode> util = new ExcelUtil<ActApplytaskNode>(ActApplytaskNode.class);
+        util.exportExcel(response, list, "化学品申购任务节点数据");
+    }
+
+    /**
+     * 获取化学品申购任务节点详细信息
+     */
+    @ApiOperation(value = "获取化学品申购任务节点详细信息")
+//    @PreAuthorize(hasPermi = "laboratory:node:query")
+    @GetMapping(value = "/{id}")
+    public ResultData<ActApplytaskNode> getInfo(@PathVariable("id") Long id)
+    {
+        return ResultData.success(actApplytaskNodeService.selectActApplytaskNodeById(id));
+    }
+
+    /**
+     * 新增化学品申购任务节点
+     */
+    @ApiOperation(value = "新增化学品申购任务节点")
+//    @PreAuthorize(hasPermi = "laboratory:node:add")
+    @Log(title = "化学品申购任务节点", businessType = BusinessType.INSERT)
+    @PostMapping
+    public ResultData add(@RequestBody ActApplytaskNode actApplytaskNode)
+    {
+        return ResultData.result(actApplytaskNodeService.insertActApplytaskNode(actApplytaskNode));
+    }
+
+    /**
+     * 修改化学品申购任务节点
+     */
+    @ApiOperation(value = "修改化学品申购任务节点")
+//    @PreAuthorize(hasPermi = "laboratory:node:edit")
+    @Log(title = "化学品申购任务节点", businessType = BusinessType.UPDATE)
+    @PutMapping
+    public ResultData edit(@RequestBody ActApplytaskNode actApplytaskNode)
+    {
+        return  ResultData.result(actApplytaskNodeService.updateActApplytaskNode(actApplytaskNode));
+    }
+
+    /**
+     * 删除化学品申购任务节点
+     */
+    @ApiOperation(value = "删除化学品申购任务节点")
+//    @PreAuthorize(hasPermi = "laboratory:node:remove")
+    @Log(title = "化学品申购任务节点", businessType = BusinessType.DELETE)
+	@DeleteMapping("/{ids}")
+    public ResultData remove(@PathVariable Long[] ids)
+    {
+        return ResultData.result(actApplytaskNodeService.deleteActApplytaskNodeByIds(ids));
+    }
+}

zd-modules/zd-chemical/src/main/java/com/zd/chemical/controller/ActAuditconfigController.java

@@ -0,0 +1,134 @@
+package com.zd.chemical.controller;
+
+import java.util.List;
+import java.io.IOException;
+import javax.servlet.http.HttpServletResponse;
+
+import com.zd.chemical.domain.vo.ActAuditconfigVo;
+import com.zd.common.core.domain.per.PerFun;
+import com.zd.common.core.domain.per.PerPrefix;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import com.zd.common.response.ResultData;
+import com.zd.common.log.annotation.Log;
+import com.zd.common.log.enums.BusinessType;
+import com.zd.common.security.annotation.PreAuthorize;
+import com.zd.chemical.domain.ActAuditconfig;
+import com.zd.chemical.service.IActAuditconfigService;
+import com.zd.common.core.web.controller.BaseController;
+import com.zd.common.core.utils.poi.ExcelUtil;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+
+import com.zd.common.core.web.page.TableDataInfo;
+
+/**
+ * 工作流审批Controller
+ *
+ * @author zd
+ * @date 2022-08-16
+ */
+@RestController
+@Api(tags = "【工作流审批】")
+@RequestMapping("/auditconfig")
+public class ActAuditconfigController extends BaseController<ActAuditconfig>
+{
+    @Autowired
+    private IActAuditconfigService actAuditconfigService;
+
+    /**
+     * 查询工作流审批列表
+     */
+//    @PreAuthorize(hasPermi = "laboratory:auditconfig:list")
+    @GetMapping("/list")
+    @ApiOperation(value = "查询工作流审批列表")
+    public TableDataInfo<ActAuditconfig> list(ActAuditconfig actAuditconfig)
+    {
+        startPage();
+        List<ActAuditconfig> list = actAuditconfigService.selectActAuditconfigList(actAuditconfig);
+        return getDataTable(list);
+    }
+
+    /**
+     * 查询工作流审批列表
+     */
+    @PreAuthorize(hasPermi = PerPrefix.ACT_HXP_AUDITCONFIG+ PerFun.LIST)
+    @GetMapping("/getConfigList")
+    @ApiOperation(value = "查询工作流审批列表")
+    public TableDataInfo<ActAuditconfigVo> getConfigList(ActAuditconfig actAuditconfig)
+    {
+        startPage();
+        List<ActAuditconfigVo> list = actAuditconfigService.getConfigList(actAuditconfig);
+        TableDataInfo<ActAuditconfigVo> info=new TableDataInfo<>();
+        info.getDataTable(list);
+        return info;
+    }
+
+    /**
+     * 导出工作流审批列表
+     */
+    @ApiOperation(value = "导出工作流审批列表")
+//    @PreAuthorize(hasPermi = "laboratory:auditconfig:export")
+    @Log(title = "工作流审批", businessType = BusinessType.EXPORT)
+    @PostMapping("/export")
+    public void export(HttpServletResponse response, ActAuditconfig actAuditconfig) throws IOException
+    {
+        List<ActAuditconfig> list = actAuditconfigService.selectActAuditconfigList(actAuditconfig);
+        ExcelUtil<ActAuditconfig> util = new ExcelUtil<ActAuditconfig>(ActAuditconfig.class);
+        util.exportExcel(response, list, "工作流审批数据");
+    }
+
+    /**
+     * 获取工作流审批详细信息
+     */
+    @ApiOperation(value = "获取工作流审批详细信息")
+//    @PreAuthorize(hasPermi = "laboratory:auditconfig:query")
+    @GetMapping(value = "/{id}")
+    public ResultData<ActAuditconfig> getInfo(@PathVariable("id") Long id)
+    {
+        return ResultData.success(actAuditconfigService.selectActAuditconfigById(id));
+    }
+
+    /**
+     * 新增工作流审批
+     */
+    @ApiOperation(value = "新增工作流审批")
+//    @PreAuthorize(hasPermi = "laboratory:auditconfig:add")
+    @Log(title = "工作流审批", businessType = BusinessType.INSERT)
+    @PostMapping
+    public ResultData add(@RequestBody List<ActAuditconfigVo> actAuditconfigList)
+    {
+        return ResultData.result(actAuditconfigService.insertActAuditconfig(actAuditconfigList));
+    }
+
+    /**
+     * 修改工作流审批
+     */
+    @ApiOperation(value = "修改工作流审批")
+//    @PreAuthorize(hasPermi = "laboratory:auditconfig:edit")
+    @Log(title = "工作流审批", businessType = BusinessType.UPDATE)
+    @PutMapping
+    public ResultData edit(@RequestBody ActAuditconfig actAuditconfig)
+    {
+        return  ResultData.result(actAuditconfigService.updateActAuditconfig(actAuditconfig));
+    }
+
+    /**
+     * 删除工作流审批
+     */
+    @ApiOperation(value = "删除工作流审批")
+//    @PreAuthorize(hasPermi = "laboratory:auditconfig:remove")
+    @Log(title = "工作流审批", businessType = BusinessType.DELETE)
+	@DeleteMapping("/{ids}")
+    public ResultData remove(@PathVariable Long[] ids)
+    {
+        return ResultData.result(actAuditconfigService.deleteActAuditconfigByIds(ids));
+    }
+}

zd-modules/zd-chemical/src/main/java/com/zd/chemical/controller/ActAudituserController.java

@@ -0,0 +1,116 @@
+package com.zd.chemical.controller;
+
+import java.util.List;
+import java.io.IOException;
+import javax.servlet.http.HttpServletResponse;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import com.zd.common.response.ResultData;
+import com.zd.common.log.annotation.Log;
+import com.zd.common.log.enums.BusinessType;
+import com.zd.common.security.annotation.PreAuthorize;
+import com.zd.chemical.domain.ActAudituser;
+import com.zd.chemical.service.IActAudituserService;
+import com.zd.common.core.web.controller.BaseController;
+import com.zd.common.core.web.domain.AjaxResult;
+import com.zd.common.core.utils.poi.ExcelUtil;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+
+import com.zd.common.core.web.page.TableDataInfo;
+
+/**
+ * 工作流审批用户Controller
+ *
+ * @author zd
+ * @date 2022-08-16
+ */
+@RestController
+@Api(tags = "【工作流审批用户】")
+@RequestMapping("/audituser")
+public class ActAudituserController extends BaseController<ActAudituser>
+{
+    @Autowired
+    private IActAudituserService actAudituserService;
+
+    /**
+     * 查询工作流审批用户列表
+     */
+//    @PreAuthorize(hasPermi = "laboratory:audituser:list")
+    @GetMapping("/list")
+    @ApiOperation(value = "查询工作流审批用户列表")
+    public TableDataInfo<ActAudituser> list(ActAudituser actAudituser)
+    {
+        startPage();
+        List<ActAudituser> list = actAudituserService.selectActAudituserList(actAudituser);
+        return getDataTable(list);
+    }
+
+    /**
+     * 导出工作流审批用户列表
+     */
+    @ApiOperation(value = "导出工作流审批用户列表")
+//    @PreAuthorize(hasPermi = "laboratory:audituser:export")
+    @Log(title = "工作流审批用户", businessType = BusinessType.EXPORT)
+    @PostMapping("/export")
+    public void export(HttpServletResponse response, ActAudituser actAudituser) throws IOException
+    {
+        List<ActAudituser> list = actAudituserService.selectActAudituserList(actAudituser);
+        ExcelUtil<ActAudituser> util = new ExcelUtil<ActAudituser>(ActAudituser.class);
+        util.exportExcel(response, list, "工作流审批用户数据");
+    }
+
+    /**
+     * 获取工作流审批用户详细信息
+     */
+    @ApiOperation(value = "获取工作流审批用户详细信息")
+//    @PreAuthorize(hasPermi = "laboratory:audituser:query")
+    @GetMapping(value = "/{id}")
+    public ResultData<ActAudituser> getInfo(@PathVariable("id") Long id)
+    {
+        return ResultData.success(actAudituserService.selectActAudituserById(id));
+    }
+
+    /**
+     * 新增工作流审批用户
+     */
+    @ApiOperation(value = "新增工作流审批用户")
+//    @PreAuthorize(hasPermi = "laboratory:audituser:add")
+    @Log(title = "工作流审批用户", businessType = BusinessType.INSERT)
+    @PostMapping
+    public ResultData add(@RequestBody ActAudituser actAudituser)
+    {
+        return ResultData.result(actAudituserService.insertActAudituser(actAudituser));
+    }
+
+    /**
+     * 修改工作流审批用户
+     */
+    @ApiOperation(value = "修改工作流审批用户")
+//    @PreAuthorize(hasPermi = "laboratory:audituser:edit")
+    @Log(title = "工作流审批用户", businessType = BusinessType.UPDATE)
+    @PutMapping
+    public ResultData edit(@RequestBody ActAudituser actAudituser)
+    {
+        return  ResultData.result(actAudituserService.updateActAudituser(actAudituser));
+    }
+
+    /**
+     * 删除工作流审批用户
+     */
+    @ApiOperation(value = "删除工作流审批用户")
+//    @PreAuthorize(hasPermi = "laboratory:audituser:remove")
+    @Log(title = "工作流审批用户", businessType = BusinessType.DELETE)
+	@DeleteMapping("/{ids}")
+    public ResultData remove(@PathVariable Long[] ids)
+    {
+        return ResultData.result(actAudituserService.deleteActAudituserByIds(ids));
+    }
+}

zd-modules/zd-chemical/src/main/java/com/zd/chemical/controller/ActHxpapplyController.java

@@ -0,0 +1,238 @@
+package com.zd.chemical.controller;
+
+import java.util.List;
+import java.io.IOException;
+import java.util.Map;
+import javax.servlet.http.HttpServletResponse;
+
+import com.zd.chemical.domain.vo.*;
+import com.zd.common.core.domain.per.PerFun;
+import com.zd.common.core.domain.per.PerPrefix;
+import com.zd.common.core.utils.SecurityUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.*;
+import com.zd.common.response.ResultData;
+import com.zd.common.log.annotation.Log;
+import com.zd.common.log.enums.BusinessType;
+import com.zd.common.security.annotation.PreAuthorize;
+import com.zd.chemical.domain.ActHxpapply;
+import com.zd.chemical.service.IActHxpapplyService;
+import com.zd.common.core.web.controller.BaseController;
+import com.zd.common.core.web.domain.AjaxResult;
+import com.zd.common.core.utils.poi.ExcelUtil;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+
+import com.zd.common.core.web.page.TableDataInfo;
+
+/**
+ * 化学品申购Controller
+ *
+ * @author zd
+ * @date 2022-08-17
+ */
+@RestController
+@Api(tags = "【化学品申购】")
+@RequestMapping("/hxpapply")
+public class ActHxpapplyController extends BaseController<ActHxpapply>
+{
+    @Autowired
+    private IActHxpapplyService actHxpapplyService;
+
+    /**
+     * 查询化学品申购列表
+     */
+    @PreAuthorize(hasPermi = PerPrefix.ACT_HXP_APPLY+ PerFun.LIST)
+    @GetMapping("/list")
+    @ApiOperation(value = "查询化学品申购列表")
+    public TableDataInfo<ActHxpapplyListVo> list(ActHxpapplySearch actHxpapplySearch)
+    {
+        startPage();
+        List<ActHxpapplyListVo> list = actHxpapplyService.selectActHxpapplyList(actHxpapplySearch);
+        TableDataInfo<ActHxpapplyListVo> info=new TableDataInfo<>();
+        info.getDataTable(list);
+        return info;
+    }
+
+
+    /**
+     * 查询化学品申购列表(草稿箱)
+     */
+    @PreAuthorize(hasPermi = PerPrefix.ACT_HXP_APPLY+ PerFun.DRAFTSLIST)
+    @GetMapping("/draftsList")
+    @ApiOperation(value = "查询化学品申购列表(草稿箱)")
+    public TableDataInfo<ActHxpapplyDraftsListVo> draftsList(ActHxpapplySearch actHxpapplySearch)
+    {
+        actHxpapplySearch.setUserId(SecurityUtils.getUserId());
+        startPage();
+        List<ActHxpapplyDraftsListVo> list = actHxpapplyService.draftsList(actHxpapplySearch);
+        TableDataInfo<ActHxpapplyDraftsListVo> info=new TableDataInfo<>();
+        info.getDataTable(list);
+        return info;
+    }
+
+
+    /**
+     * 查询化学品申购列表(学生端接口)
+     */
+    @PreAuthorize(hasPermi = PerPrefix.ACT_HXP_MYAPPLY+ PerFun.LIST)
+    @GetMapping("/myList")
+    @ApiOperation(value = "查询化学品申购列表")
+    public TableDataInfo<ActHxpapplyListVo> mylist(ActHxpapplySearch actHxpapplySearch)
+    {
+        startPage();
+        actHxpapplySearch.setUserId(SecurityUtils.getUserId());
+        List<ActHxpapplyListVo> list = actHxpapplyService.selectActHxpapplyList(actHxpapplySearch);
+        TableDataInfo<ActHxpapplyListVo> info=new TableDataInfo<>();
+        info.getDataTable(list);
+        return info;
+    }
+
+
+    /**
+     * 查询化学品申购列表(学生端草稿箱)
+     */
+    @PreAuthorize(hasPermi = PerPrefix.ACT_HXP_MYAPPLY+ PerFun.DRAFTSLIST)
+    @GetMapping("/myDraftsList")
+    @ApiOperation(value = "查询化学品申购列表(草稿箱)")
+    public TableDataInfo<ActHxpapplyDraftsListVo> myDraftsList(ActHxpapplySearch actHxpapplySearch)
+    {
+        startPage();
+        actHxpapplySearch.setUserId(SecurityUtils.getUserId());
+        List<ActHxpapplyDraftsListVo> list = actHxpapplyService.draftsList(actHxpapplySearch);
+        TableDataInfo<ActHxpapplyDraftsListVo> info=new TableDataInfo<>();
+        info.getDataTable(list);
+        return info;
+    }
+
+    /**
+     * 导出化学品申购列表
+     */
+    @ApiOperation(value = "导出化学品申购列表")
+    @PreAuthorize(hasPermi = PerPrefix.ACT_HXP_APPLY+ PerFun.EXPORT)
+    @Log(title = "化学品申购", businessType = BusinessType.EXPORT)
+    @PostMapping("/export")
+    public void export(HttpServletResponse response, ActHxpapplySearch actHxpapplySearch) throws IOException
+    {
+        List<ActHxpapplyListVo> list = actHxpapplyService.selectActHxpapplyList(actHxpapplySearch);
+        ExcelUtil<ActHxpapplyListVo> util = new ExcelUtil<ActHxpapplyListVo>(ActHxpapplyListVo.class);
+        util.exportExcel(response, list, "化学品申购数据");
+    }
+
+    /**
+     * 获取化学品申购详细信息
+     */
+    @ApiOperation(value = "获取化学品申购详细信息")
+    @PreAuthorize(hasPermi = PerPrefix.ACT_HXP_APPLY+ PerFun.QUERY)
+    @GetMapping(value = "/{id}")
+    public ResultData<ActHxpapplyInfoVo> getInfo(@PathVariable("id") Long id)
+    {
+        return ResultData.success(actHxpapplyService.selectActHxpapplyById(id,2));
+    }
+
+    /**
+     * 获取化学品申购详细信息(审批记录调用)
+     */
+    @ApiOperation(value = "获取化学品申购详细信息")
+    @PreAuthorize(hasPermi = PerPrefix.ACT_HXP_APPLYAUDIT+ PerFun.QUERY)
+    @GetMapping(value = "/audit/{id}")
+    public ResultData<ActHxpapplyInfoVo> auditByGetInfo(@PathVariable("id") Long id)
+    {
+        return ResultData.success(actHxpapplyService.selectActHxpapplyById(id,1));
+    }
+
+    /**
+     * 获取化学品申购详细信息(学生端接口)
+     */
+    @ApiOperation(value = "获取化学品申购详细信息(学生端接口)")
+    @PreAuthorize(hasPermi = PerPrefix.ACT_HXP_MYAPPLY+ PerFun.QUERY)
+    @GetMapping(value = "/myInfo/{id}")
+    public ResultData<ActHxpapplyInfoVo> getMyInfo(@PathVariable("id") Long id)
+    {
+        return ResultData.success(actHxpapplyService.selectActHxpapplyById(id,2));
+    }
+
+
+    /**
+     * 新增化学品申购
+     */
+    @ApiOperation(value = "新增化学品申购")
+    @PreAuthorize(hasPermi = PerPrefix.ACT_HXP_APPLY+ PerFun.ADD)
+    @Log(title = "化学品申购", businessType = BusinessType.INSERT)
+    @PostMapping
+    public ResultData add(@RequestBody ActHxpapplyVo actHxpapplyVo)
+    {
+        return ResultData.result(actHxpapplyService.insertActHxpapply(actHxpapplyVo));
+    }
+
+    /**
+     * 新增化学品申购(学生端接口)
+     */
+    @ApiOperation(value = "新增化学品申购(学生端接口)")
+    @PreAuthorize(hasPermi = PerPrefix.ACT_HXP_MYAPPLY+ PerFun.ADD)
+    @Log(title = "化学品申购", businessType = BusinessType.INSERT)
+    @PostMapping("/myadd")
+    public ResultData myadd(@RequestBody ActHxpapplyVo actHxpapplyVo)
+    {
+        return ResultData.result(actHxpapplyService.insertActHxpapply(actHxpapplyVo));
+    }
+
+    /**
+     * 修改化学品申购
+     */
+    @ApiOperation(value = "修改化学品申购")
+//    @PreAuthorize(hasPermi = "laboratory:hxpapply:edit")
+    @Log(title = "化学品申购", businessType = BusinessType.UPDATE)
+    @PutMapping
+    public ResultData edit(@RequestBody ActHxpapply actHxpapply)
+    {
+        return  ResultData.result(actHxpapplyService.updateActHxpapply(actHxpapply));
+    }
+
+    /**
+     * 删除化学品申购
+     */
+    @ApiOperation(value = "删除化学品申购")
+    @PreAuthorize(hasPermi = PerPrefix.ACT_HXP_APPLY+ PerFun.REMOVE)
+    @Log(title = "化学品申购", businessType = BusinessType.DELETE)
+	@DeleteMapping("/{ids}")
+    public ResultData remove(@PathVariable Long[] ids)
+    {
+        return ResultData.result(actHxpapplyService.deleteActHxpapplyByIds(ids));
+    }
+
+
+    /**
+     * 删除化学品申购(学生端接口)
+     */
+    @ApiOperation(value = "删除化学品申购(学生端接口)")
+    @PreAuthorize(hasPermi = PerPrefix.ACT_HXP_MYAPPLY+ PerFun.REMOVE)
+    @Log(title = "化学品申购", businessType = BusinessType.DELETE)
+    @DeleteMapping("/myDel/{ids}")
+    public ResultData myDel(@PathVariable Long[] ids)
+    {
+        return ResultData.result(actHxpapplyService.deleteActHxpapplyByIds(ids));
+    }
+
+
+    /**
+     * 获取化学品剩余可存放量
+     */
+    @ApiOperation(value = "获取化学品剩余可存放量")
+    @GetMapping(value = "/getRestStock")
+    public ResultData<Map <String, String>> getRestStock(ActRestStockVo actRestStockVo)
+    {
+        return ResultData.success(actHxpapplyService.getRestStock(actRestStockVo));
+    }
+
+
+    /**
+     * 获取化学品剩余可存放量（化学品存放用，一个化学品多个机柜用）
+     */
+    @ApiOperation(value = "获取化学品剩余可存放量")
+    @GetMapping(value = "/getRestStockByManyCabinet")
+    public ResultData<List<ActRestStockManyVo>> getRestStockByManyCabinet(ActRestStockManySearch actRestStockVo)
+    {
+        return ResultData.success(actHxpapplyService.getRestStockByManyCabinet(actRestStockVo));
+    }
+}

zd-modules/zd-chemical/src/main/java/com/zd/chemical/controller/ActHxpapplyDetailController.java

@@ -0,0 +1,116 @@
+package com.zd.chemical.controller;
+
+import java.util.List;
+import java.io.IOException;
+import javax.servlet.http.HttpServletResponse;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import com.zd.common.response.ResultData;
+import com.zd.common.log.annotation.Log;
+import com.zd.common.log.enums.BusinessType;
+import com.zd.common.security.annotation.PreAuthorize;
+import com.zd.chemical.domain.ActHxpapplyDetail;
+import com.zd.chemical.service.IActHxpapplyDetailService;
+import com.zd.common.core.web.controller.BaseController;
+import com.zd.common.core.web.domain.AjaxResult;
+import com.zd.common.core.utils.poi.ExcelUtil;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+
+import com.zd.common.core.web.page.TableDataInfo;
+
+/**
+ * 化学品申购详情Controller
+ *
+ * @author zd
+ * @date 2022-08-17
+ */
+@RestController
+@Api(tags = "【化学品申购详情】")
+@RequestMapping("/hxpapplyDetail")
+public class ActHxpapplyDetailController extends BaseController<ActHxpapplyDetail>
+{
+    @Autowired
+    private IActHxpapplyDetailService actHxpapplyDetailService;
+
+    /**
+     * 查询化学品申购详情列表
+     */
+//    @PreAuthorize(hasPermi = "laboratory:detail:list")
+    @GetMapping("/list")
+    @ApiOperation(value = "查询化学品申购详情列表")
+    public TableDataInfo<ActHxpapplyDetail> list(ActHxpapplyDetail actHxpapplyDetail)
+    {
+        startPage();
+        List<ActHxpapplyDetail> list = actHxpapplyDetailService.selectActHxpapplyDetailList(actHxpapplyDetail);
+        return getDataTable(list);
+    }
+
+    /**
+     * 导出化学品申购详情列表
+     */
+    @ApiOperation(value = "导出化学品申购详情列表")
+//    @PreAuthorize(hasPermi = "laboratory:detail:export")
+    @Log(title = "化学品申购详情", businessType = BusinessType.EXPORT)
+    @PostMapping("/export")
+    public void export(HttpServletResponse response, ActHxpapplyDetail actHxpapplyDetail) throws IOException
+    {
+        List<ActHxpapplyDetail> list = actHxpapplyDetailService.selectActHxpapplyDetailList(actHxpapplyDetail);
+        ExcelUtil<ActHxpapplyDetail> util = new ExcelUtil<ActHxpapplyDetail>(ActHxpapplyDetail.class);
+        util.exportExcel(response, list, "化学品申购详情数据");
+    }
+
+    /**
+     * 获取化学品申购详情详细信息
+     */
+    @ApiOperation(value = "获取化学品申购详情详细信息")
+//    @PreAuthorize(hasPermi = "laboratory:detail:query")
+    @GetMapping(value = "/{id}")
+    public ResultData<ActHxpapplyDetail> getInfo(@PathVariable("id") Long id)
+    {
+        return ResultData.success(actHxpapplyDetailService.selectActHxpapplyDetailById(id));
+    }
+
+    /**
+     * 新增化学品申购详情
+     */
+    @ApiOperation(value = "新增化学品申购详情")
+//    @PreAuthorize(hasPermi = "laboratory:detail:add")
+    @Log(title = "化学品申购详情", businessType = BusinessType.INSERT)
+    @PostMapping
+    public ResultData add(@RequestBody ActHxpapplyDetail actHxpapplyDetail)
+    {
+        return ResultData.result(actHxpapplyDetailService.insertActHxpapplyDetail(actHxpapplyDetail));
+    }
+
+    /**
+     * 修改化学品申购详情
+     */
+    @ApiOperation(value = "修改化学品申购详情")
+//    @PreAuthorize(hasPermi = "laboratory:detail:edit")
+    @Log(title = "化学品申购详情", businessType = BusinessType.UPDATE)
+    @PutMapping
+    public ResultData edit(@RequestBody ActHxpapplyDetail actHxpapplyDetail)
+    {
+        return  ResultData.result(actHxpapplyDetailService.updateActHxpapplyDetail(actHxpapplyDetail));
+    }
+
+    /**
+     * 删除化学品申购详情
+     */
+    @ApiOperation(value = "删除化学品申购详情")
+//    @PreAuthorize(hasPermi = "laboratory:detail:remove")
+    @Log(title = "化学品申购详情", businessType = BusinessType.DELETE)
+	@DeleteMapping("/{ids}")
+    public ResultData remove(@PathVariable Long[] ids)
+    {
+        return ResultData.result(actHxpapplyDetailService.deleteActHxpapplyDetailByIds(ids));
+    }
+}

zd-modules/zd-chemical/src/main/java/com/zd/chemical/controller/HxpChemicalController.java

@@ -174,6 +174,17 @@ public class HxpChemicalController extends BaseController {
         return ResultData.success(hxpChemicalService.selectHxpChemicalById(id));
     }
 
+
+    /**
+     * 获取化学品信息详细信息(学生端专用)
+     */
+    @ApiOperation(value = "获取化学品信息详细信息(学生端专用)")
+    @PreAuthorize(hasPermi = PerPrefix.HPX_CHEMICAL+PerFun.QUERY)
+    @GetMapping(value = "/myInfo/{id}")
+    public ResultData<HxpChemical> myInfo(@PathVariable("id") Long id) {
+        return ResultData.success(hxpChemicalService.selectHxpChemicalById(id));
+    }
+
     /**
      * 新增化学品信息
      */
@@ -224,4 +235,16 @@ public class HxpChemicalController extends BaseController {
         }
         return ResultData.result(hxpChemicalService.deleteHxpChemicalByIds(ids));
     }
+
+
+    /**
+     * 查询化学品信息列表
+     */
+    @GetMapping("/noAuthlist")
+    @ApiOperation(value = "查询化学品信息列表")
+    public TableDataInfo<HxpChemicalVo> noAuthlist(HxpChemicalSearch hxpChemicalSearch) {
+        startPage();
+        List<HxpChemicalVo> list = hxpChemicalService.selectHxpChemicalList(hxpChemicalSearch);
+        return getDataTable(list);
+    }
 }

zd-modules/zd-chemical/src/main/java/com/zd/chemical/domain/ActApplytask.java

@@ -0,0 +1,67 @@
+package com.zd.chemical.domain;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.zd.common.core.annotation.Excel;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
+import lombok.experimental.Accessors;
+import org.hibernate.validator.constraints.Length;
+import com.zd.common.core.web.domain.BaseEntity;
+
+import java.util.Date;
+
+/**
+ * 化学品申购任务对象 act_applytask
+ *
+ * @author zd
+ * @date 2022-08-17
+ */
+@ApiModel("化学品申购任务")
+@Data
+@Accessors(chain = true)
+@ToString(callSuper = true)
+@EqualsAndHashCode(callSuper = false)
+public class ActApplytask extends BaseEntity
+{
+    private static final long serialVersionUID = 1L;
+
+    /** 主键id */
+    @ApiModelProperty(value = "${comment}")
+    private Long id;
+    /** 规则因子对应的申请表id。 */
+    @Excel(name = "规则因子对应的申请表id。")
+    @ApiModelProperty(value = "规则因子对应的申请表id。")
+    private Long taskId;
+    /** 任务名称 */
+    @Excel(name = "任务名称")
+    @Length(message = "任务名称长度不能超过50")
+    @ApiModelProperty(value = "任务名称")
+    private String taskName;
+    /** 任务类别(1是对应的化学品申请) 目前只有这个，后期可以扩加 */
+    @Excel(name = "任务类别(1是对应的化学品申请) 目前只有这个，后期可以扩加")
+    @ApiModelProperty(value = "任务类别(1是对应的化学品申请) 目前只有这个，后期可以扩加")
+    private Integer taskType;
+    /** 记录当前步数，用于后期图形化展示 */
+    @Excel(name = "记录当前步数，用于后期图形化展示")
+    @ApiModelProperty(value = "记录当前步数，用于后期图形化展示")
+    private Long nowStep;
+    /** 记录下一步，用于环节审批提前预知，如无下一步，那么返回-1做记录 */
+    @Excel(name = "记录下一步，用于环节审批提前预知，如无下一步，那么返回-1做记录")
+    @ApiModelProperty(value = "记录下一步，用于环节审批提前预知，如无下一步，那么返回-1做记录")
+    private Long nextStep;
+    /** 审批状态（0是审批中，1是审批通过，2是审批拒绝） */
+    @Excel(name = "审批状态（0是审批中，1是审批通过，2是审批拒绝）")
+    @ApiModelProperty(value = "审批状态（0是审批中，1是审批通过，2是审批拒绝）")
+    private Integer approvalStatus;
+
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private Date overTime;
+
+    /** 拒绝审批内容 */
+    @Excel(name = "拒绝审批内容")
+    @ApiModelProperty(value = "拒绝审批内容")
+    private String refuseContent;
+}

zd-modules/zd-chemical/src/main/java/com/zd/chemical/domain/ActApplytaskNode.java

@@ -0,0 +1,67 @@
+package com.zd.chemical.domain;
+
+import com.zd.common.core.annotation.Excel;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
+import lombok.experimental.Accessors;
+import org.hibernate.validator.constraints.Length;
+import com.zd.common.core.web.domain.BaseEntity;
+
+/**
+ * 化学品申购任务节点对象 act_applytask_node
+ *
+ * @author zd
+ * @date 2022-08-17
+ */
+@ApiModel("化学品申购任务节点")
+@Data
+@Accessors(chain = true)
+@ToString(callSuper = true)
+@EqualsAndHashCode(callSuper = false)
+public class ActApplytaskNode extends BaseEntity
+{
+    private static final long serialVersionUID = 1L;
+
+    /** 主键id */
+    @ApiModelProperty(value = "${comment}")
+    private Long id;
+    /** 任务节点名称（目前可能不用） */
+    @Excel(name = "任务节点名称", readConverterExp = "目=前可能不用")
+    @Length(message = "任务节点名称长度不能超过50")
+    @ApiModelProperty(value = "任务节点名称")
+    private String nodeName;
+    /** 任务id */
+    @Excel(name = "任务id")
+    @ApiModelProperty(value = "任务id")
+    private Long applytaskId;
+    /** 审批配置表的id */
+    @Excel(name = "审批配置表的id")
+    @ApiModelProperty(value = "审批配置表的id")
+    private Long auditconfigId;
+    /** 审批人的用户id，有可能是多个用户 */
+    @Excel(name = "审批人的用户id，有可能是多个用户")
+    @Length(message = "审批人的用户id，有可能是多个用户长度不能超过200")
+    @ApiModelProperty(value = "审批人的用户id，有可能是多个用户")
+    private String applyUserIds;
+    /** 审批状态（1是审批通过，0是未审批，2是审批驳回） */
+    @Excel(name = "审批状态", readConverterExp = "1=是审批通过，0是未审批，2是审批驳回")
+    @ApiModelProperty(value = "审批状态")
+    private Integer nodeStatus;
+    /** 审批内容 */
+    @Excel(name = "审批内容")
+    @Length(message = "审批内容长度不能超过200")
+    @ApiModelProperty(value = "审批内容")
+    private String nodeContent;
+    /** 任务节点顺序 */
+    @Excel(name = "任务节点顺序")
+    @ApiModelProperty(value = "任务节点顺序")
+    private Integer nodeOrder;
+    /** 审批人id */
+    @Excel(name = "审批人id")
+    @ApiModelProperty(value = "审批人id")
+    private Long applyUserid;
+
+}

zd-modules/zd-chemical/src/main/java/com/zd/chemical/domain/ActAuditconfig.java

@@ -0,0 +1,37 @@
+package com.zd.chemical.domain;
+
+import com.zd.common.core.annotation.Excel;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
+import lombok.experimental.Accessors;
+import org.hibernate.validator.constraints.Length;
+import com.zd.common.core.web.domain.BaseEntity;
+
+/**
+ * 工作流审批对象 act_auditconfig
+ *
+ * @author zd
+ * @date 2022-08-16
+ */
+@ApiModel("工作流审批")
+@Data
+@Accessors(chain = true)
+@ToString(callSuper = true)
+@EqualsAndHashCode(callSuper = false)
+public class ActAuditconfig extends BaseEntity
+{
+    private static final long serialVersionUID = 1L;
+
+    /** 自增主键 */
+    @ApiModelProperty(value = "${comment}")
+    private Long id;
+    /** 审批类型（1是依次审批，2是或签） */
+    @Excel(name = "审批类型", readConverterExp = "1=是依次审批，2是或签")
+    @ApiModelProperty(value = "审批类型")
+    private Integer auditType;
+    @ApiModelProperty(value = "审批配置表状态，1是正常，2是已经废弃，废弃的不影响历史使用")
+    private Integer auditStatus;
+}

zd-modules/zd-chemical/src/main/java/com/zd/chemical/domain/ActAudituser.java

@@ -0,0 +1,45 @@
+package com.zd.chemical.domain;
+
+import com.zd.common.core.annotation.Excel;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
+import lombok.experimental.Accessors;
+import org.hibernate.validator.constraints.Length;
+import com.zd.common.core.web.domain.BaseEntity;
+
+/**
+ * 工作流审批用户对象 act_audituser
+ *
+ * @author zd
+ * @date 2022-08-16
+ */
+@ApiModel("工作流审批用户")
+@Data
+@Accessors(chain = true)
+@ToString(callSuper = true)
+@EqualsAndHashCode(callSuper = false)
+public class ActAudituser extends BaseEntity
+{
+    private static final long serialVersionUID = 1L;
+
+    /** 自增主键 */
+    @ApiModelProperty(value = "${comment}")
+    private Long id;
+    /** 工作流审批配置id */
+    @Excel(name = "工作流审批配置id")
+    @ApiModelProperty(value = "工作流审批配置id")
+    private Long configId;
+    /** 审批用户id */
+    @Excel(name = "审批用户id")
+    @ApiModelProperty(value = "审批用户id")
+    private Long auditUserId;
+    /** 审批状态（1.已审批，0是未审批） */
+    /** 审批顺序（审批的时候，根据这个字段排序。） */
+    @Excel(name = "审批顺序", readConverterExp = "审=批的时候，根据这个字段排序。")
+    @ApiModelProperty(value = "审批顺序")
+    private Integer auditOrder;
+
+}

zd-modules/zd-chemical/src/main/java/com/zd/chemical/domain/ActHxpapply.java

@@ -0,0 +1,52 @@
+package com.zd.chemical.domain;
+
+import com.zd.common.core.annotation.Excel;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
+import lombok.experimental.Accessors;
+import org.hibernate.validator.constraints.Length;
+import com.zd.common.core.web.domain.BaseEntity;
+
+/**
+ * 化学品申购对象 act_hxpapply
+ *
+ * @author zd
+ * @date 2022-08-17
+ */
+@ApiModel("化学品申购")
+@Data
+@Accessors(chain = true)
+@ToString(callSuper = true)
+@EqualsAndHashCode(callSuper = false)
+public class ActHxpapply extends BaseEntity
+{
+    private static final long serialVersionUID = 1L;
+
+    /** 主键id */
+    @ApiModelProperty(value = "${comment}")
+    private Long id;
+
+    /** 申购编号，由（年月日时分秒组成） */
+    @Excel(name = "申购编号，由（年月日时分秒组成）")
+    @ApiModelProperty(value = "申购编号，由（年月日时分秒组成）")
+    private String applyNum;
+
+    /** 申购原因 */
+    @Excel(name = "申购原因")
+    @Length(message = "申购原因长度不能超过50")
+    @ApiModelProperty(value = "申购原因")
+    private String applyReason;
+
+    /** 实验室id */
+    @Excel(name = "实验室id")
+    @ApiModelProperty(value = "实验室id")
+    private String subId;
+
+    /** 申购状态，1表示提交，2表示保存草稿 */
+    @ApiModelProperty(value = "申购状态，1表示提交，2表示保存草稿")
+    private Integer applyStatus;
+
+}

zd-modules/zd-chemical/src/main/java/com/zd/chemical/domain/ActHxpapplyDetail.java

@@ -0,0 +1,57 @@
+package com.zd.chemical.domain;
+
+import java.math.BigDecimal;
+import com.zd.common.core.annotation.Excel;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
+import lombok.experimental.Accessors;
+import org.hibernate.validator.constraints.Length;
+import com.zd.common.core.web.domain.BaseEntity;
+
+/**
+ * 化学品申购详情对象 act_hxpapply_detail
+ *
+ * @author zd
+ * @date 2022-08-17
+ */
+@ApiModel("化学品申购详情")
+@Data
+@Accessors(chain = true)
+@ToString(callSuper = true)
+@EqualsAndHashCode(callSuper = false)
+public class ActHxpapplyDetail extends BaseEntity
+{
+    private static final long serialVersionUID = 1L;
+
+    /** 主键id */
+    @ApiModelProperty(value = "${comment}")
+    private Long id;
+    /** 关联化学品申请表主键 */
+    @Excel(name = "关联化学品申请表主键")
+    @ApiModelProperty(value = "关联化学品申请表主键")
+    private Long hxpapplyId;
+    /** 化学品id */
+    @Excel(name = "化学品id")
+    @ApiModelProperty(value = "化学品id")
+    private Long chemicalId;
+    /** 化学品名称 */
+    @Excel(name = "化学品名称")
+    @Length(message = "化学品名称长度不能超过50")
+    @ApiModelProperty(value = "化学品名称")
+    private String chemicalName;
+    /** 机柜id */
+    @Excel(name = "机柜id")
+    @ApiModelProperty(value = "机柜id")
+    private Long cabinetId;
+    /** 本次申购量 */
+    @Excel(name = "本次申购量")
+    @ApiModelProperty(value = "本次申购量")
+    private BigDecimal applyNum;
+    /** 申购状态，1是勾选入库，0是未勾选 */
+    @Excel(name = "申购状态，1是勾选入库，0是未勾选")
+    @ApiModelProperty(value = "申购状态，1是勾选入库，0是未勾选")
+    private Integer tickStatus;
+}

zd-modules/zd-chemical/src/main/java/com/zd/chemical/domain/vo/ActApplytaskNodeVo.java

@@ -0,0 +1,78 @@
+package com.zd.chemical.domain.vo;
+
+import com.zd.common.core.annotation.Excel;
+import com.zd.common.core.web.domain.BaseEntity;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
+import lombok.experimental.Accessors;
+import org.hibernate.validator.constraints.Length;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 化学品申购任务节点对象 act_applytask_node
+ *
+ * @author zd
+ * @date 2022-08-17
+ */
+@ApiModel("化学品申购任务节点")
+@Data
+public class ActApplytaskNodeVo extends BaseEntity
+{
+    private static final long serialVersionUID = 1L;
+
+    /** 主键id */
+    @ApiModelProperty(value = "${comment}")
+    private Long id;
+    /** 任务节点名称（目前可能不用） */
+    @Excel(name = "任务节点名称", readConverterExp = "目=前可能不用")
+    @Length(message = "任务节点名称长度不能超过50")
+    @ApiModelProperty(value = "任务节点名称")
+    private String nodeName;
+    /** 任务id */
+    @Excel(name = "任务id")
+    @ApiModelProperty(value = "任务id")
+    private Long applytaskId;
+    /** 审批配置表的id */
+    @Excel(name = "审批配置表的id")
+    @ApiModelProperty(value = "审批配置表的id")
+    private Long auditconfigId;
+    /** 审批人的用户id，有可能是多个用户 */
+    @Excel(name = "审批人的用户id，有可能是多个用户")
+    @Length(message = "审批人的用户id，有可能是多个用户长度不能超过200")
+    @ApiModelProperty(value = "审批人的用户id，有可能是多个用户")
+    private String applyUserIds;
+    /** 审批状态（1是审批通过，0是未审批，2是审批驳回） */
+    @Excel(name = "审批状态", readConverterExp = "1=是审批通过，0是未审批，2是审批驳回")
+    @ApiModelProperty(value = "审批状态")
+    private Integer nodeStatus;
+    /** 审批内容 */
+    @Excel(name = "审批内容")
+    @Length(message = "审批内容长度不能超过200")
+    @ApiModelProperty(value = "审批内容")
+    private String nodeContent;
+    /** 任务节点顺序 */
+    @Excel(name = "任务节点顺序")
+    @ApiModelProperty(value = "任务节点顺序")
+    private Integer nodeOrder;
+    /** 审批人id */
+    @Excel(name = "审批人id")
+    @ApiModelProperty(value = "审批人id")
+    private Long applyUserid;
+
+    /** 审批人信息 */
+    @Excel(name = "审批人信息")
+    @ApiModelProperty(value = "审批人信息")
+    private String applyUserInfo;
+
+    /** 审批人信息列表 */
+    @Excel(name = "审批人信息列表")
+    @ApiModelProperty(value = "审批人信息列表")
+    private List <Map <String,String>> applyUserList = new ArrayList<>();
+
+}

zd-modules/zd-chemical/src/main/java/com/zd/chemical/domain/vo/ActApplytaskVo.java

@@ -0,0 +1,34 @@
+package com.zd.chemical.domain.vo;
+
+import com.zd.chemical.domain.ActHxpapplyDetail;
+import com.zd.common.core.annotation.Excel;
+import com.zd.common.core.web.domain.BaseEntity;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 化学品申购任务对象 act_applytask
+ *
+ * @author zd
+ * @date 2022-08-17
+ */
+@ApiModel("化学品申购任务")
+@Data
+public class ActApplytaskVo extends BaseEntity
+{
+    private static final long serialVersionUID = 1L;
+
+
+    /** 规则因子对应的申请表id。 */
+    @Excel(name = "规则因子对应的申请表id。")
+    @ApiModelProperty(value = "规则因子对应的申请表id。")
+    private Long taskId;
+
+    @ApiModelProperty(value = "化学品详细列表")
+    private List <ActHxpapplyDetail> actHxpapplyDetailList = new ArrayList<>();
+
+}

zd-modules/zd-chemical/src/main/java/com/zd/chemical/domain/vo/ActAuditconfigInfoVo.java

@@ -0,0 +1,48 @@
+package com.zd.chemical.domain.vo;
+
+import com.zd.chemical.domain.ActApplytaskNode;
+import com.zd.common.core.annotation.Excel;
+import com.zd.common.core.web.domain.BaseEntity;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
+import lombok.experimental.Accessors;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 工作流审批配置 act_auditconfig
+ *
+ * @author cyl
+ * @date 2022-08-16
+ */
+@ApiModel("工作流审批配置")
+@Data
+public class ActAuditconfigInfoVo
+{
+    private static final long serialVersionUID = 1L;
+
+    /** 自增主键 */
+    @ApiModelProperty(value = "${comment}")
+    private Long id;
+    /** 审批类型（1是依次审批，2是或签） */
+    @Excel(name = "审批类型", readConverterExp = "1=是依次审批，2是或签")
+    @ApiModelProperty(value = "审批类型")
+    private Integer auditType;
+
+    /** task审批状态(1 是通过，2是拒绝，0是待审核) */
+    @ApiModelProperty(value = "审批类型")
+    private Integer applyTaskStatus;
+
+    /** 审批拒绝原因 */
+    @ApiModelProperty(value = "审批拒绝原因")
+    private String refuseContent;
+
+    /** 审批节点 */
+    @ApiModelProperty(value = "审批节点")
+    List <ActApplytaskNodeVo> actApplytaskNodeList = new ArrayList <>();
+
+}

zd-modules/zd-chemical/src/main/java/com/zd/chemical/domain/vo/ActAuditconfigVo.java

@@ -0,0 +1,37 @@
+package com.zd.chemical.domain.vo;
+
+import com.zd.chemical.domain.ActAuditconfig;
+import com.zd.chemical.domain.ActAudituser;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Controller
+ *
+ * @author cyl
+ * @date 2022/8/17
+ */
+@ApiModel("审批配置")
+@Data
+public class ActAuditconfigVo {
+    @ApiModelProperty(value = "审批配置表id")
+    private Long id;
+
+    @ApiModelProperty(value = "审批类型（1是依次审批，2是或签）")
+    private Integer auditType;
+
+    @ApiModelProperty(value = "审批配置表状态，1是正常，0是已经废弃，废弃的不影响历史使用")
+    private Integer auditStatus;
+
+    @ApiModelProperty(value = "审批用户信息")
+    private List <ActAudituser> actAudituser = new ArrayList<>();
+
+
+    @ApiModelProperty(value = "获取配置信息里面的用户信息")
+    private List <ActAudituserVo> actAudituserInfo = new ArrayList<>();
+
+}

zd-modules/zd-chemical/src/main/java/com/zd/chemical/domain/vo/ActAudituserVo.java

@@ -0,0 +1,37 @@
+package com.zd.chemical.domain.vo;
+
+import com.zd.common.core.annotation.Excel;
+import com.zd.common.core.web.domain.BaseEntity;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
+import lombok.experimental.Accessors;
+
+/**
+ * 工作流审批用户对象 act_audituser
+ *
+ * @author zd
+ * @date 2022-08-16
+ */
+@ApiModel("工作流审批用户")
+@Data
+public class ActAudituserVo
+{
+    private static final long serialVersionUID = 1L;
+
+    /** 自增主键 */
+    @ApiModelProperty(value = "${comment}")
+    private Long id;
+    /** 审批用户id */
+    @ApiModelProperty(value = "审批用户id")
+    private Long userId;
+    /** 审批用户名字 */
+    @ApiModelProperty(value = "审批用户名字")
+    private String nickName;
+    /** 头像地址 */
+    @ApiModelProperty(value = "头像地址")
+    private String avatar;
+
+}

zd-modules/zd-chemical/src/main/java/com/zd/chemical/domain/vo/ActHxpapplyDetailVo.java

@@ -0,0 +1,84 @@
+package com.zd.chemical.domain.vo;
+
+import com.zd.common.core.annotation.Excel;
+import com.zd.common.core.web.domain.BaseEntity;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
+import lombok.experimental.Accessors;
+import org.hibernate.validator.constraints.Length;
+
+import java.math.BigDecimal;
+
+/**
+ * 化学品申购详情对象 act_hxpapply_detail
+ *
+ * @author zd
+ * @date 2022-08-17
+ */
+@ApiModel("化学品申购详情")
+@Data
+public class ActHxpapplyDetailVo extends BaseEntity
+{
+    private static final long serialVersionUID = 1L;
+
+    /** 主键id */
+    @ApiModelProperty(value = "${comment}")
+    private Long id;
+    /** 化学品id */
+    @Excel(name = "化学品id")
+    @ApiModelProperty(value = "化学品id")
+    private Long chemicalId;
+    /** 化学品名称 */
+    @Excel(name = "化学品名称")
+    @Length(message = "化学品名称长度不能超过50")
+    @ApiModelProperty(value = "化学品名称")
+    private String chemicalName;
+    /** 机柜id */
+    @Excel(name = "机柜id")
+    @ApiModelProperty(value = "机柜id")
+    private Long cabinetId;
+    /** 机柜名称 */
+    @Excel(name = "机柜名称")
+    @ApiModelProperty(value = "机柜名称")
+    private String cabinetName;
+    /** 位置 */
+    @Excel(name = "位置")
+    @ApiModelProperty(value = "位置")
+    private String posi;
+    /** 学院库存 */
+    @Excel(name = "学院库存")
+    @ApiModelProperty(value = "学院库存")
+    private String collegeInventory;
+    /** 实验室库存 */
+    @Excel(name = "实验室库存")
+    @ApiModelProperty(value = "实验室库存")
+    private String subInventory;
+    /** 化学品柜库存 */
+    @Excel(name = "化学品柜库存")
+    @ApiModelProperty(value = "化学品柜库存")
+    private String cabinetStorage;
+    /** 申购人剩余存放量 */
+    @Excel(name = "申购人剩余存放量")
+    @ApiModelProperty(value = "申购人剩余存放量")
+    private String remainingStorage;
+    /** 本次申购量 */
+    @Excel(name = "本次申购量")
+    @ApiModelProperty(value = "本次申购量")
+    private String applyNum;
+    /** 申购单位 */
+    @Excel(name = "申购单位")
+    @ApiModelProperty(value = "申购单位")
+    private String applyUnit;
+    /** 申购状态，1是勾选入库，0是未勾选 */
+    @Excel(name = "申购状态，1是勾选入库，0是未勾选")
+    @ApiModelProperty(value = "申购状态，1是勾选入库，0是未勾选")
+    private Integer tickStatus;
+
+    /** 实验室安全负责人 */
+    @ApiModelProperty(value = "实验室安全负责人")
+    private String safeUserNames;
+
+}

zd-modules/zd-chemical/src/main/java/com/zd/chemical/domain/vo/ActHxpapplyDraftsListVo.java

@@ -0,0 +1,30 @@
+package com.zd.chemical.domain.vo;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+/**
+ * Controller
+ *
+ * @author cyl
+ * @date 2022/8/19
+ */
+@Data
+public class ActHxpapplyDraftsListVo {
+
+    @ApiModelProperty(value = "申请表id")
+    private Long id;
+
+    @ApiModelProperty(value = "申请编号")
+    private String applyNum;
+
+    @ApiModelProperty(value = "实验室")
+    private String subName;
+
+    @ApiModelProperty(value = "申购信息")
+    private String chemicalNames;
+
+    @ApiModelProperty(value = "申请时间")
+    private String createTime;
+
+}

zd-modules/zd-chemical/src/main/java/com/zd/chemical/domain/vo/ActHxpapplyInfoVo.java

@@ -0,0 +1,74 @@
+package com.zd.chemical.domain.vo;
+
+import com.zd.chemical.domain.ActApplytask;
+import com.zd.chemical.domain.ActHxpapplyDetail;
+import com.zd.common.core.annotation.Excel;
+import com.zd.common.core.web.domain.BaseEntity;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
+import lombok.experimental.Accessors;
+import org.hibernate.validator.constraints.Length;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 化学品申购对象 act_hxpapply
+ *
+ * @author cyl
+ * @date 2022-08-17
+ */
+@ApiModel("化学品申请单")
+@Data
+public class ActHxpapplyInfoVo extends BaseEntity
+{
+    private static final long serialVersionUID = 1L;
+
+    /** 主键id */
+    @ApiModelProperty(value = "${comment}")
+    private Long id;
+
+    /** 申购编号，由（年月日时分秒组成） */
+    @Excel(name = "申购编号，由（年月日时分秒组成）")
+    @ApiModelProperty(value = "申购编号，由（年月日时分秒组成）")
+    private String applyNum;
+
+    /** 申购原因 */
+    @Excel(name = "申购原因")
+    @Length(message = "申购原因长度不能超过50")
+    @ApiModelProperty(value = "申购原因")
+    private String applyReason;
+
+    /** 实验室id */
+    @Excel(name = "实验室id")
+    @ApiModelProperty(value = "实验室id")
+    private Long subId;
+
+    /** 实验室名称 */
+    @Excel(name = "实验室名称")
+    @ApiModelProperty(value = "实验室名称")
+    private String subName;
+
+    private Integer approvalStatus;
+
+    /** 申购人 */
+    @ApiModelProperty(value = "申购人")
+    private String applyUserName;
+
+    /** 化学品申购详细信息 */
+    @ApiModelProperty(value = "化学品申购详细信息")
+    private List <ActHxpapplyDetailVo> actHxpapplyDetailList = new ArrayList<>();
+
+    /** 审批配置列表 */
+    @ApiModelProperty(value = "审批配置列表")
+    List <ActAuditconfigInfoVo> configInfoList = new ArrayList <>();
+
+
+    /** 审批配置列表 */
+    @ApiModelProperty(value = "审批配置列表")
+    private ActApplytask actApplytask;
+
+}

zd-modules/zd-chemical/src/main/java/com/zd/chemical/domain/vo/ActHxpapplyListVo.java

@@ -0,0 +1,74 @@
+package com.zd.chemical.domain.vo;
+
+import com.zd.common.core.annotation.Excel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+
+/**
+ * Controller
+ *
+ * @author cyl
+ * @date 2022/8/19
+ */
+@Data
+public class ActHxpapplyListVo {
+
+    @ApiModelProperty(value = "申请id")
+    private Long id;
+
+    @Excel(name = "申请编号")
+    @ApiModelProperty(value = "申请编号")
+    private String applyNum;
+
+    @Excel(name = "申购人")
+    @ApiModelProperty(value = "申购人")
+    private String subscriber;
+
+    @Excel(name = "实验室")
+    @ApiModelProperty(value = "实验室")
+    private String subName;
+
+    @Excel(name = "申购信息")
+    @ApiModelProperty(value = "申购信息")
+    private String chemicalNames;
+
+    @Excel(name = "申请时间")
+    @ApiModelProperty(value = "申请时间")
+    private String createTime;
+
+    @Excel(name = "完成时间")
+    @ApiModelProperty(value = "完成时间")
+    private String overTime;
+
+    @Excel(name = "状态")
+    @ApiModelProperty(value = "状态")
+    private String approvalContent;
+
+    @ApiModelProperty(value = "审批状态（0是审批中，1是审批通过，2是审批拒绝,3是已撤销）")
+    private Integer approvalStatus;
+
+    @Excel(name = "当前审批人")
+    @ApiModelProperty(value = "当前审批人")
+    private String currentApprover;
+
+    @Excel(name = "历史审批人")
+    @ApiModelProperty(value = "历史审批人")
+    private String historyApprover;
+
+    @ApiModelProperty(value = "当前审批人ids")
+    private String currentApproverIds;
+
+    @ApiModelProperty(value = "申请人id")
+    private String userId;
+
+    @ApiModelProperty(value = "当前审批人重组列表")
+    private List <LinkedHashMap<String,String>> currentUserList = new ArrayList <>();
+
+    @ApiModelProperty(value = "历史审批人重组列表")
+    private List <LinkedHashMap<String,String>> historyUserList = new ArrayList <>();
+
+}

zd-modules/zd-chemical/src/main/java/com/zd/chemical/domain/vo/ActHxpapplySearch.java

@@ -0,0 +1,36 @@
+package com.zd.chemical.domain.vo;
+
+import com.zd.common.core.web.domain.BaseEntity;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+/**
+ * Controller
+ *
+ * @author cyl
+ * @date 2022/8/19
+ */
+@Data
+public class ActHxpapplySearch extends BaseEntity {
+
+    @ApiModelProperty(value = "关键字搜索")
+    private String searchValue;
+
+    @ApiModelProperty(value = "状态")
+    private Integer approvalStatus;
+
+    @ApiModelProperty(value = "开始申请时间")
+    private String beginCreateTime;
+
+    @ApiModelProperty(value = "结束申请时间")
+    private String endCreateTime;
+
+    @ApiModelProperty(value = "开始完成时间")
+    private String beginOverTime;
+
+    @ApiModelProperty(value = "结束完成时间")
+    private String endOverTime;
+
+    @ApiModelProperty(value = "登录用户的id")
+    private Long loginUserId;
+}

zd-modules/zd-chemical/src/main/java/com/zd/chemical/domain/vo/ActHxpapplyVo.java

@@ -0,0 +1,50 @@
+package com.zd.chemical.domain.vo;
+
+import com.zd.chemical.domain.ActHxpapplyDetail;
+import com.zd.common.core.annotation.Excel;
+import com.zd.common.core.web.domain.BaseEntity;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
+import lombok.experimental.Accessors;
+import org.hibernate.validator.constraints.Length;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 化学品申购对象 act_hxpapply
+ *
+ * @author zd
+ * @date 2022-08-17
+ */
+@ApiModel("化学品申购")
+@Data
+@Accessors(chain = true)
+@ToString(callSuper = true)
+@EqualsAndHashCode(callSuper = false)
+public class ActHxpapplyVo extends BaseEntity
+{
+    private static final long serialVersionUID = 1L;
+
+    /** 主键id */
+    @ApiModelProperty(value = "${comment}")
+    private Long id;
+
+    /** 申购原因 */
+    @ApiModelProperty(value = "申购原因")
+    private String applyReason;
+
+    /** 实验室id */
+    @ApiModelProperty(value = "实验室id")
+    private String subId;
+
+    /** 申购状态，1表示提交，2表示保存草稿 */
+    @ApiModelProperty(value = "申购状态，1表示提交，2表示保存草稿")
+    private Integer applyStatus;
+
+    @ApiModelProperty(value = "化学品申购详情列表")
+    List <ActHxpapplyDetail> actHxpapplyDetailList = new ArrayList<>();
+}

zd-modules/zd-chemical/src/main/java/com/zd/chemical/domain/vo/ActRestStockManySearch.java

@@ -0,0 +1,23 @@
+package com.zd.chemical.domain.vo;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Controller
+ *
+ * @author cyl
+ * @date 2022/8/23
+ */
+@Data
+public class ActRestStockManySearch {
+
+    @ApiModelProperty(value = "化学品id")
+    private Long chemicalId;
+
+    @ApiModelProperty(value = "机柜列表id")
+    private List <Long> cabinetIds = new ArrayList<>();
+}

zd-modules/zd-chemical/src/main/java/com/zd/chemical/domain/vo/ActRestStockManyVo.java

@@ -0,0 +1,23 @@
+package com.zd.chemical.domain.vo;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Controller
+ *
+ * @author cyl
+ * @date 2022/8/23
+ */
+@Data
+public class ActRestStockManyVo {
+
+    @ApiModelProperty(value = "机柜id")
+    private Long cabinetId;
+
+    @ApiModelProperty(value = "返回机柜对应的剩余可存放量")
+    private String restStock;
+}

zd-modules/zd-chemical/src/main/java/com/zd/chemical/domain/vo/ActRestStockVo.java

@@ -0,0 +1,29 @@
+package com.zd.chemical.domain.vo;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+/**
+ * Controller
+ *
+ * @author cyl
+ * @date 2022/8/23
+ */
+@Data
+public class ActRestStockVo {
+
+    @ApiModelProperty(value = "部门id")
+    private Long deptId;
+
+    @ApiModelProperty(value = "实验室id")
+    private Long subId;
+
+    @ApiModelProperty(value = "化学品id")
+    private Long chemicalId;
+
+    @ApiModelProperty(value = "机柜id")
+    private Long cabinetId;
+
+    @ApiModelProperty(value = "返回统计的数据")
+    private String restStock;
+}

zd-modules/zd-chemical/src/main/java/com/zd/chemical/mapper/ActApplytaskMapper.java

@@ -0,0 +1,69 @@
+package com.zd.chemical.mapper;
+
+import java.util.List;
+import com.zd.chemical.domain.ActApplytask;
+
+/**
+ * 化学品申购任务Mapper接口
+ *
+ * @author zd
+ * @date 2022-08-17
+ */
+public interface ActApplytaskMapper
+{
+    /**
+     * 查询化学品申购任务
+     *
+     * @param id 化学品申购任务主键
+     * @return 化学品申购任务
+     */
+    ActApplytask selectActApplytaskById(Long id);
+
+    /**
+     * 查询化学品申购任务列表
+     *
+     * @param actApplytask 化学品申购任务
+     * @return 化学品申购任务集合
+     */
+    List<ActApplytask> selectActApplytaskList(ActApplytask actApplytask);
+
+    /**
+     * 根据主键集合查询化学品申购任务列表
+     *
+     * @param ids 主键集合
+     * @return 化学品申购任务集合
+     */
+    List<ActApplytask> getListByIds(List <Long> ids);
+
+    /**
+     * 新增化学品申购任务
+     *
+     * @param actApplytask 化学品申购任务
+     * @return 结果
+     */
+    int insertActApplytask(ActApplytask actApplytask);
+
+    /**
+     * 修改化学品申购任务
+     *
+     * @param actApplytask 化学品申购任务
+     * @return 结果
+     */
+    int updateActApplytask(ActApplytask actApplytask);
+
+    /**
+     * 删除化学品申购任务
+     *
+     * @param id 化学品申购任务主键
+     * @return 结果
+     */
+    int deleteActApplytaskById(Long id);
+
+    /**
+     * 批量删除化学品申购任务
+     *
+     * @param ids 需要删除的数据主键集合
+     * @return 结果
+     */
+    int deleteActApplytaskByIds(Long[] ids);
+}

zd-modules/zd-chemical/src/main/java/com/zd/chemical/mapper/ActApplytaskNodeMapper.java

@@ -0,0 +1,79 @@
+package com.zd.chemical.mapper;
+
+import java.util.List;
+import com.zd.chemical.domain.ActApplytaskNode;
+import com.zd.chemical.domain.vo.ActApplytaskNodeVo;
+
+/**
+ * 化学品申购任务节点Mapper接口
+ *
+ * @author zd
+ * @date 2022-08-17
+ */
+public interface ActApplytaskNodeMapper
+{
+    /**
+     * 查询化学品申购任务节点
+     *
+     * @param id 化学品申购任务节点主键
+     * @return 化学品申购任务节点
+     */
+    ActApplytaskNode selectActApplytaskNodeById(Long id);
+
+    /**
+     * 查询化学品申购任务节点列表
+     *
+     * @param actApplytaskNode 化学品申购任务节点
+     * @return 化学品申购任务节点集合
+     */
+    List<ActApplytaskNode> selectActApplytaskNodeList(ActApplytaskNode actApplytaskNode);
+
+
+    /**
+     * 查询化学品申购任务节点列表(包涵审批人信息)
+     *
+     * @param actApplytaskNode 化学品申购任务节点
+     * @return 化学品申购任务节点集合
+     */
+    List<ActApplytaskNodeVo> selectActApplytaskNodeInfoList(ActApplytaskNode actApplytaskNode);
+
+    /**
+     * 根据主键集合查询化学品申购任务节点列表
+     *
+     * @param ids 主键集合
+     * @return 化学品申购任务节点集合
+     */
+    List<ActApplytaskNode> getListByIds(List <Long> ids);
+
+    /**
+     * 新增化学品申购任务节点
+     *
+     * @param actApplytaskNode 化学品申购任务节点
+     * @return 结果
+     */
+    int insertActApplytaskNode(ActApplytaskNode actApplytaskNode);
+
+    /**
+     * 修改化学品申购任务节点
+     *
+     * @param actApplytaskNode 化学品申购任务节点
+     * @return 结果
+     */
+    int updateActApplytaskNode(ActApplytaskNode actApplytaskNode);
+
+    /**
+     * 删除化学品申购任务节点
+     *
+     * @param id 化学品申购任务节点主键
+     * @return 结果
+     */
+    int deleteActApplytaskNodeById(Long id);
+
+    /**
+     * 批量删除化学品申购任务节点
+     *
+     * @param ids 需要删除的数据主键集合
+     * @return 结果
+     */
+    int deleteActApplytaskNodeByIds(Long[] ids);
+}

zd-modules/zd-chemical/src/main/java/com/zd/chemical/mapper/ActAuditconfigMapper.java

@@ -0,0 +1,77 @@
+package com.zd.chemical.mapper;
+
+import java.util.List;
+import com.zd.chemical.domain.ActAuditconfig;
+
+/**
+ * 工作流审批Mapper接口
+ *
+ * @author zd
+ * @date 2022-08-16
+ */
+public interface ActAuditconfigMapper
+{
+    /**
+     * 查询工作流审批
+     *
+     * @param id 工作流审批主键
+     * @return 工作流审批
+     */
+    ActAuditconfig selectActAuditconfigById(Long id);
+
+    /**
+     * 查询工作流审批列表
+     *
+     * @param actAuditconfig 工作流审批
+     * @return 工作流审批集合
+     */
+    List<ActAuditconfig> selectActAuditconfigList(ActAuditconfig actAuditconfig);
+
+    /**
+     * 根据主键集合查询工作流审批列表
+     *
+     * @param ids 主键集合
+     * @return 工作流审批集合
+     */
+    List<ActAuditconfig> getListByIds(List <Long> ids);
+
+    /**
+     * 新增工作流审批
+     *
+     * @param actAuditconfig 工作流审批
+     * @return 结果
+     */
+    int insertActAuditconfig(ActAuditconfig actAuditconfig);
+
+    /**
+     * 修改工作流审批
+     *
+     * @param actAuditconfig 工作流审批
+     * @return 结果
+     */
+    int updateActAuditconfig(ActAuditconfig actAuditconfig);
+
+    /**
+     * 删除工作流审批
+     *
+     * @param id 工作流审批主键
+     * @return 结果
+     */
+    int deleteActAuditconfigById(Long id);
+
+    /**
+     * 批量删除工作流审批
+     *
+     * @param ids 需要删除的数据主键集合
+     * @return 结果
+     */
+    int deleteActAuditconfigByIds(Long[] ids);
+
+
+    /**
+     * 删除工作流审批
+     *
+     * @return 结果
+     */
+    int deleteActAuditconfigByAll();
+}

zd-modules/zd-chemical/src/main/java/com/zd/chemical/mapper/ActAudituserMapper.java

@@ -0,0 +1,87 @@
+package com.zd.chemical.mapper;
+
+import java.util.List;
+import com.zd.chemical.domain.ActAudituser;
+import com.zd.chemical.domain.vo.ActAudituserVo;
+
+/**
+ * 工作流审批用户Mapper接口
+ *
+ * @author zd
+ * @date 2022-08-16
+ */
+public interface ActAudituserMapper
+{
+    /**
+     * 查询工作流审批用户
+     *
+     * @param id 工作流审批用户主键
+     * @return 工作流审批用户
+     */
+    ActAudituser selectActAudituserById(Long id);
+
+    /**
+     * 查询工作流审批用户列表
+     *
+     * @param actAudituser 工作流审批用户
+     * @return 工作流审批用户集合
+     */
+    List<ActAudituser> selectActAudituserList(ActAudituser actAudituser);
+
+    /**
+     * 查询工作流审批用户列表
+     *
+     * @param actAudituser 工作流审批用户
+     * @return 工作流审批用户集合
+     */
+    List<ActAudituserVo> getActUserInfoList(ActAudituser actAudituser);
+
+
+    /**
+     * 根据主键集合查询工作流审批用户列表
+     *
+     * @param ids 主键集合
+     * @return 工作流审批用户集合
+     */
+    List<ActAudituser> getListByIds(List <Long> ids);
+
+    /**
+     * 新增工作流审批用户
+     *
+     * @param actAudituser 工作流审批用户
+     * @return 结果
+     */
+    int insertActAudituser(ActAudituser actAudituser);
+
+    /**
+     * 修改工作流审批用户
+     *
+     * @param actAudituser 工作流审批用户
+     * @return 结果
+     */
+    int updateActAudituser(ActAudituser actAudituser);
+
+    /**
+     * 删除工作流审批用户
+     *
+     * @param id 工作流审批用户主键
+     * @return 结果
+     */
+    int deleteActAudituserById(Long id);
+
+    /**
+     * 批量删除工作流审批用户
+     *
+     * @param ids 需要删除的数据主键集合
+     * @return 结果
+     */
+    int deleteActAudituserByIds(Long[] ids);
+
+
+    /**
+     * 删除工作流审批用户
+     *
+     * @return 结果
+     */
+    int deleteActAudituserByAll();
+}

zd-modules/zd-chemical/src/main/java/com/zd/chemical/mapper/ActHxpapplyDetailMapper.java

@@ -0,0 +1,87 @@
+package com.zd.chemical.mapper;
+
+import java.util.List;
+import com.zd.chemical.domain.ActHxpapplyDetail;
+import com.zd.chemical.domain.vo.ActHxpapplyDetailVo;
+
+/**
+ * 化学品申购详情Mapper接口
+ *
+ * @author zd
+ * @date 2022-08-17
+ */
+public interface ActHxpapplyDetailMapper
+{
+    /**
+     * 查询化学品申购详情
+     *
+     * @param id 化学品申购详情主键
+     * @return 化学品申购详情
+     */
+    ActHxpapplyDetail selectActHxpapplyDetailById(Long id);
+
+    /**
+     * 查询化学品申购详情列表
+     *
+     * @param actHxpapplyDetail 化学品申购详情
+     * @return 化学品申购详情集合
+     */
+    List<ActHxpapplyDetail> selectActHxpapplyDetailList(ActHxpapplyDetail actHxpapplyDetail);
+
+
+    /**
+     * 查询化学品申购详情列表
+     *
+     * @param actHxpapplyDetail 化学品申购详情
+     * @return 化学品申购详情集合
+     */
+    List<ActHxpapplyDetailVo> selectApplyDetailList(ActHxpapplyDetail actHxpapplyDetail);
+
+    /**
+     * 根据主键集合查询化学品申购详情列表
+     *
+     * @param ids 主键集合
+     * @return 化学品申购详情集合
+     */
+    List<ActHxpapplyDetail> getListByIds(List <Long> ids);
+
+    /**
+     * 新增化学品申购详情
+     *
+     * @param actHxpapplyDetail 化学品申购详情
+     * @return 结果
+     */
+    int insertActHxpapplyDetail(ActHxpapplyDetail actHxpapplyDetail);
+
+    /**
+     * 修改化学品申购详情
+     *
+     * @param actHxpapplyDetail 化学品申购详情
+     * @return 结果
+     */
+    int updateActHxpapplyDetail(ActHxpapplyDetail actHxpapplyDetail);
+
+    /**
+     * 删除化学品申购详情
+     *
+     * @param id 化学品申购详情主键
+     * @return 结果
+     */
+    int deleteActHxpapplyDetailById(Long id);
+
+    /**
+     * 删除申请单下面的化学品申购详情信息
+     *
+     * @param applyId 申请单主键
+     * @return 结果
+     */
+    int deleteActHxpapplyDetailByApplyId(Long applyId);
+
+    /**
+     * 批量删除化学品申购详情
+     *
+     * @param ids 需要删除的数据主键集合
+     * @return 结果
+     */
+    int deleteActHxpapplyDetailByIds(Long[] ids);
+}

zd-modules/zd-chemical/src/main/java/com/zd/chemical/mapper/ActHxpapplyMapper.java

@@ -0,0 +1,106 @@
+package com.zd.chemical.mapper;
+
+import java.util.List;
+import java.util.Map;
+
+import com.zd.chemical.domain.ActHxpapply;
+import com.zd.chemical.domain.vo.*;
+
+/**
+ * 化学品申购Mapper接口
+ *
+ * @author zd
+ * @date 2022-08-17
+ */
+public interface ActHxpapplyMapper
+{
+    /**
+     * 查询化学品申购
+     *
+     * @param id 化学品申购主键
+     * @return 化学品申购
+     */
+    ActHxpapplyInfoVo selectActHxpapplyById(Long id);
+
+    /**
+     * 查询化学品申购列表
+     *
+     * @param actHxpapplySearch 化学品申购
+     * @return 化学品申购集合
+     */
+    List<ActHxpapplyListVo> selectActHxpapplyList(ActHxpapplySearch actHxpapplySearch);
+
+    /**
+     * 查询化学品申购列表(草稿箱)
+     *
+     * @param actHxpapplySearch 化学品申购
+     * @return 化学品申购集合
+     */
+    List<ActHxpapplyDraftsListVo> draftsList(ActHxpapplySearch actHxpapplySearch);
+
+    /**
+     * 根据主键集合查询化学品申购列表
+     *
+     * @param ids 主键集合
+     * @return 化学品申购集合
+     */
+    List<ActHxpapply> getListByIds(List <Long> ids);
+
+    /**
+     * 新增化学品申购
+     *
+     * @param actHxpapply 化学品申购
+     * @return 结果
+     */
+    int insertActHxpapply(ActHxpapply actHxpapply);
+
+    /**
+     * 修改化学品申购
+     *
+     * @param actHxpapply 化学品申购
+     * @return 结果
+     */
+    int updateActHxpapply(ActHxpapply actHxpapply);
+
+    /**
+     * 删除化学品申购
+     *
+     * @param id 化学品申购主键
+     * @return 结果
+     */
+    int deleteActHxpapplyById(Long id);
+
+    /**
+     * 批量删除化学品申购
+     *
+     * @param ids 需要删除的数据主键集合
+     * @return 结果
+     */
+    int deleteActHxpapplyByIds(Long[] ids);
+
+
+    /**
+     * 查询化学品申购
+     *
+     * @param actRestStockVo  机柜主键
+     * @return 化学品申购
+     */
+    Map <String, String> getRestStock(ActRestStockVo actRestStockVo);
+
+    /**
+     * 查询化学品申购
+     *
+     * @param actRestStockVo  机柜主键
+     * @return 化学品申购
+     */
+    List<ActRestStockVo> getRestStockClassif(ActRestStockVo actRestStockVo);
+
+
+    /**
+     * 查询化学品申购
+     *
+     * @param actRestStockVo  机柜主键
+     * @return 化学品申购
+     */
+    List<ActRestStockManyVo> getRestStockByManyCabinet(ActRestStockManySearch actRestStockVo);
+}

zd-modules/zd-chemical/src/main/java/com/zd/chemical/service/IActApplytaskNodeService.java

@@ -0,0 +1,69 @@
+package com.zd.chemical.service;
+
+import java.util.List;
+import com.zd.chemical.domain.ActApplytaskNode;
+
+/**
+ * 化学品申购任务节点Service接口
+ *
+ * @author zd
+ * @date 2022-08-17
+ */
+public interface IActApplytaskNodeService
+{
+    /**
+     * 查询化学品申购任务节点
+     *
+     * @param id 化学品申购任务节点主键
+     * @return 化学品申购任务节点
+     */
+    ActApplytaskNode selectActApplytaskNodeById(Long id);
+
+    /**
+     * 查询化学品申购任务节点列表
+     *
+     * @param actApplytaskNode 化学品申购任务节点
+     * @return 化学品申购任务节点集合
+     */
+    List<ActApplytaskNode> selectActApplytaskNodeList(ActApplytaskNode actApplytaskNode);
+
+    /**
+     * 根据主键集合查询化学品申购任务节点列表
+     *
+     * @param ids 主键集合
+     * @return 化学品申购任务节点集合
+     */
+    List<ActApplytaskNode> getListByIds(List <Long> ids);
+
+    /**
+     * 新增化学品申购任务节点
+     *
+     * @param actApplytaskNode 化学品申购任务节点
+     * @return 结果
+     */
+    int insertActApplytaskNode(ActApplytaskNode actApplytaskNode);
+
+    /**
+     * 修改化学品申购任务节点
+     *
+     * @param actApplytaskNode 化学品申购任务节点
+     * @return 结果
+     */
+    int updateActApplytaskNode(ActApplytaskNode actApplytaskNode);
+
+    /**
+     * 批量删除化学品申购任务节点
+     *
+     * @param ids 需要删除的化学品申购任务节点主键集合
+     * @return 结果
+     */
+    int deleteActApplytaskNodeByIds(Long[] ids);
+
+    /**
+     * 删除化学品申购任务节点信息
+     *
+     * @param id 化学品申购任务节点主键
+     * @return 结果
+     */
+    int deleteActApplytaskNodeById(Long id);
+}

zd-modules/zd-chemical/src/main/java/com/zd/chemical/service/IActApplytaskService.java

@@ -0,0 +1,95 @@
+package com.zd.chemical.service;
+
+import java.util.List;
+import com.zd.chemical.domain.ActApplytask;
+import com.zd.chemical.domain.vo.ActApplytaskVo;
+
+/**
+ * 化学品申购任务Service接口
+ *
+ * @author zd
+ * @date 2022-08-17
+ */
+public interface IActApplytaskService
+{
+    /**
+     * 查询化学品申购任务
+     *
+     * @param id 化学品申购任务主键
+     * @return 化学品申购任务
+     */
+    ActApplytask selectActApplytaskById(Long id);
+
+    /**
+     * 查询化学品申购任务列表
+     *
+     * @param actApplytask 化学品申购任务
+     * @return 化学品申购任务集合
+     */
+    List<ActApplytask> selectActApplytaskList(ActApplytask actApplytask);
+
+    /**
+     * 根据主键集合查询化学品申购任务列表
+     *
+     * @param ids 主键集合
+     * @return 化学品申购任务集合
+     */
+    List<ActApplytask> getListByIds(List <Long> ids);
+
+    /**
+     * 新增化学品申购任务
+     *
+     * @param actApplytask 化学品申购任务
+     * @return 结果
+     */
+    int insertActApplytask(ActApplytask actApplytask);
+
+    /**
+     * 修改化学品申购任务
+     *
+     * @param actApplytask 化学品申购任务
+     * @return 结果
+     */
+    int updateActApplytask(ActApplytask actApplytask);
+
+    /**
+     * 批量删除化学品申购任务
+     *
+     * @param ids 需要删除的化学品申购任务主键集合
+     * @return 结果
+     */
+    int deleteActApplytaskByIds(Long[] ids);
+
+    /**
+     * 删除化学品申购任务信息
+     *
+     * @param id 化学品申购任务主键
+     * @return 结果
+     */
+    int deleteActApplytaskById(Long id);
+
+
+    /**
+     * 工作流节点审批
+     *
+     * @param actApplytaskVo 化学品申购任务
+     * @return 结果
+     */
+    int approvalTask(ActApplytaskVo actApplytaskVo);
+
+    /**
+     * 工作流节点审批(拒绝)
+     *
+     * @param actApplytask 化学品申购任务(拒绝)
+     * @return 结果
+     */
+    int approvalRefuse(ActApplytask actApplytask);
+
+    /**
+     * 工作流节点审批(撤销)
+     *
+     * @param actApplytask 化学品申购任务(撤销)
+     * @return 结果
+     */
+    int approvalRevoke(ActApplytask actApplytask);
+}

zd-modules/zd-chemical/src/main/java/com/zd/chemical/service/IActAuditconfigService.java

@@ -0,0 +1,78 @@
+package com.zd.chemical.service;
+
+import java.util.List;
+import com.zd.chemical.domain.ActAuditconfig;
+import com.zd.chemical.domain.vo.ActAuditconfigVo;
+
+/**
+ * 工作流审批Service接口
+ *
+ * @author zd
+ * @date 2022-08-16
+ */
+public interface IActAuditconfigService
+{
+    /**
+     * 查询工作流审批
+     *
+     * @param id 工作流审批主键
+     * @return 工作流审批
+     */
+    ActAuditconfig selectActAuditconfigById(Long id);
+
+    /**
+     * 查询工作流审批列表
+     *
+     * @param actAuditconfig 工作流审批
+     * @return 工作流审批集合
+     */
+    List<ActAuditconfig> selectActAuditconfigList(ActAuditconfig actAuditconfig);
+
+    /**
+     * 查询工作流审批列表
+     *
+     * @param actAuditconfig 工作流审批
+     * @return 工作流审批集合
+     */
+    List<ActAuditconfigVo> getConfigList(ActAuditconfig actAuditconfig);
+
+    /**
+     * 根据主键集合查询工作流审批列表
+     *
+     * @param ids 主键集合
+     * @return 工作流审批集合
+     */
+    List<ActAuditconfig> getListByIds(List <Long> ids);
+
+    /**
+     * 新增工作流审批
+     *
+     * @param actAuditconfigList 工作流审批
+     * @return 结果
+     */
+    int insertActAuditconfig(List<ActAuditconfigVo> actAuditconfigList);
+
+    /**
+     * 修改工作流审批
+     *
+     * @param actAuditconfig 工作流审批
+     * @return 结果
+     */
+    int updateActAuditconfig(ActAuditconfig actAuditconfig);
+
+    /**
+     * 批量删除工作流审批
+     *
+     * @param ids 需要删除的工作流审批主键集合
+     * @return 结果
+     */
+    int deleteActAuditconfigByIds(Long[] ids);
+
+    /**
+     * 删除工作流审批信息
+     *
+     * @param id 工作流审批主键
+     * @return 结果
+     */
+    int deleteActAuditconfigById(Long id);
+}

zd-modules/zd-chemical/src/main/java/com/zd/chemical/service/IActAudituserService.java

@@ -0,0 +1,69 @@
+package com.zd.chemical.service;
+
+import java.util.List;
+import com.zd.chemical.domain.ActAudituser;
+
+/**
+ * 工作流审批用户Service接口
+ *
+ * @author zd
+ * @date 2022-08-16
+ */
+public interface IActAudituserService
+{
+    /**
+     * 查询工作流审批用户
+     *
+     * @param id 工作流审批用户主键
+     * @return 工作流审批用户
+     */
+    ActAudituser selectActAudituserById(Long id);
+
+    /**
+     * 查询工作流审批用户列表
+     *
+     * @param actAudituser 工作流审批用户
+     * @return 工作流审批用户集合
+     */
+    List<ActAudituser> selectActAudituserList(ActAudituser actAudituser);
+
+    /**
+     * 根据主键集合查询工作流审批用户列表
+     *
+     * @param ids 主键集合
+     * @return 工作流审批用户集合
+     */
+    List<ActAudituser> getListByIds(List <Long> ids);
+
+    /**
+     * 新增工作流审批用户
+     *
+     * @param actAudituser 工作流审批用户
+     * @return 结果
+     */
+    int insertActAudituser(ActAudituser actAudituser);
+
+    /**
+     * 修改工作流审批用户
+     *
+     * @param actAudituser 工作流审批用户
+     * @return 结果
+     */
+    int updateActAudituser(ActAudituser actAudituser);
+
+    /**
+     * 批量删除工作流审批用户
+     *
+     * @param ids 需要删除的工作流审批用户主键集合
+     * @return 结果
+     */
+    int deleteActAudituserByIds(Long[] ids);
+
+    /**
+     * 删除工作流审批用户信息
+     *
+     * @param id 工作流审批用户主键
+     * @return 结果
+     */
+    int deleteActAudituserById(Long id);
+}

zd-modules/zd-chemical/src/main/java/com/zd/chemical/service/IActHxpapplyDetailService.java

@@ -0,0 +1,69 @@
+package com.zd.chemical.service;
+
+import java.util.List;
+import com.zd.chemical.domain.ActHxpapplyDetail;
+
+/**
+ * 化学品申购详情Service接口
+ *
+ * @author zd
+ * @date 2022-08-17
+ */
+public interface IActHxpapplyDetailService
+{
+    /**
+     * 查询化学品申购详情
+     *
+     * @param id 化学品申购详情主键
+     * @return 化学品申购详情
+     */
+    ActHxpapplyDetail selectActHxpapplyDetailById(Long id);
+
+    /**
+     * 查询化学品申购详情列表
+     *
+     * @param actHxpapplyDetail 化学品申购详情
+     * @return 化学品申购详情集合
+     */
+    List<ActHxpapplyDetail> selectActHxpapplyDetailList(ActHxpapplyDetail actHxpapplyDetail);
+
+    /**
+     * 根据主键集合查询化学品申购详情列表
+     *
+     * @param ids 主键集合
+     * @return 化学品申购详情集合
+     */
+    List<ActHxpapplyDetail> getListByIds(List <Long> ids);
+
+    /**
+     * 新增化学品申购详情
+     *
+     * @param actHxpapplyDetail 化学品申购详情
+     * @return 结果
+     */
+    int insertActHxpapplyDetail(ActHxpapplyDetail actHxpapplyDetail);
+
+    /**
+     * 修改化学品申购详情
+     *
+     * @param actHxpapplyDetail 化学品申购详情
+     * @return 结果
+     */
+    int updateActHxpapplyDetail(ActHxpapplyDetail actHxpapplyDetail);
+
+    /**
+     * 批量删除化学品申购详情
+     *
+     * @param ids 需要删除的化学品申购详情主键集合
+     * @return 结果
+     */
+    int deleteActHxpapplyDetailByIds(Long[] ids);
+
+    /**
+     * 删除化学品申购详情信息
+     *
+     * @param id 化学品申购详情主键
+     * @return 结果
+     */
+    int deleteActHxpapplyDetailById(Long id);
+}

zd-modules/zd-chemical/src/main/java/com/zd/chemical/service/IActHxpapplyService.java

@@ -0,0 +1,98 @@
+package com.zd.chemical.service;
+
+import java.math.BigDecimal;
+import java.util.List;
+import java.util.Map;
+
+import com.zd.chemical.domain.ActHxpapply;
+import com.zd.chemical.domain.vo.*;
+
+/**
+ * 化学品申购Service接口
+ *
+ * @author zd
+ * @date 2022-08-17
+ */
+public interface IActHxpapplyService
+{
+    /**
+     * 查询化学品申购
+     *
+     * @param id 化学品申购主键
+     * @return 化学品申购
+     */
+    ActHxpapplyInfoVo selectActHxpapplyById(Long id,Integer tickStatus);
+
+    /**
+     * 查询化学品申购列表
+     *
+     * @param actHxpapplySearch 化学品申购
+     * @return 化学品申购集合
+     */
+    List<ActHxpapplyListVo> selectActHxpapplyList(ActHxpapplySearch actHxpapplySearch);
+
+    /**
+     * 查询化学品申购列表(草稿箱)
+     *
+     * @param actHxpapplySearch 化学品申购
+     * @return 化学品申购集合
+     */
+    List<ActHxpapplyDraftsListVo> draftsList(ActHxpapplySearch actHxpapplySearch);
+
+    /**
+     * 根据主键集合查询化学品申购列表
+     *
+     * @param ids 主键集合
+     * @return 化学品申购集合
+     */
+    List<ActHxpapply> getListByIds(List <Long> ids);
+
+    /**
+     * 新增化学品申购
+     *
+     * @param actHxpapplyVo 化学品申购
+     * @return 结果
+     */
+    int insertActHxpapply(ActHxpapplyVo actHxpapplyVo);
+
+    /**
+     * 修改化学品申购
+     *
+     * @param actHxpapply 化学品申购
+     * @return 结果
+     */
+    int updateActHxpapply(ActHxpapply actHxpapply);
+
+    /**
+     * 批量删除化学品申购
+     *
+     * @param ids 需要删除的化学品申购主键集合
+     * @return 结果
+     */
+    int deleteActHxpapplyByIds(Long[] ids);
+
+    /**
+     * 删除化学品申购信息
+     *
+     * @param id 化学品申购主键
+     * @return 结果
+     */
+    int deleteActHxpapplyById(Long id);
+
+
+    /**
+     * 获取化学品剩余可存放量
+     *
+     * @param actRestStockVo 机柜主键主键
+     * @return 化学品申购
+     */
+    Map <String, String> getRestStock(ActRestStockVo actRestStockVo);
+
+    /**
+     * 获取化学品剩余可存放量
+     *
+     * @param actRestStockVo 机柜主键主键
+     * @return 化学品申购
+     */
+    List<ActRestStockManyVo> getRestStockByManyCabinet(ActRestStockManySearch actRestStockVo);
+}

zd-modules/zd-chemical/src/main/java/com/zd/chemical/service/impl/ActApplytaskNodeServiceImpl.java

@@ -0,0 +1,107 @@
+package com.zd.chemical.service.impl;
+
+import java.util.ArrayList;
+import java.util.List;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import com.zd.chemical.mapper.ActApplytaskNodeMapper;
+import com.zd.chemical.domain.ActApplytaskNode;
+import com.zd.chemical.service.IActApplytaskNodeService;
+
+/**
+ * 化学品申购任务节点Service业务层处理
+ *
+ * @author zd
+ * @date 2022-08-17
+ */
+@Service
+public class ActApplytaskNodeServiceImpl implements IActApplytaskNodeService
+{
+    @Autowired
+    private ActApplytaskNodeMapper actApplytaskNodeMapper;
+
+    /**
+     * 查询化学品申购任务节点
+     *
+     * @param id 化学品申购任务节点主键
+     * @return 化学品申购任务节点
+     */
+    @Override
+    public ActApplytaskNode selectActApplytaskNodeById(Long id)
+    {
+        return actApplytaskNodeMapper.selectActApplytaskNodeById(id);
+    }
+
+    /**
+     * 查询化学品申购任务节点列表
+     *
+     * @param actApplytaskNode 化学品申购任务节点
+     * @return 化学品申购任务节点
+     */
+    @Override
+    public List<ActApplytaskNode> selectActApplytaskNodeList(ActApplytaskNode actApplytaskNode)
+    {
+        return actApplytaskNodeMapper.selectActApplytaskNodeList(actApplytaskNode);
+    }
+
+    @Override
+    public List<ActApplytaskNode> getListByIds(List<Long> ids){
+        if (ids.isEmpty()){
+            new ArrayList <>();
+        }
+        return actApplytaskNodeMapper.getListByIds(ids);
+    }
+
+    /**
+     * 新增化学品申购任务节点
+     *
+     * @param actApplytaskNode 化学品申购任务节点
+     * @return 结果
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public int insertActApplytaskNode(ActApplytaskNode actApplytaskNode)
+    {
+        return actApplytaskNodeMapper.insertActApplytaskNode(actApplytaskNode);
+    }
+
+    /**
+     * 修改化学品申购任务节点
+     *
+     * @param actApplytaskNode 化学品申购任务节点
+     * @return 结果
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public int updateActApplytaskNode(ActApplytaskNode actApplytaskNode)
+    {
+        return actApplytaskNodeMapper.updateActApplytaskNode(actApplytaskNode);
+    }
+
+    /**
+     * 批量删除化学品申购任务节点
+     *
+     * @param ids 需要删除的化学品申购任务节点主键
+     * @return 结果
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public int deleteActApplytaskNodeByIds(Long[] ids)
+    {
+        return actApplytaskNodeMapper.deleteActApplytaskNodeByIds(ids);
+    }
+
+    /**
+     * 删除化学品申购任务节点信息
+     *
+     * @param id 化学品申购任务节点主键
+     * @return 结果
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public int deleteActApplytaskNodeById(Long id)
+    {
+        return actApplytaskNodeMapper.deleteActApplytaskNodeById(id);
+    }
+}

zd-modules/zd-chemical/src/main/java/com/zd/chemical/service/impl/ActApplytaskServiceImpl.java

@@ -0,0 +1,303 @@
+package com.zd.chemical.service.impl;
+
+import java.util.*;
+import java.util.concurrent.atomic.LongAdder;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+
+import com.alibaba.nacos.shaded.org.checkerframework.checker.nullness.Opt;
+import com.zd.chemical.domain.ActApplytaskNode;
+import com.zd.chemical.domain.ActHxpapply;
+import com.zd.chemical.domain.ActHxpapplyDetail;
+import com.zd.chemical.domain.vo.ActApplytaskVo;
+import com.zd.chemical.domain.vo.ActHxpapplyInfoVo;
+import com.zd.chemical.mapper.ActApplytaskNodeMapper;
+import com.zd.chemical.mapper.ActHxpapplyDetailMapper;
+import com.zd.chemical.mapper.ActHxpapplyMapper;
+import com.zd.common.core.exception.ServiceException;
+import com.zd.common.core.utils.DateUtils;
+import com.zd.common.core.utils.SecurityUtils;
+import com.zd.common.core.utils.StringUtils;
+import com.zd.common.security.utils.SaveUtil;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import com.zd.chemical.mapper.ActApplytaskMapper;
+import com.zd.chemical.domain.ActApplytask;
+import com.zd.chemical.service.IActApplytaskService;
+
+/**
+ * 化学品申购任务Service业务层处理
+ *
+ * @author zd
+ * @date 2022-08-17
+ */
+@Service
+public class ActApplytaskServiceImpl implements IActApplytaskService
+{
+    @Autowired
+    private ActApplytaskMapper actApplytaskMapper;
+
+    @Autowired
+    private ActApplytaskNodeMapper actApplytaskNodeMapper;
+
+    @Autowired
+    private ActHxpapplyMapper actHxpapplyMapper;
+
+    @Autowired
+    private ActHxpapplyDetailMapper actHxpapplyDetailMapper;
+
+    /**
+     * 查询化学品申购任务
+     *
+     * @param id 化学品申购任务主键
+     * @return 化学品申购任务
+     */
+    @Override
+    public ActApplytask selectActApplytaskById(Long id)
+    {
+        return actApplytaskMapper.selectActApplytaskById(id);
+    }
+
+    /**
+     * 查询化学品申购任务列表
+     *
+     * @param actApplytask 化学品申购任务
+     * @return 化学品申购任务
+     */
+    @Override
+    public List<ActApplytask> selectActApplytaskList(ActApplytask actApplytask)
+    {
+        return actApplytaskMapper.selectActApplytaskList(actApplytask);
+    }
+
+    @Override
+    public List<ActApplytask> getListByIds(List<Long> ids){
+        if (ids.isEmpty()){
+            new ArrayList <>();
+        }
+        return actApplytaskMapper.getListByIds(ids);
+    }
+
+    /**
+     * 新增化学品申购任务
+     *
+     * @param actApplytask 化学品申购任务
+     * @return 结果
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public int insertActApplytask(ActApplytask actApplytask)
+    {
+        //设置其他公共字段
+        SaveUtil.setCommonAttr(actApplytask);
+        return actApplytaskMapper.insertActApplytask(actApplytask);
+    }
+
+    /**
+     * 修改化学品申购任务
+     *
+     * @param actApplytask 化学品申购任务
+     * @return 结果
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public int updateActApplytask(ActApplytask actApplytask)
+    {
+        return actApplytaskMapper.updateActApplytask(actApplytask);
+    }
+
+    /**
+     * 批量删除化学品申购任务
+     *
+     * @param ids 需要删除的化学品申购任务主键
+     * @return 结果
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public int deleteActApplytaskByIds(Long[] ids)
+    {
+        return actApplytaskMapper.deleteActApplytaskByIds(ids);
+    }
+
+    /**
+     * 删除化学品申购任务信息
+     *
+     * @param id 化学品申购任务主键
+     * @return 结果
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public int deleteActApplytaskById(Long id)
+    {
+        return actApplytaskMapper.deleteActApplytaskById(id);
+    }
+
+
+    /**
+     * 工作流节点审批
+     *
+     * @param actApplytaskVo 化学品申购任务
+     * @return 结果
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public int approvalTask(ActApplytaskVo actApplytaskVo)
+    {
+        //根据申请单的id，查询对应的工作流
+        ActApplytask actApplytask = new ActApplytask();
+        actApplytask.setTaskId(actApplytaskVo.getTaskId());
+        List <ActApplytask> actApplytasks = actApplytaskMapper.selectActApplytaskList(actApplytask);
+        if(actApplytasks.size()>1){
+            throw new ServiceException("申请单对应的工作流task是多个，请联系管理员！！");
+        }
+        if(actApplytasks.size()==0){
+            throw new ServiceException("申请单无工作流task，请提交申请单！！");
+        }
+        ActApplytask applytask = actApplytasks.get(0);
+        ActApplytaskNode actApplytaskNode = new ActApplytaskNode();
+        actApplytaskNode.setApplytaskId(applytask.getId());
+        actApplytaskNode.setNodeStatus(0);
+        List<ActApplytaskNode> taskNodeList = actApplytaskNodeMapper.selectActApplytaskNodeList(actApplytaskNode);
+        //查询申请表的信息
+        ActHxpapplyInfoVo actHxpapplyInfoVo = actHxpapplyMapper.selectActHxpapplyById(actApplytaskVo.getTaskId());
+        Map<String,Long> jumpApply = new HashMap<>();
+        jumpApply.put("jumpApply",1L);
+        Predicate<ActApplytaskNode> pre = x->Arrays.asList(x.getApplyUserIds().split(",")).stream().filter(y->Long.parseLong(y)==actHxpapplyInfoVo.getUserId()).count()>0;
+        //这里把下一步的步数给当前步数
+        applytask.setNowStep(-1L);
+        applytask.setNextStep(-1L);
+        LongAdder longAdder = new LongAdder();
+        Optional.ofNullable(taskNodeList).orElseGet(Collections::emptyList)
+                .stream()
+                .forEach(a->{
+                    longAdder.add(1);
+                    if(longAdder.sum()==1){
+                        a.setNodeStatus(1);
+                        a.setApplyUserid(SecurityUtils.getUserId());
+                        actApplytaskNodeMapper.updateActApplytaskNode(a);
+                    }else{
+                        //todo 这里需要验证审批人是不是申请人，如果是，需要跳过
+                        if(pre.test(a)&&jumpApply.get("jumpApply")==1){
+                            jumpApply.put("jumpApply",1L);
+                            a.setNodeStatus(1);
+                            a.setApplyUserid(actHxpapplyInfoVo.getUserId());
+                            actApplytaskNodeMapper.updateActApplytaskNode(a);
+                        }else{
+                            jumpApply.put("jumpApply",2L);
+                        }
+                    }
+                });
+        //todo 调用回填步数的方法
+        int flag = proStep(applytask);
+        selectionChemical(actApplytaskVo);
+        return flag;
+    }
+
+    //todo 这里做了执行task回填步数
+    private int proStep(ActApplytask actApplytask){
+        ActApplytaskNode actApplytaskNode = new ActApplytaskNode();
+        actApplytaskNode.setNodeStatus(0);
+        actApplytaskNode.setApplytaskId(actApplytask.getId());
+        List <ActApplytaskNode> actApplytaskNodes = actApplytaskNodeMapper.selectActApplytaskNodeList(actApplytaskNode);
+        for(int i=0;i<actApplytaskNodes.size();i++){
+            if(i==0){
+                actApplytask.setNowStep(actApplytaskNodes.get(i).getId());
+            }
+            if(i==1){
+                actApplytask.setNextStep(actApplytaskNodes.get(i).getId());
+            }
+        }
+        if(actApplytaskNodes.size()==0){
+            actApplytask.setOverTime(new Date());
+            actApplytask.setApprovalStatus(1);
+        }
+        return actApplytaskMapper.updateActApplytask(actApplytask);
+    }
+
+    private void selectionChemical(ActApplytaskVo actApplytaskVo){
+        ActHxpapplyDetail actHxpapplyDetail = new ActHxpapplyDetail();
+        actHxpapplyDetail.setHxpapplyId(actApplytaskVo.getTaskId());
+        List <ActHxpapplyDetail> actHxpapplyDetails = actHxpapplyDetailMapper.selectActHxpapplyDetailList(actHxpapplyDetail);
+        Map <Long, Long> collect = actApplytaskVo.getActHxpapplyDetailList().stream().collect(Collectors.toMap(ActHxpapplyDetail::getChemicalId, ActHxpapplyDetail::getChemicalId));
+        Consumer <List <ActHxpapplyDetail>> comparator = x->x.stream().forEach(p->{
+            Predicate<Map <Long, Long>> pre = pt -> StringUtils.isNotNull(pt.get(p.getChemicalId()));
+            if(pre.test(collect)){
+                p.setTickStatus(1);
+                actHxpapplyDetailMapper.updateActHxpapplyDetail(p);
+            }else{
+                p.setTickStatus(2);
+                actHxpapplyDetailMapper.updateActHxpapplyDetail(p);
+            }
+        });
+        comparator.accept(actHxpapplyDetails);
+    }
+
+    @Override
+    public int approvalRefuse(ActApplytask actApplytask) {
+        //根据申请单的id，查询对应的工作流
+        List <ActApplytask> actApplytasks = actApplytaskMapper.selectActApplytaskList(actApplytask);
+        if(actApplytasks.size()>1){
+            throw new ServiceException("申请单对应的工作流task是多个，请联系管理员！！");
+        }
+        if(actApplytasks.size()==0){
+            throw new ServiceException("申请单无工作流task，请提交申请单！！");
+        }
+        ActApplytask applytask = actApplytasks.get(0);
+        ActApplytaskNode actApplytaskNode = new ActApplytaskNode();
+        actApplytaskNode.setApplytaskId(applytask.getId());
+        actApplytaskNode.setNodeStatus(0);
+        List<ActApplytaskNode> taskNodeList = actApplytaskNodeMapper.selectActApplytaskNodeList(actApplytaskNode);
+        //这里把下一步变成-1，审批拒绝后，没有下一步
+        applytask.setNextStep(-1L);
+        LongAdder longAdder = new LongAdder();
+        Optional.ofNullable(taskNodeList).orElseGet(Collections::emptyList)
+                .stream()
+                .forEach(a->{
+                    longAdder.add(1);
+                    if(longAdder.sum()==1){
+                        a.setNodeStatus(2);
+                        a.setApplyUserid(SecurityUtils.getUserId());
+                        a.setNodeContent(actApplytask.getRefuseContent());
+                        actApplytaskNodeMapper.updateActApplytaskNode(a);
+                    }
+                });
+        //todo 这里修改主流程的审批状态变为拒绝
+        applytask.setApprovalStatus(2);
+        applytask.setOverTime(new Date());
+        int flag = actApplytaskMapper.updateActApplytask(applytask);
+        return flag;
+    }
+
+
+
+    @Override
+    public int approvalRevoke(ActApplytask actApplytask) {
+        //根据申请单的id，查询对应的工作流
+        List <ActApplytask> actApplytasks = actApplytaskMapper.selectActApplytaskList(actApplytask);
+        if(actApplytasks.size()>1){
+            throw new ServiceException("申请单对应的工作流task是多个，请联系管理员！！");
+        }
+        if(actApplytasks.size()==0){
+            throw new ServiceException("申请单无工作流task，请提交申请单！！");
+        }
+        //这里把申请订单变为以撤销
+        ActHxpapply actHxpapply = new ActHxpapply();
+        actHxpapply.setId(actApplytask.getTaskId());
+        actHxpapply.setApplyStatus(3);
+        actHxpapplyMapper.updateActHxpapply(actHxpapply);
+        ActApplytask applytask = actApplytasks.get(0);
+        //撤销这里需要把当前步数和下一步全部置成-1
+        applytask.setNowStep(-1L);
+        applytask.setNextStep(-1L);
+
+        //todo 这里修改主流程的审批状态变为撤销
+        applytask.setApprovalStatus(3);
+        applytask.setOverTime(new Date());
+        int flag = actApplytaskMapper.updateActApplytask(applytask);
+        return flag;
+    }
+}

zd-modules/zd-chemical/src/main/java/com/zd/chemical/service/impl/ActAuditconfigServiceImpl.java

@@ -0,0 +1,177 @@
+package com.zd.chemical.service.impl;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.atomic.LongAdder;
+import java.util.stream.Collectors;
+
+import com.sun.xml.internal.bind.v2.util.CollisionCheckStack;
+import com.zd.chemical.domain.ActAudituser;
+import com.zd.chemical.domain.vo.ActAuditconfigVo;
+import com.zd.chemical.domain.vo.ActAudituserVo;
+import com.zd.chemical.mapper.ActAudituserMapper;
+import com.zd.common.core.utils.DateUtils;
+import com.zd.common.core.utils.SecurityUtils;
+import com.zd.common.security.utils.SaveUtil;
+
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import com.zd.chemical.mapper.ActAuditconfigMapper;
+import com.zd.chemical.domain.ActAuditconfig;
+import com.zd.chemical.service.IActAuditconfigService;
+
+/**
+ * 工作流审批Service业务层处理
+ *
+ * @author zd
+ * @date 2022-08-16
+ */
+@Service
+public class ActAuditconfigServiceImpl implements IActAuditconfigService
+{
+    @Autowired
+    private ActAuditconfigMapper actAuditconfigMapper;
+
+    @Autowired
+    private ActAudituserMapper actAudituserMapper;
+
+    /**
+     * 查询工作流审批
+     *
+     * @param id 工作流审批主键
+     * @return 工作流审批
+     */
+    @Override
+    public ActAuditconfig selectActAuditconfigById(Long id)
+    {
+        return actAuditconfigMapper.selectActAuditconfigById(id);
+    }
+
+    /**
+     * 查询工作流审批列表
+     *
+     * @param actAuditconfig 工作流审批
+     * @return 工作流审批
+     */
+    @Override
+    public List<ActAuditconfig> selectActAuditconfigList(ActAuditconfig actAuditconfig)
+    {
+        return actAuditconfigMapper.selectActAuditconfigList(actAuditconfig);
+    }
+
+    /**
+     * 查询工作流审批列表
+     *
+     * @param actAuditconfig 工作流审批
+     * @return 工作流审批
+     */
+    @Override
+    public List<ActAuditconfigVo> getConfigList(ActAuditconfig actAuditconfig)
+    {
+        actAuditconfig.setAuditStatus(1);
+        List <ActAuditconfig> actAuditconfigList = actAuditconfigMapper.selectActAuditconfigList(actAuditconfig);
+        List <ActAuditconfigVo> collect = Optional.ofNullable(actAuditconfigList).orElseGet(Collections::emptyList)
+                .stream()
+                .map(a -> {
+                    ActAuditconfigVo actAuditconfigVo = new ActAuditconfigVo();
+                    BeanUtils.copyProperties(a, actAuditconfigVo);
+                    ActAudituser actAudituser = new ActAudituser();
+                    actAudituser.setConfigId(a.getId());
+                    List <ActAudituserVo> actAudituserList = actAudituserMapper.getActUserInfoList(actAudituser);
+                    actAuditconfigVo.setActAudituserInfo(actAudituserList);
+                    return actAuditconfigVo;
+                }).collect(Collectors.toList());
+        return collect;
+    }
+
+    @Override
+    public List<ActAuditconfig> getListByIds(List<Long> ids){
+        if (ids.isEmpty()){
+            new ArrayList <>();
+        }
+        return actAuditconfigMapper.getListByIds(ids);
+    }
+
+    /**
+     * 新增工作流审批
+     *
+     * @param actAuditconfigList 工作流审批
+     * @return 结果
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public int insertActAuditconfig(List<ActAuditconfigVo> actAuditconfigList)
+    {
+        //先删除审批相关配置
+//        actAudituserMapper.deleteActAudituserByAll();
+        actAuditconfigMapper.deleteActAuditconfigByAll();
+        //插入审批相关数据
+        Optional.ofNullable(actAuditconfigList).orElseGet(Collections::emptyList)
+                .stream()
+                .forEach(a->{
+                    ActAuditconfig actAuditconfig = new ActAuditconfig();
+                    BeanUtils.copyProperties(a,actAuditconfig);
+                    //设置其他公共字段
+                    SaveUtil.setCommonAttr(actAuditconfig);
+                    actAuditconfigMapper.insertActAuditconfig(actAuditconfig);
+                    LongAdder longAdder = new LongAdder();
+
+                    Optional.ofNullable(a.getActAudituser()).orElseGet(Collections::emptyList)
+                            .stream()
+                            .forEach(b->{
+                                longAdder.add(1);
+                                b.setConfigId(actAuditconfig.getId());
+                                b.setAuditOrder(Integer.parseInt(longAdder.sum()+""));
+                                //设置其他公共字段
+                                SaveUtil.setCommonAttr(b);
+                                actAudituserMapper.insertActAudituser(b);
+                            });
+                });
+        return 1;
+    }
+
+    /**
+     * 修改工作流审批
+     *
+     * @param actAuditconfig 工作流审批
+     * @return 结果
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public int updateActAuditconfig(ActAuditconfig actAuditconfig)
+    {
+        actAuditconfig.setUpdateTime(DateUtils.getNowDate());
+        actAuditconfig.setUpdateBy(SecurityUtils.getUsername());
+        return actAuditconfigMapper.updateActAuditconfig(actAuditconfig);
+    }
+
+    /**
+     * 批量删除工作流审批
+     *
+     * @param ids 需要删除的工作流审批主键
+     * @return 结果
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public int deleteActAuditconfigByIds(Long[] ids)
+    {
+        return actAuditconfigMapper.deleteActAuditconfigByIds(ids);
+    }
+
+    /**
+     * 删除工作流审批信息
+     *
+     * @param id 工作流审批主键
+     * @return 结果
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public int deleteActAuditconfigById(Long id)
+    {
+        return actAuditconfigMapper.deleteActAuditconfigById(id);
+    }
+}

zd-modules/zd-chemical/src/main/java/com/zd/chemical/service/impl/ActAudituserServiceImpl.java

@@ -0,0 +1,115 @@
+package com.zd.chemical.service.impl;
+
+import java.util.ArrayList;
+import java.util.List;
+import com.zd.common.core.utils.DateUtils;
+import com.zd.common.core.utils.SecurityUtils;
+import com.zd.common.security.utils.SaveUtil;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import com.zd.chemical.mapper.ActAudituserMapper;
+import com.zd.chemical.domain.ActAudituser;
+import com.zd.chemical.service.IActAudituserService;
+
+/**
+ * 工作流审批用户Service业务层处理
+ *
+ * @author zd
+ * @date 2022-08-16
+ */
+@Service
+public class ActAudituserServiceImpl implements IActAudituserService
+{
+    @Autowired
+    private ActAudituserMapper actAudituserMapper;
+
+    /**
+     * 查询工作流审批用户
+     *
+     * @param id 工作流审批用户主键
+     * @return 工作流审批用户
+     */
+    @Override
+    public ActAudituser selectActAudituserById(Long id)
+    {
+        return actAudituserMapper.selectActAudituserById(id);
+    }
+
+    /**
+     * 查询工作流审批用户列表
+     *
+     * @param actAudituser 工作流审批用户
+     * @return 工作流审批用户
+     */
+    @Override
+    public List<ActAudituser> selectActAudituserList(ActAudituser actAudituser)
+    {
+        return actAudituserMapper.selectActAudituserList(actAudituser);
+    }
+
+    @Override
+    public List<ActAudituser> getListByIds(List<Long> ids){
+        if (ids.isEmpty()){
+            new ArrayList <>();
+        }
+        return actAudituserMapper.getListByIds(ids);
+    }
+
+    /**
+     * 新增工作流审批用户
+     *
+     * @param actAudituser 工作流审批用户
+     * @return 结果
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public int insertActAudituser(ActAudituser actAudituser)
+    {
+        //设置其他公共字段
+        SaveUtil.setCommonAttr(actAudituser);
+        return actAudituserMapper.insertActAudituser(actAudituser);
+    }
+
+    /**
+     * 修改工作流审批用户
+     *
+     * @param actAudituser 工作流审批用户
+     * @return 结果
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public int updateActAudituser(ActAudituser actAudituser)
+    {
+        actAudituser.setUpdateTime(DateUtils.getNowDate());
+        actAudituser.setUpdateBy(SecurityUtils.getUsername());
+        return actAudituserMapper.updateActAudituser(actAudituser);
+    }
+
+    /**
+     * 批量删除工作流审批用户
+     *
+     * @param ids 需要删除的工作流审批用户主键
+     * @return 结果
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public int deleteActAudituserByIds(Long[] ids)
+    {
+        return actAudituserMapper.deleteActAudituserByIds(ids);
+    }
+
+    /**
+     * 删除工作流审批用户信息
+     *
+     * @param id 工作流审批用户主键
+     * @return 结果
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public int deleteActAudituserById(Long id)
+    {
+        return actAudituserMapper.deleteActAudituserById(id);
+    }
+}

zd-modules/zd-chemical/src/main/java/com/zd/chemical/service/impl/ActHxpapplyDetailServiceImpl.java

@@ -0,0 +1,108 @@
+package com.zd.chemical.service.impl;
+
+import java.util.ArrayList;
+import java.util.List;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import com.zd.chemical.mapper.ActHxpapplyDetailMapper;
+import com.zd.chemical.domain.ActHxpapplyDetail;
+import com.zd.chemical.service.IActHxpapplyDetailService;
+
+/**
+ * 化学品申购详情Service业务层处理
+ *
+ * @author zd
+ * @date 2022-08-17
+ */
+@Service
+public class ActHxpapplyDetailServiceImpl implements IActHxpapplyDetailService
+{
+    @Autowired
+    private ActHxpapplyDetailMapper actHxpapplyDetailMapper;
+
+    /**
+     * 查询化学品申购详情
+     *
+     * @param id 化学品申购详情主键
+     * @return 化学品申购详情
+     */
+    @Override
+    public ActHxpapplyDetail selectActHxpapplyDetailById(Long id)
+    {
+        return actHxpapplyDetailMapper.selectActHxpapplyDetailById(id);
+    }
+
+    /**
+     * 查询化学品申购详情列表
+     *
+     * @param actHxpapplyDetail 化学品申购详情
+     * @return 化学品申购详情
+     */
+    @Override
+    public List<ActHxpapplyDetail> selectActHxpapplyDetailList(ActHxpapplyDetail actHxpapplyDetail)
+    {
+        return actHxpapplyDetailMapper.selectActHxpapplyDetailList(actHxpapplyDetail);
+    }
+
+    @Override
+    public List<ActHxpapplyDetail> getListByIds(List<Long> ids){
+        if (ids.isEmpty()){
+            new ArrayList <>();
+        }
+        return actHxpapplyDetailMapper.getListByIds(ids);
+    }
+
+    /**
+     * 新增化学品申购详情
+     *
+     * @param actHxpapplyDetail 化学品申购详情
+     * @return 结果
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public int insertActHxpapplyDetail(ActHxpapplyDetail actHxpapplyDetail)
+    {
+        return actHxpapplyDetailMapper.insertActHxpapplyDetail(actHxpapplyDetail);
+    }
+
+    /**
+     * 修改化学品申购详情
+     *
+     * @param actHxpapplyDetail 化学品申购详情
+     * @return 结果
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public int updateActHxpapplyDetail(ActHxpapplyDetail actHxpapplyDetail)
+    {
+        return actHxpapplyDetailMapper.updateActHxpapplyDetail(actHxpapplyDetail);
+    }
+
+    /**
+     * 批量删除化学品申购详情
+     *
+     * @param ids 需要删除的化学品申购详情主键
+     * @return 结果
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public int deleteActHxpapplyDetailByIds(Long[] ids)
+    {
+        return actHxpapplyDetailMapper.deleteActHxpapplyDetailByIds(ids);
+    }
+
+    /**
+     * 删除化学品申购详情信息
+     *
+     * @param id 化学品申购详情主键
+     * @return 结果
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public int deleteActHxpapplyDetailById(Long id)
+    {
+        return actHxpapplyDetailMapper.deleteActHxpapplyDetailById(id);
+    }
+
+}

zd-modules/zd-chemical/src/main/java/com/zd/chemical/service/impl/ActHxpapplyServiceImpl.java

@@ -0,0 +1,489 @@
+package com.zd.chemical.service.impl;
+
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.*;
+import java.util.concurrent.atomic.LongAdder;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+
+import cn.hutool.core.util.NumberUtil;
+import com.alibaba.nacos.shaded.org.checkerframework.checker.nullness.Opt;
+import com.zd.chemical.domain.*;
+import com.zd.chemical.domain.vo.*;
+import com.zd.chemical.mapper.*;
+import com.zd.chemical.service.IActAuditconfigService;
+import com.zd.common.core.utils.DateUtils;
+import com.zd.common.core.utils.SecurityUtils;
+import com.zd.common.core.utils.StringUtils;
+import com.zd.common.security.utils.SaveUtil;
+
+import org.apache.poi.ss.formula.functions.T;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import com.zd.chemical.service.IActHxpapplyService;
+
+import javax.swing.text.html.Option;
+
+/**
+ * 化学品申购Service业务层处理
+ *
+ * @author zd
+ * @date 2022-08-17
+ */
+@Service
+public class ActHxpapplyServiceImpl implements IActHxpapplyService
+{
+    @Autowired
+    private ActHxpapplyMapper actHxpapplyMapper;
+
+    @Autowired
+    private ActHxpapplyDetailMapper actHxpapplyDetailMapper;
+
+    @Autowired
+    private ActApplytaskMapper actApplytaskMapper;
+
+    @Autowired
+    private ActApplytaskNodeMapper actApplytaskNodeMapper;
+
+    @Autowired
+    private IActAuditconfigService actAuditconfigService;
+
+    @Autowired
+    private ActAudituserMapper actAudituserMapper;
+
+    @Autowired
+    private IActHxpapplyService iActHxpapplyService;
+
+    /**
+     * 查询化学品申购
+     *
+     * @param id 化学品申购主键
+     * @return 化学品申购
+     */
+    @Override
+    public ActHxpapplyInfoVo selectActHxpapplyById(Long id,Integer tickStatus)
+    {
+        ActHxpapplyInfoVo actHxpapplyInfoVo = actHxpapplyMapper.selectActHxpapplyById(id);
+        //todo 查询申请单相关的化学品详细信息列表
+        ActHxpapplyDetail actHxpapplyDetail = new ActHxpapplyDetail();
+        actHxpapplyDetail.setHxpapplyId(id);
+        actHxpapplyDetail.setTickStatus(tickStatus);
+        Consumer<List<ActHxpapplyDetailVo>> consumer = x->Optional.ofNullable(x).orElseGet(Collections::emptyList)
+                .stream().forEach(b->{
+                    ActRestStockVo actRestStockVo = new ActRestStockVo();
+                    actRestStockVo.setDeptId(actHxpapplyInfoVo.getDeptId());
+                    actRestStockVo.setSubId(actHxpapplyInfoVo.getSubId());
+                    actRestStockVo.setCabinetId(b.getCabinetId());
+                    actRestStockVo.setChemicalId(b.getChemicalId());
+//                    Map <String, String> restStock = iActHxpapplyService.getRestStock(actRestStockVo);
+//                    b.setRemainingStorage(restStock.get("restStock"));
+                    getRestStockClassif(actRestStockVo,b);
+                });
+        List <ActHxpapplyDetailVo> actHxpapplyDetailVos = actHxpapplyDetailMapper.selectApplyDetailList(actHxpapplyDetail);
+        consumer.accept(actHxpapplyDetailVos);
+        actHxpapplyInfoVo.setActHxpapplyDetailList(actHxpapplyDetailVos);
+        //todo 利用申请的id,查询出工作流对应的配置节点
+        ActApplytask actApplytask = new ActApplytask();
+        actApplytask.setTaskId(id);
+        List <ActApplytask> actApplytasks = actApplytaskMapper.selectActApplytaskList(actApplytask);
+        //todo 查出工作流子节点
+        Function<List <ActApplytask>,ActApplytask> function = x->x.stream().findFirst().orElse(null);
+        Predicate<List <ActApplytask>> pre = p->p.size()>0;
+        if(pre.test(actApplytasks)){
+            ActApplytask apply = function.apply(actApplytasks);
+            actHxpapplyInfoVo.setActApplytask(apply);
+            actHxpapplyInfoVo.setApprovalStatus(apply.getApprovalStatus());
+            ActApplytaskNode actApplytaskNode = new ActApplytaskNode();
+            actApplytaskNode.setApplytaskId(apply.getId());
+            List <ActApplytaskNodeVo> actApplytaskNodes = actApplytaskNodeMapper.selectActApplytaskNodeInfoList(actApplytaskNode);
+            List <Long> nodeCollect = Optional.ofNullable(actApplytaskNodes).orElseGet(Collections::emptyList)
+                    .stream().map(ActApplytaskNodeVo::getAuditconfigId).collect(Collectors.toList());
+            List <ActAuditconfig> listByConfig = actAuditconfigService.getListByIds(nodeCollect);
+            List <ActAuditconfigInfoVo> configInfoList = Optional.ofNullable(listByConfig).orElseGet(Collections::emptyList)
+                    .stream()
+                    .map(c -> {
+                        ActAuditconfigInfoVo actAuditconfigInfoVo = new ActAuditconfigInfoVo();
+                        BeanUtils.copyProperties(c, actAuditconfigInfoVo);
+                        Map<String,Integer> applyTaskStatus = new HashMap <>();
+                        applyTaskStatus.put("applyTaskStatus",0);
+                        List <ActApplytaskNodeVo> collect = Optional.ofNullable(actApplytaskNodes).orElseGet(Collections::emptyList)
+                                .stream().filter(n -> n.getAuditconfigId() == c.getId())
+                                .map(n->{
+                                    if(n.getNodeStatus()==1){
+                                        applyTaskStatus.put("applyTaskStatus",n.getNodeStatus());
+                                    }else if(n.getNodeStatus()==2){
+                                        applyTaskStatus.put("applyTaskStatus",n.getNodeStatus());
+                                        actAuditconfigInfoVo.setRefuseContent(n.getNodeContent());
+                                    }else if(n.getNodeStatus()==0 && applyTaskStatus.get("applyTaskStatus")!=2){
+                                        applyTaskStatus.put("applyTaskStatus",n.getNodeStatus());
+                                    }
+
+                                    String[] applyUserArr = n.getApplyUserInfo().split(";");
+                                    Arrays.asList(applyUserArr).stream()
+                                            .forEach(arr->{
+                                                String[] arrInfo = arr.split(",");
+                                                Map<String,String> userInfo = new HashMap<>();
+                                                userInfo.put("id",arrInfo[0]);
+                                                userInfo.put("name",arrInfo[1]);
+                                                userInfo.put("avatar",arrInfo[2]);
+                                                userInfo.put("postName",arrInfo[3]);
+                                                n.getApplyUserList().add(userInfo);
+                                            });
+                                    return n;
+                                })
+                                .collect(Collectors.toList());
+                        actAuditconfigInfoVo.setActApplytaskNodeList(collect);
+                        actAuditconfigInfoVo.setApplyTaskStatus(applyTaskStatus.get("applyTaskStatus"));
+                        return actAuditconfigInfoVo;
+                    }).collect(Collectors.toList());
+            actHxpapplyInfoVo.setConfigInfoList(configInfoList);
+        }
+        return actHxpapplyInfoVo;
+    }
+
+
+    /**
+     * 获取化学品剩余可存放量分类统计
+     *
+     * @param actRestStockVo 机柜主键主键
+     * @return 化学品申购
+     */
+    public void getRestStockClassif(ActRestStockVo actRestStockVo,ActHxpapplyDetailVo b)
+    {
+        List<ActRestStockVo> restStock = actHxpapplyMapper.getRestStockClassif(actRestStockVo);
+        Optional.ofNullable(restStock).orElseGet(Collections::emptyList)
+                .stream()
+                .forEach(a->{
+                    if(a.getChemicalId().equals("1")){
+                        b.setCollegeInventory(a.getRestStock());
+                    }else if(a.getChemicalId().equals("2")){
+                        b.setSubInventory(a.getRestStock());
+                    }else if(a.getChemicalId().equals("3")){
+                        b.setCabinetStorage(a.getRestStock());
+                    }else if(a.getChemicalId().equals("4")){
+                        b.setRemainingStorage(a.getRestStock());
+                    }
+                });
+    }
+
+
+    /**
+     * 查询化学品申购列表
+     *
+     * @param actHxpapplySearch 化学品申购
+     * @return 化学品申购
+     */
+    @Override
+    public List<ActHxpapplyListVo> selectActHxpapplyList(ActHxpapplySearch actHxpapplySearch)
+    {
+        actHxpapplySearch.setLoginUserId(SecurityUtils.getUserId());
+        List <ActHxpapplyListVo> actHxpapplyListVos = actHxpapplyMapper.selectActHxpapplyList(actHxpapplySearch);
+        Optional.ofNullable(actHxpapplyListVos).orElseGet(Collections::emptyList)
+                .stream()
+                .forEach(a->{
+                    Predicate<String> pre = p->StringUtils.isNotEmpty(p);
+                    if(pre.test(a.getCurrentApprover())){
+                        String[] userList = a.getCurrentApprover().split(",");
+                        a.getCurrentUserList().addAll(userChengeList(userList));
+                    }
+                    if(pre.test(a.getHistoryApprover())){
+                        String[] userList = a.getHistoryApprover().split(",");
+                        a.getHistoryUserList().addAll(userChengeList(userList));
+                    }
+                });
+        return actHxpapplyListVos;
+    }
+
+    /**
+     * 查询化学品申购列表(草稿箱)
+     *
+     * @param actHxpapplySearch 化学品申购
+     * @return 化学品申购
+     */
+    @Override
+    public List<ActHxpapplyDraftsListVo> draftsList(ActHxpapplySearch actHxpapplySearch)
+    {
+        List <ActHxpapplyDraftsListVo> actHxpapplyListVos = actHxpapplyMapper.draftsList(actHxpapplySearch);
+        return actHxpapplyListVos;
+    }
+
+
+    private List<LinkedHashMap<String,String>> userChengeList(String[] userList){
+        List<LinkedHashMap<String,String>> userAllList = new ArrayList <>();
+        for(int x=0;x<userList.length;x++){
+            LinkedHashMap<String,String> userMap = new LinkedHashMap <>();
+            String[] userInfo = userList[x].split(";");
+            userMap.put("id",userInfo[0]);
+            userMap.put("name",userInfo[1]);
+            userAllList.add(userMap);
+        }
+
+        return userAllList;
+    }
+
+    @Override
+    public List<ActHxpapply> getListByIds(List<Long> ids){
+        if (ids.isEmpty()){
+            new ArrayList <>();
+        }
+        return actHxpapplyMapper.getListByIds(ids);
+    }
+
+    /**
+     * 新增化学品申购
+     *
+     * @param actHxpapplyVo 化学品申购
+     * @return 结果
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public int insertActHxpapply(ActHxpapplyVo actHxpapplyVo)
+    {
+        //查询vo如果有id,就是修改，需要删除原来的数据，重新添加。
+        if(StringUtils.isNotNull(actHxpapplyVo.getId())){
+            //删除原来的化学品申请单
+            actHxpapplyDetailMapper.deleteActHxpapplyDetailByApplyId(actHxpapplyVo.getId());
+            actHxpapplyMapper.deleteActHxpapplyById(actHxpapplyVo.getId());
+        }
+        ActHxpapply actHxpapply = new ActHxpapply();
+        BeanUtils.copyProperties(actHxpapplyVo,actHxpapply);
+        //设置其他公共字段
+        SaveUtil.setCommonAttr(actHxpapply);
+        actHxpapply.setApplyNum(generateApplyNum());
+        actHxpapplyMapper.insertActHxpapply(actHxpapply);
+        Optional.ofNullable(actHxpapplyVo.getActHxpapplyDetailList()).orElseGet(Collections::emptyList)
+                .stream()
+                .forEach(a->{
+                    a.setHxpapplyId(actHxpapply.getId());
+                    actHxpapplyDetailMapper.insertActHxpapplyDetail(a);
+                });
+        if(actHxpapplyVo.getApplyStatus()==1){
+            Long createUserId = actHxpapply.getUserId();
+            //这里启动工作流
+            ActApplytask actApplytask = new ActApplytask();
+            actApplytask.setTaskId(actHxpapply.getId());
+            actApplytask.setTaskName("化学品申请工作流");
+            actApplytask.setTaskType(1);
+            actApplytask.setCreateTime(new Date());
+            actApplytaskMapper.insertActApplytask(actApplytask);
+            //这里需要动态生成工作流的节点任务
+            generateNode(actApplytask,createUserId);
+        }
+        return 1;
+    }
+
+    //todo 生成申购编号
+    private String generateApplyNum(){
+        LocalDateTime localDateTime = LocalDateTime.now();
+        return localDateTime.format(DateTimeFormatter.ofPattern("yyyyMMddHHmmss"));
+    }
+
+    public void generateNode(ActApplytask actApplytask,Long createUserId){
+        ActAuditconfig actAuditconfig = new ActAuditconfig();
+        actAuditconfig.setAuditStatus(1);
+        List<ActAuditconfig> actAuditconfigList = actAuditconfigService.selectActAuditconfigList(actAuditconfig);
+        Function <List<ActAuditconfig>,List<Long>> function = x-> x.parallelStream().map(ActAuditconfig::getId).collect(Collectors.toList());
+        List<ActAudituser> actAudituserList = actAudituserMapper.getListByIds(function.apply(actAuditconfigList));
+        LongAdder countAdder = new LongAdder();
+        //当前步数和下一步的map
+        Map<String,Long> stepMap = new HashMap <>();
+        stepMap.put("nowStep",-1L);
+        stepMap.put("nextStep",-1L);
+        //这里做一个跳过审核的map，暂时这么写吧，没有想到更好的办法了，啊啊啊啊，头疼（1表示第一次申请人就是审批人的需要跳过,2表示需要结束跳过）
+        Map<String,Long> jumpApply = new HashMap<>();
+        jumpApply.put("jumpApply",1L);
+        Optional.ofNullable(actAuditconfigList).orElseGet(Collections::emptyList)
+                .stream()
+                .map(a->{
+                    if(a.getAuditType()==2){
+                        countAdder.add(1);
+                        List <ActAudituser> collect = Optional.ofNullable(actAudituserList).orElseGet(Collections::emptyList).stream()
+                                .filter(b->b.getConfigId()==a.getId())
+                                .sorted((s1, s2) -> NumberUtil.compare(s1.getAuditOrder(), s2.getAuditOrder()))
+                                .collect(Collectors.toList());
+
+                        ActApplytaskNode actApplytaskNode = new ActApplytaskNode();
+                        StringBuffer stringBuffer = new StringBuffer();
+                        //这里生成或签的规则。
+                        Optional.ofNullable(collect).orElseGet(Collections::emptyList)
+                                .stream()
+                                .forEach(c1->{
+                                    stringBuffer.append(",");
+                                    stringBuffer.append(c1.getAuditUserId());
+                                    jumpApplyFun(createUserId,c1.getAuditUserId(),jumpApply,actApplytaskNode);
+                                });
+                        if(stringBuffer.length()>0){
+                            actApplytaskNode.setNodeName("流程节点："+countAdder.sum());
+                            actApplytaskNode.setApplytaskId(actApplytask.getId());
+                            actApplytaskNode.setApplyUserIds(stringBuffer.substring(1));
+                            actApplytaskNode.setNodeOrder(Integer.parseInt(countAdder.sum()+""));
+                            actApplytaskNode.setAuditconfigId(a.getId());
+                            insertNodeSave(actApplytaskNode);
+                        }
+                    }
+                    return a;
+                })
+                .forEach(a->{
+                    if(a.getAuditType()==1){
+                        //这里生成依次审批规则。
+                        Optional.ofNullable(actAudituserList).orElseGet(Collections::emptyList).stream()
+                                .filter(b->b.getConfigId()==a.getId())
+                                .sorted((s1, s2) -> NumberUtil.compare(s1.getAuditOrder(), s2.getAuditOrder()))
+                                .collect(Collectors.toList())
+                                .stream()
+                                .forEach(f->{
+                                    countAdder.add(1);
+                                    ActApplytaskNode actApplytaskNode = new ActApplytaskNode();
+                                    actApplytaskNode.setNodeName("流程节点："+countAdder.sum());
+                                    actApplytaskNode.setApplytaskId(actApplytask.getId());
+                                    actApplytaskNode.setApplyUserIds(f.getAuditUserId()+"");
+                                    actApplytaskNode.setNodeOrder(Integer.parseInt(countAdder.sum()+""));
+                                    jumpApplyFun(createUserId,f.getAuditUserId(),jumpApply,actApplytaskNode);
+                                    actApplytaskNode.setAuditconfigId(a.getId());
+                                    insertNodeSave(actApplytaskNode);
+                                });
+                    }
+                });
+        //调用回填步数的方法
+        proStep(stepMap,actApplytask);
+    }
+
+    //todo 这里做了执行task回填步数
+    private void proStep(Map<String,Long> stepMap,ActApplytask actApplytask){
+        actApplytask.setNowStep(stepMap.get("nowStep"));
+        actApplytask.setNextStep(stepMap.get("nextStep"));
+        ActApplytaskNode actApplytaskNode = new ActApplytaskNode();
+        actApplytaskNode.setNodeStatus(0);
+        actApplytaskNode.setApplytaskId(actApplytask.getId());
+        List <ActApplytaskNode> actApplytaskNodes = actApplytaskNodeMapper.selectActApplytaskNodeList(actApplytaskNode);
+        for(int i=0;i<actApplytaskNodes.size();i++){
+            if(i==0){
+                actApplytask.setNowStep(actApplytaskNodes.get(i).getId());
+            }
+            if(i==1){
+                actApplytask.setNextStep(actApplytaskNodes.get(i).getId());
+            }
+        }
+        if(actApplytaskNodes.size()==0){
+            actApplytask.setOverTime(new Date());
+            actApplytask.setApprovalStatus(1);
+        }
+        actApplytaskMapper.updateActApplytask(actApplytask);
+    }
+
+    //todo 这里处理一下跳过审核，只有当前审批人是申请人的时候，才做审批通过
+    private void jumpApplyFun(Long createUserId,Long auditUserId,Map<String,Long> jumpApply,ActApplytaskNode actApplytaskNode){
+        if(createUserId == auditUserId && jumpApply.get("jumpApply")==1){
+            actApplytaskNode.setNodeStatus(1);
+            actApplytaskNode.setApplyUserid(SecurityUtils.getUserId());
+            jumpApply.put("jumpApply",1L);
+        }else{
+            jumpApply.put("jumpApply",2L);
+        }
+    }
+
+    //todo 提出工作流节点保存
+    private void insertNodeSave(ActApplytaskNode actApplytaskNode){
+        actApplytaskNodeMapper.insertActApplytaskNode(actApplytaskNode);
+    }
+
+
+    /**
+     * 修改化学品申购
+     *
+     * @param actHxpapply 化学品申购
+     * @return 结果
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public int updateActHxpapply(ActHxpapply actHxpapply)
+    {
+        actHxpapply.setUpdateTime(DateUtils.getNowDate());
+        actHxpapply.setUpdateBy(SecurityUtils.getUsername());
+        return actHxpapplyMapper.updateActHxpapply(actHxpapply);
+    }
+
+    /**
+     * 批量删除化学品申购
+     *
+     * @param ids 需要删除的化学品申购主键
+     * @return 结果
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public int deleteActHxpapplyByIds(Long[] ids)
+    {
+        //删除原来的化学品申请单
+        actHxpapplyDetailMapper.deleteActHxpapplyDetailByApplyId(ids[0]);
+        return actHxpapplyMapper.deleteActHxpapplyByIds(ids);
+    }
+
+    /**
+     * 删除化学品申购信息
+     *
+     * @param id 化学品申购主键
+     * @return 结果
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public int deleteActHxpapplyById(Long id)
+    {
+        return actHxpapplyMapper.deleteActHxpapplyById(id);
+    }
+
+
+    /**
+     * 获取化学品剩余可存放量
+     *
+     * @param actRestStockVo 机柜主键主键
+     * @return 化学品申购
+     */
+    @Override
+    public Map <String, String> getRestStock(ActRestStockVo actRestStockVo)
+    {
+        Predicate<Map <String, String>> pre = x->StringUtils.isNotNull(x);
+        Map <String, String> restStock = actHxpapplyMapper.getRestStock(actRestStockVo);
+        if(pre.test(restStock)){
+            return restStock;
+        }else{
+            restStock = new HashMap <>();
+            restStock.put("chemicalId",actRestStockVo.getChemicalId()+"");
+            restStock.put("restStock","0g");
+            return restStock;
+        }
+    }
+
+
+    /**
+     * 获取化学品剩余可存放量
+     *
+     * @param actRestStockVo 机柜主键主键
+     * @return 化学品申购
+     */
+    @Override
+    public List<ActRestStockManyVo> getRestStockByManyCabinet(ActRestStockManySearch actRestStockVo)
+    {
+        List<ActRestStockManyVo> actRestStockManyVoList = new ArrayList <>();
+        Optional.ofNullable(actRestStockVo.getCabinetIds()).orElseGet(Collections::emptyList).stream().forEach(a->{
+            ActRestStockManyVo manyVo = new ActRestStockManyVo();
+            manyVo.setCabinetId(a.longValue());
+            manyVo.setRestStock("0");
+            actRestStockManyVoList.add(manyVo);
+        });
+        List <ActRestStockManyVo> restStockByManyCabinet = actHxpapplyMapper.getRestStockByManyCabinet(actRestStockVo);
+        Optional.ofNullable(actRestStockManyVoList).orElseGet(Collections::emptyList)
+                .stream()
+                .forEach(a->Optional.ofNullable(restStockByManyCabinet).orElseGet(Collections::emptyList).stream()
+                .filter(b->b.getCabinetId()==a.getCabinetId()).forEach(c->{
+                                    a.setRestStock(c.getRestStock());
+                                })
+                );
+
+        return actRestStockManyVoList;
+    }
+}

zd-modules/zd-chemical/src/main/resources/mapper/chemical/ActApplytaskMapper.xml

@@ -0,0 +1,108 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE mapper
+PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
+"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.zd.chemical.mapper.ActApplytaskMapper">
+
+    <resultMap type="com.zd.chemical.domain.ActApplytask" id="ActApplytaskResult">
+        <result property="id"    column="id"    />
+        <result property="taskId"    column="task_id"    />
+        <result property="taskName"    column="task_name"    />
+        <result property="taskType"    column="task_type"    />
+        <result property="nowStep"    column="now_step"    />
+        <result property="nextStep"    column="next_step"    />
+        <result property="approvalStatus"    column="approval_status"    />
+        <result property="createTime"    column="create_time"    />
+        <result property="overTime"    column="over_time"    />
+    </resultMap>
+
+    <sql id="selectActApplytaskVo">
+        select id, task_id, task_name, task_type, now_step, next_step, approval_status, create_time, over_time from act_applytask
+    </sql>
+    <sql id="selectActApplytaskListVo">
+        select t.id, t.task_id, t.task_name, t.task_type, t.now_step, t.next_step, t.approval_status, t.create_time, t.over_time from act_applytask as t
+    </sql>
+    <select id="selectActApplytaskList" parameterType="com.zd.chemical.domain.ActApplytask" resultMap="ActApplytaskResult">
+        <include refid="selectActApplytaskVo"/>
+        <where>
+            <if test="taskId != null "> and task_id = #{taskId}</if>
+            <if test="taskName != null  and taskName != ''"> and task_name like concat('%', #{taskName}, '%')</if>
+            <if test="taskType != null "> and task_type = #{taskType}</if>
+            <if test="nowStep != null "> and now_step = #{nowStep}</if>
+            <if test="nextStep != null "> and next_step = #{nextStep}</if>
+        </where>
+    </select>
+
+    <select id="getListByIds" resultMap="ActApplytaskResult">
+        <include refid="selectActApplytaskVo"/>
+        <where>
+            id in
+            <foreach item="id" collection="list" open="(" separator="," close=")">
+                #{id}
+            </foreach>
+        </where>
+    </select>
+
+    <select id="selectActApplytaskById" resultMap="ActApplytaskResult">
+        <include refid="selectActApplytaskVo"/>
+        where id = #{id}
+    </select>
+
+    <insert id="insertActApplytask" parameterType="com.zd.chemical.domain.ActApplytask" useGeneratedKeys="true" keyProperty="id">
+        insert into act_applytask
+        <trim prefix="(" suffix=")" suffixOverrides=",">
+    <if test="taskId != null">task_id,</if>
+
+    <if test="taskName != null">task_name,</if>
+
+    <if test="taskType != null">task_type,</if>
+
+    <if test="nowStep != null">now_step,</if>
+
+    <if test="nextStep != null">next_step,</if>
+
+    <if test="approvalStatus != null">approval_status,</if>
+
+    <if test="createTime != null">create_time,</if>
+
+    <if test="overTime != null">over_time,</if>
+
+         </trim>
+        <trim prefix="values (" suffix=")" suffixOverrides=",">
+    <if test="taskId != null">#{taskId},</if>
+    <if test="taskName != null">#{taskName},</if>
+    <if test="taskType != null">#{taskType},</if>
+    <if test="nowStep != null">#{nowStep},</if>
+    <if test="nextStep != null">#{nextStep},</if>
+    <if test="approvalStatus != null">#{approvalStatus},</if>
+    <if test="createTime != null">#{createTime},</if>
+    <if test="overTime != null">#{overTime},</if>
+         </trim>
+    </insert>
+
+    <update id="updateActApplytask" parameterType="com.zd.chemical.domain.ActApplytask">
+        update act_applytask
+        <trim prefix="SET" suffixOverrides=",">
+            <if test="taskId != null">task_id = #{taskId},</if>
+            <if test="taskName != null">task_name = #{taskName},</if>
+            <if test="taskType != null">task_type = #{taskType},</if>
+            <if test="nowStep != null">now_step = #{nowStep},</if>
+            <if test="nextStep != null">next_step = #{nextStep},</if>
+            <if test="approvalStatus != null">approval_status = #{approvalStatus},</if>
+            <if test="createTime != null">create_time = #{createTime},</if>
+            <if test="overTime != null">over_time = #{overTime},</if>
+        </trim>
+        where id = #{id}
+    </update>
+
+    <delete id="deleteActApplytaskById">
+        delete from act_applytask where id = #{id}
+    </delete>
+
+    <delete id="deleteActApplytaskByIds">
+        delete from act_applytask where id in
+        <foreach item="id" collection="array" open="(" separator="," close=")">
+            #{id}
+        </foreach>
+    </delete>
+</mapper>

zd-modules/zd-chemical/src/main/resources/mapper/chemical/ActApplytaskNodeMapper.xml

@@ -0,0 +1,127 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE mapper
+PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
+"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.zd.chemical.mapper.ActApplytaskNodeMapper">
+
+    <resultMap type="com.zd.chemical.domain.ActApplytaskNode" id="ActApplytaskNodeResult">
+        <result property="id"    column="id"    />
+        <result property="nodeName"    column="node_name"    />
+        <result property="applytaskId"    column="applytask_id"    />
+        <result property="auditconfigId"    column="auditconfig_id"    />
+        <result property="applyUserIds"    column="apply_user_ids"    />
+        <result property="nodeStatus"    column="node_status"    />
+        <result property="nodeContent"    column="node_content"    />
+        <result property="nodeOrder"    column="node_order"    />
+        <result property="applyUserid"    column="apply_userid"    />
+    </resultMap>
+
+    <sql id="selectActApplytaskNodeVo">
+        select id, node_name, applytask_id, auditconfig_id, apply_user_ids, node_status, node_content, node_order, apply_userid from act_applytask_node
+    </sql>
+    <sql id="selectActApplytaskNodeListVo">
+        select t.id, t.node_name, t.applytask_id, t.auditconfig_id, t.apply_user_ids, t.node_status, t.node_content, t.node_order, t.apply_userid from act_applytask_node as t
+    </sql>
+    <select id="selectActApplytaskNodeList" parameterType="com.zd.chemical.domain.ActApplytaskNode" resultMap="ActApplytaskNodeResult">
+        <include refid="selectActApplytaskNodeVo"/>
+        <where>
+            <if test="nodeName != null  and nodeName != ''"> and node_name like concat('%', #{nodeName}, '%')</if>
+            <if test="applytaskId != null "> and applytask_id = #{applytaskId}</if>
+            <if test="applyUserIds != null  and applyUserIds != ''"> and apply_user_ids = #{applyUserIds}</if>
+            <if test="nodeStatus != null "> and node_status = #{nodeStatus}</if>
+            <if test="nodeContent != null  and nodeContent != ''"> and node_content = #{nodeContent}</if>
+            <if test="nodeOrder != null "> and node_order = #{nodeOrder}</if>
+        </where>
+        order by node_order asc
+    </select>
+
+
+    <select id="selectActApplytaskNodeInfoList" parameterType="com.zd.chemical.domain.ActApplytaskNode" resultType="com.zd.chemical.domain.vo.ActApplytaskNodeVo">
+        SELECT an.id, an.node_name, an.applytask_id, an.auditconfig_id, an.apply_user_ids, an.node_status, an.node_content, an.node_order, an.apply_userid,
+        (SELECT GROUP_CONCAT(su.user_id,',',su.nick_name,',',IFNULL(su.avatar,''),',',IFNULL(pt.post_name,'')
+        SEPARATOR ';') FROM sys_user su LEFT JOIN sys_post pt ON pt.`post_id` = su.`position` WHERE FIND_IN_SET(su.user_id, an.apply_user_ids)) applyUserInfo
+        FROM act_applytask_node an
+        <where>
+            <if test="nodeName != null  and nodeName != ''"> and an.node_name like concat('%', #{nodeName}, '%')</if>
+            <if test="applytaskId != null "> and an.applytask_id = #{applytaskId}</if>
+            <if test="applyUserIds != null  and applyUserIds != ''"> and an.apply_user_ids = #{applyUserIds}</if>
+            <if test="nodeStatus != null "> and an.node_status = #{nodeStatus}</if>
+            <if test="nodeContent != null  and nodeContent != ''"> and an.node_content = #{nodeContent}</if>
+            <if test="nodeOrder != null "> and an.node_order = #{nodeOrder}</if>
+        </where>
+        order by an.node_order asc
+    </select>
+
+    <select id="getListByIds" resultMap="ActApplytaskNodeResult">
+        <include refid="selectActApplytaskNodeVo"/>
+        <where>
+            id in
+            <foreach item="id" collection="list" open="(" separator="," close=")">
+                #{id}
+            </foreach>
+        </where>
+    </select>
+
+    <select id="selectActApplytaskNodeById" resultMap="ActApplytaskNodeResult">
+        <include refid="selectActApplytaskNodeVo"/>
+        where id = #{id}
+    </select>
+
+    <insert id="insertActApplytaskNode" parameterType="com.zd.chemical.domain.ActApplytaskNode" useGeneratedKeys="true" keyProperty="id">
+        insert into act_applytask_node
+        <trim prefix="(" suffix=")" suffixOverrides=",">
+    <if test="nodeName != null">node_name,</if>
+
+    <if test="applytaskId != null">applytask_id,</if>
+
+    <if test="auditconfigId != null">auditconfig_id,</if>
+
+    <if test="applyUserIds != null">apply_user_ids,</if>
+
+    <if test="nodeStatus != null">node_status,</if>
+
+    <if test="nodeContent != null">node_content,</if>
+
+    <if test="nodeOrder != null">node_order,</if>
+
+    <if test="applyUserid != null">apply_userid,</if>
+
+         </trim>
+        <trim prefix="values (" suffix=")" suffixOverrides=",">
+    <if test="nodeName != null">#{nodeName},</if>
+    <if test="applytaskId != null">#{applytaskId},</if>
+    <if test="auditconfigId != null">#{auditconfigId},</if>
+    <if test="applyUserIds != null">#{applyUserIds},</if>
+    <if test="nodeStatus != null">#{nodeStatus},</if>
+    <if test="nodeContent != null">#{nodeContent},</if>
+    <if test="nodeOrder != null">#{nodeOrder},</if>
+    <if test="applyUserid != null">#{applyUserid},</if>
+         </trim>
+    </insert>
+
+    <update id="updateActApplytaskNode" parameterType="com.zd.chemical.domain.ActApplytaskNode">
+        update act_applytask_node
+        <trim prefix="SET" suffixOverrides=",">
+            <if test="nodeName != null">node_name = #{nodeName},</if>
+            <if test="applytaskId != null">applytask_id = #{applytaskId},</if>
+            <if test="auditconfigId != null">auditconfig_id = #{auditconfigId},</if>
+            <if test="applyUserIds != null">apply_user_ids = #{applyUserIds},</if>
+            <if test="nodeStatus != null">node_status = #{nodeStatus},</if>
+            <if test="nodeContent != null">node_content = #{nodeContent},</if>
+            <if test="nodeOrder != null">node_order = #{nodeOrder},</if>
+            <if test="applyUserid != null">apply_userid = #{applyUserid},</if>
+        </trim>
+        where id = #{id}
+    </update>
+
+    <delete id="deleteActApplytaskNodeById">
+        delete from act_applytask_node where id = #{id}
+    </delete>
+
+    <delete id="deleteActApplytaskNodeByIds">
+        delete from act_applytask_node where id in
+        <foreach item="id" collection="array" open="(" separator="," close=")">
+            #{id}
+        </foreach>
+    </delete>
+</mapper>

zd-modules/zd-chemical/src/main/resources/mapper/chemical/ActAuditconfigMapper.xml

@@ -0,0 +1,108 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE mapper
+PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
+"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.zd.chemical.mapper.ActAuditconfigMapper">
+
+    <resultMap type="com.zd.chemical.domain.ActAuditconfig" id="ActAuditconfigResult">
+        <result property="id"    column="id"    />
+        <result property="auditType"    column="audit_type"    />
+        <result property="auditStatus"    column="audit_status"    />
+        <result property="userId"    column="user_id"    />
+        <result property="createBy"    column="create_by"    />
+        <result property="createTime"    column="create_time"    />
+        <result property="updateBy"    column="update_by"    />
+        <result property="updateTime"    column="update_time"    />
+        <result property="remark"    column="remark"    />
+    </resultMap>
+
+    <sql id="selectActAuditconfigVo">
+        select id, audit_type, user_id, create_by, create_time, update_by, update_time, remark from act_auditconfig
+    </sql>
+    <sql id="selectActAuditconfigListVo">
+        select t.id, t.audit_type, t.user_id, t.create_by, t.create_time, t.update_by, t.update_time, t.remark from act_auditconfig as t
+    </sql>
+    <select id="selectActAuditconfigList" parameterType="com.zd.chemical.domain.ActAuditconfig" resultMap="ActAuditconfigResult">
+        <include refid="selectActAuditconfigVo"/>
+        <where>
+            <if test="auditType != null "> and audit_type = #{auditType}</if>
+            <if test="auditStatus != null "> and audit_status = #{auditStatus}</if>
+        </where>
+    </select>
+
+    <select id="getListByIds" resultMap="ActAuditconfigResult">
+        <include refid="selectActAuditconfigVo"/>
+        <where>
+            id in
+            <foreach item="id" collection="list" open="(" separator="," close=")">
+                #{id}
+            </foreach>
+        </where>
+        order by id asc
+    </select>
+
+    <select id="selectActAuditconfigById" resultMap="ActAuditconfigResult">
+        <include refid="selectActAuditconfigVo"/>
+        where id = #{id}
+    </select>
+
+    <insert id="insertActAuditconfig" parameterType="com.zd.chemical.domain.ActAuditconfig" useGeneratedKeys="true" keyProperty="id">
+        insert into act_auditconfig
+        <trim prefix="(" suffix=")" suffixOverrides=",">
+    <if test="auditType != null">audit_type,</if>
+
+    <if test="userId != null">user_id,</if>
+
+    <if test="createBy != null">create_by,</if>
+
+    <if test="createTime != null">create_time,</if>
+
+    <if test="updateBy != null">update_by,</if>
+
+    <if test="updateTime != null">update_time,</if>
+
+    <if test="remark != null">remark,</if>
+
+         </trim>
+        <trim prefix="values (" suffix=")" suffixOverrides=",">
+    <if test="auditType != null">#{auditType},</if>
+    <if test="userId != null">#{userId},</if>
+    <if test="createBy != null">#{createBy},</if>
+    <if test="createTime != null">#{createTime},</if>
+    <if test="updateBy != null">#{updateBy},</if>
+    <if test="updateTime != null">#{updateTime},</if>
+    <if test="remark != null">#{remark},</if>
+         </trim>
+    </insert>
+
+    <update id="updateActAuditconfig" parameterType="com.zd.chemical.domain.ActAuditconfig">
+        update act_auditconfig
+        <trim prefix="SET" suffixOverrides=",">
+            <if test="auditType != null">audit_type = #{auditType},</if>
+            <if test="userId != null">user_id = #{userId},</if>
+            <if test="createBy != null">create_by = #{createBy},</if>
+            <if test="createTime != null">create_time = #{createTime},</if>
+            <if test="updateBy != null">update_by = #{updateBy},</if>
+            <if test="updateTime != null">update_time = #{updateTime},</if>
+            <if test="remark != null">remark = #{remark},</if>
+        </trim>
+        where id = #{id}
+    </update>
+
+    <delete id="deleteActAuditconfigById">
+        delete from act_auditconfig where id = #{id}
+    </delete>
+
+    <delete id="deleteActAuditconfigByIds">
+        delete from act_auditconfig where id in
+        <foreach item="id" collection="array" open="(" separator="," close=")">
+            #{id}
+        </foreach>
+    </delete>
+
+    <update id="deleteActAuditconfigByAll">
+        update act_auditconfig
+        set audit_status = 0
+        where audit_status = 1
+    </update>
+</mapper>

zd-modules/zd-chemical/src/main/resources/mapper/chemical/ActAudituserMapper.xml

@@ -0,0 +1,125 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE mapper
+PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
+"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.zd.chemical.mapper.ActAudituserMapper">
+
+    <resultMap type="com.zd.chemical.domain.ActAudituser" id="ActAudituserResult">
+        <result property="id"    column="id"    />
+        <result property="configId"    column="config_id"    />
+        <result property="auditUserId"    column="audit_user_id"    />
+        <result property="auditOrder"    column="audit_order"    />
+        <result property="userId"    column="user_id"    />
+        <result property="createBy"    column="create_by"    />
+        <result property="createTime"    column="create_time"    />
+        <result property="updateBy"    column="update_by"    />
+        <result property="updateTime"    column="update_time"    />
+        <result property="remark"    column="remark"    />
+    </resultMap>
+
+    <sql id="selectActAudituserVo">
+        select id, config_id, audit_user_id, audit_order, user_id, create_by, create_time, update_by, update_time, remark from act_audituser
+    </sql>
+    <sql id="selectActAudituserListVo">
+        select t.id, t.config_id, t.audit_user_id, t.audit_order, t.user_id, t.create_by, t.create_time, t.update_by, t.update_time, t.remark from act_audituser as t
+    </sql>
+    <select id="selectActAudituserList" parameterType="com.zd.chemical.domain.ActAudituser" resultMap="ActAudituserResult">
+        <include refid="selectActAudituserVo"/>
+        <where>
+            <if test="configId != null "> and config_id = #{configId}</if>
+            <if test="auditUserId != null "> and audit_user_id = #{auditUserId}</if>
+            <if test="auditOrder != null "> and audit_order = #{auditOrder}</if>
+        </where>
+    </select>
+
+
+    <select id="getActUserInfoList" parameterType="com.zd.chemical.domain.ActAudituser" resultType="com.zd.chemical.domain.vo.ActAudituserVo">
+        select ar.id, ar.audit_user_id userId, ur.nick_name nickName,ur.avatar
+        from act_audituser ar left join sys_user ur on ar.audit_user_id = ur.user_id
+        <where>
+            <if test="configId != null "> and ar.config_id = #{configId}</if>
+        </where>
+        order by ar.audit_order asc
+    </select>
+
+    <select id="getListByIds" resultMap="ActAudituserResult">
+        <include refid="selectActAudituserVo"/>
+        <where>
+            config_id in
+            <foreach item="id" collection="list" open="(" separator="," close=")">
+                #{id}
+            </foreach>
+        </where>
+    </select>
+
+    <select id="selectActAudituserById" resultMap="ActAudituserResult">
+        <include refid="selectActAudituserVo"/>
+        where id = #{id}
+    </select>
+
+    <insert id="insertActAudituser" parameterType="com.zd.chemical.domain.ActAudituser" useGeneratedKeys="true" keyProperty="id">
+        insert into act_audituser
+        <trim prefix="(" suffix=")" suffixOverrides=",">
+    <if test="configId != null">config_id,</if>
+
+    <if test="auditUserId != null">audit_user_id,</if>
+
+    <if test="auditOrder != null">audit_order,</if>
+
+    <if test="userId != null">user_id,</if>
+
+    <if test="createBy != null">create_by,</if>
+
+    <if test="createTime != null">create_time,</if>
+
+    <if test="updateBy != null">update_by,</if>
+
+    <if test="updateTime != null">update_time,</if>
+
+    <if test="remark != null">remark,</if>
+
+         </trim>
+        <trim prefix="values (" suffix=")" suffixOverrides=",">
+    <if test="configId != null">#{configId},</if>
+    <if test="auditUserId != null">#{auditUserId},</if>
+    <if test="auditOrder != null">#{auditOrder},</if>
+    <if test="userId != null">#{userId},</if>
+    <if test="createBy != null">#{createBy},</if>
+    <if test="createTime != null">#{createTime},</if>
+    <if test="updateBy != null">#{updateBy},</if>
+    <if test="updateTime != null">#{updateTime},</if>
+    <if test="remark != null">#{remark},</if>
+         </trim>
+    </insert>
+
+    <update id="updateActAudituser" parameterType="com.zd.chemical.domain.ActAudituser">
+        update act_audituser
+        <trim prefix="SET" suffixOverrides=",">
+            <if test="configId != null">config_id = #{configId},</if>
+            <if test="auditUserId != null">audit_user_id = #{auditUserId},</if>
+            <if test="auditOrder != null">audit_order = #{auditOrder},</if>
+            <if test="userId != null">user_id = #{userId},</if>
+            <if test="createBy != null">create_by = #{createBy},</if>
+            <if test="createTime != null">create_time = #{createTime},</if>
+            <if test="updateBy != null">update_by = #{updateBy},</if>
+            <if test="updateTime != null">update_time = #{updateTime},</if>
+            <if test="remark != null">remark = #{remark},</if>
+        </trim>
+        where id = #{id}
+    </update>
+
+    <delete id="deleteActAudituserById">
+        delete from act_audituser where id = #{id}
+    </delete>
+
+    <delete id="deleteActAudituserByIds">
+        delete from act_audituser where id in
+        <foreach item="id" collection="array" open="(" separator="," close=")">
+            #{id}
+        </foreach>
+    </delete>
+
+    <delete id="deleteActAudituserByAll">
+        delete from act_audituser
+    </delete>
+</mapper>

zd-modules/zd-chemical/src/main/resources/mapper/chemical/ActHxpapplyDetailMapper.xml

@@ -0,0 +1,131 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE mapper
+PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
+"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.zd.chemical.mapper.ActHxpapplyDetailMapper">
+
+    <resultMap type="com.zd.chemical.domain.ActHxpapplyDetail" id="ActHxpapplyDetailResult">
+        <result property="id"    column="id"    />
+        <result property="hxpapplyId"    column="hxpapply_id"    />
+        <result property="chemicalId"    column="chemical_id"    />
+        <result property="chemicalName"    column="chemical_name"    />
+        <result property="cabinetId"    column="cabinet_id"    />
+        <result property="applyNum"    column="apply_num"    />
+        <result property="tickStatus"    column="tick_status"    />
+    </resultMap>
+
+    <sql id="selectActHxpapplyDetailVo">
+        select id, hxpapply_id, chemical_id, chemical_name, cabinet_id, apply_num,tick_status from act_hxpapply_detail
+    </sql>
+    <sql id="selectActHxpapplyDetailListVo">
+        select t.id, t.hxpapply_id, t.chemical_id, t.chemical_name, t.cabinet_id, t.apply_num, t.tick_status from act_hxpapply_detail as t
+    </sql>
+    <select id="selectActHxpapplyDetailList" parameterType="com.zd.chemical.domain.ActHxpapplyDetail" resultMap="ActHxpapplyDetailResult">
+        <include refid="selectActHxpapplyDetailVo"/>
+        <where>
+            <if test="hxpapplyId != null "> and hxpapply_id = #{hxpapplyId}</if>
+            <if test="chemicalId != null "> and chemical_id = #{chemicalId}</if>
+            <if test="chemicalName != null  and chemicalName != ''"> and chemical_name like concat('%', #{chemicalName}, '%')</if>
+            <if test="cabinetId != null "> and cabinet_id = #{cabinetId}</if>
+            <if test="applyNum != null "> and apply_num = #{applyNum}</if>
+        </where>
+    </select>
+
+    <select id="selectApplyDetailList" parameterType="com.zd.chemical.domain.ActHxpapplyDetail" resultType="com.zd.chemical.domain.vo.ActHxpapplyDetailVo">
+        SELECT hd.id, hd.chemical_id chemicalId, hd.chemical_name chemicalName,
+        hd.`cabinet_id` cabinetId,ct.cabinet_name cabinetName,
+        CONCAT((SELECT st.name FROM lab_subject st WHERE st.id = hy.sub_id),'-',(SELECT dt.dept_name FROM sys_dept
+        dt,lab_subject st WHERE dt.dept_id = st.build_id AND st.id = hy.sub_id),
+        '-',(SELECT bg.name FROM lab_building bg,lab_subject st WHERE bg.id = st.floor_id AND st.id = hy.sub_id),
+        '-',(SELECT slt.room FROM lab_subject_layout slt,lab_subject st WHERE slt.id = st.layout_id AND st.id = hy.sub_id)) posi,
+        CONCAT(0,cl.`chemical_unit`) collegeInventory,
+        CONCAT(0,cl.`chemical_unit`) subInventory,
+        CONCAT(0,cl.`chemical_unit`) cabinetStorage,
+        CONCAT(0,cl.`chemical_unit`) remainingStorage,
+        hd.apply_num applyNum,cl.`chemical_unit` applyUnit,
+        hd.tick_status tickStatus,
+        (SELECT GROUP_CONCAT(ur.nick_name) FROM sys_user ur WHERE FIND_IN_SET(ur.user_id, s.`safe_user_id`)) AS safeUserNames
+        FROM act_hxpapply_detail hd
+        LEFT JOIN act_hxpapply hy on hy.id = hd.hxpapply_id
+        LEFT JOIN hxp_cabinet ct ON hd.`cabinet_id` = ct.`id`
+        LEFT JOIN hxp_chemical cl ON hd.`chemical_id` = cl.`id`
+        LEFT JOIN lab_subject s ON hy.`sub_id` = s.`id`
+        <where>
+            <if test="tickStatus == 1 "> and hd.tick_status in(0,1)</if>
+            <if test="hxpapplyId != null "> and hd.hxpapply_id = #{hxpapplyId}</if>
+            <if test="chemicalId != null "> and hd.chemical_id = #{chemicalId}</if>
+            <if test="chemicalName != null  and chemicalName != ''"> and hd.chemical_name like concat('%', #{chemicalName}, '%')</if>
+            <if test="cabinetId != null "> and hd.cabinet_id = #{cabinetId}</if>
+            <if test="applyNum != null "> and hd.apply_num = #{applyNum}</if>
+        </where>
+    </select>
+
+    <select id="getListByIds" resultMap="ActHxpapplyDetailResult">
+        <include refid="selectActHxpapplyDetailVo"/>
+        <where>
+            id in
+            <foreach item="id" collection="list" open="(" separator="," close=")">
+                #{id}
+            </foreach>
+        </where>
+    </select>
+
+    <select id="selectActHxpapplyDetailById" resultMap="ActHxpapplyDetailResult">
+        <include refid="selectActHxpapplyDetailVo"/>
+        where id = #{id}
+    </select>
+
+    <insert id="insertActHxpapplyDetail" parameterType="com.zd.chemical.domain.ActHxpapplyDetail" useGeneratedKeys="true" keyProperty="id">
+        insert into act_hxpapply_detail
+        <trim prefix="(" suffix=")" suffixOverrides=",">
+    <if test="hxpapplyId != null">hxpapply_id,</if>
+
+    <if test="chemicalId != null">chemical_id,</if>
+
+    <if test="chemicalName != null">chemical_name,</if>
+
+    <if test="cabinetId != null">cabinet_id,</if>
+
+    <if test="applyNum != null">apply_num,</if>
+
+    <if test="tickStatus != null">tick_status,</if>
+
+         </trim>
+        <trim prefix="values (" suffix=")" suffixOverrides=",">
+    <if test="hxpapplyId != null">#{hxpapplyId},</if>
+    <if test="chemicalId != null">#{chemicalId},</if>
+    <if test="chemicalName != null">#{chemicalName},</if>
+    <if test="cabinetId != null">#{cabinetId},</if>
+    <if test="applyNum != null">#{applyNum},</if>
+    <if test="tickStatus != null">#{tickStatus},</if>
+         </trim>
+    </insert>
+
+    <update id="updateActHxpapplyDetail" parameterType="com.zd.chemical.domain.ActHxpapplyDetail">
+        update act_hxpapply_detail
+        <trim prefix="SET" suffixOverrides=",">
+            <if test="hxpapplyId != null">hxpapply_id = #{hxpapplyId},</if>
+            <if test="chemicalId != null">chemical_id = #{chemicalId},</if>
+            <if test="chemicalName != null">chemical_name = #{chemicalName},</if>
+            <if test="cabinetId != null">cabinet_id = #{cabinetId},</if>
+            <if test="applyNum != null">apply_num = #{applyNum},</if>
+            <if test="tickStatus != null">tick_status = #{tickStatus},</if>
+        </trim>
+        where id = #{id}
+    </update>
+
+    <delete id="deleteActHxpapplyDetailById">
+        delete from act_hxpapply_detail where id = #{id}
+    </delete>
+
+    <delete id="deleteActHxpapplyDetailByApplyId">
+        delete from act_hxpapply_detail where hxpapply_id = #{id}
+    </delete>
+
+    <delete id="deleteActHxpapplyDetailByIds">
+        delete from act_hxpapply_detail where id in
+        <foreach item="id" collection="array" open="(" separator="," close=")">
+            #{id}
+        </foreach>
+    </delete>
+</mapper>

zd-modules/zd-chemical/src/main/resources/mapper/chemical/ActHxpapplyMapper.xml

@@ -0,0 +1,628 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE mapper
+PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
+"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.zd.chemical.mapper.ActHxpapplyMapper">
+
+    <resultMap type="com.zd.chemical.domain.ActHxpapply" id="ActHxpapplyResult">
+        <result property="id"    column="id"    />
+        <result property="applyNum"    column="apply_num"    />
+        <result property="applyReason"    column="apply_reason"    />
+        <result property="subId"    column="sub_id"    />
+        <result property="applyStatus"    column="apply_status"    />
+        <result property="userId"    column="user_id"    />
+        <result property="createBy"    column="create_by"    />
+        <result property="createTime"    column="create_time"    />
+        <result property="updateBy"    column="update_by"    />
+        <result property="updateTime"    column="update_time"    />
+        <result property="remark"    column="remark"    />
+    </resultMap>
+
+    <sql id="selectActHxpapplyVo">
+        select id, apply_num, apply_reason, sub_id, apply_status, user_id, create_by, create_time, update_by, update_time, remark from act_hxpapply
+    </sql>
+    <sql id="selectActHxpapplyListVo">
+        select t.id, t.apply_num, t.apply_reason, t.sub_id, t.apply_status, t.user_id, t.create_by, t.create_time, t.update_by, t.update_time, t.remark from act_hxpapply as t
+    </sql>
+    <select id="selectActHxpapplyList" parameterType="com.zd.chemical.domain.vo.ActHxpapplySearch" resultType="com.zd.chemical.domain.vo.ActHxpapplyListVo">
+        <!--SELECT xx.applyNum,xx.subscriber,xx.subName,xx.chemicalNames,xx.createTime,xx.overTime,xx.approvalContent,xx.approvalStatus,-->
+            <!--CASE WHEN xx.approvalStatus = 0 THEN-->
+            <!--(SELECT GROUP_CONCAT(ur.user_id,';',ur.nick_name) FROM sys_user ur WHERE FIND_IN_SET(ur.user_id,xx.currentApprover))-->
+            <!--ELSE ''-->
+            <!--END currentApprover,-->
+            <!--CASE WHEN xx.approvalStatus = 3 THEN ''-->
+            <!--ELSE (SELECT GROUP_CONCAT(ur.user_id,';',ur.nick_name) FROM sys_user ur WHERE FIND_IN_SET(ur.user_id,xx.historyApprover))-->
+            <!--END historyApprover,-->
+            <!--xx.currentApprover currentApproverIds-->
+            <!--FROM (-->
+            <!--SELECT ah.`apply_num` applyNum,-->
+            <!--su.nick_name subscriber,-->
+            <!--st.`name` subName,-->
+            <!--GROUP_CONCAT(hd.chemical_name) chemicalNames,-->
+            <!--ah.`create_time` createTime,-->
+            <!--ak.`over_time` overTime,-->
+            <!--CASE WHEN ak.approval_status=0 THEN '审批中'-->
+            <!--ELSE CASE WHEN ak.approval_status=1 THEN '已通过'-->
+            <!--ELSE CASE WHEN ak.approval_status=2 THEN '已拒绝'-->
+            <!--ELSE '已撤销'-->
+            <!--END-->
+            <!--END-->
+            <!--END approvalContent,-->
+            <!--ak.approval_status approvalStatus,-->
+            <!--(SELECT an.apply_user_ids FROM  act_applytask apk,act_applytask_node an WHERE an.applytask_id = apk.id AND apk.id = ak.id AND an.node_status = 0-->
+            <!--AND apk.approval_status=0 ORDER BY an.node_order ASC LIMIT 1) currentApprover,-->
+            <!--(SELECT an.apply_user_ids FROM  act_applytask apk,act_applytask_node an WHERE an.applytask_id = apk.id AND apk.id = ak.id AND (an.node_status = 1 OR an.node_status = 2)-->
+            <!--AND (apk.approval_status=0 OR apk.approval_status=1) ORDER BY an.node_order DESC LIMIT 1) historyApprover-->
+            <!--FROM act_hxpapply ah LEFT JOIN sys_user su ON su.user_id = ah.`user_id`-->
+            <!--LEFT JOIN lab_subject st ON st.id = ah.`sub_id`-->
+            <!--LEFT JOIN act_hxpapply_detail hd ON hd.hxpapply_id = ah.id-->
+            <!--LEFT JOIN act_applytask ak ON ak.`task_id` = ah.`id`-->
+            <!--<where>-->
+                <!--ah.apply_status in(1,3)-->
+                <!--<if test="searchValue != null ">-->
+                    <!--and (-->
+                    <!--ah.apply_num like concat('%', #{searchValue}, '%') or-->
+                    <!--su.nick_name like concat('%', #{searchValue}, '%') or-->
+                    <!--hd.chemical_name like concat('%', #{searchValue}, '%') or-->
+                    <!--st.name like concat('%', #{searchValue}, '%')-->
+                    <!--)-->
+                <!--</if>-->
+                <!--<if test="approvalStatus != null ">-->
+                    <!--and ak.approval_status = #{approvalStatus}-->
+                <!--</if>-->
+                <!--<if test="beginCreateTime != null and beginCreateTime != ''">&lt;!&ndash; 申请开始时间 &ndash;&gt;-->
+                    <!--AND date_format(ak.create_time,'%y%m%d') &gt;= date_format(#{beginCreateTime},'%y%m%d')-->
+                <!--</if>-->
+                <!--<if test="endCreateTime != null and endCreateTime != ''">&lt;!&ndash; 申请结束时间 &ndash;&gt;-->
+                    <!--AND date_format(ak.create_time,'%y%m%d') &lt;= date_format(#{endCreateTime},'%y%m%d')-->
+                <!--</if>-->
+
+                <!--<if test="beginOverTime != null and beginOverTime != ''">&lt;!&ndash; 完成开始时间 &ndash;&gt;-->
+                    <!--AND date_format(ak.over_time,'%y%m%d') &gt;= date_format(#{beginOverTime},'%y%m%d')-->
+                <!--</if>-->
+                <!--<if test="endOverTime != null and endOverTime != ''">&lt;!&ndash; 完成结束时间 &ndash;&gt;-->
+                    <!--AND date_format(ak.over_time,'%y%m%d') &lt;= date_format(#{endOverTime},'%y%m%d')-->
+                <!--</if>-->
+            <!--</where>-->
+            <!--GROUP BY ah.`id`-->
+        <!--)xx ORDER BY xx.createTime DESC-->
+
+
+        SELECT xx1.* FROM (
+            SELECT xx.id,xx.applyNum,xx.subscriber,xx.subName,xx.chemicalNames,xx.createTime,xx.overTime,xx.approvalContent,xx.approvalStatus,
+            CASE WHEN xx.approvalStatus = 0 THEN
+            (SELECT GROUP_CONCAT(ur.user_id,';',ur.nick_name) FROM sys_user ur WHERE FIND_IN_SET(ur.user_id,xx.currentApprover))
+            ELSE ''
+            END currentApprover,
+            CASE WHEN xx.approvalStatus = 3 THEN ''
+            ELSE (SELECT GROUP_CONCAT(ur.user_id,';',ur.nick_name) FROM sys_user ur WHERE FIND_IN_SET(ur.user_id,xx.historyApprover))
+            END historyApprover,
+            xx.currentApprover currentApproverIds,xx.userId
+            FROM (
+
+            SELECT ah.id,ah.`apply_num` applyNum,
+            su.nick_name subscriber,
+            st.`name` subName,
+            GROUP_CONCAT(hd.chemical_name ORDER BY hd.chemical_name DESC,'-申购量:',hd.apply_num,'g' SEPARATOR '; ') chemicalNames,
+            ah.`create_time` createTime,
+            ak.`over_time` overTime,
+            CASE WHEN ak.approval_status=0 THEN '审批中'
+            ELSE CASE WHEN ak.approval_status=1 THEN '已通过'
+            ELSE CASE WHEN ak.approval_status=2 THEN '已拒绝'
+            ELSE '已撤销'
+            END
+            END
+            END approvalContent,
+            ak.approval_status approvalStatus,
+            (SELECT an.apply_user_ids FROM  act_applytask apk,act_applytask_node an WHERE an.applytask_id = apk.id AND apk.id = ak.id AND an.node_status = 0
+            AND apk.approval_status=0 ORDER BY an.node_order ASC LIMIT 1) currentApprover,
+            (SELECT an.apply_user_ids FROM  act_applytask apk,act_applytask_node an WHERE an.applytask_id = apk.id AND apk.id = ak.id AND (an.node_status = 1 OR an.node_status = 2)
+            AND (apk.approval_status=0 OR apk.approval_status=1) ORDER BY an.node_order DESC LIMIT 1) historyApprover,
+            ah.user_id userId
+            FROM act_hxpapply ah LEFT JOIN sys_user su ON su.user_id = ah.`user_id`
+            LEFT JOIN lab_subject st ON st.id = ah.`sub_id`
+            LEFT JOIN act_hxpapply_detail hd ON hd.hxpapply_id = ah.id
+            LEFT JOIN act_applytask ak ON ak.`task_id` = ah.`id`
+            <where>
+            ah.apply_status in(1,3)
+            <if test="searchValue != null ">
+            and (
+            ah.apply_num like concat('%', #{searchValue}, '%') or
+            su.nick_name like concat('%', #{searchValue}, '%') or
+            hd.chemical_name like concat('%', #{searchValue}, '%') or
+            st.name like concat('%', #{searchValue}, '%')
+            )
+            </if>
+            <if test="approvalStatus != null ">
+            and ak.approval_status = #{approvalStatus}
+            </if>
+            <if test="beginCreateTime != null and beginCreateTime != ''"><!-- 申请开始时间 -->
+            AND date_format(ak.create_time,'%y%m%d') &gt;= date_format(#{beginCreateTime},'%y%m%d')
+            </if>
+            <if test="endCreateTime != null and endCreateTime != ''"><!-- 申请结束时间 -->
+            AND date_format(ak.create_time,'%y%m%d') &lt;= date_format(#{endCreateTime},'%y%m%d')
+            </if>
+
+            <if test="beginOverTime != null and beginOverTime != ''"><!-- 完成开始时间 -->
+            AND date_format(ak.over_time,'%y%m%d') &gt;= date_format(#{beginOverTime},'%y%m%d')
+            </if>
+            <if test="endOverTime != null and endOverTime != ''"><!-- 完成结束时间 -->
+            AND date_format(ak.over_time,'%y%m%d') &lt;= date_format(#{endOverTime},'%y%m%d')
+            </if>
+            <if test="userId != null and userId != ''"><!-- 创建人id -->
+                and ah.user_id = #{userId}
+            </if>
+            </where>
+            GROUP BY ah.`id`
+            )xx WHERE FIND_IN_SET(#{loginUserId},xx.currentApprover) ORDER BY xx.createTime DESC
+        )xx1
+        UNION
+        SELECT xx1.* FROM (
+            SELECT xx.id,xx.applyNum,xx.subscriber,xx.subName,xx.chemicalNames,xx.createTime,xx.overTime,xx.approvalContent,xx.approvalStatus,
+            CASE WHEN xx.approvalStatus = 0 THEN
+            (SELECT GROUP_CONCAT(ur.user_id,';',ur.nick_name) FROM sys_user ur WHERE FIND_IN_SET(ur.user_id,xx.currentApprover))
+            ELSE ''
+            END currentApprover,
+            CASE WHEN xx.approvalStatus = 3 THEN ''
+            ELSE (SELECT GROUP_CONCAT(ur.user_id,';',ur.nick_name) FROM sys_user ur WHERE FIND_IN_SET(ur.user_id,xx.historyApprover))
+            END historyApprover,
+            xx.currentApprover currentApproverIds,xx.userId
+            FROM (
+
+            SELECT ah.id,ah.`apply_num` applyNum,
+            su.nick_name subscriber,
+            st.`name` subName,
+            GROUP_CONCAT(hd.chemical_name ORDER BY hd.chemical_name DESC,'-申购量:',hd.apply_num,'g' SEPARATOR '; ') chemicalNames,
+            ah.`create_time` createTime,
+            ak.`over_time` overTime,
+            CASE WHEN ak.approval_status=0 THEN '审批中'
+            ELSE CASE WHEN ak.approval_status=1 THEN '已通过'
+            ELSE CASE WHEN ak.approval_status=2 THEN '已拒绝'
+            ELSE '已撤销'
+            END
+            END
+            END approvalContent,
+            ak.approval_status approvalStatus,
+            (SELECT an.apply_user_ids FROM  act_applytask apk,act_applytask_node an WHERE an.applytask_id = apk.id AND apk.id = ak.id AND an.node_status = 0
+            AND apk.approval_status=0 ORDER BY an.node_order ASC LIMIT 1) currentApprover,
+            (SELECT an.apply_user_ids FROM  act_applytask apk,act_applytask_node an WHERE an.applytask_id = apk.id AND apk.id = ak.id AND (an.node_status = 1 OR an.node_status = 2)
+            AND (apk.approval_status=0 OR apk.approval_status=1) ORDER BY an.node_order DESC LIMIT 1) historyApprover,
+            ah.user_id userId
+            FROM act_hxpapply ah LEFT JOIN sys_user su ON su.user_id = ah.`user_id`
+            LEFT JOIN lab_subject st ON st.id = ah.`sub_id`
+            LEFT JOIN act_hxpapply_detail hd ON hd.hxpapply_id = ah.id
+            LEFT JOIN act_applytask ak ON ak.`task_id` = ah.`id`
+            <where>
+                ah.apply_status in(1,3)
+                <if test="searchValue != null ">
+                    and (
+                    ah.apply_num like concat('%', #{searchValue}, '%') or
+                    su.nick_name like concat('%', #{searchValue}, '%') or
+                    hd.chemical_name like concat('%', #{searchValue}, '%') or
+                    st.name like concat('%', #{searchValue}, '%')
+                    )
+                </if>
+                <if test="approvalStatus != null ">
+                    and ak.approval_status = #{approvalStatus}
+                </if>
+                <if test="beginCreateTime != null and beginCreateTime != ''"><!-- 申请开始时间 -->
+                    AND date_format(ak.create_time,'%y%m%d') &gt;= date_format(#{beginCreateTime},'%y%m%d')
+                </if>
+                <if test="endCreateTime != null and endCreateTime != ''"><!-- 申请结束时间 -->
+                    AND date_format(ak.create_time,'%y%m%d') &lt;= date_format(#{endCreateTime},'%y%m%d')
+                </if>
+
+                <if test="beginOverTime != null and beginOverTime != ''"><!-- 完成开始时间 -->
+                    AND date_format(ak.over_time,'%y%m%d') &gt;= date_format(#{beginOverTime},'%y%m%d')
+                </if>
+                <if test="endOverTime != null and endOverTime != ''"><!-- 完成结束时间 -->
+                    AND date_format(ak.over_time,'%y%m%d') &lt;= date_format(#{endOverTime},'%y%m%d')
+                </if>
+                <if test="userId != null and userId != ''"><!-- 创建人id -->
+                    and ah.user_id = #{userId}
+                </if>
+            </where>
+            GROUP BY ah.`id`
+
+            )xx  ORDER BY xx.createTime DESC
+        )xx1
+    </select>
+
+
+    <select id="draftsList" parameterType="com.zd.chemical.domain.vo.ActHxpapplySearch" resultType="com.zd.chemical.domain.vo.ActHxpapplyDraftsListVo">
+        SELECT xx.id,xx.applyNum,xx.subscriber,xx.subName,xx.chemicalNames,xx.createTime,xx.overTime,xx.approvalContent,xx.approvalStatus,
+        CASE WHEN xx.approvalStatus = 0 THEN
+        (SELECT GROUP_CONCAT(ur.user_id,';',ur.nick_name) FROM sys_user ur WHERE FIND_IN_SET(ur.user_id,xx.currentApprover))
+        ELSE ''
+        END currentApprover,
+        CASE WHEN xx.approvalStatus = 3 THEN ''
+        ELSE (SELECT GROUP_CONCAT(ur.user_id,';',ur.nick_name) FROM sys_user ur WHERE FIND_IN_SET(ur.user_id,xx.historyApprover))
+        END historyApprover,
+        xx.currentApprover currentApproverIds
+        FROM (
+        SELECT ah.id,ah.`apply_num` applyNum,
+        su.nick_name subscriber,
+        st.`name` subName,
+        GROUP_CONCAT(hd.chemical_name,'-申购量:',hd.apply_num,'g' SEPARATOR '; ') chemicalNames,
+        ah.`create_time` createTime,
+        ak.`over_time` overTime,
+        CASE WHEN ak.approval_status=0 THEN '审批中'
+        ELSE CASE WHEN ak.approval_status=1 THEN '已通过'
+        ELSE CASE WHEN ak.approval_status=2 THEN '已拒绝'
+        ELSE '已撤销'
+        END
+        END
+        END approvalContent,
+        ak.approval_status approvalStatus,
+        (SELECT an.apply_user_ids FROM  act_applytask apk,act_applytask_node an WHERE an.applytask_id = apk.id AND apk.id = ak.id AND an.node_status = 0
+        AND apk.approval_status=0 ORDER BY an.node_order ASC LIMIT 1) currentApprover,
+        (SELECT an.apply_user_ids FROM  act_applytask apk,act_applytask_node an WHERE an.applytask_id = apk.id AND apk.id = ak.id AND (an.node_status = 1 OR an.node_status = 2)
+        AND (apk.approval_status=0 OR apk.approval_status=1) ORDER BY an.node_order DESC LIMIT 1) historyApprover
+        FROM act_hxpapply ah LEFT JOIN sys_user su ON su.user_id = ah.`user_id`
+        LEFT JOIN lab_subject st ON st.id = ah.`sub_id`
+        LEFT JOIN act_hxpapply_detail hd ON hd.hxpapply_id = ah.id
+        LEFT JOIN act_applytask ak ON ak.`task_id` = ah.`id`
+        <where>
+            ah.apply_status =2 and ah.user_id = #{loginUserId}
+            <if test="searchValue != null ">
+            and (
+            ah.apply_num like concat('%', #{searchValue}, '%') or
+            su.nick_name like concat('%', #{searchValue}, '%') or
+            hd.chemical_name like concat('%', #{searchValue}, '%') or
+            st.name like concat('%', #{searchValue}, '%')
+            )
+            </if>
+            <if test="approvalStatus != null ">
+            and ak.approval_status = #{approvalStatus}
+            </if>
+            <if test="beginCreateTime != null and beginCreateTime != ''"><!-- 申请开始时间 -->
+            AND date_format(ak.create_time,'%y%m%d') &gt;= date_format(#{beginCreateTime},'%y%m%d')
+            </if>
+            <if test="endCreateTime != null and endCreateTime != ''"><!-- 申请结束时间 -->
+            AND date_format(ak.create_time,'%y%m%d') &lt;= date_format(#{endCreateTime},'%y%m%d')
+            </if>
+
+            <if test="beginOverTime != null and beginOverTime != ''"><!-- 完成开始时间 -->
+            AND date_format(ak.over_time,'%y%m%d') &gt;= date_format(#{beginOverTime},'%y%m%d')
+            </if>
+            <if test="endOverTime != null and endOverTime != ''"><!-- 完成结束时间 -->
+            AND date_format(ak.over_time,'%y%m%d') &lt;= date_format(#{endOverTime},'%y%m%d')
+            </if>
+            <if test="userId != null and userId != ''"><!-- 创建人id -->
+                and ah.user_id = #{userId}
+            </if>
+        </where>
+        GROUP BY ah.`id`
+        )xx ORDER BY xx.createTime DESC
+
+
+    </select>
+
+    <select id="getListByIds" resultMap="ActHxpapplyResult">
+        <include refid="selectActHxpapplyVo"/>
+        <where>
+            id in
+            <foreach item="id" collection="list" open="(" separator="," close=")">
+                #{id}
+            </foreach>
+        </where>
+    </select>
+
+    <select id="selectActHxpapplyById" resultType="com.zd.chemical.domain.vo.ActHxpapplyInfoVo">
+        select a.id, a.apply_num, a.apply_reason, a.sub_id, a.apply_status, a.user_id, a.create_by, a.create_time, a.update_by
+        , a.update_time, a.remark,
+         (select ur.nick_name from sys_user ur where ur.user_id = a.user_id) applyUserName,
+         st.name subName,st.dept_id deptId
+        from act_hxpapply a left join lab_subject st on st.id = a.sub_id
+        where a.id = #{id}
+    </select>
+
+
+    <select id="getRestStock" resultType="java.util.Map">
+        SELECT x1.chemical_id chemicalId,CONCAT((IFNULL(x1.applyNum,0)-IFNULL(x2.stockNum,0)),'g') restStock FROM (
+        SELECT hd.`chemical_id`,IFNULL(SUM(hd.`apply_num`),0) applyNum FROM act_hxpapply ah LEFT JOIN act_hxpapply_detail hd ON ah.`id` = hd.`hxpapply_id`
+        LEFT JOIN act_applytask ak ON ah.`id` = ak.`task_id`
+        LEFT JOIN lab_subject st ON ah.sub_id = st.id
+        <where>
+            ak.`approval_status`=1 AND hd.`tick_status`=1
+            <if test="deptId != null ">
+                and st.dept_id = #{deptId}
+            </if>
+            <if test="subId != null ">
+                and ah.sub_id = #{subId}
+            </if>
+            <if test="chemicalId != null ">
+                and hd.`chemical_id` = #{chemicalId}
+            </if>
+            <if test="cabinetId != null ">
+                and hd.`cabinet_id` = #{cabinetId}
+            </if>
+        </where>
+
+        GROUP BY hd.`chemical_id`
+        )x1 LEFT JOIN
+        (
+        SELECT cjc.`chemical_id`,SUM(s.usages-s.tare) stockNum FROM hxp_stock s
+        LEFT JOIN hxp_chemical_join_cabinet cjc ON s.`join_id` = cjc.`id`
+        LEFT JOIN lab_subject st ON s.sub_id = st.id
+        <where>
+            s.status = 1
+            <if test="deptId != null ">
+                and st.dept_id = #{deptId}
+            </if>
+            <if test="subId != null ">
+                and s.sub_id = #{subId}
+            </if>
+            <if test="chemicalId != null ">
+                and cjc.`chemical_id` = #{chemicalId}
+            </if>
+            <if test="cabinetId != null ">
+                and cjc.`cabinet_id` = #{cabinetId}
+            </if>
+        </where>
+        GROUP BY cjc.`chemical_id`
+        )x2 ON x1.chemical_id = x2.chemical_id
+    </select>
+
+
+    <select id="getRestStockClassif" resultType="com.zd.chemical.domain.vo.ActRestStockVo">
+        SELECT 1 chemicalId,CONCAT((IFNULL(x1.applyNum,0)-IFNULL(x2.stockNum,0)),'g') restStock FROM (
+        SELECT hd.`chemical_id`,IFNULL(SUM(hd.`apply_num`),0) applyNum FROM act_hxpapply ah LEFT JOIN act_hxpapply_detail hd ON ah.`id` = hd.`hxpapply_id`
+        LEFT JOIN act_applytask ak ON ah.`id` = ak.`task_id`
+        LEFT JOIN lab_subject st ON ah.sub_id = st.id
+        <where>
+            ak.`approval_status`=1 AND hd.`tick_status`=1
+            <if test="deptId != null ">
+                AND st.dept_id = #{deptId}
+            </if>
+            <if test="chemicalId != null ">
+                AND hd.`chemical_id` = #{chemicalId}
+            </if>
+        </where>
+
+        GROUP BY hd.`chemical_id`
+        )x1 LEFT JOIN
+        (
+        SELECT cjc.`chemical_id`,SUM(s.usages-s.tare) stockNum FROM hxp_stock s
+        LEFT JOIN hxp_chemical_join_cabinet cjc ON s.`join_id` = cjc.`id`
+        LEFT JOIN lab_subject st ON s.sub_id = st.id
+        <where>
+            s.status = 1
+            <if test="deptId != null ">
+                AND st.dept_id = #{deptId}
+            </if>
+            <if test="chemicalId != null ">
+                AND cjc.`chemical_id` = #{chemicalId}
+            </if>
+        </where>
+        GROUP BY cjc.`chemical_id`
+        )x2 ON x1.chemical_id = x2.chemical_id
+
+        UNION ALL
+
+        SELECT 2 chemicalId,CONCAT((IFNULL(x1.applyNum,0)-IFNULL(x2.stockNum,0)),'g') restStock FROM (
+        SELECT hd.`chemical_id`,IFNULL(SUM(hd.`apply_num`),0) applyNum FROM act_hxpapply ah LEFT JOIN act_hxpapply_detail hd ON ah.`id` = hd.`hxpapply_id`
+        LEFT JOIN act_applytask ak ON ah.`id` = ak.`task_id`
+        LEFT JOIN lab_subject st ON ah.sub_id = st.id
+        <where>
+            ak.`approval_status`=1 AND hd.`tick_status`=1
+
+            <if test="subId != null ">
+                AND ah.sub_id = #{subId}
+            </if>
+            <if test="chemicalId != null ">
+                AND hd.`chemical_id` = #{chemicalId}
+            </if>
+        </where>
+
+        GROUP BY hd.`chemical_id`
+        )x1 LEFT JOIN
+        (
+        SELECT cjc.`chemical_id`,SUM(s.usages-s.tare) stockNum FROM hxp_stock s
+        LEFT JOIN hxp_chemical_join_cabinet cjc ON s.`join_id` = cjc.`id`
+        LEFT JOIN lab_subject st ON s.sub_id = st.id
+        <where>
+            s.status = 1
+            <if test="subId != null ">
+                AND s.sub_id = #{subId}
+            </if>
+            <if test="chemicalId != null ">
+                AND cjc.`chemical_id` = #{chemicalId}
+            </if>
+
+        </where>
+        GROUP BY cjc.`chemical_id`
+        )x2 ON x1.chemical_id = x2.chemical_id
+
+        UNION ALL
+
+        SELECT 3 chemicalId,CONCAT((IFNULL(x1.applyNum,0)-IFNULL(x2.stockNum,0)),'g') restStock FROM (
+        SELECT hd.`chemical_id`,IFNULL(SUM(hd.`apply_num`),0) applyNum FROM act_hxpapply ah LEFT JOIN act_hxpapply_detail hd ON ah.`id` = hd.`hxpapply_id`
+        LEFT JOIN act_applytask ak ON ah.`id` = ak.`task_id`
+        LEFT JOIN lab_subject st ON ah.sub_id = st.id
+        <where>
+            ak.`approval_status`=1 AND hd.`tick_status`=1
+            <if test="chemicalId != null ">
+                AND hd.`chemical_id` = #{chemicalId}
+            </if>
+            <if test="cabinetId != null ">
+                AND hd.`cabinet_id` = #{cabinetId}
+            </if>
+        </where>
+
+        GROUP BY hd.`chemical_id`
+        )x1 LEFT JOIN
+        (
+        SELECT cjc.`chemical_id`,SUM(s.usages-s.tare) stockNum FROM hxp_stock s
+        LEFT JOIN hxp_chemical_join_cabinet cjc ON s.`join_id` = cjc.`id`
+        LEFT JOIN lab_subject st ON s.sub_id = st.id
+        <where>
+            s.status = 1
+            <if test="chemicalId != null ">
+                AND cjc.`chemical_id` = #{chemicalId}
+            </if>
+            <if test="cabinetId != null ">
+                AND cjc.`cabinet_id` = #{cabinetId}
+            </if>
+        </where>
+        GROUP BY cjc.`chemical_id`
+        )x2 ON x1.chemical_id = x2.chemical_id
+
+        UNION ALL
+
+        SELECT 4 chemicalId,CONCAT((IFNULL(x1.applyNum,0)-IFNULL(x2.stockNum,0)),'g') restStock FROM (
+        SELECT hd.`chemical_id`,IFNULL(SUM(hd.`apply_num`),0) applyNum FROM act_hxpapply ah LEFT JOIN act_hxpapply_detail hd ON ah.`id` = hd.`hxpapply_id`
+        LEFT JOIN act_applytask ak ON ah.`id` = ak.`task_id`
+        LEFT JOIN lab_subject st ON ah.sub_id = st.id
+        <where>
+            ak.`approval_status`=1 AND hd.`tick_status`=1
+            <if test="deptId != null ">
+                AND st.dept_id = #{deptId}
+            </if>
+            <if test="subId != null ">
+                AND ah.sub_id = #{subId}
+            </if>
+            <if test="chemicalId != null ">
+                AND hd.`chemical_id` = #{chemicalId}
+            </if>
+            <if test="cabinetId != null ">
+                AND hd.`cabinet_id` = #{cabinetId}
+            </if>
+        </where>
+
+        GROUP BY hd.`chemical_id`
+        )x1 LEFT JOIN
+        (
+        SELECT cjc.`chemical_id`,SUM(s.usages-s.tare) stockNum FROM hxp_stock s
+        LEFT JOIN hxp_chemical_join_cabinet cjc ON s.`join_id` = cjc.`id`
+        LEFT JOIN lab_subject st ON s.sub_id = st.id
+        <where>
+            s.status = 1
+            <if test="deptId != null ">
+                AND st.dept_id = #{deptId}
+            </if>
+            <if test="subId != null ">
+                AND s.sub_id = #{subId}
+            </if>
+            <if test="chemicalId != null ">
+                AND cjc.`chemical_id` = #{chemicalId}
+            </if>
+            <if test="cabinetId != null ">
+                AND cjc.`cabinet_id` = #{cabinetId}
+            </if>
+        </where>
+        GROUP BY cjc.`chemical_id`
+        )x2 ON x1.chemical_id = x2.chemical_id
+    </select>
+
+
+
+    <select id="getRestStockByManyCabinet" parameterType="com.zd.chemical.domain.vo.ActRestStockManySearch" resultType="com.zd.chemical.domain.vo.ActRestStockManyVo">
+        SELECT x1.cabinet_id cabinetId,CONCAT((IFNULL(x1.applyNum,0)-IFNULL(x2.stockNum,0))) restStock FROM (
+        SELECT hd.`cabinet_id`,IFNULL(SUM(hd.`apply_num`),0) applyNum FROM act_hxpapply ah LEFT JOIN act_hxpapply_detail hd ON ah.`id` = hd.`hxpapply_id`
+        LEFT JOIN act_applytask ak ON ah.`id` = ak.`task_id`
+        LEFT JOIN lab_subject st ON ah.sub_id = st.id
+        <where>
+            ak.`approval_status`=1 AND hd.`tick_status`=1
+            <if test="chemicalId != null ">
+                and hd.`chemical_id` = #{chemicalId}
+            </if>
+
+            <if test="cabinetIds != null ">
+                and hd.`cabinet_id` in
+                <foreach item="id" collection="cabinetIds" open="(" separator="," close=")">
+                    #{id}
+                </foreach>
+            </if>
+        </where>
+
+        GROUP BY hd.`cabinet_id`
+        )x1 LEFT JOIN
+        (
+        SELECT cjc.`cabinet_id`,SUM(s.usages-s.tare) stockNum FROM hxp_stock s
+        LEFT JOIN hxp_chemical_join_cabinet cjc ON s.`join_id` = cjc.`id`
+        LEFT JOIN lab_subject st ON s.sub_id = st.id
+        <where>
+            s.status = 1
+            <if test="chemicalId != null ">
+                and cjc.`chemical_id` = #{chemicalId}
+            </if>
+            <if test="cabinetIds != null ">
+                and cjc.`cabinet_id` in
+                <foreach item="id" collection="cabinetIds" open="(" separator="," close=")">
+                    #{id}
+                </foreach>
+            </if>
+        </where>
+        GROUP BY cjc.`cabinet_id`
+        )x2 ON x1.cabinet_id = x2.cabinet_id
+    </select>
+
+
+
+    <insert id="insertActHxpapply" parameterType="com.zd.chemical.domain.ActHxpapply" useGeneratedKeys="true" keyProperty="id">
+        insert into act_hxpapply
+        <trim prefix="(" suffix=")" suffixOverrides=",">
+    <if test="applyNum != null">apply_num,</if>
+
+    <if test="applyReason != null">apply_reason,</if>
+
+    <if test="subId != null">sub_id,</if>
+
+    <if test="applyStatus != null">apply_status,</if>
+
+    <if test="userId != null">user_id,</if>
+
+    <if test="createBy != null">create_by,</if>
+
+    <if test="createTime != null">create_time,</if>
+
+    <if test="updateBy != null">update_by,</if>
+
+    <if test="updateTime != null">update_time,</if>
+
+    <if test="remark != null">remark,</if>
+
+         </trim>
+        <trim prefix="values (" suffix=")" suffixOverrides=",">
+    <if test="applyNum != null">#{applyNum},</if>
+    <if test="applyReason != null">#{applyReason},</if>
+    <if test="subId != null">#{subId},</if>
+    <if test="applyStatus != null">#{applyStatus},</if>
+    <if test="userId != null">#{userId},</if>
+    <if test="createBy != null">#{createBy},</if>
+    <if test="createTime != null">#{createTime},</if>
+    <if test="updateBy != null">#{updateBy},</if>
+    <if test="updateTime != null">#{updateTime},</if>
+    <if test="remark != null">#{remark},</if>
+         </trim>
+    </insert>
+
+    <update id="updateActHxpapply" parameterType="com.zd.chemical.domain.ActHxpapply">
+        update act_hxpapply
+        <trim prefix="SET" suffixOverrides=",">
+            <if test="applyNum != null">apply_num = #{applyNum},</if>
+            <if test="applyReason != null">apply_reason = #{applyReason},</if>
+            <if test="subId != null">sub_id = #{subId},</if>
+            <if test="applyStatus != null">apply_status = #{applyStatus},</if>
+            <if test="userId != null">user_id = #{userId},</if>
+            <if test="createBy != null">create_by = #{createBy},</if>
+            <if test="createTime != null">create_time = #{createTime},</if>
+            <if test="updateBy != null">update_by = #{updateBy},</if>
+            <if test="updateTime != null">update_time = #{updateTime},</if>
+            <if test="remark != null">remark = #{remark},</if>
+        </trim>
+        where id = #{id}
+    </update>
+
+    <delete id="deleteActHxpapplyById">
+        delete from act_hxpapply where id = #{id}
+    </delete>
+
+    <delete id="deleteActHxpapplyByIds">
+        delete from act_hxpapply where id in
+        <foreach item="id" collection="array" open="(" separator="," close=")">
+            #{id}
+        </foreach>
+    </delete>
+</mapper>