Travailler avec Firebase Authentication dans Flutter

• Création de comptes utilisateurs
• Vérification d’emails
• Réinitialisation de mots de passe
• Gestion des sessions
• Sécurité des données…

Utilisateur ➜ View (Formulaire) ➜ Controller ➜ Model ➜ Firestore  
          ⬆︎                  ⬆︎                       ⬆︎
      Affichage        Logique MÉTIER              Données stockées

1. MODÈLE (models/livre.dart)

• Rôle : Définir la structure des données.
• Comprendre que le modèle est la véritable représentation du livre.

class Livre {
  final String titre;
  final String auteur;
  final int annee;

  Livre({required this.titre, required this.auteur, required this.annee});

  // Convertit l'objet en Map pour Firestore
  Map toMap() {
    return {
      'titre': titre,
      'auteur': auteur,
      'annee': annee,
    };
  }
}

• À retenir :

On crée une classe Livre pour garder un code propre et clair.

.toMap() permet de transformer l’objet en format compréhensible par Firestore.

2. CONTROLLER (controllers/livre_controller.dart)

• Rôle : Gérer la logique métier.
• C’est le « chef d’orchestre » entre la vue et la base de données.

import 'package:cloud_firestore/cloud_firestore.dart';
import '../models/livre.dart';

class LivreController {
  final CollectionReference _livresRef =
    FirebaseFirestore.instance.collection('livres');

  Future ajouterLivre(Livre livre) async {
    try {
      await _livresRef.add(livre.toMap());
      print("Livre ajouté avec succès !");
    } catch (e) {
      print("Erreur lors de l'ajout: $e");
    }
  }
}

• À retenir :

Le contrôleur prépare la donnée avant l’envoi.

On y trouve souvent try/catch pour bien gérer les erreurs.

La vue ne parle pas directement à Firestore → elle passe par le contrôleur.

3. VUE (views/ajouter_livre.dart)

• Rôle : Afficher l’interface et récupérer les données de l’utilisateur.

import 'package:flutter/material.dart';
import '../models/livre.dart';
import '../controllers/livre_controller.dart';

class AjouterLivreView extends StatelessWidget {
  final _titreController = TextEditingController();
  final _auteurController = TextEditingController();
  final _anneeController = TextEditingController();

  final LivreController livreController = LivreController();

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: Text("Ajouter un Livre")),
      body: Padding(
        padding: const EdgeInsets.all(16.0),
        child: Column(
          children: [
            TextField(controller: _titreController, decoration: InputDecoration(labelText: "Titre")),
            TextField(controller: _auteurController, decoration: InputDecoration(labelText: "Auteur")),
            TextField(controller: _anneeController, decoration: InputDecoration(labelText: "Année"), keyboardType: TextInputType.number),
            SizedBox(height: 20),
            ElevatedButton(
              onPressed: () {
                Livre livre = Livre(
                  titre: _titreController.text,
                  auteur: _auteurController.text,
                  annee: int.parse(_anneeController.text),
                );
                livreController.ajouterLivre(livre);
              },
              child: Text("Ajouter"),
            ),
          ],
        ),
      ),
    );
  }
}

• À retenir :

La vue affiche uniquement l’interface → pas de logique Firestore ici !

Elle utilise des champs TextField pour capturer les données.

Au clic, elle crée un Livre puis appelle une méthode du controller.

✅ Ajouter de nouveaux livres
📖 Consulter la liste des livres
✏️ Modifier les informations d’un livre
🗑️ Supprimer des livres
🔍 Rechercher des livres

Architecture MVC imposée

lib/
├── main.dart                      # Point d'entrée de l'application
├── firebase_options.dart          # Configuration Firebase
├── models/
│   └── livre_model.dart           # Modèle de données
├── controllers/
│   └── livre_controller.dart      # Logique métier & Firestore
└── views/
    ├── liste_livres_view.dart     # Écran principal
    └── ajouter_livre_view.dart    # Formulaire d'ajout

1. Règles et bonnes pratiques pour créer un document dans Firestore :

1. Utiliser des modèles (classes) pour représenter les données

• Toujours créer une classe Livre (ou autre) pour représenter un document :

class Livre {
  final String titre;
  final String auteur;
  final int annee;

