工装管理基础代码

cuilei

8 天以前 f135716c0df75eeb080eb4c3a606987176da5e92

工装管理基础代码

 db/Ë«ÁÖлð¾æMESÊý¾Ý¿âÉè¼Æ.pdma.json

@@ -2,9 +2,9 @@
  "name": "双林新火炬MES数据库设计",
  "describe": "描述双薪新火炬MES数据库设计详情",
  "avatar": "",
  "version": "4.9.2",
  "version": "4.9.4",
  "createdTime": "2025-3-10 16:38:19",
  "updatedTime": "2025-7-1 14:46:42",
  "updatedTime": "2025-7-28 09:40:53",
  "dbConns": [],
  "profile": {
    "default": {
@@ -632,7 +632,7 @@
      "#DDE5FF"
    ],
    "DDLToggleCase": "L",
    "menuWidth": "376px"
    "menuWidth": "364px"
  },
  "entities": [
    {

 src/main/java/org/jeecg/modules/tms/controller/TmsToolHistoryController.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,177 @@
package org.jeecg.modules.tms.controller;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.system.query.QueryGenerator;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.tms.entity.TmsToolHistory;
import org.jeecg.modules.tms.service.ITmsToolHistoryService;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;

import org.jeecgframework.poi.excel.ExcelImportUtil;
import org.jeecgframework.poi.excel.def.NormalExcelConstants;
import org.jeecgframework.poi.excel.entity.ExportParams;
import org.jeecgframework.poi.excel.entity.ImportParams;
import org.jeecgframework.poi.excel.view.JeecgEntityExcelView;
import org.jeecg.common.system.base.controller.JeecgController;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.servlet.ModelAndView;
import com.alibaba.fastjson.JSON;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.jeecg.common.aspect.annotation.AutoLog;

 /**
 * @Description: å·¥è£…履历
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
@Api(tags="工装履历")
@RestController
@RequestMapping("/tms/tmsToolHistory")
@Slf4j
public class TmsToolHistoryController extends JeecgController<TmsToolHistory, ITmsToolHistoryService> {
    @Autowired
    private ITmsToolHistoryService tmsToolHistoryService;
	
    /**
     * åˆ†é¡µåˆ—表查询
     *
     * @param tmsToolHistory
     * @param pageNo
     * @param pageSize
     * @param req
     * @return
     */
    //@AutoLog(value = "工装履历-分页列表查询")
    @ApiOperation(value="工装履历-分页列表查询", notes="工装履历-分页列表查询")
    @GetMapping(value = "/list")
    public Result<IPage<TmsToolHistory>> queryPageList(TmsToolHistory tmsToolHistory,
                                   @RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
                                   @RequestParam(name="pageSize", defaultValue="10") Integer pageSize,
                                   HttpServletRequest req) {
        QueryWrapper<TmsToolHistory> queryWrapper = QueryGenerator.initQueryWrapper(tmsToolHistory, req.getParameterMap());
        Page<TmsToolHistory> page = new Page<TmsToolHistory>(pageNo, pageSize);
        IPage<TmsToolHistory> pageList = tmsToolHistoryService.page(page, queryWrapper);
        return Result.OK(pageList);
    }
	
    /**
     *   æ·»åŠ 
     *
     * @param tmsToolHistory
     * @return
     */
    @AutoLog(value = "工装履历-添加")
    @ApiOperation(value="工装履历-添加", notes="工装履历-添加")
    //@RequiresPermissions("org.jeecg.modules:tms_tool_history:add")
    @PostMapping(value = "/add")
    public Result<String> add(@RequestBody TmsToolHistory tmsToolHistory) {
        tmsToolHistoryService.save(tmsToolHistory);
        return Result.OK("添加成功！");
    }
	
    /**
     *  ç¼–辑
     *
     * @param tmsToolHistory
     * @return
     */
    @AutoLog(value = "工装履历-编辑")
    @ApiOperation(value="工装履历-编辑", notes="工装履历-编辑")
    //@RequiresPermissions("org.jeecg.modules:tms_tool_history:edit")
    @RequestMapping(value = "/edit", method = {RequestMethod.PUT,RequestMethod.POST})
    public Result<String> edit(@RequestBody TmsToolHistory tmsToolHistory) {
        tmsToolHistoryService.updateById(tmsToolHistory);
        return Result.OK("编辑成功!");
    }
	
    /**
     *   é€šè¿‡id删除
     *
     * @param id
     * @return
     */
    @AutoLog(value = "工装履历-通过id删除")
    @ApiOperation(value="工装履历-通过id删除", notes="工装履历-通过id删除")
    //@RequiresPermissions("org.jeecg.modules:tms_tool_history:delete")
    @DeleteMapping(value = "/delete")
    public Result<String> delete(@RequestParam(name="id",required=true) String id) {
        tmsToolHistoryService.removeById(id);
        return Result.OK("删除成功!");
    }
	
    /**
     *  æ‰¹é‡åˆ é™¤
     *
     * @param ids
     * @return
     */
    @AutoLog(value = "工装履历-批量删除")
    @ApiOperation(value="工装履历-批量删除", notes="工装履历-批量删除")
    //@RequiresPermissions("org.jeecg.modules:tms_tool_history:deleteBatch")
    @DeleteMapping(value = "/deleteBatch")
    public Result<String> deleteBatch(@RequestParam(name="ids",required=true) String ids) {
        this.tmsToolHistoryService.removeByIds(Arrays.asList(ids.split(",")));
        return Result.OK("批量删除成功!");
    }
	
    /**
     * é€šè¿‡id查询
     *
     * @param id
     * @return
     */
    //@AutoLog(value = "工装履历-通过id查询")
    @ApiOperation(value="工装履历-通过id查询", notes="工装履历-通过id查询")
    @GetMapping(value = "/queryById")
    public Result<TmsToolHistory> queryById(@RequestParam(name="id",required=true) String id) {
        TmsToolHistory tmsToolHistory = tmsToolHistoryService.getById(id);
        if(tmsToolHistory==null) {
            return Result.error("未找到对应数据");
        }
        return Result.OK(tmsToolHistory);
    }

    /**
    * å¯¼å‡ºexcel
    *
    * @param request
    * @param tmsToolHistory
    */
    //@RequiresPermissions("org.jeecg.modules:tms_tool_history:exportXls")
    @RequestMapping(value = "/exportXls")
    public ModelAndView exportXls(HttpServletRequest request, TmsToolHistory tmsToolHistory) {
        return super.exportXls(request, tmsToolHistory, TmsToolHistory.class, "工装履历");
    }

    /**
      * é€šè¿‡excel导入数据
    *
    * @param request
    * @param response
    * @return
    */
    //@RequiresPermissions("tms_tool_history:importExcel")
    @RequestMapping(value = "/importExcel", method = RequestMethod.POST)
    public Result<?> importExcel(HttpServletRequest request, HttpServletResponse response) {
        return super.importExcel(request, response, TmsToolHistory.class);
    }

}

 src/main/java/org/jeecg/modules/tms/controller/TmsToolInboundController.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,316 @@
package org.jeecg.modules.tms.controller;

import org.jeecg.common.system.query.QueryGenerator;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.common.system.base.controller.JeecgController;
import org.jeecg.common.api.vo.Result;
import org.jeecg.modules.tms.vo.TmsToolInboundRequest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.ModelAndView;

import java.lang.reflect.InvocationTargetException;
import java.util.Arrays;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.tms.entity.TmsToolInboundDetail;
import org.jeecg.modules.tms.entity.TmsToolInbound;
import org.jeecg.modules.tms.service.ITmsToolInboundService;
import org.jeecg.modules.tms.service.ITmsToolInboundDetailService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.jeecg.common.aspect.annotation.AutoLog;
import org.apache.shiro.SecurityUtils;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecgframework.poi.excel.ExcelImportUtil;
import org.jeecgframework.poi.excel.def.NormalExcelConstants;
import org.jeecgframework.poi.excel.entity.ExportParams;
import org.jeecgframework.poi.excel.entity.ImportParams;
import org.jeecgframework.poi.excel.view.JeecgEntityExcelView;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import java.io.IOException;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

 /**
 * @Description: å·¥è£…入库
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
@Api(tags="工装入库")
@RestController
@RequestMapping("/tms/tmsToolInbound")
@Slf4j
public class TmsToolInboundController extends JeecgController<TmsToolInbound, ITmsToolInboundService> {

    @Autowired
    private ITmsToolInboundService tmsToolInboundService;

    @Autowired
    private ITmsToolInboundDetailService tmsToolInboundDetailService;


    /*---------------------------------主表处理-begin-------------------------------------*/

    /**
     * åˆ†é¡µåˆ—表查询
     * @param tmsToolInbound
     * @param pageNo
     * @param pageSize
     * @param req
     * @return
     */
    //@AutoLog(value = "工装入库-分页列表查询")
    @ApiOperation(value="工装入库-分页列表查询", notes="工装入库-分页列表查询")
    @GetMapping(value = "/list")
    public Result<IPage<TmsToolInbound>> queryPageList(TmsToolInbound tmsToolInbound,
                                   @RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
                                   @RequestParam(name="pageSize", defaultValue="10") Integer pageSize,
                                   HttpServletRequest req) {
        QueryWrapper<TmsToolInbound> queryWrapper = QueryGenerator.initQueryWrapper(tmsToolInbound, req.getParameterMap());
        Page<TmsToolInbound> page = new Page<TmsToolInbound>(pageNo, pageSize);
        IPage<TmsToolInbound> pageList = tmsToolInboundService.page(page, queryWrapper);
        return Result.OK(pageList);
    }

    /**
     *   æ·»åŠ 
     * @param tmsToolInbound
     * @return
     */
    @AutoLog(value = "工装入库-添加")
    @ApiOperation(value="工装入库-添加", notes="工装入库-添加")
    //@RequiresPermissions("org.jeecg.modules:tms_tool_inbound:add")
    @PostMapping(value = "/add")
    public Result<String> add(@RequestBody TmsToolInboundRequest tmsToolInboundRequest) {
        try {
            tmsToolInboundService.add(tmsToolInboundRequest);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return Result.OK("添加成功！");
    }

    /**
     *  ç¼–辑
     * @param tmsToolInbound
     * @return
     */
    @AutoLog(value = "工装入库-编辑")
    @ApiOperation(value="工装入库-编辑", notes="工装入库-编辑")
    //@RequiresPermissions("org.jeecg.modules:tms_tool_inbound:edit")
    @RequestMapping(value = "/edit", method = {RequestMethod.PUT,RequestMethod.POST})
    public Result<String> edit(@RequestBody TmsToolInboundRequest tmsToolInboundRequest) {
        try {
            tmsToolInboundService.update(tmsToolInboundRequest);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return Result.OK("编辑成功!");
    }

    /**
     * é€šè¿‡id删除
     * @param id
     * @return
     */
    @AutoLog(value = "工装入库-通过id删除")
    @ApiOperation(value="工装入库-通过id删除", notes="工装入库-通过id删除")
    //@RequiresPermissions("org.jeecg.modules:tms_tool_inbound:delete")
    @DeleteMapping(value = "/delete")
    public Result<String> delete(@RequestParam(name="id",required=true) String id) {
        tmsToolInboundService.delMain(id);
        return Result.OK("删除成功!");
    }

    /**
     * æ‰¹é‡åˆ é™¤
     * @param ids
     * @return
     */
    @AutoLog(value = "工装入库-批量删除")
    @ApiOperation(value="工装入库-批量删除", notes="工装入库-批量删除")
    //@RequiresPermissions("org.jeecg.modules:tms_tool_inbound:deleteBatch")
    @DeleteMapping(value = "/deleteBatch")
    public Result<String> deleteBatch(@RequestParam(name="ids",required=true) String ids) {
        this.tmsToolInboundService.delBatchMain(Arrays.asList(ids.split(",")));
        return Result.OK("批量删除成功!");
    }

    /**
     * å¯¼å‡º
     * @return
     */
    //@RequiresPermissions("org.jeecg.modules:tms_tool_inbound:exportXls")
    @RequestMapping(value = "/exportXls")
    public ModelAndView exportXls(HttpServletRequest request, TmsToolInbound tmsToolInbound) {
        return super.exportXls(request, tmsToolInbound, TmsToolInbound.class, "工装入库");
    }

    /**
     * å¯¼å…¥
     * @return
     */
    //@RequiresPermissions("org.jeecg.modules:tms_tool_inbound:importExcel")
    @RequestMapping(value = "/importExcel", method = RequestMethod.POST)
    public Result<?> importExcel(HttpServletRequest request, HttpServletResponse response) {
        return super.importExcel(request, response, TmsToolInbound.class);
    }
    /*---------------------------------主表处理-end-------------------------------------*/
	

    /*--------------------------------子表处理-工装入库明细-begin----------------------------------------------*/
    /**
     * é€šè¿‡ä¸»è¡¨ID查询
     * @return
     */
    //@AutoLog(value = "工装入库明细-通过主表ID查询")
    @ApiOperation(value="工装入库明细-通过主表ID查询", notes="工装入库明细-通过主表ID查询")
    @GetMapping(value = "/listTmsToolInboundDetailByMainId")
    public Result<IPage<TmsToolInboundDetail>> listTmsToolInboundDetailByMainId(TmsToolInboundDetail tmsToolInboundDetail,
                                                    @RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
                                                    @RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
                                                    HttpServletRequest req) {
        Map<String, String[]> parameterMap = req.getParameterMap();
        QueryWrapper<TmsToolInboundDetail> queryWrapper = QueryGenerator.initQueryWrapper(tmsToolInboundDetail, parameterMap);
        Page<TmsToolInboundDetail> page = new Page<TmsToolInboundDetail>(pageNo, pageSize);
        IPage<TmsToolInboundDetail> pageList = tmsToolInboundDetailService.queryPageList(page, parameterMap);
        return Result.OK(pageList);
    }

    /**
     * æ·»åŠ 
     * @param tmsToolInboundDetail
     * @return
     */
    @AutoLog(value = "工装入库明细-添加")
    @ApiOperation(value="工装入库明细-添加", notes="工装入库明细-添加")
    @PostMapping(value = "/addTmsToolInboundDetail")
    public Result<String> addTmsToolInboundDetail(@RequestBody TmsToolInboundDetail tmsToolInboundDetail) {
        tmsToolInboundDetailService.save(tmsToolInboundDetail);
        return Result.OK("添加成功！");
    }

    /**
     * ç¼–辑
     * @param tmsToolInboundDetail
     * @return
     */
    @AutoLog(value = "工装入库明细-编辑")
    @ApiOperation(value="工装入库明细-编辑", notes="工装入库明细-编辑")
    @RequestMapping(value = "/editTmsToolInboundDetail", method = {RequestMethod.PUT,RequestMethod.POST})
    public Result<String> editTmsToolInboundDetail(@RequestBody TmsToolInboundDetail tmsToolInboundDetail) {
        tmsToolInboundDetailService.updateById(tmsToolInboundDetail);
        return Result.OK("编辑成功!");
    }

    /**
     * é€šè¿‡id删除
     * @param id
     * @return
     */
    @AutoLog(value = "工装入库明细-通过id删除")
    @ApiOperation(value="工装入库明细-通过id删除", notes="工装入库明细-通过id删除")
    @DeleteMapping(value = "/deleteTmsToolInboundDetail")
    public Result<String> deleteTmsToolInboundDetail(@RequestParam(name="id",required=true) String id) {
        tmsToolInboundDetailService.removeById(id);
        return Result.OK("删除成功!");
    }

    /**
     * æ‰¹é‡åˆ é™¤
     * @param ids
     * @return
     */
    @AutoLog(value = "工装入库明细-批量删除")
    @ApiOperation(value="工装入库明细-批量删除", notes="工装入库明细-批量删除")
    @DeleteMapping(value = "/deleteBatchTmsToolInboundDetail")
    public Result<String> deleteBatchTmsToolInboundDetail(@RequestParam(name="ids",required=true) String ids) {
        this.tmsToolInboundDetailService.removeByIds(Arrays.asList(ids.split(",")));
        return Result.OK("批量删除成功!");
    }

    /**
     * å¯¼å‡º
     * @return
     */
    @RequestMapping(value = "/exportTmsToolInboundDetail")
    public ModelAndView exportTmsToolInboundDetail(HttpServletRequest request, TmsToolInboundDetail tmsToolInboundDetail) {
         // Step.1 ç»„装查询条件
         QueryWrapper<TmsToolInboundDetail> queryWrapper = QueryGenerator.initQueryWrapper(tmsToolInboundDetail, request.getParameterMap());
         LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();

         // Step.2 èŽ·å–导出数据
         List<TmsToolInboundDetail> pageList = tmsToolInboundDetailService.list(queryWrapper);
         List<TmsToolInboundDetail> exportList = null;

         // è¿‡æ»¤é€‰ä¸­æ•°æ®
         String selections = request.getParameter("selections");
         if (oConvertUtils.isNotEmpty(selections)) {
             List<String> selectionList = Arrays.asList(selections.split(","));
             exportList = pageList.stream().filter(item -> selectionList.contains(item.getId())).collect(Collectors.toList());
         } else {
             exportList = pageList;
         }

         // Step.3 AutoPoi å¯¼å‡ºExcel
         ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
         //此处设置的filename无效,前端会重更新设置一下
         mv.addObject(NormalExcelConstants.FILE_NAME, "工装入库明细");
         mv.addObject(NormalExcelConstants.CLASS, TmsToolInboundDetail.class);
         mv.addObject(NormalExcelConstants.PARAMS, new ExportParams("工装入库明细报表", "导出人:" + sysUser.getRealname(), "工装入库明细"));
         mv.addObject(NormalExcelConstants.DATA_LIST, exportList);
         return mv;
    }

    /**
     * å¯¼å…¥
     * @return
     */
    @RequestMapping(value = "/importTmsToolInboundDetail/{mainId}")
    public Result<?> importTmsToolInboundDetail(HttpServletRequest request, HttpServletResponse response, @PathVariable("mainId") String mainId) {
         MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
         Map<String, MultipartFile> fileMap = multipartRequest.getFileMap();
         for (Map.Entry<String, MultipartFile> entity : fileMap.entrySet()) {
       // èŽ·å–上传文件对象
             MultipartFile file = entity.getValue();
             ImportParams params = new ImportParams();
             params.setTitleRows(2);
             params.setHeadRows(1);
             params.setNeedSave(true);
             try {
                 List<TmsToolInboundDetail> list = ExcelImportUtil.importExcel(file.getInputStream(), TmsToolInboundDetail.class, params);
                 for (TmsToolInboundDetail temp : list) {
                    temp.setOrderId(mainId);
                 }
                 long start = System.currentTimeMillis();
                 tmsToolInboundDetailService.saveBatch(list);
                 log.info("消耗时间" + (System.currentTimeMillis() - start) + "毫秒");
                 return Result.OK("文件导入成功！数据行数：" + list.size());
             } catch (Exception e) {
                 log.error(e.getMessage(), e);
                 return Result.error("文件导入失败:" + e.getMessage());
             } finally {
                 try {
                     file.getInputStream().close();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
         }
         return Result.error("文件导入失败！");
    }

    /*--------------------------------子表处理-工装入库明细-end----------------------------------------------*/




}

 src/main/java/org/jeecg/modules/tms/controller/TmsToolInboundInventoryController.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,177 @@
package org.jeecg.modules.tms.controller;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.system.query.QueryGenerator;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.tms.entity.TmsToolInboundInventory;
import org.jeecg.modules.tms.service.ITmsToolInboundInventoryService;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;

import org.jeecgframework.poi.excel.ExcelImportUtil;
import org.jeecgframework.poi.excel.def.NormalExcelConstants;
import org.jeecgframework.poi.excel.entity.ExportParams;
import org.jeecgframework.poi.excel.entity.ImportParams;
import org.jeecgframework.poi.excel.view.JeecgEntityExcelView;
import org.jeecg.common.system.base.controller.JeecgController;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.servlet.ModelAndView;
import com.alibaba.fastjson.JSON;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.jeecg.common.aspect.annotation.AutoLog;

 /**
 * @Description: å·¥è£…入库库存关系
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
@Api(tags="工装入库库存关系")
@RestController
@RequestMapping("/tms/tmsToolInboundInventory")
@Slf4j
public class TmsToolInboundInventoryController extends JeecgController<TmsToolInboundInventory, ITmsToolInboundInventoryService> {
    @Autowired
    private ITmsToolInboundInventoryService tmsToolInboundInventoryService;
	
    /**
     * åˆ†é¡µåˆ—表查询
     *
     * @param tmsToolInboundInventory
     * @param pageNo
     * @param pageSize
     * @param req
     * @return
     */
    //@AutoLog(value = "工装入库库存关系-分页列表查询")
    @ApiOperation(value="工装入库库存关系-分页列表查询", notes="工装入库库存关系-分页列表查询")
    @GetMapping(value = "/list")
    public Result<IPage<TmsToolInboundInventory>> queryPageList(TmsToolInboundInventory tmsToolInboundInventory,
                                   @RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
                                   @RequestParam(name="pageSize", defaultValue="10") Integer pageSize,
                                   HttpServletRequest req) {
        QueryWrapper<TmsToolInboundInventory> queryWrapper = QueryGenerator.initQueryWrapper(tmsToolInboundInventory, req.getParameterMap());
        Page<TmsToolInboundInventory> page = new Page<TmsToolInboundInventory>(pageNo, pageSize);
        IPage<TmsToolInboundInventory> pageList = tmsToolInboundInventoryService.page(page, queryWrapper);
        return Result.OK(pageList);
    }
	
    /**
     *   æ·»åŠ 
     *
     * @param tmsToolInboundInventory
     * @return
     */
    @AutoLog(value = "工装入库库存关系-添加")
    @ApiOperation(value="工装入库库存关系-添加", notes="工装入库库存关系-添加")
    //@RequiresPermissions("org.jeecg.modules:tms_tool_inbound_inventory:add")
    @PostMapping(value = "/add")
    public Result<String> add(@RequestBody TmsToolInboundInventory tmsToolInboundInventory) {
        tmsToolInboundInventoryService.save(tmsToolInboundInventory);
        return Result.OK("添加成功！");
    }
	
    /**
     *  ç¼–辑
     *
     * @param tmsToolInboundInventory
     * @return
     */
    @AutoLog(value = "工装入库库存关系-编辑")
    @ApiOperation(value="工装入库库存关系-编辑", notes="工装入库库存关系-编辑")
    //@RequiresPermissions("org.jeecg.modules:tms_tool_inbound_inventory:edit")
    @RequestMapping(value = "/edit", method = {RequestMethod.PUT,RequestMethod.POST})
    public Result<String> edit(@RequestBody TmsToolInboundInventory tmsToolInboundInventory) {
        tmsToolInboundInventoryService.updateById(tmsToolInboundInventory);
        return Result.OK("编辑成功!");
    }
	
    /**
     *   é€šè¿‡id删除
     *
     * @param id
     * @return
     */
    @AutoLog(value = "工装入库库存关系-通过id删除")
    @ApiOperation(value="工装入库库存关系-通过id删除", notes="工装入库库存关系-通过id删除")
    //@RequiresPermissions("org.jeecg.modules:tms_tool_inbound_inventory:delete")
    @DeleteMapping(value = "/delete")
    public Result<String> delete(@RequestParam(name="id",required=true) String id) {
        tmsToolInboundInventoryService.removeById(id);
        return Result.OK("删除成功!");
    }
	
    /**
     *  æ‰¹é‡åˆ é™¤
     *
     * @param ids
     * @return
     */
    @AutoLog(value = "工装入库库存关系-批量删除")
    @ApiOperation(value="工装入库库存关系-批量删除", notes="工装入库库存关系-批量删除")
    //@RequiresPermissions("org.jeecg.modules:tms_tool_inbound_inventory:deleteBatch")
    @DeleteMapping(value = "/deleteBatch")
    public Result<String> deleteBatch(@RequestParam(name="ids",required=true) String ids) {
        this.tmsToolInboundInventoryService.removeByIds(Arrays.asList(ids.split(",")));
        return Result.OK("批量删除成功!");
    }
	
    /**
     * é€šè¿‡id查询
     *
     * @param id
     * @return
     */
    //@AutoLog(value = "工装入库库存关系-通过id查询")
    @ApiOperation(value="工装入库库存关系-通过id查询", notes="工装入库库存关系-通过id查询")
    @GetMapping(value = "/queryById")
    public Result<TmsToolInboundInventory> queryById(@RequestParam(name="id",required=true) String id) {
        TmsToolInboundInventory tmsToolInboundInventory = tmsToolInboundInventoryService.getById(id);
        if(tmsToolInboundInventory==null) {
            return Result.error("未找到对应数据");
        }
        return Result.OK(tmsToolInboundInventory);
    }

    /**
    * å¯¼å‡ºexcel
    *
    * @param request
    * @param tmsToolInboundInventory
    */
    //@RequiresPermissions("org.jeecg.modules:tms_tool_inbound_inventory:exportXls")
    @RequestMapping(value = "/exportXls")
    public ModelAndView exportXls(HttpServletRequest request, TmsToolInboundInventory tmsToolInboundInventory) {
        return super.exportXls(request, tmsToolInboundInventory, TmsToolInboundInventory.class, "工装入库库存关系");
    }

    /**
      * é€šè¿‡excel导入数据
    *
    * @param request
    * @param response
    * @return
    */
    //@RequiresPermissions("tms_tool_inbound_inventory:importExcel")
    @RequestMapping(value = "/importExcel", method = RequestMethod.POST)
    public Result<?> importExcel(HttpServletRequest request, HttpServletResponse response) {
        return super.importExcel(request, response, TmsToolInboundInventory.class);
    }

}

 src/main/java/org/jeecg/modules/tms/controller/TmsToolInventoryController.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,177 @@
package org.jeecg.modules.tms.controller;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.system.query.QueryGenerator;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.tms.entity.TmsToolInventory;
import org.jeecg.modules.tms.service.ITmsToolInventoryService;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;

import org.jeecgframework.poi.excel.ExcelImportUtil;
import org.jeecgframework.poi.excel.def.NormalExcelConstants;
import org.jeecgframework.poi.excel.entity.ExportParams;
import org.jeecgframework.poi.excel.entity.ImportParams;
import org.jeecgframework.poi.excel.view.JeecgEntityExcelView;
import org.jeecg.common.system.base.controller.JeecgController;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.servlet.ModelAndView;
import com.alibaba.fastjson.JSON;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.jeecg.common.aspect.annotation.AutoLog;

 /**
 * @Description: å·¥è£…库存
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
@Api(tags="工装库存")
@RestController
@RequestMapping("/tms/tmsToolInventory")
@Slf4j
public class TmsToolInventoryController extends JeecgController<TmsToolInventory, ITmsToolInventoryService> {
    @Autowired
    private ITmsToolInventoryService tmsToolInventoryService;
	
    /**
     * åˆ†é¡µåˆ—表查询
     *
     * @param tmsToolInventory
     * @param pageNo
     * @param pageSize
     * @param req
     * @return
     */
    //@AutoLog(value = "工装库存-分页列表查询")
    @ApiOperation(value="工装库存-分页列表查询", notes="工装库存-分页列表查询")
    @GetMapping(value = "/list")
    public Result<IPage<TmsToolInventory>> queryPageList(TmsToolInventory tmsToolInventory,
                                   @RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
                                   @RequestParam(name="pageSize", defaultValue="10") Integer pageSize,
                                   HttpServletRequest req) {
        QueryWrapper<TmsToolInventory> queryWrapper = QueryGenerator.initQueryWrapper(tmsToolInventory, req.getParameterMap());
        Page<TmsToolInventory> page = new Page<TmsToolInventory>(pageNo, pageSize);
        IPage<TmsToolInventory> pageList = tmsToolInventoryService.page(page, queryWrapper);
        return Result.OK(pageList);
    }
	
    /**
     *   æ·»åŠ 
     *
     * @param tmsToolInventory
     * @return
     */
    @AutoLog(value = "工装库存-添加")
    @ApiOperation(value="工装库存-添加", notes="工装库存-添加")
    //@RequiresPermissions("org.jeecg.modules:tms_tool_inventory:add")
    @PostMapping(value = "/add")
    public Result<String> add(@RequestBody TmsToolInventory tmsToolInventory) {
        tmsToolInventoryService.save(tmsToolInventory);
        return Result.OK("添加成功！");
    }
	
    /**
     *  ç¼–辑
     *
     * @param tmsToolInventory
     * @return
     */
    @AutoLog(value = "工装库存-编辑")
    @ApiOperation(value="工装库存-编辑", notes="工装库存-编辑")
    //@RequiresPermissions("org.jeecg.modules:tms_tool_inventory:edit")
    @RequestMapping(value = "/edit", method = {RequestMethod.PUT,RequestMethod.POST})
    public Result<String> edit(@RequestBody TmsToolInventory tmsToolInventory) {
        tmsToolInventoryService.updateById(tmsToolInventory);
        return Result.OK("编辑成功!");
    }
	
    /**
     *   é€šè¿‡id删除
     *
     * @param id
     * @return
     */
    @AutoLog(value = "工装库存-通过id删除")
    @ApiOperation(value="工装库存-通过id删除", notes="工装库存-通过id删除")
    //@RequiresPermissions("org.jeecg.modules:tms_tool_inventory:delete")
    @DeleteMapping(value = "/delete")
    public Result<String> delete(@RequestParam(name="id",required=true) String id) {
        tmsToolInventoryService.removeById(id);
        return Result.OK("删除成功!");
    }
	
    /**
     *  æ‰¹é‡åˆ é™¤
     *
     * @param ids
     * @return
     */
    @AutoLog(value = "工装库存-批量删除")
    @ApiOperation(value="工装库存-批量删除", notes="工装库存-批量删除")
    //@RequiresPermissions("org.jeecg.modules:tms_tool_inventory:deleteBatch")
    @DeleteMapping(value = "/deleteBatch")
    public Result<String> deleteBatch(@RequestParam(name="ids",required=true) String ids) {
        this.tmsToolInventoryService.removeByIds(Arrays.asList(ids.split(",")));
        return Result.OK("批量删除成功!");
    }
	
    /**
     * é€šè¿‡id查询
     *
     * @param id
     * @return
     */
    //@AutoLog(value = "工装库存-通过id查询")
    @ApiOperation(value="工装库存-通过id查询", notes="工装库存-通过id查询")
    @GetMapping(value = "/queryById")
    public Result<TmsToolInventory> queryById(@RequestParam(name="id",required=true) String id) {
        TmsToolInventory tmsToolInventory = tmsToolInventoryService.getById(id);
        if(tmsToolInventory==null) {
            return Result.error("未找到对应数据");
        }
        return Result.OK(tmsToolInventory);
    }

    /**
    * å¯¼å‡ºexcel
    *
    * @param request
    * @param tmsToolInventory
    */
    //@RequiresPermissions("org.jeecg.modules:tms_tool_inventory:exportXls")
    @RequestMapping(value = "/exportXls")
    public ModelAndView exportXls(HttpServletRequest request, TmsToolInventory tmsToolInventory) {
        return super.exportXls(request, tmsToolInventory, TmsToolInventory.class, "工装库存");
    }

    /**
      * é€šè¿‡excel导入数据
    *
    * @param request
    * @param response
    * @return
    */
    //@RequiresPermissions("tms_tool_inventory:importExcel")
    @RequestMapping(value = "/importExcel", method = RequestMethod.POST)
    public Result<?> importExcel(HttpServletRequest request, HttpServletResponse response) {
        return super.importExcel(request, response, TmsToolInventory.class);
    }

}

 src/main/java/org/jeecg/modules/tms/controller/TmsToolReceiveController.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,304 @@
package org.jeecg.modules.tms.controller;

import org.jeecg.common.system.query.QueryGenerator;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.common.system.base.controller.JeecgController;
import org.jeecg.common.api.vo.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.ModelAndView;
import java.util.Arrays;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.tms.entity.TmsToolReceiveDetail;
import org.jeecg.modules.tms.entity.TmsToolReceive;
import org.jeecg.modules.tms.service.ITmsToolReceiveService;
import org.jeecg.modules.tms.service.ITmsToolReceiveDetailService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.jeecg.common.aspect.annotation.AutoLog;
import org.apache.shiro.SecurityUtils;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecgframework.poi.excel.ExcelImportUtil;
import org.jeecgframework.poi.excel.def.NormalExcelConstants;
import org.jeecgframework.poi.excel.entity.ExportParams;
import org.jeecgframework.poi.excel.entity.ImportParams;
import org.jeecgframework.poi.excel.view.JeecgEntityExcelView;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import java.io.IOException;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

 /**
 * @Description: å·¥è£…领用
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
@Api(tags="工装领用")
@RestController
@RequestMapping("/tms/tmsToolReceive")
@Slf4j
public class TmsToolReceiveController extends JeecgController<TmsToolReceive, ITmsToolReceiveService> {

    @Autowired
    private ITmsToolReceiveService tmsToolReceiveService;

    @Autowired
    private ITmsToolReceiveDetailService tmsToolReceiveDetailService;


    /*---------------------------------主表处理-begin-------------------------------------*/

    /**
     * åˆ†é¡µåˆ—表查询
     * @param tmsToolReceive
     * @param pageNo
     * @param pageSize
     * @param req
     * @return
     */
    //@AutoLog(value = "工装领用-分页列表查询")
    @ApiOperation(value="工装领用-分页列表查询", notes="工装领用-分页列表查询")
    @GetMapping(value = "/list")
    public Result<IPage<TmsToolReceive>> queryPageList(TmsToolReceive tmsToolReceive,
                                   @RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
                                   @RequestParam(name="pageSize", defaultValue="10") Integer pageSize,
                                   HttpServletRequest req) {
        QueryWrapper<TmsToolReceive> queryWrapper = QueryGenerator.initQueryWrapper(tmsToolReceive, req.getParameterMap());
        Page<TmsToolReceive> page = new Page<TmsToolReceive>(pageNo, pageSize);
        IPage<TmsToolReceive> pageList = tmsToolReceiveService.page(page, queryWrapper);
        return Result.OK(pageList);
    }

    /**
     *   æ·»åŠ 
     * @param tmsToolReceive
     * @return
     */
    @AutoLog(value = "工装领用-添加")
    @ApiOperation(value="工装领用-添加", notes="工装领用-添加")
    //@RequiresPermissions("org.jeecg.modules:tms_tool_receive:add")
    @PostMapping(value = "/add")
    public Result<String> add(@RequestBody TmsToolReceive tmsToolReceive) {
        tmsToolReceiveService.save(tmsToolReceive);
        return Result.OK("添加成功！");
    }

    /**
     *  ç¼–辑
     * @param tmsToolReceive
     * @return
     */
    @AutoLog(value = "工装领用-编辑")
    @ApiOperation(value="工装领用-编辑", notes="工装领用-编辑")
    //@RequiresPermissions("org.jeecg.modules:tms_tool_receive:edit")
    @RequestMapping(value = "/edit", method = {RequestMethod.PUT,RequestMethod.POST})
    public Result<String> edit(@RequestBody TmsToolReceive tmsToolReceive) {
        tmsToolReceiveService.updateById(tmsToolReceive);
        return Result.OK("编辑成功!");
    }

    /**
     * é€šè¿‡id删除
     * @param id
     * @return
     */
    @AutoLog(value = "工装领用-通过id删除")
    @ApiOperation(value="工装领用-通过id删除", notes="工装领用-通过id删除")
    //@RequiresPermissions("org.jeecg.modules:tms_tool_receive:delete")
    @DeleteMapping(value = "/delete")
    public Result<String> delete(@RequestParam(name="id",required=true) String id) {
        tmsToolReceiveService.delMain(id);
        return Result.OK("删除成功!");
    }

    /**
     * æ‰¹é‡åˆ é™¤
     * @param ids
     * @return
     */
    @AutoLog(value = "工装领用-批量删除")
    @ApiOperation(value="工装领用-批量删除", notes="工装领用-批量删除")
    //@RequiresPermissions("org.jeecg.modules:tms_tool_receive:deleteBatch")
    @DeleteMapping(value = "/deleteBatch")
    public Result<String> deleteBatch(@RequestParam(name="ids",required=true) String ids) {
        this.tmsToolReceiveService.delBatchMain(Arrays.asList(ids.split(",")));
        return Result.OK("批量删除成功!");
    }

    /**
     * å¯¼å‡º
     * @return
     */
    //@RequiresPermissions("org.jeecg.modules:tms_tool_receive:exportXls")
    @RequestMapping(value = "/exportXls")
    public ModelAndView exportXls(HttpServletRequest request, TmsToolReceive tmsToolReceive) {
        return super.exportXls(request, tmsToolReceive, TmsToolReceive.class, "工装领用");
    }

    /**
     * å¯¼å…¥
     * @return
     */
    //@RequiresPermissions("org.jeecg.modules:tms_tool_receive:importExcel")
    @RequestMapping(value = "/importExcel", method = RequestMethod.POST)
    public Result<?> importExcel(HttpServletRequest request, HttpServletResponse response) {
        return super.importExcel(request, response, TmsToolReceive.class);
    }
    /*---------------------------------主表处理-end-------------------------------------*/
	

    /*--------------------------------子表处理-工装领用明细-begin----------------------------------------------*/
    /**
     * é€šè¿‡ä¸»è¡¨ID查询
     * @return
     */
    //@AutoLog(value = "工装领用明细-通过主表ID查询")
    @ApiOperation(value="工装领用明细-通过主表ID查询", notes="工装领用明细-通过主表ID查询")
    @GetMapping(value = "/listTmsToolReceiveDetailByMainId")
    public Result<IPage<TmsToolReceiveDetail>> listTmsToolReceiveDetailByMainId(TmsToolReceiveDetail tmsToolReceiveDetail,
                                                    @RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
                                                    @RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
                                                    HttpServletRequest req) {
        QueryWrapper<TmsToolReceiveDetail> queryWrapper = QueryGenerator.initQueryWrapper(tmsToolReceiveDetail, req.getParameterMap());
        Page<TmsToolReceiveDetail> page = new Page<TmsToolReceiveDetail>(pageNo, pageSize);
        IPage<TmsToolReceiveDetail> pageList = tmsToolReceiveDetailService.page(page, queryWrapper);
        return Result.OK(pageList);
    }

    /**
     * æ·»åŠ 
     * @param tmsToolReceiveDetail
     * @return
     */
    @AutoLog(value = "工装领用明细-添加")
    @ApiOperation(value="工装领用明细-添加", notes="工装领用明细-添加")
    @PostMapping(value = "/addTmsToolReceiveDetail")
    public Result<String> addTmsToolReceiveDetail(@RequestBody TmsToolReceiveDetail tmsToolReceiveDetail) {
        tmsToolReceiveDetailService.save(tmsToolReceiveDetail);
        return Result.OK("添加成功！");
    }

    /**
     * ç¼–辑
     * @param tmsToolReceiveDetail
     * @return
     */
    @AutoLog(value = "工装领用明细-编辑")
    @ApiOperation(value="工装领用明细-编辑", notes="工装领用明细-编辑")
    @RequestMapping(value = "/editTmsToolReceiveDetail", method = {RequestMethod.PUT,RequestMethod.POST})
    public Result<String> editTmsToolReceiveDetail(@RequestBody TmsToolReceiveDetail tmsToolReceiveDetail) {
        tmsToolReceiveDetailService.updateById(tmsToolReceiveDetail);
        return Result.OK("编辑成功!");
    }

    /**
     * é€šè¿‡id删除
     * @param id
     * @return
     */
    @AutoLog(value = "工装领用明细-通过id删除")
    @ApiOperation(value="工装领用明细-通过id删除", notes="工装领用明细-通过id删除")
    @DeleteMapping(value = "/deleteTmsToolReceiveDetail")
    public Result<String> deleteTmsToolReceiveDetail(@RequestParam(name="id",required=true) String id) {
        tmsToolReceiveDetailService.removeById(id);
        return Result.OK("删除成功!");
    }

    /**
     * æ‰¹é‡åˆ é™¤
     * @param ids
     * @return
     */
    @AutoLog(value = "工装领用明细-批量删除")
    @ApiOperation(value="工装领用明细-批量删除", notes="工装领用明细-批量删除")
    @DeleteMapping(value = "/deleteBatchTmsToolReceiveDetail")
    public Result<String> deleteBatchTmsToolReceiveDetail(@RequestParam(name="ids",required=true) String ids) {
        this.tmsToolReceiveDetailService.removeByIds(Arrays.asList(ids.split(",")));
        return Result.OK("批量删除成功!");
    }

    /**
     * å¯¼å‡º
     * @return
     */
    @RequestMapping(value = "/exportTmsToolReceiveDetail")
    public ModelAndView exportTmsToolReceiveDetail(HttpServletRequest request, TmsToolReceiveDetail tmsToolReceiveDetail) {
         // Step.1 ç»„装查询条件
         QueryWrapper<TmsToolReceiveDetail> queryWrapper = QueryGenerator.initQueryWrapper(tmsToolReceiveDetail, request.getParameterMap());
         LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();

         // Step.2 èŽ·å–导出数据
         List<TmsToolReceiveDetail> pageList = tmsToolReceiveDetailService.list(queryWrapper);
         List<TmsToolReceiveDetail> exportList = null;

         // è¿‡æ»¤é€‰ä¸­æ•°æ®
         String selections = request.getParameter("selections");
         if (oConvertUtils.isNotEmpty(selections)) {
             List<String> selectionList = Arrays.asList(selections.split(","));
             exportList = pageList.stream().filter(item -> selectionList.contains(item.getId())).collect(Collectors.toList());
         } else {
             exportList = pageList;
         }

         // Step.3 AutoPoi å¯¼å‡ºExcel
         ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
         //此处设置的filename无效,前端会重更新设置一下
         mv.addObject(NormalExcelConstants.FILE_NAME, "工装领用明细");
         mv.addObject(NormalExcelConstants.CLASS, TmsToolReceiveDetail.class);
         mv.addObject(NormalExcelConstants.PARAMS, new ExportParams("工装领用明细报表", "导出人:" + sysUser.getRealname(), "工装领用明细"));
         mv.addObject(NormalExcelConstants.DATA_LIST, exportList);
         return mv;
    }

    /**
     * å¯¼å…¥
     * @return
     */
    @RequestMapping(value = "/importTmsToolReceiveDetail/{mainId}")
    public Result<?> importTmsToolReceiveDetail(HttpServletRequest request, HttpServletResponse response, @PathVariable("mainId") String mainId) {
         MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
         Map<String, MultipartFile> fileMap = multipartRequest.getFileMap();
         for (Map.Entry<String, MultipartFile> entity : fileMap.entrySet()) {
       // èŽ·å–上传文件对象
             MultipartFile file = entity.getValue();
             ImportParams params = new ImportParams();
             params.setTitleRows(2);
             params.setHeadRows(1);
             params.setNeedSave(true);
             try {
                 List<TmsToolReceiveDetail> list = ExcelImportUtil.importExcel(file.getInputStream(), TmsToolReceiveDetail.class, params);
                 for (TmsToolReceiveDetail temp : list) {
                    temp.setOrderId(mainId);
                 }
                 long start = System.currentTimeMillis();
                 tmsToolReceiveDetailService.saveBatch(list);
                 log.info("消耗时间" + (System.currentTimeMillis() - start) + "毫秒");
                 return Result.OK("文件导入成功！数据行数：" + list.size());
             } catch (Exception e) {
                 log.error(e.getMessage(), e);
                 return Result.error("文件导入失败:" + e.getMessage());
             } finally {
                 try {
                     file.getInputStream().close();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
         }
         return Result.error("文件导入失败！");
    }

    /*--------------------------------子表处理-工装领用明细-end----------------------------------------------*/




}

 src/main/java/org/jeecg/modules/tms/controller/TmsToolScrapController.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,304 @@
package org.jeecg.modules.tms.controller;

import org.jeecg.common.system.query.QueryGenerator;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.common.system.base.controller.JeecgController;
import org.jeecg.common.api.vo.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.ModelAndView;
import java.util.Arrays;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.tms.entity.TmsToolScrapDetail;
import org.jeecg.modules.tms.entity.TmsToolScrap;
import org.jeecg.modules.tms.service.ITmsToolScrapService;
import org.jeecg.modules.tms.service.ITmsToolScrapDetailService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.jeecg.common.aspect.annotation.AutoLog;
import org.apache.shiro.SecurityUtils;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecgframework.poi.excel.ExcelImportUtil;
import org.jeecgframework.poi.excel.def.NormalExcelConstants;
import org.jeecgframework.poi.excel.entity.ExportParams;
import org.jeecgframework.poi.excel.entity.ImportParams;
import org.jeecgframework.poi.excel.view.JeecgEntityExcelView;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import java.io.IOException;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

 /**
 * @Description: å·¥è£…报废
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
@Api(tags="工装报废")
@RestController
@RequestMapping("/tms/tmsToolScrap")
@Slf4j
public class TmsToolScrapController extends JeecgController<TmsToolScrap, ITmsToolScrapService> {

    @Autowired
    private ITmsToolScrapService tmsToolScrapService;

    @Autowired
    private ITmsToolScrapDetailService tmsToolScrapDetailService;


    /*---------------------------------主表处理-begin-------------------------------------*/

    /**
     * åˆ†é¡µåˆ—表查询
     * @param tmsToolScrap
     * @param pageNo
     * @param pageSize
     * @param req
     * @return
     */
    //@AutoLog(value = "工装报废-分页列表查询")
    @ApiOperation(value="工装报废-分页列表查询", notes="工装报废-分页列表查询")
    @GetMapping(value = "/list")
    public Result<IPage<TmsToolScrap>> queryPageList(TmsToolScrap tmsToolScrap,
                                   @RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
                                   @RequestParam(name="pageSize", defaultValue="10") Integer pageSize,
                                   HttpServletRequest req) {
        QueryWrapper<TmsToolScrap> queryWrapper = QueryGenerator.initQueryWrapper(tmsToolScrap, req.getParameterMap());
        Page<TmsToolScrap> page = new Page<TmsToolScrap>(pageNo, pageSize);
        IPage<TmsToolScrap> pageList = tmsToolScrapService.page(page, queryWrapper);
        return Result.OK(pageList);
    }

    /**
     *   æ·»åŠ 
     * @param tmsToolScrap
     * @return
     */
    @AutoLog(value = "工装报废-添加")
    @ApiOperation(value="工装报废-添加", notes="工装报废-添加")
    //@RequiresPermissions("org.jeecg.modules:tms_tool_scrap:add")
    @PostMapping(value = "/add")
    public Result<String> add(@RequestBody TmsToolScrap tmsToolScrap) {
        tmsToolScrapService.save(tmsToolScrap);
        return Result.OK("添加成功！");
    }

    /**
     *  ç¼–辑
     * @param tmsToolScrap
     * @return
     */
    @AutoLog(value = "工装报废-编辑")
    @ApiOperation(value="工装报废-编辑", notes="工装报废-编辑")
    //@RequiresPermissions("org.jeecg.modules:tms_tool_scrap:edit")
    @RequestMapping(value = "/edit", method = {RequestMethod.PUT,RequestMethod.POST})
    public Result<String> edit(@RequestBody TmsToolScrap tmsToolScrap) {
        tmsToolScrapService.updateById(tmsToolScrap);
        return Result.OK("编辑成功!");
    }

    /**
     * é€šè¿‡id删除
     * @param id
     * @return
     */
    @AutoLog(value = "工装报废-通过id删除")
    @ApiOperation(value="工装报废-通过id删除", notes="工装报废-通过id删除")
    //@RequiresPermissions("org.jeecg.modules:tms_tool_scrap:delete")
    @DeleteMapping(value = "/delete")
    public Result<String> delete(@RequestParam(name="id",required=true) String id) {
        tmsToolScrapService.delMain(id);
        return Result.OK("删除成功!");
    }

    /**
     * æ‰¹é‡åˆ é™¤
     * @param ids
     * @return
     */
    @AutoLog(value = "工装报废-批量删除")
    @ApiOperation(value="工装报废-批量删除", notes="工装报废-批量删除")
    //@RequiresPermissions("org.jeecg.modules:tms_tool_scrap:deleteBatch")
    @DeleteMapping(value = "/deleteBatch")
    public Result<String> deleteBatch(@RequestParam(name="ids",required=true) String ids) {
        this.tmsToolScrapService.delBatchMain(Arrays.asList(ids.split(",")));
        return Result.OK("批量删除成功!");
    }

    /**
     * å¯¼å‡º
     * @return
     */
    //@RequiresPermissions("org.jeecg.modules:tms_tool_scrap:exportXls")
    @RequestMapping(value = "/exportXls")
    public ModelAndView exportXls(HttpServletRequest request, TmsToolScrap tmsToolScrap) {
        return super.exportXls(request, tmsToolScrap, TmsToolScrap.class, "工装报废");
    }

    /**
     * å¯¼å…¥
     * @return
     */
    //@RequiresPermissions("org.jeecg.modules:tms_tool_scrap:importExcel")
    @RequestMapping(value = "/importExcel", method = RequestMethod.POST)
    public Result<?> importExcel(HttpServletRequest request, HttpServletResponse response) {
        return super.importExcel(request, response, TmsToolScrap.class);
    }
    /*---------------------------------主表处理-end-------------------------------------*/
	

    /*--------------------------------子表处理-工装报废明细-begin----------------------------------------------*/
    /**
     * é€šè¿‡ä¸»è¡¨ID查询
     * @return
     */
    //@AutoLog(value = "工装报废明细-通过主表ID查询")
    @ApiOperation(value="工装报废明细-通过主表ID查询", notes="工装报废明细-通过主表ID查询")
    @GetMapping(value = "/listTmsToolScrapDetailByMainId")
    public Result<IPage<TmsToolScrapDetail>> listTmsToolScrapDetailByMainId(TmsToolScrapDetail tmsToolScrapDetail,
                                                    @RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
                                                    @RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
                                                    HttpServletRequest req) {
        QueryWrapper<TmsToolScrapDetail> queryWrapper = QueryGenerator.initQueryWrapper(tmsToolScrapDetail, req.getParameterMap());
        Page<TmsToolScrapDetail> page = new Page<TmsToolScrapDetail>(pageNo, pageSize);
        IPage<TmsToolScrapDetail> pageList = tmsToolScrapDetailService.page(page, queryWrapper);
        return Result.OK(pageList);
    }

    /**
     * æ·»åŠ 
     * @param tmsToolScrapDetail
     * @return
     */
    @AutoLog(value = "工装报废明细-添加")
    @ApiOperation(value="工装报废明细-添加", notes="工装报废明细-添加")
    @PostMapping(value = "/addTmsToolScrapDetail")
    public Result<String> addTmsToolScrapDetail(@RequestBody TmsToolScrapDetail tmsToolScrapDetail) {
        tmsToolScrapDetailService.save(tmsToolScrapDetail);
        return Result.OK("添加成功！");
    }

    /**
     * ç¼–辑
     * @param tmsToolScrapDetail
     * @return
     */
    @AutoLog(value = "工装报废明细-编辑")
    @ApiOperation(value="工装报废明细-编辑", notes="工装报废明细-编辑")
    @RequestMapping(value = "/editTmsToolScrapDetail", method = {RequestMethod.PUT,RequestMethod.POST})
    public Result<String> editTmsToolScrapDetail(@RequestBody TmsToolScrapDetail tmsToolScrapDetail) {
        tmsToolScrapDetailService.updateById(tmsToolScrapDetail);
        return Result.OK("编辑成功!");
    }

    /**
     * é€šè¿‡id删除
     * @param id
     * @return
     */
    @AutoLog(value = "工装报废明细-通过id删除")
    @ApiOperation(value="工装报废明细-通过id删除", notes="工装报废明细-通过id删除")
    @DeleteMapping(value = "/deleteTmsToolScrapDetail")
    public Result<String> deleteTmsToolScrapDetail(@RequestParam(name="id",required=true) String id) {
        tmsToolScrapDetailService.removeById(id);
        return Result.OK("删除成功!");
    }

    /**
     * æ‰¹é‡åˆ é™¤
     * @param ids
     * @return
     */
    @AutoLog(value = "工装报废明细-批量删除")
    @ApiOperation(value="工装报废明细-批量删除", notes="工装报废明细-批量删除")
    @DeleteMapping(value = "/deleteBatchTmsToolScrapDetail")
    public Result<String> deleteBatchTmsToolScrapDetail(@RequestParam(name="ids",required=true) String ids) {
        this.tmsToolScrapDetailService.removeByIds(Arrays.asList(ids.split(",")));
        return Result.OK("批量删除成功!");
    }

    /**
     * å¯¼å‡º
     * @return
     */
    @RequestMapping(value = "/exportTmsToolScrapDetail")
    public ModelAndView exportTmsToolScrapDetail(HttpServletRequest request, TmsToolScrapDetail tmsToolScrapDetail) {
         // Step.1 ç»„装查询条件
         QueryWrapper<TmsToolScrapDetail> queryWrapper = QueryGenerator.initQueryWrapper(tmsToolScrapDetail, request.getParameterMap());
         LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();

         // Step.2 èŽ·å–导出数据
         List<TmsToolScrapDetail> pageList = tmsToolScrapDetailService.list(queryWrapper);
         List<TmsToolScrapDetail> exportList = null;

         // è¿‡æ»¤é€‰ä¸­æ•°æ®
         String selections = request.getParameter("selections");
         if (oConvertUtils.isNotEmpty(selections)) {
             List<String> selectionList = Arrays.asList(selections.split(","));
             exportList = pageList.stream().filter(item -> selectionList.contains(item.getId())).collect(Collectors.toList());
         } else {
             exportList = pageList;
         }

         // Step.3 AutoPoi å¯¼å‡ºExcel
         ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
         //此处设置的filename无效,前端会重更新设置一下
         mv.addObject(NormalExcelConstants.FILE_NAME, "工装报废明细");
         mv.addObject(NormalExcelConstants.CLASS, TmsToolScrapDetail.class);
         mv.addObject(NormalExcelConstants.PARAMS, new ExportParams("工装报废明细报表", "导出人:" + sysUser.getRealname(), "工装报废明细"));
         mv.addObject(NormalExcelConstants.DATA_LIST, exportList);
         return mv;
    }

    /**
     * å¯¼å…¥
     * @return
     */
    @RequestMapping(value = "/importTmsToolScrapDetail/{mainId}")
    public Result<?> importTmsToolScrapDetail(HttpServletRequest request, HttpServletResponse response, @PathVariable("mainId") String mainId) {
         MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
         Map<String, MultipartFile> fileMap = multipartRequest.getFileMap();
         for (Map.Entry<String, MultipartFile> entity : fileMap.entrySet()) {
       // èŽ·å–上传文件对象
             MultipartFile file = entity.getValue();
             ImportParams params = new ImportParams();
             params.setTitleRows(2);
             params.setHeadRows(1);
             params.setNeedSave(true);
             try {
                 List<TmsToolScrapDetail> list = ExcelImportUtil.importExcel(file.getInputStream(), TmsToolScrapDetail.class, params);
                 for (TmsToolScrapDetail temp : list) {
                    temp.setOrderId(mainId);
                 }
                 long start = System.currentTimeMillis();
                 tmsToolScrapDetailService.saveBatch(list);
                 log.info("消耗时间" + (System.currentTimeMillis() - start) + "毫秒");
                 return Result.OK("文件导入成功！数据行数：" + list.size());
             } catch (Exception e) {
                 log.error(e.getMessage(), e);
                 return Result.error("文件导入失败:" + e.getMessage());
             } finally {
                 try {
                     file.getInputStream().close();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
         }
         return Result.error("文件导入失败！");
    }

    /*--------------------------------子表处理-工装报废明细-end----------------------------------------------*/




}

 src/main/java/org/jeecg/modules/tms/controller/TmsToolStocktakingController.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,304 @@
package org.jeecg.modules.tms.controller;

import org.jeecg.common.system.query.QueryGenerator;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.common.system.base.controller.JeecgController;
import org.jeecg.common.api.vo.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.ModelAndView;
import java.util.Arrays;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.tms.entity.TmsToolStocktakingDetail;
import org.jeecg.modules.tms.entity.TmsToolStocktaking;
import org.jeecg.modules.tms.service.ITmsToolStocktakingService;
import org.jeecg.modules.tms.service.ITmsToolStocktakingDetailService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.jeecg.common.aspect.annotation.AutoLog;
import org.apache.shiro.SecurityUtils;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecgframework.poi.excel.ExcelImportUtil;
import org.jeecgframework.poi.excel.def.NormalExcelConstants;
import org.jeecgframework.poi.excel.entity.ExportParams;
import org.jeecgframework.poi.excel.entity.ImportParams;
import org.jeecgframework.poi.excel.view.JeecgEntityExcelView;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import java.io.IOException;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

 /**
 * @Description: å·¥è£…盘点
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
@Api(tags="工装盘点")
@RestController
@RequestMapping("/tms/tmsToolStocktaking")
@Slf4j
public class TmsToolStocktakingController extends JeecgController<TmsToolStocktaking, ITmsToolStocktakingService> {

    @Autowired
    private ITmsToolStocktakingService tmsToolStocktakingService;

    @Autowired
    private ITmsToolStocktakingDetailService tmsToolStocktakingDetailService;


    /*---------------------------------主表处理-begin-------------------------------------*/

    /**
     * åˆ†é¡µåˆ—表查询
     * @param tmsToolStocktaking
     * @param pageNo
     * @param pageSize
     * @param req
     * @return
     */
    //@AutoLog(value = "工装盘点-分页列表查询")
    @ApiOperation(value="工装盘点-分页列表查询", notes="工装盘点-分页列表查询")
    @GetMapping(value = "/list")
    public Result<IPage<TmsToolStocktaking>> queryPageList(TmsToolStocktaking tmsToolStocktaking,
                                   @RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
                                   @RequestParam(name="pageSize", defaultValue="10") Integer pageSize,
                                   HttpServletRequest req) {
        QueryWrapper<TmsToolStocktaking> queryWrapper = QueryGenerator.initQueryWrapper(tmsToolStocktaking, req.getParameterMap());
        Page<TmsToolStocktaking> page = new Page<TmsToolStocktaking>(pageNo, pageSize);
        IPage<TmsToolStocktaking> pageList = tmsToolStocktakingService.page(page, queryWrapper);
        return Result.OK(pageList);
    }

    /**
     *   æ·»åŠ 
     * @param tmsToolStocktaking
     * @return
     */
    @AutoLog(value = "工装盘点-添加")
    @ApiOperation(value="工装盘点-添加", notes="工装盘点-添加")
    //@RequiresPermissions("org.jeecg.modules:tms_tool_stocktaking:add")
    @PostMapping(value = "/add")
    public Result<String> add(@RequestBody TmsToolStocktaking tmsToolStocktaking) {
        tmsToolStocktakingService.save(tmsToolStocktaking);
        return Result.OK("添加成功！");
    }

    /**
     *  ç¼–辑
     * @param tmsToolStocktaking
     * @return
     */
    @AutoLog(value = "工装盘点-编辑")
    @ApiOperation(value="工装盘点-编辑", notes="工装盘点-编辑")
    //@RequiresPermissions("org.jeecg.modules:tms_tool_stocktaking:edit")
    @RequestMapping(value = "/edit", method = {RequestMethod.PUT,RequestMethod.POST})
    public Result<String> edit(@RequestBody TmsToolStocktaking tmsToolStocktaking) {
        tmsToolStocktakingService.updateById(tmsToolStocktaking);
        return Result.OK("编辑成功!");
    }

    /**
     * é€šè¿‡id删除
     * @param id
     * @return
     */
    @AutoLog(value = "工装盘点-通过id删除")
    @ApiOperation(value="工装盘点-通过id删除", notes="工装盘点-通过id删除")
    //@RequiresPermissions("org.jeecg.modules:tms_tool_stocktaking:delete")
    @DeleteMapping(value = "/delete")
    public Result<String> delete(@RequestParam(name="id",required=true) String id) {
        tmsToolStocktakingService.delMain(id);
        return Result.OK("删除成功!");
    }

    /**
     * æ‰¹é‡åˆ é™¤
     * @param ids
     * @return
     */
    @AutoLog(value = "工装盘点-批量删除")
    @ApiOperation(value="工装盘点-批量删除", notes="工装盘点-批量删除")
    //@RequiresPermissions("org.jeecg.modules:tms_tool_stocktaking:deleteBatch")
    @DeleteMapping(value = "/deleteBatch")
    public Result<String> deleteBatch(@RequestParam(name="ids",required=true) String ids) {
        this.tmsToolStocktakingService.delBatchMain(Arrays.asList(ids.split(",")));
        return Result.OK("批量删除成功!");
    }

    /**
     * å¯¼å‡º
     * @return
     */
    //@RequiresPermissions("org.jeecg.modules:tms_tool_stocktaking:exportXls")
    @RequestMapping(value = "/exportXls")
    public ModelAndView exportXls(HttpServletRequest request, TmsToolStocktaking tmsToolStocktaking) {
        return super.exportXls(request, tmsToolStocktaking, TmsToolStocktaking.class, "工装盘点");
    }

    /**
     * å¯¼å…¥
     * @return
     */
    //@RequiresPermissions("org.jeecg.modules:tms_tool_stocktaking:importExcel")
    @RequestMapping(value = "/importExcel", method = RequestMethod.POST)
    public Result<?> importExcel(HttpServletRequest request, HttpServletResponse response) {
        return super.importExcel(request, response, TmsToolStocktaking.class);
    }
    /*---------------------------------主表处理-end-------------------------------------*/
	

    /*--------------------------------子表处理-工装盘点明细-begin----------------------------------------------*/
    /**
     * é€šè¿‡ä¸»è¡¨ID查询
     * @return
     */
    //@AutoLog(value = "工装盘点明细-通过主表ID查询")
    @ApiOperation(value="工装盘点明细-通过主表ID查询", notes="工装盘点明细-通过主表ID查询")
    @GetMapping(value = "/listTmsToolStocktakingDetailByMainId")
    public Result<IPage<TmsToolStocktakingDetail>> listTmsToolStocktakingDetailByMainId(TmsToolStocktakingDetail tmsToolStocktakingDetail,
                                                    @RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
                                                    @RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
                                                    HttpServletRequest req) {
        QueryWrapper<TmsToolStocktakingDetail> queryWrapper = QueryGenerator.initQueryWrapper(tmsToolStocktakingDetail, req.getParameterMap());
        Page<TmsToolStocktakingDetail> page = new Page<TmsToolStocktakingDetail>(pageNo, pageSize);
        IPage<TmsToolStocktakingDetail> pageList = tmsToolStocktakingDetailService.page(page, queryWrapper);
        return Result.OK(pageList);
    }

    /**
     * æ·»åŠ 
     * @param tmsToolStocktakingDetail
     * @return
     */
    @AutoLog(value = "工装盘点明细-添加")
    @ApiOperation(value="工装盘点明细-添加", notes="工装盘点明细-添加")
    @PostMapping(value = "/addTmsToolStocktakingDetail")
    public Result<String> addTmsToolStocktakingDetail(@RequestBody TmsToolStocktakingDetail tmsToolStocktakingDetail) {
        tmsToolStocktakingDetailService.save(tmsToolStocktakingDetail);
        return Result.OK("添加成功！");
    }

    /**
     * ç¼–辑
     * @param tmsToolStocktakingDetail
     * @return
     */
    @AutoLog(value = "工装盘点明细-编辑")
    @ApiOperation(value="工装盘点明细-编辑", notes="工装盘点明细-编辑")
    @RequestMapping(value = "/editTmsToolStocktakingDetail", method = {RequestMethod.PUT,RequestMethod.POST})
    public Result<String> editTmsToolStocktakingDetail(@RequestBody TmsToolStocktakingDetail tmsToolStocktakingDetail) {
        tmsToolStocktakingDetailService.updateById(tmsToolStocktakingDetail);
        return Result.OK("编辑成功!");
    }

    /**
     * é€šè¿‡id删除
     * @param id
     * @return
     */
    @AutoLog(value = "工装盘点明细-通过id删除")
    @ApiOperation(value="工装盘点明细-通过id删除", notes="工装盘点明细-通过id删除")
    @DeleteMapping(value = "/deleteTmsToolStocktakingDetail")
    public Result<String> deleteTmsToolStocktakingDetail(@RequestParam(name="id",required=true) String id) {
        tmsToolStocktakingDetailService.removeById(id);
        return Result.OK("删除成功!");
    }

    /**
     * æ‰¹é‡åˆ é™¤
     * @param ids
     * @return
     */
    @AutoLog(value = "工装盘点明细-批量删除")
    @ApiOperation(value="工装盘点明细-批量删除", notes="工装盘点明细-批量删除")
    @DeleteMapping(value = "/deleteBatchTmsToolStocktakingDetail")
    public Result<String> deleteBatchTmsToolStocktakingDetail(@RequestParam(name="ids",required=true) String ids) {
        this.tmsToolStocktakingDetailService.removeByIds(Arrays.asList(ids.split(",")));
        return Result.OK("批量删除成功!");
    }

    /**
     * å¯¼å‡º
     * @return
     */
    @RequestMapping(value = "/exportTmsToolStocktakingDetail")
    public ModelAndView exportTmsToolStocktakingDetail(HttpServletRequest request, TmsToolStocktakingDetail tmsToolStocktakingDetail) {
         // Step.1 ç»„装查询条件
         QueryWrapper<TmsToolStocktakingDetail> queryWrapper = QueryGenerator.initQueryWrapper(tmsToolStocktakingDetail, request.getParameterMap());
         LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();

         // Step.2 èŽ·å–导出数据
         List<TmsToolStocktakingDetail> pageList = tmsToolStocktakingDetailService.list(queryWrapper);
         List<TmsToolStocktakingDetail> exportList = null;

         // è¿‡æ»¤é€‰ä¸­æ•°æ®
         String selections = request.getParameter("selections");
         if (oConvertUtils.isNotEmpty(selections)) {
             List<String> selectionList = Arrays.asList(selections.split(","));
             exportList = pageList.stream().filter(item -> selectionList.contains(item.getId())).collect(Collectors.toList());
         } else {
             exportList = pageList;
         }

         // Step.3 AutoPoi å¯¼å‡ºExcel
         ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
         //此处设置的filename无效,前端会重更新设置一下
         mv.addObject(NormalExcelConstants.FILE_NAME, "工装盘点明细");
         mv.addObject(NormalExcelConstants.CLASS, TmsToolStocktakingDetail.class);
         mv.addObject(NormalExcelConstants.PARAMS, new ExportParams("工装盘点明细报表", "导出人:" + sysUser.getRealname(), "工装盘点明细"));
         mv.addObject(NormalExcelConstants.DATA_LIST, exportList);
         return mv;
    }

    /**
     * å¯¼å…¥
     * @return
     */
    @RequestMapping(value = "/importTmsToolStocktakingDetail/{mainId}")
    public Result<?> importTmsToolStocktakingDetail(HttpServletRequest request, HttpServletResponse response, @PathVariable("mainId") String mainId) {
         MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
         Map<String, MultipartFile> fileMap = multipartRequest.getFileMap();
         for (Map.Entry<String, MultipartFile> entity : fileMap.entrySet()) {
       // èŽ·å–上传文件对象
             MultipartFile file = entity.getValue();
             ImportParams params = new ImportParams();
             params.setTitleRows(2);
             params.setHeadRows(1);
             params.setNeedSave(true);
             try {
                 List<TmsToolStocktakingDetail> list = ExcelImportUtil.importExcel(file.getInputStream(), TmsToolStocktakingDetail.class, params);
                 for (TmsToolStocktakingDetail temp : list) {
                    temp.setOrderId(mainId);
                 }
                 long start = System.currentTimeMillis();
                 tmsToolStocktakingDetailService.saveBatch(list);
                 log.info("消耗时间" + (System.currentTimeMillis() - start) + "毫秒");
                 return Result.OK("文件导入成功！数据行数：" + list.size());
             } catch (Exception e) {
                 log.error(e.getMessage(), e);
                 return Result.error("文件导入失败:" + e.getMessage());
             } finally {
                 try {
                     file.getInputStream().close();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
         }
         return Result.error("文件导入失败！");
    }

    /*--------------------------------子表处理-工装盘点明细-end----------------------------------------------*/




}

 src/main/java/org/jeecg/modules/tms/controller/TmsToolStocktakingInventoryChangeController.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,177 @@
package org.jeecg.modules.tms.controller;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.system.query.QueryGenerator;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.tms.entity.TmsToolStocktakingInventoryChange;
import org.jeecg.modules.tms.service.ITmsToolStocktakingInventoryChangeService;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;

import org.jeecgframework.poi.excel.ExcelImportUtil;
import org.jeecgframework.poi.excel.def.NormalExcelConstants;
import org.jeecgframework.poi.excel.entity.ExportParams;
import org.jeecgframework.poi.excel.entity.ImportParams;
import org.jeecgframework.poi.excel.view.JeecgEntityExcelView;
import org.jeecg.common.system.base.controller.JeecgController;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.servlet.ModelAndView;
import com.alibaba.fastjson.JSON;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.jeecg.common.aspect.annotation.AutoLog;

 /**
 * @Description: ç›˜ç‚¹åº“存变更
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
@Api(tags="盘点库存变更")
@RestController
@RequestMapping("/tms/tmsToolStocktakingInventoryChange")
@Slf4j
public class TmsToolStocktakingInventoryChangeController extends JeecgController<TmsToolStocktakingInventoryChange, ITmsToolStocktakingInventoryChangeService> {
    @Autowired
    private ITmsToolStocktakingInventoryChangeService tmsToolStocktakingInventoryChangeService;
	
    /**
     * åˆ†é¡µåˆ—表查询
     *
     * @param tmsToolStocktakingInventoryChange
     * @param pageNo
     * @param pageSize
     * @param req
     * @return
     */
    //@AutoLog(value = "盘点库存变更-分页列表查询")
    @ApiOperation(value="盘点库存变更-分页列表查询", notes="盘点库存变更-分页列表查询")
    @GetMapping(value = "/list")
    public Result<IPage<TmsToolStocktakingInventoryChange>> queryPageList(TmsToolStocktakingInventoryChange tmsToolStocktakingInventoryChange,
                                   @RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
                                   @RequestParam(name="pageSize", defaultValue="10") Integer pageSize,
                                   HttpServletRequest req) {
        QueryWrapper<TmsToolStocktakingInventoryChange> queryWrapper = QueryGenerator.initQueryWrapper(tmsToolStocktakingInventoryChange, req.getParameterMap());
        Page<TmsToolStocktakingInventoryChange> page = new Page<TmsToolStocktakingInventoryChange>(pageNo, pageSize);
        IPage<TmsToolStocktakingInventoryChange> pageList = tmsToolStocktakingInventoryChangeService.page(page, queryWrapper);
        return Result.OK(pageList);
    }
	
    /**
     *   æ·»åŠ 
     *
     * @param tmsToolStocktakingInventoryChange
     * @return
     */
    @AutoLog(value = "盘点库存变更-添加")
    @ApiOperation(value="盘点库存变更-添加", notes="盘点库存变更-添加")
    //@RequiresPermissions("org.jeecg.modules:tms_tool_stocktaking_inventory_change:add")
    @PostMapping(value = "/add")
    public Result<String> add(@RequestBody TmsToolStocktakingInventoryChange tmsToolStocktakingInventoryChange) {
        tmsToolStocktakingInventoryChangeService.save(tmsToolStocktakingInventoryChange);
        return Result.OK("添加成功！");
    }
	
    /**
     *  ç¼–辑
     *
     * @param tmsToolStocktakingInventoryChange
     * @return
     */
    @AutoLog(value = "盘点库存变更-编辑")
    @ApiOperation(value="盘点库存变更-编辑", notes="盘点库存变更-编辑")
    //@RequiresPermissions("org.jeecg.modules:tms_tool_stocktaking_inventory_change:edit")
    @RequestMapping(value = "/edit", method = {RequestMethod.PUT,RequestMethod.POST})
    public Result<String> edit(@RequestBody TmsToolStocktakingInventoryChange tmsToolStocktakingInventoryChange) {
        tmsToolStocktakingInventoryChangeService.updateById(tmsToolStocktakingInventoryChange);
        return Result.OK("编辑成功!");
    }
	
    /**
     *   é€šè¿‡id删除
     *
     * @param id
     * @return
     */
    @AutoLog(value = "盘点库存变更-通过id删除")
    @ApiOperation(value="盘点库存变更-通过id删除", notes="盘点库存变更-通过id删除")
    //@RequiresPermissions("org.jeecg.modules:tms_tool_stocktaking_inventory_change:delete")
    @DeleteMapping(value = "/delete")
    public Result<String> delete(@RequestParam(name="id",required=true) String id) {
        tmsToolStocktakingInventoryChangeService.removeById(id);
        return Result.OK("删除成功!");
    }
	
    /**
     *  æ‰¹é‡åˆ é™¤
     *
     * @param ids
     * @return
     */
    @AutoLog(value = "盘点库存变更-批量删除")
    @ApiOperation(value="盘点库存变更-批量删除", notes="盘点库存变更-批量删除")
    //@RequiresPermissions("org.jeecg.modules:tms_tool_stocktaking_inventory_change:deleteBatch")
    @DeleteMapping(value = "/deleteBatch")
    public Result<String> deleteBatch(@RequestParam(name="ids",required=true) String ids) {
        this.tmsToolStocktakingInventoryChangeService.removeByIds(Arrays.asList(ids.split(",")));
        return Result.OK("批量删除成功!");
    }
	
    /**
     * é€šè¿‡id查询
     *
     * @param id
     * @return
     */
    //@AutoLog(value = "盘点库存变更-通过id查询")
    @ApiOperation(value="盘点库存变更-通过id查询", notes="盘点库存变更-通过id查询")
    @GetMapping(value = "/queryById")
    public Result<TmsToolStocktakingInventoryChange> queryById(@RequestParam(name="id",required=true) String id) {
        TmsToolStocktakingInventoryChange tmsToolStocktakingInventoryChange = tmsToolStocktakingInventoryChangeService.getById(id);
        if(tmsToolStocktakingInventoryChange==null) {
            return Result.error("未找到对应数据");
        }
        return Result.OK(tmsToolStocktakingInventoryChange);
    }

    /**
    * å¯¼å‡ºexcel
    *
    * @param request
    * @param tmsToolStocktakingInventoryChange
    */
    //@RequiresPermissions("org.jeecg.modules:tms_tool_stocktaking_inventory_change:exportXls")
    @RequestMapping(value = "/exportXls")
    public ModelAndView exportXls(HttpServletRequest request, TmsToolStocktakingInventoryChange tmsToolStocktakingInventoryChange) {
        return super.exportXls(request, tmsToolStocktakingInventoryChange, TmsToolStocktakingInventoryChange.class, "盘点库存变更");
    }

    /**
      * é€šè¿‡excel导入数据
    *
    * @param request
    * @param response
    * @return
    */
    //@RequiresPermissions("tms_tool_stocktaking_inventory_change:importExcel")
    @RequestMapping(value = "/importExcel", method = RequestMethod.POST)
    public Result<?> importExcel(HttpServletRequest request, HttpServletResponse response) {
        return super.importExcel(request, response, TmsToolStocktakingInventoryChange.class);
    }

}

 src/main/java/org/jeecg/modules/tms/controller/TmsToolsController.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,160 @@
package org.jeecg.modules.tms.controller;

import java.util.Arrays;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.system.query.QueryGenerator;
import org.jeecg.modules.tms.entity.TmsTools;
import org.jeecg.modules.tms.service.ITmsToolsService;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.common.system.base.controller.JeecgController;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.ModelAndView;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.jeecg.common.aspect.annotation.AutoLog;

 /**
 * @Description: å·¥è£…信息
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
@Api(tags="工装信息")
@RestController
@RequestMapping("/tms/tmsTools")
@Slf4j
public class TmsToolsController extends JeecgController<TmsTools, ITmsToolsService> {
    @Autowired
    private ITmsToolsService tmsToolsService;
	
    /**
     * åˆ†é¡µåˆ—表查询
     *
     * @param tmsTools
     * @param pageNo
     * @param pageSize
     * @param req
     * @return
     */
    //@AutoLog(value = "工装信息-分页列表查询")
    @ApiOperation(value="工装信息-分页列表查询", notes="工装信息-分页列表查询")
    @GetMapping(value = "/list")
    public Result<IPage<TmsTools>> queryPageList(TmsTools tmsTools,
                                   @RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
                                   @RequestParam(name="pageSize", defaultValue="10") Integer pageSize,
                                   HttpServletRequest req) {
        QueryWrapper<TmsTools> queryWrapper = QueryGenerator.initQueryWrapper(tmsTools, req.getParameterMap());
        Page<TmsTools> page = new Page<TmsTools>(pageNo, pageSize);
        IPage<TmsTools> pageList = tmsToolsService.page(page, queryWrapper);
        return Result.OK(pageList);
    }
	
    /**
     *   æ·»åŠ 
     *
     * @param tmsTools
     * @return
     */
    @AutoLog(value = "工装信息-添加")
    @ApiOperation(value="工装信息-添加", notes="工装信息-添加")
    //@RequiresPermissions("org.jeecg.modules:tms_tools:add")
    @PostMapping(value = "/add")
    public Result<String> add(@RequestBody TmsTools tmsTools) {
        tmsToolsService.save(tmsTools);
        return Result.OK("添加成功！");
    }
	
    /**
     *  ç¼–辑
     *
     * @param tmsTools
     * @return
     */
    @AutoLog(value = "工装信息-编辑")
    @ApiOperation(value="工装信息-编辑", notes="工装信息-编辑")
    //@RequiresPermissions("org.jeecg.modules:tms_tools:edit")
    @RequestMapping(value = "/edit", method = {RequestMethod.PUT,RequestMethod.POST})
    public Result<String> edit(@RequestBody TmsTools tmsTools) {
        tmsToolsService.updateById(tmsTools);
        return Result.OK("编辑成功!");
    }
	
    /**
     *   é€šè¿‡id删除
     *
     * @param id
     * @return
     */
    @AutoLog(value = "工装信息-通过id删除")
    @ApiOperation(value="工装信息-通过id删除", notes="工装信息-通过id删除")
    //@RequiresPermissions("org.jeecg.modules:tms_tools:delete")
    @DeleteMapping(value = "/delete")
    public Result<String> delete(@RequestParam(name="id",required=true) String id) {
        tmsToolsService.removeById(id);
        return Result.OK("删除成功!");
    }
	
    /**
     *  æ‰¹é‡åˆ é™¤
     *
     * @param ids
     * @return
     */
    @AutoLog(value = "工装信息-批量删除")
    @ApiOperation(value="工装信息-批量删除", notes="工装信息-批量删除")
    //@RequiresPermissions("org.jeecg.modules:tms_tools:deleteBatch")
    @DeleteMapping(value = "/deleteBatch")
    public Result<String> deleteBatch(@RequestParam(name="ids",required=true) String ids) {
        this.tmsToolsService.removeByIds(Arrays.asList(ids.split(",")));
        return Result.OK("批量删除成功!");
    }
	
    /**
     * é€šè¿‡id查询
     *
     * @param id
     * @return
     */
    //@AutoLog(value = "工装信息-通过id查询")
    @ApiOperation(value="工装信息-通过id查询", notes="工装信息-通过id查询")
    @GetMapping(value = "/queryById")
    public Result<TmsTools> queryById(@RequestParam(name="id",required=true) String id) {
        TmsTools tmsTools = tmsToolsService.getById(id);
        if(tmsTools==null) {
            return Result.error("未找到对应数据");
        }
        return Result.OK(tmsTools);
    }

    /**
    * å¯¼å‡ºexcel
    *
    * @param request
    * @param tmsTools
    */
    //@RequiresPermissions("org.jeecg.modules:tms_tools:exportXls")
    @RequestMapping(value = "/exportXls")
    public ModelAndView exportXls(HttpServletRequest request, TmsTools tmsTools) {
        return super.exportXls(request, tmsTools, TmsTools.class, "工装信息");
    }

    /**
      * é€šè¿‡excel导入数据
    *
    * @param request
    * @param response
    * @return
    */
    //@RequiresPermissions("tms_tools:importExcel")
    @RequestMapping(value = "/importExcel", method = RequestMethod.POST)
    public Result<?> importExcel(HttpServletRequest request, HttpServletResponse response) {
        return super.importExcel(request, response, TmsTools.class);
    }

}

 src/main/java/org/jeecg/modules/tms/entity/TmsToolHistory.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,91 @@
package org.jeecg.modules.tms.entity;

import java.io.Serializable;
import java.io.UnsupportedEncodingException;
import java.util.Date;
import java.math.BigDecimal;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.TableLogic;
import lombok.Data;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.jeecg.common.constant.CommonConstant;
import org.springframework.format.annotation.DateTimeFormat;
import org.jeecgframework.poi.excel.annotation.Excel;
import org.jeecg.common.aspect.annotation.Dict;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;

/**
 * @Description: å·¥è£…履历
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
@Data
@TableName("tms_tool_history")
@Accessors(chain = true)
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="tms_tool_history对象", description="工装履历")
public class TmsToolHistory implements Serializable {
    private static final long serialVersionUID = 1L;

    /**主键*/
    @TableId(type = IdType.ASSIGN_ID)
    @ApiModelProperty(value = "主键")
    private String id;
    /**创建人*/
    @ApiModelProperty(value = "创建人")
    private String createBy;
    /**创建时间*/
    @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd")
    @DateTimeFormat(pattern="yyyy-MM-dd")
    @ApiModelProperty(value = "创建时间")
    private Date createTime;
    /**更新人*/
    @ApiModelProperty(value = "更新人")
    private String updateBy;
    /**更新时间*/
    @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd")
    @DateTimeFormat(pattern="yyyy-MM-dd")
    @ApiModelProperty(value = "更新时间")
    private Date updateTime;
    /**删除标记*/
    @Excel(name = "删除标记", width = 15)
    @ApiModelProperty(value = "删除标记")
    @TableLogic
    private Integer delFlag = CommonConstant.DEL_FLAG_0;
    /**库存ID*/
    @Excel(name = "库存ID", width = 15)
    @ApiModelProperty(value = "库存ID")
    private String inventoryId;
    /**工装条码*/
    @Excel(name = "工装条码", width = 15)
    @ApiModelProperty(value = "工装条码")
    private String toolBarcode;
    /**操作人*/
    @Excel(name = "操作人", width = 15)
    @ApiModelProperty(value = "操作人")
    private String operator;
    /**操作时间*/
    @Excel(name = "操作时间", width = 15, format = "yyyy-MM-dd")
    @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd")
    @DateTimeFormat(pattern="yyyy-MM-dd")
    @ApiModelProperty(value = "操作时间")
    private Date operateTime;
    /**操作类型*/
    @Excel(name = "操作类型", width = 15)
    @ApiModelProperty(value = "操作类型")
    private String operateType;
    /**业务主表*/
    @Excel(name = "业务主表", width = 15)
    @ApiModelProperty(value = "业务主表")
    private String businessTable;
    /**业务id*/
    @Excel(name = "业务id", width = 15)
    @ApiModelProperty(value = "业务id")
    private String businessId;
}

 src/main/java/org/jeecg/modules/tms/entity/TmsToolInbound.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,88 @@
package org.jeecg.modules.tms.entity;

import java.io.Serializable;
import java.io.UnsupportedEncodingException;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.TableLogic;
import org.jeecg.common.constant.CommonConstant;
import org.jeecgframework.poi.excel.annotation.Excel;
import lombok.Data;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.springframework.format.annotation.DateTimeFormat;
import org.jeecg.common.aspect.annotation.Dict;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;

/**
 * @Description: å·¥è£…入库
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
@Data
@TableName("tms_tool_inbound")
@ApiModel(value="tms_tool_inbound对象", description="工装入库")
public class TmsToolInbound implements Serializable {
    private static final long serialVersionUID = 1L;

    /**主键*/
    @TableId(type = IdType.ASSIGN_ID)
    @ApiModelProperty(value = "主键")
    private String id;
    /**创建人*/
    @ApiModelProperty(value = "创建人")
    private String createBy;
    /**创建时间*/
    @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
    @DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
    @ApiModelProperty(value = "创建时间")
    private Date createTime;
    /**更新人*/
    @ApiModelProperty(value = "更新人")
    private String updateBy;
    /**更新时间*/
    @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
    @DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
    @ApiModelProperty(value = "更新时间")
    private Date updateTime;
    /**删除标记*/
    @Excel(name = "删除标记", width = 15)
    @ApiModelProperty(value = "删除标记")
    @TableLogic
    private Integer delFlag = CommonConstant.DEL_FLAG_0;
    /**入库单状态*/
    @Excel(name = "入库单状态", width = 15)
    @ApiModelProperty(value = "入库单状态")
    private String orderStatus;
    /**入库人*/
    @Excel(name = "入库人", width = 15)
    @ApiModelProperty(value = "入库人")
    private String receiver;
    /**入库时间*/
    @Excel(name = "入库时间", width = 15, format = "yyyy-MM-dd HH:mm")
    @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm")
    @DateTimeFormat(pattern="yyyy-MM-dd")
    @ApiModelProperty(value = "入库时间")
    private Date receiveTime;
    /**入库说明*/
    @Excel(name = "入库说明", width = 15)
    @ApiModelProperty(value = "入库说明")
    private String receiveComment;
    /**确认人*/
    @Excel(name = "确认人", width = 15)
    @ApiModelProperty(value = "确认人")
    private String confirmer;
    /**确认时间*/
    @Excel(name = "确认时间", width = 15, format = "yyyy-MM-dd HH:mm")
    @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm")
    @DateTimeFormat(pattern="yyyy-MM-dd")
    @ApiModelProperty(value = "确认时间")
    private Date confirmTime;
    /**确认意见*/
    @Excel(name = "确认意见", width = 15)
    @ApiModelProperty(value = "确认意见")
    private String confirmComment;
}

 src/main/java/org/jeecg/modules/tms/entity/TmsToolInboundDetail.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,77 @@
package org.jeecg.modules.tms.entity;

import java.io.Serializable;

import com.baomidou.mybatisplus.annotation.*;
import org.jeecg.common.aspect.annotation.Dict;
import lombok.Data;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.springframework.format.annotation.DateTimeFormat;
import org.jeecgframework.poi.excel.annotation.Excel;
import java.util.Date;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import java.io.UnsupportedEncodingException;

/**
 * @Description: å·¥è£…入库明细
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
@Data
@TableName("tms_tool_inbound_detail")
@ApiModel(value="tms_tool_inbound_detail对象", description="工装入库明细")
public class TmsToolInboundDetail implements Serializable {
    private static final long serialVersionUID = 1L;

    /**主键*/
    @TableId(type = IdType.ASSIGN_ID)
    @ApiModelProperty(value = "主键")
    private String id;
    /**创建人*/
    @ApiModelProperty(value = "创建人")
    private String createBy;
    /**创建时间*/
    @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
    @DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
    @ApiModelProperty(value = "创建时间")
    private Date createTime;
    /**入库单*/
    @ApiModelProperty(value = "入库单")
    private String orderId;
    /**工装ID*/
    @Excel(name = "工装ID", width = 15)
    @ApiModelProperty(value = "工装ID")
    private String toolId;
    /**入库数量*/
    @Excel(name = "入库数量", width = 15)
    @ApiModelProperty(value = "入库数量")
    private Integer receiveNumber;

    /**工装名称*/
    @Excel(name = "工装名称", width = 15)
    @ApiModelProperty(value = "工装名称")
    @TableField(exist = false)
    private String toolName;
    /**工装编码*/
    @Excel(name = "工装编码", width = 15)
    @ApiModelProperty(value = "工装编码")
    @TableField(exist = false)
    private String toolCode;
    /**工装分类*/
    @Excel(name = "工装分类", width = 15)
    @ApiModelProperty(value = "工装分类")
    @TableField(exist = false)
    private String toolCategory;
    /**型号*/
    @Excel(name = "型号", width = 15)
    @ApiModelProperty(value = "型号")
    @TableField(exist = false)
    private String toolModel;
    /**规格*/
    @Excel(name = "规格", width = 15)
    @ApiModelProperty(value = "规格")
    @TableField(exist = false)
    private String toolSpecification;
}

 src/main/java/org/jeecg/modules/tms/entity/TmsToolInboundInventory.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,55 @@
