iboss-server-mdm/src/main/java/com/dk/mdm/service/ivt/outbound/OutboundSaleOrderService.java

package com.dk.mdm.service.ivt.outbound;

import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.dk.common.exception.BaseBusinessException;
import com.dk.common.infrastructure.annotaiton.Pagination;
import com.dk.common.infrastructure.constant.Constant;
import com.dk.common.infrastructure.enums.ErrorCodeEnum;
import com.dk.common.mapper.BaseMapper;
import com.dk.common.model.pojo.PageList;
import com.dk.common.response.ResponseCodeEnum;
import com.dk.common.response.ResponseResultUtil;
import com.dk.common.response.ResponseResultVO;
import com.dk.common.service.BaseService;
import com.dk.mdm.infrastructure.convert.ivt.InboundConvert;
import com.dk.mdm.infrastructure.convert.ivt.InboundItemConvert;
import com.dk.mdm.infrastructure.convert.ivt.OutboundConvert;
import com.dk.mdm.infrastructure.convert.ivt.OutboundItemConvert;
import com.dk.mdm.mapper.common.CommonMapper;
import com.dk.mdm.mapper.ivt.*;
import com.dk.mdm.mapper.sale.OrderItemMapper;
import com.dk.mdm.mapper.sale.OrderMapper;
import com.dk.mdm.model.pojo.ivt.Inbound;
import com.dk.mdm.model.pojo.ivt.InboundItem;
import com.dk.mdm.model.pojo.ivt.Outbound;
import com.dk.mdm.model.pojo.ivt.OutboundItem;
import com.dk.mdm.model.pojo.sale.Order;
import com.dk.mdm.model.pojo.sale.OrderItem;
import com.dk.mdm.model.query.ivt.InventoryQuery;
import com.dk.mdm.model.query.ivt.OutboundItemQuery;
import com.dk.mdm.model.query.ivt.OutboundQuery;
import com.dk.mdm.model.response.ivt.InboundResponse;
import com.dk.mdm.model.response.ivt.InventoryResponse;
import com.dk.mdm.model.response.ivt.OutboundItemResponse;
import com.dk.mdm.model.response.ivt.OutboundResponse;
import com.dk.mdm.model.response.sale.OrderItemResponse;
import com.dk.mdm.model.response.sale.OrderResponse;
import com.dk.mdm.model.vo.ivt.InboundItemVO;
import com.dk.mdm.model.vo.ivt.InboundVO;
import com.dk.mdm.model.vo.ivt.OutboundItemVO;
import com.dk.mdm.model.vo.ivt.OutboundVO;
import com.dk.mdm.service.common.CommonService;
import com.dk.mdm.service.ivt.inventory.InventoryService;
import com.dk.mdm.service.mac.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.LocalDate;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.stream.Collectors;


/**
 * @author : 寇珊珊
 * @desc : 销售出库业务层
 * @date : 2024/3/18 15:33
 */
@Service
public class OutboundSaleOrderService extends BaseService<Outbound> {

    @Override
    public BaseMapper<Outbound> getRepository() {
        return outboundMapper;
    }

    @Autowired
    private CommonService commonService;

    @Autowired
    private OutboundMapper outboundMapper;

    @Autowired
    private OutboundConvert outboundConvert;

    @Autowired
    private OutboundItemMapper outboundItemMapper;

    @Autowired
    private OutboundItemConvert outboundItemConvert;

    @Autowired
    private OrderMapper orderMapper;

    @Autowired
    private OrderItemMapper orderItemMapper;

    @Autowired
    private CommonMapper commonMapper;

    @Autowired
    private InventoryService inventoryService;

    @Autowired
    private AccountService accountService;

    @Autowired
    private OutCommon outCommon;

    @Autowired
    private InboundMapper inboundMapper;

    @Autowired
    private InboundConvert inboundConvert;

    @Autowired
    private InboundItemMapper inboundItemMapper;

    @Autowired
    private InboundItemConvert inboundItemConvert;

    @Autowired
    private InventoryMapper inventoryMapper;


    /*****************************************先判断库存*****************************************/


    /**
     * @desc : 校验库存是否存在
     * @date : 2024/6/11 10:55
     * @author : 寇珊珊
     */
    @Transactional(
            rollbackFor = {Exception.class}
    )
    public InventoryResponse checkInventoryExist(OutboundItemVO outboundItemVO) {
        //存在标识
        //根据sku，仓库，非标号查询
        InventoryResponse inventoryResponse = null;
        if (outboundItemVO.getSkuId() != null) {
            inventoryResponse = inventoryMapper.selectByOther(new InventoryQuery()
                    .setSkuId(outboundItemVO.getSkuId())
                    .setWhId(outboundItemVO.getWhId())
                    .setNonStdCode(outboundItemVO.getNonStdCode()));
        }
        return inventoryResponse;
    }

    /**
     * @desc : 先查库存后出库
     * @date : 2024/6/11 9:30
     * @author : 寇珊珊
     */
    @Transactional(rollbackFor = {Exception.class})
    public void inventoryOUtBond(OutboundVO outboundVO) {
        //region 校验明细
        if (outboundVO.getItemList().size() == 0) {
            throw new BaseBusinessException(ErrorCodeEnum.OUTBOUND_ITEM_NOT_EXIST.getCode(),
                    ErrorCodeEnum.OUTBOUND_ITEM_NOT_EXIST.getMessage());
        }
        //endregion
        //可以负库存  不用交验库存直接走负库存逻辑
        if (outboundVO.getFlgHandleSetting()) {
            for (OutboundItemVO outboundItemVO : outboundVO.getItemList()) {
                //可以输入负数出库标识
                outboundItemVO.setCanNegativeFlag(true);
                //业务部门Id
                outboundItemVO.setOrgId(outboundVO.getOrgId());
                //业务员Id
                outboundItemVO.setStaffId(outboundVO.getStaffId());
                //制单员Id
                outboundItemVO.setMakeStaff(outboundVO.getMakeStaff());
            }
            //销售出库新建
            this.saleOrderOutboundInsert(outboundVO, true);
        }
        //先查库存锁表看能出库的数量有多少   可出库数量建一张已出库的单子并扣减库存，剩下的数量建一张出库中的单子
        else {
            //过滤外协品
            for (OutboundItemVO outboundItemVO : outboundVO.getItemList()) {
                //商品id不为空才校验库存    因为为空是外协品
                if (outboundItemVO.getSkuId() != null) {
                    //查询库存是否存在
                    InventoryResponse inventoryResponse = this.checkInventoryExist(outboundItemVO);
                    if (inventoryResponse != null) {
                        BigDecimal invQty = inventoryResponse.getInvQty().subtract(outboundItemVO.getOutingQty());
                        // (库存量  大于等于  本次出库数量不用做任何处理)
                        //库存量 小于  本次出库数量
                        if (invQty.compareTo(BigDecimal.ZERO) < 0) {
                            outboundItemVO.setOutingQty(inventoryResponse.getInvQty());
                            //不够库存数量----新建出库中数量
                            outboundItemVO.setNotEnoughInventoryQty(invQty.abs());
                        }
                    } else {
                        //不够库存数量----新建出库中数量
                        outboundItemVO.setNotEnoughInventoryQty(outboundItemVO.getOutingQty());
                    }
                }
            }
            //过滤出库存量足够的数据
            List<OutboundItemVO> itemList = outboundVO.getItemList().stream().filter(it -> it.getNotEnoughInventoryQty() == null).collect(Collectors.toList());

            //region  过滤出不够出库的每条明细数量  ------新建出库中数据
            List<OutboundItemVO> outboundIngList = outboundVO.getItemList().stream().filter(it -> it.getNotEnoughInventoryQty() != null && it.getNotEnoughInventoryQty().compareTo(BigDecimal.ZERO) > 0).collect(Collectors.toList());
            if (outboundIngList != null && outboundIngList.size() > 0) {
                //赋值箱片
                for (OutboundItemVO outboundItemVO : outboundIngList) {
                    //箱
                    outboundItemVO.setOutingBox(Integer.valueOf(outboundItemVO.getOutingQty().divide(outboundItemVO.getPackBox(), 0, RoundingMode.DOWN).toString()));
                    //片
                    outboundItemVO.setOutingPiece(outboundItemVO.getOutingQty().remainder(outboundItemVO.getPackBox()));
                }
                outboundVO.setFlgAutoHandle(false);
                outboundVO.setItemList(outboundIngList);
                //销售出库新建
                this.saleOrderOutboundInsert(outboundVO, true);
            }
            //endregion

            //region  库存够扣减的明细  -----------新建已出库数据并扣减库存
            //销售出库新建
            if (itemList != null && itemList.size() > 0) {
                for (OutboundItemVO outboundItemVO : itemList) {
                    if (outboundItemVO.getSkuId() != null) { //过滤外协品 外协品没有箱片
                        //箱
                        outboundItemVO.setOutBox(Integer.valueOf(outboundItemVO.getOutingQty().divide(outboundItemVO.getPackBox(), 0, RoundingMode.DOWN).toString()));
                        //片
                        outboundItemVO.setOutPiece(outboundItemVO.getOutingQty().remainder(outboundItemVO.getPackBox()));
                    }
                }
                outboundVO.setFlgAutoHandle(true);
                outboundVO.setItemList(itemList);
                this.saleOrderOutboundInsert(outboundVO, true);
            }
            //endregion

        }
    }
    /*****************************************先判断库存*****************************************/

    /**
     * @desc : 删除外协品生产外协入库单
     * @date : 2024/5/10 10:31
     * @author : 寇珊珊
     */
    @Transactional(rollbackFor = {Exception.class})
    public void deleteOutsideGoodsInto(OutboundVO outboundVO, List<OutboundItemVO> outboundItemVOList) {
        if (outboundItemVOList != null && outboundItemVOList.size() > 0) {
            //根据出库单id分组
            Map<String, List<OutboundItemVO>> outboundItemVOMap = outboundItemVOList.stream().collect(Collectors.groupingBy(OutboundItemVO::getOutId));
            for (String str : outboundItemVOMap.keySet()) {
                InboundResponse inboundResponse = inboundMapper.selectByFromId(str);
                // 退账
                if (inboundResponse != null && inboundResponse.getReceivableId() != null) {
                    accountService.reversePayable(inboundResponse.getIntoId(), Constant.InventoryDocCode.INTOBOUND.getTableName());
                }
            }
            //删除外协入库单
            //外协入库总单
            inboundMapper.deleteByFromId(outboundItemVOList.get(0).getOutId());
            //外协入库明细
            inboundItemMapper.deleteItemByFromId(outboundItemVOList.get(0).getOutId());
        }

    }

    /**
     * @desc : 新建外协品生产外协入库单
     * @date : 2024/5/10 10:31
     * @author : 寇珊珊
     */
    @Transactional(rollbackFor = {Exception.class})
    public void insertOutsideGoodsInto(OutboundVO outboundVO, List<OutboundItemVO> outboundItemVOList) {
        if (outboundItemVOList != null && outboundItemVOList.size() > 0) {
            Map<String, List<OutboundItemVO>> outboundItemVOMap = outboundItemVOList.stream().collect(Collectors.groupingBy(OutboundItemVO::getOutId));
            for (String str : outboundItemVOMap.keySet()) {
                //提取分组后的明细
                List<OutboundItemVO> outboundItemVOListGroup = outboundItemVOMap.get(str);

                //region  新建总单
                //已入库金额
                BigDecimal sumIntoAmt = outboundItemVOListGroup.stream().map(OutboundItemVO::getOutAmt).reduce(BigDecimal.ZERO, BigDecimal::add).setScale(2, BigDecimal.ROUND_HALF_UP);
                //已入库数量
                BigDecimal sumIntoQty = outboundItemVOListGroup.stream().map(OutboundItemVO::getOutQty).reduce(BigDecimal.ZERO, BigDecimal::add).setScale(2, BigDecimal.ROUND_HALF_UP);
                //总单实体
                InboundVO inboundVO = new InboundVO();
                //获取 id/单号
                Map<String, Object> codeMap = commonService.getUniqueNoteCode(Constant.docNameConstant.OUTSOURCED.getName(), false);
                inboundVO.setIntoId(codeMap.get("outId").toString()).
                        setIntoNo(codeMap.get("outNote").toString());
                //入库类型
                inboundVO.setIntoType(Constant.IntoType.OUTSOURCED.getName());
                //已入库
                inboundVO.setIntoStatus(Constant.IntoStatus.YIRUKU.getName());
                //供应商
                inboundVO.setSupId(outboundItemVOListGroup.get(0).getSupId());
                //入库状态等于已入库
                inboundVO.setIntoQty(sumIntoQty)
                        .setIntoAmt(sumIntoAmt)
                        .setIntoingQty(BigDecimal.ZERO)
                        .setIntoingAmt(BigDecimal.ZERO);
                //来源id
                inboundVO.setFromId(outboundItemVOListGroup.get(0).getFromId());
                //来源单号
                inboundVO.setFromNo(outboundVO.getOutNo());
                //部门
                inboundVO.setOrgId(outboundVO.getOrgId());
                //员工
                inboundVO.setStaffId(outboundVO.getStaffId());
                //入库日期
                inboundVO.setIntoDate(LocalDate.now());
                //制单人
                inboundVO.setMakeStaff(outboundVO.getMakeStaff());
                //公司
                inboundVO.setCpId(outboundVO.getCpId());
                // 来源Id
                inboundVO.setFromId(outboundVO.getFromId());
                inboundVO.setFromNo(outboundVO.getFromNo());
                //实体转换
                Inbound inbound = inboundConvert.convertToPo(inboundVO);
                inboundMapper.insert(inbound);
                //endregion

                //region 明细
                Integer count = 0;
                for (OutboundItemVO outboundItemVO : outboundItemVOListGroup) {
                    InboundItemVO inboundItemVO = new InboundItemVO();
                    //总单id
                    inboundItemVO.setIntoId(inboundVO.getIntoId());
                    //入库类型
                    inboundItemVO.setIntoType(inboundVO.getIntoType());
                    //入库状态等于已入库 更新合计入库数量/金额 = 入库中数量/入库中金额
                    BigDecimal costAmount = outboundItemVO.getOutQty().multiply(outboundItemVO.getPriceOut()).setScale(2, BigDecimal.ROUND_HALF_UP);
                    inboundItemVO
                            .setFromId(outboundItemVO.getFromId())
                            .setFromItemId(outboundItemVO.getFromItemId())
                            .setPriceInto(outboundItemVO.getPriceOut())
                            .setIntoQty(outboundItemVO.getOutQty())
                            .setIntoAmt(outboundItemVO.getOutAmt())
                            .setIntoAmt(costAmount)
                            .setIntoingQty(BigDecimal.ZERO)
                            .setIntoingAmt(BigDecimal.ZERO)
                            .setCostPrice(outboundItemVO.getPriceOut())
                            .setCostAmt(costAmount)
                    ;
                    //入库状态
                    inboundItemVO.setIntoStatus(inboundVO.getIntoStatus());
                    //商品顺序
                    inboundItemVO.setItemIndex(count);
                    //箱（入库中）
                    inboundItemVO.setIntoingBox(outboundItemVO.getOutingBox());
                    //片（入库中）
                    inboundItemVO.setIntoingPiece(outboundItemVO.getOutingPiece());
                    //箱（已入库）
                    inboundItemVO.setIntoBox(outboundItemVO.getOutBox());
                    //片（已入库）
                    inboundItemVO.setIntoPiece(outboundItemVO.getOutPiece());
                    //入库仓库
                    inboundItemVO.setWhId(outboundItemVO.getWhId());
                    //企业ID
                    inboundItemVO.setCpId(outboundItemVO.getCpId());
                    // 商品
                    inboundItemVO.setSkuModel(outboundItemVO.getSkuModel());
                    inboundItemVO.setSkuName(outboundItemVO.getSkuName());
                    // 来源Id
                    //实体转换
                    InboundItem inboundItem = inboundItemConvert.convertToPo(inboundItemVO);
                    inboundItemMapper.insert(inboundItem);
                    //用来填写商品顺序
                    count++;
                    inboundItemVO.setItemId(inboundItem.getItemId());
                }
                //endregion

                //region 入账
                accountService.accPayable(inboundVO.getIntoId(), Constant.InventoryDocCode.INTOBOUND.getTableName());
                //endregion
            }
        }
    }

