yunqueai/ai_dianshang
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

init

Browse Source
This commit is contained in:
sjk
2025-11-17 14:11:46 +08:00
commit ad4a600af9
1659 changed files with 171560 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

417
miniprogram/services/order/orderList.js Normal file
View File

@@ -0,0 +1,417 @@
import { config } from '../../config/index';
/** 获取订单列表mock数据 */
function mockFetchOrders(params) {
console.log('[订单服务] 使用Mock数据获取订单列表', {
params,
timestamp: new Date().toISOString()
});
const { delay } = require('../_utils/delay');
const { genOrders } = require('../../model/order/orderList');
return delay(200).then(() => {
const result = genOrders(params);
console.log('[订单服务] Mock数据生成完成', {
orderCount: result.data?.orders?.length || 0,
totalCount: result.data?.totalCount || 0
});
return result;
});
}
/** 获取订单列表数据 */
export function fetchOrders(statusOrParams, pageNum, pageSize) {
console.log('[订单服务] 开始获取订单列表', {
statusOrParams,
pageNum,
pageSize,
timestamp: new Date().toISOString()
});
// 兼容两种调用方式：
// 1. fetchOrders(params) - 原有方式，params包含parameter对象
// 2. fetchOrders(status, pageNum, pageSize) - 新的调用方式
let requestParams;
if (typeof statusOrParams === 'object' && statusOrParams.parameter) {
// 原有的参数格式
requestParams = {
page: statusOrParams.parameter.pageNum || 1,
page_size: statusOrParams.parameter.pageSize || 20,
status: statusOrParams.parameter.orderStatus
};
console.log('[订单服务] 使用原有参数格式', {
originalParams: statusOrParams,
requestParams
});
if (config.useMock) {
console.log('[订单服务] 使用Mock模式');
return mockFetchOrders(statusOrParams);
}
} else {
// 新的参数格式
requestParams = {
page: pageNum || 1,
page_size: pageSize || 20,
status: statusOrParams || ''
};
console.log('[订单服务] 使用新参数格式', {
status: statusOrParams,
pageNum,
pageSize,
requestParams
});
if (config.useMock) {
console.log('[订单服务] 使用Mock模式');
const mockParams = {
parameter: {
pageNum: pageNum || 1,
pageSize: pageSize || 20,
orderStatus: statusOrParams || -1
}
};
return mockFetchOrders(mockParams);
}
}
console.log('[订单服务] 发送真实API请求', {
url: `${config.apiBase}/orders`,
requestParams,
token: wx.getStorageSync('token') ? '已获取' : '未获取'
});
return new Promise((resolve, reject) => {
wx.request({
url: `${config.apiBase}/orders`,
method: 'GET',
header: {
'Authorization': `Bearer ${wx.getStorageSync('token') || ''}`
},
data: requestParams,
success: (res) => {
console.log('🌐 [订单服务] API响应成功 - 完整响应数据', {
statusCode: res.statusCode,
dataCode: res.data?.code,
orderCount: res.data?.data?.list?.length || 0,
total: res.data?.data?.total || 0,
requestParams,
fullResponse: res,
responseDataStructure: {
hasData: !!res.data,
hasDataData: !!res.data?.data,
hasList: !!res.data?.data?.list,
hasOrders: !!res.data?.data?.orders,
responseKeys: res.data ? Object.keys(res.data) : [],
dataKeys: res.data?.data ? Object.keys(res.data.data) : []
}
});
// 打印原始订单数据
const orderList = res.data?.data?.list || res.data?.data?.orders || [];
if (orderList.length > 0) {
console.log('📦 [订单服务] 原始API订单数据详情', {
totalOrders: orderList.length,
rawOrders: orderList,
orderSummary: orderList.map((order, index) => ({
index,
orderId: order.orderId,
orderNo: order.orderNo,
orderStatus: order.orderStatus,
paymentAmount: order.paymentAmount,
orderItemVOsCount: order.orderItemVOs?.length || 0,
orderKeys: Object.keys(order)
}))
});
}
if (res.statusCode === 200 && res.data.code === 200) {
const rawOrders = res.data.data.list || res.data.data.orders || [];
console.log('[订单服务] 开始处理订单数据', {
rawOrderCount: rawOrders.length
});
// 转换后端数据格式为前端期望的格式
const processedOrderList = rawOrders.map((order, index) => {
console.log(`[订单服务] 处理订单 ${index + 1}:`, {
id: order.orderId || order.id,
orderNo: order.orderNo || order.order_no,
status: order.orderStatus || order.status,
payAmount: order.paymentAmount || order.pay_amount,
itemCount: order.orderItemVOs?.length || order.items?.length || 0
});
return {
id: order.orderId || order.id,
orderId: order.orderId || order.id,
orderNo: order.orderNo || order.order_no,
order_no: order.orderNo || order.order_no,
parentOrderNo: order.orderNo || order.order_no,
storeId: order.storeId || '1',
storeName: order.storeName || '默认店铺',
status: order.orderStatus || order.status,
orderStatus: order.orderStatus || order.status,
statusName: getOrderStatusName(order.orderStatus || order.status),
orderStatusName: getOrderStatusName(order.orderStatus || order.status),
payAmount: order.paymentAmount || order.pay_amount,
pay_amount: order.paymentAmount || order.pay_amount,
paymentAmount: order.paymentAmount || order.pay_amount,
totalAmount: order.totalAmount || order.total_amount,
total_amount: order.totalAmount || order.total_amount,
createdAt: order.createdAt || order.created_at,
created_at: order.createdAt || order.created_at,
createTime: new Date(order.createdAt || order.created_at).getTime(),
receiverName: order.receiverName || order.receiver_name,
receiver_name: order.receiverName || order.receiver_name,
receiverPhone: order.receiverPhone || order.receiver_phone,
receiver_phone: order.receiverPhone || order.receiver_phone,
receiverAddress: order.receiverAddress || order.receiver_address,
receiver_address: order.receiverAddress || order.receiver_address,
logisticsVO: {
logisticsNo: order.logisticsNo || '',
receiverName: order.receiverName || order.receiver_name,
receiverPhone: order.receiverPhone || order.receiver_phone,
receiverAddress: order.receiverAddress || order.receiver_address
},
orderItemVOs: (order.orderItemVOs || order.items || []).map(item => ({
...item,
spec_info: item.spec_info || {},
specInfo: item.spec_info || {},
// 格式化spec_info为显示文本
specText: item.spec_info ? Object.entries(item.spec_info).map(([key, value]) => `${key}: ${value}`).join(', ') : ''
})),
items: (order.orderItemVOs || order.items || []).map(item => ({
...item,
spec_info: item.spec_info || {},
specInfo: item.spec_info || {},
// 格式化spec_info为显示文本
specText: item.spec_info ? Object.entries(item.spec_info).map(([key, value]) => `${key}: ${value}`).join(', ') : ''
})),
buttonVOs: getOrderButtons(order.orderStatus || order.status),
buttons: getOrderButtons(order.orderStatus || order.status)
};
});
console.log('✅ [订单服务] 订单数据处理完成', {
processedOrderCount: processedOrderList.length,
total: res.data.data.total || 0
});
// 打印处理后的订单详情
console.log('🔄 [订单服务] 处理后的订单数据详情', {
processedOrders: processedOrderList.map((order, index) => ({
index,
id: order.id,
orderId: order.orderId,
orderNo: order.orderNo,
status: order.status,
orderStatus: order.orderStatus,
statusName: order.statusName,
payAmount: order.payAmount,
paymentAmount: order.paymentAmount,
totalAmount: order.totalAmount,
receiverName: order.receiverName,
receiverAddress: order.receiverAddress,
orderItemVOsCount: order.orderItemVOs?.length || 0,
itemsCount: order.items?.length || 0,
orderItemVOs: order.orderItemVOs,
items: order.items,
buttons: order.buttons,
buttonVOs: order.buttonVOs,
// 添加spec_info详情
itemsWithSpecInfo: order.items?.map(item => ({
productName: item.product_name || item.productName,
specInfo: item.spec_info,
specText: item.specText
})) || []
}))
});
// 返回兼容两种格式的数据
const result = {
// 新格式 - 使用orders字段供 index.js 使用
orders: processedOrderList,
total: res.data.data.total || 0,
page: requestParams.page,
pageSize: requestParams.page_size,
// 旧格式 - 保持兼容性
list: processedOrderList,
data: {
orders: processedOrderList,
totalCount: res.data.data.total || 0,
pageNum: requestParams.page,
pageSize: requestParams.page_size
}
};
console.log('📤 [订单服务] 返回处理结果 - 完整数据结构', {
ordersCount: result.orders.length,
total: result.total,
page: result.page,
pageSize: result.pageSize,
resultStructure: {
hasOrders: !!result.orders,
hasList: !!result.list,
hasData: !!result.data,
hasDataOrders: !!result.data?.orders,
resultKeys: Object.keys(result),
dataKeys: result.data ? Object.keys(result.data) : []
},
fullResult: result
});
resolve(result);
} else {
const errorMsg = res.data.message || '获取订单列表失败';
console.error('[订单服务] API响应错误', {
statusCode: res.statusCode,
dataCode: res.data?.code,
message: errorMsg,
requestParams
});
reject(new Error(errorMsg));
}
},
fail: (err) => {
console.error('[订单服务] API请求失败', {
error: err,
requestParams,
timestamp: new Date().toISOString()
});
reject(err);
}
});
});
}
// 获取订单状态名称
function getOrderStatusName(status) {
// 与后端order.go中的状态映射保持一致
const statusMap = {
1: '未付款',
2: '待发货', // 统一为待发货
3: '待发货', // 统一为待发货
4: '已发货',
5: '待收货',
6: '已完成',
7: '已取消',
8: '退货中',
9: '已退款'
};
const statusName = statusMap[status] || '未知状态';
console.log('[订单服务] 获取订单状态名称', {
status,
statusName
});
return statusName;
}
// 获取订单按钮
function getOrderButtons(status) {
console.log('[订单服务] ===== 按钮生成开始 =====');
console.log('[订单服务] 输入参数详情', {
status: status,
statusType: typeof status,
statusString: String(status)
});
const buttons = [];
console.log('[订单服务] 开始按状态生成按钮...');
switch (status) {
case 1: // 未付款
console.log('[订单服务] 状态1-未付款: 添加取消订单和立即付款按钮');
buttons.push({ type: 1, name: '取消订单' });
buttons.push({ type: 2, name: '立即付款', primary: true });
break;
case 2: // 已付款
console.log('[订单服务] 状态2-已付款: 添加提醒发货和申请退款按钮');
buttons.push({ type: 3, name: '提醒发货', primary: true });
buttons.push({ type: 5, name: '申请退款' });
break;
case 3: // 待发货
console.log('[订单服务] 状态3-待发货: 添加提醒发货和申请退款按钮');
buttons.push({ type: 3, name: '提醒发货', primary: true });
buttons.push({ type: 5, name: '申请退款' });
break;
case 4: // 已发货
console.log('[订单服务] 状态4-已发货: 添加确认收货按钮 (type=4)');
buttons.push({ type: 4, name: '确认收货', primary: true });
break;
case 5: // 待收货
console.log('[订单服务] 状态5-待收货: 添加确认收货按钮 (type=4)');
buttons.push({ type: 4, name: '确认收货', primary: true });
break;
case 6: // 已完成
console.log('[订单服务] 状态6-已完成: 添加评价按钮 (type=5)');
buttons.push({ type: 5, name: '评价', primary: true });
break;
case 7: // 已取消
console.log('[订单服务] 状态7-已取消: 不添加任何按钮');
break;
case 8: // 已退款
case 9: // 已退款
console.log('[订单服务] 状态8/9-已退款: 不添加任何按钮');
break;
default:
console.log('[订单服务] 未知状态:', status);
break;
}
console.log('[订单服务] ===== 按钮生成完成 =====');
console.log('[订单服务] 最终生成的按钮列表:', {
status: status,
buttonCount: buttons.length,
buttons: buttons.map((btn, index) => ({
index: index,
type: btn.type,
name: btn.name,
primary: btn.primary || false
}))
});
return buttons;
}
/** 获取订单列表mock数据 */
function mockFetchOrdersCount(params) {
console.log('[订单服务] 使用Mock数据获取订单统计', {
params,
timestamp: new Date().toISOString()
});
const { delay } = require('../_utils/delay');
const { genOrdersCount } = require('../../model/order/orderList');
return delay().then(() => {
const result = genOrdersCount(params);
console.log('[订单服务] Mock统计数据生成完成', result);
return result;
});
}
/** 获取订单列表统计 */
export function fetchOrdersCount(params) {
console.log('[订单服务] 开始获取订单统计', {
params,
useMock: config.useMock,
timestamp: new Date().toISOString()
});
if (config.useMock) {
console.log('[订单服务] 使用Mock模式获取统计');
return mockFetchOrdersCount(params);
}
console.log('[订单服务] 使用真实API获取统计（暂未实现）');
return new Promise((resolve) => {
resolve('real api');
});
}