Merge branch 'master' of http://10.153.19.25:10101/r/ERP_override

guoyujie

2025-11-20 5fb1f180d0e6eceb83cda226c1daeca3f634e813

 north-glass-erp/src/main/java/com/example/erp/service/mm/FinishedGoodsInventoryService.java

@@ -3,10 +3,14 @@
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.dynamic.datasource.annotation.DS;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.example.erp.dto.mm.FinishedOperateLogDTO;
import com.example.erp.entity.mm.FinishedGoodsInventory;
import com.example.erp.entity.mm.FinishedOperateLog;
import com.example.erp.entity.mm.MaterialInventory;
import com.example.erp.entity.pp.FlowCard;
import com.example.erp.entity.sd.Delivery;
import com.example.erp.entity.sd.DeliveryDetail;
@@ -17,6 +21,7 @@
import com.example.erp.mapper.mm.BasicWarehouseTypeMapper;
import com.example.erp.mapper.mm.FinishedGoodsInventoryMapper;
import com.example.erp.mapper.mm.FinishedOperateLogMapper;
import com.example.erp.mapper.pp.FlowCardMapper;
import com.example.erp.mapper.sd.OrderDetailMapper;
import com.example.erp.mapper.sd.OrderMapper;
import com.example.erp.service.userInfo.LogService;
@@ -28,12 +33,12 @@

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.sql.SQLException;
import java.sql.Wrapper;
import java.sql.SQLOutput;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.*;
import java.util.stream.Collectors;

@Service
@DS("mm")
@@ -49,6 +54,8 @@
    OrderDetailMapper orderDetailMapper;
    @Autowired
    OrderMapper orderMapper;
    @Autowired
    FlowCardMapper flowCardMapper;
    @Autowired
    SysErrorService sysErrorService;
    @Autowired
