BruceSun
/
RuoYi-Vue
mirror of https://gitee.com/y_project/RuoYi-Vue.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

master：入库单创建抵扣需求单明细功能完善；

pull/1121/head
liujiang 2025-04-05 01:06:44 +08:00
parent 43623a8dc8
commit a3f91cedb6
15 changed files with 897 additions and 159 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

65
ruoyi-admin/src/main/java/com/ruoyi/web/controller/xkt/StoreProductStorageController.java
View File

@ -5,31 +5,21 @@ import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.core.controller.XktBaseController;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.core.page.Page;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.ruoyi.web.controller.xkt.vo.storeProd.StoreProdPageVO;
import com.ruoyi.web.controller.xkt.vo.storeProdStorage.StoreProdStoragePageVO;
import com.ruoyi.web.controller.xkt.vo.storeProdStorage.StoreProdStorageResVO;
import com.ruoyi.web.controller.xkt.vo.storeProdStorage.StoreProdStorageVO;
import com.ruoyi.xkt.domain.StoreProductStorage;
import com.ruoyi.xkt.dto.storeProdStorage.StoreProdStorageDTO;
import com.ruoyi.xkt.dto.storeProdStorage.StoreProdStoragePageDTO;
import com.ruoyi.xkt.dto.storeProdStorage.StoreProdStoragePageResDTO;
import com.ruoyi.xkt.dto.storeProdStorage.StoreProdStorageResDTO;
import com.ruoyi.xkt.dto.storeProduct.StoreProdPageDTO;
import com.ruoyi.xkt.service.IStoreProductStorageService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
/**
* 档口商品入库Controller
*
@ -44,18 +34,6 @@ public class StoreProductStorageController extends XktBaseController {
final IStoreProductStorageService storeProdStorageService;
// TODO 需求抵扣明细没做
// TODO 需求抵扣明细没做
// TODO 需求抵扣明细没做
// TODO 需求抵扣明细没做
// TODO 需求抵扣明细没做
// TODO 需求抵扣明细没做
// TODO 需求抵扣明细没做
// TODO 需求抵扣明细没做
// TODO 需求抵扣明细没做
// TODO 需求抵扣明细没做
// TODO 需求抵扣明细没做
/**
* 新增档口商品入库
*/
@ -99,47 +77,4 @@ public class StoreProductStorageController extends XktBaseController {
}
/**
* 查询档口商品入库列表
*/
@PreAuthorize("@ss.hasPermi('system:storage:list')")
@GetMapping("/list")
public TableDataInfo list(StoreProductStorage storeProductStorage) {
startPage();
List<StoreProductStorage> list = storeProdStorageService.selectStoreProductStorageList(storeProductStorage);
return getDataTable(list);
}
/**
* 导出档口商品入库列表
*/
@PreAuthorize("@ss.hasPermi('system:storage:export')")
@Log(title = "档口商品入库", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, StoreProductStorage storeProductStorage) {
List<StoreProductStorage> list = storeProdStorageService.selectStoreProductStorageList(storeProductStorage);
ExcelUtil<StoreProductStorage> util = new ExcelUtil<StoreProductStorage>(StoreProductStorage.class);
util.exportExcel(response, list, "档口商品入库数据");
}
/**
* 修改档口商品入库
*/
@PreAuthorize("@ss.hasPermi('system:storage:edit')")
@Log(title = "档口商品入库", businessType = BusinessType.UPDATE)
@PutMapping
public R edit(@RequestBody StoreProductStorage storeProductStorage) {
return success(storeProdStorageService.updateStoreProductStorage(storeProductStorage));
}
}

2
xkt/src/main/java/com/ruoyi/xkt/domain/StoreProductDemandDetail.java
View File

