Se connecter à Flutter avec PHP MySQL

<?php
require_once('config.php');
// Créer une nouvelle connexion PDO
try {
    $pdo = new PDO("mysql:host=".DB_HOST.";dbname=".DB_NAME.";charset=".DB_CHARSET, 
    DB_USER, DB_PASSWORD);
    
    // Activer le mode d'erreur PDO
    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
    
    // Activer le mode d'émulation PDO pour désactiver l'utilisation de 'prepared statements'
    $pdo->setAttribute(PDO::ATTR_EMULATE_PREPARES, false);
} catch(PDOException $e) {
    // En cas d'erreur de connexion à la base de données, afficher un message d'erreur et arrêter le script
    die("Erreur de connexion à la base de données: ".$e->getMessage());
}
?>

import 'package:exemple01/services/api_base.dart';
import 'package:flutter/material.dart';
import 'package:shared_preferences/shared_preferences.dart';
import '../services/auth_api.dart';
import '../models/user_model.dart';

class AuthController with ChangeNotifier {
  User? _user;
  String? _token;
  bool _isLoading = false;
  String? _errorMessage;

  User? get user => _user;
  String? get token => _token;
  bool get isLoading => _isLoading;
  String? get errorMessage => _errorMessage;
  bool get isAuthenticated => _user != null && _token != null;

  // Méthode de connexion
  Future<bool> login(String email, String password) async {
    _isLoading = true;
    _errorMessage = null;
    notifyListeners();

    try {
      final result = await AuthApi.login(email, password);
      
      if (result['success'] == true) {
        _user = User.fromJson(result['user']);
        _token = result['token'] ?? '';
        _errorMessage = null;
        
        // Sauvegarder le token et les données utilisateur
        await _saveToken(_token!);
        await _saveUser(_user!);
        
        _isLoading = false;
        notifyListeners();
        return true;
      } else {
        _errorMessage = result['message'];
        _isLoading = false;
        notifyListeners();
        return false;
      }
    } catch (e) {
      _errorMessage = 'Erreur de connexion: $e';
      _isLoading = false;
      notifyListeners();
      return false;
    }
  }

  // Méthode d'inscription MODIFIÉE
  Future<bool> register({
  required String email,
  required String password,
  String? nomComplet,
  String? pays,
  String? numTel,
  String? urlPhotoProfil,
  List<String>? roles,
}) async {
  _isLoading = true;
  _errorMessage = null;
  notifyListeners();

  try {
    // ✅ Forcer le rôle sélectionné ou ROLE_USER par défaut
    final List<String> finalRoles =
        (roles != null && roles.isNotEmpty)
            ? roles
            : ['ROLE_USER'];

    final data = await AuthApi.register(
      email: email,
      password: password,
      nomComplet: nomComplet,
      pays: pays,
      numTel: numTel,
      urlPhotoProfil: urlPhotoProfil,
      roles: finalRoles, // ✅ rôle garanti
    );

    if (data['success'] == true) {
      _user = User.fromJson(data['user']);
      _token = data['token'];

      await _saveToken(_token!);
      await _saveUser(_user!);

      _isLoading = false;
      notifyListeners();
      return true;
    } else {
      _errorMessage = data['message'] ?? "Erreur d'inscription";
      _isLoading = false;
      notifyListeners();
      return false;
    }
  } catch (e) {
    _errorMessage = e.toString();
    _isLoading = false;
    notifyListeners();
    return false;
  }
}


  // Méthode de déconnexion
  Future<void> logout() async {
    _isLoading = true;
    notifyListeners();

    try {
      if (_token != null && _token!.isNotEmpty) {
        try {
          await AuthApi.logout(_token!);
          print('✅ Déconnexion API réussie');
        } catch (e) {
          print('⚠️ Erreur lors de la déconnexion API (ignorée): $e');
        }
      }
      
      await _clearLocalData();
      
    } catch (e) {
      print('⚠️ Erreur dans logout (nettoyage local): $e');
      await _clearLocalData();
    } finally {
      _isLoading = false;
      notifyListeners();
    }
  }

  // Sauvegarder le token dans SharedPreferences
  Future<void> _saveToken(String token) async {
    try {
      final prefs = await SharedPreferences.getInstance();
      await prefs.setString('auth_token', token);
      print('✅ Token sauvegardé');
    } catch (e) {
      print('⚠️ Erreur lors de la sauvegarde du token: $e');
    }
  }

  // Sauvegarder les données utilisateur (NOUVEAU)
  Future<void> _saveUser(User user) async {
    try {
      final prefs = await SharedPreferences.getInstance();
      await prefs.setString('user_email', user.email);
      await prefs.setString('user_roles', user.roles.join(','));
      if (user.nomComplet != null) {
        await prefs.setString('user_nom_complet', user.nomComplet!);
      }
      if (user.id != null) {
        await prefs.setInt('user_id', user.id!);
      }
      print('✅ Données utilisateur sauvegardées');
    } catch (e) {
      print('⚠️ Erreur lors de la sauvegarde des données utilisateur: $e');
    }
  }

