更新 update 门户站点界面和后台功能

server/unified-management/internal/sources/sources.go

@@ -5,10 +5,12 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"io"
 	"net/http"
 	"net/url"
 	"os"
 	"path/filepath"
+	"regexp"
 	"strings"
 	"sync"
 	"time"
@@ -44,10 +46,28 @@ type CheckJob struct {
 	LastError  string         `json:"lastError"`
 }
 
+type mediaResolution struct {
+	URL       string
+	Key       string
+	MediaType string
+	Direct    bool
+}
+
+type mediaCandidate struct {
+	Resolution mediaResolution
+	Score      int
+	Depth      int
+	Order      int
+}
+
 type legacyMedia struct {
 	Categories []legacyCategory `json:"categories"`
 }
 
+const maxSourceProbeBytes int64 = 2 * 1024 * 1024
+
+var absoluteURLPattern = regexp.MustCompile(`https?://[^\s"'<>\\]+`)
+
 type legacyCategory struct {
 	ID            string              `json:"id"`
 	Name          string              `json:"name"`
@@ -152,6 +172,42 @@ func (s *Service) ImportLegacyMediaTypes(ctx context.Context) error {
 	return nil
 }
 
+func (s *Service) DeleteSourceAndPublishCompatibility(ctx context.Context, sourceID, actor string) error {
+	sourceID = strings.TrimSpace(sourceID)
+	if sourceID == "" || strings.ContainsAny(sourceID, `/\`) || strings.Contains(sourceID, "..") {
+		return errors.New("invalid source id")
+	}
+	if _, err := s.store.GetSourceBySourceID(sourceID); err != nil {
+		return err
+	}
+	if err := s.store.DeleteSource(sourceID); err != nil {
+		return err
+	}
+	if err := s.PublishLegacyMediaTypes(ctx, actor); err != nil {
+		return err
+	}
+	_ = s.store.InsertAudit(db.AuditLog{Actor: firstNonEmpty(actor, "admin"), Type: "source.deleted", Target: sourceID, Message: "客户端接口已删除并同步兼容 media-types.json"})
+	return nil
+}
+
+func (s *Service) PublishLegacyMediaTypes(ctx context.Context, actor string) error {
+	catalog, err := s.Catalog(false)
+	if err != nil {
+		return err
+	}
+	data, err := json.MarshalIndent(catalog, "", "  ")
+	if err != nil {
+		return err
+	}
+	formatted := append(data, '\n')
+	path := filepath.Join(s.cfg.UpdatePublicDir, "media-types.json")
+	if err := atomicWrite(path, formatted); err != nil {
+		return err
+	}
+	_, _ = s.store.SaveLegacyRevision("media-types", string(formatted), "generated from source database", firstNonEmpty(actor, "system"))
+	return nil
+}
+
 func (s *Service) Catalog(includeHidden bool) (map[string]any, error) {
 	items, err := s.store.ListSources(includeHidden)
 	if err != nil {
@@ -194,6 +250,7 @@ func (s *Service) Catalog(includeHidden bool) (map[string]any, error) {
 				"meta":               parseHealthMeta(item.LastError),
 			},
 		}
+		applyResolvedFields(sub, item.LastError)
 		cat["subcategories"] = append(cat["subcategories"].([]map[string]any), sub)
 	}
 	out := []map[string]any{}
@@ -216,7 +273,7 @@ func (s *Service) Endpoints(includeHidden bool) ([]map[string]any, error) {
 	for _, item := range items {
 		var formats []string
 		_ = json.Unmarshal([]byte(item.SupportedFormats), &formats)
-		out = append(out, map[string]any{
+		endpoint := map[string]any{
 			"id":               item.SourceID,
 			"category":         item.CategoryID,
 			"name":             item.Name,
@@ -235,7 +292,9 @@ func (s *Service) Endpoints(includeHidden bool) ([]map[string]any, error) {
 				"consecutiveFailure": item.ConsecutiveFailure,
 				"meta":               parseHealthMeta(item.LastError),
 			},
-		})
+		}
+		applyResolvedFields(endpoint, item.LastError)
+		out = append(out, endpoint)
 	}
 	return out, nil
 }
@@ -434,6 +493,18 @@ func (s *Service) CheckOneStatus(ctx context.Context, item db.Source) (string, e
 			"error":         resp.Status,
 		})
 	}
+	if resp.StatusCode < 400 {
+		meta := parseHealthMeta(message)
+		meta["finalUrl"] = resp.Request.URL.String()
+		meta["finalStatus"] = resp.StatusCode
+		if resolution := resolveMediaFromResponse(resp); resolution.URL != "" {
+			meta["resolvedUrl"] = resolution.URL
+			meta["resolvedKey"] = resolution.Key
+			meta["mediaType"] = resolution.MediaType
+			meta["directMedia"] = resolution.Direct
+		}
+		message = healthMetaMessage(meta)
+	}
 	if err := s.store.RecordSourceCheck(item.ID, status, latency, message); err != nil {
 		return status, err
 	}
@@ -486,6 +557,259 @@ func isHTTPURL(value *url.URL) bool {
 	return scheme == "http" || scheme == "https"
 }
 
+func resolveMediaFromResponse(resp *http.Response) mediaResolution {
+	if resp == nil || resp.Request == nil || resp.Request.URL == nil {
+		return mediaResolution{}
+	}
+	finalURL := resp.Request.URL
+	contentType := strings.ToLower(strings.TrimSpace(strings.Split(resp.Header.Get("Content-Type"), ";")[0]))
+	if mediaType := mediaTypeFromContentType(contentType); mediaType != "" || looksLikeMediaURL(finalURL) {
+		return mediaResolution{URL: finalURL.String(), Key: "response", MediaType: firstNonEmpty(mediaType, mediaTypeFromURL(finalURL)), Direct: true}
+	}
+	if !canProbeText(contentType, resp.ContentLength) {
+		return mediaResolution{}
+	}
+	reader := io.LimitReader(resp.Body, maxSourceProbeBytes+1)
+	data, err := io.ReadAll(reader)
+	if err != nil || int64(len(data)) > maxSourceProbeBytes {
+		return mediaResolution{}
+	}
+	text := strings.TrimSpace(string(data))
+	if text == "" {
+		return mediaResolution{}
+	}
+	var decoded any
+	if json.Unmarshal(data, &decoded) == nil {
+		if candidate, ok := bestJSONMediaCandidate(decoded, finalURL); ok {
+			return candidate.Resolution
+		}
+	}
+	if candidate, ok := bestTextMediaCandidate(text, finalURL); ok {
+		return candidate.Resolution
+	}
+	return mediaResolution{}
+}
+
+func canProbeText(contentType string, length int64) bool {
+	if length > maxSourceProbeBytes {
+		return false
+	}
+	if contentType == "" || strings.Contains(contentType, "json") {
+		return true
+	}
+	return strings.HasPrefix(contentType, "text/") ||
+		strings.Contains(contentType, "javascript") ||
+		strings.Contains(contentType, "xml") ||
+		strings.Contains(contentType, "form")
+}
+
+func bestJSONMediaCandidate(value any, base *url.URL) (mediaCandidate, bool) {
+	candidates := []mediaCandidate{}
+	order := 0
+	collectJSONMediaCandidates(value, "", base, 0, &order, &candidates)
+	return bestCandidate(candidates)
+}
+
+func collectJSONMediaCandidates(value any, key string, base *url.URL, depth int, order *int, candidates *[]mediaCandidate) {
+	switch typed := value.(type) {
+	case map[string]any:
+		for childKey, childValue := range typed {
+			nextKey := childKey
+			if key != "" {
+				nextKey = key + "." + childKey
+			}
+			collectJSONMediaCandidates(childValue, nextKey, base, depth+1, order, candidates)
+		}
+	case []any:
+		for _, childValue := range typed {
+			collectJSONMediaCandidates(childValue, key, base, depth+1, order, candidates)
+		}
+	case string:
+		*order = *order + 1
+		if candidate, ok := candidateFromString(key, typed, base, depth, *order); ok {
+			*candidates = append(*candidates, candidate)
+		}
+	}
+}
+
+func bestTextMediaCandidate(text string, base *url.URL) (mediaCandidate, bool) {
+	candidates := []mediaCandidate{}
+	matches := absoluteURLPattern.FindAllString(text, 30)
+	for index, match := range matches {
+		if candidate, ok := candidateFromString("text", strings.TrimRight(match, ".,);]}'\""), base, 0, index+1); ok {
+			candidates = append(candidates, candidate)
+		}
+	}
+	return bestCandidate(candidates)
+}
+
+func candidateFromString(key, value string, base *url.URL, depth, order int) (mediaCandidate, bool) {
+	raw := strings.TrimSpace(value)
+	if raw == "" {
+		return mediaCandidate{}, false
+	}
+	urls := []string{raw}
+	if !strings.Contains(raw, "://") {
+		urls = append(urls, absoluteURLPattern.FindAllString(raw, 10)...)
+	}
+	for _, candidate := range urls {
+		resolved, ok := resolveCandidateURL(candidate, base)
+		if !ok {
+			continue
+		}
+		mediaType := mediaTypeFromURL(resolved)
+		if mediaType == "" {
+			continue
+		}
+		keyScore := mediaKeyScore(key)
+		score := 100 + keyScore - depth
+		return mediaCandidate{
+			Resolution: mediaResolution{
+				URL:       resolved.String(),
+				Key:       key,
+				MediaType: mediaType,
+			},
+			Score: score,
+			Depth: depth,
+			Order: order,
+		}, true
+	}
+	return mediaCandidate{}, false
+}
+
+func resolveCandidateURL(value string, base *url.URL) (*url.URL, bool) {
+	value = strings.TrimSpace(strings.Trim(value, `"'`))
+	if value == "" {
+		return nil, false
+	}
+	parsed, err := url.Parse(value)
+	if err != nil {
+		return nil, false
+	}
+	if !parsed.IsAbs() {
+		if base == nil {
+			return nil, false
+		}
+		parsed = base.ResolveReference(parsed)
+	}
+	if !isHTTPURL(parsed) {
+		return nil, false
+	}
+	return parsed, true
+}
+
+func bestCandidate(candidates []mediaCandidate) (mediaCandidate, bool) {
+	if len(candidates) == 0 {
+		return mediaCandidate{}, false
+	}
+	best := candidates[0]
+	for _, candidate := range candidates[1:] {
+		if candidate.Score > best.Score ||
+			(candidate.Score == best.Score && candidate.Depth < best.Depth) ||
+			(candidate.Score == best.Score && candidate.Depth == best.Depth && candidate.Order < best.Order) {
+			best = candidate
+		}
+	}
+	return best, true
+}
+
+func mediaKeyScore(key string) int {
+	last := key
+	if index := strings.LastIndex(last, "."); index >= 0 {
+		last = last[index+1:]
+	}
+	normalized := strings.ToLower(strings.TrimSpace(last))
+	switch normalized {
+	case "url", "src", "image", "img", "pic", "cover", "thumbnail", "video", "file", "media":
+		return 80
+	case "href", "poster", "preview", "download", "play", "audio":
+		return 60
+	}
+	for _, token := range []string{"url", "src", "image", "img", "pic", "cover", "thumb", "video", "file", "media"} {
+		if strings.Contains(normalized, token) {
+			return 40
+		}
+	}
+	return 0
+}
+
+func looksLikeMediaURL(value *url.URL) bool {
+	return mediaTypeFromURL(value) != ""
+}
+
+func mediaTypeFromURL(value *url.URL) string {
+	if value == nil {
+		return ""
+	}
+	extension := strings.ToLower(strings.TrimPrefix(filepath.Ext(value.Path), "."))
+	switch extension {
+	case "jpg", "jpeg", "png", "webp", "gif", "bmp", "tif", "tiff":
+		return "image"
+	case "mp4", "webm", "m3u8", "mkv", "mov", "m4v", "avi", "wmv":
+		return "video"
+	case "mp3", "wav", "flac", "aac", "m4a", "ogg", "wma":
+		return "audio"
+	default:
+		return ""
+	}
+}
+
+func mediaTypeFromContentType(value string) string {
+	switch {
+	case strings.HasPrefix(value, "image/"):
+		return "image"
+	case strings.HasPrefix(value, "video/") || value == "application/vnd.apple.mpegurl" || value == "application/x-mpegurl":
+		return "video"
+	case strings.HasPrefix(value, "audio/"):
+		return "audio"
+	default:
+		return ""
+	}
+}
+
+func applyResolvedFields(target map[string]any, message string) {
+	meta := parseHealthMeta(message)
+	resolvedURL, _ := meta["resolvedUrl"].(string)
+	resolvedKey, _ := meta["resolvedKey"].(string)
+	mediaType, _ := meta["mediaType"].(string)
+	if strings.TrimSpace(resolvedURL) != "" {
+		target["resolvedUrl"] = resolvedURL
+		target["resolved_url"] = resolvedURL
+	}
+	if strings.TrimSpace(resolvedKey) != "" {
+		target["resolvedKey"] = resolvedKey
+		target["resolved_key"] = resolvedKey
+	}
+	if strings.TrimSpace(mediaType) != "" {
+		target["mediaType"] = mediaType
+		target["media_type"] = mediaType
+	}
+}
+
+func atomicWrite(path string, data []byte) error {
+	dir := filepath.Dir(path)
+	if err := os.MkdirAll(dir, 0o750); err != nil {
+		return err
+	}
+	tmp, err := os.CreateTemp(dir, "."+filepath.Base(path)+".*.tmp")
+	if err != nil {
+		return err
+	}
+	tmpName := tmp.Name()
+	defer os.Remove(tmpName)
+	if _, err := tmp.Write(data); err != nil {
+		_ = tmp.Close()
+		return err
+	}
+	if err := tmp.Close(); err != nil {
+		return err
+	}
+	if err := os.Chmod(tmpName, 0o640); err != nil {
+		return err
+	}
+	return os.Rename(tmpName, path)
+}
+
 func healthMetaMessage(meta map[string]any) string {
 	data, err := json.Marshal(meta)
 	if err != nil {