Up And Down : première version

This commit is contained in:
cedric committed 2026-11-19 10:30:47 +01:00
commit 89c5430308
76 files changed
+20730

No files matched your search

+166
View File
@@ -0,0 +1,166 @@
package storage
import (
"archive/zip"
"fmt"
"io"
"io/fs"
"os"
"path"
"path/filepath"
"strings"
)
// Téléchargement d'un dossier ou d'une sélection en archive ZIP, générée en
// flux (aucun fichier temporaire, mémoire constante).
// ZipItem est un fichier ou un dossier à archiver : Abs est son chemin sur le
// disque, Name son nom dans l'archive.
type ZipItem struct {
Abs string
Name string
}
// compressed : extensions déjà compressées, stockées sans recompression.
var compressed = map[string]bool{
".zip": true, ".gz": true, ".tgz": true, ".bz2": true, ".xz": true, ".7z": true, ".rar": true, ".zst": true,
".jpg": true, ".jpeg": true, ".png": true, ".gif": true, ".webp": true, ".avif": true, ".heic": true,
".mp3": true, ".aac": true, ".ogg": true, ".opus": true, ".flac": true, ".m4a": true,
".mp4": true, ".mkv": true, ".webm": true, ".mov": true, ".avi": true, ".m4v": true,
".pdf": true, ".docx": true, ".xlsx": true, ".pptx": true, ".odt": true, ".ods": true, ".jar": true,
}
// ZipItems traduit des chemins virtuels en éléments à archiver ; les doublons
// de noms (même nom dans deux dossiers) reçoivent un suffixe « (2) ». Renvoie
// aussi un nom d'archive : celui de l'élément unique, sinon « fichiers ».
func (u *Space) ZipItems(paths []string) ([]ZipItem, string, error) {
if len(paths) == 0 {
return nil, "", ErrInvalidPath
}
var items []ZipItem
used := map[string]bool{}
for _, p := range paths {
st, rel, err := u.route(p)
if err != nil {
return nil, "", err
}
c, abs, err := st.resolve(rel)
if err != nil {
return nil, "", err
}
name := path.Base(c)
if c == "" {
name = "fichiers" // racine de l'espace personnel
}
fi, err := os.Lstat(abs)
if err != nil {
return nil, "", mapErr(err)
}
if !fi.IsDir() && !fi.Mode().IsRegular() {
return nil, "", ErrNotFound
}
items = append(items, ZipItem{Abs: abs, Name: uniqueZipName(name, used)})
}
archive := "fichiers"
if len(items) == 1 {
archive = items[0].Name
}
return items, archive, nil
}
func uniqueZipName(name string, used map[string]bool) string {
n := name
for i := 2; used[strings.ToLower(n)]; i++ {
ext := path.Ext(name)
n = fmt.Sprintf("%s (%d)%s", strings.TrimSuffix(name, ext), i, ext)
}
used[strings.ToLower(n)] = true
return n
}
// SharedZipItem renvoie l'élément d'un lien de partage (ou d'un de ses
// sous-dossiers) à archiver.
func (s *Store) SharedZipItem(rel string) (ZipItem, error) {
c, abs, err := s.resolve(rel)
if err != nil {
return ZipItem{}, err
}
if _, err := os.Lstat(abs); err != nil {
return ZipItem{}, mapErr(err)
}
return ZipItem{Abs: abs, Name: path.Base(c)}, nil
}
// WriteZip écrit les éléments dans w au format ZIP. Les liens symboliques, les
// fichiers spéciaux et les fichiers internes (noms cachés) sont ignorés ; un
// fichier illisible est sauté sans interrompre l'archive.
func WriteZip(w io.Writer, items []ZipItem) error {
zw := zip.NewWriter(w)
for _, it := range items {
fi, err := os.Lstat(it.Abs)
if err != nil {
continue
}
if !fi.IsDir() {
if err := addZipFile(zw, it.Abs, it.Name, fi); err != nil {
return err
}
continue
}
err = filepath.WalkDir(it.Abs, func(p string, d fs.DirEntry, err error) error {
if err != nil {
return nil
}
if p != it.Abs && !visible(d.Name()) {
if d.IsDir() {
return filepath.SkipDir
}
return nil
}
rel, _ := filepath.Rel(it.Abs, p)
name := it.Name
if rel != "." {
name = path.Join(it.Name, filepath.ToSlash(rel))
}
switch {
case d.IsDir():
h := &zip.FileHeader{Name: name + "/", Method: zip.Store}
if info, err := d.Info(); err == nil {
h.Modified = info.ModTime()
}
_, err := zw.CreateHeader(h)
return err
case d.Type().IsRegular():
info, err := d.Info()
if err != nil {
return nil
}
return addZipFile(zw, p, name, info)
}
return nil
})
if err != nil {
return err
}
}
return zw.Close()
}
func addZipFile(zw *zip.Writer, abs, name string, fi fs.FileInfo) error {
f, err := os.Open(abs)
if err != nil {
return nil // fichier illisible : sauté
}
defer f.Close()
h := &zip.FileHeader{Name: name, Method: zip.Deflate, Modified: fi.ModTime()}
if compressed[strings.ToLower(path.Ext(name))] {
h.Method = zip.Store
}
h.UncompressedSize64 = uint64(fi.Size())
out, err := zw.CreateHeader(h)
if err != nil {
return err
}
_, err = io.Copy(out, f)
return err
}