  Livre({required this.titre, required this.auteur, required this.annee});

  Map toMap() {
    return {
      'titre': titre,
      'auteur': auteur,
      'annee': annee,
    };
  }
}

• Avantage : cohérence, lisibilité du code, moins d’erreurs lors du stockage.

2. Utiliser add() ou doc().set() selon le besoin

• Dans Firestore, vous pouvez créer un document dans une collection de deux manières :
• Avec .add() ➜ Id auto-généré par Firestore :

await FirebaseFirestore.instance
        .collection('livres')
        .add(livre.toMap());

• Avec .doc(id).set() ➜ Id personnalisé :
• Vous choisissez vous-même l’ID du document.
• Utile quand vous devez garantir l’unicité ou utiliser un ID déjà connu.
• Donne un meilleur contrôle sur la structure de votre base de données.

await FirebaseFirestore.instance
        .collection('livres')
        .doc(livreId)
        .set(livre.toMap());

3. Toujours gérer les exceptions
• Exemple :

try {
  await _livresRef.add(livre.toMap());
} catch (e) {
  print("Erreur lors de l'ajout: $e");
}


Important : ne jamais laisser une erreur Firestore passer en silence.

2. Lire un document dans Firestore:

• Firestore propose 2 niveaux de lecture :
• Document spécifique (via son ID)
• Tous les documents d’une collection
• Et 2 modes de récupération :
• En continu (temps réel) avec snapshots() ➜ Retourne un Stream
• Une seule fois (ponctuel) avec get() ➜ Retourne un Future

1. Lire tous les documents d’une collection

• En temps réel (Stream)
• Mise à jour automatique des données dès qu’un changement a lieu.

Stream, doc.id);
    }).toList();
  });
}

• Utilisation typique :
• Afficher une liste de livres dans un StreamBuilder.
• Utile pour un flux dynamique d’informations (ex : messages chat, liste mise à
  jour en direct).
2. Lecture ponctuelle (Future)
• Lecture « one shot« , uniquement au moment où le code est exécuté.

Future<List<Livre>> getTousLesLivres() async {
  try {
    final snapshot = await _livresRef.get();
    return snapshot.docs
        .map((doc) => Livre.fromFirestore(doc.data() as Map<String, dynamic>, doc.id))
        .toList();
  } catch (e) {
    throw 'Erreur lors de la récupération : $e';
  }
}

• Utilisation typique :
• Charger une liste statique, non mise à jour automatiquement.
• Exemple : Exporter une liste d’objets dans un fichier Excel.

3. Lire un document spécifique via son ID

• En temps réel (Stream)
• Pour suivre les changements en direct sur un seul document.

Stream<Livre?> getLivreStreamById(String id) {
  return _livresRef.doc(id).snapshots().map((doc) {
    if (doc.exists) {
      return Livre.fromFirestore(doc.data() as Map<String, dynamic>, doc.id);
    }
    return null;
  });
}

• Utilisation typique :
• Suivre l’état d’un document en particulier (ex : stock en temps réel, statut de
  commande).
• Lecture ponctuelle (Future)
• Lecture ciblée, destinée à une action ponctuelle ou une navigation.
• C’est idéal pour récupérer les données d’un seul document lors d’une navigation ou
  d’une action spécifique, comme ouvrir une page de détails pour un livre.
• Il utilise await ... .get() → cela indique une lecture une seule fois,
  au moment précis où tu appelles la fonction.

Future<Livre?> getLivreById(String id) async {
  try {
    final doc = await _livresRef.doc(id).get();
    if (doc.exists) {
      return Livre.fromFirestore(doc.data() as Map<String, dynamic>, doc.id);
    }
    return null;
  } catch (e) {
    throw 'Erreur lors de la récupération: $e';
  }
}

• Utilisation typique :
• Récupérer les détails d’un élément lors d’une navigation vers une nouvelle page.

4. Récapitulatif visuel

Lecture	Cible	Mode	Retourne	Exemples
.collection().snapshots()	Tous les documents	Temps réel	Stream<List>	Liste des livres qui se met à jour automatiquement
.collection().get()	Tous les documents	Ponctuel	Future<List>	Exporter tous les livres une seule fois
.doc(id).snapshots()	Document spécifique	Temps réel	Stream	Observer l’état d’un seul livre (ex : stock, statut)
.doc(id).get()	Document spécifique	Ponctuel	Future	Lire un livre quand on en a besoin (page détail)

