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

fix

Browse Source
This commit is contained in:
eson
2023-07-24 19:17:02 +08:00
parent a10e100364
commit b43b5dbd59
33 changed files with 109 additions and 415 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
server/home-user-auth/etc/home-user-auth.yaml
View File

@@ -1,6 +1,7 @@
Name: home-user-auth
Host: 0.0.0.0
Port: 9904
MainAddress: "http://localhost:9900"
SourceMysql: fusentest:XErSYmLELKMnf3Dh@tcp(110.41.19.98:3306)/fusentest
Auth:

1
server/home-user-auth/home-user-auth_test.go
View File

@@ -7,6 +7,5 @@ import (
// var configFile = flag.String("f", "etc/home-user-auth.yaml", "the config file")
func TestMain(t *testing.T) {
// log.Println(model.RawFieldNames[FsCanteenType]())
main()
}

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

@@ -13,18 +13,6 @@ type Config struct {
MainAddress string
OAuth struct {
Google struct {
Appid string
Secret string
}
Facebook struct {
Appid string
Secret string
}
}
Stripe struct {
SK string
}

35
server/home-user-auth/internal/handler/acceptcookiehandler.go
View File

@@ -1,35 +0,0 @@
package handler
import (
"net/http"
"reflect"
"fusenapi/utils/basic"
"fusenapi/server/home-user-auth/internal/logic"
"fusenapi/server/home-user-auth/internal/svc"
"fusenapi/server/home-user-auth/internal/types"
)
func AcceptCookieHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.Request
userinfo, err := basic.RequestParse(w, r, svcCtx, &req)
if err != nil {
return
}
// 创建一个业务逻辑层实例
l := logic.NewAcceptCookieLogic(r.Context(), svcCtx)
rl := reflect.ValueOf(l)
basic.BeforeLogic(w, r, rl)
resp := l.AcceptCookie(&req, userinfo)
if !basic.AfterLogic(w, r, rl, resp) {
basic.NormalAfterLogic(w, r, resp)
}
}
}

45
server/home-user-auth/internal/logic/acceptcookielogic.go
View File

@@ -1,45 +0,0 @@
package logic
import (
"fusenapi/utils/auth"
"fusenapi/utils/basic"
"context"
"fusenapi/server/home-user-auth/internal/svc"
"fusenapi/server/home-user-auth/internal/types"
"github.com/zeromicro/go-zero/core/logx"
)
type AcceptCookieLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewAcceptCookieLogic(ctx context.Context, svcCtx *svc.ServiceContext) *AcceptCookieLogic {
return &AcceptCookieLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *AcceptCookieLogic) AcceptCookie(req *types.Request, userinfo *auth.UserInfo) (resp *basic.Response) {
// 返回值必须调用Set重新返回, resp可以空指针调用 resp.SetStatus(basic.CodeOK, data)
// userinfo 传入值时, 一定不为null
idtyp := userinfo.GetIdType()
if idtyp == auth.IDTYPE_Guest {
return resp.SetStatus(basic.CodeGuestDupErr)
}
m := l.svcCtx.AllModels.FsGuest
token, err := m.GenerateGuestID(l.ctx, &l.svcCtx.Config.Auth.AccessSecret)
if err != nil {
return resp.SetStatus(basic.CodeGuestGenErr)
}
return resp.SetStatus(basic.CodeOK, types.DataGuest{
Token: token,
})
}

161
server/home-user-auth/internal/logic/email_manager.go
View File