    /**
     * @desc : 销售出库新建
     * orderTransmitFlag :订单传递过来的
     * @date : 2024/3/7 14:13
     * @author : 寇珊珊
     */
    @Transactional(rollbackFor = {Exception.class})
    public ResponseResultVO<?> saleOrderOutboundInsert(OutboundVO outboundVO, Boolean orderTransmitFlag) {

        //region 如果没有客户id，要新建
//        outboundVO = outCommon.insertCustomer(outboundVO);
        //endregion

        //region 查询当前公司的系统参数  自动办理信息  并赋值
        if (!orderTransmitFlag) {
            Map<String, Object> map = new HashMap<>();
            map.put("cpId", outboundVO.getCpId());
            map.put("code", Constant.SystemConstant.IVT_001.getValue());
            //自动办理标识
            String flgHandleSetting = commonMapper.getSettingValue(map);
            //自动办理标识为1 自动办理入库
            if (Constant.FlgAutoHandleStringType.ONE.getValue().equals(flgHandleSetting)) {
                outboundVO.setFlgHandleSetting(Constant.FlgHandleSetting.TRUE.getValue());
                outboundVO.setFlgAutoHandle(Constant.FlgAutoHandle.TRUE.getValue());
            }
        }
        //endregion

        //region  总单
        //出库数量
        BigDecimal sumIntoQty = BigDecimal.ZERO;
        //出库金额
        BigDecimal sumIntoPriceAmt = BigDecimal.ZERO;
        if (orderTransmitFlag) {
            sumIntoQty = outboundVO.getItemList().stream().map(OutboundItemVO::getOutingQty).reduce(BigDecimal.ZERO, BigDecimal::add).setScale(2, BigDecimal.ROUND_HALF_UP);
            sumIntoPriceAmt = outboundVO.getItemList().stream().map(OutboundItemVO::getFactAmt).reduce(BigDecimal.ZERO, BigDecimal::add).setScale(2, BigDecimal.ROUND_HALF_UP);
      }
        //获取 id/单号
        Map<String, Object> codeMap = commonService.getUniqueNoteCode(Constant.docNameConstant.SALEORDER.getName(), false);
        outboundVO.setOutId(codeMap.get("outId").toString()).
                setOutNo(codeMap.get("outNote").toString());
        //出库类型
        outboundVO.setOutType(Constant.OutType.SALE.getName()).setOutDate(LocalDate.now());
        //自动入库标识
        if (outboundVO.getFlgAutoHandle()) {
            //已出库
            outboundVO.setOutStatus(Constant.OutStatus.YICHUKU.getName());
        } else {
            //出库中
            outboundVO.setOutStatus(Constant.OutStatus.CHUKUZHONG.getName());
        }
        //出库状态等于已出库 更新合计出库数量/金额 = 出库中数量/出库中金额
        if (Constant.OutStatus.YICHUKU.getName().equals(outboundVO.getOutStatus())) {
            outboundVO
                    .setOutQty(orderTransmitFlag ? sumIntoQty : outboundVO.getOutingQty())
                    .setOutAmt(orderTransmitFlag ? sumIntoPriceAmt : outboundVO.getOutingAmt())
                    .setOutingQty(BigDecimal.ZERO)
                    .setOutingAmt(BigDecimal.ZERO)
            ;
        } else {
            outboundVO
                    .setOutQty(BigDecimal.ZERO)
                    .setOutAmt(BigDecimal.ZERO)
                    //用于销售订单自动创建出库单
                    .setOutingQty(orderTransmitFlag ? sumIntoQty : outboundVO.getOutingQty())
                    .setOutingAmt(orderTransmitFlag ? sumIntoPriceAmt : outboundVO.getOutingAmt())
            ;
        }

        //实体转换
        Outbound outbound = outboundConvert.convertToPo(outboundVO);
        outboundMapper.insert(outbound);
        //endregion

        //region  新建多业务归属
//        outCommon.insertMultiOwner(outboundVO);
        //endregion

        //region 销售订单
        //新建销售出库修改销售订单信息
        this.insertOrderMessageByEdit(outboundVO,outboundVO.getItemList());
        //endregion

        BigDecimal factAmt = BigDecimal.ZERO; //总单的实际金额

        //region 明细
        //校验明细
        if (outboundVO.getItemList().size() == 0) {
            throw new BaseBusinessException(ErrorCodeEnum.OUTBOUND_ITEM_NOT_EXIST.getCode(),
                    ErrorCodeEnum.OUTBOUND_ITEM_NOT_EXIST.getMessage());
        }

        for (OutboundItemVO outboundItemVO : outboundVO.getItemList()) {
            outboundItemVO.setItemId(null);

            //region 将库存需要的参数赋值
            outboundItemVO.setInventoryType(Constant.InventoryType.OUTBOUND.getName());
            outboundItemVO.setInventoryDocCode(Constant.InventoryDocCode.SALE_ORDER.getValue());
            outboundItemVO.setAddOrEditFlag(true);
            //endregion

            //总单id
            outboundItemVO.setOutId(outboundVO.getOutId());
            //出库类型
            outboundItemVO.setOutType(outboundVO.getOutType());
            //出库状态等于已出库  更新合计出库数量/金额 = 出库中数量/出库中金额
            if (Constant.OutStatus.YICHUKU.getName().equals(outboundVO.getOutStatus())) {
                outboundItemVO
                        .setOutQty(outboundItemVO.getOutingQty())
                        .setOutAmt(outboundItemVO.getOutingAmt())
                        .setOutingQty(BigDecimal.ZERO)
                        .setOutingAmt(BigDecimal.ZERO)
                        .setCostPrice(outboundItemVO.getPriceOut())
                        .setCostAmt(outboundItemVO.getOutQty().multiply(outboundItemVO.getPriceOut()).setScale(2, BigDecimal.ROUND_HALF_UP)) ;
            } else {
                outboundItemVO
                        .setOutQty(BigDecimal.ZERO)
                        .setOutAmt(BigDecimal.ZERO);
            }
            factAmt = factAmt.add(outboundItemVO.getFactAmt()); //把明细的 实际金额相加就是总单的
            //出库状态
            outboundItemVO.setOutStatus(outboundVO.getOutStatus());
            //实体转换
            OutboundItem outboundItem = outboundItemConvert.convertToPo(outboundItemVO);
            outboundItemMapper.insert(outboundItem);
            //明细id
            outboundItemVO.setItemId(outboundItem.getItemId());
            //endregion

            //region 销售明细
            if (outboundItemVO.getFromItemId() != null) {
                //赋值 （这里重写了更新方法，数量在更新方法中有数据库院士数量+本次数量）
                OrderItem orderItem = new OrderItem();
                orderItem.setItemId(outboundItemVO.getFromItemId());
                //根据id查询
                OrderItemResponse orderItemResponse = orderItemMapper.selectById(outboundItemVO.getFromItemId());
                //已出库
                if (Constant.OutStatus.YICHUKU.getName().equals(outboundVO.getOutStatus())) {
                    orderItem.setOutingQty(BigDecimal.ZERO);
                    orderItem.setOutingAmt(BigDecimal.ZERO);
                    orderItem.setOutQty(outboundItemVO.getOutQty());
                    orderItem.setOutAmt(outboundItemVO.getOutAmt());
                }
                //出库中
                else {
                    orderItem.setOutingQty(outboundItemVO.getOutingQty());
                    orderItem.setOutingAmt(outboundItemVO.getOutingAmt());
                    orderItem.setOutQty(BigDecimal.ZERO);
                    orderItem.setOutAmt(BigDecimal.ZERO);
                }

                //出库状态
                String outStatus = this.setOutStatus(orderItemResponse.getOutingQty().add(orderItem.getOutingQty()),
                        orderItemResponse.getOutQty().add(orderItem.getOutQty()), orderItemResponse.getItemQty());
                orderItem.setOutStatus(outStatus);
                //修改
                int countRow = orderItemMapper.updateById(orderItem);
                //数量超出
                if (countRow == 0) {
                    throw new BaseBusinessException(ResponseCodeEnum.OPERATE_FAIL.getCode(), ErrorCodeEnum.INVENTORY_QUANTITY_EXCEEDED_OUTBOUND.getMessage());
                }
            }
            //endregion

        }
        //endregion

        Outbound outboundup = new Outbound();
        outboundup.setOutId(outbound.getOutId()).setFactAmt(factAmt);
        //反写总单实际金额
        outboundMapper.update(outboundup,
                new UpdateWrapper<Outbound>().lambda()
                        .eq(Outbound::getOutId, UUID.fromString(outbound.getOutId()))
        );
        //region  已出库  应收记账
        if (Constant.OutStatus.YICHUKU.getName().equals(outboundVO.getOutStatus())) {
            accountService.accReceivable(outboundVO.getOutId(), Constant.InventoryDocCode.OUTBOUND.getTableName());
        }
        //endregion

        //region 外协品+库存
        if (Constant.OutStatus.YICHUKU.getName().equals(outboundVO.getOutStatus())) {
            //region 外协品新建外协入库单
            //筛选出skuId为空的 走外协品逻辑
            List<OutboundItemVO> outsideGoods = outboundVO.getItemList().stream().filter(it -> it.getSkuId() == null).collect(Collectors.toList());
            for (int i = 0; i < outsideGoods.size(); i++) {
                outsideGoods.get(i).setPriceOut(outsideGoods.get(i).getCostPrice() == null ? BigDecimal.ZERO : outsideGoods.get(i).getCostPrice());
            }
            //删除外协品生产外协入库单
            this.deleteOutsideGoodsInto(outboundVO, outsideGoods);
            //新建外协品生产外协入库单
            this.insertOutsideGoodsInto(outboundVO, outsideGoods);
            //endregion

            //region 库存
            //筛选出skuId不为空的 走库存
            List<OutboundItemVO> invList = outboundVO.getItemList().stream().filter(it -> it.getSkuId() != null).collect(Collectors.toList());
            if (invList != null && invList.size() > 0) {
                Map<String, Object> invMap = new HashMap<>();
                invMap.put("outDetail", invList);
                inventoryService.operatingInventoryInformation(invMap);
            }

            //endregion
        }
        //endregion

        return ResponseResultUtil.success(outboundVO);
    }

