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