package com.ruoyi.stock.service.impl;
|
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
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.common.enums.StockInQualifiedRecordTypeEnum;
|
import com.ruoyi.common.enums.StockOutQualifiedRecordTypeEnum;
|
import com.ruoyi.common.exception.ServiceException;
|
import com.ruoyi.framework.web.domain.R;
|
import com.ruoyi.stock.dto.StockInventoryDto;
|
import com.ruoyi.stock.mapper.StockCheckDetailMapper;
|
import com.ruoyi.stock.mapper.StockCheckMainMapper;
|
import com.ruoyi.stock.mapper.StockInventoryMapper;
|
import com.ruoyi.stock.pojo.StockCheckDetail;
|
import com.ruoyi.stock.pojo.StockCheckMain;
|
import com.ruoyi.stock.pojo.StockInventory;
|
import com.ruoyi.stock.service.StockCheckService;
|
import com.ruoyi.stock.service.StockInventoryService;
|
import lombok.RequiredArgsConstructor;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.math.BigDecimal;
|
import java.time.LocalDate;
|
import java.time.format.DateTimeFormatter;
|
import java.util.ArrayList;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Objects;
|
import java.util.stream.Collectors;
|
|
@Service
|
@RequiredArgsConstructor
|
@Transactional(rollbackFor = Exception.class)
|
public class StockCheckServiceImpl implements StockCheckService {
|
|
private final StockCheckMainMapper stockCheckMainMapper;
|
private final StockCheckDetailMapper stockCheckDetailMapper;
|
private final StockInventoryMapper stockInventoryMapper;
|
private final StockInventoryService stockInventoryService;
|
private final ProductModelMapper productModelMapper;
|
private final ProductMapper productMapper;
|
|
@Override
|
public R start(StockCheckMain main, List<Long> productModelIds) {
|
if (main.getCheckName() == null || main.getCheckName().trim().isEmpty()) {
|
throw new ServiceException("盘点名称不能为空");
|
}
|
List<StockInventory> inventories = stockInventoryMapper.selectList(
|
Wrappers.<StockInventory>lambdaQuery()
|
.in(productModelIds != null && !productModelIds.isEmpty(),
|
StockInventory::getProductModelId,
|
productModelIds == null ? List.of() : productModelIds));
|
if (inventories.isEmpty()) {
|
throw new ServiceException("没有可盘点的库存记录");
|
}
|
//同一产品规格不允许同时在两张盘点中
|
List<Long> modelIds = inventories.stream().map(StockInventory::getProductModelId)
|
.filter(Objects::nonNull).distinct().collect(Collectors.toList());
|
List<Long> pendingIds = stockCheckDetailMapper.selectList(
|
Wrappers.<StockCheckDetail>lambdaQuery()
|
.select(StockCheckDetail::getProductModelId)
|
.in(StockCheckDetail::getProductModelId, modelIds)
|
.eq(StockCheckDetail::getAdjusted, 0))
|
.stream().map(StockCheckDetail::getProductModelId).distinct().collect(Collectors.toList());
|
List<Long> conflictModelIds = new ArrayList<>();
|
if (!pendingIds.isEmpty()) {
|
List<StockCheckMain> pendingMains = stockCheckMainMapper.selectList(
|
Wrappers.<StockCheckMain>lambdaQuery()
|
.select(StockCheckMain::getId)
|
.in(StockCheckMain::getStatus, 0));
|
if (!pendingMains.isEmpty()) {
|
List<Long> pendingMainIds = pendingMains.stream().map(StockCheckMain::getId).collect(Collectors.toList());
|
conflictModelIds = stockCheckDetailMapper.selectList(
|
Wrappers.<StockCheckDetail>lambdaQuery()
|
.select(StockCheckDetail::getProductModelId)
|
.in(StockCheckDetail::getMainId, pendingMainIds)
|
.in(StockCheckDetail::getProductModelId, pendingIds))
|
.stream().map(StockCheckDetail::getProductModelId).distinct().collect(Collectors.toList());
|
}
|
}
|
if (!conflictModelIds.isEmpty()) {
|
throw new ServiceException("以下产品规格存在盘点中的单据，请先完成或取消：" + joinModels(conflictModelIds));
|
}
|
|
main.setCheckNo(generateCheckNo());
|
main.setStatus(0);
|
if (main.getCheckDate() == null) {
|
main.setCheckDate(LocalDate.now());
|
}
|
main.setTotalKinds(inventories.size());
|
main.setDiffKinds(0);
|
stockCheckMainMapper.insert(main);
|
|
Map<Long, ProductModel> modelMap = loadModels(inventories);
|
Map<Long, Product> productMap = loadProducts(modelMap.values());
|
for (StockInventory inv : inventories) {
|
StockCheckDetail detail = new StockCheckDetail();
|
detail.setMainId(main.getId());
|
detail.setInventoryId(inv.getId());
|
detail.setProductModelId(inv.getProductModelId());
|
ProductModel pm = modelMap.get(inv.getProductModelId());
|
if (pm != null) {
|
detail.setProductModel(pm.getModel());
|
detail.setUnit(pm.getUnit());
|
Product p = productMap.get(pm.getProductId());
|
if (p != null) {
|
detail.setProductName(p.getProductName());
|
}
|
}
|
detail.setBatchNo(inv.getBatchNo());
|
detail.setBookQty(inv.getQualitity());
|
detail.setAdjusted(0);
|
stockCheckDetailMapper.insert(detail);
|
}
|
return R.ok(main.getId());
|
}
|
|
@Override
|
public IPage<StockCheckMain> listPage(Page<StockCheckMain> page, StockCheckMain query) {
|
return stockCheckMainMapper.selectPage(page, Wrappers.<StockCheckMain>lambdaQuery()
|
.like(query.getCheckNo() != null && !query.getCheckNo().isEmpty(),
|
StockCheckMain::getCheckNo, query.getCheckNo())
|
.like(query.getCheckName() != null && !query.getCheckName().isEmpty(),
|
StockCheckMain::getCheckName, query.getCheckName())
|
.eq(query.getStatus() != null, StockCheckMain::getStatus, query.getStatus())
|
.ge(query.getBeginTime() != null, StockCheckMain::getCreateTime, query.getBeginTime())
|
.le(query.getEndTime() != null, StockCheckMain::getCreateTime, query.getEndTime())
|
.orderByDesc(StockCheckMain::getId));
|
}
|
|
@Override
|
public StockCheckMain getMain(Long id) {
|
StockCheckMain main = stockCheckMainMapper.selectById(id);
|
if (main == null) {
|
throw new ServiceException("盘点单不存在");
|
}
|
return main;
|
}
|
|
@Override
|
public IPage<StockCheckDetail> detailPage(Page<StockCheckDetail> page, Long mainId, Boolean onlyDiff) {
|
getMain(mainId);
|
return stockCheckDetailMapper.selectPage(page, Wrappers.<StockCheckDetail>lambdaQuery()
|
.eq(StockCheckDetail::getMainId, mainId)
|
.isNotNull(Boolean.TRUE.equals(onlyDiff), StockCheckDetail::getActualQty)
|
.apply(Boolean.TRUE.equals(onlyDiff),
|
"actual_qty is not null and ifnull(actual_qty,0) <> ifnull(book_qty,0)")
|
.orderByAsc(StockCheckDetail::getId));
|
}
|
|
@Override
|
public R entry(List<StockCheckDetail> details) {
|
if (details == null || details.isEmpty()) {
|
throw new ServiceException("请传入实盘数据");
|
}
|
for (StockCheckDetail item : details) {
|
if (item.getId() == null || item.getActualQty() == null
|
|| item.getActualQty().compareTo(BigDecimal.ZERO) < 0) {
|
throw new ServiceException("实盘数据错误：id与实盘数量(>=0)必传");
|
}
|
StockCheckDetail db = stockCheckDetailMapper.selectById(item.getId());
|
if (db == null) {
|
throw new ServiceException("盘点明细不存在，ID=" + item.getId());
|
}
|
StockCheckMain main = getMain(db.getMainId());
|
if (!Integer.valueOf(0).equals(main.getStatus())) {
|
throw new ServiceException("盘点单[" + main.getCheckNo() + "]已结束，不能再录入");
|
}
|
StockCheckDetail update = new StockCheckDetail();
|
update.setId(db.getId());
|
update.setActualQty(item.getActualQty());
|
update.setDiffQty(item.getActualQty().subtract(
|
db.getBookQty() == null ? BigDecimal.ZERO : db.getBookQty()));
|
if (item.getRemark() != null) {
|
update.setRemark(item.getRemark());
|
}
|
stockCheckDetailMapper.updateById(update);
|
}
|
return R.ok();
|
}
|
|
@Override
|
public R finish(Long id) {
|
StockCheckMain main = getMain(id);
|
if (!Integer.valueOf(0).equals(main.getStatus())) {
|
throw new ServiceException("仅盘点中的单据可以完成");
|
}
|
List<StockCheckDetail> details = stockCheckDetailMapper.selectList(
|
Wrappers.<StockCheckDetail>lambdaQuery().eq(StockCheckDetail::getMainId, id));
|
if (details.isEmpty()) {
|
throw new ServiceException("盘点明细为空");
|
}
|
List<StockCheckDetail> notEntered = details.stream()
|
.filter(d -> d.getActualQty() == null).collect(Collectors.toList());
|
if (!notEntered.isEmpty()) {
|
throw new ServiceException("还有 " + notEntered.size() + " 条明细未录入实盘数量，请先录满");
|
}
|
int diffKinds = 0;
|
int adjusted = 0;
|
for (StockCheckDetail detail : details) {
|
BigDecimal diff = detail.getDiffQty() == null ? BigDecimal.ZERO : detail.getDiffQty();
|
if (diff.compareTo(BigDecimal.ZERO) == 0) {
|
continue;
|
}
|
diffKinds++;
|
StockInventoryDto dto = new StockInventoryDto();
|
dto.setRecordId(detail.getId());
|
dto.setProductModelId(detail.getProductModelId());
|
dto.setBatchNo(detail.getBatchNo());
|
dto.setQualitity(diff.abs());
|
dto.setRemark("盘点调账 " + main.getCheckNo());
|
if (diff.compareTo(BigDecimal.ZERO) > 0) {
|
//盘盈：入库
|
dto.setRecordType(StockInQualifiedRecordTypeEnum.CUSTOMIZATION_STOCK_IN.getCode());
|
stockInventoryService.addStockInRecordOnly(dto);
|
} else {
|
//盘亏：出库（超可用库存会被出库校验拦截）
|
dto.setRecordType(StockOutQualifiedRecordTypeEnum.CUSTOMIZATION_STOCK_OUT.getCode());
|
stockInventoryService.addStockOutRecordOnly(dto);
|
}
|
StockCheckDetail update = new StockCheckDetail();
|
update.setId(detail.getId());
|
update.setAdjusted(1);
|
stockCheckDetailMapper.updateById(update);
|
adjusted++;
|
}
|
StockCheckMain update = new StockCheckMain();
|
update.setId(id);
|
update.setStatus(1);
|
update.setDiffKinds(diffKinds);
|
stockCheckMainMapper.updateById(update);
|
return R.ok("盘点完成：差异 " + diffKinds + " 条，已生成调账单据 " + adjusted
|
+ " 条（待出入库记录审核通过后账面生效）");
|
}
|
|
@Override
|
public R cancel(Long id) {
|
StockCheckMain main = getMain(id);
|
if (!Integer.valueOf(0).equals(main.getStatus())) {
|
throw new ServiceException("仅盘点中的单据可以取消");
|
}
|
StockCheckMain update = new StockCheckMain();
|
update.setId(id);
|
update.setStatus(2);
|
stockCheckMainMapper.updateById(update);
|
return R.ok();
|
}
|
|
@Override
|
public R delete(List<Long> ids) {
|
if (ids == null || ids.isEmpty()) {
|
throw new ServiceException("请选择至少一条数据");
|
}
|
stockCheckDetailMapper.delete(Wrappers.<StockCheckDetail>lambdaQuery()
|
.in(StockCheckDetail::getMainId, ids));
|
stockCheckMainMapper.deleteBatchIds(ids);
|
return R.ok();
|
}
|
|
@Override
|
public List<StockCheckDetail> diffList(Long mainId) {
|
getMain(mainId);
|
return stockCheckDetailMapper.selectList(Wrappers.<StockCheckDetail>lambdaQuery()
|
.eq(StockCheckDetail::getMainId, mainId)
|
.isNotNull(StockCheckDetail::getActualQty)
|
.apply("ifnull(actual_qty,0) <> ifnull(book_qty,0)")
|
.orderByAsc(StockCheckDetail::getId));
|
}
|
|
@Override
|
public List<StockCheckMain> listForExport(StockCheckMain query) {
|
return stockCheckMainMapper.selectList(Wrappers.<StockCheckMain>lambdaQuery()
|
.like(query != null && query.getCheckNo() != null && !query.getCheckNo().isEmpty(),
|
StockCheckMain::getCheckNo, query == null ? null : query.getCheckNo())
|
.like(query != null && query.getCheckName() != null && !query.getCheckName().isEmpty(),
|
StockCheckMain::getCheckName, query == null ? null : query.getCheckName())
|
.eq(query != null && query.getStatus() != null,
|
StockCheckMain::getStatus, query == null ? null : query.getStatus())
|
.orderByDesc(StockCheckMain::getId));
|
}
|
|
private String generateCheckNo() {
|
String prefix = "PD" + LocalDate.now().format(DateTimeFormatter.BASIC_ISO_DATE);
|
StockCheckMain latest = stockCheckMainMapper.selectOne(Wrappers.<StockCheckMain>lambdaQuery()
|
.select(StockCheckMain::getCheckNo)
|
.likeRight(StockCheckMain::getCheckNo, prefix)
|
.orderByDesc(StockCheckMain::getCheckNo)
|
.last("limit 1"), false);
|
int sequence = 1;
|
if (latest != null && latest.getCheckNo() != null && latest.getCheckNo().startsWith(prefix)) {
|
try {
|
sequence = Integer.parseInt(latest.getCheckNo().substring(prefix.length())) + 1;
|
} catch (NumberFormatException ignored) {
|
sequence = 1;
|
}
|
}
|
return prefix + String.format("%03d", sequence);
|
}
|
|
private Map<Long, ProductModel> loadModels(List<StockInventory> inventories) {
|
List<Long> ids = inventories.stream().map(StockInventory::getProductModelId)
|
.filter(Objects::nonNull).distinct().collect(Collectors.toList());
|
if (ids.isEmpty()) {
|
return new HashMap<>();
|
}
|
return productModelMapper.selectBatchIds(ids).stream()
|
.collect(Collectors.toMap(ProductModel::getId, m -> m, (a, b) -> a));
|
}
|
|
private Map<Long, Product> loadProducts(java.util.Collection<ProductModel> models) {
|
List<Long> ids = models.stream().map(ProductModel::getProductId)
|
.filter(Objects::nonNull).distinct().collect(Collectors.toList());
|
if (ids.isEmpty()) {
|
return new HashMap<>();
|
}
|
return productMapper.selectBatchIds(ids).stream()
|
.collect(Collectors.toMap(Product::getId, p -> p, (a, b) -> a));
|
}
|
|
private String joinModels(List<Long> modelIds) {
|
Map<Long, ProductModel> modelMap = productModelMapper.selectBatchIds(modelIds).stream()
|
.collect(Collectors.toMap(ProductModel::getId, m -> m, (a, b) -> a));
|
return modelIds.stream()
|
.map(id -> {
|
ProductModel pm = modelMap.get(id);
|
return pm == null || pm.getModel() == null ? String.valueOf(id) : pm.getModel();
|
})
|
.collect(Collectors.joining("、"));
|
}
|
}
|