    /**
     * @desc   : 新建销售出库修改销售订单信息
     * @date   : 2024/6/27 9:27
     * @author : 寇珊珊
     */
    @Transactional(rollbackFor = {Exception.class})
    public  void insertOrderMessageByEdit(OutboundVO outboundVO , List<OutboundItemVO> itemList){
        //出库明细汇总
        Map<String, List<OutboundItemVO>> orderOutItemVOListMap = itemList.stream().collect(Collectors.groupingBy(OutboundItemVO::getFromId));
        //出库明细汇总循环
        for (String fromId : orderOutItemVOListMap.keySet()) {

            //region  提取新建分组后的明细
            List<OutboundItemVO> orderOutItemVOListGroup = orderOutItemVOListMap.get(fromId);
            //分组后的明细 出库数量和金额总和
            BigDecimal orderSumQty = orderOutItemVOListGroup.stream().map(OutboundItemVO::getOutingQty).reduce(BigDecimal.ZERO, BigDecimal::add).setScale(6, BigDecimal.ROUND_HALF_UP);
            BigDecimal orderSumAmt = orderOutItemVOListGroup.stream().map(OutboundItemVO::getOutingAmt).reduce(BigDecimal.ZERO, BigDecimal::add).setScale(2, BigDecimal.ROUND_HALF_UP);
            //endregion

            //region  反写订单数据
            //根据id查询
            OrderResponse orderResponse = orderMapper.selectById(fromId);
            Order order = new Order();
            order.setOrderId(fromId);
            //已出库
            if (Constant.OutStatus.YICHUKU.getName().equals(outboundVO.getOutStatus())) {
                order.setOutingQty(BigDecimal.ZERO);
                order.setOutingAmt(BigDecimal.ZERO);
                order.setOutQty(orderSumQty);
                order.setOutAmt(orderSumAmt);
            }
            //出库中
            else {
                order.setOutingQty(orderSumQty);
                order.setOutingAmt(orderSumQty);
                order.setOutQty(BigDecimal.ZERO);
                order.setOutAmt(BigDecimal.ZERO);
            }
            //出库状态
            String outStatus = this.setOutStatus(orderResponse.getOutingQty().add(order.getOutingQty()),
                    orderResponse.getOutQty().add(order.getOutQty()), orderResponse.getSumQuantity());
            order.setOutStatus(outStatus);
            //修改
            int countRow = orderMapper.updateById(order);
            //数量超出
            if (countRow == 0) {
                throw new BaseBusinessException(ResponseCodeEnum.OPERATE_FAIL.getCode(), ErrorCodeEnum.INVENTORY_QUANTITY_EXCEEDED_OUTBOUND.getMessage());
            }
            //endregion
        }
    }

    /**
     * @desc : 销售出库编辑
     * @date : 2024/3/25 16:25
     * @author : 寇珊珊
     */
    @Transactional(rollbackFor = {Exception.class})
    public ResponseResultVO<?> saleOutboundUpdate(OutboundVO outboundVO) {
        //region 小编辑
        if (!outboundVO.getLimitEdit()) {
            Outbound outbound = new Outbound();
            outbound.setOutId(outboundVO.getOutId());
            outbound.setRemarks(outboundVO.getRemarks());
            outbound.setAnnexPaths(outboundVO.getAnnexPaths());
            outboundMapper.update(outbound,
                    new UpdateWrapper<Outbound>().lambda()
                            .eq(Outbound::getOutId, UUID.fromString(outbound.getOutId()))
            );
            for (OutboundItemVO outboundItemVO : outboundVO.getItemList()) {
                OutboundItem outboundItem = new OutboundItem();
                outboundItem.setItemId(outboundItemVO.getItemId());
                if (outboundItemVO.getRemarks() != null || outboundItemVO.getRemarks() != " ") {
                    outboundItem.setRemarks(outboundItemVO.getRemarks());
                    outboundItemMapper.update(outboundItem,
                            new UpdateWrapper<OutboundItem>().lambda()
                                    .eq(OutboundItem::getItemId, UUID.fromString(outboundItem.getItemId()))
                    );
                }
            }
        }
        //endregion

        //region 大编辑
        else {
            // region 更新客户信息
//            outboundVO = outCommon.insertCustomer(outboundVO);
            // endregion

            //region 根据id查询   并且明细数量金额  求和
            OutboundResponse outboundResponse = outboundMapper.selectById(outboundVO.getOutId());
            //根据总单id查询
            List<OutboundItemResponse> outboundItemResponseList = outboundItemMapper.selectByCond(new OutboundItemQuery().setOutId(outboundResponse.getOutId()));
            BigDecimal sumQty = outboundVO.getItemList().stream().map(OutboundItemVO::getOutingQty).reduce(BigDecimal.ZERO, BigDecimal::add).setScale(6, BigDecimal.ROUND_HALF_UP);
            BigDecimal sumAmt = outboundVO.getItemList().stream().map(OutboundItemVO::getOutingAmt).reduce(BigDecimal.ZERO, BigDecimal::add).setScale(2, BigDecimal.ROUND_HALF_UP);
            //endregion

            //region  已入库编辑
            if (Constant.OutStatus.YICHUKU.getName().equals(outboundVO.getOutStatus())) {
                //region 应收反记账
                if (outboundVO.getReceivableId() != null) {
                    accountService.reverseReceivable(outboundVO.getOutId(), Constant.InventoryDocCode.OUTBOUND.getTableName());
                }
                //endregion

                //region 修改明细
                List<OutboundItemVO> itemList = outboundVO.getItemList();
                for (OutboundItemVO outboundItemVO : itemList) {
                    //根据id查询
                    OutboundItemResponse outboundItemResponse = outboundItemMapper.selectById(outboundItemVO.getItemId());

                    //region 反写订单总单 数据需要  把查出来的已出库数量用别的变量存起来
                    outboundItemVO.setUpdateOrderOutQty(outboundItemResponse.getOutQty());
                    outboundItemVO.setUpdateOrderOutAmt(outboundItemResponse.getOutAmt());
                    //endregion

                    //region  编辑明细
                    if (outboundItemVO.getItemId() != null) {

                        //region 将库存需要的参数赋值
                        outboundItemVO.setInventoryType(Constant.InventoryType.OUTBOUND.getName());
                        outboundItemVO.setInventoryDocCode(Constant.InventoryDocCode.SALE_ORDER.getValue());
                        //编辑之前的数
                        outboundItemVO.setQtyBeforeUpdate(outboundItemResponse.getOutQty());
                        outboundItemVO.setAmtBeforeUpdate(outboundItemResponse.getOutAmt());
                        //编辑之后的数
                        outboundItemVO.setOutQty(outboundItemVO.getOutingQty());
                        outboundItemVO.setOutAmt(outboundItemVO.getOutingAmt());
                        outboundItemVO.setAddOrEditFlag(false);
                        //endregion

                        OutboundItem outboundItem = new OutboundItem();
                        outboundItem.setItemId(outboundItemVO.getItemId());
                        outboundItem.setOutQty(outboundItemVO.getOutingQty());
                        outboundItem.setOutAmt(outboundItemVO.getOutingAmt());
                        outboundItem.setCostPrice(outboundItemVO.getPriceOut());
                        outboundItem.setCostAmt(outboundItemVO.getOutQty().multiply(outboundItemVO.getPriceOut()).setScale(6, BigDecimal.ROUND_HALF_UP));
                        //修改
                        outboundItemMapper.update(outboundItem,
                                new UpdateWrapper<OutboundItem>().lambda()
                                        .eq(OutboundItem::getItemId, UUID.fromString(outboundItem.getItemId()))
                        );
                    }
                    //endregion

                    //region 新建明细
                    else {
                        outboundItemVO
                                .setOutId(outboundItemVO.getOutId())
                                .setOutQty(outboundItemVO.getOutingQty())
                                .setOutAmt(outboundItemVO.getOutingAmt())
                                .setOutingQty(BigDecimal.ZERO)
                                .setOutingAmt(BigDecimal.ZERO)
                                .setCostPrice(outboundItemVO.getPriceOut())
                                .setCostAmt(outboundItemVO.getOutQty().multiply(outboundItemVO.getPriceOut()).setScale(2, BigDecimal.ROUND_HALF_UP))
                                .setOutType(Constant.OutType.SALE.getName())
                        ;
                        //出库状态
                        String outStatus = this.setOutStatus(outboundItemVO.getOutingQty(), outboundItemVO.getOutQty());
                        outboundItemVO.setOutStatus(outStatus);
                        //实体转换
                        OutboundItem outboundItem = outboundItemConvert.convertToPo(outboundItemVO);
                        //新建
                        outboundItemMapper.insert(outboundItem);
                        outboundItemVO.setItemId(outboundItem.getItemId());
                        //region 将库存需要的参数赋值
                        outboundItemVO.setInventoryType(Constant.InventoryType.OUTBOUND.getName());
                        outboundItemVO.setInventoryDocCode(Constant.InventoryDocCode.SALE_ORDER.getValue());
                        outboundItemVO.setAddOrEditFlag(true);
                        //endregion
                    }
                    //endregion

                    //region  销售明细
                    if (outboundItemVO.getFromItemId() != null) {
                        //根据id查询
                        OrderItemResponse orderItemResponse = orderItemMapper.selectById(outboundItemVO.getFromItemId());
                        OrderItem orderItem = new OrderItem();
                        orderItem.setItemId(outboundItemVO.getFromItemId());
                        orderItem.setOutQty(outboundItemResponse.getOutQty().negate().add(outboundItemVO.getOutingQty()));
                        orderItem.setOutAmt(outboundItemResponse.getOutAmt().negate().add(outboundItemVO.getOutingAmt()));
                        orderItem.setOutingQty(outboundItemVO.getOutQty());
                        orderItem.setOutingAmt(outboundItemVO.getOutAmt());
                        //出库状态
                        String outStatus = this.setOutStatus(orderItemResponse.getOutingQty().add(orderItem.getOutingQty()),
                                orderItemResponse.getOutQty().add(orderItem.getOutQty()), orderItemResponse.getItemQty());
                        orderItem.setOutStatus(outStatus);
                        int countRow = orderItemMapper.updateById(orderItem);
                        //数量超出
                        if (countRow == 0) {
                            throw new BaseBusinessException(ResponseCodeEnum.OPERATE_FAIL.getCode(), ErrorCodeEnum.INVENTORY_QUANTITY_EXCEEDED_OUTBOUND.getMessage());
                        }
                    }
                    //endregion

                }
                //endregion

                //region 删除明细
                if (outboundVO.getDeleteItemList() != null && outboundVO.getDeleteItemList().size() > 0) {
                    for (OutboundItemVO outboundItemVO : outboundVO.getDeleteItemList()) {
                        if (outboundItemVO.getItemId() != null) {
                            //region 将库存需要的参数赋值
                            outboundItemVO.setInventoryType(Constant.InventoryType.OUTBOUND.getName());
                            outboundItemVO.setInventoryDocCode(Constant.InventoryDocCode.SALE_ORDER.getValue());
                            //endregion
                            OutboundItem outboundItem = outboundItemConvert.convertToPo(outboundItemVO);
                            outboundItem.setFlgValid(false);
                            //修改
                            outboundItemMapper.update(outboundItem,
                                    new UpdateWrapper<OutboundItem>().lambda()
                                            .eq(OutboundItem::getItemId, UUID.fromString(outboundItem.getItemId()))
                            );
                        }
                        //region  销售明细
                        if (outboundItemVO.getFromItemId() != null) {
                            //根据id查询
                            OrderItemResponse orderItemResponse = orderItemMapper.selectById(outboundItemVO.getFromItemId());
                            OrderItem orderItem = new OrderItem();
                            orderItem.setItemId(outboundItemVO.getFromItemId());
                            orderItem.setOutQty(outboundItemVO.getOutQty().negate());
                            orderItem.setOutAmt(outboundItemVO.getOutAmt().negate());
                            orderItem.setOutingQty(outboundItemVO.getOutQty());
                            orderItem.setOutingAmt(outboundItemVO.getOutQty());
                            //出库状态
                            String outStatus = this.setOutStatus(orderItemResponse.getOutingQty().add(orderItem.getOutingQty()),
                                    orderItemResponse.getOutQty().add(orderItem.getOutQty()), orderItemResponse.getItemQty());
                            orderItem.setOutStatus(outStatus);
                            int countRow = orderItemMapper.updateById(orderItem);
                            //数量超出
                            if (countRow == 0) {
                                throw new BaseBusinessException(ResponseCodeEnum.OPERATE_FAIL.getCode(), ErrorCodeEnum.INVENTORY_QUANTITY_EXCEEDED_OUTBOUND.getMessage());
                            }
                        }
                        //endregion
                    }
                }
                //endregion

                //region  修改出库总单
                Outbound outbound = new Outbound();
                outbound.setOutId(outboundVO.getOutId());
                outbound.setOutQty(sumQty);
                outbound.setOutAmt(sumAmt);
                outbound.setAnnexPaths(outboundVO.getAnnexPaths());
                //修改
                outboundMapper.update(outbound,
                        new UpdateWrapper<Outbound>().lambda().eq(Outbound::getOutId, UUID.fromString(outbound.getOutId()))
                );
                //endregion

                //region 修改销售总单

                this.updateOrderMessageByEdit(outboundResponse, outboundVO.getItemList(), outboundVO.getDeleteItemList());
                //endregion

                //region  应收记账
                if (outboundVO.getReceivableId() != null) {
                    accountService.accReceivable(outboundResponse.getOutId(), Constant.InventoryDocCode.OUTBOUND.getTableName());
                }
                //endregion

                //region 外协品新建外协入库单
                //筛选出skuId为空的 走外协品逻辑
                List<OutboundItemVO> outsideGoods = outboundVO.getItemList().stream().filter(it -> it.getSkuId() == null).collect(Collectors.toList());
                //删除外协品生产外协入库单
                this.deleteOutsideGoodsInto(outboundVO, outsideGoods);
                //新建外协品生产外协入库单
                this.insertOutsideGoodsInto(outboundVO, outsideGoods);
                if (outboundVO.getDeleteItemList() != null) {
                    List<OutboundItemVO> delOutsideGoods = outboundVO.getDeleteItemList().stream().filter(it -> it.getSkuId() == null).collect(Collectors.toList());
                    //删除外协品生产外协入库单
                    this.deleteOutsideGoodsInto(outboundVO, delOutsideGoods);
                }
                //endregion

                //region 修改库存
                //筛选出skuId不为空的 走库存
                List<OutboundItemVO> invList = outboundVO.getItemList().stream().filter(it -> it.getSkuId() != null).collect(Collectors.toList());
                List<OutboundItemVO> invDelList = null;
                if (outboundVO.getDeleteItemList() != null) {
                    invDelList = outboundVO.getDeleteItemList().stream().filter(it -> it.getSkuId() != null).collect(Collectors.toList());
                }
                if ((invList != null && invList.size() > 0) || (invDelList != null && invDelList.size() > 0)) {
                    Map<String, Object> invMap = new HashMap<>();
                    invMap.put("outDetail", invList);
                    invMap.put("delOutDetail", invDelList);
                    inventoryService.operatingInventoryInformation(invMap);
                }
                //endregion
            }
            //endregion

            //region 出库中编辑
            if (Constant.OutStatus.CHUKUZHONG.getName().equals(outboundVO.getOutStatus()) ||
                    Constant.OutStatus.DAICHUKU.getName().equals(outboundVO.getOutStatus())) {
                //region 修改明细
                List<OutboundItemVO> itemList = outboundVO.getItemList();
                for (OutboundItemVO outboundItemVO : itemList) {

                    //根据id查询 获取到还未进行修改的数据
                    OutboundItemResponse outboundItemResponse = outboundItemMapper.selectById(outboundItemVO.getItemId());

                    //region 编辑明细
                    if (outboundItemVO.getItemId() != null) {

                        //region 反写订单总单 数据需要  把查出来的出库中数量用别的变量存起来
                        outboundItemVO.setUpdateOrderOutingQty(outboundItemResponse.getOutingQty());
                        outboundItemVO.setUpdateOrderOutingAmt(outboundItemResponse.getOutingAmt());
                        //endregion

                        OutboundItem outboundItem = new OutboundItem();
                        outboundItem.setItemId(outboundItemResponse.getItemId());
                        outboundItem.setOutingQty(outboundItemVO.getOutingQty());
                        outboundItem.setOutingAmt(outboundItemVO.getOutingAmt());
                        outboundItem.setWhId(outboundItemVO.getWhId());
                        //修改
                        outboundItemMapper.update(outboundItem,
                                new UpdateWrapper<OutboundItem>().lambda()
                                        .eq(OutboundItem::getItemId, UUID.fromString(outboundItem.getItemId()))
                        );
                    }
                    //endregion

                    //region 新建明细
                    else {
                        //region 反写订单总单 数据需要  把查出来的出库中数量用别的变量存起来
                        outboundItemVO.setUpdateOrderOutingQty(outboundItemVO.getOutingQty());
                        outboundItemVO.setUpdateOrderOutingAmt(outboundItemVO.getOutingAmt());
                        //endregion

                        outboundItemVO
                                .setOutId(outboundItemVO.getOutId())
                                .setOutQty(BigDecimal.ZERO)
                                .setOutAmt(BigDecimal.ZERO)
                                .setCostPrice(outboundItemVO.getPriceOut())
                                .setCostAmt(outboundItemVO.getOutingQty().multiply(outboundItemVO.getPriceOut()).setScale(2, BigDecimal.ROUND_HALF_UP))
                                .setOutType(Constant.OutType.SALE.getName())
                        ;
                        //出库状态
                        String outStatus = this.setOutStatus(outboundItemVO.getOutingQty(), outboundItemVO.getOutQty());
                        outboundItemVO.setOutStatus(outStatus);
                        //实体转换
                        OutboundItem outboundItem = outboundItemConvert.convertToPo(outboundItemVO);
                        //新建
                        outboundItemMapper.insert(outboundItem);
                        outboundItemVO.setItemId(outboundItem.getItemId());
                    }
                    //endregion

                    //region  销售明细
                    if (outboundItemVO.getFromItemId() != null) {
                        //根据id查询
                        OrderItemResponse orderItemResponse = orderItemMapper.selectById(outboundItemVO.getFromItemId());
                        OrderItem orderItem = new OrderItem();
                        orderItem.setItemId(outboundItemVO.getFromItemId());
                        orderItem.setOutingQty(outboundItemResponse.getOutingQty().negate().add(outboundItemVO.getOutingQty()));
                        orderItem.setOutingAmt(outboundItemResponse.getOutingAmt().negate().add(outboundItemVO.getOutingAmt()));
                        //出库状态
                        String outStatus = this.setOutStatus(orderItemResponse.getOutingQty().add(orderItem.getOutingQty()),
                                orderItemResponse.getOutQty(), orderItemResponse.getItemQty());
                        orderItem.setOutStatus(outStatus);
                        int countRow = orderItemMapper.updateById(orderItem);
                        //数量超出
                        if (countRow == 0) {
                            throw new BaseBusinessException(ResponseCodeEnum.OPERATE_FAIL.getCode(), ErrorCodeEnum.INVENTORY_QUANTITY_EXCEEDED_OUTBOUND.getMessage());
                        }
                    }
                    //endregion
                }
                //endregion

                //region 删除明细
                if (outboundVO.getDeleteItemList() != null && outboundVO.getDeleteItemList().size() > 0) {
                    for (OutboundItemVO outboundItemVO : outboundVO.getDeleteItemList()) {
                        if (outboundItemVO.getItemId() != null) {
                            OutboundItem outboundItem = outboundItemConvert.convertToPo(outboundItemVO);
                            outboundItem.setFlgValid(false);
                            //修改
                            outboundItemMapper.update(outboundItem,
                                    new UpdateWrapper<OutboundItem>().lambda()
                                            .eq(OutboundItem::getItemId, UUID.fromString(outboundItem.getItemId()))
                            );
                        }
                        //region  销售明细
                        if (outboundItemVO.getFromItemId() != null) {
                            //根据id查询
                            OrderItemResponse orderItemResponse = orderItemMapper.selectById(outboundItemVO.getFromItemId());
                            OrderItem orderItem = new OrderItem();
                            orderItem.setItemId(outboundItemVO.getFromItemId());
                            orderItem.setOutingQty(outboundItemVO.getOutQty().negate());
                            orderItem.setOutingAmt(outboundItemVO.getOutQty().negate());
                            //出库状态
                            String outStatus = this.setOutStatus(orderItemResponse.getOutingQty().add(orderItem.getOutingQty()),
                                    orderItemResponse.getOutQty(), orderItemResponse.getItemQty());
                            orderItem.setOutStatus(outStatus);
                            int countRow = orderItemMapper.updateById(orderItem);
                            //数量超出
                            if (countRow == 0) {
                                throw new BaseBusinessException(ResponseCodeEnum.OPERATE_FAIL.getCode(), ErrorCodeEnum.INVENTORY_QUANTITY_EXCEEDED_OUTBOUND.getMessage());
                            }
                        }
                        //endregion
                    }
                }
                //endregion

                //region  修改入库总单
                Outbound outbound = new Outbound();
                outbound.setOutId(outboundVO.getOutId());
                outbound.setOutingQty(sumQty);
                outbound.setOutingAmt(sumAmt);
                outbound.setAnnexPaths(outboundVO.getAnnexPaths());
                //修改
                outboundMapper.update(outbound,
                        new UpdateWrapper<Outbound>().lambda().eq(Outbound::getOutId, UUID.fromString(outbound.getOutId()))
                );
                //endregion

                //region 修改销售总单
                this.updateOrderMessageByEdit(outboundResponse, outboundVO.getItemList(), outboundVO.getDeleteItemList());
                //endregion

            }
            //endregion
        }
        //endregion

        return ResponseResultUtil.success(outboundVO);
    }

