fix: remove tqdm dependency

* Update time_test.sh to fix the params

修复测试脚本入参问题

* Update time_test.sh to fix the params

.github/workflows/docker-image-amd64-en.yml

@@ -0,0 +1,57 @@
+name: Publish Docker image (amd64)
+
+on:
+  push:
+    tags:
+      - '*'
+  workflow_dispatch:
+    inputs:
+      name:
+        description: 'reason'
+        required: false
+jobs:
+  push_to_registries:
+    name: Push Docker image to multiple registries
+    runs-on: ubuntu-latest
+    permissions:
+      packages: write
+      contents: read
+    steps:
+      - name: Check out the repo
+        uses: actions/checkout@v3
+
+      - name: Save version info
+        run: |
+          git describe --tags > VERSION 
+
+      - name: Translate
+        run: |
+          python ./i18n/translate.py --repository_path . --json_file_path ./i18n/en.json
+      - name: Log in to Docker Hub
+        uses: docker/login-action@v2
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Log in to the Container registry
+        uses: docker/login-action@v2
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Extract metadata (tags, labels) for Docker
+        id: meta
+        uses: docker/metadata-action@v4
+        with:
+          images: |
+            justsong/one-api-en
+            ghcr.io/one-api-en
+
+      - name: Build and push Docker images
+        uses: docker/build-push-action@v3
+        with:
+          context: .
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}

.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

@@ -41,6 +41,8 @@ _✨ All in one 的 OpenAI 接口，整合各种 API 访问方式，开箱即用
   ·
   <a href="https://github.com/songquanpeng/one-api#常见问题">常见问题</a>
   ·
+  <a href="https://github.com/songquanpeng/one-api#相关项目">相关项目</a>
+  ·
   <a href="https://iamazing.cn/page/reward">赞赏支持</a>
 </p>
 
