819 lines
25 KiB
Go
819 lines
25 KiB
Go
package files
|
||
|
||
import (
|
||
"context"
|
||
"encoding/hex"
|
||
"encoding/json"
|
||
"fmt"
|
||
"os"
|
||
"path/filepath"
|
||
"regexp"
|
||
"sort"
|
||
"strconv"
|
||
"strings"
|
||
"time"
|
||
|
||
"telesrv/internal/domain"
|
||
)
|
||
|
||
// 本文件实现从外部导出的 reaction / sticker 资源目录导入媒体种子：
|
||
// JSON 元数据（外部导出 document id/access_hash/file_reference/attributes/thumbs）落 documents /
|
||
// sticker_sets / available_reactions 表，二进制 .tgs/.webp/缩略图落 blob backend。
|
||
// dc_id 统一重写为本 server 的 DC，使客户端从本 DC 下载。导入幂等（已存在则跳过）。
|
||
|
||
// SeedStats 汇报一次种子导入结果。
|
||
type SeedStats struct {
|
||
Reactions int
|
||
StickerSets int
|
||
Documents int
|
||
Blobs int
|
||
Skipped bool
|
||
}
|
||
|
||
// SeedMedia 从导出根目录导入 reaction 与 sticker 资源。maxRegularSets<=0 表示不限。
|
||
func (s *Service) SeedMedia(ctx context.Context, root string, maxRegularSets int) (SeedStats, error) {
|
||
var stats SeedStats
|
||
if root == "" {
|
||
stats.Skipped = true
|
||
return stats, nil
|
||
}
|
||
if _, err := os.Stat(root); err != nil {
|
||
// 目录不存在：跳过而非失败（开发机可能未放资源）。
|
||
stats.Skipped = true
|
||
return stats, nil
|
||
}
|
||
|
||
// reactions
|
||
if n, err := s.media.CountAvailableReactions(ctx); err != nil {
|
||
return stats, err
|
||
} else if n == 0 {
|
||
if err := s.seedReactions(ctx, root, &stats); err != nil {
|
||
return stats, fmt.Errorf("seed reactions: %w", err)
|
||
}
|
||
} else if incomplete, err := s.availableReactionSeedNeedsRepair(ctx); err != nil {
|
||
return stats, err
|
||
} else if incomplete {
|
||
if err := s.seedReactions(ctx, root, &stats); err != nil {
|
||
return stats, fmt.Errorf("repair reactions: %w", err)
|
||
}
|
||
}
|
||
|
||
// sticker sets（default 系统集 + 常规集）
|
||
if n, err := s.media.CountStickerSets(ctx); err != nil {
|
||
return stats, err
|
||
} else if n == 0 {
|
||
if err := s.seedStickerSets(ctx, root, maxRegularSets, &stats); err != nil {
|
||
return stats, fmt.Errorf("seed sticker sets: %w", err)
|
||
}
|
||
} else if stale, err := s.stickerSetDocumentThumbsNeedInlineCache(ctx); err != nil {
|
||
return stats, err
|
||
} else if stale {
|
||
if err := s.seedStickerSets(ctx, root, maxRegularSets, &stats); err != nil {
|
||
return stats, fmt.Errorf("repair sticker set thumbs: %w", err)
|
||
}
|
||
}
|
||
|
||
if stats.Reactions == 0 && stats.StickerSets == 0 {
|
||
stats.Skipped = true
|
||
}
|
||
return stats, nil
|
||
}
|
||
|
||
// ---- reactions ----
|
||
|
||
func (s *Service) seedReactions(ctx context.Context, root string, stats *SeedStats) error {
|
||
reactionsDir := filepath.Join(root, "telegram_reactions_export", "reactions")
|
||
rawPath := filepath.Join(root, "telegram_reactions_export", "global_json", "available_reactions_raw.json")
|
||
raw, err := os.ReadFile(rawPath)
|
||
if err != nil {
|
||
return nil // 没有 reaction 资源就跳过
|
||
}
|
||
var parsed struct {
|
||
Result struct {
|
||
Reactions []seedReactionJSON `json:"reactions"`
|
||
} `json:"result"`
|
||
}
|
||
if err := json.Unmarshal(raw, &parsed); err != nil {
|
||
return fmt.Errorf("parse available_reactions_raw.json: %w", err)
|
||
}
|
||
index, err := scanSeedDir(reactionsDir)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
for i, rj := range parsed.Result.Reactions {
|
||
ar := domain.AvailableReaction{
|
||
Reaction: rj.Reaction,
|
||
Title: rj.Title,
|
||
Inactive: rj.Inactive,
|
||
Premium: rj.Premium,
|
||
Order: i,
|
||
}
|
||
set := func(dst *int64, d *seedDocumentJSON) error {
|
||
if d == nil || d.ID == 0 {
|
||
return nil
|
||
}
|
||
doc, err := s.importDocument(ctx, *d, reactionsDir, index, stats)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
*dst = doc.ID
|
||
return nil
|
||
}
|
||
if err := set(&ar.StaticIconID, rj.StaticIcon); err != nil {
|
||
return err
|
||
}
|
||
if err := set(&ar.AppearAnimationID, rj.AppearAnimation); err != nil {
|
||
return err
|
||
}
|
||
if err := set(&ar.SelectAnimationID, rj.SelectAnimation); err != nil {
|
||
return err
|
||
}
|
||
if err := set(&ar.ActivateAnimationID, rj.ActivateAnimation); err != nil {
|
||
return err
|
||
}
|
||
if err := set(&ar.EffectAnimationID, rj.EffectAnimation); err != nil {
|
||
return err
|
||
}
|
||
if err := set(&ar.AroundAnimationID, rj.AroundAnimation); err != nil {
|
||
return err
|
||
}
|
||
if err := set(&ar.CenterIconID, rj.CenterIcon); err != nil {
|
||
return err
|
||
}
|
||
if err := s.media.PutAvailableReaction(ctx, ar); err != nil {
|
||
return err
|
||
}
|
||
stats.Reactions++
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func (s *Service) availableReactionSeedNeedsRepair(ctx context.Context) (bool, error) {
|
||
reactions, err := s.media.ListAvailableReactions(ctx)
|
||
if err != nil {
|
||
return false, err
|
||
}
|
||
var docIDs []int64
|
||
for _, r := range reactions {
|
||
for _, id := range r.DocumentIDs() {
|
||
if id == 0 {
|
||
continue
|
||
}
|
||
docIDs = append(docIDs, id)
|
||
if _, ok, err := s.media.GetFileBlob(ctx, fmt.Sprintf("doc:%d", id)); err != nil {
|
||
return false, err
|
||
} else if !ok {
|
||
return true, nil
|
||
}
|
||
}
|
||
}
|
||
if stale, err := s.documentsNeedInlineCachedThumbs(ctx, docIDs); err != nil || stale {
|
||
return stale, err
|
||
}
|
||
return false, nil
|
||
}
|
||
|
||
// ---- sticker sets ----
|
||
|
||
func (s *Service) seedStickerSets(ctx context.Context, root string, maxRegular int, stats *SeedStats) error {
|
||
// default 系统集：目录名 → system_key。
|
||
defaultDir := filepath.Join(root, "telegram_default_stickers_export")
|
||
order := 0
|
||
if entries, err := os.ReadDir(defaultDir); err == nil {
|
||
names := make([]string, 0, len(entries))
|
||
for _, e := range entries {
|
||
if e.IsDir() {
|
||
names = append(names, e.Name())
|
||
}
|
||
}
|
||
sort.Strings(names)
|
||
for _, name := range names {
|
||
systemKey := systemKeyForDefaultSet(name)
|
||
setDir := filepath.Join(defaultDir, name)
|
||
if err := s.importStickerSetDir(ctx, setDir, systemKey, order, stats); err != nil {
|
||
return fmt.Errorf("import default set %s: %w", name, err)
|
||
}
|
||
order++
|
||
}
|
||
}
|
||
|
||
// 常规贴纸集。
|
||
regularDir := filepath.Join(root, "telegram_stickers_export")
|
||
if entries, err := os.ReadDir(regularDir); err == nil {
|
||
names := make([]string, 0, len(entries))
|
||
for _, e := range entries {
|
||
if e.IsDir() {
|
||
names = append(names, e.Name())
|
||
}
|
||
}
|
||
sort.Strings(names)
|
||
imported := 0
|
||
for _, name := range names {
|
||
if maxRegular > 0 && imported >= maxRegular {
|
||
break
|
||
}
|
||
setDir := filepath.Join(regularDir, name)
|
||
if err := s.importStickerSetDir(ctx, setDir, "", order, stats); err != nil {
|
||
return fmt.Errorf("import sticker set %s: %w", name, err)
|
||
}
|
||
order++
|
||
imported++
|
||
}
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func (s *Service) importStickerSetDir(ctx context.Context, setDir, systemKey string, order int, stats *SeedStats) error {
|
||
infoPath := filepath.Join(setDir, "set_info.json")
|
||
raw, err := os.ReadFile(infoPath)
|
||
if err != nil {
|
||
return nil // 该目录无 set_info.json → 跳过
|
||
}
|
||
var info struct {
|
||
Result seedStickerSetResultJSON `json:"result"`
|
||
}
|
||
if err := json.Unmarshal(raw, &info); err != nil {
|
||
return fmt.Errorf("parse %s: %w", infoPath, err)
|
||
}
|
||
sj := info.Result.Set
|
||
if sj.ID == 0 {
|
||
return nil
|
||
}
|
||
stickersDir := filepath.Join(setDir, "stickers")
|
||
index, err := scanSeedDir(stickersDir)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
docIDs := make([]int64, 0, len(info.Result.Documents))
|
||
docs := make([]domain.Document, 0, len(info.Result.Documents))
|
||
docIDBySource := make(map[int64]int64, len(info.Result.Documents))
|
||
for _, dj := range info.Result.Documents {
|
||
sourceID := dj.ID
|
||
doc, err := s.importDocument(ctx, dj, stickersDir, index, stats)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if doc.ID != 0 {
|
||
docIDBySource[sourceID] = doc.ID
|
||
docIDs = append(docIDs, doc.ID)
|
||
docs = append(docs, doc)
|
||
}
|
||
}
|
||
|
||
kind := stickerSetKind(sj, systemKey)
|
||
set := domain.StickerSet{
|
||
ID: sj.ID,
|
||
AccessHash: sj.AccessHash,
|
||
ShortName: sj.ShortName,
|
||
Title: sj.Title,
|
||
Count: sj.Count,
|
||
Hash: sj.Hash,
|
||
Kind: kind,
|
||
Official: sj.Official,
|
||
Animated: true, // 导出资源均为 .tgs 动画贴纸
|
||
Emojis: sj.Emojis,
|
||
Masks: sj.Masks,
|
||
Archived: sj.Archived,
|
||
Installed: seedStickerSetInstalled(kind),
|
||
ThumbDocumentID: seedDocumentStorageID(derefInt64(sj.ThumbDocumentID)),
|
||
Thumbs: seedStickerSetPhotoSizes(sj.Thumbs),
|
||
ThumbDCID: s.dc,
|
||
ThumbVersion: sj.ThumbVersion,
|
||
DocumentIDs: docIDs,
|
||
Packs: seedStickerPacks(sj.Packs, info.Result.Packs, docIDBySource),
|
||
SortOrder: order,
|
||
SystemKey: systemKey,
|
||
}
|
||
if set.Count == 0 {
|
||
set.Count = len(docIDs)
|
||
}
|
||
if err := s.media.PutStickerSet(ctx, set); err != nil {
|
||
return err
|
||
}
|
||
s.stickerSetCache.put(set, docs)
|
||
stats.StickerSets++
|
||
return nil
|
||
}
|
||
|
||
// ---- 单个 document 导入 ----
|
||
|
||
func (s *Service) importDocument(ctx context.Context, dj seedDocumentJSON, binDir string, index seedDirIndex, stats *SeedStats) (domain.Document, error) {
|
||
if dj.ID == 0 {
|
||
return domain.Document{}, nil
|
||
}
|
||
storageID := seedDocumentStorageID(dj.ID)
|
||
ref, _ := hex.DecodeString(dj.FileReference)
|
||
doc := domain.Document{
|
||
ID: storageID,
|
||
AccessHash: dj.AccessHash,
|
||
FileReference: ref,
|
||
Date: parseSeedDate(dj.Date),
|
||
MimeType: dj.MimeType,
|
||
Size: dj.Size,
|
||
DCID: s.dc,
|
||
Attributes: seedDocumentAttributes(dj.Attributes),
|
||
}
|
||
|
||
// 主体 blob：doc:<server-owned-id>
|
||
if mainPath, ok := index.main[dj.ID]; ok {
|
||
data, err := os.ReadFile(mainPath)
|
||
if err != nil {
|
||
return domain.Document{}, err
|
||
}
|
||
objectKey, err := s.blobs.Put(ctx, data)
|
||
if err != nil {
|
||
return domain.Document{}, err
|
||
}
|
||
if err := s.media.PutFileBlob(ctx, domain.FileBlob{
|
||
LocationKey: fmt.Sprintf("doc:%d", storageID),
|
||
Backend: domain.MediaBackend(s.blobs.Name()),
|
||
ObjectKey: objectKey,
|
||
Size: int64(len(data)),
|
||
MimeType: dj.MimeType,
|
||
}); err != nil {
|
||
return domain.Document{}, err
|
||
}
|
||
s.prewarmSmallBlob(objectKey, data)
|
||
stats.Blobs++
|
||
}
|
||
|
||
// 缩略图保留两类并存（与官方 sticker 一致）：
|
||
// - PhotoPathSize 矢量轮廓：随 document 元数据内联下发，是 TDesktop 对 animated
|
||
// sticker 在完整 .tgs 下载完成前唯一可即时渲染的占位（history_view_sticker 显式
|
||
// 禁用了 stripped 内联占位，cached 字节又经 RPC 出口转成 downloadable）；丢掉它会让
|
||
// 打开会话时 sticker 先空白、并多触发一次缩略图 getFile。
|
||
// - 小 PhotoSize 静态图：写 blob 并暂存为 PhotoCachedSize（RPC 出口再转 downloadable
|
||
// photoSize m），供 sticker 面板等需要小缩略图的场景下载。
|
||
thumbs := make([]domain.PhotoSize, 0, len(dj.Thumbs))
|
||
for _, tj := range dj.Thumbs {
|
||
ps, downloadable := seedPhotoSize(tj)
|
||
if ps.Kind == "" {
|
||
continue
|
||
}
|
||
if downloadable {
|
||
thumbPath, ok := index.thumb[dj.ID][ps.Type]
|
||
if !ok {
|
||
continue // 无可服务的缩略图文件，丢弃该尺寸（保留 PhotoPathSize 占位）
|
||
}
|
||
data, err := os.ReadFile(thumbPath)
|
||
if err != nil {
|
||
return domain.Document{}, err
|
||
}
|
||
objectKey, err := s.blobs.Put(ctx, data)
|
||
if err != nil {
|
||
return domain.Document{}, err
|
||
}
|
||
ps.Size = len(data)
|
||
if err := s.media.PutFileBlob(ctx, domain.FileBlob{
|
||
LocationKey: fmt.Sprintf("doc:%d:%s", storageID, ps.Type),
|
||
Backend: domain.MediaBackend(s.blobs.Name()),
|
||
ObjectKey: objectKey,
|
||
Size: int64(len(data)),
|
||
MimeType: seedThumbMimeType(data),
|
||
}); err != nil {
|
||
return domain.Document{}, err
|
||
}
|
||
ps = seedInlineCachedDocumentThumb(ps, data)
|
||
s.prewarmSmallBlob(objectKey, data)
|
||
stats.Blobs++
|
||
}
|
||
thumbs = append(thumbs, ps)
|
||
}
|
||
doc.Thumbs = thumbs
|
||
|
||
if err := s.media.PutDocument(ctx, doc); err != nil {
|
||
return domain.Document{}, err
|
||
}
|
||
stats.Documents++
|
||
return doc, nil
|
||
}
|
||
|
||
func (s *Service) prewarmSmallBlob(objectKey string, data []byte) {
|
||
if len(data) > 0 && len(data) <= blobBytesCacheMaxEntryBytes {
|
||
s.byteCache.put(objectKey, data)
|
||
}
|
||
}
|
||
|
||
// ---- 目录扫描：docID → 主体文件 / 可下载缩略图 ----
|
||
|
||
type seedDirIndex struct {
|
||
main map[int64]string // docID -> 主体文件路径
|
||
thumb map[int64]map[string]string // docID -> thumbType -> 缩略图文件路径
|
||
}
|
||
|
||
var seedTrailingDigits = regexp.MustCompile(`(\d{6,})`)
|
||
var seedThumbMarker = regexp.MustCompile(`_thumb\d+_`)
|
||
|
||
const seedInlineCachedDocumentThumbMaxBytes = 32 * 1024
|
||
|
||
// Exported Telegram resources keep their original id in filenames/JSON, but
|
||
// telesrv owns the document catalog it serves. Imported high source ids are
|
||
// normalized once at seed time so RPC/storage use one server-owned id.
|
||
const seedExternalDocumentIDOffset int64 = 4_000_000_000_000_000_000
|
||
|
||
var seedThumbType = regexp.MustCompile(`PhotoSize_type([a-z])`)
|
||
|
||
func seedDocumentStorageID(sourceID int64) int64 {
|
||
if sourceID <= 0 {
|
||
return 0
|
||
}
|
||
if sourceID > seedExternalDocumentIDOffset {
|
||
return sourceID - seedExternalDocumentIDOffset
|
||
}
|
||
return sourceID
|
||
}
|
||
|
||
func scanSeedDir(dir string) (seedDirIndex, error) {
|
||
idx := seedDirIndex{main: map[int64]string{}, thumb: map[int64]map[string]string{}}
|
||
entries, err := os.ReadDir(dir)
|
||
if err != nil {
|
||
return idx, nil // 目录不存在 → 空 index
|
||
}
|
||
for _, e := range entries {
|
||
if e.IsDir() {
|
||
continue
|
||
}
|
||
name := e.Name()
|
||
ext := strings.ToLower(filepath.Ext(name))
|
||
full := filepath.Join(dir, name)
|
||
if marker := seedThumbMarker.FindStringIndex(name); marker != nil {
|
||
// 只收可下载的 PhotoSize 缩略图（jpg）；PhotoPathSize(svg) 内联在 JSON。
|
||
if ext != ".jpg" && ext != ".jpeg" {
|
||
continue
|
||
}
|
||
m := seedThumbType.FindStringSubmatch(name)
|
||
if m == nil {
|
||
continue
|
||
}
|
||
docID := docIDFromName(name[:marker[0]])
|
||
if docID == 0 {
|
||
continue
|
||
}
|
||
if idx.thumb[docID] == nil {
|
||
idx.thumb[docID] = map[string]string{}
|
||
}
|
||
idx.thumb[docID][m[1]] = full
|
||
continue
|
||
}
|
||
if ext == ".svg" || ext == ".json" {
|
||
continue
|
||
}
|
||
docID := docIDFromName(strings.TrimSuffix(name, filepath.Ext(name)))
|
||
if docID == 0 {
|
||
continue
|
||
}
|
||
idx.main[docID] = full
|
||
}
|
||
return idx, nil
|
||
}
|
||
|
||
// docIDFromName 取 base name 中末尾最长的数字串作为 document id。
|
||
func docIDFromName(base string) int64 {
|
||
matches := seedTrailingDigits.FindAllString(base, -1)
|
||
if len(matches) == 0 {
|
||
return 0
|
||
}
|
||
last := matches[len(matches)-1]
|
||
id, err := strconv.ParseInt(last, 10, 64)
|
||
if err != nil {
|
||
return 0
|
||
}
|
||
return id
|
||
}
|
||
|
||
func systemKeyForDefaultSet(dirName string) string {
|
||
switch dirName {
|
||
case "DefaultSet_AnimatedEmoji":
|
||
return "animated_emoji"
|
||
case "DefaultSet_AnimatedEmojiAnimations":
|
||
return "animated_emoji_animations"
|
||
case "DefaultSet_EmojiGenericAnimations":
|
||
return "emoji_generic_animations"
|
||
case "DefaultSet_Dice_Normal":
|
||
return "dice:\U0001f3b2"
|
||
case "DefaultSet_Dice_Dart":
|
||
return "dice:\U0001f3af"
|
||
case "DefaultSet_Dice_Basketball":
|
||
return "dice:\U0001f3c0"
|
||
case "DefaultSet_Dice_Football":
|
||
return "dice:⚽"
|
||
case "DefaultSet_Dice_Bowling":
|
||
return "dice:\U0001f3b3"
|
||
case "DefaultSet_Dice_Casino":
|
||
return "dice:\U0001f3b0"
|
||
default:
|
||
return ""
|
||
}
|
||
}
|
||
|
||
func stickerSetKind(sj seedStickerSetJSON, systemKey string) domain.StickerSetKind {
|
||
switch {
|
||
case systemKey != "":
|
||
return domain.StickerSetKindSystem
|
||
case sj.Emojis:
|
||
return domain.StickerSetKindEmoji
|
||
case sj.Masks:
|
||
return domain.StickerSetKindMasks
|
||
default:
|
||
return domain.StickerSetKindStickers
|
||
}
|
||
}
|
||
|
||
func seedStickerSetInstalled(kind domain.StickerSetKind) bool {
|
||
return kind != domain.StickerSetKindSystem
|
||
}
|
||
|
||
// ---- JSON → domain 转换 ----
|
||
|
||
func seedDocumentAttributes(attrs []seedAttrJSON) []domain.DocumentAttribute {
|
||
out := make([]domain.DocumentAttribute, 0, len(attrs))
|
||
for _, a := range attrs {
|
||
switch a.Type {
|
||
case "DocumentAttributeImageSize":
|
||
out = append(out, domain.DocumentAttribute{Kind: domain.DocAttrImageSize, W: a.W, H: a.H})
|
||
case "DocumentAttributeAnimated":
|
||
out = append(out, domain.DocumentAttribute{Kind: domain.DocAttrAnimated})
|
||
case "DocumentAttributeSticker":
|
||
attr := domain.DocumentAttribute{Kind: domain.DocAttrSticker, Alt: a.Alt, Mask: a.Mask}
|
||
if a.Stickerset != nil {
|
||
attr.StickerSetID = a.Stickerset.ID
|
||
attr.StickerSetAccessHash = a.Stickerset.AccessHash
|
||
}
|
||
out = append(out, attr)
|
||
case "DocumentAttributeCustomEmoji":
|
||
attr := domain.DocumentAttribute{Kind: domain.DocAttrCustomEmoji, Alt: a.Alt, Free: a.Free, TextColor: a.TextColor}
|
||
if a.Stickerset != nil {
|
||
attr.StickerSetID = a.Stickerset.ID
|
||
attr.StickerSetAccessHash = a.Stickerset.AccessHash
|
||
}
|
||
out = append(out, attr)
|
||
case "DocumentAttributeVideo":
|
||
out = append(out, domain.DocumentAttribute{Kind: domain.DocAttrVideo, W: a.W, H: a.H, Duration: a.Duration, RoundMessage: a.RoundMessage, SupportsStreaming: a.SupportsStreaming})
|
||
case "DocumentAttributeAudio":
|
||
out = append(out, domain.DocumentAttribute{Kind: domain.DocAttrAudio, AudioDuration: int(a.Duration), Voice: a.Voice, Title: a.Title, Performer: a.Performer})
|
||
case "DocumentAttributeFilename":
|
||
out = append(out, domain.DocumentAttribute{Kind: domain.DocAttrFilename, FileName: a.FileName})
|
||
}
|
||
}
|
||
return out
|
||
}
|
||
|
||
func seedPhotoSizes(thumbs []seedThumbJSON) []domain.PhotoSize {
|
||
out := make([]domain.PhotoSize, 0, len(thumbs))
|
||
for _, t := range thumbs {
|
||
ps, _ := seedPhotoSize(t)
|
||
if ps.Kind != "" {
|
||
out = append(out, ps)
|
||
}
|
||
}
|
||
return out
|
||
}
|
||
|
||
func seedStickerSetPhotoSizes(thumbs []seedThumbJSON) []domain.PhotoSize {
|
||
out := make([]domain.PhotoSize, 0, len(thumbs))
|
||
for _, t := range thumbs {
|
||
ps, downloadable := seedPhotoSize(t)
|
||
if ps.Kind == "" || downloadable {
|
||
continue
|
||
}
|
||
out = append(out, ps)
|
||
}
|
||
return out
|
||
}
|
||
|
||
func seedPhotoSize(t seedThumbJSON) (domain.PhotoSize, bool) {
|
||
switch t.Type {
|
||
case "PhotoSize":
|
||
return domain.PhotoSize{Kind: domain.PhotoSizeKindDefault, Type: t.SizeType, W: t.W, H: t.H, Size: t.Size}, true
|
||
case "PhotoStrippedSize":
|
||
b, _ := hex.DecodeString(t.Bytes)
|
||
return domain.PhotoSize{Kind: domain.PhotoSizeKindStripped, Type: t.SizeType, Bytes: b}, false
|
||
case "PhotoCachedSize":
|
||
b, _ := hex.DecodeString(t.Bytes)
|
||
return domain.PhotoSize{Kind: domain.PhotoSizeKindCached, Type: t.SizeType, W: t.W, H: t.H, Bytes: b}, false
|
||
case "PhotoPathSize":
|
||
b, _ := hex.DecodeString(t.Bytes)
|
||
return domain.PhotoSize{Kind: domain.PhotoSizeKindPath, Type: t.SizeType, Bytes: b}, false
|
||
case "PhotoSizeProgressive":
|
||
return domain.PhotoSize{Kind: domain.PhotoSizeKindProgressive, Type: t.SizeType, W: t.W, H: t.H, Sizes: t.Sizes}, true
|
||
default:
|
||
return domain.PhotoSize{}, false
|
||
}
|
||
}
|
||
|
||
func seedInlineCachedDocumentThumb(ps domain.PhotoSize, data []byte) domain.PhotoSize {
|
||
if ps.Kind != domain.PhotoSizeKindDefault || len(data) == 0 || len(data) > seedInlineCachedDocumentThumbMaxBytes {
|
||
return ps
|
||
}
|
||
ps.Kind = domain.PhotoSizeKindCached
|
||
ps.Size = 0
|
||
ps.Bytes = append([]byte(nil), data...)
|
||
return ps
|
||
}
|
||
|
||
func seedThumbMimeType(data []byte) string {
|
||
switch {
|
||
case len(data) >= 12 && data[0] == 'R' && data[1] == 'I' && data[2] == 'F' && data[3] == 'F' &&
|
||
data[8] == 'W' && data[9] == 'E' && data[10] == 'B' && data[11] == 'P':
|
||
return "image/webp"
|
||
case len(data) >= 3 && data[0] == 0xFF && data[1] == 0xD8 && data[2] == 0xFF:
|
||
return "image/jpeg"
|
||
case len(data) >= 8 && data[0] == 0x89 && data[1] == 'P' && data[2] == 'N' && data[3] == 'G':
|
||
return "image/png"
|
||
case len(data) >= 6 && data[0] == 'G' && data[1] == 'I' && data[2] == 'F':
|
||
return "image/gif"
|
||
default:
|
||
return "application/octet-stream"
|
||
}
|
||
}
|
||
|
||
func (s *Service) stickerSetDocumentThumbsNeedInlineCache(ctx context.Context) (bool, error) {
|
||
var ids []int64
|
||
for _, kind := range []domain.StickerSetKind{
|
||
domain.StickerSetKindStickers,
|
||
domain.StickerSetKindEmoji,
|
||
domain.StickerSetKindMasks,
|
||
domain.StickerSetKindSystem,
|
||
} {
|
||
sets, err := s.media.ListStickerSets(ctx, kind)
|
||
if err != nil {
|
||
return false, err
|
||
}
|
||
for _, set := range sets {
|
||
ids = append(ids, set.DocumentIDs...)
|
||
}
|
||
}
|
||
return s.documentsNeedInlineCachedThumbs(ctx, ids)
|
||
}
|
||
|
||
func (s *Service) documentsNeedInlineCachedThumbs(ctx context.Context, ids []int64) (bool, error) {
|
||
if len(ids) == 0 {
|
||
return false, nil
|
||
}
|
||
seen := make(map[int64]struct{}, len(ids))
|
||
unique := make([]int64, 0, len(ids))
|
||
for _, id := range ids {
|
||
if id == 0 {
|
||
continue
|
||
}
|
||
if _, ok := seen[id]; ok {
|
||
continue
|
||
}
|
||
seen[id] = struct{}{}
|
||
unique = append(unique, id)
|
||
}
|
||
docs, err := s.media.GetDocuments(ctx, unique)
|
||
if err != nil {
|
||
return false, err
|
||
}
|
||
for _, doc := range docs {
|
||
for _, thumb := range doc.Thumbs {
|
||
if thumb.Kind == domain.PhotoSizeKindDefault && thumb.Size > 0 && thumb.Size <= seedInlineCachedDocumentThumbMaxBytes {
|
||
return true, nil
|
||
}
|
||
if thumb.Kind == domain.PhotoSizeKindCached && len(thumb.Bytes) > 0 {
|
||
blob, ok, err := s.media.GetFileBlob(ctx, fmt.Sprintf("doc:%d:%s", doc.ID, thumb.Type))
|
||
if err != nil {
|
||
return false, err
|
||
}
|
||
if ok {
|
||
want := seedThumbMimeType(thumb.Bytes)
|
||
if want != "application/octet-stream" && blob.MimeType != want {
|
||
return true, nil
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return false, nil
|
||
}
|
||
|
||
func seedStickerPacks(setPacks, resultPacks []seedStickerPackJSON, docIDBySource map[int64]int64) []domain.StickerPack {
|
||
packs := setPacks
|
||
if len(packs) == 0 {
|
||
packs = resultPacks
|
||
}
|
||
out := make([]domain.StickerPack, 0, len(packs))
|
||
for _, p := range packs {
|
||
documents := make([]int64, 0, len(p.Documents))
|
||
for _, sourceID := range p.Documents {
|
||
if id, ok := docIDBySource[sourceID]; ok {
|
||
documents = append(documents, id)
|
||
continue
|
||
}
|
||
if id := seedDocumentStorageID(sourceID); id != 0 {
|
||
documents = append(documents, id)
|
||
}
|
||
}
|
||
out = append(out, domain.StickerPack{Emoticon: p.Emoticon, DocumentIDs: documents})
|
||
}
|
||
return out
|
||
}
|
||
|
||
func parseSeedDate(s string) int {
|
||
if s == "" {
|
||
return 0
|
||
}
|
||
if t, err := time.Parse(time.RFC3339, s); err == nil {
|
||
return int(t.Unix())
|
||
}
|
||
return 0
|
||
}
|
||
|
||
func derefInt64(v *int64) int64 {
|
||
if v == nil {
|
||
return 0
|
||
}
|
||
return *v
|
||
}
|
||
|
||
// ---- seed JSON 结构 ----
|
||
|
||
type seedInputStickerSetJSON struct {
|
||
ID int64 `json:"id"`
|
||
AccessHash int64 `json:"access_hash"`
|
||
}
|
||
|
||
type seedAttrJSON struct {
|
||
Type string `json:"_"`
|
||
W int `json:"w"`
|
||
H int `json:"h"`
|
||
Alt string `json:"alt"`
|
||
Mask bool `json:"mask"`
|
||
Duration float64 `json:"duration"`
|
||
RoundMessage bool `json:"round_message"`
|
||
SupportsStreaming bool `json:"supports_streaming"`
|
||
Voice bool `json:"voice"`
|
||
Title string `json:"title"`
|
||
Performer string `json:"performer"`
|
||
FileName string `json:"file_name"`
|
||
Free bool `json:"free"`
|
||
TextColor bool `json:"text_color"`
|
||
Stickerset *seedInputStickerSetJSON `json:"stickerset"`
|
||
}
|
||
|
||
type seedThumbJSON struct {
|
||
Type string `json:"_"`
|
||
SizeType string `json:"type"`
|
||
W int `json:"w"`
|
||
H int `json:"h"`
|
||
Size int `json:"size"`
|
||
Bytes string `json:"bytes"`
|
||
Sizes []int `json:"sizes"`
|
||
}
|
||
|
||
type seedDocumentJSON struct {
|
||
ID int64 `json:"id"`
|
||
AccessHash int64 `json:"access_hash"`
|
||
FileReference string `json:"file_reference"`
|
||
Date string `json:"date"`
|
||
MimeType string `json:"mime_type"`
|
||
Size int64 `json:"size"`
|
||
DCID int `json:"dc_id"`
|
||
Attributes []seedAttrJSON `json:"attributes"`
|
||
Thumbs []seedThumbJSON `json:"thumbs"`
|
||
}
|
||
|
||
type seedStickerPackJSON struct {
|
||
Emoticon string `json:"emoticon"`
|
||
Documents []int64 `json:"documents"`
|
||
}
|
||
|
||
type seedStickerSetJSON struct {
|
||
ID int64 `json:"id"`
|
||
AccessHash int64 `json:"access_hash"`
|
||
Title string `json:"title"`
|
||
ShortName string `json:"short_name"`
|
||
Count int `json:"count"`
|
||
Hash int `json:"hash"`
|
||
Archived bool `json:"archived"`
|
||
Official bool `json:"official"`
|
||
Masks bool `json:"masks"`
|
||
Emojis bool `json:"emojis"`
|
||
Thumbs []seedThumbJSON `json:"thumbs"`
|
||
ThumbDCID int `json:"thumb_dc_id"`
|
||
ThumbVersion int `json:"thumb_version"`
|
||
ThumbDocumentID *int64 `json:"thumb_document_id"`
|
||
Packs []seedStickerPackJSON `json:"packs"`
|
||
}
|
||
|
||
type seedStickerSetResultJSON struct {
|
||
Set seedStickerSetJSON `json:"set"`
|
||
Packs []seedStickerPackJSON `json:"packs"`
|
||
Documents []seedDocumentJSON `json:"documents"`
|
||
}
|
||
|
||
type seedReactionJSON struct {
|
||
Reaction string `json:"reaction"`
|
||
Title string `json:"title"`
|
||
Inactive bool `json:"inactive"`
|
||
Premium bool `json:"premium"`
|
||
StaticIcon *seedDocumentJSON `json:"static_icon"`
|
||
AppearAnimation *seedDocumentJSON `json:"appear_animation"`
|
||
SelectAnimation *seedDocumentJSON `json:"select_animation"`
|
||
ActivateAnimation *seedDocumentJSON `json:"activate_animation"`
|
||
EffectAnimation *seedDocumentJSON `json:"effect_animation"`
|
||
AroundAnimation *seedDocumentJSON `json:"around_animation"`
|
||
CenterIcon *seedDocumentJSON `json:"center_icon"`
|
||
}
|