package org.jeecg.modules.tms.entity;

import java.io.Serializable;
import java.io.UnsupportedEncodingException;
import java.util.Date;
import java.math.BigDecimal;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.TableLogic;
import lombok.Data;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.springframework.format.annotation.DateTimeFormat;
import org.jeecgframework.poi.excel.annotation.Excel;
import org.jeecg.common.aspect.annotation.Dict;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;

/**
 * @Description: å·¥è£…入库库存关系
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
@Data
@TableName("tms_tool_inbound_inventory")
@Accessors(chain = true)
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="tms_tool_inbound_inventory对象", description="工装入库库存关系")
public class TmsToolInboundInventory implements Serializable {
    private static final long serialVersionUID = 1L;

    /**主键*/
    @TableId(type = IdType.ASSIGN_ID)
    @ApiModelProperty(value = "主键")
    private String id;
    /**创建人*/
    @ApiModelProperty(value = "创建人")
    private String createBy;
    /**创建时间*/
    @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd")
    @DateTimeFormat(pattern="yyyy-MM-dd")
    @ApiModelProperty(value = "创建时间")
    private Date createTime;
    /**入库单ID*/
    @Excel(name = "入库单ID", width = 15)
    @ApiModelProperty(value = "入库单ID")
    private String orderId;
    /**库存ID*/
    @Excel(name = "库存ID", width = 15)
    @ApiModelProperty(value = "库存ID")
    private String inventoryId;
}

 src/main/java/org/jeecg/modules/tms/entity/TmsToolInventory.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,71 @@
