35442e4aff
Four extractions, each chosen because the two halves have different callers,
different failure modes or different testing needs. Not a line-count exercise.
internal/home out of internal/media
- media serves item RESOURCES (detail, file, cover, progress); home computes
AGGREGATES (the five shelves). The 2328-line package was doing both.
- media keeps POST /items/{id}/view because it is item-scoped and must stay in
the package that authorizes the item; it imports home.RecordView for that one
thing. home does not import media.
- Verified live: all five shelves non-empty, and two consecutive /home calls
return different explore ids, which is the non-determinism the Explore rewrite
exists for.
internal/scanner out of internal/library
- The scanner walks the filesystem and reconciles; library CRUD is an admin HTTP
surface. Different callers (a job vs a request), different failure modes.
- The registry deliberately STAYED in internal/library: three of its four callers
are not the scanner (modules register types, handlers serve the list, metadata
reads the group mode, subsonic calls CleanTitle). It is a property of the kind,
not of the scan. The one genuinely scanner-owned helper became
library.ExtensionsFor.
- Two tests moved with the code rather than being rewritten; they now exercise
the boundary by calling library.ListMissing across it.
- Verified live: first scan updates, rescan reports unchanged=N, so change
detection still short-circuits.
internal/providers out of internal/metadata
- Providers talk to third-party APIs; the enrich job owns the matching policy and
the database writes. The split's whole point is that a provider is testable
WITHOUT a database, so a DB-free test was added and OpenLibrary gained a
BaseURL override to make it possible.
- providers imports zero internal packages — a true leaf.
- The matching policy (searchTitle, artistHint, pickBest) is untouched. It exists
because real false matches were found.
dto packages out of internal/jellyfin and internal/subsonic
- The wire types and their mapping are now separate from the handler logic, so
the contract with clients we do not control is reviewable on its own.
- Both dto packages are PURE: zero references to sql.DB or net/http, verified by
grep. That is what makes them reviewable.
- No field name, tag or error code changed.
internal/arch did its job: it failed the build twice during this phase, once for
each new package that was not yet placed in a layer. That is the rule working,
not an obstacle.
Verified: gofmt clean, build exit 0, vet exit 0, 23 packages pass, svelte-check
0/0, and end to end against a running server — home shelves, a queued scan
reporting unchanged, Jellyfin /Items, and Subsonic ping.
Process note: one agent (dto) stopped mid-task and left the tree red — the dto
packages unlayered and its test still referencing constants that had moved. The
arch test caught it immediately. I finished it by hand: exported constant
references in the test, and both dto packages placed at layer 3.
Still open from Phase 1: internal/jellyfin has no test files, catalog is
item-centric while Subsonic is file-first, and subsonic loadAlbum now scopes to
the item's own library.
96 lines
2.9 KiB
Go
96 lines
2.9 KiB
Go
package jellyfin
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"io"
|
|
"net/http"
|
|
|
|
"github.com/mithral/vellum/internal/auth"
|
|
"github.com/mithral/vellum/internal/httpx"
|
|
"github.com/mithral/vellum/internal/jellyfin/dto"
|
|
"github.com/mithral/vellum/internal/progress"
|
|
)
|
|
|
|
// handlePlaying is POST /Sessions/Playing: the client has started (or resumed)
|
|
// an item.
|
|
func (h *Handlers) handlePlaying(w http.ResponseWriter, r *http.Request, u auth.User) {
|
|
h.writePlaybackProgress(w, r, u)
|
|
}
|
|
|
|
// handlePlayingProgress is POST /Sessions/Playing/Progress: periodic position
|
|
// updates, which are what keep the resume point current.
|
|
func (h *Handlers) handlePlayingProgress(w http.ResponseWriter, r *http.Request, u auth.User) {
|
|
h.writePlaybackProgress(w, r, u)
|
|
}
|
|
|
|
// handlePlayingStopped is POST /Sessions/Playing/Stopped. The final position is
|
|
// written the same way; progress.Put decides whether it counts as finished.
|
|
func (h *Handlers) handlePlayingStopped(w http.ResponseWriter, r *http.Request, u auth.User) {
|
|
h.writePlaybackProgress(w, r, u)
|
|
}
|
|
|
|
// writePlaybackProgress turns a Jellyfin report into a progress row. This is
|
|
// how a Jellyfin client reports resume position, so it is written through the
|
|
// existing progress store rather than kept anywhere new.
|
|
func (h *Handlers) writePlaybackProgress(w http.ResponseWriter, r *http.Request, u auth.User) {
|
|
var rep dto.PlayReport
|
|
// Not httpx.DecodeJSON: real clients add fields we do not model, and a
|
|
// rejected body would lose the user's position.
|
|
if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 1<<20)).Decode(&rep); err != nil {
|
|
if errors.Is(err, io.EOF) {
|
|
httpx.WriteError(w, http.StatusBadRequest, "request body is empty")
|
|
return
|
|
}
|
|
httpx.WriteError(w, http.StatusBadRequest, "invalid request body")
|
|
return
|
|
}
|
|
|
|
id, isLib, ok := dto.DecodeID(rep.ItemId)
|
|
if !ok || isLib {
|
|
httpx.WriteError(w, http.StatusBadRequest, "invalid ItemId")
|
|
return
|
|
}
|
|
it, ok := h.authorizedItem(w, r, u, id)
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
// Duration comes from the item's first file, the same source the browse
|
|
// DTOs use, so PlayedPercentage is consistent across endpoints.
|
|
f, err := h.firstFile(r.Context(), id)
|
|
if err != nil {
|
|
h.fail(w, "load duration", err)
|
|
return
|
|
}
|
|
durationMS := f.DurationMS
|
|
|
|
posMS := dto.TicksToMS(rep.PositionTicks)
|
|
if posMS < 0 {
|
|
posMS = 0
|
|
}
|
|
p := progress.Progress{
|
|
ItemID: id,
|
|
Kind: it.Kind,
|
|
Position: posMS,
|
|
Duration: durationMS,
|
|
}
|
|
if durationMS > 0 {
|
|
p.Percent = float64(posMS) / float64(durationMS)
|
|
if p.Percent > 1 {
|
|
p.Percent = 1
|
|
}
|
|
}
|
|
|
|
if _, err := progress.Put(r.Context(), h.db, u.ID, p); err != nil {
|
|
if errors.Is(err, progress.ErrNoFile) {
|
|
// Nothing to attach progress to. Jellyfin clients expect 204, and
|
|
// there is genuinely nothing to store, so do not fail playback.
|
|
w.WriteHeader(http.StatusNoContent)
|
|
return
|
|
}
|
|
h.fail(w, "save progress", err)
|
|
return
|
|
}
|
|
w.WriteHeader(http.StatusNoContent)
|
|
}
|