更新构建脚本

.github/workflows/release.yml

@@ -2,7 +2,7 @@ name: Docker
 
 on:
   push:
-    branches: [ "main" ]
+    branches: ["v*"]
 
 env:
   REGISTRY: ghcr.io
@@ -10,14 +10,12 @@ env:
 
 jobs:
   build:
-
     runs-on: ubuntu-latest
     permissions:
       contents: read
       packages: write
 
     steps:
-
       - name: Checkout repository
         uses: actions/checkout@v4
 

.vscode/launch.json

@@ -1,16 +0,0 @@
-{
-  // 使用 IntelliSense 了解相关属性。
-  // 悬停以查看现有属性的描述。
-  // 欲了解更多信息，请访问: https://go.microsoft.com/fwlink/?linkid=830387
-  "version": "0.2.0",
-  "configurations": [
-    {
-      "name": "main",
-      "type": "go",
-      "request": "launch",
-      "mode": "debug",
-      "program": "${workspaceFolder}/cmd/main",
-      "cwd": "${workspaceFolder}"
-    }
-  ]
-}

.zed/debug.json

@@ -0,0 +1,13 @@
+// Project-local debug tasks
+//
+// For more documentation on how to configure debug tasks,
+// see: https://zed.dev/docs/debugger
+[
+  {
+    "label": "debug main",
+    "adapter": "Delve",
+    "request": "launch",
+    "mode": "debug",
+    "program": "./cmd/main"
+  }
+]

Dockerfile

@@ -1,35 +1,31 @@
 # 第一阶段：构建
-FROM golang:1.24.0 AS builder
-
-ENV GOPROXY=https://goproxy.cn,direct
-
+FROM golang:1.25.3 AS builder
 WORKDIR /build
 
-# 复制Go模块文件
+ENV GOPROXY=https://goproxy.cn,direct
+ENV CGO_ENABLED=0
+ENV GOOS=linux
+ENV GOARCH=amd64
+
 COPY go.mod go.sum ./
 RUN go mod download
 
-# 复制源代码
 COPY . .
-
-# 编译
-RUN GOOS=linux GOARCH=amd64 go build -ldflags '-w -s' -o bin/platform_linux_amd64 cmd/main/main.go
+RUN go build -ldflags '-w -s' -o bin/platform_linux_amd64 cmd/main/main.go
 
 # 第二阶段：运行环境
-FROM ubuntu:24.04 AS runner
-
+FROM alpine:3.23 AS runner
 WORKDIR /app
 
-RUN apt-get update && apt-get install -y ca-certificates
+ENV TZ=Asia/Shanghai
+
+RUN sed -i 's/dl-cdn.alpinelinux.org/mirrors.tuna.tsinghua.edu.cn/g' /etc/apk/repositories
+RUN apk add --no-cache ca-certificates tzdata
 
-# 从构建阶段复制编译好的二进制文件
 COPY --from=builder /build/bin/platform_linux_amd64 /app/platform
 
-# 设置可执行权限
 RUN chmod +x /app/platform
 
-# 声明暴露端口
 EXPOSE 8080
 
-# 启动平台服务
-CMD ["/app/platform"]
+CMD ["/app/platform"]

README.md

@@ -1,49 +1,42 @@
 ## TODO
 
-trade/create 性能问题，缩短事务时间，考虑其他方式实现可靠分布式事务
+用户请求需要检查数据权限
 
-需要确认以下 ID.GenSerial 的分布式并发安全性
+用反射实现环境变量解析，以简化函数签名
 
-jsonb 类型转换问题，考虑一个高效的 any 到 struct 转换工具
-
-端口资源池的 gc 实现
-
-标准化生产环境 cors 配置
-
-底层调用集成 otel
-- redis
-- gorm
-- 三方接口
+---
 
 分离 task 的客户端，支持多进程（prefork 必要！）
 
-调整目录结构：
+jsonb 类型转换问题，考虑一个高效的 any 到 struct 转换工具
 
-```
-- /core         核心概念
-- /util         工具函数
+慢速请求底层调用埋点监控
 
-- /models       模型
-- /queries      数据库层
-- /clients      三方依赖的客户端实例
-
-- /services     服务层
-- /auth         认证相关，特化服务
-
-- /app          应用相关，初始化日志，环境变量等
-- /http         协议层，http 服务
-- /cmd          主函数
-
-逐层向上依赖
-cmd 调用 app, http 的初始化函数
-http 调用 clients 的初始化函数
-```
-  
-考虑一个方案限制接口请求速率，无侵入更好
+数据库转模型文件
 
 冷数据迁移方案
-  
-proxy 网关更新接口可以传输更结构化的数据，直接区分不同类型以加快更新速度
+
+## 开发环境
+
+### 更新表结构的流程
+
+1. 编辑 `scripts/sql/init.sql` 文件，参照原有格式，需要注意：
+  - 先写 drop table if exists 语句，确保脚本可以幂等执行
+  - 编写 create table 语句，按需添加审计字段和软删除字段 (created_at, updated_at, deleted_at)
+  - 为有必要的字段添加索引
+  - 为数据表及其字段添加注释
+  - 在文件末尾创建数据表流程全部结束后，为字段添加外键
+2. 建议用数据库工具检查差异并增量更新，或者手动增量更新
+3. 创建 model 文件，并将其添加到 gen 代码中
+4. 生成查询文件
+
+### 权限管理
+
+在 `web/core/scopes.go` 下定义了系统所有静态权限
+
+新增系统权限需要在数据库中配套添加权限
+
+前端也需要新增配套权限定义
 
 ## 业务逻辑
 
@@ -63,22 +56,20 @@ proxy 网关更新接口可以传输更结构化的数据，直接区分不同
 
 ### 节点分配与存储逻辑
 
-添加：
-- 检查用户 ip 是否在白名单内
-- 取用端口，不够则返回失败
-- 将分配结果转写成配置发送到网关
-- 保存通道信息和分配记录，其中通道信息以网关为主体，分配记录以用户为主体
-- 添加异步任务，当时间结束后释放取用的端口并清空网关配置
+提取：
 
-删除：
-- 如果传入用户信息，检查要删除的连接是否属于该用户
-- 释放可用端口
-  - redis 脚本中检查，如果端口所属节点已下线则直接忽略
-- 提交清空配置到网关
+- 检查用户套餐与白名单
+- 选中代理
+  - 找到当前可用端口最多的代理
+  - 不考虑分割端口，不够加机器
+- 获取可用端口
+- 获取可用节点
+- 生成批次号，提交到期释放任务
+- 绑定节点与端口，保存到数据库
+- 分别提交连接与配置请求
 
-缩扩容：
-- 通过调度任务实现缩扩容
-- 每分钟检查一次全部配置，按代理分组
-- 获取所有代理后备配置
-- 后备配置/当前配置
-  - 当比例 < 1.5 或 > 3 时，重新更新为 2 倍
+释放：
+
+- 根据批次查出所有端口与相关节点
+- 分别提交断开与关闭请求
+- 释放端口

cmd/gen/main.go

@@ -51,6 +51,8 @@ func main() {
 		m.LogsUserUsage{},
 		m.Permission{},
 		m.Product{},
+		m.ProductSku{},
+		m.ProductSkuUser{},
 		m.Proxy{},
 		m.Refund{},
 		m.Resource{},
@@ -61,6 +63,9 @@ func main() {
 		m.User{},
 		m.UserRole{},
 		m.Whitelist{},
+		m.Inquiry{},
+		m.ProductDiscount{},
+		m.BalanceActivity{},
 	)
 	g.Execute()
 }

docker-compose.yaml

@@ -1,8 +1,8 @@
-name: lanhu
+name: lanhu-platform
 
 services:
   postgres:
-    image: postgres:17
+    image: postgres:17.7
     environment:
       POSTGRES_USER: ${DB_USERNAME}
       POSTGRES_PASSWORD: ${DB_PASSWORD}

docs/docker-deployment.md

@@ -1,90 +0,0 @@
-# Docker 部署说明
-
-本文档说明如何使用 Docker 构建和部署平台服务。
-
-## 构建镜像
-
-在项目根目录下执行以下命令构建 Docker 镜像：
-
-```bash
-docker build -t platform:latest .
-```
-
-## 生产环境部署
-
-由于涉及敏感的 `.pem` 证书文件，这些文件不包含在代码库或 Docker 镜像中，而是在运行时通过卷挂载的方式提供。
-
-### 准备证书文件
-
-1. 在生产服务器上创建一个目录用于存放证书文件，例如：`/path/to/certs/`
-2. 将必要的证书文件放入此目录：
-   - `pub_key.pem`
-   - `apiclient_key.pem`
-
-### 运行容器
-
-使用以下命令运行容器，挂载证书目录：
-
-```bash
-docker run -d \
-  --name platform \
-  -p 8080:8080 \
-  -e APP_PORT=8080 \
-  -v /path/to/certs:/app/certs \
-  platform:latest
-```
-
-### 环境变量
-
-可以通过环境变量来配置应用程序：
-
-- `APP_PORT`: 应用监听的端口号（默认: 8080）
-- 其他应用相关的环境变量可以通过 `-e` 参数添加
-
-### 证书路径配置
-
-如果应用程序需要知道证书的路径，可以通过环境变量配置：
-
-```bash
-docker run -d \
-  --name platform \
-  -p 8080:8080 \
-  -e APP_PORT=8080 \
-  -e PUB_KEY_PATH=/app/certs/pub_key.pem \
-  -e APICLIENT_KEY_PATH=/app/certs/apiclient_key.pem \
-  -v /path/to/certs:/app/certs \
-  platform:latest
-```
-
-## 使用 Docker Compose
-
-也可以通过 Docker Compose 进行部署，创建 `docker-compose.yml` 文件：
-
-```yaml
-version: '3'
-
-services:
-  platform:
-    image: platform:latest
-    ports:
-      - "8080:8080"
-    environment:
-      - APP_PORT=8080
-      - PUB_KEY_PATH=/app/certs/pub_key.pem
-      - APICLIENT_KEY_PATH=/app/certs/apiclient_key.pem
-    volumes:
-      - /path/to/certs:/app/certs
-    restart: unless-stopped
-```
-
-然后执行：
-
-```bash
-docker-compose up -d
-```
-
-## 安全建议
-
-1. 确保证书文件的权限设置正确，仅允许必要的用户访问
-2. 在生产环境中考虑使用 Docker Secrets 或 Kubernetes Secrets 来管理敏感信息
-3. 定期更新证书和密钥

go.mod

@@ -11,6 +11,7 @@ require (
 	github.com/go-redsync/redsync/v4 v4.14.1
 	github.com/gofiber/contrib/otelfiber/v2 v2.2.3
 	github.com/gofiber/fiber/v2 v2.52.10
+	github.com/gofiber/template/html/v2 v2.1.3
 	github.com/google/uuid v1.6.0
 	github.com/hibiken/asynq v0.25.1
 	github.com/jdcloud-api/jdcloud-sdk-go v1.64.0
@@ -54,6 +55,8 @@ require (
 	github.com/go-logr/logr v1.4.3 // indirect
 	github.com/go-logr/stdr v1.2.2 // indirect
 	github.com/go-sql-driver/mysql v1.9.3 // indirect
+	github.com/gofiber/template v1.8.3 // indirect
+	github.com/gofiber/utils v1.1.0 // indirect
 	github.com/gofrs/uuid v4.4.0+incompatible // indirect
 	github.com/gomodule/redigo v2.0.0+incompatible // indirect
 	github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.3 // indirect

go.sum

@@ -115,6 +115,12 @@ github.com/gofiber/contrib/otelfiber/v2 v2.2.3 h1:WKW1XezHFAoohGZwnvC0R8TFJcNkab
 github.com/gofiber/contrib/otelfiber/v2 v2.2.3/go.mod h1:WdQ1tYbL83IYC6oBaWvKBMVGSAYvSTRuUWTcr0wK1T4=
 github.com/gofiber/fiber/v2 v2.52.10 h1:jRHROi2BuNti6NYXmZ6gbNSfT3zj/8c0xy94GOU5elY=
 github.com/gofiber/fiber/v2 v2.52.10/go.mod h1:YEcBbO/FB+5M1IZNBP9FO3J9281zgPAreiI1oqg8nDw=
+github.com/gofiber/template v1.8.3 h1:hzHdvMwMo/T2kouz2pPCA0zGiLCeMnoGsQZBTSYgZxc=
+github.com/gofiber/template v1.8.3/go.mod h1:bs/2n0pSNPOkRa5VJ8zTIvedcI/lEYxzV3+YPXdBvq8=
+github.com/gofiber/template/html/v2 v2.1.3 h1:n1LYBtmr9C0V/k/3qBblXyMxV5B0o/gpb6dFLp8ea+o=
+github.com/gofiber/template/html/v2 v2.1.3/go.mod h1:U5Fxgc5KpyujU9OqKzy6Kn6Qup6Tm7zdsISR+VpnHRE=
+github.com/gofiber/utils v1.1.0 h1:vdEBpn7AzIUJRhe+CiTOJdUcTg4Q9RK+pEa0KPbLdrM=
+github.com/gofiber/utils v1.1.0/go.mod h1:poZpsnhBykfnY1Mc0KeEa6mSHrS3dV0+oBWyeQmb2e0=
 github.com/gofrs/uuid v4.4.0+incompatible h1:3qXRTX8/NbyulANqlc0lchS1gqAVxRgsuW1YrTJupqA=
 github.com/gofrs/uuid v4.4.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM=
 github.com/golang-sql/civil v0.0.0-20220223132316-b832511892a9 h1:au07oEsX2xN0ktxqI+Sida1w446QrXBRJ0nee3SNZlA=

pkg/env/env.go

@@ -20,7 +20,7 @@ const (
 var (
 	RunMode              = RunModeProd
 	LogLevel             = slog.LevelDebug
-	TradeExpire          = 15 * 60          // 交易过期时间，单位秒。默认 15 分钟
+	TradeExpire          = 15 * 60          // 交易过期时间，单位秒。默认 900 秒（15 分钟）
 	SessionAccessExpire  = 60 * 60 * 2      // 访问令牌过期时间，单位秒。默认 2 小时
 	SessionRefreshExpire = 60 * 60 * 24 * 7 // 刷新令牌过期时间，单位秒。默认 7 天
 	DebugHttpDump        = false            // 是否打印请求和响应的原始数据
@@ -36,7 +36,10 @@ var (
 	RedisPort     = "6379"
 	RedisPassword = ""
 
-	BaiyinAddr     = "http://103.139.212.110:9989"
+	OtelHost string
+	OtelPort string
+
+	BaiyinCloudUrl string
 	BaiyinTokenUrl string
 
 	IdenCallbackUrl string
@@ -115,7 +118,10 @@ func Init() {
 	errs = append(errs, parse(&RedisPort, "REDIS_PORT", true, nil))
 	errs = append(errs, parse(&RedisPassword, "REDIS_PASS", true, nil))
 
-	errs = append(errs, parse(&BaiyinAddr, "BAIYIN_ADDR", true, nil))
+	errs = append(errs, parse(&OtelHost, "OTEL_HOST", true, nil))
+	errs = append(errs, parse(&OtelPort, "OTEL_PORT", true, nil))
+
+	errs = append(errs, parse(&BaiyinCloudUrl, "BAIYIN_CLOUD_URL", false, nil))
 	errs = append(errs, parse(&BaiyinTokenUrl, "BAIYIN_TOKEN_URL", false, nil))
 
 	errs = append(errs, parse(&IdenCallbackUrl, "IDEN_CALLBACK_URL", false, nil))

pkg/u/u.go

@@ -17,11 +17,12 @@ func Else[T any](v *T, or T) T {
 	}
 }
 
-func ElseTo[A any, B any](a *A, f func(A) B) *B {
-	if a == nil {
-		return nil
+// 三元表达式
+func Ternary[T any](condition bool, trueValue T, falseValue T) T {
+	if condition {
+		return trueValue
 	} else {
-		return P(f(*a))
+		return falseValue
 	}
 }
 
@@ -73,7 +74,7 @@ func DateHead(date time.Time) time.Time {
 	return time.Date(y, m, d, 0, 0, 0, 0, date.Location())
 }
 
-func DateFoot(date time.Time) time.Time {
+func DateTail(date time.Time) time.Time {
 	var y, m, d = date.Date()
 	return time.Date(y, m, d, 23, 59, 59, 999999999, date.Location())
 }

publish.ps1

@@ -0,0 +1,16 @@
+if (-not $args) {
+    Write-Error "需要指定版本号"
+    exit 1
+}
+
+$confrim = Read-Host "构建版本为 [platform:$($args[0])]，是否继续？(y/n)"
+if ($confrim -ne "y") {
+    Write-Host "已取消构建"
+    exit 0
+}
+
+docker build -t repo.lanhuip.com:8554/lanhu/platform:latest .
+docker build -t repo.lanhuip.com:8554/lanhu/platform:$($args[0]) .
+
+docker push repo.lanhuip.com:8554/lanhu/platform:latest
+docker push repo.lanhuip.com:8554/lanhu/platform:$($args[0])

scripts/sql/fill.sql

@@ -0,0 +1,21 @@
+-- ====================
+-- region 填充数据
+-- ====================
+
+insert into client (type, spec, name, client_id, client_secret, redirect_uri) values (1, 3, 'web', 'web', '$2a$10$Ss12mXQgpYyo1CKIZ3URouDm.Lc2KcYJzsvEK2PTIXlv6fHQht45a', '');
+insert into client (type, spec, name, client_id, client_secret, redirect_uri) values (1, 3, 'admin', 'admin', '$2a$10$dlfvX5Uf3iVsUWgwlb0Wt.oYsw/OEXgS.Aior3yoT63Ju7ZSsJr/2', '');
+
+insert into product (code, name, description) values ('short', '短效动态', '短效动态');
+insert into product (code, name, description) values ('long', '长效动态', '长效动态');
+insert into product (code, name, description) values ('static', '长效静态', '长效静态');
+
+delete from permission where true;
+insert into permission
+    (name, description)
+values
+    ('permission:read', '读取权限列表'),
+    ('permission:write', '写入权限'),
+    ('admin-role:read', '读取管理员角色列表'),
+    ('admin-role:write', '写入管理员角色')
+;
+-- endregion

scripts/sql/init.sql

@@ -109,74 +109,9 @@ comment on column logs_user_bandwidth.time is '记录时间';
 -- endregion
 
 -- ====================
--- region 管理员信息
+-- region 系统信息
 -- ====================
 
--- admin
-drop table if exists admin cascade;
-create table admin (
-    id            int generated by default as identity primary key,
-    username      text not null,
-    password      text not null,
-    name          text,
-    avatar        text,
-    phone         text,
-    email         text,
-    status        int  not null default 1,
-    last_login    timestamptz,
-    last_login_ip inet,
-    last_login_ua text,
-    created_at    timestamptz default current_timestamp,
-    updated_at    timestamptz default current_timestamp,
-    deleted_at    timestamptz
-);
-create unique index udx_admin_username on admin (username);
-create index idx_admin_status on admin (status) where deleted_at is null;
-create index idx_admin_created_at on admin (created_at) where deleted_at is null;
-
--- admin表字段注释
-comment on table admin is '管理员表';
-comment on column admin.id is '管理员ID';
-comment on column admin.username is '用户名';
-comment on column admin.password is '密码';
-comment on column admin.name is '真实姓名';
-comment on column admin.avatar is '头像URL';
-comment on column admin.phone is '手机号码';
-comment on column admin.email is '邮箱';
-comment on column admin.status is '状态：0-禁用，1-正常';
-comment on column admin.last_login is '最后登录时间';
-comment on column admin.last_login_ip is '最后登录地址';
-comment on column admin.last_login_ua is '最后登录代理';
-comment on column admin.created_at is '创建时间';
-comment on column admin.updated_at is '更新时间';
-comment on column admin.deleted_at is '删除时间';
-
--- admin_role
-drop table if exists admin_role cascade;
-create table admin_role (
-    id          int generated by default as identity primary key,
-    name        text not null,
-    description text,
-    active      bool default true,
-    sort        int default 0,
-    created_at  timestamptz default current_timestamp,
-    updated_at  timestamptz default current_timestamp,
-    deleted_at  timestamptz
-);
-create unique index udx_admin_role_name on admin_role (name) where deleted_at is null;
-create index idx_admin_role_created_at on admin_role (created_at) where deleted_at is null;
-
--- admin_role表字段注释
-comment on table admin_role is '管理员角色关联表';
-comment on column admin_role.id is '管理员角色ID';
-comment on column admin_role.name is '角色名称';
-comment on column admin_role.description is '角色描述';
-comment on column admin_role.active is '是否激活';
-comment on column admin_role.sort is '排序';
-comment on column admin_role.created_at is '创建时间';
-comment on column admin_role.updated_at is '更新时间';
-comment on column admin_role.deleted_at is '删除时间';
-
 -- announcement
 drop table if exists announcement cascade;
 create table announcement (
@@ -208,6 +143,110 @@ comment on column announcement.created_at is '创建时间';
 comment on column announcement.updated_at is '更新时间';
 comment on column announcement.deleted_at is '删除时间';
 
+-- inquiry
+drop table if exists inquiry cascade;
+create table inquiry (
+    id         int generated by default as identity primary key,
+    company    text,
+    name       text,
+    phone      text,
+    email      text,
+    content    text,
+    status     int not null default 0,
+    remark     text,
+    created_at timestamptz default current_timestamp,
+    updated_at timestamptz default current_timestamp,
+    deleted_at timestamptz
+);
+create index idx_inquiry_phone on inquiry (phone) where deleted_at is null;
+create index idx_inquiry_status on inquiry (status) where deleted_at is null;
+create index idx_inquiry_created_at on inquiry (created_at) where deleted_at is null;
+
+-- inquiry表字段注释
+comment on table inquiry is '用户咨询表';
+comment on column inquiry.id is '咨询ID';
+comment on column inquiry.name is '联系人姓名';
+comment on column inquiry.phone is '联系电话';
+comment on column inquiry.email is '联系邮箱';
+comment on column inquiry.company is '公司名称';
+comment on column inquiry.content is '咨询内容';
+comment on column inquiry.status is '处理状态：0-待处理，1-已处理';
+comment on column inquiry.remark is '备注';
+comment on column inquiry.created_at is '创建时间';
+comment on column inquiry.updated_at is '更新时间';
+comment on column inquiry.deleted_at is '删除时间';
+
+-- endregion
+
+-- ====================
+-- region 管理员信息
+-- ====================
+
+-- admin
+drop table if exists admin cascade;
+create table admin (
+    id            int generated by default as identity primary key,
+    username      text not null,
+    password      text not null,
+    name          text,
+    avatar        text,
+    phone         text,
+    email         text,
+    status        int  not null default 1,
+    last_login    timestamptz,
+    last_login_ip inet,
+    last_login_ua text,
+    created_at    timestamptz default current_timestamp,
+    updated_at    timestamptz default current_timestamp,
+    deleted_at    timestamptz
+);
+create unique index udx_admin_username on admin (username) where deleted_at is null;
+create index idx_admin_status on admin (status) where deleted_at is null;
+create index idx_admin_created_at on admin (created_at) where deleted_at is null;
+
+-- admin表字段注释
+comment on table admin is '管理员表';
+comment on column admin.id is '管理员ID';
+comment on column admin.username is '用户名';
+comment on column admin.password is '密码';
+comment on column admin.name is '真实姓名';
+comment on column admin.avatar is '头像URL';
+comment on column admin.phone is '手机号码';
+comment on column admin.email is '邮箱';
+comment on column admin.status is '状态：0-禁用，1-正常';
+comment on column admin.last_login is '最后登录时间';
+comment on column admin.last_login_ip is '最后登录地址';
+comment on column admin.last_login_ua is '最后登录代理';
+comment on column admin.created_at is '创建时间';
+comment on column admin.updated_at is '更新时间';
+comment on column admin.deleted_at is '删除时间';
+
+-- admin_role
+drop table if exists admin_role cascade;
+create table admin_role (
+    id          int generated by default as identity primary key,
+    name        text not null,
+    description text,
+    active      bool not null default true,
+    sort        int  not null default 0,
+    created_at  timestamptz default current_timestamp,
+    updated_at  timestamptz default current_timestamp,
+    deleted_at  timestamptz
+);
+create unique index udx_admin_role_name on admin_role (name) where deleted_at is null;
+create index idx_admin_role_created_at on admin_role (created_at) where deleted_at is null;
+
+-- admin_role表字段注释
+comment on table admin_role is '管理员角色关联表';
+comment on column admin_role.id is '管理员角色ID';
+comment on column admin_role.name is '角色名称';
+comment on column admin_role.description is '角色描述';
+comment on column admin_role.active is '是否激活';
+comment on column admin_role.sort is '排序';
+comment on column admin_role.created_at is '创建时间';
+comment on column admin_role.updated_at is '更新时间';
+comment on column admin_role.deleted_at is '删除时间';
+
 -- endregion
 
 -- ====================
@@ -219,10 +258,12 @@ drop table if exists "user" cascade;
 create table "user" (
     id             int generated by default as identity primary key,
     admin_id       int,
+    discount_id    int,
     phone          text           not null unique,
     username       text,
     email          text,
     password       text,
+    source         int default 0,
     name           text,
     avatar         text,
     status         int            not null default 1,
@@ -240,6 +281,7 @@ create table "user" (
     deleted_at     timestamptz
 );
 create index idx_user_admin_id on "user" (admin_id) where deleted_at is null;
+create index idx_user_discount_id on "user" (discount_id) where deleted_at is null;
 create unique index udx_user_phone on "user" (phone) where deleted_at is null;
 create unique index udx_user_username on "user" (username) where deleted_at is null;
 create unique index udx_user_email on "user" (email) where deleted_at is null;
@@ -249,9 +291,11 @@ create index idx_user_created_at on "user" (created_at) where deleted_at is null
 comment on table "user" is '用户表';
 comment on column "user".id is '用户ID';
 comment on column "user".admin_id is '管理员ID';
+comment on column "user".discount_id is '折扣ID';
 comment on column "user".password is '用户密码';
 comment on column "user".username is '用户名';
 comment on column "user".phone is '手机号码';
+comment on column "user".source is '用户来源：0-官网注册，1-管理员添加，2-代理商注册，3-代理商添加';
 comment on column "user".name is '真实姓名';
 comment on column "user".avatar is '头像URL';
 comment on column "user".status is '用户状态：0-禁用，1-正常';
@@ -389,6 +433,7 @@ create table permission (
     parent_id   int,
     name        text not null,
     description text,
+    sort        int,
     created_at  timestamptz default current_timestamp,
     updated_at  timestamptz default current_timestamp,
     deleted_at  timestamptz
@@ -403,6 +448,7 @@ comment on column permission.id is '权限ID';
 comment on column permission.parent_id is '父权限ID';
 comment on column permission.name is '权限名称';
 comment on column permission.description is '权限描述';
+comment on column permission.sort is '排序';
 comment on column permission.created_at is '创建时间';
 comment on column permission.updated_at is '更新时间';
 comment on column permission.deleted_at is '删除时间';
@@ -410,65 +456,65 @@ comment on column permission.deleted_at is '删除时间';
 -- link_user_role
 drop table if exists link_user_role cascade;
 create table link_user_role (
-    id      int generated by default as identity primary key,
-    user_id int not null,
-    role_id int not null
+    id           int generated by default as identity primary key,
+    user_id      int not null,
+    user_role_id int not null
 );
 create index idx_link_user_role_user_id on link_user_role (user_id);
-create index idx_link_user_role_role_id on link_user_role (role_id);
+create index idx_link_user_role_role_id on link_user_role (user_role_id);
 
 -- link_user_role表字段注释
 comment on table link_user_role is '用户角色关联表';
 comment on column link_user_role.id is '关联ID';
 comment on column link_user_role.user_id is '用户ID';
-comment on column link_user_role.role_id is '角色ID';
+comment on column link_user_role.user_role_id is '角色ID';
 
 -- link_admin_role
 drop table if exists link_admin_role cascade;
 create table link_admin_role (
-    id       int generated by default as identity primary key,
-    admin_id int not null,
-    role_id  int not null
+    id            int generated by default as identity primary key,
+    admin_id      int not null,
+    admin_role_id int not null
 );
 create index idx_link_admin_role_admin_id on link_admin_role (admin_id);
-create index idx_link_admin_role_role_id on link_admin_role (role_id);
+create index idx_link_admin_role_role_id on link_admin_role (admin_role_id);
 
 -- link_admin_role表字段注释
 comment on table link_admin_role is '管理员角色关联表';
 comment on column link_admin_role.id is '关联ID';
 comment on column link_admin_role.admin_id is '管理员ID';
-comment on column link_admin_role.role_id is '角色ID';
+comment on column link_admin_role.admin_role_id is '角色ID';
 
 -- link_user_role_permission
 drop table if exists link_user_role_permission cascade;
 create table link_user_role_permission (
     id            int generated by default as identity primary key,
-    role_id       int not null,
+    user_role_id  int not null,
     permission_id int not null
 );
-create index idx_link_user_role_permission_role_id on link_user_role_permission (role_id);
+create index idx_link_user_role_permission_role_id on link_user_role_permission (user_role_id);
 create index idx_link_user_role_permission_permission_id on link_user_role_permission (permission_id);
 
 -- link_user_role_permission表字段注释
 comment on table link_user_role_permission is '用户角色权限关联表';
 comment on column link_user_role_permission.id is '关联ID';
-comment on column link_user_role_permission.role_id is '角色ID';
+comment on column link_user_role_permission.user_role_id is '角色ID';
 comment on column link_user_role_permission.permission_id is '权限ID';
 
 -- link_admin_role_permission
 drop table if exists link_admin_role_permission cascade;
 create table link_admin_role_permission (
     id            int generated by default as identity primary key,
-    role_id       int not null,
+    admin_role_id int not null,
     permission_id int not null
 );
-create index idx_link_admin_role_permission_role_id on link_admin_role_permission (role_id);
+create index idx_link_admin_role_permission_role_id on link_admin_role_permission (admin_role_id);
 create index idx_link_admin_role_permission_permission_id on link_admin_role_permission (permission_id);
 
 -- link_admin_role_permission表字段注释
 comment on table link_admin_role_permission is '管理员角色权限关联表';
 comment on column link_admin_role_permission.id is '关联ID';
-comment on column link_admin_role_permission.role_id is '角色ID';
+comment on column link_admin_role_permission.admin_role_id is '角色ID';
 comment on column link_admin_role_permission.permission_id is '权限ID';
 
 -- link_client_permission
@@ -497,13 +543,14 @@ comment on column link_client_permission.permission_id is '权限ID';
 drop table if exists proxy cascade;
 create table proxy (
     id         int generated by default as identity primary key,
-    version    int   not null,
-    mac        text  not null,
-    ip         inet  not null,
+    version    int  not null,
+    mac        text not null,
+    ip         inet not null,
+    host       text,
     secret     text,
-    type       int   not null,
-    status     int   not null,
-    meta       jsonb not null,
+    type       int  not null,
+    status     int  not null,
+    meta       jsonb,
     created_at timestamptz default current_timestamp,
     updated_at timestamptz default current_timestamp,
     deleted_at timestamptz
@@ -518,8 +565,9 @@ comment on column proxy.id is '代理服务ID';
 comment on column proxy.version is '代理服务版本';
 comment on column proxy.mac is '代理服务名称';
 comment on column proxy.ip is '代理服务地址';
-comment on column proxy.type is '代理服务类型：1-自有，2-白银';
+comment on column proxy.host is '代理服务域名';
 comment on column proxy.secret is '代理服务密钥';
+comment on column proxy.type is '代理服务类型：1-自有，2-白银';
 comment on column proxy.status is '代理服务状态：0-离线，1-在线';
 comment on column proxy.meta is '代理服务元信息';
 comment on column proxy.created_at is '创建时间';
@@ -600,8 +648,10 @@ create table channel (
     resource_id int         not null,
     batch_no    text        not null,
     proxy_id    int         not null,
+    host        text        not null,
     port        int         not null,
     edge_id     int,
+    edge_ref    text,
     filter_isp  int,
     filter_prov text,
     filter_city text,
@@ -626,8 +676,10 @@ comment on column channel.user_id is '用户ID';
 comment on column channel.resource_id is '套餐ID';
 comment on column channel.batch_no is '批次编号';
 comment on column channel.proxy_id is '代理ID';
+comment on column channel.host is '代理主机（快照）';
 comment on column channel.port is '代理端口';
 comment on column channel.edge_id is '节点ID（手动配置）';
+comment on column channel.edge_ref is '外部节点引用，用于索引没有ID的外部非受控节点';
 comment on column channel.filter_isp is '运营商过滤（自动配置）：参考 edge.isp';
 comment on column channel.filter_prov is '省份过滤（自动配置）';
 comment on column channel.filter_city is '城市过滤（自动配置）';
@@ -675,14 +727,88 @@ comment on column product.created_at is '创建时间';
 comment on column product.updated_at is '更新时间';
 comment on column product.deleted_at is '删除时间';
 
+
+-- product_discount
+drop table if exists product_discount cascade;
+create table product_discount (
+    id         int generated by default as identity primary key,
+    name       text,
+    discount   int,
+    created_at timestamptz default current_timestamp,
+    updated_at timestamptz default current_timestamp,
+    deleted_at timestamptz
+);
+
+-- product_discount表字段注释
+comment on table product_discount is '产品折扣表';
+comment on column product_discount.id is 'ID';
+comment on column product_discount.name is '折扣名称';
+comment on column product_discount.discount is '折扣，0 - 100 的整数，表示 xx 折';
+comment on column product_discount.created_at is '创建时间';
+comment on column product_discount.updated_at is '更新时间';
+comment on column product_discount.deleted_at is '删除时间';
+
+-- product_sku
+drop table if exists product_sku cascade;
+create table product_sku (
+    id          int generated by default as identity primary key,
+    product_id  int     not null,
+    discount_id int,
+    code        text    not null unique,
+    name        text    not null,
+    price       decimal not null,
+    created_at  timestamptz default current_timestamp,
+    updated_at  timestamptz default current_timestamp,
+    deleted_at  timestamptz
+);
+create index idx_product_sku_product_id on product_sku (product_id) where deleted_at is null;
+create index idx_product_sku_discount_id on product_sku (discount_id) where deleted_at is null;
+create unique index idx_product_sku_code on product_sku (code) where deleted_at is null;
+
+-- product_sku表字段注释
+comment on table product_sku is '产品SKU表';
+comment on column product_sku.id is 'SKU ID';
+comment on column product_sku.product_id is '产品ID';
+comment on column product_sku.discount_id is '折扣ID';
+comment on column product_sku.code is 'SKU 代码：格式为 key=value,key=value,...，其中，key:value 是 SKU 的属性，多个属性用逗号分隔';
+comment on column product_sku.name is 'SKU 可读名称';
+comment on column product_sku.price is '定价';
+comment on column product_sku.created_at is '创建时间';
+comment on column product_sku.updated_at is '更新时间';
+comment on column product_sku.deleted_at is '删除时间';
+
+-- product_sku_user
+drop table if exists product_sku_user cascade;
+create table product_sku_user (
+    id             int generated by default as identity primary key,
+    user_id        int not null,
+    product_sku_id int not null,
+    discount_id    int,
+    created_at     timestamptz default current_timestamp,
+    updated_at     timestamptz default current_timestamp
+);
+create index idx_product_sku_user_user_id on product_sku_user (user_id);
+create index idx_product_sku_user_product_sku_id on product_sku_user (product_sku_id);
+create index idx_product_sku_user_discount_id on product_sku_user (discount_id);
+
+-- product_sku_user表字段注释
+comment on table product_sku_user is '用户产品SKU表';
+comment on column product_sku_user.id is 'ID';
+comment on column product_sku_user.user_id is '用户ID';
+comment on column product_sku_user.product_sku_id is '产品SKU ID';
+comment on column product_sku_user.discount_id is '折扣ID';
+comment on column product_sku_user.created_at is '创建时间';
+comment on column product_sku_user.updated_at is '更新时间';
+
 -- resource
 drop table if exists resource cascade;
 create table resource (
     id          int generated by default as identity primary key,
     user_id     int  not null,
-    resource_no text,
-    active      bool not null default true,
+    resource_no text not null,
+    code        text,
     type        int  not null,
+    active      bool not null default true,
     created_at  timestamptz default current_timestamp,
     updated_at  timestamptz default current_timestamp,
     deleted_at  timestamptz
@@ -690,6 +816,7 @@ create table resource (
 create unique index udx_resource_resource_no on resource (resource_no);
 create index idx_resource_user_id on resource (user_id) where deleted_at is null;
 create index idx_resource_created_at on resource (created_at) where deleted_at is null;
+create index idx_resource_code on resource (code) where deleted_at is null;
 
 -- resource表字段注释
 comment on table resource is '套餐表';
@@ -698,6 +825,7 @@ comment on column resource.user_id is '用户ID';
 comment on column resource.resource_no is '套餐编号';
 comment on column resource.active is '套餐状态';
 comment on column resource.type is '套餐类型：1-短效动态，2-长效动态';
+comment on column resource.code is '产品编码';
 comment on column resource.created_at is '创建时间';
 comment on column resource.updated_at is '更新时间';
 comment on column resource.deleted_at is '删除时间';
@@ -707,58 +835,60 @@ drop table if exists resource_short cascade;
 create table resource_short (
     id          int generated by default as identity primary key,
     resource_id int not null,
-    type        int not null,
+    code        text,
     live        int not null,
-    expire      timestamptz,
-    quota       int,
+    type        int not null,
+    quota       int not null,
+    expire_at   timestamptz,
     used        int not null default 0,
-    daily_limit int not null default 0,
-    daily_used  int not null default 0,
-    daily_last  timestamptz
+    daily       int not null default 0,
+    last_at     timestamptz
 );
 create index idx_resource_short_resource_id on resource_short (resource_id);
+create index idx_resource_short_code on resource_short (code);
 
 -- resource_short表字段注释
 comment on table resource_short is '短效动态套餐表';
 comment on column resource_short.id is 'ID';
 comment on column resource_short.resource_id is '套餐ID';
-comment on column resource_short.type is '套餐类型：1-包时，2-包量';
+comment on column resource_short.code is '产品套餐编码';
 comment on column resource_short.live is '可用时长(秒)';
-comment on column resource_short.quota is '配额数量';
-comment on column resource_short.used is '已用数量';
-comment on column resource_short.expire is '过期时间';
-comment on column resource_short.daily_limit is '每日限制';
-comment on column resource_short.daily_used is '今日已用数量';
-comment on column resource_short.daily_last is '今日最后使用时间';
+comment on column resource_short.type is '套餐类型：1-包时，2-包量';
+comment on column resource_short.quota is '每日配额（包时）或总配额（包量）';
+comment on column resource_short.expire_at is '套餐过期时间，包时模式可用';
+comment on column resource_short.used is '总用量';
+comment on column resource_short.daily is '当日用量';
+comment on column resource_short.last_at is '最后使用时间';
 
 -- resource_long
 drop table if exists resource_long cascade;
 create table resource_long (
     id          int generated by default as identity primary key,
     resource_id int not null,
-    type        int not null,
+    code        text,
     live        int not null,
-    expire      timestamptz,
-    quota       int,
+    type        int not null,
+    quota       int not null,
+    expire_at   timestamptz,
     used        int not null default 0,
-    daily_limit int not null default 0,
-    daily_used  int not null default 0,
-    daily_last  timestamptz
+    daily       int not null default 0,
+    last_at     timestamptz
 );
 create index idx_resource_long_resource_id on resource_long (resource_id);
+create index idx_resource_long_code on resource_long (code);
 
 -- resource_long表字段注释
 comment on table resource_long is '长效动态套餐表';
 comment on column resource_long.id is 'ID';
 comment on column resource_long.resource_id is '套餐ID';
+comment on column resource_long.code is '产品套餐编码';
+comment on column resource_long.live is '可用时长(小时)';
 comment on column resource_long.type is '套餐类型：1-包时，2-包量';
-comment on column resource_long.live is '可用时长(天)';
-comment on column resource_long.quota is '配额数量';
-comment on column resource_long.used is '已用数量';
-comment on column resource_long.expire is '过期时间';
-comment on column resource_long.daily_limit is '每日限制';
-comment on column resource_long.daily_used is '今日已用数量';
-comment on column resource_long.daily_last is '今日最后使用时间';
+comment on column resource_long.quota is '每日配额（包时）或总配额（包量）';
+comment on column resource_long.expire_at is '套餐过期时间，包时模式可用';
+comment on column resource_long.used is '总用量';
+comment on column resource_long.daily is '当日用量';
+comment on column resource_long.last_at is '最后使用时间';
 
 -- endregion
 
@@ -854,10 +984,12 @@ create table bill (
     trade_id    int,
     resource_id int,
     refund_id   int,
+    coupon_id   int,
     bill_no     text           not null,
     info        text,
     type        int            not null,
     amount      decimal(12, 2) not null default 0,
+    actual      decimal(12, 2) not null default 0,
     created_at  timestamptz default current_timestamp,
     updated_at  timestamptz default current_timestamp,
     deleted_at  timestamptz
@@ -867,6 +999,7 @@ create index idx_bill_user_id on bill (user_id) where deleted_at is null;
 create index idx_bill_trade_id on bill (trade_id) where deleted_at is null;
 create index idx_bill_resource_id on bill (resource_id) where deleted_at is null;
 create index idx_bill_refund_id on bill (refund_id) where deleted_at is null;
+create index idx_bill_coupon_id on bill (coupon_id) where deleted_at is null;
 create index idx_bill_created_at on bill (created_at) where deleted_at is null;
 
 -- bill表字段注释
@@ -879,11 +1012,42 @@ comment on column bill.refund_id is '退款ID';
 comment on column bill.bill_no is '易读账单号';
 comment on column bill.info is '产品可读信息';
 comment on column bill.type is '账单类型：1-消费，2-退款，3-充值';
-comment on column bill.amount is '账单金额';
+comment on column bill.amount is '应付金额';
+comment on column bill.actual is '实付金额';
 comment on column bill.created_at is '创建时间';
 comment on column bill.updated_at is '更新时间';
 comment on column bill.deleted_at is '删除时间';
 
+-- balance_activity 余额变动记录
+drop table if exists balance_activity cascade;
+create table balance_activity (
+    id           int generated by default as identity primary key,
+    user_id      int  not null,
+    bill_id      int,
+    admin_id     int,
+    amount       text not null,
+    balance_prev text not null,
+    balance_curr text not null,
+    remark       text,
+    created_at   timestamptz default current_timestamp
+);
+create index idx_balance_activity_user_id on balance_activity (user_id);
+create index idx_balance_activity_bill_id on balance_activity (bill_id);
+create index idx_balance_activity_admin_id on balance_activity (admin_id);
+create index idx_balance_activity_created_at on balance_activity (created_at);
+
+-- balance_activity表字段注释
+comment on table balance_activity is '余额变动记录表';
+comment on column balance_activity.id is '记录ID';
+comment on column balance_activity.user_id is '用户ID';
+comment on column balance_activity.bill_id is '账单ID';
+comment on column balance_activity.admin_id is '管理员ID';
+comment on column balance_activity.amount is '变动金额';
+comment on column balance_activity.balance_prev is '变动前余额';
+comment on column balance_activity.balance_curr is '变动后余额';
+comment on column balance_activity.remark is '备注';
+comment on column balance_activity.created_at is '创建时间';
+
 -- coupon 优惠券
 drop table if exists coupon cascade;
 create table coupon (
@@ -926,6 +1090,8 @@ comment on column coupon.deleted_at is '删除时间';
 -- user表外键
 alter table "user"
     add constraint fk_user_admin_id foreign key (admin_id) references admin (id) on delete set null;
+alter table "user"
+    add constraint fk_user_discount_id foreign key (discount_id) references product_discount (id) on delete set null;
 
 -- session表外键
 alter table session
@@ -941,23 +1107,23 @@ alter table permission
 alter table link_user_role
     add constraint fk_link_user_role_user_id foreign key (user_id) references "user" (id) on delete cascade;
 alter table link_user_role
-    add constraint fk_link_user_role_role_id foreign key (role_id) references user_role (id) on delete cascade;
+    add constraint fk_link_user_role_role_id foreign key (user_role_id) references user_role (id) on delete cascade;
 
 -- link_admin_role表外键
 alter table link_admin_role
     add constraint fk_link_admin_role_admin_id foreign key (admin_id) references admin (id) on delete cascade;
 alter table link_admin_role
-    add constraint fk_link_admin_role_role_id foreign key (role_id) references admin_role (id) on delete cascade;
+    add constraint fk_link_admin_role_role_id foreign key (admin_role_id) references admin_role (id) on delete cascade;
 
 -- link_user_role_permission表外键
 alter table link_user_role_permission
-    add constraint fk_link_user_role_permission_role_id foreign key (role_id) references user_role (id) on delete cascade;
+    add constraint fk_link_user_role_permission_role_id foreign key (user_role_id) references user_role (id) on delete cascade;
 alter table link_user_role_permission
     add constraint fk_link_user_role_permission_permission_id foreign key (permission_id) references permission (id) on delete cascade;
 
 -- link_admin_role_permission表外键
 alter table link_admin_role_permission
-    add constraint fk_link_admin_role_permission_role_id foreign key (role_id) references admin_role (id) on delete cascade;
+    add constraint fk_link_admin_role_permission_role_id foreign key (admin_role_id) references admin_role (id) on delete cascade;
 alter table link_admin_role_permission
     add constraint fk_link_admin_role_permission_permission_id foreign key (permission_id) references permission (id) on delete cascade;
 
@@ -984,14 +1150,20 @@ alter table channel
 -- resource表外键
 alter table resource
     add constraint fk_resource_user_id foreign key (user_id) references "user" (id) on delete cascade;
+alter table resource
+    add constraint fk_product_code foreign key (code) references product (code) on update cascade on delete restrict;
 
 -- resource_short表外键
 alter table resource_short
     add constraint fk_resource_short_resource_id foreign key (resource_id) references resource (id) on delete cascade;
+alter table resource_short
+    add constraint fk_resource_short_code foreign key (code) references product_sku (code) on update cascade on delete restrict;
 
 -- resource_long表外键
 alter table resource_long
     add constraint fk_resource_long_resource_id foreign key (resource_id) references resource (id) on delete cascade;
+alter table resource_long
+    add constraint fk_resource_long_code foreign key (code) references product_sku (code) on update cascade on delete restrict;
 
 -- trade表外键
 alter table trade
@@ -1012,22 +1184,31 @@ alter table bill
     add constraint fk_bill_resource_id foreign key (resource_id) references resource (id) on delete set null;
 alter table bill
     add constraint fk_bill_refund_id foreign key (refund_id) references refund (id) on delete set null;
+alter table bill
+    add constraint fk_bill_coupon_id foreign key (coupon_id) references coupon (id) on delete set null;
 
 -- coupon表外键
 alter table coupon
     add constraint fk_coupon_user_id foreign key (user_id) references "user" (id) on delete cascade;
 
--- endregion
+-- product_sku表外键
+alter table product_sku
+    add constraint fk_product_sku_product_id foreign key (product_id) references product (id) on delete cascade;
+alter table product_sku
+    add constraint fk_product_sku_discount_id foreign key (discount_id) references product_discount (id) on delete restrict;
 
--- ====================
--- region 填充数据
--- ====================
+-- product_sku_user表外键
+alter table product_sku_user
+    add constraint fk_product_sku_user_user_id foreign key (user_id) references "user" (id) on delete cascade;
+alter table product_sku_user
+    add constraint fk_product_sku_user_product_sku_id foreign key (product_sku_id) references product_sku (id) on delete cascade;
+alter table product_sku_user
+    add constraint fk_product_sku_user_discount_id foreign key (discount_id) references product_discount (id) on delete restrict;
 
-insert into client (
-    client_id, client_secret, redirect_uri, spec, name, type
-)
-values (
-    'web', '$2a$10$Ss12mXQgpYyo1CKIZ3URouDm.Lc2KcYJzsvEK2PTIXlv6fHQht45a', '', 3, 'web', 1
-);
+--balance_activity表外键
+alter table balance_activity
+    add constraint fk_balance_activity_user_id foreign key (user_id) references "user" (id) on delete cascade;
+alter table balance_activity
+    add constraint fk_balance_activity_bill_id foreign key (bill_id) references bill (id) on delete set null;
 
 -- endregion

web/auth/account.go

@@ -0,0 +1,175 @@
+package auth
+
+import (
+	"context"
+	"errors"
+	"log/slog"
+	"platform/pkg/u"
+	"platform/web/core"
+	m "platform/web/models"
+	q "platform/web/queries"
+	s "platform/web/services"
+
+	"golang.org/x/crypto/bcrypt"
+)
+
+func authClient(clientId string, clientSecrets ...string) (*m.Client, error) {
+
+	// 获取客户端信息
+	client, err := q.Client.
+		Preload(q.Client.Permissions).
+		Where(
+			q.Client.ClientID.Eq(clientId),
+			q.Client.Status.Eq(1)).
+		Take()
+	if err != nil {
+		return nil, err
+	}
+
+	// 检查客户端密钥
+	if client.Spec == m.ClientSpecWeb || client.Spec == m.ClientSpecAPI {
+		if len(clientSecrets) == 0 {
+			return nil, errors.New("客户端密钥错误")
+		}
+		clientSecret := clientSecrets[0]
+		if bcrypt.CompareHashAndPassword([]byte(client.ClientSecret), []byte(clientSecret)) != nil {
+			return nil, errors.New("客户端密钥错误")
+		}
+	}
+
+	// 组织授权信息（一次性请求）
+	return client, nil
+}
+
+func authUser(loginType PwdLoginType, username, password string) (user *m.User, err error) {
+	switch loginType {
+	case PwdLoginByPhone:
+		user, err = authUserBySms(q.Q, username, password)
+		if err != nil {
+			return nil, err
+		}
+		if user == nil {
+			user = &m.User{
+				Phone:    username,
+				Username: u.P(username),
+				Status:   m.UserStatusEnabled,
+			}
+		}
+	case PwdLoginByEmail:
+		user, err = authUserByEmail(q.Q, username, password)
+		if err != nil {
+			return nil, err
+		}
+	case PwdLoginByPassword:
+		user, err = authUserByPassword(q.Q, username, password)
+		if err != nil {
+			return nil, err
+		}
+	default:
+		return nil, ErrAuthorizeInvalidRequest
+	}
+
+	// 账户状态
+	if user.Status == m.UserStatusDisabled {
+		return nil, core.NewBizErr("账号已禁用")
+	}
+
+	return user, nil
+}
+
+func authUserBySms(tx *q.Query, username, code string) (*m.User, error) {
+	// 验证验证码
+	err := s.Verifier.VerifySms(context.Background(), username, code)
+	if err != nil {
+		return nil, core.NewBizErr("短信认证失败", err)
+	}
+
+	// 查找用户
+	return tx.User.Where(tx.User.Phone.Eq(username)).Take()
+}
+
+func authUserByEmail(tx *q.Query, username, code string) (*m.User, error) {
+	return nil, core.NewServErr("邮箱登录不可用")
+}
+
+func authUserByPassword(tx *q.Query, username, password string) (*m.User, error) {
+	user, err := tx.User.
+		Where(tx.User.Phone.Eq(username)).
+		Or(tx.User.Email.Eq(username)).
+		Or(tx.User.Username.Eq(username)).
+		Take()
+	if err != nil {
+		slog.Debug("查找用户失败", "error", err)
+		return nil, core.NewBizErr("用户不存在或密码错误")
+	}
+
+	// 验证密码
+	if user.Password == nil || *user.Password == "" {
+		slog.Debug("用户未设置密码", "username", username)
+		return nil, core.NewBizErr("用户不存在或密码错误")
+	}
+	if bcrypt.CompareHashAndPassword([]byte(*user.Password), []byte(password)) != nil {
+		slog.Debug("密码验证失败", "username", username)
+		return nil, core.NewBizErr("用户不存在或密码错误")
+	}
+
+	return user, nil
+}
+
+func authAdmin(loginType PwdLoginType, username, password string) (admin *m.Admin, err error) {
+	switch loginType {
+	case PwdLoginByPhone, PwdLoginByEmail:
+		return nil, core.NewServErr("不支持的登录方式：" + string(loginType))
+	case PwdLoginByPassword:
+		admin, err = authAdminByPassword(q.Q, username, password)
+		if err != nil {
+			return nil, err
+		}
+	default:
+		return nil, ErrAuthorizeInvalidRequest
+	}
+
+	// 账户状态
+	if admin.Status == m.AdminStatusDisabled {
+		return nil, core.NewBizErr("账号已禁用")
+	}
+
+	return admin, nil
+}
+
+func authAdminByPassword(tx *q.Query, username, password string) (*m.Admin, error) {
+	admin, err := tx.Admin.Where(tx.Admin.Username.Eq(username)).Take()
+	if err != nil {
+		return nil, core.NewBizErr("账号不存在或密码错误")
+	}
+
+	// 验证密码
+	if admin.Password == "" {
+		return nil, core.NewBizErr("账号不存在或密码错误")
+	}
+	if bcrypt.CompareHashAndPassword([]byte(admin.Password), []byte(password)) != nil {
+		return nil, core.NewBizErr("账号不存在或密码错误")
+	}
+
+	return admin, nil
+}
+
+func adminScopes(admin *m.Admin) ([]string, error) {
+	var scopes []struct{ Name string }
+	err := q.Admin.
+		LeftJoin(q.LinkAdminRole, q.LinkAdminRole.AdminID.EqCol(q.Admin.ID)).
+		LeftJoin(q.LinkAdminRolePermission, q.LinkAdminRolePermission.RoleID.EqCol(q.LinkAdminRole.RoleID)).
+		LeftJoin(q.Permission, q.Permission.ID.EqCol(q.LinkAdminRolePermission.PermissionID)).
+		Where(q.Admin.ID.Eq(admin.ID)).
+		Select(q.Permission.Name).
+		Scan(&scopes)
+	if err != nil {
+		return nil, err
+	}
+
+	scopeNames := make([]string, 0, len(scopes))
+	for _, scope := range scopes {
+		scopeNames = append(scopeNames, scope.Name)
+	}
+	return scopeNames, nil
+}

web/auth/check.go

@@ -2,6 +2,7 @@ package auth
 
 import (
 	m "platform/web/models"
+	"strings"
 
 	"github.com/gofiber/fiber/v2"
 )
@@ -12,7 +13,6 @@ type AuthCtx struct {
 	Client  *m.Client  `json:"client,omitempty"`
 	Scopes  []string   `json:"scopes,omitempty"`
 	Session *m.Session `json:"session,omitempty"`
-	smap    map[string]struct{}
 }
 
 func (a *AuthCtx) PermitUser(scopes ...string) (*AuthCtx, error) {
@@ -68,14 +68,11 @@ func (a *AuthCtx) checkScopes(scopes ...string) bool {
 	if len(scopes) == 0 || len(a.Scopes) == 0 {
 		return true
 	}
-	if len(a.smap) == 0 && len(a.Scopes) > 0 {
-		for _, scope := range scopes {
-			a.smap[scope] = struct{}{}
-		}
-	}
 	for _, scope := range scopes {
-		if _, ok := a.smap[scope]; ok {
-			return true
+		for _, prefix := range a.Scopes {
+			if strings.HasPrefix(scope, prefix) {
+				return true
+			}
 		}
 	}
 	return false

web/auth/endpoints.go

@@ -6,10 +6,8 @@ import (
 	"encoding/base64"
 	"encoding/json"
 	"errors"
-	"log/slog"
 	"platform/pkg/env"
 	"platform/pkg/u"
-	"platform/web/core"
 	g "platform/web/globals"
 	"platform/web/globals/orm"
 	m "platform/web/models"
@@ -22,67 +20,52 @@ import (
 	"gorm.io/gorm"
 )
 
-type GrantType string
+// AuthorizeGet 授权端点
+func AuthorizeGet(ctx *fiber.Ctx) error {
 
-const (
-	GrantAuthorizationCode = GrantType("authorization_code") // 授权码模式
-	GrantClientCredentials = GrantType("client_credentials") // 客户端凭证模式
-	GrantRefreshToken      = GrantType("refresh_token")      // 刷新令牌模式
-	GrantPassword          = GrantType("password")           // 密码模式（私有扩展）
-)
+	// 检查请求
+	req := new(AuthorizeGetReq)
+	if err := g.Validator.ParseQuery(ctx, req); err != nil {
+		return err
+	}
 
-type PasswordGrantType string
+	// 检查客户端
+	client, err := authClient(req.ClientID)
+	if err != nil {
+		return err
+	}
 
-const (
-	GrantPasswordSecret = PasswordGrantType("password")   // 账号密码
-	GrantPasswordPhone  = PasswordGrantType("phone_code") // 手机验证码
-	GrantPasswordEmail  = PasswordGrantType("email_code") // 邮箱验证码
-)
+	if client.RedirectURI == nil || *client.RedirectURI != req.RedirectURI {
+		return errors.New("客户端重定向URI错误")
+	}
 
-type TokenReq struct {
-	GrantType    GrantType `json:"grant_type" form:"grant_type"`
-	ClientID     string    `json:"client_id" form:"client_id"`
-	ClientSecret string    `json:"client_secret" form:"client_secret"`
-	Scope        string    `json:"scope" form:"scope"`
-	GrantCodeData
-	GrantClientData
-	GrantRefreshData
-	GrantPasswordData
+	// todo 检查 scope
+
+	// 授权确认页面
+	return nil
 }
 
-type GrantCodeData struct {
-	Code         string `json:"code" form:"code"`
-	RedirectURI  string `json:"redirect_uri" form:"redirect_uri"`
-	CodeVerifier string `json:"code_verifier" form:"code_verifier"`
+type AuthorizeGetReq struct {
+	ResponseType string `json:"response_type" validate:"eq=code"`
+	ClientID     string `json:"client_id" validate:"required"`
+	RedirectURI  string `json:"redirect_uri" validate:"required"`
+	Scope        string `json:"scope"`
+	State        string `json:"state"`
 }
 
-type GrantClientData struct {
+func AuthorizePost(ctx *fiber.Ctx) error {
+
+	// todo 解析用户授权的范围
+
+	return nil
 }
 
-type GrantRefreshData struct {
-	RefreshToken string `json:"refresh_token" form:"refresh_token"`
-}
-
-type GrantPasswordData struct {
-	LoginType PasswordGrantType `json:"login_type" form:"login_type"`
-	Username  string            `json:"username" form:"username"`
-	Password  string            `json:"password" form:"password"`
-	Remember  bool              `json:"remember" form:"remember"`
-}
-
-type TokenResp struct {
-	AccessToken  string `json:"access_token"`
-	RefreshToken string `json:"refresh_token,omitempty"`
-	ExpiresIn    int    `json:"expires_in"`
-	TokenType    string `json:"token_type"`
-	Scope        string `json:"scope,omitempty"`
-}
-
-type TokenErrResp struct {
-	Error       string `json:"error"`
-	Description string `json:"error_description,omitempty"`
+type AuthorizePostReq struct {
+	Accept bool   `json:"accept"`
+	Scope  string `json:"scope"`
 }
 
+// Token 令牌端点
 func Token(c *fiber.Ctx) error {
 	now := time.Now()
 
@@ -165,6 +148,75 @@ func Token(c *fiber.Ctx) error {
 	})
 }
 
+type TokenReq struct {
+	GrantType    GrantType `json:"grant_type" form:"grant_type"`
+	ClientID     string    `json:"client_id" form:"client_id"`
+	ClientSecret string    `json:"client_secret" form:"client_secret"`
+	Scope        string    `json:"scope" form:"scope"`
+	GrantCodeData
+	GrantClientData
+	GrantRefreshData
+	GrantPasswordData
+}
+
+type GrantCodeData struct {
+	Code         string `json:"code" form:"code"`
+	RedirectURI  string `json:"redirect_uri" form:"redirect_uri"`
+	CodeVerifier string `json:"code_verifier" form:"code_verifier"`
+}
+
+type GrantClientData struct {
+}
+
+type GrantRefreshData struct {
+	RefreshToken string `json:"refresh_token" form:"refresh_token"`
+}
+
+type GrantPasswordData struct {
+	LoginType PwdLoginType `json:"login_type" form:"login_type"`
+	LoginPool PwdLoginPool `json:"login_pool" form:"login_pool"`
+	Username  string       `json:"username" form:"username"`
+	Password  string       `json:"password" form:"password"`
+	Remember  bool         `json:"remember" form:"remember"`
+}
+
+type GrantType string
+
+const (
+	GrantAuthorizationCode = GrantType("authorization_code") // 授权码模式
+	GrantClientCredentials = GrantType("client_credentials") // 客户端凭证模式
+	GrantRefreshToken      = GrantType("refresh_token")      // 刷新令牌模式
+	GrantPassword          = GrantType("password")           // 密码模式（私有扩展）
+)
+
+type PwdLoginType string
+
+const (
+	PwdLoginByPassword = PwdLoginType("password")   // 账号密码
+	PwdLoginByPhone    = PwdLoginType("phone_code") // 手机验证码
+	PwdLoginByEmail    = PwdLoginType("email_code") // 邮箱验证码
+)
+
+type PwdLoginPool string
+
+const (
+	PwdLoginAsUser  = PwdLoginPool("user")  // 用户池
+	PwdLoginAsAdmin = PwdLoginPool("admin") // 管理员池
+)
+
+type TokenResp struct {
+	AccessToken  string `json:"access_token"`
+	RefreshToken string `json:"refresh_token,omitempty"`
+	ExpiresIn    int    `json:"expires_in"`
+	TokenType    string `json:"token_type"`
+	Scope        string `json:"scope,omitempty"`
+}
+
+type TokenErrResp struct {
+	Error       string `json:"error"`
+	Description string `json:"error_description,omitempty"`
+}
+
 func authAuthorizationCode(c *fiber.Ctx, auth *AuthCtx, req *TokenReq, now time.Time) (*m.Session, error) {
 
 	// 检查 code 获取用户授权信息
@@ -226,7 +278,7 @@ func authAuthorizationCode(c *fiber.Ctx, auth *AuthCtx, req *TokenReq, now time.
 		session.RefreshTokenExpires = u.P(now.Add(time.Duration(env.SessionRefreshExpire) * time.Second))
 	}
 
-	err = SaveSession(session)
+	err = SaveSession(q.Q, session)
 	if err != nil {
 		return nil, err
 	}
@@ -236,6 +288,7 @@ func authAuthorizationCode(c *fiber.Ctx, auth *AuthCtx, req *TokenReq, now time.
 
 func authClientCredential(c *fiber.Ctx, auth *AuthCtx, _ *TokenReq, now time.Time) (*m.Session, error) {
 	// todo 检查 scope
+	scopes := strings.Join(auth.Scopes, " ")
 
 	// 生成会话
 	ip, _ := orm.ParseInet(c.IP()) // 可空字段，忽略异常
@@ -246,10 +299,11 @@ func authClientCredential(c *fiber.Ctx, auth *AuthCtx, _ *TokenReq, now time.Tim
 		ClientID:           &auth.Client.ID,
 		AccessToken:        uuid.NewString(),
 		AccessTokenExpires: now.Add(time.Duration(env.SessionAccessExpire) * time.Second),
+		Scopes:             &scopes,
 	}
 
 	// 保存会话
-	err := SaveSession(session)
+	err := SaveSession(q.Q, session)
 	if err != nil {
 		return nil, err
 	}
@@ -261,71 +315,90 @@ func authPassword(c *fiber.Ctx, auth *AuthCtx, req *TokenReq, now time.Time) (*m
 	ip, _ := orm.ParseInet(c.IP()) // 可空字段，忽略异常
 	ua := u.X(c.Get(fiber.HeaderUserAgent))
 
+	// 分池认证
+	var err error
 	var user *m.User
-	err := q.Q.Transaction(func(tx *q.Query) (err error) {
-		switch req.LoginType {
-		case GrantPasswordPhone:
-			user, err = authUserBySms(tx, req.Username, req.Password)
-			if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
-				return err
-			}
-			if user == nil {
-				user = &m.User{
-					Phone:    req.Username,
-					Username: u.P(req.Username),
-					Status:   m.UserStatusEnabled,
-				}
-			}
-		case GrantPasswordEmail:
-			user, err = authUserByEmail(tx, req.Username, req.Password)
-			if err != nil {
-				return err
-			}
-		case GrantPasswordSecret:
-			user, err = authUserByPassword(tx, req.Username, req.Password)
-			if err != nil {
-				return err
-			}
-		default:
-			return ErrAuthorizeInvalidRequest
-		}
+	var admin *m.Admin
 
-		// 账户状态
-		if user.Status == m.UserStatusDisabled {
-			slog.Debug("账户状态异常", "username", req.Username, "status", user.Status)
-			return core.NewBizErr("账号无法登录")
+	var scopes []string
+
+	pool := req.LoginPool
+	if pool == "" {
+		pool = PwdLoginAsUser
+	}
+	switch pool {
+	case PwdLoginAsUser:
+		user, err = authUser(req.LoginType, req.Username, req.Password)
+		if err != nil {
+			if req.LoginType != PwdLoginByPhone || !errors.Is(err, gorm.ErrRecordNotFound) {
+				return nil, err
+			}
+
+			// 手机号首次登录的自动创建用户
+			user = &m.User{
+				Phone:  req.Username,
+				Status: m.UserStatusEnabled,
+			}
 		}
 
 		// 更新用户的登录时间
 		user.LastLogin = u.P(time.Now())
 		user.LastLoginIP = ip
 		user.LastLoginUA = ua
-		if err := tx.User.Save(user); err != nil {
-			return err
+
+	case PwdLoginAsAdmin:
+		admin, err = authAdmin(req.LoginType, req.Username, req.Password)
+		if err != nil {
+			return nil, err
+		}
+		scopes, err = adminScopes(admin)
+		if err != nil {
+			return nil, err
 		}
 
-		return nil
-	})
-	if err != nil {
-		return nil, err
+		// 更新管理员登录时间
+		admin.LastLogin = u.P(time.Now())
+		admin.LastLoginIP = ip
+		admin.LastLoginUA = ua
+
+	default:
+		return nil, ErrAuthorizeInvalidRequest
 	}
 
 	// 生成会话
 	session := &m.Session{
 		IP:                 ip,
 		UA:                 ua,
-		UserID:             &user.ID,
 		ClientID:           &auth.Client.ID,
-		Scopes:             u.X(req.Scope),
+		Scopes:             u.X(strings.Join(scopes, " ")),
 		AccessToken:        uuid.NewString(),
 		AccessTokenExpires: now.Add(time.Duration(env.SessionAccessExpire) * time.Second),
 	}
+
 	if req.Remember {
 		session.RefreshToken = u.P(uuid.NewString())
 		session.RefreshTokenExpires = u.P(now.Add(time.Duration(env.SessionRefreshExpire) * time.Second))
 	}
 
-	err = SaveSession(session)
+	// 保存用户更新和会话
+	err = q.Q.Transaction(func(tx *q.Query) error {
+		if user != nil {
+			if err := tx.User.Save(user); err != nil {
+				return err
+			}
+			session.UserID = &user.ID
+		}
+		if admin != nil {
+			if err := tx.Admin.Save(admin); err != nil {
+				return err
+			}
+			session.AdminID = &admin.ID
+		}
+		if err := SaveSession(tx, session); err != nil {
+			return err
+		}
+		return nil
+	})
 	if err != nil {
 		return nil, err
 	}
@@ -353,7 +426,7 @@ func authRefreshToken(_ *fiber.Ctx, _ *AuthCtx, req *TokenReq, now time.Time) (*
 	}
 
 	// 保存令牌
-	err = SaveSession(session)
+	err = SaveSession(q.Q, session)
 	if err != nil {
 		return nil, err
 	}
@@ -394,12 +467,125 @@ func sendError(c *fiber.Ctx, err error, description ...string) error {
 	return err
 }
 
-func Revoke() error {
+// Revoke 令牌撤销端点
+func Revoke(ctx *fiber.Ctx) error {
+	_, err := GetAuthCtx(ctx).PermitUser()
+	if err != nil {
+		// 用户未登录
+		return nil
+	}
+
+	// 解析请求参数
+	req := new(RevokeReq)
+	if err := ctx.BodyParser(req); err != nil {
+		return err
+	}
+
+	// 删除会话
+	err = RemoveSession(ctx.Context(), req.AccessToken, req.RefreshToken)
+	if err != nil {
+		return err
+	}
+
 	return nil
 }
 
-func Introspect() error {
-	return nil
+type RevokeReq struct {
+	AccessToken  string `json:"access_token"`
+	RefreshToken string `json:"refresh_token"`
+}
+
+// Introspect 令牌检查端点
+func Introspect(ctx *fiber.Ctx) error {
+	authCtx := GetAuthCtx(ctx)
+
+	// 尝试验证用户权限
+	if _, err := authCtx.PermitUser(); err == nil {
+		return introspectUser(ctx, authCtx)
+	}
+
+	// 尝试验证管理员权限
+	if _, err := authCtx.PermitAdmin(); err == nil {
+		return introspectAdmin(ctx, authCtx)
+	}
+
+	return ErrAuthenticateForbidden
+}
+
+// introspectUser 获取并返回用户信息
+func introspectUser(ctx *fiber.Ctx, authCtx *AuthCtx) error {
+	// 获取用户信息
+	profile, err := q.User.
+		Where(q.User.ID.Eq(authCtx.User.ID)).
+		Omit(q.User.DeletedAt).
+		Take()
+	if err != nil {
+		return err
+	}
+
+	// 检查用户是否设置了密码
+	hasPassword := false
+	if profile.Password != nil && *profile.Password != "" {
+		hasPassword = true
+		profile.Password = nil // 不返回密码
+	}
+
+	// 掩码敏感信息
+	if profile.Phone != "" {
+		profile.Phone = maskPhone(profile.Phone)
+	}
+	if profile.IDNo != nil && *profile.IDNo != "" {
+		profile.IDNo = u.P(maskIdNo(*profile.IDNo))
+	}
+
+	return ctx.JSON(struct {
+		m.User
+		HasPassword bool `json:"has_password"` // 是否设置了密码
+	}{*profile, hasPassword})
+}
+
+// introspectAdmin 获取并返回管理员信息
+func introspectAdmin(ctx *fiber.Ctx, authCtx *AuthCtx) error {
+	// 获取管理员信息
+	profile, err := q.Admin.
+		Preload(q.Admin.Roles, q.Admin.Roles.Permissions).
+		Where(q.Admin.ID.Eq(authCtx.Admin.ID)).
+		Omit(q.Admin.DeletedAt, q.Admin.Password).
+		Take()
+	if err != nil {
+		return err
+	}
+
+	// 整理权限列表
+	scopes := make(map[string]struct{}, 0)
+	for _, role := range profile.Roles {
+		for _, permission := range role.Permissions {
+			scopes[permission.Name] = struct{}{}
+		}
+	}
+	list := make([]string, 0, len(scopes))
+	for scope := range scopes {
+		list = append(list, scope)
+	}
+
+	return ctx.JSON(struct {
+		*m.Admin
+		Scopes []string `json:"scopes"`
+	}{profile, list})
+}
+
+func maskPhone(phone string) string {
+	if len(phone) < 11 {
+		return phone
+	}
+	return phone[:3] + "****" + phone[7:]
+}
+
+func maskIdNo(idNo string) string {
+	if len(idNo) < 18 {
+		return idNo
+	}
+	return idNo[:3] + "*********" + idNo[14:]
 }
 
 type CodeContext struct {

web/auth/middleware.go

@@ -6,15 +6,10 @@ import (
 	"errors"
 	"fmt"
 	"log/slog"
-	"platform/web/core"
-	m "platform/web/models"
-	q "platform/web/queries"
-	s "platform/web/services"
 	"strings"
 	"time"
 
 	"github.com/gofiber/fiber/v2"
-	"golang.org/x/crypto/bcrypt"
 )
 
 func Authenticate() fiber.Handler {
@@ -118,72 +113,14 @@ func authBasic(_ context.Context, token string) (*AuthCtx, error) {
 		return nil, fmt.Errorf("客户端认证失败：%w", err)
 	}
 
-	return &AuthCtx{
-		Client: client,
-		Scopes: []string{},
-	}, nil
-}
-
-func authClient(clientId, clientSecret string) (*m.Client, error) {
-
-	// 获取客户端信息
-	client, err := q.Client.
-		Where(
-			q.Client.ClientID.Eq(clientId),
-			q.Client.Status.Eq(1)).
-		Take()
-	if err != nil {
-		return nil, err
-	}
-
-	// 检查客户端密钥
-	if client.Spec == m.ClientSpecWeb || client.Spec == m.ClientSpecAPI {
-		if bcrypt.CompareHashAndPassword([]byte(client.ClientSecret), []byte(clientSecret)) != nil {
-			return nil, errors.New("客户端密钥错误")
+	scopes := []string{}
+	if client.Permissions != nil {
+		for _, p := range client.Permissions {
+			scopes = append(scopes, p.Name)
 		}
 	}
-
-	// todo 查询客户端关联权限
-
-	// 组织授权信息（一次性请求）
-	return client, nil
-}
-
-func authUserBySms(tx *q.Query, username, code string) (*m.User, error) {
-	// 验证验证码
-	err := s.Verifier.VerifySms(context.Background(), username, code)
-	if err != nil {
-		return nil, core.NewBizErr("短信认证失败：%w", err)
-	}
-
-	// 查找用户
-	return tx.User.Where(tx.User.Phone.Eq(username)).Take()
-}
-
-func authUserByEmail(tx *q.Query, username, code string) (*m.User, error) {
-	return nil, core.NewServErr("邮箱登录不可用")
-}
-
-func authUserByPassword(tx *q.Query, username, password string) (*m.User, error) {
-	user, err := tx.User.
-		Where(tx.User.Phone.Eq(username)).
-		Or(tx.User.Email.Eq(username)).
-		Or(tx.User.Username.Eq(username)).
-		Take()
-	if err != nil {
-		slog.Debug("查找用户失败", "error", err)
-		return nil, core.NewBizErr("用户不存在或密码错误")
-	}
-
-	// 验证密码
-	if user.Password == nil || *user.Password == "" {
-		slog.Debug("用户未设置密码", "username", username)
-		return nil, core.NewBizErr("用户不存在或密码错误")
-	}
-	if bcrypt.CompareHashAndPassword([]byte(*user.Password), []byte(password)) != nil {
-		slog.Debug("密码验证失败", "username", username)
-		return nil, core.NewBizErr("用户不存在或密码错误")
-	}
-
-	return user, nil
+	return &AuthCtx{
+		Client: client,
+		Scopes: scopes,
+	}, nil
 }

web/auth/session.go

@@ -29,8 +29,8 @@ func FindSessionByRefresh(refreshToken string, now time.Time) (*m.Session, error
 		).First()
 }
 
-func SaveSession(session *m.Session) error {
-	return q.Session.Save(session)
+func SaveSession(tx *q.Query, session *m.Session) error {
+	return tx.Session.Save(session)
 }
 
 func RemoveSession(ctx context.Context, accessToken string, refreshToken string) error {

web/core/error.go

@@ -19,7 +19,6 @@ type Err struct {
 func (e *Err) Error() string {
 	if e.err != nil {
 		slog.Debug(fmt.Sprintf("%s: %s", e.msg, e.err.Error()))
-		return e.msg
 	}
 	return e.msg
 }

web/core/http.go

@@ -1,5 +1,17 @@
 package core
 
+import (
+	"fmt"
+	"net/http"
+	"net/http/httputil"
+	"net/url"
+	"platform/pkg/env"
+	"platform/pkg/u"
+	"reflect"
+	"strconv"
+	"strings"
+)
+
 // PageReq 分页请求参数
 type PageReq struct {
 	RawPage int `json:"page"`
@@ -38,3 +50,88 @@ type PageResp struct {
 	Size  int `json:"size"`
 	List  any `json:"list"`
 }
+
+// Fetch 发送HTTP请求并返回响应
+func Fetch(req *http.Request) (*http.Response, error) {
+	if env.DebugHttpDump {
+		str, err := httputil.DumpRequest(req, true)
+		if err != nil {
+			return nil, err
+		}
+		fmt.Printf("===== REQUEST ===== %s\n", req.URL)
+		fmt.Println(string(str))
+	}
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return nil, err
+	}
+
+	if env.DebugHttpDump {
+		str, err := httputil.DumpResponse(resp, true)
+		if err != nil {
+			return nil, err
+		}
+		fmt.Printf("===== RESPONSE ===== %s\n", req.URL)
+		fmt.Println(string(str))
+	}
+
+	return resp, nil
+}
+
+func Query(in any) url.Values {
+	out := url.Values{}
+
+	if in == nil {
+		return out
+	}
+
+	ref := reflect.ValueOf(in)
+	if ref.Kind() == reflect.Pointer {
+		ref = ref.Elem()
+	}
+
+	if ref.Kind() != reflect.Struct {
+		return out
+	}
+
+	for i := 0; i < ref.NumField(); i++ {
+		field := ref.Type().Field(i)
+		value := ref.Field(i)
+
+		if field.Type.Kind() == reflect.Pointer {
+			if value.IsNil() {
+				continue
+			}
+			value = value.Elem()
+		}
+
+		name := field.Name
+		tags := strings.Split(field.Tag.Get("query"), ",")
+		if len(tags) > 0 && tags[0] != "" {
+			name = tags[0]
+		}
+
+		switch value := value.Interface().(type) {
+		case string:
+			out.Add(name, value)
+		case int:
+			out.Add(name, strconv.Itoa(value))
+		case bool:
+			if tags[1] == "b2i" {
+				out.Add(name, u.Ternary(value, "1", "0"))
+			} else {
+				out.Add(name, strconv.FormatBool(value))
+			}
+		default:
+			out.Add(name, fmt.Sprintf("%v", value))
+		}
+	}
+
+	return out
+}
+
+// 数据请求
+type IdReq struct {
+	Id int32 `json:"id"`
+}

web/core/model.go

@@ -15,7 +15,7 @@ type Model struct {
 	ID        int32          `json:"id" gorm:"column:id;primaryKey"`
 	CreatedAt time.Time      `json:"created_at" gorm:"column:created_at"`
 	UpdatedAt time.Time      `json:"updated_at" gorm:"column:updated_at"`
-	DeletedAt gorm.DeletedAt `json:"deleted_at" gorm:"column:deleted_at"`
+	DeletedAt gorm.DeletedAt `json:"-" gorm:"column:deleted_at"`
 }
 
 func (m *Model) GetID() int32 {

web/core/product.go

@@ -0,0 +1,8 @@
+package core
+
+type ProductCode string
+
+var (
+	ProductShort ProductCode = "short"
+	ProductLong  ProductCode = "long"
+)

web/core/scopes.go

@@ -0,0 +1,58 @@
+package core
+
+const (
+	ScopePermission      = string("permission")       // 权限
+	ScopePermissionRead  = string("permission:read")  // 读取权限列表
+	ScopePermissionWrite = string("permission:write") // 写入权限
+
+	ScopeAdminRole      = string("admin_role")       // 管理员角色
+	ScopeAdminRoleRead  = string("admin_role:read")  // 读取管理员角色列表
+	ScopeAdminRoleWrite = string("admin_role:write") // 写入管理员角色
+
+	ScopeAdmin      = string("admin")       // 管理员
+	ScopeAdminRead  = string("admin:read")  // 读取管理员列表
+	ScopeAdminWrite = string("admin:write") // 写入管理员
+
+	ScopeProduct      = string("product")       // 产品
+	ScopeProductRead  = string("product:read")  // 读取产品列表
+	ScopeProductWrite = string("product:write") // 写入产品
+
+	ScopeProductSku      = string("product_sku")       // 产品套餐
+	ScopeProductSkuRead  = string("product_sku:read")  // 读取产品套餐列表
+	ScopeProductSkuWrite = string("product_sku:write") // 写入产品套餐
+
+	ScopeDiscount      = string("discount")       // 折扣
+	ScopeDiscountRead  = string("discount:read")  // 读取折扣列表
+	ScopeDiscountWrite = string("discount:write") // 写入折扣
+
+	ScopeResource      = string("resource")       // 用户套餐
+	ScopeResourceRead  = string("resource:read")  // 读取用户套餐列表
+	ScopeResourceWrite = string("resource:write") // 写入用户套餐
+
+	ScopeUser             = string("user")               // 用户
+	ScopeUserRead         = string("user:read")          // 读取用户列表
+	ScopeUserReadOne      = string("user:read:one")      // 读取单个用户
+	ScopeUserWrite        = string("user:write")         // 写入用户
+	ScopeUserWriteBalance = string("user:write:balance") // 写入用户余额
+	ScopeUserWriteBind    = string("user:write:bind")    // 用户认领
+
+	ScopeCoupon      = string("coupon")       // 优惠券
+	ScopeCouponRead  = string("coupon:read")  // 读取优惠券列表
+	ScopeCouponWrite = string("coupon:write") // 写入优惠券
+
+	ScopeBatch      = string("batch")       // 批次
+	ScopeBatchRead  = string("batch:read")  // 读取批次列表
+	ScopeBatchWrite = string("batch:write") // 写入批次
+
+	ScopeChannel      = string("channel")       // IP
+	ScopeChannelRead  = string("channel:read")  // 读取 IP 列表
+	ScopeChannelWrite = string("channel:write") // 写入 IP
+
+	ScopeTrade      = string("trade")       // 交易
+	ScopeTradeRead  = string("trade:read")  // 读取交易列表
+	ScopeTradeWrite = string("trade:write") // 写入交易
+
+	ScopeBill      = string("bill")       // 账单
+	ScopeBillRead  = string("bill:read")  // 读取账单列表
+	ScopeBillWrite = string("bill:write") // 写入账单
+)

web/error.go

@@ -1,11 +1,14 @@
 package web
 
 import (
+	"encoding/json"
 	"errors"
+	"fmt"
 	"log/slog"
 	"platform/web/auth"
 	"platform/web/core"
 	"reflect"
+	"time"
 
 	"github.com/gofiber/fiber/v2"
 )
@@ -19,6 +22,9 @@ func ErrorHandler(c *fiber.Ctx, err error) error {
 	var authErr auth.AuthErr
 	var bizErr *core.BizErr
 	var servErr *core.ServErr
+	var timeErr *time.ParseError
+	var jsonErr *json.UnmarshalTypeError
+	var jsonSyntaxErr *json.SyntaxError
 
 	switch {
 
@@ -48,11 +54,32 @@ func ErrorHandler(c *fiber.Ctx, err error) error {
 		code = fiber.StatusInternalServerError
 		message = err.Error()
 
+	case errors.As(err, &timeErr):
+		code = fiber.StatusBadRequest
+		message = fmt.Sprintf("时间格式不正确，传入值为 %s，检查传参是否为时间类型", timeErr.Value)
+
+	case errors.As(err, &jsonErr):
+		code = fiber.StatusBadRequest
+		message = fmt.Sprintf("参数 %s 类型不正确，传入类型为 %s，正确类型应该为 %s", jsonErr.Field, jsonErr.Value, jsonErr.Type.Name())
+
+	case errors.As(err, &jsonSyntaxErr):
+		code = fiber.StatusBadRequest
+		message = "参数格式不正确，检查传参是否为 JSON 格式"
+
 	// 所有未手动声明的错误类型
 	default:
-		slog.Warn("未处理的异常", slog.String("type", reflect.TypeOf(err).Name()), slog.String("error", err.Error()))
+		t := reflect.TypeOf(err)
+		for {
+			if t.Kind() == reflect.Pointer {
+				t = t.Elem()
+				continue
+			}
+			break
+		}
+		slog.Warn("未处理的异常", slog.String("type", t.String()), slog.String("error", err.Error()))
 	}
 
+	slog.Warn(message)
 	c.Set(fiber.HeaderContentType, fiber.MIMETextPlainCharsetUTF8)
 	return c.Status(code).SendString(message)
 }

web/events/channel.go

@@ -1,24 +1,11 @@
 package events
 
 import (
-	"encoding/json"
-	"log/slog"
-
 	"github.com/hibiken/asynq"
 )
 
 const RemoveChannel = "channel:remove"
 
-type RemoveChannelData struct {
-	Batch string  `json:"batch"`
-	IDs   []int32 `json:"ids"`
-}
-
-func NewRemoveChannel(data RemoveChannelData) *asynq.Task {
-	bytes, err := json.Marshal(data)
-	if err != nil {
-		slog.Error("序列化删除通道任务失败", "error", err)
-		return nil
-	}
-	return asynq.NewTask(RemoveChannel, bytes)
+func NewRemoveChannel(batch string) *asynq.Task {
+	return asynq.NewTask(RemoveChannel, []byte(batch))
 }

web/events/trade.go

@@ -9,18 +9,23 @@ import (
 	"github.com/hibiken/asynq"
 )
 
-const CompleteTrade = "trade:update"
+const CloseTrade = "trade:update"
 
-type CompleteTradeData struct {
+type CloseTradeData struct {
+	UserId  int32         `json:"user_id" validate:"required"`
 	TradeNo string        `json:"trade_no" validate:"required"`
 	Method  m.TradeMethod `json:"method" validate:"required"`
 }
 
-func NewCancelTrade(data CompleteTradeData) *asynq.Task {
-	bytes, err := json.Marshal(data)
+func NewCloseTradeTask(uid int32, tradeNo string, method m.TradeMethod) *asynq.Task {
+	bytes, err := json.Marshal(CloseTradeData{
+		UserId:  uid,
+		TradeNo: tradeNo,
+		Method:  method,
+	})
 	if err != nil {
 		slog.Error("序列化更新交易任务失败", "error", err)
 		return nil
 	}
-	return asynq.NewTask(CompleteTrade, bytes)
+	return asynq.NewTask(CloseTrade, bytes)
 }

web/globals/baiyin.go

@@ -10,6 +10,7 @@ import (
 	"net/http/httputil"
 	"net/url"
 	"platform/pkg/env"
+	"platform/web/core"
 	"strconv"
 	"strings"
 	"time"
@@ -17,18 +18,12 @@ import (
 
 // CloudClient 定义云服务接口
 type CloudClient interface {
-	CloudEdges(param CloudEdgesReq) (*CloudEdgesResp, error)
-	CloudConnect(param CloudConnectReq) error
-	CloudDisconnect(param CloudDisconnectReq) (int, error)
+	CloudEdges(param *CloudEdgesReq) (*CloudEdgesResp, error)
+	CloudConnect(param *CloudConnectReq) error
+	CloudDisconnect(param *CloudDisconnectReq) (int, error)
 	CloudAutoQuery() (CloudConnectResp, error)
 }
 
-// GatewayClient 定义网关接口
-type GatewayClient interface {
-	GatewayPortConfigs(params []PortConfigsReq) error
-	GatewayPortActive(param ...PortActiveReq) (map[string]PortData, error)
-}
-
 type cloud struct {
 	url string
 }
@@ -37,59 +32,14 @@ var Cloud CloudClient
 
 func initBaiyin() error {
 	Cloud = &cloud{
-		url: env.BaiyinAddr,
+		url: env.BaiyinCloudUrl,
 	}
 	return nil
 }
 
-type AutoConfig struct {
-	Province string `json:"province"`
-	City     string `json:"city"`
-	Isp      string `json:"isp"`
-	Count    int    `json:"count"`
-}
-
-// region cloud:/edges
-
-type CloudEdgesReq struct {
-	Province string
-	City     string
-	Isp      string
-	Offset   int
-	Limit    int
-}
-
-type CloudEdgesResp struct {
-	Edges  []Edge `json:"edges"`
-	Total  int    `json:"total"`
-	Offset int    `json:"offset"`
-	Limit  int    `json:"limit"`
-}
-
-type Edge struct {
-	EdgesId    int    `json:"edges_id"`
-	Province   string `json:"province"`
-	City       string `json:"city"`
-	Isp        string `json:"isp"`
-	Ip         string `json:"ip"`
-	Rtt        int    `json:"rtt"`
-	PacketLoss int    `json:"packet_loss"`
-}
-
-func (c *cloud) CloudEdges(param CloudEdgesReq) (*CloudEdgesResp, error) {
-	data := strings.Builder{}
-	data.WriteString("province=")
-	data.WriteString(param.Province)
-	data.WriteString("&city=")
-	data.WriteString(param.City)
-	data.WriteString("&isp=")
-	data.WriteString(param.Isp)
-	data.WriteString("&offset=")
-	data.WriteString(strconv.Itoa(param.Offset))
-	data.WriteString("&limit=")
-	data.WriteString(strconv.Itoa(param.Limit))
-
-	resp, err := c.requestCloud("GET", "/edges?"+data.String(), "")
+// cloud:/edges 筛选查询边缘节点
+func (c *cloud) CloudEdges(param *CloudEdgesReq) (*CloudEdgesResp, error) {
+	resp, err := c.requestCloud("GET", "/edges?"+core.Query(param).Encode(), "")
 	if err != nil {
 		return nil, err
 	}
@@ -115,17 +65,46 @@ func (c *cloud) CloudEdges(param CloudEdgesReq) (*CloudEdgesResp, error) {
 	return &result, nil
 }
 
-// endregion
-
-// region cloud:/connect
-
-type CloudConnectReq struct {
-	Uuid       string       `json:"uuid"`
-	Edge       []string     `json:"edge,omitempty"`
-	AutoConfig []AutoConfig `json:"auto_config,omitempty"`
+type CloudEdgesReq struct {
+	Province        *string `query:"province"`
+	City            *string `query:"city"`
+	Isp             *string `query:"isp"`
+	Offset          *int    `query:"offset"`
+	Limit           *int    `query:"limit"`
+	NoRepeat        *bool   `query:"norepeat,b2i"`
+	NoDayRepeat     *bool   `query:"nodayrepeat,b2i"`
+	IpUnchangedTime *int    `query:"ip_unchanged_time"` // 单位秒
+	ActiveTime      *int    `query:"active_time"`       // 单位秒
+	// 排序方式，可选值：
+	//   - create_time_asc 设备创建时间顺序
+	//   - create_time_desc 设备创建时间倒序
+	//   - ip_unchanged_time_asc ip持续没变化时间顺序
+	//   - ip_unchanged_time_desc ip持续没变化时间倒序
+	//   - active_time_asc 连续活跃时间顺序
+	//   - active_time_desc 连续活跃时间倒序
+	//   - rand 随机排序 (默认)
+	Sort *string `query:"sort"`
 }
 
-func (c *cloud) CloudConnect(param CloudConnectReq) error {
+type CloudEdgesResp struct {
+	Edges  []Edge `json:"edges"`
+	Total  int    `json:"total"`
+	Offset int    `json:"offset"`
+	Limit  int    `json:"limit"`
+}
+
+type Edge struct {
+	EdgeID     string `json:"edge_id"`
+	Province   string `json:"province"`
+	City       string `json:"city"`
+	Isp        string `json:"isp"`
+	Ip         string `json:"ip"`
+	Rtt        int    `json:"rtt"`
+	PacketLoss int    `json:"packet_loss"`
+}
+
+// cloud:/connect 连接边缘节点到网关
+func (c *cloud) CloudConnect(param *CloudConnectReq) error {
 	data, err := json.Marshal(param)
 	if err != nil {
 		return err
@@ -162,25 +141,21 @@ func (c *cloud) CloudConnect(param CloudConnectReq) error {
 	return nil
 }
 
-// endregion
-
-// region cloud:/disconnect
-
-type CloudDisconnectReq struct {
-	Uuid   string   `json:"uuid"`
-	Edge   []string `json:"edge,omitempty"`
-	Config []Config `json:"auto_config,omitempty"`
+type CloudConnectReq struct {
+	Uuid       string        `json:"uuid"`
+	Edge       *[]string     `json:"edge,omitempty"`
+	AutoConfig *[]AutoConfig `json:"auto_config,omitempty"`
 }
 
-type Config struct {
+type AutoConfig struct {
 	Province string `json:"province"`
 	City     string `json:"city"`
 	Isp      string `json:"isp"`
 	Count    int    `json:"count"`
-	Online   bool   `json:"online"`
 }
 
-func (c *cloud) CloudDisconnect(param CloudDisconnectReq) (int, error) {
+// cloud:/disconnect 解除连接边缘节点到网关
+func (c *cloud) CloudDisconnect(param *CloudDisconnectReq) (int, error) {
 	data, err := json.Marshal(param)
 	if err != nil {
 		return 0, err
@@ -217,12 +192,21 @@ func (c *cloud) CloudDisconnect(param CloudDisconnectReq) (int, error) {
 	return int(result["disconnected_edges"].(float64)), nil
 }
 
-// endregion
+type CloudDisconnectReq struct {
+	Uuid   string    `json:"uuid"`
+	Edge   *[]string `json:"edge,omitempty"`
+	Config *[]Config `json:"auto_config,omitempty"`
+}
 
-// region cloud:/auto_query
-
-type CloudConnectResp map[string][]AutoConfig
+type Config struct {
+	Province string `json:"province"`
+	City     string `json:"city"`
+	Isp      string `json:"isp"`
+	Count    int    `json:"count"`
+	Online   bool   `json:"online"`
+}
 
+// cloud:/auto_query 自动连接配置查询
 func (c *cloud) CloudAutoQuery() (CloudConnectResp, error) {
 	resp, err := c.requestCloud("GET", "/auto_query", "")
 	if err != nil {
@@ -250,7 +234,7 @@ func (c *cloud) CloudAutoQuery() (CloudConnectResp, error) {
 	return result, nil
 }
 
-// endregion
+type CloudConnectResp map[string][]AutoConfig
 
 func (c *cloud) requestCloud(method string, url string, data string) (*http.Response, error) {
 
@@ -263,7 +247,7 @@ func (c *cloud) requestCloud(method string, url string, data string) (*http.Resp
 	req.Header.Set("Content-Type", "application/json")
 
 	var resp *http.Response
-	for i := 0; i < 2; i++ {
+	for i := range 2 {
 		token, err := c.token(i == 1)
 		if err != nil {
 			return nil, err
@@ -304,7 +288,7 @@ func (c *cloud) requestCloud(method string, url string, data string) (*http.Resp
 func (c *cloud) token(refresh bool) (string, error) {
 	// redis 获取令牌
 	if !refresh {
-		token, err := Redis.Get(context.Background(), "remote:token").Result()
+		token, err := Redis.Get(context.Background(), BaiyinToken).Result()
 		if err == nil && token != "" {
 			return token, nil
 		}
@@ -338,7 +322,7 @@ func (c *cloud) token(refresh bool) (string, error) {
 	var result map[string]any
 	err = json.Unmarshal(body, &result)
 	if err != nil {
-		return "", err
+		return "", fmt.Errorf("解析响应 [%s] 失败: %w", string(body), err)
 	}
 
 	if result["code"].(float64) != 1 {
@@ -347,7 +331,7 @@ func (c *cloud) token(refresh bool) (string, error) {
 
 	// redis 设置令牌
 	token := result["token"].(string)
-	err = Redis.Set(context.Background(), "remote:token", token, 1*time.Hour).Err()
+	err = Redis.Set(context.Background(), BaiyinToken, token, 1*time.Hour).Err()
 	if err != nil {
 		return "", err
 	}
@@ -355,6 +339,15 @@ func (c *cloud) token(refresh bool) (string, error) {
 	return token, nil
 }
 
+const BaiyinToken = "clients:baiyin:token"
+
+// GatewayClient 定义网关接口
+type GatewayClient interface {
+	GatewayPortConfigs(params []*PortConfigsReq) error
+	GatewayPortActive(param ...*PortActiveReq) (map[string]PortData, error)
+	GatewayEdge(params *GatewayEdgeReq) (map[string]GatewayEdgeInfo, error)
+}
+
 type gateway struct {
 	url      string
 	username string
@@ -373,6 +366,68 @@ func NewGateway(url, username, password string) GatewayClient {
 	return GatewayInitializer(url, username, password)
 }
 
+type GatewayEdgeReq struct {
+	EdgeID               *string `query:"edge_id"`
+	Province             *string `query:"province"`
+	City                 *string `query:"city"`
+	Isp                  *string `query:"isp"`
+	Connected            *bool   `query:"connected"`
+	Assigned             *bool   `query:"assigned"`
+	GetRand              *int    `query:"getRand"`
+	IpUnchangedTimeStart *int    `query:"ip_unchanged_time_start"`
+	IpUnchangedTimeEnd   *int    `query:"ip_unchanged_time_end"`
+	OnlineTimeStart      *int    `query:"online_time_start"`
+	OnlineTimeEnd        *int    `query:"online_time_end"`
+	Rtt                  *int    `query:"rtt"`
+	MinRtt               *int    `query:"min_rtt"`
+	RttBaidu             *int    `query:"rtt_baidu"`
+	PacketLoss           *int    `query:"packet_loss"`
+	PacketLossBaidu      *int    `query:"packet_loss_baidu"`
+	IP                   *string `query:"ip"`
+	Limit                *int    `query:"limit"`
+	Offset               *int    `query:"offset"`
+}
+
+type GatewayEdgeResp struct {
+	Code  int                        `json:"code"`
+	Msg   string                     `json:"msg"`
+	Data  map[string]GatewayEdgeInfo `json:"data"`
+	Total int                        `json:"total"`
+}
+
+type GatewayEdgeInfo struct {
+	IP              string `json:"ip"`
+	Connected       bool   `json:"connected"`
+	Assigned        bool   `json:"assigned"`
+	AssignedTo      string `json:"assignedto"`
+	PacketLoss      int    `json:"packet_loss"`
+	PacketLossBaidu int    `json:"packet_loss_baidu"`
+	Rtt             int    `json:"rtt"`
+	RttBaidu        int    `json:"rtt_baidu"`
+	OfflineTime     int    `json:"offline_time"`
+	OnlineTime      int    `json:"online_time"`
+	IpUnchangedTime int    `json:"ip_unchanged_time"`
+}
+
+func (c *gateway) GatewayEdge(req *GatewayEdgeReq) (map[string]GatewayEdgeInfo, error) {
+	resp, err := c.get("/edge", core.Query(req))
+	if err != nil {
+		return nil, fmt.Errorf("查询可用节点失败:%w", err)
+	}
+	defer resp.Body.Close()
+
+	body := new(GatewayEdgeResp)
+	if err = json.NewDecoder(resp.Body).Decode(body); err != nil {
+		return nil, fmt.Errorf("解析响应内容失败:%w", err)
+	}
+
+	if body.Code != 0 {
+		return nil, fmt.Errorf("接口业务响应异常: %d %s", body.Code, body.Msg)
+	}
+
+	return body.Data, nil
+}
+
 // region gateway:/port/configs
 
 type PortConfigsReq struct {
@@ -395,7 +450,7 @@ type AutoEdgeConfig struct {
 	PacketLoss int    `json:"packet_loss,omitempty"`
 }
 
-func (c *gateway) GatewayPortConfigs(params []PortConfigsReq) error {
+func (c *gateway) GatewayPortConfigs(params []*PortConfigsReq) error {
 	if len(params) == 0 {
 		return errors.New("params is empty")
 	}
@@ -461,10 +516,10 @@ type PortData struct {
 	Userpass  string   `json:"userpass"`
 }
 
-func (c *gateway) GatewayPortActive(param ...PortActiveReq) (map[string]PortData, error) {
+func (c *gateway) GatewayPortActive(param ...*PortActiveReq) (map[string]PortData, error) {
 	_param := PortActiveReq{}
-	if len(param) != 0 {
-		_param = param[0]
+	if len(param) != 0 && param[0] != nil {
+		_param = *param[0]
 	}
 
 	path := strings.Builder{}
@@ -520,38 +575,33 @@ func (c *gateway) GatewayPortActive(param ...PortActiveReq) (map[string]PortData
 
 // endregion
 
+func (c *gateway) get(url string, params url.Values) (*http.Response, error) {
+	url = fmt.Sprintf("http://%s:%s@%s:9990%s?%s", c.username, c.password, c.url, url, params.Encode())
+	req, err := http.NewRequest(http.MethodGet, url, nil)
+	if err != nil {
+		return nil, fmt.Errorf("创建请求失败:%w", err)
+	}
+
+	res, err := core.Fetch(req)
+	if err != nil {
+		return nil, fmt.Errorf("获取数据失败:%w", err)
+	}
+
+	if res.StatusCode != http.StatusOK {
+		bytes, _ := io.ReadAll(res.Body)
+		return nil, fmt.Errorf("接口响应异常: %d %s", res.StatusCode, string(bytes))
+	}
+
+	return res, nil
+}
+
 func (c *gateway) requestGateway(method string, url string, data string) (*http.Response, error) {
-	//goland:noinspection ALL
 	url = fmt.Sprintf("http://%s:%s@%s:9990%s", c.username, c.password, c.url, url)
 	req, err := http.NewRequest(method, url, strings.NewReader(data))
 	if err != nil {
 		return nil, err
 	}
-
 	req.Header.Set("Content-Type", "application/json")
 
-	if env.DebugHttpDump {
-		str, err := httputil.DumpRequest(req, true)
-		if err != nil {
-			return nil, err
-		}
-		fmt.Println("==============================")
-		fmt.Println(string(str))
-	}
-
-	resp, err := http.DefaultClient.Do(req)
-	if err != nil {
-		return nil, err
-	}
-
-	if env.DebugHttpDump {
-		str, err := httputil.DumpResponse(resp, true)
-		if err != nil {
-			return nil, err
-		}
-		fmt.Println("------------------------------")
-		fmt.Println(string(str))
-	}
-
-	return resp, nil
+	return core.Fetch(req)
 }

web/globals/orm/timez.go

@@ -0,0 +1,30 @@
+package orm
+
+import (
+	"fmt"
+	"time"
+)
+
+type DateTime struct {
+	time.Time
+}
+
+func (dt *DateTime) Scan(value any) error {
+	switch v := value.(type) {
+	case time.Time:
+		dt.Time = v
+	case string:
+		t, err := time.Parse(time.RFC3339, v)
+		if err != nil {
+			return err
+		}
+		dt.Time = t
+	default:
+		return fmt.Errorf("unsupported type: %T", value)
+	}
+	return nil
+}
+
+func (dt DateTime) Value() (any, error) {
+	return dt.Time.Format(time.RFC3339), nil
+}

web/globals/otel.go

@@ -3,6 +3,7 @@ package globals
 import (
 	"context"
 	"fmt"
+	"platform/pkg/env"
 
 	"go.opentelemetry.io/otel"
 	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
@@ -16,8 +17,13 @@ import (
 var tp *trace.TracerProvider
 
 func initOtel(ctx context.Context) error {
+	if env.OtelHost == "" || env.OtelPort == "" {
+		return nil
+	}
+
+	addr := env.OtelHost + ":" + env.OtelPort
 	exporter, err := otlptracegrpc.New(ctx,
-		otlptracegrpc.WithEndpoint("localhost:4317"),
+		otlptracegrpc.WithEndpoint(addr),
 		otlptracegrpc.WithInsecure(),
 	)
 	if err != nil {

web/globals/wechatpay.go

@@ -10,6 +10,7 @@ import (
 	"github.com/wechatpay-apiv3/wechatpay-go/core/auth/verifiers"
 	"github.com/wechatpay-apiv3/wechatpay-go/core/notify"
 	"github.com/wechatpay-apiv3/wechatpay-go/core/option"
+	"github.com/wechatpay-apiv3/wechatpay-go/services/partnerpayments/h5"
 	"github.com/wechatpay-apiv3/wechatpay-go/services/payments/native"
 	"github.com/wechatpay-apiv3/wechatpay-go/utils"
 )
@@ -18,6 +19,7 @@ var WechatPay *WechatPayClient
 
 type WechatPayClient struct {
 	Native *native.NativeApiService
+	H5     *h5.H5ApiService
 	Notify *notify.Handler
 }
 
@@ -71,6 +73,7 @@ func initWechatPay() error {
 	// 创建 WechatPay 服务
 	WechatPay = &WechatPayClient{
 		Native: &native.NativeApiService{Client: client},
+		H5:     &h5.H5ApiService{Client: client},
 		Notify: handler,
 	}
 	return nil

web/handlers/admin.go

@@ -0,0 +1,106 @@
+package handlers
+
+import (
+	"platform/web/auth"
+	"platform/web/core"
+	g "platform/web/globals"
+	s "platform/web/services"
+
+	"github.com/gofiber/fiber/v2"
+)
+
+func PageAdminByAdmin(c *fiber.Ctx) error {
+	_, err := auth.GetAuthCtx(c).PermitAdmin(core.ScopeAdminRead)
+	if err != nil {
+		return err
+	}
+
+	var req PageAdminsReq
+	if err := g.Validator.ParseBody(c, &req); err != nil {
+		return err
+	}
+
+	list, total, err := s.Admin.PageAdmins(req.PageReq)
+	if err != nil {
+		return err
+	}
+
+	return c.JSON(core.PageResp{
+		List:  list,
+		Total: int(total),
+		Page:  req.GetPage(),
+		Size:  req.GetSize(),
+	})
+}
+
+type PageAdminsReq struct {
+	core.PageReq
+}
+
+func AllAdminByAdmin(c *fiber.Ctx) error {
+	_, err := auth.GetAuthCtx(c).PermitAdmin(core.ScopeAdminRead)
+	if err != nil {
+		return err
+	}
+
+	list, err := s.Admin.All()
+	if err != nil {
+		return err
+	}
+
+	return c.JSON(list)
+}
+
+func CreateAdmin(c *fiber.Ctx) error {
+	_, err := auth.GetAuthCtx(c).PermitAdmin(core.ScopeAdminWrite)
+	if err != nil {
+		return err
+	}
+
+	var req s.CreateAdmin
+	if err := g.Validator.ParseBody(c, &req); err != nil {
+		return err
+	}
+
+	if err := s.Admin.CreateAdmin(&req); err != nil {
+		return err
+	}
+
+	return c.JSON(nil)
+}
+
+func UpdateAdmin(c *fiber.Ctx) error {
+	_, err := auth.GetAuthCtx(c).PermitAdmin(core.ScopeAdminWrite)
+	if err != nil {
+		return err
+	}
+
+	var req s.UpdateAdmin
+	if err := g.Validator.ParseBody(c, &req); err != nil {
+		return err
+	}
+
+	if err := s.Admin.UpdateAdmin(&req); err != nil {
+		return err
+	}
+
+	return c.JSON(nil)
+}
+
+func RemoveAdmin(c *fiber.Ctx) error {
+	_, err := auth.GetAuthCtx(c).PermitAdmin(core.ScopeAdminWrite)
+	if err != nil {
+		return err
+	}
+
+	var req core.IdReq
+	if err := g.Validator.ParseBody(c, &req); err != nil {
+		return err
+	}
+
+	if err := s.Admin.RemoveAdmin(req.Id); err != nil {
+		return err
+	}
+
+	return c.JSON(nil)
+}

web/handlers/admin_role.go

@@ -0,0 +1,103 @@
+package handlers
+
+import (
+	"platform/web/auth"
+	"platform/web/core"
+	g "platform/web/globals"
+	s "platform/web/services"
+
+	"github.com/gofiber/fiber/v2"
+)
+
+func AllAdminRoleByAdmin(c *fiber.Ctx) error {
+	_, err := auth.GetAuthCtx(c).PermitAdmin(core.ScopeAdminRoleRead)
+	if err != nil {
+		return err
+	}
+
+	list, err := s.AdminRole.ListRoles()
+	if err != nil {
+		return err
+	}
+
+	return c.JSON(list)
+}
+
+func PageAdminRoleByAdmin(c *fiber.Ctx) error {
+	_, err := auth.GetAuthCtx(c).PermitAdmin(core.ScopeAdminRoleRead)
+	if err != nil {
+		return err
+	}
+
+	var req PageAdminRolesReq
+	if err := g.Validator.ParseBody(c, &req); err != nil {
+		return err
+	}
+
+	list, total, err := s.AdminRole.PageRoles(req.PageReq)
+
+	return c.JSON(core.PageResp{
+		List:  list,
+		Total: int(total),
+		Page:  req.GetPage(),
+		Size:  req.GetSize(),
+	})
+}
+
+type PageAdminRolesReq struct {
+	core.PageReq
+}
+
+func CreateAdminRole(c *fiber.Ctx) error {
+	_, err := auth.GetAuthCtx(c).PermitAdmin(core.ScopeAdminRoleWrite)
+	if err != nil {
+		return err
+	}
+
+	var req s.CreateAdminRole
+	if err := g.Validator.ParseBody(c, &req); err != nil {
+		return err
+	}
+
+	if err := s.AdminRole.CreateAdminRole(&req); err != nil {
+		return err
+	}
+
+	return c.JSON(nil)
+}
+
+func UpdateAdminRole(c *fiber.Ctx) error {
+	_, err := auth.GetAuthCtx(c).PermitAdmin(core.ScopeAdminRoleWrite)
+	if err != nil {
+		return err
+	}
+
+	var req s.UpdateAdminRole
+	if err := g.Validator.ParseBody(c, &req); err != nil {
+		return err
+	}
+
+	if err := s.AdminRole.UpdateAdminRole(&req); err != nil {
+		return err
+	}
+
+	return c.JSON(nil)
+}
+
+func RemoveAdminRole(c *fiber.Ctx) error {
+	_, err := auth.GetAuthCtx(c).PermitAdmin(core.ScopeAdminRoleWrite)
+	if err != nil {
+		return err
+	}
+
+	var req core.IdReq
+	if err := g.Validator.ParseBody(c, &req); err != nil {
+		return err
+	}
+
+	if err := s.AdminRole.RemoveAdminRole(req.Id); err != nil {
+		return err
+	}
+
+	return c.JSON(nil)
+}

web/handlers/auth.go

@@ -1,97 +0,0 @@
-package handlers
-
-import (
-	"platform/pkg/u"
-	auth2 "platform/web/auth"
-	m "platform/web/models"
-	q "platform/web/queries"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-// region /revoke
-
-type RevokeReq struct {
-	AccessToken  string `json:"access_token"`
-	RefreshToken string `json:"refresh_token"`
-}
-
-func Revoke(c *fiber.Ctx) error {
-	_, err := auth2.GetAuthCtx(c).PermitUser()
-	if err != nil {
-		// 用户未登录
-		return nil
-	}
-
-	// 解析请求参数
-	req := new(RevokeReq)
-	if err := c.BodyParser(req); err != nil {
-		return err
-	}
-
-	// 删除会话
-	err = auth2.RemoveSession(c.Context(), req.AccessToken, req.RefreshToken)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-// endregion
-
-// region /profile
-
-type IntrospectResp struct {
-	m.User
-	HasPassword bool `json:"has_password"` // 是否设置了密码
-}
-
-func Introspect(c *fiber.Ctx) error {
-	// 验证权限
-	authCtx, err := auth2.GetAuthCtx(c).PermitUser()
-	if err != nil {
-		return err
-	}
-
-	// 获取用户信息
-	profile, err := q.User.
-		Where(q.User.ID.Eq(authCtx.User.ID)).
-		Omit(q.User.DeletedAt).
-		Take()
-	if err != nil {
-		return err
-	}
-
-	// 检查用户是否设置了密码
-	hasPassword := false
-	if profile.Password != nil && *profile.Password != "" {
-		hasPassword = true
-		profile.Password = nil // 不返回密码
-	}
-
-	// 掩码敏感信息
-	if profile.Phone != "" {
-		profile.Phone = maskPhone(profile.Phone)
-	}
-	if profile.IDNo != nil && *profile.IDNo != "" {
-		profile.IDNo = u.P(maskIdNo(*profile.IDNo))
-	}
-	return c.JSON(IntrospectResp{*profile, hasPassword})
-}
-
-func maskPhone(phone string) string {
-	if len(phone) < 11 {
-		return phone
-	}
-	return phone[:3] + "****" + phone[7:]
-}
-
-func maskIdNo(idNo string) string {
-	if len(idNo) < 18 {
-		return idNo
-	}
-	return idNo[:3] + "*********" + idNo[14:]
-}
-
-// endregion

web/handlers/batch.go

@@ -0,0 +1,130 @@
+package handlers
+
+import (
+	"platform/pkg/u"
+	"platform/web/auth"
+	"platform/web/core"
+	c "platform/web/core"
+	g "platform/web/globals"
+	q "platform/web/queries"
+	"time"
+
+	"github.com/gofiber/fiber/v2"
+)
+
+// PageBatch 分页查询套餐提取记录
+func PageBatch(ctx *fiber.Ctx) error {
+	// 检查权限
+	authCtx, err := auth.GetAuthCtx(ctx).PermitUser()
+	if err != nil {
+		return err
+	}
+
+	// 解析请求参数
+	req := new(PageResourceBatchReq)
+	if err := g.Validator.ParseBody(ctx, req); err != nil {
+		return err
+	}
+
+	// 查询批次
+	conds := q.LogsUserUsage.Where(q.LogsUserUsage.UserID.Eq(authCtx.User.ID))
+	if req.TimeStart != nil {
+		conds.Where(q.LogsUserUsage.Time.Gte(*req.TimeStart))
+	}
+	if req.TimeEnd != nil {
+		conds.Where(q.LogsUserUsage.Time.Lte(*req.TimeEnd))
+	}
+
+	list, total, err := q.LogsUserUsage.Where(conds).
+		Order(q.LogsUserUsage.Time.Desc()).
+		FindByPage(req.GetOffset(), req.GetLimit())
+	if err != nil {
+		return core.NewBizErr("获取数据失败", err)
+	}
+
+	// 返回数据
+	return ctx.JSON(c.PageResp{
+		Total: int(total),
+		List:  list,
+		Page:  req.GetPage(),
+		Size:  req.GetSize(),
+	})
+}
+
+type PageResourceBatchReq struct {
+	c.PageReq
+	TimeStart *time.Time `json:"time_start"`
+	TimeEnd   *time.Time `json:"time_end"`
+}
+
+// PageBatchByAdmin 分页查询所有提取记录
+func PageBatchByAdmin(c *fiber.Ctx) error {
+	_, err := auth.GetAuthCtx(c).PermitAdmin(core.ScopeBatchRead)
+	if err != nil {
+		return err
+	}
+
+	var req PageBatchByAdminReq
+	if err = g.Validator.ParseBody(c, &req); err != nil {
+		return err
+	}
+
+	do := q.LogsUserUsage.Where()
+	if req.UserPhone != nil {
+		do = do.Where(q.User.Phone.Eq(*req.UserPhone))
+	}
+	if req.ResourceNo != nil {
+		do = do.Where(q.Resource.ResourceNo.Eq(*req.ResourceNo))
+	}
+	if req.BatchNo != nil {
+		do = do.Where(q.LogsUserUsage.BatchNo.Eq(*req.BatchNo))
+	}
+	if req.Prov != nil {
+		do = do.Where(q.LogsUserUsage.Prov.Eq(*req.Prov))
+	}
+	if req.City != nil {
+		do = do.Where(q.LogsUserUsage.City.Eq(*req.City))
+	}
+	if req.Isp != nil {
+		do = do.Where(q.LogsUserUsage.ISP.Eq(*req.Isp))
+	}
+	if req.CreatedAtStart != nil {
+		time := u.DateHead(*req.CreatedAtStart)
+		do = do.Where(q.LogsUserUsage.Time.Gte(time))
+	}
+	if req.CreatedAtEnd != nil {
+		time := u.DateTail(*req.CreatedAtEnd)
+		do = do.Where(q.LogsUserUsage.Time.Lte(time))
+	}
+
+	list, total, err := q.LogsUserUsage.
+		Joins(q.LogsUserUsage.User, q.LogsUserUsage.Resource).
+		Select(
+			q.LogsUserUsage.ALL,
+			q.User.As("User").Phone.As("User__phone"),
+			q.User.As("User").Name.As("User__name"),
+			q.Resource.As("Resource").ResourceNo.As("Resource__resource_no"),
+		).
+		Where(do).
+		Order(q.LogsUserUsage.Time.Desc()).
+		FindByPage(req.GetOffset(), req.GetLimit())
+
+	return c.JSON(core.PageResp{
+		List:  list,
+		Total: int(total),
+		Page:  req.GetPage(),
+		Size:  req.GetSize(),
+	})
+}
+
+type PageBatchByAdminReq struct {
+	c.PageReq
+	UserPhone      *string    `json:"user_phone"`
+	ResourceNo     *string    `json:"resource_no"`
+	BatchNo        *string    `json:"batch_no"`
+	Prov           *string    `json:"prov"`
+	City           *string    `json:"city"`
+	Isp            *string    `json:"isp"`
+	CreatedAtStart *time.Time `json:"created_at_start"`
+	CreatedAtEnd   *time.Time `json:"created_at_end"`
+}

web/handlers/bill.go

@@ -1,22 +1,104 @@
 package handlers
 
 import (
+	"platform/pkg/u"
 	"platform/web/auth"
 	"platform/web/core"
+	g "platform/web/globals"
 	q "platform/web/queries"
 	"time"
 
 	"github.com/gofiber/fiber/v2"
 )
 
-// region ListBill
+// PageBillByAdmin 分页查询全部账单
+func PageBillByAdmin(c *fiber.Ctx) error {
+	// 检查权限
+	_, err := auth.GetAuthCtx(c).PermitAdmin(core.ScopeBillRead)
+	if err != nil {
+		return err
+	}
 
-type ListBillReq struct {
+	// 解析请求参数
+	req := new(PageBillByAdminReq)
+	if err := g.Validator.ParseBody(c, req); err != nil {
+		return err
+	}
+
+	// 构造查询条件
+	do := q.Bill.Where()
+	if req.UserPhone != nil {
+		do = do.Where(q.User.As("User").Phone.Eq(*req.UserPhone))
+	}
+	if req.TradeInnerNo != nil {
+		do = do.Where(q.Trade.As("Trade").InnerNo.Eq(*req.TradeInnerNo))
+	}
+	if req.ResourceNo != nil {
+		do = do.Where(q.Resource.As("Resource").ResourceNo.Eq(*req.ResourceNo))
+	}
+	if req.BillNo != nil {
+		do = do.Where(q.Bill.BillNo.Eq(*req.BillNo))
+	}
+	if req.CreatedAtStart != nil {
+		time := u.DateHead(*req.CreatedAtStart)
+		do = do.Where(q.Bill.CreatedAt.Gte(time))
+	}
+	if req.CreatedAtEnd != nil {
+		time := u.DateHead(*req.CreatedAtEnd)
+		do = do.Where(q.Bill.CreatedAt.Lte(time))
+	}
+	if req.ProductCode != nil {
+		do = do.Where(q.Resource.As("Resource").Code.Eq(*req.ProductCode))
+	}
+	if req.SkuCode != nil {
+		do = do.Where(q.Bill.
+			Where(q.ResourceShort.As("Resource__Short").Code.Eq(*req.SkuCode)).
+			Or(q.ResourceLong.As("Resource__Long").Code.Eq(*req.SkuCode)))
+	}
+
+	// 查询用户列表
+	list, total, err := q.Bill.
+		Joins(
+			q.Bill.User,
+			q.Bill.Resource,
+			q.Bill.Trade,
+			q.Bill.Resource.Short,
+			q.Bill.Resource.Long,
+		).
+		Select(
+			q.Bill.ALL,
+			q.User.As("User").Phone.As("User__phone"),
+			q.User.As("User").Name.As("User__name"),
+			q.Trade.As("Trade").InnerNo.As("Trade__inner_no"),
+			q.Trade.As("Trade").Acquirer.As("Trade__acquirer"),
+			q.Resource.As("Resource").ResourceNo.As("Resource__resource_no"),
+		).
+		Where(do).
+		Order(q.Bill.CreatedAt.Desc()).
+		FindByPage(req.GetOffset(), req.GetLimit())
+	if err != nil {
+		return err
+	}
+
+	// 返回结果
+	return c.JSON(core.PageResp{
+		List:  list,
+		Total: int(total),
+		Page:  req.GetPage(),
+		Size:  req.GetSize(),
+	})
+}
+
+type PageBillByAdminReq struct {
 	core.PageReq
-	BillNo       *string    `json:"bill_no"`
-	Type         *int       `json:"type"`
-	CreateAfter  *time.Time `json:"create_after"`
-	CreateBefore *time.Time `json:"create_before"`
+	UserPhone      *string    `json:"user_phone,omitempty"`
+	TradeInnerNo   *string    `json:"trade_inner_no,omitempty"`
+	ResourceNo     *string    `json:"resource_no,omitempty"`
+	BillNo         *string    `json:"bill_no,omitempty"`
+	CreatedAtStart *time.Time `json:"created_at_start,omitempty"`
+	CreatedAtEnd   *time.Time `json:"created_at_end,omitempty"`
+	ProductCode    *string    `json:"product_code,omitempty"`
+	SkuCode        *string    `json:"sku_code,omitempty"`
 }
 
 // ListBill 获取账单列表
@@ -79,4 +161,10 @@ func ListBill(c *fiber.Ctx) error {
 	})
 }
 
-// endregion
+type ListBillReq struct {
+	core.PageReq
+	BillNo       *string    `json:"bill_no"`
+	Type         *int       `json:"type"`
+	CreateAfter  *time.Time `json:"create_after"`
+	CreateBefore *time.Time `json:"create_before"`
+}

web/handlers/channel.go

@@ -6,6 +6,7 @@ import (
 	"platform/web/auth"
 	"platform/web/core"
 	g "platform/web/globals"
+	"platform/web/globals/orm"
 	m "platform/web/models"
 	q "platform/web/queries"
 	s "platform/web/services"
@@ -14,16 +15,92 @@ import (
 	"github.com/gofiber/fiber/v2"
 )
 
-// region ListChannels
+// PageChannelByAdmin 分页查询所有通道
+func PageChannelByAdmin(c *fiber.Ctx) error {
+	// 检查权限
+	_, err := auth.GetAuthCtx(c).PermitAdmin(core.ScopeChannelRead)
+	if err != nil {
+		return err
+	}
 
-type ListChannelsReq struct {
-	core.PageReq
-	AuthType     s.ChannelAuthType `json:"auth_type"`
-	ExpireAfter  *time.Time        `json:"expire_after"`
-	ExpireBefore *time.Time        `json:"expire_before"`
+	// 解析请求参数
+	var req PageChannelsByAdminReq
+	if err := g.Validator.ParseBody(c, &req); err != nil {
+		return err
+	}
+
+	// 构建查询条件
+	do := q.Channel.Where()
+	if req.UserPhone != nil {
+		do = do.Where(q.User.As("User").Phone.Eq(*req.UserPhone))
+	}
+	if req.ResourceNo != nil {
+		do = do.Where(q.Resource.As("Resource").ResourceNo.Eq(*req.ResourceNo))
+	}
+	if req.BatchNo != nil {
+		do = do.Where(q.Channel.BatchNo.Eq(*req.BatchNo))
+	}
+	if req.ProxyHost != nil {
+		do = do.Where(q.Channel.Host.Eq(*req.ProxyHost))
+	}
+	if req.ProxyPort != nil {
+		do = do.Where(q.Channel.Port.Eq(*req.ProxyPort))
+	}
+	if req.NodeIP != nil {
+		ip, err := orm.ParseInet(*req.NodeIP)
+		if err != nil {
+			return core.NewBizErr("查询参数 ip 格式不正确")
+		}
+		do = do.Where(q.Channel.IP.Eq(ip))
+	}
+	if req.ExpiredAtStart != nil {
+		time := u.DateHead(*req.ExpiredAtStart)
+		do = do.Where(q.Channel.ExpiredAt.Gte(time))
+	}
+	if req.ExpiredAtEnd != nil {
+		time := u.DateHead(*req.ExpiredAtEnd)
+		do = do.Where(q.Channel.ExpiredAt.Lte(time))
+	}
+
+	// 查询通道列表
+	list, total, err := q.Channel.
+		Joins(q.Channel.User, q.Channel.Resource).
+		Select(
+			q.Channel.ALL,
+			q.Resource.As("Resource").ResourceNo.As("Resource__resource_no"),
+			q.User.As("User").Phone.As("User__phone"),
+			q.User.As("User").Name.As("User__name"),
+		).
+		Where(do).
+		Order(q.Channel.CreatedAt.Desc()).
+		FindByPage(req.GetOffset(), req.GetLimit())
+	if err != nil {
+		return err
+	}
+
+	// 返回结果
+	return c.JSON(core.PageResp{
+		List:  list,
+		Total: int(total),
+		Page:  req.GetPage(),
+		Size:  req.GetSize(),
+	})
 }
 
-func ListChannels(c *fiber.Ctx) error {
+type PageChannelsByAdminReq struct {
+	core.PageReq
+	UserPhone      *string    `json:"user_phone"`
+	ResourceNo     *string    `json:"resource_no"`
+	BatchNo        *string    `json:"batch_no"`
+	ProxyHost      *string    `json:"proxy_host"`
+	ProxyPort      *uint16    `json:"proxy_port"`
+	NodeIP         *string    `json:"node_ip" validator:"omitempty,ip"`
+	ExpiredAtStart *time.Time `json:"expired_at_start"`
+	ExpiredAtEnd   *time.Time `json:"expired_at_end"`
+}
+
+// ListChannel 分页查询当前用户通道
+func ListChannel(c *fiber.Ctx) error {
 	// 检查权限
 	authContext, err := auth.GetAuthCtx(c).PermitUser()
 	if err != nil {
@@ -57,7 +134,6 @@ func ListChannels(c *fiber.Ctx) error {
 
 	// 查询数据
 	channels, err := q.Channel.
-		Preload(q.Channel.Proxy).
 		Where(cond).
 		Order(q.Channel.CreatedAt.Desc()).
 		Offset(req.GetOffset()).
@@ -87,9 +163,69 @@ func ListChannels(c *fiber.Ctx) error {
 	})
 }
 
-// endregion
+type ListChannelsReq struct {
+	core.PageReq
+	AuthType     s.ChannelAuthType `json:"auth_type"`
+	ExpireAfter  *time.Time        `json:"expire_after"`
+	ExpireBefore *time.Time        `json:"expire_before"`
+}
 
-// region CreateChannel
+// CreateChannel 创建新通道
+func CreateChannel(c *fiber.Ctx) error {
+
+	// 检查权限
+	_, err := auth.GetAuthCtx(c).PermitUser()
+	if err != nil {
+		return err
+	}
+
+	// 解析参数
+	req := new(CreateChannelReq)
+	if err := g.Validator.ParseBody(c, req); err != nil {
+		return core.NewBizErr("解析参数失败", err)
+	}
+
+	ip, err := netip.ParseAddr(c.IP())
+	if err != nil {
+		return core.NewBizErr("获取客户端地址失败", err)
+	}
+
+	// 创建通道
+	var isp *m.EdgeISP
+	if req.Isp != nil {
+		isp = u.X(m.ToEdgeISP(*req.Isp))
+	}
+	result, err := s.Channel.CreateChannels(
+		ip,
+		req.ResourceId,
+		req.AuthType == s.ChannelAuthTypeIp,
+		req.AuthType == s.ChannelAuthTypePass,
+		req.Count,
+		s.EdgeFilter{
+			Isp:  isp,
+			Prov: req.Prov,
+			City: req.City,
+		},
+	)
+	if err != nil {
+		return err
+	}
+
+	// 返回结果
+	var resp = make([]*CreateChannelRespItem, len(result))
+	for i, channel := range result {
+		resp[i] = &CreateChannelRespItem{
+			Proto: req.Protocol,
+			Host:  channel.Host,
+			Port:  channel.Port,
+		}
+		if req.AuthType == s.ChannelAuthTypePass {
+			resp[i].Username = channel.Username
+			resp[i].Password = channel.Password
+		}
+	}
+	return c.JSON(resp)
+}
 
 type CreateChannelReq struct {
 	ResourceId int32             `json:"resource_id" validate:"required"`
@@ -109,63 +245,7 @@ type CreateChannelRespItem struct {
 	Password *string `json:"password,omitempty"`
 }
 
-func CreateChannel(c *fiber.Ctx) error {
-
-	// 解析参数
-	req := new(CreateChannelReq)
-	if err := g.Validator.ParseBody(c, req); err != nil {
-		return core.NewBizErr("解析参数失败", err)
-	}
-
-	ip, err := netip.ParseAddr(c.IP())
-	if err != nil {
-		return core.NewBizErr("获取客户端地址失败", err)
-	}
-
-	// 创建通道
-	result, err := s.Channel.CreateChannels(
-		ip,
-		req.ResourceId,
-		req.AuthType == s.ChannelAuthTypeIp,
-		req.AuthType == s.ChannelAuthTypePass,
-		req.Count,
-		s.EdgeFilter{
-			Isp:  u.ElseTo(req.Isp, m.ToEdgeISP),
-			Prov: req.Prov,
-			City: req.City,
-		},
-	)
-	if err != nil {
-		return err
-	}
-
-	// 返回结果
-	var resp = make([]*CreateChannelRespItem, len(result))
-	for i, channel := range result {
-		resp[i] = &CreateChannelRespItem{
-			Proto: req.Protocol,
-			Host:  channel.Proxy.IP.String(),
-			Port:  channel.Port,
-		}
-		if req.AuthType == s.ChannelAuthTypePass {
-			resp[i].Username = channel.Username
-			resp[i].Password = channel.Password
-		}
-	}
-	return c.JSON(resp)
-}
-
-type CreateChannelResultType string
-
-// endregion
-
-// region RemoveChannels
-
-type RemoveChannelsReq struct {
-	Batch string  `json:"batch" validate:"required"`
-	Ids   []int32 `json:"ids" validate:"required"`
-}
-
+// RemoveChannels 删除通道
 func RemoveChannels(c *fiber.Ctx) error {
 	// 检查权限
 	_, err := auth.GetAuthCtx(c).PermitOfficialClient()
@@ -180,7 +260,7 @@ func RemoveChannels(c *fiber.Ctx) error {
 	}
 
 	// 删除通道
-	err = s.Channel.RemoveChannels(req.Batch, req.Ids)
+	err = s.Channel.RemoveChannels(req.Batch)
 	if err != nil {
 		return err
 	}
@@ -188,4 +268,6 @@ func RemoveChannels(c *fiber.Ctx) error {
 	return c.SendStatus(fiber.StatusOK)
 }
 
-// endregion
+type RemoveChannelsReq struct {
+	Batch string `json:"batch" validate:"required"`
+}

web/handlers/coupon.go

@@ -0,0 +1,105 @@
+package handlers
+
+import (
+	"platform/web/auth"
+	"platform/web/core"
+	g "platform/web/globals"
+	s "platform/web/services"
+
+	"github.com/gofiber/fiber/v2"
+)
+
+func PageCouponByAdmin(c *fiber.Ctx) error {
+	_, err := auth.GetAuthCtx(c).PermitAdmin(core.ScopeCouponRead)
+	if err != nil {
+		return err
+	}
+
+	var req core.PageReq
+	if err := g.Validator.ParseBody(c, &req); err != nil {
+		return err
+	}
+
+	list, total, err := s.Coupon.Page(&req)
+	if err != nil {
+		return err
+	}
+
+	return c.JSON(core.PageResp{
+		Total: int(total),
+		Page:  req.GetPage(),
+		Size:  req.GetSize(),
+		List:  list,
+	})
+}
+
+func AllCouponByAdmin(c *fiber.Ctx) error {
+	_, err := auth.GetAuthCtx(c).PermitAdmin(core.ScopeCouponRead)
+	if err != nil {
+		return err
+	}
+
+	list, err := s.Coupon.All()
+	if err != nil {
+		return err
+	}
+
+	return c.JSON(list)
+}
+
+func CreateCoupon(c *fiber.Ctx) error {
+	_, err := auth.GetAuthCtx(c).PermitAdmin(core.ScopeCouponWrite)
+	if err != nil {
+		return err
+	}
+
+	var req s.CreateCouponData
+	if err := g.Validator.ParseBody(c, &req); err != nil {
+		return err
+	}
+
+	err = s.Coupon.Create(req)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func UpdateCoupon(c *fiber.Ctx) error {
+	_, err := auth.GetAuthCtx(c).PermitAdmin(core.ScopeCouponWrite)
+	if err != nil {
+		return err
+	}
+
+	var req s.UpdateCouponData
+	if err := g.Validator.ParseBody(c, &req); err != nil {
+		return err
+	}
+
+	err = s.Coupon.Update(req)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DeleteCoupon(c *fiber.Ctx) error {
+	_, err := auth.GetAuthCtx(c).PermitAdmin(core.ScopeCouponWrite)
+	if err != nil {
+		return err
+	}
+
+	var req core.IdReq
+	if err := g.Validator.ParseBody(c, &req); err != nil {
+		return err
+	}
+
+	err = s.Coupon.Delete(req.Id)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

web/handlers/iden.go

@@ -18,19 +18,7 @@ import (
 	jdclient "github.com/jdcloud-api/jdcloud-sdk-go/services/cloudauth/client"
 )
 
-// region Identify
-
-type IdentifyReq struct {
-	Type   int    `json:"type" validate:"required,oneof=1 2"`
-	Name   string `json:"name" validate:"required"`
-	IdenNo string `json:"iden_no" validate:"required"`
-}
-
-type IdentifyRes struct {
-	Identified bool   `json:"identified"`
-	Target     string `json:"target"`
-}
-
+// Identify 发起实名认证
 func Identify(c *fiber.Ctx) error {
 
 	// 检查权限
@@ -99,7 +87,21 @@ func Identify(c *fiber.Ctx) error {
 	})
 }
 
-// endregion
+type IdentifyReq struct {
+	Type   int    `json:"type" validate:"required,oneof=1 2"`
+	Name   string `json:"name" validate:"required"`
+	IdenNo string `json:"iden_no" validate:"required"`
+}
+
+type IdentifyRes struct {
+	Identified bool   `json:"identified"`
+	Target     string `json:"target"`
+}
+
+type idenResultData struct {
+	Success bool
+	Message string
+}
 
 // IdentifyCallbackNew 更新用户实名认证状态
 func IdentifyCallbackNew(c *fiber.Ctx) error {
@@ -110,18 +112,17 @@ func IdentifyCallbackNew(c *fiber.Ctx) error {
 		Success bool   `json:"success" validate:"required"`
 	})
 	if err := c.QueryParser(req); err != nil {
-		return core.NewBizErr("解析请求参数失败", err)
+		return renderIdenResult(c, false, "解析请求参数失败")
 	}
 
 	// 获取 token
 	infoStr, err := g.Redis.GetDel(c.Context(), idenKey(req.Id)).Bytes()
 	if err != nil {
-		return core.NewBizErr("实名认证状态已失效", err)
+		return renderIdenResult(c, false, "实名认证状态已失效，请重新发起认证")
 	}
 	info := idenInfo{}
-	err = json.Unmarshal(infoStr, &info)
-	if err != nil {
-		return core.NewServErr("解析实名认证信息失败", err)
+	if err = json.Unmarshal(infoStr, &info); err != nil {
+		return renderIdenResult(c, false, "解析实名认证信息失败，请重新发起认证")
 	}
 
 	// 获取认证结果
@@ -131,17 +132,17 @@ func IdentifyCallbackNew(c *fiber.Ctx) error {
 		info.Token,
 	))
 	if err != nil {
-		return core.NewServErr("获取实名认证结果失败", err)
+		return renderIdenResult(c, false, "获取实名认证结果失败，请重新发起认证")
 	}
 	if resp.Error.Code != 0 {
-		return core.NewServErr(fmt.Sprintf("获取实名认证结果失败: %s", resp.Error.Message))
+		return renderIdenResult(c, false, fmt.Sprintf("获取实名认证结果失败：%s", resp.Error.Message))
 	}
 	if resp.Result.H5Result != "ok" || resp.Result.SmResult != "ok" || resp.Result.RxResult != "ok" {
-		return core.NewBizErr(fmt.Sprintf("实名认证失败: %s", resp.Result.Desc))
+		return renderIdenResult(c, false, fmt.Sprintf("实名认证未通过：%s", resp.Result.Desc))
 	}
 
 	// 更新用户实名认证状态
-	_, err = q.User.Debug().
+	_, err = q.User.
 		Where(q.User.ID.Eq(info.Uid)).
 		UpdateSimple(
 			q.User.IDType.Value(info.Type),
@@ -150,11 +151,41 @@ func IdentifyCallbackNew(c *fiber.Ctx) error {
 			q.User.IDToken.Value(info.Token),
 		)
 	if err != nil {
-		return core.NewServErr("更新用户实名信息失败", err)
+		return renderIdenResult(c, false, "保存实名认证信息失败，请联系客服处理")
 	}
 
 	// 返回结果页面
-	return c.SendString("🎉认证成功！现在可以安全关闭这个页面")
+	return renderIdenResult(c, true, "实名认证成功，请在扫码页面点击按钮完成认证")
+}
+
+func renderIdenResult(c *fiber.Ctx, success bool, message string) error {
+	return c.Render("views/iden-result", idenResultData{
+		Success: success,
+		Message: message,
+	})
+}
+
+// DebugIdentifyClear 清除用户实名认证状态（调试用）
+func DebugIdentifyClear(c *fiber.Ctx) error {
+	phone := c.Params("phone")
+	if phone == "" {
+		return core.NewServErr("需要提供手机号")
+	}
+
+	_, err := q.User.
+		Where(
+			q.User.Phone.Eq(phone),
+		).
+		UpdateSimple(
+			q.User.IDType.Value(0),
+			q.User.IDNo.Value(""),
+			q.User.IDToken.Value(""),
+		)
+	if err != nil {
+		return core.NewServErr("清除实名认证失败")
+	}
+
+	return c.SendString("实名信息已清除")
 }
 
 func idenKey(id string) string {

web/handlers/inquiry.go

@@ -0,0 +1,48 @@
+package handlers
+
+import (
+	"platform/pkg/u"
+	"platform/web/core"
+	g "platform/web/globals"
+	m "platform/web/models"
+	q "platform/web/queries"
+
+	"github.com/gofiber/fiber/v2"
+)
+
+// region CreateInquiry
+
+type CreateInquiryRequest struct {
+	Company string `json:"company" validate:"omitempty,max=200"`
+	Name    string `json:"name" validate:"required,max=100"`
+	Phone   string `json:"phone" validate:"required,max=20"`
+	Email   string `json:"email" validate:"omitempty,email,max=100"`
+	Content string `json:"content" validate:"required,max=1000"`
+}
+
+func CreateInquiry(c *fiber.Ctx) error {
+
+	// 解析请求参数
+	req := new(CreateInquiryRequest)
+	err := g.Validator.ParseBody(c, req)
+	if err != nil {
+		return err
+	}
+
+	// 创建咨询记录
+	err = q.Inquiry.Create(&m.Inquiry{
+		Company: u.X(req.Company),
+		Name:    u.X(req.Name),
+		Phone:   u.X(req.Phone),
+		Email:   u.X(req.Email),
+		Content: u.X(req.Content),
+		Status:  m.InquiryStatusPending,
+	})
+	if err != nil {
+		return core.NewServErr("提交咨询失败", err)
+	}
+
+	return c.SendStatus(fiber.StatusNoContent)
+}
+
+// endregion

web/handlers/permission.go

@@ -0,0 +1,53 @@
+package handlers
+
+import (
+	"platform/web/auth"
+	"platform/web/core"
+	g "platform/web/globals"
+	s "platform/web/services"
+
+	"github.com/gofiber/fiber/v2"
+)
+
+func AllPermissionByAdmin(c *fiber.Ctx) error {
+	_, err := auth.GetAuthCtx(c).PermitAdmin(core.ScopePermissionRead)
+	if err != nil {
+		return err
+	}
+
+	list, err := s.Permission.ListPermissions()
+	if err != nil {
+		return err
+	}
+
+	return c.JSON(list)
+}
+
+func PagePermissionByAdmin(c *fiber.Ctx) error {
+	_, err := auth.GetAuthCtx(c).PermitAdmin(core.ScopePermissionRead)
+	if err != nil {
+		return err
+	}
+
+	var req PagePermissionByAdminReq
+	if err := g.Validator.ParseBody(c, &req); err != nil {
+		return err
+	}
+
+	// 获取权限列表
+	list, total, err := s.Permission.PagePermissions(req.PageReq)
+	if err != nil {
+		return core.NewServErr("获取权限列表失败")
+	}
+
+	return c.JSON(core.PageResp{
+		List:  list,
+		Total: int(total),
+		Page:  req.GetPage(),
+		Size:  req.GetSize(),
+	})
+}
+
+type PagePermissionByAdminReq struct {
+	core.PageReq
+}

web/handlers/product.go

@@ -0,0 +1,220 @@
+package handlers
+
+import (
+	"platform/web/auth"
+	"platform/web/core"
+	g "platform/web/globals"
+	s "platform/web/services"
+
+	"github.com/gofiber/fiber/v2"
+)
+
+func AllProductByAdmin(c *fiber.Ctx) error {
+	// 检查权限
+	_, err := auth.GetAuthCtx(c).PermitAdmin(core.ScopeProductRead)
+	if err != nil {
+		return err
+	}
+
+	// 解析请求参数
+	// var req AllProductsByAdminReq
+	// if err := g.Validator.ParseBody(c, &req); err != nil {
+	// 	return err
+	// }
+
+	// 查询产品
+	products, err := s.Product.AllProducts()
+	if err != nil {
+		return err
+	}
+
+	return c.JSON(products)
+}
+
+type AllProductsByAdminReq struct {
+}
+
+func CreateProduct(c *fiber.Ctx) error {
+	_, err := auth.GetAuthCtx(c).PermitAdmin(core.ScopeProductWrite)
+	if err != nil {
+		return err
+	}
+
+	var req s.CreateProductData
+	if err := g.Validator.ParseBody(c, &req); err != nil {
+		return err
+	}
+
+	err = s.Product.CreateProduct(&req)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func UpdateProduct(c *fiber.Ctx) error {
+	_, err := auth.GetAuthCtx(c).PermitAdmin(core.ScopeProductWrite)
+	if err != nil {
+		return err
+	}
+
+	var req s.UpdateProductData
+	if err := g.Validator.ParseBody(c, &req); err != nil {
+		return err
+	}
+
+	err = s.Product.UpdateProduct(&req)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DeleteProduct(c *fiber.Ctx) error {
+	_, err := auth.GetAuthCtx(c).PermitAdmin(core.ScopeProductWrite)
+	if err != nil {
+		return err
+	}
+
+	var req core.IdReq
+	if err := g.Validator.ParseBody(c, &req); err != nil {
+		return err
+	}
+
+	err = s.Product.DeleteProduct(req.Id)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func AllProductSkuByAdmin(c *fiber.Ctx) error {
+	_, err := auth.GetAuthCtx(c).PermitAdmin(core.ScopeProductSkuRead)
+	if err != nil {
+		return err
+	}
+
+	var req AllProductSkuByAdminReq
+	if err := g.Validator.ParseBody(c, &req); err != nil {
+		return err
+	}
+
+	list, err := s.ProductSku.All(req.Code)
+	if err != nil {
+		return err
+	}
+
+	return c.JSON(list)
+}
+
+type AllProductSkuByAdminReq struct {
+	Code string `json:"product_code"`
+}
+
+func PageProductSkuByAdmin(c *fiber.Ctx) error {
+	_, err := auth.GetAuthCtx(c).PermitAdmin(core.ScopeProductSkuRead)
+	if err != nil {
+		return err
+	}
+
+	var req PageProductSkuByAdminReq
+	if err := g.Validator.ParseBody(c, &req); err != nil {
+		return err
+	}
+
+	list, total, err := s.ProductSku.Page(&req.PageReq, req.ProductId)
+	if err != nil {
+		return err
+	}
+
+	return c.JSON(core.PageResp{
+		Total: int(total),
+		Page:  req.GetPage(),
+		Size:  req.GetSize(),
+		List:  list,
+	})
+}
+
+type PageProductSkuByAdminReq struct {
+	core.PageReq
+	ProductId *int32 `json:"product_id"`
+}
+
+func CreateProductSku(c *fiber.Ctx) error {
+	_, err := auth.GetAuthCtx(c).PermitAdmin(core.ScopeProductSkuWrite)
+	if err != nil {
+		return err
+	}
+
+	var req s.CreateProductSkuData
+	if err := g.Validator.ParseBody(c, &req); err != nil {
+		return err
+	}
+
+	err = s.ProductSku.Create(req)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func UpdateProductSku(c *fiber.Ctx) error {
+	_, err := auth.GetAuthCtx(c).PermitAdmin(core.ScopeProductSkuWrite)
+	if err != nil {
+		return err
+	}
+
+	var req s.UpdateProductSkuData
+	if err := g.Validator.ParseBody(c, &req); err != nil {
+		return err
+	}
+
+	err = s.ProductSku.Update(req)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func BatchUpdateProductSkuDiscount(c *fiber.Ctx) error {
+	_, err := auth.GetAuthCtx(c).PermitAdmin(core.ScopeProductSkuWrite)
+	if err != nil {
+		return err
+	}
+
+	var req s.BatchUpdateSkuDiscountData
+	if err := g.Validator.ParseBody(c, &req); err != nil {
+		return err
+	}
+
+	err = s.ProductSku.BatchUpdateDiscount(req)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DeleteProductSku(c *fiber.Ctx) error {
+	_, err := auth.GetAuthCtx(c).PermitAdmin(core.ScopeProductSkuWrite)
+	if err != nil {
+		return err
+	}
+
+	var req core.IdReq
+	if err := g.Validator.ParseBody(c, &req); err != nil {
+		return err
+	}
+
+	err = s.ProductSku.Delete(req.Id)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

web/handlers/product_discount.go

@@ -0,0 +1,105 @@
+package handlers
+
+import (
+	"platform/web/auth"
+	"platform/web/core"
+	g "platform/web/globals"
+	s "platform/web/services"
+
+	"github.com/gofiber/fiber/v2"
+)
+
+func PageDiscountByAdmin(c *fiber.Ctx) error {
+	_, err := auth.GetAuthCtx(c).PermitAdmin(core.ScopeDiscountRead)
+	if err != nil {
+		return err
+	}
+
+	var req core.PageReq
+	if err := g.Validator.ParseBody(c, &req); err != nil {
+		return err
+	}
+
+	list, total, err := s.ProductDiscount.Page(&req)
+	if err != nil {
+		return err
+	}
+
+	return c.JSON(core.PageResp{
+		Total: int(total),
+		Page:  req.GetPage(),
+		Size:  req.GetSize(),
+		List:  list,
+	})
+}
+
+func AllDiscountByAdmin(c *fiber.Ctx) error {
+	_, err := auth.GetAuthCtx(c).PermitAdmin(core.ScopeDiscountRead)
+	if err != nil {
+		return err
+	}
+
+	list, err := s.ProductDiscount.All()
+	if err != nil {
+		return err
+	}
+
+	return c.JSON(list)
+}
+
+func CreateDiscount(c *fiber.Ctx) error {
+	_, err := auth.GetAuthCtx(c).PermitAdmin(core.ScopeDiscountWrite)
+	if err != nil {
+		return err
+	}
+
+	var req s.CreateProductDiscountData
+	if err := g.Validator.ParseBody(c, &req); err != nil {
+		return err
+	}
+
+	err = s.ProductDiscount.Create(req)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func UpdateDiscount(c *fiber.Ctx) error {
+	_, err := auth.GetAuthCtx(c).PermitAdmin(core.ScopeDiscountWrite)
+	if err != nil {
+		return err
+	}
+
+	var req s.UpdateProductDiscountData
+	if err := g.Validator.ParseBody(c, &req); err != nil {
+		return err
+	}
+
+	err = s.ProductDiscount.Update(req)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DeleteDiscount(c *fiber.Ctx) error {
+	_, err := auth.GetAuthCtx(c).PermitAdmin(core.ScopeDiscountWrite)
+	if err != nil {
+		return err
+	}
+
+	var req core.IdReq
+	if err := g.Validator.ParseBody(c, &req); err != nil {
+		return err
+	}
+
+	err = s.ProductDiscount.Delete(req.Id)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

web/handlers/proxy.go

@@ -1,10 +1,11 @@
 package handlers
 
 import (
-	"log/slog"
 	"net/netip"
 	"platform/pkg/env"
-	g "platform/web/globals"
+	"platform/web/auth"
+	"platform/web/core"
+	"platform/web/globals"
 	s "platform/web/services"
 	"time"
 
@@ -16,37 +17,48 @@ func DebugRegisterProxyBaiYin(c *fiber.Ctx) error {
 		return fiber.ErrNotFound
 	}
 
-	ok, err := g.Redis.SetNX(c.Context(), "debug:channel:register:127.0.0.1", true, 0).Result()
+	err := s.Proxy.RegisterBaiyin("1a:2b:3c:4d:5e:6f", netip.AddrFrom4([4]byte{127, 0, 0, 1}), "test", "test")
 	if err != nil {
-		return err
-	}
-	slog.Info("注册代理", "ok", ok)
-	if !ok {
-		return fiber.ErrConflict
-	}
-
-	err = s.Proxy.RegisterBaiyin("1a:2b:3c:4d:5e:6f", netip.AddrFrom4([4]byte{127, 0, 0, 1}), "test", "test")
-	if err != nil {
-		return err
+		return core.NewServErr("注册失败", err)
 	}
 
 	return nil
 }
 
+// 注册白银代理网关
+func ProxyRegisterBaiYin(c *fiber.Ctx) error {
+	_, err := auth.GetAuthCtx(c).PermitOfficialClient()
+	if err != nil {
+		return err
+	}
+
+	req := new(RegisterProxyBaiyinReq)
+	err = globals.Validator.ParseBody(c, req)
+	if err != nil {
+		return err
+	}
+
+	addr, err := netip.ParseAddr(req.IP)
+	if err != nil {
+		return core.NewServErr("IP地址格式错误", err)
+	}
+
+	err = s.Proxy.RegisterBaiyin(req.Name, addr, req.Username, req.Password)
+	if err != nil {
+		return core.NewServErr("注册失败", err)
+	}
+
+	return nil
+}
+
+type RegisterProxyBaiyinReq struct {
+	Name     string `json:"name" validate:"required"`
+	IP       string `json:"ip" validate:"required"`
+	Username string `json:"username" validate:"required"`
+	Password string `json:"password" validate:"required"`
+}
+
 // region 报告上线
-
-type ProxyReportOnlineReq struct {
-	Name    string `json:"name" validate:"required"`
-	Version int    `json:"version" validate:"required"`
-}
-
-type ProxyReportOnlineResp struct {
-	Id      int32          `json:"id"`
-	Secret  string         `json:"secret"`
-	Permits []*ProxyPermit `json:"permits"`
-	Edges   []*ProxyEdge   `json:"edges"`
-}
-
 func ProxyReportOnline(c *fiber.Ctx) (err error) {
 	return c.JSON(map[string]any{
 		"error": "接口暂不可用",
@@ -150,12 +162,19 @@ func ProxyReportOnline(c *fiber.Ctx) (err error) {
 	// })
 }
 
-// region 报告下线
-
-type ProxyReportOfflineReq struct {
-	Id int32 `json:"id" validate:"required"`
+type ProxyReportOnlineReq struct {
+	Name    string `json:"name" validate:"required"`
+	Version int    `json:"version" validate:"required"`
 }
 
+type ProxyReportOnlineResp struct {
+	Id      int32          `json:"id"`
+	Secret  string         `json:"secret"`
+	Permits []*ProxyPermit `json:"permits"`
+	Edges   []*ProxyEdge   `json:"edges"`
+}
+
+// region 报告下线
 func ProxyReportOffline(c *fiber.Ctx) (err error) {
 	return c.JSON(map[string]any{
 		"error": "接口暂不可用",
@@ -193,13 +212,11 @@ func ProxyReportOffline(c *fiber.Ctx) (err error) {
 	// return nil
 }
 
-// region 报告更新
-
-type ProxyReportUpdateReq struct {
-	Id    int32        `json:"id" validate:"required"`
-	Edges []*ProxyEdge `json:"edges" validate:"required"`
+type ProxyReportOfflineReq struct {
+	Id int32 `json:"id" validate:"required"`
 }
 
+// region 报告更新
 func ProxyReportUpdate(c *fiber.Ctx) (err error) {
 	return c.JSON(map[string]any{
 		"error": "接口暂不可用",
@@ -358,6 +375,11 @@ func ProxyReportUpdate(c *fiber.Ctx) (err error) {
 	// return nil
 }
 
+type ProxyReportUpdateReq struct {
+	Id    int32        `json:"id" validate:"required"`
+	Edges []*ProxyEdge `json:"edges" validate:"required"`
+}
+
 type ProxyPermit struct {
 	Id         int32     `json:"id"`
 	Expire     time.Time `json:"expire"`

web/handlers/resource.go

@@ -15,18 +15,8 @@ import (
 	"github.com/gofiber/fiber/v2"
 )
 
-type ListResourceShortReq struct {
-	core.PageReq
-	ResourceNo   *string    `json:"resource_no"`
-	Active       *bool      `json:"active"`
-	Type         *int       `json:"type"`
-	CreateAfter  *time.Time `json:"create_after"`
-	CreateBefore *time.Time `json:"create_before"`
-	ExpireAfter  *time.Time `json:"expire_after"`
-	ExpireBefore *time.Time `json:"expire_before"`
-}
-
-func ListResourceShort(c *fiber.Ctx) error {
+// PageResourceShort 分页查询当前用户短效套餐
+func PageResourceShort(c *fiber.Ctx) error {
 	// 检查权限
 	authCtx, err := auth.GetAuthCtx(c).PermitUser()
 	if err != nil {
@@ -34,7 +24,7 @@ func ListResourceShort(c *fiber.Ctx) error {
 	}
 
 	// 解析请求参数
-	req := new(ListResourceShortReq)
+	req := new(PageResourceShortReq)
 	if err := c.BodyParser(req); err != nil {
 		return err
 	}
@@ -60,10 +50,23 @@ func ListResourceShort(c *fiber.Ctx) error {
 		do.Where(q.Resource.CreatedAt.Lte(*req.CreateBefore))
 	}
 	if req.ExpireAfter != nil {
-		do.Where(q.ResourceShort.As(q.Resource.Short.Name()).Expire.Gte(*req.ExpireAfter))
+		do.Where(q.ResourceShort.As(q.Resource.Short.Name()).ExpireAt.Gte(*req.ExpireAfter))
 	}
 	if req.ExpireBefore != nil {
-		do.Where(q.ResourceShort.As(q.Resource.Short.Name()).Expire.Lte(*req.ExpireBefore))
+		do.Where(q.ResourceShort.As(q.Resource.Short.Name()).ExpireAt.Lte(*req.ExpireBefore))
+	}
+	if req.Status != nil {
+		var short = q.ResourceShort.As(q.Resource.Short.Name())
+		switch *req.Status {
+		case 1:
+			var timeCond = q.Resource.Where(short.Type.Eq(int(m.ResourceModeTime)), short.ExpireAt.Gte(time.Now()))
+			var quotaCond = q.Resource.Where(short.Type.Eq(int(m.ResourceModeQuota)), short.Quota.GtCol(short.Used))
+			do.Where(q.Resource.Where(timeCond).Or(quotaCond))
+		case 2:
+			var timeCond = q.Resource.Where(short.Type.Eq(int(m.ResourceModeTime)), short.ExpireAt.Lte(time.Now()))
+			var quotaCond = q.Resource.Where(short.Type.Eq(int(m.ResourceModeQuota)), short.Quota.LteCol(short.Used))
+			do.Where(q.Resource.Where(timeCond).Or(quotaCond))
+		}
 	}
 
 	resource, err := q.Resource.Where(do).
@@ -96,7 +99,7 @@ func ListResourceShort(c *fiber.Ctx) error {
 	})
 }
 
-type ListResourceLongReq struct {
+type PageResourceShortReq struct {
 	core.PageReq
 	ResourceNo   *string    `json:"resource_no"`
 	Active       *bool      `json:"active"`
@@ -105,9 +108,11 @@ type ListResourceLongReq struct {
 	CreateBefore *time.Time `json:"create_before"`
 	ExpireAfter  *time.Time `json:"expire_after"`
 	ExpireBefore *time.Time `json:"expire_before"`
+	Status       *int       `json:"status"` // 0 - 全部，1 - 有效，2 - 过期
 }
 
-func ListResourceLong(c *fiber.Ctx) error {
+// PageResourceLong 分页查询当前用户长效套餐
+func PageResourceLong(c *fiber.Ctx) error {
 	// 检查权限
 	authCtx, err := auth.GetAuthCtx(c).PermitUser()
 	if err != nil {
@@ -115,7 +120,7 @@ func ListResourceLong(c *fiber.Ctx) error {
 	}
 
 	// 解析请求参数
-	req := new(ListResourceLongReq)
+	req := new(PageResourceLongReq)
 	if err := c.BodyParser(req); err != nil {
 		return err
 	}
@@ -141,10 +146,23 @@ func ListResourceLong(c *fiber.Ctx) error {
 		do.Where(q.Resource.CreatedAt.Lte(*req.CreateBefore))
 	}
 	if req.ExpireAfter != nil {
-		do.Where(q.ResourceLong.As(q.Resource.Long.Name()).Expire.Gte(*req.ExpireAfter))
+		do.Where(q.ResourceLong.As(q.Resource.Long.Name()).ExpireAt.Gte(*req.ExpireAfter))
 	}
 	if req.ExpireBefore != nil {
-		do.Where(q.ResourceLong.As(q.Resource.Long.Name()).Expire.Lte(*req.ExpireBefore))
+		do.Where(q.ResourceLong.As(q.Resource.Long.Name()).ExpireAt.Lte(*req.ExpireBefore))
+	}
+	if req.Status != nil {
+		var long = q.ResourceLong.As(q.Resource.Long.Name())
+		switch *req.Status {
+		case 1:
+			var timeCond = q.Resource.Where(long.Type.Eq(int(m.ResourceModeTime)), long.ExpireAt.Gte(time.Now()))
+			var quotaCond = q.Resource.Where(long.Type.Eq(int(m.ResourceModeQuota)), long.Quota.GtCol(long.Used))
+			do.Where(q.Resource.Where(timeCond).Or(quotaCond))
+		case 2:
+			var timeCond = q.Resource.Where(long.Type.Eq(int(m.ResourceModeTime)), long.ExpireAt.Lte(time.Now()))
+			var quotaCond = q.Resource.Where(long.Type.Eq(int(m.ResourceModeQuota)), long.Quota.LteCol(long.Used))
+			do.Where(q.Resource.Where(timeCond).Or(quotaCond))
+		}
 	}
 
 	resource, err := q.Resource.Where(do).
@@ -177,9 +195,205 @@ func ListResourceLong(c *fiber.Ctx) error {
 	})
 }
 
-type AllResourceReq struct {
+type PageResourceLongReq struct {
+	core.PageReq
+	ResourceNo   *string    `json:"resource_no"`
+	Active       *bool      `json:"active"`
+	Type         *int       `json:"type"`
+	CreateAfter  *time.Time `json:"create_after"`
+	CreateBefore *time.Time `json:"create_before"`
+	ExpireAfter  *time.Time `json:"expire_after"`
+	ExpireBefore *time.Time `json:"expire_before"`
+	Status       *int       `json:"status"` // 0 - 全部，1 - 有效，2 - 过期
 }
 
+// PageResourceShortByAdmin 分页查询全部短效套餐
+func PageResourceShortByAdmin(c *fiber.Ctx) error {
+	_, err := auth.GetAuthCtx(c).PermitAdmin(core.ScopeResourceRead)
+	if err != nil {
+		return err
+	}
+
+	var req PageResourceShortByAdminReq
+	if err = g.Validator.ParseBody(c, &req); err != nil {
+		return err
+	}
+
+	do := q.Resource.Where()
+	if req.UserPhone != nil {
+		do = do.Where(q.User.As("User").Phone.Eq(*req.UserPhone))
+	}
+	if req.ResourceNo != nil {
+		do = do.Where(q.Resource.ResourceNo.Eq(*req.ResourceNo))
+	}
+	if req.Active != nil {
+		do = do.Where(q.Resource.Active.Is(*req.Active))
+	}
+	if req.Mode != nil {
+		do = do.Where(q.ResourceShort.As("Short").Type.Eq(int(*req.Mode)))
+	}
+	if req.CreatedAtStart != nil {
+		time := u.DateHead(*req.CreatedAtStart)
+		do = do.Where(q.Resource.CreatedAt.Gte(time))
+	}
+	if req.CreatedAtEnd != nil {
+		time := u.DateTail(*req.CreatedAtEnd)
+		do = do.Where(q.Resource.CreatedAt.Lte(time))
+	}
+	if req.Expired != nil {
+		if *req.Expired {
+			do = do.Where(q.Resource.Where(
+				q.ResourceShort.As("Short").Type.Eq(int(m.ResourceModeTime)),
+				q.ResourceShort.As("Short").ExpireAt.Lte(time.Now()),
+			).Or(
+				q.ResourceShort.As("Short").Type.Eq(int(m.ResourceModeQuota)),
+				q.ResourceShort.As("Short").Quota.LteCol(q.ResourceShort.As("Short").Used),
+			))
+		} else {
+			do = do.Where(q.Resource.Where(
+				q.ResourceShort.As("Short").Type.Eq(int(m.ResourceModeTime)),
+				q.ResourceShort.As("Short").ExpireAt.Gt(time.Now()),
+			).Or(
+				q.ResourceShort.As("Short").Type.Eq(int(m.ResourceModeQuota)),
+				q.ResourceShort.As("Short").Quota.GtCol(q.ResourceShort.As("Short").Used),
+			))
+		}
+	}
+
+	list, total, err := q.Resource.
+		Joins(q.Resource.User, q.Resource.Short, q.Resource.Short.Sku).
+		Select(
+			q.Resource.ALL,
+			q.User.As("User").Phone.As("User__phone"),
+			q.User.As("User").Name.As("User__name"),
+			q.ResourceShort.As("Short").Type.As("Short__type"),
+			q.ResourceShort.As("Short").Live.As("Short__live"),
+			q.ResourceShort.As("Short").Quota.As("Short__quota"),
+			q.ResourceShort.As("Short").Used.As("Short__used"),
+			q.ResourceShort.As("Short").Daily.As("Short__daily"),
+			q.ResourceShort.As("Short").LastAt.As("Short__last_at"),
+			q.ResourceShort.As("Short").ExpireAt.As("Short__expire_at"),
+			q.ProductSku.As("Short__Sku").Name.As("Short__Sku__name"),
+		).
+		Where(q.Resource.Type.Eq(int(m.ResourceTypeShort)), do).
+		Order(q.Resource.CreatedAt.Desc()).
+		FindByPage(req.GetOffset(), req.GetLimit())
+	if err != nil {
+		return err
+	}
+
+	return c.JSON(core.PageResp{
+		List:  list,
+		Total: int(total),
+		Page:  req.GetPage(),
+		Size:  req.GetSize(),
+	})
+}
+
+type PageResourceShortByAdminReq struct {
+	core.PageReq
+	UserPhone      *string    `json:"user_phone" form:"user_phone"`
+	ResourceNo     *string    `json:"resource_no" form:"resource_no"`
+	Active         *bool      `json:"active" form:"active"`
+	Mode           *int       `json:"mode" form:"mode"`
+	CreatedAtStart *time.Time `json:"created_at_start" form:"created_at_start"`
+	CreatedAtEnd   *time.Time `json:"created_at_end" form:"created_at_end"`
+	Expired        *bool      `json:"expired" form:"expired"`
+}
+
+// PageResourceLongByAdmin 分页查询全部长效套餐
+func PageResourceLongByAdmin(c *fiber.Ctx) error {
+	_, err := auth.GetAuthCtx(c).PermitAdmin(core.ScopeResourceRead)
+	if err != nil {
+		return err
+	}
+
+	var req PageResourceLongByAdminReq
+	if err = g.Validator.ParseBody(c, &req); err != nil {
+		return err
+	}
+
+	do := q.Resource.Where()
+	if req.UserPhone != nil {
+		do = do.Where(q.User.As("User").Phone.Eq(*req.UserPhone))
+	}
+	if req.ResourceNo != nil {
+		do = do.Where(q.Resource.ResourceNo.Eq(*req.ResourceNo))
+	}
+	if req.Active != nil {
+		do = do.Where(q.Resource.Active.Is(*req.Active))
+	}
+	if req.Mode != nil {
+		do = do.Where(q.ResourceLong.As("Long").Type.Eq(*req.Mode))
+	}
+	if req.CreatedAtStart != nil {
+		do = do.Where(q.Resource.CreatedAt.Gte(*req.CreatedAtStart))
+	}
+	if req.CreatedAtEnd != nil {
+		do = do.Where(q.Resource.CreatedAt.Lte(*req.CreatedAtEnd))
+	}
+	if req.Expired != nil {
+		if *req.Expired {
+			do = do.Where(q.Resource.Where(
+				q.ResourceLong.As("Long").Type.Eq(int(m.ResourceModeTime)),
+				q.ResourceLong.As("Long").ExpireAt.Lte(time.Now()),
+			).Or(
+				q.ResourceLong.As("Long").Type.Eq(int(m.ResourceModeQuota)),
+				q.ResourceLong.As("Long").Quota.LteCol(q.ResourceLong.As("Long").Used),
+			))
+		} else {
+			do = do.Where(q.Resource.Where(
+				q.ResourceLong.As("Long").Type.Eq(int(m.ResourceModeTime)),
+				q.ResourceLong.As("Long").ExpireAt.Gt(time.Now()),
+			).Or(
+				q.ResourceLong.As("Long").Type.Eq(int(m.ResourceModeQuota)),
+				q.ResourceLong.As("Long").Quota.GtCol(q.ResourceLong.As("Long").Used),
+			))
+		}
+	}
+
+	list, total, err := q.Resource.
+		Joins(q.Resource.User, q.Resource.Long, q.Resource.Long.Sku).
+		Select(
+			q.Resource.ALL,
+			q.User.As("User").Phone.As("User__phone"),
+			q.User.As("User").Name.As("User__name"),
+			q.ResourceLong.As("Long").Type.As("Long__type"),
+			q.ResourceLong.As("Long").Live.As("Long__live"),
+			q.ResourceLong.As("Long").Quota.As("Long__quota"),
+			q.ResourceLong.As("Long").Used.As("Long__used"),
+			q.ResourceLong.As("Long").Daily.As("Long__daily"),
+			q.ResourceLong.As("Long").LastAt.As("Long__last_at"),
+			q.ResourceLong.As("Long").ExpireAt.As("Long__expire_at"),
+			q.ProductSku.As("Long__Sku").Name.As("Long__Sku__name"),
+		).
+		Where(q.Resource.Type.Eq(int(m.ResourceTypeLong)), do).
+		Order(q.Resource.CreatedAt.Desc()).
+		FindByPage(req.GetOffset(), req.GetLimit())
+	if err != nil {
+		return err
+	}
+
+	return c.JSON(core.PageResp{
+		List:  list,
+		Total: int(total),
+		Page:  req.GetPage(),
+		Size:  req.GetSize(),
+	})
+}
+
+type PageResourceLongByAdminReq struct {
+	core.PageReq
+	UserPhone      *string    `json:"user_phone" form:"user_phone"`
+	ResourceNo     *string    `json:"resource_no" form:"resource_no"`
+	Active         *bool      `json:"active" form:"active"`
+	Mode           *int       `json:"mode" form:"mode"`
+	CreatedAtStart *time.Time `json:"created_at_start" form:"created_at_start"`
+	CreatedAtEnd   *time.Time `json:"created_at_end" form:"created_at_end"`
+	Expired        *bool      `json:"expired" form:"expired"`
+}
+
+// AllActiveResource 所有可用套餐
 func AllActiveResource(c *fiber.Ctx) error {
 	// 检查权限
 	authCtx, err := auth.GetAuthCtx(c).PermitUser()
@@ -204,10 +418,10 @@ func AllActiveResource(c *fiber.Ctx) error {
 				q.Resource.Type.Eq(int(m.ResourceTypeShort)),
 				q.ResourceShort.As(q.Resource.Short.Name()).Where(
 					short.Type.Eq(int(m.ResourceModeTime)),
-					short.Expire.Gte(now),
+					short.ExpireAt.Gte(now),
 					q.ResourceShort.As(q.Resource.Short.Name()).
-						Where(short.DailyLast.Lt(u.Today())).
-						Or(short.DailyLimit.GtCol(short.DailyUsed)),
+						Where(short.LastAt.Lt(u.Today())).
+						Or(short.Quota.GtCol(short.Daily)),
 				).Or(
 					short.Type.Eq(int(m.ResourceModeQuota)),
 					short.Quota.GtCol(short.Used),
@@ -216,10 +430,10 @@ func AllActiveResource(c *fiber.Ctx) error {
 				q.Resource.Type.Eq(int(m.ResourceTypeLong)),
 				q.ResourceLong.As(q.Resource.Long.Name()).Where(
 					long.Type.Eq(int(m.ResourceModeTime)),
-					long.Expire.Gte(now),
+					long.ExpireAt.Gte(now),
 					q.ResourceLong.As(q.Resource.Long.Name()).
-						Where(long.DailyLast.Lt(u.Today())).
-						Or(long.DailyLimit.GtCol(long.DailyUsed)),
+						Where(long.LastAt.Lt(u.Today())).
+						Or(long.Quota.GtCol(long.Daily)),
 				).Or(
 					long.Type.Eq(int(m.ResourceModeQuota)),
 					long.Quota.GtCol(long.Used),
@@ -235,23 +449,28 @@ func AllActiveResource(c *fiber.Ctx) error {
 	return c.JSON(resources)
 }
 
-type StatisticPersonalResp struct {
-	Short StatisticShort `json:"short"`
-	Long  StatisticLong  `json:"long"`
+type AllResourceReq struct {
 }
 
-type StatisticShort struct {
-	ResourceCount        int `json:"resource_count"`
-	ResourceQuotaSum     int `json:"resource_quota_sum"`
-	ResourceDailyFreeSum int `json:"resource_daily_free_sum"`
-}
-
-type StatisticLong struct {
-	ResourceCount        int `json:"resource_count"`
-	ResourceQuotaSum     int `json:"resource_quota_sum"`
-	ResourceDailyFreeSum int `json:"resource_daily_free_sum"`
+func UpdateResourceByAdmin(c *fiber.Ctx) error {
+	_, err := auth.GetAuthCtx(c).PermitAdmin(core.ScopeResourceWrite)
+	if err != nil {
+		return err
+	}
+
+	var req s.UpdateResourceData
+	if err := c.BodyParser(&req); err != nil {
+		return err
+	}
+
+	if err := s.Resource.Update(&req); err != nil {
+		return err
+	}
+
+	return c.JSON(nil)
 }
 
+// StatisticResourceFree 统计每日可用
 func StatisticResourceFree(c *fiber.Ctx) error {
 	// 检查权限
 	authCtx, err := auth.GetAuthCtx(c).PermitUser()
@@ -282,39 +501,39 @@ func StatisticResourceFree(c *fiber.Ctx) error {
 
 		// 短效包量
 		case resource.Type == m.ResourceTypeShort && resource.Short.Type == m.ResourceModeQuota:
-			if u.Z(resource.Short.Quota) > resource.Short.Used {
+			if resource.Short.Quota > resource.Short.Used {
 				shortCount++
-				shortQuotaSum += int(u.Z(resource.Short.Quota) - resource.Short.Used)
+				shortQuotaSum += int(resource.Short.Quota - resource.Short.Used)
 			}
 
 		// 长效包量
 		case resource.Type == m.ResourceTypeLong && resource.Long.Type == m.ResourceModeQuota:
-			if u.Z(resource.Long.Quota) > resource.Long.Used {
+			if resource.Long.Quota > resource.Long.Used {
 				longCount++
-				longQuotaSum += int(u.Z(resource.Long.Quota) - resource.Long.Used)
+				longQuotaSum += int(resource.Long.Quota - resource.Long.Used)
 			}
 
 		// 短效包时
 		case resource.Type == m.ResourceTypeShort && resource.Short.Type == m.ResourceModeTime:
-			if time.Time(*resource.Short.Expire).After(time.Now()) {
-				if resource.Short.DailyLast == nil || u.IsToday(time.Time(*resource.Short.DailyLast)) == false {
+			if time.Time(*resource.Short.ExpireAt).After(time.Now()) {
+				if resource.Short.LastAt == nil || u.IsToday(time.Time(*resource.Short.LastAt)) == false {
 					shortCount++
-					shortDailyFreeSum += int(resource.Short.DailyLimit)
-				} else if resource.Short.DailyLimit > resource.Short.DailyUsed {
+					shortDailyFreeSum += int(resource.Short.Quota)
+				} else if resource.Short.Quota > resource.Short.Daily {
 					shortCount++
-					shortDailyFreeSum += int(resource.Short.DailyLimit - resource.Short.DailyUsed)
+					shortDailyFreeSum += int(resource.Short.Quota - resource.Short.Daily)
 				}
 			}
 
 		// 长效包时
 		case resource.Type == m.ResourceTypeLong && resource.Long.Type == m.ResourceModeTime:
-			if time.Time(*resource.Long.Expire).After(time.Now()) {
-				if resource.Long.DailyLast == nil || u.IsToday(time.Time(*resource.Long.DailyLast)) == false {
+			if time.Time(*resource.Long.ExpireAt).After(time.Now()) {
+				if resource.Long.LastAt == nil || u.IsToday(time.Time(*resource.Long.LastAt)) == false {
 					longCount++
-					longDailyFreeSum += int(resource.Long.DailyLimit)
-				} else if resource.Long.DailyLimit > resource.Long.DailyUsed {
+					longDailyFreeSum += int(resource.Long.Quota)
+				} else if resource.Long.Quota > resource.Long.Daily {
 					longCount++
-					longDailyFreeSum += int(resource.Long.DailyLimit - resource.Long.DailyUsed)
+					longDailyFreeSum += int(resource.Long.Quota - resource.Long.Daily)
 				}
 			}
 		}
@@ -334,17 +553,24 @@ func StatisticResourceFree(c *fiber.Ctx) error {
 	})
 }
 
-type StatisticResourceUsageReq struct {
-	ResourceNo *string    `json:"resource_no"`
-	TimeAfter  *time.Time `json:"time_after"`
-	TimeBefore *time.Time `json:"time_before"`
+type StatisticPersonalResp struct {
+	Short StatisticShort `json:"short"`
+	Long  StatisticLong  `json:"long"`
 }
 
-type StatisticResourceUsageResp []struct {
-	Date  time.Time `json:"date"`
-	Count int       `json:"count"`
+type StatisticShort struct {
+	ResourceCount        int `json:"resource_count"`
+	ResourceQuotaSum     int `json:"resource_quota_sum"`
+	ResourceDailyFreeSum int `json:"resource_daily_free_sum"`
 }
 
+type StatisticLong struct {
+	ResourceCount        int `json:"resource_count"`
+	ResourceQuotaSum     int `json:"resource_quota_sum"`
+	ResourceDailyFreeSum int `json:"resource_daily_free_sum"`
+}
+
+// StatisticResourceUsage 统计每日用量
 func StatisticResourceUsage(c *fiber.Ctx) error {
 	// 检查权限
 	authCtx, err := auth.GetAuthCtx(c).PermitUser()
@@ -359,21 +585,10 @@ func StatisticResourceUsage(c *fiber.Ctx) error {
 	}
 
 	// 统计套餐提取数量
-	do := q.LogsUserUsage.Where(q.LogsUserUsage.UserID.Eq(authCtx.User.ID))
-	if req.ResourceNo != nil && *req.ResourceNo != "" {
-		var resourceID int32
-		err := q.Resource.
-			Where(
-				q.Resource.UserID.Eq(authCtx.User.ID),
-				q.Resource.ResourceNo.Eq(*req.ResourceNo),
-			).
-			Select(q.Resource.ID).
-			Scan(&resourceID)
-		if err != nil {
-			return err
-		}
-		do.Where(q.LogsUserUsage.ResourceID.Eq(resourceID))
-	}
+	do := q.LogsUserUsage.Where(
+		q.LogsUserUsage.UserID.Eq(authCtx.User.ID),
+	)
+
 	if req.TimeAfter != nil {
 		do.Where(q.LogsUserUsage.Time.Gte(*req.TimeAfter))
 	}
@@ -389,7 +604,7 @@ func StatisticResourceUsage(c *fiber.Ctx) error {
 		).
 		Where(do).
 		Group(
-			field.NewUnsafeFieldRaw("date_trunc('day', time)"),
+			field.NewField("", "date"),
 		).
 		Order(
 			field.NewField("", "date").Desc(),
@@ -402,10 +617,17 @@ func StatisticResourceUsage(c *fiber.Ctx) error {
 	return c.JSON(data)
 }
 
-type CreateResourceReq struct {
-	*s.CreateResourceData
+type StatisticResourceUsageReq struct {
+	TimeAfter  *time.Time `json:"time_start"`
+	TimeBefore *time.Time `json:"time_end"`
 }
 
+type StatisticResourceUsageResp []struct {
+	Date  time.Time `json:"date"`
+	Count int       `json:"count"`
+}
+
+// CreateResource 创建套餐
 func CreateResource(c *fiber.Ctx) error {
 
 	// 检查权限
@@ -421,7 +643,7 @@ func CreateResource(c *fiber.Ctx) error {
 	}
 
 	// 创建套餐
-	err = s.Resource.CreateResourceByBalance(authCtx.User.ID, time.Now(), req.CreateResourceData)
+	err = s.Resource.CreateResourceByBalance(authCtx.User, req.CreateResourceData)
 	if err != nil {
 		return err
 	}
@@ -429,6 +651,11 @@ func CreateResource(c *fiber.Ctx) error {
 	return nil
 }
 
+type CreateResourceReq struct {
+	*s.CreateResourceData
+}
+
+// ResourcePrice 套餐价格
 func ResourcePrice(c *fiber.Ctx) error {
 	// 检查权限
 	_, err := auth.GetAuthCtx(c).PermitSecretClient()
@@ -439,11 +666,32 @@ func ResourcePrice(c *fiber.Ctx) error {
 	// 解析请求参数
 	var req = new(CreateResourceReq)
 	if err := g.Validator.ParseBody(c, req); err != nil {
-		return err
+		return core.NewBizErr("接口参数解析异常", err)
 	}
 
 	// 获取套餐价格
-	return c.JSON(fiber.Map{
-		"price": req.GetAmount().StringFixed(2),
+	// sku, err := s.Resource.GetSku(req.CreateResourceData.Code())
+	// if err != nil {
+	// 	return err
+	// }
+
+	// _, amount, discounted, couponApplied, err := s.Resource.GetPrice(sku, req.Count(), nil, nil)
+	// if err != nil {
+	// 	return err
+	// }
+	detail, err := req.TradeDetail(nil)
+	if err != nil {
+		return err
+	}
+
+	// 计算折扣
+	return c.JSON(ResourcePriceResp{
+		Price:      detail.Amount.StringFixed(2),
+		Discounted: detail.Actual.StringFixed(2),
 	})
 }
+
+type ResourcePriceResp struct {
+	Price      string `json:"price"`
+	Discounted string `json:"discounted_price"`
+}

web/handlers/trade.go

@@ -5,30 +5,99 @@ import (
 	"fmt"
 	"log/slog"
 	"platform/pkg/env"
+	"platform/pkg/u"
 	"platform/web/auth"
 	"platform/web/core"
 	g "platform/web/globals"
 	m "platform/web/models"
+	q "platform/web/queries"
 	s "platform/web/services"
-	"reflect"
 	"time"
 
 	"github.com/gofiber/fiber/v2"
 	"github.com/valyala/fasthttp"
 )
 
-type TradeCreateReq struct {
-	s.CreateTradeData
-	Type     m.TradeType            `json:"type" validate:"required"`
-	Resource *s.CreateResourceData  `json:"resource,omitempty"`
-	Recharge *s.RechargeProductInfo `json:"recharge,omitempty"`
+// PageTradeByAdmin 分页查询所有订单
+func PageTradeByAdmin(c *fiber.Ctx) error {
+	// 检查权限
+	_, err := auth.GetAuthCtx(c).PermitAdmin(core.ScopeTradeRead)
+	if err != nil {
+		return err
+	}
+
+	// 解析请求参数
+	req := new(PageTradeByAdminReq)
+	if err := g.Validator.ParseBody(c, req); err != nil {
+		return err
+	}
+
+	// 构建查询语句
+	do := q.Trade.Where()
+	if req.UserPhone != nil {
+		do = do.Where(q.User.As("User").Phone.Eq(*req.UserPhone))
+	}
+	if req.InnerNo != nil {
+		do = do.Where(q.Trade.InnerNo.Eq(*req.InnerNo))
+	}
+	if req.OuterNo != nil {
+		do = do.Where(q.Trade.OuterNo.Eq(*req.OuterNo))
+	}
+	if req.Method != nil {
+		do = do.Where(q.Trade.Method.Eq(*req.Method))
+	}
+	if req.Platform != nil {
+		do = do.Where(q.Trade.Platform.Eq(*req.Platform))
+	}
+	if req.Status != nil {
+		do = do.Where(q.Trade.Status.Eq(*req.Status))
+	}
+	if req.CreatedAtStart != nil {
+		time := u.DateHead(*req.CreatedAtStart)
+		do = do.Where(q.Trade.CreatedAt.Gte(time))
+	}
+	if req.CreatedAtEnd != nil {
+		time := u.DateTail(*req.CreatedAtEnd)
+		do = do.Where(q.Trade.CreatedAt.Lte(time))
+	}
+
+	// 查询用户列表
+	list, total, err := q.Trade.
+		Joins(q.Trade.User).
+		Select(
+			q.Trade.ALL,
+			q.User.As("User").Phone.As("User__phone"),
+			q.User.As("User").Name.As("User__name"),
+		).
+		Where(do).
+		Order(q.Trade.CreatedAt.Desc()).
+		FindByPage(req.GetOffset(), req.GetLimit())
+	if err != nil {
+		return err
+	}
+
+	// 返回结果
+	return c.JSON(core.PageResp{
+		List:  list,
+		Total: int(total),
+		Page:  req.GetPage(),
+		Size:  req.GetSize(),
+	})
 }
 
-type TradeCreateResp struct {
-	PayUrl  string `json:"pay_url"`
-	TradeNo string `json:"trade_no"`
+type PageTradeByAdminReq struct {
+	core.PageReq
+	UserPhone      *string    `json:"user_phone,omitempty"`
+	InnerNo        *string    `json:"inner_no,omitempty"`
+	OuterNo        *string    `json:"outer_no,omitempty"`
+	Method         *int       `json:"method,omitempty"`
+	Platform       *int       `json:"platform,omitempty"`
+	Status         *int       `json:"status,omitempty"`
+	CreatedAtStart *time.Time `json:"created_at_start,omitempty"`
+	CreatedAtEnd   *time.Time `json:"created_at_end,omitempty"`
 }
 
+// 创建订单
 func TradeCreate(c *fiber.Ctx) error {
 	// 检查权限
 	authCtx, err := auth.GetAuthCtx(c).PermitUser()
@@ -41,40 +110,43 @@ func TradeCreate(c *fiber.Ctx) error {
 	if err := g.Validator.ParseBody(c, req); err != nil {
 		return err
 	}
-
 	switch req.Type {
 	case m.TradeTypePurchase:
 		if req.Resource == nil {
 			return core.NewBizErr("购买信息不能为空")
 		}
-		req.Product = req.Resource
 	case m.TradeTypeRecharge:
 		if req.Recharge == nil {
 			return core.NewBizErr("充值信息不能为空")
 		}
-		req.Product = req.Recharge
 	}
 
-	// 创建交易
-	result, err := s.Trade.CreateTrade(authCtx.User.ID, time.Now(), &req.CreateTradeData)
+	// 处理订单
+	var result *s.CreateTradeResult
+	switch req.Type {
+	case m.TradeTypePurchase:
+		result, err = s.Trade.Create(authCtx.User, req.CreateTradeData, req.Resource)
+	case m.TradeTypeRecharge:
+		result, err = s.Trade.Create(authCtx.User, req.CreateTradeData, req.Recharge)
+	}
 	if err != nil {
-		slog.Error("创建交易失败", "error", err)
-		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": "创建交易失败"})
+		return core.NewServErr("处理购买产品信息失败", err)
 	}
 
-	return c.JSON(&TradeCreateResp{
-		PayUrl:  result.PaymentUrl,
-		TradeNo: result.TradeNo,
-	})
+	return c.JSON(result)
 }
 
-type TradeCompleteReq struct {
-	s.ModifyTradeData
+type TradeCreateReq struct {
+	*s.CreateTradeData
+	Type     m.TradeType           `json:"type" validate:"required"`
+	Resource *s.CreateResourceData `json:"resource,omitempty"`
+	Recharge *s.UpdateBalanceData  `json:"recharge,omitempty"`
 }
 
+// 完成订单
 func TradeComplete(c *fiber.Ctx) error {
 	// 检查权限
-	_, err := auth.GetAuthCtx(c).PermitUser()
+	authCtx, err := auth.GetAuthCtx(c).PermitUser()
 	if err != nil {
 		return err
 	}
@@ -86,7 +158,7 @@ func TradeComplete(c *fiber.Ctx) error {
 	}
 
 	// 检查订单状态
-	err = s.Trade.CompleteTrade(&req.ModifyTradeData)
+	err = s.Trade.CompleteTrade(authCtx.User, &req.TradeRef)
 	if err != nil {
 		return err
 	}
@@ -94,10 +166,11 @@ func TradeComplete(c *fiber.Ctx) error {
 	return c.SendStatus(fiber.StatusNoContent)
 }
 
-type TradeCancelReq struct {
-	s.ModifyTradeData
+type TradeCompleteReq struct {
+	s.TradeRef
 }
 
+// 取消订单
 func TradeCancel(c *fiber.Ctx) error {
 	// 检查权限
 	_, err := auth.GetAuthCtx(c).PermitUser()
@@ -112,7 +185,7 @@ func TradeCancel(c *fiber.Ctx) error {
 	}
 
 	// 取消交易
-	err = s.Trade.CancelTrade(&req.ModifyTradeData, time.Now())
+	err = s.Trade.CancelTrade(&req.TradeRef)
 	if err != nil {
 		slog.Error("取消交易失败", "trade_no", req.TradeNo, "error", err)
 		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": "取消交易失败"})
@@ -121,11 +194,14 @@ func TradeCancel(c *fiber.Ctx) error {
 	return c.SendStatus(fiber.StatusNoContent)
 }
 
-type TradeCheckReq struct {
-	s.ModifyTradeData
+type TradeCancelReq struct {
+	s.TradeRef
 }
 
+// 检查订单
 func TradeCheck(c *fiber.Ctx) error {
+	// 检查权限：sse 接口暂时不检查权限
+
 	// 解析请求参数
 	req := new(TradeCheckReq)
 	if err := g.Validator.ParseQuery(c, req); err != nil {
@@ -142,7 +218,7 @@ func TradeCheck(c *fiber.Ctx) error {
 		interval := 5
 		for range expire / interval {
 			// 检查订单状态
-			result, err := s.Trade.CheckTrade(&req.ModifyTradeData)
+			result, err := s.Trade.CheckTrade(&req.TradeRef)
 			if err != nil {
 				slog.Error("检查订单状态失败", "trade_no", req.TradeNo, "error", err)
 				return
@@ -154,9 +230,9 @@ func TradeCheck(c *fiber.Ctx) error {
 				slog.Error("写入订单状态失败", "trade_no", req.TradeNo, "error", err)
 				return
 			}
+
 			err = w.Flush()
 			if err != nil {
-				slog.Error("刷新缓冲区失败", "trade_no", req.TradeNo, "error", err, "errType", reflect.TypeOf(err))
 				return
 			}
 
@@ -171,3 +247,7 @@ func TradeCheck(c *fiber.Ctx) error {
 
 	return nil
 }
+
+type TradeCheckReq struct {
+	s.TradeRef
+}

web/handlers/user.go

@@ -2,23 +2,288 @@ package handlers
 
 import (
 	"platform/web/auth"
+	"platform/web/core"
+	g "platform/web/globals"
 	m "platform/web/models"
 	q "platform/web/queries"
 	s "platform/web/services"
 
 	"github.com/gofiber/fiber/v2"
+	"github.com/shopspring/decimal"
 	"golang.org/x/crypto/bcrypt"
+	"gorm.io/gorm"
 )
 
-// region /update
+// 分页获取用户
+func PageUserByAdmin(c *fiber.Ctx) error {
+	// 检查权限
+	_, err := auth.GetAuthCtx(c).PermitAdmin(core.ScopeUserRead)
+	if err != nil {
+		return err
+	}
 
-type UpdateUserReq struct {
-	Username      string `json:"username" validate:"omitempty,min=3,max=20"`
-	Email         string `json:"email" validate:"omitempty,email"`
-	ContactQQ     string `json:"contact_qq" validate:"omitempty,qq"`
-	ContactWechat string `json:"contact_wechat" validate:"omitempty,wechat"`
+	// 解析请求参数
+	req := new(PageUserByAdminReq)
+	if err := g.Validator.ParseBody(c, req); err != nil {
+		return err
+	}
+
+	// 构建查询条件
+	do := q.User.Where()
+	if req.Account != nil {
+		do = do.Where(q.User.Where(
+			q.User.Username.Like("%" + *req.Account + "%"),
+		).Or(
+			q.User.Phone.Like("%" + *req.Account + "%"),
+		).Or(
+			q.User.Email.Like("%" + *req.Account + "%"),
+		))
+	}
+	if req.Name != nil {
+		do = do.Where(q.User.Name.Eq(*req.Name))
+	}
+	if req.Identified != nil {
+		if *req.Identified {
+			do = do.Where(q.User.IDType.Gt(0))
+		} else {
+			do = do.Where(q.User.IDType.Eq(0))
+		}
+	}
+	if req.Enabled != nil {
+		if *req.Enabled {
+			do = do.Where(q.User.Status.Eq(1))
+		} else {
+			do = do.Where(q.User.Status.Eq(0))
+		}
+	}
+	if req.Assigned != nil {
+		if *req.Assigned {
+			do = do.Where(q.User.AdminID.IsNotNull())
+		} else {
+			do = do.Where(q.User.AdminID.IsNull())
+		}
+	}
+
+	// 查询用户列表
+	users, total, err := q.User.
+		Preload(q.User.Admin, q.User.Discount).
+		Omit(q.User.Password).
+		Where(do).
+		Order(q.User.CreatedAt.Desc()).
+		FindByPage(req.GetOffset(), req.GetLimit())
+	if err != nil {
+		return err
+	}
+
+	for _, user := range users {
+		if user.Admin != nil {
+			user.Admin = &m.Admin{
+				Name: user.Admin.Name,
+			}
+		}
+	}
+
+	// 返回结果
+	return c.JSON(core.PageResp{
+		Total: int(total),
+		Page:  req.GetPage(),
+		Size:  req.GetSize(),
+		List:  users,
+	})
 }
 
+type PageUserByAdminReq struct {
+	core.PageReq
+	Account    *string `json:"account,omitempty"`
+	Name       *string `json:"name,omitempty"`
+	Identified *bool   `json:"identified,omitempty"`
+	Enabled    *bool   `json:"enabled,omitempty"`
+	Assigned   *bool   `json:"assigned,omitempty"`
+}
+
+// 管理员获取单个用户
+func GetUserByAdmin(c *fiber.Ctx) error {
+	// 检查权限
+	_, err := auth.GetAuthCtx(c).PermitAdmin(core.ScopeUserReadOne)
+	if err != nil {
+		return err
+	}
+
+	// 解析请求参数
+	var req GetUserByAdminReq
+	if err := g.Validator.ParseBody(c, &req); err != nil {
+		return err
+	}
+
+	// 构建查询条件
+	do := q.User.Where()
+	if req.Account != nil {
+		do = do.Where(q.User.Where(
+			q.User.Username.Like("%" + *req.Account + "%"),
+		).Or(
+			q.User.Phone.Like("%" + *req.Account + "%"),
+		).Or(
+			q.User.Email.Like("%" + *req.Account + "%"),
+		))
+	}
+	if req.Name != nil {
+		do = do.Where(q.User.Name.Eq(*req.Name))
+	}
+
+	// 查询用户
+	user, err := q.User.
+		Preload(q.User.Admin, q.User.Discount).
+		Omit(q.User.Password).
+		Where(do).
+		Order(q.User.CreatedAt.Desc()).
+		First()
+	if err == gorm.ErrRecordNotFound {
+		return core.NewBizErr("找不到用户")
+	}
+	if err != nil {
+		return err
+	}
+
+	// 仅保留管理员名称
+	if user.Admin != nil {
+		user.Admin = &m.Admin{
+			Name: user.Admin.Name,
+		}
+	}
+
+	// 返回结果
+	return c.JSON(user)
+}
+
+type GetUserByAdminReq struct {
+	Account *string `json:"account,omitempty"`
+	Name    *string `json:"name,omitempty"`
+}
+
+// 管理员创建用户
+func CreateUserByAdmin(c *fiber.Ctx) error {
+	_, err := auth.GetAuthCtx(c).PermitAdmin(core.ScopeUserWrite)
+	if err != nil {
+		return err
+	}
+
+	var req s.CreateUserByAdminData
+	if err := g.Validator.ParseBody(c, &req); err != nil {
+		return err
+	}
+
+	if err := s.User.CreateByAdmin(req); err != nil {
+		return err
+	}
+
+	return c.JSON(nil)
+}
+
+// 管理员更新用户
+func UpdateUserByAdmin(c *fiber.Ctx) error {
+	_, err := auth.GetAuthCtx(c).PermitAdmin(core.ScopeUserWrite)
+	if err != nil {
+		return err
+	}
+
+	var req s.UpdateUserByAdminData
+	if err := g.Validator.ParseBody(c, &req); err != nil {
+		return err
+	}
+
+	if err := s.User.UpdateByAdmin(req); err != nil {
+		return err
+	}
+
+	return c.JSON(nil)
+}
+
+// 管理员删除用户
+func RemoveUserByAdmin(c *fiber.Ctx) error {
+	_, err := auth.GetAuthCtx(c).PermitAdmin(core.ScopeUserWrite)
+	if err != nil {
+		return err
+	}
+
+	var req core.IdReq
+	if err := g.Validator.ParseBody(c, &req); err != nil {
+		return err
+	}
+
+	if err := s.User.RemoveByAdmin(req.Id); err != nil {
+		return err
+	}
+
+	return c.JSON(nil)
+}
+
+// 管理员更新用户余额
+func UpdateUserBalanceByAdmin(c *fiber.Ctx) error {
+	authCtx, err := auth.GetAuthCtx(c).PermitAdmin(core.ScopeUserWriteBalance)
+	if err != nil {
+		return err
+	}
+
+	var req UpdateUserBalanceByAdminData
+	if err := g.Validator.ParseBody(c, &req); err != nil {
+		return err
+	}
+
+	user, err := s.User.Get(q.Q, req.UserID)
+	if err != nil {
+		return err
+	}
+	balance, err := decimal.NewFromString(req.Balance)
+	if err != nil {
+		return err
+	}
+	if err := s.User.UpdateBalanceByAdmin(user, balance, &authCtx.Admin.ID); err != nil {
+		return err
+	}
+
+	return c.JSON(nil)
+}
+
+type UpdateUserBalanceByAdminData struct {
+	UserID  int32  `json:"user_id" validate:"required"`
+	Balance string `json:"balance" validate:"required"`
+}
+
+// 绑定管理员
+func BindAdmin(c *fiber.Ctx) error {
+	// 检查权限
+	authCtx, err := auth.GetAuthCtx(c).PermitAdmin(core.ScopeUserWrite)
+	if err != nil {
+		return err
+	}
+
+	// 解析请求参数
+	req := new(struct {
+		UserID int `json:"user_id" validate:"required"`
+	})
+	if err := g.Validator.ParseBody(c, req); err != nil {
+		return err
+	}
+
+	// 更新用户信息
+	result, err := q.User.Where(
+		q.User.ID.Eq(int32(req.UserID)),
+		q.User.AdminID.IsNull(),
+	).UpdateColumnSimple(
+		q.User.AdminID.Value(authCtx.Admin.ID),
+	)
+	if err != nil {
+		return err
+	}
+	if result.RowsAffected == 0 {
+		return core.NewBizErr("用户已绑定管理员")
+	}
+
+	// 返回结果
+	return c.SendStatus(fiber.StatusNoContent)
+}
+
+// 更新用户
 func UpdateUser(c *fiber.Ctx) error {
 	// 检查权限
 	authCtx, err := auth.GetAuthCtx(c).PermitUser()
@@ -49,15 +314,14 @@ func UpdateUser(c *fiber.Ctx) error {
 	return c.SendStatus(fiber.StatusNoContent)
 }
 
-// endregion
-
-// region /update/account
-
-type UpdateAccountReq struct {
-	Username string `json:"username" validate:"omitempty,min=3,max=20"`
-	Password string `json:"password" validate:"omitempty,min=6,max=20"`
+type UpdateUserReq struct {
+	Username      string `json:"username" validate:"omitempty,min=3,max=20"`
+	Email         string `json:"email" validate:"omitempty,email"`
+	ContactQQ     string `json:"contact_qq" validate:"omitempty,qq"`
+	ContactWechat string `json:"contact_wechat" validate:"omitempty,wechat"`
 }
 
+// 更新账号信息
 func UpdateAccount(c *fiber.Ctx) error {
 	// 检查权限
 	authCtx, err := auth.GetAuthCtx(c).PermitUser()
@@ -86,16 +350,12 @@ func UpdateAccount(c *fiber.Ctx) error {
 	return c.SendStatus(fiber.StatusNoContent)
 }
 
-// endregion
-
-// region /update/password
-
-type UpdatePasswordReq struct {
-	Phone    string `json:"phone"`
-	Code     string `json:"code"`
-	Password string `json:"password"`
+type UpdateAccountReq struct {
+	Username string `json:"username" validate:"omitempty,min=3,max=20"`
+	Password string `json:"password" validate:"omitempty,min=6,max=20"`
 }
 
+// 更新账号密码
 func UpdatePassword(c *fiber.Ctx) error {
 	// 检查权限
 	authCtx, err := auth.GetAuthCtx(c).PermitUser()
@@ -109,8 +369,13 @@ func UpdatePassword(c *fiber.Ctx) error {
 		return err
 	}
 
+	// 验证手机号
+	if req.Phone != authCtx.User.Phone {
+		return fiber.NewError(fiber.StatusBadRequest, "手机号码不正确")
+	}
+
 	// 验证手机令牌
-	if req.Phone == "" || req.Code == "" {
+	if req.Code == "" {
 		return fiber.NewError(fiber.StatusBadRequest, "手机号码和验证码不能为空")
 	}
 	err = s.Verifier.VerifySms(c.Context(), req.Phone, req.Code)
@@ -135,4 +400,8 @@ func UpdatePassword(c *fiber.Ctx) error {
 	return c.SendStatus(fiber.StatusNoContent)
 }
 
-// endregion
+type UpdatePasswordReq struct {
+	Phone    string `json:"phone"`
+	Code     string `json:"code"`
+	Password string `json:"password"`
+}

web/middlewares.go

@@ -20,6 +20,14 @@ func ApplyMiddlewares(app *fiber.App) {
 		EnableStackTrace: true,
 	}))
 
+	// cors
+	app.Use(cors.New(cors.Config{
+		AllowCredentials: true,
+		AllowOriginsFunc: func(origin string) bool {
+			return true
+		},
+	}))
+
 	// logger
 	app.Use(logger.New(logger.Config{
 		Next: func(c *fiber.Ctx) bool {
@@ -38,9 +46,6 @@ func ApplyMiddlewares(app *fiber.App) {
 		},
 	}))
 
-	// cors
-	app.Use(cors.New())
-
 	// authenticate
 	app.Use(auth.Authenticate())
 }

web/models/admin.go

@@ -10,16 +10,18 @@ import (
 // Admin 管理员表
 type Admin struct {
 	core.Model
-	Username    string      `json:"username" gorm:"column:username"`           // 用户名
-	Password    string      `json:"password" gorm:"column:password"`           // 密码
-	Name        *string     `json:"name" gorm:"column:name"`                   // 真实姓名
-	Avatar      *string     `json:"avatar" gorm:"column:avatar"`               // 头像URL
-	Phone       *string     `json:"phone" gorm:"column:phone"`                 // 手机号码
-	Email       *string     `json:"email" gorm:"column:email"`                 // 邮箱
-	Status      AdminStatus `json:"status" gorm:"column:status"`               // 状态：0-禁用，1-正常
-	LastLogin   *time.Time  `json:"last_login" gorm:"column:last_login"`       // 最后登录时间
-	LastLoginIP *orm.Inet   `json:"last_login_ip" gorm:"column:last_login_ip"` // 最后登录地址
-	LastLoginUA *string     `json:"last_login_ua" gorm:"column:last_login_ua"` // 最后登录代理
+	Username    string      `json:"username" gorm:"column:username"`                     // 用户名
+	Password    string      `json:"password" gorm:"column:password"`                     // 密码
+	Name        *string     `json:"name,omitempty" gorm:"column:name"`                   // 真实姓名
+	Avatar      *string     `json:"avatar,omitempty" gorm:"column:avatar"`               // 头像URL
+	Phone       *string     `json:"phone,omitempty" gorm:"column:phone"`                 // 手机号码
+	Email       *string     `json:"email,omitempty" gorm:"column:email"`                 // 邮箱
+	Status      AdminStatus `json:"status" gorm:"column:status"`                         // 状态：0-禁用，1-正常
+	LastLogin   *time.Time  `json:"last_login,omitempty" gorm:"column:last_login"`       // 最后登录时间
+	LastLoginIP *orm.Inet   `json:"last_login_ip,omitempty" gorm:"column:last_login_ip"` // 最后登录地址
+	LastLoginUA *string     `json:"last_login_ua,omitempty" gorm:"column:last_login_ua"` // 最后登录代理
+
+	Roles []*AdminRole `json:"roles" gorm:"many2many:link_admin_role"`
 }
 
 // AdminStatus 管理员状态枚举

web/models/admin_role.go

@@ -7,8 +7,10 @@ import (
 // AdminRole 管理员角色表
 type AdminRole struct {
 	core.Model
-	Name        string  `json:"name" gorm:"column:name"`               // 角色名称
-	Description *string `json:"description" gorm:"column:description"` // 角色描述
-	Active      bool    `json:"active" gorm:"column:active"`           // 是否激活
-	Sort        int32   `json:"sort" gorm:"column:sort"`               // 排序
+	Name        string  `json:"name" gorm:"column:name"`                         // 角色名称
+	Description *string `json:"description,omitempty" gorm:"column:description"` // 角色描述
+	Active      bool    `json:"active" gorm:"column:active"`                     // 是否激活
+	Sort        int32   `json:"sort" gorm:"column:sort"`                         // 排序
+
+	Permissions []*Permission `json:"permissions" gorm:"many2many:link_admin_role_permission"`
 }

web/models/announcement.go

@@ -7,12 +7,12 @@ import (
 // Announcement 公告表
 type Announcement struct {
 	core.Model
-	Title   string             `json:"title" gorm:"column:title"`     // 公告标题
-	Content *string            `json:"content" gorm:"column:content"` // 公告内容
-	Type    AnnouncementType   `json:"type" gorm:"column:type"`       // 公告类型：1-普通公告
-	Pin     bool               `json:"pin" gorm:"column:pin"`         // 是否置顶
-	Status  AnnouncementStatus `json:"status" gorm:"column:status"`   // 公告状态：0-禁用，1-正常
-	Sort    int32              `json:"sort" gorm:"column:sort"`       // 公告排序
+	Title   string             `json:"title" gorm:"column:title"`               // 公告标题
+	Content *string            `json:"content,omitempty" gorm:"column:content"` // 公告内容
+	Type    AnnouncementType   `json:"type" gorm:"column:type"`                 // 公告类型：1-普通公告
+	Pin     bool               `json:"pin" gorm:"column:pin"`                   // 是否置顶
+	Status  AnnouncementStatus `json:"status" gorm:"column:status"`             // 公告状态：0-禁用，1-正常
+	Sort    int32              `json:"sort" gorm:"column:sort"`                 // 公告排序
 }
 
 // AnnouncementType 公告类型枚举

web/models/balance_activity.go

@@ -0,0 +1,22 @@
+package models
+
+import (
+	"time"
+)
+
+// BalanceActivity 余额变动记录表
+type BalanceActivity struct {
+	ID          int32     `json:"id" gorm:"column:id;primaryKey"`            // 记录ID
+	UserID      int32     `json:"user_id" gorm:"column:user_id"`             // 用户ID
+	BillID      *int32    `json:"bill_id,omitempty" gorm:"column:bill_id"`   // 账单ID
+	AdminID     *int32    `json:"admin_id,omitempty" gorm:"column:admin_id"` // 管理员ID
+	Amount      string    `json:"amount" gorm:"column:amount"`               // 变动金额
+	BalancePrev string    `json:"balance_prev" gorm:"column:balance_prev"`   // 变动前余额
+	BalanceCurr string    `json:"balance_curr" gorm:"column:balance_curr"`   // 变动后余额
+	Remark      *string   `json:"remark,omitempty" gorm:"column:remark"`     // 备注
+	CreatedAt   time.Time `json:"created_at" gorm:"column:created_at"`       // 创建时间
+
+	User  *User `json:"user,omitempty" gorm:"foreignKey:UserID"`
+	Bill  *Bill `json:"bill,omitempty" gorm:"foreignKey:BillID"`
+	Admin *User `json:"admin,omitempty" gorm:"foreignKey:AdminID"`
+}

web/models/bill.go

@@ -9,19 +9,21 @@ import (
 // Bill 账单表
 type Bill struct {
 	core.Model
-	UserID     int32           `json:"user_id" gorm:"column:user_id"`         // 用户ID
-	TradeID    *int32          `json:"trade_id" gorm:"column:trade_id"`       // 订单ID
-	ResourceID *int32          `json:"resource_id" gorm:"column:resource_id"` // 套餐ID
-	RefundID   *int32          `json:"refund_id" gorm:"column:refund_id"`     // 退款ID
-	BillNo     string          `json:"bill_no" gorm:"column:bill_no"`         // 易读账单号
-	Info       *string         `json:"info" gorm:"column:info"`               // 产品可读信息
-	Type       BillType        `json:"type" gorm:"column:type"`               // 账单类型：1-消费，2-退款，3-充值
-	Amount     decimal.Decimal `json:"amount" gorm:"column:amount"`           // 账单金额
+	UserID     int32           `json:"user_id" gorm:"column:user_id"`                   // 用户ID
+	TradeID    *int32          `json:"trade_id,omitempty" gorm:"column:trade_id"`       // 订单ID
+	ResourceID *int32          `json:"resource_id,omitempty" gorm:"column:resource_id"` // 套餐ID
+	RefundID   *int32          `json:"refund_id,omitempty" gorm:"column:refund_id"`     // 退款ID
+	CouponID   *int32          `json:"coupon_id,omitempty" gorm:"column:coupon_id"`     // 优惠券ID
+	BillNo     string          `json:"bill_no" gorm:"column:bill_no"`                   // 易读账单号
+	Info       *string         `json:"info,omitempty" gorm:"column:info"`               // 产品可读信息
+	Type       BillType        `json:"type" gorm:"column:type"`                         // 账单类型：1-消费，2-退款，3-充值
+	Amount     decimal.Decimal `json:"amount" gorm:"column:amount"`                     // 应付金额
+	Actual     decimal.Decimal `json:"actual" gorm:"column:actual"`                     // 实付金额
 
-	User     *User     `json:"user" gorm:"foreignKey:UserID"`
-	Trade    *Trade    `json:"trade" gorm:"foreignKey:TradeID"`
-	Resource *Resource `json:"resource" gorm:"foreignKey:ResourceID"`
-	Refund   *Refund   `json:"refund" gorm:"foreignKey:RefundID"`
+	User     *User     `json:"user,omitempty" gorm:"foreignKey:UserID"`
+	Trade    *Trade    `json:"trade,omitempty" gorm:"foreignKey:TradeID"`
+	Resource *Resource `json:"resource,omitempty" gorm:"foreignKey:ResourceID"`
+	Refund   *Refund   `json:"refund,omitempty" gorm:"foreignKey:RefundID"`
 }
 
 // BillType 账单类型枚举

web/models/channel.go

@@ -9,23 +9,25 @@ import (
 // Channel 通道表
 type Channel struct {
 	core.Model
-	UserID     int32     `json:"user_id" gorm:"column:user_id"`         // 用户ID
-	ResourceID int32     `json:"resource_id" gorm:"column:resource_id"` // 套餐ID
-	ProxyID    int32     `json:"proxy_id" gorm:"column:proxy_id"`       // 代理ID
-	BatchNo    string    `json:"batch_no" gorm:"column:batch_no"`       // 批次编号
-	Port       uint16    `json:"port" gorm:"column:port"`               // 代理端口
-	EdgeID     *int32    `json:"edge_id" gorm:"column:edge_id"`         // 节点ID（手动配置）
-	FilterISP  *EdgeISP  `json:"filter_isp" gorm:"column:filter_isp"`   // 运营商过滤（自动配置）：参考 edge.isp
-	FilterProv *string   `json:"filter_prov" gorm:"column:filter_prov"` // 省份过滤（自动配置）
-	FilterCity *string   `json:"filter_city" gorm:"column:filter_city"` // 城市过滤（自动配置）
-	IP         *orm.Inet `json:"ip" gorm:"column:ip"`                   // 节点地址
-	Whitelists *string   `json:"whitelists" gorm:"column:whitelists"`   // IP白名单，逗号分隔
-	Username   *string   `json:"username" gorm:"column:username"`       // 用户名
-	Password   *string   `json:"password" gorm:"column:password"`       // 密码
-	ExpiredAt  time.Time `json:"expired_at" gorm:"column:expired_at"`   // 过期时间
+	UserID     int32     `json:"user_id" gorm:"column:user_id"`                   // 用户ID
+	ResourceID int32     `json:"resource_id" gorm:"column:resource_id"`           // 套餐ID
+	BatchNo    string    `json:"batch_no" gorm:"column:batch_no"`                 // 批次编号
+	ProxyID    int32     `json:"proxy_id" gorm:"column:proxy_id"`                 // 代理ID
+	Host       string    `json:"host" gorm:"column:host"`                         // 代理主机
+	Port       uint16    `json:"port" gorm:"column:port"`                         // 代理端口
+	EdgeID     *int32    `json:"edge_id,omitempty" gorm:"column:edge_id"`         // 节点ID（手动配置）
+	EdgeRef    *string   `json:"edge_ref,omitempty" gorm:"column:edge_ref"`       // 外部节点引用，用于索引没有ID的外部非受控节点
+	FilterISP  *EdgeISP  `json:"filter_isp,omitempty" gorm:"column:filter_isp"`   // 运营商过滤（自动配置）：参考 edge.isp
+	FilterProv *string   `json:"filter_prov,omitempty" gorm:"column:filter_prov"` // 省份过滤（自动配置）
+	FilterCity *string   `json:"filter_city,omitempty" gorm:"column:filter_city"` // 城市过滤（自动配置）
+	IP         *orm.Inet `json:"ip,omitempty" gorm:"column:ip"`                   // 节点地址
+	Whitelists *string   `json:"whitelists,omitempty" gorm:"column:whitelists"`   // IP白名单，逗号分隔
+	Username   *string   `json:"username,omitempty" gorm:"column:username"`       // 用户名
+	Password   *string   `json:"password,omitempty" gorm:"column:password"`       // 密码
+	ExpiredAt  time.Time `json:"expired_at" gorm:"column:expired_at"`             // 过期时间
 
-	User     User     `json:"user" gorm:"foreignKey:UserID"`
-	Resource Resource `json:"resource" gorm:"foreignKey:ResourceID"`
-	Proxy    Proxy    `json:"proxy" gorm:"foreignKey:ProxyID"`
-	Edge     *Edge    `json:"edge" gorm:"foreignKey:EdgeID"`
+	User     *User     `json:"user,omitempty" gorm:"foreignKey:UserID"`
+	Resource *Resource `json:"resource,omitempty" gorm:"foreignKey:ResourceID"`
+	Proxy    *Proxy    `json:"proxy,omitempty" gorm:"foreignKey:ProxyID"`
+	Edge     *Edge     `json:"edge,omitempty" gorm:"foreignKey:EdgeID"`
 }

web/models/client.go

@@ -7,14 +7,16 @@ import (
 // Client 客户端表
 type Client struct {
 	core.Model
-	ClientID     string       `json:"client_id" gorm:"column:client_id"`         // OAuth2客户端标识符
-	ClientSecret string       `json:"client_secret" gorm:"column:client_secret"` // OAuth2客户端密钥
-	RedirectURI  *string      `json:"redirect_uri" gorm:"column:redirect_uri"`   // OAuth2 重定向URI
-	Spec         ClientSpec   `json:"spec" gorm:"column:spec"`                   // 安全规范：1-native，2-browser，3-web，4-api
-	Name         string       `json:"name" gorm:"column:name"`                   // 名称
-	Icon         *string      `json:"icon" gorm:"column:icon"`                   // 图标URL
-	Status       ClientStatus `json:"status" gorm:"column:status"`               // 状态：0-禁用，1-正常
-	Type         ClientType   `json:"type" gorm:"column:type"`                   // 类型：0-普通，1-官方
+	ClientID     string       `json:"client_id" gorm:"column:client_id"`                 // OAuth2客户端标识符
+	ClientSecret string       `json:"client_secret" gorm:"column:client_secret"`         // OAuth2客户端密钥
+	RedirectURI  *string      `json:"redirect_uri,omitempty" gorm:"column:redirect_uri"` // OAuth2 重定向URI
+	Spec         ClientSpec   `json:"spec" gorm:"column:spec"`                           // 安全规范：1-native，2-browser，3-web，4-api
+	Name         string       `json:"name" gorm:"column:name"`                           // 名称
+	Icon         *string      `json:"icon,omitempty" gorm:"column:icon"`                 // 图标URL
+	Status       ClientStatus `json:"status" gorm:"column:status"`                       // 状态：0-禁用，1-正常
+	Type         ClientType   `json:"type" gorm:"column:type"`                           // 类型：0-普通，1-官方
+
+	Permissions []*Permission `json:"permissions" gorm:"many2many:link_client_permission"`
 }
 
 // ClientSpec 客户端安全规范枚举

web/models/coupon.go

@@ -10,13 +10,13 @@ import (
 // Coupon 优惠券表
 type Coupon struct {
 	core.Model
-	UserID    *int32          `json:"user_id" gorm:"column:user_id"`       // 用户ID
-	Code      string          `json:"code" gorm:"column:code"`             // 优惠券代码
-	Remark    *string         `json:"remark" gorm:"column:remark"`         // 优惠券备注
-	Amount    decimal.Decimal `json:"amount" gorm:"column:amount"`         // 优惠券金额
-	MinAmount decimal.Decimal `json:"min_amount" gorm:"column:min_amount"` // 最低消费金额
-	Status    CouponStatus    `json:"status" gorm:"column:status"`         // 优惠券状态：0-未使用，1-已使用，2-已过期
-	ExpireAt  *time.Time      `json:"expire_at" gorm:"column:expire_at"`   // 过期时间
+	UserID    *int32          `json:"user_id,omitempty" gorm:"column:user_id"`     // 用户ID
+	Code      string          `json:"code" gorm:"column:code"`                     // 优惠券代码
+	Remark    *string         `json:"remark,omitempty" gorm:"column:remark"`       // 优惠券备注
+	Amount    decimal.Decimal `json:"amount" gorm:"column:amount"`                 // 优惠券金额
+	MinAmount decimal.Decimal `json:"min_amount" gorm:"column:min_amount"`         // 最低消费金额
+	Status    CouponStatus    `json:"status" gorm:"column:status"`                 // 优惠券状态：0-未使用，1-已使用，2-已过期
+	ExpireAt  *time.Time      `json:"expire_at,omitempty" gorm:"column:expire_at"` // 过期时间
 }
 
 // CouponStatus 优惠券状态枚举

web/models/inquiry.go

@@ -0,0 +1,25 @@
+package models
+
+import (
+	"platform/web/core"
+)
+
+// Inquiry 用户咨询表
+type Inquiry struct {
+	core.Model
+	Company *string       `json:"company,omitempty" gorm:"column:company"` // 公司名称
+	Name    *string       `json:"name,omitempty" gorm:"column:name"`       // 联系人姓名
+	Phone   *string       `json:"phone,omitempty" gorm:"column:phone"`     // 联系电话
+	Email   *string       `json:"email,omitempty" gorm:"column:email"`     // 联系邮箱
+	Content *string       `json:"content,omitempty" gorm:"column:content"` // 咨询内容
+	Status  InquiryStatus `json:"status" gorm:"column:status"`             // 处理状态：0-待处理，1-已处理
+	Remark  *string       `json:"remark,omitempty" gorm:"column:remark"`   // 备注
+}
+
+// InquiryStatus 咨询处理状态枚举
+type InquiryStatus int
+
+const (
+	InquiryStatusPending   InquiryStatus = 0 // 待处理
+	InquiryStatusProcessed InquiryStatus = 1 // 已处理
+)

web/models/link_admin_role.go

@@ -2,7 +2,7 @@ package models
 
 // LinkAdminRole 管理员角色关联表
 type LinkAdminRole struct {
-	ID      int32 `json:"id" gorm:"column:id"`             // 关联ID
-	AdminID int32 `json:"admin_id" gorm:"column:admin_id"` // 管理员ID
-	RoleID  int32 `json:"role_id" gorm:"column:role_id"`   // 角色ID
+	ID      int32 `json:"id" gorm:"column:id"`                 // 关联ID
+	AdminID int32 `json:"admin_id" gorm:"column:admin_id"`     // 管理员ID
+	RoleID  int32 `json:"role_id" gorm:"column:admin_role_id"` // 角色ID
 }

web/models/link_admin_role_permission.go

@@ -3,6 +3,6 @@ package models
 // LinkAdminRolePermission 管理员角色权限关联表
 type LinkAdminRolePermission struct {
 	ID           int32 `json:"id" gorm:"column:id"`                       // 关联ID
-	RoleID       int32 `json:"role_id" gorm:"column:role_id"`             // 角色ID
+	RoleID       int32 `json:"role_id" gorm:"column:admin_role_id"`       // 角色ID
 	PermissionID int32 `json:"permission_id" gorm:"column:permission_id"` // 权限ID
 }

web/models/link_user_role.go

@@ -2,7 +2,7 @@ package models
 
 // LinkUserRole 用户角色关联表
 type LinkUserRole struct {
-	ID     int32 `json:"id" gorm:"column:id"`           // 关联ID
-	UserID int32 `json:"user_id" gorm:"column:user_id"` // 用户ID
-	RoleID int32 `json:"role_id" gorm:"column:role_id"` // 角色ID
+	ID     int32 `json:"id" gorm:"column:id"`                // 关联ID
+	UserID int32 `json:"user_id" gorm:"column:user_id"`      // 用户ID
+	RoleID int32 `json:"role_id" gorm:"column:user_role_id"` // 角色ID
 }

web/models/link_user_role_permission.go

@@ -3,6 +3,6 @@ package models
 // LinkUserRolePermission 用户角色权限关联表
 type LinkUserRolePermission struct {
 	ID           int32 `json:"id" gorm:"column:id"`                       // 关联ID
-	RoleID       int32 `json:"role_id" gorm:"column:role_id"`             // 角色ID
+	RoleID       int32 `json:"role_id" gorm:"column:user_role_id"`        // 角色ID
 	PermissionID int32 `json:"permission_id" gorm:"column:permission_id"` // 权限ID
 }

web/models/logs_login.go

@@ -13,10 +13,10 @@ type LogsLogin struct {
 	GrantType    GrantType    `json:"grant_type" gorm:"column:grant_type"`       // 授权类型
 	PasswordType PasswordType `json:"password_type" gorm:"column:password_type"` // 密码模式子授权类型
 	Success      bool         `json:"success" gorm:"column:success"`             // 登录是否成功
-	UserID       *int32       `json:"user_id" gorm:"column:user_id"`             // 用户ID
+	UserID       *int32       `json:"user_id,omitempty" gorm:"column:user_id"`   // 用户ID
 	Time         time.Time    `json:"time" gorm:"column:time"`                   // 登录时间
 
-	User *User `json:"user" gorm:"foreignKey:UserID"`
+	User *User `json:"user,omitempty" gorm:"foreignKey:UserID"`
 }
 
 // GrantType 授权类型枚举

web/models/logs_request.go

@@ -7,18 +7,18 @@ import (
 
 // LogsRequest 访问日志表
 type LogsRequest struct {
-	ID       int32     `json:"id" gorm:"column:id"`               // 访问日志ID
-	IP       orm.Inet  `json:"ip" gorm:"column:ip;not null"`      // IP地址
-	UA       string    `json:"ua" gorm:"column:ua"`               // 用户代理
-	UserID   *int32    `json:"user_id" gorm:"column:user_id"`     // 用户ID
-	ClientID *int32    `json:"client_id" gorm:"column:client_id"` // 客户端ID
-	Method   string    `json:"method" gorm:"column:method"`       // 请求方法
-	Path     string    `json:"path" gorm:"column:path"`           // 请求路径
-	Status   int16     `json:"status" gorm:"column:status"`       // 响应状态码
-	Error    *string   `json:"error" gorm:"column:error"`         // 错误信息
-	Time     time.Time `json:"time" gorm:"column:time"`           // 请求时间
-	Latency  string    `json:"latency" gorm:"column:latency"`     // 请求延迟
+	ID       int32     `json:"id" gorm:"column:id"`                         // 访问日志ID
+	IP       orm.Inet  `json:"ip" gorm:"column:ip;not null"`                // IP地址
+	UA       string    `json:"ua" gorm:"column:ua"`                         // 用户代理
+	UserID   *int32    `json:"user_id,omitempty" gorm:"column:user_id"`     // 用户ID
+	ClientID *int32    `json:"client_id,omitempty" gorm:"column:client_id"` // 客户端ID
+	Method   string    `json:"method" gorm:"column:method"`                 // 请求方法
+	Path     string    `json:"path" gorm:"column:path"`                     // 请求路径
+	Status   int16     `json:"status" gorm:"column:status"`                 // 响应状态码
+	Error    *string   `json:"error,omitempty" gorm:"column:error"`         // 错误信息
+	Time     time.Time `json:"time" gorm:"column:time"`                     // 请求时间
+	Latency  string    `json:"latency" gorm:"column:latency"`               // 请求延迟
 
-	User   *User   `json:"user" gorm:"foreignKey:UserID"`
-	Client *Client `json:"client" gorm:"foreignKey:ClientID"`
+	User   *User   `json:"user,omitempty" gorm:"foreignKey:UserID"`
+	Client *Client `json:"client,omitempty" gorm:"foreignKey:ClientID"`
 }

web/models/logs_user_usage.go

@@ -12,9 +12,12 @@ type LogsUserUsage struct {
 	ResourceID int32     `json:"resource_id" gorm:"column:resource_id"` // 套餐ID
 	BatchNo    string    `json:"batch_no" gorm:"column:batch_no"`       // 批次编号
 	Count      int32     `json:"count" gorm:"column:count"`             // 数量
-	Prov       *string   `json:"prov" gorm:"column:prov"`               // 省份
-	City       *string   `json:"city" gorm:"column:city"`               // 城市
-	ISP        *string   `json:"isp" gorm:"column:isp"`                 // 运营商
+	Prov       *string   `json:"prov,omitempty" gorm:"column:prov"`     // 省份
+	City       *string   `json:"city,omitempty" gorm:"column:city"`     // 城市
+	ISP        *string   `json:"isp,omitempty" gorm:"column:isp"`       // 运营商
 	IP         orm.Inet  `json:"ip" gorm:"column:ip"`                   // IP地址
 	Time       time.Time `json:"time" gorm:"column:time"`               // 提取时间
+
+	User     *User     `json:"user,omitempty" gorm:"foreignKey:UserID"`
+	Resource *Resource `json:"resource,omitempty" gorm:"foreignKey:ResourceID"`
 }

web/models/permission.go

@@ -5,10 +5,11 @@ import "platform/web/core"
 // Permission 权限表
 type Permission struct {
 	core.Model
-	ParentID    *int32  `json:"parent_id" gorm:"column:parent_id"`     // 父权限ID
-	Name        string  `json:"name" gorm:"column:name"`               // 权限名称
-	Description *string `json:"description" gorm:"column:description"` // 权限描述
+	ParentID    *int32  `json:"parent_id,omitempty" gorm:"column:parent_id"`     // 父权限ID
+	Name        string  `json:"name" gorm:"column:name"`                         // 权限名称
+	Description *string `json:"description,omitempty" gorm:"column:description"` // 权限描述
+	Sort        int     `json:"sort" gorm:"column:sort"`                         // 排序
 
-	Parent   *Permission   `json:"parent" gorm:"foreignKey:ParentID"`
-	Children []*Permission `json:"children" gorm:"foreignKey:ParentID"`
+	Parent   *Permission   `json:"parent,omitempty" gorm:"foreignKey:ParentID"`
+	Children []*Permission `json:"children,omitempty" gorm:"foreignKey:ParentID"`
 }

web/models/product.go

@@ -7,11 +7,11 @@ import (
 // Product 产品表
 type Product struct {
 	core.Model
-	Code        string        `json:"code" gorm:"column:code"`               // 产品代码
-	Name        string        `json:"name" gorm:"column:name"`               // 产品名称
-	Description *string       `json:"description" gorm:"column:description"` // 产品描述
-	Sort        int32         `json:"sort" gorm:"column:sort"`               // 排序
-	Status      ProductStatus `json:"status" gorm:"column:status"`           // 产品状态：0-禁用，1-正常
+	Code        string        `json:"code" gorm:"column:code"`                         // 产品代码
+	Name        string        `json:"name" gorm:"column:name"`                         // 产品名称
+	Description *string       `json:"description,omitempty" gorm:"column:description"` // 产品描述
+	Sort        int32         `json:"sort" gorm:"column:sort"`                         // 排序
+	Status      ProductStatus `json:"status" gorm:"column:status"`                     // 产品状态：0-禁用，1-正常
 }
 
 // ProductStatus 产品状态枚举

web/models/product_discount.go

@@ -0,0 +1,19 @@
+package models
+
+import (
+	"platform/web/core"
+
+	"github.com/shopspring/decimal"
+)
+
+// ProductDiscount 产品折扣表
+type ProductDiscount struct {
+	core.Model
+	Name     string `json:"name" gorm:"column:name"`         // 产品名称
+	Discount int32  `json:"discount" gorm:"column:discount"` // 产品折扣
+}
+
+func (pd ProductDiscount) Rate() decimal.Decimal {
+	return decimal.NewFromInt32(pd.Discount).
+		Div(decimal.NewFromInt32(100))
+}

web/models/product_sku.go

@@ -0,0 +1,20 @@
+package models
+
+import (
+	"platform/web/core"
+
+	"github.com/shopspring/decimal"
+)
+
+// ProductSku 产品SKU表
+type ProductSku struct {
+	core.Model
+	ProductID  int32           `json:"product_id" gorm:"column:product_id"`   // 产品ID
+	DiscountId int32           `json:"discount_id" gorm:"column:discount_id"` // 折扣，0 - 1 的小数，表示 xx 折
+	Code       string          `json:"code" gorm:"column:code"`               // SSKU 代码：格式为 key=value,key=value,...，其中，key:value 是 SKU 的属性，多个属性用逗号分隔
+	Name       string          `json:"name" gorm:"column:name"`               // SKU 可读名称
+	Price      decimal.Decimal `json:"price" gorm:"column:price"`             // 定价
+
+	Product  *Product         `json:"product,omitempty" gorm:"foreignKey:ProductID"`
+	Discount *ProductDiscount `json:"discount,omitempty" gorm:"foreignKey:DiscountId"`
+}

web/models/product_sku_user.go

@@ -0,0 +1,19 @@
+package models
+
+import (
+	"time"
+)
+
+// ProductSkuUser 用户产品SKU表
+type ProductSkuUser struct {
+	ID           int32     `json:"id" gorm:"column:id;primaryKey"`
+	UserID       int32     `json:"user_id" gorm:"column:user_id"`               // 用户ID
+	ProductSkuID int32     `json:"product_sku_id" gorm:"column:product_sku_id"` // 产品SKU ID
+	DiscountId   int32     `json:"discount_id" gorm:"column:discount_id"`       // 折扣ID
+	CreatedAt    time.Time `json:"created_at" gorm:"column:created_at"`
+	UpdatedAt    time.Time `json:"updated_at" gorm:"column:updated_at"`
+
+	User       *User            `json:"user,omitempty" gorm:"foreignKey:UserID"`
+	ProductSku *ProductSku      `json:"product_sku,omitempty" gorm:"foreignKey:ProductSkuID"`
+	Discount   *ProductDiscount `json:"discount,omitempty" gorm:"foreignKey:DiscountId"`
+}

web/models/proxy.go

@@ -10,15 +10,16 @@ import (
 // Proxy 代理服务表
 type Proxy struct {
 	core.Model
-	Version int32                    `json:"version" gorm:"column:version"` // 代理服务版本
-	Mac     string                   `json:"mac" gorm:"column:mac"`         // 代理服务名称
-	IP      orm.Inet                 `json:"ip" gorm:"column:ip;not null"`  // 代理服务地址
-	Secret  *string                  `json:"secret" gorm:"column:secret"`   // 代理服务密钥
-	Type    ProxyType                `json:"type" gorm:"column:type"`       // 代理服务类型：1-自有，2-白银
-	Status  ProxyStatus              `json:"status" gorm:"column:status"`   // 代理服务状态：0-离线，1-在线
-	Meta    *datatypes.JSONType[any] `json:"meta" gorm:"column:meta"`       // 代理服务元信息
+	Version int32                    `json:"version" gorm:"column:version"`         // 代理服务版本
+	Mac     string                   `json:"mac" gorm:"column:mac"`                 // 代理服务名称
+	IP      orm.Inet                 `json:"ip" gorm:"column:ip;not null"`          // 代理服务地址
+	Host    *string                  `json:"host,omitempty" gorm:"column:host"`     // 代理服务域名
+	Secret  *string                  `json:"secret,omitempty" gorm:"column:secret"` // 代理服务密钥
+	Type    ProxyType                `json:"type" gorm:"column:type"`               // 代理服务类型：1-自有，2-白银
+	Status  ProxyStatus              `json:"status" gorm:"column:status"`           // 代理服务状态：0-离线，1-在线
+	Meta    *datatypes.JSONType[any] `json:"meta,omitempty" gorm:"column:meta"`     // 代理服务元信息
 
-	Channels []Channel `json:"channels" gorm:"foreignkey:ProxyID"`
+	Channels []Channel `json:"channels,omitempty" gorm:"foreignkey:ProxyID"`
 }
 
 // ProxyType 代理服务类型枚举

web/models/refund.go

@@ -9,11 +9,11 @@ import (
 // Refund 退款记录表
 type Refund struct {
 	core.Model
-	TradeID   int32           `json:"trade_id" gorm:"column:trade_id"`     // 订单ID
-	ProductID *int32          `json:"product_id" gorm:"column:product_id"` // 产品ID
-	Amount    decimal.Decimal `json:"amount" gorm:"column:amount"`         // 退款金额
-	Reason    *string         `json:"reason" gorm:"column:reason"`         // 退款原因
-	Status    RefundStatus    `json:"status" gorm:"column:status"`         // 退款状态：0-待处理，1-已退款，2-已拒绝
+	TradeID   int32           `json:"trade_id" gorm:"column:trade_id"`               // 订单ID
+	ProductID *int32          `json:"product_id,omitempty" gorm:"column:product_id"` // 产品ID
+	Amount    decimal.Decimal `json:"amount" gorm:"column:amount"`                   // 退款金额
+	Reason    *string         `json:"reason,omitempty" gorm:"column:reason"`         // 退款原因
+	Status    RefundStatus    `json:"status" gorm:"column:status"`                   // 退款状态：0-待处理，1-已退款，2-已拒绝
 }
 
 // RefundStatus 退款状态枚举

web/models/resource.go

@@ -7,14 +7,16 @@ import (
 // Resource 套餐表
 type Resource struct {
 	core.Model
-	UserID     int32        `json:"user_id" gorm:"column:user_id"`         // 用户ID
-	ResourceNo *string      `json:"resource_no" gorm:"column:resource_no"` // 套餐编号
-	Active     bool         `json:"active" gorm:"column:active"`           // 套餐状态
-	Type       ResourceType `json:"type" gorm:"column:type"`               // 套餐类型：1-短效动态，2-长效动态
+	UserID     int32        `json:"user_id" gorm:"column:user_id"`                   // 用户ID
+	ResourceNo *string      `json:"resource_no,omitempty" gorm:"column:resource_no"` // 套餐编号
+	Active     bool         `json:"active" gorm:"column:active"`                     // 套餐状态
+	Type       ResourceType `json:"type" gorm:"column:type"`                         // 套餐类型：1-短效动态，2-长效动态
+	Code       string       `json:"code" gorm:"column:code"`                         // 产品编码
 
-	User  User           `json:"user" gorm:"foreignKey:UserID"`
-	Short *ResourceShort `json:"short" gorm:"foreignKey:ResourceID"`
-	Long  *ResourceLong  `json:"long" gorm:"foreignKey:ResourceID"`
+	User    *User          `json:"user,omitempty" gorm:"foreignKey:UserID"`
+	Short   *ResourceShort `json:"short,omitempty" gorm:"foreignKey:ResourceID"`
+	Long    *ResourceLong  `json:"long,omitempty" gorm:"foreignKey:ResourceID"`
+	Product *Product       `json:"product,omitempty" gorm:"foreignKey:Code;references:Code"`
 }
 
 // ResourceType 套餐类型枚举
@@ -25,10 +27,32 @@ const (
 	ResourceTypeLong  ResourceType = 2 // 长效动态
 )
 
-// ResourceLongType 套餐计费模式枚举
+func (t ResourceType) Code() string {
+	switch t {
+	case ResourceTypeShort:
+		return "short"
+	case ResourceTypeLong:
+		return "long"
+	default:
+		return "unknown"
+	}
+}
+
+// ResourceMode 套餐计费模式枚举
 type ResourceMode int
 
 const (
 	ResourceModeTime  ResourceMode = 1 // 包时
 	ResourceModeQuota ResourceMode = 2 // 包量
 )
+
+func (m ResourceMode) Code() string {
+	switch m {
+	case ResourceModeTime:
+		return "time"
+	case ResourceModeQuota:
+		return "quota"
+	default:
+		return "unknown"
+	}
+}

web/models/resource_long.go

@@ -6,14 +6,16 @@ import (
 
 // ResourceLong 长效动态套餐表
 type ResourceLong struct {
-	ID         int32        `json:"id" gorm:"column:id"`                   // ID
-	ResourceID int32        `json:"resource_id" gorm:"column:resource_id"` // 套餐ID
-	Type       ResourceMode `json:"type" gorm:"column:type"`               // 套餐类型：1-包时，2-包量
-	Live       int32        `json:"live" gorm:"column:live"`               // 可用时长(天)
-	Expire     *time.Time   `json:"expire" gorm:"column:expire"`           // 过期时间
-	Quota      *int32       `json:"quota" gorm:"column:quota"`             // 配额数量
-	Used       int32        `json:"used" gorm:"column:used"`               // 已用数量
-	DailyLimit int32        `json:"daily_limit" gorm:"column:daily_limit"` // 每日限制
-	DailyUsed  int32        `json:"daily_used" gorm:"column:daily_used"`   // 今日已用数量
-	DailyLast  *time.Time   `json:"daily_last" gorm:"column:daily_last"`   // 今日最后使用时间
+	ID         int32        `json:"id" gorm:"column:id"`                         // ID
+	ResourceID int32        `json:"resource_id" gorm:"column:resource_id"`       // 套餐ID
+	Code       string       `json:"code" gorm:"column:code"`                     // 套餐编码
+	Live       int32        `json:"live" gorm:"column:live"`                     // 可用时长(小时)
+	Type       ResourceMode `json:"type" gorm:"column:type"`                     // 套餐类型：1-包时，2-包量
+	Quota      int32        `json:"quota" gorm:"column:quota"`                   // 每日配额（包时）或总配额（包量）
+	ExpireAt   *time.Time   `json:"expire_at,omitempty" gorm:"column:expire_at"` // 套餐过期时间，包时模式可用
+	Used       int32        `json:"used" gorm:"column:used"`                     // 总用量
+	Daily      int32        `json:"daily" gorm:"column:daily"`                   // 当日用量
+	LastAt     *time.Time   `json:"last_at,omitempty" gorm:"column:last_at"`     // 最后使用时间
+
+	Sku *ProductSku `json:"sku,omitempty" gorm:"foreignKey:Code;references:Code"`
 }

web/models/resource_short.go

@@ -6,14 +6,16 @@ import (
 
 // ResourceShort 短效动态套餐表
 type ResourceShort struct {
-	ID         int32        `json:"id" gorm:"column:id"`                   // ID
-	ResourceID int32        `json:"resource_id" gorm:"column:resource_id"` // 套餐ID
-	Type       ResourceMode `json:"type" gorm:"column:type"`               // 套餐类型：1-包时，2-包量
-	Live       int32        `json:"live" gorm:"column:live"`               // 可用时长(秒)
-	Expire     *time.Time   `json:"expire" gorm:"column:expire"`           // 过期时间
-	Quota      *int32       `json:"quota" gorm:"column:quota"`             // 配额数量
-	Used       int32        `json:"used" gorm:"column:used"`               // 已用数量
-	DailyLimit int32        `json:"daily_limit" gorm:"column:daily_limit"` // 每日限制
-	DailyUsed  int32        `json:"daily_used" gorm:"column:daily_used"`   // 今日已用数量
-	DailyLast  *time.Time   `json:"daily_last" gorm:"column:daily_last"`   // 今日最后使用时间
+	ID         int32        `json:"id" gorm:"column:id"`                         // ID
+	ResourceID int32        `json:"resource_id" gorm:"column:resource_id"`       // 套餐ID
+	Code       string       `json:"code" gorm:"column:code"`                     // 套餐编码
+	Live       int32        `json:"live" gorm:"column:live"`                     // 可用时长(秒)
+	Type       ResourceMode `json:"type" gorm:"column:type"`                     // 套餐类型：1-包时，2-包量
+	Quota      int32        `json:"quota" gorm:"column:quota"`                   // 每日配额（包时）或总配额（包量）
+	ExpireAt   *time.Time   `json:"expire_at,omitempty" gorm:"column:expire_at"` // 套餐过期时间，包时模式可用
+	Used       int32        `json:"used" gorm:"column:used"`                     // 总用量
+	Daily      int32        `json:"daily" gorm:"column:daily"`                   // 当日用量
+	LastAt     *time.Time   `json:"last_at,omitempty" gorm:"column:last_at"`     // 最后使用时间
+
+	Sku *ProductSku `json:"sku,omitempty" gorm:"foreignKey:Code;references:Code"`
 }

web/models/session.go

@@ -9,18 +9,18 @@ import (
 // Session 会话表
 type Session struct {
 	core.Model
-	UserID              *int32     `json:"user_id" gorm:"column:user_id"`                             // 用户ID
-	AdminID             *int32     `json:"admin_id" gorm:"column:admin_id"`                           // 管理员ID
-	ClientID            *int32     `json:"client_id" gorm:"column:client_id"`                         // 客户端ID
-	IP                  *orm.Inet  `json:"ip" gorm:"column:ip"`                                       // IP地址
-	UA                  *string    `json:"ua" gorm:"column:ua"`                                       // 用户代理
-	AccessToken         string     `json:"access_token" gorm:"column:access_token"`                   // 访问令牌
-	AccessTokenExpires  time.Time  `json:"access_token_expires" gorm:"column:access_token_expires"`   // 访问令牌过期时间
-	RefreshToken        *string    `json:"refresh_token" gorm:"column:refresh_token"`                 // 刷新令牌
-	RefreshTokenExpires *time.Time `json:"refresh_token_expires" gorm:"column:refresh_token_expires"` // 刷新令牌过期时间
-	Scopes              *string    `json:"scopes" gorm:"column:scopes"`                               // 权限范围
+	UserID              *int32     `json:"user_id,omitempty" gorm:"column:user_id"`                             // 用户ID
+	AdminID             *int32     `json:"admin_id,omitempty" gorm:"column:admin_id"`                           // 管理员ID
+	ClientID            *int32     `json:"client_id,omitempty" gorm:"column:client_id"`                         // 客户端ID
+	IP                  *orm.Inet  `json:"ip,omitempty" gorm:"column:ip"`                                       // IP地址
+	UA                  *string    `json:"ua,omitempty" gorm:"column:ua"`                                       // 用户代理
+	AccessToken         string     `json:"access_token" gorm:"column:access_token"`                             // 访问令牌
+	AccessTokenExpires  time.Time  `json:"access_token_expires" gorm:"column:access_token_expires"`             // 访问令牌过期时间
+	RefreshToken        *string    `json:"refresh_token,omitempty" gorm:"column:refresh_token"`                 // 刷新令牌
+	RefreshTokenExpires *time.Time `json:"refresh_token_expires,omitempty" gorm:"column:refresh_token_expires"` // 刷新令牌过期时间
+	Scopes              *string    `json:"scopes,omitempty" gorm:"column:scopes"`                               // 权限范围
 
-	User   *User   `json:"user" gorm:"foreignKey:UserID"`
-	Admin  *Admin  `json:"admin" gorm:"foreignKey:AdminID"`
-	Client *Client `json:"client" gorm:"foreignKey:ClientID;belongsTo:ID"`
+	User   *User   `json:"user,omitempty" gorm:"foreignKey:UserID"`
+	Admin  *Admin  `json:"admin,omitempty" gorm:"foreignKey:AdminID"`
+	Client *Client `json:"client,omitempty" gorm:"foreignKey:ClientID;belongsTo:ID"`
 }

web/models/trade.go

@@ -10,22 +10,24 @@ import (
 // Trade 订单表
 type Trade struct {
 	core.Model
-	UserID      int32           `json:"user_id" gorm:"column:user_id"`           // 用户ID
-	InnerNo     string          `json:"inner_no" gorm:"column:inner_no"`         // 内部订单号
-	OuterNo     *string         `json:"outer_no" gorm:"column:outer_no"`         // 外部订单号
-	Type        TradeType       `json:"type" gorm:"column:type"`                 // 订单类型：1-购买产品，2-充值余额
-	Subject     string          `json:"subject" gorm:"column:subject"`           // 订单主题
-	Remark      *string         `json:"remark" gorm:"column:remark"`             // 订单备注
-	Amount      decimal.Decimal `json:"amount" gorm:"column:amount"`             // 订单总金额
-	Payment     decimal.Decimal `json:"payment" gorm:"column:payment"`           // 实际支付金额
-	Method      TradeMethod     `json:"method" gorm:"column:method"`             // 支付方式：1-支付宝，2-微信，3-商福通，4-商福通渠道支付宝，5-商福通渠道微信
-	Platform    TradePlatform   `json:"platform" gorm:"column:platform"`         // 支付平台：1-电脑网站，2-手机网站
-	Acquirer    *TradeAcquirer  `json:"acquirer" gorm:"column:acquirer"`         // 收单机构：1-支付宝，2-微信，3-银联
-	Status      TradeStatus     `json:"status" gorm:"column:status"`             // 订单状态：0-待支付，1-已支付，2-已取消
-	Refunded    bool            `json:"refunded" gorm:"column:refunded"`         // 是否已退款
-	PaymentURL  *string         `json:"payment_url" gorm:"column:payment_url"`   // 支付链接
-	CompletedAt *time.Time      `json:"completed_at" gorm:"column:completed_at"` // 支付时间
-	CanceledAt  *time.Time      `json:"canceled_at" gorm:"column:canceled_at"`   // 取消时间
+	UserID      int32           `json:"user_id" gorm:"column:user_id"`                     // 用户ID
+	InnerNo     string          `json:"inner_no" gorm:"column:inner_no"`                   // 内部订单号
+	OuterNo     *string         `json:"outer_no,omitempty" gorm:"column:outer_no"`         // 外部订单号
+	Type        TradeType       `json:"type" gorm:"column:type"`                           // 订单类型：1-购买产品，2-充值余额
+	Subject     string          `json:"subject" gorm:"column:subject"`                     // 订单主题
+	Remark      *string         `json:"remark,omitempty" gorm:"column:remark"`             // 订单备注
+	Amount      decimal.Decimal `json:"amount" gorm:"column:amount"`                       // 订单总金额
+	Payment     decimal.Decimal `json:"payment" gorm:"column:payment"`                     // 实际支付金额
+	Method      TradeMethod     `json:"method" gorm:"column:method"`                       // 支付方式：1-支付宝，2-微信，3-商福通，4-商福通渠道支付宝，5-商福通渠道微信
+	Platform    TradePlatform   `json:"platform" gorm:"column:platform"`                   // 支付平台：1-电脑网站，2-手机网站
+	Acquirer    *TradeAcquirer  `json:"acquirer,omitempty" gorm:"column:acquirer"`         // 收单机构：1-支付宝，2-微信，3-银联
+	Status      TradeStatus     `json:"status" gorm:"column:status"`                       // 订单状态：0-待支付，1-已支付，2-已取消
+	Refunded    bool            `json:"refunded" gorm:"column:refunded"`                   // 是否已退款
+	PaymentURL  *string         `json:"payment_url,omitempty" gorm:"column:payment_url"`   // 支付链接
+	CompletedAt *time.Time      `json:"completed_at,omitempty" gorm:"column:completed_at"` // 支付时间
+	CanceledAt  *time.Time      `json:"canceled_at,omitempty" gorm:"column:canceled_at"`   // 取消时间
+
+	User *User `json:"user,omitempty" gorm:"foreignKey:UserID"`
 }
 
 // TradeType 订单类型枚举

web/models/user.go

@@ -11,25 +11,29 @@ import (
 // User 用户表
 type User struct {
 	core.Model
-	AdminID       *int32          `json:"admin_id" gorm:"column:admin_id"`             // 管理员ID
-	Phone         string          `json:"phone" gorm:"column:phone"`                   // 手机号码
-	Username      *string         `json:"username" gorm:"column:username"`             // 用户名
-	Email         *string         `json:"email" gorm:"column:email"`                   // 邮箱
-	Password      *string         `json:"password" gorm:"column:password"`             // 用户密码
-	Name          *string         `json:"name" gorm:"column:name"`                     // 真实姓名
-	Avatar        *string         `json:"avatar" gorm:"column:avatar"`                 // 头像URL
-	Status        UserStatus      `json:"status" gorm:"column:status"`                 // 用户状态：0-禁用，1-正常
-	Balance       decimal.Decimal `json:"balance" gorm:"column:balance"`               // 账户余额
-	IDType        UserIDType      `json:"id_type" gorm:"column:id_type"`               // 认证类型：0-未认证，1-个人认证，2-企业认证
-	IDNo          *string         `json:"id_no" gorm:"column:id_no"`                   // 身份证号或营业执照号
-	IDToken       *string         `json:"id_token" gorm:"column:id_token"`             // 身份验证标识
-	ContactQQ     *string         `json:"contact_qq" gorm:"column:contact_qq"`         // QQ联系方式
-	ContactWechat *string         `json:"contact_wechat" gorm:"column:contact_wechat"` // 微信联系方式
-	LastLogin     *time.Time      `json:"last_login" gorm:"column:last_login"`         // 最后登录时间
-	LastLoginIP   *orm.Inet       `json:"last_login_ip" gorm:"column:last_login_ip"`   // 最后登录地址
-	LastLoginUA   *string         `json:"last_login_ua" gorm:"column:last_login_ua"`   // 最后登录代理
+	AdminID       *int32          `json:"admin_id,omitempty" gorm:"column:admin_id"`             // 管理员ID
+	DiscountID    *int32          `json:"discount_id,omitempty" gorm:"column:discount_id"`       // 折扣ID
+	Phone         string          `json:"phone" gorm:"column:phone"`                             // 手机号码
+	Username      *string         `json:"username,omitempty" gorm:"column:username"`             // 用户名
+	Email         *string         `json:"email,omitempty" gorm:"column:email"`                   // 邮箱
+	Password      *string         `json:"password,omitempty" gorm:"column:password"`             // 用户密码
+	Source        *UserSource     `json:"source,omitempty" gorm:"column:source"`                 // 用户来源：0-官网注册，1-管理员添加，2-代理商注册，3-代理商添加
+	Name          *string         `json:"name,omitempty" gorm:"column:name"`                     // 真实姓名
+	Avatar        *string         `json:"avatar,omitempty" gorm:"column:avatar"`                 // 头像URL
+	Status        UserStatus      `json:"status" gorm:"column:status"`                           // 用户状态：0-禁用，1-正常
+	Balance       decimal.Decimal `json:"balance" gorm:"column:balance"`                         // 账户余额
+	IDType        UserIDType      `json:"id_type" gorm:"column:id_type"`                         // 认证类型：0-未认证，1-个人认证，2-企业认证
+	IDNo          *string         `json:"id_no,omitempty" gorm:"column:id_no"`                   // 身份证号或营业执照号
+	IDToken       *string         `json:"id_token,omitempty" gorm:"column:id_token"`             // 身份验证标识
+	ContactQQ     *string         `json:"contact_qq,omitempty" gorm:"column:contact_qq"`         // QQ联系方式
+	ContactWechat *string         `json:"contact_wechat,omitempty" gorm:"column:contact_wechat"` // 微信联系方式
+	LastLogin     *time.Time      `json:"last_login,omitempty" gorm:"column:last_login"`         // 最后登录时间
+	LastLoginIP   *orm.Inet       `json:"last_login_ip,omitempty" gorm:"column:last_login_ip"`   // 最后登录地址
+	LastLoginUA   *string         `json:"last_login_ua,omitempty" gorm:"column:last_login_ua"`   // 最后登录代理
 
-	Admin Admin `json:"admin" gorm:"foreignKey:AdminID"`
+	Admin    *Admin           `json:"admin,omitempty" gorm:"foreignKey:AdminID"`
+	Roles    []*UserRole      `json:"roles" gorm:"many2many:link_user_role"`
+	Discount *ProductDiscount `json:"discount,omitempty" gorm:"foreignKey:DiscountID"`
 }
 
 // UserStatus 用户状态枚举
@@ -48,3 +52,13 @@ const (
 	UserIDTypePersonal   UserIDType = 1 // 个人认证
 	UserIDTypeEnterprise UserIDType = 2 // 企业认证
 )
+
+// UserSource 用户来源枚举
+type UserSource int
+
+const (
+	UserSourceReg      UserSource = 0 // 官网注册
+	UserSourceAdd      UserSource = 1 // 管理员添加
+	UserSourceAgentReg UserSource = 2 // 代理商注册
+	UserSourceAgentAdd UserSource = 3 // 代理商添加
+)

web/models/user_role.go

@@ -7,8 +7,10 @@ import (
 // UserRole 用户角色表
 type UserRole struct {
 	core.Model
-	Name        string  `json:"name" gorm:"column:name"`               // 角色名称
-	Description *string `json:"description" gorm:"column:description"` // 角色描述
-	Active      bool    `json:"active" gorm:"column:active"`           // 是否激活
-	Sort        int32   `json:"sort" gorm:"column:sort"`               // 排序
+	Name        string  `json:"name" gorm:"column:name"`                         // 角色名称
+	Description *string `json:"description,omitempty" gorm:"column:description"` // 角色描述
+	Active      bool    `json:"active" gorm:"column:active"`                     // 是否激活
+	Sort        int32   `json:"sort" gorm:"column:sort"`                         // 排序
+
+	Permissions []*Permission `json:"permissions" gorm:"many2many:link_user_role_permission"`
 }

web/models/whitelist.go

@@ -8,7 +8,7 @@ import (
 // Whitelist 白名单表
 type Whitelist struct {
 	core.Model
-	UserID int32    `json:"user_id" gorm:"column:user_id"` // 用户ID
-	IP     orm.Inet `json:"ip" gorm:"column:ip;not null"`  // IP地址
-	Remark *string  `json:"remark" gorm:"column:remark"`   // 备注
+	UserID int32    `json:"user_id" gorm:"column:user_id"`         // 用户ID
+	IP     orm.Inet `json:"ip" gorm:"column:ip;not null"`          // IP地址
+	Remark *string  `json:"remark,omitempty" gorm:"column:remark"` // 备注
 }

web/queries/admin.gen.go

@@ -41,6 +41,32 @@ func newAdmin(db *gorm.DB, opts ...gen.DOOption) admin {
 	_admin.LastLogin = field.NewTime(tableName, "last_login")
 	_admin.LastLoginIP = field.NewField(tableName, "last_login_ip")
 	_admin.LastLoginUA = field.NewString(tableName, "last_login_ua")
+	_admin.Roles = adminManyToManyRoles{
+		db: db.Session(&gorm.Session{}),
+
+		RelationField: field.NewRelation("Roles", "models.AdminRole"),
+		Permissions: struct {
+			field.RelationField
+			Parent struct {
+				field.RelationField
+			}
+			Children struct {
+				field.RelationField
+			}
+		}{
+			RelationField: field.NewRelation("Roles.Permissions", "models.Permission"),
+			Parent: struct {
+				field.RelationField
+			}{
+				RelationField: field.NewRelation("Roles.Permissions.Parent", "models.Permission"),
+			},
+			Children: struct {
+				field.RelationField
+			}{
+				RelationField: field.NewRelation("Roles.Permissions.Children", "models.Permission"),
+			},
+		},
+	}
 
 	_admin.fillFieldMap()
 
@@ -65,6 +91,7 @@ type admin struct {
 	LastLogin   field.Time
 	LastLoginIP field.Field
 	LastLoginUA field.String
+	Roles       adminManyToManyRoles
 
 	fieldMap map[string]field.Expr
 }
@@ -111,7 +138,7 @@ func (a *admin) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
 }
 
 func (a *admin) fillFieldMap() {
-	a.fieldMap = make(map[string]field.Expr, 14)
+	a.fieldMap = make(map[string]field.Expr, 15)
 	a.fieldMap["id"] = a.ID
 	a.fieldMap["created_at"] = a.CreatedAt
 	a.fieldMap["updated_at"] = a.UpdatedAt
@@ -126,18 +153,113 @@ func (a *admin) fillFieldMap() {
 	a.fieldMap["last_login"] = a.LastLogin
 	a.fieldMap["last_login_ip"] = a.LastLoginIP
 	a.fieldMap["last_login_ua"] = a.LastLoginUA
+
 }
 
 func (a admin) clone(db *gorm.DB) admin {
 	a.adminDo.ReplaceConnPool(db.Statement.ConnPool)
+	a.Roles.db = db.Session(&gorm.Session{Initialized: true})
+	a.Roles.db.Statement.ConnPool = db.Statement.ConnPool
 	return a
 }
 
 func (a admin) replaceDB(db *gorm.DB) admin {
 	a.adminDo.ReplaceDB(db)
+	a.Roles.db = db.Session(&gorm.Session{})
 	return a
 }
 
+type adminManyToManyRoles struct {
+	db *gorm.DB
+
+	field.RelationField
+
+	Permissions struct {
+		field.RelationField
+		Parent struct {
+			field.RelationField
+		}
+		Children struct {
+			field.RelationField
+		}
+	}
+}
+
+func (a adminManyToManyRoles) Where(conds ...field.Expr) *adminManyToManyRoles {
+	if len(conds) == 0 {
+		return &a
+	}
+
+	exprs := make([]clause.Expression, 0, len(conds))
+	for _, cond := range conds {
+		exprs = append(exprs, cond.BeCond().(clause.Expression))
+	}
+	a.db = a.db.Clauses(clause.Where{Exprs: exprs})
+	return &a
+}
+
+func (a adminManyToManyRoles) WithContext(ctx context.Context) *adminManyToManyRoles {
+	a.db = a.db.WithContext(ctx)
+	return &a
+}
+
+func (a adminManyToManyRoles) Session(session *gorm.Session) *adminManyToManyRoles {
+	a.db = a.db.Session(session)
+	return &a
+}
+
+func (a adminManyToManyRoles) Model(m *models.Admin) *adminManyToManyRolesTx {
+	return &adminManyToManyRolesTx{a.db.Model(m).Association(a.Name())}
+}
+
+func (a adminManyToManyRoles) Unscoped() *adminManyToManyRoles {
+	a.db = a.db.Unscoped()
+	return &a
+}
+
+type adminManyToManyRolesTx struct{ tx *gorm.Association }
+
+func (a adminManyToManyRolesTx) Find() (result []*models.AdminRole, err error) {
+	return result, a.tx.Find(&result)
+}
+
+func (a adminManyToManyRolesTx) Append(values ...*models.AdminRole) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Append(targetValues...)
+}
+
+func (a adminManyToManyRolesTx) Replace(values ...*models.AdminRole) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Replace(targetValues...)
+}
+
+func (a adminManyToManyRolesTx) Delete(values ...*models.AdminRole) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Delete(targetValues...)
+}
+
+func (a adminManyToManyRolesTx) Clear() error {
+	return a.tx.Clear()
+}
+
+func (a adminManyToManyRolesTx) Count() int64 {
+	return a.tx.Count()
+}
+
+func (a adminManyToManyRolesTx) Unscoped() *adminManyToManyRolesTx {
+	a.tx = a.tx.Unscoped()
+	return &a
+}
+
 type adminDo struct{ gen.DO }
 
 func (a adminDo) Debug() *adminDo {

web/queries/admin_role.gen.go

@@ -35,6 +35,21 @@ func newAdminRole(db *gorm.DB, opts ...gen.DOOption) adminRole {
 	_adminRole.Description = field.NewString(tableName, "description")
 	_adminRole.Active = field.NewBool(tableName, "active")
 	_adminRole.Sort = field.NewInt32(tableName, "sort")
+	_adminRole.Permissions = adminRoleManyToManyPermissions{
+		db: db.Session(&gorm.Session{}),
+
+		RelationField: field.NewRelation("Permissions", "models.Permission"),
+		Parent: struct {
+			field.RelationField
+		}{
+			RelationField: field.NewRelation("Permissions.Parent", "models.Permission"),
+		},
+		Children: struct {
+			field.RelationField
+		}{
+			RelationField: field.NewRelation("Permissions.Children", "models.Permission"),
+		},
+	}
 
 	_adminRole.fillFieldMap()
 
@@ -53,6 +68,7 @@ type adminRole struct {
 	Description field.String
 	Active      field.Bool
 	Sort        field.Int32
+	Permissions adminRoleManyToManyPermissions
 
 	fieldMap map[string]field.Expr
 }
@@ -93,7 +109,7 @@ func (a *adminRole) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
 }
 
 func (a *adminRole) fillFieldMap() {
-	a.fieldMap = make(map[string]field.Expr, 8)
+	a.fieldMap = make(map[string]field.Expr, 9)
 	a.fieldMap["id"] = a.ID
 	a.fieldMap["created_at"] = a.CreatedAt
 	a.fieldMap["updated_at"] = a.UpdatedAt
@@ -102,18 +118,110 @@ func (a *adminRole) fillFieldMap() {
 	a.fieldMap["description"] = a.Description
 	a.fieldMap["active"] = a.Active
 	a.fieldMap["sort"] = a.Sort
+
 }
 
 func (a adminRole) clone(db *gorm.DB) adminRole {
 	a.adminRoleDo.ReplaceConnPool(db.Statement.ConnPool)
+	a.Permissions.db = db.Session(&gorm.Session{Initialized: true})
+	a.Permissions.db.Statement.ConnPool = db.Statement.ConnPool
 	return a
 }
 
 func (a adminRole) replaceDB(db *gorm.DB) adminRole {
 	a.adminRoleDo.ReplaceDB(db)
+	a.Permissions.db = db.Session(&gorm.Session{})
 	return a
 }
 
+type adminRoleManyToManyPermissions struct {
+	db *gorm.DB
+
+	field.RelationField
+
+	Parent struct {
+		field.RelationField
+	}
+	Children struct {
+		field.RelationField
+	}
+}
+
+func (a adminRoleManyToManyPermissions) Where(conds ...field.Expr) *adminRoleManyToManyPermissions {
+	if len(conds) == 0 {
+		return &a
+	}
+
+	exprs := make([]clause.Expression, 0, len(conds))
+	for _, cond := range conds {
+		exprs = append(exprs, cond.BeCond().(clause.Expression))
+	}
+	a.db = a.db.Clauses(clause.Where{Exprs: exprs})
+	return &a
+}
+
+func (a adminRoleManyToManyPermissions) WithContext(ctx context.Context) *adminRoleManyToManyPermissions {
+	a.db = a.db.WithContext(ctx)
+	return &a
+}
+
+func (a adminRoleManyToManyPermissions) Session(session *gorm.Session) *adminRoleManyToManyPermissions {
+	a.db = a.db.Session(session)
+	return &a
+}
+
+func (a adminRoleManyToManyPermissions) Model(m *models.AdminRole) *adminRoleManyToManyPermissionsTx {
+	return &adminRoleManyToManyPermissionsTx{a.db.Model(m).Association(a.Name())}
+}
+
+func (a adminRoleManyToManyPermissions) Unscoped() *adminRoleManyToManyPermissions {
+	a.db = a.db.Unscoped()
+	return &a
+}
+
+type adminRoleManyToManyPermissionsTx struct{ tx *gorm.Association }
+
+func (a adminRoleManyToManyPermissionsTx) Find() (result []*models.Permission, err error) {
+	return result, a.tx.Find(&result)
+}
+
+func (a adminRoleManyToManyPermissionsTx) Append(values ...*models.Permission) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Append(targetValues...)
+}
+
+func (a adminRoleManyToManyPermissionsTx) Replace(values ...*models.Permission) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Replace(targetValues...)
+}
+
+func (a adminRoleManyToManyPermissionsTx) Delete(values ...*models.Permission) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Delete(targetValues...)
+}
+
+func (a adminRoleManyToManyPermissionsTx) Clear() error {
+	return a.tx.Clear()
+}
+
+func (a adminRoleManyToManyPermissionsTx) Count() int64 {
+	return a.tx.Count()
+}
+
+func (a adminRoleManyToManyPermissionsTx) Unscoped() *adminRoleManyToManyPermissionsTx {
+	a.tx = a.tx.Unscoped()
+	return &a
+}
+
 type adminRoleDo struct{ gen.DO }
 
 func (a adminRoleDo) Debug() *adminRoleDo {

web/queries/balance_activity.gen.go

@@ -0,0 +1,871 @@
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+
+package queries
+
+import (
+	"context"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"platform/web/models"
+)
+
+func newBalanceActivity(db *gorm.DB, opts ...gen.DOOption) balanceActivity {
+	_balanceActivity := balanceActivity{}
+
+	_balanceActivity.balanceActivityDo.UseDB(db, opts...)
+	_balanceActivity.balanceActivityDo.UseModel(&models.BalanceActivity{})
+
+	tableName := _balanceActivity.balanceActivityDo.TableName()
+	_balanceActivity.ALL = field.NewAsterisk(tableName)
+	_balanceActivity.ID = field.NewInt32(tableName, "id")
+	_balanceActivity.UserID = field.NewInt32(tableName, "user_id")
+	_balanceActivity.BillID = field.NewInt32(tableName, "bill_id")
+	_balanceActivity.AdminID = field.NewInt32(tableName, "admin_id")
+	_balanceActivity.Amount = field.NewString(tableName, "amount")
+	_balanceActivity.BalancePrev = field.NewString(tableName, "balance_prev")
+	_balanceActivity.BalanceCurr = field.NewString(tableName, "balance_curr")
+	_balanceActivity.Remark = field.NewString(tableName, "remark")
+	_balanceActivity.CreatedAt = field.NewTime(tableName, "created_at")
+	_balanceActivity.Admin = balanceActivityHasOneAdmin{
+		db: db.Session(&gorm.Session{}),
+
+		RelationField: field.NewRelation("Admin", "models.User"),
+		Admin: struct {
+			field.RelationField
+			Roles struct {
+				field.RelationField
+				Permissions struct {
+					field.RelationField
+					Parent struct {
+						field.RelationField
+					}
+					Children struct {
+						field.RelationField
+					}
+				}
+			}
+		}{
+			RelationField: field.NewRelation("Admin.Admin", "models.Admin"),
+			Roles: struct {
+				field.RelationField
+				Permissions struct {
+					field.RelationField
+					Parent struct {
+						field.RelationField
+					}
+					Children struct {
+						field.RelationField
+					}
+				}
+			}{
+				RelationField: field.NewRelation("Admin.Admin.Roles", "models.AdminRole"),
+				Permissions: struct {
+					field.RelationField
+					Parent struct {
+						field.RelationField
+					}
+					Children struct {
+						field.RelationField
+					}
+				}{
+					RelationField: field.NewRelation("Admin.Admin.Roles.Permissions", "models.Permission"),
+					Parent: struct {
+						field.RelationField
+					}{
+						RelationField: field.NewRelation("Admin.Admin.Roles.Permissions.Parent", "models.Permission"),
+					},
+					Children: struct {
+						field.RelationField
+					}{
+						RelationField: field.NewRelation("Admin.Admin.Roles.Permissions.Children", "models.Permission"),
+					},
+				},
+			},
+		},
+		Discount: struct {
+			field.RelationField
+		}{
+			RelationField: field.NewRelation("Admin.Discount", "models.ProductDiscount"),
+		},
+		Roles: struct {
+			field.RelationField
+			Permissions struct {
+				field.RelationField
+			}
+		}{
+			RelationField: field.NewRelation("Admin.Roles", "models.UserRole"),
+			Permissions: struct {
+				field.RelationField
+			}{
+				RelationField: field.NewRelation("Admin.Roles.Permissions", "models.Permission"),
+			},
+		},
+	}
+
+	_balanceActivity.User = balanceActivityBelongsToUser{
+		db: db.Session(&gorm.Session{}),
+
+		RelationField: field.NewRelation("User", "models.User"),
+	}
+
+	_balanceActivity.Bill = balanceActivityBelongsToBill{
+		db: db.Session(&gorm.Session{}),
+
+		RelationField: field.NewRelation("Bill", "models.Bill"),
+		User: struct {
+			field.RelationField
+		}{
+			RelationField: field.NewRelation("Bill.User", "models.User"),
+		},
+		Trade: struct {
+			field.RelationField
+			User struct {
+				field.RelationField
+			}
+		}{
+			RelationField: field.NewRelation("Bill.Trade", "models.Trade"),
+			User: struct {
+				field.RelationField
+			}{
+				RelationField: field.NewRelation("Bill.Trade.User", "models.User"),
+			},
+		},
+		Resource: struct {
+			field.RelationField
+			User struct {
+				field.RelationField
+			}
+			Short struct {
+				field.RelationField
+				Sku struct {
+					field.RelationField
+					Product struct {
+						field.RelationField
+					}
+					Discount struct {
+						field.RelationField
+					}
+				}
+			}
+			Long struct {
+				field.RelationField
+				Sku struct {
+					field.RelationField
+				}
+			}
+			Product struct {
+				field.RelationField
+			}
+		}{
+			RelationField: field.NewRelation("Bill.Resource", "models.Resource"),
+			User: struct {
+				field.RelationField
+			}{
+				RelationField: field.NewRelation("Bill.Resource.User", "models.User"),
+			},
+			Short: struct {
+				field.RelationField
+				Sku struct {
+					field.RelationField
+					Product struct {
+						field.RelationField
+					}
+					Discount struct {
+						field.RelationField
+					}
+				}
+			}{
+				RelationField: field.NewRelation("Bill.Resource.Short", "models.ResourceShort"),
+				Sku: struct {
+					field.RelationField
+					Product struct {
+						field.RelationField
+					}
+					Discount struct {
+						field.RelationField
+					}
+				}{
+					RelationField: field.NewRelation("Bill.Resource.Short.Sku", "models.ProductSku"),
+					Product: struct {
+						field.RelationField
+					}{
+						RelationField: field.NewRelation("Bill.Resource.Short.Sku.Product", "models.Product"),
+					},
+					Discount: struct {
+						field.RelationField
+					}{
+						RelationField: field.NewRelation("Bill.Resource.Short.Sku.Discount", "models.ProductDiscount"),
+					},
+				},
+			},
+			Long: struct {
+				field.RelationField
+				Sku struct {
+					field.RelationField
+				}
+			}{
+				RelationField: field.NewRelation("Bill.Resource.Long", "models.ResourceLong"),
+				Sku: struct {
+					field.RelationField
+				}{
+					RelationField: field.NewRelation("Bill.Resource.Long.Sku", "models.ProductSku"),
+				},
+			},
+			Product: struct {
+				field.RelationField
+			}{
+				RelationField: field.NewRelation("Bill.Resource.Product", "models.Product"),
+			},
+		},
+		Refund: struct {
+			field.RelationField
+		}{
+			RelationField: field.NewRelation("Bill.Refund", "models.Refund"),
+		},
+	}
+
+	_balanceActivity.fillFieldMap()
+
+	return _balanceActivity
+}
+
+type balanceActivity struct {
+	balanceActivityDo
+
+	ALL         field.Asterisk
+	ID          field.Int32
+	UserID      field.Int32
+	BillID      field.Int32
+	AdminID     field.Int32
+	Amount      field.String
+	BalancePrev field.String
+	BalanceCurr field.String
+	Remark      field.String
+	CreatedAt   field.Time
+	Admin       balanceActivityHasOneAdmin
+
+	User balanceActivityBelongsToUser
+
+	Bill balanceActivityBelongsToBill
+
+	fieldMap map[string]field.Expr
+}
+
+func (b balanceActivity) Table(newTableName string) *balanceActivity {
+	b.balanceActivityDo.UseTable(newTableName)
+	return b.updateTableName(newTableName)
+}
+
+func (b balanceActivity) As(alias string) *balanceActivity {
+	b.balanceActivityDo.DO = *(b.balanceActivityDo.As(alias).(*gen.DO))
+	return b.updateTableName(alias)
+}
+
+func (b *balanceActivity) updateTableName(table string) *balanceActivity {
+	b.ALL = field.NewAsterisk(table)
+	b.ID = field.NewInt32(table, "id")
+	b.UserID = field.NewInt32(table, "user_id")
+	b.BillID = field.NewInt32(table, "bill_id")
+	b.AdminID = field.NewInt32(table, "admin_id")
+	b.Amount = field.NewString(table, "amount")
+	b.BalancePrev = field.NewString(table, "balance_prev")
+	b.BalanceCurr = field.NewString(table, "balance_curr")
+	b.Remark = field.NewString(table, "remark")
+	b.CreatedAt = field.NewTime(table, "created_at")
+
+	b.fillFieldMap()
+
+	return b
+}
+
+func (b *balanceActivity) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
+	_f, ok := b.fieldMap[fieldName]
+	if !ok || _f == nil {
+		return nil, false
+	}
+	_oe, ok := _f.(field.OrderExpr)
+	return _oe, ok
+}
+
+func (b *balanceActivity) fillFieldMap() {
+	b.fieldMap = make(map[string]field.Expr, 12)
+	b.fieldMap["id"] = b.ID
+	b.fieldMap["user_id"] = b.UserID
+	b.fieldMap["bill_id"] = b.BillID
+	b.fieldMap["admin_id"] = b.AdminID
+	b.fieldMap["amount"] = b.Amount
+	b.fieldMap["balance_prev"] = b.BalancePrev
+	b.fieldMap["balance_curr"] = b.BalanceCurr
+	b.fieldMap["remark"] = b.Remark
+	b.fieldMap["created_at"] = b.CreatedAt
+
+}
+
+func (b balanceActivity) clone(db *gorm.DB) balanceActivity {
+	b.balanceActivityDo.ReplaceConnPool(db.Statement.ConnPool)
+	b.Admin.db = db.Session(&gorm.Session{Initialized: true})
+	b.Admin.db.Statement.ConnPool = db.Statement.ConnPool
+	b.User.db = db.Session(&gorm.Session{Initialized: true})
+	b.User.db.Statement.ConnPool = db.Statement.ConnPool
+	b.Bill.db = db.Session(&gorm.Session{Initialized: true})
+	b.Bill.db.Statement.ConnPool = db.Statement.ConnPool
+	return b
+}
+
+func (b balanceActivity) replaceDB(db *gorm.DB) balanceActivity {
+	b.balanceActivityDo.ReplaceDB(db)
+	b.Admin.db = db.Session(&gorm.Session{})
+	b.User.db = db.Session(&gorm.Session{})
+	b.Bill.db = db.Session(&gorm.Session{})
+	return b
+}
+
+type balanceActivityHasOneAdmin struct {
+	db *gorm.DB
+
+	field.RelationField
+
+	Admin struct {
+		field.RelationField
+		Roles struct {
+			field.RelationField
+			Permissions struct {
+				field.RelationField
+				Parent struct {
+					field.RelationField
+				}
+				Children struct {
+					field.RelationField
+				}
+			}
+		}
+	}
+	Discount struct {
+		field.RelationField
+	}
+	Roles struct {
+		field.RelationField
+		Permissions struct {
+			field.RelationField
+		}
+	}
+}
+
+func (a balanceActivityHasOneAdmin) Where(conds ...field.Expr) *balanceActivityHasOneAdmin {
+	if len(conds) == 0 {
+		return &a
+	}
+
+	exprs := make([]clause.Expression, 0, len(conds))
+	for _, cond := range conds {
+		exprs = append(exprs, cond.BeCond().(clause.Expression))
+	}
+	a.db = a.db.Clauses(clause.Where{Exprs: exprs})
+	return &a
+}
+
+func (a balanceActivityHasOneAdmin) WithContext(ctx context.Context) *balanceActivityHasOneAdmin {
+	a.db = a.db.WithContext(ctx)
+	return &a
+}
+
+func (a balanceActivityHasOneAdmin) Session(session *gorm.Session) *balanceActivityHasOneAdmin {
+	a.db = a.db.Session(session)
+	return &a
+}
+
+func (a balanceActivityHasOneAdmin) Model(m *models.BalanceActivity) *balanceActivityHasOneAdminTx {
+	return &balanceActivityHasOneAdminTx{a.db.Model(m).Association(a.Name())}
+}
+
+func (a balanceActivityHasOneAdmin) Unscoped() *balanceActivityHasOneAdmin {
+	a.db = a.db.Unscoped()
+	return &a
+}
+
+type balanceActivityHasOneAdminTx struct{ tx *gorm.Association }
+
+func (a balanceActivityHasOneAdminTx) Find() (result *models.User, err error) {
+	return result, a.tx.Find(&result)
+}
+
+func (a balanceActivityHasOneAdminTx) Append(values ...*models.User) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Append(targetValues...)
+}
+
+func (a balanceActivityHasOneAdminTx) Replace(values ...*models.User) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Replace(targetValues...)
+}
+
+func (a balanceActivityHasOneAdminTx) Delete(values ...*models.User) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Delete(targetValues...)
+}
+
+func (a balanceActivityHasOneAdminTx) Clear() error {
+	return a.tx.Clear()
+}
+
+func (a balanceActivityHasOneAdminTx) Count() int64 {
+	return a.tx.Count()
+}
+
+func (a balanceActivityHasOneAdminTx) Unscoped() *balanceActivityHasOneAdminTx {
+	a.tx = a.tx.Unscoped()
+	return &a
+}
+
+type balanceActivityBelongsToUser struct {
+	db *gorm.DB
+
+	field.RelationField
+}
+
+func (a balanceActivityBelongsToUser) Where(conds ...field.Expr) *balanceActivityBelongsToUser {
+	if len(conds) == 0 {
+		return &a
+	}
+
+	exprs := make([]clause.Expression, 0, len(conds))
+	for _, cond := range conds {
+		exprs = append(exprs, cond.BeCond().(clause.Expression))
+	}
+	a.db = a.db.Clauses(clause.Where{Exprs: exprs})
+	return &a
+}
+
+func (a balanceActivityBelongsToUser) WithContext(ctx context.Context) *balanceActivityBelongsToUser {
+	a.db = a.db.WithContext(ctx)
+	return &a
+}
+
+func (a balanceActivityBelongsToUser) Session(session *gorm.Session) *balanceActivityBelongsToUser {
+	a.db = a.db.Session(session)
+	return &a
+}
+
+func (a balanceActivityBelongsToUser) Model(m *models.BalanceActivity) *balanceActivityBelongsToUserTx {
+	return &balanceActivityBelongsToUserTx{a.db.Model(m).Association(a.Name())}
+}
+
+func (a balanceActivityBelongsToUser) Unscoped() *balanceActivityBelongsToUser {
+	a.db = a.db.Unscoped()
+	return &a
+}
+
+type balanceActivityBelongsToUserTx struct{ tx *gorm.Association }
+
+func (a balanceActivityBelongsToUserTx) Find() (result *models.User, err error) {
+	return result, a.tx.Find(&result)
+}
+
+func (a balanceActivityBelongsToUserTx) Append(values ...*models.User) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Append(targetValues...)
+}
+
+func (a balanceActivityBelongsToUserTx) Replace(values ...*models.User) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Replace(targetValues...)
+}
+
+func (a balanceActivityBelongsToUserTx) Delete(values ...*models.User) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Delete(targetValues...)
+}
+
+func (a balanceActivityBelongsToUserTx) Clear() error {
+	return a.tx.Clear()
+}
+
+func (a balanceActivityBelongsToUserTx) Count() int64 {
+	return a.tx.Count()
+}
+
+func (a balanceActivityBelongsToUserTx) Unscoped() *balanceActivityBelongsToUserTx {
+	a.tx = a.tx.Unscoped()
+	return &a
+}
+
+type balanceActivityBelongsToBill struct {
+	db *gorm.DB
+
+	field.RelationField
+
+	User struct {
+		field.RelationField
+	}
+	Trade struct {
+		field.RelationField
+		User struct {
+			field.RelationField
+		}
+	}
+	Resource struct {
+		field.RelationField
+		User struct {
+			field.RelationField
+		}
+		Short struct {
+			field.RelationField
+			Sku struct {
+				field.RelationField
+				Product struct {
+					field.RelationField
+				}
+				Discount struct {
+					field.RelationField
+				}
+			}
+		}
+		Long struct {
+			field.RelationField
+			Sku struct {
+				field.RelationField
+			}
+		}
+		Product struct {
+			field.RelationField
+		}
+	}
+	Refund struct {
+		field.RelationField
+	}
+}
+
+func (a balanceActivityBelongsToBill) Where(conds ...field.Expr) *balanceActivityBelongsToBill {
+	if len(conds) == 0 {
+		return &a
+	}
+
+	exprs := make([]clause.Expression, 0, len(conds))
+	for _, cond := range conds {
+		exprs = append(exprs, cond.BeCond().(clause.Expression))
+	}
+	a.db = a.db.Clauses(clause.Where{Exprs: exprs})
+	return &a
+}
+
+func (a balanceActivityBelongsToBill) WithContext(ctx context.Context) *balanceActivityBelongsToBill {
+	a.db = a.db.WithContext(ctx)
+	return &a
+}
+
+func (a balanceActivityBelongsToBill) Session(session *gorm.Session) *balanceActivityBelongsToBill {
+	a.db = a.db.Session(session)
+	return &a
+}
+
+func (a balanceActivityBelongsToBill) Model(m *models.BalanceActivity) *balanceActivityBelongsToBillTx {
+	return &balanceActivityBelongsToBillTx{a.db.Model(m).Association(a.Name())}
+}
+
+func (a balanceActivityBelongsToBill) Unscoped() *balanceActivityBelongsToBill {
+	a.db = a.db.Unscoped()
+	return &a
+}
+
+type balanceActivityBelongsToBillTx struct{ tx *gorm.Association }
+
+func (a balanceActivityBelongsToBillTx) Find() (result *models.Bill, err error) {
+	return result, a.tx.Find(&result)
+}
+
+func (a balanceActivityBelongsToBillTx) Append(values ...*models.Bill) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Append(targetValues...)
+}
+
+func (a balanceActivityBelongsToBillTx) Replace(values ...*models.Bill) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Replace(targetValues...)
+}
+
+func (a balanceActivityBelongsToBillTx) Delete(values ...*models.Bill) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Delete(targetValues...)
+}
+
+func (a balanceActivityBelongsToBillTx) Clear() error {
+	return a.tx.Clear()
+}
+
+func (a balanceActivityBelongsToBillTx) Count() int64 {
+	return a.tx.Count()
+}
+
+func (a balanceActivityBelongsToBillTx) Unscoped() *balanceActivityBelongsToBillTx {
+	a.tx = a.tx.Unscoped()
+	return &a
+}
+
+type balanceActivityDo struct{ gen.DO }
+
+func (b balanceActivityDo) Debug() *balanceActivityDo {
+	return b.withDO(b.DO.Debug())
+}
+
+func (b balanceActivityDo) WithContext(ctx context.Context) *balanceActivityDo {
+	return b.withDO(b.DO.WithContext(ctx))
+}
+
+func (b balanceActivityDo) ReadDB() *balanceActivityDo {
+	return b.Clauses(dbresolver.Read)
+}
+
+func (b balanceActivityDo) WriteDB() *balanceActivityDo {
+	return b.Clauses(dbresolver.Write)
+}
+
+func (b balanceActivityDo) Session(config *gorm.Session) *balanceActivityDo {
+	return b.withDO(b.DO.Session(config))
+}
+
+func (b balanceActivityDo) Clauses(conds ...clause.Expression) *balanceActivityDo {
+	return b.withDO(b.DO.Clauses(conds...))
+}
+
+func (b balanceActivityDo) Returning(value interface{}, columns ...string) *balanceActivityDo {
+	return b.withDO(b.DO.Returning(value, columns...))
+}
+
+func (b balanceActivityDo) Not(conds ...gen.Condition) *balanceActivityDo {
+	return b.withDO(b.DO.Not(conds...))
+}
+
+func (b balanceActivityDo) Or(conds ...gen.Condition) *balanceActivityDo {
+	return b.withDO(b.DO.Or(conds...))
+}
+
+func (b balanceActivityDo) Select(conds ...field.Expr) *balanceActivityDo {
+	return b.withDO(b.DO.Select(conds...))
+}
+
+func (b balanceActivityDo) Where(conds ...gen.Condition) *balanceActivityDo {
+	return b.withDO(b.DO.Where(conds...))
+}
+
+func (b balanceActivityDo) Order(conds ...field.Expr) *balanceActivityDo {
+	return b.withDO(b.DO.Order(conds...))
+}
+
+func (b balanceActivityDo) Distinct(cols ...field.Expr) *balanceActivityDo {
+	return b.withDO(b.DO.Distinct(cols...))
+}
+
+func (b balanceActivityDo) Omit(cols ...field.Expr) *balanceActivityDo {
+	return b.withDO(b.DO.Omit(cols...))
+}
+
+func (b balanceActivityDo) Join(table schema.Tabler, on ...field.Expr) *balanceActivityDo {
+	return b.withDO(b.DO.Join(table, on...))
+}
+
+func (b balanceActivityDo) LeftJoin(table schema.Tabler, on ...field.Expr) *balanceActivityDo {
+	return b.withDO(b.DO.LeftJoin(table, on...))
+}
+
+func (b balanceActivityDo) RightJoin(table schema.Tabler, on ...field.Expr) *balanceActivityDo {
+	return b.withDO(b.DO.RightJoin(table, on...))
+}
+
+func (b balanceActivityDo) Group(cols ...field.Expr) *balanceActivityDo {
+	return b.withDO(b.DO.Group(cols...))
+}
+
+func (b balanceActivityDo) Having(conds ...gen.Condition) *balanceActivityDo {
+	return b.withDO(b.DO.Having(conds...))
+}
+
+func (b balanceActivityDo) Limit(limit int) *balanceActivityDo {
+	return b.withDO(b.DO.Limit(limit))
+}
+
+func (b balanceActivityDo) Offset(offset int) *balanceActivityDo {
+	return b.withDO(b.DO.Offset(offset))
+}
+
+func (b balanceActivityDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *balanceActivityDo {
+	return b.withDO(b.DO.Scopes(funcs...))
+}
+
+func (b balanceActivityDo) Unscoped() *balanceActivityDo {
+	return b.withDO(b.DO.Unscoped())
+}
+
+func (b balanceActivityDo) Create(values ...*models.BalanceActivity) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return b.DO.Create(values)
+}
+
+func (b balanceActivityDo) CreateInBatches(values []*models.BalanceActivity, batchSize int) error {
+	return b.DO.CreateInBatches(values, batchSize)
+}
+
+// Save : !!! underlying implementation is different with GORM
+// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
+func (b balanceActivityDo) Save(values ...*models.BalanceActivity) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return b.DO.Save(values)
+}
+
+func (b balanceActivityDo) First() (*models.BalanceActivity, error) {
+	if result, err := b.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.BalanceActivity), nil
+	}
+}
+
+func (b balanceActivityDo) Take() (*models.BalanceActivity, error) {
+	if result, err := b.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.BalanceActivity), nil
+	}
+}
+
+func (b balanceActivityDo) Last() (*models.BalanceActivity, error) {
+	if result, err := b.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.BalanceActivity), nil
+	}
+}
+
+func (b balanceActivityDo) Find() ([]*models.BalanceActivity, error) {
+	result, err := b.DO.Find()
+	return result.([]*models.BalanceActivity), err
+}
+
+func (b balanceActivityDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*models.BalanceActivity, err error) {
+	buf := make([]*models.BalanceActivity, 0, batchSize)
+	err = b.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
+		defer func() { results = append(results, buf...) }()
+		return fc(tx, batch)
+	})
+	return results, err
+}
+
+func (b balanceActivityDo) FindInBatches(result *[]*models.BalanceActivity, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return b.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (b balanceActivityDo) Attrs(attrs ...field.AssignExpr) *balanceActivityDo {
+	return b.withDO(b.DO.Attrs(attrs...))
+}
+
+func (b balanceActivityDo) Assign(attrs ...field.AssignExpr) *balanceActivityDo {
+	return b.withDO(b.DO.Assign(attrs...))
+}
+
+func (b balanceActivityDo) Joins(fields ...field.RelationField) *balanceActivityDo {
+	for _, _f := range fields {
+		b = *b.withDO(b.DO.Joins(_f))
+	}
+	return &b
+}
+
+func (b balanceActivityDo) Preload(fields ...field.RelationField) *balanceActivityDo {
+	for _, _f := range fields {
+		b = *b.withDO(b.DO.Preload(_f))
+	}
+	return &b
+}
+
+func (b balanceActivityDo) FirstOrInit() (*models.BalanceActivity, error) {
+	if result, err := b.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.BalanceActivity), nil
+	}
+}
+
+func (b balanceActivityDo) FirstOrCreate() (*models.BalanceActivity, error) {
+	if result, err := b.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.BalanceActivity), nil
+	}
+}
+
+func (b balanceActivityDo) FindByPage(offset int, limit int) (result []*models.BalanceActivity, count int64, err error) {
+	result, err = b.Offset(offset).Limit(limit).Find()
+	if err != nil {
+		return
+	}
+
+	if size := len(result); 0 < limit && 0 < size && size < limit {
+		count = int64(size + offset)
+		return
+	}
+
+	count, err = b.Offset(-1).Limit(-1).Count()
+	return
+}
+
+func (b balanceActivityDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
+	count, err = b.Count()
+	if err != nil {
+		return
+	}
+
+	err = b.Offset(offset).Limit(limit).Scan(result)
+	return
+}
+
+func (b balanceActivityDo) Scan(result interface{}) (err error) {
+	return b.DO.Scan(result)
+}
+
+func (b balanceActivityDo) Delete(models ...*models.BalanceActivity) (result gen.ResultInfo, err error) {
+	return b.DO.Delete(models)
+}
+
+func (b *balanceActivityDo) withDO(do gen.Dao) *balanceActivityDo {
+	b.DO = *do.(*gen.DO)
+	return b
+}

web/queries/bill.gen.go

@@ -35,18 +35,85 @@ func newBill(db *gorm.DB, opts ...gen.DOOption) bill {
 	_bill.TradeID = field.NewInt32(tableName, "trade_id")
 	_bill.ResourceID = field.NewInt32(tableName, "resource_id")
 	_bill.RefundID = field.NewInt32(tableName, "refund_id")
+	_bill.CouponID = field.NewInt32(tableName, "coupon_id")
 	_bill.BillNo = field.NewString(tableName, "bill_no")
 	_bill.Info = field.NewString(tableName, "info")
 	_bill.Type = field.NewInt(tableName, "type")
 	_bill.Amount = field.NewField(tableName, "amount")
+	_bill.Actual = field.NewField(tableName, "actual")
 	_bill.User = billBelongsToUser{
 		db: db.Session(&gorm.Session{}),
 
 		RelationField: field.NewRelation("User", "models.User"),
 		Admin: struct {
 			field.RelationField
+			Roles struct {
+				field.RelationField
+				Permissions struct {
+					field.RelationField
+					Parent struct {
+						field.RelationField
+					}
+					Children struct {
+						field.RelationField
+					}
+				}
+			}
 		}{
 			RelationField: field.NewRelation("User.Admin", "models.Admin"),
+			Roles: struct {
+				field.RelationField
+				Permissions struct {
+					field.RelationField
+					Parent struct {
+						field.RelationField
+					}
+					Children struct {
+						field.RelationField
+					}
+				}
+			}{
+				RelationField: field.NewRelation("User.Admin.Roles", "models.AdminRole"),
+				Permissions: struct {
+					field.RelationField
+					Parent struct {
+						field.RelationField
+					}
+					Children struct {
+						field.RelationField
+					}
+				}{
+					RelationField: field.NewRelation("User.Admin.Roles.Permissions", "models.Permission"),
+					Parent: struct {
+						field.RelationField
+					}{
+						RelationField: field.NewRelation("User.Admin.Roles.Permissions.Parent", "models.Permission"),
+					},
+					Children: struct {
+						field.RelationField
+					}{
+						RelationField: field.NewRelation("User.Admin.Roles.Permissions.Children", "models.Permission"),
+					},
+				},
+			},
+		},
+		Discount: struct {
+			field.RelationField
+		}{
+			RelationField: field.NewRelation("User.Discount", "models.ProductDiscount"),
+		},
+		Roles: struct {
+			field.RelationField
+			Permissions struct {
+				field.RelationField
+			}
+		}{
+			RelationField: field.NewRelation("User.Roles", "models.UserRole"),
+			Permissions: struct {
+				field.RelationField
+			}{
+				RelationField: field.NewRelation("User.Roles.Permissions", "models.Permission"),
+			},
 		},
 	}
 
@@ -54,6 +121,11 @@ func newBill(db *gorm.DB, opts ...gen.DOOption) bill {
 		db: db.Session(&gorm.Session{}),
 
 		RelationField: field.NewRelation("Trade", "models.Trade"),
+		User: struct {
+			field.RelationField
+		}{
+			RelationField: field.NewRelation("Trade.User", "models.User"),
+		},
 	}
 
 	_bill.Resource = billBelongsToResource{
@@ -67,13 +139,56 @@ func newBill(db *gorm.DB, opts ...gen.DOOption) bill {
 		},
 		Short: struct {
 			field.RelationField
+			Sku struct {
+				field.RelationField
+				Product struct {
+					field.RelationField
+				}
+				Discount struct {
+					field.RelationField
+				}
+			}
 		}{
 			RelationField: field.NewRelation("Resource.Short", "models.ResourceShort"),
+			Sku: struct {
+				field.RelationField
+				Product struct {
+					field.RelationField
+				}
+				Discount struct {
+					field.RelationField
+				}
+			}{
+				RelationField: field.NewRelation("Resource.Short.Sku", "models.ProductSku"),
+				Product: struct {
+					field.RelationField
+				}{
+					RelationField: field.NewRelation("Resource.Short.Sku.Product", "models.Product"),
+				},
+				Discount: struct {
+					field.RelationField
+				}{
+					RelationField: field.NewRelation("Resource.Short.Sku.Discount", "models.ProductDiscount"),
+				},
+			},
 		},
 		Long: struct {
 			field.RelationField
+			Sku struct {
+				field.RelationField
+			}
 		}{
 			RelationField: field.NewRelation("Resource.Long", "models.ResourceLong"),
+			Sku: struct {
+				field.RelationField
+			}{
+				RelationField: field.NewRelation("Resource.Long.Sku", "models.ProductSku"),
+			},
+		},
+		Product: struct {
+			field.RelationField
+		}{
+			RelationField: field.NewRelation("Resource.Product", "models.Product"),
 		},
 	}
 
@@ -100,10 +215,12 @@ type bill struct {
 	TradeID    field.Int32
 	ResourceID field.Int32
 	RefundID   field.Int32
+	CouponID   field.Int32
 	BillNo     field.String
 	Info       field.String
 	Type       field.Int
 	Amount     field.Field
+	Actual     field.Field
 	User       billBelongsToUser
 
 	Trade billBelongsToTrade
@@ -135,10 +252,12 @@ func (b *bill) updateTableName(table string) *bill {
 	b.TradeID = field.NewInt32(table, "trade_id")
 	b.ResourceID = field.NewInt32(table, "resource_id")
 	b.RefundID = field.NewInt32(table, "refund_id")
+	b.CouponID = field.NewInt32(table, "coupon_id")
 	b.BillNo = field.NewString(table, "bill_no")
 	b.Info = field.NewString(table, "info")
 	b.Type = field.NewInt(table, "type")
 	b.Amount = field.NewField(table, "amount")
+	b.Actual = field.NewField(table, "actual")
 
 	b.fillFieldMap()
 
@@ -155,7 +274,7 @@ func (b *bill) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
 }
 
 func (b *bill) fillFieldMap() {
-	b.fieldMap = make(map[string]field.Expr, 16)
+	b.fieldMap = make(map[string]field.Expr, 18)
 	b.fieldMap["id"] = b.ID
 	b.fieldMap["created_at"] = b.CreatedAt
 	b.fieldMap["updated_at"] = b.UpdatedAt
@@ -164,10 +283,12 @@ func (b *bill) fillFieldMap() {
 	b.fieldMap["trade_id"] = b.TradeID
 	b.fieldMap["resource_id"] = b.ResourceID
 	b.fieldMap["refund_id"] = b.RefundID
+	b.fieldMap["coupon_id"] = b.CouponID
 	b.fieldMap["bill_no"] = b.BillNo
 	b.fieldMap["info"] = b.Info
 	b.fieldMap["type"] = b.Type
 	b.fieldMap["amount"] = b.Amount
+	b.fieldMap["actual"] = b.Actual
 
 }
 
@@ -200,6 +321,27 @@ type billBelongsToUser struct {
 
 	Admin struct {
 		field.RelationField
+		Roles struct {
+			field.RelationField
+			Permissions struct {
+				field.RelationField
+				Parent struct {
+					field.RelationField
+				}
+				Children struct {
+					field.RelationField
+				}
+			}
+		}
+	}
+	Discount struct {
+		field.RelationField
+	}
+	Roles struct {
+		field.RelationField
+		Permissions struct {
+			field.RelationField
+		}
 	}
 }
 
@@ -282,6 +424,10 @@ type billBelongsToTrade struct {
 	db *gorm.DB
 
 	field.RelationField
+
+	User struct {
+		field.RelationField
+	}
 }
 
 func (a billBelongsToTrade) Where(conds ...field.Expr) *billBelongsToTrade {
@@ -369,9 +515,24 @@ type billBelongsToResource struct {
 	}
 	Short struct {
 		field.RelationField
+		Sku struct {
+			field.RelationField
+			Product struct {
+				field.RelationField
+			}
+			Discount struct {
+				field.RelationField
+			}
+		}
 	}
 	Long struct {
 		field.RelationField
+		Sku struct {
+			field.RelationField
+		}
+	}
+	Product struct {
+		field.RelationField
 	}
 }
 

web/queries/channel.gen.go

@@ -33,10 +33,12 @@ func newChannel(db *gorm.DB, opts ...gen.DOOption) channel {
 	_channel.DeletedAt = field.NewField(tableName, "deleted_at")
 	_channel.UserID = field.NewInt32(tableName, "user_id")
 	_channel.ResourceID = field.NewInt32(tableName, "resource_id")
-	_channel.ProxyID = field.NewInt32(tableName, "proxy_id")
 	_channel.BatchNo = field.NewString(tableName, "batch_no")
+	_channel.ProxyID = field.NewInt32(tableName, "proxy_id")
+	_channel.Host = field.NewString(tableName, "host")
 	_channel.Port = field.NewUint16(tableName, "port")
 	_channel.EdgeID = field.NewInt32(tableName, "edge_id")
+	_channel.EdgeRef = field.NewString(tableName, "edge_ref")
 	_channel.FilterISP = field.NewInt(tableName, "filter_isp")
 	_channel.FilterProv = field.NewString(tableName, "filter_prov")
 	_channel.FilterCity = field.NewString(tableName, "filter_city")
@@ -51,8 +53,73 @@ func newChannel(db *gorm.DB, opts ...gen.DOOption) channel {
 		RelationField: field.NewRelation("User", "models.User"),
 		Admin: struct {
 			field.RelationField
+			Roles struct {
+				field.RelationField
+				Permissions struct {
+					field.RelationField
+					Parent struct {
+						field.RelationField
+					}
+					Children struct {
+						field.RelationField
+					}
+				}
+			}
 		}{
 			RelationField: field.NewRelation("User.Admin", "models.Admin"),
+			Roles: struct {
+				field.RelationField
+				Permissions struct {
+					field.RelationField
+					Parent struct {
+						field.RelationField
+					}
+					Children struct {
+						field.RelationField
+					}
+				}
+			}{
+				RelationField: field.NewRelation("User.Admin.Roles", "models.AdminRole"),
+				Permissions: struct {
+					field.RelationField
+					Parent struct {
+						field.RelationField
+					}
+					Children struct {
+						field.RelationField
+					}
+				}{
+					RelationField: field.NewRelation("User.Admin.Roles.Permissions", "models.Permission"),
+					Parent: struct {
+						field.RelationField
+					}{
+						RelationField: field.NewRelation("User.Admin.Roles.Permissions.Parent", "models.Permission"),
+					},
+					Children: struct {
+						field.RelationField
+					}{
+						RelationField: field.NewRelation("User.Admin.Roles.Permissions.Children", "models.Permission"),
+					},
+				},
+			},
+		},
+		Discount: struct {
+			field.RelationField
+		}{
+			RelationField: field.NewRelation("User.Discount", "models.ProductDiscount"),
+		},
+		Roles: struct {
+			field.RelationField
+			Permissions struct {
+				field.RelationField
+			}
+		}{
+			RelationField: field.NewRelation("User.Roles", "models.UserRole"),
+			Permissions: struct {
+				field.RelationField
+			}{
+				RelationField: field.NewRelation("User.Roles.Permissions", "models.Permission"),
+			},
 		},
 	}
 
@@ -67,13 +134,56 @@ func newChannel(db *gorm.DB, opts ...gen.DOOption) channel {
 		},
 		Short: struct {
 			field.RelationField
+			Sku struct {
+				field.RelationField
+				Product struct {
+					field.RelationField
+				}
+				Discount struct {
+					field.RelationField
+				}
+			}
 		}{
 			RelationField: field.NewRelation("Resource.Short", "models.ResourceShort"),
+			Sku: struct {
+				field.RelationField
+				Product struct {
+					field.RelationField
+				}
+				Discount struct {
+					field.RelationField
+				}
+			}{
+				RelationField: field.NewRelation("Resource.Short.Sku", "models.ProductSku"),
+				Product: struct {
+					field.RelationField
+				}{
+					RelationField: field.NewRelation("Resource.Short.Sku.Product", "models.Product"),
+				},
+				Discount: struct {
+					field.RelationField
+				}{
+					RelationField: field.NewRelation("Resource.Short.Sku.Discount", "models.ProductDiscount"),
+				},
+			},
 		},
 		Long: struct {
 			field.RelationField
+			Sku struct {
+				field.RelationField
+			}
 		}{
 			RelationField: field.NewRelation("Resource.Long", "models.ResourceLong"),
+			Sku: struct {
+				field.RelationField
+			}{
+				RelationField: field.NewRelation("Resource.Long.Sku", "models.ProductSku"),
+			},
+		},
+		Product: struct {
+			field.RelationField
+		}{
+			RelationField: field.NewRelation("Resource.Product", "models.Product"),
 		},
 	}
 
@@ -141,10 +251,12 @@ type channel struct {
 	DeletedAt  field.Field
 	UserID     field.Int32
 	ResourceID field.Int32
-	ProxyID    field.Int32
 	BatchNo    field.String
+	ProxyID    field.Int32
+	Host       field.String
 	Port       field.Uint16
 	EdgeID     field.Int32
+	EdgeRef    field.String
 	FilterISP  field.Int
 	FilterProv field.String
 	FilterCity field.String
@@ -182,10 +294,12 @@ func (c *channel) updateTableName(table string) *channel {
 	c.DeletedAt = field.NewField(table, "deleted_at")
 	c.UserID = field.NewInt32(table, "user_id")
 	c.ResourceID = field.NewInt32(table, "resource_id")
-	c.ProxyID = field.NewInt32(table, "proxy_id")
 	c.BatchNo = field.NewString(table, "batch_no")
+	c.ProxyID = field.NewInt32(table, "proxy_id")
+	c.Host = field.NewString(table, "host")
 	c.Port = field.NewUint16(table, "port")
 	c.EdgeID = field.NewInt32(table, "edge_id")
+	c.EdgeRef = field.NewString(table, "edge_ref")
 	c.FilterISP = field.NewInt(table, "filter_isp")
 	c.FilterProv = field.NewString(table, "filter_prov")
 	c.FilterCity = field.NewString(table, "filter_city")
@@ -210,17 +324,19 @@ func (c *channel) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
 }
 
 func (c *channel) fillFieldMap() {
-	c.fieldMap = make(map[string]field.Expr, 22)
+	c.fieldMap = make(map[string]field.Expr, 24)
 	c.fieldMap["id"] = c.ID
 	c.fieldMap["created_at"] = c.CreatedAt
 	c.fieldMap["updated_at"] = c.UpdatedAt
 	c.fieldMap["deleted_at"] = c.DeletedAt
 	c.fieldMap["user_id"] = c.UserID
 	c.fieldMap["resource_id"] = c.ResourceID
-	c.fieldMap["proxy_id"] = c.ProxyID
 	c.fieldMap["batch_no"] = c.BatchNo
+	c.fieldMap["proxy_id"] = c.ProxyID
+	c.fieldMap["host"] = c.Host
 	c.fieldMap["port"] = c.Port
 	c.fieldMap["edge_id"] = c.EdgeID
+	c.fieldMap["edge_ref"] = c.EdgeRef
 	c.fieldMap["filter_isp"] = c.FilterISP
 	c.fieldMap["filter_prov"] = c.FilterProv
 	c.fieldMap["filter_city"] = c.FilterCity
@@ -261,6 +377,27 @@ type channelBelongsToUser struct {
 
 	Admin struct {
 		field.RelationField
+		Roles struct {
+			field.RelationField
+			Permissions struct {
+				field.RelationField
+				Parent struct {
+					field.RelationField
+				}
+				Children struct {
+					field.RelationField
+				}
+			}
+		}
+	}
+	Discount struct {
+		field.RelationField
+	}
+	Roles struct {
+		field.RelationField
+		Permissions struct {
+			field.RelationField
+		}
 	}
 }
 
@@ -349,9 +486,24 @@ type channelBelongsToResource struct {
 	}
 	Short struct {
 		field.RelationField
+		Sku struct {
+			field.RelationField
+			Product struct {
+				field.RelationField
+			}
+			Discount struct {
+				field.RelationField
+			}
+		}
 	}
 	Long struct {
 		field.RelationField
+		Sku struct {
+			field.RelationField
+		}
+	}
+	Product struct {
+		field.RelationField
 	}
 }
 

web/queries/client.gen.go

@@ -39,6 +39,21 @@ func newClient(db *gorm.DB, opts ...gen.DOOption) client {
 	_client.Icon = field.NewString(tableName, "icon")
 	_client.Status = field.NewInt(tableName, "status")
 	_client.Type = field.NewInt(tableName, "type")
+	_client.Permissions = clientManyToManyPermissions{
+		db: db.Session(&gorm.Session{}),
+
+		RelationField: field.NewRelation("Permissions", "models.Permission"),
+		Parent: struct {
+			field.RelationField
+		}{
+			RelationField: field.NewRelation("Permissions.Parent", "models.Permission"),
+		},
+		Children: struct {
+			field.RelationField
+		}{
+			RelationField: field.NewRelation("Permissions.Children", "models.Permission"),
+		},
+	}
 
 	_client.fillFieldMap()
 
@@ -61,6 +76,7 @@ type client struct {
 	Icon         field.String
 	Status       field.Int
 	Type         field.Int
+	Permissions  clientManyToManyPermissions
 
 	fieldMap map[string]field.Expr
 }
@@ -105,7 +121,7 @@ func (c *client) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
 }
 
 func (c *client) fillFieldMap() {
-	c.fieldMap = make(map[string]field.Expr, 12)
+	c.fieldMap = make(map[string]field.Expr, 13)
 	c.fieldMap["id"] = c.ID
 	c.fieldMap["created_at"] = c.CreatedAt
 	c.fieldMap["updated_at"] = c.UpdatedAt
@@ -118,18 +134,110 @@ func (c *client) fillFieldMap() {
 	c.fieldMap["icon"] = c.Icon
 	c.fieldMap["status"] = c.Status
 	c.fieldMap["type"] = c.Type
+
 }
 
 func (c client) clone(db *gorm.DB) client {
 	c.clientDo.ReplaceConnPool(db.Statement.ConnPool)
+	c.Permissions.db = db.Session(&gorm.Session{Initialized: true})
+	c.Permissions.db.Statement.ConnPool = db.Statement.ConnPool
 	return c
 }
 
 func (c client) replaceDB(db *gorm.DB) client {
 	c.clientDo.ReplaceDB(db)
+	c.Permissions.db = db.Session(&gorm.Session{})
 	return c
 }
 
+type clientManyToManyPermissions struct {
+	db *gorm.DB
+
+	field.RelationField
+
+	Parent struct {
+		field.RelationField
+	}
+	Children struct {
+		field.RelationField
+	}
+}
+
+func (a clientManyToManyPermissions) Where(conds ...field.Expr) *clientManyToManyPermissions {
+	if len(conds) == 0 {
+		return &a
+	}
+
+	exprs := make([]clause.Expression, 0, len(conds))
+	for _, cond := range conds {
+		exprs = append(exprs, cond.BeCond().(clause.Expression))
+	}
+	a.db = a.db.Clauses(clause.Where{Exprs: exprs})
+	return &a
+}
+
+func (a clientManyToManyPermissions) WithContext(ctx context.Context) *clientManyToManyPermissions {
+	a.db = a.db.WithContext(ctx)
+	return &a
+}
+
+func (a clientManyToManyPermissions) Session(session *gorm.Session) *clientManyToManyPermissions {
+	a.db = a.db.Session(session)
+	return &a
+}
+
+func (a clientManyToManyPermissions) Model(m *models.Client) *clientManyToManyPermissionsTx {
+	return &clientManyToManyPermissionsTx{a.db.Model(m).Association(a.Name())}
+}
+
+func (a clientManyToManyPermissions) Unscoped() *clientManyToManyPermissions {
+	a.db = a.db.Unscoped()
+	return &a
+}
+
+type clientManyToManyPermissionsTx struct{ tx *gorm.Association }
+
+func (a clientManyToManyPermissionsTx) Find() (result []*models.Permission, err error) {
+	return result, a.tx.Find(&result)
+}
+
+func (a clientManyToManyPermissionsTx) Append(values ...*models.Permission) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Append(targetValues...)
+}
+
+func (a clientManyToManyPermissionsTx) Replace(values ...*models.Permission) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Replace(targetValues...)
+}
+
+func (a clientManyToManyPermissionsTx) Delete(values ...*models.Permission) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Delete(targetValues...)
+}
+
+func (a clientManyToManyPermissionsTx) Clear() error {
+	return a.tx.Clear()
+}
+
+func (a clientManyToManyPermissionsTx) Count() int64 {
+	return a.tx.Count()
+}
+
+func (a clientManyToManyPermissionsTx) Unscoped() *clientManyToManyPermissionsTx {
+	a.tx = a.tx.Unscoped()
+	return &a
+}
+
 type clientDo struct{ gen.DO }
 
 func (c clientDo) Debug() *clientDo {

web/queries/gen.go

@@ -20,11 +20,13 @@ var (
 	Admin                   *admin
 	AdminRole               *adminRole
 	Announcement            *announcement
+	BalanceActivity         *balanceActivity
 	Bill                    *bill
 	Channel                 *channel
 	Client                  *client
 	Coupon                  *coupon
 	Edge                    *edge
+	Inquiry                 *inquiry
 	LinkAdminRole           *linkAdminRole
 	LinkAdminRolePermission *linkAdminRolePermission
 	LinkClientPermission    *linkClientPermission
@@ -36,6 +38,9 @@ var (
 	LogsUserUsage           *logsUserUsage
 	Permission              *permission
 	Product                 *product
+	ProductDiscount         *productDiscount
+	ProductSku              *productSku
+	ProductSkuUser          *productSkuUser
 	Proxy                   *proxy
 	Refund                  *refund
 	Resource                *resource
@@ -53,11 +58,13 @@ func SetDefault(db *gorm.DB, opts ...gen.DOOption) {
 	Admin = &Q.Admin
 	AdminRole = &Q.AdminRole
 	Announcement = &Q.Announcement
+	BalanceActivity = &Q.BalanceActivity
 	Bill = &Q.Bill
 	Channel = &Q.Channel
 	Client = &Q.Client
 	Coupon = &Q.Coupon
 	Edge = &Q.Edge
+	Inquiry = &Q.Inquiry
 	LinkAdminRole = &Q.LinkAdminRole
 	LinkAdminRolePermission = &Q.LinkAdminRolePermission
 	LinkClientPermission = &Q.LinkClientPermission
@@ -69,6 +76,9 @@ func SetDefault(db *gorm.DB, opts ...gen.DOOption) {
 	LogsUserUsage = &Q.LogsUserUsage
 	Permission = &Q.Permission
 	Product = &Q.Product
+	ProductDiscount = &Q.ProductDiscount
+	ProductSku = &Q.ProductSku
+	ProductSkuUser = &Q.ProductSkuUser
 	Proxy = &Q.Proxy
 	Refund = &Q.Refund
 	Resource = &Q.Resource
@@ -87,11 +97,13 @@ func Use(db *gorm.DB, opts ...gen.DOOption) *Query {
 		Admin:                   newAdmin(db, opts...),
 		AdminRole:               newAdminRole(db, opts...),
 		Announcement:            newAnnouncement(db, opts...),
+		BalanceActivity:         newBalanceActivity(db, opts...),
 		Bill:                    newBill(db, opts...),
 		Channel:                 newChannel(db, opts...),
 		Client:                  newClient(db, opts...),
 		Coupon:                  newCoupon(db, opts...),
 		Edge:                    newEdge(db, opts...),
+		Inquiry:                 newInquiry(db, opts...),
 		LinkAdminRole:           newLinkAdminRole(db, opts...),
 		LinkAdminRolePermission: newLinkAdminRolePermission(db, opts...),
 		LinkClientPermission:    newLinkClientPermission(db, opts...),
@@ -103,6 +115,9 @@ func Use(db *gorm.DB, opts ...gen.DOOption) *Query {
 		LogsUserUsage:           newLogsUserUsage(db, opts...),
 		Permission:              newPermission(db, opts...),
 		Product:                 newProduct(db, opts...),
+		ProductDiscount:         newProductDiscount(db, opts...),
+		ProductSku:              newProductSku(db, opts...),
+		ProductSkuUser:          newProductSkuUser(db, opts...),
 		Proxy:                   newProxy(db, opts...),
 		Refund:                  newRefund(db, opts...),
 		Resource:                newResource(db, opts...),
@@ -122,11 +137,13 @@ type Query struct {
 	Admin                   admin
 	AdminRole               adminRole
 	Announcement            announcement
+	BalanceActivity         balanceActivity
 	Bill                    bill
 	Channel                 channel
 	Client                  client
 	Coupon                  coupon
 	Edge                    edge
+	Inquiry                 inquiry
 	LinkAdminRole           linkAdminRole
 	LinkAdminRolePermission linkAdminRolePermission
 	LinkClientPermission    linkClientPermission
@@ -138,6 +155,9 @@ type Query struct {
 	LogsUserUsage           logsUserUsage
 	Permission              permission
 	Product                 product
+	ProductDiscount         productDiscount
+	ProductSku              productSku
+	ProductSkuUser          productSkuUser
 	Proxy                   proxy
 	Refund                  refund
 	Resource                resource
@@ -158,11 +178,13 @@ func (q *Query) clone(db *gorm.DB) *Query {
 		Admin:                   q.Admin.clone(db),
 		AdminRole:               q.AdminRole.clone(db),
 		Announcement:            q.Announcement.clone(db),
+		BalanceActivity:         q.BalanceActivity.clone(db),
 		Bill:                    q.Bill.clone(db),
 		Channel:                 q.Channel.clone(db),
 		Client:                  q.Client.clone(db),
 		Coupon:                  q.Coupon.clone(db),
 		Edge:                    q.Edge.clone(db),
+		Inquiry:                 q.Inquiry.clone(db),
 		LinkAdminRole:           q.LinkAdminRole.clone(db),
 		LinkAdminRolePermission: q.LinkAdminRolePermission.clone(db),
 		LinkClientPermission:    q.LinkClientPermission.clone(db),
@@ -174,6 +196,9 @@ func (q *Query) clone(db *gorm.DB) *Query {
 		LogsUserUsage:           q.LogsUserUsage.clone(db),
 		Permission:              q.Permission.clone(db),
 		Product:                 q.Product.clone(db),
+		ProductDiscount:         q.ProductDiscount.clone(db),
+		ProductSku:              q.ProductSku.clone(db),
+		ProductSkuUser:          q.ProductSkuUser.clone(db),
 		Proxy:                   q.Proxy.clone(db),
 		Refund:                  q.Refund.clone(db),
 		Resource:                q.Resource.clone(db),
@@ -201,11 +226,13 @@ func (q *Query) ReplaceDB(db *gorm.DB) *Query {
 		Admin:                   q.Admin.replaceDB(db),
 		AdminRole:               q.AdminRole.replaceDB(db),
 		Announcement:            q.Announcement.replaceDB(db),
+		BalanceActivity:         q.BalanceActivity.replaceDB(db),
 		Bill:                    q.Bill.replaceDB(db),
 		Channel:                 q.Channel.replaceDB(db),
 		Client:                  q.Client.replaceDB(db),
 		Coupon:                  q.Coupon.replaceDB(db),
 		Edge:                    q.Edge.replaceDB(db),
+		Inquiry:                 q.Inquiry.replaceDB(db),
 		LinkAdminRole:           q.LinkAdminRole.replaceDB(db),
 		LinkAdminRolePermission: q.LinkAdminRolePermission.replaceDB(db),
 		LinkClientPermission:    q.LinkClientPermission.replaceDB(db),
@@ -217,6 +244,9 @@ func (q *Query) ReplaceDB(db *gorm.DB) *Query {
 		LogsUserUsage:           q.LogsUserUsage.replaceDB(db),
 		Permission:              q.Permission.replaceDB(db),
 		Product:                 q.Product.replaceDB(db),
+		ProductDiscount:         q.ProductDiscount.replaceDB(db),
+		ProductSku:              q.ProductSku.replaceDB(db),
+		ProductSkuUser:          q.ProductSkuUser.replaceDB(db),
 		Proxy:                   q.Proxy.replaceDB(db),
 		Refund:                  q.Refund.replaceDB(db),
 		Resource:                q.Resource.replaceDB(db),
@@ -234,11 +264,13 @@ type queryCtx struct {
 	Admin                   *adminDo
 	AdminRole               *adminRoleDo
 	Announcement            *announcementDo
+	BalanceActivity         *balanceActivityDo
 	Bill                    *billDo
 	Channel                 *channelDo
 	Client                  *clientDo
 	Coupon                  *couponDo
 	Edge                    *edgeDo
+	Inquiry                 *inquiryDo
 	LinkAdminRole           *linkAdminRoleDo
 	LinkAdminRolePermission *linkAdminRolePermissionDo
 	LinkClientPermission    *linkClientPermissionDo
@@ -250,6 +282,9 @@ type queryCtx struct {
 	LogsUserUsage           *logsUserUsageDo
 	Permission              *permissionDo
 	Product                 *productDo
+	ProductDiscount         *productDiscountDo
+	ProductSku              *productSkuDo
+	ProductSkuUser          *productSkuUserDo
 	Proxy                   *proxyDo
 	Refund                  *refundDo
 	Resource                *resourceDo
@@ -267,11 +302,13 @@ func (q *Query) WithContext(ctx context.Context) *queryCtx {
 		Admin:                   q.Admin.WithContext(ctx),
 		AdminRole:               q.AdminRole.WithContext(ctx),
 		Announcement:            q.Announcement.WithContext(ctx),
+		BalanceActivity:         q.BalanceActivity.WithContext(ctx),
 		Bill:                    q.Bill.WithContext(ctx),
 		Channel:                 q.Channel.WithContext(ctx),
 		Client:                  q.Client.WithContext(ctx),
 		Coupon:                  q.Coupon.WithContext(ctx),
 		Edge:                    q.Edge.WithContext(ctx),
+		Inquiry:                 q.Inquiry.WithContext(ctx),
 		LinkAdminRole:           q.LinkAdminRole.WithContext(ctx),
 		LinkAdminRolePermission: q.LinkAdminRolePermission.WithContext(ctx),
 		LinkClientPermission:    q.LinkClientPermission.WithContext(ctx),
@@ -283,6 +320,9 @@ func (q *Query) WithContext(ctx context.Context) *queryCtx {
 		LogsUserUsage:           q.LogsUserUsage.WithContext(ctx),
 		Permission:              q.Permission.WithContext(ctx),
 		Product:                 q.Product.WithContext(ctx),
+		ProductDiscount:         q.ProductDiscount.WithContext(ctx),
+		ProductSku:              q.ProductSku.WithContext(ctx),
+		ProductSkuUser:          q.ProductSkuUser.WithContext(ctx),
 		Proxy:                   q.Proxy.WithContext(ctx),
 		Refund:                  q.Refund.WithContext(ctx),
 		Resource:                q.Resource.WithContext(ctx),

web/queries/inquiry.gen.go

@@ -0,0 +1,359 @@
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+
+package queries
+
+import (
+	"context"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"platform/web/models"
+)
+
+func newInquiry(db *gorm.DB, opts ...gen.DOOption) inquiry {
+	_inquiry := inquiry{}
+
+	_inquiry.inquiryDo.UseDB(db, opts...)
+	_inquiry.inquiryDo.UseModel(&models.Inquiry{})
+
+	tableName := _inquiry.inquiryDo.TableName()
+	_inquiry.ALL = field.NewAsterisk(tableName)
+	_inquiry.ID = field.NewInt32(tableName, "id")
+	_inquiry.CreatedAt = field.NewTime(tableName, "created_at")
+	_inquiry.UpdatedAt = field.NewTime(tableName, "updated_at")
+	_inquiry.DeletedAt = field.NewField(tableName, "deleted_at")
+	_inquiry.Company = field.NewString(tableName, "company")
+	_inquiry.Name = field.NewString(tableName, "name")
+	_inquiry.Phone = field.NewString(tableName, "phone")
+	_inquiry.Email = field.NewString(tableName, "email")
+	_inquiry.Content = field.NewString(tableName, "content")
+	_inquiry.Status = field.NewInt(tableName, "status")
+	_inquiry.Remark = field.NewString(tableName, "remark")
+
+	_inquiry.fillFieldMap()
+
+	return _inquiry
+}
+
+type inquiry struct {
+	inquiryDo
+
+	ALL       field.Asterisk
+	ID        field.Int32
+	CreatedAt field.Time
+	UpdatedAt field.Time
+	DeletedAt field.Field
+	Company   field.String
+	Name      field.String
+	Phone     field.String
+	Email     field.String
+	Content   field.String
+	Status    field.Int
+	Remark    field.String
+
+	fieldMap map[string]field.Expr
+}
+
+func (i inquiry) Table(newTableName string) *inquiry {
+	i.inquiryDo.UseTable(newTableName)
+	return i.updateTableName(newTableName)
+}
+
+func (i inquiry) As(alias string) *inquiry {
+	i.inquiryDo.DO = *(i.inquiryDo.As(alias).(*gen.DO))
+	return i.updateTableName(alias)
+}
+
+func (i *inquiry) updateTableName(table string) *inquiry {
+	i.ALL = field.NewAsterisk(table)
+	i.ID = field.NewInt32(table, "id")
+	i.CreatedAt = field.NewTime(table, "created_at")
+	i.UpdatedAt = field.NewTime(table, "updated_at")
+	i.DeletedAt = field.NewField(table, "deleted_at")
+	i.Company = field.NewString(table, "company")
+	i.Name = field.NewString(table, "name")
+	i.Phone = field.NewString(table, "phone")
+	i.Email = field.NewString(table, "email")
+	i.Content = field.NewString(table, "content")
+	i.Status = field.NewInt(table, "status")
+	i.Remark = field.NewString(table, "remark")
+
+	i.fillFieldMap()
+
+	return i
+}
+
+func (i *inquiry) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
+	_f, ok := i.fieldMap[fieldName]
+	if !ok || _f == nil {
+		return nil, false
+	}
+	_oe, ok := _f.(field.OrderExpr)
+	return _oe, ok
+}
+
+func (i *inquiry) fillFieldMap() {
+	i.fieldMap = make(map[string]field.Expr, 11)
+	i.fieldMap["id"] = i.ID
+	i.fieldMap["created_at"] = i.CreatedAt
+	i.fieldMap["updated_at"] = i.UpdatedAt
+	i.fieldMap["deleted_at"] = i.DeletedAt
+	i.fieldMap["company"] = i.Company
+	i.fieldMap["name"] = i.Name
+	i.fieldMap["phone"] = i.Phone
+	i.fieldMap["email"] = i.Email
+	i.fieldMap["content"] = i.Content
+	i.fieldMap["status"] = i.Status
+	i.fieldMap["remark"] = i.Remark
+}
+
+func (i inquiry) clone(db *gorm.DB) inquiry {
+	i.inquiryDo.ReplaceConnPool(db.Statement.ConnPool)
+	return i
+}
+
+func (i inquiry) replaceDB(db *gorm.DB) inquiry {
+	i.inquiryDo.ReplaceDB(db)
+	return i
+}
+
+type inquiryDo struct{ gen.DO }
+
+func (i inquiryDo) Debug() *inquiryDo {
+	return i.withDO(i.DO.Debug())
+}
+
+func (i inquiryDo) WithContext(ctx context.Context) *inquiryDo {
+	return i.withDO(i.DO.WithContext(ctx))
+}
+
+func (i inquiryDo) ReadDB() *inquiryDo {
+	return i.Clauses(dbresolver.Read)
+}
+
+func (i inquiryDo) WriteDB() *inquiryDo {
+	return i.Clauses(dbresolver.Write)
+}
+
+func (i inquiryDo) Session(config *gorm.Session) *inquiryDo {
+	return i.withDO(i.DO.Session(config))
+}
+
+func (i inquiryDo) Clauses(conds ...clause.Expression) *inquiryDo {
+	return i.withDO(i.DO.Clauses(conds...))
+}
+
+func (i inquiryDo) Returning(value interface{}, columns ...string) *inquiryDo {
+	return i.withDO(i.DO.Returning(value, columns...))
+}
+
+func (i inquiryDo) Not(conds ...gen.Condition) *inquiryDo {
+	return i.withDO(i.DO.Not(conds...))
+}
+
+func (i inquiryDo) Or(conds ...gen.Condition) *inquiryDo {
+	return i.withDO(i.DO.Or(conds...))
+}
+
+func (i inquiryDo) Select(conds ...field.Expr) *inquiryDo {
+	return i.withDO(i.DO.Select(conds...))
+}
+
+func (i inquiryDo) Where(conds ...gen.Condition) *inquiryDo {
+	return i.withDO(i.DO.Where(conds...))
+}
+
+func (i inquiryDo) Order(conds ...field.Expr) *inquiryDo {
+	return i.withDO(i.DO.Order(conds...))
+}
+
+func (i inquiryDo) Distinct(cols ...field.Expr) *inquiryDo {
+	return i.withDO(i.DO.Distinct(cols...))
+}
+
+func (i inquiryDo) Omit(cols ...field.Expr) *inquiryDo {
+	return i.withDO(i.DO.Omit(cols...))
+}
+
+func (i inquiryDo) Join(table schema.Tabler, on ...field.Expr) *inquiryDo {
+	return i.withDO(i.DO.Join(table, on...))
+}
+
+func (i inquiryDo) LeftJoin(table schema.Tabler, on ...field.Expr) *inquiryDo {
+	return i.withDO(i.DO.LeftJoin(table, on...))
+}
+
+func (i inquiryDo) RightJoin(table schema.Tabler, on ...field.Expr) *inquiryDo {
+	return i.withDO(i.DO.RightJoin(table, on...))
+}
+
+func (i inquiryDo) Group(cols ...field.Expr) *inquiryDo {
+	return i.withDO(i.DO.Group(cols...))
+}
+
+func (i inquiryDo) Having(conds ...gen.Condition) *inquiryDo {
+	return i.withDO(i.DO.Having(conds...))
+}
+
+func (i inquiryDo) Limit(limit int) *inquiryDo {
+	return i.withDO(i.DO.Limit(limit))
+}
+
+func (i inquiryDo) Offset(offset int) *inquiryDo {
+	return i.withDO(i.DO.Offset(offset))
+}
+
+func (i inquiryDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *inquiryDo {
+	return i.withDO(i.DO.Scopes(funcs...))
+}
+
+func (i inquiryDo) Unscoped() *inquiryDo {
+	return i.withDO(i.DO.Unscoped())
+}
+
+func (i inquiryDo) Create(values ...*models.Inquiry) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return i.DO.Create(values)
+}
+
+func (i inquiryDo) CreateInBatches(values []*models.Inquiry, batchSize int) error {
+	return i.DO.CreateInBatches(values, batchSize)
+}
+
+// Save : !!! underlying implementation is different with GORM
+// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
+func (i inquiryDo) Save(values ...*models.Inquiry) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return i.DO.Save(values)
+}
+
+func (i inquiryDo) First() (*models.Inquiry, error) {
+	if result, err := i.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.Inquiry), nil
+	}
+}
+
+func (i inquiryDo) Take() (*models.Inquiry, error) {
+	if result, err := i.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.Inquiry), nil
+	}
+}
+
+func (i inquiryDo) Last() (*models.Inquiry, error) {
+	if result, err := i.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.Inquiry), nil
+	}
+}
+
+func (i inquiryDo) Find() ([]*models.Inquiry, error) {
+	result, err := i.DO.Find()
+	return result.([]*models.Inquiry), err
+}
+
+func (i inquiryDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*models.Inquiry, err error) {
+	buf := make([]*models.Inquiry, 0, batchSize)
+	err = i.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
+		defer func() { results = append(results, buf...) }()
+		return fc(tx, batch)
+	})
+	return results, err
+}
+
+func (i inquiryDo) FindInBatches(result *[]*models.Inquiry, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return i.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (i inquiryDo) Attrs(attrs ...field.AssignExpr) *inquiryDo {
+	return i.withDO(i.DO.Attrs(attrs...))
+}
+
+func (i inquiryDo) Assign(attrs ...field.AssignExpr) *inquiryDo {
+	return i.withDO(i.DO.Assign(attrs...))
+}
+
+func (i inquiryDo) Joins(fields ...field.RelationField) *inquiryDo {
+	for _, _f := range fields {
+		i = *i.withDO(i.DO.Joins(_f))
+	}
+	return &i
+}
+
+func (i inquiryDo) Preload(fields ...field.RelationField) *inquiryDo {
+	for _, _f := range fields {
+		i = *i.withDO(i.DO.Preload(_f))
+	}
+	return &i
+}
+
+func (i inquiryDo) FirstOrInit() (*models.Inquiry, error) {
+	if result, err := i.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.Inquiry), nil
+	}
+}
+
+func (i inquiryDo) FirstOrCreate() (*models.Inquiry, error) {
+	if result, err := i.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.Inquiry), nil
+	}
+}
+
+func (i inquiryDo) FindByPage(offset int, limit int) (result []*models.Inquiry, count int64, err error) {
+	result, err = i.Offset(offset).Limit(limit).Find()
+	if err != nil {
+		return
+	}
+
+	if size := len(result); 0 < limit && 0 < size && size < limit {
+		count = int64(size + offset)
+		return
+	}
+
+	count, err = i.Offset(-1).Limit(-1).Count()
+	return
+}
+
+func (i inquiryDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
+	count, err = i.Count()
+	if err != nil {
+		return
+	}
+
+	err = i.Offset(offset).Limit(limit).Scan(result)
+	return
+}
+
+func (i inquiryDo) Scan(result interface{}) (err error) {
+	return i.DO.Scan(result)
+}
+
+func (i inquiryDo) Delete(models ...*models.Inquiry) (result gen.ResultInfo, err error) {
+	return i.DO.Delete(models)
+}
+
+func (i *inquiryDo) withDO(do gen.Dao) *inquiryDo {
+	i.DO = *do.(*gen.DO)
+	return i
+}

web/queries/link_admin_role.gen.go

@@ -29,7 +29,7 @@ func newLinkAdminRole(db *gorm.DB, opts ...gen.DOOption) linkAdminRole {
 	_linkAdminRole.ALL = field.NewAsterisk(tableName)
 	_linkAdminRole.ID = field.NewInt32(tableName, "id")
 	_linkAdminRole.AdminID = field.NewInt32(tableName, "admin_id")
-	_linkAdminRole.RoleID = field.NewInt32(tableName, "role_id")
+	_linkAdminRole.RoleID = field.NewInt32(tableName, "admin_role_id")
 
 	_linkAdminRole.fillFieldMap()
 
@@ -61,7 +61,7 @@ func (l *linkAdminRole) updateTableName(table string) *linkAdminRole {
 	l.ALL = field.NewAsterisk(table)
 	l.ID = field.NewInt32(table, "id")
 	l.AdminID = field.NewInt32(table, "admin_id")
-	l.RoleID = field.NewInt32(table, "role_id")
+	l.RoleID = field.NewInt32(table, "admin_role_id")
 
 	l.fillFieldMap()
 
@@ -81,7 +81,7 @@ func (l *linkAdminRole) fillFieldMap() {
 	l.fieldMap = make(map[string]field.Expr, 3)
 	l.fieldMap["id"] = l.ID
 	l.fieldMap["admin_id"] = l.AdminID
-	l.fieldMap["role_id"] = l.RoleID
+	l.fieldMap["admin_role_id"] = l.RoleID
 }
 
 func (l linkAdminRole) clone(db *gorm.DB) linkAdminRole {

web/queries/link_admin_role_permission.gen.go

@@ -28,7 +28,7 @@ func newLinkAdminRolePermission(db *gorm.DB, opts ...gen.DOOption) linkAdminRole
 	tableName := _linkAdminRolePermission.linkAdminRolePermissionDo.TableName()
 	_linkAdminRolePermission.ALL = field.NewAsterisk(tableName)
 	_linkAdminRolePermission.ID = field.NewInt32(tableName, "id")
-	_linkAdminRolePermission.RoleID = field.NewInt32(tableName, "role_id")
+	_linkAdminRolePermission.RoleID = field.NewInt32(tableName, "admin_role_id")
 	_linkAdminRolePermission.PermissionID = field.NewInt32(tableName, "permission_id")
 
 	_linkAdminRolePermission.fillFieldMap()
@@ -60,7 +60,7 @@ func (l linkAdminRolePermission) As(alias string) *linkAdminRolePermission {
 func (l *linkAdminRolePermission) updateTableName(table string) *linkAdminRolePermission {
 	l.ALL = field.NewAsterisk(table)
 	l.ID = field.NewInt32(table, "id")
-	l.RoleID = field.NewInt32(table, "role_id")
+	l.RoleID = field.NewInt32(table, "admin_role_id")
 	l.PermissionID = field.NewInt32(table, "permission_id")
 
 	l.fillFieldMap()
@@ -80,7 +80,7 @@ func (l *linkAdminRolePermission) GetFieldByName(fieldName string) (field.OrderE
 func (l *linkAdminRolePermission) fillFieldMap() {
 	l.fieldMap = make(map[string]field.Expr, 3)
 	l.fieldMap["id"] = l.ID
-	l.fieldMap["role_id"] = l.RoleID
+	l.fieldMap["admin_role_id"] = l.RoleID
 	l.fieldMap["permission_id"] = l.PermissionID
 }
 

web/queries/link_user_role.gen.go

@@ -29,7 +29,7 @@ func newLinkUserRole(db *gorm.DB, opts ...gen.DOOption) linkUserRole {
 	_linkUserRole.ALL = field.NewAsterisk(tableName)
 	_linkUserRole.ID = field.NewInt32(tableName, "id")
 	_linkUserRole.UserID = field.NewInt32(tableName, "user_id")
-	_linkUserRole.RoleID = field.NewInt32(tableName, "role_id")
+	_linkUserRole.RoleID = field.NewInt32(tableName, "user_role_id")
 
 	_linkUserRole.fillFieldMap()
 
@@ -61,7 +61,7 @@ func (l *linkUserRole) updateTableName(table string) *linkUserRole {
 	l.ALL = field.NewAsterisk(table)
 	l.ID = field.NewInt32(table, "id")
 	l.UserID = field.NewInt32(table, "user_id")
-	l.RoleID = field.NewInt32(table, "role_id")
+	l.RoleID = field.NewInt32(table, "user_role_id")
 
 	l.fillFieldMap()
 
@@ -81,7 +81,7 @@ func (l *linkUserRole) fillFieldMap() {
 	l.fieldMap = make(map[string]field.Expr, 3)
 	l.fieldMap["id"] = l.ID
 	l.fieldMap["user_id"] = l.UserID
-	l.fieldMap["role_id"] = l.RoleID
+	l.fieldMap["user_role_id"] = l.RoleID
 }
 
 func (l linkUserRole) clone(db *gorm.DB) linkUserRole {

web/queries/link_user_role_permission.gen.go

@@ -28,7 +28,7 @@ func newLinkUserRolePermission(db *gorm.DB, opts ...gen.DOOption) linkUserRolePe
 	tableName := _linkUserRolePermission.linkUserRolePermissionDo.TableName()
 	_linkUserRolePermission.ALL = field.NewAsterisk(tableName)
 	_linkUserRolePermission.ID = field.NewInt32(tableName, "id")
-	_linkUserRolePermission.RoleID = field.NewInt32(tableName, "role_id")
+	_linkUserRolePermission.RoleID = field.NewInt32(tableName, "user_role_id")
 	_linkUserRolePermission.PermissionID = field.NewInt32(tableName, "permission_id")
 
 	_linkUserRolePermission.fillFieldMap()
@@ -60,7 +60,7 @@ func (l linkUserRolePermission) As(alias string) *linkUserRolePermission {
 func (l *linkUserRolePermission) updateTableName(table string) *linkUserRolePermission {
 	l.ALL = field.NewAsterisk(table)
 	l.ID = field.NewInt32(table, "id")
-	l.RoleID = field.NewInt32(table, "role_id")
+	l.RoleID = field.NewInt32(table, "user_role_id")
 	l.PermissionID = field.NewInt32(table, "permission_id")
 
 	l.fillFieldMap()
@@ -80,7 +80,7 @@ func (l *linkUserRolePermission) GetFieldByName(fieldName string) (field.OrderEx
 func (l *linkUserRolePermission) fillFieldMap() {
 	l.fieldMap = make(map[string]field.Expr, 3)
 	l.fieldMap["id"] = l.ID
-	l.fieldMap["role_id"] = l.RoleID
+	l.fieldMap["user_role_id"] = l.RoleID
 	l.fieldMap["permission_id"] = l.PermissionID
 }
 

web/queries/logs_login.gen.go

@@ -41,8 +41,73 @@ func newLogsLogin(db *gorm.DB, opts ...gen.DOOption) logsLogin {
 		RelationField: field.NewRelation("User", "models.User"),
 		Admin: struct {
 			field.RelationField
+			Roles struct {
+				field.RelationField
+				Permissions struct {
+					field.RelationField
+					Parent struct {
+						field.RelationField
+					}
+					Children struct {
+						field.RelationField
+					}
+				}
+			}
 		}{
 			RelationField: field.NewRelation("User.Admin", "models.Admin"),
+			Roles: struct {
+				field.RelationField
+				Permissions struct {
+					field.RelationField
+					Parent struct {
+						field.RelationField
+					}
+					Children struct {
+						field.RelationField
+					}
+				}
+			}{
+				RelationField: field.NewRelation("User.Admin.Roles", "models.AdminRole"),
+				Permissions: struct {
+					field.RelationField
+					Parent struct {
+						field.RelationField
+					}
+					Children struct {
+						field.RelationField
+					}
+				}{
+					RelationField: field.NewRelation("User.Admin.Roles.Permissions", "models.Permission"),
+					Parent: struct {
+						field.RelationField
+					}{
+						RelationField: field.NewRelation("User.Admin.Roles.Permissions.Parent", "models.Permission"),
+					},
+					Children: struct {
+						field.RelationField
+					}{
+						RelationField: field.NewRelation("User.Admin.Roles.Permissions.Children", "models.Permission"),
+					},
+				},
+			},
+		},
+		Discount: struct {
+			field.RelationField
+		}{
+			RelationField: field.NewRelation("User.Discount", "models.ProductDiscount"),
+		},
+		Roles: struct {
+			field.RelationField
+			Permissions struct {
+				field.RelationField
+			}
+		}{
+			RelationField: field.NewRelation("User.Roles", "models.UserRole"),
+			Permissions: struct {
+				field.RelationField
+			}{
+				RelationField: field.NewRelation("User.Roles.Permissions", "models.Permission"),
+			},
 		},
 	}
 
@@ -136,6 +201,27 @@ type logsLoginBelongsToUser struct {
 
 	Admin struct {
 		field.RelationField
+		Roles struct {
+			field.RelationField
+			Permissions struct {
+				field.RelationField
+				Parent struct {
+					field.RelationField
+				}
+				Children struct {
+					field.RelationField
+				}
+			}
+		}
+	}
+	Discount struct {
+		field.RelationField
+	}
+	Roles struct {
+		field.RelationField
+		Permissions struct {
+			field.RelationField
+		}
 	}
 }
 

web/queries/logs_request.gen.go

@@ -42,6 +42,27 @@ func newLogsRequest(db *gorm.DB, opts ...gen.DOOption) logsRequest {
 		db: db.Session(&gorm.Session{}),
 
 		RelationField: field.NewRelation("Client", "models.Client"),
+		Permissions: struct {
+			field.RelationField
+			Parent struct {
+				field.RelationField
+			}
+			Children struct {
+				field.RelationField
+			}
+		}{
+			RelationField: field.NewRelation("Client.Permissions", "models.Permission"),
+			Parent: struct {
+				field.RelationField
+			}{
+				RelationField: field.NewRelation("Client.Permissions.Parent", "models.Permission"),
+			},
+			Children: struct {
+				field.RelationField
+			}{
+				RelationField: field.NewRelation("Client.Permissions.Children", "models.Permission"),
+			},
+		},
 	}
 
 	_logsRequest.User = logsRequestBelongsToUser{
@@ -50,8 +71,45 @@ func newLogsRequest(db *gorm.DB, opts ...gen.DOOption) logsRequest {
 		RelationField: field.NewRelation("User", "models.User"),
 		Admin: struct {
 			field.RelationField
+			Roles struct {
+				field.RelationField
+				Permissions struct {
+					field.RelationField
+				}
+			}
 		}{
 			RelationField: field.NewRelation("User.Admin", "models.Admin"),
+			Roles: struct {
+				field.RelationField
+				Permissions struct {
+					field.RelationField
+				}
+			}{
+				RelationField: field.NewRelation("User.Admin.Roles", "models.AdminRole"),
+				Permissions: struct {
+					field.RelationField
+				}{
+					RelationField: field.NewRelation("User.Admin.Roles.Permissions", "models.Permission"),
+				},
+			},
+		},
+		Discount: struct {
+			field.RelationField
+		}{
+			RelationField: field.NewRelation("User.Discount", "models.ProductDiscount"),
+		},
+		Roles: struct {
+			field.RelationField
+			Permissions struct {
+				field.RelationField
+			}
+		}{
+			RelationField: field.NewRelation("User.Roles", "models.UserRole"),
+			Permissions: struct {
+				field.RelationField
+			}{
+				RelationField: field.NewRelation("User.Roles.Permissions", "models.Permission"),
+			},
 		},
 	}
 
@@ -156,6 +214,16 @@ type logsRequestHasOneClient struct {
 	db *gorm.DB
 
 	field.RelationField
+
+	Permissions struct {
+		field.RelationField
+		Parent struct {
+			field.RelationField
+		}
+		Children struct {
+			field.RelationField
+		}
+	}
 }
 
 func (a logsRequestHasOneClient) Where(conds ...field.Expr) *logsRequestHasOneClient {
@@ -240,6 +308,21 @@ type logsRequestBelongsToUser struct {
 
 	Admin struct {
 		field.RelationField
+		Roles struct {
+			field.RelationField
+			Permissions struct {
+				field.RelationField
+			}
+		}
+	}
+	Discount struct {
+		field.RelationField
+	}
+	Roles struct {
+		field.RelationField
+		Permissions struct {
+			field.RelationField
+		}
 	}
 }
 

web/queries/logs_user_usage.gen.go

@@ -37,6 +37,145 @@ func newLogsUserUsage(db *gorm.DB, opts ...gen.DOOption) logsUserUsage {
 	_logsUserUsage.ISP = field.NewString(tableName, "isp")
 	_logsUserUsage.IP = field.NewField(tableName, "ip")
 	_logsUserUsage.Time = field.NewTime(tableName, "time")
+	_logsUserUsage.User = logsUserUsageBelongsToUser{
+		db: db.Session(&gorm.Session{}),
+
+		RelationField: field.NewRelation("User", "models.User"),
+		Admin: struct {
+			field.RelationField
+			Roles struct {
+				field.RelationField
+				Permissions struct {
+					field.RelationField
+					Parent struct {
+						field.RelationField
+					}
+					Children struct {
+						field.RelationField
+					}
+				}
+			}
+		}{
+			RelationField: field.NewRelation("User.Admin", "models.Admin"),
+			Roles: struct {
+				field.RelationField
+				Permissions struct {
+					field.RelationField
+					Parent struct {
+						field.RelationField
+					}
+					Children struct {
+						field.RelationField
+					}
+				}
+			}{
+				RelationField: field.NewRelation("User.Admin.Roles", "models.AdminRole"),
+				Permissions: struct {
+					field.RelationField
+					Parent struct {
+						field.RelationField
+					}
+					Children struct {
+						field.RelationField
+					}
+				}{
+					RelationField: field.NewRelation("User.Admin.Roles.Permissions", "models.Permission"),
+					Parent: struct {
+						field.RelationField
+					}{
+						RelationField: field.NewRelation("User.Admin.Roles.Permissions.Parent", "models.Permission"),
+					},
+					Children: struct {
+						field.RelationField
+					}{
+						RelationField: field.NewRelation("User.Admin.Roles.Permissions.Children", "models.Permission"),
+					},
+				},
+			},
+		},
+		Discount: struct {
+			field.RelationField
+		}{
+			RelationField: field.NewRelation("User.Discount", "models.ProductDiscount"),
+		},
+		Roles: struct {
+			field.RelationField
+			Permissions struct {
+				field.RelationField
+			}
+		}{
+			RelationField: field.NewRelation("User.Roles", "models.UserRole"),
+			Permissions: struct {
+				field.RelationField
+			}{
+				RelationField: field.NewRelation("User.Roles.Permissions", "models.Permission"),
+			},
+		},
+	}
+
+	_logsUserUsage.Resource = logsUserUsageBelongsToResource{
+		db: db.Session(&gorm.Session{}),
+
+		RelationField: field.NewRelation("Resource", "models.Resource"),
+		User: struct {
+			field.RelationField
+		}{
+			RelationField: field.NewRelation("Resource.User", "models.User"),
+		},
+		Short: struct {
+			field.RelationField
+			Sku struct {
+				field.RelationField
+				Product struct {
+					field.RelationField
+				}
+				Discount struct {
+					field.RelationField
+				}
+			}
+		}{
+			RelationField: field.NewRelation("Resource.Short", "models.ResourceShort"),
+			Sku: struct {
+				field.RelationField
+				Product struct {
+					field.RelationField
+				}
+				Discount struct {
+					field.RelationField
+				}
+			}{
+				RelationField: field.NewRelation("Resource.Short.Sku", "models.ProductSku"),
+				Product: struct {
+					field.RelationField
+				}{
+					RelationField: field.NewRelation("Resource.Short.Sku.Product", "models.Product"),
+				},
+				Discount: struct {
+					field.RelationField
+				}{
+					RelationField: field.NewRelation("Resource.Short.Sku.Discount", "models.ProductDiscount"),
+				},
+			},
+		},
+		Long: struct {
+			field.RelationField
+			Sku struct {
+				field.RelationField
+			}
+		}{
+			RelationField: field.NewRelation("Resource.Long", "models.ResourceLong"),
+			Sku: struct {
+				field.RelationField
+			}{
+				RelationField: field.NewRelation("Resource.Long.Sku", "models.ProductSku"),
+			},
+		},
+		Product: struct {
+			field.RelationField
+		}{
+			RelationField: field.NewRelation("Resource.Product", "models.Product"),
+		},
+	}
 
 	_logsUserUsage.fillFieldMap()
 
@@ -57,6 +196,9 @@ type logsUserUsage struct {
 	ISP        field.String
 	IP         field.Field
 	Time       field.Time
+	User       logsUserUsageBelongsToUser
+
+	Resource logsUserUsageBelongsToResource
 
 	fieldMap map[string]field.Expr
 }
@@ -99,7 +241,7 @@ func (l *logsUserUsage) GetFieldByName(fieldName string) (field.OrderExpr, bool)
 }
 
 func (l *logsUserUsage) fillFieldMap() {
-	l.fieldMap = make(map[string]field.Expr, 10)
+	l.fieldMap = make(map[string]field.Expr, 12)
 	l.fieldMap["id"] = l.ID
 	l.fieldMap["user_id"] = l.UserID
 	l.fieldMap["resource_id"] = l.ResourceID
@@ -110,18 +252,237 @@ func (l *logsUserUsage) fillFieldMap() {
 	l.fieldMap["isp"] = l.ISP
 	l.fieldMap["ip"] = l.IP
 	l.fieldMap["time"] = l.Time
+
 }
 
 func (l logsUserUsage) clone(db *gorm.DB) logsUserUsage {
 	l.logsUserUsageDo.ReplaceConnPool(db.Statement.ConnPool)
+	l.User.db = db.Session(&gorm.Session{Initialized: true})
+	l.User.db.Statement.ConnPool = db.Statement.ConnPool
+	l.Resource.db = db.Session(&gorm.Session{Initialized: true})
+	l.Resource.db.Statement.ConnPool = db.Statement.ConnPool
 	return l
 }
 
 func (l logsUserUsage) replaceDB(db *gorm.DB) logsUserUsage {
 	l.logsUserUsageDo.ReplaceDB(db)
+	l.User.db = db.Session(&gorm.Session{})
+	l.Resource.db = db.Session(&gorm.Session{})
 	return l
 }
 
+type logsUserUsageBelongsToUser struct {
+	db *gorm.DB
+
+	field.RelationField
+
+	Admin struct {
+		field.RelationField
+		Roles struct {
+			field.RelationField
+			Permissions struct {
+				field.RelationField
+				Parent struct {
+					field.RelationField
+				}
+				Children struct {
+					field.RelationField
+				}
+			}
+		}
+	}
+	Discount struct {
+		field.RelationField
+	}
+	Roles struct {
+		field.RelationField
+		Permissions struct {
+			field.RelationField
+		}
+	}
+}
+
+func (a logsUserUsageBelongsToUser) Where(conds ...field.Expr) *logsUserUsageBelongsToUser {
+	if len(conds) == 0 {
+		return &a
+	}
+
+	exprs := make([]clause.Expression, 0, len(conds))
+	for _, cond := range conds {
+		exprs = append(exprs, cond.BeCond().(clause.Expression))
+	}
+	a.db = a.db.Clauses(clause.Where{Exprs: exprs})
+	return &a
+}
+
+func (a logsUserUsageBelongsToUser) WithContext(ctx context.Context) *logsUserUsageBelongsToUser {
+	a.db = a.db.WithContext(ctx)
+	return &a
+}
+
+func (a logsUserUsageBelongsToUser) Session(session *gorm.Session) *logsUserUsageBelongsToUser {
+	a.db = a.db.Session(session)
+	return &a
+}
+
+func (a logsUserUsageBelongsToUser) Model(m *models.LogsUserUsage) *logsUserUsageBelongsToUserTx {
+	return &logsUserUsageBelongsToUserTx{a.db.Model(m).Association(a.Name())}
+}
+
+func (a logsUserUsageBelongsToUser) Unscoped() *logsUserUsageBelongsToUser {
+	a.db = a.db.Unscoped()
+	return &a
+}
+
+type logsUserUsageBelongsToUserTx struct{ tx *gorm.Association }
+
+func (a logsUserUsageBelongsToUserTx) Find() (result *models.User, err error) {
+	return result, a.tx.Find(&result)
+}
+
+func (a logsUserUsageBelongsToUserTx) Append(values ...*models.User) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Append(targetValues...)
+}
+
+func (a logsUserUsageBelongsToUserTx) Replace(values ...*models.User) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Replace(targetValues...)
+}
+
+func (a logsUserUsageBelongsToUserTx) Delete(values ...*models.User) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Delete(targetValues...)
+}
+
+func (a logsUserUsageBelongsToUserTx) Clear() error {
+	return a.tx.Clear()
+}
+
+func (a logsUserUsageBelongsToUserTx) Count() int64 {
+	return a.tx.Count()
+}
+
+func (a logsUserUsageBelongsToUserTx) Unscoped() *logsUserUsageBelongsToUserTx {
+	a.tx = a.tx.Unscoped()
+	return &a
+}
+
+type logsUserUsageBelongsToResource struct {
+	db *gorm.DB
+
+	field.RelationField
+
+	User struct {
+		field.RelationField
+	}
+	Short struct {
+		field.RelationField
+		Sku struct {
+			field.RelationField
+			Product struct {
+				field.RelationField
+			}
+			Discount struct {
+				field.RelationField
+			}
+		}
+	}
+	Long struct {
+		field.RelationField
+		Sku struct {
+			field.RelationField
+		}
+	}
+	Product struct {
+		field.RelationField
+	}
+}
+
+func (a logsUserUsageBelongsToResource) Where(conds ...field.Expr) *logsUserUsageBelongsToResource {
+	if len(conds) == 0 {
+		return &a
+	}
+
+	exprs := make([]clause.Expression, 0, len(conds))
+	for _, cond := range conds {
+		exprs = append(exprs, cond.BeCond().(clause.Expression))
+	}
+	a.db = a.db.Clauses(clause.Where{Exprs: exprs})
+	return &a
+}
+
+func (a logsUserUsageBelongsToResource) WithContext(ctx context.Context) *logsUserUsageBelongsToResource {
+	a.db = a.db.WithContext(ctx)
+	return &a
+}
+
+func (a logsUserUsageBelongsToResource) Session(session *gorm.Session) *logsUserUsageBelongsToResource {
+	a.db = a.db.Session(session)
+	return &a
+}
+
+func (a logsUserUsageBelongsToResource) Model(m *models.LogsUserUsage) *logsUserUsageBelongsToResourceTx {
+	return &logsUserUsageBelongsToResourceTx{a.db.Model(m).Association(a.Name())}
+}
+
+func (a logsUserUsageBelongsToResource) Unscoped() *logsUserUsageBelongsToResource {
+	a.db = a.db.Unscoped()
+	return &a
+}
+
+type logsUserUsageBelongsToResourceTx struct{ tx *gorm.Association }
+
+func (a logsUserUsageBelongsToResourceTx) Find() (result *models.Resource, err error) {
+	return result, a.tx.Find(&result)
+}
+
+func (a logsUserUsageBelongsToResourceTx) Append(values ...*models.Resource) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Append(targetValues...)
+}
+
+func (a logsUserUsageBelongsToResourceTx) Replace(values ...*models.Resource) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Replace(targetValues...)
+}
+
+func (a logsUserUsageBelongsToResourceTx) Delete(values ...*models.Resource) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Delete(targetValues...)
+}
+
+func (a logsUserUsageBelongsToResourceTx) Clear() error {
+	return a.tx.Clear()
+}
+
+func (a logsUserUsageBelongsToResourceTx) Count() int64 {
+	return a.tx.Count()
+}
+
+func (a logsUserUsageBelongsToResourceTx) Unscoped() *logsUserUsageBelongsToResourceTx {
+	a.tx = a.tx.Unscoped()
+	return &a
+}
+
 type logsUserUsageDo struct{ gen.DO }
 
 func (l logsUserUsageDo) Debug() *logsUserUsageDo {

web/queries/permission.gen.go

@@ -34,6 +34,7 @@ func newPermission(db *gorm.DB, opts ...gen.DOOption) permission {
 	_permission.ParentID = field.NewInt32(tableName, "parent_id")
 	_permission.Name = field.NewString(tableName, "name")
 	_permission.Description = field.NewString(tableName, "description")
+	_permission.Sort = field.NewInt(tableName, "sort")
 	_permission.Children = permissionHasManyChildren{
 		db: db.Session(&gorm.Session{}),
 
@@ -72,6 +73,7 @@ type permission struct {
 	ParentID    field.Int32
 	Name        field.String
 	Description field.String
+	Sort        field.Int
 	Children    permissionHasManyChildren
 
 	Parent permissionBelongsToParent
@@ -98,6 +100,7 @@ func (p *permission) updateTableName(table string) *permission {
 	p.ParentID = field.NewInt32(table, "parent_id")
 	p.Name = field.NewString(table, "name")
 	p.Description = field.NewString(table, "description")
+	p.Sort = field.NewInt(table, "sort")
 
 	p.fillFieldMap()
 
@@ -114,7 +117,7 @@ func (p *permission) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
 }
 
 func (p *permission) fillFieldMap() {
-	p.fieldMap = make(map[string]field.Expr, 9)
+	p.fieldMap = make(map[string]field.Expr, 10)
 	p.fieldMap["id"] = p.ID
 	p.fieldMap["created_at"] = p.CreatedAt
 	p.fieldMap["updated_at"] = p.UpdatedAt
@@ -122,6 +125,7 @@ func (p *permission) fillFieldMap() {
 	p.fieldMap["parent_id"] = p.ParentID
 	p.fieldMap["name"] = p.Name
 	p.fieldMap["description"] = p.Description
+	p.fieldMap["sort"] = p.Sort
 
 }
 

web/queries/product_discount.gen.go

@@ -0,0 +1,339 @@
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+
+package queries
+
+import (
+	"context"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"platform/web/models"
+)
+
+func newProductDiscount(db *gorm.DB, opts ...gen.DOOption) productDiscount {
+	_productDiscount := productDiscount{}
+
+	_productDiscount.productDiscountDo.UseDB(db, opts...)
+	_productDiscount.productDiscountDo.UseModel(&models.ProductDiscount{})
+
+	tableName := _productDiscount.productDiscountDo.TableName()
+	_productDiscount.ALL = field.NewAsterisk(tableName)
+	_productDiscount.ID = field.NewInt32(tableName, "id")
+	_productDiscount.CreatedAt = field.NewTime(tableName, "created_at")
+	_productDiscount.UpdatedAt = field.NewTime(tableName, "updated_at")
+	_productDiscount.DeletedAt = field.NewField(tableName, "deleted_at")
+	_productDiscount.Name = field.NewString(tableName, "name")
+	_productDiscount.Discount = field.NewInt32(tableName, "discount")
+
+	_productDiscount.fillFieldMap()
+
+	return _productDiscount
+}
+
+type productDiscount struct {
+	productDiscountDo
+
+	ALL       field.Asterisk
+	ID        field.Int32
+	CreatedAt field.Time
+	UpdatedAt field.Time
+	DeletedAt field.Field
+	Name      field.String
+	Discount  field.Int32
+
+	fieldMap map[string]field.Expr
+}
+
+func (p productDiscount) Table(newTableName string) *productDiscount {
+	p.productDiscountDo.UseTable(newTableName)
+	return p.updateTableName(newTableName)
+}
+
+func (p productDiscount) As(alias string) *productDiscount {
+	p.productDiscountDo.DO = *(p.productDiscountDo.As(alias).(*gen.DO))
+	return p.updateTableName(alias)
+}
+
+func (p *productDiscount) updateTableName(table string) *productDiscount {
+	p.ALL = field.NewAsterisk(table)
+	p.ID = field.NewInt32(table, "id")
+	p.CreatedAt = field.NewTime(table, "created_at")
+	p.UpdatedAt = field.NewTime(table, "updated_at")
+	p.DeletedAt = field.NewField(table, "deleted_at")
+	p.Name = field.NewString(table, "name")
+	p.Discount = field.NewInt32(table, "discount")
+
+	p.fillFieldMap()
+
+	return p
+}
+
+func (p *productDiscount) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
+	_f, ok := p.fieldMap[fieldName]
+	if !ok || _f == nil {
+		return nil, false
+	}
+	_oe, ok := _f.(field.OrderExpr)
+	return _oe, ok
+}
+
+func (p *productDiscount) fillFieldMap() {
+	p.fieldMap = make(map[string]field.Expr, 6)
+	p.fieldMap["id"] = p.ID
+	p.fieldMap["created_at"] = p.CreatedAt
+	p.fieldMap["updated_at"] = p.UpdatedAt
+	p.fieldMap["deleted_at"] = p.DeletedAt
+	p.fieldMap["name"] = p.Name
+	p.fieldMap["discount"] = p.Discount
+}
+
+func (p productDiscount) clone(db *gorm.DB) productDiscount {
+	p.productDiscountDo.ReplaceConnPool(db.Statement.ConnPool)
+	return p
+}
+
+func (p productDiscount) replaceDB(db *gorm.DB) productDiscount {
+	p.productDiscountDo.ReplaceDB(db)
+	return p
+}
+
+type productDiscountDo struct{ gen.DO }
+
+func (p productDiscountDo) Debug() *productDiscountDo {
+	return p.withDO(p.DO.Debug())
+}
+
+func (p productDiscountDo) WithContext(ctx context.Context) *productDiscountDo {
+	return p.withDO(p.DO.WithContext(ctx))
+}
+
+func (p productDiscountDo) ReadDB() *productDiscountDo {
+	return p.Clauses(dbresolver.Read)
+}
+
+func (p productDiscountDo) WriteDB() *productDiscountDo {
+	return p.Clauses(dbresolver.Write)
+}
+
+func (p productDiscountDo) Session(config *gorm.Session) *productDiscountDo {
+	return p.withDO(p.DO.Session(config))
+}
+
+func (p productDiscountDo) Clauses(conds ...clause.Expression) *productDiscountDo {
+	return p.withDO(p.DO.Clauses(conds...))
+}
+
+func (p productDiscountDo) Returning(value interface{}, columns ...string) *productDiscountDo {
+	return p.withDO(p.DO.Returning(value, columns...))
+}
+
+func (p productDiscountDo) Not(conds ...gen.Condition) *productDiscountDo {
+	return p.withDO(p.DO.Not(conds...))
+}
+
+func (p productDiscountDo) Or(conds ...gen.Condition) *productDiscountDo {
+	return p.withDO(p.DO.Or(conds...))
+}
+
+func (p productDiscountDo) Select(conds ...field.Expr) *productDiscountDo {
+	return p.withDO(p.DO.Select(conds...))
+}
+
+func (p productDiscountDo) Where(conds ...gen.Condition) *productDiscountDo {
+	return p.withDO(p.DO.Where(conds...))
+}
+
+func (p productDiscountDo) Order(conds ...field.Expr) *productDiscountDo {
+	return p.withDO(p.DO.Order(conds...))
+}
+
+func (p productDiscountDo) Distinct(cols ...field.Expr) *productDiscountDo {
+	return p.withDO(p.DO.Distinct(cols...))
+}
+
+func (p productDiscountDo) Omit(cols ...field.Expr) *productDiscountDo {
+	return p.withDO(p.DO.Omit(cols...))
+}
+
+func (p productDiscountDo) Join(table schema.Tabler, on ...field.Expr) *productDiscountDo {
+	return p.withDO(p.DO.Join(table, on...))
+}
+
+func (p productDiscountDo) LeftJoin(table schema.Tabler, on ...field.Expr) *productDiscountDo {
+	return p.withDO(p.DO.LeftJoin(table, on...))
+}
+
+func (p productDiscountDo) RightJoin(table schema.Tabler, on ...field.Expr) *productDiscountDo {
+	return p.withDO(p.DO.RightJoin(table, on...))
+}
+
+func (p productDiscountDo) Group(cols ...field.Expr) *productDiscountDo {
+	return p.withDO(p.DO.Group(cols...))
+}
+
+func (p productDiscountDo) Having(conds ...gen.Condition) *productDiscountDo {
+	return p.withDO(p.DO.Having(conds...))
+}
+
+func (p productDiscountDo) Limit(limit int) *productDiscountDo {
+	return p.withDO(p.DO.Limit(limit))
+}
+
+func (p productDiscountDo) Offset(offset int) *productDiscountDo {
+	return p.withDO(p.DO.Offset(offset))
+}
+
+func (p productDiscountDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *productDiscountDo {
+	return p.withDO(p.DO.Scopes(funcs...))
+}
+
+func (p productDiscountDo) Unscoped() *productDiscountDo {
+	return p.withDO(p.DO.Unscoped())
+}
+
+func (p productDiscountDo) Create(values ...*models.ProductDiscount) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return p.DO.Create(values)
+}
+
+func (p productDiscountDo) CreateInBatches(values []*models.ProductDiscount, batchSize int) error {
+	return p.DO.CreateInBatches(values, batchSize)
+}
+
+// Save : !!! underlying implementation is different with GORM
+// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
+func (p productDiscountDo) Save(values ...*models.ProductDiscount) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return p.DO.Save(values)
+}
+
+func (p productDiscountDo) First() (*models.ProductDiscount, error) {
+	if result, err := p.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.ProductDiscount), nil
+	}
+}
+
+func (p productDiscountDo) Take() (*models.ProductDiscount, error) {
+	if result, err := p.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.ProductDiscount), nil
+	}
+}
+
+func (p productDiscountDo) Last() (*models.ProductDiscount, error) {
+	if result, err := p.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.ProductDiscount), nil
+	}
+}
+
+func (p productDiscountDo) Find() ([]*models.ProductDiscount, error) {
+	result, err := p.DO.Find()
+	return result.([]*models.ProductDiscount), err
+}
+
+func (p productDiscountDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*models.ProductDiscount, err error) {
+	buf := make([]*models.ProductDiscount, 0, batchSize)
+	err = p.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
+		defer func() { results = append(results, buf...) }()
+		return fc(tx, batch)
+	})
+	return results, err
+}
+
+func (p productDiscountDo) FindInBatches(result *[]*models.ProductDiscount, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return p.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (p productDiscountDo) Attrs(attrs ...field.AssignExpr) *productDiscountDo {
+	return p.withDO(p.DO.Attrs(attrs...))
+}
+
+func (p productDiscountDo) Assign(attrs ...field.AssignExpr) *productDiscountDo {
+	return p.withDO(p.DO.Assign(attrs...))
+}
+
+func (p productDiscountDo) Joins(fields ...field.RelationField) *productDiscountDo {
+	for _, _f := range fields {
+		p = *p.withDO(p.DO.Joins(_f))
+	}
+	return &p
+}
+
+func (p productDiscountDo) Preload(fields ...field.RelationField) *productDiscountDo {
+	for _, _f := range fields {
+		p = *p.withDO(p.DO.Preload(_f))
+	}
+	return &p
+}
+
+func (p productDiscountDo) FirstOrInit() (*models.ProductDiscount, error) {
+	if result, err := p.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.ProductDiscount), nil
+	}
+}
+
+func (p productDiscountDo) FirstOrCreate() (*models.ProductDiscount, error) {
+	if result, err := p.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.ProductDiscount), nil
+	}
+}
+
+func (p productDiscountDo) FindByPage(offset int, limit int) (result []*models.ProductDiscount, count int64, err error) {
+	result, err = p.Offset(offset).Limit(limit).Find()
+	if err != nil {
+		return
+	}
+
+	if size := len(result); 0 < limit && 0 < size && size < limit {
+		count = int64(size + offset)
+		return
+	}
+
+	count, err = p.Offset(-1).Limit(-1).Count()
+	return
+}
+
+func (p productDiscountDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
+	count, err = p.Count()
+	if err != nil {
+		return
+	}
+
+	err = p.Offset(offset).Limit(limit).Scan(result)
+	return
+}
+
+func (p productDiscountDo) Scan(result interface{}) (err error) {
+	return p.DO.Scan(result)
+}
+
+func (p productDiscountDo) Delete(models ...*models.ProductDiscount) (result gen.ResultInfo, err error) {
+	return p.DO.Delete(models)
+}
+
+func (p *productDiscountDo) withDO(do gen.Dao) *productDiscountDo {
+	p.DO = *do.(*gen.DO)
+	return p
+}

web/queries/product_sku.gen.go

@@ -0,0 +1,534 @@
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+
+package queries
+
+import (
+	"context"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"platform/web/models"
+)
+
+func newProductSku(db *gorm.DB, opts ...gen.DOOption) productSku {
+	_productSku := productSku{}
+
+	_productSku.productSkuDo.UseDB(db, opts...)
+	_productSku.productSkuDo.UseModel(&models.ProductSku{})
+
+	tableName := _productSku.productSkuDo.TableName()
+	_productSku.ALL = field.NewAsterisk(tableName)
+	_productSku.ID = field.NewInt32(tableName, "id")
+	_productSku.CreatedAt = field.NewTime(tableName, "created_at")
+	_productSku.UpdatedAt = field.NewTime(tableName, "updated_at")
+	_productSku.DeletedAt = field.NewField(tableName, "deleted_at")
+	_productSku.ProductID = field.NewInt32(tableName, "product_id")
+	_productSku.DiscountId = field.NewInt32(tableName, "discount_id")
+	_productSku.Code = field.NewString(tableName, "code")
+	_productSku.Name = field.NewString(tableName, "name")
+	_productSku.Price = field.NewField(tableName, "price")
+	_productSku.Product = productSkuBelongsToProduct{
+		db: db.Session(&gorm.Session{}),
+
+		RelationField: field.NewRelation("Product", "models.Product"),
+	}
+
+	_productSku.Discount = productSkuBelongsToDiscount{
+		db: db.Session(&gorm.Session{}),
+
+		RelationField: field.NewRelation("Discount", "models.ProductDiscount"),
+	}
+
+	_productSku.fillFieldMap()
+
+	return _productSku
+}
+
+type productSku struct {
+	productSkuDo
+
+	ALL        field.Asterisk
+	ID         field.Int32
+	CreatedAt  field.Time
+	UpdatedAt  field.Time
+	DeletedAt  field.Field
+	ProductID  field.Int32
+	DiscountId field.Int32
+	Code       field.String
+	Name       field.String
+	Price      field.Field
+	Product    productSkuBelongsToProduct
+
+	Discount productSkuBelongsToDiscount
+
+	fieldMap map[string]field.Expr
+}
+
+func (p productSku) Table(newTableName string) *productSku {
+	p.productSkuDo.UseTable(newTableName)
+	return p.updateTableName(newTableName)
+}
+
+func (p productSku) As(alias string) *productSku {
+	p.productSkuDo.DO = *(p.productSkuDo.As(alias).(*gen.DO))
+	return p.updateTableName(alias)
+}
+
+func (p *productSku) updateTableName(table string) *productSku {
+	p.ALL = field.NewAsterisk(table)
+	p.ID = field.NewInt32(table, "id")
+	p.CreatedAt = field.NewTime(table, "created_at")
+	p.UpdatedAt = field.NewTime(table, "updated_at")
+	p.DeletedAt = field.NewField(table, "deleted_at")
+	p.ProductID = field.NewInt32(table, "product_id")
+	p.DiscountId = field.NewInt32(table, "discount_id")
+	p.Code = field.NewString(table, "code")
+	p.Name = field.NewString(table, "name")
+	p.Price = field.NewField(table, "price")
+
+	p.fillFieldMap()
+
+	return p
+}
+
+func (p *productSku) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
+	_f, ok := p.fieldMap[fieldName]
+	if !ok || _f == nil {
+		return nil, false
+	}
+	_oe, ok := _f.(field.OrderExpr)
+	return _oe, ok
+}
+
+func (p *productSku) fillFieldMap() {
+	p.fieldMap = make(map[string]field.Expr, 11)
+	p.fieldMap["id"] = p.ID
+	p.fieldMap["created_at"] = p.CreatedAt
+	p.fieldMap["updated_at"] = p.UpdatedAt
+	p.fieldMap["deleted_at"] = p.DeletedAt
+	p.fieldMap["product_id"] = p.ProductID
+	p.fieldMap["discount_id"] = p.DiscountId
+	p.fieldMap["code"] = p.Code
+	p.fieldMap["name"] = p.Name
+	p.fieldMap["price"] = p.Price
+
+}
+
+func (p productSku) clone(db *gorm.DB) productSku {
+	p.productSkuDo.ReplaceConnPool(db.Statement.ConnPool)
+	p.Product.db = db.Session(&gorm.Session{Initialized: true})
+	p.Product.db.Statement.ConnPool = db.Statement.ConnPool
+	p.Discount.db = db.Session(&gorm.Session{Initialized: true})
+	p.Discount.db.Statement.ConnPool = db.Statement.ConnPool
+	return p
+}
+
+func (p productSku) replaceDB(db *gorm.DB) productSku {
+	p.productSkuDo.ReplaceDB(db)
+	p.Product.db = db.Session(&gorm.Session{})
+	p.Discount.db = db.Session(&gorm.Session{})
+	return p
+}
+
+type productSkuBelongsToProduct struct {
+	db *gorm.DB
+
+	field.RelationField
+}
+
+func (a productSkuBelongsToProduct) Where(conds ...field.Expr) *productSkuBelongsToProduct {
+	if len(conds) == 0 {
+		return &a
+	}
+
+	exprs := make([]clause.Expression, 0, len(conds))
+	for _, cond := range conds {
+		exprs = append(exprs, cond.BeCond().(clause.Expression))
+	}
+	a.db = a.db.Clauses(clause.Where{Exprs: exprs})
+	return &a
+}
+
+func (a productSkuBelongsToProduct) WithContext(ctx context.Context) *productSkuBelongsToProduct {
+	a.db = a.db.WithContext(ctx)
+	return &a
+}
+
+func (a productSkuBelongsToProduct) Session(session *gorm.Session) *productSkuBelongsToProduct {
+	a.db = a.db.Session(session)
+	return &a
+}
+
+func (a productSkuBelongsToProduct) Model(m *models.ProductSku) *productSkuBelongsToProductTx {
+	return &productSkuBelongsToProductTx{a.db.Model(m).Association(a.Name())}
+}
+
+func (a productSkuBelongsToProduct) Unscoped() *productSkuBelongsToProduct {
+	a.db = a.db.Unscoped()
+	return &a
+}
+
+type productSkuBelongsToProductTx struct{ tx *gorm.Association }
+
+func (a productSkuBelongsToProductTx) Find() (result *models.Product, err error) {
+	return result, a.tx.Find(&result)
+}
+
+func (a productSkuBelongsToProductTx) Append(values ...*models.Product) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Append(targetValues...)
+}
+
+func (a productSkuBelongsToProductTx) Replace(values ...*models.Product) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Replace(targetValues...)
+}
+
+func (a productSkuBelongsToProductTx) Delete(values ...*models.Product) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Delete(targetValues...)
+}
+
+func (a productSkuBelongsToProductTx) Clear() error {
+	return a.tx.Clear()
+}
+
+func (a productSkuBelongsToProductTx) Count() int64 {
+	return a.tx.Count()
+}
+
+func (a productSkuBelongsToProductTx) Unscoped() *productSkuBelongsToProductTx {
+	a.tx = a.tx.Unscoped()
+	return &a
+}
+
+type productSkuBelongsToDiscount struct {
+	db *gorm.DB
+
+	field.RelationField
+}
+
+func (a productSkuBelongsToDiscount) Where(conds ...field.Expr) *productSkuBelongsToDiscount {
+	if len(conds) == 0 {
+		return &a
+	}
+
+	exprs := make([]clause.Expression, 0, len(conds))
+	for _, cond := range conds {
+		exprs = append(exprs, cond.BeCond().(clause.Expression))
+	}
+	a.db = a.db.Clauses(clause.Where{Exprs: exprs})
+	return &a
+}
+
+func (a productSkuBelongsToDiscount) WithContext(ctx context.Context) *productSkuBelongsToDiscount {
+	a.db = a.db.WithContext(ctx)
+	return &a
+}
+
+func (a productSkuBelongsToDiscount) Session(session *gorm.Session) *productSkuBelongsToDiscount {
+	a.db = a.db.Session(session)
+	return &a
+}
+
+func (a productSkuBelongsToDiscount) Model(m *models.ProductSku) *productSkuBelongsToDiscountTx {
+	return &productSkuBelongsToDiscountTx{a.db.Model(m).Association(a.Name())}
+}
+
+func (a productSkuBelongsToDiscount) Unscoped() *productSkuBelongsToDiscount {
+	a.db = a.db.Unscoped()
+	return &a
+}
+
+type productSkuBelongsToDiscountTx struct{ tx *gorm.Association }
+
+func (a productSkuBelongsToDiscountTx) Find() (result *models.ProductDiscount, err error) {
+	return result, a.tx.Find(&result)
+}
+
+func (a productSkuBelongsToDiscountTx) Append(values ...*models.ProductDiscount) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Append(targetValues...)
+}
+
+func (a productSkuBelongsToDiscountTx) Replace(values ...*models.ProductDiscount) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Replace(targetValues...)
+}
+
+func (a productSkuBelongsToDiscountTx) Delete(values ...*models.ProductDiscount) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Delete(targetValues...)
+}
+
+func (a productSkuBelongsToDiscountTx) Clear() error {
+	return a.tx.Clear()
+}
+
+func (a productSkuBelongsToDiscountTx) Count() int64 {
+	return a.tx.Count()
+}
+
+func (a productSkuBelongsToDiscountTx) Unscoped() *productSkuBelongsToDiscountTx {
+	a.tx = a.tx.Unscoped()
+	return &a
+}
+
+type productSkuDo struct{ gen.DO }
+
+func (p productSkuDo) Debug() *productSkuDo {
+	return p.withDO(p.DO.Debug())
+}
+
+func (p productSkuDo) WithContext(ctx context.Context) *productSkuDo {
+	return p.withDO(p.DO.WithContext(ctx))
+}
+
+func (p productSkuDo) ReadDB() *productSkuDo {
+	return p.Clauses(dbresolver.Read)
+}
+
+func (p productSkuDo) WriteDB() *productSkuDo {
+	return p.Clauses(dbresolver.Write)
+}
+
+func (p productSkuDo) Session(config *gorm.Session) *productSkuDo {
+	return p.withDO(p.DO.Session(config))
+}
+
+func (p productSkuDo) Clauses(conds ...clause.Expression) *productSkuDo {
+	return p.withDO(p.DO.Clauses(conds...))
+}
+
+func (p productSkuDo) Returning(value interface{}, columns ...string) *productSkuDo {
+	return p.withDO(p.DO.Returning(value, columns...))
+}
+
+func (p productSkuDo) Not(conds ...gen.Condition) *productSkuDo {
+	return p.withDO(p.DO.Not(conds...))
+}
+
+func (p productSkuDo) Or(conds ...gen.Condition) *productSkuDo {
+	return p.withDO(p.DO.Or(conds...))
+}
+
+func (p productSkuDo) Select(conds ...field.Expr) *productSkuDo {
+	return p.withDO(p.DO.Select(conds...))
+}
+
+func (p productSkuDo) Where(conds ...gen.Condition) *productSkuDo {
+	return p.withDO(p.DO.Where(conds...))
+}
+
+func (p productSkuDo) Order(conds ...field.Expr) *productSkuDo {
+	return p.withDO(p.DO.Order(conds...))
+}
+
+func (p productSkuDo) Distinct(cols ...field.Expr) *productSkuDo {
+	return p.withDO(p.DO.Distinct(cols...))
+}
+
+func (p productSkuDo) Omit(cols ...field.Expr) *productSkuDo {
+	return p.withDO(p.DO.Omit(cols...))
+}
+
+func (p productSkuDo) Join(table schema.Tabler, on ...field.Expr) *productSkuDo {
+	return p.withDO(p.DO.Join(table, on...))
+}
+
+func (p productSkuDo) LeftJoin(table schema.Tabler, on ...field.Expr) *productSkuDo {
+	return p.withDO(p.DO.LeftJoin(table, on...))
+}
+
+func (p productSkuDo) RightJoin(table schema.Tabler, on ...field.Expr) *productSkuDo {
+	return p.withDO(p.DO.RightJoin(table, on...))
+}
+
+func (p productSkuDo) Group(cols ...field.Expr) *productSkuDo {
+	return p.withDO(p.DO.Group(cols...))
+}
+
+func (p productSkuDo) Having(conds ...gen.Condition) *productSkuDo {
+	return p.withDO(p.DO.Having(conds...))
+}
+
+func (p productSkuDo) Limit(limit int) *productSkuDo {
+	return p.withDO(p.DO.Limit(limit))
+}
+
+func (p productSkuDo) Offset(offset int) *productSkuDo {
+	return p.withDO(p.DO.Offset(offset))
+}
+
+func (p productSkuDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *productSkuDo {
+	return p.withDO(p.DO.Scopes(funcs...))
+}
+
+func (p productSkuDo) Unscoped() *productSkuDo {
+	return p.withDO(p.DO.Unscoped())
+}
+
+func (p productSkuDo) Create(values ...*models.ProductSku) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return p.DO.Create(values)
+}
+
+func (p productSkuDo) CreateInBatches(values []*models.ProductSku, batchSize int) error {
+	return p.DO.CreateInBatches(values, batchSize)
+}
+
+// Save : !!! underlying implementation is different with GORM
+// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
+func (p productSkuDo) Save(values ...*models.ProductSku) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return p.DO.Save(values)
+}
+
+func (p productSkuDo) First() (*models.ProductSku, error) {
+	if result, err := p.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.ProductSku), nil
+	}
+}
+
+func (p productSkuDo) Take() (*models.ProductSku, error) {
+	if result, err := p.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.ProductSku), nil
+	}
+}
+
+func (p productSkuDo) Last() (*models.ProductSku, error) {
+	if result, err := p.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.ProductSku), nil
+	}
+}
+
+func (p productSkuDo) Find() ([]*models.ProductSku, error) {
+	result, err := p.DO.Find()
+	return result.([]*models.ProductSku), err
+}
+
+func (p productSkuDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*models.ProductSku, err error) {
+	buf := make([]*models.ProductSku, 0, batchSize)
+	err = p.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
+		defer func() { results = append(results, buf...) }()
+		return fc(tx, batch)
+	})
+	return results, err
+}
+
+func (p productSkuDo) FindInBatches(result *[]*models.ProductSku, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return p.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (p productSkuDo) Attrs(attrs ...field.AssignExpr) *productSkuDo {
+	return p.withDO(p.DO.Attrs(attrs...))
+}
+
+func (p productSkuDo) Assign(attrs ...field.AssignExpr) *productSkuDo {
+	return p.withDO(p.DO.Assign(attrs...))
+}
+
+func (p productSkuDo) Joins(fields ...field.RelationField) *productSkuDo {
+	for _, _f := range fields {
+		p = *p.withDO(p.DO.Joins(_f))
+	}
+	return &p
+}
+
+func (p productSkuDo) Preload(fields ...field.RelationField) *productSkuDo {
+	for _, _f := range fields {
+		p = *p.withDO(p.DO.Preload(_f))
+	}
+	return &p
+}
+
+func (p productSkuDo) FirstOrInit() (*models.ProductSku, error) {
+	if result, err := p.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.ProductSku), nil
+	}
+}
+
+func (p productSkuDo) FirstOrCreate() (*models.ProductSku, error) {
+	if result, err := p.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.ProductSku), nil
+	}
+}
+
+func (p productSkuDo) FindByPage(offset int, limit int) (result []*models.ProductSku, count int64, err error) {
+	result, err = p.Offset(offset).Limit(limit).Find()
+	if err != nil {
+		return
+	}
+
+	if size := len(result); 0 < limit && 0 < size && size < limit {
+		count = int64(size + offset)
+		return
+	}
+
+	count, err = p.Offset(-1).Limit(-1).Count()
+	return
+}
+
+func (p productSkuDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
+	count, err = p.Count()
+	if err != nil {
+		return
+	}
+
+	err = p.Offset(offset).Limit(limit).Scan(result)
+	return
+}
+
+func (p productSkuDo) Scan(result interface{}) (err error) {
+	return p.DO.Scan(result)
+}
+
+func (p productSkuDo) Delete(models ...*models.ProductSku) (result gen.ResultInfo, err error) {
+	return p.DO.Delete(models)
+}
+
+func (p *productSkuDo) withDO(do gen.Dao) *productSkuDo {
+	p.DO = *do.(*gen.DO)
+	return p
+}

web/queries/product_sku_user.gen.go

@@ -0,0 +1,726 @@
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+
+package queries
+
+import (
+	"context"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"platform/web/models"
+)
+
+func newProductSkuUser(db *gorm.DB, opts ...gen.DOOption) productSkuUser {
+	_productSkuUser := productSkuUser{}
+
+	_productSkuUser.productSkuUserDo.UseDB(db, opts...)
+	_productSkuUser.productSkuUserDo.UseModel(&models.ProductSkuUser{})
+
+	tableName := _productSkuUser.productSkuUserDo.TableName()
+	_productSkuUser.ALL = field.NewAsterisk(tableName)
+	_productSkuUser.ID = field.NewInt32(tableName, "id")
+	_productSkuUser.UserID = field.NewInt32(tableName, "user_id")
+	_productSkuUser.ProductSkuID = field.NewInt32(tableName, "product_sku_id")
+	_productSkuUser.DiscountId = field.NewInt32(tableName, "discount_id")
+	_productSkuUser.CreatedAt = field.NewTime(tableName, "created_at")
+	_productSkuUser.UpdatedAt = field.NewTime(tableName, "updated_at")
+	_productSkuUser.User = productSkuUserBelongsToUser{
+		db: db.Session(&gorm.Session{}),
+
+		RelationField: field.NewRelation("User", "models.User"),
+		Admin: struct {
+			field.RelationField
+			Roles struct {
+				field.RelationField
+				Permissions struct {
+					field.RelationField
+					Parent struct {
+						field.RelationField
+					}
+					Children struct {
+						field.RelationField
+					}
+				}
+			}
+		}{
+			RelationField: field.NewRelation("User.Admin", "models.Admin"),
+			Roles: struct {
+				field.RelationField
+				Permissions struct {
+					field.RelationField
+					Parent struct {
+						field.RelationField
+					}
+					Children struct {
+						field.RelationField
+					}
+				}
+			}{
+				RelationField: field.NewRelation("User.Admin.Roles", "models.AdminRole"),
+				Permissions: struct {
+					field.RelationField
+					Parent struct {
+						field.RelationField
+					}
+					Children struct {
+						field.RelationField
+					}
+				}{
+					RelationField: field.NewRelation("User.Admin.Roles.Permissions", "models.Permission"),
+					Parent: struct {
+						field.RelationField
+					}{
+						RelationField: field.NewRelation("User.Admin.Roles.Permissions.Parent", "models.Permission"),
+					},
+					Children: struct {
+						field.RelationField
+					}{
+						RelationField: field.NewRelation("User.Admin.Roles.Permissions.Children", "models.Permission"),
+					},
+				},
+			},
+		},
+		Discount: struct {
+			field.RelationField
+		}{
+			RelationField: field.NewRelation("User.Discount", "models.ProductDiscount"),
+		},
+		Roles: struct {
+			field.RelationField
+			Permissions struct {
+				field.RelationField
+			}
+		}{
+			RelationField: field.NewRelation("User.Roles", "models.UserRole"),
+			Permissions: struct {
+				field.RelationField
+			}{
+				RelationField: field.NewRelation("User.Roles.Permissions", "models.Permission"),
+			},
+		},
+	}
+
+	_productSkuUser.ProductSku = productSkuUserBelongsToProductSku{
+		db: db.Session(&gorm.Session{}),
+
+		RelationField: field.NewRelation("ProductSku", "models.ProductSku"),
+		Product: struct {
+			field.RelationField
+		}{
+			RelationField: field.NewRelation("ProductSku.Product", "models.Product"),
+		},
+		Discount: struct {
+			field.RelationField
+		}{
+			RelationField: field.NewRelation("ProductSku.Discount", "models.ProductDiscount"),
+		},
+	}
+
+	_productSkuUser.Discount = productSkuUserBelongsToDiscount{
+		db: db.Session(&gorm.Session{}),
+
+		RelationField: field.NewRelation("Discount", "models.ProductDiscount"),
+	}
+
+	_productSkuUser.fillFieldMap()
+
+	return _productSkuUser
+}
+
+type productSkuUser struct {
+	productSkuUserDo
+
+	ALL          field.Asterisk
+	ID           field.Int32
+	UserID       field.Int32
+	ProductSkuID field.Int32
+	DiscountId   field.Int32
+	CreatedAt    field.Time
+	UpdatedAt    field.Time
+	User         productSkuUserBelongsToUser
+
+	ProductSku productSkuUserBelongsToProductSku
+
+	Discount productSkuUserBelongsToDiscount
+
+	fieldMap map[string]field.Expr
+}
+
+func (p productSkuUser) Table(newTableName string) *productSkuUser {
+	p.productSkuUserDo.UseTable(newTableName)
+	return p.updateTableName(newTableName)
+}
+
+func (p productSkuUser) As(alias string) *productSkuUser {
+	p.productSkuUserDo.DO = *(p.productSkuUserDo.As(alias).(*gen.DO))
+	return p.updateTableName(alias)
+}
+
+func (p *productSkuUser) updateTableName(table string) *productSkuUser {
+	p.ALL = field.NewAsterisk(table)
+	p.ID = field.NewInt32(table, "id")
+	p.UserID = field.NewInt32(table, "user_id")
+	p.ProductSkuID = field.NewInt32(table, "product_sku_id")
+	p.DiscountId = field.NewInt32(table, "discount_id")
+	p.CreatedAt = field.NewTime(table, "created_at")
+	p.UpdatedAt = field.NewTime(table, "updated_at")
+
+	p.fillFieldMap()
+
+	return p
+}
+
+func (p *productSkuUser) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
+	_f, ok := p.fieldMap[fieldName]
+	if !ok || _f == nil {
+		return nil, false
+	}
+	_oe, ok := _f.(field.OrderExpr)
+	return _oe, ok
+}
+
+func (p *productSkuUser) fillFieldMap() {
+	p.fieldMap = make(map[string]field.Expr, 9)
+	p.fieldMap["id"] = p.ID
+	p.fieldMap["user_id"] = p.UserID
+	p.fieldMap["product_sku_id"] = p.ProductSkuID
+	p.fieldMap["discount_id"] = p.DiscountId
+	p.fieldMap["created_at"] = p.CreatedAt
+	p.fieldMap["updated_at"] = p.UpdatedAt
+
+}
+
+func (p productSkuUser) clone(db *gorm.DB) productSkuUser {
+	p.productSkuUserDo.ReplaceConnPool(db.Statement.ConnPool)
+	p.User.db = db.Session(&gorm.Session{Initialized: true})
+	p.User.db.Statement.ConnPool = db.Statement.ConnPool
+	p.ProductSku.db = db.Session(&gorm.Session{Initialized: true})
+	p.ProductSku.db.Statement.ConnPool = db.Statement.ConnPool
+	p.Discount.db = db.Session(&gorm.Session{Initialized: true})
+	p.Discount.db.Statement.ConnPool = db.Statement.ConnPool
+	return p
+}
+
+func (p productSkuUser) replaceDB(db *gorm.DB) productSkuUser {
+	p.productSkuUserDo.ReplaceDB(db)
+	p.User.db = db.Session(&gorm.Session{})
+	p.ProductSku.db = db.Session(&gorm.Session{})
+	p.Discount.db = db.Session(&gorm.Session{})
+	return p
+}
+
+type productSkuUserBelongsToUser struct {
+	db *gorm.DB
+
+	field.RelationField
+
+	Admin struct {
+		field.RelationField
+		Roles struct {
+			field.RelationField
+			Permissions struct {
+				field.RelationField
+				Parent struct {
+					field.RelationField
+				}
+				Children struct {
+					field.RelationField
+				}
+			}
+		}
+	}
+	Discount struct {
+		field.RelationField
+	}
+	Roles struct {
+		field.RelationField
+		Permissions struct {
+			field.RelationField
+		}
+	}
+}
+
+func (a productSkuUserBelongsToUser) Where(conds ...field.Expr) *productSkuUserBelongsToUser {
+	if len(conds) == 0 {
+		return &a
+	}
+
+	exprs := make([]clause.Expression, 0, len(conds))
+	for _, cond := range conds {
+		exprs = append(exprs, cond.BeCond().(clause.Expression))
+	}
+	a.db = a.db.Clauses(clause.Where{Exprs: exprs})
+	return &a
+}
+
+func (a productSkuUserBelongsToUser) WithContext(ctx context.Context) *productSkuUserBelongsToUser {
+	a.db = a.db.WithContext(ctx)
+	return &a
+}
+
+func (a productSkuUserBelongsToUser) Session(session *gorm.Session) *productSkuUserBelongsToUser {
+	a.db = a.db.Session(session)
+	return &a
+}
+
+func (a productSkuUserBelongsToUser) Model(m *models.ProductSkuUser) *productSkuUserBelongsToUserTx {
+	return &productSkuUserBelongsToUserTx{a.db.Model(m).Association(a.Name())}
+}
+
+func (a productSkuUserBelongsToUser) Unscoped() *productSkuUserBelongsToUser {
+	a.db = a.db.Unscoped()
+	return &a
+}
+
+type productSkuUserBelongsToUserTx struct{ tx *gorm.Association }
+
+func (a productSkuUserBelongsToUserTx) Find() (result *models.User, err error) {
+	return result, a.tx.Find(&result)
+}
+
+func (a productSkuUserBelongsToUserTx) Append(values ...*models.User) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Append(targetValues...)
+}
+
+func (a productSkuUserBelongsToUserTx) Replace(values ...*models.User) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Replace(targetValues...)
+}
+
+func (a productSkuUserBelongsToUserTx) Delete(values ...*models.User) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Delete(targetValues...)
+}
+
+func (a productSkuUserBelongsToUserTx) Clear() error {
+	return a.tx.Clear()
+}
+
+func (a productSkuUserBelongsToUserTx) Count() int64 {
+	return a.tx.Count()
+}
+
+func (a productSkuUserBelongsToUserTx) Unscoped() *productSkuUserBelongsToUserTx {
+	a.tx = a.tx.Unscoped()
+	return &a
+}
+
+type productSkuUserBelongsToProductSku struct {
+	db *gorm.DB
+
+	field.RelationField
+
+	Product struct {
+		field.RelationField
+	}
+	Discount struct {
+		field.RelationField
+	}
+}
+
+func (a productSkuUserBelongsToProductSku) Where(conds ...field.Expr) *productSkuUserBelongsToProductSku {
+	if len(conds) == 0 {
+		return &a
+	}
+
+	exprs := make([]clause.Expression, 0, len(conds))
+	for _, cond := range conds {
+		exprs = append(exprs, cond.BeCond().(clause.Expression))
+	}
+	a.db = a.db.Clauses(clause.Where{Exprs: exprs})
+	return &a
+}
+
+func (a productSkuUserBelongsToProductSku) WithContext(ctx context.Context) *productSkuUserBelongsToProductSku {
+	a.db = a.db.WithContext(ctx)
+	return &a
+}
+
+func (a productSkuUserBelongsToProductSku) Session(session *gorm.Session) *productSkuUserBelongsToProductSku {
+	a.db = a.db.Session(session)
+	return &a
+}
+
+func (a productSkuUserBelongsToProductSku) Model(m *models.ProductSkuUser) *productSkuUserBelongsToProductSkuTx {
+	return &productSkuUserBelongsToProductSkuTx{a.db.Model(m).Association(a.Name())}
+}
+
+func (a productSkuUserBelongsToProductSku) Unscoped() *productSkuUserBelongsToProductSku {
+	a.db = a.db.Unscoped()
+	return &a
+}
+
+type productSkuUserBelongsToProductSkuTx struct{ tx *gorm.Association }
+
+func (a productSkuUserBelongsToProductSkuTx) Find() (result *models.ProductSku, err error) {
+	return result, a.tx.Find(&result)
+}
+
+func (a productSkuUserBelongsToProductSkuTx) Append(values ...*models.ProductSku) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Append(targetValues...)
+}
+
+func (a productSkuUserBelongsToProductSkuTx) Replace(values ...*models.ProductSku) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Replace(targetValues...)
+}
+
+func (a productSkuUserBelongsToProductSkuTx) Delete(values ...*models.ProductSku) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Delete(targetValues...)
+}
+
+func (a productSkuUserBelongsToProductSkuTx) Clear() error {
+	return a.tx.Clear()
+}
+
+func (a productSkuUserBelongsToProductSkuTx) Count() int64 {
+	return a.tx.Count()
+}
+
+func (a productSkuUserBelongsToProductSkuTx) Unscoped() *productSkuUserBelongsToProductSkuTx {
+	a.tx = a.tx.Unscoped()
+	return &a
+}
+
+type productSkuUserBelongsToDiscount struct {
+	db *gorm.DB
+
+	field.RelationField
+}
+
+func (a productSkuUserBelongsToDiscount) Where(conds ...field.Expr) *productSkuUserBelongsToDiscount {
+	if len(conds) == 0 {
+		return &a
+	}
+
+	exprs := make([]clause.Expression, 0, len(conds))
+	for _, cond := range conds {
+		exprs = append(exprs, cond.BeCond().(clause.Expression))
+	}
+	a.db = a.db.Clauses(clause.Where{Exprs: exprs})
+	return &a
+}
+
+func (a productSkuUserBelongsToDiscount) WithContext(ctx context.Context) *productSkuUserBelongsToDiscount {
+	a.db = a.db.WithContext(ctx)
+	return &a
+}
+
+func (a productSkuUserBelongsToDiscount) Session(session *gorm.Session) *productSkuUserBelongsToDiscount {
+	a.db = a.db.Session(session)
+	return &a
+}
+
+func (a productSkuUserBelongsToDiscount) Model(m *models.ProductSkuUser) *productSkuUserBelongsToDiscountTx {
+	return &productSkuUserBelongsToDiscountTx{a.db.Model(m).Association(a.Name())}
+}
+
+func (a productSkuUserBelongsToDiscount) Unscoped() *productSkuUserBelongsToDiscount {
+	a.db = a.db.Unscoped()
+	return &a
+}
+
+type productSkuUserBelongsToDiscountTx struct{ tx *gorm.Association }
+
+func (a productSkuUserBelongsToDiscountTx) Find() (result *models.ProductDiscount, err error) {
+	return result, a.tx.Find(&result)
+}
+
+func (a productSkuUserBelongsToDiscountTx) Append(values ...*models.ProductDiscount) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Append(targetValues...)
+}
+
+func (a productSkuUserBelongsToDiscountTx) Replace(values ...*models.ProductDiscount) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Replace(targetValues...)
+}
+
+func (a productSkuUserBelongsToDiscountTx) Delete(values ...*models.ProductDiscount) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Delete(targetValues...)
+}
+
+func (a productSkuUserBelongsToDiscountTx) Clear() error {
+	return a.tx.Clear()
+}
+
+func (a productSkuUserBelongsToDiscountTx) Count() int64 {
+	return a.tx.Count()
+}
+
+func (a productSkuUserBelongsToDiscountTx) Unscoped() *productSkuUserBelongsToDiscountTx {
+	a.tx = a.tx.Unscoped()
+	return &a
+}
+
+type productSkuUserDo struct{ gen.DO }
+
+func (p productSkuUserDo) Debug() *productSkuUserDo {
+	return p.withDO(p.DO.Debug())
+}
+
+func (p productSkuUserDo) WithContext(ctx context.Context) *productSkuUserDo {
+	return p.withDO(p.DO.WithContext(ctx))
+}
+
+func (p productSkuUserDo) ReadDB() *productSkuUserDo {
+	return p.Clauses(dbresolver.Read)
+}
+
+func (p productSkuUserDo) WriteDB() *productSkuUserDo {
+	return p.Clauses(dbresolver.Write)
+}
+
+func (p productSkuUserDo) Session(config *gorm.Session) *productSkuUserDo {
+	return p.withDO(p.DO.Session(config))
+}
+
+func (p productSkuUserDo) Clauses(conds ...clause.Expression) *productSkuUserDo {
+	return p.withDO(p.DO.Clauses(conds...))
+}
+
+func (p productSkuUserDo) Returning(value interface{}, columns ...string) *productSkuUserDo {
+	return p.withDO(p.DO.Returning(value, columns...))
+}
+
+func (p productSkuUserDo) Not(conds ...gen.Condition) *productSkuUserDo {
+	return p.withDO(p.DO.Not(conds...))
+}
+
+func (p productSkuUserDo) Or(conds ...gen.Condition) *productSkuUserDo {
+	return p.withDO(p.DO.Or(conds...))
+}
+
+func (p productSkuUserDo) Select(conds ...field.Expr) *productSkuUserDo {
+	return p.withDO(p.DO.Select(conds...))
+}
+
+func (p productSkuUserDo) Where(conds ...gen.Condition) *productSkuUserDo {
+	return p.withDO(p.DO.Where(conds...))
+}
+
+func (p productSkuUserDo) Order(conds ...field.Expr) *productSkuUserDo {
+	return p.withDO(p.DO.Order(conds...))
+}
+
+func (p productSkuUserDo) Distinct(cols ...field.Expr) *productSkuUserDo {
+	return p.withDO(p.DO.Distinct(cols...))
+}
+
+func (p productSkuUserDo) Omit(cols ...field.Expr) *productSkuUserDo {
+	return p.withDO(p.DO.Omit(cols...))
+}
+
+func (p productSkuUserDo) Join(table schema.Tabler, on ...field.Expr) *productSkuUserDo {
+	return p.withDO(p.DO.Join(table, on...))
+}
+
+func (p productSkuUserDo) LeftJoin(table schema.Tabler, on ...field.Expr) *productSkuUserDo {
+	return p.withDO(p.DO.LeftJoin(table, on...))
+}
+
+func (p productSkuUserDo) RightJoin(table schema.Tabler, on ...field.Expr) *productSkuUserDo {
+	return p.withDO(p.DO.RightJoin(table, on...))
+}
+
+func (p productSkuUserDo) Group(cols ...field.Expr) *productSkuUserDo {
+	return p.withDO(p.DO.Group(cols...))
+}
+
+func (p productSkuUserDo) Having(conds ...gen.Condition) *productSkuUserDo {
+	return p.withDO(p.DO.Having(conds...))
+}
+
+func (p productSkuUserDo) Limit(limit int) *productSkuUserDo {
+	return p.withDO(p.DO.Limit(limit))
+}
+
+func (p productSkuUserDo) Offset(offset int) *productSkuUserDo {
+	return p.withDO(p.DO.Offset(offset))
+}
+
+func (p productSkuUserDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *productSkuUserDo {
+	return p.withDO(p.DO.Scopes(funcs...))
+}
+
+func (p productSkuUserDo) Unscoped() *productSkuUserDo {
+	return p.withDO(p.DO.Unscoped())
+}
+
+func (p productSkuUserDo) Create(values ...*models.ProductSkuUser) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return p.DO.Create(values)
+}
+
+func (p productSkuUserDo) CreateInBatches(values []*models.ProductSkuUser, batchSize int) error {
+	return p.DO.CreateInBatches(values, batchSize)
+}
+
+// Save : !!! underlying implementation is different with GORM
+// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
+func (p productSkuUserDo) Save(values ...*models.ProductSkuUser) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return p.DO.Save(values)
+}
+
+func (p productSkuUserDo) First() (*models.ProductSkuUser, error) {
+	if result, err := p.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.ProductSkuUser), nil
+	}
+}
+
+func (p productSkuUserDo) Take() (*models.ProductSkuUser, error) {
+	if result, err := p.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.ProductSkuUser), nil
+	}
+}
+
+func (p productSkuUserDo) Last() (*models.ProductSkuUser, error) {
+	if result, err := p.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.ProductSkuUser), nil
+	}
+}
+
+func (p productSkuUserDo) Find() ([]*models.ProductSkuUser, error) {
+	result, err := p.DO.Find()
+	return result.([]*models.ProductSkuUser), err
+}
+
+func (p productSkuUserDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*models.ProductSkuUser, err error) {
+	buf := make([]*models.ProductSkuUser, 0, batchSize)
+	err = p.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
+		defer func() { results = append(results, buf...) }()
+		return fc(tx, batch)
+	})
+	return results, err
+}
+
+func (p productSkuUserDo) FindInBatches(result *[]*models.ProductSkuUser, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return p.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (p productSkuUserDo) Attrs(attrs ...field.AssignExpr) *productSkuUserDo {
+	return p.withDO(p.DO.Attrs(attrs...))
+}
+
+func (p productSkuUserDo) Assign(attrs ...field.AssignExpr) *productSkuUserDo {
+	return p.withDO(p.DO.Assign(attrs...))
+}
+
+func (p productSkuUserDo) Joins(fields ...field.RelationField) *productSkuUserDo {
+	for _, _f := range fields {
+		p = *p.withDO(p.DO.Joins(_f))
+	}
+	return &p
+}
+
+func (p productSkuUserDo) Preload(fields ...field.RelationField) *productSkuUserDo {
+	for _, _f := range fields {
+		p = *p.withDO(p.DO.Preload(_f))
+	}
+	return &p
+}
+
+func (p productSkuUserDo) FirstOrInit() (*models.ProductSkuUser, error) {
+	if result, err := p.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.ProductSkuUser), nil
+	}
+}
+
+func (p productSkuUserDo) FirstOrCreate() (*models.ProductSkuUser, error) {
+	if result, err := p.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.ProductSkuUser), nil
+	}
+}
+
+func (p productSkuUserDo) FindByPage(offset int, limit int) (result []*models.ProductSkuUser, count int64, err error) {
+	result, err = p.Offset(offset).Limit(limit).Find()
+	if err != nil {
+		return
+	}
+
+	if size := len(result); 0 < limit && 0 < size && size < limit {
+		count = int64(size + offset)
+		return
+	}
+
+	count, err = p.Offset(-1).Limit(-1).Count()
+	return
+}
+
+func (p productSkuUserDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
+	count, err = p.Count()
+	if err != nil {
+		return
+	}
+
+	err = p.Offset(offset).Limit(limit).Scan(result)
+	return
+}
+
+func (p productSkuUserDo) Scan(result interface{}) (err error) {
+	return p.DO.Scan(result)
+}
+
+func (p productSkuUserDo) Delete(models ...*models.ProductSkuUser) (result gen.ResultInfo, err error) {
+	return p.DO.Delete(models)
+}
+
+func (p *productSkuUserDo) withDO(do gen.Dao) *productSkuUserDo {
+	p.DO = *do.(*gen.DO)
+	return p
+}

web/queries/proxy.gen.go

@@ -34,6 +34,7 @@ func newProxy(db *gorm.DB, opts ...gen.DOOption) proxy {
 	_proxy.Version = field.NewInt32(tableName, "version")
 	_proxy.Mac = field.NewString(tableName, "mac")
 	_proxy.IP = field.NewField(tableName, "ip")
+	_proxy.Host = field.NewString(tableName, "host")
 	_proxy.Secret = field.NewString(tableName, "secret")
 	_proxy.Type = field.NewInt(tableName, "type")
 	_proxy.Status = field.NewInt(tableName, "status")
@@ -46,13 +47,99 @@ func newProxy(db *gorm.DB, opts ...gen.DOOption) proxy {
 			field.RelationField
 			Admin struct {
 				field.RelationField
+				Roles struct {
+					field.RelationField
+					Permissions struct {
+						field.RelationField
+						Parent struct {
+							field.RelationField
+						}
+						Children struct {
+							field.RelationField
+						}
+					}
+				}
+			}
+			Discount struct {
+				field.RelationField
+			}
+			Roles struct {
+				field.RelationField
+				Permissions struct {
+					field.RelationField
+				}
 			}
 		}{
 			RelationField: field.NewRelation("Channels.User", "models.User"),
 			Admin: struct {
 				field.RelationField
+				Roles struct {
+					field.RelationField
+					Permissions struct {
+						field.RelationField
+						Parent struct {
+							field.RelationField
+						}
+						Children struct {
+							field.RelationField
+						}
+					}
+				}
 			}{
 				RelationField: field.NewRelation("Channels.User.Admin", "models.Admin"),
+				Roles: struct {
+					field.RelationField
+					Permissions struct {
+						field.RelationField
+						Parent struct {
+							field.RelationField
+						}
+						Children struct {
+							field.RelationField
+						}
+					}
+				}{
+					RelationField: field.NewRelation("Channels.User.Admin.Roles", "models.AdminRole"),
+					Permissions: struct {
+						field.RelationField
+						Parent struct {
+							field.RelationField
+						}
+						Children struct {
+							field.RelationField
+						}
+					}{
+						RelationField: field.NewRelation("Channels.User.Admin.Roles.Permissions", "models.Permission"),
+						Parent: struct {
+							field.RelationField
+						}{
+							RelationField: field.NewRelation("Channels.User.Admin.Roles.Permissions.Parent", "models.Permission"),
+						},
+						Children: struct {
+							field.RelationField
+						}{
+							RelationField: field.NewRelation("Channels.User.Admin.Roles.Permissions.Children", "models.Permission"),
+						},
+					},
+				},
+			},
+			Discount: struct {
+				field.RelationField
+			}{
+				RelationField: field.NewRelation("Channels.User.Discount", "models.ProductDiscount"),
+			},
+			Roles: struct {
+				field.RelationField
+				Permissions struct {
+					field.RelationField
+				}
+			}{
+				RelationField: field.NewRelation("Channels.User.Roles", "models.UserRole"),
+				Permissions: struct {
+					field.RelationField
+				}{
+					RelationField: field.NewRelation("Channels.User.Roles.Permissions", "models.Permission"),
+				},
 			},
 		},
 		Resource: struct {
@@ -62,9 +149,24 @@ func newProxy(db *gorm.DB, opts ...gen.DOOption) proxy {
 			}
 			Short struct {
 				field.RelationField
+				Sku struct {
+					field.RelationField
+					Product struct {
+						field.RelationField
+					}
+					Discount struct {
+						field.RelationField
+					}
+				}
 			}
 			Long struct {
 				field.RelationField
+				Sku struct {
+					field.RelationField
+				}
+			}
+			Product struct {
+				field.RelationField
 			}
 		}{
 			RelationField: field.NewRelation("Channels.Resource", "models.Resource"),
@@ -75,13 +177,56 @@ func newProxy(db *gorm.DB, opts ...gen.DOOption) proxy {
 			},
 			Short: struct {
 				field.RelationField
+				Sku struct {
+					field.RelationField
+					Product struct {
+						field.RelationField
+					}
+					Discount struct {
+						field.RelationField
+					}
+				}
 			}{
 				RelationField: field.NewRelation("Channels.Resource.Short", "models.ResourceShort"),
+				Sku: struct {
+					field.RelationField
+					Product struct {
+						field.RelationField
+					}
+					Discount struct {
+						field.RelationField
+					}
+				}{
+					RelationField: field.NewRelation("Channels.Resource.Short.Sku", "models.ProductSku"),
+					Product: struct {
+						field.RelationField
+					}{
+						RelationField: field.NewRelation("Channels.Resource.Short.Sku.Product", "models.Product"),
+					},
+					Discount: struct {
+						field.RelationField
+					}{
+						RelationField: field.NewRelation("Channels.Resource.Short.Sku.Discount", "models.ProductDiscount"),
+					},
+				},
 			},
 			Long: struct {
 				field.RelationField
+				Sku struct {
+					field.RelationField
+				}
 			}{
 				RelationField: field.NewRelation("Channels.Resource.Long", "models.ResourceLong"),
+				Sku: struct {
+					field.RelationField
+				}{
+					RelationField: field.NewRelation("Channels.Resource.Long.Sku", "models.ProductSku"),
+				},
+			},
+			Product: struct {
+				field.RelationField
+			}{
+				RelationField: field.NewRelation("Channels.Resource.Product", "models.Product"),
 			},
 		},
 		Proxy: struct {
@@ -120,6 +265,7 @@ type proxy struct {
 	Version   field.Int32
 	Mac       field.String
 	IP        field.Field
+	Host      field.String
 	Secret    field.String
 	Type      field.Int
 	Status    field.Int
@@ -148,6 +294,7 @@ func (p *proxy) updateTableName(table string) *proxy {
 	p.Version = field.NewInt32(table, "version")
 	p.Mac = field.NewString(table, "mac")
 	p.IP = field.NewField(table, "ip")
+	p.Host = field.NewString(table, "host")
 	p.Secret = field.NewString(table, "secret")
 	p.Type = field.NewInt(table, "type")
 	p.Status = field.NewInt(table, "status")
@@ -168,7 +315,7 @@ func (p *proxy) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
 }
 
 func (p *proxy) fillFieldMap() {
-	p.fieldMap = make(map[string]field.Expr, 12)
+	p.fieldMap = make(map[string]field.Expr, 13)
 	p.fieldMap["id"] = p.ID
 	p.fieldMap["created_at"] = p.CreatedAt
 	p.fieldMap["updated_at"] = p.UpdatedAt
@@ -176,6 +323,7 @@ func (p *proxy) fillFieldMap() {
 	p.fieldMap["version"] = p.Version
 	p.fieldMap["mac"] = p.Mac
 	p.fieldMap["ip"] = p.IP
+	p.fieldMap["host"] = p.Host
 	p.fieldMap["secret"] = p.Secret
 	p.fieldMap["type"] = p.Type
 	p.fieldMap["status"] = p.Status
@@ -205,6 +353,27 @@ type proxyHasManyChannels struct {
 		field.RelationField
 		Admin struct {
 			field.RelationField
+			Roles struct {
+				field.RelationField
+				Permissions struct {
+					field.RelationField
+					Parent struct {
+						field.RelationField
+					}
+					Children struct {
+						field.RelationField
+					}
+				}
+			}
+		}
+		Discount struct {
+			field.RelationField
+		}
+		Roles struct {
+			field.RelationField
+			Permissions struct {
+				field.RelationField
+			}
 		}
 	}
 	Resource struct {
@@ -214,9 +383,24 @@ type proxyHasManyChannels struct {
 		}
 		Short struct {
 			field.RelationField
+			Sku struct {
+				field.RelationField
+				Product struct {
+					field.RelationField
+				}
+				Discount struct {
+					field.RelationField
+				}
+			}
 		}
 		Long struct {
 			field.RelationField
+			Sku struct {
+				field.RelationField
+			}
+		}
+		Product struct {
+			field.RelationField
 		}
 	}
 	Proxy struct {