3. Méthodes de Mise à Jour Firestore:

1. MISE À JOUR PARTIELLE – update()

• Concept : Modifier seulement certains champs d’un document existant
• MISE À JOUR D’UN SEUL CHAMP

await FirebaseFirestore.instance
    .collection('livres')
    .doc('abc123')              // Document existant
    .update({
      'titre': 'Nouveau Titre'  // Seul ce champ sera modifié
    });

• MISE À JOUR DE PLUSIEURS CHAMPS

await FirebaseFirestore.instance
    .collection('livres')
    .doc('abc123')
    .update({
      'titre': 'Titre Modifié',
      'auteur': 'Nouvel Auteur', 
      'annee': 2024
    });

2. REMPLACEMENT COMPLET -set() sur document existant

• Concept : Remplacer TOUT le document existant

await FirebaseFirestore.instance
    .collection('livres')
    .doc('abc123')  // Document doit EXISTER
    .set({
      'titre': 'Nouveau Titre',
      'auteur': 'Nouvel Auteur',
      'annee': 2024
      // Tous les anciens champs sont remplacés
    });

3. MISE À JOUR AVEC FUSION – set(merge: true)

• Concept : Mettre à jour certains champs sans supprimer les autres

await FirebaseFirestore.instance
    .collection('livres')
    .doc('abc123')
    .set({
      'titre': 'Titre Modifié',
      'auteur': 'Auteur Modifié'
    }, SetOptions(merge: true));  // ← Les autres champs sont conservés 

• Exemple—>AVANT/APRÈS :

{
  "titre": "Ancien Titre", 
  "auteur": "Auteur Original",
  "annee": 2000,
  "genre": "Roman"
}

// APRÈS set() avec merge: true
{
  "titre": "Titre Modifié",      // ← Modifié
  "auteur": "Auteur Modifié",    // ← Modifié
  "annee": 2000,                 // ← Conservé !
  "genre": "Roman"               // ← Conservé !
}

4. Supprimer un document :

• Pour supprimer un document, vous pouvez utiliser la méthode ‘delete’ sur une référence de
  document. Par exemple :

Firestore.instance.collection('collection').document('document').delete();

1. Principe général de la recherche dans Firestore

• Firestore ne fonctionne pas comme une base SQL :
• Il n’y a pas de SELECT * FROM ... WHERE ... LIKE.
• À la place, on utilise des requêtes structurées avec la méthode .where().
• Les requêtes Firestore :
• Filtrent les documents selon des champs spécifiques,
• Peuvent être ponctuelles (get()) ou en temps réel (snapshots()),
• Nécessitent parfois des index pour plusieurs conditions.

2. Rechercher selon la valeur exacte d’un champ (Rechercher des livres par auteur)

1. Définition

Cette recherche consiste à filtrer les documents selon la valeur exacte d’un champ.
Exemple : retrouver tous les livres écrits par Victor Hugo.

🔹 Lecture ponctuelle (Future)

Lecture « one-shot », exécutée une seule fois au moment de l’appel.

Future<List<Livre>> rechercherLivresParAuteur(String auteur) async {
  try {
    final snapshot = await FirebaseFirestore.instance
        .collection('livres')
        .where('auteur', isEqualTo: auteur) // Filtre sur le champ 'auteur'
        .get(); // Lecture ponctuelle

    // Conversion des documents Firestore en objets Livre
    return snapshot.docs.map((doc) {
      return Livre.fromFirestore(doc.data() as Map<String, dynamic>, doc.id);
    }).toList();
  } catch (e) {
    throw 'Erreur lors de la recherche : $e';
  }
}
			

🧭 Utilisation typique :
Afficher la liste des livres d’un auteur donné.
Exemple : l’utilisateur saisit « Victor Hugo » dans un champ de recherche.

🔹 Recherche dynamique en temps réel (Stream)

Lecture en continu, les résultats sont automatiquement mis à jour lorsqu’un changement a lieu dans Firestore.