@@ -52,10 +54,10 @@ _✨ 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] [OpenAI-SB](https://openai-sb.com)
    + [x] [API2GPT](http://console.api2gpt.com/m/00002S)
    + [x] [CloseAI](https://console.closeai-asia.com/r/2412)
    + [x] [AI.LS](https://ai.ls)
@@ -70,21 +72,23 @@ _✨ All in one 的 OpenAI 接口，整合各种 API 访问方式，开箱即用
 8. 支持**用户分组**以及**渠道分组**，支持为不同分组设置不同的倍率。
 9. 支持渠道**设置模型列表**。
 10. 支持**查看额度明细**。
-11. 支持发布公告，设置充值链接，设置新用户初始额度。
-12. 支持丰富的**自定义**设置，
+11. 支持**用户邀请奖励**。
+12. 支持以美元为单位显示额度。
+13. 支持发布公告，设置充值链接，设置新用户初始额度。
+14. 支持丰富的**自定义**设置，
     1. 支持自定义系统名称，logo 以及页脚。
     2. 支持自定义首页和关于页面，可以选择使用 HTML & Markdown 代码进行自定义，或者使用一个单独的网页通过 iframe 嵌入。
-13. 支持通过系统访问令牌访问管理 API。
-14. 支持 Cloudflare Turnstile 用户校验。
-15. 支持用户管理，支持**多种用户登录注册方式**：
+15. 支持通过系统访问令牌访问管理 API。
+16. 支持 Cloudflare Turnstile 用户校验。
+17. 支持用户管理，支持**多种用户登录注册方式**：
     + 邮箱登录注册以及通过邮箱进行密码重置。
     + [GitHub 开放授权](https://github.com/settings/applications/new)。
     + 微信公众号授权（需要额外部署 [WeChat Server](https://github.com/songquanpeng/wechat-server)）。
-16. 未来其他大模型开放 API 后，将第一时间支持，并将其封装成同样的 API 访问方式。
+18. 未来其他大模型开放 API 后，将第一时间支持，并将其封装成同样的 API 访问方式。
 
 ## 部署
 ### 基于 Docker 进行部署
-部署命令：`docker run --name one-api -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`
 
@@ -149,17 +153,20 @@ sudo service nginx restart
 
 ### 多机部署
 1. 所有服务器 `SESSION_SECRET` 设置一样的值。
-2. 必须设置 `SQL_DSN`，使用 MySQL 数据库而非 SQLite，请自行配置主备数据库同步。
-3. 所有从服务器必须设置 `SYNC_FREQUENCY`，以定期从数据库同步配置。
-4. 从服务器可以选择设置 `FRONTEND_BASE_URL`，以重定向页面请求到主服务器。
+2. 必须设置 `SQL_DSN`，使用 MySQL 数据库而非 SQLite，所有服务器连接同一个数据库。
+3. 所有从服务器必须设置 `NODE_TYPE` 为 `slave`。
+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)。
+详见 [#175](https://github.com/songquanpeng/one-api/issues/175)。
 
-如果部署后访问出现空白页面，详见[#97](https://github.com/songquanpeng/one-api/issues/97)。
+如果部署后访问出现空白页面，详见 [#97](https://github.com/songquanpeng/one-api/issues/97)。
 
 ### 部署第三方服务配合 One API 使用
 > 欢迎 PR 添加更多示例。
@@ -168,7 +175,7 @@ sudo service nginx restart
 项目主页：https://github.com/Yidadaa/ChatGPT-Next-Web
 
 ```bash
-docker run --name chat-next-web -d -p 3001:3000 -e BASE_URL=https://openai.justsong.cn yidadaa/chatgpt-next-web
+docker run --name chat-next-web -d -p 3001:3000 yidadaa/chatgpt-next-web
 ```
 
 注意修改端口号和 `BASE_URL`。
@@ -243,6 +250,14 @@ graph LR
    + 例子：`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`。
@@ -263,9 +278,9 @@ https://openai.justsong.cn
 
 ## 常见问题
 1. 额度是什么？怎么计算的？One API 的额度计算有问题？
-   + 额度 = token * 倍率
-   + 倍率包括分组的倍率，以及补全的倍率。
-   + 如果是非流模式，官方接口会返回消耗的总 token，但是你要注意提示和补全的消耗额度不一样。
+   + 额度 = 分组倍率 * 模型倍率 * （提示 token 数 + 补全 token 数 * 补全倍率）
+   + 其中补全倍率对于 GPT3.5 固定为 1.33，GPT4 为 2，与官方保持一致。
+   + 如果是非流模式，官方接口会返回消耗的总 token，但是你要注意提示和补全的消耗倍率不一样。
 2. 账户额度足够为什么提示额度不足？
    + 请检查你的令牌额度是否足够，这个和账户额度是分开的。
    + 令牌额度仅供用户设置最大使用量，用户可自由设置。
@@ -275,9 +290,15 @@ https://openai.justsong.cn
 4. 渠道测试报错：`invalid character '<' looking for beginning of value`
    + 这是因为返回值不是合法的 JSON，而是一个 HTML 页面。
    + 大概率是你的部署站的 IP 或代理的节点被 CloudFlare 封禁了。
+5. ChatGPT Next Web 报错：`Failed to fetch`
+   + 部署的时候不要设置 `BASE_URL`。
+   + 检查你的接口地址和 API Key 有没有填对。
+
+## 相关项目
+[FastGPT](https://github.com/c121914yu/FastGPT): 三分钟搭建 AI 知识库
 
 ## 注意
-本项目为开源项目，请在遵循 OpenAI 的[使用条款](https://openai.com/policies/terms-of-use)以及法律法规的情况下使用，不得用于非法用途。
+本项目为开源项目，请在遵循 OpenAI 的[使用条款](https://openai.com/policies/terms-of-use)以及**法律法规**的情况下使用，不得用于非法用途。
 
 本项目使用 MIT 协议进行开源，请以某种方式保留 One API 的版权信息。
 

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,6 +1,8 @@
 package common
 
 import (
+	"os"
+	"strconv"
 	"sync"
 	"time"
 
@@ -15,6 +17,9 @@ 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
 
@@ -65,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

common/group-ratio.go

@@ -11,7 +11,7 @@ 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)
 }
@@ -24,7 +24,7 @@ func UpdateGroupRatioByJSONString(jsonStr string) error {
 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

@@ -40,7 +40,7 @@ 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)
 }
@@ -53,7 +53,7 @@ func UpdateModelRatioByJSONString(jsonStr string) error {
 func GetModelRatio(name string) float64 {
 	ratio, ok := ModelRatio[name]
 	if !ok {
-		SysError("Model ratio not found: " + name)
+		SysError("model ratio not found: " + name)
 		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()
+}

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")
-	quota, err := model.GetUserQuota(userId)
+	var quota int
+	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),
-		HardLimitUSD:       float64(quota),
-		SystemHardLimitUSD: float64(quota),
+		SoftLimitUSD:       amount,
+		HardLimitUSD:       amount,
+		SystemHardLimitUSD: amount,
 	}
 	c.JSON(200, subscription)
 	return
 }
 
 func GetUsage(c *gin.Context) {
-	//userId := c.GetInt("id")
-	// TODO: get usage from database
+	var quota int
+	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

@@ -257,6 +257,7 @@ func updateAllChannelsBalance() error {
 				disableChannel(channel.Id, channel.Name, "余额不足")
 			}
 		}
+		time.Sleep(common.RequestInterval)
 	}
 	return nil
 }
@@ -277,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

@@ -25,9 +25,7 @@ func testChannel(channel *model.Channel, request ChatRequest) error {
 	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 {
-			requestURL = channel.BaseURL
-		} else if channel.Type == common.ChannelTypeOpenAI && channel.BaseURL != "" {
+		if 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 {
-	model_ := c.Query("model")
+func buildTestRequest() *ChatRequest {
 	testRequest := &ChatRequest{
-		Model:     model_,
+		Model:     "", // this will be set later
 		MaxTokens: 1,
 	}
 	testMessage := Message{
@@ -95,7 +92,7 @@ func TestChannel(c *gin.Context) {
 		})
 		return
 	}
-	testRequest := buildTestRequest(c)
+	testRequest := buildTestRequest()
 	tik := time.Now()
 	err = testChannel(channel, *testRequest)
 	tok := time.Now()
@@ -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
@@ -175,20 +168,23 @@ func testAllChannels(c *gin.Context) error {
 				disableChannel(channel.Id, channel.Name, err.Error())
 			}
 			channel.UpdateResponseTime(milliseconds)
-		}
-		err := common.SendEmail("通道测试完成", common.RootUserEmail, "通道测试完成，如果没有收到禁用通知，说明所有通道都正常")
-		if err != nil {
-			common.SysError(fmt.Sprintf("发送邮件失败：%s", err.Error()))
+			time.Sleep(common.RequestInterval)
 		}
 		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/misc.go

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

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

@@ -77,3 +77,15 @@ func countTokenText(text string, model string) int {
 	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
@@ -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,270 +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")
-		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)
-	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
-			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")
-			userId := c.GetInt("id")
-			model.RecordLog(userId, model.LogTypeConsume, fmt.Sprintf("通过令牌「%s」使用模型 %s 消耗 %d 点额度（模型倍率 %.2f，分组倍率 %.2f）", tokenName, textRequest.Model, 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.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",
@@ -395,7 +135,7 @@ func RelayNotImplemented(c *gin.Context) {
 		Param:   "",
 		Code:    "api_not_implemented",
 	}
-	c.JSON(http.StatusOK, gin.H{
+	c.JSON(http.StatusNotImplemented, gin.H{
 		"error": err,
 	})
 }
@@ -407,7 +147,7 @@ func RelayNotFound(c *gin.Context) {
 		Param:   "",
 		Code:    "api_not_found",
 	}
-	c.JSON(http.StatusOK, gin.H{
+	c.JSON(http.StatusNotFound, gin.H{
 		"error": err,
 	})
 }

controller/user.go

@@ -384,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,

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:
-    #   REDIS_CONN_STRING: redis://default:redispw@localhost:49153
-    #   SESSION_SECRET: random_string
-    #   SQL_DSN: root:123456@tcp(localhost:3306)/one-api
+    environment:
+      - SQL_DSN=root:123456@tcp(host.docker.internal:3306)/one-api  # 修改此行，或注释掉以使用 SQLite 作为数据库
+      - REDIS_CONN_STRING=redis://redis
+      - 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

i18n/en.json

@@ -0,0 +1,419 @@
+{
+  "＄%.6f 额度": "＄%.6f quota",
+  "%d 点额度": "%d point quota",
+  "尚未实现": "Not yet implemented",
+  "余额不足": "Insufficient balance",
+  "\"通道「%s」（#%d）已被禁用\"": "\"Channel %s (#%d) has been disabled\"",
+  "通道「%s」（#%d）已被禁用，原因：%s": "Channel %s (#%d) has been disabled, reason: %s",
+  "测试已在运行中": "Test is already running",
+  "响应时间 %.2fs 超过阈值 %.2fs": "Response time %.2fs exceeds threshold %.2fs",
+  "通道测试完成": "Channel test completed",
+  "通道测试完成，如果没有收到禁用通知，说明所有通道都正常": "Channel test completed, if you have not received the disable notification, it means that all channels are normal",
+  "无法连接至 GitHub 服务器，请稍后重试！": "Unable to connect to GitHub server, please try again later!",
+  "返回值非法，用户字段为空，请稍后重试！": "The return value is illegal, the user field is empty, please try again later!",
+  "管理员未开启通过 GitHub 登录以及注册": "The administrator did not turn on login and registration via GitHub",
+  "管理员关闭了新用户注册": "The administrator has turned off new user registration",
+  "用户已被封禁": "User has been banned",
+  "该 GitHub 账户已被绑定": "The GitHub account has been bound",
+  "邮箱地址已被占用": "Email address is occupied",
+  "%s邮箱验证邮件": "%s Email verification email",
+  "<p>您好，你正在进行%s邮箱验证。</p>": "<p>Hello, you are verifying %s email.</p>",
+  "<p>您的验证码为: <strong>%s</strong></p>": "<p>Your verification code is: <strong>%s</strong></p>",
+  "<p>验证码 %d 分钟内有效，如果不是本人操作，请忽略。</p>": "<p>The verification code is valid within %d minutes. If it is not your operation, please ignore it.</p>",
+  "无效的参数": "Invalid parameter",
+  "该邮箱地址未注册": "The email address is not registered",
+  "%s密码重置": "%s Password reset",
+  "<p>您好，你正在进行%s密码重置。</p>": "<p>Hello, you are resetting %s password.</p>",
+  "<p>点击<a href='%s'>此处</a>进行密码重置。</p>": "<p>Click <a href='%s'>here</a> to reset your password.</p>",
+  "<p>重置链接 %d 分钟内有效，如果不是本人操作，请忽略。</p>": "<p>The reset link is valid within %d minutes. If it is not your operation, please ignore it.</p>",
+  "重置链接非法或已过期": "Reset link is illegal or expired",
+  "无法启用 GitHub OAuth，请先填入 GitHub Client ID 以及 GitHub Client Secret！": "Unable to enable GitHub OAuth, please fill in GitHub Client ID and GitHub Client Secret first!",
+  "无法启用微信登录，请先填入微信登录相关配置信息！": "Unable to enable WeChat login, please fill in the relevant configuration information for WeChat login first!",
+  "无法启用 Turnstile 校验，请先填入 Turnstile 校验相关配置信息！": "Unable to enable Turnstile verification, please fill in the relevant configuration information for Turnstile verification first!",
+  "兑换码名称长度必须在1-20之间": "The length of the redemption code name must be between 1-20",
+  "兑换码个数必须大于0": "The number of redemption codes must be greater than 0",
+  "一次兑换码批量生成的个数不能大于 100": "The number of redemption codes generated in a batch cannot be greater than 100",
+  "通过令牌「%s」使用模型 %s 消耗 %s（模型倍率 %.2f，分组倍率 %.2f）": "Using model %s with token %s consumes %s (model rate %.2f, group rate %.2f)",
+  "当前分组负载已饱和，请稍后再试，或升级账户以提升服务质量。": "The current group load is saturated, please try again later, or upgrade your account to improve service quality.",
+  "令牌名称长度必须在1-20之间": "The length of the token name must be between 1-20",
+  "令牌已过期，无法启用，请先修改令牌过期时间": "The token has expired and cannot be enabled. Please modify the token expiration time first",
+  "令牌可用额度已用尽，无法启用，请先修改令牌剩余额度，或者设置为无限额度": "The available quota of the token has been used up and cannot be enabled. Please modify the remaining quota of the token, or set it to unlimited quota",
+  "管理员关闭了密码登录": "The administrator has turned off password login",
+  "无法保存会话信息，请重试": "Unable to save session information, please try again",
+  "管理员关闭了通过密码进行注册，请使用第三方账户验证的形式进行注册": "The administrator has turned off registration via password. Please use the form of third-party account verification to register",
+  "输入不合法 ": "Input is illegal ",
+  "管理员开启了邮箱验证，请输入邮箱地址和验证码": "The administrator has turned on email verification, please enter the email address and verification code",
+  "验证码错误或已过期": "Verification code error or expired",
+  "无权获取同级或更高等级用户的信息": "No permission to get information of users at the same level or higher",
+  "请重试，系统生成的 UUID 竟然重复了！": "Please try again, the system-generated UUID is actually duplicated!",
+  "输入不合法": "Input is illegal",
+  "无权更新同权限等级或更高权限等级的用户信息": "No permission to update user information with the same permission level or higher permission level",
+  "管理员将用户额度从 %s修改为 %s": "The administrator changed the user quota from %s to %s",
+  "无权删除同权限等级或更高权限等级的用户": "No permission to delete users with the same permission level or higher permission level",
+  "无法创建权限大于等于自己的用户": "Unable to create users with permissions greater than or equal to your own",
+  "用户不存在": "User does not exist",
+  "无法禁用超级管理员用户": "Unable to disable super administrator user",
+  "无法删除超级管理员用户": "Unable to delete super administrator user",
+  "普通管理员用户无法提升其他用户为管理员": "Ordinary administrator users cannot promote other users to administrators",
+  "该用户已经是管理员": "The user is already an administrator",
+  "无法降级超级管理员用户": "Unable to downgrade super administrator user",
+  "该用户已经是普通用户": "The user is already an ordinary user",
+  "管理员未开启通过微信登录以及注册": "The administrator has not enabled login and registration via WeChat",
+  "该微信账号已被绑定": "The WeChat account has been bound",
+  "无权进行此操作，未登录且未提供 access token": "No permission to perform this operation, not logged in and no access token provided",
+  "无权进行此操作，access token 无效": "No permission to perform this operation, access token is invalid",
+  "无权进行此操作，权限不足": "No permission to perform this operation, insufficient permissions",
+  "普通用户不支持指定渠道": "Ordinary users do not support specifying channels",
+  "无效的渠道 ID": "Invalid channel ID",
+  "该渠道已被禁用": "The channel has been disabled",
+  "无效的请求": "Invalid request",
+  "无可用渠道": "No available channels",
+  "Turnstile token 为空": "Turnstile token is empty",
+  "Turnstile 校验失败，请刷新重试！": "Turnstile verification failed, please refresh and try again!",
+  "id 为空！": "id is empty!",
+  "未提供兑换码": "No redemption code provided",
+  "无效的 user id": "Invalid user id",
+  "无效的兑换码": "Invalid redemption code",
+  "该兑换码已被使用": "The redemption code has been used",
+  "通过兑换码充值 %s": "Recharge %s through redemption code",
+  "未提供令牌": "No token provided",
+  "该令牌状态不可用": "The token status is not available",
+  "该令牌已过期": "The token has expired",
+  "该令牌额度已用尽": "The token quota has been used up",
+  "无效的令牌": "Invalid token",
+  "id 或 userId 为空！": "id or userId is empty!",
+  "quota 不能为负数！": "quota cannot be negative!",
+  "令牌额度不足": "Insufficient token quota",
+  "用户额度不足": "Insufficient user quota",
+  "您的额度即将用尽": "Your quota is about to run out",
+  "您的额度已用尽": "Your quota has been used up",
+  "%s，当前剩余额度为 %d，为了不影响您的使用，请及时充值。<br/>充值链接：<a href='%s'>%s</a>": "%s, the current remaining quota is %d, in order not to affect your use, please recharge in time. <br/> Recharge link: <a href='%s'>%s</a>",
+  "affCode 为空！": "affCode is empty!",
+  "新用户注册赠送 %s": "New user registration gives %s",
+  "使用邀请码赠送 %s": "Use invitation code to give %s",
+  "邀请用户赠送 %s": "Invite users to give %s",
+  "用户名或密码为空": "Username or password is empty",
+  "用户名或密码错误，或用户已被封禁": "Username or password is wrong, or user has been banned",
+  "email 为空！": "email is empty!",
+  "GitHub id 为空！": "GitHub id is empty!",
+  "WeChat id 为空！": "WeChat id is empty!",
+  "username 为空！": "username is empty!",
+  "邮箱地址或密码为空！": "Email address or password is empty!",
+  "OpenAI 接口聚合管理，支持多种渠道包括 Azure，可用于二次分发管理 key，仅单可执行文件，已打包好 Docker 镜像，一键部署，开箱即用": "OpenAI interface aggregation management, supports multiple channels including Azure, can be used for secondary distribution management key, only single executable file, Docker image has been packaged, one-click deployment, out of the box",
+  "未知类型": "Unknown type",
+  "不支持": "Not supported",
+  "操作成功完成！": "Operation completed successfully!",
+  "已启用": "Enabled",
+  "已禁用": "Disabled",
+  "未知状态": "Unknown status",
+  " 秒": "s",
+  "未测试": "Not tested",
+  "通道 ${name} 测试成功，耗时 ${time.toFixed(2)} 秒。": "Channel ${name} test succeeded, time consumed ${time.toFixed(2)} s.",
+  "已成功开始测试所有已启用通道，请刷新页面查看结果。": "All enabled channels have been successfully tested, please refresh the page to view the results.",
+  "通道 ${name} 余额更新成功！": "Channel ${name} balance updated successfully!",
+  "已更新完毕所有已启用通道余额！": "The balance of all enabled channels has been updated!",
+  "搜索渠道的 ID，名称和密钥 ...": "Search for channel ID, name and key ...",
+  "名称": "Name",
+  "分组": "Group",
+  "类型": "Type",
+  "状态": "Status",
+  "响应时间": "Response time",
+  "余额": "Balance",
+  "操作": "Operation",
+  "未更新": "Not updated",
+  "测试": "Test",
+  "更新余额": "Update balance",
+  "删除": "Delete",
+  "删除渠道 {channel.name}": "Delete channel {channel.name}",
+  "禁用": "Disable",
+  "启用": "Enable",
+  "编辑": "Edit",
+  "添加新的渠道": "Add a new channel",
+  "测试所有已启用通道": "Test all enabled channels",
+  "更新所有已启用通道余额": "Update the balance of all enabled channels",
+  "刷新": "Refresh",
+  "处理中...": "Processing...",
+  "绑定成功！": "Binding succeeded!",
+  "登录成功！": "Login succeeded!",
+  "操作失败，重定向至登录界面中...": "Operation failed, redirecting to the login page...",
+  "出现错误，第 ${count} 次重试中...": "An error occurred, retrying for the ${count} time...",
+  "首页": "Home",
+  "渠道": "Channel",
+  "令牌": "Token",
+  "兑换": "Redeem",
+  "充值": "Recharge",
+  "用户": "User",
+  "日志": "Log",
+  "设置": "Settings",
+  "关于": "About",
+  "聊天": "Chat",
+  "注销成功!": "Logout succeeded!",
+  "注销": "Logout",
+  "登录": "Login",
+  "注册": "Register",
+  "加载{name}中...": "Loading {name}...",
+  "未登录或登录已过期，请重新登录！": "Not logged in or login has expired, please log in again!",
+  "用户登录": "User login",
+  "\"用户名\"": "\"Username\"",
+  "\"密码\"": "\"Password\"",
+  "忘记密码？": "Forget password?",
+  "点击重置": "Click to reset",
+  "； 没有账户？": "; No account?",
+  "点击注册": "Click to register",
+  "微信扫码关注公众号，输入「验证码」获取验证码（三分钟内有效）": "Scan the QR code of WeChat to follow the official account, enter \"verification code\" to get the verification code (valid within three minutes)",
+  "\"验证码\"": "\"Verification code\"",
+  "全部用户": "All users",
+  "当前用户": "Current user",
+  "'全部'": "'All'",
+  "'充值'": "'Recharge'",
+  "'消费'": "'Consumption'",
+  "'管理'": "'Management'",
+  "'系统'": "'System'",
+  " 充值 ": " Recharge ",
+  " 消费 ": " Consumption ",
+  " 管理 ": " Management ",
+  " 系统 ": " System ",
+  " 未知 ": " Unknown ",
+  "时间": "Time",
+  "详情": "Details",
+  "选择模式": "Select mode",
+  "选择明细分类": "Select details category",
+  "模型倍率不是合法的 JSON 字符串": "Model rate is not a valid JSON string",
+  "分组倍率不是合法的 JSON 字符串": "Group rate is not a valid JSON string",
+  "通用设置": "General Settings",
+  "充值链接": "Recharge Link",
+  "例如发卡网站的购买链接": "For example, the purchase link of the card issuing website",
+  "聊天页面链接": "Chat Page Link",
+  "例如 ChatGPT Next Web 的部署地址": "For example, the deployment address of ChatGPT Next Web",
+  "单位美元额度": "Unit Dollar Quota",
+  "一单位货币能兑换的额度": "Quota that can be exchanged for one unit of currency",
+  "启用额度消费日志记录": "Enable quota consumption log recording",
+  "以货币形式显示额度": "Display quota in the form of currency",
+  "相关 API 显示令牌额度而非用户额度": "Related API displays token quota instead of user quota",
+  "保存通用设置": "Save General Settings",
+  "监控设置": "Monitoring Settings",
+  "最长响应时间": "Longest Response Time",
+  "单位秒": "Unit in seconds",
+  "当运行通道全部测试时": "When all operating channels are tested",
+  "超过此时间将自动禁用通道": "Channels will be automatically disabled if this time is exceeded",
+  "额度提醒阈值": "Quota reminder threshold",
+  "低于此额度时将发送邮件提醒用户": "Email will be sent to remind users when the quota is below this",
+  "失败时自动禁用通道": "Automatically disable the channel when it fails",
+  "保存监控设置": "Save Monitoring Settings",
+  "额度设置": "Quota Settings",
+  "新用户初始额度": "Initial quota for new users",
+  "例如": "For example",
+  "请求预扣费额度": "Request for pre-deducted quota",
+  "请求结束后多退少补": "Refund more or less after the request ends",
+  "邀请新用户奖励额度": "Invite new users to reward quota",
+  "新用户使用邀请码奖励额度": "New user rewards quota using invitation code",
+  "保存额度设置": "Save Quota Settings",
+  "倍率设置": "Rate Settings",
+  "模型倍率": "Model rate",
+  "为一个 JSON 文本": "Is a JSON text",
+  "键为模型名称": "Key is model name",
+  "值为倍率": "Value is the rate",
+  "分组倍率": "Group rate",
+  "键为分组名称": "Key is group name",
+  "保存倍率设置": "Save Rate Settings",
+  "已是最新版本": "Is the latest version",
+  "检查更新": "Check for updates",
+  "公告": "Announcement",
+  "在此输入新的公告内容": "Enter new announcement content here",
+  "保存公告": "Save Announcement",
+  "个性化设置": "Personalization Settings",
+  "系统名称": "System Name",
+  "在此输入系统名称": "Enter the system name here",
+  "设置系统名称": "Set system name",
+  "图片地址": "Image URL",
+  "在此输入 Logo 图片地址": "Enter the Logo image URL here",
+  "首页内容": "Home Page Content",
+  "在此输入首页内容，支持 Markdown & HTML 代码，设置后首页的状态信息将不再显示。如果输入的是一个链接，则会使用该链接作为 iframe 的 src 属性，这允许你设置任意网页作为首页": "Enter the homepage content here, supports Markdown & HTML code. Once set, the status information of the homepage will not be displayed. If a link is entered, it will be used as the src attribute of the iframe, allowing you to set any webpage as the homepage.",
+  "保存首页内容": "Save Home Page Content",
+  "在此输入新的关于内容，支持 Markdown & HTML 代码。如果输入的是一个链接，则会使用该链接作为 iframe 的 src 属性，这允许你设置任意网页作为关于页面": "Enter new about content here, supports Markdown & HTML code. If a link is entered, it will be used as the src attribute of the iframe, allowing you to set any webpage as the about page.",
+  "保存关于": "Save About",
+  "移除 One API 的版权标识必须首先获得授权，项目维护需要花费大量精力，如果本项目对你有意义，请主动支持本项目": "Removal of One API copyright mark must first be authorized. Project maintenance requires a lot of effort. If this project is meaningful to you, please actively support it.",
+  "页脚": "Footer",
+  "在此输入新的页脚，留空则使用默认页脚，支持 HTML 代码": "Enter the new footer here, leave blank to use the default footer, supports HTML code.",
+  "设置页脚": "Set Footer",
+  "新版本": "New Version",
+  "关闭": "Close",
+  "密码已重置并已复制到剪贴板": "Password has been reset and copied to clipboard",
+  "密码重置确认": "Password Reset Confirmation",
+  "邮箱地址": "Email Address",
+  "提交": "Submit",
+  "请稍后几秒重试": "Please retry in a few seconds",
+  "正在检查用户环境": "Checking user environment",
+  "重置邮件发送成功": "Reset mail sent successfully",
+  "请检查邮箱": "Please check your email",
+  "密码重置": "Password Reset",
+  "令牌已重置并已复制到剪贴板": "Token has been reset and copied to clipboard",
+  "邀请链接已复制到剪切板": "Invitation link has been copied to clipboard",
+  "微信账户绑定成功": "WeChat account binding succeeded",
+  "验证码发送成功": "Verification code sent successfully",
+  "邮箱账户绑定成功": "Email account binding succeeded",
+  "注意": "Note",
+  "此处生成的令牌用于系统管理": "The token generated here is used for system management",
+  "而非用于请求 OpenAI 相关的服务": "Not for requesting OpenAI related services",
+  "请知悉": "Please be aware",
+  "更新个人信息": "Update Personal Information",
+  "生成系统访问令牌": "Generate System Access Token",
+  "复制邀请链接": "Copy Invitation Link",
+  "账号绑定": "Account Binding",
+  "绑定微信账号": "Bind WeChat Account",
+  "微信扫码关注公众号": "Scan the QR code with WeChat to follow the official account",
+  "输入": "Enter",
+  "验证码": "Verification Code",
+  "获取验证码": "Get Verification Code",
+  "三分钟内有效": "Valid for three minutes",
+  "绑定": "Bind",
+  "绑定 GitHub 账号": "Bind GitHub Account",
+  "绑定邮箱地址": "Bind Email Address",
+  "输入邮箱地址": "Enter Email Address",
+  "未使用": "Unused",
+  "已使用": "Used",
+  "操作成功完成": "Operation successfully completed",
+  "搜索兑换码的 ID 和名称": "Search for ID and name",
+  "额度": "Quota",
+  "创建时间": "Creation Time",
+  "兑换时间": "Redemption Time",
+  "尚未兑换": "Not yet redeemed",
+  "已复制到剪贴板": "Copied to clipboard",
+  "无法复制到剪贴板": "Unable to copy to clipboard",
+  "请手动复制": "Please copy manually",
+  "已将兑换码填入搜索框": "The voucher code has been filled into the search box",
+  "复制": "Copy",
+  "添加新的兑换码": "Add a new voucher",
+  "密码长度不得小于 8 位": "Password length must not be less than 8 characters",
+  "两次输入的密码不一致": "The two passwords entered do not match",
+  "注册成功": "Registration succeeded",
+  "请稍后几秒重试，Turnstile 正在检查用户环境": "Please retry in a few seconds, Turnstile is checking user environment",
+  "验证码发送成功，请检查你的邮箱": "Verification code sent successfully, please check your email",
+  "新用户注册": "New User Registration",
+  "输入用户名，最长 12 位": "Enter username, up to 12 characters",
+  "输入密码，最短 8 位，最长 20 位": "Enter password, at least 8 characters and up to 20 characters",
+  "输入验证码": "Enter Verification Code",
+  "已有账户": "Already have an account",
+  "点击登录": "Click to log in",
+  "服务器地址": "Server Address",
+  "更新服务器地址": "Update Server Address",
+  "配置登录注册": "Configure Login/Registration",
+  "允许通过密码进行登录": "Allow login via password",
+  "允许通过密码进行注册": "Allow registration via password",
+  "通过密码注册时需要进行邮箱验证": "Email verification is required when registering via password",
+  "允许通过 GitHub 账户登录 & 注册": "Allow login & registration via GitHub account",
+  "允许通过微信登录 & 注册": "Allow login & registration via WeChat",
+  "允许新用户注册（此项为否时，新用户将无法以任何方式进行注册": "Allow new user registration (if this option is off, new users will not be able to register in any way",
+  "启用 Turnstile 用户校验": "Enable Turnstile user verification",
+  "配置 SMTP": "Configure SMTP",
+  "用以支持系统的邮件发送": "To support the system email sending",
+  "SMTP 服务器地址": "SMTP Server Address",
+  "例如：smtp.qq.com": "For example: smtp.qq.com",
+  "SMTP 端口": "SMTP Port",
+  "默认: 587": "Default: 587",
+  "SMTP 账户": "SMTP Account",
+  "通常是邮箱地址": "Usually an email address",
+  "发送者邮箱": "Sender email",
+  "通常和邮箱地址保持一致": "Usually consistent with the email address",
+  "SMTP 访问凭证": "SMTP Access Credential",
+  "敏感信息不会发送到前端显示": "Sensitive information will not be displayed in the frontend",
+  "保存 SMTP 设置": "Save SMTP Settings",
+  "配置 GitHub OAuth App": "Configure GitHub OAuth App",
+  "用以支持通过 GitHub 进行登录注册": "To support login & registration via GitHub",
+  "点击此处": "Click here",
+  "管理你的 GitHub OAuth App": "Manage your GitHub OAuth App",
+  "输入你注册的 GitHub OAuth APP 的 ID": "Enter your registered GitHub OAuth APP ID",
+  "保存 GitHub OAuth 设置": "Save GitHub OAuth Settings",
+  "配置 WeChat Server": "Configure WeChat Server",
+  "用以支持通过微信进行登录注册": "To support login & registration via WeChat",
+  "了解 WeChat Server": "Learn about WeChat Server",
+  "WeChat Server 访问凭证": "WeChat Server Access Credential",
+  "微信公众号二维码图片链接": "WeChat Public Account QR Code Image Link",
+  "输入一个图片链接": "Enter an image link",
+  "保存 WeChat Server 设置": "Save WeChat Server Settings",
+  "配置 Turnstile": "Configure Turnstile",
+  "用以支持用户校验": "To support user verification",
+  "管理你的 Turnstile Sites，推荐选择 Invisible Widget Type": "Manage your Turnstile Sites, recommend selecting Invisible Widget Type",
+  "输入你注册的 Turnstile Site Key": "Enter your registered Turnstile Site Key",
+  "保存 Turnstile 设置": "Save Turnstile Settings",
+  "已过期": "Expired",
+  "已耗尽": "Exhausted",
+  "搜索令牌的名称 ...": "Search for the name of the token...",
+  "已用额度": "Quota used",
+  "剩余额度": "Remaining quota",
+  "过期时间": "Expiration time",
+  "无": "None",
+  "无限制": "Unlimited",
+  "永不过期": "Never expires",
+  "无法复制到剪贴板，请手动复制，已将令牌填入搜索框": "Unable to copy to clipboard, please copy manually, the token has been entered into the search box",
+  "删除令牌": "Delete Token",
+  "添加新的令牌": "Add New Token",
+  "普通用户": "Regular User",
+  "管理员": "Admin",
+  "超级管理员": "Super Admin",
+  "未知身份": "Unknown Identity",
+  "已激活": "Activated",
+  "已封禁": "Banned",
+  "搜索用户的 ID，用户名，显示名称，以及邮箱地址 ...": "Search user ID, username, display name, and email address...",
+  "用户名": "Username",
+  "统计信息": "Statistics",
+  "用户角色": "User Role",
+  "未绑定邮箱地址": "Email not bound",
+  "请求次数": "Number of Requests",
+  "提升": "Promote",
+  "降级": "Demote",
+  "删除用户": "Delete User",
+  "添加新的用户": "Add New User",
+  "自定义": "Custom",
+  "等价金额": "Equivalent Amount",
+  "错误": "Error",
+  "错误：未登录或登录已过期，请重新登录": "Error: Not logged in or login has expired, please log in again",
+  "错误：请求次数过多，请稍后再试": "Error: Too many requests, please try again later",
+  "错误：服务器内部错误，请联系管理员": "Error: Server internal error, please contact the administrator",
+  "本站仅作演示之用，无服务端": "This site is for demonstration purposes only, no server-side",
+  "错误：": "Error:",
+  "新版本可用：${data.version}，请使用快捷键 Shift + F5 刷新页面": "New version available: ${data.version}, please refresh the page using shortcut Shift + F5",
+  "无法正常连接至服务器": "Unable to connect to the server normally",
+  "管理渠道": "Manage Channels",
+  "系统状况": "System Status",
+  "系统信息": "System Information",
+  "系统信息总览": "System Information Overview",
+  "版本": "Version",
+  "源码": "Source Code",
+  "启动时间": "Startup Time",
+  "系统配置": "System Configuration",
+  "系统配置总览": "System Configuration Overview",
+  "邮箱验证": "Email Verification",
+  "未": "Not ",
+  "GitHub 身份验证": "GitHub Authentication",
+  "微信身份验证": "WeChat Authentication",
+  "Turnstile 用户校验": "Turnstile User Verification",
+  "创建新的渠道": "Create New Channel",
+  "镜像": "Mirror",
+  "请输入镜像站地址，格式为：https://domain.com，可不填，不填则使用渠道默认值": "Please enter the mirror site address, the format is: https://domain.com, it can be left blank, if left blank, the default value of the channel will be used",
+  "模型": "Model",
+  "请选择该通道所支持的模型": "Please select the model supported by the channel",
+  "填入基础模型": "Fill in the basic model",
+  "填入所有模型": "Fill in all models",
+  "清除所有模型": "Clear all models",
+  "密钥": "Key",
+  "请输入密钥": "Please enter the key",
+  "批量创建": "Batch Create",
+  "更新渠道信息": "Update Channel Information",
+  "我的令牌": "My Tokens",
+  "管理兑换码": "Manage Redeem Codes",
+  "兑换码": "Redeem Code",
+  "管理用户": "Manage Users",
+  "额度明细": "Quota Details",
+  "个人设置": "Personal Settings",
+  "运营设置": "Operation Settings",
+  "系统设置": "System Settings",
+  "其他设置": "Other Settings",
+  "项目仓库地址": "Project Repository Address",
+  "可在设置页面设置关于内容，支持 HTML & Markdown": "You can set the content about in the settings page, support HTML & Markdown",
+  "由{' '}": "build by{' '}",
+  "构建，源代码遵循{' '}": ", the source code licensed under{' '}",
+  "MIT 协议": "MIT License",
+  "充值额度": "Recharge Quota",
+  "获取兑换码": "Get Redeem Code"
+}

i18n/translate.py

@@ -0,0 +1,61 @@
+import argparse
+import json
+import os
+
+def list_file_paths(path):
+    file_paths = []
+    for root, dirs, files in os.walk(path):
+        if "node_modules" in dirs:
+            dirs.remove("node_modules")
+        if "build" in dirs:
+            dirs.remove("build")
+        if "i18n" in dirs:
+            dirs.remove("i18n")
+        for file in files:
+            file_path = os.path.join(root, file)
+            if file_path.endswith("png") or file_path.endswith("ico") or file_path.endswith("db") or file_path.endswith("exe"):
+                continue
+            file_paths.append(file_path)
+
+        for dir in dirs:
+            dir_path = os.path.join(root, dir)
+            file_paths += list_file_paths(dir_path)
+
+    return file_paths
+
+
+def replace_keys_in_repository(repo_path, json_file_path):
+    with open(json_file_path, 'r', encoding="utf-8") as json_file:
+        key_value_pairs = json.load(json_file)
+
+    pairs = []
+    for key, value in key_value_pairs.items():
+        pairs.append((key, value))
+    pairs.sort(key=lambda x: len(x[0]), reverse=True)
+
+    files = list_file_paths(repo_path)
+    print('Total files: {}'.format(len(files)))
+    for file_path in files:
+        replace_keys_in_file(file_path, pairs)
+
+
+def replace_keys_in_file(file_path, pairs):
+    try:
+        with open(file_path, 'r', encoding="utf-8") as file:
+            content = file.read()
+
+        for key, value in pairs:
+            content = content.replace(key, value)
+
+        with open(file_path, 'w', encoding="utf-8") as file:
+            file.write(content)
+    except UnicodeDecodeError:
+        print('UnicodeDecodeError: {}'.format(file_path))
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description='Replace keys in repository.')
+    parser.add_argument('--repository_path', help='Path to repository')
+    parser.add_argument('--json_file_path', help='Path to JSON file')
+    args = parser.parse_args()
+    replace_keys_in_repository(args.repository_path, args.json_file_path)

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) {
-			c.JSON(http.StatusOK, gin.H{
+		if !model.CacheIsUserEnabled(token.UserId) {
+			c.JSON(http.StatusForbidden, gin.H{
 				"error": gin.H{
 					"message": "用户已被封禁",
 					"type":    "one_api_error",
@@ -123,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", "x-requested-with"}
+	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/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

@@ -8,7 +8,7 @@ import (
 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"`
@@ -36,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
 }
 

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

@@ -35,6 +35,8 @@ func InitOptionMap() {
 	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"] = ""
@@ -64,6 +66,7 @@ func InitOptionMap() {
 	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()
 }
@@ -73,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())
 		}
 	}
 }
@@ -81,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()
 	}
 }
@@ -140,6 +143,10 @@ func updateOptionMap(key string, value string) (err error) {
 			common.AutomaticDisableChannelEnabled = boolValue
 		case "LogConsumeEnabled":
 			common.LogConsumeEnabled = boolValue
+		case "DisplayInCurrencyEnabled":
+			common.DisplayInCurrencyEnabled = boolValue
+		case "DisplayTokenStatEnabled":
+			common.DisplayTokenStatEnabled = boolValue
 		}
 	}
 	switch key {
@@ -196,6 +203,8 @@ func updateOptionMap(key string, value string) (err error) {
 		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{}
-	err = DB.Where("`key` = ?", key).First(token).Error
+	token, err = CacheGetTokenByKey(key)
 	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

@@ -93,16 +93,16 @@ func (user *User) Insert(inviterId int) error {
 		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("使用邀请码赠送 %d 点额度", 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("邀请用户赠送 %d 点额度", common.QuotaForInviter))
+			RecordLog(inviterId, LogTypeSystem, fmt.Sprintf("邀请用户赠送 %s", common.LogQuota(common.QuotaForInviter)))
 		}
 	}
 	return nil
@@ -220,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
@@ -233,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
@@ -256,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
@@ -295,6 +300,6 @@ func UpdateUserUsedQuotaAndRequestCount(id int, quota int) {
 		},
 	).Error
 	if err != nil {
-		common.SysError("Failed to update user used quota and request count: " + err.Error())
+		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                  # 守护进程用户名
-WorkingDirectory=/path/to/One-API  # One API运行路径
-ExecStart=/path/to/One-API/one-api --port 3000 --log-dir /path/to/One-API/logs  # 端口
+User=ubuntu  # 注意修改用户名
+WorkingDirectory=/path/to/one-api  # 注意修改路径
+ExecStart=/path/to/one-api/one-api --port 3000 --log-dir /path/to/one-api/logs  # 注意修改路径和端口号
 Restart=always
 RestartSec=5
 

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

@@ -48,6 +48,8 @@ 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 {

web/src/components/ChannelsTable.js

@@ -238,9 +238,17 @@ const ChannelsTable = () => {
     if (channels.length === 0) return;
     setLoading(true);
     let sortedChannels = [...channels];
-    sortedChannels.sort((a, b) => {
-      return ('' + a[key]).localeCompare(b[key]);
-    });
+    if (typeof sortedChannels[0][key] === 'string'){
+      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();
     }
@@ -255,7 +263,7 @@ const ChannelsTable = () => {
           icon='search'
           fluid
           iconPosition='left'
-          placeholder='搜索渠道的 ID 和名称 ...'
+          placeholder='搜索渠道的 ID，名称和密钥 ...'
           value={searchKeyword}
           loading={searching}
           onChange={handleKeywordChange}

web/src/components/OperationSetting.js

@@ -13,9 +13,12 @@ const OperationSetting = () => {
     GroupRatio: '',
     TopUpLink: '',
     ChatLink: '',
+    QuotaPerUnit: 0,
     AutomaticDisableChannelEnabled: '',
     ChannelDisableThreshold: 0,
-    LogConsumeEnabled: ''
+    LogConsumeEnabled: '',
+    DisplayInCurrencyEnabled: '',
+    DisplayTokenStatEnabled: ''
   });
   const [originInputs, setOriginInputs] = useState({});
   let [loading, setLoading] = useState(false);
@@ -118,6 +121,9 @@ const OperationSetting = () => {
         if (originInputs['ChatLink'] !== inputs.ChatLink) {
           await updateOption('ChatLink', inputs.ChatLink);
         }
+        if (originInputs['QuotaPerUnit'] !== inputs.QuotaPerUnit) {
+          await updateOption('QuotaPerUnit', inputs.QuotaPerUnit);
+        }
         break;
     }
   };
@@ -129,7 +135,7 @@ const OperationSetting = () => {
           <Header as='h3'>
             通用设置
           </Header>
-          <Form.Group widths={2}>
+          <Form.Group widths={3}>
             <Form.Input
               label='充值链接'
               name='TopUpLink'
@@ -148,6 +154,36 @@ const OperationSetting = () => {
               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();
@@ -264,12 +300,6 @@ const OperationSetting = () => {
               placeholder='为一个 JSON 文本，键为分组名称，值为倍率'
             />
           </Form.Group>
-          <Form.Checkbox
-            checked={inputs.LogConsumeEnabled === 'true'}
-            label='启用额度消费日志记录'
-            name='LogConsumeEnabled'
-            onChange={handleInputChange}
-          />
           <Form.Button onClick={() => {
             submitConfig('ratio').then();
           }}>保存倍率设置</Form.Button>

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/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 (
@@ -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/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,7 +155,7 @@ const TokensTable = () => {
           icon='search'
           fluid
           iconPosition='left'
-          placeholder='搜索令牌的 ID 和名称 ...'
+          placeholder='搜索令牌的名称 ...'
           value={searchKeyword}
           loading={searching}
           onChange={handleKeywordChange}
@@ -180,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' }}
@@ -220,7 +229,8 @@ const TokensTable = () => {
                 <Table.Row key={token.id}>
                   <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>

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, renderNumber, renderText } from '../helpers/render';
+import { renderGroup, renderNumber, renderQuota, renderText } from '../helpers/render';
 
 function renderRole(role) {
   switch (role) {
@@ -244,8 +244,8 @@ const UsersTable = () => {
                     {user.email ? <Popup hoverable content={user.email} trigger={<span>{renderText(user.email, 24)}</span>} /> : '无'}
                   </Table.Cell>
                   <Table.Cell>
-                    <Popup content='剩余额度' trigger={<Label>{renderNumber(user.quota)}</Label>} />
-                    <Popup content='已用额度' trigger={<Label>{renderNumber(user.used_quota)}</Label>} />
+                    <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>

web/src/helpers/render.js

@@ -35,4 +35,24 @@ export function renderNumber(num) {
   } 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

@@ -32,15 +32,15 @@ const EditChannel = () => {
     let res = await API.get(`/api/channel/${channelId}`);
     const { success, message, data } = res.data;
     if (success) {
-      if (data.models === "") {
-        data.models = []
+      if (data.models === '') {
+        data.models = [];
       } else {
-        data.models = data.models.split(",")
+        data.models = data.models.split(',');
       }
-      if (data.group === "") {
-        data.groups = []
+      if (data.group === '') {
+        data.groups = [];
       } else {
-        data.groups = data.group.split(",")
+        data.groups = data.group.split(',');
       }
       setInputs(data);
     } else {
@@ -55,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);
     }
@@ -70,7 +70,7 @@ const EditChannel = () => {
       setGroupOptions(res.data.data.map((group) => ({
         key: group,
         text: group,
-        value: group,
+        value: group
       })));
     } catch (error) {
       showError(error.message);
@@ -90,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);
@@ -98,8 +102,8 @@ const EditChannel = () => {
       localInputs.other = '2023-03-15-preview';
     }
     let res;
-    localInputs.models = localInputs.models.join(",")
-    localInputs.group = localInputs.groups.join(",")
+    localInputs.models = localInputs.models.join(',');
+    localInputs.group = localInputs.groups.join(',');
     if (isEdit) {
       res = await API.put(`/api/channel/`, { ...localInputs, id: parseInt(channelId) });
     } else {
@@ -177,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='名称'
@@ -217,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/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/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>