feat: 添加手动设置短信验证码功能及相关前端支持

Dockerfile.v2

@@ -0,0 +1,23 @@
+FROM docker.hub.ipao.vip/jrottenberg/ffmpeg:4.4-alpine
+
+# Set timezone
+RUN apk add --no-cache tzdata && \
+    cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime && \
+    echo "Asia/Shanghai" > /etc/timezone && \
+    apk del tzdata && \
+    mkdir -p /app/downloads /app/dist
+
+COPY backend_v1/build/app /app/app
+COPY backend_v1/config.prod.toml /app/config.toml
+COPY frontend/admin/dist /app/dist/admin
+COPY frontend/wechat/dist /app/dist/wechat
+
+WORKDIR /app
+
+ENTRYPOINT  ["/app/app"]
+
+EXPOSE 9888
+
+VOLUME ["/app/downloads"]
+
+CMD [ "serve" ]

backend/app/http/admin/orders.go

@@ -33,8 +33,9 @@ func (ctl *orders) List(ctx fiber.Ctx, pagination *requests.Pagination, query *O
 }
 
 // Refund
-// @Router	/admin/orders/:id/refund [post]
+//
-// @Bind	id path
+//	@Router	/admin/orders/:id/refund [post]
+//	@Bind	id path
 func (ctl *orders) Refund(ctx fiber.Ctx, id int64) error {
 	order, err := model.OrdersModel().GetByID(ctx.Context(), id)
 	if err != nil {

backend/app/http/admin/routes.gen.go

@@ -3,15 +3,16 @@
 package admin
 
 import (
+	"quyun/app/requests"
+
 	"github.com/gofiber/fiber/v3"
 	log "github.com/sirupsen/logrus"
 	_ "go.ipao.vip/atom"
 	_ "go.ipao.vip/atom/contracts"
 	. "go.ipao.vip/atom/fen"
-	"quyun/app/requests"
 )
 
-// @provider contracts.HttpRoute atom.GroupRoutes
+// @provider	contracts.HttpRoute atom.GroupRoutes
 type Routes struct {
 	log        *log.Entry `inject:"false"`
 	auth       *auth

backend/app/http/routes.gen.go

@@ -3,16 +3,17 @@
 package http
 
 import (
+	"quyun/app/model"
+	"quyun/app/requests"
+
 	"github.com/gofiber/fiber/v3"
 	log "github.com/sirupsen/logrus"
 	_ "go.ipao.vip/atom"
 	_ "go.ipao.vip/atom/contracts"
 	. "go.ipao.vip/atom/fen"
-	"quyun/app/model"
-	"quyun/app/requests"
 )
 
-// @provider contracts.HttpRoute atom.GroupRoutes
+// @provider	contracts.HttpRoute atom.GroupRoutes
 type Routes struct {
 	log     *log.Entry `inject:"false"`
 	auth    *auth

backend/app/http/wechats.go

@@ -16,9 +16,10 @@ type wechats struct {
 }
 
 // GetJsSDK
-// @Router /wechats/js-sdk [get]
+//
-// @Bind url query
+//	@Router	/wechats/js-sdk [get]
-// @Bind user local
+//	@Bind	url query
+//	@Bind	user local
 func (ctl *wechats) GetJsSDK(ctx fiber.Ctx, url string, user *model.Users) (*wechat.JsSDK, error) {
 	if user.AuthToken.Data.StableExpiresAt.Before(time.Now()) {
 		token, err := ctl.wechat.RefreshAccessToken(user.AuthToken.Data.RefreshToken)

backend/docs/docs.go

@@ -23,7 +23,150 @@ const docTemplate = `{
     },
     "host": "{{.Host}}",
     "basePath": "{{.BasePath}}",
-    "paths": {},
+    "paths": {
+        "/admin/auth": {
+            "post": {
+                "responses": {}
+            }
+        },
+        "/admin/medias": {
+            "get": {
+                "responses": {}
+            }
+        },
+        "/admin/medias/{id}": {
+            "get": {
+                "responses": {}
+            },
+            "delete": {
+                "responses": {}
+            }
+        },
+        "/admin/orders": {
+            "get": {
+                "responses": {}
+            }
+        },
+        "/admin/orders/{id}/refund": {
+            "post": {
+                "responses": {}
+            }
+        },
+        "/admin/posts": {
+            "get": {
+                "responses": {}
+            },
+            "post": {
+                "responses": {}
+            }
+        },
+        "/admin/posts/{id}": {
+            "get": {
+                "responses": {}
+            },
+            "put": {
+                "responses": {}
+            },
+            "delete": {
+                "responses": {}
+            }
+        },
+        "/admin/posts/{id}/send-to/{userId}": {
+            "post": {
+                "responses": {}
+            }
+        },
+        "/admin/statistics": {
+            "get": {
+                "responses": {}
+            }
+        },
+        "/admin/uploads/post-uploaded-action": {
+            "post": {
+                "responses": {}
+            }
+        },
+        "/admin/uploads/pre-uploaded-check/{md5}.{ext}": {
+            "get": {
+                "responses": {}
+            }
+        },
+        "/admin/users": {
+            "get": {
+                "responses": {}
+            }
+        },
+        "/admin/users/{id}": {
+            "get": {
+                "responses": {}
+            }
+        },
+        "/admin/users/{id}/articles": {
+            "get": {
+                "responses": {}
+            }
+        },
+        "/admin/users/{id}/balance": {
+            "post": {
+                "responses": {}
+            }
+        },
+        "/auth/login": {
+            "get": {
+                "responses": {}
+            }
+        },
+        "/auth/wechat": {
+            "get": {
+                "responses": {}
+            }
+        },
+        "/pay/callback/{channel}": {
+            "post": {
+                "responses": {}
+            }
+        },
+        "/posts": {
+            "get": {
+                "responses": {}
+            }
+        },
+        "/posts/mine": {
+            "get": {
+                "responses": {}
+            }
+        },
+        "/posts/{id}/buy": {
+            "post": {
+                "responses": {}
+            }
+        },
+        "/posts/{id}/play": {
+            "get": {
+                "responses": {}
+            }
+        },
+        "/posts/{id}/show": {
+            "get": {
+                "responses": {}
+            }
+        },
+        "/users/profile": {
+            "get": {
+                "responses": {}
+            }
+        },
+        "/users/username": {
+            "put": {
+                "responses": {}
+            }
+        },
+        "/wechats/js-sdk": {
+            "get": {
+                "responses": {}
+            }
+        }
+    },
     "securityDefinitions": {
         "BasicAuth": {
             "type": "basic"

backend/docs/swagger.json

@@ -17,7 +17,150 @@
     },
     "host": "localhost:8080",
     "basePath": "/api/v1",
-    "paths": {},
+    "paths": {
+        "/admin/auth": {
+            "post": {
+                "responses": {}
+            }
+        },
+        "/admin/medias": {
+            "get": {
+                "responses": {}
+            }
+        },
+        "/admin/medias/{id}": {
+            "get": {
+                "responses": {}
+            },
+            "delete": {
+                "responses": {}
+            }
+        },
+        "/admin/orders": {
+            "get": {
+                "responses": {}
+            }
+        },
+        "/admin/orders/{id}/refund": {
+            "post": {
+                "responses": {}
+            }
+        },
+        "/admin/posts": {
+            "get": {
+                "responses": {}
+            },
+            "post": {
+                "responses": {}
+            }
+        },
+        "/admin/posts/{id}": {
+            "get": {
+                "responses": {}
+            },
+            "put": {
+                "responses": {}
+            },
+            "delete": {
+                "responses": {}
+            }
+        },
+        "/admin/posts/{id}/send-to/{userId}": {
+            "post": {
+                "responses": {}
+            }
+        },
+        "/admin/statistics": {
+            "get": {
+                "responses": {}
+            }
+        },
+        "/admin/uploads/post-uploaded-action": {
+            "post": {
+                "responses": {}
+            }
+        },
+        "/admin/uploads/pre-uploaded-check/{md5}.{ext}": {
+            "get": {
+                "responses": {}
+            }
+        },
+        "/admin/users": {
+            "get": {
+                "responses": {}
+            }
+        },
+        "/admin/users/{id}": {
+            "get": {
+                "responses": {}
+            }
+        },
+        "/admin/users/{id}/articles": {
+            "get": {
+                "responses": {}
+            }
+        },
+        "/admin/users/{id}/balance": {
+            "post": {
+                "responses": {}
+            }
+        },
+        "/auth/login": {
+            "get": {
+                "responses": {}
+            }
+        },
+        "/auth/wechat": {
+            "get": {
+                "responses": {}
+            }
+        },
+        "/pay/callback/{channel}": {
+            "post": {
+                "responses": {}
+            }
+        },
+        "/posts": {
+            "get": {
+                "responses": {}
+            }
+        },
+        "/posts/mine": {
+            "get": {
+                "responses": {}
+            }
+        },
+        "/posts/{id}/buy": {
+            "post": {
+                "responses": {}
+            }
+        },
+        "/posts/{id}/play": {
+            "get": {
+                "responses": {}
+            }
+        },
+        "/posts/{id}/show": {
+            "get": {
+                "responses": {}
+            }
+        },
+        "/users/profile": {
+            "get": {
+                "responses": {}
+            }
+        },
+        "/users/username": {
+            "put": {
+                "responses": {}
+            }
+        },
+        "/wechats/js-sdk": {
+            "get": {
+                "responses": {}
+            }
+        }
+    },
     "securityDefinitions": {
         "BasicAuth": {
             "type": "basic"

backend/docs/swagger.yaml

@@ -15,7 +15,93 @@ info:
   termsOfService: http://swagger.io/terms/
   title: ApiDoc
   version: "1.0"
-paths: {}
+paths:
+  /admin/auth:
+    post:
+      responses: {}
+  /admin/medias:
+    get:
+      responses: {}
+  /admin/medias/{id}:
+    delete:
+      responses: {}
+    get:
+      responses: {}
+  /admin/orders:
+    get:
+      responses: {}
+  /admin/orders/{id}/refund:
+    post:
+      responses: {}
+  /admin/posts:
+    get:
+      responses: {}
+    post:
+      responses: {}
+  /admin/posts/{id}:
+    delete:
+      responses: {}
+    get:
+      responses: {}
+    put:
+      responses: {}
+  /admin/posts/{id}/send-to/{userId}:
+    post:
+      responses: {}
+  /admin/statistics:
+    get:
+      responses: {}
+  /admin/uploads/post-uploaded-action:
+    post:
+      responses: {}
+  /admin/uploads/pre-uploaded-check/{md5}.{ext}:
+    get:
+      responses: {}
+  /admin/users:
+    get:
+      responses: {}
+  /admin/users/{id}:
+    get:
+      responses: {}
+  /admin/users/{id}/articles:
+    get:
+      responses: {}
+  /admin/users/{id}/balance:
+    post:
+      responses: {}
+  /auth/login:
+    get:
+      responses: {}
+  /auth/wechat:
+    get:
+      responses: {}
+  /pay/callback/{channel}:
+    post:
+      responses: {}
+  /posts:
+    get:
+      responses: {}
+  /posts/{id}/buy:
+    post:
+      responses: {}
+  /posts/{id}/play:
+    get:
+      responses: {}
+  /posts/{id}/show:
+    get:
+      responses: {}
+  /posts/mine:
+    get:
+      responses: {}
+  /users/profile:
+    get:
+      responses: {}
+  /users/username:
+    put:
+      responses: {}
+  /wechats/js-sdk:
+    get:
+      responses: {}
 securityDefinitions:
   BasicAuth:
     type: basic

backend_v1/app/commands/http/http.go

@@ -2,6 +2,8 @@ package http
 
 import (
 	"context"
+	"mime"
+	"path/filepath"
 
 	"quyun/v2/app/commands"
 	"quyun/v2/app/errorx"
@@ -21,7 +23,10 @@ import (
 	"go.ipao.vip/atom/container"
 	"go.ipao.vip/atom/contracts"
 
+	"github.com/go-pay/errgroup"
+	"github.com/gofiber/fiber/v3"
 	"github.com/gofiber/fiber/v3/middleware/favicon"
+	"github.com/rogeecn/fabfile"
 	log "github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
 	"go.uber.org/dig"
@@ -86,6 +91,54 @@ func Serve(cmd *cobra.Command, args []string) error {
 			route.Register(group)
 		}
 
-		return svc.Http.Serve(ctx)
+		svc.Http.Engine.Get("/admin*", checkStaticFile(svc.App.DistAdmin))
+		svc.Http.Engine.Get("/*", checkStaticFile(svc.App.DistWeChat))
+
+		var eg errgroup.Group
+
+		eg.Go(func(ctx context.Context) error {
+			// river job
+			if err := svc.Job.Start(ctx); err != nil {
+				log.WithError(err).Error("job start failed")
+				return err
+			}
+			defer svc.Job.StopAndCancel(ctx)
+			return nil
+		})
+
+		eg.Go(func(ctx context.Context) error {
+			return svc.Http.Serve(ctx)
+		})
+
+		return eg.Wait()
 	})
 }
+
+func checkStaticFile(rootPath string) func(ctx fiber.Ctx) error {
+	return func(ctx fiber.Ctx) error {
+		f := ctx.Params("*")
+		if f == "/" || f == "" {
+			f = "index.html"
+		}
+
+		checkFiles := []string{f, "index.html"}
+		for _, checkFile := range checkFiles {
+			filePath := filepath.Join(rootPath, checkFile)
+			log.Infof("check file: %s", filePath)
+			file, err := fabfile.Find(filePath)
+			if err != nil {
+				log.Warnf("file not found: %s", filePath)
+				continue
+			}
+
+			ext := filepath.Ext(filePath)
+			mime := mime.TypeByExtension(ext)
+
+			log.Infof("mime type: %s %s", ext, mime)
+			ctx.Set(fiber.HeaderContentType, mime)
+
+			return ctx.SendFile(file)
+		}
+		return ctx.SendStatus(fiber.StatusNotFound)
+	}
+}

backend_v1/app/commands/migrate/migrate.go

@@ -54,7 +54,7 @@ func Serve(cmd *cobra.Command, args []string) error {
 
 		goose.SetBaseFS(database.MigrationFS)
 		goose.SetTableName("migrations")
-		goose.AddNamedMigrationNoTxContext("20251219062732_river_job.go", RiverUp, RiverDown)
+		// goose.AddNamedMigrationNoTxContext("20251219062732_river_job.go", RiverUp, RiverDown)
 
 		return goose.RunContext(context.Background(), action, svc.DB, "migrations", args...)
 	})

backend_v1/app/http/admin/posts.go

@@ -195,6 +195,21 @@ func (ctl *posts) Show(ctx fiber.Ctx, post *models.Post) (*PostItem, error) {
 	}, nil
 }
 
+// Buyers
+//
+//	@Summary	作品购买人列表
+//	@Tags		Admin Posts
+//	@Produce	json
+//	@Param		id			path		int64								true	"作品 ID"
+//	@Param		pagination	query		requests.Pagination					false	"分页参数"
+//	@Success	200			{object}	requests.Pager{items=dto.PostBuyerItem}	"成功"
+//	@Router		/admin/v1/posts/:id/buyers [get]
+//	@Bind		post path key(id) model(id)
+//	@Bind		pagination query
+func (ctl *posts) Buyers(ctx fiber.Ctx, post *models.Post, pagination *requests.Pagination) (*requests.Pager, error) {
+	return services.Posts.Buyers(ctx, post.ID, pagination)
+}
+
 // SendTo
 //
 //	@Summary	赠送作品给用户

backend_v1/app/http/admin/provider.gen.go

@@ -50,25 +50,34 @@ func Provide(opts ...opt.Option) error {
 	}); err != nil {
 		return err
 	}
+	if err := container.Container.Provide(func() (*smsCodeSends, error) {
+		obj := &smsCodeSends{}
+
+		return obj, nil
+	}); err != nil {
+		return err
+	}
 	if err := container.Container.Provide(func(
 		auth *auth,
 		medias *medias,
 		middlewares *middlewares.Middlewares,
 		orders *orders,
 		posts *posts,
+		smsCodeSends *smsCodeSends,
 		statistics *statistics,
 		uploads *uploads,
 		users *users,
 	) (contracts.HttpRoute, error) {
 		obj := &Routes{
-			auth:        auth,
+			auth:         auth,
-			medias:      medias,
+			medias:       medias,
-			middlewares: middlewares,
+			middlewares:  middlewares,
-			orders:      orders,
+			orders:       orders,
-			posts:       posts,
+			posts:        posts,
-			statistics:  statistics,
+			smsCodeSends: smsCodeSends,
-			uploads:     uploads,
+			statistics:   statistics,
-			users:       users,
+			uploads:      uploads,
+			users:        users,
 		}
 		if err := obj.Prepare(); err != nil {
 			return nil, err

backend_v1/app/http/admin/routes.gen.go

@@ -26,13 +26,14 @@ type Routes struct {
 	log         *log.Entry `inject:"false"`
 	middlewares *middlewares.Middlewares
 	// Controller instances
-	auth       *auth
+	auth         *auth
-	medias     *medias
+	medias       *medias
-	orders     *orders
+	orders       *orders
-	posts      *posts
+	posts        *posts
-	statistics *statistics
+	smsCodeSends *smsCodeSends
-	uploads    *uploads
+	statistics   *statistics
-	users      *users
+	uploads      *uploads
+	users        *users
 }
 
 // Prepare initializes the routes provider with logging configuration.
@@ -114,6 +115,15 @@ func (r *Routes) Register(router fiber.Router) {
 			return models.PostQuery.WithContext(ctx).Where(field.NewUnsafeFieldRaw("id = ?", v)).First()
 		},
 	))
+	r.log.Debugf("Registering route: Get /admin/v1/posts/:id/buyers -> posts.Buyers")
+	router.Get("/admin/v1/posts/:id/buyers"[len(r.Path()):], DataFunc2(
+		r.posts.Buyers,
+		func(ctx fiber.Ctx) (*models.Post, error) {
+			v := fiber.Params[int](ctx, "id")
+			return models.PostQuery.WithContext(ctx).Where(field.NewUnsafeFieldRaw("id = ?", v)).First()
+		},
+		Query[requests.Pagination]("pagination"),
+	))
 	r.log.Debugf("Registering route: Post /admin/v1/posts -> posts.Create")
 	router.Post("/admin/v1/posts"[len(r.Path()):], Func1(
 		r.posts.Create,
@@ -140,6 +150,17 @@ func (r *Routes) Register(router fiber.Router) {
 		},
 		Body[PostForm]("form"),
 	))
+	// Register routes for controller: smsCodeSends
+	r.log.Debugf("Registering route: Get /admin/v1/sms-code-sends -> smsCodeSends.List")
+	router.Get("/admin/v1/sms-code-sends"[len(r.Path()):], DataFunc1(
+		r.smsCodeSends.List,
+		Query[dto.SmsCodeSendListQuery]("query"),
+	))
+	r.log.Debugf("Registering route: Post /admin/v1/sms-code-sends/manual-set -> smsCodeSends.ManualSet")
+	router.Post("/admin/v1/sms-code-sends/manual-set"[len(r.Path()):], DataFunc1(
+		r.smsCodeSends.ManualSet,
+		Body[SmsCodeManualSetBody]("body"),
+	))
 	// Register routes for controller: statistics
 	r.log.Debugf("Registering route: Get /admin/v1/statistics -> statistics.statistics")
 	router.Get("/admin/v1/statistics"[len(r.Path()):], DataFunc0(
@@ -164,6 +185,11 @@ func (r *Routes) Register(router fiber.Router) {
 		r.users.List,
 		Query[dto.UserListQuery]("query"),
 	))
+	r.log.Debugf("Registering route: Post /admin/v1/users -> users.Create")
+	router.Post("/admin/v1/users"[len(r.Path()):], DataFunc1(
+		r.users.Create,
+		Body[UserCreateForm]("form"),
+	))
 	r.log.Debugf("Registering route: Get /admin/v1/users/:id -> users.Show")
 	router.Get("/admin/v1/users/:id"[len(r.Path()):], DataFunc1(
 		r.users.Show,

backend_v1/app/http/admin/sms_code_sends.go

@@ -0,0 +1,80 @@
+package admin
+
+import (
+	"quyun/v2/app/http/dto"
+	"quyun/v2/app/requests"
+	"quyun/v2/app/services"
+	"quyun/v2/database"
+	"quyun/v2/database/models"
+	"time"
+
+	"github.com/gofiber/fiber/v3"
+)
+
+// @provider
+type smsCodeSends struct{}
+
+type SmsCodeManualSetBody struct {
+	Phone string `json:"phone"`
+	Code  string `json:"code"`
+}
+
+// List
+//
+//	@Summary	短信验证码发送记录
+//	@Tags		Admin SMS
+//	@Produce	json
+//	@Param		query	query		dto.SmsCodeSendListQuery								false	"筛选条件"
+//	@Success	200		{object}	requests.Pager{items=models.SmsCodeSend}	"成功"
+//	@Router		/admin/v1/sms-code-sends [get]
+//	@Bind		query query
+func (ctl *smsCodeSends) List(ctx fiber.Ctx, query *dto.SmsCodeSendListQuery) (*requests.Pager, error) {
+	if query.Pagination == nil {
+		query.Pagination = &requests.Pagination{}
+	}
+	query.Pagination.Format()
+
+	db := services.DB()
+	if db == nil {
+		return &requests.Pager{Pagination: *query.Pagination, Total: 0, Items: []*models.SmsCodeSend{}}, nil
+	}
+
+	q := db.WithContext(ctx.Context()).Model(&models.SmsCodeSend{})
+	if query.Phone != nil && *query.Phone != "" {
+		q = q.Where("phone LIKE ?", database.WrapLike(*query.Phone))
+	}
+
+	var total int64
+	if err := q.Count(&total).Error; err != nil {
+		return nil, err
+	}
+
+	var items []*models.SmsCodeSend
+	if err := q.
+		Order("sent_at desc").
+		Limit(int(query.Pagination.Limit)).
+		Offset(int(query.Pagination.Offset())).
+		Find(&items).Error; err != nil {
+		return nil, err
+	}
+
+	return &requests.Pager{
+		Pagination: *query.Pagination,
+		Total:      total,
+		Items:      items,
+	}, nil
+}
+
+// ManualSet
+//
+//	@Summary	手动设置短信验证码（用于短信认证）
+//	@Tags		Admin SMS
+//	@Accept		json
+//	@Produce	json
+//	@Param		body	body		SmsCodeManualSetBody	true	"请求体"
+//	@Success	200		{object}	models.SmsCodeSend		"成功"
+//	@Router		/admin/v1/sms-code-sends/manual-set [post]
+//	@Bind		body body
+func (ctl *smsCodeSends) ManualSet(ctx fiber.Ctx, body *SmsCodeManualSetBody) (*models.SmsCodeSend, error) {
+	return services.Users.SetPhoneCode(ctx.Context(), body.Phone, body.Code, 5*time.Minute)
+}

backend_v1/app/http/admin/users.go

@@ -7,22 +7,53 @@ import (
 	"quyun/v2/database/models"
 
 	"github.com/gofiber/fiber/v3"
+	"github.com/samber/lo"
 )
 
 // @provider
 type users struct{}
 
+type UserItem struct {
+	*models.User
+	BoughtCount int64 `json:"bought_count"` // 用户已购作品数量（统计 user_posts 记录数，含赠送/免费购买）
+}
+
 // List users
 //
 //	@Summary	用户列表
 //	@Tags		Admin Users
 //	@Produce	json
 //	@Param		query		query		UserListQuery						false	"筛选条件"
-//	@Success	200			{object}	requests.Pager{items=models.User}	"成功"
+//	@Success	200			{object}	requests.Pager{items=UserItem}	"成功"
 //	@Router		/admin/v1/users [get]
 //	@Bind		query query
 func (ctl *users) List(ctx fiber.Ctx, query *dto.UserListQuery) (*requests.Pager, error) {
-	return services.Users.List(ctx, query)
+	pager, err := services.Users.List(ctx, query)
+	if err != nil {
+		return nil, err
+	}
+
+	userIDs := lo.Map(pager.Items.([]*models.User), func(item *models.User, _ int) int64 {
+		return item.ID
+	})
+	if len(userIDs) == 0 {
+		return pager, nil
+	}
+
+	cntMap, err := services.Users.BoughtStatistics(ctx, userIDs)
+	if err != nil {
+		return pager, err
+	}
+
+	items := lo.Map(pager.Items.([]*models.User), func(item *models.User, _ int) UserItem {
+		cnt := int64(0)
+		if v, ok := cntMap[item.ID]; ok {
+			cnt = v
+		}
+		return UserItem{User: item, BoughtCount: cnt}
+	})
+	pager.Items = items
+	return pager, nil
 }
 
 // Show user
@@ -61,6 +92,11 @@ type UserPhoneForm struct {
 	Phone string `json:"phone"` // 用户手机号（11 位数字）
 }
 
+type UserCreateForm struct {
+	Phone    string `json:"phone"`    // 用户手机号（必填，11 位数字）
+	Username string `json:"username"` // 用户昵称（可选）
+}
+
 // Balance
 //
 //	@Summary	调整用户余额
@@ -92,3 +128,17 @@ func (ctl *users) Balance(ctx fiber.Ctx, user *models.User, balance *UserBalance
 func (ctl *users) SetPhone(ctx fiber.Ctx, user *models.User, form *UserPhoneForm) error {
 	return services.Users.SetPhone(ctx, user.ID, form.Phone)
 }
+
+// Create user
+//
+//	@Summary	创建用户
+//	@Tags		Admin Users
+//	@Accept		json
+//	@Produce	json
+//	@Param		form	body		UserCreateForm	true	"请求体"
+//	@Success	200		{object}	models.User		"成功"
+//	@Router		/admin/v1/users [post]
+//	@Bind		form body
+func (ctl *users) Create(ctx fiber.Ctx, form *UserCreateForm) (*models.User, error) {
+	return services.Users.CreateByPhone(ctx, form.Phone, form.Username)
+}

backend_v1/app/http/dto/post.go

@@ -7,6 +7,6 @@ import (
 
 type PostListQuery struct {
 	*requests.Pagination
-	Keyword *string           `query:"keyword"`
+	Keyword *string            `query:"keyword"`
-	Status  fields.PostStatus `query:"status"`
+	Status  *fields.PostStatus `query:"status"`
 }

backend_v1/app/http/dto/post_buyer.go

@@ -0,0 +1,17 @@
+package dto
+
+import "time"
+
+type PostBuyerItem struct {
+	UserID int64 `json:"user_id"` // 用户 ID（购买人唯一标识，用于管理端关联用户详情/后续操作）
+
+	Username string `json:"username"` // 用户名（购买人展示名称；可能为空或默认值，前端需兼容）
+
+	Avatar string `json:"avatar"` // 用户头像 URL（用于列表展示；可能为空，前端需提供占位图/降级展示）
+
+	Phone string `json:"phone"` // 用户手机号（管理端可见；用于客服联系/核对身份，可能为空）
+
+	BoughtAt time.Time `json:"bought_at"` // 购买时间（以 user_posts.created_at 为准；用于排序/审计）
+
+	Price int64 `json:"price"` // 购买价格（单位：分；-1 表示管理员赠送/免费，非负为实际支付金额）
+}

backend_v1/app/http/dto/sms_code_send.go

@@ -0,0 +1,9 @@
+package dto
+
+import "quyun/v2/app/requests"
+
+type SmsCodeSendListQuery struct {
+	*requests.Pagination
+
+	Phone *string `query:"phone"`
+}

backend_v1/app/http/dto/user.go

@@ -4,5 +4,7 @@ import "quyun/v2/app/requests"
 
 type UserListQuery struct {
 	*requests.Pagination
-	Keyword *string `query:"keyword"`
+	Keyword *string `query:"keyword"` // 关键词（模糊匹配手机号/用户名；若为数字且>0，则同时按用户 ID 精确匹配）
+
+	OnlyBought *bool `query:"onlyBought"` // 是否仅返回“购买数量>0”的用户（true=仅已购用户；false/空=全部用户）
 }

backend_v1/app/http/posts.go

@@ -44,8 +44,7 @@ type posts struct {
 //	@Bind		query query
 //	@Bind		user local
 func (ctl *posts) List(ctx fiber.Ctx, query *dto.PostListQuery, user *models.User) (*requests.Pager, error) {
-	query.Status = fields.PostStatusPublished
+	query.Status = lo.ToPtr(fields.PostStatusPublished)
-
 	pager, err := services.Posts.List(ctx, query)
 	if err != nil {
 		log.WithError(err).Errorf("post list err: %v", err)
@@ -187,15 +186,20 @@ func (ctl *posts) Play(ctx fiber.Ctx, post *models.Post, user *models.User) (*Pl
 	// return &PlayUrl{
 	// 	Url: "https://github.com/mediaelement/mediaelement-files/raw/refs/heads/master/big_buck_bunny.mp4",
 	// }, nil
-
+	if post.Status != fields.PostStatusPublished {
-	preview := true
+		return nil, fiber.ErrNotFound
-	bought, err := services.Users.HasBought(ctx, user.ID, post.ID)
-	if err != nil {
-		preview = false
 	}
 
-	if bought {
+	preview := true
-		preview = false
+	if user != nil {
+		bought, err := services.Users.HasBought(ctx, user.ID, post.ID)
+		if err != nil {
+			preview = false
+		}
+
+		if bought {
+			preview = false
+		}
 	}
 
 	log.Infof("Fetching play URL for post ID: %d", post.ID)

backend_v1/app/middlewares/mid_auth_frontend.go

@@ -22,7 +22,9 @@ func (f *Middlewares) AuthFrontend(ctx fiber.Ctx) error {
 	if strings.HasPrefix(ctx.Path(), "/v1/posts/") && strings.HasSuffix(ctx.Path(), "show") {
 		return ctx.Next()
 	}
-	if strings.HasPrefix(ctx.Path(), "/v1/posts/") && strings.HasSuffix(ctx.Path(), "play") {
+
+	token := ctx.Get("Authorization")
+	if token == "" && strings.HasPrefix(ctx.Path(), "/v1/posts/") && strings.HasSuffix(ctx.Path(), "play") {
 		return ctx.Next()
 	}
 
@@ -47,7 +49,6 @@ func (f *Middlewares) AuthFrontend(ctx fiber.Ctx) error {
 	fullUrl = u.String()
 
 	// 仅使用 Header 的 Bearer Token（前端 localStorage 存储，随请求透传）。
-	token := ctx.Get("Authorization")
 	if token == "" {
 		log.Infof("auth redirect_uri: %s", fullUrl)
 		if ctx.XHR() {
@@ -73,6 +74,7 @@ func (f *Middlewares) AuthFrontend(ctx fiber.Ctx) error {
 	}
 
 	ctx.Locals("user", user)
+	log.Infof("jwt login user id: %d", user.ID)
 
 	return ctx.Next()
 }

backend_v1/app/services/db.go

@@ -0,0 +1,5 @@
+package services
+
+import "gorm.io/gorm"
+
+func DB() *gorm.DB { return _db }

backend_v1/app/services/posts.go

@@ -42,6 +42,11 @@ func (m *posts) List(ctx context.Context, filter *dto.PostListQuery) (*requests.
 		query = query.Where(tbl.Title.Like(keyword))
 	}
 
+	// filter status
+	if filter.Status != nil {
+		query = query.Where(tbl.Status.Eq(*filter.Status))
+	}
+
 	items, cnt, err := query.FindByPage(int(filter.Offset()), int(filter.Limit))
 	if err != nil {
 		return nil, errors.Wrap(err, "list post failed")
@@ -115,6 +120,8 @@ func (m *posts) Bought(ctx context.Context, userId int64, pagination *requests.P
 		RightJoin(tblUserPost, tbl.ID.EqCol(tblUserPost.PostID)).
 		Where(tblUserPost.UserID.Eq(userId)).
 		Order(tblUserPost.CreatedAt.Desc()).
+		Limit(int(pagination.Limit)).
+		Offset(int(pagination.Offset())).
 		Scan(&retItems)
 	if err != nil {
 		return nil, err
@@ -127,6 +134,62 @@ func (m *posts) Bought(ctx context.Context, userId int64, pagination *requests.P
 	}, nil
 }
 
+// Buyers 获取某个作品的购买人列表（管理端使用）
+func (m *posts) Buyers(ctx context.Context, postID int64, pagination *requests.Pagination) (*requests.Pager, error) {
+	pagination.Format()
+
+	// 先分页查询购买记录，避免一次性拉取全量 user_posts 造成内存/延迟抖动
+	tblUserPost, queryUserPost := models.UserPostQuery.QueryContext(ctx)
+	queryUserPost = queryUserPost.
+		Where(tblUserPost.PostID.Eq(postID)).
+		Order(tblUserPost.CreatedAt.Desc())
+
+	userPosts, cnt, err := queryUserPost.FindByPage(int(pagination.Offset()), int(pagination.Limit))
+	if err != nil {
+		return nil, err
+	}
+	if len(userPosts) == 0 {
+		return &requests.Pager{
+			Items:      []dto.PostBuyerItem{},
+			Total:      cnt,
+			Pagination: *pagination,
+		}, nil
+	}
+
+	// 批量回表查询用户信息，避免 N+1
+	userIDs := lo.Uniq(lo.Map(userPosts, func(item *models.UserPost, _ int) int64 {
+		return item.UserID
+	}))
+	tblUser, queryUser := models.UserQuery.QueryContext(ctx)
+	users, err := queryUser.Where(tblUser.ID.In(userIDs...)).Find()
+	if err != nil {
+		return nil, err
+	}
+	userMap := lo.KeyBy(users, func(item *models.User) int64 { return item.ID })
+
+	items := make([]dto.PostBuyerItem, 0, len(userPosts))
+	for _, item := range userPosts {
+		user, ok := userMap[item.UserID]
+		if !ok {
+			continue
+		}
+		items = append(items, dto.PostBuyerItem{
+			UserID:   user.ID,
+			Username: user.Username,
+			Avatar:   user.Avatar,
+			Phone:    user.Phone,
+			BoughtAt: item.CreatedAt,
+			Price:    item.Price,
+		})
+	}
+
+	return &requests.Pager{
+		Items:      items,
+		Total:      cnt,
+		Pagination: *pagination,
+	}, nil
+}
+
 // GetPostsMapByIDs
 func (m *posts) GetPostsMapByIDs(ctx context.Context, ids []int64) (map[int64]*models.Post, error) {
 	tbl, query := models.PostQuery.QueryContext(ctx)

backend_v1/app/services/provider.gen.go

@@ -1,6 +1,8 @@
 package services
 
 import (
+	"quyun/v2/providers/ali"
+
 	"go.ipao.vip/atom"
 	"go.ipao.vip/atom/container"
 	"go.ipao.vip/atom/contracts"
@@ -52,8 +54,12 @@ func Provide(opts ...opt.Option) error {
 	}, atom.GroupInitial); err != nil {
 		return err
 	}
-	if err := container.Container.Provide(func() (*users, error) {
+	if err := container.Container.Provide(func(
-		obj := &users{}
+		smsNotifyClient *ali.SMSNotifyClient,
+	) (*users, error) {
+		obj := &users{
+			smsNotifyClient: smsNotifyClient,
+		}
 		if err := obj.Prepare(); err != nil {
 			return nil, err
 		}

backend_v1/app/services/users.go

@@ -50,16 +50,58 @@ func (m *users) List(
 
 	query = query.Order(tbl.ID.Desc())
 
+	keyword := ""
 	if filter.Keyword != nil && *filter.Keyword != "" {
+		keyword = strings.TrimSpace(*filter.Keyword)
 		query = query.
-			Where(tbl.Phone.Like(database.WrapLike(*filter.Keyword))).
+			Where(tbl.Phone.Like(database.WrapLike(keyword))).
-			Or(tbl.Username.Like(database.WrapLike(*filter.Keyword)))
+			Or(tbl.Username.Like(database.WrapLike(keyword))).
+			Or(tbl.OpenID.Eq(keyword))
 
-		if id, err := strconv.ParseInt(strings.TrimSpace(*filter.Keyword), 10, 64); err == nil && id > 0 {
+		if id, err := strconv.ParseInt(keyword, 10, 64); err == nil && id > 0 {
 			query = query.Or(tbl.ID.Eq(id))
 		}
 	}
 
+	if filter.OnlyBought != nil && *filter.OnlyBought {
+		// 仅返回“购买数量>0”的用户：通过 JOIN user_posts 做存在性过滤。
+		// 注意：FindByPage 内部用 Count()，在 GROUP BY 场景下可能不准确，这里改为手动 Count(DISTINCT users.id)。
+		tblUserPost, _ := models.UserPostQuery.QueryContext(ctx)
+		query = query.Join(tblUserPost, tbl.ID.EqCol(tblUserPost.UserID)).Group(tbl.ID)
+
+		offset := int(filter.Pagination.Offset())
+		limit := int(filter.Pagination.Limit)
+
+		items, err := query.Offset(offset).Limit(limit).Find()
+		if err != nil {
+			return nil, errors.Wrap(err, "query users error")
+		}
+
+		db := _db.WithContext(ctx).Model(&models.User{}).
+			Joins("JOIN user_posts ON user_posts.user_id = users.id")
+		if keyword != "" {
+			like := database.WrapLike(keyword)
+			args := []any{like, like}
+			where := "(users.phone LIKE ? OR users.username LIKE ?)"
+			if id, err := strconv.ParseInt(keyword, 10, 64); err == nil && id > 0 {
+				where = "(users.phone LIKE ? OR users.username LIKE ? OR users.id = ?)"
+				args = append(args, id)
+			}
+			db = db.Where(where, args...)
+		}
+
+		var cnt int64
+		if err := db.Distinct("users.id").Count(&cnt).Error; err != nil {
+			return nil, errors.Wrap(err, "count users error")
+		}
+
+		return &requests.Pager{
+			Items:      items,
+			Total:      cnt,
+			Pagination: *filter.Pagination,
+		}, nil
+	}
+
 	items, cnt, err := query.FindByPage(int(filter.Pagination.Offset()), int(filter.Pagination.Limit))
 	if err != nil {
 		return nil, errors.Wrap(err, "query users error")
@@ -72,6 +114,37 @@ func (m *users) List(
 	}, nil
 }
 
+// BoughtStatistics 获取指定用户 ID 的购买作品数量（仅统计 user_posts 记录数）。
+func (m *users) BoughtStatistics(ctx context.Context, userIDs []int64) (map[int64]int64, error) {
+	if len(userIDs) == 0 {
+		return map[int64]int64{}, nil
+	}
+
+	// 管理端用户列表需要展示购买数量；这里用 group by 聚合，避免 N+1。
+	tbl, query := models.UserPostQuery.QueryContext(ctx)
+
+	var items []struct {
+		Count  int64
+		UserID int64
+	}
+	if err := query.
+		Select(
+			tbl.UserID.Count().As("count"),
+			tbl.UserID,
+		).
+		Where(tbl.UserID.In(userIDs...)).
+		Group(tbl.UserID).
+		Scan(&items); err != nil {
+		return nil, err
+	}
+
+	result := make(map[int64]int64, len(items))
+	for _, item := range items {
+		result[item.UserID] = item.Count
+	}
+	return result, nil
+}
+
 // PostList returns a paginated list of posts for a user
 func (m *users) PostList(ctx context.Context, userId int64, filter *dto.PostListQuery) (*requests.Pager, error) {
 	filter.Format()
@@ -286,6 +359,64 @@ func (m *users) gen4Digits() (string, error) {
 	return fmt.Sprintf("%04d", n.Int64()), nil
 }
 
+// SetPhoneCode 手动设置短信验证码（后台操作）；默认有效期 5 分钟，不受发送频率限制。
+func (m *users) SetPhoneCode(ctx context.Context, phone, code string, ttl time.Duration) (*models.SmsCodeSend, error) {
+	phone = m.normalizePhone(phone)
+	code = strings.TrimSpace(code)
+	if phone == "" {
+		return nil, errors.New("手机号不能为空")
+	}
+	if code == "" {
+		return nil, errors.New("验证码不能为空")
+	}
+	if len(code) != 4 {
+		return nil, errors.New("验证码必须为 4 位数字")
+	}
+	for _, r := range code {
+		if r < '0' || r > '9' {
+			return nil, errors.New("验证码必须为 4 位数字")
+		}
+	}
+
+	// 前置校验：手机号必须已注册
+	_, err := m.FindByPhone(ctx, phone)
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, errors.New("手机号未注册，请联系管理员开通")
+		}
+		return nil, errors.Wrap(err, "failed to find user by phone")
+	}
+
+	now := time.Now()
+	if ttl <= 0 {
+		ttl = 5 * time.Minute
+	}
+	expiresAt := now.Add(ttl)
+
+	m.mu.Lock()
+	m.ensurePhoneAuthMaps()
+	m.codeByPhone[phone] = phoneCodeEntry{code: code, expiresAt: expiresAt}
+	m.lastSentAtByPhone[phone] = now
+	m.mu.Unlock()
+
+	if _db == nil {
+		return nil, errors.New("db not initialized")
+	}
+
+	record := &models.SmsCodeSend{
+		Phone:     phone,
+		Code:      code,
+		SentAt:    now,
+		ExpiresAt: expiresAt,
+	}
+	if err := _db.WithContext(ctx).Create(record).Error; err != nil {
+		return nil, err
+	}
+
+	log.Infof("SetPhoneCode to %s: code=%s", phone, code)
+	return record, nil
+}
+
 // SendPhoneCode 发送短信验证码（内存限流：同一手机号 58s 内仅允许发送一次；验证码 5 分钟过期）。
 func (m *users) SendPhoneCode(ctx context.Context, phone string) error {
 	phone = m.normalizePhone(phone)
@@ -319,14 +450,25 @@ func (m *users) SendPhoneCode(ctx context.Context, phone string) error {
 	}
 
 	// 生成/覆盖验证码：同一手机号再次发送时以最新验证码为准
+	expiresAt := now.Add(5 * time.Minute)
 	m.codeByPhone[phone] = phoneCodeEntry{
 		code:      code,
-		expiresAt: now.Add(5 * time.Minute),
+		expiresAt: expiresAt,
 	}
 	m.lastSentAtByPhone[phone] = now
 	// log phone and code
 	log.Infof("SendPhoneCode to %s: code=%s", phone, code)
 
+	if _db != nil {
+		// 记录短信验证码发送日志（用于后台审计与排查）。
+		_ = _db.WithContext(ctx).Create(&models.SmsCodeSend{
+			Phone:     phone,
+			Code:      code,
+			SentAt:    now,
+			ExpiresAt: expiresAt,
+		}).Error
+	}
+
 	return nil
 }
 
@@ -405,3 +547,53 @@ func (m *users) SetPhone(ctx context.Context, userID int64, phone string) error
 	}
 	return nil
 }
+
+// CreateByPhone 管理端通过手机号创建新用户（手机号必填，昵称可选）。
+func (m *users) CreateByPhone(ctx context.Context, phone, username string) (*models.User, error) {
+	phone = strings.TrimSpace(phone)
+	if phone == "" {
+		return nil, errors.New("手机号不能为空")
+	}
+	if len(phone) != 11 {
+		return nil, errors.New("手机号必须为 11 位数字")
+	}
+	for _, r := range phone {
+		if r < '0' || r > '9' {
+			return nil, errors.New("手机号必须为 11 位数字")
+		}
+	}
+
+	_, err := m.FindByPhone(ctx, phone)
+	if err == nil {
+		return nil, errors.New("手机号已被其他用户占用")
+	}
+	if !errors.Is(err, gorm.ErrRecordNotFound) {
+		return nil, errors.Wrap(err, "failed to check phone uniqueness")
+	}
+
+	openID := "phone:" + phone
+	tbl, query := models.UserQuery.QueryContext(ctx)
+	if _, err := query.Where(tbl.OpenID.Eq(openID)).First(); err == nil {
+		return nil, errors.New("用户已存在")
+	} else if !errors.Is(err, gorm.ErrRecordNotFound) {
+		return nil, errors.Wrap(err, "failed to check open_id uniqueness")
+	}
+
+	username = strings.TrimSpace(username)
+	if username == "" {
+		username = "用户" + phone[len(phone)-4:]
+	}
+
+	user := &models.User{
+		OpenID:   openID,
+		Username: username,
+		Phone:    phone,
+		Balance:  0,
+		Avatar:   "",
+	}
+
+	if err := _db.WithContext(ctx).Omit("metas", "auth_token").Create(user).Error; err != nil {
+		return nil, errors.Wrap(err, "failed to create user")
+	}
+	return user, nil
+}

backend_v1/config.prod.toml

@@ -10,7 +10,7 @@ RechargeWechat = "13932043996"
 Port = 9888
 
 [Database]
-Host = "host.local"
+Host = "postgres"
 Database = "quyun"
 Password = "xixi0202"
 
@@ -30,9 +30,9 @@ DB = 0
 [Ali]
 AccessKeyId = "LTAI5t86SjiP9zRd3q2w7jQN"
 AccessKeySecret = "hV7spvJuWh8w0EEIXj8NFi2uBlF4aS"
-Bucket ="rogee-bj"
+Bucket = "rogee-bj"
-Host ="https://assets.jdwan.com"
+Host = "https://assets.jdwan.com"
-Region ="cn-beijing"
+Region = "cn-beijing"
 
 [WeChat]
 AppID = "wx47649361b6eba174"
@@ -42,12 +42,12 @@ EncodingAesKey = "OlgPgMvsl92zy5oErtEzRcziRT2txoN3jgEHV6RQZMY"
 DevMode = false
 
 [WeChat.Pay]
-NotifyURL="https://mp.jdwan.com/v1/pay/callback/wechat"
+NotifyURL = "https://mp.jdwan.com/v1/pay/callback/wechat"
 MchID = "1702644947"
 SerialNo = "4563EC584A35BC84FB27AA4100C934C9A91D59CA"
 MechName = "佳芃（北京）企业管理咨询有限公司"
-ApiV3Key="5UBDkxVDY44AKafkqN6YgYxgtkXP6Mw6"
+ApiV3Key = "5UBDkxVDY44AKafkqN6YgYxgtkXP6Mw6"
-PrivateKey="""-----BEGIN PRIVATE KEY-----
+PrivateKey = """-----BEGIN PRIVATE KEY-----
 MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQC+GjWdwRorgQXw
 Z8ouZeW8UsUgjiSUPKLJHGOZQESa09xmzm+DVZWNCPEHJvz1bDmSNXVsQUWRE/+y
 MwSfe+faq0d4BZiw1ueFbRyj4Vw/x7B2vY0i8yo0VyTnWdC6QZRc+V+dbuPJM1Ok

backend_v1/config.toml

@@ -13,7 +13,8 @@ Port = 8088
 [Database]
 Host = "10.1.1.2"
 Port = 5433
-Database = "quyun"
+# Database = "quyun"
+Database = "q1"
 Password = "xixi0202"
 
 [JWT]

backend_v1/database/migrations/20251223170000_create_sms_code_sends.sql

@@ -0,0 +1,18 @@
+-- +goose Up
+-- +goose StatementBegin
+CREATE TABLE sms_code_sends(
+    id SERIAL8 PRIMARY KEY,
+    phone varchar(20) NOT NULL,
+    code varchar(20) NOT NULL,
+    sent_at timestamp NOT NULL DEFAULT now(),
+    expires_at timestamp NOT NULL
+);
+
+CREATE INDEX idx_sms_code_sends_phone ON sms_code_sends(phone);
+CREATE INDEX idx_sms_code_sends_sent_at ON sms_code_sends(sent_at);
+-- +goose StatementEnd
+-- +goose Down
+-- +goose StatementBegin
+DROP TABLE sms_code_sends;
+-- +goose StatementEnd
+

backend_v1/database/models/query.gen.go

@@ -16,12 +16,13 @@ import (
 )
 
 var (
-	Q             = new(Query)
+	Q                = new(Query)
-	MediumQuery   *mediumQuery
+	MediumQuery      *mediumQuery
-	OrderQuery    *orderQuery
+	OrderQuery       *orderQuery
-	PostQuery     *postQuery
+	PostQuery        *postQuery
-	UserQuery     *userQuery
+	SmsCodeSendQuery *smsCodeSendQuery
-	UserPostQuery *userPostQuery
+	UserQuery        *userQuery
+	UserPostQuery    *userPostQuery
 )
 
 func SetDefault(db *gorm.DB, opts ...gen.DOOption) {
@@ -29,41 +30,45 @@ func SetDefault(db *gorm.DB, opts ...gen.DOOption) {
 	MediumQuery = &Q.Medium
 	OrderQuery = &Q.Order
 	PostQuery = &Q.Post
+	SmsCodeSendQuery = &Q.SmsCodeSend
 	UserQuery = &Q.User
 	UserPostQuery = &Q.UserPost
 }
 
 func Use(db *gorm.DB, opts ...gen.DOOption) *Query {
 	return &Query{
-		db:       db,
+		db:          db,
-		Medium:   newMedium(db, opts...),
+		Medium:      newMedium(db, opts...),
-		Order:    newOrder(db, opts...),
+		Order:       newOrder(db, opts...),
-		Post:     newPost(db, opts...),
+		Post:        newPost(db, opts...),
-		User:     newUser(db, opts...),
+		SmsCodeSend: newSmsCodeSend(db, opts...),
-		UserPost: newUserPost(db, opts...),
+		User:        newUser(db, opts...),
+		UserPost:    newUserPost(db, opts...),
 	}
 }
 
 type Query struct {
 	db *gorm.DB
 
-	Medium   mediumQuery
+	Medium      mediumQuery
-	Order    orderQuery
+	Order       orderQuery
-	Post     postQuery
+	Post        postQuery
-	User     userQuery
+	SmsCodeSend smsCodeSendQuery
-	UserPost userPostQuery
+	User        userQuery
+	UserPost    userPostQuery
 }
 
 func (q *Query) Available() bool { return q.db != nil }
 
 func (q *Query) clone(db *gorm.DB) *Query {
 	return &Query{
-		db:       db,
+		db:          db,
-		Medium:   q.Medium.clone(db),
+		Medium:      q.Medium.clone(db),
-		Order:    q.Order.clone(db),
+		Order:       q.Order.clone(db),
-		Post:     q.Post.clone(db),
+		Post:        q.Post.clone(db),
-		User:     q.User.clone(db),
+		SmsCodeSend: q.SmsCodeSend.clone(db),
-		UserPost: q.UserPost.clone(db),
+		User:        q.User.clone(db),
+		UserPost:    q.UserPost.clone(db),
 	}
 }
 
@@ -77,30 +82,33 @@ func (q *Query) WriteDB() *Query {
 
 func (q *Query) ReplaceDB(db *gorm.DB) *Query {
 	return &Query{
-		db:       db,
+		db:          db,
-		Medium:   q.Medium.replaceDB(db),
+		Medium:      q.Medium.replaceDB(db),
-		Order:    q.Order.replaceDB(db),
+		Order:       q.Order.replaceDB(db),
-		Post:     q.Post.replaceDB(db),
+		Post:        q.Post.replaceDB(db),
-		User:     q.User.replaceDB(db),
+		SmsCodeSend: q.SmsCodeSend.replaceDB(db),
-		UserPost: q.UserPost.replaceDB(db),
+		User:        q.User.replaceDB(db),
+		UserPost:    q.UserPost.replaceDB(db),
 	}
 }
 
 type queryCtx struct {
-	Medium   *mediumQueryDo
+	Medium      *mediumQueryDo
-	Order    *orderQueryDo
+	Order       *orderQueryDo
-	Post     *postQueryDo
+	Post        *postQueryDo
-	User     *userQueryDo
+	SmsCodeSend *smsCodeSendQueryDo
-	UserPost *userPostQueryDo
+	User        *userQueryDo
+	UserPost    *userPostQueryDo
 }
 
 func (q *Query) WithContext(ctx context.Context) *queryCtx {
 	return &queryCtx{
-		Medium:   q.Medium.WithContext(ctx),
+		Medium:      q.Medium.WithContext(ctx),
-		Order:    q.Order.WithContext(ctx),
+		Order:       q.Order.WithContext(ctx),
-		Post:     q.Post.WithContext(ctx),
+		Post:        q.Post.WithContext(ctx),
-		User:     q.User.WithContext(ctx),
+		SmsCodeSend: q.SmsCodeSend.WithContext(ctx),
-		UserPost: q.UserPost.WithContext(ctx),
+		User:        q.User.WithContext(ctx),
+		UserPost:    q.UserPost.WithContext(ctx),
 	}
 }
 

backend_v1/database/models/sms_code_sends.gen.go

@@ -0,0 +1,57 @@
+// Code generated by go.ipao.vip/gen. DO NOT EDIT.
+// Code generated by go.ipao.vip/gen. DO NOT EDIT.
+// Code generated by go.ipao.vip/gen. DO NOT EDIT.
+
+package models
+
+import (
+	"context"
+	"time"
+
+	"go.ipao.vip/gen"
+)
+
+const TableNameSmsCodeSend = "sms_code_sends"
+
+// SmsCodeSend mapped from table <sms_code_sends>
+type SmsCodeSend struct {
+	ID        int64     `gorm:"column:id;type:bigint;primaryKey;autoIncrement:true" json:"id"`
+	Phone     string    `gorm:"column:phone;type:character varying(20);not null" json:"phone"`
+	Code      string    `gorm:"column:code;type:character varying(20);not null" json:"code"`
+	SentAt    time.Time `gorm:"column:sent_at;type:timestamp without time zone;not null;default:now()" json:"sent_at"`
+	ExpiresAt time.Time `gorm:"column:expires_at;type:timestamp without time zone;not null" json:"expires_at"`
+}
+
+// Quick operations without importing query package
+// Update applies changed fields to the database using the default DB.
+func (m *SmsCodeSend) Update(ctx context.Context) (gen.ResultInfo, error) {
+	return Q.SmsCodeSend.WithContext(ctx).Updates(m)
+}
+
+// Save upserts the model using the default DB.
+func (m *SmsCodeSend) Save(ctx context.Context) error { return Q.SmsCodeSend.WithContext(ctx).Save(m) }
+
+// Create inserts the model using the default DB.
+func (m *SmsCodeSend) Create(ctx context.Context) error {
+	return Q.SmsCodeSend.WithContext(ctx).Create(m)
+}
+
+// Delete removes the row represented by the model using the default DB.
+func (m *SmsCodeSend) Delete(ctx context.Context) (gen.ResultInfo, error) {
+	return Q.SmsCodeSend.WithContext(ctx).Delete(m)
+}
+
+// ForceDelete permanently deletes the row (ignores soft delete) using the default DB.
+func (m *SmsCodeSend) ForceDelete(ctx context.Context) (gen.ResultInfo, error) {
+	return Q.SmsCodeSend.WithContext(ctx).Unscoped().Delete(m)
+}
+
+// Reload reloads the model from database by its primary key and overwrites current fields.
+func (m *SmsCodeSend) Reload(ctx context.Context) error {
+	fresh, err := Q.SmsCodeSend.WithContext(ctx).GetByID(m.ID)
+	if err != nil {
+		return err
+	}
+	*m = *fresh
+	return nil
+}

backend_v1/database/models/sms_code_sends.query.gen.go

@@ -0,0 +1,477 @@
+// Code generated by go.ipao.vip/gen. DO NOT EDIT.
+// Code generated by go.ipao.vip/gen. DO NOT EDIT.
+// Code generated by go.ipao.vip/gen. DO NOT EDIT.
+
+package models
+
+import (
+	"context"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"go.ipao.vip/gen"
+	"go.ipao.vip/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+)
+
+func newSmsCodeSend(db *gorm.DB, opts ...gen.DOOption) smsCodeSendQuery {
+	_smsCodeSendQuery := smsCodeSendQuery{}
+
+	_smsCodeSendQuery.smsCodeSendQueryDo.UseDB(db, opts...)
+	_smsCodeSendQuery.smsCodeSendQueryDo.UseModel(&SmsCodeSend{})
+
+	tableName := _smsCodeSendQuery.smsCodeSendQueryDo.TableName()
+	_smsCodeSendQuery.ALL = field.NewAsterisk(tableName)
+	_smsCodeSendQuery.ID = field.NewInt64(tableName, "id")
+	_smsCodeSendQuery.Phone = field.NewString(tableName, "phone")
+	_smsCodeSendQuery.Code = field.NewString(tableName, "code")
+	_smsCodeSendQuery.SentAt = field.NewTime(tableName, "sent_at")
+	_smsCodeSendQuery.ExpiresAt = field.NewTime(tableName, "expires_at")
+
+	_smsCodeSendQuery.fillFieldMap()
+
+	return _smsCodeSendQuery
+}
+
+type smsCodeSendQuery struct {
+	smsCodeSendQueryDo smsCodeSendQueryDo
+
+	ALL       field.Asterisk
+	ID        field.Int64
+	Phone     field.String
+	Code      field.String
+	SentAt    field.Time
+	ExpiresAt field.Time
+
+	fieldMap map[string]field.Expr
+}
+
+func (s smsCodeSendQuery) Table(newTableName string) *smsCodeSendQuery {
+	s.smsCodeSendQueryDo.UseTable(newTableName)
+	return s.updateTableName(newTableName)
+}
+
+func (s smsCodeSendQuery) As(alias string) *smsCodeSendQuery {
+	s.smsCodeSendQueryDo.DO = *(s.smsCodeSendQueryDo.As(alias).(*gen.DO))
+	return s.updateTableName(alias)
+}
+
+func (s *smsCodeSendQuery) updateTableName(table string) *smsCodeSendQuery {
+	s.ALL = field.NewAsterisk(table)
+	s.ID = field.NewInt64(table, "id")
+	s.Phone = field.NewString(table, "phone")
+	s.Code = field.NewString(table, "code")
+	s.SentAt = field.NewTime(table, "sent_at")
+	s.ExpiresAt = field.NewTime(table, "expires_at")
+
+	s.fillFieldMap()
+
+	return s
+}
+
+func (s *smsCodeSendQuery) QueryContext(ctx context.Context) (*smsCodeSendQuery, *smsCodeSendQueryDo) {
+	return s, s.smsCodeSendQueryDo.WithContext(ctx)
+}
+
+func (s *smsCodeSendQuery) WithContext(ctx context.Context) *smsCodeSendQueryDo {
+	return s.smsCodeSendQueryDo.WithContext(ctx)
+}
+
+func (s smsCodeSendQuery) TableName() string { return s.smsCodeSendQueryDo.TableName() }
+
+func (s smsCodeSendQuery) Alias() string { return s.smsCodeSendQueryDo.Alias() }
+
+func (s smsCodeSendQuery) Columns(cols ...field.Expr) gen.Columns {
+	return s.smsCodeSendQueryDo.Columns(cols...)
+}
+
+func (s *smsCodeSendQuery) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
+	_f, ok := s.fieldMap[fieldName]
+	if !ok || _f == nil {
+		return nil, false
+	}
+	_oe, ok := _f.(field.OrderExpr)
+	return _oe, ok
+}
+
+func (s *smsCodeSendQuery) fillFieldMap() {
+	s.fieldMap = make(map[string]field.Expr, 5)
+	s.fieldMap["id"] = s.ID
+	s.fieldMap["phone"] = s.Phone
+	s.fieldMap["code"] = s.Code
+	s.fieldMap["sent_at"] = s.SentAt
+	s.fieldMap["expires_at"] = s.ExpiresAt
+}
+
+func (s smsCodeSendQuery) clone(db *gorm.DB) smsCodeSendQuery {
+	s.smsCodeSendQueryDo.ReplaceConnPool(db.Statement.ConnPool)
+	return s
+}
+
+func (s smsCodeSendQuery) replaceDB(db *gorm.DB) smsCodeSendQuery {
+	s.smsCodeSendQueryDo.ReplaceDB(db)
+	return s
+}
+
+type smsCodeSendQueryDo struct{ gen.DO }
+
+func (s smsCodeSendQueryDo) Debug() *smsCodeSendQueryDo {
+	return s.withDO(s.DO.Debug())
+}
+
+func (s smsCodeSendQueryDo) WithContext(ctx context.Context) *smsCodeSendQueryDo {
+	return s.withDO(s.DO.WithContext(ctx))
+}
+
+func (s smsCodeSendQueryDo) ReadDB() *smsCodeSendQueryDo {
+	return s.Clauses(dbresolver.Read)
+}
+
+func (s smsCodeSendQueryDo) WriteDB() *smsCodeSendQueryDo {
+	return s.Clauses(dbresolver.Write)
+}
+
+func (s smsCodeSendQueryDo) Session(config *gorm.Session) *smsCodeSendQueryDo {
+	return s.withDO(s.DO.Session(config))
+}
+
+func (s smsCodeSendQueryDo) Clauses(conds ...clause.Expression) *smsCodeSendQueryDo {
+	return s.withDO(s.DO.Clauses(conds...))
+}
+
+func (s smsCodeSendQueryDo) Returning(value interface{}, columns ...string) *smsCodeSendQueryDo {
+	return s.withDO(s.DO.Returning(value, columns...))
+}
+
+func (s smsCodeSendQueryDo) Not(conds ...gen.Condition) *smsCodeSendQueryDo {
+	return s.withDO(s.DO.Not(conds...))
+}
+
+func (s smsCodeSendQueryDo) Or(conds ...gen.Condition) *smsCodeSendQueryDo {
+	return s.withDO(s.DO.Or(conds...))
+}
+
+func (s smsCodeSendQueryDo) Select(conds ...field.Expr) *smsCodeSendQueryDo {
+	return s.withDO(s.DO.Select(conds...))
+}
+
+func (s smsCodeSendQueryDo) Where(conds ...gen.Condition) *smsCodeSendQueryDo {
+	return s.withDO(s.DO.Where(conds...))
+}
+
+func (s smsCodeSendQueryDo) Order(conds ...field.Expr) *smsCodeSendQueryDo {
+	return s.withDO(s.DO.Order(conds...))
+}
+
+func (s smsCodeSendQueryDo) Distinct(cols ...field.Expr) *smsCodeSendQueryDo {
+	return s.withDO(s.DO.Distinct(cols...))
+}
+
+func (s smsCodeSendQueryDo) Omit(cols ...field.Expr) *smsCodeSendQueryDo {
+	return s.withDO(s.DO.Omit(cols...))
+}
+
+func (s smsCodeSendQueryDo) Join(table schema.Tabler, on ...field.Expr) *smsCodeSendQueryDo {
+	return s.withDO(s.DO.Join(table, on...))
+}
+
+func (s smsCodeSendQueryDo) LeftJoin(table schema.Tabler, on ...field.Expr) *smsCodeSendQueryDo {
+	return s.withDO(s.DO.LeftJoin(table, on...))
+}
+
+func (s smsCodeSendQueryDo) RightJoin(table schema.Tabler, on ...field.Expr) *smsCodeSendQueryDo {
+	return s.withDO(s.DO.RightJoin(table, on...))
+}
+
+func (s smsCodeSendQueryDo) Group(cols ...field.Expr) *smsCodeSendQueryDo {
+	return s.withDO(s.DO.Group(cols...))
+}
+
+func (s smsCodeSendQueryDo) Having(conds ...gen.Condition) *smsCodeSendQueryDo {
+	return s.withDO(s.DO.Having(conds...))
+}
+
+func (s smsCodeSendQueryDo) Limit(limit int) *smsCodeSendQueryDo {
+	return s.withDO(s.DO.Limit(limit))
+}
+
+func (s smsCodeSendQueryDo) Offset(offset int) *smsCodeSendQueryDo {
+	return s.withDO(s.DO.Offset(offset))
+}
+
+func (s smsCodeSendQueryDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *smsCodeSendQueryDo {
+	return s.withDO(s.DO.Scopes(funcs...))
+}
+
+func (s smsCodeSendQueryDo) Unscoped() *smsCodeSendQueryDo {
+	return s.withDO(s.DO.Unscoped())
+}
+
+func (s smsCodeSendQueryDo) Create(values ...*SmsCodeSend) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return s.DO.Create(values)
+}
+
+func (s smsCodeSendQueryDo) CreateInBatches(values []*SmsCodeSend, batchSize int) error {
+	return s.DO.CreateInBatches(values, batchSize)
+}
+
+// Save : !!! underlying implementation is different with GORM
+// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
+func (s smsCodeSendQueryDo) Save(values ...*SmsCodeSend) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return s.DO.Save(values)
+}
+
+func (s smsCodeSendQueryDo) First() (*SmsCodeSend, error) {
+	if result, err := s.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*SmsCodeSend), nil
+	}
+}
+
+func (s smsCodeSendQueryDo) Take() (*SmsCodeSend, error) {
+	if result, err := s.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*SmsCodeSend), nil
+	}
+}
+
+func (s smsCodeSendQueryDo) Last() (*SmsCodeSend, error) {
+	if result, err := s.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*SmsCodeSend), nil
+	}
+}
+
+func (s smsCodeSendQueryDo) Find() ([]*SmsCodeSend, error) {
+	result, err := s.DO.Find()
+	return result.([]*SmsCodeSend), err
+}
+
+func (s smsCodeSendQueryDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*SmsCodeSend, err error) {
+	buf := make([]*SmsCodeSend, 0, batchSize)
+	err = s.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
+		defer func() { results = append(results, buf...) }()
+		return fc(tx, batch)
+	})
+	return results, err
+}
+
+func (s smsCodeSendQueryDo) FindInBatches(result *[]*SmsCodeSend, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return s.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (s smsCodeSendQueryDo) Attrs(attrs ...field.AssignExpr) *smsCodeSendQueryDo {
+	return s.withDO(s.DO.Attrs(attrs...))
+}
+
+func (s smsCodeSendQueryDo) Assign(attrs ...field.AssignExpr) *smsCodeSendQueryDo {
+	return s.withDO(s.DO.Assign(attrs...))
+}
+
+func (s smsCodeSendQueryDo) Joins(fields ...field.RelationField) *smsCodeSendQueryDo {
+	for _, _f := range fields {
+		s = *s.withDO(s.DO.Joins(_f))
+	}
+	return &s
+}
+
+func (s smsCodeSendQueryDo) Preload(fields ...field.RelationField) *smsCodeSendQueryDo {
+	for _, _f := range fields {
+		s = *s.withDO(s.DO.Preload(_f))
+	}
+	return &s
+}
+
+func (s smsCodeSendQueryDo) FirstOrInit() (*SmsCodeSend, error) {
+	if result, err := s.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*SmsCodeSend), nil
+	}
+}
+
+func (s smsCodeSendQueryDo) FirstOrCreate() (*SmsCodeSend, error) {
+	if result, err := s.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*SmsCodeSend), nil
+	}
+}
+
+func (s smsCodeSendQueryDo) FindByPage(offset int, limit int) (result []*SmsCodeSend, count int64, err error) {
+	result, err = s.Offset(offset).Limit(limit).Find()
+	if err != nil {
+		return
+	}
+
+	if size := len(result); 0 < limit && 0 < size && size < limit {
+		count = int64(size + offset)
+		return
+	}
+
+	count, err = s.Offset(-1).Limit(-1).Count()
+	return
+}
+
+func (s smsCodeSendQueryDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
+	count, err = s.Count()
+	if err != nil {
+		return
+	}
+
+	err = s.Offset(offset).Limit(limit).Scan(result)
+	return
+}
+
+func (s smsCodeSendQueryDo) Scan(result interface{}) (err error) {
+	return s.DO.Scan(result)
+}
+
+func (s smsCodeSendQueryDo) Delete(models ...*SmsCodeSend) (result gen.ResultInfo, err error) {
+	return s.DO.Delete(models)
+}
+
+// ForceDelete performs a permanent delete (ignores soft-delete) for current scope.
+func (s smsCodeSendQueryDo) ForceDelete() (gen.ResultInfo, error) {
+	return s.Unscoped().Delete()
+}
+
+// Inc increases the given column by step for current scope.
+func (s smsCodeSendQueryDo) Inc(column field.Expr, step int64) (gen.ResultInfo, error) {
+	// column = column + step
+	e := field.NewUnsafeFieldRaw("?+?", column.RawExpr(), step)
+	return s.DO.UpdateColumn(column, e)
+}
+
+// Dec decreases the given column by step for current scope.
+func (s smsCodeSendQueryDo) Dec(column field.Expr, step int64) (gen.ResultInfo, error) {
+	// column = column - step
+	e := field.NewUnsafeFieldRaw("?-?", column.RawExpr(), step)
+	return s.DO.UpdateColumn(column, e)
+}
+
+// Sum returns SUM(column) for current scope.
+func (s smsCodeSendQueryDo) Sum(column field.Expr) (float64, error) {
+	var _v float64
+	agg := field.NewUnsafeFieldRaw("SUM(?)", column.RawExpr())
+	if err := s.Select(agg).Scan(&_v); err != nil {
+		return 0, err
+	}
+	return _v, nil
+}
+
+// Avg returns AVG(column) for current scope.
+func (s smsCodeSendQueryDo) Avg(column field.Expr) (float64, error) {
+	var _v float64
+	agg := field.NewUnsafeFieldRaw("AVG(?)", column.RawExpr())
+	if err := s.Select(agg).Scan(&_v); err != nil {
+		return 0, err
+	}
+	return _v, nil
+}
+
+// Min returns MIN(column) for current scope.
+func (s smsCodeSendQueryDo) Min(column field.Expr) (float64, error) {
+	var _v float64
+	agg := field.NewUnsafeFieldRaw("MIN(?)", column.RawExpr())
+	if err := s.Select(agg).Scan(&_v); err != nil {
+		return 0, err
+	}
+	return _v, nil
+}
+
+// Max returns MAX(column) for current scope.
+func (s smsCodeSendQueryDo) Max(column field.Expr) (float64, error) {
+	var _v float64
+	agg := field.NewUnsafeFieldRaw("MAX(?)", column.RawExpr())
+	if err := s.Select(agg).Scan(&_v); err != nil {
+		return 0, err
+	}
+	return _v, nil
+}
+
+// PluckMap returns a map[key]value for selected key/value expressions within current scope.
+func (s smsCodeSendQueryDo) PluckMap(key, val field.Expr) (map[interface{}]interface{}, error) {
+	do := s.Select(key, val)
+	rows, err := do.DO.Rows()
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	mm := make(map[interface{}]interface{})
+	for rows.Next() {
+		var k interface{}
+		var v interface{}
+		if err := rows.Scan(&k, &v); err != nil {
+			return nil, err
+		}
+		mm[k] = v
+	}
+	return mm, rows.Err()
+}
+
+// Exists returns true if any record matches the given conditions.
+func (s smsCodeSendQueryDo) Exists(conds ...gen.Condition) (bool, error) {
+	cnt, err := s.Where(conds...).Count()
+	if err != nil {
+		return false, err
+	}
+	return cnt > 0, nil
+}
+
+// PluckIDs returns all primary key values under current scope.
+func (s smsCodeSendQueryDo) PluckIDs() ([]int64, error) {
+	ids := make([]int64, 0, 16)
+	pk := field.NewInt64(s.TableName(), "id")
+	if err := s.DO.Pluck(pk, &ids); err != nil {
+		return nil, err
+	}
+	return ids, nil
+}
+
+// GetByID finds a single record by primary key.
+func (s smsCodeSendQueryDo) GetByID(id int64) (*SmsCodeSend, error) {
+	pk := field.NewInt64(s.TableName(), "id")
+	return s.Where(pk.Eq(id)).First()
+}
+
+// GetByIDs finds records by primary key list.
+func (s smsCodeSendQueryDo) GetByIDs(ids ...int64) ([]*SmsCodeSend, error) {
+	if len(ids) == 0 {
+		return []*SmsCodeSend{}, nil
+	}
+	pk := field.NewInt64(s.TableName(), "id")
+	return s.Where(pk.In(ids...)).Find()
+}
+
+// DeleteByID deletes records by primary key.
+func (s smsCodeSendQueryDo) DeleteByID(id int64) (gen.ResultInfo, error) {
+	pk := field.NewInt64(s.TableName(), "id")
+	return s.Where(pk.Eq(id)).Delete()
+}
+
+// DeleteByIDs deletes records by a list of primary keys.
+func (s smsCodeSendQueryDo) DeleteByIDs(ids ...int64) (gen.ResultInfo, error) {
+	if len(ids) == 0 {
+		return gen.ResultInfo{RowsAffected: 0, Error: nil}, nil
+	}
+	pk := field.NewInt64(s.TableName(), "id")
+	return s.Where(pk.In(ids...)).Delete()
+}
+
+func (s *smsCodeSendQueryDo) withDO(do gen.Dao) *smsCodeSendQueryDo {
+	s.DO = *do.(*gen.DO)
+	return s
+}

backend_v1/providers/ali/sms_notify_client.go

@@ -40,7 +40,6 @@ func NewSMSNotifyClient(cfg *Config) (*SMSNotifyClient, error) {
 }
 
 func (c *SMSNotifyClient) SendTo(phone string) (string, error) {
-
 	req := &dypnsapi20170525.SendSmsVerifyCodeRequest{
 		SignName:         tea.String("速通互联验证码"),
 		TemplateCode:     tea.String("100001"),

backend_v1/providers/http/engine.go

@@ -15,7 +15,6 @@ import (
 	"github.com/gofiber/fiber/v3"
 	"github.com/gofiber/fiber/v3/middleware/compress"
 	"github.com/gofiber/fiber/v3/middleware/cors"
-	"github.com/gofiber/fiber/v3/middleware/helmet"
 	"github.com/gofiber/fiber/v3/middleware/logger"
 	"github.com/gofiber/fiber/v3/middleware/recover"
 	"github.com/gofiber/fiber/v3/middleware/requestid"
@@ -115,17 +114,17 @@ func Provide(opts ...opt.Option) error {
 			},
 		}))
 
-		// basic security + compression
-		engine.Use(helmet.New())
 		engine.Use(compress.New(compress.Config{Level: compress.LevelDefault}))
+		// basic security + compression
+		// engine.Use(helmet.New())
 
 		// optional CORS based on config
-		if config.Cors != nil {
+		// if config.Cors != nil {
-			corsCfg := buildCORSConfig(config.Cors)
+		// 	corsCfg := buildCORSConfig(config.Cors)
-			if corsCfg != nil {
+		// 	if corsCfg != nil {
-				engine.Use(cors.New(*corsCfg))
+		// 		engine.Use(cors.New(*corsCfg))
-			}
+		// 	}
-		}
+		// }
 
 		// logging with request id and latency
 		engine.Use(logger.New(logger.Config{

backend_v1/providers/postgres/config.go

@@ -90,7 +90,7 @@ func (m *Config) checkDefault() {
 	}
 
 	if m.TimeZone == "" {
-		m.TimeZone = "Asia/Shanghai"
+		// m.TimeZone = "Asia/Shanghai"
 	}
 
 	if m.Port == 0 {
@@ -104,9 +104,13 @@ func (m *Config) checkDefault() {
 
 func (m *Config) EmptyDsn() string {
 	// 基本 DSN
-	dsnTpl := "host=%s user=%s password=%s port=%d dbname=%s sslmode=%s TimeZone=%s"
+	// dsnTpl := "host=%s user=%s password=%s port=%d dbname=%s sslmode=%s TimeZone=%s"
+	// m.checkDefault()
+	// base := fmt.Sprintf(dsnTpl, m.Host, m.Username, m.Password, m.Port, m.Database, m.SslMode, m.TimeZone)
+
+	dsnTpl := "host=%s user=%s password=%s port=%d dbname=%s sslmode=%s"
 	m.checkDefault()
-	base := fmt.Sprintf(dsnTpl, m.Host, m.Username, m.Password, m.Port, m.Database, m.SslMode, m.TimeZone)
+	base := fmt.Sprintf(dsnTpl, m.Host, m.Username, m.Password, m.Port, m.Database, m.SslMode)
 	// 附加可选参数
 	extras := ""
 	if m.UseSearchPath && m.Schema != "" {
@@ -121,9 +125,9 @@ func (m *Config) EmptyDsn() string {
 // DSN connection dsn
 func (m *Config) DSN() string {
 	// 基本 DSN
-	dsnTpl := "host=%s user=%s password=%s dbname=%s port=%d sslmode=%s TimeZone=%s"
+	dsnTpl := "host=%s user=%s password=%s dbname=%s port=%d sslmode=%s"
 	m.checkDefault()
-	base := fmt.Sprintf(dsnTpl, m.Host, m.Username, m.Password, m.Database, m.Port, m.SslMode, m.TimeZone)
+	base := fmt.Sprintf(dsnTpl, m.Host, m.Username, m.Password, m.Database, m.Port, m.SslMode)
 	// 附加可选参数
 	extras := ""
 	if m.UseSearchPath && m.Schema != "" {

build.v2.sh

@@ -0,0 +1,80 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+ADMIN_DIR="$ROOT_DIR/frontend/admin"
+WECHAT_DIR="$ROOT_DIR/frontend/wechat"
+BACKEND_DIR="$ROOT_DIR/backend_v1"
+DOCKER_IMAGE="${DOCKER_IMAGE:-rogeecn/quyun}"
+NPM_REGISTRY="${NPM_REGISTRY:-https://npm.hub.ipao.vip}"
+GO_PROXY="${GO_PROXY:-https://go.hub.ipao.vip}" # fallback adds ,direct when exported
+GO_NO_PROXY="${GO_NO_PROXY:-git.ipao.vip}"
+IMAGE_ARCHIVE="${IMAGE_ARCHIVE:-$ROOT_DIR/quyun.v2.tgz}"
+
+log() {
+  printf '\n==> %s\n' "$1"
+}
+
+die() {
+  printf 'Error: %s\n' "$1" >&2
+  exit 1
+}
+
+ensure_bun() {
+  if command -v bun >/dev/null 2>&1; then
+    return
+  fi
+  log "Installing bun via npm"
+  npm install -g bun || die "Failed to install bun"
+}
+
+run_frontend_build() {
+  local dir="$1"
+  local label="$2"
+
+  [[ -d "$dir" ]] || die "Missing frontend directory $dir"
+  log "Building ${label}"
+  pushd "$dir" >/dev/null
+  bun install
+  bun run build
+  popd >/dev/null
+}
+
+build_backend() {
+  [[ -d "$BACKEND_DIR" ]] || die "Missing backend directory"
+  log "Tidying Go modules"
+  pushd "$BACKEND_DIR" >/dev/null
+  export GOPROXY="${GO_PROXY},direct"
+  export GONOPROXY="$GO_NO_PROXY"
+  export GONOSUMDB="$GO_NO_PROXY"
+  go mod tidy
+  log "Building Go binary"
+  mkdir -p build
+  CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o build/app .
+  popd >/dev/null
+}
+
+build_image() {
+  log "Building Docker image ${DOCKER_IMAGE}:v2"
+  sudo docker build -f Dockerfile.v2 -t "${DOCKER_IMAGE}:v2" "$ROOT_DIR"
+}
+
+export_image() {
+  log "Exporting image to ${IMAGE_ARCHIVE}"
+  sudo docker save "${DOCKER_IMAGE}:v2" | gzip -c > "$IMAGE_ARCHIVE"
+}
+
+main() {
+  export NPM_CONFIG_REGISTRY="$NPM_REGISTRY"
+  export npm_config_registry="$NPM_REGISTRY"
+
+  ensure_bun
+  run_frontend_build "$ADMIN_DIR" "frontend/Admin"
+  run_frontend_build "$WECHAT_DIR" "frontend/Wechat"
+  build_backend
+  build_image
+  export_image
+  log "Build finished"
+}
+
+main "$@"

frontend/admin/src/App.vue

@@ -33,6 +33,11 @@ const navItems = ref([
         icon: 'pi pi-shopping-cart',
         command: () => router.push('/orders')
     },
+    {
+        label: '短信认证',
+        icon: 'pi pi-comment',
+        command: () => router.push('/sms-code-sends')
+    },
     {
         label: '设置',
         icon: 'pi pi-cog',

frontend/admin/src/api/postService.js

@@ -26,4 +26,9 @@ export const postService = {
     sendTo(id, userId) {
         return httpClient.post(`/posts/${id}/send-to/${userId}`);
     },
-}
+    getBuyers(id, { page = 1, limit = 10 } = {}) {
+        return httpClient.get(`/posts/${id}/buyers`, {
+            params: { page, limit }
+        });
+    },
+}

frontend/admin/src/api/smsCodeSendService.js

@@ -0,0 +1,19 @@
+import httpClient from './httpClient';
+
+export const smsCodeSendService = {
+    get({ page = 1, limit = 10, phone = '' } = {}) {
+        return httpClient.get('/sms-code-sends', {
+            params: {
+                page,
+                limit,
+                phone: phone.trim()
+            }
+        });
+    },
+    manualSet({ phone = '', code = '' } = {}) {
+        return httpClient.post('/sms-code-sends/manual-set', {
+            phone: phone.trim(),
+            code: code.trim()
+        });
+    }
+};

frontend/admin/src/api/userService.js

@@ -1,15 +1,22 @@
 import httpClient from './httpClient';
 
 export const userService = {
-    getUsers({ page = 1, limit = 10, keyword = '' } = {}) {
+    getUsers({ page = 1, limit = 10, keyword = '', onlyBought = false } = {}) {
         return httpClient.get('/users', {
             params: {
                 page,
                 limit,
-                keyword: keyword.trim()
+                keyword: keyword.trim(),
+                onlyBought
             }
         });
     },
+    createUser({ phone, username } = {}) {
+        return httpClient.post('/users', {
+            phone,
+            username
+        });
+    },
     searchUser(id) {
         return httpClient.get(`/users/${id}`);
     },

frontend/admin/src/pages/PostPage.vue

@@ -194,6 +194,15 @@ const sendDialogVisible = ref(false);
 const selectedPost = ref(null);
 const selectedUser = ref(null);
 
+// Buyers dialog state (购买人列表)
+const buyersDialogVisible = ref(false);
+const buyersPost = ref(null);
+const buyersItems = ref([]);
+const buyersLoading = ref(false);
+const buyersFirst = ref(0);
+const buyersRows = ref(10);
+const buyersTotal = ref(0);
+
 // 修改用户列表相关变量
 const users = ref({
     items: [],
@@ -288,6 +297,48 @@ const handleSendConfirm = async () => {
     }
 };
 
+const formatBuyerPrice = (priceCents) => {
+    if (priceCents < 0) return '赠送';
+    return formatPrice(priceCents / 100);
+};
+
+const fetchBuyers = async () => {
+    if (!buyersPost.value) return;
+    buyersLoading.value = true;
+    try {
+        const currentPage = (buyersFirst.value / buyersRows.value) + 1;
+        const response = await postService.getBuyers(buyersPost.value.id, {
+            page: currentPage,
+            limit: buyersRows.value
+        });
+        buyersItems.value = response.data.items || [];
+        buyersTotal.value = response.data.total || 0;
+    } catch (error) {
+        toast.add({
+            severity: 'error',
+            summary: '错误',
+            detail: '加载购买人列表失败',
+            life: 3000
+        });
+    } finally {
+        buyersLoading.value = false;
+    }
+};
+
+const openBuyers = async (post) => {
+    if (!post || !post.bought_count || post.bought_count <= 0) return;
+    buyersPost.value = post;
+    buyersFirst.value = 0;
+    buyersDialogVisible.value = true;
+    await fetchBuyers();
+};
+
+const onBuyersPage = (event) => {
+    buyersFirst.value = event.first;
+    buyersRows.value = event.rows;
+    fetchBuyers();
+};
+
 </script>
 
 <template>
@@ -363,6 +414,64 @@ const handleSendConfirm = async () => {
         </template>
     </Dialog>
 
+    <!-- Buyers list dialog -->
+    <Dialog v-model:visible="buyersDialogVisible" modal header="购买人列表" :style="{ width: '80vw' }">
+        <div class="flex flex-col gap-4">
+            <div class="mb-2">
+                <span class="font-bold">曲谱：</span>
+                {{ buyersPost?.title }}
+            </div>
+
+            <DataTable :value="buyersItems" :loading="buyersLoading" :paginator="true" :rows="buyersRows"
+                :totalRecords="buyersTotal" :lazy="true" :first="buyersFirst" @page="onBuyersPage" dataKey="user_id"
+                class="p-datatable-sm" responsiveLayout="scroll" style="max-height: 60vh" scrollable>
+                <template #empty>
+                    <div class="text-center p-4">暂无购买记录</div>
+                </template>
+
+                <template #loading>
+                    <div class="flex flex-col items-center justify-center p-4">
+                        <ProgressSpinner style="width:50px;height:50px" />
+                        <span class="mt-2">加载购买人数据...</span>
+                    </div>
+                </template>
+
+                <Column field="username" header="用户">
+                    <template #body="{ data }">
+                        <div class="flex items-center space-x-3">
+                            <div class="avatar">
+                                <div class="mask mask-squircle w-12 h-12">
+                                    <img :src="data.avatar" :alt="data.username" />
+                                </div>
+                            </div>
+                            <div>
+                                <div class="font-bold">{{ data.username }}</div>
+                                <div class="text-xs text-gray-500">ID: {{ data.user_id }}</div>
+                            </div>
+                        </div>
+                    </template>
+                </Column>
+
+                <Column field="phone" header="手机号" />
+
+                <Column field="price" header="价格">
+                    <template #body="{ data }">
+                        {{ formatBuyerPrice(data.price) }}
+                    </template>
+                </Column>
+
+                <Column field="bought_at" header="购买时间">
+                    <template #body="{ data }">
+                        {{ formatDate(data.bought_at) }}
+                    </template>
+                </Column>
+            </DataTable>
+        </div>
+        <template #footer>
+            <Button label="关闭" icon="pi pi-times" @click="buyersDialogVisible = false" class="p-button-text" />
+        </template>
+    </Dialog>
+
     <div class="w-full">
         <div class="flex justify-between items-center mb-6 gap-4">
             <h1 class="text-2xl font-semibold text-gray-800 text-nowrap">曲谱列表</h1>
@@ -418,9 +527,9 @@ const handleSendConfirm = async () => {
 
                 <Column field="bought_count" header="销售数量" sortable>
                     <template #body="{ data }">
-                        <div class="flex flex-col">
+                        <Button v-if="data.bought_count > 0" text severity="info" class="p-0"
-                            <span class="text-gray-500">{{ data.bought_count }}</span>
+                            :label="data.bought_count.toString()" @click="openBuyers(data)" />
-                        </div>
+                        <span v-else class="text-gray-500">{{ data.bought_count }}</span>
                     </template>
                 </Column>
 

frontend/admin/src/pages/SmsCodeSendPage.vue

@@ -0,0 +1,179 @@
+<script setup>
+import { smsCodeSendService } from '@/api/smsCodeSendService';
+import { formatDate } from '@/utils/date';
+import Button from 'primevue/button';
+import Column from 'primevue/column';
+import DataTable from 'primevue/datatable';
+import Dialog from 'primevue/dialog';
+import InputText from 'primevue/inputtext';
+import ProgressSpinner from 'primevue/progressspinner';
+import Toast from 'primevue/toast';
+import { useToast } from 'primevue/usetoast';
+import { onMounted, ref } from 'vue';
+
+const toast = useToast();
+
+const phone = ref('');
+const loading = ref(false);
+const searchTimeout = ref(null);
+
+const manualDialogVisible = ref(false);
+const manualPhone = ref('');
+const manualCode = ref('');
+const manualSaving = ref(false);
+
+const records = ref({
+    items: [],
+    total: 0,
+    page: 1,
+    limit: 10
+});
+
+const first = ref(0);
+const rows = ref(10);
+
+const fetchRecords = async () => {
+    loading.value = true;
+    try {
+        const currentPage = (first.value / rows.value) + 1;
+        const resp = await smsCodeSendService.get({
+            page: currentPage,
+            limit: rows.value,
+            phone: phone.value
+        });
+        records.value = resp.data;
+    } catch (error) {
+        console.error('Failed to fetch sms code sends:', error);
+        toast.add({ severity: 'error', summary: '错误', detail: '加载短信验证码记录失败', life: 3000 });
+    } finally {
+        loading.value = false;
+    }
+};
+
+const onPage = (event) => {
+    first.value = event.first;
+    rows.value = event.rows;
+    fetchRecords();
+};
+
+const onSearch = () => {
+    if (searchTimeout.value) {
+        clearTimeout(searchTimeout.value);
+    }
+    searchTimeout.value = setTimeout(() => {
+        first.value = 0;
+        fetchRecords();
+    }, 300);
+};
+
+onMounted(() => {
+    fetchRecords();
+});
+
+const gen4Digits = () => {
+    return String(Math.floor(Math.random() * 10000)).padStart(4, '0');
+};
+
+const openManualDialog = () => {
+    manualPhone.value = '';
+    manualCode.value = gen4Digits();
+    manualDialogVisible.value = true;
+};
+
+const regenerateCode = () => {
+    manualCode.value = gen4Digits();
+};
+
+const submitManualSet = async () => {
+    manualSaving.value = true;
+    try {
+        const resp = await smsCodeSendService.manualSet({
+            phone: manualPhone.value,
+            code: manualCode.value
+        });
+        toast.add({ severity: 'success', summary: '成功', detail: `已设置验证码：${resp.data.code}`, life: 3000 });
+        manualDialogVisible.value = false;
+        fetchRecords();
+    } catch (error) {
+        console.error('Failed to manual set sms code:', error);
+        toast.add({ severity: 'error', summary: '错误', detail: '设置验证码失败', life: 3000 });
+    } finally {
+        manualSaving.value = false;
+    }
+};
+</script>
+
+<template>
+    <Toast />
+
+    <Dialog v-model:visible="manualDialogVisible" modal header="手动设置认证码" :style="{ width: '420px' }">
+        <div class="space-y-3">
+            <div>
+                <label class="block text-sm font-medium text-gray-700 mb-1">手机号</label>
+                <InputText v-model="manualPhone" class="w-full" placeholder="请输入 11 位手机号" inputmode="numeric"
+                    maxlength="11" />
+            </div>
+            <div>
+                <label class="block text-sm font-medium text-gray-700 mb-1">验证码</label>
+                <div class="flex gap-2">
+                    <InputText v-model="manualCode" class="flex-1" readonly />
+                    <Button label="生成" icon="pi pi-refresh" severity="secondary" @click="regenerateCode" />
+                </div>
+                <div class="text-xs text-gray-500 mt-1">有效期 5 分钟</div>
+            </div>
+        </div>
+
+        <template #footer>
+            <div class="flex justify-end gap-2">
+                <Button label="取消" text @click="manualDialogVisible = false" />
+                <Button label="设置" severity="success" :loading="manualSaving" @click="submitManualSet" />
+            </div>
+        </template>
+    </Dialog>
+
+    <div class="w-full">
+        <div class="flex justify-between items-center mb-6">
+            <h1 class="text-2xl font-semibold text-gray-800">短信认证</h1>
+            <Button label="手动设置认证码" icon="pi pi-key" severity="success" @click="openManualDialog" />
+        </div>
+
+        <div class="card">
+            <div class="pb-10 flex gap-3 items-center">
+                <InputText v-model="phone" placeholder="按手机号筛选..." class="flex-1" @input="onSearch" />
+            </div>
+
+            <DataTable :value="records.items" :paginator="true" :rows="rows" :totalRecords="records.total"
+                :loading="loading" :lazy="true" :first="first" @page="onPage"
+                paginatorTemplate="FirstPageLink PrevPageLink PageLinks NextPageLink LastPageLink CurrentPageReport RowsPerPageDropdown"
+                :rowsPerPageOptions="[10, 25, 50]"
+                currentPageReportTemplate="显示第 {first} 到 {last} 条，共 {totalRecords} 条结果" dataKey="id" stripedRows
+                removableSort class="p-datatable-sm" responsiveLayout="scroll">
+
+                <template #empty>
+                    <div class="text-center p-4">暂无短信验证码记录。</div>
+                </template>
+
+                <template #loading>
+                    <div class="flex flex-col items-center justify-center p-4">
+                        <ProgressSpinner style="width:50px;height:50px" />
+                        <span class="mt-2">加载短信验证码记录...</span>
+                    </div>
+                </template>
+
+                <Column field="id" header="ID" sortable></Column>
+                <Column field="phone" header="手机号" sortable></Column>
+                <Column field="code" header="验证码" sortable></Column>
+                <Column field="sent_at" header="发送时间" sortable>
+                    <template #body="{ data }">
+                        {{ formatDate(data.sent_at) }}
+                    </template>
+                </Column>
+                <Column field="expires_at" header="过期时间" sortable>
+                    <template #body="{ data }">
+                        {{ formatDate(data.expires_at) }}
+                    </template>
+                </Column>
+            </DataTable>
+        </div>
+    </div>
+</template>

frontend/admin/src/pages/UserDetail.vue

@@ -3,8 +3,6 @@ import { userService } from '@/api/userService';
 import { formatDate } from '@/utils/date';
 import Badge from 'primevue/badge';
 import Button from 'primevue/button';
-import Column from 'primevue/column';
-import DataTable from 'primevue/datatable';
 import ProgressSpinner from 'primevue/progressspinner';
 import { onMounted, ref } from 'vue';
 import { useRoute, useRouter } from 'vue-router';
@@ -13,12 +11,6 @@ const route = useRoute();
 const router = useRouter();
 const loading = ref(false);
 const user = ref(null);
-const userArticles = ref([]);
-const totalArticles = ref(0);
-const lazyParams = ref({
-    page: 1,
-    limit: 10
-});
 
 const fetchUserDetail = async () => {
     loading.value = true;
@@ -32,42 +24,15 @@ const fetchUserDetail = async () => {
     }
 };
 
-const fetchUserArticles = async () => {
-    try {
-        const response = await userService.getUserArticles(
-            route.params.id,
-            lazyParams.value.page,
-            lazyParams.value.limit
-        );
-        userArticles.value = response.data.items;
-        totalArticles.value = response.data.total;
-    } catch (error) {
-        console.error('Failed to fetch user articles:', error);
-    }
-};
-
 const handleBack = () => {
     router.push('/users');
 };
 
-const onPage = (event) => {
-    lazyParams.value = {
-        page: event.page + 1,
-        limit: event.rows
-    };
-    fetchUserArticles();
-};
-
 onMounted(() => {
     fetchUserDetail();
-    fetchUserArticles();
 });
 
 
-
-const formatPrice = (price) => {
-    return (price / 100).toFixed(2);
-};
 </script>
 
 <template>
@@ -121,25 +86,6 @@ const formatPrice = (price) => {
                 </div>
             </div>
 
-            <!-- 用户购买的曲谱列表 -->
-            <div class="card">
-                <h3 class="text-xl font-semibold mb-4">购买的曲谱</h3>
-                <DataTable :value="userArticles" stripedRows class="p-datatable-sm" responsiveLayout="scroll"
-                    :lazy="true" :totalRecords="totalArticles" :rows="lazyParams.limit" :loading="loading"
-                    @page="onPage" paginator :rows-per-page-options="[10, 20, 50]">
-                    <Column field="title" header="标题"></Column>
-                    <Column field="price" header="价格">
-                        <template #body="{ data }">
-                            &yen; {{ formatPrice(data.price) }}
-                        </template>
-                    </Column>
-                    <Column field="bought_at" header="购买时间">
-                        <template #body="{ data }">
-                            {{ formatDate(data.bought_at) }}
-                        </template>
-                    </Column>
-                </DataTable>
-            </div>
         </div>
     </div>
 </template>

frontend/admin/src/pages/UserPage.vue

@@ -7,6 +7,7 @@ import Column from 'primevue/column';
 import ConfirmDialog from 'primevue/confirmdialog';
 import DataTable from 'primevue/datatable';
 import Dialog from 'primevue/dialog';
+import Dropdown from 'primevue/dropdown';
 import InputText from 'primevue/inputtext';
 import ProgressSpinner from 'primevue/progressspinner';
 import Toast from 'primevue/toast';
@@ -25,6 +26,12 @@ const filters = ref({
     status: { value: null, matchMode: 'equals' }
 });
 
+const boughtFilterOptions = ref([
+    { name: '全部用户', value: false },
+    { name: '仅已购用户', value: true }
+]);
+const onlyBought = ref(false);
+
 // Table state
 const users = ref({
     items: [],
@@ -42,6 +49,19 @@ const phoneSaving = ref(false);
 const phoneTargetUser = ref(null);
 const phoneInput = ref('');
 
+const createDialogVisible = ref(false);
+const createSaving = ref(false);
+const createPhoneInput = ref('');
+const createUsernameInput = ref('');
+
+const articlesDialogVisible = ref(false);
+const articlesLoading = ref(false);
+const articlesUser = ref(null);
+const articlesItems = ref([]);
+const articlesFirst = ref(0);
+const articlesRows = ref(10);
+const articlesTotal = ref(0);
+
 const fetchUsers = async () => {
     loading.value = true;
     try {
@@ -50,7 +70,8 @@ const fetchUsers = async () => {
         const response = await userService.getUsers({
             page: currentPage,
             limit: rows.value,
-            keyword: globalFilterValue.value
+            keyword: globalFilterValue.value,
+            onlyBought: onlyBought.value
         });
         users.value = response.data;
     } catch (error) {
@@ -114,6 +135,53 @@ const openPhoneDialog = (user) => {
 
 const normalizePhone = (v) => v.toString().replace(/\D/g, '').slice(0, 11);
 
+const openCreateDialog = () => {
+    createPhoneInput.value = '';
+    createUsernameInput.value = '';
+    createDialogVisible.value = true;
+};
+
+const formatMoney = (cents) => `¥${(cents / 100).toFixed(2)}`;
+
+const formatBoughtPrice = (priceCents) => {
+    if (priceCents < 0) return '赠送';
+    return formatMoney(priceCents);
+};
+
+const fetchUserArticles = async () => {
+    if (!articlesUser.value) return;
+    articlesLoading.value = true;
+    try {
+        const currentPage = (articlesFirst.value / articlesRows.value) + 1;
+        const response = await userService.getUserArticles(
+            articlesUser.value.id,
+            currentPage,
+            articlesRows.value
+        );
+        articlesItems.value = response.data.items || [];
+        articlesTotal.value = response.data.total || 0;
+    } catch (error) {
+        console.error('Failed to fetch user articles:', error);
+        toast.add({ severity: 'error', summary: '错误', detail: '加载购买作品失败', life: 3000 });
+    } finally {
+        articlesLoading.value = false;
+    }
+};
+
+const openUserArticles = async (user) => {
+    if (!user || !user.bought_count || user.bought_count <= 0) return;
+    articlesUser.value = user;
+    articlesFirst.value = 0;
+    articlesDialogVisible.value = true;
+    await fetchUserArticles();
+};
+
+const onArticlesPage = (event) => {
+    articlesFirst.value = event.first;
+    articlesRows.value = event.rows;
+    fetchUserArticles();
+};
+
 const savePhone = async () => {
     if (!phoneTargetUser.value) return;
     const phone = normalizePhone(phoneInput.value);
@@ -136,14 +204,89 @@ const savePhone = async () => {
     }
 };
 
+const createUser = async () => {
+    const phone = normalizePhone(createPhoneInput.value);
+    if (phone.length !== 11) {
+        toast.add({ severity: 'error', summary: '错误', detail: '手机号必须为 11 位数字', life: 3000 });
+        return;
+    }
+
+    createSaving.value = true;
+    try {
+        const username = createUsernameInput.value.trim();
+        await userService.createUser({
+            phone,
+            ...(username ? { username } : {})
+        });
+        toast.add({ severity: 'success', summary: '成功', detail: '用户已创建', life: 3000 });
+        createDialogVisible.value = false;
+        first.value = 0;
+        await fetchUsers();
+    } catch (error) {
+        console.error('Failed to create user:', error);
+        toast.add({ severity: 'error', summary: '错误', detail: error?.response?.data?.message || '创建用户失败', life: 3000 });
+    } finally {
+        createSaving.value = false;
+    }
+};
+
 onMounted(() => {
     fetchUsers();
 });
+
+const onOnlyBoughtChange = () => {
+    first.value = 0;
+    fetchUsers();
+};
 </script>
 
 <template>
     <Toast />
     <ConfirmDialog />
+
+    <Dialog v-model:visible="articlesDialogVisible" modal header="已购作品" :style="{ width: '80vw' }">
+        <div class="flex flex-col gap-4">
+            <div class="text-sm text-gray-600" v-if="articlesUser">
+                用户：{{ articlesUser.username }}（ID: {{ articlesUser.id }}）
+            </div>
+
+            <DataTable :value="articlesItems" :loading="articlesLoading" :paginator="true" :rows="articlesRows"
+                :totalRecords="articlesTotal" :lazy="true" :first="articlesFirst" @page="onArticlesPage"
+                dataKey="id" class="p-datatable-sm" responsiveLayout="scroll" style="max-height: 60vh" scrollable>
+                <template #empty>
+                    <div class="text-center p-4">暂无购买记录</div>
+                </template>
+
+                <template #loading>
+                    <div class="flex flex-col items-center justify-center p-4">
+                        <ProgressSpinner style="width:50px;height:50px" />
+                        <span class="mt-2">加载购买数据...</span>
+                    </div>
+                </template>
+
+                <Column field="title" header="标题" />
+
+                <Column field="price" header="购买价格">
+                    <template #body="{ data }">
+                        {{ formatBoughtPrice(data.price) }}
+                    </template>
+                </Column>
+
+                <Column field="bought_at" header="购买时间">
+                    <template #body="{ data }">
+                        {{ formatDate(data.bought_at) }}
+                    </template>
+                </Column>
+            </DataTable>
+        </div>
+
+        <template #footer>
+            <div class="flex justify-end gap-2">
+                <Button label="关闭" text @click="articlesDialogVisible = false" />
+            </div>
+        </template>
+    </Dialog>
+
     <Dialog v-model:visible="phoneDialogVisible" modal header="设置手机号" :style="{ width: '420px' }">
         <div class="space-y-3">
             <div class="text-sm text-gray-600" v-if="phoneTargetUser">
@@ -164,13 +307,37 @@ onMounted(() => {
         </template>
     </Dialog>
 
+    <Dialog v-model:visible="createDialogVisible" modal header="添加用户" :style="{ width: '420px' }">
+        <div class="space-y-3">
+            <div>
+                <label class="block text-sm font-medium text-gray-700 mb-1">手机号（必填）</label>
+                <InputText v-model="createPhoneInput" class="w-full" placeholder="请输入 11 位手机号" inputmode="numeric"
+                    maxlength="11" @input="(e) => createPhoneInput = normalizePhone(e.target.value)" />
+            </div>
+            <div>
+                <label class="block text-sm font-medium text-gray-700 mb-1">用户昵称（可选）</label>
+                <InputText v-model="createUsernameInput" class="w-full" placeholder="请输入用户昵称" />
+            </div>
+        </div>
+
+        <template #footer>
+            <div class="flex justify-end gap-2">
+                <Button label="取消" text @click="createDialogVisible = false" />
+                <Button label="创建" severity="success" :loading="createSaving" @click="createUser" />
+            </div>
+        </template>
+    </Dialog>
+
     <div class="w-full">
         <div class="flex justify-between items-center mb-6">
             <h1 class="text-2xl font-semibold text-gray-800">用户列表</h1>
+            <Button label="添加用户" icon="pi pi-plus" severity="success" @click="openCreateDialog" />
         </div>
 
         <div class="card">
-            <div class="pb-10 flex">
+            <div class="pb-10 flex gap-3 items-center">
+                <Dropdown v-model="onlyBought" :options="boughtFilterOptions" optionLabel="name" optionValue="value"
+                    class="w-48" @change="onOnlyBoughtChange" />
                 <InputText v-model="globalFilterValue" placeholder="搜索用户..." class="flex-1" @input="onSearch" />
             </div>
 
@@ -221,6 +388,14 @@ onMounted(() => {
 
                 <Column field="phone" header="Phone" sortable></Column>
 
+                <Column field="bought_count" header="购买数量" sortable>
+                    <template #body="{ data }">
+                        <Button v-if="data.bought_count > 0" text severity="info" class="p-0"
+                            :label="data.bought_count.toString()" @click="openUserArticles(data)" />
+                        <span v-else class="text-gray-500">{{ data.bought_count || 0 }}</span>
+                    </template>
+                </Column>
+
                 <Column field="status" header="状态" sortable>
                     <template #body="{ data }">
                         <Badge :value="data.status === 0 ? '活跃' : '禁用'"

frontend/admin/src/router.js

@@ -52,6 +52,11 @@ const routes = [
         name: 'Orders',
         component: () => import('./pages/OrderPage.vue'),
     },
+    {
+        path: '/sms-code-sends',
+        name: 'SmsCodeSends',
+        component: () => import('./pages/SmsCodeSendPage.vue'),
+    },
     {
         path: '/login',
         name: 'Login',