DeXun/klp-oa
9
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor(wms): 移除废弃的出入库相关接口和实现

Browse Source 
- 注释掉推荐采购计划相关接口及其实现逻辑
- 删除出入库单主表和明细表的控制器、服务接口及实现类
- 移除出入库单相关的Mapper接口及XML配置文件
- 清理原材料服务中不再使用的库存信息填充方法
This commit is contained in:
Joshi
2025-10-28 13:06:25 +08:00
parent 00bb21b39a
commit 3be57b3f67
19 changed files with 88 additions and 1806 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
klp-wms/src/main/java/com/klp/controller/WmsPurchasePlanController.java
View File

@@ -47,14 +47,14 @@ public class WmsPurchasePlanController extends BaseController {
public R<Void> addPurchasePlan(@RequestBody WmsPurchasePlanVo planVo) {
return toAjax(iWmsPurchasePlanService.insertWithDetails(planVo));
}
/**
* 根据订单ID生成推荐采购计划（只返回，不落库）
*/
@GetMapping("/recommend/{orderId}")
public R<WmsPurchasePlanVo> recommendPurchasePlan(@PathVariable Long orderId) {
WmsPurchasePlanVo planVo = iWmsPurchasePlanService.recommendPurchasePlanByOrder(orderId);
return R.ok(planVo);
}
// /**
// * 根据订单ID生成推荐采购计划（只返回，不落库）
// */
// @GetMapping("/recommend/{orderId}")
// public R<WmsPurchasePlanVo> recommendPurchasePlan(@PathVariable Long orderId) {
// WmsPurchasePlanVo planVo = iWmsPurchasePlanService.recommendPurchasePlanByOrder(orderId);
// return R.ok(planVo);
// }
/**
* 识别图片中的文字

186
klp-wms/src/main/java/com/klp/controller/WmsStockIoController.java
View File

@@ -1,186 +0,0 @@
package com.klp.controller;
import java.util.List;
import java.util.Arrays;
import java.util.Map;
import com.klp.domain.WmsStockIo;
import com.klp.domain.WmsStockIoDetail;
import com.klp.domain.bo.WmsStockIoDetailBo;
import com.klp.domain.vo.WmsStockIoDetailVo;
import lombok.RequiredArgsConstructor;
import javax.servlet.http.HttpServletResponse;
import javax.validation.constraints.*;
import cn.dev33.satoken.annotation.SaCheckPermission;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;
import org.springframework.validation.annotation.Validated;
import com.klp.common.annotation.RepeatSubmit;
import com.klp.common.annotation.Log;
import com.klp.common.core.controller.BaseController;
import com.klp.common.core.domain.PageQuery;
import com.klp.common.core.domain.R;
import com.klp.common.core.validate.AddGroup;
import com.klp.common.core.validate.EditGroup;
import com.klp.common.enums.BusinessType;
import com.klp.common.utils.poi.ExcelUtil;
import com.klp.domain.vo.WmsStockIoVo;
import com.klp.domain.bo.WmsStockIoBo;
import com.klp.service.IWmsStockIoService;
import com.klp.common.core.page.TableDataInfo;
import com.klp.domain.bo.WmsStockIoWithDetailBo;
/**
* 出入库单主表
*
* @author Joshi
* @date 2025-07-18
*/
@Validated
@RequiredArgsConstructor
@RestController
@RequestMapping("/wms/stockIo")
public class WmsStockIoController extends BaseController {
private final IWmsStockIoService iWmsStockIoService;
/**
* 查询出入库单主列表
*/
@GetMapping("/list")
public TableDataInfo<WmsStockIoVo> list(WmsStockIoBo bo, PageQuery pageQuery) {
return iWmsStockIoService.queryPageList(bo, pageQuery);
}
/**
* 导出出入库单主列表
*/
@Log(title = "出入库单主", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(WmsStockIoBo bo, HttpServletResponse response) {
List<WmsStockIoVo> list = iWmsStockIoService.queryList(bo);
ExcelUtil.exportExcel(list, "出入库单主", WmsStockIoVo.class, response);
}
/**
* 获取出入库单主详细信息
*
* @param stockIoId 主键
*/
@GetMapping("/{stockIoId}")
public R<WmsStockIoVo> getInfo(@NotNull(message = "主键不能为空")
@PathVariable Long stockIoId) {
return R.ok(iWmsStockIoService.queryById(stockIoId));
}
/**
* 新增出入库单主
*/
@Log(title = "出入库单主", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping()
public R<Void> add(@Validated(AddGroup.class) @RequestBody WmsStockIoBo bo) {
return toAjax(iWmsStockIoService.insertByBo(bo));
}
/**
* 批量新增主表和明细
*/
@PostMapping("/withDetail")
public R<Void> addWithDetail(@RequestBody WmsStockIoWithDetailBo bo) {
iWmsStockIoService.addWithDetail(bo);
return R.ok();
}
/**
* 修改出入库单主
*/
@Log(title = "出入库单主", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping()
public R<Void> edit(@Validated(EditGroup.class) @RequestBody WmsStockIoBo bo) {
return toAjax(iWmsStockIoService.updateByBo(bo));
}
/**
* 删除出入库单主
*
* @param stockIoIds 主键串
*/
@Log(title = "出入库单主", businessType = BusinessType.DELETE)
@DeleteMapping("/{stockIoIds}")
public R<Void> remove(@NotEmpty(message = "主键不能为空")
@PathVariable Long[] stockIoIds) {
return toAjax(iWmsStockIoService.deleteWithValidByIds(Arrays.asList(stockIoIds), true));
}
/**
* 审核出入库/移库单
*/
@Log(title = "出入库单主", businessType = BusinessType.UPDATE)
@PostMapping("/audit/{stockIoId}")
public R<Void> audit(@NotNull(message = "主键不能为空") @PathVariable Long stockIoId) {
return toAjax(iWmsStockIoService.auditStockIo(stockIoId));
}
/**
* 撤销出入库/移库单
*/
@Log(title = "出入库单主", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PostMapping("/cancel/{stockIoId}")
public R<Void> cancel(@NotNull(message = "主键不能为空") @PathVariable Long stockIoId) {
return toAjax(iWmsStockIoService.cancelStockIo(stockIoId));
}
/**
* 根据ioType和stockIoId联查明细
*/
@GetMapping("/detailByTypeAndId")
public R<List<WmsStockIoDetailVo>> detailByTypeAndId(@RequestParam String ioType, @RequestParam Long stockIoId) {
return R.ok(iWmsStockIoService.detailByTypeAndId(ioType, stockIoId));
}
/**
* 更新出入库单状态
*/
@Log(title = "出入库单主", businessType = BusinessType.UPDATE)
@PostMapping("/updateStatus/{stockIoId}")
public R<Void> updateStatus(@NotNull(message = "主键不能为空") @PathVariable Long stockIoId,
@RequestParam Integer status) {
return toAjax(iWmsStockIoService.updateStatus(stockIoId, status));
}
/**
* 扫码枪专用：根据明细ID直接入库，无需审核整单
*/
@PostMapping("/scanInStock")
public R<Void> scanInStock(@RequestBody WmsStockIoDetailBo bo) {
try {
boolean result = iWmsStockIoService.scanInStockByBo(bo);
return toAjax(result);
} catch (Exception e) {
return R.fail(e.getMessage());
}
}
@PostMapping("/scanOutStock")
public R<Void> scanOutStock(@RequestBody WmsStockIoDetailBo bo) {
try {
boolean result = iWmsStockIoService.scanOutStockByBo(bo);
return toAjax(result);
} catch (Exception e) {
return R.fail(e.getMessage());
}
}
//退库操作
@PostMapping("/returnStock")
public R<Void> scanReturnStock(@RequestBody WmsStockIoBo bo) {
try {
boolean result = iWmsStockIoService.scanReturnStockByBo(bo);
return toAjax(result);
} catch (Exception e) {
return R.fail(e.getMessage());
}
}
}

108
klp-wms/src/main/java/com/klp/controller/WmsStockIoDetailController.java
View File

@@ -1,108 +0,0 @@
package com.klp.controller;
import java.util.List;
import java.util.Arrays;
import com.klp.domain.bo.WmsStockBo;
import com.klp.domain.vo.WmsStockVo;
import lombok.RequiredArgsConstructor;
import javax.servlet.http.HttpServletResponse;
import javax.validation.constraints.*;
import cn.dev33.satoken.annotation.SaCheckPermission;
import org.redisson.api.RList;
import org.springframework.web.bind.annotation.*;
import org.springframework.validation.annotation.Validated;
import com.klp.common.annotation.RepeatSubmit;
import com.klp.common.annotation.Log;
import com.klp.common.core.controller.BaseController;
import com.klp.common.core.domain.PageQuery;
import com.klp.common.core.domain.R;
import com.klp.common.core.validate.AddGroup;
import com.klp.common.core.validate.EditGroup;
import com.klp.common.enums.BusinessType;
import com.klp.common.utils.poi.ExcelUtil;
import com.klp.domain.vo.WmsStockIoDetailVo;
import com.klp.domain.bo.WmsStockIoDetailBo;
import com.klp.service.IWmsStockIoDetailService;
import com.klp.common.core.page.TableDataInfo;
/**
* 出入库单明细
*
* @author Joshi
* @date 2025-07-18
*/
@Validated
@RequiredArgsConstructor
@RestController
@RequestMapping("/wms/stockIoDetail")
public class WmsStockIoDetailController extends BaseController {
private final IWmsStockIoDetailService iWmsStockIoDetailService;
/**
* 查询出入库单明细列表
*/
@GetMapping("/list")
public TableDataInfo<WmsStockIoDetailVo> list(WmsStockIoDetailBo bo, PageQuery pageQuery) {
return iWmsStockIoDetailService.queryPageList(bo, pageQuery);
}
/**
* 导出出入库单明细列表
*/
@Log(title = "出入库单明细", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(WmsStockIoDetailBo bo, HttpServletResponse response) {
List<WmsStockIoDetailVo> list = iWmsStockIoDetailService.queryList(bo);
ExcelUtil.exportExcel(list, "出入库单明细", WmsStockIoDetailVo.class, response);
}
/**
* 获取出入库单明细详细信息
*
* @param detailId 主键
*/
@GetMapping("/{detailId}")
public R<WmsStockIoDetailVo> getInfo(@NotNull(message = "主键不能为空")
@PathVariable Long detailId) {
return R.ok(iWmsStockIoDetailService.queryById(detailId));
}
/**
* 新增出入库单明细
*/
@Log(title = "出入库单明细", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping()
public R<Void> add(@Validated(AddGroup.class) @RequestBody WmsStockIoDetailBo bo) {
return toAjax(iWmsStockIoDetailService.insertByBo(bo));
}
/**
* 修改出入库单明细
*/
@Log(title = "出入库单明细", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping()
public R<Void> edit(@Validated(EditGroup.class) @RequestBody WmsStockIoDetailBo bo) {
return toAjax(iWmsStockIoDetailService.updateByBo(bo));
}
/**
* 删除出入库单明细
*
* @param detailIds 主键串
*/
@Log(title = "出入库单明细", businessType = BusinessType.DELETE)
@DeleteMapping("/{detailIds}")
public R<Void> remove(@NotEmpty(message = "主键不能为空")
@PathVariable Long[] detailIds) {
return toAjax(iWmsStockIoDetailService.deleteWithValidByIds(Arrays.asList(detailIds), true));
}
//根据批次号联查出入库单主表以及明细表信息
@PostMapping("/batch")
public R<List<WmsStockIoDetailVo>> batchQuery(@RequestBody WmsStockIoDetailBo bo) {
return R.ok(iWmsStockIoDetailService.batchQuery(bo));
}
}

99
klp-wms/src/main/java/com/klp/controller/WmsStockLogController.java
View File

@@ -1,99 +0,0 @@
package com.klp.controller;
import java.util.List;
import java.util.Arrays;
import lombok.RequiredArgsConstructor;
import javax.servlet.http.HttpServletResponse;
import javax.validation.constraints.*;
import org.springframework.web.bind.annotation.*;
import org.springframework.validation.annotation.Validated;
import com.klp.common.annotation.RepeatSubmit;
import com.klp.common.annotation.Log;
import com.klp.common.core.controller.BaseController;
import com.klp.common.core.domain.PageQuery;
import com.klp.common.core.domain.R;
import com.klp.common.core.validate.AddGroup;
import com.klp.common.core.validate.EditGroup;
import com.klp.common.enums.BusinessType;
import com.klp.common.utils.poi.ExcelUtil;
import com.klp.domain.vo.WmsStockLogVo;
import com.klp.domain.bo.WmsStockLogBo;
import com.klp.service.IWmsStockLogService;
import com.klp.common.core.page.TableDataInfo;
/**
* 库存流水
*
* @author JR
* @date 2025-08-11
*/
@Validated
@RequiredArgsConstructor
@RestController
@RequestMapping("/klp/stockLog")
public class WmsStockLogController extends BaseController {
private final IWmsStockLogService iWmsStockLogService;
/**
* 查询库存流水列表
*/
@GetMapping("/list")
public TableDataInfo<WmsStockLogVo> list(WmsStockLogBo bo, PageQuery pageQuery) {
return iWmsStockLogService.queryPageList(bo, pageQuery);
}
/**
* 导出库存流水列表
*/
@Log(title = "库存流水", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(WmsStockLogBo bo, HttpServletResponse response) {
List<WmsStockLogVo> list = iWmsStockLogService.queryList(bo);
ExcelUtil.exportExcel(list, "库存流水", WmsStockLogVo.class, response);
}
/**
* 获取库存流水详细信息
*
* @param id 主键
*/
@GetMapping("/{id}")
public R<WmsStockLogVo> getInfo(@NotNull(message = "主键不能为空")
@PathVariable Long id) {
return R.ok(iWmsStockLogService.queryById(id));
}
/**
* 新增库存流水
*/
@Log(title = "库存流水", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping()
public R<Void> add(@Validated(AddGroup.class) @RequestBody WmsStockLogBo bo) {
return toAjax(iWmsStockLogService.insertByBo(bo));
}
/**
* 修改库存流水
*/
@Log(title = "库存流水", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping()
public R<Void> edit(@Validated(EditGroup.class) @RequestBody WmsStockLogBo bo) {
return toAjax(iWmsStockLogService.updateByBo(bo));
}
/**
* 删除库存流水
*
* @param ids 主键串
*/
@Log(title = "库存流水", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public R<Void> remove(@NotEmpty(message = "主键不能为空")
@PathVariable Long[] ids) {
return toAjax(iWmsStockLogService.deleteWithValidByIds(Arrays.asList(ids), true));
}
}

37
klp-wms/src/main/java/com/klp/mapper/WmsStockIoDetailMapper.java
View File

@@ -1,37 +0,0 @@
package com.klp.mapper;
import com.klp.common.core.validate.AddGroup;
import com.klp.common.core.validate.EditGroup;
import com.klp.domain.WmsStockIoDetail;
import com.klp.domain.vo.WmsStockIoDetailVo;
import com.klp.common.core.mapper.BaseMapperPlus;
import org.apache.ibatis.annotations.Param;
import java.util.List;
import java.util.Map;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import javax.validation.constraints.NotBlank;
/**
* 出入库单明细Mapper接口
*
* VO带有库区/库位名称和源库区/库位名称
*
* @author Joshi
* @date 2025-07-18
*/
public interface WmsStockIoDetailMapper extends BaseMapperPlus<WmsStockIoDetailMapper, WmsStockIoDetail, WmsStockIoDetailVo> {
/**
* 联查库区/库位名称的明细列表，返回Map
*/
List<Map<String, Object>> selectDetailWithWarehouseName(@Param("stockIoId") Long stockIoId);
/**
* 分页联查库区/库位名称的明细列表，支持Wrapper动态条件，返回Page<WmsStockIoDetailVo>
*/
Page<WmsStockIoDetailVo> selectVoPagePlus(Page<?> page, @Param("ew") Wrapper<WmsStockIoDetail> wrapper);
List<WmsStockIoDetailVo> batchQuery(@Param("batchNo") String batchNo);
}

15
klp-wms/src/main/java/com/klp/mapper/WmsStockIoMapper.java
View File

@@ -1,15 +0,0 @@
package com.klp.mapper;
import com.klp.domain.WmsStockIo;
import com.klp.domain.vo.WmsStockIoVo;
import com.klp.common.core.mapper.BaseMapperPlus;
/**
* 出入库单主Mapper接口
*
* @author Joshi
* @date 2025-07-18
*/
public interface WmsStockIoMapper extends BaseMapperPlus<WmsStockIoMapper, WmsStockIo, WmsStockIoVo> {
}

19
klp-wms/src/main/java/com/klp/mapper/WmsStockLogMapper.java
View File

@@ -1,19 +0,0 @@
package com.klp.mapper;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.klp.domain.WmsStockLog;
import com.klp.domain.vo.WmsStockLogVo;
import com.klp.common.core.mapper.BaseMapperPlus;
import org.apache.ibatis.annotations.Param;
/**
* 库存流水Mapper接口
*
* @author JR
* @date 2025-08-11
*/
public interface WmsStockLogMapper extends BaseMapperPlus<WmsStockLogMapper, WmsStockLog, WmsStockLogVo> {
Page<WmsStockLogVo> selectVoPagePlus(Page<?> page, @Param("ew") Wrapper<WmsStockLog> wrapper);
}

8
klp-wms/src/main/java/com/klp/service/IWmsPurchasePlanService.java
View File

@@ -22,10 +22,10 @@ public interface IWmsPurchasePlanService {
*/
Boolean insertWithDetails(WmsPurchasePlanVo planVo);
/**
* 根据订单ID生成推荐采购计划（只返回，不落库）
*/
WmsPurchasePlanVo recommendPurchasePlanByOrder(Long orderId);
// /**
// * 根据订单ID生成推荐采购计划（只返回，不落库）
// */
// WmsPurchasePlanVo recommendPurchasePlanByOrder(Long orderId);
/**
* 查询采购计划主

53
klp-wms/src/main/java/com/klp/service/IWmsStockIoDetailService.java
View File

@@ -1,53 +0,0 @@
package com.klp.service;
import com.klp.domain.WmsStockIoDetail;
import com.klp.domain.bo.WmsStockBo;
import com.klp.domain.vo.WmsStockIoDetailVo;
import com.klp.domain.bo.WmsStockIoDetailBo;
import com.klp.common.core.page.TableDataInfo;
import com.klp.common.core.domain.PageQuery;
import com.klp.domain.vo.WmsStockVo;
import java.util.Collection;
import java.util.List;
/**
* 出入库单明细Service接口
*
* @author Joshi
* @date 2025-07-18
*/
public interface IWmsStockIoDetailService {
/**
* 查询出入库单明细
*/
WmsStockIoDetailVo queryById(Long detailId);
/**
* 查询出入库单明细列表
*/
TableDataInfo<WmsStockIoDetailVo> queryPageList(WmsStockIoDetailBo bo, PageQuery pageQuery);
/**
* 查询出入库单明细列表
*/
List<WmsStockIoDetailVo> queryList(WmsStockIoDetailBo bo);
/**
* 新增出入库单明细
*/
Boolean insertByBo(WmsStockIoDetailBo bo);
/**
* 修改出入库单明细
*/
Boolean updateByBo(WmsStockIoDetailBo bo);
/**
* 校验并批量删除出入库单明细信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
List<WmsStockIoDetailVo> batchQuery(WmsStockIoDetailBo bo);
}

84
klp-wms/src/main/java/com/klp/service/IWmsStockIoService.java
View File

@@ -1,84 +0,0 @@
package com.klp.service;
import com.klp.domain.WmsStockIo;
import com.klp.domain.bo.WmsStockIoDetailBo;
import com.klp.domain.vo.WmsStockIoDetailVo;
import com.klp.domain.vo.WmsStockIoVo;
import com.klp.domain.bo.WmsStockIoBo;
import com.klp.domain.bo.WmsStockIoWithDetailBo;
import com.klp.common.core.page.TableDataInfo;
import com.klp.common.core.domain.PageQuery;
import java.util.Collection;
import java.util.List;
/**
* 出入库单主Service接口
*
* @author Joshi
* @date 2025-07-18
*/
public interface IWmsStockIoService {
/**
* 查询出入库单主
*/
WmsStockIoVo queryById(Long stockIoId);
/**
* 查询出入库单主列表
*/
TableDataInfo<WmsStockIoVo> queryPageList(WmsStockIoBo bo, PageQuery pageQuery);
/**
* 查询出入库单主列表
*/
List<WmsStockIoVo> queryList(WmsStockIoBo bo);
/**
* 新增出入库单主
*/
Boolean insertByBo(WmsStockIoBo bo);
/**
* 修改出入库单主
*/
Boolean updateByBo(WmsStockIoBo bo);
/**
* 校验并批量删除出入库单主信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
/**
* 审核出入库/移库单，变更库存，含库存校验
*/
Boolean auditStockIo(Long stockIoId);
/**
* 撤销出入库/移库单，库存回滚
*/
Boolean cancelStockIo(Long stockIoId);
/**
* 根据ioType和stockIoId联查明细
*/
java.util.List<WmsStockIoDetailVo> detailByTypeAndId(String ioType, Long stockIoId);
/**
* 更新出入库单状态
*/
Boolean updateStatus(Long stockIoId, Integer status);
/**
* 批量新增主表和明细
*/
void addWithDetail(WmsStockIoWithDetailBo bo);
boolean scanInStockByBo(WmsStockIoDetailBo bo);
boolean scanOutStockByBo(WmsStockIoDetailBo bo);
boolean scanReturnStockByBo(WmsStockIoBo bo);
}

49
klp-wms/src/main/java/com/klp/service/IWmsStockLogService.java
View File

@@ -1,49 +0,0 @@
package com.klp.service;
import com.klp.domain.WmsStockLog;
import com.klp.domain.vo.WmsStockLogVo;
import com.klp.domain.bo.WmsStockLogBo;
import com.klp.common.core.page.TableDataInfo;
import com.klp.common.core.domain.PageQuery;
import java.util.Collection;
import java.util.List;
/**
* 库存流水Service接口
*
* @author JR
* @date 2025-08-11
*/
public interface IWmsStockLogService {
/**
* 查询库存流水
*/
WmsStockLogVo queryById(Long id);
/**
* 查询库存流水列表
*/
TableDataInfo<WmsStockLogVo> queryPageList(WmsStockLogBo bo, PageQuery pageQuery);
/**
* 查询库存流水列表
*/
List<WmsStockLogVo> queryList(WmsStockLogBo bo);
/**
* 新增库存流水
*/
Boolean insertByBo(WmsStockLogBo bo);
/**
* 修改库存流水
*/
Boolean updateByBo(WmsStockLogBo bo);
/**
* 校验并批量删除库存流水信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
}

106
klp-wms/src/main/java/com/klp/service/impl/WmsPurchasePlanServiceImpl.java
View File

@@ -71,59 +71,59 @@ public class WmsPurchasePlanServiceImpl implements IWmsPurchasePlanService {
return flag > 0;
}
@Override
public WmsPurchasePlanVo recommendPurchasePlanByOrder(Long orderId) {
// 1. 查询订单明细
List<WmsOrderDetailVo> orderDetails = wmsOrderDetailService.queryListByOrderId(orderId);
// 2. 汇总原材料需求
Map<Long, WmsPurchasePlanDetailVo> materialMap = new HashMap<>();
for (WmsOrderDetailVo detail : orderDetails) {
List<WmsProductBom> bomList = wmsProductBomService.listByProductId(detail.getProductId());
for (WmsProductBom bom : bomList) {
BigDecimal needQty = bom.getQuantity().multiply(detail.getQuantity());
WmsPurchasePlanDetailVo vo =
materialMap.getOrDefault(bom.getRawMaterialId(), new WmsPurchasePlanDetailVo());
vo.setRawMaterialId(bom.getRawMaterialId());
vo.setQuantity(vo.getQuantity() == null ? needQty : vo.getQuantity().add(needQty));
vo.setUnit(bom.getUnit());
// 挂载原材料名称编号
WmsRawMaterial wmsRawMaterial = wmsRawMaterialMapper.selectById(bom.getRawMaterialId());
vo.setRawMaterialName(wmsRawMaterial.getRawMaterialName());
vo.setRawMaterialCode(wmsRawMaterial.getRawMaterialCode());
materialMap.put(bom.getRawMaterialId(), vo);
}
}
// 3. 查询库存并计算推荐采购量
for (WmsPurchasePlanDetailVo vo : materialMap.values()) {
// 需求量
vo.setDemand(vo.getQuantity());
BigDecimal stockQty = wmsStockService.getStockByItemId(vo.getRawMaterialId());
// 库存量
if(stockQty == null){
stockQty = BigDecimal.ZERO;
}
vo.setInventory(stockQty);
// 在途量
BigDecimal onTheWayQty = BigDecimal.ZERO;
BigDecimal byRawMaterialIdAndOnTheWay =
wmsPurchasePlanDetailMapper.getByRawMaterialIdAndOnTheWay(vo.getRawMaterialId());
if (byRawMaterialIdAndOnTheWay != null) {
onTheWayQty = byRawMaterialIdAndOnTheWay;
}
vo.setOnTheWay(onTheWayQty);
// 计算推荐采购量
BigDecimal recommendQty = vo.getQuantity().subtract(onTheWayQty).subtract(stockQty);
vo.setQuantity(recommendQty.compareTo(BigDecimal.ZERO) > 0 ? recommendQty : BigDecimal.ZERO);
}
// 4. 组装主VO
WmsPurchasePlanVo planVo = new WmsPurchasePlanVo();
planVo.setPlanCode("推荐计划-" + orderId);
planVo.setOrderId(orderId);
planVo.setOwner("系统推荐");
planVo.setRemark("仅供参考，实际采购请确认");
planVo.setDetailList(new ArrayList<>(materialMap.values()));
return planVo;
}
// @Override
// public WmsPurchasePlanVo recommendPurchasePlanByOrder(Long orderId) {
// // 1. 查询订单明细
// List<WmsOrderDetailVo> orderDetails = wmsOrderDetailService.queryListByOrderId(orderId);
// // 2. 汇总原材料需求
// Map<Long, WmsPurchasePlanDetailVo> materialMap = new HashMap<>();
// for (WmsOrderDetailVo detail : orderDetails) {
// List<WmsProductBom> bomList = wmsProductBomService.listByProductId(detail.getProductId());
// for (WmsProductBom bom : bomList) {
// BigDecimal needQty = bom.getQuantity().multiply(detail.getQuantity());
// WmsPurchasePlanDetailVo vo =
// materialMap.getOrDefault(bom.getRawMaterialId(), new WmsPurchasePlanDetailVo());
// vo.setRawMaterialId(bom.getRawMaterialId());
// vo.setQuantity(vo.getQuantity() == null ? needQty : vo.getQuantity().add(needQty));
// vo.setUnit(bom.getUnit());
// // 挂载原材料名称编号
// WmsRawMaterial wmsRawMaterial = wmsRawMaterialMapper.selectById(bom.getRawMaterialId());
// vo.setRawMaterialName(wmsRawMaterial.getRawMaterialName());
// vo.setRawMaterialCode(wmsRawMaterial.getRawMaterialCode());
// materialMap.put(bom.getRawMaterialId(), vo);
// }
// }
// // 3. 查询库存并计算推荐采购量
// for (WmsPurchasePlanDetailVo vo : materialMap.values()) {
// // 需求量
// vo.setDemand(vo.getQuantity());
// BigDecimal stockQty = wmsStockService.getStockByItemId(vo.getRawMaterialId());
// // 库存量
// if(stockQty == null){
// stockQty = BigDecimal.ZERO;
// }
// vo.setInventory(stockQty);
// // 在途量
// BigDecimal onTheWayQty = BigDecimal.ZERO;
// BigDecimal byRawMaterialIdAndOnTheWay =
// wmsPurchasePlanDetailMapper.getByRawMaterialIdAndOnTheWay(vo.getRawMaterialId());
// if (byRawMaterialIdAndOnTheWay != null) {
// onTheWayQty = byRawMaterialIdAndOnTheWay;
// }
// vo.setOnTheWay(onTheWayQty);
// // 计算推荐采购量
// BigDecimal recommendQty = vo.getQuantity().subtract(onTheWayQty).subtract(stockQty);
// vo.setQuantity(recommendQty.compareTo(BigDecimal.ZERO) > 0 ? recommendQty : BigDecimal.ZERO);
// }
// // 4. 组装主VO
// WmsPurchasePlanVo planVo = new WmsPurchasePlanVo();
// planVo.setPlanCode("推荐计划-" + orderId);
// planVo.setOrderId(orderId);
// planVo.setOwner("系统推荐");
// planVo.setRemark("仅供参考，实际采购请确认");
// planVo.setDetailList(new ArrayList<>(materialMap.values()));
// return planVo;
// }
/**
* 查询采购计划主

46
klp-wms/src/main/java/com/klp/service/impl/WmsRawMaterialServiceImpl.java
View File

@@ -83,32 +83,32 @@ public class WmsRawMaterialServiceImpl implements IWmsRawMaterialService {
public TableDataInfo<WmsRawMaterialVo> queryPageListWithDemand(WmsRawMaterialBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<WmsRawMaterial> lqw = buildQueryWrapper(bo);
Page<WmsRawMaterialVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
// 填充需求、库存、在途信息
fillDemandInfo(result.getRecords());
// // 填充需求、库存、在途信息
// fillDemandInfo(result.getRecords());
return TableDataInfo.build(result);
}
/**
* 填充原材料需求、库存、在途信息
*/
private void fillDemandInfo(List<WmsRawMaterialVo> rawMaterialList) {
if (rawMaterialList == null || rawMaterialList.isEmpty()) {
return;
}
// 为每个原材料填充信息
for (WmsRawMaterialVo vo : rawMaterialList) {
Long rawMaterialId = vo.getRawMaterialId();
// 查询库存量
BigDecimal inventory = stockService.getStockByItemId(rawMaterialId);
vo.setInventory(inventory != null ? inventory : BigDecimal.ZERO);
// 查询在途量（采购计划明细）
BigDecimal onTheWay = getOnTheWayQuantity(rawMaterialId);
vo.setOnTheWay(onTheWay);
// 查询需求量（订单+BOM）
BigDecimal demand = getDemandQuantity(rawMaterialId);
vo.setDemand(demand);
}
}
// /**
// * 填充原材料需求、库存、在途信息
// */
// private void fillDemandInfo(List<WmsRawMaterialVo> rawMaterialList) {
// if (rawMaterialList == null || rawMaterialList.isEmpty()) {
// return;
// }
// // 为每个原材料填充信息
// for (WmsRawMaterialVo vo : rawMaterialList) {
// Long rawMaterialId = vo.getRawMaterialId();
// // 查询库存量
// BigDecimal inventory = stockService.getStockByItemId(rawMaterialId);
// vo.setInventory(inventory != null ? inventory : BigDecimal.ZERO);
// // 查询在途量（采购计划明细）
// BigDecimal onTheWay = getOnTheWayQuantity(rawMaterialId);
// vo.setOnTheWay(onTheWay);
// // 查询需求量（订单+BOM）
// BigDecimal demand = getDemandQuantity(rawMaterialId);
// vo.setDemand(demand);
// }
// }
/**
* 获取在途量

229
klp-wms/src/main/java/com/klp/service/impl/WmsStockIoDetailServiceImpl.java
View File

@@ -1,229 +0,0 @@
package com.klp.service.impl;
import cn.hutool.core.bean.BeanUtil;
import com.klp.common.core.page.TableDataInfo;
import com.klp.common.core.domain.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.klp.common.utils.StringUtils;
import com.klp.domain.WmsProduct;
import com.klp.domain.WmsRawMaterial;
import com.klp.domain.bo.WmsStockBo;
import com.klp.domain.vo.WmsStockVo;
import com.klp.mapper.WmsProductMapper;
import com.klp.mapper.WmsRawMaterialMapper;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.klp.domain.bo.WmsStockIoDetailBo;
import com.klp.domain.vo.WmsStockIoDetailVo;
import com.klp.domain.WmsStockIoDetail;
import com.klp.domain.WmsStockIo;
import com.klp.mapper.WmsStockIoDetailMapper;
import com.klp.mapper.WmsStockIoMapper;
import com.klp.service.IWmsStockIoDetailService;
import java.util.*;
import com.klp.common.exception.ServiceException;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
/**
* 出入库单明细Service业务层处理
*
* @author Joshi
* @date 2025-07-18
*/
@RequiredArgsConstructor
@Service
public class WmsStockIoDetailServiceImpl implements IWmsStockIoDetailService {
private final WmsStockIoDetailMapper baseMapper;
private final WmsStockIoMapper stockIoMapper;
private final WmsProductMapper productMapper;
private final WmsRawMaterialMapper rawMaterialMapper;
/**
* 查询出入库单明细
*/
@Override
public WmsStockIoDetailVo queryById(Long detailId){
return baseMapper.selectVoById(detailId);
}
/**
* 查询出入库单明细列表
*/
@Override
public TableDataInfo<WmsStockIoDetailVo> queryPageList(WmsStockIoDetailBo bo, PageQuery pageQuery) {
QueryWrapper<WmsStockIoDetail> qw = buildQueryWrapperPlus(bo);
Page<WmsStockIoDetailVo> result = baseMapper.selectVoPagePlus(pageQuery.build(), qw);
return TableDataInfo.build(result);
}
/**
* 查询出入库单明细列表
*/
@Override
public List<WmsStockIoDetailVo> queryList(WmsStockIoDetailBo bo) {
LambdaQueryWrapper<WmsStockIoDetail> qw = buildQueryWrapper(bo);
return baseMapper.selectVoList(qw);
}
private LambdaQueryWrapper<WmsStockIoDetail> buildQueryWrapper(WmsStockIoDetailBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<WmsStockIoDetail> lqw = new LambdaQueryWrapper<>();
lqw.eq(bo.getStockIoId() != null, WmsStockIoDetail::getStockIoId, bo.getStockIoId());
lqw.eq(bo.getWarehouseId() != null, WmsStockIoDetail::getWarehouseId, bo.getWarehouseId());
lqw.eq(StringUtils.isNotBlank(bo.getItemType()), WmsStockIoDetail::getItemType, bo.getItemType());
lqw.eq(bo.getItemId() != null, WmsStockIoDetail::getItemId, bo.getItemId());
lqw.eq(bo.getQuantity() != null, WmsStockIoDetail::getQuantity, bo.getQuantity());
lqw.eq(StringUtils.isNotBlank(bo.getUnit()), WmsStockIoDetail::getUnit, bo.getUnit());
lqw.eq(StringUtils.isNotBlank(bo.getBatchNo()), WmsStockIoDetail::getBatchNo, bo.getBatchNo());
return lqw;
}
private QueryWrapper<WmsStockIoDetail> buildQueryWrapperPlus(WmsStockIoDetailBo bo) {
Map<String, Object> params = bo.getParams();
QueryWrapper<WmsStockIoDetail> qw = new QueryWrapper<>();
qw.eq("d.del_flag", 0); // 手动添加逻辑删除条件
qw.eq(bo.getStockIoId() != null, "d.stock_io_id", bo.getStockIoId());
qw.eq(bo.getWarehouseId() != null, "d.warehouse_id", bo.getWarehouseId());
qw.eq(StringUtils.isNotBlank(bo.getItemType()), "d.item_type", bo.getItemType());
qw.eq(bo.getItemId() != null, "d.item_id", bo.getItemId());
qw.eq(bo.getQuantity() != null, "d.quantity", bo.getQuantity());
qw.eq(StringUtils.isNotBlank(bo.getUnit()), "d.unit", bo.getUnit());
qw.eq(StringUtils.isNotBlank(bo.getBatchNo()), "d.batch_no", bo.getBatchNo());
return qw;
}
/**
* 新增出入库单明细
*/
@Override
@Transactional(rollbackFor = Exception.class)
public Boolean insertByBo(WmsStockIoDetailBo bo) {
// 检查主表状态，已审核的单据不能添加明细
WmsStockIo stockIo = stockIoMapper.selectById(bo.getStockIoId());
if (stockIo != null && stockIo.getStatus() >= 2) {
throw new ServiceException("已审核的单据不能修改明细");
}
// 如果unit为空，自动查item表补全（新增逻辑）
String unit = bo.getUnit();
if (unit == null || unit.trim().isEmpty()) {
if ("product".equals(bo.getItemType())) {
WmsProduct p = productMapper.selectById(bo.getItemId());
unit = p != null ? p.getUnit() : null;
} else if ("raw_material".equals(bo.getItemType())) {
WmsRawMaterial r = rawMaterialMapper.selectById(bo.getItemId());
unit = r != null ? r.getUnit() : null;
}
}
// 将获取到的unit设置回bo对象
bo.setUnit(unit);
WmsStockIoDetail add = BeanUtil.toBean(bo, WmsStockIoDetail.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setDetailId(add.getDetailId());
// 检查主表状态，如果有明细且状态为草稿，则自动变为待审核
if (stockIo != null && stockIo.getStatus() == 0) {
// 检查是否有明细
Long detailCount = baseMapper.selectCount(
new LambdaQueryWrapper<WmsStockIoDetail>()
.eq(WmsStockIoDetail::getStockIoId, bo.getStockIoId())
);
if (detailCount > 0) {
// 自动更新状态为待审核
stockIo.setStatus(1);
stockIo.setUpdateTime(new Date());
stockIoMapper.updateById(stockIo);
}
}
}
return flag;
}
/**
* 修改出入库单明细
*/
@Override
public Boolean updateByBo(WmsStockIoDetailBo bo) {
// 检查主表状态，已审核的单据不能修改明细
WmsStockIo stockIo = stockIoMapper.selectById(bo.getStockIoId());
if (stockIo != null && stockIo.getStatus() >= 2) {
throw new ServiceException("已审核的单据不能修改明细");
}
WmsStockIoDetail update = BeanUtil.toBean(bo, WmsStockIoDetail.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(WmsStockIoDetail entity){
//TODO 做一些数据校验,如唯一约束
}
/**
* 批量删除出入库单明细
*/
@Override
@Transactional(rollbackFor = Exception.class)
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if(isValid){
//TODO 做一些业务上的校验,判断是否需要校验
}
// 获取要删除的明细对应的主表ID，检查状态
List<WmsStockIoDetail> details = baseMapper.selectBatchIds(ids);
if (details != null && !details.isEmpty()) {
// 检查主表状态，已审核的单据不能删除明细
for (WmsStockIoDetail detail : details) {
WmsStockIo stockIo = stockIoMapper.selectById(detail.getStockIoId());
if (stockIo != null && stockIo.getStatus() >= 2) {
throw new ServiceException("已审核的单据不能修改明细");
}
}
// 按主表ID分组
Map<Long, List<WmsStockIoDetail>> stockIoIdMap = details.stream()
.collect(java.util.stream.Collectors.groupingBy(WmsStockIoDetail::getStockIoId));
boolean flag = baseMapper.deleteBatchIds(ids) > 0;
if (flag) {
// 检查每个主表是否还有其他明细
for (Long stockIoId : stockIoIdMap.keySet()) {
Long remainingCount = baseMapper.selectCount(
new LambdaQueryWrapper<WmsStockIoDetail>()
.eq(WmsStockIoDetail::getStockIoId, stockIoId)
);
// 如果没有明细了，状态回退为草稿
if (remainingCount == 0) {
WmsStockIo stockIo = stockIoMapper.selectById(stockIoId);
if (stockIo != null && stockIo.getStatus() == 1) {
stockIo.setStatus(0);
stockIo.setUpdateTime(new Date());
stockIoMapper.updateById(stockIo);
}
}
}
}
return flag;
}
return baseMapper.deleteBatchIds(ids) > 0;
}
@Override
public List<WmsStockIoDetailVo> batchQuery(WmsStockIoDetailBo bo) {
//根据这个bo.getBatchNo()拿到这个批次号对应明细表的信息在根据明细表带的stockIoId拿到库存表信息
return baseMapper.batchQuery(bo.getBatchNo());
}
}

493
klp-wms/src/main/java/com/klp/service/impl/WmsStockIoServiceImpl.java
View File

@@ -1,493 +0,0 @@
package com.klp.service.impl;
import cn.hutool.core.bean.BeanUtil;
import com.klp.common.core.page.TableDataInfo;
import com.klp.common.core.domain.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.klp.common.utils.StringUtils;
import com.klp.domain.*;
import com.klp.domain.vo.WmsStockIoDetailVo;
import com.klp.mapper.*;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import com.klp.domain.bo.WmsStockIoBo;
import com.klp.domain.vo.WmsStockIoVo;
import com.klp.service.IWmsStockIoService;
import org.springframework.transaction.annotation.Transactional;
import java.math.BigDecimal;
import java.util.*;
import com.klp.common.exception.ServiceException;
import com.klp.domain.bo.WmsStockIoWithDetailBo;
import com.klp.domain.bo.WmsStockIoDetailBo;
import javax.annotation.Resource;
/**
* 出入库单主Service业务层处理
*
* @author Joshi
* @date 2025-07-18
*/
@RequiredArgsConstructor
@Service
public class WmsStockIoServiceImpl implements IWmsStockIoService {
private final WmsStockIoMapper baseMapper;
private final WmsStockIoDetailMapper stockIoDetailMapper;
private final WmsStockMapper stockMapper;
private final WmsProductMapper productMapper;
private final WmsRawMaterialMapper rawMaterialMapper;
private final WmsWarehouseMapper warehouseMapper;
@Resource
private WmsStockLogMapper stockLogMapper;
/**
* 查询出入库单主
*/
@Override
public WmsStockIoVo queryById(Long stockIoId){
return baseMapper.selectVoById(stockIoId);
}
/**
* 查询出入库单主列表
*/
@Override
public TableDataInfo<WmsStockIoVo> queryPageList(WmsStockIoBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<WmsStockIo> lqw = buildQueryWrapper(bo);
Page<WmsStockIoVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
return TableDataInfo.build(result);
}
/**
* 查询出入库单主列表
*/
@Override
public List<WmsStockIoVo> queryList(WmsStockIoBo bo) {
LambdaQueryWrapper<WmsStockIo> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<WmsStockIo> buildQueryWrapper(WmsStockIoBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<WmsStockIo> lqw = Wrappers.lambdaQuery();
lqw.eq(StringUtils.isNotBlank(bo.getStockIoCode()), WmsStockIo::getStockIoCode, bo.getStockIoCode());
lqw.eq(StringUtils.isNotBlank(bo.getIoType()), WmsStockIo::getIoType, bo.getIoType());
lqw.eq(StringUtils.isNotBlank(bo.getBizType()), WmsStockIo::getBizType, bo.getBizType());
lqw.eq(bo.getStatus() != null, WmsStockIo::getStatus, bo.getStatus());
return lqw;
}
/**
* 新增出入库单主
*/
@Override
public Boolean insertByBo(WmsStockIoBo bo) {
WmsStockIo add = BeanUtil.toBean(bo, WmsStockIo.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setStockIoId(add.getStockIoId());
}
return flag;
}
/**
* 修改出入库单主
*/
@Override
public Boolean updateByBo(WmsStockIoBo bo) {
WmsStockIo update = BeanUtil.toBean(bo, WmsStockIo.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(WmsStockIo entity){
//TODO 做一些数据校验,如唯一约束
}
/**
* 批量删除出入库单主
*/
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if(isValid){
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteBatchIds(ids) > 0;
}
/**
* 批量新增主表和明细
*/
@Override
@Transactional(rollbackFor = Exception.class)
public void addWithDetail(WmsStockIoWithDetailBo bo) {
// 插入主表
WmsStockIo stockIo = BeanUtil.toBean(bo, WmsStockIo.class);
stockIo.setParentId(bo.getParentId());
baseMapper.insert(stockIo);
// 插入明细
if (bo.getDetails() != null && !bo.getDetails().isEmpty()) {
for (WmsStockIoDetailBo detailBo : bo.getDetails()) {
WmsStockIoDetail detail = BeanUtil.toBean(detailBo, WmsStockIoDetail.class);
detail.setStockIoId(stockIo.getStockIoId());
stockIoDetailMapper.insert(detail);
}
}
}
@Override
@Transactional(rollbackFor = Exception.class)
public boolean scanInStockByBo(WmsStockIoDetailBo bo) {
String unit = bo.getUnit();
// 如果unit为空，自动查item表补全
if (unit == null || unit.trim().isEmpty()) {
if ("product".equals(bo.getItemType())) {
WmsProduct p = productMapper.selectById(bo.getItemId());
unit = p != null ? p.getUnit() : null;
} else if ("raw_material".equals(bo.getItemType())) {
WmsRawMaterial r = rawMaterialMapper.selectById(bo.getItemId());
unit = r != null ? r.getUnit() : null;
}
}
if (unit == null || unit.trim().isEmpty()) {
throw new RuntimeException("未能获取到单位");
}
// 入库操作
changeStock(bo.getWarehouseId(), bo.getItemType(), bo.getItemId(), bo.getBatchNo(), bo.getQuantity(), true, unit);
return true;
}
@Override
@Transactional(rollbackFor = Exception.class)
public boolean scanOutStockByBo(WmsStockIoDetailBo bo) {
String unit = bo.getUnit();
// 如果unit为空，自动查item表补全
if (unit == null || unit.trim().isEmpty()) {
if ("product".equals(bo.getItemType())) {
WmsProduct p = productMapper.selectById(bo.getItemId());
unit = p != null ? p.getUnit() : null;
} else if ("raw_material".equals(bo.getItemType())) {
WmsRawMaterial r = rawMaterialMapper.selectById(bo.getItemId());
unit = r != null ? r.getUnit() : null;
}
}
if (unit == null || unit.trim().isEmpty()) {
throw new RuntimeException("未能获取到单位");
}
// 出库操作
changeStock(bo.getWarehouseId(), bo.getItemType(), bo.getItemId(), bo.getBatchNo(), bo.getQuantity(), false, unit);
return true;
}
@Override
@Transactional(rollbackFor = Exception.class)
public boolean scanReturnStockByBo(WmsStockIoBo bo) {
// 退库操作：根据主表ID查询明细列表，验证退库数量，执行退库
if (bo.getStockIoId() == null) {
throw new ServiceException("退库单ID不能为空");
}
// 1. 获取退库单主表信息
WmsStockIo returnStockIo = baseMapper.selectById(bo.getStockIoId());
if (returnStockIo == null || returnStockIo.getParentId() == null) {
throw new ServiceException("退库单不存在或未关联原出库单");
}
// 2. 获取退库单明细列表
List<WmsStockIoDetail> returnDetails = stockIoDetailMapper.selectList(
Wrappers.<WmsStockIoDetail>lambdaQuery().eq(WmsStockIoDetail::getStockIoId, bo.getStockIoId())
);
if (returnDetails == null || returnDetails.isEmpty()) {
throw new ServiceException("退库单明细不能为空");
}
// 3. 获取原出库单明细列表
List<WmsStockIoDetail> originalOutDetails = stockIoDetailMapper.selectList(
Wrappers.<WmsStockIoDetail>lambdaQuery().eq(WmsStockIoDetail::getStockIoId, returnStockIo.getParentId())
);
if (originalOutDetails == null || originalOutDetails.isEmpty()) {
throw new ServiceException("原出库单明细不存在");
}
// 4. 遍历退库明细，验证数量并执行退库
for (WmsStockIoDetail returnDetail : returnDetails) {
// 查找对应的原出库明细
WmsStockIoDetail originalOutDetail = originalOutDetails.stream()
.filter(detail -> detail.getItemType().equals(returnDetail.getItemType()) &&
detail.getItemId().equals(returnDetail.getItemId()) &&
detail.getWarehouseId().equals(returnDetail.getWarehouseId()))
.findFirst()
.orElse(null);
if (originalOutDetail == null) {
throw new ServiceException("未找到对应的原出库明细：" + returnDetail.getItemType() + "-" + returnDetail.getItemId());
}
// 验证退库数量不能超过原出库数量
BigDecimal totalReturnedQty = baseMapper.selectList(
Wrappers.<WmsStockIo>lambdaQuery()
.eq(WmsStockIo::getParentId, returnStockIo.getParentId())
.eq(WmsStockIo::getIoType, "withdraw")
.ne(WmsStockIo::getStockIoId, returnStockIo.getStockIoId())
).stream()
.flatMap(returnStockIoItem -> stockIoDetailMapper.selectList(
Wrappers.<WmsStockIoDetail>lambdaQuery()
.eq(WmsStockIoDetail::getStockIoId, returnStockIoItem.getStockIoId())
.eq(WmsStockIoDetail::getItemType, returnDetail.getItemType())
.eq(WmsStockIoDetail::getItemId, returnDetail.getItemId())
.eq(WmsStockIoDetail::getWarehouseId, returnDetail.getWarehouseId())
).stream())
.map(WmsStockIoDetail::getQuantity)
.reduce(BigDecimal.ZERO, BigDecimal::add);
BigDecimal remainingQty = originalOutDetail.getQuantity().subtract(totalReturnedQty);
if (returnDetail.getQuantity().compareTo(remainingQty) > 0) {
throw new ServiceException("退库数量超过原出库数量，物品：" + returnDetail.getItemType() + "-" + returnDetail.getItemId() +
"，原出库数量：" + originalOutDetail.getQuantity() + "，已退库数量：" + totalReturnedQty +
"，剩余可退数量：" + remainingQty + "，本次退库数量：" + returnDetail.getQuantity());
}
// 执行退库操作（增加库存）
String unit = returnDetail.getUnit();
if (unit == null || unit.trim().isEmpty()) {
if ("product".equals(returnDetail.getItemType())) {
WmsProduct p = productMapper.selectById(returnDetail.getItemId());
unit = p != null ? p.getUnit() : "个";
} else if ("raw_material".equals(returnDetail.getItemType())) {
WmsRawMaterial r = rawMaterialMapper.selectById(returnDetail.getItemId());
unit = r != null ? r.getUnit() : "个";
}
}
// 执行入库操作（退库就是入库）
changeStock(returnDetail.getWarehouseId(), returnDetail.getItemType(),
returnDetail.getItemId(), returnDetail.getBatchNo(), returnDetail.getQuantity(), true, unit);
}
// 更新单据状态为已审核（2）
returnStockIo.setStatus(2);
return baseMapper.updateById(returnStockIo) > 0;
}
/**
* 审核出入库/移库单，变更库存，含库存校验
*/
@Override
@Transactional(rollbackFor = Exception.class)
public Boolean auditStockIo(Long stockIoId) {
WmsStockIo stockIo = baseMapper.selectById(stockIoId);
if (stockIo == null || stockIo.getStatus() == null || stockIo.getStatus() != 1) {
// 只允许审核“已提交”状态的单据
throw new RuntimeException("单据不存在或状态不允许审核");
}
List<WmsStockIoDetail> details = stockIoDetailMapper.selectList(
Wrappers.<WmsStockIoDetail>lambdaQuery().eq(WmsStockIoDetail::getStockIoId, stockIoId)
);
if (details == null || details.isEmpty()) {
throw new RuntimeException("单据明细不能为空");
}
//如果details.batchNo不相等则需要去stock表新建一条批次号不同的记录
for (WmsStockIoDetail detail : details) {
String ioType = stockIo.getIoType();
if ("in".equals(ioType)) {
// 入库：目标库位库存增加
changeStock(detail.getWarehouseId(), detail.getItemType(), detail.getItemId(), detail.getBatchNo(), detail.getQuantity(), true, detail.getUnit());
} else if ("out".equals(ioType)) {
// 出库：目标库位库存减少
changeStock(detail.getWarehouseId(), detail.getItemType(), detail.getItemId(), detail.getBatchNo(), detail.getQuantity(), false, detail.getUnit());
} else if ("transfer".equals(ioType)) {
// 移库：fromWarehouseId减少，warehouseId增加
if (detail.getFromWarehouseId() == null) {
throw new RuntimeException("移库明细缺少源库位ID");
}
// 先减少源库位
changeStock(detail.getFromWarehouseId(), detail.getItemType(), detail.getItemId(), detail.getBatchNo(), detail.getQuantity(), false, detail.getUnit());
// 再增加目标库位
changeStock(detail.getWarehouseId(), detail.getItemType(), detail.getItemId(), detail.getBatchNo(), detail.getQuantity(), true, detail.getUnit());
} else {
throw new RuntimeException("未知的出入库类型");
}
}
// 更新单据状态为已审核（2）
stockIo.setStatus(2);
return baseMapper.updateById(stockIo) > 0;
}
/**
* 撤销出入库/移库单，库存回滚
*/
@Override
@Transactional(rollbackFor = Exception.class)
public Boolean cancelStockIo(Long stockIoId) {
WmsStockIo stockIo = baseMapper.selectById(stockIoId);
if (stockIo == null || stockIo.getStatus() == null || stockIo.getStatus() != 2) {
throw new ServiceException("只能撤销已审核的单据");
}
List<WmsStockIoDetail> details = stockIoDetailMapper.selectList(
Wrappers.<WmsStockIoDetail>lambdaQuery().eq(WmsStockIoDetail::getStockIoId, stockIoId)
);
if (details == null || details.isEmpty()) {
throw new ServiceException("单据明细不能为空");
}
for (WmsStockIoDetail detail : details) {
String ioType = stockIo.getIoType();
if ("in".equals(ioType)) {
// 入库撤销：目标库位库存减少
changeStock(detail.getWarehouseId(), detail.getItemType(), detail.getItemId(), detail.getBatchNo(), detail.getQuantity(), false, detail.getUnit());
} else if ("out".equals(ioType)) {
// 出库撤销：目标库位库存增加
changeStock(detail.getWarehouseId(), detail.getItemType(), detail.getItemId(), detail.getBatchNo(), detail.getQuantity(), true, detail.getUnit());
} else if ("transfer".equals(ioType)) {
if (detail.getFromWarehouseId() == null) {
throw new ServiceException("移库明细缺少源库位ID");
}
// 源库位库存增加
changeStock(detail.getFromWarehouseId(), detail.getItemType(), detail.getItemId(), detail.getBatchNo(), detail.getQuantity(), true, detail.getUnit());
// 目标库位库存减少
changeStock(detail.getWarehouseId(), detail.getItemType(), detail.getItemId(), detail.getBatchNo(), detail.getQuantity(), false, detail.getUnit());
} else {
throw new ServiceException("未知的出入库类型");
}
}
// 更新单据状态为待审核（1）
stockIo.setStatus(1);
baseMapper.updateById(stockIo);
return true;
}
/**
* 根据ioType和stockIoId联查明细
*/
@Override
public List<WmsStockIoDetailVo> detailByTypeAndId(String ioType, Long stockIoId) {
WmsStockIo stockIo = baseMapper.selectById(stockIoId);
if (stockIo == null) {
throw new ServiceException("单据不存在");
}
if (!ioType.equals(stockIo.getIoType())) {
throw new ServiceException("单据类型不匹配");
}
List<WmsStockIoDetail> details = stockIoDetailMapper.selectList(
Wrappers.<WmsStockIoDetail>lambdaQuery().eq(WmsStockIoDetail::getStockIoId, stockIoId)
);
if (details == null || details.isEmpty()) {
return java.util.Collections.emptyList();
}
// 转VO
List<WmsStockIoDetailVo> voList = new ArrayList<>();
for (WmsStockIoDetail detail : details) {
WmsStockIoDetailVo vo = new WmsStockIoDetailVo();
BeanUtils.copyProperties(detail, vo);
voList.add(vo);
}
return voList;
}
/**
* 更新出入库单状态
*/
@Override
public Boolean updateStatus(Long stockIoId, Integer status) {
WmsStockIo stockIo = baseMapper.selectById(stockIoId);
if (stockIo == null) {
throw new ServiceException("单据不存在");
}
// 状态流转验证
if (stockIo.getStatus() == 0 && status == 1) {
// 草稿 -> 已提交：需要检查是否有明细
List<WmsStockIoDetail> details = stockIoDetailMapper.selectList(
Wrappers.<WmsStockIoDetail>lambdaQuery().eq(WmsStockIoDetail::getStockIoId, stockIoId)
);
if (details == null || details.isEmpty()) {
throw new ServiceException("单据明细不能为空，无法提交");
}
} else if (stockIo.getStatus() == 1 && status == 0) {
// 已提交 -> 草稿：允许回退
} else {
throw new ServiceException("状态流转不允许");
}
stockIo.setStatus(status);
return baseMapper.updateById(stockIo) > 0;
}
/**
* 库存增减，isAdd=true为增加，false为减少，减少时校验库存是否足够
*/
private void changeStock(Long warehouseId, String itemType, Long itemId, BigDecimal quantity, boolean isAdd, String unit) {
changeStock(warehouseId, itemType, itemId, null, quantity, isAdd, unit);
}
/**
* 库存增减（支持批次号），isAdd=true为增加，false为减少，减少时校验库存是否足够
*/
private void changeStock(Long warehouseId, String itemType, Long itemId, String batchNo, BigDecimal quantity, boolean isAdd, String unit) {
WmsStock stock = null;
if (StringUtils.isNotBlank(batchNo)) {
// 如果指定了批次号，按批次号查找（应该是唯一的）
stock = stockMapper.selectOne(Wrappers.<WmsStock>lambdaQuery()
.eq(WmsStock::getWarehouseId, warehouseId)
.eq(WmsStock::getItemType, itemType)
.eq(WmsStock::getItemId, itemId)
.eq(WmsStock::getBatchNo, batchNo));
} else {
// 如果没有指定批次号，查找任意一个批次（按创建时间排序取第一个）
stock = stockMapper.selectOne(Wrappers.<WmsStock>lambdaQuery()
.eq(WmsStock::getWarehouseId, warehouseId)
.eq(WmsStock::getItemType, itemType)
.eq(WmsStock::getItemId, itemId)
.orderByAsc(WmsStock::getCreateTime)
.last("limit 1"));
}
if (stock == null) {
if (!isAdd) {
throw new RuntimeException("库存不足，无法出库/移库");
}
// 新增库存记录
stock = new WmsStock();
stock.setWarehouseId(warehouseId);
stock.setItemType(itemType);
stock.setItemId(itemId);
stock.setBatchNo(StringUtils.isNotBlank(batchNo) ? batchNo : "B-100");
stock.setQuantity(quantity);
stock.setUnit(unit);
stockMapper.insert(stock);
} else {
// 更新现有库存
BigDecimal newQty = isAdd ? stock.getQuantity().add(quantity) : stock.getQuantity().subtract(quantity);
if (newQty.compareTo(BigDecimal.ZERO) < 0) {
throw new RuntimeException("库存不足，无法出库/移库");
}
stock.setQuantity(newQty);
stockMapper.updateById(stock);
}
// 记录库存变更日志
WmsStockLog log = new WmsStockLog();
log.setWarehouseId(warehouseId);
log.setItemType(itemType);
log.setItemId(itemId);
// 变动数量（正=入库，负=出库）
log.setChangeQty(isAdd ? quantity : quantity.negate());
// 变动后的库存数量
log.setAfterQty(stock.getQuantity());
// 变动类型（入库/出库等）
log.setChangeType(isAdd ? "入库" : "出库");
log.setChangeTime(new Date());
log.setBatchNo(batchNo);
stockLogMapper.insert(log);
}
}

183
klp-wms/src/main/java/com/klp/service/impl/WmsStockLogServiceImpl.java
View File

@@ -1,183 +0,0 @@
package com.klp.service.impl;
import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.klp.common.core.page.TableDataInfo;
import com.klp.common.core.domain.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.klp.common.utils.StringUtils;
import com.klp.domain.WmsWarehouse;
import com.klp.mapper.WmsWarehouseMapper;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import com.klp.domain.bo.WmsStockLogBo;
import com.klp.domain.vo.WmsStockLogVo;
import com.klp.domain.WmsStockLog;
import com.klp.mapper.WmsStockLogMapper;
import com.klp.service.IWmsStockLogService;
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Collection;
/**
* 库存流水Service业务层处理
*
* @author JR
* @date 2025-08-11
*/
@RequiredArgsConstructor
@Service
public class WmsStockLogServiceImpl implements IWmsStockLogService {
private final WmsStockLogMapper baseMapper;
@Resource
private WmsWarehouseMapper warehouseMapper;
/**
* 查询库存流水
*/
@Override
public WmsStockLogVo queryById(Long id){
return baseMapper.selectVoById(id);
}
/**
* 查询库存流水列表
*/
@Override
public TableDataInfo<WmsStockLogVo> queryPageList(WmsStockLogBo bo, PageQuery pageQuery) {
QueryWrapper<WmsStockLog> lqw = buildQueryWrapperPlus(bo);
Page<WmsStockLogVo> result = baseMapper.selectVoPagePlus(pageQuery.build(), lqw);
return TableDataInfo.build(result);
}
/**
* 查询库存流水列表
*/
@Override
public List<WmsStockLogVo> queryList(WmsStockLogBo bo) {
LambdaQueryWrapper<WmsStockLog> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private QueryWrapper<WmsStockLog> buildQueryWrapperPlus(WmsStockLogBo bo) {
QueryWrapper<WmsStockLog> lqw = Wrappers.query();
lqw.eq("sl.del_flag", 0);
// 处理仓库ID查询，支持递归查询子节点
if (bo.getWarehouseId() != null) {
List<Long> warehouseIds = getWarehouseIdsWithChildren(bo.getWarehouseId());
if (warehouseIds.size() == 1) {
lqw.eq("sl.warehouse_id", warehouseIds.get(0));
} else {
lqw.in("sl.warehouse_id", warehouseIds);
}
}
lqw.eq(bo.getItemId() != null, "sl.item_id", bo.getItemId());
lqw.eq(StringUtils.isNotBlank(bo.getItemType()), "sl.item_type", bo.getItemType());
lqw.eq(bo.getChangeQty() != null, "sl.change_qty", bo.getChangeQty());
lqw.eq(bo.getAfterQty() != null, "sl.after_qty", bo.getAfterQty());
lqw.eq(StringUtils.isNotBlank(bo.getChangeType()), "sl.change_type", bo.getChangeType());
// 根据时间区间查询
lqw.ge(bo.getStartTime() != null, "sl.change_time", bo.getStartTime());
lqw.le(bo.getEndTime() != null, "sl.change_time", bo.getEndTime());
lqw.eq(StringUtils.isNotBlank(bo.getBatchNo()), "sl.batch_no", bo.getBatchNo());
return lqw;
}
private LambdaQueryWrapper<WmsStockLog> buildQueryWrapper(WmsStockLogBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<WmsStockLog> lqw = Wrappers.lambdaQuery();
lqw.eq(bo.getWarehouseId() != null, WmsStockLog::getWarehouseId, bo.getWarehouseId());
lqw.eq(bo.getItemId() != null, WmsStockLog::getItemId, bo.getItemId());
lqw.eq(StringUtils.isNotBlank(bo.getItemType()), WmsStockLog::getItemType, bo.getItemType());
lqw.eq(bo.getChangeQty() != null, WmsStockLog::getChangeQty, bo.getChangeQty());
lqw.eq(bo.getAfterQty() != null, WmsStockLog::getAfterQty, bo.getAfterQty());
lqw.eq(StringUtils.isNotBlank(bo.getChangeType()), WmsStockLog::getChangeType, bo.getChangeType());
lqw.eq(StringUtils.isNotBlank(bo.getBatchNo()), WmsStockLog::getBatchNo, bo.getBatchNo());
// 根据时间区间查询
lqw.ge(bo.getStartTime() != null, WmsStockLog::getChangeTime, bo.getStartTime());
lqw.le(bo.getEndTime() != null, WmsStockLog::getChangeTime, bo.getEndTime());
return lqw;
}
/**
* 新增库存流水
*/
@Override
public Boolean insertByBo(WmsStockLogBo bo) {
WmsStockLog add = BeanUtil.toBean(bo, WmsStockLog.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setId(add.getId());
}
return flag;
}
/**
* 修改库存流水
*/
@Override
public Boolean updateByBo(WmsStockLogBo bo) {
WmsStockLog update = BeanUtil.toBean(bo, WmsStockLog.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(WmsStockLog entity){
//TODO 做一些数据校验,如唯一约束
}
/**
* 批量删除库存流水
*/
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if(isValid){
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteBatchIds(ids) > 0;
}
/**
* 获取指定仓库ID及其所有子仓库ID
* @param warehouseId 仓库ID
* @return 包含当前仓库ID和所有子仓库ID的列表
*/
private List<Long> getWarehouseIdsWithChildren(Long warehouseId) {
List<Long> warehouseIds = new ArrayList<>();
warehouseIds.add(warehouseId); // 添加当前仓库ID
// 递归获取所有子仓库ID
getChildWarehouseIds(warehouseId, warehouseIds);
return warehouseIds;
}
/**
* 递归获取子仓库ID
* @param parentId 父仓库ID
* @param warehouseIds 仓库ID列表（用于收集结果）
*/
private void getChildWarehouseIds(Long parentId, List<Long> warehouseIds) {
// 查询直接子仓库
List<WmsWarehouse> children = warehouseMapper.selectList(
Wrappers.<WmsWarehouse>lambdaQuery()
.eq(WmsWarehouse::getParentId, parentId)
.eq(WmsWarehouse::getDelFlag, 0)
);
// 递归处理每个子仓库
for (WmsWarehouse child : children) {
warehouseIds.add(child.getWarehouseId());
getChildWarehouseIds(child.getWarehouseId(), warehouseIds);
}
}
}

107
klp-wms/src/main/resources/mapper/klp/WmsStockIoDetailMapper.xml
View File

@@ -1,107 +0,0 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.klp.mapper.WmsStockIoDetailMapper">
<resultMap type="com.klp.domain.WmsStockIoDetail" id="WmsStockIoDetailResult">
<result property="detailId" column="detail_id"/>
<result property="stockIoId" column="stock_io_id"/>
<result property="warehouseId" column="warehouse_id"/>
<result property="itemType" column="item_type"/>
<result property="itemId" column="item_id"/>
<result property="quantity" column="quantity"/>
<result property="unit" column="unit"/>
<result property="batchNo" column="batch_no"/>
<result property="remark" column="remark"/>
<result property="delFlag" column="del_flag"/>
<result property="createTime" column="create_time"/>
<result property="createBy" column="create_by"/>
<result property="updateTime" column="update_time"/>
<result property="updateBy" column="update_by"/>
<result property="fromWarehouseId" column="from_warehouse_id"/>
<result property="recordType" column="record_type"/>
</resultMap>
<!-- 联查库区/库位名称的明细列表SQL，直接返回Map -->
<select id="selectDetailWithWarehouseName" resultType="map">
SELECT
d.detail_id,
d.stock_io_id,
d.warehouse_id,
d.item_type,
d.item_id,
d.quantity,
d.unit,
d.batch_no,
d.remark,
d.del_flag,
d.create_time,
d.create_by,
d.update_time,
d.update_by,
d.from_warehouse_id,
d.record_type,
w1.warehouse_name AS warehouseName,
w2.warehouse_name AS fromWarehouseName
FROM wms_stock_io_detail d
LEFT JOIN wms_warehouse w1 ON d.warehouse_id = w1.warehouse_id and w1.del_flag = 0
LEFT JOIN wms_warehouse w2 ON d.from_warehouse_id = w2.warehouse_id and w2.del_flag = 0
<where>
<if test="stockIoId != null">d.stock_io_id = #{stockIoId}</if>
<!-- 其他条件可补充 -->
</where>
</select>
<!-- 分页联查库区/库位名称的明细列表SQL，支持Wrapper动态条件，返回Page<WmsStockIoDetailVo> -->
<select id="selectVoPagePlus" resultType="com.klp.domain.vo.WmsStockIoDetailVo">
SELECT
d.detail_id,
d.stock_io_id,
d.warehouse_id,
d.item_type,
d.item_id,
d.quantity,
d.unit,
d.batch_no,
d.remark,
d.del_flag,
d.create_time,
d.create_by,
d.update_time,
d.update_by,
d.from_warehouse_id,
d.record_type,
w1.warehouse_name AS warehouseName,
w2.warehouse_name AS fromWarehouseName
FROM wms_stock_io_detail d
LEFT JOIN wms_warehouse w1 ON d.warehouse_id = w1.warehouse_id and w1.del_flag = 0
LEFT JOIN wms_warehouse w2 ON d.from_warehouse_id = w2.warehouse_id and w2.del_flag = 0
${ew.customSqlSegment}
</select>
<select id="batchQuery" resultType="com.klp.domain.vo.WmsStockIoDetailVo">
SELECT
d.detail_id,
d.stock_io_id,
d.warehouse_id,
d.item_type,
d.item_id,
d.quantity,
d.unit,
d.batch_no,
d.remark,
d.del_flag,
d.create_time,
d.create_by,
d.update_time,
d.update_by,
d.from_warehouse_id,
d.record_type,
io.stock_io_code AS stockIoCode,
io.io_type AS ioType,
io.biz_type AS bizType
FROM wms_stock_io_detail d
LEFT JOIN wms_stock_io io ON d.stock_io_id = io.stock_io_id and io.del_flag = 0
WHERE d.batch_no = #{batchNo}
</select>
</mapper>

23
klp-wms/src/main/resources/mapper/klp/WmsStockIoMapper.xml
View File

@@ -1,23 +0,0 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.klp.mapper.WmsStockIoMapper">
<resultMap type="com.klp.domain.WmsStockIo" id="WmsStockIoResult">
<result property="stockIoId" column="stock_io_id"/>
<result property="stockIoCode" column="stock_io_code"/>
<result property="ioType" column="io_type"/>
<result property="bizType" column="biz_type"/>
<result property="status" column="status"/>
<result property="parentId" column="parent_id"/>
<result property="remark" column="remark"/>
<result property="delFlag" column="del_flag"/>
<result property="createTime" column="create_time"/>
<result property="createBy" column="create_by"/>
<result property="updateTime" column="update_time"/>
<result property="updateBy" column="update_by"/>
</resultMap>
</mapper>

33
klp-wms/src/main/resources/mapper/klp/WmsStockLogMapper.xml
View File

@@ -1,33 +0,0 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.klp.mapper.WmsStockLogMapper">
<resultMap type="com.klp.domain.WmsStockLog" id="WmsStockLogResult">
<result property="id" column="id"/>
<result property="warehouseId" column="warehouse_id"/>
<result property="itemId" column="item_id"/>
<result property="itemType" column="item_type"/>
<result property="changeQty" column="change_qty"/>
<result property="afterQty" column="after_qty"/>
<result property="changeType" column="change_type"/>
<result property="changeTime" column="change_time"/>
<result property="batchNo" column="batch_no"/>
<result property="remark" column="remark"/>
<result property="createTime" column="create_time"/>
<result property="createBy" column="create_by"/>
<result property="updateTime" column="update_time"/>
<result property="updateBy" column="update_by"/>
<result property="delFlag" column="del_flag"/>
</resultMap>
<select id="selectVoPagePlus" resultType="com.klp.domain.vo.WmsStockLogVo">
select sl.*, w.warehouse_name
from wms_stock_log sl
left join wms_warehouse w on sl.warehouse_id = w.warehouse_id and w.del_flag = 0
${ew.customSqlSegment}
</select>
</mapper>