C4M
/
GUYCOM_FLUTTER
4
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

pointage de base

master
Stephane 6 months ago
parent
5f665acf35
commit
8d86d99e24
6 changed files with 479 additions and 235 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 16
      lib/Components/appDrawer.dart
  2. 30
      lib/Models/pointage_model.dart
  3. 508
      lib/Services/app_database.dart
  4. 61
      lib/Services/pointageDatabase.dart
  5. 93
      lib/Views/pointage.dart
  6. 2
      lib/accueil.dart

16
lib/Components/appDrawer.dart
View File

@ -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();
}

30
lib/Models/pointage_model.dart
View File

@ -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,
};
}
}

508
lib/Services/app_database.dart
View File

@ -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> 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);
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> _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'},
];
if (existing.isEmpty) {
await db.insert('menu', menu);
print("Menu ajouté: ${menu['name']}");
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
);
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);
// 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);
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
);
}
// 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);
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
);
}
// 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 && 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'],
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);
}
, 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(
if (gererCommandesMenu.isNotEmpty && viewPermission.isNotEmpty) {
// User peut voir les commandes
await db.insert(
'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'],
{
'role_id': userRoleId,
'menu_id': gererCommandesMenu.first['id'],
'permission_id': viewPermission.first['id'],
},
conflictAlgorithm: ConflictAlgorithm.ignore
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']);
// 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);
}
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");
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',
where: 'designation = ?',
whereArgs: ['Super Admin']
);
final superAdminRole = await db
.query('roles', where: 'designation = ?', 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', {
'role_id': roleId,
'permission_id': permissionId,
}, conflictAlgorithm: ConflictAlgorithm.ignore);
await db.insert(
'role_permissions',
{
'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', {
'menu_id': menuId,
'permission_id': permissionId,
}, conflictAlgorithm: ConflictAlgorithm.ignore);
await db.insert(
'menu_permissions',
{
'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 {
final db = await database;
final result = await db.rawQuery('''
Future<bool> hasPermission(
String username, String permissionName, String menuRoute) async {
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 {
final db = await database;
final result = await db.rawQuery('''
Future<List<Permission>> getPermissionsForRoleAndMenu(
int roleId, int menuId) async {
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();
}
// Ajoutez cette méthode temporaire pour supprimer la DB corrompue
Future<void> deleteDatabaseFile() async {
final documentsDirectory = await getApplicationDocumentsDirectory();
final path = join(documentsDirectory.path, 'app_database.db');
final file = File(path);
if (await file.exists()) {
await file.delete();
print("Base de données utilisateur supprimée");
return result.map((map) => Permission.fromMap(map)).toList();
}
}
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);
}
// Ajoutez cette méthode temporaire pour supprimer la DB corrompue
Future<void> deleteDatabaseFile() async {
final documentsDirectory = await getApplicationDocumentsDirectory();
final path = join(documentsDirectory.path, 'app_database.db');
final file = File(path);
if (await file.exists()) {
await file.delete();
print("Base de données utilisateur supprimée");
}
}
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],
);
}
}

61
lib/Services/pointageDatabase.dart
View File

@ -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]);
}
}

93
lib/Views/pointage.dart
View File

@ -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),
),
);
}
}

2
lib/accueil.dart
View File

@ -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,

Write Preview
Loading…
Cancel
Save