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

View File

@@ -0,0 +1,275 @@
import { config } from '../../config/index';
/** 获取售后单mock数据 */
function mockFetchRightsPreview(params) {
console.log('[订单操作服务] 使用Mock数据获取售后预览', {
params,
timestamp: new Date().toISOString()
});
const { delay } = require('../_utils/delay');
const { genRightsPreview } = require('../../model/order/applyService');
return delay().then(() => {
const result = genRightsPreview(params);
console.log('[订单操作服务] Mock售后预览数据生成完成', result);
return result;
});
}
/** 获取售后单数据 */
export function fetchRightsPreview(params) {
console.log('[订单操作服务] 开始获取售后预览', {
params,
useMock: config.useMock,
timestamp: new Date().toISOString()
});
if (config.useMock) {
console.log('[订单操作服务] 使用Mock模式获取售后预览');
return mockFetchRightsPreview(params);
}
console.log('[订单操作服务] 使用真实API获取售后预览暂未实现');
return new Promise((resolve) => {
resolve('real api');
});
}
/** 确认收货 */
export function dispatchConfirmReceived(orderNo) {
console.log('[订单操作服务] 开始确认收货', {
orderNo,
useMock: config.useMock,
timestamp: new Date().toISOString()
});
if (config.useMock) {
console.log('[订单操作服务] 使用Mock模式确认收货');
const { delay } = require('../_utils/delay');
return delay().then(() => {
console.log('[订单操作服务] Mock确认收货完成', { orderNo });
return { success: true, message: '确认收货成功' };
});
}
return new Promise((resolve, reject) => {
const token = wx.getStorageSync('token');
console.log('[订单操作服务] 检查登录状态', {
hasToken: !!token,
orderNo
});
if (!token) {
console.error('[订单操作服务] 用户未登录');
reject(new Error('未登录'));
return;
}
if (!orderNo) {
console.error('[订单操作服务] 缺少订单号');
reject(new Error('缺少订单号'));
return;
}
const requestUrl = `${config.apiBase}/orders/${orderNo}/confirm`;
console.log('[订单操作服务] 发送确认收货API请求', {
url: requestUrl,
orderNo
});
wx.request({
url: requestUrl,
method: 'POST',
header: {
'Authorization': `Bearer ${token}`,
'Content-Type': 'application/json'
},
success: (res) => {
console.log('[订单操作服务] 确认收货API响应', {
statusCode: res.statusCode,
dataCode: res.data?.code,
message: res.data?.message,
orderNo
});
if (res.statusCode === 200 && res.data.code === 200) {
console.log('[订单操作服务] 确认收货成功', { orderNo });
resolve({ success: true, message: '确认收货成功' });
} else {
const errorMsg = res.data?.message || '确认收货失败';
console.error('[订单操作服务] 确认收货失败', {
statusCode: res.statusCode,
dataCode: res.data?.code,
message: errorMsg,
orderNo
});
reject(new Error(errorMsg));
}
},
fail: (err) => {
console.error('[订单操作服务] 确认收货请求失败', {
error: err,
orderNo,
url: requestUrl,
timestamp: new Date().toISOString()
});
reject(new Error('网络请求失败'));
}
});
});
}
/** 获取可选的mock售后原因列表 */
function mockFetchApplyReasonList(params) {
console.log('[订单操作服务] 使用Mock数据获取售后原因列表', {
params,
timestamp: new Date().toISOString()
});
const { delay } = require('../_utils/delay');
const { genApplyReasonList } = require('../../model/order/applyService');
return delay().then(() => {
const result = genApplyReasonList(params);
console.log('[订单操作服务] Mock售后原因列表生成完成', {
reasonCount: result.data?.length || 0
});
return result;
});
}
/** 获取可选的售后原因列表 */
export function fetchApplyReasonList(params) {
console.log('[订单操作服务] 开始获取售后原因列表', {
params,
useMock: config.useMock,
timestamp: new Date().toISOString()
});
if (config.useMock) {
console.log('[订单操作服务] 使用Mock模式获取售后原因列表');
return mockFetchApplyReasonList(params);
}
console.log('[订单操作服务] 使用真实API获取售后原因列表暂未实现');
return new Promise((resolve) => {
resolve('real api');
});
}
/** 发起mock售后申请 */
function mockDispatchApplyService(params) {
console.log('[订单操作服务] 使用Mock数据发起售后申请', {
params,
timestamp: new Date().toISOString()
});
const { delay } = require('../_utils/delay');
const { applyService } = require('../../model/order/applyService');
return delay().then(() => {
const result = applyService(params);
console.log('[订单操作服务] Mock售后申请完成', {
success: result.success,
serviceId: result.data?.serviceId
});
return result;
});
}
/** 发起售后申请 */
export function dispatchApplyService(params) {
console.log('[订单操作服务] 开始发起售后申请', {
params,
useMock: config.useMock,
timestamp: new Date().toISOString()
});
if (config.useMock) {
console.log('[订单操作服务] 使用Mock模式发起售后申请');
return mockDispatchApplyService(params);
}
return new Promise((resolve, reject) => {
const token = wx.getStorageSync('token');
console.log('[订单操作服务] 检查登录状态', {
hasToken: !!token,
orderNo: params.orderNo
});
if (!token) {
console.error('[订单操作服务] 用户未登录');
reject(new Error('未登录'));
return;
}
if (!params.orderNo) {
console.error('[订单操作服务] 缺少订单号', { params });
reject(new Error('缺少订单号'));
return;
}
const requestUrl = `${config.apiBase}/orders/${params.orderNo}/service`;
console.log('[订单操作服务] 发送售后申请API请求', {
url: requestUrl,
orderNo: params.orderNo,
reason: params.reason,
description: params.description
});
wx.request({
url: requestUrl,
method: 'POST',
data: {
reason: params.reason,
description: params.description,
images: params.images || [],
type: params.type || 1 // 1-退款 2-退货退款
},
header: {
'Authorization': `Bearer ${token}`,
'Content-Type': 'application/json'
},
success: (res) => {
console.log('[订单操作服务] 售后申请API响应', {
statusCode: res.statusCode,
dataCode: res.data?.code,
message: res.data?.message,
serviceId: res.data?.data?.serviceId,
orderNo: params.orderNo
});
if (res.statusCode === 200 && res.data.code === 200) {
console.log('[订单操作服务] 售后申请成功', {
orderNo: params.orderNo,
serviceId: res.data.data?.serviceId
});
resolve({
success: true,
message: '售后申请提交成功',
data: res.data.data
});
} else {
const errorMsg = res.data?.message || '售后申请失败';
console.error('[订单操作服务] 售后申请失败', {
statusCode: res.statusCode,
dataCode: res.data?.code,
message: errorMsg,
orderNo: params.orderNo
});
reject(new Error(errorMsg));
}
},
fail: (err) => {
console.error('[订单操作服务] 售后申请请求失败', {
error: err,
orderNo: params.orderNo,
url: requestUrl,
timestamp: new Date().toISOString()
});
reject(new Error('网络请求失败'));
}
});
});
}

