package com.ruoyi.stock.service.impl;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
|
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.ruoyi.basic.dto.ProductDto;
|
import com.ruoyi.basic.dto.ProductTreeDto;
|
import com.ruoyi.basic.mapper.ProductMapper;
|
import com.ruoyi.basic.mapper.ProductModelMapper;
|
import com.ruoyi.basic.pojo.Product;
|
import com.ruoyi.common.enums.StockInQualifiedRecordTypeEnum;
|
import com.ruoyi.common.utils.StringUtils;
|
import com.ruoyi.common.utils.poi.ExcelUtil;
|
import com.ruoyi.framework.web.domain.R;
|
import com.ruoyi.sales.mapper.SalesLedgerProductMapper;
|
import com.ruoyi.sales.pojo.SalesLedgerProduct;
|
import com.ruoyi.stock.dto.StockInRecordDto;
|
import com.ruoyi.stock.dto.StockInventoryDto;
|
import com.ruoyi.stock.dto.StockOutRecordDto;
|
import com.ruoyi.stock.execl.StockInventoryExportData;
|
import com.ruoyi.stock.mapper.StockInventoryMapper;
|
import com.ruoyi.stock.pojo.StockInventory;
|
import com.ruoyi.stock.service.StockInRecordService;
|
import com.ruoyi.stock.service.StockInventoryService;
|
import com.ruoyi.stock.service.StockOutRecordService;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.web.multipart.MultipartFile;
|
|
import javax.servlet.http.HttpServletResponse;
|
import java.math.BigDecimal;
|
import java.util.*;
|
|
/**
|
* <p>
|
* 库存表 服务实现类
|
* </p>
|
*
|
* @author 芯导软件（江苏）有限公司
|
* @since 2026-01-21 04:16:36
|
*/
|
@Service
|
public class StockInventoryServiceImpl extends ServiceImpl<StockInventoryMapper, StockInventory> implements StockInventoryService {
|
|
@Autowired
|
private StockInventoryMapper stockInventoryMapper;
|
@Autowired
|
private StockInRecordService stockInRecordService;
|
@Autowired
|
private StockOutRecordService stockOutRecordService;
|
@Autowired
|
private SalesLedgerProductMapper salesLedgerProductMapper;
|
@Autowired
|
private ProductMapper productMapper;
|
@Autowired
|
private ProductModelMapper productModelMapper;
|
|
|
@Override
|
public IPage<StockInventoryDto> pagestockInventory(Page page, StockInventoryDto stockInventoryDto) {
|
return stockInventoryMapper.pagestockInventory(page, stockInventoryDto);
|
}
|
|
//入库调用
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public Boolean addstockInventory(StockInventoryDto stockInventoryDto) {
|
//新增入库记录再添加库存
|
if (stockInventoryDto.getRecordType() != null) {
|
StockInRecordDto stockInRecordDto = new StockInRecordDto();
|
stockInRecordDto.setRecordId(stockInventoryDto.getRecordId());
|
stockInRecordDto.setRecordType(stockInventoryDto.getRecordType());
|
stockInRecordDto.setStockInNum(stockInventoryDto.getQualitity());
|
stockInRecordDto.setProductModelId(stockInventoryDto.getProductModelId());
|
stockInRecordDto.setType("0");
|
stockInRecordDto.setBatchNo(stockInventoryDto.getBatchNo());
|
stockInRecordDto.setCustomer(stockInventoryDto.getCustomer());
|
stockInRecordService.add(stockInRecordDto);
|
}
|
//再进行新增库存数量库存
|
//先查询库存表中的产品是否存在，不存在新增，存在更新
|
StockInventory oldStockInventory = stockInventoryMapper.selectOne(new QueryWrapper<StockInventory>().lambda()
|
.eq(StockInventory::getProductModelId, stockInventoryDto.getProductModelId())
|
.eq(StockInventory::getBatchNo, stockInventoryDto.getBatchNo())
|
.eq(StockInventory::getCustomer, stockInventoryDto.getCustomer())
|
);
|
if (ObjectUtils.isEmpty(oldStockInventory)) {
|
StockInventory newStockInventory = new StockInventory();
|
newStockInventory.setProductModelId(stockInventoryDto.getProductModelId());
|
newStockInventory.setQualitity(stockInventoryDto.getQualitity());
|
newStockInventory.setVersion(1);
|
newStockInventory.setRemark(stockInventoryDto.getRemark());
|
newStockInventory.setLockedQuantity(stockInventoryDto.getLockedQuantity());
|
newStockInventory.setWarnNum(stockInventoryDto.getWarnNum());
|
newStockInventory.setBatchNo(stockInventoryDto.getBatchNo());
|
newStockInventory.setCustomer(stockInventoryDto.getCustomer());
|
stockInventoryMapper.insert(newStockInventory);
|
}else {
|
stockInventoryMapper.updateAddStockInventory(stockInventoryDto);
|
}
|
return true;
|
}
|
|
//出库调用
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public Boolean subtractStockInventory(StockInventoryDto stockInventoryDto) {
|
// 新增出库记录
|
if (stockInventoryDto.getRecordType() != null) {
|
StockOutRecordDto stockOutRecordDto = new StockOutRecordDto();
|
stockOutRecordDto.setRecordId(stockInventoryDto.getRecordId());
|
stockOutRecordDto.setRecordType(stockInventoryDto.getRecordType());
|
stockOutRecordDto.setStockOutNum(stockInventoryDto.getQualitity());
|
stockOutRecordDto.setProductModelId(stockInventoryDto.getProductModelId());
|
stockOutRecordDto.setBatchNo(stockInventoryDto.getBatchNo());
|
stockOutRecordDto.setCustomer(stockInventoryDto.getCustomer());
|
stockOutRecordDto.setType("0");
|
stockOutRecordService.add(stockOutRecordDto);
|
}
|
StockInventory oldStockInventory = stockInventoryMapper.selectOne(new QueryWrapper<StockInventory>().lambda()
|
.eq(StockInventory::getProductModelId, stockInventoryDto.getProductModelId())
|
.eq(StockInventory::getBatchNo, stockInventoryDto.getBatchNo())
|
.eq(StockInventory::getCustomer, stockInventoryDto.getCustomer())
|
);
|
if (ObjectUtils.isEmpty(oldStockInventory)) {
|
throw new RuntimeException("产品库存不存在");
|
}
|
BigDecimal lockedQty = oldStockInventory.getLockedQuantity();
|
if (lockedQty == null) {
|
lockedQty = BigDecimal.ZERO;
|
}
|
if (stockInventoryDto.getQualitity().compareTo(oldStockInventory.getQualitity().subtract(lockedQty)) > 0) {
|
throw new RuntimeException("库存不足无法出库");
|
}
|
|
stockInventoryMapper.updateSubtractStockInventory(stockInventoryDto);
|
return true;
|
}
|
|
@Override
|
public R importStockInventory(MultipartFile file) {
|
try {
|
// 查询所有的产品
|
List<SalesLedgerProduct> salesLedgerProducts = salesLedgerProductMapper.selectProduct();
|
|
ExcelUtil<StockInventoryExportData> util = new ExcelUtil<StockInventoryExportData>(StockInventoryExportData.class);
|
List<StockInventoryExportData> list = util.importExcel(file.getInputStream());
|
|
// 记录未找到匹配项的数据
|
List<String> unmatchedRecords = new ArrayList<>();
|
|
list.forEach(dto -> {
|
boolean matched = false;
|
for (SalesLedgerProduct item : salesLedgerProducts) {
|
if (item.getProductCategory().equals(dto.getProductName()) &&
|
item.getSpecificationModel().equals(dto.getModel())) {
|
StockInventoryDto stockInventoryDto = new StockInventoryDto();
|
stockInventoryDto.setRecordId(0L);
|
stockInventoryDto.setRecordType(StockInQualifiedRecordTypeEnum.CUSTOMIZATION_STOCK_IN.getCode());
|
stockInventoryDto.setQualitity(dto.getQualitity());
|
stockInventoryDto.setRemark(dto.getRemark());
|
stockInventoryDto.setWarnNum(dto.getWarnNum());
|
if (ObjectUtils.isNotEmpty(dto.getLockedQuantity())&&dto.getLockedQuantity().compareTo(dto.getQualitity())>0) {
|
throw new RuntimeException("冻结数量不能超过本次导入的库存数量");
|
}
|
stockInventoryDto.setLockedQuantity(dto.getLockedQuantity());
|
stockInventoryDto.setProductModelId(item.getProductModelId());
|
this.addstockInventory(stockInventoryDto);
|
matched = true;
|
break; // 找到匹配项后跳出循环
|
}
|
}
|
if (!matched) {
|
// 记录未匹配的数据
|
String unmatchedInfo = String.format("产品名称：%s，规格型号：%s",
|
dto.getProductName(), dto.getModel());
|
unmatchedRecords.add(unmatchedInfo);
|
}
|
});
|
// 构建返回信息
|
StringBuilder message = new StringBuilder();
|
if (!unmatchedRecords.isEmpty()) {
|
message.append("以下产品未找到匹配项：\n");
|
for (String record : unmatchedRecords) {
|
message.append(record).append("\n");
|
}
|
throw new RuntimeException(message.toString());
|
}
|
} catch (Exception e) {
|
e.printStackTrace();
|
return R.fail("导入失败：" + e.getMessage());
|
}
|
return R.ok("导入成功");
|
}
|
|
|
@Override
|
public void exportStockInventory(HttpServletResponse response, StockInventoryDto stockInventoryDto) {
|
|
List<StockInventoryExportData> list = stockInventoryMapper.listStockInventoryExportData(stockInventoryDto);
|
ExcelUtil<StockInventoryExportData> util = new ExcelUtil<>(StockInventoryExportData.class);
|
util.exportExcel(response,list, "库存信息");
|
}
|
|
@Override
|
public IPage<StockInRecordDto> stockInventoryPage(StockInventoryDto stockInventoryDto, Page page) {
|
return stockInventoryMapper.stockInventoryPage(stockInventoryDto,page);
|
}
|
|
@Override
|
public IPage<StockInventoryDto> stockInAndOutRecord(StockInventoryDto stockInventoryDto, Page page) {
|
return stockInventoryMapper.stockInAndOutRecord(stockInventoryDto,page);
|
}
|
|
@Override
|
public Boolean frozenStock(StockInventoryDto stockInventoryDto) {
|
StockInventory stockInventory = stockInventoryMapper.selectById(stockInventoryDto.getId());
|
if (stockInventory.getQualitity().compareTo(stockInventoryDto.getLockedQuantity())<0) {
|
throw new RuntimeException("冻结数量不能超过库存数量");
|
}
|
if (ObjectUtils.isEmpty(stockInventory.getLockedQuantity())) {
|
stockInventory.setLockedQuantity(stockInventoryDto.getLockedQuantity());
|
}else {
|
stockInventory.setLockedQuantity(stockInventory.getLockedQuantity().add(stockInventoryDto.getLockedQuantity()));
|
}
|
return this.updateById(stockInventory);
|
}
|
|
@Override
|
public Boolean thawStock(StockInventoryDto stockInventoryDto) {
|
StockInventory stockInventory = stockInventoryMapper.selectById(stockInventoryDto.getId());
|
if (stockInventory.getLockedQuantity().compareTo(stockInventoryDto.getLockedQuantity())<0) {
|
throw new RuntimeException("解冻数量不能超过冻结数量");
|
}
|
stockInventory.setLockedQuantity(stockInventory.getLockedQuantity().subtract(stockInventoryDto.getLockedQuantity()));
|
return this.updateById(stockInventory);
|
}
|
|
@Override
|
public List<StockInventoryDto> getMaterials(StockInventoryDto stockInventoryDto) {
|
return stockInventoryMapper.getMaterials(stockInventoryDto);
|
}
|
|
@Override
|
public List<ProductTreeDto> getStockInventoryAll(ProductDto productDto) {
|
// 查询库存列表
|
List<StockInventoryDto> stockList = stockInventoryMapper.getStockInventoryAll(productDto);
|
|
if (CollectionUtils.isEmpty(stockList)) {
|
return new ArrayList<>();
|
}
|
|
// 构建产品树（基于产品表的父子关系）
|
Map<Long, ProductTreeDto> productNodeMap = buildProductTree(stockList);
|
|
// 将库存数据（型号->批次->客户）挂载到对应的产品节点下
|
attachStockDataToProduct(productNodeMap, stockList);
|
|
// 返回根节点
|
List<ProductTreeDto> tree = new ArrayList<>();
|
for (ProductTreeDto node : productNodeMap.values()) {
|
if (node.getParentId() == null || node.getParentId() == 0) {
|
tree.add(node);
|
}
|
}
|
|
return tree;
|
}
|
|
/**
|
* 构建产品树（自动递归查询所有父级，包含根节点）
|
*/
|
private Map<Long, ProductTreeDto> buildProductTree(List<StockInventoryDto> stockList) {
|
// 1. 收集所有需要加载的产品ID
|
Set<Long> needQueryIds = new HashSet<>();
|
for (StockInventoryDto stock : stockList) {
|
if (stock.getProductId() != null) {
|
needQueryIds.add(stock.getProductId());
|
}
|
}
|
|
// 递归查询所有节点（直到根节点）
|
Set<Long> allAncestors = getAllAncestorIds(needQueryIds);
|
needQueryIds.addAll(allAncestors);
|
|
// 批量查询所有产品（包含完整层级）
|
LambdaQueryWrapper<Product> wrapper = new LambdaQueryWrapper<>();
|
wrapper.in(Product::getId, needQueryIds);
|
List<Product> products = productMapper.selectList(wrapper);
|
|
// 构建节点Map
|
Map<Long, ProductTreeDto> nodeMap = new HashMap<>();
|
for (Product product : products) {
|
ProductTreeDto node = new ProductTreeDto();
|
node.setId(product.getId());
|
node.setParentId(product.getParentId());
|
node.setProductName(product.getProductName());
|
node.setLabel(product.getProductName());
|
node.setNodeType("product");
|
node.setChildren(new ArrayList<>());
|
nodeMap.put(product.getId(), node);
|
}
|
|
// 构建父子关系
|
for (ProductTreeDto node : nodeMap.values()) {
|
Long parentId = node.getParentId();
|
if (parentId != null && parentId != 0 && nodeMap.containsKey(parentId)) {
|
nodeMap.get(parentId).getChildren().add(node);
|
}
|
}
|
|
return nodeMap;
|
}
|
|
/**
|
* 递归查询所有产品的祖先ID（直到根节点）
|
*/
|
private Set<Long> getAllAncestorIds(Set<Long> productIds) {
|
Set<Long> ancestorIds = new HashSet<>();
|
Queue<Long> queue = new LinkedList<>(productIds);
|
|
while (!queue.isEmpty()) {
|
Long currentId = queue.poll();
|
Product product = productMapper.selectById(currentId);
|
if (product == null) continue;
|
|
Long parentId = product.getParentId();
|
if (parentId != null && parentId != 0 && !ancestorIds.contains(parentId)) {
|
ancestorIds.add(parentId);
|
queue.add(parentId);
|
}
|
}
|
return ancestorIds;
|
}
|
|
/**
|
* 将库存数据（型号->批次->客户）挂载到产品节点下
|
*/
|
private void attachStockDataToProduct(Map<Long, ProductTreeDto> productNodeMap,
|
List<StockInventoryDto> stockList) {
|
for (StockInventoryDto stock : stockList) {
|
Long productId = stock.getProductId();
|
if (productId == null || !productNodeMap.containsKey(productId)) {
|
continue;
|
}
|
|
ProductTreeDto productNode = productNodeMap.get(productId);
|
|
// 构建该产品的库存树（型号 -> 批次 -> 客户）
|
ProductTreeDto stockTree = buildStockTree(stock);
|
|
// 合并到产品节点的 children 中
|
mergeStockTree(productNode.getChildren(), stockTree);
|
}
|
}
|
|
/**
|
* 构建单个库存的树结构（型号 -> 批次 -> 客户）
|
*/
|
private ProductTreeDto buildStockTree(StockInventoryDto stock) {
|
// 型号节点
|
ProductTreeDto modelNode = new ProductTreeDto();
|
modelNode.setModel(stock.getModel());
|
modelNode.setUidNo(stock.getUidNo());
|
modelNode.setUnit(stock.getUnit());
|
modelNode.setProductModelId(stock.getProductModelId());
|
modelNode.setLabel(stock.getModel());
|
modelNode.setNodeType("model");
|
modelNode.setChildren(new ArrayList<>());
|
|
// 批次节点
|
ProductTreeDto batchNode = new ProductTreeDto();
|
String batchNo = StringUtils.isBlank(stock.getBatchNo()) ? "无批次" : stock.getBatchNo();
|
batchNode.setBatchNo(batchNo);
|
batchNode.setLabel("批次: " + batchNo);
|
batchNode.setNodeType("batch");
|
batchNode.setChildren(new ArrayList<>());
|
|
// 客户节点
|
ProductTreeDto customerNode = new ProductTreeDto();
|
String customer = StringUtils.isBlank(stock.getCustomer()) ? "无客户" : stock.getCustomer();
|
customerNode.setCustomer(customer);
|
customerNode.setLabel(customer);
|
customerNode.setNodeType("customer");
|
customerNode.setChildren(new ArrayList<>());
|
|
batchNode.getChildren().add(customerNode);
|
modelNode.getChildren().add(batchNode);
|
|
return modelNode;
|
}
|
|
/**
|
* 合并库存树到产品节点的 children 中
|
*/
|
private void mergeStockTree(List<ProductTreeDto> children, ProductTreeDto newStockTree) {
|
if (children == null) {
|
return;
|
}
|
|
// 查找是否已有相同型号的节点
|
ProductTreeDto existingModelNode = null;
|
for (ProductTreeDto child : children) {
|
if (child.getNodeType().equals("model") &&
|
child.getModel() != null &&
|
child.getModel().equals(newStockTree.getModel())) {
|
existingModelNode = child;
|
break;
|
}
|
}
|
|
if (existingModelNode == null) {
|
// 没有相同型号，直接添加
|
children.add(newStockTree);
|
} else {
|
// 有相同型号，合并批次节点
|
ProductTreeDto newBatchNode = newStockTree.getChildren().get(0);
|
|
// 查找是否已有相同批次
|
ProductTreeDto existingBatchNode = null;
|
for (ProductTreeDto batchChild : existingModelNode.getChildren()) {
|
if (batchChild.getNodeType().equals("batch") &&
|
batchChild.getBatchNo() != null &&
|
batchChild.getBatchNo().equals(newBatchNode.getBatchNo())) {
|
existingBatchNode = batchChild;
|
break;
|
}
|
}
|
|
if (existingBatchNode == null) {
|
existingModelNode.getChildren().add(newBatchNode);
|
} else {
|
// 合并客户节点
|
ProductTreeDto newCustomerNode = newBatchNode.getChildren().get(0);
|
boolean customerExists = false;
|
for (ProductTreeDto customerChild : existingBatchNode.getChildren()) {
|
if (customerChild.getNodeType().equals("customer") &&
|
customerChild.getCustomer() != null &&
|
customerChild.getCustomer().equals(newCustomerNode.getCustomer())) {
|
customerExists = true;
|
break;
|
}
|
}
|
if (!customerExists) {
|
existingBatchNode.getChildren().add(newCustomerNode);
|
}
|
}
|
}
|
}
|
}
|