    /**
     * @desc : 编辑销售出库修改销售订单信息
     * @date : 2024/6/21 10:34
     * @author : 寇珊珊
     */
    @Transactional(rollbackFor = {Exception.class})
    public void updateOrderMessageByEdit(OutboundResponse outboundResponse, List<OutboundItemVO> itemList, List<OutboundItemVO> deleteItemList) {
        //出库明细汇总
        Map<String, List<OutboundItemVO>> orderOutItemVOListMap = itemList.stream().collect(Collectors.groupingBy(OutboundItemVO::getFromId));
        //出库明细删除汇总
        Map<String, List<OutboundItemVO>> delOrderOutItemVOListMap = deleteItemList.stream().collect(Collectors.groupingBy(OutboundItemVO::getFromId));
        //出库明细汇总循环
        for (String fromId : orderOutItemVOListMap.keySet()) {
            //有需要删除的修改数据
            if(delOrderOutItemVOListMap!=null  && delOrderOutItemVOListMap.keySet().size()>0){
                //出库明细删除汇总循环
                for (String delFromId : delOrderOutItemVOListMap.keySet()) {
                    //新建出库明细来源Id = 删除出库明细来源Id
                    if (fromId.equals(delFromId)) {

                        //region  提取新建分组后的明细
                        List<OutboundItemVO> orderOutItemVOListGroup = orderOutItemVOListMap.get(fromId);
                        //分组后的明细 出库数量和金额总和
                        BigDecimal orderSumQty = orderOutItemVOListGroup.stream().map(OutboundItemVO::getOutingQty).reduce(BigDecimal.ZERO, BigDecimal::add).setScale(6, BigDecimal.ROUND_HALF_UP);
                        BigDecimal orderSumAmt = orderOutItemVOListGroup.stream().map(OutboundItemVO::getOutingAmt).reduce(BigDecimal.ZERO, BigDecimal::add).setScale(2, BigDecimal.ROUND_HALF_UP);
                        //分组后的明细 原出库数量和金额总和
                        BigDecimal updateOrderOutQty = BigDecimal.ZERO;
                        BigDecimal updateOrderOutAmt = BigDecimal.ZERO;
                        BigDecimal updateOrderOutingQty = BigDecimal.ZERO;
                        BigDecimal updateOrderOutingAmt = BigDecimal.ZERO;
                        //已出库
                        if (Constant.OutStatus.YICHUKU.getName().equals(outboundResponse.getOutStatus())) {
                            updateOrderOutQty = orderOutItemVOListGroup.stream().map(OutboundItemVO::getUpdateOrderOutQty).reduce(BigDecimal.ZERO, BigDecimal::add).setScale(6, BigDecimal.ROUND_HALF_UP);
                            updateOrderOutAmt = orderOutItemVOListGroup.stream().map(OutboundItemVO::getUpdateOrderOutAmt).reduce(BigDecimal.ZERO, BigDecimal::add).setScale(2, BigDecimal.ROUND_HALF_UP);
                        }
                        //出库中
                        else {
                            updateOrderOutingQty = orderOutItemVOListGroup.stream().map(OutboundItemVO::getUpdateOrderOutingQty).reduce(BigDecimal.ZERO, BigDecimal::add).setScale(6, BigDecimal.ROUND_HALF_UP);
                            updateOrderOutingAmt = orderOutItemVOListGroup.stream().map(OutboundItemVO::getUpdateOrderOutingAmt).reduce(BigDecimal.ZERO, BigDecimal::add).setScale(2, BigDecimal.ROUND_HALF_UP);
                        }
                        //endregion

                        //region 提取删除分组后的明细
                        List<OutboundItemVO> delOrderOutItemVOListGroup = delOrderOutItemVOListMap.get(delFromId);
                        BigDecimal orderDelOutQty = BigDecimal.ZERO;
                        BigDecimal orderDelOutAmt = BigDecimal.ZERO;
                        //已出库
                        if (Constant.OutStatus.YICHUKU.getName().equals(outboundResponse.getOutStatus())) {
                            orderDelOutQty = delOrderOutItemVOListGroup.stream().map(OutboundItemVO::getOutQty).reduce(BigDecimal.ZERO, BigDecimal::add).setScale(6, BigDecimal.ROUND_HALF_UP);
                            orderDelOutAmt = delOrderOutItemVOListGroup.stream().map(OutboundItemVO::getOutAmt).reduce(BigDecimal.ZERO, BigDecimal::add).setScale(2, BigDecimal.ROUND_HALF_UP);
                        }
                        //出库中
                        else if (Constant.OutStatus.CHUKUZHONG.getName().equals(outboundResponse.getOutStatus())) {
                            orderDelOutQty = delOrderOutItemVOListGroup.stream().map(OutboundItemVO::getOutingQty).reduce(BigDecimal.ZERO, BigDecimal::add).setScale(6, BigDecimal.ROUND_HALF_UP);
                            orderDelOutAmt = delOrderOutItemVOListGroup.stream().map(OutboundItemVO::getOutingAmt).reduce(BigDecimal.ZERO, BigDecimal::add).setScale(2, BigDecimal.ROUND_HALF_UP);
                        }
                        //endregion

                        //region  反写订单数据
                        //根据id查询
                        OrderResponse orderResponse = orderMapper.selectById(fromId);
                        Order order = new Order();
                        order.setOrderId(fromId);
                        //已出库
                        if (Constant.OutStatus.YICHUKU.getName().equals(outboundResponse.getOutStatus())) {
                            order.setOutQty(updateOrderOutQty.negate().add(orderSumQty).subtract(orderDelOutQty));
                            order.setOutAmt(updateOrderOutAmt.negate().add(orderSumAmt).subtract(orderDelOutAmt));
                            order.setOutingQty(orderDelOutQty);
                            order.setOutingAmt(orderDelOutAmt);
                            //出库状态
                            String outStatus = this.setOutStatus(orderResponse.getOutingQty().add(order.getOutingQty()),
                                    orderResponse.getOutQty().add(order.getOutQty()), orderResponse.getSumQuantity());
                            order.setOutStatus(outStatus);
                        }
                        //出库中
                        else if (Constant.OutStatus.CHUKUZHONG.getName().equals(outboundResponse.getOutStatus())) {
                            order.setOutingQty(updateOrderOutingQty.negate().add(orderSumQty).subtract(orderDelOutQty));
                            order.setOutingAmt(updateOrderOutingAmt.negate().add(orderSumQty).subtract(orderDelOutAmt));
                            //出库状态
                            String outStatus = this.setOutStatus(orderResponse.getOutingQty().add(order.getOutingQty()),
                                    orderResponse.getOutQty(), orderResponse.getSumQuantity());
                            order.setOutStatus(outStatus);
                        }
                        //修改
                        int countRow = orderMapper.updateById(order);
                        //数量超出
                        if (countRow == 0) {
                            throw new BaseBusinessException(ResponseCodeEnum.OPERATE_FAIL.getCode(), ErrorCodeEnum.INVENTORY_QUANTITY_EXCEEDED_OUTBOUND.getMessage());
                        }
                        //endregion
                    }
                }
            }
            //没有需要删除的修改数据
            else{

                //region  提取新建分组后的明细
                List<OutboundItemVO> orderOutItemVOListGroup = orderOutItemVOListMap.get(fromId);
                //分组后的明细 出库数量和金额总和
                BigDecimal orderSumQty = orderOutItemVOListGroup.stream().map(OutboundItemVO::getOutingQty).reduce(BigDecimal.ZERO, BigDecimal::add).setScale(6, BigDecimal.ROUND_HALF_UP);
                BigDecimal orderSumAmt = orderOutItemVOListGroup.stream().map(OutboundItemVO::getOutingAmt).reduce(BigDecimal.ZERO, BigDecimal::add).setScale(2, BigDecimal.ROUND_HALF_UP);
                //分组后的明细 原出库数量和金额总和
                BigDecimal updateOrderOutQty = BigDecimal.ZERO;
                BigDecimal updateOrderOutAmt = BigDecimal.ZERO;
                BigDecimal updateOrderOutingQty = BigDecimal.ZERO;
                BigDecimal updateOrderOutingAmt = BigDecimal.ZERO;
                //已出库
                if (Constant.OutStatus.YICHUKU.getName().equals(outboundResponse.getOutStatus())) {
                    updateOrderOutQty = orderOutItemVOListGroup.stream().map(OutboundItemVO::getUpdateOrderOutQty).reduce(BigDecimal.ZERO, BigDecimal::add).setScale(6, BigDecimal.ROUND_HALF_UP);
                    updateOrderOutAmt = orderOutItemVOListGroup.stream().map(OutboundItemVO::getUpdateOrderOutAmt).reduce(BigDecimal.ZERO, BigDecimal::add).setScale(2, BigDecimal.ROUND_HALF_UP);
                }
                //出库中
                else {
                    updateOrderOutingQty = orderOutItemVOListGroup.stream().map(OutboundItemVO::getUpdateOrderOutingQty).reduce(BigDecimal.ZERO, BigDecimal::add).setScale(6, BigDecimal.ROUND_HALF_UP);
                    updateOrderOutingAmt = orderOutItemVOListGroup.stream().map(OutboundItemVO::getUpdateOrderOutingAmt).reduce(BigDecimal.ZERO, BigDecimal::add).setScale(2, BigDecimal.ROUND_HALF_UP);
                }
                //endregion

                //region  反写订单数据
                //根据id查询
                OrderResponse orderResponse = orderMapper.selectById(fromId);
                Order order = new Order();
                order.setOrderId(fromId);
                //已出库
                if (Constant.OutStatus.YICHUKU.getName().equals(outboundResponse.getOutStatus())) {
                    order.setOutQty(updateOrderOutQty.negate().add(orderSumQty));
                    order.setOutAmt(updateOrderOutAmt.negate().add(orderSumAmt));
                    //出库状态
                    String outStatus = this.setOutStatus(orderResponse.getOutingQty().add(order.getOutingQty()),
                            orderResponse.getOutQty().add(order.getOutQty()), orderResponse.getSumQuantity());
                    order.setOutStatus(outStatus);
                }
                //出库中
                else if (Constant.OutStatus.CHUKUZHONG.getName().equals(outboundResponse.getOutStatus())) {
                    order.setOutingQty(updateOrderOutingQty.negate().add(orderSumQty));
                    order.setOutingAmt(updateOrderOutingAmt.negate().add(orderSumQty));
                    //出库状态
                    String outStatus = this.setOutStatus(orderResponse.getOutingQty().add(order.getOutingQty()),
                            orderResponse.getOutQty(), orderResponse.getSumQuantity());
                    order.setOutStatus(outStatus);
                }
                //修改
                int countRow = orderMapper.updateById(order);
                //数量超出
                if (countRow == 0) {
                    throw new BaseBusinessException(ResponseCodeEnum.OPERATE_FAIL.getCode(), ErrorCodeEnum.INVENTORY_QUANTITY_EXCEEDED_OUTBOUND.getMessage());
                }
                //endregion
            }
        }
    }

