fix: 修复订单 claim 机制状态冲突与 stuck 订单恢复

- 将 OrderStatusClaimed 从 4 改为 6，与 OrderStatusFailed(4) 区分
- releaseClaim 改为返回 error，失败时不再静默吞掉
- claimAndGetOrder 对 status=claimed 返回可重试错误而非静默跳过
- ProcessTask 区分 claimed stuck 错误（触发重试）和其他非 paid 状态（跳过）
- finalizeCouponAndOrder 使用直接 DB 更新 claimed→finished，绕过
  UpdateOrderStatus 的 status<target 守卫（6 > 5 无法通过该条件）
  并显式删除 Redis 缓存避免缓存脏读
- 新增 StuckOrderRecoveryLogic：每 10 分钟扫描超时 claimed 订单，
  重置为 paid 并重新入队激活任务

Co-authored-by: multica-agent <github@multica.ai>

.codex-tmp/inspect_device_cache_roundtrip.go

@@ -0,0 +1,25 @@
+package main
+
+import (
+  "fmt"
+
+  "github.com/perfect-panel/server/internal/config"
+  "github.com/perfect-panel/server/internal/svc"
+  "github.com/perfect-panel/server/pkg/conf"
+)
+
+func main() {
+  var c config.Config
+  conf.MustLoad("/private/tmp/ppanel-local-upload.yaml", &c)
+  ctx := svc.NewServiceContext(c)
+  const key = "cache:auth:method:device"
+  before, _ := ctx.Redis.Get(ctx.DB.Statement.Context, key).Result()
+  fmt.Printf("cache before=%q\n", before)
+  m, err := ctx.AuthModel.FindOneByMethod(ctx.DB.Statement.Context, "device")
+  fmt.Printf("model err=%v enabled_nil=%v", err, m == nil || m.Enabled == nil)
+  if m != nil && m.Enabled != nil { fmt.Printf(" enabled=%v", *m.Enabled) }
+  if m != nil { fmt.Printf(" config=%s", m.Config) }
+  fmt.Println()
+  after, _ := ctx.Redis.Get(ctx.DB.Statement.Context, key).Result()
+  fmt.Printf("cache after=%q\n", after)
+}

.codex-tmp/inspect_device_config.go

@@ -0,0 +1,23 @@
+package main
+
+import (
+  "fmt"
+
+  initpkg "github.com/perfect-panel/server/initialize"
+  "github.com/perfect-panel/server/internal/config"
+  "github.com/perfect-panel/server/internal/svc"
+  "github.com/perfect-panel/server/pkg/conf"
+)
+
+func main() {
+  var c config.Config
+  conf.MustLoad("/private/tmp/ppanel-local-upload.yaml", &c)
+  ctx := svc.NewServiceContext(c)
+  method, err := ctx.AuthModel.FindOneByMethod(ctx.DB.Statement.Context, "device")
+  if err != nil {
+    panic(err)
+  }
+  fmt.Printf("db auth_method.enabled=%v config=%s\n", *method.Enabled, method.Config)
+  initpkg.Device(ctx)
+  fmt.Printf("ctx.Config.Device.Enable=%v SecuritySecret=%q EnableSecurity=%v\n", ctx.Config.Device.Enable, ctx.Config.Device.SecuritySecret, ctx.Config.Device.EnableSecurity)
+}

.codex-tmp/inspect_device_db_vs_model.go

@@ -0,0 +1,36 @@
+package main
+
+import (
+  "fmt"
+
+  "github.com/perfect-panel/server/internal/config"
+  "github.com/perfect-panel/server/internal/svc"
+  "github.com/perfect-panel/server/pkg/conf"
+)
+
+type row struct {
+  ID int64
+  Method string
+  Enabled int
+  Config string
+}
+
+func main() {
+  var c config.Config
+  conf.MustLoad("/private/tmp/ppanel-local-upload.yaml", &c)
+  ctx := svc.NewServiceContext(c)
+
+  var rows []row
+  if err := ctx.DB.Raw("SELECT id, method, enabled, config FROM auth_method WHERE method = ?", "device").Scan(&rows).Error; err != nil {
+    panic(err)
+  }
+  fmt.Printf("raw rows: %+v\n", rows)
+
+  m, err := ctx.AuthModel.FindOneByMethod(ctx.DB.Statement.Context, "device")
+  fmt.Printf("model err=%v\n", err)
+  if err == nil && m != nil && m.Enabled != nil {
+    fmt.Printf("model row: id=%d method=%s enabled=%v config=%s\n", m.Id, m.Method, *m.Enabled, m.Config)
+  } else {
+    fmt.Printf("model row nil or no enabled ptr: %#v\n", m)
+  }
+}

.codex-tmp/inspect_device_gorm.go

@@ -0,0 +1,28 @@
+package main
+
+import (
+  "fmt"
+
+  "github.com/perfect-panel/server/internal/config"
+  authmodel "github.com/perfect-panel/server/internal/model/auth"
+  "github.com/perfect-panel/server/internal/svc"
+  "github.com/perfect-panel/server/pkg/conf"
+)
+
+func main() {
+  var c config.Config
+  conf.MustLoad("/private/tmp/ppanel-local-upload.yaml", &c)
+  ctx := svc.NewServiceContext(c)
+
+  var a1 authmodel.Auth
+  err1 := ctx.DB.Model(&authmodel.Auth{}).Where("method = ?", "device").First(&a1).Error
+  fmt.Printf("gorm direct err=%v enabled_nil=%v", err1, a1.Enabled == nil)
+  if a1.Enabled != nil { fmt.Printf(" enabled=%v", *a1.Enabled) }
+  fmt.Printf(" config=%s\n", a1.Config)
+
+  var a2 authmodel.Auth
+  err2 := ctx.DB.Table("auth_method").Where("method = ?", "device").First(&a2).Error
+  fmt.Printf("gorm table err=%v enabled_nil=%v", err2, a2.Enabled == nil)
+  if a2.Enabled != nil { fmt.Printf(" enabled=%v", *a2.Enabled) }
+  fmt.Printf(" config=%s\n", a2.Config)
+}

.gitea/workflows/docker.yml

@@ -55,7 +55,7 @@ jobs:
           elif [ "${{ github.ref_name }}" = "internal" ]; then
             echo "DOCKER_TAG_SUFFIX=internal" >> $GITHUB_ENV
             echo "CONTAINER_NAME=ppanel-server-internal" >> $GITHUB_ENV
-            echo "DEPLOY_PATH=/root/hifast" >> $GITHUB_ENV
+            echo "DEPLOY_PATH=/root/bindbox" >> $GITHUB_ENV
             echo "为 internal 分支设置开发环境变量"
           else
             echo "DOCKER_TAG_SUFFIX=${{ github.ref_name }}" >> $GITHUB_ENV

apis/admin/log.api

@@ -149,35 +149,6 @@ type (
 		Total int64           `json:"total"`
 		List  []CommissionLog `json:"list"`
 	}