  // Charger le token et l'utilisateur depuis SharedPreferences (MODIFIÉ)
  Future<void> loadToken() async {
    try {
      final prefs = await SharedPreferences.getInstance();
      _token = prefs.getString('auth_token');
      
      if (_token != null) {
        // Charger aussi les données utilisateur
        final userId = prefs.getInt('user_id');
        final userEmail = prefs.getString('user_email');
        final userRolesString = prefs.getString('user_roles');
        final userNomComplet = prefs.getString('user_nom_complet');
        
        if (userEmail != null && userRolesString != null) {
          _user = User(
            id: userId,
            email: userEmail,
            nomComplet: userNomComplet,
            roles: userRolesString.split(','),
          );
          print('✅ Token et utilisateur chargés depuis le stockage');
        } else {
          print('✅ Token chargé depuis le stockage');
        }
        
        notifyListeners();
      }
    } catch (e) {
      print('⚠️ Erreur lors du chargement du token: $e');
    }
  }

  // Nettoyer les données locales (MODIFIÉ)
  Future<void> _clearLocalData() async {
    _user = null;
    _token = null;
    _errorMessage = null;
    
    try {
      final prefs = await SharedPreferences.getInstance();
      await prefs.remove('auth_token');
      await prefs.remove('user_id');
      await prefs.remove('user_email');
      await prefs.remove('user_roles');
      await prefs.remove('user_nom_complet');
      print('✅ Données locales nettoyées');
    } catch (e) {
      print('⚠️ Erreur lors du nettoyage des données: $e');
    }
  }

  // Forcer la déconnexion sans appeler l'API
  Future<void> forceLogout() async {
    await _clearLocalData();
    notifyListeners();
  }

  // Effacer le message d'erreur
  void clearError() {
    _errorMessage = null;
    notifyListeners();
  }

  // Méthode pour simuler une connexion (pour tests)
  void mockLogin() {
    _user = User(
      id: 1,
      email: 'test@test.com',
      nomComplet: 'Test User',
      roles: ['ROLE_USER'],
    );
    _token = 'mock_token_123456';
    notifyListeners();
  }

  // Vérifier si l'utilisateur a un rôle spécifique (NOUVEAU)
  bool hasRole(String role) {
    return _user?.hasRole(role) ?? false;
  }

  // Getters pour les rôles (NOUVEAU)
  bool get isAdmin => _user?.isAdmin ?? false;
  bool get isVendeur => _user?.isVendeur ?? false;
  bool get isClient => _user?.isClient ?? false;
}

import 'package:flutter/material.dart';
import '../models/product_model.dart';
import '../services/product_api.dart';

class ProductController extends ChangeNotifier {
  final int idUtilisateur;

  ProductController(this.idUtilisateur);

  List<Product> _products = [];
  bool _isLoading = false;
  String? _errorMessage;
  Product? _selectedProduct;

  List<Product> get products => _products;
  bool get isLoading => _isLoading;
  String? get errorMessage => _errorMessage;
  Product? get selectedProduct => _selectedProduct;

  // Charger tous les produits
 Future<void> loadProductsByUtilisateur(int idUtilisateur) async {
  _isLoading = true;
  notifyListeners();

  try {
    _products = await ProductApi.getProductsByUtilisateur(idUtilisateur);
    _isLoading = false;
    notifyListeners();
  } catch (e) {
    _errorMessage = e.toString();
    _isLoading = false;
    notifyListeners();
  }
}


  // Charger un produit par ID
  Future<void> loadProductById(int id) async {
    _isLoading = true;
    _errorMessage = null;
    notifyListeners();

    try {
      _selectedProduct = await ProductApi.getProductById(id);
      _isLoading = false;
      notifyListeners();
    } catch (e) {
      _errorMessage = e.toString();
      _isLoading = false;
      notifyListeners();
    }
  }

  // Ajouter un produit
  Future<bool> addProduct(Product product) async {
    _isLoading = true;
    _errorMessage = null;
    notifyListeners();

    try {
      await ProductApi.addProduct(product);
      await loadProductsByUtilisateur(idUtilisateur);  // Recharger la liste
      _isLoading = false;
      notifyListeners();
      return true;
    } catch (e) {
      _errorMessage = e.toString();
      _isLoading = false;
      notifyListeners();
      return false;
    }
  }

  // Modifier un produit
  Future<bool> updateProduct(Product product) async {
    _isLoading = true;
    _errorMessage = null;
    notifyListeners();

    try {
      await ProductApi.updateProduct(product);
      await loadProductsByUtilisateur(idUtilisateur); // ✅
      _isLoading = false;
      notifyListeners();
      return true;
    } catch (e) {
      _errorMessage = e.toString();
      _isLoading = false;
      notifyListeners();
      return false;
    }
  }