@ -68,7 +68,7 @@ public class StoreProductDemandDetail extends XktBaseEntity {
private Integer emergency;
/**
* 档口商品需求明细状态
* 档口商品需求明细状态 1 待生产 2 生产中 3 生产完成
*/
@Excel(name = "档口商品需求明细状态")
private Integer detailStatus;

17
xkt/src/main/java/com/ruoyi/xkt/domain/StoreProductStorageDemandDeduct.java
View File

@ -30,13 +30,13 @@ public class StoreProductStorageDemandDeduct extends XktBaseEntity {
* 档口商品入库明细ID
*/
@Excel(name = "档口商品入库明细ID")
private Long storeProdStorDetailId;
private Long storeProdStorageDetailId;
/**
* 档口商品需求ID
* 档口商品需求明细ID
*/
@Excel(name = "档口商品需求ID")
private Long storeProdDemandId;
@Excel(name = "档口商品需求明细ID")
private Long storeProdDemandDetailId;
/**
* 档口商品颜色ID
@ -153,13 +153,18 @@ public class StoreProductStorageDemandDeduct extends XktBaseEntity {
@TableField("size_43")
private Integer size43;
/**
* 备注说明
*/
private String remark;
@Override
public String toString() {
return new ToStringBuilder(this, ToStringStyle.MULTI_LINE_STYLE)
.append("id", getId())
.append("storeProdStorDetailId", getStoreProdStorDetailId())
.append("storeProdDemandId", getStoreProdDemandId())
.append("storeProdStorDetailId", getStoreProdStorageDetailId())
.append("storeProdDemandId", getStoreProdDemandDetailId())
.append("storeProdColorId", getStoreProdColorId())
.append("storeProdId", getStoreProdId())
.append("storageCode", getStorageCode())

95
xkt/src/main/java/com/ruoyi/xkt/domain/StoreProductStorageDemandDeductNew.java 100644
View File

@ -0,0 +1,95 @@
package com.ruoyi.xkt.domain;
import com.baomidou.mybatisplus.annotation.TableId;
import com.ruoyi.common.annotation.Excel;
import com.ruoyi.common.core.domain.XktBaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import org.apache.commons.lang3.builder.ToStringBuilder;
import org.apache.commons.lang3.builder.ToStringStyle;
/**
* 档口商品入库抵扣需求对象 store_product_storage_demand_deducte
*
* @author ruoyi
* @date 2025-03-26
*/
@EqualsAndHashCode(callSuper = true)
@Data
@Accessors(chain = true)
public class StoreProductStorageDemandDeductNew extends XktBaseEntity {
private static final long serialVersionUID = 1L;
/**
* 档口商品入库抵扣需求ID
*/
@TableId
private Long id;
/**
* 档口商品入库明细ID
*/
@Excel(name = "档口商品入库明细ID")
private Long storeProdStorageDetailId;
/**
* 档口商品需求明细ID
*/
@Excel(name = "档口商品需求明细ID")
private Long storeProdDemandDetailId;
/**
* 档口商品颜色ID
*/
@Excel(name = "档口商品颜色ID")
private Long storeProdColorId;
/**
* 入库code
*/
@Excel(name = "入库code")
private String storageCode;
/**
* 需求code
*/
@Excel(name = "需求code")
private String demandCode;
/**
* 总的数量
*/
private Integer quantity;
/**
* 尺码
*/
private Integer size;
/**
* 备注说明
*/
private String remark;
@Override
public String toString() {
return new ToStringBuilder(this, ToStringStyle.MULTI_LINE_STYLE)
.append("id", getId())
.append("storeProdStorDetailId", getStoreProdStorageDetailId())
.append("storeProdDemandId", getStoreProdDemandDetailId())
.append("storeProdColorId", getStoreProdColorId())
.append("storageCode", getStorageCode())
.append("demandCode", getDemandCode())
.append("size", getSize())
.append("version", getVersion())
.append("delFlag", getDelFlag())
.append("createBy", getCreateBy())
.append("createTime", getCreateTime())
.append("updateBy", getUpdateBy())
.append("updateTime", getUpdateTime())
.toString();
}
}

36
xkt/src/main/java/com/ruoyi/xkt/domain/StoreProductStorageDetail.java
View File

@ -55,6 +55,27 @@ public class StoreProductStorageDetail extends XktBaseEntity {
*/
@Excel(name = "档口商品ID")
private Long storeProdId;
/**
* 总数量
*/
@Excel(name = "总数量")
private Integer quantity;
/**
* 生产价格
*/
@Excel(name = "生产价格")
private BigDecimal producePrice;
/**
* 总的生产价格
*/
@Excel(name = "总的生产价格")
private BigDecimal produceAmount;
/**
* 抵扣状态：0.未抵扣 1.部分抵扣 2.已抵扣
*/
private Integer deductStatus;
/**
* 尺码30
*/
@ -139,21 +160,6 @@ public class StoreProductStorageDetail extends XktBaseEntity {
@Excel(name = "尺码43")
@TableField("size_43")
private Integer size43;
/**
* 总数量
*/
@Excel(name = "总数量")
private Integer quantity;
/**
* 生产价格
*/
@Excel(name = "生产价格")
private BigDecimal producePrice;
/**
* 总的生产价格
*/
@Excel(name = "总的生产价格")
private BigDecimal produceAmount;
@Override
public String toString() {

23
xkt/src/main/java/com/ruoyi/xkt/dto/storeProductDemand/StoreProdDemandSimpleDTO.java 100644
View File

@ -0,0 +1,23 @@
package com.ruoyi.xkt.dto.storeProductDemand;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Builder;
import lombok.Data;
/**
* @author liujiang
* @version v1.0
* @date 2025/3/27 15:12
*/
@ApiModel("档口商品生产需求单")
@Data
@Builder
public class StoreProdDemandSimpleDTO {
@ApiModelProperty(name = "档口需求详情ID")
private Long storeProdDemandDetailId;
@ApiModelProperty(name = "档口需求code")
private String code;
}

4
xkt/src/main/java/com/ruoyi/xkt/enums/DemandStatus.java
View File

@ -4,8 +4,8 @@ import lombok.AllArgsConstructor;
import lombok.Getter;
/**
* @author liangyq
* @date 2025-04-02 23:42
* @author 刘江
* @date 2025-04-04 23:42
*/
@Getter
@AllArgsConstructor

10
xkt/src/main/java/com/ruoyi/xkt/mapper/StoreProductDemandDetailMapper.java
View File

@ -4,6 +4,8 @@ import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.ruoyi.xkt.domain.StoreProductDemandDetail;
import com.ruoyi.xkt.dto.storeProductDemand.StoreProdDemandPageDTO;
import com.ruoyi.xkt.dto.storeProductDemand.StoreProdDemandPageResDTO;
import com.ruoyi.xkt.dto.storeProductDemand.StoreProdDemandSimpleDTO;
import org.apache.ibatis.annotations.Param;
import java.util.List;
@ -70,4 +72,12 @@ public interface StoreProductDemandDetailMapper extends BaseMapper<StoreProductD
*/
List<StoreProdDemandPageResDTO> selectDemandPage(StoreProdDemandPageDTO pageDTO);
/**
* 根据需求code查询需求单
*
* @param detailIdList 明细ID集合
* @return 需求单
*/
List<StoreProdDemandSimpleDTO> selectDemandCodeList(@Param("detailIdList") List<Long> detailIdList);
}

9
xkt/src/main/java/com/ruoyi/xkt/mapper/StoreProductDemandMapper.java
View File

@ -2,6 +2,7 @@ package com.ruoyi.xkt.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.ruoyi.xkt.domain.StoreProductDemand;
import org.apache.ibatis.annotations.Param;
import java.util.List;
@ -59,4 +60,12 @@ public interface StoreProductDemandMapper extends BaseMapper<StoreProductDemand>
* @return 结果
*/
public int deleteStoreProductDemandByStoreProdDemandIds(Long[] storeProdDemandIds);
/**
* 修改状态为已完成
*
* @param demandIdList 待更新的需求单ID列表
*/
void updateStatusByIds(@Param("demandIdList") List<Long> demandIdList);
}

14
xkt/src/main/java/com/ruoyi/xkt/mapper/StoreProductStorageDemandDeductNewMapper.java 100644
View File

@ -0,0 +1,14 @@
package com.ruoyi.xkt.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.ruoyi.xkt.domain.StoreProductStorageDemandDeductNew;
/**
* 档口商品入库抵扣需求Mapper接口
*
* @author ruoyi
* @date 2025-03-26
*/
public interface StoreProductStorageDemandDeductNewMapper extends BaseMapper<StoreProductStorageDemandDeductNew> {
}

28
xkt/src/main/java/com/ruoyi/xkt/service/IStoreProductStorageService.java
View File

@ -1,14 +1,11 @@
package com.ruoyi.xkt.service;
import com.ruoyi.common.core.page.Page;
import com.ruoyi.xkt.domain.StoreProductStorage;
import com.ruoyi.xkt.dto.storeProdStorage.StoreProdStorageDTO;
import com.ruoyi.xkt.dto.storeProdStorage.StoreProdStoragePageDTO;
import com.ruoyi.xkt.dto.storeProdStorage.StoreProdStoragePageResDTO;
import com.ruoyi.xkt.dto.storeProdStorage.StoreProdStorageResDTO;
import java.util.List;
/**
* 档口商品入库Service接口
*
@ -16,6 +13,7 @@ import java.util.List;
* @date 2025-03-26
*/
public interface IStoreProductStorageService {
/**
* 查询档口商品入库
*
@ -24,14 +22,6 @@ public interface IStoreProductStorageService {
*/
public StoreProdStorageResDTO selectByStoreProdStorId(Long storeProdStorId);
/**
* 查询档口商品入库列表
*
* @param storeProductStorage 档口商品入库
* @return 档口商品入库集合
*/
public List<StoreProductStorage> selectStoreProductStorageList(StoreProductStorage storeProductStorage);
/**
* 新增档口商品入库
*
@ -40,13 +30,6 @@ public interface IStoreProductStorageService {
*/
public int create(StoreProdStorageDTO storeProdStorageDTO);
/**
* 修改档口商品入库
*
* @param storeProductStorage 档口商品入库
* @return 结果
*/
public int updateStoreProductStorage(StoreProductStorage storeProductStorage);
/**
* 撤销档口商品入库
@ -56,16 +39,9 @@ public interface IStoreProductStorageService {
*/
public int deleteByStoreProdStorId(Long storeProdStorId);
/**
* 删除档口商品入库信息
*
* @param storeProdStorId 档口商品入库主键
* @return 结果
*/
public int deleteStoreProductStorageByStoreProdStorId(Long storeProdStorId);
/**
* 分页查询
*
* @param storagePageDTO 查询入参
* @return Page
*/

4
xkt/src/main/java/com/ruoyi/xkt/service/impl/StoreProductDemandServiceImpl.java
View File

@ -169,10 +169,10 @@ public class StoreProductDemandServiceImpl implements IStoreProductDemandService
List<Long> demandDetailIdList = demandList.stream().map(StoreProdDemandPageResDTO::getStoreProdDemandDetailId).distinct().collect(Collectors.toList());
// 找到需求单抵扣的数据
List<StoreProductStorageDemandDeduct> deductList = this.storageDemandDeductMapper.selectList(new LambdaQueryWrapper<StoreProductStorageDemandDeduct>()
.in(StoreProductStorageDemandDeduct::getStoreProdStorDetailId, demandDetailIdList).eq(StoreProductStorageDemandDeduct::getDelFlag, "0"));
.in(StoreProductStorageDemandDeduct::getStoreProdStorageDetailId, demandDetailIdList).eq(StoreProductStorageDemandDeduct::getDelFlag, "0"));
// 明细抵扣的数量
Map<Long, Integer> deductQuantityMap = CollectionUtils.isEmpty(deductList) ? new HashMap<>()
: deductList.stream().collect(Collectors.groupingBy(StoreProductStorageDemandDeduct::getStoreProdStorDetailId, Collectors.summingInt(StoreProductStorageDemandDeduct::getQuantity)));
: deductList.stream().collect(Collectors.groupingBy(StoreProductStorageDemandDeduct::getStoreProdStorageDetailId, Collectors.summingInt(StoreProductStorageDemandDeduct::getQuantity)));
// 更新需求列表中的每个项，设置库存数量和生产中数量
demandList.forEach(x -> {
final Integer deductQuantity = deductQuantityMap.getOrDefault(x.getStoreProdDemandDetailId(), 0);

718
xkt/src/main/java/com/ruoyi/xkt/service/impl/StoreProductStorageServiceImpl.java
View File

@ -4,33 +4,36 @@ import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.ruoyi.common.constant.Constants;
import com.ruoyi.common.constant.HttpStatus;
import com.ruoyi.common.core.domain.model.LoginUser;
import com.ruoyi.common.core.page.Page;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.xkt.domain.StoreProductDemandDetail;
import com.ruoyi.xkt.domain.StoreProductStorage;
import com.ruoyi.xkt.domain.StoreProductStorageDemandDeductNew;
import com.ruoyi.xkt.domain.StoreProductStorageDetail;
import com.ruoyi.xkt.dto.storeProdStorage.StoreProdStorageDTO;
import com.ruoyi.xkt.dto.storeProdStorage.StoreProdStoragePageDTO;
import com.ruoyi.xkt.dto.storeProdStorage.StoreProdStoragePageResDTO;
import com.ruoyi.xkt.dto.storeProdStorage.StoreProdStorageResDTO;
import com.ruoyi.xkt.dto.storeProductDemand.StoreProdDemandSimpleDTO;
import com.ruoyi.xkt.dto.storeProductStock.StoreProdStockDTO;
import com.ruoyi.xkt.mapper.StoreProductStorageDetailMapper;
import com.ruoyi.xkt.mapper.StoreProductStorageMapper;
import com.ruoyi.xkt.mapper.*;
import com.ruoyi.xkt.service.IStoreProductStockService;
import com.ruoyi.xkt.service.IStoreProductStorageService;
import com.ruoyi.xkt.service.IVoucherSequenceService;
import lombok.RequiredArgsConstructor;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.MapUtils;
import org.apache.commons.lang3.ObjectUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.math.BigDecimal;
import java.util.Date;
import java.util.List;
import java.util.Optional;
import java.util.*;
import java.util.stream.Collectors;
/**
@ -47,6 +50,10 @@ public class StoreProductStorageServiceImpl implements IStoreProductStorageServi
final StoreProductStorageDetailMapper storageDetailMapper;
final IVoucherSequenceService sequenceService;
final IStoreProductStockService stockService;
final StoreProductDemandDetailMapper demandDetailMapper;
final StoreProductDemandMapper demandMapper;
final StoreProductStorageDemandDeductMapper deductMapper;
final StoreProductStorageDemandDeductNewMapper deductNewMapper;
/**
@ -85,13 +92,358 @@ public class StoreProductStorageServiceImpl implements IStoreProductStorageServi
.setCode(code).setQuantity(totalNum).setProduceAmount(produceAmount).setOperatorId(loginUser.getUserId()).setOperatorName(loginUser.getUsername());
int count = this.storageMapper.insert(storeProdStorage);
// 新增档口商品入库明细
List<StoreProductStorageDetail> detailList = storeProdStorageDTO.getDetailList().stream().map(x -> BeanUtil.toBean(x, StoreProductStorageDetail.class)
List<StoreProductStorageDetail> detailList = storeProdStorageDTO.getDetailList().stream().map(x -> BeanUtil.toBean(x, StoreProductStorageDetail.class)
.setStoreProdStorId(storeProdStorage.getId())).collect(Collectors.toList());
this.storageDetailMapper.insert(detailList);
// 构造增加库存的入参DTO
List<StoreProdStockDTO> increaseStockList = BeanUtil.copyToList(detailList, StoreProdStockDTO.class);
// 增加档口商品的库存
this.stockService.increaseStock(storeProdStorageDTO.getStoreId(), increaseStockList);
// 根据明细列表找到所有提交的需求
List<StoreProductDemandDetail> demandDetailList = this.demandDetailMapper.selectList(new LambdaQueryWrapper<StoreProductDemandDetail>()
.eq(StoreProductDemandDetail::getStoreId, storeProdStorageDTO.getStoreId()).eq(StoreProductDemandDetail::getDelFlag, "0")
.in(StoreProductDemandDetail::getDetailStatus, Arrays.asList(1, 2))
.in(StoreProductDemandDetail::getStoreProdColorId, detailList.stream().map(StoreProductStorageDetail::getStoreProdColorId).collect(Collectors.toList())));
// 若没有任何需求则不抵扣，直接结束流程
if (CollectionUtils.isEmpty(demandDetailList)) {
return count;
}
// 所有的需求单ID列表
final List<Long> demandIdList = demandDetailList.stream().map(StoreProductDemandDetail::getStoreProdDemandId).distinct().collect(Collectors.toList());
List<StoreProductStorageDemandDeductNew> deductedNewList = this.deductNewMapper.selectList(new LambdaQueryWrapper<StoreProductStorageDemandDeductNew>()
.in(StoreProductStorageDemandDeductNew::getStoreProdColorId, detailList.stream().map(StoreProductStorageDetail::getStoreProdColorId).collect(Collectors.toList()))
.eq(StoreProductStorageDemandDeductNew::getDelFlag, "0"));
// 已存在的需求抵扣明细列表
Map<Long, Map<Integer, Integer>> deductedExistsMap = deductedNewList.stream().collect(Collectors.groupingBy(StoreProductStorageDemandDeductNew::getStoreProdColorId,
Collectors.groupingBy(StoreProductStorageDemandDeductNew::getSize, Collectors.summingInt(x -> ObjectUtils.defaultIfNull(x.getQuantity(), 0)))));
// 按照需求的storeProdColorId进行分组，再按照：1.生产中（2）、待生产（1） 排序 2. 再按照需求创建时间升序排列
Map<Long, List<StoreProductDemandDetail>> tempDemandDetailMap = demandDetailList.stream().collect(Collectors
.groupingBy(StoreProductDemandDetail::getStoreProdColorId, Collectors
.collectingAndThen(Collectors.toList(), tempList -> tempList.stream()
.sorted(Comparator.comparing(StoreProductDemandDetail::getDetailStatus).reversed()
.thenComparing(StoreProductDemandDetail::getCreateTime)).collect(Collectors.toList()))));
// 所有颜色尺码需要抵扣的需求数量
Map<Long, Map<Integer, Map<Long, Integer>>> unDeductMap = new LinkedHashMap<>();
tempDemandDetailMap.forEach((storeProdColorId, tempDemandDetailList) -> {
// 已存在抵扣的数量
Map<Integer, Integer> sizeDeductedMap = ObjectUtils.defaultIfNull(deductedExistsMap.get(storeProdColorId), new LinkedHashMap<>());
// 尺码为30的已抵扣需求数量
Integer size30Deduct = ObjectUtils.defaultIfNull(sizeDeductedMap.get(30), 0);
Integer size31Deduct = ObjectUtils.defaultIfNull(sizeDeductedMap.get(31), 0);
Integer size32Deduct = ObjectUtils.defaultIfNull(sizeDeductedMap.get(32), 0);
Integer size33Deduct = ObjectUtils.defaultIfNull(sizeDeductedMap.get(33), 0);
Integer size34Deduct = ObjectUtils.defaultIfNull(sizeDeductedMap.get(34), 0);
Integer size35Deduct = ObjectUtils.defaultIfNull(sizeDeductedMap.get(35), 0);
Integer size36Deduct = ObjectUtils.defaultIfNull(sizeDeductedMap.get(36), 0);
Integer size37Deduct = ObjectUtils.defaultIfNull(sizeDeductedMap.get(37), 0);
Integer size38Deduct = ObjectUtils.defaultIfNull(sizeDeductedMap.get(38), 0);
Integer size39Deduct = ObjectUtils.defaultIfNull(sizeDeductedMap.get(39), 0);
Integer size40Deduct = ObjectUtils.defaultIfNull(sizeDeductedMap.get(40), 0);
Integer size41Deduct = ObjectUtils.defaultIfNull(sizeDeductedMap.get(41), 0);
Integer size42Deduct = ObjectUtils.defaultIfNull(sizeDeductedMap.get(42), 0);
Integer size43Deduct = ObjectUtils.defaultIfNull(sizeDeductedMap.get(43), 0);
Map<Long, Integer> size30DemandMap = new LinkedHashMap<>();
Map<Long, Integer> size31DemandMap = new LinkedHashMap<>();
Map<Long, Integer> size32DemandMap = new LinkedHashMap<>();
Map<Long, Integer> size33DemandMap = new LinkedHashMap<>();
Map<Long, Integer> size34DemandMap = new LinkedHashMap<>();
Map<Long, Integer> size35DemandMap = new LinkedHashMap<>();
Map<Long, Integer> size36DemandMap = new LinkedHashMap<>();
Map<Long, Integer> size37DemandMap = new LinkedHashMap<>();
Map<Long, Integer> size38DemandMap = new LinkedHashMap<>();
Map<Long, Integer> size39DemandMap = new LinkedHashMap<>();
Map<Long, Integer> size40DemandMap = new LinkedHashMap<>();
Map<Long, Integer> size41DemandMap = new LinkedHashMap<>();
Map<Long, Integer> size42DemandMap = new LinkedHashMap<>();
Map<Long, Integer> size43DemandMap = new LinkedHashMap<>();
// 不同size仍需抵扣的数量
Map<Integer, Map<Long, Integer>> sizeRequireMap = new LinkedHashMap<>();
// 依次计算各尺码的需求数量
for (StoreProductDemandDetail demandDetail : tempDemandDetailList) {
size30Deduct = this.handleSize30RequireQuantity(size30Deduct, size30DemandMap, demandDetail);
size31Deduct = this.handleSize31RequireQuantity(size31Deduct, size31DemandMap, demandDetail);
size32Deduct = this.handleSize32RequireQuantity(size32Deduct, size32DemandMap, demandDetail);
size33Deduct = this.handleSize33RequireQuantity(size33Deduct, size33DemandMap, demandDetail);
size34Deduct = this.handleSize34RequireQuantity(size34Deduct, size34DemandMap, demandDetail);
size35Deduct = this.handleSize35RequireQuantity(size35Deduct, size35DemandMap, demandDetail);
size36Deduct = this.handleSize36RequireQuantity(size36Deduct, size36DemandMap, demandDetail);
size37Deduct = this.handleSize37RequireQuantity(size37Deduct, size37DemandMap, demandDetail);
size38Deduct = this.handleSize38RequireQuantity(size38Deduct, size38DemandMap, demandDetail);
size39Deduct = this.handleSize39RequireQuantity(size39Deduct, size39DemandMap, demandDetail);
size40Deduct = this.handleSize40RequireQuantity(size40Deduct, size40DemandMap, demandDetail);
size41Deduct = this.handleSize41RequireQuantity(size41Deduct, size41DemandMap, demandDetail);
size42Deduct = this.handleSize42RequireQuantity(size42Deduct, size42DemandMap, demandDetail);
size43Deduct = this.handleSize43RequireQuantity(size43Deduct, size43DemandMap, demandDetail);
}
if (MapUtils.isNotEmpty(size30DemandMap)) {
sizeRequireMap.put(30, size30DemandMap);
}
if (MapUtils.isNotEmpty(size31DemandMap)) {
sizeRequireMap.put(31, size31DemandMap);
}
if (MapUtils.isNotEmpty(size32DemandMap)) {
sizeRequireMap.put(32, size32DemandMap);
}
if (MapUtils.isNotEmpty(size33DemandMap)) {
sizeRequireMap.put(33, size33DemandMap);
}
if (MapUtils.isNotEmpty(size34DemandMap)) {
sizeRequireMap.put(34, size34DemandMap);
}
if (MapUtils.isNotEmpty(size35DemandMap)) {
sizeRequireMap.put(35, size35DemandMap);
}
if (MapUtils.isNotEmpty(size36DemandMap)) {
sizeRequireMap.put(36, size36DemandMap);
}
if (MapUtils.isNotEmpty(size37DemandMap)) {
sizeRequireMap.put(37, size37DemandMap);
}
if (MapUtils.isNotEmpty(size38DemandMap)) {
sizeRequireMap.put(38, size38DemandMap);
}
if (MapUtils.isNotEmpty(size39DemandMap)) {
sizeRequireMap.put(39, size39DemandMap);
}
if (MapUtils.isNotEmpty(size40DemandMap)) {
sizeRequireMap.put(40, size40DemandMap);
}
if (MapUtils.isNotEmpty(size41DemandMap)) {
sizeRequireMap.put(41, size41DemandMap);
}
if (MapUtils.isNotEmpty(size42DemandMap)) {
sizeRequireMap.put(42, size42DemandMap);
}
if (MapUtils.isNotEmpty(size43DemandMap)) {
sizeRequireMap.put(43, size43DemandMap);
}
if (MapUtils.isNotEmpty(sizeRequireMap)) {
unDeductMap.put(storeProdColorId, sizeRequireMap);
}
});
// 按照入库明细列表依次进行需求数量扣减
Map<Long, Map<Long, Map<Integer, Integer>>> storageQuantityMap = new LinkedHashMap<>();
for (StoreProductStorageDetail storageDetail : detailList) {
Map<Integer, Integer> sizeStorageMap = new LinkedHashMap<>();
if (ObjectUtils.isNotEmpty(storageDetail.getSize30())) {
sizeStorageMap.put(30, storageDetail.getSize30());
}
if (ObjectUtils.isNotEmpty(storageDetail.getSize31())) {
sizeStorageMap.put(31, storageDetail.getSize31());
}
if (ObjectUtils.isNotEmpty(storageDetail.getSize32())) {
sizeStorageMap.put(32, storageDetail.getSize32());
}
if (ObjectUtils.isNotEmpty(storageDetail.getSize33())) {
sizeStorageMap.put(33, storageDetail.getSize33());
}
if (ObjectUtils.isNotEmpty(storageDetail.getSize34())) {
sizeStorageMap.put(34, storageDetail.getSize34());
}
if (ObjectUtils.isNotEmpty(storageDetail.getSize35())) {
sizeStorageMap.put(35, storageDetail.getSize35());
}
if (ObjectUtils.isNotEmpty(storageDetail.getSize36())) {
sizeStorageMap.put(36, storageDetail.getSize36());
}
if (ObjectUtils.isNotEmpty(storageDetail.getSize37())) {
sizeStorageMap.put(37, storageDetail.getSize37());
}
if (ObjectUtils.isNotEmpty(storageDetail.getSize38())) {
sizeStorageMap.put(38, storageDetail.getSize38());
}
if (ObjectUtils.isNotEmpty(storageDetail.getSize39())) {
sizeStorageMap.put(39, storageDetail.getSize39());
}
if (ObjectUtils.isNotEmpty(storageDetail.getSize40())) {
sizeStorageMap.put(40, storageDetail.getSize40());
}
if (ObjectUtils.isNotEmpty(storageDetail.getSize41())) {
sizeStorageMap.put(41, storageDetail.getSize41());
}
if (ObjectUtils.isNotEmpty(storageDetail.getSize42())) {
sizeStorageMap.put(42, storageDetail.getSize42());
}
if (ObjectUtils.isNotEmpty(storageDetail.getSize43())) {
sizeStorageMap.put(43, storageDetail.getSize43());
}
if (MapUtils.isNotEmpty(sizeStorageMap)) {
storageQuantityMap.put(storageDetail.getStoreProdColorId(), new LinkedHashMap<Long, Map<Integer, Integer>>(){{
put(storageDetail.getId(), sizeStorageMap);
}});
}
}
// 按照入库的数量明细依次判断哪些需求订单明细还未抵扣完毕
Map<Long, Map<Long, Map<Integer, Map<Long, Integer>>>> totalMatchMap = new LinkedHashMap<>();
storageQuantityMap.forEach((storeProdColorId, detailSizeStorageMap) -> {
Map<Integer, Map<Long, Integer>> sizeRequireMap = unDeductMap.get(storeProdColorId);
if (MapUtils.isEmpty(sizeRequireMap) || MapUtils.isEmpty(detailSizeStorageMap)) {
return;
}
Map<Long, Map<Integer, Map<Long, Integer>>> storageDetailIdSizeMatchMap = new LinkedHashMap<>();
// 匹配的尺码集合
detailSizeStorageMap.forEach((storageDetailId, sizeStorageMap) -> {
if (MapUtils.isEmpty(sizeStorageMap)) {
return;
}
Map<Integer, Map<Long, Integer>> sizeMatchMap = new LinkedHashMap<>();
// 遍历每个入库单明细尺码
sizeStorageMap.forEach((size, storageQuantity) -> {
Map<Long, Integer> requireMap = sizeRequireMap.get(size);
if (MapUtils.isEmpty(requireMap)) {
return;
}
// key storeProductDemandDetailId； value matchQuantity
Map<Long, Integer> itemMatchMap = new LinkedHashMap<>();
// 遍历每个需求订单
for (Map.Entry<Long, Integer> entry : requireMap.entrySet()) {
// 尺码的入库数量 + 当前尺码的需求明细数量
final int tempCompareQuantity = storageQuantity + entry.getValue();
if (tempCompareQuantity == 0) {
continue;
}
if (tempCompareQuantity > 0) {
// value 取绝对值
itemMatchMap.put(entry.getKey(), Math.abs(entry.getValue()));
storageQuantity = tempCompareQuantity;
} else {
// value 取绝对值
itemMatchMap.put(entry.getKey(), Math.abs(storageQuantity));
break;
}
}
// 本次入库单明细可抵扣的需求单明细ID及数量
if (MapUtils.isNotEmpty(itemMatchMap)) {
sizeMatchMap.put(size, itemMatchMap);
}
});
if (MapUtils.isNotEmpty(sizeMatchMap)) {
storageDetailIdSizeMatchMap.put(storageDetailId, sizeMatchMap);
}
});
if (MapUtils.isNotEmpty(storageDetailIdSizeMatchMap)) {
totalMatchMap.put(storeProdColorId, storageDetailIdSizeMatchMap);
}
});
System.err.println(totalMatchMap);
if (MapUtils.isEmpty(totalMatchMap)) {
return count;
}
List<StoreProdDemandSimpleDTO> demandSimpleList = Optional.ofNullable(this.demandDetailMapper.selectDemandCodeList(demandDetailList.stream()
.map(StoreProductDemandDetail::getId).distinct().collect(Collectors.toList())))
.orElseThrow(() -> new ServiceException("获取需求单号失败", HttpStatus.ERROR));
// demandDetailId 与 demandCode 的映射关系
Map<Long, String> demandCodeMap = demandSimpleList.stream().collect(Collectors.toMap(StoreProdDemandSimpleDTO::getStoreProdDemandDetailId, StoreProdDemandSimpleDTO::getCode));
List<StoreProductStorageDemandDeductNew> deductList = new ArrayList<>();
// 待更新的需求单明细ID列表
List<Long> updateDetailIdList = new ArrayList<>();
totalMatchMap.forEach((storeProdColorId, detailSizeStorageMap) -> {
detailSizeStorageMap.forEach((storageDetailId, sizeMatchMap) -> {
sizeMatchMap.forEach((size, itemMatchMap) -> {
itemMatchMap.forEach((storeProductDemandDetailId, matchQuantity) -> {
StoreProductStorageDemandDeductNew deductNew = new StoreProductStorageDemandDeductNew();
deductNew.setStoreProdColorId(storeProdColorId)
.setStoreProdDemandDetailId(storeProductDemandDetailId)
.setStoreProdStorageDetailId(storageDetailId)
.setStorageCode(storeProdStorage.getCode())
.setDemandCode(demandCodeMap.get(storeProductDemandDetailId))
.setSize(size)
.setQuantity(matchQuantity)
.setDelFlag(Constants.UNDELETED);
updateDetailIdList.add(storeProductDemandDetailId);
deductList.add(deductNew);
});
});
});
});
this.deductNewMapper.insert(deductList);
List<StoreProductStorageDemandDeductNew> listAfterInsert = this.deductNewMapper.selectList(new LambdaQueryWrapper<StoreProductStorageDemandDeductNew>()
.eq(StoreProductStorageDemandDeductNew::getDelFlag, "0").in(StoreProductStorageDemandDeductNew::getStoreProdDemandDetailId, updateDetailIdList));
if (CollectionUtils.isEmpty(listAfterInsert)) {
return count;
}
Map<Long, List<StoreProductStorageDemandDeductNew>> latestDeductMap = listAfterInsert.stream().collect(Collectors.groupingBy(StoreProductStorageDemandDeductNew::getStoreProdDemandDetailId));
Map<Long, Map<Integer, Integer>> latestDeductSizeQuantityMap = new LinkedHashMap<>();
latestDeductMap.forEach((storeProdDemandDetailId, latestDeductList) -> {
Map<Integer, Integer> sizeQuantityMap = new LinkedHashMap<>();
Integer size30Quantity = latestDeductList.stream().filter(x -> x.getSize() == 30).map(x -> ObjectUtils.defaultIfNull(x.getQuantity(), 0)).reduce(0, Integer::sum);
sizeQuantityMap.put(30, size30Quantity);
Integer size31Quantity = latestDeductList.stream().filter(x -> x.getSize() == 31).map(x -> ObjectUtils.defaultIfNull(x.getQuantity(), 0)).reduce(0, Integer::sum);
sizeQuantityMap.put(31, size31Quantity);
Integer size32Quantity = latestDeductList.stream().filter(x -> x.getSize() == 32).map(x -> ObjectUtils.defaultIfNull(x.getQuantity(), 0)).reduce(0, Integer::sum);
sizeQuantityMap.put(32, size32Quantity);
Integer size33Quantity = latestDeductList.stream().filter(x -> x.getSize() == 33).map(x -> ObjectUtils.defaultIfNull(x.getQuantity(), 0)).reduce(0, Integer::sum);
sizeQuantityMap.put(33, size33Quantity);
Integer size34Quantity = latestDeductList.stream().filter(x -> x.getSize() == 34).map(x -> ObjectUtils.defaultIfNull(x.getQuantity(), 0)).reduce(0, Integer::sum);
sizeQuantityMap.put(34, size34Quantity);
Integer size35Quantity = latestDeductList.stream().filter(x -> x.getSize() == 35).map(x -> ObjectUtils.defaultIfNull(x.getQuantity(), 0)).reduce(0, Integer::sum);
sizeQuantityMap.put(35, size35Quantity);
Integer size36Quantity = latestDeductList.stream().filter(x -> x.getSize() == 36).map(x -> ObjectUtils.defaultIfNull(x.getQuantity(), 0)).reduce(0, Integer::sum);
sizeQuantityMap.put(36, size36Quantity);
Integer size37Quantity = latestDeductList.stream().filter(x -> x.getSize() == 37).map(x -> ObjectUtils.defaultIfNull(x.getQuantity(), 0)).reduce(0, Integer::sum);
sizeQuantityMap.put(37, size37Quantity);
Integer size38Quantity = latestDeductList.stream().filter(x -> x.getSize() == 38).map(x -> ObjectUtils.defaultIfNull(x.getQuantity(), 0)).reduce(0, Integer::sum);
sizeQuantityMap.put(38, size38Quantity);
Integer size39Quantity = latestDeductList.stream().filter(x -> x.getSize() == 39).map(x -> ObjectUtils.defaultIfNull(x.getQuantity(), 0)).reduce(0, Integer::sum);
sizeQuantityMap.put(39, size39Quantity);
Integer size40Quantity = latestDeductList.stream().filter(x -> x.getSize() == 40).map(x -> ObjectUtils.defaultIfNull(x.getQuantity(), 0)).reduce(0, Integer::sum);
sizeQuantityMap.put(40, size40Quantity);
Integer size41Quantity = latestDeductList.stream().filter(x -> x.getSize() == 41).map(x -> ObjectUtils.defaultIfNull(x.getQuantity(), 0)).reduce(0, Integer::sum);
sizeQuantityMap.put(41, size41Quantity);
Integer size42Quantity = latestDeductList.stream().filter(x -> x.getSize() == 42).map(x -> ObjectUtils.defaultIfNull(x.getQuantity(), 0)).reduce(0, Integer::sum);
sizeQuantityMap.put(42, size42Quantity);
Integer size43Quantity = latestDeductList.stream().filter(x -> x.getSize() == 43).map(x -> ObjectUtils.defaultIfNull(x.getQuantity(), 0)).reduce(0, Integer::sum);
sizeQuantityMap.put(43, size43Quantity);
latestDeductSizeQuantityMap.put(storeProdDemandDetailId, sizeQuantityMap);
});
// 筛选出所有和本次需求单抵扣有关的需求单列表
List<StoreProductDemandDetail> updateDemandDetailList = Optional.ofNullable(this.demandDetailMapper.selectList(new LambdaQueryWrapper<StoreProductDemandDetail>()
.in(StoreProductDemandDetail::getStoreProdDemandId, demandIdList).eq(StoreProductDemandDetail::getDelFlag, "0")))
.orElseThrow(() -> new ServiceException("获取需求单明细失败", HttpStatus.ERROR));
// 依次对比需求单明细不同size的完成数量，并更新需求单明细的detailStatus
List<StoreProductDemandDetail> demandDetailListAfterUpdate = updateDemandDetailList.stream().map(updateDetail -> {
Map<Integer, Integer> latestSizeQuantityMap = latestDeductSizeQuantityMap.get(updateDetail.getId());
if (MapUtils.isEmpty(latestSizeQuantityMap)) {
return updateDetail;
}
Boolean size30Finish = ObjectUtils.defaultIfNull(latestSizeQuantityMap.get(30), 0) >= ObjectUtils.defaultIfNull(updateDetail.getSize30(), 0);
Boolean size31Finish = ObjectUtils.defaultIfNull(latestSizeQuantityMap.get(31), 0) >= ObjectUtils.defaultIfNull(updateDetail.getSize31(), 0);
Boolean size32Finish = ObjectUtils.defaultIfNull(latestSizeQuantityMap.get(32), 0) >= ObjectUtils.defaultIfNull(updateDetail.getSize32(), 0);
Boolean size33Finish = ObjectUtils.defaultIfNull(latestSizeQuantityMap.get(33), 0) >= ObjectUtils.defaultIfNull(updateDetail.getSize33(), 0);
Boolean size34Finish = ObjectUtils.defaultIfNull(latestSizeQuantityMap.get(34), 0) >= ObjectUtils.defaultIfNull(updateDetail.getSize34(), 0);
Boolean size35Finish = ObjectUtils.defaultIfNull(latestSizeQuantityMap.get(35), 0) >= ObjectUtils.defaultIfNull(updateDetail.getSize35(), 0);
Boolean size36Finish = ObjectUtils.defaultIfNull(latestSizeQuantityMap.get(36), 0) >= ObjectUtils.defaultIfNull(updateDetail.getSize36(), 0);
Boolean size37Finish = ObjectUtils.defaultIfNull(latestSizeQuantityMap.get(37), 0) >= ObjectUtils.defaultIfNull(updateDetail.getSize37(), 0);
Boolean size38Finish = ObjectUtils.defaultIfNull(latestSizeQuantityMap.get(38), 0) >= ObjectUtils.defaultIfNull(updateDetail.getSize38(), 0);
Boolean size39Finish = ObjectUtils.defaultIfNull(latestSizeQuantityMap.get(39), 0) >= ObjectUtils.defaultIfNull(updateDetail.getSize39(), 0);
Boolean size40Finish = ObjectUtils.defaultIfNull(latestSizeQuantityMap.get(40), 0) >= ObjectUtils.defaultIfNull(updateDetail.getSize40(), 0);
Boolean size41Finish = ObjectUtils.defaultIfNull(latestSizeQuantityMap.get(41), 0) >= ObjectUtils.defaultIfNull(updateDetail.getSize41(), 0);
Boolean size42Finish = ObjectUtils.defaultIfNull(latestSizeQuantityMap.get(42), 0) >= ObjectUtils.defaultIfNull(updateDetail.getSize42(), 0);
Boolean size43Finish = ObjectUtils.defaultIfNull(latestSizeQuantityMap.get(43), 0) >= ObjectUtils.defaultIfNull(updateDetail.getSize43(), 0);
if (size30Finish && size31Finish && size32Finish && size33Finish && size34Finish && size35Finish && size36Finish && size37Finish && size38Finish
&& size39Finish && size40Finish && size41Finish && size42Finish && size43Finish) {
updateDetail.setDetailStatus(3);
}
return updateDetail;
}).collect(Collectors.toList());
this.demandDetailMapper.updateById(demandDetailListAfterUpdate);
Map<Long, List<StoreProductDemandDetail>> demandGroupMap = updateDemandDetailList.stream().collect(Collectors.groupingBy(StoreProductDemandDetail::getStoreProdDemandId));
List<Long> demandIdListAfterUpdate = new ArrayList<>();
demandGroupMap.forEach((demandId, tempDetailList) -> {
if (tempDetailList.stream().allMatch(x -> x.getDetailStatus() == 3)) {
demandIdListAfterUpdate.add(demandId);
}
});
if (CollectionUtils.isNotEmpty(demandIdListAfterUpdate)) {
this.demandMapper.updateStatusByIds(demandIdListAfterUpdate);
}
return count;
}
@ -108,7 +460,7 @@ public class StoreProductStorageServiceImpl implements IStoreProductStorageServi
public StoreProdStorageResDTO selectByStoreProdStorId(Long storeProdStorId) {
// 档口商品入库
StoreProductStorage storage = Optional.ofNullable(this.storageMapper.selectOne(new LambdaQueryWrapper<StoreProductStorage>()
.eq(StoreProductStorage::getId, storeProdStorId).eq(StoreProductStorage::getDelFlag, "0")))
.eq(StoreProductStorage::getId, storeProdStorId).eq(StoreProductStorage::getDelFlag, "0")))
.orElseThrow(() -> new ServiceException("档口商品入库不存在!", HttpStatus.ERROR));
// 档口商品入库明细
List<StoreProductStorageDetail> storageDetailList = storageDetailMapper.selectList(new LambdaQueryWrapper<StoreProductStorageDetail>()
@ -117,17 +469,6 @@ public class StoreProductStorageServiceImpl implements IStoreProductStorageServi
.setDetailList(storageDetailList.stream().map(x -> BeanUtil.toBean(x, StoreProdStorageResDTO.StorageDetailDTO.class)).collect(Collectors.toList()));
}
/**
* 查询档口商品入库列表
*
* @param storeProductStorage 档口商品入库
* @return 档口商品入库
*/
@Override
@Transactional(readOnly = true)
public List<StoreProductStorage> selectStoreProductStorageList(StoreProductStorage storeProductStorage) {
return storageMapper.selectStoreProductStorageList(storeProductStorage);
}
/**
* 撤销档口商品入库
@ -143,48 +484,341 @@ public class StoreProductStorageServiceImpl implements IStoreProductStorageServi
.eq(StoreProductStorage::getId, storeProdStorId).eq(StoreProductStorage::getDelFlag, "0")))
.orElseThrow(() -> new ServiceException("档口商品入库不存在!", HttpStatus.ERROR));
storage.setDelFlag("2");
int count = this.storageMapper.updateById(storage);
int count = this.storageMapper.updateById(storage);
// 档口商品入库明细
List<StoreProductStorageDetail> storageDetailList = storageDetailMapper.selectList(new LambdaQueryWrapper<StoreProductStorageDetail>()
.eq(StoreProductStorageDetail::getStoreProdStorId, storeProdStorId).eq(StoreProductStorageDetail::getDelFlag, "0"));
storageDetailList.forEach(x -> x.setDelFlag("2"));
this.storageDetailMapper.updateById(storageDetailList);
// 减少档口商品库存
// 减少档口商品库存
this.stockService.decreaseStock(storage.getStoreId(), storageDetailList.stream()
.map(x -> BeanUtil.toBean(x, StoreProdStockDTO.class)).collect(Collectors.toList()));
return count;
}
private Integer handleSize43RequireQuantity(Integer size43Deduct, Map<Long, Integer> size43DemandMap, StoreProductDemandDetail demandDetail) {
final Integer size43Demand = ObjectUtils.defaultIfNull(demandDetail.getSize43(), 0);
if (size43Deduct < 0) {
if (size43Demand != 0) {
size43DemandMap.put(demandDetail.getId(), size43Demand * -1);
}
} else {
// 临时结果
final int tempSize43Deduct = size43Deduct - size43Demand;
if (tempSize43Deduct < 0) {
size43DemandMap.put(demandDetail.getId(), tempSize43Deduct);
}
size43Deduct = tempSize43Deduct;
}
return size43Deduct;
}
private Integer handleSize42RequireQuantity(Integer size42Deduct, Map<Long, Integer> size42DemandMap, StoreProductDemandDetail demandDetail) {
final Integer size42Demand = ObjectUtils.defaultIfNull(demandDetail.getSize42(), 0);
if (size42Deduct < 0) {
if (size42Demand != 0) {
size42DemandMap.put(demandDetail.getId(), size42Demand * -1);
}
} else {
// 临时结果
final int tempSize42Deduct = size42Deduct - size42Demand;
if (tempSize42Deduct < 0) {
size42DemandMap.put(demandDetail.getId(), tempSize42Deduct);
}
size42Deduct = tempSize42Deduct;
}
return size42Deduct;
}
private Integer handleSize41RequireQuantity(Integer size41Deduct, Map<Long, Integer> size41DemandMap, StoreProductDemandDetail demandDetail) {
final Integer size41Demand = ObjectUtils.defaultIfNull(demandDetail.getSize41(), 0);
if (size41Deduct < 0) {
if (size41Demand != 0) {
size41DemandMap.put(demandDetail.getId(), size41Demand * -1);
}
} else {
// 临时结果
final int tempSize41Deduct = size41Deduct - size41Demand;
if (tempSize41Deduct < 0) {
size41DemandMap.put(demandDetail.getId(), tempSize41Deduct);
}
size41Deduct = tempSize41Deduct;
}
return size41Deduct;
}
/**
* 修改档口商品入库
*
* @param storeProductStorage 档口商品入库
* @return 结果
*/
@Override
@Transactional
public int updateStoreProductStorage(StoreProductStorage storeProductStorage) {
storeProductStorage.setUpdateTime(DateUtils.getNowDate());
return storageMapper.updateStoreProductStorage(storeProductStorage);
private Integer handleSize40RequireQuantity(Integer size40Deduct, Map<Long, Integer> size40DemandMap, StoreProductDemandDetail demandDetail) {
final Integer size40Demand = ObjectUtils.defaultIfNull(demandDetail.getSize40(), 0);
if (size40Deduct < 0) {
if (size40Demand != 0) {
size40DemandMap.put(demandDetail.getId(), size40Demand * -1);
}
} else {
// 临时结果
final int tempSize40Deduct = size40Deduct - size40Demand;
if (tempSize40Deduct < 0) {
size40DemandMap.put(demandDetail.getId(), tempSize40Deduct);
}
size40Deduct = tempSize40Deduct;
}
return size40Deduct;
}
private Integer handleSize39RequireQuantity(Integer size39Deduct, Map<Long, Integer> size39DemandMap, StoreProductDemandDetail demandDetail) {
final Integer size39Demand = ObjectUtils.defaultIfNull(demandDetail.getSize39(), 0);
if (size39Deduct < 0) {
if (size39Demand != 0) {
size39DemandMap.put(demandDetail.getId(), size39Demand * -1);
}
} else {
// 临时结果
final int tempSize39Deduct = size39Deduct - size39Demand;
if (tempSize39Deduct < 0) {
size39DemandMap.put(demandDetail.getId(), tempSize39Deduct);
}
size39Deduct = tempSize39Deduct;
}
return size39Deduct;
}
private Integer handleSize38RequireQuantity(Integer size38Deduct, Map<Long, Integer> size38DemandMap, StoreProductDemandDetail demandDetail) {
final Integer size38Demand = ObjectUtils.defaultIfNull(demandDetail.getSize38(), 0);
if (size38Deduct < 0) {
if (size38Demand != 0) {
size38DemandMap.put(demandDetail.getId(), size38Demand * -1);
}
} else {
// 临时结果
final int tempSize38Deduct = size38Deduct - size38Demand;
if (tempSize38Deduct < 0) {
size38DemandMap.put(demandDetail.getId(), tempSize38Deduct);
}
size38Deduct = tempSize38Deduct;
}
return size38Deduct;
}
private Integer handleSize37RequireQuantity(Integer size37Deduct, Map<Long, Integer> size37DemandMap, StoreProductDemandDetail demandDetail) {
final Integer size37Demand = ObjectUtils.defaultIfNull(demandDetail.getSize37(), 0);
if (size37Deduct < 0) {
if (size37Demand != 0) {
size37DemandMap.put(demandDetail.getId(), size37Demand * -1);
}
} else {
// 临时结果
final int tempSize37Deduct = size37Deduct - size37Demand;
if (tempSize37Deduct < 0) {
size37DemandMap.put(demandDetail.getId(), tempSize37Deduct);
}
size37Deduct = tempSize37Deduct;
}
return size37Deduct;
}
private Integer handleSize36RequireQuantity(Integer size36Deduct, Map<Long, Integer> size36DemandMap, StoreProductDemandDetail demandDetail) {
final Integer size36Demand = ObjectUtils.defaultIfNull(demandDetail.getSize36(), 0);
if (size36Deduct < 0) {
if (size36Demand != 0) {
size36DemandMap.put(demandDetail.getId(), size36Demand * -1);
}
} else {
// 临时结果
final int tempSize36Deduct = size36Deduct - size36Demand;
if (tempSize36Deduct < 0) {
size36DemandMap.put(demandDetail.getId(), tempSize36Deduct);
}
size36Deduct = tempSize36Deduct;
}
return size36Deduct;
}
private Integer handleSize35RequireQuantity(Integer size35Deduct, Map<Long, Integer> size35DemandMap, StoreProductDemandDetail demandDetail) {
final Integer size35Demand = ObjectUtils.defaultIfNull(demandDetail.getSize35(), 0);
if (size35Deduct < 0) {
if (size35Demand != 0) {
size35DemandMap.put(demandDetail.getId(), size35Demand * -1);
}
} else {
// 临时结果
final int tempSize35Deduct = size35Deduct - size35Demand;
if (tempSize35Deduct < 0) {
size35DemandMap.put(demandDetail.getId(), tempSize35Deduct);
}
size35Deduct = tempSize35Deduct;
}
return size35Deduct;
}
private Integer handleSize34RequireQuantity(Integer size34Deduct, Map<Long, Integer> size34DemandMap, StoreProductDemandDetail demandDetail) {
final Integer size34Demand = ObjectUtils.defaultIfNull(demandDetail.getSize34(), 0);
if (size34Deduct < 0) {
if (size34Demand != 0) {
size34DemandMap.put(demandDetail.getId(), size34Demand * -1);
}
} else {
// 临时结果
final int tempSize34Deduct = size34Deduct - size34Demand;
if (tempSize34Deduct < 0) {
size34DemandMap.put(demandDetail.getId(), tempSize34Deduct);
}
size34Deduct = tempSize34Deduct;
}
return size34Deduct;
}
private Integer handleSize33RequireQuantity(Integer size33Deduct, Map<Long, Integer> size33DemandMap, StoreProductDemandDetail demandDetail) {
final Integer size33Demand = ObjectUtils.defaultIfNull(demandDetail.getSize33(), 0);
if (size33Deduct < 0) {
if (size33Demand != 0) {
size33DemandMap.put(demandDetail.getId(), size33Demand * -1);
}
} else {
// 临时结果
final int tempSize33Deduct = size33Deduct - size33Demand;
if (tempSize33Deduct < 0) {
size33DemandMap.put(demandDetail.getId(), tempSize33Deduct);
}
size33Deduct = tempSize33Deduct;
}
return size33Deduct;
}
private Integer handleSize32RequireQuantity(Integer size32Deduct, Map<Long, Integer> size32DemandMap, StoreProductDemandDetail demandDetail) {
final Integer size32Demand = ObjectUtils.defaultIfNull(demandDetail.getSize32(), 0);
if (size32Deduct < 0) {
if (size32Demand != 0) {
size32DemandMap.put(demandDetail.getId(), size32Demand * -1);
}
} else {
// 临时结果
final int tempSize32Deduct = size32Deduct - size32Demand;
if (tempSize32Deduct < 0) {
size32DemandMap.put(demandDetail.getId(), tempSize32Deduct);
}
size32Deduct = tempSize32Deduct;
}
return size32Deduct;
}
private Integer handleSize31RequireQuantity(Integer size31Deduct, Map<Long, Integer> size31DemandMap, StoreProductDemandDetail demandDetail) {
final Integer size31Demand = ObjectUtils.defaultIfNull(demandDetail.getSize31(), 0);
if (size31Deduct < 0) {
if (size31Demand != 0) {
size31DemandMap.put(demandDetail.getId(), size31Demand * -1);
}
} else {
// 临时结果
final int tempSize31Deduct = size31Deduct - size31Demand;
if (tempSize31Deduct < 0) {
size31DemandMap.put(demandDetail.getId(), tempSize31Deduct);
}
size31Deduct = tempSize31Deduct;
}
return size31Deduct;
}
private Integer handleSize30RequireQuantity(Integer size30Deduct, Map<Long, Integer> size30DemandMap, StoreProductDemandDetail demandDetail) {
final Integer size30Demand = ObjectUtils.defaultIfNull(demandDetail.getSize30(), 0);
if (size30Deduct < 0) {
if (size30Demand != 0) {
size30DemandMap.put(demandDetail.getId(), size30Demand * -1);
}
} else {
// 临时结果
final int tempSize30Deduct = size30Deduct - size30Demand;
if (tempSize30Deduct < 0) {
size30DemandMap.put(demandDetail.getId(), tempSize30Deduct);
}
size30Deduct = tempSize30Deduct;
}
return size30Deduct;
}
/* // 找到入库需求抵扣明细中间表，查看哪些是已经抵扣了的
List<StoreProductStorageDemandDeduct> deductedList = this.deductMapper.selectList(new LambdaQueryWrapper<StoreProductStorageDemandDeduct>()
.in(StoreProductStorageDemandDeduct::getStoreProdDemandDetailId, detailList.stream().map(StoreProductStorageDetail::getId).collect(Collectors.toList())));
Map<Long, List<StoreProductStorageDemandDeduct>> deductedQuantityMap = deductedList.stream().collect(Collectors.groupingBy(StoreProductStorageDemandDeduct::getStoreProdDemandDetailId));
// 存货每一个货品颜色，不同尺码已抵扣数量
Map<Long, Map<Integer, Integer>> deductedDetailMap = new HashMap<>();
deductedQuantityMap.forEach((prodColorId, deductList) -> {
Map<Integer, Integer> sizeDeductedMap = new HashMap<>();
Integer size30Quantity = deductList.stream().map(StoreProductStorageDemandDeduct::getSize30).filter(size30 -> ObjectUtils.defaultIfNull(size30, 0) > 0).reduce(0, Integer::sum);
sizeDeductedMap.put(30, size30Quantity);
Integer size31Quantity = deductList.stream().map(StoreProductStorageDemandDeduct::getSize31).filter(size31 -> ObjectUtils.defaultIfNull(size31, 0) > 0).reduce(0, Integer::sum);
sizeDeductedMap.put(31, size31Quantity);
Integer size32Quantity = deductList.stream().map(StoreProductStorageDemandDeduct::getSize32).filter(size32 -> ObjectUtils.defaultIfNull(size32, 0) > 0).reduce(0, Integer::sum);
sizeDeductedMap.put(32, size32Quantity);
Integer size33Quantity = deductList.stream().map(StoreProductStorageDemandDeduct::getSize33).filter(size33 -> ObjectUtils.defaultIfNull(size33, 0) > 0).reduce(0, Integer::sum);
sizeDeductedMap.put(33, size33Quantity);
Integer size34Quantity = deductList.stream().map(StoreProductStorageDemandDeduct::getSize34).filter(size34 -> ObjectUtils.defaultIfNull(size34, 0) > 0).reduce(0, Integer::sum);
sizeDeductedMap.put(34, size34Quantity);
Integer size35Quantity = deductList.stream().map(StoreProductStorageDemandDeduct::getSize35).filter(size35 -> ObjectUtils.defaultIfNull(size35, 0) > 0).reduce(0, Integer::sum);
sizeDeductedMap.put(35, size35Quantity);
Integer size36Quantity = deductList.stream().map(StoreProductStorageDemandDeduct::getSize36).filter(size36 -> ObjectUtils.defaultIfNull(size36, 0) > 0).reduce(0, Integer::sum);
sizeDeductedMap.put(36, size36Quantity);
Integer size37Quantity = deductList.stream().map(StoreProductStorageDemandDeduct::getSize37).filter(size37 -> ObjectUtils.defaultIfNull(size37, 0) > 0).reduce(0, Integer::sum);
sizeDeductedMap.put(37, size37Quantity);
Integer size38Quantity = deductList.stream().map(StoreProductStorageDemandDeduct::getSize38).filter(size38 -> ObjectUtils.defaultIfNull(size38, 0) > 0).reduce(0, Integer::sum);
sizeDeductedMap.put(38, size38Quantity);
Integer size39Quantity = deductList.stream().map(StoreProductStorageDemandDeduct::getSize39).filter(size39 -> ObjectUtils.defaultIfNull(size39, 0) > 0).reduce(0, Integer::sum);
sizeDeductedMap.put(39, size39Quantity);
Integer size40Quantity = deductList.stream().map(StoreProductStorageDemandDeduct::getSize40).filter(size40 -> ObjectUtils.defaultIfNull(size40, 0) > 0).reduce(0, Integer::sum);
sizeDeductedMap.put(40, size40Quantity);
Integer size41Quantity = deductList.stream().map(StoreProductStorageDemandDeduct::getSize41).filter(size41 -> ObjectUtils.defaultIfNull(size41, 0) > 0).reduce(0, Integer::sum);
sizeDeductedMap.put(41, size41Quantity);
Integer size42Quantity = deductList.stream().map(StoreProductStorageDemandDeduct::getSize42).filter(size42 -> ObjectUtils.defaultIfNull(size42, 0) > 0).reduce(0, Integer::sum);
sizeDeductedMap.put(42, size42Quantity);
Integer size43Quantity = deductList.stream().map(StoreProductStorageDemandDeduct::getSize43).filter(size43 -> ObjectUtils.defaultIfNull(size43, 0) > 0).reduce(0, Integer::sum);
sizeDeductedMap.put(43, size43Quantity);
deductedDetailMap.put(prodColorId, sizeDeductedMap);
});
*/
/**
* 删除档口商品入库信息
*
* @param storeProdStorId 档口商品入库主键
* @return 结果
*/
@Override
@Transactional
public int deleteStoreProductStorageByStoreProdStorId(Long storeProdStorId) {
return storageMapper.deleteStoreProductStorageByStoreProdStorId(storeProdStorId);
}
/*
// 拷贝一份需求明细列表，避免修改原集合，避免数据污染
List<StoreProductDemandDetail> copyDemandDetailList = new ArrayList<>(demandDetailList);
// 如果有档口生产需求订单，则直接抵扣
Map<Long, List<StoreProductDemandDetail>> demandDetailMap = copyDemandDetailList.stream().collect(Collectors.groupingBy(StoreProductDemandDetail::getStoreProdColorId));
// 先按照需求明细的每个尺码处理，将入库的数据插入到抵扣需求明细表中，然后再将需求的对应的中间表数据筛选出来，依次对比需求单明细的状态，如果状态都为: 3 生产完成，则更新生产需求单 整体状态
// 拷贝一份入库明细列表，避免修改原集合，避免数据污染
List<StoreProductStorageDetail> tempCopyList = new ArrayList<>(detailList);
List<StoreProductStorageDemandDeduct> targetList = new ArrayList<>();
tempCopyList.forEach(storageDetail -> {
List<StoreProductDemandDetail> targetDemandList = demandDetailMap.get(storageDetail.getStoreProdColorId());
if (CollectionUtils.isEmpty(targetDemandList)) {
return;
}
// 抵扣规则：1.优先按照：生产中（2）、待生产（1） 排序 2. 再按照需求创建时间升序排列
targetDemandList = targetDemandList.stream().sorted(Comparator.comparing(StoreProductDemandDetail::getDetailStatus).reversed()
.thenComparing(StoreProductDemandDetail::getCreateTime)).collect(Collectors.toList());
// 可能存在需求单没抵扣完，抵扣了部分，这个如何提现出来？？？？
// 可能出现的情况 生产数量小于需求数量 生产数量等于需求数量 生产数量大于需求数量
// 依次抵扣需求单数量，如果还有多的则继续抵扣，如果没有则结束循环
// 还要更改需求单的需求状态
});*/
}

16
xkt/src/main/resources/mapper/StoreProductDemandDetailMapper.xml
View File

@ -201,4 +201,20 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
</select>
<select id="selectDemandCodeList" resultType="com.ruoyi.xkt.dto.storeProductDemand.StoreProdDemandSimpleDTO">
SELECT
spdd.id AS storeProdDemandDetailId,
spd.`code`
FROM
store_product_demand_detail spdd JOIN store_product_demand spd ON spdd.store_prod_demand_id = spd.id
WHERE
spdd.del_flag = 0
<if test="detailIdList != null and detailIdList.size > 0">
AND spdd.id IN
<foreach item="id" collection="detailIdList" open="(" separator="," close=")">
#{id}
</foreach>
</if>
</select>
</mapper>

15
xkt/src/main/resources/mapper/StoreProductDemandMapper.xml
View File

@ -83,4 +83,19 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
#{id}
</foreach>
</delete>
<update id="updateStatusByIds">
UPDATE
store_product_demand SET demand_status = 3, update_time = NOW()
WHERE
del_flag = 0
<if test="demandIdList != null and demandIdList.size > 0">
AND id IN
<foreach collection="demandIdList" item="id" open="(" separator="," close=")">
#{id}
</foreach>
</if>
</update>
</mapper>