-	OrderRefundLog {
-		OrderId                int64  `json:"order_id"`
-		OrderNo                string `json:"order_no"`
-		OperatorUserId         int64  `json:"operator_user_id"`
-		OperatorAuthIdentifier string `json:"operator_auth_identifier,omitempty"`
-		TargetUserId           int64  `json:"target_user_id"`
-		UserSubscribeId        int64  `json:"user_subscribe_id"`
-		RefererUserId          int64  `json:"referer_user_id,omitempty"`
-		CommissionAmount       int64  `json:"commission_amount"`
-		Reason                 string `json:"reason,omitempty"`
-		OrderStatusBefore      uint8  `json:"order_status_before"`
-		OrderStatusAfter       uint8  `json:"order_status_after"`
-		SubscribeStatusBefore  uint8  `json:"subscribe_status_before"`
-		SubscribeStatusAfter   uint8  `json:"subscribe_status_after"`
-		SubscribeExpireBefore  int64  `json:"subscribe_expire_before"`
-		SubscribeExpireAfter   int64  `json:"subscribe_expire_after"`
-		CommissionBefore       int64  `json:"commission_before"`
-		CommissionAfter        int64  `json:"commission_after"`
-		Timestamp              int64  `json:"timestamp"`
-	}
-	FilterOrderRefundLogRequest {
-		FilterLogParams
-		OrderId int64 `form:"order_id,optional"`
-		UserId  int64 `form:"user_id,optional"`
-	}
-	FilterOrderRefundLogResponse {
-		Total int64            `json:"total"`
-		List  []OrderRefundLog `json:"list"`
-	}
 	GiftLog {
 		Type        uint16 `json:"type"`
 		userId      int64  `json:"user_id"`
@@ -320,10 +291,6 @@ service ppanel {
 	@handler FilterCommissionLog
 	get /commission/list (FilterCommissionLogRequest) returns (FilterCommissionLogResponse)
 
-	@doc "Filter order refund log"
-	@handler FilterOrderRefundLog
-	get /order/refund/list (FilterOrderRefundLogRequest) returns (FilterOrderRefundLogResponse)
-
 	@doc "Filter gift log"
 	@handler FilterGiftLog
 	get /gift/list (FilterGiftLogRequest) returns (FilterGiftLogResponse)

apis/admin/order.api

@@ -33,10 +33,6 @@ type (
 		PaymentId int64  `json:"payment_id,omitempty"`
 		TradeNo   string `json:"trade_no,omitempty"`
 	}
-	RefundOrderRequest {
-		Id     int64  `json:"id" validate:"required"`
-		Reason string `json:"reason,omitempty" validate:"omitempty,max=500"`
-	}
 	ActivateOrderRequest {
 		OrderNo string `json:"order_no" validate:"required"`
 	}
@@ -72,10 +68,6 @@ service ppanel {
 	@handler UpdateOrderStatus
 	put /status (UpdateOrderStatusRequest)
 
-	@doc "Refund order"
-	@handler RefundOrder
-	post /refund (RefundOrderRequest)
-
 	@doc "Manually activate order"
 	@handler ActivateOrder
 	post /activate (ActivateOrderRequest)

apis/admin/user.api

@@ -230,6 +230,23 @@ type (
 		FamilyId int64  `json:"family_id" validate:"required,gt=0"`
 		Reason   string `json:"reason,omitempty"`
 	}
+	GetWithdrawalListRequest {
+		Page   int    `form:"page"`
+		Size   int    `form:"size"`
+		UserId *int64 `form:"user_id,omitempty"`
+		Status *uint8 `form:"status,omitempty"`
+	}
+	GetWithdrawalListResponse {
+		List  []WithdrawalLog `json:"list"`
+		Total int64           `json:"total"`
+	}
+	ApproveWithdrawalRequest {
+		WithdrawalId int64 `json:"withdrawal_id" validate:"required,gt=0"`
+	}
+	RejectWithdrawalRequest {
+		WithdrawalId int64  `json:"withdrawal_id" validate:"required,gt=0"`
+		Reason       string `json:"reason" validate:"required,max=500"`
+	}
 )
 
 @server (
@@ -370,5 +387,16 @@ service ppanel {
 	@doc "Dissolve family"
 	@handler DissolveFamily
 	put /family/dissolve (DissolveFamilyRequest)
-}
 
+	@doc "Get withdrawal list"
+	@handler GetWithdrawalList
+	get /withdrawal/list (GetWithdrawalListRequest) returns (GetWithdrawalListResponse)
+
+	@doc "Approve withdrawal"
+	@handler ApproveWithdrawal
+	post /withdrawal/approve (ApproveWithdrawalRequest)
+
+	@doc "Reject withdrawal"
+	@handler RejectWithdrawal
+	post /withdrawal/reject (RejectWithdrawalRequest)
+}

apis/types.api

@@ -27,6 +27,7 @@ type (
 		EnableLoginNotify     bool             `json:"enable_login_notify"`
 		EnableSubscribeNotify bool             `json:"enable_subscribe_notify"`
 		EnableTradeNotify     bool             `json:"enable_trade_notify"`
+		UseStatus             bool             `json:"use_status"` // Whether to show the "bind email to get free trial" prompt
 		AuthMethods           []UserAuthMethod `json:"auth_methods"`
 		UserDevices           []UserDevice     `json:"user_devices"`
 		Rules                 []string         `json:"rules"`
@@ -426,7 +427,6 @@ type (
 		FeeAmount      int64         `json:"fee_amount"`
 		TradeNo        string        `json:"trade_no"`
 		Status         uint8         `json:"status"`
-		StatusName     string        `json:"status_name,omitempty"`
 		SubscribeId    int64         `json:"subscribe_id"`
 		CreatedAt      int64         `json:"created_at"`
 		UpdatedAt      int64         `json:"updated_at"`
@@ -449,7 +449,6 @@ type (
 		FeeAmount      int64         `json:"fee_amount"`
 		TradeNo        string        `json:"trade_no"`
 		Status         uint8         `json:"status"`
-		StatusName     string        `json:"status_name,omitempty"`
 		SubscribeId    int64         `json:"subscribe_id"`
 		Subscribe      Subscribe     `json:"subscribe"`
 		CreatedAt      int64         `json:"created_at"`
@@ -1006,4 +1005,3 @@ type (
 		ConfigSnapshot map[string]interface{} `json:"config_snapshot,omitempty"`
 	}
 )
-

deploy/aws/ap-east-1/configs/replica-ops.env.example

@@ -17,7 +17,7 @@ REDIS_HOST=127.0.0.1
 REDIS_PORT=6379
 REDIS_PASSWORD=CHANGE_ME
 
-REDIS_SOURCE_HOST=43.198.248.161
+REDIS_SOURCE_HOST=18.163.33.75
 REDIS_SOURCE_PORT=6379
 REDIS_SOURCE_USER=
 REDIS_SOURCE_PASSWORD=CHANGE_ME

doc/tapi-file-upload-zh.md

@@ -0,0 +1,184 @@
+# TAPI 文件上传接入说明
+
+本文档说明 `https://tapi.hifast.biz/v1/public/file/upload` 相关上传接口的推荐接入方式、签名规则与常见排查方式。
+
+## 总览
+
+上传能力包含两类接入方式：
+
+- 推荐方式：`init -> S3 PUT -> complete`
+- 兼容方式：`/upload` multipart 直传
+
+推荐优先使用预签名三段式，因为：
+
+- 现有签名串包含 `BODY_SHA256`
+- `/upload` 是 `multipart/form-data`
+- multipart 原始 body 的签名和调试成本更高
+- `init` 和 `complete` 是 JSON，更适合客户端和 Apifox 调试
+
+## 签名生效逻辑
+
+项目保持现有旧逻辑，不做强制签名改造：
+
+- `Signature.EnableSignature = false` 时：不校验签名
+- `Signature.EnableSignature = true` 且未携带 `X-App-Id` 时：不校验签名，兼容老客户端
+- `Signature.EnableSignature = true` 且携带 `X-App-Id` 时：必须同时携带并校验
+  - `X-Timestamp`
+  - `X-Nonce`
+  - `X-Signature`
+
+这意味着：
+
+- 新客户端建议始终带完整签名头
+- 老客户端如果没有 `X-App-Id`，仍可按旧逻辑访问
+
+## 签名头定义
+
+- `X-App-Id`: 客户端标识，例如 `ios-client`
+- `X-Timestamp`: Unix 秒级时间戳
+- `X-Nonce`: 每次请求唯一随机串
+- `X-Signature`: `HMAC-SHA256` 结果的十六进制小写字符串
+
+## StringToSign 规则
+
+StringToSign 由下面 7 段按换行符 `\n` 拼接：
+
+```text
+METHOD
+PATH
+CANONICAL_QUERY
+BODY_SHA256
+X-App-Id
+X-Timestamp
+X-Nonce
+```
+
+说明：
+
+- `METHOD`：HTTP 方法大写，例如 `POST`
+- `PATH`：请求路径，例如 `/v1/public/file/upload/init`
+- `CANONICAL_QUERY`：按 key 排序后的 query string，没有 query 则为空字符串
+- `BODY_SHA256`：请求体原始字节的 SHA-256 十六进制小写
+- 其余三项直接使用请求头值
+
+签名计算方式：
+
+```text
+signature = hex_lower(HMAC_SHA256(app_secret, string_to_sign))
+```
+
+时间窗与防重放：
+
+- `X-Timestamp` 默认有效时间窗是 300 秒
+- `X-Nonce` 在有效时间窗内不能重复使用
+
+## 推荐接入：预签名三段式
+
+### 1. 初始化上传
+
+请求：
+
+```bash
+curl -X POST 'https://tapi.hifast.biz/v1/public/file/upload/init' \
+  -H 'Accept: application/json, text/plain, */*' \
+  -H 'Content-Type: application/json' \
+  -H 'authorization: your-token' \
+  -H 'X-App-Id: ios-client' \
+  -H 'X-Timestamp: 1778776400' \
+  -H 'X-Nonce: nonce-001' \
+  -H 'X-Signature: your-signature' \
+  -d '{
+    "biz_type": "app-package",
+    "file_name": "demo.zip",
+    "content_type": "application/zip",
+    "size": 123456,
+    "sha256": ""
+  }'
+```
+
+典型返回：
+
+```json
+{
+  "code": 200,
+  "msg": "success",
+  "data": {
+    "file_id": "c29274ee26ab5aa211e0396e",
+    "object_key": "app-upload/app-package/519/2026/05/c29274ee26ab5aa211e0396e_demo.zip",
+    "upload_url": "https://bucket.s3.ap-east-1.amazonaws.com/...",
+    "method": "PUT",
+    "headers": {
+      "Content-Type": "application/zip"
+    },
+    "expired_at": 1778776715
+  }
+}
+```
+
+### 2. 直传 S3
+
+这一步是直接上传二进制文件到 S3，不走业务签名中间件。
+
+```bash
+curl -X PUT 'https://bucket.s3.ap-east-1.amazonaws.com/...' \
+  -H 'Content-Type: application/zip' \
+  --upload-file '/tmp/demo.zip'
+```
+
+说明：
+
+- `Content-Type` 需和 `init` 返回的 `headers.Content-Type` 一致
+- `upload_url` 有过期时间，通常 300 秒
+- 成功时 S3 常见返回 `200` 或 `204`
+
+### 3. 完成上传
+
+```bash
+curl -X POST 'https://tapi.hifast.biz/v1/public/file/upload/complete' \
+  -H 'Accept: application/json, text/plain, */*' \
+  -H 'Content-Type: application/json' \
+  -H 'authorization: your-token' \
+  -H 'X-App-Id: ios-client' \
+  -H 'X-Timestamp: 1778776405' \
+  -H 'X-Nonce: nonce-002' \
+  -H 'X-Signature: your-signature' \
+  -d '{
+    "file_id": "c29274ee26ab5aa211e0396e"
+  }'
+```
+
+## 兼容接入：单接口 multipart 直传
+
+接口：
+
+- `POST /v1/public/file/upload`
+
+表单字段：
+
+- `biz_type`
+- `file`
+
+说明：
+
+- 该接口继续保留，兼容旧客户端
+- 如果请求带了 `X-App-Id`，就按现有逻辑验签
+- 如果没有 `X-App-Id`，仍按旧逻辑放行
+- 如果要给该接口加签，签名时必须对原始 multipart body 计算 `BODY_SHA256`
+
+## 常见错误码
+
+- `200`: 成功
+- `400`: 参数错误
+- `40008`: 缺少签名头
+- `40009`: 签名已过期
+- `40010`: 签名无效
+- `40011`: nonce 重放
+- `10001`: 上传元数据不存在或对象不存在
+
+## 排查建议
+
+- `40008`：确认带了 `X-App-Id` 后，也同时带上 `X-Timestamp / X-Nonce / X-Signature`
+- `40009`：检查客户端时间是否偏差过大
+- `40010`：确认 `PATH`、query 排序、body 原始字节、secret 是否完全一致
+- `40011`：确保每次请求都生成新的 `X-Nonce`
+- `complete` 失败：确认 S3 `PUT` 已成功，且上传大小与 `init.size` 一致

initialize/migrate/database/00001_init_schema.up.sql

@@ -449,7 +449,7 @@ CREATE TABLE IF NOT EXISTS `user_device`
     `subscribe_id` bigint                                                        DEFAULT NULL COMMENT 'Subscribe ID',
     `ip`           varchar(191) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT 'Device Ip.',
     `Identifier`   varchar(191) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT 'Device Identifier.',
-    `user_agent`   varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci  DEFAULT NULL COMMENT 'Device User Agent.',
+    `user_agent`   varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT 'Device User Agent.',
     `online`       tinyint(1) NOT NULL                                           DEFAULT '0' COMMENT 'Online',
     `enabled`      tinyint(1) NOT NULL                                           DEFAULT '1' COMMENT 'EnableDeviceNumber',
     `created_at`   datetime(3)                                                   DEFAULT NULL COMMENT 'Creation Time',

initialize/migrate/database/02141_order_iap_token.down.sql

@@ -1,13 +0,0 @@
--- Remove app_account_token column from order table if it exists
-SET @col_exists = (SELECT COUNT(*) FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = 'order' AND COLUMN_NAME = 'app_account_token');
-SET @sql = IF(@col_exists = 1, 'ALTER TABLE `order` DROP COLUMN `app_account_token`', 'SELECT 1');
-PREPARE stmt FROM @sql;
-EXECUTE stmt;
-DEALLOCATE PREPARE stmt;
-
--- Remove subscription_user_id column from order table if it exists
-SET @col_exists2 = (SELECT COUNT(*) FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = 'order' AND COLUMN_NAME = 'subscription_user_id');
-SET @sql2 = IF(@col_exists2 = 1, 'ALTER TABLE `order` DROP COLUMN `subscription_user_id`', 'SELECT 1');
-PREPARE stmt2 FROM @sql2;
-EXECUTE stmt2;
-DEALLOCATE PREPARE stmt2;

initialize/migrate/database/02150_refund_pending_withdrawals.down.sql

@@ -1,19 +0,0 @@
--- Rollback: re-deduct commission for users with pending (status=0) withdrawals.
--- This re-applies the OLD behaviour where commission is deducted on application.
--- Only run this if you are rolling back to the old code; do NOT run against
--- the new code or commission will be double-deducted on approval.
-
-UPDATE `user` u
-JOIN (
-    SELECT user_id, COALESCE(SUM(amount), 0) AS pending_total
-    FROM user_withdrawal
-    WHERE status = 0
-    GROUP BY user_id
-) p ON u.id = p.user_id
-SET u.commission = u.commission - p.pending_total
-WHERE p.pending_total > 0;
-
--- Remove the migration log entries written by the up migration.
-DELETE FROM system_log
-WHERE type = 3
-  AND content LIKE '%migration: refund pending withdrawal commission (HIF-22)%';

initialize/migrate/database/02150_refund_pending_withdrawals.up.sql

@@ -1,45 +0,0 @@
--- Migration: refund commission for existing pending (status=0) withdrawals
---
--- Under the old logic, commission was deducted when a withdrawal was submitted.
--- Under the new logic, commission is only deducted on approval.
--- This migration refunds the deducted amounts back to each user so that
--- the system is in a consistent state before the new code is deployed.
---
--- Idempotency: the UPDATE only touches rows whose commission would need
--- to increase, and each execution produces the same result because
--- COALESCE(SUM(amount),0) is deterministic given the same pending set.
--- Running this script multiple times is safe only if no new pending
--- withdrawals are created between runs; deploy new code immediately after.
-
--- Step 1: refund commission for all users with pending withdrawals.
-UPDATE `user` u
-JOIN (
-    SELECT user_id, COALESCE(SUM(amount), 0) AS pending_total
-    FROM user_withdrawal
-    WHERE status = 0
-    GROUP BY user_id
-) p ON u.id = p.user_id
-SET u.commission = u.commission + p.pending_total
-WHERE p.pending_total > 0;
-
--- Step 2: write a migration log entry for each refunded user.
-INSERT INTO system_log (type, date, object_id, content, created_at)
-SELECT
-    3 AS type,
-    DATE(NOW()) AS date,
-    p.user_id AS object_id,
-    JSON_OBJECT(
-        'type', 99,
-        'amount', p.pending_total,
-        'order_no', '',
-        'timestamp', UNIX_TIMESTAMP(NOW()) * 1000,
-        'note', 'migration: refund pending withdrawal commission (HIF-22)'
-    ) AS content,
-    NOW() AS created_at
-FROM (
-    SELECT user_id, COALESCE(SUM(amount), 0) AS pending_total
-    FROM user_withdrawal
-    WHERE status = 0
-    GROUP BY user_id
-    HAVING pending_total > 0
-) p;

initialize/migrate/database/02151_order_activation_context.down.sql

@@ -1,2 +0,0 @@
--- Remove activation_context column from order table
-ALTER TABLE `order` DROP COLUMN IF EXISTS `activation_context`;

initialize/migrate/database/02151_order_activation_context.up.sql

@@ -1,6 +0,0 @@
--- Add activation_context column to order table for Redis fallback persistence (idempotent)
-SET @col_exists = (SELECT COUNT(*) FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = 'order' AND COLUMN_NAME = 'activation_context');
-SET @sql = IF(@col_exists = 0, 'ALTER TABLE `order` ADD COLUMN `activation_context` TEXT DEFAULT NULL COMMENT ''Activation context JSON (guest/redemption info for DB fallback)'' AFTER `app_account_token`', 'SELECT 1');
-PREPARE stmt FROM @sql;
-EXECUTE stmt;
-DEALLOCATE PREPARE stmt;

initialize/schema_compat.go

@@ -20,6 +20,14 @@ type schemaColumnPatch struct {
 	ddl    string
 }
 
+type schemaColumnDefinitionPatch struct {
+	table           string
+	column          string
+	dataType        string
+	characterMaxLen *int64
+	ddl             string
+}
+
 func EnsureSchemaCompatibility(ctx *svc.ServiceContext) error {
 	tablePatches := []schemaTablePatch{
 		{
@@ -142,6 +150,17 @@ func EnsureSchemaCompatibility(ctx *svc.ServiceContext) error {
 		},
 	}
 
+	varchar255 := int64(255)
+	columnDefinitionPatches := []schemaColumnDefinitionPatch{
+		{
+			table:           "user_device",
+			column:          "user_agent",
+			dataType:        "varchar",
+			characterMaxLen: &varchar255,
+			ddl:             "ALTER TABLE `user_device` MODIFY COLUMN `user_agent` VARCHAR(255) NULL COMMENT 'Device User Agent.';",
+		},
+	}
+
 	for _, patch := range tablePatches {
 		exists, err := tableExists(ctx.DB, patch.table)
 		if err != nil {
@@ -199,6 +218,27 @@ func EnsureSchemaCompatibility(ctx *svc.ServiceContext) error {
 		logger.Infof("[SchemaCompat] created missing index: %s.%s", patch.table, patch.index)
 	}
 
+	for _, patch := range columnDefinitionPatches {
+		tblExists, err := tableExists(ctx.DB, patch.table)
+		if err != nil {
+			return errors.Wrapf(err, "check table %s failed", patch.table)
+		}
+		if !tblExists {
+			continue
+		}
+		matches, err := columnDefinitionMatches(ctx.DB, patch.table, patch.column, patch.dataType, patch.characterMaxLen)
+		if err != nil {
+			return errors.Wrapf(err, "check column definition %s.%s failed", patch.table, patch.column)
+		}
+		if matches {
+			continue
+		}
+		if err = ctx.DB.Exec(patch.ddl).Error; err != nil {
+			return errors.Wrapf(err, "modify column %s.%s failed", patch.table, patch.column)
+		}
+		logger.Infof("[SchemaCompat] repaired column definition: %s.%s", patch.table, patch.column)
+	}
+
 	return nil
 }
 
@@ -237,6 +277,38 @@ func indexExists(db *gorm.DB, table, index string) (bool, error) {
 	return count > 0, nil
 }
 
+func columnDefinitionMatches(db *gorm.DB, table, column, dataType string, characterMaxLen *int64) (bool, error) {
+	type columnMeta struct {
+		DataType            string
+		CharacterMaximumLen *int64
+	}
+
+	var meta columnMeta
+	err := db.Raw(
+		`SELECT DATA_TYPE AS data_type, CHARACTER_MAXIMUM_LENGTH AS character_maximum_len
+FROM information_schema.COLUMNS
+WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ? AND COLUMN_NAME = ?`,
+		table,
+		column,
+	).Scan(&meta).Error
+	if err != nil {
+		return false, err
+	}
+	if meta.DataType == "" {
+		return false, nil
+	}
+	if meta.DataType != dataType {
+		return false, nil
+	}
+	if characterMaxLen == nil {
+		return true, nil
+	}
+	if meta.CharacterMaximumLen == nil {
+		return false, nil
+	}
+	return *meta.CharacterMaximumLen == *characterMaxLen, nil
+}
+
 func _schemaCompatDebug(table, column string) string {
 	if column == "" {
 		return table

internal/handler/admin/user/approveWithdrawalHandler.go

@@ -0,0 +1,26 @@
+package user
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/perfect-panel/server/internal/logic/admin/user"
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/result"
+)
+
+// Approve withdrawal
+func ApproveWithdrawalHandler(svcCtx *svc.ServiceContext) func(c *gin.Context) {
+	return func(c *gin.Context) {
+		var req types.ApproveWithdrawalRequest
+		_ = c.ShouldBind(&req)
+		validateErr := svcCtx.Validate(&req)
+		if validateErr != nil {
+			result.ParamErrorResult(c, validateErr)
+			return
+		}
+
+		l := user.NewApproveWithdrawalLogic(c.Request.Context(), svcCtx)
+		err := l.ApproveWithdrawal(&req)
+		result.HttpResult(c, nil, err)
+	}
+}

internal/handler/admin/user/getWithdrawalListHandler.go

@@ -1,16 +1,17 @@
-package log
+package user
 
 import (
 	"github.com/gin-gonic/gin"
-	"github.com/perfect-panel/server/internal/logic/admin/log"
+	"github.com/perfect-panel/server/internal/logic/admin/user"
 	"github.com/perfect-panel/server/internal/svc"
 	"github.com/perfect-panel/server/internal/types"
 	"github.com/perfect-panel/server/pkg/result"
 )
 
-func FilterOrderRefundLogHandler(svcCtx *svc.ServiceContext) func(c *gin.Context) {
+// Get withdrawal list
+func GetWithdrawalListHandler(svcCtx *svc.ServiceContext) func(c *gin.Context) {
 	return func(c *gin.Context) {
-		var req types.FilterOrderRefundLogRequest
+		var req types.GetWithdrawalListRequest
 		_ = c.ShouldBind(&req)
 		validateErr := svcCtx.Validate(&req)
 		if validateErr != nil {
@@ -18,8 +19,8 @@ func FilterOrderRefundLogHandler(svcCtx *svc.ServiceContext) func(c *gin.Context
 			return
 		}
 
-		l := log.NewFilterOrderRefundLogLogic(c.Request.Context(), svcCtx)
-		resp, err := l.FilterOrderRefundLog(&req)
+		l := user.NewGetWithdrawalListLogic(c.Request.Context(), svcCtx)
+		resp, err := l.GetWithdrawalList(&req)
 		result.HttpResult(c, resp, err)
 	}
 }

internal/handler/admin/user/rejectWithdrawalHandler.go

@@ -1,16 +1,17 @@
-package order
+package user
 
 import (
 	"github.com/gin-gonic/gin"
-	"github.com/perfect-panel/server/internal/logic/admin/order"
+	"github.com/perfect-panel/server/internal/logic/admin/user"
 	"github.com/perfect-panel/server/internal/svc"
 	"github.com/perfect-panel/server/internal/types"
 	"github.com/perfect-panel/server/pkg/result"
 )
 
-func RefundOrderHandler(svcCtx *svc.ServiceContext) func(c *gin.Context) {
+// Reject withdrawal
+func RejectWithdrawalHandler(svcCtx *svc.ServiceContext) func(c *gin.Context) {
 	return func(c *gin.Context) {
-		var req types.RefundOrderRequest
+		var req types.RejectWithdrawalRequest
 		_ = c.ShouldBind(&req)
 		validateErr := svcCtx.Validate(&req)
 		if validateErr != nil {
@@ -18,8 +19,8 @@ func RefundOrderHandler(svcCtx *svc.ServiceContext) func(c *gin.Context) {
 			return
 		}
 
-		l := order.NewRefundOrderLogic(c.Request.Context(), svcCtx)
-		err := l.RefundOrder(&req)
+		l := user.NewRejectWithdrawalLogic(c.Request.Context(), svcCtx)
+		err := l.RejectWithdrawal(&req)
 		result.HttpResult(c, nil, err)
 	}
 }

internal/handler/routes.go

@@ -250,9 +250,6 @@ func RegisterHandlers(router *gin.Engine, serverCtx *svc.ServiceContext) {
 		// Filter commission log
 		adminLogGroupRouter.GET("/commission/list", adminLog.FilterCommissionLogHandler(serverCtx))
 
-		// Filter order refund log
-		adminLogGroupRouter.GET("/order/refund/list", adminLog.FilterOrderRefundLogHandler(serverCtx))
-
 		// Filter email log
 		adminLogGroupRouter.GET("/email/list", adminLog.FilterEmailLogHandler(serverCtx))
 
@@ -344,9 +341,6 @@ func RegisterHandlers(router *gin.Engine, serverCtx *svc.ServiceContext) {
 		// Update order status
 		adminOrderGroupRouter.PUT("/status", adminOrder.UpdateOrderStatusHandler(serverCtx))
 
-		// Refund order
-		adminOrderGroupRouter.POST("/refund", adminOrder.RefundOrderHandler(serverCtx))
-
 		// Manually activate order
 		adminOrderGroupRouter.POST("/activate", adminOrder.ActivateOrderHandler(serverCtx))
 	}
@@ -713,6 +707,15 @@ func RegisterHandlers(router *gin.Engine, serverCtx *svc.ServiceContext) {
 
 		// Get admin user invite list
 		adminUserGroupRouter.GET("/invite/list", adminUser.GetAdminUserInviteListHandler(serverCtx))
+
+		// Get withdrawal list
+		adminUserGroupRouter.GET("/withdrawal/list", adminUser.GetWithdrawalListHandler(serverCtx))
+
+		// Approve withdrawal
+		adminUserGroupRouter.POST("/withdrawal/approve", adminUser.ApproveWithdrawalHandler(serverCtx))
+
+		// Reject withdrawal
+		adminUserGroupRouter.POST("/withdrawal/reject", adminUser.RejectWithdrawalHandler(serverCtx))
 	}
 
 	authGroupRouter := router.Group("/v1/auth")

internal/logic/admin/log/filterOrderRefundLogLogic.go

@@ -1,77 +0,0 @@
-package log
-
-import (
-	"context"
-
-	modellog "github.com/perfect-panel/server/internal/model/log"
-	"github.com/perfect-panel/server/internal/svc"
-	"github.com/perfect-panel/server/internal/types"
-	"github.com/perfect-panel/server/pkg/logger"
-	"github.com/perfect-panel/server/pkg/xerr"
-	"github.com/pkg/errors"
-)
-
-type FilterOrderRefundLogLogic struct {
-	logger.Logger
-	ctx    context.Context
-	svcCtx *svc.ServiceContext
-}
-
-func NewFilterOrderRefundLogLogic(ctx context.Context, svcCtx *svc.ServiceContext) *FilterOrderRefundLogLogic {
-	return &FilterOrderRefundLogLogic{
-		Logger: logger.WithContext(ctx),
-		ctx:    ctx,
-		svcCtx: svcCtx,
-	}
-}
-
-func (l *FilterOrderRefundLogLogic) FilterOrderRefundLog(req *types.FilterOrderRefundLogRequest) (resp *types.FilterOrderRefundLogResponse, err error) {
-	data, total, err := l.svcCtx.LogModel.FilterSystemLog(l.ctx, &modellog.FilterParams{
-		Page:     req.Page,
-		Size:     req.Size,
-		Data:     req.Date,
-		Search:   req.Search,
-		Type:     modellog.TypeOrderRefund.Uint8(),
-		ObjectID: req.OrderId,
-	})
-	if err != nil {
-		l.Errorw("Query order refund log failed", logger.Field("error", err.Error()))
-		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "Query order refund log failed")
-	}
-
-	var list []types.OrderRefundLog
-	for _, item := range data {
-		var content modellog.OrderRefund
-		if err := content.Unmarshal([]byte(item.Content)); err != nil {
-			l.Errorf("unmarshal order refund log content failed: %v", err.Error())
-			continue
-		}
-		if req.UserId > 0 && content.TargetUserId != req.UserId && content.RefererUserId != req.UserId && content.OperatorUserId != req.UserId {
-			continue
-		}
-		list = append(list, types.OrderRefundLog{
-			OrderId:                content.OrderId,
-			OrderNo:                content.OrderNo,
-			OperatorUserId:         content.OperatorUserId,
-			OperatorAuthIdentifier: content.OperatorAuthIdentifier,
-			TargetUserId:           content.TargetUserId,
-			UserSubscribeId:        content.UserSubscribeId,
-			RefererUserId:          content.RefererUserId,
-			CommissionAmount:       content.CommissionAmount,
-			Reason:                 content.Reason,
-			OrderStatusBefore:      content.OrderStatusBefore,
-			OrderStatusAfter:       content.OrderStatusAfter,
-			SubscribeStatusBefore:  content.SubscribeStatusBefore,
-			SubscribeStatusAfter:   content.SubscribeStatusAfter,
-			SubscribeExpireBefore:  content.SubscribeExpireBefore,
-			SubscribeExpireAfter:   content.SubscribeExpireAfter,
-			CommissionBefore:       content.CommissionBefore,
-			CommissionAfter:        content.CommissionAfter,
-			Timestamp:              content.Timestamp,
-		})
-	}
-	return &types.FilterOrderRefundLogResponse{
-		Total: total,
-		List:  list,
-	}, nil
-}

internal/logic/admin/order/getOrderListLogic.go

@@ -35,28 +35,6 @@ func (l *GetOrderListLogic) GetOrderList(req *types.GetOrderListRequest) (resp *
 	resp = &types.GetOrderListResponse{}
 	resp.List = make([]types.Order, 0)
 	tool.DeepCopy(&resp.List, list)
-	for i := range resp.List {
-		resp.List[i].StatusName = orderStatusName(resp.List[i].Status)
-	}
 	resp.Total = total
 	return
 }
-
-func orderStatusName(status uint8) string {
-	switch status {
-	case 1:
-		return "pending"
-	case 2:
-		return "paid"
-	case 3:
-		return "closed"
-	case 4:
-		return "failed"
-	case 5:
-		return "finished"
-	case 6:
-		return "refunded"
-	default:
-		return "unknown"
-	}
-}

internal/logic/admin/order/refundOrderLogic.go

@@ -1,298 +0,0 @@
-package order
-
-import (
-	"context"
-	"fmt"
-	"strings"
-	"time"
-
-	"github.com/perfect-panel/server/internal/model/log"
-	modelorder "github.com/perfect-panel/server/internal/model/order"
-	modeluser "github.com/perfect-panel/server/internal/model/user"
-	"github.com/perfect-panel/server/internal/svc"
-	"github.com/perfect-panel/server/internal/types"
-	"github.com/perfect-panel/server/pkg/constant"
-	"github.com/perfect-panel/server/pkg/logger"
-	"github.com/perfect-panel/server/pkg/xerr"
-	"github.com/pkg/errors"
-	"gorm.io/gorm"
-	"gorm.io/gorm/clause"
-)
-
-const (
-	orderStatusRefunded = 6
-)
-
-type RefundOrderLogic struct {
-	logger.Logger
-	ctx    context.Context
-	svcCtx *svc.ServiceContext
-}
-
-func NewRefundOrderLogic(ctx context.Context, svcCtx *svc.ServiceContext) *RefundOrderLogic {
-	return &RefundOrderLogic{
-		Logger: logger.WithContext(ctx),
-		ctx:    ctx,
-		svcCtx: svcCtx,
-	}
-}
-
-func (l *RefundOrderLogic) RefundOrder(req *types.RefundOrderRequest) error {
-	operator, ok := l.ctx.Value(constant.CtxKeyUser).(*modeluser.User)
-	if !ok {
-		return errors.Wrapf(xerr.NewErrCode(xerr.InvalidAccess), "Invalid Access")
-	}
-
-	reason := strings.TrimSpace(req.Reason)
-	var cachesToClear []*modeluser.Subscribe
-	var planCacheIDs []int64
-	var userCacheTargets []*modeluser.User
-
-	err := l.svcCtx.DB.WithContext(l.ctx).Transaction(func(tx *gorm.DB) error {
-		var orderInfo modelorder.Order
-		if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).
-			Model(&modelorder.Order{}).
-			Where("id = ?", req.Id).
-			First(&orderInfo).Error; err != nil {
-			if errors.Is(err, gorm.ErrRecordNotFound) {
-				return errors.Wrapf(xerr.NewErrCode(xerr.OrderNotExist), "order %d not found", req.Id)
-			}
-			return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "query order failed: %v", err)
-		}
-
-		if orderInfo.Status == orderStatusRefunded {
-			return errors.Wrapf(xerr.NewErrCode(xerr.OrderAlreadyRefunded), "order %d already refunded", orderInfo.Id)
-		}
-		if orderInfo.Status != 2 && orderInfo.Status != 5 {
-			return errors.Wrapf(xerr.NewErrCode(xerr.OrderStatusError), "order %d status %d is not refundable", orderInfo.Id, orderInfo.Status)
-		}
-
-		userSub, err := l.lockRefundTargetSubscription(tx, &orderInfo)
-		if err != nil {
-			return err
-		}
-
-		orderStatusBefore := orderInfo.Status
-		subStatusBefore := userSub.Status
-		subExpireBefore := userSub.ExpireTime
-		now := time.Now()
-
-		referer, commissionAmount, err := l.lockCommissionSource(tx, orderInfo.OrderNo, orderInfo.Commission)
-		if err != nil {
-			return err
-		}
-
-		var commissionBefore int64
-		var commissionAfter int64
-		if referer != nil {
-			commissionBefore = referer.Commission
-			commissionAfter = referer.Commission - commissionAmount
-			if err := tx.Model(&modeluser.User{}).
-				Where("id = ?", referer.Id).
-				UpdateColumn("commission", gorm.Expr("commission - ?", commissionAmount)).Error; err != nil {
-				return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "refund commission failed: %v", err)
-			}
-
-			commissionLog := log.Commission{
-				Type:      log.CommissionTypeRefund,
-				Amount:    -commissionAmount,
-				OrderNo:   orderInfo.OrderNo,
-				Timestamp: now.UnixMilli(),
-			}
-			content, marshalErr := commissionLog.Marshal()
-			if marshalErr != nil {
-				return errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "marshal commission refund log failed: %v", marshalErr)
-			}
-			if err := tx.Model(&log.SystemLog{}).Create(&log.SystemLog{
-				Type:      log.TypeCommission.Uint8(),
-				Date:      now.Format(time.DateOnly),
-				ObjectID:  referer.Id,
-				Content:   string(content),
-				CreatedAt: now,
-			}).Error; err != nil {
-				return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "insert commission refund log failed: %v", err)
-			}
-			referer.Commission = commissionAfter
-			userCacheTargets = append(userCacheTargets, referer)
-		}
-
-		if err := tx.Model(&modelorder.Order{}).
-			Where("id = ? AND status IN ?", orderInfo.Id, []int{2, 5}).
-			Update("status", orderStatusRefunded).Error; err != nil {
-			return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "refund order status update failed: %v", err)
-		}
-		orderInfo.Status = orderStatusRefunded
-
-		userSub.Status = 3
-		userSub.ExpireTime = now.Add(-time.Second)
-		userSub.FinishedAt = &now
-		if err := tx.Model(&modeluser.Subscribe{}).
-			Where("id = ?", userSub.Id).
-			Updates(map[string]interface{}{
-				"status":      userSub.Status,
-				"expire_time": userSub.ExpireTime,
-				"finished_at": userSub.FinishedAt,
-			}).Error; err != nil {
-			return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "update subscription failed: %v", err)
-		}
-
-		refundLog, err := l.buildRefundAuditLog(operator, &orderInfo, userSub, referer, commissionAmount, reason, orderStatusBefore, subStatusBefore, subExpireBefore, commissionBefore, commissionAfter, now)
-		if err != nil {
-			return err
-		}
-		logContent, err := refundLog.Marshal()
-		if err != nil {
-			return errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "marshal refund audit log failed: %v", err)
-		}
-		if err := tx.Model(&log.SystemLog{}).Create(&log.SystemLog{
-			Type:      log.TypeOrderRefund.Uint8(),
-			Date:      now.Format(time.DateOnly),
-			ObjectID:  orderInfo.Id,
-			Content:   string(logContent),
-			CreatedAt: now,
-		}).Error; err != nil {
-			return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "insert refund audit log failed: %v", err)
-		}
-
-		cachesToClear = append(cachesToClear, userSub)
-		if userSub.SubscribeId > 0 {
-			planCacheIDs = append(planCacheIDs, userSub.SubscribeId)
-		}
-		if orderInfo.UserId > 0 {
-			orderUser := &modeluser.User{Id: orderInfo.UserId}
-			userCacheTargets = append(userCacheTargets, orderUser)
-		}
-		return nil
-	})
-	if err != nil {
-		l.Errorw("[RefundOrder] refund failed", logger.Field("error", err.Error()), logger.Field("order_id", req.Id))
-		return err
-	}
-
-	if len(cachesToClear) > 0 {
-		if clearErr := l.svcCtx.UserModel.ClearSubscribeCache(l.ctx, cachesToClear...); clearErr != nil {
-			l.Errorw("[RefundOrder] clear subscribe cache failed", logger.Field("error", clearErr.Error()), logger.Field("order_id", req.Id))
-		}
-	}
-	for _, subscribeID := range planCacheIDs {
-		if clearErr := l.svcCtx.SubscribeModel.ClearCache(l.ctx, subscribeID); clearErr != nil {
-			l.Errorw("[RefundOrder] clear subscribe cache failed", logger.Field("error", clearErr.Error()), logger.Field("subscribe_id", subscribeID))
-		}
-	}
-	if len(userCacheTargets) > 0 {
-		if clearErr := l.svcCtx.UserModel.ClearUserCache(l.ctx, userCacheTargets...); clearErr != nil {
-			l.Errorw("[RefundOrder] clear user cache failed", logger.Field("error", clearErr.Error()))
-		}
-	}
-	return nil
-}
-
-func (l *RefundOrderLogic) lockRefundTargetSubscription(tx *gorm.DB, orderInfo *modelorder.Order) (*modeluser.Subscribe, error) {
-	var userSub modeluser.Subscribe
-	err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).
-		Model(&modeluser.Subscribe{}).
-		Where("order_id = ?", orderInfo.Id).
-		First(&userSub).Error
-	if err == nil {
-		return &userSub, nil
-	}
-	if !errors.Is(err, gorm.ErrRecordNotFound) {
-		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "query refund subscription failed: %v", err)
-	}
-
-	if orderInfo.Type != 2 {
-		return nil, errors.Wrapf(xerr.NewErrCode(xerr.OrderRefundNoSubscription), "order %d has no linked subscription", orderInfo.Id)
-	}
-
-	if orderInfo.ParentId == 0 {
-		return nil, errors.Wrapf(xerr.NewErrCode(xerr.OrderRefundNoSubscription), "renewal order %d has no parent order", orderInfo.Id)
-	}
-
-	err = tx.Clauses(clause.Locking{Strength: "UPDATE"}).
-		Model(&modeluser.Subscribe{}).
-		Where("order_id = ?", orderInfo.ParentId).
-		First(&userSub).Error
-	if err != nil {
-		if errors.Is(err, gorm.ErrRecordNotFound) {
-			return nil, errors.Wrapf(xerr.NewErrCode(xerr.OrderRefundNoSubscription), "renewal order %d parent subscription not found", orderInfo.Id)
-		}
-		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "query renewal subscription failed: %v", err)
-	}
-	return &userSub, nil
-}
-
-func (l *RefundOrderLogic) lockCommissionSource(tx *gorm.DB, orderNo string, orderCommission int64) (*modeluser.User, int64, error) {
-	var commissionLogs []log.SystemLog
-	if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).
-		Model(&log.SystemLog{}).
-		Where("type = ? AND content LIKE ?", log.TypeCommission.Uint8(), fmt.Sprintf("%%\"order_no\":\"%s\"%%", orderNo)).
-		Order("id DESC").
-		Find(&commissionLogs).Error; err != nil {
-		return nil, 0, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "query commission log failed: %v", err)
-	}
-
-	for _, item := range commissionLogs {
-		var content log.Commission
-		if err := content.Unmarshal([]byte(item.Content)); err != nil {
-			continue
-		}
-		if content.Type != log.CommissionTypePurchase && content.Type != log.CommissionTypeRenewal {
-			continue
-		}
-
-		var referer modeluser.User
-		if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).
-			Model(&modeluser.User{}).
-			Where("id = ?", item.ObjectID).
-			First(&referer).Error; err != nil {
-			return nil, 0, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "query commission owner failed: %v", err)
-		}
-		return &referer, content.Amount, nil
-	}
-
-	if orderCommission > 0 {
-		return nil, 0, errors.Wrapf(xerr.NewErrCode(xerr.OrderRefundCommissionMismatch), "order %s commission owner not found", orderNo)
-	}
-	return nil, 0, nil
-}
-
-func (l *RefundOrderLogic) buildRefundAuditLog(
-	operator *modeluser.User,
-	orderInfo *modelorder.Order,
-	userSub *modeluser.Subscribe,
-	referer *modeluser.User,
-	commissionAmount int64,
-	reason string,
-	orderStatusBefore uint8,
-	subStatusBefore uint8,
-	subExpireBefore time.Time,
-	commissionBefore int64,
-	commissionAfter int64,
-	now time.Time,
-) (*log.OrderRefund, error) {
-	refundLog := &log.OrderRefund{
-		OrderId:               orderInfo.Id,
-		OrderNo:               orderInfo.OrderNo,
-		OperatorUserId:        operator.Id,
-		TargetUserId:          userSub.UserId,
-		UserSubscribeId:       userSub.Id,
-		CommissionAmount:      commissionAmount,
-		Reason:                reason,
-		OrderStatusBefore:     orderStatusBefore,
-		OrderStatusAfter:      orderInfo.Status,
-		SubscribeStatusBefore: subStatusBefore,
-		SubscribeStatusAfter:  userSub.Status,
-		SubscribeExpireBefore: subExpireBefore.UnixMilli(),
-		SubscribeExpireAfter:  userSub.ExpireTime.UnixMilli(),
-		CommissionBefore:      commissionBefore,
-		CommissionAfter:       commissionAfter,
-		Timestamp:             now.UnixMilli(),
-	}
-	if referer != nil {
-		refundLog.RefererUserId = referer.Id
-	}
-	if len(operator.AuthMethods) > 0 {
-		refundLog.OperatorAuthIdentifier = operator.AuthMethods[0].AuthIdentifier
-	}
-	return refundLog, nil
-}