  // Supprimer un produit
  Future<bool> deleteProduct(int id) async {
    _isLoading = true;
    _errorMessage = null;
    notifyListeners();

    try {
      await ProductApi.deleteProduct(id);
      await loadProductsByUtilisateur(idUtilisateur); // ✅

      _isLoading = false;
      notifyListeners();
      return true;
    } catch (e) {
      _errorMessage = e.toString();
      _isLoading = false;
      notifyListeners();
      return false;
    }
  }

  // Rechercher des produits
  List<Product> searchProducts(String query) {
    if (query.isEmpty) return _products;
    
    return _products.where((product) {
      return product.nom.toLowerCase().contains(query.toLowerCase()) ||
             product.description.toLowerCase().contains(query.toLowerCase());
    }).toList();
  }

  // Filtrer par prix
  List<Product> filterByPrice(double minPrice, double maxPrice) {
    return _products.where((product) {
      return product.prix >= minPrice && product.prix <= maxPrice;
    }).toList();
  }

  // Trier les produits
  void sortProducts(String sortBy) {
    switch (sortBy) {
      case 'nom_asc':
        _products.sort((a, b) => a.nom.compareTo(b.nom));
        break;
      case 'nom_desc':
        _products.sort((a, b) => b.nom.compareTo(a.nom));
        break;
      case 'prix_asc':
        _products.sort((a, b) => a.prix.compareTo(b.prix));
        break;
      case 'prix_desc':
        _products.sort((a, b) => b.prix.compareTo(a.prix));
        break;
      case 'date_asc':
        _products.sort((a, b) => (a.createdAt ?? DateTime.now())
            .compareTo(b.createdAt ?? DateTime.now()));
        break;
      case 'date_desc':
        _products.sort((a, b) => (b.createdAt ?? DateTime.now())
            .compareTo(a.createdAt ?? DateTime.now()));
        break;
    }
    notifyListeners();
  }
}

class Product {
  final int? id;
  final String nom;
  final String description;
  final double prix;
  final int quantite;
  final String? imageUrl;
  int idUtilisateur; // vendeur
  final DateTime? createdAt;
  final DateTime? updatedAt;

  Product({
    this.id,
    required this.nom,
    required this.description,
    required this.prix,
    this.quantite = 0,
    this.imageUrl,
    required this.idUtilisateur,
    this.createdAt,
    this.updatedAt,
  });

  // Convertir JSON en objet Product
  factory Product.fromJson(Map<String, dynamic> json) {
    return Product(
      id: json['id'] != null ? int.parse(json['id'].toString()) : null,
      nom: json['nom'] ?? '',
      description: json['description'] ?? '',
      prix: json['prix'] != null ? double.parse(json['prix'].toString()) : 0.0,
      quantite: json['quantite'] != null ? int.parse(json['quantite'].toString()) : 0,
      imageUrl: json['image_url'],
      idUtilisateur: json['id_utilisateur'] ?? json['idUtilisateur'] ?? 0,
      createdAt: json['created_at'] != null 
          ? DateTime.parse(json['created_at'])
          : null,
      updatedAt: json['updated_at'] != null 
          ? DateTime.parse(json['updated_at'])
          : null,
    );
  }

  // Convertir objet Product en JSON
  Map<String, dynamic> toJson() {
    return {
      'id': id,
      'nom': nom,
      'description': description,
      'prix': prix,
      'quantite': quantite,
      'image_url': imageUrl,
      'id_utilisateur': idUtilisateur, // correspond à la colonne MySQL
      'created_at': createdAt?.toIso8601String(),
      'updated_at': updatedAt?.toIso8601String(),
    };
  }

  // Copier avec modification
  Product copyWith({
    int? id,
    String? nom,
    String? description,
    double? prix,
    int? quantite,
    String? imageUrl,
    int? idUtilisateur,
    DateTime? createdAt,
    DateTime? updatedAt,
  }) {
    return Product(
      id: id ?? this.id,
      nom: nom ?? this.nom,
      description: description ?? this.description,
      prix: prix ?? this.prix,
      quantite: quantite ?? this.quantite,
      imageUrl: imageUrl ?? this.imageUrl,
      idUtilisateur: idUtilisateur ?? this.idUtilisateur,
      createdAt: createdAt ?? this.createdAt,
      updatedAt: updatedAt ?? this.updatedAt,
    );
  }
}

// models/user_model.dart
import 'dart:convert';

class User {
  final int? id;
  final String email;
  final String? nomComplet;
  final String? pays;
  final String? numTel;
  final String? urlPhotoProfil;
  final List<String> roles; // Liste des rôles
  final DateTime? creeA;
  final DateTime? misAJourA;

  User({
    this.id,
    required this.email,
    this.nomComplet,
    this.pays,
    this.numTel,
    this.urlPhotoProfil,
    required this.roles,
    this.creeA,
    this.misAJourA,
  });