View File

@@ -0,0 +1,351 @@
import { config } from '../../config/index';
import { mockIp, mockReqId } from '../../utils/mock';
// 添加日志工具
const logger = {
info: (module, message, data = {}) => {
console.log(`[${module}] ${message}`, data);
},
debug: (module, message, data = {}) => {
console.log(`[DEBUG][${module}] ${message}`, data);
},
error: (module, message, data = {}) => {
console.error(`[ERROR][${module}] ${message}`, data);
},
warn: (module, message, data = {}) => {
console.warn(`[WARN][${module}] ${message}`, data);
}
};
/** 获取结算mock数据 */
function mockFetchSettleDetail(params) {
const { delay } = require('../_utils/delay');
const { genSettleDetail } = require('../../model/order/orderConfirm');
logger.info('ORDER_SETTLE_SERVICE', '使用Mock数据获取结算详情', { params });
return delay().then(() => genSettleDetail(params));
}
/** 提交mock订单 */
function mockDispatchCommitPay() {
const { delay } = require('../_utils/delay');
logger.info('ORDER_SETTLE_SERVICE', '使用Mock数据提交订单');
return delay().then(() => ({
data: {
isSuccess: true,
tradeNo: '350930961469409099',
payInfo: '{}',
code: null,
transactionId: 'E-200915180100299000',
msg: null,
interactId: '15145',
channel: 'wechat',
limitGoodsList: null,
},
code: 'Success',
msg: null,
requestId: mockReqId(),
clientIp: mockIp(),
rt: 891,
success: true,
}));
}
/** 获取结算数据 */
export function fetchSettleDetail(params) {
logger.info('ORDER_SETTLE_SERVICE', '开始获取结算详情', {
useMock: config.useMock,
apiBase: config.apiBase,
params
});
if (config.useMock) {
return mockFetchSettleDetail(params);
}
return new Promise((resolve, reject) => {
const token = wx.getStorageSync('token') || '';
const requestUrl = `${config.apiBase}/orders/settle`;
// 数据类型转换和验证
const processedParams = {
...params,
// 确保userAddressReq中的addressId是数字类型
userAddressReq: params.userAddressReq ? {
...params.userAddressReq,
addressId: params.userAddressReq.addressId ? parseInt(params.userAddressReq.addressId) : undefined
} : null,
// 确保goodsRequestList中的数字字段是正确类型
goodsRequestList: (params.goodsRequestList || []).map(goods => ({
...goods,
quantity: parseInt(goods.quantity) || 0,
price: parseInt(goods.price) || 0,
originPrice: parseInt(goods.originPrice) || 0,
available: parseInt(goods.available) || 0
})),
// 确保couponList中的数字字段是正确类型
couponList: (params.couponList || []).map(coupon => ({
...coupon,
couponId: coupon.couponId ? parseInt(coupon.couponId) : undefined,
userCouponId: coupon.userCouponId ? parseInt(coupon.userCouponId) : undefined,
type: coupon.type ? parseInt(coupon.type) : undefined,
value: coupon.value ? parseInt(coupon.value) : undefined
}))
};
logger.debug('ORDER_SETTLE_SERVICE', '准备发送API请求', {
url: requestUrl,
method: 'POST',
hasToken: !!token,
originalParams: params,
processedParams
});
wx.request({
url: requestUrl,
method: 'POST',
data: processedParams,
header: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${token}`
},
success: (res) => {
logger.info('ORDER_SETTLE_SERVICE', 'API请求成功', {
statusCode: res.statusCode,
data: res.data,
header: res.header
});
if (res.statusCode === 200) {
if (res.data && res.data.code === 200) {
logger.info('ORDER_SETTLE_SERVICE', '结算数据获取成功', { data: res.data.data });
resolve(res.data);
} else {
const errorMsg = res.data?.message || res.data?.msg || '结算失败';
logger.error('ORDER_SETTLE_SERVICE', 'API返回错误', {
code: res.data?.code,
message: errorMsg,
fullResponse: res.data
});
reject(new Error(errorMsg));
}
} else {
logger.error('ORDER_SETTLE_SERVICE', 'HTTP状态码错误', {
statusCode: res.statusCode,
data: res.data
});
reject(new Error(`HTTP ${res.statusCode}: ${res.data?.message || '请求失败'}`));
}
},
fail: (err) => {
logger.error('ORDER_SETTLE_SERVICE', '网络请求失败', {
error: err,
url: requestUrl,
originalParams: params,
processedParams
});
reject(new Error('网络请求失败: ' + (err.errMsg || '未知错误')));
}
});
});
}
/* 提交订单 */
export function dispatchCommitPay(params) {
logger.info('ORDER_SETTLE_SERVICE', '开始提交订单', {
useMock: config.useMock,
params
});
if (config.useMock) {
return mockDispatchCommitPay(params);
}
return new Promise((resolve, reject) => {
// 转换前端参数为后端期望的格式
const addressId = params.addressId ||
(params.userAddressReq && params.userAddressReq.addressId) ||
(params.userAddressReq && params.userAddressReq.id);
logger.debug('ORDER_SETTLE_SERVICE', '地址ID提取调试', {
'params.addressId': params.addressId,
'params.userAddressReq': params.userAddressReq,
'userAddressReq.addressId': params.userAddressReq?.addressId,
'userAddressReq.id': params.userAddressReq?.id,
'extractedAddressId': addressId,
'addressIdType': typeof addressId,
'parsedAddressId': parseInt(addressId),
'isValidNumber': !isNaN(parseInt(addressId))
});
// 处理优惠券ID
console.log('=== dispatchCommitPay 优惠券处理开始 ===');
console.log('- params.couponList:', params.couponList);
console.log('- params.couponList类型:', typeof params.couponList);
console.log('- params.couponList是否为数组:', Array.isArray(params.couponList));
console.log('- params.couponList长度:', params.couponList ? params.couponList.length : 'null/undefined');
console.log('- params.couponList JSON:', JSON.stringify(params.couponList, null, 2));
let couponId = null;
if (params.couponList && params.couponList.length > 0) {
// 取第一个优惠券的ID假设一次只能使用一张优惠券
const firstCoupon = params.couponList[0];
console.log('- 第一张优惠券对象:', firstCoupon);
console.log('- 第一张优惠券JSON:', JSON.stringify(firstCoupon, null, 2));
// 修复应该传递userCouponId用户优惠券表的ID而不是couponId优惠券模板ID
// 这样后端才能正确验证用户权限并获取优惠券信息
couponId = firstCoupon.couponId;
console.log('=== 优惠券ID提取详情 ===');
console.log('- firstCoupon.userCouponId:', firstCoupon.userCouponId);
console.log('- firstCoupon.userCouponId类型:', typeof firstCoupon.userCouponId);
console.log('- firstCoupon.id:', firstCoupon.id);
console.log('- firstCoupon.couponId:', firstCoupon.couponId);
console.log('- 最终提取的couponId:', couponId);
console.log('- 最终couponId类型:', typeof couponId);
console.log('- parseInt(couponId):', parseInt(couponId));
console.log('- parseInt(couponId)类型:', typeof parseInt(couponId));
logger.debug('ORDER_SETTLE_SERVICE', '提取优惠券ID', {
couponList: params.couponList,
firstCoupon,
extractedCouponId: couponId,
idFields: {
userCouponId: firstCoupon.userCouponId,
id: firstCoupon.id,
couponId: firstCoupon.couponId
}
});
} else {
console.log('=== 无优惠券处理 ===');
console.log('- 优惠券列表为空或不存在');
console.log('- couponId将设置为null');
}
console.log('=== 构建orderData ===');
console.log('- couponId值:', couponId);
console.log('- couponId类型:', typeof couponId);
console.log('- couponId是否为null:', couponId === null);
console.log('- couponId是否为undefined:', couponId === undefined);
console.log('- couponId转换为布尔值:', !!couponId);
const parsedCouponId = couponId ? parseInt(couponId) : undefined;
console.log('- parseInt(couponId):', parsedCouponId);
console.log('- parseInt(couponId)类型:', typeof parsedCouponId);
const orderData = {
address_id: parseInt(addressId),
items: params.goodsRequestList.map(goods => ({
product_id: parseInt(goods.spuId),
sku_id: goods.skuId ? parseInt(goods.skuId) : 0,
quantity: goods.quantity,
spec_info: goods.specInfo || {}
})),
remark: params.remark || '',
coupon_id: parsedCouponId
};
console.log('=== orderData构建完成 ===');
console.log('- orderData:', orderData);
console.log('- orderData.coupon_id:', orderData.coupon_id);
console.log('- orderData.coupon_id类型:', typeof orderData.coupon_id);
console.log('- orderData是否包含coupon_id属性:', 'coupon_id' in orderData);
console.log('- orderData JSON字符串:', JSON.stringify(orderData, null, 2));
// 检查JSON序列化后是否包含coupon_id
const jsonString = JSON.stringify(orderData);
console.log('- JSON序列化字符串:', jsonString);
console.log('- JSON中是否包含coupon_id:', jsonString.includes('coupon_id'));
logger.debug('ORDER_SETTLE_SERVICE', '最终订单数据', {
orderData,
'address_id_type': typeof orderData.address_id,
'address_id_value': orderData.address_id,
'coupon_id_value': orderData.coupon_id,
'coupon_id_type': typeof orderData.coupon_id
});
const token = wx.getStorageSync('token') || '';
const requestUrl = `${config.apiBase}/orders`;
logger.debug('ORDER_SETTLE_SERVICE', '准备提交订单API请求', {
url: requestUrl,
orderData,
hasToken: !!token
});
wx.request({
url: requestUrl,
method: 'POST',
data: orderData,
header: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${token}`
},
success: (res) => {
logger.info('ORDER_SETTLE_SERVICE', '订单提交API响应', {
statusCode: res.statusCode,
data: res.data
});
if (res.statusCode === 200 && res.data.code === 200) {
// 转换后端返回数据为前端期望的格式
const result = {
data: {
isSuccess: true,
tradeNo: res.data.data.order_no,
payInfo: '{}',
code: null,
transactionId: res.data.data.order_no,
msg: null,
interactId: res.data.data.id.toString(),
channel: 'wechat',
limitGoodsList: null,
},
code: 'Success',
msg: null,
requestId: Date.now().toString(),
clientIp: '127.0.0.1',
rt: 200,
success: true,
};
logger.info('ORDER_SETTLE_SERVICE', '订单提交成功', { result });
resolve(result);
} else {
const errorMsg = res.data?.message || '订单创建失败';
logger.error('ORDER_SETTLE_SERVICE', '订单提交失败', {
code: res.data?.code,
message: errorMsg,
fullResponse: res.data
});
reject(new Error(errorMsg));
}
},
fail: (err) => {
logger.error('ORDER_SETTLE_SERVICE', '订单提交网络请求失败', {
error: err,
url: requestUrl,
orderData
});
reject(new Error('网络请求失败: ' + (err.errMsg || '未知错误')));
}
});
});
}
/** 开发票 */
export function dispatchSupplementInvoice() {
logger.info('ORDER_SETTLE_SERVICE', '开始开发票', { useMock: config.useMock });
if (config.useMock) {
const { delay } = require('../_utils/delay');
return delay();
}
return new Promise((resolve) => {
resolve('real api');
});
}