internal/logic/admin/order/refundOrderLogic_test.go

@@ -1,85 +0,0 @@
-package order
-
-import (
-	"testing"
-	"time"
-
-	modelorder "github.com/perfect-panel/server/internal/model/order"
-	modeluser "github.com/perfect-panel/server/internal/model/user"
-)
-
-func TestOrderStatusName(t *testing.T) {
-	tests := map[uint8]string{
-		1: "pending",
-		2: "paid",
-		3: "closed",
-		4: "failed",
-		5: "finished",
-		6: "refunded",
-		7: "unknown",
-	}
-
-	for input, want := range tests {
-		if got := orderStatusName(input); got != want {
-			t.Fatalf("status %d: got %q want %q", input, got, want)
-		}
-	}
-}
-
-func TestBuildRefundAuditLog(t *testing.T) {
-	logic := &RefundOrderLogic{}
-	now := time.Unix(1710000000, 0)
-	expireBefore := now.Add(24 * time.Hour)
-	expireAfter := now.Add(-time.Second)
-	operator := &modeluser.User{
-		Id: 100,
-		AuthMethods: []modeluser.AuthMethods{
-			{AuthIdentifier: "admin@example.com"},
-		},
-	}
-	orderInfo := &modelorder.Order{Id: 10, OrderNo: "ORD-1", Status: orderStatusRefunded}
-	userSub := &modeluser.Subscribe{Id: 20, UserId: 30, Status: 3, ExpireTime: expireAfter}
-	referer := &modeluser.User{Id: 40}
-
-	got, err := logic.buildRefundAuditLog(
-		operator,
-		orderInfo,
-		userSub,
-		referer,
-		500,
-		"manual refund",
-		5,
-		1,
-		expireBefore,
-		900,
-		400,
-		now,
-	)
-	if err != nil {
-		t.Fatalf("buildRefundAuditLog error: %v", err)
-	}
-	if got.OrderId != 10 || got.OrderNo != "ORD-1" {
-		t.Fatalf("unexpected order info: %+v", got)
-	}
-	if got.OperatorUserId != 100 || got.OperatorAuthIdentifier != "admin@example.com" {
-		t.Fatalf("unexpected operator info: %+v", got)
-	}
-	if got.TargetUserId != 30 || got.UserSubscribeId != 20 {
-		t.Fatalf("unexpected subscription info: %+v", got)
-	}
-	if got.RefererUserId != 40 || got.CommissionAmount != 500 {
-		t.Fatalf("unexpected commission info: %+v", got)
-	}
-	if got.OrderStatusBefore != 5 || got.OrderStatusAfter != orderStatusRefunded {
-		t.Fatalf("unexpected order status: %+v", got)
-	}
-	if got.SubscribeStatusBefore != 1 || got.SubscribeStatusAfter != 3 {
-		t.Fatalf("unexpected subscribe status: %+v", got)
-	}
-	if got.SubscribeExpireBefore != expireBefore.UnixMilli() || got.SubscribeExpireAfter != expireAfter.UnixMilli() {
-		t.Fatalf("unexpected expire transition: %+v", got)
-	}
-	if got.CommissionBefore != 900 || got.CommissionAfter != 400 {
-		t.Fatalf("unexpected commission transition: %+v", got)
-	}
-}

internal/logic/admin/user/approveWithdrawalLogic.go

@@ -0,0 +1,27 @@
+package user
+
+import (
+	"context"
+
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/logger"
+)
+
+type ApproveWithdrawalLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewApproveWithdrawalLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ApproveWithdrawalLogic {
+	return &ApproveWithdrawalLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *ApproveWithdrawalLogic) ApproveWithdrawal(req *types.ApproveWithdrawalRequest) error {
+	return approveWithdrawal(l.ctx, l.svcCtx, req.WithdrawalId)
+}

internal/logic/admin/user/getWithdrawalListLogic.go

