Files
2025-11-17 13:32:54 +08:00

1394 lines
42 KiB
JavaScript
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

import { formatTime } from '../../../utils/util';
import { OrderStatus, LogisticsIconMap } from '../config';
import { fetchBusinessTime, fetchOrderDetail } from '../../../services/order/orderDetail';
import Toast from 'tdesign-miniprogram/toast/index';
import { getAddressPromise } from '../../../services/address/list';
import { config } from '../../../config/index';
Page({
data: {
pageLoading: true,
order: {}, // 后台返回的原始数据
_order: {}, // 内部使用和提供给 order-card 的数据
storeDetail: {},
countDownTime: null,
addressEditable: false,
backRefresh: false, // 用于接收其他页面back时的状态
formatCreateTime: '', //格式化订单创建时间
logisticsNodes: [],
/** 订单评论状态 */
orderHasCommented: true,
/** 提醒发货状态 */
isRemindingShip: false,
},
// 通用登录检查函数
checkLoginAndNavigate() {
const token = wx.getStorageSync('token');
if (!token) {
wx.showModal({
title: '提示',
content: '请先登录后再进行操作',
confirmText: '去登录',
cancelText: '取消',
success: (res) => {
if (res.confirm) {
wx.navigateTo({ url: '/pages/login/index' });
}
}
});
return false;
}
return true;
},
onLoad(query) {
console.log('[订单详情] 页面加载开始', {
query,
orderNo: query.orderNo,
refresh: query.refresh,
timestamp: new Date().toISOString()
});
this.orderNo = query.orderNo;
if (!this.orderNo) {
console.error('[订单详情] 缺少订单号参数');
wx.showToast({
title: '订单号不能为空',
icon: 'none'
});
return;
}
// 检查是否需要刷新(来自支付结果页面)
if (query.refresh === '1') {
console.log('🔄 [订单详情] 检测到刷新标志,将在页面显示时刷新数据');
this.setData({ backRefresh: true });
}
console.log('[订单详情] 开始初始化', { orderNo: this.orderNo });
this.init();
this.navbar = this.selectComponent('#navbar');
this.pullDownRefresh = this.selectComponent('#wr-pull-down-refresh');
console.log('[订单详情] 页面加载完成');
},
onShow() {
console.log('[订单详情] 页面显示', {
backRefresh: this.data.backRefresh,
orderNo: this.orderNo,
timestamp: new Date().toISOString()
});
// 当从其他页面返回,并且 backRefresh 被置为 true 时,刷新数据
if (!this.data.backRefresh) {
return;
}
console.log('[订单详情] 执行数据刷新(支付状态更新)');
this.onRefresh();
this.setData({ backRefresh: false });
},
onPageScroll(e) {
this.pullDownRefresh && this.pullDownRefresh.onPageScroll(e);
},
onImgError(e) {
if (e.detail) {
console.error('[订单详情] 图片加载失败', e.detail);
}
},
// 页面初始化会展示pageLoading
init() {
console.log('[订单详情] 初始化开始', {
orderNo: this.orderNo,
timestamp: new Date().toISOString()
});
this.setData({
pageLoading: true,
});
Promise.all([this.getDetail(), this.getStoreDetail()])
.then(() => {
console.log('[订单详情] 初始化完成');
this.setData({
pageLoading: false,
});
})
.catch((err) => {
console.error('[订单详情] 初始化失败', err);
this.setData({
pageLoading: false,
});
});
},
// 页面刷新,展示下拉刷新
onRefresh() {
console.log('[订单详情] 手动刷新开始', {
orderNo: this.orderNo,
timestamp: new Date().toISOString()
});
this.init();
// 如果上一页为订单列表,通知其刷新数据
const pages = getCurrentPages();
const lastPage = pages[pages.length - 2];
if (lastPage) {
console.log('[订单详情] 通知上一页刷新数据');
lastPage.data.backRefresh = true;
}
console.log('[订单详情] 手动刷新完成');
},
// 页面刷新,展示下拉刷新
onPullDownRefresh_(e) {
console.log('[订单详情] 下拉刷新开始', {
orderNo: this.orderNo,
timestamp: new Date().toISOString()
});
// 安全检查 e.detail 是否存在
const callback = e && e.detail && e.detail.callback;
return this.getDetail().then(() => {
console.log('[订单详情] 下拉刷新成功');
// 确保 callback 存在且是函数
if (callback && typeof callback === 'function') {
callback();
}
}).catch((error) => {
console.error('[订单详情] 下拉刷新失败:', error);
// 即使出错也要调用 callback 来结束刷新状态
if (callback && typeof callback === 'function') {
callback();
}
});
},
getDetail() {
const params = {
parameter: this.orderNo,
};
console.log('🔍 [订单详情] 开始获取订单详情,订单号:', this.orderNo);
return fetchOrderDetail(params).then((res) => {
console.log('📦 [订单详情] API响应数据:', res);
const order = res.data;
console.log('📋 [订单详情] 原始订单数据:', order);
// 处理_order对象中的价格字段
console.log('💰 [_order价格] 开始处理_order对象中的价格字段...');
const _orderPrices = {
paymentAmount: order.paymentAmount,
totalAmount: order.totalAmount
};
console.log('💰 [_order价格] 原始价格数据:', _orderPrices);
// 后端返回的价格是以分为单位需要除以100转换为元
const convertedAmount = order.paymentAmount ? (order.paymentAmount / 100).toFixed(2) : '0.00';
const convertedTotalAmount = order.totalAmount ? (order.totalAmount / 100).toFixed(2) : '0.00';
console.log('💰 [_order价格] 格式化后价格:', {
amount: convertedAmount,
totalAmount: convertedTotalAmount
});
const _order = {
id: order.orderId,
orderNo: order.orderNo,
parentOrderNo: order.parentOrderNo,
storeId: order.storeId,
storeName: order.storeName,
status: order.orderStatus || order.status,
statusDesc: order.orderStatusName || order.statusName || this.getOrderStatusName(order.orderStatus || order.status),
amount: convertedAmount,
totalAmount: convertedTotalAmount,
logisticsNo: (order.logisticsVO && order.logisticsVO.logisticsNo) || '',
goodsList: (order.orderItemVOs || []).map((goods, index) => {
console.log(`🛍️ [商品处理] 处理商品 ${index + 1}:`, goods);
// 处理规格信息,将数组转换为字符串
let specsText = '';
if (goods.specifications && Array.isArray(goods.specifications)) {
specsText = goods.specifications.map(spec => `${spec.specTitle}:${spec.specValue}`).join(' ');
}
console.log(`📝 [规格处理] 商品 ${index + 1} 规格信息:`, goods.specifications, '-> 转换后:', specsText);
// 商品价格是以分为单位需要除以100转换为元
const originalGoodsPrices = {
actualPrice: goods.actualPrice,
originPrice: goods.originPrice
};
console.log(`💰 [商品价格] 商品 ${index + 1} 价格:`, originalGoodsPrices);
const convertedPrice = goods.actualPrice ? (goods.actualPrice / 100).toFixed(2) : '0.00';
const convertedOriginPrice = goods.originPrice ? (goods.originPrice / 100).toFixed(2) : null;
console.log(`💰 [商品价格] 商品 ${index + 1} 格式化后价格:`, {
actualPrice: convertedPrice,
originPrice: convertedOriginPrice
});
return Object.assign({}, goods, {
id: goods.id,
thumb: goods.goodsPictureUrl || '',
title: goods.goodsName || '',
skuId: goods.skuId,
spuId: goods.spuId,
specs: specsText,
price: convertedPrice, // 将分转换为元,保留两位小数
originPrice: convertedOriginPrice, // 原价也需要转换
num: goods.buyQuantity,
titlePrefixTags: [],
buttons: goods.buttonVOs || [],
});
}),
buttons: [],
createTime: order.createdAt,
receiverAddress: this.composeAddress(order),
totalAmount: convertedTotalAmount,
payAmount: convertedAmount,
orderNo: order.orderNo,
status: order.orderStatus,
};
console.log('🛍️ [商品处理] 处理完成的商品列表:', _order.goodsList);
// 处理订单中的价格字段,格式化显示
console.log('💰 [价格格式化] 开始格式化订单价格...');
const originalPrices = {
totalAmount: order.totalAmount,
freightFee: order.freightFee,
discountAmount: order.discountAmount,
couponAmount: order.couponAmount,
paymentAmount: order.paymentAmount
};
console.log('💰 [价格格式化] 原始价格:', originalPrices);
// 添加调试信息
console.log('🔍 [调试] couponAmount 原始值:', order.couponAmount, '类型:', typeof order.couponAmount);
const couponAmountConverted = order.couponAmount ? (order.couponAmount / 100).toFixed(2) : '0.00';
console.log('🔍 [调试] couponAmount 转换后:', couponAmountConverted, '类型:', typeof couponAmountConverted);
const processedOrder = {
...order,
totalAmount: order.totalAmount ? (order.totalAmount / 100).toFixed(2) : '0.00',
freightFee: order.freightFee ? (order.freightFee / 100).toFixed(2) : '0.00',
discountAmount: order.discountAmount ? (order.discountAmount / 100).toFixed(2) : '0.00',
couponAmount: couponAmountConverted,
paymentAmount: order.paymentAmount ? (order.paymentAmount / 100).toFixed(2) : '0.00',
};
console.log('🔍 [调试] processedOrder.couponAmount:', processedOrder.couponAmount);
const formattedPrices = {
totalAmount: processedOrder.totalAmount,
freightFee: processedOrder.freightFee,
discountAmount: processedOrder.discountAmount,
couponAmount: processedOrder.couponAmount,
paymentAmount: processedOrder.paymentAmount
};
console.log('💰 [价格格式化] 格式化后价格:', formattedPrices);
// 处理地址信息
console.log('🏠 [地址处理] 开始处理地址信息...');
const addressText = this.composeAddress(order);
console.log('🏠 [地址处理] 生成的地址文本:', addressText);
console.log('✅ [数据设置] 设置页面数据...');
this.setData({
order: processedOrder,
_order,
formatCreateTime: this.formatOrderTime(order.createdAt), // 格式化订单创建时间
countDownTime: this.computeCountDownTime(order),
addressEditable:
[1, 3].includes(order.orderStatus), // 1未付款3待发货时允许修改地址已发货后不允许修改
isPaid: order.payStatus === 1, // 1已支付
invoiceStatus: 3, // 默认未开票
invoiceDesc: '',
invoiceType: '不开发票',
logisticsNodes: [],
});
console.log('✅ [数据设置] 页面数据设置完成');
}).catch((error) => {
console.error('获取订单详情失败:', error);
// 根据错误类型显示不同的提示信息
let errorMessage = '获取订单详情失败';
if (error.message) {
if (error.message.includes('订单不存在') || error.message.includes('无效的订单')) {
errorMessage = '订单不存在或已被删除';
} else if (error.message.includes('网络')) {
errorMessage = '网络连接失败,请检查网络后重试';
} else if (error.message.includes('无权访问')) {
errorMessage = '无权访问该订单';
} else {
errorMessage = error.message;
}
}
// 显示错误提示
Toast({
context: this,
selector: '#t-toast',
message: errorMessage,
theme: 'error',
direction: 'column',
});
// 确保在出错时数据保持一致性
this.setData({
logisticsNodes: [],
order: {},
_order: {},
pageLoading: false,
});
// 如果是网络错误,提供重试选项
if (error.message && error.message.includes('网络')) {
wx.showModal({
title: '网络错误',
content: '网络连接失败,是否重新加载?',
confirmText: '重试',
cancelText: '取消',
success: (res) => {
if (res.confirm) {
this.init();
}
}
});
}
});
},
// 展开物流节点
flattenNodes(nodes) {
return (nodes || []).reduce((res, node) => {
return (node.nodes || []).reduce((res1, subNode, index) => {
res1.push({
title: index === 0 ? node.title : '', // 子节点中仅第一个显示title
desc: subNode.status,
date: formatTime(+subNode.timestamp, 'YYYY-MM-DD HH:mm:ss'),
icon: index === 0 ? LogisticsIconMap[node.code] || '' : '', // 子节点中仅第一个显示icon
});
return res1;
}, res);
}, []);
},
datermineInvoiceStatus(order) {
// 1-已开票
// 2-未开票(可补开)
// 3-未开票
// 4-门店不支持开票
return order.invoiceStatus;
},
// 拼接省市区
composeAddress(order) {
console.log('🏠 [地址组装] 开始组装地址,订单数据:', order);
if (!order || !order.logisticsVO) {
console.log('🏠 [地址组装] 订单或物流信息为空,返回默认地址');
return '暂无收货地址';
}
// 返回完整的地址字符串,而不是对象
// 从logisticsVO中获取地址信息
const logistics = order.logisticsVO;
console.log('🏠 [地址组装] 物流信息:', logistics);
const province = logistics.receiverProvince || '';
const city = logistics.receiverCity || '';
const district = logistics.receiverCountry || ''; // 注意后端使用receiverCountry表示区县
const address = logistics.receiverAddress || '';
console.log('🏠 [地址组装] 地址组件:', {
province,
city,
district,
address,
receiverName: logistics.receiverName,
receiverPhone: logistics.receiverPhone
});
// 拼接完整地址
const fullAddress = `${province}${city}${district}${address}`.trim();
console.log('🏠 [地址组装] 组装完成的完整地址:', fullAddress);
// 如果地址为空,返回默认提示
const result = fullAddress || '暂无收货地址';
console.log('🏠 [地址组装] 最终返回地址:', result);
return result;
},
// 格式化订单时间
formatOrderTime(timeStr) {
if (!timeStr) {
return '未知时间';
}
try {
let date;
// 处理不同的时间格式
if (typeof timeStr === 'string') {
// 如果是字符串,尝试解析
if (timeStr.includes('T')) {
// ISO 格式: 2025-01-01T12:00:00Z
date = new Date(timeStr);
} else if (timeStr.includes('-')) {
// 日期格式: 2025-01-01 12:00:00
date = new Date(timeStr.replace(/-/g, '/'));
} else if (/^\d+$/.test(timeStr)) {
// 时间戳字符串
date = new Date(parseInt(timeStr));
} else {
date = new Date(timeStr);
}
} else if (typeof timeStr === 'number') {
// 时间戳数字
date = new Date(timeStr);
} else {
date = new Date(timeStr);
}
// 检查日期是否有效
if (isNaN(date.getTime())) {
console.warn('无效的时间格式:', timeStr);
return '时间格式错误';
}
return formatTime(date.getTime(), 'YYYY-MM-DD HH:mm');
} catch (error) {
console.error('时间格式化错误:', error, timeStr);
return '时间解析失败';
}
},
getStoreDetail() {
console.log('🏪 [店铺详情] 开始获取店铺详情');
fetchBusinessTime().then((res) => {
console.log('🏪 [店铺详情] API响应:', res);
if (res && res.data) {
const storeDetail = {
storeTel: res.data.telphone || '400-000-0000',
storeBusiness: (res.data.businessTime && Array.isArray(res.data.businessTime))
? res.data.businessTime.join('\n')
: '周一至周日: 9:00-18:00',
};
console.log('🏪 [店铺详情] 处理后的店铺信息:', storeDetail);
this.setData({ storeDetail });
} else {
console.log('🏪 [店铺详情] 响应数据为空,使用默认值');
// 设置默认值
const storeDetail = {
storeTel: '400-000-0000',
storeBusiness: '周一至周日: 9:00-18:00',
};
this.setData({ storeDetail });
}
}).catch((err) => {
console.error('❌ [店铺详情] 获取店铺详情失败:', err);
// 设置默认值
const storeDetail = {
storeTel: '400-000-0000',
storeBusiness: '周一至周日: 9:00-18:00',
};
this.setData({ storeDetail });
});
},
// 仅对待支付状态计算付款倒计时
// 返回时间若是大于2020.01.01,说明返回的是关闭时间,否则说明返回的直接就是剩余时间
computeCountDownTime(order) {
if (order.orderStatus !== OrderStatus.PENDING_PAYMENT) return null;
return order.autoCancelTime > 1577808000000 ? order.autoCancelTime - Date.now() : order.autoCancelTime;
},
onCountDownFinish() {
//this.setData({ countDownTime: -1 });
const { countDownTime, order } = this.data;
if (countDownTime > 0 || (order && order.groupInfoVo && order.groupInfoVo.residueTime > 0)) {
this.onRefresh();
}
},
onGoodsCardTap(e) {
const { index } = e.currentTarget.dataset;
const goods = this.data.order.orderItemVOs[index];
console.log('[订单详情] 商品卡片点击', {
index,
spuId: goods.spuId,
goodsName: goods.goodsName,
orderNo: this.orderNo,
timestamp: new Date().toISOString()
});
wx.navigateTo({ url: `/pages/goods/details/index?spuId=${goods.spuId}` });
},
onEditAddressTap() {
console.log('[订单详情] 编辑地址点击', {
orderNo: this.orderNo,
addressEditable: this.data.addressEditable,
timestamp: new Date().toISOString()
});
getAddressPromise()
.then((address) => {
console.log('[订单详情] 地址选择成功', address);
this.setData({
'order.logisticsVO.receiverName': address.name,
'order.logisticsVO.receiverPhone': address.phone,
'_order.receiverAddress': address.address,
});
})
.catch((error) => {
console.error('[订单详情] 地址选择失败', error);
});
wx.navigateTo({
url: `/pages/user/address/list/index?selectMode=1`,
});
},
onOrderNumCopy() {
const orderNo = this.data.order.orderNo;
console.log('[订单详情] 复制订单号', {
orderNo,
timestamp: new Date().toISOString()
});
wx.setClipboardData({
data: orderNo,
success: () => {
console.log('[订单详情] 订单号复制成功');
Toast({
context: this,
selector: '#t-toast',
message: '订单号已复制',
theme: 'success',
});
},
fail: (error) => {
console.error('[订单详情] 订单号复制失败', error);
}
});
},
onDeliveryNumCopy() {
const logisticsNo = this.data.order.logisticsVO.logisticsNo;
console.log('[订单详情] 复制物流单号', {
logisticsNo,
orderNo: this.orderNo,
timestamp: new Date().toISOString()
});
wx.setClipboardData({
data: logisticsNo,
success: () => {
console.log('[订单详情] 物流单号复制成功');
Toast({
context: this,
selector: '#t-toast',
message: '物流单号已复制',
theme: 'success',
});
},
fail: (error) => {
console.error('[订单详情] 物流单号复制失败', error);
}
});
},
// 订单操作按钮点击处理
onOrderButtonTap(e) {
const { type } = e.currentTarget.dataset;
const { order } = this.data;
console.log('[订单详情] ===== 按钮点击调试开始 =====');
console.log('[订单详情] 按钮点击事件详情', {
type: type,
typeType: typeof type,
originalEvent: e,
dataset: e.currentTarget.dataset,
orderNo: this.orderNo,
orderStatus: order?.orderStatus,
orderButtons: order?.orderButtons,
timestamp: new Date().toISOString()
});
// 检查按钮列表
if (order?.orderButtons) {
console.log('[订单详情] 当前订单按钮列表:');
order.orderButtons.forEach((btn, index) => {
console.log(`[订单详情] 按钮${index}: type=${btn.type}, name=${btn.name}, primary=${btn.primary}`);
});
}
console.log('[订单详情] 即将执行的操作类型:', type);
switch (type) {
case 1: // 取消订单
console.log('[订单详情] 执行取消订单操作');
this.cancelOrder();
break;
case 2: // 立即付款
console.log('[订单详情] 执行立即付款操作');
this.payOrder();
break;
case 3: // 提醒发货
console.log('[订单详情] 执行提醒发货操作');
this.remindShip();
break;
case 4: // 确认收货
console.log('[订单详情] 执行确认收货操作');
this.confirmReceive();
break;
case 5: // 申请售后
console.log('[订单详情] 执行申请售后操作');
this.applyAfterSale();
break;
case 6: // 评价
console.log('[订单详情] 执行评价操作');
this.goToComment();
break;
case 7: // 申请退款
console.log('[订单详情] 执行申请退款操作');
this.applyRefund();
break;
default:
console.warn('[订单详情] 未知操作类型:', type);
}
},
// 申请退款
applyRefund() {
console.log('[订单详情] ===== 申请退款函数被调用 =====');
console.log('[订单详情] 当前订单信息:', {
orderNo: this.orderNo,
orderData: this.data.order,
orderStatus: this.data.order?.orderStatus
});
// 跳转到退款申请页面
wx.navigateTo({
url: `/pages/refund/refund-apply/index?orderNo=${this.orderNo}`
});
},
// 执行申请退款
performApplyRefund() {
console.log('[订单详情] ===== 执行申请退款操作 =====');
console.log('[订单详情] 订单号:', this.orderNo);
if (!this.checkLoginAndNavigate()) {
console.error('[订单详情] 申请退款失败:未登录');
return;
}
const token = wx.getStorageSync('token');
wx.showLoading({ title: '处理中...' });
const requestUrl = `${config.apiBase}/orders/${this.data.order.orderNo || this.orderNo}/refund`;
console.log('[订单详情] 发送申请退款请求', {
url: requestUrl,
orderNo: this.orderNo
});
wx.request({
url: requestUrl,
method: 'PUT',
header: {
'Authorization': `Bearer ${token}`,
'Content-Type': 'application/json'
},
success: (res) => {
wx.hideLoading();
console.log('[订单详情] 申请退款API响应', {
statusCode: res.statusCode,
data: res.data,
orderNo: this.orderNo
});
if (res.statusCode === 200 && res.data.code === 200) {
console.log('[订单详情] 申请退款成功');
Toast({
context: this,
selector: '#t-toast',
message: '退款申请已提交',
theme: 'success',
});
// 刷新订单详情
setTimeout(() => {
this.getDetail();
}, 1000);
} else {
console.error('[订单详情] 申请退款失败', res.data);
Toast({
context: this,
selector: '#t-toast',
message: res.data.message || '申请退款失败',
theme: 'error',
});
}
},
fail: (error) => {
wx.hideLoading();
console.error('[订单详情] 申请退款网络错误', error);
Toast({
context: this,
selector: '#t-toast',
message: '网络错误',
theme: 'error',
});
}
});
},
// 取消订单
cancelOrder() {
console.log('[订单详情] 显示取消订单确认弹窗', {
orderNo: this.orderNo,
timestamp: new Date().toISOString()
});
wx.showModal({
title: '确认取消',
content: '确定要取消这个订单吗?',
success: (res) => {
console.log('[订单详情] 取消订单确认结果', {
confirm: res.confirm,
orderNo: this.orderNo
});
if (res.confirm) {
this.performCancelOrder();
} else {
console.log('[订单详情] 用户取消了取消订单操作');
}
}
});
},
// 执行取消订单
performCancelOrder() {
console.log('[订单详情] 开始执行取消订单', {
orderNo: this.orderNo,
timestamp: new Date().toISOString()
});
if (!this.checkLoginAndNavigate()) {
console.error('[订单详情] 取消订单失败:未登录');
return;
}
const token = wx.getStorageSync('token');
wx.showLoading({ title: '取消中...' });
const requestUrl = `${config.apiBase}/orders/${this.data.order.orderNo || this.orderNo}/cancel`;
console.log('[订单详情] 发送取消订单请求', {
url: requestUrl,
orderNo: this.orderNo
});
wx.request({
url: requestUrl,
method: 'PUT',
header: {
'Authorization': `Bearer ${token}`,
'Content-Type': 'application/json'
},
data: {
order_no: this.data.order.orderNo || this.orderNo
},
success: (res) => {
wx.hideLoading();
console.log('[订单详情] 取消订单API响应', {
statusCode: res.statusCode,
data: res.data,
orderNo: this.orderNo
});
if (res.statusCode === 200 && res.data.code === 200) {
console.log('[订单详情] 取消订单成功');
Toast({
context: this,
selector: '#t-toast',
message: '订单已取消',
theme: 'success',
});
// 刷新订单详情
setTimeout(() => {
this.getDetail();
}, 1000);
} else {
console.error('[订单详情] 取消订单失败', res.data);
Toast({
context: this,
selector: '#t-toast',
message: res.data.message || '取消失败',
theme: 'error',
});
}
},
fail: (error) => {
wx.hideLoading();
console.error('[订单详情] 取消订单网络错误', error);
Toast({
context: this,
selector: '#t-toast',
message: '网络错误',
theme: 'error',
});
}
});
},
// 立即付款
payOrder() {
if (!this.checkLoginAndNavigate()) {
return;
}
const token = wx.getStorageSync('token');
wx.showLoading({ title: '创建支付订单...' });
wx.request({
url: `${config.apiBase}/payment/create`,
method: 'POST',
header: {
'Authorization': `Bearer ${token}`,
'Content-Type': 'application/json'
},
data: {
orderNo: this.data.order.orderNo || this.orderNo,
paymentMethod: 'wechat'
},
success: (res) => {
if (res.statusCode === 200 && res.data.code === 200) {
const paymentData = res.data.data;
// 如果返回了微信支付参数调用微信支付SDK
if (paymentData && paymentData.payInfo) {
wx.hideLoading();
wx.showLoading({ title: '调起微信支付...' });
try {
const payInfo = typeof paymentData.payInfo === 'string'
? JSON.parse(paymentData.payInfo)
: paymentData.payInfo;
console.log('微信支付参数:', payInfo);
wx.requestPayment({
timeStamp: payInfo.timeStamp,
nonceStr: payInfo.nonceStr,
package: payInfo.package,
signType: payInfo.signType || 'RSA',
paySign: payInfo.paySign,
success: (payRes) => {
wx.hideLoading();
Toast({
context: this,
selector: '#t-toast',
message: '支付成功',
theme: 'success',
});
// 刷新订单详情
setTimeout(() => {
this.getDetail();
}, 1000);
},
fail: (payErr) => {
wx.hideLoading();
Toast({
context: this,
selector: '#t-toast',
message: payErr.errMsg || '支付失败',
theme: 'error',
});
}
});
} catch (parseErr) {
wx.hideLoading();
Toast({
context: this,
selector: '#t-toast',
message: '支付参数解析失败',
theme: 'error',
});
}
} else {
// 如果没有返回微信支付参数,可能是模拟支付成功
wx.hideLoading();
Toast({
context: this,
selector: '#t-toast',
message: '支付成功',
theme: 'success',
});
// 刷新订单详情
setTimeout(() => {
this.getDetail();
}, 1000);
}
} else {
wx.hideLoading();
Toast({
context: this,
selector: '#t-toast',
message: res.data.message || '创建支付订单失败',
theme: 'error',
});
}
},
fail: () => {
wx.hideLoading();
Toast({
context: this,
selector: '#t-toast',
message: '网络错误',
theme: 'error',
});
}
});
},
// 提醒发货
remindShip() {
console.log('[订单详情] ===== 提醒发货函数被调用 =====');
console.log('[订单详情] 当前订单信息:', {
orderNo: this.orderNo,
orderData: this.data.order,
orderStatus: this.data.order?.orderStatus
});
// 检查是否正在处理中
if (this.data.isRemindingShip) {
Toast({
context: this,
selector: '#t-toast',
message: '正在处理中,请稍候...',
theme: 'warning',
});
return;
}
// 检查订单状态
const orderStatus = this.data.order?.orderStatus;
if (orderStatus !== 2 && orderStatus !== 3) {
Toast({
context: this,
selector: '#t-toast',
message: '当前订单状态不支持提醒发货',
theme: 'warning',
});
return;
}
wx.showModal({
title: '提醒发货',
content: '确定要提醒商家尽快发货吗?提醒后商家会收到通知。',
confirmText: '确定提醒',
cancelText: '取消',
success: (res) => {
console.log('[订单详情] 提醒发货弹窗响应:', res);
if (res.confirm) {
console.log('[订单详情] 用户确认提醒发货,执行操作');
this.performRemindShip();
} else {
console.log('[订单详情] 用户取消提醒发货');
}
}
});
},
// 执行提醒发货
performRemindShip() {
console.log('[订单详情] ===== 执行提醒发货操作 =====');
console.log('[订单详情] 订单号:', this.orderNo);
if (!this.checkLoginAndNavigate()) {
return;
}
const token = wx.getStorageSync('token');
// 设置加载状态
this.setData({
isRemindingShip: true
});
// 显示加载提示
wx.showLoading({
title: '提醒发货中...',
mask: true
});
const url = `${config.apiBase}/orders/${this.data.order.orderNo || this.orderNo}/remind-ship`;
console.log('[订单详情] 提醒发货请求URL:', url);
wx.request({
url: url,
method: 'PUT',
header: {
'Authorization': `Bearer ${token}`,
'Content-Type': 'application/json'
},
success: (res) => {
console.log('[订单详情] 提醒发货响应:', res);
if (res.statusCode === 200 && res.data.code === 200) {
Toast({
context: this,
selector: '#t-toast',
message: '提醒发货成功,商家已收到通知',
theme: 'success',
});
// 刷新订单信息
this.getDetail();
} else {
console.error('[订单详情] 提醒发货失败:', res.data);
let errorMessage = '提醒发货失败';
if (res.data.message) {
if (res.data.message.includes('订单不存在')) {
errorMessage = '订单信息异常,请刷新页面重试';
} else if (res.data.message.includes('状态')) {
errorMessage = '订单状态不支持提醒发货';
} else {
errorMessage = res.data.message;
}
}
Toast({
context: this,
selector: '#t-toast',
message: errorMessage,
theme: 'error',
});
}
},
fail: (err) => {
console.error('[订单详情] 提醒发货请求失败:', err);
Toast({
context: this,
selector: '#t-toast',
message: '网络连接失败,请检查网络后重试',
theme: 'error',
});
},
complete: () => {
// 隐藏加载提示
wx.hideLoading();
// 重置加载状态
this.setData({
isRemindingShip: false
});
}
});
},
// 确认收货
confirmReceive() {
console.log('[订单详情] ===== 确认收货函数被调用 =====');
console.log('[订单详情] 当前订单信息:', {
orderNo: this.orderNo,
orderData: this.data.order,
orderStatus: this.data.order?.orderStatus
});
wx.showModal({
title: '确认收货',
content: '确定已收到商品吗?确认后将无法撤销。',
success: (res) => {
console.log('[订单详情] 确认收货弹窗响应:', res);
if (res.confirm) {
console.log('[订单详情] 用户确认收货,执行操作');
this.performConfirmReceive();
} else {
console.log('[订单详情] 用户取消确认收货');
}
}
});
},
// 执行确认收货
performConfirmReceive() {
if (!this.checkLoginAndNavigate()) {
return;
}
const token = wx.getStorageSync('token');
wx.showLoading({ title: '确认中...' });
wx.request({
url: `${config.apiBase}/orders/${this.data.order.orderNo || this.orderNo}/receive`,
method: 'PUT',
header: {
'Authorization': `Bearer ${token}`,
'Content-Type': 'application/json'
},
data: {
order_no: this.data.order.orderNo || this.orderNo
},
success: (res) => {
wx.hideLoading();
if (res.statusCode === 200 && res.data.code === 200) {
Toast({
context: this,
selector: '#t-toast',
message: '确认收货成功',
theme: 'success',
});
// 刷新订单详情
setTimeout(() => {
this.getDetail();
}, 1000);
} else {
Toast({
context: this,
selector: '#t-toast',
message: res.data.message || '确认收货失败',
theme: 'error',
});
}
},
fail: () => {
wx.hideLoading();
Toast({
context: this,
selector: '#t-toast',
message: '网络错误',
theme: 'error',
});
}
});
},
// 申请售后
applyAfterSale() {
console.log('[订单详情] ===== 申请售后函数被调用 =====');
console.log('[订单详情] 当前订单信息:', {
orderNo: this.orderNo,
orderData: this.data.order,
orderStatus: this.data.order?.orderStatus
});
const { order } = this.data;
if (!order || !order.orderNo) {
Toast({
context: this,
selector: '#t-toast',
message: '订单信息异常,请刷新页面重试',
theme: 'error',
});
return;
}
// 检查订单状态是否支持申请售后
const orderStatus = order.orderStatus;
if (orderStatus === 1) { // 未付款
Toast({
context: this,
selector: '#t-toast',
message: '未付款订单不支持申请售后',
theme: 'warning',
});
return;
}
if (orderStatus === 7) { // 已取消
Toast({
context: this,
selector: '#t-toast',
message: '已取消订单不支持申请售后',
theme: 'warning',
});
return;
}
// 获取第一个商品信息用于售后申请
const firstGoods = order.goodsList && order.goodsList[0];
if (!firstGoods) {
Toast({
context: this,
selector: '#t-toast',
message: '商品信息异常,无法申请售后',
theme: 'error',
});
return;
}
console.log('[订单详情] 跳转到申请售后页面', {
orderNo: order.orderNo,
goodsId: firstGoods.goodsId,
orderStatus: orderStatus
});
// 跳转到申请售后页面
wx.navigateTo({
url: `/pages/order/apply-service/index?orderNo=${order.orderNo}&goodsId=${firstGoods.goodsId}&orderStatus=${orderStatus}`,
success: () => {
console.log('[订单详情] 成功跳转到申请售后页面');
},
fail: (error) => {
console.error('[订单详情] 跳转申请售后页面失败:', error);
Toast({
context: this,
selector: '#t-toast',
message: '跳转失败,请重试',
theme: 'error',
});
}
});
},
// 去评价
goToComment() {
console.log('[订单详情] ===== 评价函数被调用 =====');
console.log('[订单详情] 当前订单信息:', {
orderNo: this.orderNo,
orderData: this.data.order,
orderStatus: this.data.order?.orderStatus
});
const { order } = this.data;
console.log('[订单详情] ', order);
if (!order || !order.orderNo) {
Toast({
context: this,
selector: '#t-toast',
message: '订单信息异常,请刷新页面重试',
theme: 'error',
});
return;
}
// 检查订单状态是否支持评价
const orderStatus = order.orderStatus;
if (orderStatus !== 6) { // 只有已完成的订单才能评价
Toast({
context: this,
selector: '#t-toast',
message: '只有已完成的订单才能评价',
theme: 'warning',
});
return;
}
// 获取第一个商品信息用于评价
const firstGoods = order.orderItemVOs && order.orderItemVOs[0];
if (!firstGoods) {
Toast({
context: this,
selector: '#t-toast',
message: '商品信息异常,无法评价',
theme: 'error',
});
return;
}
console.log('[订单详情] 跳转到评价页面', {
firstGoods:firstGoods,
orderNo: order.orderNo,
goodsId: firstGoods.spuId,
title: firstGoods.goodsName,
imgUrl: firstGoods.goodsPictureUrl
});
// 跳转到评价页面
wx.navigateTo({
url: `/pages/goods/comments/create/index?orderNo=${order.orderNo}&goodsId=${firstGoods.spuId}&title=${encodeURIComponent(firstGoods.goodsName || '')}&imgUrl=${encodeURIComponent(firstGoods.goodsPictureUrl || '')}&specs=${encodeURIComponent(firstGoods.specs || '')}`,
success: () => {
console.log('[订单详情] 成功跳转到评价页面');
},
fail: (error) => {
console.error('[订单详情] 跳转评价页面失败:', error);
Toast({
context: this,
selector: '#t-toast',
message: '跳转失败,请重试',
theme: 'error',
});
}
});
},
onToInvoice() {
wx.navigateTo({
url: `/pages/order/invoice/index?orderNo=${this.data._order.orderNo}`,
});
},
onSuppleMentInvoice() {
wx.navigateTo({
url: `/pages/order/receipt/index?orderNo=${this.data._order.orderNo}`,
});
},
onDeliveryClick() {
const logisticsData = {
nodes: this.data.logisticsNodes,
company: this.data.order.logisticsVO.logisticsCompanyName,
logisticsNo: this.data.order.logisticsVO.logisticsNo,
phoneNumber: this.data.order.logisticsVO.logisticsCompanyTel,
};
wx.navigateTo({
url: `/pages/order/delivery-detail/index?data=${encodeURIComponent(JSON.stringify(logisticsData))}`,
});
},
/** 跳转订单评价 */
navToCommentCreate() {
wx.navigateTo({
url: `/pages/order/createComment/index?orderNo=${this.orderNo}`,
});
},
/** 跳转拼团详情/分享页*/
toGrouponDetail() {
wx.showToast({ title: '点击了拼团' });
},
clickService() {
Toast({
context: this,
selector: '#t-toast',
message: '您点击了联系客服',
});
},
onOrderInvoiceView() {
wx.navigateTo({
url: `/pages/order/invoice/index?orderNo=${this.orderNo}`,
});
},
// 获取订单状态名称
getOrderStatusName(status) {
const statusMap = {
1: '未付款',
2: '待发货', // 统一为待发货
3: '待发货', // 统一为待发货
4: '已发货',
5: '待收货',
6: '已完成',
7: '已取消',
8: '退货中',
9: '已退款'
};
return statusMap[status] || '未知状态';
},
});