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

go.mod

@@ -3,6 +3,7 @@ module fusenapi
 go 1.20
 
 require (
+	github.com/SebastiaanKlippert/go-wkhtmltopdf v1.9.0
 	github.com/golang-jwt/jwt v3.2.2+incompatible
 	github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646
 	github.com/skip2/go-qrcode v0.0.0-20200617195104-da1b6568686e
@@ -14,6 +15,7 @@ require (
 
 require (
 	github.com/antlr/antlr4/runtime/Go/antlr v0.0.0-20210521184019-c5ad59b459ec // indirect
+	github.com/google/uuid v1.3.0 // indirect
 	github.com/logrusorgru/aurora v2.0.3+incompatible // indirect
 )
 
@@ -40,7 +42,6 @@ require (
 	github.com/golang-jwt/jwt/v4 v4.5.0 // indirect
 	github.com/golang/protobuf v1.5.3 // indirect
 	github.com/google/pprof v0.0.0-20211214055906-6f57359322fd // indirect
-	github.com/google/uuid v1.3.0 // indirect
 	github.com/grpc-ecosystem/grpc-gateway/v2 v2.15.0 // indirect
 	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.17 // indirect

go.sum

@@ -38,6 +38,8 @@ github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03
 github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
 github.com/DATA-DOG/go-sqlmock v1.5.0 h1:Shsta01QNfFxHCfpW6YH2STWB0MudeXXEWMr20OEh60=
 github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
+github.com/SebastiaanKlippert/go-wkhtmltopdf v1.9.0 h1:DNrExYwvyyI404SxdUCCANAj9TwnGjRfa3cYFMNY1AU=
+github.com/SebastiaanKlippert/go-wkhtmltopdf v1.9.0/go.mod h1:SQq4xfIdvf6WYKSDxAJc+xOJdolt+/bc1jnQKMtPMvQ=
 github.com/alicebob/gopher-json v0.0.0-20200520072559-a9ecdc9d1d3a h1:HbKu58rmZpUGpz5+4FfNmIU+FmZg2P3Xaj2v2bfNWmk=
 github.com/alicebob/miniredis/v2 v2.30.2 h1:lc1UAUT9ZA7h4srlfBmBt2aorm5Yftk9nBjxz7EyY9I=
 github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY=

model/gmodel/fs_user_gen.go

@@ -1,4 +1,4 @@
-package model
+package gmodel
 
 import (
 	"gorm.io/gorm"

server/canteen/internal/handler/getcanteendetailhandler.go

@@ -17,9 +17,29 @@ 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,            // 返回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,
@@ -28,17 +48,9 @@ func GetCanteenDetailHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 				logx.Info("unauthorized:", err.Error())
 				return
 			}
-
+		} else {
-		// 从Token里获取对应的信息
+			// 如果claims为nil,则认为用户身份为白板用户
-		userinfo, err := auth.GetUserInfoFormMapClaims(claims)
+			userinfo = &auth.UserInfo{UserId: 0, GuestId: 0}
-		// 如果获取用户信息出错，则返回未授权的JSON响应并记录错误消息
-		if err != nil {
-			httpx.OkJsonCtx(r.Context(), w, &basic.Response{
-				Code:    401,
-				Message: "unauthorized",
-			})
-			logx.Info("unauthorized:", err.Error())
-			return
 		}
 
 		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,9 +17,29 @@ 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,            // 返回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,
@@ -28,17 +48,9 @@ func SaveCanteenTypeProductHandler(svcCtx *svc.ServiceContext) http.HandlerFunc
 				logx.Info("unauthorized:", err.Error())
 				return
 			}
-
+		} else {
-		// 从Token里获取对应的信息
+			// 如果claims为nil,则认为用户身份为白板用户
-		userinfo, err := auth.GetUserInfoFormMapClaims(claims)
+			userinfo = &auth.UserInfo{UserId: 0, GuestId: 0}
-		// 如果获取用户信息出错，则返回未授权的JSON响应并记录错误消息
-		if err != nil {
-			httpx.OkJsonCtx(r.Context(), w, &basic.Response{
-				Code:    401,
-				Message: "unauthorized",
-			})
-			logx.Info("unauthorized:", err.Error())
-			return
 		}
 
 		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,9 +16,29 @@ 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,            // 返回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,
@@ -27,23 +47,14 @@ func GetQrCodeSetListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 				logx.Info("unauthorized:", err.Error())
 				return
 			}
-
+		} else {
-		// 从Token里获取对应的信息
+			// 如果claims为nil,则认为用户身份为白板用户
-		userinfo, err := auth.GetUserInfoFormMapClaims(claims)
+			userinfo = &auth.UserInfo{UserId: 0, GuestId: 0}
-		// 如果获取用户信息出错，则返回未授权的JSON响应并记录错误消息
-		if err != nil {
-			httpx.OkJsonCtx(r.Context(), w, &basic.Response{
-				Code:    401,
-				Message: "unauthorized",
-			})
-			logx.Info("unauthorized:", err.Error())
-			return
 		}
 
 		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,9 +16,29 @@ 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,            // 返回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,
@@ -27,23 +47,14 @@ func GetStandardLogoListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 				logx.Info("unauthorized:", err.Error())
 				return
 			}
