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, } }