Récupérer et Ajouter des Données dans Firestore avec Flutter et StreamProvider

// Classe représentant un utilisateur avec deux attributs : name et age
class UserModel {
  // Attributs (ou propriétés) de l'utilisateur
  String name;
  int age;

  // Constructeur principal : permet de créer un objet UserModel avec un nom et un âge
  UserModel({required this.name, required this.age});

  // Constructeur nommé 'fromJson' : permet de créer un objet UserModel à partir d'une Map (JSON)
  // Utile pour convertir les données provenant de Firestore, d'une API REST, etc.
  UserModel.fromJson(Map<String, dynamic> parsedJSON)
      : name = parsedJSON['name'],
        // Vérifie que 'age' est bien un int ; sinon, le convertit en int (ex : si c'est un double)
        age = parsedJSON['age'] is int ? parsedJSON['age'] : parsedJSON['age'].toInt();
}

// Importation de la bibliothèque Firestore de Firebase
// Elle permet d’accéder aux collections et documents de la base de données Cloud Firestore
import 'package:cloud_firestore/cloud_firestore.dart';
// Importation du modèle de données UserModel (représente un utilisateur avec ses propriétés)
import '../models/user_model.dart';
// Déclaration de la classe de service Firebase
// Elle centralise toutes les interactions avec Firestore liées aux utilisateurs
class FirebaseServices {
  // Création d'une instance unique de Firestore
  // Cette instance (_db) permet d'effectuer toutes les opérations de lecture/écriture sur Firestore
  final FirebaseFirestore _db = FirebaseFirestore.instance;
  // Méthode pour récupérer les utilisateurs en temps réel depuis la collection 'user'
  // Elle retourne un Stream (flux) de liste d'utilisateurs de type UserModel
  Stream<List<UserModel>> getUsers() { 
    // Accès à la collection 'user' dans Firestore
    // .snapshots() écoute les modifications en temps réel (ajout, suppression, modification)
    return _db.collection('user').snapshots().map(   
      // Pour chaque snapshot (état actuel de la collection), on transforme chaque document...
      (snapshot) => snapshot.docs.map(
        // ...en objet UserModel à l'aide du constructeur fromJson
        (doc) => UserModel.fromJson(doc.data()),
      // Une fois que tous les documents sont convertis, on les transforme en liste
      ).toList()
    );
  }
}

// Importation des widgets Flutter nécessaires à l'interface utilisateur
import 'package:flutter/material.dart';

// Importation du package Provider pour la gestion d’état via StreamProvider et Consumer
import 'package:provider/provider.dart';

// Importation du modèle UserModel, qui représente la structure d’un utilisateur
import '../models/user_model.dart';

// Importation de la classe FirebaseServices, qui contient la méthode pour récupérer les utilisateurs
import '../services/firebase_services.dart';
// Définition d’un widget stateless pour afficher la liste des utilisateurs
class ViewUsersPage extends StatelessWidget {
  
  // Création d’une instance de FirebaseServices pour accéder à Firestore
  final FirebaseServices firebaseServices = FirebaseServices();

  // Constructeur avec clé optionnelle
  ViewUsersPage({super.key});
  @override
  Widget build(BuildContext context) {
    
    // Utilisation de StreamProvider pour fournir un flux de List<UserModel> à l’arbre des widgets
    return StreamProvider<List<UserModel>>(
      
      // Source des données : appel à la méthode getUsers() qui retourne un Stream<List<UserModel>>
      create: (_) => firebaseServices.getUsers(),
      
      // Données initiales avant l’arrivée du flux réel
      initialData: [],
      // Scaffold : structure de base de la page
      child: Scaffold(
        
        // Barre d’application en haut de l’écran
        appBar: AppBar(
          elevation: 4,
          title: Text('Liste des utilisateurs'), // Titre de l'appBar
          centerTitle: true,                    // Centrage du titre
          backgroundColor: Colors.amber,        // Couleur de fond
        ),
        // Body : zone principale du contenu
        body: Consumer<List<UserModel>>(
          
          // Consumer : écoute les données fournies par le StreamProvider (ici, List<UserModel>)
          builder: (context, users, _) {

            // Si la liste est vide, afficher un message
            if (users.isEmpty) {
              return Center(child: Text('Aucun utilisateur trouvé.'));
            }

            // Sinon, afficher une liste d’utilisateurs
            return ListView.builder(
              itemCount: users.length, // Nombre total d’éléments à afficher
              itemBuilder: (_, index) {
                final user = users[index]; // Récupérer un utilisateur à l’index donné

                // Affichage d’un utilisateur avec ListTile
                return ListTile(
                  leading: CircleAvatar(child: Icon(Icons.person)), // Avatar avec icône
                  title: Text(user.name),                           // Nom de l'utilisateur
                  subtitle: Text('${user.age} ans'),                // Âge de l'utilisateur
                );
              },
            );
          },
        ),
      ),
    );
  }
}

import 'package:flutter/material.dart';
import '../models/user_model.dart';
import '../services/firebase_services.dart';

class AddUserDialog extends StatefulWidget {
  const AddUserDialog({super.key});

  @override
  _AddUserDialogState createState() => _AddUserDialogState();
}

class _AddUserDialogState extends State<AddUserDialog> {
  final _formKey = GlobalKey<FormState>();
  String _name = '';
  int _age = 0;

  final FirebaseServices _firebaseServices = FirebaseServices();

  @override
  Widget build(BuildContext context) {
    return AlertDialog(
      title: const Text('Ajouter un utilisateur'),
      content: Form(
        key: _formKey,
        child: Column(
          mainAxisSize: MainAxisSize.min,
          children: [
            // Champ nom
            TextFormField(
              decoration: const InputDecoration(labelText: 'Nom'),
              validator: (value) =>
                  value == null || value.isEmpty ? 'Entrez un nom' : null,
              onSaved: (value) => _name = value!,
            ),
            // Champ âge
            TextFormField(
              decoration: const InputDecoration(labelText: 'Âge'),
              keyboardType: TextInputType.number,
              validator: (value) =>
                  value == null || int.tryParse(value) == null
                      ? 'Entrez un âge valide'
                      : null,
              onSaved: (value) => _age = int.parse(value!),
            ),
          ],
        ),
      ),
      actions: [
        TextButton(
          onPressed: () => Navigator.pop(context),
          child: const Text('Annuler'),
        ),
        ElevatedButton(
          onPressed: () {
            if (_formKey.currentState!.validate()) {
              _formKey.currentState!.save();
              _firebaseServices.addUser(UserModel(name: _name, age: _age));
              Navigator.pop(context);
            }
          },
          child: const Text('Ajouter'),
        ),
      ],
    );
  }
}

 // Ajouter un utilisateur
  Future<void> addUser(UserModel user) async {
    await _db.collection('user').add({
      'name': user.name,
      'age': user.age,
    });
  }

floatingActionButton: FloatingActionButton(
  onPressed: () {
    // Ouvrir une boîte de dialogue pour ajouter un utilisateur
    showDialog(
      context: context,
      builder: (context) => AddUserDialog(),
    );
  },
  backgroundColor: Colors.amber,
  child: Icon(Icons.add),
),