-
+		} else {
-		// 从Token里获取对应的信息
+			// 如果claims为nil,则认为用户身份为白板用户
-		userinfo, err := auth.GetUserInfoFormMapClaims(claims)
+			userinfo = &auth.UserInfo{UserId: 0, GuestId: 0}
-		// 如果获取用户信息出错，则返回未授权的JSON响应并记录错误消息
-		if err != nil {
-			httpx.OkJsonCtx(r.Context(), w, &basic.Response{
-				Code:    401,
-				Message: "unauthorized",
-			})
-			logx.Info("unauthorized:", err.Error())
-			return
 		}
 
 		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,9 +17,29 @@ 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,            // 返回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,
@@ -28,17 +48,9 @@ func UploadQrcodeHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 				logx.Info("unauthorized:", err.Error())
 				return
 			}
-
+		} else {
-		// 从Token里获取对应的信息
+			// 如果claims为nil,则认为用户身份为白板用户
-		userinfo, err := auth.GetUserInfoFormMapClaims(claims)
+			userinfo = &auth.UserInfo{UserId: 0, GuestId: 0}
-		// 如果获取用户信息出错，则返回未授权的JSON响应并记录错误消息
-		if err != nil {
-			httpx.OkJsonCtx(r.Context(), w, &basic.Response{
-				Code:    401,
-				Message: "unauthorized",
-			})
-			logx.Info("unauthorized:", err.Error())
-			return
 		}
 
 		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/config"
-	"fusenapi/server/map_library/internal/handler"
+	"fusenapi/server/map-library/internal/handler"
-	"fusenapi/server/map_library/internal/svc"
+	"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,9 +17,29 @@ 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,            // 返回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,
@@ -28,17 +48,9 @@ func GetProductListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 				logx.Info("unauthorized:", err.Error())
 				return
 			}
-
+		} else {
-		// 从Token里获取对应的信息
+			// 如果claims为nil,则认为用户身份为白板用户
-		userinfo, err := auth.GetUserInfoFormMapClaims(claims)
+			userinfo = &auth.UserInfo{UserId: 0, GuestId: 0}
-		// 如果获取用户信息出错，则返回未授权的JSON响应并记录错误消息
-		if err != nil {
-			httpx.OkJsonCtx(r.Context(), w, &basic.Response{
-				Code:    401,
-				Message: "unauthorized",
-			})
-			logx.Info("unauthorized:", err.Error())
-			return
 		}
 
 		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,9 +16,29 @@ 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,            // 返回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,
@@ -27,23 +47,14 @@ func GetSizeByProductHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 				logx.Info("unauthorized:", err.Error())
 				return
 			}
-
+		} else {
-		// 从Token里获取对应的信息
+			// 如果claims为nil,则认为用户身份为白板用户
-		userinfo, err := auth.GetUserInfoFormMapClaims(claims)
+			userinfo = &auth.UserInfo{UserId: 0, GuestId: 0}
-		// 如果获取用户信息出错，则返回未授权的JSON响应并记录错误消息
-		if err != nil {
-			httpx.OkJsonCtx(r.Context(), w, &basic.Response{
-				Code:    401,
-				Message: "unauthorized",
-			})
-			logx.Info("unauthorized:", err.Error())
-			return
 		}
 
 		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,9 +17,29 @@ 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,            // 返回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,
@@ -28,17 +48,9 @@ func GetSuccessRecommandHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 				logx.Info("unauthorized:", err.Error())
 				return
 			}
-
+		} else {
-		// 从Token里获取对应的信息
+			// 如果claims为nil,则认为用户身份为白板用户
-		userinfo, err := auth.GetUserInfoFormMapClaims(claims)
+			userinfo = &auth.UserInfo{UserId: 0, GuestId: 0}
-		// 如果获取用户信息出错，则返回未授权的JSON响应并记录错误消息
-		if err != nil {
-			httpx.OkJsonCtx(r.Context(), w, &basic.Response{
-				Code:    401,
-				Message: "unauthorized",
-			})
-			logx.Info("unauthorized:", err.Error())
-			return
 		}
 
 		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,9 +17,29 @@ 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,            // 返回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,
@@ -28,17 +48,9 @@ func CartAddHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 				logx.Info("unauthorized:", err.Error())
 				return
 			}
