285 lines
6.8 KiB
Go
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,
|
|
}
|
|
}
|