package org.jeecg.modules.tms.entity;

import java.io.Serializable;
import java.io.UnsupportedEncodingException;
import java.util.Date;
import java.math.BigDecimal;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.TableLogic;
import lombok.Data;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.springframework.format.annotation.DateTimeFormat;
import org.jeecgframework.poi.excel.annotation.Excel;
import org.jeecg.common.aspect.annotation.Dict;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;

/**
 * @Description: å·¥è£…库存
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
@Data
@TableName("tms_tool_inventory")
@Accessors(chain = true)
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="tms_tool_inventory对象", description="工装库存")
public class TmsToolInventory implements Serializable {
    private static final long serialVersionUID = 1L;

    /**主键*/
    @TableId(type = IdType.ASSIGN_ID)
    @ApiModelProperty(value = "主键")
    private String id;
    /**创建人*/
    @ApiModelProperty(value = "创建人")
    private String createBy;
    /**创建时间*/
    @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd")
    @DateTimeFormat(pattern="yyyy-MM-dd")
    @ApiModelProperty(value = "创建时间")
    private Date createTime;
    /**更新人*/
    @ApiModelProperty(value = "更新人")
    private String updateBy;
    /**更新时间*/
    @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd")
    @DateTimeFormat(pattern="yyyy-MM-dd")
    @ApiModelProperty(value = "更新时间")
    private Date updateTime;
    /**工装ID*/
    @Excel(name = "工装ID", width = 15)
    @ApiModelProperty(value = "工装ID")
    private String toolId;
    /**工装条码*/
    @Excel(name = "工装条码", width = 15)
    @ApiModelProperty(value = "工装条码")
    private String toolBarcode;
    /**库存状态*/
    @Excel(name = "库存状态", width = 15)
    @ApiModelProperty(value = "库存状态")
    private String inventoryStatus;
    /**当前寿命(百分比)*/
    @Excel(name = "当前寿命(百分比)", width = 15)
    @ApiModelProperty(value = "当前寿命(百分比)")
    private BigDecimal currentLife;
}

 src/main/java/org/jeecg/modules/tms/entity/TmsToolReceive.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,116 @@
