Dalibi est un outil complet libre et open-source de gestion pour les établissements scolaires du Togo et d'Afrique (primaire, collège, lycée). Élèves, notes & bulletins, présences, examens officiels, comptabilité & écolage, emploi du temps, documents PDF, stockage local/S3 et sauvegardes planifiées

• Backend : Laravel 12, PHP 8.3+
• Frontend : React 19, TypeScript, Tailwind CSS 4
• Pont : Inertia.js (SPA sans API REST séparée)
• Base de données : PostgreSQL 12+
• Auth : Laravel Sanctum + 2FA, Spatie Laravel Permission
• Files d'attente : e-mails et sauvegardes manuelles traités en arrière-plan (worker)
• Observabilité (optionnelle) : logs JSON pour Loki/Grafana + capture d'exceptions Sentry/GlitchTip — voir documentations/OBSERVABILITY.md

• Composé par permission : chaque profil ne voit que les sections auxquelles il a droit
• Finances (direction / comptabilité) : facturé / encaissé / reste, évolution mensuelle, caisses, synthèse du mois (encaissé / dépenses / solde net) et répartition par moyen de paiement (Mobile Money en avant)
• Inscriptions & effectifs : totaux, parité, inscriptions récentes, répartition par classe
• Vie scolaire : présences du jour, permissions en attente, prochains examens
• Enseignant (personnalisé) : emploi du temps du jour, notes à saisir (lien direct), ses classes avec accès rapide « Faire l'appel »
• Parents & élèves : synthèse par enfant via l'API portail (GET /api/v1/dashboard)
• Filtrage par année académique

Un menu Statistiques dédié, avec filtres (année, classe, sexe) et export PDF & Excel sur chaque section, aligné sur les indicateurs de l'annuaire statistique / carte scolaire (MEPSTA) :

