pointage de base

lib/Components/appDrawer.dart

@@ -13,6 +13,7 @@ import 'package:youmazgestion/Views/newCommand.dart';
 import 'package:youmazgestion/Views/registrationPage.dart';
 import 'package:youmazgestion/accueil.dart';
 import 'package:youmazgestion/controller/userController.dart';
+import 'package:youmazgestion/Views/pointage.dart';
 
 class CustomDrawer extends StatelessWidget {
   final UserController userController = Get.find<UserController>();
@@ -73,7 +74,9 @@ class CustomDrawer extends StatelessWidget {
                 crossAxisAlignment: CrossAxisAlignment.start,
                 children: [
                   Text(
-                    controller.name.isNotEmpty ? controller.name : 'Utilisateur',
+                    controller.name.isNotEmpty
+                        ? controller.name
+                        : 'Utilisateur',
                     style: const TextStyle(
                       color: Colors.white,
                       fontSize: 18,
@@ -123,6 +126,14 @@ class CustomDrawer extends StatelessWidget {
         permissionRoute: '/modifier-utilisateur',
         onTap: () => Get.to(const ListUserPage()),
       ),
+      await _buildDrawerItem(
+        icon: Icons.timer,
+        title: "Gestion des pointages",
+        color: const Color.fromARGB(255, 4, 54, 95),
+        permissionAction: 'update',
+        permissionRoute: '/pointage',
+        onTap: () => Get.to(const PointagePage()),
+      )
     ];
 
     if (gestionUtilisateursItems.any((item) => item is ListTile)) {
@@ -321,7 +332,8 @@ class CustomDrawer extends StatelessWidget {
     required VoidCallback onTap,
   }) async {
     if (permissionAction != null && permissionRoute != null) {
-      bool hasPermission = await userController.hasPermission(permissionAction, permissionRoute);
+      bool hasPermission =
+          await userController.hasPermission(permissionAction, permissionRoute);
       if (!hasPermission) {
         return const SizedBox.shrink();
       }

lib/Models/pointage_model.dart

@@ -0,0 +1,30 @@
+class Pointage {
+  int? id;
+  String date;
+  String heureArrivee;
+  String heureDepart;
+
+  Pointage(
+      {this.id,
+      required this.date,
+      required this.heureArrivee,
+      required this.heureDepart});
+
+  factory Pointage.fromJson(Map<String, dynamic> json) {
+    return Pointage(
+      id: json['id'],
+      date: json['date'],
+      heureArrivee: json['heureArrivee'],
+      heureDepart: json['heureDepart'],
+    );
+  }
+
+  Map<String, dynamic> toJson() {
+    return {
+      'id': id,
+      'date': date,
+      'heureArrivee': heureArrivee,
+      'heureDepart': heureDepart,
+    };
+  }
+}

lib/Services/app_database.dart

@@ -39,7 +39,8 @@ class AppDatabase {
     if (!dbExists) {
       try {
         ByteData data = await rootBundle.load('assets/database/$filePath');
-        List<int> bytes = data.buffer.asUint8List(data.offsetInBytes, data.lengthInBytes);
+        List<int> bytes =
+            data.buffer.asUint8List(data.offsetInBytes, data.lengthInBytes);
         await File(path).writeAsBytes(bytes);
       } catch (e) {
         print('Pas de fichier DB dans assets, création d\'une nouvelle DB');
@@ -50,7 +51,8 @@ class AppDatabase {
   }
 
   Future<void> _createDB(Database db, int version) async {
-    final tables = await db.rawQuery("SELECT name FROM sqlite_master WHERE type='table'");
+    final tables =
+        await db.rawQuery("SELECT name FROM sqlite_master WHERE type='table'");
     final tableNames = tables.map((row) => row['name'] as String).toList();
 
     if (!tableNames.contains('roles')) {
@@ -126,7 +128,7 @@ class AppDatabase {
       print("Table 'users' créée.");
     }
     if (!tableNames.contains('role_menu_permissions')) {
-  await db.execute('''
+      await db.execute('''
     CREATE TABLE role_menu_permissions (
       role_id INTEGER,
       menu_id INTEGER,
@@ -137,210 +139,242 @@ class AppDatabase {
       FOREIGN KEY (permission_id) REFERENCES permissions(id) ON DELETE CASCADE
     )
   ''');
-  print("Table 'role_menu_permissions' créée.");
+      print("Table 'role_menu_permissions' créée.");
-}
-
-  }
-
- Future<void> insertDefaultPermissions() async {
-  final db = await database;
-  final existing = await db.query('permissions');
-  if (existing.isEmpty) {
-    await db.insert('permissions', {'name': 'view'});
-    await db.insert('permissions', {'name': 'create'});
-    await db.insert('permissions', {'name': 'update'});
-    await db.insert('permissions', {'name': 'delete'});
-    await db.insert('permissions', {'name': 'admin'});
-    await db.insert('permissions', {'name': 'manage'}); // Nouvelle permission
-    await db.insert('permissions', {'name': 'read'});   // Nouvelle permission
-    print("Permissions par défaut insérées");
-  } else {
-    // Vérifier et ajouter les nouvelles permissions si elles n'existent pas
-    final newPermissions = ['manage', 'read'];
-    for (var permission in newPermissions) {
-      final existingPermission = await db.query('permissions', where: 'name = ?', whereArgs: [permission]);
-      if (existingPermission.isEmpty) {
-        await db.insert('permissions', {'name': permission});
-        print("Permission ajoutée: $permission");
-      }
     }
   }
-}
-
-  Future<void> insertDefaultMenus() async {
-  final db = await database;
-  final existingMenus = await db.query('menu');
-
-  if (existingMenus.isEmpty) {
-    // Menus existants
-    await db.insert('menu', {'name': 'Accueil', 'route': '/accueil'});
-    await db.insert('menu', {'name': 'Ajouter un utilisateur', 'route': '/ajouter-utilisateur'});
-    await db.insert('menu', {'name': 'Modifier/Supprimer un utilisateur', 'route': '/modifier-utilisateur'});
-    await db.insert('menu', {'name': 'Ajouter un produit', 'route': '/ajouter-produit'});
-    await db.insert('menu', {'name': 'Modifier/Supprimer un produit', 'route': '/modifier-produit'});
-    await db.insert('menu', {'name': 'Bilan', 'route': '/bilan'});
-    await db.insert('menu', {'name': 'Gérer les rôles', 'route': '/gerer-roles'});
-    await db.insert('menu', {'name': 'Gestion de stock', 'route': '/gestion-stock'});
-    await db.insert('menu', {'name': 'Historique', 'route': '/historique'});
-    await db.insert('menu', {'name': 'Déconnexion', 'route': '/deconnexion'});
-    
-    // Nouveaux menus ajoutés
-    await db.insert('menu', {'name': 'Nouvelle commande', 'route': '/nouvelle-commande'});
-    await db.insert('menu', {'name': 'Gérer les commandes', 'route': '/gerer-commandes'});
-    
-    print("Menus par défaut insérés");
-  } else {
-    // Si des menus existent déjà, vérifier et ajouter les nouveaux menus manquants
-    await _addMissingMenus(db);
-  }
-}
-
-Future<void> _addMissingMenus(Database db) async {
-  final menusToAdd = [
-    {'name': 'Nouvelle commande', 'route': '/nouvelle-commande'},
-    {'name': 'Gérer les commandes', 'route': '/gerer-commandes'},
-  ];
-
-  for (var menu in menusToAdd) {
-    final existing = await db.query(
-      'menu',
-      where: 'route = ?',
-      whereArgs: [menu['route']],
-    );
 
+  Future<void> insertDefaultPermissions() async {
+    final db = await database;
+    final existing = await db.query('permissions');
     if (existing.isEmpty) {
-      await db.insert('menu', menu);
+      await db.insert('permissions', {'name': 'view'});
-      print("Menu ajouté: ${menu['name']}");
+      await db.insert('permissions', {'name': 'create'});
-    }
+      await db.insert('permissions', {'name': 'update'});
-  }
+      await db.insert('permissions', {'name': 'delete'});
-}
+      await db.insert('permissions', {'name': 'admin'});
-
+      await db.insert('permissions', {'name': 'manage'}); // Nouvelle permission
-  Future<void> insertDefaultRoles() async {
+      await db.insert('permissions', {'name': 'read'}); // Nouvelle permission
-  final db = await database;
+      print("Permissions par défaut insérées");
-  final existingRoles = await db.query('roles');
+    } else {
-
+      // Vérifier et ajouter les nouvelles permissions si elles n'existent pas
-  if (existingRoles.isEmpty) {
+      final newPermissions = ['manage', 'read'];
-    int superAdminRoleId = await db.insert('roles', {'designation': 'Super Admin'});
+      for (var permission in newPermissions) {
-    int adminRoleId = await db.insert('roles', {'designation': 'Admin'});
+        final existingPermission = await db
-    int userRoleId = await db.insert('roles', {'designation': 'User'});
+            .query('permissions', where: 'name = ?', whereArgs: [permission]);
-
-    final permissions = await db.query('permissions');
-    final menus = await db.query('menu');
-
-    // Assigner toutes les permissions à tous les menus pour le Super Admin
-    for (var menu in menus) {
-      for (var permission in permissions) {
-        await db.insert('role_menu_permissions', {
-          'role_id': superAdminRoleId,
-          'menu_id': menu['id'],
-          'permission_id': permission['id'],
-        },
-         conflictAlgorithm: ConflictAlgorithm.ignore
-        );
-      }
-    }
-
-    // Assigner quelques permissions à l'Admin et à l'User pour les nouveaux menus
-    await _assignBasicPermissionsToRoles(db, adminRoleId, userRoleId);
-
-    print("Rôles par défaut créés et permissions assignées");
-  } else {
-    // Si les rôles existent déjà, vérifier et ajouter les permissions manquantes
-    await _updateExistingRolePermissions(db);
-  }
-}
-// Nouvelle méthode pour assigner les permissions de base aux nouveaux menus
-Future<void> _assignBasicPermissionsToRoles(Database db, int adminRoleId, int userRoleId) async {
-  final viewPermission = await db.query('permissions', where: 'name = ?', whereArgs: ['view']);
-  final createPermission = await db.query('permissions', where: 'name = ?', whereArgs: ['create']);
-  final updatePermission = await db.query('permissions', where: 'name = ?', whereArgs: ['update']);
-  final managePermission = await db.query('permissions', where: 'name = ?', whereArgs: ['manage']);
-
-  // Récupérer les IDs des nouveaux menus
-  final nouvelleCommandeMenu = await db.query('menu', where: 'route = ?', whereArgs: ['/nouvelle-commande']);
-  final gererCommandesMenu = await db.query('menu', where: 'route = ?', whereArgs: ['/gerer-commandes']);
-
-  if (nouvelleCommandeMenu.isNotEmpty && createPermission.isNotEmpty) {
-    // Admin peut créer de nouvelles commandes
-    await db.insert('role_menu_permissions', {
-      'role_id': adminRoleId,
-      'menu_id': nouvelleCommandeMenu.first['id'],
-      'permission_id': createPermission.first['id'],
-    },
-     conflictAlgorithm: ConflictAlgorithm.ignore
-    );
-    
-    // User peut aussi créer de nouvelles commandes
-    await db.insert('role_menu_permissions', {
-      'role_id': userRoleId,
-      'menu_id': nouvelleCommandeMenu.first['id'],
-      'permission_id': createPermission.first['id'],
-    },
-     conflictAlgorithm: ConflictAlgorithm.ignore
-    );
-  }
-
-  if (gererCommandesMenu.isNotEmpty && managePermission.isNotEmpty) {
-    // Admin peut gérer les commandes
-    await db.insert('role_menu_permissions', {
-      'role_id': adminRoleId,
-      'menu_id': gererCommandesMenu.first['id'],
-      'permission_id': managePermission.first['id'],
-    },
-     conflictAlgorithm: ConflictAlgorithm.ignore
-    );
-  }
-
-  if (gererCommandesMenu.isNotEmpty && viewPermission.isNotEmpty) {
-    // User peut voir les commandes
-    await db.insert('role_menu_permissions', {
-      'role_id': userRoleId,
-      'menu_id': gererCommandesMenu.first['id'],
-      'permission_id': viewPermission.first['id'],
-    }
-    , conflictAlgorithm: ConflictAlgorithm.ignore
-    );
-  }
-}
-Future<void> _updateExistingRolePermissions(Database db) async {
-  final superAdminRole = await db.query('roles', where: 'designation = ?', whereArgs: ['Super Admin']);
-  if (superAdminRole.isNotEmpty) {
-    final superAdminRoleId = superAdminRole.first['id'] as int;
-    final permissions = await db.query('permissions');
-    final menus = await db.query('menu');
-
-    // Vérifier et ajouter les permissions manquantes pour le Super Admin sur tous les menus
-    for (var menu in menus) {
-      for (var permission in permissions) {
-        final existingPermission = await db.query(
-          'role_menu_permissions',
-          where: 'role_id = ? AND menu_id = ? AND permission_id = ?',
-          whereArgs: [superAdminRoleId, menu['id'], permission['id']],
-        );
         if (existingPermission.isEmpty) {
-          await db.insert('role_menu_permissions', {
+          await db.insert('permissions', {'name': permission});
-            'role_id': superAdminRoleId,
+          print("Permission ajoutée: $permission");
-            'menu_id': menu['id'],
-            'permission_id': permission['id'],
-          },
-           conflictAlgorithm: ConflictAlgorithm.ignore
-          );
         }
       }
     }
+  }
 
-    // Assigner les permissions de base aux autres rôles pour les nouveaux menus
+  Future<void> insertDefaultMenus() async {
-    final adminRole = await db.query('roles', where: 'designation = ?', whereArgs: ['Admin']);
+    final db = await database;
-    final userRole = await db.query('roles', where: 'designation = ?', whereArgs: ['User']);
+    final existingMenus = await db.query('menu');
 
-    if (adminRole.isNotEmpty && userRole.isNotEmpty) {
+    if (existingMenus.isEmpty) {
-      await _assignBasicPermissionsToRoles(db, adminRole.first['id'] as int, userRole.first['id'] as int);
+      // Menus existants
+      await db.insert('menu', {'name': 'Accueil', 'route': '/accueil'});
+      await db.insert('menu',
+          {'name': 'Ajouter un utilisateur', 'route': '/ajouter-utilisateur'});
+      await db.insert('menu', {
+        'name': 'Modifier/Supprimer un utilisateur',
+        'route': '/modifier-utilisateur'
+      });
+      await db.insert(
+          'menu', {'name': 'Ajouter un produit', 'route': '/ajouter-produit'});
+      await db.insert('menu', {
+        'name': 'Modifier/Supprimer un produit',
+        'route': '/modifier-produit'
+      });
+      await db.insert('menu', {'name': 'Bilan', 'route': '/bilan'});
+      await db
+          .insert('menu', {'name': 'Gérer les rôles', 'route': '/gerer-roles'});
+      await db.insert(
+          'menu', {'name': 'Gestion de stock', 'route': '/gestion-stock'});
+      await db.insert('menu', {'name': 'Historique', 'route': '/historique'});
+      await db.insert('menu', {'name': 'Déconnexion', 'route': '/deconnexion'});
+
+      // Nouveaux menus ajoutés
+      await db.insert(
+          'menu', {'name': 'Nouvelle commande', 'route': '/nouvelle-commande'});
+      await db.insert(
+          'menu', {'name': 'Gérer les commandes', 'route': '/gerer-commandes'});
+
+      print("Menus par défaut insérés");
+    } else {
+      // Si des menus existent déjà, vérifier et ajouter les nouveaux menus manquants
+      await _addMissingMenus(db);
+    }
+  }
+
+  Future<void> _addMissingMenus(Database db) async {
+    final menusToAdd = [
+      {'name': 'Nouvelle commande', 'route': '/nouvelle-commande'},
+      {'name': 'Gérer les commandes', 'route': '/gerer-commandes'},
+      {'name': 'Gérer les pointages', 'route': '/pointage'},
+    ];
+
+    for (var menu in menusToAdd) {
+      final existing = await db.query(
+        'menu',
+        where: 'route = ?',
+        whereArgs: [menu['route']],
+      );
+
+      if (existing.isEmpty) {
+        await db.insert('menu', menu);
+        print("Menu ajouté: ${menu['name']}");
+      }
+    }
+  }
+
+  Future<void> insertDefaultRoles() async {
+    final db = await database;
+    final existingRoles = await db.query('roles');
+
+    if (existingRoles.isEmpty) {
+      int superAdminRoleId =
+          await db.insert('roles', {'designation': 'Super Admin'});
+      int adminRoleId = await db.insert('roles', {'designation': 'Admin'});
+      int userRoleId = await db.insert('roles', {'designation': 'User'});
+
+      final permissions = await db.query('permissions');
+      final menus = await db.query('menu');
+
+      // Assigner toutes les permissions à tous les menus pour le Super Admin
+      for (var menu in menus) {
+        for (var permission in permissions) {
+          await db.insert(
+              'role_menu_permissions',
+              {
+                'role_id': superAdminRoleId,
+                'menu_id': menu['id'],
+                'permission_id': permission['id'],
+              },
+              conflictAlgorithm: ConflictAlgorithm.ignore);
+        }
+      }
+
+      // Assigner quelques permissions à l'Admin et à l'User pour les nouveaux menus
+      await _assignBasicPermissionsToRoles(db, adminRoleId, userRoleId);
+
+      print("Rôles par défaut créés et permissions assignées");
+    } else {
+      // Si les rôles existent déjà, vérifier et ajouter les permissions manquantes
+      await _updateExistingRolePermissions(db);
+    }
+  }
+
+// Nouvelle méthode pour assigner les permissions de base aux nouveaux menus
+  Future<void> _assignBasicPermissionsToRoles(
+      Database db, int adminRoleId, int userRoleId) async {
+    final viewPermission =
+        await db.query('permissions', where: 'name = ?', whereArgs: ['view']);
+    final createPermission =
+        await db.query('permissions', where: 'name = ?', whereArgs: ['create']);
+    final updatePermission =
+        await db.query('permissions', where: 'name = ?', whereArgs: ['update']);
+    final managePermission =
+        await db.query('permissions', where: 'name = ?', whereArgs: ['manage']);
+
+    // Récupérer les IDs des nouveaux menus
+    final nouvelleCommandeMenu = await db
+        .query('menu', where: 'route = ?', whereArgs: ['/nouvelle-commande']);
+    final gererCommandesMenu = await db
+        .query('menu', where: 'route = ?', whereArgs: ['/gerer-commandes']);
+
+    if (nouvelleCommandeMenu.isNotEmpty && createPermission.isNotEmpty) {
+      // Admin peut créer de nouvelles commandes
+      await db.insert(
+          'role_menu_permissions',
+          {
+            'role_id': adminRoleId,
+            'menu_id': nouvelleCommandeMenu.first['id'],
+            'permission_id': createPermission.first['id'],
+          },
+          conflictAlgorithm: ConflictAlgorithm.ignore);
+
+      // User peut aussi créer de nouvelles commandes
+      await db.insert(
+          'role_menu_permissions',
+          {
+            'role_id': userRoleId,
+            'menu_id': nouvelleCommandeMenu.first['id'],
+            'permission_id': createPermission.first['id'],
+          },
+          conflictAlgorithm: ConflictAlgorithm.ignore);
     }
 
-    print("Permissions mises à jour pour tous les rôles");
+    if (gererCommandesMenu.isNotEmpty && managePermission.isNotEmpty) {
-  }
+      // Admin peut gérer les commandes
-}
+      await db.insert(
+          'role_menu_permissions',
+          {
+            'role_id': adminRoleId,
+            'menu_id': gererCommandesMenu.first['id'],
+            'permission_id': managePermission.first['id'],
+          },
+          conflictAlgorithm: ConflictAlgorithm.ignore);
+    }
 
+    if (gererCommandesMenu.isNotEmpty && viewPermission.isNotEmpty) {
+      // User peut voir les commandes
+      await db.insert(
+          'role_menu_permissions',
+          {
+            'role_id': userRoleId,
+            'menu_id': gererCommandesMenu.first['id'],
+            'permission_id': viewPermission.first['id'],
+          },
+          conflictAlgorithm: ConflictAlgorithm.ignore);
+    }
+  }
+
+  Future<void> _updateExistingRolePermissions(Database db) async {
+    final superAdminRole = await db
+        .query('roles', where: 'designation = ?', whereArgs: ['Super Admin']);
+    if (superAdminRole.isNotEmpty) {
+      final superAdminRoleId = superAdminRole.first['id'] as int;
+      final permissions = await db.query('permissions');
+      final menus = await db.query('menu');
+
+      // Vérifier et ajouter les permissions manquantes pour le Super Admin sur tous les menus
+      for (var menu in menus) {
+        for (var permission in permissions) {
+          final existingPermission = await db.query(
+            'role_menu_permissions',
+            where: 'role_id = ? AND menu_id = ? AND permission_id = ?',
+            whereArgs: [superAdminRoleId, menu['id'], permission['id']],
+          );
+          if (existingPermission.isEmpty) {
+            await db.insert(
+                'role_menu_permissions',
+                {
+                  'role_id': superAdminRoleId,
+                  'menu_id': menu['id'],
+                  'permission_id': permission['id'],
+                },
+                conflictAlgorithm: ConflictAlgorithm.ignore);
+          }
+        }
+      }
+
+      // Assigner les permissions de base aux autres rôles pour les nouveaux menus
+      final adminRole = await db
+          .query('roles', where: 'designation = ?', whereArgs: ['Admin']);
+      final userRole = await db
+          .query('roles', where: 'designation = ?', whereArgs: ['User']);
+
+      if (adminRole.isNotEmpty && userRole.isNotEmpty) {
+        await _assignBasicPermissionsToRoles(
+            db, adminRole.first['id'] as int, userRole.first['id'] as int);
+      }
+
+      print("Permissions mises à jour pour tous les rôles");
+    }
+  }
 
   Future<void> insertDefaultSuperAdmin() async {
     final db = await database;
@@ -352,10 +386,8 @@ Future<void> _updateExistingRolePermissions(Database db) async {
     ''');
 
     if (existingSuperAdmin.isEmpty) {
-      final superAdminRole = await db.query('roles',
+      final superAdminRole = await db
-        where: 'designation = ?',
+          .query('roles', where: 'designation = ?', whereArgs: ['Super Admin']);
-        whereArgs: ['Super Admin']
-      );
 
       if (superAdminRole.isNotEmpty) {
         final superAdminRoleId = superAdminRole.first['id'] as int;
@@ -372,7 +404,8 @@ Future<void> _updateExistingRolePermissions(Database db) async {
         print("Super Admin créé avec succès !");
         print("Username: superadmin");
         print("Password: admin123");
-        print("ATTENTION: Changez ce mot de passe après la première connexion !");
+        print(
+            "ATTENTION: Changez ce mot de passe après la première connexion !");
       }
     } else {
       print("Super Admin existe déjà");
@@ -391,12 +424,14 @@ Future<void> _updateExistingRolePermissions(Database db) async {
 
   Future<int> updateUser(Users user) async {
     final db = await database;
-    return await db.update('users', user.toMap(), where: 'id = ?', whereArgs: [user.id]);
+    return await db
+        .update('users', user.toMap(), where: 'id = ?', whereArgs: [user.id]);
   }
 
   Future<int> getUserCount() async {
     final db = await database;
-    List<Map<String, dynamic>> result = await db.rawQuery('SELECT COUNT(*) as count FROM users');
+    List<Map<String, dynamic>> result =
+        await db.rawQuery('SELECT COUNT(*) as count FROM users');
     return result.first['count'] as int;
   }
 
@@ -426,7 +461,8 @@ Future<void> _updateExistingRolePermissions(Database db) async {
     }
   }
 
-  Future<Map<String, dynamic>?> getUserCredentials(String username, String password) async {
+  Future<Map<String, dynamic>?> getUserCredentials(
+      String username, String password) async {
     final db = await database;
     final result = await db.rawQuery('''
       SELECT users.username, users.id, roles.designation as role_name, roles.id as role_id
@@ -524,10 +560,13 @@ Future<void> _updateExistingRolePermissions(Database db) async {
 
   Future<void> assignPermission(int roleId, int permissionId) async {
     final db = await database;
-    await db.insert('role_permissions', {
+    await db.insert(
-      'role_id': roleId,
+        'role_permissions',
-      'permission_id': permissionId,
+        {
-    }, conflictAlgorithm: ConflictAlgorithm.ignore);
+          'role_id': roleId,
+          'permission_id': permissionId,
+        },
+        conflictAlgorithm: ConflictAlgorithm.ignore);
   }
 
   Future<void> removePermission(int roleId, int permissionId) async {
@@ -541,10 +580,13 @@ Future<void> _updateExistingRolePermissions(Database db) async {
 
   Future<void> assignMenuPermission(int menuId, int permissionId) async {
     final db = await database;
-    await db.insert('menu_permissions', {
+    await db.insert(
-      'menu_id': menuId,
+        'menu_permissions',
-      'permission_id': permissionId,
+        {
-    }, conflictAlgorithm: ConflictAlgorithm.ignore);
+          'menu_id': menuId,
+          'permission_id': permissionId,
+        },
+        conflictAlgorithm: ConflictAlgorithm.ignore);
   }
 
   Future<void> removeMenuPermission(int menuId, int permissionId) async {
@@ -568,7 +610,8 @@ Future<void> _updateExistingRolePermissions(Database db) async {
     return (result.first['count'] as int) > 0;
   }
 
-  Future<void> changePassword(String username, String oldPassword, String newPassword) async {
+  Future<void> changePassword(
+      String username, String oldPassword, String newPassword) async {
     final db = await database;
 
     final isValidOldPassword = await verifyUser(username, oldPassword);
@@ -584,9 +627,10 @@ Future<void> _updateExistingRolePermissions(Database db) async {
     );
   }
 
- Future<bool> hasPermission(String username, String permissionName, String menuRoute) async {
+  Future<bool> hasPermission(
-  final db = await database;
+      String username, String permissionName, String menuRoute) async {
-  final result = await db.rawQuery('''
+    final db = await database;
+    final result = await db.rawQuery('''
     SELECT COUNT(*) as count
     FROM permissions p
     JOIN role_menu_permissions rmp ON p.id = rmp.permission_id
@@ -596,9 +640,8 @@ Future<void> _updateExistingRolePermissions(Database db) async {
     WHERE u.username = ? AND p.name = ? AND rmp.menu_id = m.id
   ''', [menuRoute, username, permissionName]);
 
-  return (result.first['count'] as int) > 0;
+    return (result.first['count'] as int) > 0;
-}
+  }
-
 
   Future<void> close() async {
     if (_database.isOpen) {
@@ -635,9 +678,10 @@ Future<void> _updateExistingRolePermissions(Database db) async {
     print("=========================================");
   }
 
-  Future<List<Permission>> getPermissionsForRoleAndMenu(int roleId, int menuId) async {
+  Future<List<Permission>> getPermissionsForRoleAndMenu(
-  final db = await database;
+      int roleId, int menuId) async {
-  final result = await db.rawQuery('''
+    final db = await database;
+    final result = await db.rawQuery('''
     SELECT p.id, p.name
     FROM permissions p
     JOIN role_menu_permissions rmp ON p.id = rmp.permission_id
@@ -645,36 +689,40 @@ Future<void> _updateExistingRolePermissions(Database db) async {
     ORDER BY p.name ASC
   ''', [roleId, menuId]);
 
-  return result.map((map) => Permission.fromMap(map)).toList();
+    return result.map((map) => Permission.fromMap(map)).toList();
-}
+  }
+
   // Ajoutez cette méthode temporaire pour supprimer la DB corrompue
-Future<void> deleteDatabaseFile() async {
+  Future<void> deleteDatabaseFile() async {
-  final documentsDirectory = await getApplicationDocumentsDirectory();
+    final documentsDirectory = await getApplicationDocumentsDirectory();
-  final path = join(documentsDirectory.path, 'app_database.db');
+    final path = join(documentsDirectory.path, 'app_database.db');
-  final file = File(path);
+    final file = File(path);
-  if (await file.exists()) {
+    if (await file.exists()) {
-    await file.delete();
+      await file.delete();
-    print("Base de données utilisateur supprimée");
+      print("Base de données utilisateur supprimée");
+    }
+  }
+
+  Future<void> assignRoleMenuPermission(
+      int roleId, int menuId, int permissionId) async {
+    final db = await database;
+    await db.insert(
+        'role_menu_permissions',
+        {
+          'role_id': roleId,
+          'menu_id': menuId,
+          'permission_id': permissionId,
+        },
+        conflictAlgorithm: ConflictAlgorithm.ignore);
+  }
+
+  Future<void> removeRoleMenuPermission(
+      int roleId, int menuId, int permissionId) async {
+    final db = await database;
+    await db.delete(
+      'role_menu_permissions',
+      where: 'role_id = ? AND menu_id = ? AND permission_id = ?',
+      whereArgs: [roleId, menuId, permissionId],
+    );
   }
 }
-Future<void> assignRoleMenuPermission(int roleId, int menuId, int permissionId) async {
-  final db = await database;
-  await db.insert('role_menu_permissions', {
-    'role_id': roleId,
-    'menu_id': menuId,
-    'permission_id': permissionId,
-  }, conflictAlgorithm: ConflictAlgorithm.ignore);
-}
-
-
-
-Future<void> removeRoleMenuPermission(int roleId, int menuId, int permissionId) async {
-  final db = await database;
-  await db.delete(
-    'role_menu_permissions',
-    where: 'role_id = ? AND menu_id = ? AND permission_id = ?',
-    whereArgs: [roleId, menuId, permissionId],
-  );
-}
-
-}

lib/Services/pointageDatabase.dart

@@ -0,0 +1,61 @@
+// database_helper.dart
+
+import 'dart:async';
+import 'package:path/path.dart';
+import 'package:sqflite/sqflite.dart';
+import '../Models/pointage_model.dart'; // Import your Pointage model
+
+class DatabaseHelper {
+  static final DatabaseHelper _instance = DatabaseHelper._internal();
+
+  factory DatabaseHelper() => _instance;
+
+  DatabaseHelper._internal();
+
+  Database? _db;
+
+  Future<Database> get db async {
+    if (_db != null) return _db!;
+    _db = await _initDatabase();
+    return _db!;
+  }
+
+  Future<Database> _initDatabase() async {
+    String databasesPath = await getDatabasesPath();
+    String dbPath = join(databasesPath, 'pointage.db');
+    return await openDatabase(dbPath, version: 1, onCreate: _onCreate);
+  }
+
+  Future _onCreate(Database db, int version) async {
+    await db.execute('''
+        CREATE TABLE pointages (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          date TEXT NOT NULL,
+          heureArrivee TEXT NOT NULL,
+          heureDepart TEXT NOT NULL
+        )
+      ''');
+  }
+
+  Future<int> insertPointage(Pointage pointage) async {
+    Database db = await this.db;
+    return await db.insert('pointages', pointage.toJson());
+  }
+
+  Future<List<Pointage>> getPointages() async {
+    Database db = await this.db;
+    List<Map<String, dynamic>> pointages = await db.query('pointages');
+    return pointages.map((pointage) => Pointage.fromJson(pointage)).toList();
+  }
+
+  Future<int> updatePointage(Pointage pointage) async {
+    Database db = await this.db;
+    return await db.update('pointages', pointage.toJson(),
+        where: 'id = ?', whereArgs: [pointage.id]);
+  }
+
+  Future<int> deletePointage(int id) async {
+    Database db = await this.db;
+    return await db.delete('pointages', where: 'id = ?', whereArgs: [id]);
+  }
+}

lib/Views/pointage.dart

@@ -0,0 +1,93 @@
+import 'package:flutter/material.dart';
+import 'package:youmazgestion/Services/pointageDatabase.dart';
+import 'package:youmazgestion/Models/pointage_model.dart';
+
+class PointagePage extends StatefulWidget {
+  const PointagePage({Key? key}) : super(key: key);
+
+  @override
+  State<PointagePage> createState() => _PointagePageState();
+}
+
+class _PointagePageState extends State<PointagePage> {
+  final DatabaseHelper _databaseHelper = DatabaseHelper();
+  List<Pointage> _pointages = [];
+
+  @override
+  void initState() {
+    super.initState();
+    _loadPointages();
+  }
+
+  Future<void> _loadPointages() async {
+    final pointages = await _databaseHelper.getPointages();
+    setState(() {
+      _pointages = pointages;
+    });
+  }
+
+  Future<void> _showAddDialog() async {
+    final _arrivalController = TextEditingController();
+
+    await showDialog(
+      context: context,
+      builder: (context) {
+        return AlertDialog(
+          title: Text('Ajouter Pointage'),
+          content: TextField(
+            controller: _arrivalController,
+            decoration: InputDecoration(
+              labelText: 'Heure d\'arrivée (HH:mm)',
+            ),
+          ),
+          actions: [
+            TextButton(
+              child: Text('Annuler'),
+              onPressed: () => Navigator.of(context).pop(),
+            ),
+            ElevatedButton(
+              child: Text('Ajouter'),
+              onPressed: () async {
+                final pointage = Pointage(
+                  date: DateTime.now().toString().split(' ')[0],
+                  heureArrivee: _arrivalController.text,
+                  heureDepart: '',
+                );
+                await _databaseHelper.insertPointage(pointage);
+                Navigator.of(context).pop();
+                _loadPointages();
+              },
+            ),
+          ],
+        );
+      },
+    );
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      appBar: AppBar(
+        title: const Text('Pointage'),
+      ),
+      body: _pointages.isEmpty
+          ? Center(child: Text('Aucun pointage enregistré.'))
+          : ListView.builder(
+              itemCount: _pointages.length,
+              itemBuilder: (context, index) {
+                final pointage = _pointages[index];
+                return ListTile(
+                  title: Text(pointage.date),
+                  subtitle: Text(
+                      'Arrivée: ${pointage.heureArrivee}, Départ: ${pointage.heureDepart.isNotEmpty ? pointage.heureDepart : '---'}'),
+                );
+              },
+            ),
+      floatingActionButton: FloatingActionButton(
+        onPressed: _showAddDialog,
+        tooltip: 'Ajouter Pointage',
+        child: const Icon(Icons.add),
+      ),
+    );
+  }
+}

lib/accueil.dart

@@ -448,7 +448,7 @@ class _AccueilPageState extends State<AccueilPage> {
                                               fontSize: 16,
                                               fontWeight: FontWeight.bold)),
                                       Text(
-                                        '${NumberFormat('#,##0.00').format(calculateTotalPrice())} FCFA',
+                                        '${NumberFormat('#,##0.00').format(calculateTotalPrice())} MGA',
                                         style: TextStyle(
                                           fontSize: 18,
                                           fontWeight: FontWeight.bold,