Migrating hosting from Codeberg to git.kmalloc.org. Renames the module path in go.mod, every internal import, and the OCI image source label in the Dockerfile. Build and full test suite verified green after the rename.
169 lines
5.6 KiB
Go
169 lines
5.6 KiB
Go
package httpapi
|
|
|
|
import (
|
|
"errors"
|
|
"net/http"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
|
|
"git.kmalloc.org/squid/sonda/internal/duplicates"
|
|
"git.kmalloc.org/squid/sonda/internal/jobs"
|
|
)
|
|
|
|
// duplicateHandlers serve the admin's view of the songs that are in more than one file, and the
|
|
// removal of the extra copies. File paths never appear in any answer.
|
|
type duplicateHandlers struct{ svc duplicateService }
|
|
|
|
const (
|
|
defaultDuplicatesLimit = 50
|
|
maxDuplicatesLimit = 200
|
|
)
|
|
|
|
type duplicateFileJSON struct {
|
|
TrackID int64 `json:"track_id"`
|
|
Album *albumRefJSON `json:"album"`
|
|
Format string `json:"format"`
|
|
Bitrate int `json:"bitrate"`
|
|
SizeBytes int64 `json:"size_bytes"`
|
|
DurationMs int64 `json:"duration_ms"`
|
|
Hashed bool `json:"hashed"`
|
|
}
|
|
|
|
type duplicateGroupJSON struct {
|
|
Title string `json:"title"`
|
|
Artists []artistRefJSON `json:"artists"`
|
|
Files []duplicateFileJSON `json:"files"`
|
|
Hashed bool `json:"hashed"`
|
|
Identical bool `json:"identical"`
|
|
SuggestedID int64 `json:"suggested_keep_track_id"`
|
|
FreedBytes int64 `json:"freed_bytes"`
|
|
}
|
|
|
|
type duplicatePageJSON struct {
|
|
DeletionAllowed bool `json:"deletion_allowed"`
|
|
Total int `json:"total"`
|
|
Limit int `json:"limit"`
|
|
Offset int `json:"offset"`
|
|
Groups []duplicateGroupJSON `json:"groups"`
|
|
}
|
|
|
|
// list gives the groups of copies, a page at a time.
|
|
func (h *duplicateHandlers) list(c *gin.Context) {
|
|
limit, ok := queryInt(c, "limit")
|
|
if !ok {
|
|
return
|
|
}
|
|
offset, ok := queryInt(c, "offset")
|
|
if !ok {
|
|
return
|
|
}
|
|
if limit < 0 || offset < 0 {
|
|
writeError(c, http.StatusBadRequest, "invalid_input", "limit and offset cannot be negative")
|
|
return
|
|
}
|
|
size := clampInt(limit)
|
|
if size == 0 {
|
|
size = defaultDuplicatesLimit
|
|
}
|
|
size = min(size, maxDuplicatesLimit)
|
|
|
|
page, err := h.svc.Groups(c.Request.Context(), size, clampInt(offset))
|
|
if err != nil {
|
|
_ = c.Error(err)
|
|
writeError(c, http.StatusInternalServerError, "internal", "internal error")
|
|
return
|
|
}
|
|
out := duplicatePageJSON{
|
|
DeletionAllowed: page.DeletionAllowed, Total: page.Total, Limit: size, Offset: clampInt(offset),
|
|
Groups: make([]duplicateGroupJSON, len(page.Groups)),
|
|
}
|
|
for i, g := range page.Groups {
|
|
out.Groups[i] = toDuplicateGroupJSON(g)
|
|
}
|
|
c.JSON(http.StatusOK, out)
|
|
}
|
|
|
|
func toDuplicateGroupJSON(g duplicates.Group) duplicateGroupJSON {
|
|
out := duplicateGroupJSON{
|
|
Title: g.Title, Artists: make([]artistRefJSON, len(g.Artists)), Files: make([]duplicateFileJSON, len(g.Files)),
|
|
Hashed: g.Hashed, Identical: g.Identical, SuggestedID: g.KeepTrackID, FreedBytes: g.FreedBytes,
|
|
}
|
|
for i, a := range g.Artists {
|
|
out.Artists[i] = artistRefJSON{ID: a.ID, Name: a.Name}
|
|
}
|
|
for i, f := range g.Files {
|
|
file := duplicateFileJSON{
|
|
TrackID: f.TrackID, Format: f.Format, Bitrate: f.BitRate, SizeBytes: f.SizeBytes, DurationMs: f.DurationMs, Hashed: f.Hash != "",
|
|
}
|
|
if f.AlbumID != 0 {
|
|
file.Album = &albumRefJSON{ID: f.AlbumID, Title: f.Album}
|
|
}
|
|
out.Files[i] = file
|
|
}
|
|
return out
|
|
}
|
|
|
|
type cleanRequest struct {
|
|
KeepTrackID int64 `json:"keep_track_id"`
|
|
RemoveTrackIDs []int64 `json:"remove_track_ids"`
|
|
}
|
|
|
|
// clean removes the copies named of one song, keeping the one named.
|
|
func (h *duplicateHandlers) clean(c *gin.Context) {
|
|
var req cleanRequest
|
|
if !bindJSON(c, &req) {
|
|
return
|
|
}
|
|
if req.KeepTrackID <= 0 || len(req.RemoveTrackIDs) == 0 {
|
|
writeError(c, http.StatusBadRequest, "invalid_input", "name the copy to keep and at least one copy to remove")
|
|
return
|
|
}
|
|
for _, id := range req.RemoveTrackIDs {
|
|
if id <= 0 {
|
|
writeError(c, http.StatusBadRequest, "invalid_input", "track ids must be positive numbers")
|
|
return
|
|
}
|
|
}
|
|
res, err := h.svc.Clean(c.Request.Context(), req.KeepTrackID, req.RemoveTrackIDs)
|
|
if err != nil {
|
|
writeDuplicatesError(c, err)
|
|
return
|
|
}
|
|
c.JSON(http.StatusOK, gin.H{"removed": res.Removed, "freed_bytes": res.FreedBytes})
|
|
}
|
|
|
|
// writeDuplicatesError gives each way a removal is refused its own status and code, so a client can tell them apart.
|
|
func writeDuplicatesError(c *gin.Context, err error) {
|
|
switch {
|
|
case errors.Is(err, duplicates.ErrDisabled):
|
|
writeError(c, http.StatusConflict, "deletion_disabled", "deleting files is not turned on: set library.allow_delete")
|
|
case errors.Is(err, duplicates.ErrScanRunning):
|
|
writeError(c, http.StatusConflict, "scan_running", "wait for the running scan to finish")
|
|
case errors.Is(err, duplicates.ErrInvalid):
|
|
writeError(c, http.StatusBadRequest, "invalid_input", err.Error())
|
|
case errors.Is(err, duplicates.ErrTrackNotFound):
|
|
writeError(c, http.StatusNotFound, "track_not_found", "no such track")
|
|
case errors.Is(err, duplicates.ErrChanged):
|
|
writeError(c, http.StatusConflict, "duplicate_changed", "a file is not what the last scan saw: scan again")
|
|
case errors.Is(err, duplicates.ErrReadOnly):
|
|
writeError(c, http.StatusConflict, "library_read_only", "the music folder cannot be written to")
|
|
default:
|
|
_ = c.Error(err)
|
|
writeError(c, http.StatusInternalServerError, "internal", "internal error")
|
|
}
|
|
}
|
|
|
|
type duplicatesCheckSummaryJSON struct {
|
|
Checked int `json:"checked"`
|
|
Hashed int `json:"hashed"`
|
|
Skipped int `json:"skipped"`
|
|
Failed int `json:"failed"`
|
|
Stopped bool `json:"stopped"`
|
|
}
|
|
|
|
// duplicatesCheckSummary is the summary of the job that fingerprints the files of the groups.
|
|
func duplicatesCheckSummary(s *jobs.Summary) any {
|
|
return duplicatesCheckSummaryJSON{
|
|
Checked: s.Checked, Hashed: s.Outcomes[duplicates.OutcomeHashed], Skipped: s.Skipped, Failed: s.Failed, Stopped: s.Stopped,
|
|
}
|
|
}
|