Backend : token_version (000022, claim tv, 401 si révoqué, bump au password — fin limite V1), quota (000023 idempotente, colonne héritée de 000001, 413 QUOTA_EXCEEDED, GET /users/me/usage), devices (GET + DELETE révocation, EnforceDeviceExists en prod), renames concurrents transparents (baseUpdatedAt + conflicts[] non-fataux, tolérance 2 s). Tests service + handlers + migrations + auth. Mobile : pipeline conflits (DTO + SyncConflictStore + worker + dialogue), baseUpdatedAt prêt, liens 7j par défaut, écran Appareils (+ quota), import classeur unifié (scan/note/dossier), onboarding cercle Famille. Contrat docs/api-v1.md, V3.md (S6 livré).
164 lines
4.7 KiB
Go
164 lines
4.7 KiB
Go
package repository
|
|
|
|
import (
|
|
"database/sql"
|
|
"time"
|
|
)
|
|
|
|
// UserRow est une ligne users (identité locale, pas le DTO du contrat).
|
|
type UserRow struct {
|
|
ID string
|
|
Username string
|
|
UsernameNormalized string
|
|
PasswordHash string
|
|
IsAdmin bool
|
|
CreatedAt time.Time
|
|
// V3 S6 : révocation des tokens (bump au changement de password) et
|
|
// quota de stockage (garde-fou upload).
|
|
TokenVersion int
|
|
QuotaBytes int64
|
|
}
|
|
|
|
// Users persiste les comptes utilisateurs (auth par login, cf. tranche identité).
|
|
type Users struct {
|
|
DB *sql.DB
|
|
}
|
|
|
|
// Count retourne le nombre d'utilisateurs ACTIFS (deleted_at IS NULL) — sert
|
|
// au bootstrap admin au démarrage. Une base dont tous les comptes sont
|
|
// soft-deleted est vue comme vide : EnsureAdmin recréera un admin (#9+A10).
|
|
func (u *Users) Count() (int, error) {
|
|
var n int
|
|
err := u.DB.QueryRow(`SELECT COUNT(*) FROM users WHERE deleted_at IS NULL`).Scan(&n)
|
|
return n, err
|
|
}
|
|
|
|
// GetByUsernameNormalized cherche le compte actif par username normalisé
|
|
// (lowercase, unique). Absent → ErrNotFound.
|
|
func (u *Users) GetByUsernameNormalized(normalized string) (*UserRow, error) {
|
|
row := u.DB.QueryRow(
|
|
`SELECT id, username, username_normalized, password_hash, is_admin, created_at,
|
|
token_version, storage_quota_bytes
|
|
FROM users
|
|
WHERE username_normalized = $1 AND deleted_at IS NULL`,
|
|
normalized,
|
|
)
|
|
user, err := scanUser(row.Scan)
|
|
if err == sql.ErrNoRows {
|
|
return nil, ErrNotFound
|
|
}
|
|
return user, err
|
|
}
|
|
|
|
// GetByID charge un compte actif par id. Absent → ErrNotFound.
|
|
func (u *Users) GetByID(id string) (*UserRow, error) {
|
|
row := u.DB.QueryRow(
|
|
`SELECT id, username, username_normalized, password_hash, is_admin, created_at,
|
|
token_version, storage_quota_bytes
|
|
FROM users
|
|
WHERE id = $1 AND deleted_at IS NULL`,
|
|
id,
|
|
)
|
|
user, err := scanUser(row.Scan)
|
|
if err == sql.ErrNoRows {
|
|
return nil, ErrNotFound
|
|
}
|
|
return user, err
|
|
}
|
|
|
|
// ResolveExact est l'unique résolution de destinataire (aucun listing, aucun
|
|
// préfixe) : {id, username} pour le username normalisé, ou ErrNotFound.
|
|
func (u *Users) ResolveExact(normalized string) (*UserRow, error) {
|
|
return u.GetByUsernameNormalized(normalized)
|
|
}
|
|
|
|
// Create insère un compte avec un id 32-hex généré. Retourne l'id.
|
|
func (u *Users) Create(username, usernameNormalized, passwordHash string, isAdmin bool) (string, error) {
|
|
id, err := NewIDErr()
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
_, err = u.DB.Exec(
|
|
`INSERT INTO users (id, username, username_normalized, password_hash, is_admin, created_at)
|
|
VALUES ($1, $2, $3, $4, $5, NOW())`,
|
|
id, username, usernameNormalized, passwordHash, isAdmin,
|
|
)
|
|
if isUniqueViolation(err) {
|
|
return "", ErrNameConflict
|
|
}
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return id, nil
|
|
}
|
|
|
|
// UpdatePassword remplace le hash du compte actif. Compte absent ou
|
|
// soft-deleted → ErrNotFound. Les tokens déjà émis restent valides 7 jours :
|
|
// limite assumée V1 (pas de liste de révocation).
|
|
func (u *Users) UpdatePassword(id, newHash string) error {
|
|
result, err := u.DB.Exec(
|
|
`UPDATE users SET password_hash = $2, updated_at = NOW() WHERE id = $1 AND deleted_at IS NULL`,
|
|
id, newHash,
|
|
)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
affected, err := result.RowsAffected()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if affected == 0 {
|
|
return ErrNotFound
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// MarkDeleted soft-delete un compte actif : les tokens issus sont rejetés par
|
|
// le middleware (GetByID filtre deleted_at). Compte absent ou déjà supprimé →
|
|
// ErrNotFound (pas d'idempotence silencieuse : le second delete signale que
|
|
// la cible n'est plus active).
|
|
func (u *Users) MarkDeleted(id string) error {
|
|
result, err := u.DB.Exec(
|
|
`UPDATE users SET deleted_at = NOW(), updated_at = NOW() WHERE id = $1 AND deleted_at IS NULL`,
|
|
id,
|
|
)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
affected, err := result.RowsAffected()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if affected == 0 {
|
|
return ErrNotFound
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func scanUser(scan func(...any) error) (*UserRow, error) {
|
|
var user UserRow
|
|
err := scan(&user.ID, &user.Username, &user.UsernameNormalized, &user.PasswordHash, &user.IsAdmin, &user.CreatedAt, &user.TokenVersion, &user.QuotaBytes)
|
|
return &user, err
|
|
}
|
|
|
|
// BumpTokenVersion invalide tous les tokens émis (V3 S6) : le middleware
|
|
// rejette les tokens dont le claim `tv` diffère. Compte absent → ErrNotFound.
|
|
func (u *Users) BumpTokenVersion(id string) error {
|
|
result, err := u.DB.Exec(
|
|
`UPDATE users SET token_version = token_version + 1, updated_at = NOW()
|
|
WHERE id = $1 AND deleted_at IS NULL`,
|
|
id,
|
|
)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
affected, err := result.RowsAffected()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if affected == 0 {
|
|
return ErrNotFound
|
|
}
|
|
return nil
|
|
}
|