@@ -0,0 +1,74 @@
+package user
+
+import (
+	"context"
+
+	usermodel "github.com/perfect-panel/server/internal/model/user"
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/logger"
+	"github.com/perfect-panel/server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type GetWithdrawalListLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewGetWithdrawalListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetWithdrawalListLogic {
+	return &GetWithdrawalListLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetWithdrawalListLogic) GetWithdrawalList(req *types.GetWithdrawalListRequest) (*types.GetWithdrawalListResponse, error) {
+	page := req.Page
+	size := req.Size
+	if page <= 0 {
+		page = 1
+	}
+	if size <= 0 {
+		size = 10
+	}
+
+	query := l.svcCtx.DB.WithContext(l.ctx).Model(&usermodel.Withdrawal{})
+	if req.UserId != nil {
+		query = query.Where("user_id = ?", *req.UserId)
+	}
+	if req.Status != nil {
+		query = query.Where("status = ?", *req.Status)
+	}
+
+	var total int64
+	if err := query.Count(&total).Error; err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "count withdrawals failed: %v", err)
+	}
+
+	var rows []usermodel.Withdrawal
+	if err := query.Order("id DESC").Limit(size).Offset((page - 1) * size).Find(&rows).Error; err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "query withdrawals failed: %v", err)
+	}
+
+	list := make([]types.WithdrawalLog, 0, len(rows))
+	for _, row := range rows {
+		list = append(list, types.WithdrawalLog{
+			Id:        row.Id,
+			UserId:    row.UserId,
+			Amount:    row.Amount,
+			Content:   row.Content,
+			Status:    row.Status,
+			Reason:    row.Reason,
+			CreatedAt: row.CreatedAt.UnixMilli(),
+			UpdatedAt: row.UpdatedAt.UnixMilli(),
+		})
+	}
+
+	return &types.GetWithdrawalListResponse{
+		List:  list,
+		Total: total,
+	}, nil
+}

internal/logic/admin/user/rejectWithdrawalLogic.go

@@ -0,0 +1,27 @@
+package user
+
+import (
+	"context"
+
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/logger"
+)
+
+type RejectWithdrawalLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewRejectWithdrawalLogic(ctx context.Context, svcCtx *svc.ServiceContext) *RejectWithdrawalLogic {
+	return &RejectWithdrawalLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *RejectWithdrawalLogic) RejectWithdrawal(req *types.RejectWithdrawalRequest) error {
+	return rejectWithdrawal(l.ctx, l.svcCtx, req.WithdrawalId, req.Reason)
+}

internal/logic/admin/user/updateUserBasicInfoLogic.go

@@ -6,6 +6,7 @@ import (
 	"strings"
 	"time"
 
+	logicCommon "github.com/perfect-panel/server/internal/logic/common"
 	"github.com/perfect-panel/server/internal/model/log"
 	"github.com/perfect-panel/server/internal/svc"
 	"github.com/perfect-panel/server/internal/types"
@@ -100,21 +101,15 @@ func (l *UpdateUserBasicInfoLogic) UpdateUserBasicInfo(req *types.UpdateUserBasi
 		}
 
 		if req.Commission != userInfo.Commission {
-
-			commentLog := log.Commission{
-				Type:      log.CommissionTypeAdjust,
-				Amount:    req.Commission - userInfo.Commission,
-				Timestamp: time.Now().UnixMilli(),
+			if isWithdrawalScene(req.Remark) {
+				logWithdrawalGuard(l.Logger, userInfo.Id)
+				return errors.Wrapf(xerr.NewErrCode(xerr.InvalidAccess), "commission overwrite is blocked in withdrawal scene")
 			}
-
-			content, _ := commentLog.Marshal()
-			err = tx.Create(&log.SystemLog{
-				Type:     log.TypeCommission.Uint8(),
-				Date:     time.Now().Format(time.DateOnly),
-				ObjectID: userInfo.Id,
-				Content:  string(content),
-			}).Error
-			if err != nil {
+			change := req.Commission - userInfo.Commission
+			if err = l.svcCtx.UserModel.UpdateCommission(l.ctx, userInfo.Id, change, tx); err != nil {
+				return err
+			}
+			if err = logicCommon.WriteCommissionLog(tx, userInfo.Id, log.CommissionTypeAdjust, change, ""); err != nil {
 				return err
 			}
 			userInfo.Commission = req.Commission

internal/logic/admin/user/withdrawalCommon.go

@@ -12,12 +12,10 @@ import (
 	"github.com/perfect-panel/server/pkg/xerr"
 	"github.com/pkg/errors"
 	"gorm.io/gorm"
-	"gorm.io/gorm/clause"
 )
 
 func approveWithdrawal(ctx context.Context, svcCtx *svc.ServiceContext, withdrawalID int64) error {
-	var approvedUserID int64
-	err := svcCtx.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+	return svcCtx.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
 		withdrawal, err := logicCommon.LoadPendingWithdrawalForUpdate(ctx, tx, withdrawalID)
 		if err != nil {
 			if err.Error() == "withdrawal status invalid" {
@@ -26,16 +24,6 @@ func approveWithdrawal(ctx context.Context, svcCtx *svc.ServiceContext, withdraw
 			return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "load withdrawal failed: %v", err)
 		}
 
-		// Lock user row and verify sufficient balance before deducting.
-		var u usermodel.User
-		if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).
-			Where("id = ?", withdrawal.UserId).First(&u).Error; err != nil {
-			return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "load user failed: %v", err)
-		}
-		if u.Commission < withdrawal.Amount {
-			return errors.Wrapf(xerr.NewErrCode(xerr.UserCommissionNotEnough), "user %d has insufficient commission balance", withdrawal.UserId)
-		}
-
 		if err := tx.Model(&usermodel.Withdrawal{}).
 			Where("id = ? AND status = 0", withdrawalID).
 			Updates(map[string]interface{}{
@@ -45,31 +33,17 @@ func approveWithdrawal(ctx context.Context, svcCtx *svc.ServiceContext, withdraw
 			return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "approve withdrawal failed: %v", err)
 		}
 
-		// Deduct commission atomically inside the transaction.
-		if err := tx.Model(&usermodel.User{}).
-			Where("id = ?", withdrawal.UserId).
-			UpdateColumn("commission", gorm.Expr("commission - ?", withdrawal.Amount)).Error; err != nil {
-			return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "deduct commission failed: %v", err)
-		}
-
 		if err := logicCommon.WriteCommissionLog(tx, withdrawal.UserId, log.CommissionTypeWithdraw, withdrawal.Amount, ""); err != nil {
 			return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "write commission log failed: %v", err)
 		}
-
-		approvedUserID = withdrawal.UserId
 		return nil
 	})
-
-	if err == nil && approvedUserID > 0 {
-		_ = svcCtx.UserModel.ClearUserCache(ctx, &usermodel.User{Id: approvedUserID})
-	}
-	return err
 }
 
 func rejectWithdrawal(ctx context.Context, svcCtx *svc.ServiceContext, withdrawalID int64, reason string) error {
 	reason = strings.TrimSpace(reason)
 	return svcCtx.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
-		_, err := logicCommon.LoadPendingWithdrawalForUpdate(ctx, tx, withdrawalID)
+		withdrawal, err := logicCommon.LoadPendingWithdrawalForUpdate(ctx, tx, withdrawalID)
 		if err != nil {
 			if err.Error() == "withdrawal status invalid" {
 				return errors.Wrapf(xerr.NewErrCode(xerr.WithdrawalStatusInvalid), "withdrawal %d already processed", withdrawalID)
@@ -77,14 +51,23 @@ func rejectWithdrawal(ctx context.Context, svcCtx *svc.ServiceContext, withdrawa
 			return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "load withdrawal failed: %v", err)
 		}
 
-		// Commission was NOT deducted at application time under the new logic,
-		// so rejection requires no refund — only a status update.
-		return tx.Model(&usermodel.Withdrawal{}).
+		if err := tx.Model(&usermodel.Withdrawal{}).
 			Where("id = ? AND status = 0", withdrawalID).
 			Updates(map[string]interface{}{
 				"status": 2,
 				"reason": reason,
-			}).Error
+			}).Error; err != nil {
+			return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "reject withdrawal failed: %v", err)
+		}
+
+		if err := svcCtx.UserModel.UpdateCommission(ctx, withdrawal.UserId, withdrawal.Amount, tx); err != nil {
+			return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "refund commission failed: %v", err)
+		}
+
+		if err := logicCommon.WriteCommissionLog(tx, withdrawal.UserId, log.CommissionTypeWithdrawReject, withdrawal.Amount, ""); err != nil {
+			return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "write commission log failed: %v", err)
+		}
+		return nil
 	})
 }
 

internal/logic/common/logMessageReportLogic.go

@@ -25,7 +25,7 @@ type ReportLogMessageLogic struct {
 }
 
 func NewReportLogMessageLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ReportLogMessageLogic {
-    return &ReportLogMessageLogic{ Logger: logger.WithContext(ctx), ctx: ctx, svcCtx: svcCtx }
+	return &ReportLogMessageLogic{Logger: logger.WithContext(ctx), ctx: ctx, svcCtx: svcCtx}
 }
 
 func (l *ReportLogMessageLogic) ReportLogMessage(req *types.ReportLogMessageRequest, c *gin.Context) (resp *types.ReportLogMessageResponse, err error) {
@@ -35,9 +35,13 @@ func (l *ReportLogMessageLogic) ReportLogMessage(req *types.ReportLogMessageRequ
 
 	// 简单限流：设备ID优先，其次IP
 	limitKey := "logmsg:" + strings.TrimSpace(req.DeviceId)
-    if limitKey == "logmsg:" { limitKey = "logmsg:" + ip }
+	if limitKey == "logmsg:" {
+		limitKey = "logmsg:" + ip
+	}
 	count, _ := l.svcCtx.Redis.Incr(l.ctx, limitKey).Result()
-    if count == 1 { _ = l.svcCtx.Redis.Expire(l.ctx, limitKey, 60*time.Second).Err() }
+	if count == 1 {
+		_ = l.svcCtx.Redis.Expire(l.ctx, limitKey, 60*time.Second).Err()
+	}
 	if count > 120 { // 每分钟最多120条
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.TooManyRequests), "too many reports")
 	}
@@ -60,18 +64,20 @@ func (l *ReportLogMessageLogic) ReportLogMessage(req *types.ReportLogMessageRequ
 	}
 
 	var userIdPtr *int64
-    if req.UserId > 0 { userIdPtr = &req.UserId }
+	if req.UserId > 0 {
+		userIdPtr = &req.UserId
+	}
 
 	row := &logmessage.LogMessage{
-        Platform:   req.Platform,
-        AppVersion: req.AppVersion,
-        OsName:     req.OsName,
-        OsVersion:  req.OsVersion,
-        DeviceId:   req.DeviceId,
+		Platform:   safeTruncate(req.Platform, 32),
+		AppVersion: safeTruncate(req.AppVersion, 64),
+		OsName:     safeTruncate(req.OsName, 64),
+		OsVersion:  safeTruncate(req.OsVersion, 64),
+		DeviceId:   safeTruncate(req.DeviceId, 255),
 		UserId:     userIdPtr,
-        SessionId:  req.SessionId,
+		SessionId:  safeTruncate(req.SessionId, 255),
 		Level:      req.Level,
-        ErrorCode:  req.ErrorCode,
+		ErrorCode:  safeTruncate(req.ErrorCode, 128),
 		Message:    safeTruncate(req.Message, 1024*64),
 		Stack:      safeTruncate(req.Stack, 1024*1024),
 		Context:    ctxStr,
@@ -84,25 +90,31 @@ func (l *ReportLogMessageLogic) ReportLogMessage(req *types.ReportLogMessageRequ
 
 	if err = l.svcCtx.LogMessageModel.Insert(l.ctx, row); err != nil {
 		// 唯一指纹冲突时尝试查询已有记录返回ID
-        ex, _, findErr := l.svcCtx.LogMessageModel.Filter(l.ctx, &logmessage.FilterParams{ Keyword: req.Message, Page: 1, Size: 1 })
+		ex, _, findErr := l.svcCtx.LogMessageModel.Filter(l.ctx, &logmessage.FilterParams{Keyword: req.Message, Page: 1, Size: 1})
 		if findErr == nil && len(ex) > 0 {
-            return &types.ReportLogMessageResponse{ Id: ex[0].Id }, nil
+			return &types.ReportLogMessageResponse{Id: ex[0].Id}, nil
 		}
 		l.Errorf("[ReportLogMessage] insert error: %v", err)
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "insert log_message failed: %v", err)
 	}
-    return &types.ReportLogMessageResponse{ Id: row.Id }, nil
+	return &types.ReportLogMessageResponse{Id: row.Id}, nil
 }
 
 func safeTruncate(s string, n int) string {
-    if len(s) <= n { return s }
+	if len(s) <= n {
+		return s
+	}
 	return s[:n]
 }
 
 func clientIP(c *gin.Context) string {
 	ip := c.ClientIP()
-    if ip != "" { return ip }
+	if ip != "" {
+		return ip
+	}
 	host, _, err := net.SplitHostPort(strings.TrimSpace(c.Request.RemoteAddr))
-    if err == nil && host != "" { return host }
+	if err == nil && host != "" {
+		return host
+	}
 	return ""
 }

internal/logic/notify/appleIAPNotifyLogic.go

@@ -3,20 +3,17 @@ package notify
 import (
 	"context"
 	"encoding/json"
-	"fmt"
 	"strconv"
 	"strings"
 
 	commonLogic "github.com/perfect-panel/server/internal/logic/common"
 	iapmodel "github.com/perfect-panel/server/internal/model/iap/apple"
-	"github.com/perfect-panel/server/internal/model/order"
 	"github.com/perfect-panel/server/internal/model/subscribe"
 	"github.com/perfect-panel/server/internal/model/user"
 	"github.com/perfect-panel/server/internal/svc"
 	"github.com/perfect-panel/server/internal/types"
 	iapapple "github.com/perfect-panel/server/pkg/iap/apple"
 	"github.com/perfect-panel/server/pkg/logger"
-	"github.com/perfect-panel/server/pkg/tool"
 	"gorm.io/gorm"
 )
 
@@ -87,7 +84,6 @@ func (l *AppleIAPNotifyLogic) Handle(signedPayload string) error {
 				l.Errorw("iap notify insert transaction error", logger.Field("error", e.Error()), logger.Field("productId", txPayload.ProductId), logger.Field("originalTransactionId", txPayload.OriginalTransactionId))
 				return e
 			}
-			existing = rec
 		} else {
 			if txPayload.RevocationDate != nil {
 				// 撤销场景：更新 revocation_at
@@ -100,32 +96,6 @@ func (l *AppleIAPNotifyLogic) Handle(signedPayload string) error {
 				}
 			}
 		}
-
-		// Fix Bug 7: resolve userId when the IAP transaction record has no associated user.
-		// This can happen if the first notification for a subscription arrived before the
-		// in-app purchase flow created the order (race) or the order was made in a previous
-		// build that did not write user_id to the IAP transaction table.
-		if existing != nil && existing.UserId == 0 {
-			var origOrder order.Order
-			if lookupErr := db.Model(&order.Order{}).
-				Where("trade_no = ? AND method = ?", txPayload.OriginalTransactionId, "apple_iap").
-				Order("id ASC").
-				First(&origOrder).Error; lookupErr == nil && origOrder.UserId > 0 {
-				existing.UserId = origOrder.UserId
-				_ = db.Model(&iapmodel.Transaction{}).
-					Where("id = ?", existing.Id).
-					Update("user_id", origOrder.UserId).Error
-				l.Infow("iap notify resolved zero userId from original purchase order",
-					logger.Field("userId", origOrder.UserId),
-					logger.Field("originalTransactionId", txPayload.OriginalTransactionId),
-				)
-			} else {
-				l.Errorw("CRITICAL: iap notify UserId=0 and cannot resolve from order, notification dropped",
-					logger.Field("originalTransactionId", txPayload.OriginalTransactionId))
-				return fmt.Errorf("iap notify: UserId=0 and cannot resolve from order for original_transaction_id=%s", txPayload.OriginalTransactionId)
-			}
-		}
-
 		var days int64
 		{
 			pid := strings.ToLower(txPayload.ProductId)
@@ -199,12 +169,7 @@ func (l *AppleIAPNotifyLogic) Handle(signedPayload string) error {
 			}
 		}
 		if days == 0 {
-			// Both string-parse and DB fallback failed to map the product to days.
-			// Return an error so Apple retries the notification; silently ignoring
-			// this would cause the subscriber's renewal to be lost.
-			l.Errorw("CRITICAL: iap notify product mapping missing, returning error to trigger retry",
-				logger.Field("productId", txPayload.ProductId))
-			return fmt.Errorf("iap product id %s could not be mapped to subscription days", txPayload.ProductId)
+			l.Errorw("iap notify product mapping missing", logger.Field("productId", txPayload.ProductId))
 		}
 		token := "iap:" + txPayload.OriginalTransactionId
 		sub, e := l.svcCtx.UserModel.FindOneSubscribeByToken(l.ctx, token)
@@ -251,11 +216,6 @@ func (l *AppleIAPNotifyLogic) Handle(signedPayload string) error {
 							logger.Field("product_id", txPayload.ProductId),
 						)...,
 					)
-					// Create audit order record for renewal notifications (Bug 7)
-					if err := l.createIAPRenewalAuditOrder(db, ntype, txPayload.TransactionId, candidate.UserId, candidate.SubscribeId, candidate.Token); err != nil {
-						l.Errorw("iap notify fallback create renewal order error", logger.Field("error", err.Error()))
-						// Non-fatal: subscription already updated; order creation failure is logged only
-					}
 					break
 				}
 			}
@@ -288,52 +248,7 @@ func (l *AppleIAPNotifyLogic) Handle(signedPayload string) error {
 					logger.Field("product_id", txPayload.ProductId),
 				)...,
 			)
-			// Create audit order record for renewal notifications (Bug 7)
-			if err := l.createIAPRenewalAuditOrder(db, ntype, txPayload.TransactionId, sub.UserId, sub.SubscribeId, sub.Token); err != nil {
-				l.Errorw("iap notify create renewal order error", logger.Field("error", err.Error()))
-				// Non-fatal: subscription already updated; order creation failure is logged only
-			}
 		}
 		return nil
 	})
 }
-
-// createIAPRenewalAuditOrder creates a finished renewal order record for DID_RENEW and SUBSCRIBED
-// Apple SSNS notifications so that the order table has a complete financial audit trail.
-// The operation is idempotent: if an order with the same trade_no already exists it is skipped.
-func (l *AppleIAPNotifyLogic) createIAPRenewalAuditOrder(db *gorm.DB, ntype, transactionId string, userId, subscribeId int64, subscribeToken string) error {
-	if ntype != "DID_RENEW" && ntype != "SUBSCRIBED" {
-		return nil
-	}
-	// Idempotency check
-	var count int64
-	if err := db.Model(&order.Order{}).
-		Where("trade_no = ? AND method = ?", transactionId, "apple_iap").
-		Count(&count).Error; err != nil {
-		return fmt.Errorf("check existing iap renewal order: %w", err)
-	}
-	if count > 0 {
-		return nil
-	}
-	rec := &order.Order{
-		UserId:         userId,
-		OrderNo:        tool.GenerateTradeNo(),
-		Type:           2, // OrderTypeRenewal
-		Status:         5, // OrderStatusFinished
-		Method:         "apple_iap",
-		TradeNo:        transactionId,
-		SubscribeId:    subscribeId,
-		SubscribeToken: subscribeToken,
-		Quantity:       1,
-		IsNew:          false,
-	}
-	if err := db.Model(&order.Order{}).Create(rec).Error; err != nil {
-		return fmt.Errorf("create iap renewal audit order: %w", err)
-	}
-	l.Infow("iap notify created renewal audit order",
-		logger.Field("orderNo", rec.OrderNo),
-		logger.Field("transactionId", transactionId),
-		logger.Field("userId", userId),
-	)
-	return nil
-}