    /**
     * @desc : 销售出库作废
     * @date : 2024/3/26 9:24
     * @author : 寇珊珊
     */
    @Transactional(rollbackFor = {Exception.class})
    public ResponseResultVO<?> saleOutboundRepeal(String outId) {
        //region  查询总单  查询明细
        //根据id查询 此条出库单的数据还未更改前的数据
        OutboundResponse outboundResponse = outboundMapper.selectById(outId);
        //根据总单id查询
        List<OutboundItemResponse> outboundItemResponseList = outboundItemMapper.selectByCond(new OutboundItemQuery().setOutId(outboundResponse.getOutId()));

        //endregion

        //region 已出库状态作废
        if (Constant.OutStatus.YICHUKU.getName().equals(outboundResponse.getOutStatus())) {
            //region 应收反记账
            if (outboundResponse.getReceivableId() != null) {
                accountService.reverseReceivable(outboundResponse.getOutId(), Constant.InventoryDocCode.OUTBOUND.getTableName());
            }
            //endregion

            //region 修改明细
            for (OutboundItemResponse outboundItemResponse : outboundItemResponseList) {
                //region 将库存需要的参数赋值
                outboundItemResponse.setInventoryType(Constant.InventoryType.OUTBOUND.getName());
                outboundItemResponse.setInventoryDocCode(Constant.InventoryDocCode.SALE_ORDER.getValue());
                outboundItemResponse.setOutQty(outboundItemResponse.getOutQty());
                outboundItemResponse.setOutAmt(outboundItemResponse.getOutAmt());
                //endregion

                //赋值  防止作废的单据查不到明细 故注掉下面代码
//                OutboundItem outboundItem = new OutboundItem();
//                outboundItem.setItemId(outboundItemResponse.getItemId());
//                outboundItem.setFlgValid(false);
//                //修改
//                outboundItemMapper.update(outboundItem,
//                        new UpdateWrapper<OutboundItem>().lambda()
//                                .eq(OutboundItem::getItemId, UUID.fromString(outboundItem.getItemId()))
//                );

                //region  销售明细
                if (outboundItemResponse.getFromItemId() != null) {
                    //根据id查询
                    OrderItemResponse orderItemResponse = orderItemMapper.selectById(outboundItemResponse.getFromItemId());
                    OrderItem orderItem = new OrderItem();
                    orderItem.setItemId(outboundItemResponse.getFromItemId());
                    orderItem.setOutQty(outboundItemResponse.getOutQty().negate());
                    orderItem.setOutAmt(outboundItemResponse.getOutAmt().negate());
                    //出库状态
                    String orderOutStatus = this.setOutStatus(orderItemResponse.getOutingQty(),
                            orderItemResponse.getOutQty().add(orderItem.getOutQty()), orderItemResponse.getItemQty());
                    orderItem.setOutStatus(orderOutStatus);
                    int countRow = orderItemMapper.updateById(orderItem);
                    //数量超出
                    if (countRow == 0) {
                        throw new BaseBusinessException(ResponseCodeEnum.OPERATE_FAIL.getCode(), ErrorCodeEnum.INVENTORY_QUANTITY_EXCEEDED_OUTBOUND.getMessage());
                    }
                }
                //endregion
            }
            //endregion

            //region  修改出库总单
            Outbound outbound = new Outbound();
            outbound.setOutId(outboundResponse.getOutId());
            outbound.setFlgValid(false);
            //修改
            outboundMapper.update(outbound,
                    new UpdateWrapper<Outbound>().lambda().eq(Outbound::getOutId, UUID.fromString(outbound.getOutId()))
            );
            //endregion

            //region 修改销售总单
            this.updateOrderMessageByRepeal(outboundResponse, outboundItemResponseList);
            //endregion

            //region 外协品新建外协入库单
            //筛选出skuId为空的 走外协品逻辑
            OutboundVO outboundVO = outboundConvert.convertResToVO(outboundResponse);
            List<OutboundItemResponse> outsideGoods = outboundItemResponseList.stream().filter(it -> it.getSkuId() == null).collect(Collectors.toList());
            List<OutboundItemVO> outsideGoodsVOList = outboundItemConvert.convertResListToVOList(outsideGoods);
            //删除外协品生产外协入库单
            this.deleteOutsideGoodsInto(outboundVO, outsideGoodsVOList);
            //endregion

            //region  修改库存
            //筛选出skuId不为空的 走库存
            List<OutboundItemResponse> invList = outboundItemResponseList.stream().filter(it -> it.getSkuId() != null).collect(Collectors.toList());
            if (invList != null && invList.size() > 0) {
                Map<String, Object> map = new HashMap<>();
                map.put("delOutDetail", invList);
                inventoryService.operatingInventoryInformation(map);
            }
            //endregion
        }
        //endregion

        //region 出库中、待出库状态作废
        if (Constant.OutStatus.CHUKUZHONG.getName().equals(outboundResponse.getOutStatus()) ||
                Constant.OutStatus.DAICHUKU.getName().equals(outboundResponse.getOutStatus())) {
            //region 修改明细
            for (OutboundItemResponse outboundItemResponse : outboundItemResponseList) {
                //region 修改明细
                //赋值
                OutboundItem outboundItem = new OutboundItem();
                outboundItem.setItemId(outboundItemResponse.getItemId());
                outboundItem.setOutingQty(BigDecimal.ZERO);
                outboundItem.setOutingAmt(BigDecimal.ZERO);
//                outboundItem.setFlgValid(false);
                //修改
                outboundItemMapper.update(outboundItem,
                        new UpdateWrapper<OutboundItem>().lambda()
                                .eq(OutboundItem::getItemId, UUID.fromString(outboundItem.getItemId()))
                );
                //endregion

                //region  销售明细
                if (outboundItemResponse.getFromItemId() != null) {
                    //根据id查询
                    OrderItemResponse orderItemResponse = orderItemMapper.selectById(outboundItemResponse.getFromItemId());
                    OrderItem orderItem = new OrderItem();
                    orderItem.setItemId(outboundItemResponse.getFromItemId());
                    orderItem.setOutingQty(outboundItemResponse.getOutingQty().negate());
                    orderItem.setOutingAmt(outboundItemResponse.getOutingAmt().negate());
                    //出库状态
                    String orderOutStatus = this.setOutStatus(orderItemResponse.getOutingQty().add(orderItem.getOutingQty()),
                            orderItemResponse.getOutQty(), orderItemResponse.getItemQty());
                    orderItem.setOutStatus(orderOutStatus);
                    int countRow = orderItemMapper.updateById(orderItem);
                    //数量超出
                    if (countRow == 0) {
                        throw new BaseBusinessException(ResponseCodeEnum.OPERATE_FAIL.getCode(), ErrorCodeEnum.INVENTORY_QUANTITY_EXCEEDED_OUTBOUND.getMessage());
                    }
                }
                //endregion
            }
            //endregion

            //region  修改出库总单
            Outbound outbound = new Outbound();
            outbound.setOutId(outboundResponse.getOutId());
            outbound.setOutingQty(BigDecimal.ZERO);
            outbound.setOutingAmt(BigDecimal.ZERO);
            outbound.setFlgValid(false);
            //修改
            outboundMapper.update(outbound,
                    new UpdateWrapper<Outbound>().lambda().eq(Outbound::getOutId, UUID.fromString(outbound.getOutId()))
            );
            //endregion

            //region 修改销售总单
            this.updateOrderMessageByRepeal(outboundResponse, outboundItemResponseList);
            //endregion
        }
        //endregion

        return ResponseResultUtil.success();
    }

