Files
upandown/internal/api/files.go
T

518 lines
11 KiB
Go

package api
import (
"crypto/sha256"
"encoding/hex"
"io"
"net/http"
"path"
"strconv"
"strings"
"time"
"github.com/vblogio/upandown/internal/storage"
)
func (h *Handler) list(w http.ResponseWriter, r *http.Request) {
u, ok := h.space(w, r)
if !ok {
return
}
entries, err := u.List(r.URL.Query().Get("path"))
if err != nil {
fail(w, err)
return
}
if wantDetails(r) {
ps := make([]*storage.Entry, len(entries))
for i := range entries {
ps[i] = &entries[i]
}
u.AddDetails(ps)
}
w.Header().Set("Cache-Control", "no-store")
writeJSON(w, http.StatusOK, entries)
}
func (h *Handler) search(w http.ResponseWriter, r *http.Request) {
u, ok := h.space(w, r)
if !ok {
return
}
q := r.URL.Query()
f := storage.Filter{Tag: q.Get("tag"), Favorite: q.Get("fav") == "true"}
entries, err := u.Search(q.Get("q"), f, 200)
if err != nil {
fail(w, err)
return
}
if wantDetails(r) {
ps := make([]*storage.Entry, len(entries))
for i := range entries {
ps[i] = &entries[i].Entry
}
u.AddDetails(ps)
}
w.Header().Set("Cache-Control", "no-store")
writeJSON(w, http.StatusOK, entries)
}
func (h *Handler) tags(w http.ResponseWriter, r *http.Request) {
u, ok := h.space(w, r)
if !ok {
return
}
tags, err := u.Tags()
if err != nil {
fail(w, err)
return
}
w.Header().Set("Cache-Control", "no-cache")
writeJSON(w, http.StatusOK, tags)
}
type metaReq struct {
Paths []string `json:"paths"`
Favorite bool `json:"favorite"`
Add []string `json:"add"`
Remove []string `json:"remove"`
Icon string `json:"icon"`
}
func (h *Handler) decodeMeta(w http.ResponseWriter, r *http.Request) (metaReq, bool) {
var req metaReq
if !h.decode(w, r, &req) {
return req, false
}
if len(req.Paths) == 0 || len(req.Paths) > 1000 {
writeErr(w, http.StatusBadRequest, "entre 1 et 1000 chemins attendus")
return req, false
}
return req, true
}
func (h *Handler) setFavorite(w http.ResponseWriter, r *http.Request) {
u, ok := h.space(w, r)
if !ok {
return
}
req, ok := h.decodeMeta(w, r)
if !ok {
return
}
if err := u.SetFavorite(req.Paths, req.Favorite); err != nil {
fail(w, err)
return
}
w.WriteHeader(http.StatusNoContent)
}
func (h *Handler) editTags(w http.ResponseWriter, r *http.Request) {
u, ok := h.space(w, r)
if !ok {
return
}
req, ok := h.decodeMeta(w, r)
if !ok {
return
}
if err := u.EditTags(req.Paths, req.Add, req.Remove); err != nil {
fail(w, err)
return
}
w.WriteHeader(http.StatusNoContent)
}
func (h *Handler) setIcon(w http.ResponseWriter, r *http.Request) {
u, ok := h.space(w, r)
if !ok {
return
}
req, ok := h.decodeMeta(w, r)
if !ok {
return
}
if err := u.SetIcon(req.Paths, req.Icon); err != nil {
fail(w, err)
return
}
w.WriteHeader(http.StatusNoContent)
}
// download sert un fichier (Range, ETag, If-Modified-Since). Sans inline, ou si
// le type n'est pas sûr à afficher, il est téléchargé (Content-Disposition:
// attachment).
func (h *Handler) download(w http.ResponseWriter, r *http.Request) {
u, ok := h.space(w, r)
if !ok {
return
}
f, fi, err := u.Open(r.URL.Query().Get("path"))
if err != nil {
fail(w, err)
return
}
defer f.Close()
serveFile(w, r, f, fi, fi.Name(), r.URL.Query().Get("inline") == "1")
}
// upload dépose un fichier : le corps de la requête est le contenu, lu en flux
// (aucune limite de mémoire). Paramètres : conflict (fail, overwrite, rename),
// mtime (date de modification d'origine, en millisecondes Unix).
func (h *Handler) upload(w http.ResponseWriter, r *http.Request) {
u, ok := h.space(w, r)
if !ok {
return
}
q := r.URL.Query()
o := storage.PutOptions{Conflict: q.Get("conflict"), IfMatch: r.Header.Get("If-Match")}
switch o.Conflict {
case "", "fail", "overwrite", "rename":
default:
writeErr(w, http.StatusBadRequest, "conflict : fail, overwrite ou rename")
return
}
if v := q.Get("mtime"); v != "" {
if ms, err := strconv.ParseInt(v, 10, 64); err == nil {
o.ModTime = time.UnixMilli(ms)
}
}
e, err := u.Put(q.Get("path"), r.Body, r.ContentLength, o)
if err != nil {
// Le corps n'a pas été lu en entier : fermer la connexion plutôt que de la réutiliser.
w.Header().Set("Connection", "close")
fail(w, err)
return
}
writeJSON(w, http.StatusOK, e)
}
type pathReq struct {
Path string `json:"path"`
}
type moveReq struct {
From string `json:"from"`
To string `json:"to"`
}
func (h *Handler) mkdir(w http.ResponseWriter, r *http.Request) {
u, ok := h.space(w, r)
if !ok {
return
}
var req pathReq
if !h.decode(w, r, &req) {
return
}
entry, err := u.Mkdir(req.Path)
if err != nil {
fail(w, err)
return
}
writeJSON(w, http.StatusCreated, entry)
}
func (h *Handler) move(w http.ResponseWriter, r *http.Request) {
u, ok := h.space(w, r)
if !ok {
return
}
var req moveReq
if !h.decode(w, r, &req) {
return
}
entry, err := u.Move(req.From, req.To)
if err != nil {
fail(w, err)
return
}
writeJSON(w, http.StatusOK, entry)
}
type moveManyReq struct {
Paths []string `json:"paths"`
Dir string `json:"dir"`
}
// moveMany renvoie toujours 200 avec le détail par élément : le client
// affiche les échecs partiels (ex. nom déjà pris dans la destination).
func (h *Handler) moveMany(w http.ResponseWriter, r *http.Request) {
u, ok := h.space(w, r)
if !ok {
return
}
var req moveManyReq
if !h.decode(w, r, &req) {
return
}
if len(req.Paths) == 0 || len(req.Paths) > 1000 {
writeErr(w, http.StatusBadRequest, "entre 1 et 1000 chemins attendus")
return
}
res, err := u.MoveMany(req.Paths, req.Dir)
if err != nil {
fail(w, err)
return
}
writeJSON(w, http.StatusOK, res)
}
func (h *Handler) copy(w http.ResponseWriter, r *http.Request) {
u, ok := h.space(w, r)
if !ok {
return
}
var req moveReq
if !h.decode(w, r, &req) {
return
}
entry, err := u.Copy(req.From, req.To)
if err != nil {
fail(w, err)
return
}
writeJSON(w, http.StatusCreated, entry)
}
func (h *Handler) delete(w http.ResponseWriter, r *http.Request) {
u, ok := h.space(w, r)
if !ok {
return
}
q := r.URL.Query()
if err := u.Delete(q.Get("path"), q.Get("recursive") == "true"); err != nil {
fail(w, err)
return
}
w.WriteHeader(http.StatusNoContent)
}
func (h *Handler) restoreTrash(w http.ResponseWriter, r *http.Request) {
u, ok := h.space(w, r)
if !ok {
return
}
req, ok := h.decodeMeta(w, r)
if !ok {
return
}
writeJSON(w, http.StatusOK, u.RestoreTrash(req.Paths))
}
func (h *Handler) thumb(w http.ResponseWriter, r *http.Request) {
u, ok := h.space(w, r)
if !ok {
return
}
data, typ, mod, err := u.Thumb(r.URL.Query().Get("path"))
if err != nil {
w.Header().Set("Cache-Control", "no-store")
fail(w, err)
return
}
writeThumb(w, data, typ, mod)
}
func writeThumb(w http.ResponseWriter, data []byte, typ string, mod time.Time) {
// L'URL porte la date du fichier (?v=...) : une nouvelle version change l'URL.
w.Header().Set("Cache-Control", "private, max-age=86400")
w.Header().Set("Content-Type", typ)
w.Header().Set("Last-Modified", mod.UTC().Format(http.TimeFormat))
_, _ = w.Write(data)
}
// zip envoie un dossier ou une sélection en archive ZIP. GET ?path=x pour un
// élément ; POST (formulaire) avec paths = tableau JSON de chemins.
func (h *Handler) zip(w http.ResponseWriter, r *http.Request) {
u, ok := h.space(w, r)
if !ok {
return
}
var paths []string
if r.Method == http.MethodPost {
r.Body = http.MaxBytesReader(w, r.Body, 4<<20)
if err := r.ParseForm(); err != nil {
writeErr(w, http.StatusBadRequest, "formulaire invalide")
return
}
if err := jsonUnmarshal(r.PostForm.Get("paths"), &paths); err != nil {
writeErr(w, http.StatusBadRequest, "paths : tableau JSON attendu")
return
}
} else {
paths = r.URL.Query()["path"]
}
if len(paths) == 0 || len(paths) > 5000 {
writeErr(w, http.StatusBadRequest, "entre 1 et 5000 chemins attendus")
return
}
items, name, err := u.ZipItems(paths)
if err != nil {
fail(w, err)
return
}
w.Header().Set("Content-Type", "application/zip")
w.Header().Set("Content-Disposition", contentDisposition(false, name+".zip"))
w.Header().Set("Cache-Control", "no-store")
if err := storage.WriteZip(w, items); err != nil {
panic(http.ErrAbortHandler) // archive tronquée : couper la connexion plutôt qu'annoncer une fin normale
}
}
// hash calcule l'empreinte SHA-256 d'un fichier.
func (h *Handler) hash(w http.ResponseWriter, r *http.Request) {
u, ok := h.space(w, r)
if !ok {
return
}
f, _, err := u.Open(r.URL.Query().Get("path"))
if err != nil {
fail(w, err)
return
}
defer f.Close()
sum := sha256.New()
if _, err := io.Copy(sum, f); err != nil {
fail(w, err)
return
}
writeJSON(w, http.StatusOK, map[string]string{"sha256": hex.EncodeToString(sum.Sum(nil))})
}
func (h *Handler) history(w http.ResponseWriter, r *http.Request) {
u, ok := h.space(w, r)
if !ok {
return
}
vs, err := u.Versions(r.URL.Query().Get("path"))
if err != nil {
fail(w, err)
return
}
w.Header().Set("Cache-Control", "no-cache")
writeJSON(w, http.StatusOK, vs)
}
// readVersion télécharge une version ancienne d'un fichier.
func (h *Handler) readVersion(w http.ResponseWriter, r *http.Request) {
u, ok := h.space(w, r)
if !ok {
return
}
q := r.URL.Query()
f, fi, err := u.OpenVersion(q.Get("path"), q.Get("id"))
if err != nil {
fail(w, err)
return
}
defer f.Close()
serveFile(w, r, f, fi, path.Base(q.Get("path")), false)
}
func (h *Handler) snapshot(w http.ResponseWriter, r *http.Request) {
u, ok := h.space(w, r)
if !ok {
return
}
var req pathReq
if !h.decode(w, r, &req) {
return
}
v, err := u.Snapshot(req.Path)
if err != nil {
fail(w, err)
return
}
writeJSON(w, http.StatusOK, v)
}
type restoreReq struct {
Path string `json:"path"`
ID string `json:"id"`
}
func (h *Handler) restore(w http.ResponseWriter, r *http.Request) {
u, ok := h.space(w, r)
if !ok {
return
}
var req restoreReq
if !h.decode(w, r, &req) {
return
}
entry, err := u.Restore(req.Path, req.ID)
if err != nil {
fail(w, err)
return
}
writeJSON(w, http.StatusOK, entry)
}
func (h *Handler) shares(w http.ResponseWriter, r *http.Request) {
u, ok := h.space(w, r)
if !ok {
return
}
l, err := u.Shares(r.URL.Query().Get("path"))
if err != nil {
fail(w, err)
return
}
w.Header().Set("Cache-Control", "no-store")
writeJSON(w, http.StatusOK, l)
}
type shareReq struct {
Path string `json:"path"`
Days int `json:"days"`
Password string `json:"password"`
}
func (h *Handler) createShare(w http.ResponseWriter, r *http.Request) {
u, ok := h.space(w, r)
if !ok {
return
}
var req shareReq
if !h.decode(w, r, &req) {
return
}
if req.Days < 0 || req.Days > 3650 {
writeErr(w, http.StatusBadRequest, "durée de 0 (sans expiration) à 3650 jours")
return
}
sh, err := u.CreateShare(req.Path, storage.ShareOptions{TTL: time.Duration(req.Days) * 24 * time.Hour, Password: req.Password})
if err != nil {
fail(w, err)
return
}
writeJSON(w, http.StatusCreated, sh)
}
func (h *Handler) revokeShare(w http.ResponseWriter, r *http.Request) {
u, ok := h.space(w, r)
if !ok {
return
}
if err := u.RevokeShare(r.URL.Query().Get("id")); err != nil {
fail(w, err)
return
}
w.WriteHeader(http.StatusNoContent)
}
func (h *Handler) revokeAllShares(w http.ResponseWriter, r *http.Request) {
u, ok := h.space(w, r)
if !ok {
return
}
if err := u.RevokeAllShares(); err != nil {
fail(w, err)
return
}
w.WriteHeader(http.StatusNoContent)
}
func jsonUnmarshal(s string, v any) error { return jsonDecode(strings.NewReader(s), v) }