@@ -1,161 +0,0 @@
package logic
import (
"bytes"
"log"
"net/smtp"
"sync"
"text/template"
"time"
)
var EmailManager *EmailSender
// EmailSender
type EmailSender struct {
lock sync.Mutex
EmailTasks chan string // 处理email的队列
Auth smtp.Auth // 邮箱发送处理
FromEmail string // 发送的email, 公司email
emailSending map[string]*EmailTask // 正在发送的邮件
ResendTimeLimit time.Duration // 重发时间限制
}
// EmailTask
type EmailTask struct {
Email string // email
SendTime time.Time // 处理的任务时间
}
// ProcessEmailTasks 处理邮件队列
func (m *EmailSender) ProcessEmailTasks() {
for {
emailTarget, ok := <-m.EmailTasks
if !ok {
log.Println("Email task channel closed")
break
}
m.lock.Lock()
_, isSending := m.emailSending[emailTarget]
if isSending {
m.lock.Unlock()
continue
}
m.emailSending[emailTarget] = &EmailTask{
Email: emailTarget,
SendTime: time.Now(),
}
m.lock.Unlock()
// TODO: Replace with actual email content
content := []byte("Hello, this is a test email")
err := smtp.SendMail(emailTarget, m.Auth, m.FromEmail, []string{emailTarget}, content)
if err != nil {
log.Printf("Failed to send email to %s: %v\n", emailTarget, err)
m.Resend(emailTarget, content)
}
}
}
// Resend 重发邮件
func (m *EmailSender) Resend(emailTarget string, content []byte) {
time.Sleep(m.ResendTimeLimit)
m.lock.Lock()
defer m.lock.Unlock()
// Check if the email task still exists and has not been sent successfully
if task, ok := m.emailSending[emailTarget]; ok && task.SendTime.Add(m.ResendTimeLimit).After(time.Now()) {
err := smtp.SendMail(emailTarget, m.Auth, m.FromEmail, []string{emailTarget}, content)
if err != nil {
log.Printf("Failed to resend email to %s: %v\n", emailTarget, err)
} else {
delete(m.emailSending, emailTarget)
}
}
}
// ClearExpiredTasks 清除过期的邮件任务
func (m *EmailSender) ClearExpiredTasks() {
ticker := time.NewTicker(time.Minute)
defer ticker.Stop()
for {
<-ticker.C
m.lock.Lock()
for email, task := range m.emailSending {
if task.SendTime.Add(m.ResendTimeLimit).Before(time.Now()) {
delete(m.emailSending, email)
}
}
m.lock.Unlock()
}
}
func init() {
// Initialize the email manager
EmailManager = &EmailSender{
EmailTasks: make(chan string, 10),
Auth: smtp.PlainAuth(
"",
"user@example.com",
"password",
"smtp.gmail.com",
),
FromEmail: "user@example.com",
emailSending: make(map[string]*EmailTask, 10),
ResendTimeLimit: time.Minute * 1,
}
// Start processing email tasks
go EmailManager.ProcessEmailTasks()
// Start clearing expired tasks
go EmailManager.ClearExpiredTasks()
}
const emailTemplate = `Subject: Your {{.CompanyName}} Account Confirmation
Dear
Thank you for creating an account with {{.CompanyName}}. We're excited to have you on board!
Before we get started, we just need to confirm that this is the right email address. Please confirm your email address by clicking on the link below:
{{.ConfirmationLink}}
Once you've confirmed, you can get started with {{.CompanyName}}. If you have any questions, feel free to reply to this email. We're here to help!
If you did not create an account with us, please ignore this email.
Thanks,
{{.SenderName}}
{{.SenderTitle}}
{{.CompanyName}}
`
func RenderEmailTemplate(companyName, recipient, confirmationLink, senderName, senderTitle string) string {
tmpl, err := template.New("email").Parse(emailTemplate)
if err != nil {
log.Fatal(err)
}
data := map[string]string{
"CompanyName": companyName,
"ConfirmationLink": confirmationLink,
"SenderName": senderName,
"SenderTitle": senderTitle,
}
var result bytes.Buffer
err = tmpl.Execute(&result, data)
if err != nil {
log.Fatal(err)
}
return result.String()
}

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