    /**
     * @desc : 作废销售出库修改销售订单信息
     * @date : 2024/6/21 10:34
     * @author : 寇珊珊
     */
    @Transactional(rollbackFor = {Exception.class})
    public void updateOrderMessageByRepeal(OutboundResponse outboundResponse, List<OutboundItemResponse> itemList) {
        //出库明细汇总
        Map<String, List<OutboundItemResponse>> orderOutItemListMap = itemList.stream().collect(Collectors.groupingBy(OutboundItemResponse::getFromId));
        //出库明细汇总循环
        for (String fromId : orderOutItemListMap.keySet()) {

            //region  提取新建分组后的明细
            //分组后的明细 原出库数量和金额总和
            List<OutboundItemResponse> orderOutItemListGroup = orderOutItemListMap.get(fromId);
            BigDecimal updateOrderOutQty = BigDecimal.ZERO;
            BigDecimal updateOrderOutAmt = BigDecimal.ZERO;
            BigDecimal updateOrderOutingQty = BigDecimal.ZERO;
            BigDecimal updateOrderOutingAmt = BigDecimal.ZERO;
            //已出库
            if (Constant.OutStatus.YICHUKU.getName().equals(outboundResponse.getOutStatus())) {
                updateOrderOutQty = orderOutItemListGroup.stream().map(OutboundItemResponse::getOutQty).reduce(BigDecimal.ZERO, BigDecimal::add).setScale(6, BigDecimal.ROUND_HALF_UP);
                updateOrderOutAmt = orderOutItemListGroup.stream().map(OutboundItemResponse::getOutAmt).reduce(BigDecimal.ZERO, BigDecimal::add).setScale(2, BigDecimal.ROUND_HALF_UP);
            }
            //出库中
            else {
                updateOrderOutingQty = orderOutItemListGroup.stream().map(OutboundItemResponse::getOutingQty).reduce(BigDecimal.ZERO, BigDecimal::add).setScale(6, BigDecimal.ROUND_HALF_UP);
                updateOrderOutingAmt = orderOutItemListGroup.stream().map(OutboundItemResponse::getOutingAmt).reduce(BigDecimal.ZERO, BigDecimal::add).setScale(2, BigDecimal.ROUND_HALF_UP);
            }
            //endregion

            //region  反写订单数据
            //根据id查询
            OrderResponse orderResponse = orderMapper.selectById(fromId);
            Order order = new Order();
            order.setOrderId(fromId);
            //已出库
            if (Constant.OutStatus.YICHUKU.getName().equals(outboundResponse.getOutStatus())) {
                order.setOutQty(updateOrderOutQty.negate());
                order.setOutAmt(updateOrderOutAmt.negate());
                //出库状态
                String orderOutStatus = this.setOutStatus(orderResponse.getOutingQty(),
                        orderResponse.getOutQty().add(order.getOutQty()), orderResponse.getSumQuantity());
                order.setOutStatus(orderOutStatus);
            }
            //出库中
            else if (Constant.OutStatus.CHUKUZHONG.getName().equals(outboundResponse.getOutStatus())) {
                order.setOutingQty(updateOrderOutingQty.negate());
                order.setOutingAmt(updateOrderOutingAmt.negate());
                //出库状态
                String orderOutStatus = this.setOutStatus(orderResponse.getOutingQty().add(order.getOutingQty()),
                        orderResponse.getOutQty(), orderResponse.getSumQuantity());
                order.setOutStatus(orderOutStatus);
            }
            //修改
            int countRow = orderMapper.updateById(order);
            //数量超出
            if (countRow == 0) {
                throw new BaseBusinessException(ResponseCodeEnum.OPERATE_FAIL.getCode(), ErrorCodeEnum.INVENTORY_QUANTITY_EXCEEDED_OUTBOUND.getMessage());
            }
            //endregion
        }
    }

    /**
     * @desc : 销售出库办理
     * @date : 2024/3/7 15:47
     * @author : 寇珊珊
     */
    @Transactional(rollbackFor = {Exception.class})
    public ResponseResultVO<?> saleOrderHandleOutbound(OutboundVO outboundVO) {
        //region 根据id查询 此条入库单的数据还未更改前的数据
        OutboundResponse outboundResponse = outboundMapper.selectById(outboundVO.getOutId());
        //endregion

        //region 应收反记账
        if (outboundResponse.getReceivableId() != null) {
            accountService.reverseReceivable(outboundResponse.getOutId(), Constant.InventoryDocCode.OUTBOUND.getTableName());
        }
        //endregion

        //region 编辑明细
        //校验明细
        if (outboundVO.getItemList().size() == 0) {
            throw new BaseBusinessException(ErrorCodeEnum.OUTBOUND_ITEM_NOT_EXIST.getCode(),
                    ErrorCodeEnum.OUTBOUND_ITEM_NOT_EXIST.getMessage());
        }
        for (OutboundItemVO outboundItemVO : outboundVO.getItemList()) {

            //明细根据id查询
            OutboundItemResponse outboundItemResponse = outboundItemMapper.selectById(outboundItemVO.getItemId());

            //region 校验数量是否超出
            if (outboundItemVO.getOutingQty().compareTo(outboundItemResponse.getOutingQty()) > 0) {
                throw new BaseBusinessException(ErrorCodeEnum.CANNOT_EXCEED_THE_QUANTITYIN_THE_WAREHOUSE.getCode(),
                        ErrorCodeEnum.CANNOT_EXCEED_THE_QUANTITYIN_THE_WAREHOUSE.getMessage());
            }
            //endregion

            //region 反写订单总单 数据需要  把查出来的出库中数量用别的变量存起来
            outboundItemVO.setUpdateOrderOutingQty(outboundItemResponse.getOutingQty());
            outboundItemVO.setUpdateOrderOutingAmt(outboundItemResponse.getOutingAmt());
            //endregion

            //region  编辑明细
            if (outboundItemVO.getItemId() != null) {
                outboundItemVO
                        .setOutQty(outboundItemVO.getOutingQty())
                        .setOutBox(outboundItemVO.getOutingBox()).setOutPiece(outboundItemVO.getOutingPiece())
                        .setOutAmt(outboundItemVO.getOutingAmt())
                        .setOutingQty(BigDecimal.ZERO).setOutingBox(0).setOutingPiece(BigDecimal.ZERO)
                        .setOutingAmt(BigDecimal.ZERO)
                        .setCostPrice(outboundItemVO.getPriceOut())
                        .setCostAmt(outboundItemVO.getOutQty().multiply(outboundItemVO.getPriceOut()).setScale(2, BigDecimal.ROUND_HALF_UP))
                ;
                //出库状态
                String outStatus = this.setOutStatus(outboundItemVO.getOutingQty(), outboundItemVO.getOutQty());
                outboundItemVO.setOutStatus(outStatus);
                //实体转换
                OutboundItem outboundItem = outboundItemConvert.convertToPo(outboundItemVO);
                //修改
                outboundItemMapper.update(outboundItem,
                        new UpdateWrapper<OutboundItem>().lambda()
                                .eq(OutboundItem::getItemId, UUID.fromString(outboundItem.getItemId()))
                );
                //region 将库存需要的参数赋值
                outboundItemVO.setInventoryType(Constant.InventoryType.OUTBOUND.getName());
                outboundItemVO.setInventoryDocCode(Constant.InventoryDocCode.SALE_ORDER.getValue());
                //编辑之前的数
                if (outboundItemResponse.getOutQty().compareTo(BigDecimal.ZERO) > 0) {
                    outboundItemVO.setQtyBeforeUpdate(outboundItemResponse.getOutQty());
                    outboundItemVO.setAmtBeforeUpdate(outboundItemResponse.getOutAmt());
                }
                outboundItemVO.setAddOrEditFlag(true);
                //endregion

            }

            //endregion

            //region  新建明细
            else {
                outboundItemVO
                        .setOutId(outboundItemVO.getOutId())
                        .setOutQty(outboundItemVO.getOutingQty())
                        .setOutBox(outboundItemVO.getOutingBox()).setOutPiece(outboundItemVO.getOutingPiece())
                        .setOutAmt(outboundItemVO.getOutingAmt())
                        .setCostPrice(outboundItemVO.getPriceOut())
                        .setCostAmt(outboundItemVO.getOutQty().multiply(outboundItemVO.getPriceOut()).setScale(2, BigDecimal.ROUND_HALF_UP))
                        .setOutType(Constant.OutType.SALE.getName())
                        .setOutingQty(BigDecimal.ZERO)
                        .setOutingAmt(BigDecimal.ZERO)
                ;
                //出库状态
                String outStatus = this.setOutStatus(outboundItemVO.getOutingQty(), outboundItemVO.getOutQty());
                outboundItemVO.setOutStatus(outStatus);
                //实体转换
                OutboundItem outboundItem = outboundItemConvert.convertToPo(outboundItemVO);
                //新建
                outboundItemMapper.insert(outboundItem);
                outboundItemVO.setItemId(outboundItem.getItemId());

                //region 将库存需要的参数赋值
                outboundItemVO.setInventoryType(Constant.InventoryType.OUTBOUND.getName());
                outboundItemVO.setInventoryDocCode(Constant.InventoryDocCode.SALE_ORDER.getValue());
                outboundItemVO.setAddOrEditFlag(true);
                //endregion
            }
            //endregion

            //region  销售订单明细
            if (outboundItemVO.getFromItemId() != null) {
                //根据id查询
                OrderItemResponse orderItemResponse = orderItemMapper.selectById(outboundItemVO.getFromItemId());
                //赋值（这里重写了更新方法，数量在更新方法中有数据库院士数量+本次数量）
                OrderItem orderItem = new OrderItem();
                orderItem.setItemId(outboundItemVO.getFromItemId());
                orderItem.setOutingQty(outboundItemVO.getOutQty().negate());
                orderItem.setOutingAmt(outboundItemVO.getOutAmt().negate());
                orderItem.setOutQty(outboundItemVO.getOutQty());
                orderItem.setOutAmt(outboundItemVO.getOutAmt());
                //出库状态
                String orderOutStatus = this.setOutStatus(orderItemResponse.getOutingQty().subtract(outboundItemVO.getOutQty()),
                        orderItemResponse.getOutQty().add(orderItem.getOutQty()), orderItemResponse.getItemQty());
                orderItem.setOutStatus(orderOutStatus);
                //修改
                int countRow = orderItemMapper.updateById(orderItem);
                //数量超出
                if (countRow == 0) {
                    throw new BaseBusinessException(ResponseCodeEnum.OPERATE_FAIL.getCode(), ErrorCodeEnum.INVENTORY_QUANTITY_EXCEEDED_OUTBOUND.getMessage());
                }
            }
            //endregion

        }
        //endregion

        //region 删除明细
        if (outboundVO.getDeleteItemList() != null && outboundVO.getDeleteItemList().size() > 0) {
            for (OutboundItemVO outboundItemVO : outboundVO.getDeleteItemList()) {
                if (outboundItemVO.getItemId() != null) {

                    //region 将库存需要的参数赋值
                    outboundItemVO.setInventoryType(Constant.InventoryType.OUTBOUND.getName());
                    outboundItemVO.setInventoryDocCode(Constant.InventoryDocCode.SALE_ORDER.getValue());
                    //endregion

                    OutboundItem outboundItem = outboundItemConvert.convertToPo(outboundItemVO);
                    outboundItem.setFlgValid(false);
                    //修改
                    outboundItemMapper.update(outboundItem,
                            new UpdateWrapper<OutboundItem>().lambda()
                                    .eq(OutboundItem::getItemId, UUID.fromString(outboundItem.getItemId()))
                    );
                }
                //region  销售订单明细
                if (outboundItemVO.getFromItemId() != null) {
                    //根据id查询
                    OrderItemResponse orderItemResponse = orderItemMapper.selectById(outboundItemVO.getFromItemId());
                    //赋值（这里重写了更新方法，数量在更新方法中有数据库院士数量+本次数量）
                    OrderItem orderItem = new OrderItem();
                    orderItem.setItemId(outboundItemVO.getFromItemId());
                    orderItem.setOutingQty(outboundItemVO.getOutingQty().negate());
                    orderItem.setOutingAmt(outboundItemVO.getOutingAmt().negate());
                    orderItem.setOutQty(outboundItemVO.getOutQty().negate());
                    orderItem.setOutAmt(outboundItemVO.getOutAmt().negate());
                    //出库状态
                    String outStatus = this.setOutStatus(orderItemResponse.getOutingQty().subtract(orderItem.getOutingQty()),
                            orderItemResponse.getOutQty().add(orderItem.getOutQty()), orderItemResponse.getItemQty());
                    orderItem.setOutStatus(outStatus);
                    //修改
                    int countRow = orderItemMapper.updateById(orderItem);
                    //数量超出
                    if (countRow == 0) {
                        throw new BaseBusinessException(ResponseCodeEnum.OPERATE_FAIL.getCode(), ErrorCodeEnum.INVENTORY_QUANTITY_EXCEEDED_OUTBOUND.getMessage());
                    }
                }
                //endregion
            }
        }
        //endregion

        //region 编辑总单
        BigDecimal sumOutQty = outboundVO.getItemList().stream().map(OutboundItemVO::getOutQty).reduce(BigDecimal.ZERO, BigDecimal::add).setScale(6, BigDecimal.ROUND_HALF_UP);
        BigDecimal sumOutAmt = outboundVO.getItemList().stream().map(OutboundItemVO::getOutAmt).reduce(BigDecimal.ZERO, BigDecimal::add).setScale(2, BigDecimal.ROUND_HALF_UP);
        outboundVO.setOutQty(sumOutQty);
        outboundVO.setOutAmt(sumOutAmt);
        outboundVO.setOutingQty(BigDecimal.ZERO);
        outboundVO.setOutingAmt(BigDecimal.ZERO);
        //出库状态
        String outStatus = this.setOutStatus(outboundVO.getOutingQty(), outboundVO.getOutQty());
        outboundVO.setOutStatus(outStatus);
        //实体转换
        Outbound outbound = outboundConvert.convertToPo(outboundVO);
        //修改
        outboundMapper.update(outbound,
                new UpdateWrapper<Outbound>().lambda()
                        .eq(Outbound::getOutId, UUID.fromString(outbound.getOutId()))
        );
        //endregion

        //region  修改销售订单订单
        this.updateOrderMessageByHandle(outboundVO.getItemList(), outboundVO.getDeleteItemList());
        //endregion

        //region  应收记账
        accountService.accReceivable(outboundResponse.getOutId(), Constant.InventoryDocCode.OUTBOUND.getTableName());
        //endregion

        //region 库存明细处理
        if (outboundVO.getItemList() != null && outboundVO.getItemList().size() > 0) {
            Map<String, Object> map = new HashMap<>(); // 定义map值 修改库存用
            // 获取外协数据
            List<OutboundItemVO> outsideGoods = outboundVO.getItemList().stream().filter(it -> it.getSkuId() == null).collect(Collectors.toList());
            //新建外协品生产外协入库单
            this.insertOutsideGoodsInto(outboundVO, outsideGoods);
            // 获取商品明细数据
            List<OutboundItemVO> invList = outboundVO.getItemList().stream().filter(it -> it.getSkuId() != null).collect(Collectors.toList());

            // 赋值修改明细
            map.put("outDetail", invList);
            // 删除的商品
            if (outboundVO.getDeleteItemList() != null && outboundVO.getDeleteItemList().size() > 0) {
                // 获取外协删除数据
                List<OutboundItemVO> invsideDelList = outboundVO.getDeleteItemList().stream().filter(it -> it.getSkuId() == null).collect(Collectors.toList());
                //删除外协品生产外协入库单
                this.deleteOutsideGoodsInto(outboundVO, invsideDelList);
                // 获取删除商品数据
                List<OutboundItemVO> invDelList = outboundVO.getDeleteItemList().stream().filter(it -> it.getSkuId() != null).collect(Collectors.toList());
                // 赋值删除明细
                map.put("delOutDetail", invDelList);
            }
            // 调用修改库存信息方法
            inventoryService.operatingInventoryInformation(map);
        }
        //endregion

        return ResponseResultUtil.success(outboundVO);
    }

