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;
|
import com.ruoyi.basic.mapper.ProductMapper;
|
import com.ruoyi.basic.mapper.ProductModelMapper;
|
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
|
public class ProductServiceImpl extends ServiceImpl<ProductMapper, Product> implements IProductService {
|
|
private ProductMapper productMapper;
|
|
private ProductModelMapper productModelMapper;
|
|
private StockInventoryMapper stockInventoryMapper;
|
|
@Override
|
public List<ProductTreeDto> selectProductList(ProductDto productDto) {
|
// 查询根节点（parentId 为 null）
|
LambdaQueryWrapper<Product> queryWrapper = new LambdaQueryWrapper<>();
|
queryWrapper.isNull(Product::getParentId);
|
|
// 如果有产品名称条件，添加到查询中
|
if (productDto.getProductName() != null && !productDto.getProductName().isEmpty()) {
|
queryWrapper.like(Product::getProductName, productDto.getProductName());
|
}
|
|
// 查询根节点列表
|
List<Product> rootProducts = productMapper.selectList(queryWrapper);
|
|
// 转换为树节点并递归构建子树
|
List<ProductTreeDto> tree = new ArrayList<>();
|
for (Product product : rootProducts) {
|
ProductTreeDto node = convertToTreeDto(product);
|
node.setChildren(buildChildrenNodes(product.getId()));
|
tree.add(node);
|
}
|
return tree;
|
}
|
|
@Override
|
public IPage<ProductModelVo> listPageProductModel(Page<ProductModelVo> page, ProductModel productModel) {
|
return productModelMapper.listPageProductModel(page, productModel);
|
}
|
|
|
// 递归构建子节点
|
private List<ProductTreeDto> buildChildrenNodes(Long parentId) {
|
// 查询当前父节点的子节点
|
LambdaQueryWrapper<Product> queryWrapper = new LambdaQueryWrapper<>();
|
queryWrapper.eq(Product::getParentId, parentId);
|
List<Product> childProducts = productMapper.selectList(queryWrapper);
|
|
// 转换子节点并递归构建它们的子树
|
List<ProductTreeDto> children = new ArrayList<>();
|
for (Product child : childProducts) {
|
ProductTreeDto childNode = convertToTreeDto(child);
|
childNode.setChildren(buildChildrenNodes(child.getId()));
|
children.add(childNode);
|
}
|
|
return children;
|
}
|
|
// 将 Product 转换为 ProductTreeDto
|
private ProductTreeDto convertToTreeDto(Product product) {
|
ProductTreeDto dto = new ProductTreeDto();
|
BeanUtils.copyProperties(product, dto);
|
dto.setLabel(product.getProductName()); // 设置 label 为产品名称
|
dto.setChildren(new ArrayList<>());
|
return dto;
|
}
|
|
@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) {
|
// 新增产品逻辑
|
// 检查父节点是否存在（可选，根据业务需求）
|
Product parent = productMapper.selectById(productDto.getParentId());
|
if (parent == null) {
|
throw new IllegalArgumentException("父节点不存在，无法添加子产品");
|
}
|
return productMapper.insert(productDto);
|
} else {
|
// 编辑产品逻辑
|
// 检查产品是否存在（可选，根据业务需求）
|
Product existingProduct = productMapper.selectById(productDto.getId());
|
if (existingProduct == null) {
|
throw new IllegalArgumentException("要编辑的产品不存在");
|
}
|
return productMapper.updateById(productDto);
|
}
|
}
|
|
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) {
|
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, 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);
|
}
|
|
// 3. 删除主表 product 数据
|
return productMapper.deleteBatchIds(idList);
|
}
|
|
}
|