package org.jeecg.modules.tms.entity;

import java.io.Serializable;
import java.io.UnsupportedEncodingException;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.TableLogic;
import org.jeecg.common.constant.CommonConstant;
import org.jeecgframework.poi.excel.annotation.Excel;
import lombok.Data;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.springframework.format.annotation.DateTimeFormat;
import org.jeecg.common.aspect.annotation.Dict;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;

/**
 * @Description: å·¥è£…领用
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
@Data
@TableName("tms_tool_receive")
@ApiModel(value="tms_tool_receive对象", description="工装领用")
public class TmsToolReceive implements Serializable {
    private static final long serialVersionUID = 1L;

    /**主键*/
    @TableId(type = IdType.ASSIGN_ID)
    @ApiModelProperty(value = "主键")
    private String id;
    /**创建人*/
    @ApiModelProperty(value = "创建人")
    private String createBy;
    /**创建时间*/
    @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd")
    @DateTimeFormat(pattern="yyyy-MM-dd")
    @ApiModelProperty(value = "创建时间")
    private Date createTime;
    /**更新人*/
    @ApiModelProperty(value = "更新人")
    private String updateBy;
    /**更新时间*/
    @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd")
    @DateTimeFormat(pattern="yyyy-MM-dd")
    @ApiModelProperty(value = "更新时间")
    private Date updateTime;
    /**删除标记*/
    @Excel(name = "删除标记", width = 15)
    @ApiModelProperty(value = "删除标记")
    @TableLogic
    private Integer delFlag = CommonConstant.DEL_FLAG_0;
    /**领用单状态*/
    @Excel(name = "领用单状态", width = 15)
    @ApiModelProperty(value = "领用单状态")
    private String orderStatus;
    /**领用人*/
    @Excel(name = "领用人", width = 15)
    @ApiModelProperty(value = "领用人")
    private String receiver;
    /**领用时间*/
    @Excel(name = "领用时间", width = 15, format = "yyyy-MM-dd")
    @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd")
    @DateTimeFormat(pattern="yyyy-MM-dd")
    @ApiModelProperty(value = "领用时间")
    private Date receiveTime;
    /**领用说明*/
    @Excel(name = "领用说明", width = 15)
    @ApiModelProperty(value = "领用说明")
    private String receiveComment;
    /**确认人*/
    @Excel(name = "确认人", width = 15)
    @ApiModelProperty(value = "确认人")
    private String confirmer;
    /**确认时间*/
    @Excel(name = "确认时间", width = 15, format = "yyyy-MM-dd")
    @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd")
    @DateTimeFormat(pattern="yyyy-MM-dd")
    @ApiModelProperty(value = "确认时间")
    private Date confirmTime;
    /**确认意见*/
    @Excel(name = "确认意见", width = 15)
    @ApiModelProperty(value = "确认意见")
    private String confirmComment;
    /**是否会归还*/
    @Excel(name = "是否会归还", width = 15)
    @ApiModelProperty(value = "是否会归还")
    private String returnFlag;
    /**归还时间*/
    @Excel(name = "归还时间", width = 15, format = "yyyy-MM-dd")
    @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd")
    @DateTimeFormat(pattern="yyyy-MM-dd")
    @ApiModelProperty(value = "归还时间")
    private Date returnTime;
    /**归还说明*/
    @Excel(name = "归还说明", width = 15)
    @ApiModelProperty(value = "归还说明")
    private String returnComment;
    /**归还确认人*/
    @Excel(name = "归还确认人", width = 15)
    @ApiModelProperty(value = "归还确认人")
    private String returnConfirmer;
    /**归还确认时间*/
    @Excel(name = "归还确认时间", width = 15, format = "yyyy-MM-dd")
    @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd")
    @DateTimeFormat(pattern="yyyy-MM-dd")
    @ApiModelProperty(value = "归还确认时间")
    private Date returnConfirmTime;
    /**归还确认意见*/
    @Excel(name = "归还确认意见", width = 15)
    @ApiModelProperty(value = "归还确认意见")
    private String returnConfirmComment;
}

 src/main/java/org/jeecg/modules/tms/entity/TmsToolReceiveDetail.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,65 @@