    /**
     * @desc : 办理销售出库修改销售订单信息
     * @date : 2024/6/21 15:13
     * @author : 寇珊珊
     */
    @Transactional(rollbackFor = {Exception.class})
    public void updateOrderMessageByHandle(List<OutboundItemVO> itemList, List<OutboundItemVO> deleteItemList) {
        //出库明细汇总
        Map<String, List<OutboundItemVO>> orderOutItemVOListMap = itemList.stream().collect(Collectors.groupingBy(OutboundItemVO::getFromId));
        //出库明细删除汇总
        Map<String, List<OutboundItemVO>> delOrderOutItemVOListMap = deleteItemList.stream().collect(Collectors.groupingBy(OutboundItemVO::getFromId));
        //出库明细汇总循环
        for (String fromId : orderOutItemVOListMap.keySet()) {
            //有需要删除的办理数据
            if (delOrderOutItemVOListMap != null && delOrderOutItemVOListMap.keySet().size() > 0) {
                //出库明细删除汇总循环
                for (String delFromId : delOrderOutItemVOListMap.keySet()) {
                    //新建出库明细来源Id = 删除出库明细来源Id
                    if (fromId.equals(delFromId)) {
                        //region  提取新建分组后的明细
                        List<OutboundItemVO> orderOutItemVOListGroup = orderOutItemVOListMap.get(fromId);
                        //分组后的明细 出库数量和金额总和
                        BigDecimal orderSumQty = orderOutItemVOListGroup.stream().map(OutboundItemVO::getOutQty).reduce(BigDecimal.ZERO, BigDecimal::add).setScale(6, BigDecimal.ROUND_HALF_UP);
                        BigDecimal orderSumAmt = orderOutItemVOListGroup.stream().map(OutboundItemVO::getOutAmt).reduce(BigDecimal.ZERO, BigDecimal::add).setScale(2, BigDecimal.ROUND_HALF_UP);
                        //分组后的明细 原出库数量和金额总和
                        BigDecimal updateOrderOutingQty = orderOutItemVOListGroup.stream().map(OutboundItemVO::getUpdateOrderOutingQty).reduce(BigDecimal.ZERO, BigDecimal::add).setScale(6, BigDecimal.ROUND_HALF_UP);
                        BigDecimal updateOrderOutingAmt = orderOutItemVOListGroup.stream().map(OutboundItemVO::getUpdateOrderOutingAmt).reduce(BigDecimal.ZERO, BigDecimal::add).setScale(2, BigDecimal.ROUND_HALF_UP);
                        //endregion

                        //region 提取删除分组后的明细
                        List<OutboundItemVO> delOrderOutItemVOListGroup = delOrderOutItemVOListMap.get(delFromId);
                        BigDecimal orderDelOutingQty = delOrderOutItemVOListGroup.stream().map(OutboundItemVO::getOutingQty).reduce(BigDecimal.ZERO, BigDecimal::add).setScale(6, BigDecimal.ROUND_HALF_UP);
                        BigDecimal orderDelOutingAmt = delOrderOutItemVOListGroup.stream().map(OutboundItemVO::getOutingAmt).reduce(BigDecimal.ZERO, BigDecimal::add).setScale(2, BigDecimal.ROUND_HALF_UP);
                        BigDecimal orderDelOutQty = delOrderOutItemVOListGroup.stream().map(OutboundItemVO::getOutQty).reduce(BigDecimal.ZERO, BigDecimal::add).setScale(6, BigDecimal.ROUND_HALF_UP);
                        BigDecimal orderDelOutAmt = delOrderOutItemVOListGroup.stream().map(OutboundItemVO::getOutAmt).reduce(BigDecimal.ZERO, BigDecimal::add).setScale(2, BigDecimal.ROUND_HALF_UP);
                        //endregion

                        //region 反写订单数据
                        //根据id查询
                        OrderResponse orderResponse = orderMapper.selectById(fromId);
                        //赋值（这里重写了更新方法，数量在更新方法中有数据库院士数量+本次数量）
                        Order order = new Order();
                        order.setOrderId(fromId);
                        order.setOutQty(orderSumQty.subtract(orderDelOutQty));
                        order.setOutAmt(orderSumAmt.subtract(orderDelOutAmt));
                        order.setOutingQty((updateOrderOutingQty.add(orderDelOutingQty)).negate());
                        order.setOutingAmt((updateOrderOutingAmt.add(orderDelOutingAmt)).negate());
                        //出库状态
                        String orderOutStatus = this.setOutStatus(orderResponse.getOutingQty().subtract(orderSumQty).add(orderDelOutQty),
                                orderResponse.getOutQty().add(order.getOutQty()), orderResponse.getSumQuantity());
                        order.setOutStatus(orderOutStatus);
                        //修改
                        int countRow = orderMapper.updateById(order);
                        //数量超出
                        if (countRow == 0) {
                            throw new BaseBusinessException(ResponseCodeEnum.OPERATE_FAIL.getCode(), ErrorCodeEnum.INVENTORY_QUANTITY_EXCEEDED_OUTBOUND.getMessage());
                        }
                        //endregion
                    }
                }
            }
            //没有需要删除的办理数据
            else {
                //region  提取新建分组后的明细
                List<OutboundItemVO> orderOutItemVOListGroup = orderOutItemVOListMap.get(fromId);
                //分组后的明细 出库数量和金额总和
                BigDecimal orderSumQty = orderOutItemVOListGroup.stream().map(OutboundItemVO::getOutQty).reduce(BigDecimal.ZERO, BigDecimal::add).setScale(6, BigDecimal.ROUND_HALF_UP);
                BigDecimal orderSumAmt = orderOutItemVOListGroup.stream().map(OutboundItemVO::getOutAmt).reduce(BigDecimal.ZERO, BigDecimal::add).setScale(2, BigDecimal.ROUND_HALF_UP);
                //分组后的明细 原出库数量和金额总和
                BigDecimal updateOrderOutingQty = orderOutItemVOListGroup.stream().map(OutboundItemVO::getUpdateOrderOutingQty).reduce(BigDecimal.ZERO, BigDecimal::add).setScale(6, BigDecimal.ROUND_HALF_UP);
                BigDecimal updateOrderOutingAmt = orderOutItemVOListGroup.stream().map(OutboundItemVO::getUpdateOrderOutingAmt).reduce(BigDecimal.ZERO, BigDecimal::add).setScale(2, BigDecimal.ROUND_HALF_UP);
                //endregion

                //region 反写订单数据
                //根据id查询
                OrderResponse orderResponse = orderMapper.selectById(fromId);
                //赋值（这里重写了更新方法，数量在更新方法中有数据库院士数量+本次数量）
                Order order = new Order();
                order.setOrderId(fromId);
                order.setOutQty(orderSumQty);
                order.setOutAmt(orderSumAmt);
                order.setOutingQty(updateOrderOutingQty.negate());
                order.setOutingAmt(updateOrderOutingAmt.negate());
                //出库状态
                String orderOutStatus = this.setOutStatus(orderResponse.getOutingQty().subtract(orderSumQty),
                        orderResponse.getOutQty().add(order.getOutQty()), orderResponse.getSumQuantity());
                order.setOutStatus(orderOutStatus);
                //修改
                int countRow = orderMapper.updateById(order);
                //数量超出
                if (countRow == 0) {
                    throw new BaseBusinessException(ResponseCodeEnum.OPERATE_FAIL.getCode(), ErrorCodeEnum.INVENTORY_QUANTITY_EXCEEDED_OUTBOUND.getMessage());
                }
                //endregion
            }
        }
    }

    /**
     * @desc : 销售出库撤销
     * @date : 2024/3/7 17:06
     * @author : 寇珊珊
     */
    @Transactional(rollbackFor = {Exception.class})
    public ResponseResultVO<?> saleOrderOutboundCancel(OutboundVO outboundVO) {
        //region 查询出库总单数据信息
        OutboundResponse outboundResponse = outboundMapper.selectById(outboundVO.getOutId());
        //endregion

        //region根据总单id查明细
        List<OutboundItemResponse> outboundItemResponseList = outboundItemMapper.selectByCond(new OutboundItemQuery().setOutId(outboundResponse.getOutId()));
        //endregion

        //region    应收反记账
        if (outboundResponse.getReceivableId() != null) {
            accountService.reverseReceivable(outboundResponse.getOutId(), Constant.InventoryDocCode.OUTBOUND.getTableName());
        }
        //endregion

        //region 修改订单数据信息
        this.updateOrderMessageByCancel(outboundItemResponseList);
        //endregion

        //region 修改总单数据信息
        Outbound outbound = new Outbound();
        outbound.setOutId(outboundResponse.getOutId());
        outbound.setOutDate(null);
        outbound.setOutStatus(Constant.OutStatus.CHUKUZHONG.getName());
        outbound.setOutQty(BigDecimal.ZERO);
        outbound.setOutAmt(BigDecimal.ZERO);
        outbound.setOutingQty(outboundResponse.getOutingQty().add(outboundResponse.getOutQty()));
        outbound.setOutingAmt(outboundResponse.getOutingAmt().add(outboundResponse.getOutAmt()));
        //修改
        outboundMapper.update(outbound,
                new UpdateWrapper<Outbound>().lambda()
                        .eq(Outbound::getOutId, UUID.fromString(outbound.getOutId()))
        );
        //endregion

        //region 明细数据
        for (OutboundItemResponse outboundItemResponse : outboundItemResponseList) {
            //region 修改销售订单明细数据信息
            if (outboundItemResponse.getFromItemId() != null) {
                //根据id查询
                OrderItemResponse orderItemResponse = orderItemMapper.selectById(outboundItemResponse.getFromItemId());
                //赋值  （这里重写了更新方法，数量在更新方法中有数据库院士数量+本次数量）
                OrderItem orderItem = new OrderItem();
                orderItem.setItemId(outboundItemResponse.getFromItemId());
                orderItem.setOutQty(outboundItemResponse.getOutQty().negate());
                orderItem.setOutAmt(outboundItemResponse.getOutAmt().negate());
                orderItem.setOutingQty(outboundItemResponse.getOutQty());
                orderItem.setOutingAmt(outboundItemResponse.getOutAmt());
                //出库状态
                String outStatus = this.setOutStatus(orderItemResponse.getOutingQty().add(orderItem.getOutingQty()),
                        orderItemResponse.getOutQty().add(orderItem.getOutQty()), orderItemResponse.getItemQty());
                orderItem.setOutStatus(outStatus);
                //修改
                int countRow = orderItemMapper.updateById(orderItem);
                //数量超出
                if (countRow == 0) {
                    throw new BaseBusinessException(ResponseCodeEnum.OPERATE_FAIL.getCode(), ErrorCodeEnum.INVENTORY_QUANTITY_EXCEEDED_OUTBOUND.getMessage());
                }
            }
            //endregion

            //region修改出库明细信息
            OutboundItem outboundItem = new OutboundItem();

            //region 将库存需要的参数赋值
            outboundItemResponse.setInventoryType(Constant.InventoryType.OUTBOUND.getName());
            outboundItemResponse.setInventoryDocCode(Constant.InventoryDocCode.SALE_ORDER.getValue());
            outboundItemResponse.setOutQty(outboundItemResponse.getOutQty().negate());
            outboundItemResponse.setOutQty(outboundItemResponse.getOutQty().negate());
            //endregion

            outboundItem
                    .setOutId(outboundResponse.getOutId())
                    .setOutStatus(Constant.OutStatus.CHUKUZHONG.getName())
                    .setOutingQty(outboundItemResponse.getOutingQty().add(outboundItemResponse.getOutQty()))
                    .setOutAmt(outboundItemResponse.getOutingAmt().add(outboundItemResponse.getOutAmt()))
                    .setOutQty(BigDecimal.ZERO)
                    .setOutAmt(BigDecimal.ZERO)
                    .setCostPrice(BigDecimal.ZERO)
                    .setCostAmt(BigDecimal.ZERO)
                    .setItemId(outboundItemResponse.getItemId());
            //修改
            outboundItemMapper.update(outboundItem,
                    new UpdateWrapper<OutboundItem>().lambda()
                            .eq(OutboundItem::getItemId, UUID.fromString(outboundItem.getItemId()))
            );
            //endregion
        }
        //endregion

        //region 外协品新建外协入库单
        //筛选出skuId为空的 走外协品逻辑
        OutboundVO outsideGoodVO = outboundConvert.convertResToVO(outboundResponse);
        List<OutboundItemResponse> outsideGoods = outboundItemResponseList.stream().filter(it -> it.getSkuId() == null).collect(Collectors.toList());
        List<OutboundItemVO> outsideGoodsVOList = outboundItemConvert.convertResListToVOList(outsideGoods);
        //删除外协品生产外协入库单
        this.deleteOutsideGoodsInto(outsideGoodVO, outsideGoodsVOList);
        //endregion

        //region   调用库存
        //筛选出skuId不为空的 走库存
        List<OutboundItemResponse> invList = outboundItemResponseList.stream().filter(it -> it.getSkuId() != null).collect(Collectors.toList());
        if (invList != null && invList.size() > 0) {
            Map<String, Object> map = new HashMap<>();
            map.put("delOutDetail", invList);
            inventoryService.operatingInventoryInformation(map);
        }
        //endregion

        return ResponseResultUtil.success();
    }

