Files
upandown/internal/storage/details.go
claude BotandClaude Opus 5.5 7c1f49cb5c Lot 3 (1/4) : racine S3, backend du Store (catalogue + objets minio-go)
Arborescence dans s3_nodes, contenus sous des clés o/<id> figées au dépôt,
corbeille dans s3_trash, configuration admin dans s3_config. Délégations
S3 dans List/Stat/Open/Put/Mkdir/Move/Copy/Delete/Walk/corbeille,
miniatures, partages, tags, recherche (noms et tags). Pas d'historique.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LNfwm4pfYR9C914C2EeiuB
2026-11-20 18:01:01 +01:00

222 lines
5.5 KiB
Go

package storage
import (
"image"
"os"
"path/filepath"
"strings"
"time"
)
// Détails des fichiers et dossiers pour la vue Galerie et le panneau Détails
// (/api/list?details=1) : dimensions d'une image, versions, liens de partage
// actifs, création et dernier auteur ; contenu d'un dossier.
// Details complète une entrée.
type Details struct {
Width int `json:"width,omitempty"` // image : dimensions en pixels
Height int `json:"height,omitempty"`
Versions int `json:"versions,omitempty"` // versions dans l'historique
Shares int `json:"shares,omitempty"` // liens de partage actifs
Created *time.Time `json:"created,omitempty"` // création (ou plus ancienne version connue)
CreatedBy string `json:"createdBy,omitempty"` // vide si inconnu
Dirs int `json:"dirs,omitempty"` // dossier : sous-dossiers directs
Files int `json:"files,omitempty"` // dossier : fichiers directs
Total int64 `json:"total,omitempty"` // dossier : taille de tout le contenu (octets)
Count int `json:"count,omitempty"` // dossier : nombre de fichiers dans tout le contenu
}
// maxDirWalk borne le parcours qui totalise la taille d'un dossier.
const maxDirWalk = 20000
func (s *Store) fileDetails(rel string, meta map[string]itemMeta, shares map[string]int) (*Details, error) {
if s.s3 != nil {
c, _, err := s.lstat(rel)
if err != nil {
return nil, err
}
d := &Details{Shares: shares[c]}
if m := meta[c]; m.Created != nil {
d.Created, d.CreatedBy = m.Created, m.CreatedBy
}
return d, nil
}
c, abs, err := s.resolve(rel)
if err != nil {
return nil, err
}
fi, err := os.Lstat(abs)
if err != nil {
return nil, mapErr(err)
}
d := &Details{Shares: shares[c]}
if isDecodableImage(c) && fi.Size() < 200<<20 {
if f, err := os.Open(abs); err == nil {
if cfg, _, err := image.DecodeConfig(f); err == nil {
d.Width, d.Height = cfg.Width, cfg.Height
}
f.Close()
}
}
var oldest string
d.Versions, oldest = s.versionCount(c)
if m := meta[c]; m.Created != nil {
d.Created, d.CreatedBy = m.Created, m.CreatedBy
} else if t, err := time.Parse(versionLayout, oldest); err == nil {
d.Created = &t
}
return d, nil
}
// versionCount compte les versions d'un fichier et renvoie l'identifiant de la
// plus ancienne, sans lire leurs métadonnées.
func (s *Store) versionCount(c string) (int, string) {
des, err := os.ReadDir(s.historyAbs(c))
if err != nil {
return 0, ""
}
n, oldest := 0, ""
for _, de := range des {
id := de.Name()
if de.IsDir() || !versionID.MatchString(id) {
continue
}
n++
if oldest == "" || id < oldest {
oldest = id
}
}
return n, oldest
}
// dirDetails compte le contenu d'un dossier : éléments directs, puis taille
// et nombre de fichiers de toute l'arborescence (borné à maxDirWalk entrées).
func (s *Store) dirDetails(rel string) (*Details, error) {
if s.s3 != nil {
c, err := Clean(rel)
if err != nil {
return nil, err
}
return s.s3DirDetails(c)
}
_, abs, err := s.resolve(rel)
if err != nil {
return nil, err
}
des, err := os.ReadDir(abs)
if err != nil {
return nil, mapErr(err)
}
d := &Details{}
for _, de := range des {
if !visible(de.Name()) || de.Type()&os.ModeSymlink != 0 {
continue
}
if de.IsDir() {
d.Dirs++
} else {
d.Files++
}
}
seen := 0
_ = filepath.WalkDir(abs, func(p string, e os.DirEntry, err error) error {
if err != nil || p == abs {
return nil
}
if strings.HasPrefix(e.Name(), ".") {
if e.IsDir() {
return filepath.SkipDir
}
return nil
}
if seen++; seen > maxDirWalk {
return filepath.SkipAll
}
if e.Type().IsRegular() {
if fi, err := e.Info(); err == nil {
d.Total += fi.Size()
d.Count++
}
}
return nil
})
return d, nil
}
// shareCounts compte les liens de partage actifs par chemin.
func (s *Store) shareCounts() map[string]int {
s.sharesMu.Lock()
defer s.sharesMu.Unlock()
m, err := s.readShares()
if err != nil {
return nil
}
out := map[string]int{}
now := time.Now()
for _, d := range m {
if d.Expires == nil || now.Before(*d.Expires) {
out[d.Path]++
}
}
return out
}
// noteEdit retient le dernier utilisateur qui a déposé un fichier et, pour un
// fichier nouveau, sa date de création et son auteur. .meta.json n'est réécrit
// que si quelque chose change.
func (s *Store) noteEdit(c, by string, created bool) {
if c == "" {
return
}
_ = s.updateMeta(func(meta map[string]itemMeta) (bool, error) {
m := meta[c]
changed := false
if by != "" && m.EditedBy != by {
m.EditedBy, changed = by, true
}
if created && m.Created == nil {
now := time.Now().UTC().Truncate(time.Second)
m.Created, m.CreatedBy, changed = &now, by, true
}
if changed {
meta[c] = m
}
return changed, nil
})
}
// AddDetails complète des entrées (chemins virtuels) de leurs détails. Les
// dossiers virtuels, favoris cassés et éléments de la poubelle sont laissés
// tels quels.
func (u *Space) AddDetails(es []*Entry) {
metas := map[*Store]map[string]itemMeta{}
shares := map[*Store]map[string]int{}
for _, e := range es {
if e.Special != "" || e.Broken || e.Origin != "" {
continue
}
st, rel, err := u.route(e.Path)
if err != nil {
continue
}
if _, ok := metas[st]; !ok {
metas[st], shares[st] = st.metaSnapshot(), st.shareCounts()
}
if e.IsDir {
if d, _ := st.dirDetails(rel); d != nil {
d.Shares = shares[st][cleanOr(rel)]
e.Details = d
}
continue
}
e.Details, _ = st.fileDetails(rel, metas[st], shares[st])
}
}
func cleanOr(rel string) string {
c, _ := Clean(rel)
return c
}