package org.jeecg.modules.tms.entity;

import java.io.Serializable;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.TableLogic;
import org.jeecg.common.aspect.annotation.Dict;
import lombok.Data;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.springframework.format.annotation.DateTimeFormat;
import org.jeecgframework.poi.excel.annotation.Excel;
import java.util.Date;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import java.io.UnsupportedEncodingException;

/**
 * @Description: å·¥è£…领用明细
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
@Data
@TableName("tms_tool_receive_detail")
@ApiModel(value="tms_tool_receive_detail对象", description="工装领用明细")
public class TmsToolReceiveDetail implements Serializable {
    private static final long serialVersionUID = 1L;

    /**主键*/
    @TableId(type = IdType.ASSIGN_ID)
    @ApiModelProperty(value = "主键")
    private String id;
    /**创建人*/
    @ApiModelProperty(value = "创建人")
    private String createBy;
    /**创建时间*/
    @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd")
    @DateTimeFormat(pattern="yyyy-MM-dd")
    @ApiModelProperty(value = "创建时间")
    private Date createTime;
    /**更新人*/
    @ApiModelProperty(value = "更新人")
    private String updateBy;
    /**更新时间*/
    @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd")
    @DateTimeFormat(pattern="yyyy-MM-dd")
    @ApiModelProperty(value = "更新时间")
    private Date updateTime;
    /**领用单ID*/
    @ApiModelProperty(value = "领用单ID")
    private String orderId;
    /**工装ID*/
    @Excel(name = "工装ID", width = 15)
    @ApiModelProperty(value = "工装ID")
    private String toolId;
    /**库存ID*/
    @Excel(name = "库存ID", width = 15)
    @ApiModelProperty(value = "库存ID")
    private String inventoryId;
    /**使用寿命(百分比)*/
    @Excel(name = "使用寿命(百分比)", width = 15)
    @ApiModelProperty(value = "使用寿命(百分比)")
    private java.math.BigDecimal usedLife;
}

 src/main/java/org/jeecg/modules/tms/entity/TmsToolScrap.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,88 @@