  factory User.fromJson(Map<String, dynamic> json) {
    // Parser les rôles JSON
    List<String> rolesList = [];
    if (json['roles'] != null) {
      if (json['roles'] is String) {
        // Si c'est une string JSON
        try {
          rolesList = List<String>.from(jsonDecode(json['roles']));
        } catch (e) {
          rolesList = ['ROLE_USER'];
        }
      } else if (json['roles'] is List) {
        // Si c'est déjà une liste
        rolesList = List<String>.from(json['roles']);
      }
    }

    return User(
      id: json['id'] != null ? int.parse(json['id'].toString()) : null,
      email: json['email'] ?? '',
      nomComplet: json['nom_complet'],
      pays: json['pays'],
      numTel: json['num_tel'],
      urlPhotoProfil: json['url_photo_profil'],
      roles: rolesList.isEmpty ? ['ROLE_USER'] : rolesList,
      creeA: json['cree_a'] != null ? DateTime.parse(json['cree_a']) : null,
      misAJourA: json['mis_a_jour_a'] != null ? DateTime.parse(json['mis_a_jour_a']) : null,
    );
  }

  Map<String, dynamic> toJson() {
    return {
      'id': id,
      'email': email,
      'nom_complet': nomComplet,
      'pays': pays,
      'num_tel': numTel,
      'url_photo_profil': urlPhotoProfil,
      'roles': roles,
    };
  }

  // Méthodes pour vérifier les rôles
  bool hasRole(String role) => roles.contains(role);
  
  bool get isAdmin => hasRole('ROLE_ADMIN');
  bool get isVendeur => hasRole('ROLE_VENDEUR');
  bool get isClient => hasRole('ROLE_USER') || hasRole('ROLE_CLIENT');
  
  // Obtenir le rôle principal (priorité)
  String get mainRole {
    if (isAdmin) return 'ROLE_ADMIN';
    if (isVendeur) return 'ROLE_VENDEUR';
    return 'ROLE_USER';
  }
}

import 'dart:async';
import 'dart:convert';
import 'dart:io';

import 'package:http/http.dart' as http;

class ApiBase {
  // URL de base corrigée
  static String baseUrl = 'http://10.0.2.2/flutter/mon_api_php';
  
  // Méthode principale pour toutes les requêtes
  static Future<Map<String, dynamic>> request({
    required String method,
    required String endpoint,
    Map<String, dynamic>? body,
    String? token,
  }) async {
    try {
      // Nettoyer l'endpoint (enlever les slashes en trop)
      String cleanEndpoint = endpoint.trim();
      if (cleanEndpoint.startsWith('/')) {
        cleanEndpoint = cleanEndpoint.substring(1);
      }
      
      // Ajouter .php si pas présent et pas d'autre extension
      if (!cleanEndpoint.contains('.')) {
        cleanEndpoint = '$cleanEndpoint.php';
        print('📝 Extension ajoutée: $cleanEndpoint');
      }
      
      // Construire l'URL
      final url = Uri.parse('$baseUrl/$cleanEndpoint');
      print('🌐 Requête API: $method $url');
      
      // Headers
      final headers = {
        'Content-Type': 'application/json',
        'Accept': 'application/json',
        if (token != null) 'Authorization': 'Bearer $token',
      };
      
      // Log du body pour debug
      if (body != null) {
        print('📤 Body: ${json.encode(body)}');
      }

      // Faire la requête avec timeout
      http.Response response;
      
      switch (method.toUpperCase()) {
        case 'GET':
          response = await http
              .get(url, headers: headers)
              .timeout(const Duration(seconds: 15));
          break;
        case 'POST':
          response = await http
              .post(
                url,
                headers: headers,
                body: body != null ? json.encode(body) : null,
              )
              .timeout(const Duration(seconds: 15));
          break;
        case 'PUT':
          response = await http
              .put(
                url,
                headers: headers,
                body: body != null ? json.encode(body) : null,
              )
              .timeout(const Duration(seconds: 15));
          break;
        case 'DELETE':
          response = await http
              .delete(url, headers: headers)
              .timeout(const Duration(seconds: 15));
          break;
        default:
          throw Exception('Méthode non supportée: $method');
      }

      print('📥 Réponse: ${response.statusCode}');
      print('📄 Body: ${response.body}');
      
      // Parser la réponse
      return _parseResponse(response);
      
    } on SocketException {
      throw Exception('Pas de connexion internet. Vérifiez votre réseau.');
    } on TimeoutException {
      throw Exception('Le serveur ne répond pas. Vérifiez que XAMPP est démarré.');
    } on http.ClientException catch (e) {
      throw Exception('Erreur réseau: ${e.message}');
    } on FormatException catch (e) {
      throw Exception('Format JSON invalide: $e');
    } catch (e) {
      throw Exception('Erreur: $e');
    }
  }
  
