fix: fix http status code (close #193)

* Update time_test.sh to fix the params

修复测试脚本入参问题

* Update time_test.sh to fix the params

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,24 @@
+---
+name: 报告问题
+about: 使用简练详细的语言描述你遇到的问题
+title: ''
+labels: bug
+assignees: ''
+
+---
+
+**例行检查**
++ [ ] 我已确认目前没有类似 issue
++ [ ] 我已确认我已升级到最新版本
++ [ ] 我已完整查看过项目 README，尤其是常见问题部分
++ [ ] 我理解并愿意跟进此 issue，协助测试和提供反馈 
++ [ ] 我理解并认可上述内容，并理解项目维护者精力有限，不遵循规则的 issue 可能会被无视或直接关闭
+
+**问题描述**
+
+**复现步骤**
+
+**预期结果**
+
+**相关截图**
+如果没有的话，请删除此节。

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,11 @@
+blank_issues_enabled: false
+contact_links:
+  - name: 项目群聊
+    url: https://openai.justsong.cn/
+    about: QQ 群：828520184，自动审核，备注 One API
+  - name: 赞赏支持
+    url: https://iamazing.cn/page/reward
+    about: 请作者喝杯咖啡，以激励作者持续开发
+  - name: 付费部署或定制功能
+    url: https://openai.justsong.cn/
+    about: 加群后联系群主

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,18 @@
+---
+name: 功能请求
+about: 使用简练详细的语言描述希望加入的新功能
+title: ''
+labels: enhancement
+assignees: ''
+
+---
+
+**例行检查**
++ [ ] 我已确认目前没有类似 issue
++ [ ] 我已确认我已升级到最新版本
++ [ ] 我理解并愿意跟进此 issue，协助测试和提供反馈
++ [ ] 我理解并认可上述内容，并理解项目维护者精力有限，不遵循规则的 issue 可能会被无视或直接关闭
+
+**功能描述**
+
+**应用场景**

.github/workflows/docker-image-arm64.yml

@@ -4,6 +4,7 @@ on:
   push:
     tags:
       - '*'
+      - '!*-alpha*'
   workflow_dispatch:
     inputs:
       name:

.github/workflows/linux-release.yml

@@ -6,6 +6,7 @@ on:
   push:
     tags:
       - '*'
+      - '!*-alpha*'
 jobs:
   release:
     runs-on: ubuntu-latest

.github/workflows/macos-release.yml

@@ -6,6 +6,7 @@ on:
   push:
     tags:
       - '*'
+      - '!*-alpha*'
 jobs:
   release:
     runs-on: macos-latest

.github/workflows/windows-release.yml

@@ -6,6 +6,7 @@ on:
   push:
     tags:
       - '*'
+      - '!*-alpha*'
 jobs:
   release:
     runs-on: windows-latest

README.md

@@ -29,10 +29,10 @@ _✨ All in one 的 OpenAI 接口，整合各种 API 访问方式，开箱即用
 </p>
 
 <p align="center">
-  <a href="https://github.com/songquanpeng/one-api/releases">程序下载</a>
-  ·
   <a href="https://github.com/songquanpeng/one-api#部署">部署教程</a>
   ·
+  <a href="https://github.com/songquanpeng/one-api#使用方法">使用方法</a>
+  ·
   <a href="https://github.com/songquanpeng/one-api/issues">意见反馈</a>
   ·
   <a href="https://github.com/songquanpeng/one-api#截图展示">截图展示</a>
@@ -52,13 +52,14 @@ _✨ All in one 的 OpenAI 接口，整合各种 API 访问方式，开箱即用
 1. 支持多种 API 访问渠道，欢迎 PR 或提 issue 添加更多渠道：
    + [x] OpenAI 官方通道（支持配置代理）
    + [x] **Azure OpenAI API**
+   + [x] [OpenAI-SB](https://openai-sb.com)
    + [x] [API2D](https://api2d.com/r/197971)
    + [x] [OhMyGPT](https://aigptx.top?aff=uFpUl2Kf)
    + [x] [AI Proxy](https://aiproxy.io/?i=OneAPI) （邀请码：`OneAPI`）
+   + [x] [API2GPT](http://console.api2gpt.com/m/00002S)
+   + [x] [CloseAI](https://console.closeai-asia.com/r/2412)
    + [x] [AI.LS](https://ai.ls)
    + [x] [OpenAI Max](https://openaimax.com)
-   + [x] [OpenAI-SB](https://openai-sb.com)
-   + [x] [CloseAI](https://console.openai-asia.com/r/2412)
    + [x] 自定义渠道：例如各种未收录的第三方代理服务
 2. 支持通过**负载均衡**的方式访问多个渠道。
 3. 支持 **stream 模式**，可以通过流式传输实现打字机效果。
@@ -69,20 +70,25 @@ _✨ All in one 的 OpenAI 接口，整合各种 API 访问方式，开箱即用
 8. 支持**用户分组**以及**渠道分组**，支持为不同分组设置不同的倍率。
 9. 支持渠道**设置模型列表**。
 10. 支持**查看额度明细**。
-11. 支持发布公告，设置充值链接，设置新用户初始额度。
+11. 支持**用户邀请奖励**。
-12. 支持丰富的**自定义**设置，
+12. 支持以美元为单位显示额度。
+13. 支持发布公告，设置充值链接，设置新用户初始额度。
+14. 支持丰富的**自定义**设置，
     1. 支持自定义系统名称，logo 以及页脚。
     2. 支持自定义首页和关于页面，可以选择使用 HTML & Markdown 代码进行自定义，或者使用一个单独的网页通过 iframe 嵌入。
-13. 支持通过系统访问令牌访问管理 API。
+15. 支持通过系统访问令牌访问管理 API。
-14. 支持用户管理，支持**多种用户登录注册方式**：
+16. 支持 Cloudflare Turnstile 用户校验。
+17. 支持用户管理，支持**多种用户登录注册方式**：
     + 邮箱登录注册以及通过邮箱进行密码重置。
     + [GitHub 开放授权](https://github.com/settings/applications/new)。
     + 微信公众号授权（需要额外部署 [WeChat Server](https://github.com/songquanpeng/wechat-server)）。
-15. 未来其他大模型开放 API 后，将第一时间支持，并将其封装成同样的 API 访问方式。
+18. 未来其他大模型开放 API 后，将第一时间支持，并将其封装成同样的 API 访问方式。
 
 ## 部署
 ### 基于 Docker 进行部署
-执行：`docker run -d --restart always -p 3000:3000 -v /home/ubuntu/data/one-api:/data justsong/one-api`
+部署命令：`docker run --name one-api -d --restart always -p 3000:3000 -e TZ=Asia/Shanghai -v /home/ubuntu/data/one-api:/data justsong/one-api`
+
+更新命令：`docker run --rm -v /var/run/docker.sock:/var/run/docker.sock containrrr/watchtower -cR`
 
 `-p 3000:3000` 中的第一个 `3000` 是宿主机的端口，可以根据需要进行修改。
 
@@ -117,6 +123,8 @@ sudo certbot --nginx
 sudo service nginx restart
 ```
 
+初始账号用户名为 `root`，密码为 `123456`。
+
 ### 手动部署
 1. 从 [GitHub Releases](https://github.com/songquanpeng/one-api/releases/latest) 下载可执行文件或者从源码编译：
    ```shell
@@ -143,12 +151,62 @@ sudo service nginx restart
 
 ### 多机部署
 1. 所有服务器 `SESSION_SECRET` 设置一样的值。
-2. 必须设置 `SQL_DSN`，使用 MySQL 数据库而非 SQLite，请自行配置主备数据库同步。
+2. 必须设置 `SQL_DSN`，使用 MySQL 数据库而非 SQLite，所有服务器连接同一个数据库。
-3. 所有从服务器必须设置 `SYNC_FREQUENCY`，以定期从数据库同步配置。
+3. 所有从服务器必须设置 `NODE_TYPE` 为 `slave`。
-4. 从服务器可以选择设置 `FRONTEND_BASE_URL`，以重定向页面请求到主服务器。
+4. 设置 `SYNC_FREQUENCY` 后服务器将定期从数据库同步配置。
+5. 从服务器可以选择设置 `FRONTEND_BASE_URL`，以重定向页面请求到主服务器。
+6. 从服务器上**分别**装好 Redis，设置好 `REDIS_CONN_STRING`，这样可以做到在缓存未过期的情况下数据库零访问，可以减少延迟。
+7. 如果主服务器访问数据库延迟也比较高，则也需要启用 Redis，并设置 `SYNC_FREQUENCY`，以定期从数据库同步配置。
 
 环境变量的具体使用方法详见[此处](#环境变量)。
 
+### 宝塔部署教程
+
+详见 [#175](https://github.com/songquanpeng/one-api/issues/175)。
+
+如果部署后访问出现空白页面，详见 [#97](https://github.com/songquanpeng/one-api/issues/97)。
+
+### 部署第三方服务配合 One API 使用
+> 欢迎 PR 添加更多示例。
+
+#### ChatGPT Next Web
+项目主页：https://github.com/Yidadaa/ChatGPT-Next-Web
+
+```bash
+docker run --name chat-next-web -d -p 3001:3000 yidadaa/chatgpt-next-web
+```
+
+注意修改端口号和 `BASE_URL`。
+
+#### ChatGPT Web
+项目主页：https://github.com/Chanzhaoyu/chatgpt-web
+
+```bash
+docker run --name chatgpt-web -d -p 3002:3002 -e OPENAI_API_BASE_URL=https://openai.justsong.cn -e OPENAI_API_KEY=sk-xxx chenzhaoyu94/chatgpt-web
+```
+
+注意修改端口号、`OPENAI_API_BASE_URL` 和 `OPENAI_API_KEY`。
+
+### 部署到第三方平台
+<details>
+<summary><strong>部署到 Zeabur</strong></summary>
+<div>
+
+> Zeabur 的服务器在国外，自动解决了网络的问题，同时免费的额度也足够个人使用。
+
+1. 首先 fork 一份代码。
+2. 进入 [Zeabur](https://zeabur.com/)，登录，进入控制台。
+3. 新建一个 Project，在 Service -> Add Service 选择 Marketplace，选择 MySQL，并记下连接参数（用户名、密码、地址、端口）。
+4. 复制链接参数，运行 ```create database `one-api` ``` 创建数据库。
+5. 然后在 Service -> Add Service，选择 Git（第一次使用需要先授权），选择你 fork 的仓库。
+6. Deploy 会自动开始，先取消。进入下方 Variable，添加一个 `PORT`，值为 `3000`，再添加一个 `SQL_DSN`，值为 `<username>:<password>@tcp(<addr>:<port>)/one-api` ，然后保存。 注意如果不填写 `SQL_DSN`，数据将无法持久化，重新部署后数据会丢失。
+7. 选择 Redeploy。
+8. 进入下方 Domains，选择一个合适的域名前缀，如 "my-one-api"，最终域名为 "my-one-api.zeabur.app"，也可以 CNAME 自己的域名。
+9. 等待部署完成，点击生成的域名进入 One API。
+
+</div>
+</details>
+
 ## 配置
 系统本身开箱即用。
 
@@ -156,11 +214,24 @@ sudo service nginx restart
 
 等到系统启动后，使用 `root` 用户登录系统并做进一步的配置。
 
-## 使用方式
+## 使用方法
-在`渠道`页面中添加你的 API Key，之后在`令牌`页面中新增一个访问令牌。
+在`渠道`页面中添加你的 API Key，之后在`令牌`页面中新增访问令牌。
 
 之后就可以使用你的令牌访问 One API 了，使用方式与 [OpenAI API](https://platform.openai.com/docs/api-reference/introduction) 一致。
 
+你需要在各种用到 OpenAI API 的地方设置 API Base 为你的 One API 的部署地址，例如：`https://openai.justsong.cn`，API Key 则为你在 One API 中生成的令牌。
+
+注意，具体的 API Base 的格式取决于你所使用的客户端。
+
+```mermaid
+graph LR
+    A(用户)
+    A --->|请求| B(One API)
+    B -->|中继请求| C(OpenAI)
+    B -->|中继请求| D(Azure)
+    B -->|中继请求| E(其他下游渠道)
+```
+
 可以通过在令牌后面添加渠道 ID 的方式指定使用哪一个渠道处理本次请求，例如：`Authorization: Bearer ONE_API_KEY-CHANNEL_ID`。
 注意，需要是管理员用户创建的令牌才能指定渠道 ID。
 
@@ -171,12 +242,20 @@ sudo service nginx restart
    + 例子：`REDIS_CONN_STRING=redis://default:redispw@localhost:49153`
 2. `SESSION_SECRET`：设置之后将使用固定的会话密钥，这样系统重新启动后已登录用户的 cookie 将依旧有效。
    + 例子：`SESSION_SECRET=random_string`
-3. `SQL_DSN`：设置之后将使用指定数据库而非 SQLite。
+3. `SQL_DSN`：设置之后将使用指定数据库而非 SQLite，请使用 MySQL 8.0 版本。
-   + 例子：`SQL_DSN=root:123456@tcp(localhost:3306)/one-api`
+   + 例子：`SQL_DSN=root:123456@tcp(localhost:3306)/oneapi`
 4. `FRONTEND_BASE_URL`：设置之后将使用指定的前端地址，而非后端地址。
    + 例子：`FRONTEND_BASE_URL=https://openai.justsong.cn`
 5. `SYNC_FREQUENCY`：设置之后将定期与数据库同步配置，单位为秒，未设置则不进行同步。
    + 例子：`SYNC_FREQUENCY=60`
+6. `NODE_TYPE`：设置之后将指定节点类型，可选值为 `master` 和 `slave`，未设置则默认为 `master`。
+   + 例子：`NODE_TYPE=slave`
+7. `CHANNEL_UPDATE_FREQUENCY`：设置之后将定期更新渠道余额，单位为分钟，未设置则不进行更新。
+   + 例子：`CHANNEL_UPDATE_FREQUENCY=1440`
+8. `CHANNEL_TEST_FREQUENCY`：设置之后将定期检查渠道，单位为分钟，未设置则不进行检查。
+   + 例子：`CHANNEL_TEST_FREQUENCY=1440`
+9. `REQUEST_INTERVAL`：批量更新渠道余额以及测试可用性时的请求间隔，单位为秒，默认无间隔。
+   + 例子：`POLLING_INTERVAL=5`
 
 ### 命令行参数
 1. `--port <port_number>`: 指定服务器监听的端口号，默认为 `3000`。
@@ -196,16 +275,26 @@ https://openai.justsong.cn
 ![token](https://user-images.githubusercontent.com/39998050/233837971-dab488b7-6d96-43af-b640-a168e8d1c9bf.png)
 
 ## 常见问题
-1. 账户额度足够为什么提示额度不足？
+1. 额度是什么？怎么计算的？One API 的额度计算有问题？
+   + 额度 = 分组倍率 * 模型倍率 * （提示 token 数 + 补全 token 数 * 补全倍率）
+   + 其中补全倍率对于 GPT3.5 固定为 1.33，GPT4 为 2，与官方保持一致。
+   + 如果是非流模式，官方接口会返回消耗的总 token，但是你要注意提示和补全的消耗倍率不一样。
+2. 账户额度足够为什么提示额度不足？
    + 请检查你的令牌额度是否足够，这个和账户额度是分开的。
    + 令牌额度仅供用户设置最大使用量，用户可自由设置。
-2. 宝塔部署后访问出现空白页面？
-   + 自动配置的问题，详见[#97](https://github.com/songquanpeng/one-api/issues/97)。
 3. 提示无可用渠道？
    + 请检查的用户分组和渠道分组设置。
    + 以及渠道的模型设置。
+4. 渠道测试报错：`invalid character '<' looking for beginning of value`
+   + 这是因为返回值不是合法的 JSON，而是一个 HTML 页面。
+   + 大概率是你的部署站的 IP 或代理的节点被 CloudFlare 封禁了。
+5. ChatGPT Next Web 报错：`Failed to fetch`
+   + 部署的时候不要设置 `BASE_URL`。
+   + 检查你的接口地址和 API Key 有没有填对。
 
 ## 注意
-本项目为开源项目，请在遵循 OpenAI 的[使用条款](https://openai.com/policies/terms-of-use)以及法律法规的情况下使用，不得用于非法用途。
+本项目为开源项目，请在遵循 OpenAI 的[使用条款](https://openai.com/policies/terms-of-use)以及**法律法规**的情况下使用，不得用于非法用途。
 
-本项目依据 MIT 协议开源，请以某种方式保留 One API 的版权信息。
+本项目使用 MIT 协议进行开源，请以某种方式保留 One API 的版权信息。
+
+依据 MIT 协议，使用者需自行承担使用本项目的风险与责任，本开源项目开发者与此无关。

bin/time_test.sh

@@ -0,0 +1,36 @@
+#!/bin/bash
+
+if [ $# -ne 3 ]; then
+  echo "Usage: time_test.sh <domain> <key> <count>"
+  exit 1
+fi
+
+domain=$1
+key=$2
+count=$3
+total_time=0
+times=()
+
+for ((i=1; i<=count; i++)); do
+  result=$(curl -o /dev/null -s -w %{time_total}\\n \
+           https://"$domain"/v1/chat/completions \
+           -H "Content-Type: application/json" \
+           -H "Authorization: Bearer $key" \
+           -d '{"messages": [{"content": "echo hi", "role": "user"}], "model": "gpt-3.5-turbo", "stream": false, "max_tokens": 1}')
+  echo "$result"
+  total_time=$(bc <<< "$total_time + $result")
+  times+=("$result")
+done
+
+average_time=$(echo "scale=4; $total_time / $count" | bc)
+
+sum_of_squares=0
+for time in "${times[@]}"; do
+  difference=$(echo "scale=4; $time - $average_time" | bc)
+  square=$(echo "scale=4; $difference * $difference" | bc)
+  sum_of_squares=$(echo "scale=4; $sum_of_squares + $square" | bc)
+done
+
+standard_deviation=$(echo "scale=4; sqrt($sum_of_squares / $count)" | bc)
+
+echo "Average time: $average_time±$standard_deviation"

common/constants.go

@@ -1,9 +1,12 @@
 package common
 
 import (
-	"github.com/google/uuid"
+	"os"
+	"strconv"
 	"sync"
 	"time"
+
+	"github.com/google/uuid"
 )
 
 var StartTime = time.Now().Unix() // unit: second
@@ -13,6 +16,10 @@ var ServerAddress = "http://localhost:3000"
 var Footer = ""
 var Logo = ""
 var TopUpLink = ""
+var ChatLink = ""
+var QuotaPerUnit = 500 * 1000.0 // $0.002 / 1K tokens
+var DisplayInCurrencyEnabled = true
+var DisplayTokenStatEnabled = true
 
 var UsingSQLite = false
 
@@ -35,6 +42,8 @@ var WeChatAuthEnabled = false
 var TurnstileCheckEnabled = false
 var RegisterEnabled = true
 
+var LogConsumeEnabled = true
+
 var SMTPServer = ""
 var SMTPPort = 587
 var SMTPAccount = ""
@@ -52,6 +61,8 @@ var TurnstileSiteKey = ""
 var TurnstileSecretKey = ""
 
 var QuotaForNewUser = 0
+var QuotaForInviter = 0
+var QuotaForInvitee = 0
 var ChannelDisableThreshold = 5.0
 var AutomaticDisableChannelEnabled = false
 var QuotaRemindThreshold = 1000
@@ -59,6 +70,11 @@ var PreConsumedQuota = 500
 
 var RootUserEmail = ""
 
+var IsMasterNode = os.Getenv("NODE_TYPE") != "slave"
+
+var requestInterval, _ = strconv.Atoi(os.Getenv("REQUEST_INTERVAL"))
+var RequestInterval = time.Duration(requestInterval) * time.Second
+
 const (
 	RoleGuestUser  = 0
 	RoleCommonUser = 1
@@ -131,19 +147,21 @@ const (
 	ChannelTypeAILS      = 9
 	ChannelTypeAIProxy   = 10
 	ChannelTypePaLM      = 11
+	ChannelTypeAPI2GPT   = 12
 )
 
 var ChannelBaseURLs = []string{
-	"",                            // 0
+	"",                             // 0
-	"https://api.openai.com",      // 1
+	"https://api.openai.com",       // 1
-	"https://oa.api2d.net",        // 2
+	"https://oa.api2d.net",         // 2
-	"",                            // 3
+	"",                             // 3
-	"https://api.openai-asia.com", // 4
+	"https://api.openai-proxy.org", // 4
-	"https://api.openai-sb.com",   // 5
+	"https://api.openai-sb.com",    // 5
-	"https://api.openaimax.com",   // 6
+	"https://api.openaimax.com",    // 6
-	"https://api.ohmygpt.com",     // 7
+	"https://api.ohmygpt.com",      // 7
-	"",                            // 8
+	"",                             // 8
-	"https://api.caipacity.com",   // 9
+	"https://api.caipacity.com",    // 9
-	"https://api.aiproxy.io",      // 10
+	"https://api.aiproxy.io",       // 10
-	"",                            // 11
+	"",                             // 11
+	"https://api.api2gpt.com",      // 12
 }

common/group-ratio.go

@@ -11,19 +11,20 @@ var GroupRatio = map[string]float64{
 func GroupRatio2JSONString() string {
 	jsonBytes, err := json.Marshal(GroupRatio)
 	if err != nil {
-		SysError("Error marshalling model ratio: " + err.Error())
+		SysError("error marshalling model ratio: " + err.Error())
 	}
 	return string(jsonBytes)
 }
 
 func UpdateGroupRatioByJSONString(jsonStr string) error {
+	GroupRatio = make(map[string]float64)
 	return json.Unmarshal([]byte(jsonStr), &GroupRatio)
 }
 
 func GetGroupRatio(name string) float64 {
 	ratio, ok := GroupRatio[name]
 	if !ok {
-		SysError("Group ratio not found: " + name)
+		SysError("group ratio not found: " + name)
 		return 1
 	}
 	return ratio

common/logger.go

@@ -42,3 +42,11 @@ func FatalLog(v ...any) {
 	_, _ = fmt.Fprintf(gin.DefaultErrorWriter, "[FATAL] %v | %v \n", t.Format("2006/01/02 - 15:04:05"), v)
 	os.Exit(1)
 }
+
+func LogQuota(quota int) string {
+	if DisplayInCurrencyEnabled {
+		return fmt.Sprintf("＄%.6f 额度", float64(quota)/QuotaPerUnit)
+	} else {
+		return fmt.Sprintf("%d 点额度", quota)
+	}
+}

common/model-ratio.go

@@ -2,16 +2,23 @@ package common
 
 import "encoding/json"
 
+// ModelRatio
 // https://platform.openai.com/docs/models/model-endpoint-compatibility
 // https://openai.com/pricing
 // TODO: when a new api is enabled, check the pricing here
+// 1 === $0.002 / 1K tokens
 var ModelRatio = map[string]float64{
 	"gpt-4":                   15,
 	"gpt-4-0314":              15,
+	"gpt-4-0613":              15,
 	"gpt-4-32k":               30,
 	"gpt-4-32k-0314":          30,
-	"gpt-3.5-turbo":           1, // $0.002 / 1K tokens
+	"gpt-4-32k-0613":          30,
-	"gpt-3.5-turbo-0301":      1,
+	"gpt-3.5-turbo":           0.75, // $0.0015 / 1K tokens
+	"gpt-3.5-turbo-0301":      0.75,
+	"gpt-3.5-turbo-0613":      0.75,
+	"gpt-3.5-turbo-16k":       1.5, // $0.003 / 1K tokens
+	"gpt-3.5-turbo-16k-0613":  1.5,
 	"text-ada-001":            0.2,
 	"text-babbage-001":        0.25,
 	"text-curie-001":          1,
@@ -33,20 +40,21 @@ var ModelRatio = map[string]float64{
 func ModelRatio2JSONString() string {
 	jsonBytes, err := json.Marshal(ModelRatio)
 	if err != nil {
-		SysError("Error marshalling model ratio: " + err.Error())
+		SysError("error marshalling model ratio: " + err.Error())
 	}
 	return string(jsonBytes)
 }
 
 func UpdateModelRatioByJSONString(jsonStr string) error {
+	ModelRatio = make(map[string]float64)
 	return json.Unmarshal([]byte(jsonStr), &ModelRatio)
 }
 
 func GetModelRatio(name string) float64 {
 	ratio, ok := ModelRatio[name]
 	if !ok {
-		SysError("Model ratio not found: " + name)
+		SysError("model ratio not found: " + name)
-		return 1
+		return 30
 	}
 	return ratio
 }

common/redis.go

@@ -17,9 +17,15 @@ func InitRedisClient() (err error) {
 		SysLog("REDIS_CONN_STRING not set, Redis is not enabled")
 		return nil
 	}
+	if os.Getenv("SYNC_FREQUENCY") == "" {
+		RedisEnabled = false
+		SysLog("SYNC_FREQUENCY not set, Redis is disabled")
+		return nil
+	}
+	SysLog("Redis is enabled")
 	opt, err := redis.ParseURL(os.Getenv("REDIS_CONN_STRING"))
 	if err != nil {
-		panic(err)
+		FatalLog("failed to parse Redis connection string: " + err.Error())
 	}
 	RDB = redis.NewClient(opt)
 
@@ -27,13 +33,31 @@ func InitRedisClient() (err error) {
 	defer cancel()
 
 	_, err = RDB.Ping(ctx).Result()
+	if err != nil {
+		FatalLog("Redis ping test failed: " + err.Error())
+	}
 	return err
 }
 
 func ParseRedisOption() *redis.Options {
 	opt, err := redis.ParseURL(os.Getenv("REDIS_CONN_STRING"))
 	if err != nil {
-		panic(err)
+		FatalLog("failed to parse Redis connection string: " + err.Error())
 	}
 	return opt
 }
+
+func RedisSet(key string, value string, expiration time.Duration) error {
+	ctx := context.Background()
+	return RDB.Set(ctx, key, value, expiration).Err()
+}
+
+func RedisGet(key string) (string, error) {
+	ctx := context.Background()
+	return RDB.Get(ctx, key).Result()
+}
+
+func RedisDel(key string) error {
+	ctx := context.Background()
+	return RDB.Del(ctx, key).Err()
+}

common/utils.go

@@ -157,6 +157,15 @@ func GenerateKey() string {
 	return string(key)
 }
 
+func GetRandomString(length int) string {
+	rand.Seed(time.Now().UnixNano())
+	key := make([]byte, length)
+	for i := 0; i < length; i++ {
+		key[i] = keyChars[rand.Intn(len(keyChars))]
+	}
+	return string(key)
+}
+
 func GetTimestamp() int64 {
 	return time.Now().Unix()
 }

controller/billing.go

@@ -2,12 +2,22 @@ package controller
 
 import (
 	"github.com/gin-gonic/gin"
+	"one-api/common"
 	"one-api/model"
 )
 
 func GetSubscription(c *gin.Context) {
-	userId := c.GetInt("id")
+	var quota int
-	quota, err := model.GetUserQuota(userId)
+	var err error
+	var token *model.Token
+	if common.DisplayTokenStatEnabled {
+		tokenId := c.GetInt("token_id")
+		token, err = model.GetTokenById(tokenId)
+		quota = token.RemainQuota
+	} else {
+		userId := c.GetInt("id")
+		quota, err = model.GetUserQuota(userId)
+	}
 	if err != nil {
 		openAIError := OpenAIError{
 			Message: err.Error(),
@@ -18,23 +28,50 @@ func GetSubscription(c *gin.Context) {
 		})
 		return
 	}
+	amount := float64(quota)
+	if common.DisplayInCurrencyEnabled {
+		amount /= common.QuotaPerUnit
+	}
 	subscription := OpenAISubscriptionResponse{
 		Object:             "billing_subscription",
 		HasPaymentMethod:   true,
-		SoftLimitUSD:       float64(quota),
+		SoftLimitUSD:       amount,
-		HardLimitUSD:       float64(quota),
+		HardLimitUSD:       amount,
-		SystemHardLimitUSD: float64(quota),
+		SystemHardLimitUSD: amount,
 	}
 	c.JSON(200, subscription)
 	return
 }
 
 func GetUsage(c *gin.Context) {
-	//userId := c.GetInt("id")
+	var quota int
-	// TODO: get usage from database
+	var err error
+	var token *model.Token
+	if common.DisplayTokenStatEnabled {
+		tokenId := c.GetInt("token_id")
+		token, err = model.GetTokenById(tokenId)
+		quota = token.UsedQuota
+	} else {
+		userId := c.GetInt("id")
+		quota, err = model.GetUserUsedQuota(userId)
+	}
+	if err != nil {
+		openAIError := OpenAIError{
+			Message: err.Error(),
+			Type:    "one_api_error",
+		}
+		c.JSON(200, gin.H{
+			"error": openAIError,
+		})
+		return
+	}
+	amount := float64(quota)
+	if common.DisplayInCurrencyEnabled {
+		amount /= common.QuotaPerUnit
+	}
 	usage := OpenAIUsageResponse{
 		Object:     "list",
-		TotalUsage: 0,
+		TotalUsage: amount,
 	}
 	c.JSON(200, usage)
 	return

controller/channel-billing.go

@@ -4,13 +4,14 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"github.com/gin-gonic/gin"
 	"io"
 	"net/http"
 	"one-api/common"
 	"one-api/model"
 	"strconv"
 	"time"
+
+	"github.com/gin-gonic/gin"
 )
 
 // https://github.com/songquanpeng/one-api/issues/79
@@ -44,14 +45,38 @@ type OpenAISBUsageResponse struct {
 	} `json:"data"`
 }
 
-func GetResponseBody(method, url string, channel *model.Channel) ([]byte, error) {
+type AIProxyUserOverviewResponse struct {
+	Success   bool   `json:"success"`
+	Message   string `json:"message"`
+	ErrorCode int    `json:"error_code"`
+	Data      struct {
+		TotalPoints float64 `json:"totalPoints"`
+	} `json:"data"`
+}
+
+type API2GPTUsageResponse struct {
+	Object         string  `json:"object"`
+	TotalGranted   float64 `json:"total_granted"`
+	TotalUsed      float64 `json:"total_used"`
+	TotalRemaining float64 `json:"total_remaining"`
+}
+
+// GetAuthHeader get auth header
+func GetAuthHeader(token string) http.Header {
+	h := http.Header{}
+	h.Add("Authorization", fmt.Sprintf("Bearer %s", token))
+	return h
+}
+
+func GetResponseBody(method, url string, channel *model.Channel, headers http.Header) ([]byte, error) {
 	client := &http.Client{}
 	req, err := http.NewRequest(method, url, nil)
 	if err != nil {
 		return nil, err
 	}
-	auth := fmt.Sprintf("Bearer %s", channel.Key)
+	for k := range headers {
-	req.Header.Add("Authorization", auth)
+		req.Header.Add(k, headers.Get(k))
+	}
 	res, err := client.Do(req)
 	if err != nil {
 		return nil, err
@@ -69,7 +94,7 @@ func GetResponseBody(method, url string, channel *model.Channel) ([]byte, error)
 
 func updateChannelOpenAISBBalance(channel *model.Channel) (float64, error) {
 	url := fmt.Sprintf("https://api.openai-sb.com/sb-api/user/status?api_key=%s", channel.Key)
-	body, err := GetResponseBody("GET", url, channel)
+	body, err := GetResponseBody("GET", url, channel, GetAuthHeader(channel.Key))
 	if err != nil {
 		return 0, err
 	}
@@ -89,6 +114,42 @@ func updateChannelOpenAISBBalance(channel *model.Channel) (float64, error) {
 	return balance, nil
 }
 
+func updateChannelAIProxyBalance(channel *model.Channel) (float64, error) {
+	url := "https://aiproxy.io/api/report/getUserOverview"
+	headers := http.Header{}
+	headers.Add("Api-Key", channel.Key)
+	body, err := GetResponseBody("GET", url, channel, headers)
+	if err != nil {
+		return 0, err
+	}
+	response := AIProxyUserOverviewResponse{}
+	err = json.Unmarshal(body, &response)
+	if err != nil {
+		return 0, err
+	}
+	if !response.Success {
+		return 0, fmt.Errorf("code: %d, message: %s", response.ErrorCode, response.Message)
+	}
+	channel.UpdateBalance(response.Data.TotalPoints)
+	return response.Data.TotalPoints, nil
+}
+
+func updateChannelAPI2GPTBalance(channel *model.Channel) (float64, error) {
+	url := "https://api.api2gpt.com/dashboard/billing/credit_grants"
+	body, err := GetResponseBody("GET", url, channel, GetAuthHeader(channel.Key))
+
+	if err != nil {
+		return 0, err
+	}
+	response := API2GPTUsageResponse{}
+	err = json.Unmarshal(body, &response)
+	if err != nil {
+		return 0, err
+	}
+	channel.UpdateBalance(response.TotalRemaining)
+	return response.TotalRemaining, nil
+}
+
 func updateChannelBalance(channel *model.Channel) (float64, error) {
 	baseURL := common.ChannelBaseURLs[channel.Type]
 	switch channel.Type {
@@ -102,12 +163,16 @@ func updateChannelBalance(channel *model.Channel) (float64, error) {
 		baseURL = channel.BaseURL
 	case common.ChannelTypeOpenAISB:
 		return updateChannelOpenAISBBalance(channel)
+	case common.ChannelTypeAIProxy:
+		return updateChannelAIProxyBalance(channel)
+	case common.ChannelTypeAPI2GPT:
+		return updateChannelAPI2GPTBalance(channel)
 	default:
 		return 0, errors.New("尚未实现")
 	}
 	url := fmt.Sprintf("%s/v1/dashboard/billing/subscription", baseURL)
 
-	body, err := GetResponseBody("GET", url, channel)
+	body, err := GetResponseBody("GET", url, channel, GetAuthHeader(channel.Key))
 	if err != nil {
 		return 0, err
 	}
@@ -123,7 +188,7 @@ func updateChannelBalance(channel *model.Channel) (float64, error) {
 		startDate = now.AddDate(0, 0, -100).Format("2006-01-02")
 	}
 	url = fmt.Sprintf("%s/v1/dashboard/billing/usage?start_date=%s&end_date=%s", baseURL, startDate, endDate)
-	body, err = GetResponseBody("GET", url, channel)
+	body, err = GetResponseBody("GET", url, channel, GetAuthHeader(channel.Key))
 	if err != nil {
 		return 0, err
 	}
@@ -192,6 +257,7 @@ func updateAllChannelsBalance() error {
 				disableChannel(channel.Id, channel.Name, "余额不足")
 			}
 		}
+		time.Sleep(common.RequestInterval)
 	}
 	return nil
 }
@@ -212,3 +278,12 @@ func UpdateAllChannelsBalance(c *gin.Context) {
 	})
 	return
 }
+
+func AutomaticallyUpdateChannels(frequency int) {
+	for {
+		time.Sleep(time.Duration(frequency) * time.Minute)
+		common.SysLog("updating all channels")
+		_ = updateAllChannelsBalance()
+		common.SysLog("channels update done")
+	}
+}

controller/channel-test.go

@@ -14,20 +14,18 @@ import (
 	"time"
 )
 
-func testChannel(channel *model.Channel, request *ChatRequest) error {
+func testChannel(channel *model.Channel, request ChatRequest) error {
-	if request.Model == "" {
+	switch channel.Type {
+	case common.ChannelTypeAzure:
+		request.Model = "gpt-35-turbo"
+	default:
 		request.Model = "gpt-3.5-turbo"
-		if channel.Type == common.ChannelTypeAzure {
-			request.Model = "gpt-35-turbo"
-		}
 	}
 	requestURL := common.ChannelBaseURLs[channel.Type]
 	if channel.Type == common.ChannelTypeAzure {
 		requestURL = fmt.Sprintf("%s/openai/deployments/%s/chat/completions?api-version=2023-03-15-preview", channel.BaseURL, request.Model)
 	} else {
-		if channel.Type == common.ChannelTypeCustom {
+		if channel.BaseURL != "" {
-			requestURL = channel.BaseURL
-		} else if channel.Type == common.ChannelTypeOpenAI && channel.BaseURL != "" {
 			requestURL = channel.BaseURL
 		}
 		requestURL += "/v1/chat/completions"
@@ -64,10 +62,9 @@ func testChannel(channel *model.Channel, request *ChatRequest) error {
 	return nil
 }
 
-func buildTestRequest(c *gin.Context) *ChatRequest {
+func buildTestRequest() *ChatRequest {
-	model_ := c.Query("model")
 	testRequest := &ChatRequest{
-		Model:     model_,
+		Model:     "", // this will be set later
 		MaxTokens: 1,
 	}
 	testMessage := Message{
@@ -95,9 +92,9 @@ func TestChannel(c *gin.Context) {
 		})
 		return
 	}
-	testRequest := buildTestRequest(c)
+	testRequest := buildTestRequest()
 	tik := time.Now()
-	err = testChannel(channel, testRequest)
+	err = testChannel(channel, *testRequest)
 	tok := time.Now()
 	milliseconds := tok.Sub(tik).Milliseconds()
 	go channel.UpdateResponseTime(milliseconds)
@@ -131,11 +128,11 @@ func disableChannel(channelId int, channelName string, reason string) {
 	content := fmt.Sprintf("通道「%s」（#%d）已被禁用，原因：%s", channelName, channelId, reason)
 	err := common.SendEmail(subject, common.RootUserEmail, content)
 	if err != nil {
-		common.SysError(fmt.Sprintf("发送邮件失败：%s", err.Error()))
+		common.SysError(fmt.Sprintf("failed to send email: %s", err.Error()))
 	}
 }
 
-func testAllChannels(c *gin.Context) error {
+func testAllChannels(notify bool) error {
 	if common.RootUserEmail == "" {
 		common.RootUserEmail = model.GetRootUserEmail()
 	}
@@ -148,13 +145,9 @@ func testAllChannels(c *gin.Context) error {
 	testAllChannelsLock.Unlock()
 	channels, err := model.GetAllChannels(0, 0, true)
 	if err != nil {
-		c.JSON(http.StatusOK, gin.H{
-			"success": false,
-			"message": err.Error(),
-		})
 		return err
 	}
-	testRequest := buildTestRequest(c)
+	testRequest := buildTestRequest()
 	var disableThreshold = int64(common.ChannelDisableThreshold * 1000)
 	if disableThreshold == 0 {
 		disableThreshold = 10000000 // a impossible value
@@ -165,7 +158,7 @@ func testAllChannels(c *gin.Context) error {
 				continue
 			}
 			tik := time.Now()
-			err := testChannel(channel, testRequest)
+			err := testChannel(channel, *testRequest)
 			tok := time.Now()
 			milliseconds := tok.Sub(tik).Milliseconds()
 			if err != nil || milliseconds > disableThreshold {
@@ -175,20 +168,23 @@ func testAllChannels(c *gin.Context) error {
 				disableChannel(channel.Id, channel.Name, err.Error())
 			}
 			channel.UpdateResponseTime(milliseconds)
-		}
+			time.Sleep(common.RequestInterval)
-		err := common.SendEmail("通道测试完成", common.RootUserEmail, "通道测试完成，如果没有收到禁用通知，说明所有通道都正常")
-		if err != nil {
-			common.SysError(fmt.Sprintf("发送邮件失败：%s", err.Error()))
 		}
 		testAllChannelsLock.Lock()
 		testAllChannelsRunning = false
 		testAllChannelsLock.Unlock()
+		if notify {
+			err := common.SendEmail("通道测试完成", common.RootUserEmail, "通道测试完成，如果没有收到禁用通知，说明所有通道都正常")
+			if err != nil {
+				common.SysError(fmt.Sprintf("failed to send email: %s", err.Error()))
+			}
+		}
 	}()
 	return nil
 }
 
 func TestAllChannels(c *gin.Context) {
-	err := testAllChannels(c)
+	err := testAllChannels(true)
 	if err != nil {
 		c.JSON(http.StatusOK, gin.H{
 			"success": false,
@@ -202,3 +198,12 @@ func TestAllChannels(c *gin.Context) {
 	})
 	return
 }
+
+func AutomaticallyTestChannels(frequency int) {
+	for {
+		time.Sleep(time.Duration(frequency) * time.Minute)
+		common.SysLog("testing all channels")
+		_ = testAllChannels(false)
+		common.SysLog("channel test finished")
+	}
+}

controller/github.go

@@ -125,7 +125,7 @@ func GitHubOAuth(c *gin.Context) {
 			user.Role = common.RoleCommonUser
 			user.Status = common.UserStatusEnabled
 
-			if err := user.Insert(); err != nil {
+			if err := user.Insert(0); err != nil {
 				c.JSON(http.StatusOK, gin.H{
 					"success": false,
 					"message": err.Error(),

controller/misc.go

@@ -14,20 +14,23 @@ func GetStatus(c *gin.Context) {
 		"success": true,
 		"message": "",
 		"data": gin.H{
-			"version":            common.Version,
+			"version":             common.Version,
-			"start_time":         common.StartTime,
+			"start_time":          common.StartTime,
-			"email_verification": common.EmailVerificationEnabled,
+			"email_verification":  common.EmailVerificationEnabled,
-			"github_oauth":       common.GitHubOAuthEnabled,
+			"github_oauth":        common.GitHubOAuthEnabled,
-			"github_client_id":   common.GitHubClientId,
+			"github_client_id":    common.GitHubClientId,
-			"system_name":        common.SystemName,
+			"system_name":         common.SystemName,
-			"logo":               common.Logo,
+			"logo":                common.Logo,
-			"footer_html":        common.Footer,
+			"footer_html":         common.Footer,
-			"wechat_qrcode":      common.WeChatAccountQRCodeImageURL,
+			"wechat_qrcode":       common.WeChatAccountQRCodeImageURL,
-			"wechat_login":       common.WeChatAuthEnabled,
+			"wechat_login":        common.WeChatAuthEnabled,
-			"server_address":     common.ServerAddress,
+			"server_address":      common.ServerAddress,
-			"turnstile_check":    common.TurnstileCheckEnabled,
+			"turnstile_check":     common.TurnstileCheckEnabled,
-			"turnstile_site_key": common.TurnstileSiteKey,
+			"turnstile_site_key":  common.TurnstileSiteKey,
-			"top_up_link":        common.TopUpLink,
+			"top_up_link":         common.TopUpLink,
+			"chat_link":           common.ChatLink,
+			"quota_per_unit":      common.QuotaPerUnit,
+			"display_in_currency": common.DisplayInCurrencyEnabled,
 		},
 	})
 	return

controller/model.go

@@ -71,6 +71,33 @@ func init() {
 			Root:       "gpt-3.5-turbo-0301",
 			Parent:     nil,
 		},
+		{
+			Id:         "gpt-3.5-turbo-0613",
+			Object:     "model",
+			Created:    1677649963,
+			OwnedBy:    "openai",
+			Permission: permission,
+			Root:       "gpt-3.5-turbo-0613",
+			Parent:     nil,
+		},
+		{
+			Id:         "gpt-3.5-turbo-16k",
+			Object:     "model",
+			Created:    1677649963,
+			OwnedBy:    "openai",
+			Permission: permission,
+			Root:       "gpt-3.5-turbo-16k",
+			Parent:     nil,
+		},
+		{
+			Id:         "gpt-3.5-turbo-16k-0613",
+			Object:     "model",
+			Created:    1677649963,
+			OwnedBy:    "openai",
+			Permission: permission,
+			Root:       "gpt-3.5-turbo-16k-0613",
+			Parent:     nil,
+		},
 		{
 			Id:         "gpt-4",
 			Object:     "model",
@@ -89,6 +116,15 @@ func init() {
 			Root:       "gpt-4-0314",
 			Parent:     nil,
 		},
+		{
+			Id:         "gpt-4-0613",
+			Object:     "model",
+			Created:    1677649963,
+			OwnedBy:    "openai",
+			Permission: permission,
+			Root:       "gpt-4-0613",
+			Parent:     nil,
+		},
 		{
 			Id:         "gpt-4-32k",
 			Object:     "model",
@@ -107,6 +143,15 @@ func init() {
 			Root:       "gpt-4-32k-0314",
 			Parent:     nil,
 		},
+		{
+			Id:         "gpt-4-32k-0613",
+			Object:     "model",
+			Created:    1677649963,
+			OwnedBy:    "openai",
+			Permission: permission,
+			Root:       "gpt-4-32k-0613",
+			Parent:     nil,
+		},
 		{
 			Id:         "text-embedding-ada-002",
 			Object:     "model",

controller/option.go

@@ -13,7 +13,7 @@ func GetOptions(c *gin.Context) {
 	var options []*model.Option
 	common.OptionMapRWMutex.Lock()
 	for k, v := range common.OptionMap {
-		if strings.Contains(k, "Token") || strings.Contains(k, "Secret") {
+		if strings.HasSuffix(k, "Token") || strings.HasSuffix(k, "Secret") {
 			continue
 		}
 		options = append(options, &model.Option{

controller/relay-image.go

@@ -0,0 +1,34 @@
+package controller
+
+import (
+	"github.com/gin-gonic/gin"
+	"io"
+	"net/http"
+)
+
+func relayImageHelper(c *gin.Context, relayMode int) *OpenAIErrorWithStatusCode {
+	// TODO: this part is not finished
+	req, err := http.NewRequest(c.Request.Method, c.Request.RequestURI, c.Request.Body)
+	client := &http.Client{}
+	resp, err := client.Do(req)
+	if err != nil {
+		return errorWrapper(err, "do_request_failed", http.StatusOK)
+	}
+	err = req.Body.Close()
+	if err != nil {
+		return errorWrapper(err, "close_request_body_failed", http.StatusOK)
+	}
+	for k, v := range resp.Header {
+		c.Writer.Header().Set(k, v[0])
+	}
+	c.Writer.WriteHeader(resp.StatusCode)
+	_, err = io.Copy(c.Writer, resp.Body)
+	if err != nil {
+		return errorWrapper(err, "copy_response_body_failed", http.StatusOK)
+	}
+	err = resp.Body.Close()
+	if err != nil {
+		return errorWrapper(err, "close_response_body_failed", http.StatusOK)
+	}
+	return nil
+}

controller/relay-text.go

@@ -0,0 +1,271 @@
+package controller
+
+import (
+	"bufio"
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"github.com/gin-gonic/gin"
+	"io"
+	"net/http"
+	"one-api/common"
+	"one-api/model"
+	"strings"
+)
+
+func relayTextHelper(c *gin.Context, relayMode int) *OpenAIErrorWithStatusCode {
+	channelType := c.GetInt("channel")
+	tokenId := c.GetInt("token_id")
+	userId := c.GetInt("id")
+	consumeQuota := c.GetBool("consume_quota")
+	group := c.GetString("group")
+	var textRequest GeneralOpenAIRequest
+	if consumeQuota || channelType == common.ChannelTypeAzure || channelType == common.ChannelTypePaLM {
+		err := common.UnmarshalBodyReusable(c, &textRequest)
+		if err != nil {
+			return errorWrapper(err, "bind_request_body_failed", http.StatusBadRequest)
+		}
+	}
+	if relayMode == RelayModeModeration && textRequest.Model == "" {
+		textRequest.Model = "text-moderation-latest"
+	}
+	baseURL := common.ChannelBaseURLs[channelType]
+	requestURL := c.Request.URL.String()
+	if c.GetString("base_url") != "" {
+		baseURL = c.GetString("base_url")
+	}
+	fullRequestURL := fmt.Sprintf("%s%s", baseURL, requestURL)
+	if channelType == common.ChannelTypeAzure {
+		// https://learn.microsoft.com/en-us/azure/cognitive-services/openai/chatgpt-quickstart?pivots=rest-api&tabs=command-line#rest-api
+		query := c.Request.URL.Query()
+		apiVersion := query.Get("api-version")
+		if apiVersion == "" {
+			apiVersion = c.GetString("api_version")
+		}
+		requestURL := strings.Split(requestURL, "?")[0]
+		requestURL = fmt.Sprintf("%s?api-version=%s", requestURL, apiVersion)
+		baseURL = c.GetString("base_url")
+		task := strings.TrimPrefix(requestURL, "/v1/")
+		model_ := textRequest.Model
+		model_ = strings.Replace(model_, ".", "", -1)
+		// https://github.com/songquanpeng/one-api/issues/67
+		model_ = strings.TrimSuffix(model_, "-0301")
+		model_ = strings.TrimSuffix(model_, "-0314")
+		model_ = strings.TrimSuffix(model_, "-0613")
+		fullRequestURL = fmt.Sprintf("%s/openai/deployments/%s/%s", baseURL, model_, task)
+	} else if channelType == common.ChannelTypePaLM {
+		err := relayPaLM(textRequest, c)
+		return err
+	}
+	var promptTokens int
+	switch relayMode {
+	case RelayModeChatCompletions:
+		promptTokens = countTokenMessages(textRequest.Messages, textRequest.Model)
+	case RelayModeCompletions:
+		promptTokens = countTokenInput(textRequest.Prompt, textRequest.Model)
+	case RelayModeModeration:
+		promptTokens = countTokenInput(textRequest.Input, textRequest.Model)
+	}
+	preConsumedTokens := common.PreConsumedQuota
+	if textRequest.MaxTokens != 0 {
+		preConsumedTokens = promptTokens + textRequest.MaxTokens
+	}
+	modelRatio := common.GetModelRatio(textRequest.Model)
+	groupRatio := common.GetGroupRatio(group)
+	ratio := modelRatio * groupRatio
+	preConsumedQuota := int(float64(preConsumedTokens) * ratio)
+	userQuota, err := model.CacheGetUserQuota(userId)
+	if err != nil {
+		return errorWrapper(err, "get_user_quota_failed", http.StatusInternalServerError)
+	}
+	if userQuota > 10*preConsumedQuota {
+		// in this case, we do not pre-consume quota
+		// because the user has enough quota
+		preConsumedQuota = 0
+	}
+	if consumeQuota && preConsumedQuota > 0 {
+		err := model.PreConsumeTokenQuota(tokenId, preConsumedQuota)
+		if err != nil {
+			return errorWrapper(err, "pre_consume_token_quota_failed", http.StatusForbidden)
+		}
+	}
+	req, err := http.NewRequest(c.Request.Method, fullRequestURL, c.Request.Body)
+	if err != nil {
+		return errorWrapper(err, "new_request_failed", http.StatusInternalServerError)
+	}
+	if channelType == common.ChannelTypeAzure {
+		key := c.Request.Header.Get("Authorization")
+		key = strings.TrimPrefix(key, "Bearer ")
+		req.Header.Set("api-key", key)
+	} else {
+		req.Header.Set("Authorization", c.Request.Header.Get("Authorization"))
+	}
+	req.Header.Set("Content-Type", c.Request.Header.Get("Content-Type"))
+	req.Header.Set("Accept", c.Request.Header.Get("Accept"))
+	req.Header.Set("Connection", c.Request.Header.Get("Connection"))
+	client := &http.Client{}
+	resp, err := client.Do(req)
+	if err != nil {
+		return errorWrapper(err, "do_request_failed", http.StatusInternalServerError)
+	}
+	err = req.Body.Close()
+	if err != nil {
+		return errorWrapper(err, "close_request_body_failed", http.StatusInternalServerError)
+	}
+	err = c.Request.Body.Close()
+	if err != nil {
+		return errorWrapper(err, "close_request_body_failed", http.StatusInternalServerError)
+	}
+	var textResponse TextResponse
+	isStream := strings.HasPrefix(resp.Header.Get("Content-Type"), "text/event-stream")
+	var streamResponseText string
+
+	defer func() {
+		if consumeQuota {
+			quota := 0
+			completionRatio := 1.34 // default for gpt-3
+			if strings.HasPrefix(textRequest.Model, "gpt-4") {
+				completionRatio = 2
+			}
+			if isStream {
+				responseTokens := countTokenText(streamResponseText, textRequest.Model)
+				quota = promptTokens + int(float64(responseTokens)*completionRatio)
+			} else {
+				quota = textResponse.Usage.PromptTokens + int(float64(textResponse.Usage.CompletionTokens)*completionRatio)
+			}
+			quota = int(float64(quota) * ratio)
+			if ratio != 0 && quota <= 0 {
+				quota = 1
+			}
+			quotaDelta := quota - preConsumedQuota
+			err := model.PostConsumeTokenQuota(tokenId, quotaDelta)
+			if err != nil {
+				common.SysError("error consuming token remain quota: " + err.Error())
+			}
+			tokenName := c.GetString("token_name")
+			model.RecordLog(userId, model.LogTypeConsume, fmt.Sprintf("通过令牌「%s」使用模型 %s 消耗 %s（模型倍率 %.2f，分组倍率 %.2f）", tokenName, textRequest.Model, common.LogQuota(quota), modelRatio, groupRatio))
+			model.UpdateUserUsedQuotaAndRequestCount(userId, quota)
+			channelId := c.GetInt("channel_id")
+			model.UpdateChannelUsedQuota(channelId, quota)
+		}
+	}()
+
+	if isStream {
+		scanner := bufio.NewScanner(resp.Body)
+		scanner.Split(func(data []byte, atEOF bool) (advance int, token []byte, err error) {
+			if atEOF && len(data) == 0 {
+				return 0, nil, nil
+			}
+
+			if i := strings.Index(string(data), "\n\n"); i >= 0 {
+				return i + 2, data[0:i], nil
+			}
+
+			if atEOF {
+				return len(data), data, nil
+			}
+
+			return 0, nil, nil
+		})
+		dataChan := make(chan string)
+		stopChan := make(chan bool)
+		go func() {
+			for scanner.Scan() {
+				data := scanner.Text()
+				if len(data) < 6 { // must be something wrong!
+					common.SysError("invalid stream response: " + data)
+					continue
+				}
+				dataChan <- data
+				data = data[6:]
+				if !strings.HasPrefix(data, "[DONE]") {
+					switch relayMode {
+					case RelayModeChatCompletions:
+						var streamResponse ChatCompletionsStreamResponse
+						err = json.Unmarshal([]byte(data), &streamResponse)
+						if err != nil {
+							common.SysError("error unmarshalling stream response: " + err.Error())
+							return
+						}
+						for _, choice := range streamResponse.Choices {
+							streamResponseText += choice.Delta.Content
+						}
+					case RelayModeCompletions:
+						var streamResponse CompletionsStreamResponse
+						err = json.Unmarshal([]byte(data), &streamResponse)
+						if err != nil {
+							common.SysError("error unmarshalling stream response: " + err.Error())
+							return
+						}
+						for _, choice := range streamResponse.Choices {
+							streamResponseText += choice.Text
+						}
+					}
+				}
+			}
+			stopChan <- true
+		}()
+		c.Writer.Header().Set("Content-Type", "text/event-stream")
+		c.Writer.Header().Set("Cache-Control", "no-cache")
+		c.Writer.Header().Set("Connection", "keep-alive")
+		c.Writer.Header().Set("Transfer-Encoding", "chunked")
+		c.Writer.Header().Set("X-Accel-Buffering", "no")
+		c.Stream(func(w io.Writer) bool {
+			select {
+			case data := <-dataChan:
+				if strings.HasPrefix(data, "data: [DONE]") {
+					data = data[:12]
+				}
+				c.Render(-1, common.CustomEvent{Data: data})
+				return true
+			case <-stopChan:
+				return false
+			}
+		})
+		err = resp.Body.Close()
+		if err != nil {
+			return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError)
+		}
+		return nil
+	} else {
+		if consumeQuota {
+			responseBody, err := io.ReadAll(resp.Body)
+			if err != nil {
+				return errorWrapper(err, "read_response_body_failed", http.StatusInternalServerError)
+			}
+			err = resp.Body.Close()
+			if err != nil {
+				return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError)
+			}
+			err = json.Unmarshal(responseBody, &textResponse)
+			if err != nil {
+				return errorWrapper(err, "unmarshal_response_body_failed", http.StatusInternalServerError)
+			}
+			if textResponse.Error.Type != "" {
+				return &OpenAIErrorWithStatusCode{
+					OpenAIError: textResponse.Error,
+					StatusCode:  resp.StatusCode,
+				}
+			}
+			// Reset response body
+			resp.Body = io.NopCloser(bytes.NewBuffer(responseBody))
+		}
+		// We shouldn't set the header before we parse the response body, because the parse part may fail.
+		// And then we will have to send an error response, but in this case, the header has already been set.
+		// So the client will be confused by the response.
+		// For example, Postman will report error, and we cannot check the response at all.
+		for k, v := range resp.Header {
+			c.Writer.Header().Set(k, v[0])
+		}
+		c.Writer.WriteHeader(resp.StatusCode)
+		_, err = io.Copy(c.Writer, resp.Body)
+		if err != nil {
+			return errorWrapper(err, "copy_response_body_failed", http.StatusInternalServerError)
+		}
+		err = resp.Body.Close()
+		if err != nil {
+			return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError)
+		}
+		return nil
+	}
+}

controller/relay-utils.go

@@ -58,8 +58,34 @@ func countTokenMessages(messages []Message, model string) int {
 	return tokenNum
 }
 
+func countTokenInput(input any, model string) int {
+	switch input.(type) {
+	case string:
+		return countTokenText(input.(string), model)
+	case []string:
+		text := ""
+		for _, s := range input.([]string) {
+			text += s
+		}
+		return countTokenText(text, model)
+	}
+	return 0
+}
+
 func countTokenText(text string, model string) int {
 	tokenEncoder := getTokenEncoder(model)
 	token := tokenEncoder.Encode(text, nil, nil)
 	return len(token)
 }
+
+func errorWrapper(err error, code string, statusCode int) *OpenAIErrorWithStatusCode {
+	openAIError := OpenAIError{
+		Message: err.Error(),
+		Type:    "one_api_error",
+		Code:    code,
+	}
+	return &OpenAIErrorWithStatusCode{
+		OpenAIError: openAIError,
+		StatusCode:  statusCode,
+	}
+}

controller/relay.go

@@ -1,15 +1,10 @@
 package controller
 
 import (
-	"bufio"
-	"bytes"
-	"encoding/json"
 	"fmt"
 	"github.com/gin-gonic/gin"
-	"io"
 	"net/http"
 	"one-api/common"
-	"one-api/model"
 	"strings"
 )
 
@@ -25,6 +20,7 @@ const (
 	RelayModeCompletions
 	RelayModeEmbeddings
 	RelayModeModeration
+	RelayModeImagesGenerations
 )
 
 // https://platform.openai.com/docs/api-reference/chat
@@ -32,13 +28,13 @@ const (
 type GeneralOpenAIRequest struct {
 	Model       string    `json:"model"`
 	Messages    []Message `json:"messages"`
-	Prompt      string    `json:"prompt"`
+	Prompt      any       `json:"prompt"`
 	Stream      bool      `json:"stream"`
 	MaxTokens   int       `json:"max_tokens"`
 	Temperature float64   `json:"temperature"`
 	TopP        float64   `json:"top_p"`
 	N           int       `json:"n"`
-	Input       string    `json:"input"`
+	Input       any       `json:"input"`
 }
 
 type ChatRequest struct {
@@ -104,8 +100,16 @@ func Relay(c *gin.Context) {
 		relayMode = RelayModeEmbeddings
 	} else if strings.HasPrefix(c.Request.URL.Path, "/v1/moderations") {
 		relayMode = RelayModeModeration
+	} else if strings.HasPrefix(c.Request.URL.Path, "/v1/images/generations") {
+		relayMode = RelayModeImagesGenerations
+	}
+	var err *OpenAIErrorWithStatusCode
+	switch relayMode {
+	case RelayModeImagesGenerations:
+		err = relayImageHelper(c, relayMode)
+	default:
+		err = relayTextHelper(c, relayMode)
 	}
-	err := relayHelper(c, relayMode)
 	if err != nil {
 		if err.StatusCode == http.StatusTooManyRequests {
 			err.OpenAIError.Message = "当前分组负载已饱和，请稍后再试，或升级账户以提升服务质量。"
@@ -114,7 +118,7 @@ func Relay(c *gin.Context) {
 			"error": err.OpenAIError,
 		})
 		channelId := c.GetInt("channel_id")
-		common.SysError(fmt.Sprintf("Relay error (channel #%d): %s", channelId, err.Message))
+		common.SysError(fmt.Sprintf("relay error (channel #%d): %s", channelId, err.Message))
 		// https://platform.openai.com/docs/guides/error-codes/api-errors
 		if common.AutomaticDisableChannelEnabled && (err.Type == "insufficient_quota" || err.Code == "invalid_api_key") {
 			channelId := c.GetInt("channel_id")
@@ -124,266 +128,6 @@ func Relay(c *gin.Context) {
 	}
 }
 
-func errorWrapper(err error, code string, statusCode int) *OpenAIErrorWithStatusCode {
-	openAIError := OpenAIError{
-		Message: err.Error(),
-		Type:    "one_api_error",
-		Code:    code,
-	}
-	return &OpenAIErrorWithStatusCode{
-		OpenAIError: openAIError,
-		StatusCode:  statusCode,
-	}
-}
-
-func relayHelper(c *gin.Context, relayMode int) *OpenAIErrorWithStatusCode {
-	channelType := c.GetInt("channel")
-	tokenId := c.GetInt("token_id")
-	consumeQuota := c.GetBool("consume_quota")
-	group := c.GetString("group")
-	var textRequest GeneralOpenAIRequest
-	if consumeQuota || channelType == common.ChannelTypeAzure || channelType == common.ChannelTypePaLM {
-		err := common.UnmarshalBodyReusable(c, &textRequest)
-		if err != nil {
-			return errorWrapper(err, "bind_request_body_failed", http.StatusBadRequest)
-		}
-	}
-	if relayMode == RelayModeModeration && textRequest.Model == "" {
-		textRequest.Model = "text-moderation-latest"
-	}
-	baseURL := common.ChannelBaseURLs[channelType]
-	requestURL := c.Request.URL.String()
-	if channelType == common.ChannelTypeCustom {
-		baseURL = c.GetString("base_url")
-	} else if channelType == common.ChannelTypeOpenAI {
-		if c.GetString("base_url") != "" {
-			baseURL = c.GetString("base_url")
-		}
-	}
-	fullRequestURL := fmt.Sprintf("%s%s", baseURL, requestURL)
-	if channelType == common.ChannelTypeAzure {
-		// https://learn.microsoft.com/en-us/azure/cognitive-services/openai/chatgpt-quickstart?pivots=rest-api&tabs=command-line#rest-api
-		query := c.Request.URL.Query()
-		apiVersion := query.Get("api-version")
-		if apiVersion == "" {
-			apiVersion = c.GetString("api_version")
-		}
-		requestURL := strings.Split(requestURL, "?")[0]
-		requestURL = fmt.Sprintf("%s?api-version=%s", requestURL, apiVersion)
-		baseURL = c.GetString("base_url")
-		task := strings.TrimPrefix(requestURL, "/v1/")
-		model_ := textRequest.Model
-		model_ = strings.Replace(model_, ".", "", -1)
-		// https://github.com/songquanpeng/one-api/issues/67
-		model_ = strings.TrimSuffix(model_, "-0301")
-		model_ = strings.TrimSuffix(model_, "-0314")
-		fullRequestURL = fmt.Sprintf("%s/openai/deployments/%s/%s", baseURL, model_, task)
-	} else if channelType == common.ChannelTypePaLM {
-		err := relayPaLM(textRequest, c)
-		return err
-	}
-	var promptTokens int
-	switch relayMode {
-	case RelayModeChatCompletions:
-		promptTokens = countTokenMessages(textRequest.Messages, textRequest.Model)
-	case RelayModeCompletions:
-		promptTokens = countTokenText(textRequest.Prompt, textRequest.Model)
-	case RelayModeModeration:
-		promptTokens = countTokenText(textRequest.Input, textRequest.Model)
-	}
-	preConsumedTokens := common.PreConsumedQuota
-	if textRequest.MaxTokens != 0 {
-		preConsumedTokens = promptTokens + textRequest.MaxTokens
-	}
-	modelRatio := common.GetModelRatio(textRequest.Model)
-	groupRatio := common.GetGroupRatio(group)
-	ratio := modelRatio * groupRatio
-	preConsumedQuota := int(float64(preConsumedTokens) * ratio)
-	if consumeQuota {
-		err := model.PreConsumeTokenQuota(tokenId, preConsumedQuota)
-		if err != nil {
-			return errorWrapper(err, "pre_consume_token_quota_failed", http.StatusOK)
-		}
-	}
-	req, err := http.NewRequest(c.Request.Method, fullRequestURL, c.Request.Body)
-	if err != nil {
-		return errorWrapper(err, "new_request_failed", http.StatusOK)
-	}
-	if channelType == common.ChannelTypeAzure {
-		key := c.Request.Header.Get("Authorization")
-		key = strings.TrimPrefix(key, "Bearer ")
-		req.Header.Set("api-key", key)
-	} else {
-		req.Header.Set("Authorization", c.Request.Header.Get("Authorization"))
-	}
-	req.Header.Set("Content-Type", c.Request.Header.Get("Content-Type"))
-	req.Header.Set("Accept", c.Request.Header.Get("Accept"))
-	req.Header.Set("Connection", c.Request.Header.Get("Connection"))
-	client := &http.Client{}
-	resp, err := client.Do(req)
-	if err != nil {
-		return errorWrapper(err, "do_request_failed", http.StatusOK)
-	}
-	err = req.Body.Close()
-	if err != nil {
-		return errorWrapper(err, "close_request_body_failed", http.StatusOK)
-	}
-	err = c.Request.Body.Close()
-	if err != nil {
-		return errorWrapper(err, "close_request_body_failed", http.StatusOK)
-	}
-	var textResponse TextResponse
-	isStream := strings.HasPrefix(resp.Header.Get("Content-Type"), "text/event-stream")
-	var streamResponseText string
-
-	defer func() {
-		if consumeQuota {
-			quota := 0
-			usingGPT4 := strings.HasPrefix(textRequest.Model, "gpt-4")
-			completionRatio := 1
-			if usingGPT4 {
-				completionRatio = 2
-			}
-			if isStream {
-				responseTokens := countTokenText(streamResponseText, textRequest.Model)
-				quota = promptTokens + responseTokens*completionRatio
-			} else {
-				quota = textResponse.Usage.PromptTokens + textResponse.Usage.CompletionTokens*completionRatio
-			}
-			quota = int(float64(quota) * ratio)
-			if ratio != 0 && quota <= 0 {
-				quota = 1
-			}
-			quotaDelta := quota - preConsumedQuota
-			err := model.PostConsumeTokenQuota(tokenId, quotaDelta)
-			if err != nil {
-				common.SysError("Error consuming token remain quota: " + err.Error())
-			}
-			userId := c.GetInt("id")
-			model.RecordLog(userId, model.LogTypeConsume, fmt.Sprintf("使用模型 %s 消耗 %d 点额度（模型倍率 %.2f，分组倍率 %.2f）", textRequest.Model, quota, modelRatio, groupRatio))
-		}
-	}()
-
-	if isStream {
-		scanner := bufio.NewScanner(resp.Body)
-		scanner.Split(func(data []byte, atEOF bool) (advance int, token []byte, err error) {
-			if atEOF && len(data) == 0 {
-				return 0, nil, nil
-			}
-
-			if i := strings.Index(string(data), "\n\n"); i >= 0 {
-				return i + 2, data[0:i], nil
-			}
-
-			if atEOF {
-				return len(data), data, nil
-			}
-
-			return 0, nil, nil
-		})
-		dataChan := make(chan string)
-		stopChan := make(chan bool)
-		go func() {
-			for scanner.Scan() {
-				data := scanner.Text()
-				if len(data) < 6 { // must be something wrong!
-					common.SysError("Invalid stream response: " + data)
-					continue
-				}
-				dataChan <- data
-				data = data[6:]
-				if !strings.HasPrefix(data, "[DONE]") {
-					switch relayMode {
-					case RelayModeChatCompletions:
-						var streamResponse ChatCompletionsStreamResponse
-						err = json.Unmarshal([]byte(data), &streamResponse)
-						if err != nil {
-							common.SysError("Error unmarshalling stream response: " + err.Error())
-							return
-						}
-						for _, choice := range streamResponse.Choices {
-							streamResponseText += choice.Delta.Content
-						}
-					case RelayModeCompletions:
-						var streamResponse CompletionsStreamResponse
-						err = json.Unmarshal([]byte(data), &streamResponse)
-						if err != nil {
-							common.SysError("Error unmarshalling stream response: " + err.Error())
-							return
-						}
-						for _, choice := range streamResponse.Choices {
-							streamResponseText += choice.Text
-						}
-					}
-				}
-			}
-			stopChan <- true
-		}()
-		c.Writer.Header().Set("Content-Type", "text/event-stream")
-		c.Writer.Header().Set("Cache-Control", "no-cache")
-		c.Writer.Header().Set("Connection", "keep-alive")
-		c.Writer.Header().Set("Transfer-Encoding", "chunked")
-		c.Writer.Header().Set("X-Accel-Buffering", "no")
-		c.Stream(func(w io.Writer) bool {
-			select {
-			case data := <-dataChan:
-				if strings.HasPrefix(data, "data: [DONE]") {
-					data = data[:12]
-				}
-				c.Render(-1, common.CustomEvent{Data: data})
-				return true
-			case <-stopChan:
-				return false
-			}
-		})
-		err = resp.Body.Close()
-		if err != nil {
-			return errorWrapper(err, "close_response_body_failed", http.StatusOK)
-		}
-		return nil
-	} else {
-		if consumeQuota {
-			responseBody, err := io.ReadAll(resp.Body)
-			if err != nil {
-				return errorWrapper(err, "read_response_body_failed", http.StatusOK)
-			}
-			err = resp.Body.Close()
-			if err != nil {
-				return errorWrapper(err, "close_response_body_failed", http.StatusOK)
-			}
-			err = json.Unmarshal(responseBody, &textResponse)
-			if err != nil {
-				return errorWrapper(err, "unmarshal_response_body_failed", http.StatusOK)
-			}
-			if textResponse.Error.Type != "" {
-				return &OpenAIErrorWithStatusCode{
-					OpenAIError: textResponse.Error,
-					StatusCode:  resp.StatusCode,
-				}
-			}
-			// Reset response body
-			resp.Body = io.NopCloser(bytes.NewBuffer(responseBody))
-		}
-		// We shouldn't set the header before we parse the response body, because the parse part may fail.
-		// And then we will have to send an error response, but in this case, the header has already been set.
-		// So the client will be confused by the response.
-		// For example, Postman will report error, and we cannot check the response at all.
-		for k, v := range resp.Header {
-			c.Writer.Header().Set(k, v[0])
-		}
-		c.Writer.WriteHeader(resp.StatusCode)
-		_, err = io.Copy(c.Writer, resp.Body)
-		if err != nil {
-			return errorWrapper(err, "copy_response_body_failed", http.StatusOK)
-		}
-		err = resp.Body.Close()
-		if err != nil {
-			return errorWrapper(err, "close_response_body_failed", http.StatusOK)
-		}
-		return nil
-	}
-}
-
 func RelayNotImplemented(c *gin.Context) {
 	err := OpenAIError{
 		Message: "API not implemented",
@@ -391,7 +135,19 @@ func RelayNotImplemented(c *gin.Context) {
 		Param:   "",
 		Code:    "api_not_implemented",
 	}
-	c.JSON(http.StatusOK, gin.H{
+	c.JSON(http.StatusNotImplemented, gin.H{
+		"error": err,
+	})
+}
+
+func RelayNotFound(c *gin.Context) {
+	err := OpenAIError{
+		Message: fmt.Sprintf("API not found: %s:%s", c.Request.Method, c.Request.URL.Path),
+		Type:    "one_api_error",
+		Param:   "",
+		Code:    "api_not_found",
+	}
+	c.JSON(http.StatusNotFound, gin.H{
 		"error": err,
 	})
 }

controller/user.go

@@ -150,15 +150,18 @@ func Register(c *gin.Context) {
 			return
 		}
 	}
+	affCode := user.AffCode // this code is the inviter's code, not the user's own code
+	inviterId, _ := model.GetUserIdByAffCode(affCode)
 	cleanUser := model.User{
 		Username:    user.Username,
 		Password:    user.Password,
 		DisplayName: user.Username,
+		InviterId:   inviterId,
 	}
 	if common.EmailVerificationEnabled {
 		cleanUser.Email = user.Email
 	}
-	if err := cleanUser.Insert(); err != nil {
+	if err := cleanUser.Insert(inviterId); err != nil {
 		c.JSON(http.StatusOK, gin.H{
 			"success": false,
 			"message": err.Error(),
@@ -256,7 +259,7 @@ func GenerateAccessToken(c *gin.Context) {
 	}
 	user.AccessToken = common.GetUUID()
 
-	if model.DB.Where("token = ?", user.AccessToken).First(user).RowsAffected != 0 {
+	if model.DB.Where("access_token = ?", user.AccessToken).First(user).RowsAffected != 0 {
 		c.JSON(http.StatusOK, gin.H{
 			"success": false,
 			"message": "请重试，系统生成的 UUID 竟然重复了！",
@@ -280,6 +283,34 @@ func GenerateAccessToken(c *gin.Context) {
 	return
 }
 
+func GetAffCode(c *gin.Context) {
+	id := c.GetInt("id")
+	user, err := model.GetUserById(id, true)
+	if err != nil {
+		c.JSON(http.StatusOK, gin.H{
+			"success": false,
+			"message": err.Error(),
+		})
+		return
+	}
+	if user.AffCode == "" {
+		user.AffCode = common.GetRandomString(4)
+		if err := user.Update(false); err != nil {
+			c.JSON(http.StatusOK, gin.H{
+				"success": false,
+				"message": err.Error(),
+			})
+			return
+		}
+	}
+	c.JSON(http.StatusOK, gin.H{
+		"success": true,
+		"message": "",
+		"data":    user.AffCode,
+	})
+	return
+}
+
 func GetSelf(c *gin.Context) {
 	id := c.GetInt("id")
 	user, err := model.GetUserById(id, false)
@@ -353,7 +384,7 @@ func UpdateUser(c *gin.Context) {
 		return
 	}
 	if originUser.Quota != updatedUser.Quota {
-		model.RecordLog(originUser.Id, model.LogTypeManage, fmt.Sprintf("管理员将用户额度从 %d 点修改为 %d 点", originUser.Quota, updatedUser.Quota))
+		model.RecordLog(originUser.Id, model.LogTypeManage, fmt.Sprintf("管理员将用户额度从 %s修改为 %s", common.LogQuota(originUser.Quota), common.LogQuota(updatedUser.Quota)))
 	}
 	c.JSON(http.StatusOK, gin.H{
 		"success": true,
@@ -495,7 +526,7 @@ func CreateUser(c *gin.Context) {
 		Password:    user.Password,
 		DisplayName: user.DisplayName,
 	}
-	if err := cleanUser.Insert(); err != nil {
+	if err := cleanUser.Insert(0); err != nil {
 		c.JSON(http.StatusOK, gin.H{
 			"success": false,
 			"message": err.Error(),

controller/wechat.go

@@ -85,7 +85,7 @@ func WeChatAuth(c *gin.Context) {
 			user.Role = common.RoleCommonUser
 			user.Status = common.UserStatusEnabled
 
-			if err := user.Insert(); err != nil {
+			if err := user.Insert(0); err != nil {
 				c.JSON(http.StatusOK, gin.H{
 					"success": false,
 					"message": err.Error(),

docker-compose.yml

@@ -2,7 +2,7 @@ version: '3.4'
 
 services:
   one-api:
-    image: ghcr.io/songquanpeng/one-api:latest
+    image: justsong/one-api:latest
     container_name: one-api
     restart: always
     command: --log-dir /app/logs
@@ -11,12 +11,24 @@ services:
     volumes:
       - ./data:/data
       - ./logs:/app/logs
-    # environment:
+    environment:
-    #   REDIS_CONN_STRING: redis://default:redispw@localhost:49153
+      - SQL_DSN=root:123456@tcp(host.docker.internal:3306)/one-api  # 修改此行，或注释掉以使用 SQLite 作为数据库
-    #   SESSION_SECRET: random_string
+      - REDIS_CONN_STRING=redis://redis
-    #   SQL_DSN: root:123456@tcp(localhost:3306)/one-api
+      - SESSION_SECRET=random_string  # 修改为随机字符串
+      - TZ=Asia/Shanghai
+#      - NODE_TYPE=slave  # 多机部署时从节点取消注释该行
+#      - SYNC_FREQUENCY=60  # 需要定期从数据库加载数据时取消注释该行
+#      - FRONTEND_BASE_URL=https://openai.justsong.cn  # 多机部署时从节点取消注释该行
+
+    depends_on:
+      - redis
     healthcheck:
-      test: ["CMD-SHELL", "curl -s http://localhost:3000/api/status | grep -o '\"success\":\\s*true' | awk '{print $2}' | grep 'true'"]
+      test: [ "CMD-SHELL", "curl -s http://localhost:3000/api/status | grep -o '\"success\":\\s*true' | awk '{print $2}' | grep 'true'" ]
       interval: 30s
       timeout: 10s
       retries: 3
+
+  redis:
+    image: redis:latest
+    container_name: redis
+    restart: always

main.go

@@ -6,8 +6,8 @@ import (
 	"github.com/gin-contrib/sessions/cookie"
 	"github.com/gin-contrib/sessions/redis"
 	"github.com/gin-gonic/gin"
-	"log"
 	"one-api/common"
+	"one-api/controller"
 	"one-api/middleware"
 	"one-api/model"
 	"one-api/router"
@@ -30,29 +30,49 @@ func main() {
 	// Initialize SQL Database
 	err := model.InitDB()
 	if err != nil {
-		common.FatalLog(err)
+		common.FatalLog("failed to initialize database: " + err.Error())
 	}
 	defer func() {
 		err := model.CloseDB()
 		if err != nil {
-			common.FatalLog(err)
+			common.FatalLog("failed to close database: " + err.Error())
 		}
 	}()
 
 	// Initialize Redis
 	err = common.InitRedisClient()
 	if err != nil {
-		common.FatalLog(err)
+		common.FatalLog("failed to initialize Redis: " + err.Error())
 	}
 
 	// Initialize options
 	model.InitOptionMap()
+	if common.RedisEnabled {
+		model.InitChannelCache()
+	}
 	if os.Getenv("SYNC_FREQUENCY") != "" {
 		frequency, err := strconv.Atoi(os.Getenv("SYNC_FREQUENCY"))
 		if err != nil {
-			common.FatalLog(err)
+			common.FatalLog("failed to parse SYNC_FREQUENCY: " + err.Error())
 		}
 		go model.SyncOptions(frequency)
+		if common.RedisEnabled {
+			go model.SyncChannelCache(frequency)
+		}
+	}
+	if os.Getenv("CHANNEL_UPDATE_FREQUENCY") != "" {
+		frequency, err := strconv.Atoi(os.Getenv("CHANNEL_UPDATE_FREQUENCY"))
+		if err != nil {
+			common.FatalLog("failed to parse CHANNEL_UPDATE_FREQUENCY: " + err.Error())
+		}
+		go controller.AutomaticallyUpdateChannels(frequency)
+	}
+	if os.Getenv("CHANNEL_TEST_FREQUENCY") != "" {
+		frequency, err := strconv.Atoi(os.Getenv("CHANNEL_TEST_FREQUENCY"))
+		if err != nil {
+			common.FatalLog("failed to parse CHANNEL_TEST_FREQUENCY: " + err.Error())
+		}
+		go controller.AutomaticallyTestChannels(frequency)
 	}
 
 	// Initialize HTTP server
@@ -78,6 +98,6 @@ func main() {
 	}
 	err = server.Run(":" + port)
 	if err != nil {
-		log.Println(err)
+		common.FatalLog("failed to start HTTP server: " + err.Error())
 	}
 }

middleware/auth.go

@@ -91,7 +91,7 @@ func TokenAuth() func(c *gin.Context) {
 		key = parts[0]
 		token, err := model.ValidateUserToken(key)
 		if err != nil {
-			c.JSON(http.StatusOK, gin.H{
+			c.JSON(http.StatusUnauthorized, gin.H{
 				"error": gin.H{
 					"message": err.Error(),
 					"type":    "one_api_error",
@@ -100,8 +100,8 @@ func TokenAuth() func(c *gin.Context) {
 			c.Abort()
 			return
 		}
-		if !model.IsUserEnabled(token.UserId) {
+		if !model.CacheIsUserEnabled(token.UserId) {
-			c.JSON(http.StatusOK, gin.H{
+			c.JSON(http.StatusForbidden, gin.H{
 				"error": gin.H{
 					"message": "用户已被封禁",
 					"type":    "one_api_error",
@@ -112,6 +112,7 @@ func TokenAuth() func(c *gin.Context) {
 		}
 		c.Set("id", token.UserId)
 		c.Set("token_id", token.Id)
+		c.Set("token_name", token.Name)
 		requestURL := c.Request.URL.String()
 		consumeQuota := true
 		if strings.HasPrefix(requestURL, "/v1/models") {
@@ -122,7 +123,7 @@ func TokenAuth() func(c *gin.Context) {
 			if model.IsAdmin(token.UserId) {
 				c.Set("channelId", parts[1])
 			} else {
-				c.JSON(http.StatusOK, gin.H{
+				c.JSON(http.StatusForbidden, gin.H{
 					"error": gin.H{
 						"message": "普通用户不支持指定渠道",
 						"type":    "one_api_error",

middleware/cors.go

@@ -10,6 +10,6 @@ func CORS() gin.HandlerFunc {
 	config.AllowAllOrigins = true
 	config.AllowCredentials = true
 	config.AllowMethods = []string{"GET", "POST", "PUT", "DELETE", "OPTIONS"}
-	config.AllowHeaders = []string{"Origin", "Content-Length", "Content-Type", "Authorization", "Accept", "Connection"}
+	config.AllowHeaders = []string{"*"}
 	return cors.New(config)
 }

middleware/distributor.go

@@ -17,14 +17,14 @@ type ModelRequest struct {
 func Distribute() func(c *gin.Context) {
 	return func(c *gin.Context) {
 		userId := c.GetInt("id")
-		userGroup, _ := model.GetUserGroup(userId)
+		userGroup, _ := model.CacheGetUserGroup(userId)
 		c.Set("group", userGroup)
 		var channel *model.Channel
 		channelId, ok := c.Get("channelId")
 		if ok {
 			id, err := strconv.Atoi(channelId.(string))
 			if err != nil {
-				c.JSON(http.StatusOK, gin.H{
+				c.JSON(http.StatusBadRequest, gin.H{
 					"error": gin.H{
 						"message": "无效的渠道 ID",
 						"type":    "one_api_error",
@@ -35,7 +35,7 @@ func Distribute() func(c *gin.Context) {
 			}
 			channel, err = model.GetChannelById(id, true)
 			if err != nil {
-				c.JSON(200, gin.H{
+				c.JSON(http.StatusBadRequest, gin.H{
 					"error": gin.H{
 						"message": "无效的渠道 ID",
 						"type":    "one_api_error",
@@ -45,7 +45,7 @@ func Distribute() func(c *gin.Context) {
 				return
 			}
 			if channel.Status != common.ChannelStatusEnabled {
-				c.JSON(200, gin.H{
+				c.JSON(http.StatusForbidden, gin.H{
 					"error": gin.H{
 						"message": "该渠道已被禁用",
 						"type":    "one_api_error",
@@ -59,7 +59,7 @@ func Distribute() func(c *gin.Context) {
 			var modelRequest ModelRequest
 			err := common.UnmarshalBodyReusable(c, &modelRequest)
 			if err != nil {
-				c.JSON(200, gin.H{
+				c.JSON(http.StatusBadRequest, gin.H{
 					"error": gin.H{
 						"message": "无效的请求",
 						"type":    "one_api_error",
@@ -73,9 +73,9 @@ func Distribute() func(c *gin.Context) {
 					modelRequest.Model = "text-moderation-stable"
 				}
 			}
-			channel, err = model.GetRandomSatisfiedChannel(userGroup, modelRequest.Model)
+			channel, err = model.CacheGetRandomSatisfiedChannel(userGroup, modelRequest.Model)
 			if err != nil {
-				c.JSON(200, gin.H{
+				c.JSON(http.StatusServiceUnavailable, gin.H{
 					"error": gin.H{
 						"message": "无可用渠道",
 						"type":    "one_api_error",

model/ability.go

@@ -30,15 +30,18 @@ func GetRandomSatisfiedChannel(group string, model string) (*Channel, error) {
 
 func (channel *Channel) AddAbilities() error {
 	models_ := strings.Split(channel.Models, ",")
+	groups_ := strings.Split(channel.Group, ",")
 	abilities := make([]Ability, 0, len(models_))
 	for _, model := range models_ {
-		ability := Ability{
+		for _, group := range groups_ {
-			Group:     channel.Group,
+			ability := Ability{
-			Model:     model,
+				Group:     group,
-			ChannelId: channel.Id,
+				Model:     model,
-			Enabled:   channel.Status == common.ChannelStatusEnabled,
+				ChannelId: channel.Id,
+				Enabled:   channel.Status == common.ChannelStatusEnabled,
+			}
+			abilities = append(abilities, ability)
 		}
-		abilities = append(abilities, ability)
 	}
 	return DB.Create(&abilities).Error
 }

model/cache.go

@@ -0,0 +1,163 @@
+package model
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"math/rand"
+	"one-api/common"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+)
+
+const (
+	TokenCacheSeconds         = 60 * 60
+	UserId2GroupCacheSeconds  = 60 * 60
+	UserId2QuotaCacheSeconds  = 10 * 60
+	UserId2StatusCacheSeconds = 60 * 60
+)
+
+func CacheGetTokenByKey(key string) (*Token, error) {
+	var token Token
+	if !common.RedisEnabled {
+		err := DB.Where("`key` = ?", key).First(&token).Error
+		return &token, err
+	}
+	tokenObjectString, err := common.RedisGet(fmt.Sprintf("token:%s", key))
+	if err != nil {
+		err := DB.Where("`key` = ?", key).First(&token).Error
+		if err != nil {
+			return nil, err
+		}
+		jsonBytes, err := json.Marshal(token)
+		if err != nil {
+			return nil, err
+		}
+		err = common.RedisSet(fmt.Sprintf("token:%s", key), string(jsonBytes), TokenCacheSeconds*time.Second)
+		if err != nil {
+			common.SysError("Redis set token error: " + err.Error())
+		}
+		return &token, nil
+	}
+	err = json.Unmarshal([]byte(tokenObjectString), &token)
+	return &token, err
+}
+
+func CacheGetUserGroup(id int) (group string, err error) {
+	if !common.RedisEnabled {
+		return GetUserGroup(id)
+	}
+	group, err = common.RedisGet(fmt.Sprintf("user_group:%d", id))
+	if err != nil {
+		group, err = GetUserGroup(id)
+		if err != nil {
+			return "", err
+		}
+		err = common.RedisSet(fmt.Sprintf("user_group:%d", id), group, UserId2GroupCacheSeconds*time.Second)
+		if err != nil {
+			common.SysError("Redis set user group error: " + err.Error())
+		}
+	}
+	return group, err
+}
+
+func CacheGetUserQuota(id int) (quota int, err error) {
+	if !common.RedisEnabled {
+		return GetUserQuota(id)
+	}
+	quotaString, err := common.RedisGet(fmt.Sprintf("user_quota:%d", id))
+	if err != nil {
+		quota, err = GetUserQuota(id)
+		if err != nil {
+			return 0, err
+		}
+		err = common.RedisSet(fmt.Sprintf("user_quota:%d", id), fmt.Sprintf("%d", quota), UserId2QuotaCacheSeconds*time.Second)
+		if err != nil {
+			common.SysError("Redis set user quota error: " + err.Error())
+		}
+		return quota, err
+	}
+	quota, err = strconv.Atoi(quotaString)
+	return quota, err
+}
+
+func CacheIsUserEnabled(userId int) bool {
+	if !common.RedisEnabled {
+		return IsUserEnabled(userId)
+	}
+	enabled, err := common.RedisGet(fmt.Sprintf("user_enabled:%d", userId))
+	if err != nil {
+		status := common.UserStatusDisabled
+		if IsUserEnabled(userId) {
+			status = common.UserStatusEnabled
+		}
+		enabled = fmt.Sprintf("%d", status)
+		err = common.RedisSet(fmt.Sprintf("user_enabled:%d", userId), enabled, UserId2StatusCacheSeconds*time.Second)
+		if err != nil {
+			common.SysError("Redis set user enabled error: " + err.Error())
+		}
+	}
+	return enabled == "1"
+}
+
+var group2model2channels map[string]map[string][]*Channel
+var channelSyncLock sync.RWMutex
+
+func InitChannelCache() {
+	newChannelId2channel := make(map[int]*Channel)
+	var channels []*Channel
+	DB.Find(&channels)
+	for _, channel := range channels {
+		newChannelId2channel[channel.Id] = channel
+	}
+	var abilities []*Ability
+	DB.Find(&abilities)
+	groups := make(map[string]bool)
+	for _, ability := range abilities {
+		groups[ability.Group] = true
+	}
+	newGroup2model2channels := make(map[string]map[string][]*Channel)
+	for group := range groups {
+		newGroup2model2channels[group] = make(map[string][]*Channel)
+	}
+	for _, channel := range channels {
+		groups := strings.Split(channel.Group, ",")
+		for _, group := range groups {
+			models := strings.Split(channel.Models, ",")
+			for _, model := range models {
+				if _, ok := newGroup2model2channels[group][model]; !ok {
+					newGroup2model2channels[group][model] = make([]*Channel, 0)
+				}
+				newGroup2model2channels[group][model] = append(newGroup2model2channels[group][model], channel)
+			}
+		}
+	}
+	channelSyncLock.Lock()
+	group2model2channels = newGroup2model2channels
+	channelSyncLock.Unlock()
+	common.SysLog("channels synced from database")
+}
+
+func SyncChannelCache(frequency int) {
+	for {
+		time.Sleep(time.Duration(frequency) * time.Second)
+		common.SysLog("syncing channels from database")
+		InitChannelCache()
+	}
+}
+
+func CacheGetRandomSatisfiedChannel(group string, model string) (*Channel, error) {
+	if !common.RedisEnabled {
+		return GetRandomSatisfiedChannel(group, model)
+	}
+	channelSyncLock.RLock()
+	defer channelSyncLock.RUnlock()
+	channels := group2model2channels[group][model]
+	if len(channels) == 0 {
+		return nil, errors.New("channel not found")
+	}
+	idx := rand.Intn(len(channels))
+	return channels[idx], nil
+}

model/channel.go

@@ -1,13 +1,14 @@
 package model
 
 import (
+	"gorm.io/gorm"
 	"one-api/common"
 )
 
 type Channel struct {
 	Id                 int     `json:"id"`
 	Type               int     `json:"type" gorm:"default:0"`
-	Key                string  `json:"key" gorm:"not null"`
+	Key                string  `json:"key" gorm:"not null;index"`
 	Status             int     `json:"status" gorm:"default:1"`
 	Name               string  `json:"name" gorm:"index"`
 	Weight             int     `json:"weight"`
@@ -20,6 +21,7 @@ type Channel struct {
 	BalanceUpdatedTime int64   `json:"balance_updated_time" gorm:"bigint"`
 	Models             string  `json:"models"`
 	Group              string  `json:"group" gorm:"type:varchar(32);default:'default'"`
+	UsedQuota          int64   `json:"used_quota" gorm:"bigint;default:0"`
 }
 
 func GetAllChannels(startIdx int, num int, selectAll bool) ([]*Channel, error) {
@@ -34,7 +36,7 @@ func GetAllChannels(startIdx int, num int, selectAll bool) ([]*Channel, error) {
 }
 
 func SearchChannels(keyword string) (channels []*Channel, err error) {
-	err = DB.Omit("key").Where("id = ? or name LIKE ?", keyword, keyword+"%").Find(&channels).Error
+	err = DB.Omit("key").Where("id = ? or name LIKE ? or key = ?", keyword, keyword+"%", keyword).Find(&channels).Error
 	return channels, err
 }
 
@@ -136,3 +138,10 @@ func UpdateChannelStatusById(id int, status int) {
 		common.SysError("failed to update channel status: " + err.Error())
 	}
 }
+
+func UpdateChannelUsedQuota(id int, quota int) {
+	err := DB.Model(&Channel{}).Where("id = ?", id).Update("used_quota", gorm.Expr("used_quota + ?", quota)).Error
+	if err != nil {
+		common.SysError("failed to update channel used quota: " + err.Error())
+	}
+}

model/log.go

@@ -22,6 +22,9 @@ const (
 )
 
 func RecordLog(userId int, logType int, content string) {
+	if logType == LogTypeConsume && !common.LogConsumeEnabled {
+		return
+	}
 	log := &Log{
 		UserId:    userId,
 		CreatedAt: common.GetTimestamp(),

model/main.go

@@ -42,19 +42,24 @@ func InitDB() (err error) {
 	var db *gorm.DB
 	if os.Getenv("SQL_DSN") != "" {
 		// Use MySQL
+		common.SysLog("using MySQL as database")
 		db, err = gorm.Open(mysql.Open(os.Getenv("SQL_DSN")), &gorm.Config{
 			PrepareStmt: true, // precompile SQL
 		})
 	} else {
 		// Use SQLite
+		common.SysLog("SQL_DSN not set, using SQLite as database")
 		common.UsingSQLite = true
 		db, err = gorm.Open(sqlite.Open(common.SQLitePath), &gorm.Config{
 			PrepareStmt: true, // precompile SQL
 		})
-		common.SysLog("SQL_DSN not set, using SQLite as database")
 	}
+	common.SysLog("database connected")
 	if err == nil {
 		DB = db
+		if !common.IsMasterNode {
+			return nil
+		}
 		err := db.AutoMigrate(&Channel{})
 		if err != nil {
 			return err
@@ -83,6 +88,7 @@ func InitDB() (err error) {
 		if err != nil {
 			return err
 		}
+		common.SysLog("database migrated")
 		err = createRootAccountIfNeed()
 		return err
 	} else {

model/option.go

@@ -34,6 +34,9 @@ func InitOptionMap() {
 	common.OptionMap["TurnstileCheckEnabled"] = strconv.FormatBool(common.TurnstileCheckEnabled)
 	common.OptionMap["RegisterEnabled"] = strconv.FormatBool(common.RegisterEnabled)
 	common.OptionMap["AutomaticDisableChannelEnabled"] = strconv.FormatBool(common.AutomaticDisableChannelEnabled)
+	common.OptionMap["LogConsumeEnabled"] = strconv.FormatBool(common.LogConsumeEnabled)
+	common.OptionMap["DisplayInCurrencyEnabled"] = strconv.FormatBool(common.DisplayInCurrencyEnabled)
+	common.OptionMap["DisplayTokenStatEnabled"] = strconv.FormatBool(common.DisplayTokenStatEnabled)
 	common.OptionMap["ChannelDisableThreshold"] = strconv.FormatFloat(common.ChannelDisableThreshold, 'f', -1, 64)
 	common.OptionMap["SMTPServer"] = ""
 	common.OptionMap["SMTPFrom"] = ""
@@ -55,11 +58,15 @@ func InitOptionMap() {
 	common.OptionMap["TurnstileSiteKey"] = ""
 	common.OptionMap["TurnstileSecretKey"] = ""
 	common.OptionMap["QuotaForNewUser"] = strconv.Itoa(common.QuotaForNewUser)
+	common.OptionMap["QuotaForInviter"] = strconv.Itoa(common.QuotaForInviter)
+	common.OptionMap["QuotaForInvitee"] = strconv.Itoa(common.QuotaForInvitee)
 	common.OptionMap["QuotaRemindThreshold"] = strconv.Itoa(common.QuotaRemindThreshold)
 	common.OptionMap["PreConsumedQuota"] = strconv.Itoa(common.PreConsumedQuota)
 	common.OptionMap["ModelRatio"] = common.ModelRatio2JSONString()
 	common.OptionMap["GroupRatio"] = common.GroupRatio2JSONString()
 	common.OptionMap["TopUpLink"] = common.TopUpLink
+	common.OptionMap["ChatLink"] = common.ChatLink
+	common.OptionMap["QuotaPerUnit"] = strconv.FormatFloat(common.QuotaPerUnit, 'f', -1, 64)
 	common.OptionMapRWMutex.Unlock()
 	loadOptionsFromDatabase()
 }
@@ -69,7 +76,7 @@ func loadOptionsFromDatabase() {
 	for _, option := range options {
 		err := updateOptionMap(option.Key, option.Value)
 		if err != nil {
-			common.SysError("Failed to update option map: " + err.Error())
+			common.SysError("failed to update option map: " + err.Error())
 		}
 	}
 }
@@ -77,7 +84,7 @@ func loadOptionsFromDatabase() {
 func SyncOptions(frequency int) {
 	for {
 		time.Sleep(time.Duration(frequency) * time.Second)
-		common.SysLog("Syncing options from database")
+		common.SysLog("syncing options from database")
 		loadOptionsFromDatabase()
 	}
 }
@@ -134,6 +141,12 @@ func updateOptionMap(key string, value string) (err error) {
 			common.RegisterEnabled = boolValue
 		case "AutomaticDisableChannelEnabled":
 			common.AutomaticDisableChannelEnabled = boolValue
+		case "LogConsumeEnabled":
+			common.LogConsumeEnabled = boolValue
+		case "DisplayInCurrencyEnabled":
+			common.DisplayInCurrencyEnabled = boolValue
+		case "DisplayTokenStatEnabled":
+			common.DisplayTokenStatEnabled = boolValue
 		}
 	}
 	switch key {
@@ -172,6 +185,10 @@ func updateOptionMap(key string, value string) (err error) {
 		common.TurnstileSecretKey = value
 	case "QuotaForNewUser":
 		common.QuotaForNewUser, _ = strconv.Atoi(value)
+	case "QuotaForInviter":
+		common.QuotaForInviter, _ = strconv.Atoi(value)
+	case "QuotaForInvitee":
+		common.QuotaForInvitee, _ = strconv.Atoi(value)
 	case "QuotaRemindThreshold":
 		common.QuotaRemindThreshold, _ = strconv.Atoi(value)
 	case "PreConsumedQuota":
@@ -182,8 +199,12 @@ func updateOptionMap(key string, value string) (err error) {
 		err = common.UpdateGroupRatioByJSONString(value)
 	case "TopUpLink":
 		common.TopUpLink = value
+	case "ChatLink":
+		common.ChatLink = value
 	case "ChannelDisableThreshold":
 		common.ChannelDisableThreshold, _ = strconv.ParseFloat(value, 64)
+	case "QuotaPerUnit":
+		common.QuotaPerUnit, _ = strconv.ParseFloat(value, 64)
 	}
 	return err
 }

model/redemption.go

@@ -64,9 +64,9 @@ func Redeem(key string, userId int) (quota int, err error) {
 		redemption.Status = common.RedemptionCodeStatusUsed
 		err := redemption.SelectUpdate()
 		if err != nil {
-			common.SysError("更新兑换码状态失败：" + err.Error())
+			common.SysError("failed to update redemption status: " + err.Error())
 		}
-		RecordLog(userId, LogTypeTopup, fmt.Sprintf("通过兑换码充值 %d 点额度", redemption.Quota))
+		RecordLog(userId, LogTypeTopup, fmt.Sprintf("通过兑换码充值 %s", common.LogQuota(redemption.Quota)))
 	}()
 	return redemption.Quota, nil
 }

model/token.go

@@ -18,6 +18,7 @@ type Token struct {
 	ExpiredTime    int64  `json:"expired_time" gorm:"bigint;default:-1"` // -1 means never expired
 	RemainQuota    int    `json:"remain_quota" gorm:"default:0"`
 	UnlimitedQuota bool   `json:"unlimited_quota" gorm:"default:false"`
+	UsedQuota      int    `json:"used_quota" gorm:"default:0"` // used quota
 }
 
 func GetAllUserTokens(userId int, startIdx int, num int) ([]*Token, error) {
@@ -28,46 +29,45 @@ func GetAllUserTokens(userId int, startIdx int, num int) ([]*Token, error) {
 }
 
 func SearchUserTokens(userId int, keyword string) (tokens []*Token, err error) {
-	err = DB.Where("user_id = ?", userId).Where("id = ? or name LIKE ?", keyword, keyword+"%").Find(&tokens).Error
+	err = DB.Where("user_id = ?", userId).Where("name LIKE ?", keyword+"%").Find(&tokens).Error
 	return tokens, err
 }
 
 func ValidateUserToken(key string) (token *Token, err error) {
 	if key == "" {
-		return nil, errors.New("未提供 token")
+		return nil, errors.New("未提供令牌")
 	}
-	token = &Token{}
+	token, err = CacheGetTokenByKey(key)
-	err = DB.Where("`key` = ?", key).First(token).Error
 	if err == nil {
 		if token.Status != common.TokenStatusEnabled {
-			return nil, errors.New("该 token 状态不可用")
+			return nil, errors.New("该令牌状态不可用")
 		}
 		if token.ExpiredTime != -1 && token.ExpiredTime < common.GetTimestamp() {
 			token.Status = common.TokenStatusExpired
 			err := token.SelectUpdate()
 			if err != nil {
-				common.SysError("更新 token 状态失败：" + err.Error())
+				common.SysError("failed to update token status" + err.Error())
 			}
-			return nil, errors.New("该 token 已过期")
+			return nil, errors.New("该令牌已过期")
 		}
 		if !token.UnlimitedQuota && token.RemainQuota <= 0 {
 			token.Status = common.TokenStatusExhausted
 			err := token.SelectUpdate()
 			if err != nil {
-				common.SysError("更新 token 状态失败：" + err.Error())
+				common.SysError("failed to update token status" + err.Error())
 			}
-			return nil, errors.New("该 token 额度已用尽")
+			return nil, errors.New("该令牌额度已用尽")
 		}
 		go func() {
 			token.AccessedTime = common.GetTimestamp()
 			err := token.SelectUpdate()
 			if err != nil {
-				common.SysError("更新 token 失败：" + err.Error())
+				common.SysError("failed to update token" + err.Error())
 			}
 		}()
 		return token, nil
 	}
-	return nil, errors.New("无效的 token")
+	return nil, errors.New("无效的令牌")
 }
 
 func GetTokenByIds(id int, userId int) (*Token, error) {
@@ -131,7 +131,12 @@ func IncreaseTokenQuota(id int, quota int) (err error) {
 	if quota < 0 {
 		return errors.New("quota 不能为负数！")
 	}
-	err = DB.Model(&Token{}).Where("id = ?", id).Update("remain_quota", gorm.Expr("remain_quota + ?", quota)).Error
+	err = DB.Model(&Token{}).Where("id = ?", id).Updates(
+		map[string]interface{}{
+			"remain_quota": gorm.Expr("remain_quota + ?", quota),
+			"used_quota":   gorm.Expr("used_quota - ?", quota),
+		},
+	).Error
 	return err
 }
 
@@ -139,7 +144,12 @@ func DecreaseTokenQuota(id int, quota int) (err error) {
 	if quota < 0 {
 		return errors.New("quota 不能为负数！")
 	}
-	err = DB.Model(&Token{}).Where("id = ?", id).Update("remain_quota", gorm.Expr("remain_quota - ?", quota)).Error
+	err = DB.Model(&Token{}).Where("id = ?", id).Updates(
+		map[string]interface{}{
+			"remain_quota": gorm.Expr("remain_quota - ?", quota),
+			"used_quota":   gorm.Expr("used_quota + ?", quota),
+		},
+	).Error
 	return err
 }
 
@@ -167,7 +177,7 @@ func PreConsumeTokenQuota(tokenId int, quota int) (err error) {
 		go func() {
 			email, err := GetUserEmail(token.UserId)
 			if err != nil {
-				common.SysError("获取用户邮箱失败：" + err.Error())
+				common.SysError("failed to fetch user email: " + err.Error())
 			}
 			prompt := "您的额度即将用尽"
 			if noMoreQuota {
@@ -178,7 +188,7 @@ func PreConsumeTokenQuota(tokenId int, quota int) (err error) {
 				err = common.SendEmail(prompt, email,
 					fmt.Sprintf("%s，当前剩余额度为 %d，为了不影响您的使用，请及时充值。<br/>充值链接：<a href='%s'>%s</a>", prompt, userQuota, topUpLink, topUpLink))
 				if err != nil {
-					common.SysError("发送邮件失败：" + err.Error())
+					common.SysError("failed to send email" + err.Error())
 				}
 			}
 		}()

model/user.go

@@ -23,7 +23,11 @@ type User struct {
 	VerificationCode string `json:"verification_code" gorm:"-:all"`                                    // this field is only for Email verification, don't save it to database!
 	AccessToken      string `json:"access_token" gorm:"type:char(32);column:access_token;uniqueIndex"` // this token is for system management
 	Quota            int    `json:"quota" gorm:"type:int;default:0"`
+	UsedQuota        int    `json:"used_quota" gorm:"type:int;default:0;column:used_quota"` // used quota
+	RequestCount     int    `json:"request_count" gorm:"type:int;default:0;"`               // request number
 	Group            string `json:"group" gorm:"type:varchar(32);default:'default'"`
+	AffCode          string `json:"aff_code" gorm:"type:varchar(32);column:aff_code;uniqueIndex"`
+	InviterId        int    `json:"inviter_id" gorm:"type:int;column:inviter_id;index"`
 }
 
 func GetMaxUserId() int {
@@ -56,6 +60,15 @@ func GetUserById(id int, selectAll bool) (*User, error) {
 	return &user, err
 }
 
+func GetUserIdByAffCode(affCode string) (int, error) {
+	if affCode == "" {
+		return 0, errors.New("affCode 为空！")
+	}
+	var user User
+	err := DB.Select("id").First(&user, "aff_code = ?", affCode).Error
+	return user.Id, err
+}
+
 func DeleteUserById(id int) (err error) {
 	if id == 0 {
 		return errors.New("id 为空！")
@@ -64,7 +77,7 @@ func DeleteUserById(id int) (err error) {
 	return user.Delete()
 }
 
-func (user *User) Insert() error {
+func (user *User) Insert(inviterId int) error {
 	var err error
 	if user.Password != "" {
 		user.Password, err = common.Password2Hash(user.Password)
@@ -74,12 +87,23 @@ func (user *User) Insert() error {
 	}
 	user.Quota = common.QuotaForNewUser
 	user.AccessToken = common.GetUUID()
+	user.AffCode = common.GetRandomString(4)
 	result := DB.Create(user)
 	if result.Error != nil {
 		return result.Error
 	}
 	if common.QuotaForNewUser > 0 {
-		RecordLog(user.Id, LogTypeSystem, fmt.Sprintf("新用户注册赠送 %d 点额度", common.QuotaForNewUser))
+		RecordLog(user.Id, LogTypeSystem, fmt.Sprintf("新用户注册赠送 %s", common.LogQuota(common.QuotaForNewUser)))
+	}
+	if inviterId != 0 {
+		if common.QuotaForInvitee > 0 {
+			_ = IncreaseUserQuota(user.Id, common.QuotaForInvitee)
+			RecordLog(user.Id, LogTypeSystem, fmt.Sprintf("使用邀请码赠送 %s", common.LogQuota(common.QuotaForInvitee)))
+		}
+		if common.QuotaForInviter > 0 {
+			_ = IncreaseUserQuota(inviterId, common.QuotaForInviter)
+			RecordLog(inviterId, LogTypeSystem, fmt.Sprintf("邀请用户赠送 %s", common.LogQuota(common.QuotaForInviter)))
+		}
 	}
 	return nil
 }
@@ -196,7 +220,7 @@ func IsAdmin(userId int) bool {
 	var user User
 	err := DB.Where("id = ?", userId).Select("role").Find(&user).Error
 	if err != nil {
-		common.SysError("No such user " + err.Error())
+		common.SysError("no such user " + err.Error())
 		return false
 	}
 	return user.Role >= common.RoleAdminUser
@@ -209,7 +233,7 @@ func IsUserEnabled(userId int) bool {
 	var user User
 	err := DB.Where("id = ?", userId).Select("status").Find(&user).Error
 	if err != nil {
-		common.SysError("No such user " + err.Error())
+		common.SysError("no such user " + err.Error())
 		return false
 	}
 	return user.Status == common.UserStatusEnabled
@@ -232,6 +256,11 @@ func GetUserQuota(id int) (quota int, err error) {
 	return quota, err
 }
 
+func GetUserUsedQuota(id int) (quota int, err error) {
+	err = DB.Model(&User{}).Where("id = ?", id).Select("used_quota").Find(&quota).Error
+	return quota, err
+}
+
 func GetUserEmail(id int) (email string, err error) {
 	err = DB.Model(&User{}).Where("id = ?", id).Select("email").Find(&email).Error
 	return email, err
@@ -262,3 +291,15 @@ func GetRootUserEmail() (email string) {
 	DB.Model(&User{}).Where("role = ?", common.RoleRootUser).Select("email").Find(&email)
 	return email
 }
+
+func UpdateUserUsedQuotaAndRequestCount(id int, quota int) {
+	err := DB.Model(&User{}).Where("id = ?", id).Updates(
+		map[string]interface{}{
+			"used_quota":    gorm.Expr("used_quota + ?", quota),
+			"request_count": gorm.Expr("request_count + ?", 1),
+		},
+	).Error
+	if err != nil {
+		common.SysError("failed to update user used quota and request count: " + err.Error())
+	}
+}

one-api.service

@@ -1,11 +1,16 @@
+# File path: /etc/systemd/system/one-api.service
+# sudo systemctl daemon-reload
+# sudo systemctl start one-api
+# sudo systemctl enable one-api
+# sudo systemctl status one-api
 [Unit]
 Description=One API Service
 After=network.target
 
 [Service]
-User=yourusername                  # 守护进程用户名
+User=ubuntu  # 注意修改用户名
-WorkingDirectory=/path/to/One-API  # One API运行路径
+WorkingDirectory=/path/to/one-api  # 注意修改路径
-ExecStart=/path/to/One-API/one-api --port 3000 --log-dir /path/to/One-API/logs  # 端口
+ExecStart=/path/to/one-api/one-api --port 3000 --log-dir /path/to/one-api/logs  # 注意修改路径和端口号
 Restart=always
 RestartSec=5
 

router/api-router.go

@@ -37,6 +37,7 @@ func SetApiRouter(router *gin.Engine) {
 				selfRoute.PUT("/self", controller.UpdateSelf)
 				selfRoute.DELETE("/self", controller.DeleteSelf)
 				selfRoute.GET("/token", controller.GenerateAccessToken)
+				selfRoute.GET("/aff", controller.GetAffCode)
 				selfRoute.POST("/topup", controller.TopUp)
 			}
 

router/web-router.go

@@ -7,7 +7,9 @@ import (
 	"github.com/gin-gonic/gin"
 	"net/http"
 	"one-api/common"
+	"one-api/controller"
 	"one-api/middleware"
+	"strings"
 )
 
 func SetWebRouter(router *gin.Engine, buildFS embed.FS, indexPage []byte) {
@@ -16,6 +18,10 @@ func SetWebRouter(router *gin.Engine, buildFS embed.FS, indexPage []byte) {
 	router.Use(middleware.Cache())
 	router.Use(static.Serve("/", common.EmbedFolder(buildFS, "web/build")))
 	router.NoRoute(func(c *gin.Context) {
+		if strings.HasPrefix(c.Request.RequestURI, "/v1") {
+			controller.RelayNotFound(c)
+			return
+		}
 		c.Header("Cache-Control", "no-cache")
 		c.Data(http.StatusOK, "text/html; charset=utf-8", indexPage)
 	})

web/public/index.html

@@ -7,7 +7,7 @@
     <meta name="theme-color" content="#ffffff" />
     <meta
       name="description"
-      content="Web site created using create-react-app"
+      content="OpenAI 接口聚合管理，支持多种渠道包括 Azure，可用于二次分发管理 key，仅单可执行文件，已打包好 Docker 镜像，一键部署，开箱即用"
     />
     <title>One API</title>
   </head>

web/src/App.js

@@ -23,6 +23,7 @@ import Redemption from './pages/Redemption';
 import EditRedemption from './pages/Redemption/EditRedemption';
 import TopUp from './pages/TopUp';
 import Log from './pages/Log';
+import Chat from './pages/Chat';
 
 const Home = lazy(() => import('./pages/Home'));
 const About = lazy(() => import('./pages/About'));
@@ -47,6 +48,13 @@ function App() {
       localStorage.setItem('system_name', data.system_name);
       localStorage.setItem('logo', data.logo);
       localStorage.setItem('footer_html', data.footer_html);
+      localStorage.setItem('quota_per_unit', data.quota_per_unit);
+      localStorage.setItem('display_in_currency', data.display_in_currency);
+      if (data.chat_link) {
+        localStorage.setItem('chat_link', data.chat_link);
+      } else {
+        localStorage.removeItem('chat_link');
+      }
       if (
         data.version !== process.env.REACT_APP_VERSION &&
         data.version !== 'v0.0.0' &&
@@ -267,6 +275,14 @@ function App() {
           </Suspense>
         }
       />
+      <Route
+        path='/chat'
+        element={
+          <Suspense fallback={<Loading></Loading>}>
+            <Chat />
+          </Suspense>
+        }
+      />
       <Route path='*' element={NotFound} />
     </Routes>
   );

web/src/components/ChannelsTable.js

@@ -4,7 +4,7 @@ import { Link } from 'react-router-dom';
 import { API, showError, showInfo, showSuccess, timestamp2string } from '../helpers';
 
 import { CHANNEL_OPTIONS, ITEMS_PER_PAGE } from '../constants';
-import { renderGroup } from '../helpers/render';
+import { renderGroup, renderNumber } from '../helpers/render';
 
 function renderTimestamp(timestamp) {
   return (
@@ -28,10 +28,19 @@ function renderType(type) {
 }
 
 function renderBalance(type, balance) {
-  if (type === 5) {
+  switch (type) {
-    return <span>{balance.toFixed(2)}</span>
+    case 1: // OpenAI
+    case 8: // 自定义
+      return <span>${balance.toFixed(2)}</span>;
+    case 5: // OpenAI-SB
+      return <span>¥{(balance / 10000).toFixed(2)}</span>;
+    case 10: // AI Proxy
+      return <span>{renderNumber(balance)}</span>;
+    case 12: // API2GPT
+      return <span>¥{balance.toFixed(2)}</span>;
+    default:
+      return <span>不支持</span>;
   }
-  return <span>${balance.toFixed(2)}</span>
 }
 
 const ChannelsTable = () => {
@@ -229,9 +238,17 @@ const ChannelsTable = () => {
     if (channels.length === 0) return;
     setLoading(true);
     let sortedChannels = [...channels];
-    sortedChannels.sort((a, b) => {
+    if (typeof sortedChannels[0][key] === 'string'){
-      return ('' + a[key]).localeCompare(b[key]);
+      sortedChannels.sort((a, b) => {
-    });
+        return ('' + a[key]).localeCompare(b[key]);
+      });
+    } else {
+      sortedChannels.sort((a, b) => {
+        if (a[key] === b[key]) return 0;
+        if (a[key] > b[key]) return -1;
+        if (a[key] < b[key]) return 1;
+      });
+    }
     if (sortedChannels[0].id === channels[0].id) {
       sortedChannels.reverse();
     }
@@ -246,14 +263,14 @@ const ChannelsTable = () => {
           icon='search'
           fluid
           iconPosition='left'
-          placeholder='搜索渠道的 ID 和名称 ...'
+          placeholder='搜索渠道的 ID，名称和密钥 ...'
           value={searchKeyword}
           loading={searching}
           onChange={handleKeywordChange}
         />
       </Form>
 
-      <Table basic>
+      <Table basic compact size='small'>
         <Table.Header>
           <Table.Row>
             <Table.HeaderCell
@@ -422,7 +439,8 @@ const ChannelsTable = () => {
               <Button size='small' loading={loading} onClick={testAllChannels}>
                 测试所有已启用通道
               </Button>
-              <Button size='small' onClick={updateAllChannelsBalance} loading={loading || updatingBalance}>更新所有已启用通道余额</Button>
+              <Button size='small' onClick={updateAllChannelsBalance}
+                      loading={loading || updatingBalance}>更新所有已启用通道余额</Button>
               <Pagination
                 floated='right'
                 activePage={activePage}

web/src/components/Footer.js

@@ -1,11 +1,31 @@
-import React from 'react';
+import React, { useEffect, useState } from 'react';
 
 import { Container, Segment } from 'semantic-ui-react';
 import { getFooterHTML, getSystemName } from '../helpers';
 
 const Footer = () => {
   const systemName = getSystemName();
-  const footer = getFooterHTML();
+  const [footer, setFooter] = useState(getFooterHTML());
+  let remainCheckTimes = 5;
+
+  const loadFooter = () => {
+    let footer_html = localStorage.getItem('footer_html');
+    if (footer_html) {
+      setFooter(footer_html);
+    }
+  };
+
+  useEffect(() => {
+    const timer = setInterval(() => {
+      if (remainCheckTimes <= 0) {
+        clearInterval(timer);
+        return;
+      }
+      remainCheckTimes--;
+      loadFooter();
+    }, 200);
+    return () => clearTimeout(timer);
+  }, []);
 
   return (
     <Segment vertical>

web/src/components/Header.js

@@ -7,57 +7,65 @@ import { API, getLogo, getSystemName, isAdmin, isMobile, showSuccess } from '../
 import '../index.css';
 
 // Header Buttons
-const headerButtons = [
+let headerButtons = [
   {
     name: '首页',
     to: '/',
-    icon: 'home',
+    icon: 'home'
   },
   {
     name: '渠道',
     to: '/channel',
     icon: 'sitemap',
-    admin: true,
+    admin: true
   },
   {
     name: '令牌',
     to: '/token',
-    icon: 'key',
+    icon: 'key'
   },
   {
     name: '兑换',
     to: '/redemption',
     icon: 'dollar sign',
-    admin: true,
+    admin: true
   },
   {
     name: '充值',
     to: '/topup',
-    icon: 'cart',
+    icon: 'cart'
   },
   {
     name: '用户',
     to: '/user',
     icon: 'user',
-    admin: true,
+    admin: true
   },
   {
     name: '日志',
     to: '/log',
-    icon: 'book',
+    icon: 'book'
   },
   {
     name: '设置',
     to: '/setting',
-    icon: 'setting',
+    icon: 'setting'
   },
   {
     name: '关于',
     to: '/about',
-    icon: 'info circle',
+    icon: 'info circle'
-  },
+  }
 ];
 
+if (localStorage.getItem('chat_link')) {
+  headerButtons.splice(1, 0, {
+    name: '聊天',
+    to: '/chat',
+    icon: 'comments'
+  });
+}
+
 const Header = () => {
   const [userState, userDispatch] = useContext(UserContext);
   let navigate = useNavigate();
@@ -112,11 +120,11 @@ const Header = () => {
           style={
             showSidebar
               ? {
-                  borderBottom: 'none',
+                borderBottom: 'none',
-                  marginBottom: '0',
+                marginBottom: '0',
-                  borderTop: 'none',
+                borderTop: 'none',
-                  height: '51px',
+                height: '51px'
-                }
+              }
               : { borderTop: 'none', height: '52px' }
           }
         >

web/src/components/OperationSetting.js

@@ -0,0 +1,312 @@
+import React, { useEffect, useState } from 'react';
+import { Divider, Form, Grid, Header } from 'semantic-ui-react';
+import { API, showError, verifyJSON } from '../helpers';
+
+const OperationSetting = () => {
+  let [inputs, setInputs] = useState({
+    QuotaForNewUser: 0,
+    QuotaForInviter: 0,
+    QuotaForInvitee: 0,
+    QuotaRemindThreshold: 0,
+    PreConsumedQuota: 0,
+    ModelRatio: '',
+    GroupRatio: '',
+    TopUpLink: '',
+    ChatLink: '',
+    QuotaPerUnit: 0,
+    AutomaticDisableChannelEnabled: '',
+    ChannelDisableThreshold: 0,
+    LogConsumeEnabled: '',
+    DisplayInCurrencyEnabled: '',
+    DisplayTokenStatEnabled: ''
+  });
+  const [originInputs, setOriginInputs] = useState({});
+  let [loading, setLoading] = useState(false);
+
+  const getOptions = async () => {
+    const res = await API.get('/api/option/');
+    const { success, message, data } = res.data;
+    if (success) {
+      let newInputs = {};
+      data.forEach((item) => {
+        if (item.key === 'ModelRatio' || item.key === 'GroupRatio') {
+          item.value = JSON.stringify(JSON.parse(item.value), null, 2);
+        }
+        newInputs[item.key] = item.value;
+      });
+      setInputs(newInputs);
+      setOriginInputs(newInputs);
+    } else {
+      showError(message);
+    }
+  };
+
+  useEffect(() => {
+    getOptions().then();
+  }, []);
+
+  const updateOption = async (key, value) => {
+    setLoading(true);
+    if (key.endsWith('Enabled')) {
+      value = inputs[key] === 'true' ? 'false' : 'true';
+    }
+    const res = await API.put('/api/option/', {
+      key,
+      value
+    });
+    const { success, message } = res.data;
+    if (success) {
+      setInputs((inputs) => ({ ...inputs, [key]: value }));
+    } else {
+      showError(message);
+    }
+    setLoading(false);
+  };
+
+  const handleInputChange = async (e, { name, value }) => {
+    if (name.endsWith('Enabled')) {
+      await updateOption(name, value);
+    } else {
+      setInputs((inputs) => ({ ...inputs, [name]: value }));
+    }
+  };
+
+  const submitConfig = async (group) => {
+    switch (group) {
+      case 'monitor':
+        if (originInputs['AutomaticDisableChannelEnabled'] !== inputs.AutomaticDisableChannelEnabled) {
+          await updateOption('AutomaticDisableChannelEnabled', inputs.AutomaticDisableChannelEnabled);
+        }
+        if (originInputs['ChannelDisableThreshold'] !== inputs.ChannelDisableThreshold) {
+          await updateOption('ChannelDisableThreshold', inputs.ChannelDisableThreshold);
+        }
+        if (originInputs['QuotaRemindThreshold'] !== inputs.QuotaRemindThreshold) {
+          await updateOption('QuotaRemindThreshold', inputs.QuotaRemindThreshold);
+        }
+        break;
+      case 'ratio':
+        if (originInputs['ModelRatio'] !== inputs.ModelRatio) {
+          if (!verifyJSON(inputs.ModelRatio)) {
+            showError('模型倍率不是合法的 JSON 字符串');
+            return;
+          }
+          await updateOption('ModelRatio', inputs.ModelRatio);
+        }
+        if (originInputs['GroupRatio'] !== inputs.GroupRatio) {
+          if (!verifyJSON(inputs.GroupRatio)) {
+            showError('分组倍率不是合法的 JSON 字符串');
+            return;
+          }
+          await updateOption('GroupRatio', inputs.GroupRatio);
+        }
+        break;
+      case 'quota':
+        if (originInputs['QuotaForNewUser'] !== inputs.QuotaForNewUser) {
+          await updateOption('QuotaForNewUser', inputs.QuotaForNewUser);
+        }
+        if (originInputs['QuotaForInvitee'] !== inputs.QuotaForInvitee) {
+          await updateOption('QuotaForInvitee', inputs.QuotaForInvitee);
+        }
+        if (originInputs['QuotaForInviter'] !== inputs.QuotaForInviter) {
+          await updateOption('QuotaForInviter', inputs.QuotaForInviter);
+        }
+        if (originInputs['PreConsumedQuota'] !== inputs.PreConsumedQuota) {
+          await updateOption('PreConsumedQuota', inputs.PreConsumedQuota);
+        }
+        break;
+      case 'general':
+        if (originInputs['TopUpLink'] !== inputs.TopUpLink) {
+          await updateOption('TopUpLink', inputs.TopUpLink);
+        }
+        if (originInputs['ChatLink'] !== inputs.ChatLink) {
+          await updateOption('ChatLink', inputs.ChatLink);
+        }
+        if (originInputs['QuotaPerUnit'] !== inputs.QuotaPerUnit) {
+          await updateOption('QuotaPerUnit', inputs.QuotaPerUnit);
+        }
+        break;
+    }
+  };
+
+  return (
+    <Grid columns={1}>
+      <Grid.Column>
+        <Form loading={loading}>
+          <Header as='h3'>
+            通用设置
+          </Header>
+          <Form.Group widths={3}>
+            <Form.Input
+              label='充值链接'
+              name='TopUpLink'
+              onChange={handleInputChange}
+              autoComplete='new-password'
+              value={inputs.TopUpLink}
+              type='link'
+              placeholder='例如发卡网站的购买链接'
+            />
+            <Form.Input
+              label='聊天页面链接'
+              name='ChatLink'
+              onChange={handleInputChange}
+              autoComplete='new-password'
+              value={inputs.ChatLink}
+              type='link'
+              placeholder='例如 ChatGPT Next Web 的部署地址'
+            />
+            <Form.Input
+              label='单位美元额度'
+              name='QuotaPerUnit'
+              onChange={handleInputChange}
+              autoComplete='new-password'
+              value={inputs.QuotaPerUnit}
+              type='number'
+              step='0.01'
+              placeholder='一单位货币能兑换的额度'
+            />
+          </Form.Group>
+          <Form.Group inline>
+            <Form.Checkbox
+              checked={inputs.LogConsumeEnabled === 'true'}
+              label='启用额度消费日志记录'
+              name='LogConsumeEnabled'
+              onChange={handleInputChange}
+            />
+            <Form.Checkbox
+              checked={inputs.DisplayInCurrencyEnabled === 'true'}
+              label='以货币形式显示额度'
+              name='DisplayInCurrencyEnabled'
+              onChange={handleInputChange}
+            />
+            <Form.Checkbox
+              checked={inputs.DisplayTokenStatEnabled === 'true'}
+              label='Billing 相关 API 显示令牌额度而非用户额度'
+              name='DisplayTokenStatEnabled'
+              onChange={handleInputChange}
+            />
+          </Form.Group>
+          <Form.Button onClick={() => {
+            submitConfig('general').then();
+          }}>保存通用设置</Form.Button>
+          <Divider />
+          <Header as='h3'>
+            监控设置
+          </Header>
+          <Form.Group widths={3}>
+            <Form.Input
+              label='最长响应时间'
+              name='ChannelDisableThreshold'
+              onChange={handleInputChange}
+              autoComplete='new-password'
+              value={inputs.ChannelDisableThreshold}
+              type='number'
+              min='0'
+              placeholder='单位秒，当运行通道全部测试时，超过此时间将自动禁用通道'
+            />
+            <Form.Input
+              label='额度提醒阈值'
+              name='QuotaRemindThreshold'
+              onChange={handleInputChange}
+              autoComplete='new-password'
+              value={inputs.QuotaRemindThreshold}
+              type='number'
+              min='0'
+              placeholder='低于此额度时将发送邮件提醒用户'
+            />
+          </Form.Group>
+          <Form.Group inline>
+            <Form.Checkbox
+              checked={inputs.AutomaticDisableChannelEnabled === 'true'}
+              label='失败时自动禁用通道'
+              name='AutomaticDisableChannelEnabled'
+              onChange={handleInputChange}
+            />
+          </Form.Group>
+          <Form.Button onClick={() => {
+            submitConfig('monitor').then();
+          }}>保存监控设置</Form.Button>
+          <Divider />
+          <Header as='h3'>
+            额度设置
+          </Header>
+          <Form.Group widths={4}>
+            <Form.Input
+              label='新用户初始额度'
+              name='QuotaForNewUser'
+              onChange={handleInputChange}
+              autoComplete='new-password'
+              value={inputs.QuotaForNewUser}
+              type='number'
+              min='0'
+              placeholder='例如：100'
+            />
+            <Form.Input
+              label='请求预扣费额度'
+              name='PreConsumedQuota'
+              onChange={handleInputChange}
+              autoComplete='new-password'
+              value={inputs.PreConsumedQuota}
+              type='number'
+              min='0'
+              placeholder='请求结束后多退少补'
+            />
+            <Form.Input
+              label='邀请新用户奖励额度'
+              name='QuotaForInviter'
+              onChange={handleInputChange}
+              autoComplete='new-password'
+              value={inputs.QuotaForInviter}
+              type='number'
+              min='0'
+              placeholder='例如：2000'
+            />
+            <Form.Input
+              label='新用户使用邀请码奖励额度'
+              name='QuotaForInvitee'
+              onChange={handleInputChange}
+              autoComplete='new-password'
+              value={inputs.QuotaForInvitee}
+              type='number'
+              min='0'
+              placeholder='例如：1000'
+            />
+          </Form.Group>
+          <Form.Button onClick={() => {
+            submitConfig('quota').then();
+          }}>保存额度设置</Form.Button>
+          <Divider />
+          <Header as='h3'>
+            倍率设置
+          </Header>
+          <Form.Group widths='equal'>
+            <Form.TextArea
+              label='模型倍率'
+              name='ModelRatio'
+              onChange={handleInputChange}
+              style={{ minHeight: 250, fontFamily: 'JetBrains Mono, Consolas' }}
+              autoComplete='new-password'
+              value={inputs.ModelRatio}
+              placeholder='为一个 JSON 文本，键为模型名称，值为倍率'
+            />
+          </Form.Group>
+          <Form.Group widths='equal'>
+            <Form.TextArea
+              label='分组倍率'
+              name='GroupRatio'
+              onChange={handleInputChange}
+              style={{ minHeight: 250, fontFamily: 'JetBrains Mono, Consolas' }}
+              autoComplete='new-password'
+              value={inputs.GroupRatio}
+              placeholder='为一个 JSON 文本，键为分组名称，值为倍率'
+            />
+          </Form.Group>
+          <Form.Button onClick={() => {
+            submitConfig('ratio').then();
+          }}>保存倍率设置</Form.Button>
+        </Form>
+      </Grid.Column>
+    </Grid>
+  );
+};
+
+export default OperationSetting;

web/src/components/OtherSetting.js

@@ -1,5 +1,5 @@
 import React, { useEffect, useState } from 'react';
-import { Button, Divider, Form, Grid, Header, Modal } from 'semantic-ui-react';
+import { Button, Divider, Form, Grid, Header, Message, Modal } from 'semantic-ui-react';
 import { API, showError, showSuccess } from '../helpers';
 import { marked } from 'marked';
 
@@ -10,13 +10,13 @@ const OtherSetting = () => {
     About: '',
     SystemName: '',
     Logo: '',
-    HomePageContent: '',
+    HomePageContent: ''
   });
   let [loading, setLoading] = useState(false);
   const [showUpdateModal, setShowUpdateModal] = useState(false);
   const [updateData, setUpdateData] = useState({
     tag_name: '',
-    content: '',
+    content: ''
   });
 
   const getOptions = async () => {
@@ -43,7 +43,7 @@ const OtherSetting = () => {
     setLoading(true);
     const res = await API.put('/api/option/', {
       key,
-      value,
+      value
     });
     const { success, message } = res.data;
     if (success) {
@@ -97,7 +97,7 @@ const OtherSetting = () => {
     } else {
       setUpdateData({
         tag_name: tag_name,
-        content: marked.parse(body),
+        content: marked.parse(body)
       });
       setShowUpdateModal(true);
     }
@@ -153,7 +153,7 @@ const OtherSetting = () => {
               style={{ minHeight: 150, fontFamily: 'JetBrains Mono, Consolas' }}
             />
           </Form.Group>
-          <Form.Button onClick={()=>submitOption('HomePageContent')}>保存首页内容</Form.Button>
+          <Form.Button onClick={() => submitOption('HomePageContent')}>保存首页内容</Form.Button>
           <Form.Group widths='equal'>
             <Form.TextArea
               label='关于'
@@ -165,6 +165,7 @@ const OtherSetting = () => {
             />
           </Form.Group>
           <Form.Button onClick={submitAbout}>保存关于</Form.Button>
+          <Message>移除 One API 的版权标识必须首先获得授权，项目维护需要花费大量精力，如果本项目对你有意义，请主动支持本项目。</Message>
           <Form.Group widths='equal'>
             <Form.Input
               label='页脚'

web/src/components/PasswordResetConfirm.js

@@ -1,6 +1,6 @@
 import React, { useEffect, useState } from 'react';
 import { Button, Form, Grid, Header, Image, Segment } from 'semantic-ui-react';
-import { API, copy, showError, showSuccess } from '../helpers';
+import { API, copy, showError, showInfo, showNotice, showSuccess } from '../helpers';
 import { useSearchParams } from 'react-router-dom';
 
 const PasswordResetConfirm = () => {
@@ -33,7 +33,7 @@ const PasswordResetConfirm = () => {
     if (success) {
       let password = res.data.data;
       await copy(password);
-      showSuccess(`密码已重置并已复制到剪贴板：${password}`);
+      showNotice(`密码已重置并已复制到剪贴板：${password}`);
     } else {
       showError(message);
     }

web/src/components/PersonalSetting.js

@@ -1,7 +1,7 @@
 import React, { useEffect, useState } from 'react';
 import { Button, Divider, Form, Header, Image, Message, Modal } from 'semantic-ui-react';
 import { Link } from 'react-router-dom';
-import { API, copy, showError, showInfo, showSuccess } from '../helpers';
+import { API, copy, showError, showInfo, showNotice, showSuccess } from '../helpers';
 import Turnstile from 'react-turnstile';
 
 const PersonalSetting = () => {
@@ -45,6 +45,18 @@ const PersonalSetting = () => {
     }
   };
 
+  const getAffLink = async () => {
+    const res = await API.get('/api/user/aff');
+    const { success, message, data } = res.data;
+    if (success) {
+      let link = `${window.location.origin}/register?aff=${data}`;
+      await copy(link);
+      showNotice(`邀请链接已复制到剪切板：${link}`);
+    } else {
+      showError(message);
+    }
+  };
+
   const bindWeChat = async () => {
     if (inputs.wechat_verification_code === '') return;
     const res = await API.get(
@@ -110,6 +122,7 @@ const PersonalSetting = () => {
         更新个人信息
       </Button>
       <Button onClick={generateAccessToken}>生成系统访问令牌</Button>
+      <Button onClick={getAffLink}>复制邀请链接</Button>
       <Divider />
       <Header as='h3'>账号绑定</Header>
       {

web/src/components/RedemptionsTable.js

@@ -4,6 +4,7 @@ import { Link } from 'react-router-dom';
 import { API, copy, showError, showInfo, showSuccess, showWarning, timestamp2string } from '../helpers';
 
 import { ITEMS_PER_PAGE } from '../constants';
+import { renderQuota } from '../helpers/render';
 
 function renderTimestamp(timestamp) {
   return (
@@ -152,7 +153,7 @@ const RedemptionsTable = () => {
         />
       </Form>
 
-      <Table basic>
+      <Table basic compact size='small'>
         <Table.Header>
           <Table.Row>
             <Table.HeaderCell
@@ -220,7 +221,7 @@ const RedemptionsTable = () => {
                   <Table.Cell>{redemption.id}</Table.Cell>
                   <Table.Cell>{redemption.name ? redemption.name : '无'}</Table.Cell>
                   <Table.Cell>{renderStatus(redemption.status)}</Table.Cell>
-                  <Table.Cell>{redemption.quota}</Table.Cell>
+                  <Table.Cell>{renderQuota(redemption.quota)}</Table.Cell>
                   <Table.Cell>{renderTimestamp(redemption.created_time)}</Table.Cell>
                   <Table.Cell>{redemption.redeemed_time ? renderTimestamp(redemption.redeemed_time) : "尚未兑换"} </Table.Cell>
                   <Table.Cell>

web/src/components/RegisterForm.js

@@ -27,6 +27,10 @@ const RegisterForm = () => {
   const [turnstileToken, setTurnstileToken] = useState('');
   const [loading, setLoading] = useState(false);
   const logo = getLogo();
+  let affCode = new URLSearchParams(window.location.search).get('aff');
+  if (affCode) {
+    localStorage.setItem('aff', affCode);
+  }
 
   useEffect(() => {
     let status = localStorage.getItem('status');
@@ -63,6 +67,10 @@ const RegisterForm = () => {
         return;
       }
       setLoading(true);
+      if (!affCode) {
+        affCode = localStorage.getItem('aff');
+      }
+      inputs.aff_code = affCode;
       const res = await API.post(
         `/api/user/register?turnstile=${turnstileToken}`,
         inputs

web/src/components/SystemSetting.js

@@ -26,14 +26,6 @@ const SystemSetting = () => {
     TurnstileSiteKey: '',
     TurnstileSecretKey: '',
     RegisterEnabled: '',
-    QuotaForNewUser: 0,
-    QuotaRemindThreshold: 0,
-    PreConsumedQuota: 0,
-    ModelRatio: '',
-    GroupRatio: '',
-    TopUpLink: '',
-    AutomaticDisableChannelEnabled: '',
-    ChannelDisableThreshold: 0,
   });
   const [originInputs, setOriginInputs] = useState({});
   let [loading, setLoading] = useState(false);
@@ -67,7 +59,6 @@ const SystemSetting = () => {
       case 'WeChatAuthEnabled':
       case 'TurnstileCheckEnabled':
       case 'RegisterEnabled':
-      case 'AutomaticDisableChannelEnabled':
         value = inputs[key] === 'true' ? 'false' : 'true';
         break;
       default:
@@ -97,13 +88,7 @@ const SystemSetting = () => {
       name === 'WeChatServerToken' ||
       name === 'WeChatAccountQRCodeImageURL' ||
       name === 'TurnstileSiteKey' ||
-      name === 'TurnstileSecretKey' ||
+      name === 'TurnstileSecretKey'
-      name === 'QuotaForNewUser' ||
-      name === 'QuotaRemindThreshold' ||
-      name === 'PreConsumedQuota' ||
-      name === 'ModelRatio' ||
-      name === 'GroupRatio' ||
-      name === 'TopUpLink'
     ) {
       setInputs((inputs) => ({ ...inputs, [name]: value }));
     } else {
@@ -116,35 +101,6 @@ const SystemSetting = () => {
     await updateOption('ServerAddress', ServerAddress);
   };
 
-  const submitOperationConfig = async () => {
-    if (originInputs['QuotaForNewUser'] !== inputs.QuotaForNewUser) {
-      await updateOption('QuotaForNewUser', inputs.QuotaForNewUser);
-    }
-    if (originInputs['QuotaRemindThreshold'] !== inputs.QuotaRemindThreshold) {
-      await updateOption('QuotaRemindThreshold', inputs.QuotaRemindThreshold);
-    }
-    if (originInputs['PreConsumedQuota'] !== inputs.PreConsumedQuota) {
-      await updateOption('PreConsumedQuota', inputs.PreConsumedQuota);
-    }
-    if (originInputs['ModelRatio'] !== inputs.ModelRatio) {
-      if (!verifyJSON(inputs.ModelRatio)) {
-        showError('模型倍率不是合法的 JSON 字符串');
-        return;
-      }
-      await updateOption('ModelRatio', inputs.ModelRatio);
-    }
-    if (originInputs['GroupRatio'] !== inputs.GroupRatio) {
-      if (!verifyJSON(inputs.GroupRatio)) {
-        showError('分组倍率不是合法的 JSON 字符串');
-        return;
-      }
-      await updateOption('GroupRatio', inputs.GroupRatio);
-    }
-    if (originInputs['TopUpLink'] !== inputs.TopUpLink) {
-      await updateOption('TopUpLink', inputs.TopUpLink);
-    }
-  };
-
   const submitSMTP = async () => {
     if (originInputs['SMTPServer'] !== inputs.SMTPServer) {
       await updateOption('SMTPServer', inputs.SMTPServer);
@@ -283,98 +239,6 @@ const SystemSetting = () => {
             />
           </Form.Group>
           <Divider />
-          <Header as='h3'>
-            运营设置
-          </Header>
-          <Form.Group widths={4}>
-            <Form.Input
-              label='新用户初始配额'
-              name='QuotaForNewUser'
-              onChange={handleInputChange}
-              autoComplete='new-password'
-              value={inputs.QuotaForNewUser}
-              type='number'
-              min='0'
-              placeholder='例如：100'
-            />
-            <Form.Input
-              label='充值链接'
-              name='TopUpLink'
-              onChange={handleInputChange}
-              autoComplete='new-password'
-              value={inputs.TopUpLink}
-              type='link'
-              placeholder='例如发卡网站的购买链接'
-            />
-            <Form.Input
-              label='额度提醒阈值'
-              name='QuotaRemindThreshold'
-              onChange={handleInputChange}
-              autoComplete='new-password'
-              value={inputs.QuotaRemindThreshold}
-              type='number'
-              min='0'
-              placeholder='低于此额度时将发送邮件提醒用户'
-            />
-            <Form.Input
-              label='请求预扣费额度'
-              name='PreConsumedQuota'
-              onChange={handleInputChange}
-              autoComplete='new-password'
-              value={inputs.PreConsumedQuota}
-              type='number'
-              min='0'
-              placeholder='请求结束后多退少补'
-            />
-          </Form.Group>
-          <Form.Group widths='equal'>
-            <Form.TextArea
-              label='模型倍率'
-              name='ModelRatio'
-              onChange={handleInputChange}
-              style={{ minHeight: 250, fontFamily: 'JetBrains Mono, Consolas' }}
-              autoComplete='new-password'
-              value={inputs.ModelRatio}
-              placeholder='为一个 JSON 文本，键为模型名称，值为倍率'
-            />
-          </Form.Group>
-          <Form.Group widths='equal'>
-            <Form.TextArea
-              label='分组倍率'
-              name='GroupRatio'
-              onChange={handleInputChange}
-              style={{ minHeight: 250, fontFamily: 'JetBrains Mono, Consolas' }}
-              autoComplete='new-password'
-              value={inputs.GroupRatio}
-              placeholder='为一个 JSON 文本，键为分组名称，值为倍率'
-            />
-          </Form.Group>
-          <Form.Button onClick={submitOperationConfig}>保存运营设置</Form.Button>
-          <Divider />
-          <Header as='h3'>
-            监控设置
-          </Header>
-          <Form.Group widths={3}>
-            <Form.Input
-              label='最长响应时间'
-              name='ChannelDisableThreshold'
-              onChange={handleInputChange}
-              autoComplete='new-password'
-              value={inputs.ChannelDisableThreshold}
-              type='number'
-              min='0'
-              placeholder='单位秒，当运行通道全部测试时，超过此时间将自动禁用通道'
-            />
-          </Form.Group>
-          <Form.Group inline>
-            <Form.Checkbox
-              checked={inputs.AutomaticDisableChannelEnabled === 'true'}
-              label='失败时自动禁用通道'
-              name='AutomaticDisableChannelEnabled'
-              onChange={handleInputChange}
-            />
-          </Form.Group>
-          <Divider />
           <Header as='h3'>
             配置 SMTP
             <Header.Subheader>用以支持系统的邮件发送</Header.Subheader>

web/src/components/TokensTable.js

@@ -4,6 +4,7 @@ import { Link } from 'react-router-dom';
 import { API, copy, showError, showSuccess, showWarning, timestamp2string } from '../helpers';
 
 import { ITEMS_PER_PAGE } from '../constants';
+import { renderQuota } from '../helpers/render';
 
 function renderTimestamp(timestamp) {
   return (
@@ -154,24 +155,16 @@ const TokensTable = () => {
           icon='search'
           fluid
           iconPosition='left'
-          placeholder='搜索令牌的 ID 和名称 ...'
+          placeholder='搜索令牌的名称 ...'
           value={searchKeyword}
           loading={searching}
           onChange={handleKeywordChange}
         />
       </Form>
 
-      <Table basic>
+      <Table basic compact size='small'>
         <Table.Header>
           <Table.Row>
-            <Table.HeaderCell
-              style={{ cursor: 'pointer' }}
-              onClick={() => {
-                sortToken('id');
-              }}
-            >
-              ID
-            </Table.HeaderCell>
             <Table.HeaderCell
               style={{ cursor: 'pointer' }}
               onClick={() => {
@@ -188,13 +181,21 @@ const TokensTable = () => {
             >
               状态
             </Table.HeaderCell>
+            <Table.HeaderCell
+              style={{ cursor: 'pointer' }}
+              onClick={() => {
+                sortToken('used_quota');
+              }}
+            >
+              已用额度
+            </Table.HeaderCell>
             <Table.HeaderCell
               style={{ cursor: 'pointer' }}
               onClick={() => {
                 sortToken('remain_quota');
               }}
             >
-              额度
+              剩余额度
             </Table.HeaderCell>
             <Table.HeaderCell
               style={{ cursor: 'pointer' }}
@@ -226,10 +227,10 @@ const TokensTable = () => {
               if (token.deleted) return <></>;
               return (
                 <Table.Row key={token.id}>
-                  <Table.Cell>{token.id}</Table.Cell>
                   <Table.Cell>{token.name ? token.name : '无'}</Table.Cell>
                   <Table.Cell>{renderStatus(token.status)}</Table.Cell>
-                  <Table.Cell>{token.unlimited_quota ? '无限制' : token.remain_quota}</Table.Cell>
+                  <Table.Cell>{renderQuota(token.used_quota)}</Table.Cell>
+                  <Table.Cell>{token.unlimited_quota ? '无限制' : renderQuota(token.remain_quota, 2)}</Table.Cell>
                   <Table.Cell>{renderTimestamp(token.created_time)}</Table.Cell>
                   <Table.Cell>{token.expired_time === -1 ? '永不过期' : renderTimestamp(token.expired_time)}</Table.Cell>
                   <Table.Cell>
@@ -296,7 +297,7 @@ const TokensTable = () => {
 
         <Table.Footer>
           <Table.Row>
-            <Table.HeaderCell colSpan='8'>
+            <Table.HeaderCell colSpan='7'>
               <Button size='small' as={Link} to='/token/add' loading={loading}>
                 添加新的令牌
               </Button>

web/src/components/UsersTable.js

@@ -4,7 +4,7 @@ import { Link } from 'react-router-dom';
 import { API, showError, showSuccess } from '../helpers';
 
 import { ITEMS_PER_PAGE } from '../constants';
-import { renderGroup, renderText } from '../helpers/render';
+import { renderGroup, renderNumber, renderQuota, renderText } from '../helpers/render';
 
 function renderRole(role) {
   switch (role) {
@@ -156,7 +156,7 @@ const UsersTable = () => {
         />
       </Form>
 
-      <Table basic>
+      <Table basic compact size='small'>
         <Table.Header>
           <Table.Row>
             <Table.HeaderCell
@@ -197,7 +197,7 @@ const UsersTable = () => {
                 sortUser('quota');
               }}
             >
-              剩余额度
+              统计信息
             </Table.HeaderCell>
             <Table.HeaderCell
               style={{ cursor: 'pointer' }}
@@ -240,8 +240,14 @@ const UsersTable = () => {
                     />
                   </Table.Cell>
                   <Table.Cell>{renderGroup(user.group)}</Table.Cell>
-                  <Table.Cell>{user.email ? renderText(user.email, 30) : '无'}</Table.Cell>
+                  <Table.Cell>
-                  <Table.Cell>{user.quota}</Table.Cell>
+                    {user.email ? <Popup hoverable content={user.email} trigger={<span>{renderText(user.email, 24)}</span>} /> : '无'}
+                  </Table.Cell>
+                  <Table.Cell>
+                    <Popup content='剩余额度' trigger={<Label>{renderQuota(user.quota)}</Label>} />
+                    <Popup content='已用额度' trigger={<Label>{renderQuota(user.used_quota)}</Label>} />
+                    <Popup content='请求次数' trigger={<Label>{renderNumber(user.request_count)}</Label>} />
+                  </Table.Cell>
                   <Table.Cell>{renderRole(user.role)}</Table.Cell>
                   <Table.Cell>{renderStatus(user.status)}</Table.Cell>
                   <Table.Cell>

web/src/constants/channel.constants.js

@@ -8,5 +8,6 @@ export const CHANNEL_OPTIONS = [
   { key: 6, text: 'OpenAI Max', value: 6, color: 'violet' },
   { key: 7, text: 'OhMyGPT', value: 7, color: 'purple' },
   { key: 9, text: 'AI.LS', value: 9, color: 'yellow' },
-  { key: 10, text: 'AI Proxy', value: 10, color: 'purple' }
+  { key: 10, text: 'AI Proxy', value: 10, color: 'purple' },
+  { key: 12, text: 'API2GPT', value: 12, color: 'blue' }
 ];

web/src/helpers/render.js

@@ -8,12 +8,51 @@ export function renderText(text, limit) {
 }
 
 export function renderGroup(group) {
-  if (group === "") {
+  if (group === '') {
-    return <Label>default</Label>
+    return <Label>default</Label>;
-  } else if (group === "vip" || group === "pro") {
-    return <Label color='yellow'>{group}</Label>
-  } else if (group === "svip" || group === "premium") {
-    return <Label color='red'>{group}</Label>
   }
-  return <Label>{group}</Label>
+  let groups = group.split(',');
+  groups.sort();
+  return <>
+    {groups.map((group) => {
+      if (group === 'vip' || group === 'pro') {
+        return <Label color='yellow'>{group}</Label>;
+      } else if (group === 'svip' || group === 'premium') {
+        return <Label color='red'>{group}</Label>;
+      }
+      return <Label>{group}</Label>;
+    })}
+  </>;
+}
+
+export function renderNumber(num) {
+  if (num >= 1000000000) {
+    return (num / 1000000000).toFixed(1) + 'B';
+  } else if (num >= 1000000) {
+    return (num / 1000000).toFixed(1) + 'M';
+  } else if (num >= 10000) {
+    return (num / 1000).toFixed(1) + 'k';
+  } else {
+    return num;
+  }
+}
+
+export function renderQuota(quota, digits = 2) {
+  let quotaPerUnit = localStorage.getItem('quota_per_unit');
+  let displayInCurrency = localStorage.getItem('display_in_currency');
+  quotaPerUnit = parseFloat(quotaPerUnit);
+  displayInCurrency = displayInCurrency === 'true';
+  if (displayInCurrency) {
+    return '$' + (quota / quotaPerUnit).toFixed(digits);
+  }
+  return renderNumber(quota);
+}
+
+export function renderQuotaWithPrompt(quota, digits) {
+  let displayInCurrency = localStorage.getItem('display_in_currency');
+  displayInCurrency = displayInCurrency === 'true';
+  if (displayInCurrency) {
+    return `（等价金额：${renderQuota(quota, digits)}）`;
+  }
+  return '';
 }

web/src/pages/Channel/EditChannel.js

@@ -15,8 +15,8 @@ const EditChannel = () => {
     key: '',
     base_url: '',
     other: '',
-    group: 'default',
     models: [],
+    groups: ['default']
   };
   const [batch, setBatch] = useState(false);
   const [inputs, setInputs] = useState(originInputs);
@@ -32,10 +32,15 @@ const EditChannel = () => {
     let res = await API.get(`/api/channel/${channelId}`);
     const { success, message, data } = res.data;
     if (success) {
-      if (data.models === "") {
+      if (data.models === '') {
-        data.models = []
+        data.models = [];
       } else {
-        data.models = data.models.split(",")
+        data.models = data.models.split(',');
+      }
+      if (data.group === '') {
+        data.groups = [];
+      } else {
+        data.groups = data.group.split(',');
       }
       setInputs(data);
     } else {
@@ -50,10 +55,10 @@ const EditChannel = () => {
       setModelOptions(res.data.data.map((model) => ({
         key: model.id,
         text: model.id,
-        value: model.id,
+        value: model.id
       })));
       setFullModels(res.data.data.map((model) => model.id));
-      setBasicModels(res.data.data.filter((model) => !model.id.startsWith("gpt-4")).map((model) => model.id));
+      setBasicModels(res.data.data.filter((model) => !model.id.startsWith('gpt-4')).map((model) => model.id));
     } catch (error) {
       showError(error.message);
     }
@@ -65,7 +70,7 @@ const EditChannel = () => {
       setGroupOptions(res.data.data.map((group) => ({
         key: group,
         text: group,
-        value: group,
+        value: group
       })));
     } catch (error) {
       showError(error.message);
@@ -85,6 +90,10 @@ const EditChannel = () => {
       showInfo('请填写渠道名称和渠道密钥！');
       return;
     }
+    if (inputs.models.length === 0) {
+      showInfo('请至少选择一个模型！');
+      return;
+    }
     let localInputs = inputs;
     if (localInputs.base_url.endsWith('/')) {
       localInputs.base_url = localInputs.base_url.slice(0, localInputs.base_url.length - 1);
@@ -93,7 +102,8 @@ const EditChannel = () => {
       localInputs.other = '2023-03-15-preview';
     }
     let res;
-    localInputs.models = localInputs.models.join(",")
+    localInputs.models = localInputs.models.join(',');
+    localInputs.group = localInputs.groups.join(',');
     if (isEdit) {
       res = await API.put(`/api/channel/`, { ...localInputs, id: parseInt(channelId) });
     } else {
@@ -171,6 +181,20 @@ const EditChannel = () => {
               </Form.Field>
             )
           }
+          {
+            inputs.type !== 3 && inputs.type !== 8 && (
+              <Form.Field>
+                <Form.Input
+                  label='镜像'
+                  name='base_url'
+                  placeholder={'请输入镜像站地址，格式为：https://domain.com，可不填，不填则使用渠道默认值'}
+                  onChange={handleInputChange}
+                  value={inputs.base_url}
+                  autoComplete='new-password'
+                />
+              </Form.Field>
+            )
+          }
           <Form.Field>
             <Form.Input
               label='名称'
@@ -185,14 +209,14 @@ const EditChannel = () => {
             <Form.Dropdown
               label='分组'
               placeholder={'请选择分组'}
-              name='group'
+              name='groups'
               fluid
-              search
+              multiple
               selection
               allowAdditions
               additionLabel={'请在系统设置页面编辑分组倍率以添加新的分组：'}
               onChange={handleInputChange}
-              value={inputs.group}
+              value={inputs.groups}
               autoComplete='new-password'
               options={groupOptions}
             />
@@ -211,28 +235,17 @@ const EditChannel = () => {
               options={modelOptions}
             />
           </Form.Field>
-          <div style={{ lineHeight: '40px', marginBottom: '12px'}}>
+          <div style={{ lineHeight: '40px', marginBottom: '12px' }}>
             <Button type={'button'} onClick={() => {
               handleInputChange(null, { name: 'models', value: basicModels });
             }}>填入基础模型</Button>
             <Button type={'button'} onClick={() => {
               handleInputChange(null, { name: 'models', value: fullModels });
             }}>填入所有模型</Button>
+            <Button type={'button'} onClick={() => {
+              handleInputChange(null, { name: 'models', value: [] });
+            }}>清除所有模型</Button>
           </div>
-          {
-            inputs.type === 1 && (
-              <Form.Field>
-                <Form.Input
-                  label='代理'
-                  name='base_url'
-                  placeholder={'请输入 OpenAI API 代理地址，如果不需要请留空，格式为：https://api.openai.com'}
-                  onChange={handleInputChange}
-                  value={inputs.base_url}
-                  autoComplete='new-password'
-                />
-              </Form.Field>
-            )
-          }
           {
             batch ? <Form.Field>
               <Form.TextArea

web/src/pages/Chat/index.js

@@ -0,0 +1,15 @@
+import React from 'react';
+
+const Chat = () => {
+  const chatLink = localStorage.getItem('chat_link');
+
+  return (
+    <iframe
+      src={chatLink}
+      style={{ width: '100%', height: '85vh', border: 'none' }}
+    />
+  );
+};
+
+
+export default Chat;

web/src/pages/Redemption/EditRedemption.js

@@ -2,6 +2,7 @@ import React, { useEffect, useState } from 'react';
 import { Button, Form, Header, Segment } from 'semantic-ui-react';
 import { useParams } from 'react-router-dom';
 import { API, downloadTextAsFile, showError, showSuccess } from '../../helpers';
+import { renderQuota, renderQuotaWithPrompt } from '../../helpers/render';
 
 const EditRedemption = () => {
   const params = useParams();
@@ -10,7 +11,7 @@ const EditRedemption = () => {
   const [loading, setLoading] = useState(isEdit);
   const originInputs = {
     name: '',
-    quota: 100,
+    quota: 100000,
     count: 1
   };
   const [inputs, setInputs] = useState(originInputs);
@@ -87,7 +88,7 @@ const EditRedemption = () => {
           </Form.Field>
           <Form.Field>
             <Form.Input
-              label='额度'
+              label={`额度${renderQuotaWithPrompt(quota)}`}
               name='quota'
               placeholder={'请输入单个兑换码中包含的额度'}
               onChange={handleInputChange}

web/src/pages/Setting/index.js

@@ -4,6 +4,7 @@ import SystemSetting from '../../components/SystemSetting';
 import { isRoot } from '../../helpers';
 import OtherSetting from '../../components/OtherSetting';
 import PersonalSetting from '../../components/PersonalSetting';
+import OperationSetting from '../../components/OperationSetting';
 
 const Setting = () => {
   let panes = [
@@ -18,6 +19,14 @@ const Setting = () => {
   ];
 
   if (isRoot()) {
+    panes.push({
+      menuItem: '运营设置',
+      render: () => (
+        <Tab.Pane attached={false}>
+          <OperationSetting />
+        </Tab.Pane>
+      )
+    });
     panes.push({
       menuItem: '系统设置',
       render: () => (

web/src/pages/Token/EditToken.js

@@ -2,6 +2,7 @@ import React, { useEffect, useState } from 'react';
 import { Button, Form, Header, Message, Segment } from 'semantic-ui-react';
 import { useParams } from 'react-router-dom';
 import { API, showError, showSuccess, timestamp2string } from '../../helpers';
+import { renderQuota, renderQuotaWithPrompt } from '../../helpers/render';
 
 const EditToken = () => {
   const params = useParams();
@@ -137,7 +138,7 @@ const EditToken = () => {
           <Message>注意，令牌的额度仅用于限制令牌本身的最大额度使用量，实际的使用受到账户的剩余额度限制。</Message>
           <Form.Field>
             <Form.Input
-              label='额度'
+              label={`额度${renderQuotaWithPrompt(remain_quota)}`}
               name='remain_quota'
               placeholder={'请输入额度'}
               onChange={handleInputChange}

web/src/pages/TopUp/index.js

@@ -1,6 +1,7 @@
 import React, { useEffect, useState } from 'react';
 import { Button, Form, Grid, Header, Segment, Statistic } from 'semantic-ui-react';
 import { API, showError, showInfo, showSuccess } from '../../helpers';
+import { renderQuota } from '../../helpers/render';
 
 const TopUp = () => {
   const [redemptionCode, setRedemptionCode] = useState('');
@@ -81,7 +82,7 @@ const TopUp = () => {
         <Grid.Column>
           <Statistic.Group widths='one'>
             <Statistic>
-              <Statistic.Value>{userQuota.toLocaleString()}</Statistic.Value>
+              <Statistic.Value>{renderQuota(userQuota)}</Statistic.Value>
               <Statistic.Label>剩余额度</Statistic.Label>
             </Statistic>
           </Statistic.Group>