E-MD/CRM/customer/modules/orderCreate/create.js

const _Http = getApp().globalData.http;

Page({
  data: {
    loading: false,
    disabled: false,
    showAll: false,
    activeTab: 0,
    productList: [],
    form: [{
        label: "客户",
        error: false,
        errMsg: "",
        type: "route",
        url: "/CRM/customer/index?selectMode=true",
        params: {},
        value: "",
        placeholder: "客户名称",
        valueName: "name",
        required: false,
        checking: "base",
        interrupt: true
      },
      {
        label: "门店",
        error: false,
        errMsg: "",
        type: "text",
        value: "",
        placeholder: "门店名称",
        valueName: "storename",
        required: false,
        checking: "base",
        disabled: true
      },
      {
        label: "开单日期",
        error: false,
        errMsg: "",
        type: "date",
        value: "",
        placeholder: "请选择开单日期",
        valueName: "billdate",
        required: false,
        checking: "base"
      },
      {
        label: "订单数量",
        error: false,
        errMsg: "",
        type: "number",
        value: "0",
        placeholder: "订单数量",
        valueName: "orderCount",
        required: false,
        checking: "base",
        disabled: true
      },
      {
        label: "订单金额",
        error: false,
        errMsg: "",
        type: "number",
        value: "0",
        placeholder: "订单金额",
        valueName: "amount",
        required: false,
        checking: "base",
        disabled: true
      },
      {
        label: "备注",
        error: false,
        errMsg: "",
        type: "textarea",
        value: "",
        placeholder: "请输入备注",
        valueName: "remarks",
        required: false,
        checking: "base"
      }
    ],
    "content": {
      "sa_custorderid": 0,
      "sa_customersid": 0,
    }
  },
  onLoad(options) {
    getApp().globalData.setCustomer = this.setCustomer.bind(this);
    // 如果传递了客户信息，填充到表单
    try {
      const customerInfo = getCurrentPages().find(v => v.__route__ == 'CRM/customer/detail').data.detail;
      let form = this.data.form;
      // 填充客户信息到表单
      form.forEach(item => {
        if (item.valueName === 'name' && customerInfo.name) {
          item.value = [customerInfo.name, [customerInfo.sa_customersid]];
          item.disabled = true;
        }
        if (item.valueName === 'storename' && customerInfo.storename) {
          item.value = customerInfo.storename;
        }
      });
      this.setData({
        form,
        "content.sa_storeid": customerInfo.sa_storeid,
        "content.storeno": customerInfo.storeno,
        "content.sa_customersid": customerInfo.sa_customersid,
      });
    } catch (error) {
      console.error("解析客户信息失败", error);
      // 从订单列表页面跳转过来，需要选择客户
      this.selectCustomer();
    }

    // 设置默认开单日期为当天
    const today = new Date().toISOString().split('T')[0];
    let form = this.data.form;
    form.forEach(item => {
      if (item.valueName === 'billdate') {
        item.value = today;
        this.setData({
          "content.billdate": today
        });
      }
    });
    this.setData({
      form
    });
  },
  // 选择客户
  selectCustomer() {
    // 设置全局回调函数
    wx.navigateTo({
      url: "/CRM/customer/index?selectMode=true"
    });
  },
  // 设置客户信息
  setCustomer(customerInfo) {
    this.setData({
      "content.sa_storeid": customerInfo.sa_storeid,
      "content.storeno": customerInfo.storeno,
      "content.sa_customersid": customerInfo.sa_customersid,
      "content.name": customerInfo.name || '',
      "content.storename": customerInfo.storename || ''
    });

    // 更新表单数据
    let form = this.data.form;
    form.forEach(item => {
      if (item.valueName === 'name') {
        item.value = [customerInfo.name, [customerInfo.sa_customersid]];
      }
      if (item.valueName === 'storename') {
        item.value = customerInfo.storename || '';
      }
    });

    this.setData({
      form
    });
  },
  // 切换客户
  switchCustomer() {
    this.selectCustomer();
  },
  submit() {
    // 检查是否有商品
    if (this.data.productList.length === 0) {
      this.addProduct();
      wx.showToast({
        title: '请先添加商品',
        icon: 'none'
      });
      return;
    }

    this.setData({
      loading: true
    });
    let formData = this.selectComponent("#Form").submit();
    delete formData.name
    if (!formData) {
      this.setData({
        loading: false
      });
      return;
    }

    let content = {
      ...this.data.content,
      ...formData
    };

    // 先创建订单
    _Http.basic({
      "id": "2026031309441701", // 创建订单的接口ID
      content
    }).then(res => {
      console.log("保存订单", res);
      if (res.code == 1) {
        const orderId = res.data;
        console.log("订单ID", orderId);

        // 显示加载提示
        wx.showLoading({
          title: '正在处理...',
          mask: true
        });

        // 准备绑定操作
        const promises = [];

        // 绑定商品
        if (this.data.productList.length > 0) {
          promises.push(this.bindProductsWithPromise(orderId));
        }

        // 绑定附件
        const attachmentids = this.selectComponent("#Yl_files").getFiles().attachmentids;
        if (attachmentids && attachmentids.length > 0) {
          promises.push(this.bindAttachmentsWithPromise(orderId, attachmentids));
        }

        // 使用Promise.all处理所有绑定操作
        Promise.all(promises).then(() => {
          // 所有绑定完成，跳转到订单详情
          this.navigateToOrderDetail(orderId);
        }).catch(() => {
          // 绑定失败，跳转到订单详情
          this.navigateToOrderDetail(orderId);
        });
      } else {
        this.setData({
          loading: false
        });
        wx.showToast({
          title: res.msg || '保存失败',
          icon: 'none'
        });
      }
    }).catch(err => {
      this.setData({
        loading: false
      });
      console.error("保存订单失败", err);
      wx.showToast({
        title: '网络错误',
        icon: 'none'
      });
    });
  },
  // 使用Promise.all绑定商品
  bindProductsWithPromise(orderId) {
    const productList = this.data.productList;

    // 创建商品绑定的Promise数组
    const bindPromises = productList.map(product => {
      return new Promise((resolve, reject) => {
        _Http.basic({
          "id": "2026031415462301", // 绑定商品接口ID
          content: {
            sa_custorderid: orderId,
            sa_custorderitemsid: 0,
            sys_enterprise_itemid: product.sys_enterprise_itemid || product.itemid,
            qty: product.qty,
            oldprice: product.originalPrice || product.price,
            discountrate: product.discount,
            price: product.price,
            amount: product.amount,
            remarks: product.remarks || ""
          }
        }).then(res => {
          if (res.code != 1) {
            console.error("绑定商品失败", res);
          }
          resolve(res);
        }).catch(err => {
          console.error("绑定商品失败", err);
          resolve(null); // 即使失败也继续处理
        });
      });
    });

    // 处理附件绑定（预留接口）
    const attachmentPromise = this.bindAttachmentsWithPromise(orderId);

    // 合并所有Promise
    const allPromises = [...bindPromises, attachmentPromise];

    // 使用Promise.all处理所有请求
    return Promise.all(allPromises);
  },
  // 绑定附件
  bindAttachmentsWithPromise(orderId, attachmentids) {
    return new Promise((resolve) => {
      if (!attachmentids || attachmentids.length === 0) {
        resolve(null);
        return;
      }
      _Http.basic({
        "classname": "system.attachment.Attachment",
        "method": "createFileLink",
        id: 10020501,
        "content": {
          ownertable: "sa_custorder",
          ownerid: orderId,
          usetype: 'default',
          attachmentids
        }
      }).then(res => {
        console.log('绑定附件', res);
        if (res.code == 1) {
          resolve(res.data);
        } else {
          console.error('绑定附件失败', res);
          resolve(); // 绑定失败也继续执行
        }
      }).catch(err => {
        console.error('绑定附件错误', err);
        resolve(); // 错误也继续执行
      });
    });
  },
  // 跳转到订单详情
  navigateToOrderDetail(orderId) {
    // 隐藏加载提示
    wx.hideLoading();
    this.setData({
      loading: false
    });
    wx.redirectTo({
      url: `/CRM/order/detail?id=${orderId}`,
      success: () => {
        // 跳转到订单详情页面
        wx.showToast({
          title: "开单成功",
          icon: "none",
          duration: 1500,
        });
      }
    });
  },
  interrupt({
    detail
  }) {
    // 处理中断逻辑，如果需要的话
  },
  /* 表单必填项是否完成 */
  onConfirm({
    detail
  }) {
    this.setData({
      disabled: detail
    });
  },
  onChange(e) {
    this.setData({
      showAll: e.detail
    });
  },
  closePage() {
    wx.navigateBack({
      delta: 1
    });
  },
  // tab切换
  onTabChange(e) {
    this.setData({
      activeTab: e.detail
    });
  },
  // 打开添加商品面板
  addProduct() {
    // 直接跳转到产品选择页面
    wx.navigateTo({
      url: `/CRM/customer/modules/orderCreate/productSelect/index?params=${JSON.stringify({
        "id": "2026031312441901",
        "content": {
          "pageNumber": 1,
          "pageSize": 20,
          "where": {
            "tablefilter": {
              "itemname": null,
              "itemno": null,
              "model": null,
              "guid_price": null,
              "guid_price_cus": null,
              "packageqty": null
            }
          }
        }
      })}&butText=添加商品`
    });
    // 设置全局回调函数
    getApp().globalData.handleSelect = this.handleSelect.bind(this);
  },
  // 处理选择商品回调
  handleSelect(detail) {
    if (detail && detail.list) {
      const existingItemIds = this.data.productList.map(item => item.sys_enterprise_itemid);

      // 过滤掉已经存在的商品
      const newProducts = detail.list.filter(item => !existingItemIds.includes(item.sys_enterprise_itemid)).map(item => {
        // 处理价格字段，去除格式化符号
        const priceStr = item.guid_price_cus || item.price || "0";
        const price = parseFloat(priceStr.toString().replace(/[￥,]/g, '')) || 0;
        const qty = parseInt(item.qty) || 1;

        return {
          itemid: item.itemid,
          sys_enterprise_itemid: item.sys_enterprise_itemid,
          itemname: item.itemname,
          itemno: item.itemno,
          model: item.model,
          originalPrice: price,
          price: price,
          discount: 1,
          qty: qty,
          amount: parseFloat((price * qty * 1).toFixed(2)),
          remarks: item.remarks || ''
        };
      });

      if (newProducts.length > 0) {
        this.setData({
          productList: [...this.data.productList, ...newProducts]
        });

        // 更新订单金额
        this.updateOrderAmount();
      } else {
        wx.showToast({
          title: '所选商品已在列表中',
          icon: 'none'
        });
      }

      // 返回页面
      wx.navigateBack();
    }
  },
  // 处理字段编辑
  onFieldBlur(e) {
    const index = e.currentTarget.dataset.index;
    const field = e.currentTarget.dataset.field;
    const value = e.detail.value;

    const productList = [...this.data.productList];
    const product = productList[index];

    // 处理不同字段的编辑
    switch (field) {
      case 'price':
        product.price = parseFloat(value) || 0;
        // 重新计算金额，保留两位小数，折扣1=100%
        product.amount = parseFloat((product.price * product.qty * product.discount).toFixed(2));
        break;
      case 'discount':
        product.discount = parseFloat(value) || 1;
        // 重新计算金额，保留两位小数，折扣1=100%
        product.amount = parseFloat((product.price * product.qty * product.discount).toFixed(2));
        break;
      case 'qty':
        let qty = parseInt(value) || 1;
        // 数量不能为0
        qty = Math.max(1, qty);
        product.qty = qty;
        // 重新计算金额，保留两位小数，折扣1=100%
        product.amount = parseFloat((product.price * product.qty * product.discount).toFixed(2));
        break;
      case 'amount':
        product.amount = parseFloat(value) || 0;
        // 重新计算单价（假设数量和折扣不变），保留两位小数，折扣1=100%
        if (product.qty > 0 && product.discount > 0) {
          product.price = parseFloat((product.amount / (product.qty * product.discount)).toFixed(2));
        }
        break;
      case 'remarks':
        product.remarks = value;
        break;
    }

    this.setData({
      productList
    });

    // 更新订单金额
    this.updateOrderAmount();
  },
  // 删除商品
  deleteProduct(e) {
    wx.showModal({
      title: '提示',
      content: '确定要删除这个商品吗？',
      confirmText: '确定',
      cancelText: '取消',
      success: (res) => {
        if (res.confirm) {
          const index = e.currentTarget.dataset.index;
          const productList = [...this.data.productList];
          productList.splice(index, 1);

          this.setData({
            productList
          });

          // 更新订单金额
          this.updateOrderAmount();
        }
      }
    });
  },
  // 更新订单金额
  updateOrderAmount() {
    // 计算总金额，确保不是NaN，默认0
    const totalAmount = parseFloat(this.data.productList.reduce((sum, item) => {
      const amount = parseFloat(item.amount) || 0;
      return sum + amount;
    }, 0)) || 0;

    // 计算总数量，所有商品数量的总计
    const totalQty = this.data.productList.reduce((sum, item) => {
      const qty = parseInt(item.qty) || 0;
      return sum + qty;
    }, 0);

    const form = [...this.data.form];
    form.forEach(item => {
      if (item.valueName === 'amount') {
        item.value = totalAmount.toString();
        this.setData({
          "content.amount": totalAmount
        });
      }
      if (item.valueName === 'orderCount') {
        item.value = totalQty.toString();
        this.setData({
          "content.orderCount": totalQty
        });
      }
    });
    this.setData({
      form
    });
  },
  // 处理上传状态
  changeState({
    detail
  }) {
    this.setData({
      loading: detail
    });
  },
  // 处理文件上传回调
  handleFileUpload({
    detail
  }) {
    console.log("detail", detail)
    Promise.all(detail.map(attachmentid => {
      return _Http.basic({
        "id": 2024061710590401,
        "content": {
          "pageSize": 1,
          "pageNumber": 1,
          "attachmentid": attachmentid
        }
      })
    })).then(res => {
      console.log('获取文件详情', res);
      this.selectComponent("#Yl_files").handleFiles(res.map(v => v.data[0]))
    })
  },
});