fusen/fusenapi
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Hiven 2023-07-20 15:44:06 +08:00
commit 810f4fbee7
17 changed files with 394 additions and 201 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
constants/recommend_product.go Normal file
View File

@ -0,0 +1,6 @@
package constants
type recommend_product int64
// 产品详情页推荐产品
const PRODUCT_DETAIL_RECOMMEND_CATEGORY recommend_product = 1

62
goctl_template/api/handler.tpl
View File

@ -2,12 +2,7 @@ package {{.PkgName}}
import (
"net/http"
"errors"
"github.com/zeromicro/go-zero/core/logx"
"github.com/zeromicro/go-zero/rest/httpx"
"fusenapi/utils/auth"
"fusenapi/utils/basic"
{{.ImportPackages}}
@ -16,61 +11,16 @@ import (
func {{.HandlerName}}(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var (
// 定义错误变量
err error
// 定义用户信息变量
userinfo *auth.UserInfo
)
// 解析JWT token,并对空用户进行判断
claims, err := svcCtx.ParseJwtToken(r)
// 如果解析JWT token出错,则返回未授权的JSON响应并记录错误消息
if err != nil {
httpx.OkJsonCtx(r.Context(), w, &basic.Response{
Code: 401, // 返回401状态码,表示未授权
Message: "unauthorized", // 返回未授权信息
})
logx.Info("unauthorized:", err.Error()) // 记录错误日志
return
}
if claims != nil {
// 从token中获取对应的用户信息
userinfo, err = auth.GetUserInfoFormMapClaims(claims)
// 如果获取用户信息出错,则返回未授权的JSON响应并记录错误消息
if err != nil {
httpx.OkJsonCtx(r.Context(), w, &basic.Response{
Code: 401,
Message: "unauthorized",
})
logx.Info("unauthorized:", err.Error())
return
}
} else {
// 如果claims为nil,则认为用户身份为白板用户
userinfo = &auth.UserInfo{UserId: 0, GuestId: 0}
}
{{if .HasRequest}}var req types.{{.RequestType}}
// 如果端点有请求结构体，则使用httpx.Parse方法从HTTP请求体中解析请求数据
if err := httpx.Parse(r, &req); err != nil {
httpx.OkJsonCtx(r.Context(), w, &basic.Response{
Code: 510,
Message: "parameter error",
})
logx.Info(err)
userinfo, err := basic.RequestParse(w, r, svcCtx, &req)
if err != nil {
return
}
// 创建一个业务逻辑层实例
{{end}}l := {{.LogicName}}.New{{.LogicType}}(r.Context(), svcCtx)
{{if .HasResp}}resp{{end}} := l.{{.Call}}({{if .HasRequest}}&req, {{end}}userinfo)
// 如果响应不为nil，则使用httpx.OkJsonCtx方法返回JSON响应;
if resp != nil {
{{if .HasResp}}httpx.OkJsonCtx(r.Context(), w, resp){{else}}httpx.Ok(w){{end}}
} else {
err := errors.New("server logic is error, resp must not be nil")
httpx.ErrorCtx(r.Context(), w, err)
logx.Error(err)
}
basic.AfterLogic(w, r, resp)
}
}

61
goctl_template_backend/api/handler.tpl
View File

@ -2,12 +2,7 @@ package {{.PkgName}}
import (
"net/http"
"errors"
"github.com/zeromicro/go-zero/core/logx"
"github.com/zeromicro/go-zero/rest/httpx"
"fusenapi/utils/auth"
"fusenapi/utils/basic"
{{.ImportPackages}}
@ -15,60 +10,16 @@ import (
func {{.HandlerName}}(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var (
// 定义错误变量
err error
// 定义用户信息变量
userinfo *auth.BackendUserInfo
)
// 解析JWT token,并对空用户进行判断
claims, err := svcCtx.ParseJwtToken(r)
// 如果解析JWT token出错,则返回未授权的JSON响应并记录错误消息
if err != nil || claims == nil {
httpx.OkJsonCtx(r.Context(), w, &basic.Response{
Code: 401, // 返回401状态码,表示未授权
Message: "unauthorized", // 返回未授权信息
})
logx.Info("unauthorized:", err.Error()) // 记录错误日志
return
}
// 从token中获取对应的用户信息
userinfo, err = auth.GetBackendUserInfoFormMapClaims(claims)
// 如果获取用户信息出错,则返回未授权的JSON响应并记录错误消息
if err != nil {
httpx.OkJsonCtx(r.Context(), w, &basic.Response{
Code: 401,
Message: "unauthorized",
})
logx.Info("unauthorized:", err.Error())
return
}
{{if .HasRequest}}var req types.{{.RequestType}}
// 如果端点有请求结构体，则使用httpx.Parse方法从HTTP请求体中解析请求数据
if err := httpx.Parse(r, &req); err != nil {
httpx.OkJsonCtx(r.Context(), w, &basic.Response{
Code: 510,
Message: "parameter error",
})
logx.Info(err)
userinfo, err := basic.RequestParse(w, r, svcCtx, &req)
if err != nil {
return
}
// 创建一个业务逻辑层实例
{{end}}l := {{.LogicName}}.New{{.LogicType}}(r.Context(), svcCtx)
{{if .HasResp}}resp{{end}} := l.{{.Call}}({{if .HasRequest}}&req, {{end}}userinfo)
// 如果响应不为nil，则使用httpx.OkJsonCtx方法返回JSON响应;
if resp != nil {
{{if .HasResp}}httpx.OkJsonCtx(r.Context(), w, resp){{else}}httpx.Ok(w){{end}}
} else {
err := errors.New("server logic is error, resp must not be nil")
httpx.ErrorCtx(r.Context(), w, err)
logx.Error(err)
}
basic.AfterLogic(w, r, resp)
}
}

6
model/gmodel/fs_product_logic.go
View File

@ -72,7 +72,11 @@ func (p *FsProductModel) GetRandomProductList(ctx context.Context, limit int) (r
Where("`is_del` =? and `is_shelf` = ?", 0, 1).Order("RAND()").Limit(limit).Find(&resp).Error
return resp, err
}
func (p *FsProductModel) GetIgnoreRandomProductList(ctx context.Context, limit int, notInProductIds []int64) (resp []FsProduct, err error) {
err = p.db.WithContext(ctx).Model(&FsProduct{}).
Where("`is_del` =? and `is_shelf` = ? and `id` not in(?)", 0, 1, notInProductIds).Order("RAND()").Limit(limit).Find(&resp).Error
return resp, err
}
func (p *FsProductModel) FindAllOnlyByIds(ctx context.Context, ids []int64) (resp []FsProduct, err error) {
err = p.db.WithContext(ctx).Model(&FsProduct{}).Where("`id` IN (?)", ids).Find(&resp).Error
return resp, err

22
model/gmodel/fs_product_recommend_gen.go Normal file
View File

@ -0,0 +1,22 @@
package gmodel
import (
"gorm.io/gorm"
)
// fs_product_recommend 推荐商品表
type FsProductRecommend struct {
Id int64 `gorm:"primary_key;default:0;auto_increment;" json:"id"` //
ProductId *int64 `gorm:"unique_key;default:0;" json:"product_id"` // 产品ID
Status *int64 `gorm:"default:1;" json:"status"` // 状态 1正常 0不正常
Category *int64 `gorm:"default:1;" json:"category"` // 推荐类别1:详情推荐产品
Ctime *int64 `gorm:"default:0;" json:"ctime"` // 添加时间
}
type FsProductRecommendModel struct {
db *gorm.DB
name string
}
func NewFsProductRecommendModel(db *gorm.DB) *FsProductRecommendModel {
return &FsProductRecommendModel{db: db, name: "fs_product_recommend"}
}

50
model/gmodel/fs_product_recommend_logic.go Normal file
View File

@ -0,0 +1,50 @@
package gmodel
import (
"context"
"errors"
"gorm.io/gorm"
)
type GetRecommendProductListReq struct {
Ctx context.Context
Page int
Limit int
OrderBy string
Category int64
Status *int64
}
func (r *FsProductRecommendModel) GetRecommendProductList(req GetRecommendProductListReq) (resp []FsProductRecommend, total int64, err error) {
db := r.db.WithContext(req.Ctx).Model(&FsProductRecommend{})
if req.Status != nil {
db = db.Where("`status` = ?", *req.Status)
}
if req.Category != 0 {
db = db.Where("`category` = ?", req.Category)
}
if req.OrderBy != "" {
db = db.Order(req.OrderBy)
}
if err = db.Limit(1).Count(&total).Error; err != nil {
return nil, 0, err
}
offset := (req.Page - 1) * req.Limit
err = db.Offset(offset).Limit(req.Limit).Find(&resp).Error
return resp, total, err
}
func (r *FsProductRecommendModel) GetIgnoreRandomRecommendProductList(ctx context.Context, limit int, category int64, idNotInt []int64) (resp []FsProductRecommend, err error) {
err = r.db.WithContext(ctx).Model(&FsProductRecommend{}).Where("`product_id` not in(?) and `category` = ?", idNotInt, category).Order("RAND()").Limit(limit).Find(&resp).Error
return resp, err
}
func (r *FsProductRecommendModel) CreateOrUpdate(ctx context.Context, productId int64, category int64, data *FsProductRecommend) error {
var info FsProductRecommend
err := r.db.WithContext(ctx).Model(&FsProductRecommend{}).Where("`product_id` = ? and `category` = ?", productId, category).Take(&info).Error
if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
return err
}
if info.Id == 0 {
return r.db.WithContext(ctx).Model(&FsProductRecommend{}).Create(data).Error
}
return r.db.WithContext(ctx).Model(&FsProductRecommend{}).Where("`product_id` = ? and `category` = ?", productId, category).Updates(data).Error
}

67
server/home-user-auth/internal/handler/usergoogleloginhandler.go
View File

@ -1,13 +1,9 @@
package handler
import (
"errors"
"net/http"
"reflect"
"github.com/zeromicro/go-zero/core/logx"
"github.com/zeromicro/go-zero/rest/httpx"
"fusenapi/utils/auth"
"fusenapi/utils/basic"
"fusenapi/server/home-user-auth/internal/logic"
@ -18,67 +14,22 @@ import (
func UserGoogleLoginHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var (
// 定义错误变量
err error
// 定义用户信息变量
userinfo *auth.UserInfo
)
// 解析JWT token,并对空用户进行判断
claims, err := svcCtx.ParseJwtToken(r)
// 如果解析JWT token出错,则返回未授权的JSON响应并记录错误消息
if err != nil {
httpx.OkJsonCtx(r.Context(), w, &basic.Response{
Code: 401, // 返回401状态码,表示未授权
Message: "unauthorized", // 返回未授权信息
})
logx.Info("unauthorized:", err.Error()) // 记录错误日志
return
}
if claims != nil {
// 从token中获取对应的用户信息
userinfo, err = auth.GetUserInfoFormMapClaims(claims)
// 如果获取用户信息出错,则返回未授权的JSON响应并记录错误消息
if err != nil {
httpx.OkJsonCtx(r.Context(), w, &basic.Response{
Code: 401,
Message: "unauthorized",
})
logx.Info("unauthorized:", err.Error())
return
}
} else {
// 如果claims为nil,则认为用户身份为白板用户
userinfo = &auth.UserInfo{UserId: 0, GuestId: 0}
}
var req types.RequestGoogleLogin
// 如果端点有请求结构体，则使用httpx.Parse方法从HTTP请求体中解析请求数据
if err := httpx.Parse(r, &req); err != nil {
httpx.OkJsonCtx(r.Context(), w, &basic.Response{
Code: 510,
Message: "parameter error",
})
logx.Info(err)
userinfo, err := basic.RequestParse(w, r, svcCtx, &req)
if err != nil {
return
}
// 创建一个业务逻辑层实例
l := logic.NewUserGoogleLoginLogic(r.Context(), svcCtx)
rl := reflect.ValueOf(l)
basic.BeforeLogic(w, r, rl)
resp := l.UserGoogleLogin(&req, userinfo)
// 如果响应不为nil，则使用httpx.OkJsonCtx方法返回JSON响应;
if resp != nil {
if resp.IsRewriteHandler() {
resp.RewriteHandler(w, r)
} else {
httpx.OkJsonCtx(r.Context(), w, resp)
}
} else {
err := errors.New("server logic is error, resp must not be nil")
httpx.ErrorCtx(r.Context(), w, err)
logx.Error(err)
if !basic.AfterLogic(w, r, resp, rl) {
basic.NormalAfterLogic(w, r, resp)
}
}
}

78
server/home-user-auth/internal/handler/usergoogleloginhandler_old.go1 Normal file
View File

@ -0,0 +1,78 @@
package handler
import (
"errors"
"net/http"
"github.com/zeromicro/go-zero/core/logx"
"github.com/zeromicro/go-zero/rest/httpx"
"fusenapi/utils/auth"
"fusenapi/utils/basic"
"fusenapi/server/home-user-auth/internal/logic"
"fusenapi/server/home-user-auth/internal/svc"
"fusenapi/server/home-user-auth/internal/types"
)
func UserGoogleLoginHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var (
// 定义错误变量
err error
// 定义用户信息变量
userinfo *auth.UserInfo
)
// 解析JWT token,并对空用户进行判断
claims, err := svcCtx.ParseJwtToken(r)
// 如果解析JWT token出错,则返回未授权的JSON响应并记录错误消息
if err != nil {
httpx.OkJsonCtx(r.Context(), w, &basic.Response{
Code: 401, // 返回401状态码,表示未授权
Message: "unauthorized", // 返回未授权信息
})
logx.Info("unauthorized:", err.Error()) // 记录错误日志
return
}
if claims != nil {
// 从token中获取对应的用户信息
userinfo, err = auth.GetUserInfoFormMapClaims(claims)
// 如果获取用户信息出错,则返回未授权的JSON响应并记录错误消息
if err != nil {
httpx.OkJsonCtx(r.Context(), w, &basic.Response{
Code: 401,
Message: "unauthorized",
})
logx.Info("unauthorized:", err.Error())
return
}
} else {
// 如果claims为nil,则认为用户身份为白板用户
userinfo = &auth.UserInfo{UserId: 0, GuestId: 0}
}
var req types.RequestGoogleLogin
// 如果端点有请求结构体，则使用httpx.Parse方法从HTTP请求体中解析请求数据
if err := httpx.Parse(r, &req); err != nil {
httpx.OkJsonCtx(r.Context(), w, &basic.Response{
Code: 510,
Message: "parameter error",
})
logx.Info(err)
return
}
// 创建一个业务逻辑层实例
l := logic.NewUserGoogleLoginLogic(r.Context(), svcCtx)
resp := l.UserGoogleLogin(&req, userinfo)
// 如果响应不为nil，则使用httpx.OkJsonCtx方法返回JSON响应;
if resp != nil {
httpx.OkJsonCtx(r.Context(), w, resp)
} else {
err := errors.New("server logic is error, resp must not be nil")
httpx.ErrorCtx(r.Context(), w, err)
logx.Error(err)
}
}
}

6
server/home-user-auth/internal/logic/usergettypelogic.go
View File

@ -27,9 +27,9 @@ func NewUserGetTypeLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UserG
func (l *UserGetTypeLogic) UserGetType(req *types.Request, userinfo *auth.UserInfo) (resp *basic.Response) {
if userinfo.GetIdType() != auth.IDTYPE_User {
return resp.SetStatus(basic.CodeUnAuth)
}
// if userinfo.GetIdType() != auth.IDTYPE_User {
// return resp.SetStatus(basic.CodeUnAuth)
// }
// 返回值必须调用Set重新返回, resp可以空指针调用 resp.SetStatus(basic.CodeOK, data)
data, err := l.svcCtx.AllModels.FsCanteenType.FindAllGetType(l.ctx)

12
server/home-user-auth/internal/logic/usergoogleloginlogic.go
View File

@ -35,6 +35,16 @@ func NewUserGoogleLoginLogic(ctx context.Context, svcCtx *svc.ServiceContext) *U
}
}
func (l *UserGoogleLoginLogic) BeforeLogic(w http.ResponseWriter, r *http.Request) {
log.Println(r, w)
}
func (l *UserGoogleLoginLogic) AfterLogic(w http.ResponseWriter, r *http.Request, resp *basic.Response) {
log.Println(resp.Message)
http.Redirect(w, r, "http://localhost:9900/?token="+resp.Message, http.StatusMovedPermanently)
// log.Println(r, w)
}
func (l *UserGoogleLoginLogic) UserGoogleLogin(req *types.RequestGoogleLogin, userinfo *auth.UserInfo) (resp *basic.Response) {
// 返回值必须调用Set重新返回, resp可以空指针调用 resp.SetStatus(basic.CodeOK, data)
// userinfo 传入值时, 一定不为null
@ -77,11 +87,13 @@ func (l *UserGoogleLoginLogic) UserGoogleLogin(req *types.RequestGoogleLogin, us
log.Println(r.Json())
googleId := r.Json().Get("id").Int()
return resp.Set(304, "21321321")
user, err := l.svcCtx.AllModels.FsUser.FindUserByGoogleId(context.TODO(), googleId)
log.Println(user)
if err != nil {
if err != gorm.ErrRecordNotFound {
logx.Error(err)
return resp.SetStatus(basic.CodeDbSqlErr)
}

5
server/product/internal/handler/routes.go
View File

@ -107,11 +107,6 @@ func RegisterHandlers(server *rest.Server, serverCtx *svc.ServiceContext) {
Path: "/api/product/get_last_product_design",
Handler: GetLastProductDesignHandler(serverCtx),
},
{
Method: http.MethodPost,
Path: "/api/product/save_recommend_product",
Handler: SaveRecommendProductHandler(serverCtx),
},
},
)
}

96
server/product/internal/logic/getrecommandproductlistlogic.go
View File

@ -2,10 +2,14 @@ package logic
import (
"errors"
"fusenapi/constants"
"fusenapi/utils/auth"
"fusenapi/utils/basic"
"fusenapi/utils/format"
"fusenapi/utils/image"
"gorm.io/gorm"
"sort"
"strings"
"context"
@ -30,18 +34,83 @@ func NewGetRecommandProductListLogic(ctx context.Context, svcCtx *svc.ServiceCon
}
func (l *GetRecommandProductListLogic) GetRecommandProductList(req *types.GetRecommandProductListReq, userinfo *auth.UserInfo) (resp *basic.Response) {
req.Num = 8 //目前写死
req.Num = 4 //写死4个
if req.Size > 0 {
req.Size = image.GetCurrentSize(req.Size)
}
//随机取产品列表
productList, err := l.svcCtx.AllModels.FsProduct.GetRandomProductList(l.ctx, int(req.Num))
productInfo, err := l.svcCtx.AllModels.FsProduct.FindOneBySn(l.ctx, req.Sn)
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return resp.SetStatusWithMessage(basic.CodeDbRecordNotFoundErr, "detail`s product is not found")
}
logx.Error(err)
return resp.SetStatusWithMessage(basic.CodeDbSqlErr, "failed to get detail product info")
}
//随机取产品列表(不包含详情产品)
recommendList, err := l.svcCtx.AllModels.FsProductRecommend.GetIgnoreRandomRecommendProductList(l.ctx, int(req.Num), int64(constants.PRODUCT_DETAIL_RECOMMEND_CATEGORY), []int64{productInfo.Id})
if err != nil {
logx.Error(err)
return resp.SetStatusWithMessage(basic.CodeDbSqlErr, "failed to get random recommend product list")
return resp.SetStatusWithMessage(basic.CodeDbSqlErr, "failed to get random recommend list")
}
if len(productList) == 0 {
return resp.SetStatusWithMessage(basic.CodeOK, "success")
//需要填充时需要忽略的id
ignoreProductIds := make([]int64, 0, len(recommendList)+1)
ignoreProductIds = append(ignoreProductIds, productInfo.Id)
productIds := make([]int64, 0, len(recommendList))
for _, v := range recommendList {
ignoreProductIds = append(ignoreProductIds, *v.ProductId)
productIds = append(productIds, *v.ProductId)
}
//获取推荐产品列表
recommendProductList, err := l.svcCtx.AllModels.FsProduct.GetProductListByIds(l.ctx, productIds, "")
if err != nil {
logx.Error(err)
return resp.SetStatus(basic.CodeDbSqlErr, "failed to get recommend product list")
}
//在合并之前记住推荐的产品
mapRecommend := make(map[int64]struct{})
for _, v := range recommendProductList {
mapRecommend[v.Id] = struct{}{}
}
//小于请求的数量则需要从产品表中随机填补上
lenRecommendProduct := len(recommendProductList)
if lenRecommendProduct < int(req.Num) {
appendNum := int(req.Num) - lenRecommendProduct
productList, err := l.svcCtx.AllModels.FsProduct.GetIgnoreRandomProductList(l.ctx, appendNum, ignoreProductIds)
if err != nil {
logx.Error(err)
return resp.SetStatusWithMessage(basic.CodeDbSqlErr, "failed to get product list")
}
//合并列表
for _, v := range productList {
productIds = append(productIds, v.Id)
recommendProductList = append(recommendProductList, v)
}
}
//查询产品价格
priceList, err := l.svcCtx.AllModels.FsProductPrice.GetPriceListByProductIds(l.ctx, productIds)
if err != nil {
logx.Error(err)
return resp.SetStatusWithMessage(basic.CodeDbSqlErr, "failed to get product price list")
}
mapProductMinPrice := make(map[int64]int64)
for _, v := range priceList {
if v.StepPrice == nil || *v.StepPrice == "" {
continue
}
stepPriceSlice, err := format.StrSlicToIntSlice(strings.Split(*v.StepPrice, ","))
if err != nil {
logx.Error(err)
return resp.SetStatusWithMessage(basic.CodeServiceErr, "failed to parse step price")
}
//正序排序
sort.Ints(stepPriceSlice)
if min, ok := mapProductMinPrice[*v.ProductId]; ok {
if min > int64(stepPriceSlice[0]) {
mapProductMinPrice[*v.ProductId] = int64(stepPriceSlice[0])
}
} else {
mapProductMinPrice[*v.ProductId] = int64(stepPriceSlice[0])
}
}
//获取用户信息(不用判断存在)
user, err := l.svcCtx.AllModels.FsUser.FindUserById(l.ctx, userinfo.UserId)
@ -49,8 +118,8 @@ func (l *GetRecommandProductListLogic) GetRecommandProductList(req *types.GetRec
logx.Error(err)
return resp.SetStatusWithMessage(basic.CodeDbSqlErr, "failed to get user")
}
list := make([]types.GetRecommandProductListRsp, 0, len(productList))
for _, v := range productList {
list := make([]types.GetRecommandProductListRsp, 0, len(recommendProductList))
for _, v := range recommendProductList {
r := image.ThousandFaceImageFormatReq{
Size: int(req.Size),
IsThousandFace: 0,
@ -63,7 +132,16 @@ func (l *GetRecommandProductListLogic) GetRecommandProductList(req *types.GetRec
if user.Id != 0 {
r.IsThousandFace = int(*user.IsThousandFace)
}
//千人前面处理
image.ThousandFaceImageFormat(&r)
isRecommend := int64(0)
if _, ok := mapRecommend[v.Id]; ok {
isRecommend = 1
}
minPrice := int64(0)
if minVal, ok := mapProductMinPrice[v.Id]; ok {
minPrice = minVal
}
list = append(list, types.GetRecommandProductListRsp{
Id: v.Id,
Sn: *v.Sn,
@ -73,6 +151,8 @@ func (l *GetRecommandProductListLogic) GetRecommandProductList(req *types.GetRec
CoverImg: r.CoverImg,
CoverDefault: r.CoverDefault,
Intro: *v.Intro,
IsRecommend: isRecommend,
MinPrice: minPrice,
})
}
return resp.SetStatusWithMessage(basic.CodeOK, "success", list)

8
server/product/internal/logic/gettagproductlistlogic.go
View File

@ -143,7 +143,13 @@ func (l *GetTagProductListLogic) GetTagProductList(req *types.GetTagProductListR
continue
}
sort.Ints(priceSlice)
mapProductMinPrice[v.ProductId] = int64(priceSlice[0])
if min, ok := mapProductMinPrice[v.ProductId]; ok {
if min > int64(priceSlice[0]) {
mapProductMinPrice[v.ProductId] = int64(priceSlice[0])
}
} else {
mapProductMinPrice[v.ProductId] = int64(priceSlice[0])
}
}
//获取模板(只是获取产品product_id)
productTemplatesV2, err = l.svcCtx.AllModels.FsProductTemplateV2.FindAllByProductIds(l.ctx, productIds, "product_id")

12
server/product/internal/types/types.go
View File

@ -242,6 +242,8 @@ type GetRecommandProductListRsp struct {
CoverImg string `json:"cover_img"`
CoverDefault string `json:"cover_default"`
Intro string `json:"intro"`
IsRecommend int64 `json:"is_recommend"`
MinPrice int64 `json:"min_price"`
}
type GetTagProductListReq struct {
@ -376,16 +378,6 @@ type GetLastProductDesignRsp struct {
Info interface{} `json:"info"`
}
type SaveRecommendProductReq struct {
ProductList []RecommendProductItem `json:"product_list"`
}
type RecommendProductItem struct {
ProductId int64 `json:"product_id"`
Sort int64 `json:"sort"`
Status int64 `json:"status,options=0|1"`
}
type Request struct {
}

6
server_api/product.api
View File

@ -70,7 +70,7 @@ service product {
get /api/product/get_last_product_design(request) returns (response);
//*********************产品详情分解接口结束***********************
//*********************推荐产品接口开始××××××××××××××××××××××××××
//*********************推荐产品接口结束××××××××××××××××××××××××××
}
@ -291,6 +291,8 @@ type GetRecommandProductListRsp {
CoverImg string `json:"cover_img"`
CoverDefault string `json:"cover_default"`
Intro string `json:"intro"`
IsRecommend int64 `json:"is_recommend"`
MinPrice int64 `json:"min_price"`
}
//获取分类产品列表
type GetTagProductListReq {
@ -415,4 +417,4 @@ type GetLastProductDesignRsp {
SizeId int64 `json:"size_id"`
LogoColor interface{} `json:"logo_color"`
Info interface{} `json:"info"`
}
}

4
utils/basic/basic.go
View File

@ -242,11 +242,11 @@ func (resp *Response) SetRewriteHandler(do http.HandlerFunc) *Response {
}
// RewriteHandler
func (resp *Response) RewriteHandler(w http.ResponseWriter, r *http.Request) {
func (resp *Response) rewriteHandler(w http.ResponseWriter, r *http.Request) {
resp.rewriteHandlerFunc(w, r)
}
// Set 设置Response的Code和Message值
func (resp *Response) IsRewriteHandler() bool {
func (resp *Response) isRewriteHandler() bool {
return resp.rewriteHandlerFunc != nil
}

94
utils/basic/request_parse.go Normal file
View File

@ -0,0 +1,94 @@
package basic
import (
"errors"
"fusenapi/utils/auth"
"net/http"
"reflect"
"github.com/golang-jwt/jwt"
"github.com/zeromicro/go-zero/core/logx"
"github.com/zeromicro/go-zero/rest/httpx"
)
type IJWTParse interface {
ParseJwtToken(r *http.Request) (jwt.MapClaims, error)
}
func BeforeLogic(w http.ResponseWriter, r *http.Request, l reflect.Value) (isNext bool) {
m := l.MethodByName("BeforeLogic")
if m.IsValid() {
result := m.Call([]reflect.Value{reflect.ValueOf(w), reflect.ValueOf(r)})
if len(result) != 0 {
return false
}
}
return true
}
func AfterLogic(w http.ResponseWriter, r *http.Request, resp *Response, l reflect.Value) bool {
m := l.MethodByName("AfterLogic")
if m.IsValid() {
m.Call([]reflect.Value{reflect.ValueOf(w), reflect.ValueOf(r), reflect.ValueOf(resp)})
return true
}
return false
}
func NormalAfterLogic(w http.ResponseWriter, r *http.Request, resp *Response) {
// 如果响应不为nil，则使用httpx.OkJsonCtx方法返回JSON响应;
if resp != nil {
httpx.OkJsonCtx(r.Context(), w, resp)
} else {
err := errors.New("server logic is error, resp must not be nil")
httpx.ErrorCtx(r.Context(), w, err)
logx.Error(err)
}
}
func RequestParse(w http.ResponseWriter, r *http.Request, svcCtx IJWTParse, LogicRequest any) (userinfo *auth.UserInfo, err error) {
// 解析JWT token,并对空用户进行判断
claims, err := svcCtx.ParseJwtToken(r)
// 如果解析JWT token出错,则返回未授权的JSON响应并记录错误消息
if err != nil {
httpx.OkJsonCtx(r.Context(), w, &Response{
Code: 401, // 返回401状态码,表示未授权
Message: "unauthorized", // 返回未授权信息
})
logx.Info("unauthorized:", err.Error()) // 记录错误日志
return
}
if claims != nil {
// 从token中获取对应的用户信息
userinfo, err = auth.GetUserInfoFormMapClaims(claims)
// 如果获取用户信息出错,则返回未授权的JSON响应并记录错误消息
if err != nil {
httpx.OkJsonCtx(r.Context(), w, &Response{
Code: 401,
Message: "unauthorized",
})
logx.Info("unauthorized:", err.Error())
return
}
} else {
// 如果claims为nil,则认为用户身份为白板用户
userinfo = &auth.UserInfo{UserId: 0, GuestId: 0}
}
// var req types.RequestGoogleLogin
// 如果端点有请求结构体，则使用httpx.Parse方法从HTTP请求体中解析请求数据
if err = httpx.Parse(r, LogicRequest); err != nil {
httpx.OkJsonCtx(r.Context(), w, &Response{
Code: 510,
Message: "parameter error",
})
logx.Info(err)
return
}
return userinfo, err
}