1942 lines
57 KiB
Go
1942 lines
57 KiB
Go
package app
|
|
|
|
import (
|
|
"context"
|
|
"crypto/aes"
|
|
"crypto/cipher"
|
|
"crypto/sha256"
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"net/http"
|
|
"net/url"
|
|
"os"
|
|
"path/filepath"
|
|
"sort"
|
|
"strconv"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
const (
|
|
uiStatusQueued = "queued"
|
|
uiStatusParsing = "parsing"
|
|
uiStatusRunning = "running"
|
|
uiStatusSuccess = "success"
|
|
uiStatusFailed = "failed"
|
|
uiStatusCanceled = "canceled"
|
|
uiStatusPaused = "paused"
|
|
)
|
|
|
|
type UIApp struct {
|
|
downloader *Downloader
|
|
cfg Config
|
|
mu sync.Mutex
|
|
dramas []Drama
|
|
selected map[string]bool
|
|
tasks map[string]*UITask
|
|
taskOrder []string
|
|
merges map[string]*UIMergeState
|
|
lastError string
|
|
loadedAt time.Time
|
|
libraryLoading chan struct{}
|
|
librarySaved bool
|
|
libraryDirty bool
|
|
libraryAttempted bool
|
|
libraryRevision uint64
|
|
librarySources map[string]librarySourceState
|
|
libraryError string
|
|
libraryCancel context.CancelFunc
|
|
libraryWriteMu sync.Mutex
|
|
libraryLastSave time.Time
|
|
libraryApp *hongguoCatalogState
|
|
libraryMore bool
|
|
libraryLoadingSource string
|
|
libraryMetadata libraryMetadataProgress
|
|
metadataQueue []string
|
|
metadataPending map[string]bool
|
|
metadataCancel context.CancelFunc
|
|
metadataDone chan struct{}
|
|
metadataClosed bool
|
|
rankingApplied map[string]time.Time
|
|
|
|
cond *sync.Cond
|
|
statePath string
|
|
address string
|
|
runningCancels map[string]context.CancelFunc
|
|
mergeMu sync.Mutex
|
|
mergeJobs map[string]*uiMergeJob
|
|
mergeStopped bool
|
|
parsingInFlight map[string]bool
|
|
parsingCancels map[string]context.CancelFunc
|
|
closed bool
|
|
workerCount int
|
|
activeDownloads int
|
|
settingsMu sync.Mutex
|
|
nextOutputDir string
|
|
directoryPickerMu sync.Mutex
|
|
directoryPicker func(context.Context, string) (string, error)
|
|
playbackMu sync.Mutex
|
|
playbacks map[string]*playbackSession
|
|
playbackPrefetchSlots chan struct{}
|
|
playbackResourcesOnce sync.Once
|
|
playbackResources *playbackResources
|
|
viewersOnce sync.Once
|
|
viewers *viewerManager
|
|
embyMu sync.Mutex
|
|
embyKey []byte
|
|
embySyncOnce sync.Once
|
|
embySync *embySyncManager
|
|
dramaRefreshes map[string]*dramaRefreshCall
|
|
dramaRefreshSlots chan struct{}
|
|
coverImages coverImageCache
|
|
coverRepairs map[string]*coverRepairCall
|
|
coverRepairSlots chan struct{}
|
|
}
|
|
type uiState struct {
|
|
Dramas []Drama `json:"dramas,omitempty"`
|
|
LoadedAt time.Time `json:"loadedAt,omitempty"`
|
|
LastError string `json:"lastError,omitempty"`
|
|
TaskOrder []string `json:"taskOrder"`
|
|
Tasks []*UITask `json:"tasks"`
|
|
MergeStates map[string]*UIMergeState `json:"merges,omitempty"`
|
|
}
|
|
|
|
type UIMergeState struct {
|
|
PlaybackTaskID string `json:"playbackTaskId,omitempty"`
|
|
DramaID string `json:"dramaId"`
|
|
DramaTitle string `json:"dramaTitle,omitempty"`
|
|
Status string `json:"status"`
|
|
Progress int `json:"progress"`
|
|
Merged int `json:"merged"`
|
|
StartEpisode int `json:"startEpisode,omitempty"`
|
|
EndEpisode int `json:"endEpisode,omitempty"`
|
|
Total int `json:"total"`
|
|
OutputPath string `json:"outputPath,omitempty"`
|
|
Detail string `json:"detail,omitempty"`
|
|
Error string `json:"error,omitempty"`
|
|
Skipped bool `json:"skipped,omitempty"`
|
|
DeleteEpisodes bool `json:"deleteEpisodes,omitempty"`
|
|
UpdatedAt time.Time `json:"updatedAt"`
|
|
}
|
|
|
|
type uiMergeResult struct {
|
|
DramaID string `json:"dramaId"`
|
|
DramaTitle string `json:"dramaTitle,omitempty"`
|
|
OK bool `json:"ok"`
|
|
Skipped bool `json:"skipped,omitempty"`
|
|
Merged int `json:"merged"`
|
|
StartEpisode int `json:"startEpisode,omitempty"`
|
|
EndEpisode int `json:"endEpisode,omitempty"`
|
|
OutputPath string `json:"outputPath,omitempty"`
|
|
Detail string `json:"detail,omitempty"`
|
|
Error string `json:"error,omitempty"`
|
|
}
|
|
|
|
type UITask struct {
|
|
ID string `json:"id"`
|
|
DramaID string `json:"dramaId"`
|
|
DramaTitle string `json:"dramaTitle"`
|
|
Episode string `json:"episode"`
|
|
Title string `json:"title"`
|
|
Status string `json:"status"`
|
|
Progress int `json:"progress"`
|
|
Error string `json:"error,omitempty"`
|
|
Path string `json:"path"`
|
|
Attempt int `json:"attempt"`
|
|
DownloadedBytes int64 `json:"downloadedBytes"`
|
|
TotalBytes int64 `json:"totalBytes"`
|
|
SpeedBytesPerSecond float64 `json:"speedBytesPerSecond"`
|
|
ElapsedSeconds int64 `json:"elapsedSeconds"`
|
|
RemainingSeconds int64 `json:"remainingSeconds"`
|
|
MediaElapsedSeconds int64 `json:"mediaElapsedSeconds"`
|
|
MediaTotalSeconds int64 `json:"mediaTotalSeconds"`
|
|
Phase string `json:"phase"`
|
|
CreatedAt time.Time `json:"createdAt"`
|
|
UpdatedAt time.Time `json:"updatedAt"`
|
|
CancelRequested bool `json:"cancelRequested,omitempty"`
|
|
RemoveRequested bool `json:"removeRequested,omitempty"`
|
|
PauseRequested bool `json:"pauseRequested,omitempty"`
|
|
Source Task `json:"task"`
|
|
}
|
|
|
|
type uiTaskView struct {
|
|
DownloadQuality int `json:"downloadQuality"`
|
|
ID string `json:"id"`
|
|
DramaID string `json:"dramaId"`
|
|
DramaTitle string `json:"dramaTitle"`
|
|
Episode string `json:"episode"`
|
|
Title string `json:"title"`
|
|
Index int `json:"index"`
|
|
Total int `json:"total"`
|
|
Status string `json:"status"`
|
|
Progress int `json:"progress"`
|
|
Error string `json:"error,omitempty"`
|
|
Path string `json:"path"`
|
|
Attempt int `json:"attempt"`
|
|
DownloadedBytes int64 `json:"downloadedBytes"`
|
|
TotalBytes int64 `json:"totalBytes"`
|
|
SpeedBytesPerSecond float64 `json:"speedBytesPerSecond"`
|
|
ElapsedSeconds int64 `json:"elapsedSeconds"`
|
|
RemainingSeconds int64 `json:"remainingSeconds"`
|
|
MediaElapsedSeconds int64 `json:"mediaElapsedSeconds"`
|
|
MediaTotalSeconds int64 `json:"mediaTotalSeconds"`
|
|
Phase string `json:"phase"`
|
|
CreatedAt time.Time `json:"createdAt"`
|
|
UpdatedAt time.Time `json:"updatedAt"`
|
|
CancelRequested bool `json:"cancelRequested,omitempty"`
|
|
RemoveRequested bool `json:"removeRequested,omitempty"`
|
|
PauseRequested bool `json:"pauseRequested,omitempty"`
|
|
ReleaseStatus string `json:"releaseStatus,omitempty"`
|
|
Playable bool `json:"playable"`
|
|
}
|
|
|
|
func NewUIApp(d *Downloader) *UIApp {
|
|
cfg := d.cfg
|
|
if cfg.OutputDir == "" {
|
|
cfg.OutputDir = defaultOutputDir()
|
|
}
|
|
if cfg.Concurrency <= 0 {
|
|
cfg.Concurrency = 1
|
|
}
|
|
a := &UIApp{
|
|
downloader: d,
|
|
cfg: cfg,
|
|
selected: map[string]bool{},
|
|
tasks: map[string]*UITask{},
|
|
merges: map[string]*UIMergeState{},
|
|
statePath: filepath.Join(cfg.dataDirectory(), "ui-state.json"),
|
|
runningCancels: map[string]context.CancelFunc{},
|
|
parsingInFlight: map[string]bool{},
|
|
parsingCancels: map[string]context.CancelFunc{},
|
|
nextOutputDir: cfg.outputDirSetting,
|
|
}
|
|
a.cond = sync.NewCond(&a.mu)
|
|
a.loadState()
|
|
a.loadLibrary()
|
|
a.startWorkers()
|
|
return a
|
|
}
|
|
|
|
func (a *UIApp) ListenAndServe(addr string) error {
|
|
if err := a.prepareBrowserViewers(); err != nil {
|
|
return err
|
|
}
|
|
defer a.stopSortMetadata()
|
|
a.embySyncer().start()
|
|
defer a.embySyncer().stop()
|
|
installer := a.downloader.ffmpegInstallation()
|
|
defer installer.stop()
|
|
go func() {
|
|
path, err := installer.ensure(context.Background())
|
|
if err != nil {
|
|
fmt.Printf("FFmpeg 准备失败：%v\n", publicError(err))
|
|
} else {
|
|
fmt.Printf("FFmpeg 已就绪：%s\n", path)
|
|
}
|
|
}()
|
|
a.mu.Lock()
|
|
a.address = addr
|
|
_ = a.saveStateLocked()
|
|
a.mu.Unlock()
|
|
|
|
defer a.closePlaybacks()
|
|
defer a.stopMergeJobs()
|
|
|
|
server := &http.Server{Addr: addr, Handler: a.routes(), ReadHeaderTimeout: 10 * time.Second}
|
|
return server.ListenAndServe()
|
|
}
|
|
|
|
func (a *UIApp) routes() http.Handler {
|
|
mux := http.NewServeMux()
|
|
mux.HandleFunc("/", a.handleIndex)
|
|
mux.Handle("/assets/", webAssets())
|
|
mux.HandleFunc("/api/ui/viewer", a.handleViewer)
|
|
mux.HandleFunc("/api/ui/viewer/legacy", a.handleViewerLegacy)
|
|
mux.HandleFunc("/api/ui/account/register", a.handleAccountRegister)
|
|
mux.HandleFunc("/api/ui/account/login", a.handleAccountLogin)
|
|
mux.HandleFunc("/api/ui/account/logout", a.handleAccountLogout)
|
|
mux.HandleFunc("/api/ui/account/password", a.handleAccountPassword)
|
|
mux.HandleFunc("/api/ui/account/import", a.handleAccountImport)
|
|
mux.HandleFunc("/api/ui/admin/settings", a.handleAdminSettings)
|
|
mux.HandleFunc("/api/ui/admin/accounts", a.handleAdminAccounts)
|
|
mux.HandleFunc("/api/ui/admin/accounts/sources", a.handleAdminAccountPermissions)
|
|
mux.HandleFunc("/api/ui/admin/accounts/permissions", a.handleAdminAccountPermissions)
|
|
mux.HandleFunc("/api/ui/dramas", a.handleDramas)
|
|
mux.HandleFunc("/api/ui/cover/repair", a.handleCoverRepair)
|
|
mux.HandleFunc("/api/ui/dramas/refresh", a.handleDramaRefresh)
|
|
mux.HandleFunc("/api/ui/vip/metadata", a.handleVIPMetadata)
|
|
mux.HandleFunc("/api/ui/search", a.handleLibrarySearch)
|
|
mux.HandleFunc("/api/ui/following", a.handleFollowing)
|
|
mux.HandleFunc("/api/ui/rankings", a.handleRankings)
|
|
mux.HandleFunc("/api/ui/recommendations", a.handleRecommendations)
|
|
mux.HandleFunc("/api/ui/download", a.handleDownload)
|
|
mux.HandleFunc("/api/ui/tasks", a.handleTasks)
|
|
mux.HandleFunc("/api/ui/update", a.handleUpdate)
|
|
mux.HandleFunc("/api/ui/tasks/retry", a.handleRetry)
|
|
mux.HandleFunc("/api/ui/tasks/cancel", a.handleCancel)
|
|
mux.HandleFunc("/api/ui/tasks/pause", a.handlePause)
|
|
mux.HandleFunc("/api/ui/tasks/resume", a.handleResume)
|
|
mux.HandleFunc("/api/ui/tasks/clear", a.handleClear)
|
|
mux.HandleFunc("/api/ui/merge", a.handleMerge)
|
|
mux.HandleFunc("/api/ui/merge/cancel", a.handleMergeCancel)
|
|
mux.HandleFunc("/api/ui/ffmpeg", a.handleFFmpeg)
|
|
mux.HandleFunc("/api/ui/config", a.handleConfig)
|
|
mux.HandleFunc("/api/ui/network/check", a.handleNetworkCheck)
|
|
mux.HandleFunc("/api/ui/directory/pick", a.handleDirectoryPicker)
|
|
mux.HandleFunc("/api/ui/image", a.handleImage)
|
|
mux.HandleFunc("/api/ui/admin/emby", a.handleEmbySyncSettings)
|
|
mux.HandleFunc("/api/ui/admin/emby/sync", a.handleEmbySyncNow)
|
|
mux.HandleFunc("/api/emby/export", a.handleEmbyExport)
|
|
mux.HandleFunc("/api/emby/cover", a.handleEmbyCover)
|
|
mux.HandleFunc("/api/emby/stream.m3u8", a.handleEmbyStream)
|
|
mux.HandleFunc("/api/emby/segment.ts", a.handleEmbySegment)
|
|
a.registerPlaybackRoutes(mux)
|
|
return a.withAccountAccess(a.withBrowserViewer(mux))
|
|
}
|
|
|
|
func (a *UIApp) startWorkers() {
|
|
a.mu.Lock()
|
|
defer a.mu.Unlock()
|
|
a.ensureWorkersLocked()
|
|
}
|
|
|
|
func (a *UIApp) ensureWorkersLocked() {
|
|
for a.workerCount < a.cfg.Concurrency {
|
|
a.workerCount++
|
|
go a.worker()
|
|
}
|
|
}
|
|
|
|
func (a *UIApp) worker() {
|
|
for {
|
|
a.mu.Lock()
|
|
var task *UITask
|
|
for task == nil && !a.closed {
|
|
if a.activeDownloads >= a.cfg.Concurrency {
|
|
a.cond.Wait()
|
|
continue
|
|
}
|
|
for _, id := range a.taskOrder {
|
|
candidate := a.tasks[id]
|
|
if candidate != nil && candidate.Status == uiStatusQueued {
|
|
task = candidate
|
|
break
|
|
}
|
|
}
|
|
if task == nil && !a.closed {
|
|
a.cond.Wait()
|
|
}
|
|
}
|
|
if a.closed {
|
|
a.mu.Unlock()
|
|
return
|
|
}
|
|
|
|
now := time.Now()
|
|
a.activeDownloads++
|
|
task.Status = uiStatusRunning
|
|
task.Progress = 0
|
|
task.Error = ""
|
|
task.CancelRequested = false
|
|
task.PauseRequested = false
|
|
task.SpeedBytesPerSecond = 0
|
|
task.DownloadedBytes = 0
|
|
task.ElapsedSeconds = 0
|
|
task.MediaElapsedSeconds = 0
|
|
task.RemainingSeconds = 0
|
|
task.Phase = "starting"
|
|
task.Attempt++
|
|
task.UpdatedAt = now
|
|
taskID := task.ID
|
|
downloadTask := task.Source
|
|
ctx, cancel := context.WithTimeout(context.Background(), uiTaskTimeout(downloadTask))
|
|
a.runningCancels[taskID] = cancel
|
|
_ = a.saveStateLocked()
|
|
a.mu.Unlock()
|
|
|
|
err := a.downloader.DownloadEpisodeWithProgress(ctx, downloadTask, func(p DownloadProgress) {
|
|
a.mu.Lock()
|
|
current := a.tasks[taskID]
|
|
if current != nil && current.Status == uiStatusRunning {
|
|
current.Progress = p.Percent
|
|
current.DownloadedBytes = p.DownloadedBytes
|
|
current.TotalBytes = p.TotalBytes
|
|
current.SpeedBytesPerSecond = p.SpeedBytesPerSecond
|
|
current.ElapsedSeconds = int64(p.Elapsed / time.Second)
|
|
current.RemainingSeconds = int64(p.Remaining / time.Second)
|
|
current.MediaElapsedSeconds = int64(p.MediaElapsed / time.Second)
|
|
current.MediaTotalSeconds = int64(p.MediaTotal / time.Second)
|
|
current.Phase = p.Phase
|
|
current.UpdatedAt = time.Now()
|
|
}
|
|
a.mu.Unlock()
|
|
})
|
|
cancel()
|
|
|
|
a.mu.Lock()
|
|
a.activeDownloads--
|
|
delete(a.runningCancels, taskID)
|
|
current := a.tasks[taskID]
|
|
if current != nil && current.Status == uiStatusRunning {
|
|
current.UpdatedAt = time.Now()
|
|
current.RemainingSeconds = 0
|
|
current.SpeedBytesPerSecond = 0
|
|
if current.PauseRequested && !current.RemoveRequested {
|
|
current.Status = uiStatusPaused
|
|
current.PauseRequested = false
|
|
current.CancelRequested = false
|
|
current.Error = ""
|
|
current.Phase = "paused"
|
|
} else if current.CancelRequested || errors.Is(err, context.Canceled) {
|
|
current.Status = uiStatusCanceled
|
|
current.Progress = 0
|
|
current.Error = "已取消"
|
|
current.Phase = "canceled"
|
|
} else if err != nil {
|
|
current.Status = uiStatusFailed
|
|
current.Progress = 0
|
|
if errors.Is(err, context.DeadlineExceeded) {
|
|
current.Error = "下载任务超时，已自动失败，可稍后重试"
|
|
} else {
|
|
current.Error = a.redactError(err)
|
|
}
|
|
current.Phase = "failed"
|
|
} else {
|
|
current.Status = uiStatusSuccess
|
|
current.Progress = 100
|
|
current.Error = ""
|
|
current.Phase = "completed"
|
|
if st, statErr := os.Stat(current.Path); statErr == nil && !st.IsDir() {
|
|
current.DownloadedBytes = st.Size()
|
|
if current.TotalBytes <= 0 {
|
|
current.TotalBytes = st.Size()
|
|
}
|
|
}
|
|
}
|
|
if current.RemoveRequested {
|
|
a.removeTaskLocked(taskID)
|
|
}
|
|
_ = a.saveStateLocked()
|
|
}
|
|
a.mu.Unlock()
|
|
a.cond.Broadcast()
|
|
if err == nil {
|
|
a.notifyEmbySync()
|
|
}
|
|
}
|
|
}
|
|
|
|
func (a *UIApp) migrateTaskPathLocked(task *UITask) bool {
|
|
if task == nil {
|
|
return false
|
|
}
|
|
if task.Path != "" || task.Source.OutPath != "" {
|
|
return false
|
|
}
|
|
index := task.Source.Index
|
|
if index <= 0 {
|
|
index = episodeNumber(task.Episode)
|
|
}
|
|
if index <= 0 {
|
|
return false
|
|
}
|
|
title := strings.TrimSpace(task.DramaTitle)
|
|
if title == "" {
|
|
title = strings.TrimSpace(task.Source.DramaTitle)
|
|
}
|
|
if title == "" {
|
|
return false
|
|
}
|
|
dramaID := strings.TrimSpace(task.DramaID)
|
|
if dramaID == "" {
|
|
dramaID = strings.TrimSpace(task.Source.DramaID)
|
|
}
|
|
dramaDir := filepath.Join(a.cfg.OutputDir, safeFilename(title))
|
|
markerPath := filepath.Join(dramaDir, ".drama-id")
|
|
if marker, err := os.ReadFile(markerPath); err == nil && strings.TrimSpace(string(marker)) != "" && dramaID != "" && strings.TrimSpace(string(marker)) != dramaID {
|
|
dramaDir = filepath.Join(a.cfg.OutputDir, safeFilename(title+"_"+hashShort(dramaID)))
|
|
markerPath = filepath.Join(dramaDir, ".drama-id")
|
|
}
|
|
if err := os.MkdirAll(dramaDir, 0o755); err != nil {
|
|
return false
|
|
}
|
|
if dramaID != "" {
|
|
_ = os.WriteFile(markerPath, []byte(dramaID), 0o644)
|
|
}
|
|
newPath := filepath.Join(dramaDir, fmt.Sprintf("%03d.mp4", index))
|
|
task.Path = newPath
|
|
task.Source.OutPath = newPath
|
|
task.DramaID = dramaID
|
|
task.Source.DramaID = dramaID
|
|
task.DramaTitle = title
|
|
task.Source.DramaTitle = title
|
|
return true
|
|
}
|
|
|
|
func episodeNumber(value string) int {
|
|
value = strings.TrimSpace(value)
|
|
if n, err := strconv.Atoi(value); err == nil && n > 0 {
|
|
return n
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func isInvalidPersistedProviderTask(task *UITask) bool {
|
|
if task == nil {
|
|
return false
|
|
}
|
|
providerTask := isHuangguoProviderSource(task.Source.Chapter.Source)
|
|
if !providerTask {
|
|
_, _, providerTask = splitProviderDramaID(task.DramaID)
|
|
}
|
|
if !providerTask {
|
|
_, _, providerTask = splitProviderDramaID(task.Source.DramaID)
|
|
}
|
|
if !providerTask {
|
|
return false
|
|
}
|
|
total := task.Source.Total
|
|
if total <= 0 || total > 300 {
|
|
return false
|
|
}
|
|
ep := episodeNumber(task.Episode)
|
|
if ep <= 0 {
|
|
ep = episodeNumber(task.Source.Chapter.EpisodeString(task.Source.Index))
|
|
}
|
|
return ep > total
|
|
}
|
|
|
|
func (a *UIApp) loadState() {
|
|
b, err := os.ReadFile(a.statePath)
|
|
if err != nil {
|
|
if !errors.Is(err, os.ErrNotExist) {
|
|
a.lastError = a.redactString(err.Error())
|
|
}
|
|
return
|
|
}
|
|
var state uiState
|
|
if err := json.Unmarshal(b, &state); err != nil {
|
|
a.lastError = a.redactString(err.Error())
|
|
return
|
|
}
|
|
|
|
a.mu.Lock()
|
|
defer a.mu.Unlock()
|
|
a.dramas = append([]Drama(nil), state.Dramas...)
|
|
a.normalizeDramaCovers(a.dramas)
|
|
a.loadedAt = state.LoadedAt
|
|
a.lastError = a.redactString(state.LastError)
|
|
if state.MergeStates != nil {
|
|
a.merges = state.MergeStates
|
|
}
|
|
seen := map[string]bool{}
|
|
changed := false
|
|
for _, state := range a.merges {
|
|
if state != nil && (state.Status == "running" || state.Status == "queued") {
|
|
state.Status, state.Detail, state.Error = "failed", "", "服务已重启，合并已中断；原分集已保留，可重新合并"
|
|
changed = true
|
|
}
|
|
}
|
|
for _, task := range state.Tasks {
|
|
if task == nil || task.RemoveRequested {
|
|
changed = true
|
|
continue
|
|
}
|
|
if task.PauseRequested {
|
|
task.Status = uiStatusPaused
|
|
task.Phase = "paused"
|
|
task.PauseRequested = false
|
|
task.CancelRequested = false
|
|
changed = true
|
|
}
|
|
if task.Status == uiStatusRunning || task.Status == "" {
|
|
task.Status = uiStatusQueued
|
|
task.Progress = 0
|
|
task.CancelRequested = false
|
|
task.SpeedBytesPerSecond = 0
|
|
task.RemainingSeconds = 0
|
|
task.Phase = "queued"
|
|
task.UpdatedAt = time.Now()
|
|
changed = true
|
|
}
|
|
if task.Status == uiStatusParsing || task.Phase == "parsing" {
|
|
task.Status = uiStatusFailed
|
|
task.Title = "章节获取失败"
|
|
task.Progress = 0
|
|
task.Error = "上次章节解析中断，请点击重试重新获取章节"
|
|
task.Phase = "failed"
|
|
source := firstNonEmpty(task.Source.Chapter.Source, sourceFromDramaID(task.DramaID), sourceFromDramaID(task.Source.DramaID), "unknown")
|
|
sourceID := firstNonEmpty(task.Source.DramaID, task.DramaID)
|
|
if _, parsedID, ok := splitProviderDramaID(sourceID); ok {
|
|
sourceID = parsedID
|
|
}
|
|
task.Source.Chapter.Source = source
|
|
task.Source.Chapter.ID = providerChapterID(source, sourceID, "fetch-failed")
|
|
task.Source.Chapter.Title = "章节处理中"
|
|
task.UpdatedAt = time.Now()
|
|
changed = true
|
|
}
|
|
if task.Path == "" {
|
|
task.Path = task.Source.OutPath
|
|
changed = true
|
|
}
|
|
if task.Source.OutPath == "" {
|
|
task.Source.OutPath = task.Path
|
|
changed = true
|
|
}
|
|
if isInvalidPersistedProviderTask(task) {
|
|
changed = true
|
|
continue
|
|
}
|
|
if !isFetchFailedPlaceholderTask(task) {
|
|
if a.migrateTaskPathLocked(task) {
|
|
changed = true
|
|
}
|
|
}
|
|
if newID := uiTaskID(task.Path); newID != "" && task.ID != newID {
|
|
task.ID = newID
|
|
changed = true
|
|
}
|
|
if task.Status == uiStatusRunning || task.Status == "" {
|
|
task.Status = uiStatusQueued
|
|
task.Progress = 0
|
|
task.CancelRequested = false
|
|
task.SpeedBytesPerSecond = 0
|
|
task.RemainingSeconds = 0
|
|
task.Phase = "queued"
|
|
task.UpdatedAt = time.Now()
|
|
changed = true
|
|
}
|
|
task.Error = a.redactString(task.Error)
|
|
if task.CreatedAt.IsZero() {
|
|
task.CreatedAt = time.Now()
|
|
changed = true
|
|
}
|
|
if task.UpdatedAt.IsZero() {
|
|
task.UpdatedAt = task.CreatedAt
|
|
changed = true
|
|
}
|
|
if task.ID != "" && !seen[task.ID] {
|
|
seen[task.ID] = true
|
|
a.tasks[task.ID] = task
|
|
}
|
|
}
|
|
for _, id := range state.TaskOrder {
|
|
if a.tasks[id] != nil && seen[id] {
|
|
a.taskOrder = append(a.taskOrder, id)
|
|
seen[id] = false
|
|
}
|
|
}
|
|
ids := make([]string, 0, len(a.tasks))
|
|
for id := range a.tasks {
|
|
if seen[id] {
|
|
ids = append(ids, id)
|
|
}
|
|
}
|
|
sort.Strings(ids)
|
|
a.taskOrder = append(a.taskOrder, ids...)
|
|
if changed {
|
|
_ = a.saveStateLocked()
|
|
}
|
|
}
|
|
|
|
func (a *UIApp) saveStateLocked() error {
|
|
directory := filepath.Dir(a.statePath)
|
|
if err := os.MkdirAll(directory, 0o755); err != nil {
|
|
a.lastError = a.redactString(err.Error())
|
|
return err
|
|
}
|
|
state := uiState{
|
|
LoadedAt: a.loadedAt,
|
|
LastError: a.lastError,
|
|
TaskOrder: append([]string(nil), a.taskOrder...),
|
|
Tasks: make([]*UITask, 0, len(a.tasks)),
|
|
MergeStates: cloneMergeStates(a.merges),
|
|
}
|
|
if !a.librarySaved {
|
|
state.Dramas = append([]Drama(nil), a.dramas...)
|
|
}
|
|
for _, id := range a.taskOrder {
|
|
if task := a.tasks[id]; task != nil {
|
|
state.Tasks = append(state.Tasks, task)
|
|
}
|
|
}
|
|
tmp, err := os.CreateTemp(directory, ".ui-state-*.tmp")
|
|
if err != nil {
|
|
a.lastError = a.redactString(err.Error())
|
|
return err
|
|
}
|
|
tmpName := tmp.Name()
|
|
enc := json.NewEncoder(tmp)
|
|
enc.SetIndent("", " ")
|
|
if err := enc.Encode(state); err != nil {
|
|
_ = tmp.Close()
|
|
_ = os.Remove(tmpName)
|
|
a.lastError = a.redactString(err.Error())
|
|
return err
|
|
}
|
|
if err := tmp.Close(); err != nil {
|
|
_ = os.Remove(tmpName)
|
|
a.lastError = a.redactString(err.Error())
|
|
return err
|
|
}
|
|
if err := os.Rename(tmpName, a.statePath); err != nil {
|
|
_ = os.Remove(tmpName)
|
|
a.lastError = a.redactString(err.Error())
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (a *UIApp) handleIndex(w http.ResponseWriter, r *http.Request) {
|
|
if r.URL.Path != "/" && r.URL.Path != "/login" {
|
|
http.NotFound(w, r)
|
|
return
|
|
}
|
|
if r.Method != http.MethodGet {
|
|
writeJSON(w, http.StatusMethodNotAllowed, map[string]string{"error": "method not allowed"})
|
|
return
|
|
}
|
|
w.Header().Set("Content-Type", "text/html; charset=utf-8")
|
|
w.Header().Set("Cache-Control", "no-store")
|
|
_, _ = w.Write([]byte(uiHTML))
|
|
}
|
|
|
|
func (a *UIApp) handleDramas(w http.ResponseWriter, r *http.Request) {
|
|
if r.Method != http.MethodGet {
|
|
writeJSON(w, http.StatusMethodNotAllowed, map[string]string{"error": "method not allowed"})
|
|
return
|
|
}
|
|
refresh := r.URL.Query().Get("refresh") == "1"
|
|
more := r.URL.Query().Get("more") == "1"
|
|
update := r.URL.Query().Get("update") == "1"
|
|
if refresh && more || update && (refresh || more) {
|
|
writeJSON(w, http.StatusBadRequest, map[string]string{"error": "更新操作不能同时指定多个模式"})
|
|
return
|
|
}
|
|
source := r.URL.Query().Get("source")
|
|
switch source {
|
|
case "", "huangguo", "cloudfront", sourceHuangguoAI, sourceHuangguoVideo, sourceHuangdou, sourceHongguo:
|
|
default:
|
|
writeJSON(w, http.StatusBadRequest, map[string]string{"error": "不支持刷新该站源"})
|
|
return
|
|
}
|
|
if source != "" && !requireSource(w, r.Context(), source) {
|
|
return
|
|
}
|
|
var priority []string
|
|
if raw := r.URL.Query().Get("priority"); (update || more) && raw != "" {
|
|
priority = strings.Split(raw, ",")
|
|
if len(raw) > 6000 || len(priority) > sortMetadataBatchSize {
|
|
writeJSON(w, http.StatusBadRequest, map[string]string{"error": "优先补齐条目过多"})
|
|
return
|
|
}
|
|
for _, id := range priority {
|
|
if len(id) > 120 {
|
|
writeJSON(w, http.StatusBadRequest, map[string]string{"error": "无效的剧集 ID"})
|
|
return
|
|
}
|
|
}
|
|
}
|
|
if !a.requireDramaSources(w, r, priority) {
|
|
return
|
|
}
|
|
a.mu.Lock()
|
|
updateAccepted := update && a.libraryLoading == nil
|
|
if a.libraryLoading == nil && (update || refresh || more || len(a.dramas) == 0 && !a.libraryAttempted) {
|
|
mode := libraryLoadRefresh
|
|
if update {
|
|
mode = libraryLoadUpdate
|
|
} else if more {
|
|
mode = libraryLoadMore
|
|
}
|
|
a.startLibraryLoadLocked(source, mode, priority, r.Context())
|
|
}
|
|
revision, _ := strconv.ParseUint(r.URL.Query().Get("revision"), 10, 64)
|
|
resp := a.librarySnapshotForSourceLocked(r.Context(), revision)
|
|
if update {
|
|
resp["updateAccepted"] = updateAccepted
|
|
}
|
|
a.mu.Unlock()
|
|
writeJSON(w, http.StatusOK, resp)
|
|
}
|
|
|
|
func (a *UIApp) normalizeDramaCovers(dramas []Drama) {
|
|
for i := range dramas {
|
|
normalizeDramaCover(&dramas[i])
|
|
}
|
|
}
|
|
|
|
func normalizeDramaCover(drama *Drama) {
|
|
drama.OnlineDate = normalizeDate(drama.OnlineDate)
|
|
drama.Views = normalizeViews(drama.Views)
|
|
if p := bestDramaCover(*drama); p != "" {
|
|
drama.Cover = "/api/ui/image?url=" + url.QueryEscape(p)
|
|
}
|
|
}
|
|
|
|
func bestDramaCover(dr Drama) string {
|
|
for _, v := range []any{dr.CoverURL, dr.CoverURLSnake, dr.Cover, dr.ImageURL, dr.ImageURLSnake, dr.Image, dr.Img, dr.Pic, dr.Picture, dr.Poster, dr.Thumb, dr.Thumbnail} {
|
|
if p := coverPathFromAny(v); p != "" {
|
|
return p
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func coverPathFromAny(v any) string {
|
|
switch x := v.(type) {
|
|
case nil:
|
|
return ""
|
|
case string:
|
|
s := strings.TrimSpace(x)
|
|
if s == "" {
|
|
return ""
|
|
}
|
|
if strings.HasPrefix(s, "/api/ui/image") {
|
|
if u, err := url.Parse(s); err == nil {
|
|
if raw := strings.TrimSpace(u.Query().Get("url")); raw != "" {
|
|
return raw
|
|
}
|
|
}
|
|
}
|
|
if u, err := url.Parse(s); err == nil && u.IsAbs() {
|
|
return u.String()
|
|
}
|
|
return strings.TrimLeft(s, "/")
|
|
case map[string]any:
|
|
for _, key := range []string{"url", "src", "path", "cover", "coverUrl", "cover_url", "image", "pic", "poster"} {
|
|
if s := coverPathFromAny(x[key]); s != "" {
|
|
return s
|
|
}
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (a *UIApp) handleImage(w http.ResponseWriter, r *http.Request) {
|
|
w.Header().Set("Cache-Control", "no-store")
|
|
if r.Method != http.MethodGet {
|
|
writeJSON(w, http.StatusMethodNotAllowed, map[string]string{"error": "method not allowed"})
|
|
return
|
|
}
|
|
imgPath := strings.TrimSpace(r.URL.Query().Get("url"))
|
|
if imgPath == "" {
|
|
http.Error(w, "missing url", http.StatusBadRequest)
|
|
return
|
|
}
|
|
remoteURL, ok := buildImageURL(imgPath)
|
|
if !ok {
|
|
http.Error(w, "invalid image url", http.StatusBadRequest)
|
|
return
|
|
}
|
|
source, allowed := a.imageSource(r.Context(), remoteURL)
|
|
if !allowed {
|
|
writeSourceDenied(w)
|
|
return
|
|
}
|
|
ctx, cancel := context.WithTimeout(context.WithValue(r.Context(), coverSourceKey{}, source), 90*time.Second)
|
|
defer cancel()
|
|
buf, err := a.loadCoverImage(ctx, remoteURL, decodeImageBytes)
|
|
if err != nil {
|
|
if r.Context().Err() == nil {
|
|
remote, _ := url.Parse(remoteURL)
|
|
a.downloader.recordDiagnostic(diagnosticEvent{Event: "cover.failed", Host: remote.Hostname(), Message: a.redactError(err)})
|
|
}
|
|
http.Error(w, a.redactError(err), http.StatusBadGateway)
|
|
return
|
|
}
|
|
w.Header().Set("Content-Type", imageContentType(buf))
|
|
w.Header().Set("X-Content-Type-Options", "nosniff")
|
|
w.Header().Set("Cache-Control", "private, max-age=86400")
|
|
if sourceScopeRestricted(r.Context()) {
|
|
w.Header().Set("Cache-Control", "private, no-store")
|
|
}
|
|
w.WriteHeader(http.StatusOK)
|
|
_, _ = w.Write(buf)
|
|
}
|
|
|
|
func buildImageURL(imgPath string) (string, bool) {
|
|
imgPath = strings.TrimSpace(imgPath)
|
|
if imgPath == "" {
|
|
return "", false
|
|
}
|
|
if u, err := url.Parse(imgPath); err == nil && u.IsAbs() {
|
|
if !validImageURL(u) {
|
|
return "", false
|
|
}
|
|
return u.String(), true
|
|
}
|
|
imgPath = strings.TrimLeft(imgPath, "/")
|
|
if imgPath == "" || strings.Contains(imgPath, "..") || strings.Contains(imgPath, "://") {
|
|
return "", false
|
|
}
|
|
if strings.HasPrefix(imgPath, "upload_01/") || strings.HasPrefix(imgPath, "upload/") {
|
|
return "https://pic.zdmhyg.cn/" + imgPath, true
|
|
}
|
|
return "https://zzzznnn.lkkwip.cn/" + imgPath, true
|
|
}
|
|
|
|
func isHuangguoImageCDNHost(host string) bool {
|
|
host = strings.ToLower(strings.TrimSpace(host))
|
|
return host == "pic.tuafjz.cn" || strings.HasSuffix(host, ".zdmhyg.cn")
|
|
}
|
|
|
|
func sourceCoverReferer(source, remoteURL string) string {
|
|
switch source {
|
|
case sourceHongguo:
|
|
return hongguoBaseURL + "/"
|
|
case sourceHuangguoAI:
|
|
return "https://huangguoai.com/"
|
|
case sourceHuangguoVideo:
|
|
return "https://huangguo.video/"
|
|
case sourceHuangdou:
|
|
if remote, err := url.Parse(remoteURL); err == nil {
|
|
host := strings.ToLower(remote.Hostname())
|
|
if host == "tideember.cc" || host == "xqjurgek.top" {
|
|
return remote.Scheme + "://" + remote.Host + "/home"
|
|
}
|
|
}
|
|
return huangdouBaseURL + "/home"
|
|
}
|
|
return imageReferer(remoteURL)
|
|
}
|
|
|
|
func imageReferer(remoteURL string) string {
|
|
if u, err := url.Parse(remoteURL); err == nil {
|
|
if isHuangguoImageCDNHost(u.Hostname()) {
|
|
return "https://huangguoai.com/"
|
|
}
|
|
switch strings.ToLower(u.Hostname()) {
|
|
case "huangguoai.com", "www.huangguoai.com":
|
|
return "https://huangguoai.com/"
|
|
case "huangguo.video", "cdn.huangguo.video":
|
|
return "https://huangguo.video/"
|
|
case "tideember.cc", "xqjurgek.top":
|
|
return u.Scheme + "://" + u.Host + "/home"
|
|
case "d3rorc0p4i1kyz.cloudfront.net":
|
|
return huangdouBaseURL + "/home"
|
|
}
|
|
if isHongguoImageHost(u.Hostname()) {
|
|
return hongguoBaseURL + "/"
|
|
}
|
|
}
|
|
return "https://d2pypzndaqisk.cloudfront.net/"
|
|
}
|
|
|
|
func decodeImageBytes(buf []byte, remoteURL string) []byte {
|
|
if isKnownImage(buf) {
|
|
return buf
|
|
}
|
|
if decoded := decryptHuangguoImage(buf); isKnownImage(decoded) || isHEICImage(decoded) {
|
|
return decoded
|
|
}
|
|
copyBuf := append([]byte(nil), buf...)
|
|
decryptImageHeader(copyBuf)
|
|
if isKnownImage(copyBuf) {
|
|
return copyBuf
|
|
}
|
|
return buf
|
|
}
|
|
|
|
func decryptHuangguoImage(buf []byte) []byte {
|
|
if len(buf) == 0 || len(buf)%aes.BlockSize != 0 {
|
|
return nil
|
|
}
|
|
block, err := aes.NewCipher([]byte("f5d965df75336270"))
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
out := make([]byte, len(buf))
|
|
cipher.NewCBCDecrypter(block, []byte("97b60394abc2fbe1")).CryptBlocks(out, buf)
|
|
if len(out) > 0 {
|
|
pad := int(out[len(out)-1])
|
|
if pad > 0 && pad <= aes.BlockSize && pad <= len(out) {
|
|
valid := true
|
|
for _, b := range out[len(out)-pad:] {
|
|
if int(b) != pad {
|
|
valid = false
|
|
break
|
|
}
|
|
}
|
|
if valid {
|
|
out = out[:len(out)-pad]
|
|
}
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
func decryptImageHeader(buf []byte) {
|
|
key := []byte("2019ysapp7527")
|
|
limit := len(buf)
|
|
if limit > 100 {
|
|
limit = 100
|
|
}
|
|
for i := 0; i < limit; i++ {
|
|
buf[i] ^= key[i%len(key)]
|
|
}
|
|
}
|
|
|
|
func imageContentType(buf []byte) string {
|
|
if len(buf) >= 12 && buf[0] == 'R' && buf[1] == 'I' && buf[2] == 'F' && buf[3] == 'F' && buf[8] == 'W' && buf[9] == 'E' && buf[10] == 'B' && buf[11] == 'P' {
|
|
return "image/webp"
|
|
}
|
|
if len(buf) >= 8 && buf[0] == 0x89 && buf[1] == 0x50 && buf[2] == 0x4e && buf[3] == 0x47 {
|
|
return "image/png"
|
|
}
|
|
if len(buf) >= 3 && buf[0] == 0x47 && buf[1] == 0x49 && buf[2] == 0x46 {
|
|
return "image/gif"
|
|
}
|
|
if len(buf) >= 2 && buf[0] == 0xff && buf[1] == 0xd8 {
|
|
return "image/jpeg"
|
|
}
|
|
return http.DetectContentType(buf)
|
|
}
|
|
|
|
func isKnownImage(buf []byte) bool {
|
|
return imageContentType(buf) == "image/jpeg" || imageContentType(buf) == "image/png" || imageContentType(buf) == "image/gif" || imageContentType(buf) == "image/webp"
|
|
}
|
|
|
|
func (a *UIApp) handleDownload(w http.ResponseWriter, r *http.Request) {
|
|
if r.Method != http.MethodPost {
|
|
writeJSON(w, http.StatusMethodNotAllowed, map[string]string{"error": "method not allowed"})
|
|
return
|
|
}
|
|
ids, quality, ok := readDownloadRequest(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
if !a.requireDramaSources(w, r, ids) {
|
|
return
|
|
}
|
|
views := a.enqueueDramasAsync(ids, false, quality)
|
|
writeJSON(w, http.StatusAccepted, map[string]any{"data": views, "pending": true})
|
|
}
|
|
|
|
func (a *UIApp) handleUpdate(w http.ResponseWriter, r *http.Request) {
|
|
if r.Method != http.MethodPost {
|
|
writeJSON(w, http.StatusMethodNotAllowed, map[string]string{"error": "method not allowed"})
|
|
return
|
|
}
|
|
ids, quality, ok := readDownloadRequest(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
if !a.requireDramaSources(w, r, ids) {
|
|
return
|
|
}
|
|
views := a.enqueueDramasAsync(ids, true, quality)
|
|
writeJSON(w, http.StatusAccepted, map[string]any{"data": views, "pending": true})
|
|
}
|
|
|
|
func (a *UIApp) enqueueDramasAsync(ids []string, updateOnly bool, requestedQuality *int) []uiTaskView {
|
|
a.mu.Lock()
|
|
if a.parsingInFlight == nil {
|
|
a.parsingInFlight = map[string]bool{}
|
|
}
|
|
dramaByID := make(map[string]Drama, len(a.dramas))
|
|
for _, dr := range a.dramas {
|
|
if strings.TrimSpace(dr.ID) != "" {
|
|
dramaByID[dr.ID] = dr
|
|
}
|
|
}
|
|
views := make([]uiTaskView, 0, len(ids))
|
|
dramas := make([]Drama, 0, len(ids))
|
|
for _, id := range ids {
|
|
drama, found := dramaByID[id]
|
|
if !found {
|
|
drama = Drama{ID: id, Title: "短剧"}
|
|
}
|
|
dramaKey := placeholderDramaKey(drama)
|
|
if a.parsingInFlight[dramaKey] {
|
|
if view, ok := a.existingParsingPlaceholderViewLocked(drama); ok {
|
|
views = append(views, view)
|
|
}
|
|
continue
|
|
}
|
|
quality := 0
|
|
if updateOnly {
|
|
for _, taskID := range a.taskOrder {
|
|
if task := a.tasks[taskID]; task != nil && task.DramaID == drama.ID {
|
|
quality = task.Source.DownloadQuality
|
|
break
|
|
}
|
|
}
|
|
}
|
|
if requestedQuality != nil {
|
|
quality = *requestedQuality
|
|
}
|
|
dramas = append(dramas, drama)
|
|
a.parsingInFlight[dramaKey] = true
|
|
if view, changed := a.addParsingPlaceholderTaskLocked(drama, quality); view.ID != "" {
|
|
views = append(views, view)
|
|
if changed {
|
|
a.cond.Broadcast()
|
|
}
|
|
}
|
|
}
|
|
_ = a.saveStateLocked()
|
|
a.mu.Unlock()
|
|
for _, drama := range dramas {
|
|
a.startDramaParse(drama, updateOnly)
|
|
}
|
|
return views
|
|
}
|
|
|
|
func placeholderDramaKey(drama Drama) string {
|
|
if id := strings.TrimSpace(drama.ID); id != "" {
|
|
return id
|
|
}
|
|
return strings.Join([]string{strings.TrimSpace(drama.Source), strings.TrimSpace(drama.SourceID), drama.DisplayTitle()}, "|")
|
|
}
|
|
|
|
func (a *UIApp) existingParsingPlaceholderViewLocked(drama Drama) (uiTaskView, bool) {
|
|
task := a.placeholderTask(drama, "parsing")
|
|
id := uiTaskID(task.OutPath)
|
|
if existing := a.tasks[id]; existing != nil && existing.Status == uiStatusParsing && existing.Phase == "parsing" {
|
|
return taskToView(existing), true
|
|
}
|
|
return uiTaskView{}, false
|
|
}
|
|
|
|
func (a *UIApp) markParsingFinished(dramas []Drama) {
|
|
a.mu.Lock()
|
|
defer a.mu.Unlock()
|
|
if a.parsingInFlight == nil {
|
|
return
|
|
}
|
|
for _, drama := range dramas {
|
|
delete(a.parsingInFlight, placeholderDramaKey(drama))
|
|
delete(a.parsingCancels, placeholderDramaKey(drama))
|
|
}
|
|
}
|
|
|
|
func (a *UIApp) enqueueDramas(ctx context.Context, dramas []Drama, updateOnly bool, quality int) ([]uiTaskView, []uiTaskView, string) {
|
|
views := []uiTaskView{}
|
|
failedViews := []uiTaskView{}
|
|
respErr := ""
|
|
for _, drama := range dramas {
|
|
a.mu.Lock()
|
|
existingDirectory := ""
|
|
for _, id := range a.taskOrder {
|
|
if task := a.tasks[id]; task != nil && task.DramaID == drama.ID && !isChapterPlaceholderTask(task) && task.Path != "" {
|
|
existingDirectory = filepath.Dir(task.Path)
|
|
break
|
|
}
|
|
}
|
|
a.mu.Unlock()
|
|
built, err := a.downloader.buildDramaTasksInDirectory(ctx, drama, existingDirectory)
|
|
if err != nil {
|
|
msg := fmt.Sprintf("《%s》加入失败：%s", drama.DisplayTitle(), a.redactError(err))
|
|
if respErr != "" {
|
|
respErr += "\n"
|
|
}
|
|
respErr += msg
|
|
a.mu.Lock()
|
|
if a.finishCanceledParseLocked(drama) {
|
|
a.mu.Unlock()
|
|
continue
|
|
}
|
|
a.lastError = respErr
|
|
a.removeParsingPlaceholderTaskLocked(drama)
|
|
if view, changed := a.addFailedPlaceholderTaskLocked(drama, err, quality); view.ID != "" {
|
|
failedViews = append(failedViews, view)
|
|
if changed {
|
|
a.cond.Broadcast()
|
|
}
|
|
}
|
|
_ = a.saveStateLocked()
|
|
a.mu.Unlock()
|
|
continue
|
|
}
|
|
if len(built) == 0 {
|
|
msg := fmt.Sprintf("《%s》没有可下载章节", drama.DisplayTitle())
|
|
if respErr != "" {
|
|
respErr += "\n"
|
|
}
|
|
respErr += msg
|
|
a.mu.Lock()
|
|
if a.finishCanceledParseLocked(drama) {
|
|
a.mu.Unlock()
|
|
continue
|
|
}
|
|
a.lastError = respErr
|
|
a.removeParsingPlaceholderTaskLocked(drama)
|
|
if view, changed := a.addFailedPlaceholderTaskLocked(drama, errors.New("没有可下载章节"), quality); view.ID != "" {
|
|
failedViews = append(failedViews, view)
|
|
if changed {
|
|
a.cond.Broadcast()
|
|
}
|
|
}
|
|
_ = a.saveStateLocked()
|
|
a.mu.Unlock()
|
|
continue
|
|
}
|
|
|
|
a.mu.Lock()
|
|
if a.finishCanceledParseLocked(drama) {
|
|
a.mu.Unlock()
|
|
continue
|
|
}
|
|
a.removeParsingPlaceholderTaskLocked(drama)
|
|
a.removeFailedPlaceholderTaskLocked(drama)
|
|
pathIndex := a.pathIndexLocked()
|
|
now := time.Now()
|
|
changed := true
|
|
for _, task := range built {
|
|
task.DownloadQuality = quality
|
|
if existing := pathIndex[task.OutPath]; existing != nil {
|
|
task.DownloadQuality = existing.Source.DownloadQuality
|
|
if existing.Status != uiStatusRunning {
|
|
existing.Source = task
|
|
}
|
|
if existing.Status == uiStatusSuccess {
|
|
if fileOK, _ := existingGood(existing.Path, a.cfg.SkipBytes); fileOK {
|
|
views = append(views, taskToView(existing))
|
|
continue
|
|
}
|
|
if updateOnly {
|
|
existing.Status = uiStatusQueued
|
|
existing.Progress = 0
|
|
existing.Error = ""
|
|
existing.Phase = "queued"
|
|
existing.DownloadedBytes = 0
|
|
existing.TotalBytes = task.Chapter.MediaSize
|
|
existing.UpdatedAt = now
|
|
views = append(views, taskToView(existing))
|
|
changed = true
|
|
continue
|
|
}
|
|
}
|
|
views = append(views, taskToView(existing))
|
|
continue
|
|
}
|
|
uiTask := newUITask(task, now)
|
|
if ok, size := existingGood(task.OutPath, a.cfg.SkipBytes); ok {
|
|
uiTask.Status = uiStatusSuccess
|
|
uiTask.Progress = 100
|
|
uiTask.DownloadedBytes = size
|
|
if uiTask.TotalBytes <= 0 {
|
|
uiTask.TotalBytes = size
|
|
}
|
|
uiTask.Phase = "completed"
|
|
}
|
|
a.tasks[uiTask.ID] = uiTask
|
|
a.taskOrder = append(a.taskOrder, uiTask.ID)
|
|
pathIndex[uiTask.Path] = uiTask
|
|
views = append(views, taskToView(uiTask))
|
|
changed = true
|
|
}
|
|
if changed {
|
|
_ = a.saveStateLocked()
|
|
a.cond.Broadcast()
|
|
}
|
|
a.mu.Unlock()
|
|
}
|
|
return views, failedViews, respErr
|
|
}
|
|
|
|
func (a *UIApp) addParsingPlaceholderTaskLocked(drama Drama, quality int) (uiTaskView, bool) {
|
|
task := a.placeholderTask(drama, "parsing")
|
|
task.DownloadQuality = quality
|
|
uiTask := newUITask(task, time.Now())
|
|
uiTask.Status = uiStatusParsing
|
|
uiTask.Progress = 0
|
|
uiTask.Phase = "parsing"
|
|
uiTask.Title = "正在解析章节"
|
|
if existing := a.tasks[uiTask.ID]; existing != nil {
|
|
existing.Source = task
|
|
existing.Status = uiStatusParsing
|
|
existing.CancelRequested = false
|
|
existing.PauseRequested = false
|
|
existing.RemoveRequested = false
|
|
existing.Progress = 0
|
|
existing.Error = ""
|
|
existing.Phase = "parsing"
|
|
existing.Title = "正在解析章节"
|
|
existing.UpdatedAt = uiTask.UpdatedAt
|
|
return taskToView(existing), false
|
|
}
|
|
a.tasks[uiTask.ID] = uiTask
|
|
a.taskOrder = append(a.taskOrder, uiTask.ID)
|
|
return taskToView(uiTask), true
|
|
}
|
|
|
|
func (a *UIApp) removeParsingPlaceholderTaskLocked(drama Drama) {
|
|
task := a.placeholderTask(drama, "parsing")
|
|
id := uiTaskID(task.OutPath)
|
|
if id == "" {
|
|
return
|
|
}
|
|
if existing := a.tasks[id]; existing == nil || existing.Phase != "parsing" {
|
|
return
|
|
}
|
|
delete(a.tasks, id)
|
|
for i, taskID := range a.taskOrder {
|
|
if taskID == id {
|
|
a.taskOrder = append(a.taskOrder[:i], a.taskOrder[i+1:]...)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
func (a *UIApp) placeholderTask(drama Drama, suffix string) Task {
|
|
title := drama.DisplayTitle()
|
|
if title == "" {
|
|
title = "短剧"
|
|
}
|
|
dramaID := strings.TrimSpace(drama.ID)
|
|
if dramaID == "" {
|
|
dramaID = title
|
|
}
|
|
dramaDir, err := safeJoin(a.cfg.OutputDir, safeFilename(title))
|
|
if err != nil {
|
|
dramaDir = filepath.Join(a.cfg.OutputDir, safeFilename(title))
|
|
}
|
|
outPath := filepath.Join(dramaDir, ".placeholder-"+hashShort(dramaID)+".txt")
|
|
chapterSource := firstNonEmpty(drama.Source, sourceFromDramaID(dramaID), "unknown")
|
|
return Task{DramaID: dramaID, DramaTitle: title, Chapter: Chapter{ID: providerChapterID(chapterSource, firstNonEmpty(drama.SourceID, dramaID), suffix), Source: chapterSource, Title: "章节处理中", CurrentEpisode: rawEpisode(1)}, Index: 1, Total: 1, OutPath: outPath}
|
|
}
|
|
|
|
func sourceFromDramaID(id string) string {
|
|
if source, _, ok := splitProviderDramaID(id); ok {
|
|
return source
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (a *UIApp) addFailedPlaceholderTaskLocked(drama Drama, cause error, quality int) (uiTaskView, bool) {
|
|
task := a.placeholderTask(drama, "fetch-failed")
|
|
task.DownloadQuality = quality
|
|
uiTask := newUITask(task, time.Now())
|
|
uiTask.Title = "章节获取失败"
|
|
uiTask.Status = uiStatusFailed
|
|
uiTask.Progress = 0
|
|
uiTask.Error = a.redactError(cause)
|
|
uiTask.Phase = "failed"
|
|
if existing := a.tasks[uiTask.ID]; existing != nil {
|
|
existing.Source = task
|
|
existing.Status = uiStatusFailed
|
|
existing.Title = "章节获取失败"
|
|
existing.Progress = 0
|
|
existing.Error = uiTask.Error
|
|
existing.Phase = "failed"
|
|
existing.UpdatedAt = uiTask.UpdatedAt
|
|
return taskToView(existing), false
|
|
}
|
|
a.tasks[uiTask.ID] = uiTask
|
|
a.taskOrder = append(a.taskOrder, uiTask.ID)
|
|
return taskToView(uiTask), true
|
|
}
|
|
|
|
func (a *UIApp) removeFailedPlaceholderTaskLocked(drama Drama) {
|
|
task := a.placeholderTask(drama, "fetch-failed")
|
|
id := uiTaskID(task.OutPath)
|
|
if id == "" {
|
|
return
|
|
}
|
|
if existing := a.tasks[id]; existing == nil || !isFetchFailedPlaceholderTask(existing) {
|
|
return
|
|
}
|
|
delete(a.tasks, id)
|
|
for i, taskID := range a.taskOrder {
|
|
if taskID == id {
|
|
a.taskOrder = append(a.taskOrder[:i], a.taskOrder[i+1:]...)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
func isFetchFailedPlaceholderTask(task *UITask) bool {
|
|
return task != nil && task.Phase == "failed" && task.Title == "章节获取失败" && strings.Contains(task.Source.Chapter.ID, ":fetch-failed")
|
|
}
|
|
|
|
func dramaFromPlaceholderTask(task *UITask) Drama {
|
|
if task == nil {
|
|
return Drama{}
|
|
}
|
|
drama := Drama{ID: task.DramaID, Title: task.DramaTitle, Name: task.DramaTitle}
|
|
drama.Source = firstNonEmpty(task.Source.Chapter.Source, sourceFromDramaID(task.DramaID))
|
|
if _, sourceID, ok := splitProviderDramaID(task.DramaID); ok {
|
|
drama.SourceID = sourceID
|
|
} else if task.Source.Chapter.ID != "" {
|
|
parts := strings.Split(task.Source.Chapter.ID, ":")
|
|
if len(parts) >= 2 {
|
|
drama.SourceID = parts[1]
|
|
}
|
|
}
|
|
return drama
|
|
}
|
|
|
|
func (a *UIApp) handleTasks(w http.ResponseWriter, r *http.Request) {
|
|
if r.Method != http.MethodGet {
|
|
writeJSON(w, http.StatusMethodNotAllowed, map[string]string{"error": "method not allowed"})
|
|
return
|
|
}
|
|
a.mu.Lock()
|
|
views := a.taskViewsForSourceLocked(r.Context())
|
|
merges := cloneMergeStates(a.merges)
|
|
for id := range merges {
|
|
if !dramaAllowed(r.Context(), id, "") {
|
|
delete(merges, id)
|
|
continue
|
|
}
|
|
merges[id].PlaybackTaskID = ""
|
|
if _, _, err := a.mergedPlaybackTaskLocked(mergedPlaybackPrefix + id); err == nil {
|
|
merges[id].PlaybackTaskID = mergedPlaybackPrefix + id
|
|
}
|
|
}
|
|
a.mu.Unlock()
|
|
writeJSON(w, http.StatusOK, map[string]any{"data": views, "merges": merges, "ffmpeg": a.downloader.ffmpegInstallation().snapshot()})
|
|
}
|
|
|
|
func (a *UIApp) handleRetry(w http.ResponseWriter, r *http.Request) {
|
|
if r.Method != http.MethodPost {
|
|
writeJSON(w, http.StatusMethodNotAllowed, map[string]string{"error": "method not allowed"})
|
|
return
|
|
}
|
|
selection, ok := readTaskSelection(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
a.mu.Lock()
|
|
if !a.requireTaskSourcesLocked(w, r, selection) {
|
|
a.mu.Unlock()
|
|
return
|
|
}
|
|
if a.parsingInFlight == nil {
|
|
a.parsingInFlight = map[string]bool{}
|
|
}
|
|
now := time.Now()
|
|
changed := false
|
|
var reparses []Drama
|
|
for _, id := range selection.idsLocked(a) {
|
|
task := a.tasks[id]
|
|
if task == nil || task.RemoveRequested || task.Status != uiStatusFailed && task.Status != uiStatusCanceled {
|
|
continue
|
|
}
|
|
if isChapterPlaceholderTask(task) {
|
|
drama := dramaFromPlaceholderTask(task)
|
|
dramaKey := placeholderDramaKey(drama)
|
|
if a.parsingInFlight[dramaKey] {
|
|
continue
|
|
}
|
|
a.parsingInFlight[dramaKey] = true
|
|
a.removeFailedPlaceholderTaskLocked(drama)
|
|
if _, placeholderChanged := a.addParsingPlaceholderTaskLocked(drama, task.Source.DownloadQuality); placeholderChanged {
|
|
changed = true
|
|
}
|
|
reparses = append(reparses, drama)
|
|
changed = true
|
|
continue
|
|
}
|
|
task.Status = uiStatusQueued
|
|
task.Progress = 0
|
|
task.Error = ""
|
|
task.CancelRequested = false
|
|
task.PauseRequested = false
|
|
task.DownloadedBytes = 0
|
|
task.ElapsedSeconds = 0
|
|
task.MediaElapsedSeconds = 0
|
|
task.SpeedBytesPerSecond = 0
|
|
task.RemainingSeconds = 0
|
|
task.Phase = "queued"
|
|
task.UpdatedAt = now
|
|
changed = true
|
|
}
|
|
if changed {
|
|
_ = a.saveStateLocked()
|
|
a.cond.Broadcast()
|
|
}
|
|
views := a.taskViewsForSourceLocked(r.Context())
|
|
a.mu.Unlock()
|
|
for _, drama := range reparses {
|
|
a.startDramaParse(drama, true)
|
|
}
|
|
writeJSON(w, http.StatusOK, map[string]any{"data": views, "pending": len(reparses) > 0})
|
|
}
|
|
|
|
func (a *UIApp) handleCancel(w http.ResponseWriter, r *http.Request) {
|
|
if r.Method != http.MethodPost {
|
|
writeJSON(w, http.StatusMethodNotAllowed, map[string]string{"error": "method not allowed"})
|
|
return
|
|
}
|
|
selection, ok := readTaskSelection(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
a.mu.Lock()
|
|
if !a.requireTaskSourcesLocked(w, r, selection) {
|
|
a.mu.Unlock()
|
|
return
|
|
}
|
|
now := time.Now()
|
|
changed := false
|
|
for _, id := range selection.idsLocked(a) {
|
|
task := a.tasks[id]
|
|
if task == nil {
|
|
continue
|
|
}
|
|
task.PauseRequested = false
|
|
switch task.Status {
|
|
case uiStatusParsing:
|
|
task.CancelRequested = true
|
|
if cancel := a.parsingCancels[task.DramaID]; cancel != nil {
|
|
cancel()
|
|
}
|
|
changed = true
|
|
case uiStatusQueued, uiStatusPaused:
|
|
task.Status = uiStatusCanceled
|
|
task.Progress = 0
|
|
task.Error = "已取消"
|
|
task.CancelRequested = false
|
|
task.RemainingSeconds = 0
|
|
task.SpeedBytesPerSecond = 0
|
|
task.Phase = "canceled"
|
|
task.UpdatedAt = now
|
|
changed = true
|
|
case uiStatusRunning:
|
|
task.CancelRequested = true
|
|
task.UpdatedAt = now
|
|
if cancel := a.runningCancels[id]; cancel != nil {
|
|
cancel()
|
|
}
|
|
changed = true
|
|
}
|
|
}
|
|
if changed {
|
|
_ = a.saveStateLocked()
|
|
}
|
|
views := a.taskViewsForSourceLocked(r.Context())
|
|
a.mu.Unlock()
|
|
writeJSON(w, http.StatusOK, map[string]any{"data": views})
|
|
}
|
|
|
|
func (a *UIApp) handleClear(w http.ResponseWriter, r *http.Request) {
|
|
if r.Method != http.MethodPost {
|
|
writeJSON(w, http.StatusMethodNotAllowed, map[string]string{"error": "method not allowed"})
|
|
return
|
|
}
|
|
ids, ok := readIDsRequest(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
a.mu.Lock()
|
|
if !a.requireTaskSourcesLocked(w, r, taskSelection{IDs: ids}) {
|
|
a.mu.Unlock()
|
|
return
|
|
}
|
|
removed, pending := 0, 0
|
|
for _, id := range ids {
|
|
task := a.tasks[id]
|
|
if task == nil {
|
|
continue
|
|
}
|
|
if task.Status == uiStatusRunning || task.Status == uiStatusParsing {
|
|
task.RemoveRequested = true
|
|
task.CancelRequested = true
|
|
if cancel := a.runningCancels[id]; cancel != nil {
|
|
cancel()
|
|
}
|
|
if task.Status == uiStatusParsing {
|
|
if cancel := a.parsingCancels[task.DramaID]; cancel != nil {
|
|
cancel()
|
|
}
|
|
}
|
|
pending++
|
|
} else {
|
|
a.removeTaskLocked(id)
|
|
removed++
|
|
}
|
|
}
|
|
_ = a.saveStateLocked()
|
|
views := a.taskViewsForSourceLocked(r.Context())
|
|
a.mu.Unlock()
|
|
writeJSON(w, http.StatusOK, map[string]any{"data": views, "removed": removed, "pending": pending})
|
|
}
|
|
|
|
func (a *UIApp) handleMerge(w http.ResponseWriter, r *http.Request) {
|
|
if r.Method != http.MethodPost {
|
|
writeJSON(w, http.StatusMethodNotAllowed, map[string]string{"error": "method not allowed"})
|
|
return
|
|
}
|
|
ids, deleteEpisodes, async, ok := readMergeRequest(w, r)
|
|
if !ok || !requireDownload(w, r) || !a.requireDramaSources(w, r, ids) {
|
|
return
|
|
}
|
|
a.mu.Lock()
|
|
if !a.requireTaskSourcesLocked(w, r, taskSelection{DramaIDs: ids}) {
|
|
a.mu.Unlock()
|
|
return
|
|
}
|
|
jobs, err := a.enqueueMergesLocked(ids, deleteEpisodes)
|
|
a.mu.Unlock()
|
|
if err != nil {
|
|
writeJSON(w, http.StatusConflict, map[string]string{"error": a.redactError(err)})
|
|
return
|
|
}
|
|
if async {
|
|
writeJSON(w, http.StatusAccepted, map[string]any{"accepted": len(jobs), "async": true})
|
|
return
|
|
}
|
|
results := make([]uiMergeResult, 0, len(jobs))
|
|
for _, job := range jobs {
|
|
select {
|
|
case <-r.Context().Done():
|
|
return
|
|
case <-job.done:
|
|
results = append(results, job.result)
|
|
}
|
|
}
|
|
writeJSON(w, http.StatusOK, map[string]any{"data": results})
|
|
}
|
|
|
|
func (a *UIApp) mergeDrama(ctx context.Context, dramaID string, tasks []*UITask, deleteEpisodes bool) uiMergeResult {
|
|
res := uiMergeResult{DramaID: dramaID}
|
|
if len(tasks) == 0 {
|
|
res.Error = "没有已完成的分集可合并"
|
|
a.setMergeState(res, "failed", 0, false, deleteEpisodes)
|
|
return res
|
|
}
|
|
sort.SliceStable(tasks, func(i, j int) bool { return tasks[i].Source.Index < tasks[j].Source.Index })
|
|
valid := make([]*UITask, 0, len(tasks))
|
|
seenEp := map[int]bool{}
|
|
startEp, endEp := 0, 0
|
|
for _, task := range tasks {
|
|
if task == nil || task.Path == "" {
|
|
continue
|
|
}
|
|
ep := task.Source.Index
|
|
if ep <= 0 {
|
|
ep = episodeNumber(task.Episode)
|
|
}
|
|
if ep <= 0 || seenEp[ep] {
|
|
continue
|
|
}
|
|
if st, err := os.Stat(task.Path); err == nil && !st.IsDir() && st.Size() > 0 {
|
|
seenEp[ep] = true
|
|
valid = append(valid, task)
|
|
if startEp == 0 || ep < startEp {
|
|
startEp = ep
|
|
}
|
|
if ep > endEp {
|
|
endEp = ep
|
|
}
|
|
}
|
|
}
|
|
if len(valid) == 0 {
|
|
res.Error = "已完成任务的文件不存在"
|
|
a.setMergeState(res, "failed", 0, false, deleteEpisodes)
|
|
return res
|
|
}
|
|
for ep := startEp; ep <= endEp; ep++ {
|
|
if !seenEp[ep] {
|
|
res.DramaTitle = valid[0].DramaTitle
|
|
res.StartEpisode = startEp
|
|
res.EndEpisode = endEp
|
|
res.Merged = len(valid)
|
|
res.Error = fmt.Sprintf("缺少第%03d集，未执行合并", ep)
|
|
a.setMergeState(res, "failed", 0, false, deleteEpisodes)
|
|
return res
|
|
}
|
|
}
|
|
res.DramaTitle = valid[0].DramaTitle
|
|
res.Merged = len(valid)
|
|
res.StartEpisode = startEp
|
|
res.EndEpisode = endEp
|
|
dir := filepath.Dir(valid[0].Path)
|
|
outPath := filepath.Join(dir, mergeOutputName(res.DramaTitle, startEp, endEp))
|
|
res.OutputPath = outPath
|
|
if ok, _ := existingGood(outPath, a.cfg.SkipBytes); ok {
|
|
res.OK = true
|
|
res.Skipped = true
|
|
a.setMergeState(res, "success", 100, true, deleteEpisodes)
|
|
return res
|
|
}
|
|
|
|
paths := make([]string, 0, len(valid))
|
|
for _, task := range valid {
|
|
paths = append(paths, task.Path)
|
|
}
|
|
partPath := filepath.Join(dir, "."+strings.TrimSuffix(filepath.Base(outPath), filepath.Ext(outPath))+".part.mp4")
|
|
_ = os.Remove(partPath)
|
|
defer os.Remove(partPath)
|
|
cmdCtx, cancel := context.WithTimeout(ctx, 2*time.Hour)
|
|
defer cancel()
|
|
res.Detail = "正在准备 FFmpeg"
|
|
a.setMergeState(res, "running", 0, false, deleteEpisodes)
|
|
ffmpeg, err := a.downloader.ensureFFmpeg(cmdCtx)
|
|
if err != nil {
|
|
res.Error = a.redactError(err)
|
|
a.setMergeState(res, "failed", 0, false, deleteEpisodes)
|
|
return res
|
|
}
|
|
method, err := mergeMediaFiles(cmdCtx, ffmpeg, paths, partPath, func(progress int, detail string) {
|
|
res.Detail = detail
|
|
a.setMergeState(res, "running", progress, false, deleteEpisodes)
|
|
})
|
|
if err != nil {
|
|
res.Error = a.redactError(err)
|
|
a.setMergeState(res, "failed", 0, false, deleteEpisodes)
|
|
return res
|
|
}
|
|
res.Detail = method
|
|
if err := cmdCtx.Err(); err != nil {
|
|
res.Error = "合并已取消，原分集已保留"
|
|
a.setMergeState(res, "failed", 0, false, deleteEpisodes)
|
|
return res
|
|
}
|
|
if ok, _ := existingGood(partPath, a.cfg.SkipBytes); !ok {
|
|
res.Error = "合并输出文件无效"
|
|
a.setMergeState(res, "failed", 0, false, deleteEpisodes)
|
|
return res
|
|
}
|
|
if err := os.Rename(partPath, outPath); err != nil {
|
|
res.Error = a.redactError(err)
|
|
a.setMergeState(res, "failed", 0, false, deleteEpisodes)
|
|
return res
|
|
}
|
|
res.OK = true
|
|
if deleteEpisodes {
|
|
for _, task := range valid {
|
|
_ = os.Remove(task.Path)
|
|
}
|
|
}
|
|
a.setMergeState(res, "success", 100, false, deleteEpisodes)
|
|
return res
|
|
}
|
|
|
|
func cloneMergeStates(in map[string]*UIMergeState) map[string]*UIMergeState {
|
|
out := make(map[string]*UIMergeState, len(in))
|
|
for id, state := range in {
|
|
if state == nil {
|
|
continue
|
|
}
|
|
copyState := *state
|
|
out[id] = ©State
|
|
}
|
|
return out
|
|
}
|
|
|
|
func mergeOutputName(title string, start, end int) string {
|
|
if start <= 0 {
|
|
start = 1
|
|
}
|
|
if end < start {
|
|
end = start
|
|
}
|
|
return fmt.Sprintf("%s%d-%d.mp4", safeFilename(title), start, end)
|
|
}
|
|
|
|
func (a *UIApp) setMergeState(res uiMergeResult, status string, progress int, skipped, deleteEpisodes bool) {
|
|
state := &UIMergeState{
|
|
DramaID: res.DramaID, DramaTitle: res.DramaTitle, Status: status, Progress: progress,
|
|
Merged: res.Merged, StartEpisode: res.StartEpisode, EndEpisode: res.EndEpisode,
|
|
Total: res.Merged, OutputPath: res.OutputPath, Detail: res.Detail, Error: res.Error, Skipped: skipped,
|
|
DeleteEpisodes: deleteEpisodes, UpdatedAt: time.Now(),
|
|
}
|
|
a.mu.Lock()
|
|
if a.merges == nil {
|
|
a.merges = map[string]*UIMergeState{}
|
|
}
|
|
a.merges[res.DramaID] = state
|
|
_ = a.saveStateLocked()
|
|
a.mu.Unlock()
|
|
}
|
|
|
|
func readMergeRequest(w http.ResponseWriter, r *http.Request) ([]string, bool, bool, bool) {
|
|
var req struct {
|
|
Async bool `json:"async"`
|
|
DramaIDs []string `json:"dramaIds"`
|
|
DeleteEpisodes bool `json:"deleteEpisodes"`
|
|
}
|
|
r.Body = http.MaxBytesReader(w, r.Body, 1<<20)
|
|
dec := json.NewDecoder(r.Body)
|
|
dec.DisallowUnknownFields()
|
|
if err := dec.Decode(&req); err != nil {
|
|
writeJSON(w, http.StatusBadRequest, map[string]string{"error": "invalid json: " + err.Error()})
|
|
return nil, false, false, false
|
|
}
|
|
ids, ok := cleanIDList(w, req.DramaIDs)
|
|
return ids, req.DeleteEpisodes, req.Async, ok
|
|
}
|
|
|
|
func (a *UIApp) handleConfig(w http.ResponseWriter, r *http.Request) {
|
|
if r.Method == http.MethodPost {
|
|
if !a.updateRuntimeSettings(w, r) {
|
|
return
|
|
}
|
|
} else if r.Method != http.MethodGet {
|
|
writeJSON(w, http.StatusMethodNotAllowed, map[string]string{"error": "method not allowed"})
|
|
return
|
|
}
|
|
a.mu.Lock()
|
|
addr := a.address
|
|
cfg := a.cfg
|
|
nextOutputDir := firstNonEmpty(a.nextOutputDir, cfg.outputDirSetting, cfg.OutputDir)
|
|
a.mu.Unlock()
|
|
proxyMode, proxyURL, proxyHasAuth := publicProxyConfig(cfg.ProxyURL)
|
|
writeJSON(w, http.StatusOK, map[string]any{"outputDir": cfg.OutputDir, "outputDirSetting": nextOutputDir, "restartRequired": !sameDirectory(cfg.OutputDir, nextOutputDir), "dataDir": cfg.dataDirectory(), "concurrency": cfg.Concurrency, "ffmpeg": cfg.FFmpeg, "address": addr, "libraryCachePath": libraryCachePath(cfg.dataDirectory()), "requestConcurrency": cfg.RequestConcurrency, "requestIntervalMs": cfg.RequestIntervalMS, "network": a.downloader.proxyRouter.summary(), "proxyMode": proxyMode, "proxyURL": proxyURL, "proxyHasAuth": proxyHasAuth})
|
|
}
|
|
|
|
func readIDsRequest(w http.ResponseWriter, r *http.Request) ([]string, bool) {
|
|
var req struct {
|
|
IDs []string `json:"ids"`
|
|
}
|
|
r.Body = http.MaxBytesReader(w, r.Body, 1<<20)
|
|
dec := json.NewDecoder(r.Body)
|
|
dec.DisallowUnknownFields()
|
|
if err := dec.Decode(&req); err != nil {
|
|
writeJSON(w, http.StatusBadRequest, map[string]string{"error": "invalid json: " + err.Error()})
|
|
return nil, false
|
|
}
|
|
return cleanIDList(w, req.IDs)
|
|
}
|
|
|
|
func readDramaIDsRequest(w http.ResponseWriter, r *http.Request) ([]string, bool) {
|
|
var req struct {
|
|
DramaIDs []string `json:"dramaIds"`
|
|
}
|
|
r.Body = http.MaxBytesReader(w, r.Body, 1<<20)
|
|
dec := json.NewDecoder(r.Body)
|
|
dec.DisallowUnknownFields()
|
|
if err := dec.Decode(&req); err != nil {
|
|
writeJSON(w, http.StatusBadRequest, map[string]string{"error": "invalid json: " + err.Error()})
|
|
return nil, false
|
|
}
|
|
return cleanIDList(w, req.DramaIDs)
|
|
}
|
|
|
|
func cleanIDList(w http.ResponseWriter, in []string) ([]string, bool) {
|
|
seen := map[string]bool{}
|
|
ids := make([]string, 0, len(in))
|
|
for _, id := range in {
|
|
id = strings.TrimSpace(id)
|
|
if id == "" || seen[id] {
|
|
continue
|
|
}
|
|
seen[id] = true
|
|
ids = append(ids, id)
|
|
}
|
|
if len(ids) == 0 {
|
|
writeJSON(w, http.StatusBadRequest, map[string]string{"error": "ids is required"})
|
|
return nil, false
|
|
}
|
|
return ids, true
|
|
}
|
|
|
|
func writeJSON(w http.ResponseWriter, status int, v any) {
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(status)
|
|
_ = json.NewEncoder(w).Encode(v)
|
|
}
|
|
|
|
func uiTaskTimeout(task Task) time.Duration {
|
|
total := task.Total
|
|
if total <= 0 {
|
|
total = 1
|
|
}
|
|
|
|
timeout := time.Duration(20+total*3) * time.Minute
|
|
if timeout < 30*time.Minute {
|
|
return 30 * time.Minute
|
|
}
|
|
if timeout > 2*time.Hour {
|
|
return 2 * time.Hour
|
|
}
|
|
return timeout
|
|
}
|
|
|
|
func newUITask(task Task, now time.Time) *UITask {
|
|
episode := task.Chapter.EpisodeString(task.Index)
|
|
title := strings.TrimSpace(task.Chapter.Title)
|
|
if title == "" || strings.TrimSpace(title) == strings.TrimSpace(episode) {
|
|
title = "第" + padEpisode(episode) + "集"
|
|
}
|
|
return &UITask{
|
|
ID: uiTaskID(task.OutPath), DramaID: task.DramaID, DramaTitle: task.DramaTitle,
|
|
Episode: episode, Title: title, Status: uiStatusQueued, Progress: 0,
|
|
TotalBytes: task.Chapter.MediaSize, Phase: "queued", Path: task.OutPath,
|
|
CreatedAt: now, UpdatedAt: now, Source: task,
|
|
}
|
|
}
|
|
|
|
func uiTaskID(path string) string {
|
|
path = strings.TrimSpace(path)
|
|
if path == "" {
|
|
return ""
|
|
}
|
|
sum := sha256.Sum256([]byte(path))
|
|
return hex.EncodeToString(sum[:])[:16]
|
|
}
|
|
|
|
func cloneUITask(task *UITask) *UITask {
|
|
if task == nil {
|
|
return nil
|
|
}
|
|
cp := *task
|
|
return &cp
|
|
}
|
|
|
|
func (a *UIApp) pathIndexLocked() map[string]*UITask {
|
|
out := make(map[string]*UITask, len(a.tasks))
|
|
for _, task := range a.tasks {
|
|
if task == nil {
|
|
continue
|
|
}
|
|
if task.Path != "" {
|
|
out[task.Path] = task
|
|
}
|
|
if task.Source.OutPath != "" {
|
|
out[task.Source.OutPath] = task
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
func (a *UIApp) taskViewsLocked() []uiTaskView {
|
|
views := make([]uiTaskView, 0, len(a.taskOrder))
|
|
releases := make(map[string]string, len(a.dramas))
|
|
for _, drama := range a.dramas {
|
|
releases[drama.ID] = dramaReleaseStatus(drama)
|
|
}
|
|
for _, id := range a.taskOrder {
|
|
if task := a.tasks[id]; task != nil {
|
|
view := taskToView(task)
|
|
if status := releases[task.DramaID]; status != "" {
|
|
view.ReleaseStatus = status
|
|
}
|
|
views = append(views, view)
|
|
}
|
|
}
|
|
return views
|
|
}
|
|
|
|
func taskToView(task *UITask) uiTaskView {
|
|
return uiTaskView{
|
|
ID: task.ID, DramaID: task.DramaID, DramaTitle: task.DramaTitle, Episode: task.Episode, Title: task.Title,
|
|
Index: task.Source.Index, Total: task.Source.Total, Status: task.Status, Progress: task.Progress, Error: task.Error,
|
|
Path: task.Path, Attempt: task.Attempt, DownloadedBytes: task.DownloadedBytes, TotalBytes: task.TotalBytes,
|
|
SpeedBytesPerSecond: task.SpeedBytesPerSecond, ElapsedSeconds: task.ElapsedSeconds, RemainingSeconds: task.RemainingSeconds,
|
|
MediaElapsedSeconds: task.MediaElapsedSeconds, MediaTotalSeconds: task.MediaTotalSeconds, Phase: task.Phase,
|
|
CreatedAt: task.CreatedAt, UpdatedAt: task.UpdatedAt, CancelRequested: task.CancelRequested,
|
|
RemoveRequested: task.RemoveRequested, PauseRequested: task.PauseRequested, ReleaseStatus: task.Source.ReleaseStatus,
|
|
Playable: isPlayableDownloadTask(task), DownloadQuality: task.Source.DownloadQuality,
|
|
}
|
|
}
|
|
|
|
func (a *UIApp) redactError(err error) string {
|
|
if err == nil {
|
|
return ""
|
|
}
|
|
return a.redactString(err.Error())
|
|
}
|
|
|
|
func (a *UIApp) redactString(s string) string {
|
|
return redactConfiguredString(&a.cfg, s)
|
|
}
|