package org.jeecg.modules.tms.entity;

import java.io.Serializable;
import java.io.UnsupportedEncodingException;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.TableLogic;
import org.jeecg.common.constant.CommonConstant;
import org.jeecgframework.poi.excel.annotation.Excel;
import lombok.Data;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.springframework.format.annotation.DateTimeFormat;
import org.jeecg.common.aspect.annotation.Dict;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;

/**
 * @Description: å·¥è£…报废
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
@Data
@TableName("tms_tool_scrap")
@ApiModel(value="tms_tool_scrap对象", description="工装报废")
public class TmsToolScrap implements Serializable {
    private static final long serialVersionUID = 1L;

    /**主键*/
    @TableId(type = IdType.ASSIGN_ID)
    @ApiModelProperty(value = "主键")
    private String id;
    /**创建人*/
    @ApiModelProperty(value = "创建人")
    private String createBy;
    /**创建时间*/
    @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd")
    @DateTimeFormat(pattern="yyyy-MM-dd")
    @ApiModelProperty(value = "创建时间")
    private Date createTime;
    /**更新人*/
    @ApiModelProperty(value = "更新人")
    private String updateBy;
    /**更新时间*/
    @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd")
    @DateTimeFormat(pattern="yyyy-MM-dd")
    @ApiModelProperty(value = "更新时间")
    private Date updateTime;
    /**删除标记*/
    @Excel(name = "删除标记", width = 15)
    @ApiModelProperty(value = "删除标记")
    @TableLogic
    private Integer delFlag = CommonConstant.DEL_FLAG_0;
    /**报废单状态*/
    @Excel(name = "报废单状态", width = 15)
    @ApiModelProperty(value = "报废单状态")
    private String orderStatus;
    /**申请人*/
    @Excel(name = "申请人", width = 15)
    @ApiModelProperty(value = "申请人")
    private String applicant;
    /**申请时间*/
    @Excel(name = "申请时间", width = 15, format = "yyyy-MM-dd")
    @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd")
    @DateTimeFormat(pattern="yyyy-MM-dd")
    @ApiModelProperty(value = "申请时间")
    private Date applicationTime;
    /**申请说明*/
    @Excel(name = "申请说明", width = 15)
    @ApiModelProperty(value = "申请说明")
    private String applicationComment;
    /**确认人*/
    @Excel(name = "确认人", width = 15)
    @ApiModelProperty(value = "确认人")
    private String confirmer;
    /**确认时间*/
    @Excel(name = "确认时间", width = 15, format = "yyyy-MM-dd")
    @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd")
    @DateTimeFormat(pattern="yyyy-MM-dd")
    @ApiModelProperty(value = "确认时间")
    private Date confirmTime;
    /**确认意见*/
    @Excel(name = "确认意见", width = 15)
    @ApiModelProperty(value = "确认意见")
    private String confirmComment;
}

 src/main/java/org/jeecg/modules/tms/entity/TmsToolScrapDetail.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,53 @@
package org.jeecg.modules.tms.entity;

import java.io.Serializable;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.TableLogic;
import org.jeecg.common.aspect.annotation.Dict;
import lombok.Data;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.springframework.format.annotation.DateTimeFormat;
import org.jeecgframework.poi.excel.annotation.Excel;
import java.util.Date;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import java.io.UnsupportedEncodingException;

/**
 * @Description: å·¥è£…报废明细
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
@Data
@TableName("tms_tool_scrap_detail")
@ApiModel(value="tms_tool_scrap_detail对象", description="工装报废明细")
public class TmsToolScrapDetail implements Serializable {
    private static final long serialVersionUID = 1L;

    /**主键*/
    @TableId(type = IdType.ASSIGN_ID)
    @ApiModelProperty(value = "主键")
    private String id;
    /**创建人*/
    @ApiModelProperty(value = "创建人")
    private String createBy;
    /**创建时间*/
    @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd")
    @DateTimeFormat(pattern="yyyy-MM-dd")
    @ApiModelProperty(value = "创建时间")
    private Date createTime;
    /**报废单ID*/
    @ApiModelProperty(value = "报废单ID")
    private String orderId;
    /**工装ID*/
    @Excel(name = "工装ID", width = 15)
    @ApiModelProperty(value = "工装ID")
    private String toolId;
    /**库存ID*/
    @Excel(name = "库存ID", width = 15)
    @ApiModelProperty(value = "库存ID")
    private String inventoryId;
}

 src/main/java/org/jeecg/modules/tms/entity/TmsToolStocktaking.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,78 @@
package org.jeecg.modules.tms.entity;

import java.io.Serializable;
import java.io.UnsupportedEncodingException;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.TableLogic;
import org.jeecg.common.constant.CommonConstant;
import org.jeecgframework.poi.excel.annotation.Excel;
import lombok.Data;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.springframework.format.annotation.DateTimeFormat;
import org.jeecg.common.aspect.annotation.Dict;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;

/**
 * @Description: å·¥è£…盘点
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
@Data
@TableName("tms_tool_stocktaking")
@ApiModel(value="tms_tool_stocktaking对象", description="工装盘点")
public class TmsToolStocktaking implements Serializable {
    private static final long serialVersionUID = 1L;

    /**主键*/
    @TableId(type = IdType.ASSIGN_ID)
    @ApiModelProperty(value = "主键")
    private String id;
    /**创建人*/
    @ApiModelProperty(value = "创建人")
    private String createBy;
    /**创建时间*/
    @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd")
    @DateTimeFormat(pattern="yyyy-MM-dd")
    @ApiModelProperty(value = "创建时间")
    private Date createTime;
    /**更新人*/
    @ApiModelProperty(value = "更新人")
    private String updateBy;
    /**更新时间*/
    @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd")
    @DateTimeFormat(pattern="yyyy-MM-dd")
    @ApiModelProperty(value = "更新时间")
    private Date updateTime;
    /**删除标记*/
    @Excel(name = "删除标记", width = 15)
    @ApiModelProperty(value = "删除标记")
    @TableLogic
    private Integer delFlag = CommonConstant.DEL_FLAG_0;
    /**盘点单号*/
    @Excel(name = "盘点单号", width = 15)
    @ApiModelProperty(value = "盘点单号")
    private String orderCode;
    /**盘点状态*/
    @Excel(name = "盘点状态", width = 15)
    @ApiModelProperty(value = "盘点状态")
    private String orderStatus;
    /**盘点人*/
    @Excel(name = "盘点人", width = 15)
    @ApiModelProperty(value = "盘点人")
    private String operator;
    /**盘点时间*/
    @Excel(name = "盘点时间", width = 15, format = "yyyy-MM-dd")
    @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd")
    @DateTimeFormat(pattern="yyyy-MM-dd")
    @ApiModelProperty(value = "盘点时间")
    private Date operateTime;
    /**备注*/
    @Excel(name = "备注", width = 15)
    @ApiModelProperty(value = "备注")
    private String remark;
}

 src/main/java/org/jeecg/modules/tms/entity/TmsToolStocktakingDetail.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,69 @@
package org.jeecg.modules.tms.entity;

import java.io.Serializable;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.TableLogic;
import org.jeecg.common.aspect.annotation.Dict;
import lombok.Data;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.springframework.format.annotation.DateTimeFormat;
import org.jeecgframework.poi.excel.annotation.Excel;
import java.util.Date;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import java.io.UnsupportedEncodingException;

/**
 * @Description: å·¥è£…盘点明细
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
@Data
@TableName("tms_tool_stocktaking_detail")
@ApiModel(value="tms_tool_stocktaking_detail对象", description="工装盘点明细")
public class TmsToolStocktakingDetail implements Serializable {
    private static final long serialVersionUID = 1L;

    /**主键*/
    @TableId(type = IdType.ASSIGN_ID)
    @ApiModelProperty(value = "主键")
    private String id;
    /**创建人*/
    @ApiModelProperty(value = "创建人")
    private String createBy;
    /**创建时间*/
    @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd")
    @DateTimeFormat(pattern="yyyy-MM-dd")
    @ApiModelProperty(value = "创建时间")
    private Date createTime;
    /**更新人*/
    @ApiModelProperty(value = "更新人")
    private String updateBy;
    /**更新时间*/
    @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd")
    @DateTimeFormat(pattern="yyyy-MM-dd")
    @ApiModelProperty(value = "更新时间")
    private Date updateTime;
    /**盘点单ID*/
    @ApiModelProperty(value = "盘点单ID")
    private String orderId;
    /**工装ID*/
    @Excel(name = "工装ID", width = 15)
    @ApiModelProperty(value = "工装ID")
    private String toolId;
    /**盘点前数量*/
    @Excel(name = "盘点前数量", width = 15)
    @ApiModelProperty(value = "盘点前数量")
    private java.math.BigDecimal beforeNumber;
    /**实际盘点数量*/
    @Excel(name = "实际盘点数量", width = 15)
    @ApiModelProperty(value = "实际盘点数量")
    private java.math.BigDecimal actualNumber;
    /**盘点结果*/
    @Excel(name = "盘点结果", width = 15)
    @ApiModelProperty(value = "盘点结果")
    private String stocktakingResult;
}

 src/main/java/org/jeecg/modules/tms/entity/TmsToolStocktakingInventoryChange.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,67 @@
package org.jeecg.modules.tms.entity;

import java.io.Serializable;
import java.io.UnsupportedEncodingException;
import java.util.Date;
import java.math.BigDecimal;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.TableLogic;
import lombok.Data;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.springframework.format.annotation.DateTimeFormat;
import org.jeecgframework.poi.excel.annotation.Excel;
import org.jeecg.common.aspect.annotation.Dict;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;

/**
 * @Description: ç›˜ç‚¹åº“存变更
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
@Data
@TableName("tms_tool_stocktaking_inventory_change")
@Accessors(chain = true)
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="tms_tool_stocktaking_inventory_change对象", description="盘点库存变更")
public class TmsToolStocktakingInventoryChange implements Serializable {
    private static final long serialVersionUID = 1L;

    /**主键*/
    @TableId(type = IdType.ASSIGN_ID)
    @ApiModelProperty(value = "主键")
    private String id;
    /**创建人*/
    @ApiModelProperty(value = "创建人")
    private String createBy;
    /**创建时间*/
    @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd")
    @DateTimeFormat(pattern="yyyy-MM-dd")
    @ApiModelProperty(value = "创建时间")
    private Date createTime;
    /**盘点明细ID*/
    @Excel(name = "盘点明细ID", width = 15)
    @ApiModelProperty(value = "盘点明细ID")
    private String detailId;
    /**库存ID*/
    @Excel(name = "库存ID", width = 15)
    @ApiModelProperty(value = "库存ID")
    private String inventoryId;
    /**工装条码*/
    @Excel(name = "工装条码", width = 15)
    @ApiModelProperty(value = "工装条码")
    private String toolBarcode;
    /**数量(默认1)*/
    @Excel(name = "数量(默认1)", width = 15)
    @ApiModelProperty(value = "数量(默认1)")
    private BigDecimal number;
    /**变更类型;正常/出库/入库*/
    @Excel(name = "变更类型;正常/出库/入库", width = 15)
    @ApiModelProperty(value = "变更类型;正常/出库/入库")
    private String changeType;
}

 src/main/java/org/jeecg/modules/tms/entity/TmsTools.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,101 @@
package org.jeecg.modules.tms.entity;

import java.io.Serializable;
import java.io.UnsupportedEncodingException;
import java.util.Date;
import java.math.BigDecimal;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.TableLogic;
import lombok.Data;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.jeecg.common.constant.CommonConstant;
import org.springframework.format.annotation.DateTimeFormat;
import org.jeecgframework.poi.excel.annotation.Excel;
import org.jeecg.common.aspect.annotation.Dict;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;

/**
 * @Description: å·¥è£…信息
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
@Data
@TableName("tms_tools")
@Accessors(chain = true)
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="tms_tools对象", description="工装信息")
public class TmsTools implements Serializable {
    private static final long serialVersionUID = 1L;

    /**主键*/
    @TableId(type = IdType.ASSIGN_ID)
    @ApiModelProperty(value = "主键")
    private String id;
    /**创建人*/
    @ApiModelProperty(value = "创建人")
    private String createBy;
    /**创建时间*/
    @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd")
    @DateTimeFormat(pattern="yyyy-MM-dd")
    @ApiModelProperty(value = "创建时间")
    private Date createTime;
    /**更新人*/
    @ApiModelProperty(value = "更新人")
    private String updateBy;
    /**更新时间*/
    @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd")
    @DateTimeFormat(pattern="yyyy-MM-dd")
    @ApiModelProperty(value = "更新时间")
    private Date updateTime;
    /**删除标记*/
    @Excel(name = "删除标记", width = 15)
    @ApiModelProperty(value = "删除标记")
    @TableLogic
    private Integer delFlag = CommonConstant.DEL_FLAG_0;
    /**工装名称*/
    @Excel(name = "工装名称", width = 15)
    @ApiModelProperty(value = "工装名称")
    private String toolName;
    /**工装编码*/
    @Excel(name = "工装编码", width = 15)
    @ApiModelProperty(value = "工装编码")
    private String toolCode;
    /**工装分类*/
    @Excel(name = "工装分类", width = 15)
    @ApiModelProperty(value = "工装分类")
    private String toolCategory;
    /**型号*/
    @Excel(name = "型号", width = 15)
    @ApiModelProperty(value = "型号")
    private String toolModel;
    /**规格*/
    @Excel(name = "规格", width = 15)
    @ApiModelProperty(value = "规格")
    private String toolSpecification;
    /**单位*/
    @Excel(name = "单位", width = 15)
    @ApiModelProperty(value = "单位")
    private String toolUnit;
    /**存放位置*/
    @Excel(name = "存放位置", width = 15)
    @ApiModelProperty(value = "存放位置")
    private String storeLocation;
    /**供应商*/
    @Excel(name = "供应商", width = 15)
    @ApiModelProperty(value = "供应商")
    private String supplierId;
    /**库存预警值*/
    @Excel(name = "库存预警值", width = 15)
    @ApiModelProperty(value = "库存预警值")
    private Integer inventoryWarning;
    /**备注*/
    @Excel(name = "备注", width = 15)
    @ApiModelProperty(value = "备注")
    private String remark;
}

 src/main/java/org/jeecg/modules/tms/mapper/TmsToolHistoryMapper.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,17 @@
package org.jeecg.modules.tms.mapper;

import java.util.List;

import org.apache.ibatis.annotations.Param;
import org.jeecg.modules.tms.entity.TmsToolHistory;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;

/**
 * @Description: å·¥è£…履历
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
public interface TmsToolHistoryMapper extends BaseMapper<TmsToolHistory> {

}

 src/main/java/org/jeecg/modules/tms/mapper/TmsToolInboundDetailMapper.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,40 @@
package org.jeecg.modules.tms.mapper;

import java.util.List;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Constants;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.jeecg.modules.tms.entity.TmsToolInboundDetail;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Param;

/**
 * @Description: å·¥è£…入库明细
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
public interface TmsToolInboundDetailMapper extends BaseMapper<TmsToolInboundDetail> {

    /**
     * é€šè¿‡ä¸»è¡¨id删除子表数据
     *
     * @param mainId ä¸»è¡¨id
     * @return boolean
     */
    public boolean deleteByMainId(@Param("mainId") String mainId);

   /**
    * é€šè¿‡ä¸»è¡¨id查询子表数据
    *
    * @param mainId ä¸»è¡¨id
    * @return List<TmsToolInboundDetail>
    */
    public List<TmsToolInboundDetail> selectByMainId(@Param("mainId") String mainId);

    IPage<TmsToolInboundDetail> queryPageList(Page<TmsToolInboundDetail> page,
                                              @Param(Constants.WRAPPER) Wrapper<TmsToolInboundDetail> queryWrapper);
}

 src/main/java/org/jeecg/modules/tms/mapper/TmsToolInboundInventoryMapper.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,17 @@
package org.jeecg.modules.tms.mapper;

import java.util.List;

import org.apache.ibatis.annotations.Param;
import org.jeecg.modules.tms.entity.TmsToolInboundInventory;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;

/**
 * @Description: å·¥è£…入库库存关系
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
public interface TmsToolInboundInventoryMapper extends BaseMapper<TmsToolInboundInventory> {

}

 src/main/java/org/jeecg/modules/tms/mapper/TmsToolInboundMapper.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,17 @@
package org.jeecg.modules.tms.mapper;

import java.util.List;

import org.apache.ibatis.annotations.Param;
import org.jeecg.modules.tms.entity.TmsToolInbound;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;

/**
 * @Description: å·¥è£…入库
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
public interface TmsToolInboundMapper extends BaseMapper<TmsToolInbound> {

}

 src/main/java/org/jeecg/modules/tms/mapper/TmsToolInventoryMapper.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,17 @@
package org.jeecg.modules.tms.mapper;

import java.util.List;

import org.apache.ibatis.annotations.Param;
import org.jeecg.modules.tms.entity.TmsToolInventory;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;

/**
 * @Description: å·¥è£…库存
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
public interface TmsToolInventoryMapper extends BaseMapper<TmsToolInventory> {

}

 src/main/java/org/jeecg/modules/tms/mapper/TmsToolReceiveDetailMapper.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,32 @@
package org.jeecg.modules.tms.mapper;

import java.util.List;
import org.jeecg.modules.tms.entity.TmsToolReceiveDetail;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Param;

/**
 * @Description: å·¥è£…领用明细
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
public interface TmsToolReceiveDetailMapper extends BaseMapper<TmsToolReceiveDetail> {

    /**
     * é€šè¿‡ä¸»è¡¨id删除子表数据
     *
     * @param mainId ä¸»è¡¨id
     * @return boolean
     */
    public boolean deleteByMainId(@Param("mainId") String mainId);

   /**
    * é€šè¿‡ä¸»è¡¨id查询子表数据
    *
    * @param mainId ä¸»è¡¨id
    * @return List<TmsToolReceiveDetail>
    */
    public List<TmsToolReceiveDetail> selectByMainId(@Param("mainId") String mainId);

}

 src/main/java/org/jeecg/modules/tms/mapper/TmsToolReceiveMapper.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,17 @@
