package storage import ( "encoding/json" "errors" "fmt" "io/fs" "os" "path/filepath" "regexp" "sort" "strings" "time" "unicode/utf8" ) // Tags et favoris des fichiers et dossiers, et icône des dossiers, dans // .meta.json à la racine : // {"items":{"a/b.pdf":{"tags":["NSX"],"favorite":true},"a":{"icon":"server"}}}. // Ils suivent les renommages, déplacements et suppressions. Les fichiers y // gardent aussi leur auteur et leur date de création, et le dernier // utilisateur qui les a enregistrés (details.go). const metaFile = ".meta.json" const ( // MaxTagLen borne la longueur d'un tag (en caractères). MaxTagLen = 40 // MaxTags borne le nombre de tags d'un élément. MaxTags = 20 ) type itemMeta struct { Tags []string `json:"tags,omitempty"` Favorite bool `json:"favorite,omitempty"` Icon string `json:"icon,omitempty"` // dossiers : nom d'icône du frontend // Schémas (details.go) : création et dernier enregistrement. Created *time.Time `json:"created,omitempty"` CreatedBy string `json:"createdBy,omitempty"` EditedBy string `json:"editedBy,omitempty"` } func (m itemMeta) empty() bool { return len(m.Tags) == 0 && !m.Favorite && m.Icon == "" && m.Created == nil && m.CreatedBy == "" && m.EditedBy == "" } // iconName : nom d'icône accepté (le frontend affiche le dossier classique // pour un nom qu'il ne connaît pas). var iconName = regexp.MustCompile(`^[a-z0-9][a-z0-9-]{0,31}$`) // TagCount est un tag utilisé et son nombre d'éléments. type TagCount struct { Name string `json:"name"` Count int `json:"count"` } // loadMeta charge .meta.json au premier accès ; appelé sous metaMu. func (s *Store) loadMeta() error { if s.meta != nil { return nil } var d struct { Items map[string]itemMeta `json:"items"` } b, err := os.ReadFile(filepath.Join(s.root, metaFile)) switch { case errors.Is(err, fs.ErrNotExist): case err != nil: return err default: if err := json.Unmarshal(b, &d); err != nil { return fmt.Errorf("%s : %w", metaFile, err) } } if d.Items == nil { d.Items = map[string]itemMeta{} } s.meta = d.Items return nil } // saveMeta écrit .meta.json ; appelé sous metaMu. func (s *Store) saveMeta() error { for k, m := range s.meta { if m.empty() { delete(s.meta, k) } } b, err := json.Marshal(map[string]any{"items": s.meta}) if err != nil { return err } return atomicWrite(filepath.Join(s.root, metaFile), b) } // metaSnapshot renvoie une copie des métadonnées (pour List et Search) ; // vide en cas d'erreur de lecture. func (s *Store) metaSnapshot() map[string]itemMeta { m, err := s.readMeta() if err != nil { return map[string]itemMeta{} } return m } // readMeta renvoie une copie des métadonnées de la racine (fichier .meta.json // ou catalogue PostgreSQL). func (s *Store) readMeta() (map[string]itemMeta, error) { if s.cat != nil { return s.cat.readMeta() } s.metaMu.Lock() defer s.metaMu.Unlock() if err := s.loadMeta(); err != nil { return nil, err } out := make(map[string]itemMeta, len(s.meta)) for k, v := range s.meta { out[k] = v } return out, nil } // updateMeta applique fn aux métadonnées de la racine sous verrou (verrou du // processus, ou verrou consultatif PostgreSQL partagé par les instances) et // enregistre le résultat si fn renvoie true. fn reçoit une copie : rien n'est // enregistré en cas d'erreur. func (s *Store) updateMeta(fn func(map[string]itemMeta) (bool, error)) error { if s.cat != nil { return s.cat.updateMeta(fn) } s.metaMu.Lock() defer s.metaMu.Unlock() if err := s.loadMeta(); err != nil { return err } m := make(map[string]itemMeta, len(s.meta)) for k, v := range s.meta { m[k] = v } changed, err := fn(m) if err != nil || !changed { return err } old := s.meta s.meta = m if err := s.saveMeta(); err != nil { s.meta = old return err } return nil } func decorate(e *Entry, meta map[string]itemMeta) { if m, ok := meta[e.Path]; ok { e.Tags, e.Favorite = m.Tags, m.Favorite if e.IsDir { e.Icon = m.Icon } else { e.EditedBy = m.EditedBy } } } func normTag(t string) (string, error) { t = strings.Join(strings.Fields(strings.TrimPrefix(strings.TrimSpace(t), "#")), " ") switch { case t == "", !utf8.ValidString(t), strings.ContainsAny(t, ",\x00"): return "", fmt.Errorf("%w : tag %q", ErrInvalidPath, t) case utf8.RuneCountInString(t) > MaxTagLen: return "", fmt.Errorf("%w : tag de %d caractères max", ErrInvalidPath, MaxTagLen) } return t, nil } // editMeta vérifie que chaque chemin existe puis applique edit à ses // métadonnées, et enregistre le tout. func (s *Store) editMeta(paths []string, edit func(*itemMeta) error) error { cs := make([]string, 0, len(paths)) for _, p := range paths { c, err := Clean(p) if err != nil { return err } if c == "" { return ErrInvalidPath } if _, _, err := s.lstat(c); err != nil { return err } cs = append(cs, c) } return s.updateMeta(func(meta map[string]itemMeta) (bool, error) { for _, c := range cs { m := meta[c] m.Tags = append([]string(nil), m.Tags...) if err := edit(&m); err != nil { return false, err } meta[c] = m } return true, nil }) } // SetFavorite ajoute ou retire des éléments des favoris. func (s *Store) SetFavorite(paths []string, favorite bool) error { return s.editMeta(paths, func(m *itemMeta) error { m.Favorite = favorite return nil }) } // SetIcon choisit l'icône de dossiers ; icon = "" rétablit l'icône par défaut. func (s *Store) SetIcon(paths []string, icon string) error { if icon != "" && !iconName.MatchString(icon) { return fmt.Errorf("%w : icône %q", ErrInvalidPath, icon) } for _, p := range paths { if _, fi, err := s.lstat(p); err != nil { return err } else if !fi.IsDir() { return fmt.Errorf("%w : %q n'est pas un dossier", ErrInvalidPath, p) } } return s.editMeta(paths, func(m *itemMeta) error { m.Icon = icon return nil }) } // EditTags ajoute et retire des tags sur des éléments. Les tags sont comparés // sans casse ni accents ; un tag déjà utilisé garde son écriture d'origine. func (s *Store) EditTags(paths, add, remove []string) error { var adds []string for _, t := range add { n, err := normTag(t) if err != nil { return err } adds = append(adds, n) } drop := map[string]bool{} for _, t := range remove { drop[fold(strings.TrimSpace(t))] = true } canon := map[string]string{} // écriture existante de chaque tag all, err := s.readMeta() if err != nil { return err } for _, m := range all { for _, t := range m.Tags { if _, ok := canon[fold(t)]; !ok { canon[fold(t)] = t } } } return s.editMeta(paths, func(m *itemMeta) error { kept := m.Tags[:0] has := map[string]bool{} for _, t := range m.Tags { if !drop[fold(t)] && !has[fold(t)] { kept = append(kept, t) has[fold(t)] = true } } for _, t := range adds { if has[fold(t)] { continue } if c, ok := canon[fold(t)]; ok { t = c } kept = append(kept, t) has[fold(t)] = true } if len(kept) > MaxTags { return fmt.Errorf("%w : %d tags max par élément", ErrInvalidPath, MaxTags) } sort.Slice(kept, func(i, j int) bool { return fold(kept[i]) < fold(kept[j]) }) m.Tags = kept return nil }) } // Tags liste les tags utilisés, triés par nom, avec leur nombre d'éléments. func (s *Store) Tags() ([]TagCount, error) { all, err := s.readMeta() if err != nil { return nil, err } idx := map[string]int{} out := []TagCount{} for _, m := range all { for _, t := range m.Tags { k := fold(t) if i, ok := idx[k]; ok { out[i].Count++ } else { idx[k] = len(out) out = append(out, TagCount{Name: t, Count: 1}) } } } sort.Slice(out, func(i, j int) bool { return fold(out[i].Name) < fold(out[j].Name) }) return out, nil } // Les opérations suivantes accompagnent Move/Copy/Delete (au mieux). func under(k, c string) bool { return k == c || strings.HasPrefix(k, c+"/") } func (s *Store) moveMeta(from, to string) { _ = s.updateMeta(func(meta map[string]itemMeta) (bool, error) { moved := map[string]itemMeta{} for k, m := range meta { if under(k, from) { delete(meta, k) moved[to+k[len(from):]] = m } } for k, m := range moved { meta[k] = m } return len(moved) > 0, nil }) } func (s *Store) copyMeta(from, to string) { _ = s.updateMeta(func(meta map[string]itemMeta) (bool, error) { if m, ok := meta[from]; ok && len(m.Tags) > 0 { meta[to] = itemMeta{Tags: append([]string(nil), m.Tags...)} // pas le favori return true, nil } return false, nil }) } func (s *Store) removeMeta(c string) { _ = s.updateMeta(func(meta map[string]itemMeta) (bool, error) { changed := false for k := range meta { if under(k, c) { delete(meta, k) changed = true } } return changed, nil }) }