Merge branch 'develop' of https://gitee.com/fusenpack/fusenapi into develop

server/product/internal/logic/getproductlistlogic.go

@@ -45,7 +45,7 @@ func (l *GetProductListLogic) GetProductList(req *types.GetProductListReq, useri
 		}
 		return resp.SetStatusWithMessage(basic.CodeOK, "success", demo)
 	}
-	if req.Page <= 0 && req.Page > 10000 {
+	if req.Page <= 0{
 		req.Page = constants.DEFAULT_PAGE
 	}
 	//获取合适尺寸

server/product/internal/logic/gettagproductlistlogic.go

@@ -2,7 +2,6 @@ package logic
 
 import (
 	"errors"
-	"fmt"
 	"fusenapi/model/gmodel"
 	"fusenapi/utils/auth"
 	"fusenapi/utils/basic"
@@ -60,6 +59,8 @@ func (l *GetTagProductListLogic) GetTagProductList(req *types.GetTagProductListR
 			if errors.Is(err, gorm.ErrRecordNotFound) {
 				return resp.SetStatusWithMessage(basic.CodeDbRecordNotFoundErr, "param cid is invalid:record not found")
 			}
+			logx.Error(err)
+			return resp.SetStatusWithMessage(basic.CodeDbSqlErr,"failed to get tag info")
 		}
 		tReq.LevelPrefixLeftLike = *tagData.LevelPrefix
 	}
@@ -77,8 +78,6 @@ func (l *GetTagProductListLogic) GetTagProductList(req *types.GetTagProductListR
 	}
 	var (
 		productList          []gmodel.FsProduct                   //产品列表（select 字段需要看查询的地方）
-		recommendProductList []gmodel.FsProduct                   //tag推荐产品列表（select 字段需要看查询的地方）
-		mapProduct           = make(map[int64]int)                //产品map
 		productPriceList     []gmodel.GetPriceListByProductIdsRsp //产品价格列表（select 字段需要看查询的地方）
 		mapProductMinPrice   = make(map[int64]int64)              //产品最小价格map
 		productTemplatesV2   []gmodel.FsProductTemplateV2         //产品模板列表（select 字段需要看查询的地方）
@@ -86,64 +85,28 @@ func (l *GetTagProductListLogic) GetTagProductList(req *types.GetTagProductListR
 		mapProductSizeCount  = make(map[int64]int64)              //产品尺寸数量map
 		mapProductTemplate   = make(map[int64]struct{})           //产品模板map
 	)
-	//携带推荐产品
-	if req.WithRecommendProduct{
-		//提取tag推荐产品
-		allTagRecommendProductIds := make([]int64, 0, len(tagList)*5)
-		for _, v := range tagList {
-			if v.RecommendProduct == nil || *v.RecommendProduct == "" {
-				continue
-			}
-			sl, err := format.StrSlicToInt64Slice(strings.Split(*v.RecommendProductSort, ","))
-			if err != nil {
-				logx.Error(err)
-				return resp.SetStatusWithMessage(basic.CodeServiceErr, fmt.Sprintf("failed to parse recommend product ids,id=%d", v.Id))
-			}
-			allTagRecommendProductIds = append(allTagRecommendProductIds, sl...)
-		}
-		//获取推荐的产品列表
-		recommendProductList, err = l.svcCtx.AllModels.FsProduct.FindAllOnlyByIds(l.ctx, allTagRecommendProductIds)
-		if err != nil {
-			logx.Error(err)
-			return resp.SetStatusWithMessage(basic.CodeDbSqlErr, "failed to get tag recommend products")
-		}
-	}
 	//携带产品
 	if req.WithProduct {
 		//查询符合的产品列表
 		pIsDel := int64(0)
 		pStatus := int64(1)
 		pIsShelf := int64(1)
-		pReq := gmodel.GetProductListByParamsReq{
-			Type:    typeIds,
-			IsDel:   &pIsDel,
-			IsShelf: &pIsShelf,
-			Status:  &pStatus,
-			OrderBy: "`sort` DESC",
-		}
 		//获取产品列表
-		productList, err = l.svcCtx.AllModels.FsProduct.GetProductListByParams(l.ctx, pReq)
+		productList, err = l.svcCtx.AllModels.FsProduct.GetProductListByParams(l.ctx,
+			gmodel.GetProductListByParamsReq{
+				Type:    typeIds,
+				IsDel:   &pIsDel,
+				IsShelf: &pIsShelf,
+				Status:  &pStatus,
+				OrderBy: "`sort` DESC",
+			})
 		if err != nil {
 			logx.Error(err)
 			return resp.SetStatusWithMessage(basic.CodeServiceErr, "failed to get product list")
 		}
-	}
+		productIds := make([]int64,0,len(productList))
-	//任意一个不为空
+		for _,product := range productList{
-	if len(productList) != 0 || len(recommendProductList) != 0{
+			productIds = append(productIds,product.Id)
-		//提取产品ids
-		productIds := make([]int64, 0, len(productList))
-		for k, v := range productList {
-			productIds = append(productIds, v.Id)
-			mapProduct[v.Id] = k
-		}
-		//合并产品列表
-		for _, v := range recommendProductList {
-			//存在则不并入
-			if _, ok := mapProduct[v.Id]; ok {
-				continue
-			}
-			productList = append(productList, v)
-			mapProduct[v.Id] = len(productList) - 1
 		}
 		//获取产品价格列表
 		productPriceList, err = l.svcCtx.AllModels.FsProductPrice.GetSimplePriceListByProductIds(l.ctx, productIds)
@@ -186,10 +149,50 @@ func (l *GetTagProductListLogic) GetTagProductList(req *types.GetTagProductListR
 	}
 	//map tag菜单
 	mapTagLevel := make(map[string]*types.TagItem)
-	for _, tagInfo := range tagList {
+	//处理tags数据
+	if err = l.dealWithTagMenuData(dealWithTagMenuDataReq{
+		TagList:              tagList,
+		WithProduct:          req.WithProduct,
+		ProductList:          productList,
+		MapProductMinPrice:   mapProductMinPrice,
+		MapProductTemplate:   mapProductTemplate,
+		MapProductSizeCount:  mapProductSizeCount,
+		MapTagLevel:          mapTagLevel,
+		Size:                 req.Size,
+		user:                 user,
+	}); err != nil {
+		logx.Error(err)
+		return resp.SetStatusAddMessage(basic.CodeServiceErr, "failed to deal with tag data")
+	}
+	return resp.SetStatusWithMessage(basic.CodeOK, "success", types.GetTagProductListRsp{
+		TotalCategoryProduct: len(productList),
+		TagList:       l.organizationLevelRelation(mapTagLevel), //组装等级从属关系
+	})
+}
+
+// 排序推荐产品结构体
+type sortRecommendProduct struct {
+	ProductId int64
+	Sort      int64
+}
+
+// 处理tag菜单数据
+type dealWithTagMenuDataReq struct {
+	TagList              []gmodel.FsTags
+	WithProduct          bool
+	ProductList          []gmodel.FsProduct
+	MapProductMinPrice   map[int64]int64
+	MapProductTemplate   map[int64]struct{}
+	MapProductSizeCount  map[int64]int64
+	MapTagLevel          map[string]*types.TagItem
+	Size                 uint32
+	user                 gmodel.FsUser
+}
+
+func (l *GetTagProductListLogic) dealWithTagMenuData(req dealWithTagMenuDataReq) error {
+	for _, tagInfo := range req.TagList {
 		tagTem := types.TagItem{
 			TagProductList:          nil,
-			TagRecommendProductList: nil,
 			TypeName:                *tagInfo.Title,
 			TypeId:                  tagInfo.Id,
 			Level:                   *tagInfo.Level,
@@ -197,66 +200,31 @@ func (l *GetTagProductListLogic) GetTagProductList(req *types.GetTagProductListR
 			Icon:                    *tagInfo.Icon,
 			Sort:                    *tagInfo.Sort,
 			Description:             *tagInfo.Description,
-			ChildTagList:            make([]*types.TagItem, 0, 100),
+			ChildTagList:            make([]*types.TagItem, 0, 50),
 		}
 		//携带产品
-		if req.WithProduct  {
+		if req.WithProduct {
 			//获取分类产品列表
 			productListRsp := l.getTagProducts(getTagProductsReq{
 				TagId:               tagInfo.Id,
-				ProductList:         productList,
+				ProductList:         req.ProductList,
-				MapProductMinPrice:  mapProductMinPrice,
+				MapProductMinPrice:  req.MapProductMinPrice,
-				MapProductTemplate:  mapProductTemplate,
+				MapProductTemplate:  req.MapProductTemplate,
-				MapProductSizeCount: mapProductSizeCount,
+				MapProductSizeCount: req.MapProductSizeCount,
 				Size:                req.Size,
-				User:                user,
+				User:                req.user,
 			})
 			//赋值
 			tagTem.TagProductList = productListRsp
 		}
-		//获取推荐产品列表
-		if req.WithRecommendProduct && tagInfo.RecommendProduct != nil && *tagInfo.RecommendProduct != "" {
-			//上面解析过，这里就无需判断错误
-			recommendProductIds, _ := format.StrSlicToInt64Slice(strings.Split(*tagInfo.RecommendProduct, ","))
-			//推荐产品的排序
-			recommendProductIdsSort, err := format.StrSlicToInt64Slice(strings.Split(*tagInfo.RecommendProductSort, ","))
-			if err != nil{
-				logx.Error(err)
-				return nil
-			}
-			if len(recommendProductIds) != len(recommendProductIdsSort){
-				return resp.SetStatusWithMessage(basic.CodeServiceErr,fmt.Sprintf("length of recommend product id is neq length of recommend sort,id= %d",tagInfo.Id))
-			}
-			recommendProductListRsp := l.getTagRecommendProducts(getTagRecommendProductsReq{
-				TagInfo:                 tagInfo,
-				ProductList:             productList,
-				MapProduct:              mapProduct,
-				MapProductMinPrice:      mapProductMinPrice,
-				MapProductTemplate:      mapProductTemplate,
-				MapProductSizeCount:     mapProductSizeCount,
-				RecommendProductIds:     recommendProductIds,
-				RecommendProductIdsSort: recommendProductIdsSort,
-				Size:                    req.Size,
-				User:                    user,
-			})
-			//赋值
-			tagTem.TagRecommendProductList = recommendProductListRsp
-		}
 		//加入分类
-		mapTagLevel[*tagInfo.LevelPrefix] = &tagTem
+		req.MapTagLevel[*tagInfo.LevelPrefix] = &tagTem
 	}
-	return resp.SetStatusWithMessage(basic.CodeOK, "success", types.GetTagProductListRsp{
+	return nil
-		TotalCategory: len(mapTagLevel),
-		TagList:       l.organizationLevelRelation(mapTagLevel),//组装等级从属关系
-	})
 }
-//排序推荐产品结构体
+
-type sortRecommendProduct struct {
+// 组织等级从属关系
-	ProductId int64
+func (l *GetTagProductListLogic) organizationLevelRelation(mapTagLevel map[string]*types.TagItem) []types.TagItem {
-	Sort int64
-}
-//组织等级从属关系
-func (l *GetTagProductListLogic)organizationLevelRelation(mapTagLevel map[string]*types.TagItem)[]types.TagItem{
 	mapTop := make(map[string]struct{})
 	for prefix, tagItem := range mapTagLevel {
 		//最上级没有父级
@@ -267,19 +235,21 @@ func (l *GetTagProductListLogic)organizationLevelRelation(mapTagLevel map[string
 		prefixSlice := strings.Split(prefix, "/")
 		//有父级
 		parentPrefix := strings.Join(prefixSlice[:len(prefixSlice)-1], "/")
-		if parent, ok := mapTagLevel[parentPrefix]; ok {
+		parent, ok := mapTagLevel[parentPrefix]
-			parent.ChildTagList = append(parent.ChildTagList, tagItem)
+		if !ok {
-			//排序
+			continue
-			sort.SliceStable(parent.ChildTagList, func(i, j int) bool {
-				return parent.ChildTagList[i].Sort < parent.ChildTagList[j].Sort
-			})
-			mapTagLevel[parentPrefix] = parent
 		}
+		parent.ChildTagList = append(parent.ChildTagList, tagItem)
+		//排序
+		sort.SliceStable(parent.ChildTagList, func(i, j int) bool {
+			return parent.ChildTagList[i].Sort < parent.ChildTagList[j].Sort
+		})
+		mapTagLevel[parentPrefix] = parent
 	}
 	//最终值提取最高级别那一层出来
 	rspList := make([]types.TagItem, 0, len(mapTagLevel))
 	for prefix, _ := range mapTop {
-		rspList = append(rspList,*mapTagLevel[prefix])
+		rspList = append(rspList, *mapTagLevel[prefix])
 	}
 	//排序
 	sort.SliceStable(rspList, func(i, j int) bool {
@@ -287,81 +257,6 @@ func (l *GetTagProductListLogic)organizationLevelRelation(mapTagLevel map[string
 	})
 	return rspList
 }
-//获取tag推荐产品列表
-type getTagRecommendProductsReq struct {
-	TagInfo               gmodel.FsTags
-	ProductList         []gmodel.FsProduct
-	MapProduct  map[int64]int
-	MapProductMinPrice  map[int64]int64
-	MapProductTemplate  map[int64]struct{}
-	MapProductSizeCount map[int64]int64
-	RecommendProductIds []int64
-	RecommendProductIdsSort []int64
-	Size uint32
-	User                gmodel.FsUser
-}
-
-func (l *GetTagProductListLogic)getTagRecommendProducts(req getTagRecommendProductsReq)(productListRsp []types.TagProduct){
-	//排序
-	sortList := make([]sortRecommendProduct,0,len(req.RecommendProductIds))
-	for sortIndex,pid := range req.RecommendProductIds{
-		sortList = append(sortList,sortRecommendProduct{
-			ProductId: pid,
-			Sort: req.RecommendProductIdsSort[sortIndex],
-		})
-	}
-	sort.SliceStable(sortList, func(i, j int) bool {
-		return sortList[i].Sort < sortList[j].Sort
-	})
-	productListRsp = make([]types.TagProduct,0,len(sortList))
-	for _,sortVal := range sortList{
-		productIndex,ok := req.MapProduct[sortVal.ProductId]
-		if !ok{
-			continue
-		}
-		productInfo := req.ProductList[productIndex]
-		minPrice, ok := req.MapProductMinPrice[productInfo.Id]
-		_, tmpOk := req.MapProductTemplate[productInfo.Id]
-		//无最小价格则不显示 || 没有模板也不显示
-		if !ok || !tmpOk {
-			continue
-		}
-		sizeNum := int64(0)
-		if mapSizeNum, ok := req.MapProductSizeCount[productInfo.Id]; ok {
-			sizeNum = mapSizeNum
-		}
-		item := types.TagProduct{
-			ProductId: productInfo.Id,
-			Sn:        *productInfo.Sn,
-			Title:     *productInfo.Title,
-			Intro:     *productInfo.Intro,
-			IsEnv:     *productInfo.IsProtection,
-			IsMicro:   *productInfo.IsMicrowave,
-			SizeNum:   uint32(sizeNum),
-			MiniPrice: minPrice,
-		}
-		//千人千面处理
-		r := image.ThousandFaceImageFormatReq{
-			Size:           int(req.Size),
-			IsThousandFace: 0,
-			Cover:          *productInfo.Cover,
-			CoverImg:       *productInfo.CoverImg,
-			CoverDefault:   *productInfo.CoverImg,
-			ProductId:      productInfo.Id,
-			UserId:         req.User.Id,
-		}
-		if req.User.Id != 0 {
-			r.IsThousandFace = int(*req.User.IsThousandFace)
-		}
-		image.ThousandFaceImageFormat(&r)
-		item.Cover = r.Cover
-		item.CoverImg = r.CoverImg
-		item.CoverDefault = r.CoverDefault
-		//加入切片
-		productListRsp = append(productListRsp,item)
-	}
-	return productListRsp
-}
 // 获取对应tag的产品列表
 type getTagProductsReq struct {
 	TagId               int64

server/product/internal/types/types.go

@@ -245,28 +245,26 @@ type GetRecommandProductListRsp struct {
 }
 
 type GetTagProductListReq struct {
-	Cid                  int64  `form:"cid,optional"`           //分类id
+	Cid         int64  `form:"cid,optional"`          //分类id
-	Size                 uint32 `form:"size,optional"`          //尺寸
+	Size        uint32 `form:"size,optional"`         //尺寸
-	WithProduct          bool   `form:"with_product,optional"`  //是否携带分类下的产品
+	WithProduct bool   `form:"with_product,optional"` //是否携带分类下的产品
-	WithRecommendProduct bool   `form:"with_recommend_product"` //是否携带分类推荐产品
 }
 
 type GetTagProductListRsp struct {
-	TotalCategory int       `json:"total_category"`
+	TotalCategoryProduct int       `json:"total_category_product"`
-	TagList       []TagItem `json:"tag_list"`
+	TagList              []TagItem `json:"tag_list"`
 }
 
 type TagItem struct {
-	TypeName                string       `json:"type_name"`
+	TypeName       string       `json:"type_name"`
-	TypeId                  int64        `json:"type_id"`
+	TypeId         int64        `json:"type_id"`
-	Description             string       `json:"description"`
+	Description    string       `json:"description"`
-	Level                   int64        `json:"level"`
+	Level          int64        `json:"level"`
-	LevelPrefix             string       `json:"level_prefix"`
+	LevelPrefix    string       `json:"level_prefix"`
-	Icon                    string       `json:"icon"`
+	Icon           string       `json:"icon"`
-	Sort                    int64        `json:"sort"`
+	Sort           int64        `json:"sort"`
-	TagProductList          []TagProduct `json:"tag_product_list"`           //分类下的产品
+	TagProductList []TagProduct `json:"tag_product_list"` //分类下的产品
-	TagRecommendProductList []TagProduct `json:"tag_recommend_product_list"` //分类推荐产品
+	ChildTagList   []*TagItem   `json:"child_tag_list"`
-	ChildTagList            []*TagItem   `json:"child_tag_list"`
 }
 
 type TagProduct struct {

server_api/product.api

@@ -291,26 +291,24 @@ type GetRecommandProductListRsp {
 }
 //获取分类产品列表
 type GetTagProductListReq {
-	Cid                  int64  `form:"cid,optional"`           //分类id
+	Cid         int64  `form:"cid,optional"`          //分类id
-	Size                 uint32 `form:"size,optional"`          //尺寸
+	Size        uint32 `form:"size,optional"`         //尺寸
-	WithProduct          bool   `form:"with_product,optional"`  //是否携带分类下的产品
+	WithProduct bool   `form:"with_product,optional"` //是否携带分类下的产品
-	WithRecommendProduct bool   `form:"with_recommend_product"` //是否携带分类推荐产品
 }
 type GetTagProductListRsp {
-	TotalCategory int       `json:"total_category"`
+	TotalCategoryProduct int       `json:"total_category_product"`
-	TagList       []TagItem `json:"tag_list"`
+	TagList              []TagItem `json:"tag_list"`
 }
 type TagItem {
-	TypeName                string       `json:"type_name"`
+	TypeName       string       `json:"type_name"`
-	TypeId                  int64        `json:"type_id"`
+	TypeId         int64        `json:"type_id"`
-	Description             string       `json:"description"`
+	Description    string       `json:"description"`
-	Level                   int64        `json:"level"`
+	Level          int64        `json:"level"`
-	LevelPrefix             string       `json:"level_prefix"`
+	LevelPrefix    string       `json:"level_prefix"`
-	Icon                    string       `json:"icon"`
+	Icon           string       `json:"icon"`
-	Sort                    int64        `json:"sort"`
+	Sort           int64        `json:"sort"`
-	TagProductList          []TagProduct `json:"tag_product_list"`           //分类下的产品
+	TagProductList []TagProduct `json:"tag_product_list"` //分类下的产品
-	TagRecommendProductList []TagProduct `json:"tag_recommend_product_list"` //分类推荐产品
+	ChildTagList   []*TagItem   `json:"child_tag_list"`
-	ChildTagList            []*TagItem   `json:"child_tag_list"`
 }
 type TagProduct {
 	ProductId    int64  `json:"product_id"`