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

server/canteen/internal/handler/getcanteendetailhandler.go

@@ -17,28 +17,40 @@ import (
 
 func GetCanteenDetailHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		// 解析jwtToken
+
+		var (
+			// 定义错误变量
+			err error
+			// 定义用户信息变量
+			userinfo *auth.UserInfo
+		)
+		// 解析JWT token,并对空用户进行判断
 		claims, err := svcCtx.ParseJwtToken(r)
-		// 如果解析出错，则返回未授权的JSON响应并记录错误消息
+		// 如果解析JWT token出错,则返回未授权的JSON响应并记录错误消息
 		if err != nil {
 			httpx.OkJsonCtx(r.Context(), w, &basic.Response{
-				Code:    401,
-				Message: "unauthorized",
+				Code:    401,            // 返回401状态码,表示未授权
+				Message: "unauthorized", // 返回未授权信息
 			})
-			logx.Info("unauthorized:", err.Error())
+			logx.Info("unauthorized:", err.Error()) // 记录错误日志
 			return
 		}
 
-		// 从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
+		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.GetCanteenDetailReq
@@ -55,7 +67,6 @@ func GetCanteenDetailHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 		l := logic.NewGetCanteenDetailLogic(r.Context(), svcCtx)
 		resp := l.GetCanteenDetail(&req, userinfo)
 		// 如果响应不为nil，则使用httpx.OkJsonCtx方法返回JSON响应;
-		// 否则，发送500内部服务器错误的JSON响应并记录错误消息logx.Error。
 		if resp != nil {
 			httpx.OkJsonCtx(r.Context(), w, resp)
 		} else {

server/canteen/internal/handler/savecanteentypeproducthandler.go

@@ -17,28 +17,40 @@ import (
 
 func SaveCanteenTypeProductHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		// 解析jwtToken
+
+		var (
+			// 定义错误变量
+			err error
+			// 定义用户信息变量
+			userinfo *auth.UserInfo
+		)
+		// 解析JWT token,并对空用户进行判断
 		claims, err := svcCtx.ParseJwtToken(r)
-		// 如果解析出错，则返回未授权的JSON响应并记录错误消息
+		// 如果解析JWT token出错,则返回未授权的JSON响应并记录错误消息
 		if err != nil {
 			httpx.OkJsonCtx(r.Context(), w, &basic.Response{
-				Code:    401,
-				Message: "unauthorized",
+				Code:    401,            // 返回401状态码,表示未授权
+				Message: "unauthorized", // 返回未授权信息
 			})
-			logx.Info("unauthorized:", err.Error())
+			logx.Info("unauthorized:", err.Error()) // 记录错误日志
 			return
 		}
 
-		// 从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
+		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.SaveCanteenTypeProductReq
@@ -55,7 +67,6 @@ func SaveCanteenTypeProductHandler(svcCtx *svc.ServiceContext) http.HandlerFunc
 		l := logic.NewSaveCanteenTypeProductLogic(r.Context(), svcCtx)
 		resp := l.SaveCanteenTypeProduct(&req, userinfo)
 		// 如果响应不为nil，则使用httpx.OkJsonCtx方法返回JSON响应;
-		// 否则，发送500内部服务器错误的JSON响应并记录错误消息logx.Error。
 		if resp != nil {
 			httpx.OkJsonCtx(r.Context(), w, resp)
 		} else {

server/canteen/internal/logic/getcanteendetaillogic.go

@@ -27,7 +27,10 @@ func NewGetCanteenDetailLogic(ctx context.Context, svcCtx *svc.ServiceContext) *
 }
 
 // 获取餐厅详情
-func (l *GetCanteenDetailLogic) GetCanteenDetail(req *types.GetCanteenDetailReq, loginInfo *auth.UserInfo) (resp *basic.Response) {
+func (l *GetCanteenDetailLogic) GetCanteenDetail(req *types.GetCanteenDetailReq, userinfo *auth.UserInfo) (resp *basic.Response) {
+	if userinfo.GetIdType() != auth.IDTYPE_User {
+		return resp.SetStatusWithMessage(basic.CodeServiceErr, "please login first")
+	}
 	//获取餐厅类型数据
 	canteenTypeModel := gmodel.NewFsCanteenTypeModel(l.svcCtx.MysqlConn)
 	canteenTypeInfo, err := canteenTypeModel.FindOne(l.ctx, req.Id)

server/canteen/internal/logic/savecanteentypeproductlogic.go

@@ -29,7 +29,10 @@ func NewSaveCanteenTypeProductLogic(ctx context.Context, svcCtx *svc.ServiceCont
 }
 
 // 保存餐厅类型的关联产品
-func (l *SaveCanteenTypeProductLogic) SaveCanteenTypeProduct(req *types.SaveCanteenTypeProductReq, loginInfo *auth.UserInfo) (resp *basic.Response) {
+func (l *SaveCanteenTypeProductLogic) SaveCanteenTypeProduct(req *types.SaveCanteenTypeProductReq, userinfo *auth.UserInfo) (resp *basic.Response) {
+	if userinfo.GetIdType() != auth.IDTYPE_User {
+		return resp.SetStatusWithMessage(basic.CodeServiceErr, "please login first")
+	}
 	if len(req.ProductList) == 0 {
 		return resp.SetStatusWithMessage(basic.CodeRequestParamsErr, "product list can`t be empty")
 	}

server/canteen/internal/types/types.go

@@ -35,9 +35,6 @@ type SaveCanteenProduct struct {
 	SId    string `json:"s_id"`
 }
 
-type Request struct {
-}
-
 type Response struct {
 	Code    int         `json:"code"`
 	Message string      `json:"msg"`

server/data-transfer/internal/handler/getqrcodesetlisthandler.go

@@ -16,34 +16,45 @@ import (
 
 func GetQrCodeSetListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		// 解析jwtToken
+
+		var (
+			// 定义错误变量
+			err error
+			// 定义用户信息变量
+			userinfo *auth.UserInfo
+		)
+		// 解析JWT token,并对空用户进行判断
 		claims, err := svcCtx.ParseJwtToken(r)
-		// 如果解析出错，则返回未授权的JSON响应并记录错误消息
+		// 如果解析JWT token出错,则返回未授权的JSON响应并记录错误消息
 		if err != nil {
 			httpx.OkJsonCtx(r.Context(), w, &basic.Response{
-				Code:    401,
-				Message: "unauthorized",
+				Code:    401,            // 返回401状态码,表示未授权
+				Message: "unauthorized", // 返回未授权信息
 			})
-			logx.Info("unauthorized:", err.Error())
+			logx.Info("unauthorized:", err.Error()) // 记录错误日志
 			return
 		}
 
-		// 从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
+		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}
 		}
 
 		l := logic.NewGetQrCodeSetListLogic(r.Context(), svcCtx)
 		resp := l.GetQrCodeSetList(userinfo)
 		// 如果响应不为nil，则使用httpx.OkJsonCtx方法返回JSON响应;
-		// 否则，发送500内部服务器错误的JSON响应并记录错误消息logx.Error。
 		if resp != nil {
 			httpx.OkJsonCtx(r.Context(), w, resp)
 		} else {

server/data-transfer/internal/handler/getstandardlogolisthandler.go

@@ -16,34 +16,45 @@ import (
 
 func GetStandardLogoListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		// 解析jwtToken
+
+		var (
+			// 定义错误变量
+			err error
+			// 定义用户信息变量
+			userinfo *auth.UserInfo
+		)
+		// 解析JWT token,并对空用户进行判断
 		claims, err := svcCtx.ParseJwtToken(r)
-		// 如果解析出错，则返回未授权的JSON响应并记录错误消息
+		// 如果解析JWT token出错,则返回未授权的JSON响应并记录错误消息
 		if err != nil {
 			httpx.OkJsonCtx(r.Context(), w, &basic.Response{
-				Code:    401,
-				Message: "unauthorized",
+				Code:    401,            // 返回401状态码,表示未授权
+				Message: "unauthorized", // 返回未授权信息
 			})
-			logx.Info("unauthorized:", err.Error())
+			logx.Info("unauthorized:", err.Error()) // 记录错误日志
 			return
 		}
 
-		// 从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
+		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}
 		}
 
 		l := logic.NewGetStandardLogoListLogic(r.Context(), svcCtx)
 		resp := l.GetStandardLogoList(userinfo)
 		// 如果响应不为nil，则使用httpx.OkJsonCtx方法返回JSON响应;
-		// 否则，发送500内部服务器错误的JSON响应并记录错误消息logx.Error。
 		if resp != nil {
 			httpx.OkJsonCtx(r.Context(), w, resp)
 		} else {

server/data-transfer/internal/handler/uploadqrcodehandler.go

@@ -17,28 +17,40 @@ import (
 
 func UploadQrcodeHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		// 解析jwtToken
+
+		var (
+			// 定义错误变量
+			err error
+			// 定义用户信息变量
+			userinfo *auth.UserInfo
+		)
+		// 解析JWT token,并对空用户进行判断
 		claims, err := svcCtx.ParseJwtToken(r)
-		// 如果解析出错，则返回未授权的JSON响应并记录错误消息
+		// 如果解析JWT token出错,则返回未授权的JSON响应并记录错误消息
 		if err != nil {
 			httpx.OkJsonCtx(r.Context(), w, &basic.Response{
-				Code:    401,
-				Message: "unauthorized",
+				Code:    401,            // 返回401状态码,表示未授权
+				Message: "unauthorized", // 返回未授权信息
 			})
-			logx.Info("unauthorized:", err.Error())
+			logx.Info("unauthorized:", err.Error()) // 记录错误日志
 			return
 		}
 
-		// 从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
+		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.UploadQrcodeReq
@@ -55,7 +67,6 @@ func UploadQrcodeHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 		l := logic.NewUploadQrcodeLogic(r.Context(), svcCtx)
 		resp := l.UploadQrcode(&req, userinfo)
 		// 如果响应不为nil，则使用httpx.OkJsonCtx方法返回JSON响应;
-		// 否则，发送500内部服务器错误的JSON响应并记录错误消息logx.Error。
 		if resp != nil {
 			httpx.OkJsonCtx(r.Context(), w, resp)
 		} else {

server/data-transfer/internal/logic/getqrcodesetlistlogic.go

@@ -27,7 +27,10 @@ func NewGetQrCodeSetListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *
 }
 
 // 获取二维码配置列表
-func (l *GetQrCodeSetListLogic) GetQrCodeSetList(loginInfo *auth.UserInfo) (resp *basic.Response) {
+func (l *GetQrCodeSetListLogic) GetQrCodeSetList(userinfo *auth.UserInfo) (resp *basic.Response) {
+	if userinfo.GetIdType() != auth.IDTYPE_User {
+		return resp.SetStatusWithMessage(basic.CodeServiceErr, "please login first")
+	}
 	qrCodeModel := gmodel.NewFsQrcodeSetModel(l.svcCtx.MysqlConn)
 	qrCodeList, err := qrCodeModel.GetAll(l.ctx)
 	if err != nil {

server/data-transfer/internal/logic/getstandardlogolistlogic.go

@@ -26,7 +26,10 @@ func NewGetStandardLogoListLogic(ctx context.Context, svcCtx *svc2.ServiceContex
 }
 
 // 获取标准logo列表
-func (l *GetStandardLogoListLogic) GetStandardLogoList(loginInfo *auth.UserInfo) (resp *basic.Response) {
+func (l *GetStandardLogoListLogic) GetStandardLogoList(userinfo *auth.UserInfo) (resp *basic.Response) {
+	if userinfo.GetIdType() != auth.IDTYPE_User {
+		return resp.SetStatusWithMessage(basic.CodeServiceErr, "please login first")
+	}
 	standardLogoModel := gmodel.NewFsStandardLogoModel(l.svcCtx.MysqlConn)
 	logoList, err := standardLogoModel.GetAll(l.ctx)
 	if err != nil {

server/data-transfer/internal/logic/uploadqrcodelogic.go

@@ -27,7 +27,10 @@ func NewUploadQrcodeLogic(ctx context.Context, svcCtx *svc.ServiceContext) *Uplo
 }
 
 // 生成base64二维码
-func (l *UploadQrcodeLogic) UploadQrcode(req *types.UploadQrcodeReq, loginInfo *auth.UserInfo) (resp *basic.Response) {
+func (l *UploadQrcodeLogic) UploadQrcode(req *types.UploadQrcodeReq, userinfo *auth.UserInfo) (resp *basic.Response) {
+	if userinfo.GetIdType() != auth.IDTYPE_User {
+		return resp.SetStatusWithMessage(basic.CodeServiceErr, "please login first")
+	}
 	if req.Url == "" {
 		resp.SetStatus(basic.CodeApiErr, "param url is empty")
 	}

server/map-library/internal/config/config.go

@@ -1,7 +1,7 @@
 package config
 
 import (
-	"fusenapi/server/map_library/internal/types"
+	"fusenapi/server/map-library/internal/types"
 	"github.com/zeromicro/go-zero/rest"
 )
 

server/map-library/internal/handler/getmaplibrarylisthandler.go

@@ -0,0 +1,66 @@
+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/map-library/internal/logic"
+	"fusenapi/server/map-library/internal/svc"
+)
+
+func GetMapLibraryListHandler(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}
+		}
+
+		l := logic.NewGetMapLibraryListLogic(r.Context(), svcCtx)
+		resp := l.GetMapLibraryList(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)
+		}
+	}
+}

server/map-library/internal/handler/routes.go

@@ -4,7 +4,7 @@ package handler
 import (
 	"net/http"
 
-	"fusenapi/server/map_library/internal/svc"
+	"fusenapi/server/map-library/internal/svc"
 
 	"github.com/zeromicro/go-zero/rest"
 )

server/map-library/internal/logic/getmaplibrarylistlogic.go

@@ -3,14 +3,13 @@ package logic
 import (
 	"encoding/json"
 	"fusenapi/model/gmodel"
-	"fusenapi/server/map_library/internal/types"
+	"fusenapi/server/map-library/internal/svc"
+	"fusenapi/server/map-library/internal/types"
 	"fusenapi/utils/auth"
 	"fusenapi/utils/basic"
 	"time"
 
 	"context"
-
-	"fusenapi/server/map_library/internal/svc"
 	"github.com/zeromicro/go-zero/core/logx"
 )
 
@@ -29,6 +28,9 @@ func NewGetMapLibraryListLogic(ctx context.Context, svcCtx *svc.ServiceContext)
 }
 
 func (l *GetMapLibraryListLogic) GetMapLibraryList(userinfo *auth.UserInfo) (resp *basic.Response) {
+	if userinfo.GetIdType() != auth.IDTYPE_User {
+		return resp.SetStatusWithMessage(basic.CodeServiceErr, "please login first")
+	}
 	mapLibraryModel := gmodel.NewFsMapLibraryModel(l.svcCtx.MysqlConn)
 	mapLibraryList, err := mapLibraryModel.GetAllEnabledList(l.ctx)
 	if err != nil {

server/map-library/internal/svc/servicecontext.go

@@ -4,7 +4,7 @@ import (
 	"errors"
 	"fmt"
 	"fusenapi/initalize"
-	"fusenapi/server/map_library/internal/config"
+	"fusenapi/server/map-library/internal/config"
 	"github.com/golang-jwt/jwt"
 	"gorm.io/gorm"
 	"net/http"

server/map-library/map-library.go

@@ -4,9 +4,9 @@ import (
 	"flag"
 	"fmt"
 
-	"fusenapi/server/map_library/internal/config"
-	"fusenapi/server/map_library/internal/handler"
-	"fusenapi/server/map_library/internal/svc"
+	"fusenapi/server/map-library/internal/config"
+	"fusenapi/server/map-library/internal/handler"
+	"fusenapi/server/map-library/internal/svc"
 
 	"github.com/zeromicro/go-zero/core/conf"
 	"github.com/zeromicro/go-zero/rest"

server/map_library/internal/handler/getmaplibrarylisthandler.go

@@ -1,55 +0,0 @@
-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/map_library/internal/logic"
-	"fusenapi/server/map_library/internal/svc"
-)
-
-func GetMapLibraryListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		// 解析jwtToken
-		claims, err := svcCtx.ParseJwtToken(r)
-		// 如果解析出错，则返回未授权的JSON响应并记录错误消息
-		if err != nil {
-			httpx.OkJsonCtx(r.Context(), w, &basic.Response{
-				Code:    401,
-				Message: "unauthorized",
-			})
-			logx.Info("unauthorized:", err.Error())
-			return
-		}
-
-		// 从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
-		}
-
-		l := logic.NewGetMapLibraryListLogic(r.Context(), svcCtx)
-		resp := l.GetMapLibraryList(userinfo)
-		// 如果响应不为nil，则使用httpx.OkJsonCtx方法返回JSON响应;
-		// 否则，发送500内部服务器错误的JSON响应并记录错误消息logx.Error。
-		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)
-		}
-	}
-}

server/orders/etc/orders.yaml

@@ -0,0 +1,8 @@
+Name: orders
+Host: 0.0.0.0
+Port: 8893
+SourceMysql: fusentest:XErSYmLELKMnf3Dh@tcp(110.41.19.98:3306)/fusentest
+Auth:
+    AccessSecret: fusen2023
+    AccessExpire: 60
+    RefreshAfter: 60

server/orders/internal/config/config.go

@@ -0,0 +1,12 @@
+package config
+
+import (
+	"fusenapi/server/orders/internal/types"
+	"github.com/zeromicro/go-zero/rest"
+)
+
+type Config struct {
+	rest.RestConf
+	SourceMysql string
+	Auth        types.Auth
+}

server/orders/internal/handler/getorderinvoicehandler.go

@@ -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/orders/internal/logic"
+	"fusenapi/server/orders/internal/svc"
+	"fusenapi/server/orders/internal/types"
+)
+
+func GetOrderInvoiceHandler(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.GetOrderInvoiceReq
+		// 如果端点有请求结构体，则使用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.NewGetOrderInvoiceLogic(r.Context(), svcCtx)
+		resp := l.GetOrderInvoice(&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)
+		}
+	}
+}

server/orders/internal/handler/routes.go

@@ -0,0 +1,22 @@
+// Code generated by goctl. DO NOT EDIT.
+package handler
+
+import (
+	"net/http"
+
+	"fusenapi/server/orders/internal/svc"
+
+	"github.com/zeromicro/go-zero/rest"
+)
+
+func RegisterHandlers(server *rest.Server, serverCtx *svc.ServiceContext) {
+	server.AddRoutes(
+		[]rest.Route{
+			{
+				Method:  http.MethodGet,
+				Path:    "/order/invoice",
+				Handler: GetOrderInvoiceHandler(serverCtx),
+			},
+		},
+	)
+}

server/orders/internal/logic/getorderinvoicelogic.go

@@ -0,0 +1,68 @@
+package logic
+
+import (
+	"encoding/json"
+	"fusenapi/model/gmodel"
+	"fusenapi/utils/auth"
+	"fusenapi/utils/basic"
+
+	"context"
+
+	"fusenapi/server/orders/internal/svc"
+	"fusenapi/server/orders/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type GetOrderInvoiceLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewGetOrderInvoiceLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetOrderInvoiceLogic {
+	return &GetOrderInvoiceLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetOrderInvoiceLogic) GetOrderInvoice(req *types.GetOrderInvoiceReq, userinfo *auth.UserInfo) (resp *basic.Response) {
+	if userinfo.GetIdType() != auth.IDTYPE_User {
+		return resp.SetStatusWithMessage(basic.CodeUnAuth, "please login first")
+	}
+	//获取用户信息
+	userModel := gmodel.NewFsUserModel(l.svcCtx.MysqlConn)
+	user, err := userModel.FindOne(l.ctx, userinfo.UserId)
+	if err != nil {
+		logx.Error(err)
+		return resp.SetStatusWithMessage(basic.CodeServiceErr, "failed to get user info")
+	}
+	if user.Id == 0 {
+		return resp.SetStatusWithMessage(basic.CodeDbRecordNotFoundErr, "user not found")
+	}
+	if req.Sn == "" {
+		return resp.SetStatusWithMessage(basic.CodeRequestParamsErr, "param sn is required")
+	}
+	//查询订单信息
+	orderModel := gmodel.NewFsOrderModel(l.svcCtx.MysqlConn)
+	orderInfo, err := orderModel.FindOneBySn(l.ctx, userinfo.UserId, req.Sn)
+	if err != nil {
+		logx.Error(err)
+		return resp.SetStatusWithMessage(basic.CodeServiceErr, "failed to get order info")
+	}
+	if orderInfo.Id == 0 {
+		return resp.SetStatusWithMessage(basic.CodeDbRecordNotFoundErr, "order is not exists")
+	}
+	//地址数据
+	var address gmodel.FsAddress
+	if err = json.Unmarshal([]byte(*orderInfo.AddressInfo), &address); err != nil {
+		logx.Error(err)
+		return resp.SetStatusWithMessage(basic.CodeServiceErr, "failed to parse address info")
+	}
+	if user.LastName != nil && user.FirstName != nil {
+
+	}
+	return resp.SetStatus(basic.CodeOK)
+}

server/orders/internal/svc/servicecontext.go

@@ -0,0 +1,50 @@
+package svc
+
+import (
+	"errors"
+	"fusenapi/initalize"
+	"fusenapi/server/orders/internal/config"
+	"github.com/golang-jwt/jwt"
+	"gorm.io/gorm"
+	"net/http"
+)
+
+type ServiceContext struct {
+	Config config.Config
+
+	MysqlConn *gorm.DB
+}
+
+func NewServiceContext(c config.Config) *ServiceContext {
+
+	return &ServiceContext{
+		Config:    c,
+		MysqlConn: initalize.InitMysql(c.SourceMysql),
+	}
+}
+
+func (svcCxt *ServiceContext) ParseJwtToken(r *http.Request) (jwt.MapClaims, error) {
+	AuthKey := r.Header.Get("Authorization")
+	if len(AuthKey) <= 50 {
+		return nil, errors.New(fmt.Sprint("Error parsing token, len:", len(AuthKey)))
+	}
+
+	token, err := jwt.Parse(AuthKey, func(token *jwt.Token) (interface{}, error) {
+		// 检查签名方法是否为 HS256
+		if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
+			return nil, fmt.Errorf("unexpected signing method: %v", token.Header["alg"])
+		}
+		// 返回用于验证签名的密钥
+		return svcCxt.Config.Auth.AccessSecret, nil
+	})
+	if err != nil {
+		return nil, errors.New(fmt.Sprint("Error parsing token:", err))
+	}
+
+	// 验证成功返回
+	if claims, ok := token.Claims.(jwt.MapClaims); ok && token.Valid {
+		return claims, nil
+	}
+
+	return nil, errors.New(fmt.Sprint("Invalid token", err))
+}

server/orders/internal/types/types.go

@@ -0,0 +1,76 @@
+// Code generated by goctl. DO NOT EDIT.
+package types
+
+import (
+	"fusenapi/utils/basic"
+)
+
+type GetOrderInvoiceReq struct {
+	Sn       string `json:"sn"`
+	TimeZone string `json:"timeZone"`
+}
+
+type GetOrderInvoiceRsp struct {
+	FileName string `json:"file_name"`
+	Pdf      int64  `json:"pdf"`
+}
+
+type Response struct {
+	Code    int         `json:"code"`
+	Message string      `json:"msg"`
+	Data    interface{} `json:"data"`
+}
+
+type ResponseJwt struct {
+	Code         int         `json:"code"`
+	Message      string      `json:"msg"`
+	Data         interface{} `json:"data"`
+	AccessSecret string      `json:"accessSecret"`
+	AccessExpire int64       `json:"accessExpire"`
+}
+
+type Auth struct {
+	AccessSecret string `json:"accessSecret"`
+	AccessExpire int64  `json:"accessExpire"`
+	RefreshAfter int64  `json:"refreshAfter"`
+}
+
+// Set 设置Response的Code和Message值
+func (resp *Response) Set(Code int, Message string) *Response {
+	return &Response{
+		Code:    Code,
+		Message: Message,
+	}
+}
+
+// Set 设置整个Response
+func (resp *Response) SetWithData(Code int, Message string, Data interface{}) *Response {
+	return &Response{
+		Code:    Code,
+		Message: Message,
+		Data:    Data,
+	}
+}
+
+// SetStatus 设置默认StatusResponse(内部自定义) 默认msg, 可以带data, data只使用一个参数
+func (resp *Response) SetStatus(sr *basic.StatusResponse, data ...interface{}) *Response {
+	newResp := &Response{
+		Code: sr.Code,
+	}
+	if len(data) == 1 {
+		newResp.Data = data[0]
+	}
+	return newResp
+}
+
+// SetStatusWithMessage 设置默认StatusResponse(内部自定义) 非默认msg, 可以带data, data只使用一个参数
+func (resp *Response) SetStatusWithMessage(sr *basic.StatusResponse, msg string, data ...interface{}) *Response {
+	newResp := &Response{
+		Code:    sr.Code,
+		Message: msg,
+	}
+	if len(data) == 1 {
+		newResp.Data = data[0]
+	}
+	return newResp
+}

server/orders/orders.go

@@ -0,0 +1,49 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+
+	"fusenapi/server/orders/internal/config"
+	"fusenapi/server/orders/internal/handler"
+	"fusenapi/server/orders/internal/svc"
+
+	"github.com/zeromicro/go-zero/core/conf"
+	"github.com/zeromicro/go-zero/rest"
+)
+
+var configFile = flag.String("f", "etc/orders.yaml", "the config file")
+
+func main() {
+	flag.Parse()
+
+	var c config.Config
+	conf.MustLoad(*configFile, &c)
+
+	server := rest.MustNewServer(c.RestConf)
+	defer server.Stop()
+
+	ctx := svc.NewServiceContext(c)
+	handler.RegisterHandlers(server, ctx)
+
+	fmt.Printf("Starting server at %s:%d...\n", c.Host, c.Port)
+	server.Start()
+}
+
+// var testConfigFile = flag.String("f", "../etc/orders.yaml", "the config file")
+// var cnf config.Config
+
+// func GetTestServer() *rest.Server {
+// 	flag.Parse()
+
+// 	conf.MustLoad(*testConfigFile, &cnf)
+
+// 	server := rest.MustNewServer(cnf.RestConf)
+// 	defer server.Stop()
+
+// 	ctx := svc.NewServiceContext(cnf)
+// 	handler.RegisterHandlers(server, ctx)
+
+// 	fmt.Printf("Starting server at %s:%d...\n", cnf.Host, cnf.Port)
+// 	return server
+// }

server/product/internal/handler/getproductlisthandler.go

@@ -17,28 +17,40 @@ import (
 
 func GetProductListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		// 解析jwtToken
+
+		var (
+			// 定义错误变量
+			err error
+			// 定义用户信息变量
+			userinfo *auth.UserInfo
+		)
+		// 解析JWT token,并对空用户进行判断
 		claims, err := svcCtx.ParseJwtToken(r)
-		// 如果解析出错，则返回未授权的JSON响应并记录错误消息
+		// 如果解析JWT token出错,则返回未授权的JSON响应并记录错误消息
 		if err != nil {
 			httpx.OkJsonCtx(r.Context(), w, &basic.Response{
-				Code:    401,
-				Message: "unauthorized",
+				Code:    401,            // 返回401状态码,表示未授权
+				Message: "unauthorized", // 返回未授权信息
 			})
-			logx.Info("unauthorized:", err.Error())
+			logx.Info("unauthorized:", err.Error()) // 记录错误日志
 			return
 		}
 
-		// 从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
+		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.GetProductListReq
@@ -55,7 +67,6 @@ func GetProductListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 		l := logic.NewGetProductListLogic(r.Context(), svcCtx)
 		resp := l.GetProductList(&req, userinfo)
 		// 如果响应不为nil，则使用httpx.OkJsonCtx方法返回JSON响应;
-		// 否则，发送500内部服务器错误的JSON响应并记录错误消息logx.Error。
 		if resp != nil {
 			httpx.OkJsonCtx(r.Context(), w, resp)
 		} else {

server/product/internal/handler/getsizebyproducthandler.go

@@ -16,34 +16,45 @@ import (
 
 func GetSizeByProductHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		// 解析jwtToken
+
+		var (
+			// 定义错误变量
+			err error
+			// 定义用户信息变量
+			userinfo *auth.UserInfo
+		)
+		// 解析JWT token,并对空用户进行判断
 		claims, err := svcCtx.ParseJwtToken(r)
-		// 如果解析出错，则返回未授权的JSON响应并记录错误消息
+		// 如果解析JWT token出错,则返回未授权的JSON响应并记录错误消息
 		if err != nil {
 			httpx.OkJsonCtx(r.Context(), w, &basic.Response{
-				Code:    401,
-				Message: "unauthorized",
+				Code:    401,            // 返回401状态码,表示未授权
+				Message: "unauthorized", // 返回未授权信息
 			})
-			logx.Info("unauthorized:", err.Error())
+			logx.Info("unauthorized:", err.Error()) // 记录错误日志
 			return
 		}
 
-		// 从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
+		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}
 		}
 
 		l := logic.NewGetSizeByProductLogic(r.Context(), svcCtx)
 		resp := l.GetSizeByProduct(userinfo)
 		// 如果响应不为nil，则使用httpx.OkJsonCtx方法返回JSON响应;
-		// 否则，发送500内部服务器错误的JSON响应并记录错误消息logx.Error。
 		if resp != nil {
 			httpx.OkJsonCtx(r.Context(), w, resp)
 		} else {

server/product/internal/handler/getsuccessrecommandhandler.go

@@ -17,28 +17,40 @@ import (
 
 func GetSuccessRecommandHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		// 解析jwtToken
+
+		var (
+			// 定义错误变量
+			err error
+			// 定义用户信息变量
+			userinfo *auth.UserInfo
+		)
+		// 解析JWT token,并对空用户进行判断
 		claims, err := svcCtx.ParseJwtToken(r)
-		// 如果解析出错，则返回未授权的JSON响应并记录错误消息
+		// 如果解析JWT token出错,则返回未授权的JSON响应并记录错误消息
 		if err != nil {
 			httpx.OkJsonCtx(r.Context(), w, &basic.Response{
-				Code:    401,
-				Message: "unauthorized",
+				Code:    401,            // 返回401状态码,表示未授权
+				Message: "unauthorized", // 返回未授权信息
 			})
-			logx.Info("unauthorized:", err.Error())
+			logx.Info("unauthorized:", err.Error()) // 记录错误日志
 			return
 		}
 
-		// 从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
+		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.GetSuccessRecommandReq
@@ -55,7 +67,6 @@ func GetSuccessRecommandHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 		l := logic.NewGetSuccessRecommandLogic(r.Context(), svcCtx)
 		resp := l.GetSuccessRecommand(&req, userinfo)
 		// 如果响应不为nil，则使用httpx.OkJsonCtx方法返回JSON响应;
-		// 否则，发送500内部服务器错误的JSON响应并记录错误消息logx.Error。
 		if resp != nil {
 			httpx.OkJsonCtx(r.Context(), w, resp)
 		} else {

server/product/internal/logic/getproductlistlogic.go

@@ -33,7 +33,10 @@ func NewGetProductListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *Ge
 }
 
 // 获取产品列表
-func (l *GetProductListLogic) GetProductList(req *types.GetProductListReq, loginInfo *auth.UserInfo) (resp *basic.Response) {
+func (l *GetProductListLogic) GetProductList(req *types.GetProductListReq, userinfo *auth.UserInfo) (resp *basic.Response) {
+	if userinfo.GetIdType() != auth.IDTYPE_User {
+		return resp.SetStatusWithMessage(basic.CodeUnAuth, "please login first")
+	}
 	//如果是demo
 	if req.IsDemo == 1 {
 		var demo types.GetProductListRsp
@@ -52,7 +55,7 @@ func (l *GetProductListLogic) GetProductList(req *types.GetProductListReq, login
 	}
 	//查询用户信息
 	userModel := gmodel.NewFsUserModel(l.svcCtx.MysqlConn)
-	userInfo, err := userModel.FindOne(l.ctx, loginInfo.UserId)
+	userInfo, err := userModel.FindOne(l.ctx, userinfo.UserId)
 	if err != nil {
 		logx.Error(err)
 		return resp.SetStatusWithMessage(basic.CodeServiceErr, "get user info err")

server/product/internal/logic/getsizebyproductlogic.go

@@ -33,7 +33,10 @@ func NewGetSizeByProductLogic(ctx context.Context, svcCtx *svc.ServiceContext) *
 }
 
 // 获取分类下的产品以及尺寸
-func (l *GetSizeByProductLogic) GetSizeByProduct(loginInfo *auth.UserInfo) (resp *basic.Response) {
+func (l *GetSizeByProductLogic) GetSizeByProduct(userinfo *auth.UserInfo) (resp *basic.Response) {
+	if userinfo.GetIdType() != auth.IDTYPE_User {
+		return resp.SetStatusWithMessage(basic.CodeUnAuth, "please login first")
+	}
 	//获取所有网站目录
 	tagsModel := gmodel.NewFsTagsModel(l.svcCtx.MysqlConn)
 	tagsList, err := tagsModel.GetAllByLevel(l.ctx, constants.TYPE_WEBSITE)

server/product/internal/logic/getsuccessrecommandlogic.go

@@ -27,6 +27,9 @@ func NewGetSuccessRecommandLogic(ctx context.Context, svcCtx *svc.ServiceContext
 
 // 获取推荐的产品列表
 func (l *GetSuccessRecommandLogic) GetSuccessRecommand(req *types.GetSuccessRecommandReq, userInfo *auth.UserInfo) (resp *basic.Response) {
+	if userInfo.GetIdType() != auth.IDTYPE_User {
+		return resp.SetStatusWithMessage(basic.CodeUnAuth, "please login first")
+	}
 	//获取用户信息
 	userModel := gmodel.NewFsUserModel(l.svcCtx.MysqlConn)
 	user, err := userModel.FindOne(l.ctx, userInfo.UserId)

server/product/internal/types/types.go

@@ -96,9 +96,6 @@ type PriceObj struct {
 	Price float64 `json:"price"`
 }
 
-type Request struct {
-}
-
 type Response struct {
 	Code    int         `json:"code"`
 	Message string      `json:"msg"`

server/shopping-cart-confirmation/internal/handler/cartaddhandler.go

@@ -17,28 +17,40 @@ import (
 
 func CartAddHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		// 解析jwtToken
+
+		var (
+			// 定义错误变量
+			err error
+			// 定义用户信息变量
+			userinfo *auth.UserInfo
+		)
+		// 解析JWT token,并对空用户进行判断
 		claims, err := svcCtx.ParseJwtToken(r)
-		// 如果解析出错，则返回未授权的JSON响应并记录错误消息
+		// 如果解析JWT token出错,则返回未授权的JSON响应并记录错误消息
 		if err != nil {
 			httpx.OkJsonCtx(r.Context(), w, &basic.Response{
-				Code:    401,
-				Message: "unauthorized",
+				Code:    401,            // 返回401状态码,表示未授权
+				Message: "unauthorized", // 返回未授权信息
 			})
-			logx.Info("unauthorized:", err.Error())
+			logx.Info("unauthorized:", err.Error()) // 记录错误日志
 			return
 		}
 
-		// 从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
+		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.CartAddReq
@@ -55,7 +67,6 @@ func CartAddHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 		l := logic.NewCartAddLogic(r.Context(), svcCtx)
 		resp := l.CartAdd(&req, userinfo)
 		// 如果响应不为nil，则使用httpx.OkJsonCtx方法返回JSON响应;
-		// 否则，发送500内部服务器错误的JSON响应并记录错误消息logx.Error。
 		if resp != nil {
 			httpx.OkJsonCtx(r.Context(), w, resp)
 		} else {

server/shopping-cart-confirmation/internal/handler/cartdeletehandler.go

@@ -17,28 +17,40 @@ import (
 
 func CartDeleteHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		// 解析jwtToken
+
+		var (
+			// 定义错误变量
+			err error
+			// 定义用户信息变量
+			userinfo *auth.UserInfo
+		)
+		// 解析JWT token,并对空用户进行判断
 		claims, err := svcCtx.ParseJwtToken(r)
-		// 如果解析出错，则返回未授权的JSON响应并记录错误消息
+		// 如果解析JWT token出错,则返回未授权的JSON响应并记录错误消息
 		if err != nil {
 			httpx.OkJsonCtx(r.Context(), w, &basic.Response{
-				Code:    401,
-				Message: "unauthorized",
+				Code:    401,            // 返回401状态码,表示未授权
+				Message: "unauthorized", // 返回未授权信息
 			})
-			logx.Info("unauthorized:", err.Error())
+			logx.Info("unauthorized:", err.Error()) // 记录错误日志
 			return
 		}
 
-		// 从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
+		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.CartDeleteReq
@@ -55,7 +67,6 @@ func CartDeleteHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 		l := logic.NewCartDeleteLogic(r.Context(), svcCtx)
 		resp := l.CartDelete(&req, userinfo)
 		// 如果响应不为nil，则使用httpx.OkJsonCtx方法返回JSON响应;
-		// 否则，发送500内部服务器错误的JSON响应并记录错误消息logx.Error。
 		if resp != nil {
 			httpx.OkJsonCtx(r.Context(), w, resp)
 		} else {

server/shopping-cart-confirmation/internal/handler/cartlisthandler.go

@@ -17,28 +17,40 @@ import (
 
 func CartListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		// 解析jwtToken
+
+		var (
+			// 定义错误变量
+			err error
+			// 定义用户信息变量
+			userinfo *auth.UserInfo
+		)
+		// 解析JWT token,并对空用户进行判断
 		claims, err := svcCtx.ParseJwtToken(r)
-		// 如果解析出错，则返回未授权的JSON响应并记录错误消息
+		// 如果解析JWT token出错,则返回未授权的JSON响应并记录错误消息
 		if err != nil {
 			httpx.OkJsonCtx(r.Context(), w, &basic.Response{
-				Code:    401,
-				Message: "unauthorized",
+				Code:    401,            // 返回401状态码,表示未授权
+				Message: "unauthorized", // 返回未授权信息
 			})
-			logx.Info("unauthorized:", err.Error())
+			logx.Info("unauthorized:", err.Error()) // 记录错误日志
 			return
 		}
 
-		// 从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
+		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.CartListReq
@@ -55,7 +67,6 @@ func CartListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 		l := logic.NewCartListLogic(r.Context(), svcCtx)
 		resp := l.CartList(&req, userinfo)
 		// 如果响应不为nil，则使用httpx.OkJsonCtx方法返回JSON响应;
-		// 否则，发送500内部服务器错误的JSON响应并记录错误消息logx.Error。
 		if resp != nil {
 			httpx.OkJsonCtx(r.Context(), w, resp)
 		} else {

server/shopping-cart-confirmation/internal/handler/cartnumberhandler.go

@@ -16,34 +16,45 @@ import (
 
 func CartNumberHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		// 解析jwtToken
+
+		var (
+			// 定义错误变量
+			err error
+			// 定义用户信息变量
+			userinfo *auth.UserInfo
+		)
+		// 解析JWT token,并对空用户进行判断
 		claims, err := svcCtx.ParseJwtToken(r)
-		// 如果解析出错，则返回未授权的JSON响应并记录错误消息
+		// 如果解析JWT token出错,则返回未授权的JSON响应并记录错误消息
 		if err != nil {
 			httpx.OkJsonCtx(r.Context(), w, &basic.Response{
-				Code:    401,
-				Message: "unauthorized",
+				Code:    401,            // 返回401状态码,表示未授权
+				Message: "unauthorized", // 返回未授权信息
 			})
-			logx.Info("unauthorized:", err.Error())
+			logx.Info("unauthorized:", err.Error()) // 记录错误日志
 			return
 		}
 
-		// 从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
+		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}
 		}
 
 		l := logic.NewCartNumberLogic(r.Context(), svcCtx)
 		resp := l.CartNumber(userinfo)
 		// 如果响应不为nil，则使用httpx.OkJsonCtx方法返回JSON响应;
-		// 否则，发送500内部服务器错误的JSON响应并记录错误消息logx.Error。
 		if resp != nil {
 			httpx.OkJsonCtx(r.Context(), w, resp)
 		} else {

server/shopping-cart-confirmation/internal/handler/cartorderdetailhandler.go

@@ -17,28 +17,40 @@ import (
 
 func CartOrderDetailHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		// 解析jwtToken
+
+		var (
+			// 定义错误变量
+			err error
+			// 定义用户信息变量
+			userinfo *auth.UserInfo
+		)
+		// 解析JWT token,并对空用户进行判断
 		claims, err := svcCtx.ParseJwtToken(r)
-		// 如果解析出错，则返回未授权的JSON响应并记录错误消息
+		// 如果解析JWT token出错,则返回未授权的JSON响应并记录错误消息
 		if err != nil {
 			httpx.OkJsonCtx(r.Context(), w, &basic.Response{
-				Code:    401,
-				Message: "unauthorized",
+				Code:    401,            // 返回401状态码,表示未授权
+				Message: "unauthorized", // 返回未授权信息
 			})
-			logx.Info("unauthorized:", err.Error())
+			logx.Info("unauthorized:", err.Error()) // 记录错误日志
 			return
 		}
 
-		// 从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
+		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.CartOrderDetailReq
@@ -55,7 +67,6 @@ func CartOrderDetailHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 		l := logic.NewCartOrderDetailLogic(r.Context(), svcCtx)
 		resp := l.CartOrderDetail(&req, userinfo)
 		// 如果响应不为nil，则使用httpx.OkJsonCtx方法返回JSON响应;
-		// 否则，发送500内部服务器错误的JSON响应并记录错误消息logx.Error。
 		if resp != nil {
 			httpx.OkJsonCtx(r.Context(), w, resp)
 		} else {

server/shopping-cart-confirmation/internal/handler/changeordermethodhandler.go

@@ -17,28 +17,40 @@ import (
 
 func ChangeOrderMethodHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		// 解析jwtToken
+
+		var (
+			// 定义错误变量
+			err error
+			// 定义用户信息变量
+			userinfo *auth.UserInfo
+		)
+		// 解析JWT token,并对空用户进行判断
 		claims, err := svcCtx.ParseJwtToken(r)
-		// 如果解析出错，则返回未授权的JSON响应并记录错误消息
+		// 如果解析JWT token出错,则返回未授权的JSON响应并记录错误消息
 		if err != nil {
 			httpx.OkJsonCtx(r.Context(), w, &basic.Response{
-				Code:    401,
-				Message: "unauthorized",
+				Code:    401,            // 返回401状态码,表示未授权
+				Message: "unauthorized", // 返回未授权信息
 			})
-			logx.Info("unauthorized:", err.Error())
+			logx.Info("unauthorized:", err.Error()) // 记录错误日志
 			return
 		}
 
-		// 从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
+		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.ChangeOrderMethodReq
@@ -55,7 +67,6 @@ func ChangeOrderMethodHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 		l := logic.NewChangeOrderMethodLogic(r.Context(), svcCtx)
 		resp := l.ChangeOrderMethod(&req, userinfo)
 		// 如果响应不为nil，则使用httpx.OkJsonCtx方法返回JSON响应;
-		// 否则，发送500内部服务器错误的JSON响应并记录错误消息logx.Error。
 		if resp != nil {
 			httpx.OkJsonCtx(r.Context(), w, resp)
 		} else {

server/shopping-cart-confirmation/internal/logic/cartaddlogic.go

@@ -31,6 +31,9 @@ func NewCartAddLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CartAddLo
 
 // 添加入购物车
 func (l *CartAddLogic) CartAdd(req *types.CartAddReq, userinfo *auth.UserInfo) (resp *basic.Response) {
+	if userinfo.GetIdType() != auth.IDTYPE_User {
+		return resp.SetStatusWithMessage(basic.CodeUnAuth, "please login first")
+	}
 	if req.BuyNum == 0 {
 		return resp.SetStatusWithMessage(basic.CodeRequestParamsErr, "param buy_num can`t be 0")
 	}

server/shopping-cart-confirmation/internal/logic/cartdeletelogic.go

@@ -28,6 +28,9 @@ func NewCartDeleteLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CartDe
 }
 
 func (l *CartDeleteLogic) CartDelete(req *types.CartDeleteReq, userinfo *auth.UserInfo) (resp *basic.Response) {
+	if userinfo.GetIdType() != auth.IDTYPE_User {
+		return resp.SetStatusWithMessage(basic.CodeUnAuth, "please login first")
+	}
 	if req.Id <= 0 {
 		return resp.SetStatusWithMessage(basic.CodeRequestParamsErr, "invalid param id")
 	}

server/shopping-cart-confirmation/internal/logic/cartlistlogic.go

@@ -38,6 +38,9 @@ func NewCartListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CartList
 
 // 获取用户购物车列表
 func (l *CartListLogic) CartList(req *types.CartListReq, userinfo *auth.UserInfo) (resp *basic.Response) {
+	if userinfo.GetIdType() != auth.IDTYPE_User {
+		return resp.SetStatusWithMessage(basic.CodeUnAuth, "please login first")
+	}
 	//获取当前图片应该返回的尺寸大小
 	if req.Size > 0 {
 		req.Size = image.GetCurrentSize(req.Size)

server/shopping-cart-confirmation/internal/logic/cartnumberlogic.go

@@ -27,6 +27,9 @@ func NewCartNumberLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CartNu
 }
 
 func (l *CartNumberLogic) CartNumber(userinfo *auth.UserInfo) (resp *basic.Response) {
+	if userinfo.GetIdType() != auth.IDTYPE_User {
+		return resp.SetStatusWithMessage(basic.CodeUnAuth, "please login first")
+	}
 	cartModel := gmodel.NewFsCartModel(l.svcCtx.MysqlConn)
 	total, err := cartModel.CountUserCart(l.ctx, userinfo.UserId)
 	if err != nil {

server/shopping-cart-confirmation/internal/logic/cartorderdetaillogic.go

@@ -31,6 +31,9 @@ func NewCartOrderDetailLogic(ctx context.Context, svcCtx *svc.ServiceContext) *C
 }
 
 func (l *CartOrderDetailLogic) CartOrderDetail(req *types.CartOrderDetailReq, userinfo *auth.UserInfo) (resp *basic.Response) {
+	if userinfo.GetIdType() != auth.IDTYPE_User {
+		return resp.SetStatusWithMessage(basic.CodeUnAuth, "please login first")
+	}
 	req.Sn = strings.Trim(req.Sn, " ")
 	if req.Sn == "" {
 		return resp.SetStatusWithMessage(basic.CodeRequestParamsErr, "param sn is required")

server/shopping-cart-confirmation/internal/logic/changeordermethodlogic.go

@@ -30,6 +30,9 @@ func NewChangeOrderMethodLogic(ctx context.Context, svcCtx *svc.ServiceContext)
 }
 
 func (l *ChangeOrderMethodLogic) ChangeOrderMethod(req *types.ChangeOrderMethodReq, userinfo *auth.UserInfo) (resp *basic.Response) {
+	if userinfo.GetIdType() != auth.IDTYPE_User {
+		return resp.SetStatusWithMessage(basic.CodeUnAuth, "please login first")
+	}
 	req.Sn = strings.Trim(req.Sn, " ")
 	if req.Sn == "" {
 		return resp.SetStatusWithMessage(basic.CodeRequestParamsErr, "param sn is required")