• Effectifs & parité : effectifs par classe/sexe, indice de parité (IPS), répartition des statuts (promotion / redoublement / abandon), pyramide des âges et taux de sur-âge (retard scolaire, via l'âge attendu par classe)
• Finances & recouvrement : facturé / encaissé / reste, taux de recouvrement, répartition par mode de paiement (Mobile Money, espèces, virement, chèque), évolution mensuelle
• Réussite & examens : réussite interne, mentions, résultats aux examens officiels (CEPD, BEPC, BAC) avec taux d'admission par centre
• Encadrement : ratio élèves/enseignant (REM), taille moyenne des classes, classes pléthoriques
• Assiduité : taux de présence / absence / retard, absentéisme chronique
• Comparaisons pluriannuelles : évolution des indicateurs clés d'une année à l'autre
• Géographie : origine des élèves par région et préfecture du Togo

• Support multi-écoles (primaire, collège, lycée)
• Paramétrage par établissement : nom, code, devise, terme (ex. « République Togolaise »)
• Upload du logo de l'école (image, avec prévisualisation)
• Années académiques et périodes (trimestres)
• Types de classes et niveaux configurables

• Rôles par défaut : Administrateur, Directeur, Enseignant, Comptable, Secrétariat
• Accès piloté par les permissions (Spatie) : on peut créer un rôle personnalisé (censeur, surveillant…) et lui accorder des permissions depuis l'interface, sans code — menus, routes et tableau de bord s'adaptent automatiquement
• Préfixe de matricule configurable par rôle (config/matricule.php), repli générique USR
• Authentification email/mot de passe, Two-Factor Authentication (2FA)
• Affectation des enseignants aux classes et matières (tout rôle disposant de la permission de saisie des notes est sélectionnable)

• Création et gestion des classes
• Inscription des élèves avec statut (actif/transféré/retiré)
• Gestion des matières et attribution aux classes
• Calcul des moyennes configurable par établissement (coefficients, seuils)
• Système trimestre / semestre configurable par type de classe (le primaire en trimestres, le lycée en semestres dans le même établissement)

• Fiche élève complète avec photo de profil (stockage privé)
• Import CSV en masse (création groupée d'élèves)
• Promotion en masse des élèves vers la classe supérieure
• Réaffectation d'un élève vers une autre classe
• Statistiques par élève et effectifs / statut académique
• Effectifs / listes de classe avec export PDF
• Dossier de pièces par élève : tout fichier lié à l'élève (extrait de naissance, passeport, etc.) est rangé dans son dossier privé students/{id}, avec ajout dynamique (nom + fichier), téléchargement authentifié et suppression

• Grille hebdomadaire par classe (jour / créneau horaire)
• Création, modification et suppression des créneaux (matière, enseignant)
• Export PDF de l'emploi du temps d'une classe

• Modèles d'évaluation : création d'un template (nom, type, barème, date) une seule fois
• Déploiement vers les classes : sélection des classes + date individuelle par matière
• Planning des examens : vue par classe avec heure et édition de date en ligne, report / modification / suppression, export PDF imprimable (A4 paysage)
• Saisie des notes : grille pleine largeur par classe/matière, tri alphabétique des élèves
• Modèles d'évaluation par type de classe pour plus de cohérence
• Examens officiels (CEPD, BEPC, Baccalauréat) : liste filtrable (type, session, statut, recherche), rattachée à l'année académique active, gestion des inscriptions et des résultats (admis)

• Archivage de tout document (PDF, Office, image, CSV, ZIP) avec titre, description, catégorie et référence automatique (ARC-AAAA-0001)
• Tags réutilisables et colorés : page de gestion dédiée (création via modal, couleur, suppression), création à la volée depuis l'archivage, filtrage multi-tags. Un jeu de tags par défaut (Administratif, Comptable, Juridique, RH, Courrier…) est seedé (DocumentTagSeeder, inclus dans les données de référence)
• Liste filtrable (recherche, catégorie, tags, plage de dates) + pagination
• Liaison optionnelle d'un document à un élève (matricule) ou une classe
• Corbeille (soft delete) → restauration / suppression définitive
• Date de conservation (rétention) indicative
• Fichiers sur le disque privé secure, téléchargement via route authentifiée ; réservé aux rôles Admin / Directeur / Secrétariat

• Modèles de documents PDF personnalisables (éditeur de contenu riche)
• Éditeur d'en-tête glisser-déposer (par école) : positionnement libre du logo, du nom, de la devise et de champs de texte (avec variables {{ecole.nom}}…), réutilisé par tous les documents ; filigrane activable (texte ou image, opacité/taille/rotation). Repli sur l'en-tête classique sans configuration
• Génération de documents par élève (certificats, attestations…) avec en-tête (logo de l'école embarqué)
• Code-barres de vérification unique sur les documents pour éviter la falsification
• Traçabilité des documents délivrés par élève

• API REST (/api/v1) pour l'application mobile / SPA des familles, authentifiée par token (Laravel Sanctum)
• Deux profils : tuteur (consulte ses enfants) et élève (ses propres données), avec isolation stricte (un tuteur n'accède qu'à ses enfants)
• Tableau de bord (GET /api/v1/dashboard) : synthèse par enfant (moyenne/rang du trimestre, assiduité, écolage, dernier bulletin) + prochains événements
• Lecture : notes par période, bulletins (liste + PDF), présences, scolarité / solde, calendrier
• Onboarding : le secrétariat crée le compte tuteur, le lie aux élèves et envoie une invitation par e-mail (lien signé) ; l'accès élève est activé par l'établissement (connexion par matricule)
• Journal d'audit des actions sensibles (création/modification/suppression) et calendrier académique d'événements
• Documentation : docs/api/openapi.yaml (OpenAPI 3.1)

Un visualiseur Redoc est exposé sur /docs/api, mais gardé par l'environnement : il décrit toute la surface d'API et ne doit pas être public.

• En prod, le viewer renvoie 404 (gardé dans le contrôleur) ; en complément, l'image Docker n'embarque pas docs/ (sauf la spec docs/api/openapi.yaml, nécessaire au viewer staging).
• Variable d'env : API_DOCS_ENABLED (défaut false). À ne mettre à true que sur staging ; ne jamais l'activer en production.

• Saisie de l'appel : grille par classe / date / session (journée, matin, après-midi)
• Statuts : Présent, Absent, Retard (avec minutes), Excusé
• Actions groupées "Tous présents / Tous absents"
• Affichage automatique du badge permission quand un élève a une permission approuvée couvrant la date
• Enregistrement idempotent (la même saisie peut être soumise plusieurs fois sans doublon)

• Création d'une demande (élève, période, motif : médical / familial / autre, justification)
• Révision par Directeur ou Administrateur (approbation / rejet + commentaire)
• Auto-excusement : à l'approbation, toutes les absences enregistrées sur la période sont automatiquement marquées comme excusées
• Cards de statistiques (total / en attente / approuvées / rejetées)
• Suppression bloquée pour les permissions approuvées

• Tableau de bord par classe et période
• Taux d'absence par élève avec barre colorée (vert < 10 %, orange < 20 %, rouge ≥ 20 %)
• Résumé journalier (présents / absents / retards / excusés par séance)

• Journal des transactions
• Situation financière par classe
• Gestion des caisses
• Frais scolaires avec catégories, structures et bourses étudiantes

• Structuration des frais par catégorie, classe et année — création toujours rattachée à l'année académique active
• Tranches de paiement (échéancier) avec contrôle serveur : le total des tranches ne peut jamais dépasser le montant de la structure
• Réplication d'une année : copie de toutes les structures (et leurs tranches) d'une année source vers l'année active, sans doublons
• Inscriptions et paiements des écolages avec cycle de facturation (émise / partiellement payée / payée)
• Reçus de paiement : numérotation séquentielle (REC-AAAA-0001), code-barres avec code de vérification unique anti-falsification, page de vérification réservée à la comptabilité ; garde-fou anti trop-perçu

• Saisie des notes par période (contrôle continu Classe / Composition), moyennes pondérées par coefficient
• Bulletins figés (snapshot) par classe et période : moyennes, rangs (global + par matière), mentions, récapitulatif inter-périodes et moyenne annuelle
• Calcul par lot performant : la validation d'une classe précharge tout en mémoire (fini les milliers de requêtes)
• Barème de mentions configurable — de « Tableau d'honneur » à « Avertissement (travail) »
• Édition d'un bulletin (appréciations par matière, observations, décision, discipline) conservée lors d'une re-validation (option « tout régénérer » pour repartir de zéro)
• Téléchargement PDF individuel ou groupé (toute la classe en un seul PDF)
• Dévalidation d'un bulletin figé (créé par erreur / élève parti)
• Réclamations sur les notes : dépôt et traitement (uniquement si « en attente »), report automatique de la note corrigée
• Référence de bulletin unique, robuste à la concurrence (BUL-AAAA-0001)

• Choix du backend de stockage des fichiers depuis l'interface : local (serveur Laravel) ou cloud S3 (AWS S3, Cloudflare R2, MinIO, compatible S3)
• Bascule local ↔ cloud sans toucher au .env, ni redéploiement
• Configuration centralisée et propagée à tous les uploads de l'app via un disque logique media (toujours défini, y compris en console / file d'attente)
• Disque privé secure pour les fichiers sensibles (photos d'élèves, pièces du dossier) : stockés hors du dossier public, servis uniquement via des routes authentifiées
• Bouton « Tester la connexion » qui valide l'accès au stockage en temps réel (toast de résultat)
• Sécurité : credentials S3 chiffrés au repos (APP_KEY), clé d'accès masquée à l'affichage, page réservée aux administrateurs
• Recommandation Cloudflare R2 (S3-compatible, sans frais de bande passante sortante)

• Sauvegarde de la base depuis l'interface (Paramètres → Sauvegardes), aux formats JSON et SQL
• Stockage sur le dépôt distant configuré (S3 / Cloudflare R2) ou en local — via la même configuration centralisée que les uploads
• Planification des sauvegardes automatiques : quotidienne ou hebdomadaire, heure et jour configurables
• Rétention automatique (nombre de sauvegardes conservées par format)
• Historique des sauvegardes (taille, statut, origine manuelle/planifiée), téléchargement et suppression
• Restauration : import d'un fichier .json ou .sql pour réécrire la base ; une sauvegarde de sécurité est générée automatiquement avant l'opération
• Commande CLI : php artisan backup:run --formats=json,sql
• Les sauvegardes manuelles (interface) sont traitées en arrière-plan : un worker de file d'attente doit tourner (voir Installation → étape 7). Les sauvegardes planifiées et la commande CLI s'exécutent, elles, de façon synchrone.
• Page réservée aux administrateurs

• PHP 8.3+
• PostgreSQL 12+
• Composer
• Node.js & npm

git clone https://github.com/horacioskrp/dalibi.git
cd dalibi

composer install
npm install

cp .env.example .env
php artisan key:generate

Mettre à jour le fichier .env :

DB_CONNECTION=pgsql
DB_HOST=127.0.0.1
DB_PORT=5432
DB_DATABASE=ecolio
DB_USERNAME=postgres
DB_PASSWORD=votre_mot_de_passe

php artisan migrate
php artisan db:seed --class=SchoolDemoSeeder  # optionnel

php artisan storage:link   # requis pour servir les fichiers uploadés (logos…)

# Développement
npm run dev
php artisan serve

# Production
npm run build

L'application est accessible sur http://localhost:8000.

Pour activer les sauvegardes planifiées, ajoutez le planificateur Laravel au cron du serveur :

* * * * * cd /chemin/vers/dalibi && php artisan schedule:run >> /dev/null 2>&1

Certaines tâches sont traitées en arrière-plan via la file d'attente (QUEUE_CONNECTION=database par défaut, table jobs créée par les migrations) :

• l'envoi des e-mails (invitations au portail parents/élèves, réinitialisation de mot de passe) ;
• la génération des sauvegardes lancées manuellement depuis l'interface (le bouton Créer une sauvegarde).

Sans worker actif, ces tâches restent en attente et ne s'exécutent jamais. Les sauvegardes planifiées (via le scheduler de l'étape 6) ne sont pas concernées : elles s'exécutent de façon synchrone.

En production, gardez un worker en permanence avec un superviseur de processus (ex. supervisor) :

; /etc/supervisor/conf.d/dalibi-worker.conf
[program:dalibi-worker]
command=php /chemin/vers/dalibi/artisan queue:work --max-time=3600 --tries=3
autostart=true
autorestart=true
user=www-data
numprocs=1
redirect_stderr=true
stdout_logfile=/var/log/dalibi-worker.log
stopwaitsecs=3600

sudo supervisorctl reread && sudo supervisorctl update && sudo supervisorctl start dalibi-worker

En développement, un simple php artisan queue:work suffit. Après un déploiement, redémarrez le worker (php artisan queue:restart) pour qu'il charge le nouveau code.

(En Docker/Kubernetes, ce rôle est déjà fourni par le workload worker — voir ci-dessous.)

Image de production multi-stage (build PHP+Node → runtime PHP-FPM 8.3 + Nginx), non-root (utilisateur www-data, port non privilégié 8080) et prête pour Kubernetes.

Le rôle par défaut de l'image est le web (php-fpm + nginx). Les autres rôles s'obtiennent en surchargeant la commande de la même image :

Un docker-compose.yml de référence est fourni : il lance PostgreSQL + web + worker + scheduler, mirroir de l'architecture k8s.

# 1) Générer une clé applicative
docker run --rm dalibi php artisan key:generate --show   # ou : openssl rand -base64 32 → APP_KEY="base64:<valeur>"

# 2) Démarrer la base + construire l'image
APP_KEY="base64:..." docker compose up -d --build db

# 3) Migrer + seeder les données de référence (une seule fois)
APP_KEY="base64:..." docker compose run --rm migrate

# 4) Lancer l'application (web + worker + scheduler)
APP_KEY="base64:..." docker compose up -d

L'application est disponible sur http://localhost:8080 (variable APP_PORT). Variables utiles : APP_KEY (obligatoire), DB_*, APP_URL, APP_PORT.

Les fichiers (logos, filigranes, archives, photos, sauvegardes) sont persistés dans le volume app_storage (monté sur storage/app).

L'entrypoint attend la base de données, met en cache config/vues, puis migre/seed selon les variables :

Les données de référence (ReferenceDataSeeder) sont idempotentes : rôles & permissions, niveaux, types de classes, classes (PS → Terminale), matières, catégories de frais, types d'évaluation, bourses, tags d'archivage, en-tête & modèle de bulletin par défaut. Les modèles de documents nécessitent une école : créez votre établissement puis lancez php artisan db:seed --class=DocumentTemplateSeeder.

L'image est non-root (runAsNonRoot: true compatible PodSecurity « restricted »), expose le port 8080 et journalise sur stdout/stderr. Architecture recommandée — une seule image, plusieurs workloads :

• Deployment web : commande par défaut, livenessProbe/readinessProbe/startupProbe en httpGet sur /up (la HEALTHCHECK Docker est ignorée par k8s). Scalable (HPA).
• Deployment worker : command: ["php","artisan","queue:work","--max-time=3600"].
• Deployment scheduler : command: ["php","artisan","schedule:work"], replicas: 1 (sinon sauvegardes en double).
• Job migrate (hook Helm pre-upgrade) : command: ["php","artisan","migrate","--force"] ; mettez RUN_MIGRATIONS=false sur les pods.
• Stockage : en multi-réplicas, utilisez S3/R2 (FILESYSTEM_DISK=s3 + AWS_*) ou un volume RWX ; un PVC ReadWriteOnce ne convient qu'à un seul réplica.
• Secrets : APP_KEY, DB_*, AWS_* via Secret ; le reste en ConfigMap.

Production : RUN_MIGRATIONS via le Job/one-shot uniquement (jamais SEED_DATABASE). Générez APP_KEY avec php artisan key:generate --show.

Le seeder DefaultUsersSeeder crée un compte par rôle (mot de passe commun : password) :

Ces comptes sont marqués is_demo = true : une bannière d'avertissement s'affiche dans l'application lorsqu'ils sont connectés.

🔒 En production

1. Changez immédiatement les mots de passe (ou supprimez ces comptes de test).
2. Ne lancez pas DefaultUsersSeeder en prod ; créez plutôt votre administrateur, puis les comptes via Administration → Utilisateurs.
3. Pour purger les comptes de démo : User::where('is_demo', true)->delete();

• Authentification email / mot de passe
• Inscription publique désactivée : les comptes sont créés uniquement par un administrateur (module Utilisateurs)
• Limitation des tentatives de connexion (5/min par e-mail + IP)
• Two-Factor Authentication (2FA)
• UUIDs pour toutes les clés primaires
• Gestion des rôles et permissions via Spatie Laravel Permission
• Protection CSRF (Inertia)
• Validation stricte de toutes les entrées
• Credentials de stockage S3 chiffrés au repos (APP_KEY)
• Fichiers sensibles privés (photos d'élèves, pièces du dossier) hors du dossier public, servis via routes authentifiées
• Upload d'images restreint (pas de SVG → pas de XSS stocké) et génération PDF verrouillée (dompdf sans accès distant)
• Code-barres de vérification anti-falsification sur reçus et documents

L'application est entièrement gouvernée par les permissions (Spatie Laravel Permission). La protection est appliquée à 4 niveaux cohérents :

1. Menu : chaque entrée porte sa permission ; les items/groupes non autorisés sont masqués.
2. Routes : middleware can:<permission> (accès aux pages).
3. FormRequests : authorize() vérifie create_* / edit_* / review_*.
4. Contrôleurs & dashboard : actions et sections conditionnées par can(...).

Les permissions sont générées par module (aligné sur les menus) sous la forme {capacité}_{module} — ex. view_students, create_archives, delete_backups. Capacités : view, create, edit, delete, et spéciales export, generate, review, restore, execute, manage. ~145 permissions au total (voir App\Constants\Permissions).

Un administrateur peut affiner finement chaque rôle via Administration → Rôles & permissions, sans toucher au code.

Deux contrôles restent volontairement liés au rôle (sécurité/affichage, pas des gardes d'accès) : seul un administrateur peut supprimer un compte administrateur, et un enseignant ne voit que ses réclamations.

dalibi/
├── app/
│   ├── Models/          # Modèles Eloquent
│   ├── Http/Controllers/# Contrôleurs
│   └── Constants/       # Constantes (rôles…)
├── database/
│   ├── migrations/      # Migrations
│   └── seeders/         # Seeders
├── resources/
│   ├── js/
│   │   ├── pages/       # Pages React (Inertia)
│   │   ├── components/  # Composants UI réutilisables
│   │   ├── helpers/     # route.ts, etc.
│   │   └── types/       # Types TypeScript & menu
│   └── views/
│       └── exports/     # Vues Blade pour export PDF (planning)
└── routes/web.php       # Toutes les routes

• Bulletins électroniques (PDF) — bulletin configurable (colonnes, groupes, mentions) fidèle au format togolais
• Portail parents & élèves (API REST + onboarding)
• Calendrier académique
• Journal d'audit
• Statistiques & pilotage (parité, réussite, recouvrement, encadrement, assiduité, géographie) + export PDF/Excel
• Application mobile (consomme l'API du portail)
• Notifications & communication école-parents (e-mail / SMS / push)
• Paiement en ligne (mobile money : Flooz / T-Money…)
• Intégration avec le système éducatif togolais

php artisan test

Ce projet est sous licence MIT. Voir le fichier LICENSE pour plus de détails.

1. Fork le projet
2. Créer une branche (git checkout -b feature/ma-feature)
3. Commiter (git commit -m 'feat: description')
4. Pusher (git push origin feature/ma-feature)
5. Ouvrir une Pull Request

Horacio Skrp — GitHub

Note : Ce logiciel est en développement actif. Signalez les bugs via les GitHub Issues.