+ 
-
+
-
+
", "`")
- result = strings.ReplaceAll(result, "", "`")
- result = strings.ReplaceAll(result, "<", "<")
- result = strings.ReplaceAll(result, ">", ">")
- result = strings.ReplaceAll(result, "&", "&")
- return result
-}
-
-func formatTelegramNotification(event NotifyEvent) string {
- if text := formatTelegramMediaNotification(event); text != "" {
- return text
- }
-
- var sb strings.Builder
- if tag := telegramEventTag(event); tag != "" {
- sb.WriteString(tag)
- if telegramShouldShowEventHeading(event) {
- sb.WriteString("\n")
- }
- }
- if telegramShouldShowEventHeading(event) {
- sb.WriteString(telegramEventHeading(event))
- }
-
- message := strings.TrimSpace(event.Message)
- if message != "" {
- if sb.Len() > 0 {
- sb.WriteString("\n\n")
- }
- sb.WriteString(formatTelegramBody(message))
- }
-
- fields := telegramDisplayData(event.Data)
- if len(fields) > 0 {
- if sb.Len() > 0 {
- sb.WriteString("\n")
- }
- sb.WriteString("\n")
- for _, field := range fields {
- sb.WriteString(formatTelegramField(field.key, field.value))
- sb.WriteString("\n")
- }
- }
- if links := telegramExternalLinks(event.Data); links != "" {
- sb.WriteString("\n")
- sb.WriteString(links)
- }
-
- return strings.TrimSpace(sb.String())
-}
diff --git a/internal/service/notify_telegram_body.go b/internal/service/notify_telegram_body.go
deleted file mode 100644
index 3945438..0000000
--- a/internal/service/notify_telegram_body.go
+++ /dev/null
@@ -1,175 +0,0 @@
-package service
-
-import (
- "fmt"
- "strings"
-)
-
-func telegramShouldShowEventHeading(event NotifyEvent) bool {
- if telegramMediaTag(event.Data) != "" {
- return false
- }
- switch strings.TrimSpace(event.Type) {
- case EventSubscriptionHit, EventDownloadComplete:
- return false
- default:
- return true
- }
-}
-
-func telegramEventTag(event NotifyEvent) string {
- if tag := telegramMediaTag(event.Data); tag != "" {
- return tag
- }
- switch strings.TrimSpace(event.Type) {
- case EventSubscriptionHit:
- return "#订阅"
- case EventDownloadComplete:
- return "#下载完成"
- case EventScrapeFailed:
- return "#刮削失败"
- case EventSystemAlert:
- return "#系统提醒"
- case EventLibraryIngest:
- return "#入库"
- default:
- title := strings.TrimSpace(strings.TrimPrefix(event.Title, "MediaStationGo "))
- if title == "" {
- return "#MediaStationGo"
- }
- return "#" + escapeHTML(strings.ReplaceAll(title, " ", ""))
- }
-}
-
-func telegramEventHeading(event NotifyEvent) string {
- title := strings.TrimSpace(event.Title)
- title = strings.TrimSpace(strings.TrimPrefix(title, "MediaStationGo "))
- if title == "" {
- title = "MediaStationGo 通知"
- }
- icon := "🔔"
- switch strings.TrimSpace(event.Type) {
- case EventSubscriptionHit:
- icon = "🎯"
- case EventDownloadComplete:
- icon = "✅"
- case EventScrapeFailed:
- icon = "⚠️"
- case EventSystemAlert:
- icon = "🚨"
- case EventLibraryIngest:
- icon = "📚"
- }
- return fmt.Sprintf("%s %s", icon, escapeHTML(title))
-}
-
-func formatTelegramBody(message string) string {
- lines := strings.Split(message, "\n")
- out := make([]string, 0, len(lines))
- for _, line := range lines {
- line = strings.TrimSpace(line)
- if line == "" {
- out = append(out, "")
- continue
- }
- if strings.HasPrefix(line, "- ") {
- out = append(out, "- "+escapeHTML(strings.TrimSpace(strings.TrimPrefix(line, "- "))))
- continue
- }
- if key, ok := trimTelegramEmptyField(line); ok {
- out = append(out, fmt.Sprintf("%s %s：", telegramFieldIcon(telegramFieldLabel(key)), escapeHTML(telegramFieldLabel(key))))
- continue
- }
- if key, value, ok := splitTelegramField(line); ok {
- out = append(out, formatTelegramField(key, value))
- continue
- }
- out = append(out, escapeHTML(line))
- }
- return strings.TrimSpace(strings.Join(out, "\n"))
-}
-
-func trimTelegramEmptyField(line string) (string, bool) {
- line = strings.TrimSpace(line)
- for _, suffix := range []string{"：", ":"} {
- if strings.HasSuffix(line, suffix) {
- key := strings.TrimSpace(strings.TrimSuffix(line, suffix))
- if key != "" && len([]rune(key)) <= 16 {
- return key, true
- }
- }
- }
- return "", false
-}
-
-func splitTelegramField(line string) (string, string, bool) {
- idx := strings.Index(line, "：")
- sepLen := len("：")
- if idx < 0 {
- idx = strings.Index(line, ":")
- sepLen = len(":")
- }
- if idx <= 0 {
- return "", "", false
- }
- key := strings.TrimSpace(line[:idx])
- value := strings.TrimSpace(line[idx+sepLen:])
- if key == "" || value == "" || len([]rune(key)) > 16 {
- return "", "", false
- }
- return key, value, true
-}
-
-func formatTelegramField(key, value string) string {
- key = telegramFieldLabel(key)
- escapedValue := escapeHTML(strings.TrimSpace(value))
- if telegramCodeField(key) {
- escapedValue = "" + escapedValue + ""
- }
- return fmt.Sprintf("%s %s：%s", telegramFieldIcon(key), escapeHTML(key), escapedValue)
-}
-
-func telegramCodeField(key string) bool {
- key = strings.ToLower(strings.TrimSpace(key))
- return strings.Contains(key, "hash") ||
- strings.Contains(key, "路径") ||
- strings.Contains(key, "path") ||
- strings.Contains(key, "id")
-}
-
-func telegramFieldIcon(key string) string {
- switch strings.ToLower(strings.TrimSpace(key)) {
- case "中文片名", "标题", "任务", "媒体", "资源":
- return "📺"
- case "原始片名":
- return "🧿"
- case "原始语言", "语言":
- return "🌐"
- case "发行年份", "年份":
- return "📅"
- case "类别", "分类", "媒体类型":
- return "🐈⬛"
- case "季集", "集数":
- return "🫧"
- case "大小", "质量", "规格":
- return "🔎"
- case "版本", "保存路径":
- return "📁"
- case "评分":
- return "⭐️"
- case "类型":
- return "💎"
- case "简介":
- return "🪬"
- case "订阅":
- return "🎯"
- case "新增资源":
- return "✨"
- case "Hash":
- return "🧿"
- case "错误":
- return "⚠️"
- default:
- return "•"
- }
-}
diff --git a/internal/service/notify_telegram_config.go b/internal/service/notify_telegram_config.go
deleted file mode 100644
index 65a4dcf..0000000
--- a/internal/service/notify_telegram_config.go
+++ /dev/null
@@ -1,47 +0,0 @@
-package service
-
-import "strings"
-
-func telegramTargetChatIDs(cfg map[string]string) []string {
- seen := map[string]bool{}
- targets := []string{}
- for _, key := range []string{"group_chat_id", "channel_chat_id"} {
- chatID := strings.TrimSpace(cfg[key])
- if chatID == "" || seen[chatID] {
- continue
- }
- seen[chatID] = true
- targets = append(targets, chatID)
- }
- if len(targets) == 0 {
- chatID := strings.TrimSpace(cfg["chat_id"])
- if strings.HasPrefix(chatID, "-") {
- targets = append(targets, chatID)
- } else if chatID != "" && strings.TrimSpace(cfg["admin_user_ids"]) == "" {
- targets = append(targets, chatID)
- }
- }
- if len(targets) == 0 {
- for _, userID := range telegramConfiguredUserIDs(cfg["admin_user_ids"]) {
- if seen[userID] {
- continue
- }
- seen[userID] = true
- targets = append(targets, userID)
- }
- }
- return targets
-}
-
-func telegramConfiguredUserIDs(raw string) []string {
- out := []string{}
- for _, value := range strings.FieldsFunc(raw, func(r rune) bool {
- return r == ',' || r == ';' || r == '，' || r == ' ' || r == '\n' || r == '\t'
- }) {
- value = strings.TrimSpace(value)
- if value != "" {
- out = append(out, value)
- }
- }
- return out
-}
diff --git a/internal/service/notify_telegram_data.go b/internal/service/notify_telegram_data.go
deleted file mode 100644
index adf432c..0000000
--- a/internal/service/notify_telegram_data.go
+++ /dev/null
@@ -1,170 +0,0 @@
-package service
-
-import (
- "fmt"
- "net/url"
- "sort"
- "strings"
-)
-
-type telegramDataField struct {
- key string
- value string
-}
-
-func telegramDisplayData(data map[string]interface{}) []telegramDataField {
- if len(data) == 0 {
- return nil
- }
- keys := make([]string, 0, len(data))
- for key := range data {
- if telegramHiddenDataKey(key) {
- continue
- }
- keys = append(keys, key)
- }
- sort.Strings(keys)
- fields := make([]telegramDataField, 0, len(keys))
- for _, key := range keys {
- value := strings.TrimSpace(fmt.Sprint(data[key]))
- if value == "" || value == "| 测试资源 | 下载 |
| 电影 | -- ignored - 副标题 & 描述 - 下载 - | -12.5 GiB | -33 | -4 | -99 | -
| Some Show | -下载 | -
| shukBeta | 15.5 GiB |
| 问心下载 | 1.5 GiB |
| Selected Site Result下载 |
%s\n\n发给用户在 Bot 中兑换即可。", kindLabel, dur, code.Code),
- Buttons: [][]telegramInlineButton{{{Text: "再生成一个", Data: "adm_gencode"}, {Text: "⬅️ 返回菜单", Data: "menu_main"}}},
- }
-}
-
-func (s *TelegramBotService) cmdGenCode(ctx context.Context, msg *TelegramMessage, args []string) telegramCommandReply {
- if len(args) < 2 {
- return telegramCommandReply{Text: "用法：/gencode register|renew 天数 [有效天数] [可用次数]\n示例：/gencode register 30、/gencode renew 90 7 5"}
- }
- kind := strings.ToLower(strings.TrimSpace(args[0]))
- switch kind {
- case "reg", "register", "注册码":
- kind = model.RegistrationCodeRegister
- case "renew", "续期", "续期码":
- kind = model.RegistrationCodeRenew
- default:
- return telegramCommandReply{Text: "类型无效，只支持 register / renew。"}
- }
- days, err := strconv.Atoi(args[1])
- if err != nil || days < 0 {
- return telegramCommandReply{Text: "天数必须是非负整数，0 表示永久。"}
- }
- validDays := 0
- if len(args) > 2 {
- validDays, err = strconv.Atoi(args[2])
- if err != nil || validDays < 0 {
- return telegramCommandReply{Text: "有效天数必须是非负整数。"}
- }
- }
- maxUses := 1
- if len(args) > 3 {
- maxUses, err = strconv.Atoi(args[3])
- if err != nil || maxUses <= 0 {
- return telegramCommandReply{Text: "可用次数必须是正整数。"}
- }
- }
- createdBy := ""
- if u := s.boundUser(ctx, msg.From.ID); u != nil {
- createdBy = u.ID
- }
- code, err := s.generateCodeWithUses(ctx, kind, days, validDays, maxUses, createdBy)
- if err != nil {
- return telegramCommandReply{Text: "生成失败：" + err.Error()}
- }
- kindLabel := map[string]string{model.RegistrationCodeRegister: "注册码", model.RegistrationCodeRenew: "续期码"}[code.Kind]
- dur := "永久"
- if days > 0 {
- dur = fmt.Sprintf("%d 天", days)
- }
- valid := "长期有效"
- if validDays > 0 && code.ExpiresAt != nil {
- valid = "有效至 " + code.ExpiresAt.Format("2006-01-02 15:04")
- }
- uses := "单次使用"
- if code.EffectiveMaxUses() > 1 {
- uses = fmt.Sprintf("最多 %d 次", code.EffectiveMaxUses())
- }
- return telegramCommandReply{Text: fmt.Sprintf("已生成%s（%s，%s，%s）：\n\n%s", kindLabel, dur, valid, uses, code.Code)}
-}
diff --git a/internal/service/telegram_admin_users.go b/internal/service/telegram_admin_users.go
deleted file mode 100644
index 2653af2..0000000
--- a/internal/service/telegram_admin_users.go
+++ /dev/null
@@ -1,186 +0,0 @@
-package service
-
-import (
- "context"
- "fmt"
- "strconv"
- "strings"
-)
-
-func (s *TelegramBotService) replyUserList(ctx context.Context) telegramCommandReply {
- users, err := s.repo.User.List(ctx)
- if err != nil {
- return telegramCommandReply{Text: "读取用户失败：" + err.Error()}
- }
- if len(users) == 0 {
- return telegramCommandReply{Text: "暂无用户。"}
- }
- var rows [][]telegramInlineButton
- limit := len(users)
- if limit > 12 {
- limit = 12
- }
- for i := 0; i < limit; i++ {
- u := users[i]
- flag := ""
- if !u.IsActive {
- flag = "🚫"
- }
- if u.Role == "admin" {
- flag = "👑"
- }
- rows = append(rows, []telegramInlineButton{{Text: flag + " " + u.Username, Data: "usr:" + u.ID}})
- }
- rows = append(rows, []telegramInlineButton{{Text: "⬅️ 返回菜单", Data: "menu_main"}})
- return telegramCommandReply{Text: fmt.Sprintf("用户管理（共 %d 人，显示前 %d）\n点击用户进行操作：", len(users), limit), Buttons: rows}
-}
-
-func (s *TelegramBotService) replyUserActions(ctx context.Context, userID string) telegramCommandReply {
- u, err := s.repo.User.FindByID(ctx, userID)
- if err != nil || u == nil {
- return telegramCommandReply{Text: "用户不存在。"}
- }
- protected := UserIsProtectedAccount(ctx, s.repo, u)
- text := fmt.Sprintf("%s\n角色：%s\n状态：%s\n到期：%s\n防共享警告：%d 次",
- u.Username, u.Role, map[bool]string{true: "正常", false: "已禁用"}[u.IsActive], formatExpiry(u.ExpiredAt), u.ShareWarnings)
- if protected {
- return telegramCommandReply{Text: text + "\n\n（受保护账号，不可禁用/删除）", Buttons: [][]telegramInlineButton{{{Text: "⬅️ 返回", Data: "adm_users"}}}}
- }
- banBtn := telegramInlineButton{Text: "🚫 禁用", Data: "uban:" + u.ID}
- if !u.IsActive {
- banBtn = telegramInlineButton{Text: "✅ 解禁", Data: "uunban:" + u.ID}
- }
- return telegramCommandReply{
- Text: text,
- Buttons: [][]telegramInlineButton{
- {banBtn, {Text: "⏳ 续期30天", Data: "urenew:" + u.ID + ":30"}},
- {{Text: "🗑 删除用户", Data: "udel:" + u.ID}},
- {{Text: "⬅️ 返回", Data: "adm_users"}},
- },
- }
-}
-
-func (s *TelegramBotService) replyUserBan(ctx context.Context, userID string, unban bool) telegramCommandReply {
- if !unban {
- if reason := s.protectReason(ctx, userID); reason != "" {
- return telegramCommandReply{Text: reason}
- }
- }
- updates := map[string]any{"is_active": unban}
- if unban {
- updates["share_warnings"] = 0
- updates["last_share_warn_at"] = nil
- }
- if err := s.repo.User.UpdateFields(ctx, userID, updates); err != nil {
- return telegramCommandReply{Text: "操作失败：" + err.Error()}
- }
- if unban {
- _ = s.repo.UserDevice.SetKickedByUser(ctx, userID, false)
- }
- return s.replyUserActions(ctx, userID)
-}
-
-func (s *TelegramBotService) replyUserDelete(ctx context.Context, userID string) telegramCommandReply {
- if reason := s.protectReason(ctx, userID); reason != "" {
- return telegramCommandReply{Text: reason}
- }
- u, _ := s.repo.User.FindByID(ctx, userID)
- _ = s.repo.UserDevice.DeleteByUser(ctx, userID)
- if err := s.repo.User.Delete(ctx, userID); err != nil {
- return telegramCommandReply{Text: "删除失败：" + err.Error()}
- }
- name := userID
- if u != nil {
- name = u.Username
- }
- return telegramCommandReply{Text: fmt.Sprintf("已删除用户 %s。", name), Buttons: [][]telegramInlineButton{{{Text: "⬅️ 返回", Data: "adm_users"}}}}
-}
-
-func (s *TelegramBotService) replyUserRenew(ctx context.Context, payload string) telegramCommandReply {
- parts := strings.Split(payload, ":") // /renew_user 用户名 天数，天数 0 表示永久。"}
- }
- user, _ := s.repo.User.FindByUsername(ctx, args[0])
- if user == nil {
- user, _ = s.repo.User.FindByID(ctx, args[0])
- }
- if user == nil {
- return telegramCommandReply{Text: "未找到用户。"}
- }
- days, err := strconv.Atoi(args[1])
- if err != nil || days < 0 {
- return telegramCommandReply{Text: "天数必须是非负整数。"}
- }
- if err := s.applyRenewal(ctx, user.ID, days); err != nil {
- return telegramCommandReply{Text: "续期失败：" + err.Error()}
- }
- return s.replyUserActions(ctx, user.ID)
-}
-
-func (s *TelegramBotService) cmdUserDelete(ctx context.Context, args []string) telegramCommandReply {
- if len(args) == 0 {
- return telegramCommandReply{Text: "用法：/delete_user 用户名 confirm\n为避免误删，最后一个参数必须是 confirm。"}
- }
- if len(args) < 2 || !strings.EqualFold(args[len(args)-1], "confirm") {
- return telegramCommandReply{Text: "删除用户需要确认：/delete_user 用户名 confirm"}
- }
- user, _ := s.repo.User.FindByUsername(ctx, args[0])
- if user == nil {
- user, _ = s.repo.User.FindByID(ctx, args[0])
- }
- if user == nil {
- return telegramCommandReply{Text: "未找到用户。"}
- }
- return s.replyUserDelete(ctx, user.ID)
-}
-
-// protectReason returns a non-empty message when a user must not be
-// disabled/deleted (admins, default admin and protected-list users).
-func (s *TelegramBotService) protectReason(ctx context.Context, userID string) string {
- u, err := s.repo.User.FindByID(ctx, userID)
- if err != nil || u == nil {
- return "用户不存在。"
- }
- if u.Role == "admin" {
- return "管理员账号受保护，不可禁用/删除。"
- }
- if first, _ := s.repo.User.FirstAdmin(ctx); first != nil && first.ID == u.ID {
- return "默认管理员账号受保护，不可禁用/删除。"
- }
- if _, ok := ProtectedUserIDSet(ctx, s.repo)[u.ID]; ok {
- return "该账号在 Bot 保护名单中，不可禁用/删除。"
- }
- if s.device != nil && s.device.UserRecentlyActive(ctx, u.ID, realtimeSessionTTL) {
- return "该账号最近仍有实时活跃会话，为避免误删/误禁用，请先确认用户已下线。"
- }
- return ""
-}
-
-func (s *TelegramBotService) cmdUserBan(ctx context.Context, args []string, unban bool) telegramCommandReply {
- if len(args) == 0 {
- if unban {
- return telegramCommandReply{Text: "用法：/unban 用户名"}
- }
- return telegramCommandReply{Text: "用法：/ban 用户名"}
- }
- user, _ := s.repo.User.FindByUsername(ctx, args[0])
- if user == nil {
- user, _ = s.repo.User.FindByID(ctx, args[0])
- }
- if user == nil {
- return telegramCommandReply{Text: "未找到用户。"}
- }
- return s.replyUserBan(ctx, user.ID, unban)
-}
diff --git a/internal/service/telegram_api.go b/internal/service/telegram_api.go
deleted file mode 100644
index 6ea8383..0000000
--- a/internal/service/telegram_api.go
+++ /dev/null
@@ -1,232 +0,0 @@
-package service
-
-import (
- "bytes"
- "context"
- "encoding/json"
- "errors"
- "fmt"
- "io"
- "mime/multipart"
- "net/http"
- "net/url"
- "strings"
- "time"
-)
-
-func telegramPostForm(ctx context.Context, cfg map[string]string, method string, form url.Values, timeout time.Duration) error {
- apiURL, err := telegramMethodURL(cfg, cfg["bot_token"], method)
- if err != nil {
- return err
- }
- return telegramDoWithFallback(ctx, cfg, http.MethodPost, apiURL, form.Encode(), "application/x-www-form-urlencoded", timeout)
-}
-
-func telegramPostJSON(ctx context.Context, cfg map[string]string, method string, payload any, timeout time.Duration) error {
- apiURL, err := telegramMethodURL(cfg, cfg["bot_token"], method)
- if err != nil {
- return err
- }
- body, err := json.Marshal(payload)
- if err != nil {
- return err
- }
- return telegramDoWithFallback(ctx, cfg, http.MethodPost, apiURL, string(body), "application/json", timeout)
-}
-
-func telegramPostMultipart(ctx context.Context, cfg map[string]string, method string, fields map[string]string, fileField, fileName string, file []byte, timeout time.Duration) error {
- apiURL, err := telegramMethodURL(cfg, cfg["bot_token"], method)
- if err != nil {
- return err
- }
- var body bytes.Buffer
- writer := multipart.NewWriter(&body)
- for key, value := range fields {
- if strings.TrimSpace(value) == "" {
- continue
- }
- if err := writer.WriteField(key, value); err != nil {
- _ = writer.Close()
- return err
- }
- }
- part, err := writer.CreateFormFile(fileField, fileName)
- if err != nil {
- _ = writer.Close()
- return err
- }
- if _, err := part.Write(file); err != nil {
- _ = writer.Close()
- return err
- }
- if err := writer.Close(); err != nil {
- return err
- }
- return telegramDoWithFallback(ctx, cfg, http.MethodPost, apiURL, body.String(), writer.FormDataContentType(), timeout)
-}
-
-func telegramFetchRemotePhoto(ctx context.Context, cfg map[string]string, rawURL string, timeout time.Duration) ([]byte, string, error) {
- rawURL = strings.TrimSpace(rawURL)
- if rawURL == "" {
- return nil, "", errors.New("telegram photo url required")
- }
- var lastErr error
- for _, client := range telegramHTTPClients(timeout, cfg) {
- req, err := http.NewRequestWithContext(ctx, http.MethodGet, rawURL, nil)
- if err != nil {
- return nil, "", err
- }
- req.Header.Set("User-Agent", "MediaStationGo/1.0")
- resp, err := client.Do(req)
- if err != nil {
- lastErr = sanitizeTelegramError(err)
- continue
- }
- body, readErr := io.ReadAll(io.LimitReader(resp.Body, 10*1024*1024+1))
- _ = resp.Body.Close()
- if readErr != nil {
- lastErr = readErr
- continue
- }
- if resp.StatusCode >= 400 {
- lastErr = fmt.Errorf("photo fetch error %d", resp.StatusCode)
- continue
- }
- if len(body) == 0 {
- lastErr = errors.New("photo fetch returned empty body")
- continue
- }
- if len(body) > 10*1024*1024 {
- lastErr = errors.New("photo too large")
- continue
- }
- contentType := strings.TrimSpace(resp.Header.Get("Content-Type"))
- return body, contentType, nil
- }
- if lastErr != nil {
- return nil, "", lastErr
- }
- return nil, "", errors.New("photo fetch failed")
-}
-
-func deleteTelegramWebhook(ctx context.Context, cfg map[string]string) error {
- payload := map[string]any{
- "drop_pending_updates": false,
- }
- return telegramPostJSON(ctx, cfg, "deleteWebhook", payload, 15*time.Second)
-}
-
-func telegramDo(client *http.Client, req *http.Request) error {
- resp, err := client.Do(req)
- if err != nil {
- return sanitizeTelegramError(err)
- }
- defer resp.Body.Close()
- if resp.StatusCode >= 400 {
- body, _ := io.ReadAll(io.LimitReader(resp.Body, 4096))
- return fmt.Errorf("telegram api error %d: %s", resp.StatusCode, sanitizeTelegramText(string(body)))
- }
- return nil
-}
-
-func telegramDoWithFallback(ctx context.Context, cfg map[string]string, method, apiURL, body, contentType string, timeout time.Duration) error {
- var lastErr error
- for _, client := range telegramHTTPClients(timeout, cfg) {
- req, err := http.NewRequestWithContext(ctx, method, apiURL, strings.NewReader(body))
- if err != nil {
- return err
- }
- if contentType != "" {
- req.Header.Set("Content-Type", contentType)
- }
- if err := telegramDo(client, req); err != nil {
- lastErr = err
- continue
- }
- return nil
- }
- if lastErr != nil {
- return lastErr
- }
- return errors.New("telegram request failed")
-}
-
-func telegramPostJSONDecode(ctx context.Context, cfg map[string]string, method string, payload any, timeout time.Duration, out any) error {
- apiURL, err := telegramMethodURL(cfg, cfg["bot_token"], method)
- if err != nil {
- return err
- }
- body, err := json.Marshal(payload)
- if err != nil {
- return err
- }
- var lastErr error
- for _, client := range telegramHTTPClients(timeout, cfg) {
- req, err := http.NewRequestWithContext(ctx, http.MethodPost, apiURL, strings.NewReader(string(body)))
- if err != nil {
- return err
- }
- req.Header.Set("Content-Type", "application/json")
- resp, err := client.Do(req)
- if err != nil {
- lastErr = sanitizeTelegramError(err)
- continue
- }
- respBody, _ := io.ReadAll(io.LimitReader(resp.Body, 4096))
- _ = resp.Body.Close()
- if resp.StatusCode >= 400 {
- lastErr = fmt.Errorf("telegram api error %d: %s", resp.StatusCode, sanitizeTelegramText(string(respBody)))
- continue
- }
- if out != nil {
- return json.Unmarshal(respBody, out)
- }
- return nil
- }
- if lastErr != nil {
- return lastErr
- }
- return errors.New("telegram request failed")
-}
-
-func telegramGetJSONDecode(ctx context.Context, cfg map[string]string, method string, timeout time.Duration, out any) error {
- apiURL, err := telegramMethodURL(cfg, cfg["bot_token"], method)
- if err != nil {
- return err
- }
- var lastErr error
- for _, client := range telegramHTTPClients(timeout, cfg) {
- req, err := http.NewRequestWithContext(ctx, http.MethodGet, apiURL, nil)
- if err != nil {
- return err
- }
- resp, err := client.Do(req)
- if err != nil {
- lastErr = sanitizeTelegramError(err)
- continue
- }
- respBody, _ := io.ReadAll(io.LimitReader(resp.Body, 4096))
- _ = resp.Body.Close()
- if resp.StatusCode >= 400 {
- lastErr = fmt.Errorf("telegram api error %d: %s", resp.StatusCode, sanitizeTelegramText(string(respBody)))
- continue
- }
- if out != nil {
- return json.Unmarshal(respBody, out)
- }
- return nil
- }
- if lastErr != nil {
- return lastErr
- }
- return errors.New("telegram request failed")
-}
-
-func telegramStringConfigFromAny(cfg map[string]any) map[string]string {
- out := make(map[string]string, len(cfg))
- for key, value := range cfg {
- out[key] = str(value)
- }
- normalizeTelegramConfig(out)
- return out
-}
diff --git a/internal/service/telegram_api_client.go b/internal/service/telegram_api_client.go
deleted file mode 100644
index 3a88709..0000000
--- a/internal/service/telegram_api_client.go
+++ /dev/null
@@ -1,124 +0,0 @@
-package service
-
-import (
- "errors"
- "fmt"
- "net/http"
- "net/url"
- "os"
- "regexp"
- "strings"
- "time"
-)
-
-const defaultTelegramAPIBaseURL = "https://api.telegram.org"
-
-var telegramTokenPattern = regexp.MustCompile(`bot[0-9]+:[^/\s"'?]+`)
-
-func telegramAPIBaseURL(cfg map[string]string) string {
- base := strings.TrimSpace(cfg["api_base_url"])
- if base == "" {
- base = strings.TrimSpace(os.Getenv("MEDIASTATION_TELEGRAM_API_BASE_URL"))
- }
- if base == "" {
- base = defaultTelegramAPIBaseURL
- }
- return strings.TrimRight(base, "/")
-}
-
-func telegramMethodURL(cfg map[string]string, botToken, method string) (string, error) {
- botToken = strings.TrimSpace(botToken)
- method = strings.TrimSpace(method)
- if botToken == "" {
- return "", errors.New("telegram bot_token required")
- }
- if method == "" {
- return "", errors.New("telegram method required")
- }
- base := telegramAPIBaseURL(cfg)
- if _, err := url.ParseRequestURI(base); err != nil {
- return "", fmt.Errorf("telegram api_base_url invalid")
- }
- return fmt.Sprintf("%s/bot%s/%s", base, botToken, method), nil
-}
-
-func telegramHTTPClient(timeout time.Duration, cfg map[string]string) *http.Client {
- clients := telegramHTTPClients(timeout, cfg)
- return clients[0]
-}
-
-func telegramHTTPClients(timeout time.Duration, cfg map[string]string) []*http.Client {
- clients := []*http.Client{}
- seen := map[string]bool{}
- customAPIBase := telegramUsesCustomAPIBase(cfg)
- for _, proxyRaw := range telegramProxyCandidates(cfg) {
- proxyURL, err := normalizeProxyURL(proxyRaw, "http")
- if err != nil || proxyURL == nil {
- continue
- }
- key := proxyURL.String()
- if seen[key] {
- continue
- }
- seen[key] = true
- transport := NewExternalTransport()
- transport.Proxy = http.ProxyURL(proxyURL)
- clients = append(clients, &http.Client{Timeout: timeout, Transport: transport})
- }
- transport := NewExternalTransport()
- if customAPIBase {
- transport = NewInternalTransport()
- }
- clients = append(clients, &http.Client{Timeout: timeout, Transport: transport})
- return clients
-}
-
-func telegramProxyCandidates(cfg map[string]string) []string {
- out := []string{}
- for _, value := range []string{
- cfg["proxy_url"],
- os.Getenv("MEDIASTATION_TELEGRAM_PROXY_URL"),
- } {
- if strings.TrimSpace(value) != "" {
- out = append(out, value)
- }
- }
- if len(out) > 0 {
- return out
- }
- if telegramUsesCustomAPIBase(cfg) {
- return out
- }
- for _, value := range []string{
- "http://127.0.0.1:10808",
- "http://127.0.0.1:10809",
- "http://127.0.0.1:7890",
- "http://127.0.0.1:7891",
- "http://host.docker.internal:7890",
- "http://host.docker.internal:10808",
- "http://172.17.0.1:7890",
- "http://172.17.0.1:10808",
- } {
- out = append(out, value)
- }
- return out
-}
-
-func telegramUsesCustomAPIBase(cfg map[string]string) bool {
- return telegramAPIBaseURL(cfg) != defaultTelegramAPIBaseURL
-}
-
-func sanitizeTelegramError(err error) error {
- if err == nil {
- return nil
- }
- msg := sanitizeTelegramText(err.Error())
- if strings.Contains(msg, "Client.Timeout exceeded") || strings.Contains(msg, "context deadline exceeded") {
- return errors.New("telegram request timeout: 请检查 NAS/Docker 到 Telegram API 的代理、反代或网络连通性")
- }
- return errors.New(msg)
-}
-
-func sanitizeTelegramText(text string) string {
- return telegramTokenPattern.ReplaceAllString(text, "bot/start。"
-}
-
-func telegramGroupPrivateDeliveryFailedHint() string {
- return "无法私聊发送给你。请先打开 Bot 私聊窗口发送 /start，再回群里使用命令。"
-}
diff --git a/internal/service/telegram_bot_binding_test.go b/internal/service/telegram_bot_binding_test.go
deleted file mode 100644
index 9c2209d..0000000
--- a/internal/service/telegram_bot_binding_test.go
+++ /dev/null
@@ -1,293 +0,0 @@
-package service
-
-import (
- "encoding/json"
- "errors"
- "strings"
- "testing"
-
- "go.uber.org/zap"
-
- "github.com/ShukeBta/MediaStationGo/internal/model"
-)
-
-func TestTelegramStartClearsStaleUserBinding(t *testing.T) {
- repos, auth, _, _ := newAuthTestServices(t)
- if err := repos.DB.Create(&model.TelegramBinding{
- TelegramUserID: 20001,
- TelegramName: "@viewer",
- ChatID: 20001,
- UserID: "deleted-user",
- }).Error; err != nil {
- t.Fatalf("create binding: %v", err)
- }
- bot := NewTelegramBotService(zap.NewNop(), repos, nil, auth)
-
- reply := bot.cmdStart(t.Context(), &TelegramMessage{
- From: TelegramUser{ID: 20001, Username: "viewer", FirstName: "Viewer"},
- Chat: TelegramChat{ID: 20001, Type: "private"},
- }, nil)
-
- if !strings.Contains(reply.Text, "已不存在") {
- t.Fatalf("expected stale binding message, got %q", reply.Text)
- }
- var count int64
- if err := repos.DB.Model(&model.TelegramBinding{}).Where("telegram_user_id = ?", 20001).Count(&count).Error; err != nil {
- t.Fatalf("count binding: %v", err)
- }
- if count != 0 {
- t.Fatalf("stale binding should be removed, got %d", count)
- }
-}
-
-func TestTelegramStartReplacesAccountBindingFromAnotherTelegram(t *testing.T) {
- ctx := t.Context()
- repos, auth, _, _ := newAuthTestServices(t)
- user, _, err := auth.Register(ctx, "viewer", "secret-pass")
- if err != nil {
- t.Fatalf("register: %v", err)
- }
- if err := repos.DB.Create(&model.TelegramBinding{
- TelegramUserID: 20001,
- TelegramName: "@viewer-one",
- ChatID: 20001,
- UserID: user.ID,
- }).Error; err != nil {
- t.Fatalf("create binding: %v", err)
- }
-
- bot := NewTelegramBotService(zap.NewNop(), repos, nil, auth)
- cfgJSON, _ := json.Marshal(map[string]string{"admin_user_ids": "20002"})
- if err := repos.DB.AutoMigrate(&model.NotifyChannel{}); err != nil {
- t.Fatalf("migrate notify channel: %v", err)
- }
- if err := repos.DB.Create(&model.NotifyChannel{Name: "Telegram", Type: "telegram", Enabled: true, Config: string(cfgJSON)}).Error; err != nil {
- t.Fatalf("create notify channel: %v", err)
- }
- msg := &TelegramMessage{
- From: TelegramUser{ID: 20002, Username: "viewer-two", FirstName: "Viewer Two"},
- Chat: TelegramChat{ID: 20002, Type: "private"},
- }
- reply := bot.cmdStart(ctx, msg, []string{"viewer", "secret-pass"})
-
- if !strings.Contains(reply.Text, "绑定成功") {
- t.Fatalf("expected new telegram account to replace old binding, got %q", reply.Text)
- }
- var accountBindings int64
- if err := repos.DB.Model(&model.TelegramBinding{}).Where("user_id = ?", user.ID).Count(&accountBindings).Error; err != nil {
- t.Fatalf("count account bindings: %v", err)
- }
- if accountBindings != 1 {
- t.Fatalf("account should keep exactly one telegram binding, got %d", accountBindings)
- }
- if binding := bot.telegramBinding(ctx, 20002); binding == nil || binding.UserID != user.ID {
- t.Fatalf("new telegram account should be bound to user, got %#v", binding)
- }
- if binding := bot.telegramBinding(ctx, 20001); binding != nil {
- t.Fatalf("old telegram binding should be removed, got %#v", binding)
- }
-}
-
-func TestTelegramStartUnbindsWhenBoundPasswordChanged(t *testing.T) {
- ctx := t.Context()
- repos, auth, _, _ := newAuthTestServices(t)
- user, _, err := auth.Register(ctx, "viewer", "old-password")
- if err != nil {
- t.Fatalf("register: %v", err)
- }
- if err := repos.DB.Create(&model.TelegramBinding{
- TelegramUserID: 20003,
- TelegramName: "@viewer",
- ChatID: 20003,
- UserID: user.ID,
- }).Error; err != nil {
- t.Fatalf("create binding: %v", err)
- }
- if err := auth.ResetPassword(ctx, user.ID, "new-password"); err != nil {
- t.Fatalf("reset password: %v", err)
- }
- if err := repos.DB.AutoMigrate(&model.NotifyChannel{}); err != nil {
- t.Fatalf("migrate notify channel: %v", err)
- }
- cfgJSON, _ := json.Marshal(map[string]string{"admin_user_ids": "20003"})
- if err := repos.DB.Create(&model.NotifyChannel{Name: "Telegram", Type: "telegram", Enabled: true, Config: string(cfgJSON)}).Error; err != nil {
- t.Fatalf("create notify channel: %v", err)
- }
-
- bot := NewTelegramBotService(zap.NewNop(), repos, nil, auth)
- msg := &TelegramMessage{
- From: TelegramUser{ID: 20003, Username: "viewer", FirstName: "Viewer"},
- Chat: TelegramChat{ID: 20003, Type: "private"},
- }
- reply := bot.cmdStart(ctx, msg, []string{"viewer", "old-password"})
-
- if !strings.Contains(reply.Text, "已自动解绑") {
- t.Fatalf("expected auto unbind reply, got %q", reply.Text)
- }
- if binding := bot.telegramBinding(ctx, 20003); binding != nil {
- t.Fatal("stale binding should be removed after password mismatch")
- }
-}
-
-func TestTelegramSelfSetNameRequiresCurrentPassword(t *testing.T) {
- ctx := t.Context()
- repos, auth, _, _ := newAuthTestServices(t)
- user, _, err := auth.Register(ctx, "viewer", "old-password")
- if err != nil {
- t.Fatalf("register: %v", err)
- }
- if err := repos.DB.Create(&model.TelegramBinding{
- TelegramUserID: 20004,
- TelegramName: "@viewer",
- ChatID: 20004,
- UserID: user.ID,
- }).Error; err != nil {
- t.Fatalf("create binding: %v", err)
- }
-
- bot := NewTelegramBotService(zap.NewNop(), repos, nil, auth)
- msg := &TelegramMessage{From: TelegramUser{ID: 20004, Username: "viewer"}, Chat: TelegramChat{ID: 20004, Type: "private"}}
- if reply := bot.selfSetName(ctx, msg, "renamed"); !strings.Contains(reply.Text, "当前密码 新用户名") {
- t.Fatalf("expected usage reply, got %q", reply.Text)
- }
- if reply := bot.selfSetName(ctx, msg, "old-password renamed"); !strings.Contains(reply.Text, "用户名已修改") {
- t.Fatalf("expected rename success, got %q", reply.Text)
- }
- updated, _ := repos.User.FindByID(ctx, user.ID)
- if updated == nil || updated.Username != "renamed" {
- t.Fatalf("username not updated: %#v", updated)
- }
-}
-
-func TestTelegramSelfSetPassWrongCurrentPasswordUnbinds(t *testing.T) {
- ctx := t.Context()
- repos, auth, _, _ := newAuthTestServices(t)
- user, _, err := auth.Register(ctx, "viewer", "old-password")
- if err != nil {
- t.Fatalf("register: %v", err)
- }
- if err := repos.DB.Create(&model.TelegramBinding{
- TelegramUserID: 20005,
- TelegramName: "@viewer",
- ChatID: 20005,
- UserID: user.ID,
- }).Error; err != nil {
- t.Fatalf("create binding: %v", err)
- }
-
- bot := NewTelegramBotService(zap.NewNop(), repos, nil, auth)
- msg := &TelegramMessage{From: TelegramUser{ID: 20005, Username: "viewer"}, Chat: TelegramChat{ID: 20005, Type: "private"}}
- reply := bot.selfSetPass(ctx, msg, "wrong-password new-password")
-
- if !strings.Contains(reply.Text, "已自动解绑") {
- t.Fatalf("expected auto unbind reply, got %q", reply.Text)
- }
- if binding := bot.telegramBinding(ctx, 20005); binding != nil {
- t.Fatal("binding should be removed after wrong current password")
- }
- if _, err := auth.Login(ctx, "viewer", "old-password"); err != nil {
- t.Fatalf("old password should remain valid after failed change: %v", err)
- }
-}
-
-func TestTelegramSelfSetPassChangesPasswordWithCurrentPassword(t *testing.T) {
- ctx := t.Context()
- repos, auth, _, _ := newAuthTestServices(t)
- user, _, err := auth.Register(ctx, "viewer", "old-password")
- if err != nil {
- t.Fatalf("register: %v", err)
- }
- if err := repos.DB.Create(&model.TelegramBinding{
- TelegramUserID: 20006,
- TelegramName: "@viewer",
- ChatID: 20006,
- UserID: user.ID,
- }).Error; err != nil {
- t.Fatalf("create binding: %v", err)
- }
-
- bot := NewTelegramBotService(zap.NewNop(), repos, nil, auth)
- msg := &TelegramMessage{From: TelegramUser{ID: 20006, Username: "viewer"}, Chat: TelegramChat{ID: 20006, Type: "private"}}
- reply := bot.selfSetPass(ctx, msg, "old-password new-password")
-
- if !strings.Contains(reply.Text, "密码已修改") {
- t.Fatalf("expected password change success, got %q", reply.Text)
- }
- if _, err := auth.Login(ctx, "viewer", "old-password"); !errors.Is(err, ErrInvalidCredentials) {
- t.Fatalf("old password should fail, got %v", err)
- }
- if _, err := auth.Login(ctx, "viewer", "new-password"); err != nil {
- t.Fatalf("new password should login: %v", err)
- }
- if binding := bot.telegramBinding(ctx, 20006); binding == nil {
- t.Fatal("successful password change should keep telegram binding")
- }
-}
-
-func TestTelegramBindingFromGroupStoresPrivateUserChatID(t *testing.T) {
- ctx := t.Context()
- repos, auth, _, _ := newAuthTestServices(t)
- user, _, err := auth.Register(ctx, "viewer", "secret-pass")
- if err != nil {
- t.Fatalf("register: %v", err)
- }
- bot := NewTelegramBotService(zap.NewNop(), repos, nil, auth)
- msg := &TelegramMessage{
- From: TelegramUser{ID: 21001, Username: "viewer", FirstName: "Viewer"},
- Chat: TelegramChat{ID: -100123456, Type: "group"},
- }
-
- if err := bot.upsertTelegramBinding(ctx, msg, user.ID); err != nil {
- t.Fatalf("upsert binding: %v", err)
- }
- binding := bot.telegramBinding(ctx, 21001)
- if binding == nil {
- t.Fatal("binding should be created")
- }
- if binding.ChatID != 21001 {
- t.Fatalf("group binding must store private user chat id, got %d", binding.ChatID)
- }
-}
-
-func TestTelegramBindingFromGroupPreservesExistingPrivateChatID(t *testing.T) {
- ctx := t.Context()
- repos, auth, _, _ := newAuthTestServices(t)
- user, _, err := auth.Register(ctx, "viewer", "secret-pass")
- if err != nil {
- t.Fatalf("register: %v", err)
- }
- if err := repos.DB.Create(&model.TelegramBinding{
- TelegramUserID: 21002,
- TelegramName: "@viewer",
- ChatID: 987654,
- UserID: user.ID,
- }).Error; err != nil {
- t.Fatalf("seed binding: %v", err)
- }
- bot := NewTelegramBotService(zap.NewNop(), repos, nil, auth)
- msg := &TelegramMessage{
- From: TelegramUser{ID: 21002, Username: "viewer", FirstName: "Viewer"},
- Chat: TelegramChat{ID: -100123456, Type: "supergroup"},
- }
-
- if err := bot.upsertTelegramBinding(ctx, msg, user.ID); err != nil {
- t.Fatalf("upsert binding: %v", err)
- }
- binding := bot.telegramBinding(ctx, 21002)
- if binding == nil {
- t.Fatal("binding should exist")
- }
- if binding.ChatID != 987654 {
- t.Fatalf("group command must not overwrite existing private chat id, got %d", binding.ChatID)
- }
-}
-
-func TestTelegramPrivateNotifyChatIDFallsBackFromLegacyGroupBinding(t *testing.T) {
- binding := model.TelegramBinding{
- TelegramUserID: 21003,
- ChatID: -100123456,
- }
- if got := telegramPrivateChatIDFromBinding(binding); got != 21003 {
- t.Fatalf("legacy group binding should notify private user chat, got %d", got)
- }
-}
diff --git a/internal/service/telegram_bot_commands_core.go b/internal/service/telegram_bot_commands_core.go
deleted file mode 100644
index 7d0d203..0000000
--- a/internal/service/telegram_bot_commands_core.go
+++ /dev/null
@@ -1,225 +0,0 @@
-package service
-
-import (
- "context"
- "errors"
- "fmt"
- "strconv"
- "strings"
-
- "golang.org/x/crypto/bcrypt"
-
- "github.com/ShukeBta/MediaStationGo/internal/model"
-)
-
-// cmdStart 处理 /start 命令。
-func (s *TelegramBotService) cmdStart(ctx context.Context, msg *TelegramMessage, args []string) telegramCommandReply {
- name := msg.From.FirstName
- if msg.From.Username != "" {
- name = "@" + msg.From.Username
- }
- if telegramIsGroupChat(msg.Chat.Type) && len(args) > 0 {
- return telegramCommandReply{Text: telegramGroupPrivateUserHint("绑定账号")}
- }
- if len(args) == 0 {
- if binding := s.telegramBinding(ctx, msg.From.ID); binding != nil {
- user, _ := s.repo.User.FindByID(ctx, binding.UserID)
- if user == nil {
- _ = s.repo.DB.WithContext(ctx).Unscoped().Delete(&model.TelegramBinding{}, "id = ?", binding.ID).Error
- return telegramCommandReply{Text: "之前绑定的媒体中心账号已不存在，请重新绑定：\n/start 用户名 密码"}
- }
- status := "未隐藏"
- if user.HideAdult {
- status = "已隐藏"
- }
- return telegramCommandReply{
- Text: fmt.Sprintf("MediaStationGo 已绑定\n\n你好 %s，当前账号：%s\n成人目录：%s", name, userNameOrFallback(user), status),
- Buttons: [][]telegramInlineButton{{{
- Text: map[bool]string{true: "显示成人目录", false: "隐藏成人目录"}[user.HideAdult],
- Data: "adult_toggle",
- }}},
- }
- }
- hint := "如果没有账号，请联系管理员注册。"
- if s.openRegEnabled(ctx) {
- hint = "如果还没有账号，可直接注册：\n/register 用户名 密码\n或：/register 用户名-密码"
- }
- return telegramCommandReply{Text: "欢迎使用 MediaStationGo\n\n普通用户请先绑定账号：\n/start 用户名 密码\n或：/start 用户名-密码\n\n" + hint}
- }
- channel := s.findChannelForMessage(ctx, msg)
- if dec := s.telegramUserBindDecision(ctx, channel, msg.From.ID); dec != bindAllowed {
- return telegramCommandReply{Text: telegramBindRejectText(dec, "绑定媒体中心账号")}
- }
- username, password := parseStartCredentials(args)
- if username == "" || password == "" {
- return telegramCommandReply{Text: "绑定格式不正确，请使用：\n/start 用户名 密码\n或：/start 用户名-密码"}
- }
- existingBinding := s.telegramBinding(ctx, msg.From.ID)
- user, err := s.repo.User.FindByUsername(ctx, username)
- if err != nil || user == nil {
- if existingBinding != nil {
- _ = s.unbindTelegramUser(ctx, msg.From.ID)
- return telegramCommandReply{Text: "当前绑定的媒体账号信息已失效，已自动解绑。请使用新的用户名和密码重新绑定。"}
- }
- return telegramCommandReply{Text: "未找到此用户，请联系管理员注册。"}
- }
- if !user.IsActive {
- return telegramCommandReply{Text: "此账号已被禁用，请联系管理员。"}
- }
- if err := bcrypt.CompareHashAndPassword([]byte(user.PasswordHash), []byte(password)); err != nil {
- if existingBinding != nil && existingBinding.UserID == user.ID {
- _ = s.unbindTelegramUser(ctx, msg.From.ID)
- return telegramCommandReply{Text: "当前绑定账号的密码已失效，已自动解绑。请使用新密码重新绑定。"}
- }
- return telegramCommandReply{Text: "账号或密码错误。"}
- }
- if err := s.upsertTelegramBinding(ctx, msg, user.ID); err != nil {
- return telegramCommandReply{Text: "绑定失败：" + err.Error()}
- }
- return telegramCommandReply{
- Text: fmt.Sprintf("绑定成功：%s\n\n普通用户只能使用此 Bot 管理自己的成人目录隐藏状态；系统状态、搜索、下载和统计命令仅管理员可用。", user.Username),
- Buttons: [][]telegramInlineButton{{{
- Text: map[bool]string{true: "显示成人目录", false: "隐藏成人目录"}[user.HideAdult],
- Data: "adult_toggle",
- }}},
- }
-}
-
-// cmdRegister 处理 /register 命令：在管理员开启注册后，普通用户可通过 Bot
-// 注册一个新的媒体中心账号，并自动绑定到当前 Telegram 账号。
-func (s *TelegramBotService) cmdRegister(ctx context.Context, channel *model.NotifyChannel, msg *TelegramMessage, args []string) telegramCommandReply {
- if len(args) == 1 && looksLikeRedemptionCode(args[0]) {
- return s.redeemRegisterFlow(ctx, channel, msg, args[0])
- }
- if !s.openRegEnabled(ctx) {
- return telegramCommandReply{Text: "注册功能未开放，请联系管理员开启后再试。"}
- }
- // 开注名额已用尽则拦截（容量随凭证授权实时变化，名额单独计数）。
- if c := s.loadCapacity(ctx); c.Remaining() <= 0 {
- return telegramCommandReply{Text: "注册名额已满，请等待管理员重新开放或扩容授权。"}
- }
- if s.auth == nil {
- return telegramCommandReply{Text: "注册功能暂不可用，请联系管理员。"}
- }
- if channel == nil {
- channel = s.findChannelForMessage(ctx, msg)
- }
- if dec := s.telegramUserBindDecision(ctx, channel, msg.From.ID); dec != bindAllowed {
- return telegramCommandReply{Text: telegramBindRejectText(dec, "注册账号")}
- }
- if binding := s.telegramBinding(ctx, msg.From.ID); binding != nil {
- if user, _ := s.repo.User.FindByID(ctx, binding.UserID); user != nil {
- return telegramCommandReply{Text: fmt.Sprintf("当前 Telegram 已绑定账号：%s，无需重复注册。\n如需切换账号请使用 /start 用户名 密码。", userNameOrFallback(user))}
- }
- }
- username, password := parseStartCredentials(args)
- if username == "" || password == "" {
- return telegramCommandReply{Text: "注册格式不正确，请使用：\n/register 用户名 密码\n或：/register 用户名-密码"}
- }
- user, _, err := s.auth.Register(ctx, username, password)
- if err != nil {
- switch {
- case errors.Is(err, ErrUsernameTaken):
- return telegramCommandReply{Text: "该用户名已被占用，请换一个；如果是你本人的账号，请改用 /start 用户名 密码 绑定。"}
- case errors.Is(err, ErrUserLimitReached):
- return telegramCommandReply{Text: "注册失败：已达到用户数量上限，请联系管理员。"}
- default:
- return telegramCommandReply{Text: "注册失败：" + err.Error()}
- }
- }
- // 注册成功，扣减一个开注名额（名额用尽自动关闭注册）。
- s.consumeOpenRegSlot(ctx)
- if err := s.upsertTelegramBinding(ctx, msg, user.ID); err != nil {
- return telegramCommandReply{Text: fmt.Sprintf("账号 %s 注册成功，但自动绑定失败：%s\n请稍后使用 /start %s 密码 重新绑定。", user.Username, err.Error(), user.Username)}
- }
- return telegramCommandReply{
- Text: fmt.Sprintf("注册并绑定成功：%s\n\n你现在可以用此账号登录网页与第三方客户端。普通用户只能在此 Bot 管理成人目录显隐；其他功能仅管理员可用。", user.Username),
- Buttons: [][]telegramInlineButton{{{
- Text: map[bool]string{true: "显示成人目录", false: "隐藏成人目录"}[user.HideAdult],
- Data: "adult_toggle",
- }}},
- }
-}
-
-// cmdRegistrationToggle handles /registration and /openreg. It uses the same
-// quota-aware open-registration state as the inline Bot menu.
-func (s *TelegramBotService) cmdRegistrationToggle(ctx context.Context, args []string) telegramCommandReply {
- if len(args) == 0 || strings.EqualFold(strings.TrimSpace(args[0]), "status") {
- c := s.loadCapacity(ctx)
- state := "已关闭"
- if c.OpenRegOn {
- if c.OpenRegLimit > 0 {
- state = fmt.Sprintf("已开启（%d/%d 名额）", c.OpenRegUsed, c.OpenRegLimit)
- } else {
- state = "已开启（不限名额，受授权上限约束）"
- }
- }
- return telegramCommandReply{Text: fmt.Sprintf("普通用户 Bot 注册功能当前%s。\n剩余可注册：%d 人。\n\n开启：/registration on 10\n不限：/registration on 0\n关闭：/registration off", state, c.Remaining())}
- }
- switch strings.ToLower(strings.TrimSpace(args[0])) {
- case "on", "true", "1", "open", "enable", "enabled", "开启", "打开", "开":
- limit := 0
- if len(args) > 1 {
- n, err := strconv.Atoi(strings.TrimSpace(args[1]))
- if err != nil || n < 0 {
- return telegramCommandReply{Text: "名额必须是非负整数，0 表示不限名额。"}
- }
- limit = n
- }
- if err := s.openRegistration(ctx, limit); err != nil {
- return telegramCommandReply{Text: "开启失败：" + err.Error()}
- }
- label := "不限名额"
- if limit > 0 {
- label = fmt.Sprintf("%d 个名额", limit)
- }
- return telegramCommandReply{Text: "普通用户 Bot 注册功能已开启：" + label + "。"}
- case "off", "false", "0", "close", "disable", "disabled", "关闭", "关":
- if err := s.closeRegistration(ctx); err != nil {
- return telegramCommandReply{Text: "关闭失败：" + err.Error()}
- }
- return telegramCommandReply{Text: "普通用户 Bot 注册功能已关闭。"}
- default:
- return telegramCommandReply{Text: "参数无效，请使用 /registration on [名额] 或 /registration off。"}
- }
-}
-
-// cmdStatus 处理 /status 命令。
-func (s *TelegramBotService) cmdHideAdult(ctx context.Context, msg *TelegramMessage, args []string) telegramCommandReply {
- channel := s.findChannelForMessage(ctx, msg)
- if dec := s.telegramUserBindDecision(ctx, channel, msg.From.ID); dec != bindAllowed {
- return telegramCommandReply{Text: telegramBindRejectText(dec, "使用成人目录隐藏开关")}
- }
- binding := s.telegramBinding(ctx, msg.From.ID)
- if binding == nil {
- return telegramCommandReply{Text: "请先绑定账号：/start 用户名 密码"}
- }
- user, err := s.repo.User.FindByID(ctx, binding.UserID)
- if err != nil || user == nil {
- return telegramCommandReply{Text: "绑定用户不存在，请重新 /start 绑定。"}
- }
- next := true
- if len(args) > 0 {
- switch strings.ToLower(strings.TrimSpace(args[0])) {
- case "off", "false", "0", "show", "显示", "关闭":
- next = false
- case "on", "true", "1", "hide", "隐藏", "开启":
- next = true
- default:
- next = !user.HideAdult
- }
- } else {
- next = !user.HideAdult
- }
- if err := s.repo.User.UpdateFields(ctx, user.ID, map[string]any{"hide_adult": next}); err != nil {
- return telegramCommandReply{Text: "更新失败：" + err.Error()}
- }
- status := map[bool]string{true: "已隐藏", false: "已显示"}[next]
- return telegramCommandReply{
- Text: "成人目录" + status + "。此设置会同步影响网页与第三方客户端。",
- Buttons: [][]telegramInlineButton{{{
- Text: map[bool]string{true: "显示成人目录", false: "隐藏成人目录"}[next],
- Data: "adult_toggle",
- }}},
- }
-}
diff --git a/internal/service/telegram_bot_commands_help.go b/internal/service/telegram_bot_commands_help.go
deleted file mode 100644
index 6390753..0000000
--- a/internal/service/telegram_bot_commands_help.go
+++ /dev/null
@@ -1,81 +0,0 @@
-package service
-
-import "context"
-
-// cmdHelp 处理 /help 命令。
-func (s *TelegramBotService) cmdHelp(ctx context.Context, msg *TelegramMessage) string {
- channel := s.findChannelForMessage(ctx, msg)
- if telegramIsGroupChat(msg.Chat.Type) {
- adminHint := ""
- if s.telegramUserIsAdmin(ctx, channel, msg.From.ID) {
- adminHint = "\n\n管理员可在已绑定群组直接发送文本管理命令；管理面板和账号凭据操作请私聊 Bot。"
- }
- return "MediaStationGo 群组可用命令\n\n" +
- "/menu — 打开群组自助菜单\n" +
- "/account — 查看账号状态\n" +
- "/signin — 签到\n" +
- "/devices — 查看登录设备\n" +
- "/kick all|编号 — 踢下线设备\n" +
- "/hideadult on|off — 隐藏或显示成人目录\n\n" +
- "绑定、注册、兑换、改名、改密等包含敏感信息的操作请私聊 Bot。" +
- adminHint
- }
- if !s.telegramUserIsAdmin(ctx, channel, msg.From.ID) {
- register := ""
- if s.openRegEnabled(ctx) {
- register = "/register 用户名 密码 — 注册新账号\n"
- }
- return "MediaStationGo 用户命令\n\n" +
- register +
- "/start 用户名 密码 — 绑定账号\n" +
- "/account — 查看账号状态\n" +
- "/signin — 签到\n" +
- "/devices — 查看登录设备\n" +
- "/kick all|编号 — 踢下线设备\n" +
- "/setname 当前密码 新用户名 — 修改用户名\n" +
- "/setpass 当前密码 新密码 — 修改密码\n" +
- "/redeem 兑换码 — 注册或续期兑换\n" +
- "/hideadult on|off — 隐藏或显示成人目录\n\n" +
- "系统状态、搜索、下载列表与统计命令仅管理员可用。"
- }
- return "MediaStationGo 命令列表\n\n" +
- "/start — 开始使用\n" +
- "/help — 帮助信息\n" +
- "/account / /devices / /kick all|编号 — 用户自助设备管理\n" +
- "/signin / /redeem 兑换码 — 签到与兑换\n" +
- "/setname 当前密码 新用户名 / /setpass 当前密码 新密码 — 用户自助改名改密\n" +
- "/register 用户名 密码 — 注册新账号（需管理员开启）\n" +
- "/registration on [名额]|off — 开启/关闭普通用户注册（管理员）\n" +
- "/capacity / /users — 容量与用户管理（管理员）\n" +
- "/gencode register|renew 天数 [有效天数] — 生成兑换码（管理员）\n" +
- "/renew_user 用户名 天数 / /delete_user 用户名 confirm — 续期/删除用户（管理员）\n" +
- "/unbind 用户1 用户2 — 批量解绑 Telegram 绑定（管理员）\n" +
- "/unbind_duplicates / /unbind_inactive 天数 — 清理重复/无效绑定或久未登录绑定（管理员）\n" +
- "/antishare on play=3 login=3 warn=2 — 防共享策略（管理员）\n" +
- "/cleanup run — 预览保号清理候选（管理员）\n" +
- "/cleanup run confirm — 确认清理候选账号（管理员）\n" +
- "/cleanup on|off — 保号规则开关（管理员）\n" +
- "/cleanup_rule list|add|edit|修改|del|enable|disable — Mgo 保号规则（管理员）\n" +
- "/ban 用户名 / /unban 用户名 — 禁用/解禁用户（管理员）\n" +
- "/hideadult on|off — 隐藏/显示当前绑定账号的成人目录\n" +
- "/status — 系统运行状态\n" +
- "/search 关键词 — 搜索媒体库\n" +
- "/downloads — 下载列表\n" +
- "/stats — 媒体库统计\n\n" +
- telegramMgoAdminCommandHelp() + "\n\n" +
- "自动推送事件：\n" +
- "• 订阅命中新资源\n" +
- "• 下载任务完成\n" +
- "• 刮削失败告警\n" +
- "• 系统异常通知"
-}
-
-func telegramMgoAdminCommandHelp() string {
- return "Mgo 管理命令（管理员可用，已注册到命令栏）：\n" +
- "用户：/ucr 用户名 密码 [天数] 创建账号；/uinfo 用户名 查询账号；/rmemby 用户名 confirm 删除账号；/only_rm_record tg:ID|用户名 仅删 Bot 绑定；/renewall 天数 confirm 批量续期。\n" +
- "审计：/userip 用户名 查用户 IP；/auditip IP 按 IP 审计；/auditdevice 关键词 按终端设备审计；/auditclient 关键词 按客户端审计；/udeviceid 设备ID 按设备指纹审计。\n" +
- "清理：/syncunbound 检查未绑定账号；/syncgroupm 校验群成员；/check_ex 检查过期账号；/deleted 按保号规则预览清理候选。\n" +
- "权限：/embyadmin 用户名 on|off 设置管理员；/banall confirm//unbanall confirm 批量禁用/解禁；/prouser 用户名//revuser 用户名 管理保护名单；/embylibs_blockall//embylibs_unblockall 批量禁用/开放媒体库权限。\n" +
- "运维：/proadmin TelegramID//revadmin TelegramID 管理 Bot 管理员；/backup_db 备份数据库；/restore_from_db 文件名 confirm 恢复数据库。\n" +
- "说明：重复别名如 /low_activity、/urm 仍可兼容识别，但不显示在命令栏。"
-}
diff --git a/internal/service/telegram_bot_user_test.go b/internal/service/telegram_bot_user_test.go
deleted file mode 100644
index d506f41..0000000
--- a/internal/service/telegram_bot_user_test.go
+++ /dev/null
@@ -1,286 +0,0 @@
-package service
-
-import (
- "encoding/json"
- "strings"
- "testing"
-
- "go.uber.org/zap"
-
- "github.com/ShukeBta/MediaStationGo/internal/model"
-)
-
-func TestTelegramUpdateActionableDispatchesCallbackQuery(t *testing.T) {
- if !telegramUpdateActionable(TelegramUpdate{CallbackQuery: &TelegramCallbackQuery{Data: "adult_toggle"}}) {
- t.Fatal("callback_query update must be dispatched, otherwise inline buttons break")
- }
- if !telegramUpdateActionable(TelegramUpdate{Message: &TelegramMessage{Text: "/help"}}) {
- t.Fatal("text command message must be dispatched")
- }
- if telegramUpdateActionable(TelegramUpdate{}) {
- t.Fatal("empty update must be skipped")
- }
- if telegramUpdateActionable(TelegramUpdate{Message: &TelegramMessage{}}) {
- t.Fatal("message without text must be skipped")
- }
-}
-
-func TestTelegramCallbackTogglesAdultVisibility(t *testing.T) {
- ctx := t.Context()
- repos, auth, _, _ := newAuthTestServices(t)
- user, _, err := auth.Register(ctx, "viewer", "secret-pass")
- if err != nil {
- t.Fatalf("register user: %v", err)
- }
- if err := repos.DB.Create(&model.TelegramBinding{
- TelegramUserID: 30001,
- TelegramName: "@viewer",
- ChatID: 30001,
- UserID: user.ID,
- }).Error; err != nil {
- t.Fatalf("create binding: %v", err)
- }
- if err := repos.DB.AutoMigrate(&model.NotifyChannel{}); err != nil {
- t.Fatalf("migrate notify_channels: %v", err)
- }
- // 配置一个绑定该 Telegram 用户的渠道（无 bot_token，避免测试触发网络请求）。
- cfg, _ := json.Marshal(map[string]string{"admin_user_ids": "30001"})
- if err := repos.DB.Create(&model.NotifyChannel{
- Name: "Telegram",
- Type: "telegram",
- Enabled: true,
- Config: string(cfg),
- }).Error; err != nil {
- t.Fatalf("create channel: %v", err)
- }
-
- before, err := repos.User.FindByID(ctx, user.ID)
- if err != nil || before == nil {
- t.Fatalf("load user before toggle: %v", err)
- }
-
- bot := NewTelegramBotService(zap.NewNop(), repos, nil, auth)
- update, _ := json.Marshal(TelegramUpdate{
- UpdateID: 1,
- CallbackQuery: &TelegramCallbackQuery{
- ID: "cb1",
- From: TelegramUser{ID: 30001, Username: "viewer", FirstName: "Viewer"},
- Message: &TelegramMessage{MessageID: 5, Chat: TelegramChat{ID: 30001, Type: "private"}},
- Data: "adult_toggle",
- },
- })
- // reply 因 bot_token 为空会返回错误，但成人目录状态应已在数据库中被切换。
- _ = bot.HandleWebhook(ctx, update)
-
- updated, err := repos.User.FindByID(ctx, user.ID)
- if err != nil || updated == nil {
- t.Fatalf("reload user: %v", err)
- }
- if updated.HideAdult == before.HideAdult {
- t.Fatalf("adult_toggle callback should have flipped HideAdult (was %v)", before.HideAdult)
- }
-}
-
-func TestTelegramRegisterRespectsAdminToggle(t *testing.T) {
- ctx := t.Context()
- repos, auth, _, _ := newAuthTestServices(t)
- if err := repos.DB.AutoMigrate(&model.Setting{}, &model.NotifyChannel{}); err != nil {
- t.Fatalf("migrate: %v", err)
- }
- // 预置一个管理员，确保通过 Bot 注册的用户是普通角色而非首个管理员。
- if _, _, err := auth.Register(ctx, "rootadmin", "admin-pass"); err != nil {
- t.Fatalf("seed admin: %v", err)
- }
-
- bot := NewTelegramBotService(zap.NewNop(), repos, nil, auth)
- // 把注册者放进 admin_user_ids，即可让 telegramUserCanBind 通过（私聊场景，
- // 无需走 getChatMember 网络校验）；注册流程本身不依赖角色。
- cfgJSON, _ := json.Marshal(map[string]string{"admin_user_ids": "999"})
- channel := &model.NotifyChannel{Name: "Telegram", Type: "telegram", Enabled: true, Config: string(cfgJSON)}
-
- msg := &TelegramMessage{From: TelegramUser{ID: 999, Username: "newbie", FirstName: "Newbie"}, Chat: TelegramChat{ID: 999, Type: "private"}}
-
- // 默认关闭：拒绝且不创建用户。
- if reply := bot.cmdRegister(ctx, channel, msg, []string{"newbie", "secret-pass"}); !strings.Contains(reply.Text, "未开放") {
- t.Fatalf("registration disabled by default, got %q", reply.Text)
- }
- if u, _ := repos.User.FindByUsername(ctx, "newbie"); u != nil {
- t.Fatal("no user should be created while registration disabled")
- }
-
- // 管理员开启后注册成功并自动绑定。
- if err := bot.setRegistrationEnabled(ctx, true); err != nil {
- t.Fatalf("enable registration: %v", err)
- }
- reply := bot.cmdRegister(ctx, channel, msg, []string{"newbie", "secret-pass"})
- if !strings.Contains(reply.Text, "注册并绑定成功") {
- t.Fatalf("expected success reply, got %q", reply.Text)
- }
- created, err := repos.User.FindByUsername(ctx, "newbie")
- if err != nil || created == nil {
- t.Fatalf("user should be created after enabling: %v", err)
- }
- if created.Role != "user" {
- t.Fatalf("bot-registered account should be a regular user, got role %q", created.Role)
- }
- if binding := bot.telegramBinding(ctx, 999); binding == nil || binding.UserID != created.ID {
- t.Fatalf("telegram should be bound to the newly registered user")
- }
-
- // 重复注册：已绑定 → 提示无需重复注册。
- if reply := bot.cmdRegister(ctx, channel, msg, []string{"another", "pass-2"}); !strings.Contains(reply.Text, "无需重复注册") {
- t.Fatalf("expected already-bound reply, got %q", reply.Text)
- }
-}
-
-func TestTelegramGroupHidesAdminPanelFromRegularUsers(t *testing.T) {
- ctx := t.Context()
- _, bot := newBotTestService(t)
- channel := &model.NotifyChannel{Name: "Telegram", Type: "telegram", Enabled: true, Config: `{"group_chat_id":"-100123","admin_user_ids":"9001"}`}
- msg := &TelegramMessage{
- From: TelegramUser{ID: 9002, Username: "viewer", FirstName: "Viewer"},
- Chat: TelegramChat{ID: -100123, Type: "supergroup"},
- }
-
- menu := bot.mainMenu(ctx, channel, msg)
- if strings.Contains(menu.Text, "管理员") || telegramReplyHasButtonPrefix(menu, "adm_") {
- t.Fatalf("regular group user must not see admin panel: text=%q buttons=%#v", menu.Text, menu.Buttons)
- }
-
- reply, err := bot.executeCommand(ctx, channel, msg, "/users")
- if err != nil {
- t.Fatal(err)
- }
- if reply.Text != "" || len(reply.Buttons) != 0 {
- t.Fatalf("regular group user admin command should be ignored, got %#v", reply)
- }
-
- reply, err = bot.executeCommand(ctx, channel, msg, "/start viewer secret-pass")
- if err != nil {
- t.Fatal(err)
- }
- if !strings.Contains(reply.Text, "请私聊 Bot") {
- t.Fatalf("group credential command should point to private chat, got %q", reply.Text)
- }
-}
-
-func TestTelegramGroupAdminMenuExposesButtonsOnlyToAdmins(t *testing.T) {
- ctx := t.Context()
- repos, bot := newBotTestService(t)
- admin := &model.User{Username: "root", PasswordHash: "x", Role: "admin", IsActive: true}
- if err := repos.User.Create(ctx, admin); err != nil {
- t.Fatal(err)
- }
- channel := &model.NotifyChannel{Name: "Telegram", Type: "telegram", Enabled: true, Config: `{"group_chat_id":"-100123","admin_user_ids":"9001"}`}
- msg := &TelegramMessage{
- From: TelegramUser{ID: 9001, Username: "admin", FirstName: "Admin"},
- Chat: TelegramChat{ID: -100123, Type: "group"},
- }
-
- menu := bot.mainMenu(ctx, channel, msg)
- if !telegramReplyHasButtonPrefix(menu, "adm_") {
- t.Fatalf("admin group menu should expose admin buttons, got %#v", menu.Buttons)
- }
- if !strings.Contains(menu.Text, "管理员入口") {
- t.Fatalf("admin group menu should label admin section, got %q", menu.Text)
- }
-
- reply, handled := bot.handleMenuCallback(ctx, channel, msg, "adm_users")
- if !handled {
- t.Fatal("admin callback should be handled")
- }
- if !strings.Contains(reply.Text, "用户管理") {
- t.Fatalf("group admin callback should render admin panel, got %#v", reply)
- }
-
- normal := &TelegramMessage{
- From: TelegramUser{ID: 9002, Username: "viewer", FirstName: "Viewer"},
- Chat: TelegramChat{ID: -100123, Type: "group"},
- }
- normalMenu := bot.mainMenu(ctx, channel, normal)
- if telegramReplyHasButtonPrefix(normalMenu, "adm_") || strings.Contains(normalMenu.Text, "管理员入口") {
- t.Fatalf("normal group user must not see admin controls: %#v", normalMenu)
- }
- normalReply, handled := bot.handleMenuCallback(ctx, channel, normal, "adm_users")
- if !handled || normalReply.Text != "" || len(normalReply.Buttons) != 0 {
- t.Fatalf("normal group user must not use admin callbacks: %#v handled=%v", normalReply, handled)
- }
-
- reply, err := bot.executeCommand(ctx, channel, msg, "/users")
- if err != nil {
- t.Fatal(err)
- }
- if !strings.Contains(reply.Text, "用户管理") {
- t.Fatalf("bound group admin text command should run, got %q", reply.Text)
- }
- if len(reply.Buttons) == 0 {
- t.Fatalf("group admin text command should expose admin action buttons: %#v", reply.Buttons)
- }
-}
-
-func TestTelegramPollingChannelHintWinsForPrivateMessages(t *testing.T) {
- ctx := t.Context()
- repos, bot := newBotTestService(t)
- msg := &TelegramMessage{
- From: TelegramUser{ID: 9101, Username: "viewer", FirstName: "Viewer"},
- Chat: TelegramChat{ID: 9101, Type: "private"},
- }
- bad := model.NotifyChannel{Name: "BadToken", Type: "telegram", Enabled: true, Config: `{"bot_token":"bad","admin_user_ids":"9101"}`}
- good := model.NotifyChannel{Name: "GoodToken", Type: "telegram", Enabled: true, Config: `{"bot_token":"good","admin_user_ids":"9101"}`}
- if err := repos.DB.Create(&bad).Error; err != nil {
- t.Fatal(err)
- }
- if err := repos.DB.Create(&good).Error; err != nil {
- t.Fatal(err)
- }
-
- if first := bot.findChannelForMessage(ctx, msg); first == nil || first.ID != bad.ID {
- t.Fatalf("setup expected normal private lookup to pick first channel, got %#v", first)
- }
- if hinted := bot.channelForMessage(ctx, msg, &good); hinted == nil || hinted.ID != good.ID {
- t.Fatalf("polling channel hint should route replies through the token that received the update, got %#v", hinted)
- }
-}
-
-func TestTelegramMgoCompatibleUserCommands(t *testing.T) {
- ctx := t.Context()
- repos, bot := newBotTestService(t)
- user := &model.User{Username: "viewer", PasswordHash: "hash", Role: "user", IsActive: true}
- if err := repos.User.Create(ctx, user); err != nil {
- t.Fatal(err)
- }
- if err := repos.DB.Create(&model.TelegramBinding{TelegramUserID: 9102, ChatID: 9102, UserID: user.ID}).Error; err != nil {
- t.Fatal(err)
- }
- channel := &model.NotifyChannel{Name: "Telegram", Type: "telegram", Enabled: true, Config: `{"admin_user_ids":"9102"}`}
- msg := &TelegramMessage{
- From: TelegramUser{ID: 9102, Username: "viewer", FirstName: "Viewer"},
- Chat: TelegramChat{ID: 9102, Type: "private"},
- }
-
- info, err := bot.executeCommand(ctx, channel, msg, "/myinfo")
- if err != nil {
- t.Fatal(err)
- }
- if !strings.Contains(info.Text, "我的账号") {
- t.Fatalf("/myinfo should show account info, got %q", info.Text)
- }
- count, err := bot.executeCommand(ctx, channel, msg, "/count")
- if err != nil {
- t.Fatal(err)
- }
- if !strings.Contains(count.Text, "媒体库统计") {
- t.Fatalf("/count should show library counts, got %q", count.Text)
- }
-}
-
-func telegramReplyHasButtonPrefix(reply telegramCommandReply, prefix string) bool {
- for _, row := range reply.Buttons {
- for _, button := range row {
- if strings.HasPrefix(button.Data, prefix) {
- return true
- }
- }
- }
- return false
-}
diff --git a/internal/service/telegram_callback.go b/internal/service/telegram_callback.go
deleted file mode 100644
index 08816ae..0000000
--- a/internal/service/telegram_callback.go
+++ /dev/null
@@ -1,77 +0,0 @@
-package service
-
-import (
- "context"
- "strings"
- "time"
-
- "go.uber.org/zap"
-
- "github.com/ShukeBta/MediaStationGo/internal/model"
-)
-
-func (s *TelegramBotService) handleCallback(ctx context.Context, cb *TelegramCallbackQuery, channelHint *model.NotifyChannel) error {
- if cb == nil || cb.Message == nil {
- return nil
- }
- msg := *cb.Message
- msg.From = cb.From
- channel := s.channelForMessage(ctx, &msg, channelHint)
- if channel == nil {
- channel = s.findChannelByChatID(ctx, cb.Message.Chat.ID)
- }
- // 立即应答回调，关闭按钮上的加载状态，避免客户端长时间转圈。
- if telegramIsGroupChat(cb.Message.Chat.Type) {
- s.answerCallbackWithText(ctx, channel, cb.ID, "为了隐私，群组内按钮面板已禁用。请私聊 Bot 或在群里发送 /menu，我会把面板私聊给你。", true)
- s.deleteTelegramSourceMessage(channel, cb.Message.Chat.ID, cb.Message.MessageID)
- return nil
- }
- if cb.Message.Chat.Type == "private" && cb.Message.Chat.ID != cb.From.ID {
- s.answerCallbackWithText(ctx, channel, cb.ID, "这个面板不属于你，请发送 /menu 打开自己的面板。", true)
- return nil
- }
- s.answerCallback(ctx, channel, cb.ID)
- data := strings.TrimSpace(cb.Data)
- if data == "adult_toggle" {
- reply := s.cmdHideAdult(ctx, &msg, nil)
- if reply.Text != "" {
- err := s.reply(ctx, channel, cb.Message.Chat.ID, reply)
- s.deleteTelegramSourceMessage(channel, cb.Message.Chat.ID, cb.Message.MessageID)
- return err
- }
- return nil
- }
- if reply, handled := s.handleMenuCallback(ctx, channel, &msg, data); handled {
- if reply.Text != "" {
- err := s.reply(ctx, channel, cb.Message.Chat.ID, reply)
- s.deleteTelegramSourceMessage(channel, cb.Message.Chat.ID, cb.Message.MessageID)
- return err
- }
- }
- return nil
-}
-
-// answerCallback 应答 Telegram 回调查询，关闭按钮上的加载提示。
-func (s *TelegramBotService) answerCallback(ctx context.Context, channel *model.NotifyChannel, callbackID string) {
- s.answerCallbackWithText(ctx, channel, callbackID, "", false)
-}
-
-func (s *TelegramBotService) answerCallbackWithText(ctx context.Context, channel *model.NotifyChannel, callbackID, text string, showAlert bool) {
- if channel == nil || strings.TrimSpace(callbackID) == "" {
- return
- }
- cfg := s.telegramChannelConfig(channel)
- if strings.TrimSpace(cfg["bot_token"]) == "" {
- return
- }
- payload := map[string]interface{}{
- "callback_query_id": callbackID,
- }
- if strings.TrimSpace(text) != "" {
- payload["text"] = text
- payload["show_alert"] = showAlert
- }
- if err := telegramPostJSON(ctx, cfg, "answerCallbackQuery", payload, 8*time.Second); err != nil {
- s.log.Debug("telegram answerCallbackQuery failed", zap.Error(sanitizeTelegramError(err)))
- }
-}
diff --git a/internal/service/telegram_channel_resolve.go b/internal/service/telegram_channel_resolve.go
deleted file mode 100644
index af30068..0000000
--- a/internal/service/telegram_channel_resolve.go
+++ /dev/null
@@ -1,160 +0,0 @@
-package service
-
-import (
- "context"
- "encoding/json"
- "strconv"
- "strings"
-
- "github.com/ShukeBta/MediaStationGo/internal/model"
-)
-
-// findChannelByChatID 根据 chat_id 查找已配置的通知渠道。
-func (s *TelegramBotService) findChannelByChatID(ctx context.Context, chatID int) *model.NotifyChannel {
- channels, err := s.repo.NotifyChannel.ListByType(ctx, "telegram")
- if err != nil {
- return nil
- }
- target := strconv.Itoa(chatID)
- for _, ch := range channels {
- if !ch.Enabled {
- continue
- }
- configStr := ch.Config
- if s.crypto != nil && configStr != "" {
- configStr = s.crypto.Decrypt(configStr)
- }
- var cfg map[string]string
- if err := json.Unmarshal([]byte(configStr), &cfg); err != nil {
- continue
- }
- if cfg["chat_id"] == target || cfg["command_chat_id"] == target ||
- cfg["group_chat_id"] == target || cfg["channel_chat_id"] == target {
- return &ch
- }
- }
- if len(channels) == 1 && channels[0].Enabled {
- return &channels[0]
- }
- return nil
-}
-
-func (s *TelegramBotService) findChannelForMessage(ctx context.Context, msg *TelegramMessage) *model.NotifyChannel {
- if msg == nil {
- return nil
- }
- if msg.Chat.Type != "" && msg.Chat.Type != "private" {
- return s.findChannelByChatID(ctx, msg.Chat.ID)
- }
- channels, err := s.repo.NotifyChannel.ListByType(ctx, "telegram")
- if err != nil {
- return nil
- }
- var first *model.NotifyChannel
- for i := range channels {
- ch := channels[i]
- if !ch.Enabled {
- continue
- }
- if first == nil {
- first = &ch
- }
- if s.telegramUserIsAdmin(ctx, &ch, msg.From.ID) || s.telegramUserCanBind(ctx, &ch, msg.From.ID) {
- return &ch
- }
- }
- return first
-}
-
-func (s *TelegramBotService) channelForMessage(ctx context.Context, msg *TelegramMessage, hint *model.NotifyChannel) *model.NotifyChannel {
- if hint == nil {
- return s.findChannelForMessage(ctx, msg)
- }
- if msg == nil {
- return hint
- }
- if msg.Chat.Type != "" && msg.Chat.Type != "private" && !s.telegramChatAllowed(hint, msg.Chat.ID) {
- return nil
- }
- return hint
-}
-
-func (s *TelegramBotService) telegramChatAllowed(channel *model.NotifyChannel, chatID int) bool {
- if channel == nil {
- return false
- }
- configStr := channel.Config
- if s.crypto != nil && configStr != "" {
- configStr = s.crypto.Decrypt(configStr)
- }
- var cfg map[string]string
- if err := json.Unmarshal([]byte(configStr), &cfg); err != nil {
- return false
- }
- target := strconv.Itoa(chatID)
- for _, key := range []string{"group_chat_id", "channel_chat_id", "command_chat_id"} {
- if configured := strings.TrimSpace(cfg[key]); configured != "" && configured == target {
- return true
- }
- }
- if strings.TrimSpace(cfg["group_chat_id"]) != "" || strings.TrimSpace(cfg["channel_chat_id"]) != "" || strings.TrimSpace(cfg["command_chat_id"]) != "" {
- return false
- }
- return strings.TrimSpace(cfg["chat_id"]) == target
-}
-
-func (s *TelegramBotService) telegramUserIDConfigured(channel *model.NotifyChannel, telegramUserID int) bool {
- if channel == nil || telegramUserID == 0 {
- return false
- }
- cfg := s.telegramChannelConfig(channel)
- target := strconv.Itoa(telegramUserID)
- for _, value := range telegramConfiguredUserIDs(cfg["admin_user_ids"]) {
- if value == target {
- return true
- }
- }
- if strings.TrimSpace(cfg["admin_user_ids"]) == "" && strings.TrimSpace(cfg["chat_id"]) == target {
- return true
- }
- return false
-}
-
-func (s *TelegramBotService) telegramChannelConfig(channel *model.NotifyChannel) map[string]string {
- return telegramConfigFromChannel(s.crypto, channel)
-}
-
-func telegramConfigFromChannel(crypto *CryptoService, channel *model.NotifyChannel) map[string]string {
- if channel == nil {
- return map[string]string{}
- }
- configStr := channel.Config
- if crypto != nil && configStr != "" {
- configStr = crypto.Decrypt(configStr)
- }
- var cfg map[string]string
- if err := json.Unmarshal([]byte(configStr), &cfg); err != nil || cfg == nil {
- return map[string]string{}
- }
- normalizeTelegramConfig(cfg)
- return cfg
-}
-
-func normalizeTelegramConfig(cfg map[string]string) {
- if cfg == nil {
- return
- }
- chatID := strings.TrimSpace(cfg["chat_id"])
- if chatID == "" {
- return
- }
- if strings.HasPrefix(chatID, "-") {
- if strings.TrimSpace(cfg["group_chat_id"]) == "" && strings.TrimSpace(cfg["channel_chat_id"]) == "" && strings.TrimSpace(cfg["command_chat_id"]) == "" {
- cfg["group_chat_id"] = chatID
- }
- return
- }
- if strings.TrimSpace(cfg["admin_user_ids"]) == "" {
- cfg["admin_user_ids"] = chatID
- }
-}
diff --git a/internal/service/telegram_cleanup_rules.go b/internal/service/telegram_cleanup_rules.go
deleted file mode 100644
index 6103b83..0000000
--- a/internal/service/telegram_cleanup_rules.go
+++ /dev/null
@@ -1,220 +0,0 @@
-package service
-
-import (
- "context"
- "encoding/json"
- "fmt"
- "strconv"
- "strings"
-)
-
-func (s *TelegramBotService) currentCleanupRules(ctx context.Context) []accountCleanupRule {
- cfg := loadBotConfig(ctx, s.repo)
- return cfg.AccountCleanupRules
-}
-
-func (s *TelegramBotService) saveCleanupRules(ctx context.Context, rules []accountCleanupRule) error {
- raw, err := json.Marshal(normalizeCleanupRules(rules))
- if err != nil {
- return err
- }
- return s.repo.Setting.Set(ctx, SettingAccountCleanupRules, string(raw))
-}
-
-func parseCommandBool(value string) (bool, bool) {
- switch strings.ToLower(strings.TrimSpace(value)) {
- case "on", "true", "1", "yes", "enable", "enabled", "开启", "开":
- return true, true
- case "off", "false", "0", "no", "disable", "disabled", "关闭", "关":
- return false, true
- default:
- return false, false
- }
-}
-
-func parseCleanupRuleCommand(args []string) (accountCleanupRule, error) {
- if len(args) < 2 {
- return accountCleanupRule{}, fmt.Errorf("新增规则参数不足")
- }
- rule := accountCleanupRule{
- Type: strings.ToLower(strings.TrimSpace(args[0])),
- ID: strings.TrimSpace(args[1]),
- Enabled: true,
- WindowDaysMin: 3,
- WindowDaysMax: 5,
- MinHours: 6,
- MinCount: 1,
- }
- switch rule.Type {
- case "watch_hours":
- name, values := cleanupRuleNameAndValues(args[2:], 3)
- rule.Name = name
- if len(values) >= 3 {
- rule.WindowDaysMin, _ = strconv.Atoi(values[0])
- rule.WindowDaysMax, _ = strconv.Atoi(values[1])
- rule.MinHours, _ = strconv.ParseFloat(values[2], 64)
- if rule.Name == "" {
- rule.Name = fmt.Sprintf("%d~%d 天观看满 %s 小时", rule.WindowDaysMin, rule.WindowDaysMax, formatRuleHours(rule.MinHours))
- }
- }
- case "recent_login":
- name, values := cleanupRuleNameAndValues(args[2:], 1)
- rule.Name = name
- if len(values) >= 1 {
- rule.WindowDaysMax, _ = strconv.Atoi(values[0])
- if rule.Name == "" {
- rule.Name = fmt.Sprintf("%d 天内登录", rule.WindowDaysMax)
- }
- }
- case "signin_streak", "account_age_grace":
- name, values := cleanupRuleNameAndValues(args[2:], 1)
- rule.Name = name
- if len(values) >= 1 {
- rule.MinCount, _ = strconv.Atoi(values[0])
- if rule.Name == "" {
- if rule.Type == "signin_streak" {
- rule.Name = fmt.Sprintf("连续签到 %d 天", rule.MinCount)
- } else {
- rule.Name = fmt.Sprintf("新号宽限 %d 天", rule.MinCount)
- }
- }
- }
- default:
- return accountCleanupRule{}, fmt.Errorf("不支持的规则类型：%s", rule.Type)
- }
- normalized := normalizeCleanupRules([]accountCleanupRule{rule})
- if len(normalized) == 0 {
- return accountCleanupRule{}, fmt.Errorf("规则无效")
- }
- return normalized[0], nil
-}
-
-func cleanupRuleNameAndValues(args []string, numericCount int) (string, []string) {
- if len(args) == 0 {
- return "", nil
- }
- if len(args) >= numericCount && cleanupRuleValuesAreNumeric(args[:numericCount]) {
- return "", args
- }
- return strings.TrimSpace(args[0]), args[1:]
-}
-
-func cleanupRuleValuesAreNumeric(values []string) bool {
- for _, value := range values {
- if _, err := strconv.ParseFloat(strings.TrimSpace(value), 64); err != nil {
- return false
- }
- }
- return true
-}
-
-func formatCleanupRules(rules []accountCleanupRule) string {
- if len(rules) == 0 {
- return "保号规则\n\n暂无规则。"
- }
- var sb strings.Builder
- sb.WriteString("保号规则\n")
- for i, r := range rules {
- state := map[bool]string{true: "启用", false: "停用"}[r.Enabled]
- detail := cleanupRuleDetail(r)
- parts := []string{
- fmt.Sprintf("\n%d. %s", i+1, r.ID),
- }
- if shouldShowCleanupRuleName(r, detail) {
- parts = append(parts, r.Name)
- }
- parts = append(parts, cleanupRuleTypeLabel(r.Type), state)
- if detail != "" {
- parts = append(parts, detail)
- }
- sb.WriteString(strings.Join(parts, " · "))
- }
- return sb.String()
-}
-
-func shouldShowCleanupRuleName(r accountCleanupRule, detail string) bool {
- name := strings.TrimSpace(r.Name)
- if name == "" || strings.EqualFold(name, r.ID) {
- return false
- }
- if detail != "" && strings.EqualFold(name, detail) {
- return false
- }
- return true
-}
-
-func cleanupRuleDetail(r accountCleanupRule) string {
- switch r.Type {
- case "watch_hours":
- return fmt.Sprintf("%d~%d 天 %s 小时", r.WindowDaysMin, r.WindowDaysMax, formatRuleHours(r.MinHours))
- case "recent_login":
- return fmt.Sprintf("%d 天内登录", r.WindowDaysMax)
- case "signin_streak":
- return fmt.Sprintf("连续签到 %d 天", r.MinCount)
- case "account_age_grace":
- return fmt.Sprintf("新号宽限 %d 天", r.MinCount)
- default:
- return ""
- }
-}
-
-func formatRuleHours(hours float64) string {
- if hours == float64(int(hours)) {
- return strconv.Itoa(int(hours))
- }
- return fmt.Sprintf("%.1f", hours)
-}
-
-func cleanupRuleTypeLabel(t string) string {
- switch t {
- case "watch_hours":
- return "观看时长"
- case "recent_login":
- return "最近登录"
- case "signin_streak":
- return "连续签到"
- case "account_age_grace":
- return "新号宽限"
- default:
- return t
- }
-}
-
-func cleanupRuleHelp() string {
- return "Mgo 保号规则命令\n\n" +
- "/cleanup_rule list — 查看规则\n" +
- "/cleanup_rule add watch_hours watch_3_5d_6h 观看3到5天满6小时 3 5 6\n" +
- "/cleanup_rule add recent_login login_7d 七天内登录 7\n" +
- "/cleanup_rule add signin_streak sign_3 连续签到3天 3\n" +
- "/cleanup_rule add account_age_grace new_7d 新号宽限7天 7\n" +
- "/cleanup_rule edit 规则类型 规则ID 名称 参数... — 修改同 ID 规则\n" +
- "/cleanup_rule 修改 规则类型 规则ID 名称 参数... — 中文修改入口\n" +
- "/cleanup_rule enable 规则ID / disable 规则ID\n" +
- "/cleanup_rule del 规则ID\n\n" +
- "保号模式固定为：满足任意一条启用规则即保留；全部不满足才会清理。"
-}
-
-func onOff(b bool) string {
- return map[bool]string{true: "已开启", false: "已关闭"}[b]
-}
-
-func toggleLabel(name string, enabled bool) string {
- if enabled {
- return "关闭" + name
- }
- return "开启" + name
-}
-
-func cleanupModeLabel(mode string) string {
- return "满足任意一条"
-}
-
-func countEnabledCleanupRules(rules []accountCleanupRule) int {
- n := 0
- for _, r := range rules {
- if r.Enabled {
- n++
- }
- }
- return n
-}
diff --git a/internal/service/telegram_cleanup_rules_test.go b/internal/service/telegram_cleanup_rules_test.go
deleted file mode 100644
index 47f5fdf..0000000
--- a/internal/service/telegram_cleanup_rules_test.go
+++ /dev/null
@@ -1,34 +0,0 @@
-package service
-
-import (
- "strings"
- "testing"
-)
-
-func TestParseCleanupRuleCommandWithNamedWatchHours(t *testing.T) {
- rule, err := parseCleanupRuleCommand([]string{"watch_hours", "watch_3_5d_6h", "观看3到5天满6小时", "3", "5", "6"})
- if err != nil {
- t.Fatal(err)
- }
- if rule.Type != "watch_hours" || rule.ID != "watch_3_5d_6h" || rule.Name != "观看3到5天满6小时" {
- t.Fatalf("unexpected rule identity: %+v", rule)
- }
- if !rule.Enabled || rule.WindowDaysMin != 3 || rule.WindowDaysMax != 5 || rule.MinHours != 6 {
- t.Fatalf("unexpected watch-hours rule values: %+v", rule)
- }
-}
-
-func TestFormatCleanupRulesShowsUsefulDetails(t *testing.T) {
- text := formatCleanupRules([]accountCleanupRule{{
- ID: "login_7d",
- Type: "recent_login",
- Name: "七天内登录",
- Enabled: true,
- WindowDaysMax: 7,
- }})
- for _, want := range []string{"保号规则", "login_7d", "七天内登录", "最近登录", "启用"} {
- if !strings.Contains(text, want) {
- t.Fatalf("formatCleanupRules() missing %q in %q", want, text)
- }
- }
-}
diff --git a/internal/service/telegram_command_menus.go b/internal/service/telegram_command_menus.go
deleted file mode 100644
index e7aefbc..0000000
--- a/internal/service/telegram_command_menus.go
+++ /dev/null
@@ -1,158 +0,0 @@
-package service
-
-import (
- "context"
- "strings"
- "time"
-)
-
-func telegramSupportedCommand(cmd string) bool {
- cmd = telegramCommandName(cmd)
- if cmd == "" {
- return false
- }
- _, ok := telegramSupportedCommandSet[cmd]
- return ok
-}
-
-var telegramSupportedCommandSet = map[string]struct{}{
- "/start": {}, "/menu": {}, "/cancel": {}, "/help": {}, "/hideadult": {}, "/hide_adult": {}, "/adult": {},
- "/account": {}, "/me": {}, "/myinfo": {}, "/count": {}, "/signin": {}, "/checkin": {}, "/devices": {}, "/kick": {}, "/setname": {}, "/rename": {}, "/setpass": {}, "/passwd": {}, "/password": {},
- "/redeem": {}, "/redeem_register": {}, "/redeem_renew": {},
- "/register": {}, "/reg": {}, "/signup": {}, "/registration": {}, "/reg_switch": {}, "/openreg": {},
- "/capacity": {}, "/users": {}, "/kk": {}, "/gencode": {}, "/renew_user": {}, "/delete_user": {}, "/unbind": {}, "/unbind_duplicates": {}, "/unbind_inactive": {},
- "/devicepolicy": {}, "/policy": {}, "/antishare": {}, "/cleanup": {}, "/cleanup_mode": {}, "/cleanup_rule": {},
- "/ban": {}, "/unban": {}, "/status": {}, "/search": {}, "/downloads": {}, "/stats": {},
- "/renew": {}, "/ucr": {}, "/uinfo": {}, "/rmemby": {}, "/urm": {}, "/only_rm_emby": {}, "/only_rm_record": {},
- "/userip": {}, "/udeviceid": {}, "/auditip": {}, "/auditdevice": {}, "/auditclient": {},
- "/renewall": {}, "/callall": {}, "/syncunbound": {}, "/syncgroupm": {}, "/kick_not_emby": {}, "/scan_embyname": {},
- "/check_ex": {}, "/deleted": {}, "/low_activity": {}, "/uranks": {}, "/days_ranks": {}, "/week_ranks": {},
- "/embyadmin": {}, "/unbanall": {}, "/banall": {}, "/embylibs_unblockall": {}, "/embylibs_blockall": {},
- "/extraembylibs_unblockall": {}, "/extraembylibs_blockall": {}, "/proadmin": {}, "/revadmin": {},
- "/backup_db": {}, "/restore_from_db": {}, "/prouser": {}, "/revuser": {},
-}
-
-type telegramBotCommand struct {
- Command string `json:"command"`
- Description string `json:"description"`
-}
-
-func telegramBotCommandMenu() []telegramBotCommand {
- return telegramPrivateBotCommandMenu()
-}
-
-func telegramPrivateBotCommandMenu() []telegramBotCommand {
- return []telegramBotCommand{
- {Command: "start", Description: "绑定账号或打开主菜单"},
- {Command: "menu", Description: "打开功能菜单"},
- {Command: "help", Description: "查看命令帮助"},
- {Command: "account", Description: "查看账号状态"},
- {Command: "signin", Description: "签到"},
- {Command: "devices", Description: "查看登录设备"},
- {Command: "kick", Description: "踢下线设备"},
- {Command: "setname", Description: "修改用户名(需当前密码)"},
- {Command: "setpass", Description: "修改密码(需当前密码)"},
- {Command: "hideadult", Description: "隐藏/显示成人媒体库"},
- {Command: "redeem", Description: "兑换注册码或续期码"},
- {Command: "register", Description: "注册新账号"},
- }
-}
-
-func telegramGroupBotCommandMenu() []telegramBotCommand {
- return []telegramBotCommand{
- {Command: "start", Description: "打开群组自助菜单"},
- {Command: "menu", Description: "打开群组自助菜单"},
- {Command: "help", Description: "查看群组可用命令"},
- {Command: "account", Description: "查看账号状态"},
- {Command: "signin", Description: "签到"},
- {Command: "devices", Description: "查看登录设备"},
- {Command: "kick", Description: "踢下线设备"},
- {Command: "hideadult", Description: "隐藏/显示成人媒体库"},
- }
-}
-
-func telegramAdminBotCommandMenu() []telegramBotCommand {
- commands := append([]telegramBotCommand{}, telegramPrivateBotCommandMenu()...)
- commands = append(commands,
- telegramBotCommand{Command: "status", Description: "系统运行状态(管理员)"},
- telegramBotCommand{Command: "search", Description: "搜索媒体库(管理员)"},
- telegramBotCommand{Command: "downloads", Description: "下载列表(管理员)"},
- telegramBotCommand{Command: "stats", Description: "媒体库统计(管理员)"},
- telegramBotCommand{Command: "users", Description: "用户管理(管理员)"},
- telegramBotCommand{Command: "cleanup", Description: "保号清理预览/确认(管理员)"},
- telegramBotCommand{Command: "cleanup_mode", Description: "查看固定保号模式(管理员)"},
- telegramBotCommand{Command: "cleanup_rule", Description: "Mgo保号规则管理(管理员)"},
- )
- commands = append(commands, telegramMgoAdminBotCommandMenu()...)
- return commands
-}
-
-func telegramMgoAdminBotCommandMenu() []telegramBotCommand {
- return []telegramBotCommand{
- // 用户管理：保留 Sakura/Mgo 常用命令名，剔除 /urm、/only_rm_emby 等重复别名。
- {Command: "ucr", Description: "Mgo用户: 创建账号"},
- {Command: "uinfo", Description: "Mgo用户: 查询账号"},
- {Command: "rmemby", Description: "Mgo用户: 删除账号"},
- {Command: "only_rm_record", Description: "Mgo用户: 仅删Bot绑定"},
- {Command: "renewall", Description: "Mgo用户: 批量续期"},
-
- // 审计：按 IP、设备指纹、客户端和 Telegram 绑定信息排查共享。
- {Command: "userip", Description: "Mgo审计: 查询用户IP"},
- {Command: "auditip", Description: "Mgo审计: 按IP审计"},
- {Command: "auditdevice", Description: "Mgo审计: 按设备审计"},
- {Command: "auditclient", Description: "Mgo审计: 按客户端审计"},
- {Command: "udeviceid", Description: "Mgo审计: 按设备ID审计"},
-
- // 清理：/low_activity 是 /deleted 的兼容别名，不显示在命令栏。
- {Command: "syncunbound", Description: "Mgo清理: 未绑定账号"},
- {Command: "syncgroupm", Description: "Mgo清理: 校验群成员"},
- {Command: "check_ex", Description: "Mgo清理: 检查过期账号"},
- {Command: "deleted", Description: "Mgo清理: 保号清理预览"},
-
- // 权限：批量禁用、保护用户、媒体库播放权限。
- {Command: "embyadmin", Description: "Mgo权限: 设置管理员"},
- {Command: "banall", Description: "Mgo权限: 批量禁用用户"},
- {Command: "unbanall", Description: "Mgo权限: 批量解禁用户"},
- {Command: "prouser", Description: "Mgo权限: 加入保护名单"},
- {Command: "revuser", Description: "Mgo权限: 移出保护名单"},
- {Command: "embylibs_blockall", Description: "Mgo权限: 批量禁用媒体库"},
- {Command: "embylibs_unblockall", Description: "Mgo权限: 批量开放媒体库"},
-
- // 运维：Bot 管理员与数据库备份恢复。
- {Command: "proadmin", Description: "Mgo运维: 添加Bot管理员"},
- {Command: "revadmin", Description: "Mgo运维: 移除Bot管理员"},
- {Command: "backup_db", Description: "Mgo运维: 备份数据库"},
- {Command: "restore_from_db", Description: "Mgo运维: 恢复数据库"},
- }
-}
-
-func registerTelegramBotCommands(ctx context.Context, cfg map[string]string) error {
- if strings.TrimSpace(cfg["bot_token"]) == "" {
- return nil
- }
- normalizeTelegramConfig(cfg)
- if err := telegramSetBotCommands(ctx, cfg, telegramPrivateBotCommandMenu(), nil); err != nil {
- return err
- }
- if err := telegramSetBotCommands(ctx, cfg, telegramPrivateBotCommandMenu(), map[string]interface{}{"type": "all_private_chats"}); err != nil {
- return err
- }
- if err := telegramSetBotCommands(ctx, cfg, telegramGroupBotCommandMenu(), map[string]interface{}{"type": "all_group_chats"}); err != nil {
- return err
- }
- _ = telegramSetBotCommands(ctx, cfg, telegramAdminBotCommandMenu(), map[string]interface{}{"type": "all_chat_administrators"})
-
- adminCommands := telegramAdminBotCommandMenu()
- for _, adminID := range telegramConfiguredUserIDs(cfg["admin_user_ids"]) {
- _ = telegramSetBotCommands(ctx, cfg, adminCommands, map[string]interface{}{"type": "chat", "chat_id": adminID})
- }
- return nil
-}
-
-func telegramSetBotCommands(ctx context.Context, cfg map[string]string, commands []telegramBotCommand, scope map[string]interface{}) error {
- payload := map[string]interface{}{"commands": commands}
- if scope != nil {
- payload["scope"] = scope
- }
- return telegramPostJSON(ctx, cfg, "setMyCommands", payload, 15*time.Second)
-}
diff --git a/internal/service/telegram_commands.go b/internal/service/telegram_commands.go
deleted file mode 100644
index 6bdb682..0000000
--- a/internal/service/telegram_commands.go
+++ /dev/null
@@ -1,224 +0,0 @@
-// Package service — Telegram command registry and dispatch.
-package service
-
-import (
- "context"
- "fmt"
- "strings"
- "time"
-
- "github.com/ShukeBta/MediaStationGo/internal/model"
-)
-
-type telegramCommandHandler func(args []string) (telegramCommandReply, error)
-
-type telegramCommandDefinition struct {
- Aliases []string
- AdminOnly bool
- AdminOnlyText string
- GroupAllowed bool
- Handle telegramCommandHandler
-}
-
-func (s *TelegramBotService) telegramCommandDefinitions(ctx context.Context, channel *model.NotifyChannel, msg *TelegramMessage) []telegramCommandDefinition {
- adminOnly := "此命令仅管理员可用。"
- defs := s.telegramCoreCommandDefinitions(ctx, channel, msg)
- defs = append(defs, s.telegramSelfServiceCommandDefinitions(ctx, channel, msg)...)
- defs = append(defs, s.telegramAdminCoreCommandDefinitions(ctx, msg, adminOnly)...)
- defs = append(defs, s.telegramMgoUserCommandDefinitions(ctx, adminOnly)...)
- defs = append(defs, s.telegramMgoAuditCommandDefinitions(ctx, adminOnly)...)
- defs = append(defs, s.telegramMgoMaintenanceCommandDefinitions(ctx, channel, adminOnly)...)
- defs = append(defs, s.telegramMgoPolicyCommandDefinitions(ctx, channel, adminOnly)...)
- return defs
-}
-
-func (s *TelegramBotService) telegramCoreCommandDefinitions(ctx context.Context, channel *model.NotifyChannel, msg *TelegramMessage) []telegramCommandDefinition {
- return []telegramCommandDefinition{
- {Aliases: []string{"/start"}, GroupAllowed: true, Handle: func(args []string) (telegramCommandReply, error) {
- if len(args) == 0 {
- return s.mainMenu(ctx, channel, msg), nil
- }
- return s.cmdStart(ctx, msg, args), nil
- }},
- {Aliases: []string{"/menu"}, GroupAllowed: true, Handle: func(args []string) (telegramCommandReply, error) {
- return s.mainMenu(ctx, channel, msg), nil
- }},
- {Aliases: []string{"/cancel"}, GroupAllowed: true, Handle: func(args []string) (telegramCommandReply, error) {
- s.takePending(int64(msg.From.ID))
- return telegramCommandReply{Text: "已取消当前操作。"}, nil
- }},
- {Aliases: []string{"/help"}, GroupAllowed: true, Handle: func(args []string) (telegramCommandReply, error) {
- return telegramCommandReply{Text: s.cmdHelp(ctx, msg)}, nil
- }},
- }
-}
-
-func (s *TelegramBotService) telegramSelfServiceCommandDefinitions(ctx context.Context, channel *model.NotifyChannel, msg *TelegramMessage) []telegramCommandDefinition {
- return []telegramCommandDefinition{
- {Aliases: []string{"/hideadult", "/hide_adult", "/adult"}, GroupAllowed: true, Handle: func(args []string) (telegramCommandReply, error) { return s.cmdHideAdult(ctx, msg, args), nil }},
- {Aliases: []string{"/account", "/me", "/myinfo"}, GroupAllowed: true, Handle: func(args []string) (telegramCommandReply, error) { return s.replyAccount(ctx, msg), nil }},
- {Aliases: []string{"/count"}, GroupAllowed: true, Handle: func(args []string) (telegramCommandReply, error) { return s.cmdStats(ctx) }},
- {Aliases: []string{"/signin", "/checkin"}, GroupAllowed: true, Handle: func(args []string) (telegramCommandReply, error) { return s.replySignIn(ctx, msg), nil }},
- {Aliases: []string{"/devices"}, GroupAllowed: true, Handle: func(args []string) (telegramCommandReply, error) { return s.replyDevices(ctx, msg), nil }},
- {Aliases: []string{"/kick"}, GroupAllowed: true, Handle: func(args []string) (telegramCommandReply, error) { return s.cmdKick(ctx, msg, args), nil }},
- {Aliases: []string{"/setname", "/rename"}, Handle: func(args []string) (telegramCommandReply, error) { return s.cmdSetName(ctx, msg, args), nil }},
- {Aliases: []string{"/setpass", "/passwd", "/password"}, Handle: func(args []string) (telegramCommandReply, error) { return s.cmdSetPass(ctx, msg, args), nil }},
- {Aliases: []string{"/redeem"}, Handle: func(args []string) (telegramCommandReply, error) { return s.cmdRedeem(ctx, channel, msg, args), nil }},
- {Aliases: []string{"/redeem_register"}, Handle: func(args []string) (telegramCommandReply, error) {
- return s.cmdRedeemRegister(ctx, channel, msg, args), nil
- }},
- {Aliases: []string{"/redeem_renew"}, Handle: func(args []string) (telegramCommandReply, error) { return s.cmdRedeemRenew(ctx, msg, args), nil }},
- {Aliases: []string{"/register", "/reg", "/signup"}, Handle: func(args []string) (telegramCommandReply, error) { return s.cmdRegister(ctx, channel, msg, args), nil }},
- }
-}
-
-func (s *TelegramBotService) telegramAdminCoreCommandDefinitions(ctx context.Context, msg *TelegramMessage, adminOnly string) []telegramCommandDefinition {
- return []telegramCommandDefinition{
- {Aliases: []string{"/registration", "/reg_switch", "/openreg"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) { return s.cmdRegistrationToggle(ctx, args), nil }},
- {Aliases: []string{"/capacity"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) { return s.replyCapacity(ctx), nil }},
- {Aliases: []string{"/users", "/kk"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) { return s.replyUserList(ctx), nil }},
- {Aliases: []string{"/gencode"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) { return s.cmdGenCode(ctx, msg, args), nil }},
- {Aliases: []string{"/renew_user"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) { return s.cmdUserRenew(ctx, args), nil }},
- {Aliases: []string{"/delete_user"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) { return s.cmdUserDelete(ctx, args), nil }},
- {Aliases: []string{"/unbind"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) { return s.cmdUnbind(ctx, args), nil }},
- {Aliases: []string{"/unbind_duplicates"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) { return s.cmdUnbindDuplicates(ctx), nil }},
- {Aliases: []string{"/unbind_inactive"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) { return s.cmdUnbindInactive(ctx, args), nil }},
- {Aliases: []string{"/devicepolicy", "/policy"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) { return s.cmdDevicePolicy(ctx, args), nil }},
- {Aliases: []string{"/antishare"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) { return s.cmdAntiShare(ctx, args), nil }},
- {Aliases: []string{"/cleanup"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) { return s.cmdCleanup(ctx, args), nil }},
- {Aliases: []string{"/cleanup_mode"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) { return s.cmdCleanupMode(ctx, args), nil }},
- {Aliases: []string{"/cleanup_rule"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) { return s.cmdCleanupRule(ctx, args), nil }},
- {Aliases: []string{"/ban"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) { return s.cmdUserBan(ctx, args, false), nil }},
- {Aliases: []string{"/unban"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) { return s.cmdUserBan(ctx, args, true), nil }},
- {Aliases: []string{"/status"}, AdminOnly: true, AdminOnlyText: "此命令仅管理员可用。普通用户只能使用 /start 绑定账号，并通过按钮隐藏成人目录。", Handle: func(args []string) (telegramCommandReply, error) { return s.cmdStatus(ctx) }},
- {Aliases: []string{"/search"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) { return s.cmdSearch(ctx, args) }},
- {Aliases: []string{"/downloads"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) { return s.cmdDownloads(ctx) }},
- {Aliases: []string{"/stats"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) { return s.cmdStats(ctx) }},
- {Aliases: []string{"/renew"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) { return s.cmdUserRenew(ctx, args), nil }},
- }
-}
-
-func (s *TelegramBotService) telegramMgoUserCommandDefinitions(ctx context.Context, adminOnly string) []telegramCommandDefinition {
- return []telegramCommandDefinition{
- {Aliases: []string{"/ucr"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) { return s.cmdMgoCreateUser(ctx, args), nil }},
- {Aliases: []string{"/uinfo"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) { return s.cmdMgoUserInfo(ctx, args), nil }},
- {Aliases: []string{"/rmemby", "/urm", "/only_rm_emby"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) { return s.cmdMgoDeleteUser(ctx, args), nil }},
- {Aliases: []string{"/only_rm_record"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) { return s.cmdMgoOnlyRemoveRecord(ctx, args), nil }},
- {Aliases: []string{"/userip"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) { return s.cmdMgoUserIP(ctx, args), nil }},
- }
-}
-
-func (s *TelegramBotService) telegramMgoAuditCommandDefinitions(ctx context.Context, adminOnly string) []telegramCommandDefinition {
- return []telegramCommandDefinition{
- {Aliases: []string{"/udeviceid"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) {
- return s.cmdMgoAuditDevices(ctx, "udeviceid", args), nil
- }},
- {Aliases: []string{"/auditip"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) {
- return s.cmdMgoAuditDevices(ctx, "auditip", args), nil
- }},
- {Aliases: []string{"/auditdevice"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) {
- return s.cmdMgoAuditDevices(ctx, "auditdevice", args), nil
- }},
- {Aliases: []string{"/auditclient"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) {
- return s.cmdMgoAuditDevices(ctx, "auditclient", args), nil
- }},
- }
-}
-
-func (s *TelegramBotService) telegramMgoMaintenanceCommandDefinitions(ctx context.Context, channel *model.NotifyChannel, adminOnly string) []telegramCommandDefinition {
- return []telegramCommandDefinition{
- {Aliases: []string{"/renewall"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) { return s.cmdMgoRenewAll(ctx, args), nil }},
- {Aliases: []string{"/callall"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) { return s.cmdMgoCallAll(ctx, channel, args), nil }},
- {Aliases: []string{"/syncunbound"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) { return s.cmdMgoSyncUnbound(ctx, args), nil }},
- {Aliases: []string{"/syncgroupm"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) {
- return s.cmdMgoSyncGroup(ctx, channel, args), nil
- }},
- {Aliases: []string{"/kick_not_emby"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) {
- return s.cmdMgoUnsupported("群内无号用户清理", "/syncgroupm 可检查已绑定账号是否仍在群内；Telegram Bot API 无法枚举全部群成员，因此不能可靠找出“在群但无号”的用户。"), nil
- }},
- {Aliases: []string{"/scan_embyname"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) { return s.cmdMgoScanNames(ctx), nil }},
- {Aliases: []string{"/check_ex"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) { return s.cmdMgoCheckExpired(ctx, args), nil }},
- {Aliases: []string{"/deleted", "/low_activity"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) { return s.cmdCleanup(ctx, []string{"run"}), nil }},
- {Aliases: []string{"/uranks"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) { return s.cmdMgoRanks(ctx, 0, true), nil }},
- {Aliases: []string{"/days_ranks"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) {
- return s.cmdMgoRanks(ctx, 24*time.Hour, false), nil
- }},
- {Aliases: []string{"/week_ranks"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) {
- return s.cmdMgoRanks(ctx, 7*24*time.Hour, false), nil
- }},
- }
-}
-
-func (s *TelegramBotService) telegramMgoPolicyCommandDefinitions(ctx context.Context, channel *model.NotifyChannel, adminOnly string) []telegramCommandDefinition {
- return []telegramCommandDefinition{
- {Aliases: []string{"/embyadmin"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) { return s.cmdMgoAdminRole(ctx, args), nil }},
- {Aliases: []string{"/unbanall"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) { return s.cmdMgoBanAll(ctx, true, args), nil }},
- {Aliases: []string{"/banall"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) { return s.cmdMgoBanAll(ctx, false, args), nil }},
- {Aliases: []string{"/embylibs_unblockall", "/extraembylibs_unblockall"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) {
- return s.cmdMgoMediaAccessAll(ctx, true), nil
- }},
- {Aliases: []string{"/embylibs_blockall", "/extraembylibs_blockall"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) {
- return s.cmdMgoMediaAccessAll(ctx, false), nil
- }},
- {Aliases: []string{"/proadmin"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) {
- return s.cmdMgoBotAdmin(ctx, channel, args, true), nil
- }},
- {Aliases: []string{"/revadmin"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) {
- return s.cmdMgoBotAdmin(ctx, channel, args, false), nil
- }},
- {Aliases: []string{"/backup_db"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) { return s.cmdMgoBackupDB(ctx), nil }},
- {Aliases: []string{"/restore_from_db"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) { return s.cmdMgoRestoreDB(ctx, args), nil }},
- {Aliases: []string{"/prouser"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) {
- return s.cmdMgoProtectedUser(ctx, args, true), nil
- }},
- {Aliases: []string{"/revuser"}, AdminOnly: true, AdminOnlyText: adminOnly, Handle: func(args []string) (telegramCommandReply, error) {
- return s.cmdMgoProtectedUser(ctx, args, false), nil
- }},
- }
-}
-
-func (s *TelegramBotService) telegramCommandRegistry(ctx context.Context, channel *model.NotifyChannel, msg *TelegramMessage) map[string]telegramCommandDefinition {
- defs := s.telegramCommandDefinitions(ctx, channel, msg)
- registry := make(map[string]telegramCommandDefinition, len(defs)*2)
- for _, def := range defs {
- for _, alias := range def.Aliases {
- registry[alias] = def
- }
- }
- return registry
-}
-
-// executeCommand parses and dispatches Telegram commands through a registry so
-// adding a command does not grow a monolithic switch.
-func (s *TelegramBotService) executeCommand(ctx context.Context, channel *model.NotifyChannel, msg *TelegramMessage, text string) (telegramCommandReply, error) {
- parts := strings.Fields(text)
- if len(parts) == 0 {
- return telegramCommandReply{}, nil
- }
-
- cmd := telegramCommandName(parts[0])
- args := parts[1:]
- if msg.Chat.Type != "" && msg.Chat.Type != "private" && !s.telegramChatAllowed(channel, msg.Chat.ID) {
- return telegramCommandReply{Text: "此群组/频道未绑定到 Bot 管理入口，请在通知渠道里填写「绑定群组 ID」或「绑定频道 ID」。"}, nil
- }
-
- def, ok := s.telegramCommandRegistry(ctx, channel, msg)[cmd]
- if !ok {
- return telegramCommandReply{Text: fmt.Sprintf("未知命令: %s\n\n输入 /help 查看可用命令列表。", cmd)}, nil
- }
- if telegramIsGroupChat(msg.Chat.Type) && !def.GroupAllowed {
- if !def.AdminOnly || !s.telegramUserIsAdmin(ctx, channel, msg.From.ID) {
- return telegramCommandReply{}, nil
- }
- }
- if def.AdminOnly && !s.telegramUserIsAdmin(ctx, channel, msg.From.ID) {
- return telegramCommandReply{Text: def.AdminOnlyText}, nil
- }
- reply, err := def.Handle(args)
- if telegramIsGroupChat(msg.Chat.Type) && def.AdminOnly && !def.GroupAllowed {
- if !s.telegramUserIsAdmin(ctx, channel, msg.From.ID) {
- reply.Buttons = nil
- }
- }
- return reply, err
-}
diff --git a/internal/service/telegram_device_policy.go b/internal/service/telegram_device_policy.go
deleted file mode 100644
index 79eeb57..0000000
--- a/internal/service/telegram_device_policy.go
+++ /dev/null
@@ -1,252 +0,0 @@
-package service
-
-import (
- "context"
- "fmt"
- "strconv"
- "strings"
-)
-
-func (s *TelegramBotService) replyDevicePolicy(ctx context.Context) telegramCommandReply {
- cfg := loadBotConfig(ctx, s.repo)
- text := fmt.Sprintf(
- "设备策略\n\n① 防共享：%s\n 并发播放终端上限 %d / 登录终端上限 %d；同一终端多个 App 只算 1 台，App 作为登录渠道记录。\n 设备指纹异常警告 %d 次后禁用账号。\n\n② Mgo 保号规则：%s\n 保号模式：%s；启用规则 %d 条。\n\n命令：\n/antishare on play=3 login=3 warn=2\n/cleanup run 预览候选\n/cleanup run confirm 确认清理\n/cleanup on|off\n/cleanup_rule list|add|edit|修改|del|enable|disable\n\n策略默认关闭；清理前会先预览候选；满足任意一条保号规则即保留；管理员/受保护账号永不自动处理。",
- onOff(cfg.AntiShareEnabled), cfg.MaxConcurrentPlay, cfg.MaxLoggedClients, cfg.WarnThreshold,
- onOff(cfg.AccountCleanupEnabled), cleanupModeLabel(cfg.AccountCleanupKeepMode), countEnabledCleanupRules(cfg.AccountCleanupRules))
- return telegramCommandReply{
- Text: text,
- Buttons: [][]telegramInlineButton{
- {{Text: toggleLabel("防共享", cfg.AntiShareEnabled), Data: "dp_toggle:antishare"}},
- {{Text: toggleLabel("保号规则", cfg.AccountCleanupEnabled), Data: "dp_toggle:cleanup"}},
- {{Text: "⬅️ 返回菜单", Data: "menu_main"}},
- },
- }
-}
-
-func (s *TelegramBotService) cmdDevicePolicy(ctx context.Context, args []string) telegramCommandReply {
- if len(args) == 0 || strings.EqualFold(args[0], "status") {
- return s.replyDevicePolicy(ctx)
- }
- switch strings.ToLower(strings.TrimSpace(args[0])) {
- case "run", "sweep":
- return s.cmdCleanup(ctx, []string{"run"})
- default:
- return telegramCommandReply{Text: "用法：/devicepolicy 查看策略，或使用 /antishare、/cleanup、/cleanup_rule 管理。"}
- }
-}
-
-func (s *TelegramBotService) cmdAntiShare(ctx context.Context, args []string) telegramCommandReply {
- if len(args) == 0 || strings.EqualFold(args[0], "status") {
- return s.replyDevicePolicy(ctx)
- }
- enabled, ok := parseCommandBool(args[0])
- if !ok {
- return telegramCommandReply{Text: "用法：/antishare on|off [play=3] [login=3] [warn=2]，login 表示登录终端设备上限，同一终端多个 App 不重复计数。"}
- }
- if err := s.repo.Setting.Set(ctx, SettingAntiShareEnabled, strconv.FormatBool(enabled)); err != nil {
- return telegramCommandReply{Text: "更新失败：" + err.Error()}
- }
- for _, arg := range args[1:] {
- key, value, ok := strings.Cut(arg, "=")
- if !ok {
- continue
- }
- n, err := strconv.Atoi(strings.TrimSpace(value))
- if err != nil || n < 1 {
- continue
- }
- switch strings.ToLower(strings.TrimSpace(key)) {
- case "play", "maxplay", "播放":
- _ = s.repo.Setting.Set(ctx, SettingMaxConcurrentPlay, strconv.Itoa(n))
- case "login", "client", "clients", "登录":
- _ = s.repo.Setting.Set(ctx, SettingMaxLoggedClients, strconv.Itoa(n))
- case "warn", "warnings", "警告":
- _ = s.repo.Setting.Set(ctx, SettingWarnThreshold, strconv.Itoa(n))
- }
- }
- return s.replyDevicePolicy(ctx)
-}
-
-func (s *TelegramBotService) cmdCleanup(ctx context.Context, args []string) telegramCommandReply {
- if len(args) == 0 || strings.EqualFold(args[0], "status") {
- return s.replyDevicePolicy(ctx)
- }
- switch strings.ToLower(strings.TrimSpace(args[0])) {
- case "on", "true", "1", "开启", "enable":
- if err := s.repo.Setting.Set(ctx, SettingAccountCleanupEnabled, "true"); err != nil {
- return telegramCommandReply{Text: "开启失败：" + err.Error()}
- }
- return s.replyDevicePolicy(ctx)
- case "off", "false", "0", "关闭", "disable":
- if err := s.repo.Setting.Set(ctx, SettingAccountCleanupEnabled, "false"); err != nil {
- return telegramCommandReply{Text: "关闭失败：" + err.Error()}
- }
- return s.replyDevicePolicy(ctx)
- case "run", "sweep", "巡检", "preview", "预览":
- device := s.device
- if device == nil {
- device = NewDeviceService(s.log, s.repo)
- }
- if len(args) > 1 && isCleanupConfirmArg(args[1]) {
- cfg := loadBotConfig(ctx, s.repo)
- if !cfg.AccountCleanupEnabled {
- return telegramCommandReply{Text: "保号规则未开启，不会清理账号。"}
- }
- if countEnabledCleanupRules(cfg.AccountCleanupRules) == 0 {
- return telegramCommandReply{Text: "没有启用的保号规则，不会清理账号。"}
- }
- removed, err := device.SweepAccountCleanup(ctx)
- if err != nil {
- return telegramCommandReply{Text: "确认清理失败：" + err.Error()}
- }
- return telegramCommandReply{Text: fmt.Sprintf("保号规则确认清理完成，已清理 %d 个账号。", removed)}
- }
- candidates, err := device.PreviewAccountCleanup(ctx)
- if err != nil {
- return telegramCommandReply{Text: "巡检预览失败：" + err.Error()}
- }
- return telegramCommandReply{Text: s.formatCleanupPreview(ctx, candidates)}
- default:
- return telegramCommandReply{Text: "用法：/cleanup on|off、/cleanup run 预览、/cleanup run confirm 确认清理"}
- }
-}
-
-func isCleanupConfirmArg(arg string) bool {
- switch strings.ToLower(strings.TrimSpace(arg)) {
- case "confirm", "yes", "delete", "确认", "清理", "删除":
- return true
- default:
- return false
- }
-}
-
-func (s *TelegramBotService) formatCleanupPreview(ctx context.Context, candidates []accountCleanupCandidate) string {
- cfg := loadBotConfig(ctx, s.repo)
- if !cfg.AccountCleanupEnabled {
- return "保号规则未开启，不会清理账号。"
- }
- if countEnabledCleanupRules(cfg.AccountCleanupRules) == 0 {
- return "没有启用的保号规则，不会清理账号。"
- }
- if len(candidates) == 0 {
- return "保号规则预览完成：没有需要清理的账号。"
- }
- var sb strings.Builder
- sb.WriteString(fmt.Sprintf("保号规则预览\n\n将清理候选：%d 个账号。\n当前只是预览，未删除任何账号。\n\n", len(candidates)))
- limit := len(candidates)
- if limit > 10 {
- limit = 10
- }
- for i := 0; i < limit; i++ {
- candidate := candidates[i]
- sb.WriteString(fmt.Sprintf("%d. %s\n%s\n", i+1, escapeHTML(candidate.Username), escapeHTML(candidate.Details)))
- }
- if len(candidates) > limit {
- sb.WriteString(fmt.Sprintf("……另有 %d 个候选未展示。\n", len(candidates)-limit))
- }
- sb.WriteString("\n确认无误后再执行：/cleanup run confirm")
- return sb.String()
-}
-
-func (s *TelegramBotService) cmdCleanupMode(ctx context.Context, args []string) telegramCommandReply {
- if err := s.repo.Setting.Set(ctx, SettingAccountCleanupKeepMode, "any"); err != nil {
- return telegramCommandReply{Text: "更新失败：" + err.Error()}
- }
- if err := s.repo.Setting.Set(ctx, SettingAccountCleanupRequiredCount, "1"); err != nil {
- return telegramCommandReply{Text: "更新失败：" + err.Error()}
- }
- reply := s.replyDevicePolicy(ctx)
- reply.Text = "Mgo 保号模式固定为：满足任意一条启用规则即保留；只有全部规则都不满足才进入清理候选。\n\n" + reply.Text
- return reply
-}
-
-func (s *TelegramBotService) cmdCleanupRule(ctx context.Context, args []string) telegramCommandReply {
- rules := s.currentCleanupRules(ctx)
- if len(args) == 0 {
- return telegramCommandReply{Text: formatCleanupRules(rules)}
- }
- action := strings.ToLower(strings.TrimSpace(args[0]))
- switch action {
- case "list", "ls", "status":
- return telegramCommandReply{Text: formatCleanupRules(rules)}
- case "help", "?", "帮助":
- return telegramCommandReply{Text: cleanupRuleHelp()}
- case "del", "delete", "rm":
- if len(args) < 2 {
- return telegramCommandReply{Text: "用法：/cleanup_rule del 规则ID"}
- }
- next := make([]accountCleanupRule, 0, len(rules))
- removed := false
- for _, r := range rules {
- if r.ID == args[1] {
- removed = true
- continue
- }
- next = append(next, r)
- }
- if !removed {
- return telegramCommandReply{Text: "未找到该规则。"}
- }
- if err := s.saveCleanupRules(ctx, next); err != nil {
- return telegramCommandReply{Text: "保存失败：" + err.Error()}
- }
- return telegramCommandReply{Text: "已删除规则。\n\n" + formatCleanupRules(next)}
- case "enable", "on", "disable", "off":
- if len(args) < 2 {
- return telegramCommandReply{Text: "用法：/cleanup_rule enable|disable 规则ID"}
- }
- enable := action == "enable" || action == "on"
- changed := false
- for i := range rules {
- if rules[i].ID == args[1] {
- rules[i].Enabled = enable
- changed = true
- }
- }
- if !changed {
- return telegramCommandReply{Text: "未找到该规则。"}
- }
- if err := s.saveCleanupRules(ctx, rules); err != nil {
- return telegramCommandReply{Text: "保存失败：" + err.Error()}
- }
- return telegramCommandReply{Text: "已更新规则状态。\n\n" + formatCleanupRules(rules)}
- case "add", "set", "edit", "update", "修改", "更新", "改":
- rule, err := parseCleanupRuleCommand(args[1:])
- if err != nil {
- return telegramCommandReply{Text: err.Error() + "\n\n" + cleanupRuleHelp()}
- }
- updated := false
- for i := range rules {
- if rules[i].ID == rule.ID {
- rules[i] = rule
- updated = true
- break
- }
- }
- if !updated {
- rules = append(rules, rule)
- }
- rules = normalizeCleanupRules(rules)
- if err := s.saveCleanupRules(ctx, rules); err != nil {
- return telegramCommandReply{Text: "保存失败：" + err.Error()}
- }
- actionText := "已新增规则。"
- if updated {
- actionText = "已更新规则。"
- }
- return telegramCommandReply{Text: actionText + "\n\n" + formatCleanupRules(rules)}
- default:
- return telegramCommandReply{Text: cleanupRuleHelp()}
- }
-}
-
-func (s *TelegramBotService) replyDevicePolicyToggle(ctx context.Context, which string) telegramCommandReply {
- cfg := loadBotConfig(ctx, s.repo)
- switch which {
- case "antishare":
- _ = s.repo.Setting.Set(ctx, SettingAntiShareEnabled, strconv.FormatBool(!cfg.AntiShareEnabled))
- case "cleanup":
- _ = s.repo.Setting.Set(ctx, SettingAccountCleanupEnabled, strconv.FormatBool(!cfg.AccountCleanupEnabled))
- }
- return s.replyDevicePolicy(ctx)
-}
diff --git a/internal/service/telegram_membership.go b/internal/service/telegram_membership.go
deleted file mode 100644
index 37f3c30..0000000
--- a/internal/service/telegram_membership.go
+++ /dev/null
@@ -1,122 +0,0 @@
-package service
-
-import (
- "context"
- "fmt"
- "strings"
- "time"
-
- "go.uber.org/zap"
-
- "github.com/ShukeBta/MediaStationGo/internal/model"
-)
-
-func (s *TelegramBotService) telegramUserIsAdmin(ctx context.Context, channel *model.NotifyChannel, telegramUserID int) bool {
- if s.telegramUserIDConfigured(channel, telegramUserID) {
- return true
- }
- binding := s.telegramBinding(ctx, telegramUserID)
- if binding == nil {
- return false
- }
- user, err := s.repo.User.FindByID(ctx, binding.UserID)
- return err == nil && user != nil && user.Role == "admin" && user.IsActive
-}
-
-// telegramBindDecision 表示成员资格校验的三态结果：通过 / 明确不通过 /
-// 无法验证（getChatMember 出错，如 Bot 不在群、群 ID 失效、网络或代理不可达）。
-// 区分「明确不是成员」和「查不了」，是为了避免把验证失败误报成「你不在群」。
-type telegramBindDecision int
-
-const (
- bindDenied telegramBindDecision = iota // 已查实：不在任何绑定群组/频道
- bindAllowed // 管理员，或查实是某绑定群组/频道成员
- bindUnverifiable // 配了群组/频道但 getChatMember 全部失败
-)
-
-// telegramMembership 表示单个 chat 的成员资格三态。
-type telegramMembership int
-
-const (
- membershipNo telegramMembership = iota // 查实不是成员（left/kicked 等）
- membershipYes // 查实是成员
- membershipUnknown // getChatMember 出错，无法判定
-)
-
-func (s *TelegramBotService) telegramUserBindDecision(ctx context.Context, channel *model.NotifyChannel, telegramUserID int) telegramBindDecision {
- if telegramUserID == 0 || channel == nil {
- return bindDenied
- }
- if s.telegramUserIDConfigured(channel, telegramUserID) {
- return bindAllowed
- }
- chatIDs := s.telegramMembershipChatIDs(channel)
- if len(chatIDs) == 0 {
- return bindDenied
- }
- sawUnknown := false
- for _, chatID := range chatIDs {
- switch s.telegramChatMembership(ctx, channel, chatID, telegramUserID) {
- case membershipYes:
- return bindAllowed
- case membershipUnknown:
- sawUnknown = true
- }
- }
- if sawUnknown {
- return bindUnverifiable
- }
- return bindDenied
-}
-
-// telegramUserCanBind 是 telegramUserBindDecision 的布尔包装，供尽力而为的场景
-// 使用（如私聊时挑选可用渠道）：只有查实通过才返回 true。
-func (s *TelegramBotService) telegramUserCanBind(ctx context.Context, channel *model.NotifyChannel, telegramUserID int) bool {
- return s.telegramUserBindDecision(ctx, channel, telegramUserID) == bindAllowed
-}
-
-// telegramBindRejectText 根据三态结果生成面向用户的提示。action 形如「兑换注册账号」
-// 「绑定媒体中心账号」。bindUnverifiable 时不再误导用户「你不在群」，而是提示
-// 管理员检查 Bot 权限与群组 ID。
-func telegramBindRejectText(decision telegramBindDecision, action string) string {
- if decision == bindUnverifiable {
- return fmt.Sprintf("暂时无法验证你的群组/频道成员身份，%s未成功。这通常是因为 Bot 未加入绑定群组、在频道中不是管理员，或群组 ID 配置有误（如超级群需带 -100 前缀）。请联系管理员检查 Bot 权限与「绑定群组/频道 ID」。", action)
- }
- return fmt.Sprintf("当前 Telegram 账号不在管理员配置的绑定群组/频道中，无法%s。请先加入管理员配置的群组或频道；如果尚未配置，请联系管理员。", action)
-}
-
-func (s *TelegramBotService) telegramChatMembership(ctx context.Context, channel *model.NotifyChannel, chatID string, telegramUserID int) telegramMembership {
- cfg := s.telegramChannelConfig(channel)
- if strings.TrimSpace(cfg["bot_token"]) == "" || chatID == "" || telegramUserID == 0 {
- return membershipUnknown
- }
- payload := map[string]interface{}{
- "chat_id": chatID,
- "user_id": telegramUserID,
- }
- var result struct {
- OK bool `json:"ok"`
- Result struct {
- Status string `json:"status"`
- } `json:"result"`
- }
- if err := telegramPostJSONDecode(ctx, cfg, "getChatMember", payload, 15*time.Second, &result); err != nil {
- s.log.Warn("telegram getChatMember failed", zap.String("chat_id", chatID), zap.Int("telegram_user_id", telegramUserID), zap.Error(sanitizeTelegramError(err)))
- return membershipUnknown
- }
- if !result.OK {
- return membershipUnknown
- }
- switch strings.ToLower(result.Result.Status) {
- case "creator", "administrator", "member", "restricted":
- return membershipYes
- default:
- return membershipNo
- }
-}
-
-// telegramUserIsChatMember 是 telegramChatMembership 的布尔包装，仅在查实是成员时
-// 返回 true（查不了也视为非成员，供尽力而为的场景使用）。
-func (s *TelegramBotService) telegramUserIsChatMember(ctx context.Context, channel *model.NotifyChannel, chatID string, telegramUserID int) bool {
- return s.telegramChatMembership(ctx, channel, chatID, telegramUserID) == membershipYes
-}
diff --git a/internal/service/telegram_menu.go b/internal/service/telegram_menu.go
deleted file mode 100644
index 064d543..0000000
--- a/internal/service/telegram_menu.go
+++ /dev/null
@@ -1,219 +0,0 @@
-package service
-
-import (
- "context"
- "fmt"
- "strconv"
- "strings"
- "time"
-
- "github.com/ShukeBta/MediaStationGo/internal/model"
-)
-
-// pendingTTL bounds how long a button-initiated text prompt stays valid.
-const pendingTTL = 5 * time.Minute
-
-func (s *TelegramBotService) setPending(userID int64, kind string) {
- s.pendingMu.Lock()
- s.pending[userID] = pendingInput{Kind: kind, CreatedAt: time.Now()}
- s.pendingMu.Unlock()
-}
-
-func (s *TelegramBotService) takePending(userID int64) (pendingInput, bool) {
- s.pendingMu.Lock()
- defer s.pendingMu.Unlock()
- p, ok := s.pending[userID]
- if ok {
- delete(s.pending, userID)
- }
- if ok && time.Since(p.CreatedAt) > pendingTTL {
- return pendingInput{}, false
- }
- return p, ok
-}
-
-// boundUser resolves the local user bound to a Telegram account, or nil.
-func (s *TelegramBotService) boundUser(ctx context.Context, telegramUserID int) *model.User {
- binding := s.telegramBinding(ctx, telegramUserID)
- if binding == nil {
- return nil
- }
- u, _ := s.repo.User.FindByID(ctx, binding.UserID)
- return u
-}
-
-// handleMenuCallback routes inline-button taps. Returns (reply, handled).
-func (s *TelegramBotService) handleMenuCallback(ctx context.Context, channel *model.NotifyChannel, msg *TelegramMessage, data string) (telegramCommandReply, bool) {
- isAdmin := s.telegramUserIsAdmin(ctx, channel, msg.From.ID)
- isGroup := telegramIsGroupChat(msg.Chat.Type)
- if reply, handled := s.handleUserMenuCallback(ctx, channel, msg, data, isGroup); handled {
- return reply, true
- }
- if !isAdmin {
- if isGroup {
- return telegramCommandReply{}, true
- }
- return telegramCommandReply{Text: "此功能仅管理员可用。"}, true
- }
- return s.handleAdminMenuCallback(ctx, msg, data)
-}
-
-func (s *TelegramBotService) handleUserMenuCallback(ctx context.Context, channel *model.NotifyChannel, msg *TelegramMessage, data string, isGroup bool) (telegramCommandReply, bool) {
- switch {
- case data == "noop":
- return telegramCommandReply{}, true
- case data == "menu_main":
- return s.mainMenu(ctx, channel, msg), true
- case data == "act_account":
- return s.replyAccount(ctx, msg), true
- case data == "act_signin":
- return s.replySignIn(ctx, msg), true
- case data == "act_devices":
- return s.replyDevices(ctx, msg), true
- case strings.HasPrefix(data, "kick:"):
- return s.replyKick(ctx, msg, strings.TrimPrefix(data, "kick:")), true
- }
- return s.handlePrivatePromptMenuCallback(ctx, msg, data, isGroup)
-}
-
-func (s *TelegramBotService) handlePrivatePromptMenuCallback(ctx context.Context, msg *TelegramMessage, data string, isGroup bool) (telegramCommandReply, bool) {
- switch data {
- case "act_bind":
- return telegramPrivateOnlyMenuReply(isGroup, "绑定账号", "请发送：/start 用户名 密码 绑定已有账号。"), true
- case "act_register":
- if isGroup {
- return telegramCommandReply{Text: telegramGroupPrivateUserHint("注册账号")}, true
- }
- if !s.openRegEnabled(ctx) {
- return telegramCommandReply{Text: "注册功能未开放，请联系管理员。"}, true
- }
- s.setPending(int64(msg.From.ID), "register")
- return telegramCommandReply{Text: "请发送新账号的 用户名 密码（空格分隔），例如：alice mypass123"}, true
- case "act_redeem_register":
- if isGroup {
- return telegramCommandReply{Text: telegramGroupPrivateUserHint("兑换码注册")}, true
- }
- s.setPending(int64(msg.From.ID), "redeem_register")
- return telegramCommandReply{Text: "请发送你的注册兑换码，例如：ABCD2345EFGH\n（兑换后会要求设置用户名密码）"}, true
- case "act_redeem_renew":
- if isGroup {
- return telegramCommandReply{Text: telegramGroupPrivateUserHint("兑换码续期")}, true
- }
- s.setPending(int64(msg.From.ID), "redeem_renew")
- return telegramCommandReply{Text: "请发送你的续期兑换码，将为当前绑定账号续期。"}, true
- case "act_setname":
- return s.setPendingPrivatePrompt(msg, isGroup, "修改用户名", "setname", "请发送：当前密码 新用户名。"), true
- case "act_setpass":
- return s.setPendingPrivatePrompt(msg, isGroup, "修改密码", "setpass", "请发送：当前密码 新密码（新密码至少 6 位）。"), true
- }
- return telegramCommandReply{}, false
-}
-
-func telegramPrivateOnlyMenuReply(isGroup bool, action, privateText string) telegramCommandReply {
- if isGroup {
- return telegramCommandReply{Text: telegramGroupPrivateUserHint(action)}
- }
- return telegramCommandReply{Text: privateText}
-}
-
-func (s *TelegramBotService) setPendingPrivatePrompt(msg *TelegramMessage, isGroup bool, action, kind, text string) telegramCommandReply {
- if isGroup {
- return telegramCommandReply{Text: telegramGroupPrivateUserHint(action)}
- }
- s.setPending(int64(msg.From.ID), kind)
- return telegramCommandReply{Text: text}
-}
-
-func (s *TelegramBotService) handleAdminMenuCallback(ctx context.Context, msg *TelegramMessage, data string) (telegramCommandReply, bool) {
- if reply, handled := s.handleAdminRegistrationCallback(ctx, msg, data); handled {
- return reply, true
- }
- if reply, handled := s.handleAdminUserCallback(ctx, data); handled {
- return reply, true
- }
- switch {
- case data == "adm_capacity":
- return s.replyCapacity(ctx), true
- case data == "adm_devicepolicy":
- return s.replyDevicePolicy(ctx), true
- case data == "adm_mgo_commands":
- return telegramCommandReply{Text: telegramMgoAdminCommandHelp(), Buttons: [][]telegramInlineButton{{{Text: "⬅️ 返回菜单", Data: "menu_main"}}}}, true
- case strings.HasPrefix(data, "dp_toggle:"):
- return s.replyDevicePolicyToggle(ctx, strings.TrimPrefix(data, "dp_toggle:")), true
- }
- return telegramCommandReply{}, false
-}
-
-func (s *TelegramBotService) handleAdminRegistrationCallback(ctx context.Context, msg *TelegramMessage, data string) (telegramCommandReply, bool) {
- switch {
- case data == "adm_openreg":
- return s.replyOpenRegMenu(ctx), true
- case data == "adm_openreg_close":
- _ = s.closeRegistration(ctx)
- return telegramCommandReply{Text: "已关闭注册。"}, true
- case strings.HasPrefix(data, "adm_openreg_set:"):
- n, _ := strconv.Atoi(strings.TrimPrefix(data, "adm_openreg_set:"))
- if err := s.openRegistration(ctx, n); err != nil {
- return telegramCommandReply{Text: "开注失败：" + err.Error()}, true
- }
- label := "不限"
- if n > 0 {
- label = fmt.Sprintf("%d 个名额", n)
- }
- return telegramCommandReply{Text: "已开放注册：" + label + "。"}, true
- case data == "adm_gencode":
- return s.replyGenCodeMenu(), true
- case strings.HasPrefix(data, "gc:"):
- return s.replyGenCode(ctx, msg, data), true
- }
- return telegramCommandReply{}, false
-}
-
-func (s *TelegramBotService) handleAdminUserCallback(ctx context.Context, data string) (telegramCommandReply, bool) {
- switch {
- case data == "adm_users":
- return s.replyUserList(ctx), true
- case strings.HasPrefix(data, "usr:"):
- return s.replyUserActions(ctx, strings.TrimPrefix(data, "usr:")), true
- case strings.HasPrefix(data, "uban:"):
- return s.replyUserBan(ctx, strings.TrimPrefix(data, "uban:"), false), true
- case strings.HasPrefix(data, "uunban:"):
- return s.replyUserBan(ctx, strings.TrimPrefix(data, "uunban:"), true), true
- case strings.HasPrefix(data, "udel:"):
- return s.replyUserDelete(ctx, strings.TrimPrefix(data, "udel:")), true
- case strings.HasPrefix(data, "urenew:"):
- return s.replyUserRenew(ctx, strings.TrimPrefix(data, "urenew:")), true
- }
- return telegramCommandReply{}, false
-}
-
-// handlePendingText consumes a button-initiated text prompt. Returns (reply,
-// handled). handled=false means there was no pending prompt for this user.
-func (s *TelegramBotService) handlePendingText(ctx context.Context, channel *model.NotifyChannel, msg *TelegramMessage, text string) (telegramCommandReply, bool) {
- p, ok := s.takePending(int64(msg.From.ID))
- if !ok {
- return telegramCommandReply{}, false
- }
- switch p.Kind {
- case "register":
- return s.cmdRegister(ctx, channel, msg, strings.Fields(text)), true
- case "redeem_register":
- return s.redeemRegisterFlow(ctx, channel, msg, text), true
- case "redeem_renew":
- return s.redeemRenewFlow(ctx, msg, text), true
- case "setname":
- return s.selfSetName(ctx, msg, text), true
- case "setpass":
- return s.selfSetPass(ctx, msg, text), true
- case "openreg_limit":
- n, err := strconv.Atoi(strings.TrimSpace(text))
- if err != nil || n < 0 {
- return telegramCommandReply{Text: "请输入有效的非负整数。"}, true
- }
- if err := s.openRegistration(ctx, n); err != nil {
- return telegramCommandReply{Text: "开注失败：" + err.Error()}, true
- }
- return telegramCommandReply{Text: fmt.Sprintf("已开放注册：%d 个名额。", n)}, true
- }
- return telegramCommandReply{}, false
-}
diff --git a/internal/service/telegram_menu_layout.go b/internal/service/telegram_menu_layout.go
deleted file mode 100644
index 851ca67..0000000
--- a/internal/service/telegram_menu_layout.go
+++ /dev/null
@@ -1,115 +0,0 @@
-package service
-
-import (
- "context"
- "fmt"
-
- "github.com/ShukeBta/MediaStationGo/internal/model"
-)
-
-// mainMenu builds the button-based menu, tailored to the user's binding and
-// admin status. Ordinary users only see self-service actions; admins get an
-// extra management section.
-func (s *TelegramBotService) mainMenu(ctx context.Context, channel *model.NotifyChannel, msg *TelegramMessage) telegramCommandReply {
- isAdmin := s.telegramUserIsAdmin(ctx, channel, msg.From.ID)
- user := s.boundUser(ctx, msg.From.ID)
- if telegramIsGroupChat(msg.Chat.Type) {
- return s.groupMainMenu(isAdmin, user)
- }
- return s.privateMainMenu(ctx, isAdmin, user)
-}
-
-func (s *TelegramBotService) groupMainMenu(isAdmin bool, user *model.User) telegramCommandReply {
- header := "MediaStationGo 群组自助菜单\n\n你还没有绑定媒体中心账号。绑定、注册、兑换等包含敏感信息的操作请私聊 Bot。"
- var rows [][]telegramInlineButton
- if user != nil {
- header = telegramUserMenuHeader("MediaStationGo 群组自助菜单", user)
- rows = telegramBoundUserMenuRows(user, false)
- }
- if isAdmin {
- header += "\n\n管理员入口"
- rows = append(rows, telegramAdminMenuRows()...)
- }
- return telegramCommandReply{Text: header, Buttons: rows}
-}
-
-func (s *TelegramBotService) privateMainMenu(ctx context.Context, isAdmin bool, user *model.User) telegramCommandReply {
- header := "MediaStationGo\n\n你还没有绑定媒体中心账号。"
- rows := s.privateUnboundMenuRows(ctx)
- if user != nil {
- header = telegramUserMenuHeader("MediaStationGo", user)
- rows = telegramBoundUserMenuRows(user, true)
- }
- if isAdmin {
- rows = append(rows, telegramAdminMenuRows()...)
- }
- return telegramCommandReply{Text: header, Buttons: rows}
-}
-
-func (s *TelegramBotService) privateUnboundMenuRows(ctx context.Context) [][]telegramInlineButton {
- rows := [][]telegramInlineButton{{{Text: "🔗 绑定账号", Data: "act_bind"}}}
- if s.openRegEnabled(ctx) {
- rows = append(rows, []telegramInlineButton{{Text: "📝 注册新账号", Data: "act_register"}})
- }
- return append(rows, []telegramInlineButton{{Text: "🎟 兑换码注册", Data: "act_redeem_register"}})
-}
-
-func telegramUserMenuHeader(title string, user *model.User) string {
- return fmt.Sprintf("%s\n\n账号：%s\n到期：%s\n成人目录：%s",
- title, user.Username, formatExpiry(user.ExpiredAt), telegramAdultVisibilityLabel(user.HideAdult))
-}
-
-func telegramAdultVisibilityLabel(hidden bool) string {
- if hidden {
- return "已隐藏"
- }
- return "已显示"
-}
-
-func telegramAdultToggleText(hidden bool) string {
- if hidden {
- return "🔞 显示成人目录"
- }
- return "🔞 隐藏成人目录"
-}
-
-func telegramBoundUserMenuRows(user *model.User, includePrivateActions bool) [][]telegramInlineButton {
- rows := [][]telegramInlineButton{
- {
- {Text: "👤 我的账号", Data: "act_account"},
- {Text: "📅 签到", Data: "act_signin"},
- },
- {
- {Text: "📱 我的设备", Data: "act_devices"},
- {Text: telegramAdultToggleText(user.HideAdult), Data: "adult_toggle"},
- },
- }
- if includePrivateActions {
- rows = append(rows,
- []telegramInlineButton{
- {Text: "✏️ 改用户名", Data: "act_setname"},
- {Text: "🔑 改密码", Data: "act_setpass"},
- },
- []telegramInlineButton{{Text: "🎟 兑换码续期", Data: "act_redeem_renew"}},
- )
- }
- return rows
-}
-
-func telegramAdminMenuRows() [][]telegramInlineButton {
- return [][]telegramInlineButton{
- {{Text: "—— 管理员 ——", Data: "noop"}},
- {
- {Text: "📊 容量/状态", Data: "adm_capacity"},
- {Text: "👥 用户管理", Data: "adm_users"},
- },
- {
- {Text: "🔓 开注设置", Data: "adm_openreg"},
- {Text: "🎟 生成兑换码", Data: "adm_gencode"},
- },
- {
- {Text: "⚙️ 设备策略", Data: "adm_devicepolicy"},
- {Text: "🛠 管理命令", Data: "adm_mgo_commands"},
- },
- }
-}
diff --git a/internal/service/telegram_mgo_admin.go b/internal/service/telegram_mgo_admin.go
deleted file mode 100644
index 728d50f..0000000
--- a/internal/service/telegram_mgo_admin.go
+++ /dev/null
@@ -1,159 +0,0 @@
-package service
-
-import (
- "context"
- "encoding/json"
- "fmt"
- "sort"
- "strconv"
- "strings"
-
- "github.com/ShukeBta/MediaStationGo/internal/model"
-)
-
-func (s *TelegramBotService) cmdMgoAdminRole(ctx context.Context, args []string) telegramCommandReply {
- if len(args) < 2 {
- return telegramCommandReply{Text: "用法：/embyadmin 用户名 on|off"}
- }
- user := s.findMgoBotUser(ctx, args[0])
- if user == nil {
- return telegramCommandReply{Text: "未找到用户。"}
- }
- enable := parseOnOff(args[1])
- if enable == nil {
- return telegramCommandReply{Text: "第二个参数请使用 on/off。"}
- }
- if !*enable {
- if first, _ := s.repo.User.FirstAdmin(ctx); first != nil && first.ID == user.ID {
- return telegramCommandReply{Text: "默认管理员不可降级。"}
- }
- }
- role := "user"
- if *enable {
- role = "admin"
- }
- if err := s.repo.User.UpdateFields(ctx, user.ID, map[string]any{"role": role}); err != nil {
- return telegramCommandReply{Text: "更新失败：" + err.Error()}
- }
- return telegramCommandReply{Text: fmt.Sprintf("已将 %s 角色设置为 %s。", user.Username, role)}
-}
-
-func (s *TelegramBotService) cmdMgoMediaAccessAll(ctx context.Context, allow bool) telegramCommandReply {
- users, err := s.repo.User.List(ctx)
- if err != nil {
- return telegramCommandReply{Text: "读取用户失败：" + err.Error()}
- }
- updated := 0
- for _, user := range users {
- if user.Role == "admin" {
- continue
- }
- perm, err := s.repo.Permission.FindByUserID(ctx, user.ID)
- if err != nil {
- continue
- }
- if perm == nil {
- perm = DefaultPermissions(user.ID)
- perm.CanPlayMedia = allow
- if err := s.repo.Permission.Create(ctx, perm); err != nil {
- continue
- }
- }
- if err := s.repo.DB.WithContext(ctx).Model(&model.UserPermission{}).
- Where("user_id = ?", user.ID).
- Update("can_play_media", allow).Error; err == nil {
- updated++
- }
- }
- state := "关闭"
- if allow {
- state = "开启"
- }
- return telegramCommandReply{Text: fmt.Sprintf("已为普通用户%s媒体播放权限：%d 个。", state, updated)}
-}
-
-func (s *TelegramBotService) cmdMgoBotAdmin(ctx context.Context, channel *model.NotifyChannel, args []string, add bool) telegramCommandReply {
- if channel == nil {
- return telegramCommandReply{Text: "Telegram 渠道不存在。"}
- }
- if len(args) == 0 {
- return telegramCommandReply{Text: "用法：/proadmin TelegramID 或 /revadmin TelegramID"}
- }
- tgID := strings.TrimPrefix(strings.TrimSpace(args[0]), "tg:")
- if _, err := strconv.ParseInt(tgID, 10, 64); err != nil {
- return telegramCommandReply{Text: "TelegramID 必须是数字。"}
- }
- cfg := s.telegramChannelConfig(channel)
- ids := telegramConfiguredUserIDs(cfg["admin_user_ids"])
- seen := make(map[string]bool, len(ids)+1)
- var next []string
- for _, id := range ids {
- if id == tgID {
- seen[id] = true
- if add {
- next = append(next, id)
- }
- continue
- }
- if id != "" {
- next = append(next, id)
- }
- }
- if add && !seen[tgID] {
- next = append(next, tgID)
- }
- cfg["admin_user_ids"] = strings.Join(next, ",")
- raw, _ := json.Marshal(cfg)
- updated := *channel
- updated.Config = string(raw)
- if s.crypto != nil {
- updated.Config = s.crypto.Encrypt(updated.Config)
- }
- if err := s.repo.NotifyChannel.Update(ctx, &updated); err != nil {
- return telegramCommandReply{Text: "更新管理员列表失败：" + err.Error()}
- }
- if add {
- return telegramCommandReply{Text: "已添加 Bot 管理员：" + tgID + ""}
- }
- return telegramCommandReply{Text: "已移除 Bot 管理员：" + tgID + ""}
-}
-
-func (s *TelegramBotService) cmdMgoProtectedUser(ctx context.Context, args []string, protect bool) telegramCommandReply {
- if len(args) == 0 || strings.EqualFold(args[0], "list") {
- return s.cmdMgoProtectedUserList(ctx)
- }
- user := s.findMgoBotUser(ctx, args[0])
- if user == nil {
- return telegramCommandReply{Text: "未找到用户。"}
- }
- ids := ProtectedUserIDSet(ctx, s.repo)
- if protect {
- ids[user.ID] = struct{}{}
- if err := SaveProtectedUserIDSet(ctx, s.repo, ids); err != nil {
- return telegramCommandReply{Text: "保存保护名单失败：" + err.Error()}
- }
- return telegramCommandReply{Text: fmt.Sprintf("已加入保护名单：%s。\n该用户不会被 Bot 自动清理、批量禁用或删除。", user.Username)}
- }
- delete(ids, user.ID)
- if err := SaveProtectedUserIDSet(ctx, s.repo, ids); err != nil {
- return telegramCommandReply{Text: "保存保护名单失败：" + err.Error()}
- }
- return telegramCommandReply{Text: fmt.Sprintf("已移出保护名单：%s。", user.Username)}
-}
-
-func (s *TelegramBotService) cmdMgoProtectedUserList(ctx context.Context) telegramCommandReply {
- ids := ProtectedUserIDSet(ctx, s.repo)
- if len(ids) == 0 {
- return telegramCommandReply{Text: "保护名单为空。管理员和默认管理员始终自动保护。"}
- }
- names := make([]string, 0, len(ids))
- for id := range ids {
- if user, _ := s.repo.User.FindByID(ctx, id); user != nil {
- names = append(names, user.Username)
- } else {
- names = append(names, id+"(用户不存在)")
- }
- }
- sort.Strings(names)
- return telegramCommandReply{Text: fmt.Sprintf("保护名单：%d 个。\n%s", len(names), telegramInlineCodeList(names))}
-}
diff --git a/internal/service/telegram_mgo_audit.go b/internal/service/telegram_mgo_audit.go
deleted file mode 100644
index b696852..0000000
--- a/internal/service/telegram_mgo_audit.go
+++ /dev/null
@@ -1,133 +0,0 @@
-package service
-
-import (
- "context"
- "fmt"
- "strings"
- "time"
-
- "github.com/ShukeBta/MediaStationGo/internal/model"
-)
-
-func (s *TelegramBotService) cmdMgoSyncUnbound(ctx context.Context, args []string) telegramCommandReply {
- var users []model.User
- if err := s.repo.DB.WithContext(ctx).
- Where("role <> ?", "admin").
- Where("NOT EXISTS (SELECT 1 FROM telegram_bindings WHERE telegram_bindings.user_id = users.id AND telegram_bindings.deleted_at IS NULL)").
- Order("created_at asc").Find(&users).Error; err != nil {
- return telegramCommandReply{Text: "查询失败：" + err.Error()}
- }
- if len(args) >= 2 && strings.EqualFold(args[0], "delete") && strings.EqualFold(args[1], "confirm") {
- deleted := 0
- for _, user := range users {
- if UserIsProtectedAccount(ctx, s.repo, &user) {
- continue
- }
- _ = s.repo.UserDevice.DeleteByUser(ctx, user.ID)
- if err := s.repo.User.Delete(ctx, user.ID); err == nil {
- deleted++
- }
- }
- return telegramCommandReply{Text: fmt.Sprintf("已删除未绑定 Bot 的普通用户：%d 个。", deleted)}
- }
- if len(users) == 0 {
- return telegramCommandReply{Text: "没有未绑定 Bot 的普通用户。"}
- }
- names := make([]string, 0, minInt(len(users), 20))
- for i, user := range users {
- if i >= 20 {
- break
- }
- names = append(names, user.Username)
- }
- return telegramCommandReply{Text: fmt.Sprintf("未绑定 Bot 的普通用户：%d 个。\n%s\n\n如需删除：/syncunbound delete confirm", len(users), telegramInlineCodeList(names))}
-}
-
-func (s *TelegramBotService) cmdMgoCheckExpired(ctx context.Context, args []string) telegramCommandReply {
- now := time.Now()
- var users []model.User
- if err := s.repo.DB.WithContext(ctx).Where("expired_at IS NOT NULL AND expired_at < ?", now).Order("expired_at asc").Find(&users).Error; err != nil {
- return telegramCommandReply{Text: "查询失败：" + err.Error()}
- }
- if len(args) >= 2 && strings.EqualFold(args[0], "disable") && strings.EqualFold(args[1], "confirm") {
- disabled := 0
- for _, user := range users {
- if UserIsProtectedAccount(ctx, s.repo, &user) {
- continue
- }
- if err := s.repo.User.UpdateFields(ctx, user.ID, map[string]any{"is_active": false}); err == nil {
- disabled++
- }
- }
- return telegramCommandReply{Text: fmt.Sprintf("已禁用过期普通用户：%d 个。", disabled)}
- }
- if len(users) == 0 {
- return telegramCommandReply{Text: "没有过期用户。"}
- }
- lines := make([]string, 0, minInt(len(users), 20))
- for i, user := range users {
- if i >= 20 {
- break
- }
- lines = append(lines, fmt.Sprintf("%s（%s）", user.Username, formatExpiry(user.ExpiredAt)))
- }
- return telegramCommandReply{Text: fmt.Sprintf("过期用户：%d 个。\n%s\n\n如需禁用：/check_ex disable confirm", len(users), telegramInlineCodeList(lines))}
-}
-
-func (s *TelegramBotService) cmdMgoScanNames(ctx context.Context) telegramCommandReply {
- var rows []struct {
- Username string
- Count int64
- }
- if err := s.repo.DB.WithContext(ctx).Table("users").
- Select("LOWER(username) AS username, COUNT(*) AS count").
- Group("LOWER(username)").Having("COUNT(*) > 1").Scan(&rows).Error; err != nil {
- return telegramCommandReply{Text: "扫描失败：" + err.Error()}
- }
- if len(rows) == 0 {
- return telegramCommandReply{Text: "未发现同名用户记录。"}
- }
- var out []string
- for _, row := range rows {
- out = append(out, fmt.Sprintf("%s x%d", row.Username, row.Count))
- }
- return telegramCommandReply{Text: "同名用户记录\n" + telegramInlineCodeList(out)}
-}
-
-func (s *TelegramBotService) cmdMgoRanks(ctx context.Context, window time.Duration, byDuration bool) telegramCommandReply {
- since := time.Now().Add(-window)
- title := "播放次数排行"
- selectExpr := "COUNT(*) AS score"
- if byDuration {
- title = "观影时长排行"
- selectExpr = "COALESCE(SUM(position_ms), 0) AS score"
- }
- q := s.repo.DB.WithContext(ctx).Table("playback_histories").
- Select("users.username, " + selectExpr).
- Joins("JOIN users ON users.id = playback_histories.user_id").
- Group("users.username").
- Order("score DESC").
- Limit(10)
- if window > 0 {
- q = q.Where("playback_histories.watched_at >= ?", since)
- }
- var rows []struct {
- Username string
- Score int64
- }
- if err := q.Scan(&rows).Error; err != nil {
- return telegramCommandReply{Text: "排行查询失败：" + err.Error()}
- }
- if len(rows) == 0 {
- return telegramCommandReply{Text: "暂无排行数据。"}
- }
- var out []string
- for i, row := range rows {
- score := fmt.Sprintf("%d 次", row.Score)
- if byDuration {
- score = humanDurationFromMillis(row.Score)
- }
- out = append(out, fmt.Sprintf("%d. %s — %s", i+1, row.Username, score))
- }
- return telegramCommandReply{Text: "" + title + "\n\n" + strings.Join(out, "\n") + ""}
-}
diff --git a/internal/service/telegram_mgo_backup.go b/internal/service/telegram_mgo_backup.go
deleted file mode 100644
index 7ba58c9..0000000
--- a/internal/service/telegram_mgo_backup.go
+++ /dev/null
@@ -1,49 +0,0 @@
-package service
-
-import (
- "context"
- "fmt"
- "strings"
-)
-
-func (s *TelegramBotService) cmdMgoBackupDB(ctx context.Context) telegramCommandReply {
- if s.backup == nil {
- return telegramCommandReply{Text: "备份服务暂不可用。"}
- }
- info, err := s.backup.Create(ctx)
- if err != nil {
- return telegramCommandReply{Text: "数据库备份失败：" + err.Error()}
- }
- return telegramCommandReply{Text: fmt.Sprintf("数据库备份完成：%s\n大小：%d bytes", info.Filename, info.Size)}
-}
-
-func (s *TelegramBotService) cmdMgoRestoreDB(ctx context.Context, args []string) telegramCommandReply {
- if s.backup == nil {
- return telegramCommandReply{Text: "备份服务暂不可用。"}
- }
- if len(args) == 0 || strings.EqualFold(args[0], "list") {
- items, err := s.backup.List()
- if err != nil {
- return telegramCommandReply{Text: "读取备份列表失败：" + err.Error()}
- }
- if len(items) == 0 {
- return telegramCommandReply{Text: "暂无数据库备份。可先使用 /backup_db 创建。"}
- }
- lines := make([]string, 0, minInt(len(items), 10))
- for i, item := range items {
- if i >= 10 {
- break
- }
- lines = append(lines, fmt.Sprintf("%s（%d bytes）", item.Filename, item.Size))
- }
- return telegramCommandReply{Text: "可恢复备份：\n" + telegramInlineCodeList(lines) + "\n\n恢复需要确认：/restore_from_db 文件名 confirm"}
- }
- if len(args) < 2 || !strings.EqualFold(args[len(args)-1], "confirm") {
- return telegramCommandReply{Text: "恢复数据库会覆盖当前数据，需要确认：/restore_from_db 文件名 confirm"}
- }
- filename := strings.TrimSpace(args[0])
- if err := s.backup.Restore(ctx, filename); err != nil {
- return telegramCommandReply{Text: "恢复失败：" + err.Error()}
- }
- return telegramCommandReply{Text: "数据库已从备份恢复，请重启 MediaStationGo 后生效。"}
-}
diff --git a/internal/service/telegram_mgo_bulk.go b/internal/service/telegram_mgo_bulk.go
deleted file mode 100644
index e06f554..0000000
--- a/internal/service/telegram_mgo_bulk.go
+++ /dev/null
@@ -1,94 +0,0 @@
-package service
-
-import (
- "context"
- "fmt"
- "strconv"
- "strings"
-
- "github.com/ShukeBta/MediaStationGo/internal/model"
-)
-
-func (s *TelegramBotService) cmdMgoRenewAll(ctx context.Context, args []string) telegramCommandReply {
- if len(args) < 2 || !strings.EqualFold(args[len(args)-1], "confirm") {
- return telegramCommandReply{Text: "批量续期需要确认：/renewall 天数 confirm"}
- }
- days, err := strconv.Atoi(args[0])
- if err != nil || days < 0 {
- return telegramCommandReply{Text: "天数必须是非负整数，0 表示永久。"}
- }
- users, err := s.repo.User.List(ctx)
- if err != nil {
- return telegramCommandReply{Text: "读取用户失败：" + err.Error()}
- }
- var count int
- for _, user := range users {
- if user.Role == "admin" {
- continue
- }
- if err := s.applyRenewal(ctx, user.ID, days); err == nil {
- count++
- }
- }
- return telegramCommandReply{Text: fmt.Sprintf("批量续期完成：%d 个普通用户。", count)}
-}
-
-func (s *TelegramBotService) cmdMgoBanAll(ctx context.Context, active bool, args []string) telegramCommandReply {
- if len(args) == 0 || !strings.EqualFold(args[len(args)-1], "confirm") {
- action := "banall"
- if active {
- action = "unbanall"
- }
- return telegramCommandReply{Text: fmt.Sprintf("批量操作需要确认：/%s confirm", action)}
- }
- users, err := s.repo.User.List(ctx)
- if err != nil {
- return telegramCommandReply{Text: "读取用户失败：" + err.Error()}
- }
- var count int
- for _, user := range users {
- if !active && UserIsProtectedAccount(ctx, s.repo, &user) {
- continue
- }
- if active && user.Role == "admin" {
- continue
- }
- updates := map[string]any{"is_active": active}
- if active {
- updates["share_warnings"] = 0
- updates["last_share_warn_at"] = nil
- }
- if err := s.repo.User.UpdateFields(ctx, user.ID, updates); err == nil {
- _ = s.repo.UserDevice.SetKickedByUser(ctx, user.ID, !active)
- count++
- }
- }
- if active {
- return telegramCommandReply{Text: fmt.Sprintf("已解禁普通用户：%d 个。", count)}
- }
- return telegramCommandReply{Text: fmt.Sprintf("已禁用普通用户：%d 个。", count)}
-}
-
-func (s *TelegramBotService) cmdMgoCallAll(ctx context.Context, channel *model.NotifyChannel, args []string) telegramCommandReply {
- message := strings.TrimSpace(strings.Join(args, " "))
- if message == "" {
- return telegramCommandReply{Text: "用法：/callall 消息内容"}
- }
- if strings.TrimSpace(s.telegramChannelConfig(channel)["bot_token"]) == "" {
- return telegramCommandReply{Text: "当前 Telegram 渠道未配置 bot_token，无法群发。"}
- }
- var bindings []model.TelegramBinding
- if err := s.repo.DB.WithContext(ctx).Find(&bindings).Error; err != nil {
- return telegramCommandReply{Text: "读取绑定失败：" + err.Error()}
- }
- sent := 0
- for _, binding := range bindings {
- if binding.ChatID == 0 {
- continue
- }
- if err := s.reply(ctx, channel, int(binding.ChatID), telegramCommandReply{Text: message}); err == nil {
- sent++
- }
- }
- return telegramCommandReply{Text: fmt.Sprintf("群发完成：成功发送 %d 个绑定用户。", sent)}
-}
diff --git a/internal/service/telegram_mgo_compat.go b/internal/service/telegram_mgo_compat.go
deleted file mode 100644
index 46f2188..0000000
--- a/internal/service/telegram_mgo_compat.go
+++ /dev/null
@@ -1,104 +0,0 @@
-package service
-
-import (
- "context"
- "fmt"
- "strconv"
- "strings"
- "time"
-
- "github.com/ShukeBta/MediaStationGo/internal/model"
-)
-
-func (s *TelegramBotService) cmdMgoUnsupported(name, replacement string) telegramCommandReply {
- text := fmt.Sprintf("%s 已识别，但当前 Telegram Bot API 无法完整复刻该行为。", name)
- if replacement != "" {
- text += "\n请使用：" + replacement
- }
- return telegramCommandReply{Text: text}
-}
-
-func (s *TelegramBotService) findMgoBotUser(ctx context.Context, target string) *model.User {
- target = strings.TrimSpace(strings.TrimPrefix(target, "@"))
- if target == "" {
- return nil
- }
- if user, _ := s.repo.User.FindByUsername(ctx, target); user != nil {
- return user
- }
- if user, _ := s.repo.User.FindByID(ctx, target); user != nil {
- return user
- }
- if tgRaw, ok := strings.CutPrefix(strings.ToLower(target), "tg:"); ok {
- if tgID, err := strconv.ParseInt(tgRaw, 10, 64); err == nil {
- var binding model.TelegramBinding
- if err := s.repo.DB.WithContext(ctx).Where("telegram_user_id = ?", tgID).First(&binding).Error; err == nil {
- user, _ := s.repo.User.FindByID(ctx, binding.UserID)
- return user
- }
- }
- }
- return nil
-}
-
-func activeLabel(user *model.User) string {
- if user == nil {
- return "未知"
- }
- if !user.IsActive {
- return "已禁用"
- }
- if user.ExpiredAt != nil && time.Now().After(*user.ExpiredAt) {
- return "已过期"
- }
- return "正常"
-}
-
-func formatOptionalTime(t *time.Time) string {
- if t == nil {
- return "-"
- }
- return t.Format("2006-01-02 15:04")
-}
-
-func blankDash(value string) string {
- value = strings.TrimSpace(value)
- if value == "" {
- return "-"
- }
- return value
-}
-
-func telegramInlineCodeList(items []string) string {
- if len(items) == 0 {
- return ""
- }
- return "" + strings.Join(items, "、") + ""
-}
-
-func parseOnOff(raw string) *bool {
- value := strings.ToLower(strings.TrimSpace(raw))
- switch value {
- case "on", "true", "1", "yes", "enable", "enabled", "开启", "开":
- v := true
- return &v
- case "off", "false", "0", "no", "disable", "disabled", "关闭", "关":
- v := false
- return &v
- default:
- return nil
- }
-}
-
-func humanDurationFromMillis(ms int64) string {
- if ms <= 0 {
- return "0 分钟"
- }
- totalMinutes := ms / 1000 / 60
- hours := totalMinutes / 60
- minutes := totalMinutes % 60
- if hours == 0 {
- return fmt.Sprintf("%d 分钟", minutes)
- }
- return fmt.Sprintf("%d 小时 %d 分钟", hours, minutes)
-}
diff --git a/internal/service/telegram_mgo_compat_test.go b/internal/service/telegram_mgo_compat_test.go
deleted file mode 100644
index bf3abee..0000000
--- a/internal/service/telegram_mgo_compat_test.go
+++ /dev/null
@@ -1,278 +0,0 @@
-package service
-
-import (
- "strings"
- "testing"
- "time"
-
- "go.uber.org/zap"
-
- "github.com/ShukeBta/MediaStationGo/internal/config"
- "github.com/ShukeBta/MediaStationGo/internal/model"
-)
-
-func TestMgoBotUserManagementAndAuditCommands(t *testing.T) {
- ctx := t.Context()
- repos, bot := newBotTestService(t)
- if err := repos.User.Create(ctx, &model.User{Username: "root", PasswordHash: "x", Role: "admin", IsActive: true}); err != nil {
- t.Fatal(err)
- }
- channel := &model.NotifyChannel{Name: "Telegram", Type: "telegram", Enabled: true, Config: `{"admin_user_ids":"9401"}`}
- msg := &TelegramMessage{From: TelegramUser{ID: 9401, Username: "admin"}, Chat: TelegramChat{ID: 9401, Type: "private"}}
-
- reply, err := bot.executeCommand(ctx, channel, msg, "/ucr viewer secret-pass 30")
- if err != nil {
- t.Fatal(err)
- }
- if !strings.Contains(reply.Text, "已创建用户") {
- t.Fatalf("expected user creation, got %q", reply.Text)
- }
- viewer, err := repos.User.FindByUsername(ctx, "viewer")
- if err != nil || viewer == nil {
- t.Fatalf("viewer should exist: %v", err)
- }
- if err := repos.UserDevice.Create(ctx, &model.UserDevice{
- UserID: viewer.ID,
- DeviceID: "dev-abc",
- DeviceName: "Windows PC",
- Client: "Infuse",
- LastIP: "1.2.3.4",
- FirstSeenAt: time.Now(),
- LastSeenAt: time.Now(),
- }); err != nil {
- t.Fatal(err)
- }
-
- for _, tc := range []struct {
- command string
- want string
- }{
- {"/uinfo viewer", "用户信息"},
- {"/userip viewer", "1.2.3.4"},
- {"/auditip 1.2.3", "viewer"},
- {"/auditdevice Windows", "viewer"},
- {"/auditclient Infuse", "viewer"},
- {"/udeviceid dev-abc", "viewer"},
- } {
- t.Run(tc.command, func(t *testing.T) {
- reply, err := bot.executeCommand(ctx, channel, msg, tc.command)
- if err != nil {
- t.Fatal(err)
- }
- if !strings.Contains(reply.Text, tc.want) {
- t.Fatalf("%s expected %q in %q", tc.command, tc.want, reply.Text)
- }
- })
- }
-}
-
-func TestMgoBotBatchAndPermissionCommands(t *testing.T) {
- ctx := t.Context()
- repos, bot := newBotTestService(t)
- channel := &model.NotifyChannel{Name: "Telegram", Type: "telegram", Enabled: true, Config: `{"admin_user_ids":"9501"}`}
- msg := &TelegramMessage{From: TelegramUser{ID: 9501, Username: "admin"}, Chat: TelegramChat{ID: 9501, Type: "private"}}
- users := []*model.User{
- {Username: "root", PasswordHash: "x", Role: "admin", IsActive: true},
- {Username: "viewer1", PasswordHash: "x", Role: "user", IsActive: true},
- {Username: "viewer2", PasswordHash: "x", Role: "user", IsActive: true},
- {Username: "viewer3", PasswordHash: "x", Role: "user", IsActive: true},
- }
- for _, user := range users {
- if err := repos.User.Create(ctx, user); err != nil {
- t.Fatal(err)
- }
- if user.Role != "admin" && user.Username != "viewer3" {
- if err := repos.Permission.Create(ctx, DefaultPermissions(user.ID)); err != nil {
- t.Fatal(err)
- }
- }
- }
-
- reply, err := bot.executeCommand(ctx, channel, msg, "/renewall 7 confirm")
- if err != nil {
- t.Fatal(err)
- }
- if !strings.Contains(reply.Text, "批量续期完成") {
- t.Fatalf("expected renewall success, got %q", reply.Text)
- }
- renewed, _ := repos.User.FindByUsername(ctx, "viewer1")
- if renewed.ExpiredAt == nil {
- t.Fatal("renewall should set expiry for normal users")
- }
-
- if reply, err = bot.executeCommand(ctx, channel, msg, "/embylibs_blockall"); err != nil || !strings.Contains(reply.Text, "关闭媒体播放权限") {
- t.Fatalf("expected blockall success, reply=%q err=%v", reply.Text, err)
- }
- perm, _ := repos.Permission.FindByUserID(ctx, users[1].ID)
- if perm == nil || perm.CanPlayMedia {
- t.Fatal("embylibs_blockall should disable media playback for normal users")
- }
- perm, _ = repos.Permission.FindByUserID(ctx, users[3].ID)
- if perm == nil || perm.CanPlayMedia {
- t.Fatal("embylibs_blockall should create disabled media playback permissions when missing")
- }
- if reply, err = bot.executeCommand(ctx, channel, msg, "/embylibs_unblockall"); err != nil || !strings.Contains(reply.Text, "开启媒体播放权限") {
- t.Fatalf("expected unblockall success, reply=%q err=%v", reply.Text, err)
- }
- perm, _ = repos.Permission.FindByUserID(ctx, users[1].ID)
- if perm == nil || !perm.CanPlayMedia {
- t.Fatal("embylibs_unblockall should enable media playback for normal users")
- }
-
- if reply, err = bot.executeCommand(ctx, channel, msg, "/banall confirm"); err != nil || !strings.Contains(reply.Text, "已禁用普通用户") {
- t.Fatalf("expected banall success, reply=%q err=%v", reply.Text, err)
- }
- banned, _ := repos.User.FindByUsername(ctx, "viewer2")
- if banned.IsActive {
- t.Fatal("banall should disable normal users")
- }
- if reply, err = bot.executeCommand(ctx, channel, msg, "/unbanall confirm"); err != nil || !strings.Contains(reply.Text, "已解禁普通用户") {
- t.Fatalf("expected unbanall success, reply=%q err=%v", reply.Text, err)
- }
- unbanned, _ := repos.User.FindByUsername(ctx, "viewer2")
- if !unbanned.IsActive {
- t.Fatal("unbanall should re-enable normal users")
- }
-}
-
-func TestMgoBotSyncExpiryAndBotAdminCommands(t *testing.T) {
- ctx := t.Context()
- repos, bot := newBotTestService(t)
- channel := &model.NotifyChannel{Name: "Telegram", Type: "telegram", Enabled: true, Config: `{"admin_user_ids":"9601"}`}
- if err := repos.NotifyChannel.Create(ctx, channel); err != nil {
- t.Fatal(err)
- }
- msg := &TelegramMessage{From: TelegramUser{ID: 9601, Username: "admin"}, Chat: TelegramChat{ID: 9601, Type: "private"}}
- past := time.Now().Add(-24 * time.Hour)
- if err := repos.User.Create(ctx, &model.User{Username: "expired", PasswordHash: "x", Role: "user", IsActive: true, ExpiredAt: &past}); err != nil {
- t.Fatal(err)
- }
-
- reply, err := bot.executeCommand(ctx, channel, msg, "/syncunbound")
- if err != nil {
- t.Fatal(err)
- }
- if !strings.Contains(reply.Text, "expired") {
- t.Fatalf("syncunbound should list unbound users, got %q", reply.Text)
- }
- reply, err = bot.executeCommand(ctx, channel, msg, "/check_ex")
- if err != nil {
- t.Fatal(err)
- }
- if !strings.Contains(reply.Text, "expired") {
- t.Fatalf("check_ex should list expired users, got %q", reply.Text)
- }
- reply, err = bot.executeCommand(ctx, channel, msg, "/proadmin 9602")
- if err != nil {
- t.Fatal(err)
- }
- if !strings.Contains(reply.Text, "已添加") {
- t.Fatalf("proadmin should update channel config, got %q", reply.Text)
- }
- updated, _ := repos.NotifyChannel.FindByID(ctx, channel.ID)
- cfg := bot.telegramChannelConfig(updated)
- if !strings.Contains(cfg["admin_user_ids"], "9602") {
- t.Fatalf("expected admin ids to include 9602, got %#v", cfg)
- }
-}
-
-func TestMgoBotProtectedUsersAndBackupCommands(t *testing.T) {
- ctx := t.Context()
- repos, bot := newBotTestService(t)
- cfg := &config.Config{}
- cfg.App.DataDir = t.TempDir()
- bot.SetBackupService(NewBackupService(cfg, zap.NewNop(), repos.DB))
-
- channel := &model.NotifyChannel{Name: "Telegram", Type: "telegram", Enabled: true, Config: `{"admin_user_ids":"9701"}`}
- msg := &TelegramMessage{From: TelegramUser{ID: 9701, Username: "admin"}, Chat: TelegramChat{ID: 9701, Type: "private"}}
- users := []*model.User{
- {Username: "root", PasswordHash: "x", Role: "admin", IsActive: true},
- {Username: "safe", PasswordHash: "x", Role: "user", IsActive: true},
- {Username: "normal", PasswordHash: "x", Role: "user", IsActive: true},
- }
- for _, user := range users {
- if err := repos.User.Create(ctx, user); err != nil {
- t.Fatal(err)
- }
- }
-
- reply, err := bot.executeCommand(ctx, channel, msg, "/prouser safe")
- if err != nil {
- t.Fatal(err)
- }
- if !strings.Contains(reply.Text, "已加入保护名单") {
- t.Fatalf("expected protect success, got %q", reply.Text)
- }
- if reason := bot.protectReason(ctx, users[1].ID); !strings.Contains(reason, "保护名单") {
- t.Fatalf("protected user should have protect reason, got %q", reason)
- }
- reply, err = bot.executeCommand(ctx, channel, msg, "/banall confirm")
- if err != nil {
- t.Fatal(err)
- }
- if !strings.Contains(reply.Text, "已禁用普通用户") {
- t.Fatalf("expected banall success, got %q", reply.Text)
- }
- protected, _ := repos.User.FindByUsername(ctx, "safe")
- normal, _ := repos.User.FindByUsername(ctx, "normal")
- if !protected.IsActive {
- t.Fatal("protected user should not be disabled by banall")
- }
- if normal.IsActive {
- t.Fatal("normal user should be disabled by banall")
- }
- reply, err = bot.executeCommand(ctx, channel, msg, "/revuser safe")
- if err != nil {
- t.Fatal(err)
- }
- if !strings.Contains(reply.Text, "已移出保护名单") {
- t.Fatalf("expected unprotect success, got %q", reply.Text)
- }
-
- reply, err = bot.executeCommand(ctx, channel, msg, "/backup_db")
- if err != nil {
- t.Fatal(err)
- }
- if !strings.Contains(reply.Text, "数据库备份完成") {
- t.Fatalf("backup_db should create backup, got %q", reply.Text)
- }
- reply, err = bot.executeCommand(ctx, channel, msg, "/restore_from_db list")
- if err != nil {
- t.Fatal(err)
- }
- if !strings.Contains(reply.Text, "mediastation_") {
- t.Fatalf("restore list should show backup, got %q", reply.Text)
- }
-}
-
-func TestMgoBotAliasesAndSyncGroupGuards(t *testing.T) {
- ctx := t.Context()
- repos, bot := newBotTestService(t)
- if err := repos.User.Create(ctx, &model.User{Username: "root", PasswordHash: "x", Role: "admin", IsActive: true}); err != nil {
- t.Fatal(err)
- }
- channel := &model.NotifyChannel{Name: "Telegram", Type: "telegram", Enabled: true, Config: `{"admin_user_ids":"9801"}`}
- msg := &TelegramMessage{From: TelegramUser{ID: 9801, Username: "admin"}, Chat: TelegramChat{ID: 9801, Type: "private"}}
-
- reply, err := bot.executeCommand(ctx, channel, msg, "/kk")
- if err != nil {
- t.Fatal(err)
- }
- if !strings.Contains(reply.Text, "用户管理") {
- t.Fatalf("/kk should map to user management, got %q", reply.Text)
- }
- reply, err = bot.executeCommand(ctx, channel, msg, "/syncgroupm")
- if err != nil {
- t.Fatal(err)
- }
- if !strings.Contains(reply.Text, "未配置可校验成员") {
- t.Fatalf("syncgroupm should explain missing group config, got %q", reply.Text)
- }
- reply, err = bot.executeCommand(ctx, channel, msg, "/kick_not_emby")
- if err != nil {
- t.Fatal(err)
- }
- if !strings.Contains(reply.Text, "无法枚举全部群成员") {
- t.Fatalf("kick_not_emby should explain Telegram limitation, got %q", reply.Text)
- }
-}
diff --git a/internal/service/telegram_mgo_membership.go b/internal/service/telegram_mgo_membership.go
deleted file mode 100644
index 0804483..0000000
--- a/internal/service/telegram_mgo_membership.go
+++ /dev/null
@@ -1,92 +0,0 @@
-package service
-
-import (
- "context"
- "fmt"
- "strings"
-
- "github.com/ShukeBta/MediaStationGo/internal/model"
-)
-
-func (s *TelegramBotService) cmdMgoSyncGroup(ctx context.Context, channel *model.NotifyChannel, args []string) telegramCommandReply {
- chatIDs := s.telegramMembershipChatIDs(channel)
- if len(chatIDs) == 0 {
- return telegramCommandReply{Text: "未配置可校验成员的群组/频道 ID。请在 Telegram 通知渠道设置 group_chat_id 或 channel_chat_id。"}
- }
- if strings.TrimSpace(s.telegramChannelConfig(channel)["bot_token"]) == "" {
- return telegramCommandReply{Text: "当前 Telegram 渠道未配置 bot_token，无法校验群成员。"}
- }
- var bindings []model.TelegramBinding
- if err := s.repo.DB.WithContext(ctx).Find(&bindings).Error; err != nil {
- return telegramCommandReply{Text: "读取绑定失败：" + err.Error()}
- }
- type staleBinding struct {
- User model.User
- Binding model.TelegramBinding
- }
- var stale []staleBinding
- for _, binding := range bindings {
- if binding.TelegramUserID == 0 || binding.UserID == "" {
- continue
- }
- user, _ := s.repo.User.FindByID(ctx, binding.UserID)
- if user == nil || UserIsProtectedAccount(ctx, s.repo, user) {
- continue
- }
- // 仅当所有绑定群组/频道都「查实不是成员」时才判定为可清理；
- // getChatMember 出错（membershipUnknown）时保守跳过，避免误删。
- confirmedNo := true
- for _, chatID := range chatIDs {
- if s.telegramChatMembership(ctx, channel, chatID, int(binding.TelegramUserID)) != membershipNo {
- confirmedNo = false
- break
- }
- }
- if confirmedNo {
- stale = append(stale, staleBinding{User: *user, Binding: binding})
- }
- }
- if len(stale) == 0 {
- return telegramCommandReply{Text: "所有已绑定账号都仍在配置的群组/频道中。"}
- }
- if len(args) >= 2 && strings.EqualFold(args[0], "delete") && strings.EqualFold(args[1], "confirm") {
- deleted := 0
- for _, item := range stale {
- _ = s.repo.UserDevice.DeleteByUser(ctx, item.User.ID)
- if err := s.repo.User.Delete(ctx, item.User.ID); err == nil {
- deleted++
- }
- }
- return telegramCommandReply{Text: fmt.Sprintf("已删除不在群组/频道中的普通账号：%d 个。", deleted)}
- }
- names := make([]string, 0, minInt(len(stale), 20))
- for i, item := range stale {
- if i >= 20 {
- break
- }
- names = append(names, fmt.Sprintf("%s(tg:%d)", item.User.Username, item.Binding.TelegramUserID))
- }
- return telegramCommandReply{Text: fmt.Sprintf("不在配置群组/频道中的绑定账号：%d 个。\n%s\n\n删除需确认：/syncgroupm delete confirm", len(stale), telegramInlineCodeList(names))}
-}
-
-func (s *TelegramBotService) telegramMembershipChatIDs(channel *model.NotifyChannel) []string {
- cfg := s.telegramChannelConfig(channel)
- seen := map[string]struct{}{}
- var out []string
- for _, key := range []string{"group_chat_id", "channel_chat_id", "command_chat_id"} {
- value := strings.TrimSpace(cfg[key])
- if value == "" {
- continue
- }
- if _, ok := seen[value]; !ok {
- seen[value] = struct{}{}
- out = append(out, value)
- }
- }
- if len(out) == 0 {
- if value := strings.TrimSpace(cfg["chat_id"]); strings.HasPrefix(value, "-") {
- out = append(out, value)
- }
- }
- return out
-}
diff --git a/internal/service/telegram_mgo_users.go b/internal/service/telegram_mgo_users.go
deleted file mode 100644
index 552ed3b..0000000
--- a/internal/service/telegram_mgo_users.go
+++ /dev/null
@@ -1,184 +0,0 @@
-package service
-
-import (
- "context"
- "fmt"
- "strconv"
- "strings"
- "time"
-
- "github.com/ShukeBta/MediaStationGo/internal/model"
-)
-
-func (s *TelegramBotService) cmdMgoCreateUser(ctx context.Context, args []string) telegramCommandReply {
- if len(args) < 2 {
- return telegramCommandReply{Text: "用法：/ucr 用户名 密码 [天数]，天数 0 表示永久。"}
- }
- if s.auth == nil {
- return telegramCommandReply{Text: "注册服务暂不可用。"}
- }
- user, _, err := s.auth.Register(ctx, args[0], args[1])
- if err != nil {
- return telegramCommandReply{Text: "创建失败：" + err.Error()}
- }
- days := 0
- if len(args) >= 3 {
- parsed, err := strconv.Atoi(args[2])
- if err != nil || parsed < 0 {
- return telegramCommandReply{Text: "账号已创建，但天数无效。请用 /renew 用户名 天数 调整。"}
- }
- days = parsed
- if err := s.applyRenewal(ctx, user.ID, days); err != nil {
- return telegramCommandReply{Text: "账号已创建，但续期失败：" + err.Error()}
- }
- }
- return telegramCommandReply{Text: fmt.Sprintf("已创建用户：%s\n到期：%s", user.Username, formatExpiry(s.userExpiry(ctx, user.ID)))}
-}
-
-func (s *TelegramBotService) cmdMgoUserInfo(ctx context.Context, args []string) telegramCommandReply {
- if len(args) == 0 {
- return telegramCommandReply{Text: "用法：/uinfo 用户名"}
- }
- user := s.findMgoBotUser(ctx, args[0])
- if user == nil {
- return telegramCommandReply{Text: "未找到用户。"}
- }
- s.applyRealtimeUserActivity(ctx, user)
- devices, _ := s.listUserDevices(ctx, user.ID)
- var historyCount int64
- _ = s.repo.DB.WithContext(ctx).Model(&model.PlaybackHistory{}).Where("user_id = ?", user.ID).Count(&historyCount).Error
- var binding model.TelegramBinding
- tg := "未绑定"
- if err := s.repo.DB.WithContext(ctx).Where("user_id = ?", user.ID).First(&binding).Error; err == nil {
- tg = fmt.Sprintf("tg:%d", binding.TelegramUserID)
- if binding.TelegramName != "" {
- tg += " " + binding.TelegramName
- }
- }
- return telegramCommandReply{Text: fmt.Sprintf(
- "用户信息\n\n用户名：%s\n角色：%s\n状态：%s\n到期：%s\nTelegram：%s\n设备：%d\n播放记录：%d\n最后登录：%s",
- user.Username, user.Role, activeLabel(user), formatExpiry(user.ExpiredAt), tg, len(devices), historyCount, formatOptionalTime(user.LastLoginAt),
- )}
-}
-
-func (s *TelegramBotService) applyRealtimeUserActivity(ctx context.Context, user *model.User) {
- if s == nil || user == nil || s.device == nil || s.device.sessions == nil {
- return
- }
- users := []model.User{*user}
- s.device.sessions.ApplyToUsers(ctx, users)
- *user = users[0]
-}
-
-func (s *TelegramBotService) cmdMgoDeleteUser(ctx context.Context, args []string) telegramCommandReply {
- if len(args) < 2 || !strings.EqualFold(args[len(args)-1], "confirm") {
- return telegramCommandReply{Text: "删除用户需要确认：/rmemby 用户名 confirm 或 /urm 用户名 confirm"}
- }
- user := s.findMgoBotUser(ctx, args[0])
- if user == nil {
- return telegramCommandReply{Text: "未找到用户。"}
- }
- if reason := s.protectReason(ctx, user.ID); reason != "" {
- return telegramCommandReply{Text: reason}
- }
- _ = s.repo.UserDevice.DeleteByUser(ctx, user.ID)
- if err := s.repo.User.Delete(ctx, user.ID); err != nil {
- return telegramCommandReply{Text: "删除失败：" + err.Error()}
- }
- return telegramCommandReply{Text: fmt.Sprintf("已删除用户 %s。", user.Username)}
-}
-
-func (s *TelegramBotService) cmdMgoOnlyRemoveRecord(ctx context.Context, args []string) telegramCommandReply {
- if len(args) == 0 {
- return telegramCommandReply{Text: "用法：/only_rm_record tg:123456 或 /only_rm_record 用户名，只删除 Telegram 绑定记录。"}
- }
- target := strings.TrimSpace(args[0])
- var removed int64
- if raw, ok := strings.CutPrefix(strings.ToLower(target), "tg:"); ok {
- tgID, err := strconv.ParseInt(raw, 10, 64)
- if err != nil || tgID == 0 {
- return telegramCommandReply{Text: "Telegram ID 无效。"}
- }
- removed, err = s.deleteTelegramBindings(ctx, "telegram_user_id = ?", tgID)
- if err != nil {
- return telegramCommandReply{Text: "删除绑定失败：" + err.Error()}
- }
- } else {
- user := s.findMgoBotUser(ctx, target)
- if user == nil {
- return telegramCommandReply{Text: "未找到用户。"}
- }
- n, err := s.deleteTelegramBindings(ctx, "user_id = ?", user.ID)
- if err != nil {
- return telegramCommandReply{Text: "删除绑定失败：" + err.Error()}
- }
- removed = n
- }
- return telegramCommandReply{Text: fmt.Sprintf("已删除 Telegram 绑定记录：%d 条。", removed)}
-}
-
-func (s *TelegramBotService) cmdMgoUserIP(ctx context.Context, args []string) telegramCommandReply {
- if len(args) == 0 {
- return telegramCommandReply{Text: "用法：/userip 用户名"}
- }
- user := s.findMgoBotUser(ctx, args[0])
- if user == nil {
- return telegramCommandReply{Text: "未找到用户。"}
- }
- devices, err := s.listUserDevices(ctx, user.ID)
- if err != nil {
- return telegramCommandReply{Text: "查询失败：" + err.Error()}
- }
- if len(devices) == 0 {
- return telegramCommandReply{Text: "该用户暂无设备/IP记录。"}
- }
- var out []string
- for i, d := range devices {
- if i >= 20 {
- break
- }
- out = append(out, fmt.Sprintf("%d. %s / %s / %s / %s", i+1, blankDash(d.LastIP), blankDash(d.DeviceName), blankDash(d.Client), d.LastSeenAt.Format("2006-01-02 15:04")))
- }
- return telegramCommandReply{Text: "" + user.Username + " 的设备/IP\n\n" + strings.Join(out, "\n") + ""}
-}
-
-func (s *TelegramBotService) cmdMgoAuditDevices(ctx context.Context, mode string, args []string) telegramCommandReply {
- if len(args) == 0 {
- return telegramCommandReply{Text: fmt.Sprintf("用法：/%s 关键词", mode)}
- }
- keyword := strings.TrimSpace(strings.Join(args, " "))
- var rows []struct {
- Username string
- DeviceID string
- DeviceName string
- Client string
- LastIP string
- LastSeenAt time.Time
- }
- q := s.repo.DB.WithContext(ctx).Table("user_devices").
- Select("users.username, user_devices.device_id, user_devices.device_name, user_devices.client, user_devices.last_ip, user_devices.last_seen_at").
- Joins("JOIN users ON users.id = user_devices.user_id").
- Order("user_devices.last_seen_at desc").
- Limit(20)
- switch mode {
- case "auditip":
- q = q.Where("user_devices.last_ip LIKE ?", "%"+keyword+"%")
- case "auditdevice":
- q = q.Where("user_devices.device_name LIKE ? OR user_devices.device_id LIKE ?", "%"+keyword+"%", "%"+keyword+"%")
- case "auditclient":
- q = q.Where("user_devices.client LIKE ?", "%"+keyword+"%")
- case "udeviceid":
- q = q.Where("user_devices.device_id LIKE ?", "%"+keyword+"%")
- }
- if err := q.Scan(&rows).Error; err != nil {
- return telegramCommandReply{Text: "查询失败：" + err.Error()}
- }
- if len(rows) == 0 {
- return telegramCommandReply{Text: "没有匹配记录。"}
- }
- var out []string
- for i, r := range rows {
- out = append(out, fmt.Sprintf("%d. %s / %s / %s / %s / %s", i+1, r.Username, blankDash(r.LastIP), blankDash(r.DeviceName), blankDash(r.Client), r.LastSeenAt.Format("2006-01-02 15:04")))
- }
- return telegramCommandReply{Text: "审计结果\n\n" + strings.Join(out, "\n") + ""}
-}
diff --git a/internal/service/telegram_polling.go b/internal/service/telegram_polling.go
deleted file mode 100644
index 399f1b3..0000000
--- a/internal/service/telegram_polling.go
+++ /dev/null
@@ -1,208 +0,0 @@
-package service
-
-import (
- "context"
- "encoding/json"
- "errors"
- "fmt"
- "io"
- "net/http"
- "strings"
- "time"
-
- "go.uber.org/zap"
-
- "github.com/ShukeBta/MediaStationGo/internal/model"
-)
-
-// TelegramPollingStartResult describes what happened when local long polling
-// was requested. The admin UI uses it to avoid a silent "started" toast when
-// no Telegram channel can actually poll.
-type TelegramPollingStartResult struct {
- Message string `json:"message"`
- Started int `json:"started"`
- AlreadyRunning int `json:"already_running"`
- Skipped int `json:"skipped"`
- Errors []string `json:"errors,omitempty"`
-}
-
-// StartPolling 为所有已启用的 Telegram 通知渠道启动长轮询。
-func (s *TelegramBotService) StartPolling(ctx context.Context) TelegramPollingStartResult {
- result := TelegramPollingStartResult{Message: "telegram polling started"}
- channels, err := s.repo.NotifyChannel.ListByType(ctx, "telegram")
- if err != nil {
- s.log.Error("failed to list telegram channels for polling", zap.Error(err))
- result.Message = "failed to list telegram channels"
- result.Errors = append(result.Errors, err.Error())
- return result
- }
- if len(channels) == 0 {
- result.Message = "no telegram channels configured"
- result.Errors = append(result.Errors, "没有配置 Telegram 通知渠道")
- return result
- }
-
- for _, ch := range channels {
- if !ch.Enabled {
- result.Skipped++
- result.Errors = append(result.Errors, ch.Name+": 通知渠道未启用")
- continue
- }
- configStr := ch.Config
- if s.crypto != nil && configStr != "" {
- configStr = s.crypto.Decrypt(configStr)
- }
- var rawCfg map[string]any
- if err := json.Unmarshal([]byte(configStr), &rawCfg); err != nil {
- result.Skipped++
- result.Errors = append(result.Errors, ch.Name+": Telegram 配置解析失败: "+err.Error())
- continue
- }
- cfg := telegramStringConfigFromAny(rawCfg)
- botToken := cfg["bot_token"]
- if botToken == "" {
- result.Skipped++
- result.Errors = append(result.Errors, ch.Name+": Telegram Bot Token 为空")
- continue
- }
- s.pollingMu.Lock()
- if _, running := s.pollingCancel[botToken]; running {
- s.pollingMu.Unlock()
- result.AlreadyRunning++
- continue
- }
- s.pollingMu.Unlock()
-
- if err := registerTelegramBotCommands(ctx, cfg); err != nil && s.log != nil {
- s.log.Warn("telegram setMyCommands failed", zap.Error(sanitizeTelegramError(err)))
- }
- if err := deleteTelegramWebhook(ctx, cfg); err != nil {
- result.Skipped++
- result.Errors = append(result.Errors, ch.Name+": "+sanitizeTelegramError(err).Error())
- continue
- }
-
- s.pollingMu.Lock()
- if _, running := s.pollingCancel[botToken]; running {
- s.pollingMu.Unlock()
- result.AlreadyRunning++
- continue
- }
- pollCtx, cancel := context.WithCancel(context.Background())
- s.pollingCancel[botToken] = cancel
- s.pollingMu.Unlock()
-
- channel := ch
- go s.pollLoop(pollCtx, cfg, &channel)
- result.Started++
- s.log.Info("started telegram polling", zap.String("channel", ch.Name))
- }
- if result.Started == 0 && result.AlreadyRunning == 0 {
- result.Message = "no enabled telegram channels started"
- }
- return result
-}
-
-// StopPolling 停止所有 Telegram 长轮询。
-func (s *TelegramBotService) StopPolling() int {
- s.pollingMu.Lock()
- defer s.pollingMu.Unlock()
- stopped := 0
- for token, cancel := range s.pollingCancel {
- cancel()
- delete(s.pollingCancel, token)
- stopped++
- }
- s.log.Info("telegram polling stopped")
- return stopped
-}
-
-// pollLoop 对单个 Bot Token 执行长轮询。
-func (s *TelegramBotService) pollLoop(ctx context.Context, cfg map[string]string, channel *model.NotifyChannel) {
- var offset int64 = 0
- pollURL, err := telegramMethodURL(cfg, cfg["bot_token"], "getUpdates")
- if err != nil {
- s.log.Warn("telegram polling config invalid", zap.Error(err))
- return
- }
- clients := telegramHTTPClients(45*time.Second, cfg)
-
- for {
- select {
- case <-ctx.Done():
- return
- default:
- }
-
- reqBody, _ := json.Marshal(map[string]interface{}{
- "offset": offset,
- "timeout": 30,
- })
- respBody, err := telegramPollingRequest(ctx, clients, pollURL, string(reqBody))
- if err != nil {
- s.log.Debug("telegram polling failed", zap.Error(err))
- time.Sleep(5 * time.Second)
- continue
- }
-
- var result struct {
- OK bool `json:"ok"`
- Result []TelegramUpdate `json:"result"`
- }
- if err := json.Unmarshal(respBody, &result); err != nil || !result.OK {
- time.Sleep(3 * time.Second)
- continue
- }
-
- for _, upd := range result.Result {
- if upd.UpdateID >= int(offset) {
- offset = int64(upd.UpdateID) + 1
- }
- if !telegramUpdateActionable(upd) {
- continue
- }
- go func(u TelegramUpdate) {
- handlerCtx, cancel := context.WithTimeout(ctx, 2*time.Minute)
- defer cancel()
- _ = s.handleTelegramUpdate(handlerCtx, u, channel)
- }(upd)
- }
- }
-}
-
-// telegramUpdateActionable 判断一条 update 是否需要分发处理。
-// 长轮询默认会返回 message 与 callback_query 两类更新；命令消息需有文本，
-// 而内联按钮回调（callback_query）必须被分发，否则成人目录显隐开关会失效。
-func telegramUpdateActionable(upd TelegramUpdate) bool {
- if upd.CallbackQuery != nil {
- return true
- }
- return upd.Message != nil && upd.Message.Text != ""
-}
-
-func telegramPollingRequest(ctx context.Context, clients []*http.Client, pollURL, body string) ([]byte, error) {
- var lastErr error
- for _, client := range clients {
- req, err := http.NewRequestWithContext(ctx, http.MethodPost, pollURL, strings.NewReader(body))
- if err != nil {
- return nil, err
- }
- req.Header.Set("Content-Type", "application/json")
- resp, err := client.Do(req)
- if err != nil {
- lastErr = sanitizeTelegramError(err)
- continue
- }
- respBody, _ := io.ReadAll(resp.Body)
- _ = resp.Body.Close()
- if resp.StatusCode >= 400 {
- lastErr = fmt.Errorf("telegram api error %d: %s", resp.StatusCode, sanitizeTelegramText(string(respBody)))
- continue
- }
- return respBody, nil
- }
- if lastErr != nil {
- return nil, lastErr
- }
- return nil, errors.New("telegram polling failed")
-}
diff --git a/internal/service/telegram_redeem.go b/internal/service/telegram_redeem.go
deleted file mode 100644
index dc9862f..0000000
--- a/internal/service/telegram_redeem.go
+++ /dev/null
@@ -1,185 +0,0 @@
-package service
-
-import (
- "context"
- "errors"
- "fmt"
- "strings"
- "time"
-
- "github.com/ShukeBta/MediaStationGo/internal/model"
- "gorm.io/gorm"
-)
-
-var (
- errRegistrationCodeAlreadyUsed = errors.New("registration code already used")
- errRegistrationCodeExpired = errors.New("registration code expired")
-)
-
-func (s *TelegramBotService) cmdRedeem(ctx context.Context, channel *model.NotifyChannel, msg *TelegramMessage, args []string) telegramCommandReply {
- if len(args) == 0 {
- return telegramCommandReply{Text: "请发送：/redeem 兑换码\n未绑定账号时自动尝试注册码；已绑定账号时自动尝试续期码。"}
- }
- code := strings.Join(args, " ")
- if s.boundUser(ctx, msg.From.ID) == nil {
- return s.redeemRegisterFlow(ctx, channel, msg, code)
- }
- return s.redeemRenewFlow(ctx, msg, code)
-}
-
-func (s *TelegramBotService) cmdRedeemRegister(ctx context.Context, channel *model.NotifyChannel, msg *TelegramMessage, args []string) telegramCommandReply {
- if len(args) == 0 {
- return telegramCommandReply{Text: "请发送：/redeem_register 注册兑换码"}
- }
- return s.redeemRegisterFlow(ctx, channel, msg, strings.Join(args, " "))
-}
-
-func (s *TelegramBotService) cmdRedeemRenew(ctx context.Context, msg *TelegramMessage, args []string) telegramCommandReply {
- if len(args) == 0 {
- return telegramCommandReply{Text: "请发送：/redeem_renew 续期兑换码"}
- }
- return s.redeemRenewFlow(ctx, msg, strings.Join(args, " "))
-}
-
-func (s *TelegramBotService) redeemRegisterFlow(ctx context.Context, channel *model.NotifyChannel, msg *TelegramMessage, raw string) telegramCommandReply {
- if channel == nil {
- channel = s.findChannelForMessage(ctx, msg)
- }
- if dec := s.telegramUserBindDecision(ctx, channel, msg.From.ID); dec != bindAllowed {
- return telegramCommandReply{Text: telegramBindRejectText(dec, "兑换注册账号")}
- }
- rc, errMsg := s.lookupRedeemableCode(ctx, raw, model.RegistrationCodeRegister)
- if rc == nil {
- return telegramCommandReply{Text: errMsg}
- }
- if s.auth == nil {
- return telegramCommandReply{Text: "注册服务暂不可用。"}
- }
- if binding := s.telegramBinding(ctx, msg.From.ID); binding != nil {
- if u, _ := s.repo.User.FindByID(ctx, binding.UserID); u != nil {
- return telegramCommandReply{Text: fmt.Sprintf("当前 Telegram 已绑定账号 %s，无需再用注册码。", u.Username)}
- }
- }
- user, password, claimedCode, err := s.createUserFromRegistrationCode(ctx, rc.Code)
- if err != nil {
- if errors.Is(err, errRegistrationCodeAlreadyUsed) {
- return telegramCommandReply{Text: "兑换码刚刚被使用，请换一个。"}
- }
- if errors.Is(err, errRegistrationCodeExpired) {
- return telegramCommandReply{Text: "兑换码已过期。"}
- }
- if errors.Is(err, ErrUserLimitReached) {
- return telegramCommandReply{Text: "注册失败：用户数量已达授权上限。"}
- }
- return telegramCommandReply{Text: "注册失败：" + err.Error()}
- }
- if claimedCode == nil {
- return telegramCommandReply{Text: "兑换码刚刚被使用，请换一个。"}
- }
- _ = s.upsertTelegramBinding(ctx, msg, user.ID)
- return telegramCommandReply{
- Text: fmt.Sprintf("兑换成功并已创建账号：\n用户名：%s\n密码：%s\n到期：%s\n\n请尽快用「改用户名/改密码」修改为你自己的凭据。",
- user.Username, password, formatExpiry(s.userExpiry(ctx, user.ID))),
- Buttons: [][]telegramInlineButton{{{Text: "⬅️ 返回菜单", Data: "menu_main"}}},
- }
-}
-
-func (s *TelegramBotService) createUserFromRegistrationCode(ctx context.Context, rawCode string) (*model.User, string, *model.RegistrationCode, error) {
- code := normalizeRedemptionCode(rawCode)
- if code == "" {
- return nil, "", nil, errRegistrationCodeAlreadyUsed
- }
- password := randomCode(10)
- var created model.User
- var claimed model.RegistrationCode
- err := s.repo.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
- if err := tx.Where("code = ? AND kind = ? AND used_at IS NULL AND used_count < CASE WHEN max_uses > 0 THEN max_uses ELSE 1 END", code, model.RegistrationCodeRegister).
- First(&claimed).Error; err != nil {
- if errors.Is(err, gorm.ErrRecordNotFound) {
- return errRegistrationCodeAlreadyUsed
- }
- return err
- }
- if claimed.IsExpired() {
- return errRegistrationCodeExpired
- }
- var count int64
- if err := tx.Model(&model.User{}).Count(&count).Error; err != nil {
- return err
- }
- if count >= LicensedMaxUsers(ctx, s.repo) {
- return ErrUserLimitReached
- }
- hash, err := hashPassword(password)
- if err != nil {
- return err
- }
- codePrefix := strings.ToLower(claimed.Code)
- if len(codePrefix) > 8 {
- codePrefix = codePrefix[:8]
- }
- created = model.User{
- Username: "u" + codePrefix,
- PasswordHash: hash,
- Role: "user",
- Tier: "free",
- HideAdult: true,
- ExpiredAt: renewExpiry(nil, claimed.DurationDays),
- }
- if err := tx.Create(&created).Error; err != nil {
- return err
- }
- if err := tx.Create(DefaultPermissions(created.ID)).Error; err != nil {
- return err
- }
- now := time.Now()
- res := tx.Model(&model.RegistrationCode{}).
- Where("id = ? AND used_at IS NULL AND used_count < CASE WHEN max_uses > 0 THEN max_uses ELSE 1 END", claimed.ID).
- Updates(map[string]any{
- "used_by_user_id": created.ID,
- "used_count": gorm.Expr("used_count + 1"),
- "used_at": gorm.Expr("CASE WHEN used_count + 1 >= CASE WHEN max_uses > 0 THEN max_uses ELSE 1 END THEN ? ELSE used_at END", now),
- })
- if res.Error != nil {
- return res.Error
- }
- if res.RowsAffected == 0 {
- return errRegistrationCodeAlreadyUsed
- }
- claimed.UsedByUserID = created.ID
- claimed.UsedCount++
- if claimed.UsedCount >= claimed.EffectiveMaxUses() {
- claimed.UsedAt = &now
- }
- return nil
- })
- if err != nil {
- return nil, "", nil, err
- }
- return &created, password, &claimed, nil
-}
-
-func (s *TelegramBotService) redeemRenewFlow(ctx context.Context, msg *TelegramMessage, raw string) telegramCommandReply {
- user := s.boundUser(ctx, msg.From.ID)
- if user == nil {
- return telegramCommandReply{Text: "请先绑定账号再续期。"}
- }
- rc, errMsg := s.lookupRedeemableCode(ctx, raw, model.RegistrationCodeRenew)
- if rc == nil {
- return telegramCommandReply{Text: errMsg}
- }
- if err := s.repo.RegCode.MarkUsed(ctx, rc.ID, user.ID); err != nil {
- return telegramCommandReply{Text: "兑换码刚刚被使用，请换一个。"}
- }
- if err := s.applyRenewal(ctx, user.ID, rc.DurationDays); err != nil {
- return telegramCommandReply{Text: "续期失败：" + err.Error()}
- }
- return telegramCommandReply{Text: fmt.Sprintf("续期成功 ✅ 当前到期：%s", formatExpiry(s.userExpiry(ctx, user.ID)))}
-}
-
-func (s *TelegramBotService) userExpiry(ctx context.Context, userID string) *time.Time {
- if u, _ := s.repo.User.FindByID(ctx, userID); u != nil {
- return u.ExpiredAt
- }
- return nil
-}
diff --git a/internal/service/telegram_reply.go b/internal/service/telegram_reply.go
deleted file mode 100644
index f710cd2..0000000
--- a/internal/service/telegram_reply.go
+++ /dev/null
@@ -1,127 +0,0 @@
-package service
-
-import (
- "context"
- "fmt"
- "strconv"
- "strings"
- "time"
-
- "go.uber.org/zap"
-
- "github.com/ShukeBta/MediaStationGo/internal/model"
-)
-
-const defaultTelegramMessageDeleteDelay = 120 * time.Second
-
-type telegramSendMessageResponse struct {
- OK bool `json:"ok"`
- Result struct {
- MessageID int `json:"message_id"`
- } `json:"result"`
-}
-
-// reply 通过 Telegram Bot API 发送回复消息。
-func (s *TelegramBotService) reply(ctx context.Context, channel *model.NotifyChannel, chatID int, reply telegramCommandReply) error {
- cfg := s.telegramChannelConfig(channel)
- if strings.TrimSpace(cfg["bot_token"]) == "" {
- return fmt.Errorf("bot_token not configured")
- }
-
- payload := map[string]interface{}{
- "chat_id": strconv.Itoa(chatID),
- "text": reply.Text,
- "parse_mode": "HTML",
- }
- if len(reply.Buttons) > 0 {
- keyboard := make([][]map[string]string, 0, len(reply.Buttons))
- for _, row := range reply.Buttons {
- buttons := make([]map[string]string, 0, len(row))
- for _, button := range row {
- buttons = append(buttons, map[string]string{
- "text": button.Text,
- "callback_data": button.Data,
- })
- }
- keyboard = append(keyboard, buttons)
- }
- payload["reply_markup"] = map[string]interface{}{"inline_keyboard": keyboard}
- }
- var sent telegramSendMessageResponse
- if err := telegramPostJSONDecode(ctx, cfg, "sendMessage", payload, 15*time.Second, &sent); err != nil {
- return err
- }
- if sent.Result.MessageID > 0 {
- s.scheduleTelegramMessageDelete(cfg, chatID, sent.Result.MessageID)
- }
- return nil
-}
-
-func (s *TelegramBotService) replyForMessage(ctx context.Context, channel *model.NotifyChannel, msg *TelegramMessage, reply telegramCommandReply) error {
- if msg == nil {
- return nil
- }
- if strings.TrimSpace(reply.Text) == "" {
- return nil
- }
- return s.reply(ctx, channel, msg.Chat.ID, reply)
-}
-
-func (s *TelegramBotService) deleteTelegramSourceMessage(channel *model.NotifyChannel, chatID, messageID int) {
- if messageID <= 0 {
- return
- }
- s.scheduleTelegramMessageDelete(s.telegramChannelConfig(channel), chatID, messageID)
-}
-
-func (s *TelegramBotService) scheduleTelegramMessageDelete(cfg map[string]string, chatID, messageID int) {
- if chatID == 0 || messageID <= 0 || strings.TrimSpace(cfg["bot_token"]) == "" {
- return
- }
- delay := telegramMessageDeleteDelay(cfg)
- if delay < 0 {
- return
- }
- cfgCopy := make(map[string]string, len(cfg))
- for k, v := range cfg {
- cfgCopy[k] = v
- }
- go func() {
- if delay > 0 {
- timer := time.NewTimer(delay)
- defer timer.Stop()
- <-timer.C
- }
- deleteCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
- defer cancel()
- err := telegramPostJSON(deleteCtx, cfgCopy, "deleteMessage", map[string]interface{}{
- "chat_id": strconv.Itoa(chatID),
- "message_id": messageID,
- }, 10*time.Second)
- if err != nil && s.log != nil {
- s.log.Debug("telegram deleteMessage failed",
- zap.Int("chat_id", chatID),
- zap.Int("message_id", messageID),
- zap.Error(sanitizeTelegramError(err)),
- )
- }
- }()
-}
-
-func telegramMessageDeleteDelay(cfg map[string]string) time.Duration {
- for _, key := range []string{"auto_delete_seconds", "message_delete_seconds", "delete_after_seconds"} {
- raw := strings.TrimSpace(cfg[key])
- if raw == "" {
- continue
- }
- seconds, err := strconv.Atoi(raw)
- if err != nil {
- continue
- }
- if seconds < 0 {
- return -1
- }
- return time.Duration(seconds) * time.Second
- }
- return defaultTelegramMessageDeleteDelay
-}
diff --git a/internal/service/telegram_stats.go b/internal/service/telegram_stats.go
deleted file mode 100644
index faf62b9..0000000
--- a/internal/service/telegram_stats.go
+++ /dev/null
@@ -1,224 +0,0 @@
-package service
-
-import (
- "context"
- "fmt"
- "strings"
-
- "gorm.io/gorm"
-
- "github.com/ShukeBta/MediaStationGo/internal/model"
-)
-
-// cmdStatus 处理 /status 命令。
-func (s *TelegramBotService) cmdStatus(ctx context.Context) (telegramCommandReply, error) {
- libraryIDs, err := s.activeTelegramStatsLibraryIDs(ctx)
- if err != nil {
- return telegramCommandReply{}, err
- }
- var mediaCount int64
- s.mediaStatsQuery(libraryIDs).Count(&mediaCount)
-
- var totalSize int64
- if err := s.mediaStatsQuery(libraryIDs).Select("COALESCE(SUM(size_bytes), 0)").Row().Scan(&totalSize); err != nil {
- return telegramCommandReply{}, err
- }
- totalSizeGB := float64(totalSize) / 1024 / 1024 / 1024
-
- return telegramCommandReply{Text: fmt.Sprintf(
- "系统运行状态\n\n"+
- "🎬 媒体总数: %d\n"+
- "💾 存储占用: %.1f GB",
- mediaCount, totalSizeGB,
- )}, nil
-}
-
-// cmdSearch 处理 /search 命令。
-func (s *TelegramBotService) cmdSearch(ctx context.Context, args []string) (telegramCommandReply, error) {
- if len(args) == 0 {
- return telegramCommandReply{Text: "请提供搜索关键词\n例: /search 哥斯拉"}, nil
- }
-
- keyword := strings.Join(args, " ")
- var results []model.Media
- err := s.repo.DB.Where("title LIKE ?", "%"+keyword+"%").
- Order("year DESC").Limit(8).
- Find(&results).Error
- if err != nil {
- return telegramCommandReply{}, err
- }
-
- if len(results) == 0 {
- return telegramCommandReply{Text: fmt.Sprintf("未找到与 %s 相关的媒体", keyword)}, nil
- }
-
- var sb strings.Builder
- sb.WriteString(fmt.Sprintf("搜索: %s\n\n", keyword))
- for i, m := range results {
- year := ""
- if m.Year > 0 {
- year = fmt.Sprintf(" (%d)", m.Year)
- }
- ep := ""
- if m.SeasonNum > 0 && m.EpisodeNum > 0 {
- ep = fmt.Sprintf(" S%02dE%02d", m.SeasonNum, m.EpisodeNum)
- }
- sb.WriteString(fmt.Sprintf("%d. %s%s%s — %s\n", i+1, m.Title, year, ep, formatSize(m.SizeBytes)))
- }
-
- return telegramCommandReply{Text: sb.String()}, nil
-}
-
-// cmdDownloads 处理 /downloads 命令。
-func (s *TelegramBotService) cmdDownloads(ctx context.Context) (telegramCommandReply, error) {
- type Row struct {
- Title string
- Status string
- }
- var rows []Row
- if err := s.repo.DB.Raw(
- "SELECT COALESCE(NULLIF(title,''),'下载任务') as title, COALESCE(status,'unknown') as status FROM download_tasks ORDER BY created_at DESC LIMIT 8",
- ).Scan(&rows).Error; err != nil {
- return telegramCommandReply{}, err
- }
-
- if len(rows) == 0 {
- return telegramCommandReply{Text: "当前没有下载任务。"}, nil
- }
-
- var sb strings.Builder
- sb.WriteString(fmt.Sprintf("下载任务 (%d)\n\n", len(rows)))
- for _, r := range rows {
- icon := "⏳"
- switch r.Status {
- case "completed":
- icon = "✅"
- case "downloading":
- icon = "📥"
- case "error":
- icon = "❌"
- }
- name := strings.TrimSpace(r.Title)
- if name == "" {
- name = "下载任务"
- }
- if len(name) > 60 {
- name = name[:57] + "..."
- }
- sb.WriteString(fmt.Sprintf("%s %s\n", icon, name))
- }
-
- return telegramCommandReply{Text: sb.String()}, nil
-}
-
-// cmdStats 处理 /stats 命令。
-func (s *TelegramBotService) cmdStats(ctx context.Context) (telegramCommandReply, error) {
- libs, err := s.activeTelegramStatsLibraries(ctx)
- if err != nil {
- return telegramCommandReply{}, err
- }
- libraryIDs := make([]string, 0, len(libs))
- for _, lib := range libs {
- libraryIDs = append(libraryIDs, lib.ID)
- }
- var totalMedia int64
- s.mediaStatsQuery(libraryIDs).Count(&totalMedia)
-
- var totalSize int64
- if err := s.mediaStatsQuery(libraryIDs).Select("COALESCE(SUM(size_bytes), 0)").Row().Scan(&totalSize); err != nil {
- return telegramCommandReply{}, err
- }
-
- type LibStat struct {
- Name string
- Type string
- Count int64
- }
- stats := make([]LibStat, 0, len(libs))
- for _, lib := range libs {
- var count int64
- if err := s.repo.DB.WithContext(ctx).Model(&model.Media{}).Where("library_id = ?", lib.ID).Count(&count).Error; err != nil {
- return telegramCommandReply{}, err
- }
- stats = append(stats, LibStat{Name: lib.Name, Type: lib.Type, Count: count})
- }
-
- var sb strings.Builder
- sb.WriteString("媒体库统计\n\n")
- sb.WriteString(fmt.Sprintf("📚 总数: %d\n", totalMedia))
- sb.WriteString(fmt.Sprintf("💾 大小: %s\n", formatSize(totalSize)))
-
- if len(stats) > 0 {
- sb.WriteString("\n各库分布:\n")
- for _, l := range stats {
- icon := "🎬"
- switch l.Type {
- case "tv":
- icon = "📺"
- case "anime":
- icon = "🍥"
- case "music":
- icon = "🎵"
- }
- sb.WriteString(fmt.Sprintf("%s %s: %d\n", icon, l.Name, l.Count))
- }
- }
-
- return telegramCommandReply{Text: sb.String()}, nil
-}
-
-func (s *TelegramBotService) activeTelegramStatsLibraries(ctx context.Context) ([]model.Library, error) {
- if s == nil || s.repo == nil || s.repo.Library == nil {
- return nil, nil
- }
- libs, err := s.repo.Library.List(ctx)
- if err != nil {
- return nil, err
- }
- libs = FilterDisplayCloudLibraries(ctx, s.repo, libs)
- out := libs[:0]
- for _, lib := range libs {
- if lib.Enabled {
- out = append(out, lib)
- }
- }
- return out, nil
-}
-
-func (s *TelegramBotService) activeTelegramStatsLibraryIDs(ctx context.Context) ([]string, error) {
- libs, err := s.activeTelegramStatsLibraries(ctx)
- if err != nil {
- return nil, err
- }
- ids := make([]string, 0, len(libs))
- for _, lib := range libs {
- ids = append(ids, lib.ID)
- }
- return ids, nil
-}
-
-func (s *TelegramBotService) mediaStatsQuery(libraryIDs []string) *gorm.DB {
- q := s.repo.DB.Model(&model.Media{})
- if len(libraryIDs) == 0 {
- return q.Where("1 = 0")
- }
- return q.Where("library_id IN ?", libraryIDs)
-}
-
-// formatSize 格式化字节数为可读字符串。
-func formatSize(bytes int64) string {
- if bytes <= 0 {
- return "0 B"
- }
- units := []string{"B", "KB", "MB", "GB", "TB"}
- v := float64(bytes)
- i := 0
- for v >= 1024 && i < len(units)-1 {
- v /= 1024
- i++
- }
- if i == 0 {
- return fmt.Sprintf("%.0f %s", v, units[i])
- }
- return fmt.Sprintf("%.1f %s", v, units[i])
-}
diff --git a/internal/service/telegram_unbind.go b/internal/service/telegram_unbind.go
deleted file mode 100644
index d496eee..0000000
--- a/internal/service/telegram_unbind.go
+++ /dev/null
@@ -1,224 +0,0 @@
-package service
-
-import (
- "context"
- "fmt"
- "strconv"
- "strings"
- "time"
-
- "github.com/ShukeBta/MediaStationGo/internal/model"
-)
-
-func (s *TelegramBotService) cmdUnbind(ctx context.Context, args []string) telegramCommandReply {
- targets := parseTelegramUnbindTargets(args)
- if len(targets) == 0 {
- return telegramCommandReply{Text: "用法：/unbind 用户名1 用户名2\n也支持逗号分隔，或使用 tg:TelegramID 按 Telegram ID 解绑。此命令只解绑 Bot，不删除媒体账号。"}
- }
- var removed int64
- var done []string
- var skipped []string
- var missing []string
- for _, target := range targets {
- if tgIDRaw, ok := strings.CutPrefix(strings.ToLower(target), "tg:"); ok {
- tgID, err := strconv.ParseInt(tgIDRaw, 10, 64)
- if err != nil || tgID == 0 {
- missing = append(missing, target)
- continue
- }
- n, err := s.deleteTelegramBindings(ctx, "telegram_user_id = ?", tgID)
- if err != nil {
- return telegramCommandReply{Text: "解绑失败：" + err.Error()}
- }
- if n == 0 {
- missing = append(missing, target)
- continue
- }
- removed += n
- done = append(done, target)
- continue
- }
-
- user, _ := s.repo.User.FindByUsername(ctx, target)
- if user == nil {
- user, _ = s.repo.User.FindByID(ctx, target)
- }
- if user == nil {
- missing = append(missing, target)
- continue
- }
- if user.Role == "admin" {
- skipped = append(skipped, user.Username+"(管理员)")
- continue
- }
- n, err := s.deleteTelegramBindings(ctx, "user_id = ?", user.ID)
- if err != nil {
- return telegramCommandReply{Text: "解绑失败：" + err.Error()}
- }
- if n == 0 {
- missing = append(missing, user.Username+"(未绑定)")
- continue
- }
- removed += n
- done = append(done, user.Username)
- }
- return formatUnbindResult("批量解绑完成", removed, done, skipped, missing)
-}
-
-func (s *TelegramBotService) cmdUnbindDuplicates(ctx context.Context) telegramCommandReply {
- if s == nil || s.repo == nil || s.repo.DB == nil {
- return telegramCommandReply{Text: "仓库不可用。"}
- }
- var bindings []model.TelegramBinding
- if err := s.repo.DB.WithContext(ctx).Order("updated_at desc, created_at desc").Find(&bindings).Error; err != nil {
- return telegramCommandReply{Text: "读取绑定失败：" + err.Error()}
- }
- seenTelegram := make(map[int64]string)
- seenUser := make(map[string]string)
- var removeIDs []string
- var removedLabels []string
- for _, binding := range bindings {
- remove := false
- if binding.UserID == "" || binding.TelegramUserID == 0 {
- remove = true
- } else if user, _ := s.repo.User.FindByID(ctx, binding.UserID); user == nil {
- remove = true
- } else if _, ok := seenTelegram[binding.TelegramUserID]; ok {
- remove = true
- } else if _, ok := seenUser[binding.UserID]; ok {
- remove = true
- }
- if remove {
- removeIDs = append(removeIDs, binding.ID)
- removedLabels = append(removedLabels, fmt.Sprintf("tg:%d", binding.TelegramUserID))
- continue
- }
- seenTelegram[binding.TelegramUserID] = binding.ID
- seenUser[binding.UserID] = binding.ID
- }
- if len(removeIDs) == 0 {
- return telegramCommandReply{Text: "未发现重复或无效绑定。"}
- }
- n, err := s.deleteTelegramBindings(ctx, "id IN ?", removeIDs)
- if err != nil {
- return telegramCommandReply{Text: "清理失败：" + err.Error()}
- }
- return formatUnbindResult("重复/无效绑定清理完成", n, removedLabels, nil, nil)
-}
-
-func (s *TelegramBotService) cmdUnbindInactive(ctx context.Context, args []string) telegramCommandReply {
- if len(args) == 0 {
- return telegramCommandReply{Text: "用法：/unbind_inactive 天数\n例如 /unbind_inactive 30 会解绑 30 天未登录的普通用户 Bot 绑定，不删除账号。"}
- }
- days, err := strconv.Atoi(strings.TrimSpace(args[0]))
- if err != nil || days < 1 {
- return telegramCommandReply{Text: "天数必须是大于 0 的整数。"}
- }
- users, err := s.repo.User.List(ctx)
- if err != nil {
- return telegramCommandReply{Text: "读取用户失败：" + err.Error()}
- }
- cutoff := time.Now().Add(-time.Duration(days) * 24 * time.Hour)
- recentWindow := time.Duration(days) * 24 * time.Hour
- var userIDs []string
- var done []string
- for _, user := range users {
- if user.Role == "admin" {
- continue
- }
- lastActive := user.CreatedAt
- if user.LastLoginAt != nil {
- lastActive = *user.LastLoginAt
- }
- if lastActive.IsZero() || lastActive.After(cutoff) {
- continue
- }
- if s.device != nil && s.device.UserRecentlyActive(ctx, user.ID, recentWindow) {
- continue
- }
- var count int64
- _ = s.repo.DB.WithContext(ctx).Model(&model.TelegramBinding{}).Where("user_id = ?", user.ID).Count(&count).Error
- if count == 0 {
- continue
- }
- userIDs = append(userIDs, user.ID)
- done = append(done, user.Username)
- }
- if len(userIDs) == 0 {
- return telegramCommandReply{Text: fmt.Sprintf("未发现 %d 天未登录且已绑定 Bot 的普通用户。", days)}
- }
- n, err := s.deleteTelegramBindings(ctx, "user_id IN ?", userIDs)
- if err != nil {
- return telegramCommandReply{Text: "解绑失败：" + err.Error()}
- }
- return formatUnbindResult(fmt.Sprintf("已解绑 %d 天未登录用户", days), n, done, nil, nil)
-}
-
-func parseTelegramUnbindTargets(args []string) []string {
- seen := make(map[string]struct{})
- var targets []string
- for _, arg := range args {
- for _, part := range strings.FieldsFunc(arg, func(r rune) bool {
- return r == ',' || r == '，' || r == ';' || r == '；' || r == '\n' || r == '\t'
- }) {
- part = strings.TrimSpace(part)
- if part == "" {
- continue
- }
- key := strings.ToLower(part)
- if _, ok := seen[key]; ok {
- continue
- }
- seen[key] = struct{}{}
- targets = append(targets, part)
- }
- }
- return targets
-}
-
-func (s *TelegramBotService) deleteTelegramBindings(ctx context.Context, query string, args ...interface{}) (int64, error) {
- if s == nil || s.repo == nil || s.repo.DB == nil {
- return 0, nil
- }
- tx := s.repo.DB.WithContext(ctx).Unscoped().Where(query, args...).Delete(&model.TelegramBinding{})
- return tx.RowsAffected, tx.Error
-}
-
-func formatUnbindResult(title string, removed int64, done, skipped, missing []string) telegramCommandReply {
- var sb strings.Builder
- sb.WriteString("")
- sb.WriteString(title)
- sb.WriteString("\n\n")
- sb.WriteString(fmt.Sprintf("已解绑：%d 条绑定", removed))
- if len(done) > 0 {
- sb.WriteString("\n目标：")
- sb.WriteString(formatShortList(done, 12))
- }
- if len(skipped) > 0 {
- sb.WriteString("\n跳过：")
- sb.WriteString(formatShortList(skipped, 8))
- }
- if len(missing) > 0 {
- sb.WriteString("\n未找到/未绑定：")
- sb.WriteString(formatShortList(missing, 8))
- }
- return telegramCommandReply{Text: sb.String()}
-}
-
-func formatShortList(items []string, limit int) string {
- if len(items) == 0 {
- return ""
- }
- if limit < 1 {
- limit = 1
- }
- out := items
- if len(out) > limit {
- out = out[:limit]
- }
- text := "" + strings.Join(out, "、") + ""
- if len(items) > limit {
- text += fmt.Sprintf(" 等 %d 项", len(items))
- }
- return text
-}
diff --git a/internal/service/telegram_user_self.go b/internal/service/telegram_user_self.go
deleted file mode 100644
index 3588129..0000000
--- a/internal/service/telegram_user_self.go
+++ /dev/null
@@ -1,241 +0,0 @@
-package service
-
-import (
- "context"
- "errors"
- "fmt"
- "strconv"
- "strings"
-
- "github.com/ShukeBta/MediaStationGo/internal/model"
-)
-
-func (s *TelegramBotService) cmdKick(ctx context.Context, msg *TelegramMessage, args []string) telegramCommandReply {
- user := s.boundUser(ctx, msg.From.ID)
- if user == nil {
- return telegramCommandReply{Text: "请先绑定账号：/start 用户名 密码"}
- }
- if len(args) == 0 {
- return telegramCommandReply{Text: "请指定要踢下线的设备：/kick all 或 /kick 设备编号。先用 /devices 查看编号。"}
- }
- target := strings.TrimSpace(args[0])
- if strings.EqualFold(target, "all") || target == "全部" {
- if s.device != nil {
- if err := s.device.KickAllDevices(ctx, user.ID); err != nil {
- return telegramCommandReply{Text: "踢下线失败：" + err.Error()}
- }
- } else if err := s.repo.UserDevice.SetKickedByUser(ctx, user.ID, true); err != nil {
- return telegramCommandReply{Text: "踢下线失败：" + err.Error()}
- }
- return telegramCommandReply{Text: "已踢下线此账号的全部设备。"}
- }
- devices, _ := s.listUserDevices(ctx, user.ID)
- if len(devices) == 0 {
- return telegramCommandReply{Text: "当前没有记录到登录设备。"}
- }
- var chosen *model.UserDevice
- if n, err := strconv.Atoi(target); err == nil && n >= 1 && n <= len(devices) {
- chosen = &devices[n-1]
- } else {
- for i := range devices {
- if devices[i].ID == target || devices[i].DeviceID == target {
- chosen = &devices[i]
- break
- }
- }
- }
- if chosen == nil {
- return telegramCommandReply{Text: "未找到该设备。请用 /devices 查看设备编号后重试。"}
- }
- if s.device != nil {
- if err := s.device.KickDevice(ctx, user.ID, chosen.DeviceID); err != nil {
- return telegramCommandReply{Text: "踢下线失败：" + err.Error()}
- }
- } else if fp := strings.TrimSpace(chosen.Fingerprint); fp != "" {
- if err := s.repo.UserDevice.SetKickedByFingerprint(ctx, user.ID, fp, true); err != nil {
- return telegramCommandReply{Text: "踢下线失败：" + err.Error()}
- }
- } else if err := s.repo.UserDevice.SetKicked(ctx, chosen.ID, true); err != nil {
- return telegramCommandReply{Text: "踢下线失败：" + err.Error()}
- }
- return telegramCommandReply{Text: fmt.Sprintf("已踢下线：%s。", deviceLabel(chosen.DeviceName, chosen.Client))}
-}
-
-func (s *TelegramBotService) cmdSetName(ctx context.Context, msg *TelegramMessage, args []string) telegramCommandReply {
- if len(args) < 2 {
- return telegramCommandReply{Text: "请发送：/setname 当前密码 新用户名"}
- }
- return s.selfSetName(ctx, msg, strings.Join(args, " "))
-}
-
-func (s *TelegramBotService) cmdSetPass(ctx context.Context, msg *TelegramMessage, args []string) telegramCommandReply {
- if len(args) < 2 {
- return telegramCommandReply{Text: "请发送：/setpass 当前密码 新密码"}
- }
- return s.selfSetPass(ctx, msg, strings.Join(args, " "))
-}
-
-func (s *TelegramBotService) replyAccount(ctx context.Context, msg *TelegramMessage) telegramCommandReply {
- user := s.boundUser(ctx, msg.From.ID)
- if user == nil {
- return telegramCommandReply{Text: "请先绑定账号：/start 用户名 密码"}
- }
- streak := 0
- if rec, _ := s.repo.SignIn.Get(ctx, user.ID); rec != nil {
- streak = rec.StreakDays
- }
- devices, _ := s.listUserDevices(ctx, user.ID)
- text := fmt.Sprintf("我的账号\n\n用户名：%s\n状态：%s\n到期：%s\n连续签到：%d 天\n登录设备：%d 台",
- user.Username,
- map[bool]string{true: "正常", false: "已禁用"}[user.IsActive],
- formatExpiry(user.ExpiredAt), streak, len(devices))
- return telegramCommandReply{Text: text, Buttons: [][]telegramInlineButton{{{Text: "⬅️ 返回菜单", Data: "menu_main"}}}}
-}
-
-func (s *TelegramBotService) replySignIn(ctx context.Context, msg *TelegramMessage) telegramCommandReply {
- user := s.boundUser(ctx, msg.From.ID)
- if user == nil {
- return telegramCommandReply{Text: "请先绑定账号后再签到。"}
- }
- res, err := s.signIn(ctx, user.ID)
- if err != nil {
- return telegramCommandReply{Text: "签到失败：" + err.Error()}
- }
- if res.AlreadySigned {
- return telegramCommandReply{Text: fmt.Sprintf("今天已经签到过啦～\n连续签到 %d 天，累计 %d 天。", res.Streak, res.Total)}
- }
- return telegramCommandReply{Text: fmt.Sprintf("签到成功 ✅\n连续签到 %d 天，累计 %d 天。", res.Streak, res.Total)}
-}
-
-func (s *TelegramBotService) replyDevices(ctx context.Context, msg *TelegramMessage) telegramCommandReply {
- user := s.boundUser(ctx, msg.From.ID)
- if user == nil {
- return telegramCommandReply{Text: "请先绑定账号。"}
- }
- devices, _ := s.listUserDevices(ctx, user.ID)
- if len(devices) == 0 {
- return telegramCommandReply{Text: "当前没有记录到登录设备。"}
- }
- var sb strings.Builder
- sb.WriteString("我的登录设备\n点击下方按钮可一键踢下线：\n")
- var rows [][]telegramInlineButton
- for i, d := range devices {
- status := ""
- if d.Kicked {
- status = "（已踢下线）"
- } else if d.Playing {
- status = "（播放中）"
- } else if d.Online {
- status = "（在线）"
- }
- sb.WriteString(fmt.Sprintf("\n%d. %s%s\n 最近活跃：%s", i+1, deviceLabel(d.DeviceName, d.Client), status, d.LastSeenAt.Format("01-02 15:04")))
- if !d.Kicked && !strings.HasPrefix(d.ID, "rt:") {
- rows = append(rows, []telegramInlineButton{{Text: "🚫 踢下线：" + deviceLabel(d.DeviceName, d.Client), Data: "kick:" + d.ID}})
- }
- }
- rows = append(rows, []telegramInlineButton{{Text: "⬅️ 返回菜单", Data: "menu_main"}})
- return telegramCommandReply{Text: sb.String(), Buttons: rows}
-}
-
-func (s *TelegramBotService) replyKick(ctx context.Context, msg *TelegramMessage, deviceRowID string) telegramCommandReply {
- user := s.boundUser(ctx, msg.From.ID)
- if user == nil {
- return telegramCommandReply{Text: "请先绑定账号。"}
- }
- var d model.UserDevice
- if err := s.repo.DB.WithContext(ctx).Where("id = ? AND user_id = ?", deviceRowID, user.ID).First(&d).Error; err != nil {
- return telegramCommandReply{Text: "未找到该设备。"}
- }
- if s.device != nil {
- if err := s.device.KickDevice(ctx, user.ID, d.DeviceID); err != nil {
- return telegramCommandReply{Text: "操作失败：" + err.Error()}
- }
- } else if fp := strings.TrimSpace(d.Fingerprint); fp != "" {
- if err := s.repo.UserDevice.SetKickedByFingerprint(ctx, user.ID, fp, true); err != nil {
- return telegramCommandReply{Text: "操作失败：" + err.Error()}
- }
- } else if err := s.repo.UserDevice.SetKicked(ctx, d.ID, true); err != nil {
- return telegramCommandReply{Text: "操作失败：" + err.Error()}
- }
- return s.replyDevices(ctx, msg)
-}
-
-func (s *TelegramBotService) listUserDevices(ctx context.Context, userID string) ([]model.UserDevice, error) {
- if s.device != nil {
- return s.device.ListDevices(ctx, userID)
- }
- return s.repo.UserDevice.ListByUser(ctx, userID)
-}
-
-func (s *TelegramBotService) selfSetName(ctx context.Context, msg *TelegramMessage, input string) telegramCommandReply {
- user := s.boundUser(ctx, msg.From.ID)
- if user == nil {
- return telegramCommandReply{Text: "请先绑定账号。"}
- }
- currentPassword, newName := splitCurrentPasswordAndValue(input)
- if currentPassword == "" || newName == "" {
- return telegramCommandReply{Text: "请发送：当前密码 新用户名。"}
- }
- newName = strings.TrimSpace(newName)
- if len(newName) < 2 || strings.ContainsAny(newName, " \t\n") {
- return telegramCommandReply{Text: "用户名至少 2 位且不能含空格，请重试。"}
- }
- if reply, ok := s.verifyTelegramSelfPassword(ctx, msg, user, currentPassword); !ok {
- return reply
- }
- if existing, _ := s.repo.User.FindByUsername(ctx, newName); existing != nil && existing.ID != user.ID {
- return telegramCommandReply{Text: "该用户名已被占用，请换一个。"}
- }
- if err := s.repo.User.UpdateFields(ctx, user.ID, map[string]any{"username": newName}); err != nil {
- return telegramCommandReply{Text: "修改失败：" + err.Error()}
- }
- return telegramCommandReply{Text: fmt.Sprintf("用户名已修改为 %s。请用新用户名登录。", newName)}
-}
-
-func (s *TelegramBotService) selfSetPass(ctx context.Context, msg *TelegramMessage, input string) telegramCommandReply {
- user := s.boundUser(ctx, msg.From.ID)
- if user == nil {
- return telegramCommandReply{Text: "请先绑定账号。"}
- }
- currentPassword, newPass := splitCurrentPasswordAndValue(input)
- if currentPassword == "" || newPass == "" {
- return telegramCommandReply{Text: "请发送：当前密码 新密码。"}
- }
- newPass = strings.TrimSpace(newPass)
- if s.auth == nil {
- return telegramCommandReply{Text: "服务暂不可用。"}
- }
- if err := s.auth.ChangePassword(ctx, user.ID, currentPassword, newPass); err != nil {
- if errors.Is(err, ErrInvalidCredentials) {
- _ = s.unbindTelegramUser(ctx, msg.From.ID)
- return telegramCommandReply{Text: "当前密码验证失败，绑定已自动解绑。请用新密码重新绑定账号。"}
- }
- return telegramCommandReply{Text: "修改失败：" + err.Error()}
- }
- if s.device != nil {
- _ = s.device.KickAllDevices(ctx, user.ID)
- }
- return telegramCommandReply{Text: "密码已修改，请用新密码重新登录第三方客户端。"}
-}
-
-func splitCurrentPasswordAndValue(input string) (string, string) {
- fields := strings.Fields(strings.TrimSpace(input))
- if len(fields) < 2 {
- return "", ""
- }
- return fields[0], strings.TrimSpace(strings.Join(fields[1:], " "))
-}
-
-func (s *TelegramBotService) verifyTelegramSelfPassword(ctx context.Context, msg *TelegramMessage, user *model.User, currentPassword string) (telegramCommandReply, bool) {
- if s.auth == nil {
- return telegramCommandReply{Text: "服务暂不可用。"}, false
- }
- if err := s.auth.VerifyPassword(ctx, user.ID, currentPassword); err != nil {
- if errors.Is(err, ErrInvalidCredentials) {
- _ = s.unbindTelegramUser(ctx, msg.From.ID)
- return telegramCommandReply{Text: "当前密码验证失败，绑定已自动解绑。请用新密码重新绑定账号。"}, false
- }
- return telegramCommandReply{Text: "验证失败：" + err.Error()}, false
- }
- return telegramCommandReply{}, true
-}
diff --git a/internal/service/telegram_webhook_admin.go b/internal/service/telegram_webhook_admin.go
deleted file mode 100644
index c3a70da..0000000
--- a/internal/service/telegram_webhook_admin.go
+++ /dev/null
@@ -1,31 +0,0 @@
-package service
-
-import (
- "context"
- "time"
-
- "go.uber.org/zap"
-)
-
-// SetWebhook 注册 Telegram Bot Webhook URL。
-func (s *TelegramBotService) SetWebhook(ctx context.Context, botToken, webhookURL string) error {
- cfg := map[string]string{"bot_token": botToken}
- if err := registerTelegramBotCommands(ctx, cfg); err != nil && s.log != nil {
- s.log.Warn("telegram setMyCommands failed", zap.Error(sanitizeTelegramError(err)))
- }
- payload := map[string]interface{}{
- "url": webhookURL,
- "allowed_updates": []string{"message", "callback_query"},
- }
- return telegramPostJSON(ctx, cfg, "setWebhook", payload, 15*time.Second)
-}
-
-// GetWebhookInfo 获取 Webhook 配置信息。
-func (s *TelegramBotService) GetWebhookInfo(ctx context.Context, botToken string) (map[string]interface{}, error) {
- cfg := map[string]string{"bot_token": botToken}
- var result map[string]interface{}
- if err := telegramGetJSONDecode(ctx, cfg, "getWebhookInfo", 10*time.Second, &result); err != nil {
- return nil, err
- }
- return result, nil
-}
diff --git a/internal/service/transmission_adp.go b/internal/service/transmission_adp.go
deleted file mode 100644
index b609d5b..0000000
--- a/internal/service/transmission_adp.go
+++ /dev/null
@@ -1,220 +0,0 @@
-// Package service — Transmission 下载适配器。
-//
-// TransmissionAdapter 实现了 DownloadAdapter 接口，通过 Transmission RPC API
-// 管理下载任务。
-package service
-
-import (
- "context"
- "encoding/base64"
- "fmt"
- "net/http"
- "strings"
- "sync"
- "time"
-)
-
-// TransmissionAdapter 是 Transmission 的 DownloadAdapter 实现。
-type TransmissionAdapter struct {
- mu sync.Mutex
- cfg DownloadClientConfig
- client *http.Client
- tag int
- sessionID string
-}
-
-// NewTransmissionAdapter 创建新的 Transmission 适配器。
-func NewTransmissionAdapter() *TransmissionAdapter {
- return &TransmissionAdapter{
- client: NewInternalHTTPClient(20 * time.Second),
- }
-}
-
-// AddTorrent 通过 URL 添加种子。
-func (a *TransmissionAdapter) AddTorrent(ctx context.Context, torrentURL, savePath string) (string, error) {
- a.mu.Lock()
- defer a.mu.Unlock()
- args := map[string]interface{}{"filename": torrentURL}
- return a.addTorrentLocked(ctx, args, savePath)
-}
-
-// AddTorrentFile submits application-fetched .torrent bytes through
-// Transmission's base64 metainfo field. This keeps private tracker cookies and
-// signed URLs inside MediaStationGo instead of asking Transmission to refetch.
-func (a *TransmissionAdapter) AddTorrentFile(ctx context.Context, data []byte, _ string, savePath string) (string, error) {
- a.mu.Lock()
- defer a.mu.Unlock()
- args := map[string]interface{}{"metainfo": base64.StdEncoding.EncodeToString(data)}
- return a.addTorrentLocked(ctx, args, savePath)
-}
-
-func (a *TransmissionAdapter) addTorrentLocked(ctx context.Context, args map[string]interface{}, savePath string) (string, error) {
- if savePath != "" {
- args["download-dir"] = savePath
- }
- resp, err := a.rpcLocked(ctx, "torrent-add", args)
- if err != nil {
- return "", err
- }
- if added, ok := resp.Arguments["torrent-added"].(map[string]interface{}); ok {
- if hashStr, ok := added["hashString"].(string); ok {
- return hashStr, nil
- }
- }
- if dup, ok := resp.Arguments["torrent-duplicate"].(map[string]interface{}); ok {
- if hashStr, ok := dup["hashString"].(string); ok {
- return hashStr, nil
- }
- }
- return "", nil
-}
-
-// AddMagnet 通过磁力链接添加种子。
-func (a *TransmissionAdapter) AddMagnet(ctx context.Context, magnet, savePath string) (string, error) {
- return a.AddTorrent(ctx, magnet, savePath)
-}
-
-// Pause 暂停种子。
-func (a *TransmissionAdapter) Pause(ctx context.Context, hash string) error {
- a.mu.Lock()
- defer a.mu.Unlock()
- _, err := a.rpcLocked(ctx, "torrent-stop", map[string]interface{}{
- "ids": []string{hash},
- })
- return err
-}
-
-// Resume 恢复种子。
-func (a *TransmissionAdapter) Resume(ctx context.Context, hash string) error {
- a.mu.Lock()
- defer a.mu.Unlock()
- _, err := a.rpcLocked(ctx, "torrent-start", map[string]interface{}{
- "ids": []string{hash},
- })
- return err
-}
-
-// Remove 删除种子。
-func (a *TransmissionAdapter) Remove(ctx context.Context, hash string, deleteFiles bool) error {
- a.mu.Lock()
- defer a.mu.Unlock()
- _, err := a.rpcLocked(ctx, "torrent-remove", map[string]interface{}{
- "ids": []string{hash},
- "delete-local-data": deleteFiles,
- })
- return err
-}
-
-// List 列出种子。
-func (a *TransmissionAdapter) List(ctx context.Context, filter string) ([]TorrentInfo, error) {
- a.mu.Lock()
- defer a.mu.Unlock()
- args := map[string]interface{}{
- "fields": []string{
- "hashString", "name", "totalSize", "percentDone",
- "rateDownload", "rateUpload", "status", "downloadDir",
- "peersSendingToUs", "peersGettingFromUs", "addedDate",
- "doneDate", "labels", "isStalled",
- },
- }
- resp, err := a.rpcLocked(ctx, "torrent-get", args)
- if err != nil {
- return nil, err
- }
-
- torrentsRaw, ok := resp.Arguments["torrents"].([]interface{})
- if !ok {
- return nil, nil
- }
-
- result := make([]TorrentInfo, 0, len(torrentsRaw))
- for _, tr := range torrentsRaw {
- t, ok := tr.(map[string]interface{})
- if !ok {
- continue
- }
-
- hash, _ := t["hashString"].(string)
- name, _ := t["name"].(string)
- size := toInt64(t["totalSize"])
- progress := toFloat64(t["percentDone"])
- dlSpeed := toInt64(t["rateDownload"])
- upSpeed := toInt64(t["rateUpload"])
- savePath, _ := t["downloadDir"].(string)
- numSeeds := int(toInt64(t["peersSendingToUs"]))
- numLeechs := int(toInt64(t["peersGettingFromUs"]))
- addedOn := int64(toFloat64(t["addedDate"]))
-
- // Transmission 状态码转字符串
- status := int(toFloat64(t["status"]))
- state := canonicalTorrentState(transmissionStateStr(status), progress)
-
- // 过滤
- if filter != "" && !strings.EqualFold(state, filter) {
- continue
- }
-
- result = append(result, TorrentInfo{
- Hash: hash,
- Name: name,
- Size: size,
- Progress: normalizedTorrentProgress(progress),
- DLSpeed: dlSpeed,
- UPSpeed: upSpeed,
- State: state,
- SavePath: savePath,
- NumSeeds: numSeeds,
- NumLeechs: numLeechs,
- AddedOn: time.Unix(addedOn, 0),
- Tags: toJSONLabels(t["labels"]),
- ContentPath: downloaderPayloadPath(savePath, name),
- CompletionOn: toInt64(t["doneDate"]),
- })
- }
- return result, nil
-}
-
-// GetInfo 获取单个种子信息。
-func (a *TransmissionAdapter) GetInfo(ctx context.Context, hash string) (*TorrentInfo, error) {
- a.mu.Lock()
- defer a.mu.Unlock()
- args := map[string]interface{}{
- "ids": []string{hash},
- "fields": []string{
- "hashString", "name", "totalSize", "percentDone",
- "rateDownload", "rateUpload", "status", "downloadDir",
- "peersSendingToUs", "peersGettingFromUs", "addedDate", "doneDate", "labels",
- },
- }
- resp, err := a.rpcLocked(ctx, "torrent-get", args)
- if err != nil {
- return nil, err
- }
- torrentsRaw, ok := resp.Arguments["torrents"].([]interface{})
- if !ok || len(torrentsRaw) == 0 {
- return nil, fmt.Errorf("torrent %s not found", hash)
- }
- t, ok := torrentsRaw[0].(map[string]interface{})
- if !ok {
- return nil, fmt.Errorf("torrent %s: invalid response", hash)
- }
-
- status := int(toFloat64(t["status"]))
- info := &TorrentInfo{
- Hash: hash,
- Name: strVal(t["name"]),
- Size: toInt64(t["totalSize"]),
- Progress: normalizedTorrentProgress(toFloat64(t["percentDone"])),
- DLSpeed: toInt64(t["rateDownload"]),
- UPSpeed: toInt64(t["rateUpload"]),
- State: canonicalTorrentState(transmissionStateStr(status), toFloat64(t["percentDone"])),
- SavePath: strVal(t["downloadDir"]),
- NumSeeds: int(toInt64(t["peersSendingToUs"])),
- NumLeechs: int(toInt64(t["peersGettingFromUs"])),
- AddedOn: time.Unix(int64(toFloat64(t["addedDate"])), 0),
- Tags: toJSONLabels(t["labels"]),
- ContentPath: downloaderPayloadPath(strVal(t["downloadDir"]), strVal(t["name"])),
- CompletionOn: toInt64(t["doneDate"]),
- }
- return info, nil
-}
diff --git a/internal/service/transmission_parse.go b/internal/service/transmission_parse.go
deleted file mode 100644
index d8a4c63..0000000
--- a/internal/service/transmission_parse.go
+++ /dev/null
@@ -1,100 +0,0 @@
-package service
-
-import (
- "encoding/json"
- "fmt"
- "strconv"
- "strings"
-)
-
-// transmissionStateStr 将 Transmission 状态码转为可读字符串。
-func transmissionStateStr(status int) string {
- switch status {
- case 0:
- return "stopped"
- case 1:
- return "check_pending"
- case 2:
- return "checking"
- case 3:
- return "download_pending"
- case 4:
- return "downloading"
- case 5:
- return "seed_pending"
- case 6:
- return "seeding"
- default:
- return "unknown"
- }
-}
-
-// toInt64 安全地将 interface{} 转为 int64。
-func toInt64(v interface{}) int64 {
- switch val := v.(type) {
- case float64:
- return int64(val)
- case int:
- return int64(val)
- case int64:
- return val
- case json.Number:
- n, _ := val.Int64()
- return n
- case string:
- n, _ := strconv.ParseInt(val, 10, 64)
- return n
- default:
- return 0
- }
-}
-
-// toFloat64 安全地将 interface{} 转为 float64。
-func toFloat64(v interface{}) float64 {
- switch val := v.(type) {
- case float64:
- return val
- case int:
- return float64(val)
- case int64:
- return float64(val)
- case json.Number:
- n, _ := val.Float64()
- return n
- case string:
- n, _ := strconv.ParseFloat(val, 64)
- return n
- default:
- return 0
- }
-}
-
-// strVal 安全地提取字符串。
-func strVal(v interface{}) string {
- if v == nil {
- return ""
- }
- s, ok := v.(string)
- if ok {
- return s
- }
- return fmt.Sprintf("%v", v)
-}
-
-// toJSONLabels 将 Transmission labels 转为逗号分隔字符串。
-func toJSONLabels(v interface{}) string {
- if v == nil {
- return ""
- }
- arr, ok := v.([]interface{})
- if !ok {
- return ""
- }
- labels := make([]string, 0, len(arr))
- for _, item := range arr {
- if s, ok := item.(string); ok {
- labels = append(labels, s)
- }
- }
- return strings.Join(labels, ",")
-}
diff --git a/internal/service/transmission_rpc.go b/internal/service/transmission_rpc.go
deleted file mode 100644
index f17cbb1..0000000
--- a/internal/service/transmission_rpc.go
+++ /dev/null
@@ -1,141 +0,0 @@
-package service
-
-import (
- "bytes"
- "context"
- "encoding/json"
- "fmt"
- "io"
- "net/http"
-)
-
-// transmissionRPCRequest 是 Transmission RPC 请求的通用结构。
-type transmissionRPCRequest struct {
- Method string `json:"method"`
- Arguments map[string]interface{} `json:"arguments"`
- Tag int `json:"tag,omitempty"`
-}
-
-// transmissionRPCResponse 是 Transmission RPC 响应的通用结构。
-type transmissionRPCResponse struct {
- Result string `json:"result"`
- Arguments map[string]interface{} `json:"arguments"`
- Tag int `json:"tag"`
-}
-
-// Initialize 配置并初始化 Transmission RPC 连接。
-func (a *TransmissionAdapter) Initialize(ctx context.Context, cfg DownloadClientConfig) error {
- a.mu.Lock()
- defer a.mu.Unlock()
- endpoint, err := normalizeDownloadClientEndpoint("transmission", cfg.Host)
- if err != nil {
- return err
- }
- cfg.Host = endpoint
- a.cfg = cfg
- a.sessionID = ""
- a.tag = 0
- return a.pingLocked(ctx)
-}
-
-// Ping 测试连接。
-func (a *TransmissionAdapter) Ping(ctx context.Context) error {
- a.mu.Lock()
- defer a.mu.Unlock()
- return a.pingLocked(ctx)
-}
-
-// pingLocked 内部 ping 实现（调用者必须持有锁）。
-func (a *TransmissionAdapter) pingLocked(ctx context.Context) error {
- rpcURL, err := downloadClientRPCURL("transmission", a.cfg.Host)
- if err != nil {
- return err
- }
- req, err := newDownloadClientHTTPRequest(ctx, http.MethodGet, rpcURL, nil)
- if err != nil {
- return err
- }
- if a.cfg.Username != "" {
- req.SetBasicAuth(a.cfg.Username, a.cfg.Password)
- }
- resp, err := a.client.Do(req)
- if err != nil {
- return err
- }
- defer resp.Body.Close()
- _, _ = io.Copy(io.Discard, resp.Body)
- if resp.StatusCode == 409 {
- // 正常：需要 CSRF token
- a.sessionID = resp.Header.Get("X-Transmission-Session-Id")
- return nil
- }
- if resp.StatusCode >= 400 {
- return fmt.Errorf("transmission rpc: %d", resp.StatusCode)
- }
- return nil
-}
-
-// rpcLocked 发送 RPC 请求（调用者必须持有锁）。
-func (a *TransmissionAdapter) rpcLocked(ctx context.Context, method string, args map[string]interface{}) (*transmissionRPCResponse, error) {
- rpcURL, err := downloadClientRPCURL("transmission", a.cfg.Host)
- if err != nil {
- return nil, err
- }
-
- a.tag++
- body, err := json.Marshal(transmissionRPCRequest{
- Method: method,
- Arguments: args,
- Tag: a.tag,
- })
- if err != nil {
- return nil, err
- }
-
- for attempt := 0; attempt < 2; attempt++ {
- res, retry, err := func() (*transmissionRPCResponse, bool, error) {
- req, err := newDownloadClientHTTPRequest(ctx, http.MethodPost, rpcURL, bytes.NewReader(body))
- if err != nil {
- return nil, false, err
- }
- req.Header.Set("Content-Type", "application/json")
- if a.sessionID != "" {
- req.Header.Set("X-Transmission-Session-Id", a.sessionID)
- }
- if a.cfg.Username != "" {
- req.SetBasicAuth(a.cfg.Username, a.cfg.Password)
- }
-
- resp, err := a.client.Do(req)
- if err != nil {
- return nil, false, err
- }
- defer resp.Body.Close()
-
- if resp.StatusCode == 409 {
- a.sessionID = resp.Header.Get("X-Transmission-Session-Id")
- return nil, true, nil
- }
- if resp.StatusCode >= 400 {
- raw, _ := io.ReadAll(resp.Body)
- return nil, false, fmt.Errorf("transmission rpc error: %d: %s", resp.StatusCode, string(raw))
- }
-
- var result transmissionRPCResponse
- if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
- return nil, false, err
- }
- if result.Result != "success" {
- return nil, false, fmt.Errorf("transmission rpc result: %s", result.Result)
- }
- return &result, false, nil
- }()
- if err != nil {
- return nil, err
- }
- if !retry {
- return res, nil
- }
- }
- return nil, fmt.Errorf("transmission: failed after CSRF retry")
-}
diff --git a/internal/service/watcher.go b/internal/service/watcher.go
index 7a37bfc..47cc4cd 100644
--- a/internal/service/watcher.go
+++ b/internal/service/watcher.go
@@ -108,9 +108,6 @@ func (w *WatcherService) Refresh(ctx context.Context) error {
if !root.Enabled {
continue
}
- if _, _, ok := parseCloudLibraryPath(root.Path); ok {
- continue
- }
watchRoot, info, err := resolveAccessibleMappedPath(root.Path)
if err != nil || !info.IsDir() {
w.log.Warn("watch path inaccessible",
diff --git a/web/index.html b/web/index.html
index ce08c73..948f2b0 100644
--- a/web/index.html
+++ b/web/index.html
@@ -4,16 +4,17 @@
-
-
-
+
+
+
+
-