Files
Mediarr/api/content.go
T
2026-11-16 13:12:36 +01:00

285 lines
6.8 KiB
Go

package api
import (
"encoding/hex"
"fmt"
"io"
"mime"
"net/http"
"path/filepath"
"strconv"
"strings"
"mediarr/content"
"mediarr/ident"
)
type versionDTO struct {
ID string `json:"id"`
DocumentID string `json:"document_id"`
Seq int64 `json:"seq"`
ContentRoot string `json:"content_root"`
Size int64 `json:"size"`
Mime string `json:"mime,omitempty"`
AuthorID string `json:"author_id"`
Origin string `json:"origin"`
Message string `json:"message,omitempty"`
Pinned bool `json:"pinned"`
ContentPurgedAt *int64 `json:"content_purged_at,omitempty"`
CreatedAt int64 `json:"created_at"`
}
type setHeadRequest struct {
VersionID string `json:"version_id"`
}
type retentionDTO struct {
Purged []string `json:"purged"`
Kept int `json:"kept"`
}
type garbageCollectionDTO struct {
Blobs int `json:"blobs"`
Locations int `json:"locations"`
Bytes int64 `json:"bytes"`
}
func (s *Server) handleListVersions(w http.ResponseWriter, r *http.Request) {
documentID, err := idParam(r, "id")
if err != nil {
writeErrorFor(w, err)
return
}
versions, err := s.node.Content().ListVersions(r.Context(), actorID(r), documentID)
if err != nil {
writeErrorFor(w, err)
return
}
result := make([]versionDTO, 0, len(versions))
for i := range versions {
result = append(result, versionDTOFrom(&versions[i]))
}
writeJSON(w, http.StatusOK, result)
}
func (s *Server) handleUploadVersion(w http.ResponseWriter, r *http.Request) {
documentID, err := idParam(r, "id")
if err != nil {
writeErrorFor(w, err)
return
}
r.Body = http.MaxBytesReader(w, r.Body, maxUploadBody)
defer func() {
if r.MultipartForm != nil {
_ = r.MultipartForm.RemoveAll()
}
}()
file, header, err := r.FormFile("file")
if err != nil {
writeError(w, http.StatusBadRequest, "fichier requis")
return
}
defer file.Close()
origin := r.FormValue("origin")
if origin == "" {
origin = content.OriginUpload
}
if origin != content.OriginUpload && origin != content.OriginRestore {
writeError(w, http.StatusBadRequest, "origine invalide")
return
}
mimeType := strings.TrimSpace(r.FormValue("mime"))
if mimeType == "" {
mimeType = mime.TypeByExtension(strings.ToLower(filepath.Ext(header.Filename)))
}
if mimeType == "" {
mimeType = "application/octet-stream"
}
pinned := false
if raw := r.FormValue("pinned"); raw != "" {
parsed, err := strconv.ParseBool(raw)
if err != nil {
writeError(w, http.StatusBadRequest, "pinned invalide")
return
}
pinned = parsed
}
version, err := s.node.Content().CreateVersion(r.Context(), actorID(r), documentID, content.CreateVersionParams{
Source: file,
Mime: mimeType,
Origin: origin,
Message: r.FormValue("message"),
Pinned: pinned,
})
if err != nil {
writeErrorFor(w, err)
return
}
w.Header().Set("Location", "/api/versions/"+version.ID.String())
writeJSON(w, http.StatusCreated, versionDTOFrom(version))
}
func (s *Server) handleDownloadVersion(w http.ResponseWriter, r *http.Request) {
versionID, err := idParam(r, "id")
if err != nil {
writeErrorFor(w, err)
return
}
reader, version, err := s.node.Content().OpenVersion(r.Context(), actorID(r), versionID)
if err != nil {
writeErrorFor(w, err)
return
}
defer reader.Close()
contentType := version.Mime
if contentType == "" {
contentType = "application/octet-stream"
}
w.Header().Set("Content-Type", contentType)
w.Header().Set("Content-Length", strconv.FormatInt(version.Size, 10))
w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=%q", fmt.Sprintf("version-%d", version.Seq)))
w.WriteHeader(http.StatusOK)
_, _ = io.Copy(w, reader)
}
func (s *Server) handleGetHead(w http.ResponseWriter, r *http.Request) {
documentID, err := idParam(r, "id")
if err != nil {
writeErrorFor(w, err)
return
}
version, err := s.node.Content().HeadVersion(r.Context(), actorID(r), documentID)
if err != nil {
writeErrorFor(w, err)
return
}
if version == nil {
writeJSON(w, http.StatusOK, map[string]any{"version": nil})
return
}
writeJSON(w, http.StatusOK, map[string]any{"version": versionDTOFrom(version)})
}
func (s *Server) handleSetHead(w http.ResponseWriter, r *http.Request) {
documentID, err := idParam(r, "id")
if err != nil {
writeErrorFor(w, err)
return
}
var request setHeadRequest
if err := decodeJSON(w, r, &request); err != nil {
writeErrorFor(w, err)
return
}
versionID, err := ident.Parse(request.VersionID)
if err != nil {
writeError(w, http.StatusBadRequest, "version_id invalide")
return
}
version, err := s.node.Content().SetHeadVersion(r.Context(), actorID(r), documentID, versionID)
if err != nil {
writeErrorFor(w, err)
return
}
writeJSON(w, http.StatusOK, versionDTOFrom(version))
}
func (s *Server) handleApplyRetention(w http.ResponseWriter, r *http.Request) {
documentID, err := idParam(r, "id")
if err != nil {
writeErrorFor(w, err)
return
}
result, err := s.node.Content().ApplyRetention(r.Context(), actorID(r), documentID)
if err != nil {
writeErrorFor(w, err)
return
}
purged := make([]string, 0, len(result.Purged))
for _, id := range result.Purged {
purged = append(purged, id.String())
}
writeJSON(w, http.StatusOK, retentionDTO{Purged: purged, Kept: result.Kept})
}
func (s *Server) handlePurgeVersion(w http.ResponseWriter, r *http.Request) {
versionID, err := idParam(r, "id")
if err != nil {
writeErrorFor(w, err)
return
}
if err := s.node.Content().PurgeVersion(r.Context(), actorID(r), versionID); err != nil {
writeErrorFor(w, err)
return
}
w.WriteHeader(http.StatusNoContent)
}
func (s *Server) handleVerifyVersion(w http.ResponseWriter, r *http.Request) {
versionID, err := idParam(r, "id")
if err != nil {
writeErrorFor(w, err)
return
}
if err := s.node.Content().VerifyVersion(r.Context(), actorID(r), versionID); err != nil {
writeErrorFor(w, err)
return
}
w.WriteHeader(http.StatusNoContent)
}
func (s *Server) handleCollectGarbage(w http.ResponseWriter, r *http.Request) {
result, err := s.node.Content().CollectGarbage(r.Context())
if err != nil {
writeErrorFor(w, err)
return
}
writeJSON(w, http.StatusOK, garbageCollectionDTO{
Blobs: result.Blobs,
Locations: result.Locations,
Bytes: result.Bytes,
})
}
func versionDTOFrom(version *content.Version) versionDTO {
return versionDTO{
ID: version.ID.String(),
DocumentID: version.DocumentID.String(),
Seq: version.Seq,
ContentRoot: hex.EncodeToString(version.ContentRoot),
Size: version.Size,
Mime: version.Mime,
AuthorID: version.AuthorID.String(),
Origin: version.Origin,
Message: version.Message,
Pinned: version.Pinned,
ContentPurgedAt: version.ContentPurgedAt,
CreatedAt: version.CreatedAt,
}
}