将版本号修改为1.3.4

build/build.sh

@@ -115,7 +115,11 @@ function build() {
 	fi
 
 	# building api node
-	env GOOS="$OS" GOARCH="$ARCH" go build -trimpath -tags $TAG --ldflags="-s -w" -o "$DIST"/bin/edge-api "$ROOT"/../cmd/edge-api/main.go
+	env GOOS="$OS" GOARCH="$ARCH" go build -trimpath -tags $TAG --ldflags="-s -w" -o "$DIST/bin/$NAME" "$ROOT"/../cmd/edge-api/main.go
+	if [ ! -f "${DIST}/bin/${NAME}" ]; then
+		echo "build failed!"
+		exit
+	fi
 
 	# delete hidden files
 	find "$DIST" -name ".DS_Store" -delete

cmd/edge-instance-installer/.gitignore

@@ -0,0 +1,2 @@
+edge-instance-installer*
+prepare.sh

cmd/edge-instance-installer/build.sh

@@ -0,0 +1,45 @@
+#!/usr/bin/env bash
+
+function build() {
+	ROOT=$(dirname "$0")
+
+	OS="${1}"
+	ARCH="${2}"
+	TAG="${3}"
+
+	if [ -z "$OS" ]; then
+		echo "usage: build.sh OS ARCH"
+		exit
+	fi
+
+	if [ -z "$ARCH" ]; then
+		echo "usage: build.sh OS ARCH"
+		exit
+	fi
+
+	VERSION=$(lookup_version "${ROOT}/../../internal/const/const.go")
+	TARGET_NAME="edge-instance-installer-${OS}-${ARCH}-v${VERSION}"
+
+	env GOOS=linux GOARCH="${ARCH}" go build -tags="${TAG}" -trimpath -ldflags="-s -w" -o "${TARGET_NAME}" main.go
+
+	if [ -f "${TARGET_NAME}" ]; then
+		cp "${TARGET_NAME}" "${ROOT}/../../../EdgeAdmin/docker/instance/edge-instance/assets"
+	fi
+
+	echo "[done]"
+}
+
+function lookup_version() {
+	FILE=$1
+	VERSION_DATA=$(cat "$FILE")
+	re="Version[ ]+=[ ]+\"([0-9.]+)\""
+	if [[ $VERSION_DATA =~ $re ]]; then
+		VERSION=${BASH_REMATCH[1]}
+		echo "$VERSION"
+	else
+		echo "could not match version"
+		exit
+	fi
+}
+
+build "$1" "$2" "$3"

cmd/edge-instance-installer/main.go

@@ -0,0 +1,97 @@
+// Copyright 2024 GoEdge CDN goedge.cdn@gmail.com. All rights reserved. Official site: https://goedge.cn .
+
+package main
+
+import (
+	"fmt"
+	"github.com/TeaOSLab/EdgeAPI/internal/instances"
+	_ "github.com/iwind/TeaGo/bootstrap"
+	"github.com/iwind/TeaGo/lists"
+	"log"
+	"os"
+)
+
+func main() {
+	var verbose = lists.ContainsString(os.Args, "-v")
+
+	var dbHost = "127.0.0.1"
+	var dbPassword = "123456"
+	var dbName = "edges"
+
+	envDBHost, _ := os.LookupEnv("EDGE_DB_HOST")
+	if len(envDBHost) > 0 {
+		dbHost = envDBHost
+		if verbose {
+			log.Println("env EDGE_DB_HOST=" + envDBHost)
+		}
+	}
+
+	envDBPassword, _ := os.LookupEnv("EDGE_DB_PASSWORD")
+	if len(envDBPassword) > 0 {
+		dbPassword = envDBPassword
+		if verbose {
+			log.Println("env EDGE_DB_PASSWORD=" + envDBPassword)
+		}
+	}
+
+	envDBName, _ := os.LookupEnv("EDGE_DB_NAME")
+	if len(envDBName) > 0 {
+		dbName = envDBName
+		if verbose {
+			log.Println("env EDGE_DB_NAME=" + envDBName)
+		}
+	}
+
+	var isTesting = lists.ContainsString(os.Args, "-test") || lists.ContainsString(os.Args, "--test")
+	if isTesting {
+		fmt.Println("testing mode ...")
+	}
+
+	var instance = instances.NewInstance(instances.Options{
+		IsTesting: isTesting,
+		Verbose:   verbose,
+		Cacheable: false,
+		WorkDir:   "",
+		SrcDir:    "/usr/local/goedge/src",
+		DB: struct {
+			Host     string
+			Port     int
+			Username string
+			Password string
+			Name     string
+		}{
+			Host:     dbHost,
+			Port:     3306,
+			Username: "root",
+			Password: dbPassword,
+			Name:     dbName,
+		},
+		AdminNode: struct {
+			Port int
+		}{
+			Port: 7788,
+		},
+		APINode: struct {
+			HTTPPort     int
+			RestHTTPPort int
+		}{
+			HTTPPort:     8001,
+			RestHTTPPort: 8002,
+		},
+		Node: struct{ HTTPPort int }{
+			HTTPPort: 80,
+		},
+		UserNode: struct {
+			HTTPPort int
+		}{
+			HTTPPort: 7799,
+		},
+	})
+	err := instance.SetupAll()
+	if err != nil {
+		fmt.Println("[ERROR]setup failed: " + err.Error())
+		return
+	}
+
+	fmt.Println("ok")
+}

internal/const/const.go

@@ -1,7 +1,7 @@
 package teaconst
 
 const (
-	Version = "1.3.1"
+	Version = "1.3.4"
 
 	ProductName   = "Edge API"
 	ProcessName   = "edge-api"
@@ -20,7 +20,7 @@ const (
 
 	// 其他节点版本号，用来检测是否有需要升级的节点
 
-	NodeVersion = "1.3.1"
+	NodeVersion = "1.3.4"
 
 	// SQLVersion SQL版本号
 	SQLVersion = "11"

internal/const/const_community.go

@@ -0,0 +1,9 @@
+// Copyright 2022 Liuxiangchao iwind.liu@gmail.com. All rights reserved. Official site: https://goedge.cn .
+//go:build !plus
+
+package teaconst
+
+const (
+	// DefaultMaxNodes 节点数限制
+	DefaultMaxNodes int32 = 50
+)

internal/db/models/acme/acme_task_log_dao.go

@@ -1,6 +1,7 @@
 package acme
 
 import (
+	"github.com/TeaOSLab/EdgeAPI/internal/utils"
 	_ "github.com/go-sql-driver/mysql"
 	"github.com/iwind/TeaGo/Tea"
 	"github.com/iwind/TeaGo/dbs"
@@ -31,7 +32,7 @@ func init() {
 func (this *ACMETaskLogDAO) CreateACMETaskLog(tx *dbs.Tx, taskId int64, isOk bool, errMsg string) error {
 	var op = NewACMETaskLogOperator()
 	op.TaskId = taskId
-	op.Error = errMsg
+	op.Error = utils.LimitString(errMsg, 1024)
 	op.IsOk = isOk
 	err := this.Save(tx, op)
 	return err

internal/db/models/admin_dao.go

@@ -130,6 +130,19 @@ func (this *AdminDAO) FindAdminIdWithUsername(tx *dbs.Tx, username string) (int6
 	return int64(one.(*Admin).Id), nil
 }
 
+// FindAdminWithUsername 根据用户名查询管理员信息
+func (this *AdminDAO) FindAdminWithUsername(tx *dbs.Tx, username string) (*Admin, error) {
+	one, err := this.Query(tx).
+		Attr("username", username).
+		State(AdminStateEnabled).
+		ResultPk().
+		Find()
+	if err != nil || one == nil {
+		return nil, err
+	}
+	return one.(*Admin), nil
+}
+
 // UpdateAdminPassword 更改管理员密码
 func (this *AdminDAO) UpdateAdminPassword(tx *dbs.Tx, adminId int64, password string) error {
 	if adminId <= 0 {
@@ -212,7 +225,7 @@ func (this *AdminDAO) UpdateAdmin(tx *dbs.Tx, adminId int64, username string, ca
 	return nil
 }
 
-// CheckAdminUsername 检查用户名是否存在
+// CheckAdminUsername 检查管理员用户名是否存在
 func (this *AdminDAO) CheckAdminUsername(tx *dbs.Tx, adminId int64, username string) (bool, error) {
 	query := this.Query(tx).
 		State(AdminStateEnabled).
@@ -260,7 +273,7 @@ func (this *AdminDAO) FindAllAdminModules(tx *dbs.Tx) (result []*Admin, err erro
 	_, err = this.Query(tx).
 		State(AdminStateEnabled).
 		Attr("isOn", true).
-		Result("id", "modules", "isSuper", "fullname", "theme").
+		Result("id", "modules", "isSuper", "fullname", "theme", "lang").
 		Slice(&result).
 		FindAll()
 	return
@@ -313,6 +326,14 @@ func (this *AdminDAO) UpdateAdminTheme(tx *dbs.Tx, adminId int64, theme string)
 		UpdateQuickly()
 }
 
+// UpdateAdminLang 设置管理员语言
+func (this *AdminDAO) UpdateAdminLang(tx *dbs.Tx, adminId int64, langCode string) error {
+	return this.Query(tx).
+		Pk(adminId).
+		Set("lang", langCode).
+		UpdateQuickly()
+}
+
 // CheckSuperAdmin 检查管理员是否为超级管理员
 func (this *AdminDAO) CheckSuperAdmin(tx *dbs.Tx, adminId int64) (bool, error) {
 	if adminId <= 0 {

internal/db/models/http_firewall_policy_dao.go

@@ -149,6 +149,14 @@ func (this *HTTPFirewallPolicyDAO) CreateFirewallPolicy(tx *dbs.Tx, userId int64
 		}
 		op.BlockOptions = blockOptionsJSON
 
+		// page options
+		var pageOptions = firewallconfigs.DefaultHTTPFirewallPageAction()
+		pageOptionsJSON, err := json.Marshal(pageOptions)
+		if err != nil {
+			return 0, err
+		}
+		op.PageOptions = pageOptionsJSON
+
 		// captcha options
 		var captchaOptions = firewallconfigs.DefaultHTTPFirewallCaptchaAction()
 		captchaOptionsJSON, err := json.Marshal(captchaOptions)
@@ -313,6 +321,7 @@ func (this *HTTPFirewallPolicyDAO) UpdateFirewallPolicy(tx *dbs.Tx,
 	inboundJSON []byte,
 	outboundJSON []byte,
 	blockOptionsJSON []byte,
+	pageOptionsJSON []byte,
 	captchaOptionsJSON []byte,
 	mode firewallconfigs.FirewallMode,
 	useLocalFirewall bool,
@@ -343,6 +352,9 @@ func (this *HTTPFirewallPolicyDAO) UpdateFirewallPolicy(tx *dbs.Tx,
 	if IsNotNull(blockOptionsJSON) {
 		op.BlockOptions = blockOptionsJSON
 	}
+	if IsNotNull(pageOptionsJSON) {
+		op.PageOptions = pageOptionsJSON
+	}
 	if IsNotNull(captchaOptionsJSON) {
 		op.CaptchaOptions = captchaOptionsJSON
 	}
@@ -444,6 +456,7 @@ func (this *HTTPFirewallPolicyDAO) ComposeFirewallPolicy(tx *dbs.Tx, policyId in
 
 	var config = &firewallconfigs.HTTPFirewallPolicy{}
 	config.Id = int64(policy.Id)
+	config.ServerId = int64(policy.ServerId)
 	config.IsOn = policy.IsOn
 	config.Name = policy.Name
 	config.Description = policy.Description
@@ -523,6 +536,16 @@ func (this *HTTPFirewallPolicyDAO) ComposeFirewallPolicy(tx *dbs.Tx, policyId in
 		config.BlockOptions = blockAction
 	}
 
+	// Page动作配置
+	if IsNotNull(policy.PageOptions) {
+		var pageAction = firewallconfigs.DefaultHTTPFirewallPageAction()
+		err = json.Unmarshal(policy.PageOptions, pageAction)
+		if err != nil {
+			return config, err
+		}
+		config.PageOptions = pageAction
+	}
+
 	// Captcha动作配置
 	if IsNotNull(policy.CaptchaOptions) {
 		var captchaAction = &firewallconfigs.HTTPFirewallCaptchaAction{}
@@ -667,6 +690,19 @@ func (this *HTTPFirewallPolicyDAO) FindFirewallPolicyIdsWithServerId(tx *dbs.Tx,
 	return result, nil
 }
 
+// FindServerIdWithFirewallPolicyId 根据策略查找网站ID
+func (this *HTTPFirewallPolicyDAO) FindServerIdWithFirewallPolicyId(tx *dbs.Tx, policyId int64) (serverId int64, err error) {
+	if policyId <= 0 {
+		return
+	}
+
+	serverId, err = this.Query(tx).
+		Pk(policyId).
+		Result("serverId").
+		FindInt64Col(0)
+	return
+}
+
 // NotifyUpdate 通知更新
 func (this *HTTPFirewallPolicyDAO) NotifyUpdate(tx *dbs.Tx, policyId int64) error {
 	webIds, err := SharedHTTPWebDAO.FindAllWebIdsWithHTTPFirewallPolicyId(tx, policyId)

internal/db/models/http_firewall_policy_model.go

@@ -16,8 +16,9 @@ const (
 	HTTPFirewallPolicyField_Description        dbs.FieldName = "description"        // 描述
 	HTTPFirewallPolicyField_Inbound            dbs.FieldName = "inbound"            // 入站规则
 	HTTPFirewallPolicyField_Outbound           dbs.FieldName = "outbound"           // 出站规则
-	HTTPFirewallPolicyField_BlockOptions       dbs.FieldName = "blockOptions"       // BLOCK选项
-	HTTPFirewallPolicyField_CaptchaOptions     dbs.FieldName = "captchaOptions"     // 验证码选项
+	HTTPFirewallPolicyField_BlockOptions       dbs.FieldName = "blockOptions"       // BLOCK动作选项
+	HTTPFirewallPolicyField_PageOptions        dbs.FieldName = "pageOptions"        // PAGE动作选项
+	HTTPFirewallPolicyField_CaptchaOptions     dbs.FieldName = "captchaOptions"     // 验证码动作选项
 	HTTPFirewallPolicyField_Mode               dbs.FieldName = "mode"               // 模式
 	HTTPFirewallPolicyField_UseLocalFirewall   dbs.FieldName = "useLocalFirewall"   // 是否自动使用本地防火墙
 	HTTPFirewallPolicyField_SynFlood           dbs.FieldName = "synFlood"           // SynFlood防御设置
@@ -42,8 +43,9 @@ type HTTPFirewallPolicy struct {
 	Description        string   `field:"description"`        // 描述
 	Inbound            dbs.JSON `field:"inbound"`            // 入站规则
 	Outbound           dbs.JSON `field:"outbound"`           // 出站规则
-	BlockOptions       dbs.JSON `field:"blockOptions"`       // BLOCK选项
-	CaptchaOptions     dbs.JSON `field:"captchaOptions"`     // 验证码选项
+	BlockOptions       dbs.JSON `field:"blockOptions"`       // BLOCK动作选项
+	PageOptions        dbs.JSON `field:"pageOptions"`        // PAGE动作选项
+	CaptchaOptions     dbs.JSON `field:"captchaOptions"`     // 验证码动作选项
 	Mode               string   `field:"mode"`               // 模式
 	UseLocalFirewall   uint8    `field:"useLocalFirewall"`   // 是否自动使用本地防火墙
 	SynFlood           dbs.JSON `field:"synFlood"`           // SynFlood防御设置
@@ -67,8 +69,9 @@ type HTTPFirewallPolicyOperator struct {
 	Description        any // 描述
 	Inbound            any // 入站规则
 	Outbound           any // 出站规则
-	BlockOptions       any // BLOCK选项
-	CaptchaOptions     any // 验证码选项
+	BlockOptions       any // BLOCK动作选项
+	PageOptions        any // PAGE动作选项
+	CaptchaOptions     any // 验证码动作选项
 	Mode               any // 模式
 	UseLocalFirewall   any // 是否自动使用本地防火墙
 	SynFlood           any // SynFlood防御设置

internal/db/models/http_web_dao.go

@@ -554,6 +554,18 @@ func (this *HTTPWebDAO) ComposeWebConfig(tx *dbs.Tx, webId int64, isLocationOrGr
 		}
 	}
 
+	// hls
+	if IsNotNull(web.Hls) {
+		var hlsConfig = &serverconfigs.HLSConfig{}
+		err = json.Unmarshal(web.Hls, hlsConfig)
+		if err != nil {
+			return nil, err
+		}
+		if this.shouldCompose(isLocationOrGroup, forNode, hlsConfig.IsPrior, true) {
+			config.HLS = hlsConfig
+		}
+	}
+
 	if cacheMap != nil {
 		cacheMap.Put(cacheKey, config)
 	}
@@ -1299,6 +1311,61 @@ func (this *HTTPWebDAO) UpdateWebRequestScripts(tx *dbs.Tx, webId int64, config
 	return this.NotifyUpdate(tx, webId)
 }
 
+// UpdateWebRequestScriptsAsPassed 设置请求脚本为审核通过
+func (this *HTTPWebDAO) UpdateWebRequestScriptsAsPassed(tx *dbs.Tx, webId int64, codeMD5 string) error {
+	if webId <= 0 || len(codeMD5) == 0 {
+		return nil
+	}
+
+	configString, err := this.Query(tx).
+		Pk(webId).
+		Result("requestScripts").
+		FindStringCol("")
+	if err != nil {
+		return nil
+	}
+
+	var config = &serverconfigs.HTTPRequestScriptsConfig{}
+	if len(configString) == 0 {
+		return nil
+	}
+	err = json.Unmarshal([]byte(configString), config)
+	if err != nil {
+		return err
+	}
+
+	var found bool
+
+	for _, group := range config.AllGroups() {
+		for _, script := range group.Scripts {
+			if script.AuditingCodeMD5 == codeMD5 {
+				script.Code = script.AuditingCode
+				script.AuditingCode = ""
+				script.AuditingCodeMD5 = ""
+
+				found = true
+			}
+		}
+	}
+
+	if found {
+		configJSON, err := json.Marshal(config)
+		if err != nil {
+			return err
+		}
+		err = this.Query(tx).
+			Pk(webId).
+			Set("requestScripts", configJSON).
+			UpdateQuickly()
+		if err != nil {
+			return err
+		}
+		return this.NotifyUpdate(tx, webId)
+	}
+
+	return nil
+}
+
 // FindWebRequestScripts 查找服务的脚本设置
 func (this *HTTPWebDAO) FindWebRequestScripts(tx *dbs.Tx, webId int64) (*serverconfigs.HTTPRequestScriptsConfig, error) {
 	configString, err := this.Query(tx).
@@ -1399,7 +1466,7 @@ func (this *HTTPWebDAO) UpdateWebReferers(tx *dbs.Tx, webId int64, referersConfi
 	return this.NotifyUpdate(tx, webId)
 }
 
-// FindWebReferers 查找服务的防盗链配置
+// FindWebReferers 查找网站的防盗链配置
 func (this *HTTPWebDAO) FindWebReferers(tx *dbs.Tx, webId int64) ([]byte, error) {
 	return this.Query(tx).
 		Pk(webId).
@@ -1409,6 +1476,10 @@ func (this *HTTPWebDAO) FindWebReferers(tx *dbs.Tx, webId int64) ([]byte, error)
 
 // UpdateWebUserAgent 修改User-Agent设置
 func (this *HTTPWebDAO) UpdateWebUserAgent(tx *dbs.Tx, webId int64, userAgentConfig *serverconfigs.UserAgentConfig) error {
+	if webId <= 0 {
+		return errors.New("require 'webId'")
+	}
+
 	if userAgentConfig == nil {
 		return nil
 	}

internal/db/models/http_web_model.go

@@ -41,6 +41,7 @@ const (
 	HTTPWebField_Referers           dbs.FieldName = "referers"           // 防盗链设置
 	HTTPWebField_UserAgent          dbs.FieldName = "userAgent"          // UserAgent设置
 	HTTPWebField_Optimization       dbs.FieldName = "optimization"       // 页面优化配置
+	HTTPWebField_Hls                dbs.FieldName = "hls"                // HLS设置
 )
 
 // HTTPWeb HTTP Web
@@ -83,6 +84,7 @@ type HTTPWeb struct {
 	Referers           dbs.JSON `field:"referers"`           // 防盗链设置
 	UserAgent          dbs.JSON `field:"userAgent"`          // UserAgent设置
 	Optimization       dbs.JSON `field:"optimization"`       // 页面优化配置
+	Hls                dbs.JSON `field:"hls"`                // HLS设置
 }
 
 type HTTPWebOperator struct {
@@ -124,6 +126,7 @@ type HTTPWebOperator struct {
 	Referers           any // 防盗链设置
 	UserAgent          any // UserAgent设置
 	Optimization       any // 页面优化配置
+	Hls                any // HLS设置
 }
 
 func NewHTTPWebOperator() *HTTPWebOperator {

internal/db/models/ip_item_dao.go

@@ -582,6 +582,62 @@ func (this *IPItemDAO) ListAllEnabledIPItems(tx *dbs.Tx, sourceUserId int64, key
 	return
 }
 
+// ListAllIPItemIds 搜索所有IP Id列表
+func (this *IPItemDAO) ListAllIPItemIds(tx *dbs.Tx, sourceUserId int64, keyword string, ip string, listId int64, unread bool, eventLevel string, listType string, offset int64, size int64) (itemIds []int64, err error) {
+	var query = this.Query(tx)
+	if sourceUserId > 0 {
+		if listId <= 0 {
+			query.Where("((listId=" + types.String(firewallconfigs.GlobalListId) + " AND sourceUserId=:sourceUserId) OR listId IN (SELECT id FROM " + SharedIPListDAO.Table + " WHERE userId=:sourceUserId AND state=1))")
+			query.Param("sourceUserId", sourceUserId)
+		} else if listId == firewallconfigs.GlobalListId {
+			query.Attr("sourceUserId", sourceUserId)
+			query.UseIndex("sourceUserId")
+		}
+	}
+	if len(keyword) > 0 {
+		if net.ParseIP(keyword) != nil { // 是一个IP地址
+			query.Attr("ipFrom", keyword)
+		} else {
+			query.Like("ipFrom", dbutils.QuoteLike(keyword))
+		}
+	}
+	if len(ip) > 0 {
+		query.Attr("ipFrom", ip)
+	}
+	if listId > 0 {
+		query.Attr("listId", listId)
+	} else {
+		if len(listType) > 0 {
+			query.Where("(listId=" + types.String(firewallconfigs.GlobalListId) + " OR listId IN (SELECT id FROM " + SharedIPListDAO.Table + " WHERE state=1 AND type=:listType))")
+			query.Param("listType", listType)
+		} else {
+			query.Where("(listId=" + types.String(firewallconfigs.GlobalListId) + " OR listId IN (SELECT id FROM " + SharedIPListDAO.Table + " WHERE state=1))")
+		}
+	}
+	if unread {
+		query.Attr("isRead", 0)
+	}
+	if len(eventLevel) > 0 {
+		query.Attr("eventLevel", eventLevel)
+	}
+	result, err := query.
+		ResultPk().
+		State(IPItemStateEnabled).
+		Where("(expiredAt=0 OR expiredAt>:expiredAt)").
+		Param("expiredAt", time.Now().Unix()).
+		DescPk().
+		Offset(offset).
+		Size(size).
+		FindAll()
+	if err != nil {
+		return nil, err
+	}
+	for _, itemOne := range result {
+		itemIds = append(itemIds, int64(itemOne.(*IPItem).Id))
+	}
+	return
+}
+
 // UpdateItemsRead 设置所有未已读
 func (this *IPItemDAO) UpdateItemsRead(tx *dbs.Tx, sourceUserId int64) error {
 	var query = this.Query(tx).

internal/db/models/ip_library_file_dao.go

@@ -13,6 +13,7 @@ import (
 	"github.com/iwind/TeaGo/types"
 	"io"
 	"os"
+	"strings"
 	"time"
 )
 
@@ -449,6 +450,14 @@ func (this *IPLibraryFileDAO) GenerateIPLibrary(tx *dbs.Tx, libraryFileId int64)
 	for _, province := range dbProvinces {
 		for _, code := range province.AllCodes() {
 			provinceMap[types.String(province.CountryId)+"_"+code] = int64(province.ValueId)
+
+			for _, suffix := range regions.RegionProvinceSuffixes {
+				if strings.HasSuffix(code, suffix) {
+					provinceMap[types.String(province.CountryId)+"_"+strings.TrimSuffix(code, suffix)] = int64(province.ValueId)
+				} else {
+					provinceMap[types.String(province.CountryId)+"_"+(code+suffix)] = int64(province.ValueId)
+				}
+			}
 		}
 	}
 

internal/db/models/ip_list_dao.go

@@ -339,3 +339,16 @@ func (this *IPListDAO) NotifyUpdate(tx *dbs.Tx, listId int64, taskType NodeTaskT
 
 	return nil
 }
+
+// FindServerIdWithListId 查找IP名单对应的网站ID
+func (this *IPListDAO) FindServerIdWithListId(tx *dbs.Tx, listId int64) (serverId int64, err error) {
+	if listId <= 0 {
+		return
+	}
+
+	serverId, err = this.Query(tx).
+		Pk(listId).
+		Result("serverId").
+		FindInt64Col(0)
+	return
+}

internal/db/models/login_session_dao.go

@@ -135,40 +135,16 @@ func (this *LoginSessionDAO) WriteSessionValue(tx *dbs.Tx, sid string, key strin
 		sessionOp.UserId = userId
 
 		if isNewSession {
-			// 删除此用户之前创建的SESSION，防止单个用户SESSION过多
-			// TODO 将来改成按照活跃时间排序
-			const maxSessionsPerUser = 10
-			oldOnes, err := this.Query(tx).
+			// 删除此用户之前创建的SESSION，不再保存以往的SESSION，避免安全问题
+			err = this.Query(tx).
 				ResultPk().
 				Attr("adminId", adminId).
 				Attr("userId", userId).
-				Asc("createdAt").
-				FindAll()
+				Neq("sid", sid).
+				DeleteQuickly()
 			if err != nil {
 				return err
 			}
-			var countOldOnes = len(oldOnes)
-			if countOldOnes > maxSessionsPerUser {
-				var countDeleted int
-				for _, oldOne := range oldOnes {
-					var oldSessionId = int64(oldOne.(*LoginSession).Id)
-					if oldSessionId == sessionId {
-						continue
-					}
-
-					if countDeleted < countOldOnes-maxSessionsPerUser {
-						err = this.Query(tx).
-							Pk(oldSessionId).
-							DeleteQuickly()
-						if err != nil {
-							return err
-						}
-						countDeleted++
-					} else {
-						break
-					}
-				}
-			}
 		}
 	}
 

internal/db/models/metric_stat_dao.go

@@ -5,7 +5,6 @@ import (
 	"github.com/TeaOSLab/EdgeAPI/internal/goman"
 	"github.com/TeaOSLab/EdgeAPI/internal/remotelogs"
 	"github.com/TeaOSLab/EdgeCommon/pkg/serverconfigs"
-	"github.com/go-sql-driver/mysql"
 	_ "github.com/go-sql-driver/mysql"
 	"github.com/iwind/TeaGo/Tea"
 	"github.com/iwind/TeaGo/dbs"
@@ -759,10 +758,5 @@ func (this *MetricStatDAO) canIgnore(err error) bool {
 	}
 
 	// 忽略 Error 1213: Deadlock found 错误
-	mysqlErr, ok := err.(*mysql.MySQLError)
-	if ok && mysqlErr.Number == 1213 {
-		return true
-	}
-
-	return false
+	return CheckSQLErrCode(err, 1213)
 }

internal/db/models/metric_sum_stat_dao.go

@@ -4,7 +4,6 @@ import (
 	"github.com/TeaOSLab/EdgeAPI/internal/goman"
 	"github.com/TeaOSLab/EdgeAPI/internal/remotelogs"
 	"github.com/TeaOSLab/EdgeCommon/pkg/serverconfigs"
-	"github.com/go-sql-driver/mysql"
 	_ "github.com/go-sql-driver/mysql"
 	"github.com/iwind/TeaGo/Tea"
 	"github.com/iwind/TeaGo/dbs"
@@ -289,10 +288,5 @@ func (this *MetricSumStatDAO) canIgnore(err error) bool {
 	}
 
 	// 忽略 Error 1213: Deadlock found 错误
-	mysqlErr, ok := err.(*mysql.MySQLError)
-	if ok && mysqlErr.Number == 1213 {
-		return true
-	}
-
-	return false
+	return CheckSQLErrCode(err, 1213)
 }

internal/db/models/node_cluster_dao.go

@@ -264,13 +264,22 @@ func (this *NodeClusterDAO) CountAllEnabledClusters(tx *dbs.Tx, keyword string)
 }
 
 // ListEnabledClusters 列出单页集群
-func (this *NodeClusterDAO) ListEnabledClusters(tx *dbs.Tx, keyword string, offset, size int64) (result []*NodeCluster, err error) {
+func (this *NodeClusterDAO) ListEnabledClusters(tx *dbs.Tx, keyword string, idDesc bool, idAsc bool, offset, size int64) (result []*NodeCluster, err error) {
 	var query = this.Query(tx).
 		State(NodeClusterStateEnabled)
 	if len(keyword) > 0 {
 		query.Where("(name LIKE :keyword OR dnsName like :keyword OR (dnsDomainId > 0 AND dnsDomainId IN (SELECT id FROM "+dns.SharedDNSDomainDAO.Table+" WHERE name LIKE :keyword AND state=1)))").
 			Param("keyword", dbutils.QuoteLike(keyword))
 	}
+
+	if idDesc {
+		query.DescPk()
+	} else if idAsc {
+		query.AscPk()
+	} else {
+		query.Desc("isPinned").DescPk()
+	}
+
 	_, err = query.
 		Result(
 			NodeClusterField_Id,
@@ -295,8 +304,6 @@ func (this *NodeClusterDAO) ListEnabledClusters(tx *dbs.Tx, keyword string, offs
 		Offset(offset).
 		Limit(size).
 		Slice(&result).
-		Desc("isPinned").
-		DescPk().
 		FindAll()
 
 	return
@@ -1043,7 +1050,7 @@ func (this *NodeClusterDAO) UpdateClusterWebPPolicy(tx *dbs.Tx, clusterId int64,
 			return err
 		}
 
-		return this.NotifyUpdate(tx, clusterId)
+		return this.NotifyWebPPolicyUpdate(tx, clusterId)
 	}
 
 	webpPolicyJSON, err := json.Marshal(webpPolicy)
@@ -1058,7 +1065,7 @@ func (this *NodeClusterDAO) UpdateClusterWebPPolicy(tx *dbs.Tx, clusterId int64,
 		return err
 	}
 
-	return this.NotifyUpdate(tx, clusterId)
+	return this.NotifyWebPPolicyUpdate(tx, clusterId)
 }
 
 // FindClusterWebPPolicy 查询WebP设置
@@ -1083,7 +1090,7 @@ func (this *NodeClusterDAO) FindClusterWebPPolicy(tx *dbs.Tx, clusterId int64, c
 		return nodeconfigs.DefaultWebPImagePolicy, nil
 	}
 
-	var policy = &nodeconfigs.WebPImagePolicy{}
+	var policy = nodeconfigs.NewWebPImagePolicy()
 	err = json.Unmarshal(webpJSON, policy)
 	if err != nil {
 		return nil, err
@@ -1518,6 +1525,11 @@ func (this *NodeClusterDAO) NotifyTOAUpdate(tx *dbs.Tx, clusterId int64) error {
 	return SharedNodeTaskDAO.CreateClusterTask(tx, nodeconfigs.NodeRoleNode, clusterId, 0, 0, NodeTaskTypeTOAChanged)
 }
 
+// NotifyWebPPolicyUpdate 通知WebP策略更新
+func (this *NodeClusterDAO) NotifyWebPPolicyUpdate(tx *dbs.Tx, clusterId int64) error {
+	return SharedNodeTaskDAO.CreateClusterTask(tx, nodeconfigs.NodeRoleNode, clusterId, 0, 0, NodeTaskTypeWebPPolicyChanged)
+}
+
 // NotifyDNSUpdate 通知DNS更新
 // TODO 更新新的DNS解析记录的同时，需要删除老的DNS解析记录
 func (this *NodeClusterDAO) NotifyDNSUpdate(tx *dbs.Tx, clusterId int64) error {

internal/db/models/node_dao.go

@@ -882,9 +882,28 @@ func (this *NodeDAO) FindNodeStatus(tx *dbs.Tx, nodeId int64) (*nodeconfigs.Node
 	return status, nil
 }
 
+// UpdateNodeIsOn 修改节点启用状态
+func (this *NodeDAO) UpdateNodeIsOn(tx *dbs.Tx, nodeId int64, isOn bool) error {
+	if nodeId <= 0 {
+		return errors.New("invalid nodeId")
+	}
+	err := this.Query(tx).
+		Pk(nodeId).
+		Set("isOn", isOn).
+		UpdateQuickly()
+	if err != nil {
+		return err
+	}
+
+	return this.NotifyDNSUpdate(tx, nodeId)
+}
+
 // UpdateNodeIsActive 更改节点在线状态
 func (this *NodeDAO) UpdateNodeIsActive(tx *dbs.Tx, nodeId int64, isActive bool) error {
-	b := "true"
+	if nodeId <= 0 {
+		return errors.New("invalid nodeId")
+	}
+	var b = "true"
 	if !isActive {
 		b = "false"
 	}
@@ -898,6 +917,9 @@ func (this *NodeDAO) UpdateNodeIsActive(tx *dbs.Tx, nodeId int64, isActive bool)
 
 // UpdateNodeIsInstalled 设置节点安装状态
 func (this *NodeDAO) UpdateNodeIsInstalled(tx *dbs.Tx, nodeId int64, isInstalled bool) error {
+	if nodeId <= 0 {
+		return errors.New("invalid nodeId")
+	}
 	_, err := this.Query(tx).
 		Pk(nodeId).
 		Set("isInstalled", isInstalled).
@@ -1151,7 +1173,7 @@ func (this *NodeDAO) ComposeNodeConfig(tx *dbs.Tx, nodeId int64, dataMap *shared
 
 		// webp
 		if IsNotNull(nodeCluster.Webp) {
-			var webpPolicy = &nodeconfigs.WebPImagePolicy{}
+			var webpPolicy = nodeconfigs.NewWebPImagePolicy()
 			err = json.Unmarshal(nodeCluster.Webp, webpPolicy)
 			if err != nil {
 				return nil, err

internal/db/models/node_dao_limit.go

@@ -4,7 +4,10 @@
 package models
 
 import (
+	"errors"
+	teaconst "github.com/TeaOSLab/EdgeAPI/internal/const"
 	"github.com/iwind/TeaGo/dbs"
+	"github.com/iwind/TeaGo/types"
 )
 
 func (this *NodeDAO) CountAllAuthorityNodes(tx *dbs.Tx) (int64, error) {
@@ -15,5 +18,18 @@ func (this *NodeDAO) CountAllAuthorityNodes(tx *dbs.Tx) (int64, error) {
 }
 
 func (this *NodeDAO) CheckNodesLimit(tx *dbs.Tx) error {
+	var maxNodes = teaconst.DefaultMaxNodes
+
+	// 检查节点数量
+	if maxNodes > 0 {
+		count, err := this.CountAllAuthorityNodes(tx)
+		if err != nil {
+			return err
+		}
+		if count >= int64(maxNodes) {
+			return errors.New("超出最大节点数限制：" + types.String(maxNodes) + "，当前已用：" + types.String(count) + "，请自行修改源码修改此限制（EdgeAPI/internal/const/const_community.go） 或者 购买商业版本授权。")
+		}
+	}
+
 	return nil
 }

internal/db/models/node_task_dao.go

@@ -31,8 +31,10 @@ const (
 	NodeTaskTypeHTTPCCPolicyChanged          NodeTaskType = "httpCCPolicyChanged"          // CC策略变化
 	NodeTaskTypeHTTP3PolicyChanged           NodeTaskType = "http3PolicyChanged"           // HTTP3策略变化
 	NodeTaskTypeNetworkSecurityPolicyChanged NodeTaskType = "networkSecurityPolicyChanged" // 网络安全策略变化
+	NodeTaskTypeWebPPolicyChanged            NodeTaskType = "webPPolicyChanged"            // WebP策略变化
 	NodeTaskTypeUpdatingServers              NodeTaskType = "updatingServers"              // 更新一组服务
 	NodeTaskTypeTOAChanged                   NodeTaskType = "toaChanged"                   // TOA配置变化
+	NodeTaskTypePlanChanged                  NodeTaskType = "planChanged"                  // 套餐变化
 
 	// NS相关
 

internal/db/models/origin_dao.go

@@ -538,6 +538,17 @@ func (this *OriginDAO) CheckUserOrigin(tx *dbs.Tx, userId int64, originId int64)
 	return SharedReverseProxyDAO.CheckUserReverseProxy(tx, userId, reverseProxyId)
 }
 
+// ExistsOrigin 检查源站是否存在
+func (this *OriginDAO) ExistsOrigin(tx *dbs.Tx, originId int64) (bool, error) {
+	if originId <= 0 {
+		return false, nil
+	}
+	return this.Query(tx).
+		Pk(originId).
+		State(OriginStateEnabled).
+		Exist()
+}
+
 // NotifyUpdate 通知更新
 func (this *OriginDAO) NotifyUpdate(tx *dbs.Tx, originId int64) error {
 	reverseProxyId, err := SharedReverseProxyDAO.FindReverseProxyContainsOriginId(tx, originId)

internal/db/models/plan_dao.go

@@ -49,7 +49,12 @@ func (this *PlanDAO) EnablePlan(tx *dbs.Tx, id uint32) error {
 
 // DisablePlan 禁用条目
 func (this *PlanDAO) DisablePlan(tx *dbs.Tx, id int64) error {
-	_, err := this.Query(tx).
+	clusterId, err := this.FindPlanClusterId(tx, id)
+	if err != nil {
+		return err
+	}
+
+	_, err = this.Query(tx).
 		Pk(id).
 		Set("state", PlanStateDisabled).
 		Update()
@@ -57,7 +62,7 @@ func (this *PlanDAO) DisablePlan(tx *dbs.Tx, id int64) error {
 		return err
 	}
 
-	return this.NotifyUpdate(tx, id)
+	return this.NotifyUpdate(tx, id, clusterId)
 }
 
 // FindEnabledPlan 查找启用中的条目
@@ -175,18 +180,18 @@ func (this *PlanDAO) FindEnabledPlanTrafficLimit(tx *dbs.Tx, planId int64, cache
 	return config, nil
 }
 
-// NotifyUpdate 通知变更
-func (this *PlanDAO) NotifyUpdate(tx *dbs.Tx, planId int64) error {
-	// 这里不要加入状态参数，因为需要适应删除后的更新
-	clusterId, err := this.Query(tx).
+// FindPlanClusterId 查找套餐所属集群
+func (this *PlanDAO) FindPlanClusterId(tx *dbs.Tx, planId int64) (clusterId int64, err error) {
+	return this.Query(tx).
 		Pk(planId).
 		Result("clusterId").
 		FindInt64Col(0)
-	if err != nil {
-		return err
-	}
-	if clusterId > 0 {
-		return SharedNodeClusterDAO.NotifyUpdate(tx, clusterId)
-	}
-	return nil
+}
+
+// NotifyUpdate 通知变更
+func (this *PlanDAO) NotifyUpdate(tx *dbs.Tx, planId int64, clusterId int64) error {
+	if clusterId <= 0 {
+		return nil
+	}
+	return SharedNodeClusterDAO.NotifyUpdate(tx, clusterId)
 }

internal/db/models/plan_model.go

@@ -3,70 +3,88 @@ package models
 import "github.com/iwind/TeaGo/dbs"
 
 const (
-	PlanField_Id                        dbs.FieldName = "id"                        // ID
-	PlanField_IsOn                      dbs.FieldName = "isOn"                      // 是否启用
-	PlanField_Name                      dbs.FieldName = "name"                      // 套餐名
-	PlanField_ClusterId                 dbs.FieldName = "clusterId"                 // 集群ID
-	PlanField_TrafficLimit              dbs.FieldName = "trafficLimit"              // 流量限制
-	PlanField_Features                  dbs.FieldName = "features"                  // 允许的功能
-	PlanField_TrafficPrice              dbs.FieldName = "trafficPrice"              // 流量价格设定
-	PlanField_BandwidthPrice            dbs.FieldName = "bandwidthPrice"            // 带宽价格
-	PlanField_MonthlyPrice              dbs.FieldName = "monthlyPrice"              // 月付
-	PlanField_SeasonallyPrice           dbs.FieldName = "seasonallyPrice"           // 季付
-	PlanField_YearlyPrice               dbs.FieldName = "yearlyPrice"               // 年付
-	PlanField_PriceType                 dbs.FieldName = "priceType"                 // 价格类型
-	PlanField_Order                     dbs.FieldName = "order"                     // 排序
-	PlanField_State                     dbs.FieldName = "state"                     // 状态
-	PlanField_TotalServers              dbs.FieldName = "totalServers"              // 可以绑定的网站数量
-	PlanField_TotalServerNamesPerServer dbs.FieldName = "totalServerNamesPerServer" // 每个网站可以绑定的域名数量
-	PlanField_TotalServerNames          dbs.FieldName = "totalServerNames"          // 总域名数量
-	PlanField_MonthlyRequests           dbs.FieldName = "monthlyRequests"           // 每月访问量额度
-	PlanField_DailyRequests             dbs.FieldName = "dailyRequests"             // 每日访问量额度
+	PlanField_Id                          dbs.FieldName = "id"                          // ID
+	PlanField_IsOn                        dbs.FieldName = "isOn"                        // 是否启用
+	PlanField_Name                        dbs.FieldName = "name"                        // 套餐名
+	PlanField_Description                 dbs.FieldName = "description"                 // 套餐简介
+	PlanField_ClusterId                   dbs.FieldName = "clusterId"                   // 集群ID
+	PlanField_TrafficLimit                dbs.FieldName = "trafficLimit"                // 流量限制
+	PlanField_BandwidthLimitPerNode       dbs.FieldName = "bandwidthLimitPerNode"       // 单节点带宽限制
+	PlanField_Features                    dbs.FieldName = "features"                    // 允许的功能
+	PlanField_HasFullFeatures             dbs.FieldName = "hasFullFeatures"             // 是否有完整的功能
+	PlanField_TrafficPrice                dbs.FieldName = "trafficPrice"                // 流量价格设定
+	PlanField_BandwidthPrice              dbs.FieldName = "bandwidthPrice"              // 带宽价格
+	PlanField_MonthlyPrice                dbs.FieldName = "monthlyPrice"                // 月付
+	PlanField_SeasonallyPrice             dbs.FieldName = "seasonallyPrice"             // 季付
+	PlanField_YearlyPrice                 dbs.FieldName = "yearlyPrice"                 // 年付
+	PlanField_PriceType                   dbs.FieldName = "priceType"                   // 价格类型
+	PlanField_Order                       dbs.FieldName = "order"                       // 排序
+	PlanField_State                       dbs.FieldName = "state"                       // 状态
+	PlanField_TotalServers                dbs.FieldName = "totalServers"                // 可以绑定的网站数量
+	PlanField_TotalServerNamesPerServer   dbs.FieldName = "totalServerNamesPerServer"   // 每个网站可以绑定的域名数量
+	PlanField_TotalServerNames            dbs.FieldName = "totalServerNames"            // 总域名数量
+	PlanField_MonthlyRequests             dbs.FieldName = "monthlyRequests"             // 每月访问量额度
+	PlanField_DailyRequests               dbs.FieldName = "dailyRequests"               // 每日访问量额度
+	PlanField_DailyWebsocketConnections   dbs.FieldName = "dailyWebsocketConnections"   // 每日Websocket连接数
+	PlanField_MonthlyWebsocketConnections dbs.FieldName = "monthlyWebsocketConnections" // 每月Websocket连接数
+	PlanField_MaxUploadSize               dbs.FieldName = "maxUploadSize"               // 最大上传
 )
 
 // Plan 用户套餐
 type Plan struct {
-	Id                        uint32   `field:"id"`                        // ID
-	IsOn                      bool     `field:"isOn"`                      // 是否启用
-	Name                      string   `field:"name"`                      // 套餐名
-	ClusterId                 uint32   `field:"clusterId"`                 // 集群ID
-	TrafficLimit              dbs.JSON `field:"trafficLimit"`              // 流量限制
-	Features                  dbs.JSON `field:"features"`                  // 允许的功能
-	TrafficPrice              dbs.JSON `field:"trafficPrice"`              // 流量价格设定
-	BandwidthPrice            dbs.JSON `field:"bandwidthPrice"`            // 带宽价格
-	MonthlyPrice              float64  `field:"monthlyPrice"`              // 月付
-	SeasonallyPrice           float64  `field:"seasonallyPrice"`           // 季付
-	YearlyPrice               float64  `field:"yearlyPrice"`               // 年付
-	PriceType                 string   `field:"priceType"`                 // 价格类型
-	Order                     uint32   `field:"order"`                     // 排序
-	State                     uint8    `field:"state"`                     // 状态
-	TotalServers              uint32   `field:"totalServers"`              // 可以绑定的网站数量
-	TotalServerNamesPerServer uint32   `field:"totalServerNamesPerServer"` // 每个网站可以绑定的域名数量
-	TotalServerNames          uint32   `field:"totalServerNames"`          // 总域名数量
-	MonthlyRequests           uint64   `field:"monthlyRequests"`           // 每月访问量额度
-	DailyRequests             uint64   `field:"dailyRequests"`             // 每日访问量额度
+	Id                          uint32   `field:"id"`                          // ID
+	IsOn                        bool     `field:"isOn"`                        // 是否启用
+	Name                        string   `field:"name"`                        // 套餐名
+	Description                 string   `field:"description"`                 // 套餐简介
+	ClusterId                   uint32   `field:"clusterId"`                   // 集群ID
+	TrafficLimit                dbs.JSON `field:"trafficLimit"`                // 流量限制
+	BandwidthLimitPerNode       dbs.JSON `field:"bandwidthLimitPerNode"`       // 单节点带宽限制
+	Features                    dbs.JSON `field:"features"`                    // 允许的功能
+	HasFullFeatures             bool     `field:"hasFullFeatures"`             // 是否有完整的功能
+	TrafficPrice                dbs.JSON `field:"trafficPrice"`                // 流量价格设定
+	BandwidthPrice              dbs.JSON `field:"bandwidthPrice"`              // 带宽价格
+	MonthlyPrice                float64  `field:"monthlyPrice"`                // 月付
+	SeasonallyPrice             float64  `field:"seasonallyPrice"`             // 季付
+	YearlyPrice                 float64  `field:"yearlyPrice"`                 // 年付
+	PriceType                   string   `field:"priceType"`                   // 价格类型
+	Order                       uint32   `field:"order"`                       // 排序
+	State                       uint8    `field:"state"`                       // 状态
+	TotalServers                uint32   `field:"totalServers"`                // 可以绑定的网站数量
+	TotalServerNamesPerServer   uint32   `field:"totalServerNamesPerServer"`   // 每个网站可以绑定的域名数量
+	TotalServerNames            uint32   `field:"totalServerNames"`            // 总域名数量
+	MonthlyRequests             uint64   `field:"monthlyRequests"`             // 每月访问量额度
+	DailyRequests               uint64   `field:"dailyRequests"`               // 每日访问量额度
+	DailyWebsocketConnections   uint64   `field:"dailyWebsocketConnections"`   // 每日Websocket连接数
+	MonthlyWebsocketConnections uint64   `field:"monthlyWebsocketConnections"` // 每月Websocket连接数
+	MaxUploadSize               dbs.JSON `field:"maxUploadSize"`               // 最大上传
 }
 
 type PlanOperator struct {
-	Id                        any // ID
-	IsOn                      any // 是否启用
-	Name                      any // 套餐名
-	ClusterId                 any // 集群ID
-	TrafficLimit              any // 流量限制
-	Features                  any // 允许的功能
-	TrafficPrice              any // 流量价格设定
-	BandwidthPrice            any // 带宽价格
-	MonthlyPrice              any // 月付
-	SeasonallyPrice           any // 季付
-	YearlyPrice               any // 年付
-	PriceType                 any // 价格类型
-	Order                     any // 排序
-	State                     any // 状态
-	TotalServers              any // 可以绑定的网站数量
-	TotalServerNamesPerServer any // 每个网站可以绑定的域名数量
-	TotalServerNames          any // 总域名数量
-	MonthlyRequests           any // 每月访问量额度
-	DailyRequests             any // 每日访问量额度
+	Id                          any // ID
+	IsOn                        any // 是否启用
+	Name                        any // 套餐名
+	Description                 any // 套餐简介
+	ClusterId                   any // 集群ID
+	TrafficLimit                any // 流量限制
+	BandwidthLimitPerNode       any // 单节点带宽限制
+	Features                    any // 允许的功能
+	HasFullFeatures             any // 是否有完整的功能
+	TrafficPrice                any // 流量价格设定
+	BandwidthPrice              any // 带宽价格
+	MonthlyPrice                any // 月付
+	SeasonallyPrice             any // 季付
+	YearlyPrice                 any // 年付
+	PriceType                   any // 价格类型
+	Order                       any // 排序
+	State                       any // 状态
+	TotalServers                any // 可以绑定的网站数量
+	TotalServerNamesPerServer   any // 每个网站可以绑定的域名数量
+	TotalServerNames            any // 总域名数量
+	MonthlyRequests             any // 每月访问量额度
+	DailyRequests               any // 每日访问量额度
+	DailyWebsocketConnections   any // 每日Websocket连接数
+	MonthlyWebsocketConnections any // 每月Websocket连接数
+	MaxUploadSize               any // 最大上传
 }
 
 func NewPlanOperator() *PlanOperator {

internal/db/models/posts/post_category_dao.go

@@ -0,0 +1,71 @@
+package posts
+
+import (
+	_ "github.com/go-sql-driver/mysql"
+	"github.com/iwind/TeaGo/Tea"
+	"github.com/iwind/TeaGo/dbs"
+)
+
+const (
+	PostCategoryStateEnabled  = 1 // 已启用
+	PostCategoryStateDisabled = 0 // 已禁用
+)
+
+type PostCategoryDAO dbs.DAO
+
+func NewPostCategoryDAO() *PostCategoryDAO {
+	return dbs.NewDAO(&PostCategoryDAO{
+		DAOObject: dbs.DAOObject{
+			DB:     Tea.Env,
+			Table:  "edgePostCategories",
+			Model:  new(PostCategory),
+			PkName: "id",
+		},
+	}).(*PostCategoryDAO)
+}
+
+var SharedPostCategoryDAO *PostCategoryDAO
+
+func init() {
+	dbs.OnReady(func() {
+		SharedPostCategoryDAO = NewPostCategoryDAO()
+	})
+}
+
+// EnablePostCategory 启用条目
+func (this *PostCategoryDAO) EnablePostCategory(tx *dbs.Tx, categoryId int64) error {
+	_, err := this.Query(tx).
+		Pk(categoryId).
+		Set("state", PostCategoryStateEnabled).
+		Update()
+	return err
+}
+
+// DisablePostCategory 禁用条目
+func (this *PostCategoryDAO) DisablePostCategory(tx *dbs.Tx, categoryId int64) error {
+	_, err := this.Query(tx).
+		Pk(categoryId).
+		Set("state", PostCategoryStateDisabled).
+		Update()
+	return err
+}
+
+// FindEnabledPostCategory 查找启用中的条目
+func (this *PostCategoryDAO) FindEnabledPostCategory(tx *dbs.Tx, categoryId int64) (*PostCategory, error) {
+	result, err := this.Query(tx).
+		Pk(categoryId).
+		State(PostCategoryStateEnabled).
+		Find()
+	if result == nil {
+		return nil, err
+	}
+	return result.(*PostCategory), err
+}
+
+// FindPostCategoryName 根据主键查找名称
+func (this *PostCategoryDAO) FindPostCategoryName(tx *dbs.Tx, categoryId int64) (string, error) {
+	return this.Query(tx).
+		Pk(categoryId).
+		Result("name").
+		FindStringCol("")
+}

internal/db/models/posts/post_category_dao_test.go

@@ -0,0 +1,6 @@
+package posts_test
+
+import (
+	_ "github.com/go-sql-driver/mysql"
+	_ "github.com/iwind/TeaGo/bootstrap"
+)

internal/db/models/posts/post_category_model.go

@@ -0,0 +1,35 @@
+package posts
+
+import "github.com/iwind/TeaGo/dbs"
+
+const (
+	PostCategoryField_Id    dbs.FieldName = "id"    // ID
+	PostCategoryField_Name  dbs.FieldName = "name"  // 分类名称
+	PostCategoryField_IsOn  dbs.FieldName = "isOn"  // 是否启用
+	PostCategoryField_Code  dbs.FieldName = "code"  // 代号
+	PostCategoryField_Order dbs.FieldName = "order" // 排序
+	PostCategoryField_State dbs.FieldName = "state" // 分类状态
+)
+
+// PostCategory 文章分类
+type PostCategory struct {
+	Id    uint32 `field:"id"`    // ID
+	Name  string `field:"name"`  // 分类名称
+	IsOn  bool   `field:"isOn"`  // 是否启用
+	Code  string `field:"code"`  // 代号
+	Order uint32 `field:"order"` // 排序
+	State uint8  `field:"state"` // 分类状态
+}
+
+type PostCategoryOperator struct {
+	Id    any // ID
+	Name  any // 分类名称
+	IsOn  any // 是否启用
+	Code  any // 代号
+	Order any // 排序
+	State any // 分类状态
+}
+
+func NewPostCategoryOperator() *PostCategoryOperator {
+	return &PostCategoryOperator{}
+}

internal/db/models/posts/post_category_model_ext.go

@@ -0,0 +1 @@
+package posts

internal/db/models/posts/post_dao.go

@@ -0,0 +1,63 @@
+package posts
+
+import (
+	_ "github.com/go-sql-driver/mysql"
+	"github.com/iwind/TeaGo/Tea"
+	"github.com/iwind/TeaGo/dbs"
+)
+
+const (
+	PostStateEnabled  = 1 // 已启用
+	PostStateDisabled = 0 // 已禁用
+)
+
+type PostDAO dbs.DAO
+
+func NewPostDAO() *PostDAO {
+	return dbs.NewDAO(&PostDAO{
+		DAOObject: dbs.DAOObject{
+			DB:     Tea.Env,
+			Table:  "edgePosts",
+			Model:  new(Post),
+			PkName: "id",
+		},
+	}).(*PostDAO)
+}
+
+var SharedPostDAO *PostDAO
+
+func init() {
+	dbs.OnReady(func() {
+		SharedPostDAO = NewPostDAO()
+	})
+}
+
+// EnablePost 启用条目
+func (this *PostDAO) EnablePost(tx *dbs.Tx, postId int64) error {
+	_, err := this.Query(tx).
+		Pk(postId).
+		Set("state", PostStateEnabled).
+		Update()
+	return err
+}
+
+// DisablePost 禁用条目
+func (this *PostDAO) DisablePost(tx *dbs.Tx, postId int64) error {
+	_, err := this.Query(tx).
+		Pk(postId).
+		Set("state", PostStateDisabled).
+		Update()
+	return err
+}
+
+// FindEnabledPost 查找启用中的条目
+func (this *PostDAO) FindEnabledPost(tx *dbs.Tx, postId int64) (*Post, error) {
+	result, err := this.Query(tx).
+		Pk(postId).
+		State(PostStateEnabled).
+		Find()
+	if result == nil {
+		return nil, err
+	}
+	return result.(*Post), err
+}

internal/db/models/posts/post_dao_test.go

@@ -0,0 +1,6 @@
+package posts_test
+
+import (
+	_ "github.com/go-sql-driver/mysql"
+	_ "github.com/iwind/TeaGo/bootstrap"
+)

internal/db/models/posts/post_model.go

@@ -0,0 +1,50 @@
+package posts
+
+import "github.com/iwind/TeaGo/dbs"
+
+const (
+	PostField_Id          dbs.FieldName = "id"          // ID
+	PostField_CategoryId  dbs.FieldName = "categoryId"  // 文章分类
+	PostField_Type        dbs.FieldName = "type"        // 类型：normal, url
+	PostField_Url         dbs.FieldName = "url"         // URL
+	PostField_Subject     dbs.FieldName = "subject"     // 标题
+	PostField_Body        dbs.FieldName = "body"        // 内容
+	PostField_CreatedAt   dbs.FieldName = "createdAt"   // 创建时间
+	PostField_IsPublished dbs.FieldName = "isPublished" // 是否已发布
+	PostField_PublishedAt dbs.FieldName = "publishedAt" // 发布时间
+	PostField_ProductCode dbs.FieldName = "productCode" // 产品代号
+	PostField_State       dbs.FieldName = "state"       // 状态
+)
+
+// Post 文章管理
+type Post struct {
+	Id          uint32 `field:"id"`          // ID
+	CategoryId  uint32 `field:"categoryId"`  // 文章分类
+	Type        string `field:"type"`        // 类型：normal, url
+	Url         string `field:"url"`         // URL
+	Subject     string `field:"subject"`     // 标题
+	Body        string `field:"body"`        // 内容
+	CreatedAt   uint64 `field:"createdAt"`   // 创建时间
+	IsPublished bool   `field:"isPublished"` // 是否已发布
+	PublishedAt uint64 `field:"publishedAt"` // 发布时间
+	ProductCode string `field:"productCode"` // 产品代号
+	State       uint8  `field:"state"`       // 状态
+}
+
+type PostOperator struct {
+	Id          any // ID
+	CategoryId  any // 文章分类
+	Type        any // 类型：normal, url
+	Url         any // URL
+	Subject     any // 标题
+	Body        any // 内容
+	CreatedAt   any // 创建时间
+	IsPublished any // 是否已发布
+	PublishedAt any // 发布时间
+	ProductCode any // 产品代号
+	State       any // 状态
+}
+
+func NewPostOperator() *PostOperator {
+	return &PostOperator{}
+}

internal/db/models/posts/post_model_ext.go

@@ -0,0 +1 @@
+package posts

internal/db/models/regions/region_country_dao.go

@@ -98,6 +98,14 @@ func (this *RegionCountryDAO) FindRegionCountryName(tx *dbs.Tx, id int64) (strin
 	return name, nil
 }
 
+// FindRegionCountryRouteCode 查找国家｜地区线路代号
+func (this *RegionCountryDAO) FindRegionCountryRouteCode(tx *dbs.Tx, countryId int64) (string, error) {
+	return this.Query(tx).
+		Attr("valueId", countryId).
+		Result("routeCode").
+		FindStringCol("")
+}
+
 // FindCountryIdWithDataId 根据数据ID查找国家
 func (this *RegionCountryDAO) FindCountryIdWithDataId(tx *dbs.Tx, dataId string) (int64, error) {
 	return this.Query(tx).

internal/db/models/regions/region_country_model.go

@@ -14,11 +14,12 @@ const (
 	RegionCountryField_DataId      dbs.FieldName = "dataId"      // 原始数据ID
 	RegionCountryField_Pinyin      dbs.FieldName = "pinyin"      // 拼音
 	RegionCountryField_IsCommon    dbs.FieldName = "isCommon"    // 是否常用
+	RegionCountryField_RouteCode   dbs.FieldName = "routeCode"   // 线路代号
 )
 
 // RegionCountry 区域-国家/地区
 type RegionCountry struct {
-	Id1          uint32   `field:"id"`          // ID
+	Id          uint32   `field:"id"`          // ID
 	ValueId     uint32   `field:"valueId"`     // 实际ID
 	ValueCode   string   `field:"valueCode"`   // 值代号
 	Name        string   `field:"name"`        // 名称
@@ -29,6 +30,7 @@ type RegionCountry struct {
 	DataId      string   `field:"dataId"`      // 原始数据ID
 	Pinyin      dbs.JSON `field:"pinyin"`      // 拼音
 	IsCommon    bool     `field:"isCommon"`    // 是否常用
+	RouteCode   string   `field:"routeCode"`   // 线路代号
 }
 
 type RegionCountryOperator struct {
@@ -43,6 +45,7 @@ type RegionCountryOperator struct {
 	DataId      any // 原始数据ID
 	Pinyin      any // 拼音
 	IsCommon    any // 是否常用
+	RouteCode   any // 线路代号
 }
 
 func NewRegionCountryOperator() *RegionCountryOperator {

internal/db/models/regions/region_province_dao.go

@@ -11,6 +11,7 @@ import (
 	"github.com/iwind/TeaGo/types"
 	"sort"
 	"strconv"
+	"strings"
 )
 
 const (
@@ -18,6 +19,8 @@ const (
 	RegionProvinceStateDisabled = 0 // 已禁用
 )
 
+var RegionProvinceSuffixes = []string{"省", "州", "区", "大区", "特区", "港", "岛", "环礁", "谷地", "山", "口岸", "郡", "县", "城", "河", "河畔", "市"}
+
 type RegionProvinceDAO dbs.DAO
 
 func NewRegionProvinceDAO() *RegionProvinceDAO {
@@ -77,6 +80,14 @@ func (this *RegionProvinceDAO) FindRegionProvinceName(tx *dbs.Tx, id int64) (str
 		FindStringCol("")
 }
 
+// FindRegionCountryId 获取省份对应的国家|地区
+func (this *RegionProvinceDAO) FindRegionCountryId(tx *dbs.Tx, provinceId int64) (int64, error) {
+	return this.Query(tx).
+		Attr("valueId", provinceId).
+		Result("countryId").
+		FindInt64Col(0)
+}
+
 // FindProvinceIdWithDataId 根据数据ID查找省份
 func (this *RegionProvinceDAO) FindProvinceIdWithDataId(tx *dbs.Tx, dataId string) (int64, error) {
 	return this.Query(tx).
@@ -87,6 +98,37 @@ func (this *RegionProvinceDAO) FindProvinceIdWithDataId(tx *dbs.Tx, dataId strin
 
 // FindProvinceIdWithName 根据省份名查找省份ID
 func (this *RegionProvinceDAO) FindProvinceIdWithName(tx *dbs.Tx, countryId int64, provinceName string) (int64, error) {
+	{
+		provinceId, err := this.findProvinceIdWithExactName(tx, countryId, provinceName)
+		if err != nil {
+			return 0, err
+		}
+		if provinceId > 0 {
+			return provinceId, nil
+		}
+	}
+
+	// 候选词
+	for _, suffix := range RegionProvinceSuffixes {
+		var name string
+		if strings.HasSuffix(provinceName, suffix) {
+			name = strings.TrimSuffix(provinceName, suffix)
+		} else {
+			name = provinceName + suffix
+		}
+		provinceId, err := this.findProvinceIdWithExactName(tx, countryId, name)
+		if err != nil {
+			return 0, err
+		}
+		if provinceId > 0 {
+			return provinceId, nil
+		}
+	}
+
+	return 0, nil
+}
+
+func (this *RegionProvinceDAO) findProvinceIdWithExactName(tx *dbs.Tx, countryId int64, provinceName string) (int64, error) {
 	return this.Query(tx).
 		Attr("countryId", countryId).
 		Where("(name=:provinceName OR customName=:provinceName OR JSON_CONTAINS(codes, :provinceNameJSON) OR JSON_CONTAINS(customCodes, :provinceNameJSON))").

internal/db/models/regions/region_province_dao_test.go

@@ -26,6 +26,25 @@ func TestRegionProvinceDAO_FindProvinceIdWithName(t *testing.T) {
 	}
 }
 
+func TestRegionProvinceDAO_FindProvinceIdWithName_Suffix(t *testing.T) {
+	dbs.NotifyReady()
+
+	var tx *dbs.Tx
+	for _, name := range []string{
+		"维埃纳",
+		"维埃纳省",
+		"维埃纳大区",
+		"维埃纳市",
+		"维埃纳小区", // expect 0
+	} {
+		provinceId, err := SharedRegionProvinceDAO.FindProvinceIdWithName(tx, 74, name)
+		if err != nil {
+			t.Fatal(err)
+		}
+		t.Log(name, "=>", provinceId)
+	}
+}
+
 func TestRegionProvinceDAO_FindSimilarProvinces(t *testing.T) {
 	dbs.NotifyReady()
 

internal/db/models/regions/region_province_model.go

@@ -12,11 +12,12 @@ const (
 	RegionProvinceField_CustomCodes dbs.FieldName = "customCodes" // 自定义代号
 	RegionProvinceField_State       dbs.FieldName = "state"       // 状态
 	RegionProvinceField_DataId      dbs.FieldName = "dataId"      // 原始数据ID
+	RegionProvinceField_RouteCode   dbs.FieldName = "routeCode"   // 线路代号
 )
 
 // RegionProvince 区域-省份
 type RegionProvince struct {
-	Id1          uint32   `field:"id"`          // ID
+	Id          uint32   `field:"id"`          // ID
 	ValueId     uint32   `field:"valueId"`     // 实际ID
 	CountryId   uint32   `field:"countryId"`   // 国家ID
 	Name        string   `field:"name"`        // 名称
@@ -25,6 +26,7 @@ type RegionProvince struct {
 	CustomCodes dbs.JSON `field:"customCodes"` // 自定义代号
 	State       uint8    `field:"state"`       // 状态
 	DataId      string   `field:"dataId"`      // 原始数据ID
+	RouteCode   string   `field:"routeCode"`   // 线路代号
 }
 
 type RegionProvinceOperator struct {
@@ -37,6 +39,7 @@ type RegionProvinceOperator struct {
 	CustomCodes any // 自定义代号
 	State       any // 状态
 	DataId      any // 原始数据ID
+	RouteCode   any // 线路代号
 }
 
 func NewRegionProvinceOperator() *RegionProvinceOperator {

internal/db/models/reverse_proxy_dao.go

@@ -376,14 +376,14 @@ func (this *ReverseProxyDAO) UpdateReverseProxyScheduling(tx *dbs.Tx, reversePro
 }
 
 // UpdateReverseProxyPrimaryOrigins 修改主要源站
-func (this *ReverseProxyDAO) UpdateReverseProxyPrimaryOrigins(tx *dbs.Tx, reverseProxyId int64, origins []byte) error {
+func (this *ReverseProxyDAO) UpdateReverseProxyPrimaryOrigins(tx *dbs.Tx, reverseProxyId int64, originRefs []byte) error {
 	if reverseProxyId <= 0 {
 		return errors.New("invalid reverseProxyId")
 	}
 	var op = NewReverseProxyOperator()
 	op.Id = reverseProxyId
-	if len(origins) > 0 {
-		op.PrimaryOrigins = origins
+	if len(originRefs) > 0 {
+		op.PrimaryOrigins = originRefs
 	} else {
 		op.PrimaryOrigins = "[]"
 	}

internal/db/models/reverse_proxy_model_ext.go

@@ -1 +1,31 @@
 package models
+
+import (
+	"encoding/json"
+	"github.com/TeaOSLab/EdgeCommon/pkg/serverconfigs"
+	"github.com/iwind/TeaGo/logs"
+)
+
+// DecodePrimaryOrigins 解析主要源站
+func (this *ReverseProxy) DecodePrimaryOrigins() []*serverconfigs.OriginRef {
+	var refs = []*serverconfigs.OriginRef{}
+	if IsNotNull(this.PrimaryOrigins) {
+		err := json.Unmarshal(this.PrimaryOrigins, &refs)
+		if err != nil {
+			logs.Error(err)
+		}
+	}
+	return refs
+}
+
+// DecodeBackupOrigins 解析备用源站
+func (this *ReverseProxy) DecodeBackupOrigins() []*serverconfigs.OriginRef {
+	var refs = []*serverconfigs.OriginRef{}
+	if IsNotNull(this.BackupOrigins) {
+		err := json.Unmarshal(this.BackupOrigins, &refs)
+		if err != nil {
+			logs.Error(err)
+		}
+	}
+	return refs
+}

internal/db/models/server_dao.go

@@ -757,14 +757,14 @@ func (this *ServerDAO) UpdateServerAuditing(tx *dbs.Tx, serverId int64, result *
 	return this.NotifyDNSUpdate(tx, serverId)
 }
 
-// UpdateServerReverseProxy 修改反向代理配置
-func (this *ServerDAO) UpdateServerReverseProxy(tx *dbs.Tx, serverId int64, config []byte) error {
+// UpdateServerReverseProxyRef 修改反向代理配置
+func (this *ServerDAO) UpdateServerReverseProxyRef(tx *dbs.Tx, serverId int64, reverseProxyRefJSON []byte) error {
 	if serverId <= 0 {
 		return errors.New("serverId should not be smaller than 0")
 	}
 	var op = NewServerOperator()
 	op.Id = serverId
-	op.ReverseProxy = JSONBytes(config)
+	op.ReverseProxy = JSONBytes(reverseProxyRefJSON)
 	err := this.Save(tx, op)
 	if err != nil {
 		return err
@@ -773,6 +773,28 @@ func (this *ServerDAO) UpdateServerReverseProxy(tx *dbs.Tx, serverId int64, conf
 	return this.NotifyUpdate(tx, serverId)
 }
 
+// CreateServerReverseProxyRef 创建反向代理配置
+func (this *ServerDAO) CreateServerReverseProxyRef(tx *dbs.Tx, userId int64, serverId int64) (reverseProxyId int64, err error) {
+	reverseProxyId, err = SharedReverseProxyDAO.CreateReverseProxy(tx, 0, userId, nil, []byte("[]"), []byte("[]"))
+	if err != nil {
+		return 0, err
+	}
+	var reverseProxyRef = &serverconfigs.ReverseProxyRef{
+		IsPrior:        false,
+		IsOn:           true,
+		ReverseProxyId: reverseProxyId,
+	}
+	reverseProxyRefJSON, err := json.Marshal(reverseProxyRef)
+	if err != nil {
+		return 0, err
+	}
+	err = this.UpdateServerReverseProxyRef(tx, serverId, reverseProxyRefJSON)
+	if err != nil {
+		return 0, err
+	}
+	return reverseProxyId, nil
+}
+
 // CountAllEnabledServers 计算所有可用服务数量
 func (this *ServerDAO) CountAllEnabledServers(tx *dbs.Tx) (int64, error) {
 	return this.Query(tx).
@@ -1322,28 +1344,10 @@ func (this *ServerDAO) ComposeServerConfig(tx *dbs.Tx, server *Server, ignoreCer
 			}
 
 			// 套餐是否依然有效
-			plan, err := SharedPlanDAO.FindEnabledPlan(tx, int64(userPlan.PlanId), cacheMap)
-			if err != nil {
-				return nil, err
-			}
-			if plan != nil {
-				config.UserPlan = &serverconfigs.UserPlanConfig{
-					Id:    int64(userPlan.Id),
-					DayTo: userPlan.DayTo,
-					Plan: &serverconfigs.PlanConfig{
-						Id:   int64(plan.Id),
-						Name: plan.Name,
-					},
-				}
-
-				if len(plan.TrafficLimit) > 0 && (config.TrafficLimit == nil || !config.TrafficLimit.IsOn) {
-					var trafficLimitConfig = &serverconfigs.TrafficLimitConfig{}
-					err = json.Unmarshal(plan.TrafficLimit, trafficLimitConfig)
-					if err != nil {
-						return nil, err
-					}
-					config.TrafficLimit = trafficLimitConfig
-				}
+			config.UserPlan = &serverconfigs.UserPlanConfig{
+				Id:     int64(userPlan.Id),
+				DayTo:  userPlan.DayTo,
+				PlanId: int64(userPlan.PlanId),
 			}
 		}
 	}
@@ -1380,8 +1384,8 @@ func (this *ServerDAO) ComposeServerConfig(tx *dbs.Tx, server *Server, ignoreCer
 	return config, nil
 }
 
-// FindReverseProxyRef 根据条件获取反向代理配置
-func (this *ServerDAO) FindReverseProxyRef(tx *dbs.Tx, serverId int64) (*serverconfigs.ReverseProxyRef, error) {
+// FindServerReverseProxyRef 根据条件获取反向代理配置
+func (this *ServerDAO) FindServerReverseProxyRef(tx *dbs.Tx, serverId int64) (*serverconfigs.ReverseProxyRef, error) {
 	reverseProxy, err := this.Query(tx).
 		Pk(serverId).
 		Result("reverseProxy").
@@ -1392,7 +1396,7 @@ func (this *ServerDAO) FindReverseProxyRef(tx *dbs.Tx, serverId int64) (*serverc
 	if len(reverseProxy) == 0 || reverseProxy == "null" {
 		return nil, nil
 	}
-	config := &serverconfigs.ReverseProxyRef{}
+	var config = &serverconfigs.ReverseProxyRef{}
 	err = json.Unmarshal([]byte(reverseProxy), config)
 	return config, err
 }
@@ -2358,8 +2362,36 @@ func (this *ServerDAO) UpdateServerTrafficLimitConfig(tx *dbs.Tx, serverId int64
 
 // RenewServerTrafficLimitStatus 根据限流配置更新网站的流量限制状态
 func (this *ServerDAO) RenewServerTrafficLimitStatus(tx *dbs.Tx, trafficLimitConfig *serverconfigs.TrafficLimitConfig, serverId int64, isUpdatingConfig bool) error {
+	if serverId <= 0 {
+		return nil
+	}
+
 	if !trafficLimitConfig.IsOn {
 		if isUpdatingConfig {
+			var oldStatus = &serverconfigs.TrafficLimitStatus{}
+			trafficLimitStatus, err := this.Query(tx).
+				Pk(serverId).
+				Result("trafficLimitStatus").
+				FindJSONCol()
+			if err != nil {
+				return err
+			}
+			if IsNotNull(trafficLimitStatus) {
+				err = json.Unmarshal(trafficLimitStatus, oldStatus)
+				if err != nil {
+					return err
+				}
+				if oldStatus.PlanId == 0 /** 说明是网站自行设置的限制 **/ {
+					err = this.Query(tx).
+						Pk(serverId).
+						Set("trafficLimitStatus", dbs.SQL("NULL")).
+						UpdateQuickly()
+					if err != nil {
+						return err
+					}
+				}
+			}
+
 			return this.NotifyUpdate(tx, serverId)
 		}
 		return nil
@@ -2470,7 +2502,9 @@ func (this *ServerDAO) UpdateServerTrafficLimitStatus(tx *dbs.Tx, serverId int64
 		if err != nil {
 			return err
 		}
-		if len(oldStatus.UntilDay) > 0 && oldStatus.UntilDay >= day /** 如果已经限制，且比当前日期长，则无需重复 **/ {
+		if len(oldStatus.UntilDay) > 0 &&
+			oldStatus.UntilDay >= day /** 如果已经限制，且比当前日期长，则无需重复 **/ &&
+			oldStatus.PlanId == planId /** 套餐无变化 **/ {
 			// no need to change
 			return nil
 		}
@@ -2986,6 +3020,17 @@ func (this *ServerDAO) CheckServerPlanQuota(tx *dbs.Tx, serverId int64, countSer
 	return nil
 }
 
+// ExistsServer 检查网站是否存在
+func (this *ServerDAO) ExistsServer(tx *dbs.Tx, serverId int64) (bool, error) {
+	if serverId <= 0 {
+		return false, nil
+	}
+	return this.Query(tx).
+		Pk(serverId).
+		State(ServerStateEnabled).
+		Exist()
+}
+
 // NotifyUpdate 同步服务所在的集群
 func (this *ServerDAO) NotifyUpdate(tx *dbs.Tx, serverId int64) error {
 	if serverId <= 0 {

internal/db/models/sys_setting_dao.go

@@ -177,10 +177,10 @@ func (this *SysSettingDAO) ReadUserUIConfig(tx *dbs.Tx) (*systemconfigs.UserUICo
 		return nil, err
 	}
 	if len(valueJSON) == 0 {
-		return systemconfigs.DefaultUserUIConfig(), nil
+		return systemconfigs.NewUserUIConfig(), nil
 	}
 
-	var config = systemconfigs.DefaultUserUIConfig()
+	var config = systemconfigs.NewUserUIConfig()
 	err = json.Unmarshal(valueJSON, config)
 	if err != nil {
 		return nil, err

internal/db/models/user_plan_bandwidth_stat_dao.go

@@ -59,7 +59,7 @@ func init() {
 
 // UpdateUserPlanBandwidth 写入数据
 // 暂时不使用region区分
-func (this *UserPlanBandwidthStatDAO) UpdateUserPlanBandwidth(tx *dbs.Tx, userId int64, userPlanId int64, regionId int64, day string, timeAt string, bandwidthBytes int64, totalBytes int64, cachedBytes int64, attackBytes int64, countRequests int64, countCachedRequests int64, countAttackRequests int64) error {
+func (this *UserPlanBandwidthStatDAO) UpdateUserPlanBandwidth(tx *dbs.Tx, userId int64, userPlanId int64, regionId int64, day string, timeAt string, bandwidthBytes int64, totalBytes int64, cachedBytes int64, attackBytes int64, countRequests int64, countCachedRequests int64, countAttackRequests int64, countWebsocketConnections int64) error {
 	if userId <= 0 || userPlanId <= 0 {
 		return nil
 	}
@@ -73,29 +73,32 @@ func (this *UserPlanBandwidthStatDAO) UpdateUserPlanBandwidth(tx *dbs.Tx, userId
 		Param("countRequests", countRequests).
 		Param("countCachedRequests", countCachedRequests).
 		Param("countAttackRequests", countAttackRequests).
+		Param("countWebsocketConnections", countWebsocketConnections).
 		InsertOrUpdateQuickly(maps.Map{
-			"userId":              userId,
-			"userPlanId":          userPlanId,
-			"regionId":            regionId,
-			"day":                 day,
-			"timeAt":              timeAt,
-			"bytes":               bandwidthBytes,
-			"totalBytes":          totalBytes,
-			"avgBytes":            totalBytes / 300,
-			"cachedBytes":         cachedBytes,
-			"attackBytes":         attackBytes,
-			"countRequests":       countRequests,
-			"countCachedRequests": countCachedRequests,
-			"countAttackRequests": countAttackRequests,
+			"userId":                    userId,
+			"userPlanId":                userPlanId,
+			"regionId":                  regionId,
+			"day":                       day,
+			"timeAt":                    timeAt,
+			"bytes":                     bandwidthBytes,
+			"totalBytes":                totalBytes,
+			"avgBytes":                  totalBytes / 300,
+			"cachedBytes":               cachedBytes,
+			"attackBytes":               attackBytes,
+			"countRequests":             countRequests,
+			"countCachedRequests":       countCachedRequests,
+			"countAttackRequests":       countAttackRequests,
+			"countWebsocketConnections": countWebsocketConnections,
 		}, maps.Map{
-			"bytes":               dbs.SQL("bytes+:bytes"),
-			"avgBytes":            dbs.SQL("(totalBytes+:totalBytes)/300"), // 因为生成SQL语句时会自动将avgBytes排在totalBytes之前，所以这里不用担心先后顺序的问题
-			"totalBytes":          dbs.SQL("totalBytes+:totalBytes"),
-			"cachedBytes":         dbs.SQL("cachedBytes+:cachedBytes"),
-			"attackBytes":         dbs.SQL("attackBytes+:attackBytes"),
-			"countRequests":       dbs.SQL("countRequests+:countRequests"),
-			"countCachedRequests": dbs.SQL("countCachedRequests+:countCachedRequests"),
-			"countAttackRequests": dbs.SQL("countAttackRequests+:countAttackRequests"),
+			"bytes":                     dbs.SQL("bytes+:bytes"),
+			"avgBytes":                  dbs.SQL("(totalBytes+:totalBytes)/300"), // 因为生成SQL语句时会自动将avgBytes排在totalBytes之前，所以这里不用担心先后顺序的问题
+			"totalBytes":                dbs.SQL("totalBytes+:totalBytes"),
+			"cachedBytes":               dbs.SQL("cachedBytes+:cachedBytes"),
+			"attackBytes":               dbs.SQL("attackBytes+:attackBytes"),
+			"countRequests":             dbs.SQL("countRequests+:countRequests"),
+			"countCachedRequests":       dbs.SQL("countCachedRequests+:countCachedRequests"),
+			"countAttackRequests":       dbs.SQL("countAttackRequests+:countAttackRequests"),
+			"countWebsocketConnections": dbs.SQL("countWebsocketConnections+:countWebsocketConnections"),
 		})
 }
 

internal/db/models/user_plan_bandwidth_stat_model.go

@@ -3,55 +3,58 @@ package models
 import "github.com/iwind/TeaGo/dbs"
 
 const (
-	UserPlanBandwidthStatField_Id                  dbs.FieldName = "id"                  // ID
-	UserPlanBandwidthStatField_UserId              dbs.FieldName = "userId"              // 用户ID
-	UserPlanBandwidthStatField_UserPlanId          dbs.FieldName = "userPlanId"          // 用户套餐ID
-	UserPlanBandwidthStatField_Day                 dbs.FieldName = "day"                 // 日期YYYYMMDD
-	UserPlanBandwidthStatField_TimeAt              dbs.FieldName = "timeAt"              // 时间点HHII
-	UserPlanBandwidthStatField_Bytes               dbs.FieldName = "bytes"               // 带宽
-	UserPlanBandwidthStatField_RegionId            dbs.FieldName = "regionId"            // 区域ID
-	UserPlanBandwidthStatField_TotalBytes          dbs.FieldName = "totalBytes"          // 总流量
-	UserPlanBandwidthStatField_AvgBytes            dbs.FieldName = "avgBytes"            // 平均流量
-	UserPlanBandwidthStatField_CachedBytes         dbs.FieldName = "cachedBytes"         // 缓存的流量
-	UserPlanBandwidthStatField_AttackBytes         dbs.FieldName = "attackBytes"         // 攻击流量
-	UserPlanBandwidthStatField_CountRequests       dbs.FieldName = "countRequests"       // 请求数
-	UserPlanBandwidthStatField_CountCachedRequests dbs.FieldName = "countCachedRequests" // 缓存的请求数
-	UserPlanBandwidthStatField_CountAttackRequests dbs.FieldName = "countAttackRequests" // 攻击请求数
+	UserPlanBandwidthStatField_Id                        dbs.FieldName = "id"                        // ID
+	UserPlanBandwidthStatField_UserId                    dbs.FieldName = "userId"                    // 用户ID
+	UserPlanBandwidthStatField_UserPlanId                dbs.FieldName = "userPlanId"                // 用户套餐ID
+	UserPlanBandwidthStatField_Day                       dbs.FieldName = "day"                       // 日期YYYYMMDD
+	UserPlanBandwidthStatField_TimeAt                    dbs.FieldName = "timeAt"                    // 时间点HHII
+	UserPlanBandwidthStatField_Bytes                     dbs.FieldName = "bytes"                     // 带宽
+	UserPlanBandwidthStatField_RegionId                  dbs.FieldName = "regionId"                  // 区域ID
+	UserPlanBandwidthStatField_TotalBytes                dbs.FieldName = "totalBytes"                // 总流量
+	UserPlanBandwidthStatField_AvgBytes                  dbs.FieldName = "avgBytes"                  // 平均流量
+	UserPlanBandwidthStatField_CachedBytes               dbs.FieldName = "cachedBytes"               // 缓存的流量
+	UserPlanBandwidthStatField_AttackBytes               dbs.FieldName = "attackBytes"               // 攻击流量
+	UserPlanBandwidthStatField_CountRequests             dbs.FieldName = "countRequests"             // 请求数
+	UserPlanBandwidthStatField_CountCachedRequests       dbs.FieldName = "countCachedRequests"       // 缓存的请求数
+	UserPlanBandwidthStatField_CountAttackRequests       dbs.FieldName = "countAttackRequests"       // 攻击请求数
+	UserPlanBandwidthStatField_CountWebsocketConnections dbs.FieldName = "countWebsocketConnections" // Websocket连接数
 )
 
 // UserPlanBandwidthStat 用户套餐带宽峰值
 type UserPlanBandwidthStat struct {
-	Id                  uint64 `field:"id"`                  // ID
-	UserId              uint64 `field:"userId"`              // 用户ID
-	UserPlanId          uint64 `field:"userPlanId"`          // 用户套餐ID
-	Day                 string `field:"day"`                 // 日期YYYYMMDD
-	TimeAt              string `field:"timeAt"`              // 时间点HHII
-	Bytes               uint64 `field:"bytes"`               // 带宽
-	RegionId            uint32 `field:"regionId"`            // 区域ID
-	TotalBytes          uint64 `field:"totalBytes"`          // 总流量
-	AvgBytes            uint64 `field:"avgBytes"`            // 平均流量
-	CachedBytes         uint64 `field:"cachedBytes"`         // 缓存的流量
-	AttackBytes         uint64 `field:"attackBytes"`         // 攻击流量
-	CountRequests       uint64 `field:"countRequests"`       // 请求数
-	CountCachedRequests uint64 `field:"countCachedRequests"` // 缓存的请求数
-	CountAttackRequests uint64 `field:"countAttackRequests"` // 攻击请求数
+	Id                        uint64 `field:"id"`                        // ID
+	UserId                    uint64 `field:"userId"`                    // 用户ID
+	UserPlanId                uint64 `field:"userPlanId"`                // 用户套餐ID
+	Day                       string `field:"day"`                       // 日期YYYYMMDD
+	TimeAt                    string `field:"timeAt"`                    // 时间点HHII
+	Bytes                     uint64 `field:"bytes"`                     // 带宽
+	RegionId                  uint32 `field:"regionId"`                  // 区域ID
+	TotalBytes                uint64 `field:"totalBytes"`                // 总流量
+	AvgBytes                  uint64 `field:"avgBytes"`                  // 平均流量
+	CachedBytes               uint64 `field:"cachedBytes"`               // 缓存的流量
+	AttackBytes               uint64 `field:"attackBytes"`               // 攻击流量
+	CountRequests             uint64 `field:"countRequests"`             // 请求数
+	CountCachedRequests       uint64 `field:"countCachedRequests"`       // 缓存的请求数
+	CountAttackRequests       uint64 `field:"countAttackRequests"`       // 攻击请求数
+	CountWebsocketConnections uint64 `field:"countWebsocketConnections"` // Websocket连接数
 }
 
 type UserPlanBandwidthStatOperator struct {
-	Id                  any // ID
-	UserId              any // 用户ID
-	UserPlanId          any // 用户套餐ID
-	Day                 any // 日期YYYYMMDD
-	TimeAt              any // 时间点HHII
-	Bytes               any // 带宽
-	RegionId            any // 区域ID
-	TotalBytes          any // 总流量
-	AvgBytes            any // 平均流量
-	CachedBytes         any // 缓存的流量
-	AttackBytes         any // 攻击流量
-	CountRequests       any // 请求数
-	CountCachedRequests any // 缓存的请求数
-	CountAttackRequests any // 攻击请求数
+	Id                        any // ID
+	UserId                    any // 用户ID
+	UserPlanId                any // 用户套餐ID
+	Day                       any // 日期YYYYMMDD
+	TimeAt                    any // 时间点HHII
+	Bytes                     any // 带宽
+	RegionId                  any // 区域ID
+	TotalBytes                any // 总流量
+	AvgBytes                  any // 平均流量
+	CachedBytes               any // 缓存的流量
+	AttackBytes               any // 攻击流量
+	CountRequests             any // 请求数
+	CountCachedRequests       any // 缓存的请求数
+	CountAttackRequests       any // 攻击请求数
+	CountWebsocketConnections any // Websocket连接数
 }
 
 func NewUserPlanBandwidthStatOperator() *UserPlanBandwidthStatOperator {

internal/db/models/user_plan_stat_dao_community.go

@@ -5,6 +5,6 @@ package models
 
 import "github.com/iwind/TeaGo/dbs"
 
-func (this *UserPlanStatDAO) IncreaseUserPlanStat(tx *dbs.Tx, userPlanId int64, trafficBytes int64, countRequests int64) error {
+func (this *UserPlanStatDAO) IncreaseUserPlanStat(tx *dbs.Tx, userPlanId int64, trafficBytes int64, countRequests int64, countWebsocketConnections int64) error {
 	return nil
 }

internal/db/models/user_plan_stat_model.go

@@ -3,34 +3,37 @@ package models
 import "github.com/iwind/TeaGo/dbs"
 
 const (
-	UserPlanStatField_Id            dbs.FieldName = "id"            // ID
-	UserPlanStatField_UserPlanId    dbs.FieldName = "userPlanId"    // 用户套餐ID
-	UserPlanStatField_Date          dbs.FieldName = "date"          // 日期：YYYYMMDD或YYYYMM
-	UserPlanStatField_DateType      dbs.FieldName = "dateType"      // 日期类型：day|month
-	UserPlanStatField_TrafficBytes  dbs.FieldName = "trafficBytes"  // 流量
-	UserPlanStatField_CountRequests dbs.FieldName = "countRequests" // 总请求数
-	UserPlanStatField_IsProcessed   dbs.FieldName = "isProcessed"   // 是否已处理
+	UserPlanStatField_Id                        dbs.FieldName = "id"                        // ID
+	UserPlanStatField_UserPlanId                dbs.FieldName = "userPlanId"                // 用户套餐ID
+	UserPlanStatField_Date                      dbs.FieldName = "date"                      // 日期：YYYYMMDD或YYYYMM
+	UserPlanStatField_DateType                  dbs.FieldName = "dateType"                  // 日期类型：day|month
+	UserPlanStatField_TrafficBytes              dbs.FieldName = "trafficBytes"              // 流量
+	UserPlanStatField_CountRequests             dbs.FieldName = "countRequests"             // 总请求数
+	UserPlanStatField_CountWebsocketConnections dbs.FieldName = "countWebsocketConnections" // Websocket连接数
+	UserPlanStatField_IsProcessed               dbs.FieldName = "isProcessed"               // 是否已处理
 )
 
 // UserPlanStat 用户套餐统计
 type UserPlanStat struct {
-	Id            uint64 `field:"id"`            // ID
-	UserPlanId    uint64 `field:"userPlanId"`    // 用户套餐ID
-	Date          string `field:"date"`          // 日期：YYYYMMDD或YYYYMM
-	DateType      string `field:"dateType"`      // 日期类型：day|month
-	TrafficBytes  uint64 `field:"trafficBytes"`  // 流量
-	CountRequests uint64 `field:"countRequests"` // 总请求数
-	IsProcessed   bool   `field:"isProcessed"`   // 是否已处理
+	Id                        uint64 `field:"id"`                        // ID
+	UserPlanId                uint64 `field:"userPlanId"`                // 用户套餐ID
+	Date                      string `field:"date"`                      // 日期：YYYYMMDD或YYYYMM
+	DateType                  string `field:"dateType"`                  // 日期类型：day|month
+	TrafficBytes              uint64 `field:"trafficBytes"`              // 流量
+	CountRequests             uint64 `field:"countRequests"`             // 总请求数
+	CountWebsocketConnections uint64 `field:"countWebsocketConnections"` // Websocket连接数
+	IsProcessed               bool   `field:"isProcessed"`               // 是否已处理
 }
 
 type UserPlanStatOperator struct {
-	Id            any // ID
-	UserPlanId    any // 用户套餐ID
-	Date          any // 日期：YYYYMMDD或YYYYMM
-	DateType      any // 日期类型：day|month
-	TrafficBytes  any // 流量
-	CountRequests any // 总请求数
-	IsProcessed   any // 是否已处理
+	Id                        any // ID
+	UserPlanId                any // 用户套餐ID
+	Date                      any // 日期：YYYYMMDD或YYYYMM
+	DateType                  any // 日期类型：day|month
+	TrafficBytes              any // 流量
+	CountRequests             any // 总请求数
+	CountWebsocketConnections any // Websocket连接数
+	IsProcessed               any // 是否已处理
 }
 
 func NewUserPlanStatOperator() *UserPlanStatOperator {

internal/db/models/user_script_dao.go

@@ -0,0 +1,33 @@
+package models
+
+import (
+	_ "github.com/go-sql-driver/mysql"
+	"github.com/iwind/TeaGo/Tea"
+	"github.com/iwind/TeaGo/dbs"
+)
+
+const (
+	UserScriptStateEnabled  = 1 // 已启用
+	UserScriptStateDisabled = 0 // 已禁用
+)
+
+type UserScriptDAO dbs.DAO
+
+func NewUserScriptDAO() *UserScriptDAO {
+	return dbs.NewDAO(&UserScriptDAO{
+		DAOObject: dbs.DAOObject{
+			DB:     Tea.Env,
+			Table:  "edgeUserScripts",
+			Model:  new(UserScript),
+			PkName: "id",
+		},
+	}).(*UserScriptDAO)
+}
+
+var SharedUserScriptDAO *UserScriptDAO
+
+func init() {
+	dbs.OnReady(func() {
+		SharedUserScriptDAO = NewUserScriptDAO()
+	})
+}

internal/db/models/user_script_dao_test.go

@@ -0,0 +1,6 @@
+package models_test
+
+import (
+	_ "github.com/go-sql-driver/mysql"
+	_ "github.com/iwind/TeaGo/bootstrap"
+)

internal/db/models/user_script_model.go

@@ -0,0 +1,56 @@
+package models
+
+import "github.com/iwind/TeaGo/dbs"
+
+const (
+	UserScriptField_Id             dbs.FieldName = "id"             // ID
+	UserScriptField_UserId         dbs.FieldName = "userId"         // 用户ID
+	UserScriptField_AdminId        dbs.FieldName = "adminId"        // 操作管理员
+	UserScriptField_Code           dbs.FieldName = "code"           // 代码
+	UserScriptField_CodeMD5        dbs.FieldName = "codeMD5"        // 代码MD5
+	UserScriptField_CreatedAt      dbs.FieldName = "createdAt"      // 创建时间
+	UserScriptField_IsRejected     dbs.FieldName = "isRejected"     // 是否已驳回
+	UserScriptField_RejectedAt     dbs.FieldName = "rejectedAt"     // 驳回时间
+	UserScriptField_RejectedReason dbs.FieldName = "rejectedReason" // 驳回原因
+	UserScriptField_IsPassed       dbs.FieldName = "isPassed"       // 是否通过审核
+	UserScriptField_PassedAt       dbs.FieldName = "passedAt"       // 通过时间
+	UserScriptField_State          dbs.FieldName = "state"          // 状态
+	UserScriptField_WebIds         dbs.FieldName = "webIds"         // WebId列表
+)
+
+// UserScript 用户脚本审核
+type UserScript struct {
+	Id             uint64   `field:"id"`             // ID
+	UserId         uint64   `field:"userId"`         // 用户ID
+	AdminId        uint64   `field:"adminId"`        // 操作管理员
+	Code           string   `field:"code"`           // 代码
+	CodeMD5        string   `field:"codeMD5"`        // 代码MD5
+	CreatedAt      uint64   `field:"createdAt"`      // 创建时间
+	IsRejected     bool     `field:"isRejected"`     // 是否已驳回
+	RejectedAt     uint64   `field:"rejectedAt"`     // 驳回时间
+	RejectedReason string   `field:"rejectedReason"` // 驳回原因
+	IsPassed       bool     `field:"isPassed"`       // 是否通过审核
+	PassedAt       uint64   `field:"passedAt"`       // 通过时间
+	State          uint8    `field:"state"`          // 状态
+	WebIds         dbs.JSON `field:"webIds"`         // WebId列表
+}
+
+type UserScriptOperator struct {
+	Id             any // ID
+	UserId         any // 用户ID
+	AdminId        any // 操作管理员
+	Code           any // 代码
+	CodeMD5        any // 代码MD5
+	CreatedAt      any // 创建时间
+	IsRejected     any // 是否已驳回
+	RejectedAt     any // 驳回时间
+	RejectedReason any // 驳回原因
+	IsPassed       any // 是否通过审核
+	PassedAt       any // 通过时间
+	State          any // 状态
+	WebIds         any // WebId列表
+}
+
+func NewUserScriptOperator() *UserScriptOperator {
+	return &UserScriptOperator{}
+}

internal/db/models/user_script_model_ext.go

@@ -0,0 +1 @@
+package models

internal/db/models/utils.go

@@ -1,6 +1,7 @@
 package models
 
 import (
+	"errors"
 	"github.com/go-sql-driver/mysql"
 	"github.com/iwind/TeaGo/dbs"
 	"github.com/iwind/TeaGo/types"
@@ -60,8 +61,8 @@ func CheckSQLErrCode(err error, code uint16) bool {
 	}
 
 	// 快速判断错误方法
-	mysqlErr, ok := err.(*mysql.MySQLError)
-	if ok && mysqlErr.Number == code { // Error 1050: Table 'xxx' already exists
+	var mysqlErr *mysql.MySQLError
+	if errors.As(err, &mysqlErr) && mysqlErr.Number == code { // Error 1050: Table 'xxx' already exists
 		return true
 	}
 
@@ -86,6 +87,6 @@ func IsMySQLError(err error) bool {
 	if err == nil {
 		return false
 	}
-	_, ok := err.(*mysql.MySQLError)
-	return ok
+	var mysqlErr *mysql.MySQLError
+	return errors.As(err, &mysqlErr)
 }

internal/db/models/utils_test.go

@@ -0,0 +1,39 @@
+// Copyright 2024 GoEdge CDN goedge.cdn@gmail.com. All rights reserved. Official site: https://goedge.cn .
+
+package models_test
+
+import (
+	"errors"
+	"github.com/TeaOSLab/EdgeAPI/internal/db/models"
+	"github.com/iwind/TeaGo/assert"
+	"github.com/iwind/TeaGo/dbs"
+	"testing"
+)
+
+func TestIsMySQLError(t *testing.T) {
+	var a = assert.NewAssertion(t)
+
+	{
+		var err error
+		a.IsFalse(models.IsMySQLError(err))
+	}
+
+	{
+		var err = errors.New("hello")
+		a.IsFalse(models.IsMySQLError(err))
+	}
+
+	{
+		db, err := dbs.Default()
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer func() {
+			_ = db.Close()
+		}()
+		_, err = db.Exec("SELECT abc")
+		a.IsTrue(models.IsMySQLError(err))
+		a.IsTrue(models.CheckSQLErrCode(err, 1054))
+		a.IsFalse(models.CheckSQLErrCode(err, 1000))
+	}
+}

internal/dnsclients/provider_alidns.go

@@ -42,6 +42,14 @@ func (this *AliDNSProvider) Auth(params maps.Map) error {
 	return nil
 }
 
+// MaskParams 对参数进行掩码
+func (this *AliDNSProvider) MaskParams(params maps.Map) {
+	if params == nil {
+		return
+	}
+	params["accessKeySecret"] = MaskString(params.GetString("accessKeySecret"))
+}
+
 // GetDomains 获取所有域名列表
 func (this *AliDNSProvider) GetDomains() (domains []string, err error) {
 	var pageNumber = 1
@@ -128,7 +136,7 @@ func (this *AliDNSProvider) GetRoutes(domain string) (routes []*dnstypes.Route,
 	}
 	for _, line := range resp.RecordLines.RecordLine {
 		routes = append(routes, &dnstypes.Route{
-			Name: line.LineName,
+			Name: line.LineDisplayName,
 			Code: line.LineCode,
 		})
 	}

internal/dnsclients/provider_cloud_flare.go

@@ -66,6 +66,14 @@ func (this *CloudFlareProvider) Auth(params maps.Map) error {
 	return nil
 }
 
+// MaskParams 对参数进行掩码
+func (this *CloudFlareProvider) MaskParams(params maps.Map) {
+	if params == nil {
+		return
+	}
+	params["apiKey"] = MaskString(params.GetString("apiKey"))
+}
+
 // GetDomains 获取所有域名列表
 func (this *CloudFlareProvider) GetDomains() (domains []string, err error) {
 	for page := 1; page <= 500; page++ {

internal/dnsclients/provider_custom_http.go

@@ -53,6 +53,11 @@ func (this *CustomHTTPProvider) Auth(params maps.Map) error {
 	return nil
 }
 
+// MaskParams 对参数进行掩码
+func (this *CustomHTTPProvider) MaskParams(params maps.Map) {
+	// 这里暂时不要掩码，避免用户忘记
+}
+
 // GetDomains 获取所有域名列表
 func (this *CustomHTTPProvider) GetDomains() (domains []string, err error) {
 	resp, err := this.post(maps.Map{

internal/dnsclients/provider_dnspod.go

@@ -69,6 +69,19 @@ func (this *DNSPodProvider) Auth(params maps.Map) error {
 	return nil
 }
 
+// MaskParams 对参数进行掩码
+func (this *DNSPodProvider) MaskParams(params maps.Map) {
+	if params == nil {
+		return
+	}
+
+	if params.GetString("apiType") == "tencentDNS" {
+		params["accessKeySecret"] = MaskString(params.GetString("accessKeySecret"))
+	} else {
+		params["token"] = MaskString(params.GetString("token"))
+	}
+}
+
 // GetDomains 获取所有域名列表
 func (this *DNSPodProvider) GetDomains() (domains []string, err error) {
 	if this.tencentDNSProvider != nil {

internal/dnsclients/provider_edge_dns_api.go

@@ -71,6 +71,14 @@ func (this *EdgeDNSAPIProvider) Auth(params maps.Map) error {
 	return nil
 }
 
+// MaskParams 对参数进行掩码
+func (this *EdgeDNSAPIProvider) MaskParams(params maps.Map) {
+	if params == nil {
+		return
+	}
+	params["accessKeySecret"] = MaskString(params.GetString("accessKeySecret"))
+}
+
 // GetDomains 获取所有域名列表
 func (this *EdgeDNSAPIProvider) GetDomains() (domains []string, err error) {
 	var offset = 0

internal/dnsclients/provider_huawei_dns.go

@@ -71,6 +71,14 @@ func (this *HuaweiDNSProvider) Auth(params maps.Map) error {
 	return nil
 }
 
+// MaskParams 对参数进行掩码
+func (this *HuaweiDNSProvider) MaskParams(params maps.Map) {
+	if params == nil {
+		return
+	}
+	params["accessKeySecret"] = MaskString(params.GetString("accessKeySecret"))
+}
+
 // GetDomains 获取所有域名列表
 func (this *HuaweiDNSProvider) GetDomains() (domains []string, err error) {
 	var resp = new(huaweidns.ZonesResponse)
@@ -177,13 +185,12 @@ func (this *HuaweiDNSProvider) GetRoutes(domain string) (routes []*dnstypes.Rout
 
 		{
 			Code: "Pengboshi",
-
 			Name: "鹏博士",
 		},
 
 		{
 			Code: "CN",
-			Name: "中国",
+			Name: "中国大陆",
 		},
 
 		{
@@ -192,6 +199,944 @@ func (this *HuaweiDNSProvider) GetRoutes(domain string) (routes []*dnstypes.Rout
 		},
 	}...)
 
+	// 运营商线路细分
+	routes = append(routes, []*dnstypes.Route{
+		{
+			Code: "Dianxin_Huabei",
+			Name: "电信_华北地区",
+		},
+		{
+
+			Code: "Dianxin_Dongbei",
+			Name: "电信_东北地区",
+		},
+		{
+
+			Code: "Dianxin_Huadong",
+			Name: "电信_华东地区",
+		},
+		{
+
+			Code: "Dianxin_Huazhong",
+			Name: "电信_华中地区",
+		},
+		{
+
+			Code: "Dianxin_Huanan",
+			Name: "电信_华南地区",
+		},
+		{
+
+			Code: "Dianxin_Xinan",
+			Name: "电信_西南地区",
+		},
+		{
+
+			Code: "Dianxin_Xibei",
+			Name: "电信_西北地区",
+		},
+		{
+
+			Code: "Dianxin_Beijing",
+			Name: "电信_北京",
+		},
+
+		{
+			Code: "Dianxin_Hebei",
+			Name: "电信_河北",
+		},
+		{
+
+			Code: "Dianxin_Tianjin",
+			Name: "电信_天津",
+		},
+		{
+			Code: "Dianxin_Shanxi",
+			Name: "电信_山西",
+		},
+		{
+			Code: "Dianxin_Neimenggu",
+			Name: "电信_内蒙古",
+		},
+		{
+			Code: "Dianxin_Heilongjiang",
+			Name: "电信_黑龙江",
+		},
+		{
+			Code: "Dianxin_Jilin",
+			Name: "电信_吉林",
+		},
+		{
+			Code: "Dianxin_Liaoning",
+			Name: "电信_辽宁",
+		},
+		{
+			Code: "Dianxin_Jiangsu",
+			Name: "电信_江苏",
+		},
+		{
+			Code: "Dianxin_Shanghai",
+			Name: "电信_上海",
+		},
+		{
+			Code: "Dianxin_Zhejiang",
+			Name: "电信_浙江",
+		},
+		{
+			Code: "Dianxin_Anhui",
+			Name: "电信_安徽",
+		},
+		{
+			Code: "Dianxin_Fujian",
+			Name: "电信_福建",
+		},
+		{
+			Code: "Dianxin_Jiangxi",
+			Name: "电信_江西",
+		},
+		{
+			Code: "Dianxin_Shandong",
+			Name: "电信_山东",
+		},
+		{
+			Code: "Dianxin_Hubei",
+			Name: "电信_湖北",
+		},
+		{
+			Code: "Dianxin_Hunan",
+			Name: "电信_湖南",
+		},
+		{
+			Code: "Dianxin_Henan",
+			Name: "电信_河南",
+		},
+		{
+			Code: "Dianxin_Guangdong",
+			Name: "电信_广东",
+		},
+		{
+			Code: "Dianxin_Guangxi",
+			Name: "电信_广西",
+		},
+		{
+			Code: "Dianxin_Hainan",
+			Name: "电信_海南",
+		},
+		{
+			Code: "Dianxin_Sichuan",
+			Name: "电信_四川",
+		},
+		{
+			Code: "Dianxin_Xizang",
+			Name: "电信_西藏",
+		},
+		{
+			Code: "Dianxin_Chongqing",
+			Name: "电信_重庆",
+		},
+		{
+			Code: "Dianxin_Yunnan",
+			Name: "电信_云南",
+		},
+		{
+			Code: "Dianxin_Guizhou",
+			Name: "电信_贵州",
+		},
+		{
+			Code: "Dianxin_Gansu",
+			Name: "电信_甘肃",
+		},
+		{
+			Code: "Dianxin_Xinjiang",
+			Name: "电信_新疆",
+		},
+		{
+			Code: "Dianxin_Shaanxi",
+			Name: "电信_陕西",
+		},
+		{
+			Code: "Dianxin_Qinghai",
+			Name: "电信_青海",
+		},
+		{
+			Code: "Dianxin_Ningxia",
+			Name: "电信_宁夏",
+		},
+		{
+			Code: "Yidong_Huabei",
+			Name: "移动_华北地区",
+		},
+		{
+			Code: "Yidong_Dongbei",
+			Name: "移动_东北地区",
+		},
+		{
+			Code: "Yidong_Huadong",
+			Name: "移动_华东地区",
+		},
+		{
+			Code: "Yidong_Huazhong",
+			Name: "移动_华中地区",
+		},
+		{
+			Code: "Yidong_Huanan",
+			Name: "移动_华南地区",
+		},
+		{
+			Code: "Yidong_Xinan",
+			Name: "移动_西南地区",
+		},
+		{
+			Code: "Yidong_Xibei",
+			Name: "移动_西北地区",
+		},
+		{
+			Code: "Yidong_Beijing",
+			Name: "移动_北京",
+		},
+		{
+			Code: "Yidong_Hebei",
+			Name: "移动_河北",
+		},
+		{
+			Code: "Yidong_Tianjin",
+			Name: "移动_天津",
+		},
+		{
+			Code: "Yidong_Shanxi",
+			Name: "移动_山西",
+		},
+		{
+			Code: "Yidong_Neimenggu",
+			Name: "移动_内蒙古",
+		},
+		{
+			Code: "Yidong_Heilongjiang",
+			Name: "移动_黑龙江",
+		},
+		{
+			Code: "Yidong_Jilin",
+			Name: "移动_吉林",
+		},
+		{
+			Code: "Yidong_Liaoning",
+			Name: "移动_辽宁",
+		},
+		{
+			Code: "Yidong_Jiangsu",
+			Name: "移动_江苏",
+		},
+		{
+			Code: "Yidong_Shanghai",
+			Name: "移动_上海",
+		},
+		{
+			Code: "Yidong_Zhejiang",
+			Name: "移动_浙江",
+		},
+		{
+			Code: "Yidong_Anhui",
+			Name: "移动_安徽",
+		},
+		{
+			Code: "Yidong_Fujian",
+			Name: "移动_福建",
+		},
+		{
+			Code: "Yidong_Jiangxi",
+			Name: "移动_江西",
+		},
+		{
+			Code: "Yidong_Shandong",
+			Name: "移动_山东",
+		},
+		{
+			Code: "Yidong_Hubei",
+			Name: "移动_湖北",
+		},
+		{
+			Code: "Yidong_Hunan",
+			Name: "移动_湖南",
+		},
+		{
+			Code: "Yidong_Henan",
+			Name: "移动_河南",
+		},
+		{
+			Code: "Yidong_Guangdong",
+			Name: "移动_广东",
+		},
+		{
+			Code: "Yidong_Guangxi",
+			Name: "移动_广西",
+		},
+		{
+			Code: "Yidong_Hainan",
+			Name: "移动_海南",
+		},
+		{
+			Code: "Yidong_Sichuan",
+			Name: "移动_四川",
+		},
+		{
+			Code: "Yidong_Xizang",
+			Name: "移动_西藏",
+		},
+		{
+			Code: "Yidong_Chongqing",
+			Name: "移动_重庆",
+		},
+		{
+			Code: "Yidong_Yunnan",
+			Name: "移动_云南",
+		},
+		{
+			Code: "Yidong_Guizhou",
+			Name: "移动_贵州",
+		},
+		{
+			Code: "Yidong_Gansu",
+			Name: "移动_甘肃",
+		},
+		{
+			Code: "Yidong_Xinjiang",
+			Name: "移动_新疆",
+		},
+		{
+			Code: "Yidong_Shaanxi",
+			Name: "移动_陕西",
+		},
+		{
+			Code: "Yidong_Qinghai",
+			Name: "移动_青海",
+		},
+		{
+			Code: "Yidong_Ningxia",
+			Name: "移动_宁夏",
+		},
+		{
+			Code: "Liantong_Huabei",
+			Name: "联通_华北地区",
+		},
+		{
+			Code: "Liantong_Dongbei",
+			Name: "联通_东北地区",
+		},
+		{
+			Code: "Liantong_Huadong",
+			Name: "联通_华东地区",
+		},
+		{
+			Code: "Liantong_Huazhong",
+			Name: "联通_华中地区",
+		},
+		{
+			Code: "Liantong_Huanan",
+			Name: "联通_华南地区",
+		},
+		{
+			Code: "Liantong_Xinan",
+			Name: "联通_西南地区",
+		},
+		{
+			Code: "Liantong_Xibei",
+			Name: "联通_西北地区",
+		},
+		{
+			Code: "Liantong_Beijing",
+			Name: "联通_北京",
+		},
+		{
+			Code: "Liantong_Hebei",
+			Name: "联通_河北",
+		},
+		{
+			Code: "Liantong_Tianjin",
+			Name: "联通_天津",
+		},
+		{
+			Code: "Liantong_Shanxi",
+			Name: "联通_山西",
+		},
+		{
+			Code: "Liantong_Neimenggu",
+			Name: "联通_内蒙古",
+		},
+		{
+			Code: "Liantong_Heilongjiang",
+			Name: "联通_黑龙江",
+		},
+		{
+			Code: "Liantong_Jilin",
+			Name: "联通_吉林",
+		},
+		{
+			Code: "Liantong_Liaoning",
+			Name: "联通_辽宁",
+		},
+		{
+			Code: "Liantong_Jiangsu",
+			Name: "联通_江苏",
+		},
+		{
+			Code: "Liantong_Shanghai",
+			Name: "联通_上海",
+		},
+		{
+			Code: "Liantong_Zhejiang",
+			Name: "联通_浙江",
+		},
+		{
+			Code: "Liantong_Anhui",
+			Name: "联通_安徽",
+		},
+		{
+			Code: "Liantong_Fujian",
+			Name: "联通_福建",
+		},
+		{
+			Code: "Liantong_Jiangxi",
+			Name: "联通_江西",
+		},
+		{
+			Code: "Liantong_Shandong",
+			Name: "联通_山东",
+		},
+		{
+			Code: "Liantong_Hubei",
+			Name: "联通_湖北",
+		},
+		{
+			Code: "Liantong_Hunan",
+			Name: "联通_湖南",
+		},
+		{
+			Code: "Liantong_Henan",
+			Name: "联通_河南",
+		},
+		{
+			Code: "Liantong_Guangdong",
+			Name: "联通_广东",
+		},
+		{
+			Code: "Liantong_Guangxi",
+			Name: "联通_广西",
+		},
+		{
+			Code: "Liantong_Hainan",
+			Name: "联通_海南",
+		},
+		{
+			Code: "Liantong_Sichuan",
+			Name: "联通_四川",
+		},
+		{
+			Code: "Liantong_Xizang",
+			Name: "联通_西藏",
+		},
+		{
+			Code: "Liantong_Chongqing",
+			Name: "联通_重庆",
+		},
+		{
+			Code: "Liantong_Yunnan",
+			Name: "联通_云南",
+		},
+		{
+			Code: "Liantong_Guizhou",
+			Name: "联通_贵州",
+		},
+		{
+			Code: "Liantong_Gansu",
+			Name: "联通_甘肃",
+		},
+		{
+			Code: "Liantong_Xinjiang",
+			Name: "联通_新疆",
+		},
+		{
+			Code: "Liantong_Shaanxi",
+			Name: "联通_陕西",
+		},
+		{
+			Code: "Liantong_Qinghai",
+			Name: "联通_青海",
+		},
+		{
+			Code: "Liantong_Ningxia",
+			Name: "联通_宁夏",
+		},
+		{
+			Code: "Jiaoyuwang",
+			Name: "教育网默认",
+		},
+		{
+			Code: "Jiaoyuwang_Huabei",
+			Name: "教育网_华北地区",
+		},
+		{
+			Code: "Jiaoyuwang_Dongbei",
+			Name: "教育网_东北地区",
+		},
+		{
+			Code: "Jiaoyuwang_Huadong",
+			Name: "教育网_华东地区",
+		},
+		{
+			Code: "Jiaoyuwang_Huazhong",
+			Name: "教育网_华中地区",
+		},
+		{
+			Code: "Jiaoyuwang_Huanan",
+			Name: "教育网_华南地区",
+		},
+		{
+			Code: "Jiaoyuwang_Xinan",
+			Name: "教育网_西南地区",
+		},
+		{
+			Code: "Jiaoyuwang_Xibei",
+			Name: "教育网_西北地区",
+		},
+		{
+			Code: "Jiaoyuwang_Beijing",
+			Name: "教育网_北京",
+		},
+		{
+			Code: "Jiaoyuwang_Hebei",
+			Name: "教育网_河北",
+		},
+		{
+			Code: "Jiaoyuwang_Tianjin",
+			Name: "教育网_天津",
+		},
+		{
+			Code: "Jiaoyuwang_Shanxi",
+			Name: "教育网_山西",
+		},
+		{
+			Code: "Jiaoyuwang_Neimenggu",
+			Name: "教育网_内蒙古",
+		},
+		{
+			Code: "Jiaoyuwang_Heilongjiang",
+			Name: "教育网_黑龙江",
+		},
+		{
+			Code: "Jiaoyuwang_Jilin",
+			Name: "教育网_吉林",
+		},
+		{
+			Code: "Jiaoyuwang_Liaoning",
+			Name: "教育网_辽宁",
+		},
+		{
+			Code: "Jiaoyuwang_Jiangsu",
+			Name: "教育网_江苏",
+		},
+		{
+			Code: "Jiaoyuwang_Shanghai",
+			Name: "教育网_上海",
+		},
+		{
+			Code: "Jiaoyuwang_Zhejiang",
+			Name: "教育网_浙江",
+		},
+		{
+			Code: "Jiaoyuwang_Anhui",
+			Name: "教育网_安徽",
+		},
+		{
+			Code: "Jiaoyuwang_Fujian",
+			Name: "教育网_福建",
+		},
+		{
+			Code: "Jiaoyuwang_Jiangxi",
+			Name: "教育网_江西",
+		},
+		{
+			Code: "Jiaoyuwang_Shandong",
+			Name: "教育网_山东",
+		},
+		{
+			Code: "Jiaoyuwang_Hubei",
+			Name: "教育网_湖北",
+		},
+		{
+			Code: "Jiaoyuwang_Hunan",
+			Name: "教育网_湖南",
+		},
+		{
+			Code: "Jiaoyuwang_Henan",
+			Name: "教育网_河南",
+		},
+		{
+			Code: "Jiaoyuwang_Guangdong",
+			Name: "教育网_广东",
+		},
+		{
+			Code: "Jiaoyuwang_Guangxi",
+			Name: "教育网_广西",
+		},
+		{
+			Code: "Jiaoyuwang_Hainan",
+			Name: "教育网_海南",
+		},
+		{
+			Code: "Jiaoyuwang_Sichuan",
+			Name: "教育网_四川",
+		},
+		{
+			Code: "Jiaoyuwang_Xizang",
+			Name: "教育网_西藏",
+		},
+		{
+			Code: "Jiaoyuwang_Chongqing",
+			Name: "教育网_重庆",
+		},
+		{
+			Code: "Jiaoyuwang_Yunnan",
+			Name: "教育网_云南",
+		},
+		{
+			Code: "Jiaoyuwang_Guizhou",
+			Name: "教育网_贵州",
+		},
+		{
+			Code: "Jiaoyuwang_Gansu",
+			Name: "教育网_甘肃",
+		},
+		{
+			Code: "Jiaoyuwang_Xinjiang",
+			Name: "教育网_新疆",
+		},
+		{
+			Code: "Jiaoyuwang_Shaanxi",
+			Name: "教育网_陕西",
+		},
+		{
+			Code: "Jiaoyuwang_Qinghai",
+			Name: "教育网_青海",
+		},
+		{
+			Code: "Jiaoyuwang_Ningxia",
+			Name: "教育网_宁夏",
+		},
+		{
+			Code: "Pengboshi",
+			Name: "鹏博士默认",
+		},
+		{
+			Code: "Pengboshi_Huabei",
+			Name: "鹏博士_华北地区",
+		},
+		{
+			Code: "Pengboshi_Dongbei",
+			Name: "鹏博士_东北地区",
+		},
+		{
+			Code: "Pengboshi_Huadong",
+			Name: "鹏博士_华东地区",
+		},
+		{
+			Code: "Pengboshi_Huazhong",
+			Name: "鹏博士_华中地区",
+		},
+		{
+			Code: "Pengboshi_Huanan",
+			Name: "鹏博士_华南地区",
+		},
+		{
+			Code: "Pengboshi_Xinan",
+			Name: "鹏博士_西南",
+		},
+		{
+			Code: "Pengboshi_Xibei",
+			Name: "鹏博士_西北",
+		},
+		{
+			Code: "Pengboshi_Beijing",
+			Name: "鹏博士_北京",
+		},
+		{
+			Code: "Pengboshi_Hebei",
+			Name: "鹏博士_河北",
+		},
+		{
+			Code: "Pengboshi_Tianjin",
+			Name: "鹏博士_天津",
+		},
+		{
+			Code: "Pengboshi_Shanxi",
+			Name: "鹏博士_山西",
+		},
+		{
+			Code: "Pengboshi_Neimenggu",
+			Name: "鹏博士_内蒙古",
+		},
+		{
+			Code: "Pengboshi_Heilongjiang",
+			Name: "鹏博士_黑龙江",
+		},
+		{
+			Code: "Pengboshi_Jilin",
+			Name: "鹏博士_吉林",
+		},
+		{
+			Code: "Pengboshi_Liaoning",
+			Name: "鹏博士_辽宁",
+		},
+		{
+			Code: "Pengboshi_Jiangsu",
+			Name: "鹏博士_江苏",
+		},
+		{
+			Code: "Pengboshi_Shanghai",
+			Name: "鹏博士_上海",
+		},
+		{
+			Code: "Pengboshi_Zhejiang",
+			Name: "鹏博士_浙江",
+		},
+		{
+			Code: "Pengboshi_Anhui",
+			Name: "鹏博士_安徽",
+		},
+		{
+			Code: "Pengboshi_Fujian",
+			Name: "鹏博士_福建",
+		},
+		{
+			Code: "Pengboshi_Jiangxi",
+			Name: "鹏博士_江西",
+		},
+		{
+			Code: "Pengboshi_Shandong",
+			Name: "鹏博士_山东",
+		},
+		{
+			Code: "Pengboshi_Hubei",
+			Name: "鹏博士_湖北",
+		},
+		{
+			Code: "Pengboshi_Hunan",
+			Name: "鹏博士_湖南",
+		},
+		{
+			Code: "Pengboshi_Henan",
+			Name: "鹏博士_河南",
+		},
+		{
+			Code: "Pengboshi_Guangdong",
+			Name: "鹏博士_广东",
+		},
+		{
+			Code: "Pengboshi_Guangxi",
+			Name: "鹏博士_广西",
+		},
+		{
+			Code: "Pengboshi_Hainan",
+			Name: "鹏博士_海南",
+		},
+		{
+			Code: "Pengboshi_Sichuan",
+			Name: "鹏博士_四川",
+		},
+		{
+			Code: "Pengboshi_Xizang",
+			Name: "鹏博士_西藏",
+		},
+		{
+			Code: "Pengboshi_Chongqing",
+			Name: "鹏博士_重庆",
+		},
+		{
+			Code: "Pengboshi_Yunnan",
+			Name: "鹏博士_云南",
+		},
+		{
+			Code: "Pengboshi_Guizhou",
+			Name: "鹏博士_贵州",
+		},
+		{
+			Code: "Pengboshi_Gansu",
+			Name: "鹏博士_甘肃",
+		},
+		{
+			Code: "Pengboshi_Xinjiang",
+			Name: "鹏博士_新疆",
+		},
+		{
+			Code: "Pengboshi_Shaanxi",
+			Name: "鹏博士_陕西",
+		},
+		{
+			Code: "Pengboshi_Qinghai",
+			Name: "鹏博士_青海",
+		},
+		{
+			Code: "Pengboshi_Ningxia",
+			Name: "鹏博士_宁夏",
+		},
+		{
+			Code: "Tietong",
+			Name: "铁通默认",
+		},
+		{
+			Code: "Tietong_Huabei",
+			Name: "铁通_华北地区",
+		},
+		{
+			Code: "Tietong_Dongbei",
+			Name: "铁通_东北地区",
+		},
+		{
+			Code: "Tietong_Huadong",
+			Name: "铁通_华东地区",
+		},
+		{
+			Code: "Tietong_Huazhong",
+			Name: "铁通_华中地区",
+		},
+		{
+			Code: "Tietong_Huanan",
+			Name: "铁通_华南地区",
+		},
+		{
+			Code: "Tietong_Xinan",
+			Name: "铁通_西南地区",
+		},
+		{
+			Code: "Tietong_Xibei",
+			Name: "铁通_西北地区",
+		},
+		{
+			Code: "Tietong_Beijing",
+			Name: "铁通_北京",
+		},
+		{
+			Code: "Tietong_Hebei",
+			Name: "铁通_河北",
+		},
+		{
+			Code: "Tietong_Tianjin",
+			Name: "铁通_天津",
+		},
+		{
+			Code: "Tietong_Shanxi",
+			Name: "铁通_山西",
+		},
+		{
+			Code: "Tietong_Neimenggu",
+			Name: "铁通_内蒙古",
+		},
+		{
+			Code: "Tietong_Heilongjiang",
+			Name: "铁通_黑龙江",
+		},
+		{
+			Code: "Tietong_Jilin",
+			Name: "铁通_吉林",
+		},
+		{
+			Code: "Tietong_Liaoning",
+			Name: "铁通_辽宁",
+		},
+		{
+			Code: "Tietong_Jiangsu",
+			Name: "铁通_江苏",
+		},
+		{
+			Code: "Tietong_Shanghai",
+			Name: "铁通_上海",
+		},
+		{
+			Code: "Tietong_Zhejiang",
+			Name: "铁通_浙江",
+		},
+		{
+			Code: "Tietong_Anhui",
+			Name: "铁通_安徽",
+		},
+		{
+			Code: "Tietong_Fujian",
+			Name: "铁通_福建",
+		},
+		{
+			Code: "Tietong_Jiangxi",
+			Name: "铁通_江西",
+		},
+		{
+			Code: "Tietong_Shandong",
+			Name: "铁通_山东",
+		},
+		{
+			Code: "Tietong_Hubei",
+			Name: "铁通_湖北",
+		},
+		{
+			Code: "Tietong_Hunan",
+			Name: "铁通_湖南",
+		},
+		{
+			Code: "Tietong_Henan",
+			Name: "铁通_河南",
+		},
+		{
+			Code: "Tietong_Guangdong",
+			Name: "铁通_广东",
+		},
+		{
+			Code: "Tietong_Guangxi",
+			Name: "铁通_广西",
+		},
+		{
+			Code: "Tietong_Hainan",
+			Name: "铁通_海南",
+		},
+		{
+			Code: "Tietong_Sichuan",
+			Name: "铁通_四川",
+		},
+		{
+			Code: "Tietong_Xizang",
+			Name: "铁通_西藏",
+		},
+		{
+			Code: "Tietong_Chongqing",
+			Name: "铁通_重庆",
+		},
+		{
+			Code: "Tietong_Yunnan",
+			Name: "铁通_云南",
+		},
+		{
+			Code: "Tietong_Guizhou",
+			Name: "铁通_贵州",
+		},
+		{
+			Code: "Tietong_Gansu",
+			Name: "铁通_甘肃",
+		},
+		{
+			Code: "Tietong_Xinjiang",
+			Name: "铁通_新疆",
+		},
+		{
+			Code: "Tietong_Shaanxi",
+			Name: "铁通_陕西",
+		},
+		{
+			Code: "Tietong_Qinghai",
+			Name: "铁通_青海",
+		},
+
+		{
+			Code: "Tietong_Ningxia",
+			Name: "铁通_宁夏",
+		},
+	}...)
+
 	// 地域线路细分（全球）
 	routes = append(routes, []*dnstypes.Route{
 		{

internal/dnsclients/provider_interface.go

@@ -10,6 +10,9 @@ type ProviderInterface interface {
 	// Auth 认证
 	Auth(params maps.Map) error
 
+	// MaskParams 对参数进行掩码
+	MaskParams(params maps.Map)
+
 	// GetDomains 获取所有域名列表
 	GetDomains() (domains []string, err error)
 

internal/dnsclients/provider_tencent_dns.go

@@ -47,6 +47,14 @@ func (this *TencentDNSProvider) Auth(params maps.Map) error {
 	return nil
 }
 
+// MaskParams 对参数进行掩码
+func (this *TencentDNSProvider) MaskParams(params maps.Map) {
+	if params == nil {
+		return
+	}
+	params["accessKeySecret"] = MaskString(params.GetString("accessKeySecret"))
+}
+
 // GetDomains 获取所有域名列表
 func (this *TencentDNSProvider) GetDomains() (domains []string, err error) {
 	var offset int64 = 0

internal/dnsclients/utils.go

@@ -0,0 +1,67 @@
+// Copyright 2024 GoEdge CDN goedge.cdn@gmail.com. All rights reserved. Official site: https://goedge.cn .
+
+package dnsclients
+
+import (
+	"encoding/json"
+	"github.com/iwind/TeaGo/maps"
+	"strings"
+)
+
+// MaskString 对字符串进行掩码
+func MaskString(s string) string {
+	var l = len(s)
+	if l == 0 {
+		return ""
+	}
+	if l < 8 {
+		return strings.Repeat("*", l)
+	}
+	return s[:4] + strings.Repeat("*", l-4)
+}
+
+// IsMasked 判断字符串是否被掩码
+func IsMasked(s string) bool {
+	if len(s) == 0 {
+		return false
+	}
+	return s == strings.Repeat("*", len(s)) || strings.HasSuffix(s, "**")
+}
+
+// UnmaskAPIParams 恢复API参数
+func UnmaskAPIParams(oldParamsJSON []byte, newParamsJSON []byte) (resultJSON []byte, err error) {
+	var oldParams maps.Map
+	var newParams maps.Map
+
+	if len(oldParamsJSON) == 0 || len(newParamsJSON) == 0 {
+		return newParamsJSON, nil
+	}
+	err = json.Unmarshal(oldParamsJSON, &oldParams)
+	if err != nil {
+		return nil, err
+	}
+
+	err = json.Unmarshal(newParamsJSON, &newParams)
+	if err != nil {
+		return nil, err
+	}
+
+	if oldParams == nil || newParams == nil {
+		return newParamsJSON, nil
+	}
+
+	for k, v := range newParams {
+		if v != nil {
+			s, ok := v.(string)
+			if ok && IsMasked(s) {
+				var oldV = oldParams.GetString(k)
+				if len(oldV) > 0 {
+					newParams[k] = oldV
+				}
+			}
+		}
+	}
+
+	resultJSON, err = json.Marshal(newParams)
+	return
+}

internal/dnsclients/utils_test.go

@@ -0,0 +1,35 @@
+// Copyright 2024 GoEdge CDN goedge.cdn@gmail.com. All rights reserved. Official site: https://goedge.cn .
+
+package dnsclients_test
+
+import (
+	"github.com/TeaOSLab/EdgeAPI/internal/dnsclients"
+	"github.com/iwind/TeaGo/assert"
+	"testing"
+)
+
+func TestIsMasked(t *testing.T) {
+	var a = assert.NewAssertion(t)
+	a.IsFalse(dnsclients.IsMasked(""))
+	a.IsFalse(dnsclients.IsMasked("abc"))
+	a.IsFalse(dnsclients.IsMasked("abc*"))
+	a.IsTrue(dnsclients.IsMasked("*"))
+	a.IsTrue(dnsclients.IsMasked("**"))
+	a.IsTrue(dnsclients.IsMasked("***"))
+	a.IsTrue(dnsclients.IsMasked("*******"))
+	a.IsTrue(dnsclients.IsMasked("abc**"))
+	a.IsTrue(dnsclients.IsMasked("abcd*********"))
+}
+
+func TestUnmaskAPIParams(t *testing.T) {
+	data, err := dnsclients.UnmaskAPIParams([]byte(`{
+	"key": "a",
+	"secret": "abc12"
+}`), []byte(`{
+	"secret": "abc**"
+}`))
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Log(string(data))
+}

internal/instances/README.md

@@ -0,0 +1,39 @@
+# 实例
+
+## 目录结构：
+~~~
+/opt/cache
+/usr/local/goedge/
+	edge-admin/
+	   configs/
+	      api_admin.yaml
+	      api_db.yaml
+	      server.yaml
+	edge-api/
+	   configs/api.yaml
+	   configs/db.yaml
+	api-node/
+	   configs/api_node.yaml
+	api-user/
+	   configs/api_user.yaml
+    src/	   
+/usr/bin/
+  edge-admin -> ...
+  edge-api -> ...
+  edge-node -> ...
+  edge-user -> ...
+/usr/local/mysql
+~~~
+
+* 其中 `->` 表示软链接。
+* `src/` 目录下放置zip格式的待安装压缩包
+
+## 端口
+* Admin：7788
+* API：8001
+* API HTTP：8002
+* User: 7799
+* Server: 8080
+
+## 数据库
+数据库名称为 `edges`

internal/instances/api_config.go

@@ -0,0 +1,16 @@
+// Copyright 2024 GoEdge CDN goedge.cdn@gmail.com. All rights reserved. Official site: https://goedge.cn .
+
+package instances
+
+import "gopkg.in/yaml.v3"
+
+type APIConfig struct {
+	RPCEndpoints     []string `yaml:"rpc.endpoints,flow,omitempty" json:"rpc.endpoints"`
+	RPCDisableUpdate bool     `yaml:"rpc.disableUpdate,omitempty" json:"rpc.disableUpdate"`
+	NodeId           string   `yaml:"nodeId" json:"nodeId"`
+	Secret           string   `yaml:"secret" json:"secret"`
+}
+
+func (this *APIConfig) AsYAML() ([]byte, error) {
+	return yaml.Marshal(this)
+}

internal/instances/instance_test.go

@@ -0,0 +1,98 @@
+// Copyright 2024 GoEdge CDN goedge.cdn@gmail.com. All rights reserved. Official site: https://goedge.cn .
+
+package instances_test
+
+import (
+	"github.com/TeaOSLab/EdgeAPI/internal/instances"
+	"github.com/iwind/TeaGo/Tea"
+	_ "github.com/iwind/TeaGo/bootstrap"
+	"testing"
+)
+
+var instance = instances.NewInstance(instances.Options{
+	Cacheable: true,
+	WorkDir:   Tea.Root + "/standalone-instance",
+	SrcDir:    Tea.Root + "/standalone-instance/src",
+	DB: struct {
+		Host     string
+		Port     int
+		Username string
+		Password string
+		Name     string
+	}{
+		Host:     "127.0.0.1",
+		Port:     3306,
+		Username: "root",
+		Password: "123456",
+		Name:     "edges2",
+	},
+	AdminNode: struct {
+		Port int
+	}{
+		Port: 7788,
+	},
+	APINode: struct {
+		HTTPPort     int
+		RestHTTPPort int
+	}{
+		HTTPPort:     8001,
+		RestHTTPPort: 8002,
+	},
+	Node: struct{ HTTPPort int }{
+		HTTPPort: 8080,
+	},
+	UserNode: struct {
+		HTTPPort int
+	}{
+		HTTPPort: 7799,
+	},
+})
+
+func TestInstanceSetupAll(t *testing.T) {
+	err := instance.SetupAll()
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestInstance_SetupDB(t *testing.T) {
+	err := instance.SetupDB()
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestInstance_SetupAdminNode(t *testing.T) {
+	err := instance.SetupAdminNode()
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestInstance_SetupAPINode(t *testing.T) {
+	err := instance.SetupAPINode()
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestInstance_SetupUserNode(t *testing.T) {
+	err := instance.SetupUserNode()
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestInstance_SetupNode(t *testing.T) {
+	err := instance.SetupNode()
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestInstance_Clean(t *testing.T) {
+	err := instance.Clean()
+	if err != nil {
+		t.Fatal(err)
+	}
+}

internal/instances/options.go

@@ -0,0 +1,32 @@
+// Copyright 2024 GoEdge CDN goedge.cdn@gmail.com. All rights reserved. Official site: https://goedge.cn .
+
+package instances
+
+type Options struct {
+	IsTesting bool
+	Verbose   bool
+	Cacheable bool
+
+	WorkDir string
+	SrcDir  string
+	DB      struct {
+		Host     string
+		Port     int
+		Username string
+		Password string
+		Name     string
+	}
+	AdminNode struct {
+		Port int
+	}
+	APINode struct {
+		HTTPPort     int
+		RestHTTPPort int
+	}
+	Node struct {
+		HTTPPort int
+	}
+	UserNode struct {
+		HTTPPort int
+	}
+}

internal/nodes/rest_server.go

@@ -67,6 +67,11 @@ func (this *RestServer) handle(writer http.ResponseWriter, req *http.Request) {
 	var matches = servicePathReg.FindStringSubmatch(path)
 	if len(matches) != 3 {
 		writer.WriteHeader(http.StatusNotFound)
+		this.writeJSON(writer, maps.Map{
+			"code":    "404",
+			"message": "invalid api path '" + path + "'",
+			"data":    maps.Map{},
+		}, shouldPretty)
 		return
 	}
 
@@ -76,11 +81,21 @@ func (this *RestServer) handle(writer http.ResponseWriter, req *http.Request) {
 	serviceType, ok := restServicesMap[serviceName]
 	if !ok {
 		writer.WriteHeader(http.StatusNotFound)
+		this.writeJSON(writer, maps.Map{
+			"code":    "404",
+			"message": "service '" + serviceName + "' not found",
+			"data":    maps.Map{},
+		}, shouldPretty)
 		return
 	}
 
 	if len(methodName) == 0 {
 		writer.WriteHeader(http.StatusNotFound)
+		this.writeJSON(writer, maps.Map{
+			"code":    "404",
+			"message": "method '" + methodName + "' not found",
+			"data":    maps.Map{},
+		}, shouldPretty)
 		return
 	}
 
@@ -94,19 +109,39 @@ func (this *RestServer) handle(writer http.ResponseWriter, req *http.Request) {
 			method = serviceType.MethodByName(methodName)
 			if !method.IsValid() {
 				writer.WriteHeader(http.StatusNotFound)
+				this.writeJSON(writer, maps.Map{
+					"code":    "404",
+					"message": "method '" + methodName + "' not found",
+					"data":    maps.Map{},
+				}, shouldPretty)
 				return
 			}
 		} else {
 			writer.WriteHeader(http.StatusNotFound)
+			this.writeJSON(writer, maps.Map{
+				"code":    "404",
+				"message": "method '" + methodName + "' not found",
+				"data":    maps.Map{},
+			}, shouldPretty)
 			return
 		}
 	}
 	if method.Type().NumIn() != 2 || method.Type().NumOut() != 2 {
 		writer.WriteHeader(http.StatusNotFound)
+		this.writeJSON(writer, maps.Map{
+			"code":    "404",
+			"message": "method '" + methodName + "' not found",
+			"data":    maps.Map{},
+		}, shouldPretty)
 		return
 	}
 	if method.Type().In(0).Name() != "Context" {
 		writer.WriteHeader(http.StatusNotFound)
+		this.writeJSON(writer, maps.Map{
+			"code":    "404",
+			"message": "method '" + methodName + "' not found (or invalid context)",
+			"data":    maps.Map{},
+		}, shouldPretty)
 		return
 	}
 
@@ -166,7 +201,11 @@ func (this *RestServer) handle(writer http.ResponseWriter, req *http.Request) {
 	body, err := io.ReadAll(io.LimitReader(req.Body, 32*sizes.M))
 	if err != nil {
 		writer.WriteHeader(http.StatusBadRequest)
-		_, _ = writer.Write([]byte(err.Error()))
+		this.writeJSON(writer, maps.Map{
+			"code":    400,
+			"message": err.Error(),
+			"data":    maps.Map{},
+		}, shouldPretty)
 		return
 	}
 
@@ -180,7 +219,11 @@ func (this *RestServer) handle(writer http.ResponseWriter, req *http.Request) {
 	err = json.Unmarshal(body, reqValue)
 	if err != nil {
 		writer.WriteHeader(http.StatusBadRequest)
-		_, _ = writer.Write([]byte("Decode request failed: " + err.Error() + ". Request body should be a valid JSON data"))
+		this.writeJSON(writer, maps.Map{
+			"code":    400,
+			"message": "Decode request failed: " + err.Error() + ". Request body should be a valid JSON data",
+			"data":    maps.Map{},
+		}, shouldPretty)
 		return
 	}
 

internal/rpc/services/service_admin.go

@@ -104,6 +104,39 @@ func (this *AdminService) CheckAdminUsername(ctx context.Context, req *pb.CheckA
 	return &pb.CheckAdminUsernameResponse{Exists: exists}, nil
 }
 
+// FindAdminWithUsername 使用用管理员户名查找管理员信息
+func (this *AdminService) FindAdminWithUsername(ctx context.Context, req *pb.FindAdminWithUsernameRequest) (*pb.FindAdminWithUsernameResponse, error) {
+	// 校验请求
+	_, err := this.ValidateAdmin(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	var tx = this.NullTx()
+
+	if len(req.Username) == 0 {
+		return nil, errors.New("require 'username'")
+	}
+	admin, err := models.SharedAdminDAO.FindAdminWithUsername(tx, req.Username)
+	if err != nil {
+		return nil, err
+	}
+	if admin == nil {
+		return &pb.FindAdminWithUsernameResponse{Admin: nil}, nil
+	}
+
+	return &pb.FindAdminWithUsernameResponse{
+		Admin: &pb.Admin{
+			Id:       int64(admin.Id),
+			Fullname: admin.Fullname,
+			Username: admin.Username,
+			IsOn:     admin.IsOn,
+			IsSuper:  admin.IsSuper,
+			CanLogin: admin.CanLogin,
+		},
+	}, nil
+}
+
 // FindAdminFullname 获取管理员名称
 func (this *AdminService) FindAdminFullname(ctx context.Context, req *pb.FindAdminFullnameRequest) (*pb.FindAdminFullnameResponse, error) {
 	// 校验请求
@@ -503,7 +536,7 @@ func (this *AdminService) ComposeAdminDashboard(ctx context.Context, req *pb.Com
 
 	// 默认集群
 	this.BeginTag(ctx, "SharedNodeClusterDAO.ListEnabledClusters")
-	nodeClusters, err := models.SharedNodeClusterDAO.ListEnabledClusters(tx, "", 0, 1)
+	nodeClusters, err := models.SharedNodeClusterDAO.ListEnabledClusters(tx, "", true, false, 0, 1)
 	this.EndTag(ctx, "SharedNodeClusterDAO.ListEnabledClusters")
 	if err != nil {
 		return nil, err
@@ -740,3 +773,18 @@ func (this *AdminService) UpdateAdminTheme(ctx context.Context, req *pb.UpdateAd
 	}
 	return this.Success()
 }
+
+// UpdateAdminLang 修改管理员使用的语言
+func (this *AdminService) UpdateAdminLang(ctx context.Context, req *pb.UpdateAdminLangRequest) (*pb.RPCSuccess, error) {
+	adminId, err := this.ValidateAdmin(ctx)
+	if err != nil {
+		return nil, err
+	}
+	var tx = this.NullTx()
+
+	err = models.SharedAdminDAO.UpdateAdminLang(tx, adminId, req.LangCode)
+	if err != nil {
+		return nil, err
+	}
+	return this.Success()
+}

internal/rpc/services/service_dns_provider.go

@@ -2,9 +2,11 @@ package services
 
 import (
 	"context"
+	"encoding/json"
 	"github.com/TeaOSLab/EdgeAPI/internal/db/models/dns"
 	"github.com/TeaOSLab/EdgeAPI/internal/dnsclients"
 	"github.com/TeaOSLab/EdgeCommon/pkg/rpc/pb"
+	"github.com/iwind/TeaGo/maps"
 )
 
 // DNSProviderService DNS服务商相关服务
@@ -42,6 +44,21 @@ func (this *DNSProviderService) UpdateDNSProvider(ctx context.Context, req *pb.U
 
 	var tx = this.NullTx()
 
+	provider, err := dns.SharedDNSProviderDAO.FindEnabledDNSProvider(tx, req.DnsProviderId)
+	if err != nil {
+		return nil, err
+	}
+	if provider == nil {
+		// do nothing here
+		return this.Success()
+	}
+
+	// 恢复被掩码的数据
+	req.ApiParamsJSON, err = dnsclients.UnmaskAPIParams(provider.ApiParams, req.ApiParamsJSON)
+	if err != nil {
+		return nil, err
+	}
+
 	err = dns.SharedDNSProviderDAO.UpdateDNSProvider(tx, req.DnsProviderId, req.Name, req.ApiParamsJSON)
 	if err != nil {
 		return nil, err
@@ -175,14 +192,34 @@ func (this *DNSProviderService) FindEnabledDNSProvider(ctx context.Context, req
 		return &pb.FindEnabledDNSProviderResponse{DnsProvider: nil}, nil
 	}
 
-	return &pb.FindEnabledDNSProviderResponse{DnsProvider: &pb.DNSProvider{
-		Id:            int64(provider.Id),
-		Name:          provider.Name,
-		Type:          provider.Type,
-		TypeName:      dnsclients.FindProviderTypeName(provider.Type),
-		ApiParamsJSON: provider.ApiParams,
-		DataUpdatedAt: int64(provider.DataUpdatedAt),
-	}}, nil
+	if req.MaskParams {
+		var providerObj = dnsclients.FindProvider(provider.Type, int64(provider.Id))
+		if providerObj != nil {
+			var paramsMap = maps.Map{}
+			if len(provider.ApiParams) > 0 {
+				err = json.Unmarshal(provider.ApiParams, &paramsMap)
+				if err != nil {
+					return nil, err
+				}
+				providerObj.MaskParams(paramsMap)
+				provider.ApiParams, err = json.Marshal(paramsMap)
+				if err != nil {
+					return nil, err
+				}
+			}
+		}
+	}
+
+	return &pb.FindEnabledDNSProviderResponse{
+		DnsProvider: &pb.DNSProvider{
+			Id:            int64(provider.Id),
+			Name:          provider.Name,
+			Type:          provider.Type,
+			TypeName:      dnsclients.FindProviderTypeName(provider.Type),
+			ApiParamsJSON: provider.ApiParams,
+			DataUpdatedAt: int64(provider.DataUpdatedAt),
+		},
+	}, nil
 }
 
 // FindAllDNSProviderTypes 取得所有服务商类型

internal/rpc/services/service_http_cache_task.go

@@ -353,14 +353,28 @@ func (this *HTTPCacheTaskService) FindEnabledHTTPCacheTask(ctx context.Context,
 			key.Errors = nil
 		}
 
+		// 集群信息
+		var pbNodeCluster *pb.NodeCluster
+		if !isFromUser && key.ClusterId > 0 {
+			clusterName, findClusterErr := models.SharedNodeClusterDAO.FindNodeClusterName(tx, int64(key.ClusterId))
+			if findClusterErr != nil {
+				return nil, findClusterErr
+			}
+			pbNodeCluster = &pb.NodeCluster{
+				Id:   int64(key.ClusterId),
+				Name: clusterName,
+			}
+		}
+
 		pbKeys = append(pbKeys, &pb.HTTPCacheTaskKey{
-			Id:         int64(key.Id),
-			TaskId:     int64(key.TaskId),
-			Key:        key.Key,
-			KeyType:    key.KeyType,
-			IsDone:     key.IsDone,
-			IsDoing:    !key.IsDone && len(key.DecodeNodes()) > 0,
-			ErrorsJSON: key.Errors,
+			Id:          int64(key.Id),
+			TaskId:      int64(key.TaskId),
+			Key:         key.Key,
+			KeyType:     key.KeyType,
+			IsDone:      key.IsDone,
+			IsDoing:     !key.IsDone && len(key.DecodeNodes()) > 0,
+			ErrorsJSON:  key.Errors,
+			NodeCluster: pbNodeCluster,
 		})
 	}
 

internal/rpc/services/service_http_firewall_policy.go

@@ -33,7 +33,7 @@ func (this *HTTPFirewallPolicyService) FindAllEnabledHTTPFirewallPolicies(ctx co
 		return nil, err
 	}
 
-	result := []*pb.HTTPFirewallPolicy{}
+	var result = []*pb.HTTPFirewallPolicy{}
 	for _, p := range policies {
 		result = append(result, &pb.HTTPFirewallPolicy{
 			Id:               int64(p.Id),
@@ -305,7 +305,7 @@ func (this *HTTPFirewallPolicyService) UpdateHTTPFirewallPolicy(ctx context.Cont
 		req.MaxRequestBodySize = 0
 	}
 
-	err = models.SharedHTTPFirewallPolicyDAO.UpdateFirewallPolicy(tx, req.HttpFirewallPolicyId, req.IsOn, req.Name, req.Description, inboundConfigJSON, outboundConfigJSON, req.BlockOptionsJSON, req.CaptchaOptionsJSON, req.Mode, req.UseLocalFirewall, synFloodConfig, logConfig, req.MaxRequestBodySize, req.DenyCountryHTML, req.DenyProvinceHTML)
+	err = models.SharedHTTPFirewallPolicyDAO.UpdateFirewallPolicy(tx, req.HttpFirewallPolicyId, req.IsOn, req.Name, req.Description, inboundConfigJSON, outboundConfigJSON, req.BlockOptionsJSON, req.PageOptionsJSON, req.CaptchaOptionsJSON, req.Mode, req.UseLocalFirewall, synFloodConfig, logConfig, req.MaxRequestBodySize, req.DenyCountryHTML, req.DenyProvinceHTML)
 	if err != nil {
 		return nil, err
 	}
@@ -395,7 +395,7 @@ func (this *HTTPFirewallPolicyService) ListEnabledHTTPFirewallPolicies(ctx conte
 		return nil, err
 	}
 
-	result := []*pb.HTTPFirewallPolicy{}
+	var result = []*pb.HTTPFirewallPolicy{}
 	for _, p := range policies {
 		result = append(result, &pb.HTTPFirewallPolicy{
 			Id:               int64(p.Id),
@@ -488,17 +488,22 @@ func (this *HTTPFirewallPolicyService) FindEnabledHTTPFirewallPolicy(ctx context
 	if policy == nil {
 		return &pb.FindEnabledHTTPFirewallPolicyResponse{HttpFirewallPolicy: nil}, nil
 	}
-	return &pb.FindEnabledHTTPFirewallPolicyResponse{HttpFirewallPolicy: &pb.HTTPFirewallPolicy{
-		Id:           int64(policy.Id),
-		ServerId:     int64(policy.ServerId),
-		Name:         policy.Name,
-		Description:  policy.Description,
-		IsOn:         policy.IsOn,
-		InboundJSON:  policy.Inbound,
-		OutboundJSON: policy.Outbound,
-		Mode:         policy.Mode,
-		SynFloodJSON: policy.SynFlood,
-	}}, nil
+	return &pb.FindEnabledHTTPFirewallPolicyResponse{
+		HttpFirewallPolicy: &pb.HTTPFirewallPolicy{
+			Id:                 int64(policy.Id),
+			ServerId:           int64(policy.ServerId),
+			Name:               policy.Name,
+			Description:        policy.Description,
+			IsOn:               policy.IsOn,
+			InboundJSON:        policy.Inbound,
+			OutboundJSON:       policy.Outbound,
+			Mode:               policy.Mode,
+			SynFloodJSON:       policy.SynFlood,
+			BlockOptionsJSON:   policy.BlockOptions,
+			PageOptionsJSON:    policy.PageOptions,
+			CaptchaOptionsJSON: policy.CaptchaOptions,
+		},
+	}, nil
 }
 
 // ImportHTTPFirewallPolicy 导入策略数据
@@ -858,3 +863,29 @@ func (this *HTTPFirewallPolicyService) CheckHTTPFirewallPolicyIPStatus(ctx conte
 		RegionProvince: nil,
 	}, nil
 }
+
+// FindServerIdWithHTTPFirewallPolicyId 获取防火墙对应的网站ID
+func (this *HTTPFirewallPolicyService) FindServerIdWithHTTPFirewallPolicyId(ctx context.Context, req *pb.FindServerIdWithHTTPFirewallPolicyIdRequest) (*pb.FindServerIdWithHTTPFirewallPolicyIdResponse, error) {
+	_, userId, err := this.ValidateAdminAndUser(ctx, true)
+	if err != nil {
+		return nil, err
+	}
+
+	var tx = this.NullTx()
+	serverId, err := models.SharedHTTPFirewallPolicyDAO.FindServerIdWithFirewallPolicyId(tx, req.HttpFirewallPolicyId)
+	if err != nil {
+		return nil, err
+	}
+
+	// check user
+	if serverId > 0 && userId > 0 {
+		err = models.SharedServerDAO.CheckUserServer(tx, userId, serverId)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return &pb.FindServerIdWithHTTPFirewallPolicyIdResponse{
+		ServerId: serverId,
+	}, nil
+}

internal/rpc/services/service_http_web.go

@@ -3,12 +3,16 @@ package services
 import (
 	"context"
 	"encoding/json"
+	"fmt"
 	"github.com/TeaOSLab/EdgeAPI/internal/db/models"
 	"github.com/TeaOSLab/EdgeAPI/internal/errors"
+	"github.com/TeaOSLab/EdgeAPI/internal/utils/domainutils"
 	"github.com/TeaOSLab/EdgeAPI/internal/utils/regexputils"
 	"github.com/TeaOSLab/EdgeCommon/pkg/rpc/pb"
 	"github.com/TeaOSLab/EdgeCommon/pkg/serverconfigs"
 	"github.com/iwind/TeaGo/dbs"
+	"github.com/iwind/TeaGo/lists"
+	"strings"
 )
 
 type HTTPWebService struct {
@@ -532,6 +536,49 @@ func (this *HTTPWebService) UpdateHTTPWebCache(ctx context.Context, req *pb.Upda
 
 	var tx = this.NullTx()
 
+	var cacheConfig = &serverconfigs.HTTPCacheConfig{}
+	if len(req.CacheJSON) > 0 {
+		err = json.Unmarshal(req.CacheJSON, cacheConfig)
+		if err != nil {
+			return nil, err
+		}
+		err = cacheConfig.Init()
+		if err != nil {
+			return nil, fmt.Errorf("validate cache config failed: %w", err)
+		}
+	}
+
+	// validate host
+	if cacheConfig.Key != nil && cacheConfig.Key.IsOn {
+		if cacheConfig.Key.Scheme != "http" && cacheConfig.Key.Scheme != "https" {
+			return nil, errors.New("key scheme must be 'http' or 'https'")
+		}
+
+		cacheConfig.Key.Host = strings.ToLower(cacheConfig.Key.Host)
+		if !domainutils.ValidateDomainFormat(cacheConfig.Key.Host) {
+			return nil, errors.New("key host must be a valid domain")
+		}
+
+		serverId, err := models.SharedHTTPWebDAO.FindWebServerId(tx, req.HttpWebId)
+		if err != nil {
+			return nil, err
+		}
+		if serverId > 0 {
+			serverNamesJSON, _, _, _, _, err := models.SharedServerDAO.FindServerServerNames(tx, serverId)
+			if err != nil {
+				return nil, err
+			}
+			var serverNames = []*serverconfigs.ServerNameConfig{}
+			err = json.Unmarshal(serverNamesJSON, &serverNames)
+			if err != nil {
+				return nil, err
+			}
+			if !lists.ContainsString(serverconfigs.PlainServerNames(serverNames), cacheConfig.Key.Host) {
+				return nil, errors.New("key host '" + cacheConfig.Key.Host + "' not exists in server names")
+			}
+		}
+	}
+
 	err = models.SharedHTTPWebDAO.UpdateWebCache(tx, req.HttpWebId, req.CacheJSON)
 	if err != nil {
 		return nil, err
@@ -851,28 +898,6 @@ func (this *HTTPWebService) FindHTTPWebRequestLimit(ctx context.Context, req *pb
 	return &pb.FindHTTPWebRequestLimitResponse{RequestLimitJSON: configJSON}, nil
 }
 
-// UpdateHTTPWebRequestScripts 修改请求脚本
-func (this *HTTPWebService) UpdateHTTPWebRequestScripts(ctx context.Context, req *pb.UpdateHTTPWebRequestScriptsRequest) (*pb.RPCSuccess, error) {
-	_, err := this.ValidateAdmin(ctx)
-	if err != nil {
-		return nil, err
-	}
-
-	var tx = this.NullTx()
-	var config = &serverconfigs.HTTPRequestScriptsConfig{}
-	err = json.Unmarshal(req.RequestScriptsJSON, config)
-	if err != nil {
-		return nil, err
-	}
-
-	err = models.SharedHTTPWebDAO.UpdateWebRequestScripts(tx, req.HttpWebId, config)
-	if err != nil {
-		return nil, err
-	}
-
-	return this.Success()
-}
-
 // FindHTTPWebRequestScripts 查找请求脚本
 func (this *HTTPWebService) FindHTTPWebRequestScripts(ctx context.Context, req *pb.FindHTTPWebRequestScriptsRequest) (*pb.FindHTTPWebRequestScriptsResponse, error) {
 	_, err := this.ValidateAdmin(ctx)
@@ -947,18 +972,13 @@ func (this *HTTPWebService) FindHTTPWebReferers(ctx context.Context, req *pb.Fin
 		}
 	}
 
-	config, err := models.SharedHTTPWebDAO.FindWebReferers(tx, req.HttpWebId)
-	if err != nil {
-		return nil, err
-	}
-
-	configJSON, err := json.Marshal(config)
+	referersJSON, err := models.SharedHTTPWebDAO.FindWebReferers(tx, req.HttpWebId)
 	if err != nil {
 		return nil, err
 	}
 
 	return &pb.FindHTTPWebReferersResponse{
-		ReferersJSON: configJSON,
+		ReferersJSON: referersJSON,
 	}, nil
 }
 
@@ -1015,17 +1035,39 @@ func (this *HTTPWebService) FindHTTPWebUserAgent(ctx context.Context, req *pb.Fi
 		}
 	}
 
-	config, err := models.SharedHTTPWebDAO.FindWebUserAgent(tx, req.HttpWebId)
-	if err != nil {
-		return nil, err
-	}
-
-	configJSON, err := json.Marshal(config)
+	userAgentJSON, err := models.SharedHTTPWebDAO.FindWebUserAgent(tx, req.HttpWebId)
 	if err != nil {
 		return nil, err
 	}
 
 	return &pb.FindHTTPWebUserAgentResponse{
-		UserAgentJSON: configJSON,
+		UserAgentJSON: userAgentJSON,
 	}, nil
 }
+
+// FindServerIdWithHTTPWebId 根据WebId查找ServerId
+func (this *HTTPWebService) FindServerIdWithHTTPWebId(ctx context.Context, req *pb.FindServerIdWithHTTPWebIdRequest) (*pb.FindServerIdWithHTTPWebIdResponse, error) {
+	_, userId, err := this.ValidateAdminAndUser(ctx, true)
+	if err != nil {
+		return nil, err
+	}
+
+	if req.HttpWebId <= 0 {
+		return nil, errors.New("invalid 'httpWebId'")
+	}
+
+	var tx = this.NullTx()
+	serverId, err := models.SharedHTTPWebDAO.FindWebServerId(tx, req.HttpWebId)
+	if err != nil {
+		return nil, err
+	}
+
+	if serverId > 0 && userId > 0 {
+		err = models.SharedServerDAO.CheckUserServer(tx, userId, serverId)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return &pb.FindServerIdWithHTTPWebIdResponse{ServerId: serverId}, nil
+}

internal/rpc/services/service_http_web_community.go

@@ -27,3 +27,18 @@ func (this *HTTPWebService) UpdateHTTPWebCC(ctx context.Context, req *pb.UpdateH
 func (this *HTTPWebService) FindHTTPWebCC(ctx context.Context, req *pb.FindHTTPWebCCRequest) (*pb.FindHTTPWebCCResponse, error) {
 	return nil, this.NotImplementedYet()
 }
+
+// UpdateHTTPWebRequestScripts 修改请求脚本
+func (this *HTTPWebService) UpdateHTTPWebRequestScripts(ctx context.Context, req *pb.UpdateHTTPWebRequestScriptsRequest) (*pb.RPCSuccess, error) {
+	return nil, this.NotImplementedYet()
+}
+
+// UpdateHTTPWebHLS 修改HLS设置
+func (this *HTTPWebService) UpdateHTTPWebHLS(ctx context.Context, req *pb.UpdateHTTPWebHLSRequest) (*pb.RPCSuccess, error) {
+	return nil, this.NotImplementedYet()
+}
+
+// FindHTTPWebHLS 查找HLS设置
+func (this *HTTPWebService) FindHTTPWebHLS(ctx context.Context, req *pb.FindHTTPWebHLSRequest) (*pb.FindHTTPWebHLSResponse, error) {
+	return nil, this.NotImplementedYet()
+}

internal/rpc/services/service_ip_item.go

@@ -768,6 +768,29 @@ func (this *IPItemService) ListAllEnabledIPItems(ctx context.Context, req *pb.Li
 	return &pb.ListAllEnabledIPItemsResponse{Results: results}, nil
 }
 
+// ListAllIPItemIds 列出所有名单中的IP ID
+func (this *IPItemService) ListAllIPItemIds(ctx context.Context, req *pb.ListAllIPItemIdsRequest) (*pb.ListAllIPItemIdsResponse, error) {
+	adminId, userId, err := this.ValidateAdminAndUser(ctx, true)
+	if err != nil {
+		return nil, err
+	}
+
+	if adminId > 0 {
+		userId = req.UserId
+	}
+
+	var tx = this.NullTx()
+	var listId int64 = 0
+	if req.GlobalOnly {
+		listId = firewallconfigs.GlobalListId
+	}
+	itemIds, err := models.SharedIPItemDAO.ListAllIPItemIds(tx, userId, req.Keyword, req.Ip, listId, req.Unread, req.EventLevel, req.ListType, req.Offset, req.Size)
+	if err != nil {
+		return nil, err
+	}
+	return &pb.ListAllIPItemIdsResponse{IpItemIds: itemIds}, nil
+}
+
 // UpdateIPItemsRead 设置所有为已读
 func (this *IPItemService) UpdateIPItemsRead(ctx context.Context, req *pb.UpdateIPItemsReadRequest) (*pb.RPCSuccess, error) {
 	_, userId, err := this.ValidateAdminAndUser(ctx, true)
@@ -782,3 +805,38 @@ func (this *IPItemService) UpdateIPItemsRead(ctx context.Context, req *pb.Update
 	}
 	return this.Success()
 }
+
+// FindServerIdWithIPItemId 查找IP对应的名单所属网站ID
+func (this *IPItemService) FindServerIdWithIPItemId(ctx context.Context, req *pb.FindServerIdWithIPItemIdRequest) (*pb.FindServerIdWithIPItemIdResponse, error) {
+	_, userId, err := this.ValidateAdminAndUser(ctx, true)
+	if err != nil {
+		return nil, err
+	}
+
+	var tx = this.NullTx()
+	listId, err := models.SharedIPItemDAO.FindItemListId(tx, req.IpItemId)
+	if err != nil {
+		return nil, err
+	}
+
+	if listId > 0 {
+		var serverId int64
+		serverId, err = models.SharedIPListDAO.FindServerIdWithListId(tx, listId)
+		if err != nil {
+			return nil, err
+		}
+
+		if serverId > 0 {
+			// check user
+			if userId > 0 {
+				err = models.SharedServerDAO.CheckUserServer(tx, userId, serverId)
+				if err != nil {
+					return nil, err
+				}
+			}
+			return &pb.FindServerIdWithIPItemIdResponse{ServerId: serverId}, nil
+		}
+	}
+
+	return &pb.FindServerIdWithIPItemIdResponse{ServerId: 0}, nil
+}

internal/rpc/services/service_ip_list.go

@@ -224,3 +224,29 @@ func (this *IPListService) FindEnabledIPListContainsIP(ctx context.Context, req
 	}
 	return &pb.FindEnabledIPListContainsIPResponse{IpLists: pbLists}, nil
 }
+
+// FindServerIdWithIPListId 查找IP名单对应的网站ID
+func (this *IPListService) FindServerIdWithIPListId(ctx context.Context, req *pb.FindServerIdWithIPListIdRequest) (*pb.FindServerIdWithIPListIdResponse, error) {
+	_, userId, err := this.ValidateAdminAndUser(ctx, true)
+	if err != nil {
+		return nil, err
+	}
+
+	var tx = this.NullTx()
+	serverId, err := models.SharedIPListDAO.FindServerIdWithListId(tx, req.IpListId)
+	if err != nil {
+		return nil, err
+	}
+
+	// check user
+	if serverId > 0 && userId > 0 {
+		err = models.SharedServerDAO.CheckUserServer(tx, userId, serverId)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return &pb.FindServerIdWithIPListIdResponse{
+		ServerId: serverId,
+	}, nil
+}

internal/rpc/services/service_node.go

@@ -2257,3 +2257,55 @@ func (this *NodeService) UpdateNodeAPIConfig(ctx context.Context, req *pb.Update
 
 	return this.Success()
 }
+
+// FindNodeWebPPolicies 查找节点的WebP策略
+func (this *NodeService) FindNodeWebPPolicies(ctx context.Context, req *pb.FindNodeWebPPoliciesRequest) (*pb.FindNodeWebPPoliciesResponse, error) {
+	nodeId, err := this.ValidateNode(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	var tx = this.NullTx()
+	clusterIds, err := models.SharedNodeDAO.FindEnabledAndOnNodeClusterIds(tx, nodeId)
+	if err != nil {
+		return nil, err
+	}
+
+	var pbPolicies = []*pb.FindNodeWebPPoliciesResponse_WebPPolicy{}
+	for _, clusterId := range clusterIds {
+		policy, err := models.SharedNodeClusterDAO.FindClusterWebPPolicy(tx, clusterId, nil)
+		if err != nil {
+			return nil, err
+		}
+		if policy == nil {
+			continue
+		}
+		policyJSON, err := json.Marshal(policy)
+		if err != nil {
+			return nil, err
+		}
+		pbPolicies = append(pbPolicies, &pb.FindNodeWebPPoliciesResponse_WebPPolicy{
+			NodeClusterId:  clusterId,
+			WebPPolicyJSON: policyJSON,
+		})
+	}
+	return &pb.FindNodeWebPPoliciesResponse{
+		WebPPolicies: pbPolicies,
+	}, nil
+}
+
+// UpdateNodeIsOn 修改节点的启用状态
+func (this *NodeService) UpdateNodeIsOn(ctx context.Context, req *pb.UpdateNodeIsOnRequest) (*pb.RPCSuccess, error) {
+	_, err := this.ValidateAdmin(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	var tx = this.NullTx()
+	err = models.SharedNodeDAO.UpdateNodeIsOn(tx, req.NodeId, req.IsOn)
+	if err != nil {
+		return nil, err
+	}
+
+	return this.Success()
+}

internal/rpc/services/service_node_cluster.go

@@ -349,12 +349,12 @@ func (this *NodeClusterService) ListEnabledNodeClusters(ctx context.Context, req
 
 	var tx = this.NullTx()
 
-	clusters, err := models.SharedNodeClusterDAO.ListEnabledClusters(tx, req.Keyword, req.Offset, req.Size)
+	clusters, err := models.SharedNodeClusterDAO.ListEnabledClusters(tx, req.Keyword, req.IdDesc, req.IdAsc, req.Offset, req.Size)
 	if err != nil {
 		return nil, err
 	}
 
-	result := []*pb.NodeCluster{}
+	var result = []*pb.NodeCluster{}
 	for _, cluster := range clusters {
 		result = append(result, &pb.NodeCluster{
 			Id:          int64(cluster.Id),
@@ -1126,14 +1126,14 @@ func (this *NodeClusterService) FindEnabledNodeClusterConfigInfo(ctx context.Con
 
 	// webp
 	if models.IsNotNull(cluster.Webp) {
-		var webpPolicy = &nodeconfigs.WebPImagePolicy{}
+		var webpPolicy = nodeconfigs.NewWebPImagePolicy()
 		err = json.Unmarshal(cluster.Webp, webpPolicy)
 		if err != nil {
 			return nil, err
 		}
-		result.WebpIsOn = webpPolicy.IsOn
+		result.WebPIsOn = webpPolicy.IsOn
 	} else {
-		result.WebpIsOn = nodeconfigs.DefaultWebPImagePolicy.IsOn
+		result.WebPIsOn = nodeconfigs.DefaultWebPImagePolicy.IsOn
 	}
 
 	// UAM
@@ -1247,8 +1247,8 @@ func (this *NodeClusterService) UpdateNodeClusterWebPPolicy(ctx context.Context,
 		return nil, err
 	}
 
-	var webpPolicy = &nodeconfigs.WebPImagePolicy{}
-	err = json.Unmarshal(req.WebpPolicyJSON, webpPolicy)
+	var webpPolicy = nodeconfigs.NewWebPImagePolicy()
+	err = json.Unmarshal(req.WebPPolicyJSON, webpPolicy)
 	if err != nil {
 		return nil, err
 	}

internal/rpc/services/service_node_grant.go

@@ -10,6 +10,8 @@ import (
 	"github.com/TeaOSLab/EdgeCommon/pkg/rpc/pb"
 	"golang.org/x/crypto/ssh"
 	"net"
+	"regexp"
+	"strings"
 	"time"
 )
 
@@ -48,6 +50,25 @@ func (this *NodeGrantService) UpdateNodeGrant(ctx context.Context, req *pb.Updat
 
 	var tx = this.NullTx()
 
+	// 从掩码中恢复密码和私钥
+	grant, err := models.SharedNodeGrantDAO.FindEnabledNodeGrant(tx, req.NodeGrantId)
+	if err != nil {
+		return nil, err
+	}
+	if grant == nil {
+		// do nothing here
+		return this.Success()
+	}
+
+	var maskReg = regexp.MustCompile(`^\*+$`)
+	if len(req.Password) > 0 && maskReg.MatchString(req.Password) {
+		req.Password = grant.Password
+	}
+
+	if len(req.PrivateKey) > 0 && strings.HasSuffix(req.PrivateKey, "********") {
+		req.PrivateKey = grant.PrivateKey
+	}
+
 	err = models.SharedNodeGrantDAO.UpdateGrant(tx, req.NodeGrantId, req.Name, req.Method, req.Username, req.Password, req.PrivateKey, req.Passphrase, req.Description, req.NodeId, req.Su)
 	return this.Success()
 }

internal/rpc/services/service_plan_community.go

@@ -1,6 +1,5 @@
 // Copyright 2021 Liuxiangchao iwind.liu@gmail.com. All rights reserved.
 //go:build !plus
-// +build !plus
 
 package services
 
@@ -34,6 +33,11 @@ func (this *PlanService) FindEnabledPlan(ctx context.Context, req *pb.FindEnable
 	return &pb.FindEnabledPlanResponse{Plan: nil}, nil
 }
 
+// FindBasicPlan 查找套餐基本信息
+func (this *PlanService) FindBasicPlan(ctx context.Context, req *pb.FindBasicPlanRequest) (*pb.FindBasicPlanResponse, error) {
+	return nil, this.NotImplementedYet()
+}
+
 // CountAllEnabledPlans 计算套餐数量
 func (this *PlanService) CountAllEnabledPlans(ctx context.Context, req *pb.CountAllEnabledPlansRequest) (*pb.RPCCountResponse, error) {
 	return this.SuccessCount(0)
@@ -48,3 +52,13 @@ func (this *PlanService) ListEnabledPlans(ctx context.Context, req *pb.ListEnabl
 func (this *PlanService) SortPlans(ctx context.Context, req *pb.SortPlansRequest) (*pb.RPCSuccess, error) {
 	return this.Success()
 }
+
+// FindAllAvailablePlans 列出所有可用的套餐
+func (this *PlanService) FindAllAvailablePlans(ctx context.Context, req *pb.FindAllAvailablePlansRequest) (*pb.FindAllAvailablePlansResponse, error) {
+	return nil, this.NotImplementedYet()
+}
+
+// FindAllAvailableBasicPlans 列出所有可用的套餐的基本信息
+func (this *PlanService) FindAllAvailableBasicPlans(ctx context.Context, req *pb.FindAllAvailableBasicPlansRequest) (*pb.FindAllAvailableBasicPlansResponse, error) {
+	return nil, this.NotImplementedYet()
+}

internal/rpc/services/service_region_province.go

@@ -88,9 +88,9 @@ func (this *RegionProvinceService) FindAllRegionProvincesWithRegionCountryId(ctx
 	if err != nil {
 		return nil, err
 	}
-	var result = []*pb.RegionProvince{}
+	var pbProvinces = []*pb.RegionProvince{}
 	for _, province := range provinces {
-		result = append(result, &pb.RegionProvince{
+		pbProvinces = append(pbProvinces, &pb.RegionProvince{
 			Id:          int64(province.ValueId),
 			Name:        province.Name,
 			Codes:       province.DecodeCodes(),
@@ -101,7 +101,61 @@ func (this *RegionProvinceService) FindAllRegionProvincesWithRegionCountryId(ctx
 	}
 
 	return &pb.FindAllRegionProvincesWithRegionCountryIdResponse{
-		RegionProvinces: result,
+		RegionProvinces: pbProvinces,
+	}, nil
+}
+
+// FindAllRegionProvinces 查找所有国家|地区的所有省份
+func (this *RegionProvinceService) FindAllRegionProvinces(ctx context.Context, req *pb.FindAllRegionProvincesRequest) (*pb.FindAllRegionProvincesResponse, error) {
+	_, _, err := this.ValidateAdminAndUser(ctx, true)
+	if err != nil {
+		return nil, err
+	}
+
+	var tx = this.NullTx()
+	provinces, err := regions.SharedRegionProvinceDAO.FindAllEnabledProvinces(tx)
+	if err != nil {
+		return nil, err
+	}
+
+	var pbProvinces = []*pb.RegionProvince{}
+	var countryRouteCodeCache = map[int64]string{} // countryId => routeCode
+	for _, province := range provinces {
+		// 国家|地区ID
+		var countryId = int64(province.CountryId)
+		if countryId <= 0 {
+			continue
+		}
+
+		// 国家|地区线路
+		countryRouteCode, ok := countryRouteCodeCache[countryId]
+		if !ok {
+			countryRouteCode, err = regions.SharedRegionCountryDAO.FindRegionCountryRouteCode(tx, countryId)
+			if err != nil {
+				return nil, err
+			}
+			countryRouteCodeCache[countryId] = countryRouteCode
+		}
+		if len(countryRouteCode) == 0 {
+			continue
+		}
+
+		pbProvinces = append(pbProvinces, &pb.RegionProvince{
+			Id:              int64(province.ValueId),
+			Name:            province.Name,
+			Codes:           province.DecodeCodes(),
+			CustomName:      province.CustomName,
+			CustomCodes:     province.DecodeCustomCodes(),
+			DisplayName:     province.DisplayName(),
+			RegionCountryId: countryId,
+			RegionCountry: &pb.RegionCountry{
+				Id:        countryId,
+				RouteCode: countryRouteCode,
+			},
+		})
+	}
+	return &pb.FindAllRegionProvincesResponse{
+		RegionProvinces: pbProvinces,
 	}, nil
 }
 

internal/rpc/services/service_server.go

@@ -695,6 +695,218 @@ func (this *ServerService) CreateBasicTCPServer(ctx context.Context, req *pb.Cre
 	return &pb.CreateBasicTCPServerResponse{ServerId: serverId}, nil
 }
 
+// AddServerOrigin 为网站添加源站
+func (this *ServerService) AddServerOrigin(ctx context.Context, req *pb.AddServerOriginRequest) (*pb.RPCSuccess, error) {
+	_, userId, err := this.ValidateAdminAndUser(ctx, true)
+	if err != nil {
+		return nil, err
+	}
+
+	if req.ServerId <= 0 {
+		return nil, errors.New("require 'serverId'")
+	}
+	if req.OriginId <= 0 {
+		return nil, errors.New("require 'originId'")
+	}
+
+	var tx = this.NullTx()
+
+	// check user
+	if userId > 0 {
+		err = models.SharedServerDAO.CheckUserServer(tx, userId, req.ServerId)
+		if err != nil {
+			return nil, err
+		}
+
+		err = models.SharedOriginDAO.CheckUserOrigin(tx, userId, req.OriginId)
+		if err != nil {
+			return nil, err
+		}
+	} else {
+		// check server
+		existsServer, err := models.SharedServerDAO.ExistsServer(tx, req.ServerId)
+		if err != nil {
+			return nil, err
+		}
+		if !existsServer {
+			return nil, errors.New("server '" + types.String(req.ServerId) + "' not found")
+		}
+
+		// check origin
+		existsOrigin, err := models.SharedOriginDAO.ExistsOrigin(tx, req.OriginId)
+		if err != nil {
+			return nil, err
+		}
+		if !existsOrigin {
+			return nil, errors.New("origin '" + types.String(req.OriginId) + "' not found")
+		}
+	}
+
+	reverseProxyRef, err := models.SharedServerDAO.FindServerReverseProxyRef(tx, req.ServerId)
+	if err != nil {
+		return nil, err
+	}
+	if reverseProxyRef == nil || reverseProxyRef.ReverseProxyId <= 0 {
+		reverseProxyId, err := models.SharedServerDAO.CreateServerReverseProxyRef(tx, userId, req.ServerId)
+		if err != nil {
+			return nil, err
+		}
+		reverseProxyRef = &serverconfigs.ReverseProxyRef{
+			IsPrior:        false,
+			IsOn:           true,
+			ReverseProxyId: reverseProxyId,
+		}
+	}
+
+	reverseProxy, err := models.SharedReverseProxyDAO.FindEnabledReverseProxy(tx, reverseProxyRef.ReverseProxyId)
+	if err != nil {
+		return nil, err
+	}
+	if reverseProxy == nil {
+		return nil, errors.New("can not found reverse proxy")
+	}
+
+	if req.IsPrimary {
+		var refs = reverseProxy.DecodePrimaryOrigins()
+		refs = append(refs, &serverconfigs.OriginRef{
+			IsOn:     true,
+			OriginId: req.OriginId,
+		})
+		refsJSON, err := json.Marshal(refs)
+		if err != nil {
+			return nil, err
+		}
+		err = models.SharedReverseProxyDAO.UpdateReverseProxyPrimaryOrigins(tx, int64(reverseProxy.Id), refsJSON)
+		if err != nil {
+			return nil, err
+		}
+	} else {
+		var refs = reverseProxy.DecodeBackupOrigins()
+		refs = append(refs, &serverconfigs.OriginRef{
+			IsOn:     true,
+			OriginId: req.OriginId,
+		})
+		refsJSON, err := json.Marshal(refs)
+		if err != nil {
+			return nil, err
+		}
+		err = models.SharedReverseProxyDAO.UpdateReverseProxyBackupOrigins(tx, int64(reverseProxy.Id), refsJSON)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return this.Success()
+}
+
+// DeleteServerOrigin 从网站中删除某个源站
+func (this *ServerService) DeleteServerOrigin(ctx context.Context, req *pb.DeleteServerOriginRequest) (*pb.RPCSuccess, error) {
+	_, userId, err := this.ValidateAdminAndUser(ctx, true)
+	if err != nil {
+		return nil, err
+	}
+
+	if req.ServerId <= 0 {
+		return nil, errors.New("require 'serverId'")
+	}
+	if req.OriginId <= 0 {
+		return nil, errors.New("require 'originId'")
+	}
+
+	var tx = this.NullTx()
+
+	// check user
+	if userId > 0 {
+		err = models.SharedServerDAO.CheckUserServer(tx, userId, req.ServerId)
+		if err != nil {
+			return nil, err
+		}
+
+		err = models.SharedOriginDAO.CheckUserOrigin(tx, userId, req.OriginId)
+		if err != nil {
+			return nil, err
+		}
+	} else {
+		// check server
+		existsServer, err := models.SharedServerDAO.ExistsServer(tx, req.ServerId)
+		if err != nil {
+			return nil, err
+		}
+		if !existsServer {
+			return nil, errors.New("server '" + types.String(req.ServerId) + "' not found")
+		}
+
+		// check origin
+		existsOrigin, err := models.SharedOriginDAO.ExistsOrigin(tx, req.OriginId)
+		if err != nil {
+			return nil, err
+		}
+		if !existsOrigin {
+			return nil, errors.New("origin '" + types.String(req.OriginId) + "' not found")
+		}
+	}
+
+	reverseProxyRef, err := models.SharedServerDAO.FindServerReverseProxyRef(tx, req.ServerId)
+	if err != nil {
+		return nil, err
+	}
+	if reverseProxyRef == nil || reverseProxyRef.ReverseProxyId <= 0 {
+		return this.Success()
+	}
+
+	reverseProxy, err := models.SharedReverseProxyDAO.FindEnabledReverseProxy(tx, reverseProxyRef.ReverseProxyId)
+	if err != nil {
+		return nil, err
+	}
+	if reverseProxy == nil {
+		return this.Success()
+	}
+
+	var primaryOrigins = reverseProxy.DecodePrimaryOrigins()
+	var newPrimaryOrigins = []*serverconfigs.OriginRef{}
+	var found = false
+	for _, origin := range primaryOrigins {
+		if origin.OriginId == req.OriginId {
+			found = true
+			continue
+		}
+		newPrimaryOrigins = append(newPrimaryOrigins, origin)
+	}
+	if found {
+		newPrimaryOriginsJSON, err := json.Marshal(newPrimaryOrigins)
+		if err != nil {
+			return nil, err
+		}
+		err = models.SharedReverseProxyDAO.UpdateReverseProxyPrimaryOrigins(tx, int64(reverseProxy.Id), newPrimaryOriginsJSON)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	var backupOrigins = reverseProxy.DecodeBackupOrigins()
+	var newBackupOrigins = []*serverconfigs.OriginRef{}
+	found = false
+	for _, origin := range backupOrigins {
+		if origin.OriginId == req.OriginId {
+			found = true
+			continue
+		}
+		newBackupOrigins = append(newBackupOrigins, origin)
+	}
+	if found {
+		newBackupOriginsJSON, err := json.Marshal(newBackupOrigins)
+		if err != nil {
+			return nil, err
+		}
+		err = models.SharedReverseProxyDAO.UpdateReverseProxyBackupOrigins(tx, int64(reverseProxy.Id), newBackupOriginsJSON)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return this.Success()
+}
+
 // UpdateServerBasic 修改服务基本信息
 func (this *ServerService) UpdateServerBasic(ctx context.Context, req *pb.UpdateServerBasicRequest) (*pb.RPCSuccess, error) {
 	// 校验请求
@@ -1001,7 +1213,7 @@ func (this *ServerService) UpdateServerReverseProxy(ctx context.Context, req *pb
 	}
 
 	// 修改配置
-	err = models.SharedServerDAO.UpdateServerReverseProxy(tx, req.ServerId, req.ReverseProxyJSON)
+	err = models.SharedServerDAO.UpdateServerReverseProxyRef(tx, req.ServerId, req.ReverseProxyJSON)
 	if err != nil {
 		return nil, err
 	}
@@ -1462,7 +1674,7 @@ func (this *ServerService) ListEnabledServersMatch(ctx context.Context, req *pb.
 	return &pb.ListEnabledServersMatchResponse{Servers: result}, nil
 }
 
-// DeleteServer 禁用某服务
+// DeleteServer 删除某网站
 func (this *ServerService) DeleteServer(ctx context.Context, req *pb.DeleteServerRequest) (*pb.RPCSuccess, error) {
 	// 校验请求
 	_, userId, err := this.ValidateAdminAndUser(ctx, true)
@@ -1479,7 +1691,7 @@ func (this *ServerService) DeleteServer(ctx context.Context, req *pb.DeleteServe
 		}
 	}
 
-	// 禁用服务
+	// 禁用网站
 	err = models.SharedServerDAO.DisableServer(tx, req.ServerId)
 	if err != nil {
 		return nil, err
@@ -1488,6 +1700,37 @@ func (this *ServerService) DeleteServer(ctx context.Context, req *pb.DeleteServe
 	return this.Success()
 }
 
+// DeleteServers 删除一组网站
+func (this *ServerService) DeleteServers(ctx context.Context, req *pb.DeleteServersRequest) (*pb.RPCSuccess, error) {
+	// 校验请求
+	_, userId, err := this.ValidateAdminAndUser(ctx, true)
+	if err != nil {
+		return nil, err
+	}
+
+	var tx = this.NullTx()
+	for _, serverId := range req.ServerIds {
+		if serverId <= 0 {
+			continue
+		}
+
+		// 检查权限
+		if userId > 0 {
+			err = models.SharedServerDAO.CheckUserServer(tx, userId, serverId)
+			if err != nil {
+				return nil, err
+			}
+		}
+
+		// 禁用网站
+		err = models.SharedServerDAO.DisableServer(tx, serverId)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return this.Success()
+}
+
 // FindEnabledServer 查找单个服务
 func (this *ServerService) FindEnabledServer(ctx context.Context, req *pb.FindEnabledServerRequest) (*pb.FindEnabledServerResponse, error) {
 	// 校验请求
@@ -1674,7 +1917,7 @@ func (this *ServerService) FindAndInitServerReverseProxyConfig(ctx context.Conte
 
 	var tx = this.NullTx()
 
-	reverseProxyRef, err := models.SharedServerDAO.FindReverseProxyRef(tx, req.ServerId)
+	reverseProxyRef, err := models.SharedServerDAO.FindServerReverseProxyRef(tx, req.ServerId)
 	if err != nil {
 		return nil, err
 	}
@@ -1693,7 +1936,7 @@ func (this *ServerService) FindAndInitServerReverseProxyConfig(ctx context.Conte
 		if err != nil {
 			return nil, err
 		}
-		err = models.SharedServerDAO.UpdateServerReverseProxy(tx, req.ServerId, refJSON)
+		err = models.SharedServerDAO.UpdateServerReverseProxyRef(tx, req.ServerId, refJSON)
 		if err != nil {
 			return nil, err
 		}
@@ -2414,7 +2657,7 @@ func (this *ServerService) UploadServerHTTPRequestStat(ctx context.Context, req
 	return this.Success()
 }
 
-// CheckServerNameDuplicationInNodeCluster 检查域名是否已经存在
+// CheckServerNameDuplicationInNodeCluster 检查域名是否在集群中已经存在
 func (this *ServerService) CheckServerNameDuplicationInNodeCluster(ctx context.Context, req *pb.CheckServerNameDuplicationInNodeClusterRequest) (*pb.CheckServerNameDuplicationInNodeClusterResponse, error) {
 	_, _, err := this.ValidateAdminAndUser(ctx, true)
 	if err != nil {
@@ -2441,6 +2684,47 @@ func (this *ServerService) CheckServerNameDuplicationInNodeCluster(ctx context.C
 	return &pb.CheckServerNameDuplicationInNodeClusterResponse{DuplicatedServerNames: duplicatedServerNames}, nil
 }
 
+// CheckServerNameInServer 检查域名是否在网站中已经绑定
+func (this *ServerService) CheckServerNameInServer(ctx context.Context, req *pb.CheckServerNameInServerRequest) (*pb.CheckServerNameInServerResponse, error) {
+	_, userId, err := this.ValidateAdminAndUser(ctx, true)
+	if err != nil {
+		return nil, err
+	}
+
+	if req.ServerId <= 0 {
+		return nil, errors.New("invalid serverId '" + types.String(req.ServerId) + "'")
+	}
+
+	var tx = this.NullTx()
+
+	if userId > 0 {
+		err = models.SharedServerDAO.CheckUserServer(tx, userId, req.ServerId)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	if len(req.ServerName) == 0 {
+		return &pb.CheckServerNameInServerResponse{
+			Exists: false,
+		}, nil
+	}
+
+	serverNamesJSON, _, _, _, _, err := models.SharedServerDAO.FindServerServerNames(tx, req.ServerId)
+	if err != nil {
+		return nil, err
+	}
+	var serverNames = []*serverconfigs.ServerNameConfig{}
+	err = json.Unmarshal(serverNamesJSON, &serverNames)
+	if err != nil {
+		return nil, err
+	}
+
+	return &pb.CheckServerNameInServerResponse{
+		Exists: lists.ContainsString(serverconfigs.PlainServerNames(serverNames), req.ServerName),
+	}, nil
+}
+
 // FindLatestServers 查找最近访问的服务
 func (this *ServerService) FindLatestServers(ctx context.Context, req *pb.FindLatestServersRequest) (*pb.FindLatestServersResponse, error) {
 	_, err := this.ValidateAdmin(ctx)
@@ -2849,6 +3133,7 @@ func (this *ServerService) FindServerUserPlan(ctx context.Context, req *pb.FindS
 			User:   nil,
 			Plan: &pb.Plan{
 				Id:                        int64(plan.Id),
+				IsOn:                      plan.IsOn,
 				Name:                      plan.Name,
 				PriceType:                 plan.PriceType,
 				TrafficPriceJSON:          plan.TrafficPrice,
@@ -2856,6 +3141,8 @@ func (this *ServerService) FindServerUserPlan(ctx context.Context, req *pb.FindS
 				TotalServers:              types.Int32(plan.TotalServers),
 				TotalServerNames:          types.Int32(plan.TotalServerNames),
 				TotalServerNamesPerServer: types.Int32(plan.TotalServerNamesPerServer),
+				HasFullFeatures:           plan.HasFullFeatures,
+				FeaturesJSON:              plan.Features,
 			},
 		},
 	}, nil

internal/rpc/services/service_server_bandwidth_stat.go

@@ -80,13 +80,13 @@ func init() {
 							// 套餐统计
 							if stat.UserPlanId > 0 {
 								// 总体统计
-								err = models.SharedUserPlanStatDAO.IncreaseUserPlanStat(tx, stat.UserPlanId, stat.TotalBytes, stat.CountRequests)
+								err = models.SharedUserPlanStatDAO.IncreaseUserPlanStat(tx, stat.UserPlanId, stat.TotalBytes, stat.CountRequests, stat.CountWebsocketConnections)
 								if err != nil {
 									remotelogs.Error("ServerBandwidthStatService", "IncreaseUserPlanStat: "+err.Error())
 								}
 
 								// 分时统计
-								err = models.SharedUserPlanBandwidthStatDAO.UpdateUserPlanBandwidth(tx, stat.UserId, stat.UserPlanId, stat.NodeRegionId, stat.Day, stat.TimeAt, stat.Bytes, stat.TotalBytes, stat.CachedBytes, stat.AttackBytes, stat.CountRequests, stat.CountCachedRequests, stat.CountAttackRequests)
+								err = models.SharedUserPlanBandwidthStatDAO.UpdateUserPlanBandwidth(tx, stat.UserId, stat.UserPlanId, stat.NodeRegionId, stat.Day, stat.TimeAt, stat.Bytes, stat.TotalBytes, stat.CachedBytes, stat.AttackBytes, stat.CountRequests, stat.CountCachedRequests, stat.CountAttackRequests, stat.CountWebsocketConnections)
 							}
 						}
 
@@ -146,22 +146,24 @@ func (this *ServerBandwidthStatService) UploadServerBandwidthStats(ctx context.C
 			oldStat.CountRequests += stat.CountRequests
 			oldStat.CountCachedRequests += stat.CountCachedRequests
 			oldStat.CountAttackRequests += stat.CountAttackRequests
+			oldStat.CountWebsocketConnections += stat.CountWebsocketConnections
 		} else {
 			serverBandwidthStatsMap[key] = &pb.ServerBandwidthStat{
-				Id:                  0,
-				NodeRegionId:        stat.NodeRegionId,
-				UserId:              stat.UserId,
-				ServerId:            stat.ServerId,
-				Day:                 stat.Day,
-				TimeAt:              stat.TimeAt,
-				Bytes:               stat.Bytes,
-				TotalBytes:          stat.TotalBytes,
-				CachedBytes:         stat.CachedBytes,
-				AttackBytes:         stat.AttackBytes,
-				CountRequests:       stat.CountRequests,
-				CountCachedRequests: stat.CountCachedRequests,
-				CountAttackRequests: stat.CountAttackRequests,
-				UserPlanId:          stat.UserPlanId,
+				Id:                        0,
+				NodeRegionId:              stat.NodeRegionId,
+				UserId:                    stat.UserId,
+				ServerId:                  stat.ServerId,
+				Day:                       stat.Day,
+				TimeAt:                    stat.TimeAt,
+				Bytes:                     stat.Bytes,
+				TotalBytes:                stat.TotalBytes,
+				CachedBytes:               stat.CachedBytes,
+				AttackBytes:               stat.AttackBytes,
+				CountRequests:             stat.CountRequests,
+				CountCachedRequests:       stat.CountCachedRequests,
+				CountAttackRequests:       stat.CountAttackRequests,
+				CountWebsocketConnections: stat.CountWebsocketConnections,
+				UserPlanId:                stat.UserPlanId,
 			}
 		}
 		serverBandwidthStatsLocker.Unlock()

internal/rpc/services/users/service_user.go

@@ -618,31 +618,6 @@ func (this *UserService) UpdateAllUsersFeatures(ctx context.Context, req *pb.Upd
 	return this.Success()
 }
 
-// FindUserFeatures 获取用户所有的功能列表
-func (this *UserService) FindUserFeatures(ctx context.Context, req *pb.FindUserFeaturesRequest) (*pb.FindUserFeaturesResponse, error) {
-	_, userId, err := this.ValidateAdminAndUser(ctx, false)
-	if err != nil {
-		return nil, err
-	}
-	if userId > 0 {
-		req.UserId = userId
-	}
-
-	var tx = this.NullTx()
-
-	features, err := models.SharedUserDAO.FindUserFeatures(tx, req.UserId)
-	if err != nil {
-		return nil, err
-	}
-
-	result := []*pb.UserFeature{}
-	for _, feature := range features {
-		result = append(result, feature.ToPB())
-	}
-
-	return &pb.FindUserFeaturesResponse{Features: result}, nil
-}
-
 // FindAllUserFeatureDefinitions 获取所有的功能定义
 func (this *UserService) FindAllUserFeatureDefinitions(ctx context.Context, req *pb.FindAllUserFeatureDefinitionsRequest) (*pb.FindAllUserFeatureDefinitionsResponse, error) {
 	_, err := this.ValidateAdmin(ctx)
@@ -650,8 +625,8 @@ func (this *UserService) FindAllUserFeatureDefinitions(ctx context.Context, req
 		return nil, err
 	}
 
-	features := userconfigs.FindAllUserFeatures()
-	result := []*pb.UserFeature{}
+	var features = userconfigs.FindAllUserFeatures()
+	var result = []*pb.UserFeature{}
 	for _, feature := range features {
 		result = append(result, feature.ToPB())
 	}

internal/rpc/services/users/service_user_ext.go

@@ -89,3 +89,28 @@ func (this *UserService) RegisterUser(ctx context.Context, req *pb.RegisterUserR
 		RequireEmailVerification: requireEmailVerification,
 	}, nil
 }
+
+// FindUserFeatures 获取用户所有的功能列表
+func (this *UserService) FindUserFeatures(ctx context.Context, req *pb.FindUserFeaturesRequest) (*pb.FindUserFeaturesResponse, error) {
+	_, userId, err := this.ValidateAdminAndUser(ctx, false)
+	if err != nil {
+		return nil, err
+	}
+	if userId > 0 {
+		req.UserId = userId
+	}
+
+	var tx = this.NullTx()
+
+	features, err := models.SharedUserDAO.FindUserFeatures(tx, req.UserId)
+	if err != nil {
+		return nil, err
+	}
+
+	result := []*pb.UserFeature{}
+	for _, feature := range features {
+		result = append(result, feature.ToPB())
+	}
+
+	return &pb.FindUserFeaturesResponse{Features: result}, nil
+}

internal/setup/sql_executor.go

@@ -1,6 +1,7 @@
 package setup
 
 import (
+	"crypto/rand"
 	"encoding/json"
 	"fmt"
 	"github.com/TeaOSLab/EdgeAPI/internal/db/models"
@@ -55,6 +56,12 @@ func (this *SQLExecutor) Run(showLog bool) error {
 		return err
 	}
 
+	// prevent default configure loading
+	var globalConfig = dbs.GlobalConfig()
+	if globalConfig != nil && len(globalConfig.DBs) == 0 {
+		globalConfig.DBs = map[string]*dbs.DBConfig{"prod": this.dbConfig}
+	}
+
 	defer func() {
 		_ = db.Close()
 	}()
@@ -90,56 +97,56 @@ func (this *SQLExecutor) checkData(db *dbs.DB) error {
 	// 检查管理员平台节点
 	err := this.checkAdminNode(db)
 	if err != nil {
-		return err
+		return fmt.Errorf("check admin node failed: %w", err)
 	}
 
 	// 检查用户平台节点
 	err = this.checkUserNode(db)
 	if err != nil {
-		return err
+		return fmt.Errorf("check user node failed: %w", err)
 	}
 
 	// 检查集群配置
 	err = this.checkCluster(db)
 	if err != nil {
-		return err
+		return fmt.Errorf("check cluster failed: %w", err)
 	}
 
 	// 检查初始化用户
 	// 需要放在检查集群后面
 	err = this.checkUser(db)
 	if err != nil {
-		return err
+		return fmt.Errorf("check user failed: %w", err)
 	}
 
 	// 检查IP名单
 	err = this.checkIPList(db)
 	if err != nil {
-		return err
+		return fmt.Errorf("check ip list failed: %w", err)
 	}
 
 	// 检查指标设置
 	err = this.checkMetricItems(db)
 	if err != nil {
-		return err
+		return fmt.Errorf("check metric items failed: %w", err)
 	}
 
 	// 检查自建DNS全局设置
 	err = this.checkNS(db)
 	if err != nil {
-		return err
+		return fmt.Errorf("check ns failed: %w", err)
 	}
 
 	// 更新Agents
 	err = this.checkClientAgents(db)
 	if err != nil {
-		return err
+		return fmt.Errorf("check client agents failed: %w", err)
 	}
 
 	// 更新版本号
 	err = this.updateVersion(db, ComposeSQLVersion())
 	if err != nil {
-		return err
+		return fmt.Errorf("update version failed: %w", err)
 	}
 
 	return nil
@@ -179,13 +186,13 @@ func (this *SQLExecutor) checkAdminNode(db *dbs.DB) error {
 	if err != nil {
 		return err
 	}
-	count := types.Int(col)
+	var count = types.Int(col)
 	if count > 0 {
 		return nil
 	}
 
-	nodeId := rands.HexString(32)
-	secret := rands.String(32)
+	var nodeId = rands.HexString(32)
+	var secret = rands.String(32)
 	_, err = db.Exec("INSERT INTO edgeAPITokens (nodeId, secret, role) VALUES (?, ?, ?)", nodeId, secret, "admin")
 	if err != nil {
 		return err
@@ -207,13 +214,13 @@ func (this *SQLExecutor) checkUserNode(db *dbs.DB) error {
 	if err != nil {
 		return err
 	}
-	count := types.Int(col)
+	var count = types.Int(col)
 	if count > 0 {
 		return nil
 	}
 
-	nodeId := rands.HexString(32)
-	secret := rands.String(32)
+	var nodeId = rands.HexString(32)
+	var secret = rands.String(32)
 	_, err = db.Exec("INSERT INTO edgeAPITokens (nodeId, secret, role) VALUES (?, ?, ?)", nodeId, secret, "user")
 	if err != nil {
 		return err
@@ -224,7 +231,7 @@ func (this *SQLExecutor) checkUserNode(db *dbs.DB) error {
 
 // 检查集群配置
 func (this *SQLExecutor) checkCluster(db *dbs.DB) error {
-	/// 检查是否有集群数字
+	/// 检查是否有集群数据
 	stmt, err := db.Prepare("SELECT COUNT(*) FROM edgeNodeClusters")
 	if err != nil {
 		return fmt.Errorf("query clusters failed: %w", err)
@@ -237,7 +244,7 @@ func (this *SQLExecutor) checkCluster(db *dbs.DB) error {
 	if err != nil {
 		return fmt.Errorf("query clusters failed: %w", err)
 	}
-	count := types.Int(col)
+	var count = types.Int(col)
 	if count > 0 {
 		return nil
 	}
@@ -259,7 +266,16 @@ func (this *SQLExecutor) checkCluster(db *dbs.DB) error {
 		return err
 	}
 
-	_, err = db.Exec("INSERT INTO edgeNodeClusters (name, useAllAPINodes, state, uniqueId, secret, dns) VALUES (?, ?, ?, ?, ?, ?)", "默认集群", 1, 1, uniqueId, secret, string(clusterDNSConfigJSON))
+	var defaultDNSName = "g" + rands.HexString(6) + ".cdn"
+	{
+		var b = make([]byte, 3)
+		_, err = rand.Read(b)
+		if err == nil {
+			defaultDNSName = fmt.Sprintf("g%x.cdn", b)
+		}
+	}
+
+	_, err = db.Exec("INSERT INTO edgeNodeClusters (name, useAllAPINodes, state, uniqueId, secret, dns, dnsName) VALUES (?, ?, ?, ?, ?, ?, ?)", "默认集群", 1, 1, uniqueId, secret, string(clusterDNSConfigJSON), defaultDNSName)
 	if err != nil {
 		return err
 	}
@@ -271,6 +287,7 @@ func (this *SQLExecutor) checkCluster(db *dbs.DB) error {
 	}
 
 	// 默认缓存策略
+
 	models.SharedHTTPCachePolicyDAO = models.NewHTTPCachePolicyDAO()
 	models.SharedHTTPCachePolicyDAO.Instance = db
 	policyId, err := models.SharedHTTPCachePolicyDAO.CreateDefaultCachePolicy(nil, "默认集群")
@@ -295,6 +312,15 @@ func (this *SQLExecutor) checkCluster(db *dbs.DB) error {
 	models.SharedHTTPFirewallRuleDAO = models.NewHTTPFirewallRuleDAO()
 	models.SharedHTTPFirewallRuleDAO.Instance = db
 
+	models.SharedHTTPWebDAO = models.NewHTTPWebDAO()
+	models.SharedHTTPWebDAO.Instance = db
+
+	models.SharedServerDAO = models.NewServerDAO()
+	models.SharedServerDAO.Instance = db
+
+	models.SharedNodeClusterDAO = models.NewNodeClusterDAO()
+	models.SharedNodeClusterDAO.Instance = db
+
 	policyId, err = models.SharedHTTPFirewallPolicyDAO.CreateDefaultFirewallPolicy(nil, "默认集群")
 	if err != nil {
 		return err
@@ -321,7 +347,7 @@ func (this *SQLExecutor) checkIPList(db *dbs.DB) error {
 	if err != nil {
 		return fmt.Errorf("query ip lists failed: %w", err)
 	}
-	count := types.Int(col)
+	var count = types.Int(col)
 	if count > 0 {
 		return nil
 	}
@@ -378,7 +404,7 @@ func (this *SQLExecutor) checkMetricItems(db *dbs.DB) error {
 
 		// chart
 		for _, chartMap := range chartMaps {
-			chartCode := chartMap.GetString("code")
+			var chartCode = chartMap.GetString("code")
 			one, err := db.FindOne("SELECT id FROM edgeMetricCharts WHERE itemId=? AND code=? LIMIT 1", itemId, chartCode)
 			if err != nil {
 				return err
@@ -518,7 +544,7 @@ func (this *SQLExecutor) updateVersion(db *dbs.DB, version string) error {
 	if err != nil {
 		return fmt.Errorf("query version failed: %w", err)
 	}
-	count := types.Int(col)
+	var count = types.Int(col)
 	if count > 0 {
 		_, err = db.Exec("UPDATE edgeVersions SET version=?", version)
 		if err != nil {

internal/setup/sql_upgrade.go

@@ -11,12 +11,14 @@ import (
 	"github.com/TeaOSLab/EdgeCommon/pkg/serverconfigs/firewallconfigs"
 	"github.com/TeaOSLab/EdgeCommon/pkg/serverconfigs/shared"
 	"github.com/TeaOSLab/EdgeCommon/pkg/systemconfigs"
+	"github.com/TeaOSLab/EdgeCommon/pkg/userconfigs"
 	"github.com/iwind/TeaGo/dbs"
 	"github.com/iwind/TeaGo/lists"
 	"github.com/iwind/TeaGo/maps"
 	"github.com/iwind/TeaGo/rands"
 	"github.com/iwind/TeaGo/types"
 	stringutil "github.com/iwind/TeaGo/utils/string"
+	"strconv"
 	"strings"
 )
 
@@ -101,6 +103,12 @@ var upgradeFuncs = []*upgradeVersion{
 	{
 		"1.2.10", upgradeV1_2_10,
 	},
+	{
+		"1.3.2", upgradeV1_3_2,
+	},
+	{
+		"1.3.4", upgradeV1_3_4,
+	},
 }
 
 // UpgradeSQLData 升级SQL数据
@@ -816,3 +824,422 @@ func upgradeV1_2_10(db *dbs.DB) error {
 
 	return nil
 }
+
+// 1.3.2
+func upgradeV1_3_2(db *dbs.DB) error {
+	// waf
+	{
+		var disableSet = func(setId int64) error {
+			_, err := db.Exec("UPDATE edgeHTTPFirewallRuleSets SET state=0 WHERE id=?", setId)
+			return err
+		}
+
+		var addRuleToGroup = func(groupId int64, setCode string, setName string, actions []*firewallconfigs.HTTPFirewallActionConfig, ruleParam string, ruleOperator string, value string) error {
+			actionsJSON, err := json.Marshal(actions)
+			if err != nil {
+				return err
+			}
+
+			// rule
+			ruleResult, err := db.Exec("INSERT INTO edgeHTTPFirewallRules (isOn, param, operator, value, isCaseInsensitive, state) VALUES (1, ?, ?, ?, 0, 1)", ruleParam, ruleOperator, value)
+			if err != nil {
+				return err
+			}
+			ruleId, err := ruleResult.LastInsertId()
+			if err != nil {
+				return err
+			}
+			var ruleRefs = []*firewallconfigs.HTTPFirewallRuleRef{
+				{
+					IsOn:   true,
+					RuleId: ruleId,
+				},
+			}
+			ruleRefsJSON, err := json.Marshal(ruleRefs)
+			if err != nil {
+				return err
+			}
+
+			// set
+			setResult, err := db.Exec("INSERT INTO edgeHTTPFirewallRuleSets (isOn, code, name, rules, connector, state, actions) VALUES (1, ?, ?, ?, 'or', 1, ?)", setCode, setName, ruleRefsJSON, actionsJSON)
+			if err != nil {
+				return err
+			}
+			setId, err := setResult.LastInsertId()
+			if err != nil {
+				return err
+			}
+			var setRefs = []*firewallconfigs.HTTPFirewallRuleSetRef{
+				{
+					IsOn:  true,
+					SetId: setId,
+				},
+			}
+			setRefsJSON, err := json.Marshal(setRefs)
+			if err != nil {
+				return err
+			}
+
+			// group
+			_, err = db.Exec("UPDATE edgeHTTPFirewallRuleGroups SET sets=? WHERE id=?", setRefsJSON, groupId)
+			if err != nil {
+				return err
+			}
+
+			return nil
+		}
+
+		// sql injection
+		{
+			ruleGroups, _, err := db.FindOnes("SELECT id, sets FROM edgeHTTPFirewallRuleGroups WHERE code='sqlInjection' AND state=1")
+			if err != nil {
+				return err
+			}
+			for _, ruleGroup := range ruleGroups {
+				var setsJSON = ruleGroup.GetBytes("sets")
+				if len(setsJSON) == 0 {
+					continue
+				}
+
+				var setRefs = []*firewallconfigs.HTTPFirewallRuleSetRef{}
+				err = json.Unmarshal(setsJSON, &setRefs)
+				if err != nil {
+					continue
+				}
+				if len(setRefs) != 5 {
+					continue
+				}
+
+				var isChanged = false
+				for setIndex, setRef := range setRefs {
+					set, setErr := db.FindOne("SELECT id, rules, isOn, actions FROM edgeHTTPFirewallRuleSets WHERE id=? AND state=1", setRef.SetId)
+					if setErr != nil {
+						return setErr
+					}
+					if set == nil {
+						isChanged = true
+						break
+					}
+					var rulesJSON = set.GetBytes("rules")
+					if len(rulesJSON) == 0 {
+						isChanged = true
+						break
+					}
+					var ruleRefs = []*firewallconfigs.HTTPFirewallRuleRef{}
+					err = json.Unmarshal(rulesJSON, &ruleRefs)
+					if err != nil {
+						return err
+					}
+					if len(ruleRefs) < 1 {
+						isChanged = true
+						break
+					}
+
+					var actionsJSON = set.GetBytes("actions")
+					if len(actionsJSON) == 0 {
+						isChanged = true
+						break
+					}
+					var actions = []*firewallconfigs.HTTPFirewallActionConfig{}
+					err = json.Unmarshal(actionsJSON, &actions)
+					if err != nil {
+						return err
+					}
+					if !(len(actions) == 1 && actions[0].Code == firewallconfigs.HTTPFirewallActionBlock) {
+						isChanged = true
+						break
+					}
+
+					var rules = []maps.Map{}
+					for _, ruleRef := range ruleRefs {
+						rule, ruleErr := db.FindOne("SELECT * FROM edgeHTTPFirewallRules WHERE id=? AND state=1", ruleRef.RuleId)
+						if ruleErr != nil {
+							return ruleErr
+						}
+						if rule == nil {
+							isChanged = true
+							break
+						}
+						rules = append(rules, rule)
+					}
+					if isChanged {
+						break
+					}
+					if len(rules) < 1 {
+						isChanged = true
+						break
+					}
+
+					switch setIndex {
+					case 0:
+						var rule = rules[0]
+						if !(rule.GetString("param") == "${requestAll}" && rule.GetString("operator") == "match" && rule.GetString("value") == `union[\s/\*]+select`) {
+							isChanged = true
+						}
+					case 1:
+						var rule = rules[0]
+						if !(rule.GetString("param") == "${requestAll}" && rule.GetString("operator") == "match" && rule.GetString("value") == `/\*(!|\x00)`) {
+							isChanged = true
+						}
+					case 2:
+						if len(rules) != 4 {
+							isChanged = true
+						} else {
+							{
+								var rule = rules[0]
+								if !(rule.GetString("param") == "${requestAll}" && rule.GetString("operator") == "match" && rule.GetString("value") == `\s(and|or|rlike)\s+(if|updatexml)\s*\(`) {
+									isChanged = true
+								}
+							}
+
+							{
+								var rule = rules[1]
+								if !(rule.GetString("param") == "${requestAll}" && rule.GetString("operator") == "match" && rule.GetString("value") == `\s+(and|or|rlike)\s+(select|case)\s+`) {
+									isChanged = true
+								}
+							}
+
+							{
+								var rule = rules[2]
+								if !(rule.GetString("param") == "${requestAll}" && rule.GetString("operator") == "match" && rule.GetString("value") == `\s+(and|or|procedure)\s+[\w\p{L}]+\s*=\s*[\w\p{L}]+(\s|$|--|#)`) {
+									isChanged = true
+								}
+							}
+
+							{
+								var rule = rules[3]
+								if !(rule.GetString("param") == "${requestAll}" && rule.GetString("operator") == "match" && rule.GetString("value") == `\(\s*case\s+when\s+[\w\p{L}]+\s*=\s*[\w\p{L}]+\s+then\s+`) {
+									isChanged = true
+								}
+							}
+						}
+					case 3:
+						var rule = rules[0]
+						if !(rule.GetString("param") == "${requestAll}" && rule.GetString("operator") == "match" && rule.GetString("value") == `\b(updatexml|extractvalue|ascii|ord|char|chr|count|concat|rand|floor|substr|length|len|user|database|benchmark|analyse)\s*\(.*\)`) {
+							isChanged = true
+						}
+					case 4:
+						var rule = rules[0]
+						if !(rule.GetString("param") == "${requestAll}" && rule.GetString("operator") == "match" && rule.GetString("value") == `;\s*(declare|use|drop|create|exec|delete|update|insert)\s`) {
+							isChanged = true
+						}
+					}
+				}
+				if isChanged {
+					continue
+				}
+
+				for _, setRef := range setRefs {
+					err = disableSet(setRef.SetId)
+					if err != nil {
+						return err
+					}
+				}
+
+				err = addRuleToGroup(ruleGroup.GetInt64("id"), "7010", "SQL注入检测", []*firewallconfigs.HTTPFirewallActionConfig{
+					{
+						Code:    firewallconfigs.HTTPFirewallActionPage,
+						Options: maps.Map{"status": 403, "body": ""},
+					},
+				}, "${requestAll}", firewallconfigs.HTTPFirewallRuleOperatorContainsSQLInjection, "")
+				if err != nil {
+					return err
+				}
+			}
+		}
+
+		// xss
+		{
+			ruleGroups, _, err := db.FindOnes("SELECT id, sets FROM edgeHTTPFirewallRuleGroups WHERE code='xss' AND state=1")
+			if err != nil {
+				return err
+			}
+			for _, ruleGroup := range ruleGroups {
+				var setsJSON = ruleGroup.GetBytes("sets")
+				if len(setsJSON) == 0 {
+					continue
+				}
+
+				var setRefs = []*firewallconfigs.HTTPFirewallRuleSetRef{}
+				err = json.Unmarshal(setsJSON, &setRefs)
+				if err != nil {
+					continue
+				}
+				if len(setRefs) != 3 {
+					continue
+				}
+
+				var isChanged = false
+				for setIndex, setRef := range setRefs {
+					set, setErr := db.FindOne("SELECT id, rules, isOn, actions FROM edgeHTTPFirewallRuleSets WHERE id=? AND state=1", setRef.SetId)
+					if setErr != nil {
+						return setErr
+					}
+					if set == nil {
+						isChanged = true
+						break
+					}
+					var rulesJSON = set.GetBytes("rules")
+					if len(rulesJSON) == 0 {
+						isChanged = true
+						break
+					}
+					var ruleRefs = []*firewallconfigs.HTTPFirewallRuleRef{}
+					err = json.Unmarshal(rulesJSON, &ruleRefs)
+					if err != nil {
+						return err
+					}
+					if len(ruleRefs) != 1 {
+						isChanged = true
+						break
+					}
+
+					var actionsJSON = set.GetBytes("actions")
+					if len(actionsJSON) == 0 {
+						isChanged = true
+						break
+					}
+					var actions = []*firewallconfigs.HTTPFirewallActionConfig{}
+					err = json.Unmarshal(actionsJSON, &actions)
+					if err != nil {
+						return err
+					}
+					if !(len(actions) == 1 && actions[0].Code == firewallconfigs.HTTPFirewallActionBlock) {
+						isChanged = true
+						break
+					}
+
+					rule, ruleErr := db.FindOne("SELECT * FROM edgeHTTPFirewallRules WHERE id=? AND state=1", ruleRefs[0].RuleId)
+					if ruleErr != nil {
+						return ruleErr
+					}
+					if rule == nil {
+						isChanged = true
+						break
+					}
+
+					switch setIndex {
+					case 0:
+						if !(rule.GetString("param") == "${requestURI}" && rule.GetString("operator") == "match" && rule.GetString("value") == `(onmouseover|onmousemove|onmousedown|onmouseup|onerror|onload|onclick|ondblclick|onkeydown|onkeyup|onkeypress)\s*=`) {
+							isChanged = true
+						}
+					case 1:
+						if !(rule.GetString("param") == "${requestURI}" && rule.GetString("operator") == "match" && rule.GetString("value") == `(alert|eval|prompt|confirm)\s*\(`) {
+							isChanged = true
+						}
+					case 2:
+						if !(rule.GetString("param") == "${requestURI}" && rule.GetString("operator") == "match" && rule.GetString("value") == `<(script|iframe|link)`) {
+							isChanged = true
+						}
+					}
+				}
+				if isChanged {
+					continue
+				}
+
+				for _, setRef := range setRefs {
+					err = disableSet(setRef.SetId)
+					if err != nil {
+						return err
+					}
+				}
+
+				err = addRuleToGroup(ruleGroup.GetInt64("id"), "1010", "XSS攻击检测", []*firewallconfigs.HTTPFirewallActionConfig{
+					{
+						Code:    firewallconfigs.HTTPFirewallActionPage,
+						Options: maps.Map{"status": 403, "body": ""},
+					},
+				}, "${requestAll}", firewallconfigs.HTTPFirewallRuleOperatorContainsXSS, "")
+				if err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	// user register config
+
+	var newAddedFeatureCodes = []string{
+		userconfigs.UserFeatureCodeServerOptimization,
+		userconfigs.UserFeatureCodeServerAuth,
+		userconfigs.UserFeatureCodeServerWebsocket,
+		userconfigs.UserFeatureCodeServerHTTP3,
+		userconfigs.UserFeatureCodeServerCC,
+		userconfigs.UserFeatureCodeServerReferers,
+		userconfigs.UserFeatureCodeServerUserAgent,
+		userconfigs.UserFeatureCodeServerRequestLimit,
+		userconfigs.UserFeatureCodeServerCompression,
+		userconfigs.UserFeatureCodeServerRewriteRules,
+		userconfigs.UserFeatureCodeServerHostRedirects,
+		userconfigs.UserFeatureCodeServerHTTPHeaders,
+		userconfigs.UserFeatureCodeServerPages,
+	}
+
+	{
+		value, err := db.FindCol(0, "SELECT value FROM edgeSysSettings WHERE code=?", systemconfigs.SettingCodeUserRegisterConfig)
+		if err != nil {
+			return err
+		}
+		if value != nil {
+			var valueString = types.String(value)
+			if valueString != "null" && len(valueString) > 0 {
+				var registerConfig = &userconfigs.UserRegisterConfig{}
+				err = json.Unmarshal([]byte(valueString), registerConfig)
+				if err != nil {
+					return err
+				}
+
+				if len(registerConfig.Features) > 0 {
+					var newFeatureCodes = registerConfig.Features
+					var changed = false
+					for _, featureCode := range newAddedFeatureCodes {
+						if !lists.ContainsString(newFeatureCodes, featureCode) {
+							newFeatureCodes = append(newFeatureCodes, featureCode)
+							changed = true
+						}
+					}
+
+					if changed {
+						registerConfig.Features = newFeatureCodes
+						registerConfigJSON, err := json.Marshal(registerConfig)
+						if err != nil {
+							return err
+						}
+						_, err = db.Exec("UPDATE edgeSysSettings SET value=? WHERE code=?", registerConfigJSON, systemconfigs.SettingCodeUserRegisterConfig)
+						if err != nil {
+							return err
+						}
+					}
+				}
+			}
+		}
+	}
+
+	// user features
+	{
+		var sqlPieces []string
+		for _, featureCode := range newAddedFeatureCodes {
+			if strings.Contains(featureCode, "'") {
+				continue
+			}
+			sqlPieces = append(sqlPieces, "'$', '"+featureCode+"'")
+		}
+
+		_, err := db.Exec("UPDATE edgeUsers SET features=JSON_ARRAY_APPEND(features," + strings.Join(sqlPieces, ",") + ") WHERE features IS NOT NULL AND JSON_LENGTH(features)>0 AND NOT JSON_CONTAINS(features, '" + strconv.Quote(newAddedFeatureCodes[0]) + "')")
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// 1.3.4
+func upgradeV1_3_4(db *dbs.DB) error {
+	_, err := db.Exec("DELETE FROM edgeLoginSessions WHERE adminId>0")
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

internal/setup/sql_upgrade_ext_test.go

@@ -27,3 +27,26 @@ func TestUpgradeSQLData_v0_5_6(t *testing.T) {
 	}
 	t.Log("ok")
 }
+
+
+func TestUpgradeSQLData_v1_3_4(t *testing.T) {
+	db, err := dbs.NewInstanceFromConfig(&dbs.DBConfig{
+		Driver: "mysql",
+		Dsn:    "root:123456@tcp(127.0.0.1:3306)/db_edge?charset=utf8mb4&timeout=30s",
+		Prefix: "edge",
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		_ = db.Close()
+	}()
+
+	err = upgradeV1_3_4(db)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Log("ok")
+}
+
+

internal/setup/sql_upgrade_test.go

@@ -289,3 +289,23 @@ func TestUpgradeSQLData_v1_2_10(t *testing.T) {
 	}
 	t.Log("ok")
 }
+
+
+func TestUpgradeSQLData_v1_3_2(t *testing.T) {
+	db, err := dbs.NewInstanceFromConfig(&dbs.DBConfig{
+		Driver: "mysql",
+		Dsn:    "root:123456@tcp(127.0.0.1:3306)/db_edge?charset=utf8mb4&timeout=30s",
+		Prefix: "edge",
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		_ = db.Close()
+	}()
+	err = upgradeV1_3_2(db)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Log("ok")
+}

internal/utils/service_linux.go

@@ -113,6 +113,12 @@ func (this *ServiceManager) installSystemdService(systemd, exePath string, args
 	shortName := teaconst.SystemdServiceName
 	longName := "GoEdge API" // TODO 将来可以修改
 
+	var startCmd = exePath + " daemon"
+	bashPath, _ := executils.LookPath("bash")
+	if len(bashPath) > 0 {
+		startCmd = bashPath + " -c \"" + startCmd + "\""
+	}
+
 	desc := `### BEGIN INIT INFO
 # Provides:          ` + shortName + `
 # Required-Start:    $all
@@ -131,7 +137,7 @@ After=network-online.target
 Type=simple
 Restart=always
 RestartSec=1s
-ExecStart=` + exePath + ` daemon
+ExecStart=` + startCmd + `
 ExecStop=` + exePath + ` stop
 ExecReload=` + exePath + ` reload
 

internal/zero/zero_test.go

@@ -33,7 +33,7 @@ func TestZero_Map(t *testing.T) {
 
 	var stat2 = &runtime.MemStats{}
 	runtime.ReadMemStats(stat2)
-	t.Log((stat2.HeapInuse-stat1.HeapInuse)/1024/1024, "MB")
+	t.Log((stat2.HeapInuse-stat1.HeapInuse)/1024/1024, "MiB")
 	t.Log(len(m))
 
 	_, ok := m[1024]