(Feat) Migration PocketBase

lib/services/client_repository.dart

@@ -1,9 +1,12 @@
+import 'dart:math';
+
 import 'package:flutter/foundation.dart';
 
+import '../config.dart';
 import '../models/client.dart';
 import '../models/mouvement.dart';
 import '../models/recompense.dart';
-import '../supabase_config.dart';
+import '../pocketbase_config.dart';
 import '../utils/format.dart';
 import 'reglages.dart';
 
@@ -15,9 +18,10 @@ class SoldeInsuffisant implements Exception {
   String toString() => 'Solde insuffisant (${points(manquant)} manquants)';
 }
 
-/// Source de vérité des clients (côté staff), adossée à Supabase.
-/// Le solde de points est tenu à jour côté base (trigger) à chaque mouvement ;
-/// on reflète le delta en mémoire pour un affichage immédiat.
+/// Source de vérité des clients (côté staff), adossée à PocketBase.
+/// Comme PocketBase n'a pas de trigger, le solde de points est maintenu par
+/// l'app : à chaque mouvement, on crée l'enregistrement ET on met à jour le
+/// solde du client. Seul le staff (la tablette) écrit → pas de concurrence.
 class ClientRepository extends ChangeNotifier {
   ClientRepository._();
   static final ClientRepository instance = ClientRepository._();
@@ -25,11 +29,13 @@ class ClientRepository extends ChangeNotifier {
   final List<Client> _clients = [];
   bool _charge = false;
   bool _enCours = false;
+  bool _abonne = false;
   String? _erreur;
 
   List<Client> get clients => List.unmodifiable(_clients);
   bool get charge => _charge;
   bool get enCours => _enCours;
+  bool get tempsReelActif => _abonne;
   String? get erreur => _erreur;
 
   Future<void> charger() async {
@@ -37,11 +43,12 @@ class ClientRepository extends ChangeNotifier {
     _erreur = null;
     notifyListeners();
     try {
-      final rows = await supabase.from('clients').select().order('nom');
+      final rows = await pb.collection('clients').getFullList(sort: 'nom');
       _clients
         ..clear()
-        ..addAll((rows as List).map((e) => Client.fromMap(e)));
+        ..addAll(rows.map((r) => Client.fromMap(r.toJson())));
       _charge = true;
+      await _sabonner();
     } catch (e) {
       _erreur = e.toString();
     } finally {
@@ -50,6 +57,34 @@ class ClientRepository extends ChangeNotifier {
     }
   }
 
+  /// Abonnement temps réel : la liste et les soldes se synchronisent en direct
+  /// entre tous les appareils (autre tablette, app client…).
+  Future<void> _sabonner() async {
+    if (_abonne) return;
+    _abonne = true;
+    try {
+      await pb.collection('clients').subscribe('*', (e) {
+        final rec = e.record;
+        if (rec == null) return;
+        if (e.action == 'delete') {
+          _clients.removeWhere((x) => x.id == rec.id);
+        } else {
+          final c = Client.fromMap(rec.toJson());
+          final i = _clients.indexWhere((x) => x.id == c.id);
+          if (i == -1) {
+            _clients.add(c);
+          } else {
+            _clients[i] = c;
+          }
+          _trier();
+        }
+        notifyListeners();
+      });
+    } catch (_) {
+      _abonne = false; // on réessaiera au prochain chargement
+    }
+  }
+
   Client? parCode(String code) {
     for (final c in _clients) {
       if (c.code == code) return c;
@@ -64,7 +99,6 @@ class ClientRepository extends ChangeNotifier {
     return null;
   }
 
-  /// Filtre par nom, téléphone ou code (recherche insensible à la casse).
   List<Client> rechercher(String requete) {
     final q = requete.trim().toLowerCase();
     if (q.isEmpty) return clients;
@@ -77,36 +111,41 @@ class ClientRepository extends ChangeNotifier {
         .toList();
   }
 
-  /// Crée un client « au comptoir » (sans compte de connexion). Le code unique
-  /// et le QR sont générés côté base.
+  /// Crée un client « au comptoir » avec un code unique généré par l'app.
   Future<Client> creer({
     required String nom,
     String? prenom,
     String? telephone,
   }) async {
-    final row = await supabase
-        .from('clients')
-        .insert({
+    // Quelques essais en cas de collision (peu probable) sur le code.
+    Object? derniereErreur;
+    for (var essai = 0; essai < 8; essai++) {
+      try {
+        final rec = await pb.collection('clients').create(body: {
+          'code': _genererCode(),
           'nom': nom.trim(),
           'prenom': _ouNull(prenom),
           'telephone': _ouNull(telephone),
-        })
-        .select()
-        .single();
-    final cree = Client.fromMap(row);
-    _clients.add(cree);
-    _trier();
-    notifyListeners();
-    return cree;
+          'points': 0,
+        });
+        final cree = Client.fromMap(rec.toJson());
+        _clients.add(cree);
+        _trier();
+        notifyListeners();
+        return cree;
+      } catch (e) {
+        derniereErreur = e; // probable conflit d'index unique → on régénère
+      }
+    }
+    throw Exception('Création du client impossible : $derniereErreur');
   }
 
-  /// Modifie nom / prénom / téléphone (pas le solde : il évolue via facture).
   Future<void> modifier(Client c) async {
-    await supabase.from('clients').update({
+    await pb.collection('clients').update(c.id, body: {
       'nom': c.nom.trim(),
       'prenom': _ouNull(c.prenom),
       'telephone': _ouNull(c.telephone),
-    }).eq('id', c.id);
+    });
     final i = _clients.indexWhere((e) => e.id == c.id);
     if (i != -1) {
       _clients[i] =
@@ -116,35 +155,29 @@ class ClientRepository extends ChangeNotifier {
     notifyListeners();
   }
 
-  /// Renvoie null si la chaîne est vide/espaces, sinon la valeur nettoyée.
-  String? _ouNull(String? v) =>
-      (v == null || v.trim().isEmpty) ? null : v.trim();
-
   Future<void> supprimer(String id) async {
-    await supabase.from('clients').delete().eq('id', id);
+    await pb.collection('clients').delete(id);
     _clients.removeWhere((e) => e.id == id);
     notifyListeners();
   }
 
   /// Ajoute une facture : crédite les points correspondant au montant dépensé.
-  /// Retourne le nombre de points gagnés.
   Future<double> ajouterFacture({
     required String clientId,
     required double montantEuros,
   }) async {
     final gagnes = Reglages.instance.pointsPour(montantEuros);
-    await supabase.from('mouvements').insert({
-      'client_id': clientId,
+    await pb.collection('mouvements').create(body: {
+      'client': clientId,
       'type': TypeMouvement.facture,
       'montant_euros': montantEuros,
       'points': gagnes,
       'libelle': 'Facture ${euro(montantEuros)}',
     });
-    _majSoldeMemoire(clientId, gagnes);
+    await _ecrireSolde(clientId, gagnes);
     return gagnes;
   }
 
-  /// Utilise une récompense : débite son coût. Lève [SoldeInsuffisant] si besoin.
   Future<void> utiliserRecompense({
     required String clientId,
     required Recompense recompense,
@@ -154,70 +187,77 @@ class ClientRepository extends ChangeNotifier {
     if (client.points < recompense.coutPoints) {
       throw SoldeInsuffisant(recompense.coutPoints - client.points);
     }
-    await supabase.from('mouvements').insert({
-      'client_id': clientId,
+    await pb.collection('mouvements').create(body: {
+      'client': clientId,
       'type': TypeMouvement.recompense,
       'points': -recompense.coutPoints,
       'libelle': recompense.nom,
     });
-    _majSoldeMemoire(clientId, -recompense.coutPoints);
+    await _ecrireSolde(clientId, -recompense.coutPoints);
   }
 
-  /// Correction manuelle du solde (ajout ou retrait de points).
   Future<void> ajuster({
     required String clientId,
     required double points,
     required String libelle,
   }) async {
-    await supabase.from('mouvements').insert({
-      'client_id': clientId,
+    await pb.collection('mouvements').create(body: {
+      'client': clientId,
       'type': TypeMouvement.ajustement,
       'points': points,
       'libelle': libelle,
     });
-    _majSoldeMemoire(clientId, points);
+    await _ecrireSolde(clientId, points);
   }
 
-  /// Historique d'un client, du plus récent au plus ancien.
-  Future<List<Mouvement>> mouvements(String clientId) async {
-    final rows = await supabase
-        .from('mouvements')
-        .select()
-        .eq('client_id', clientId)
-        .order('created_at', ascending: false);
-    return (rows as List).map((e) => Mouvement.fromMap(e)).toList();
-  }
-
-  /// Corrige le montant d'une facture existante : recalcule les points au ratio
-  /// courant et réajuste le solde du client (via le trigger côté base).
+  /// Corrige le montant d'une facture (recalcule les points au ratio courant).
   Future<void> modifierFacture({
     required Mouvement mouvement,
     required double nouveauMontant,
   }) async {
     final nouveauxPoints = Reglages.instance.pointsPour(nouveauMontant);
-    await supabase.from('mouvements').update({
+    await pb.collection('mouvements').update(mouvement.id, body: {
       'montant_euros': nouveauMontant,
       'points': nouveauxPoints,
       'libelle': 'Facture ${euro(nouveauMontant)}',
-    }).eq('id', mouvement.id);
-    _majSoldeMemoire(mouvement.clientId, nouveauxPoints - mouvement.points);
+    });
+    await _ecrireSolde(mouvement.clientId, nouveauxPoints - mouvement.points);
   }
 
-  /// Supprime un mouvement (facture, récompense ou ajustement). Le solde du
-  /// client est réajusté automatiquement (trigger côté base).
   Future<void> supprimerMouvement(Mouvement mouvement) async {
-    await supabase.from('mouvements').delete().eq('id', mouvement.id);
-    _majSoldeMemoire(mouvement.clientId, -mouvement.points);
+    await pb.collection('mouvements').delete(mouvement.id);
+    await _ecrireSolde(mouvement.clientId, -mouvement.points);
   }
 
-  void _majSoldeMemoire(String clientId, double delta) {
+  Future<List<Mouvement>> mouvements(String clientId) async {
+    final rows = await pb.collection('mouvements').getFullList(
+          filter: 'client = "$clientId"',
+          sort: '-created',
+        );
+    return rows.map((r) => Mouvement.fromMap(r.toJson())).toList();
+  }
+
+  /// Applique un delta au solde du client : met à jour la base ET la mémoire.
+  Future<void> _ecrireSolde(String clientId, double delta) async {
     final i = _clients.indexWhere((c) => c.id == clientId);
-    if (i != -1) {
-      _clients[i] = _clients[i].copyWith(points: _clients[i].points + delta);
-    }
+    final actuel = i != -1 ? _clients[i].points : 0.0;
+    final nouveau = actuel + delta;
+    await pb.collection('clients').update(clientId, body: {'points': nouveau});
+    if (i != -1) _clients[i] = _clients[i].copyWith(points: nouveau);
     notifyListeners();
   }
 
+  String _genererCode() {
+    const alphabet = 'ABCDEFGHJKLMNPQRSTUVWXYZ23456789'; // sans I, O, 0, 1
+    final rnd = Random();
+    final suffixe =
+        List.generate(6, (_) => alphabet[rnd.nextInt(alphabet.length)]).join();
+    return '${Config.prefixeCode}$suffixe';
+  }
+
+  String? _ouNull(String? v) =>
+      (v == null || v.trim().isEmpty) ? null : v.trim();
+
   void _trier() => _clients
       .sort((a, b) => a.nom.toLowerCase().compareTo(b.nom.toLowerCase()));
 }

lib/services/recompense_repository.dart

@@ -1,19 +1,19 @@
 import 'package:flutter/foundation.dart';
 
 import '../models/recompense.dart';
-import '../supabase_config.dart';
+import '../pocketbase_config.dart';
 
-/// Source de vérité du catalogue de récompenses (table `recompenses` Supabase).
+/// Source de vérité du catalogue de récompenses (collection `recompenses`).
 class RecompenseRepository extends ChangeNotifier {
   RecompenseRepository._();
   static final RecompenseRepository instance = RecompenseRepository._();
 
   final List<Recompense> _recompenses = [];
   bool _charge = false;
+  bool _abonne = false;
 
   List<Recompense> get recompenses => List.unmodifiable(_recompenses);
 
-  /// Uniquement les récompenses proposées (actives), triées par coût croissant.
   List<Recompense> get actives {
     final l = _recompenses.where((r) => r.actif).toList()
       ..sort((a, b) => a.coutPoints.compareTo(b.coutPoints));
@@ -25,25 +25,53 @@ class RecompenseRepository extends ChangeNotifier {
   Future<void> charger() async {
     try {
       final rows =
-          await supabase.from('recompenses').select().order('cout_points');
+          await pb.collection('recompenses').getFullList(sort: 'cout_points');
       _recompenses
         ..clear()
-        ..addAll((rows as List).map((e) => Recompense.fromMap(e)));
+        ..addAll(rows.map((r) => Recompense.fromMap(r.toJson())));
       _charge = true;
       notifyListeners();
+      await _sabonner();
     } catch (_) {
-      // Ignore si non connecté ; sera rechargé après connexion.
+      // Ignoré si non connecté ; rechargé après connexion.
+    }
+  }
+
+  /// Abonnement temps réel au catalogue (synchronisé entre appareils).
+  Future<void> _sabonner() async {
+    if (_abonne) return;
+    _abonne = true;
+    try {
+      await pb.collection('recompenses').subscribe('*', (e) {
+        final rec = e.record;
+        if (rec == null) return;
+        if (e.action == 'delete') {
+          _recompenses.removeWhere((x) => x.id == rec.id);
+        } else {
+          final r = Recompense.fromMap(rec.toJson());
+          final i = _recompenses.indexWhere((x) => x.id == r.id);
+          if (i == -1) {
+            _recompenses.add(r);
+          } else {
+            _recompenses[i] = r;
+          }
+          _trier();
+        }
+        notifyListeners();
+      });
+    } catch (_) {
+      _abonne = false;
     }
   }
 
   Future<Recompense> creer(
       {required String nom, required double coutPoints}) async {
-    final row = await supabase
-        .from('recompenses')
-        .insert({'nom': nom.trim(), 'cout_points': coutPoints, 'actif': true})
-        .select()
-        .single();
-    final cree = Recompense.fromMap(row);
+    final rec = await pb.collection('recompenses').create(body: {
+      'nom': nom.trim(),
+      'cout_points': coutPoints,
+      'actif': true,
+    });
+    final cree = Recompense.fromMap(rec.toJson());
     _recompenses.add(cree);
     _trier();
     notifyListeners();
@@ -51,11 +79,11 @@ class RecompenseRepository extends ChangeNotifier {
   }
 
   Future<void> modifier(Recompense r) async {
-    await supabase.from('recompenses').update({
+    await pb.collection('recompenses').update(r.id, body: {
       'nom': r.nom.trim(),
       'cout_points': r.coutPoints,
       'actif': r.actif,
-    }).eq('id', r.id);
+    });
     final i = _recompenses.indexWhere((e) => e.id == r.id);
     if (i != -1) _recompenses[i] = r;
     _trier();
@@ -63,7 +91,7 @@ class RecompenseRepository extends ChangeNotifier {
   }
 
   Future<void> supprimer(String id) async {
-    await supabase.from('recompenses').delete().eq('id', id);
+    await pb.collection('recompenses').delete(id);
     _recompenses.removeWhere((e) => e.id == id);
     notifyListeners();
   }

lib/services/reglages.dart

@@ -1,55 +1,72 @@
 import 'package:flutter/foundation.dart';
 
 import '../config.dart';
-import '../supabase_config.dart';
+import '../pocketbase_config.dart';
 
-/// Réglages globaux du magasin (ligne unique `reglages` id=1 sur Supabase).
-/// Étend [ChangeNotifier] pour que les écrans se rafraîchissent au changement.
+/// Réglages globaux du magasin (unique enregistrement de la collection
+/// `reglages` sur PocketBase). [ChangeNotifier] pour rafraîchir les écrans.
 class Reglages extends ChangeNotifier {
   Reglages._();
   static final Reglages instance = Reglages._();
 
+  String? _recordId;
+  bool _abonne = false;
   double _eurosParPoint = Config.eurosParPointParDefaut;
   String _nomMagasin = '';
 
-  /// Nombre d'euros à dépenser pour gagner 1 point.
   double get eurosParPoint => _eurosParPoint;
-
-  /// Nom du magasin, affiché sur la carte / le QR du client.
   String get nomMagasin => _nomMagasin;
 
   Future<void> charger() async {
     try {
-      final row = await supabase
-          .from('reglages')
-          .select('euros_par_point, nom_magasin')
-          .eq('id', 1)
-          .maybeSingle();
-      if (row != null) {
-        _eurosParPoint = (row['euros_par_point'] as num?)?.toDouble() ??
+      final rows = await pb.collection('reglages').getFullList();
+      if (rows.isNotEmpty) {
+        final r = rows.first;
+        _recordId = r.id;
+        _eurosParPoint = (r.toJson()['euros_par_point'] as num?)?.toDouble() ??
             Config.eurosParPointParDefaut;
-        _nomMagasin = (row['nom_magasin'] as String?) ?? '';
+        _nomMagasin = (r.toJson()['nom_magasin'] as String?) ?? '';
         notifyListeners();
+        await _sabonner();
       }
     } catch (_) {
-      // Réglages par défaut si non connecté / hors-ligne.
+      // Valeurs par défaut si non connecté / serveur injoignable.
+    }
+  }
+
+  /// Abonnement temps réel : un changement de ratio/nom se propage aux appareils.
+  Future<void> _sabonner() async {
+    if (_abonne) return;
+    _abonne = true;
+    try {
+      await pb.collection('reglages').subscribe('*', (e) {
+        final rec = e.record;
+        if (rec == null) return;
+        _recordId = rec.id;
+        _eurosParPoint = (rec.toJson()['euros_par_point'] as num?)?.toDouble() ??
+            _eurosParPoint;
+        _nomMagasin = (rec.toJson()['nom_magasin'] as String?) ?? _nomMagasin;
+        notifyListeners();
+      });
+    } catch (_) {
+      _abonne = false;
     }
   }
 
-  /// Points gagnés pour un montant donné, selon le ratio courant.
   double pointsPour(double euros) =>
       _eurosParPoint > 0 ? euros / _eurosParPoint : 0;
 
   Future<void> definirEurosParPoint(double valeur) async {
-    if (valeur <= 0) return;
-    await supabase.from('reglages').update({'euros_par_point': valeur}).eq('id', 1);
+    if (valeur <= 0 || _recordId == null) return;
+    await pb.collection('reglages').update(_recordId!, body: {'euros_par_point': valeur});
     _eurosParPoint = valeur;
     notifyListeners();
   }
 
   Future<void> definirNomMagasin(String valeur) async {
+    if (_recordId == null) return;
     final v = valeur.trim();
-    await supabase.from('reglages').update({'nom_magasin': v}).eq('id', 1);
+    await pb.collection('reglages').update(_recordId!, body: {'nom_magasin': v});
     _nomMagasin = v;
     notifyListeners();
   }