Browse Source

重写新接口api,添加查询速率

main
User 4 days ago
parent
commit
4b1461ed77
  1. 533
      pages/compare_price/index.js
  2. 292
      pages/goods-detail/goods-detail.js
  3. 114
      utils/api.js

533
pages/compare_price/index.js

@ -130,7 +130,9 @@ Page({
currentGoods: null,
currentSwiperIndex: 0,
currentPage: 1,
hasMore: true
pageSize: 10, // 每页展示10条数据
hasMore: true,
allGoods: [] // 存储所有符合条件的商品
},
onLoad: function (options) {
@ -490,350 +492,283 @@ Page({
loadingMore: page > 1 ? true : false
});
API.getProducts(page, 20, 'all', '')
.then(res => {
console.log('获取商品列表成功:', res);
console.log('选择的种类:', selectedCategory);
console.log('选择的规格:', specWeight);
let filteredGoods = [];
if (res && res.products) {
console.log('原始商品数量:', res.products.length);
// 获取当前商品的唯一标识符
const currentGoodsId = goodsData.productId || goodsData.id || goodsData._id;
console.log('当前商品ID:', currentGoodsId);
// 过滤商品
filteredGoods = res.products.filter(item => {
// 1. 排除当前商品
const itemId = item.productId || item.id || item._id;
if (currentGoodsId && itemId && currentGoodsId === itemId) {
console.log('排除当前商品:', itemId);
return false;
}
// 2. 检查商品状态和价格
if ((item.status !== 'published' && item.status !== 'sold_out') || item.price === null || item.price === undefined) {
return false;
}
// 3. 过滤种类
if (selectedCategory && selectedCategory !== '全部' && item.category !== selectedCategory) {
return false;
}
// 4. 过滤规格
if (specWeight) {
// 检查多个可能存储重量信息的字段
const fieldsToCheck = [
item.specification,
item.grossWeight,
item.weightQuantityData,
item.spec // 检查spec字段
];
let hasMatchingSpec = false;
for (const field of fieldsToCheck) {
if (!field) continue;
if (typeof field === 'string') {
// 处理字符串格式的规格数据
console.log('检查字符串规格:', field, '是否包含', specWeight);
// 处理逗号分隔的规格字符串
const specs = field.split(/[,,、]/).map(s => s.trim());
if (specs.some(spec => spec.includes(specWeight))) {
hasMatchingSpec = true;
break;
}
} else if (Array.isArray(field)) {
// 处理数组格式的规格数据
console.log('检查数组规格:', field);
if (field.some(spec => {
if (typeof spec === 'string') {
console.log('检查数组元素(字符串):', spec, '是否包含', specWeight);
return spec.includes(specWeight);
} else if (typeof spec === 'object') {
// 检查对象格式的规格数据
const specStr = spec.weightSpec || spec.display || spec.spec || '';
console.log('检查数组元素(对象):', specStr, '是否包含', specWeight);
return specStr.includes(specWeight);
}
return false;
})) {
hasMatchingSpec = true;
break;
}
} else if (typeof field === 'object') {
// 处理对象格式的规格数据
console.log('检查对象规格:', field);
const specStr = field.weightSpec || field.display || field.spec || '';
console.log('检查对象规格值:', specStr, '是否包含', specWeight);
if (specStr.includes(specWeight)) {
hasMatchingSpec = true;
break;
}
}
// 如果是第一页,获取所有符合条件的商品
if (page === 1) {
// 使用新的API接口获取相同规格的商品数据
API.getProductsBySpecification(specWeight)
.then(comparisonProducts => {
console.log('获取到的对比商品数据:', comparisonProducts);
console.log('选择的种类:', selectedCategory);
console.log('选择的规格:', specWeight);
let filteredGoods = [];
if (comparisonProducts && Array.isArray(comparisonProducts)) {
console.log('原始商品数量:', comparisonProducts.length);
// 获取当前商品的唯一标识符
const currentGoodsId = goodsData.productId || goodsData.id || goodsData._id;
console.log('当前商品ID:', currentGoodsId);
// 过滤商品
filteredGoods = comparisonProducts.filter(item => {
// 1. 排除当前商品
const itemId = item.productId || item.id || item._id;
if (currentGoodsId && itemId && currentGoodsId === itemId) {
console.log('排除当前商品:', itemId);
return false;
}
// 如果没有找到匹配的规格,尝试进行更宽松的匹配
if (!hasMatchingSpec) {
console.log('尝试更宽松的匹配...');
// 提取规格中的数字部分进行匹配
const weightNum = specWeight.replace(/[^0-9-]/g, '');
console.log('提取的重量数字:', weightNum);
for (const field of fieldsToCheck) {
if (!field) continue;
if (typeof field === 'string') {
console.log('检查字符串字段:', field, '是否包含', weightNum);
if (field.includes(weightNum)) {
hasMatchingSpec = true;
break;
}
} else if (Array.isArray(field)) {
console.log('检查数组字段:', field);
if (field.some(spec => {
const specStr = typeof spec === 'string' ? spec : (spec.weightSpec || spec.display || spec.spec || '');
console.log('检查数组元素:', specStr, '是否包含', weightNum);
return specStr.includes(weightNum);
})) {
hasMatchingSpec = true;
break;
}
} else if (typeof field === 'object') {
console.log('检查对象字段:', field);
const specStr = field.weightSpec || field.display || field.spec || '';
console.log('检查对象字段值:', specStr, '是否包含', weightNum);
if (specStr.includes(weightNum)) {
hasMatchingSpec = true;
break;
}
}
}
// 2. 检查商品状态和价格
if ((item.status !== 'published' && item.status !== 'sold_out') || item.price === null || item.price === undefined) {
return false;
}
if (!hasMatchingSpec) {
// 3. 过滤种类
if (selectedCategory && selectedCategory !== '全部' && item.category !== selectedCategory) {
return false;
}
}
return true;
});
console.log('过滤后的商品数量:', filteredGoods.length);
console.log('过滤后的商品:', filteredGoods);
}
// 处理商品数据
const processedGoods = filteredGoods.map(item => {
// 首先清理 imageUrls 字段(如果存在)
if (item.imageUrls && Array.isArray(item.imageUrls)) {
item.imageUrls = item.imageUrls.map(url => {
return url.trim().replace(/[`]/g, '');
return true;
});
console.log('过滤后的商品数量:', filteredGoods.length);
console.log('过滤后的商品:', filteredGoods);
}
// 使用processMediaUrls函数处理媒体数据
item.mediaItems = processMediaUrls(item.imageUrls);
// 处理商品数据
const processedGoods = filteredGoods.map(item => {
// 首先清理 imageUrls 字段(如果存在)
if (item.imageUrls && Array.isArray(item.imageUrls)) {
item.imageUrls = item.imageUrls.map(url => {
return url.trim().replace(/[`]/g, '');
});
// 确保图片优先显示:将图片类型的媒体项移到数组前面
if (item.mediaItems && item.mediaItems.length > 1) {
const imageItems = item.mediaItems.filter(media => media.type === 'image');
const videoItems = item.mediaItems.filter(media => media.type === 'video');
item.mediaItems = [...imageItems, ...videoItems];
}
}
// 使用processMediaUrls函数处理媒体数据
item.mediaItems = processMediaUrls(item.imageUrls);
// 清理 mediaItems 中的 URL
if (item.mediaItems && Array.isArray(item.mediaItems)) {
item.mediaItems = item.mediaItems.map(media => {
if (media.url) {
// 去除 URL 中的反引号和空格
media.url = media.url.trim().replace(/[`]/g, '');
// 确保媒体类型正确
if (!media.type) {
media.type = isVideoUrl(media.url) ? 'video' : 'image';
}
// 确保图片优先显示:将图片类型的媒体项移到数组前面
if (item.mediaItems && item.mediaItems.length > 1) {
const imageItems = item.mediaItems.filter(media => media.type === 'image');
const videoItems = item.mediaItems.filter(media => media.type === 'video');
item.mediaItems = [...imageItems, ...videoItems];
}
return media;
});
}
}
// 处理商品价格和库存,使用选中规格的价格和库存
if (specWeight) {
if (item.weightQuantityData && Array.isArray(item.weightQuantityData)) {
// 尝试从weightQuantityData中找到对应规格的价格和库存
const matchingSpec = item.weightQuantityData.find(spec => {
if (spec.weightSpec) {
return spec.weightSpec.trim() === specWeight;
// 清理 mediaItems 中的 URL
if (item.mediaItems && Array.isArray(item.mediaItems)) {
item.mediaItems = item.mediaItems.map(media => {
if (media.url) {
// 去除 URL 中的反引号和空格
media.url = media.url.trim().replace(/[`]/g, '');
// 确保媒体类型正确
if (!media.type) {
media.type = isVideoUrl(media.url) ? 'video' : 'image';
}
}
return false;
return media;
});
if (matchingSpec) {
// 确保价格是一个单一的值,而不是多个价格的组合
if (matchingSpec.price) {
item.price = matchingSpec.price;
}
// 确保库存是对应规格的库存
if (matchingSpec.quantity) {
item.specStock = matchingSpec.quantity;
}
// 处理商品价格和库存,使用选中规格的价格和库存
if (specWeight) {
if (item.weightQuantityData && Array.isArray(item.weightQuantityData)) {
// 尝试从weightQuantityData中找到对应规格的价格和库存
const matchingSpec = item.weightQuantityData.find(spec => {
if (spec.weightSpec) {
return spec.weightSpec.trim() === specWeight;
}
return false;
});
if (matchingSpec) {
// 确保价格是一个单一的值,而不是多个价格的组合
if (matchingSpec.price) {
item.price = matchingSpec.price;
}
// 确保库存是对应规格的库存
if (matchingSpec.quantity) {
item.specStock = matchingSpec.quantity;
}
}
}
}
}
// 清理价格字段,确保只显示单一价格
if (item.price) {
// 如果价格是字符串且包含逗号,只取第一个价格
if (typeof item.price === 'string' && item.price.includes(',')) {
item.price = item.price.split(',')[0].trim();
}
// 如果价格是数组,只取第一个价格
if (Array.isArray(item.price)) {
item.price = item.price[0];
// 清理价格字段,确保只显示单一价格
if (item.price) {
// 如果价格是字符串且包含逗号,只取第一个价格
if (typeof item.price === 'string' && item.price.includes(',')) {
item.price = item.price.split(',')[0].trim();
}
// 如果价格是数组,只取第一个价格
if (Array.isArray(item.price)) {
item.price = item.price[0];
}
}
}
// 处理规格信息,将多个净重信息分割成数组
item.processedSpecs = [];
if (item.specification) {
item.processedSpecs = processSpecifications(item.specification);
} else if (item.weightSpec) {
item.processedSpecs = processSpecifications(item.weightSpec);
} else if (item.grossWeight) {
item.processedSpecs = processSpecifications(item.grossWeight);
} else if (selectedSpec) {
item.processedSpecs = processSpecifications(selectedSpec);
}
// 处理库存显示逻辑
// 优先使用对应规格的库存,如果没有则使用默认库存
let quantity = item.specStock || item.quantity || item.minOrder || item.stock || item.inventory || item.availableStock || item.totalAvailable;
// 清理库存字段,确保只显示单一值
if (quantity) {
// 如果库存是字符串且包含逗号,只取第一个库存
if (typeof quantity === 'string' && quantity.includes(',')) {
quantity = quantity.split(',')[0].trim();
}
// 如果库存是数组,只取第一个库存
if (Array.isArray(quantity)) {
quantity = quantity[0];
// 处理规格信息,将多个净重信息分割成数组
item.processedSpecs = [];
if (item.specification) {
item.processedSpecs = processSpecifications(item.specification);
} else if (item.weightSpec) {
item.processedSpecs = processSpecifications(item.weightSpec);
} else if (item.grossWeight) {
item.processedSpecs = processSpecifications(item.grossWeight);
} else if (selectedSpec) {
item.processedSpecs = processSpecifications(selectedSpec);
}
// 转换为数字
quantity = Number(quantity);
}
const totalStock = quantity;
let displayStock;
if (totalStock >= 10000) {
// 库存>=10000时显示"库存充足"
displayStock = '充足';
} else if (totalStock === 0) {
// 库存=0时显示"暂无"
displayStock = '暂无';
} else {
// 其他情况显示具体数字
displayStock = totalStock;
}
// 处理库存显示逻辑
// 优先使用对应规格的库存,如果没有则使用默认库存
let quantity = item.specStock || item.quantity || item.minOrder || item.stock || item.inventory || item.availableStock || item.totalAvailable;
// 更新商品的库存显示
item.totalStock = displayStock;
item.originalTotalStock = totalStock;
// 清理库存字段,确保只显示单一值
if (quantity) {
// 如果库存是字符串且包含逗号,只取第一个库存
if (typeof quantity === 'string' && quantity.includes(',')) {
quantity = quantity.split(',')[0].trim();
}
// 如果库存是数组,只取第一个库存
if (Array.isArray(quantity)) {
quantity = quantity[0];
}
// 转换为数字
quantity = Number(quantity);
}
// 添加当前对比的规格信息
if (specWeight) {
item.currentSpec = specWeight;
}
const totalStock = quantity;
// 处理地区信息,只显示省份
if (item.region) {
// 提取省份信息
const provinceRegex = /^([^省]+省|[^自治区]+自治区|[^直辖市]+直辖市|[^特别行政区]+特别行政区)/;
const match = item.region.match(provinceRegex);
if (match) {
item.region = match[1];
let displayStock;
if (totalStock >= 10000) {
// 库存>=10000时显示"库存充足"
displayStock = '充足';
} else if (totalStock === 0) {
// 库存=0时显示"暂无"
displayStock = '暂无';
} else {
// 其他情况显示具体数字
displayStock = totalStock;
}
}
// 计算单位价格
item.unitPrice = calculateUnitPrice(item.price, item.currentSpec || item.specification || (item.processedSpecs && item.processedSpecs.length > 0 ? item.processedSpecs.join(' | ') : ''));
// 更新商品的库存显示
item.totalStock = displayStock;
item.originalTotalStock = totalStock;
// 计算价格涨幅
if (goodsData.price) {
// 获取当前商品的价格(使用单位价格如果低于10元)
let currentPrice = parseFloat(goodsData.price);
if (goodsData.unitPrice) {
currentPrice = parseFloat(goodsData.unitPrice);
// 添加当前对比的规格信息
if (specWeight) {
item.currentSpec = specWeight;
}
// 获取对比商品的价格(根据规则使用合适的价格)
let itemPrice = parseFloat(item.price);
if (currentPrice >= 10 && item.unitPrice) {
// 如果当前商品价格高于10元,对比商品使用单位价格
itemPrice = parseFloat(item.unitPrice);
} else if (currentPrice < 10 && itemPrice < 10) {
// 如果两者都低于10元,使用原始价格
itemPrice = parseFloat(item.price);
} else if (currentPrice < 10 && itemPrice >= 10) {
// 如果当前商品低于10元,对比商品高于10元,当前商品使用单位价格
currentPrice = parseFloat(goodsData.unitPrice || goodsData.price);
// 处理地区信息,只显示省份
if (item.region) {
// 提取省份信息
const provinceRegex = /^([^省]+省|[^自治区]+自治区|[^直辖市]+直辖市|[^特别行政区]+特别行政区)/;
const match = item.region.match(provinceRegex);
if (match) {
item.region = match[1];
}
}
if (!isNaN(currentPrice) && !isNaN(itemPrice)) {
const priceDiff = itemPrice - currentPrice;
const pricePercent = ((priceDiff / currentPrice) * 100).toFixed(1);
item.priceDiff = priceDiff;
item.pricePercent = pricePercent;
}
}
// 计算单位价格
item.unitPrice = calculateUnitPrice(item.price, item.currentSpec || item.specification || (item.processedSpecs && item.processedSpecs.length > 0 ? item.processedSpecs.join(' | ') : ''));
return item;
});
// 计算价格涨幅
if (goodsData.price) {
// 获取当前商品的价格(使用单位价格如果低于10元)
let currentPrice = parseFloat(goodsData.price);
if (goodsData.unitPrice) {
currentPrice = parseFloat(goodsData.unitPrice);
}
// 获取对比商品的价格(根据规则使用合适的价格)
let itemPrice = parseFloat(item.price);
if (currentPrice >= 10 && item.unitPrice) {
// 如果当前商品价格高于10元,对比商品使用单位价格
itemPrice = parseFloat(item.unitPrice);
} else if (currentPrice < 10 && itemPrice < 10) {
// 如果两者都低于10元,使用原始价格
itemPrice = parseFloat(item.price);
} else if (currentPrice < 10 && itemPrice >= 10) {
// 如果当前商品低于10元,对比商品高于10元,当前商品使用单位价格
currentPrice = parseFloat(goodsData.unitPrice || goodsData.price);
}
if (!isNaN(currentPrice) && !isNaN(itemPrice)) {
const priceDiff = itemPrice - currentPrice;
const pricePercent = ((priceDiff / currentPrice) * 100).toFixed(1);
item.priceDiff = priceDiff;
item.pricePercent = pricePercent;
}
}
// 合并商品数据
const newGoods = page === 1 ? processedGoods : [...this.data.goods, ...processedGoods];
return item;
});
// 检查是否还有更多数据
const hasMore = res && res.products && res.products.length >= 20;
// 存储所有符合条件的商品
this.setData({
allGoods: processedGoods
});
// 设置商品数据
this.setData({
goods: newGoods,
loading: false,
loadingMore: false,
currentPage: page,
hasMore: hasMore,
selectedOption: selectedCategory || '对比价格',
showTips: false
});
// 计算当前页应该显示的商品
const { pageSize } = this.data;
const startIndex = (page - 1) * pageSize;
const endIndex = startIndex + pageSize;
const currentPageGoods = processedGoods.slice(startIndex, endIndex);
// 检查是否还有更多数据
const hasMore = endIndex < processedGoods.length;
// 设置商品数据
this.setData({
goods: currentPageGoods,
loading: false,
loadingMore: false,
currentPage: page,
hasMore: hasMore,
selectedOption: selectedCategory || '对比价格',
showTips: false
});
console.log('对比价格数据加载完成:', newGoods);
console.log('对比价格数据加载完成:', currentPageGoods);
// 如果符合条件的数据少于5条,自动加载更多数据
if (newGoods.length < 5 && hasMore) {
console.log('符合条件的数据少于5条,自动加载更多数据');
this.loadGoodsData(page + 1, selectedCategory, specWeight, goodsData);
} else if (page === 1) {
// 显示提示信息
wx.showToast({
title: `找到${newGoods.length}个符合条件的商品`,
title: `找到${processedGoods.length}个符合条件的商品`,
icon: 'success',
duration: 2000
});
}
})
.catch(err => {
console.error('获取商品列表失败:', err);
this.setData({
loading: false,
loadingMore: false
});
wx.showToast({
title: '获取商品失败,请稍后重试',
icon: 'none'
})
.catch(err => {
console.error('获取商品列表失败:', err);
this.setData({
loading: false,
loadingMore: false
});
wx.showToast({
title: '获取商品失败,请稍后重试',
icon: 'none'
});
});
} else {
// 如果不是第一页,从allGoods中获取数据
const { allGoods, pageSize } = this.data;
const startIndex = (page - 1) * pageSize;
const endIndex = startIndex + pageSize;
const currentPageGoods = allGoods.slice(startIndex, endIndex);
// 检查是否还有更多数据
const hasMore = endIndex < allGoods.length;
// 合并商品数据
const newGoods = [...this.data.goods, ...currentPageGoods];
// 设置商品数据
this.setData({
goods: newGoods,
loading: false,
loadingMore: false,
currentPage: page,
hasMore: hasMore
});
console.log('加载更多数据完成:', currentPageGoods);
}
},
// 加载更多数据

292
pages/goods-detail/goods-detail.js

@ -3861,41 +3861,100 @@ Page({
// 只有一个规格,直接跳转
const selectedSpec = currentSpecifications[0];
// 构建要传递的数据
const goodsData = {
id: currentGoods.id || currentGoods.productId,
name: currentGoods.name || '',
price: currentGoods.price || '',
imageUrls: currentGoods.imageUrls || [],
region: currentGoods.region || '',
weightQuantityData: currentGoods.weightQuantityData || [],
category: selectedCategory,
yolk: currentGoods.yolk || '',
sourceType: currentGoods.sourceType || '',
supplyStatus: currentGoods.supplyStatus || '',
mediaItems: currentGoods.mediaItems || [],
frequency: currentGoods.frequency || 0,
status: currentGoods.status || 'published',
totalStock: currentGoods.totalStock || '充足',
selectedSpec: selectedSpec
};
// 显示加载提示
wx.showLoading({
title: '正在获取对比数据...',
mask: true
});
console.log('准备跳转到对比价格页面,传递的数据:', goodsData);
// 提取规格信息用于查询
const specification = selectedSpec.weightSpec || selectedSpec.display || '';
console.log('准备通过规格查询商品,规格:', specification);
// 跳转到对比价格页面
wx.navigateTo({
url: `/pages/compare_price/index?goodsData=${encodeURIComponent(JSON.stringify(goodsData))}`,
success: function () {
console.log('成功跳转到对比价格页面');
},
fail: function (error) {
console.error('跳转到对比价格页面失败:', error);
wx.showToast({
title: '跳转失败,请稍后重试',
icon: 'none'
// 调用API获取相同规格的商品数据
API.getProductsBySpecification(specification)
.then(comparisonProducts => {
wx.hideLoading();
console.log('获取到的对比商品数据:', comparisonProducts);
// 构建要传递的数据
const goodsData = {
id: currentGoods.id || currentGoods.productId,
name: currentGoods.name || '',
price: currentGoods.price || '',
imageUrls: currentGoods.imageUrls || [],
region: currentGoods.region || '',
weightQuantityData: currentGoods.weightQuantityData || [],
category: selectedCategory,
yolk: currentGoods.yolk || '',
sourceType: currentGoods.sourceType || '',
supplyStatus: currentGoods.supplyStatus || '',
mediaItems: currentGoods.mediaItems || [],
frequency: currentGoods.frequency || 0,
status: currentGoods.status || 'published',
totalStock: currentGoods.totalStock || '充足',
selectedSpec: selectedSpec,
comparisonProducts: comparisonProducts // 添加对比商品数据
};
console.log('准备跳转到对比价格页面,传递的数据:', goodsData);
// 跳转到对比价格页面
wx.navigateTo({
url: `/pages/compare_price/index?goodsData=${encodeURIComponent(JSON.stringify(goodsData))}`,
success: function () {
console.log('成功跳转到对比价格页面');
},
fail: function (error) {
console.error('跳转到对比价格页面失败:', error);
wx.showToast({
title: '跳转失败,请稍后重试',
icon: 'none'
});
}
});
}
});
})
.catch(error => {
wx.hideLoading();
console.error('获取对比商品数据失败:', error);
// 即使获取对比数据失败,也继续跳转到对比价格页面
const goodsData = {
id: currentGoods.id || currentGoods.productId,
name: currentGoods.name || '',
price: currentGoods.price || '',
imageUrls: currentGoods.imageUrls || [],
region: currentGoods.region || '',
weightQuantityData: currentGoods.weightQuantityData || [],
category: selectedCategory,
yolk: currentGoods.yolk || '',
sourceType: currentGoods.sourceType || '',
supplyStatus: currentGoods.supplyStatus || '',
mediaItems: currentGoods.mediaItems || [],
frequency: currentGoods.frequency || 0,
status: currentGoods.status || 'published',
totalStock: currentGoods.totalStock || '充足',
selectedSpec: selectedSpec,
comparisonProducts: [] // 空数组,表示获取失败
};
console.log('获取对比数据失败,准备跳转到对比价格页面,传递的数据:', goodsData);
// 跳转到对比价格页面
wx.navigateTo({
url: `/pages/compare_price/index?goodsData=${encodeURIComponent(JSON.stringify(goodsData))}`,
success: function () {
console.log('成功跳转到对比价格页面');
},
fail: function (error) {
console.error('跳转到对比价格页面失败:', error);
wx.showToast({
title: '跳转失败,请稍后重试',
icon: 'none'
});
}
});
});
} else if (currentSpecifications.length > 1) {
// 存在多个规格,弹出弹窗让用户选择
this.setData({
@ -3924,7 +3983,8 @@ Page({
frequency: currentGoods.frequency || 0,
status: currentGoods.status || 'published',
totalStock: currentGoods.totalStock || '充足',
selectedSpec: null
selectedSpec: null,
comparisonProducts: [] // 空数组,因为没有规格
};
console.log('准备跳转到对比价格页面,传递的数据:', goodsData);
@ -4000,56 +4060,130 @@ Page({
const selectedCategory = this.data.selectedCategory || currentGoods.category || '全部';
const selectedSpec = this.data.selectedSpec;
// 显示提示信息
wx.showToast({
title: `已选择${selectedCategory} ${selectedSpec.display}`,
icon: 'info',
duration: 1500,
success: () => {
setTimeout(() => {
// 关闭弹窗
this.setData({
showCompareModal: false
});
// 显示加载提示
wx.showLoading({
title: '正在获取对比数据...',
mask: true
});
// 构建要传递的数据
const goodsData = {
id: currentGoods.id || currentGoods.productId,
name: currentGoods.name || '',
price: currentGoods.price || '',
imageUrls: currentGoods.imageUrls || [],
region: currentGoods.region || '',
weightQuantityData: currentGoods.weightQuantityData || [],
category: selectedCategory,
yolk: currentGoods.yolk || '',
sourceType: currentGoods.sourceType || '',
supplyStatus: currentGoods.supplyStatus || '',
mediaItems: currentGoods.mediaItems || [],
frequency: currentGoods.frequency || 0,
status: currentGoods.status || 'published',
totalStock: currentGoods.totalStock || '充足',
selectedSpec: selectedSpec
};
// 提取规格信息用于查询
const specification = selectedSpec.weightSpec || selectedSpec.display || '';
console.log('准备通过规格查询商品,规格:', specification);
console.log('准备跳转到对比价格页面,传递的数据:', goodsData);
// 调用API获取相同规格的商品数据
API.getProductsBySpecification(specification)
.then(comparisonProducts => {
wx.hideLoading();
console.log('获取到的对比商品数据:', comparisonProducts);
// 跳转到对比价格页面
wx.navigateTo({
url: `/pages/compare_price/index?goodsData=${encodeURIComponent(JSON.stringify(goodsData))}`,
success: function () {
console.log('成功跳转到对比价格页面');
},
fail: function (error) {
console.error('跳转到对比价格页面失败:', error);
wx.showToast({
title: '跳转失败,请稍后重试',
icon: 'none'
// 显示提示信息
wx.showToast({
title: `已选择${selectedCategory} ${selectedSpec.display}`,
icon: 'info',
duration: 1500,
success: () => {
setTimeout(() => {
// 关闭弹窗
this.setData({
showCompareModal: false
});
}
});
}, 1500);
}
});
// 构建要传递的数据
const goodsData = {
id: currentGoods.id || currentGoods.productId,
name: currentGoods.name || '',
price: currentGoods.price || '',
imageUrls: currentGoods.imageUrls || [],
region: currentGoods.region || '',
weightQuantityData: currentGoods.weightQuantityData || [],
category: selectedCategory,
yolk: currentGoods.yolk || '',
sourceType: currentGoods.sourceType || '',
supplyStatus: currentGoods.supplyStatus || '',
mediaItems: currentGoods.mediaItems || [],
frequency: currentGoods.frequency || 0,
status: currentGoods.status || 'published',
totalStock: currentGoods.totalStock || '充足',
selectedSpec: selectedSpec,
comparisonProducts: comparisonProducts // 添加对比商品数据
};
console.log('准备跳转到对比价格页面,传递的数据:', goodsData);
// 跳转到对比价格页面
wx.navigateTo({
url: `/pages/compare_price/index?goodsData=${encodeURIComponent(JSON.stringify(goodsData))}`,
success: function () {
console.log('成功跳转到对比价格页面');
},
fail: function (error) {
console.error('跳转到对比价格页面失败:', error);
wx.showToast({
title: '跳转失败,请稍后重试',
icon: 'none'
});
}
});
}, 1500);
}
});
})
.catch(error => {
wx.hideLoading();
console.error('获取对比商品数据失败:', error);
// 即使获取对比数据失败,也继续跳转到对比价格页面
wx.showToast({
title: `已选择${selectedCategory} ${selectedSpec.display}`,
icon: 'info',
duration: 1500,
success: () => {
setTimeout(() => {
// 关闭弹窗
this.setData({
showCompareModal: false
});
// 构建要传递的数据
const goodsData = {
id: currentGoods.id || currentGoods.productId,
name: currentGoods.name || '',
price: currentGoods.price || '',
imageUrls: currentGoods.imageUrls || [],
region: currentGoods.region || '',
weightQuantityData: currentGoods.weightQuantityData || [],
category: selectedCategory,
yolk: currentGoods.yolk || '',
sourceType: currentGoods.sourceType || '',
supplyStatus: currentGoods.supplyStatus || '',
mediaItems: currentGoods.mediaItems || [],
frequency: currentGoods.frequency || 0,
status: currentGoods.status || 'published',
totalStock: currentGoods.totalStock || '充足',
selectedSpec: selectedSpec,
comparisonProducts: [] // 空数组,表示获取失败
};
console.log('获取对比数据失败,准备跳转到对比价格页面,传递的数据:', goodsData);
// 跳转到对比价格页面
wx.navigateTo({
url: `/pages/compare_price/index?goodsData=${encodeURIComponent(JSON.stringify(goodsData))}`,
success: function () {
console.log('成功跳转到对比价格页面');
},
fail: function (error) {
console.error('跳转到对比价格页面失败:', error);
wx.showToast({
title: '跳转失败,请稍后重试',
icon: 'none'
});
}
});
}, 1500);
}
});
});
},
// 关闭对比价格弹窗

114
utils/api.js

@ -5056,5 +5056,119 @@ module.exports = {
reject(error);
});
});
},
// 通过规格查找不同规格的数据
getProductsBySpecification: function (specification) {
console.log('API.getProductsBySpecification - specification:', specification);
return new Promise((resolve, reject) => {
// 使用getProducts接口获取所有商品,然后在客户端过滤
this.getProducts(1, 100, 'all', '').then(res => {
console.log('获取商品列表成功:', res);
if (res && res.products) {
// 过滤出具有相同规格的商品
const filteredProducts = res.products.filter(item => {
// 检查多个可能存储重量信息的字段
const fieldsToCheck = [
item.specification,
item.grossWeight,
item.weightQuantityData,
item.spec // 检查spec字段
];
let hasMatchingSpec = false;
for (const field of fieldsToCheck) {
if (!field) continue;
if (typeof field === 'string') {
// 处理字符串格式的规格数据
console.log('检查字符串规格:', field, '是否包含', specification);
// 处理逗号分隔的规格字符串
const specs = field.split(/[,,、]/).map(s => s.trim());
if (specs.some(spec => spec.includes(specification))) {
hasMatchingSpec = true;
break;
}
} else if (Array.isArray(field)) {
// 处理数组格式的规格数据
console.log('检查数组规格:', field);
if (field.some(spec => {
if (typeof spec === 'string') {
console.log('检查数组元素(字符串):', spec, '是否包含', specification);
return spec.includes(specification);
} else if (typeof spec === 'object') {
// 检查对象格式的规格数据
const specStr = spec.weightSpec || spec.display || spec.spec || '';
console.log('检查数组元素(对象):', specStr, '是否包含', specification);
return specStr.includes(specification);
}
return false;
})) {
hasMatchingSpec = true;
break;
}
} else if (typeof field === 'object') {
// 处理对象格式的规格数据
console.log('检查对象规格:', field);
const specStr = field.weightSpec || field.display || field.spec || '';
console.log('检查对象规格值:', specStr, '是否包含', specification);
if (specStr.includes(specification)) {
hasMatchingSpec = true;
break;
}
}
}
// 如果没有找到匹配的规格,尝试进行更宽松的匹配
if (!hasMatchingSpec) {
console.log('尝试更宽松的匹配...');
// 提取规格中的数字部分进行匹配
const weightNum = specification.replace(/[^0-9-]/g, '');
console.log('提取的重量数字:', weightNum);
for (const field of fieldsToCheck) {
if (!field) continue;
if (typeof field === 'string') {
console.log('检查字符串字段:', field, '是否包含', weightNum);
if (field.includes(weightNum)) {
hasMatchingSpec = true;
break;
}
} else if (Array.isArray(field)) {
console.log('检查数组字段:', field);
if (field.some(spec => {
const specStr = typeof spec === 'string' ? spec : (spec.weightSpec || spec.display || spec.spec || '');
console.log('检查数组元素:', specStr, '是否包含', weightNum);
return specStr.includes(weightNum);
})) {
hasMatchingSpec = true;
break;
}
} else if (typeof field === 'object') {
console.log('检查对象字段:', field);
const specStr = field.weightSpec || field.display || field.spec || '';
console.log('检查对象字段值:', specStr, '是否包含', weightNum);
if (specStr.includes(weightNum)) {
hasMatchingSpec = true;
break;
}
}
}
}
return hasMatchingSpec;
});
console.log('过滤后的商品数量:', filteredProducts.length);
console.log('过滤后的商品:', filteredProducts);
resolve(filteredProducts);
} else {
reject(new Error('通过规格查找商品失败'));
}
}).catch(error => {
console.error('通过规格查找商品失败:', error);
reject(new Error('通过规格查找商品失败,请稍后重试'));
});
});
}
};
Loading…
Cancel
Save