internal/logic/public/file/common.go

@@ -109,14 +109,14 @@ func buildObjectKey(prefix string, userID int64, bizType, fileID, fileName strin
 	if prefix == "" {
 		prefix = "app-upload"
 	}
-	return fmt.Sprintf("%s/%s/%d/%04d/%02d/%s_%s",
+	return fmt.Sprintf("%s/%04d/%02d/%02d/%d/%s__%s",
 		prefix,
-		strings.Trim(safeFileNameRegexp.ReplaceAllString(strings.ToLower(strings.TrimSpace(bizType)), "-"), "-"),
-		userID,
 		now.Year(),
 		int(now.Month()),
-		fileID,
+		now.Day(),
+		userID,
 		safeFileName(fileName),
+		fileID,
 	)
 }
 

internal/logic/public/portal/purchaseLogic.go

@@ -154,12 +154,9 @@ func (l *PurchaseLogic) Purchase(req *types.PortalPurchaseRequest) (resp *types.
 		}
 		content, _ := tempOrder.Marshal()
 
-		// Persist activation context to DB so the worker can recover if Redis TTL expires.
-		orderInfo.ActivationContext = string(content)
-
-		// Write to Redis as a hot cache (best-effort; non-fatal on failure).
-		if _, redisErr := l.svcCtx.Redis.Set(l.ctx, fmt.Sprintf(constant.TempOrderCacheKey, orderInfo.OrderNo), string(content), CloseOrderTimeMinutes*time.Minute).Result(); redisErr != nil {
-			l.Infow("[Purchase] Redis set error (non-fatal, DB fallback available)", logger.Field("error", redisErr.Error()), logger.Field("order_no", orderInfo.OrderNo))
+		if _, err = l.svcCtx.Redis.Set(l.ctx, fmt.Sprintf(constant.TempOrderCacheKey, orderInfo.OrderNo), string(content), CloseOrderTimeMinutes*time.Minute).Result(); err != nil {
+			l.Errorw("[Purchase] Redis set error", logger.Field("error", err.Error()), logger.Field("order_no", orderInfo.OrderNo))
+			return err
 		}
 		l.Infow("[Purchase] Guest order", logger.Field("order_no", orderInfo.OrderNo), logger.Field("identifier", req.Identifier))
 
@@ -172,7 +169,7 @@ func (l *PurchaseLogic) Purchase(req *types.PortalPurchaseRequest) (resp *types.
 			}
 		}
 
-		// save guest order (activation_context is included)
+		// save guest order
 		if err = l.svcCtx.OrderModel.Insert(l.ctx, orderInfo, tx); err != nil {
 			return err
 		}

internal/logic/public/redemption/redeemCodeLogic.go

@@ -151,19 +151,6 @@ func (l *RedeemCodeLogic) RedeemCode(req *types.RedeemCodeRequest) (resp *types.
 	}
 
 	// 创建Order记录
-	redemptionContext := struct {
-		Type             string `json:"type"`
-		RedemptionCodeId int64  `json:"redemption_code_id"`
-		UnitTime         string `json:"unit_time"`
-		Quantity         int64  `json:"quantity"`
-	}{
-		Type:             "redemption",
-		RedemptionCodeId: redemptionCode.Id,
-		UnitTime:         redemptionCode.UnitTime,
-		Quantity:         redemptionCode.Quantity,
-	}
-	activationContextJSON, _ := json.Marshal(redemptionContext)
-
 	orderInfo := &order.Order{
 		UserId:         u.Id,
 		OrderNo:        tool.GenerateTradeNo(),
@@ -182,17 +169,16 @@ func (l *RedeemCodeLogic) RedeemCode(req *types.RedeemCodeRequest) (resp *types.
 		Status:         2, // 直接设置为已支付
 		SubscribeId:    redemptionCode.SubscribePlan,
 		IsNew:          isNew,
-		ActivationContext: string(activationContextJSON),
 	}
 
-	// 保存Order到数据库（activation_context 同步写入，作为 Redis 的持久化兜底）
+	// 保存Order到数据库
 	err = l.svcCtx.OrderModel.Insert(l.ctx, orderInfo)
 	if err != nil {
 		l.Errorw("[RedeemCode] Create order failed", logger.Field("error", err.Error()))
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "create order failed")
 	}
 
-	// 缓存兑换码信息到Redis（热缓存，供队列任务快速读取，非关键路径）
+	// 缓存兑换码信息到Redis（供队列任务使用）
 	cacheKey := fmt.Sprintf("redemption_order:%s", orderInfo.OrderNo)
 	cacheData := map[string]interface{}{
 		"redemption_code_id": redemptionCode.Id,
@@ -200,8 +186,16 @@ func (l *RedeemCodeLogic) RedeemCode(req *types.RedeemCodeRequest) (resp *types.
 		"quantity":           redemptionCode.Quantity,
 	}
 	jsonData, _ := json.Marshal(cacheData)
-	if redisErr := l.svcCtx.Redis.Set(l.ctx, cacheKey, jsonData, 2*time.Hour).Err(); redisErr != nil {
-		l.Infow("[RedeemCode] Cache redemption data failed (non-fatal, DB fallback available)", logger.Field("error", redisErr.Error()))
+	err = l.svcCtx.Redis.Set(l.ctx, cacheKey, jsonData, 2*time.Hour).Err()
+	if err != nil {
+		l.Errorw("[RedeemCode] Cache redemption data failed", logger.Field("error", err.Error()))
+		// 缓存失败，删除已创建的Order避免孤儿记录
+		if delErr := l.svcCtx.OrderModel.Delete(l.ctx, orderInfo.Id); delErr != nil {
+			l.Errorw("[RedeemCode] Delete order failed after cache error",
+				logger.Field("order_id", orderInfo.Id),
+				logger.Field("error", delErr.Error()))
+		}
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "cache redemption data failed")
 	}
 
 	// 触发队列任务

internal/logic/public/user/commissionWithdrawLogic.go

@@ -2,7 +2,10 @@ package user
 
 import (
 	"context"
+	"time"
 
+	logicCommon "github.com/perfect-panel/server/internal/logic/common"
+	"github.com/perfect-panel/server/internal/model/log"
 	"github.com/perfect-panel/server/internal/model/user"
 	"github.com/perfect-panel/server/internal/svc"
 	"github.com/perfect-panel/server/internal/types"
@@ -35,38 +38,48 @@ func (l *CommissionWithdrawLogic) CommissionWithdraw(req *types.CommissionWithdr
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.InvalidAccess), "Invalid Access")
 	}
 
-	// Sum all pending (status=0) withdrawals to compute available balance.
-	// Available = commission - pendingTotal; commission is only deducted on approval.
-	var pendingTotal int64
-	if err = l.svcCtx.DB.WithContext(l.ctx).
-		Model(&user.Withdrawal{}).
-		Where("user_id = ? AND status = 0", u.Id).
-		Select("COALESCE(SUM(amount), 0)").
-		Scan(&pendingTotal).Error; err != nil {
-		l.Errorf("Failed to query pending withdrawals for user %d: %v", u.Id, err)
-		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "Failed to query pending withdrawals for user %d", u.Id)
-	}
-
-	if u.Commission < req.Amount+pendingTotal {
-		logger.Errorf("User %d insufficient available commission: total=%d pending=%d requested=%d",
-			u.Id, u.Commission, pendingTotal, req.Amount)
+	if u.Commission < req.Amount {
+		logger.Errorf("User %d has insufficient commission balance: %.2f, requested: %.2f", u.Id, float64(u.Commission)/100, float64(req.Amount)/100)
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.UserCommissionNotEnough), "User %d has insufficient commission balance", u.Id)
 	}
 
-	var w user.Withdrawal
-	err = l.svcCtx.DB.WithContext(l.ctx).Transaction(func(tx *gorm.DB) error {
-		w = user.Withdrawal{
+	tx := l.svcCtx.DB.WithContext(l.ctx).Begin()
+	now := time.Now()
+
+	// Atomically deduct the requested amount so concurrent commission growth is preserved.
+	if err = l.svcCtx.DB.WithContext(l.ctx).
+		Model(&user.User{}).
+		Where("id = ? AND commission >= ?", u.Id, req.Amount).
+		UpdateColumn("commission", gorm.Expr("commission - ?", req.Amount)).Error; err != nil {
+		tx.Rollback()
+		l.Errorf("Failed to update user %d commission balance: %v", u.Id, err)
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "Failed to update user %d commission balance: %v", u.Id, err)
+	}
+	_ = l.svcCtx.UserModel.ClearUserCache(l.ctx, u)
+
+	// create withdrawal log
+	if err = logicCommon.WriteCommissionLog(tx, u.Id, log.CommissionTypeConvertBalance, req.Amount, ""); err != nil {
+		tx.Rollback()
+		l.Errorf("Failed to create commission log for user %d: %v", u.Id, err)
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "Failed to create commission log for user %d: %v", u.Id, err)
+	}
+
+	err = tx.Model(&user.Withdrawal{}).Create(&user.Withdrawal{
 		UserId:  u.Id,
 		Amount:  req.Amount,
 		Content: req.Content,
 		Status:  0,
 		Reason:  "",
-		}
-		return tx.Create(&w).Error
-	})
+	}).Error
+
 	if err != nil {
-		l.Errorf("Failed to create withdrawal for user %d: %v", u.Id, err)
-		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "Failed to create withdrawal for user %d: %v", u.Id, err)
+		tx.Rollback()
+		l.Errorf("Failed to create withdrawal log for user %d: %v", u.Id, err)
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "Failed to create withdrawal log for user %d: %v", u.Id, err)
+	}
+	if err = tx.Commit().Error; err != nil {
+		l.Errorf("Transaction commit failed for user %d withdrawal: %v", u.Id, err)
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "Transaction commit failed for user %d withdrawal: %v", u.Id, err)
 	}
 
 	return &types.WithdrawalLog{
@@ -75,7 +88,7 @@ func (l *CommissionWithdrawLogic) CommissionWithdraw(req *types.CommissionWithdr
 		Content:   req.Content,
 		Status:    0,
 		Reason:    "",
-		CreatedAt: w.CreatedAt.UnixMilli(),
-		UpdatedAt: w.UpdatedAt.UnixMilli(),
+		CreatedAt: now.UnixMilli(),
+		UpdatedAt: now.UnixMilli(),
 	}, nil
 }

internal/logic/public/user/queryUserInfoLogic.go

@@ -6,7 +6,9 @@ import (
 	"sort"
 	"strings"
 
+	authlogic "github.com/perfect-panel/server/internal/logic/auth"
 	logicCommon "github.com/perfect-panel/server/internal/logic/common"
+	modelOrder "github.com/perfect-panel/server/internal/model/order"
 	"github.com/perfect-panel/server/pkg/constant"
 	"github.com/perfect-panel/server/pkg/uuidx"
 	"github.com/perfect-panel/server/pkg/xerr"
@@ -44,6 +46,7 @@ func (l *QueryUserInfoLogic) QueryUserInfo() (resp *types.User, err error) {
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.InvalidAccess), "Invalid Access")
 	}
 	tool.DeepCopy(resp, u)
+	resp.UseStatus = true
 
 	// 用家庭范围查设备，而不是只看当前用户自己的 UserDevices
 	scopeHelper := newFamilyScopeHelper(l.ctx, l.svcCtx)
@@ -65,6 +68,14 @@ func (l *QueryUserInfoLogic) QueryUserInfo() (resp *types.User, err error) {
 		}
 		resp.UserDevices = userDevices
 	}
+
+	useStatus, useStatusErr := l.resolveBindEmailTrialUseStatus(u.Id, scopeUserIds)
+	if useStatusErr != nil {
+		l.Errorw("resolve bind email trial use status failed", logger.Field("user_id", u.Id), logger.Field("error", useStatusErr.Error()))
+	} else {
+		resp.UseStatus = useStatus
+	}
+
 	// refer_code 为空时自动生成
 	if resp.ReferCode == "" {
 		resp.ReferCode = uuidx.UserInviteCode(u.Id)
@@ -108,6 +119,49 @@ func (l *QueryUserInfoLogic) QueryUserInfo() (resp *types.User, err error) {
 	return resp, nil
 }
 
+// resolveBindEmailTrialUseStatus determines whether userinfo should show the
+// "bind email to get free trial" prompt. `true` means show the prompt.
+func (l *QueryUserInfoLogic) resolveBindEmailTrialUseStatus(currentUserId int64, scopeUserIds []int64) (bool, error) {
+	if len(scopeUserIds) == 0 {
+		scopeUserIds = []int64{currentUserId}
+	}
+
+	var hasBoundEmailCount int64
+	if err := l.svcCtx.DB.WithContext(l.ctx).
+		Model(&user.AuthMethods{}).
+		Where("user_id IN ? AND auth_type = ? AND auth_identifier != ''", scopeUserIds, "email").
+		Count(&hasBoundEmailCount).Error; err != nil {
+		return false, err
+	}
+
+	var hasPurchaseCount int64
+	if err := l.svcCtx.DB.WithContext(l.ctx).
+		Model(&modelOrder.Order{}).
+		Where("user_id IN ? AND type IN ? AND status IN ?", scopeUserIds, []int64{1, 2}, []int64{2, 5}).
+		Count(&hasPurchaseCount).Error; err != nil {
+		return false, err
+	}
+
+	hasTrial := false
+	registerCfg := l.svcCtx.Config.Register
+	if authlogic.IsTrialConfigReady(registerCfg) && registerCfg.TrialSubscribe > 0 {
+		var hasTrialCount int64
+		if err := l.svcCtx.DB.WithContext(l.ctx).
+			Model(&user.Subscribe{}).
+			Where("user_id IN ? AND subscribe_id = ?", scopeUserIds, registerCfg.TrialSubscribe).
+			Count(&hasTrialCount).Error; err != nil {
+			return false, err
+		}
+		hasTrial = hasTrialCount > 0
+	}
+
+	return shouldShowBindEmailTrialPrompt(hasBoundEmailCount > 0, hasPurchaseCount > 0, hasTrial), nil
+}
+
+func shouldShowBindEmailTrialPrompt(hasBoundEmail, hasPurchased, hasTrial bool) bool {
+	return !hasBoundEmail && !hasPurchased && !hasTrial
+}
+
 func (l *QueryUserInfoLogic) fillFamilyContext(resp *types.User, userId int64) *user.AuthMethods {
 	type familyRelation struct {
 		FamilyId     int64

internal/logic/public/user/queryUserInfoLogic_test.go

@@ -0,0 +1,67 @@
+package user
+
+import "testing"
+
+func TestShouldShowBindEmailTrialPrompt(t *testing.T) {
+	tests := []struct {
+		name          string
+		hasBoundEmail bool
+		hasPurchased  bool
+		hasTrial      bool
+		want          bool
+	}{
+		{
+			name: "new user should see prompt",
+			want: true,
+		},
+		{
+			name:          "bound email should hide prompt",
+			hasBoundEmail: true,
+			want:          false,
+		},
+		{
+			name:         "paid purchase should hide prompt",
+			hasPurchased: true,
+			want:         false,
+		},
+		{
+			name:     "trial claimed should hide prompt",
+			hasTrial: true,
+			want:     false,
+		},
+		{
+			name:          "bound email and purchase should hide prompt",
+			hasBoundEmail: true,
+			hasPurchased:  true,
+			want:          false,
+		},
+		{
+			name:          "bound email and trial should hide prompt",
+			hasBoundEmail: true,
+			hasTrial:      true,
+			want:          false,
+		},
+		{
+			name:         "purchase and trial should hide prompt",
+			hasPurchased: true,
+			hasTrial:     true,
+			want:         false,
+		},
+		{
+			name:          "all blockers should hide prompt",
+			hasBoundEmail: true,
+			hasPurchased:  true,
+			hasTrial:      true,
+			want:          false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := shouldShowBindEmailTrialPrompt(tt.hasBoundEmail, tt.hasPurchased, tt.hasTrial)
+			if got != tt.want {
+				t.Fatalf("shouldShowBindEmailTrialPrompt(%v, %v, %v) = %v, want %v", tt.hasBoundEmail, tt.hasPurchased, tt.hasTrial, got, tt.want)
+			}
+		})
+	}
+}

internal/logic/public/user/queryWithdrawalLogLogic.go

@@ -3,9 +3,13 @@ package user
 import (
 	"context"
 
+	"github.com/perfect-panel/server/internal/model/user"
 	"github.com/perfect-panel/server/internal/svc"
 	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/constant"
 	"github.com/perfect-panel/server/pkg/logger"
+	"github.com/perfect-panel/server/pkg/xerr"
+	"github.com/pkg/errors"
 )
 
 type QueryWithdrawalLogLogic struct {
@@ -24,7 +28,49 @@ func NewQueryWithdrawalLogLogic(ctx context.Context, svcCtx *svc.ServiceContext)
 }
 
 func (l *QueryWithdrawalLogLogic) QueryWithdrawalLog(req *types.QueryWithdrawalLogListRequest) (resp *types.QueryWithdrawalLogListResponse, err error) {
-	// todo: add your logic here and delete this line
+	u, ok := l.ctx.Value(constant.CtxKeyUser).(*user.User)
+	if !ok {
+		l.Error("current user is not found in context")
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.InvalidAccess), "Invalid Access")
+	}
 
-	return
+	page := req.Page
+	size := req.Size
+	if page <= 0 {
+		page = 1
+	}
+	if size <= 0 {
+		size = 10
+	}
+
+	query := l.svcCtx.DB.WithContext(l.ctx).Model(&user.Withdrawal{}).Where("user_id = ?", u.Id)
+
+	var total int64
+	if err = query.Count(&total).Error; err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "count withdrawal logs failed: %v", err)
+	}
+
+	var rows []user.Withdrawal
+	if err = query.Order("id DESC").Limit(size).Offset((page - 1) * size).Find(&rows).Error; err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "query withdrawal logs failed: %v", err)
+	}
+
+	list := make([]types.WithdrawalLog, 0, len(rows))
+	for _, row := range rows {
+		list = append(list, types.WithdrawalLog{
+			Id:        row.Id,
+			UserId:    row.UserId,
+			Amount:    row.Amount,
+			Content:   row.Content,
+			Status:    row.Status,
+			Reason:    row.Reason,
+			CreatedAt: row.CreatedAt.UnixMilli(),
+			UpdatedAt: row.UpdatedAt.UnixMilli(),
+		})
+	}
+
+	return &types.QueryWithdrawalLogListResponse{
+		List:  list,
+		Total: total,
+	}, nil
 }