-
+		} else {
-		// 从Token里获取对应的信息
+			// 如果claims为nil,则认为用户身份为白板用户
-		userinfo, err := auth.GetUserInfoFormMapClaims(claims)
+			userinfo = &auth.UserInfo{UserId: 0, GuestId: 0}
-		// 如果获取用户信息出错，则返回未授权的JSON响应并记录错误消息
-		if err != nil {
-			httpx.OkJsonCtx(r.Context(), w, &basic.Response{
-				Code:    401,
-				Message: "unauthorized",
-			})
-			logx.Info("unauthorized:", err.Error())
-			return
 		}
 
 		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,9 +17,29 @@ 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,            // 返回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,
@@ -28,17 +48,9 @@ func CartDeleteHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 				logx.Info("unauthorized:", err.Error())
 				return
 			}
-
+		} else {
-		// 从Token里获取对应的信息
+			// 如果claims为nil,则认为用户身份为白板用户
-		userinfo, err := auth.GetUserInfoFormMapClaims(claims)
+			userinfo = &auth.UserInfo{UserId: 0, GuestId: 0}
-		// 如果获取用户信息出错，则返回未授权的JSON响应并记录错误消息
-		if err != nil {
-			httpx.OkJsonCtx(r.Context(), w, &basic.Response{
-				Code:    401,
-				Message: "unauthorized",
-			})
-			logx.Info("unauthorized:", err.Error())
-			return
 		}
 
 		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,9 +17,29 @@ 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,            // 返回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,
@@ -28,17 +48,9 @@ func CartListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 				logx.Info("unauthorized:", err.Error())
 				return
 			}
-
+		} else {
-		// 从Token里获取对应的信息
+			// 如果claims为nil,则认为用户身份为白板用户
-		userinfo, err := auth.GetUserInfoFormMapClaims(claims)
+			userinfo = &auth.UserInfo{UserId: 0, GuestId: 0}
-		// 如果获取用户信息出错，则返回未授权的JSON响应并记录错误消息
-		if err != nil {
-			httpx.OkJsonCtx(r.Context(), w, &basic.Response{
-				Code:    401,
-				Message: "unauthorized",
-			})
-			logx.Info("unauthorized:", err.Error())
-			return
 		}
 
 		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,9 +16,29 @@ 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,            // 返回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,
@@ -27,23 +47,14 @@ func CartNumberHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 				logx.Info("unauthorized:", err.Error())
 				return
 			}
-
+		} else {
-		// 从Token里获取对应的信息
+			// 如果claims为nil,则认为用户身份为白板用户
-		userinfo, err := auth.GetUserInfoFormMapClaims(claims)
+			userinfo = &auth.UserInfo{UserId: 0, GuestId: 0}
-		// 如果获取用户信息出错，则返回未授权的JSON响应并记录错误消息
-		if err != nil {
-			httpx.OkJsonCtx(r.Context(), w, &basic.Response{
-				Code:    401,
-				Message: "unauthorized",
-			})
-			logx.Info("unauthorized:", err.Error())
-			return
 		}
 
 		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,9 +17,29 @@ 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,            // 返回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,
@@ -28,17 +48,9 @@ func CartOrderDetailHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 				logx.Info("unauthorized:", err.Error())
 				return
 			}
-
+		} else {
-		// 从Token里获取对应的信息
+			// 如果claims为nil,则认为用户身份为白板用户
-		userinfo, err := auth.GetUserInfoFormMapClaims(claims)
+			userinfo = &auth.UserInfo{UserId: 0, GuestId: 0}
-		// 如果获取用户信息出错，则返回未授权的JSON响应并记录错误消息
-		if err != nil {
-			httpx.OkJsonCtx(r.Context(), w, &basic.Response{
-				Code:    401,
-				Message: "unauthorized",
-			})
-			logx.Info("unauthorized:", err.Error())
-			return
 		}
 
 		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,9 +17,29 @@ 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,            // 返回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,
@@ -28,17 +48,9 @@ func ChangeOrderMethodHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 				logx.Info("unauthorized:", err.Error())
 				return
 			}
