var t = getApp(), app = t, a = t.request, e = require("../../../../utils/common.js"),
  s = require("../../../../utils/util.js"), rq = require("../../../../utils/request.js"), ut = s, o = require("../../../../utils/md5.js"), to = getApp();
var oo = t.globalData.setting, os = oo;
var regeneratorRuntime = require('../../../../utils/runtime.js');
var util_pay = require("../../../../utils/pay.js");
var zh_calc = require("zh_calculate.js");
var ladder_calc = require("ladder_calculate.js");

// 防抖函数用定时器    
//公共的函数合并在一起
const m_cx = require("../../../../utils/more_cx.js");

// 防抖函数用定时器   
let timer;
Page({
  data: {

    url: t.globalData.setting.url,
    resourceUrl: t.globalData.setting.resourceUrl,
    imgUrl: t.globalData.setting.imghost,
    goods: null,
    order: null,
    orderPrices: null,
    coupons: null,
    coupon: null,
    invoiceToggle: !0,
    payWithUserMoney: !0,
    payWithPoints: !0,
    maxWord: 0,
    enterAddressPage: !1,
    firstEnter: !0,
    //页面获取的参数
    param: null,
    //提交订单的格式
    formData: {
      order_amount: 0,//支付金额
      total_amount: 0,//总价
      all_price: 0,//商品卖的总价
      pay_points: 0,//使用积分
      user_money: 0,//使用余额
      couponCode: "",//使用优惠券(多单就用逗号隔开)
      shipping_price: 0,//物流费用
    },

    /*-----------当是购物车结算的时候-------------*/
    cartlist: null,
    old_cartlist: null,
    cartlist_y: null,  //购物车原始列表
    js_use_money: 0,  //是否使用余额
    is_all_zt: 1,      //是否全部都是自提

    /*----------------立即购买---------------------*/
    is_b_now: 0,    //0是购物车结算  1立即购买
    bn_goods: null, //立即购买时候的调用商品
    bn_use_money: 0,//是否使用余额
    bn_exp_type: 1, //0是物流 1自提
    bn_pick: 0,     //选择的门店
    bn_pickname: "", //选择的门店名称
    bn_t_exp_t: 0,    //判断商品和门店一起决定的物流自提的方式0 都可以 1自提 2物流

    bn_is_order_yh: 1,  //是不是订单优惠
    bn_is_post_temp: 1, //是不是进行计算包邮模板

    bn_plus_cut_price: 0,  //显示等级卡会优惠多少钱
    /*------------------------*/
    user_addr: null,//物流
    userinfo: null, //获取会员
    /*----------物流选择--------*/
    wu_arr: null,
    index: 0,
    w_sele_index: 0,

    //判断页面是返回回来的还是 首次进入的
    isclose: 1,
    //申请提现的金额
    txmon: 0,
    yuer: 0,
    //提交中，不重复提交
    is_summit_ing: 0,
    //--更优惠券抵用有关，立即购买的，如果是购物车，就要把相应的值，写入cartlist数组中--
    ckeck_quan_price: 0,
    check_quan_price_list: '',
    check_quan_ware_list: '',

    // 设计一个数组来存放已经选择了的券编号,coupon_no是券号，money是面值，coupon_price是真正优惠的价格，数组的下标是pickid
    //using_quan[11]={coupon_no:"1212121",money:"20",coupon_price:"45"}
    using_quan: {},
    open_quan: 0,
    //选择的券列表
    selected_quan_list: null,
    //选择的券的门店
    selected_quan_pick: null,
    is_close_quan: 0,
    disabled: 0,
    open_express: 0,//控制选择物流名列表 的属性

    is_express: 0,       //选中物流的属性
    expres_name: "",     //点击选定
    isopen: 0,           //券的说明
    is_coupon: 1,     //选择券的控制属性
    is_shipping_code: "",//插入用户默认地址
    wu_arr_txt: "",      //要更新的物流的字段
    sales_rules: 1,         //默认是显示线上库存
    isget_by_quan: {},       //是否调用了接口获取包邮券
    get_by_quan_list: null,       //立即购买的
    get_by_quan_list_cart: {},    //购物车的
    by_quan_list_cart: null,   //点击选择的包邮列表
    //如果是全场包邮了，或者是全场不包邮了，就不要选包邮券
    is_no_by: {},
    is_by: {},
    is_quan_by: {},
    //--购买赠送的商品--
    buy_now_gift_goods: null,
    //--订单优惠--
    order_prom: {},
    //-- 购物车优惠活动 --
    prom_goods_map: {},
    //-- order_prom_list --
    order_prom_list_cart: null,

    ispt_goods: 0,       //是否平摊至单品，0要平摊 1不平摊

    rank_switch: 0,      //是不是开同等级卡
    show_card: null,     //显示的等级卡
    card_name: '',       //显示的卡的名称
    card_cut_price: null,//减价多少钱

    show_submit: 0,      //提交按钮变正常显示
    is_get_offline: 1,

    tabs: ['门店自提', '快递邮寄'],
    currentTabIndex: 1,

    in_zhact_gdmap: {}, //不同门店参与同一活动的限购，这些都是map表，很
    in_zhact: {},        //组合购活动在列表中的显示
    in_yhact: {},        //优惠活动在列表中的显示
    in_zh_gd_buy_map: {},  //就是商品在组合购中的

    in_zhact_gdmap_new: {}, //不同门店参与同一活动的限购，这些都是map表，是多促销互动专用，不能和in_zhact_gdmap重叠
    in_zhact_new: {},        //组合购活动在列表中的显示 是多促销互动专用，不能和in_zhact重叠
    in_yhact_new: {},        //组合购活动在列表中的显示 是多促销互动专用，不能和in_yhact重叠

    hid_inp: 1,
    user_note: "",
    zhhe_act_map: {},    //组合活动的map表
    zuhe_map_good: {},  //组合购的map表
    ladder_map: {},  //阶梯促销的map表
    is_no_past: 1,
    state: 0,  //阶梯促销的的立即购买也走购物车流程state=1
    show_duo_gift: 0,
    send_gf: {}, //多赠品的计算
    send_lb: {},
    month_lb: {}, //每月礼包数据
    dis_config: null,
    bn_use_commission: 0, //是不是使用佣金
    cart_use_commission: 0,
    cart_commission: 0,
    udata: null,//用户预存值，数据
    //订单所有搭配购的
    all_collocation_list: [],
    appoint_pick_keyid: '',
    is_pre_cut: 0, //是否可以使用预存 0是不可以1的可以

    coll_prom: {}, //搭配活动存储
    yh_is_xz_yh: {},//优惠促销优惠券使用开关

    same_ok: 1,  //同城配送的控制，默认ok

    bconfig: null,
    showFold: true,

    ly_map: {},
    template_id: [],

    //用于后台计算的多促销集合
    show_can_cx_map: {},
    //优惠促销活动的集合
    yhcx_act_map: {},

    //优惠促销购买次数
    yhcx_buy_map: {},

    //-- 订单促销判断积累 ---2024-2-20
    order_prom_map_ck: {},
    //能不能使用订单促销
    can_use_ord_prom: {},
    //存储订单促销的取价，按照门店进行索引
    show_ord_prom: {},
    
    sameCityExp_off: 0, //未达到起送价
    sameCityExp_info: '',//未达到起送价提示信息
    first_entry: 0,//进入次数，如果是第一次进入，进行判断是否进行优惠券是否直接使用
    def_coupon1: null,//购物车优惠券列表
    def_coupon2: null,//直接购买优惠券列表
    def_coupon3: null,//购物车包邮券列表
    def_coupon4: null,//直接购买包邮券列表

  },


  onReady() {

    setTimeout(() => {
      wx.createSelectorQuery().selectAll(".showArea, .hideArea").boundingClientRect(res => {
        if (res.length != 0) {
          this.setData({
            showFold: res[0].height < res[1].height,
          });
        };

      }).exec();
    }, 1000);

  },

  clickCollapse() {
    this.setData({
      flag: !this.data.flag,
    })
  },

  onLoad: async function (t) {

    this.data.fir_in = 1;

    wx.setNavigationBarTitle({ title: "填写订单", })
    var th = this;
    this.setData({ is_b_now: t.is_bnow == undefined ? 0 : t.is_bnow, });
    th.data.param = t;
    //清理一下，确保最新的系统配置
    getApp().globalData.config2 = null;
    //清空is_pick_up
    getApp().request.put("/api/weshop/useraddress/updatePickUp", {
      data: { user_id: getApp().globalData.user_id, is_pickup: 0 },
      success: function (s) { }
    });
    getApp().getConfig2(function (e) {
      th.setData({
        bconfig: e
      });
    }, 1);

    //阶梯购 或者 组合购的立即购买
    if (t.state) {
      th.data.state = 1;
    }
    // getApp().promiseGet("/api/wx/weappSendlist/page", {
    //   data: {
    //     store_id: os.stoid,
    //     typeid: "1001"
    //   }
    // }).then(res => {
    //   if (res.data.code == 0 && res.data.data.pageData.length > 0) {
    //     var template_id = res.data.data.pageData[0].template_id;
    //     th.setData({ template_id: template_id });
    //   }
    // })
    try {
      let template_id = await getApp().get_template_id('1001,1012,1027')
      this.setData({
        template_id
      })
    } catch (error) { }
    //判断是不是佣金抵扣
    getApp().is_distribut(this);

  },
  onUnload: function () {
    this.setData({ isclose: 1 })
  },

  onReady() {

    setTimeout(() => {
      wx.createSelectorQuery().selectAll(".showArea, .hideArea").boundingClientRect(res => {
        if (res.length != 0) {
          this.setData({
            showFold: res[0].height < res[1].height,
          });
        };

      }).exec();
    }, 1000);

  },

  clickCollapse() {
    this.setData({
      flag: !this.data.flag,
    })
  },
  onHide: function () {
    this.setData({
      isget_by_quan: {},
      is_no_by: {},
      is_by: {},
      send_gf: {},
      send_lb: {},
      month_lb: {},
    })
  },

  //----------子页返回父页触发----------
  onShow: function () {


    var th = this;
    //判断是不是第一次进入
    if (this.data.fir_in) {
      this.data.fir_in = 0;
    } else {
      //富友支付取消支付强行回去
      var fy = ut.fy_back("/pages/user/order_list/order_list", 1);
      if (fy) return false;
      util_pay.set_fir();

      //-- 通联的第三方支付的返回优化 --
      ut.is_pay_ok(th.data.ok_order_sn, "/packageG/pages/payment/pay_success/pay_success?type=2&order_sn=" + this.data.ok_order_sn,
        "/pages/user/order_list/order_list", function () {
          //支付信息会先记录着
          if (!th.data.ok_order_sn) return false;
          getApp().request.promiseGet("/api/weshop/order/page",
            { data: { store_id: os.stoid, parent_sn: th.data.ok_order_sn } }).then(res => {
              if (ut.ajax_ok(res)) {
                var item = res.data.data.pageData[0];
                if (item.pay_status == 1) {
                  //支付支付，返回首页
                  ut.m_toast('支付成功');
                  setTimeout(() => {
                    getApp().re_to("/packageG/pages/payment/pay_success/pay_success?type=2&order_sn=" + th.data.ok_order_sn);
                  }, 1000)

                } else {
                  //支付支付，返回首页
                  ut.m_toast('支付失败');
                  setTimeout(() => {
                    getApp().goto("/pages/index/index/index");
                  }, 1000)
                }
              }
            })
        });
    }


    th.data.g_cart_q_time = null;
    if (th.data.isclose == 0) {
      wx.navigateTo({
        url: "/pages/index/index/index"
      })
    } else {
      this.getuser_addr(function (ie) {
        console.log("getuser_addr")
        console.log(ie)
        //地址切换要把包邮券清空
        if (!th.data.user_addr || !ie || th.data.user_addr.address_id != ie.address_id) {
          var using_quan = th.data.using_quan;
          for (var i in using_quan) {
            var item = using_quan[i];
            if (item.isby == 1) {
              var ob = {}, txt = "using_quan[" + i + "]";
              ob[txt] = {};
              th.setData(ob);
            }
          }
          th.data.isget_by_quan = {};
        }


        //th.data.prom_goods_map = {};
        th.data.is_summit_ing = 0;
        //更换地址回来要重新调用计算价钱的接口
        if (!th.data.user_addr || th.data.user_addr.address_id != ie.address_id) {
          th.setData({ user_addr: ie, show_submit: 0 });
          if (th.data.is_b_now == 1) {
            if (th.data.bn_goods) {
              th.setData({ add_back: 1, same_ok: 1 });
              //th.calculatePrice2();
            }
          } else {
            if (th.data.cartlist) {
              th.setData({ add_back: 1, same_ok: 1 });
              //th.calculatePrice();
            }
          }
        } else {
          th.setData({ user_addr: ie, show_submit: 0 });
        }
      });
      var is_card_back = getApp().globalData.is_card_back;
      //--更新默认地址--,看一下是不是跳到地址页面,同时也不是购买等级卡返回的，这里很重要，否则会重新更新收货物流公司
      if (!getApp().globalData.is_cart_old && !is_card_back && !getApp().globalData.plus_buy_back) {
        this.update_code();
      } else {
        getApp().globalData.is_cart_old = 0;
        getApp().globalData.plus_buy_back = 0;
      }
    }



    this.setData({
      show_ord_prom:{},
      can_use_ord_prom:{}
    })

    //先获取是否有关闭使用优惠券
    getApp().getConfig2(function (ee) {
      var json_d = JSON.parse(ee.switch_list);

      //测试强行写死，后面一定要删除
      //json_d.pickupway=2;

      th.data.json_d = json_d;
      th.data.ispt_goods = json_d.ispt_goods;  //是不是平摊到单品的控制参数赋值
      var is_default_logistics = json_d.is_default_logistics;
      var is_same_city = json_d.is_same_city;

      th.setData({
        is_pre_cut: json_d.is_pre_cut,//预存是否可以使用0是不可以 ，1是可以
        is_close_quan: json_d.is_close_quan,
        sales_rules: ee.sales_rules,
        rank_switch: json_d.rank_switch,
        is_default_logistics: is_default_logistics,
        is_same_city: is_same_city,
        appoint_pick_keyid: json_d.appoint_pick_keyid
      });

      var rank_switch = json_d.rank_switch;
      var max_price = -1;
      var show_card = null;
      var name = "";
      //如果有开等级卡的时候,
      //因为都是调接口，要返回在计算
      if (rank_switch == 2) {
        //-- 获取所有的等级卡, --
        getApp().request.promiseGet("/api/weshop/plus/vip/mem/bership/list?storeId=" + os.stoid,
          {}).then(res => {
            if (res.data.code == 0) {
              var plusCard = res.data.data;
              //-- 循环判断，拿到最贵的那张卡 --
              for (var ih in plusCard) {
                if (plusCard[ih].IsStopBuy == true) {
                  continue;
                }
                if (max_price < 0) {
                  max_price = plusCard[ih].CardFee;
                  name = 'card' + plusCard[ih]['CorrPrice'];
                  show_card = plusCard[ih];
                } else {
                  if (max_price < plusCard[ih].CardFee) {
                    max_price = plusCard[ih].CardFee;
                    name = 'card' + plusCard[ih]['CorrPrice'];
                    show_card = plusCard[ih];
                  }
                }
              }

              if (show_card) {
                name = name.toLowerCase();
                th.setData({ card_name: name, show_card: show_card })
              }
            }
            //-----先获取物流，再获取用户信息，再展示页面-----
            th.get_wuliu(th.get_info(th.show_page));
          })
      } else {
        //-----先获取物流，再获取用户信息，再展示页面-----
        th.get_wuliu(th.get_info(th.show_page));
      }

    }, 1);
    //值在这里换
    getApp().globalData.plus_buy_back = 0;
  },
  //获取预存款余额
  async getAdvancesum() {
    /*-----获取线下会员的预存款和优惠券的数量-----*/
    let url = "/api/weshop/users/getinfo/" + os.stoid + "/" + getApp().globalData.userInfo.user_id
    await getApp().request.promiseGet(url, {
      data: {
        isShowLoading: 0,
      },
    }).then(su => {
      if (su.data.code == 0 && su.data.data) {
        var data = su.data.data;
        if (!data) data = {};
        data.cashcount = parseInt(data.cashcount);
        this.setData({
          udata: data,
        });
      }
    })
  },

  //购物车预存开启关闭
  prestore(e) {
    let ind = e.currentTarget.dataset.ind;
    let item = e.currentTarget.dataset.item
    let txt = 'cartlist[' + ind + '].yck_off';
    let txt1 = 'old_cartlist[' + ind + '].yck_off';
    if (item.yck_off == 2) {
      this.setData({ [txt]: 1, [txt1]: 1 })
    } else if (item.yck_off == 1) {
      this.setData({ [txt]: 2, [txt1]: 2 })
    }
    this.calculatePrice()//计算金额
  },


  //直接购买预存开启关闭
  prestore2() {
    let txt = 'bn_goods.yck_off';
    if (this.data.bn_goods.yck_off == 2) {
      this.setData({ [txt]: 1 })
    } else if (this.data.bn_goods.yck_off == 1) {
      this.setData({ [txt]: 2 })
    }
    //搭配购直接购买特殊处理
    if (this.data.collocation_goods && this.data.collocation_goods.length > 0 && this.data.cartlist) {
      let txt = 'cartlist[0].yck_off';
      let txt1 = 'old_cartlist[0].yck_off';
      if (this.data.cartlist[0].yck_off == 2) {
        this.setData({ [txt]: 1, [txt1]: 1 })
      } else if (this.data.cartlist[0].yck_off == 1) {
        this.setData({ [txt]: 2, [txt1]: 2 })
      }
      this.calculatePrice()//计算金额
    } else {
      this.calculatePrice2()//计算金额
    }
  },
  //计算商品预存款前置方法------------------------------------
  async beforAdvancesum(cartList) {
    // let cartList= this.data.cartlist
    // let cartList= arr
    // let length = cartList.length
    if (!this.data.is_pre_cut) {
      return {}
    }
    wx.showLoading({
      title: '加载中',
      mask: true
    })
    // for (let i = 0; i < length; i++) {
    let item = cartList;
    let goods = item.goods
    let keyid = item.sto.keyid
    let listform = []

    //-- 如果有订单优惠的时候，就要进行第二次平摊,要用实收来判断满 --
    if (cartList.order_prom_amount > 0) {
      let new_arr = [];
      //--- 预存要以商品的实收为准, ---
      goods.map(ite => {
        //-- 不是赠品的时候 --
        if (!ite.is_gift) {
          let obj = {
            goods_sn: ite.goods_sn,
            goods_id: ite.goods_id,
            prom_type: ite.prom_type,
            prom_id: ite.id,
            goods_price: ite.goods_price,   //account是平摊后的实收价格
            goods_num: ite.goods_num,
            sumgoods_price: ite.account_fir * ite.goods_num - ite.account_yu_fir - (ite.quan_num ? ite.quan_num : 0)  //-- 优惠后的实收 --
          }
          new_arr.push(obj);
        }

      })

      //-- 如果系统要平摊到单品 --
      var pt_data = {
        'prom_id': 1,
        'dis': cartList.order_prom_amount,
        'goods': new_arr
      }
      var pt_res = null;
      await getApp().request.promisePost("/api/weshop/order/getGoodsSplit", {
        is_json: 1,
        data: pt_data
      }).then(res => {
        if (res.data.code == 0) {
          pt_res = res.data.data;
        }
      })
      if (pt_res) {
        for (let io = 0; io < new_arr.length; io++) {
          //要防止空对象，用 || 0
          new_arr[io].account_yc = this.arr_get_goods_n(new_arr[io], pt_res).fisrt_account || 0;
          new_arr[io].account_yc_yu = this.arr_get_goods_n(new_arr[io], pt_res).fisrt_account_yu || 0;
        }
      }

      new_arr.map(ite => {
        let obj = {
          wareno: ite.goods_sn,
          price: ite.account_yc,   //account是平摊后的实收价格
          qty: ite.goods_num,
          sumprice: parseFloat(ite.account_yc * ite.goods_num - ite.account_yc_yu).toFixed(2)
        }
        listform.push(obj)
      })
    }
    else {
      goods.map(ite => {
        //-- 不是赠品的时候 --
        if (!ite.is_gift) {
          let obj = {
            wareno: ite.goods_sn,
            price: ite.account_fir,   //account是平摊后的实收价格
            qty: ite.goods_num,
            sumprice: parseFloat(ite.account_fir * ite.goods_num - ite.account_yu_fir - (ite.quan_num ? ite.quan_num : 0)).toFixed(2)
          }
          listform.push(obj)
        }
      })

    }


    let arr = await this.getGoodsAdvancesum(keyid, listform, cartList)
    // }
    wx.hideLoading()
    return arr
  },

  //计算商品预存款请求方法------------------------------------
  async getGoodsAdvancesum(storageid, listform, cartList) {
    if (!getApp().globalData.config) {
      await getApp().request.promiseGet("/api/weshop/store/get/" + os.stoid, {
      }).then(res => {
        if (res.data.code == 0) {
          getApp().globalData.config = res.data.data
        }
      })
    }
    if (!getApp().globalData.config) return false;
    let res = await getApp().request.promisePost(`/api/weshop/delphiapi/saveErpApi`, {
      data: {
        accdb: getApp().globalData.config.erpid,
        ApiName: 'api.pos.shop.advancesum.seek',
        usercode: "admin",
        vipid: this.data.userinfo.erpvipid,
        oddsum: "0",
        advancesum: cartList.order_amount,
        storageid: storageid,
        listform
      },
      is_json: 1
    })
    console.log('计算商品的预存款');
    console.log(res);
    let yck = 0
    let yckid = ""
    let yckIdArr = []
    let pre_json = null
    if (res.data.code == 0 && res.data.data && res.data.data.length > 0) {
      let resData = res.data.data
      resData.map(ite => {
        yck += ite.advancesum * 1
        yckIdArr.push(ite.advanceitemid)
      })
      pre_json = resData
    }
    yckid = yckIdArr.join()
    let obj = {}
    if (yck * 1 > 0) {
      obj.yck_off = 1
    } else {
      obj.yck_off = 0
    }
    obj.yck = yck.toFixed(2)
    obj.yckid = yckid
    obj.pre_json = pre_json
    return obj
  },

  //支付成功后预存处理请求
  async setAdvancesum(item, number) {
    let pre_json = item.pre_json ? JSON.parse(item.pre_json) : []
    if (!pre_json.length) { return }
    let listform = []
    pre_json.map(ite => {
      let ob = {
        advanceitemid: ite.advanceitemid,
        insum: "",
        outsum: ite.advancesum,
        remark: ""
      }
      listform.push(ob)
    })
    let obj = {
      accdb: getApp().globalData.config.erpid,
      ApiName: 'api.pos.shop.vipinfolist.save',
      vipid: this.data.userinfo.erpvipid,
      storageid: item.keyid,
      operator: "admin",
      number,
      listform,
    }
    let res = await getApp().request.promisePost(`/api/weshop/delphiapi/saveErpApi`, {
      data: obj,
      is_json: 1
    })
  },

  //-------------------获取物流---------------
  get_wuliu(func) {
    var th = this;
    to.getwuliu(function (e) {
      //系统是是否开启了默认的物流
      if (th.data.is_default_logistics) {
        //如果第一个不是开启默认，说明要让用户自己选
        if (!e[0].is_default) {
          th.setData({ is_default_logistics: 0 });
        }
      }
      th.setData({ wu_arr: e })
      typeof func == "function" && func();
    })
  },
  //------获取会员信息-----先获取用户信息，在进行下一步---
  get_info: function (func) {
    var user_id = t.globalData.user_id;
    to.auth.get_u(func);
  },

  //------获取会员收货地址-----
  getuser_addr: function (func) {
    var th = this;
    a.get("/api/weshop/useraddress/page", {
      data: { user_id: to.globalData.user_id, store_id: oo.stoid, pageSize: 600, t: Math.random() },
      success: function (su) {

        var item = null;
        if (su.data.code == 0 && su.data.data && su.data.data.pageData) {
          var user_addr = su.data.data.pageData;
          var def_item = null;
          for (var i = 0; i < user_addr.length; i++) {
            if (user_addr[i]['is_default'] == 1) {
              def_item = user_addr[i];
            }
            if (user_addr[i]['is_pickup'] == 1) {
              item = user_addr[i];
            }
          }

          if (item == null) item = def_item;
          if (item == null) item = user_addr[0];
        }

        if (item == undefined) item = null;
        if (!item) th.setData({ user_addr: null });  //地址为空的时候，要清空，因为返回的时候，有缓存

        func(item);
      }
    });
  },

  //---------------- 展示页面,是再获取用户信息之后 --------------
  async show_page() {
    var th = this, ta = this.data.param;
    //获取用户预存款
    await th.getAdvancesum()
    //会员的信息，要获取最新
    var user = getApp().globalData.userInfo;
    getApp().request.get("/api/weshop/users/get/" + oo.stoid + "/" + user.user_id, {
      data: { r: Math.random() },
      success: function (e) {
        getApp().globalData.userInfo = e.data.data;
        th.setData({ userinfo: e.data.data });

        //选获取地址
        th.getuser_addr(function (addr) {
          th.setData({ user_addr: addr });
          //--------------------------立即购买------------------
          if (ta.is_bnow == 1) {
            //读取门店
            //to.get_allsto(function (e) {
            //th.setData({ allsto: e });
            //获取立即购买的商品信息
            th.get_buy_goods(ta.goods_id);
            //});
          } else {
            //------------------------购物车结算----------------------
            //读取门店
            //to.get_allsto(function (e) {
            //th.setData({ allsto: e });
            //-------获取购物车已经选择的商品--------
            if (!th.data.old_cartlist) {
              th.data.prom_goods_map = {};
              th.get_cart();
            }
            else {
              th.calculatePrice();
            }
            //})
          }
        });

        //获取提现金额
        getApp().request.get("/api/weshop/withdrawals/summoney", {
          data: { user_id: to.globalData.user_id, store_id: oo.stoid, status: 0 },
          success: function (su) {
            if (su.data.code == 0) {
              var yuer = parseFloat(th.data.userinfo.user_money -
                (th.data.userinfo.frozen_money > 0 ? th.data.userinfo.frozen_money : 0) - su.data.data.summoney).toFixed(2);
              th.setData({ txmon: su.data.data.summoney, yuer: yuer });
            }
          }
        });

      },
    });

  },

  //-- 获取搭配购商品gd是商品  arr是购物车商品列表（某个门店的）   --
  async set_collection(gd, arr, index) {
    var th = this;
    var user_id = getApp().globalData.user_id;
    var collocation_list = [];
    var pick = null;
    var distr_t = 0;

    //如果是购物车的时候，
    if (arr) {
      // var idx = th.data.allsto.findIndex(function (e) {
      //   return e.pickup_id == arr[index].pick_id
      // })
      // pick = th.data.allsto[idx];
      var get_gd = null;
      await getApp().request.promiseGet("/api/weshop/goods/get/" + os.stoid + "/" + gd.goods_id, {

      }).then(res1 => {
        if (res1.data.code == 0) {
          get_gd = res1.data.data;
        }
      })
      distr_t = gd.pickup_distr_type || get_gd.distr_type;

    } else {
      var gg = to.get_b_now();
      //---获取门店---
      await getApp().request.promiseGet("/api/weshop/pickup/get/" + oo.stoid + "/" + gg.pick_id, {})
        .then(res => {
          pick = res.data.data;
        });
      distr_t = gd.distr_type || pick.distr_type;
    }

    var prom = null;
    await getApp().request.promiseGet("/api/weshop/goods/getGoodsPromListNew/"
      + os.stoid + "/" + gd.goods_id + "/0/" + user_id, {
    }).then(res => {
      if (res.data.code == 0 && res.data.data) {
        var r_data = res.data.data;
        if (r_data.collocationList) {
          collocation_list = r_data.collocationList;
          prom = r_data.collocationPromList;
        }
      }
    })

    if (!collocation_list) return null;

    var new_arr = collocation_list;
    // for (let i = 0; i < collocation_list.length; i++) {
    //   var item0 = collocation_list[i];
    //   //判断物流配送一样的
    //   if (item0.distr_type == 0 || item0.distr_type == distr_t) {
    //     new_arr.push(item0);
    //   }
    // }

    if (!new_arr.length) return null;

    this.data.coll_prom[prom.id] = prom;

    for (let i = 0; i < new_arr.length; i++) {
      new_arr[i].is_coupon = prom.is_coupon;
    }

    if (arr) {

      //-- 看一下增品是不是已经在购物车列表中 --
      for (var ig = 0; ig < new_arr.length; ig++) {
        var f_coll = arr.find(function (em) {
          return em.goods_id == new_arr[ig].goods_id && em.is_collocation == 1 && new_arr[ig].prom_id == em.prom_id
        })
        if (f_coll) {
          new_arr[ig].selected = 1;
        }
      }

      arr[index].collocationList = new_arr;
    }
    else th.setData({
      all_collocation_list: new_arr
    })

  },


  //-- 获取促销活动的组合 --
  cx_prom_group(prom_list, item1) {
    var th = this;
    //需要读者系统顺序
    var json_d = this.data.json_d;
    var auto_promote_sale = json_d.auto_promote_sale;
    var sort_type = '';

    if (!auto_promote_sale) {
      sort_type = 'prom_type';
    } else {
      var auto_promote_sale = auto_promote_sale.split(',');
      //--- 循环处理 ---
      prom_list.map(function (e) {
        var fd = auto_promote_sale.indexOf(e.prom_type + '');
        e.sort = fd;
        if (e.prom_type == item1.prom_type) {
          e.sele = 1;
        }
      })
      sort_type = 'sort';
    }

    //-- 排序一下,进行升序 --
    function comp(a, b) {
      return a[sort_type] - b[sort_type]; //升序
    }
    //使用sort排序
    prom_list.sort(comp);
  },

  //-----真的获取购物车,入口--------
  get_cart: function () {
    var th = this, app = getApp();
    var state = 0;
    if (th.data.state) state = 1;
    a.get("/api/weshop/cart/listNew1", {
      data: {
        user_id: to.globalData.user_id, selected: 1, state: state,
        store_id: oo.stoid, pageSize: 600,
        isorder: 1
      },
      success: async function (su) {

        var carr = su.data.data.pageData;
        th.setData({ is_all_zt: 1 });

        //-- 找出所有的门店 --
        var pick_id_arr = []; var len = carr.length;
        for (var i = 0; i < len; i++) {
          if (pick_id_arr.length == 0 || pick_id_arr.indexOf(carr[i].pick_id) == -1)
            pick_id_arr.push(carr[i].pick_id);
        }
        //-- 门店不在获取2024-2-3 --
        // var req_d = {
        //   store_id: os.stoid, ids: pick_id_arr.join(',')
        // }
        // //-- 获取门店的列表 --
        // await getApp().request.promiseGet("/api/weshop/pickup/list", { data: req_d }).then(res => {
        //   if (ut.ajax_ok(res)) {
        //     th.data.allsto = res.data.data.pageData;
        //   }
        // })

        th.data.cartlist_y = JSON.parse(JSON.stringify(carr));    //存储原始购物车列表,这个数据还会收到污染
        th.data.cartlist_old = JSON.parse(JSON.stringify(carr));  //存储原始购物车列表
        wx.showLoading();

        th.get_cart_next(carr);

      }
    });
  },


  is_last(gid, goods, map) {
    let last_id = 0;
    for (let i = 0; i < goods.length; i++) {
      if (map && map.indexOf(goods[i].goods_id) > -1) {
        last_id = goods[i].goods_id;
      }
    }
    if (gid == last_id) return true;
    return false;
  },


  //-- is_change是有没有切换活动的意思 --
  async get_cart_next(carr, is_change, old_prom) {

    this.setData({ yh_is_xz_yh: {} });

    //--- 切换的时候一定要把赠品去掉 ---
    if (is_change) {

      carr = JSON.parse(JSON.stringify(this.data.cartlist_y));
      //-- 剔除赠品的数据，等到确定活动是优惠促销的时候，在显示赠品, 赠品直接删除 --
      var new_arr = [];
      for (var ir = 0; ir < carr.length; ir++) {

        carr[ir].collocationList = null;

        var c_ok = 1;
        if (old_prom && (carr[ir].prom_type != old_prom.prom_type || carr[ir].prom_id != old_prom.prom_id)) {
          c_ok = 0;
        }

        if (carr[ir].is_gift && carr[ir].id && c_ok) {

          var url = '/api/weshop/cart/del/' + oo.stoid + '/' + carr[ir].id;
          getApp().request.delete(url, {
            success: function (t) { }
          });
          //商品已经下架
          continue;
        }
        new_arr.push(carr[ir]);
      }

      this.data.cartlist_y = JSON.parse(JSON.stringify(new_arr));
      carr = new_arr;

      //-- map cy_cx属性要删除 --
      var map = this.data.prom_goods_map;
      if (map) {
        for (var ky in map) {
          if (map[ky]) {
            var ob = map[ky];
            for (var ii in ob) {
              var item_map = ob[ii];
              if (item_map.hasOwnProperty('cy_cx')) {
                delete item_map.cy_cx;
              }
            }
          }
        }
      }
    }

    //按门店分类的数组
    var arr = new Array();

    var th = this;
    th.data.in_zhact_gdmap = {};
    //---是不是购买等级卡成功的返回---等级卡显示的判断---
    var is_card_back = getApp().globalData.is_card_back;

    //-- 判断组合购是总数量是不是存在 --
    var no_zh_num = {};
    //-- 多促销活动调用接口需要的参数,和商品的购买数量和活动的购买数量的请求参数 --

    if (!is_change) {
      //-- 多促销活动调用接口需要的参数,和商品的购买数量和活动的购买数量的请求参数 --
      var dug_cx_arr = [];
      //获取 限购 和 多活动的促销---2024-2-1
      for (var iv = 0; iv < carr.length; iv++) {

        let item1 = carr[iv];
        //如果不是活动的时候,不是代发商品的时候,不是赠品的时候,不是阶梯商品拆分的，不是组合购拆分的
        if ([1, 2, 4, 6, 8, 9].indexOf(item1.prom_type) == -1 && !item1.whsle_id
          && !item1.is_gift && !item1.is_ld_split && !item1.is_zh_split) {
          //-- 快速查找,组装查询多活动的列表 --
          let f_idx = dug_cx_arr.findIndex(function (ele) {
            return ele.goods_id == item1.goods_id
          });
          if (f_idx == -1) {
            let gd_ite = {
              goods_id: carr[iv].goods_id,
              goods_num: 1,
              is_limit_show: 0,
              is_state: 0,
              zh_prom_id:item1.zh_prom_id
            }
            dug_cx_arr.push(gd_ite);
          }

        }
      }
      //-- 对商品的多促销进行判断 ---2024-2-1--
      if (dug_cx_arr.length) {
        await th.buy_pro_group(dug_cx_arr, carr);
      }
    }
    //在分组的时候，就不要再调用接口，await
    for (var i = 0; i < carr.length; i++) {
      var item = carr[i];

      //如果有户有点击参与订单促销的话，那么可以参与订单促销的商品的活动都要清理成0，订单促销在使用过程中的重要方法
      if (this.data.can_use_ord_prom[item.pick_id]) {
        //从订单促销的order_prom_map_ck数据结构中获取到可以参与的商品列表
        let gdlist = this.data.order_prom_map_ck[item.pick_id] ? this.data.order_prom_map_ck[item.pick_id].goodsList : null;
        if (gdlist && gdlist.length) {
          //查找商品item1有没有在gdlist中,就要把商品的prom_type清理0
          let f_idx = gdlist.findIndex(function (ele) {
            return ele.id == item.id
          });
          if (f_idx != -1) {
            //开始变换商品的价格显示
            switch (th.data.show_ord_prom[item.pick_id]) {
              case 1:
                carr[i].goods_price = item.shop_price;
                break;
              case 2:
                carr[i].goods_price = item.goods_market_price;
                break;
            }

            if (!carr[i].prom_type) carr[i].prom_type = 0;
            switch (parseInt(carr[i].prom_type)) {
              case 4:
                carr[i].is_integral_normal = 1;
                break;
              default:
                carr[i].is_pd_normal = 1;
                break;
            }
            carr[i].prom_type = 0;
            carr[i].discount_field = th.data.show_ord_prom[item.pick_id];
          }
        }
      }

      //-- 如果是等级会员注册返回 --
      if (is_card_back) {
        th.data.card_name = th.data.userinfo.card_field;
        //如果是秒杀的返回，就要把活动弄回0
        if (item['prom_type'] == 1) {
          item['prom_type'] = 0;
          item['prom_id'] = 0;
        }
        // 拼团,搭配购不计算,赠品也不计算
        if (item['prom_type'] != 5 && item['prom_type'] != 6 && !item.is_gift && !item['is_collocation'] && item.goods_price > item[th.data.card_name]) {
          item.goods_price = item[th.data.card_name];
          carr[i].goods_price = item[th.data.card_name];

        }
      } else {
        // 拼团,搭配购不计算,赠品也不计算,同时会员还未购买等级会员
        if (item[th.data.card_name] > 0 && item['prom_type'] != 5 && item['prom_type'] != 6 && !th.data.userinfo.card_field
          && !item.is_gift && !item['is_collocation'] && item.goods_price > item[th.data.card_name]) {
          item.cut_price1 = item.goods_price - item[th.data.card_name];
          carr[i].cut_price1 = (item.goods_price - item[th.data.card_name]) * item.goods_num;
        }

      }

      //商品的图片不能重复的赋值
      if (item.original_img.indexOf(oo.imghost) == -1)
        item.original_img = oo.imghost + item.original_img;

      var car_item = item;
      /*----接口要弄出来的，先顶着-----*/
      var pcid = car_item.pick_id;
      var find = 0;
      //----如果有就加进去，没有就新增一个----
      //-----------循环查找门店-------------
      if (arr.length > 0) {
        for (var j = 0; j < arr.length; j++) {

          if (arr[j].pickup_id == pcid) {
            if (item.is_gift != 1) {
              //确定配送方式
              if (arr[j].distr_t == 0) {
                arr[j].distr_t = car_item.distr_type;
              }
            } else {
              item.distr_type = 0; //赠品不控制物流的方式
            }

            var e_t = 0, dis_t = 0;//物流方式，配送方式
            if (item.distr_type == 0) {
              dis_t = sto.distr_type;
            } else {
              dis_t = item.distr_type;
            }
            switch (dis_t) {
              case 0:
                if (!arr[j].exp_sure) {
                  e_t = 1;
                  //-- 系统后台有设置要默认的 --
                  if (th.data.json_d.pickupway && th.data.json_d.pickupway == 1) e_t = 0;
                  arr[j].exp_type = e_t
                }
                break;
              case 1:
                e_t = 1;
                arr[j].exp_sure = 1
                arr[j].exp_type = 1
                break;
              case 2:
                e_t = 0;
                arr[j].exp_sure = 1
                arr[j].exp_type = 0
                break;
            }
            //如果是物流的话，全部自提的控制要弄成0
            //if (e_t == 0) th.setData({ is_all_zt: 0 });
            //else th.setData({ is_all_zt: 1 });

            var narr = new Array();
            narr.push(car_item);

            //-----------拼装购物车结算的数组,如果有默认物流时要用默认物流编号,计算默认的物流，不管是不是自提都算一下-----------------
            var m_wind = 0, def_exp_code = getApp().globalData.userInfo.def_exp_code;
            if (def_exp_code && !th.data.is_default_logistics && th.data.wu_arr) {
              for (var k = 0; k < th.data.wu_arr.length; k++) {
                var item = th.data.wu_arr[k];
                if (def_exp_code == item.code) {
                  m_wind = k;
                }

              }
              if (car_item.is_gift != 1) {
                arr[j].exp_type = e_t;
                if (e_t == 0) th.setData({ is_all_zt: 0 });
              }

              //else if (e_t == 1) th.setData({ is_all_zt: 1 });
            }

            //-- 把等级卡会优惠多少钱装进去 --
            if (car_item.cut_price1) arr[j].card_cut_price += car_item.cut_price1;

            arr[j].goods.push(car_item);
            if (car_item.collocationList) {

              if (!arr[j].collocationList) arr[j].collocationList = car_item.collocationList;
              else {
                var arr_new = [...arr[j].collocationList, ...car_item.collocationList];
                arr[j].collocationList = arr_new;
              }
            }

            find = 1;
            break;
          }
        }
      }
      //------如果没有找到-----
      if (find == 0) {
        var pikname = '', sto = null;
        //----找到门店名称-----
        pikname = item.pickup_name;
        sto = {
          pickup_id: item.pick_id,
          pickup_name: pikname,
          distr_type: item.pickup_distr_type,
          keyid: item.keyid,
          is_same_city: item.is_same_city,
        };
        var e_t = 0, dis_t = 0;//物流方式，配送方式
        if (item.distr_type == 0) {
          dis_t = sto.distr_type;
        } else {
          dis_t = item.distr_type;
        }

        let exp_sure = 0;
        switch (dis_t) {
          case 0:
            e_t = 1;
            //-- 系统后台有设置要默认的 --
            if (th.data.json_d.pickupway && th.data.json_d.pickupway == 1) e_t = 0;
            break;
          case 1:
            e_t = 1;
            exp_sure = 1;
            break;
          case 2:
            e_t = 0;
            exp_sure = 1;
            break;
        }
        //如果是物流的话，全部自提的控制要弄成0
        if (e_t == 0) th.setData({ is_all_zt: 0 });
        //else th.setData({ is_all_zt: 1 });

        var narr = new Array();
        narr.push(car_item);

        //-----------拼装购物车结算的数组,如果有默认物流时要用默认物流编号,计算默认的物流，不管是不是自提都算一下-----------------
        var m_wind = 0, def_exp_code = getApp().globalData.userInfo.def_exp_code;
        if (def_exp_code && !th.data.is_default_logistics && th.data.wu_arr) {
          for (var k = 0; k < th.data.wu_arr.length; k++) {
            var item = th.data.wu_arr[k];
            if (def_exp_code == item.code) {
              m_wind = k;
            }
          }
        }
        if (back_data && parseFloat(back_data)) {
          c_item.can_usecommise = parseFloat(parseFloat(back_data).toFixed(2));
          cart_commission += c_item.can_usecommise;
        }

        var ie = {
          pickup_id: pcid,
          pname: pikname,
          goods: narr,
          wind: m_wind,
          distr_t: dis_t,
          card_cut_price: 0,
          exp_type: e_t,
          goods_price: 0,
          shipping_price: 0,
          user_money: 0,
          total_amount: 0,
          order_amount: 0,
          user_note: "",
          sto: sto,
          exp_sure: 1
        };

        //-- 把等级卡会优惠多少钱装进去 --
        if (car_item.cut_price1) ie.card_cut_price += car_item.cut_price1;
        if (car_item.collocationList) {
          ie.collocationList = car_item.collocationList;
        }

        arr.push(ie);
      }
    }
    //-- 如果是回退回来的情况 --
    if (th.data.cartlist && th.data.cartlist.length > 0) {
      for (var kj in th.data.cartlist) {
        for (var ih in arr) {
          var ie = arr[ih];
          if (ie.pickup_id == th.data.cartlist[kj].pickup_id) {
            ie.exp_type = parseInt(th.data.cartlist[kj].exp_type);
            ie.wind = parseInt(th.data.cartlist[kj].wind);

            //-- 是不是全部自提清空 --
            if (ie.exp_type == 0 || ie.exp_type == 2) th.setData({ is_all_zt: 0 });
            break;
          }
        }
      }
    }
    else {
      var is_a_zt = 1;
      for (var ih in arr) {
        var ie = arr[ih];
        //-- 是不是全部自提清空 --
        if (ie.exp_type == 0 || ie.exp_type == 2) is_a_zt = 0;
      }
      th.setData({ is_all_zt: is_a_zt });
    }

    var cart_commission = 0;
    //-- 循环计算一下线下取价 --
    for (var k = 0; k < arr.length; k++) {
      var c_item = arr[k];
      if (!is_change) {
        //-- 要进行归类一下活动 --
        await m_cx.cart_cx_group(th, arr[k].goods, c_item, 0, 0, (show_can_cx) => {
          //后台计算使用
          th.data.show_can_cx_map[c_item.pickup_id] = show_can_cx;
          //-- 把活动组装进去 ---
          let show_can_cx1 = ut.deep_cp(show_can_cx);
          //前端处理渲染的时，要处理一些不需要的字段属性
          if (show_can_cx1) {
            for (const key in show_can_cx1) {
              let element = show_can_cx1[key];
              if (element.cur_act) {
                let c_act = element.cur_act;
                delete c_act.goods;
              }
              if (element.act_arr && element.act_arr.length > 0) {
                for (var ij = 0; ij < element.act_arr.length; ij++) {
                  var act_ite = element.act_arr[ij];
                  delete act_ite.goods;
                  delete act_ite.key;
                }
              }
            }
          }
          arr[k].show_can_cx = show_can_cx1;
        }, 2)
      } else {
        var show_can_cx = this.data.cartlist[k].show_can_cx;
        //-- 多促销活动的优化 --
        if (show_can_cx) {
          arr[k].show_can_cx = show_can_cx;
        }
      }

      //要在多活动确定之后，在来计算
      for (var jh = 0; jh < arr[k].goods.length; jh++) {

        var item1 = arr[k].goods[jh];
        if (arr[k].show_can_cx) {
          for (let key_o in arr[k].show_can_cx) {
            let k_arr = key_o.split(',');

            //秒杀，团购等活动不参与计算
            if (k_arr.indexOf(item1.goods_id + '') > -1 &&  ![1,2,4,6,8,9].includes(parseInt(item1.prom_type+''))){
              //-- 如果初始活动在计算的时候，是不满足的时候，就要把活动清理掉 --
              var is_no_ok = arr[k].show_can_cx[key_o].cur_act.is_no_ok;
              if (is_no_ok == 1) {

                let temp_id = arr[k].show_can_cx[key_o].cur_act.prom_id;
                switch (parseInt(arr[k].show_can_cx[key_o].cur_act.prom_type + '')) {
                  case 3:
                    var yhcx_act_map = th.data.yhcx_act_map ? th.data.yhcx_act_map[temp_id] : null;
                    if (yhcx_act_map && !yhcx_act_map.is_order_yh) {
                      item1.is_no_order_yh = 1;
                    }
                    break;
                  case 7:
                    var zhhe_act = th.data.zhhe_act_map ? th.data.zhhe_act_map[temp_id] : null;
                    if (zhhe_act && !zhhe_act.is_orderyh) {
                      item1.is_no_order_yh = 1;
                    }
                    break;
                }


                item1.prom_id = 0;
                item1.prom_type = 0;

                //这里要判断一下活动的最后一个商品，is_act_last
                if (th.is_last(item1.goods_id, arr[k].goods, arr[k].show_can_cx[key_o].ch_map)) {
                  item1.is_act_last = 1;  //这个是要在前端显示按钮切换的
                }

              } else {

                let obj = arr[k].show_can_cx[key_o];
                //不是优惠促销的不参与  不是订单促销参与（订单促销不是实收价的时候）
                let ck1 = obj.no_cj_prom && obj.cur_act.prom_type == 3;
                let ck2 = th.data.can_use_ord_prom[arr[k].pickup_id];
                if (!ck1 && !ck2) {
                  item1.prom_id = arr[k].show_can_cx[key_o].cur_act.prom_id;
                  item1.prom_type = arr[k].show_can_cx[key_o].cur_act.prom_type;
                }
              }
            }
          }
        }

        //如果是立即购买的时候，item_j.promgoodsbuynum
        if(carr[0].state==1 && item1.prom_type>0){
          item1.promgoodsbuynum=0;
          await getApp().request.promiseGet("/api/weshop/ordergoods/getUserBuyGoodsNum", {
            data: {
              store_id: oo.stoid,
              user_id: getApp().globalData.user_id,
              goods_id: item1.goods_id,
              prom_type: item1.prom_type,
              prom_id: item1.prom_id,
              isnew:1
            },
          }).then(res => {
                // debugger
                if(res.data.code==0 && res.data.data && res.data.data.promgoodsbuynum){
                   item1.promgoodsbuynum = res.data.data.promgoodsbuynum;
                }
          })
        }



        //要把优惠活动加入,prom_goods_map中,赠品不要运算，代发商品不算优惠
        if (item1.prom_type == 3 && item1.is_gift != 1 && !item1.whsle_id) {
          // th.check_is_youhui(item1.goods_id, item1.pick_id);
          //增加优惠活动次数限制
          let limit_num = th.getprom(item1)  //活动限制次数

          if (!limit_num) {
            await th.add_prom_goods_map(item1);
            // item1.prom_id=''
            // item1.prom_type=''
          } else {

            let user_pre_buynum = await th.getUserBuyPromNum_pre(item1.prom_id)  //用户已经参与次数


            if (user_pre_buynum < limit_num) {
              await th.add_prom_goods_map(item1);
            } else {
              // await th.add_prom_goods_map(item1);
              item1.prom_id = ''
              item1.prom_type = ''
            }
          }
        }
        //-- 如果组合购的总数量不足的处理 --
        // if(no_zh_num[item1.prom_id] && item1.prom_type == 7){
        //   item1.prom_type = 0;
        //   item1.prom_type1 = 0;
        //   item1.prom_id = 0;
        //   item1.prom_id1 = 0
        // }

        //要把组合购的东西拿出来算一下,同时组合购的总数量要有存在
        if (item1.prom_type == 7) {

          if (!th.data.zuhe_map_good[item1.prom_id]) {
            var isok = 1;
            var is_flag = 1;
            var store_count_ok = 1;
            //如果有组合购
            var url = "/api/weshop/prom/zhbuy/get/" + os.stoid + "/" + item1.prom_id + '/' + getApp().globalData.userInfo.user_id;
            await getApp().request.promiseGet(url, {}).then(res => {
              if (res.data.code == 0 && res.data.data) {
                //如果活动已经结束
                if (res.data.data.is_end == 1) {
                  isok = 0;
                }
                if (ut.gettimestamp() > res.data.data.end_time) {
                  isok = 0;
                }
                item1.act = res.data.data;

                //-- 在这里要判断一下活动的组合购总数量 --
                if (item1.act.zh_num > 0 && item1.act.zh_buy_num >= item1.act.zh_num) {
                  store_count_ok = 0;
                  no_zh_num[item1.prom_id] = 1;
                  //-- 清理一下活动的状态 --
                  // item1.prom_type = 0;
                  // item1.prom_type1 = 0;
                  // item1.prom_id = 0;
                  // item1.prom_id1 = 0

                } else {
                  th.data.zhhe_act_map[item1.prom_id] = res.data.data;
                }

              } else {
                //未找到商品的活动
                is_flag = 0;
              }
            })

            if (!isok) {
              getApp().my_warnning("组合购的活动已经过期", 0, th);
              return false;
            }

            //------ 先增组合活动的总数量的时候 -------
            if (store_count_ok) {
              var url1 = "/api/weshop/prom/zhbuyGoods/page";
              var req_data = {
                page: 1,
                pageSize: 2000,
                store_id: os.stoid,
                zh_id: item1.prom_id,
              }
              await getApp().request.promiseGet(url1, {
                data: req_data
              }).then(res => {
                if (ut.ajax_ok(res)) {
                  var gdlist = res.data.data.pageData;
                  gdlist.forEach(i => {
                    if (item1.goods_id == i.goods_id && !is_flag) {
                      item1.prom_type = 0;
                      item1.prom_type1 = 0;
                      item1.prom_id = 0;
                      item1.prom_id1 = 0
                    }
                  })
                  th.data.zuhe_map_good[item1.prom_id] = gdlist;
                }
              })
            }


          } else {
            item1.act = th.data.zhhe_act_map[item1.prom_id];
          }
        }
        if (item1.prom_type == 10) {
          if (!th.data.ladder_map[item1.prom_id]) {
            //如果有预售
            var isok = 1;
            var is_flag = 1;
            var act = null;
            var url = "/api/weshop/prom/ladderForm/get/" + os.stoid + "/" + item1.prom_id;
            await getApp().request.promiseGet(url, {}).then(res => {
              console.log(res, 1000);
              if (res.data.code == 0 && res.data.data) {
                if (res.data.data.isuse != 1) {
                  isok = 0;
                }
                //如果活动已经结束
                if (res.data.data.is_end == 1) {
                  isok = 0;
                }
                //已经结束
                if (ut.gettimestamp() > res.data.data.end_time) {
                  isok = 0;
                }
                //还未开始
                if (ut.gettimestamp() < res.data.data.start_time) {
                  isok = 0;
                }
                act = res.data.data;

              } else {
                //未找到商品的活动
                is_flag = 0;
              }
            })
            if (!isok) {
              var url = '/api/weshop/cart/del/' + oo.stoid + '/' + item1.id;
              getApp().request.delete(url, {});
              th.data.ladder_map[item1.prom_id] = -1;
              continue;
            }
            th.data.ladder_map[item1.prom_id] = act;

            //-- 获取阶梯规则 --
            var url1 = "/api/weshop/prom/ladderList/list";
            var req_data = {
              store_id: os.stoid,
              form_id: item1.prom_id,
            }
            await getApp().request.promiseGet(url1, {
              data: req_data
            }).then(rs1 => {
              if (rs1.data.code == 0 && rs1.data.data) {
                var gdlist = rs1.data.data;
                th.data.ladder_map[item1.prom_id].ladder_list = gdlist;
              }
            })
          }
        }

        //-- 判断一下，获取搭配购的消息,只有prom_type==5才会判断优惠活动  --
        if (item1.prom_type == 5 && (!item1.collocationList || !item1.collocationList.length)) {
          await th.set_collection(item1, arr[k].goods, jh);
        }

        if (item1.collocationList) {
          if (!arr[k].collocationList) arr[k].collocationList = item1.collocationList;
          else {
            var arr_new = [...arr[k].collocationList, ...item1.collocationList];
            arr[k].collocationList = arr_new;
          }
        }

        //默认是包邮和优惠的
        item1.is_order_yh = 1;
        item1.is_post_temp = 1;
        //如果是秒杀,团购的时候,优惠促销和搭配购的时候
        if ([1, 2, 3, 5, 6, 7, 10].indexOf(item1.prom_type) > -1) {

          //由于是购物车购买，所以prom_type 基本不会员等于6
          if (item1.prom_type == 1 || item1.prom_type == 6) {
            item1.is_quan = 0;
          }
          let t_goodsActinfo = item1.goodsActinfo;
          if (t_goodsActinfo && t_goodsActinfo.length) {
            let ff_prom = t_goodsActinfo.find(function (e) {
              return e.prom_type == item1.prom_type;
            })
            if (ff_prom) {
              if (item1.prom_type != 7 && item1.prom_type != 10) {
                item1.is_order_yh = ff_prom.is_order_yh;
              } else item1.is_order_yh = 0;

              item1.is_post_temp = ff_prom.is_post_temp;

              //由于是购物车购买，所以prom_type 基本不会员等于6
              if (item1.prom_type == 1 || item1.prom_type == 6) {
                item1.is_quan = item1.cartActinfo.is_quan;
              }
            }
          }

          // var url= "/api/weshop/activitylist/getSJGoodsPriceNew/" + os.stoid
          //     + "/" + item1.goods_id + "/"+item1.prom_type+"/" + item1.prom_id + "/" + app.globalData.user_id;
          // await app.request.promiseGet(url,{}).then(res=>{
          //   if(res.data.code==0){
          //     console.log(res.data.data,"111");
          //     //组合促销有另外一个字段名is_orderyh，在控制订单促销的叠加
          //
          //     if(item1.prom_type!=7 && item1.prom_type!=10) {
          //         item1.is_order_yh=res.data.data.is_order_yh;
          //     }else item1.is_order_yh=0;
          //
          //     item1.is_post_temp=res.data.data.is_post_temp;
          //
          //     if(item1.prom_type==1 || item1.prom_type==6) {
          //         item1.is_quan=res.data.data.is_quan;
          //     }
          //
          //   }
          // })
        }

      }


      var item = arr[k].goods;
      var offline_price = 0;
      var offline_num = 0;
      //计算佣金的商品
      var commission_gds = [];
      for (var c = 0; c < item.length; c++) {

        //-- 有开启佣金抵扣的时候 --
        if (getApp().globalData.userInfo.is_distribut
          && th.data.dis_config && th.data.dis_config.is_yongjin_dk) {

          if (!item[c].is_gift) {
            var hr = {
              goods_id: item[c].goods_id,
              goods_num: item[c].goods_num,
              prom_type: item[c].prom_type,
              prom_id: item[c].prom_id,
            }
            // let req_d1 = {
            //   user_id: getApp().globalData.user_id, goods_ids: [hr], store_id: os.stoid
            // }
            // await getApp().request.promisePost("/api/weshop/order/getrebateSum", {
            //   is_json: 1, data: req_d1
            // }).then(grs => {
            //   if (grs.data.code == 0) item[c].use_commission = grs.data.data;
            // });

            commission_gds.push(hr);
          }
        }

        if (th.data.sales_rules != 2) {
          item[c].offline_price = 0;
        }
        //-- 如果这个商品是线下取价的时候 --
        if (item[c].offline_price > 0 && item[c].prom_type != 7) {
          offline_price += (item[c].goods_price - item[c].offline_price) * item[c].goods_num;
          offline_num += item[c].goods_num;
        }
      }
      if (offline_price > 0) {
        c_item.offline_price = offline_price;
        c_item.offline_num = offline_num;
        c_item.is_offline = 1;
      }

      //-- 如果有佣金抵扣的时候 --
      if (commission_gds.length) {
        //获取购物车的佣金,此处要优化调用接口，获取佣金
        var req_d = {
          user_id: getApp().globalData.user_id, goods_ids: commission_gds, store_id: os.stoid
        }
        var back_data = null;
        await getApp().request.promisePost("/api/weshop/order/getrebateSum", {
          is_json: 1, data: req_d
        }).then(rs => {
          if (rs.data.code == 0) back_data = rs.data.data;
        });

        if (back_data && parseFloat(back_data)) {
          c_item.can_usecommise = parseFloat(back_data);
          cart_commission += c_item.can_usecommise;
        }
      }
    }

    if (cart_commission) {
      th.setData({ cart_commission });
    }

    //每一个门店内的组合购要进行拆分,
    //还得把组合商品的多余商品的线下价格算一算
    for (let var1 in arr) {
      var u_item = arr[var1];
      //把组合购进行分组
      var obj = zh_calc.find_split(u_item);
      if (!obj) {
        continue;
      }
      //存储不同活动的商品列表
      u_item.zh_prom_goods = {};
      for (let var1 in obj) {
        var h_item = obj[var1];
        var gdlist = th.data.zuhe_map_good[h_item.prom_id];
        //获取活动需要的商品列表
        u_item.zh_prom_goods[h_item.prom_id] = { gdlist: gdlist, act: h_item.act };
      }
      zh_calc.fir_set_arr(u_item, th);
    }

    //每一个门店内的阶梯促销要进行拆分,
    //还得把阶梯促销商品的多余商品的线下价格算一算
    for (let var2 in arr) {
      var u_item1 = arr[var2];

      //把阶梯促销进行分组
      var obj = ladder_calc.find_split(u_item1);
      if (!obj) continue;
      //存储不同阶梯促销活动的商品列表
      u_item1.ladder_map = {};
      for (let var1 in obj) {
        var h_item = obj[var1];
        var act = th.data.ladder_map[h_item.prom_id];
        //获取活动需要的商品列表
        u_item1.ladder_map[h_item.prom_id] = act;
      }
      ladder_calc.fir_set_arr(u_item1, th);
    }


    //-- 要判断总开关有没有同城配送 --
    if (th.data.is_same_city) {
      //----- 判断每一个商品的配送方式，和门店的配送方式 -------
      for (var ik = 0; ik < arr.length; ik++) {
        if (!arr[ik].sto.is_same_city) continue;
        var fd = arr[ik].goods.filter(function (e) {
          return e.is_same_city != 1 || e.whsle_id > 0
        })
        if (!fd || fd.length == 0) {
          arr[ik].show_same_city = 1;
        }
      }
    }
    //深拷贝
    th.data.old_cartlist = JSON.parse(JSON.stringify(arr));

    th.data.cartlist = arr;

    //-- 大于20使用逐步渲染 --
    if (arr.length > 10) {
      for (let ib = 0; ib < arr.length; ib++) {
        //-- 都用深拷贝 --
        var ite = ut.deep_cp(th.data.old_cartlist[ib]);
        delete ite.goods;
        var txt0 = "cartlist[" + ib + "]";
        th.setData({
          [txt0]: ite
        })
        //都用深拷贝
        var tt_goods = ut.deep_cp(th.data.old_cartlist[ib].goods);
        for (let iz = 0; iz < tt_goods.length; iz++) {
          var txt = "cartlist[" + ib + "].goods[" + iz + "]";
          setTimeout(() => {
            th.setData({
              [txt]: tt_goods[iz]
            })
          }, ib * 200 + iz * 300 + 100)
        }
      }
    } else {
      th.setData({
        cartlist: arr,
      });
    }

    //--- 获取一下看有没有优惠券 ----
    setTimeout(function () {
      var frozenQuan = null;
      var url0 = "/api/weshop/users/frozenQuan/listFrozenQuan/" + app.globalData.user_id;
      app.request.promiseGet(url0, { 1: 1 }).then(res => {
        if (res.data.code == 0) {
          frozenQuan = res.data.data;
          th.data.frozenQuan = frozenQuan;
        }
        th.calculatePrice();
        th.get_cart_quan();
      })
    }, 500)
  },


  //-----单个商品购买的入口判断----
  get_buy_goods: function (e) {
    var th = this;
    var gg = to.get_b_now();

    //--------如果goods_id一样，就是要立即购买-----
    if (e == gg.goods_id) {
      a.get("/api/weshop/goods/get/" + oo.stoid + "/" + e, {
        success: async function (t) {
          var gd = t.data.data;
          if (!gd) return false;

          //-- 如果商品有同城配送的参数的时候,一件代发商品不能显示同城配送按钮 --
          if (gd.is_same_city && th.data.is_same_city && gd.whsle_id <= 0) {

            await getApp().request.promiseGet("/api/weshop/pickup/get/" + os.stoid + "/" + gg.pick_id, {}).then(res => {
              if (res.data.code == 0) {
                var pk = res.data.data;
                if (pk && pk.is_same_city) {
                  th.setData({ show_same_city: 1 })
                }
              }

            })

          }

          t.data.data.original_img = oo.imghost + t.data.data.original_img;
          t.data.data['buynum'] = gg.goods_num;
          var distr_t = 0, et = 0;


          if (t.data.data.is_minishop == 1 && getApp().is_sp_hao()) {

            if (t.data.data.distr_type == 1 || gg.pick_dis == 1) {
              wx.showToast({
                title: "视频号仅支持物流",
                icon: 'none',
                duration: 2500
              })

              setTimeout(function () {
                wx.navigateBack({ delta: 1 })
              }, 1000)

              return false
            }

            t.data.data.distr_type = 2;
            th.setData({ show_same_city: 0 })

          }


          if (t.data.data.distr_type == 0) {
            distr_t = gg.pick_dis;
          } else {
            distr_t = t.data.data.distr_type;
          }

          switch (distr_t) {
            case 0:
              et = 1;
              //-- 系统后台有设置要默认的 --
              if (th.data.json_d.pickupway && th.data.json_d.pickupway == 1) et = 0;
              break;
            case 1:
              et = 1;
              break;
            case 2:
              et = 0;
              break;
          }

          if (th.data.show_same_city == 1 && th.data.json_d.pickupway && th.data.json_d.pickupway == 2) {
            et = 2;
          }

          var m_wind = 0, def_exp_code = getApp().globalData.userInfo.def_exp_code;

          if (et == 0 && def_exp_code && !th.data.is_default_logistics) {
            for (var k = 0; k < th.data.wu_arr.length; k++) {
              var item = th.data.wu_arr[k];
              if (def_exp_code == item.code) {
                m_wind = k;
              }
            }
          }

          if (th.data.bn_goods) {
            et = th.data.bn_exp_type;
            m_wind = th.data.index;
          }
          th.data.m_wind = m_wind;

          //---是不是购买等级卡成功的返回---等级卡显示的判断---
          var is_card_back = getApp().globalData.is_card_back;
          if (is_card_back) {
            th.data.card_name = th.data.userinfo.card_field;
            gg.goods_price = gd[th.data.card_name];
            getApp().globalData.is_card_back = 0;
            th.setData({ card_cut_price: 0 });
            //如果是秒杀的返回
            if (gd.prom_type == 1) gd.prom_type = 0;
          } else {
            //--- 商家等级卡开通的情况下,  会员不是等级会员的情况， 商品有设置等级卡价格，同时等级卡价格小于商品的价格
            //-- 搭配购的商品也可以单独购买，所以此时搭配购的商品要进行计算优惠 --
            if (!gg.collocation_goods && gd['prom_type'] != 6 && th.data.card_name && gd[th.data.card_name] > 0 && gg.goods_price > gd[th.data.card_name] && !th.data.userinfo.card_field) {
              var cut_p = (gg.goods_price - gd[th.data.card_name]) * gg.goods_num;
              th.setData({ card_cut_price: cut_p });
            }
          }

          //-- 当是搭配购的时候 --
          gd.prom_type = gg.prom_type ? gg.prom_type : 0;
          gd.prom_id = gg.prom_id ? gg.prom_id : 0;

          //-- 判断是不是可以收藏 --
          if (gd.prom_type == 5 && !th.data.all_collocation_list.length) {
            await th.set_collection(gd);
          }

          if (gd.whsle_id > 0) {
            gd.prom_type = gg.prom_type = 0;
            gd.prom_id = gg.prom_id = 0;
          }


          switch (gd.prom_type) {
            case 0:
            case 3:
            case 4:
            case 5:
            case 6:
            case 7:
            case 10:
              //--此时开始计算商品的使用券相关,如果有等级价还要计算和等级价相关的,
              // 如果有优惠促销，还要把促销的部分计算在内，因为促销还有不能使用优惠券--
              t.data.data.shop_price = gg.goods_price;
              t.data.data.goods_price = gg.goods_price;
              t.data.data.goods_num = gg.goods_num;
              th.data.ckeck_quan_price = t.data.data.shop_price * gg.goods_num;
              th.data.check_quan_price_list = t.data.data.shop_price * gg.goods_num + "";
              th.data.check_quan_ware_list = t.data.data.erpwareid + "";

              //-- 如果有线下取价的时候 --
              if (gg.offline_price) {
                t.data.data.offline_price = gg.offline_price;
                t.data.data.pricing_type = gg.pricing_type;
                t.data.data.is_offline = 1;

                th.data.ckeck_quan_price = t.data.data.offline_price * gg.goods_num;
                th.data.check_quan_price_list = t.data.data.offline_price * gg.goods_num + "";
                th.data.check_quan_ware_list = t.data.data.erpwareid + "";
              }
              t.data.data.prom_id = 0;
              t.data.data.prom_type = 0;


              //如果有开启佣金抵扣，同时会员是分销商的时候
              if (getApp().globalData.userInfo.is_distribut
                && th.data.dis_config && th.data.dis_config.is_yongjin_dk) {
                var fir_num = 0;
                var sec_num = 0;
                var thi_num = 0;
                if (th.data.dis_config.pattern == 1) {
                  fir_num = (t.data.data.fir_rate || 0) * gg.goods_num;
                  sec_num = (t.data.data.sec_rate || 0) * gg.goods_num;
                  thi_num = (t.data.data.thi_rate || 0) * gg.goods_num;
                } else {
                  fir_num = parseFloat((t.data.data.commission || 0) * gg.goods_num * (th.data.dis_config.firstRate || 0) / 100).toFixed(2);
                  sec_num = parseFloat((t.data.data.commission || 0) * gg.goods_num * (th.data.dis_config.secondRate || 0) / 100).toFixed(2);
                  thi_num = parseFloat((t.data.data.commission || 0) * gg.goods_num * (th.data.dis_config.thirdRate || 0) / 100).toFixed(2);
                }
                var c_num = getApp().get_commission(fir_num, sec_num, thi_num, th);

                gd.use_commission = c_num;
                t.data.data.use_commission = c_num;

              }


              //如果立即购买那边过来，就要读取接口，查看活动的优惠内容
              if (gg.prom_type == 3) {
                t.data.data.prom_id = gg.prom_id;
                t.data.data.prom_type = 3;
                //如果是优惠活动，就要调用活动，计算价格
                // th.check_is_youhui(gg.goods_id, gg.pick_id);
                th.buy_now_prom_goods(gg.prom_id, t.data.data, function (data) {
                  //判断一下购买商品的数量是不是超过
                  if (data.gift_goods_id && (!data.zp_mode || parseInt(data.zp_mode) == 0)) {
                    var num = data.zp_num ? data.zp_num : 1;
                    if (data.is_bz == 1) {
                      num = num * data.bs;
                      if (num > data.gift_limit_num) num = 0;
                    }
                    //如果赠品数量超出礼品库存，就取消
                    if (num > data['gift_storecount']) num = 0;
                    if (num > 0) {
                      var ob = {};
                      ob.is_gift = 1;
                      ob.prom_id = data.prom_id;
                      ob.goods_id = data.gift_goods_id;
                      ob.goods_name = data.gift_goods_name;
                      ob.goods_sn = data.gift_goods_sn;
                      ob.goods_color = data.gift_goods_color;
                      ob.goods_spec = data.gift_goods_spec;
                      ob.original_img = os.imghost + data.gift_original_img;
                      ob.market_price = data.gift_market_price;
                      ob.gift_id = data.gift_id;
                      ob.shop_price = 0;
                      ob.buynum = num;
                      ob.weight = data.gift_weight;              //商品的重量
                      ob.exp_sum_type = data.gift_exp_sum_type;  //商品的物流计算方式
                      ob.uniform_exp_sum = data.gift_uniform_exp_sum  //统一运费的金额

                      var arr_gf = [];
                      arr_gf.push(ob);
                      th.setData({ buy_now_gift_goods: arr_gf });
                    }
                  }

                  th.setData({
                    bn_goods: data, bn_pickname: gg.pick_name, index: m_wind,
                    bn_pick: gg.pick_id, bn_t_exp_t: distr_t, bn_exp_type: et
                  });


                  //计算价格
                  th.calculatePrice2();
                  //获取优惠券
                  th.get_buy_now_quan();

                })
              } else {


                //--看是不是搭配促销--
                if (gg.prom_type == 5) {
                  t.data.data.prom_id = gg.prom_id;
                  t.data.data.prom_type = 5;
                  // th.is_coupon = gg.is_coupon;
                  // th.setData({
                  //   is_coupon: gg.is_coupon
                  // });
                  if (gg.room_id) {
                    t.data.data.room_id = gg.room_id;
                  }
                  //--主商品要有导购id和导购类型--
                  if (gg.guide_id) {
                    t.data.data.guide_id = gg.guide_id;
                    t.data.data.guide_type = gg.guide_type;
                  }
                  if (gg.groupchat_id && gg.groupchat_id != 'undefined') {
                    t.data.data.groupchat_id = groupchat_id;
                  }
                  //搭配购如果原来就有勾选，不能直接赋值，旧的要保留
                  if (!th.data.collocation_goods) {
                    th.setData({ collocation_goods: gg.collocation_goods });
                  }
                  // if(th.data.collocation_goods && th.data.collocation_goods.length){
                  //   if(gg.collocation_goods){
                  //     let coll_goods=th.data.collocation_goods
                  //     coll_goods.push(...gg.collocation_goods)
                  //     th.setData({collocation_goods:coll_goods})
                  //   }
                  // }else{
                  //   th.setData({ collocation_goods: gg.collocation_goods });
                  // }

                  if (th.data.all_collocation_list && gg.collocation_goods && gg.collocation_goods.length > 0) {
                    for (var i = 0; i < th.data.all_collocation_list.length; i++) {
                      var item0 = th.data.all_collocation_list[i];
                      var idx = gg.collocation_goods.findIndex(function (e) {
                        // return e.goods_id == item0.goods_id && e.prom_id == item0.prom_id;
                        return e.goods_id == item0.goods_id;
                      })
                      if (idx != -1) {
                        var txt = 'all_collocation_list[' + i + '].selected';
                        th.setData({ [txt]: 1 });
                      } else {
                        var txt = 'all_collocation_list[' + i + '].selected';
                        th.setData({ [txt]: 0 });
                      }
                    }

                  }

                  if (gg.collocation_goods && gg.collocation_goods.length > 0) {
                    //var narr=gg.collocation_goods;
                    //修改成深拷贝，确保返回是数据正确
                    var narr = JSON.parse(JSON.stringify(gg.collocation_goods));
                    narr.push(t.data.data);
                    await th.get_collocation_list(narr);
                  }

                }
                th.setData({
                  bn_goods: gd, bn_pickname: gg.pick_name, index: m_wind,
                  bn_pick: gg.pick_id, bn_t_exp_t: distr_t, bn_exp_type: et
                });


                //--搭配促销也是按照购物车的方式来计算优惠券--
                if (gg.prom_type == 5 && th.data.collocation_goods && th.data.collocation_goods.length > 0) {
                  var frozenQuan = null;
                  var url0 = "/api/weshop/users/frozenQuan/listFrozenQuan/" + app.globalData.user_id;
                  app.request.promiseGet(url0, { 1: 1 }).then(res => {
                    if (res.data.code == 0) {
                      frozenQuan = res.data.data;
                      th.data.frozenQuan = frozenQuan;
                    }
                    //计算价格
                    th.calculatePrice2();
                    th.get_cart_quan();
                  });

                } else {
                  //计算价格
                  th.calculatePrice2();
                  //获取优惠券，
                  th.get_buy_now_quan();
                }
              }

              break;
            case 1: //---秒杀-----
              var quanlist = null;
              getApp().request.get("/api/weshop/activitylist/getSJGoodsPriceNew/" + gd.store_id
                + "/" + gd.goods_id + "/1/" + gd.prom_id + "/" + app.globalData.user_id, {
                success: async function (tt) {
                  if (tt.data.code == 0) {
                    //t.data.data.shop_price = tt.data.data.prom_price;

                    gd.shop_price_y = gd.shop_price;
                    gd.shop_price = t.data.data.shop_price = tt.data.data.prom_user_price;
                    th.data.ckeck_quan_price = 0;

                    t.data.data.fir_rate = tt.data.data.fir_rate;
                    t.data.data.sec_rate = tt.data.data.sec_rate;
                    t.data.data.thi_rate = tt.data.data.thi_rate;
                    t.data.data.commission = tt.data.data.commission;

                    if (tt.data.data.is_order_yh) {
                      th.data.bn_is_order_yh = 1;
                    } else {
                      th.data.bn_is_order_yh = 0;
                    }

                    if (tt.data.data.is_post_temp) {
                      th.data.bn_is_post_temp = 1;
                    } else {
                      th.data.bn_is_post_temp = 0;
                    }

                  } else {
                    t.data.data.prom_id = 0;
                    t.data.data.prom_type = 0;
                    th.data.ckeck_quan_price = t.data.data.shop_price * gg.goods_num;
                    th.data.check_quan_price_list = t.data.data.shop_price * gg.goods_num + "";
                    th.data.check_quan_ware_list = t.data.data.erpwareid + "";
                  }

                  //-- 计算获得佣金的金额 --
                  if (getApp().globalData.userInfo.is_distribut
                    && th.data.dis_config && th.data.dis_config.is_yongjin_dk) {

                    var c_num = getApp().get_commission2(th.data.dis_config, t.data.data, gg.goods_num);

                    gd.use_commission = c_num;
                    t.data.data.use_commission = c_num;

                  }

                  if (tt.data.data.is_quan) {
                    th.data.ckeck_quan_price = t.data.data.shop_price * gg.goods_num;
                    th.data.check_quan_price_list = t.data.data.shop_price * gg.goods_num + "";
                    th.data.check_quan_ware_list = t.data.data.erpwareid + "";
                  } else {
                    gd.is_xz_yh = 1;
                  }


                  //用深拷贝把商品缓存起来，方便后面使用
                  th.data.old_bn_goods = ut.deep_cp(gd);

                  th.setData({
                    bn_goods: gd,
                    bn_pickname: gg.pick_name,
                    bn_exp_type: et,
                    index: m_wind,
                    bn_pick: gg.pick_id,
                    bn_t_exp_t: distr_t,
                    bn_exp_type: et
                  });

                  //计算价格
                  th.calculatePrice2();
                  //获取优惠券,如果有券的钱，就调用
                  if (th.data.ckeck_quan_price > 0) th.get_buy_now_quan();
                }
              });

              break;

            case 2: //--- 团购 ---
              var quanlist = null;
              getApp().request.get("/api/weshop/goods/groupBuy/getActInfo/" + os.stoid + "/" + gd.goods_id + "/" + gd.prom_id, {
                success: async function (tt) {
                  if (tt.data.code == 0) {
                    //获取一下主表的信息
                    ut.get_active_info(2, gd.prom_id, os.stoid, function (e) {

                      //t.data.data.shop_price = tt.data.data.prom_price;
                      gd.shop_price_y = gd.shop_price;
                      gd.shop_price = t.data.data.shop_price = tt.data.data.price;

                      t.data.data.fir_rate = tt.data.data.fir_rate;
                      t.data.data.sec_rate = tt.data.data.sec_rate;
                      t.data.data.thi_rate = tt.data.data.thi_rate;
                      t.data.data.commission = tt.data.data.commission;

                      if (tt.data.data.is_order_yh) {
                        th.data.bn_is_order_yh = 1;
                      } else {
                        th.data.bn_is_order_yh = 0;
                      }
                      if (tt.data.data.is_post_temp) {
                        th.data.bn_is_post_temp = 1;
                      } else {
                        th.data.bn_is_post_temp = 0;
                      }


                      //-- 计算获得佣金的金额 --
                      if (getApp().globalData.userInfo.is_distribut
                        && th.data.dis_config && th.data.dis_config.is_yongjin_dk) {

                        var c_num = getApp().get_commission(th.data.dis_config, t.data.data, gg.goods_num, th);

                        gd.use_commission = c_num;
                        t.data.data.use_commission = c_num;

                      }


                      if (tt.data.data.isQuan) {
                        th.data.ckeck_quan_price = t.data.data.shop_price * gg.goods_num;
                        th.data.check_quan_price_list = t.data.data.shop_price * gg.goods_num + "";
                        th.data.check_quan_ware_list = t.data.data.erpwareid + "";
                      } else {
                        gd.is_xz_yh = 1;
                      }


                      //用深拷贝把商品缓存起来，方便后面使用
                      th.data.old_bn_goods = ut.deep_cp(gd);

                      th.setData({
                        bn_goods: gd,
                        bn_pickname: gg.pick_name,
                        bn_exp_type: et,
                        index: m_wind,
                        bn_pick: gg.pick_id,
                        bn_t_exp_t: distr_t,
                        bn_exp_type: et
                      });

                      //-- 计算价格 --
                      th.calculatePrice2();
                      //获取优惠券,如果有券的钱，就调用
                      if (th.data.ckeck_quan_price > 0) th.get_buy_now_quan();

                    })


                  } else {
                    t.data.data.prom_id = 0;
                    t.data.data.prom_type = 0;



                    //-- 计算获得佣金的金额 --
                    if (getApp().globalData.userInfo.is_distribut
                      && th.data.dis_config && th.data.dis_config.is_yongjin_dk) {
                      var c_num = getApp().get_commission2(th.data.dis_config, t.data.data, gg.goods_num);

                      gd.use_commission = c_num;
                      t.data.data.use_commission = c_num;

                    }


                    if (tt.data.data.isQuan) {
                      th.data.ckeck_quan_price = t.data.data.shop_price * gg.goods_num;
                      th.data.check_quan_price_list = t.data.data.shop_price * gg.goods_num + "";
                      th.data.check_quan_ware_list = t.data.data.erpwareid + "";
                    } else {
                      gd.is_xz_yh = 1;
                    }

                    th.setData({
                      bn_goods: gd,
                      bn_pickname: gg.pick_name,
                      bn_exp_type: et,
                      index: m_wind,
                      bn_pick: gg.pick_id,
                      bn_t_exp_t: distr_t,
                      bn_exp_type: et
                    });

                    //-- 计算价格 --
                    th.calculatePrice2();
                    //获取优惠券,如果有券的钱，就调用
                    if (th.data.check_quan_ware_list ) th.get_buy_now_quan();

                  }


                }
              });

              break;
          }
        },
      });
    }
  },


  //-- 立即购买的时候，获取商品优惠活动,is_state判断是不是单个商品购买,
  // 很多活动需要判断会员的plus等级， 权益登陆，user_id调用接口是必须的 --
  //先用着，后面会用接口来代替
  async buy_pro_group(g_arr, carr) {
    var th = this;
    //获取商品参与的促销活，优惠促，搭配促，组合促，阶梯促销
    let cx_rs = await getApp().request.promisePost("/api/weshop/cart/listGoodsPromInfo", {
      is_json: 1,
      data: {
        user_id: app.globalData.user_id,
        store_id: oo.stoid,
        goods: g_arr,
      }
    });
    //-- 判断返回结果有没有正确,有促销活动就要进行赋值 --
    if (cx_rs && cx_rs.data.code == 0 && cx_rs.data.data && cx_rs.data.data.goods) {
      let g_list = cx_rs.data.data.goods;
      for (var ia = 0; ia < carr.length; ia++) {
        if (carr[ia].whsle_id) continue; //代发商品不进行赋值
        if (carr[ia].is_gift) continue;  //赠品不进行赋值
        //有参与秒，团购之类的活动不进行赋值
        if ([1, 2, 4, 6, 8, 9].indexOf(carr[ia].prom_type) > -1) continue;
        //再g_list中快速查找
        let i_fd = g_list.find(function (ele) {
          return ele.goods_id == carr[ia].goods_id
        });
        if (i_fd.goodsPromInfoRespDto) {
          //-- 多促销活动的优化 --
          i_fd = i_fd.goodsPromInfoRespDto;
          //-- 赋值多促销活动的优化--
          carr[ia].more_cx = i_fd.more_cx;

          //商品优惠促销的缓存
          if (i_fd.yhcx_pro) {
            th.data.yhcx_act_map[i_fd.yhcx_pro.id] = i_fd.yhcx_pro;
          }
          //商品组合促销的缓存
          if (i_fd.zh_pro) {
            th.data.zhhe_act_map[i_fd.zh_pro.id] = i_fd.zh_pro;
          }
          //商品阶梯促销的缓存
          if (i_fd.ladder_pro) {
            var ladder_pro = i_fd.ladder_pro;
            th.data.ladder_map[ladder_pro.id] = ladder_pro;
            var fd_ite = i_fd.more_cx.find(function (e) {
              return e.prom_type == 10;
            })
            if (fd_ite) {
              th.data.ladder_map[ladder_pro.id].ladder_list = fd_ite.ladder_list;
            }
          }

        }

      }
    }
  },




  //---------------检查是否有收货地址-------------------
  checkAddressList: function () {
    var t = this;
    return !(!this.data.order || null == this.data.order.userAddress) || (wx.showModal({
      title: "请先填写或选择收货地址~",
      success: function (a) {
        a.confirm ? t.enterAddressPage() : wx.navigateBack();
      },
      fail: function () {
        wx.navigateBack();
      }
    }), !1);
  },
  showInvoice: function () {
    this.setData({
      invoiceToggle: !this.data.invoiceToggle
    });
  },
  keyUpChangePay1: function (t) {
    this.setData({
      payWithUserMoney: !(t.detail.value.length > 0)
    });
  },
  keyUpChangePay2: function (t) {
    this.setData({
      payWithPoints: !(t.detail.value.length > 0)
    });
  },


  keyUpChangeNum: function (t) {
    var index = t.currentTarget.dataset.index;
    var txt = "user_note." + index;
    this.setData({
      maxWord: t.detail.value.length,
      [txt]: t.detail.value
    });
  },


  show_ly: function (t) {
    var index = t.currentTarget.dataset.index;
    var txt = 'ly_map[' + index + ']';
    this.setData({
      [txt]: 1
    })
  },

  hide_ly: function (t) {
    var index = t.currentTarget.dataset.index;
    var txt = 'ly_map[' + index + ']';
    this.setData({
      [txt]: 0
    })
  },

  //寻找活动在列表中的最后一个
  find_pro_last(ord_goods, prom_type, prom_id) {
    if (!ord_goods || ord_goods.length == 0) return -1;
    var len = ord_goods.length;
    for (var i = len - 1; i > -1; i--) {
      var e = ord_goods[i];
      if (e.prom_type == prom_type && e.prom_id == prom_id && e.is_gift != 1) {
        return i;
      }
    }
    return -1;
  },

  //寻找活动在列表中的最后一个
  is_has_gift(ord_goods, prom_id,get_data,index) {
    if (!ord_goods || ord_goods.length == 0) return false;
    var len = ord_goods.length;
    var is_ck=false;
    for (var i = 0; i < len; i++) {
      var e = ord_goods[i];
      if (e.prom_type == 3 && e.prom_id == prom_id && e.is_gift == 1) {
        if(get_data.zp_by>0){
          ord_goods[i].is_past=1;

          //cartlist和old_cartlist的值要同步
          let fidx=this.data.cartlist[index].goods.findIndex((ee)=>{
              return ee.prom_type == 3 && ee.prom_id == prom_id && ee.is_gift == 1 && ee.goods_id==e.goods_id
          })
          if(fidx>-1){
            this.data.cartlist[index].goods[fidx].is_past=1;
          }

          fidx=this.data.old_cartlist[index].goods.findIndex((ee)=>{
            return ee.prom_type == 3 && ee.prom_id == prom_id && ee.is_gift == 1 && ee.goods_id==e.goods_id
          })
          if(fidx>-1){
            this.data.old_cartlist[index].goods[fidx].is_past=1;
          }


        }
        is_ck=true;
      }
    }
    return is_ck;
  },


  /**
   *
   * @param item_map  //是门店ID
   * @param pickid  //是门店ID
   * @param i  //是购物车索引
   * @param ord_goods 对应的商品列表
   * @param get_data
   */
  cart_add_gift(item_map, pickid, i, ord_goods, get_data) {

    var th = this;
    var is_has_gift = this.is_has_gift(ord_goods, item_map.prom_id,get_data,i)

    //-- 没有赠品的时候才添加，避免购物车重复出现 --
    if (!is_has_gift) {

      //看一下要插入的位置
      var pos = this.find_pro_last(ord_goods, 3, item_map.prom_id);
      var pos2 = this.find_pro_last(th.data.old_cartlist[i].goods, 3, item_map.prom_id);

      if (pos > -1) {
        var newd = {
          goods_id: get_data.goods_id,
          goods_num: get_data.bs * get_data.zp_num, //是赠品的翻倍
          pick_id: pickid,
          user_id: app.globalData.user_id,
          store_id: os.stoid,
          goods_price: 0,
          member_goods_price: 0,
          goods_name: get_data.goods_name,
          goods_sn: get_data.goodsinfo.goods_sn,
          sku: get_data.goodsinfo.sku,
          is_gift: 1,
          prom_id: item_map.prom_id,
          prom_type: 3,
          selected: 1,
          gift_id: get_data.gift_id,
          original_img: th.data.imgUrl + get_data.goodsinfo.original_img,
          weight: get_data.goodsinfo.weight,   //赠品在计算运费必须的字段
          exp_sum_type: get_data.goodsinfo.exp_sum_type,  //赠品在计算运费必须的字段
          uniform_exp_sum: get_data.goodsinfo.uniform_exp_sum,  //赠品在计算运费必须的字段
        };
        var fd_gd = ord_goods[pos]

        newd.guide_id = fd_gd.guide_id;
        newd.guide_type = fd_gd.guide_type;
        newd.distr_type = fd_gd.distr_type;
        newd.is_order_yh = fd_gd.is_order_yh;
        newd.is_post_temp = fd_gd.is_post_temp;

        if (get_data.zp_by > 0) {
          newd.is_past = 1;
        }

        ord_goods.splice(pos + 1, 0, newd);
        th.data.old_cartlist[i].goods.splice(pos2 + 1, 0, newd);
        var txt9 = "cartlist[" + i + "].goods";
        th.setData({ [txt9]: ord_goods })


      }

    }

  },

  //-- 其他门店赠品的总和 --
  get_other_gift(c_arr, gift_id, pickid) {
    var num = 0;
    for (var i in c_arr) {
      var cart_item = c_arr[i];      //就是每一单的意思
      var pickid0 = cart_item.pickup_id;
      //相同门店不用统计
      if (pickid0 == pickid) continue;
      var ord_goods = cart_item.goods;   //就是每一单的从表的意思
      var fd = ord_goods.find(function (er) {
        return er.is_gift && er.gift_id == gift_id
      })
      if (fd) {
        num += fd.goods_num;
      }
    }
    return num;
  },

  calc_per: async function (c_arr) {

    var send_gf = {};
    var duo_zp_num_arr = {};
    var th = this;
    //-- 循环处理 --
    for (var i in c_arr) {
      var cart_item = c_arr[i];      //就是每一单的意思
      //--优惠多少钱--
      cart_item.cut_price = 0;

      var pickid = cart_item.pickup_id;
      var ord_goods = c_arr[i].goods;   //就是每一单的从表的意思
      var o_price = 0, q_conditin = 0;
      //--------循环计算总价-----------
      for (var j = 0; j < ord_goods.length; j++) {

        if (ord_goods[j].is_gift) continue;
        ord_goods[j].account_fir = ord_goods[j].goods_price;     //初始实际价格
        ord_goods[j].account_yu_fir = 0;                         //初始余数

        if (ord_goods[j].whsle_id) continue;
        o_price += ord_goods[j].goods_price * ord_goods[j].goods_num;
      }

      //---如果该门店的相关活动，就要算一下减价--
      if (th.data.prom_goods_map[pickid]) {
        var ob = th.data.prom_goods_map[pickid];
        for (var ii in ob) {
          var item_map = ob[ii];
          var b = 1;

          //if (item_map.bs == undefined || item_map.bs == null) {
          if (!item_map.hasOwnProperty('cy_cx')) {
            //等待，获取一下优惠活动的信息

            await getApp().request.promiseGet("/api/weshop/goods/getDiscount", {
              data: {
                price: parseFloat(item_map.price).toFixed(2), prom_id: item_map.prom_id,
                goods_num: item_map.goods_num, user_id: getApp().globalData.user_id,
                is_bz: item_map.is_bz
              }
            }).then(res => {
              if (res.data.code == 0 && res.data.data.condition) {
                var get_data = res.data.data;
                item_map.cy_cx = 1;
                item_map.is_bz = get_data.is_bz;         //是不是倍增
                item_map.bs = get_data.bs;               //是不是倍数
                item_map.is_past = get_data.is_past;     //是不是包邮
                item_map.prom_price = get_data.price >= 0 ? get_data.price : item_map.price;
                item_map.s_intValue = get_data.intValue;
                item_map.s_coupon_id = get_data.coupon_id;
                item_map.s_coupon_num = get_data.coupon_num;
                item_map.lbtitle = get_data.lbtitle;
                item_map.zxlbtitle = get_data.zxlbtitle;


                var rule = JSON.parse(get_data.rule);
                if (rule.is_monthgiftbag && parseFloat(rule.is_monthgiftbag) > 0) {
                  //每月礼包
                  item_map.monthlbtitle = get_data.monthlbtitle;
                }

                //优惠促销新增的不包邮模板
                item_map.no_ex_id=rule.no_ex_id;

                //-- 单赠品和多赠品 --
                if (get_data.gift_id || parseInt(get_data.zp_mode) == 1) {
                  item_map.zp_by = rule.zp_by;
                  get_data.zp_by = rule.zp_by;
                }
                //-- 其他门店赠品的总和 --
                var other_gift = 0;
                other_gift = th.get_other_gift(c_arr, get_data.gift_id, pickid);

                //------end------- ,因为增加了限购数量不限的情况
                if (get_data.gift_id && parseInt(get_data.zp_mode) != 1
                  && (get_data.zp_num * item_map.bs <= get_data.limit_num - other_gift || !get_data.limit_num)
                  && get_data.zp_num * item_map.bs <= get_data.gift_storecount
                  && get_data.zp_num >= get_data.must_num  //增加一个超量
                ) {

                  item_map.gift_id = get_data.gift_id;
                  item_map.gift_goods_id = get_data.goods_id;
                  item_map.gift_goods_name = get_data.goods_name;
                  item_map.gift_goods_color = get_data.goodsinfo.goods_color ? get_data.goodsinfo.goods_color : '';
                  item_map.gift_goods_spec = get_data.goodsinfo.goods_spec ? get_data.goodsinfo.goods_spec : '';
                  item_map.gift_original_img = get_data.goodsinfo.original_img;
                  item_map.gift_limit_num = get_data.limit_num;
                  item_map.gift_storecount = get_data.gift_storecount;
                  item_map.gift_weight = get_data.goodsinfo.weight;
                  item_map.gift_exp_sum_type = get_data.goodsinfo.exp_sum_type;
                  item_map.uniform_exp_sum = get_data.goodsinfo.uniform_exp_sum;
                  item_map.whsle_id = get_data.goodsinfo.whsle_id;

                  //-- 购物车添加赠品 --
                  th.cart_add_gift(item_map, pickid, i, ord_goods, get_data);

                }
                item_map.s_libao = get_data.libao;
                item_map.s_lb_num = get_data.lb_num;

                //专享礼包
                item_map.zx_libao = get_data.zxlibao;
                item_map.zx_lb_num = get_data.zxlb_num;
                //每月礼包
                if (rule.is_monthgiftbag && parseFloat(rule.is_monthgiftbag) > 0) {
                  item_map.monthlibao = get_data.monthlibao;
                  item_map.monthlb_num = get_data.monthlb_num;
                }
                //------end-------

                if (parseInt(get_data.zp_mode) == 1) {
                  if (!send_gf[pickid]) send_gf[pickid] = [];

                  var can_zp_num = 0;
                  for (let iy in get_data.giftsinfo) {
                    let item = get_data.giftsinfo[iy];

                    var c_zp = 0;
                    if (parseInt(item.limit_num) > 0) {
                      c_zp = parseInt(item.gift_storecount) > parseInt(item.can_num) ? parseInt(item.can_num) : parseInt(item.gift_storecount);
                    } else {
                      c_zp = parseInt(item.gift_storecount);
                    }

                    if (c_zp < 0) c_zp = 0;
                    can_zp_num += c_zp;

                  }

                  var t_zp_num = parseInt(get_data.zp_num) * parseInt(get_data.bs);
                  if (duo_zp_num_arr[item_map.prom_id]) {
                    t_zp_num += duo_zp_num_arr[item_map.prom_id];
                  }

                  if (can_zp_num >= t_zp_num) {
                    send_gf[pickid].push({
                      pickup_id: pickid,
                      giftsinfo: get_data.giftsinfo,
                      zp_num: get_data.zp_num * get_data.bs,
                      zp_by: get_data.zp_by,
                      gf_pr_name: item_map.name,
                      prom_id: item_map.prom_id,
                      bs: parseInt(get_data.bs),
                    });

                    duo_zp_num_arr[item_map.prom_id] = t_zp_num;
                  }
                }

              } else item_map.cy_cx = 0;
            })
          }

          //有活动，且优惠活动并没有限制使用优惠券，且有减价
          //--看有没有减价--
          //if(item_map.prom_price>=0 && item_map.price-item_map.prom_price){
          if (item_map.price - item_map.prom_price && item_map.prom_price !== null) {
            if (cart_item.prom_pt_json) {
              cart_item.prom_pt_json.push({
                "prom_id": item_map.prom_id,
                "dis": (item_map.price - item_map.prom_price).toFixed(2),
                "ispt": 0
              })
            } else {
              cart_item.prom_pt_json = [{
                "prom_id": item_map.prom_id,
                "dis": (item_map.price - item_map.prom_price).toFixed(2),
                "ispt": 0
              }];
            }

            //-- 如果系统要平摊到单品 --

            var pt_data = {
              'prom_id': item_map.prom_id,
              'dis': parseFloat((item_map.price - item_map.prom_price).toFixed(2)),
              'goods': item_map.goods
            }

            var pt_res = null;
            await getApp().request.promisePost("/api/weshop/order/getGoodsSplit", {
              is_json: 1,
              data: pt_data
            }).then(res => {
              if (res.data.code == 0) {
                pt_res = res.data.data;
              }
            })
            if (pt_res) {
              for (var io in item_map.goods) {
                //平摊赋值
                item_map.goods[io].account_fir = th.arr_get_goods(item_map.goods[io].goods_id, pt_res).fisrt_account || 0;
                item_map.goods[io].account_yu_fir = th.arr_get_goods(item_map.goods[io].goods_id, pt_res).fisrt_account_yu || 0;
                if (!th.data.ispt_goods) {
                  item_map.goods[io].account = item_map.goods[io].account_fir;
                  item_map.goods[io].account_yu = item_map.goods[io].account_yu_fir;
                }
              }
            }

            o_price -= (item_map.price - item_map.prom_price);
            //如果有限制使用优惠券，就要减掉参与的活动商品的钱
            if (!item_map.is_xz_yh) q_conditin = o_price;
          }

          //--------循环计算商品是不是包邮，是不是使用优惠券,此时循环是商品从表-----------
          for (var j = 0; j < ord_goods.length; j++) {
            if (ord_goods[j].whsle_id) continue;
            if (ord_goods[j].prom_type == 3 && ord_goods[j].prom_id == item_map.prom_id) {
              ord_goods[j].is_xz_yh = ord_goods[j].is_xz_yh ? ord_goods[j].is_xz_yh : item_map.is_xz_yh;
              ord_goods[j].is_past = item_map.is_past;

              if (ord_goods[j].is_gift){
                //赠品要看赠品本身包不包邮
                if(!item_map.zp_by)  ord_goods[j].is_past =0;
                continue;  //赠品不平摊
              }

              // ord_goods[j].account_fir = th.item_map_get_goods(ord_goods[j].goods_id, item_map).account_fir;
              // ord_goods[j].account_yu_fir = th.item_map_get_goods(ord_goods[j].goods_id, item_map).account_yu_fir;
              // ord_goods[j].account = th.item_map_get_goods(ord_goods[j].goods_id, item_map).account;
              // ord_goods[j].account_yu = th.item_map_get_goods(ord_goods[j].goods_id, item_map).account_yu;

              //-- 如果有参与促销才来进行计算 --
              if (item_map.cy_cx) {
                //--------循环计算商品是不是包邮，是不是使用优惠券,此时循环是商品从表-----------
                for (var j = 0; j < ord_goods.length; j++) {
                  if (ord_goods[j].is_gift) continue;
                  if (ord_goods[j].whsle_id) continue;
                  if (ord_goods[j].prom_type == 3 && ord_goods[j].prom_id == item_map.prom_id) {
                    ord_goods[j].is_xz_yh = ord_goods[j].is_xz_yh ? ord_goods[j].is_xz_yh : item_map.is_xz_yh;
                    ord_goods[j].is_past = item_map.is_past;
                    ord_goods[j].is_order_yh = item_map.is_order_yh;
                    ord_goods[j].is_post_temp = item_map.is_post_temp;

                    //-- 真的判断 --
                    var fd_map_gd = th.item_map_get_goods(ord_goods[j].goods_id, item_map);
                    if (fd_map_gd) {
                      if (fd_map_gd.account_fir != undefined) ord_goods[j].account_fir = fd_map_gd.account_fir;
                      if (fd_map_gd.account_yu_fir != undefined) ord_goods[j].account_yu_fir = fd_map_gd.account_yu_fir;
                      if (fd_map_gd.account != undefined) ord_goods[j].account = fd_map_gd.account;
                      if (fd_map_gd.account_yu != undefined) ord_goods[j].account_yu = fd_map_gd.account_yu;
                    }

                    //优惠促销包邮，但是又不包邮模板的时候
                    if(ord_goods[j].is_past && item_map.no_ex_id>0){
                    
                          let by_mb=null;
                          let by_mb_url="/api/weshop/areaFeemail/getAreaGoods";
                          let by_mb_res= await getApp().request.promiseGet(by_mb_url, {
                               data:{
                                  store_id:os.stoid,
                                  id:item_map.no_ex_id
                               }
                          })
    
                          if(by_mb_res && by_mb_res.data.code==0 && by_mb_res.data.data && by_mb_res.data.data.length){
                            by_mb=by_mb_res.data.data[0];
    
                            //如果是不包邮区域的话
                            if (by_mb.region_list && th.check_by_area(by_mb.region_list)) {
                              ord_goods[j].is_past =0;
                            }
                            //如果是不包邮商品的时候
                            else if (by_mb.goods_list) {
                              var no_goods_arr = by_mb.goods_list.split(",");
                              if (no_goods_arr.includes(ord_goods[j].goods_id+"")){
                                ord_goods[j].is_past =0;
                              }
                            }  
                          
                          }                    
                      
                    }


                  }
                }
              }


              if (item_map.price != undefined && item_map.price != null
                && item_map.prom_price != undefined && item_map.prom_price != null)
                cart_item.cut_price += (item_map.price - item_map.prom_price);
              //---如果有送积分---
              if (item_map.s_intValue) {
                if (!cart_item.s_intValue) cart_item.s_intValue = 0;
                cart_item.s_intValue += item_map.s_intValue;
              }
              //-- 如果有送优惠券的情况 --
              if (item_map.s_coupon_id) {
                if (!cart_item.s_coupon_id) {
                  cart_item.s_coupon_id = item_map.s_coupon_id + "";
                  cart_item.g_coupon_num = [{ 'c_id': item_map.s_coupon_id, "num": item_map.s_coupon_num }];
                } else {
                  cart_item.s_coupon_id += "," + item_map.s_coupon_id;
                  cart_item.g_coupon_num.push({ 'c_id': item_map.s_coupon_id, "num": item_map.s_coupon_num })
                }
              }

              //-- 如果有送礼包的情况 --
              if (item_map.s_libao) {
                if (!cart_item.s_libao) {
                  cart_item.s_libao = item_map.s_libao + "";
                  cart_item.g_lb_num = [{
                    'l_id': item_map.s_libao,
                    "num": item_map.s_lb_num,
                    'lbtitle': item_map.lbtitle
                  }];
                } else {
                  cart_item.s_libao += "," + item_map.s_libao;
                  cart_item.g_lb_num.push({
                    'l_id': item_map.s_libao,
                    "num": item_map.s_lb_num,
                    'lbtitle': item_map.lbtitle
                  })
                }
              }

              if (item_map.zx_libao) {
                if (!cart_item.zx_libao) {
                  cart_item.zx_libao = item_map.zx_libao + "";
                  cart_item.g_zxlb_num = [{
                    'l_id': item_map.zx_libao,
                    "num": item_map.zx_lb_num,
                    'zxlbtitle': item_map.zxlbtitle
                  }];
                } else {
                  cart_item.zx_libao += "," + item_map.zx_libao;
                  cart_item.g_zxlb_num.push({
                    'l_id': item_map.zx_libao,
                    "num": item_map.zx_lb_num,
                    'zxlbtitle': item_map.zxlbtitle
                  })
                }
              }
              //每月礼包
              if (item_map.monthlibao) {
                if (!cart_item.monthlibao) {
                  cart_item.monthlibao = item_map.monthlibao + "";
                  cart_item.g_monthlb_num = [{
                    'month_id': item_map.monthlibao,
                    "monthnum": item_map.monthlb_num,
                    'monthlbtitle': item_map.monthlbtitle,
                    'prom_id':item_map.prom_id
                  }];
                } else {
                  cart_item.monthlibao += "," + item_map.monthlibao;
                  cart_item.g_monthlb_num.push({
                    'month_id': item_map.monthlibao,
                    "monthnum": item_map.monthlb_num,
                    'monthlbtitle': item_map.monthlbtitle,
                    'prom_id':item_map.prom_id
                  })
                }
              }
              //------------end--------
            }
          }
        }
      }
    }


    var arr = Object.keys(send_gf);
    var arr2 = Object.keys(th.data.send_gf);
    if (arr2.length > 0) return false;
    th.calclate_lbNum(c_arr);
    if (arr.length > 0) {
      th.setData({ send_gf: send_gf })
    } else {
      th.setData({ send_gf: {} })
    }

  },


  calclate_lbNum(r_data) {

    if (!r_data) return false;

    let send_lb = this.data.send_lb;
    let month_lb = this.data.month_lb;

    //g_lb_num我的礼包 g_zxlb_num专享礼包
    r_data.forEach(r_d => {
      let arr = [];
      if (r_d.g_zxlb_num) {
        let g_lb = r_d.g_zxlb_num;
        for (let i = 0; i < g_lb.length; i++) {
          let item = g_lb[i];
          let new_lb = g_lb.filter(lb => {
            return item.l_id === lb.l_id;
          });
          if (new_lb.length == 1) {
            arr.push(item);
          } else {
            item.num = new_lb.reduce((pre, next) => {
              return pre + next.num;
            }, 0);
            arr.push(item);
            g_lb = g_lb.filter(ii => {
              return ii.l_id !== item.l_id;
            });
          }
          send_lb[r_d.pickup_id] = arr;
        }
      }
      if (r_d.g_lb_num) {
        let zx_lb = r_d.g_lb_num;
        for (let i = 0; i < zx_lb.length; i++) {
          let item = zx_lb[i];
          item.flag = 1;
          let new_lb = zx_lb.filter(lb => {
            return item.l_id === lb.l_id;
          });
          if (new_lb.length == 1) {
            arr.push(item);
          } else {
            item.num = new_lb.reduce((pre, next) => {
              return pre + next.num;
            }, 0);
            arr.push(item);
            zx_lb = zx_lb.filter(ii => {
              return ii.l_id !== item.l_id;
            });
          }
          send_lb[r_d.pickup_id] = arr;
        }
      }
      //每月礼包
      let monthArr = []
      if (r_d.g_monthlb_num) {
        let g_lb = r_d.g_monthlb_num;
        for (let i = 0; i < g_lb.length; i++) {
          let item = g_lb[i];
          let new_lb = g_lb.filter(lb => {
            return item.month_id === lb.month_id;
          });
          if (new_lb.length == 1) {
            monthArr.push(item);
          } else {
            item.num = new_lb.reduce((pre, next) => {
              return pre + next.num;
            }, 0);
            monthArr.push(item);
            g_lb = g_lb.filter(ii => {
              return ii.month_id !== item.month_id;
            });
          }
          month_lb[r_d.pickup_id] = monthArr;
        }
      }
      //-----end--------

    })
    this.setData({
      send_lb,
      month_lb
    })

  },

  //-------------------计算订单价格-------------------
  calculatePrice: async function (qfunc) {
    console.error('计算价格-----11111111111111111---------');
    var th = this;
    th.setData({ submit: 1 });

    wx.showLoading({
      title: "处理中.",
      mask: true
    })
    //-- to.getwuliuprice(async function (rs) { --

    th.data.lon = 0;
    th.data.lat = 0;

    //是不是区域包邮
    th.data.is_area_by = 0;
    //当不是区域不包邮的时候，没有不包邮商品的时候
    th.data.free1 = 0;
    th.data.cut_o_shipping_price = 0;
    th.data.cut_goods_piece = 0;
    th.data.cut_goods_weight = 0;

    var all_price = 0;           //所有的商品总价
    var all_shipping_m = 0;     //所有的物流总价 
    var all_total_m = 0;       //所有的订单应付总价
    var all_order_m = 0;       //所有的订单应付总价
    var all_user_m = 0;          //所有的订单用户使用金额
    var all_coupon_price_m = 0;  //所有的订单用户使用优惠券价格
    var all_cutprice = 0;        //所有的优惠减
    var all_zh_cutprice = 0;     //所有的组合优惠减
    var all_ladder_cutprice = 0; //所有的阶梯促销优惠减
    var all_order_prom = 0;      //所有的订单优惠
    var all_prestore = 0;    //所有预存优化金额
    var all_pre_json = [];    //所有预存优化json
    var all_yck_arr = [];    //所有预存真实抵扣数组

    var umoney = th.data.userinfo.user_money - th.data.txmon - (th.data.userinfo.frozen_money ? th.data.userinfo.frozen_money : 0);
    var out_of_weight = 0; //超出多少重量
    var c_arr = JSON.parse(JSON.stringify(th.data.old_cartlist));

    if (th.data.cartlist && th.data.cartlist.length > 0) {
      for (var i = 0; i < c_arr.length; i++) {
        c_arr[i].exp_type = th.data.cartlist[i].exp_type;
        c_arr[i].wind = th.data.cartlist[i].wind;
      }
    }

    //重置订单促销判断累计
    this.re_set_order_prom_map_ck();

    for (var i in c_arr) {
      var cart_item = c_arr[i];
      cart_item.prom_pt_json = [];
      //要清空
      cart_item.g_zxlb_num = [];  //专享礼包
      cart_item.g_lb_num = [];     //旧礼包
      cart_item.g_monthlb_num = [];  //月包
      cart_item.g_coupon_num = [];   //送优惠券

      cart_item.s_coupon_id = '';
      cart_item.s_libao = '';
      cart_item.zx_libao = '';
      cart_item.monthlibao = '';

    }


    //调用函数计算每件商品的单价
    await th.calc_per(c_arr);

    //调用函数计算每件组合购商品的单价,
    await zh_calc.calc_zh_split_price(c_arr, th);
    //调用函数计算每件阶梯促销商品的单价,
    await ladder_calc.calc_split_price(c_arr, th);
    //调用函数计算，优惠券优惠什么商品价格，优惠券优惠什么商品
    console.error(c_arr);
    await th.get_cart_quan(c_arr);
    console.error('优惠券后');

    //-- 经纬度不循环调用接口 --
    var lon = 0; var lat = 0;
    //---循环购物车,按照门店订单进行循环---
    for (var i in c_arr) {
      //因为搭配购买也是再这里计算，搭配购的is_b_now==1
      if (th.data.is_b_now == 0) {
        //此时物流的选择方式要用th.data.cartlist;
        c_arr[i].exp_type = th.data.cartlist[i].exp_type;
        c_arr[i].wind = th.data.cartlist[i].wind;
        if (th.data.cartlist[i].check_quan_price_list) c_arr[i].check_quan_price_list = th.data.cartlist[i].check_quan_price_list;  //优惠券优惠什么商品价格
        if (th.data.cartlist[i].check_quan_ware_list) c_arr[i].check_quan_ware_list = th.data.cartlist[i].check_quan_ware_list;    //优惠券优惠什么商品
      } else {
        c_arr[i].exp_type = th.data.bn_exp_type;   //配送方式
        c_arr[i].wind = th.data.index;             //立即购买选择的物流
        //c_arr[i].=th.data.                        //立即购买的使用余额
        if (th.data.cartlist) c_arr[i].check_quan_price_list = th.data.cartlist[i].check_quan_price_list;  //优惠券优惠什么商品价格
        if (th.data.cartlist) c_arr[i].check_quan_ware_list = th.data.cartlist[i].check_quan_ware_list;    //优惠券优惠什么商品
      }


      var cart_item = c_arr[i];      //就是每一单的意思
      var pickid = cart_item.pickup_id;
      var o_price = 0;
      var o_price_no_zh = 0;  //参与订单优惠累积的金额
      var o_shipping_price = 0, goods_weight = -1, goods_piece = -1;
      var item = c_arr[i].goods;   //就是每一单的从表的意思

      //---如果有选择优惠券的情况下---
      var quan_price = 0;
      var coupon_price = 0;
      var quan_no = null;
      var is_has_zh = c_arr[i].is_has_zh;
      var is_has_ladder = c_arr[i].is_has_ladder;

      var zh_prom_goods = c_arr[i].zh_prom_goods;          //组合购计算的原始数据存储空间
      var ladder_prom_goods = c_arr[i].ladder_prom_goods;  //组合购计算的原始数据存储空间


      var no_order_yh = 0;    //-- 有些活动不能和订单优惠叠加的金额 --
      var no_post_temp = 0;   //-- 有些活动不能和包邮模板的金额 --
      var no_post_temp_shop_price = 0;     //-- 有些活动不能和包邮模板的金额 --因为订单促销有手店价取价
      var no_post_temp_market_price = 0;   //-- 有些活动不能和包邮模板的金额 --因为订单促销有市场价取价

      if (th.data.using_quan[pickid] != null && th.data.using_quan[pickid] != undefined)
        quan_no = th.data.using_quan[pickid].coupon_no;

      //普通券的时候
      if (quan_no && th.data.using_quan[pickid].isby != 1) {
        var IsUserWare = 1;
        let is_quan_scj=0;
        let get_c_price_data={
          storeId: oo.stoid,
          CashRepNo: quan_no,
          WaresSum: cart_item.check_quan_price_list,
          WareIds: cart_item.check_quan_ware_list
        };

        //-- 如果是零售价的时候 ---
        if(th.data.using_quan[pickid].FactPriceType){
           let scj_arr=c_arr[i].scj_arr;
           let scj_check_quan_price_list=[];
           let scj_check_quan_ware_list=[];
           for (let jh = 0; jh <scj_arr.length ; jh++) {

             //如果商品有重复的过滤，一般是组合购和阶梯购的情况下
             var idxx = scj_check_quan_ware_list.findIndex(function (ele) {
               return ele == encodeURIComponent(scj_arr[jh].erpwareid);
             })

             if (idxx > -1) {
               scj_check_quan_price_list[idxx] += scj_arr[jh].sum_price;
             } else {
               scj_check_quan_price_list.push(scj_arr[jh].sum_price);
               scj_check_quan_ware_list.push(encodeURIComponent(scj_arr[jh].erpwareid));
             }
           }

           get_c_price_data.WaresSum= scj_check_quan_price_list.join();
           get_c_price_data.WareIds= scj_check_quan_ware_list.join();
           is_quan_scj=1;
        }

        //---获取优惠券优惠---
        await getApp().request.promiseGet("/api/weshop/couponList/getUseCouponPrice", {
          data:get_c_price_data
        }).then(res => {
          if (res.data.code == 0 && res.data.data && res.data.data.length > 0) {
            var q_data = res.data.data;
            //--存储商品优惠的内容--
            cart_item.quan_youhui_list = q_data;
            for (var k in q_data) {
              quan_price += q_data[k].WareCashSum;
              IsUserWare = q_data[k].IsUserWare;
              if (!IsUserWare) {
                quan_price = 0;
                break;
              }
            }
          }
        })

        if (!IsUserWare) {

          wx.showToast({
            title: '优惠券使用对象的订单金额未满足',
            icon: 'none',
            duration: 1000,
          });
          th.setData({ submit: 0 });
          var txt = 'using_quan[' + pickid + ']';
          th.setData({ [txt]: null });
          return false;
        }

        if (cart_item.quan_youhui_list) {
          for (var kk in cart_item.quan_youhui_list) {
            var you_item = cart_item.quan_youhui_list[kk];
            //-- 对券的价格进行平摊 --
            await th.split_set_goods_quanprice(you_item, cart_item,is_quan_scj);
          }
        }

      }


      var whsle_goods_price = 0;
      var no_zh_all_quan_num = 0;  //不是组合购商品的使用的优惠券综合

      //--------循环计算总价-----------
      for (var jc = 0; jc < item.length; jc++) {
        //如果item的prom_type==0，没有如果活动的时候,如果是优惠促销和组合促销不满足的时候
        //或者是组合购和阶梯购多出来的商品
        if (item[jc].prom_type == 0 && !item[jc].whsle_id && !item[jc].is_no_order_yh) {
          th.get_order_prom_map_ck(item[jc], pickid);
        }

        if (item[jc].whsle_id > 0) {
          whsle_goods_price += item[jc].goods_price * item[jc].goods_num;
        }

        var is_no_zh = 0;
        if (item[jc].prom_type != 7 && item[jc].prom_type != 10) is_no_zh = 1;

        //组合购的商品，且有订单优惠的叠加,is_orderyh就是优惠叠加，就要累积组合购的金额
        if (item[jc].prom_type == 7 && th.data.zhhe_act_map && th.data.zhhe_act_map[item[jc].prom_id]
          && th.data.zhhe_act_map[item[jc].prom_id].is_orderyh) {
          is_no_zh = 1;
          th.get_order_prom_map_ck(item[jc], pickid); //有订单优惠叠加的时候，就要构建数据解救
        }
        //阶梯购的商品，且有订单优惠的叠加,is_orderyh就是优惠叠加，就要累积阶梯促销的金额
        if (item[jc].prom_type == 10 && ladder_prom_goods && ladder_prom_goods[item[jc].prom_id]
          && th.data.ladder_map[item[jc].prom_id].is_useorderyh) {
          is_no_zh = 1;
          th.get_order_prom_map_ck(item[jc], pickid); //有订单优惠叠加的时候，就要构建数据解救
        }

        if (is_no_zh) {
          o_price_no_zh += item[jc].goods_price * item[jc].goods_num;
          if (item[jc].quan_num && item[jc].quan_num > 0) no_zh_all_quan_num += item[jc].quan_num;
        }

        o_price += item[jc].goods_price * item[jc].goods_num;

        //--- 秒杀, 团购的时候，判断有没有订单优惠和包邮模板的叠加 ---
        if ([1, 2, 3, 5, 6, 7, 10].indexOf(item[jc].prom_type) > -1) {

          var gd_price = item[jc].goods_price;
          if (item[jc].account_fir) gd_price = item[jc].account_fir;

          //组合购和阶梯购是订单优惠是另外算的,不参与订单促销的时候
          if (!item[jc].is_order_yh && !item[jc].whsle_id && item[jc].prom_type != 7 && item[jc].prom_type != 10) {
            no_order_yh += gd_price * item[jc].goods_num;
            if (item[jc].quan_num) no_order_yh -= item[jc].quan_num;  //券要把他补回去
          }
          //参与订单促销的时候
          if (item[jc].is_order_yh && !item[jc].whsle_id && item[jc].prom_type != 7 && item[jc].prom_type != 10) {
            th.get_order_prom_map_ck(item[jc], pickid); //有订单优惠叠加的时候，就要构建数据解救
          }

          if (!item[jc].is_post_temp) {
            no_post_temp += gd_price * item[jc].goods_num;
            no_post_temp_shop_price += item[jc].shop_price * item[jc].goods_num;
            no_post_temp_market_price += item[jc].goods_market_price * item[jc].goods_num;
            if (item[jc].quan_num) no_post_temp -= item[jc].quan_num; //券要把他补回去
          }
        }

      }



      //判断是不是有组合购的金额
      var f_o_price = o_price;
      //如果又优惠的钱，就要减价
      if (c_arr[i].cut_price > 0) {
        o_price -= c_arr[i].cut_price;
        o_price_no_zh -= c_arr[i].cut_price;
      }
      //如果有组合购优惠的钱，就要减价
      if (c_arr[i].zh_cut_price > 0 || c_arr[i].zh_cut_price < 0) {
        o_price -= c_arr[i].zh_cut_price;
        if (o_price_no_zh > 0) {
          //找到那些可以订单优惠叠加的
          for (let ij in zh_prom_goods) {
            let kitem = zh_prom_goods[ij];
            if (kitem.act.is_orderyh)
              o_price_no_zh -= kitem.cut_price;
          }
        } else {
          //找到那些可以订单优惠叠加的
          for (let ij in zh_prom_goods) {
            let kitem_z = zh_prom_goods[ij];
            if (!kitem_z.act.is_orderyh)
              no_order_yh += kitem_z.actual_price;
          }
        }
      }

      //如果有组合购优惠的钱，就要减价
      if (c_arr[i].ladder_cut_price > 0 || c_arr[i].ladder_cut_price < 0) {
        o_price -= c_arr[i].ladder_cut_price;
        if (o_price_no_zh > 0) {
          //找到那些可以订单优惠叠加的
          for (let ij in ladder_prom_goods) {
            let kitem = ladder_prom_goods[ij];
            if (th.data.ladder_map[ij].is_useorderyh)
              o_price_no_zh -= kitem.cut_price;
          }
        } else {
          //找到那些可以订单优惠叠加的不参与的要减掉
          for (let ij in ladder_prom_goods) {
            let kitem_l = ladder_prom_goods[ij];
            if (!th.data.ladder_map[ij].is_useorderyh)
              no_order_yh += kitem_l.actual_price;
          }
        }
      }

      //-- 计算线下取价的功能 --
      if (cart_item.is_offline == 1) {
        o_price = o_price - cart_item.offline_price;
        o_price_no_zh -= c_arr[i].offline_price;
      }
      //判断包邮券的钱,组合购的商品不使用优惠券
      var q_conditin = 0;
      q_conditin = o_price - quan_price;
      if (is_has_zh) {
        q_conditin = o_price_no_zh - quan_price;
      }
      cart_item.goods_price = f_o_price.toFixed(2);      //商品总费用,用f_o_price来计算
      //计算物流费用
      cart_item.shipping_price = 0;

      th.data.is_no_past = 1;  //不包邮标识符

      var back_data = null;
      var quan_no_goods_arr = null;
      var ord_prom = null;


      var ord_prom_condition = 0;

      //如果有组合购
      if (o_price_no_zh) {
        ord_prom_condition = o_price_no_zh - whsle_goods_price - no_zh_all_quan_num - no_order_yh;
      } else {
        ord_prom_condition = o_price - quan_price - whsle_goods_price - no_order_yh;
      }

      //判断订单促销的实收价的累计
      if (!this.data.order_prom_map_ck[pickid]) {
        this.data.order_prom_map_ck[pickid] = {
          shop_price_all: 0,   //手店价的累计
          market_price_all: 0, //市场价的累计
          goods_price_all: 0,  //实收价的累计
          no_ord_price: 0,    //要累计上不参与订单促销的金额
          goodsList: [],
        }
      }
      this.data.order_prom_map_ck[pickid].goods_price_all = ord_prom_condition;
      //---判断是不是有订单优惠---
      // await getApp().request.promiseGet("/api/weshop/promorder/getOrderPromotion", {
      //   data: { store_id: os.stoid, orderAmount: parseFloat(ord_prom_condition).toFixed(2), user_id: getApp().globalData.user_id }
      // }).then(res => {
      //   if (res.data.code == 0) {
      //     ord_prom = res.data.data;
      //   }
      // })
      //获取当前时间段的进行中的订单促销
      ord_prom = await th.get_cur_ord_prom(pickid);

      //如果有使用优惠券，如何订单促销有控制使用优惠券不参与此活动的话
      if (quan_price > 0 && ord_prom && ord_prom.is_xz_yh) {
        ord_prom = null;
      }

      //--如果是物流，且选择了地址，就要开始显示包邮券，且包邮券也已经优惠了优惠活动的金额--
      if (cart_item.exp_type == 0 && th.data.user_addr != null && !cart_item.is_xz_yh) {

        //看是不是有调用过包邮券,同时有使用非实收的订单促销，就也不能显示包邮券
        if (!th.data.isget_by_quan[pickid] && !this.data.can_use_ord_prom[pickid] && cart_item.check_quan_ware_list) {
          //--判断要不要显示包邮券,调用接口，因为有for循环---
          await getApp().request.promiseGet("/api/weshop/userfeemail/pageAndArea", {
            data: {
              store_id: os.stoid,
              isuse: 0,
              //condition: q_conditin,
              condition: cart_item.ckeck_quan_price,
              user_id: getApp().globalData.user_id,
              pageSize: 2000
            }
          }).then(res => {
            console.error('包邮券1111111111111111111111111111');
            if (res.data.code == 0 && res.data.data.total > 0) {
              //此时要循环判断包邮的地区，不包邮商品是不是符合
              var arr = [], quanlist = res.data.data.pageData;
              quanlist = th.check_is_frozenQuan(quanlist, th.data.frozenQuan, 1);
              for (var i in quanlist) {
                var item = quanlist[i];
                var goods = cart_item.goods;
                var g_arr = [];
                for (var ii in goods) {
                  g_arr.push(goods[ii].goods_id);
                }
                if (item.region_list && th.check_by_area(item.region_list)) continue;  //如果是不包邮区域
                if (item.goods_list) {
                  var no_goods_arr = item.goods_list.split(",");
                  if (ut.isContained(no_goods_arr, g_arr)) continue;   //如果是不包邮商品
                }
                arr.push(item);
              }
              if (arr) {
                th.data.get_by_quan_list_cart[pickid] = arr;
                th.setData({ get_by_quan_list_cart: th.data.get_by_quan_list_cart, def_coupon3: arr });

                // let first_entry = th.data.first_entry;
                // if (arr && arr.length == 1 && first_entry == 0) {
                //   first_entry += 1;
                //   th.setData({
                //     by_quan_list_cart: arr,
                //     sele_cart_ind: 0,
                //     sele_exp_type: cart_item.exp_type,
                //     selected_quan_pick: pickid,
                //     first_entry
                //   })
                //   th.sele_quan_item_by_befor();
                //   th.confirm_quan_befor()
                // }

              }
              th.data.isget_by_quan[pickid] = 1;
            }
          })
        }

        //要让包邮券消失,在使用非实收包邮券的时候
        if (th.data.can_use_ord_prom[pickid]) {
          var tt_by = 'get_by_quan_list_cart[' + pickid + ']';
          th.setData({ [tt_by]: null });
          th.data.isget_by_quan[pickid] = 0;
        }


        //-- 如果没有订单优惠，或者订单优惠中有勾选包邮模板 --
        if (!ord_prom || ord_prom.is_post_temp) {

          let user_addr = th.data.user_addr;
          let c_wuliu = parseFloat(o_price - quan_price - whsle_goods_price - no_post_temp).toFixed(2);


          var req_d = {
            province: user_addr.province, city: user_addr.city, district: user_addr.district,
            wuliu: c_wuliu, store_id: os.stoid
          }
          await getApp().request.promisePost("/api/weshop/order/areaFreight", {
            is_json: 1, data: req_d
          }).then(rs => {
            if (rs.data.code == 0) back_data = rs.data.data;
          });
        }
      }

      //如果是包邮券的时候，要看看券的情况
      if (quan_no && th.data.using_quan[pickid].isby == 1) {
        var quan = th.data.using_quan[pickid];
        if (!quan.goods_list) {
          th.data.is_quan_by[pickid] = 1;  //专门给券的判断用的
        } else {
          th.data.is_quan_by[pickid] = 0;
          quan_no_goods_arr = quan.goods_list.split(",");

        }
      } else {
        th.data.is_quan_by[pickid] = 0;  //专门给券的判断用的
      }

      var cut_good_weight = 0;
      //计算物流价格
      if (cart_item.exp_type == 0 && th.data.user_addr && !th.data.is_quan_by[pickid]) {

        //如果有包邮券的不包邮商品的时候
        if (quan_no_goods_arr) {
          if (back_data && back_data.no_free_goods) {
            back_data['is_by_all'] = 1;
            var arr3 = back_data.no_free_goods.filter(item => {
              return quan_no_goods_arr.includes(item)
            })
            back_data.no_free_goods = null;
            if (arr3.length) {
              back_data.no_free_goods = arr3;
            }
          }
          if (!back_data || !back_data.no_free_goods) {
            if (!back_data) back_data = {};
            back_data['is_by_all'] = 1;
            back_data['no_free_goods'] = quan_no_goods_arr;
          }
        }


        var goods_weight_out1=-1;

        //--------循环计算总价-----------
        for (var j = 0; j < item.length; j++) {

          //如果是一件代发商品，不计算运费
          if (item[j].whsle_id) continue;
          //如果商品本身是包邮了
          if (item[j].is_free_shipping == 1) continue;
          //如果是优惠活动是包邮，就不用计算包邮的费用了
          if (item[j].is_past) continue;
          //--如果是包邮券使用的情况下，如果商品是包邮的，那么就不进行计算--
          if (th.data.using_quan[pickid] && th.data.using_quan[pickid].isby == 1 && th.data.is_quan_by[pickid]) {
            continue;
          }

          //-- 如果有达到包邮条件，同时判断商品有没有在不包邮商品里面 --
          if (back_data && back_data['is_by_all'] && item[j].is_post_temp
            && (!back_data.no_free_goods || !th.ck_no_goods_arr(back_data.no_free_goods, item[j].goods_id))) {

            //if( back_data.weight_free* 1000<item[j]['weight'] * item[j]['goods_num']){
              if (item[j]['exp_sum_type'] == 2 && back_data.weight_free > 0 ) {
                if (goods_weight_out1 < 0) goods_weight_out1 = 0;
                cut_good_weight += item[j]['weight'] * item[j]['goods_num'];
                goods_weight_out1 += item[j]['weight'] * item[j]['goods_num'];
              }
              if (back_data.weight_free > 0) {
                out_of_weight = (back_data.weight_free * 1000) - cut_good_weight;
              }
            //}
            continue;

          }

          switch (item[j]['exp_sum_type']) {
            case 1:
              //统一运费
              o_shipping_price += item[j]['uniform_exp_sum'];
              break;
            case 2:
              if (goods_weight < 0) goods_weight = 0;
              //累积商品重量 每种商品的重量 * 数量
              goods_weight += item[j]['weight'] * item[j]['goods_num'];

              if (back_data && back_data.is_by_all && !back_data.no_free_goods && item[j].is_post_temp) {
                cut_good_weight += item[j]['weight'] * item[j]['goods_num'];
                if (back_data.weight_free > 0) {
                  out_of_weight = (back_data.weight_free * 1000) - cut_good_weight;
                }
              }
              break;
            case 3:
              if (goods_piece < 0) goods_piece = 0;
              //累积商品数量
              goods_piece += item[j]['goods_num'];
              break;
          }

        }

        //如果是正值的时候,多少重量内免运费
        if (out_of_weight >= 0) out_of_weight = -cut_good_weight;
        else out_of_weight = -back_data.weight_free * 1000;

        if(out_of_weight<0){
          if (goods_weight < 0 && goods_weight_out1<0) goods_weight = -1;
          else{
             if(goods_weight<0) goods_weight=0;
             goods_weight+=(goods_weight_out1>-1?goods_weight_out1:0);
          }  
        }


        var code = "";

        if (!th.data.wu_arr) {
          wx.hideLoading();
          wx.showToast({
            title: "物流配置未启用物流公司", icon: 'none', duration: 2000
          })
          //th.setData({ show_submit:0, });
          th.setData({ show_submit: 1, submit: 0, same_ok: 0 })
          return false;
        }

        if (th.data.wu_arr && th.data.wu_arr[cart_item.wind])
          code = th.data.wu_arr[cart_item.wind].code;

        // cart_item.shipping_price =
        //     ut.calculatewuliu(code, o_shipping_price, goods_weight, out_of_weight,goods_piece, th.data.user_addr, back_data, rs);

        var no_free = back_data && back_data.no_free_goods && back_data.no_free_goods.length > 0 ? 1 : 0


        var w_data = {
          store_id: os.stoid, code: code,
          o_shipping_price: o_shipping_price,
          goods_weight: goods_weight,
          out_of_weight: out_of_weight, goods_piece: goods_piece,
          user_addr_province: th.data.user_addr.province,
          user_addr_city: th.data.user_addr.city,
          user_addr_district: th.data.user_addr.district,
          is_by_all: back_data && back_data.is_by_all ? 1 : 0,
          no_free_goods: no_post_temp > 0 || no_free ? 1 : 0,
        }

        var is_ok = 1;
        await getApp().request.promisePost('/api/weshop/order/getOrderWuLiPrice', { data: w_data, is_json: 1 }).then(res => {
          if (res.data.code == 0) {
            cart_item.shipping_price = res.data.data;
          } else {
            is_ok = 0;
          }
        })

        if (!is_ok) {
          wx.hideLoading();
          wx.showToast({
            title: "计算物流错误", icon: 'none', duration: 2000
          })
          //th.setData({ show_submit:0, });
          th.setData({ show_submit: 1, submit: 0, same_ok: 0 })

          return false;
        }

        if (!th.data.using_quan[pickid] || th.data.using_quan[pickid].isby != 1) {
          if (cart_item.shipping_price == 0) th.data.is_by[pickid] = 1; //已经全场包邮，就不要选择券了
        }
      } else if (cart_item.exp_type == 1) {
        cart_item.shipping_price = 0;
      }

      cart_item.shipping_price = cart_item.shipping_price.toFixed(2);
      //总价计算,总价不包含运费
      cart_item.order_amount = (o_price - quan_price).toFixed(2);
      cart_item.total_amount = f_o_price.toFixed(2);

      var order_prom_amount = 0;
      var order_prom_id = 0;
      var o_condition = cart_item.order_amount;
      var t_o_condition = cart_item.order_amount;


      //看一下是不是不用组合购的订单优惠的叠加
      if (is_has_zh) {
        o_condition = o_price_no_zh - no_zh_all_quan_num;
      }
      //看一下是不是不用组合购的订单优惠的叠加
      if (is_has_ladder) {
        o_condition = o_price_no_zh - no_zh_all_quan_num;
      }

      if (whsle_goods_price > 0) {
        o_condition = o_condition - whsle_goods_price;
        t_o_condition = t_o_condition - whsle_goods_price;
      }


      if (no_order_yh) {
        o_condition = o_condition - no_order_yh;
        t_o_condition = t_o_condition - no_order_yh;
        o_price_no_zh = o_price_no_zh - no_order_yh;
      }

      var order_m = 0;
      //么有使用券，或者活动没有限制使用优惠券
      if (ord_prom && (quan_price <= 0 || !ord_prom.is_xz_yh)) {
        order_prom_id = ord_prom['id'];
        //-- 订单促销是按照实收价格进行计算的时候 --
        switch (ord_prom['type']) {
          case 0:
            order_m = Math.round(o_condition * ord_prom['expression']) / 100;//满额打折
            order_prom_amount = (o_condition - order_m).toFixed(2);
            break;
          case 1:
            //order_m = o_condition - ord_prom['expression'];//满额优惠金额
            var bs = 1;
            if (ord_prom.is_bz) {
              bs = Math.floor(o_condition / ord_prom.money);
            }
            order_prom_amount = ord_prom['expression'];
            break;
        }

      }

      cart_item.order_prom_amount = 0;
      //--订单优惠的显示--
      if (order_prom_id > 0) {
        cart_item.order_amount = (o_price - quan_price - order_prom_amount).toFixed(2);
        cart_item.order_prom_id = order_prom_id;
        cart_item.order_prom_amount = order_prom_amount;
      }
      coupon_price = quan_price;
      if (cart_item.order_amount < 0) {
        cart_item.order_amount = 0;
        coupon_price = o_price;
      }


      //-- 在选择到同城配送的时候 --
      if (c_arr[i].exp_type == 2 && th.data.user_addr) {

        var gd_w = 0;
        for (let ib in c_arr[i].goods) {
          let item_bb = c_arr[i].goods[ib];
          gd_w += item_bb['weight'] * item_bb['goods_num'];
        }

        if (!lon) {
          //-- 获取距离  --
          await getApp().request.promisePost("/api/weshop/order/sameCityExp/getGeocoder", {
            is_json: 1, data: { address: th.data.user_addr.more_address + th.data.user_addr.address, store_id: os.stoid }
          }).then(res => {
            if (res.data.code == 0) {
              var data = JSON.parse(res.data.data);
              if (data.status == 0) {
                lon = data.result.location.lng;
                lat = data.result.location.lat;
              }
            }
          })
        }


        var req_data = {
          store_id: os.stoid, order_amount: parseFloat(cart_item.order_amount),
          lon: lon, lat: lat, pickup_id: c_arr[i].pickup_id, goods_weight: gd_w
        }
        var is_next = 1;

        //获取同城配送参数
        await getApp().request.promisePost("/api/weshop/order/sameCityExp/getMoney", { is_json: 1, data: req_data }).then(res => {
          if (res.data.code == 0) {
            cart_item.shipping_price = res.data.data;
            th.setData({
              sameCityExp_off: 0,
              sameCityExp_info: ''
            })
          } else {
            if (res.data.code == -2) {  //未达到起送价
              th.setData({
                sameCityExp_off: 2,
                sameCityExp_info: res.data.msg
              })
            } else {
              th.setData({
                sameCityExp_off: 1,
                sameCityExp_info: res.data.msg
              })
            }
            // is_next = 0;

            if (qfunc) qfunc();
            else {
              wx.showToast({
                title: res.data.msg,
                icon: 'none',
                duration: 2000
              })
            }
          }
        })
        if (!is_next) {
          th.setData({ show_submit: 1, submit: 0, same_ok: 0 })
          return false
        }

        //重量要带出去
        cart_item.gd_w = gd_w;
        cart_item.samecity_order_amount = req_data.order_amount;

      }

      //预存金额使用参与计算
      if (th.data.udata && th.data.udata.Balance > 0 && cart_item.order_amount * 1 > 0) {

        if (!cart_item.sto) {
          console.log('没有线下门店id');
          //获取门店信息
          await getApp().request.promiseGet("/api/weshop/pickup/list", {
            data: {
              store_id: os.stoid,
              ids: th.data.bn_pick
            }
          }).then(res => {
            if (ut.ajax_ok(res)) {
              console.log(res);
              if (res.data.code == 0) {
                let resData = res.data.data.pageData
                if (resData && resData[0]) {
                  let keyid = resData[0].keyid

                  cart_item.sto = {
                    keyid
                  }
                }
              }
            }
          })
        }
        let cart_yc = await th.beforAdvancesum(cart_item)

        console.log('购物车--------');
        if (!cart_item.yck_off) {
          cart_item.yck_off = cart_yc.yck_off
        }
        if (cart_yc.yck * 1 == 0) {
          cart_item.yck_off = 0
        }
        cart_item.yck = cart_yc.yck
        cart_item.yckid = cart_yc.yckid
        cart_item.pre_json = cart_yc.pre_json
        let yct1 = 'cartlist[' + i + '].yck_off';
        let yct11 = 'old_cartlist[' + i + '].yck_off';
        let yct2 = 'cartlist[' + i + '].yck';
        let yct22 = 'old_cartlist[' + i + '].yck';
        let yct3 = 'cartlist[' + i + '].yckid';
        let yct33 = 'old_cartlist[' + i + '].yckid';
        let yct4 = 'cartlist[' + i + '].pre_json';
        let yct44 = 'old_cartlist[' + i + '].pre_json';
        th.setData({
          [yct1]: cart_item.yck_off,
          [yct11]: cart_item.yck_off,
          [yct2]: cart_item.yck,
          [yct22]: cart_item.yck,
          [yct3]: cart_item.yckid,
          [yct33]: cart_item.yckid,
          [yct4]: cart_item.pre_json,
          [yct44]: cart_item.pre_json,
        })
        //搭配购直接购买特殊处理
        if (th.data.collocation_goods) {
          let yct1 = 'bn_goods.yck_off';
          let yct2 = 'bn_goods.yck';
          let yct3 = 'bn_goods.yckid';
          let yct4 = 'bn_goods.pre_json';
          th.setData({
            [yct1]: cart_item.yck_off,
            [yct2]: cart_item.yck,
            [yct3]: cart_item.yckid,
            [yct4]: cart_item.pre_json,
          })
        }
        //--------------------
        if (cart_item.yck_off && cart_item.yck_off == 2) {
          let order_amount = (cart_item.order_amount - cart_item.yck).toFixed(2);
          let yck = 0
          if (order_amount * 1 > 0) {
            cart_item.order_amount = order_amount;
            all_prestore += parseFloat(cart_item.yck);
            yck = parseFloat(cart_item.yck)
          } else {
            all_prestore += cart_item.order_amount * 1
            yck = parseFloat(cart_item.order_amount)
            cart_item.order_amount = 0
          }
          all_yck_arr.push(yck) //真实预存款抵扣金额
          all_pre_json.push(cart_item.pre_json)
          all_prestore = parseFloat(all_prestore); //真实预存款抵扣金额总和
        }
      } else {
        let yct1 = 'cartlist[' + i + '].yck_off';
        let yct11 = 'old_cartlist[' + i + '].yck_off';
        let yct2 = 'cartlist[' + i + '].yck';
        let yct22 = 'old_cartlist[' + i + '].yck';
        let yct3 = 'cartlist[' + i + '].yckid';
        let yct33 = 'old_cartlist[' + i + '].yckid';
        let yct4 = 'cartlist[' + i + '].pre_json';
        let yct44 = 'old_cartlist[' + i + '].pre_json';
        th.setData({
          [yct2]: 0,
          [yct22]: 0,
          [yct3]: '',
          [yct33]: '',
          [yct4]: '',
          [yct44]: '',
        })
      }



      cart_item.total_amount = parseFloat(cart_item.total_amount) + parseFloat(cart_item.shipping_price);  //总金额
      cart_item.order_amount = parseFloat(cart_item.order_amount) + parseFloat(cart_item.shipping_price);  //总金额
      cart_item.total_amount = cart_item.total_amount.toFixed(2);
      cart_item.order_amount = cart_item.order_amount.toFixed(2);

      //-- 最后的金额小于佣金 --
      if (cart_item.order_amount < cart_item.can_usecommise) {

        if (th.data.cart_use_commission) {
          wx.showToast({
            title: '应付金额小于本单佣金，不可使用！',
            icon: 'none',
            duration: 2000
          })
        }

        th.setData({
          cart_use_commission: 0
        });


      }


      if (th.data.cart_use_commission && cart_item.can_usecommise) {
        cart_item.order_amount -= cart_item.can_usecommise;
      }

      //搭配购在使用余额
      if (th.data.bn_use_money == 1 && th.data.is_b_now == 1) {

        if (umoney > cart_item.order_amount) {
          cart_item.user_money = cart_item.order_amount;
          umoney = umoney - cart_item.order_amount;
        } else {
          cart_item.user_money = umoney;
          umoney = 0;
        }

      } else {
        //--------------如果使用余额,购物车购买---------------------
        if (th.data.js_use_money == 1) {
          if (umoney > cart_item.order_amount) {
            cart_item.user_money = cart_item.order_amount;
            umoney = umoney - cart_item.order_amount;
          } else {
            cart_item.user_money = umoney;
            umoney = 0;
          }
        } else {
          cart_item.user_money = 0;
        }
      }

      cart_item.user_money = parseFloat(cart_item.user_money).toFixed(2);
      if (coupon_price > 0) cart_item.coupon_price = coupon_price.toFixed(2);
      else cart_item.coupon_price = coupon_price
      if (quan_no) cart_item.quan_no = quan_no;


      //cart_item.goods_price = o_price.toFixed(2);
      cart_item.order_amount = cart_item.order_amount - cart_item.user_money;         //会员使用余额


      all_price += parseFloat(f_o_price);
      all_total_m += parseFloat(cart_item.total_amount);
      all_shipping_m += parseFloat(cart_item.shipping_price);
      all_order_m += parseFloat(cart_item.order_amount);
      all_user_m += parseFloat(cart_item.user_money);
      all_coupon_price_m += parseFloat(cart_item.coupon_price);
      all_cutprice += parseFloat(cart_item.cut_price);

      all_zh_cutprice += parseFloat((cart_item.zh_cut_price ? cart_item.zh_cut_price : '0'));
      all_ladder_cutprice += parseFloat(cart_item.ladder_cut_price);
      all_order_prom += parseFloat(cart_item.order_prom_amount);
    }

    all_prestore = parseFloat(all_prestore).toFixed(2);
    all_shipping_m = parseFloat(all_shipping_m).toFixed(2);
    all_total_m = parseFloat(all_total_m).toFixed(2);
    all_order_m = parseFloat(all_order_m).toFixed(2);
    all_price = parseFloat(all_price).toFixed(2);
    all_user_m = parseFloat(all_user_m).toFixed(2);
    all_total_m = parseFloat(all_total_m).toFixed(2);
    all_coupon_price_m = parseFloat(all_coupon_price_m).toFixed(2);
    all_cutprice = all_cutprice.toFixed(2);
    all_order_prom = all_order_prom.toFixed(2);
    all_zh_cutprice = parseFloat(all_zh_cutprice).toFixed(2);
    all_ladder_cutprice = parseFloat(all_ladder_cutprice).toFixed(2);

    var atxt = "formData.total_amount";
    var atxt1 = "formData.order_amount";
    var atxt2 = "formData.all_price";
    var atxt3 = "formData.user_money";
    var atxt4 = "formData.shipping_price";
    var atxt5 = "formData.coupon_price";
    var atxt6 = "formData.cut_price";
    var atxt7 = "formData.order_prom_amount";
    var atxt8 = "formData.zh_cut_price";
    var atxt9 = "formData.ladder_cut_price";
    var atxt10 = "formData.prestore"; //预存金额
    var atxt11 = "formData.pre_json"; //预存json
    var atxt12 = "formData.all_yck_arr"; //预存真实抵扣列表

    th.setData({
      [atxt]: all_total_m, [atxt1]: all_order_m,
      [atxt2]: all_price, [atxt3]: all_user_m, [atxt4]: all_shipping_m,
      [atxt5]: all_coupon_price_m, [atxt6]: all_cutprice,
      [atxt7]: all_order_prom, show_submit: 1, [atxt8]: all_zh_cutprice, [atxt9]: all_ladder_cutprice, submit: 0,
      [atxt10]: all_prestore,
      [atxt11]: all_pre_json,
      [atxt12]: all_yck_arr,
    })

    th.data.lon = lon;
    th.data.lat = lat;

    th.data.order_prom_list_cart = c_arr;
    th.set_can_num();
     //调用默认优惠券方法
    th.def_coupon_fn();
    // wx.hideLoading();
    
    //});
  },

  set_can_num: function () {
    var th = this;
    //-- 这个地方，循环计算几张优惠券可用--
    for (var iter in th.data.cartlist) {
      var num = 0;
      var c_item = th.data.cartlist[iter];
      var pkid = c_item.pickup_id;
      //-- 普通券 --
      if (c_item.quan_list) {
        for (var iter1 in c_item.quan_list) {
          //判断是不是其他订单有选用
          var is_other_is_use = th.check_other_use(c_item.quan_list[iter1], pkid);
          if (!is_other_is_use) num++;
        }
      }
      //-- 包邮券 --
      var by_quan = th.data.get_by_quan_list_cart[pkid];
      if (by_quan && c_item.exp_type == 0) {
        for (var iter2 in by_quan) {
          //判断是不是其他订单有选用
          var is_other_is_use = th.check_other_use_by(by_quan[iter2], pkid);
          if (!is_other_is_use) num++;
        }
      }
      var set_txt = "cartlist[" + iter + "].can_num";
      th.setData({ [set_txt]: num });
    }
  },

  //-- 判断商品是不是在不包邮商品里面 --
  ck_no_goods_arr(no_free_goods, goods_id) {
    for (var j = 0; j < no_free_goods.length; j++) {
      var ck_gd_id = parseInt(no_free_goods[j] + '');
      var goods_id = parseInt(goods_id + '');
      if (ck_gd_id == goods_id) {
        return true;
      }
    }
    return false;
  },

  //---------计算立即购买----------
  calculatePrice2: async function (qfunc) {
    var th = this, good = this.data.bn_goods;

    if (!good) return false;
    console.error('计算价格-----222222222222222---------');
    //搭配的计算要用购物的车计算方法 
    // if (good.prom_type == 5 ) {

    if (good.prom_type == 5) {
      if (th.data.old_cartlist && th.data.old_cartlist.length > 0) {
        th.calculatePrice();
        return false;
      } else {
        //如果搭配购搭配商品未空的话，让主商品的活动变成0，取消搭配购
        th.setData({ 'bn_goods.prom_type': 0, 'bn_goods.prom_id': 0, collocation_goods: [] });
        good.prom_type = 0
        good.prom_id = 0
      }
    }

    th.setData({ submit: 1 });
    wx.showLoading({
      title: "处理中.",
      mask: true
    })

    //-----------计算商品总价--------------
    var allpice = good.shop_price * good.buynum;
    var cut_price = 0;
    var allpice1 = allpice;

    th.data.lon = 0;
    th.data.lat = 0;

    //如果有线下取价的时候
    if (good.is_offline) {
      allpice = good.offline_price * good.buynum;
    }

    if (good.prom_type == 3 && good.prom_price !== null) {
      cut_price = allpice - good.prom_price;
    }

    allpice = parseFloat(allpice).toFixed(2);
    var txt = "formData.all_price";
    th.setData({ [txt]: allpice, });
    if (cut_price) {
      var c_txt = "formData.cut_price";
      th.setData({ [c_txt]: cut_price, });
    }

    //to.getwuliuprice(async function (rs) {

    var o_shipping_price = 0, goods_weight = -1, goods_piece = -1;
    var out_of_weight = null; //超出多少重量

    //---如果有选择优惠券的情况下---
    var quan_price = 0, bn_pick = th.data.bn_pick;
    var quan_no = null;
    if (th.data.using_quan && th.data.using_quan[bn_pick] != null && th.data.using_quan[bn_pick] != undefined)
      quan_no = th.data.using_quan[bn_pick].coupon_no;

    if (quan_no) {
      //如果是一件代发就不要找商品
      if (th.data.using_quan[bn_pick].isby != 1 && !good.whsle_id) {
        //---获取优惠券优惠---
        await getApp().request.promiseGet("/api/weshop/couponList/getUseCouponPrice", {
          data: {
            storeId: oo.stoid,
            CashRepNo: quan_no,
            WaresSum: th.data.ckeck_quan_price,
            WareIds: th.data.check_quan_ware_list
          }
        }).then(res => {

          if (res.data.code == 0 && res.data.data && res.data.data.length > 0) {
            quan_price = res.data.data[0].WareCashSum;
          }
        })
      }
    }

    var gd_arr_list = [];
    gd_arr_list.push(good);
    if (th.data.buy_now_gift_goods) {
      gd_arr_list = [...gd_arr_list, ...th.data.buy_now_gift_goods];
    }

    //-- 把订单优惠的判断提前，bn_is_order_yh是确定要不要订单优惠的控制 --
    var condition = parseFloat(parseFloat(allpice) - cut_price - quan_price).toFixed(2);
    var ord_prom = null;
    var is_ord_prom_post = 0;

    //一件代发商品不参与订单优惠， 本身商品的活动也有要不要参与优惠促销的设置bn_is_order_yh
    if (th.data.bn_is_order_yh && !th.data.bn_goods.whsle_id) {

      th.set_by_now_ord_prom(th.data.bn_goods);
      th.data.order_prom_map_ck[bn_pick].goods_price_all = condition;

      // await getApp().request.promiseGet("/api/weshop/promorder/getOrderPromotion", {
      //   data: { store_id: os.stoid, orderAmount: condition, user_id: getApp().globalData.user_id }
      // }).then(res => {
      //   if (res.data.code == 0) {
      //     var data = res.data.data;
      //     ord_prom = data;
      //   }
      // })
      ord_prom = await th.get_cur_ord_prom(bn_pick);

      if (ord_prom && ord_prom.is_post_temp) {
        is_ord_prom_post = 1;
      }
    }

    //如果有使用优惠券，订单促销又是使用优惠券不参与此活动
    if (quan_price > 0 && ord_prom && ord_prom.is_xz_yh) {
      ord_prom = null;
    }

    //-----------当地址不为空，且是物流时，计算物流费用,并同时商品不是优惠活动的包邮----------
    if (th.data.user_addr != null && th.data.bn_exp_type == 0 && good.is_past != 1) {
      //看是不是有调用过包邮券，同时非实收订单促销也不用使用包邮券
      if (!th.data.isget_by_quan[th.data.bn_pick] && good.is_xz_yh != 1 && !th.data.can_use_ord_prom[th.data.bn_pick]) {

        //--判断要不要显示包邮券,链式调用接口，调取包邮券，已经是减了优惠的金额，见到优惠券的钱---
        await getApp().request.promiseGet("/api/weshop/userfeemail/pageAndArea", {
          data: {
            store_id: os.stoid,
            isuse: 0,
            condition: condition,
            user_id: getApp().globalData.user_id,
            pageSize: 2000
          }
        }).then(res => {
          console.error('包邮券22222222222222222222');
          if (res.data.code == 0 && res.data.data.total > 0) {
            //此时要循环判断包邮的地区，不包邮商品是不是符合
            var arr = [], quanlist = res.data.data.pageData;
            quanlist = th.check_is_frozenQuan(quanlist, th.data.frozenQuan, 1);
            for (var i in quanlist) {
              var item = quanlist[i];
              if (item.region_list && th.check_by_area(item.region_list)) continue;  //如果是不包邮区域
              if (item.goods_list) {
                var no_goods_arr = item.goods_list.split(",");
                if (ut.isContained(no_goods_arr, gd_arr_list)) continue;   //如果是不包邮商品
              }
              arr.push(item);
            }
            if (arr) {
              th.setData({ get_by_quan_list: arr, def_coupon4: arr });
              // let first_entry = th.data.first_entry;
              // if ( arr && arr.length == 1 && first_entry == 0) {
              //   first_entry += 1;
              //   th.setData({
              //     first_entry
              //   })
              //   setTimeout(() => {                
              //     th.setData({
              //       sele_cart_ind: 0,
              //       selected_quan_pick: th.data.bn_pick,
              //     })
              //     th.sele_quan_item_by_befor();
              //     th.confirm_quan_befor()
              //   }, 500);
              // }
            }
            th.data.isget_by_quan[th.data.bn_pick] = 1;
          }
        })
      }


      //要让包邮券消失,在使用非实收包邮券的时候
      if (th.data.can_use_ord_prom[th.data.bn_pick]) {
        th.setData({ get_by_quan_list: null });
        th.data.isget_by_quan[th.data.bn_pick] = 0;
      }


      var shipping_price = 0;
      var quan_no_goods_arr = null;
      var is_by_quan = 0;
      var pickid = th.data.bn_pick;

      //如果是包邮券的时候，要看看券的情况,判断一下包邮有没有不包邮模板
      if (quan_no && th.data.using_quan[pickid].isby == 1) {
        var quan = th.data.using_quan[pickid];
        if (quan.goods_list) {
          quan_no_goods_arr = quan.goods_list.split(",");
        } else {
          is_by_quan = 1;
        }
      }

      if (!is_by_quan) {
        var user_addr = th.data.user_addr;
        var req_d = {
          province: user_addr.province,
          city: user_addr.city,
          district: user_addr.district,
          wuliu: parseFloat(parseFloat(allpice) - cut_price - quan_price).toFixed(2),
          store_id: os.stoid
        }
        var back_data = null;

        //判断是不是包邮模板,bn_is_post_temp  和 订单优惠的包邮模板一起控制
        if (th.data.bn_is_post_temp && (!ord_prom || is_ord_prom_post)) {

          await getApp().request.promisePost("/api/weshop/order/areaFreight", {
            is_json: 1, data: req_d
          }).then(rs => {
            if (rs.data.code == 0) back_data = rs.data.data;
          });
        }

        //如果有包邮券的不包邮商品的时候
        if (quan_no_goods_arr) {
          if (back_data && back_data.no_free_goods) {
            back_data['is_by_all'] = 1;
            var arr3 = back_data.no_free_goods.filter(item => {
              return quan_no_goods_arr.includes(item)
            })
            back_data.no_free_goods = null;
            if (arr3.length) {
              back_data.no_free_goods = arr3;
            }
          }
          if (!back_data || !back_data.no_free_goods) {
            if (!back_data) back_data = {};
            back_data['is_by_all'] = 1;
            back_data['no_free_goods'] = quan_no_goods_arr;
          }
        }

        var cut_good_weight = 0;
        for (let i in gd_arr_list) {
          let item = gd_arr_list[i];

          if (good.is_free_shipping == 1) continue;
          //-- 代发商品不算运费 --
          if (good.whsle_id) continue;

          if (back_data && back_data['is_by_all'] && (!back_data.no_free_goods || !th.ck_no_goods_arr(back_data.no_free_goods, item.goods_id))) {

            if(back_data.weight_free* 1000<item['weight'] * item['buynum']){
              if (item['exp_sum_type'] == 2 && back_data.weight_free > 0) {
                if (goods_weight < 0) goods_weight = 0;
                goods_weight += item['weight'] * item['buynum'];
                cut_good_weight += item['weight'] * item['buynum'];
              }
              if (back_data.weight_free > 0) {
                out_of_weight = (back_data.weight_free * 1000) - cut_good_weight;
              }
           }
            continue;

          }

          switch (item['exp_sum_type']) {
            case 1:
              //统一运费
              o_shipping_price += item['uniform_exp_sum'];
              break;
            case 2:
              if (goods_weight < 0) goods_weight = 0;
              //累积商品重量 每种商品的重量 * 数量
              goods_weight += item['weight'] * item['buynum'];

              if (back_data && back_data.is_by_all && !back_data.no_free_goods) {
                cut_good_weight += item['weight'] * item['buynum'];
                if (back_data.weight_free > 0) {
                  out_of_weight = (back_data.weight_free * 1000) - cut_good_weight;
                }
              }
              break;
            case 3:
              if (goods_piece < 0) goods_piece = 0;
              //累积商品数量
              goods_piece += parseInt(item['buynum']);
              break;
          }
        }

        //如果是正值的时候
        if (out_of_weight >= 0) out_of_weight = -cut_good_weight;
        else out_of_weight = -back_data.weight_free * 1000;

        var code = "";
        if (!th.data.wu_arr) {
          wx.hideLoading();
          wx.showToast({
            title: "物流配置未启用物流公司", icon: 'none', duration: 2000
          })
          //th.setData({ show_submit:0, });
          th.setData({ show_submit: 1, submit: 0, same_ok: 0 })
          return false;
        }


        if (th.data.wu_arr && th.data.wu_arr[th.data.index]) code = th.data.wu_arr[th.data.index].code;
        th.data.is_no_by[th.data.bn_pick] = 0;
        th.data.is_by[th.data.bn_pick] = 0;

        //--------------开始计算物流------------------
        // shipping_price = ut.calculatewuliu(code, o_shipping_price, goods_weight, out_of_weight,
        //     goods_piece, th.data.user_addr, back_data, rs);

        var w_data = {
          store_id: os.stoid, code: code,
          o_shipping_price: o_shipping_price,
          goods_weight: goods_weight,
          out_of_weight: out_of_weight, goods_piece: goods_piece,
          user_addr_province: th.data.user_addr.province,
          user_addr_city: th.data.user_addr.city,
          user_addr_district: th.data.user_addr.district,
          is_by_all: back_data && back_data.is_by_all ? 1 : 0,
          no_free_goods: back_data && back_data.no_free_goods && back_data.no_free_goods.length > 0 ? 1 : 0,
        }

        var is_ok = 1;
        await getApp().request.promisePost('/api/weshop/order/getOrderWuLiPrice', { data: w_data, is_json: 1 }).then(res => {
          if (res.data.code == 0) {
            shipping_price = res.data.data;
          } else {
            is_ok = 0;
          }
        })

        if (!is_ok) {
          wx.hideLoading();
          wx.showToast({
            title: "计算物流错误", icon: 'none', duration: 2000
          })
          //th.setData({ show_submit:0 });
          th.setData({ show_submit: 1, submit: 0, same_ok: 0 })

          return false;
        }

        if (shipping_price <= 0) {
          th.data.is_by[th.data.bn_pick] = 1;  //已经是包邮了，就不要选择包邮券
        }
      }

      shipping_price = parseFloat(shipping_price).toFixed(2);
      var wl_txt = "formData.shipping_price";
      th.setData({ [wl_txt]: shipping_price, })

    } else if (th.data.bn_exp_type == 1) {
      var wl_txt = "formData.shipping_price";
      th.setData({ [wl_txt]: 0, })
    }
    console.error('包邮券汇总----');
    
    if (quan_no) {
      if (th.data.using_quan[bn_pick].isby == 1) {
        shipping_price = 0;
        var wl_txt = "formData.shipping_price";
        th.setData({ [wl_txt]: 0, })
      }
    }

    //-----------------支付价,优惠券不减物流-----------------
    var total_m = (parseFloat(allpice1)).toFixed(2);
    var order_m = (parseFloat(allpice - cut_price) - quan_price).toFixed(2);
    var coupon_price = quan_price; //优惠券优惠了多少钱
    if (order_m < 0) {
      order_m = 0;
      coupon_price = parseFloat(allpice - cut_price).toFixed(2);
    }
    //--看一下有没有订单优惠--
    var o_condition = parseFloat(order_m);
    if (th.data.bn_goods.whsle_id > 0) {
      o_condition = 0;
    }

    var order_prom_amount = 0;
    var order_prom_id = 0;
    if (ord_prom && o_condition > 0) {
      //么有使用券，或者活动没有限制使用优惠券
      if (coupon_price <= 0 || !ord_prom.is_xz_yh) {
        order_prom_id = ord_prom['id'];
        switch (ord_prom['type']) {
          case 0:
            order_m = Math.round(o_condition * ord_prom['expression']) / 100;//满额打折
            order_prom_amount = (o_condition - order_m).toFixed(2);
            break;
          case 1:
            //-- 如果有优惠促销倍减的时候 --
            var bs = 1;
            if (ord_prom.is_bz) {
              bs = Math.floor(o_condition / ord_prom.money);
            }

            order_m = o_condition - bs * ord_prom['expression'];//满额优惠金额
            order_prom_amount = ord_prom['expression'];
            break;
        }
      }
    }
    //--订单优惠的显示--
    var order_prom_txt1 = "formData.order_prom_id";
    var order_prom_txt2 = "formData.order_prom_amount";
    if (order_prom_id > 0) {
      th.setData({ [order_prom_txt1]: order_prom_id, [order_prom_txt2]: order_prom_amount })
    } else {
      th.setData({ [order_prom_txt1]: 0, [order_prom_txt2]: 0 })
    }

    //预存金额使用参与计算
    if (th.data.udata && th.data.udata.Balance > 0 && order_m * 1 > 0) {
      if (!th.data.bn_goods.keyid) {
        //获取门店信息
        await getApp().request.promiseGet("/api/weshop/pickup/list", {
          data: {
            store_id: os.stoid,
            ids: th.data.bn_pick
          }
        }).then(res => {
          if (ut.ajax_ok(res)) {
            console.log(res);
            if (res.data.code == 0) {
              let resData = res.data.data.pageData
              if (resData && resData[0]) {
                let keyid = resData[0].keyid
                let txt = 'bn_goods.keyid'
                th.setData({
                  [txt]: keyid
                })
              }
            }
          }
        })
      }

      if (th.data.bn_goods.keyid) {

        let cart_yc = await th.beforAdvancesum({
          order_amount: order_m,
          goods: [{
            goods_sn: th.data.bn_goods.goods_sn,
            goods_price: th.data.bn_goods.shop_price || th.data.bn_goods.goods_price,
            goods_num: th.data.bn_goods.buynum || th.data.bn_goods.goods_num,

            account_fir: th.data.bn_goods.shop_price || th.data.bn_goods.goods_price,
            account_yu_fir: 0

          }],
          sto: {
            keyid: th.data.bn_goods.keyid
          }
        })

        if (!good.yck_off) {
          good.yck_off = cart_yc.yck_off
        }
        if (cart_yc.yck * 1 == 0) {
          good.yck_off = 0
        }
        good.yck = cart_yc.yck
        good.yckid = cart_yc.yckid
        good.pre_json = cart_yc.pre_json
        let yct1 = 'bn_goods.yck_off';
        let yct2 = 'bn_goods.yck';
        let yct3 = 'bn_goods.yckid';
        let yct4 = 'bn_goods.pre_json';
        th.setData({
          [yct1]: good.yck_off,
          [yct2]: good.yck,
          [yct3]: good.yckid,
          [yct4]: good.pre_json,
        })

        if (good.yck_off && good.yck_off == 2) {
          let order_amount = (order_m - good.yck).toFixed(2);
          let yck = 0
          if (order_amount * 1 > 0) {
            order_m = order_amount;
            // all_prestore+=parseFloat(good.yck);
            yck = parseFloat(good.yck)
          } else {
            // all_prestore+=order_m*1
            yck = parseFloat(order_m)
            order_m = 0
          }
          let atxt10 = "formData.prestore"; //预存金额
          let atxt11 = "formData.pre_json"; //预存json
          let atxt12 = "formData.all_yck_arr"; //预存真实抵扣列表
          th.setData({
            [atxt10]: yck,
            [atxt11]: [good.pre_json],
            [atxt12]: [yck],
          })
          // formData.prestore
          // all_yck_arr.push(yck) //真实预存款抵扣金额
          // all_pre_json.push(good.pre_json)
          // all_prestore = parseFloat(all_prestore); //真实预存款抵扣金额总和
        } else {
          let atxt10 = "formData.prestore"; //预存金额
          let atxt11 = "formData.pre_json"; //预存json
          let atxt12 = "formData.all_yck_arr"; //预存真实抵扣列表
          th.setData({
            [atxt10]: 0,
            [atxt11]: '',
            [atxt12]: [],
          })
        }
      }
    } else {
      let yct1 = 'bn_goods.yck_off';
      let yct2 = 'bn_goods.yck';
      let yct3 = 'bn_goods.yckid';
      let yct4 = 'bn_goods.pre_json';
      let atxt10 = "formData.prestore"; //预存金额
      let atxt11 = "formData.pre_json"; //预存json
      let atxt12 = "formData.all_yck_arr"; //预存真实抵扣列表
      th.setData({
        [yct2]: 0,
        [yct3]: '',
        [yct4]: '',
        [atxt10]: 0,
        [atxt11]: '',
        [atxt12]: [],
      })
    }


    //判断是否同城配送,而且没有调用过
    if (th.data.bn_exp_type == 2 && th.data.user_addr) {
      var gd_w = 0, lon = 0, lat = 0;
      for (let ib in gd_arr_list) {
        let item_b = gd_arr_list[ib];
        gd_w += item_b['weight'] * item_b['buynum'];
      }

      //-- 获取距离  --
      await getApp().request.promisePost("/api/weshop/order/sameCityExp/getGeocoder", {
        is_json: 1, data: { address: th.data.user_addr.more_address + th.data.user_addr.address, store_id: os.stoid }
      }).then(res => {
        if (res.data.code == 0) {
          var data = JSON.parse(res.data.data);
          if (data.status == 0) {
            lon = data.result.location.lng;
            lat = data.result.location.lat;
          }
        }
      })

      var req_data = {
        store_id: os.stoid, order_amount: parseFloat(order_m),
        lon: lon, lat: lat, pickup_id: bn_pick, goods_weight: gd_w
      }

      var is_next = 1;

      //获取同城配送参数
      await getApp().request.promisePost("/api/weshop/order/sameCityExp/getMoney", {
        is_json: 1, data: req_data
      }).then(res => {
        if (res.data.code == 0) {
          var wl_txt = "formData.shipping_price";
          th.setData({ [wl_txt]: res.data.data, })
          th.setData({
            sameCityExp_off: 0,
            sameCityExp_info: ''
          })
        } else {
          if (res.data.code == -2) {  //未达到起送价
            th.setData({
              sameCityExp_off: 2,
              sameCityExp_info: res.data.msg
            })
          } else {
            th.setData({
              sameCityExp_off: 1,
              sameCityExp_info: res.data.msg
            })
          }
          // is_next = 0;
          if (qfunc) {
            qfunc();
          } else {
            wx.showToast({
              title: res.data.msg,
              icon: 'none',
              duration: 2000
            })
          }

        }
      })
      if (!is_next) {
        th.setData({ show_submit: 1, same_ok: 0, submit: 0 })
        return false
      }
      th.data.lon = lon;
      th.data.lat = lat;
      th.data.bn_gd_w = gd_w;
      th.data.bn_samecity_order_amount = req_data.order_amount;
    }


    total_m = parseFloat(total_m) + parseFloat(th.data.formData.shipping_price);
    order_m = parseFloat(order_m) + parseFloat(th.data.formData.shipping_price);

    total_m = total_m.toFixed(2);
    order_m = order_m.toFixed(2);

    var atxt = "formData.total_amount";
    th.setData({ [atxt]: total_m, })

    var txt = "formData.user_money";
    var txt2 = "formData.order_amount";
    var txt3 = "formData.coupon_price";

    //-- 最后的金额小于佣金 --
    if (parseFloat(order_m) < parseFloat(th.data.bn_goods.use_commission)) {

      if (th.data.bn_use_commission) {
        wx.showToast({
          title: '应付金额小于本单佣金，不可使用！',
          icon: 'none',
          duration: 2000
        })
      }

      th.setData({
        bn_use_commission: 0
      });


    }

    var txt4 = "formData.use_commission";

    if (th.data.bn_use_commission) {
      order_m = (parseFloat(order_m) - parseFloat(th.data.bn_goods.use_commission)).toFixed(2);
      th.setData({ [txt4]: th.data.bn_goods.use_commission })
    }


    var amoney = parseFloat(th.data.userinfo.user_money - th.data.txmon - th.data.userinfo.frozen_money);
    //--------------如果使用余额---------------------
    if (th.data.bn_use_money == 1) {
      if (amoney > parseFloat(order_m)) {
        order_m = parseFloat(order_m).toFixed(2);
        th.setData({ [txt]: order_m, [txt2]: 0, [txt3]: coupon_price, show_submit: 1, submit: 0 })
      } else {
        order_m = parseFloat(order_m) - parseFloat(amoney);
        order_m = order_m.toFixed(2);
        th.setData({ [txt]: amoney, [txt2]: order_m, [txt3]: coupon_price, show_submit: 1, submit: 0 })
      }
    } else {
      th.setData({ [txt]: 0, [txt2]: order_m, [txt3]: coupon_price, show_submit: 1, submit: 0 })
    }
    //优惠活动送积分
    if (good.s_intValue) {
      txt = "formData.give_integral";
      th.setData({ [txt]: good.s_intValue });
    }
    //优惠送券
    if (good.s_coupon_id) {
      var i_txt = "formData.give_coupon_id";
      //这个是json格式的
      var i_txt1 = "formData.g_coupon_num";
      var ob = [{ "num": good.s_coupon_num, "c_id": good.s_coupon_id }];
      ob = JSON.stringify(ob);
      th.setData({ [i_txt]: good.s_coupon_id, [i_txt1]: ob });
    }
    //优惠礼包
    if (good.s_libao) {
      var l_txt = "formData.give_lb_id";
      //这个是json格式的
      var l_txt1 = "formData.g_lb_num";
      var ob = [{ "num": good.s_lb_num, "l_id": good.s_libao }];
      ob = JSON.stringify(ob);
      th.setData({ [l_txt]: good.s_libao, [l_txt1]: ob });
    }

    //专享礼包
    if (good.zx_libao) {
      var l_txt = "formData.give_zxlb_id";
      //这个是json格式的
      var l_txt1 = "formData.g_zxlb_num";
      var ob = [{ "num": good.zx_lb_num, "l_id": good.zx_libao }];
      ob = JSON.stringify(ob);
      th.setData({ [l_txt]: good.zx_libao, [l_txt1]: ob });
    }
    //每月礼包
    if (good.month_libao) {
      var l_txt = "formData.give_monthlb_id";
      //这个是json格式的
      var l_txt1 = "formData.g_monthlb_num";
      var ob = [{ "num": good.month_lb_num, "l_id": good.month_libao }];
      ob = JSON.stringify(ob);
      th.setData({ [l_txt]: good.month_libao, [l_txt1]: ob });
    }

    //调用默认优惠券方法
    th.def_coupon_fn()

    // wx.hideLoading();

    //});

  },


  requestSubscribe() {
    const th = this;
    const template_id = this.data.template_id;
    th.sendsm(function () {
      //要检查一下赠品有可以足够
      th.sub_check_gift(function () {
        th.submit_func();
      })
    })
    // wx.getSetting({
    //   withSubscriptions: true,
    //   success(res) {
    //     let itemSettings = res.subscriptionsSetting.itemSettings;
    //     if (itemSettings && itemSettings[template_id] == "accept") {
    //       //要检查一下赠品有可以足够
    //       th.sub_check_gift(function () {
    //         th.submit_func();
    //       })

    //     } else {
    //       th.sendsm(function () {
    //         //要检查一下赠品有可以足够
    //         th.sub_check_gift(function () {
    //           th.submit_func();
    //         })
    //       })
    //     }
    //   }
    // })
    this.setData({
      submit: 1,
    })
  },


  //分配代发商品
  add_df_goods(good, df_goods, whsle_id, room_id) {
    var df_price = parseFloat(good.goods_num * good.goods_price);

    var index = df_goods.findIndex(function (e) {
      return e.whsle_id == whsle_id
    })
    if (index > -1) {
      df_goods[index].df_price += df_price;
      df_goods[index].df_goods.push(good);

      if (room_id) {
        if (!df_goods[index].df_room_ids)
          df_goods[index].df_room_ids = "";
        df_goods[index].df_room_ids += room_id + ",";

      }
      if (getApp().globalData.groupchat_id && getApp().globalData.groupchat_id != 'undefined') {
        df_goods[index].groupchat_id = getApp().globalData.groupchat_id
      }
    } else {
      var e = {
        whsle_id: whsle_id,
        df_price: df_price,
        df_goods: []
      }
      if (room_id) e.df_room_ids = room_id + ','
      if (getApp().globalData.groupchat_id && getApp().globalData.groupchat_id != 'undefined') {
        e.groupchat_id = getApp().globalData.groupchat_id
      }
      e.df_goods.push(good);
      df_goods.push(e);
    }

  },
  async submit_func() {
    let cartlist = this.data.cartlist || [];
    let allarr = []
    let strarr = []
    let cbarr = []
    let cbarr_id = []

    if (cartlist && cartlist.length > 0) {
      for (let index = 0, length = cartlist.length; index < length; index++) {
        let item = cartlist[index].goods;
        if (!item) continue;
        for (let i = 0, leng = item.length; i < leng; i++) {
          if (item[i].prom_type == 7) {
            strarr.push(item[i])
          }
          if (item[i].prom_type != 7 && item[i].goods_prom_type == 7) {
            allarr.push(item[i])
          }
        }
      }
    }

    if (strarr.length > 0) {
      if (allarr.length > 0) {
        allarr.map(item => {
          let aitem = strarr.find(ite => item.goods_prom_id == ite.goods_prom_id)
          if (aitem) {
            strarr.push(item)
          }
        })
      }

      for (let j = 0, length = strarr.length; j < length; j++) {

        let userbuynum = await this.getUserBuyPromNum(strarr[j].goods_prom_id)
        if (strarr[j].act.buy_limit != 0 && userbuynum >= strarr[j].act.buy_limit) {
          cbarr.push(strarr[j].goods_name)
          cbarr_id.push(strarr[j].id)
        }
      }
      if (cbarr.length > 0) {
        let str = cbarr.join()
        wx.showModal({
          title: '提示',
          content: `${str}超出组合购限购次数，将以普通商品购买`,
          success: async (res) => {
            if (res.confirm) {
              //-- 数据的更新 --
              for (let k = 0, length = cbarr_id.length; k < length; k++) {
                let data = {
                  id: cbarr_id[k],
                  selected: 1,
                  store_id: oo.stoid,
                  prom_type: 0,
                  prom_id: 0
                };
                await getApp().request.promisePut("/api/weshop/cart/update", {
                  data: data
                });
              }

              wx.reLaunch({
                url: '/packageE/pages/cart/cart2/cart2',
              })
            } else if (res.cancel) {
              console.log('用户点击取消')
              this.setData({
                submit: 0
              })
            }
          }
        })
      } else {
        this.submit_func2()
      }
    } else {
      this.submit_func2()
    }
  },

  //获取用户活动参与次数
  async getUserBuyPromNum(prom_id) {
    var userInfo = getApp().globalData.userInfo;
    var url = `/api/weshop/ordergoods/getUserBuyPromNum?store_id=${os.stoid}&user_id=${userInfo.user_id}&prom_type=7&prom_id=${prom_id}`;
    let res = await getApp().request.promiseGet(url, {
      data: {}
    });
    let userbuynum = 0
    if (res.data.code == 0 && res.data.data) {
      userbuynum = res.data.data.userbuynum
    }
    return userbuynum
  },

  //--------------------提交订单-----------------------
  async submit_func2() {

    if (this.data.is_summit_ing) return false;
    this.data.is_summit_ing = 1;

    function is_ok_wu_arr(index, name) {
      if (!th.data.wu_arr) return '';
      if (!th.data.wu_arr[index]) return '';
      return th.data.wu_arr[index][name];
    }

    var th = this, pdata = new Array();
    var ff = true;
    //------------立即购买-------------
    if (th.data.is_b_now == 1 && th.data.bn_goods.prom_type != 5) {
      //if ( [0,2].indexOf(th.data.bn_exp_type)>-1 && th.data.user_addr == null) {
      if (getApp().is_no_addr(th, th.data.bn_exp_type)) {
        ff = false;
        getApp().my_warnning("请选择收货地址", 0, th);
        th.data.is_summit_ing = 0;
      }
      if (!ff) return false;
      var addr = th.data.user_addr;
      if (th.data.bn_exp_type == 1) addr = null;
      if (th.data.bn_exp_type == 0)
        if (th.data.wu_arr == null || th.data.wu_arr.length <= 0) {
          getApp().my_warnning("读取物流失败", 0, th);
          th.data.is_summit_ing = 0;
          th.setData({
            submit: 0
          })
          return false;
        }


      var item = {
        'user_id': to.globalData.user_id,
        'consignee': addr == null ? "" : addr.consignee,
        'province': addr == null ? 0 : addr.province,
        'city': addr == null ? 0 : addr.city,
        'district': addr == null ? 0 : addr.district,
        'twon': addr == null ? 0 : addr.twon,
        'address': addr == null ? "" : addr.address,
        'more_address': addr == null ? "" : addr.more_address,
        //'mobile': th.data.userinfo.mobile,
        'mobile': addr == null ? th.data.userinfo.mobile : addr.mobile,
        'email': '',
        'shipping_code': th.data.bn_exp_type == 1 ? 0 : is_ok_wu_arr(th.data.index, 'code'),
        'shipping_name': th.data.bn_exp_type == 1 ? '' : is_ok_wu_arr(th.data.index, 'name'),
        'invoice_title': '',
        'goods_price': parseFloat(th.data.formData.all_price).toFixed(2),           //商品总价
        'shipping_price': parseFloat(th.data.formData.shipping_price).toFixed(2), //物流金额
        'user_money': parseFloat(th.data.formData.user_money).toFixed(2),         //使用余额
        'total_amount': parseFloat(th.data.formData.total_amount).toFixed(2),     //订单总价
        'order_amount': parseFloat(th.data.formData.order_amount).toFixed(2),     //应付
        'user_note': th.data.user_note['0'] ? th.data.user_note['0'] : "",             //用户备注
        'store_id': oo.stoid,                //商家
        'pickup_id': th.data.bn_pick,       //门店
        'exp_type': th.data.bn_exp_type,    //配送方式
        'order_goods': new Array(),
      };

      //是不是重新提交
      if (th.data.is_continue == 1) item.is_continue = 1;

      //-- 如果有使用佣金抵扣的话 --
      if (th.data.bn_use_commission) {
        item.use_commission = th.data.bn_goods.use_commission;
      }

      if (item.exp_type == 2) {
        item.lon = th.data.lon ? th.data.lon : 0;
        item.lat = th.data.lat ? th.data.lat : 0;
        item.goods_weight = th.data.bn_gd_w;
        item.samecity_order_amount = th.data.bn_samecity_order_amount;
      }

      //获取立即购买的商品的信息
      var gg = to.get_b_now();
      //--商品的房间号--
      if (gg.room_id && gg.room_id > 0) {
        item.room_ids = gg.room_id;
      }
      //群id
      if (gg.groupchat_id && gg.groupchat_id != 'undefined') {
        item.groupchat_ids = gg.groupchat_id;
      }
      var order_prom_list = {};
      //--判断有没有优惠活动--
      if (th.data.formData.order_prom_amount > 0) {
        order_prom_list.order_prom_id = th.data.formData.order_prom_id;
        order_prom_list.order_prom_amount = th.data.formData.order_prom_amount;
      }


      //--判断优惠活动的提交--
      if (th.data.formData.cut_price > 0) {
        order_prom_list.discount_amount = th.data.formData.cut_price.toFixed(2);
        var ob = [{
          "prom_id": th.data.bn_goods.prom_id,
          "dis": parseFloat(th.data.formData.cut_price).toFixed(2),
          "ispt": 0
        }]
        order_prom_list.prom_pt_json = JSON.stringify(ob);
      }
      if (th.data.formData.give_integral > 0) {
        order_prom_list.give_integral = th.data.formData.give_integral;
      }
      if (th.data.formData.give_coupon_id > 0) {
        order_prom_list.give_coupon_id = th.data.formData.give_coupon_id;
        order_prom_list.g_coupon_num = th.data.formData.g_coupon_num;
      }
      if (th.data.formData.give_lb_id > 0) {
        order_prom_list.give_lb_id = th.data.formData.give_lb_id;
        order_prom_list.g_lb_num = th.data.formData.g_lb_num;
      }
      //--- 专享礼包 ---
      if (th.data.formData.give_zxlb_id > 0) {
        order_prom_list.give_zxlb_id = th.data.formData.give_zxlb_id;
        order_prom_list.g_zxlb_num = th.data.formData.g_zxlb_num;
      }
      //--- 每月礼包 ---
      if (th.data.formData.give_monthlb_id > 0) {
        order_prom_list.give_monthlb_id = th.data.formData.give_monthlb_id;
        order_prom_list.g_monthlb_num = th.data.formData.g_monthlb_num;
        // order_prom_list.g_monthlb_num = [{ "num": good.month_lb_num, "l_id": th.data.formData.month_libao_id }];
      }

      item.order_prom_list = order_prom_list;

      //组装优惠券的钱
      if (parseFloat(th.data.formData.coupon_price) > 0) {
        item.coupon_price = th.data.formData.coupon_price;
        item.coupon_no = th.data.using_quan[th.data.bn_pick].coupon_no;
      }
      if (th.data.using_quan[th.data.bn_pick] && th.data.using_quan[th.data.bn_pick].coupon_no && th.data.using_quan[th.data.bn_pick].isby) {
        item.coupon_no = th.data.using_quan[th.data.bn_pick].coupon_no;
        item.coupon_price = 0;
      }

      //老会员成为分销下线需要的参数
      if (getApp().globalData.first_leader && !getApp().globalData.userInfo.first_leader) {
        //判断一下分享人是不是分享商
        await app.request.promiseGet("/api/weshop/users/get/" + os.stoid + "/" + getApp().globalData.first_leader, {}).then(res => {
          if (res.data.code == 0) {
            var user = res.data.data;
            if (user.is_distribut == 1) {
              item.first_leader = parseInt(getApp().globalData.first_leader);
            }
          }
        })
      }


      var goods = {
        'goods_id': gg.goods_id,
        'goods_name': gg.goods_name,
        'goods_sn': gg.goods_sn,
        'goods_num': gg.goods_num,
        'market_price': th.data.bn_goods.market_price,
        'goods_price': th.data.bn_goods.shop_price,
        'member_goods_price': th.data.bn_goods.shop_price,
        'store_id': oo.stoid,
        'prom_type': th.data.bn_goods.prom_type,  //促销活动类型
        'prom_id': th.data.bn_goods.prom_id,     //促销活动id
      };

      //如果有参与非实收的订单促销，那么就相当于是普通购买
      if (th.data.can_use_ord_prom[th.data.bn_pick]) {
        goods.is_pd_normal = 1;
        goods.discount_field = th.data.show_ord_prom[th.data.bn_pick];

        //如果是指定门店，就要判断
        if (th.data.bn_goods.pick_group_ids) {
          var idx0 = th.data.bn_goods.pick_up_lists.findIndex(function (e) {
            return e.pickup_id == th.data.bn_pick;
          })
          if (idx0 < 0) {
            getApp().my_warnning(th.data.bn_goods.goods_name + "的门店不可售", 0, th);
            th.data.is_summit_ing = 0;
            th.setData({
              submit: 0
            })
            return false;
          }
        }
      }



      if (th.data.bn_goods.whsle_id) {
        item.is_whsle = 1;
        item.whsle_id = th.data.bn_goods.whsle_id;
        goods.is_whsle_goods = 1;
      }

      if (getApp().globalData.skinface_id) {
        goods.skinface_id = getApp().globalData.skinface_id;
      }

      //-- 把导购的信息填入--
      if (gg.guide_id) {
        goods.guide_id = gg.guide_id;
        goods.guide_type = gg.guide_type;
        //调用接口判断是不是会员
        await getApp().request.promiseGet("/api/weshop/shoppingGuide/getId/" + oo.stoid + "/" + gg.guide_id, {}).then(res => {
          if (res.data.code == 0) {
            goods.guide_name = res.data.data.salesman;
            goods.guide_sn = res.data.data.salesman_no;
          }
        })
      }
      if (gg.groupchat_id && gg.groupchat_id != 'undefined') {
        goods.groupchat_id = gg.groupchat_id
      }

      //--商品的房间号--
      if (gg.room_id && gg.room_id > 0) {
        goods.room_id = gg.room_id;
      }

      //积分购，先要带is_integral_normal=1
      if (gg.is_integral_normal) {
        goods.is_integral_normal = 1; item.is_normal = 1;
      }

      //先要带is_pd_normal=1
      if (gg.is_pd_normal) {
        goods.is_pd_normal = 1; item.is_normal = 1;
      }


      var act = await getApp().get_has_cx_act(th.data.bn_goods.goods_id);
      var mo_num = getApp().get_limit_qty(th.data.bn_goods, act.length);
      var steep = getApp().get_limit_qty(th.data.bn_goods, act.length, 1);

      if ([0, 3, 5, 7, 10].indexOf(goods.prom_type) > -1) {
        if (mo_num > goods.goods_num) {
          getApp().confirmBox(goods.goods_name + "的未达到起订数量");
          th.data.is_summit_ing = 0;
          th.setData({
            submit: 0
          })
          return false;
        }
        if (steep > 1 && (goods.goods_num - mo_num) % steep != 0) {
          getApp().confirmBox(goods.goods_name + "的购买的数量不是起订量的倍数");
          th.data.is_summit_ing = 0;
          th.setData({
            submit: 0
          })
          return false;
        }
      }

      //如果不立即购买或者秒杀，如果是线下库存购买的时候
      if (goods.prom_type != 1 && goods.prom_type != 6 && goods.prom_type != 2
        && th.data.sales_rules >= 2 && !th.data.bn_goods.whsle_id && !getApp().is_virtual(th.data.bn_goods)) {
        var isok = 1;

        await th.check_store_num(goods.goods_id, th.data.bn_pick, gg.goods_num, function (res) {
          isok = res;
        });
        if (!isok) {
          getApp().confirmBox("商品的门店库存不足");
          th.data.is_summit_ing = 0;
          th.setData({
            submit: 0
          })
          return false;
        }
      }


      //-- 如果有线下取价的话 --
      if (th.data.bn_goods.is_offline) {
        item.sum_offline_cut = (th.data.bn_goods.shop_price - th.data.bn_goods.offline_price).toFixed(2);
        goods.offline_cut = item.sum_offline_cut;
        goods.pricing_type = th.data.bn_goods.pricing_type;
        goods.goods_price = th.data.bn_goods.offline_price;
        goods.member_goods_price = th.data.bn_goods.offline_price;
      }

      //---  如果有优惠促销的金额，要把金额先平摊下去 ---
      if (th.data.formData.cut_price > 0 && !th.data.ispt_goods) {
        var g_arr = new Array();
        g_arr.push(goods);
        var pt_data = {
          'prom_id': goods.prom_id,
          'dis': parseFloat(th.data.formData.cut_price),
          'goods': g_arr,
        }

        var pt_res = null;
        await getApp().request.promisePost("/api/weshop/order/getGoodsSplit", {
          is_json: 1,
          data: pt_data
        }).then(res => {
          if (res.data.code == 0) {
            pt_res = res.data.data;
          }
        })

        if (pt_res) {
          //平摊赋值
          goods.account = pt_res[0].fisrt_account || 0;
          goods.account_yu = pt_res[0].fisrt_account_yu || 0;
          item.is_discount_amount = 1;
        }
      }

      //--组装优惠券的钱--
      if (th.data.formData.coupon_price) {
        item.coupon_price = th.data.formData.coupon_price;
        item.coupon_no = th.data.using_quan[th.data.bn_pick].coupon_no;
        goods.quan_num = th.data.formData.coupon_price;
        goods.quan_no = item.coupon_no;
      }

      item.order_goods.push(goods);

      //--如果有赠品的时候，赠品也要提交---
      if (th.data.buy_now_gift_goods) {
        var gift_gg_arr = th.data.buy_now_gift_goods;
        for (let i in gift_gg_arr) {
          let gift_gg = gift_gg_arr[i];
          var g_goods = {
            'goods_id': gift_gg.goods_id,
            'goods_name': gift_gg.goods_name,
            'goods_sn': gift_gg.goods_sn,
            'goods_num': gift_gg.buynum,
            'market_price': gift_gg.market_price,
            'goods_price': 0,
            'member_goods_price': 0,
            'store_id': oo.stoid,
            'is_gift': 1,
            'gift_id': gift_gg.gift_id,
            'prom_id': gift_gg.prom_id,
          };
          //-- 把导购的信息填入--
          if (gg.guide_id) {
            g_goods.guide_id = gg.guide_id;
            g_goods.guide_type = gg.guide_type;
            //调用接口判断是不是会员
            await getApp().request.promiseGet("/api/weshop/shoppingGuide/getId/" + oo.stoid + "/" + gg.guide_id, {}).then(res => {
              if (res.data.code == 0) {
                g_goods.guide_name = res.data.data.salesman;
                g_goods.guide_sn = res.data.data.salesman_no;
              }
            })
          }
          if (gg.groupchat_id && gg.groupchat_id != 'undefined') {
            g_goods.groupchat_id = gg.groupchat_id;
          }
          item.order_goods.push(g_goods);

        }

      }
      pdata.push(item);
    } else {

      //---------购物车的结算---------
      if (th.data.is_all_zt == 0 && th.data.user_addr == null) {
        th.data.is_summit_ing = 0;
        ff = false;
        getApp().confirmBox("请新建收货地址");
        th.setData({ submit: 0 })
      }
      if (!ff) return false;

      var addr = th.data.user_addr;
      // 自提，地址数据清空 exp_type设置为1
      if (th.data.is_all_zt == 1) addr = null;
      var val_arr = th.data.user_note;

      var order_prom_list_cart = th.data.order_prom_list_cart;

      //优惠商品限购的优化
      var yh_lm_map = {};
      //--组装推送数据--
      for (var i = 0; i < order_prom_list_cart.length; i++) {
        var t_item = order_prom_list_cart[i];

        if (t_item.exp_type == 0) {
          if (th.data.wu_arr == null || th.data.wu_arr.length <= 0) {
            th.data.is_summit_ing = 0;
            getApp().confirmBox("读取物流失败");
            th.setData({
              submit: 0
            })
            return false;
          }
        }

        var item = {
          "keyid": t_item.sto ? t_item.sto.keyid : '',
          'user_id': to.globalData.user_id,
          'consignee': addr == null ? th.data.userinfo.mobile : addr.consignee,
          'province': addr == null ? 0 : addr.province,
          'city': addr == null ? 0 : addr.city,
          'district': addr == null ? 0 : addr.district,
          'twon': addr == null ? 0 : addr.twon,
          'address': addr == null ? "" : addr.address,
          'more_address': addr == null ? "" : addr.more_address,
          'mobile': addr == null ? th.data.userinfo.mobile : addr.mobile,
          'email': '',
          'shipping_code': th.data.is_all_zt == 1 ? 0 : is_ok_wu_arr(t_item.wind, 'code'),
          'shipping_name': th.data.is_all_zt == 1 ? '' : is_ok_wu_arr(t_item.wind, 'name'),
          'invoice_title': '',
          'goods_price': parseFloat(t_item.goods_price).toFixed(2),       //商品总价
          'shipping_price': parseFloat(t_item.shipping_price).toFixed(2), //物流金额
          'user_money': parseFloat(t_item.user_money).toFixed(2),         //使用余额
          'total_amount': parseFloat(t_item.total_amount).toFixed(2),     //订单总价
          'order_amount': parseFloat(t_item.order_amount).toFixed(2),     //应付
          'user_note': val_arr[i], //用户备注
          'store_id': oo.stoid,                //商家
          'pickup_id': t_item.pickup_id,       //门店
          'exp_type': t_item.exp_type,         //配送方式
          'order_goods': new Array(),
        };
        //是不是重新提交
        if (th.data.is_continue == 1) item.is_continue = 1;
        //----- 如果有线下取价的话 ----
        if (t_item.is_offline == 1) {
          item.sum_offline_cut = t_item.offline_price.toFixed(2);
        }

        //组装优惠券的钱
        if (t_item.coupon_price) {
          item.coupon_price = t_item.coupon_price;
          item.coupon_no = th.data.using_quan[t_item.pickup_id].coupon_no;
        } else if (t_item.quan_no) {
          item.coupon_no = t_item.quan_no;
          item.coupon_price = 0;
        }

        //-- 如果有使用佣金抵扣的话 --
        if (th.data.cart_use_commission) {
          item.use_commission = t_item.can_usecommise;
        }

        if (item.exp_type == 2) {
          item.lon = th.data.lon ? th.data.lon : 0;
          item.lat = th.data.lat ? th.data.lat : 0;
          item.goods_weight = t_item.gd_w;
          item.samecity_order_amount = t_item.samecity_order_amount;
        }

        var order_prom_list = {};
        //--判断有没有优惠活动--
        if (t_item.order_prom_amount > 0) {
          order_prom_list.order_prom_id = t_item.order_prom_id;
          order_prom_list.order_prom_amount = t_item.order_prom_amount;
        }

        order_prom_list.discount_amount = 0;
        //--判断优惠活动的提交--
        if (t_item.cut_price > 0) {
          order_prom_list.discount_amount += t_item.cut_price;
        }
        //--判断组合优惠活动的提交--
        if (t_item.zh_cut_price > 0 || t_item.zh_cut_price < 0) {
          order_prom_list.discount_amount += t_item.zh_cut_price;
          order_prom_list.zh_pt_json = JSON.stringify(t_item.zh_pt_json);
        }

        //--判断阶梯优惠活动的提交--
        if (t_item.ladder_cut_price > 0 || t_item.ladder_cut_price < 0) {
          order_prom_list.discount_amount += t_item.ladder_cut_price;
        }

        if (t_item.prom_pt_json) {
          order_prom_list.prom_pt_json = JSON.stringify(t_item.prom_pt_json);
        }

        if (t_item.s_intValue > 0) {
          order_prom_list.give_integral = t_item.s_intValue;
        }

        if (t_item.s_coupon_id) {
          order_prom_list.give_coupon_id = t_item.s_coupon_id;
          order_prom_list.g_coupon_num = JSON.stringify(t_item.g_coupon_num);
        }
        if (t_item.s_libao) {
          order_prom_list.give_lb_id = t_item.s_libao;
          order_prom_list.g_lb_num = JSON.stringify(t_item.g_lb_num);
        }

        //-- 送专享礼包的时候 --
        if (t_item.zx_libao) {
          order_prom_list.give_zxlb_id = t_item.zx_libao;
          order_prom_list.g_zxlb_num = JSON.stringify(t_item.g_zxlb_num);
        }

        //-- 送每月礼包的时候 --
        if (t_item.monthlibao) {
          order_prom_list.give_monthlb_id = t_item.monthlibao;
          let marr = [];
          if (t_item.g_monthlb_num && t_item.g_monthlb_num.length > 0) {
            t_item.g_monthlb_num.map(ite => {
              let obj = {
                num: ite.monthnum,
                l_id: ite.month_id,
                monthlbtitle: ite.monthlbtitle,
                prom_id: ite.prom_id,
              }
              marr.push(obj)
            })
          }
          order_prom_list.g_monthlb_num = JSON.stringify(marr);
        }

        if (Object.keys(order_prom_list).length > 0) {
          if (order_prom_list.discount_amount)
            order_prom_list.discount_amount = parseFloat(order_prom_list.discount_amount).toFixed(2);
          if (order_prom_list.order_prom_amount)
            order_prom_list.order_prom_amount = parseFloat(order_prom_list.order_prom_amount).toFixed(2);

          item.order_prom_list = order_prom_list;
        }


        //老会员成为分销下线需要的参数
        if (getApp().globalData.first_leader && !getApp().globalData.userInfo.first_leader) {
          //判断一下分享人是不是分享商
          await app.request.promiseGet("/api/weshop/users/get/" + os.stoid + "/" + getApp().globalData.first_leader, {}).then(res => {
            if (res.data.code == 0) {
              var user = res.data.data;
              if (user.is_distribut == 1) {
                item.first_leader = parseInt(getApp().globalData.first_leader);
              }
            }
          })
        }


        //房间号的ids
        var room_ids = "";
        //-- 把券的钱，写入从表,前面已经摊了一次了，不要再摊第二次 ---
        // if (t_item.quan_youhui_list && t_item.coupon_price) {
        //   for (var kk in t_item.quan_youhui_list) {
        //     var you_item = t_item.quan_youhui_list[kk];
        //     //-- 对券的价格进行平摊 --
        //     await th.split_set_goods_quanprice(you_item, t_item);
        //   }
        // }

        //看一下有没有活动不参与的，要记录到order_more表中
        let can_cx = t_item.show_can_cx;
        let is_user_no_yhcx = null;
        for (let iu in can_cx) {
          if (can_cx[iu].no_cj_prom) {

            if (!is_user_no_yhcx) is_user_no_yhcx = [];
            is_user_no_yhcx.push({
              prom_id: can_cx[iu].cur_act.prom_id,
              prom_type: can_cx[iu].cur_act.prom_type,
            })
            break;
          }
        }
        //如果有活动不参与的，要记录到order_more表中
        if (is_user_no_yhcx) {
          item.is_user_no_yhcx = JSON.stringify(is_user_no_yhcx);
        }


        //代发商品的集合
        var df_goods = [];
        var df_price = 0;
        var df_room_ids = "";


        //此单的组合活动汇总
        var zh_map_count = {};
        var check_map = {};
        let groupchat_ids = [];


        //-------------让商品添加到商品列表--------------------
        for (var k = 0; k < t_item.goods.length; k++) {

          console.log("222");
          var g_item = t_item.goods[k];
          if (g_item.goods_num <= 0) continue;
          var goods = {
            'goods_id': g_item.goods_id,
            'goods_name': g_item.goods_name,
            'goods_sn': g_item.goods_sn,
            'goods_num': g_item.goods_num,
            'market_price': g_item.market_price,
            'goods_price': g_item.goods_price,
            'member_goods_price': g_item.goods_price,
            'store_id': oo.stoid,
          };

          //订单促销取价规则使用
          if (g_item.discount_field) {
            goods.discount_field = g_item.discount_field;
            //此时要判断商品的门店是不是匹配
            if (g_item.prom_type == 0 && g_item.pick_group_ids) {
              var idx0 = g_item.pick_up_lists.findIndex(function (e) {
                return e.pickup_id == item.pickup_id;
              })
              if (idx0 < 0) {
                getApp().my_warnning(g_item.goods_name + "的门店不可售", 0, th);
                th.data.is_summit_ing = 0;
                th.setData({
                  submit: 0
                })
                return false;
              }
            }

          }

          if (g_item.is_pd_normal) {
            goods.is_pd_normal = 1;
          }
          if (g_item.is_integral_normal) {
            goods.is_integral_normal = 1;
          }

          if (getApp().globalData.skinface_id) {
            goods.skinface_id = getApp().globalData.skinface_id;
          }

          //-- 线下取价也要写入,组合购的商品不能去线下价格 --
          if (g_item.offline_price && t_item.is_offline == 1 && g_item.prom_type != 7) {
            goods.goods_price = g_item.offline_price;
            goods.member_goods_price = g_item.offline_price;
            goods.offline_cut = (g_item.goods_price - g_item.offline_price).toFixed(2);
            goods.pricing_type = g_item.pricing_type;
          }
          if (g_item.quan_num) {
            goods.quan_num = g_item.quan_num;
            goods.quan_no = g_item.quan_no;
          }

          //如果活动一样，那么商品的活动就要清理成0
          var sh_can_cx = t_item.show_can_cx;
          if (sh_can_cx && !g_item.is_zh_split) {
            for (let kh in sh_can_cx) {
              var cur = sh_can_cx[kh] ? sh_can_cx[kh].cur_act : null;
              if (cur && cur.is_no_ok) {
                //如果活动一样，那么商品的活动就要清理成0
                if (g_item.prom_type == cur.prom_type && g_item.prom_id == cur.prom_id) {
                  g_item.prom_type = 0;
                }
              }
            }
          }

          //--判断活动的类型--
          switch (g_item.prom_type) {
            case 1:
            case 2:
            case 10:
              goods.prom_type = g_item.prom_type;
              goods.prom_id = g_item.prom_id;
              break;
            case 3:

              //判断一个优惠促销商品用户参与的问题
              let grs= await getApp().request.promiseGet("/api/weshop/promgoods/getUser/" + oo.stoid + "/" + g_item.prom_id+"/"+ getApp().globalData.user_id, {});
              if(!grs ||  grs.data.code==-1){
                let error_ts=goods.goods_name + "未找到优惠促销活动";
                if(grs && grs.data.msg.indexOf('无权限')>-1){
                  error_ts=goods.goods_name + "无权限参与优惠促销活动";
                }

                getApp().confirmBox(error_ts);
                th.data.is_summit_ing = 0;
                th.setData({ submit: 0 })
                return false;
              }

              goods.prom_type = 3;
              goods.prom_id = g_item.prom_id;
              if (g_item.is_gift) {
                goods.is_gift = g_item.is_gift;
                goods.gift_id = g_item.gift_id;
              }
              break;
            case 5:
              //看一下有没有搭配商品
              if (th.has_collocation(t_item.goods, g_item.prom_id)) {
                goods.prom_type = 5;
                goods.prom_id = g_item.prom_id;
                if (g_item.is_collocation) {
                  goods.is_collocation = g_item.is_collocation;
                }
              }

              break
            case 7:
              goods.prom_type = 7;
              goods.prom_id = g_item.prom_id;
              zh_map_count[g_item.prom_id] = (zh_map_count[g_item.prom_id] ? zh_map_count[g_item.prom_id] : 0) + goods.goods_num; //汇总一下组合购的活动
              break
            default:
              goods.prom_type = 0;
              goods.prom_id = 0;

          }

          var txt = goods.prom_id + ',' + goods.prom_type + ',' + goods.goods_id + ',' + goods.is_gift;
          //--赠品的时候,阶梯促销会右重复的情况,还有组合购的时候拆分出去的 --
          if (check_map[txt] && goods.prom_type != 10) {
            getApp().confirmBox(goods.goods_name + "计算金额错误，请重新刷新");
            th.setData({ submit: 0 })
            return false;
          } else {
            check_map[txt] = 1;
          }

          goods.prom_type = parseInt(goods.prom_type + '');

          var act = await getApp().get_has_cx_act(g_item.goods_id);
          var mo_num = getApp().get_limit_qty(g_item, act.length);
          var steep = getApp().get_limit_qty(g_item, act.length, 1);

          //赠品要排除之外，不进行判断
          if ([0, 3, 5, 7, 10].indexOf(goods.prom_type) > -1 && !goods.is_gift) {
            if (mo_num > goods.goods_num) {
              getApp().confirmBox(goods.goods_name + "的未达到起订数量");
              th.data.is_summit_ing = 0;
              th.setData({ submit: 0 })
              return false;
            }
            if (steep > 1 && (goods.goods_num - mo_num) % steep != 0) {
              getApp().confirmBox(goods.goods_name + "的购买的数量不是起订量的倍数");
              th.data.is_summit_ing = 0;
              th.setData({ submit: 0 })
              return false;
            }

            //-- 要判断一下优惠促销的商品的限购 --
            if (goods.prom_type == 3) {
              var pro_gd_limit_num = 0;
              var p_limit_rs = await getApp().request.promisePost('/api/weshop/promgoods/getPromGoodsLimitNum', {
                data: {
                  store_id: os.stoid, goods_id: goods.goods_id, prom_id: goods.prom_id, prom_type: 3
                }
              })
              if (p_limit_rs && p_limit_rs.data.code == 0) {
                pro_gd_limit_num = p_limit_rs.data.data
              }
              //-- 如果有商品限购的时候 --
              if (pro_gd_limit_num > 0) {
                //-- 获取会员之前优惠促销商品买了多少件 --
                var pro_by_num = 0;
                var lrs = {
                  store_id: os.stoid, user_id: getApp().globalData.user_id,
                  goods_id: goods.goods_id, prom_type: 3,
                  prom_id: goods.prom_id, isnew: 1
                };
                var gd_limit_rs = await getApp().promiseGet('/api/weshop/ordergoods/getUserBuyGoodsNum', { data: lrs });
                if (gd_limit_rs && gd_limit_rs.data.code == 0) {
                  pro_by_num = gd_limit_rs.data.data.promgoodsbuynum
                }

                var m_ky = goods.goods_id + '|' + goods.prom_id;

                var more_num = yh_lm_map[m_ky] ? yh_lm_map[m_ky] : 0;

                if (pro_gd_limit_num < pro_by_num + goods.goods_num + more_num) {
                  getApp().confirmBox(goods.goods_name + "超优惠促销限购" + pro_gd_limit_num + "件，无法购买");
                  th.data.is_summit_ing = 0;
                  th.setData({ submit: 0 })
                  return false;
                }

                //方便下一轮商品判断限购
                if (!yh_lm_map[m_ky]) {
                  yh_lm_map[m_ky] = 0;
                }
                yh_lm_map[m_ky] += goods.goods_num;
              }
            }

          }

          //如果不立即购买或者秒杀，如果是线下库存购买的时候
          if (!goods.is_gift && [0, 3, 5, 7, 10].indexOf(goods.prom_type) > -1 && th.data.sales_rules >= 2 && !g_item.whsle_id && !getApp().is_virtual(g_item)) {
            var isok = 1;
            await th.check_store_num(goods.goods_id, t_item.pickup_id, goods.goods_num, function (res) {
              isok = res;
            });
            if (!isok) {
              getApp().confirmBox(goods.goods_name + "的门店库存不足");
              th.data.is_summit_ing = 0;
              th.setData({ submit: 0 })
              return false;
            }
          }

          //把优惠的平摊结果写进去
          if (g_item.account >= 0 || (g_item.account_yu != 0 && g_item.account != undefined)) {
            if (g_item.account >= 0) goods.account = g_item.account;
            if (g_item.account_yu != 0) goods.account_yu = g_item.account_yu;
            item.is_discount_amount = 1;
          }

          //导购ID
          if (g_item.guide_id) {
            goods.guide_id = g_item.guide_id;
            goods.guide_type = g_item.guide_type;
            //调用接口判断是不是会员
            await getApp().request.promiseGet("/api/weshop/shoppingGuide/getId/" + oo.stoid + "/" + g_item.guide_id, {}).then(res => {
              if (res.data.code == 0) {
                goods.guide_name = res.data.data.salesman;
                goods.guide_sn = res.data.data.salesman_no;
              }
            })
          }

          if (g_item.groupchat_id && g_item.groupchat_id != 'undefined') {
            goods.groupchat_id = g_item.groupchat_id;
            groupchat_ids.push(g_item.groupchat_id);
          }
          //如果有阶梯促销
          if (g_item.ladder_list_id) {
            goods.ladder_list_id = g_item.ladder_list_id;
          }

          //-- 如果有代发商品，就要开始拆单 --
          if (g_item.whsle_id && t_item.goods.length > 1) {
            df_price += parseFloat(g_item.goods_num * g_item.goods_price);
            goods.is_whsle_goods = 1;
            th.add_df_goods(goods, df_goods, g_item.whsle_id, g_item.room_id);

            //df_goods.push(goods);
            // df_room_ids += g_item.room_id + ",";
          } else {

            //-- 如果只有一件的时候，商品又是代发商品，订单的状态要改成代发订单 --
            if (g_item.whsle_id) {
              goods.is_whsle_goods = 1;
              item.is_whsle = 1;
              item.whsle_id = g_item.whsle_id
            }
            //如果房间号不为空的时候
            if (g_item.room_id) {
              goods.room_id = g_item.room_id;
              room_ids += g_item.room_id + ",";
            }

            item.order_goods.push(goods);

          }
        }


        //-- 如果订单中有组合购,要统计到倍增的情况 ---
        if (Object.keys(zh_map_count).length) {
          var zhlist = [];

          for (var kf in zh_map_count) {

            var zh_act_th = th.data.zhhe_act_map[kf];
            var ite = { zhid: kf, zhnum: 1 };

            if (zh_act_th.is_bz) {
              if (zh_map_count[kf] > zh_act_th.zhbuyqty) {
                ite.zhnum = zh_map_count[kf] / zh_act_th.zhbuyqty;
              }
            }

            zhlist.push(ite);

          }
          item.zhlist = zhlist;
        }

        //如果房间号不为空的时候
        if (room_ids != "") item.room_ids = ut.sub_last(room_ids);
        if (groupchat_ids && groupchat_ids.length > 0) item.groupchat_ids = groupchat_ids.join(',');
        // if (getApp().globalData.groupchat_id) {item.groupchat_id = getApp().globalData.groupchat_id;}
        //处理代发商品的拆分
        if (df_goods.length > 0) {



          item.goods_price = parseFloat(item.goods_price - df_price).toFixed(2);
          item.total_amount = parseFloat(item.total_amount - df_price).toFixed(2);

          for (let j = 0; j < df_goods.length; j++) {

            var df_item = JSON.parse(JSON.stringify(item));

            var ddff_item = df_goods[j];

            df_item.is_whsle = 1;
            df_item.whsle_id = ddff_item.whsle_id;
            df_item.is_discount_amount = 0;
            df_item.goods_price = ddff_item.df_price;
            df_item.total_amount = ddff_item.df_price;
            df_item.shipping_price = 0;   //没有运费
            if (df_item.order_prom_list) df_item.order_prom_list = {};
            if (df_item.coupon_price) delete (df_item.coupon_price);
            if (df_item.coupon_no) delete (df_item.coupon_no);

            //看一下是用余额比较多，还是用钱比较多
            if (item.order_amount > item.user_money) {
              if (item.order_amount > ddff_item.df_price) {
                item.order_amount = parseFloat(item.order_amount - ddff_item.df_price).toFixed(2);
                df_item.order_amount = ddff_item.df_price.toFixed(2);
              } else {
                var more_p = parseFloat(ddff_item.df_price - item.order_amount).toFixed(2);
                item.order_amount = 0;
                item.user_money = parseFloat(item.user_money - more_p).toFixed(2);
                df_item.user_money = more_p;
              }
            } else {

              if (item.user_money > ddff_item.df_price) {
                item.user_money = parseFloat(item.user_money - ddff_item.df_price).toFixed(2);
                df_item.user_money = ddff_item.df_price.toFixed(2);
              } else {
                var more_p = parseFloat(ddff_item.df_price - item.user_money).toFixed(2);
                item.user_money = 0;
                item.order_amount = parseFloat(item.user_money - more_p).toFixed(2);
                df_item.order_amount = more_p;

              }
            }

            if (ddff_item.df_room_ids)
              df_item.room_ids = ut.sub_last(ddff_item.df_room_ids);

            if (getApp().globalData.groupchat_id && getApp().globalData.groupchat_id != 'undefined') {
              df_item.groupchat_ids = getApp().globalData.groupchat_id;
            }
            df_item.order_goods = ddff_item.df_goods;
            pdata.push(df_item);
          }


        }
        //如果只有代发商品的时候
        if (item.order_goods.length > 0) {
          //item.order_goods=df_goods;
          //item.is_whsle=1;
          pdata.push(item);
        }

      }

    }

    if (pdata.length == 0) return;
    //如果有使用预存，要处理
    if (th.data.formData && th.data.formData.prestore * 1 > 0) {
      let formData = th.data.formData
      let pre_json = formData.pre_json
      let all_yck_arr = formData.all_yck_arr
      pdata.map((item, i) => {
        item.pre_cut = all_yck_arr[i] ? all_yck_arr[i].toFixed(2) : 0
        item.pre_preferential = 0
        item.pre_json = pre_json[i] ? JSON.stringify(pre_json[i]) : ''
      })
    }


    if (!pdata.keyid && th.data.bn_goods) {
      pdata.map(ite => {
        ite.keyid = th.data.bn_goods.keyid
      })
      // pdata.keyid = th.data.bn_goods.keyid
    }
    var str = JSON.stringify(pdata);

    console.log("--str--");
    console.log(str);

    wx.showLoading({ title: "加载中" });
    th.setData({ submit: 1, })

    getApp().request.promisePost("/api/weshop/order/createWxdOrder", {
      data: pdata,is_json:1,is_normal:1
    }).then(res => {
        wx.hideLoading();

        if (res.statusCode == 200) {
          var data = res.data;
          if (data.code == 0) {
            th.setData({ submit: 1, })
            //如果是购物车结算，还要删除购物车
            if (th.data.is_b_now == 0) {
              console.log(th.data.cartlist_y);
              var list = JSON.parse(JSON.stringify(th.data.cartlist_y));
              for (var i = 0; i < list.length; i++) {
                //删除购物车
                a.delete("/api/weshop/cart/del/" + oo.stoid + "/" + list[i].id, {});
              }
            }
            var order_amount = 0;
            pdata.forEach(function (em, ind) {
              order_amount += parseFloat(em.order_amount);
            })

            //要进行判断，如果是用微信支付，就要跳转到支付界面
            if (order_amount > 0) {
              th.setData({ isclose: 0 });
              //void e.jumpToCart4({
              //  order_sn: data.data,
              //}, 1);

              th.data.ok_order_sn = data.data;
              util_pay.pay(data.data, async function () {
                //app.my_warnning("支付成功",1,th);
                //setTimeout(function () {
                // if (th.data.formData && th.data.formData.prestore * 1 > 0) {  //有使用预存的处理
                //   let length = pdata.length
                //   wx.showLoading({ title: "加载中", mask: true });
                //   for (let yi = 0; yi < length; yi++) {
                //     await th.setAdvancesum(pdata[yi], data.data)
                //   }
                //   wx.hideLoading()
                //   wx.redirectTo({
                //     url: "/packageG/pages/payment/pay_success/pay_success?type=2&order_sn=" + data.data
                //   })
                // } else {
                //   wx.redirectTo({
                //     url: "/packageG/pages/payment/pay_success/pay_success?type=2&order_sn=" + data.data
                //   })
                // }
                wx.redirectTo({
                  url: "/packageG/pages/payment/pay_success/pay_success?type=2&order_sn=" + data.data
                })
                //},1000)

              }, function () {

                // return false;
                //支付失败
                setTimeout(function () {
                  getApp().re_to("/pages/user/order_list/order_list");
                }, 1000)
              }, oo.stoid);

            } else {
              var dd = {
                parent_sn: data.data,
                store_id: oo.stoid,
                type: 2,
              };
              a.post("/api/weshop/order/pay/createOrder", {
                data: dd,
                success: async function (t) {
                  console.log(t);
                  if (t.data.code == 0) {
                    //app.my_warnning("支付成功",1,th);
                    //setTimeout(function () {
                    // if (th.data.formData && th.data.formData.prestore * 1 > 0) {  //有使用预存的处理
                    //   let length = pdata.length
                    //   wx.showLoading({ title: "加载中", mask: true });
                    //   for (let yi = 0; yi < length; yi++) {
                    //     await th.setAdvancesum(pdata[yi], data.data)
                    //   }
                    //   wx.hideLoading()
                    //   th.setData({ isclose: 0 });
                    //   wx.redirectTo({
                    //     url: "/packageG/pages/payment/pay_success/pay_success?type=2&order_sn=" + data.data,
                    //   })
                    // } else {
                    //   th.setData({ isclose: 0 });
                    //   wx.redirectTo({
                    //     url: "/packageG/pages/payment/pay_success/pay_success?type=2&order_sn=" + data.data,
                    //   })
                    // }
                    th.setData({ isclose: 0 });
                    wx.redirectTo({
                      url: "/packageG/pages/payment/pay_success/pay_success?type=2&order_sn=" + data.data,
                    })
                    //}, 1000)
                  }
                },
                fail: function () {

                }
              });
            }

          }
          else {
            //--内容换行--
            var msg = data.msg;
            //赠品活动已经取消，无法赠送，是否继续买单？
            if (msg.indexOf("是否继续买单") > 0) {
              wx.showModal({
                title: "提示",
                content: data.msg,
                cancelText: '取消',
                confirmText: '确定',
                showCancel: true,
                success(res) {
                  if (res.cancel) {
                    return;
                  } else if (res.confirm) {
                    th.data.is_continue = 1;
                    th.data.is_summit_ing = 0;  //是否提交中
                    th.submit_func();
                  }
                }
              })
              return;
            } else {
              if (msg.length > 13) {
                msg = msg.slice(0, 13) + "\r\n" + msg.slice(13);
              }
              getApp().confirmBox(msg);
              th.data.is_summit_ing = 0;  //是否提交中
              th.setData({
                submit: 0,
              })
              if (data.code == -2) {


                //-- 如果是购物车结算，还要删除购物车 --
                if (th.data.is_b_now == 0) {
                  console.log(th.data.cartlist_y);
                  var list = JSON.parse(JSON.stringify(th.data.cartlist_y));
                  for (var i = 0; i < list.length; i++) {
                    //删除购物车
                    a.delete("/api/weshop/cart/del/" + oo.stoid + "/" + list[i].id, {});
                  }
                }

                setTimeout(() => {
                  getApp().re_to('/pages/user/order_list/order_list')
                }, 1300)

              }

            }


          }
        } else {
          th.data.is_summit_ing = 0;  //是否提交中
          console.log("index.js wx.request CheckCallUser statusCode" + res.statusCode);
          th.setData({
            submit: 0,
          })
        }

    }).catch(function(err) {
      th.data.is_summit_ing = 0;
      wx.hideLoading();
      console.log("index.js wx.request CheckCallUser fail");
      th.setData({
        submit: 0,
      })
    })


  },
  //看一下有没有选择搭配的商品
  has_collocation(goods, prom_id) {
    var idx = goods.findIndex(function (e) {
      return e.prom_type == 5 && e.prom_id == prom_id && e.is_collocation;
    })
    return idx > 0;
  },

  //---确认线下门店的数量足不足---
  async check_store_num(goods_id, pick, goods_num, func) {
    var lock = 0, pick_no, plist, erpwareid;

    var lock_rq = { store_id: os.stoid, wareId: goods_id, storageId: pick, pageSize: 1000 };
    if (this.data.sales_rules == 3) {
      lock_rq.appoint_pick_keyid = this.data.appoint_pick_keyid;
      delete lock_rq.storageId
    }
    //先读取门店的lock
    await getApp().request.promiseGet("/api/weshop/order/ware/lock/page", {
      data: lock_rq
    }).then(res => {
      if (res.data.code == 0 && res.data.data.total > 0) {
        for (var i in res.data.data.pageData)
          lock += res.data.data.pageData[i].outQty;
      }
    })

    if (this.data.sales_rules == 2) {
      //先获取门店的编号
      await getApp().request.promiseGet("/api/weshop/pickup/get/" + os.stoid + "/" + pick, {
        //data: { storeId: os.stoid, goodsId: t.goods_id, pickupId: pick }
      }).then(res => {
        if (res.data.code == 0) {
          pick_no = res.data.data.pickup_no;
        }
      })
    }

    //先获取商品的线下库存
    await getApp().request.promiseGet("/api/weshop/goods/get/" + os.stoid + "/" + goods_id, {
      //data: { storeId: os.stoid, goodsId: t.goods_id, pickupId: pick }
    }).then(res => {
      if (res.data.code == 0) {
        erpwareid = res.data.data.erpwareid;
      }
    })


    var sto_rq = { storageNos: pick_no, wareIds: encodeURIComponent(erpwareid), storeId: os.stoid, pageSize: 2000 };
    if (this.data.sales_rules == 3) {
      sto_rq.storageIds = this.data.appoint_pick_keyid;
      delete sto_rq.storageNos
    }

    //读取线下的门店库存
    await getApp().request.promiseGet("/api/weshop/goods/getWareStorages", {
      data: sto_rq
    }).then(res => {
      if (res.data.code == 0) {
        plist = res.data.data.pageData[0];
      }
    })

    var isok = 1;
    if (!plist || goods_num > plist.CanOutQty - lock) {
      isok = 0;
    }
    func(isok);
  },

  useCoupon: function () {
    if (this.data.order.couponNum <= 0) {
      getApp().my_warnning("无可用优惠券", 0, this);
      return;
    }

    var a = {
      lid: this.data.coupon ? this.data.coupon.id : "0"
    };
    wx.navigateTo({
      url: "/pages/user/checkcoupon/checkcoupon?" + s.Obj2Str(a)
    });
  },
  enterAddressPage: function () {
    getApp().globalData.is_cart_old = 1;
    this.data.isget_by_quan = {};
    this.data.enterAddressPage = !0, wx.navigateTo({
      url: "/packageF/pages/user/address_list/address_list"
    });
  },

  //--------购物车购买时，选择自提和物流-----------
  setexptype_w: function (t) {

    var def_exp_code = getApp().globalData.userInfo.def_exp_code, th = this;
    var ty = t.currentTarget.dataset.t, txt = t.currentTarget.dataset.txt,
      wl_txt = t.currentTarget.dataset.wl_txt,
      ont = t.currentTarget.dataset.ont;

    th.setData({ [txt]: ty });
    var iszt = 1;

    if (ty == 0) {
      th.setData({ is_all_zt: 0 });
    } else {
      for (var i = 0; i < th.data.cartlist.length; i++) {
        var item = th.data.cartlist[i];
        if (item.exp_type == 0 || item.exp_type == 2) {
          iszt = 0;
          break;
        }
      }

      th.setData({ is_all_zt: iszt });

      var ind = t.currentTarget.dataset.ind;
      var c_item = th.data.cartlist[ind];
      var pickid = c_item.pickup_id;

      if (th.data.using_quan[pickid] && th.data.using_quan[pickid].isby == 1) {
        th.data.using_quan[pickid] = {};
        th.setData({ using_quan: th.data.using_quan });
      }


    }
    //判断有没有默认的物流地址值
    if (def_exp_code != "" && def_exp_code != null && def_exp_code != undefined && !th.data.is_default_logistics && !th.data.get_exp_ing) {
      th.data.get_exp_ing = 1;
      var wu_arr = this.data.wu_arr;
      if (wu_arr != null && wu_arr != "") {
        for (var i = 0; i < wu_arr.length; i++) {
          if (wu_arr[i].shipping_code == def_exp_code) {
            var set_txt = "cartlist"
            th.setData({ wl_txt: i });
          }
        }
      }
    }
    //----计算此时购物车的价格----
    th.calculatePrice();
  },

  //--------立即购买时，选择自提和物流----------
  setexptype: function (t) {
    var th = this;
    var ty = t.currentTarget.dataset.t, def_exp_code = getApp().globalData.userInfo.def_exp_code;
    th.setData({ bn_exp_type: ty });
    if (ty == 0) {
      th.setData({ is_all_zt: 0 });
    }

    //当物流为空的时候。
    if (ty == 0 && th.data.wu_arr == null) {
      th.data.isget_by_quan = {};
      return th.get_wuliu(th.calculatePrice2());
    }

    //--自提就要把包邮券清理掉--
    if (ty == 1) {
      th.data.isget_by_quan = {};
      if (th.data.using_quan[th.data.bn_pick] && th.data.using_quan[th.data.bn_pick].isby == 1) {
        th.setData({ using_quan: {} });
      }
    }

    //判断有没有默认的物流地址值
    if (def_exp_code != "" && def_exp_code != null && def_exp_code != undefined && !th.data.is_default_logistics && !th.data.get_exp_ing) {
      th.data.get_exp_ing = 1;
      var wu_arr = this.data.wu_arr;
      if (wu_arr != null && wu_arr != "") {
        for (var i = 0; i < wu_arr.length; i++) {
          if (wu_arr[i].shipping_code == def_exp_code) {
            th.setData({ index: i });
          }
        }
      }
    }
    th.calculatePrice2()

  },

  //--------立即购买时，使用余额--------
  set_bn_useyuer: function () {
    var th = this;
    th.setData({ bn_use_money: !th.data.bn_use_money });
    th.calculatePrice2();
  },

  //立即购买的时候，使用余额
  set_bn_commission: function () {
    var th = this;
    th.setData({ bn_use_commission: !th.data.bn_use_commission });
    th.calculatePrice2();
  },
  //加入购物车使用余额
  set_cart_commission: function () {
    var th = this;
    th.setData({ cart_use_commission: !th.data.cart_use_commission });
    th.calculatePrice();
  },

  set_js_useyuer: function () {
    var th = this;
    th.setData({ js_use_money: !th.data.js_use_money });
    th.calculatePrice();
  },


  //----------立即购买，选择物流-------------
  bindPickerChange: function (e) {
    var ind = e.detail.value
    this.setData({ index: ind });
    this.calculatePrice2();
  },
  //----------购物车结算，选择物流-------------
  bindPickerChange_w: function (e) {
    var ind = e.detail.value, txt = e.currentTarget.dataset.txt;
    this.setData({ [txt]: ind });
    this.calculatePrice();
  },

  /*----券的所有操作----*/
  open_coupon_list: function (e) {
    var th = this;
    var pickid = e.currentTarget.dataset.pickid;
    var bn = e.currentTarget.dataset.bn;
    var cindx = e.currentTarget.dataset.cind;
    var get_by_quan_list_cart = th.data.get_by_quan_list_cart[pickid];


    if (bn == 1) {
      th.setData({ open_quan: 1, selected_quan_pick: pickid, disabled: 1 });
    } else {
      //---多单打开券的时候，就要判断券在其他门店是否有使用---
      var quanlist = th.data.cartlist[cindx].quan_list;
      var exp_type = th.data.cartlist[cindx].exp_type;


      //对于在其他门店已经选择了的券 要判断是否显示到界面
      var t_user = th.data.using_quan[pickid];

      for (var i in quanlist) {
        quanlist[i].is_using = th.check_in_sele(quanlist[i].CashRepNo, pickid);
        if (t_user && quanlist[i].CashRepNo == t_user.coupon_no)
          quanlist[i].show_red = 1;
        else
          quanlist[i].show_red = 0;
      }

      if (get_by_quan_list_cart) {
        for (var i in get_by_quan_list_cart) {
          get_by_quan_list_cart[i].is_using = th.check_in_sele(get_by_quan_list_cart[i].no, pickid);
          if (t_user && get_by_quan_list_cart[i].no == t_user.coupon_no)
            get_by_quan_list_cart[i].show_red = 1;
          else
            get_by_quan_list_cart[i].show_red = 0;
        }
        th.setData({ by_quan_list_cart: get_by_quan_list_cart });
      } else {
        th.setData({ by_quan_list_cart: null });
      }

      console.log("2222222券的列表", quanlist);
      th.setData({
        sele_cart_ind: cindx,
        sele_exp_type: exp_type,
        open_quan: 1,
        selected_quan_pick: pickid,
        selected_quan_list: quanlist,
        disabled: 1
      });
    }
  },
  close_coupon: function (e) {
    var th = this;
    th.setData({ open_quan: 0, disabled: 0 });
  },

  //---判断券时候在已经选择的列表中---
  check_in_sele: function (no, pick_id) {
    var th = this;
    if (th.data.using_quan.length <= 0) return false;
    for (var i in th.data.using_quan) {
      //--如果键值等于本身就要跳出--
      if (parseInt(i) == parseInt(pick_id)) continue;
      var item = th.data.using_quan[i];
      if (item.coupon_no == no) {
        return true;
      }
    }
    return false;
  },

  /*--点击选择券--*/
  sele_quan_item_befor: async function (e) {

    // var ind = e.currentTarget.dataset.ind;
    var ind = 0;
    var quan_item = this.data.selected_quan_list[ind];
    var pickid = this.data.selected_quan_pick;  //现在选择的是哪一个门店
    //--如果券是单品使用的时候--
    if (quan_item && quan_item.UseObjectType && quan_item.UseObjectType == "20") {
      //---只有多件购买的时候才要计算，//购物车购买和搭配勾的时候---
      var gg = getApp().get_b_now();
      if (this.data.is_b_now == 0 || gg.prom_type == 5) {
        var arr = this.data.order_prom_list_cart;
        var t_pk_item = null;
        for (var ii in arr) {
          var ep = arr[ii];
          if (pickid == ep.pickup_id) {
            t_pk_item = ep;
            break;
          }
        }
        //--寻找券指定的商品--
        var gd = null;
        if (t_pk_item) {
          var goods = t_pk_item.goods;
          for (var gid in goods) {
            if (quan_item.UseObjectID == goods[gid].erpwareid) {
              gd = goods[gid];
            }
          }
        }
        if (!gd) {
          // getApp().my_warnning("未找到指定商品使用", 0, this, 600);
          return false;
        }
        //计算价格，如果有平摊的实收要计算实收的金额
        var item_price = gd.goods_price * gd.goods_num;
        //-- 如果有平摊下去，有实收价格的时候，就要用account_fir来计算价格 --
        if (gd.account_fir != null && gd.account_fir != undefined) {
          item_price = gd.account_fir * gd.goods_num;
        }

        if (item_price < parseFloat(quan_item.BuySum)) {
          // getApp().my_warnning("该单品金额没有大于等于" + quan_item.BuySum + "元时不能使用优惠券", 0, this, 600);
          return false;
        }
      }
    }

    // var no_use = e.currentTarget.dataset.no, quanlist = this.data.selected_quan_list;
    var quanlist = this.data.selected_quan_list;
    //---所有的券的显示红色选择都清理一遍---
    for (var i in quanlist) {
      quanlist[i].show_red = 0;
    }
    this.setData({ selected_quan_list: quanlist });
    var by_quanlist = this.data.get_by_quan_list;
    if (by_quanlist) {
      //---所有的券的显示红色选择都清理一遍---
      for (var inb in by_quanlist) {
        by_quanlist[inb].show_red = 0;
      }
      this.setData({ get_by_quan_list: by_quanlist });
    }

    var by_cart_list = this.data.by_quan_list_cart;
    if (by_cart_list) {
      //---所有的券的显示红色选择都清理一遍---
      for (var inc in by_cart_list) {
        by_cart_list[inc].show_red = 0;
      }
      this.setData({ by_quan_list_cart: by_cart_list });
    }

    var using_quan = this.data.using_quan;
    var th = this;
    //---如果是不使用优惠券---
    // if (no_use == 1) {
    //   console.log("有进来吗券", no_use);
    //   if (using_quan[th.data.selected_quan_pick]) {
    //     using_quan[th.data.selected_quan_pick].is_nouse_red = 1;
    //   }
    //   else {
    //     using_quan[th.data.selected_quan_pick] = { is_nouse_red: 1 };
    //   }
    //   this.setData({ using_quan: using_quan, is_coupon: th.is_coupon });
    //   return;
    // }


    var txt = "selected_quan_list[" + ind + "].show_red";
    var obj = {};
    obj[txt] = 1;
    if (quan_item.show_red) {
      obj[txt] = 0;
    }
    this.setData(obj);
    console.log(this.data.selected_quan_list, "选中的券的下标", quan_item, "数据都在这里", txt);
    if (using_quan[th.data.selected_quan_pick]) {
      using_quan[th.data.selected_quan_pick].is_nouse_red = 0;
    }
    else {
      using_quan[th.data.selected_quan_pick] = { is_nouse_red: 0 };
    }
    this.setData({ using_quan: using_quan });
    return true
  },
  /*--点击选择券--*/
  sele_quan_item: function (e) {

    var ind = e.currentTarget.dataset.ind;
    var quan_item = this.data.selected_quan_list[ind];
    var pickid = this.data.selected_quan_pick;  //现在选择的是哪一个门店
    //--如果券是单品使用的时候--
    if (quan_item && quan_item.UseObjectType && quan_item.UseObjectType == "20") {
      //---只有多件购买的时候才要计算，//购物车购买和搭配勾的时候---
      var gg = getApp().get_b_now();
      if (this.data.is_b_now == 0 || gg.prom_type == 5) {
        var arr = this.data.order_prom_list_cart;
        var t_pk_item = null;
        for (var ii in arr) {
          var ep = arr[ii];
          if (pickid == ep.pickup_id) {
            t_pk_item = ep;
            break;
          }
        }
        //--寻找券指定的商品--
        var gd = null;
        if (t_pk_item) {
          var goods = t_pk_item.goods;
          for (var gid in goods) {
            if (quan_item.UseObjectID == goods[gid].erpwareid) {
              gd = goods[gid];
            }
          }
        }
        if (!gd) {
          getApp().my_warnning("未找到指定商品使用", 0, this, 600);
          return false;
        }
        //计算价格，如果有平摊的实收要计算实收的金额
        var item_price = gd.goods_price * gd.goods_num;
        //-- 如果有平摊下去，有实收价格的时候，就要用account_fir来计算价格 --
        if (gd.account_fir != null && gd.account_fir != undefined) {
          item_price = gd.account_fir * gd.goods_num;
        }

        if (item_price < parseFloat(quan_item.BuySum)) {
          getApp().my_warnning("该单品金额没有大于等于" + quan_item.BuySum + "元时不能使用优惠券", 0, this, 600);
          return false;
        }
      }
    }

    var no_use = e.currentTarget.dataset.no, quanlist = this.data.selected_quan_list;
    //---所有的券的显示红色选择都清理一遍---
    for (var i in quanlist) {
      quanlist[i].show_red = 0;
    }
    this.setData({ selected_quan_list: quanlist });
    var by_quanlist = this.data.get_by_quan_list;
    if (by_quanlist) {
      //---所有的券的显示红色选择都清理一遍---
      for (var inb in by_quanlist) {
        by_quanlist[inb].show_red = 0;
      }
      this.setData({ get_by_quan_list: by_quanlist });
    }

    var by_cart_list = this.data.by_quan_list_cart;
    if (by_cart_list) {
      //---所有的券的显示红色选择都清理一遍---
      for (var inc in by_cart_list) {
        by_cart_list[inc].show_red = 0;
      }
      this.setData({ by_quan_list_cart: by_cart_list });
    }

    var using_quan = this.data.using_quan;
    var th = this;
    //---如果是不使用优惠券---
    if (no_use == 1) {
      console.log("有进来吗券", no_use);
      if (using_quan[th.data.selected_quan_pick]) {
        using_quan[th.data.selected_quan_pick].is_nouse_red = 1;
      }
      else {
        using_quan[th.data.selected_quan_pick] = { is_nouse_red: 1 };
      }
      this.setData({ using_quan: using_quan, is_coupon: th.is_coupon });
      return;
    }


    var txt = "selected_quan_list[" + ind + "].show_red";
    var obj = {};
    obj[txt] = 1;
    if (quan_item.show_red) {
      obj[txt] = 0;
    }
    this.setData(obj);
    console.log(this.data.selected_quan_list, "选中的券的下标", quan_item, "数据都在这里", txt);
    if (using_quan[th.data.selected_quan_pick]) {
      using_quan[th.data.selected_quan_pick].is_nouse_red = 0;
    }
    else {
      using_quan[th.data.selected_quan_pick] = { is_nouse_red: 0 };
    }
    this.setData({ using_quan: using_quan });

  },
  /*----- 点击选择包邮券 -----*/
  sele_quan_item_by_befor: function () {
    // var no_use = e.currentTarget.dataset.no;
    //立即购买的包邮券
    var by_quanlist = this.data.get_by_quan_list;
    if (by_quanlist) {
      //---所有的券的显示红色选择都清理一遍---
      for (var ind in by_quanlist) {
        by_quanlist[ind].show_red = 0;
      }
      this.setData({ get_by_quan_list: by_quanlist });
    }
    console.error('选中包邮');
    
    //--购物车过来的包邮券--
    var by_cart_list = this.data.by_quan_list_cart;
    if (by_cart_list) {
      //---所有的券的显示红色选择都清理一遍---
      for (var ind in by_cart_list) {
        by_cart_list[ind].show_red = 0;
      }
      this.setData({ by_quan_list_cart: by_cart_list });
    }
    //普通券
    var quanlist = this.data.selected_quan_list;
    if (quanlist) {
      //---所有的券的显示红色选择都清理一遍---
      for (var ind in quanlist) {
        quanlist[ind].show_red = 0;
      }
      this.setData({ selected_quan_list: quanlist });
    }

    var th = this;
    var using_quan = this.data.using_quan;
    //---如果是不使用优惠券---
    // if (no_use == 1) {
    //   if (using_quan[th.data.selected_quan_pick]) {
    //     using_quan[th.data.selected_quan_pick].is_nouse_red = 1;
    //   }
    //   else {
    //     using_quan[th.data.selected_quan_pick] = { is_nouse_red: 1 };
    //   }
    //   this.setData({ using_quan: using_quan, is_coupon: th.is_coupon });
    //   return;
    // }

    var pickid = th.data.selected_quan_pick;  //现在选择的是哪一个门店
    var ind = 0;
    //--如果是立即购买的部分--
    var txt = "";
    var txt1 = "";
    var quan_item = null;
    if (th.data.is_b_now) {
      quan_item = this.data.get_by_quan_list[ind];
      txt = "get_by_quan_list[" + ind + "].show_red";
      var obj = {};
      obj[txt] = 1;
      this.setData(obj);
    } else {
      txt = "by_quan_list_cart[" + ind + "].show_red";
      quan_item = th.data.by_quan_list_cart[ind];
      var obj = {};
      obj[txt] = 1;
      this.setData(obj);
      th.data.get_by_quan_list_cart[pickid] = JSON.parse(JSON.stringify(th.data.by_quan_list_cart));  //要把选中的弄回数组
    }

    if (using_quan[th.data.selected_quan_pick]) {
      using_quan[th.data.selected_quan_pick].is_nouse_red = 0;
    }
    else {
      using_quan[th.data.selected_quan_pick] = { is_nouse_red: 0 };
    }
    this.setData({ using_quan: using_quan });
  },
  /*----- 点击选择包邮券 -----*/
  sele_quan_item_by: function (e) {
    var no_use = e.currentTarget.dataset.no;
    //立即购买的包邮券
    var by_quanlist = this.data.get_by_quan_list;
    if (by_quanlist) {
      //---所有的券的显示红色选择都清理一遍---
      for (var ind in by_quanlist) {
        by_quanlist[ind].show_red = 0;
      }
      this.setData({ get_by_quan_list: by_quanlist });
    }

    //--购物车过来的包邮券--
    var by_cart_list = this.data.by_quan_list_cart;
    if (by_cart_list) {
      //---所有的券的显示红色选择都清理一遍---
      for (var ind in by_cart_list) {
        by_cart_list[ind].show_red = 0;
      }
      this.setData({ by_quan_list_cart: by_cart_list });
    }
    //普通券
    var quanlist = this.data.selected_quan_list;
    if (quanlist) {
      //---所有的券的显示红色选择都清理一遍---
      for (var ind in quanlist) {
        quanlist[ind].show_red = 0;
      }
      this.setData({ selected_quan_list: quanlist });
    }

    var th = this;
    var using_quan = this.data.using_quan;
    
    //---如果是不使用优惠券---
    if (no_use == 1) {
      if (using_quan[th.data.selected_quan_pick]) {
        using_quan[th.data.selected_quan_pick].is_nouse_red = 1;
      }
      else {
        using_quan[th.data.selected_quan_pick] = { is_nouse_red: 1 };
      }
      this.setData({ using_quan: using_quan, is_coupon: th.is_coupon });
      return;
    }

    var pickid = th.data.selected_quan_pick;  //现在选择的是哪一个门店
    var ind = e.currentTarget.dataset.ind;
    //--如果是立即购买的部分--
    var txt = "";
    var txt1 = "";
    var quan_item = null;
    if (th.data.is_b_now) {
      quan_item = this.data.get_by_quan_list[ind];
      txt = "get_by_quan_list[" + ind + "].show_red";
      var obj = {};
      obj[txt] = 1;
      this.setData(obj);
    } else {
      txt = "by_quan_list_cart[" + ind + "].show_red";
      quan_item = th.data.by_quan_list_cart[ind];
      var obj = {};
      obj[txt] = 1;
      this.setData(obj);
      th.data.get_by_quan_list_cart[pickid] = JSON.parse(JSON.stringify(th.data.by_quan_list_cart));  //要把选中的弄回数组
    }

    if (using_quan[th.data.selected_quan_pick]) {
      using_quan[th.data.selected_quan_pick].is_nouse_red = 0;
    }
    else {
      using_quan[th.data.selected_quan_pick] = { is_nouse_red: 0 };
    }
    this.setData({ using_quan: using_quan });
  },

  //--确认使用券---
  confirm_quan: function () {
    var using_quan = this.data.using_quan;     //正在使用中的券列表
    var pickid = this.data.selected_quan_pick; //选中的门店ID
    var th = this;
    var selected_quan_list = this.data.selected_quan_list;  //选择了那个门店的券列表
    var get_by_quan_list = this.data.get_by_quan_list;      //立即购买的包邮券列表
    var by_quan_list_cart = this.data.by_quan_list_cart;    //购物车购买的包邮券列表
    //选择了的券
    var sele_quan = null;
    
    //循环普通的券
    for (var i in selected_quan_list) {
      var item = selected_quan_list[i];
      if (item.show_red) {
        th.insert_into_using_quan(item, using_quan, pickid);
        return;
      }
    }
    //循环包邮的券，立即购买的
    for (var i in get_by_quan_list) {
      var item = get_by_quan_list[i];
      if (item.show_red) {
        if (th.data.is_no_by[pickid] == 1) {
          getApp().my_warnning("已全场不能包邮，不能选择包邮券", 0, th);
          return false;
        }
        if (th.data.is_by[pickid] == 1) {
          getApp().my_warnning("已全场包邮，不能选择包邮券", 0, th);
          return false;
        }

        th.insert_into_using_quan(item, using_quan, pickid, 1);
        return;
      }
    }

    //循环包邮的券
    for (var i in by_quan_list_cart) {
      var item = by_quan_list_cart[i];
      if (item.show_red) {
        if (th.data.is_no_by[pickid] == 1) {
          getApp().my_warnning("已全场不能包邮，不能选择包邮券", 0, th);
          return false;
        }
        if (th.data.is_by[pickid] == 1) {
          getApp().my_warnning("已全场包邮，不能选择包邮券", 0, th);
          return false;
        }
        th.insert_into_using_quan(item, using_quan, pickid, 1);
        return;
      }
    }
    
    //选择了的券，看是不是点击了不使用券,点击了不使用优惠券
    if (using_quan[pickid]) {
      if (using_quan[pickid].is_nouse_red == 1) {
        using_quan[pickid] = { is_nouse_red: 1 };
        th.setData({ using_quan: using_quan });
        if (th.data.is_b_now == 1) {
          th.calculatePrice2();
        } else {
          th.calculatePrice();
        }
        th.setData({ open_quan: 0 });
        return;
      }
    }
  },
  //--第一次进入如果只有一张券时使用使用券---
  confirm_quan_befor: async function () {
    var using_quan = this.data.using_quan;     //正在使用中的券列表
    var pickid = this.data.selected_quan_pick; //选中的门店ID
    var th = this;
    var selected_quan_list = this.data.selected_quan_list;  //选择了那个门店的券列表
    var get_by_quan_list = this.data.get_by_quan_list;      //立即购买的包邮券列表
    var by_quan_list_cart = this.data.by_quan_list_cart;    //购物车购买的包邮券列表
    //选择了的券
    var sele_quan = null;
    
    //循环普通的券
    for (var i in selected_quan_list) {
      var item = selected_quan_list[i];
      if (item.show_red) {
        th.insert_into_using_quan(item, using_quan, pickid, 0, false);
        return;
      }
    }
    console.error('66确认使用劵');
    //循环包邮的券，立即购买的
    for (var i in get_by_quan_list) {
      var item = get_by_quan_list[i];
      if (item.show_red) {
        if (th.data.is_no_by[pickid] == 1) {
          // getApp().my_warnning("已全场不能包邮，不能选择包邮券", 0, th);
          return false;
        }
        if (th.data.is_by[pickid] == 1) {
          // getApp().my_warnning("已全场包邮，不能选择包邮券", 0, th);
          return false;
        }

        th.insert_into_using_quan(item, using_quan, pickid, 1, false);
        return;
      }
    }
    console.error('777确认使用劵');
    //循环包邮的券
    for (var i in by_quan_list_cart) {
      var item = by_quan_list_cart[i];
      if (item.show_red) {
        if (th.data.is_no_by[pickid] == 1) {
          // getApp().my_warnning("已全场不能包邮，不能选择包邮券", 0, th);
          return false;
        }
        if (th.data.is_by[pickid] == 1) {
          // getApp().my_warnning("已全场包邮，不能选择包邮券", 0, th);
          return false;
        }
        th.insert_into_using_quan(item, using_quan, pickid, 1, false);
        return;
      }
    }
    
    //选择了的券，看是不是点击了不使用券,点击了不使用优惠券
    if (using_quan[pickid]) {
      if (using_quan[pickid].is_nouse_red == 1) {
        using_quan[pickid] = { is_nouse_red: 1 };
        th.setData({ using_quan: using_quan });
        if (th.data.is_b_now == 1) {
          th.calculatePrice2();
        } else {
          th.calculatePrice();
        }
        th.setData({ open_quan: 0 });
        return;
      }
    }
  },
  //----把券插入之后的操作，同时还要重新计算价格----
  insert_into_using_quan: async function (item, using_quan, pickid, isby, showToast = true) {


    var th = this;
    var old_quan = null;
    
    if (isby == 1) {
      using_quan[pickid] = {
        coupon_no: item.no,
        money: 0,
        is_nouse_red: 0,
        region_list: item.region_list,
        goods_list: item.goods_list
      };
      using_quan[pickid].isby = 1;
    } else {
      if (using_quan[pickid]) old_quan = using_quan[pickid];

      let using_data={ coupon_no: item.CashRepNo, money: item.Sum, is_nouse_red: 0 };

      //-- 优化判断是有使用零售价的时候 --
      if(item.FactPriceType){
        using_data.FactPriceType=1;
      }

      using_quan[pickid] =using_data ;
      using_quan[pickid].isby = 0;
    }
    this.setData({ using_quan: using_quan });
    if (th.data.is_b_now == 1) {
      th.calculatePrice2(function () {
        // if (old_quan) using_quan[pickid] = old_quan;
        // else using_quan[pickid] = null;
        // th.setData({ using_quan: using_quan, submit: 0 });
        // if(showToast){
        //   wx.showToast({
        //     title: "不能使用优惠券，同城起送价不足",
        //     icon: 'none',
        //     duration: 2000
        //   })
        // }
      });
    } else {
      th.calculatePrice(function () {
        // if (old_quan) using_quan[pickid] = old_quan;
        // else using_quan[pickid] = null;
        // th.setData({ using_quan: using_quan, submit: 0 });
        // if(showToast){
        //   wx.showToast({
        //     title: "不能使用优惠券，同城起送价不足",
        //     icon: 'none',
        //     duration: 2000
        //   })
        // }
      });
    }
    th.setData({ open_quan: 0 });
  },

  cart_set_err: function (e) {
    var txt = e.currentTarget.dataset.err;
    var ob = {};
    ob[txt] = this.data.imgUrl + "/miniapp/images/default_g_img.gif";
    this.setData(ob);
  },
  cart_set_err1: function (e) {
    var txt = e.currentTarget.dataset.err;
    var ob = {};
    ob[txt] = "/miniapp/images/default_g_img.gif";
    this.setData(ob);
  },

  //--验证是否已经冻结--
  check_is_frozenQuan: function (quanlist, frozenQuan, isby) {
    console.log("券列表", quanlist);
    if (!quanlist) return null;
    if (!frozenQuan) return quanlist;
    var arr = [];
    for (var i = 0; i < quanlist.length; i++) {
      var item = quanlist[i];
      var is_find = 0;
      var Q_no = quanlist[i].CashRepNo;
      if (isby) Q_no = quanlist[i].no;
      for (var j = 0; j < frozenQuan.length; j++) {
        var q_no = frozenQuan[j].cashRepNo;
        if (Q_no == q_no) {
          is_find = 1;
          break;
        }
      }
      if (!is_find) arr.push(item);
    }
    return arr;
  },

  //// 开启物流的弹窗
  show_wu_arr: function (e) {
    var wu_arr_txt = e.currentTarget.dataset.txt;
    var w_sele_index = e.currentTarget.dataset.w_sele_index;
    var is_express = null;
    var ob = { open_express: 1, wu_arr_txt: wu_arr_txt, disabled: 1 };

    //--如果是多个门店的时候--
    if (w_sele_index != undefined) {
      is_express = this.data.cartlist[w_sele_index].wind;
      ob['is_express'] = is_express;
    }
    this.setData(ob);
  },
  // 关闭物流的弹窗
  close_express: function () {
    this.setData({ open_express: 0, disabled: 0 });
  },
  // 选择物流
  click_express_name: function (e) {
    var express_name = e.currentTarget.dataset.name, shippingcode = e.currentTarget.dataset.shippingcode;
    var index = e.currentTarget.dataset.idxe;
    var ob = { is_express: index, is_shipping_code: shippingcode, disabled: 0 };
    ob[this.data.wu_arr_txt] = index;
    this.setData(ob);
  },

  //点击确定物流
  determine_expres: function (e) {
    this.setData({ open_express: 0 });
    if (this.data.is_b_now == 1)
      this.calculatePrice2();
    else
      this.calculatePrice();
  },

  //点击打开优惠券使用说明
  clik_coupons: function (e) {
    var ind = e.currentTarget.dataset.idx;
    var is_open = this.data.selected_quan_list[ind].is_open;

    if (is_open == 1) is_open = 0;
    else is_open = 1;

    var txt = "selected_quan_list[" + ind + "].is_open"
    var obj = {};
    obj[txt] = is_open;

    this.setData(obj);
    this.setData({ disabled: 1 })
  },

  clik_coupons2: function (e) {
    var ind = e.currentTarget.dataset.idx;
    var is_open = this.data.get_by_quan_list[ind].is_open;

    if (is_open == 1) is_open = 0;
    else is_open = 1;

    var txt = "get_by_quan_list[" + ind + "].is_open"
    var obj = {};
    obj[txt] = is_open;

    this.setData(obj);
    this.setData({ disabled: 1 })
  },


  //设置默认物流
  select_default_logistics: function () {
    var th = this;
    var is_shipping_code = this.data.is_shipping_code
    getApp().request.put("/api/weshop/users/update", {
      data: { user_id: getApp().globalData.user_id, store_id: oo.stoid, def_exp_code: is_shipping_code },
      success: function (rse) {
        if (rse.data.code == 0) {
          getApp().globalData.userInfo.def_exp_code = is_shipping_code;
          th.setData({ open_express: 0 });
          //----计算此时购物车的价格----
          if (th.data.is_b_now == 1) th.calculatePrice2();
          else th.calculatePrice();
        }
      }
    })
  },

  //更新下默认，在onshow里面
  update_code() {
    var th = this, m_wind = 0, def_exp_code = getApp().globalData.userInfo.def_exp_code;

    //--定时器，判断wu_arr不未空--
    var uii = setInterval(function () {
      if (th.data.wu_arr) {
        clearInterval(uii);
        if (th.data.is_default_logistics) return false;
        for (var k = 0; k < th.data.wu_arr.length; k++) {
          var item = th.data.wu_arr[k];
          if (def_exp_code == item.code) {
            m_wind = k;
          }
        }
        //--如果是立即购买--
        if (th.data.is_b_now == 1) {
          th.setData({ index: m_wind, is_express: m_wind });
        } else {
          var ui = setInterval(function () {
            if (th.data.cartlist) {
              var c_arr = th.data.cartlist;
              for (var i in c_arr) {
                c_arr[i].wind = m_wind;
              }
              th.setData({ cartlist: c_arr, is_express: m_wind })
              clearInterval(ui);
            }
          }, 500)
        }
      }
    }, 500);
  },

  //-----获取购物车进来的劵-------
  get_cart_quan: async function (order_prom_list_cart) {
    var th = this;
    var user_id = getApp().globalData.user_id;

    //等待值的出现
    //getApp().waitfor2(this,"g_cart_q_time","order_prom_list_cart",async function () {
    //var arr=th.data.order_prom_list_cart;
    var arr = order_prom_list_cart;
    if (!arr) arr = [];
    //如果系统有限制使用优惠券
    if (th.data.is_close_quan) return false;

    //------------开始计算使用优惠券相关------------
    for (var ind in arr) {
      var ep = arr[ind];

      arr[ind].scj_arr=[];  //清空

      //如果门店订单使用订单促销（此订单促销取价规则不是实收价的时候）
      if (th.data.can_use_ord_prom[ep.pickup_id]) {
        continue;
      }

      var goodlist = ep.goods;
      var pickup_id = ep.pickup_id;
      //--更优惠券抵用有关，立即购买的，如果是购物车，如果有等级价还有考虑等级价的东西
      //就要把相应的值，写入cartlist数组中--
      var ckeck_quan_price = 0,
        check_quan_price_list = '',
        check_quan_ware_list = '',
        check_quan_price_list_arr = [],
        check_quan_ware_list_arr = [];

      let ck_price_scj=0;  //市场价的优化

      for (var i in goodlist) {
        var gd = goodlist[i];
        //--如果是秒杀就跳出,如果是赠品，如果是组合购限制使用优惠券--
        if (gd.whsle_id == 1 || gd.is_gift || (gd.prom_type == 7 && gd.act && gd.act.is_xz_yh) || gd.is_xz_yh == 1) {
          continue;
        }

        //有搭配购的时候才来判断
        if (gd.prom_type == 5 && th.data.coll_prom && th.data.coll_prom[gd.prom_id]) {
          if (!th.data.coll_prom[gd.prom_id].is_coupon && th.has_dp(goodlist, gd.prom_id)) {
            continue;
          }
        }

        //--如果是秒杀，要判断有没有限制使用优惠券
        if (gd.prom_type == 1 && !gd.is_quan) {
          continue;
        }

        //--如果是团购，要判断有没有限制使用优惠券
        if (gd.prom_type == 2) {
          var prom1 = null;
          await getApp().request.promiseGet("/api/weshop/goods/groupBuy/getActInfo/" + os.stoid + "/" + gd.goods_id + "/" + gd.prom_id, {
          }).then(res => {
            if (res.data.code == 0) prom1 = res.data.data;
          })
          if (prom1 && !prom1.isQuan) {
            continue;
          }
        }

        //--如果是阶梯购，要判断有没有限制使用优惠券
        if (gd.prom_type == 10) {
          var prom1 = null;
          await getApp().request.promiseGet("/api/weshop/prom/ladderForm/getNew/" + os.stoid + "/" + user_id + "/" + gd.prom_id, {
          }).then(res => {
            if (res.data.code == 0) prom1 = res.data.data;
          })
          if (prom1 && prom1.isuse && prom1.is_usecoupon) {
            continue;
          }
        }

        if(gd.is_collocation && gd.market_price && !gd.goods_market_price){
          gd.goods_market_price=gd.market_price;
        }

        //如果有限制使用优惠券，就要返回
        if (gd.prom_type == 3) {

          if (th.data.prom_goods_map && th.data.prom_goods_map[pickup_id] && th.data.prom_goods_map[pickup_id][gd.prom_id]) {
            if (th.data.prom_goods_map[pickup_id][gd.prom_id].is_xz_yh) continue;
            th.data.prom_goods_map[pickup_id][gd.prom_id].coupon_sele = 1;
          }
        }
        var item_price = gd.goods_price * gd.goods_num;
        var item_price2 = item_price;
        var real_price=gd.goods_price;

        //-- 如果有平摊下去，有实收价格的时候，就要用account来计算价格 --
        if (gd.account_fir != null && gd.account_fir != undefined) {
          item_price2 = gd.account_fir * gd.goods_num;
          real_price=gd.account_fir;
        }

        if (gd.ld_account) {
          item_price2 = gd.ld_account * gd.goods_num;
          real_price=gd.ld_account;
        }
        ckeck_quan_price += item_price;

        //如果实收价等于市场价的死后
        if(real_price>=gd.goods_market_price){
             ck_price_scj+= real_price * gd.goods_num;  //市场价的优化
             if(!arr[ind].scj_arr) arr[ind].scj_arr=[];  //组装市场价的数组，如果优惠券使用了零售价的券，就要带入使用券的接口
             arr[ind].scj_arr.push({
                sum_price:real_price * gd.goods_num,
                index: parseInt(i),
                goods_id:gd.goods_id,
                erpwareid:gd.erpwareid
             })
        }


        //如果商品有重复的过滤，一般是组合购和阶梯购的情况下
        var idx = check_quan_ware_list_arr.findIndex(function (ele) {
          return ele == encodeURIComponent(gd['erpwareid']);
        })

        if (idx > -1) {
          check_quan_price_list_arr[idx] += item_price2;
        } else {
          check_quan_ware_list_arr.push(encodeURIComponent(gd['erpwareid']));
          check_quan_price_list_arr.push(item_price2);
        }
        //--组装价格list--
        /*--
        if (check_quan_price_list) {
            check_quan_price_list += "," + item_price;
        } else {
            check_quan_price_list = item_price;
        }
        //--组装商品的线下erpwareid--
        if (check_quan_ware_list) {
            check_quan_ware_list += "," + encodeURIComponent(gd['erpwareid']);
        } else {
            check_quan_ware_list = encodeURIComponent(gd['erpwareid']);
        }---*/
      }
      //优惠券优惠的金额要控制到优惠券的选择条件
      var cut_price = 0;
      for (var i in th.data.prom_goods_map[pickup_id]) {
        var obj = th.data.prom_goods_map[pickup_id][i];
        if (obj.coupon_sele) {
          cut_price += obj.price - obj.prom_price;
        }
      }

      var prom_pt_json = ep.prom_pt_json;
      if (prom_pt_json) {
        for (let oj in prom_pt_json) {
          let item_j = prom_pt_json[oj];
          //要对一下阶梯优惠促销的功能
          if (item_j.ladder_prom_id) {
            //看一下要不要限制使用优惠券
            if (th.data.ladder_map[item_j.ladder_prom_id] && th.data.ladder_map[item_j.ladder_prom_id].is_usecoupon) {
              continue;
            }
            cut_price += parseFloat(item_j.dis);
          }
          //要对一下组合购促销的功能
          if (item_j.zhprom_id) {
            //看一下要不要限制使用优惠券
            if (th.data.zhhe_act_map[item_j.zhprom_id] && th.data.zhhe_act_map[item_j.zhprom_id].is_xz_yh) {
              continue;
            }
            cut_price += parseFloat(item_j.dis);
          }
        }
      }

      if (check_quan_price_list_arr.length) check_quan_price_list = check_quan_price_list_arr.join(',');
      if (check_quan_ware_list_arr.length) check_quan_ware_list = check_quan_ware_list_arr.join(',')

      arr[ind].ckeck_quan_price = ckeck_quan_price - (cut_price ? cut_price : 0);
      arr[ind].check_quan_ware_list = check_quan_ware_list;
      arr[ind].check_quan_price_list = check_quan_price_list;
      arr[ind].quan_list = null;

      var quan_req= {
        storeId: oo.stoid,
        userId: app.globalData.user_id,
        BuySum: arr[ind].ckeck_quan_price,
        WareIds: check_quan_ware_list,
        pageSize: 100
      }

      if(arr[ind].scj_arr && arr[ind].scj_arr.length ){
        quan_req.BuyPosSum=ck_price_scj  //优化获取市场价的优惠券
        
        let PosWareIds=[];
        for (let is = 0; is < arr[ind].scj_arr.length; is++) {
          PosWareIds.push(arr[ind].scj_arr[is].erpwareid)
        }

        quan_req.PosWareIds=PosWareIds.join()  //优化获取市场价的优惠券
      }

      //-- 是否关闭使用优惠券,循环有找到商品 --
      if (th.data.is_close_quan != 1 && check_quan_ware_list) {
        //--调用接口，获取优惠券的列表，3秒钟内控制接口请求--
        var url = "/api/weshop/couponList/getUseCouponList";
        await app.request.promiseGet(url, {
          data:quan_req
        }).then(res => {
          console.error('优惠券111111111111');
          if (res.data.code == 0) {
            var quan_list = res.data.data.pageData;
            //arr[ind].quan_list = th.check_is_frozenQuan(quan_list, th.data.frozenQuan);
            quan_list = th.check_is_frozenQuan(quan_list, th.data.frozenQuan);
            var set_txt = "cartlist[" + ind + "].quan_list";
            th.setData({
              [set_txt]: quan_list,
              def_coupon1: quan_list
            })
            //判断是否是第一进入且优惠券只有一张的时候，进行优惠券使用  first_entry 表示是否是第一次进入
            // let first_entry = th.data.first_entry;
            // if (quan_list && quan_list.length == 1 && first_entry == 0) {
            //   first_entry += 1;
            //   th.setData({
            //     sele_cart_ind: 0,
            //     sele_exp_type: th.data.cartlist[0].exp_type,
            //     selected_quan_pick: th.data.cartlist[0].pickup_id,
            //     selected_quan_list: th.data.cartlist[0].quan_list,
            //     first_entry
            //   })
            //   let quan_off = th.sele_quan_item_befor();
            //   if (quan_off) {
            //     th.confirm_quan_befor()
            //   }
            // }
            //--------------end--------------
          }
        })
      }
    }


    //如果是搭配购的立即购买的时候
    if (th.data.is_b_now) {
      if (arr && arr.length > 0) {
        var quanlist = arr[0].quan_list;
        th.setData({ selected_quan_list: quanlist })
      }
    } else {
      //th.setData({ cartlist: arr })
      th.set_can_num();
    }

    //})
  },

  //------ 获取立即购买的购物车的劵,因为立即购买只有一个商品 --------
  get_buy_now_quan: function () {
    var quanlist = null, th = this, frozenQuan = null;
    var good = this.data.bn_goods;

    //一件代发商品不使用优惠券
    if (good.whsle_id) return false;
    if (good.prom_price) {
      th.data.ckeck_quan_price = good.prom_price;  //如果有优惠价，就用优惠价
    } else if (good.is_offline) {
      th.data.ckeck_quan_price = good.offline_price; //如果有线下取价，就用线下价
    }
    //--如果商家后台没有限制使用优惠券，同时商品的优惠活动没有限制使用优惠券--
    if (th.data.is_close_quan != 1 && th.data.bn_goods.is_xz_yh != 1 && th.data.check_quan_ware_list) {
      var url0 = "/api/weshop/users/frozenQuan/listFrozenQuan/" + app.globalData.user_id;
      var url = "/api/weshop/couponList/getUseCouponList";
      app.request.promiseGet(url0, { 1: 1 }).then(res => {
        if (res.data.code == 0) {
          frozenQuan = res.data.data;
          th.data.frozenQuan = frozenQuan;
        }

        let get_q_req={
          storeId: oo.stoid,
          userId: app.globalData.user_id,
          BuySum: th.data.ckeck_quan_price,
          WareIds: encodeURIComponent(th.data.check_quan_ware_list),
          pageSize: 100
        };

        var gg = to.get_b_now();
        if(th.data.ckeck_quan_price>= good.market_price* gg.goods_num){
          get_q_req.BuyPosSum=th.data.ckeck_quan_price  //优化获取市场价的优惠券
          get_q_req.PosWareIds=encodeURIComponent(th.data.check_quan_ware_list)  //优化获取市场价的优惠券
        }

        app.request.time_limit_get(6, url, {
          data:get_q_req ,
          success: function (res) {
            console.error('优惠券22222222222222222');
            if (res.data.code == 0) {
              quanlist = res.data.data.pageData;
              if (quanlist) {
                quanlist = th.check_is_frozenQuan(quanlist, frozenQuan);
                th.setData({ selected_quan_list: quanlist, def_coupon2: quanlist })
                // let first_entry = th.data.first_entry;
                // if (quanlist && quanlist.length == 1 && first_entry == 0) {
                //   first_entry += 1;
                //   th.setData({
                //     selected_quan_pick: th.data.bn_pick,
                //     first_entry
                //   })
                //   let quan_off = th.sele_quan_item_befor();
                //   if (quan_off) {
                //     th.confirm_quan_befor()
                //   }
                // }
              }
            }
          }
        })
      })
    }
  },
  //默认选择优惠券
  def_coupon_fn() {
      // setTimeout(() => {
      //   this.def_coupon_fn_aft()
      // }, 100);
      wx.showLoading({
        title: '加载中',
        mask:true
      })
    try {
      setTimeout(() => {
        wx.hideLoading()
        this.def_coupon_fn_aft()
      }, 1000);
    } catch (error) { }

  },
  //默认选择优惠券
  def_coupon_fn_aft() {
    console.error('进入默认优惠券选择');

    let th = this;
    let first_entry = th.data.first_entry;
    console.error(first_entry);
    if (first_entry > 0 || (th.data.cartlist && th.data.cartlist.length>1)) {
      return
    }
    first_entry += 1;
    th.setData({
      first_entry
    })
    let length1 = th.data.def_coupon1 ? th.data.def_coupon1.length : 0
    let length2 = th.data.def_coupon2 ? th.data.def_coupon2.length : 0
    let length3 = th.data.def_coupon3 ? th.data.def_coupon3.length : 0
    let length4 = th.data.def_coupon4 ? th.data.def_coupon4.length : 0
    let length = length1 + length2
    if ((th.data.show_submit && th.data.is_b_now==1 && th.data.bn_exp_type==0) || (th.data.is_b_now==0 && th.data.cartlist && th.data.cartlist.length==1 && th.data.cartlist[0].exp_type==0)) {
      length= length + length3 + length4
    }
    console.error(length);
    if (length != 1) {
      return
    }
    if (length1 == 1) {
      console.error('优惠券1');
      let first_entry = th.data.first_entry;
      let quan_list = th.data.def_coupon1
      if (quan_list && quan_list.length == 1 && first_entry == 1) {
        // first_entry += 1;
        th.setData({
          sele_cart_ind: 0,
          sele_exp_type: th.data.cartlist[0].exp_type,
          selected_quan_pick: th.data.cartlist[0].pickup_id,
          selected_quan_list: th.data.cartlist[0].quan_list,
          // first_entry
        })
        let quan_off = th.sele_quan_item_befor();
        if (quan_off) {
          th.confirm_quan_befor()
        }
      }
      return
    }
    if (length2 == 1) {
      console.error('优惠券2');
      let first_entry = th.data.first_entry;
      let quanlist = th.data.def_coupon2
      if (quanlist && quanlist.length == 1 && first_entry == 1) {
        // first_entry += 1;
        th.setData({
          selected_quan_pick: th.data.bn_pick,
          // first_entry
        })
        let quan_off = th.sele_quan_item_befor();
        if (quan_off) {
          th.confirm_quan_befor()
        }
      }
      return
    }
    if (length3 == 1) {
      console.error('优惠券3');
      let arr = th.data.def_coupon3
      let first_entry = th.data.first_entry;
      if (arr && arr.length == 1 && first_entry == 1) {
        // first_entry += 1;
        let cart_item= th.data.cartlist[0]
        th.setData({
          by_quan_list_cart: arr,
          sele_cart_ind: 0,
          sele_exp_type: cart_item.exp_type,
          selected_quan_pick: cart_item.pickup_id,
          // first_entry
        })
        th.sele_quan_item_by_befor();
        th.confirm_quan_befor()
      }
      return

    }
    if (length4 == 1) {
      console.error('优惠券4');
      let first_entry = th.data.first_entry;
      let arr = th.data.def_coupon4
      if (arr && arr.length == 1 && first_entry == 1) {
        // first_entry += 1;
        // th.setData({
        //   first_entry
        // })
        setTimeout(() => {
          th.setData({
            sele_cart_ind: 0,
            selected_quan_pick: th.data.bn_pick,
          })
          th.sele_quan_item_by_befor();
          th.confirm_quan_befor()
        }, 500);
      }
      return
    }

  },
  //检查区域是不是包邮
  check_area: function (arr) {
    var user_addr = this.data.user_addr;
    if (!user_addr) return 0;
    for (var i in arr) {
      var item = arr[i];
      if (user_addr.twon == item || user_addr.district == item
        || user_addr.city == item || user_addr.province == item) {
        return 0;
      }
    }
    return 1;
  },

  //检查立即购买的商品是不是不包邮
  check_good: function (arr, goods_id) {
    if (!goods_id) goods_id = this.data.bn_goods.goods_id;
    for (var i in arr) {
      var item = arr[i];
      if (goods_id == item) return 0;
    }
    return 1;
  },
  check_by_area: function (region_list) {
    var arr = region_list.split(",");
    var check = this.check_area(arr);
    return !check;
  },
  check_by_goods: function (goods_list, goods_id) {
    var arr = goods_list.split(",");
    var check = this.check_good(arr, goods_id);
    return !check;
  },

  //立即购买获取优惠活动的内容
  buy_now_prom_goods: async function (prom_id, arr, func) {
    var th = this;
    var price = arr.shop_price * arr.goods_num;
    var prom = null;
    var gg = to.get_b_now();
    getApp().request.promiseGet("/api/weshop/promgoods/get/" + os.stoid + "/" + prom_id, {}).then(async res => {

      if (res.data.code == 0) {
        prom = res.data.data;

        if (prom && prom.limit_num * 1) {
          let user_pre_buynum = await th.getUserBuyPromNum_pre(prom.id)
          if (user_pre_buynum >= prom.limit_num) {
            arr.prom_price = null;
            arr.prom_id = "";
            arr.prom_type = "";
            if (prom.is_xz_yh) {
              arr.is_xz_yh = prom.is_xz_yh
            }
            func(arr);
          } else {
            let min_value = 0
            if (prom && prom.is_xz_yh) {
              let arr = prom.promGoodsList || []
              arr.map(item => {
                if (min_value) {
                  min_value = item.condition
                } else {
                  if (min_value < item.condition) {
                    min_value = item.condition
                  }
                }
              })
              if (arr.length > 0) {
                if (arr[0].prom_type == 0) {
                  if (price < min_value) {
                    prom.is_xz_yh = 0
                  }
                } else {
                  if (arr.goods_num < min_value) {
                    prom.is_xz_yh = 0
                  }
                }
              }
            }
            return getApp().request.promiseGet("/api/weshop/goods/getDiscount", {
              data: {
                price: parseFloat(price).toFixed(2),
                prom_id: prom_id,
                goods_num: arr.goods_num,
                user_id: getApp().globalData.user_id,
                is_bz: prom.is_bz
              }
            })
          }
        } else {
          let min_value = 0
          if (prom && prom.is_xz_yh) {
            let arr = prom.promGoodsList || []
            arr.map(item => {
              if (min_value) {
                min_value = item.condition
              } else {
                if (min_value < item.condition) {
                  min_value = item.condition
                }
              }
            })
            if (arr.length > 0) {
              if (arr[0].prom_type == 0) {
                if (price < min_value) {
                  prom.is_xz_yh = 0
                }
              } else {
                if (arr.goods_num < min_value) {
                  prom.is_xz_yh = 0
                }
              }
            }
          }
          //-------------------
          return getApp().request.promiseGet("/api/weshop/goods/getDiscount", {
            data: {
              price: parseFloat(price).toFixed(2),
              prom_id: prom_id,
              goods_num: arr.goods_num,
              user_id: getApp().globalData.user_id,
              is_bz: prom.is_bz
            }
          })
        }
      } else {
        func(arr);
      }
    }).then(res => {
      if (res.data.code == 0) {

        var get_data = res.data.data;

        //只有在活动已经开始参与优惠促销的时候
        th.data.bn_is_order_yh = prom.is_order_yh;
        th.data.bn_is_post_temp = prom.is_post_temp;

        arr.is_bz = prom.is_bz;             //是不是倍增
        arr.is_xz_yh = arr.is_xz_yh ? arr.is_xz_yh : prom.is_xz_yh;       //是不是优惠
        arr.bs = get_data.bs;               //是不是倍数
        arr.is_past = get_data.is_past;     //是不是包邮
        arr.prom_price = get_data.price >= 0 ? get_data.price : price;
        arr.s_intValue = get_data.intValue;
        arr.s_coupon_id = get_data.coupon_id;
        arr.s_coupon_num = get_data.coupon_num;
        arr.zp_mode = get_data.zp_mode;
        arr.zp_num = get_data.zp_num ? get_data.zp_num : 1; //确保默认一个

        //-- 看是不是有赠品 --
        if (get_data.gift_id && parseInt(get_data.zp_mode) != 1
          && get_data.zp_num * arr.bs <= get_data.limit_num
          && get_data.zp_num * arr.bs <= get_data.gift_storecount && get_data.goodsinfo
        ) {
          arr.gift_id = get_data.gift_id;
          arr.gift_goods_id = get_data.goods_id;
          arr.gift_goods_name = get_data.goods_name;
          arr.gift_goods_sn = get_data.goodsinfo.goods_sn;
          arr.gift_goods_color = get_data.goodsinfo.goods_color;
          arr.gift_goods_spec = get_data.goodsinfo.goods_spec;
          arr.gift_original_img = get_data.goodsinfo.original_img;
          arr.gift_weight = get_data.goodsinfo.weight;
          arr.gift_exp_sum_type = get_data.goodsinfo.exp_sum_type;
          arr.gift_uniform_exp_sum = get_data.goodsinfo.uniform_exp_sum;
          arr.gift_limit_num = get_data.limit_num;
          arr.gift_storecount = get_data.gift_storecount;
          arr.whsle_id = get_data.goodsinfo.whsle_id;
        }
        arr.s_libao = get_data.libao;
        arr.s_lb_num = get_data.lb_num;
        arr.lbtitle = get_data.lbtitle;
        arr.zxlbtitle = get_data.zxlbtitle;
        arr.zx_libao = get_data.zxlibao;
        arr.zx_lb_num = get_data.zxlb_num;
        //立即购买，每月礼包
        arr.monthlbtitle = get_data.monthlbtitle;
        arr.month_libao = get_data.monthlibao;
        arr.month_lb_num = get_data.monthlb_num;
        //----end-------

        arr.prom_id = prom_id;

        var send_gf = {};
        var pickid = gg.pick_id;
        if (parseInt(get_data.zp_mode) == 1) {
          if (!send_gf[pickid]) send_gf[pickid] = [];

          var a_stock_num = 0;
          var a_limit_num = 0;
          for (let iy in get_data.giftsinfo) {
            let item = get_data.giftsinfo[iy];
            a_stock_num += parseInt(item.gift_storecount);
            a_limit_num += parseInt(item.limit_num);
          }

          var t_zp_num = parseInt(get_data.zp_num) * parseInt(get_data.bs);
          if (a_limit_num >= t_zp_num && a_stock_num >= t_zp_num) {
            send_gf[pickid].push({
              pickup_id: pickid, giftsinfo: get_data.giftsinfo, zp_num: get_data.zp_num * get_data.bs,
              gf_pr_name: prom.name, prom_id: prom.prom_id, bs: get_data.bs
            });
          }
          th.setData({ send_gf: send_gf });
        }
      }
      func(arr);
    })
  },
  //优惠促销用户参与次数
  async getUserBuyPromNum_pre(prom_id) {

    //如果有缓存的数据，就用缓存的数据
    if (this.data.in_yhact[prom_id] && this.data.in_yhact[prom_id].buyed != undefined) {
      let user_pre_buynum = this.data.in_yhact[prom_id].buyed;
      return user_pre_buynum;
    }
    var userInfo = getApp().globalData.userInfo;
    var url = `/api/weshop/ordergoods/getUserBuyPromNum?is_all=1&store_id=${os.stoid}&user_id=${userInfo.user_id}&prom_type=3&prom_id=${prom_id}`;
    let res = await getApp().request.promiseGet(url, {
      data: {}
    });
    let user_pre_buynum = 0
    if (res.data.code == 0 && res.data.data) {
      user_pre_buynum = res.data.data.userbuynum
    }
    return user_pre_buynum
  },


  //获取优惠活动
  getprom(item) {

    let prom_id = item.prom_id
    let pickup_id = item.pick_id
    let limit_num = 0
    //不再调用接口活动优惠促销活动的内容
    // await getApp().request.promiseGet("/api/weshop/promgoods/get/" + oo.stoid + "/" + prom_id, {}).then(res => {
    //   if (res.data.code == 0) {
    //     let prom = res.data.data;
    //     limit_num =prom.limit_num
    //     let yh_is_xz_yh=this.data.yh_is_xz_yh
    //     yh_is_xz_yh[pickup_id]=prom.is_xz_yh
    //     this.setData({
    //       ['yh_is_xz_yh']:yh_is_xz_yh
    //     })
    //   }
    // })
    if (this.data.yhcx_act_map[prom_id]) {
      let prom = this.data.yhcx_act_map[prom_id];
      limit_num = prom.limit_num
      let yh_is_xz_yh = this.data.yh_is_xz_yh
      yh_is_xz_yh[pickup_id] = prom.is_xz_yh
      this.setData({
        ['yh_is_xz_yh']: yh_is_xz_yh
      })
    }
    return limit_num
  },

  //--检查订单优惠--
  check_is_order_prom: function (condition, func, pick) {
    var th = this;
    if (this.data.is_b_now == 1) pick = this.data.bn_pick;
    //---获取订单优惠---
    getApp().request.promiseGet("/api/weshop/promorder/getOrderPromotion", {
      data: { store_id: os.stoid, orderAmount: condition, user_id: getApp().globalData.user_id }
    }).then(res => {
      if (res.data.code == 0) {
        var data = res.data.data;
        th.data.order_prom[pick] = data;
      }
      func();
    })
  },

  //--- 加入优惠活动的映射中，同时要有一个good列表 ---
  add_prom_goods_map: async function (item) {
    var th = this;
    var pickid = item.pick_id;
    var map = th.data.prom_goods_map;
    var obj = map[pickid];

    if (map[pickid]) {
      if (map[pickid][item.prom_id]) {

        var ob = map[pickid][item.prom_id];
        //-- 避免同一件商品重复添加 --
        if (ob.goods && ob.goods.length) {
          var fid = ob.goods.findIndex(function (e) {
            e.goods_id == item.goods_id
          })
          if (fid > -1) return false;
        }

        //优惠促销取价的优化
        let f_price = item.goods_price;
        if (ob.discount_field != undefined) {
          switch (ob.discount_field) {
            case 0: f_price = item.goods_price; break;
            case 1: f_price = item.shop_price; break;
            case 2: f_price = item.goods_market_price; break;
          }
        }

        item.goods_price = f_price;

        ob.price += f_price * item.goods_num;
        ob.goods_num += item.goods_num;
        ob.goods.push({ goods_id: item.goods_id, goods_price: item.goods_price, goods_num: item.goods_num });

      } else {
        var prom = null;


        if (th.data.yhcx_act_map[item.prom_id]) {

          prom = th.data.yhcx_act_map[item.prom_id];

          let min_value = 0
          if (prom && prom.is_xz_yh) {
            let arr = prom.promGoodsList || []
            arr.map(ite => {
              if (min_value) {
                min_value = ite.condition
              } else {
                if (min_value < ite.condition) {
                  min_value = ite.condition
                }
              }
            })
            if (arr.length > 0) {
              if (arr[0].prom_type == 0) {
                if ((item.goods_price * item.goods_num) < min_value) {
                  prom.is_xz_yh = 0
                }
              } else {
                if (item.goods_num < min_value) {
                  prom.is_xz_yh = 0
                }
              }
            }
          }
        }

        if (!prom) return false;
        var ob = {};
        ob.prom_id = item.prom_id;
        ob.name = prom.name;

        //优惠促销取价的优化
        let f_price = item.goods_price;
        if (prom.discount_field != undefined) {
          switch (prom.discount_field) {
            case 0: f_price = item.goods_price; break;
            case 1: f_price = item.shop_price; break;
            case 2: f_price = item.goods_market_price; break;
          }
        }

        item.goods_price = f_price;

        ob.price = f_price * item.goods_num;
        ob.goods_num = item.goods_num;
        ob.is_bz = prom.is_bz;
        ob.is_xz_yh = prom.is_xz_yh;
        ob.is_xz_yh = prom.is_xz_yh;
        ob.is_order_yh = prom.is_order_yh;
        ob.is_post_temp = prom.is_post_temp;
        ob.discount_field = prom.discount_field;
        ob.goods = new Array();
        ob.goods.push({ goods_id: item.goods_id, goods_price: item.goods_price, goods_num: item.goods_num });
        map[pickid][item.prom_id] = ob;
      }
    } else {
      var ob = {};
      var prom = null;

      if (th.data.yhcx_act_map[item.prom_id]) {
        prom = th.data.yhcx_act_map[item.prom_id];
        let min_value = 0
        if (prom && prom.is_xz_yh) {
          let arr = prom.promGoodsList || []
          arr.map(ite => {
            if (min_value) {
              min_value = ite.condition
            } else {
              if (min_value < ite.condition) {
                min_value = ite.condition
              }
            }
          })
          if (arr.length > 0) {
            if (arr[0].prom_type == 0) {
              if ((item.goods_price * item.goods_num) < min_value) {
                prom.is_xz_yh = 0
              }
            } else {
              if (item.goods_num < min_value) {
                prom.is_xz_yh = 0
              }
            }
          }
        }
      }

      if (!prom) return false;
      //优惠促销取价的优化
      let f_price = item.goods_price;

      if (prom.discount_field != undefined) {
        switch (prom.discount_field) {
          case 0: f_price = item.goods_price; break;
          case 1: f_price = item.shop_price; break;
          case 2: f_price = item.goods_market_price; break;
        }
      }

      item.goods_price = f_price;

      ob.prom_id = item.prom_id;
      ob.name = prom.name;
      ob.price = f_price * item.goods_num;
      ob.goods_num = item.goods_num;
      ob.is_bz = prom.is_bz;
      ob.is_xz_yh = prom.is_xz_yh;
      ob.is_order_yh = prom.is_order_yh;
      ob.is_post_temp = prom.is_post_temp;
      ob.discount_field = prom.discount_field;
      ob.goods = new Array();
      ob.goods.push({ goods_id: item.goods_id, goods_price: item.goods_price, goods_num: item.goods_num });
      var obj = {};
      obj[item.prom_id] = ob;
      map[pickid] = obj;

    }
  },
  //---检查有没有优惠活动---
  check_is_youhui: function (r_data, pick_id) {
    let send_lb = this.data.send_lb;
    let lodash = null;

    r_data.forEach(item => {
      if (send_lb[pick_id]) {
        for (let i = 0; i < send_lb[pick_id].length; i++) {
          let sends = send_lb[pick_id][i];
          if (item.lb_id) {
            if (sends.id === item.lb_id) {
              sends['num']++;
            } else {
              let send_arr1 = send_lb[pick_id].filter(ii => ii.id === item.lb_id);
              if (send_arr1.length == 0) {
                if (item.lb_id) {
                  let ob = {};
                  ob.num = 1;
                  ob.title = item.lbtitle;
                  ob.id = item.lb_id;
                  lodash.push(ob);
                  // break;
                }
              }

            }
          }
          if (item.zxlb_id) {
            if (sends.id === item.zxlb_id) {
              sends['num']++;
            } else {
              let send_arr = send_lb[pick_id].filter(ii => ii.id === item.zxlb_id);
              if (send_arr.length == 0) {
                if (item.zxlb_id) {
                  let ob = {};
                  ob.num = 1;
                  ob.flag = 1;
                  ob.title = item.zxlbtitle;
                  ob.id = item.zxlb_id;
                  lodash.push(ob);
                  // break;
                }
              }
            }
          }
        }

      } else {
        let arr = new Array();
        if (item.lb_id) {
          let ob = {};
          ob.num = 1;
          ob.title = item.lbtitle;
          ob.id = item.lb_id;
          arr.push(ob);
        }
        if (item.zxlb_id) {
          let ob = {};
          ob.num = 1;
          ob.flag = 1;
          ob.title = item.zxlbtitle;
          ob.id = item.zxlb_id;
          arr.push(ob);
        }
        send_lb[pick_id] = arr;
        lodash = JSON.parse(JSON.stringify(send_lb[pick_id]));
      }
    })
    send_lb[pick_id] = lodash;
    th.setData({
      send_lb,
    })


  },

  //从优惠的映射中拿出商品从表的item
  item_map_get_goods: function (goods_id, map) {
    for (var i in map.goods) {
      if (map.goods[i].goods_id == goods_id) return map.goods[i];
    }
  },
  //从优惠的映射中拿出商品从表的item
  arr_get_goods: function (goods_id, arr) {
    for (var i in arr) {
      if (arr[i].goods_id == goods_id) return arr[i];
    }
    return {};
  },

  //从优惠的映射中拿出商品从表的item,要防止空对象的时候，空就返回空对象
  arr_get_goods_n: function (good, arr) {
    for (var i in arr) {
      if (arr[i].goods_id == good.goods_id && arr[i].prom_id == good.prom_id && arr[i].prom_type == good.prom_type) return arr[i];
    }
    return {};
  },


  //检查是不是有其他门店的订单在选择了券
  check_other_use: function (iter, pkid) {
    var using = this.data.using_quan;
    var is_use = 0;
    if (using) {
      for (var i in using) {
        if (i == pkid) continue;
        if (iter.CashRepNo == using[i].coupon_no) {
          is_use = 1;
          break;
        }
      }
    }
    return is_use;
  },
  //检查是不是有其他门店的订单在选择了包邮券
  check_other_use_by: function (iter, pkid) {
    var using = this.data.using_quan;
    var is_use = 0;
    if (using) {
      for (var i in using) {
        if (i == pkid) continue;
        if (iter.no == using[i].coupon_no) {
          is_use = 1;
          break;
        }
      }
    }
    return is_use;
  },

  //跳转到购买卡
  buycard: function () {
    getApp().goto("/pages/user/plus/plus");
    getApp().globalData.plus_buy_back = 1;
  },

  //跳转关闭弹出框的显示
  close_offline: function () {
    this.setData({ is_offline_show: 0 });
  },

  //立即购买显示弹出框
  bn_pop_offline: function () {
    var off_price = this.data.bn_goods.shop_price - this.data.bn_goods.offline_price;
    //是不是线下
    var is_get_offline = this.data.bn_goods.is_offline;
    this.setData({ is_offline_show: 1, show_off_price: off_price.toFixed(2), is_get_offline: is_get_offline });
  },

  // 促销 -> 送礼包 -> 查看详情
  viewLbDetails(e) {
    let id = e.currentTarget.dataset.id; // 获取礼包id
    let flag = e.currentTarget.dataset.flag;
    let url = '';

    if (flag == 2) { // flag =2 控制跳转到每月礼包
      // url = `/pages/giftpack/giftpacklist/giftpacklist?lbId=${id}&flag=1`;
      url = `/packageE/pages/user/monthgiftbag/giftpackinfo/giftpackinfo?isBuy=1&id=${id}&is_act=1`;
    } else if (flag == 1) {
      url = `/packageA/pages/myGiftDetails/myGiftDetails?btn=0&index=0&id=${id}`; // btn=0 控制跳转到的页面不显示按钮
    } else {
      url = `/packageF/pages/giftpack/giftpacklist/giftpacklist?lbId=${id}&flag=1`;
    };
    // console.log('myurl', url);
    getApp().goto(url);
  },

  //确定使用线下取价
  sure_offline: function () {
    var bn_goods = this.data.bn_goods;
    if (bn_goods && bn_goods.prom_type == 0) {
      bn_goods.is_offline = 1;
      this.setData({ is_offline_show: 0, bn_goods: bn_goods });
      this.calculatePrice2();
    }
    //就是购物车结算时的
    else {
      var index = this.data.pop_offline_index;
      var txt = "cartlist[" + index + "].is_offline";
      this.setData({ [txt]: 1, is_offline_show: 0, });
      this.data.old_cartlist[index].is_offline = 1;
      this.calculatePrice();
    }
  },

  //取消使用线下取价
  cancle_offline: function () {
    //判断是不是立即购买
    var bn_goods = this.data.bn_goods;
    if (bn_goods && bn_goods.prom_type == 0) {
      bn_goods.is_offline = 0;
      this.setData({ is_offline_show: 0, bn_goods: bn_goods });
      this.calculatePrice2();
    }
    //就是购物车结算时的
    else {
      var index = this.data.pop_offline_index;
      var txt = "cartlist[" + index + "].is_offline";
      this.setData({ [txt]: 0, is_offline_show: 0, })
      this.data.old_cartlist[index].is_offline = 0;
      this.calculatePrice();
    }
  },

  //-- 弹出购物车选择是不是要店铺优惠 --
  cart_pop_offline: function (e) {
    var index = e.currentTarget.dataset.index;
    var item = this.data.cartlist[index];
    var off_price = item.offline_price;
    //是不是线下
    var is_get_offline = item.is_offline;
    this.setData({
      pop_offline_index: index,
      is_offline_show: 1,
      show_off_price: off_price.toFixed(2),
      is_get_offline: is_get_offline
    });
  },

  go_url: function (e) {
    var url = e.currentTarget.dataset.url;
    getApp().goto(url);
  },

  //进行对商品的平摊g_item是单个商品，you_item是这个商品分多少优惠券的钱，goods是商品列表
  split_set_goods_quanprice: async function (you_item, t_item,is_quan_scj) {
    var coupon_price = you_item.WareCashSum;
    var goods = t_item.goods;
    var arr = [];

    if(!t_item.quan_no) t_item.quan_no=you_item.CashRepNo;

    //判断是不是有goods_id重复
    for (var i = 0; i < goods.length; i++) {

      if(is_quan_scj){
         let fd=t_item.scj_arr.find(function (e){
              return e.index==i && e.erpwareid==you_item.WareId;
         })
         //不是零售价的商品，就进入下一轮
         if(!fd) continue;
      }

      if (goods[i].erpwareid == you_item.WareId  && !goods[i].is_gift) {
        var gg_ite = {
          goods_id: goods[i].goods_id,
          goods_num: goods[i].goods_num,
          goods_price: goods[i].goods_price,
        };
        if (goods[i].account) gg_ite.goods_price = goods[i].account;
        gg_ite.idx = i; arr.push(gg_ite);
      }
    }

    if (arr.length <= 0) return false;
    if (arr.length == 1) {
      var idx = arr[0].idx;
      t_item.goods[idx].quan_num =coupon_price;
      t_item.goods[idx].quan_no = t_item.quan_no;
      return false;
    }

    var pt_data = {
      'dis': parseFloat(coupon_price),
      'goods': arr,
    }

    var pt_res = null;
    await getApp().request.promisePost("/api/weshop/order/getGoodsSplit", {
      is_json: 1,
      data: pt_data
    }).then(res => {
      if (res.data.code == 0) {
        pt_res = res.data.data;
      }
    })
    if (pt_res) {
      var q_s_num = 0;
      for (var i in pt_res) {
        var idx = pt_res[i].idx;
        //有account的实收价，就要用account实收价
        var price = (t_item.goods[idx].account ? t_item.goods[idx].account : t_item.goods[idx].goods_price);
        price = (price - pt_res[i].fisrt_account) * t_item.goods[idx].goods_num;
        t_item.goods[idx].quan_num = price;

        t_item.goods[idx].quan_num = Math.floor(t_item.goods[idx].quan_num * 100) / 100;
        t_item.goods[idx].quan_no = t_item.quan_no;
        q_s_num += t_item.goods[idx].quan_num;
      }

      if (q_s_num > parseFloat(coupon_price) || q_s_num < parseFloat(coupon_price)) {
        var pri = Math.floor(coupon_price * 100) / 100 - Math.floor(q_s_num * 100) / 100
        var is_ok = 0;
        for (var ik in arr) {
          if (arr[ik].goods_num == 1) {
            var id = arr[ik].idx;
            t_item.goods[id].quan_num += pri;
            is_ok = 1;
            break;
          }
        }
        if (!is_ok) {
          var id2 = arr[0].idx;
          t_item.goods[id2].quan_num += pri;
        }

      }
    }
  },

  //订阅消息提醒
  sendsm: function (func) {
    let th = this;
    var template_id = this.data.template_id;
    // //授权订阅
    wx.requestSubscribeMessage({
      tmplIds: template_id,
      success(res) {
        func();
      },
      fail(res) {
        func();
      }
    })

  },

  setexptype2: function (e) {

    if (this.data.submit) return false;
    this.setData({ submit: 1, same_ok: 1, sameCityExp_off: 0, sameCityExp_info: '',first_entry: 0 });

    if (this.data.all_collocation_list) {
      var bn_coll = this.selectComponent('#bn_coll');
      bn_coll.clear_sele();
      this.setData({ collocation_goods: [] });
      this.data.old_cartlist = null;
      //让主商品的活动变成5，搭配购
      if (this.data.bn_goods == 5)
        this.setData({ 'bn_goods.prom_type': 0, 'bn_goods.prom_id': 0 });
    }

    this.debounce(this.setexptype.bind(this, e), 400)();

  },

  setexptype_w2: function (e) {

    if (this.data.submit) return false;
    this.setData({ submit: 1, same_ok: 1, sameCityExp_off: 0, sameCityExp_info: '', first_entry:0});

    for (let i = 0; i < this.data.cartlist.length; i++) {


      var collocationList = this.data.cartlist[i].collocationList;
      if (collocationList) {

        var txt2 = 'cartlist[' + i + '].collocationList';
        for (let jy = 0; jy < collocationList.length; jy++) {
          collocationList[jy].selected = 0;
        }
        this.setData({ [txt2]: collocationList })


        var bn_coll = this.selectComponent("#col" + i);
        bn_coll.clear_sele();
        var goods = this.data.cartlist[i].goods;

        var g_arr = [];
        for (var j = 0; j < goods.length; j++) {
          if (goods[j].is_collocation) continue;
          g_arr.push(goods[j]);
        }

        var txt = 'cartlist[' + i + '].goods';

        this.setData({ [txt]: g_arr });
      }
    }

    this.data.old_cartlist = JSON.parse(JSON.stringify(this.data.cartlist));

    this.debounce(this.setexptype_w.bind(this, e), 400)();
  },

  // 函数防抖
  debounce: function (func, wait) {
    return () => {
      clearTimeout(timer);
      timer = setTimeout(func, wait);
    };
  },


  //-- 判断是不是选中 --
  check_th_item: function (e) {
    var th = this;
    var idx = e.currentTarget.dataset.item;
    var check = e.currentTarget.dataset.check;
    var txt = "giftsinfo[" + idx + "].selected";
    var gift_item = this.data.giftsinfo[idx];

    if (check) {
      th.setData({ [txt]: 0 });
    } else {

      var is_true = th.check_out_num_cart(gift_item, this.data.gift_pkid, gift_item.goods_num);
      if (!is_true) { return false; }

      th.setData({ [txt]: 1 });
    }
  },


  //输入框输入数量的时候
  valueToNum: function (e) {
    var th = this;
    var idx = e.currentTarget.dataset.item;
    var gift_item = this.data.giftsinfo[idx];
    var num = parseInt(e.detail.value);
    var txt = "giftsinfo[" + idx + "].goods_num";
    var is_true = th.check_out_num_cart(gift_item, this.data.gift_pkid, num);
    if (!is_true) {
      th.setData({ [txt]: 1 });
      return false;
    }
    th.setData({ [txt]: num });

  },



  addNum: function (e) {
    var th = this;
    var idx = e.currentTarget.dataset.item;
    var txt = "giftsinfo[" + idx + "].goods_num";
    var num = th.data.giftsinfo[idx].goods_num + 1;
    var gift_item = this.data.giftsinfo[idx];
    var is_true = th.check_out_num_cart(gift_item, this.data.gift_pkid, num);
    if (!is_true) { return false; }
    th.setData({ [txt]: num });
  },

  subNum: function (e) {
    var th = this;
    var idx = e.currentTarget.dataset.item;
    var txt = "giftsinfo[" + idx + "].goods_num";
    var num = th.data.giftsinfo[idx].goods_num - 1;
    var gift_item = this.data.giftsinfo[idx];
    var is_true = th.check_out_num_cart(gift_item, this.data.gift_pkid, num);
    if (!is_true) {
      return false;
    }
    if (num < 1) return false;
    th.setData({ [txt]: num });
  },

  //-- 点击选中赠品 --
  show_sele_gift: function (e) {
    var index = e.currentTarget.dataset.index;
    var pk = e.currentTarget.dataset.pk;
    var giftsinfo = this.data.send_gf[pk][index].giftsinfo;

    for (let i in giftsinfo) {
      let item = giftsinfo[i];
      if (!item.goods_num) giftsinfo[i].goods_num = 1;
    }

    this.setData({
      show_duo_gift: 1,
      giftsinfo: giftsinfo,
      gf_pr_name: this.data.send_gf[pk][index].gf_pr_name,
      zp_num: this.data.send_gf[pk][index].zp_num,
      gift_pkid: pk,
      gf_prom_id: this.data.send_gf[pk][index].prom_id,
      send_gf_index: index,
      gf_bs: this.data.send_gf[pk][index].bs
    })
  },

  close_sele_gift: function () {
    this.setData({ show_duo_gift: 0 })
  },

  //购物车赠品有咩有超出库存。有灭有超出限购
  check_out_num_cart: function (discount, pick_id, num) {
    var prom_id = discount.prom_id;
    var alllist = this.data.cartlist;
    var all_num = num;
    var all_limit_num = num;
    var gift_id = discount.gift_id;
    for (var i in alllist) {
      var list_item = alllist[i];
      //-- 门店相同，活动相同的时候,就continue掉 --
      if (pick_id == list_item.pickup_id && prom_id == list_item.prom_id) continue;
      for (var j in list_item.goods) {
        //如果赠品的ID一样，要进行统计数量
        if (list_item.goods[j].is_gift == 1 &&
          list_item.goods[j].gift_id == gift_id) {
          all_num += list_item.goods[j].goods_num;
        }
        if (list_item.goods[j].is_gift == 1 && list_item.goods[j].gift_id == gift_id && list_item.goods[j].prom_id == prom_id) {
          all_limit_num += list_item.goods[j].goods_num;
        }
      }
    }
    //-- 赠品的数量超出库存数量和会员的限制,
    // 这里是保证所有的赠品部会超出 --
    if (discount.gift_storecount < all_num) {
      wx.showToast({
        title: "赠品库存不足",
        icon: 'none',
        duration: 2000
      });
      return false;
    }
    //-- 限购一定要大于0，否则就是不限的意思 --
    if (discount.limit_num > 0 && discount.can_num < all_limit_num) {
      wx.showToast({
        title: "超出赠品限购",
        icon: 'none',
        duration: 2000
      });
      return false;
    }
    return true;
  },

  //-- 确定赠品 --
  sure_this_gift: async function () {
    var th = this;
    var gf_pickup_id = this.data.gift_pkid;
    //包邮券要重新获取
    th.data.isget_by_quan[gf_pickup_id] = null;

    var zp_num = this.data.zp_num;
    var gf_bs = this.data.gf_bs ? this.data.gf_bs : 1;

    var giftsinfo = this.data.giftsinfo;
    var all_num = 0;
    for (let i in giftsinfo) {
      let item = giftsinfo[i];
      if (item.must_num > 0) {
        if (!item.selected) {
          ut.m_toast("必送的赠品没有选中");
          return false;
        }
        if (item.goods_num < item.must_num * gf_bs) {
          ut.m_toast(item.goods_name + "赠品的数量需选" + item.must_num * gf_bs + "件");
          return false;
        }
      }
      if (!item.selected) continue;
      all_num += item.goods_num;
    }
    if (all_num > zp_num) {
      wx.showToast({
        title: "超出活动赠品赠送的数量" + zp_num + "件",
        icon: 'none',
        duration: 2000
      });
      return false;
    }
    if (all_num < zp_num) {
      wx.showToast({
        title: "您还可以加" + (zp_num - all_num) + "件",
        icon: 'none',
        duration: 2000
      });
      return false;
    }

    //-- 当是购物车购买的时候 --
    if (this.data.cartlist && this.data.cartlist.length > 0) {
      var alllist = this.data.cartlist;
      var index = alllist.findIndex(function (e) {
        return e.pickup_id == gf_pickup_id
      });
      var pk_list_goods = alllist[index].goods;


      var pos = this.find_pro_last(pk_list_goods, 3, this.data.gf_prom_id);
      var fd_gd = pk_list_goods[pos]

      var url = "/api/weshop/cart/delGift?store_id=" + os.stoid + "&user_id="
        + getApp().globalData.user_id + "&is_gift=1&pick_id=" + this.data.gift_pkid + "&prom_id=" + this.data.gf_prom_id;
      await getApp().request.promiseDelete(url, {});

      var new_pk_list_goods = [];
      for (let i in pk_list_goods) {
        let item = pk_list_goods[i];
        if (item.is_gift && item.prom_id == this.data.gf_prom_id) {
          continue;
        }
        new_pk_list_goods.push(item)
      }

      var set_data = this.data.send_gf[gf_pickup_id][this.data.send_gf_index];

      //-- 循环把赠品添加进去 --
      for (var i = 0; i < giftsinfo.length; i++) {
        var gf_item = giftsinfo[i];
        if (!gf_item.selected) continue;
        var add_data = null;
        var newd = {
          goods_id: gf_item.goodsinfo.goods_id,
          goods_num: gf_item.goods_num,
          pick_id: gf_pickup_id,
          user_id: app.globalData.user_id,
          store_id: os.stoid,
          goods_price: 0,
          member_goods_price: 0,
          goods_name: gf_item.goodsinfo.goods_name,
          goods_sn: gf_item.goodsinfo.goods_sn,
          sku: gf_item.goodsinfo.sku,
          is_gift: 1,
          prom_id: th.data.gf_prom_id,
          prom_type: 3,
          selected: 1,
          gift_id: gf_item.gift_id,
          original_img: th.data.imgUrl + gf_item.goodsinfo.original_img,
          exp_sum_type: gf_item.goodsinfo.exp_sum_type,
          is_free_shipping: gf_item.goodsinfo.is_free_shipping,
          weight: gf_item.goodsinfo.weight,
          uniform_exp_sum: gf_item.goodsinfo.uniform_exp_sum,
          goods_spec: gf_item.goodsinfo.goods_spec,
          goods_color: gf_item.goodsinfo.goods_color,
        };

        var prom_goods_map = th.data.prom_goods_map[gf_pickup_id];
        var fd = prom_goods_map[th.data.gf_prom_id];

        if (fd) {
          //newd.is_past=fd.is_past;
          newd.is_xz_yh = fd.is_xz_yh;
          //赠品包邮的优化
          if (set_data.zp_by && set_data.zp_by > 0) {
            newd.is_past = 1;
          }

        }

        //赠品的优惠要和商品的一样
        if (fd_gd) {
          newd.is_post_temp = fd_gd.is_post_temp;
          newd.is_order_yh = fd_gd.is_order_yh;
        }

        //-- 如果是代发商品的时候 --
        if (gf_item.goodsinfo.whsle_id) {
          newd.whsle_id = gf_item.goodsinfo.whsle_id;
        }
        await getApp().request.promisePost("/api/weshop/cart/save", {
          data: newd
        }).then(res => {
          if (res.data.code == 0) {
            add_data = res.data.data;
          }
        })
        if (add_data) {
          newd.id = add_data.id;
          new_pk_list_goods.push(newd);
        }
      }


      set_data.selected = 1;
      var txt9 = "cartlist[" + index + "].goods";

      th.setData({ [txt9]: new_pk_list_goods, send_gf: this.data.send_gf });
      this.data.old_cartlist[index].goods = new_pk_list_goods;

      console.log(this.data.send_gf, "----");
      th.calculatePrice();

    } else {
      var new_pk_list_goods = [];
      //-- 当是立即购买的时候 --
      for (var i = 0; i < giftsinfo.length; i++) {
        var gf_item = giftsinfo[i];
        if (!gf_item.selected) continue;
        var newd = {
          goods_id: gf_item.goodsinfo.goods_id,
          buynum: gf_item.goods_num,
          pick_id: gf_pickup_id,
          user_id: app.globalData.user_id,
          store_id: os.stoid,
          goods_price: 0,
          member_goods_price: 0,
          goods_name: gf_item.goodsinfo.goods_name,
          goods_sn: gf_item.goodsinfo.goods_sn,
          sku: gf_item.goodsinfo.sku,
          is_gift: 1,
          prom_id: th.data.gf_prom_id,
          prom_type: 3,
          selected: 1,
          gift_id: gf_item.gift_id,
          original_img: th.data.imgUrl + gf_item.goodsinfo.original_img,
          exp_sum_type: gf_item.goodsinfo.exp_sum_type,
          is_free_shipping: gf_item.goodsinfo.is_free_shipping,
          weight: gf_item.goodsinfo.weight,
          uniform_exp_sum: gf_item.goodsinfo.uniform_exp_sum,
          uniform_exp_sum: gf_item.goodsinfo.uniform_exp_sum,
          goods_spec: gf_item.goodsinfo.goods_spec,
          goods_color: gf_item.goodsinfo.goods_color,
        };
        //-- 如果是代发商品的时候 --
        if (gf_item.goodsinfo.whsle_id) {
          newd.whsle_id = gf_item.goodsinfo.whsle_id;
        }

        new_pk_list_goods.push(newd);
      }
      var set_data = this.data.send_gf[th.data.bn_pick][this.data.send_gf_index];
      set_data.selected = 1;
      var txt1 = "send_gf[" + gf_pickup_id + "][" + this.data.send_gf_index + "]";

      th.setData({ buy_now_gift_goods: new_pk_list_goods, [txt1]: set_data });
      th.calculatePrice2();

    }
    th.close_sele_gift();
  },

  //获取输入
  getInput: function (e) {
    this.data.gift_sear = e.detail.value;
  },
  //-- 搜索赠品 --
  submitSearch: function () {
    var giftsinfo = this.data.giftsinfo;
    if (!this.data.gift_sear) {
      for (let i in giftsinfo) {
        let item = giftsinfo[i];
        item.hide_div = 0;
      }
    } else {
      for (let i in giftsinfo) {
        let item = giftsinfo[i];
        item.hide_div = 0;
        if (item.goods_name.indexOf(this.data.gift_sear) == -1) {
          item.hide_div = 1;
        }
      }
    }
    this.setData({ giftsinfo: giftsinfo })

  },

  //-- 赠品的验证 --
  sub_check_gift(func) {
    var th = this;
    if (th.data.send_gf) {
      var error_arr = [];
      for (let io in th.data.send_gf) {
        let item_arr = th.data.send_gf[io];
        for (let ip in item_arr) {
          var gf_pr_name = item_arr[ip].gf_pr_name;
          var zp_num = item_arr[ip].zp_num;
          var giftsinfo = item_arr[ip].giftsinfo;

          var limit_all = 0;
          var stock_all = 0;
          var no_limit = 0;

          for (let iu in giftsinfo) {
            let gf_item = giftsinfo[iu];
            limit_all += gf_item.can_num > 0 ? gf_item.can_num : 0;
            stock_all += gf_item.gift_storecount;
            if (gf_item.limit_num <= 0) no_limit = 1;
          }
          if (!no_limit && limit_all < zp_num) {
            error_arr.push(gf_pr_name + "限购不足");
          }
          if (stock_all < zp_num) {
            error_arr.push(gf_pr_name + "赠品库存不足");
          }
        }
      }

      //-- 有赠品错误的时候，是不是继续下单 --
      if (error_arr.length) {
        var err = error_arr.join(",");
        wx.showModal({
          title: '提示',
          content: err + '，无法赠送赠品，是否继续下单',
          success(res) {
            if (res.confirm) {
              func();
            } else if (res.cancel) {
              console.log('用户点击取消');
              th.setData({
                submit: 0,
              })
            }
          }
        })
      } else {

        var is_ok = 1;
        var error_arr = [];
        for (let io in th.data.send_gf) {
          let item_arr1 = th.data.send_gf[io];
          for (let ip1 in item_arr1) {
            var item_b = item_arr1[ip1];
            if (!item_b.selected) {
              is_ok = 0;
              break;
            }
          }
          if (!is_ok) break;
        }

        if (!is_ok) {
          getApp().confirmBox("请选择赠品");
          th.setData({
            submit: 0,
          })
          return false;
        }
        func();
      }


    } else {
      func();
    }
  },

  //子组件返回的优化
  select_coll(e) {
    console.log("--1111--aaa--");
    console.log(e);

    //-- 如果是购物车的选择添加搭配商品 --
    if (e.detail.is_cart == 1) {
      this.select_coll_buy_cart(e.detail);
    } else {
      this.select_coll_buy_now(e.detail);
    }
  },

  //立即购买的时候，选中和不选中搭配商品
  async select_coll_buy_now(e) {
    var th = this;
    //--按钮变灰色 --
    th.setData({ submit: 1 });
    var txt = 'using_quan[' + th.data.bn_pick + ']';
    th.setData({ [txt]: null })

    //如果是选中
    if (e.selected) {
      var item = this.data.all_collocation_list[e.index];

      //如果是自提的时候
      if (this.data.bn_exp_type == 1) {

        if (item.distr_type == 2) {
          wx.showToast({
            title: "商品的配送方式不一致",
            icon: 'none',
            duration: 2000
          })
          th.setData({ submit: 0 });
          return false;
        }

      } else {

        if (this.data.bn_exp_type == 2) {

          if (!item.is_same_city) {
            wx.showToast({
              title: "商品不支持同城配送",
              icon: 'none',
              duration: 2000
            })
            th.setData({ submit: 0 });
            return false;
          }

        } else {
          if (item.distr_type == 1) {
            wx.showToast({
              title: "商品的配送方式不一致",
              icon: 'none',
              duration: 2000
            })
            th.setData({ submit: 0 });
            return false;
          }
        }
      }

      var bn_coll = th.selectComponent("#bn_coll"); //组件的id
      bn_coll.set_sele(e.index);

      item.goods_num = 1;
      item.goods_price = item.price;
      item.is_collocation = 1;
      item.prom_type = 5;
      item.is_post_temp = 1;


      th.setData({ is_coupon: item.is_coupon })


      var coll_arr = [];
      if (this.data.collocation_goods && this.data.collocation_goods.length) {
        coll_arr = this.data.collocation_goods;
      }
      coll_arr.push(item);
      this.setData({ collocation_goods: coll_arr });
      //让主商品的活动变成5，搭配购
      this.setData({ 'bn_goods.prom_type': 5, 'bn_goods.prom_id': coll_arr[0].prom_id });

      var is_has_main = coll_arr.findIndex(function (e) {
        return e.goods_id == th.data.bn_goods.goods_id;
      })

      //要进行深拷贝
      var coll_arr_new = JSON.parse(JSON.stringify(coll_arr));
      coll_arr_new.unshift(this.data.bn_goods);

      await th.get_collocation_list(coll_arr_new);
      //计算价格
      th.calculatePrice2();
      th.get_cart_quan();

    } else {

      var item = this.data.all_collocation_list[e.index];

      th.setData({ is_coupon: item.is_coupon })

      var coll_arr = this.data.collocation_goods;
      var find = coll_arr.findIndex(function (e) {
        return e.goods_id == item.goods_id;
      })
      coll_arr.splice(find, 1);

      //当coll_arr的长度等于1的时候，说明没有选中搭配商品，只有主商品了
      if (!coll_arr || coll_arr.length < 1) {
        //让主商品的活动变成0,取消搭配购
        this.setData({ 'bn_goods.prom_type': 0, 'bn_goods.prom_id': 0, collocation_goods: [] });

        th.setData({ is_coupon: 1 })

        //计算价格
        th.calculatePrice2();
        //获取优惠券
        th.get_buy_now_quan();



      } else {
        this.setData({ collocation_goods: coll_arr });
        //要进行深拷贝
        var coll_arr_new = JSON.parse(JSON.stringify(coll_arr));
        coll_arr_new.unshift(this.data.bn_goods);
        await th.get_collocation_list(coll_arr_new);
        //计算价格
        th.calculatePrice2();
        th.get_cart_quan();
      }
    }
  },

  //购物车购买的时候，选中和不选中搭配商品
  async select_coll_buy_cart(e) {
    var th = this;
    var cart_index = e.cart_index;
    var index = e.index;

    var collocationList = this.data.cartlist[cart_index].collocationList;
    var item = JSON.parse(JSON.stringify(collocationList[index]));


    var goods = this.data.cartlist[cart_index].goods;
    var txt = 'cartlist[' + cart_index + '].goods';
    var txt2 = 'cartlist[' + cart_index + '].collocationList[' + index + '].selected';

    //有改，都强制把券选择清理一下
    var pickup_id = this.data.cartlist[cart_index].pickup_id;
    var txt1 = 'using_quan[' + pickup_id + ']';
    th.setData({ [txt1]: null });

    //-- 如果是选中 --
    if (e.selected) {

      var m_cartlist = this.data.old_cartlist;
      if (this.data.order_prom_list_cart) {
        m_cartlist = this.data.order_prom_list_cart;
      }

      var exp_type = m_cartlist[cart_index].exp_type; //配送方式
      //如果是自提的时候
      if (exp_type == 1) {

        if (item.distr_type == 2) {
          wx.showToast({
            title: "商品的配送方式不一致",
            icon: 'none',
            duration: 2000
          })
          return false;
        }

      } else {

        if (exp_type == 2) {

          if (!item.is_same_city) {
            wx.showToast({
              title: "商品不支持同城配送",
              icon: 'none',
              duration: 2000
            })
            th.setData({ submit: 0 });
            return false;
          }

        } else {

          if (item.distr_type == 1) {
            wx.showToast({
              title: "商品的配送方式不一致",
              icon: 'none',
              duration: 2000
            })
            return false;
          }
        }
      }

      //promise_get.  看一下有没有指定门店的限制
      let gd = null
      let gd_rs = await getApp().promiseGet('/api/weshop/goods/get/' + os.stoid + "/" + item.goods_id, {})
      if (gd_rs && gd_rs.data.code == 0 && gd_rs.data.data) {
        gd = gd_rs.data.data;
      }

      if (gd.pick_group_ids) {
        var idx0 = gd.pick_up_lists.findIndex(function (e) {
          return e.pickup_id == pickup_id;
        })
        if (idx0 < 0) {
          wx.showToast({
            title: item.goods_name + "的门店不可售",
            icon: 'none',
            duration: 2000
          })
          return false;
        }
      }


      var bn_coll = th.selectComponent("#col" + cart_index); //组件的id
      bn_coll.set_sele(index);

      item.goods_num = 1;
      item.goods_price = item.price;
      item.goods_market_price = gd.market_price;

      item.prom_type = 5;
      item.is_collocation = 1;
      item.is_post_temp = 1;
      if (!item.original_img) item.original_img = 1;
      else item.original_img = th.data.imgUrl + item.original_img;

      goods.push(item);

      th.setData({ [txt]: goods, [txt2]: 1 });

      th.data.old_cartlist = JSON.parse(JSON.stringify(this.data.cartlist));
      th.calculatePrice();
      //th.get_cart_quan();

    } else {
      var fd = goods.findIndex(function (e) {
        return e.goods_id == item.goods_id && e.prom_type == 5;
      })

      goods.splice(fd, 1);
      th.setData({ [txt]: goods, [txt2]: 0 });
      th.data.old_cartlist = JSON.parse(JSON.stringify(this.data.cartlist));

      th.calculatePrice();
      //th.get_cart_quan();
    }
  },

  //-- 搭配购的获取搭配商品的购物车计算价格的数组格式 --
  async get_collocation_list(narr) {
    var gg = to.get_b_now();
    var th = this;
    var cart_arr = new Array();
    //-- 搭配促销的门店配送方式的修复 --
    var et = 1;
    var distr_t = 0; // 配送方式 0=用户自选 1=自提 2=物流
    for (var hi in narr) {

      narr[hi].is_post_temp = 1;  //-- 固定都是参与包邮模板 --
      var dis_t = narr[hi].distr_type;
      if (dis_t == 2) {
        th.setData({ is_all_zt: 0 });
        et = 0;
      }
      if (dis_t > 0) {
        distr_t = dis_t;
      }

      //-- 如果有一件代发的商品或者不是同城配送的配送 --
      if (narr[hi].is_same_city != 1 || narr[hi].whsle_id > 0) {
        //th.setData({ show_same_city: 0 })
      }

    }
    //自选的时候，系统配置了默认的配送方式是物流的时候
    if (distr_t == 0 && th.data.json_d.pickupway && th.data.json_d.pickupway == 1) {
      et = 0; th.setData({ is_all_zt: 0 });
    }

    //-- 如果是同城配送和默认同城配送的时候 --
    if (th.data.show_same_city == 1 && th.data.json_d.pickupway && th.data.json_d.pickupway == 2) {
      et = 2; th.setData({ is_all_zt: 0 });
    }



    var m_wind = th.data.m_wind;
    var ie = {
      pickup_id: gg.pick_id,
      pname: gg.pick_name,
      goods: narr,
      exp_type: et,
      wind: m_wind,
      distr_t: distr_t,
      bn_t_exp_t: distr_t,
      goods_price: 0,
      shipping_price: 0,
      user_money: 0,
      total_amount: 0,
      order_amount: 0,
      user_note: ""
    };

    var cart_commission = 0;
    //-- 循环计算一下线下取价 --
    //计算佣金的商品
    var commission_gds = [];
    for (var c = 0; c < narr.length; c++) {
      var hr = {
        goods_id: narr[c].goods_id,
        goods_num: narr[c].goods_num,
        prom_type: 0,
        prom_id: 0,
      }
      commission_gds.push(hr);

    }

    //获取购物车的佣金,此处要优化调用接口，获取佣金
    var req_d = {
      user_id: getApp().globalData.user_id, goods_ids: commission_gds, store_id: os.stoid
    }
    var back_data = null;
    await getApp().request.promisePost("/api/weshop/order/getrebateSum", {
      is_json: 1, data: req_d
    }).then(rs => {
      if (rs.data.code == 0) back_data = rs.data.data;
    });

    if (back_data && parseFloat(back_data)) {
      ie.can_usecommise = parseFloat(parseFloat(back_data).toFixed(2));
      cart_commission = ie.can_usecommise;
    }

    cart_arr.push(ie);
    if (cart_commission) {
      th.setData({ cart_commission });
    }
    th.data.old_cartlist = cart_arr;
  },

  //-- 获取到搭配 --
  has_dp: function (list, prom_id) {
    for (let i in list) {
      var it = list[i];
      if (it.prom_id == prom_id && it.is_collocation == 1) {
        return true;
      }
    }
    return false;
  },


  //-- 开始显示活动的弹出 --
  switch_cx_group: function (e) {
    var idx = e.currentTarget.dataset.index;
    var gd_key = e.currentTarget.dataset.gd_key;
    this.data.sele_cx_group_cidx = idx;
    this.data.cx_group_gd_key = gd_key;
    //-- 获取到--
    var cx_prom_group = this.data.cartlist[idx].show_can_cx[gd_key].act_arr;

    var cx_arr = [];
    for (var h = 0; h < cx_prom_group.length; h++) {
      cx_prom_group[h].act.sele = 0;
      //-- 看有没有选中的活动 --
      if (cx_prom_group[h].sele) {
        cx_prom_group[h].act.sele = 1;
      }
      cx_arr.push(cx_prom_group[h].act);
    }
    //-- 如果没有，就默认第一个为选中 --
    //-- if(!find_sele) cx_arr[0].sele=1; --
    var cp_arr = JSON.parse(JSON.stringify(cx_arr));
    var pro_pop = this.selectComponent("#pro_pop"); //组件的id
    pro_pop.set_init(1, cp_arr);
  },


  //--- 选择回来时候的选择 ---
  sure_cx_group: function (e) {
    var th = this;
    //选中的活动类型
    var sele_prom_type = e.detail.sele_prom_type;
    //-- 获取到当前的show_can_cx--
    var idx = this.data.sele_cx_group_cidx;
    var gd_key = this.data.cx_group_gd_key;
    var pk = this.data.cartlist[idx].pickup_id;
    var cx_prom_group2 = th.data.show_can_cx_map[pk][gd_key].act_arr;

    var cx_prom_group = this.data.cartlist[idx].show_can_cx[gd_key].act_arr;

    //-- 切换活动的时候，让订单促销参与不选中 --
    let tt_wd = "can_use_ord_prom[" + pk + "]";

    let  using_quan =this.data.using_quan;
    using_quan[pk]={};

    th.setData({
      send_lb: {},
      month_lb: {},
      send_gf: {},
      [tt_wd]: 0,
      using_quan:using_quan
    })

    th.data.prom_goods_map = {};
    //-- 包邮券要重新获取 --
    th.data.isget_by_quan[pk] = null;

    //-- 获取第一次选中的 --
    var fir_sele = 0;
    for (var dx = 0; dx < cx_prom_group.length; dx++) {
      if (cx_prom_group[dx].sele) fir_sele = dx;
      //如果活动不是选择的
      if (cx_prom_group[dx].prom_type != sele_prom_type) cx_prom_group[dx].sele = 0;
      else cx_prom_group[dx].sele = 1;

      if (cx_prom_group2[dx].prom_type != sele_prom_type) cx_prom_group2[dx].sele = 0;
      else cx_prom_group2[dx].sele = 1;
    }
    //选择后就要把活动确定下来
    //确定一下活动,先看一下有没有选择的活动
    var ck_prom_type = cx_prom_group.find(function (el) {
      return el.sele;
    })
    var ck_prom_type2 = cx_prom_group2.find(function (el) {
      return el.sele;
    })

    this.cx_check_ok2(function (ck_res) {

      if (ck_res.code == 0) {
        th.data.cartlist[idx].show_can_cx[gd_key].sele_prom_type = ck_prom_type.prom_type;
        th.data.cartlist[idx].show_can_cx[gd_key].cur_act = ck_prom_type;

        var goods0 = JSON.parse(JSON.stringify(th.data.cartlist_y));
        var goods = [];
        for (var ik = 0; ik < goods0.length; ik++) {
          var item_c = goods0[ik];
          if (item_c.pick_id == pk && item_c.is_collocation) continue;
          goods.push(item_c);
        }

        //-- 此时要把购物车中的商品确定活动 --
        for (var b = 0; b < ck_prom_type2.goods.length; b++) {
          //-- 开始查找 --
          var fg = goods.findIndex(function (g_item) {
            return g_item.goods_id == ck_prom_type2.goods[b].goods_id
              && [0, 3, 5, 7, 10].indexOf(g_item.prom_type) > -1
              && g_item.pick_id == pk && g_item.is_gift == 0;
          })
          if (fg > -1) {
            goods[fg].prom_type = ck_prom_type.prom_type;
            goods[fg].prom_id = ck_prom_type.prom_id;

            //如果是不参与的话，商品的活动状态要清理
            if (th.data.cartlist[idx].show_can_cx[gd_key].no_cj_prom && ck_prom_type.prom_type == 3) {
              goods[fg].prom_type = 0;
              goods[fg].prom_id = 0;
            }

            for (var ik = 0; ik < th.data.cartlist[idx].goods.length; ik++) {
              if (th.data.cartlist[idx].goods[ik].id == goods[fg].id) {
                th.data.cartlist[idx].goods[ik].prom_type = goods[fg].prom_type;
                th.data.cartlist[idx].goods[ik].prom_id = goods[fg].prom_id;
              }
            }

            //原始数据要有深拷贝不能有地址的牵连
            th.data.cartlist_y = JSON.parse(JSON.stringify(goods))
          }
        }

        wx.showLoading({
          title: "处理中.",
          mask: true
        })
        //-- 重新计算一下价格 --
        th.get_cart_next(null, 1, cx_prom_group[fir_sele]);
      } else {
        wx.showToast({
          title: ck_res.msg,
          icon: 'none',
          duration: 2500
        });

        for (var dx = 0; dx < cx_prom_group.length; dx++) {
          if (dx != fir_sele) cx_prom_group[dx].sele = 0;
          else cx_prom_group[dx].sele = 1;
        }
      }
    })

  },


  //--- 在点击商品和或者门店的时候调用,这个可以在活动切换的时候调用，也可以被单个选择调用---
  async cx_check_ok2(func, car) {
    //如果购物车没有带入，要进行赋值
    if (!car) {
      car = JSON.parse(JSON.stringify(this.data.cartlist));
    }

    var nei_in_zhact_gdmap = {};
    var nei_in_zhact = {};
    var nei_in_yhact = {};
    for (var i = 0; i < car.length; i++) {
      var show_can_cx = car[i].show_can_cx;
      for (var j in show_can_cx) {
        var sele_act = show_can_cx[j].act_arr.find(function (m) {
          return m.sele == 1;
        })

        if (!sele_act) continue;
        var pid = sele_act['prom_id'];
        if (sele_act['prom_type'] == 3) {
          if (!nei_in_yhact[pid]) nei_in_yhact[pid] = 0;
          nei_in_yhact[pid]++;
        }
        if (sele_act['prom_type'] == 7) {
          if (!nei_in_zhact[pid]) nei_in_zhact[pid] = 0;
          nei_in_zhact[pid] += sele_act['act_num'];
        }
        var in_zhact_gdmap1 = sele_act['in_zhact_gdmap'];
        for (var vg in in_zhact_gdmap1) {
          if (!nei_in_zhact_gdmap[vg]) nei_in_zhact_gdmap[vg] = 0;
          nei_in_zhact_gdmap[vg] += in_zhact_gdmap1[vg];
        }
      }
    }

    //-- 判断优惠促销是不是超出限购 --
    if (nei_in_yhact && Object.keys(nei_in_yhact).length) {
      for (var ky0 in nei_in_yhact) {
        var num = nei_in_yhact[ky0];

        var fd = null;
        var fd_res = await getApp().request.promiseGet('/api/weshop/promgoods/get/' + os.stoid + '/' + ky0, {})
        if (fd_res && fd_res.data.code == 0) {
          fd = fd_res.data.data;
        }
        if (fd && fd['limit_num'] > 0 && num > fd['limit_num']) {
          func({ 'code': -1, 'msg': '超出优惠促销活动的限购' });
          return false;
        }
      }
    }

    //-- 判断组合促销是不是超出活动总数量 --
    if (nei_in_zhact && Object.keys(nei_in_zhact).length) {
      for (var ky in nei_in_zhact) {

        var num0 = nei_in_zhact[ky];
        var zh = this.data.zhhe_act_map[ky];
        var buyed = 0;

        //获取已经购买了多少件
        var z_url = "/api/weshop/ordergoods/getUserBuyPromNum?store_id=" + os.stoid + "user_id=" + getApp().globalData.user_id + "prom_type=7&prom_id=" + ky;
        var zbuy = await getApp().request.promiseGet(z_url, {});
        if (zbuy && zbuy.data.code == 0) {
          buyed = zbuy.data.data.userbuynum;
        }
        if (zh['zh_num'] > 0 && zh['zh_buy_num'] + num0 > zh['zh_num']) {
          //func({'code': -1, 'msg': '超出组合购活动总数量'});
          //return false;
        }

        if (zh && zh['buy_limit'] > 0 && num0 + buyed > zh['buy_limit']) {
          //func({'code': -1, 'msg': '超出超出组合购活动的限购'});
          //return false;
        }

      }
    }

    //-- 判断组合促销是不是超出活动总数量 --
    if (nei_in_zhact_gdmap && Object.keys(nei_in_zhact_gdmap).length) {
      for (var key in nei_in_zhact_gdmap) {

        var num1 = nei_in_zhact_gdmap[key];
        var key_a = key.split('.');
        var gid = key_a[0];
        var pid = key_a[1];

        //-- 商品的限购 --
        var promgoodsbuynum = 0;
        var rq = {
          'store_id': os.stoid, 'user_id': getApp().globalData.user_id, 'goods_id': gid,
          'prom_type': 7, 'prom_id': pid, isnew: 1
        };

        var res = await getApp().request.promiseGet("/api/weshop/ordergoods/getUserBuyGoodsNum", { data: rq });
        if (res && res.data.code == 0) {
          promgoodsbuynum = res.data.data.promgoodsbuynum;
        }

        var gdlist_arr = this.data.zuhe_map_good[pid];
        var gdlist = gdlist_arr.find(function (e) {
          return e.goods_id == gid;
        })
        if (gdlist['buyqty'] > 0 && num1 + promgoodsbuynum > gdlist['buyqty']) {
          //func({'code': -1, 'msg': '超出组合购商品的限购'});
          //return false;
        }
      }
    }
    func({ 'code': 0, 'msg': '成功' })
  },

  //--- 不参与优惠促销的开关 ---
  no_cj_prom: function (e) {
    //避免重复点击
    if (this.data.submit) return false;
    this.setData({ submit: 1, same_ok: 1 });

    //重新调用cart_next,进行下一步计算
    wx.showLoading({
      title: "处理中.",
    })

    this.setData({
      send_lb: {},
      month_lb: {},
      send_gf: {}
    })


    //清空优惠促销的内容
    this.data.prom_goods_map = {};

    let th = this;
    let can_cx_idx = e.currentTarget.dataset.can_cx_idx;  //多促销的索引
    let pidx = e.currentTarget.dataset.pidx;  //订单索引
    let item = this.data.cartlist[pidx].show_can_cx[can_cx_idx];  //促销内容
    let pk = this.data.cartlist[pidx].pickup_id;  //门店ID

    //获取到后台计算多促销的数据
    var cx_prom_group2 = this.data.show_can_cx_map[pk][can_cx_idx].act_arr;

    //给no_cj_prom进行赋值
    item.no_cj_prom = !item.no_cj_prom ? 1 : 0;
    var txt = 'cartlist[' + pidx + '].show_can_cx';
    this.setData({
      [txt]: this.data.cartlist[pidx].show_can_cx,
    })

    //使用深拷贝，生成临时的变量
    let ck_prom_type = ut.deep_cp(item.cur_act);
    var f_act = cx_prom_group2.find(function (ite) {
      return ite.prom_type == ck_prom_type.prom_type
    })
    if (!ck_prom_type || !f_act) {
      ut.m_toast('未找到活动');
    }
    ck_prom_type.goods = f_act.goods;

    //处理一下商品
    let goods0 = JSON.parse(JSON.stringify(th.data.cartlist_y));
    let goods = [];
    for (var ik = 0; ik < goods0.length; ik++) {
      var item_c = goods0[ik];
      if (item_c.pick_id == pk && item_c.is_collocation) continue;
      goods.push(item_c);
    }

    //-- 此时要把购物车中的商品确定活动 --
    for (var b = 0; b < ck_prom_type.goods.length; b++) {
      //-- 开始查找 --
      var fg = goods.findIndex(function (g_item) {
        return g_item.goods_id == ck_prom_type.goods[b].goods_id
          && [0, 3, 5, 7, 10].indexOf(g_item.prom_type) > -1
          && g_item.pick_id == pk && g_item.is_gift == 0;
      })
      if (fg > -1) {
        goods[fg].prom_type = ck_prom_type.prom_type;
        goods[fg].prom_id = ck_prom_type.prom_id;

        //如果是不参与的话，商品的活动状态要清理
        if (item.no_cj_prom && ck_prom_type.prom_type == 3) {
          goods[fg].prom_type = 0;
          goods[fg].prom_id = 0;
        }

        for (var ik = 0; ik < th.data.cartlist[pidx].goods.length; ik++) {
          if (th.data.cartlist[pidx].goods[ik].id == goods[fg].id) {
            th.data.cartlist[pidx].goods[ik].prom_type = goods[fg].prom_type;
            th.data.cartlist[pidx].goods[ik].prom_id = goods[fg].prom_id;
          }
        }
      }
    }

    //清理下赠品
    let n_goods = [];
    for (let ig = 0; ig < goods.length; ig++) {
      if (!goods[ig].is_gift) {
        n_goods.push(goods[ig]);
      }
    }

    //原始数据要有深拷贝不能有地址的牵连
    th.data.cartlist_y = JSON.parse(JSON.stringify(n_goods))
    //重新调用cart_next,进行下一步计算
    wx.showLoading({
      title: "处理中.",
    })
    this.get_cart_next(null, 1, { prom_type: 0, prom_id: 0 });

  },

  //---订单促销累计的数据结构的构建,购物车计算流程的那一部分
  get_order_prom_map_ck(item, pickid) {

    //赠品不计算
    if (item.is_gift) return false;

    var order_prom_map_ck = this.data.order_prom_map_ck;
    if (!order_prom_map_ck[pickid]) {
      order_prom_map_ck[pickid] = {
        shop_price_all: 0,   //手店价的累计
        market_price_all: 0, //市场价的累计
        goods_price_all: 0,  //实收价的累计
        no_ord_price: 0,    //要累计上不参与订单促销的金额
        goodsList: [],
      }
    }

    let pk_ord_map = order_prom_map_ck[pickid];
    pk_ord_map.shop_price_all += item.shop_price * item.goods_num;
    pk_ord_map.market_price_all += item.goods_market_price * item.goods_num;

    let ite = {
      id: item.id,
      goods_id: item.goods_id,
      goods_num: item.goods_num,
      prom_type: item.prom_type
    }
    pk_ord_map.goodsList.push(ite);
  },


  //-- 秒杀和团购使用 --
  set_by_now_ord_prom(item) {
    let pickid = this.data.bn_pick;
    let order_prom_map_ck = this.data.order_prom_map_ck;
    order_prom_map_ck[pickid] = {
      shop_price_all: 0,   //手店价的累计
      market_price_all: 0, //市场价的累计
      goods_price_all: 0,  //实收价的累计
      no_ord_price: 0,    //要累计上不参与订单促销的金额
      goodsList: [],
    }

    let pk_ord_map = order_prom_map_ck[pickid];
    pk_ord_map.shop_price_all += item.shop_price_y * item.buynum;
    pk_ord_map.market_price_all += item.market_price * item.buynum;

  },

  //重置订单促销判断累计
  re_set_order_prom_map_ck() {
    this.data.order_prom_map_ck = {}
  },

  //获取当前进行中订单促销，同时带入相应的金额判断订单促销是不是运行，同时订单促销的条件不是实收价判断的话，默认的时候，订单促销是不参与运算的
  async get_cur_ord_prom(pickid) {
    let ord_prom = null;
    let order_prom_map_ck = this.data.order_prom_map_ck[pickid];
    if (!order_prom_map_ck) return null;

    //获取当前进行中的优惠促销
    await getApp().request.promiseGet("/api/weshop/promorder/getPromOrder", {
      data: {
        store_id: os.stoid,
        orderAmount: -1,  //-1为不判断金额条件
        user_id: getApp().globalData.user_id
      }
    }).then(res => {
      if (res.data.code == 0) {
        ord_prom = res.data.data;
      }
    })

    if (!ord_prom) return null;
    //用于计算订单促销的金额
    let calculate_price = 0;

    let txt1 = 'show_ord_prom[' + pickid + ']';
    //-- 此时判断活动的金额满足与否 --
    switch (ord_prom.discount_field) {
      //实收价的时候
      case 0:
        //要先还原
        this.setData({
          [txt1]: 0
        });

        if (ord_prom.money > order_prom_map_ck.goods_price_all) {
          return null;
        }
        break;
      //手店价的时候
      case 1:
        if (ord_prom.money > order_prom_map_ck.shop_price_all) {
          //要先还原
          this.setData({
            [txt1]: 0
          });
          return null;
        }
        //要显示订单促销使用的按钮
        this.setData({
          [txt1]: 1
        });
        break;
      //市场价的时候
      case 2:
        if (ord_prom.money > order_prom_map_ck.market_price_all) {
          //要先还原
          this.setData({
            [txt1]: 0
          });
          return null;
        }
        //要显示订单促销使用的按钮
        this.setData({
          [txt1]: 2
        });
        break;
    }
    //如果订单促销是不参与订单促销的，那么就直接返回null（订单促销不是实收价的时候）
    if (ord_prom.discount_field > 0 && !this.data.can_use_ord_prom[pickid]) {
      return null;
    }
    return ord_prom;
  },

  //设置能够参与订单促销
  set_can_use_ord_prom: function (e) {

    if (this.data.submit) return false;
    this.setData({ submit: 1, same_ok: 1 });

    let pickid = e.currentTarget.dataset.pd;
    let txt = 'can_use_ord_prom[' + pickid + ']';
    let can_use = this.data.can_use_ord_prom[pickid] ? this.data.can_use_ord_prom[pickid] : 0;
    this.setData({
      [txt]: !can_use
    })

    //使用了订单促销（非实收的时候，不能使用优惠券）
    if(!can_use){
      var s_txt='using_quan['+pickid+']';
      this.setData({
          [s_txt]:null
      })
    }


    //购物车进行还原,一下数据的清理的必须的
    this.setData({
      send_lb: {},
      month_lb: {},
      send_gf: {}
    })
    //清空优惠促销的内容
    this.data.prom_goods_map = {};

    //处理一下商品
    let goods0 = JSON.parse(JSON.stringify(this.data.cartlist_y));
    let goods = [];
    for (var ik = 0; ik < goods0.length; ik++) {
      var item_c = goods0[ik];
      if (item_c.pick_id == pickid && item_c.is_collocation) continue;
      if (item_c.is_gift) continue
      goods.push(item_c);
    }

    //原始数据要有深拷贝不能有地址的牵连
    this.data.cartlist_y = JSON.parse(JSON.stringify(goods))
    //重新调用cart_next,进行下一步计算
    wx.showLoading({
      title: "处理中.",
      mark: true
    })
    //-- 重新计算一下价格 --
    this.get_cart_next(null, 1, { prom_type: 0, prom_id: 0 });
  },

  //立即购买的时候，点击订单促销的参与
  set_can_use_ord_prom_now: function (e) {

    if (this.data.submit) return false;
    this.setData({ submit: 1, same_ok: 1 });

    let pickid = this.data.bn_pick;
    let txt = 'can_use_ord_prom[' + pickid + ']';
    let can_use = this.data.can_use_ord_prom[pickid] ? this.data.can_use_ord_prom[pickid] : 0;
    this.setData({
      [txt]: !can_use
    })

    let th = this;
    let good = th.data.bn_goods;

    //如果有要参与订单促销的按钮点击后,要修改商品的价格
    if (th.data.can_use_ord_prom[pickid]) {
      let discount_field = th.data.show_ord_prom[pickid];
      switch (discount_field) {
        case 1:
          good.shop_price = good.shop_price_y;
          break;
        case 2:
          good.shop_price = good.market_price;
          break;
      }

      //-- 转成普通商品 ---
      good.prom_type = 0;
      good.prom_id = 0;

      th.setData({
        selected_quan_list: null,
        using_quan: {}
      })
    } else {
      good = ut.deep_cp(th.data.old_bn_goods);
    }

    th.setData({
      bn_goods: good
    })
    wx.showLoading({
      title: "处理中.",
      mark: true
    })
    th.calculatePrice2()

    if (!th.data.can_use_ord_prom[pickid]) {
      th.get_buy_now_quan();
    }
  },

  //去凑单
  qcd() {
    getApp().goto("/pages/index/index/index");
  },




});