Stream<List<Livre>> rechercherLivresStream(String auteur) {
  return FirebaseFirestore.instance
      .collection('livres')
      .where('auteur', isEqualTo: auteur)
      .snapshots() // Écoute en temps réel
      .map((snapshot) {
        return snapshot.docs.map((doc) {
          return Livre.fromFirestore(doc.data() as Map<String, dynamic>, doc.id);
        }).toList();
      });
}
			

🧭 Utilisation typique :
Rafraîchir automatiquement la liste affichée à l’écran.
Exemple : affichage avec un StreamBuilder dans Flutter.

3. Recherche avec plusieurs critères

1. Définition

Tu peux combiner plusieurs conditions (where) pour affiner la recherche.
⚠️ Firestore impose certaines limites (souvent un index combiné est requis).

🔹 Exemple : auteur + année minimale

Future<List<Livre>> rechercherLivresAvances(String auteur, int anneeMin) async {
  try {
    final snapshot = await FirebaseFirestore.instance
        .collection('livres')
        .where('auteur', isEqualTo: auteur)
        .where('annee', isGreaterThanOrEqualTo: anneeMin)
        .get();

    return snapshot.docs.map((doc) {
      return Livre.fromFirestore(doc.data() as Map<String, dynamic>, doc.id);
    }).toList();
  } catch (e) {
    throw 'Erreur lors de la recherche avancée : $e';
  }
}
			

🧭 Utilisation typique :
Rechercher tous les livres de Victor Hugo publiés après 1850.
Utile pour des filtres combinés (par année, catégorie, auteur…).

4. Recherche par mot-clé (titre ou recherche partielle)

1. Définition

Firestore ne prend pas en charge les recherches textuelles floues (contains, startsWith, etc.) comme SQL.
➡️ Solution : créer un champ d’index de mots-clés (keywords) dans chaque document.

🔹 Exemple de structure de document

{
  "titre": "Les Misérables",
  "auteur": "Victor Hugo",
  "annee": 1862,
  "keywords": ["les", "misérables", "les misérables", "victor hugo"]
}
			

Chaque document contient un tableau keywords utilisé pour la recherche.

🔹 Exemple de fonction Dart

Future<List<Livre>> rechercherParMotCle(String mot) async {
  try {
    final snapshot = await FirebaseFirestore.instance
        .collection('livres')
        .where('keywords', arrayContains: mot.toLowerCase())
        .get();

    return snapshot.docs.map((doc) {
      return Livre.fromFirestore(doc.data() as Map<String, dynamic>, doc.id);
    }).toList();
  } catch (e) {
    throw 'Erreur lors de la recherche par mot-clé : $e';
  }
}
			

🧭 Utilisation typique :
Recherche « intelligente » dans une barre de recherche.
Exemple : taper “mis” retourne Les Misérables grâce au champ keywords.

5. Récapitulatif visuel des recherches

Type de recherche	Méthode Firestore	Mode	Retourne	Exemple d’usage
Filtrage simple	.where('auteur', isEqualTo: ...)	Ponctuel (get())	Future<List>	Trouver tous les livres d’un auteur
Filtrage numérique	.where('annee', isGreaterThanOrEqualTo: ...)	Ponctuel ou Stream	Liste filtrée	Livres publiés après une certaine année
Temps réel	.snapshots()	Stream	Stream<List>	Résultats mis à jour automatiquement
Recherche par mot-clé	.where('keywords', arrayContains: ...)	Ponctuel	Liste filtrée	Recherche partielle sur le titre

6. Activité

• Ajouter une zone de recherche dans ton interface pour filtrer les livres en temps réel selon le titre saisi.
• Dans une petite application, il est plus ergonomique d’intégrer la recherche dans la liste principale.
  Cependant, dans une application plus complexe (ex : librairie en ligne), il est préférable d’avoir une page de recherche dédiée, pour gérer plusieurs filtres et une interface plus riche.
• Étapes globales
• Transformer ListeLivresView en StatefulWidget (car la recherche change dynamiquement).
• Ajouter un TextField (champ de recherche) dans la page.
• Utiliser livreController.rechercherLivres(query) quand le champ n’est pas vide, sinon afficher la liste complète avec getLivresStream().