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

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
-// @Bind user local
+//
+//	@Router	/wechats/js-sdk [get]
+//	@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/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,
-			medias:      medias,
-			middlewares: middlewares,
-			orders:      orders,
-			posts:       posts,
-			statistics:  statistics,
-			uploads:     uploads,
-			users:       users,
+			auth:         auth,
+			medias:       medias,
+			middlewares:  middlewares,
+			orders:       orders,
+			posts:        posts,
+			smsCodeSends: smsCodeSends,
+			statistics:   statistics,
+			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
-	medias     *medias
-	orders     *orders
-	posts      *posts
-	statistics *statistics
-	uploads    *uploads
-	users      *users
+	auth         *auth
+	medias       *medias
+	orders       *orders
+	posts        *posts
+	smsCodeSends *smsCodeSends
+	statistics   *statistics
+	uploads      *uploads
+	users        *users
 }
 
 // Prepare initializes the routes provider with logging configuration.
@@ -149,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(
@@ -173,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

@@ -92,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	调整用户余额
@@ -123,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/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/services/db.go

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

backend_v1/app/services/users.go

@@ -55,7 +55,8 @@ func (m *users) List(
 		keyword = strings.TrimSpace(*filter.Keyword)
 		query = query.
 			Where(tbl.Phone.Like(database.WrapLike(keyword))).
-			Or(tbl.Username.Like(database.WrapLike(keyword)))
+			Or(tbl.Username.Like(database.WrapLike(keyword))).
+			Or(tbl.OpenID.Eq(keyword))
 
 		if id, err := strconv.ParseInt(keyword, 10, 64); err == nil && id > 0 {
 			query = query.Or(tbl.ID.Eq(id))
@@ -358,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)
@@ -391,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
 }
 
@@ -477,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/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)
-	MediumQuery   *mediumQuery
-	OrderQuery    *orderQuery
-	PostQuery     *postQuery
-	UserQuery     *userQuery
-	UserPostQuery *userPostQuery
+	Q                = new(Query)
+	MediumQuery      *mediumQuery
+	OrderQuery       *orderQuery
+	PostQuery        *postQuery
+	SmsCodeSendQuery *smsCodeSendQuery
+	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,
-		Medium:   newMedium(db, opts...),
-		Order:    newOrder(db, opts...),
-		Post:     newPost(db, opts...),
-		User:     newUser(db, opts...),
-		UserPost: newUserPost(db, opts...),
+		db:          db,
+		Medium:      newMedium(db, opts...),
+		Order:       newOrder(db, opts...),
+		Post:        newPost(db, opts...),
+		SmsCodeSend: newSmsCodeSend(db, opts...),
+		User:        newUser(db, opts...),
+		UserPost:    newUserPost(db, opts...),
 	}
 }
 
 type Query struct {
 	db *gorm.DB
 
-	Medium   mediumQuery
-	Order    orderQuery
-	Post     postQuery
-	User     userQuery
-	UserPost userPostQuery
+	Medium      mediumQuery
+	Order       orderQuery
+	Post        postQuery
+	SmsCodeSend smsCodeSendQuery
+	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,
-		Medium:   q.Medium.clone(db),
-		Order:    q.Order.clone(db),
-		Post:     q.Post.clone(db),
-		User:     q.User.clone(db),
-		UserPost: q.UserPost.clone(db),
+		db:          db,
+		Medium:      q.Medium.clone(db),
+		Order:       q.Order.clone(db),
+		Post:        q.Post.clone(db),
+		SmsCodeSend: q.SmsCodeSend.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,
-		Medium:   q.Medium.replaceDB(db),
-		Order:    q.Order.replaceDB(db),
-		Post:     q.Post.replaceDB(db),
-		User:     q.User.replaceDB(db),
-		UserPost: q.UserPost.replaceDB(db),
+		db:          db,
+		Medium:      q.Medium.replaceDB(db),
+		Order:       q.Order.replaceDB(db),
+		Post:        q.Post.replaceDB(db),
+		SmsCodeSend: q.SmsCodeSend.replaceDB(db),
+		User:        q.User.replaceDB(db),
+		UserPost:    q.UserPost.replaceDB(db),
 	}
 }
 
 type queryCtx struct {
-	Medium   *mediumQueryDo
-	Order    *orderQueryDo
-	Post     *postQueryDo
-	User     *userQueryDo
-	UserPost *userPostQueryDo
+	Medium      *mediumQueryDo
+	Order       *orderQueryDo
+	Post        *postQueryDo
+	SmsCodeSend *smsCodeSendQueryDo
+	User        *userQueryDo
+	UserPost    *userPostQueryDo
 }
 
 func (q *Query) WithContext(ctx context.Context) *queryCtx {
 	return &queryCtx{
-		Medium:   q.Medium.WithContext(ctx),
-		Order:    q.Order.WithContext(ctx),
-		Post:     q.Post.WithContext(ctx),
-		User:     q.User.WithContext(ctx),
-		UserPost: q.UserPost.WithContext(ctx),
+		Medium:      q.Medium.WithContext(ctx),
+		Order:       q.Order.WithContext(ctx),
+		Post:        q.Post.WithContext(ctx),
+		SmsCodeSend: q.SmsCodeSend.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
+}

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/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

@@ -11,6 +11,12 @@ export const userService = {
             }
         });
     },
+    createUser({ phone, username } = {}) {
+        return httpClient.post('/users', {
+            phone,
+            username
+        });
+    },
     searchUser(id) {
         return httpClient.get(`/users/${id}`);
     },

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/UserPage.vue

@@ -49,6 +49,11 @@ 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);
@@ -130,6 +135,12 @@ 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) => {
@@ -193,6 +204,32 @@ 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();
 });
@@ -270,9 +307,31 @@ const onOnlyBoughtChange = () => {
         </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">

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',