@@ -1,176 +0,0 @@
package logic
import (
"fmt"
"fusenapi/utils/auth"
"fusenapi/utils/basic"
"log"
"net/http"
"time"
"context"
"fusenapi/server/home-user-auth/internal/svc"
"fusenapi/server/home-user-auth/internal/types"
"github.com/474420502/requests"
"github.com/zeromicro/go-zero/core/logx"
"github.com/zeromicro/go-zero/rest/httpx"
"golang.org/x/net/proxy"
"golang.org/x/oauth2"
"golang.org/x/oauth2/google"
"gorm.io/gorm"
)
type UserGoogleLoginLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
token string // 登录 token
isRegistered bool // 是否注册
registerToken string // 注册邮箱的token
oauthinfo *auth.OAuthInfo
}
func NewUserGoogleLoginLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UserGoogleLoginLogic {
return &UserGoogleLoginLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
// func (l *UserGoogleLoginLogic) BeforeLogic(w http.ResponseWriter, r *http.Request) {
// log.Println(r, w)
// }
func (l *UserGoogleLoginLogic) AfterLogic(w http.ResponseWriter, r *http.Request, resp *basic.Response) {
if resp.Code == 200 {
if !l.isRegistered {
now := time.Now()
rtoken, err := auth.GenerateRegisterToken(
&l.svcCtx.Config.Auth.AccessSecret,
l.svcCtx.Config.Auth.AccessExpire,
now.Unix(),
l.oauthinfo.Id,
l.oauthinfo.Platform,
)
if err != nil {
resp.SetStatus(basic.CodeOAuthRegisterTokenErr)
}
l.registerToken = rtoken
}
rurl := fmt.Sprintf(
l.svcCtx.Config.MainAddress+"/oauth?token=%s&is_registered=%t&register_token=%s",
l.token,
l.isRegistered,
l.registerToken,
)
html := fmt.Sprintf(`
<!DOCTYPE html>
<html>
<head>
<title>Redirect</title>
<script type="text/javascript">
window.onload = function() {
window.location = "%s";
}
</script>
</head>
<body>
</body>
</html>
`, rurl)
fmt.Fprintln(w, html)
} else {
httpx.OkJson(w, resp)
}
}
func (l *UserGoogleLoginLogic) UserGoogleLogin(req *types.RequestGoogleLogin, userinfo *auth.UserInfo) (resp *basic.Response) {
// 返回值必须调用Set重新返回, resp可以空指针调用 resp.SetStatus(basic.CodeOK, data)
// userinfo 传入值时, 一定不为null
dialer, err := proxy.SOCKS5("tcp", "127.0.0.1:1080", nil, proxy.Direct)
if err != nil {
log.Fatal(err)
}
customClient := &http.Client{
Transport: &http.Transport{
Dial: dialer.Dial,
},
}
ctx := context.WithValue(context.Background(), oauth2.HTTPClient, customClient)
var googleOauthConfig = &oauth2.Config{
RedirectURL: "http://localhost:9900/api/user/oauth2/login/google",
ClientID: l.svcCtx.Config.OAuth.Google.Appid,
ClientSecret: l.svcCtx.Config.OAuth.Google.Secret,
Scopes: []string{"https://www.googleapis.com/auth/userinfo.email", "https://www.googleapis.com/auth/userinfo.profile"},
Endpoint: google.Endpoint,
}
token, err := googleOauthConfig.Exchange(ctx, req.Code)
if err != nil {
logx.Error(err)
resp.SetStatus(basic.CodeApiErr)
}
ses := requests.NewSession()
ses.Config().SetProxy("socks5://127.0.0.1:1080") // 代理 为了测试功能
r, err := ses.Get("https://www.googleapis.com/oauth2/v2/userinfo?access_token=" + token.AccessToken).Execute()
if err != nil {
logx.Error(err)
return resp.SetStatus(basic.CodeOAuthGoogleApiErr)
}
log.Println(r.Json())
googleId := r.Json().Get("id").Int()
user, err := l.svcCtx.AllModels.FsUser.FindUserByGoogleId(context.TODO(), googleId)
if err != nil {
if err != gorm.ErrRecordNotFound {
logx.Error(err)
return resp.SetStatus(basic.CodeDbSqlErr)
}
// 进入邮件注册流程
if req.Email == "" {
return resp.SetStatus(basic.CodeOK)
}
// 这里是注册模块, 发邮件, 通过邮件注册确认邮箱存在
// 邮箱验证格式错误
if !auth.ValidateEmail(req.Email) {
return resp.SetStatus(basic.CodeOAuthEmailErr)
}
return resp.SetStatus(basic.CodeOK)
}
// 如果密码匹配，则生成 JWT Token。
nowSec := time.Now().Unix()
jwtToken, err := auth.GenerateJwtToken(&l.svcCtx.Config.Auth.AccessSecret, l.svcCtx.Config.Auth.AccessExpire, nowSec, user.Id, 0)
// 如果生成 JWT Token 失败，则抛出错误并返回未认证的状态码。
if err != nil {
logx.Error(err)
return resp.SetStatus(basic.CodeServiceErr)
}
l.token = jwtToken
return resp.SetStatus(basic.CodeOK)
}

84
server/home-user-auth/internal/logic/userloginlogic.go
View File

@@ -1,84 +0,0 @@
package logic
import (
"context"
"errors"
"fmt"
"net/http"
"time"
"fusenapi/server/home-user-auth/internal/svc"
"fusenapi/server/home-user-auth/internal/types"
"fusenapi/utils/auth"
"fusenapi/utils/basic"
"github.com/zeromicro/go-zero/core/logx"
"github.com/zeromicro/go-zero/rest/httpx"
"gorm.io/gorm"
)
type UserLoginLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
token string
}
func NewUserLoginLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UserLoginLogic {
return &UserLoginLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *UserLoginLogic) AfterLogic(w http.ResponseWriter, r *http.Request, resp *basic.Response) {
if l.token != "" {
w.Header().Add("Authorization", fmt.Sprintf("Bearer %s", l.token))
}
httpx.OkJsonCtx(r.Context(), w, resp)
}
func (l *UserLoginLogic) UserLogin(req *types.RequestUserLogin, userinfo *auth.UserInfo) (resp *basic.Response) {
// 创建一个 FsUserModel 对象 m 并实例化之，该对象用于操作 MySQL 数据库中的用户数据表。
m := l.svcCtx.AllModels.FsUser
// 在用户数据表中根据登录名(email)查找用户记录，并返回 UserModel 类型的结构体对象 userModel。
user, err := m.FindUserByEmail(l.ctx, req.Email)
if errors.Is(err, gorm.ErrRecordNotFound) {
return resp.SetStatus(basic.CodeEmailNotFoundErr)
}
// 如果在用户数据表中找到了登录名匹配的用户记录，则判断密码是否匹配。
if *user.PasswordHash != req.Password {
logx.Info("密码错误")
return resp.SetStatus(basic.CodePasswordErr)
}
// 如果密码匹配，则生成 JWT Token。
nowSec := time.Now().Unix()
jwtToken, err := auth.GenerateJwtToken(&l.svcCtx.Config.Auth.AccessSecret, l.svcCtx.Config.Auth.AccessExpire, nowSec, user.Id, 0)
// 如果生成 JWT Token 失败，则抛出错误并返回未认证的状态码。
if err != nil {
logx.Error(err)
return resp.SetStatus(basic.CodeUnAuth)
}
// 如果更新 VerificationToken 字段失败，则返回未认证的状态码。
if err != nil {
return resp.SetStatus(basic.CodeUnAuth)
}
// 构造 DataUserLogin 类型的数据对象 data 并设置其属性值为生成的 JWT Token。
data := &types.DataUserLogin{
Token: jwtToken,
}
l.token = jwtToken
// 返回认证成功的状态码以及数据对象 data 和 JWT Token。
return resp.SetStatus(basic.CodeOK, data)
}

