feat(basic): 添加产品条码功能并完善生产统计报表

云

6 天以前 1e123568c2f561013f5636e45dc0db30b17a3517

 src/main/java/com/ruoyi/basic/service/impl/ProductServiceImpl.java

@@ -1,6 +1,9 @@
package com.ruoyi.basic.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
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;
@@ -9,13 +12,19 @@
import com.ruoyi.basic.pojo.Product;
import com.ruoyi.basic.pojo.ProductModel;
import com.ruoyi.basic.service.IProductService;
import com.ruoyi.basic.vo.ProductModelVo;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.bean.BeanUtils;
import com.ruoyi.stock.mapper.StockInventoryMapper;
import com.ruoyi.stock.pojo.StockInventory;
import lombok.AllArgsConstructor;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

@Service
@AllArgsConstructor
@@ -24,6 +33,8 @@
    private ProductMapper productMapper;

    private ProductModelMapper productModelMapper;

    private StockInventoryMapper stockInventoryMapper;

    @Override
    public List<ProductTreeDto> selectProductList(ProductDto productDto) {
@@ -48,6 +59,12 @@
        }
        return tree;
    }

    @Override
    public IPage<ProductModelVo> listPageProductModel(Page<ProductModelVo> page, ProductModel productModel) {
        return productModelMapper.listPageProductModel(page, productModel);
    }


    // 递归构建子节点
    private List<ProductTreeDto> buildChildrenNodes(Long parentId) {
@@ -78,17 +95,21 @@

    @Override
    public int addOrEditProduct(ProductDto productDto) {
        if (ObjectUtils.isEmpty(productDto.getParentId())) {
            throw new IllegalArgumentException("请选择父节点");
        }
        String productName = StringUtils.trim(productDto.getProductName());
        if (StringUtils.isEmpty(productName)) {
            throw new IllegalArgumentException("产品名称不能为空");
        }
        productDto.setProductName(productName);
        checkProductNameUnique(productDto.getParentId(), productName, productDto.getId());
        if (productDto.getId() == null) {
            // 新增产品逻辑
            if (productDto.getParentId() == null) {
                // 若未指定父节点，默认为根节点（parentId 设为 null）
                productDto.setParentId(null);
            } else {
                // 检查父节点是否存在（可选，根据业务需求）
                Product parent = productMapper.selectById(productDto.getParentId());
                if (parent == null) {
                    throw new IllegalArgumentException("父节点不存在，无法添加子产品");
                }
            // 检查父节点是否存在（可选，根据业务需求）
            Product parent = productMapper.selectById(productDto.getParentId());
            if (parent == null) {
                throw new IllegalArgumentException("父节点不存在，无法添加子产品");
            }
            return productMapper.insert(productDto);
        } else {
@@ -102,17 +123,45 @@
        }
    }

    private void checkProductNameUnique(Long parentId, String productName, Long currentId) {
        LambdaQueryWrapper<Product> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Product::getParentId, parentId)
                .eq(Product::getProductName, productName)
                .ne(currentId != null, Product::getId, currentId)
                .last("limit 1");
        Product duplicateProduct = productMapper.selectOne(queryWrapper);
        if (duplicateProduct != null) {
            throw new IllegalArgumentException("对应的" + productName + "已经存在");
        }
    }

    @Override
    public int delProductByIds(Long[] ids) {
        // 1. 删除子表 product_model 中关联的数据
        List<Long> idList = Arrays.asList(ids);

        // 1. 存在子分类时不允许删除，避免树结构出现孤儿节点
        LambdaQueryWrapper<Product> childWrapper = new LambdaQueryWrapper<>();
        childWrapper.in(Product::getParentId, idList);
        if (productMapper.selectCount(childWrapper) > 0) {
            throw new ServiceException("该产品下存在子分类，请先删除子分类");
        }

        // 2. 规格已被库存记录引用时不允许删除，避免历史数据断链
        LambdaQueryWrapper<ProductModel> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.in(ProductModel::getProductId, ids);
        productModelMapper.delete(queryWrapper);
        queryWrapper.in(ProductModel::getProductId, idList);
        List<ProductModel> models = productModelMapper.selectList(queryWrapper);
        if (!models.isEmpty()) {
            List<Long> modelIds = models.stream().map(ProductModel::getId).collect(Collectors.toList());
            LambdaQueryWrapper<StockInventory> stockWrapper = new LambdaQueryWrapper<>();
            stockWrapper.in(StockInventory::getProductModelId, modelIds);
            if (stockInventoryMapper.selectCount(stockWrapper) > 0) {
                throw new ServiceException("该产品规格已存在库存记录，不能删除");
            }
            productModelMapper.delete(queryWrapper);
        }

        // 2. 删除主表 product 数据
        int deleteCount = productMapper.deleteBatchIds(Arrays.asList(ids));

        return deleteCount;
        // 3. 删除主表 product 数据
        return productMapper.deleteBatchIds(idList);
    }

}