@@ -71,6 +78,19 @@
        return map;
    }

    public Map<String, Object> getSelectWarehousingApp(String processId) {
        Map<String, Object> map = new HashMap<>();
        FlowCard flowCard=new FlowCard();
        if(processId!=null){
            flowCard.setProcessId(processId.substring(0,14));
            map.put("data", finishedGoodsInventoryMapper.getSelectWarehousing(0, 999999999, flowCard));
            map.put("total", finishedGoodsInventoryMapper.getSelectWarehousingPageTotal(0, 999999999, flowCard));
        }


        return map;
    }

    public String addSelectWarehousing(Map<String,Object> object) {
        String saveState = "true";
        Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();
@@ -86,7 +106,7 @@
            if (object.get("storageRegion") != null) {
                storageRegion = object.get("storageRegion").toString();
            }
            if (object.get("container") != null) {
            if (object.get("container") != null) {//箱号
                container = object.get("container").toString();
            }

@@ -101,6 +121,11 @@
            if (object.get("decValue") != null) {
                decValue = Integer.parseInt(object.get("decValue").toString());
            }
            String createTime = null;
            if(object.get("createTime")!=null){
                createTime =  object.get("createTime").toString();
            }

            Log log = new Log();
            log.setOperator(userName);
            log.setOperatorId(userId);
@@ -111,6 +136,8 @@
            //获取对象集合循环进行新增修改
            List<FlowCard> flowCardlist = JSONArray.parseArray(JSONObject.toJSONString(object.get("flowCard")), FlowCard.class);
            if (!flowCardlist.isEmpty()){
                //删除一年前且发货的订单库存信息
                finishedGoodsInventoryMapper.deleteFinishedGoodsInventoryDate();
                //获取单号
                String oddNumber= orderNumberSetting("入库");
                for (FlowCard flowCards : flowCardlist) {
@@ -118,6 +145,9 @@
                    Integer calculateType=flowCard.getOrder().getCalculateType();
                    double deliveryDetailMoney = 0.0;
                    double deliveryDetailArea = 0.0;
                    if(flowCards.getInventoryQuantity()<=flowCard.getInventoryQuantity()){
                        flowCard.setInventoryQuantity(flowCards.getInventoryQuantity());
                    }
                    BigDecimal getComputeArea= BigDecimal.valueOf(flowCard.getOrderDetail().getComputeArea());
                    BigDecimal getQuantity= BigDecimal.valueOf(flowCard.getInventoryQuantity());
                    BigDecimal getPrice= BigDecimal.valueOf(flowCard.getOrderDetail().getPrice());
@@ -158,8 +188,12 @@


                    //添加出入库记录
                    finishedOperateLogMapper.insertIntFinishedOperateLog(flowCard,userName,oddNumber,container,deliveryDetailMoney,deliveryDetailArea);
                    Integer finishedGoodsInventorycount = finishedGoodsInventoryMapper.findOrderNumberdcount(flowCard.getOrder().getOrderId(),flowCard.getOrderNumber());
                    finishedOperateLogMapper.insertIntFinishedOperateLog(flowCard,userName,oddNumber,container,deliveryDetailMoney,deliveryDetailArea,createTime,getComputeArea.doubleValue());
                    Integer finishedGoodsInventorycount = 0;
                    finishedGoodsInventorycount = finishedGoodsInventoryMapper.findOrderNumberdContainercount(flowCard.getOrder().getOrderId(),flowCard.getOrderNumber(),container);

                    //finishedGoodsInventorycount = finishedGoodsInventoryMapper.findOrderNumberdcount(flowCard.getOrder().getOrderId(),flowCard.getOrderNumber());

                    Integer ordersum = finishedGoodsInventoryMapper.findOrderQuantity(flowCard.getOrder().getOrderId());
                    Integer ordernumbersum = finishedGoodsInventoryMapper.findOrderNumberdsum(flowCard.getOrder().getOrderId());
                    FlowCard flowCard1=finishedGoodsInventoryMapper.findFlowCard(flowCard);
@@ -181,7 +215,7 @@
                                finishedGoodsInventoryMapper.updateOrderWarehousingState(flowCard.getOrder().getOrderId(),2);
                            }
                        } else {
                            if (finishedGoodsInventoryMapper.insertFinishedGoodsInventory(flowCard, storageRegion, remark,container)) {
                            if (finishedGoodsInventoryMapper.insertFinishedGoodsInventory(flowCard, storageRegion, remark,container,getComputeArea.doubleValue())) {
                                //修改流程卡表入库数量
                                finishedGoodsInventoryMapper.updateflowcard(flowCard);
                                //修改订单明细表入库数量
@@ -230,6 +264,14 @@
        Map<String, Object> map = new HashMap<>();
        map.put("data", finishedGoodsInventoryMapper.getSelectDeliveryDetail(offset, pageSize, orderDetail));
        map.put("total", finishedGoodsInventoryMapper.getSelectDeliveryDetailPageTotal(offset, pageSize, orderDetail));
        return map;
    }

    public Map<String, Object> getSelectDeliveryDetailApp() {
        Map<String, Object> map = new HashMap<>();
        OrderDetail orderDetail=new OrderDetail();
        map.put("data", finishedGoodsInventoryMapper.getSelectDeliveryDetail(0, 999999999, orderDetail));
        map.put("total", finishedGoodsInventoryMapper.getSelectDeliveryDetailPageTotal(0, 999999999, orderDetail));
        return map;
    }

@@ -417,7 +459,7 @@
                    //添加领出记录
                    finishedOperateLogMapper.insertFinishedOperateLogTakeOut(orderDetail,userName,oddNumber,operateType,remarks);
                    //修改库存数量
                    finishedGoodsInventoryMapper.updateInventoryquantityOut(orderDetail.getFinishedGoodsInventory().getOrderId(),orderDetail.getFinishedGoodsInventory().getOrderNumber(), Math.toIntExact(orderDetail.getQuantity()));
                    finishedGoodsInventoryMapper.updateInventoryquantityOut(orderDetail.getFinishedGoodsInventory().getOrderId(),orderDetail.getFinishedGoodsInventory().getOrderNumber(), Math.toIntExact(orderDetail.getQuantity()), orderDetail.getDeliveryDetail().getBoxNo());
                    //修改订单明细表数量
                    finishedGoodsInventoryMapper.updateOutOrderNumberConut(orderDetail.getFinishedGoodsInventory().getOrderId(),orderDetail.getFinishedGoodsInventory().getOrderNumber(), Math.toIntExact(orderDetail.getQuantity()));
                    if (Objects.equals(oldordersum, oldordernumbersum)){
@@ -500,7 +542,7 @@
                    //添加领出记录
                    finishedOperateLogMapper.insertFinishedOperateLogRework(orderDetail,userName,oddNumber,operateType,remarks);
                    //修改库存数量
                    finishedGoodsInventoryMapper.updateInventoryquantityOut(orderDetail.getFinishedGoodsInventory().getOrderId(),orderDetail.getFinishedGoodsInventory().getOrderNumber(), Math.toIntExact(orderDetail.getQuantity()));
                    finishedGoodsInventoryMapper.updateInventoryquantityOut(orderDetail.getFinishedGoodsInventory().getOrderId(),orderDetail.getFinishedGoodsInventory().getOrderNumber(), Math.toIntExact(orderDetail.getQuantity()), orderDetail.getDeliveryDetail().getBoxNo());
                    //修改订单明细表数量
                    finishedGoodsInventoryMapper.updateOutOrderNumberConut(orderDetail.getFinishedGoodsInventory().getOrderId(),orderDetail.getFinishedGoodsInventory().getOrderNumber(), Math.toIntExact(orderDetail.getQuantity()));
                    if (Objects.equals(oldordersum, oldordernumbersum)){
@@ -550,13 +592,13 @@
                        //审核修改领出记录
                        finishedOperateLogMapper.updateToExamine(finishedOperateLog,userName,"已审核");
                        //审核修改库存数量
                        finishedGoodsInventoryMapper.updateInventoryInventoryOut(finishedOperateLog.getOrderId(),finishedOperateLog.getOperationNumber(),Math.toIntExact(finishedOperateLog.getQuantity()));
                        finishedGoodsInventoryMapper.updateInventoryInventoryOut(finishedOperateLog.getOrderId(),finishedOperateLog.getOperationNumber(),Math.toIntExact(finishedOperateLog.getQuantity()),finishedOperateLog.getRemarks());
                        log.setFunction("updateFinishedGoodsInventoryToExamine审核");
                    } else if (Objects.equals(type, "反审")) {
                        //审核修改领出记录
                        finishedOperateLogMapper.updateToExamine(finishedOperateLog,userName,"未审核");
                        //审核修改库存数量
                        finishedGoodsInventoryMapper.updateInventoryInventoryInt(finishedOperateLog.getOrderId(),finishedOperateLog.getOperationNumber(),Math.toIntExact(finishedOperateLog.getQuantity()));
                        finishedGoodsInventoryMapper.updateInventoryInventoryInt(finishedOperateLog.getOrderId(),finishedOperateLog.getOperationNumber(),Math.toIntExact(finishedOperateLog.getQuantity()), finishedOperateLog.getRemarks());
                        log.setFunction("updateFinishedGoodsInventoryToExamine反审");
                    }

@@ -721,16 +763,92 @@
            if(order.getWarehousing()!=2){
                List<OrderDetail> orderDetailList=finishedGoodsInventoryMapper.getSelectOrderDetail(orderId);
                for (OrderDetail orderDetail:orderDetailList){
                    FlowCard flowCard  =flowCardMapper.selectOne(
                            new LambdaQueryWrapper<FlowCard>()
                            .eq(FlowCard::getOrderId, orderDetail.getOrderId())
                            .eq(FlowCard::getOrderNumber, orderDetail.getOrderNumber())
                            .groupBy(FlowCard::getOrderId,FlowCard::getOrderNumber));
                    FinishedGoodsInventory finishedGoodsInventory = finishedGoodsInventoryMapper.findOrderNumberd(orderDetail.getOrderId(),orderDetail.getOrderNumber());
                    if(finishedGoodsInventory!=null){
                        finishedOperateLogMapper.updateOrderFinishedOperateLog(orderDetail,userName,oddNumber);
                        //修改库存表入库数量


                    // 计算剩余数量
                    long quantity;
                    if (flowCard != null) {
                        quantity = flowCard.getQuantity() - flowCard.getReceivedQuantity();
                    } else {
                        quantity = orderDetail.getQuantity() - orderDetail.getWarehouseNum();
                    }

                    if (quantity <= 0) continue ;

                    int calculateType=order.getCalculateType();
                    double deliveryDetailMoney = 0.0;
                    double deliveryDetailArea = 0.0;

                    BigDecimal getComputeArea= BigDecimal.valueOf(orderDetail.getComputeArea());
                    BigDecimal getQuantity= BigDecimal.valueOf(quantity);
                    BigDecimal getPrice= BigDecimal.valueOf(orderDetail.getPrice());
                    BigDecimal getWidth= BigDecimal.valueOf(orderDetail.getWidth());
                    BigDecimal getHeight= BigDecimal.valueOf(orderDetail.getHeight());
                    BigDecimal singlePieceArea =getComputeArea.multiply(getQuantity).setScale(2, RoundingMode.HALF_UP)
                            .multiply(getPrice).setScale(2, RoundingMode.HALF_UP);
                    //根据订单计算方式进行金额计算
                    if (calculateType==1){
                        deliveryDetailMoney=singlePieceArea.doubleValue();
                        deliveryDetailArea=getComputeArea.multiply(getQuantity).doubleValue();

                    }else if (calculateType==2){
                        //判断实际单片面积跟结算单片面积是否相等 结算总面积跟实际总面积是否相等
                        if(Objects.equals(orderDetail.getArea(), orderDetail.getComputeArea())&&Objects.equals(orderDetail.getGrossArea(), orderDetail.getComputeGrossArea())){
                            deliveryDetailMoney=getWidth.multiply(getHeight).multiply(getQuantity).divide(BigDecimal.valueOf(1000000), 2, RoundingMode.HALF_UP)
                                    .multiply(getPrice).setScale(2, RoundingMode.HALF_UP).doubleValue();
                            deliveryDetailArea=getWidth.multiply(getHeight).multiply(getQuantity).divide(BigDecimal.valueOf(1000000), 2, RoundingMode.HALF_UP).doubleValue();
                        }else{
                            deliveryDetailMoney=singlePieceArea.doubleValue();
                            deliveryDetailArea=getComputeArea.multiply(getQuantity).doubleValue();
                        }
                    }else if (calculateType==3){
                        deliveryDetailMoney=getQuantity.multiply(getPrice).setScale(2, RoundingMode.HALF_UP).doubleValue();
                        deliveryDetailArea=getComputeArea.multiply(getQuantity).doubleValue();

                    }else if (calculateType==4){
                        //判断实际单片面积跟结算单片面积是否相等 结算总面积跟实际总面积是否相等
                        if(Objects.equals(orderDetail.getArea(), orderDetail.getComputeArea())&&Objects.equals(orderDetail.getGrossArea(), orderDetail.getComputeGrossArea())){
                            deliveryDetailMoney=getWidth.multiply(getHeight).multiply(getQuantity).multiply(getPrice).
                                    divide(BigDecimal.valueOf(1000000), 2, RoundingMode.HALF_UP).doubleValue();
                            deliveryDetailArea=getWidth.multiply(getHeight).multiply(getQuantity).divide(BigDecimal.valueOf(1000000), 2, RoundingMode.HALF_UP).doubleValue();
                        }else{
                            deliveryDetailMoney=getComputeArea.multiply(getQuantity).multiply(getPrice).setScale(2, RoundingMode.HALF_UP).doubleValue();
                            deliveryDetailArea=getComputeArea.multiply(getQuantity).doubleValue();
                        }
                    }

                    // 更新订单明细
                    orderDetail.setQuantity(quantity);
                    orderDetail.setGrossAmount(deliveryDetailMoney);
                    orderDetail.setComputeGrossArea(deliveryDetailArea);

                    // 更新库存
                    if (finishedGoodsInventory != null) {
                        finishedGoodsInventoryMapper.updateOrderInventory(orderDetail);
                    }else{
                    } else {
                        finishedGoodsInventoryMapper.insertOrderFinishedGoodsInventory(orderDetail);
                    }
                    finishedOperateLogMapper.insertOrderFinishedOperateLog(orderDetail,userName,oddNumber);
                    finishedGoodsInventoryMapper.updateOrderNumberConut(orderDetail.getOrderId(),orderDetail.getOrderNumber(),orderDetail.getQuantity());

                    // 记录操作日志
                    String processId = flowCard != null ? flowCard.getProcessId() : "";
                    finishedOperateLogMapper.insertOrderFinishedOperateLog(orderDetail, userName, oddNumber, processId);
                    finishedGoodsInventoryMapper.updateOrderNumberConut(orderDetail.getOrderId(), orderDetail.getOrderNumber(), orderDetail.getQuantity());

                    // 更新流程卡
                    if (flowCard != null) {
                        flowCard.setInventoryQuantity((int) quantity);
                        Order order1 = new Order();
                        order1.setOrderId(flowCard.getOrderId());
                        flowCard.setOrder(order1);
                        finishedGoodsInventoryMapper.updateflowcard(flowCard);
                    }

                }
                finishedGoodsInventoryMapper.updateOrderWarehousingState(orderId,2);
            }
@@ -793,6 +911,8 @@
            alias="LC";
        }else if(Objects.equals(type, "返工")){
            alias="FG";
        }else if(Objects.equals(type, "调架")){
            alias="TJ";
        }
        //查询当天的最大数量
        Integer maximum=finishedOperateLogMapper.getmaximum(type);
@@ -854,7 +974,10 @@
                }

                Map<String, Object> itemmap = new HashMap<>();
                itemmap.put("detail", finishedOperateLogMapper.getPrimaryListLimts(finishedOperateLog.getOrderId(),finishedOperateLog.getProcessId(),finishedOperateLog.getRemarks()));
                itemmap.put("detail", finishedOperateLogMapper.getPrimaryListLimts(
                        finishedOperateLog.getOrder().getCustomerId(),
                        finishedOperateLog.getOrder().getProject(),
                        finishedOperateLog.getRemarks()));

                List<Map<String, Object>> detailList = finishedOperateLogMapper.getDetailList2(finishedOperateLog.getOrderId(),finishedOperateLog.getProcessId(),finishedOperateLog.getRemarks());

@@ -895,22 +1018,53 @@
        for (OrderDetail orderDetail : list) {
            //获取单号
            String oddNumber= orderNumberSetting("出库");
            OrderDetail orderDetailNew= finishedGoodsInventoryMapper.findOrderDetailNumberd(orderDetail.getDeliveryDetail().getOrderId(),orderDetail.getDeliveryDetail().getOrderNumber());
            OrderDetail orderDetailNew= finishedGoodsInventoryMapper.
                    findOrderDetailNumberd(
                            orderDetail.getDeliveryDetail().getOrderId(),
                            orderDetail.getDeliveryDetail().getOrderNumber());


            //添加出入库记录
            finishedOperateLogMapper.insertOutFinishedOperateLog(orderDetail,userName,oddNumber);
            Integer finishedGoodsInventorycount = finishedGoodsInventoryMapper.findOrderNumberdcount(orderDetail.getDeliveryDetail().getOrderId(),orderDetail.getDeliveryDetail().getOrderNumber());
            finishedOperateLogMapper.insertOutFinishedOperateLog(orderDetail,userName,oddNumber,orderDetail.getDeliveryDetail().getBoxNo());
            orderDetailMapper.update(null,
                    new UpdateWrapper<OrderDetail>()
                            .setSql("out_stock_num = ifnull(out_stock_num,0)+"+orderDetail.getDeliveryDetail().getQuantity())
                            .eq("order_id",orderDetail.getDeliveryDetail().getOrderId())
                            .eq("order_number",orderDetail.getDeliveryDetail().getOrderNumber())
            );
            //判断发货单的库存是否存在
            Integer finishedGoodsInventorycount = finishedGoodsInventoryMapper.findOrderNumberdcount(orderDetail.getDeliveryDetail().getOrderId(),orderDetail.getDeliveryDetail().getOrderNumber(),orderDetail.getDeliveryDetail().getBoxNo());


            //获取订单总数量
            Integer ordersum = finishedGoodsInventoryMapper.findOrderQuantity(orderDetail.getDeliveryDetail().getOrderId());
            //获取库存总数量
            Integer orderNumberdsum = finishedGoodsInventoryMapper.findOrderNumberdsum(orderDetail.getDeliveryDetail().getOrderId());
            //获取发货总数量
            Integer orderNumberdDeliverysum = finishedGoodsInventoryMapper.findOrderDeliveryQuantitySum(orderDetail.getDeliveryDetail().getOrderId());

            //获取此发货单 发货总数量
            Integer deliverysum = finishedGoodsInventoryMapper.findDeliveryQuantity(orderDetail.getDeliveryDetail().getDeliveryId());
            //获取已经出库的数量
            Integer deliverydetailsum = finishedGoodsInventoryMapper.findDeliverydetailsum(orderDetail.getDeliveryDetail().getDeliveryId(),0);
            //获取订单已经出库的数量
            OrderDetail orderDetail1  = orderDetailMapper.
                    selectOne(new QueryWrapper<OrderDetail>()
                            .select("ifnull(sum(out_stock_num),0) as out_stock_num")
                            .eq("order_id",orderDetail.getDeliveryDetail().getOrderId())
                    );


            if(deliverydetailsum==null){
                deliverydetailsum=0;
            }

            DeliveryDetail deliveryDetail=finishedGoodsInventoryMapper.findDeliverydetail(orderDetail.getDeliveryDetail().getOrderId(),orderDetail.getDeliveryDetail().getOrderNumber(),orderDetail.getDeliveryDetail().getDeliveryId());
            DeliveryDetail deliveryDetail=finishedGoodsInventoryMapper.
                    findDeliverydetail(orderDetail.getDeliveryDetail().getOrderId(),
                            orderDetail.getDeliveryDetail().getOrderNumber(),
                            orderDetail.getDeliveryDetail().getDeliveryId(),
                            orderDetail.getDeliveryDetail().getBoxNo()

                    );
                    /*System.out.println("订单总数:" + ordersum + "订单库存数：" + orderNumberdsum + "准备出库数量" +
                            orderDetail.getWarehouseNum()+ "发货数量" + orderDetail.getDeliveryDetail().getQuantity()+ "发货总数" +
                            deliverysum+ "已发数量" + deliverydetailsum);*/
@@ -920,9 +1074,9 @@
                if(deliveryDetail==null){
                    if(orderDetailNew.getWarehouseNum()>=orderDetail.getDeliveryDetail().getQuantity()){
                        //修改库存表库存数量
                        finishedGoodsInventoryMapper.updateInventoryInventoryOut(orderDetail.getDeliveryDetail().getOrderId(),orderDetail.getDeliveryDetail().getOrderNumber(),orderDetail.getDeliveryDetail().getQuantity());
                        finishedGoodsInventoryMapper.updateInventoryInventoryOut(orderDetail.getDeliveryDetail().getOrderId(),orderDetail.getDeliveryDetail().getOrderNumber(),orderDetail.getDeliveryDetail().getQuantity(),orderDetail.getDeliveryDetail().getBoxNo());
                        //修改发货明细表状态
                        finishedGoodsInventoryMapper.updateDeliveryDetailState(orderDetail.getDeliveryDetail().getOrderId(),orderDetail.getDeliveryDetail().getOrderNumber(),orderDetail.getDeliveryDetail().getDeliveryId(),0);
                        finishedGoodsInventoryMapper.updateDeliveryDetailState(orderDetail.getDeliveryDetail().getOrderId(),orderDetail.getDeliveryDetail().getOrderNumber(),orderDetail.getDeliveryDetail().getDeliveryId(),0, orderDetail.getDeliveryDetail().getBoxNo());
                        //修改发货表状态
                        finishedGoodsInventoryMapper.updateDeliveryDeliveryState(orderDetail.getDeliveryDetail().getDeliveryId(),1);
                        //修改订单明细表发货数量
@@ -930,10 +1084,11 @@
                        //修改订单表发货状态
                        finishedGoodsInventoryMapper.updateOrderDeliveryState(orderDetail.getDeliveryDetail().getOrderId(),1);
                        //判断订单是否全部发货
                        if (Objects.equals(orderNumberdsum, orderDetail.getWarehouseNum())) {
                        if (Objects.equals(ordersum, orderDetail1.getOutStockNum())) {
                            //if (ordersum == (orderDeliveryQuantitySum + orderDetail.getWarehouseNum())) {
                            //修改订单表发货状态
                            finishedGoodsInventoryMapper.updateOrderDeliveryState(orderDetail.getDeliveryDetail().getOrderId(),2);
                            finishedGoodsInventoryMapper.
                                    updateOrderDeliveryState(orderDetail.getDeliveryDetail().getOrderId(),2);
                        }
                        if (deliverysum==deliverydetailsum+orderDetail.getDeliveryDetail().getQuantity()) {
                            //修改发货表状态
@@ -966,9 +1121,80 @@

            if(Objects.equals(finishedOperateLog.getOperateType(), "入库")){
                Delivery delivery = finishedGoodsInventoryMapper.findOrderDelivery(finishedOperateLog.getOrderId());
                if(delivery==null){
                FinishedGoodsInventory existFinishedGoodsInventory = finishedGoodsInventoryMapper.
                        selectOne(new LambdaQueryWrapper<FinishedGoodsInventory>()
                                .eq(FinishedGoodsInventory::getOrderId, finishedOperateLog.getOrderId())
                                .eq(FinishedGoodsInventory::getOrderNumber, finishedOperateLog.getOperationNumber())
                                .eq(FinishedGoodsInventory::getBoxNo, finishedOperateLog.getRemarks())
                        );
                /*if(delivery!=null){
                    return "false1";
                }*/
                if(existFinishedGoodsInventory.getQuantityAvailable()<finishedOperateLog.getCancelAvailable()){
                    return "false2";
                }
                    //修改记录表
                    finishedOperateLogMapper.updateFinishedOperateLogState(finishedOperateLog,"已作废");
                    if(existFinishedGoodsInventory.getQuantityAvailable()>finishedOperateLog.getCancelAvailable()
                        && finishedOperateLog.getQuantity()>finishedOperateLog.getCancelAvailable()){

                        Order order=orderMapper.selectOne(new LambdaQueryWrapper<Order>().eq(Order::getOrderId,finishedOperateLog.getOrderId()));
                        OrderDetail orderDetail=orderDetailMapper.selectOne(new LambdaQueryWrapper<OrderDetail>()
                                .eq(OrderDetail::getOrderId,finishedOperateLog.getOrderId())
                                .eq(OrderDetail::getOrderNumber,finishedOperateLog.getOperationNumber())
                        );
                        if(order != null && orderDetail != null){
                            Integer calculateType=order.getCalculateType();
                            double deliveryDetailMoney = 0.0;
                            double deliveryDetailArea = 0.0;

                            BigDecimal getComputeArea= BigDecimal.valueOf(orderDetail.getComputeArea());
                            BigDecimal getQuantity= BigDecimal.valueOf(finishedOperateLog.getCancelAvailable());
                            BigDecimal getPrice= BigDecimal.valueOf(orderDetail.getPrice());
                            BigDecimal getWidth= BigDecimal.valueOf(orderDetail.getWidth());
                            BigDecimal getHeight= BigDecimal.valueOf(orderDetail.getHeight());
                            BigDecimal singlePieceArea =getComputeArea.multiply(getQuantity).setScale(2, RoundingMode.HALF_UP)
                                    .multiply(getPrice).setScale(2, RoundingMode.HALF_UP);
                            //根据订单计算方式进行金额计算
                            if (calculateType==1){
                                deliveryDetailMoney=singlePieceArea.doubleValue();
                                deliveryDetailArea=getComputeArea.multiply(getQuantity).doubleValue();

                            }else if (calculateType==2){
                                //判断实际单片面积跟结算单片面积是否相等 结算总面积跟实际总面积是否相等
                                if(Objects.equals(orderDetail.getArea(), orderDetail.getComputeArea())&&Objects.equals(orderDetail.getGrossArea(), orderDetail.getComputeGrossArea())){
                                    deliveryDetailMoney=getWidth.multiply(getHeight).multiply(getQuantity).divide(BigDecimal.valueOf(1000000), 2, RoundingMode.HALF_UP)
                                            .multiply(getPrice).setScale(2, RoundingMode.HALF_UP).doubleValue();
                                    deliveryDetailArea=getWidth.multiply(getHeight).multiply(getQuantity).divide(BigDecimal.valueOf(1000000), 2, RoundingMode.HALF_UP).doubleValue();
                                }else{
                                    deliveryDetailMoney=singlePieceArea.doubleValue();
                                    deliveryDetailArea=getComputeArea.multiply(getQuantity).doubleValue();
                                }
                            }else if (calculateType==3){
                                deliveryDetailMoney=getQuantity.multiply(getPrice).setScale(2, RoundingMode.HALF_UP).doubleValue();
                                deliveryDetailArea=getComputeArea.multiply(getQuantity).doubleValue();

                            }else if (calculateType==4){
                                //判断实际单片面积跟结算单片面积是否相等 结算总面积跟实际总面积是否相等
                                if(Objects.equals(orderDetail.getArea(), orderDetail.getComputeArea())&&Objects.equals(orderDetail.getGrossArea(), orderDetail.getComputeGrossArea())){
                                    deliveryDetailMoney=getWidth.multiply(getHeight).multiply(getQuantity).multiply(getPrice).
                                            divide(BigDecimal.valueOf(1000000), 2, RoundingMode.HALF_UP).doubleValue();
                                    deliveryDetailArea=getWidth.multiply(getHeight).multiply(getQuantity).divide(BigDecimal.valueOf(1000000), 2, RoundingMode.HALF_UP).doubleValue();
                                }else{
                                    deliveryDetailMoney=getComputeArea.multiply(getQuantity).multiply(getPrice).setScale(2, RoundingMode.HALF_UP).doubleValue();
                                    deliveryDetailArea=getComputeArea.multiply(getQuantity).doubleValue();
                                }
                            }

                            finishedOperateLogMapper.updateFinishedOperateLogQuantity(finishedOperateLog,deliveryDetailMoney,deliveryDetailArea);
                        }else{
                            return "false3";
                        }



                    }else{
                        finishedOperateLogMapper.updateFinishedOperateLogState(finishedOperateLog,"已作废");
                    }
                    //修改库存表入库数量
                    finishedGoodsInventoryMapper.updateInventoryOut(finishedOperateLog);
                    if(finishedOperateLog.getProcessId()!=null){
@@ -977,20 +1203,16 @@
                    }

                    //修改订单明细表入库数量
                    finishedGoodsInventoryMapper.updateOutOrderNumberConut(finishedOperateLog.getOrderId(),finishedOperateLog.getOperationNumber(),finishedOperateLog.getQuantity());
                    //判断订单是否全部入库
                    if (Objects.equals(ordersum, ordernumbersum)) {
                        //修改订单表入库状态
                        finishedGoodsInventoryMapper.updateOrderWarehousingState(finishedOperateLog.getOrderId(),1);
                    }
                    finishedGoodsInventoryMapper.updateOutOrderNumberConut(finishedOperateLog.getOrderId(),finishedOperateLog.getOperationNumber(),finishedOperateLog.getCancelAvailable());

                    //修改订单表入库状态
                    finishedGoodsInventoryMapper.updateOrderWarehousingState(finishedOperateLog.getOrderId(),1);
                    if (ordernumbersum-finishedOperateLog.getQuantity()==0) {
                        //修改订单表入库状态
                        finishedGoodsInventoryMapper.updateOrderWarehousingState(finishedOperateLog.getOrderId(),0);
                    }
                    log.setFunction("cancelFinishedGoodsInventoryStorage入库");
                }else{
                    return "false1";
                }




@@ -998,9 +1220,33 @@
                //修改记录表
                finishedOperateLogMapper.updateFinishedOperateLogState(finishedOperateLog,"已作废");
                //修改库存表库存数量
                finishedGoodsInventoryMapper.updateInventoryInventoryInt(finishedOperateLog.getOrderId(),finishedOperateLog.getOperationNumber(),finishedOperateLog.getQuantity());
                finishedGoodsInventoryMapper.updateInventoryInventoryInt(
                        finishedOperateLog.getOrderId(),
                        finishedOperateLog.getOperationNumber(),
                        finishedOperateLog.getQuantity(),
                        finishedOperateLog.getRemarks()
                );
                //修改订单明细 出库数量
                orderDetailMapper.update(null,
                        new LambdaUpdateWrapper<OrderDetail>().
                                setSql("out_stock_num = ifnull(out_stock_num,0)-"+finishedOperateLog.getQuantity())
                        .eq(OrderDetail::getOrderId, finishedOperateLog.getOrderId())
                        .eq(OrderDetail::getOrderNumber, finishedOperateLog.getOperationNumber())
                );

                OrderDetail orderDetail1  = orderDetailMapper.
                        selectOne(new QueryWrapper<OrderDetail>()
                                .select("ifnull(sum(out_stock_num),0) as out_stock_num")
                                .eq("order_id",finishedOperateLog.getOrderId())
                        );

                //修改发货明细表状态
                finishedGoodsInventoryMapper.updateDeliveryDetailState(finishedOperateLog.getOrderId(),finishedOperateLog.getOperationNumber(),finishedOperateLog.getOperationOrderNumber(),1);
                finishedGoodsInventoryMapper.updateDeliveryDetailState(
                        finishedOperateLog.getOrderId(),
                        finishedOperateLog.getOperationNumber(),
                        finishedOperateLog.getOperationOrderNumber(),
                        1,
                        finishedOperateLog.getRemarks());
                //修改发货表状态
                finishedGoodsInventoryMapper.updateDeliveryDeliveryState(finishedOperateLog.getOperationOrderNumber(),1);
                //修改订单明细表库内数量
@@ -1008,7 +1254,7 @@
                //修改订单表发货状态
                finishedGoodsInventoryMapper.updateOrderDeliveryState(finishedOperateLog.getOrderId(),1);
                //判断订单是否全部发货
                if (ordersum==finishedOperateLog.getQuantity()+ordernumbersum){
                if (orderDetail1.getOutStockNum()==0){
                    //修改订单表发货状态
                    finishedGoodsInventoryMapper.updateOrderDeliveryState(finishedOperateLog.getOrderId(),0);

@@ -1024,4 +1270,197 @@
        }
        return "true";
    }

    public Map<String,Object> changeRack(FinishedGoodsInventory finishedGoodsInventory, String user) {
        Long id = finishedGoodsInventory.getId();
        Map<String,Object> map = new HashMap<>();
        FinishedGoodsInventory oldFinishedGoodsInventory = finishedGoodsInventoryMapper.selectById(finishedGoodsInventory.getId());

        //查询此此序号箱号的库存是否存在
        FinishedGoodsInventory existFinishedGoodsInventory = finishedGoodsInventoryMapper
                .selectOne(new LambdaQueryWrapper<FinishedGoodsInventory>()
                        .eq(FinishedGoodsInventory::getOrderId, finishedGoodsInventory.getOrderId())
                        .eq(FinishedGoodsInventory::getOrderNumber, finishedGoodsInventory.getOrderNumber())
                        .eq(FinishedGoodsInventory::getBoxNo, finishedGoodsInventory.getBoxNo())
                        .last("limit 1")
                );
        String operationOrderNumber = orderNumberSetting("调架");
        FinishedOperateLog finishedOperateLog = new FinishedOperateLog();
        finishedOperateLog.setOperationOrderNumber(operationOrderNumber);
        finishedOperateLog.setOrderId(oldFinishedGoodsInventory.getOrderId());
        finishedOperateLog.setOperationNumber(oldFinishedGoodsInventory.getOrderNumber());
        finishedOperateLog.setProcessId(oldFinishedGoodsInventory.getProcessId());
        finishedOperateLog.setOperateType("调架");
        finishedOperateLog.setOperator(user);
        //当成品箱号不存在，则新增
        if(existFinishedGoodsInventory==null){
            //当转移数量大于实际库存箱号时，则不能转移
            if(oldFinishedGoodsInventory.getQuantityAvailable()<finishedGoodsInventory.getQuantityAvailable()){
                map.put("code",0);
                return map;
            }
            //原库存 数量面积减少
            oldFinishedGoodsInventory.setInventory(oldFinishedGoodsInventory.getInventory()-finishedGoodsInventory.getQuantityAvailable());
            oldFinishedGoodsInventory.setQuantityAvailable(oldFinishedGoodsInventory.getQuantityAvailable()-finishedGoodsInventory.getQuantityAvailable());
            oldFinishedGoodsInventory.setArea(oldFinishedGoodsInventory.getInventory()*oldFinishedGoodsInventory.getActualSignalArea());
            oldFinishedGoodsInventory.setComputeGrossArea(oldFinishedGoodsInventory.getInventory()*oldFinishedGoodsInventory.getComputeArea());

            //新库存数据增加
            finishedGoodsInventory.setId(null);
            finishedGoodsInventory.setInventory(finishedGoodsInventory.getQuantityAvailable());
            finishedGoodsInventory.setArea(finishedGoodsInventory.getQuantityAvailable()*finishedGoodsInventory.getActualSignalArea());
            finishedGoodsInventory.setComputeGrossArea(finishedGoodsInventory.getQuantityAvailable()*finishedGoodsInventory.getComputeArea());
            finishedGoodsInventory.setEnterStorageTime(null);
            finishedGoodsInventoryMapper.
                    update(oldFinishedGoodsInventory,
                            new LambdaUpdateWrapper<FinishedGoodsInventory>()
                                    .eq(FinishedGoodsInventory::getId,id)
                    ) ;
            finishedGoodsInventoryMapper.insert(finishedGoodsInventory);


            //往操作日志表添加数据
            finishedOperateLog.setQuantity(finishedGoodsInventory.getQuantityAvailable());
            finishedOperateLog.setArea(finishedGoodsInventory.getQuantityAvailable()*finishedGoodsInventory.getComputeArea());
            finishedOperateLog.setComputeArea(finishedGoodsInventory.getComputeArea());
            finishedOperateLog.setRemarks(oldFinishedGoodsInventory.getBoxNo()+"->"+finishedGoodsInventory.getBoxNo());
            finishedOperateLogMapper.insert(finishedOperateLog);

            map.put("code",1);
            return map;//库存转移成功，新增箱号

        }else{
            //当id不变时，修改备注
            if(Objects.equals(id, existFinishedGoodsInventory.getId())){
                finishedGoodsInventoryMapper.
                        update(null,new LambdaUpdateWrapper<FinishedGoodsInventory>()
                                .eq(FinishedGoodsInventory::getId,id)
                                .set(FinishedGoodsInventory::getRemark,finishedGoodsInventory.getRemark()));
                map.put("code",2);
                return map;//库存备注修改成功
            }else{
                //原库存 数量面积减少
                oldFinishedGoodsInventory.setInventory(oldFinishedGoodsInventory.getInventory()-finishedGoodsInventory.getQuantityAvailable());
                oldFinishedGoodsInventory.setQuantityAvailable(oldFinishedGoodsInventory.getQuantityAvailable()-finishedGoodsInventory.getQuantityAvailable());
                oldFinishedGoodsInventory.setArea(oldFinishedGoodsInventory.getInventory()*oldFinishedGoodsInventory.getActualSignalArea());
                oldFinishedGoodsInventory.setComputeGrossArea(oldFinishedGoodsInventory.getInventory()*oldFinishedGoodsInventory.getComputeArea());

                existFinishedGoodsInventory.setInventory(existFinishedGoodsInventory.getInventory()+finishedGoodsInventory.getQuantityAvailable());
                existFinishedGoodsInventory.setQuantityAvailable(existFinishedGoodsInventory.getQuantityAvailable()+finishedGoodsInventory.getQuantityAvailable());
                existFinishedGoodsInventory.setArea(existFinishedGoodsInventory.getInventory()*existFinishedGoodsInventory.getActualSignalArea());
                existFinishedGoodsInventory.setComputeGrossArea(existFinishedGoodsInventory.getInventory()*existFinishedGoodsInventory.getComputeArea());

                finishedGoodsInventoryMapper.
                        update(oldFinishedGoodsInventory,
                                new LambdaUpdateWrapper<FinishedGoodsInventory>()
                                        .eq(FinishedGoodsInventory::getId,id)
                        ) ;
                finishedGoodsInventoryMapper.
                        update(existFinishedGoodsInventory,
                                new LambdaUpdateWrapper<FinishedGoodsInventory>()
                                        .eq(FinishedGoodsInventory::getId,existFinishedGoodsInventory.getId())
                        ) ;

                //往操作日志表添加数据
                finishedOperateLog.setQuantity(finishedGoodsInventory.getQuantityAvailable());
                finishedOperateLog.setComputeArea(existFinishedGoodsInventory.getComputeArea());
                finishedOperateLog.setRemarks(oldFinishedGoodsInventory.getBoxNo()+"->"+existFinishedGoodsInventory.getBoxNo());
                finishedOperateLogMapper.insert(finishedOperateLog);

                map.put("code",3);
                List<String> list = new ArrayList<>();
                list.add(oldFinishedGoodsInventory.getBoxNo());
                list.add(existFinishedGoodsInventory.getBoxNo());
                map.put("msg",list);
                return map;//库存转移成功，修改箱号
            }
        }
    }

    public Map<String, Object> getInventoryPrints(List<FinishedGoodsInventory> finishedGoodsInventories) {
        Map<String, Object> map = new HashMap<>();
        List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();//最终结果
        if (!finishedGoodsInventories.isEmpty()) {
            Set<String> processedProcessIds = new HashSet<>();
            for (FinishedGoodsInventory finishedGoodsInventory : finishedGoodsInventories) {
                String orderId = finishedGoodsInventory.getOrderId();
                String boxNo = finishedGoodsInventory.getBoxNo();

                // 检查是否已经处理过该 OrderId，如果处理过则跳过
                if (processedProcessIds.contains(orderId) && processedProcessIds.contains(boxNo)) {
                    continue;
                }

                Map<String, Object> itemmap = new HashMap<>();
                List<Map<String, String>> detail = finishedGoodsInventoryMapper.getPrintTitleByBox(
                        finishedGoodsInventory.getOrder().getCustomerId(),
                        finishedGoodsInventory.getOrder().getProject(),
                        boxNo,
                        orderId
                );

                itemmap.put("detail",detail);
                //获取库存里面此订单此箱号的所有产品信息
                List<Map<String, Object>> detailList = finishedGoodsInventoryMapper
                        .getorderProductByBoxNo(orderId,boxNo);

                List<Map<String, Object>> detailsmaplist = new ArrayList<Map<String, Object>>();

                for(Map<String, Object> details:detailList){
                    Map<String, Object> detailsmap = new HashMap<>();
                    detailsmap.put("product_name",details.get("product_name").toString());
                    //获取明细数据
                    List<Map<String, Object>> orderDetailList = finishedGoodsInventoryMapper
                            .getPrintDetail(
                                    orderId,
                                    boxNo,
                                    Integer.valueOf(details.get("product_id").toString()),
                                    details.get("thickness").toString()
                            );

                    detailsmap.put("detailList",orderDetailList);
                    detailsmaplist.add(detailsmap);

                }
                itemmap.put("detailList", detailsmaplist);
                list.add(itemmap);


                processedProcessIds.add(orderId);
                processedProcessIds.add(boxNo);
            }
        }
        map.put("data", list);
        return map;
    }


    public Map<String, Object> appFinishedGoodsInventoryList() {
        Map<String, Object> map = new HashMap<>();
        Map<String, Object> totalSum  = new HashMap<>();
        Integer inventory = 0;
        Integer quantityAvailable = 0;
        Double area = 0.00;
        Double computeGrossArea = 0.00;

        List<FinishedGoodsInventory> finishedGoodsInventoryList=finishedGoodsInventoryMapper.getFinishedGoodsInventoryList();
        if(!finishedGoodsInventoryList.isEmpty()){
            for(FinishedGoodsInventory finishedGoodsInventory:finishedGoodsInventoryList){
                inventory += finishedGoodsInventory.getInventory();
                quantityAvailable += finishedGoodsInventory.getQuantityAvailable();
                area += finishedGoodsInventory.getArea();
                computeGrossArea+=finishedGoodsInventory.getComputeGrossArea();
            }
            DecimalFormat df = new DecimalFormat("#.00");
            totalSum.put("inventory",inventory);
            totalSum.put("quantityAvailable",quantityAvailable);
            totalSum.put("area", df.format(area));
            totalSum.put("computeGrossArea", df.format(computeGrossArea));

            map.put("data", finishedGoodsInventoryList);
            map.put("total", totalSum);
        }

        return map;
    }
}