207 lines
5.2 KiB
Go
207 lines
5.2 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) {
|
|
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
|
|
}
|