  // Parser la réponse
  static Map<String, dynamic> _parseResponse(http.Response response) {
    // Vérifier si c'est du HTML (erreur commune)
    if (response.body.trim().startsWith('<!DOCTYPE') || 
        response.body.trim().startsWith('<html') ||
        response.body.trim().startsWith('<?xml')) {
      throw Exception(
        'Le serveur retourne du HTML au lieu de JSON. '
        'Vérifiez l\'URL et que le fichier PHP existe.'
      );
    }
    
    // Vérifier si la réponse est vide
    if (response.body.isEmpty) {
      throw Exception('Réponse vide du serveur');
    }
    
    try {
      final data = json.decode(response.body);
      
      // Gérer les différents codes de statut
      if (response.statusCode >= 200 && response.statusCode < 300) {
        return data;
      } else if (response.statusCode == 400) {
        throw Exception(data['message'] ?? 'Requête invalide');
      } else if (response.statusCode == 401) {
        throw Exception(data['message'] ?? 'Non autorisé');
      } else if (response.statusCode == 404) {
        throw Exception('API introuvable. Vérifiez l\'URL: $baseUrl');
      } else if (response.statusCode == 406) {
        throw Exception(
          'Erreur 406: Le serveur n\'accepte pas le format de la requête. '
          'Vérifiez les headers dans login.php'
        );
      } else if (response.statusCode == 500) {
        throw Exception(data['message'] ?? 'Erreur serveur');
      } else {
        throw Exception(data['message'] ?? 'Erreur ${response.statusCode}');
      }
    } on FormatException {
      // Si le JSON est invalide, afficher un extrait du corps
      final preview = response.body.length > 200 
          ? '${response.body.substring(0, 200)}...' 
          : response.body;
      throw Exception('Réponse invalide (JSON attendu): $preview');
    }
  }
  
  // Tester la connexion à l'API
  static Future<bool> testConnection() async {
    print('🔍 Test de connexion à $baseUrl');
    
    try {
      // Créer un endpoint de test
      final testUrl = Uri.parse('$baseUrl/test.php');
      print('🌐 Test: GET $testUrl');
      
      final response = await http
          .get(testUrl)
          .timeout(const Duration(seconds: 10));
      
      print('📥 Réponse test: ${response.statusCode}');
      print('📄 Body: ${response.body}');
      
      if (response.statusCode == 200) {
        print('✅ Serveur accessible');
        
        // Vérifier le contenu
        if (response.body.contains('success') ||
            response.body.contains('status') ||
            response.body.startsWith('{') || 
            response.body.startsWith('[')) {
          print('✅ API semble fonctionner correctement');
          return true;
        } else {
          print('⚠️ Contenu inattendu');
          return false;
        }
      } else if (response.statusCode == 404) {
        print('❌ Fichier test.php introuvable');
        print('💡 Créez un fichier test.php dans $baseUrl');
        return false;
      } else {
        print('❌ Erreur HTTP: ${response.statusCode}');
        return false;
      }
    } on SocketException {
      print('❌ Impossible de se connecter au serveur');
      print('💡 Vérifications:');
      print('   1. XAMPP est démarré?');
      print('   2. Apache est en cours d\'exécution?');
      print('   3. Le dossier existe: C:\\xampp\\htdocs\\flutter\\mon_api_php\\');
      return false;
    } on TimeoutException {
      print('❌ Timeout - Le serveur ne répond pas');
      return false;
    } catch (e) {
      print('❌ Erreur: $e');
      return false;
    }
  }
  
  // Méthodes pratiques pour chaque type de requête
  static Future<Map<String, dynamic>> get(
    String endpoint, {
    String? token,
  }) async {
    return request(
      method: 'GET',
      endpoint: endpoint,
      token: token,
    );
  }
  
  static Future<Map<String, dynamic>> post(
    String endpoint, {
    Map<String, dynamic>? body,
    String? token,
  }) async {
    return request(
      method: 'POST',
      endpoint: endpoint,
      body: body,
      token: token,
    );
  }
  
  static Future<Map<String, dynamic>> put(
    String endpoint, {
    Map<String, dynamic>? body,
    String? token,
  }) async {
    return request(
      method: 'PUT',
      endpoint: endpoint,
      body: body,
      token: token,
    );
  }
  
  static Future<Map<String, dynamic>> delete(
    String endpoint, {
    String? token,
  }) async {
    return request(
      method: 'DELETE',
      endpoint: endpoint,
      token: token,
    );
  }
}

import 'api_base.dart';

class AuthApi {
  // Login
  static Future<Map<String, dynamic>> login(
      String email, String password) async {
    try {
      final response = await ApiBase.request(
        method: 'POST',
        endpoint: 'login',
        body: {
          'email': email,
          'password': password,
        },
      );

      return response;
    } catch (e) {
      return {
        'success': false,
        'message': 'Erreur de connexion: $e',
      };
    }
  }

