活动价格逻辑修改

model/activity.go

@@ -44,6 +44,7 @@ type Activity struct {
 	ExcludeStandardBrandIdList []string
 	ExcludeStandardBrandIdList []string
 	CurrencyRmb                int `json:"currency_rmb"`
 	CurrencyRmb                int `json:"currency_rmb"`
 	CurrencyUs                 int `json:"currency_us"`
 	CurrencyUs                 int `json:"currency_us"`
+	UseType                    int `json:"use_type"`
 }
 }
 
 
 type ActivityItem struct {
 type ActivityItem struct {
@@ -58,9 +59,10 @@ type ActivityItem struct {
 	AddTime    int     `json:"add_time"`
 	AddTime    int     `json:"add_time"`
 }
 }
 
 
-//用于检查是否有活动情况的结构体
+// 用于检查是否有活动情况的结构体
 type ActivityCheckData struct {
 type ActivityCheckData struct {
 	SupplierId      int
 	SupplierId      int
+	GoodsName       string
 	BrandId         int
 	BrandId         int
 	StandardBrandId int
 	StandardBrandId int
 	GoodsId         string
 	GoodsId         string

service/service_activity.go

-package service
-
-import (
-	"encoding/json"
-	"fmt"
-	"go_sku_server/model"
-	"go_sku_server/pkg/gredis"
-	"strings"
-	"time"
-
-	"github.com/gogf/gf/util/gconv"
-	"github.com/gomodule/redigo/redis"
-	"github.com/syyongx/php2go"
-)
-
-type ActivityService struct {
-}
-
-//获取活动信息,目前是包括促销活动(系数打折)以及满赠活动
-func (as *ActivityService) GetActivityData(checkData model.ActivityCheckData) (priceActivity model.PriceActivity, giftActivity model.GiftActivity) {
-	supplierId := checkData.SupplierId
-	redisCon := gredis.Conn("default_r")
-	defer redisCon.Close()
-	//处理单品促销活动(打折活动)
-	activityStr, _ := redis.String(redisCon.Do("hget", "lie_price_activity", supplierId))
-	if activityStr != "" {
-		var activities []model.Activity
-		err := json.Unmarshal([]byte(activityStr), &activities)
-		if err != nil {
-			fmt.Println(err)
-		}
-		if len(activities) != 0 {
-			priceActivity = as.GetPriceActivity(checkData, activities)
-		}
-	}
-	return
-}
-
-//获取满赠活动信息
-func (as *ActivityService) GetGiftActivity(checkData model.ActivityCheckData, activities []model.Activity) (giftActivity model.GiftActivity) {
-	var hasActivity bool
-	nowTimestamp := int(time.Now().Unix())
-	for _, activity := range activities {
-		if activity.Status != 1 {
-			continue
-		}
-		//判断时间是否过期
-		if activity.StartTime > nowTimestamp || activity.EndTime < nowTimestamp {
-			continue
-		}
-
-		//如果是整个供应商搞活动,则直接返回系数
-		if activity.EntireSupplierActivity {
-			hasActivity = true
-			goto INFO
-		}
-
-		//判断是否是排除的sku或者品牌,如果是的话,直接返回没活动
-		if as.CheckExcludeSku(checkData.GoodsId, activity) || as.CheckExcludeBrand(checkData.BrandId, activity) {
-			continue
-		}
-
-		//判断是否是搞活动的品牌
-		if as.CheckBrand(checkData.BrandId, activity) {
-			hasActivity = true
-			goto INFO
-		}
-
-		//如果是专卖,则要去判断canal,如果是自营,则去判断分类
-		if checkData.SupplierId == 17 {
-			if as.CheckCanal(checkData.Canal, activity) {
-				hasActivity = true
-				goto INFO
-			}
-		} else {
-			if as.CheckClass(checkData.ClassId, activity) {
-				hasActivity = true
-				goto INFO
-			}
-		}
-	INFO:
-		if hasActivity {
-			for key, item := range activity.ItemList {
-				activity.ItemList[key].Content = "订单满" + gconv.String(item.Amount) + "元赠" +
-					gconv.String(item.ItemName) + "X" + gconv.String(item.Num) + "" + item.Remark
-			}
-			giftActivity.ActivityName = activity.ActivityName
-			giftActivity.ActivityId = activity.ActivityId
-			giftActivity = model.GiftActivity{
-				CanAdminOrder: activity.CanAdminOrder,
-				ItemList:      activity.ItemList,
-				ActivityCommon: model.ActivityCommon{
-					HasActivity:  hasActivity,
-					ActivityId:   activity.ActivityId,
-					ActivityName: activity.ActivityName,
-					AllowCoupon:  activity.AllowCoupon,
-					UserScope:    activity.UserScope,
-				},
-			}
-			break
-		}
-	}
-
-	return
-}
-
-func (as *ActivityService) GetPriceActivity(checkData model.ActivityCheckData, activities []model.Activity) (priceActivity model.PriceActivity) {
-	var hasActivity bool
-	nowTimestamp := int(time.Now().Unix())
-	for _, activity := range activities {
-		if activity.Status != 1 {
-			continue
-		}
-		//判断时间是否过期
-		if activity.StartTime > nowTimestamp || activity.EndTime < nowTimestamp {
-			continue
-		}
-		//如果是整个供应商搞活动,则直接返回系数
-		if activity.EntireSupplierActivity {
-			hasActivity = true
-			goto INFO
-		}
-
-		//判断是否是排除的sku或者品牌,如果是的话,直接返回没活动
-		if as.CheckExcludeSku(checkData.GoodsId, activity) || as.CheckExcludeStandardBrand(checkData.StandardBrandId, activity) {
-			continue
-		}
-
-		//如果是专卖,则要去判断canal,如果是自营,则去判断分类
-		if checkData.SupplierId == 17 {
-			if as.CheckCanal(checkData.Canal, activity) {
-				//品牌不为空,还要去判断品牌,是同时满足的关系
-				if activity.StandardBrandIds != "" {
-					//判断是否是搞活动的品牌
-					if as.CheckStandardBrand(checkData.StandardBrandId, activity) {
-						hasActivity = true
-						goto INFO
-					}
-				} else {
-					hasActivity = true
-					goto INFO
-				}
-			}
-		} else if checkData.SupplierId == 10000 {
-			//自营活动特殊判断
-			//判断活动指定的渠道编码,品牌,分类id,如果都为空,那么这个活动可以理解为整个供应商了,上面的排除已经会提前去判断了
-			if activity.StandardBrandIds == "" && activity.ClassIds == "" {
-				hasActivity = true
-				goto INFO
-			}
-			if as.CheckClass(checkData.ClassId, activity) {
-				//品牌不为空,还要去判断品牌,是同时满足的关系
-				if activity.StandardBrandIds != "" {
-					//判断是否是搞活动的品牌
-					if as.CheckStandardBrand(checkData.StandardBrandId, activity) {
-						hasActivity = true
-						goto INFO
-					}
-				} else {
-					hasActivity = true
-					goto INFO
-				}
-			}
-		} else {
-			//判断是否是搞活动的品牌
-			if as.CheckStandardBrand(checkData.StandardBrandId, activity) {
-				hasActivity = true
-				goto INFO
-			}
-		}
-	INFO:
-		if hasActivity {
-			priceActivity.ActivityName = activity.ActivityName
-			priceActivity.ActivityId = activity.ActivityId
-			priceActivity = model.PriceActivity{
-				Ratio:    activity.Ratio,
-				SignText: activity.SignText,
-				Sign:     activity.Sign,
-				ShowName: activity.ShowName,
-				ActivityCommon: model.ActivityCommon{
-					HasActivity:  hasActivity,
-					ActivityId:   activity.ActivityId,
-					ActivityName: activity.ActivityName,
-					AllowCoupon:  activity.AllowCoupon,
-					UserScope:    activity.UserScope,
-				},
-			}
-			if activity.CurrencyRmb == 1 {
-				priceActivity.Ratio = activity.Ratio
-			} else {
-				priceActivity.Ratio = 0
-			}
-			if activity.CurrencyUs == 1 {
-				priceActivity.RatioUs = activity.RatioUs
-			} else {
-				priceActivity.RatioUs = 0
-			}
-			break
-		}
-	}
-
-	priceActivity.HasActivity = hasActivity
-	return
-}
-
-//检查是否属于被排除的品牌
-func (as *ActivityService) CheckExcludeBrand(brandId int, activity model.Activity) bool {
-	if brandId == 0 {
-		return false
-	}
-	//先去判断品牌
-	activity.ExcludeBrandIdList = strings.Split(activity.ExcludeBrandIds, ",")
-	brandIdStr := gconv.String(brandId)
-	//如果存在于有活动价的品牌,就是有折扣活动了
-	if php2go.InArray(brandIdStr, activity.ExcludeBrandIdList) {
-		return true
-	}
-	return false
-}
-
-//检查是否属于被排除的标准品牌
-func (as *ActivityService) CheckExcludeStandardBrand(standardBrandId int, activity model.Activity) bool {
-	if standardBrandId == 0 {
-		return false
-	}
-	//先去判断品牌
-	activity.ExcludeStandardBrandIdList = strings.Split(activity.ExcludeStandardBrandIds, ",")
-	standardBrandIdStr := gconv.String(standardBrandId)
-	//如果存在于有活动价的品牌,就是有折扣活动了
-	if php2go.InArray(standardBrandIdStr, activity.ExcludeStandardBrandIdList) {
-		return true
-	}
-	return false
-}
-
-//检查是否属于被排除的sku
-func (as *ActivityService) CheckExcludeSku(skuId string, activity model.Activity) bool {
-	if skuId == "" {
-		return false
-	}
-	//先去判断品牌
-	activity.ExcludeSkuIdList = strings.Split(activity.ExcludeSkuIds, ",")
-	//如果存在于有活动价的品牌,就是有折扣活动了
-	if php2go.InArray(skuId, activity.ExcludeSkuIdList) {
-		return true
-	}
-	return false
-}
-
-//检查是否属于活动分类(只有自营需要判断)
-func (as *ActivityService) CheckClass(classId int, activity model.Activity) bool {
-	if classId == 0 {
-		return false
-	}
-	//先去判断品牌
-	activity.ClassIdList = strings.Split(activity.ClassIds, ",")
-	classIdStr := gconv.String(classId)
-	//如果存在于有活动价的品牌,就是有折扣活动了
-	if php2go.InArray(classIdStr, activity.ClassIdList) {
-		return true
-	}
-	return false
-}
-
-//检查是否属于活动品牌
-func (as *ActivityService) CheckBrand(brandId int, activity model.Activity) bool {
-	if brandId == 0 {
-		return false
-	}
-	//先去判断品牌
-	activity.BrandIdList = strings.Split(activity.BrandIds, ",")
-	brandIdStr := gconv.String(brandId)
-	//如果存在于有活动价的品牌,就是有折扣活动了
-	if php2go.InArray(brandIdStr, activity.BrandIdList) {
-		return true
-	}
-	return false
-}
-
-//检测是否属于活动标准品牌
-func (as *ActivityService) CheckStandardBrand(standardBrandId int, activity model.Activity) bool {
-	if standardBrandId == 0 {
-		return false
-	}
-	//先去判断品牌
-	activity.StandardBrandIdList = strings.Split(activity.StandardBrandIds, ",")
-	standardBrandIdStr := gconv.String(standardBrandId)
-	//如果存在于有活动价的品牌,就是有折扣活动了
-	if php2go.InArray(standardBrandIdStr, activity.StandardBrandIdList) {
-		return true
-	}
-	return false
-}
-
-//检查是否属于供应商渠道
-func (as *ActivityService) CheckCanal(canal string, activity model.Activity) bool {
-	if canal == "" {
-		return false
-	}
-	//先去判断品牌
-	activity.CanalList = strings.Split(activity.Canals, ",")
-	//如果存在于有活动价的品牌,就是有折扣活动了
-	if php2go.InArray(canal, activity.CanalList) {
-		return true
-	}
-	return false
-}
+package service
+
+import (
+	"encoding/json"
+	"fmt"
+	"go_sku_server/model"
+	"go_sku_server/pkg/gredis"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/gogf/gf/util/gconv"
+	"github.com/gomodule/redigo/redis"
+	"github.com/syyongx/php2go"
+)
+
+type ActivityService struct {
+}
+
+// 获取活动信息,目前是包括促销活动(系数打折)以及满赠活动
+func (as *ActivityService) GetActivityData(checkData model.ActivityCheckData) (priceActivity model.PriceActivity, giftActivity model.GiftActivity) {
+	supplierId := checkData.SupplierId
+	redisCon := gredis.Conn("default_r")
+	defer redisCon.Close()
+	//处理单品促销活动(打折活动)
+	activityStr, _ := redis.String(redisCon.Do("hget", "lie_price_activity", supplierId))
+	if activityStr != "" {
+		var activities []model.Activity
+		err := json.Unmarshal([]byte(activityStr), &activities)
+		if err != nil {
+			fmt.Println(err)
+		}
+		if len(activities) != 0 {
+			priceActivity = as.GetPriceActivity(checkData, activities)
+		}
+	}
+	return
+}
+
+// 获取满赠活动信息
+func (as *ActivityService) GetGiftActivity(checkData model.ActivityCheckData, activities []model.Activity) (giftActivity model.GiftActivity) {
+	var hasActivity bool
+	nowTimestamp := int(time.Now().Unix())
+	for _, activity := range activities {
+		if activity.Status != 1 {
+			continue
+		}
+		//判断时间是否过期
+		if activity.StartTime > nowTimestamp || activity.EndTime < nowTimestamp {
+			continue
+		}
+
+		//如果是整个供应商搞活动,则直接返回系数
+		if activity.EntireSupplierActivity {
+			hasActivity = true
+			goto INFO
+		}
+
+		//判断是否是排除的sku或者品牌,如果是的话,直接返回没活动
+		if as.CheckExcludeSku(checkData.GoodsId, activity) || as.CheckExcludeBrand(checkData.BrandId, activity) {
+			continue
+		}
+
+		//判断是否是搞活动的品牌
+		if as.CheckBrand(checkData.BrandId, activity) {
+			hasActivity = true
+			goto INFO
+		}
+
+		//如果是专卖,则要去判断canal,如果是自营,则去判断分类
+		if checkData.SupplierId == 17 {
+			if as.CheckCanal(checkData.Canal, activity) {
+				hasActivity = true
+				goto INFO
+			}
+		} else {
+			if as.CheckClass(checkData.ClassId, activity) {
+				hasActivity = true
+				goto INFO
+			}
+		}
+	INFO:
+		if hasActivity {
+			for key, item := range activity.ItemList {
+				activity.ItemList[key].Content = "订单满" + gconv.String(item.Amount) + "元赠" +
+					gconv.String(item.ItemName) + "X" + gconv.String(item.Num) + "" + item.Remark
+			}
+			giftActivity.ActivityName = activity.ActivityName
+			giftActivity.ActivityId = activity.ActivityId
+			giftActivity = model.GiftActivity{
+				CanAdminOrder: activity.CanAdminOrder,
+				ItemList:      activity.ItemList,
+				ActivityCommon: model.ActivityCommon{
+					HasActivity:  hasActivity,
+					ActivityId:   activity.ActivityId,
+					ActivityName: activity.ActivityName,
+					AllowCoupon:  activity.AllowCoupon,
+					UserScope:    activity.UserScope,
+				},
+			}
+			break
+		}
+	}
+
+	return
+}
+
+func (as *ActivityService) GetPriceActivity(checkData model.ActivityCheckData, activities []model.Activity) (priceActivity model.PriceActivity) {
+	redisConn := gredis.Conn("default_r")
+	defer redisConn.Close()
+	var hasActivity bool
+	nowTimestamp := int(time.Now().Unix())
+	for _, activity := range activities {
+		if activity.Status != 1 {
+			continue
+		}
+		//判断时间是否过期
+		if activity.StartTime > nowTimestamp || activity.EndTime < nowTimestamp {
+			continue
+		}
+		//如果是整个供应商搞活动,则直接返回系数
+		if activity.EntireSupplierActivity {
+			hasActivity = true
+			goto INFO
+		}
+
+		//判断是否是排除的sku或者品牌,如果是的话,直接返回没活动
+		if as.CheckExcludeSku(checkData.GoodsId, activity) || as.CheckExcludeStandardBrand(checkData.StandardBrandId, activity) {
+			continue
+		}
+
+		//如果是专卖,则要去判断canal,如果是自营,则去判断分类
+		if checkData.SupplierId == 17 {
+			if checkData.Canal != "" {
+				if !as.CheckCanal(checkData.Canal, activity) {
+					continue
+				}
+			}
+			if activity.UseType == 2 {
+				//判断商品名称是否在redis
+				redisKey := "lie_activity_and_coupon_sku_" + strconv.Itoa(activity.ActivityId)
+				exists, _ := redis.Bool(redisConn.Do("hexists", redisKey, checkData.GoodsName))
+				if exists {
+					hasActivity = true
+					goto INFO
+				}
+			} else {
+				//不等于2都是根据品牌来,因为老数据以前也只有品牌,0和1都是品牌
+				//品牌不为空,还要去判断品牌,是同时满足的关系
+				if activity.StandardBrandIds != "" {
+					//判断是否是搞活动的品牌
+					if as.CheckStandardBrand(checkData.StandardBrandId, activity) {
+						hasActivity = true
+						goto INFO
+					}
+				} else {
+					hasActivity = true
+					goto INFO
+				}
+			}
+
+		} else if checkData.SupplierId == 10000 {
+			//自营活动特殊判断
+			//判断活动指定的渠道编码,品牌,分类id,如果都为空,那么这个活动可以理解为整个供应商了,上面的排除已经会提前去判断了
+			if activity.StandardBrandIds == "" && activity.ClassIds == "" {
+				hasActivity = true
+				goto INFO
+			}
+			if as.CheckClass(checkData.ClassId, activity) {
+				//品牌不为空,还要去判断品牌,是同时满足的关系
+				if activity.StandardBrandIds != "" {
+					//判断是否是搞活动的品牌
+					if as.CheckStandardBrand(checkData.StandardBrandId, activity) {
+						hasActivity = true
+						goto INFO
+					}
+				} else {
+					hasActivity = true
+					goto INFO
+				}
+			}
+		} else {
+			//这是针对代购的
+			//判断是否是搞活动的品牌
+			if activity.UseType == 2 {
+				//判断商品名称是否在redis
+				redisKey := "lie_activity_and_coupon_sku_" + strconv.Itoa(activity.ActivityId)
+				exists, _ := redis.Bool(redisConn.Do("hexists", redisKey, checkData.GoodsName))
+				if exists {
+					hasActivity = true
+					goto INFO
+				}
+			} else {
+				//不等于2都是根据品牌来,因为老数据以前也只有品牌,0和1都是品牌
+				//品牌不为空,还要去判断品牌,是同时满足的关系
+				if activity.StandardBrandIds != "" {
+					//判断是否是搞活动的品牌
+					if as.CheckStandardBrand(checkData.StandardBrandId, activity) {
+						hasActivity = true
+						goto INFO
+					}
+				} else {
+					hasActivity = true
+					goto INFO
+				}
+			}
+		}
+	INFO:
+		if hasActivity {
+			priceActivity.ActivityName = activity.ActivityName
+			priceActivity.ActivityId = activity.ActivityId
+			priceActivity = model.PriceActivity{
+				Ratio:    activity.Ratio,
+				SignText: activity.SignText,
+				Sign:     activity.Sign,
+				ShowName: activity.ShowName,
+				ActivityCommon: model.ActivityCommon{
+					HasActivity:  hasActivity,
+					ActivityId:   activity.ActivityId,
+					ActivityName: activity.ActivityName,
+					AllowCoupon:  activity.AllowCoupon,
+					UserScope:    activity.UserScope,
+				},
+			}
+			if activity.CurrencyRmb == 1 {
+				priceActivity.Ratio = activity.Ratio
+			} else {
+				priceActivity.Ratio = 0
+			}
+			if activity.CurrencyUs == 1 {
+				priceActivity.RatioUs = activity.RatioUs
+			} else {
+				priceActivity.RatioUs = 0
+			}
+			break
+		}
+	}
+
+	priceActivity.HasActivity = hasActivity
+	return
+}
+
+// 检查是否属于被排除的品牌
+func (as *ActivityService) CheckExcludeBrand(brandId int, activity model.Activity) bool {
+	if brandId == 0 {
+		return false
+	}
+	//先去判断品牌
+	activity.ExcludeBrandIdList = strings.Split(activity.ExcludeBrandIds, ",")
+	brandIdStr := gconv.String(brandId)
+	//如果存在于有活动价的品牌,就是有折扣活动了
+	if php2go.InArray(brandIdStr, activity.ExcludeBrandIdList) {
+		return true
+	}
+	return false
+}
+
+// 检查是否属于被排除的标准品牌
+func (as *ActivityService) CheckExcludeStandardBrand(standardBrandId int, activity model.Activity) bool {
+	if standardBrandId == 0 {
+		return false
+	}
+	//先去判断品牌
+	activity.ExcludeStandardBrandIdList = strings.Split(activity.ExcludeStandardBrandIds, ",")
+	standardBrandIdStr := gconv.String(standardBrandId)
+	//如果存在于有活动价的品牌,就是有折扣活动了
+	if php2go.InArray(standardBrandIdStr, activity.ExcludeStandardBrandIdList) {
+		return true
+	}
+	return false
+}
+
+// 检查是否属于被排除的sku
+func (as *ActivityService) CheckExcludeSku(skuId string, activity model.Activity) bool {
+	if skuId == "" {
+		return false
+	}
+	//先去判断品牌
+	activity.ExcludeSkuIdList = strings.Split(activity.ExcludeSkuIds, ",")
+	//如果存在于有活动价的品牌,就是有折扣活动了
+	if php2go.InArray(skuId, activity.ExcludeSkuIdList) {
+		return true
+	}
+	return false
+}
+
+// 检查是否属于活动分类(只有自营需要判断)
+func (as *ActivityService) CheckClass(classId int, activity model.Activity) bool {
+	if classId == 0 {
+		return false
+	}
+	//先去判断品牌
+	activity.ClassIdList = strings.Split(activity.ClassIds, ",")
+	classIdStr := gconv.String(classId)
+	//如果存在于有活动价的品牌,就是有折扣活动了
+	if php2go.InArray(classIdStr, activity.ClassIdList) {
+		return true
+	}
+	return false
+}
+
+// 检查是否属于活动品牌
+func (as *ActivityService) CheckBrand(brandId int, activity model.Activity) bool {
+	if brandId == 0 {
+		return false
+	}
+	//先去判断品牌
+	activity.BrandIdList = strings.Split(activity.BrandIds, ",")
+	brandIdStr := gconv.String(brandId)
+	//如果存在于有活动价的品牌,就是有折扣活动了
+	if php2go.InArray(brandIdStr, activity.BrandIdList) {
+		return true
+	}
+	return false
+}
+
+// 检测是否属于活动标准品牌
+func (as *ActivityService) CheckStandardBrand(standardBrandId int, activity model.Activity) bool {
+	if standardBrandId == 0 {
+		return false
+	}
+	//先去判断品牌
+	activity.StandardBrandIdList = strings.Split(activity.StandardBrandIds, ",")
+	standardBrandIdStr := gconv.String(standardBrandId)
+	//如果存在于有活动价的品牌,就是有折扣活动了
+	if php2go.InArray(standardBrandIdStr, activity.StandardBrandIdList) {
+		return true
+	}
+	return false
+}
+
+// 检查是否属于供应商渠道
+func (as *ActivityService) CheckCanal(canal string, activity model.Activity) bool {
+	if canal == "" {
+		return false
+	}
+	//先去判断品牌
+	activity.CanalList = strings.Split(activity.Canals, ",")
+	//如果存在于有活动价的品牌,就是有折扣活动了
+	if php2go.InArray(canal, activity.CanalList) {
+		return true
+	}
+	return false
+}

service/service_ly.go

@@ -211,6 +211,7 @@ func (ls *LyService) GetActivity(sku model.LySku) model.LySku {
 		GoodsId:         sku.GoodsId,
 		GoodsId:         sku.GoodsId,
 		Canal:           sku.Canal,
 		Canal:           sku.Canal,
 		ClassId:         sku.ClassID2,
 		ClassId:         sku.ClassID2,
+		GoodsName:       sku.GoodsName,
 	}
 	}
 	var activityService ActivityService
 	var activityService ActivityService
 	priceActivity, giftActivity := activityService.GetActivityData(checkData)
 	priceActivity, giftActivity := activityService.GetActivityData(checkData)

service/service_price.go

 package service
 package service
 
 
 import (
 import (
+	"fmt"
 	"github.com/gomodule/redigo/redis"
 	"github.com/gomodule/redigo/redis"
 	"github.com/syyongx/php2go"
 	"github.com/syyongx/php2go"
 	"github.com/tidwall/gjson"
 	"github.com/tidwall/gjson"
@@ -93,6 +94,7 @@ func (ps *PriceService) GenerateLadderPrice(sku model.LySku) model.LySku {
 			if brandIds != "" {
 			if brandIds != "" {
 				hasSpecialCheck = true
 				hasSpecialCheck = true
 				standardBrandIdList := strings.Split(brandIds, ",")
 				standardBrandIdList := strings.Split(brandIds, ",")
+				fmt.Println(standardBrandIdList)
 				standardBrandId := strconv.Itoa(sku.StandardBrand.StandardBrandId)
 				standardBrandId := strconv.Itoa(sku.StandardBrand.StandardBrandId)
 				//找到有对应的品牌,那么优先级肯定是最高的了
 				//找到有对应的品牌,那么优先级肯定是最高的了
 				if php2go.InArray(standardBrandId, standardBrandIdList) {
 				if php2go.InArray(standardBrandId, standardBrandIdList) {

service/service_zy_common.go

@@ -38,7 +38,7 @@ func (qs *ZiyingService) skuLockNum(c *redis.Conn, goodsId string) int64 {
 }
 }
 
 
 /*
 /*
- 获取自营活动价
+获取自营活动价
 */
 */
 func (qs *ZiyingService) ActivityPrice(ctx *gin.Context, SkuInfo string) *orderedmap.OrderedMap {
 func (qs *ZiyingService) ActivityPrice(ctx *gin.Context, SkuInfo string) *orderedmap.OrderedMap {
 	data := qs.HDActivityPrice(SkuInfo)
 	data := qs.HDActivityPrice(SkuInfo)
@@ -48,7 +48,7 @@ func (qs *ZiyingService) ActivityPrice(ctx *gin.Context, SkuInfo string) *ordere
 	return nil
 	return nil
 }
 }
 
 
-//获取活动相关信息
+// 获取活动相关信息
 func (qs *ZiyingService) GetActivity(skuInfo string) (priceActivity model.PriceActivity, giftActivity model.GiftActivity) {
 func (qs *ZiyingService) GetActivity(skuInfo string) (priceActivity model.PriceActivity, giftActivity model.GiftActivity) {
 	//去判断是否有活动(促销打折活动和满赠活动)
 	//去判断是否有活动(促销打折活动和满赠活动)
 	var standardBrandId int
 	var standardBrandId int
@@ -72,6 +72,7 @@ func (qs *ZiyingService) GetActivity(skuInfo string) (priceActivity model.PriceA
 		StandardBrandId: standardBrandId,
 		StandardBrandId: standardBrandId,
 		GoodsId:         gjson.Get(skuInfo, "goods_id").String(),
 		GoodsId:         gjson.Get(skuInfo, "goods_id").String(),
 		ClassId:         int(gjson.Get(skuInfo, "class_id2").Int()),
 		ClassId:         int(gjson.Get(skuInfo, "class_id2").Int()),
+		GoodsName:       gjson.Get(skuInfo, "goods_name").String(),
 	}
 	}
 	var activityService ActivityService
 	var activityService ActivityService
 	priceActivity, giftActivity = activityService.GetActivityData(checkData)
 	priceActivity, giftActivity = activityService.GetActivityData(checkData)
@@ -79,13 +80,12 @@ func (qs *ZiyingService) GetActivity(skuInfo string) (priceActivity model.PriceA
 }
 }
 
 
 /*
 /*
- 计算活动价
+	计算活动价
 
 
 ac_type说明： 0 没有活动
 ac_type说明： 0 没有活动
 活动名称 	ac_type 类型
 活动名称 	ac_type 类型
 自营系数 	6 	    自营
 自营系数 	6 	    自营
 折扣(系数)活动 	10 	    自营/联营
 折扣(系数)活动 	10 	    自营/联营
-
 */
 */
 func (qs *ZiyingService) HDActivityPrice(SkuInfo string) *orderedmap.OrderedMap {
 func (qs *ZiyingService) HDActivityPrice(SkuInfo string) *orderedmap.OrderedMap {
 	priceActivity, giftActivity := qs.GetActivity(SkuInfo)
 	priceActivity, giftActivity := qs.GetActivity(SkuInfo)
@@ -132,7 +132,7 @@ func (qs *ZiyingService) HDActivityPrice(SkuInfo string) *orderedmap.OrderedMap
 }
 }
 
 
 /*
 /*
- 获取当前锁住的库存
+获取当前锁住的库存
 */
 */
 func (qs *ZiyingService) HDGoodsLimit(SkuID string, Stock string, c *redis.Conn) *orderedmap.OrderedMap {
 func (qs *ZiyingService) HDGoodsLimit(SkuID string, Stock string, c *redis.Conn) *orderedmap.OrderedMap {