bug1 barcode为空依旧查询报错提示出现报错,

chen.lin

3 天以前 9831ab22d6b82696229849e9935ec15d24c79092

bug1 barcode为空依旧查询报错提示出现报错,

 rsf-admin/src/page/orders/outStock/OutStockPublic.jsx

@@ -73,6 +73,7 @@
    const gridRef = useGridApiRef();
    const [rows, setRows] = useState([]);
    const [fetchRows, setFetchRows] = useState([]);
    const [isLoading, setIsLoading] = useState(false);
    const translate = useTranslate();
    const [rowSelectedIds, setRowSelectedIds] = useState([]);
    const [selectedMatnr, setSelectedMatnr] = useState([]);
@@ -82,29 +83,93 @@
    const [selectedValue, setSelectedValue] = useState({});

    useEffect(() => {
        console.log('useEffect triggered - selectedMatnr:', selectedMatnr, 'fetchRows length:', fetchRows.length);
        if (selectedMatnr.length < 1) {
            console.log('没有选中物料，显示所有数据');
            setRows(fetchRows)
        } else {
            const mas = fetchRows.filter(item => selectedMatnr.includes(item.matnrCode));
            console.log('过滤数据，选中的物料编码:', selectedMatnr);
            const mas = fetchRows.filter(item => {
                const matnrCode = item.matnrCode || item.locItem?.matnrCode;
                const included = selectedMatnr.includes(matnrCode);
                console.log('物料编码:', matnrCode, '是否包含:', included);
                return included;
            });
            console.log('过滤后的数据:', mas);
            setRows(mas)
        }
    }, [selectedMatnr])
    }, [selectedMatnr, fetchRows])


    const ComfirmButton = () => {
        const { selectedIds, data } = useListContext();
        const handleRowClick = () => {
            console.log(selectedIds);
        const handleRowClick = async () => {
            console.log('selectedIds:', selectedIds);
            console.log('data:', data);
            console.log('fetchRows:', fetchRows);
            console.log('isLoading:', isLoading);
            
            if (!selectedIds || selectedIds.length === 0) {
                notify('请先选择物料');
                return;
            }
            
            if (!data || data.length === 0) {
                notify('数据加载中，请稍候');
                return;
            }
            
            const ids = data.filter(item => selectedIds.includes(item.id)).map(item => item.id);
            setRowSelectedIds(ids);
            const mas = data.filter(item => selectedIds.includes(item.id)).map(item => item.matnrCode);
            console.log('selectedMatnr:', mas);
            
            // 检查选中的物料是否已全部出库
            const selectedItems = data.filter(item => selectedIds.includes(item.id));
            const allCompleted = selectedItems.every(item => {
                const remaining = (item.anfme || 0) - (item.workQty || 0);
                return remaining <= 0;
            });
            
            if (allCompleted) {
                notify('选中的物料已全部出库（已出数量 >= 计划出库数），没有可出库的库存数据');
                setSelectedMatnr(mas);
                setRows([]);
                return;
            }
            
            //设置库位信息筛选条件
            setSelectedMatnr(mas);
            
            // 如果 fetchRows 还没有数据，重新加载
            if (!fetchRows || fetchRows.length === 0) {
                console.log('fetchRows为空，重新加载数据');
                notify('正在加载库存数据...');
                // 重新加载数据，getWaveRule 会在加载完成后自动处理 selectedMatnr
                await getWaveRule(formData);
            } else {
                // 如果 fetchRows 有数据，立即过滤显示
                const filteredRows = fetchRows.filter(item => {
                    const matnrCode = item.matnrCode || item.locItem?.matnrCode;
                    return mas.includes(matnrCode);
                });
                console.log('filteredRows:', filteredRows);
                setRows(filteredRows);
                
                // 如果过滤后没有数据，提示用户
                if (filteredRows.length === 0) {
                    notify('选中的物料没有可出库的库存数据，可能已全部出库或库存不足');
                }
            }
        }

        return (
            <Button label="toolbar.confirm" size="medium" onClick={handleRowClick} />
            <Button 
                label="toolbar.confirm" 
                size="medium" 
                onClick={handleRowClick}
                disabled={isLoading}
            />
        )
    };

@@ -135,27 +200,83 @@
    };

    useEffect(() => {
        getWaveRule()
    }, [open])
        if (open && record?.id) {
            // 重置状态，确保数据能正确显示
            setSelectedMatnr([]);
            setRows([]);
            setFetchRows([]);
            setIsLoading(false);
            // 确保 formData 正确初始化
            const initialFormData = { orderId: record.id, waveId: DEFAULT_TYPE };
            setFormData(initialFormData);
            getWaveRule(initialFormData)
        }
    }, [open, record?.id])

    const getWaveRule = async () => {
        if (formData.waveId == null && formData.waveId == undefined) {
    const getWaveRule = async (data = formData) => {
        if (data.waveId == null || data.waveId == undefined) {
            return
        }
        const { data: { code, data, msg } } = await request.post('/outStock/order/getOutTaskItems', { ...formData });
        if (code === 200) {
            // setRows(data)
            setFetchRows(data)
        } else {
            notify(msg);
        if (!data.orderId) {
            return
        }
        setIsLoading(true);
        try {
            const { data: { code, data: responseData, msg } } = await request.post('/outStock/order/getOutTaskItems', { ...data });
            if (code === 200) {
                console.log('API返回的数据:', responseData);
                // 处理返回的数据，确保数据结构正确
                const processedData = (responseData || []).map((item, index) => {
                    // 如果数据有 locItem 嵌套结构，需要展开
                    if (item.locItem) {
                        return {
                            ...item.locItem,
                            id: item.locItem.id || `temp_${index}`,
                            siteNo: item.siteNo,
                            staNos: item.staNos || [],
                            sourceId: item.sourceId,
                            source: item.source
                        };
                    }
                    // 如果数据已经是扁平结构，直接返回
                    return {
                        ...item,
                        id: item.id || `temp_${index}`
                    };
                });
                console.log('处理后的数据:', processedData);
                setFetchRows(processedData);
                
                // 如果返回的数据为空，且用户已选中物料，提示原因
                if (processedData.length === 0 && selectedMatnr.length > 0) {
                    notify('选中的物料已全部出库，没有可出库的库存数据');
                } else if (processedData.length === 0) {
                    notify('当前出库单没有可出库的库存数据，可能所有物料已全部出库');
                }
                // useEffect 会自动根据 selectedMatnr 和 fetchRows 来过滤数据
            } else {
                notify(msg);
            }
        } catch (error) {
            console.error('获取库存数据失败:', error);
            notify('获取库存数据失败，请重试');
        } finally {
            setIsLoading(false);
        }
    }

    const handleChange = (value, name) => {
        setFormData((prevData) => ({
            ...prevData,
            [name]: value
        }));
        setFormData((prevData) => {
            const newData = {
                ...prevData,
                [name]: value
            };
            // 当策略改变时，重新获取数据
            if (name === 'waveId' && value && prevData.orderId) {
                getWaveRule(newData);
            }
            return newData;
        });
    };



 rsf-server/src/main/java/com/vincent/rsf/server/manager/service/impl/OutStockServiceImpl.java

@@ -478,16 +478,28 @@
            if (Objects.isNull(param) || StringUtils.isBlank(param.getLocCode())) {
                continue;
            }
            Loc loc = locService.getOne(new LambdaQueryWrapper<Loc>().eq(Loc::getCode, param.getLocCode()).eq(Loc::getBarcode, param.getBarcode()));
            // 修复：构建库位查询条件，如果barcode为空，只按locCode查询
            LambdaQueryWrapper<Loc> locQueryWrapper = new LambdaQueryWrapper<Loc>()
                    .eq(Loc::getCode, param.getLocCode());
            if (StringUtils.isNotBlank(param.getBarcode())) {
                locQueryWrapper.eq(Loc::getBarcode, param.getBarcode());
            }
            Loc loc = locService.getOne(locQueryWrapper);
            if (!Objects.isNull(loc)) {
                List<LocItem> locItems = new ArrayList<>();
                LocItem locItem = locItemService.getById(param.getId());

                WkOrderItem orderItem = outStockItemService.getOne(new LambdaQueryWrapper<WkOrderItem>()
                // 修复：构建查询条件，先构建基础条件，再根据值是否为空动态添加
                LambdaQueryWrapper<WkOrderItem> orderItemWrapper = new LambdaQueryWrapper<WkOrderItem>()
                        .eq(WkOrderItem::getOrderId, outId)
                        .eq(StringUtils.isNotBlank(locItem.getBatch()), WkOrderItem::getSplrBatch, locItem.getBatch())
                        .eq(StringUtils.isNotBlank(locItem.getFieldsIndex()), WkOrderItem::getFieldsIndex, locItem.getFieldsIndex())
                        .eq(WkOrderItem::getMatnrId, locItem.getMatnrId()));
                        .eq(WkOrderItem::getMatnrId, locItem.getMatnrId());
                if (StringUtils.isNotBlank(locItem.getBatch())) {
                    orderItemWrapper.eq(WkOrderItem::getSplrBatch, locItem.getBatch());
                }
                if (StringUtils.isNotBlank(locItem.getFieldsIndex())) {
                    orderItemWrapper.eq(WkOrderItem::getFieldsIndex, locItem.getFieldsIndex());
                }
                WkOrderItem orderItem = outStockItemService.getOne(orderItemWrapper);

                if (Objects.isNull(orderItem)) {
                    throw new CoolException("单据明细不存在！！");