  // Register avec tous les champs de ta table
  static Future<Map<String, dynamic>> register({
    required String email,
    required String password,
    String? nomComplet,
    String? pays,
    String? numTel,
    String? urlPhotoProfil,
    List<String>? roles,
  }) async {
    try {
      final response = await ApiBase.request(
        method: 'POST',
        endpoint: 'register',
        body: {
          'email': email,
          'password': password,
          if (nomComplet != null) 'nom_complet': nomComplet,
          if (pays != null) 'pays': pays,
          if (numTel != null) 'num_tel': numTel,
          if (urlPhotoProfil != null) 'url_photo_profil': urlPhotoProfil,
          'roles': roles ?? ['ROLE_USER'], // Par défaut ROLE_USER
        },
      );

      return response;
    } catch (e) {
      return {
        'success': false,
        'message': 'Erreur d\'inscription: $e',
      };
    }
  }

  // Logout
  static Future<Map<String, dynamic>> logout(String token) async {
    try {
      final response = await ApiBase.request(
        method: 'POST',
        endpoint: 'logout',
        token: token,
      );

      return response;
    } catch (e) {
      // Pour logout, on ne throw pas - on retourne un succès simulé
      if (e.toString().contains('404') || 
          e.toString().contains('Endpoint non trouvé')) {
        return {
          'success': true,
          'message': 'Déconnexion locale (endpoint non disponible)',
        };
      }
      
      // Autres erreurs
      return {
        'success': true, // On considère quand même que c'est un succès
        'message': 'Déconnexion effectuée (erreur ignorée: $e)',
      };
    }
  }

  // Méthode de test pour vérifier quels endpoints sont disponibles
  static Future<void> testEndpoints() async {
    print('🧪 Test des endpoints d\'authentification');
    
    final endpoints = ['login', 'logout', 'register'];
    
    for (var endpoint in endpoints) {
      print('\nTest endpoint: $endpoint');
      try {
        final response = await ApiBase.request(
          method: endpoint == 'login' || endpoint == 'register' ? 'POST' : 'GET',
          endpoint: endpoint,
          body: endpoint == 'login' || endpoint == 'register' 
              ? {'test': 'data'} 
              : null,
        );
        print('  ✅ Disponible: ${response['success']}');
      } catch (e) {
        print('  ❌ Non disponible: $e');
      }
    }
  }
}

import 'dart:convert';
import 'package:http/http.dart' as http;
import '../models/product_model.dart';
import 'api_base.dart';

class ProductApi {
  // Récupérer tous les produits
  static Future<List<Product>> getAllProducts() async {
    try {
      final data = await ApiBase.get('produits/get_products.php');

      if (data['success'] == true) {
        List<Product> products = (data['produits'] as List)
            .map((product) => Product.fromJson(product))
            .toList();
        return products;
      } else {
        throw Exception(data['error'] ?? 'Erreur lors de la récupération des produits');
      }
    } catch (e) {
      throw Exception('Erreur: $e');
    }
  }

  // Récupérer un produit par ID
  static Future<Product> getProductById(int id) async {
    try {
      final data = await ApiBase.get('produits/get_product.php?id=$id');

      if (data['success'] == true) {
        return Product.fromJson(data['produit']);
      } else {
        throw Exception(data['error'] ?? 'Produit non trouvé');
      }
    } catch (e) {
      throw Exception('Erreur: $e');
    }
  }

  // Ajouter un produit
  static Future<Map<String, dynamic>> addProduct(Product product) async {
    try {
      final data = await ApiBase.post(
        'produits/add_product.php',
        body: product.toJson(),
      );

      if (data['success'] == true) {
        return data;
      } else {
        throw Exception(data['error'] ?? 'Erreur lors de l\'ajout du produit');
      }
    } catch (e) {
      throw Exception('Erreur: $e');
    }
  }

  // Modifier un produit
  static Future<Map<String, dynamic>> updateProduct(Product product) async {
    try {
      final data = await ApiBase.put(
        'produits/update_product.php',
        body: product.toJson(),
      );

      if (data['success'] == true) {
        return data;
      } else {
        throw Exception(data['error'] ?? 'Erreur lors de la modification du produit');
      }
    } catch (e) {
      throw Exception('Erreur: $e');
    }
  }

  // Supprimer un produit
  static Future<Map<String, dynamic>> deleteProduct(int id) async {
    try {
      final data = await ApiBase.delete('produits/delete_product.php?id=$id');

      if (data['success'] == true) {
        return data;
      } else {
        throw Exception(data['error'] ?? 'Erreur lors de la suppression du produit');
      }
    } catch (e) {
      throw Exception('Erreur: $e');
    }
  }

