ai_dianshang/miniprogram/services/order/orderList.js

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