From 373d5dca456ef1215242245042eb30a034c89459 Mon Sep 17 00:00:00 2001
From: eson <9673575+githubcontent@user.noreply.gitee.com>
Date: Fri, 21 Jul 2023 14:20:21 +0800
Subject: [PATCH] =?UTF-8?q?=E5=A4=84=E7=90=86=20=E6=9C=89=E9=97=AE?=
=?UTF-8?q?=E9=A2=98=E7=9A=84handler?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
.../internal/handler/redirecthandler.go | 2 +-
.../assistant/internal/logic/redirectlogic.go | 26 ++++----
server/assistant/internal/types/types.go | 4 ++
.../handler/backenduserloginhandler.go | 9 ---
.../handler/quotationdetailhandler.go | 20 +-----
.../handler/getcanteendetailhandler.go | 61 +------------------
.../handler/savecanteentypeproducthandler.go | 61 +------------------
.../handler/getqrcodesetlisthandler.go | 51 +---------------
.../handler/getstandardlogolisthandler.go | 51 +---------------
.../internal/handler/acceptcookiehandler.go | 61 +------------------
.../internal/handler/useraddaddresshandler.go | 61 +------------------
.../handler/useraddresslisthandler.go | 61 +------------------
.../internal/handler/userbasicinfohandler.go | 61 +------------------
.../handler/usercontactservicehandler.go | 61 +------------------
.../internal/handler/userfontshandler.go | 61 +------------------
.../internal/handler/usergettypehandler.go | 61 +------------------
.../handler/usergoogleloginhandler.go | 2 +-
.../internal/handler/userloginhandler.go | 10 +--
.../handler/useroauth2loginhandler.go | 61 +------------------
.../internal/handler/useroderdeletehandler.go | 61 +------------------
.../handler/userordercancelhandler.go | 61 +------------------
.../internal/handler/userorderlisthandler.go | 60 +-----------------
.../handler/usersavebasicinfohandler.go | 61 +------------------
.../handler/userstatusconfighandler.go | 61 +------------------
.../internal/logic/usergoogleloginlogic.go | 32 ++++++++--
.../internal/handler/getcloudlisthandler.go | 61 +------------------
.../internal/handler/getpickuplisthandler.go | 61 +------------------
.../internal/handler/supplementhandler.go | 61 +------------------
.../inventory/internal/handler/takehandler.go | 61 +------------------
.../handler/getmaplibrarylisthandler.go | 51 +---------------
.../internal/handler/savemaplibraryhandler.go | 50 +--------------
.../internal/handler/getorderdetailhandler.go | 61 +------------------
.../handler/getorderinvoicehandler.go | 61 +------------------
.../internal/handler/getmodeldetailhandler.go | 20 +-----
.../handler/getmodelotherinfohandler.go | 20 +-----
.../handler/updateproductmodelhandler.go | 20 +-----
.../internal/handler/addbasemaphandler.go | 20 +-----
.../internal/handler/getbasemaplisthandler.go | 10 +--
.../handler/gettemplatevdetailhandler.go | 20 +-----
.../internal/handler/savebasemaphandler.go | 10 +--
.../internal/handler/updatetemplatehandler.go | 20 +-----
.../internal/handler/designgatherhandler.go | 61 +------------------
.../handler/getfittingbypidhandler.go | 61 +------------------
.../handler/getlastproductdesignhandler.go | 61 +------------------
.../internal/handler/getlightbypidhandler.go | 61 +------------------
.../internal/handler/getmodelbypidhandler.go | 61 +------------------
.../internal/handler/getpricebypidhandler.go | 61 +------------------
.../handler/getproductdesignhandler.go | 61 +------------------
.../internal/handler/getproductinfohandler.go | 61 +------------------
.../internal/handler/getproductlisthandler.go | 61 +------------------
.../handler/getrecommandproductlisthandler.go | 61 +------------------
.../handler/getrenderdesignhandler.go | 61 +------------------
.../handler/getrendersettingbypidhandler.go | 61 +------------------
.../internal/handler/getsizebypidhandler.go | 61 +------------------
.../handler/getsizebyproducthandler.go | 51 +---------------
.../handler/getsuccessrecommandhandler.go | 61 +------------------
.../handler/gettagproductlisthandler.go | 61 +------------------
.../handler/gettemplatebypidhandler.go | 61 +------------------
.../homepagerecommendproductlisthandler.go | 59 +-----------------
.../handler/otherproductlisthandler.go | 61 +------------------
.../internal/handler/savedesignhandler.go | 61 +------------------
.../internal/handler/cartaddhandler.go | 61 +------------------
.../internal/handler/cartdeletehandler.go | 61 +------------------
.../internal/handler/cartlisthandler.go | 61 +------------------
.../internal/handler/cartnumberhandler.go | 51 +---------------
.../handler/cartorderdetailhandler.go | 61 +------------------
.../handler/changeordermethodhandler.go | 61 +------------------
.../internal/handler/createorderhandler.go | 61 +------------------
.../handler/uploadfilebackendhandler.go | 56 +----------------
.../handler/uploadfilefrontendhandler.go | 61 +------------------
.../internal/handler/uploadqrcodehandler.go | 61 +------------------
.../internal/handler/uploadupfilehandler.go | 61 +------------------
.../internal/handler/websetsettinghandler.go | 61 +------------------
server_api/assistant.api | 6 +-
74 files changed, 174 insertions(+), 3485 deletions(-)
diff --git a/server/assistant/internal/handler/redirecthandler.go b/server/assistant/internal/handler/redirecthandler.go
index b10d7260..c309c6d9 100644
--- a/server/assistant/internal/handler/redirecthandler.go
+++ b/server/assistant/internal/handler/redirecthandler.go
@@ -14,7 +14,7 @@ import (
func RedirectHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
- var req types.Request
+ var req types.RequestRedirect
userinfo, err := basic.RequestParse(w, r, svcCtx, &req)
if err != nil {
return
diff --git a/server/assistant/internal/logic/redirectlogic.go b/server/assistant/internal/logic/redirectlogic.go
index a054a32d..e913a752 100644
--- a/server/assistant/internal/logic/redirectlogic.go
+++ b/server/assistant/internal/logic/redirectlogic.go
@@ -4,6 +4,7 @@ import (
"fmt"
"fusenapi/utils/auth"
"fusenapi/utils/basic"
+ "log"
"net/http"
"context"
@@ -18,6 +19,8 @@ type RedirectLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
+
+ RedirectUrl string
}
func NewRedirectLogic(ctx context.Context, svcCtx *svc.ServiceContext) *RedirectLogic {
@@ -33,35 +36,32 @@ func NewRedirectLogic(ctx context.Context, svcCtx *svc.ServiceContext) *Redirect
// }
// 处理逻辑后 w,r 如:重定向
-func (l *RedirectLogic) AfterLogic(w http.ResponseWriter, r *http.Request, resp *basic.Response) {
- html := `
+func (l *RedirectLogic) AfterLogic(w http.ResponseWriter, r *http.Request) {
+ if l.RedirectUrl != "" {
+ html := fmt.Sprintf(`
Redirect
- `
+ `, l.RedirectUrl)
+ fmt.Fprintln(w, html)
+ }
- fmt.Fprintln(w, html)
}
-func (l *RedirectLogic) Redirect(req *types.Request, userinfo *auth.UserInfo) (resp *basic.Response) {
+func (l *RedirectLogic) Redirect(req *types.RequestRedirect, userinfo *auth.UserInfo) (resp *basic.Response) {
// 返回值必须调用Set重新返回, resp可以空指针调用 resp.SetStatus(basic.CodeOK, data)
// userinfo 传入值时, 一定不为null
-
+ l.RedirectUrl = req.Url
+ log.Println(req.Url)
return resp.SetStatus(basic.CodeOK)
}
diff --git a/server/assistant/internal/types/types.go b/server/assistant/internal/types/types.go
index 70ec268a..f84b7394 100644
--- a/server/assistant/internal/types/types.go
+++ b/server/assistant/internal/types/types.go
@@ -5,6 +5,10 @@ import (
"fusenapi/utils/basic"
)
+type RequestRedirect struct {
+ Url string `query:"url"`
+}
+
type Request struct {
}
diff --git a/server/backend/internal/handler/backenduserloginhandler.go b/server/backend/internal/handler/backenduserloginhandler.go
index f09d1424..640f36b6 100644
--- a/server/backend/internal/handler/backenduserloginhandler.go
+++ b/server/backend/internal/handler/backenduserloginhandler.go
@@ -20,15 +20,6 @@ func BackendUserLoginHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
var req types.RequestUserLogin
- // 如果端点有请求结构体，则使用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.NewBackendUserLoginLogic(r.Context(), svcCtx)
resp, token := l.BackendUserLogin(&req)
diff --git a/server/backend/internal/handler/quotationdetailhandler.go b/server/backend/internal/handler/quotationdetailhandler.go
index 59640c7b..d84e0cda 100644
--- a/server/backend/internal/handler/quotationdetailhandler.go
+++ b/server/backend/internal/handler/quotationdetailhandler.go
@@ -1,7 +1,6 @@
package handler
import (
- "errors"
"net/http"
"github.com/zeromicro/go-zero/core/logx"
@@ -49,25 +48,10 @@ func QuotationDetailHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
}
var req types.RequestQuotationId
- // 如果端点有请求结构体，则使用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.NewQuotationDetailLogic(r.Context(), svcCtx)
resp := l.QuotationDetail(&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)
- }
+
}
}
diff --git a/server/canteen/internal/handler/getcanteendetailhandler.go b/server/canteen/internal/handler/getcanteendetailhandler.go
index 97b4889c..d8834f08 100644
--- a/server/canteen/internal/handler/getcanteendetailhandler.go
+++ b/server/canteen/internal/handler/getcanteendetailhandler.go
@@ -1,15 +1,8 @@
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/canteen/internal/logic"
"fusenapi/server/canteen/internal/svc"
"fusenapi/server/canteen/internal/types"
@@ -18,61 +11,11 @@ import (
func GetCanteenDetailHandler(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.GetCanteenDetailReq
- // 如果端点有请求结构体，则使用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.NewGetCanteenDetailLogic(r.Context(), svcCtx)
resp := l.GetCanteenDetail(&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)
- }
+
}
}
diff --git a/server/canteen/internal/handler/savecanteentypeproducthandler.go b/server/canteen/internal/handler/savecanteentypeproducthandler.go
index 770c77b1..47daa9d6 100644
--- a/server/canteen/internal/handler/savecanteentypeproducthandler.go
+++ b/server/canteen/internal/handler/savecanteentypeproducthandler.go
@@ -1,15 +1,8 @@
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/canteen/internal/logic"
"fusenapi/server/canteen/internal/svc"
"fusenapi/server/canteen/internal/types"
@@ -18,61 +11,11 @@ import (
func SaveCanteenTypeProductHandler(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.SaveCanteenTypeProductReq
- // 如果端点有请求结构体，则使用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.NewSaveCanteenTypeProductLogic(r.Context(), svcCtx)
resp := l.SaveCanteenTypeProduct(&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)
- }
+
}
}
diff --git a/server/data-transfer/internal/handler/getqrcodesetlisthandler.go b/server/data-transfer/internal/handler/getqrcodesetlisthandler.go
index 8b6d101b..9c665dc4 100644
--- a/server/data-transfer/internal/handler/getqrcodesetlisthandler.go
+++ b/server/data-transfer/internal/handler/getqrcodesetlisthandler.go
@@ -1,15 +1,8 @@
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/data-transfer/internal/logic"
"fusenapi/server/data-transfer/internal/svc"
)
@@ -17,50 +10,8 @@ import (
func GetQrCodeSetListHandler(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.NewGetQrCodeSetListLogic(r.Context(), svcCtx)
resp := l.GetQrCodeSetList(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)
- }
+
}
}
diff --git a/server/data-transfer/internal/handler/getstandardlogolisthandler.go b/server/data-transfer/internal/handler/getstandardlogolisthandler.go
index ae5e1316..008deb56 100644
--- a/server/data-transfer/internal/handler/getstandardlogolisthandler.go
+++ b/server/data-transfer/internal/handler/getstandardlogolisthandler.go
@@ -1,15 +1,8 @@
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/data-transfer/internal/logic"
"fusenapi/server/data-transfer/internal/svc"
)
@@ -17,50 +10,8 @@ import (
func GetStandardLogoListHandler(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.NewGetStandardLogoListLogic(r.Context(), svcCtx)
resp := l.GetStandardLogoList(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)
- }
+
}
}
diff --git a/server/home-user-auth/internal/handler/acceptcookiehandler.go b/server/home-user-auth/internal/handler/acceptcookiehandler.go
index c4b168eb..99755317 100644
--- a/server/home-user-auth/internal/handler/acceptcookiehandler.go
+++ b/server/home-user-auth/internal/handler/acceptcookiehandler.go
@@ -1,15 +1,8 @@
package handler
import (
- "errors"
"net/http"
- "github.com/zeromicro/go-zero/core/logx"
- "github.com/zeromicro/go-zero/rest/httpx"
-
- "fusenapi/utils/auth"
- "fusenapi/utils/basic"
-
"fusenapi/server/home-user-auth/internal/logic"
"fusenapi/server/home-user-auth/internal/svc"
"fusenapi/server/home-user-auth/internal/types"
@@ -18,61 +11,11 @@ import (
func AcceptCookieHandler(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.Request
- // 如果端点有请求结构体，则使用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.NewAcceptCookieLogic(r.Context(), svcCtx)
resp := l.AcceptCookie(&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)
- }
+
}
}
diff --git a/server/home-user-auth/internal/handler/useraddaddresshandler.go b/server/home-user-auth/internal/handler/useraddaddresshandler.go
index dbd94a52..70decaba 100644
--- a/server/home-user-auth/internal/handler/useraddaddresshandler.go
+++ b/server/home-user-auth/internal/handler/useraddaddresshandler.go
@@ -1,15 +1,8 @@
package handler
import (
- "errors"
"net/http"
- "github.com/zeromicro/go-zero/core/logx"
- "github.com/zeromicro/go-zero/rest/httpx"
-
- "fusenapi/utils/auth"
- "fusenapi/utils/basic"
-
"fusenapi/server/home-user-auth/internal/logic"
"fusenapi/server/home-user-auth/internal/svc"
"fusenapi/server/home-user-auth/internal/types"
@@ -18,61 +11,11 @@ import (
func UserAddAddressHandler(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.RequestAddAddress
- // 如果端点有请求结构体，则使用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.NewUserAddAddressLogic(r.Context(), svcCtx)
resp := l.UserAddAddress(&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)
- }
+
}
}
diff --git a/server/home-user-auth/internal/handler/useraddresslisthandler.go b/server/home-user-auth/internal/handler/useraddresslisthandler.go
index 271c3e24..93d1e571 100644
--- a/server/home-user-auth/internal/handler/useraddresslisthandler.go
+++ b/server/home-user-auth/internal/handler/useraddresslisthandler.go
@@ -1,15 +1,8 @@
package handler
import (
- "errors"
"net/http"
- "github.com/zeromicro/go-zero/core/logx"
- "github.com/zeromicro/go-zero/rest/httpx"
-
- "fusenapi/utils/auth"
- "fusenapi/utils/basic"
-
"fusenapi/server/home-user-auth/internal/logic"
"fusenapi/server/home-user-auth/internal/svc"
"fusenapi/server/home-user-auth/internal/types"
@@ -18,61 +11,11 @@ import (
func UserAddressListHandler(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.Request
- // 如果端点有请求结构体，则使用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.NewUserAddressListLogic(r.Context(), svcCtx)
resp := l.UserAddressList(&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)
- }
+
}
}
diff --git a/server/home-user-auth/internal/handler/userbasicinfohandler.go b/server/home-user-auth/internal/handler/userbasicinfohandler.go
index b6aa5894..d9452400 100644
--- a/server/home-user-auth/internal/handler/userbasicinfohandler.go
+++ b/server/home-user-auth/internal/handler/userbasicinfohandler.go
@@ -1,15 +1,8 @@
package handler
import (
- "errors"
"net/http"
- "github.com/zeromicro/go-zero/core/logx"
- "github.com/zeromicro/go-zero/rest/httpx"
-
- "fusenapi/utils/auth"
- "fusenapi/utils/basic"
-
"fusenapi/server/home-user-auth/internal/logic"
"fusenapi/server/home-user-auth/internal/svc"
"fusenapi/server/home-user-auth/internal/types"
@@ -18,61 +11,11 @@ import (
func UserBasicInfoHandler(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.Request
- // 如果端点有请求结构体，则使用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.NewUserBasicInfoLogic(r.Context(), svcCtx)
resp := l.UserBasicInfo(&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)
- }
+
}
}
diff --git a/server/home-user-auth/internal/handler/usercontactservicehandler.go b/server/home-user-auth/internal/handler/usercontactservicehandler.go
index c6dd536c..a5570456 100644
--- a/server/home-user-auth/internal/handler/usercontactservicehandler.go
+++ b/server/home-user-auth/internal/handler/usercontactservicehandler.go
@@ -1,15 +1,8 @@
package handler
import (
- "errors"
"net/http"
- "github.com/zeromicro/go-zero/core/logx"
- "github.com/zeromicro/go-zero/rest/httpx"
-
- "fusenapi/utils/auth"
- "fusenapi/utils/basic"
-
"fusenapi/server/home-user-auth/internal/logic"
"fusenapi/server/home-user-auth/internal/svc"
"fusenapi/server/home-user-auth/internal/types"
@@ -18,61 +11,11 @@ import (
func UserContactServiceHandler(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.RequestContactService
- // 如果端点有请求结构体，则使用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.NewUserContactServiceLogic(r.Context(), svcCtx)
resp := l.UserContactService(&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)
- }
+
}
}
diff --git a/server/home-user-auth/internal/handler/userfontshandler.go b/server/home-user-auth/internal/handler/userfontshandler.go
index e534f790..afdc8f94 100644
--- a/server/home-user-auth/internal/handler/userfontshandler.go
+++ b/server/home-user-auth/internal/handler/userfontshandler.go
@@ -1,15 +1,8 @@
package handler
import (
- "errors"
"net/http"
- "github.com/zeromicro/go-zero/core/logx"
- "github.com/zeromicro/go-zero/rest/httpx"
-
- "fusenapi/utils/auth"
- "fusenapi/utils/basic"
-
"fusenapi/server/home-user-auth/internal/logic"
"fusenapi/server/home-user-auth/internal/svc"
"fusenapi/server/home-user-auth/internal/types"
@@ -18,61 +11,11 @@ import (
func UserFontsHandler(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.Request
- // 如果端点有请求结构体，则使用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.NewUserFontsLogic(r.Context(), svcCtx)
resp := l.UserFonts(&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)
- }
+
}
}
diff --git a/server/home-user-auth/internal/handler/usergettypehandler.go b/server/home-user-auth/internal/handler/usergettypehandler.go
index ccd49a20..5d842075 100644
--- a/server/home-user-auth/internal/handler/usergettypehandler.go
+++ b/server/home-user-auth/internal/handler/usergettypehandler.go
@@ -1,15 +1,8 @@
package handler
import (
- "errors"
"net/http"
- "github.com/zeromicro/go-zero/core/logx"
- "github.com/zeromicro/go-zero/rest/httpx"
-
- "fusenapi/utils/auth"
- "fusenapi/utils/basic"
-
"fusenapi/server/home-user-auth/internal/logic"
"fusenapi/server/home-user-auth/internal/svc"
"fusenapi/server/home-user-auth/internal/types"
@@ -18,61 +11,11 @@ import (
func UserGetTypeHandler(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.Request
- // 如果端点有请求结构体，则使用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.NewUserGetTypeLogic(r.Context(), svcCtx)
resp := l.UserGetType(&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)
- }
+
}
}
diff --git a/server/home-user-auth/internal/handler/usergoogleloginhandler.go b/server/home-user-auth/internal/handler/usergoogleloginhandler.go
index 33c0e06d..07e3c998 100644
--- a/server/home-user-auth/internal/handler/usergoogleloginhandler.go
+++ b/server/home-user-auth/internal/handler/usergoogleloginhandler.go
@@ -28,7 +28,7 @@ func UserGoogleLoginHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
resp := l.UserGoogleLogin(&req, userinfo)
- if !basic.AfterLogic(w, r, resp, rl) {
+ if !basic.AfterLogic(w, r, rl) {
basic.NormalAfterLogic(w, r, resp)
}
}
diff --git a/server/home-user-auth/internal/handler/userloginhandler.go b/server/home-user-auth/internal/handler/userloginhandler.go
index 919f92d7..020e407e 100644
--- a/server/home-user-auth/internal/handler/userloginhandler.go
+++ b/server/home-user-auth/internal/handler/userloginhandler.go
@@ -19,15 +19,7 @@ func UserLoginHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.RequestUserLogin
- // 如果端点有请求结构体，则使用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.NewUserLoginLogic(r.Context(), svcCtx)
resp, token := l.UserLogin(&req)
diff --git a/server/home-user-auth/internal/handler/useroauth2loginhandler.go b/server/home-user-auth/internal/handler/useroauth2loginhandler.go
index 8ad6f5f7..c3038951 100644
--- a/server/home-user-auth/internal/handler/useroauth2loginhandler.go
+++ b/server/home-user-auth/internal/handler/useroauth2loginhandler.go
@@ -1,15 +1,8 @@
package handler
import (
- "errors"
"net/http"
- "github.com/zeromicro/go-zero/core/logx"
- "github.com/zeromicro/go-zero/rest/httpx"
-
- "fusenapi/utils/auth"
- "fusenapi/utils/basic"
-
"fusenapi/server/home-user-auth/internal/logic"
"fusenapi/server/home-user-auth/internal/svc"
"fusenapi/server/home-user-auth/internal/types"
@@ -18,61 +11,11 @@ import (
func UserOAuth2LoginHandler(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.RequestOAuth
- // 如果端点有请求结构体，则使用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.NewUserOAuth2LoginLogic(r.Context(), svcCtx)
resp := l.UserOAuth2Login(&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)
- }
+
}
}
diff --git a/server/home-user-auth/internal/handler/useroderdeletehandler.go b/server/home-user-auth/internal/handler/useroderdeletehandler.go
index ba21c5f5..c98ce43b 100644
--- a/server/home-user-auth/internal/handler/useroderdeletehandler.go
+++ b/server/home-user-auth/internal/handler/useroderdeletehandler.go
@@ -1,15 +1,8 @@
package handler
import (
- "errors"
"net/http"
- "github.com/zeromicro/go-zero/core/logx"
- "github.com/zeromicro/go-zero/rest/httpx"
-
- "fusenapi/utils/auth"
- "fusenapi/utils/basic"
-
"fusenapi/server/home-user-auth/internal/logic"
"fusenapi/server/home-user-auth/internal/svc"
"fusenapi/server/home-user-auth/internal/types"
@@ -18,61 +11,11 @@ import (
func UserOderDeleteHandler(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.RequestOrderId
- // 如果端点有请求结构体，则使用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.NewUserOderDeleteLogic(r.Context(), svcCtx)
resp := l.UserOderDelete(&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)
- }
+
}
}
diff --git a/server/home-user-auth/internal/handler/userordercancelhandler.go b/server/home-user-auth/internal/handler/userordercancelhandler.go
index 04425eae..e1c2b563 100644
--- a/server/home-user-auth/internal/handler/userordercancelhandler.go
+++ b/server/home-user-auth/internal/handler/userordercancelhandler.go
@@ -1,15 +1,8 @@
package handler
import (
- "errors"
"net/http"
- "github.com/zeromicro/go-zero/core/logx"
- "github.com/zeromicro/go-zero/rest/httpx"
-
- "fusenapi/utils/auth"
- "fusenapi/utils/basic"
-
"fusenapi/server/home-user-auth/internal/logic"
"fusenapi/server/home-user-auth/internal/svc"
"fusenapi/server/home-user-auth/internal/types"
@@ -18,61 +11,11 @@ import (
func UserOrderCancelHandler(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.UserOrderCancelReq
- // 如果端点有请求结构体，则使用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.NewUserOrderCancelLogic(r.Context(), svcCtx)
resp := l.UserOrderCancel(&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)
- }
+
}
}
diff --git a/server/home-user-auth/internal/handler/userorderlisthandler.go b/server/home-user-auth/internal/handler/userorderlisthandler.go
index fc74c3f9..1fd6d4e5 100644
--- a/server/home-user-auth/internal/handler/userorderlisthandler.go
+++ b/server/home-user-auth/internal/handler/userorderlisthandler.go
@@ -1,77 +1,21 @@
package handler
import (
- "errors"
"net/http"
- "fusenapi/utils/auth"
- "fusenapi/utils/basic"
-
"fusenapi/server/home-user-auth/internal/logic"
"fusenapi/server/home-user-auth/internal/svc"
"fusenapi/server/home-user-auth/internal/types"
-
- "github.com/zeromicro/go-zero/core/logx"
- "github.com/zeromicro/go-zero/rest/httpx"
)
func UserOrderListHandler(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.UserOrderListReq
- // 如果端点有请求结构体，则使用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.NewUserOrderListLogic(r.Context(), svcCtx)
resp := l.UserOrderList(&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)
- }
+
}
}
diff --git a/server/home-user-auth/internal/handler/usersavebasicinfohandler.go b/server/home-user-auth/internal/handler/usersavebasicinfohandler.go
index 5e48dd1d..90cebbf8 100644
--- a/server/home-user-auth/internal/handler/usersavebasicinfohandler.go
+++ b/server/home-user-auth/internal/handler/usersavebasicinfohandler.go
@@ -1,15 +1,8 @@
package handler
import (
- "errors"
"net/http"
- "github.com/zeromicro/go-zero/core/logx"
- "github.com/zeromicro/go-zero/rest/httpx"
-
- "fusenapi/utils/auth"
- "fusenapi/utils/basic"
-
"fusenapi/server/home-user-auth/internal/logic"
"fusenapi/server/home-user-auth/internal/svc"
"fusenapi/server/home-user-auth/internal/types"
@@ -18,61 +11,11 @@ import (
func UserSaveBasicInfoHandler(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.RequestBasicInfoForm
- // 如果端点有请求结构体，则使用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.NewUserSaveBasicInfoLogic(r.Context(), svcCtx)
resp := l.UserSaveBasicInfo(&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)
- }
+
}
}
diff --git a/server/home-user-auth/internal/handler/userstatusconfighandler.go b/server/home-user-auth/internal/handler/userstatusconfighandler.go
index bc0d5ee6..4d07e340 100644
--- a/server/home-user-auth/internal/handler/userstatusconfighandler.go
+++ b/server/home-user-auth/internal/handler/userstatusconfighandler.go
@@ -1,15 +1,8 @@
package handler
import (
- "errors"
"net/http"
- "github.com/zeromicro/go-zero/core/logx"
- "github.com/zeromicro/go-zero/rest/httpx"
-
- "fusenapi/utils/auth"
- "fusenapi/utils/basic"
-
"fusenapi/server/home-user-auth/internal/logic"
"fusenapi/server/home-user-auth/internal/svc"
"fusenapi/server/home-user-auth/internal/types"
@@ -18,61 +11,11 @@ import (
func UserStatusConfigHandler(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.Request
- // 如果端点有请求结构体，则使用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.NewUserStatusConfigLogic(r.Context(), svcCtx)
resp := l.UserStatusConfig(&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)
- }
+
}
}
diff --git a/server/home-user-auth/internal/logic/usergoogleloginlogic.go b/server/home-user-auth/internal/logic/usergoogleloginlogic.go
index 9427fcb8..59825e69 100644
--- a/server/home-user-auth/internal/logic/usergoogleloginlogic.go
+++ b/server/home-user-auth/internal/logic/usergoogleloginlogic.go
@@ -1,6 +1,7 @@
package logic
import (
+ "fmt"
"fusenapi/utils/auth"
"fusenapi/utils/basic"
"log"
@@ -37,14 +38,32 @@ func NewUserGoogleLoginLogic(ctx context.Context, svcCtx *svc.ServiceContext) *U
}
}
-func (l *UserGoogleLoginLogic) BeforeLogic(w http.ResponseWriter, r *http.Request) {
- log.Println(r, w)
-}
+// func (l *UserGoogleLoginLogic) BeforeLogic(w http.ResponseWriter, r *http.Request) {
+// log.Println(r, w)
+// }
func (l *UserGoogleLoginLogic) AfterLogic(w http.ResponseWriter, r *http.Request) {
- if l.redirectUrl != "" {
- http.Redirect(w, r, "http://localhost:9900/assistant/redirect?url="+url.QueryEscape(l.redirectUrl), http.StatusFound)
- }
+
+ html := fmt.Sprintf(`
+
+
+
+ Redirect
+
+
+
+
+
+ `, l.redirectUrl)
+ fmt.Fprintln(w, html)
+
+ // if l.redirectUrl != "" {
+ // http.Redirect(w, r, "http://localhost:9900/api/assistant/redirect?url="+url.QueryEscape(l.redirectUrl), http.StatusFound)
+ // }
}
func (l *UserGoogleLoginLogic) UserGoogleLogin(req *types.RequestGoogleLogin, userinfo *auth.UserInfo) (resp *basic.Response) {
@@ -89,6 +108,7 @@ func (l *UserGoogleLoginLogic) UserGoogleLogin(req *types.RequestGoogleLogin, us
log.Println(r.Json())
googleId := r.Json().Get("id").Int()
+ l.redirectUrl = "http://localhost:9900/oauth?token=21321123"
return resp.Set(304, "21321321")
user, err := l.svcCtx.AllModels.FsUser.FindUserByGoogleId(context.TODO(), googleId)
log.Println(user)
diff --git a/server/inventory/internal/handler/getcloudlisthandler.go b/server/inventory/internal/handler/getcloudlisthandler.go
index 5d39c8f0..b8508640 100644
--- a/server/inventory/internal/handler/getcloudlisthandler.go
+++ b/server/inventory/internal/handler/getcloudlisthandler.go
@@ -1,15 +1,8 @@
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/inventory/internal/logic"
"fusenapi/server/inventory/internal/svc"
"fusenapi/server/inventory/internal/types"
@@ -18,61 +11,11 @@ import (
func GetCloudListHandler(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.GetCloudListReq
- // 如果端点有请求结构体，则使用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.NewGetCloudListLogic(r.Context(), svcCtx)
resp := l.GetCloudList(&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)
- }
+
}
}
diff --git a/server/inventory/internal/handler/getpickuplisthandler.go b/server/inventory/internal/handler/getpickuplisthandler.go
index 93caf33a..fe5848f9 100644
--- a/server/inventory/internal/handler/getpickuplisthandler.go
+++ b/server/inventory/internal/handler/getpickuplisthandler.go
@@ -1,15 +1,8 @@
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/inventory/internal/logic"
"fusenapi/server/inventory/internal/svc"
"fusenapi/server/inventory/internal/types"
@@ -18,61 +11,11 @@ import (
func GetPickupListHandler(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.GetPickupListReq
- // 如果端点有请求结构体，则使用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.NewGetPickupListLogic(r.Context(), svcCtx)
resp := l.GetPickupList(&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)
- }
+
}
}
diff --git a/server/inventory/internal/handler/supplementhandler.go b/server/inventory/internal/handler/supplementhandler.go
index a056cdac..c4f21bb4 100644
--- a/server/inventory/internal/handler/supplementhandler.go
+++ b/server/inventory/internal/handler/supplementhandler.go
@@ -1,15 +1,8 @@
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/inventory/internal/logic"
"fusenapi/server/inventory/internal/svc"
"fusenapi/server/inventory/internal/types"
@@ -18,61 +11,11 @@ import (
func SupplementHandler(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.SupplementReq
- // 如果端点有请求结构体，则使用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.NewSupplementLogic(r.Context(), svcCtx)
resp := l.Supplement(&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)
- }
+
}
}
diff --git a/server/inventory/internal/handler/takehandler.go b/server/inventory/internal/handler/takehandler.go
index 2ff8d910..2bb89815 100644
--- a/server/inventory/internal/handler/takehandler.go
+++ b/server/inventory/internal/handler/takehandler.go
@@ -1,15 +1,8 @@
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/inventory/internal/logic"
"fusenapi/server/inventory/internal/svc"
"fusenapi/server/inventory/internal/types"
@@ -18,61 +11,11 @@ import (
func TakeHandler(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.TakeReq
- // 如果端点有请求结构体，则使用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.NewTakeLogic(r.Context(), svcCtx)
resp := l.Take(&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)
- }
+
}
}
diff --git a/server/map-library/internal/handler/getmaplibrarylisthandler.go b/server/map-library/internal/handler/getmaplibrarylisthandler.go
index d717c6da..84b2f2c1 100644
--- a/server/map-library/internal/handler/getmaplibrarylisthandler.go
+++ b/server/map-library/internal/handler/getmaplibrarylisthandler.go
@@ -1,15 +1,8 @@
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"
)
@@ -17,50 +10,8 @@ import (
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)
- }
+
}
}
diff --git a/server/map-library/internal/handler/savemaplibraryhandler.go b/server/map-library/internal/handler/savemaplibraryhandler.go
index 50519097..f09b1fd5 100644
--- a/server/map-library/internal/handler/savemaplibraryhandler.go
+++ b/server/map-library/internal/handler/savemaplibraryhandler.go
@@ -1,15 +1,8 @@
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"
)
@@ -17,50 +10,9 @@ import (
func SaveMapLibraryHandler(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.NewSaveMapLibraryLogic(r.Context(), svcCtx)
resp := l.SaveMapLibrary(userinfo, r)
- // 如果响应不为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)
- }
+
}
}
diff --git a/server/orders/internal/handler/getorderdetailhandler.go b/server/orders/internal/handler/getorderdetailhandler.go
index 1dc6a36f..1223572d 100644
--- a/server/orders/internal/handler/getorderdetailhandler.go
+++ b/server/orders/internal/handler/getorderdetailhandler.go
@@ -1,15 +1,8 @@
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"
@@ -18,61 +11,11 @@ import (
func GetOrderDetailHandler(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.GetOrderDetailReq
- // 如果端点有请求结构体，则使用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.NewGetOrderDetailLogic(r.Context(), svcCtx)
resp := l.GetOrderDetail(&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)
- }
+
}
}
diff --git a/server/orders/internal/handler/getorderinvoicehandler.go b/server/orders/internal/handler/getorderinvoicehandler.go
index 03992ff7..4e74edb3 100644
--- a/server/orders/internal/handler/getorderinvoicehandler.go
+++ b/server/orders/internal/handler/getorderinvoicehandler.go
@@ -1,15 +1,8 @@
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"
@@ -18,61 +11,11 @@ import (
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)
- }
+
}
}
diff --git a/server/product-model/internal/handler/getmodeldetailhandler.go b/server/product-model/internal/handler/getmodeldetailhandler.go
index 57e33649..7d811902 100644
--- a/server/product-model/internal/handler/getmodeldetailhandler.go
+++ b/server/product-model/internal/handler/getmodeldetailhandler.go
@@ -1,7 +1,6 @@
package handler
import (
- "errors"
"net/http"
"github.com/zeromicro/go-zero/core/logx"
@@ -49,25 +48,10 @@ func GetModelDetailHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
}
var req types.GetModelDetailReq
- // 如果端点有请求结构体，则使用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.NewGetModelDetailLogic(r.Context(), svcCtx)
resp := l.GetModelDetail(&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)
- }
+
}
}
diff --git a/server/product-model/internal/handler/getmodelotherinfohandler.go b/server/product-model/internal/handler/getmodelotherinfohandler.go
index e52d6a2f..b963705b 100644
--- a/server/product-model/internal/handler/getmodelotherinfohandler.go
+++ b/server/product-model/internal/handler/getmodelotherinfohandler.go
@@ -1,7 +1,6 @@
package handler
import (
- "errors"
"net/http"
"github.com/zeromicro/go-zero/core/logx"
@@ -49,25 +48,10 @@ func GetModelOtherInfoHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
}
var req types.GetModelOtherInfoReq
- // 如果端点有请求结构体，则使用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.NewGetModelOtherInfoLogic(r.Context(), svcCtx)
resp := l.GetModelOtherInfo(&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)
- }
+
}
}
diff --git a/server/product-model/internal/handler/updateproductmodelhandler.go b/server/product-model/internal/handler/updateproductmodelhandler.go
index 9bbe2298..1f1212cb 100644
--- a/server/product-model/internal/handler/updateproductmodelhandler.go
+++ b/server/product-model/internal/handler/updateproductmodelhandler.go
@@ -1,7 +1,6 @@
package handler
import (
- "errors"
"net/http"
"github.com/zeromicro/go-zero/core/logx"
@@ -49,25 +48,10 @@ func UpdateProductModelHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
}
var req types.UpdateProductModelReq
- // 如果端点有请求结构体，则使用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.NewUpdateProductModelLogic(r.Context(), svcCtx)
resp := l.UpdateProductModel(&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)
- }
+
}
}
diff --git a/server/product-template/internal/handler/addbasemaphandler.go b/server/product-template/internal/handler/addbasemaphandler.go
index a2c9c38e..049e2430 100644
--- a/server/product-template/internal/handler/addbasemaphandler.go
+++ b/server/product-template/internal/handler/addbasemaphandler.go
@@ -1,7 +1,6 @@
package handler
import (
- "errors"
"net/http"
"github.com/zeromicro/go-zero/core/logx"
@@ -49,25 +48,10 @@ func AddBaseMapHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
}
var req types.AddBaseMapReq
- // 如果端点有请求结构体，则使用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.NewAddBaseMapLogic(r.Context(), svcCtx)
resp := l.AddBaseMap(&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)
- }
+
}
}
diff --git a/server/product-template/internal/handler/getbasemaplisthandler.go b/server/product-template/internal/handler/getbasemaplisthandler.go
index 24d9f887..add18713 100644
--- a/server/product-template/internal/handler/getbasemaplisthandler.go
+++ b/server/product-template/internal/handler/getbasemaplisthandler.go
@@ -1,7 +1,6 @@
package handler
import (
- "errors"
"net/http"
"github.com/zeromicro/go-zero/core/logx"
@@ -49,13 +48,6 @@ func GetBaseMapListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
l := logic.NewGetBaseMapListLogic(r.Context(), svcCtx)
resp := l.GetBaseMapList(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)
- }
+
}
}
diff --git a/server/product-template/internal/handler/gettemplatevdetailhandler.go b/server/product-template/internal/handler/gettemplatevdetailhandler.go
index 85fc95f5..7d843a3b 100644
--- a/server/product-template/internal/handler/gettemplatevdetailhandler.go
+++ b/server/product-template/internal/handler/gettemplatevdetailhandler.go
@@ -1,7 +1,6 @@
package handler
import (
- "errors"
"net/http"
"github.com/zeromicro/go-zero/core/logx"
@@ -49,25 +48,10 @@ func GetTemplatevDetailHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
}
var req types.GetTemplatevDetailReq
- // 如果端点有请求结构体，则使用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.NewGetTemplatevDetailLogic(r.Context(), svcCtx)
resp := l.GetTemplatevDetail(&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)
- }
+
}
}
diff --git a/server/product-template/internal/handler/savebasemaphandler.go b/server/product-template/internal/handler/savebasemaphandler.go
index 42e6ce04..77a393d5 100644
--- a/server/product-template/internal/handler/savebasemaphandler.go
+++ b/server/product-template/internal/handler/savebasemaphandler.go
@@ -1,7 +1,6 @@
package handler
import (
- "errors"
"net/http"
"github.com/zeromicro/go-zero/core/logx"
@@ -49,13 +48,6 @@ func SaveBaseMapHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
l := logic.NewSaveBaseMapLogic(r.Context(), svcCtx)
resp := l.SaveBaseMap(r, 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)
- }
+
}
}
diff --git a/server/product-template/internal/handler/updatetemplatehandler.go b/server/product-template/internal/handler/updatetemplatehandler.go
index 98855c20..9bb864da 100644
--- a/server/product-template/internal/handler/updatetemplatehandler.go
+++ b/server/product-template/internal/handler/updatetemplatehandler.go
@@ -1,7 +1,6 @@
package handler
import (
- "errors"
"net/http"
"github.com/zeromicro/go-zero/core/logx"
@@ -49,25 +48,10 @@ func UpdateTemplateHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
}
var req types.UpdateTemplateReq
- // 如果端点有请求结构体，则使用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.NewUpdateTemplateLogic(r.Context(), svcCtx)
resp := l.UpdateTemplate(&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)
- }
+
}
}
diff --git a/server/product/internal/handler/designgatherhandler.go b/server/product/internal/handler/designgatherhandler.go
index ca3b8296..fb24bb32 100644
--- a/server/product/internal/handler/designgatherhandler.go
+++ b/server/product/internal/handler/designgatherhandler.go
@@ -1,15 +1,8 @@
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/product/internal/logic"
"fusenapi/server/product/internal/svc"
"fusenapi/server/product/internal/types"
@@ -18,61 +11,11 @@ import (
func DesignGatherHandler(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.DesignGatherReq
- // 如果端点有请求结构体，则使用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.NewDesignGatherLogic(r.Context(), svcCtx)
resp := l.DesignGather(&req, userinfo, r)
- // 如果响应不为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)
- }
+
}
}
diff --git a/server/product/internal/handler/getfittingbypidhandler.go b/server/product/internal/handler/getfittingbypidhandler.go
index 2c276903..c4b8c169 100644
--- a/server/product/internal/handler/getfittingbypidhandler.go
+++ b/server/product/internal/handler/getfittingbypidhandler.go
@@ -1,15 +1,8 @@
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/product/internal/logic"
"fusenapi/server/product/internal/svc"
"fusenapi/server/product/internal/types"
@@ -18,61 +11,11 @@ import (
func GetFittingByPidHandler(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.GetFittingByPidReq
- // 如果端点有请求结构体，则使用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.NewGetFittingByPidLogic(r.Context(), svcCtx)
resp := l.GetFittingByPid(&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)
- }
+
}
}
diff --git a/server/product/internal/handler/getlastproductdesignhandler.go b/server/product/internal/handler/getlastproductdesignhandler.go
index 22e73dd2..3df924b5 100644
--- a/server/product/internal/handler/getlastproductdesignhandler.go
+++ b/server/product/internal/handler/getlastproductdesignhandler.go
@@ -1,15 +1,8 @@
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/product/internal/logic"
"fusenapi/server/product/internal/svc"
"fusenapi/server/product/internal/types"
@@ -18,61 +11,11 @@ import (
func GetLastProductDesignHandler(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.Request
- // 如果端点有请求结构体，则使用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.NewGetLastProductDesignLogic(r.Context(), svcCtx)
resp := l.GetLastProductDesign(&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)
- }
+
}
}
diff --git a/server/product/internal/handler/getlightbypidhandler.go b/server/product/internal/handler/getlightbypidhandler.go
index e9bfee96..d810afbf 100644
--- a/server/product/internal/handler/getlightbypidhandler.go
+++ b/server/product/internal/handler/getlightbypidhandler.go
@@ -1,15 +1,8 @@
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/product/internal/logic"
"fusenapi/server/product/internal/svc"
"fusenapi/server/product/internal/types"
@@ -18,61 +11,11 @@ import (
func GetLightByPidHandler(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.GetLightByPidReq
- // 如果端点有请求结构体，则使用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.NewGetLightByPidLogic(r.Context(), svcCtx)
resp := l.GetLightByPid(&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)
- }
+
}
}
diff --git a/server/product/internal/handler/getmodelbypidhandler.go b/server/product/internal/handler/getmodelbypidhandler.go
index f944508e..8a01c0ca 100644
--- a/server/product/internal/handler/getmodelbypidhandler.go
+++ b/server/product/internal/handler/getmodelbypidhandler.go
@@ -1,15 +1,8 @@
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/product/internal/logic"
"fusenapi/server/product/internal/svc"
"fusenapi/server/product/internal/types"
@@ -18,61 +11,11 @@ import (
func GetModelByPidHandler(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.GetModelByPidReq
- // 如果端点有请求结构体，则使用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.NewGetModelByPidLogic(r.Context(), svcCtx)
resp := l.GetModelByPid(&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)
- }
+
}
}
diff --git a/server/product/internal/handler/getpricebypidhandler.go b/server/product/internal/handler/getpricebypidhandler.go
index b4e55c9a..42a607d8 100644
--- a/server/product/internal/handler/getpricebypidhandler.go
+++ b/server/product/internal/handler/getpricebypidhandler.go
@@ -1,15 +1,8 @@
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/product/internal/logic"
"fusenapi/server/product/internal/svc"
"fusenapi/server/product/internal/types"
@@ -18,61 +11,11 @@ import (
func GetPriceByPidHandler(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.GetPriceByPidReq
- // 如果端点有请求结构体，则使用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.NewGetPriceByPidLogic(r.Context(), svcCtx)
resp := l.GetPriceByPid(&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)
- }
+
}
}
diff --git a/server/product/internal/handler/getproductdesignhandler.go b/server/product/internal/handler/getproductdesignhandler.go
index 53bcbfe0..4cd70b40 100644
--- a/server/product/internal/handler/getproductdesignhandler.go
+++ b/server/product/internal/handler/getproductdesignhandler.go
@@ -1,15 +1,8 @@
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/product/internal/logic"
"fusenapi/server/product/internal/svc"
"fusenapi/server/product/internal/types"
@@ -18,61 +11,11 @@ import (
func GetProductDesignHandler(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.GetProductDesignReq
- // 如果端点有请求结构体，则使用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.NewGetProductDesignLogic(r.Context(), svcCtx)
resp := l.GetProductDesign(&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)
- }
+
}
}
diff --git a/server/product/internal/handler/getproductinfohandler.go b/server/product/internal/handler/getproductinfohandler.go
index d8c83be3..a8ac8ad5 100644
--- a/server/product/internal/handler/getproductinfohandler.go
+++ b/server/product/internal/handler/getproductinfohandler.go
@@ -1,15 +1,8 @@
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/product/internal/logic"
"fusenapi/server/product/internal/svc"
"fusenapi/server/product/internal/types"
@@ -18,61 +11,11 @@ import (
func GetProductInfoHandler(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.GetProductInfoReq
- // 如果端点有请求结构体，则使用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.NewGetProductInfoLogic(r.Context(), svcCtx)
resp := l.GetProductInfo(&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)
- }
+
}
}
diff --git a/server/product/internal/handler/getproductlisthandler.go b/server/product/internal/handler/getproductlisthandler.go
index 5f1154c2..ba5f1fa4 100644
--- a/server/product/internal/handler/getproductlisthandler.go
+++ b/server/product/internal/handler/getproductlisthandler.go
@@ -1,15 +1,8 @@
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/product/internal/logic"
"fusenapi/server/product/internal/svc"
"fusenapi/server/product/internal/types"
@@ -18,61 +11,11 @@ import (
func GetProductListHandler(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.GetProductListReq
- // 如果端点有请求结构体，则使用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.NewGetProductListLogic(r.Context(), svcCtx)
resp := l.GetProductList(&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)
- }
+
}
}
diff --git a/server/product/internal/handler/getrecommandproductlisthandler.go b/server/product/internal/handler/getrecommandproductlisthandler.go
index 2d4d2546..b6474541 100644
--- a/server/product/internal/handler/getrecommandproductlisthandler.go
+++ b/server/product/internal/handler/getrecommandproductlisthandler.go
@@ -1,15 +1,8 @@
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/product/internal/logic"
"fusenapi/server/product/internal/svc"
"fusenapi/server/product/internal/types"
@@ -18,61 +11,11 @@ import (
func GetRecommandProductListHandler(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.GetRecommandProductListReq
- // 如果端点有请求结构体，则使用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.NewGetRecommandProductListLogic(r.Context(), svcCtx)
resp := l.GetRecommandProductList(&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)
- }
+
}
}
diff --git a/server/product/internal/handler/getrenderdesignhandler.go b/server/product/internal/handler/getrenderdesignhandler.go
index 2584153c..016a39fd 100644
--- a/server/product/internal/handler/getrenderdesignhandler.go
+++ b/server/product/internal/handler/getrenderdesignhandler.go
@@ -1,15 +1,8 @@
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/product/internal/logic"
"fusenapi/server/product/internal/svc"
"fusenapi/server/product/internal/types"
@@ -18,61 +11,11 @@ import (
func GetRenderDesignHandler(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.GetRenderDesignReq
- // 如果端点有请求结构体，则使用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.NewGetRenderDesignLogic(r.Context(), svcCtx)
resp := l.GetRenderDesign(&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)
- }
+
}
}
diff --git a/server/product/internal/handler/getrendersettingbypidhandler.go b/server/product/internal/handler/getrendersettingbypidhandler.go
index dcf7faee..e46ba3f0 100644
--- a/server/product/internal/handler/getrendersettingbypidhandler.go
+++ b/server/product/internal/handler/getrendersettingbypidhandler.go
@@ -1,15 +1,8 @@
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/product/internal/logic"
"fusenapi/server/product/internal/svc"
"fusenapi/server/product/internal/types"
@@ -18,61 +11,11 @@ import (
func GetRenderSettingByPidHandler(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.GetRenderSettingByPidReq
- // 如果端点有请求结构体，则使用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.NewGetRenderSettingByPidLogic(r.Context(), svcCtx)
resp := l.GetRenderSettingByPid(&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)
- }
+
}
}
diff --git a/server/product/internal/handler/getsizebypidhandler.go b/server/product/internal/handler/getsizebypidhandler.go
index 9d4250e9..edc29865 100644
--- a/server/product/internal/handler/getsizebypidhandler.go
+++ b/server/product/internal/handler/getsizebypidhandler.go
@@ -1,15 +1,8 @@
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/product/internal/logic"
"fusenapi/server/product/internal/svc"
"fusenapi/server/product/internal/types"
@@ -18,61 +11,11 @@ import (
func GetSizeByPidHandler(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.GetSizeByPidReq
- // 如果端点有请求结构体，则使用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.NewGetSizeByPidLogic(r.Context(), svcCtx)
resp := l.GetSizeByPid(&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)
- }
+
}
}
diff --git a/server/product/internal/handler/getsizebyproducthandler.go b/server/product/internal/handler/getsizebyproducthandler.go
index ffb4fbe6..673433d3 100644
--- a/server/product/internal/handler/getsizebyproducthandler.go
+++ b/server/product/internal/handler/getsizebyproducthandler.go
@@ -1,15 +1,8 @@
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/product/internal/logic"
"fusenapi/server/product/internal/svc"
)
@@ -17,50 +10,8 @@ import (
func GetSizeByProductHandler(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.NewGetSizeByProductLogic(r.Context(), svcCtx)
resp := l.GetSizeByProduct(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)
- }
+
}
}
diff --git a/server/product/internal/handler/getsuccessrecommandhandler.go b/server/product/internal/handler/getsuccessrecommandhandler.go
index c779fd4f..fb74bfb7 100644
--- a/server/product/internal/handler/getsuccessrecommandhandler.go
+++ b/server/product/internal/handler/getsuccessrecommandhandler.go
@@ -1,15 +1,8 @@
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/product/internal/logic"
"fusenapi/server/product/internal/svc"
"fusenapi/server/product/internal/types"
@@ -18,61 +11,11 @@ import (
func GetSuccessRecommandHandler(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.GetSuccessRecommandReq
- // 如果端点有请求结构体，则使用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.NewGetSuccessRecommandLogic(r.Context(), svcCtx)
resp := l.GetSuccessRecommand(&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)
- }
+
}
}
diff --git a/server/product/internal/handler/gettagproductlisthandler.go b/server/product/internal/handler/gettagproductlisthandler.go
index 18a2a96c..88be7c20 100644
--- a/server/product/internal/handler/gettagproductlisthandler.go
+++ b/server/product/internal/handler/gettagproductlisthandler.go
@@ -1,15 +1,8 @@
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/product/internal/logic"
"fusenapi/server/product/internal/svc"
"fusenapi/server/product/internal/types"
@@ -18,61 +11,11 @@ import (
func GetTagProductListHandler(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.GetTagProductListReq
- // 如果端点有请求结构体，则使用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.NewGetTagProductListLogic(r.Context(), svcCtx)
resp := l.GetTagProductList(&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)
- }
+
}
}
diff --git a/server/product/internal/handler/gettemplatebypidhandler.go b/server/product/internal/handler/gettemplatebypidhandler.go
index 8d000560..0f5ba9b1 100644
--- a/server/product/internal/handler/gettemplatebypidhandler.go
+++ b/server/product/internal/handler/gettemplatebypidhandler.go
@@ -1,15 +1,8 @@
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/product/internal/logic"
"fusenapi/server/product/internal/svc"
"fusenapi/server/product/internal/types"
@@ -18,61 +11,11 @@ import (
func GetTemplateByPidHandler(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.GetTemplateByPidReq
- // 如果端点有请求结构体，则使用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.NewGetTemplateByPidLogic(r.Context(), svcCtx)
resp := l.GetTemplateByPid(&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)
- }
+
}
}
diff --git a/server/product/internal/handler/homepagerecommendproductlisthandler.go b/server/product/internal/handler/homepagerecommendproductlisthandler.go
index 6187d025..d32dfb45 100644
--- a/server/product/internal/handler/homepagerecommendproductlisthandler.go
+++ b/server/product/internal/handler/homepagerecommendproductlisthandler.go
@@ -1,13 +1,8 @@
package handler
import (
- "errors"
"fusenapi/server/product/internal/logic"
"fusenapi/server/product/internal/types"
- "fusenapi/utils/auth"
- "fusenapi/utils/basic"
- "github.com/zeromicro/go-zero/core/logx"
- "github.com/zeromicro/go-zero/rest/httpx"
"net/http"
"fusenapi/server/product/internal/svc"
@@ -16,61 +11,11 @@ import (
func HomePageRecommendProductListHandler(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.HomePageRecommendProductListReq
- // 如果端点有请求结构体，则使用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.NewHomePageRecommendProductListLogic(r.Context(), svcCtx)
resp := l.HomePageRecommendProductList(&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)
- }
+
}
}
diff --git a/server/product/internal/handler/otherproductlisthandler.go b/server/product/internal/handler/otherproductlisthandler.go
index 8510f6f9..13d827c1 100644
--- a/server/product/internal/handler/otherproductlisthandler.go
+++ b/server/product/internal/handler/otherproductlisthandler.go
@@ -1,15 +1,8 @@
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/product/internal/logic"
"fusenapi/server/product/internal/svc"
"fusenapi/server/product/internal/types"
@@ -18,61 +11,11 @@ import (
func OtherProductListHandler(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.OtherProductListReq
- // 如果端点有请求结构体，则使用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.NewOtherProductListLogic(r.Context(), svcCtx)
resp := l.OtherProductList(&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)
- }
+
}
}
diff --git a/server/product/internal/handler/savedesignhandler.go b/server/product/internal/handler/savedesignhandler.go
index 9c69607a..78a1ea11 100644
--- a/server/product/internal/handler/savedesignhandler.go
+++ b/server/product/internal/handler/savedesignhandler.go
@@ -1,15 +1,8 @@
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/product/internal/logic"
"fusenapi/server/product/internal/svc"
"fusenapi/server/product/internal/types"
@@ -18,61 +11,11 @@ import (
func SaveDesignHandler(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.SaveDesignReq
- // 如果端点有请求结构体，则使用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.NewSaveDesignLogic(r.Context(), svcCtx)
resp := l.SaveDesign(&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)
- }
+
}
}
diff --git a/server/shopping-cart-confirmation/internal/handler/cartaddhandler.go b/server/shopping-cart-confirmation/internal/handler/cartaddhandler.go
index 6a94336a..d07785f4 100644
--- a/server/shopping-cart-confirmation/internal/handler/cartaddhandler.go
+++ b/server/shopping-cart-confirmation/internal/handler/cartaddhandler.go
@@ -1,15 +1,8 @@
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/shopping-cart-confirmation/internal/logic"
"fusenapi/server/shopping-cart-confirmation/internal/svc"
"fusenapi/server/shopping-cart-confirmation/internal/types"
@@ -18,61 +11,11 @@ import (
func CartAddHandler(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.CartAddReq
- // 如果端点有请求结构体，则使用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.NewCartAddLogic(r.Context(), svcCtx)
resp := l.CartAdd(&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)
- }
+
}
}
diff --git a/server/shopping-cart-confirmation/internal/handler/cartdeletehandler.go b/server/shopping-cart-confirmation/internal/handler/cartdeletehandler.go
index dbf617c7..d5e578fb 100644
--- a/server/shopping-cart-confirmation/internal/handler/cartdeletehandler.go
+++ b/server/shopping-cart-confirmation/internal/handler/cartdeletehandler.go
@@ -1,15 +1,8 @@
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/shopping-cart-confirmation/internal/logic"
"fusenapi/server/shopping-cart-confirmation/internal/svc"
"fusenapi/server/shopping-cart-confirmation/internal/types"
@@ -18,61 +11,11 @@ import (
func CartDeleteHandler(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.CartDeleteReq
- // 如果端点有请求结构体，则使用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.NewCartDeleteLogic(r.Context(), svcCtx)
resp := l.CartDelete(&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)
- }
+
}
}
diff --git a/server/shopping-cart-confirmation/internal/handler/cartlisthandler.go b/server/shopping-cart-confirmation/internal/handler/cartlisthandler.go
index b7ccbbc2..1e1eaa26 100644
--- a/server/shopping-cart-confirmation/internal/handler/cartlisthandler.go
+++ b/server/shopping-cart-confirmation/internal/handler/cartlisthandler.go
@@ -1,15 +1,8 @@
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/shopping-cart-confirmation/internal/logic"
"fusenapi/server/shopping-cart-confirmation/internal/svc"
"fusenapi/server/shopping-cart-confirmation/internal/types"
@@ -18,61 +11,11 @@ import (
func CartListHandler(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.CartListReq
- // 如果端点有请求结构体，则使用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.NewCartListLogic(r.Context(), svcCtx)
resp := l.CartList(&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)
- }
+
}
}
diff --git a/server/shopping-cart-confirmation/internal/handler/cartnumberhandler.go b/server/shopping-cart-confirmation/internal/handler/cartnumberhandler.go
index 40070f45..4f49ed1e 100644
--- a/server/shopping-cart-confirmation/internal/handler/cartnumberhandler.go
+++ b/server/shopping-cart-confirmation/internal/handler/cartnumberhandler.go
@@ -1,15 +1,8 @@
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/shopping-cart-confirmation/internal/logic"
"fusenapi/server/shopping-cart-confirmation/internal/svc"
)
@@ -17,50 +10,8 @@ import (
func CartNumberHandler(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.NewCartNumberLogic(r.Context(), svcCtx)
resp := l.CartNumber(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)
- }
+
}
}
diff --git a/server/shopping-cart-confirmation/internal/handler/cartorderdetailhandler.go b/server/shopping-cart-confirmation/internal/handler/cartorderdetailhandler.go
index 1bda9ec4..174f170c 100644
--- a/server/shopping-cart-confirmation/internal/handler/cartorderdetailhandler.go
+++ b/server/shopping-cart-confirmation/internal/handler/cartorderdetailhandler.go
@@ -1,15 +1,8 @@
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/shopping-cart-confirmation/internal/logic"
"fusenapi/server/shopping-cart-confirmation/internal/svc"
"fusenapi/server/shopping-cart-confirmation/internal/types"
@@ -18,61 +11,11 @@ import (
func CartOrderDetailHandler(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.CartOrderDetailReq
- // 如果端点有请求结构体，则使用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.NewCartOrderDetailLogic(r.Context(), svcCtx)
resp := l.CartOrderDetail(&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)
- }
+
}
}
diff --git a/server/shopping-cart-confirmation/internal/handler/changeordermethodhandler.go b/server/shopping-cart-confirmation/internal/handler/changeordermethodhandler.go
index bc861fad..f52bf6f8 100644
--- a/server/shopping-cart-confirmation/internal/handler/changeordermethodhandler.go
+++ b/server/shopping-cart-confirmation/internal/handler/changeordermethodhandler.go
@@ -1,15 +1,8 @@
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/shopping-cart-confirmation/internal/logic"
"fusenapi/server/shopping-cart-confirmation/internal/svc"
"fusenapi/server/shopping-cart-confirmation/internal/types"
@@ -18,61 +11,11 @@ import (
func ChangeOrderMethodHandler(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.ChangeOrderMethodReq
- // 如果端点有请求结构体，则使用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.NewChangeOrderMethodLogic(r.Context(), svcCtx)
resp := l.ChangeOrderMethod(&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)
- }
+
}
}
diff --git a/server/shopping-cart-confirmation/internal/handler/createorderhandler.go b/server/shopping-cart-confirmation/internal/handler/createorderhandler.go
index e06afabb..a0f4fc17 100644
--- a/server/shopping-cart-confirmation/internal/handler/createorderhandler.go
+++ b/server/shopping-cart-confirmation/internal/handler/createorderhandler.go
@@ -1,15 +1,8 @@
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/shopping-cart-confirmation/internal/logic"
"fusenapi/server/shopping-cart-confirmation/internal/svc"
"fusenapi/server/shopping-cart-confirmation/internal/types"
@@ -18,61 +11,11 @@ import (
func CreateOrderHandler(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.CreateOrderReq
- // 如果端点有请求结构体，则使用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.NewCreateOrderLogic(r.Context(), svcCtx)
resp := l.CreateOrder(&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)
- }
+
}
}
diff --git a/server/upload/internal/handler/uploadfilebackendhandler.go b/server/upload/internal/handler/uploadfilebackendhandler.go
index a3f72895..f68083ff 100644
--- a/server/upload/internal/handler/uploadfilebackendhandler.go
+++ b/server/upload/internal/handler/uploadfilebackendhandler.go
@@ -1,13 +1,10 @@
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/upload/internal/logic"
@@ -18,51 +15,7 @@ import (
func UploadFileBackendHandler(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.RequestUploadFileBackend
- // 如果端点有请求结构体，则使用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
- }
// 解析upload文件类型
err = basic.RequestFileParse(r, &req)
@@ -77,13 +30,6 @@ func UploadFileBackendHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
// 创建一个业务逻辑层实例
l := logic.NewUploadFileBackendLogic(r.Context(), svcCtx)
resp := l.UploadFileBackend(&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)
- }
+
}
}
diff --git a/server/upload/internal/handler/uploadfilefrontendhandler.go b/server/upload/internal/handler/uploadfilefrontendhandler.go
index ca38a4f0..bc6b2b54 100644
--- a/server/upload/internal/handler/uploadfilefrontendhandler.go
+++ b/server/upload/internal/handler/uploadfilefrontendhandler.go
@@ -1,15 +1,8 @@
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/upload/internal/logic"
"fusenapi/server/upload/internal/svc"
"fusenapi/server/upload/internal/types"
@@ -18,61 +11,11 @@ import (
func UploadFileFrontendHandler(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.RequestUploadFileFrontend
- // 如果端点有请求结构体，则使用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.NewUploadFileFrontendLogic(r.Context(), svcCtx)
resp := l.UploadFileFrontend(&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)
- }
+
}
}
diff --git a/server/upload/internal/handler/uploadqrcodehandler.go b/server/upload/internal/handler/uploadqrcodehandler.go
index 8ff3d05a..17c312b1 100644
--- a/server/upload/internal/handler/uploadqrcodehandler.go
+++ b/server/upload/internal/handler/uploadqrcodehandler.go
@@ -1,15 +1,8 @@
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/upload/internal/logic"
"fusenapi/server/upload/internal/svc"
"fusenapi/server/upload/internal/types"
@@ -18,61 +11,11 @@ import (
func UploadQrcodeHandler(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.UploadQrcodeReq
- // 如果端点有请求结构体，则使用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.NewUploadQrcodeLogic(r.Context(), svcCtx)
resp := l.UploadQrcode(&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)
- }
+
}
}
diff --git a/server/upload/internal/handler/uploadupfilehandler.go b/server/upload/internal/handler/uploadupfilehandler.go
index 49f742d0..ae6fb6af 100644
--- a/server/upload/internal/handler/uploadupfilehandler.go
+++ b/server/upload/internal/handler/uploadupfilehandler.go
@@ -1,15 +1,8 @@
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/upload/internal/logic"
"fusenapi/server/upload/internal/svc"
"fusenapi/server/upload/internal/types"
@@ -18,61 +11,11 @@ import (
func UploadUpFileHandler(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.RequestUpFile
- // 如果端点有请求结构体，则使用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.NewUploadUpFileLogic(r.Context(), svcCtx)
resp := l.UploadUpFile(&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)
- }
+
}
}
diff --git a/server/webset/internal/handler/websetsettinghandler.go b/server/webset/internal/handler/websetsettinghandler.go
index 651be166..39624ba6 100644
--- a/server/webset/internal/handler/websetsettinghandler.go
+++ b/server/webset/internal/handler/websetsettinghandler.go
@@ -1,15 +1,8 @@
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/webset/internal/logic"
"fusenapi/server/webset/internal/svc"
"fusenapi/server/webset/internal/types"
@@ -18,61 +11,11 @@ import (
func WebSetSettingHandler(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.RequestWebSet
- // 如果端点有请求结构体，则使用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.NewWetSetSettingLogic(r.Context(), svcCtx)
resp := l.WebSetSetting(&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)
- }
+
}
}
diff --git a/server_api/assistant.api b/server_api/assistant.api
index e92d6354..7dafa1b5 100644
--- a/server_api/assistant.api
+++ b/server_api/assistant.api
@@ -12,5 +12,9 @@ import "basic.api"
service assistant {
// 处理重定向
@handler RedirectHandler
- get /api/assistant/redirect(request) returns (response);
+ post /api/assistant/redirect(RequestRedirect) returns (response);
+}
+
+type RequestRedirect {
+ Url string `json:"url"`
}
\ No newline at end of file