  // Récupérer les produits d'un utilisateur
  static Future<List<Product>> getProductsByUtilisateur(int idUtilisateur) async {
    try {
      final data = await ApiBase.get(
        'produits/get_products.php?id_utilisateur=$idUtilisateur',
      );

      if (data['success'] == true) {
        return (data['produits'] as List)
            .map((p) => Product.fromJson(p))
            .toList();
      } else {
        throw Exception(data['error'] ?? 'Erreur lors de la récupération des produits');
      }
    } catch (e) {
      throw Exception('Erreur: $e');
    }
  }
}

import 'package:flutter/material.dart';
import '../models/user_model.dart';
import 'package:provider/provider.dart';
import '../controllers/auth_controller.dart';
import 'login_page.dart';

class AdminDashboard extends StatelessWidget {
  final User user;

  const AdminDashboard({super.key, required this.user});

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('Dashboard Admin'),
        backgroundColor: Colors.red,
        foregroundColor: Colors.white,
        actions: [
          IconButton(
            icon: const Icon(Icons.logout),
            onPressed: () async {
              await context.read<AuthController>().logout();
              if (context.mounted) {
                Navigator.pushAndRemoveUntil(
                  context,
                  MaterialPageRoute(builder: (_) => const LoginPage()),
                  (route) => false,
                );
              }
            },
          ),
        ],
      ),
      body: Padding(
        padding: const EdgeInsets.all(16.0),
        child: Column(
          crossAxisAlignment: CrossAxisAlignment.start,
          children: [
            // En-tête
            Container(
              padding: const EdgeInsets.all(20),
              decoration: BoxDecoration(
                gradient: LinearGradient(
                  colors: [Colors.red.shade700, Colors.red.shade500],
                ),
                borderRadius: BorderRadius.circular(16),
                boxShadow: [
                  BoxShadow(
                    color: Colors.red.withOpacity(0.3),
                    blurRadius: 10,
                    offset: const Offset(0, 4),
                  ),
                ],
              ),
              child: Row(
                children: [
                  const CircleAvatar(
                    radius: 30,
                    backgroundColor: Colors.white,
                    child: Icon(Icons.admin_panel_settings, size: 35, color: Colors.red),
                  ),
                  const SizedBox(width: 16),
                  Expanded(
                    child: Column(
                      crossAxisAlignment: CrossAxisAlignment.start,
                      children: [
                        Text(
                          user.nomComplet ?? user.email,
                          style: const TextStyle(
                            fontSize: 20,
                            fontWeight: FontWeight.bold,
                            color: Colors.white,
                          ),
                        ),
                        const SizedBox(height: 4),
                        Text(
                          'Administrateur',
                          style: TextStyle(
                            fontSize: 14,
                            color: Colors.white.withOpacity(0.9),
                          ),
                        ),
                      ],
                    ),
                  ),
                ],
              ),
            ),

            const SizedBox(height: 32),

            // Grille de cartes
            Expanded(
              child: GridView.count(
                crossAxisCount: 2,
                crossAxisSpacing: 16,
                mainAxisSpacing: 16,
                children: [
                  _DashboardCard(
                    title: 'Gestion\nUtilisateurs',
                    icon: Icons.people,
                    color: Colors.blue,
                    onTap: () {
                      ScaffoldMessenger.of(context).showSnackBar(
                        const SnackBar(content: Text('Gestion Utilisateurs - À venir')),
                      );
                    },
                  ),
                  _DashboardCard(
                    title: 'Gestion\nProduits',
                    icon: Icons.inventory,
                    color: Colors.green,
                    onTap: () {
                      ScaffoldMessenger.of(context).showSnackBar(
                        const SnackBar(content: Text('Gestion Produits - À venir')),
                      );
                    },
                  ),
                  _DashboardCard(
                    title: 'Statistiques',
                    icon: Icons.bar_chart,
                    color: Colors.orange,
                    onTap: () {
                      ScaffoldMessenger.of(context).showSnackBar(
                        const SnackBar(content: Text('Statistiques - À venir')),
                      );
                    },
                  ),
                  _DashboardCard(
                    title: 'Validation\nInscriptions',
                    icon: Icons.check_circle,
                    color: Colors.purple,
                    onTap: () {
                      ScaffoldMessenger.of(context).showSnackBar(
                        const SnackBar(content: Text('Validation - À venir')),
                      );
                    },
                  ),
                ],
              ),
            ),
          ],
        ),
      ),
    );
  }
}

class _DashboardCard extends StatelessWidget {
  final String title;
  final IconData icon;
  final Color color;
  final VoidCallback onTap;

  const _DashboardCard({
    required this.title,
    required this.icon,
    required this.color,
    required this.onTap,
  });

