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) { 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) { _, 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.metaMu.Lock() defer s.metaMu.Unlock() if s.loadMeta() != nil { return } m := s.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 { s.meta[c] = m _ = s.saveMeta() } } // 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 }