Commit e29578e1a7e851ad90e7db9858ba753c969269c3

Authored by yvan.ni
1 parent b9aff81c

多促销活动的优化

packageE/pages/cart/cart2/cart2.js
@@ -5,6 +5,9 @@ var regeneratorRuntime = require('../../../../utils/runtime.js'); @@ -5,6 +5,9 @@ var regeneratorRuntime = require('../../../../utils/runtime.js');
5 var util_pay = require("../../../../utils/pay.js"); 5 var util_pay = require("../../../../utils/pay.js");
6 var zh_calc = require("zh_calculate.js"); 6 var zh_calc = require("zh_calculate.js");
7 var ladder_calc = require("ladder_calculate.js"); 7 var ladder_calc = require("ladder_calculate.js");
  8 +//公共的函数合并在一起
  9 +const m_cx = require("../../../../utils/more_cx.js");
  10 +
8 // 防抖函数用定时器 11 // 防抖函数用定时器
9 let timer; 12 let timer;
10 Page({ 13 Page({
@@ -749,6 +752,8 @@ Page({ @@ -749,6 +752,8 @@ Page({
749 752
750 th.data.cartlist_y = carr; //存储原始购物车列表 753 th.data.cartlist_y = carr; //存储原始购物车列表
751 754
  755 + wx.showLoading();
  756 +
752 th.get_cart_next(carr); 757 th.get_cart_next(carr);
753 758
754 } 759 }
@@ -1014,7 +1019,10 @@ Page({ @@ -1014,7 +1019,10 @@ Page({
1014 1019
1015 } 1020 }
1016 1021
1017 - item.original_img = oo.imghost + item.original_img; 1022 +
  1023 + //商品的图片不能重复的赋值
  1024 + if(item.original_img.indexOf(oo.imghost)==-1)
  1025 + item.original_img = oo.imghost + item.original_img;
1018 1026
1019 var car_item = item; 1027 var car_item = item;
1020 /*----接口要弄出来的,先顶着-----*/ 1028 /*----接口要弄出来的,先顶着-----*/
@@ -1164,7 +1172,7 @@ Page({ @@ -1164,7 +1172,7 @@ Page({
1164 var c_item = arr[k]; 1172 var c_item = arr[k];
1165 if(!is_change){ 1173 if(!is_change){
1166 //-- 要进行归类一下活动 -- 1174 //-- 要进行归类一下活动 --
1167 - await th.cart_cx_group(arr[k].goods,c_item,(show_can_cx)=>{ 1175 + await m_cx.cart_cx_group(th,arr[k].goods,c_item,1,1,(show_can_cx)=>{
1168 arr[k].show_can_cx=show_can_cx; 1176 arr[k].show_can_cx=show_can_cx;
1169 }) 1177 })
1170 }else{ 1178 }else{
@@ -7120,403 +7128,6 @@ Page({ @@ -7120,403 +7128,6 @@ Page({
7120 }, 7128 },
7121 7129
7122 7130
7123 - //-- 判读一下促销分组的问题 --  
7124 - async cart_cx_group(goods,car_item,func){  
7125 - //更改活动的时候,就不能再重新计算活动,只有再加减数量和选择商品的时候,就要重新计算活动  
7126 - if(this.data.change_act){  
7127 - var show_can_cx=car_item.show_can_cx;  
7128 - for(var k in show_can_cx){  
7129 - var k_item=show_can_cx[k];  
7130 - var ck_prom_type=null;  
7131 - //-- 如果是多活动,先把活动按照后台的顺序排序一下,  
7132 - //-- 同时确定一下商品最终要用什么活动来购买计算。 --就是要进行切换 --  
7133 - if(k_item.act_arr.length>1){  
7134 - var json_d =this.data.json_d;  
7135 - var auto_promote_sale=json_d.auto_promote_sale;  
7136 - var sort_type='';  
7137 -  
7138 - if(!auto_promote_sale){  
7139 - sort_type='prom_type';  
7140 - }else{  
7141 - var auto_promote_sale=auto_promote_sale.split(',');  
7142 - //-- 循环处理 --  
7143 - k_item.act_arr.map(function (e){  
7144 - var fd=auto_promote_sale.indexOf(e.prom_type+'');  
7145 - e.sort=fd;  
7146 - })  
7147 - sort_type='sort';  
7148 - }  
7149 - //-- 排序一下,进行升序 --  
7150 - function comp(a, b) {  
7151 - return a[sort_type]-b[sort_type]; //升序  
7152 - }  
7153 - //活动要排序一下  
7154 - k_item.act_arr.sort(comp);  
7155 -  
7156 - //确定一下活动,先看一下有没有选择的活动  
7157 - ck_prom_type=k_item.act_arr.find(function (el){  
7158 - return el.sele;  
7159 - })  
7160 -  
7161 - }  
7162 - //-- 此时已经确定了商品的活动是什么类型的,可以确定购物车中商品的具体活动进行金额的计算 --  
7163 - if(!ck_prom_type) ck_prom_type=k_item.act_arr[0];  
7164 -  
7165 - k_item.sele_prom_type=ck_prom_type.prom_type;  
7166 -  
7167 - //-- 如果是要控制数量的时候,也就是全选的时候,或者加减号的时候 --  
7168 - if(is_need_ck_num){  
7169 - var t_pid=ck_prom_type.prom_id;  
7170 - switch (ck_prom_type.prom_type){  
7171 - case 3:  
7172 - if(!th.data.in_yhact_new[t_pid]) th.data.in_yhact_new[t_pid]=0;  
7173 - th.data.in_yhact_new[t_pid]++;  
7174 - break;  
7175 - case 7:  
7176 - if(!th.data.in_zhact_new[t_pid]) th.data.in_zhact_new[t_pid]=0;  
7177 - th.data.in_zhact_new[t_pid]+=ck_prom_type.act_num;  
7178 - //-- 数组的优化 --  
7179 - var nei_gd_map=ck_prom_type.in_zhact_gdmap;  
7180 - if(nei_gd_map){  
7181 - for (var vg in nei_gd_map) {  
7182 - if (!th.data.in_zhact_gdmap_new[vg]) th.data.in_zhact_gdmap_new[vg] = 0;  
7183 - th.datain_zhact_gdmap_new[vg] += nei_gd_map[vg];  
7184 - }  
7185 - }  
7186 - break;  
7187 - }  
7188 - }  
7189 -  
7190 -  
7191 - //-- 此时要把购物车中的商品确定活动 --  
7192 - for (var b=0; b<ck_prom_type.goods.length;b++){  
7193 - //-- 开始查找 --  
7194 - var fg=goods.findIndex(function (g_item){  
7195 - return g_item.goods_id==ck_prom_type.goods[b].goods_id && [0,3,5,7,10].indexOf(g_item.prom_type)>-1;  
7196 - })  
7197 - if(fg>-1){  
7198 - goods[fg].prom_type=ck_prom_type.prom_type;  
7199 - goods[fg].prom_id=ck_prom_type.prom_id;  
7200 - }  
7201 - }  
7202 -  
7203 - }  
7204 - func(show_can_cx);  
7205 - return false;  
7206 - }  
7207 -  
7208 - var th=this;  
7209 - //-- 促销活动对象表,最初的map表,包含活动类型,活动id,goods商品 ---  
7210 - var cx_act_map=[];  
7211 - for(var i=0; i<goods.length;i++){  
7212 - var c_item=goods[i];  
7213 - //没有选中  
7214 - if(!c_item.selected) continue;  
7215 - //如果是秒杀之类是商品  
7216 - if([1,2,4,6,8,9].indexOf(c_item.prom_type)>-1) continue;  
7217 -  
7218 - //-- 把活动进行规整 --  
7219 - var more_cx=c_item.more_cx;  
7220 - for (var j=0;j<more_cx.length;j++){  
7221 - var n_item=more_cx[j];  
7222 - var key=n_item.prom_type+'-'+n_item.prom_id;  
7223 - var fd=cx_act_map.find(function (e){  
7224 - return e.key==key;  
7225 - })  
7226 - if(fd){  
7227 - fd.goods.push(c_item);  
7228 - }else{  
7229 - var p_item={key:key,prom_type:n_item.prom_type,prom_id:n_item.prom_id,goods:[],act:n_item};  
7230 - if(n_item.prom_type==7){  
7231 - p_item.zh_pro=n_item.zh_pro;  
7232 - }  
7233 - p_item.goods.push(c_item);  
7234 - cx_act_map.push(p_item);  
7235 - }  
7236 - }  
7237 - //goods[i].prom_type=0;  
7238 - //goods[i].prom_id=0;  
7239 - }  
7240 - //-- 如果活动数量大于1个,那么活动就要排序一下,有商品种类数最多排再前面,降序进行排列 --  
7241 - if(cx_act_map.length>1){  
7242 - //门店分类要排序下  
7243 - function compare(a, b) {  
7244 - var value1 = a.goods.length;  
7245 - var value2 = b.goods.length;  
7246 - return value2 - value1;  
7247 - }  
7248 - cx_act_map.sort(compare);  
7249 - }  
7250 -  
7251 - //-- 在确认订单的页面强行要用数量的控制  
7252 - var is_need_ck_num=1;  
7253 - //-- 能够进行最后计算的活动(包含切换) --  
7254 - var can_calc_cx=[];  
7255 - //-- 此时对数组的活动进行判断,看能不能达到购买数量的条件 --  
7256 - for(var ii=0;ii<cx_act_map.length;ii++){  
7257 -  
7258 - var item_act_map=cx_act_map[ii];  
7259 - //如果活动有交集的时候,商品数量一样多(不是完全相同时,就是参与的商品有交集),就按照后台确定的活动顺序  
7260 - //如果活动商品数量少的和 活动数量多的 有交集,那么数量少的不显示,也不计算  
7261 - //如果活动的商品一样(那就是多活动切换),优先计算的活动按照后台确定的活动顺序  
7262 - if(!th.check_ok_cx_pro(item_act_map,can_calc_cx)){  
7263 - continue;  
7264 - }  
7265 - switch(item_act_map.prom_type){  
7266 - case 3:  
7267 -  
7268 - //活动ID  
7269 - var aid=item_act_map.prom_id;  
7270 - var need_num=0;  
7271 - //-- 这个时候要判断是不是要判断优惠促销多门店的时候的限购 --  
7272 - if(is_need_ck_num){  
7273 - need_num=th.data.in_yhact_new[aid]?th.data.in_yhact_new[aid]:0;  
7274 - }  
7275 - //-- 判断优惠促销要不要限购 --  
7276 - var fd=null;  
7277 - var fd_res = await getApp().request.promiseGet('/api/weshop/promgoods/get/'+os.stoid+'/'+ky0,{})  
7278 - if(fd_res && fd_res.data.code==0 ){  
7279 - fd=fd_res.data.data;  
7280 - }  
7281 - //如果有限购的时候,也要计算一下  
7282 - if (fd && fd['limit_num'] > 0){  
7283 - //-- 获取已经购买了多少件 --  
7284 - var url = "/api/weshop/ordergoods/getUserBuyPromNum?store_id="+os.stoid+"&user_id="  
7285 - +getApp().globalData.user_id+"&prom_type=3&prom_id="+zh_pro0.id;  
7286 - await getApp().request.promiseGet(url, {}).then(rh => {  
7287 - if(rh.data.code==0){  
7288 - item_act_map.buyed=rh.data.data.userbuynum;  
7289 - }  
7290 - })  
7291 - if(item_act_map.buyed+need_num>=fd['limit_num']){  
7292 - continue; //-- 进行下一个循环 --  
7293 - }  
7294 - }  
7295 -  
7296 - var fir_act=item_act_map.act.fir_act;  
7297 - var t_goods=item_act_map.goods;  
7298 - var all_num=0;  
7299 - var all_pri=0;  
7300 - for(var f=0;f<t_goods.length;f++){  
7301 - all_num+=t_goods[f].goods_num;  
7302 - all_pri+=t_goods[f].goods_num*t_goods[f].goods_price;  
7303 - }  
7304 -  
7305 - var yh_ok=1;  
7306 - switch (fir_act.prom_type){  
7307 - case 0:  
7308 - if(all_pri<fir_act.condition) {  
7309 - yh_ok=0;  
7310 - }  
7311 - break;  
7312 - case 1:  
7313 - if(all_num<fir_act.condition) {  
7314 - yh_ok=0;  
7315 - }  
7316 - break;  
7317 - }  
7318 -  
7319 - //-- 如果有满足优惠条件的时候 --  
7320 - if(yh_ok){  
7321 - can_calc_cx.push(item_act_map)  
7322 - }  
7323 - break  
7324 -  
7325 - case 7:  
7326 - //-- 活动列表 --  
7327 - var zhact_gdlist=item_act_map.act.gdlist;  
7328 - var zh_goods=item_act_map.goods;  
7329 -  
7330 - //--- 要循环计算一下商品的已购数量 ---  
7331 - for(var h=0;h<zh_goods.length;h++){  
7332 - //-- 商品的限购 --  
7333 - var promgoodsbuynum = 0;  
7334 - var res=await getApp().request.promiseGet("/api/weshop/ordergoods/getUserBuyGoodsNum", {  
7335 - data: {  
7336 - store_id: os.stoid,  
7337 - user_id: getApp().globalData.user_id,  
7338 - goods_id: zh_goods[h].goods_id,  
7339 - prom_type: 7,  
7340 - prom_id: item_act_map.prom_id  
7341 - },  
7342 - })  
7343 - if(res.data.code==0 && res.data.data && res.data.data.promgoodsbuynum){  
7344 - promgoodsbuynum = res.data.data.promgoodsbuynum;  
7345 - }  
7346 - zh_goods[h].zh_b_num=promgoodsbuynum;  
7347 - }  
7348 - //-- 放到map中 --  
7349 - th.data.zuhe_map_good[item_act_map.prom_id] = zhact_gdlist;  
7350 - if(!car_item.zh_prom_goods) car_item.zh_prom_goods={};  
7351 - car_item.zh_prom_goods[item_act_map.prom_id] = zhact_gdlist;  
7352 -  
7353 - var zh_pro0 = th.data.zhhe_act_map[item_act_map.prom_id];  
7354 - //-- 获取活动信息 --  
7355 - var url = "/api/weshop/ordergoods/getUserBuyPromNum?store_id="+os.stoid+"&user_id="  
7356 - +getApp().globalData.user_id+"&prom_type=7&prom_id="+zh_pro0.id;  
7357 - await getApp().request.promiseGet(url, {}).then(rh => {  
7358 - if(rh.data.code==0){  
7359 - item_act_map.buyed=rh.data.data.userbuynum;  
7360 - }  
7361 - })  
7362 -  
7363 - //当满足组合的要求:总数要满足,起购数要满足  
7364 - if(zh_calc.ch_zh_ok(zh_pro0,zhact_gdlist,zh_goods,th,item_act_map,is_need_ck_num)){  
7365 - can_calc_cx.push(item_act_map)  
7366 - }  
7367 - break;  
7368 - default:  
7369 - can_calc_cx.push(item_act_map);  
7370 - }  
7371 -  
7372 - }  
7373 -  
7374 - //-- 此时来给满足条件的活动进行分组~~相同参与商品和数量的归纳再一起, --  
7375 - //-- 同时相同商品数量的活动,还要看取那一个来进行计算金额。 默认的时候是按照后台的顺序。--  
7376 - //-- 有选择的时候,就按照切换选择了什么就按照什么来计算 --  
7377 - var show_can_cx={};  
7378 -  
7379 - if(can_calc_cx.length){  
7380 - for(var p=0;p<can_calc_cx.length;p++){  
7381 - var ch_map=[];  
7382 -  
7383 - //-- 立即购买的时候,选择的活动是确定的 --  
7384 - if(can_calc_cx[p].prom_type==can_calc_cx[p].goods[0].prom_type){  
7385 - can_calc_cx[p].sele=1;  
7386 - }  
7387 - can_calc_cx[p].goods.map(function (gd){  
7388 - ch_map.push(gd.goods_id);  
7389 - })  
7390 - ch_map.sort();  
7391 - //-- 先找一下,有没有参与的商品一模一样的 --  
7392 - var fd=show_can_cx[ch_map.join()];  
7393 - if(fd){  
7394 - //-- 把数组添加进去 --ch_map  
7395 - fd.act_arr.push(can_calc_cx[p])  
7396 - }else{  
7397 - var e={ch_map:ch_map,act_arr:[]};  
7398 - if(ch_map.length>1){  
7399 - e.is_duo_gd=1;  
7400 - }  
7401 - e.act_arr.push(can_calc_cx[p]);  
7402 - show_can_cx[ch_map.join()]=e;  
7403 - }  
7404 - }  
7405 - }  
7406 -  
7407 - for(var k in show_can_cx){  
7408 - var k_item=show_can_cx[k];  
7409 - var ck_prom_type=null;  
7410 - //-- 如果是多活动,先把活动按照后台的顺序排序一下,  
7411 - //-- 同时确定一下商品最终要用什么活动来购买计算。 --就是要进行切换 --  
7412 - if(k_item.act_arr.length>1){  
7413 - var json_d =this.data.json_d;  
7414 - var auto_promote_sale=json_d.auto_promote_sale;  
7415 - var sort_type='';  
7416 -  
7417 - if(!auto_promote_sale){  
7418 - sort_type='prom_type';  
7419 - }else{  
7420 - var auto_promote_sale=auto_promote_sale.split(',');  
7421 - //-- 循环处理 --  
7422 - k_item.act_arr.map(function (e){  
7423 - var fd=auto_promote_sale.indexOf(e.prom_type+'');  
7424 - e.sort=fd;  
7425 - })  
7426 - sort_type='sort';  
7427 - }  
7428 - //-- 排序一下,进行升序 --  
7429 - function comp(a, b) {  
7430 - return a[sort_type]-b[sort_type]; //升序  
7431 - }  
7432 - //活动要排序一下  
7433 - k_item.act_arr.sort(comp);  
7434 -  
7435 - //确定一下活动,先看一下有没有选择的活动  
7436 - ck_prom_type=k_item.act_arr.find(function (el){  
7437 - return el.sele;  
7438 - })  
7439 -  
7440 - }  
7441 - //-- 此时已经确定了商品的活动是什么类型的,可以确定购物车中商品的具体活动进行金额的计算 --  
7442 - if(!ck_prom_type) ck_prom_type=k_item.act_arr[0];  
7443 -  
7444 - k_item.sele_prom_type=ck_prom_type.prom_type;  
7445 -  
7446 - //-- 如果是要控制数量的时候,也就是全选的时候,或者加减号的时候 --  
7447 - if(is_need_ck_num){  
7448 - var t_pid=ck_prom_type.prom_id;  
7449 - switch (ck_prom_type.prom_type){  
7450 - case 3:  
7451 - if(!th.data.in_yhact_new[t_pid]) th.data.in_yhact_new[t_pid]=0;  
7452 - th.data.in_yhact_new[t_pid]++;  
7453 - break;  
7454 - case 7:  
7455 - if(!th.data.in_zhact_new[t_pid]) th.data.in_zhact_new[t_pid]=0;  
7456 - th.data.in_zhact_new[t_pid]+=ck_prom_type.act_num;  
7457 - //-- 数组的优化 --  
7458 - var nei_gd_map=ck_prom_type.in_zhact_gdmap;  
7459 - if(nei_gd_map){  
7460 - for (var vg in nei_gd_map) {  
7461 - if (!th.data.in_zhact_gdmap_new[vg]) th.data.in_zhact_gdmap_new[vg] = 0;  
7462 - th.data.in_zhact_gdmap_new[vg] += nei_gd_map[vg];  
7463 - }  
7464 - }  
7465 - break;  
7466 - }  
7467 - }  
7468 -  
7469 -  
7470 - //-- 此时要把购物车中的商品确定活动 --  
7471 - for (var b=0; b<ck_prom_type.goods.length;b++){  
7472 - //-- 开始查找 --  
7473 - var fg=goods.findIndex(function (g_item){  
7474 - return g_item.goods_id==ck_prom_type.goods[b].goods_id && [0,3,5,7,10].indexOf(g_item.prom_type)>-1;  
7475 - })  
7476 - if(fg>-1){  
7477 - goods[fg].prom_type=ck_prom_type.prom_type;  
7478 - goods[fg].prom_id=ck_prom_type.prom_id;  
7479 - }  
7480 - }  
7481 - }  
7482 -  
7483 - //-- 显示到前端,并切换 --  
7484 - //th.setData({show_can_cx})  
7485 - //--- 调用回调函数 ---  
7486 - func(show_can_cx);  
7487 - },  
7488 - //-- 查看活动参与的商品是不是有重复交集的地方,是不是一样的商品数量,can_calc_cx这个数组也是按照商品的数量降序排列的--  
7489 - check_ok_cx_pro(item_act_map,can_calc_cx){  
7490 - //-- 加入第一个,返回真 --  
7491 - if(!can_calc_cx.length) return true;  
7492 - var th_goods=item_act_map.goods;  
7493 - for(var i=0;i<can_calc_cx.length;i++){  
7494 - var can_goods=can_calc_cx[i].goods;  
7495 - //计算一下有交集的数量,没有交集,OK  
7496 - var num=this.hasJiao(can_goods,th_goods);  
7497 - if(!num) continue;  
7498 - //计算一下俩个shu  
7499 - if(can_goods.length==th_goods.length && can_goods.length==num){  
7500 - return true;  
7501 - }  
7502 - if(can_goods.length>th_goods.length){  
7503 - return false;  
7504 - }  
7505 - }  
7506 - return true;  
7507 - },  
7508 - //-- 判断是不是有交集,返回交集的数量 --  
7509 - hasJiao(arr1, arr2){  
7510 - var num=0;  
7511 - arr1.map(function (e){  
7512 - var idx=arr2.findIndex(function (g){  
7513 - return g.goods_id==e.goods_id;  
7514 - })  
7515 - if(idx>-1) num++;  
7516 - })  
7517 - return num;  
7518 - },  
7519 -  
7520 //-- 开始显示活动的弹出 -- 7131 //-- 开始显示活动的弹出 --
7521 switch_cx_group:function (e){ 7132 switch_cx_group:function (e){
7522 var idx=e.currentTarget.dataset.index; 7133 var idx=e.currentTarget.dataset.index;
@@ -7582,6 +7193,9 @@ Page({ @@ -7582,6 +7193,9 @@ Page({
7582 if(fg>-1){ 7193 if(fg>-1){
7583 goods[fg].prom_type=ck_prom_type.prom_type; 7194 goods[fg].prom_type=ck_prom_type.prom_type;
7584 goods[fg].prom_id=ck_prom_type.prom_id; 7195 goods[fg].prom_id=ck_prom_type.prom_id;
  7196 + th.data.cartlist_y[idx].goods[fg].prom_type= goods[fg].prom_type;
  7197 + th.data.cartlist_y[idx].goods[fg].prom_id= goods[fg].prom_id;
  7198 +
7585 } 7199 }
7586 } 7200 }
7587 7201
pages/cart/cart/cart.js
@@ -9,7 +9,8 @@ var t = getApp(), @@ -9,7 +9,8 @@ var t = getApp(),
9 ladder_calc = require("ladder_calculate.js"); 9 ladder_calc = require("ladder_calculate.js");
10 var regeneratorRuntime = require('../../../utils/runtime.js'); 10 var regeneratorRuntime = require('../../../utils/runtime.js');
11 const e = require("../../../utils/common.js"); 11 const e = require("../../../utils/common.js");
12 - 12 +//公共的函数合并在一起
  13 +const m_cx = require("../../../utils/more_cx.js");
13 14
14 Page({ 15 Page({
15 data: { 16 data: {
@@ -1894,9 +1895,12 @@ Page({ @@ -1894,9 +1895,12 @@ Page({
1894 th.data.in_zhact_gdmap = {}; 1895 th.data.in_zhact_gdmap = {};
1895 for (var a = 0; a < car.length; a++) { 1896 for (var a = 0; a < car.length; a++) {
1896 1897
  1898 + car[a].zh_map=null;
  1899 + car[a].ladder_map=null;
  1900 +
1897 var item = car[a].goods, is_s_sele = 1; 1901 var item = car[a].goods, is_s_sele = 1;
1898 //-- 先批量判断一下活动的类型,同时要同步跟新 -- 1902 //-- 先批量判断一下活动的类型,同时要同步跟新 --
1899 - await th.cart_cx_group(item,car[a],1,(show_can_cx)=>{ 1903 + await m_cx.cart_cx_group(th,item,car[a],1,0,(show_can_cx)=>{
1900 var offline_price = 0; 1904 var offline_price = 0;
1901 var offline_num = 0; 1905 var offline_num = 0;
1902 for (var c = 0; c < item.length; c++) { 1906 for (var c = 0; c < item.length; c++) {
@@ -1922,6 +1926,7 @@ Page({ @@ -1922,6 +1926,7 @@ Page({
1922 obj.goods_num = 0; 1926 obj.goods_num = 0;
1923 zh_calc.add_zhprom(car, a, obj); 1927 zh_calc.add_zhprom(car, a, obj);
1924 } 1928 }
  1929 +
1925 if (item[c].prom_type == 10) { 1930 if (item[c].prom_type == 10) {
1926 obj.goods_num = 0; 1931 obj.goods_num = 0;
1927 ladder_calc.add_ladder_prom(car, a, obj); 1932 ladder_calc.add_ladder_prom(car, a, obj);
@@ -1929,6 +1934,8 @@ Page({ @@ -1929,6 +1934,8 @@ Page({
1929 1934
1930 1935
1931 } else { 1936 } else {
  1937 +
  1938 +
1932 if (item[c].prom_type == 7) { 1939 if (item[c].prom_type == 7) {
1933 //先把商品放入组合计算的专用的区域 1940 //先把商品放入组合计算的专用的区域
1934 console.log('是组合商品---') 1941 console.log('是组合商品---')
@@ -4204,363 +4211,7 @@ Page({ @@ -4204,363 +4211,7 @@ Page({
4204 }); 4211 });
4205 }, 4212 },
4206 4213
4207 - //-- 判读一下促销分组的问题 --  
4208 - async cart_cx_group(goods,car_item,is_need_ck_num,func){  
4209 - //更改活动的时候,就不能再重新计算活动,只有再加减数量和选择商品的时候,就要重新计算活动  
4210 - if(this.data.change_act || (car_item.show_can_cx && Object.keys(car_item.show_can_cx).length>0)){  
4211 - var show_can_cx=car_item.show_can_cx;  
4212 - for(var k in show_can_cx){  
4213 - var k_item=show_can_cx[k];  
4214 - var ck_prom_type=null;  
4215 - //-- 如果是多活动,先把活动按照后台的顺序排序一下,  
4216 - //-- 同时确定一下商品最终要用什么活动来购买计算。 --就是要进行切换 --  
4217 - if(k_item.act_arr.length>1){  
4218 - var json_d =this.data.json_d;  
4219 - var auto_promote_sale=json_d.auto_promote_sale;  
4220 - var sort_type='';  
4221 -  
4222 - if(!auto_promote_sale){  
4223 - sort_type='prom_type';  
4224 - }else{  
4225 - var auto_promote_sale=auto_promote_sale.split(',');  
4226 - //-- 循环处理 --  
4227 - k_item.act_arr.map(function (e){  
4228 - var fd=auto_promote_sale.indexOf(e.prom_type+'');  
4229 - e.sort=fd;  
4230 - })  
4231 - sort_type='sort';  
4232 - }  
4233 - //-- 排序一下,进行升序 --  
4234 - function comp(a, b) {  
4235 - return a[sort_type]-b[sort_type]; //升序  
4236 - }  
4237 - //活动要排序一下  
4238 - k_item.act_arr.sort(comp);  
4239 -  
4240 - //确定一下活动,先看一下有没有选择的活动  
4241 - ck_prom_type=k_item.act_arr.find(function (el){  
4242 - return el.sele;  
4243 - })  
4244 -  
4245 - }  
4246 - //-- 此时已经确定了商品的活动是什么类型的,可以确定购物车中商品的具体活动进行金额的计算 --  
4247 - if(!ck_prom_type) ck_prom_type=k_item.act_arr[0];  
4248 -  
4249 - //-- 此时要把购物车中的商品确定活动 --  
4250 - for (var b=0; b<ck_prom_type.goods.length;b++){  
4251 - //-- 开始查找 --  
4252 - var fg=goods.findIndex(function (g_item){  
4253 - return g_item.goods_id==ck_prom_type.goods[b].goods_id && [0,3,5,7,10].indexOf(g_item.prom_type)>-1;  
4254 - })  
4255 - if(fg>-1){  
4256 - goods[fg].prom_type=ck_prom_type.prom_type;  
4257 - goods[fg].prom_id=ck_prom_type.prom_id;  
4258 - }  
4259 - }  
4260 -  
4261 - }  
4262 - func(show_can_cx);  
4263 - return false;  
4264 - }  
4265 -  
4266 - var th=this;  
4267 - //-- 促销活动对象表,最初的map表,包含活动类型,活动id,goods商品 ---  
4268 - var cx_act_map=[];  
4269 - for(var i=0; i<goods.length;i++){  
4270 - var c_item=goods[i];  
4271 - //没有选中  
4272 - if(!c_item.selected) continue;  
4273 - //如果是秒杀之类是商品  
4274 - if([1,2,4,6,8,9].indexOf(c_item.prom_type)>-1) continue;  
4275 -  
4276 - //-- 把活动进行规整 --  
4277 - var more_cx=c_item.more_cx;  
4278 - for (var j=0;j<more_cx.length;j++){  
4279 - var n_item=more_cx[j];  
4280 - var key=n_item.prom_type+'-'+n_item.prom_id;  
4281 - var fd=cx_act_map.find(function (e){  
4282 - return e.key==key;  
4283 - })  
4284 - if(fd){  
4285 - fd.goods.push(c_item);  
4286 - }else{  
4287 - var p_item={key:key,prom_type:n_item.prom_type,prom_id:n_item.prom_id,goods:[],act:n_item};  
4288 - if(n_item.prom_type==7){  
4289 - p_item.zh_pro=n_item.zh_pro;  
4290 - }  
4291 - p_item.goods.push(c_item);  
4292 - cx_act_map.push(p_item);  
4293 - }  
4294 - }  
4295 - goods[i].prom_type=0;  
4296 - goods[i].prom_id=0;  
4297 - }  
4298 - //-- 如果活动数量大于1个,那么活动就要排序一下,有商品种类数最多排再前面,降序进行排列 --  
4299 - if(cx_act_map.length>1){  
4300 - //门店分类要排序下  
4301 - function compare(a, b) {  
4302 - var value1 = a.goods.length;  
4303 - var value2 = b.goods.length;  
4304 - return value2 - value1;  
4305 - }  
4306 - cx_act_map.sort(compare);  
4307 - }  
4308 - //-- 能够进行最后计算的活动(包含切换) --  
4309 - var can_calc_cx=[];  
4310 - //-- 此时对数组的活动进行判断,看能不能达到购买数量的条件 --  
4311 - for(var ii=0;ii<cx_act_map.length;ii++){  
4312 -  
4313 - var item_act_map=cx_act_map[ii];  
4314 - //如果活动有交集的时候,商品数量一样多(不是完全相同时,就是参与的商品有交集),就按照后台确定的活动顺序  
4315 - //如果活动商品数量少的和 活动数量多的 有交集,那么数量少的不显示,也不计算  
4316 - //如果活动的商品一样(那就是多活动切换),优先计算的活动按照后台确定的活动顺序  
4317 - if(!th.check_ok_cx_pro(item_act_map,can_calc_cx)){  
4318 - continue;  
4319 - }  
4320 - switch(item_act_map.prom_type){  
4321 - case 3:  
4322 - //活动ID  
4323 - var aid=item_act_map.prom_id;  
4324 - var need_num=0;  
4325 - //-- 这个时候要判断是不是要判断优惠促销多门店的时候的限购 --  
4326 - if(is_need_ck_num){  
4327 - need_num=th.data.in_yhact_new[aid]?th.data.in_yhact_new[aid]:0;  
4328 - }  
4329 - //-- 判断优惠促销要不要限购 --  
4330 - var fd=null;  
4331 - var fd_res = await getApp().request.promiseGet('/api/weshop/promgoods/get/'+os.stoid+'/'+ky0,{})  
4332 - if(fd_res && fd_res.data.code==0 ){  
4333 - fd=fd_res.data.data;  
4334 - }  
4335 - //如果有限购的时候,也要计算一下  
4336 - if (fd && fd['limit_num'] > 0){  
4337 - //-- 获取已经购买了多少件 --  
4338 - var url = "/api/weshop/ordergoods/getUserBuyPromNum?store_id="+os.stoid+"&user_id="  
4339 - +getApp().globalData.user_id+"&prom_type=3&prom_id="+zh_pro0.id;  
4340 - await getApp().request.promiseGet(url, {}).then(rh => {  
4341 - if(rh.data.code==0){  
4342 - item_act_map.buyed=rh.data.data.userbuynum;  
4343 - }  
4344 - })  
4345 - if(item_act_map.buyed+need_num>=fd['limit_num']){  
4346 - continue; //-- 进行下一个循环 --  
4347 - }  
4348 - }  
4349 -  
4350 - var fir_act=item_act_map.act.fir_act;  
4351 - var t_goods=item_act_map.goods;  
4352 - var all_num=0;  
4353 - var all_pri=0;  
4354 - for(var f=0;f<t_goods.length;f++){  
4355 - all_num+=t_goods[f].goods_num;  
4356 - all_pri+=t_goods[f].goods_num*t_goods[f].goods_price;  
4357 - }  
4358 - var yh_ok=1;  
4359 - switch (fir_act.prom_type){  
4360 - case 0:  
4361 - if(all_pri<fir_act.condition) {  
4362 - yh_ok=0;  
4363 - }  
4364 - break;  
4365 - case 1:  
4366 - if(all_num<fir_act.condition) {  
4367 - yh_ok=0;  
4368 - }  
4369 - break;  
4370 - }  
4371 - //-- 如果有满足优惠条件的时候 --  
4372 - if(yh_ok){  
4373 - can_calc_cx.push(item_act_map)  
4374 - }  
4375 - break  
4376 -  
4377 - case 7:  
4378 - //-- 活动列表 --  
4379 - var zhact_gdlist=item_act_map.act.gdlist;  
4380 - var zh_goods=item_act_map.goods;  
4381 - //--- 要循环计算一下商品的已购数量 ---  
4382 - for(var h=0;h<zh_goods.length;h++){  
4383 - //-- 商品的限购 --  
4384 - var promgoodsbuynum = 0;  
4385 - var res=await getApp().request.promiseGet("/api/weshop/ordergoods/getUserBuyGoodsNum", {  
4386 - data: {  
4387 - store_id: os.stoid,  
4388 - user_id: getApp().globalData.user_id,  
4389 - goods_id: zh_goods[h].goods_id,  
4390 - prom_type: 7,  
4391 - prom_id: item_act_map.prom_id  
4392 - },  
4393 - })  
4394 - if(res.data.code==0 && res.data.data && res.data.data.promgoodsbuynum){  
4395 - promgoodsbuynum = res.data.data.promgoodsbuynum;  
4396 - }  
4397 - zh_goods[h].zh_b_num=promgoodsbuynum;  
4398 - }  
4399 - //-- 放到参与组合优惠促销的map中 --  
4400 - th.data.zuhe_map_good[item_act_map.prom_id] = zhact_gdlist;  
4401 - if(!car_item.zh_prom_goods) car_item.zh_prom_goods={};  
4402 - car_item.zh_prom_goods[item_act_map.prom_id] = zhact_gdlist;  
4403 -  
4404 - var zh_pro0 = th.data.zuhe_map[item_act_map.prom_id];  
4405 -  
4406 - //-- 获取活动信息 --  
4407 - var url = "/api/weshop/ordergoods/getUserBuyPromNum?store_id="+os.stoid+"&user_id="  
4408 - +getApp().globalData.user_id+"&prom_type=7&prom_id="+zh_pro0.id;  
4409 - await getApp().request.promiseGet(url, {}).then(rh => {  
4410 - if(rh.data.code==0){  
4411 - item_act_map.buyed=rh.data.data.userbuynum;  
4412 - }  
4413 - })  
4414 - //当满足组合的要求:总数要满足,起购数要满足  
4415 - if(zh_calc.ch_zh_ok(zh_pro0,zhact_gdlist,zh_goods,th,item_act_map,is_need_ck_num)){  
4416 - can_calc_cx.push(item_act_map)  
4417 - }  
4418 - break;  
4419 - default:  
4420 - can_calc_cx.push(item_act_map);  
4421 - }  
4422 -  
4423 - }  
4424 4214
4425 - //-- 此时来给满足条件的活动进行分组~~相同参与商品和数量的归纳再一起, --  
4426 - //-- 同时相同商品数量的活动,还要看取那一个来进行计算金额。 默认的时候是按照后台的顺序。--  
4427 - //-- 有选择的时候,就按照切换选择了什么就按照什么来计算 --  
4428 - //-- can_calc_cx的元素(item_act_map)最后是放到act_arr里面去了 --  
4429 - var show_can_cx={};  
4430 - if(can_calc_cx.length){  
4431 - for(var p=0;p<can_calc_cx.length;p++){  
4432 - var ch_map=[];  
4433 - can_calc_cx[p].goods.map(function (gd){  
4434 - ch_map.push(gd.goods_id);  
4435 - })  
4436 - ch_map.sort();  
4437 - //-- 先找一下,有没有参与的商品一模一样的 --  
4438 - var fd=show_can_cx[ch_map.join()];  
4439 - if(fd){  
4440 - //-- 把数组添加进去 --ch_map  
4441 - fd.act_arr.push(can_calc_cx[p])  
4442 - }else{  
4443 - var e={ch_map:ch_map,act_arr:[]};  
4444 - if(ch_map.length>1){  
4445 - e.is_duo_gd=1;  
4446 - }  
4447 - e.act_arr.push(can_calc_cx[p]);  
4448 - show_can_cx[ch_map.join()]=e;  
4449 - }  
4450 - }  
4451 - }  
4452 -  
4453 - for(var k in show_can_cx){  
4454 - var k_item=show_can_cx[k];  
4455 - var ck_prom_type=null;  
4456 - //-- 如果是多活动,先把活动按照后台的顺序排序一下,  
4457 - //-- 同时确定一下商品最终要用什么活动来购买计算。 --就是要进行切换 --  
4458 - if(k_item.act_arr.length>1){  
4459 - var json_d =this.data.json_d;  
4460 - var auto_promote_sale=json_d.auto_promote_sale;  
4461 - var sort_type='';  
4462 -  
4463 - if(!auto_promote_sale){  
4464 - sort_type='prom_type';  
4465 - }else{  
4466 - var auto_promote_sale=auto_promote_sale.split(',');  
4467 - //-- 循环处理 --  
4468 - k_item.act_arr.map(function (e){  
4469 - var fd=auto_promote_sale.indexOf(e.prom_type+'');  
4470 - e.sort=fd;  
4471 - })  
4472 - sort_type='sort';  
4473 - }  
4474 - //-- 排序一下,进行升序 --  
4475 - function comp(a, b) {  
4476 - return a[sort_type]-b[sort_type]; //升序  
4477 - }  
4478 - //活动要排序一下  
4479 - k_item.act_arr.sort(comp);  
4480 -  
4481 - //确定一下活动,先看一下有没有选择的活动  
4482 - ck_prom_type=k_item.act_arr.find(function (el){  
4483 - return el.sele;  
4484 - })  
4485 -  
4486 - }  
4487 - //-- 此时已经确定了商品的活动是什么类型的,可以确定购物车中商品的具体活动进行金额的计算 --  
4488 - if(!ck_prom_type){  
4489 - ck_prom_type=k_item.act_arr[0];  
4490 - k_item.act_arr[0].sele=1;  
4491 - }  
4492 -  
4493 - //-- 如果是要控制数量的时候,也就是全选的时候,或者加减号的时候 --  
4494 - if(is_need_ck_num){  
4495 - var t_pid=ck_prom_type.prom_id;  
4496 - switch (ck_prom_type.prom_type){  
4497 - case 3:  
4498 - if(!th.data.in_yhact_new[t_pid]) th.data.in_yhact_new[t_pid]=0;  
4499 - th.data.in_yhact_new[t_pid]++;  
4500 - break;  
4501 - case 7:  
4502 - if(!th.data.in_zhact_new[t_pid]) th.data.in_zhact_new[t_pid]=0;  
4503 - th.data.in_zhact_new[t_pid]+=ck_prom_type.act_num;  
4504 - //-- 数组的优化 --  
4505 - var nei_gd_map=ck_prom_type.in_zhact_gdmap;  
4506 - if(nei_gd_map){  
4507 - for (var vg in nei_gd_map) {  
4508 - if (!th.data.in_zhact_gdmap_new[vg]) th.data.in_zhact_gdmap_new[vg] = 0;  
4509 - th.data.in_zhact_gdmap_new[vg] += nei_gd_map[vg];  
4510 - }  
4511 - }  
4512 - break;  
4513 - }  
4514 - }  
4515 - //-- 此时要把购物车中的商品确定活动 --  
4516 - for (var b=0; b<ck_prom_type.goods.length;b++){  
4517 - //-- 开始查找 --  
4518 - var fg=goods.findIndex(function (g_item){  
4519 - return g_item.goods_id==ck_prom_type.goods[b].goods_id && [0,3,5,7,10].indexOf(g_item.prom_type)>-1;  
4520 - })  
4521 - if(fg>-1){  
4522 - goods[fg].prom_type=ck_prom_type.prom_type;  
4523 - goods[fg].prom_id=ck_prom_type.prom_id;  
4524 - }  
4525 - }  
4526 - }  
4527 - //-- 显示到前端,并切换 --  
4528 - //th.setData({show_can_cx})  
4529 - //--- 调用回调函数 ---  
4530 - func(show_can_cx);  
4531 -  
4532 - },  
4533 - //-- 查看活动参与的商品是不是有重复交集的地方,是不是一样的商品数量,can_calc_cx这个数组也是按照商品的数量降序排列的--  
4534 - check_ok_cx_pro(item_act_map,can_calc_cx){  
4535 - //-- 加入第一个,返回真 --  
4536 - if(!can_calc_cx.length) return true;  
4537 - var th_goods=item_act_map.goods;  
4538 - for(var i=0;i<can_calc_cx.length;i++){  
4539 - var can_goods=can_calc_cx[i].goods;  
4540 - //计算一下有交集的数量,没有交集,OK  
4541 - var num=this.hasJiao(can_goods,th_goods);  
4542 - if(!num) continue;  
4543 - //计算一下俩个shu  
4544 - if(can_goods.length==th_goods.length && can_goods.length==num){  
4545 - return true;  
4546 - }  
4547 - if(can_goods.length>th_goods.length){  
4548 - return false;  
4549 - }  
4550 - }  
4551 - return true;  
4552 - },  
4553 - //-- 判断是不是有交集,返回交集的数量 --  
4554 - hasJiao(arr1, arr2){  
4555 - var num=0;  
4556 - arr1.map(function (e){  
4557 - var idx=arr2.findIndex(function (g){  
4558 - return g.goods_id==e.goods_id;  
4559 - })  
4560 - if(idx>-1) num++;  
4561 - })  
4562 - return num;  
4563 - },  
4564 4215
4565 //-- 开始显示活动的弹出 -- 4216 //-- 开始显示活动的弹出 --
4566 switch_cx_group:function (e){ 4217 switch_cx_group:function (e){
@@ -4607,10 +4258,17 @@ Page({ @@ -4607,10 +4258,17 @@ Page({
4607 else cx_prom_group[dx].sele=1; 4258 else cx_prom_group[dx].sele=1;
4608 } 4259 }
4609 4260
4610 - this.cx_check_ok2(function (the_rs){ 4261 + this.cx_check_ok2(async function (the_rs){
4611 if(the_rs.code==0){ 4262 if(the_rs.code==0){
4612 th.data.change_act=1; 4263 th.data.change_act=1;
4613 - th.doCheckAll(); 4264 +
  4265 +
  4266 + th.doCheckAll(async function (){
  4267 + for (var i in th.data.requestData) {
  4268 + await th.check_prom_activity(i)
  4269 + }
  4270 + });
  4271 +
4614 }else{ 4272 }else{
4615 wx.showToast({ 4273 wx.showToast({
4616 title: the_rs.msg, 4274 title: the_rs.msg,
@@ -4655,12 +4313,11 @@ Page({ @@ -4655,12 +4313,11 @@ Page({
4655 } 4313 }
4656 } 4314 }
4657 //-- 先批量判断一下活动的类型,同时要同步跟新 -- 4315 //-- 先批量判断一下活动的类型,同时要同步跟新 --
4658 - this.cart_cx_group(item,car[c_idx],0,(show_can_cx)=>{ 4316 + m_cx.cart_cx_group(this,item,car[c_idx],0,0,(show_can_cx)=>{
4659 car[c_idx].show_can_cx=show_can_cx; 4317 car[c_idx].show_can_cx=show_can_cx;
4660 th.cx_check_ok2(func,car); 4318 th.cx_check_ok2(func,car);
4661 }); 4319 });
4662 4320
4663 -  
4664 }, 4321 },
4665 4322
4666 //--- 在点击商品和或者门店的时候调用,这个可以在活动切换的时候调用,也可以被单个选择调用--- 4323 //--- 在点击商品和或者门店的时候调用,这个可以在活动切换的时候调用,也可以被单个选择调用---
pages/cart/cart/cart.wxml
@@ -137,7 +137,7 @@ @@ -137,7 +137,7 @@
137 data-index="{{pidx}}" 137 data-index="{{pidx}}"
138 data-gd_key="{{items.goods_id}}" 138 data-gd_key="{{items.goods_id}}"
139 class="cx-frame flex" style="position: relative"> 139 class="cx-frame flex" style="position: relative">
140 - <view class="cx-sizs fs30">促销</view> 140 + <view class="cx-sizs fs30">可参促销</view>
141 <view class="flex ai_c f1 pdh20"> 141 <view class="flex ai_c f1 pdh20">
142 <view class="xc-coupon-fram" wx:for="{{item.show_can_cx[items.goods_id].act_arr}}" > 142 <view class="xc-coupon-fram" wx:for="{{item.show_can_cx[items.goods_id].act_arr}}" >
143 <view wx:if="{{item.prom_type==3}}" class="xc-coupon t-c four-level-word">优惠促销</view> 143 <view wx:if="{{item.prom_type==3}}" class="xc-coupon t-c four-level-word">优惠促销</view>
@@ -166,7 +166,7 @@ @@ -166,7 +166,7 @@
166 data-index="{{pidx}}" 166 data-index="{{pidx}}"
167 data-gd_key="{{index}}" 167 data-gd_key="{{index}}"
168 class="cx-frame flex" style="position: relative"> 168 class="cx-frame flex" style="position: relative">
169 - <view class="cx-sizs fs30">促销</view> 169 + <view class="cx-sizs fs30">可参促销</view>
170 <view class="flex ai_c f1 pdh20"> 170 <view class="flex ai_c f1 pdh20">
171 <view class="xc-coupon-fram" wx:for="{{pitem.act_arr}}" > 171 <view class="xc-coupon-fram" wx:for="{{pitem.act_arr}}" >
172 <view wx:if="{{item.prom_type==3}}" class="xc-coupon t-c four-level-word">优惠促销</view> 172 <view wx:if="{{item.prom_type==3}}" class="xc-coupon t-c four-level-word">优惠促销</view>
pages/cart/cart/zh_calculate.js
@@ -787,7 +787,9 @@ module.exports = { @@ -787,7 +787,9 @@ module.exports = {
787 item_act_map.in_zhact_gdmap=in_zhact_gdmap; 787 item_act_map.in_zhact_gdmap=in_zhact_gdmap;
788 return true; 788 return true;
789 } 789 }
790 - return false; 790 +
  791 + item_act_map.act_num=0;
  792 + return true;
791 } 793 }
792 794
793 795
utils/more_cx.js 0 → 100644
  1 +var regeneratorRuntime = require('runtime.js');
  2 +module.exports = {
  3 + zhqty_bz_fun(zhqty_bz,be,zhqty_bz_arr){
  4 + let zhqty_bz_flag =true;
  5 + for(let i=0;i<zhqty_bz.length;i++){
  6 + let item=zhqty_bz[i];
  7 + let bz_num = be * item['zhqty']; //超量倍增
  8 + let num = item['num'] - item['zhqty']; //购买数量减去超量
  9 + if (bz_num > num) {
  10 + zhqty_bz_flag=false;
  11 +
  12 + var be=0;
  13 + if (num % vv.zhqty == 0) {
  14 + be = num / vv.zhqty;
  15 + } else {
  16 + be = Math.floor(num / vv.zhqty)
  17 + }
  18 + item.be=item;
  19 +
  20 + zhqty_bz_arr.push(item);
  21 + // zhqty_bz.splice(i,1)
  22 + }
  23 + }
  24 + return zhqty_bz_flag;
  25 + },
  26 + //-- 判断组合购有没有满足,只有在检查的时候,要用新的 ---
  27 + ch_zh_ok(act,gdlist,c_goods,th,item_act_map,is_need_ck_num,need_ok){
  28 +
  29 + //-- 寻找一下 --
  30 + function get_num(ite) {
  31 + for (let v1 in c_goods) {
  32 + var vh = c_goods[v1];
  33 + if (vh.goods_id == ite.goods_id) {
  34 + return vh;
  35 + }
  36 + }
  37 + return 0;
  38 + }
  39 + var goods =gdlist;
  40 + var all_num=0;
  41 + var need_to_buy=0;
  42 + var all_zhqty=0;
  43 + //-- 是综合考虑到组合购的总数量和限购数量 --
  44 + var min_can_buy=-1;
  45 + var aid=act.id;
  46 +
  47 + let no_in_arr = []; //剩余的未加入组合购
  48 + let out_arr = []; //超出活动限购的商品放入
  49 +
  50 + //-- 判断组合购的总数量是不是到了 --
  51 + if(act.zh_num>0){
  52 + //如果是在全选的情况下,那么就需要in_zhact_new来控制数量
  53 + var need_ck=0;
  54 + if(is_need_ck_num){
  55 + need_ck=th.data.in_zhact_new[aid]?th.data.in_zhact_new[aid]:0;
  56 + }
  57 + if(need_ck+act.zh_buy_num>=act.zh_num ){
  58 + return false;
  59 + }else{
  60 + min_can_buy= act.zh_num-act.zh_buy_num-need_ck;
  61 + }
  62 + }
  63 + //-- 判断组合购的限购是不是到了 --
  64 + if(act.buy_limit>0){
  65 + var need_ck0=0;
  66 + if(is_need_ck_num){
  67 + need_ck0=th.data.in_zhact_new[aid]?th.data.in_zhact_new[aid]:0;
  68 + }
  69 + var min_can_buy0=0;
  70 + if(need_ck+item_act_map.buyed>=act.buy_limit ){
  71 + return false;
  72 + }else{
  73 + min_can_buy0=act.buy_limit-item_act_map.buyed-need_ck;
  74 + }
  75 + if(min_can_buy>0){
  76 + if(min_can_buy0<min_can_buy) min_can_buy=min_can_buy0;
  77 + }else{
  78 + min_can_buy=min_can_buy0;
  79 + }
  80 + }
  81 +
  82 + if(!need_ok) return true;
  83 + for (var i in goods) {
  84 + var item = goods[i];
  85 + var cart_num = get_num(item).goods_num;
  86 + var zh_b_num = get_num(item).zh_b_num;
  87 + if (!cart_num) {
  88 + if (item.zhqty) {
  89 + need_to_buy += item.zhqty;
  90 + }
  91 + continue;
  92 + }
  93 +
  94 + item.cart_num = cart_num;
  95 + //-- 当商品有购买的时候,以及有限购的时候 --
  96 + if (item.buyqty > 0) {
  97 + var cbuy = item.buyqty - zh_b_num;
  98 + var key = item.goods_id + "." + act.id;
  99 + if (is_need_ck_num && th.data.in_zhact_gdmap_new[key]) {
  100 + var cbuy = item.buyqty - zh_b_num - th.data.in_zhact_gdmap_new[key];
  101 + }
  102 + //当可买的数量为0
  103 + if (cbuy <= 0) {
  104 + item.num = 0;
  105 + out_arr.push({
  106 + goods_id: item.goods_id,
  107 + num: cart_num
  108 + })
  109 + } else {
  110 + if (cbuy >= cart_num) item.num = cart_num;
  111 + else {
  112 + item.num = cbuy;
  113 + out_arr.push({
  114 + goods_id: item.goods_id,
  115 + num: cart_num - cbuy
  116 + })
  117 + }
  118 + }
  119 + } else {
  120 + item.num = cart_num;
  121 + }
  122 +
  123 + if (item.num) {
  124 + all_num += item.num;
  125 + //当有起购数的控制的时候
  126 + if (item.zhqty) {
  127 + all_zhqty += item.zhqty;
  128 + if (item.num < item.zhqty) {
  129 + need_to_buy += item.zhqty - item.num;
  130 + }
  131 + if (item.num > item.zhqty) {
  132 + for (let i = 0; i < item.num - item.zhqty; i++) {
  133 + no_in_arr.push({
  134 + goods_id: item.goods_id,
  135 + })
  136 + }
  137 + }
  138 + }
  139 + else {
  140 + for (let j = 0; j < item.num; j++) {
  141 + no_in_arr.push({
  142 + goods_id: item.goods_id,
  143 + })
  144 + }
  145 + }
  146 + } else {
  147 + if (item.zhqty) {
  148 + need_to_buy += item.zhqty;
  149 + }
  150 + }
  151 + }
  152 + //当满足组合的要求:总数要满足,起购数要满足
  153 + if (all_num >= act.zhbuyqty && !need_to_buy) {
  154 + //默认数量是1
  155 + var act_num=1;
  156 + function sortData(a, b) {
  157 + return a.price - b.price
  158 + }
  159 + if (no_in_arr.length > 0) no_in_arr.sort(sortData);
  160 + if (act.zhbuyqty > all_zhqty) {
  161 + for (let n = 0; n < act.zhbuyqty - all_zhqty; n++) {
  162 + no_in_arr.pop();
  163 + }
  164 + }
  165 +
  166 + //看一下剩下的数量有没有满足组合购的要求,以及要不要倍增
  167 + if (act.is_bz && no_in_arr.length >= act.zhbuyqty) {
  168 +
  169 + var bz_num_ok = 0; //超量倍增是否满足
  170 + var zhqty_len = 0; //几个超量倍增
  171 + var delete_num = 0;
  172 + //看一下是几倍
  173 + let be = parseInt(no_in_arr.length / act.zhbuyqty);
  174 + //如果有总数控制的时候
  175 + if (min_can_buy>0) {
  176 + var be1 = min_can_buy - 1;
  177 + if (be1 < be) be = be1;
  178 + }
  179 + if(be) {
  180 + if (act.is_bzyh && zhqty_bz.length > 0) {
  181 +
  182 + let zhqty_bz_arr = [];
  183 + let zhqty_bz_flag = this.zhqty_bz_fun(zhqty_bz, be, zhqty_bz_arr);
  184 + if (zhqty_bz_flag) {
  185 + for (let i = 0; i < zhqty_bz.length; i++) {
  186 + var vv = zhqty_bz[i];
  187 + for (let j = 0; j < be * vv['zhqty']; j++) {
  188 + let index = no_in_arr.findIndex(i => {
  189 + return vv.goods_id === i.goods_id
  190 + })
  191 + if (index > -1) {
  192 + delete_num++
  193 + no_in_arr.splice(index, 1)
  194 + }
  195 + }
  196 + }
  197 + } else {
  198 + zhqty_len = 1;
  199 + let min_bz_num = Math.min.apply(Math, zhqty_bz_arr.map(function (o) {
  200 + return o['be'];
  201 + }));
  202 + let new_arr = zhqty_bz_arr.filter(ii => {
  203 + return ii['be'] == min_bz_num;
  204 + })
  205 + //-- 要看一下倍数还有没有 ---
  206 + be = new_arr[0].be;
  207 + //如果有总数控制的时候
  208 + if (min_can_buy>0) {
  209 + var be1 = min_can_buy - 1;
  210 + if (be1 < be) be = be1;
  211 + }
  212 + if(be){
  213 + for (let i = 0; i < zhqty_bz.length; i++) {
  214 + let item1 = zhqty_bz[i];
  215 + for (let j = 0; j < be * item1['zhqty']; j++) {
  216 + let index = no_in_arr.findIndex(i => {
  217 + return item1.goods_id === i.goods_id
  218 + })
  219 + if (index > -1) {
  220 + no_in_arr.splice(index, 1)
  221 + }
  222 + }
  223 + }
  224 + act_num+=be;
  225 + }
  226 + }
  227 + }
  228 + if (!zhqty_len) {
  229 + let pop_num = be * act.zhbuyqty - delete_num;
  230 + for (var m = 0; m < pop_num; m++) {
  231 + no_in_arr.pop();
  232 + }
  233 + act_num+=be;
  234 + }
  235 + }
  236 + }
  237 +
  238 + //-- 参与活动的金额要返回回去 --
  239 + item_act_map.act_num=act_num;
  240 + let goods_map = {};
  241 + //算一下剩余的商品
  242 + if (no_in_arr.length) {
  243 + for (let ii in no_in_arr) {
  244 + let item = no_in_arr[ii];
  245 + if (goods_map[item.goods_id]) {
  246 + var num = goods_map[item.goods_id];
  247 + goods_map[item.goods_id] = ++num;
  248 + } else {
  249 + goods_map[item.goods_id] = 1;
  250 + }
  251 + }
  252 + }
  253 + //超量的部分也要计算一下
  254 + if (out_arr.length) {
  255 + for (var m in out_arr) {
  256 + if (goods_map[item.goods_id]) {
  257 + var num = goods_map[item.goods_id];
  258 + num += item.num
  259 + goods_map[item.goods_id] = num;
  260 + } else {
  261 + goods_map[item.goods_id] = item.num;
  262 + }
  263 + }
  264 + }
  265 +
  266 + //-- 组合购的商品限购的数组控制 --
  267 + var in_zhact_gdmap={};
  268 + //商品的列表
  269 + for (var u in goods) {
  270 + var ite = goods[u];
  271 + var cart_num = get_num(ite).goods_num;
  272 +
  273 + if (ite.buyqty > 0 && cart_num > 0) {
  274 + var key = ite.goods_id + "." + act.id;
  275 + if(goods_map[ite.goods_id]){
  276 + cart_num-=goods_map[ite.goods_id];
  277 + }
  278 + if(cart_num>0){
  279 + if (in_zhact_gdmap[key]) {
  280 + in_zhact_gdmap[key] += ite.num;
  281 + } else {
  282 + in_zhact_gdmap[key] = ite.num;
  283 + }
  284 + }
  285 +
  286 + }
  287 + }
  288 + item_act_map.in_zhact_gdmap=in_zhact_gdmap;
  289 + return true;
  290 + }
  291 + return false;
  292 + },
  293 + //-- 判读一下促销分组的问题 --
  294 + //-- is_need_ck_num 是多门店计算的时候,数量是不是要累家计算 --
  295 + //-- need_ok是判断要不要满足条件 --
  296 + async cart_cx_group(th,goods,car_item,is_need_ck_num,need_ok,func){
  297 +
  298 + var os= getApp().globalData.setting;
  299 + //更改活动的时候,就不能再重新计算活动,只有再加减数量和选择商品的时候,就要重新计算活动
  300 + if(th.data.change_act || (car_item.show_can_cx && Object.keys(car_item.show_can_cx).length>0)){
  301 + var show_can_cx=car_item.show_can_cx;
  302 + for(var k in show_can_cx){
  303 + var k_item=show_can_cx[k];
  304 + var ck_prom_type=null;
  305 + //-- 如果是多活动,先把活动按照后台的顺序排序一下,
  306 + //-- 同时确定一下商品最终要用什么活动来购买计算。 --就是要进行切换 --
  307 + if(k_item.act_arr.length>1){
  308 + var json_d =th.data.json_d;
  309 + var auto_promote_sale=json_d.auto_promote_sale;
  310 + var sort_type='';
  311 +
  312 + if(!auto_promote_sale){
  313 + sort_type='prom_type';
  314 + }else{
  315 + var auto_promote_sale=auto_promote_sale.split(',');
  316 + //-- 循环处理 --
  317 + k_item.act_arr.map(function (e){
  318 + var fd=auto_promote_sale.indexOf(e.prom_type+'');
  319 + e.sort=fd;
  320 + })
  321 + sort_type='sort';
  322 + }
  323 + //-- 排序一下,进行升序 --
  324 + function comp(a, b) {
  325 + return a[sort_type]-b[sort_type]; //升序
  326 + }
  327 + //活动要排序一下
  328 + k_item.act_arr.sort(comp);
  329 +
  330 + //确定一下活动,先看一下有没有选择的活动
  331 + ck_prom_type=k_item.act_arr.find(function (el){
  332 + return el.sele;
  333 + })
  334 +
  335 + }
  336 + //-- 此时已经确定了商品的活动是什么类型的,可以确定购物车中商品的具体活动进行金额的计算 --
  337 + if(!ck_prom_type) ck_prom_type=k_item.act_arr[0];
  338 +
  339 + //-- 此时要把购物车中的商品确定活动 --
  340 + for (var b=0; b<ck_prom_type.goods.length;b++){
  341 + //-- 开始查找 --
  342 + var fg=goods.findIndex(function (g_item){
  343 + return g_item.goods_id==ck_prom_type.goods[b].goods_id && [0,3,5,7,10].indexOf(g_item.prom_type)>-1;
  344 + })
  345 + if(fg>-1){
  346 + goods[fg].prom_type=ck_prom_type.prom_type;
  347 + goods[fg].prom_id=ck_prom_type.prom_id;
  348 + }
  349 + }
  350 +
  351 + }
  352 + func(show_can_cx);
  353 + return false;
  354 + }
  355 +
  356 + //-- 促销活动对象表,最初的map表,包含活动类型,活动id,goods商品 ---
  357 + var cx_act_map=[];
  358 + for(var i=0; i<goods.length;i++){
  359 + var c_item=goods[i];
  360 + //没有选中
  361 + if(!c_item.selected) continue;
  362 + //如果是秒杀之类是商品
  363 + if([1,2,4,6,8,9].indexOf(c_item.prom_type)>-1) continue;
  364 +
  365 + //-- 把活动进行规整 --
  366 + var more_cx=c_item.more_cx;
  367 + for (var j=0;j<more_cx.length;j++){
  368 + var n_item=more_cx[j];
  369 + var key=n_item.prom_type+'-'+n_item.prom_id;
  370 + var fd=cx_act_map.find(function (e){
  371 + return e.key==key;
  372 + })
  373 + if(fd){
  374 + fd.goods.push(c_item);
  375 + }else{
  376 + var p_item={key:key,prom_type:n_item.prom_type,prom_id:n_item.prom_id,goods:[],act:n_item};
  377 + if(n_item.prom_type==7){
  378 + p_item.zh_pro=n_item.zh_pro;
  379 + }
  380 + p_item.goods.push(c_item);
  381 + cx_act_map.push(p_item);
  382 + }
  383 + }
  384 + goods[i].prom_type=0;
  385 + goods[i].prom_id=0;
  386 + }
  387 + //-- 如果活动数量大于1个,那么活动就要排序一下,有商品种类数最多排再前面,降序进行排列 --
  388 + if(cx_act_map.length>1){
  389 + //门店分类要排序下
  390 + function compare(a, b) {
  391 + var value1 = a.goods.length;
  392 + var value2 = b.goods.length;
  393 + return value2 - value1;
  394 + }
  395 + cx_act_map.sort(compare);
  396 + }
  397 + //-- 能够进行最后计算的活动(包含切换) --
  398 + var can_calc_cx=[];
  399 + //-- 此时对数组的活动进行判断,看能不能达到购买数量的条件 --
  400 + for(var ii=0;ii<cx_act_map.length;ii++){
  401 +
  402 + var item_act_map=cx_act_map[ii];
  403 + //如果活动有交集的时候,商品数量一样多(不是完全相同时,就是参与的商品有交集),就按照后台确定的活动顺序
  404 + //如果活动商品数量少的和 活动数量多的 有交集,那么数量少的不显示,也不计算
  405 + //如果活动的商品一样(那就是多活动切换),优先计算的活动按照后台确定的活动顺序
  406 + if(!this.check_ok_cx_pro(item_act_map,can_calc_cx)){
  407 + continue;
  408 + }
  409 + switch(item_act_map.prom_type){
  410 + case 3:
  411 + //活动ID
  412 + var aid=item_act_map.prom_id;
  413 + var need_num=0;
  414 + //-- 这个时候要判断是不是要判断优惠促销多门店的时候的限购 --
  415 + if(is_need_ck_num){
  416 + need_num=th.data.in_yhact_new[aid]?th.data.in_yhact_new[aid]:0;
  417 + }
  418 + //-- 判断优惠促销要不要限购 --
  419 + var fd=null;
  420 + var fd_res = await getApp().request.promiseGet('/api/weshop/promgoods/get/'+os.stoid+'/'+ky0,{})
  421 + if(fd_res && fd_res.data.code==0 ){
  422 + fd=fd_res.data.data;
  423 + }
  424 + //如果有限购的时候,也要计算一下
  425 + if (fd && fd['limit_num'] > 0){
  426 + //-- 获取已经购买了多少件 --
  427 + var url = "/api/weshop/ordergoods/getUserBuyPromNum?store_id="+os.stoid+"&user_id="
  428 + +getApp().globalData.user_id+"&prom_type=3&prom_id="+zh_pro0.id;
  429 + await getApp().request.promiseGet(url, {}).then(rh => {
  430 + if(rh.data.code==0){
  431 + item_act_map.buyed=rh.data.data.userbuynum;
  432 + }
  433 + })
  434 + if(item_act_map.buyed+need_num>=fd['limit_num']){
  435 + continue; //-- 进行下一个循环 --
  436 + }
  437 + }
  438 +
  439 + if(!need_ok){
  440 + can_calc_cx.push(item_act_map);
  441 + continue;
  442 + }
  443 +
  444 + var fir_act=item_act_map.act.fir_act;
  445 + var t_goods=item_act_map.goods;
  446 + var all_num=0;
  447 + var all_pri=0;
  448 + for(var f=0;f<t_goods.length;f++){
  449 + all_num+=t_goods[f].goods_num;
  450 + all_pri+=t_goods[f].goods_num*t_goods[f].goods_price;
  451 + }
  452 + var yh_ok=1;
  453 + switch (fir_act.prom_type){
  454 + case 0:
  455 + if(all_pri<fir_act.condition) {
  456 + yh_ok=0;
  457 + }
  458 + break;
  459 + case 1:
  460 + if(all_num<fir_act.condition) {
  461 + yh_ok=0;
  462 + }
  463 + break;
  464 + }
  465 + //-- 如果有满足优惠条件的时候 --
  466 + if(yh_ok){
  467 + can_calc_cx.push(item_act_map)
  468 + }
  469 + break
  470 +
  471 + case 7:
  472 + //-- 活动列表 --
  473 + var zhact_gdlist=item_act_map.act.gdlist;
  474 + var zh_goods=item_act_map.goods;
  475 + //--- 要循环计算一下商品的已购数量 ---
  476 + for(var h=0;h<zh_goods.length;h++){
  477 + //-- 商品的限购 --
  478 + var promgoodsbuynum = 0;
  479 + var res=await getApp().request.promiseGet("/api/weshop/ordergoods/getUserBuyGoodsNum", {
  480 + data: {
  481 + store_id: os.stoid,
  482 + user_id: getApp().globalData.user_id,
  483 + goods_id: zh_goods[h].goods_id,
  484 + prom_type: 7,
  485 + prom_id: item_act_map.prom_id
  486 + },
  487 + })
  488 + if(res.data.code==0 && res.data.data && res.data.data.promgoodsbuynum){
  489 + promgoodsbuynum = res.data.data.promgoodsbuynum;
  490 + }
  491 + zh_goods[h].zh_b_num=promgoodsbuynum;
  492 + }
  493 + //-- 放到参与组合优惠促销的map中 --
  494 + th.data.zuhe_map_good[item_act_map.prom_id] = zhact_gdlist;
  495 + if(!car_item.zh_prom_goods) car_item.zh_prom_goods={};
  496 + car_item.zh_prom_goods[item_act_map.prom_id] = zhact_gdlist;
  497 +
  498 + //-- 兼容购物车和确认订单的页面 --
  499 + var ob=th.data.zuhe_map;
  500 + if(!ob) ob=th.data.zhhe_act_map;
  501 +
  502 + var zh_pro0 = ob[item_act_map.prom_id];
  503 +
  504 + //-- 获取活动信息 --
  505 + var url = "/api/weshop/ordergoods/getUserBuyPromNum?store_id="+os.stoid+"&user_id="
  506 + +getApp().globalData.user_id+"&prom_type=7&prom_id="+zh_pro0.id;
  507 + await getApp().request.promiseGet(url, {}).then(rh => {
  508 + if(rh.data.code==0){
  509 + item_act_map.buyed=rh.data.data.userbuynum;
  510 + }
  511 + })
  512 + //当满足组合的要求:总数要满足,起购数要满足
  513 + if(this.ch_zh_ok(zh_pro0,zhact_gdlist,zh_goods,th,item_act_map,is_need_ck_num,need_ok)){
  514 + can_calc_cx.push(item_act_map)
  515 + }
  516 + break;
  517 + default:
  518 + can_calc_cx.push(item_act_map);
  519 + }
  520 +
  521 + }
  522 +
  523 + //-- 此时来给满足条件的活动进行分组~~相同参与商品和数量的归纳再一起, --
  524 + //-- 同时相同商品数量的活动,还要看取那一个来进行计算金额。 默认的时候是按照后台的顺序。--
  525 + //-- 有选择的时候,就按照切换选择了什么就按照什么来计算 --
  526 + //-- can_calc_cx的元素(item_act_map)最后是放到act_arr里面去了 --
  527 + var show_can_cx={};
  528 + if(can_calc_cx.length){
  529 + for(var p=0;p<can_calc_cx.length;p++){
  530 + var ch_map=[];
  531 + can_calc_cx[p].goods.map(function (gd){
  532 + ch_map.push(gd.goods_id);
  533 + })
  534 + ch_map.sort();
  535 + //-- 先找一下,有没有参与的商品一模一样的 --
  536 + var fd=show_can_cx[ch_map.join()];
  537 + if(fd){
  538 + //-- 把数组添加进去 --ch_map
  539 + fd.act_arr.push(can_calc_cx[p])
  540 + }else{
  541 + var e={ch_map:ch_map,act_arr:[]};
  542 + if(ch_map.length>1){
  543 + e.is_duo_gd=1;
  544 + }
  545 + e.act_arr.push(can_calc_cx[p]);
  546 + show_can_cx[ch_map.join()]=e;
  547 + }
  548 + }
  549 + }
  550 +
  551 + for(var k in show_can_cx){
  552 + var k_item=show_can_cx[k];
  553 + var ck_prom_type=null;
  554 + //-- 如果是多活动,先把活动按照后台的顺序排序一下,
  555 + //-- 同时确定一下商品最终要用什么活动来购买计算。 --就是要进行切换 --
  556 + if(k_item.act_arr.length>1){
  557 + var json_d =th.data.json_d;
  558 + var auto_promote_sale=json_d.auto_promote_sale;
  559 + var sort_type='';
  560 +
  561 + if(!auto_promote_sale){
  562 + sort_type='prom_type';
  563 + }else{
  564 + var auto_promote_sale=auto_promote_sale.split(',');
  565 + //-- 循环处理 --
  566 + k_item.act_arr.map(function (e){
  567 + var fd=auto_promote_sale.indexOf(e.prom_type+'');
  568 + e.sort=fd;
  569 + })
  570 + sort_type='sort';
  571 + }
  572 + //-- 排序一下,进行升序 --
  573 + function comp(a, b) {
  574 + return a[sort_type]-b[sort_type]; //升序
  575 + }
  576 + //活动要排序一下
  577 + k_item.act_arr.sort(comp);
  578 +
  579 + //确定一下活动,先看一下有没有选择的活动
  580 + ck_prom_type=k_item.act_arr.find(function (el){
  581 + return el.sele;
  582 + })
  583 +
  584 + }
  585 + //-- 此时已经确定了商品的活动是什么类型的,可以确定购物车中商品的具体活动进行金额的计算 --
  586 + if(!ck_prom_type){
  587 + ck_prom_type=k_item.act_arr[0];
  588 + k_item.act_arr[0].sele=1;
  589 + }
  590 +
  591 + //-- 如果是要控制数量的时候,也就是全选的时候,或者加减号的时候 --
  592 + if(is_need_ck_num){
  593 + var t_pid=ck_prom_type.prom_id;
  594 + switch (ck_prom_type.prom_type){
  595 + case 3:
  596 + if(!th.data.in_yhact_new[t_pid]) th.data.in_yhact_new[t_pid]=0;
  597 + th.data.in_yhact_new[t_pid]++;
  598 + break;
  599 + case 7:
  600 + if(!th.data.in_zhact_new[t_pid]) th.data.in_zhact_new[t_pid]=0;
  601 + th.data.in_zhact_new[t_pid]+=ck_prom_type.act_num;
  602 + //-- 数组的优化 --
  603 + var nei_gd_map=ck_prom_type.in_zhact_gdmap;
  604 + if(nei_gd_map){
  605 + for (var vg in nei_gd_map) {
  606 + if (!th.data.in_zhact_gdmap_new[vg]) th.data.in_zhact_gdmap_new[vg] = 0;
  607 + th.data.in_zhact_gdmap_new[vg] += nei_gd_map[vg];
  608 + }
  609 + }
  610 + break;
  611 + }
  612 + }
  613 + //-- 此时要把购物车中的商品确定活动 --
  614 + for (var b=0; b<ck_prom_type.goods.length;b++){
  615 + //-- 开始查找 --
  616 + var fg=goods.findIndex(function (g_item){
  617 + return g_item.goods_id==ck_prom_type.goods[b].goods_id && [0,3,5,7,10].indexOf(g_item.prom_type)>-1;
  618 + })
  619 + if(fg>-1){
  620 + goods[fg].prom_type=ck_prom_type.prom_type;
  621 + goods[fg].prom_id=ck_prom_type.prom_id;
  622 + }
  623 + }
  624 + }
  625 + //-- 显示到前端,并切换 --
  626 + //th.setData({show_can_cx})
  627 + //--- 调用回调函数 ---
  628 + func(show_can_cx);
  629 +
  630 + },
  631 + //-- 查看活动参与的商品是不是有重复交集的地方,是不是一样的商品数量,can_calc_cx这个数组也是按照商品的数量降序排列的--
  632 + check_ok_cx_pro(item_act_map,can_calc_cx){
  633 + //-- 加入第一个,返回真 --
  634 + if(!can_calc_cx.length) return true;
  635 + var th_goods=item_act_map.goods;
  636 + for(var i=0;i<can_calc_cx.length;i++){
  637 + var can_goods=can_calc_cx[i].goods;
  638 + //计算一下有交集的数量,没有交集,OK
  639 + var num=this.hasJiao(can_goods,th_goods);
  640 + if(!num) continue;
  641 + //计算一下俩个shu
  642 + if(can_goods.length==th_goods.length && can_goods.length==num){
  643 + return true;
  644 + }
  645 + if(can_goods.length>th_goods.length){
  646 + return false;
  647 + }
  648 + }
  649 + return true;
  650 + },
  651 + //-- 判断是不是有交集,返回交集的数量 --
  652 + hasJiao(arr1, arr2){
  653 + var num=0;
  654 + arr1.map(function (e){
  655 + var idx=arr2.findIndex(function (g){
  656 + return g.goods_id==e.goods_id;
  657 + })
  658 + if(idx>-1) num++;
  659 + })
  660 + return num;
  661 + },
  662 +
  663 +
  664 +}
0 \ No newline at end of file 665 \ No newline at end of file