    /**
     * @desc : 撤销销售出库修改销售订单信息
     * @date : 2024/6/21 16:00
     * @author : 寇珊珊
     */
    @Transactional(rollbackFor = {Exception.class})
    public void updateOrderMessageByCancel(List<OutboundItemResponse> itemList) {
        //出库明细汇总
        Map<String, List<OutboundItemResponse>> orderOutItemListMap = itemList.stream().collect(Collectors.groupingBy(OutboundItemResponse::getFromId));
        //出库明细汇总循环
        for (String fromId : orderOutItemListMap.keySet()) {

            //region  提取新建分组后的明细
            List<OutboundItemResponse> orderOutItemListGroup = orderOutItemListMap.get(fromId);
            //分组后的明细 出库数量和金额总和
            BigDecimal orderSumQty = orderOutItemListGroup.stream().map(OutboundItemResponse::getOutQty).reduce(BigDecimal.ZERO, BigDecimal::add).setScale(6, BigDecimal.ROUND_HALF_UP);
            BigDecimal orderSumAmt = orderOutItemListGroup.stream().map(OutboundItemResponse::getOutAmt).reduce(BigDecimal.ZERO, BigDecimal::add).setScale(2, BigDecimal.ROUND_HALF_UP);
            //endregion

            //region  反写订单数据
            //根据id查询
            OrderResponse orderResponse = orderMapper.selectById(fromId);
            Order order = new Order();
            order.setOrderId(fromId);
            order.setOutingQty(orderSumQty);
            order.setOutingAmt(orderSumAmt);
            order.setOutQty(orderSumAmt.negate());
            order.setOutAmt(orderSumAmt.negate());
            //出库状态
            String outStatus = this.setOutStatus(orderResponse.getOutingQty().add(order.getOutingQty()),
                    orderResponse.getOutQty().add(order.getOutQty()), orderResponse.getSumQuantity());
            order.setOutStatus(outStatus);
            //修改
            int countRow = orderMapper.updateById(order);
            //数量超出
            if (countRow == 0) {
                throw new BaseBusinessException(ResponseCodeEnum.OPERATE_FAIL.getCode(), ErrorCodeEnum.INVENTORY_QUANTITY_EXCEEDED_OUTBOUND.getMessage());
            }
            //endregion
        }
    }

    /**
     * @desc : 出库状态通用（目前本页面）
     * @date : 2024/3/9 8:59
     * @author : 寇珊珊
     */
    @Transactional(rollbackFor = {Exception.class})
    public String setOutStatus(BigDecimal outingQty, BigDecimal outQty) {
        //出库状态
        String outStatus = null;
        //已出库数量>0 出库中数量>0
        if (outQty.compareTo(BigDecimal.ZERO) >= 0 && outingQty.compareTo(BigDecimal.ZERO) > 0) {
            //出库中
            outStatus = Constant.OutStatus.CHUKUZHONG.getName();
        }
        //出入库数量=0 出库中数量=0
        else if (outQty.compareTo(BigDecimal.ZERO) == 0 && outingQty.compareTo(BigDecimal.ZERO) == 0) {
            //待出库
            outStatus = Constant.OutStatus.DAICHUKU.getName();
        }
        //已出库数量>0 出库中数量=0
        else if (outQty.compareTo(BigDecimal.ZERO) > 0 && outingQty.compareTo(BigDecimal.ZERO) == 0) {
            //已出库
            outStatus = Constant.OutStatus.YICHUKU.getName();
        }
        return outStatus;
    }

    /**
     * @desc : 上游单据入库状态通用（目前本页面）
     * @date : 2024/4/1 17:14
     * @author : 寇珊珊
     */
    @Transactional(rollbackFor = {Exception.class})
    public String setOutStatus(BigDecimal intoingQty, BigDecimal intoQty, BigDecimal sumQty) {
        //出库状态
        String outStatus = null;
        //出库中小于等于总数，已出库小于总数，并且出库中+已出库大于0
        if(intoingQty.compareTo(sumQty)<=0 && intoQty.compareTo(sumQty) < 0  && intoingQty.add(intoQty).compareTo(BigDecimal.ZERO) > 0 ){
            //出库中
            outStatus = Constant.OutStatus.CHUKUZHONG.getName();
        }
        //已出库数量=0 出库中数量=0
        else if (intoQty.compareTo(BigDecimal.ZERO) == 0 && intoingQty.compareTo(BigDecimal.ZERO) == 0) {
            //待出库
            outStatus = Constant.OutStatus.DAICHUKU.getName();
        }
        //出库中+已出库 等于 总数  并且 出库中数量小于等于订单总数量
        else if (intoingQty.compareTo(sumQty) < 0 && intoingQty.add(intoQty).compareTo(sumQty) == 0) {
            //已出库
            outStatus = Constant.OutStatus.YICHUKU.getName();
        }
        return outStatus;
    }

    /**
     * @desc : 获取单据信息（编辑用）
     * @date : 2024/3/16 16:28
     * @author : 寇珊珊
     */
    public ResponseResultVO<?> selectByUpdate(String id) {
        Map<String, Object> dataInfo = new HashMap<>();
        //总单
        OutboundResponse outboundResponse = outboundMapper.selectMessageByOtherQuery(new OutboundQuery().setOutId(id).setOutStatus(Constant.OutStatus.CHUKUZHONG.getName()));
        //单据不存在
        if (outboundResponse == null) {
            throw new BaseBusinessException(ErrorCodeEnum.THERE_ORDER_IS_NOT_CAN_OUTBOUND_QUANTITY.getCode(),
                    ErrorCodeEnum.THERE_ORDER_IS_NOT_CAN_OUTBOUND_QUANTITY.getMessage());
        }
        dataInfo.put("data", outboundResponse);
        // 明细
        List<OutboundItemResponse> outboundItemResponseList = outboundItemMapper.selectByCond(new OutboundItemQuery().setOutId(outboundResponse.getOutId()));
        dataInfo.put("dataItem", outboundItemResponseList);
        return ResponseResultUtil.success(dataInfo);
    }

    /********************************************** 销售出库查询相关方法begin *************************************/
    /**
     * @desc : 一览页销售出库
     * @author : 付斌
     * @date : 2023/1/9 10:40
     */
    @Pagination
    public ResponseResultVO<PageList<OutboundResponse>> selectByCond(OutboundQuery outboundQuery) {
        outboundQuery.setOutType(Constant.OutType.SALE.getName());
        return super.mergeListWithCount(outboundQuery, outboundMapper.selectByCond(outboundQuery),
                outboundMapper.countByCond(outboundQuery));
    }

    /**
     * @desc : 一览页销售出库明细（货物、附件）
     * @author : 付斌
     * @date : 2024-02-28 13:25
     */
    @Pagination
    public ResponseResultVO<Map<String, Object>> selectOutboundInfoById(String id) {
        Map<String, Object> result = new HashMap<>();
        // 商品明细
        List<OutboundItemResponse> outboundItem = outboundItemMapper.selectByCond(new OutboundItemQuery().setOutId(id));
        result.put("outboundItem", outboundItem);

        // 附件
        return ResponseResultUtil.success(result);
    }

    /**
     * @desc : 获取销售出库信息（编辑用）
     * @author : 付斌
     * @date : 2024-03-02 17:27
     */
    public ResponseResultVO<?> getOutboundForUpdate(String id) {
        Map<String, Object> dataInfo = new HashMap<>();
        OutboundResponse outboundResponse = outboundMapper.selectById(id);
        dataInfo.put("data", outboundResponse);

        // 商品明细
        List<OutboundItemResponse> outboundItemResponseList = outboundItemMapper.selectByCondForOutEdit(id);
        dataInfo.put("dataItem", outboundItemResponseList);
        return ResponseResultUtil.success(dataInfo);
    }

    /**
     * @desc : 获取销售出库信息（编辑用，适用于直接新建的出库单）
     * @author : 付斌
     * @date : 2024-03-02 17:27
     */
    public ResponseResultVO<?> getOutboundTogetherForUpdate(String id) {
        Map<String, Object> dataInfo = new HashMap<>();
        OutboundResponse outboundResponse = outboundMapper.selectById(id);
        dataInfo.put("data", outboundResponse);

        // 商品明细
        List<OutboundItemResponse> outboundItemResponseList = outboundItemMapper.selectByCondForOutEditTogether(id);
        dataInfo.put("dataItem", outboundItemResponseList);
        return ResponseResultUtil.success(dataInfo);
    }

    /**
     * @desc : 获取出库信息（新建退货用）
     * @author : 付斌
     * @date : 2024-03-02 17:27
     */
    public ResponseResultVO<?> getOutForReturn(String id) {
        OutboundResponse outboundResponse = outboundMapper.selectByIdForReturn(id);
        List<OutboundItemResponse> outboundItemList = outboundItemMapper.selectByCondForReturn(new OutboundItemQuery().setOutId(id));

        if (outboundItemList != null && outboundItemList.size() > 0) {
            // 求和
            OutboundItemResponse sumEntity = outboundItemList.stream().reduce((x, y) -> {
                OutboundItemResponse item = new OutboundItemResponse();
                item.setOutingQty(x.getOutingQty().add(y.getOutingQty()));
                item.setOutingAmt(x.getOutingAmt().add(y.getOutingAmt()));
                return item;
            }).get();
            outboundResponse.setOutingQty(sumEntity.getOutingQty()).setOutingAmt(sumEntity.getOutingAmt());
        }

        Map<String, Object> dataInfo = new HashMap<>();
        dataInfo.put("data", outboundResponse);
        dataInfo.put("dataItem", outboundItemList);

        return ResponseResultUtil.success(dataInfo);
    }

    /**
     * @desc : 查询出库明细（货物、附件）
     * @author : 付斌
     * @date : 2024-02-28 13:25
     */
    @Pagination
    public ResponseResultVO selectById(String id) {

        OutboundResponse outboundResponse = outboundMapper.selectById(id);
        // 商品明细
        List<OutboundItemResponse> outboundItem = outboundItemMapper.selectByCond(new OutboundItemQuery().setOutId(id));
        outboundResponse.setGoodsList(outboundItem);

        // 附件
        return ResponseResultUtil.success(outboundResponse);
    }
    /********************************************** 销售出库查询相关方法end *************************************/

//    /**
//     * @desc : 条件查询
//     * @date : 2024/3/18 11:20
//     * @author : 寇珊珊
//     */
//    @Pagination
//    public ResponseResultVO<PageList<InboundResponse>> selectByCond(OutboundQuery outboundQuery) {
//        return super.mergeListWithCount(outboundQuery, outboundMapper.selectByCond(outboundQuery),
//                outboundMapper.countByCond(outboundQuery));
//    }
//
//    /**
//     * @desc : 查询明细
//     * @date : 2024/3/15 16:43
//     * @author : 寇珊珊
//     */
//    @Pagination
//    public ResponseResultVO<Map<String, Object>> selectOutBoundSaleOrderItemInfoById(String id) {
//        Map<String, Object> result = new HashMap<>();
//        // 商品明细
//        List<OutboundItemResponse> outboundItemResponseList = outboundItemMapper.selectByCond(new OutboundItemQuery().setOutId(id));
//        result.put("itemList", outboundItemResponseList);
//        // 收款
//
//        // 附件
//        return ResponseResultUtil.success(result);
//    }

    /**
     * @desc : 条件查询(总单带明细)
     * @author : 于继渤
     * @date : 2023/1/9 10:36
     */
    @Pagination
    public ResponseResultVO<PageList<OutboundResponse>> selectByCondDetail(OutboundQuery outboundQuery) {
        return super.mergeListWithCount(outboundQuery, outboundMapper.selectByCondDetail(outboundQuery),
                outboundMapper.countByCondDetail(outboundQuery));
    }

}