internal/middleware/deviceMiddleware.go

@@ -31,6 +31,8 @@ const (
 	ctxDecryptedQueryKey      = "decrypted_query"
 	ctxEncryptedBodyKey       = "encrypted_request_body"
 	ctxDecryptedBodyKey       = "decrypted_request_body"
+
+	deviceDecryptSkipPathPublicFileUpload = "/v1/public/file/upload"
 )
 
 func DeviceMiddleware(srvCtx *svc.ServiceContext) func(c *gin.Context) {
@@ -70,6 +72,14 @@ func DeviceMiddleware(srvCtx *svc.ServiceContext) func(c *gin.Context) {
 		}
 
 		rw := NewResponseWriter(c, srvCtx)
+		if shouldSkipDeviceRequestDecrypt(c) {
+			c.Set(ctxDeviceDecryptStatusKey, "skipped")
+			c.Set(ctxDeviceDecryptReasonKey, "multipart_upload_passthrough")
+			c.Writer = rw
+			c.Next()
+			rw.FlushAbort()
+			return
+		}
 		if !rw.Decrypt() {
 			c.Set(ctxDeviceDecryptStatusKey, "failed")
 			if _, exists := c.Get(ctxDeviceDecryptReasonKey); !exists {
@@ -85,6 +95,13 @@ func DeviceMiddleware(srvCtx *svc.ServiceContext) func(c *gin.Context) {
 	}
 }
 
+func shouldSkipDeviceRequestDecrypt(c *gin.Context) bool {
+	if c.Request.URL.Path != deviceDecryptSkipPathPublicFileUpload {
+		return false
+	}
+	return strings.HasPrefix(strings.ToLower(strings.TrimSpace(c.GetHeader("Content-Type"))), "multipart/form-data")
+}
+
 func NewResponseWriter(c *gin.Context, srvCtx *svc.ServiceContext) (rw *ResponseWriter) {
 	rw = &ResponseWriter{
 		c:              c,

internal/model/log/log.go

@@ -23,7 +23,6 @@ const (
 	TypeSubscribeTraffic  Type = 21 // Subscription traffic log
 	TypeServerTraffic     Type = 22 // Server traffic log
 	TypeResetSubscribe    Type = 23 // Reset subscription log
-	TypeOrderRefund       Type = 24 // Admin order refund log
 	TypeLogin             Type = 30 // Login log
 	TypeRegister          Type = 31 // Registration log
 	TypeBalance           Type = 32 // Balance log
@@ -50,6 +49,7 @@ const (
 	CommissionTypeWithdraw       uint16 = 334 // withdraw
 	CommissionTypeAdjust         uint16 = 335 // Admin Adjust
 	CommissionTypeConvertBalance uint16 = 336 // Convert to Balance
+	CommissionTypeWithdrawReject uint16 = 337 // Withdraw rejected refund
 	GiftTypeIncrease             uint16 = 341 // Increase
 	GiftTypeReduce               uint16 = 342 // Reduce
 )
@@ -278,42 +278,6 @@ func (c *Commission) Unmarshal(data []byte) error {
 	return json.Unmarshal(data, aux)
 }
 
-type OrderRefund struct {
-	OrderId                int64  `json:"order_id"`
-	OrderNo                string `json:"order_no"`
-	OperatorUserId         int64  `json:"operator_user_id"`
-	OperatorAuthIdentifier string `json:"operator_auth_identifier,omitempty"`
-	TargetUserId           int64  `json:"target_user_id"`
-	UserSubscribeId        int64  `json:"user_subscribe_id"`
-	RefererUserId          int64  `json:"referer_user_id,omitempty"`
-	CommissionAmount       int64  `json:"commission_amount"`
-	Reason                 string `json:"reason,omitempty"`
-	OrderStatusBefore      uint8  `json:"order_status_before"`
-	OrderStatusAfter       uint8  `json:"order_status_after"`
-	SubscribeStatusBefore  uint8  `json:"subscribe_status_before"`
-	SubscribeStatusAfter   uint8  `json:"subscribe_status_after"`
-	SubscribeExpireBefore  int64  `json:"subscribe_expire_before"`
-	SubscribeExpireAfter   int64  `json:"subscribe_expire_after"`
-	CommissionBefore       int64  `json:"commission_before"`
-	CommissionAfter        int64  `json:"commission_after"`
-	Timestamp              int64  `json:"timestamp"`
-}
-
-func (o *OrderRefund) Marshal() ([]byte, error) {
-	type Alias OrderRefund
-	return json.Marshal(&struct {
-		*Alias
-	}{
-		Alias: (*Alias)(o),
-	})
-}
-
-func (o *OrderRefund) Unmarshal(data []byte) error {
-	type Alias OrderRefund
-	aux := (*Alias)(o)
-	return json.Unmarshal(data, aux)
-}
-
 // Gift represents a gift log entry.
 type Gift struct {
 	Type        uint16 `json:"type"`

internal/model/logmessage/entity.go

@@ -5,14 +5,14 @@ import "time"
 type LogMessage struct {
 	Id         int64      `gorm:"primaryKey;AUTO_INCREMENT"`
 	Platform   string     `gorm:"type:varchar(32);not null"`
-    AppVersion string    `gorm:"type:varchar(32);default:null"`
-    OsName     string    `gorm:"type:varchar(32);default:null"`
-    OsVersion  string    `gorm:"type:varchar(32);default:null"`
-    DeviceId   string    `gorm:"type:varchar(64);default:null"`
+	AppVersion string     `gorm:"type:varchar(64);default:null"`
+	OsName     string     `gorm:"type:varchar(64);default:null"`
+	OsVersion  string     `gorm:"type:varchar(64);default:null"`
+	DeviceId   string     `gorm:"type:varchar(255);default:null"`
 	UserId     *int64     `gorm:"type:bigint;default:null"`
-    SessionId  string    `gorm:"type:varchar(64);default:null"`
+	SessionId  string     `gorm:"type:varchar(255);default:null"`
 	Level      uint8      `gorm:"type:tinyint(1);not null;default:3"`
-    ErrorCode  string    `gorm:"type:varchar(64);default:null"`
+	ErrorCode  string     `gorm:"type:varchar(128);default:null"`
 	Message    string     `gorm:"type:text;not null"`
 	Stack      string     `gorm:"type:mediumtext;default:null"`
 	Context    string     `gorm:"type:json;default:null"`

internal/model/order/model.go

@@ -110,10 +110,6 @@ func (m *customOrderModel) UpdateOrderStatus(ctx context.Context, orderNo string
 	if err != nil {
 		return err
 	}
-	keys := m.getCacheKeys(orderInfo)
-	// Pre-delete: evict cache before the DB write so concurrent reads during the update
-	// window go to DB instead of getting a stale cached status (double-delete pattern).
-	_ = m.DelCacheCtx(ctx, keys...)
 	return m.ExecCtx(ctx, func(conn *gorm.DB) error {
 		if len(tx) > 0 {
 			conn = tx[0]
@@ -127,7 +123,7 @@ func (m *customOrderModel) UpdateOrderStatus(ctx context.Context, orderNo string
 			return nil
 		}
 		return nil
-	}, keys...)
+	}, m.getCacheKeys(orderInfo)...)
 }
 
 // FindOneDetailsByOrderNo Find order details by order number
@@ -160,8 +156,8 @@ func (m *customOrderModel) QueryMonthlyOrders(ctx context.Context, date time.Tim
 			Where("status IN ? AND created_at BETWEEN ? AND ? AND method != ?", []int64{2, 5}, firstDay, lastDay, "balance").
 			Select(
 				"SUM(amount) as amount_total, " +
-					"SUM(CASE WHEN type = 1 THEN amount ELSE 0 END) as new_order_amount, " +
-					"SUM(CASE WHEN type = 2 THEN amount ELSE 0 END) as renewal_order_amount",
+					"SUM(CASE WHEN is_new = 1 THEN amount ELSE 0 END) as new_order_amount, " +
+					"SUM(CASE WHEN is_new = 0 THEN amount ELSE 0 END) as renewal_order_amount",
 			).
 			Scan(v).Error
 	})
@@ -177,8 +173,8 @@ func (m *customOrderModel) QueryDateOrders(ctx context.Context, date time.Time)
 			Where("status IN ? AND DATE_FORMAT(created_at, '%Y-%m-%d') = ? AND method != ?", []int64{2, 5}, dateStr, "balance").
 			Select(
 				"SUM(amount) as amount_total, " +
-					"SUM(CASE WHEN type = 1 THEN amount ELSE 0 END) as new_order_amount, " +
-					"SUM(CASE WHEN type = 2 THEN amount ELSE 0 END) as renewal_order_amount",
+					"SUM(CASE WHEN is_new = 1 THEN amount ELSE 0 END) as new_order_amount, " +
+					"SUM(CASE WHEN is_new = 0 THEN amount ELSE 0 END) as renewal_order_amount",
 			).
 			Scan(v).Error
 	})
@@ -192,8 +188,8 @@ func (m *customOrderModel) QueryTotalOrders(ctx context.Context) (OrdersTotal, e
 		return conn.Model(&Order{}).
 			Select(`
 				SUM(amount) AS amount_total,
-				SUM(CASE WHEN type = 1 THEN amount ELSE 0 END) AS new_order_amount,
-				SUM(CASE WHEN type = 2 THEN amount ELSE 0 END) AS renewal_order_amount
+				SUM(CASE WHEN is_new = 1 THEN amount ELSE 0 END) AS new_order_amount,
+				SUM(CASE WHEN is_new = 0 THEN amount ELSE 0 END) AS renewal_order_amount
 			`).
 			Where("status IN ? AND method != ?", []int64{2, 5}, "balance").
 			Scan(&result).Error
@@ -214,8 +210,8 @@ func (m *customOrderModel) QueryMonthlyUserCounts(ctx context.Context, date time
 	err := m.QueryNoCacheCtx(ctx, nil, func(conn *gorm.DB, _ interface{}) error {
 		return conn.Model(&Order{}).
 			Select(`
-				COUNT(DISTINCT CASE WHEN type = 1 THEN user_id END) AS new_users,
-				COUNT(DISTINCT CASE WHEN type = 2 THEN user_id END) AS renewal_users
+				COUNT(DISTINCT CASE WHEN is_new = 1 THEN user_id END) AS new_users,
+				COUNT(DISTINCT CASE WHEN is_new = 0 THEN user_id END) AS renewal_users
 			`).
 			Where("status IN ? AND created_at >= ? AND created_at < ? AND method != ?",
 				[]int64{2, 5}, firstDay, nextMonth, "balance").
@@ -232,8 +228,8 @@ func (m *customOrderModel) QueryDateUserCounts(ctx context.Context, date time.Ti
 	err := m.QueryNoCacheCtx(ctx, nil, func(conn *gorm.DB, _ interface{}) error {
 		return conn.Model(&Order{}).
 			Select(`
-				COUNT(DISTINCT CASE WHEN type = 1 THEN user_id END) AS new_users,
-				COUNT(DISTINCT CASE WHEN type = 2 THEN user_id END) AS renewal_users
+				COUNT(DISTINCT CASE WHEN is_new = 1 THEN user_id END) AS new_users,
+				COUNT(DISTINCT CASE WHEN is_new = 0 THEN user_id END) AS renewal_users
 			`).
 			Where("status IN ? AND DATE_FORMAT(created_at, '%Y-%m-%d') = ? AND method != ?",
 				[]int64{2, 5}, dateStr, "balance").
@@ -249,8 +245,8 @@ func (m *customOrderModel) QueryTotalUserCounts(ctx context.Context) (int64, int
 		return conn.Model(&Order{}).
 			Where("status IN ? AND method != ?", []int64{2, 5}, "balance").
 			Select(`
-				COUNT(DISTINCT CASE WHEN type = 1 THEN user_id END) AS new_users,
-				COUNT(DISTINCT CASE WHEN type = 2 THEN user_id END) AS renewal_users
+				COUNT(DISTINCT CASE WHEN is_new = 1 THEN user_id END) AS new_users,
+				COUNT(DISTINCT CASE WHEN is_new = 0 THEN user_id END) AS renewal_users
 			`).
 			Scan(&counts).Error
 	})
@@ -282,8 +278,8 @@ func (m *customOrderModel) QueryDailyOrdersList(ctx context.Context, date time.T
 			Select(`
 				DATE_FORMAT(created_at, '%Y-%m-%d') AS date,
 				SUM(amount) AS amount_total,
-				SUM(CASE WHEN type = 1 THEN amount ELSE 0 END) AS new_order_amount,
-				SUM(CASE WHEN type = 2 THEN amount ELSE 0 END) AS renewal_order_amount
+				SUM(CASE WHEN is_new = 1 THEN amount ELSE 0 END) AS new_order_amount,
+				SUM(CASE WHEN is_new = 0 THEN amount ELSE 0 END) AS renewal_order_amount
 			`).
 			Where("status IN ? AND created_at >= ? AND created_at < ? AND method != ?",
 				[]int64{2, 5}, firstDay, nextDay, "balance").
@@ -326,8 +322,8 @@ func (m *customOrderModel) QueryMonthlyOrdersList(ctx context.Context, date time
 			Select(`
 				DATE_FORMAT(created_at, '%Y-%m') AS date,
 				SUM(amount) AS amount_total,
-				SUM(CASE WHEN type = 1 THEN amount ELSE 0 END) AS new_order_amount,
-				SUM(CASE WHEN type = 2 THEN amount ELSE 0 END) AS renewal_order_amount
+				SUM(CASE WHEN is_new = 1 THEN amount ELSE 0 END) AS new_order_amount,
+				SUM(CASE WHEN is_new = 0 THEN amount ELSE 0 END) AS renewal_order_amount
 			`).
 			Where("status IN ? AND created_at >= ? AND created_at < ? AND method != ?",
 				[]int64{2, 5}, start, end, "balance").

internal/model/order/order.go

@@ -25,7 +25,6 @@ type Order struct {
 	SubscribeId    int64     `gorm:"type:bigint;not null;default:0;comment:Subscribe Id"`
 	SubscribeToken  string    `gorm:"type:varchar(255);default:null;comment:Renewal Subscribe Token"`
 	AppAccountToken string    `gorm:"type:varchar(36);default:null;comment:Apple IAP App Account Token (UUID)"`
-	ActivationContext string    `gorm:"type:text;default:null;comment:Activation context JSON (guest/redemption info for DB fallback)"`
 	IsNew           bool      `gorm:"type:tinyint(1);not null;default:0;comment:Is New Order"`
 	CreatedAt      time.Time `gorm:"<-:create;comment:Create Time"`
 	UpdatedAt      time.Time `gorm:"comment:Update Time"`

internal/model/user/default.go

@@ -26,6 +26,7 @@ type (
 		Insert(ctx context.Context, data *User, tx ...*gorm.DB) error
 		FindOne(ctx context.Context, id int64) (*User, error)
 		Update(ctx context.Context, data *User, tx ...*gorm.DB) error
+		UpdateCommission(ctx context.Context, userId int64, delta int64, tx ...*gorm.DB) error
 		Delete(ctx context.Context, id int64, tx ...*gorm.DB) error
 		Transaction(ctx context.Context, fn func(db *gorm.DB) error) error
 	}
@@ -111,6 +112,22 @@ func (m *defaultUserModel) Update(ctx context.Context, data *User, tx ...*gorm.D
 	return err
 }
 
+func (m *defaultUserModel) UpdateCommission(ctx context.Context, userId int64, delta int64, tx ...*gorm.DB) error {
+	old, err := m.FindOne(ctx, userId)
+	if err != nil {
+		return err
+	}
+
+	return m.ExecCtx(ctx, func(conn *gorm.DB) error {
+		if len(tx) > 0 {
+			conn = tx[0]
+		}
+		return conn.Model(&User{}).
+			Where("id = ?", userId).
+			UpdateColumn("commission", gorm.Expr("commission + ?", delta)).Error
+	}, m.getCacheKeys(old)...)
+}
+
 func (m *defaultUserModel) Delete(ctx context.Context, id int64, tx ...*gorm.DB) error {
 	data, err := m.FindOne(ctx, id)
 	if err != nil {

internal/model/user/device.go

@@ -8,6 +8,22 @@ import (
 	"gorm.io/gorm"
 )
 
+const userDeviceUserAgentMaxLength = 255
+
+func normalizeDeviceForStorage(data *Device) {
+	if data == nil {
+		return
+	}
+	data.UserAgent = truncateForColumn(data.UserAgent, userDeviceUserAgentMaxLength)
+}
+
+func truncateForColumn(s string, max int) string {
+	if len(s) <= max {
+		return s
+	}
+	return s[:max]
+}
+
 func (m *customUserModel) FindOneDevice(ctx context.Context, id int64) (*Device, error) {
 	deviceIdKey := fmt.Sprintf("%s%v", cacheUserDeviceIdPrefix, id)
 	var resp Device
@@ -69,6 +85,7 @@ func (m *customUserModel) QueryDeviceListByUserIds(ctx context.Context, userIds
 }
 
 func (m *customUserModel) UpdateDevice(ctx context.Context, data *Device, tx ...*gorm.DB) error {
+	normalizeDeviceForStorage(data)
 	old, err := m.FindOneDevice(ctx, data.Id)
 	if err != nil {
 		return err
@@ -100,6 +117,7 @@ func (m *customUserModel) DeleteDevice(ctx context.Context, id int64, tx ...*gor
 }
 
 func (m *customUserModel) InsertDevice(ctx context.Context, data *Device, tx ...*gorm.DB) error {
+	normalizeDeviceForStorage(data)
 	defer func() {
 		if clearErr := m.ClearDeviceCache(ctx, data); clearErr != nil {
 			// log cache clear error

internal/model/user/model.go

@@ -378,13 +378,13 @@ func (m *customUserModel) QueryDailyUserStatisticsList(ctx context.Context, date
 		// 子查询：统计每天的新用户订单数量
 		newOrderSub := conn.Model(&order.Order{}).
 			Select("DATE_FORMAT(created_at, '%Y-%m-%d') AS date, COUNT(DISTINCT user_id) AS new_order_users").
-			Where("type = 1 AND created_at BETWEEN ? AND ? AND status IN ? AND method != ?", firstDay, date, []int64{2, 5}, "balance").
+			Where("is_new = 1 AND created_at BETWEEN ? AND ? AND status IN ?", firstDay, date, []int64{2, 5}).
 			Group("DATE_FORMAT(created_at, '%Y-%m-%d')")
 
 		// 子查询：统计每天的续费订单数量
 		renewalOrderSub := conn.Model(&order.Order{}).
 			Select("DATE_FORMAT(created_at, '%Y-%m-%d') AS date, COUNT(DISTINCT user_id) AS renewal_order_users").
-			Where("type = 2 AND created_at BETWEEN ? AND ? AND status IN ? AND method != ?", firstDay, date, []int64{2, 5}, "balance").
+			Where("is_new = 0 AND created_at BETWEEN ? AND ? AND status IN ?", firstDay, date, []int64{2, 5}).
 			Group("DATE_FORMAT(created_at, '%Y-%m-%d')")
 
 		return conn.Model(&User{}).
@@ -416,13 +416,13 @@ func (m *customUserModel) QueryMonthlyUserStatisticsList(ctx context.Context, da
 		// 子查询：每月新订单用户数量
 		newOrderSub := conn.Model(&order.Order{}).
 			Select("DATE_FORMAT(created_at, '%Y-%m') AS date, COUNT(DISTINCT user_id) AS new_order_users").
-			Where("type = 1 AND created_at >= ? AND status IN ? AND method != ?", sixMonthsAgo, []int64{2, 5}, "balance").
+			Where("is_new = 1 AND created_at >= ? AND status IN ?", sixMonthsAgo, []int64{2, 5}).
 			Group("DATE_FORMAT(created_at, '%Y-%m')")
 
 		// 子查询：每月续费订单用户数量
 		renewalOrderSub := conn.Model(&order.Order{}).
 			Select("DATE_FORMAT(created_at, '%Y-%m') AS date, COUNT(DISTINCT user_id) AS renewal_order_users").
-			Where("type = 2 AND created_at >= ? AND status IN ? AND method != ?", sixMonthsAgo, []int64{2, 5}, "balance").
+			Where("is_new = 0 AND created_at >= ? AND status IN ?", sixMonthsAgo, []int64{2, 5}).
 			Group("DATE_FORMAT(created_at, '%Y-%m')")
 
 		return conn.Model(&User{}).

internal/types/types.go

@@ -7,11 +7,6 @@ type ActivateOrderRequest struct {
 	OrderNo string `json:"order_no" validate:"required"`
 }
 
-type RefundOrderRequest struct {
-	Id     int64  `json:"id" validate:"required"`
-	Reason string `json:"reason,omitempty" validate:"omitempty,max=500"`
-}
-
 type Ads struct {
 	Id          int    `json:"id"`
 	Title       string `json:"title"`
@@ -831,17 +826,6 @@ type FilterCommissionLogResponse struct {
 	List  []CommissionLog `json:"list"`
 }
 
-type FilterOrderRefundLogRequest struct {
-	FilterLogParams
-	OrderId int64 `form:"order_id,optional"`
-	UserId  int64 `form:"user_id,optional"`
-}
-
-type FilterOrderRefundLogResponse struct {
-	Total int64            `json:"total"`
-	List  []OrderRefundLog `json:"list"`
-}
-
 type FilterEmailLogResponse struct {
 	Total int64        `json:"total"`
 	List  []MessageLog `json:"list"`
@@ -1868,7 +1852,6 @@ type Order struct {
 	FeeAmount      int64         `json:"fee_amount"`
 	TradeNo        string        `json:"trade_no"`
 	Status         uint8         `json:"status"`
-	StatusName     string        `json:"status_name,omitempty"`
 	SubscribeId    int64         `json:"subscribe_id"`
 	CreatedAt      int64         `json:"created_at"`
 	UpdatedAt      int64         `json:"updated_at"`
@@ -1892,34 +1875,12 @@ type OrderDetail struct {
 	FeeAmount      int64         `json:"fee_amount"`
 	TradeNo        string        `json:"trade_no"`
 	Status         uint8         `json:"status"`
-	StatusName     string        `json:"status_name,omitempty"`
 	SubscribeId    int64         `json:"subscribe_id"`
 	Subscribe      Subscribe     `json:"subscribe"`
 	CreatedAt      int64         `json:"created_at"`
 	UpdatedAt      int64         `json:"updated_at"`
 }
 
-type OrderRefundLog struct {
-	OrderId                int64  `json:"order_id"`
-	OrderNo                string `json:"order_no"`
-	OperatorUserId         int64  `json:"operator_user_id"`
-	OperatorAuthIdentifier string `json:"operator_auth_identifier,omitempty"`
-	TargetUserId           int64  `json:"target_user_id"`
-	UserSubscribeId        int64  `json:"user_subscribe_id"`
-	RefererUserId          int64  `json:"referer_user_id,omitempty"`
-	CommissionAmount       int64  `json:"commission_amount"`
-	Reason                 string `json:"reason,omitempty"`
-	OrderStatusBefore      uint8  `json:"order_status_before"`
-	OrderStatusAfter       uint8  `json:"order_status_after"`
-	SubscribeStatusBefore  uint8  `json:"subscribe_status_before"`
-	SubscribeStatusAfter   uint8  `json:"subscribe_status_after"`
-	SubscribeExpireBefore  int64  `json:"subscribe_expire_before"`
-	SubscribeExpireAfter   int64  `json:"subscribe_expire_after"`
-	CommissionBefore       int64  `json:"commission_before"`
-	CommissionAfter        int64  `json:"commission_after"`
-	Timestamp              int64  `json:"timestamp"`
-}
-
 type OrdersStatistics struct {
 	Date               string             `json:"date,omitempty"`
 	AmountTotal        int64              `json:"amount_total"`
@@ -2323,6 +2284,27 @@ type QueryWithdrawalLogListResponse struct {
 	Total int64           `json:"total"`
 }
 
+type GetWithdrawalListRequest struct {
+	Page   int    `form:"page"`
+	Size   int    `form:"size"`
+	UserId *int64 `form:"user_id,omitempty"`
+	Status *uint8 `form:"status,omitempty"`
+}
+
+type GetWithdrawalListResponse struct {
+	List  []WithdrawalLog `json:"list"`
+	Total int64           `json:"total"`
+}
+
+type ApproveWithdrawalRequest struct {
+	WithdrawalId int64 `json:"withdrawal_id" validate:"required,gt=0"`
+}
+
+type RejectWithdrawalRequest struct {
+	WithdrawalId int64  `json:"withdrawal_id" validate:"required,gt=0"`
+	Reason       string `json:"reason" validate:"required,max=500"`
+}
+
 type QuotaTask struct {
 	Id           int64   `json:"id"`
 	Subscribers  []int64 `json:"subscribers"`
@@ -3317,6 +3299,7 @@ type User struct {
 	EnableLoginNotify     bool             `json:"enable_login_notify"`
 	EnableSubscribeNotify bool             `json:"enable_subscribe_notify"`
 	EnableTradeNotify     bool             `json:"enable_trade_notify"`
+	UseStatus             bool             `json:"use_status"`
 	AuthMethods           []UserAuthMethod `json:"auth_methods"`
 	UserDevices           []UserDevice     `json:"user_devices"`
 	Rules                 []string         `json:"rules"`

ops/aws-rds-external-replica-runbook.md

@@ -22,7 +22,7 @@
 - Region: `ap-east-1`
 - AWS app EC2:
   - Name: `hifast-hk-app-01`
-  - Public IP: `43.198.248.161`
+  - Public IP: `18.163.33.75`
   - Private IP: `10.0.1.201`
 - AWS MySQL:
   - Type: `RDS MySQL`
@@ -183,7 +183,7 @@ redis-cli INFO replication
 重点看：
 
 - `role:slave`
-- `master_host:43.198.248.161`
+- `master_host:18.163.33.75`
 - `master_port:6379`
 - `master_link_status:up`
 
@@ -416,7 +416,7 @@ SHOW REPLICA STATUS\G
 
 ```bash
 redis-cli CONFIG SET masterauth '0BVz9XOHf7KUfEuoFJRK-dURdKUGFiZ8QeaHpysHnKeKhLskZb55HPK121lFsKtr'
-redis-cli REPLICAOF 43.198.248.161 6379
+redis-cli REPLICAOF 18.163.33.75 6379
 redis-cli CONFIG SET replica-read-only yes
 redis-cli INFO replication
 ```
@@ -426,7 +426,7 @@ redis-cli INFO replication
 检查 `/etc/redis/redis.conf` 至少包含：
 
 ```conf
-replicaof 43.198.248.161 6379
+replicaof 18.163.33.75 6379
 masterauth 0BVz9XOHf7KUfEuoFJRK-dURdKUGFiZ8QeaHpysHnKeKhLskZb55HPK121lFsKtr
 replica-read-only yes
 ```

ops/hifast-aws-standby-architecture-zh.md

@@ -66,7 +66,7 @@
 - Instance ID: `i-079cd9d3ef3748714`
 - 角色：当前实际生产入口 / Nginx / 业务服务 / AWS 侧 Redis 主库宿主机
 - 私网 IP: `10.0.1.201`
-- 公网 IP: `43.198.248.161`
+- 公网 IP: `18.163.33.75`
 - 业务服务运行方式：`Docker Compose`
 - 业务容器：`ppanel-server`
 - 部署目录：`/opt/ppanel`
@@ -103,7 +103,7 @@
 - 容器名：`hifast-redis`
 - 版本：`redis:8.2.1`
 - 访问端口：`6379`
-- 主库出口地址：`43.198.248.161:6379`
+- 主库出口地址：`18.163.33.75:6379`
 - 应用当前实际连接：`127.0.0.1:6379`
 - 认证方式：已启用密码认证
 
@@ -130,10 +130,10 @@
 ```mermaid
 flowchart TB
     USER["用户 / 客户端"] --> DNS["域名 / DNS / 入口层"]
-    DNS --> APP["AWS EC2\nhifast-hk-app-01\n43.198.248.161\n10.0.1.201"]
+    DNS --> APP["AWS EC2\nhifast-hk-app-01\n18.163.33.75\n10.0.1.201"]
 
     APP --> RDS["AWS RDS MySQL\nhifast-mysql-prod-v2\n主库"]
-    APP --> REDISM["AWS Redis 主库\nDocker redis:8.2.1\n43.198.248.161:6379"]
+    APP --> REDISM["AWS Redis 主库\nDocker redis:8.2.1\n18.163.33.75:6379"]
 
     RDS -. MySQL 备用 / 同步 .-> MYSQLS["104.238.220.230\nMySQL 备用库"]
     REDISM -. Redis 主从复制 .-> REDISS["104.238.220.230\n原生 Redis 8.6.3\n从库"]
@@ -238,7 +238,7 @@ App / Nginx
 
 ```mermaid
 flowchart LR
-    SG["hifast-hk-app-core-sg"] --> REDIS["AWS Redis 主库\n43.198.248.161:6379"]
+    SG["hifast-hk-app-core-sg"] --> REDIS["AWS Redis 主库\n18.163.33.75:6379"]
     STANDBY["104.238.220.230/32"] --> SG
 ```
 
@@ -311,7 +311,7 @@ RDS 当前状态已经比之前干净很多：
 
 `104.238.220.230` 连接 AWS Redis，不是通过 PEM 证书，也不是通过 SSH 登录 AWS 机器，而是直接作为 Redis 从库去访问 AWS Redis 主库：
 
-- 目标地址：`43.198.248.161:6379`
+- 目标地址：`18.163.33.75:6379`
 - 连接方式：`TCP`
 - 认证方式：`Redis 密码`
 - 网络前提：AWS EC2 安全组已放行 `104.238.220.230/32 -> 6379`
@@ -325,7 +325,7 @@ RDS 当前状态已经比之前干净很多：
 示意命令：
 
 ```bash
-redis-cli -h 43.198.248.161 -p 6379 -a '<REDIS_PASSWORD>'
+redis-cli -h 18.163.33.75 -p 6379 -a '<REDIS_PASSWORD>'
 ```
 
 ### 4.6.2 104 连接 AWS MySQL RDS 的方式
@@ -380,7 +380,7 @@ mysql -h hifast-mysql-prod-v2.cd6aey40m6ag.ap-east-1.rds.amazonaws.com -u admin
 
 - 部署方式：Docker
 - 版本：`8.2.1`
-- 主库地址：`43.198.248.161:6379`
+- 主库地址：`18.163.33.75:6379`
 - 运行容器：`hifast-redis`
 
 ### 5.2 104 Redis 从库
@@ -417,7 +417,7 @@ mysql -h hifast-mysql-prod-v2.cd6aey40m6ag.ap-east-1.rds.amazonaws.com -u admin
 
 ```mermaid
 flowchart LR
-    REDISMASTER["AWS Redis 主库\n43.198.248.161:6379\nDocker redis:8.2.1"]
+    REDISMASTER["AWS Redis 主库\n18.163.33.75:6379\nDocker redis:8.2.1"]
     REDISSLAVE["104.238.220.230\n原生 Redis 8.6.3\nrole: slave"]
     REDISMASTER --> REDISSLAVE
 ```

pkg/xerr/errCode.go

@@ -146,7 +146,4 @@ const (
 	OrderStatusError      uint32 = 61003
 	InsufficientOfPeriod  uint32 = 61004
 	ExistAvailableTraffic uint32 = 61005
-	OrderAlreadyRefunded          uint32 = 61006
-	OrderRefundNoSubscription     uint32 = 61007
-	OrderRefundCommissionMismatch uint32 = 61008
 )

pkg/xerr/errMsg.go

@@ -103,9 +103,6 @@ func init() {
 		PaymentMethodNotFound: "Payment method not found",
 		OrderStatusError:      "Order status error",
 		InsufficientOfPeriod:  "Insufficient number of period",
-		OrderAlreadyRefunded:          "Order already refunded",
-		OrderRefundNoSubscription:     "Refund target subscription not found",
-		OrderRefundCommissionMismatch: "Refund commission source not found",
 
 		// Permission error
 		PermissionDenied: "Permission denied",

queue/handler/routes.go

@@ -49,6 +49,6 @@ func RegisterHandlers(mux *asynq.ServeMux, serverCtx *svc.ServiceContext) {
 	mux.Handle(types.SchedulerIAPReconcile, iapLogic.NewReconcileLogic(serverCtx))
 	mux.Handle(types.SchedulerIAPDailyReconcile, iapLogic.NewDailyReconcileLogic(serverCtx))
 
-	// Stuck order recovery
+	// Stuck order recovery: reset claimed orders that timed out back to paid
 	mux.Handle(types.SchedulerStuckOrderRecovery, orderLogic.NewStuckOrderRecoveryLogic(serverCtx))
 }

queue/logic/order/activateOrderLogic.go

@@ -93,11 +93,12 @@ func (l *ActivateOrderLogic) ProcessTask(ctx context.Context, task *asynq.Task)
 
 	orderInfo, err := l.claimAndGetOrder(ctx, payload.OrderNo)
 	if err != nil {
+		// 如果订单不存在或状态不对，不重试
 		if errors.Is(err, ErrInvalidOrderStatus) {
 			if strings.Contains(err.Error(), "stuck in claimed") {
 				logger.WithContext(ctx).Error("[ActivateOrderLogic] 订单卡在 claimed，将重试",
 					logger.Field("order_no", payload.OrderNo))
-				return err // 返回错误触发 asynq 重试
+				return err
 			}
 			logger.WithContext(ctx).Info("[ActivateOrderLogic] 订单状态不是已支付，跳过",
 				logger.Field("order_no", payload.OrderNo))
@@ -191,7 +192,6 @@ func (l *ActivateOrderLogic) claimAndGetOrder(ctx context.Context, orderNo strin
 		return nil, nil
 	}
 
-	// Detect stuck claimed order — return retryable error so asynq re-tries
 	if orderInfo.Status == OrderStatusClaimed {
 		logger.WithContext(ctx).Error("Order stuck in claimed status",
 			logger.Field("order_no", orderInfo.OrderNo),
@@ -589,9 +589,8 @@ func (l *ActivateOrderLogic) finalizeCouponAndOrder(ctx context.Context, orderIn
 		}
 	}
 
-	// UpdateOrderStatus uses WHERE status < target, which blocks claimed(6)→finished(5).
-	// Use a direct update matching the exact claimed status, then update the full record
-	// via the model layer to properly invalidate the cache.
+	// Direct update from claimed(6) → finished(5), bypassing the model's status<target guard.
+	// UpdateOrderStatus uses WHERE status < ?, so status=6 > 5 would never match.
 	result := l.svc.DB.WithContext(ctx).
 		Model(&order.Order{}).
 		Where("order_no = ? AND status = ?", orderInfo.OrderNo, OrderStatusClaimed).
@@ -602,14 +601,18 @@ func (l *ActivateOrderLogic) finalizeCouponAndOrder(ctx context.Context, orderIn
 			logger.Field("order_no", orderInfo.OrderNo),
 		)
 	}
-	// Invalidate order cache regardless of whether the DB update succeeded
-	orderInfo.Status = OrderStatusFinished
-	if err := l.svc.OrderModel.Update(ctx, orderInfo); err != nil {
-		logger.WithContext(ctx).Error("Update order cache after finalization failed",
-			logger.Field("error", err.Error()),
+	// Invalidate cache entries; key format matches order/default.go cacheOrderIdPrefix / cacheOrderNoPrefix.
+	cacheKeys := []string{
+		fmt.Sprintf("cache:order:id:%d", orderInfo.Id),
+		fmt.Sprintf("cache:order:no:%s", orderInfo.OrderNo),
+	}
+	if delErr := l.svc.Redis.Del(ctx, cacheKeys...).Err(); delErr != nil {
+		logger.WithContext(ctx).Error("Failed to invalidate order cache after status update",
+			logger.Field("error", delErr.Error()),
 			logger.Field("order_no", orderInfo.OrderNo),
 		)
 	}
+	orderInfo.Status = OrderStatusFinished
 	commonLogic.SubscriptionTraceInfo(logger.WithContext(ctx), commonLogic.SubscriptionTraceFlowOrder, "order_status_finished",
 		"[SubscriptionFlow] order status updated to finished",
 		commonLogic.OrderTraceFields(orderInfo)...,
@@ -636,7 +639,7 @@ func (l *ActivateOrderLogic) NewPurchase(ctx context.Context, orderInfo *order.O
 		return err
 	}
 
-	if err = validateNewUserOnlyEligibilityAtActivation(ctx, l.svc.DB, l.svc.Redis, orderInfo, sub); err != nil {
+	if err = validateNewUserOnlyEligibilityAtActivation(ctx, l.svc.DB, orderInfo, sub); err != nil {
 		return err
 	}
 
@@ -714,23 +717,18 @@ func (l *ActivateOrderLogic) NewPurchase(ctx context.Context, orderInfo *order.O
 	// 兜底：创建新订阅前，查找用户是否已有同套餐的订阅记录（含过期/赠送），
 	// 有则复用旧记录续期，避免出现重复订阅。
 	// 需要同时检查 UserId 和 SubscriptionUserId，因为家庭组绑定前后 owner 可能不同。
-	// 使用 SELECT ... FOR UPDATE 防止并发下多个 worker 同时选中同一订阅并创建重复记录。
 	if userSub == nil {
 		candidateUserIds := []int64{orderInfo.UserId}
 		if orderInfo.SubscriptionUserId > 0 && orderInfo.SubscriptionUserId != orderInfo.UserId {
 			candidateUserIds = append(candidateUserIds, orderInfo.SubscriptionUserId)
 		}
 		var existingSub user.Subscribe
-		findErr := l.svc.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
-			return tx.Clauses(clause.Locking{Strength: "UPDATE"}).
-				Model(&user.Subscribe{}).
+		if findErr := l.svc.DB.Model(&user.Subscribe{}).
 			Where("user_id IN ? AND token != ''", candidateUserIds).
 			Order("expire_time DESC").
 			Order("updated_at DESC").
 			Order("id DESC").
-				First(&existingSub).Error
-		})
-		if findErr == nil {
+			First(&existingSub).Error; findErr == nil {
 			// 家庭组场景：订阅 owner 可能变更（如成员注册的试用 → 被家主收归），
 			// 续期前把 user_id 校正为当前订单的 SubscriptionUserId
 			effectiveOwner := orderInfo.UserId
@@ -868,52 +866,26 @@ func (l *ActivateOrderLogic) createGuestUser(ctx context.Context, orderInfo *ord
 	return userInfo, nil
 }
 
-// getTempOrderInfo retrieves temporary order information from Redis cache with DB fallback.
+// getTempOrderInfo retrieves temporary order information from Redis cache
 func (l *ActivateOrderLogic) getTempOrderInfo(ctx context.Context, orderNo string) (*constant.TemporaryOrderInfo, error) {
 	cacheKey := fmt.Sprintf(constant.TempOrderCacheKey, orderNo)
 	data, err := l.svc.Redis.Get(ctx, cacheKey).Result()
-	if err == nil {
+	if err != nil {
+		logger.WithContext(ctx).Error("Get temp order cache failed",
+			logger.Field("error", err.Error()),
+			logger.Field("cache_key", cacheKey),
+		)
+		return nil, err
+	}
+
 	var tempOrder constant.TemporaryOrderInfo
-		if unmarshalErr := tempOrder.Unmarshal([]byte(data)); unmarshalErr != nil {
+	if err = tempOrder.Unmarshal([]byte(data)); err != nil {
 		logger.WithContext(ctx).Error("Unmarshal temp order cache failed",
-				logger.Field("error", unmarshalErr.Error()),
+			logger.Field("error", err.Error()),
 			logger.Field("cache_key", cacheKey),
 			logger.Field("data", data),
 		)
-			return nil, unmarshalErr
-		}
-		return &tempOrder, nil
-	}
-
-	// Redis miss — fall back to DB activation_context field.
-	logger.WithContext(ctx).Infow("Redis cache miss for temp order, falling back to DB",
-		logger.Field("cache_key", cacheKey),
-		logger.Field("error", err.Error()),
-	)
-
-	orderInfo, dbErr := l.svc.OrderModel.FindOneByOrderNo(ctx, orderNo)
-	if dbErr != nil {
-		logger.WithContext(ctx).Error("DB fallback for temp order failed",
-			logger.Field("order_no", orderNo),
-			logger.Field("error", dbErr.Error()),
-		)
-		return nil, dbErr
-	}
-
-	if orderInfo.ActivationContext == "" {
-		logger.WithContext(ctx).Error("CRITICAL: activation_context missing in DB and Redis expired; cannot recover guest order",
-			logger.Field("order_no", orderNo),
-		)
-		return nil, errors.New("activation context not found: Redis expired and no DB fallback available")
-	}
-
-	var tempOrder constant.TemporaryOrderInfo
-	if unmarshalErr := tempOrder.Unmarshal([]byte(orderInfo.ActivationContext)); unmarshalErr != nil {
-		logger.WithContext(ctx).Error("Unmarshal DB activation_context failed",
-			logger.Field("order_no", orderNo),
-			logger.Field("error", unmarshalErr.Error()),
-		)
-		return nil, unmarshalErr
+		return nil, err
 	}
 
 	return &tempOrder, nil
@@ -1517,40 +1489,7 @@ func (l *ActivateOrderLogic) resolveRenewalActivationSubscription(ctx context.Co
 	}
 	userSub, err := l.getUserSubscription(ctx, orderInfo.SubscribeToken)
 	if err != nil {
-		// Fallback: token may have been lost (subscription deleted or owner changed).
-		// Locate the most recent subscription by user_id + subscribe_id with FOR UPDATE
-		// to prevent a concurrent worker from renewing the same record twice.
-		targetUserID := orderInfo.UserId
-		if orderInfo.SubscriptionUserId > 0 {
-			targetUserID = orderInfo.SubscriptionUserId
-		}
-		var fallbackSub user.Subscribe
-		txErr := l.svc.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
-			return tx.Clauses(clause.Locking{Strength: "UPDATE"}).
-				Model(&user.Subscribe{}).
-				Where("user_id = ? AND subscribe_id = ?", targetUserID, orderInfo.SubscribeId).
-				Where("status IN ?", []int64{0, 1, 2, 3}).
-				Order("expire_time DESC").
-				Order("updated_at DESC").
-				Order("id DESC").
-				First(&fallbackSub).Error
-		})
-		if txErr != nil {
-			logger.WithContext(ctx).Error("CRITICAL: Renewal activation token and fallback lookup both failed",
-				logger.Field("token_error", err.Error()),
-				logger.Field("fallback_error", txErr.Error()),
-				logger.Field("order_no", orderInfo.OrderNo),
-				logger.Field("target_user_id", targetUserID),
-				logger.Field("subscribe_id", orderInfo.SubscribeId),
-			)
-			return nil, fmt.Errorf("renewal activation subscription not found by token or user_id+subscribe_id for order %s: %w", orderInfo.OrderNo, err)
-		}
-		logger.WithContext(ctx).Info("Renewal token lookup failed; found subscription via fallback user_id+subscribe_id",
-			logger.Field("order_no", orderInfo.OrderNo),
-			logger.Field("fallback_subscribe_id", fallbackSub.Id),
-			logger.Field("target_user_id", targetUserID),
-		)
-		userSub = &fallbackSub
+		return nil, err
 	}
 	if orderInfo.UserId <= 0 {
 		return userSub, nil
@@ -1846,51 +1785,26 @@ func (l *ActivateOrderLogic) RedemptionActivate(ctx context.Context, orderInfo *
 		return err
 	}
 
-	// 3. 从Redis获取兑换码信息，Redis缺失时回查DB
+	// 3. 从Redis获取兑换码信息
+	cacheKey := fmt.Sprintf("redemption_order:%s", orderInfo.OrderNo)
+	data, err := l.svc.Redis.Get(ctx, cacheKey).Result()
+	if err != nil {
+		logger.WithContext(ctx).Error("Get redemption cache failed",
+			logger.Field("error", err.Error()),
+			logger.Field("cache_key", cacheKey),
+		)
+		return err
+	}
+
 	var redemptionData struct {
 		RedemptionCodeId int64  `json:"redemption_code_id"`
 		UnitTime         string `json:"unit_time"`
 		Quantity         int64  `json:"quantity"`
 	}
-
-	cacheKey := fmt.Sprintf("redemption_order:%s", orderInfo.OrderNo)
-	data, redisErr := l.svc.Redis.Get(ctx, cacheKey).Result()
-	if redisErr == nil {
 	if err = json.Unmarshal([]byte(data), &redemptionData); err != nil {
 		logger.WithContext(ctx).Error("Unmarshal redemption cache failed", logger.Field("error", err.Error()))
 		return err
 	}
-	} else {
-		// Redis miss — fall back to DB activation_context field.
-		logger.WithContext(ctx).Infow("Redis cache miss for redemption order, falling back to DB",
-			logger.Field("cache_key", cacheKey),
-			logger.Field("error", redisErr.Error()),
-		)
-
-		if orderInfo.ActivationContext == "" {
-			logger.WithContext(ctx).Error("CRITICAL: activation_context missing in DB and Redis expired; cannot recover redemption order",
-				logger.Field("order_no", orderInfo.OrderNo),
-			)
-			return errors.New("activation context not found: Redis expired and no DB fallback available")
-		}
-
-		var fullContext struct {
-			Type             string `json:"type"`
-			RedemptionCodeId int64  `json:"redemption_code_id"`
-			UnitTime         string `json:"unit_time"`
-			Quantity         int64  `json:"quantity"`
-		}
-		if err = json.Unmarshal([]byte(orderInfo.ActivationContext), &fullContext); err != nil {
-			logger.WithContext(ctx).Error("Unmarshal DB activation_context failed",
-				logger.Field("order_no", orderInfo.OrderNo),
-				logger.Field("error", err.Error()),
-			)
-			return err
-		}
-		redemptionData.RedemptionCodeId = fullContext.RedemptionCodeId
-		redemptionData.UnitTime = fullContext.UnitTime
-		redemptionData.Quantity = fullContext.Quantity
-	}
 
 	// 4. 幂等性检查：查询是否已有兑换记录
 	existingRecords, err := l.svc.RedemptionRecordModel.FindByUserId(ctx, userInfo.Id)

queue/logic/order/newUserEligibility.go

@@ -10,14 +10,12 @@ import (
 	"github.com/perfect-panel/server/internal/model/order"
 	"github.com/perfect-panel/server/internal/model/subscribe"
 	internaltypes "github.com/perfect-panel/server/internal/types"
-	"github.com/redis/go-redis/v9"
 	"gorm.io/gorm"
 )
 
 func validateNewUserOnlyEligibilityAtActivation(
 	ctx context.Context,
 	db *gorm.DB,
-	rdb *redis.Client,
 	orderInfo *order.Order,
 	sub *subscribe.Subscribe,
 ) error {
@@ -33,20 +31,6 @@ func validateNewUserOnlyEligibilityAtActivation(
 		return nil
 	}
 
-	// Acquire a per-user distributed lock so concurrent new-user-only activations
-	// for the same account are serialised. Without this, two workers can both read
-	// historyCount=0 and both pass the check before either has written the order.
-	lockKey := fmt.Sprintf("new_user_only_activate:%d", orderInfo.UserId)
-	const lockTTL = 30 * time.Second
-	acquired, lockErr := rdb.SetNX(ctx, lockKey, orderInfo.OrderNo, lockTTL).Result()
-	if lockErr != nil {
-		return fmt.Errorf("new user only: acquire lock error: %w", lockErr)
-	}
-	if !acquired {
-		return fmt.Errorf("new user only: another activation is in progress for user %d", orderInfo.UserId)
-	}
-	defer rdb.Del(ctx, lockKey)
-
 	eligibility, err := commonLogic.ResolveNewUserEligibility(ctx, db, orderInfo.UserId)
 	if err != nil {
 		return err

queue/logic/order/stuckOrderRecoveryLogic.go

@@ -12,7 +12,10 @@ import (
 	queueTypes "github.com/perfect-panel/server/queue/types"
 )
 
-// StuckOrderRecoveryLogic scans orders stuck in claimed status and re-queues them for processing.
+const stuckClaimTimeout = 10 * time.Minute
+
+// StuckOrderRecoveryLogic scans orders stuck in claimed(6) status and resets them to paid(2)
+// so that asynq retry can re-claim and process them.
 type StuckOrderRecoveryLogic struct {
 	svc *svc.ServiceContext
 }
@@ -21,11 +24,8 @@ func NewStuckOrderRecoveryLogic(svc *svc.ServiceContext) *StuckOrderRecoveryLogi
 	return &StuckOrderRecoveryLogic{svc: svc}
 }
 
-// ProcessTask scans for orders stuck in claimed status for over 10 minutes,
-// resets them to paid, and re-enqueues the activate task so they are retried
-// independently of asynq's original retry counter (which may be exhausted).
 func (l *StuckOrderRecoveryLogic) ProcessTask(ctx context.Context, _ *asynq.Task) error {
-	cutoff := time.Now().Add(-10 * time.Minute)
+	cutoff := time.Now().Add(-stuckClaimTimeout)
 
 	var stuckOrders []order.Order
 	if err := l.svc.DB.WithContext(ctx).
@@ -46,57 +46,39 @@ func (l *StuckOrderRecoveryLogic) ProcessTask(ctx context.Context, _ *asynq.Task
 	for i := range stuckOrders {
 		orderNos = append(orderNos, stuckOrders[i].OrderNo)
 	}
-	logger.WithContext(ctx).Error("[StuckOrderRecovery] Found stuck claimed orders, recovering",
+
+	logger.WithContext(ctx).Error("[StuckOrderRecovery] Found stuck claimed orders, resetting to paid",
 		logger.Field("count", len(stuckOrders)),
 		logger.Field("order_nos", orderNos),
 	)
 
-	for i := range stuckOrders {
-		o := &stuckOrders[i]
-
 	result := l.svc.DB.WithContext(ctx).
 		Model(&order.Order{}).
-			Where("order_no = ? AND status = ?", o.OrderNo, OrderStatusClaimed).
+		Where("status = ? AND updated_at < ?", OrderStatusClaimed, cutoff).
 		Update("status", OrderStatusPaid)
 	if result.Error != nil {
-			logger.WithContext(ctx).Error("[StuckOrderRecovery] Failed to reset order status",
-				logger.Field("order_no", o.OrderNo),
+		logger.WithContext(ctx).Error("[StuckOrderRecovery] Failed to reset stuck orders",
 			logger.Field("error", result.Error.Error()),
 		)
-			continue
-		}
-		if result.RowsAffected == 0 {
-			// Another process already handled this order
-			continue
+		return result.Error
 	}
 
-		// Invalidate order cache
-		o.Status = OrderStatusPaid
-		if err := l.svc.OrderModel.Update(ctx, o); err != nil {
-			logger.WithContext(ctx).Error("[StuckOrderRecovery] Failed to update order cache",
-				logger.Field("order_no", o.OrderNo),
-				logger.Field("error", err.Error()),
-			)
-		}
-
-		// Re-enqueue activate task so the order gets processed regardless of asynq retry state
-		payload, err := json.Marshal(queueTypes.ForthwithActivateOrderPayload{OrderNo: o.OrderNo})
+	for i := range stuckOrders {
+		ord := &stuckOrders[i]
+		payload, err := json.Marshal(queueTypes.ForthwithActivateOrderPayload{OrderNo: ord.OrderNo})
 		if err != nil {
-			logger.WithContext(ctx).Error("[StuckOrderRecovery] Failed to marshal task payload",
-				logger.Field("order_no", o.OrderNo),
+			logger.WithContext(ctx).Error("[StuckOrderRecovery] Failed to marshal payload",
+				logger.Field("order_no", ord.OrderNo),
 				logger.Field("error", err.Error()),
 			)
 			continue
 		}
-		if _, err = l.svc.Queue.EnqueueContext(ctx, asynq.NewTask(queueTypes.ForthwithActivateOrder, payload)); err != nil {
-			logger.WithContext(ctx).Error("[StuckOrderRecovery] Failed to re-enqueue activate task",
-				logger.Field("order_no", o.OrderNo),
+		task := asynq.NewTask(queueTypes.ForthwithActivateOrder, payload, asynq.MaxRetry(5))
+		if _, err := l.svc.Queue.EnqueueContext(ctx, task); err != nil {
+			logger.WithContext(ctx).Error("[StuckOrderRecovery] Failed to re-enqueue order",
+				logger.Field("order_no", ord.OrderNo),
 				logger.Field("error", err.Error()),
 			)
-		} else {
-			logger.WithContext(ctx).Info("[StuckOrderRecovery] Re-enqueued activate task",
-				logger.Field("order_no", o.OrderNo),
-			)
 		}
 	}
 

queue/types/scheduler.go

@@ -7,5 +7,5 @@ const (
 	SchedulerTrafficStat        = "scheduler:traffic:stat"
 	SchedulerIAPReconcile       = "scheduler:iap:reconcile"       // 第二层：每 5 分钟扫描待支付 IAP 订单
 	SchedulerIAPDailyReconcile  = "scheduler:iap:daily:reconcile" // 第三层：日终全量对账
-	SchedulerStuckOrderRecovery = "scheduler:stuck:order:recovery"  // 扫描并恢复超时 claimed 订单
+	SchedulerStuckOrderRecovery = "scheduler:stuck:order:recovery" // 定时恢复卡在 claimed 状态的订单
 )

迁移到命令.txt

@@ -0,0 +1,44 @@
+导出数据库:
+mysqldump --socket=/var/run/mysqld/mysqld.sock -uroot -p   --single-transaction   --routines   --triggers   --events   --set-gtid-purged=OFF   --source-data=2   --no-tablespaces   hifast > /root/data/hifast-final-0515.sql
+
+jpcV41ppanel
+
+gzip -1 /root/hifast-final-0515.sql
+
+
+
+
+
+导出redis：
+redis-cli -a '0BVz9XOHf7KUfEuoFJRK-dURdKUGFiZ8QeaHpysHnKeKhLskZb55HPK121lFsKtr' BGSAVE
+sleep 5
+cp /var/lib/redis/dump.rdb /root/data/redis-backup-0515.rdb
+
+
+导入数据库:
+gunzip -c /root/hifast-final-0515.sql.gz | docker exec -i ppanel-mysql mysql -uroot -p'jpcV41ppanel' hifast
+
+
+导入redis：
+docker stop ppanel-redis
+docker cp /root/data/redis-backup-0515.rdb ppanel-redis:/data/dump.rdb
+docker start ppanel-redis
+docker exec ppanel-redis redis-cli -a 'hifast67yj' DBSIZE
+
+
+
+docker stop ppanel-redis || true
+docker rm -f ppanel-redis
+
+rm -f /root/data/dump.rdb
+rm -rf /root/data/appendonlydir
+rm -f /root/data/appendonly.aof*
+mkdir -p /root/data
+
+docker pull redis:8.6.3
+docker run -d \
+  --name ppanel-redis \
+  --restart always \
+  -p 6379:6379 \
+  redis:8.6.3 \
+  redis-server --requirepass 'hifast67yj'