-
+		} else {
-		// 从Token里获取对应的信息
+			// 如果claims为nil,则认为用户身份为白板用户
-		userinfo, err := auth.GetUserInfoFormMapClaims(claims)
+			userinfo = &auth.UserInfo{UserId: 0, GuestId: 0}
-		// 如果获取用户信息出错，则返回未授权的JSON响应并记录错误消息
-		if err != nil {
-			httpx.OkJsonCtx(r.Context(), w, &basic.Response{
-				Code:    401,
-				Message: "unauthorized",
-			})
-			logx.Info("unauthorized:", err.Error())
-			return
 		}
 
 		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")

server_api/orders.api

@@ -1,23 +1,24 @@
 syntax = "v1"
 
 info (
-	title: // TODO: add title
+	title: "订单服务"// TODO: add title
 	desc: // TODO: add description
 	author: ""
 	email: ""
 )
-
+import "basic.api"
-type request {
+service orders {
-	// TODO: add members here and delete this comment
+	//获取订单发票
-	Name string `path:"name,options=you|me"` // parameters are auto validated
+	@handler GetOrderInvoiceHandler
+	get /order/invoice (GetOrderInvoiceReq) returns (response);
 }
 
-type response {
+//获取订单发票
-	// TODO: add members here and delete this comment
+type GetOrderInvoiceReq {
-	Message string `json:"message"`
+	Sn       string `json:"sn"`
+	TimeZone string `json:"timeZone"`
 }
-
+type GetOrderInvoiceRsp {
-service user-auth {
+	FileName string `json:"file_name"`
-	@handler GreetHandler
+	Pdf      int64  `json:"pdf"`
-	get /greet/from/:name(request) returns (response);
 }

server_api/shopping-cart-confirmation.api

@@ -26,9 +26,6 @@ service shopping-cart-confirmation {
 	//变更发货方式和地址
 	@handler ChangeOrderMethodHandler
 	post /cart/chang-order-method (ChangeOrderMethodReq) returns (response);
-	//创建订单
-	@handler CartCreateOrderHandler
-	post /cart/create-order (CartCreateOrderReq) returns (response);
 }
 
 //添加入购物车
@@ -124,8 +121,3 @@ type ChangeOrderMethodReq {
 	AddressId      int64  `json:"address_id"`
 	PayMethod      int64  `json:"pay_method"`
 }
-
-//创建订单
-type CartCreateOrderReq{
-
-}

utils/basic/basic.go

@@ -13,9 +13,6 @@ var (
 	CodeServiceErr = &StatusResponse{510, "server logic error"} // server logic 错误
 	CodeUnAuth     = &StatusResponse{401, "unauthorized"}       // 未授权
 
-	CodeUpdateErr        = &StatusResponse{5000, "update database error"} // update database logic 错误
-	CodeRequestParamsErr = &StatusResponse{5002, "invalid request param"} // api参数校验 错误
-
 	CodeEmailNotFoundErr  = &StatusResponse{5050, "the email was not found"} // email 不存在
 	CodeUserIdNotFoundErr = &StatusResponse{5051, "the user was not found"}  // email 不存在
 	CodePasswordErr       = &StatusResponse{5052, "invalid password"}        // 密码错误
@@ -23,6 +20,10 @@ var (
 	CodeGuestDupErr = &StatusResponse{5010, "the user is already a guest user and does not need to apply again"} // 用户已经是guest用户不需要重复申请 错误
 	CodeGuestGenErr = &StatusResponse{5011, "serialization failed for guest_id of the visitor"}                  // 游客guest_id序列化失败
 
+	CodeUpdateErr           = &StatusResponse{5000, "update database error"}                                             // update database logic 错误
+	CodeDupGuestErr         = &StatusResponse{5001, "the user is already a guest user and does not need to apply again"} // 用户已经是guest用户不需要重复申请 错误
+	CodeRequestParamsErr    = &StatusResponse{5002, "invalid request param"}                                             // api参数校验 错误
+	CodeDbRecordNotFoundErr = &StatusResponse{5003, "db record not found"}
 )
 
 type Response struct {

utils/pdf/html_to_pdf.go

@@ -0,0 +1,36 @@
+package pdf
+
+import (
+	"encoding/base64"
+	"github.com/SebastiaanKlippert/go-wkhtmltopdf"
+	"strings"
+)
+
+// html转 Pdf dataType = 1 为网页url dataType = 2为网页内容 outFile为空则不保存
+func HtmlToPdfBase64(content string, dataType int, outFile ...string) (string, error) {
+	pdfg, err := wkhtmltopdf.NewPDFGenerator()
+	if err != nil {
+		return "", err
+	}
+	switch dataType {
+	case 1: //网页地址
+		pdfg.AddPage(wkhtmltopdf.NewPage(content))
+	case 2: //网页内容
+		pdfg.AddPage(wkhtmltopdf.NewPageReader(strings.NewReader(content)))
+	}
+	//模式
+	pdfg.Orientation.Set(wkhtmltopdf.OrientationPortrait)
+	//pdf尺寸默认A4纸
+	pdfg.PageSize.Set(wkhtmltopdf.PageSizeA4)
+	// Create PDF document in memory
+	if err = pdfg.Create(); err != nil {
+		return "", err
+	}
+	// Write PDF to file
+	if len(outFile) != 0 {
+		if err = pdfg.WriteFile(outFile[0]); err != nil {
+			return "", err
+		}
+	}
+	return base64.StdEncoding.EncodeToString(pdfg.Bytes()), nil
+}