  @override
  Widget build(BuildContext context) {
    return Card(
      elevation: 4,
      shape: RoundedRectangleBorder(
        borderRadius: BorderRadius.circular(16),
      ),
      child: InkWell(
        onTap: onTap,
        borderRadius: BorderRadius.circular(16),
        child: Container(
          padding: const EdgeInsets.all(16.0),
          decoration: BoxDecoration(
            borderRadius: BorderRadius.circular(16),
            gradient: LinearGradient(
              begin: Alignment.topLeft,
              end: Alignment.bottomRight,
              colors: [
                color.withOpacity(0.1),
                color.withOpacity(0.05),
              ],
            ),
          ),
          child: Column(
            mainAxisAlignment: MainAxisAlignment.center,
            children: [
              Icon(icon, size: 48, color: color),
              const SizedBox(height: 12),
              Text(
                title,
                textAlign: TextAlign.center,
                style: TextStyle(
                  fontSize: 14,
                  fontWeight: FontWeight.bold,
                  color: color,
                ),
              ),
            ],
          ),
        ),
      ),
    );
  }
}

import 'package:flutter/material.dart';
import '../models/user_model.dart';
import 'package:provider/provider.dart';
import '../controllers/auth_controller.dart';
import 'login_page.dart';

class ClientDashboard extends StatelessWidget {
  final User user;

  const ClientDashboard({super.key, required this.user});

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('Catalogue Produits'),
        backgroundColor: Colors.blue,
        foregroundColor: Colors.white,
        actions: [
          IconButton(
            icon: const Icon(Icons.shopping_cart),
            onPressed: () {
              ScaffoldMessenger.of(context).showSnackBar(
                const SnackBar(content: Text('Panier - À venir')),
              );
            },
          ),
          IconButton(
            icon: const Icon(Icons.logout),
            onPressed: () async {
              await context.read<AuthController>().logout();
              if (context.mounted) {
                Navigator.pushAndRemoveUntil(
                  context,
                  MaterialPageRoute(builder: (_) => const LoginPage()),
                  (route) => false,
                );
              }
            },
          ),
        ],
      ),
      body: Padding(
        padding: const EdgeInsets.all(16.0),
        child: Column(
          crossAxisAlignment: CrossAxisAlignment.start,
          children: [
            // En-tête
            Container(
              padding: const EdgeInsets.all(20),
              decoration: BoxDecoration(
                gradient: LinearGradient(
                  colors: [Colors.blue.shade700, Colors.blue.shade500],
                ),
                borderRadius: BorderRadius.circular(16),
                boxShadow: [
                  BoxShadow(
                    color: Colors.blue.withOpacity(0.3),
                    blurRadius: 10,
                    offset: const Offset(0, 4),
                  ),
                ],
              ),
              child: Row(
                children: [
                  const CircleAvatar(
                    radius: 30,
                    backgroundColor: Colors.white,
                    child: Icon(Icons.shopping_bag, size: 35, color: Colors.blue),
                  ),
                  const SizedBox(width: 16),
                  Expanded(
                    child: Column(
                      crossAxisAlignment: CrossAxisAlignment.start,
                      children: [
                        Text(
                          user.nomComplet ?? user.email,
                          style: const TextStyle(
                            fontSize: 20,
                            fontWeight: FontWeight.bold,
                            color: Colors.white,
                          ),
                        ),
                        const SizedBox(height: 4),
                        Text(
                          'Client',
                          style: TextStyle(
                            fontSize: 14,
                            color: Colors.white.withOpacity(0.9),
                          ),
                        ),
                      ],
                    ),
                  ),
                ],
              ),
            ),

            const SizedBox(height: 32),

            // Section recherche
            TextField(
              decoration: InputDecoration(
                hintText: 'Rechercher un produit...',
                prefixIcon: const Icon(Icons.search),
                border: OutlineInputBorder(
                  borderRadius: BorderRadius.circular(12),
                ),
                filled: true,
                fillColor: Colors.grey.shade100,
              ),
            ),

            const SizedBox(height: 24),

            // Liste des produits (vide pour le moment)
            const Expanded(
              child: Center(
                child: Column(
                  mainAxisAlignment: MainAxisAlignment.center,
                  children: [
                    Icon(Icons.shopping_bag_outlined, size: 80, color: Colors.grey),
                    SizedBox(height: 16),
                    Text(
                      'Aucun produit disponible',
                      style: TextStyle(
                        fontSize: 20,
                        fontWeight: FontWeight.bold,
                        color: Colors.grey,
                      ),
                    ),
                    SizedBox(height: 8),
                    Text(
                      'Les produits apparaîtront ici',
                      style: TextStyle(color: Colors.grey),
                    ),
                  ],
                ),
              ),
            ),
          ],
        ),
      ),
      floatingActionButton: FloatingActionButton.extended(
        onPressed: () {
          ScaffoldMessenger.of(context).showSnackBar(
            const SnackBar(content: Text('Filtres - À venir')),
          );
        },
        icon: const Icon(Icons.filter_list),
        label: const Text('Filtres'),
        backgroundColor: Colors.blue,
      ),
    );
  }
}