8
server/home-user-auth/internal/types/types.go
View File

@@ -115,14 +115,6 @@ type RequestOrderId struct {
RefundReason string `json:"refund_reason"` //取消原因
}
type DataUserLogin struct {
Token string `json:"token"` // 登录jwt token
}
type DataGuest struct {
Token string `json:"token"` // 登录jwt token
}
type DataUserBasicInfo struct {
Type int64 `json:"type"` // 1普通餐厅 2连锁餐厅
IsOrderStatusEmail int64 `json:"is_order_status_email"` // 订单状态改变时是否接收邮件

47
server/home-user-auth/test/acceptcookielogic_test.go
View File

@@ -1,47 +0,0 @@
package homeuserauthtest
import (
"fmt"
"fusenapi/utils/fstests"
"testing"
"github.com/474420502/requests"
"github.com/tidwall/gjson"
)
func TestAcceptCookieLogic(t *testing.T) {
var err error
var resp *requests.Response
var result gjson.Result
// 获取 session，并携带 JWT token
ses := fstests.GetSesssion()
// 向服务器发送 GET 请求，获取 cookie 信息
resp, err = ses.Post(fmt.Sprintf("http://%s:%d/user/accept-cookie", cnf.Host, cnf.Port)).TestExecute(gserver)
if err != nil {
t.Error(err)
}
// 使用 gjson 解析返回的 json 数据
result = resp.Json() // gjson
// 检查返回值中的 code 字段是否存在，并且值是否为 200
code := result.Get("code").Int()
if code != 200 {
t.Errorf("Invalid code value: %d", code)
}
// 检查返回值中的 msg 字段是否存在，并且值是否为 "success"
msg := result.Get("msg").String()
if msg != "success" {
t.Errorf(`Invalid msg value: "%s"`, msg)
}
// 检查返回值中的 data 字段是否存在，并且值是否符合预期
token := result.Get("data.token").String()
if len(token) == 0 {
t.Error("Missing token field")
}
}

3
server/home-user-auth/test/basic.go
View File

@@ -2,6 +2,7 @@ package homeuserauthtest
import (
"fmt"
authtest "fusenapi/server/auth/test"
"fusenapi/server/home-user-auth/internal/config"
"fusenapi/server/home-user-auth/internal/handler"
"fusenapi/server/home-user-auth/internal/svc"
@@ -15,10 +16,12 @@ import (
)
var cnf config.Config
var userserver *rest.Server
var gserver *rest.Server
func init() {
log.SetFlags(log.Llongfile)
userserver = authtest.GetTestServer()
gserver = GetTestServer()
}

6
server/home-user-auth/test/useraddaddresslogic_test.go
View File

@@ -16,7 +16,7 @@ func TestCaseUserAddAddress(t *testing.T) {
var result gjson.Result
// 获取 session,并携带 JWT token
ses := fstests.GetSessionWithUserToken(t, gserver, cnf.Host, cnf.Port)
ses := fstests.GetSessionWithUserToken(t, userserver, cnf.Host, cnf.Port)
// 构建新增地址请求体
addrReq := types.RequestAddAddress{
@@ -32,7 +32,7 @@ func TestCaseUserAddAddress(t *testing.T) {
}
// 向服务器发送 POST 请求,新增用户地址
tp := ses.Post(fmt.Sprintf("http://%s:%d/user/add-address", cnf.Host, cnf.Port))
tp := ses.Post(fmt.Sprintf("http://%s:%d/api/user/add-address", cnf.Host, cnf.Port))
tp.SetBodyJson(addrReq)
resp, err = tp.TestExecute(gserver)
if err != nil {
@@ -85,7 +85,7 @@ func TestCaseUserAddAddress(t *testing.T) {
}
// 向服务器发送 POST 请求,新增用户地址
tp = ses.Post(fmt.Sprintf("http://%s:%d/user/add-address", cnf.Host, cnf.Port))
tp = ses.Post(fmt.Sprintf("http://%s:%d/api/user/add-address", cnf.Host, cnf.Port))
tp.SetBodyJson(addrReq)
resp, err = tp.TestExecute(gserver)
if err != nil {

4
server/home-user-auth/test/useraddresslistlogic_test.go
View File

@@ -15,10 +15,10 @@ func TestCaseAddressList(t *testing.T) {
var result gjson.Result
// 获取 session，并携带 JWT token
ses := fstests.GetSessionWithUserToken(t, gserver, cnf.Host, cnf.Port)
ses := fstests.GetSessionWithUserToken(t, userserver, cnf.Host, cnf.Port)
// 向服务器发送 GET 请求，获取用户地址列表
resp, err = ses.Get(fmt.Sprintf("http://%s:%d/user/address-list", cnf.Host, cnf.Port)).TestExecute(gserver)
resp, err = ses.Get(fmt.Sprintf("http://%s:%d/api/user/address-list", cnf.Host, cnf.Port)).TestExecute(gserver)
if err != nil {
t.Error(err)
}

4
server/home-user-auth/test/userbasicinfologic_test.go
View File

@@ -15,10 +15,10 @@ func TestCaseBasicInfoLogic(t *testing.T) {
var result gjson.Result
// 获取 session，并携带 JWT token
ses := fstests.GetSessionWithUserToken(t, gserver, cnf.Host, cnf.Port)
ses := fstests.GetSessionWithUserToken(t, userserver, cnf.Host, cnf.Port)
// 向服务器发送 GET 请求，获取用户基本信息
resp, err = ses.Get(fmt.Sprintf("http://%s:%d/user/basic-info", cnf.Host, cnf.Port)).TestExecute(gserver)
resp, err = ses.Get(fmt.Sprintf("http://%s:%d/api/user/basic-info", cnf.Host, cnf.Port)).TestExecute(gserver)
if err != nil {
t.Error(err)
}

4
server/home-user-auth/test/usercontactservicelogic_test.go
View File

@@ -16,8 +16,8 @@ func TestUserContactService(t *testing.T) {
var result gjson.Result
// 获取 session，并携带 JWT token
ses := fstests.GetSessionWithUserToken(t, gserver, cnf.Host, cnf.Port)
tp := ses.Post(fmt.Sprintf("http://%s:%d/user/contact-service", cnf.Host, cnf.Port))
ses := fstests.GetSessionWithUserToken(t, userserver, cnf.Host, cnf.Port)
tp := ses.Post(fmt.Sprintf("http://%s:%d/api/user/contact-service", cnf.Host, cnf.Port))
req := types.RequestContactService{Type: "order", RelationID: 481, Email: "9107058@qq.com", Name: "zhang"}
tp.SetBodyJson(req)
// 向服务器发送 GET 请求，获取用户基本信息

4
server/home-user-auth/test/userfontslogic_test.go
View File

@@ -16,10 +16,10 @@ func TestCaseUserFontsLogic(t *testing.T) {
var result gjson.Result
// 获取 session，并携带 JWT token
ses := fstests.GetSessionWithUserToken(t, gserver, cnf.Host, cnf.Port)
ses := fstests.GetSessionWithUserToken(t, userserver, cnf.Host, cnf.Port)
// 向服务器发送 GET 请求，获取字体列表
resp, err = ses.Get(fmt.Sprintf("http://%s:%d/user/fonts", cnf.Host, cnf.Port)).TestExecute(gserver)
resp, err = ses.Get(fmt.Sprintf("http://%s:%d/api/user/fonts", cnf.Host, cnf.Port)).TestExecute(gserver)
if err != nil {
t.Error(err)
}

4
server/home-user-auth/test/usergettypelogic_test.go
View File

@@ -15,10 +15,10 @@ func TestCaseGetTypeLogic(t *testing.T) {
var result gjson.Result
// 获取 session，并携带 JWT token
ses := fstests.GetSessionWithUserToken(t, gserver, cnf.Host, cnf.Port)
ses := fstests.GetSessionWithUserToken(t, userserver, cnf.Host, cnf.Port)
// 向服务器发送 GET 请求，获取用户类型信息
resp, err = ses.Get(fmt.Sprintf("http://%s:%d/user/get-type", cnf.Host, cnf.Port)).TestExecute(gserver)
resp, err = ses.Get(fmt.Sprintf("http://%s:%d/api/user/get-type", cnf.Host, cnf.Port)).TestExecute(gserver)
if err != nil {
t.Error(err)
}

4
server/home-user-auth/test/useroderdeletelogic_test.go
View File

@@ -16,10 +16,10 @@ func TestCaseLogic(t *testing.T) {
var result gjson.Result
// 获取 session，并携带 JWT token
ses := fstests.GetSessionWithUserToken(t, gserver, cnf.Host, cnf.Port)
ses := fstests.GetSessionWithUserToken(t, userserver, cnf.Host, cnf.Port)
// 向服务器发送 GET 请求，获取用户类型信息
tp := ses.Post(fmt.Sprintf("http://%s:%d/user/order-delete", cnf.Host, cnf.Port))
tp := ses.Post(fmt.Sprintf("http://%s:%d/api/user/order-delete", cnf.Host, cnf.Port))
reqO := types.RequestOrderId{
OrderId: 12,
}

8
server/home-user-auth/test/usersavebasicinfologic_test.go
View File

@@ -17,10 +17,10 @@ func TestCaseUserSaveBasicinfoLogic(t *testing.T) {
var result gjson.Result
// 获取 session，并携带 JWT token
ses := fstests.GetSessionWithUserToken(t, gserver, cnf.Host, cnf.Port)
ses := fstests.GetSessionWithUserToken(t, userserver, cnf.Host, cnf.Port)
var tp *requests.Temporary
tp = ses.Get(fmt.Sprintf("http://%s:%d/user/basic-info", cnf.Host, cnf.Port))
tp = ses.Get(fmt.Sprintf("http://%s:%d/api/user/basic-info", cnf.Host, cnf.Port))
resp, err = tp.TestExecute(gserver)
if err != nil {
t.Error(err)
@@ -52,7 +52,7 @@ func TestCaseUserSaveBasicinfoLogic(t *testing.T) {
req.IsRemoveBg = ^req.IsRemoveBg + 2
// 向服务器发送 GET 请求，获取用户类型信息
tp = ses.Post(fmt.Sprintf("http://%s:%d/user/basic-info", cnf.Host, cnf.Port)).SetBodyJson(req)
tp = ses.Post(fmt.Sprintf("http://%s:%d/api/user/basic-info", cnf.Host, cnf.Port)).SetBodyJson(req)
resp, err = tp.TestExecute(gserver)
if err != nil {
t.Error(err)
@@ -69,7 +69,7 @@ func TestCaseUserSaveBasicinfoLogic(t *testing.T) {
return
}
tp = ses.Get(fmt.Sprintf("http://%s:%d/user/basic-info", cnf.Host, cnf.Port))
tp = ses.Get(fmt.Sprintf("http://%s:%d/api/user/basic-info", cnf.Host, cnf.Port))
resp, err = tp.TestExecute(gserver)
if err != nil {
t.Error(err)

4
server/home-user-auth/test/userstatusconfiglogic_test.go
View File

@@ -15,10 +15,10 @@ func TestCaseUserStatusConfigLogic(t *testing.T) {
var result gjson.Result
// 获取 session，并携带 JWT token
ses := fstests.GetSessionWithUserToken(t, gserver, cnf.Host, cnf.Port)
ses := fstests.GetSessionWithUserToken(t, userserver, cnf.Host, cnf.Port)
// 向服务器发送 GET 请求，获取用户类型信息
resp, err = ses.Post(fmt.Sprintf("http://%s:%d/user/status-config", cnf.Host, cnf.Port)).TestExecute(gserver)
resp, err = ses.Post(fmt.Sprintf("http://%s:%d/api/user/status-config", cnf.Host, cnf.Port)).TestExecute(gserver)
if err != nil {
t.Error(err)
}