View File

@@ -0,0 +1,402 @@
import { config } from '../../config/index';
/** 获取订单详情mock数据 */
function mockFetchOrderDetail(params) {
console.log('[订单详情服务] 使用Mock数据获取订单详情', {
params,
timestamp: new Date().toISOString()
});
const { delay } = require('../_utils/delay');
const { genOrderDetail } = require('../../model/order/orderDetail');
return delay().then(() => {
const result = genOrderDetail(params);
console.log('[订单详情服务] Mock数据生成完成', {
orderId: result.data?.orderId,
orderNo: result.data?.orderNo,
orderStatus: result.data?.orderStatus,
itemCount: result.data?.orderItemVOs?.length || 0
});
return result;
});
}
/** 获取订单详情数据 */
export function fetchOrderDetail(params) {
console.log('[订单详情服务] 开始获取订单详情', {
params,
useMock: config.useMock,
timestamp: new Date().toISOString()
});
if (config.useMock) {
console.log('[订单详情服务] 使用Mock模式');
return mockFetchOrderDetail(params);
}
return new Promise((resolve, reject) => {
// 从本地存储获取token
const token = wx.getStorageSync('token');
console.log('[订单详情服务] 检查登录状态', {
hasToken: !!token
});
if (!token) {
console.error('[订单详情服务] 用户未登录');
reject(new Error('未登录'));
return;
}
// 使用订单号或订单ID获取详情
const orderIdentifier = params.parameter || params.orderNo || params.orderId;
console.log('[订单详情服务] 解析订单标识', {
parameter: params.parameter,
orderNo: params.orderNo,
orderId: params.orderId,
orderIdentifier
});
if (!orderIdentifier) {
console.error('[订单详情服务] 缺少订单标识', { params });
reject(new Error('缺少订单标识'));
return;
}
const requestUrl = `${config.apiBase}/orders/${orderIdentifier}`;
console.log('[订单详情服务] 发送API请求', {
url: requestUrl,
orderIdentifier,
hasToken: !!token
});
wx.request({
url: requestUrl,
method: 'GET',
header: {
'Authorization': `Bearer ${token}`,
'Content-Type': 'application/json'
},
success: (res) => {
console.log('[订单详情服务] API响应成功', {
statusCode: res.statusCode,
dataCode: res.data?.code,
orderId: res.data?.data?.orderId,
orderNo: res.data?.data?.orderNo,
orderStatus: res.data?.data?.orderStatus
});
if (res.statusCode === 200 && res.data.code === 200) {
console.log('[订单详情服务] 开始处理订单详情数据');
// 转换后端数据格式为前端需要的格式
const order = res.data.data;
console.log('[订单详情服务] 原始订单数据', {
orderId: order.orderId,
orderNo: order.orderNo,
orderStatus: order.orderStatus,
paymentAmount: order.paymentAmount,
itemCount: order.orderItemVOs?.length || 0,
hasLogistics: !!order.logisticsVO
});
// 构建符合前端期望的数据结构
// 注意后端API已经返回正确格式的数据直接使用
const orderDetail = {
data: {
orderId: order.orderId,
orderNo: order.orderNo,
parentOrderNo: order.parentOrderNo,
storeId: order.storeId,
storeName: order.storeName,
orderStatus: order.orderStatus,
orderStatusName: order.orderStatusName,
paymentAmount: order.paymentAmount, // 后端已经是分为单位的整数
goodsAmountApp: order.goodsAmountApp,
totalAmount: order.totalAmount,
payAmount: order.payAmount,
couponAmount: order.couponAmount || 0, // 优惠券金额(分为单位)
freightFee: 0,
discountAmount: 0,
createdAt: order.createdAt,
createTime: new Date(order.createdAt).getTime(),
autoCancelTime: order.orderStatus === 1 ? Date.now() + 30 * 60 * 1000 : null, // 30分钟后自动取消
// 订单商品列表 - 直接使用后端返回的数据
orderItemVOs: order.orderItemVOs || [],
// 物流信息 - 直接使用后端返回的数据
logisticsVO: order.logisticsVO || {
logisticsNo: '',
logisticsCompanyName: '',
receiverName: '',
receiverPhone: '',
receiverProvince: '',
receiverCity: '',
receiverCountry: '',
receiverAddress: '',
sendTime: null,
arrivalTime: null
},
// 支付信息
paymentVO: {
payStatus: order.payStatus || 0,
amount: order.payAmount || order.totalAmount,
paySuccessTime: order.paidAt || null,
payWayName: '微信支付'
},
// 操作按钮
buttonVOs: getOrderButtons(order.orderStatus),
// 发票信息
invoiceStatus: 2, // 暂不开发票
invoiceDesc: '暂不开发票',
invoiceVO: null
},
code: 'Success',
success: true
};
console.log('[订单详情服务] 订单详情数据处理完成', {
orderId: orderDetail.data.orderId,
orderNo: orderDetail.data.orderNo,
orderStatus: orderDetail.data.orderStatus,
orderStatusName: orderDetail.data.orderStatusName,
paymentAmount: orderDetail.data.paymentAmount,
itemCount: orderDetail.data.orderItemVOs.length,
buttonCount: orderDetail.data.buttonVOs.length,
hasLogistics: !!orderDetail.data.logisticsVO.logisticsNo,
autoCancelTime: orderDetail.data.autoCancelTime
});
resolve(orderDetail);
} else {
const errorMsg = res.data.message || '获取订单详情失败';
console.error('[订单详情服务] API响应错误', {
statusCode: res.statusCode,
dataCode: res.data?.code,
message: errorMsg,
orderIdentifier
});
reject(new Error(errorMsg));
}
},
fail: (error) => {
console.error('[订单详情服务] API请求失败', {
error,
orderIdentifier,
url: requestUrl,
timestamp: new Date().toISOString()
});
reject(new Error('网络请求失败'));
}
});
});
}
// 获取订单操作按钮
function getOrderButtons(status) {
console.log('[订单详情服务] 获取订单操作按钮', { status });
const buttons = [];
switch (status) {
case 1: // 待付款
buttons.push(
{ primary: false, type: 1, name: '取消订单' },
{ primary: true, type: 2, name: '立即付款' }
);
break;
case 2: // 已付款/待发货
buttons.push(
{ primary: false, type: 7, name: '申请退款' },
{ primary: true, type: 3, name: '提醒发货' }
);
break;
case 3: // 待发货
buttons.push(
{ primary: false, type: 7, name: '申请退款' },
{ primary: true, type: 3, name: '提醒发货' }
);
break;
case 4: // 已发货/待收货
buttons.push(
{ primary: true, type: 4, name: '确认收货' }
);
break;
case 5: // 待收货
buttons.push(
{ primary: true, type: 4, name: '确认收货' }
);
break;
case 6: // 已完成
buttons.push(
{ primary: false, type: 5, name: '申请售后' },
{ primary: true, type: 6, name: '评价' }
);
break;
case 7: // 已取消
// 无操作按钮
break;
}
console.log('[订单详情服务] 生成的操作按钮', {
status,
buttonCount: buttons.length,
buttons: buttons.map(btn => ({ name: btn.name, type: btn.type, primary: btn.primary }))
});
return buttons;
}
// 获取商品操作按钮
function getItemButtons(orderStatus) {
console.log('[订单详情服务] 获取商品操作按钮', { orderStatus });
if (orderStatus === 3) { // 已完成
const buttons = [
{ primary: false, type: 4, name: '申请售后' }
];
console.log('[订单详情服务] 生成商品按钮', { buttons });
return buttons;
}
console.log('[订单详情服务] 无商品操作按钮', { orderStatus });
return [];
}
// 状态描述映射
function getStatusDesc(status) {
// 与后端order.go中的状态映射保持一致
const statusMap = {
1: '未付款',
2: '待发货', // 统一为待发货
3: '待发货', // 统一为待发货
4: '已发货',
5: '待收货',
6: '已完成',
7: '已取消',
8: '退货中',
9: '已退款'
};
const statusDesc = statusMap[status] || '未知状态';
console.log('[订单详情服务] 获取状态描述', {
status,
statusDesc
});
return statusDesc;
}
/** 获取客服mock数据 */
function mockFetchBusinessTime(params) {
console.log('[订单详情服务] 使用Mock数据获取客服信息', {
params,
timestamp: new Date().toISOString()
});
const { delay } = require('../_utils/delay');
const { genBusinessTime } = require('../../model/order/orderDetail');
return delay().then(() => {
const result = genBusinessTime(params);
console.log('[订单详情服务] Mock客服数据生成完成', result);
return result;
});
}
/** 获取客服数据 */
export function fetchBusinessTime(params) {
console.log('[订单详情服务] 开始获取客服信息', {
params,
useMock: config.useMock,
timestamp: new Date().toISOString()
});
if (config.useMock) {
console.log('[订单详情服务] 使用Mock模式获取客服信息');
return mockFetchBusinessTime(params);
}
return new Promise((resolve, reject) => {
const requestUrl = `${config.apiBase}/business/time`;
const token = wx.getStorageSync('token') || '';
console.log('[订单详情服务] 发送客服信息API请求', {
url: requestUrl,
hasToken: !!token
});
wx.request({
url: requestUrl,
method: 'GET',
header: {
'Authorization': `Bearer ${token}`
},
success: (res) => {
console.log('[订单详情服务] 客服信息API响应', {
statusCode: res.statusCode,
dataCode: res.data?.code,
hasBusinessTime: !!res.data?.data?.business_time,
hasPhone: !!res.data?.data?.phone
});
if (res.statusCode === 200 && res.data.code === 200) {
const result = {
data: {
businessTime: res.data.data.business_time || ['周一至周日: 9:00-18:00'],
telphone: res.data.data.phone || '400-000-0000',
saasId: res.data.data.saas_id || '88888888',
},
code: 'Success',
msg: null,
success: true,
};
console.log('[订单详情服务] 客服信息获取成功', result.data);
resolve(result);
} else {
console.warn('[订单详情服务] 客服信息API失败使用默认数据', {
statusCode: res.statusCode,
dataCode: res.data?.code,
message: res.data?.message
});
// 如果API失败返回默认数据
resolve({
data: {
businessTime: ['周一至周日: 9:00-18:00'],
telphone: '400-000-0000',
saasId: '88888888',
},
code: 'Success',
msg: null,
success: true,
});
}
},
fail: (err) => {
console.error('[订单详情服务] 客服信息请求失败,使用默认数据', {
error: err,
url: requestUrl
});
// 网络错误时返回默认数据
resolve({
data: {
businessTime: ['周一至周日: 9:00-18:00'],
telphone: '400-000-0000',
saasId: '88888888',
},
code: 'Success',
msg: null,
success: true,
});
}
});
});
}

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');
});
}

View File

@@ -0,0 +1,22 @@
import { config } from '../../config/index';
/** 获取评价商品 */
function mockGetGoods(parameter) {
const { delay } = require('../_utils/delay');
const { getGoods } = require('../../model/submitComment');
const data = getGoods(parameter);
return delay().then(() => {
return data;
});
}
/** 获取评价商品 */
export function getGoods(parameter) {
if (config.useMock) {
return mockGetGoods(parameter);
}
return new Promise((resolve) => {
resolve('real api');
});
}