package org.jeecg.modules.tms.mapper;

import java.util.List;

import org.apache.ibatis.annotations.Param;
import org.jeecg.modules.tms.entity.TmsToolReceive;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;

/**
 * @Description: å·¥è£…领用
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
public interface TmsToolReceiveMapper extends BaseMapper<TmsToolReceive> {

}

 src/main/java/org/jeecg/modules/tms/mapper/TmsToolScrapDetailMapper.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,32 @@
package org.jeecg.modules.tms.mapper;

import java.util.List;
import org.jeecg.modules.tms.entity.TmsToolScrapDetail;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Param;

/**
 * @Description: å·¥è£…报废明细
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
public interface TmsToolScrapDetailMapper extends BaseMapper<TmsToolScrapDetail> {

    /**
     * é€šè¿‡ä¸»è¡¨id删除子表数据
     *
     * @param mainId ä¸»è¡¨id
     * @return boolean
     */
    public boolean deleteByMainId(@Param("mainId") String mainId);

   /**
    * é€šè¿‡ä¸»è¡¨id查询子表数据
    *
    * @param mainId ä¸»è¡¨id
    * @return List<TmsToolScrapDetail>
    */
    public List<TmsToolScrapDetail> selectByMainId(@Param("mainId") String mainId);

}

 src/main/java/org/jeecg/modules/tms/mapper/TmsToolScrapMapper.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,17 @@
package org.jeecg.modules.tms.mapper;

import java.util.List;

import org.apache.ibatis.annotations.Param;
import org.jeecg.modules.tms.entity.TmsToolScrap;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;

/**
 * @Description: å·¥è£…报废
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
public interface TmsToolScrapMapper extends BaseMapper<TmsToolScrap> {

}

 src/main/java/org/jeecg/modules/tms/mapper/TmsToolStocktakingDetailMapper.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,32 @@
package org.jeecg.modules.tms.mapper;

import java.util.List;
import org.jeecg.modules.tms.entity.TmsToolStocktakingDetail;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Param;

/**
 * @Description: å·¥è£…盘点明细
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
public interface TmsToolStocktakingDetailMapper extends BaseMapper<TmsToolStocktakingDetail> {

    /**
     * é€šè¿‡ä¸»è¡¨id删除子表数据
     *
     * @param mainId ä¸»è¡¨id
     * @return boolean
     */
    public boolean deleteByMainId(@Param("mainId") String mainId);

   /**
    * é€šè¿‡ä¸»è¡¨id查询子表数据
    *
    * @param mainId ä¸»è¡¨id
    * @return List<TmsToolStocktakingDetail>
    */
    public List<TmsToolStocktakingDetail> selectByMainId(@Param("mainId") String mainId);

}

 src/main/java/org/jeecg/modules/tms/mapper/TmsToolStocktakingInventoryChangeMapper.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,17 @@
package org.jeecg.modules.tms.mapper;

import java.util.List;

import org.apache.ibatis.annotations.Param;
import org.jeecg.modules.tms.entity.TmsToolStocktakingInventoryChange;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;

/**
 * @Description: ç›˜ç‚¹åº“存变更
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
public interface TmsToolStocktakingInventoryChangeMapper extends BaseMapper<TmsToolStocktakingInventoryChange> {

}

 src/main/java/org/jeecg/modules/tms/mapper/TmsToolStocktakingMapper.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,17 @@
package org.jeecg.modules.tms.mapper;

import java.util.List;

import org.apache.ibatis.annotations.Param;
import org.jeecg.modules.tms.entity.TmsToolStocktaking;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;

/**
 * @Description: å·¥è£…盘点
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
public interface TmsToolStocktakingMapper extends BaseMapper<TmsToolStocktaking> {

}

 src/main/java/org/jeecg/modules/tms/mapper/TmsToolsMapper.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,17 @@
package org.jeecg.modules.tms.mapper;

import java.util.List;

import org.apache.ibatis.annotations.Param;
import org.jeecg.modules.tms.entity.TmsTools;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;

/**
 * @Description: å·¥è£…信息
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
public interface TmsToolsMapper extends BaseMapper<TmsTools> {

}

 src/main/java/org/jeecg/modules/tms/mapper/xml/TmsToolHistoryMapper.xml

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,5 @@
<?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="org.jeecg.modules.tms.mapper.TmsToolHistoryMapper">

</mapper>

 src/main/java/org/jeecg/modules/tms/mapper/xml/TmsToolInboundDetailMapper.xml

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,29 @@
<?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="org.jeecg.modules.tms.mapper.TmsToolInboundDetailMapper">

    <delete id="deleteByMainId" parameterType="java.lang.String">
        DELETE 
        FROM  tms_tool_inbound_detail 
        WHERE
             order_id = #{mainId} 
    </delete>
	
    <select id="selectByMainId" parameterType="java.lang.String" resultType="org.jeecg.modules.tms.entity.TmsToolInboundDetail">
        SELECT * 
        FROM  tms_tool_inbound_detail
        WHERE
             order_id = #{mainId} 
    </select>
    <select id="queryPageList" resultType="org.jeecg.modules.tms.entity.TmsToolInboundDetail">
        SELECT t1.*,
               t2.tool_name toolName,
               t2.tool_code toolCode,
               t2.tool_category toolCategory,
               t2.tool_model toolModel,
               t2.tool_specification toolSpecification
        FROM  tms_tool_inbound_detail t1
        LEFT JOIN tms_tools t2 ON t1.tool_id = t2.id
        ${ew.customSqlSegment}
    </select>
</mapper>

 src/main/java/org/jeecg/modules/tms/mapper/xml/TmsToolInboundInventoryMapper.xml

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,5 @@
<?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="org.jeecg.modules.tms.mapper.TmsToolInboundInventoryMapper">

</mapper>

 src/main/java/org/jeecg/modules/tms/mapper/xml/TmsToolInboundMapper.xml

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,5 @@
<?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="org.jeecg.modules.tms.mapper.TmsToolInboundMapper">

</mapper>

 src/main/java/org/jeecg/modules/tms/mapper/xml/TmsToolInventoryMapper.xml

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,5 @@
<?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="org.jeecg.modules.tms.mapper.TmsToolInventoryMapper">

</mapper>

 src/main/java/org/jeecg/modules/tms/mapper/xml/TmsToolReceiveDetailMapper.xml

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,18 @@
<?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="org.jeecg.modules.tms.mapper.TmsToolReceiveDetailMapper">

    <delete id="deleteByMainId" parameterType="java.lang.String">
        DELETE 
        FROM  tms_tool_receive_detail 
        WHERE
             order_id = #{mainId} 
    </delete>
	
    <select id="selectByMainId" parameterType="java.lang.String" resultType="org.jeecg.modules.tms.entity.TmsToolReceiveDetail">
        SELECT * 
        FROM  tms_tool_receive_detail
        WHERE
             order_id = #{mainId} 
    </select>
</mapper>

 src/main/java/org/jeecg/modules/tms/mapper/xml/TmsToolReceiveMapper.xml

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,5 @@
<?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="org.jeecg.modules.tms.mapper.TmsToolReceiveMapper">

</mapper>

 src/main/java/org/jeecg/modules/tms/mapper/xml/TmsToolScrapDetailMapper.xml

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,18 @@
<?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="org.jeecg.modules.tms.mapper.TmsToolScrapDetailMapper">

    <delete id="deleteByMainId" parameterType="java.lang.String">
        DELETE 
        FROM  tms_tool_scrap_detail 
        WHERE
             order_id = #{mainId} 
    </delete>
	
    <select id="selectByMainId" parameterType="java.lang.String" resultType="org.jeecg.modules.tms.entity.TmsToolScrapDetail">
        SELECT * 
        FROM  tms_tool_scrap_detail
        WHERE
             order_id = #{mainId} 
    </select>
</mapper>

 src/main/java/org/jeecg/modules/tms/mapper/xml/TmsToolScrapMapper.xml

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,5 @@
<?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="org.jeecg.modules.tms.mapper.TmsToolScrapMapper">

</mapper>

 src/main/java/org/jeecg/modules/tms/mapper/xml/TmsToolStocktakingDetailMapper.xml

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,18 @@
<?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="org.jeecg.modules.tms.mapper.TmsToolStocktakingDetailMapper">

    <delete id="deleteByMainId" parameterType="java.lang.String">
        DELETE 
        FROM  tms_tool_stocktaking_detail 
        WHERE
             order_id = #{mainId} 
    </delete>
	
    <select id="selectByMainId" parameterType="java.lang.String" resultType="org.jeecg.modules.tms.entity.TmsToolStocktakingDetail">
        SELECT * 
        FROM  tms_tool_stocktaking_detail
        WHERE
             order_id = #{mainId} 
    </select>
</mapper>

 src/main/java/org/jeecg/modules/tms/mapper/xml/TmsToolStocktakingInventoryChangeMapper.xml

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,5 @@
<?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="org.jeecg.modules.tms.mapper.TmsToolStocktakingInventoryChangeMapper">

</mapper>

 src/main/java/org/jeecg/modules/tms/mapper/xml/TmsToolStocktakingMapper.xml

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,5 @@
<?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="org.jeecg.modules.tms.mapper.TmsToolStocktakingMapper">

</mapper>

 src/main/java/org/jeecg/modules/tms/mapper/xml/TmsToolsMapper.xml

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,5 @@
<?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="org.jeecg.modules.tms.mapper.TmsToolsMapper">

</mapper>

 src/main/java/org/jeecg/modules/tms/service/ITmsToolHistoryService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,14 @@
package org.jeecg.modules.tms.service;

import org.jeecg.modules.tms.entity.TmsToolHistory;
import com.baomidou.mybatisplus.extension.service.IService;

/**
 * @Description: å·¥è£…履历
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
public interface ITmsToolHistoryService extends IService<TmsToolHistory> {

}

 src/main/java/org/jeecg/modules/tms/service/ITmsToolInboundDetailService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,28 @@
package org.jeecg.modules.tms.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.jeecg.modules.tms.entity.TmsToolInboundDetail;
import com.baomidou.mybatisplus.extension.service.IService;
import java.util.List;
import java.util.Map;

/**
 * @Description: å·¥è£…入库明细
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
public interface ITmsToolInboundDetailService extends IService<TmsToolInboundDetail> {

  /**
   * é€šè¿‡ä¸»è¡¨id查询子表数据
   *
   * @param mainId
   * @return List<TmsToolInboundDetail>
   */
    public List<TmsToolInboundDetail> selectByMainId(String mainId);

    IPage<TmsToolInboundDetail> queryPageList(Page<TmsToolInboundDetail> page, Map<String, String[]> parameterMap);
}

 src/main/java/org/jeecg/modules/tms/service/ITmsToolInboundInventoryService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,14 @@
package org.jeecg.modules.tms.service;

import org.jeecg.modules.tms.entity.TmsToolInboundInventory;
import com.baomidou.mybatisplus.extension.service.IService;

/**
 * @Description: å·¥è£…入库库存关系
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
public interface ITmsToolInboundInventoryService extends IService<TmsToolInboundInventory> {

}

 src/main/java/org/jeecg/modules/tms/service/ITmsToolInboundService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,37 @@
package org.jeecg.modules.tms.service;

import org.jeecg.modules.tms.entity.TmsToolInbound;
import com.baomidou.mybatisplus.extension.service.IService;
import org.jeecg.modules.tms.vo.TmsToolInboundRequest;

import java.io.Serializable;
import java.lang.reflect.InvocationTargetException;
import java.util.Collection;

/**
 * @Description: å·¥è£…入库
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
public interface ITmsToolInboundService extends IService<TmsToolInbound> {

    /**
     * åˆ é™¤ä¸€å¯¹å¤š
     *
     * @param id
     */
    public void delMain (String id);
	
    /**
     * æ‰¹é‡åˆ é™¤ä¸€å¯¹å¤š
     *
     * @param idList
     */
    public void delBatchMain (Collection<? extends Serializable> idList);


    void add(TmsToolInboundRequest tmsToolInboundRequest) throws InvocationTargetException, IllegalAccessException;

    void update(TmsToolInboundRequest tmsToolInboundRequest) throws InvocationTargetException, IllegalAccessException;
}

 src/main/java/org/jeecg/modules/tms/service/ITmsToolInventoryService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,14 @@
package org.jeecg.modules.tms.service;

import org.jeecg.modules.tms.entity.TmsToolInventory;
import com.baomidou.mybatisplus.extension.service.IService;

/**
 * @Description: å·¥è£…库存
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
public interface ITmsToolInventoryService extends IService<TmsToolInventory> {

}

 src/main/java/org/jeecg/modules/tms/service/ITmsToolReceiveDetailService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,22 @@
package org.jeecg.modules.tms.service;

import org.jeecg.modules.tms.entity.TmsToolReceiveDetail;
import com.baomidou.mybatisplus.extension.service.IService;
import java.util.List;

/**
 * @Description: å·¥è£…领用明细
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
public interface ITmsToolReceiveDetailService extends IService<TmsToolReceiveDetail> {

  /**
   * é€šè¿‡ä¸»è¡¨id查询子表数据
   *
   * @param mainId
   * @return List<TmsToolReceiveDetail>
   */
    public List<TmsToolReceiveDetail> selectByMainId(String mainId);
}

 src/main/java/org/jeecg/modules/tms/service/ITmsToolReceiveService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,34 @@
package org.jeecg.modules.tms.service;

import org.jeecg.modules.tms.entity.TmsToolReceiveDetail;
import org.jeecg.modules.tms.entity.TmsToolReceive;
import com.baomidou.mybatisplus.extension.service.IService;
import org.springframework.beans.factory.annotation.Autowired;
import java.io.Serializable;
import java.util.Collection;
import java.util.List;

/**
 * @Description: å·¥è£…领用
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
public interface ITmsToolReceiveService extends IService<TmsToolReceive> {

    /**
     * åˆ é™¤ä¸€å¯¹å¤š
     *
     * @param id
     */
    public void delMain (String id);
	
    /**
     * æ‰¹é‡åˆ é™¤ä¸€å¯¹å¤š
     *
     * @param idList
     */
    public void delBatchMain (Collection<? extends Serializable> idList);


}

 src/main/java/org/jeecg/modules/tms/service/ITmsToolScrapDetailService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,22 @@
package org.jeecg.modules.tms.service;

import org.jeecg.modules.tms.entity.TmsToolScrapDetail;
import com.baomidou.mybatisplus.extension.service.IService;
import java.util.List;

/**
 * @Description: å·¥è£…报废明细
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
public interface ITmsToolScrapDetailService extends IService<TmsToolScrapDetail> {

  /**
   * é€šè¿‡ä¸»è¡¨id查询子表数据
   *
   * @param mainId
   * @return List<TmsToolScrapDetail>
   */
    public List<TmsToolScrapDetail> selectByMainId(String mainId);
}

 src/main/java/org/jeecg/modules/tms/service/ITmsToolScrapService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,34 @@
package org.jeecg.modules.tms.service;

import org.jeecg.modules.tms.entity.TmsToolScrapDetail;
import org.jeecg.modules.tms.entity.TmsToolScrap;
import com.baomidou.mybatisplus.extension.service.IService;
import org.springframework.beans.factory.annotation.Autowired;
import java.io.Serializable;
import java.util.Collection;
import java.util.List;

/**
 * @Description: å·¥è£…报废
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
public interface ITmsToolScrapService extends IService<TmsToolScrap> {

    /**
     * åˆ é™¤ä¸€å¯¹å¤š
     *
     * @param id
     */
    public void delMain (String id);
	
    /**
     * æ‰¹é‡åˆ é™¤ä¸€å¯¹å¤š
     *
     * @param idList
     */
    public void delBatchMain (Collection<? extends Serializable> idList);


}

 src/main/java/org/jeecg/modules/tms/service/ITmsToolStocktakingDetailService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,22 @@
package org.jeecg.modules.tms.service;

import org.jeecg.modules.tms.entity.TmsToolStocktakingDetail;
import com.baomidou.mybatisplus.extension.service.IService;
import java.util.List;

/**
 * @Description: å·¥è£…盘点明细
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
public interface ITmsToolStocktakingDetailService extends IService<TmsToolStocktakingDetail> {

  /**
   * é€šè¿‡ä¸»è¡¨id查询子表数据
   *
   * @param mainId
   * @return List<TmsToolStocktakingDetail>
   */
    public List<TmsToolStocktakingDetail> selectByMainId(String mainId);
}

 src/main/java/org/jeecg/modules/tms/service/ITmsToolStocktakingInventoryChangeService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,14 @@
package org.jeecg.modules.tms.service;

import org.jeecg.modules.tms.entity.TmsToolStocktakingInventoryChange;
import com.baomidou.mybatisplus.extension.service.IService;

/**
 * @Description: ç›˜ç‚¹åº“存变更
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
public interface ITmsToolStocktakingInventoryChangeService extends IService<TmsToolStocktakingInventoryChange> {

}

 src/main/java/org/jeecg/modules/tms/service/ITmsToolStocktakingService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,34 @@
package org.jeecg.modules.tms.service;

import org.jeecg.modules.tms.entity.TmsToolStocktakingDetail;
import org.jeecg.modules.tms.entity.TmsToolStocktaking;
import com.baomidou.mybatisplus.extension.service.IService;
import org.springframework.beans.factory.annotation.Autowired;
import java.io.Serializable;
import java.util.Collection;
import java.util.List;

/**
 * @Description: å·¥è£…盘点
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
public interface ITmsToolStocktakingService extends IService<TmsToolStocktaking> {

    /**
     * åˆ é™¤ä¸€å¯¹å¤š
     *
     * @param id
     */
    public void delMain (String id);
	
    /**
     * æ‰¹é‡åˆ é™¤ä¸€å¯¹å¤š
     *
     * @param idList
     */
    public void delBatchMain (Collection<? extends Serializable> idList);


}

 src/main/java/org/jeecg/modules/tms/service/ITmsToolsService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,14 @@
package org.jeecg.modules.tms.service;

import org.jeecg.modules.tms.entity.TmsTools;
import com.baomidou.mybatisplus.extension.service.IService;

/**
 * @Description: å·¥è£…信息
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
public interface ITmsToolsService extends IService<TmsTools> {

}

 src/main/java/org/jeecg/modules/tms/service/impl/TmsToolHistoryServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,19 @@
package org.jeecg.modules.tms.service.impl;

import org.jeecg.modules.tms.entity.TmsToolHistory;
import org.jeecg.modules.tms.mapper.TmsToolHistoryMapper;
import org.jeecg.modules.tms.service.ITmsToolHistoryService;
import org.springframework.stereotype.Service;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;

/**
 * @Description: å·¥è£…履历
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
@Service
public class TmsToolHistoryServiceImpl extends ServiceImpl<TmsToolHistoryMapper, TmsToolHistory> implements ITmsToolHistoryService {

}

 src/main/java/org/jeecg/modules/tms/service/impl/TmsToolInboundDetailServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,44 @@
package org.jeecg.modules.tms.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.jeecg.modules.tms.entity.TmsToolInboundDetail;
import org.jeecg.modules.tms.mapper.TmsToolInboundDetailMapper;
import org.jeecg.modules.tms.service.ITmsToolInboundDetailService;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Map;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;

/**
 * @Description: å·¥è£…入库明细
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
@Service
public class TmsToolInboundDetailServiceImpl extends ServiceImpl<TmsToolInboundDetailMapper, TmsToolInboundDetail> implements ITmsToolInboundDetailService {
	
    @Autowired
    private TmsToolInboundDetailMapper tmsToolInboundDetailMapper;
	
    @Override
    public List<TmsToolInboundDetail> selectByMainId(String mainId) {
        return tmsToolInboundDetailMapper.selectByMainId(mainId);
    }

    @Override
    public IPage<TmsToolInboundDetail> queryPageList(Page<TmsToolInboundDetail> page, Map<String, String[]> parameterMap) {
        QueryWrapper<TmsToolInboundDetail> queryWrapper = Wrappers.query();
        String[] orderIds = parameterMap.get("orderId");
        if (orderIds != null && orderIds.length > 0) {
            queryWrapper.eq("t1.order_id", orderIds[0]);
        }
        return tmsToolInboundDetailMapper.queryPageList(page, queryWrapper);
    }

}

 src/main/java/org/jeecg/modules/tms/service/impl/TmsToolInboundInventoryServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,19 @@
package org.jeecg.modules.tms.service.impl;

import org.jeecg.modules.tms.entity.TmsToolInboundInventory;
import org.jeecg.modules.tms.mapper.TmsToolInboundInventoryMapper;
import org.jeecg.modules.tms.service.ITmsToolInboundInventoryService;
import org.springframework.stereotype.Service;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;

/**
 * @Description: å·¥è£…入库库存关系
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
@Service
public class TmsToolInboundInventoryServiceImpl extends ServiceImpl<TmsToolInboundInventoryMapper, TmsToolInboundInventory> implements ITmsToolInboundInventoryService {

}

 src/main/java/org/jeecg/modules/tms/service/impl/TmsToolInboundServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,81 @@
package org.jeecg.modules.tms.service.impl;

import org.apache.commons.beanutils.BeanUtils;
import org.jeecg.modules.tms.entity.TmsToolInbound;
import org.jeecg.modules.tms.entity.TmsToolInboundDetail;
import org.jeecg.modules.tms.mapper.TmsToolInboundDetailMapper;
import org.jeecg.modules.tms.mapper.TmsToolInboundMapper;
import org.jeecg.modules.tms.service.ITmsToolInboundDetailService;
import org.jeecg.modules.tms.service.ITmsToolInboundService;
import org.jeecg.modules.tms.vo.TmsToolInboundRequest;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import java.io.Serializable;
import java.lang.reflect.InvocationTargetException;
import java.util.List;
import java.util.Collection;

/**
 * @Description: å·¥è£…入库
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
@Service
public class TmsToolInboundServiceImpl extends ServiceImpl<TmsToolInboundMapper, TmsToolInbound> implements ITmsToolInboundService {

    @Autowired
    private TmsToolInboundMapper tmsToolInboundMapper;
    @Autowired
    private TmsToolInboundDetailMapper tmsToolInboundDetailMapper;
    @Autowired
    private ITmsToolInboundDetailService tmsToolInboundDetailService;
	
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void delMain(String id) {
        tmsToolInboundDetailMapper.deleteByMainId(id);
        tmsToolInboundMapper.deleteById(id);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void delBatchMain(Collection<? extends Serializable> idList) {
        for(Serializable id:idList) {
            tmsToolInboundDetailMapper.deleteByMainId(id.toString());
            tmsToolInboundMapper.deleteById(id);
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void add(TmsToolInboundRequest tmsToolInboundRequest) throws InvocationTargetException, IllegalAccessException {
        TmsToolInbound tmsToolInbound = new TmsToolInbound();
        BeanUtils.copyProperties(tmsToolInbound, tmsToolInboundRequest);
        save(tmsToolInbound);
        List<TmsToolInboundDetail> tmsToolInboundDetailList = tmsToolInboundRequest.getTmsToolInboundDetailList();
        tmsToolInboundDetailList.forEach(tmsToolInboundDetail -> {
            tmsToolInboundDetail.setId(null);
            tmsToolInboundDetail.setOrderId(tmsToolInbound.getId());
        });
        tmsToolInboundDetailService.saveBatch(tmsToolInboundDetailList);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void update(TmsToolInboundRequest tmsToolInboundRequest) throws InvocationTargetException, IllegalAccessException {
        tmsToolInboundDetailMapper.deleteByMainId(tmsToolInboundRequest.getId());
        TmsToolInbound toolInboundUpdate = new TmsToolInbound();
        BeanUtils.copyProperties(toolInboundUpdate, tmsToolInboundRequest);
        updateById(toolInboundUpdate);
        List<TmsToolInboundDetail> tmsToolInboundDetailList = tmsToolInboundRequest.getTmsToolInboundDetailList();
        tmsToolInboundDetailList.forEach(tmsToolInboundDetail -> {
            tmsToolInboundDetail.setId(null);
            tmsToolInboundDetail.setOrderId(tmsToolInboundRequest.getId());
        });
        tmsToolInboundDetailService.saveBatch(tmsToolInboundDetailList);
    }

}

 src/main/java/org/jeecg/modules/tms/service/impl/TmsToolInventoryServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,19 @@
package org.jeecg.modules.tms.service.impl;

import org.jeecg.modules.tms.entity.TmsToolInventory;
import org.jeecg.modules.tms.mapper.TmsToolInventoryMapper;
import org.jeecg.modules.tms.service.ITmsToolInventoryService;
import org.springframework.stereotype.Service;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;

/**
 * @Description: å·¥è£…库存
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
@Service
public class TmsToolInventoryServiceImpl extends ServiceImpl<TmsToolInventoryMapper, TmsToolInventory> implements ITmsToolInventoryService {

}

 src/main/java/org/jeecg/modules/tms/service/impl/TmsToolReceiveDetailServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,27 @@
package org.jeecg.modules.tms.service.impl;

import org.jeecg.modules.tms.entity.TmsToolReceiveDetail;
import org.jeecg.modules.tms.mapper.TmsToolReceiveDetailMapper;
import org.jeecg.modules.tms.service.ITmsToolReceiveDetailService;
import org.springframework.stereotype.Service;
import java.util.List;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;

/**
 * @Description: å·¥è£…领用明细
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
@Service
public class TmsToolReceiveDetailServiceImpl extends ServiceImpl<TmsToolReceiveDetailMapper, TmsToolReceiveDetail> implements ITmsToolReceiveDetailService {
	
    @Autowired
    private TmsToolReceiveDetailMapper tmsToolReceiveDetailMapper;
	
    @Override
    public List<TmsToolReceiveDetail> selectByMainId(String mainId) {
        return tmsToolReceiveDetailMapper.selectByMainId(mainId);
    }
}

 src/main/java/org/jeecg/modules/tms/service/impl/TmsToolReceiveServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,46 @@
package org.jeecg.modules.tms.service.impl;

import org.jeecg.modules.tms.entity.TmsToolReceive;
import org.jeecg.modules.tms.entity.TmsToolReceiveDetail;
import org.jeecg.modules.tms.mapper.TmsToolReceiveDetailMapper;
import org.jeecg.modules.tms.mapper.TmsToolReceiveMapper;
import org.jeecg.modules.tms.service.ITmsToolReceiveService;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import java.io.Serializable;
import java.util.List;
import java.util.Collection;

/**
 * @Description: å·¥è£…领用
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
@Service
public class TmsToolReceiveServiceImpl extends ServiceImpl<TmsToolReceiveMapper, TmsToolReceive> implements ITmsToolReceiveService {

    @Autowired
    private TmsToolReceiveMapper tmsToolReceiveMapper;
    @Autowired
    private TmsToolReceiveDetailMapper tmsToolReceiveDetailMapper;
	
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void delMain(String id) {
        tmsToolReceiveDetailMapper.deleteByMainId(id);
        tmsToolReceiveMapper.deleteById(id);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void delBatchMain(Collection<? extends Serializable> idList) {
        for(Serializable id:idList) {
            tmsToolReceiveDetailMapper.deleteByMainId(id.toString());
            tmsToolReceiveMapper.deleteById(id);
        }
    }
	
}

 src/main/java/org/jeecg/modules/tms/service/impl/TmsToolScrapDetailServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,27 @@
package org.jeecg.modules.tms.service.impl;

import org.jeecg.modules.tms.entity.TmsToolScrapDetail;
import org.jeecg.modules.tms.mapper.TmsToolScrapDetailMapper;
import org.jeecg.modules.tms.service.ITmsToolScrapDetailService;
import org.springframework.stereotype.Service;
import java.util.List;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;

/**
 * @Description: å·¥è£…报废明细
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
@Service
public class TmsToolScrapDetailServiceImpl extends ServiceImpl<TmsToolScrapDetailMapper, TmsToolScrapDetail> implements ITmsToolScrapDetailService {
	
    @Autowired
    private TmsToolScrapDetailMapper tmsToolScrapDetailMapper;
	
    @Override
    public List<TmsToolScrapDetail> selectByMainId(String mainId) {
        return tmsToolScrapDetailMapper.selectByMainId(mainId);
    }
}

 src/main/java/org/jeecg/modules/tms/service/impl/TmsToolScrapServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,46 @@
package org.jeecg.modules.tms.service.impl;

import org.jeecg.modules.tms.entity.TmsToolScrap;
import org.jeecg.modules.tms.entity.TmsToolScrapDetail;
import org.jeecg.modules.tms.mapper.TmsToolScrapDetailMapper;
import org.jeecg.modules.tms.mapper.TmsToolScrapMapper;
import org.jeecg.modules.tms.service.ITmsToolScrapService;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import java.io.Serializable;
import java.util.List;
import java.util.Collection;

/**
 * @Description: å·¥è£…报废
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
@Service
public class TmsToolScrapServiceImpl extends ServiceImpl<TmsToolScrapMapper, TmsToolScrap> implements ITmsToolScrapService {

    @Autowired
    private TmsToolScrapMapper tmsToolScrapMapper;
    @Autowired
    private TmsToolScrapDetailMapper tmsToolScrapDetailMapper;
	
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void delMain(String id) {
        tmsToolScrapDetailMapper.deleteByMainId(id);
        tmsToolScrapMapper.deleteById(id);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void delBatchMain(Collection<? extends Serializable> idList) {
        for(Serializable id:idList) {
            tmsToolScrapDetailMapper.deleteByMainId(id.toString());
            tmsToolScrapMapper.deleteById(id);
        }
    }
	
}

 src/main/java/org/jeecg/modules/tms/service/impl/TmsToolStocktakingDetailServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,27 @@
package org.jeecg.modules.tms.service.impl;

import org.jeecg.modules.tms.entity.TmsToolStocktakingDetail;
import org.jeecg.modules.tms.mapper.TmsToolStocktakingDetailMapper;
import org.jeecg.modules.tms.service.ITmsToolStocktakingDetailService;
import org.springframework.stereotype.Service;
import java.util.List;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;

/**
 * @Description: å·¥è£…盘点明细
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
@Service
public class TmsToolStocktakingDetailServiceImpl extends ServiceImpl<TmsToolStocktakingDetailMapper, TmsToolStocktakingDetail> implements ITmsToolStocktakingDetailService {
	
    @Autowired
    private TmsToolStocktakingDetailMapper tmsToolStocktakingDetailMapper;
	
    @Override
    public List<TmsToolStocktakingDetail> selectByMainId(String mainId) {
        return tmsToolStocktakingDetailMapper.selectByMainId(mainId);
    }
}

 src/main/java/org/jeecg/modules/tms/service/impl/TmsToolStocktakingInventoryChangeServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,19 @@
package org.jeecg.modules.tms.service.impl;

import org.jeecg.modules.tms.entity.TmsToolStocktakingInventoryChange;
import org.jeecg.modules.tms.mapper.TmsToolStocktakingInventoryChangeMapper;
import org.jeecg.modules.tms.service.ITmsToolStocktakingInventoryChangeService;
import org.springframework.stereotype.Service;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;

/**
 * @Description: ç›˜ç‚¹åº“存变更
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
@Service
public class TmsToolStocktakingInventoryChangeServiceImpl extends ServiceImpl<TmsToolStocktakingInventoryChangeMapper, TmsToolStocktakingInventoryChange> implements ITmsToolStocktakingInventoryChangeService {

}

 src/main/java/org/jeecg/modules/tms/service/impl/TmsToolStocktakingServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,46 @@
package org.jeecg.modules.tms.service.impl;

import org.jeecg.modules.tms.entity.TmsToolStocktaking;
import org.jeecg.modules.tms.entity.TmsToolStocktakingDetail;
import org.jeecg.modules.tms.mapper.TmsToolStocktakingDetailMapper;
import org.jeecg.modules.tms.mapper.TmsToolStocktakingMapper;
import org.jeecg.modules.tms.service.ITmsToolStocktakingService;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import java.io.Serializable;
import java.util.List;
import java.util.Collection;

/**
 * @Description: å·¥è£…盘点
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
@Service
public class TmsToolStocktakingServiceImpl extends ServiceImpl<TmsToolStocktakingMapper, TmsToolStocktaking> implements ITmsToolStocktakingService {

    @Autowired
    private TmsToolStocktakingMapper tmsToolStocktakingMapper;
    @Autowired
    private TmsToolStocktakingDetailMapper tmsToolStocktakingDetailMapper;
	
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void delMain(String id) {
        tmsToolStocktakingDetailMapper.deleteByMainId(id);
        tmsToolStocktakingMapper.deleteById(id);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void delBatchMain(Collection<? extends Serializable> idList) {
        for(Serializable id:idList) {
            tmsToolStocktakingDetailMapper.deleteByMainId(id.toString());
            tmsToolStocktakingMapper.deleteById(id);
        }
    }
	
}

 src/main/java/org/jeecg/modules/tms/service/impl/TmsToolsServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,19 @@
package org.jeecg.modules.tms.service.impl;

import org.jeecg.modules.tms.entity.TmsTools;
import org.jeecg.modules.tms.mapper.TmsToolsMapper;
import org.jeecg.modules.tms.service.ITmsToolsService;
import org.springframework.stereotype.Service;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;

/**
 * @Description: å·¥è£…信息
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
@Service
public class TmsToolsServiceImpl extends ServiceImpl<TmsToolsMapper, TmsTools> implements ITmsToolsService {

}

 src/main/java/org/jeecg/modules/tms/vo/TmsToolInboundRequest.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,66 @@
package org.jeecg.modules.tms.vo;

import java.util.List;

import org.jeecg.modules.tms.entity.TmsToolInboundDetail;
import lombok.Data;
import org.jeecgframework.poi.excel.annotation.Excel;
import org.jeecgframework.poi.excel.annotation.ExcelCollection;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.springframework.format.annotation.DateTimeFormat;
import java.util.Date;

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;

/**
 * @Description: å·¥è£…入库
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
@Data
@ApiModel(value="tms_tool_inboundPage对象", description="工装入库")
public class TmsToolInboundRequest {

    /**主键*/
    @ApiModelProperty(value = "主键")
    private String id;
    /**入库单状态*/
    @Excel(name = "入库单状态", width = 15)
    @ApiModelProperty(value = "入库单状态")
    private String orderStatus;
    /**入库人*/
    @Excel(name = "入库人", width = 15)
    @ApiModelProperty(value = "入库人")
    private String receiver;
    /**入库时间*/
    @Excel(name = "入库时间", width = 15, format = "yyyy-MM-dd HH:mm")
    @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm")
    @DateTimeFormat(pattern="yyyy-MM-dd HH:mm")
    @ApiModelProperty(value = "入库时间")
    private Date receiveTime;
    /**入库说明*/
    @Excel(name = "入库说明", width = 15)
    @ApiModelProperty(value = "入库说明")
    private String receiveComment;
    /**确认人*/
    @Excel(name = "确认人", width = 15)
    @ApiModelProperty(value = "确认人")
    private String confirmer;
    /**确认时间*/
    @Excel(name = "确认时间", width = 15, format = "yyyy-MM-dd HH:mm")
    @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm")
    @DateTimeFormat(pattern="yyyy-MM-dd")
    @ApiModelProperty(value = "确认时间")
    private Date confirmTime;
    /**确认意见*/
    @Excel(name = "确认意见", width = 15)
    @ApiModelProperty(value = "确认意见")
    private String confirmComment;

    @ExcelCollection(name="工装入库明细")
    @ApiModelProperty(value = "工装入库明细")
    private List<TmsToolInboundDetail> tmsToolInboundDetailList;

}

 src/main/java/org/jeecg/modules/tms/vo/TmsToolScrapPage.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,87 @@
package org.jeecg.modules.tms.vo;

import java.util.List;
import org.jeecg.modules.tms.entity.TmsToolScrap;
import org.jeecg.modules.tms.entity.TmsToolScrapDetail;
import lombok.Data;
import org.jeecgframework.poi.excel.annotation.Excel;
import org.jeecgframework.poi.excel.annotation.ExcelEntity;
import org.jeecgframework.poi.excel.annotation.ExcelCollection;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.springframework.format.annotation.DateTimeFormat;
import java.util.Date;
import org.jeecg.common.aspect.annotation.Dict;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;

/**
 * @Description: å·¥è£…报废
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
@Data
@ApiModel(value="tms_tool_scrapPage对象", description="工装报废")
public class TmsToolScrapPage {

    /**主键*/
    @ApiModelProperty(value = "主键")
    private String id;
    /**创建人*/
    @ApiModelProperty(value = "创建人")
    private String createBy;
    /**创建时间*/
    @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd")
    @DateTimeFormat(pattern="yyyy-MM-dd")
    @ApiModelProperty(value = "创建时间")
    private Date createTime;
    /**更新人*/
    @ApiModelProperty(value = "更新人")
    private String updateBy;
    /**更新时间*/
    @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd")
    @DateTimeFormat(pattern="yyyy-MM-dd")
    @ApiModelProperty(value = "更新时间")
    private Date updateTime;
    /**删除标记*/
    @Excel(name = "删除标记", width = 15)
    @ApiModelProperty(value = "删除标记")
    private Integer delFlag;
    /**报废单状态*/
    @Excel(name = "报废单状态", width = 15)
    @ApiModelProperty(value = "报废单状态")
    private String orderStatus;
    /**申请人*/
    @Excel(name = "申请人", width = 15)
    @ApiModelProperty(value = "申请人")
    private String applicant;
    /**申请时间*/
    @Excel(name = "申请时间", width = 15, format = "yyyy-MM-dd")
    @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd")
    @DateTimeFormat(pattern="yyyy-MM-dd")
    @ApiModelProperty(value = "申请时间")
    private Date applicationTime;
    /**申请说明*/
    @Excel(name = "申请说明", width = 15)
    @ApiModelProperty(value = "申请说明")
    private String applicationComment;
    /**确认人*/
    @Excel(name = "确认人", width = 15)
    @ApiModelProperty(value = "确认人")
    private String confirmer;
    /**确认时间*/
    @Excel(name = "确认时间", width = 15, format = "yyyy-MM-dd")
    @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd")
    @DateTimeFormat(pattern="yyyy-MM-dd")
    @ApiModelProperty(value = "确认时间")
    private Date confirmTime;
    /**确认意见*/
    @Excel(name = "确认意见", width = 15)
    @ApiModelProperty(value = "确认意见")
    private String confirmComment;

    @ExcelCollection(name="工装报废明细")
    @ApiModelProperty(value = "工装报废明细")
    private List<TmsToolScrapDetail> tmsToolScrapDetailList;

}