12 Commits

Author SHA1 Message Date
206c76c7db feat: Livraison version 3.0.6
- Amélioration de la gestion des entités et des utilisateurs
- Mise à jour des modèles Amicale et Client avec champs supplémentaires
- Ajout du service de logging et amélioration du chargement UI
- Refactoring des formulaires utilisateur et amicale
- Intégration de file_picker et image_picker pour la gestion des fichiers
- Amélioration de la gestion des membres et de leur suppression
- Optimisation des performances de l'API
- Mise à jour de la documentation technique

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>
2025-08-08 20:33:54 +02:00
pierre
599b9fcda0 feat: Gestion des secteurs et migration v3.0.4+304
- Ajout système complet de gestion des secteurs avec contours géographiques
- Import des contours départementaux depuis GeoJSON
- API REST pour la gestion des secteurs (/api/sectors)
- Service de géolocalisation pour déterminer les secteurs
- Migration base de données avec tables x_departements_contours et sectors_adresses
- Interface Flutter pour visualisation et gestion des secteurs
- Ajout thème sombre dans l'application
- Corrections diverses et optimisations

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>
2025-08-07 11:01:45 +02:00
d6soft
6a609fb467 docs: Ajout du guide de migration Git GitLab vers Gitea
- Guide complet avec toutes les commandes commentées
- Phases de migration sécurisées (sauvegarde, migration, nettoyage)
- Gestion des problèmes courants
- Exemple concret de la migration réalisée
2025-06-24 13:31:56 +02:00
d6soft
7763d02fae Livraison d ela gestion des opérations v0.4.0 2025-06-24 13:01:43 +02:00
d6soft
b9672a6228 Mise en place suppression membre 2025-06-12 16:39:44 +02:00
d6soft
4244b961fd membre add 2025-06-11 09:27:25 +02:00
d6soft
f3f1a9c5e8 Fix: Hive sync et update entité via API REST
- Correction mapping JSON membres (fk_role, chk_active)
- Ajout traitement amicale au login
- Fix callback onSubmit pour sync Hive après update API
2025-06-09 18:46:49 +02:00
d6soft
15a0f2d2be feat: refactorisation majeure - DataLoadingService + UserRepository simplifié
 NOUVEAU SERVICE CRÉÉ:
- DataLoadingService: gère tout le chargement des données au login
- Sépare les responsabilités: UserRepository se concentre sur l'auth
- Simplification massive du code de connexion

 USERREPOSITORY REFACTORISÉ:
- Suppression de toute la logique de chargement de données (déplacée vers DataLoadingService)
- Délégation complète aux services singleton (CurrentUserService, CurrentAmicaleService)
- Constructeur ultra-simplifié (plus d'injection ApiService)
- Méthodes d'auth optimisées et clarifiées

 REPOSITORIES SIMPLIFIÉS:
- AmicaleRepository: constructeur sans paramètres, ApiService.instance
- ClientRepository: même pattern de simplification
- MembreRepository: suppression injection, getters sécurisés
- OperationRepository: utilisation ApiService.instance
- PassageRepository: simplification massive, nouveau pattern
- SectorRepository: optimisation et nouvelle structure

 ARCHITECTURE SINGLETONS:
- ApiService: pattern singleton thread-safe
- CurrentUserService: gestion utilisateur connecté + persistence Hive (Box user)
- CurrentAmicaleService: gestion amicale courante + auto-sync
- Box Hive 'users' renommée en 'user' avec migration automatique

 APP.DART & MAIN.DART:
- Suppression injections multiples dans repositories
- Intégration des services singleton dans main.dart
- Router simplifié avec CurrentUserService

État: Architecture singleton opérationnelle, prêt pour tests et widgets
2025-06-05 18:35:12 +02:00
d6soft
86a9a35594 feat: création services singleton et renommage Box
Services créés:
 CurrentUserService singleton pour utilisateur connecté
 CurrentAmicaleService singleton pour amicale courante
 ApiService transformé en singleton

Box Hive:
 Renommage users -> user (plus logique)
 Migration automatique des données
 Services intégrés dans main.dart

État: Services créés, prêt pour refactorisation repositories
2025-06-05 17:02:11 +02:00
d6soft
e5ab857913 feat: création branche singletons - début refactorisation
- Sauvegarde des fichiers critiques
- Préparation transformation ApiService en singleton
- Préparation création CurrentUserService et CurrentAmicaleService
- Objectif: renommer Box users -> user
2025-06-05 15:22:29 +02:00
d6soft
2aa2706179 Merge branch 'feature/splashpage' 2025-06-04 16:56:43 +02:00
d6soft
41f1db1169 Amélioration de la splash_page et du login 2025-06-04 16:51:40 +02:00
1579 changed files with 444960 additions and 251017 deletions

6
.gitignore vendored
View File

@@ -20,12 +20,6 @@ web/storage/*.key
web/public/storage
web/public/hot
# API
api/sessions/
api/logs/
api/uploads/
api/vendor/
# Général
*.DS_Store
*.log

View File

@@ -1,40 +0,0 @@
# Changelog Version 3.1.6
## Date: 2025-08-21
### Améliorations des flux de passages
#### Interfaces utilisateur
- Optimisation de l'affichage des listes de passages
- Amélioration de l'ergonomie de navigation
- Ajout de filtres avancés pour la recherche de passages
- Mise à jour de l'interface responsive mobile
#### Flux de création
- Simplification du processus de création de passage
- Validation en temps réel des données saisies
- Ajout de modèles de passages prédéfinis
- Amélioration de la gestion des erreurs
#### Flux de consultation
- Affichage optimisé des détails de passage
- Historique complet des modifications
- Export des données en plusieurs formats
- Amélioration des performances de chargement
#### Flux de modification
- Interface de modification intuitive
- Suivi des changements avec comparaison avant/après
- Validation multi-niveaux des modifications
- Notifications automatiques des mises à jour
### Corrections de bugs
- Correction de l'affichage sur écrans de petite taille
- Résolution des problèmes de synchronisation
- Amélioration de la stabilité générale
### Améliorations techniques
- Optimisation des requêtes base de données
- Mise en cache des données fréquemment consultées
- Amélioration des temps de réponse API
- Refactoring du code pour une meilleure maintenabilité

Binary file not shown.

Before

Width:  |  Height:  |  Size: 255 KiB

View File

@@ -1,608 +0,0 @@
# Guide de Monitoring - Container Incus (Application Web PHP + MariaDB)
## Vue d'ensemble
Ce guide décrit les métriques essentielles à surveiller pour un container Incus hébergeant une application web PHP avec API mobile et base de données MariaDB.
---
## 1. Ressources Système
### CPU
**Pourquoi ?** Identifier les pics de charge et les processus gourmands
```bash
# Utilisation CPU globale du container
incus info nx4 | grep "CPU utilisé"
# Détail par processus (dans le container)
top -bn1 | head -20
htop
```
**Métriques à surveiller :**
- Load average (devrait être < nombre de CPU)
- % CPU par processus (MariaDB, PHP-FPM, nginx)
**Seuils d'alerte :**
- Warning : Load average > 70% des CPU
- 🚨 Critical : Load average > 150% des CPU pendant >5min
---
### Mémoire RAM
**Pourquoi ?** Éviter les OOM (Out of Memory) qui tuent les processus
```bash
# Vue globale depuis le host
incus info nx4 | grep "Mémoire"
# Détail dans le container
free -h
ps aux --sort=-%mem | head -10
```
**Métriques à surveiller :**
- RAM utilisée / totale
- Swap utilisé (devrait rester minimal)
- Top processus consommateurs
**Seuils d'alerte :**
- ⚠️ Warning : RAM > 85%
- 🚨 Critical : RAM > 95% ou Swap > 1GB
---
### Disque I/O
**Pourquoi ?** MariaDB est très sensible aux lenteurs disque
```bash
# Sur le host
iostat -x 2 5
# Dans le container
iostat -x 1 3
iotop -oa
```
**Métriques à surveiller :**
- Latence disque (await)
- IOPS (r/s, w/s)
- % utilisation disque
**Seuils d'alerte :**
- ⚠️ Warning : await > 50ms
- 🚨 Critical : await > 200ms ou %util > 90%
---
### Espace Disque
**Pourquoi ?** MariaDB ne peut plus écrire si disque plein
```bash
df -h
du -sh /var/lib/mysql
```
**Seuils d'alerte :**
- ⚠️ Warning : > 80% utilisé
- 🚨 Critical : > 90% utilisé
---
## 2. PHP-FPM (Application Web)
### Pool de Workers
**Pourquoi ?** Cause #1 des timeouts et coupures de service (votre cas !)
```bash
# Nombre de workers actifs
ps aux | grep "php-fpm: pool www" | wc -l
# Config du pool
grep "^pm" /etc/php/8.3/fpm/pool.d/www.conf
# Logs d'alertes
tail -f /var/log/php8.3-fpm.log | grep "max_children"
```
**Métriques critiques :**
- Nombre de workers actifs vs `pm.max_children`
- Warnings "max_children reached"
- Slow requests (>2s)
**Seuils d'alerte :**
- ⚠️ Warning : Workers actifs > 80% de max_children
- 🚨 Critical : Warning "max_children reached" apparaît
**Configuration recommandée pour votre cas :**
```ini
pm = dynamic
pm.max_children = 50-100 (selon RAM disponible)
pm.start_servers = 10-20
pm.min_spare_servers = 5-10
pm.max_spare_servers = 20-35
pm.max_requests = 500
```
---
### Temps de Réponse PHP
**Pourquoi ?** Scripts lents = workers bloqués
```bash
# Activer le slow log PHP-FPM
# Dans /etc/php/8.3/fpm/pool.d/www.conf
slowlog = /var/log/php8.3-fpm-slow.log
request_slowlog_timeout = 3s
# Voir les requêtes lentes
tail -f /var/log/php8.3-fpm-slow.log
```
**Seuils d'alerte :**
- ⚠️ Warning : Requêtes > 3s
- 🚨 Critical : Requêtes > 10s ou timeouts fréquents
---
## 3. MariaDB / MySQL
### Connexions
**Pourquoi ?** Trop de connexions = refus de nouvelles connexions
```bash
mysql -e "SHOW STATUS LIKE 'Threads_connected';"
mysql -e "SHOW STATUS LIKE 'Max_used_connections';"
mysql -e "SHOW VARIABLES LIKE 'max_connections';"
mysql -e "SHOW FULL PROCESSLIST;"
```
**Métriques critiques :**
- Connexions actives vs max_connections
- Connexions en attente / bloquées
- Requêtes longues (>5s)
**Seuils d'alerte :**
- ⚠️ Warning : Connexions > 80% de max_connections
- 🚨 Critical : Connexions = max_connections
**Config recommandée :**
```ini
max_connections = 200-500 (selon votre trafic)
```
---
### Slow Queries
**Pourquoi ?** Requêtes lentes = workers PHP bloqués
```bash
# Activer le slow query log
mysql -e "SET GLOBAL slow_query_log = 'ON';"
mysql -e "SET GLOBAL long_query_time = 2;"
mysql -e "SET GLOBAL log_queries_not_using_indexes = 'ON';"
# Voir les slow queries
tail -f /var/lib/mysql/slow-query.log
# ou
mysqldumpslow /var/lib/mysql/slow-query.log
```
**Seuils d'alerte :**
- ⚠️ Warning : Requêtes > 2s
- 🚨 Critical : Requêtes > 10s ou >50 slow queries/min
---
### InnoDB Buffer Pool
**Pourquoi ?** Si trop petit, beaucoup de lectures disque (lent)
```bash
mysql -e "SHOW VARIABLES LIKE 'innodb_buffer_pool_size';"
mysql -e "SHOW STATUS LIKE 'Innodb_buffer_pool_read%';"
```
**Métriques critiques :**
- Buffer pool hit ratio (devrait être >99%)
- Read requests vs reads from disk
**Config recommandée :**
- `innodb_buffer_pool_size` = 70-80% de la RAM dédiée à MySQL
- Pour 20GB de données : `innodb_buffer_pool_size = 16G`
---
### Deadlocks et Locks
**Pourquoi ?** Peuvent causer des timeouts
```bash
mysql -e "SHOW ENGINE INNODB STATUS\G" | grep -A 50 "LATEST DETECTED DEADLOCK"
mysql -e "SHOW OPEN TABLES WHERE In_use > 0;"
```
**Seuils d'alerte :**
- ⚠️ Warning : >1 deadlock/heure
- 🚨 Critical : Tables lockées >30s
---
## 4. Nginx / Serveur Web
### Connexions et Erreurs
**Pourquoi ?** Identifier les 502/504 (backend timeout)
```bash
# Connexions actives
netstat -an | grep :80 | wc -l
netstat -an | grep :443 | wc -l
# Erreurs récentes
tail -100 /var/log/nginx/error.log | grep -E "502|504|timeout"
tail -100 /var/log/nginx/access.log | grep -E " 502 | 504 "
```
**Métriques critiques :**
- Erreurs 502 Bad Gateway (PHP-FPM down)
- Erreurs 504 Gateway Timeout (PHP-FPM trop lent)
- Connexions actives
**Seuils d'alerte :**
- ⚠️ Warning : >5 erreurs 502/504 en 5min
- 🚨 Critical : >20 erreurs 502/504 en 5min
---
### Worker Connections
**Pourquoi ?** Limite le nombre de connexions simultanées
```bash
# Config nginx
grep worker_connections /etc/nginx/nginx.conf
ps aux | grep nginx | wc -l
```
**Config recommandée :**
```nginx
worker_processes auto;
worker_connections 2048;
```
---
## 5. Réseau
### Bande Passante
**Pourquoi ?** Identifier les pics de trafic
```bash
# Depuis le host
incus info nx4 | grep -A 10 "eth0:"
# Dans le container
iftop -i eth0
vnstat -i eth0
```
**Métriques :**
- Octets reçus/émis
- Paquets reçus/émis
- Erreurs réseau
---
### Connexions TCP
**Pourquoi ?** Trop de connexions TIME_WAIT = problème
```bash
netstat -an | grep -E "ESTABLISHED|TIME_WAIT|CLOSE_WAIT" | wc -l
ss -s
```
**Seuils d'alerte :**
- ⚠️ Warning : >1000 connexions TIME_WAIT
- 🚨 Critical : >5000 connexions TIME_WAIT
---
## 6. Logs et Événements
### Logs Système
```bash
# Container Debian
journalctl -u nginx -n 100
journalctl -u php8.3-fpm -n 100
journalctl -u mariadb -n 100
# Container Alpine (si pas de systemd)
tail -100 /var/log/messages
```
### Logs Applicatifs
```bash
# PHP errors
tail -100 /var/log/php8.3-fpm.log
tail -100 /var/www/html/logs/*.log
# Nginx
tail -100 /var/log/nginx/error.log
tail -100 /var/log/nginx/access.log
```
---
## 7. Scripts de Monitoring Automatisés
### Script de Monitoring Global
Créer `/root/monitor.sh` :
```bash
#!/bin/bash
LOG_FILE="/var/log/system-monitor.log"
ALERT_FILE="/var/log/alerts.log"
echo "=== Monitoring $(date) ===" >> $LOG_FILE
# 1. CPU
LOAD=$(uptime | awk -F'load average:' '{print $2}' | awk '{print $1}')
echo "Load: $LOAD" >> $LOG_FILE
# 2. RAM
RAM_PERCENT=$(free | awk '/Mem:/ {printf("%.1f"), ($3/$2)*100}')
echo "RAM: ${RAM_PERCENT}%" >> $LOG_FILE
if (( $(echo "$RAM_PERCENT > 85" | bc -l) )); then
echo "[WARNING] RAM > 85%: ${RAM_PERCENT}%" >> $ALERT_FILE
fi
# 3. PHP-FPM Workers
PHP_WORKERS=$(ps aux | grep "php-fpm: pool www" | wc -l)
PHP_MAX=$(grep "^pm.max_children" /etc/php/8.3/fpm/pool.d/www.conf | awk '{print $3}')
echo "PHP Workers: $PHP_WORKERS / $PHP_MAX" >> $LOG_FILE
if [ $PHP_WORKERS -gt $(echo "$PHP_MAX * 0.8" | bc) ]; then
echo "[WARNING] PHP Workers > 80%: $PHP_WORKERS / $PHP_MAX" >> $ALERT_FILE
fi
# 4. MySQL Connexions
MYSQL_CONN=$(mysql -e "SHOW STATUS LIKE 'Threads_connected';" | awk 'NR==2 {print $2}')
MYSQL_MAX=$(mysql -e "SHOW VARIABLES LIKE 'max_connections';" | awk 'NR==2 {print $2}')
echo "MySQL Connections: $MYSQL_CONN / $MYSQL_MAX" >> $LOG_FILE
if [ $MYSQL_CONN -gt $(echo "$MYSQL_MAX * 0.8" | bc) ]; then
echo "[WARNING] MySQL Connections > 80%: $MYSQL_CONN / $MYSQL_MAX" >> $ALERT_FILE
fi
# 5. Disque
DISK_PERCENT=$(df -h / | awk 'NR==2 {print $5}' | sed 's/%//')
echo "Disk: ${DISK_PERCENT}%" >> $LOG_FILE
if [ $DISK_PERCENT -gt 80 ]; then
echo "[WARNING] Disk > 80%: ${DISK_PERCENT}%" >> $ALERT_FILE
fi
# 6. Erreurs nginx
NGINX_ERRORS=$(grep -c "error" /var/log/nginx/error.log | tail -100)
if [ $NGINX_ERRORS -gt 10 ]; then
echo "[WARNING] Nginx errors: $NGINX_ERRORS in last 100 lines" >> $ALERT_FILE
fi
echo "" >> $LOG_FILE
```
**Installation :**
```bash
chmod +x /root/monitor.sh
# Exécuter toutes les 5 minutes
(crontab -l 2>/dev/null; echo "*/5 * * * * /root/monitor.sh") | crontab -
```
---
### Script de Monitoring PHP-FPM Spécifique
Créer `/root/monitor-php-fpm.sh` :
```bash
#!/bin/bash
LOG="/var/log/php-fpm-monitor.log"
TIMESTAMP=$(date '+%Y-%m-%d %H:%M:%S')
# Compter les workers (sans grep lui-même)
WORKERS=$(ps aux | grep 'php-fpm: pool www' | grep -v grep | wc -l)
MAX_CHILDREN=$(grep '^pm.max_children' /etc/php/8.3/fpm/pool.d/www.conf | awk '{print $3}')
PERCENT=$(echo "scale=1; ($WORKERS / $MAX_CHILDREN) * 100" | bc)
# Log au format: timestamp,workers,max,percentage
echo "$TIMESTAMP,$WORKERS,$MAX_CHILDREN,$PERCENT%" >> $LOG
# Alerte si >80%
if (( $(echo "$PERCENT > 80" | bc -l) )); then
echo "[$TIMESTAMP] [ALERT] PHP Workers > 80%: $WORKERS / $MAX_CHILDREN ($PERCENT%)" >> /var/log/alerts.log
fi
# Vérifier si max_children atteint dans les logs récents
if tail -10 /var/log/php8.3-fpm.log | grep -q "max_children"; then
echo "[$TIMESTAMP] [CRITICAL] MAX_CHILDREN REACHED!" >> /var/log/alerts.log
tail -3 /var/log/php8.3-fpm.log >> /var/log/alerts.log
fi
```
**Installation :**
```bash
chmod +x /root/monitor-php-fpm.sh
# Exécuter toutes les minutes
(crontab -l 2>/dev/null; echo "* * * * * /root/monitor-php-fpm.sh") | crontab -
```
**Visualiser les données :**
```bash
# Afficher les dernières 60 minutes
tail -60 /var/log/php-fpm-monitor.log
# Voir l'évolution graphique (nécessite gnuplot)
echo 'set datafile separator ","; plot "/var/log/php-fpm-monitor.log" using 2 with lines title "Workers"' | gnuplot -p
# Statistiques rapides
echo "Max workers last hour: $(tail -60 /var/log/php-fpm-monitor.log | cut -d',' -f2 | sort -n | tail -1)"
echo "Min workers last hour: $(tail -60 /var/log/php-fpm-monitor.log | cut -d',' -f2 | sort -n | head -1)"
echo "Avg workers last hour: $(tail -60 /var/log/php-fpm-monitor.log | cut -d',' -f2 | awk '{sum+=$1} END {print sum/NR}')"
# Alertes récentes
tail -20 /var/log/alerts.log | grep "PHP Workers"
```
**Rotation automatique des logs :**
Créer `/etc/logrotate.d/php-fpm-monitor` :
```
/var/log/php-fpm-monitor.log {
daily
rotate 30
compress
missingok
notifempty
}
```
---
## 8. Solutions de Monitoring Automatisées
### Option 1 : Netdata (Recommandé)
**Avantages :** Installation simple, interface web, détection auto des services
```bash
# Installation
bash <(curl -Ss https://get.netdata.cloud/kickstart.sh) --dont-wait
# Accessible sur http://IP:19999
# Détecte automatiquement : PHP-FPM, MariaDB, Nginx, ressources système
```
**Métriques auto-détectées :**
- ✅ CPU, RAM, I/O, réseau
- ✅ PHP-FPM (workers, slow requests)
- ✅ MariaDB (connexions, queries, locks)
- ✅ Nginx (connexions, erreurs)
---
### Option 2 : Prometheus + Grafana
**Avantages :** Professionnel, historique long terme, alerting avancé
```bash
# Exposer les métriques Incus
incus config set core.metrics_address :8443
# Installer Prometheus + Grafana
# (plus complexe, voir doc officielle)
```
---
### Option 3 : Scripts + Monitoring Simple
Si vous préférez rester léger, surveillez manuellement avec :
```bash
# Dashboard temps réel
watch -n 2 'echo "=== RESSOURCES ===";
free -h | head -2;
echo "";
echo "=== PHP-FPM ===";
ps aux | grep "php-fpm: pool" | wc -l;
echo "";
echo "=== MySQL ===";
mysql -e "SHOW STATUS LIKE \"Threads_connected\";" 2>/dev/null;
echo "";
echo "=== NGINX ===";
netstat -an | grep :80 | wc -l'
```
---
## 9. Checklist de Diagnostic en Cas de Problème
### Coupures / Timeouts
1.**Vérifier PHP-FPM** : `tail /var/log/php8.3-fpm.log | grep max_children`
2.**Vérifier MySQL** : `mysql -e "SHOW PROCESSLIST;"`
3.**Vérifier nginx** : `tail /var/log/nginx/error.log | grep -E "502|504"`
4.**Vérifier RAM** : `free -h`
5.**Vérifier I/O** : `iostat -x 1 5`
### Lenteurs
1.**Slow queries MySQL** : `tail /var/lib/mysql/slow-query.log`
2.**Slow PHP** : `tail /var/log/php8.3-fpm-slow.log`
3.**CPU** : `top -bn1 | head -20`
4.**I/O disque** : `iotop -oa`
### Crashes / Erreurs 502
1.**PHP-FPM status** : `systemctl status php8.3-fpm`
2.**OOM Killer** : `dmesg | grep -i "out of memory"`
3.**Logs PHP** : `tail -100 /var/log/php8.3-fpm.log`
---
## 10. Optimisations Recommandées
### PHP-FPM
```ini
# /etc/php/8.3/fpm/pool.d/www.conf
pm = dynamic
pm.max_children = 50-100
pm.start_servers = 10-20
pm.min_spare_servers = 5-10
pm.max_spare_servers = 20-35
pm.max_requests = 500
request_slowlog_timeout = 3s
```
### MariaDB
```ini
# /etc/mysql/mariadb.conf.d/50-server.cnf
max_connections = 200-500
innodb_buffer_pool_size = 16G # 70-80% de la RAM MySQL
slow_query_log = 1
long_query_time = 2
log_queries_not_using_indexes = 1
```
### Nginx
```nginx
# /etc/nginx/nginx.conf
worker_processes auto;
worker_connections 2048;
keepalive_timeout 30;
```
---
## Résumé des Seuils Critiques
| Métrique | Warning | Critical |
|----------|---------|----------|
| **RAM** | >85% | >95% |
| **CPU Load** | >70% CPU count | >150% CPU count |
| **Disk I/O await** | >50ms | >200ms |
| **Disk Space** | >80% | >90% |
| **PHP Workers** | >80% max | max_children reached |
| **MySQL Connections** | >80% max | = max_connections |
| **Slow Queries** | >2s | >10s ou >50/min |
| **Nginx 502/504** | >5 en 5min | >20 en 5min |
---
## Contacts et Escalade
En cas d'incident critique :
1. Vérifier les logs (`/var/log/alerts.log`)
2. Identifier le goulot (CPU/RAM/PHP/MySQL)
3. Appliquer le correctif approprié
4. Documenter l'incident
---
**Date de création :** 2025-10-18
**Dernière mise à jour :** 2025-10-18
**Version :** 1.0

View File

@@ -1,249 +0,0 @@
# PLANNING STRIPE - TÂCHES ADMINISTRATIVES
## Intégration Stripe Connect + Terminal pour Calendriers Pompiers
### Période : 25/08/2024 - 05/09/2024
---
## 📅 LUNDI 25/08 - Préparation (4h)
### ✅ Compte Stripe Platform
- [x] Créer compte Stripe sur https://dashboard.stripe.com/register
- [x] Remplir informations entreprise (SIRET, adresse, etc.)
- [x] Vérifier email de confirmation
- [x] Activer l'authentification 2FA
### ✅ Activation des produits
- [x] Activer Stripe Connect dans Dashboard → Products
- [x] Choisir type "Express accounts" pour les amicales
- [x] Activer Stripe Terminal dans Dashboard
- [x] Demander accès "Tap to Pay on iPhone" via formulaire support
### ✅ Configuration initiale
- [x] Définir les frais de plateforme (DECISION: 0% commission plateforme - 100% pour les amicales)
- [x] Configurer les paramètres de virement (J+2 recommandé)
- [x] Ajouter logo et branding pour les pages Stripe
---
## 📅 MARDI 26/08 - Setup environnements (2h)
### ✅ Clés API et Webhooks
- [x] Récupérer clés TEST (pk_test_... et sk_test_...)
- [x] Créer endpoint webhook : https://dapp.geosector.fr/api/stripe/webhook
- [x] Sélectionner événements webhook :
- `account.updated`
- `account.application.authorized`
- `payment_intent.succeeded`
- `payment_intent.payment_failed`
- `charge.dispute.created`
- [x] Noter le Webhook signing secret (whsec_...)
### ✅ Documentation amicales
- [x] Préparer template email pour amicales
- [x] Créer guide PDF "Activer les paiements CB"
- [x] Lister documents requis :
- Statuts association
- RIB avec IBAN/BIC
- Pièce identité responsable
- Justificatif adresse siège
---
## 📅 MERCREDI 27/08 - Amicale pilote (3h)
### ✅ Onboarding première amicale
- [x] Contacter amicale pilote (Amicale ID: 5)
- [x] Créer compte Connect Express via API
- [x] Envoyer lien onboarding à l'amicale
- [x] Suivre progression dans Dashboard → Connect → Accounts
- [x] Vérifier statut "Charges enabled"
### ✅ Configuration compte amicale
- [x] Vérifier informations bancaires (IBAN)
- [x] Configurer email notifications
- [x] Tester micro-virement de vérification
- [x] Noter le compte ID : acct_1S2YfNP63A07c33Y
---
## 📅 JEUDI 28/08 - Tests paiements (2h)
### ✅ Configuration Terminal Test
- [x] Créer "Location" test dans Dashboard → Terminal (Location ID: tml_GLJ21w7KCYX4Wj)
- [x] Générer reader test virtuel pour Simulator
- [x] Configurer les montants de test (10€, 20€, 30€)
### ✅ Cartes de test
- [x] Préparer liste cartes test :
- 4242 4242 4242 4242 : Succès
- 4000 0000 0000 9995 : Refus
- 4000 0025 0000 3155 : Authentification requise
- [x] Documenter processus de test pour développeurs
---
## 📅 VENDREDI 29/08 - Compliance et sécurité (2h)
### ✅ Conformité légale
- [ ] Vérifier statut PCI DSS (auto-évaluation SAQ A)
- [ ] Préparer mentions légales paiement
- [ ] Créer template CGV pour paiements
- [ ] Documenter process RGPD
### ✅ Limites et sécurité
- [ ] Configurer limites de paiement (max 500€/transaction ?)
- [ ] Activer Radar (protection fraude) rules
- [ ] Configurer alertes email pour transactions > 100€
- [ ] Définir politique remboursements
---
## 📅 SAMEDI 30/08 - Monitoring (1h)
### ✅ Dashboard et alertes
- [ ] Créer vues personnalisées Dashboard
- [ ] Configurer alertes :
- Taux d'échec > 10%
- Nouveau litige (chargeback)
- Compte amicale suspendu
- [ ] Installer app mobile Stripe (iOS/Android)
---
## 📅 LUNDI 02/09 - Préparation production (3h)
### ✅ Amicales supplémentaires
- [ ] Onboarder 2-3 amicales test supplémentaires
- [ ] Vérifier leurs statuts de compte
- [ ] Former les responsables à l'interface Stripe
### ✅ Documentation finale
- [ ] Guide administrateur plateforme
- [ ] FAQ amicales (comment voir mes ventes ?)
- [ ] Process de support niveau 1
---
## 📅 MARDI 03/09 - Tests grandeur nature (2h)
### ✅ Simulation production
- [ ] Paiement test avec vraie carte (sera remboursé)
- [ ] Vérifier apparition dans Dashboard amicale
- [ ] Tester virement vers compte bancaire
- [ ] Vérifier commissions plateforme
---
## 📅 MERCREDI 04/09 - Go/No-Go Production (2h)
### ✅ Checklist production
- [ ] Obtenir clés PRODUCTION (pk_live_... et sk_live_...)
- [ ] ⚠️ JAMAIS les commiter dans le code
- [ ] Configurer webhook production
- [ ] Vérifier tous les comptes amicales "enabled"
- [ ] Backup des configurations
### ✅ Plan de bascule
- [ ] Planifier fenêtre de maintenance
- [ ] Préparer rollback si besoin
- [ ] Numéro hotline Stripe : +33 1 88 45 05 35
---
## 📅 JEUDI 05/09 - Support jour J (4h)
### ✅ Surveillance active
- [ ] Monitoring Dashboard en temps réel
- [ ] Vérifier premiers paiements réels
- [ ] Support hotline pour amicales
- [ ] Documenter issues rencontrées
---
## 📊 RÉCAPITULATIF TEMPS ADMIN
- **Préparation** : 4h
- **Configuration** : 7h
- **Tests** : 4h
- **Production** : 6h
- **TOTAL** : 21h sur 11 jours
## 🔐 INFORMATIONS SENSIBLES À STOCKER
```env
# JAMAIS dans le code source !
STRIPE_PUBLIC_KEY_TEST=pk_test_...
STRIPE_SECRET_KEY_TEST=sk_test_...
STRIPE_WEBHOOK_SECRET_TEST=whsec_...
STRIPE_PUBLIC_KEY_LIVE=pk_live_...
STRIPE_SECRET_KEY_LIVE=sk_live_...
STRIPE_WEBHOOK_SECRET_LIVE=whsec_...
STRIPE_PLATFORM_ACCOUNT_ID=acct_...
```
## 📞 CONTACTS UTILES
- **Support Stripe France** : +33 1 88 45 05 35
- **Email support** : support@stripe.com
- **Dashboard** : https://dashboard.stripe.com
- **Statut système** : https://status.stripe.com
## ⚠️ POINTS D'ATTENTION CRITIQUES
1. **NE JAMAIS** partager les clés secrètes (sk_)
2. **TOUJOURS** commencer en mode TEST
3. **VÉRIFIER** 2x avant passage en LIVE
4. Les virements vers comptes amicales prennent 2-7 jours
5. Garder 1 personne dispo pour support le jour J
6. **Android Tap to Pay** : Vérifier certification SoftPOS des appareils
7. **Maintenir** liste des modèles Android certifiés à jour
---
## 🎯 BILAN DES ACCOMPLISSEMENTS (01/09/2024)
### ✅ RÉALISATIONS CLÉS
1. **Intégration Stripe Connect complète**
- API PHP 8.3 fonctionnelle avec tous les endpoints
- Interface Flutter pour gestion Stripe dans l'amicale
- Webhooks configurés et testés
2. **Compte amicale pilote opérationnel**
- Amicale ID: 5 avec compte Stripe : acct_1S2YfNP63A07c33Y
- Location Terminal créée : tml_GLJ21w7KCYX4Wj
- Onboarding Stripe complété avec succès
3. **Configuration 0% commission plateforme**
- 100% des paiements vont aux amicales
- Seuls les frais Stripe standard s'appliquent (~1.4% + 0.25€)
- Interface UI mise à jour pour refléter cette politique
4. **Corrections techniques majeures**
- Problèmes de déchiffrement des données résolus
- Erreurs 502 nginx corrigées (logs debug supprimés)
- Base de données et API entièrement fonctionnelles
### 🔧 PROBLÈMES RÉSOLUS
- **Erreur 500** : "Database not found" → Fixed
- **Erreur 400** : "Invalid email address" → Fixed (déchiffrement ajouté)
- **Erreur 502** : "upstream sent too big header" → Fixed (logs supprimés)
- **Commission plateforme** : Supprimée comme demandé (0%)
- **UI messaging** : Corrigé pour refléter "100% pour votre amicale"
### 📊 APIs FONCTIONNELLES
- ✅ POST /api/stripe/accounts - Création compte
- ✅ GET /api/stripe/accounts/:id/status - Statut compte
- ✅ POST /api/stripe/accounts/:id/onboarding-link - Lien onboarding
- ✅ POST /api/stripe/locations - Création location Terminal
- ✅ POST /api/stripe/webhook - Réception événements
### 🎯 PROCHAINES ÉTAPES
1. Tests de paiements réels avec Terminal
2. Déploiement en environnement de recette
3. Formation des amicales pilotes
4. Monitoring des premiers paiements
---
*Document créé le 24/08/2024 - Dernière mise à jour : 01/09/2024*

View File

@@ -1 +0,0 @@
3.5.2

Binary file not shown.

115
api/.vscode/settings.json vendored Executable file → Normal file
View File

@@ -1,116 +1,4 @@
{
"window.zoomLevel": 1, // Permet de zoomer, pratique si vous faites une présentation
// Apparence
// -- Editeur
"workbench.startupEditor": "none", // On ne veut pas une page d'accueil chargée
"editor.minimap.enabled": true, // On veut voir la minimap
"editor.minimap.showSlider": "always", // On veut voir la minimap
"editor.minimap.size": "fill", // On veut voir la minimap
"editor.minimap.scale": 2,
"editor.tokenColorCustomizations": {
"textMateRules": [
{
"scope": ["storage.type.function", "storage.type.class"],
"settings": {
"fontStyle": "bold",
"foreground": "#4B9CD3"
}
}
]
},
"editor.minimap.renderCharacters": true,
"editor.minimap.maxColumn": 120,
"breadcrumbs.enabled": false,
// -- Tabs
"workbench.editor.wrapTabs": true, // On veut voir les tabs
"workbench.editor.tabSizing": "shrink", // On veut voir les tabs
"workbench.editor.pinnedTabSizing": "compact",
"workbench.editor.enablePreview": false, // Un clic sur un fichier l'ouvre
// -- Sidebar
"workbench.tree.indent": 15, // Indente plus pour plus de clarté dans la sidebar
"workbench.tree.renderIndentGuides": "always",
// -- Code
"editor.occurrencesHighlight": "singleFile", // On veut voir les occurences d'une variable
"editor.renderWhitespace": "trailing", // On ne veut pas laisser d'espace en fin de ligne
"editor.renderControlCharacters": true, // On veut voir les caractères de contrôle
// Thème
"editor.fontFamily": "'JetBrains Mono', 'Fira Code', 'Operator Mono Lig', monospace",
"editor.fontLigatures": false,
"editor.fontSize": 13,
"editor.lineHeight": 22,
"editor.guides.bracketPairs": "active",
// Ergonomie
"editor.wordWrap": "off",
"editor.rulers": [],
"editor.suggest.insertMode": "replace", // L'autocomplétion remplace le mot en cours
"editor.acceptSuggestionOnCommitCharacter": false, // Evite que l'autocomplétion soit accepté lors d'un . par exemple
"editor.formatOnSave": true,
"editor.formatOnPaste": true,
"editor.linkedEditing": true, // Quand on change un élément HTML, change la balise fermante
"editor.tabSize": 2,
"editor.unicodeHighlight.nonBasicASCII": false,
"[php]": {
"editor.defaultFormatter": "bmewburn.vscode-intelephense-client",
"editor.formatOnSave": true,
"editor.formatOnPaste": true
},
"intelephense.format.braces": "k&r",
"intelephense.format.enable": true,
"[javascript]": {
"editor.defaultFormatter": "esbenp.prettier-vscode",
"editor.formatOnSave": true,
"editor.formatOnPaste": true
},
"prettier.printWidth": 360,
"prettier.semi": true,
"prettier.singleQuote": true,
"prettier.tabWidth": 2,
"prettier.trailingComma": "es5",
"explorer.autoReveal": false,
"explorer.confirmDragAndDrop": false,
"emmet.triggerExpansionOnTab": true,
"emmet.includeLanguages": {
"javascript": "javascriptreact"
},
"problems.decorations.enabled": true,
"explorer.decorations.colors": true,
"explorer.decorations.badges": true,
"php.validate.enable": true,
"php.suggest.basic": false,
"dart.analysisExcludedFolders": [],
"dart.enableSdkFormatter": true,
// Fichiers
"files.defaultLanguage": "markdown",
"files.autoSaveWorkspaceFilesOnly": true,
"files.exclude": {
"**/.idea": true
},
// Languages
"javascript.preferences.importModuleSpecifierEnding": "js",
"typescript.preferences.importModuleSpecifierEnding": "js",
// Extensions
"tailwindCSS.experimental.configFile": "web/tailwind.config.js",
"editor.quickSuggestions": {
"strings": true
},
"[svelte]": {
"editor.defaultFormatter": "svelte.svelte-vscode",
"editor.formatOnSave": true
},
"prettier.documentSelectors": ["**/*.svelte"],
"svelte.plugin.svelte.diagnostics.enable": false,
"js/ts.implicitProjectConfig.checkJs": false,
"svelte.enable-ts-plugin": false,
"workbench.colorCustomizations": {
"activityBar.activeBackground": "#fa1b49",
"activityBar.background": "#fa1b49",
@@ -130,6 +18,5 @@
"titleBar.inactiveBackground": "#dd053199",
"titleBar.inactiveForeground": "#e7e7e799"
},
"peacock.color": "#dd0531",
"peacock.color": "#dd0531"
}

View File

@@ -14,17 +14,10 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
## Build Commands
- Install dependencies: `composer install` - install PHP dependencies
- Update dependencies: `composer update` - update PHP dependencies to latest versions
- Deploy to DEV: `./deploy-api.sh` - deploy local code to dva-geo on IN3 (195.154.80.116)
- Deploy to REC: `./deploy-api.sh rca` - deploy from dva-geo to rca-geo on IN3
- Deploy to PROD: `./deploy-api.sh pra` - deploy from rca-geo (IN3) to pra-geo (IN4)
- Deploy to REC: `./livre-api.sh rec` - deploy from DVA to RECETTE environment
- Deploy to PROD: `./livre-api.sh prod` - deploy from RECETTE to PRODUCTION environment
- Export operations: `php export_operation.php` - export operations data
## Development Environment
- **DEV Container**: dva-geo on IN3 server (195.154.80.116)
- **DEV API URL Public**: https://dapp.geosector.fr/api/
- **DEV API URL Internal**: http://13.23.33.43/api/
- **Access**: Via Incus container on IN3 server
## Code Architecture
This is a PHP 8.3 API without framework, using a custom MVC-like architecture:

View File

@@ -1,651 +0,0 @@
#!/bin/bash
set -uo pipefail
# Note: Removed -e to allow script to continue on errors
# Errors are handled explicitly with ERROR_COUNT
# Parse command line arguments
ONLY_DB=false
if [[ "${1:-}" == "-onlydb" ]]; then
ONLY_DB=true
echo "Mode: Database backup only"
fi
# Configuration
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
CONFIG_FILE="$SCRIPT_DIR/d6back.yaml"
LOG_DIR="$SCRIPT_DIR/logs"
mkdir -p "$LOG_DIR"
LOG_FILE="$LOG_DIR/d6back-$(date +%Y%m%d).log"
ERROR_COUNT=0
RECAP_FILE="/tmp/backup_recap_$$.txt"
# Lock file to prevent concurrent executions
LOCK_FILE="/var/lock/d6back.lock"
exec 200>"$LOCK_FILE"
if ! flock -n 200; then
echo "ERROR: Another backup is already running" >&2
exit 1
fi
trap 'flock -u 200' EXIT
# Clean old log files (keep only last 10)
find "$LOG_DIR" -maxdepth 1 -name "d6back-*.log" -type f 2>/dev/null | sort -r | tail -n +11 | xargs -r rm -f || true
# Check dependencies - COMMENTED OUT
# for cmd in yq ssh tar openssl; do
# if ! command -v "$cmd" &> /dev/null; then
# echo "ERROR: $cmd is required but not installed" | tee -a "$LOG_FILE"
# exit 1
# fi
# done
# Load config
DIR_BACKUP=$(yq '.global.dir_backup' "$CONFIG_FILE" | tr -d '"')
ENC_KEY_PATH=$(yq '.global.enc_key' "$CONFIG_FILE" | tr -d '"')
BACKUP_SERVER=$(yq '.global.backup_server // "BACKUP"' "$CONFIG_FILE" | tr -d '"')
EMAIL_TO=$(yq '.global.email_to // "support@unikoffice.com"' "$CONFIG_FILE" | tr -d '"')
KEEP_DIRS=$(yq '.global.keep_dirs' "$CONFIG_FILE" | tr -d '"')
KEEP_DB=$(yq '.global.keep_db' "$CONFIG_FILE" | tr -d '"')
# Load encryption key
if [[ ! -f "$ENC_KEY_PATH" ]]; then
echo "ERROR: Encryption key not found: $ENC_KEY_PATH" | tee -a "$LOG_FILE"
exit 1
fi
ENC_KEY=$(cat "$ENC_KEY_PATH")
echo "=== Backup Started $(date) ===" | tee -a "$LOG_FILE"
echo "Backup directory: $DIR_BACKUP" | tee -a "$LOG_FILE"
# Check available disk space
DISK_USAGE=$(df "$DIR_BACKUP" | tail -1 | awk '{print $5}' | sed 's/%//')
DISK_FREE=$((100 - DISK_USAGE))
if [[ $DISK_FREE -lt 20 ]]; then
echo "WARNING: Low disk space! Only ${DISK_FREE}% free on backup partition" | tee -a "$LOG_FILE"
# Send warning email
echo "Sending DISK SPACE WARNING email to $EMAIL_TO (${DISK_FREE}% free)" | tee -a "$LOG_FILE"
if command -v msmtp &> /dev/null; then
{
echo "To: $EMAIL_TO"
echo "Subject: Backup${BACKUP_SERVER} WARNING - Low disk space (${DISK_FREE}% free)"
echo ""
echo "WARNING: Low disk space on $(hostname)"
echo ""
echo "Backup directory: $DIR_BACKUP"
echo "Disk usage: ${DISK_USAGE}%"
echo "Free space: ${DISK_FREE}%"
echo ""
echo "The backup will continue but please free up some space soon."
echo ""
echo "Date: $(date '+%d.%m.%Y %H:%M')"
} | msmtp "$EMAIL_TO"
echo "DISK SPACE WARNING email sent successfully to $EMAIL_TO" | tee -a "$LOG_FILE"
else
echo "WARNING: msmtp not found - DISK WARNING email NOT sent" | tee -a "$LOG_FILE"
fi
else
echo "Disk space OK: ${DISK_FREE}% free" | tee -a "$LOG_FILE"
fi
# Initialize recap file
echo "BACKUP REPORT - $(hostname) - $(date '+%d.%m.%Y %H')h" > "$RECAP_FILE"
echo "========================================" >> "$RECAP_FILE"
echo "" >> "$RECAP_FILE"
# Function to format size in MB with thousand separator
format_size_mb() {
local file="$1"
if [[ -f "$file" ]]; then
local size_kb=$(du -k "$file" | cut -f1)
local size_mb=$((size_kb / 1024))
# Add thousand separator with printf and sed
printf "%d" "$size_mb" | sed ':a;s/\B[0-9]\{3\}\>/\.&/;ta'
else
echo "0"
fi
}
# Function to calculate age in days
get_age_days() {
local file="$1"
local now=$(date +%s)
local file_time=$(stat -c %Y "$file" 2>/dev/null || echo 0)
echo $(( (now - file_time) / 86400 ))
}
# Function to get week number of year for a file
get_week_year() {
local file="$1"
local file_time=$(stat -c %Y "$file" 2>/dev/null || echo 0)
date -d "@$file_time" +"%Y-%W"
}
# Function to cleanup old backups according to retention policy
cleanup_old_backups() {
local DELETED_COUNT=0
local KEPT_COUNT=0
echo "" | tee -a "$LOG_FILE"
echo "=== Starting Backup Retention Cleanup ===" | tee -a "$LOG_FILE"
# Parse retention periods
local KEEP_DIRS_DAYS=${KEEP_DIRS%d} # Remove 'd' suffix
# Parse database retention (5d,3w,15m)
IFS=',' read -r KEEP_DB_DAILY KEEP_DB_WEEKLY KEEP_DB_MONTHLY <<< "$KEEP_DB"
local KEEP_DB_DAILY_DAYS=${KEEP_DB_DAILY%d}
local KEEP_DB_WEEKLY_WEEKS=${KEEP_DB_WEEKLY%w}
local KEEP_DB_MONTHLY_MONTHS=${KEEP_DB_MONTHLY%m}
# Convert to days
local KEEP_DB_WEEKLY_DAYS=$((KEEP_DB_WEEKLY_WEEKS * 7))
local KEEP_DB_MONTHLY_DAYS=$((KEEP_DB_MONTHLY_MONTHS * 30))
echo "Retention policy: dirs=${KEEP_DIRS_DAYS}d, db=${KEEP_DB_DAILY_DAYS}d/${KEEP_DB_WEEKLY_WEEKS}w/${KEEP_DB_MONTHLY_MONTHS}m" | tee -a "$LOG_FILE"
# Process each host directory
for host_dir in "$DIR_BACKUP"/*; do
if [[ ! -d "$host_dir" ]]; then
continue
fi
local host_name=$(basename "$host_dir")
echo " Cleaning host: $host_name" | tee -a "$LOG_FILE"
# Clean directory backups (*.tar.gz but not *.sql.gz.enc)
while IFS= read -r -d '' file; do
if [[ $(basename "$file") == *".sql.gz.enc" ]]; then
continue # Skip SQL files
fi
local age_days=$(get_age_days "$file")
if [[ $age_days -gt $KEEP_DIRS_DAYS ]]; then
rm -f "$file"
echo " Deleted: $(basename "$file") (${age_days}d > ${KEEP_DIRS_DAYS}d)" | tee -a "$LOG_FILE"
((DELETED_COUNT++))
else
((KEPT_COUNT++))
fi
done < <(find "$host_dir" -name "*.tar.gz" -type f -print0 2>/dev/null)
# Clean database backups with retention policy
declare -A db_files
while IFS= read -r -d '' file; do
local filename=$(basename "$file")
local db_name=${filename%%_*}
if [[ -z "${db_files[$db_name]:-}" ]]; then
db_files[$db_name]="$file"
else
db_files[$db_name]+=$'\n'"$file"
fi
done < <(find "$host_dir" -name "*.sql.gz.enc" -type f -print0 2>/dev/null)
# Process each database
for db_name in "${!db_files[@]}"; do
# Sort files by age (newest first)
mapfile -t files < <(echo "${db_files[$db_name]}" | while IFS= read -r f; do
echo "$f"
done | xargs -I {} stat -c "%Y {}" {} 2>/dev/null | sort -rn | cut -d' ' -f2-)
# Track which files to keep
declare -A keep_daily
declare -A keep_weekly
for file in "${files[@]}"; do
local age_days=$(get_age_days "$file")
if [[ $age_days -le $KEEP_DB_DAILY_DAYS ]]; then
# Keep all files within daily retention
((KEPT_COUNT++))
elif [[ $age_days -le $KEEP_DB_WEEKLY_DAYS ]]; then
# Weekly retention: keep one per day
local file_date=$(date -d "@$(stat -c %Y "$file")" +"%Y-%m-%d")
if [[ -z "${keep_daily[$file_date]:-}" ]]; then
keep_daily[$file_date]="$file"
((KEPT_COUNT++))
else
rm -f "$file"
((DELETED_COUNT++))
fi
elif [[ $age_days -le $KEEP_DB_MONTHLY_DAYS ]]; then
# Monthly retention: keep one per week
local week_year=$(get_week_year "$file")
if [[ -z "${keep_weekly[$week_year]:-}" ]]; then
keep_weekly[$week_year]="$file"
((KEPT_COUNT++))
else
rm -f "$file"
((DELETED_COUNT++))
fi
else
# Beyond retention period
rm -f "$file"
echo " Deleted: $(basename "$file") (${age_days}d > ${KEEP_DB_MONTHLY_DAYS}d)" | tee -a "$LOG_FILE"
((DELETED_COUNT++))
fi
done
unset keep_daily keep_weekly
done
unset db_files
done
echo "Cleanup completed: ${DELETED_COUNT} deleted, ${KEPT_COUNT} kept" | tee -a "$LOG_FILE"
# Add cleanup summary to recap file
echo "" >> "$RECAP_FILE"
echo "CLEANUP SUMMARY:" >> "$RECAP_FILE"
echo " Files deleted: $DELETED_COUNT" >> "$RECAP_FILE"
echo " Files kept: $KEPT_COUNT" >> "$RECAP_FILE"
}
# Function to backup a single database (must be defined before use)
backup_database() {
local database="$1"
local timestamp="$(date +%Y%m%d_%H)"
local backup_file="$backup_dir/sql/${database}_${timestamp}.sql.gz.enc"
echo " Backing up database: $database" | tee -a "$LOG_FILE"
if [[ "$ssh_user" != "root" ]]; then
CMD_PREFIX="sudo"
else
CMD_PREFIX=""
fi
# Execute backup with encryption
# First test MySQL connection to get clear error messages (|| true to continue on error)
MYSQL_TEST=$(ssh -i "$ssh_key" -p "$ssh_port" -o ConnectTimeout=20 "$ssh_user@$host_ip" \
"$CMD_PREFIX incus exec $container_name -- bash -c 'cat > /tmp/d6back.cnf << EOF
[client]
user=$db_user
password=$db_pass
host=$db_host
EOF
chmod 600 /tmp/d6back.cnf
mariadb --defaults-extra-file=/tmp/d6back.cnf -e \"SELECT 1\" 2>&1
rm -f /tmp/d6back.cnf'" 2>/dev/null || true)
if ssh -i "$ssh_key" -p "$ssh_port" -o ConnectTimeout=20 "$ssh_user@$host_ip" \
"$CMD_PREFIX incus exec $container_name -- bash -c 'cat > /tmp/d6back.cnf << EOF
[client]
user=$db_user
password=$db_pass
host=$db_host
EOF
chmod 600 /tmp/d6back.cnf
mariadb-dump --defaults-extra-file=/tmp/d6back.cnf --single-transaction --lock-tables=false --add-drop-table --create-options --databases $database 2>/dev/null | sed -e \"/^CREATE DATABASE/s/\\\`$database\\\`/\\\`${database}_${timestamp}\\\`/\" -e \"/^USE/s/\\\`$database\\\`/\\\`${database}_${timestamp}\\\`/\" | gzip
rm -f /tmp/d6back.cnf'" | \
openssl enc -aes-256-cbc -salt -pass pass:"$ENC_KEY" -pbkdf2 > "$backup_file" 2>/dev/null; then
# Validate backup file size (encrypted SQL should be > 100 bytes)
if [[ -f "$backup_file" ]]; then
file_size=$(stat -c%s "$backup_file" 2>/dev/null || echo 0)
if [[ $file_size -lt 100 ]]; then
# Analyze MySQL connection test results
if [[ "$MYSQL_TEST" == *"Access denied"* ]]; then
echo " ERROR: MySQL authentication failed for $database on $host_name/$container_name" | tee -a "$LOG_FILE"
echo " User: $db_user@$db_host - Check password in configuration" | tee -a "$LOG_FILE"
elif [[ "$MYSQL_TEST" == *"Unknown database"* ]]; then
echo " ERROR: Database '$database' does not exist on $host_name/$container_name" | tee -a "$LOG_FILE"
elif [[ "$MYSQL_TEST" == *"Can't connect"* ]]; then
echo " ERROR: Cannot connect to MySQL server at $db_host in $container_name" | tee -a "$LOG_FILE"
else
echo " ERROR: Backup file too small (${file_size} bytes): $database on $host_name/$container_name" | tee -a "$LOG_FILE"
fi
((ERROR_COUNT++))
rm -f "$backup_file"
else
size=$(du -h "$backup_file" | cut -f1)
size_mb=$(format_size_mb "$backup_file")
echo " ✓ Saved (encrypted): $(basename "$backup_file") ($size)" | tee -a "$LOG_FILE"
echo " SQL: $(basename "$backup_file") - ${size_mb} Mo" >> "$RECAP_FILE"
# Test backup integrity
if ! openssl enc -aes-256-cbc -d -pass pass:"$ENC_KEY" -pbkdf2 -in "$backup_file" | gunzip -t 2>/dev/null; then
echo " ERROR: Backup integrity check failed for $database" | tee -a "$LOG_FILE"
((ERROR_COUNT++))
fi
fi
else
echo " ERROR: Backup file not created: $database" | tee -a "$LOG_FILE"
((ERROR_COUNT++))
fi
else
# Analyze MySQL connection test for failed backup
if [[ "$MYSQL_TEST" == *"Access denied"* ]]; then
echo " ERROR: MySQL authentication failed for $database on $host_name/$container_name" | tee -a "$LOG_FILE"
echo " User: $db_user@$db_host - Check password in configuration" | tee -a "$LOG_FILE"
elif [[ "$MYSQL_TEST" == *"Unknown database"* ]]; then
echo " ERROR: Database '$database' does not exist on $host_name/$container_name" | tee -a "$LOG_FILE"
elif [[ "$MYSQL_TEST" == *"Can't connect"* ]]; then
echo " ERROR: Cannot connect to MySQL server at $db_host in $container_name" | tee -a "$LOG_FILE"
else
echo " ERROR: Failed to backup database $database on $host_name/$container_name" | tee -a "$LOG_FILE"
fi
((ERROR_COUNT++))
rm -f "$backup_file"
fi
}
# Process each host
host_count=$(yq '.hosts | length' "$CONFIG_FILE")
for ((i=0; i<$host_count; i++)); do
host_name=$(yq ".hosts[$i].name" "$CONFIG_FILE" | tr -d '"')
host_ip=$(yq ".hosts[$i].ip" "$CONFIG_FILE" | tr -d '"')
ssh_user=$(yq ".hosts[$i].user" "$CONFIG_FILE" | tr -d '"')
ssh_key=$(yq ".hosts[$i].key" "$CONFIG_FILE" | tr -d '"')
ssh_port=$(yq ".hosts[$i].port // 22" "$CONFIG_FILE" | tr -d '"')
echo "Processing host: $host_name ($host_ip)" | tee -a "$LOG_FILE"
echo "" >> "$RECAP_FILE"
echo "HOST: $host_name ($host_ip)" >> "$RECAP_FILE"
echo "----------------------------" >> "$RECAP_FILE"
# Test SSH connection
if ! ssh -i "$ssh_key" -p "$ssh_port" -o ConnectTimeout=20 -o StrictHostKeyChecking=no "$ssh_user@$host_ip" "true" 2>/dev/null; then
echo " ERROR: Cannot connect to $host_name ($host_ip)" | tee -a "$LOG_FILE"
((ERROR_COUNT++))
continue
fi
# Process containers
container_count=$(yq ".hosts[$i].containers | length" "$CONFIG_FILE" 2>/dev/null || echo "0")
for ((c=0; c<$container_count; c++)); do
container_name=$(yq ".hosts[$i].containers[$c].name" "$CONFIG_FILE" | tr -d '"')
echo " Processing container: $container_name" | tee -a "$LOG_FILE"
# Add container to recap
echo "" >> "$RECAP_FILE"
echo " Container: $container_name" >> "$RECAP_FILE"
# Create backup directories
backup_dir="$DIR_BACKUP/$host_name/$container_name"
mkdir -p "$backup_dir"
mkdir -p "$backup_dir/sql"
# Backup directories (skip if -onlydb mode)
if [[ "$ONLY_DB" == "false" ]]; then
dir_count=$(yq ".hosts[$i].containers[$c].dirs | length" "$CONFIG_FILE" 2>/dev/null || echo "0")
for ((d=0; d<$dir_count; d++)); do
dir_path=$(yq ".hosts[$i].containers[$c].dirs[$d]" "$CONFIG_FILE" | sed 's/^"\|"$//g')
# Use sudo if not root
if [[ "$ssh_user" != "root" ]]; then
CMD_PREFIX="sudo"
else
CMD_PREFIX=""
fi
# Special handling for /var/www - backup each subdirectory separately
if [[ "$dir_path" == "/var/www" ]]; then
echo " Backing up subdirectories of $dir_path" | tee -a "$LOG_FILE"
# Get list of subdirectories
subdirs=$(ssh -i "$ssh_key" -p "$ssh_port" -o ConnectTimeout=20 "$ssh_user@$host_ip" \
"$CMD_PREFIX incus exec $container_name -- find /var/www -maxdepth 1 -type d ! -path /var/www" 2>/dev/null || echo "")
for subdir in $subdirs; do
subdir_name=$(basename "$subdir" | tr '/' '_')
backup_file="$backup_dir/www_${subdir_name}_$(date +%Y%m%d_%H).tar.gz"
echo " Backing up: $subdir" | tee -a "$LOG_FILE"
if ssh -i "$ssh_key" -p "$ssh_port" -o ConnectTimeout=20 "$ssh_user@$host_ip" \
"$CMD_PREFIX incus exec $container_name -- tar czf - $subdir 2>/dev/null" > "$backup_file"; then
# Validate backup file size (tar.gz should be > 1KB)
if [[ -f "$backup_file" ]]; then
file_size=$(stat -c%s "$backup_file" 2>/dev/null || echo 0)
if [[ $file_size -lt 1024 ]]; then
echo " WARNING: Backup file very small (${file_size} bytes): $subdir" | tee -a "$LOG_FILE"
# Keep the file but note it's small
size=$(du -h "$backup_file" | cut -f1)
size_mb=$(format_size_mb "$backup_file")
echo " ✓ Saved (small): $(basename "$backup_file") ($size)" | tee -a "$LOG_FILE"
echo " DIR: $(basename "$backup_file") - ${size_mb} Mo (WARNING: small)" >> "$RECAP_FILE"
else
size=$(du -h "$backup_file" | cut -f1)
size_mb=$(format_size_mb "$backup_file")
echo " ✓ Saved: $(basename "$backup_file") ($size)" | tee -a "$LOG_FILE"
echo " DIR: $(basename "$backup_file") - ${size_mb} Mo" >> "$RECAP_FILE"
fi
# Test tar integrity
if ! tar tzf "$backup_file" >/dev/null 2>&1; then
echo " ERROR: Tar integrity check failed" | tee -a "$LOG_FILE"
((ERROR_COUNT++))
fi
else
echo " ERROR: Backup file not created: $subdir" | tee -a "$LOG_FILE"
((ERROR_COUNT++))
fi
else
echo " ERROR: Failed to backup $subdir" | tee -a "$LOG_FILE"
((ERROR_COUNT++))
rm -f "$backup_file"
fi
done
else
# Normal backup for other directories
dir_name=$(basename "$dir_path" | tr '/' '_')
backup_file="$backup_dir/${dir_name}_$(date +%Y%m%d_%H).tar.gz"
echo " Backing up: $dir_path" | tee -a "$LOG_FILE"
if ssh -i "$ssh_key" -p "$ssh_port" -o ConnectTimeout=20 "$ssh_user@$host_ip" \
"$CMD_PREFIX incus exec $container_name -- tar czf - $dir_path 2>/dev/null" > "$backup_file"; then
# Validate backup file size (tar.gz should be > 1KB)
if [[ -f "$backup_file" ]]; then
file_size=$(stat -c%s "$backup_file" 2>/dev/null || echo 0)
if [[ $file_size -lt 1024 ]]; then
echo " WARNING: Backup file very small (${file_size} bytes): $dir_path" | tee -a "$LOG_FILE"
# Keep the file but note it's small
size=$(du -h "$backup_file" | cut -f1)
size_mb=$(format_size_mb "$backup_file")
echo " ✓ Saved (small): $(basename "$backup_file") ($size)" | tee -a "$LOG_FILE"
echo " DIR: $(basename "$backup_file") - ${size_mb} Mo (WARNING: small)" >> "$RECAP_FILE"
else
size=$(du -h "$backup_file" | cut -f1)
size_mb=$(format_size_mb "$backup_file")
echo " ✓ Saved: $(basename "$backup_file") ($size)" | tee -a "$LOG_FILE"
echo " DIR: $(basename "$backup_file") - ${size_mb} Mo" >> "$RECAP_FILE"
fi
# Test tar integrity
if ! tar tzf "$backup_file" >/dev/null 2>&1; then
echo " ERROR: Tar integrity check failed" | tee -a "$LOG_FILE"
((ERROR_COUNT++))
fi
else
echo " ERROR: Backup file not created: $dir_path" | tee -a "$LOG_FILE"
((ERROR_COUNT++))
fi
else
echo " ERROR: Failed to backup $dir_path" | tee -a "$LOG_FILE"
((ERROR_COUNT++))
rm -f "$backup_file"
fi
fi
done
fi # End of directory backup section
# Backup databases
db_user=$(yq ".hosts[$i].containers[$c].db_user" "$CONFIG_FILE" 2>/dev/null | tr -d '"')
db_pass=$(yq ".hosts[$i].containers[$c].db_pass" "$CONFIG_FILE" 2>/dev/null | tr -d '"')
db_host=$(yq ".hosts[$i].containers[$c].db_host // \"localhost\"" "$CONFIG_FILE" 2>/dev/null | tr -d '"')
# Check if we're in onlydb mode
if [[ "$ONLY_DB" == "true" ]]; then
# Use onlydb list if it exists
onlydb_count=$(yq ".hosts[$i].containers[$c].onlydb | length" "$CONFIG_FILE" 2>/dev/null || echo "0")
if [[ "$onlydb_count" != "0" ]] && [[ "$onlydb_count" != "null" ]]; then
db_count="$onlydb_count"
use_onlydb=true
else
# No onlydb list, skip this container in onlydb mode
continue
fi
else
# Normal mode - use databases list
db_count=$(yq ".hosts[$i].containers[$c].databases | length" "$CONFIG_FILE" 2>/dev/null || echo "0")
use_onlydb=false
fi
if [[ -n "$db_user" ]] && [[ -n "$db_pass" ]] && [[ "$db_count" != "0" ]]; then
for ((db=0; db<$db_count; db++)); do
if [[ "$use_onlydb" == "true" ]]; then
db_name=$(yq ".hosts[$i].containers[$c].onlydb[$db]" "$CONFIG_FILE" | tr -d '"')
else
db_name=$(yq ".hosts[$i].containers[$c].databases[$db]" "$CONFIG_FILE" | tr -d '"')
fi
if [[ "$db_name" == "ALL" ]]; then
echo " Fetching all databases..." | tee -a "$LOG_FILE"
# Get database list
if [[ "$ssh_user" != "root" ]]; then
db_list=$(ssh -i "$ssh_key" -p "$ssh_port" -o ConnectTimeout=20 "$ssh_user@$host_ip" \
"sudo incus exec $container_name -- bash -c 'cat > /tmp/d6back.cnf << EOF
[client]
user=$db_user
password=$db_pass
host=$db_host
EOF
chmod 600 /tmp/d6back.cnf
mariadb --defaults-extra-file=/tmp/d6back.cnf -e \"SHOW DATABASES;\" 2>/dev/null
rm -f /tmp/d6back.cnf'" | \
grep -Ev '^(Database|information_schema|performance_schema|mysql|sys)$' || echo "")
else
db_list=$(ssh -i "$ssh_key" -p "$ssh_port" -o ConnectTimeout=20 "$ssh_user@$host_ip" \
"incus exec $container_name -- bash -c 'cat > /tmp/d6back.cnf << EOF
[client]
user=$db_user
password=$db_pass
host=$db_host
EOF
chmod 600 /tmp/d6back.cnf
mariadb --defaults-extra-file=/tmp/d6back.cnf -e \"SHOW DATABASES;\" 2>/dev/null
rm -f /tmp/d6back.cnf'" | \
grep -Ev '^(Database|information_schema|performance_schema|mysql|sys)$' || echo "")
fi
# Backup each database
for single_db in $db_list; do
backup_database "$single_db"
done
else
backup_database "$db_name"
fi
done
fi
done
done
echo "=== Backup Completed $(date) ===" | tee -a "$LOG_FILE"
# Cleanup old backups according to retention policy
cleanup_old_backups
# Show summary
total_size=$(du -sh "$DIR_BACKUP" 2>/dev/null | cut -f1)
echo "Total backup size: $total_size" | tee -a "$LOG_FILE"
# Add summary to recap
echo "" >> "$RECAP_FILE"
echo "========================================" >> "$RECAP_FILE"
# Add size details per host/container
echo "BACKUP SIZES:" >> "$RECAP_FILE"
for host_dir in "$DIR_BACKUP"/*; do
if [[ -d "$host_dir" ]]; then
host_name=$(basename "$host_dir")
host_size=$(du -sh "$host_dir" 2>/dev/null | cut -f1)
echo "" >> "$RECAP_FILE"
echo " $host_name: $host_size" >> "$RECAP_FILE"
# Size per container
for container_dir in "$host_dir"/*; do
if [[ -d "$container_dir" ]]; then
container_name=$(basename "$container_dir")
container_size=$(du -sh "$container_dir" 2>/dev/null | cut -f1)
echo " - $container_name: $container_size" >> "$RECAP_FILE"
fi
done
fi
done
echo "" >> "$RECAP_FILE"
echo "TOTAL SIZE: $total_size" >> "$RECAP_FILE"
echo "COMPLETED: $(date '+%d.%m.%Y %H:%M')" >> "$RECAP_FILE"
# Prepare email subject with date format
DATE_SUBJECT=$(date '+%d.%m.%Y %H')
# Send recap email
if [[ $ERROR_COUNT -gt 0 ]]; then
echo "Total errors: $ERROR_COUNT" | tee -a "$LOG_FILE"
# Add errors to recap
echo "" >> "$RECAP_FILE"
echo "ERRORS DETECTED: $ERROR_COUNT" >> "$RECAP_FILE"
echo "----------------------------" >> "$RECAP_FILE"
grep -i "ERROR" "$LOG_FILE" >> "$RECAP_FILE"
# Send email with ERROR in subject
echo "Sending ERROR email to $EMAIL_TO (Errors found: $ERROR_COUNT)" | tee -a "$LOG_FILE"
if command -v msmtp &> /dev/null; then
{
echo "To: $EMAIL_TO"
echo "Subject: Backup${BACKUP_SERVER} ERROR $DATE_SUBJECT"
echo ""
cat "$RECAP_FILE"
} | msmtp "$EMAIL_TO"
echo "ERROR email sent successfully to $EMAIL_TO" | tee -a "$LOG_FILE"
else
echo "WARNING: msmtp not found - ERROR email NOT sent" | tee -a "$LOG_FILE"
fi
else
echo "Backup completed successfully with no errors" | tee -a "$LOG_FILE"
# Send success recap email
echo "Sending SUCCESS recap email to $EMAIL_TO" | tee -a "$LOG_FILE"
if command -v msmtp &> /dev/null; then
{
echo "To: $EMAIL_TO"
echo "Subject: Backup${BACKUP_SERVER} $DATE_SUBJECT"
echo ""
cat "$RECAP_FILE"
} | msmtp "$EMAIL_TO"
echo "SUCCESS recap email sent successfully to $EMAIL_TO" | tee -a "$LOG_FILE"
else
echo "WARNING: msmtp not found - SUCCESS recap email NOT sent" | tee -a "$LOG_FILE"
fi
fi
# Clean up recap file
rm -f "$RECAP_FILE"
# Exit with error code if there were errors
if [[ $ERROR_COUNT -gt 0 ]]; then
exit 1
fi

View File

@@ -1,112 +0,0 @@
# Configuration for MariaDB and directories backup
# Backup structure: $dir_backup/$hostname/$containername/ for dirs
# $dir_backup/$hostname/$containername/sql/ for databases
# Global parameters
global:
backup_server: PM7 # Nom du serveur de backup (PM7, PM1, etc.)
email_to: support@unikoffice.com # Email de notification
dir_backup: /var/pierre/back # Base backup directory
enc_key: /home/pierre/.key_enc # Encryption key for SQL backups
keep_dirs: 7d # Garde 7 jours pour les dirs
keep_db: 5d,3w,15m # 5 jours complets, 3 semaines (1/jour), 15 mois (1/semaine)
# Hosts configuration
hosts:
- name: IN2
ip: 145.239.9.105
user: debian
key: /home/pierre/.ssh/backup_key
port: 22
dirs:
- /etc/nginx
containers:
- name: nx4
db_user: root
db_pass: MyDebServer,90b
db_host: localhost
dirs:
- /etc/nginx
- /var/www
databases:
- ALL # Backup all databases
onlydb: # Used only with -onlydb parameter (optional)
- turing
- name: IN3
ip: 195.154.80.116
user: pierre
key: /home/pierre/.ssh/backup_key
port: 22
dirs:
- /etc/nginx
containers:
- name: nx4
db_user: root
db_pass: MyAlpLocal,90b
db_host: localhost
dirs:
- /etc/nginx
- /var/www
databases:
- ALL # Backup all databases
onlydb: # Used only with -onlydb parameter (optional)
- geosector
- name: rca-geo
dirs:
- /etc/nginx
- /var/www
- name: dva-res
db_user: root
db_pass: MyAlpineDb.90b
db_host: localhost
dirs:
- /etc/nginx
- /var/www
databases:
- ALL
onlydb:
- resalice
- name: dva-front
dirs:
- /etc/nginx
- /var/www
- name: maria3
db_user: root
db_pass: MyAlpLocal,90b
db_host: localhost
dirs:
- /etc/my.cnf.d
- /var/osm
- /var/log
databases:
- ALL
onlydb:
- cleo
- rca_geo
- name: IN4
ip: 51.159.7.190
user: pierre
key: /home/pierre/.ssh/backup_key
port: 22
dirs:
- /etc/nginx
containers:
- name: maria4
db_user: root
db_pass: MyAlpLocal,90b
db_host: localhost
dirs:
- /etc/my.cnf.d
- /var/osm
- /var/log
databases:
- ALL
onlydb:
- cleo
- pra_geo

View File

@@ -1,118 +0,0 @@
#!/bin/bash
set -euo pipefail
# Colors for output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color
# Configuration
CONFIG_FILE="backpm7.yaml"
# Check if file argument is provided
if [ $# -eq 0 ]; then
echo -e "${RED}Error: No input file specified${NC}"
echo "Usage: $0 <database.sql.gz.enc>"
echo "Example: $0 wordpress_20250905_14.sql.gz.enc"
exit 1
fi
INPUT_FILE="$1"
# Check if input file exists
if [ ! -f "$INPUT_FILE" ]; then
echo -e "${RED}Error: File not found: $INPUT_FILE${NC}"
exit 1
fi
# Function to load encryption key from config
load_key_from_config() {
if [ ! -f "$CONFIG_FILE" ]; then
echo -e "${YELLOW}Warning: $CONFIG_FILE not found${NC}"
return 1
fi
# Check for yq
if ! command -v yq &> /dev/null; then
echo -e "${RED}Error: yq is required to read config file${NC}"
echo "Install with: sudo wget -qO /usr/local/bin/yq https://github.com/mikefarah/yq/releases/latest/download/yq_linux_amd64 && sudo chmod +x /usr/local/bin/yq"
return 1
fi
local key_path=$(yq '.global.enc_key' "$CONFIG_FILE" | tr -d '"')
if [ -z "$key_path" ]; then
echo -e "${RED}Error: enc_key not found in $CONFIG_FILE${NC}"
return 1
fi
if [ ! -f "$key_path" ]; then
echo -e "${RED}Error: Encryption key file not found: $key_path${NC}"
return 1
fi
ENC_KEY=$(cat "$key_path")
echo -e "${GREEN}Encryption key loaded from: $key_path${NC}"
return 0
}
# Check file type early - accept both old and new naming
if [[ "$INPUT_FILE" != *.sql.gz.enc ]] && [[ "$INPUT_FILE" != *.sql.tar.gz.enc ]]; then
echo -e "${RED}Error: File must be a .sql.gz.enc or .sql.tar.gz.enc file${NC}"
echo "This tool only decrypts SQL backup files created by backpm7.sh"
exit 1
fi
# Get encryption key from config
if ! load_key_from_config; then
echo -e "${RED}Error: Cannot load encryption key${NC}"
echo "Make sure $CONFIG_FILE exists and contains enc_key path"
exit 1
fi
# Process SQL backup file
echo -e "${BLUE}Decrypting SQL backup: $INPUT_FILE${NC}"
# Determine output file - extract just the filename and put in current directory
BASENAME=$(basename "$INPUT_FILE")
if [[ "$BASENAME" == *.sql.tar.gz.enc ]]; then
OUTPUT_FILE="${BASENAME%.sql.tar.gz.enc}.sql"
else
OUTPUT_FILE="${BASENAME%.sql.gz.enc}.sql"
fi
# Decrypt and decompress in one command
echo "Decrypting to: $OUTPUT_FILE"
# Decrypt and decompress in one pipeline
if openssl enc -aes-256-cbc -d -salt -pass pass:"$ENC_KEY" -pbkdf2 -in "$INPUT_FILE" | gunzip > "$OUTPUT_FILE" 2>/dev/null; then
# Get file size
size=$(du -h "$OUTPUT_FILE" | cut -f1)
echo -e "${GREEN}✓ Successfully decrypted: $OUTPUT_FILE ($size)${NC}"
# Show first few lines of SQL
echo -e "${BLUE}First 5 lines of SQL:${NC}"
head -n 5 "$OUTPUT_FILE"
else
echo -e "${RED}✗ Decryption failed${NC}"
echo "Possible causes:"
echo " - Wrong encryption key"
echo " - Corrupted file"
echo " - File was encrypted differently"
# Try to help debug
echo -e "\n${YELLOW}Debug info:${NC}"
echo "File size: $(du -h "$INPUT_FILE" | cut -f1)"
echo "First bytes (should start with 'Salted__'):"
hexdump -C "$INPUT_FILE" | head -n 1
# Let's also check what key we're using (first 10 chars)
echo "Key begins with: ${ENC_KEY:0:10}..."
exit 1
fi
echo -e "${GREEN}Operation completed successfully${NC}"

View File

@@ -1,248 +0,0 @@
#!/bin/bash
#
# sync_geosector.sh - Synchronise les backups geosector depuis PM7 vers maria3 (IN3) et maria4 (IN4)
#
# Ce script :
# 1. Trouve le dernier backup chiffré de geosector sur PM7
# 2. Le déchiffre et décompresse localement
# 3. Le transfère et l'importe dans IN3/maria3/geosector
# 4. Le transfère et l'importe dans IN4/maria4/geosector
#
# Installation: /var/pierre/bat/sync_geosector.sh
# Usage: ./sync_geosector.sh [--force] [--date YYYYMMDD_HH]
#
set -uo pipefail
# Note: Removed -e to allow script to continue on sync errors
# Errors are handled explicitly with ERROR_COUNT
# Configuration
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
CONFIG_FILE="$SCRIPT_DIR/d6back.yaml"
BACKUP_DIR="/var/pierre/back/IN3/nx4/sql"
ENC_KEY_FILE="/home/pierre/.key_enc"
SSH_KEY="/home/pierre/.ssh/backup_key"
TEMP_DIR="/tmp/geosector_sync"
LOG_FILE="/var/pierre/bat/logs/sync_geosector.log"
RECAP_FILE="/tmp/sync_geosector_recap_$$.txt"
# Load email config from d6back.yaml
if [[ -f "$CONFIG_FILE" ]]; then
EMAIL_TO=$(yq '.global.email_to // "support@unikoffice.com"' "$CONFIG_FILE" | tr -d '"')
BACKUP_SERVER=$(yq '.global.backup_server // "BACKUP"' "$CONFIG_FILE" | tr -d '"')
else
EMAIL_TO="support@unikoffice.com"
BACKUP_SERVER="BACKUP"
fi
# Serveurs cibles
IN3_HOST="195.154.80.116"
IN3_USER="pierre"
IN3_CONTAINER="maria3"
IN4_HOST="51.159.7.190"
IN4_USER="pierre"
IN4_CONTAINER="maria4"
# Credentials MariaDB
DB_USER="root"
IN3_DB_PASS="MyAlpLocal,90b" # maria3
IN4_DB_PASS="MyAlpLocal,90b" # maria4
DB_NAME="geosector"
# Fonctions utilitaires
log() {
echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*" | tee -a "$LOG_FILE"
}
error() {
log "ERROR: $*"
exit 1
}
cleanup() {
if [[ -d "$TEMP_DIR" ]]; then
log "Nettoyage de $TEMP_DIR"
rm -rf "$TEMP_DIR"
fi
rm -f "$RECAP_FILE"
}
trap cleanup EXIT
# Lecture de la clé de chiffrement
if [[ ! -f "$ENC_KEY_FILE" ]]; then
error "Clé de chiffrement non trouvée: $ENC_KEY_FILE"
fi
ENC_KEY=$(cat "$ENC_KEY_FILE")
# Parsing des arguments
FORCE=0
SPECIFIC_DATE=""
while [[ $# -gt 0 ]]; do
case $1 in
--force)
FORCE=1
shift
;;
--date)
SPECIFIC_DATE="$2"
shift 2
;;
*)
echo "Usage: $0 [--force] [--date YYYYMMDD_HH]"
exit 1
;;
esac
done
# Trouver le fichier backup
if [[ -n "$SPECIFIC_DATE" ]]; then
BACKUP_FILE="$BACKUP_DIR/geosector_${SPECIFIC_DATE}.sql.gz.enc"
if [[ ! -f "$BACKUP_FILE" ]]; then
error "Backup non trouvé: $BACKUP_FILE"
fi
else
# Chercher le plus récent
BACKUP_FILE=$(find "$BACKUP_DIR" -name "geosector_*.sql.gz.enc" -type f -printf '%T@ %p\n' | sort -rn | head -1 | cut -d' ' -f2-)
if [[ -z "$BACKUP_FILE" ]]; then
error "Aucun backup geosector trouvé dans $BACKUP_DIR"
fi
fi
BACKUP_BASENAME=$(basename "$BACKUP_FILE")
log "Backup sélectionné: $BACKUP_BASENAME"
# Initialiser le fichier récapitulatif
echo "SYNC GEOSECTOR REPORT - $(hostname) - $(date '+%d.%m.%Y %H')h" > "$RECAP_FILE"
echo "========================================" >> "$RECAP_FILE"
echo "" >> "$RECAP_FILE"
echo "Backup source: $BACKUP_BASENAME" >> "$RECAP_FILE"
echo "" >> "$RECAP_FILE"
# Créer le répertoire temporaire
mkdir -p "$TEMP_DIR"
DECRYPTED_FILE="$TEMP_DIR/geosector.sql"
# Étape 1: Déchiffrer et décompresser
log "Déchiffrement et décompression du backup..."
if ! openssl enc -aes-256-cbc -d -pass pass:"$ENC_KEY" -pbkdf2 -in "$BACKUP_FILE" | gunzip > "$DECRYPTED_FILE"; then
error "Échec du déchiffrement/décompression"
fi
FILE_SIZE=$(du -h "$DECRYPTED_FILE" | cut -f1)
log "Fichier SQL déchiffré: $FILE_SIZE"
echo "Decrypted SQL size: $FILE_SIZE" >> "$RECAP_FILE"
echo "" >> "$RECAP_FILE"
# Compteur d'erreurs
ERROR_COUNT=0
# Fonction pour synchroniser vers un serveur
sync_to_server() {
local HOST=$1
local USER=$2
local CONTAINER=$3
local DB_PASS=$4
local SERVER_NAME=$5
log "=== Synchronisation vers $SERVER_NAME ($HOST) ==="
echo "TARGET: $SERVER_NAME ($HOST/$CONTAINER)" >> "$RECAP_FILE"
# Test de connexion SSH
if ! ssh -i "$SSH_KEY" -o ConnectTimeout=10 "$USER@$HOST" "echo 'SSH OK'" &>/dev/null; then
log "ERROR: Impossible de se connecter à $HOST via SSH"
echo " ✗ SSH connection FAILED" >> "$RECAP_FILE"
((ERROR_COUNT++))
return 1
fi
# Import dans MariaDB
log "Import dans $SERVER_NAME/$CONTAINER/geosector..."
# Drop et recréer la base sur le serveur distant
if ! ssh -i "$SSH_KEY" "$USER@$HOST" "incus exec $CONTAINER --project default -- mariadb -u root -p'$DB_PASS' -e 'DROP DATABASE IF EXISTS $DB_NAME; CREATE DATABASE $DB_NAME CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;'"; then
log "ERROR: Échec de la création de la base sur $SERVER_NAME"
echo " ✗ Database creation FAILED" >> "$RECAP_FILE"
((ERROR_COUNT++))
return 1
fi
# Filtrer et importer le SQL (enlever CREATE DATABASE et USE avec timestamp)
log "Filtrage et import du SQL..."
if ! sed -e '/^CREATE DATABASE.*geosector_[0-9]/d' \
-e '/^USE.*geosector_[0-9]/d' \
"$DECRYPTED_FILE" | \
ssh -i "$SSH_KEY" "$USER@$HOST" "incus exec $CONTAINER --project default -- mariadb -u root -p'$DB_PASS' $DB_NAME"; then
log "ERROR: Échec de l'import sur $SERVER_NAME"
echo " ✗ SQL import FAILED" >> "$RECAP_FILE"
((ERROR_COUNT++))
return 1
fi
log "$SERVER_NAME: Import réussi"
echo " ✓ Import SUCCESS" >> "$RECAP_FILE"
echo "" >> "$RECAP_FILE"
}
# Synchronisation vers IN3/maria3
sync_to_server "$IN3_HOST" "$IN3_USER" "$IN3_CONTAINER" "$IN3_DB_PASS" "IN3/maria3"
# Synchronisation vers IN4/maria4
sync_to_server "$IN4_HOST" "$IN4_USER" "$IN4_CONTAINER" "$IN4_DB_PASS" "IN4/maria4"
# Finaliser le récapitulatif
echo "========================================" >> "$RECAP_FILE"
echo "COMPLETED: $(date '+%d.%m.%Y %H:%M')" >> "$RECAP_FILE"
# Préparer le sujet email avec date
DATE_SUBJECT=$(date '+%d.%m.%Y %H')
# Envoyer l'email récapitulatif
if [[ $ERROR_COUNT -gt 0 ]]; then
log "Total errors: $ERROR_COUNT"
# Ajouter les erreurs au récap
echo "" >> "$RECAP_FILE"
echo "ERRORS DETECTED: $ERROR_COUNT" >> "$RECAP_FILE"
echo "----------------------------" >> "$RECAP_FILE"
grep -i "ERROR" "$LOG_FILE" | tail -20 >> "$RECAP_FILE"
# Envoyer email avec ERROR dans le sujet
log "Sending ERROR email to $EMAIL_TO (Errors found: $ERROR_COUNT)"
if command -v msmtp &> /dev/null; then
{
echo "To: $EMAIL_TO"
echo "Subject: Sync${BACKUP_SERVER} ERROR $DATE_SUBJECT"
echo ""
cat "$RECAP_FILE"
} | msmtp "$EMAIL_TO"
log "ERROR email sent successfully to $EMAIL_TO"
else
log "WARNING: msmtp not found - ERROR email NOT sent"
fi
log "=== Synchronisation terminée avec des erreurs ==="
exit 1
else
log "=== Synchronisation terminée avec succès ==="
log "Les bases geosector sur maria3 et maria4 sont à jour avec le backup $BACKUP_BASENAME"
# Envoyer email de succès
log "Sending SUCCESS recap email to $EMAIL_TO"
if command -v msmtp &> /dev/null; then
{
echo "To: $EMAIL_TO"
echo "Subject: Sync${BACKUP_SERVER} $DATE_SUBJECT"
echo ""
cat "$RECAP_FILE"
} | msmtp "$EMAIL_TO"
log "SUCCESS recap email sent successfully to $EMAIL_TO"
else
log "WARNING: msmtp not found - SUCCESS recap email NOT sent"
fi
exit 0
fi

File diff suppressed because it is too large Load Diff

View File

@@ -8,20 +8,11 @@
"ext-openssl": "*",
"ext-pdo": "*",
"phpmailer/phpmailer": "^6.8",
"phpoffice/phpspreadsheet": "^5.0",
"setasign/fpdf": "^1.8",
"setasign/fpdi": "^2.6",
"stripe/stripe-php": "^17.6"
"phpoffice/phpspreadsheet": "^2.0"
},
"autoload": {
"psr-4": {
"App\\": "src/"
},
"classmap": [
"src/Core/",
"src/Config/",
"src/Utils/",
"src/Controllers/LogController.php"
"src/"
]
},
"config": {

229
api/composer.lock generated
View File

@@ -4,7 +4,7 @@
"Read more about it at https://getcomposer.org/doc/01-basic-usage.md#installing-dependencies",
"This file is @generated automatically"
],
"content-hash": "936a7e1a35fde56354a4dea02b309267",
"content-hash": "cf5e9de2a9687d04e4e094ad368ce366",
"packages": [
{
"name": "composer/pcre",
@@ -87,22 +87,22 @@
},
{
"name": "maennchen/zipstream-php",
"version": "3.2.0",
"version": "3.1.2",
"source": {
"type": "git",
"url": "https://github.com/maennchen/ZipStream-PHP.git",
"reference": "9712d8fa4cdf9240380b01eb4be55ad8dcf71416"
"reference": "aeadcf5c412332eb426c0f9b4485f6accba2a99f"
},
"dist": {
"type": "zip",
"url": "https://api.github.com/repos/maennchen/ZipStream-PHP/zipball/9712d8fa4cdf9240380b01eb4be55ad8dcf71416",
"reference": "9712d8fa4cdf9240380b01eb4be55ad8dcf71416",
"url": "https://api.github.com/repos/maennchen/ZipStream-PHP/zipball/aeadcf5c412332eb426c0f9b4485f6accba2a99f",
"reference": "aeadcf5c412332eb426c0f9b4485f6accba2a99f",
"shasum": ""
},
"require": {
"ext-mbstring": "*",
"ext-zlib": "*",
"php-64bit": "^8.3"
"php-64bit": "^8.2"
},
"require-dev": {
"brianium/paratest": "^7.7",
@@ -111,7 +111,7 @@
"guzzlehttp/guzzle": "^7.5",
"mikey179/vfsstream": "^1.6",
"php-coveralls/php-coveralls": "^2.5",
"phpunit/phpunit": "^12.0",
"phpunit/phpunit": "^11.0",
"vimeo/psalm": "^6.0"
},
"suggest": {
@@ -153,7 +153,7 @@
],
"support": {
"issues": "https://github.com/maennchen/ZipStream-PHP/issues",
"source": "https://github.com/maennchen/ZipStream-PHP/tree/3.2.0"
"source": "https://github.com/maennchen/ZipStream-PHP/tree/3.1.2"
},
"funding": [
{
@@ -161,7 +161,7 @@
"type": "github"
}
],
"time": "2025-07-17T11:15:13+00:00"
"time": "2025-01-27T12:07:53+00:00"
},
{
"name": "markbaker/complex",
@@ -272,16 +272,16 @@
},
{
"name": "phpmailer/phpmailer",
"version": "v6.11.1",
"version": "v6.10.0",
"source": {
"type": "git",
"url": "https://github.com/PHPMailer/PHPMailer.git",
"reference": "d9e3b36b47f04b497a0164c5a20f92acb4593284"
"reference": "bf74d75a1fde6beaa34a0ddae2ec5fce0f72a144"
},
"dist": {
"type": "zip",
"url": "https://api.github.com/repos/PHPMailer/PHPMailer/zipball/d9e3b36b47f04b497a0164c5a20f92acb4593284",
"reference": "d9e3b36b47f04b497a0164c5a20f92acb4593284",
"url": "https://api.github.com/repos/PHPMailer/PHPMailer/zipball/bf74d75a1fde6beaa34a0ddae2ec5fce0f72a144",
"reference": "bf74d75a1fde6beaa34a0ddae2ec5fce0f72a144",
"shasum": ""
},
"require": {
@@ -302,7 +302,6 @@
},
"suggest": {
"decomplexity/SendOauth2": "Adapter for using XOAUTH2 authentication",
"ext-imap": "Needed to support advanced email address parsing according to RFC822",
"ext-mbstring": "Needed to send email in multibyte encoding charset or decode encoded addresses",
"ext-openssl": "Needed for secure SMTP sending and DKIM signing",
"greew/oauth2-azure-provider": "Needed for Microsoft Azure XOAUTH2 authentication",
@@ -342,7 +341,7 @@
"description": "PHPMailer is a full-featured email creation and transfer class for PHP",
"support": {
"issues": "https://github.com/PHPMailer/PHPMailer/issues",
"source": "https://github.com/PHPMailer/PHPMailer/tree/v6.11.1"
"source": "https://github.com/PHPMailer/PHPMailer/tree/v6.10.0"
},
"funding": [
{
@@ -350,24 +349,24 @@
"type": "github"
}
],
"time": "2025-09-30T11:54:53+00:00"
"time": "2025-04-24T15:19:31+00:00"
},
{
"name": "phpoffice/phpspreadsheet",
"version": "5.1.0",
"version": "2.3.8",
"source": {
"type": "git",
"url": "https://github.com/PHPOffice/PhpSpreadsheet.git",
"reference": "fd26e45a814e94ae2aad0df757d9d1739c4bf2e0"
"reference": "7a700683743bf1c4a21837c84b266916f1aa7d25"
},
"dist": {
"type": "zip",
"url": "https://api.github.com/repos/PHPOffice/PhpSpreadsheet/zipball/fd26e45a814e94ae2aad0df757d9d1739c4bf2e0",
"reference": "fd26e45a814e94ae2aad0df757d9d1739c4bf2e0",
"url": "https://api.github.com/repos/PHPOffice/PhpSpreadsheet/zipball/7a700683743bf1c4a21837c84b266916f1aa7d25",
"reference": "7a700683743bf1c4a21837c84b266916f1aa7d25",
"shasum": ""
},
"require": {
"composer/pcre": "^1||^2||^3",
"composer/pcre": "^1 || ^2 || ^3",
"ext-ctype": "*",
"ext-dom": "*",
"ext-fileinfo": "*",
@@ -396,10 +395,9 @@
"mitoteam/jpgraph": "^10.3",
"mpdf/mpdf": "^8.1.1",
"phpcompatibility/php-compatibility": "^9.3",
"phpstan/phpstan": "^1.1 || ^2.0",
"phpstan/phpstan-deprecation-rules": "^1.0 || ^2.0",
"phpstan/phpstan-phpunit": "^1.0 || ^2.0",
"phpunit/phpunit": "^10.5",
"phpstan/phpstan": "^1.1",
"phpstan/phpstan-phpunit": "^1.0",
"phpunit/phpunit": "^9.6 || ^10.5",
"squizlabs/php_codesniffer": "^3.7",
"tecnickcom/tcpdf": "^6.5"
},
@@ -454,9 +452,9 @@
],
"support": {
"issues": "https://github.com/PHPOffice/PhpSpreadsheet/issues",
"source": "https://github.com/PHPOffice/PhpSpreadsheet/tree/5.1.0"
"source": "https://github.com/PHPOffice/PhpSpreadsheet/tree/2.3.8"
},
"time": "2025-09-04T05:34:49+00:00"
"time": "2025-02-08T03:01:45+00:00"
},
{
"name": "psr/http-client",
@@ -668,183 +666,6 @@
"source": "https://github.com/php-fig/simple-cache/tree/3.0.0"
},
"time": "2021-10-29T13:26:27+00:00"
},
{
"name": "setasign/fpdf",
"version": "1.8.6",
"source": {
"type": "git",
"url": "https://github.com/Setasign/FPDF.git",
"reference": "0838e0ee4925716fcbbc50ad9e1799b5edfae0a0"
},
"dist": {
"type": "zip",
"url": "https://api.github.com/repos/Setasign/FPDF/zipball/0838e0ee4925716fcbbc50ad9e1799b5edfae0a0",
"reference": "0838e0ee4925716fcbbc50ad9e1799b5edfae0a0",
"shasum": ""
},
"require": {
"ext-gd": "*",
"ext-zlib": "*"
},
"type": "library",
"autoload": {
"classmap": [
"fpdf.php"
]
},
"notification-url": "https://packagist.org/downloads/",
"license": [
"MIT"
],
"authors": [
{
"name": "Olivier Plathey",
"email": "oliver@fpdf.org",
"homepage": "http://fpdf.org/"
}
],
"description": "FPDF is a PHP class which allows to generate PDF files with pure PHP. F from FPDF stands for Free: you may use it for any kind of usage and modify it to suit your needs.",
"homepage": "http://www.fpdf.org",
"keywords": [
"fpdf",
"pdf"
],
"support": {
"source": "https://github.com/Setasign/FPDF/tree/1.8.6"
},
"time": "2023-06-26T14:44:25+00:00"
},
{
"name": "setasign/fpdi",
"version": "v2.6.4",
"source": {
"type": "git",
"url": "https://github.com/Setasign/FPDI.git",
"reference": "4b53852fde2734ec6a07e458a085db627c60eada"
},
"dist": {
"type": "zip",
"url": "https://api.github.com/repos/Setasign/FPDI/zipball/4b53852fde2734ec6a07e458a085db627c60eada",
"reference": "4b53852fde2734ec6a07e458a085db627c60eada",
"shasum": ""
},
"require": {
"ext-zlib": "*",
"php": "^7.1 || ^8.0"
},
"conflict": {
"setasign/tfpdf": "<1.31"
},
"require-dev": {
"phpunit/phpunit": "^7",
"setasign/fpdf": "~1.8.6",
"setasign/tfpdf": "~1.33",
"squizlabs/php_codesniffer": "^3.5",
"tecnickcom/tcpdf": "^6.8"
},
"suggest": {
"setasign/fpdf": "FPDI will extend this class but as it is also possible to use TCPDF or tFPDF as an alternative. There's no fixed dependency configured."
},
"type": "library",
"autoload": {
"psr-4": {
"setasign\\Fpdi\\": "src/"
}
},
"notification-url": "https://packagist.org/downloads/",
"license": [
"MIT"
],
"authors": [
{
"name": "Jan Slabon",
"email": "jan.slabon@setasign.com",
"homepage": "https://www.setasign.com"
},
{
"name": "Maximilian Kresse",
"email": "maximilian.kresse@setasign.com",
"homepage": "https://www.setasign.com"
}
],
"description": "FPDI is a collection of PHP classes facilitating developers to read pages from existing PDF documents and use them as templates in FPDF. Because it is also possible to use FPDI with TCPDF, there are no fixed dependencies defined. Please see suggestions for packages which evaluates the dependencies automatically.",
"homepage": "https://www.setasign.com/fpdi",
"keywords": [
"fpdf",
"fpdi",
"pdf"
],
"support": {
"issues": "https://github.com/Setasign/FPDI/issues",
"source": "https://github.com/Setasign/FPDI/tree/v2.6.4"
},
"funding": [
{
"url": "https://tidelift.com/funding/github/packagist/setasign/fpdi",
"type": "tidelift"
}
],
"time": "2025-08-05T09:57:14+00:00"
},
{
"name": "stripe/stripe-php",
"version": "v17.6.0",
"source": {
"type": "git",
"url": "https://github.com/stripe/stripe-php.git",
"reference": "a6219df5df1324a0d3f1da25fb5e4b8a3307ea16"
},
"dist": {
"type": "zip",
"url": "https://api.github.com/repos/stripe/stripe-php/zipball/a6219df5df1324a0d3f1da25fb5e4b8a3307ea16",
"reference": "a6219df5df1324a0d3f1da25fb5e4b8a3307ea16",
"shasum": ""
},
"require": {
"ext-curl": "*",
"ext-json": "*",
"ext-mbstring": "*",
"php": ">=5.6.0"
},
"require-dev": {
"friendsofphp/php-cs-fixer": "3.72.0",
"phpstan/phpstan": "^1.2",
"phpunit/phpunit": "^5.7 || ^9.0"
},
"type": "library",
"extra": {
"branch-alias": {
"dev-master": "2.0-dev"
}
},
"autoload": {
"psr-4": {
"Stripe\\": "lib/"
}
},
"notification-url": "https://packagist.org/downloads/",
"license": [
"MIT"
],
"authors": [
{
"name": "Stripe and contributors",
"homepage": "https://github.com/stripe/stripe-php/contributors"
}
],
"description": "Stripe PHP Library",
"homepage": "https://stripe.com/",
"keywords": [
"api",
"payment processing",
"stripe"
],
"support": {
"issues": "https://github.com/stripe/stripe-php/issues",
"source": "https://github.com/stripe/stripe-php/tree/v17.6.0"
},
"time": "2025-08-27T19:32:42+00:00"
}
],
"packages-dev": [],

Binary file not shown.

View File

@@ -1,200 +0,0 @@
# =============================================================================
# Configuration NGINX PRODUCTION pour pra-geo (IN4)
# Date: 2025-10-07
# Environnement: PRODUCTION
# Server: Container pra-geo (13.23.34.43)
# Port: 80 uniquement (HTTP)
# SSL/HTTPS: Géré par le reverse proxy NGINX sur le host IN4
# =============================================================================
# Site principal (web statique)
server {
listen 80;
server_name geosector.fr;
root /var/www/geosector/web;
index index.html;
# Logs PRODUCTION
access_log /var/log/nginx/geosector-web_access.log combined;
error_log /var/log/nginx/geosector-web_error.log warn;
location / {
try_files $uri $uri/ /index.html;
}
# Assets statiques avec cache agressif
location ~* \.(jpg|jpeg|png|gif|ico|svg|webp|css|js|woff|woff2|ttf|eot)$ {
expires 1y;
add_header Cache-Control "public, immutable";
access_log off;
}
# Protection des fichiers sensibles
location ~ /\.(?!well-known) {
deny all;
access_log off;
log_not_found off;
}
}
# =============================================================================
# APPLICATION FLUTTER + API PHP
# =============================================================================
server {
listen 80;
server_name app3.geosector.fr;
# Logs PRODUCTION
access_log /var/log/nginx/pra-app_access.log combined;
error_log /var/log/nginx/pra-app_error.log warn;
# Récupérer le vrai IP du client depuis le reverse proxy
set_real_ip_from 13.23.34.0/24; # Réseau Incus
set_real_ip_from 51.159.7.190; # IP publique IN4
real_ip_header X-Forwarded-For;
real_ip_recursive on;
# Taille maximale des uploads (pour les logos, exports, etc.)
client_max_body_size 10M;
client_body_buffer_size 128k;
# Timeouts optimisés pour PRODUCTION
client_body_timeout 30s;
client_header_timeout 30s;
send_timeout 60s;
# =============================================================================
# APPLICATION FLUTTER (contenu statique)
# =============================================================================
location / {
root /var/www/geosector/app;
index index.html;
try_files $uri $uri/ /index.html;
# Cache intelligent pour PRODUCTION
# HTML : pas de cache (pour déploiements)
location ~* \.html$ {
expires -1;
add_header Cache-Control "no-cache, no-store, must-revalidate";
}
# Assets Flutter (JS, CSS, fonts) avec hash : cache agressif
location ~* \.(js|css|woff|woff2|ttf|eot)$ {
expires 1y;
add_header Cache-Control "public, immutable";
access_log off;
}
# Images : cache longue durée
location ~* \.(jpg|jpeg|png|gif|ico|svg|webp)$ {
expires 30d;
add_header Cache-Control "public";
access_log off;
}
}
# =============================================================================
# API PHP (RESTful)
# =============================================================================
location /api/ {
root /var/www/geosector;
# CORS - Le reverse proxy IN4 ajoute déjà les headers CORS
# On les ajoute ici pour les requêtes internes si besoin
# Cache API : pas de cache (données dynamiques)
add_header Cache-Control "no-store, no-cache, must-revalidate" always;
add_header Pragma "no-cache" always;
add_header Expires "0" always;
# Rewrite vers index.php
try_files $uri $uri/ /api/index.php$is_args$args;
# Traitement PHP
location ~ ^/api/(.+\.php)$ {
root /var/www/geosector;
# FastCGI PHP-FPM
fastcgi_pass unix:/run/php-fpm83/php-fpm.sock;
fastcgi_index index.php;
include fastcgi_params;
fastcgi_param SCRIPT_FILENAME $request_filename;
# Variable d'environnement PRODUCTION
fastcgi_param APP_ENV "production";
fastcgi_param SERVER_NAME "app3.geosector.fr";
# Headers transmis à PHP (viennent du reverse proxy)
fastcgi_param HTTP_X_REAL_IP $http_x_real_ip;
fastcgi_param HTTP_X_FORWARDED_FOR $http_x_forwarded_for;
fastcgi_param HTTP_X_FORWARDED_PROTO $http_x_forwarded_proto;
fastcgi_param HTTPS $http_x_forwarded_proto;
# Timeouts pour opérations longues (sync, exports)
fastcgi_read_timeout 300;
fastcgi_send_timeout 300;
fastcgi_connect_timeout 60;
# Buffers optimisés
fastcgi_buffer_size 128k;
fastcgi_buffers 256 16k;
fastcgi_busy_buffers_size 256k;
fastcgi_temp_file_write_size 256k;
}
}
# =============================================================================
# UPLOADS ET MÉDIAS
# =============================================================================
location /api/uploads/ {
alias /var/www/geosector/api/uploads/;
# Cache pour les médias uploadés
expires 7d;
add_header Cache-Control "public";
# Sécurité : empêcher l'exécution de scripts
location ~ \.(php|phtml|php3|php4|php5|phps)$ {
deny all;
}
}
# =============================================================================
# SÉCURITÉ
# =============================================================================
# Bloquer l'accès aux fichiers sensibles
location ~ /\.(?!well-known) {
deny all;
access_log off;
log_not_found off;
}
# Bloquer l'accès aux fichiers de configuration
location ~* \.(env|sql|bak|backup|swp|config|conf|ini|log)$ {
deny all;
access_log off;
log_not_found off;
}
# Protection contre les requêtes invalides
if ($request_method !~ ^(GET|HEAD|POST|PUT|DELETE|PATCH|OPTIONS)$) {
return 405;
}
# =============================================================================
# MONITORING
# =============================================================================
# Endpoint de health check (accessible en interne)
location = /nginx-health {
access_log off;
allow 127.0.0.1;
allow 13.23.34.0/24; # Réseau interne Incus
deny all;
return 200 "healthy\n";
add_header Content-Type text/plain;
}
}

View File

@@ -1,290 +0,0 @@
# =============================================================================
# Configuration NGINX PRODUCTION pour pra-geo (IN4)
# Date: 2025-10-07
# Environnement: PRODUCTION
# Server: IN4 (51.159.7.190)
# =============================================================================
# Site principal (redirection vers www ou app)
server {
listen 80;
server_name geosector.fr;
# Redirection permanente vers HTTPS
return 301 https://$server_name$request_uri;
}
server {
listen 443 ssl http2;
server_name geosector.fr;
# Certificats SSL
ssl_certificate /etc/letsencrypt/live/geosector.fr/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/geosector.fr/privkey.pem;
# Configuration SSL optimisée
ssl_protocols TLSv1.2 TLSv1.3;
ssl_ciphers 'ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-CHACHA20-POLY1305';
ssl_prefer_server_ciphers on;
ssl_session_cache shared:SSL:10m;
ssl_session_timeout 10m;
ssl_stapling on;
ssl_stapling_verify on;
root /var/www/geosector/web;
index index.html;
# Logs PRODUCTION
access_log /var/log/nginx/geosector-web_access.log combined;
error_log /var/log/nginx/geosector-web_error.log warn;
# Headers de sécurité
add_header Strict-Transport-Security "max-age=31536000; includeSubDomains; preload" always;
add_header X-Frame-Options "SAMEORIGIN" always;
add_header X-Content-Type-Options "nosniff" always;
add_header X-XSS-Protection "1; mode=block" always;
add_header Referrer-Policy "strict-origin-when-cross-origin" always;
location / {
try_files $uri $uri/ /index.html;
}
# Assets statiques avec cache agressif
location ~* \.(jpg|jpeg|png|gif|ico|svg|webp|css|js|woff|woff2|ttf|eot)$ {
expires 1y;
add_header Cache-Control "public, immutable";
access_log off;
}
# Protection des fichiers sensibles
location ~ /\.(?!well-known) {
deny all;
access_log off;
log_not_found off;
}
}
# =============================================================================
# APPLICATION FLUTTER + API PHP
# =============================================================================
# Redirection HTTP → HTTPS
server {
listen 80;
server_name app3.geosector.fr;
# Permettre Let's Encrypt validation
location ^~ /.well-known/acme-challenge/ {
root /var/www/letsencrypt;
allow all;
}
# Redirection permanente vers HTTPS
return 301 https://$server_name$request_uri;
}
server {
listen 443 ssl http2;
server_name app3.geosector.fr;
# Certificats SSL
ssl_certificate /etc/letsencrypt/live/app3.geosector.fr/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/app3.geosector.fr/privkey.pem;
# Configuration SSL optimisée (même que ci-dessus)
ssl_protocols TLSv1.2 TLSv1.3;
ssl_ciphers 'ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-CHACHA20-POLY1305';
ssl_prefer_server_ciphers on;
ssl_session_cache shared:SSL:10m;
ssl_session_timeout 10m;
ssl_stapling on;
ssl_stapling_verify on;
# Logs PRODUCTION
access_log /var/log/nginx/pra-app_access.log combined;
error_log /var/log/nginx/pra-app_error.log warn;
# Headers de sécurité globaux
add_header Strict-Transport-Security "max-age=31536000; includeSubDomains; preload" always;
add_header X-Frame-Options "SAMEORIGIN" always;
add_header X-Content-Type-Options "nosniff" always;
add_header X-XSS-Protection "1; mode=block" always;
add_header Referrer-Policy "strict-origin-when-cross-origin" always;
# Taille maximale des uploads (pour les logos, exports, etc.)
client_max_body_size 10M;
client_body_buffer_size 128k;
# Timeouts optimisés pour PRODUCTION
client_body_timeout 30s;
client_header_timeout 30s;
send_timeout 60s;
# =============================================================================
# APPLICATION FLUTTER (contenu statique)
# =============================================================================
location / {
root /var/www/geosector/app;
index index.html;
try_files $uri $uri/ /index.html;
# Cache intelligent pour PRODUCTION
# HTML : pas de cache (pour déploiements)
location ~* \.html$ {
expires -1;
add_header Cache-Control "no-cache, no-store, must-revalidate";
}
# Assets Flutter (JS, CSS, fonts) avec hash : cache agressif
location ~* \.(js|css|woff|woff2|ttf|eot)$ {
expires 1y;
add_header Cache-Control "public, immutable";
access_log off;
}
# Images : cache longue durée
location ~* \.(jpg|jpeg|png|gif|ico|svg|webp)$ {
expires 30d;
add_header Cache-Control "public";
access_log off;
}
}
# =============================================================================
# API PHP (RESTful)
# =============================================================================
location /api/ {
root /var/www/geosector;
# CORS - Liste blanche des origines autorisées en PRODUCTION
set $cors_origin "";
# Autoriser uniquement les domaines de production
if ($http_origin ~* ^https://(app\.geosector\.fr|geosector\.fr)$) {
set $cors_origin $http_origin;
}
# Gestion des preflight requests (OPTIONS)
if ($request_method = 'OPTIONS') {
add_header 'Access-Control-Allow-Origin' $cors_origin always;
add_header 'Access-Control-Allow-Methods' 'GET, POST, PUT, DELETE, PATCH, OPTIONS' always;
add_header 'Access-Control-Allow-Headers' 'DNT,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type,Range,Authorization' always;
add_header 'Access-Control-Allow-Credentials' 'true' always;
add_header 'Access-Control-Max-Age' 86400;
add_header 'Content-Type' 'text/plain; charset=utf-8';
add_header 'Content-Length' 0;
return 204;
}
# Headers CORS pour les requêtes normales
add_header 'Access-Control-Allow-Origin' $cors_origin always;
add_header 'Access-Control-Allow-Methods' 'GET, POST, PUT, DELETE, PATCH, OPTIONS' always;
add_header 'Access-Control-Allow-Headers' 'DNT,X-CustomHeader,Keep-Alive,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type,Authorization' always;
add_header 'Access-Control-Allow-Credentials' 'true' always;
# Cache API : pas de cache (données dynamiques)
add_header Cache-Control "no-store, no-cache, must-revalidate, proxy-revalidate" always;
add_header Pragma "no-cache" always;
add_header Expires "0" always;
# Headers de sécurité spécifiques API
add_header X-Content-Type-Options "nosniff" always;
add_header X-Frame-Options "DENY" always;
# Rewrite vers index.php
try_files $uri $uri/ /api/index.php$is_args$args;
# Traitement PHP
location ~ ^/api/(.+\.php)$ {
root /var/www/geosector;
# FastCGI PHP-FPM
fastcgi_pass unix:/run/php-fpm83/php-fpm.sock;
fastcgi_index index.php;
include fastcgi_params;
fastcgi_param SCRIPT_FILENAME $request_filename;
# Variable d'environnement PRODUCTION
fastcgi_param APP_ENV "production";
fastcgi_param SERVER_NAME "app3.geosector.fr";
# Headers transmis à PHP
fastcgi_param HTTP_X_REAL_IP $remote_addr;
fastcgi_param HTTP_X_FORWARDED_FOR $proxy_add_x_forwarded_for;
fastcgi_param HTTP_X_FORWARDED_PROTO $scheme;
# Timeouts pour opérations longues (sync, exports)
fastcgi_read_timeout 300;
fastcgi_send_timeout 300;
fastcgi_connect_timeout 60;
# Buffers optimisés
fastcgi_buffer_size 128k;
fastcgi_buffers 256 16k;
fastcgi_busy_buffers_size 256k;
fastcgi_temp_file_write_size 256k;
# Headers CORS pour réponses PHP
add_header 'Access-Control-Allow-Origin' $cors_origin always;
add_header 'Access-Control-Allow-Credentials' 'true' always;
}
}
# =============================================================================
# UPLOADS ET MÉDIAS
# =============================================================================
location /api/uploads/ {
alias /var/www/geosector/api/uploads/;
# Cache pour les médias uploadés
expires 7d;
add_header Cache-Control "public";
# Sécurité : empêcher l'exécution de scripts
location ~ \.(php|phtml|php3|php4|php5|phps)$ {
deny all;
}
}
# =============================================================================
# SÉCURITÉ
# =============================================================================
# Bloquer l'accès aux fichiers sensibles
location ~ /\.(?!well-known) {
deny all;
access_log off;
log_not_found off;
}
# Bloquer l'accès aux fichiers de configuration
location ~* \.(env|sql|bak|backup|swp|config|conf|ini|log)$ {
deny all;
access_log off;
log_not_found off;
}
# Bloquer les user-agents malveillants
if ($http_user_agent ~* (bot|crawler|spider|scraper|wget|curl)) {
return 403;
}
# Protection contre les requêtes invalides
if ($request_method !~ ^(GET|HEAD|POST|PUT|DELETE|PATCH|OPTIONS)$) {
return 405;
}
# =============================================================================
# MONITORING
# =============================================================================
# Endpoint de health check (accessible uniquement en local)
location = /nginx-health {
access_log off;
allow 127.0.0.1;
allow 13.23.34.0/24; # Réseau interne Incus
deny all;
return 200 "healthy\n";
add_header Content-Type text/plain;
}
}

View File

@@ -1 +0,0 @@
{"ip":"169.155.255.55","timestamp":1758618220,"retrieved_at":"2025-09-23 09:03:41"}

View File

@@ -1,30 +0,0 @@
# Répertoire data
Ce répertoire contient les données de référence pour l'API.
## Fichiers
- `stripe_certified_devices.json` (optionnel) : Liste personnalisée des appareils certifiés Stripe Tap to Pay
## Format stripe_certified_devices.json
Si vous souhaitez ajouter des appareils supplémentaires à la liste intégrée, créez un fichier `stripe_certified_devices.json` avec le format suivant :
```json
[
{
"manufacturer": "Samsung",
"model": "Galaxy A55",
"model_identifier": "SM-A556B",
"min_android_version": 14
},
{
"manufacturer": "Fairphone",
"model": "Fairphone 5",
"model_identifier": "FP5",
"min_android_version": 13
}
]
```
Les appareils dans ce fichier seront ajoutés à la liste intégrée dans le script CRON.

View File

@@ -1,42 +1,27 @@
#!/bin/bash
# Script de déploiement unifié pour GEOSECTOR API
# Version: 4.0 (Janvier 2025)
# Script de déploiement pour GEOSECTOR API
# Version: 3.0 (10 mai 2025)
# Auteur: Pierre (avec l'aide de Claude)
#
# Usage:
# ./deploy-api.sh # Déploiement local DEV (code → container geo)
# ./deploy-api.sh rca # Livraison RECETTE (container geo → rca-geo)
# ./deploy-api.sh pra # Livraison PRODUCTION (rca-geo → pra-geo)
set -euo pipefail
# =====================================
# Configuration générale
# =====================================
# Paramètre optionnel pour l'environnement cible
TARGET_ENV=${1:-dev}
# Configuration SSH
HOST_KEY="/home/pierre/.ssh/id_rsa_mbpi"
HOST_PORT="22"
HOST_USER="root"
# Configuration des serveurs
RCA_HOST="195.154.80.116" # IN3 - Serveur de recette
PRA_HOST="51.159.7.190" # IN4 - Serveur de production
JUMP_USER="root"
JUMP_HOST="195.154.80.116"
JUMP_PORT="22"
JUMP_KEY="/home/pierre/.ssh/id_rsa_mbpi"
# Configuration Incus
INCUS_PROJECT="default"
API_PATH="/var/www/geosector/api"
# Paramètres du container Incus
INCUS_PROJECT=default
INCUS_CONTAINER=dva-geo
CONTAINER_USER=root
# Paramètres de déploiement
FINAL_PATH="/var/www/geosector/api"
FINAL_OWNER="nginx"
FINAL_GROUP="nginx"
FINAL_OWNER_LOGS="nobody"
FINAL_GROUP_LOGS="nginx"
# Configuration de sauvegarde
BACKUP_DIR="/data/backup/geosector/api"
# Couleurs pour les messages
GREEN='\033[0;32m'
@@ -45,131 +30,61 @@ YELLOW='\033[0;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color
# =====================================
# Fonctions utilitaires
# =====================================
run_in_container() {
echo "-> Running: $*"
incus exec "${INCUS_CONTAINER}" -- "$@" || {
echo "❌ Failed to run: $*"
exit 1
}
}
# Fonction pour afficher les messages d'étape
echo_step() {
echo -e "${GREEN}==>${NC} $1"
}
# Fonction pour afficher les informations
echo_info() {
echo -e "${BLUE}Info:${NC} $1"
}
# Fonction pour afficher les avertissements
echo_warning() {
echo -e "${YELLOW}Warning:${NC} $1"
}
# Fonction pour afficher les erreurs
echo_error() {
echo -e "${RED}Error:${NC} $1"
exit 1
}
# Fonction pour nettoyer les anciens backups
cleanup_old_backups() {
local prefix=""
case $TARGET_ENV in
"dev") prefix="api-dev-" ;;
"rca") prefix="api-rca-" ;;
"pra") prefix="api-pra-" ;;
esac
# Vérification de l'environnement
echo_step "Verifying environment..."
echo_info "Cleaning old backups (keeping last 5)..."
ls -t "${BACKUP_DIR}"/${prefix}*.tar.gz 2>/dev/null | tail -n +6 | xargs -r rm -f && {
REMAINING_BACKUPS=$(ls "${BACKUP_DIR}"/${prefix}*.tar.gz 2>/dev/null | wc -l)
echo_info "Kept ${REMAINING_BACKUPS} backup(s) for ${TARGET_ENV}"
}
}
# =====================================
# Détermination de la configuration selon l'environnement
# =====================================
case $TARGET_ENV in
"dev")
echo_step "Configuring for DEV deployment on IN3"
SOURCE_TYPE="local_code"
DEST_CONTAINER="dva-geo"
DEST_HOST="${RCA_HOST}" # IN3 pour le DEV aussi
ENV_NAME="DEVELOPMENT"
;;
"rca")
echo_step "Configuring for RECETTE delivery"
SOURCE_TYPE="remote_container"
SOURCE_CONTAINER="dva-geo"
SOURCE_HOST="${RCA_HOST}"
DEST_CONTAINER="rca-geo"
DEST_HOST="${RCA_HOST}"
ENV_NAME="RECETTE"
;;
"pra")
echo_step "Configuring for PRODUCTION delivery"
SOURCE_TYPE="remote_container"
SOURCE_HOST="${RCA_HOST}"
SOURCE_CONTAINER="rca-geo"
DEST_CONTAINER="pra-geo"
DEST_HOST="${PRA_HOST}"
ENV_NAME="PRODUCTION"
;;
*)
echo_error "Unknown environment: $TARGET_ENV. Use 'dev', 'rca' or 'pra'"
;;
esac
echo_info "Deployment flow: ${ENV_NAME}"
# =====================================
# Création de l'archive selon la source
# =====================================
# Créer le dossier de backup s'il n'existe pas
if [ ! -d "${BACKUP_DIR}" ]; then
echo_info "Creating backup directory ${BACKUP_DIR}..."
mkdir -p "${BACKUP_DIR}" || echo_error "Failed to create backup directory"
# Vérification des fichiers requis
if [ ! -f "src/Config/AppConfig.php" ]; then
echo_error "Configuration file missing"
fi
# Horodatage format YYYYMMDDHH
TIMESTAMP=$(date +%Y%m%d%H)
# Nom de l'archive selon l'environnement
case $TARGET_ENV in
"dev")
ARCHIVE_NAME="api-dev-${TIMESTAMP}.tar.gz"
;;
"rca")
ARCHIVE_NAME="api-rca-${TIMESTAMP}.tar.gz"
;;
"pra")
ARCHIVE_NAME="api-pra-${TIMESTAMP}.tar.gz"
;;
esac
ARCHIVE_PATH="${BACKUP_DIR}/${ARCHIVE_NAME}"
if [ "$SOURCE_TYPE" = "local_code" ]; then
# DEV: Créer une archive depuis le code local
echo_step "Creating archive from local code..."
# Vérification des fichiers requis
if [ ! -f "src/Config/AppConfig.php" ]; then
echo_error "Configuration file missing"
fi
if [ ! -f "composer.json" ] || [ ! -f "composer.lock" ]; then
if [ ! -f "composer.json" ] || [ ! -f "composer.lock" ]; then
echo_error "Composer files missing"
fi
fi
tar --exclude='.git' \
# Étape 0: Définir le nom de l'archive
ARCHIVE_NAME="api-deploy-$(date +%s).tar.gz"
TEMP_ARCHIVE="/tmp/${ARCHIVE_NAME}"
echo_info "Archive name will be: $ARCHIVE_NAME"
# Étape 1: Créer une archive du projet
echo_step "Creating project archive..."
tar --exclude='.git' \
--exclude='.gitignore' \
--exclude='.vscode' \
--exclude='logs' \
--exclude='sessions' \
--exclude='opendata' \
--exclude='*.template' \
--exclude='*.sh' \
--exclude='.env' \
--exclude='.env_marker' \
--exclude='*.log' \
--exclude='.DS_Store' \
--exclude='README.md' \
@@ -179,205 +94,65 @@ if [ "$SOURCE_TYPE" = "local_code" ]; then
--exclude='*.swp' \
--exclude='*.swo' \
--exclude='*~' \
-czf "${ARCHIVE_PATH}" . 2>/dev/null || echo_error "Failed to create archive"
--warning=no-file-changed \
--no-xattrs \
-czf "${TEMP_ARCHIVE}" . || echo_error "Failed to create archive"
echo_info "Archive created: ${ARCHIVE_PATH}"
echo_info "Archive size: $(du -h "${ARCHIVE_PATH}" | cut -f1)"
# Vérifier la taille de l'archive
ARCHIVE_SIZE=$(du -h "${TEMP_ARCHIVE}" | cut -f1)
# Cette section n'est plus utilisée car RCA utilise maintenant remote_container
SSH_JUMP_CMD="ssh -i ${JUMP_KEY} -p ${JUMP_PORT} ${JUMP_USER}@${JUMP_HOST}"
elif [ "$SOURCE_TYPE" = "remote_container" ]; then
# RCA et PRA: Créer une archive depuis un container distant
echo_step "Creating archive from remote container ${SOURCE_CONTAINER} on ${SOURCE_HOST}..."
# Étape 2: Copier l'archive vers le serveur de saut
echo_step "Copying archive to jump server..."
echo_info "Archive size: $ARCHIVE_SIZE"
scp -i "${JUMP_KEY}" -P "${JUMP_PORT}" "${TEMP_ARCHIVE}" "${JUMP_USER}@${JUMP_HOST}:/tmp/${ARCHIVE_NAME}" || echo_error "Failed to copy archive to jump server"
# Créer l'archive sur le serveur source
ssh -i ${HOST_KEY} -p ${HOST_PORT} ${HOST_USER}@${SOURCE_HOST} "
incus project switch ${INCUS_PROJECT} &&
incus exec ${SOURCE_CONTAINER} -- tar \
--exclude='logs' \
--exclude='uploads' \
--exclude='sessions' \
--exclude='opendata' \
-czf /tmp/${ARCHIVE_NAME} -C ${API_PATH} .
" || echo_error "Failed to create archive on remote"
# Extraire l'archive du container vers l'hôte
ssh -i ${HOST_KEY} -p ${HOST_PORT} ${HOST_USER}@${SOURCE_HOST} "
incus file pull ${SOURCE_CONTAINER}/tmp/${ARCHIVE_NAME} /tmp/${ARCHIVE_NAME} &&
incus exec ${SOURCE_CONTAINER} -- rm -f /tmp/${ARCHIVE_NAME}
" || echo_error "Failed to extract archive from remote container"
# Copier l'archive vers la machine locale
scp -i ${HOST_KEY} -P ${HOST_PORT} ${HOST_USER}@${SOURCE_HOST}:/tmp/${ARCHIVE_NAME} ${ARCHIVE_PATH} || echo_error "Failed to copy archive locally"
echo_info "Archive saved: ${ARCHIVE_PATH}"
echo_info "Archive size: $(du -h "${ARCHIVE_PATH}" | cut -f1)"
fi
# Nettoyer les anciens backups
cleanup_old_backups
# =====================================
# Déploiement selon la destination
# =====================================
# Tous les déploiements se font maintenant sur des containers distants
if [ "$DEST_HOST" != "local" ]; then
# Déploiement sur container distant (DEV, RCA ou PRA)
echo_step "Deploying to remote container ${DEST_CONTAINER} on ${DEST_HOST}..."
# Créer une sauvegarde sur le serveur de destination
BACKUP_TIMESTAMP=$(date +"%Y%m%d_%H%M%S")
REMOTE_BACKUP_DIR="${API_PATH}_backup_${BACKUP_TIMESTAMP}"
echo_info "Creating backup on destination..."
ssh -i ${HOST_KEY} -p ${HOST_PORT} ${HOST_USER}@${DEST_HOST} "
incus project switch ${INCUS_PROJECT} &&
incus exec ${DEST_CONTAINER} -- test -d ${API_PATH} &&
incus exec ${DEST_CONTAINER} -- cp -r ${API_PATH} ${REMOTE_BACKUP_DIR} &&
echo 'Backup created: ${REMOTE_BACKUP_DIR}'
" || echo_warning "No existing installation to backup"
# Transférer l'archive vers le serveur de destination
echo_info "Transferring archive to ${DEST_HOST}..."
if [ "$SOURCE_TYPE" = "local_code" ]; then
# Pour DEV: copier depuis local vers IN3
scp -i ${HOST_KEY} -P ${HOST_PORT} ${ARCHIVE_PATH} ${HOST_USER}@${DEST_HOST}:/tmp/${ARCHIVE_NAME} || echo_error "Failed to copy archive to destination"
elif [ "$SOURCE_TYPE" = "remote_container" ] && [ "$SOURCE_HOST" = "$DEST_HOST" ]; then
# Pour RCA: même serveur (IN3), pas de transfert nécessaire, l'archive est déjà là
echo_info "Archive already on destination server (same host)"
else
# Pour PRA: l'archive est déjà sur la machine locale (copiée depuis IN3)
# On la transfère maintenant vers IN4
echo_info "Transferring archive from local to IN4..."
scp -i ${HOST_KEY} -P ${HOST_PORT} ${ARCHIVE_PATH} ${HOST_USER}@${DEST_HOST}:/tmp/${ARCHIVE_NAME} || echo_error "Failed to copy archive to IN4"
# Nettoyer sur le serveur source IN3
ssh -i ${HOST_KEY} -p ${HOST_PORT} ${HOST_USER}@${SOURCE_HOST} "rm -f /tmp/${ARCHIVE_NAME}" || echo_warning "Could not clean source server"
fi
# Déployer sur le container de destination
echo_info "Extracting on destination container..."
# Déterminer le nom de l'environnement pour le marqueur
case $TARGET_ENV in
"dev") ENV_MARKER="development" ;;
"rca") ENV_MARKER="recette" ;;
"pra") ENV_MARKER="production" ;;
esac
ssh -i ${HOST_KEY} -p ${HOST_PORT} ${HOST_USER}@${DEST_HOST} "
# Étape 3: Exécuter les commandes sur le serveur de saut pour déployer dans le container Incus
echo_step "Deploying to Incus container..."
$SSH_JUMP_CMD "
set -euo pipefail
# Pousser l'archive dans le container
incus project switch ${INCUS_PROJECT} &&
incus file push /tmp/${ARCHIVE_NAME} ${DEST_CONTAINER}/tmp/${ARCHIVE_NAME} &&
echo '✅ Passage au projet Incus...'
incus project switch ${INCUS_PROJECT} || exit 1
# Nettoyer sélectivement (préserver logs, uploads et sessions)
incus exec ${DEST_CONTAINER} -- find ${API_PATH} -mindepth 1 -maxdepth 1 ! -name 'uploads' ! -name 'logs' ! -name 'sessions' -exec rm -rf {} \; 2>/dev/null || true &&
echo '📦 Poussée de archive dans le conteneur...'
incus file push /tmp/${ARCHIVE_NAME} ${INCUS_CONTAINER}/tmp/${ARCHIVE_NAME} || exit 1
# Extraire l'archive
incus exec ${DEST_CONTAINER} -- tar -xzf /tmp/${ARCHIVE_NAME} -C ${API_PATH}/ &&
echo '📁 Préparation du dossier final...'
incus exec ${INCUS_CONTAINER} -- mkdir -p ${FINAL_PATH} || exit 1
incus exec ${INCUS_CONTAINER} -- rm -rf ${FINAL_PATH}/* || exit 1
incus exec ${INCUS_CONTAINER} -- tar -xzf /tmp/${ARCHIVE_NAME} -C ${FINAL_PATH}/ || exit 1
# Créer le marqueur d'environnement pour la détection CLI
incus exec ${DEST_CONTAINER} -- bash -c 'echo \"${ENV_MARKER}\" > ${API_PATH}/.env_marker' &&
echo '🔧 Réglage des permissions...'
incus exec ${INCUS_CONTAINER} -- mkdir -p ${FINAL_PATH}/logs || exit 1
incus exec ${INCUS_CONTAINER} -- chown -R ${FINAL_OWNER}:${FINAL_GROUP} ${FINAL_PATH} || exit 1
incus exec ${INCUS_CONTAINER} -- find ${FINAL_PATH} -type d -exec chmod 755 {} \; || exit 1
incus exec ${INCUS_CONTAINER} -- find ${FINAL_PATH} -type f -exec chmod 644 {} \; || exit 1
# Permissions
incus exec ${DEST_CONTAINER} -- chown -R ${FINAL_OWNER}:${FINAL_GROUP} ${API_PATH} &&
incus exec ${DEST_CONTAINER} -- find ${API_PATH} -type d -exec chmod 755 {} \; &&
incus exec ${DEST_CONTAINER} -- find ${API_PATH} -type f -exec chmod 644 {} \; &&
# Permissions spéciales pour le dossier logs (pour permettre à PHP-FPM de l'utilisateur nobody d'y écrire)
incus exec ${INCUS_CONTAINER} -- chown -R ${FINAL_OWNER}:${FINAL_OWNER_LOGS} ${FINAL_PATH}/logs || exit 1
incus exec ${INCUS_CONTAINER} -- chmod -R 775 ${FINAL_PATH}/logs || exit 1
incus exec ${INCUS_CONTAINER} -- find ${FINAL_PATH}/logs -type f -exec chmod 664 {} \; || exit 1
# Permissions spéciales pour logs
incus exec ${DEST_CONTAINER} -- mkdir -p ${API_PATH}/logs/events &&
incus exec ${DEST_CONTAINER} -- chown -R ${FINAL_OWNER_LOGS}:${FINAL_GROUP} ${API_PATH}/logs &&
incus exec ${DEST_CONTAINER} -- find ${API_PATH}/logs -type d -exec chmod 750 {} \; &&
incus exec ${DEST_CONTAINER} -- find ${API_PATH}/logs -type f -exec chmod 640 {} \; &&
echo '📁 Création des dossiers uploads...'
incus exec ${INCUS_CONTAINER} -- mkdir -p ${FINAL_PATH}/uploads || exit 1
incus exec ${INCUS_CONTAINER} -- chown -R ${FINAL_OWNER}:${FINAL_OWNER_LOGS} ${FINAL_PATH}/uploads || exit 1
incus exec ${INCUS_CONTAINER} -- chmod -R 775 ${FINAL_PATH}/uploads || exit 1
incus exec ${INCUS_CONTAINER} -- find ${FINAL_PATH}/uploads -type f -exec chmod -R 664 {} \; || exit 1
# Permissions spéciales pour uploads
incus exec ${DEST_CONTAINER} -- mkdir -p ${API_PATH}/uploads &&
incus exec ${DEST_CONTAINER} -- chown -R ${FINAL_OWNER_LOGS}:${FINAL_GROUP} ${API_PATH}/uploads &&
incus exec ${DEST_CONTAINER} -- find ${API_PATH}/uploads -type d -exec chmod 750 {} \; &&
incus exec ${DEST_CONTAINER} -- find ${API_PATH}/uploads -type f -exec chmod 640 {} \; &&
echo '🧹 Nettoyage...'
incus exec ${INCUS_CONTAINER} -- rm -f /tmp/${ARCHIVE_NAME} || exit 1
rm -f /tmp/${ARCHIVE_NAME} || exit 1
"
# Permissions spéciales pour sessions
incus exec ${DEST_CONTAINER} -- mkdir -p ${API_PATH}/sessions &&
incus exec ${DEST_CONTAINER} -- chown -R ${FINAL_OWNER_LOGS}:${FINAL_GROUP} ${API_PATH}/sessions &&
incus exec ${DEST_CONTAINER} -- chmod 700 ${API_PATH}/sessions &&
# Nettoyage local
rm -f "${TEMP_ARCHIVE}"
# Composer (installation stricte - échec bloquant)
incus exec ${DEST_CONTAINER} -- bash -c 'cd ${API_PATH} && composer install --no-dev --optimize-autoloader' || { echo 'ERROR: Composer install failed'; exit 1; } &&
# Nettoyage
incus exec ${DEST_CONTAINER} -- rm -f /tmp/${ARCHIVE_NAME} &&
rm -f /tmp/${ARCHIVE_NAME}
" || echo_error "Deployment failed on destination"
echo_info "Remote backup saved: ${REMOTE_BACKUP_DIR} on ${DEST_CONTAINER}"
# Nettoyage des anciens backups sur le container distant
echo_info "Cleaning old backup directories on ${DEST_CONTAINER}..."
ssh -i ${HOST_KEY} -p ${HOST_PORT} ${HOST_USER}@${DEST_HOST} "
incus exec ${DEST_CONTAINER} -- bash -c 'rm -rf ${API_PATH}_backup_*'
" && echo_info "Old backups cleaned" || echo_warning "Could not clean old backups"
# =====================================
# Configuration des tâches CRON
# =====================================
echo_step "Configuring CRON tasks..."
ssh -i ${HOST_KEY} -p ${HOST_PORT} ${HOST_USER}@${DEST_HOST} "
incus exec ${DEST_CONTAINER} -- bash <<'EOFCRON'
# Sauvegarder les crons existants (hors geosector)
crontab -l 2>/dev/null | grep -v 'geosector/api/scripts/cron' > /tmp/crontab_backup || true
# Créer le nouveau crontab avec les tâches CRON pour l'API
cat /tmp/crontab_backup > /tmp/new_crontab
cat >> /tmp/new_crontab <<'EOF'
# GEOSECTOR API - Email queue processing (every 5 minutes)
*/5 * * * * /usr/bin/php /var/www/geosector/api/scripts/cron/process_email_queue.php >> /var/www/geosector/api/logs/email_queue.log 2>&1
# GEOSECTOR API - Security data cleanup (daily at 2am)
0 2 * * * /usr/bin/php /var/www/geosector/api/scripts/cron/cleanup_security_data.php >> /var/www/geosector/api/logs/cleanup_security.log 2>&1
# GEOSECTOR API - Stripe devices update (weekly Sunday at 3am)
0 3 * * 0 /usr/bin/php /var/www/geosector/api/scripts/cron/update_stripe_devices.php >> /var/www/geosector/api/logs/stripe_devices.log 2>&1
EOF
# Installer le nouveau crontab
crontab /tmp/new_crontab
# Nettoyer
rm -f /tmp/crontab_backup /tmp/new_crontab
# Afficher les crons installés
echo 'CRON tasks installed:'
crontab -l | grep geosector
EOFCRON
" && echo_info "CRON tasks configured successfully" || echo_warning "CRON configuration failed"
fi
# L'archive reste dans le dossier de backup, pas de nettoyage nécessaire
echo_info "Archive preserved in backup directory: ${ARCHIVE_PATH}"
# =====================================
# Résumé final
# =====================================
echo_step "Deployment completed successfully!"
echo_info "Environment: ${ENV_NAME}"
if [ "$TARGET_ENV" = "dev" ]; then
echo_info "Deployed from local code to container ${DEST_CONTAINER} on IN3 (${DEST_HOST})"
elif [ "$TARGET_ENV" = "rca" ]; then
echo_info "Delivered from ${SOURCE_CONTAINER} to ${DEST_CONTAINER} on ${DEST_HOST}"
elif [ "$TARGET_ENV" = "pra" ]; then
echo_info "Delivered from ${SOURCE_CONTAINER} on ${SOURCE_HOST} to ${DEST_CONTAINER} on ${DEST_HOST}"
fi
echo_step "Deployment completed successfully."
echo_info "Your API has been updated on the container."
echo_info "Deployment completed at: $(date)"
# Journaliser le déploiement
echo "$(date '+%Y-%m-%d %H:%M:%S') - API deployed to ${ENV_NAME} (${DEST_CONTAINER}) - Archive: ${ARCHIVE_NAME}" >> ~/.geo_deploy_history
echo "$(date '+%Y-%m-%d %H:%M:%S') - API deployed to ${JUMP_HOST}:${INCUS_CONTAINER}" >> ~/.geo_deploy_history

View File

@@ -1,334 +0,0 @@
# API Security & Performance Monitoring
## 📋 Vue d'ensemble
Système complet de sécurité et monitoring pour l'API GeoSector implémenté et opérationnel.
### ✅ Fonctionnalités implémentées
- **Détection d'intrusions** : Brute force, SQL injection, patterns de scan
- **Monitoring des performances** : Temps de réponse, utilisation mémoire, requêtes DB
- **Alertes email intelligentes** : Throttling, niveaux de priorité
- **Blocage d'IP automatique** : Temporaire ou permanent
- **Traçabilité complète** : Historique pour audit et analyse
## 🏗️ Architecture
### Tables de base de données (préfixe `sec_`)
```sql
-- 4 tables créées dans scripts/sql/create_security_tables.sql
sec_alerts -- Alertes de sécurité
sec_performance_metrics -- Métriques de performance
sec_failed_login_attempts -- Tentatives de connexion échouées
sec_blocked_ips -- IPs bloquées
```
### Services PHP implémentés
```
src/Services/Security/
├── AlertService.php # Gestion centralisée des alertes
├── EmailThrottler.php # Anti-spam pour emails
├── SecurityMonitor.php # Détection des menaces
├── PerformanceMonitor.php # Monitoring des temps
└── IPBlocker.php # Gestion des blocages IP
```
### Contrôleur d'administration
```
src/Controllers/SecurityController.php # Interface d'administration
```
## 🚀 Installation
### 1. Créer les tables
```bash
# Exécuter le script SQL sur chaque environnement
mysql -u root -p geo_app < scripts/sql/create_security_tables.sql
```
### 2. Configurer le cron de purge
```bash
# Ajouter dans crontab (crontab -e)
0 2 * * * /usr/bin/php /var/www/geosector/api/scripts/cron/cleanup_security_data.php >> /var/log/security_cleanup.log 2>&1
```
### 3. Tester l'installation
```bash
php test_security.php
```
## 🔒 Fonctionnement
### Détection automatique
Le système détecte et bloque automatiquement :
- **Brute force** : 5 tentatives échouées en 5 minutes → IP bloquée 1h
- **SQL injection** : Patterns suspects → IP bloquée définitivement
- **Scan de vulnérabilités** : Accès aux fichiers sensibles → IP bloquée 1h
- **Rate limiting** : Plus de 60 requêtes/minute → Rejet temporaire
### Monitoring de performance
Chaque requête est automatiquement monitorée :
```php
// Dans index.php
PerformanceMonitor::startRequest();
// ... traitement ...
PerformanceMonitor::endRequest($endpoint, $method, $statusCode);
```
### Alertes email
Configuration des niveaux :
- **INFO** : Log uniquement
- **WARNING** : Email avec throttling 1h
- **ERROR** : Email avec throttling 15min
- **CRITICAL** : Email avec throttling 5min
- **SECURITY** : Email immédiat, priorité haute
## 📊 Endpoints d'administration
Tous les endpoints nécessitent une authentification admin (role >= 2) :
```
GET /api/admin/metrics # Métriques de performance
GET /api/admin/alerts # Alertes actives
POST /api/admin/alerts/:id/resolve # Résoudre une alerte
GET /api/admin/blocked-ips # IPs bloquées
POST /api/admin/unblock-ip # Débloquer une IP
POST /api/admin/block-ip # Bloquer une IP manuellement
GET /api/admin/security-report # Rapport complet
POST /api/admin/cleanup # Nettoyer les anciennes données
POST /api/admin/test-alert # Tester les alertes
```
## 🔧 Configuration
### Seuils par défaut (modifiables dans les services)
```php
// PerformanceMonitor.php
const DEFAULT_THRESHOLDS = [
'response_time_warning' => 1000, // 1 seconde
'response_time_critical' => 3000, // 3 secondes
'db_time_warning' => 500, // 500ms
'db_time_critical' => 1000, // 1 seconde
'memory_warning' => 64, // 64 MB
'memory_critical' => 128 // 128 MB
];
// SecurityMonitor.php
- Brute force : 5 tentatives en 5 minutes
- Rate limit : 60 requêtes par minute
- 404 pattern : 10 erreurs 404 en 10 minutes
// EmailThrottler.php
const DEFAULT_CONFIG = [
'max_per_hour' => 10,
'max_per_day' => 50,
'digest_after' => 5,
'cooldown_minutes' => 60
];
```
### Rétention des données
Configurée dans `scripts/cron/cleanup_security_data.php` :
```php
$RETENTION_DAYS = [
'performance_metrics' => 30, // 30 jours
'failed_login_attempts' => 7, // 7 jours
'resolved_alerts' => 90, // 90 jours
'expired_blocks' => 0 // Déblocage immédiat
];
```
## 📈 Métriques surveillées
### Performance
- Temps de réponse total
- Temps cumulé des requêtes DB
- Nombre de requêtes DB
- Utilisation mémoire (pic et moyenne)
- Codes HTTP de réponse
### Sécurité
- Tentatives de connexion échouées
- IPs bloquées (temporaires/permanentes)
- Patterns d'attaque détectés
- Alertes par type et niveau
## 🛡️ Patterns de détection
### SQL Injection
```php
// Patterns détectés dans SecurityMonitor.php
- UNION SELECT
- DROP TABLE
- INSERT INTO
- UPDATE SET
- DELETE FROM
- Script tags
- OR 1=1
- Commentaires SQL (--)
```
### Fichiers sensibles
```php
// Patterns de scan détectés
- admin, administrator
- wp-admin, phpmyadmin
- .git, .env
- config.php
- backup, .sql, .zip
- shell.php, eval.php
```
## 📝 Exemples d'utilisation
### Déclencher une alerte manuelle
```php
use App\Services\Security\AlertService;
AlertService::trigger('CUSTOM_ALERT', [
'message' => 'Événement important détecté',
'details' => ['user' => $userId, 'action' => $action]
], 'WARNING');
```
### Bloquer une IP manuellement
```php
use App\Services\Security\IPBlocker;
// Blocage temporaire (1 heure)
IPBlocker::block('192.168.1.100', 3600, 'Comportement suspect');
// Blocage permanent
IPBlocker::blockPermanent('192.168.1.100', 'Attaque confirmée');
```
### Obtenir les statistiques
```php
use App\Services\Security\SecurityMonitor;
use App\Services\Security\PerformanceMonitor;
$securityStats = SecurityMonitor::getSecurityStats();
$perfStats = PerformanceMonitor::getStats(null, 24); // 24h
```
## ⚠️ Points d'attention
### RGPD
- Les IPs sont des données personnelles
- Durée de conservation limitée (voir rétention)
- Anonymisation après traitement
### Performance
- Overhead < 5ms par requête
- Optimisation des tables avec index
- Purge automatique des anciennes données
### Sécurité
- Pas d'exposition de données sensibles dans les alertes
- Chiffrement des données utilisateur
- Whitelist pour IPs de confiance (localhost)
## 🔄 Maintenance
### Quotidienne (cron)
```bash
# Purge automatique à 2h du matin
0 2 * * * php /var/www/geosector/api/scripts/cron/cleanup_security_data.php
```
### Hebdomadaire
- Vérifier les alertes actives
- Analyser les tendances de performance
- Ajuster les seuils si nécessaire
### Mensuelle
- Analyser le rapport de sécurité
- Mettre à jour les IPs whitelist/blacklist
- Optimiser les tables si nécessaire
## 🐛 Dépannage
### Les tables n'existent pas
```bash
# Créer les tables
mysql -u root -p geo_app < scripts/sql/create_security_tables.sql
```
### Pas d'alertes email
- Vérifier la configuration email dans `AppConfig`
- Vérifier les logs : `tail -f logs/geosector-*.log`
- Tester avec : `POST /api/admin/test-alert`
### IP bloquée par erreur
```bash
# Via API
curl -X POST https://dapp.geosector.fr/api/admin/unblock-ip \
-H "Authorization: Bearer TOKEN" \
-d '{"ip": "192.168.1.100"}'
# Via MySQL
UPDATE sec_blocked_ips SET unblocked_at = NOW() WHERE ip_address = '192.168.1.100';
```
## 📚 Ressources
- [OWASP Top 10](https://owasp.org/www-project-top-ten/)
- [PHP Security Best Practices](https://www.php.net/manual/en/security.php)
- Code source : `/src/Services/Security/`
- Tests : `test_security.php`
- Logs : `/logs/geosector-*.log`
## 🎯 Statut d'implémentation
**Phase 1** : Infrastructure de base - COMPLÉTÉ
- Tables créées avec préfixe `sec_`
- Services PHP implémentés
- Intégration dans index.php et Database.php
**Phase 2** : Monitoring de Performance - COMPLÉTÉ
- Chronométrage automatique des requêtes
- Monitoring des requêtes DB
- Alertes sur dégradation
**Phase 3** : Détection d'intrusions - COMPLÉTÉ
- Détection brute force
- Détection SQL injection
- Blocage IP automatique
**Phase 4** : Alertes Email - COMPLÉTÉ
- Service d'alertes avec throttling
- Templates d'emails
- Niveaux de priorité
**Phase 5** : Administration - COMPLÉTÉ
- Endpoints d'administration
- Interface de gestion
- Rapports de sécurité
**Phase 6** : Maintenance - COMPLÉTÉ
- Script de purge automatique
- Optimisation des tables
- Documentation complète
---
*Dernière mise à jour : 2025-01-17*
*Version : 1.0.0*

View File

@@ -1,419 +0,0 @@
# Module Chat - Documentation API
## Vue d'ensemble
Le module Chat permet aux utilisateurs de l'application GeoSector de communiquer entre eux via une messagerie intégrée. Il supporte les conversations privées, de groupe et les diffusions (broadcast).
## Architecture
### Tables de base de données
- `chat_rooms` : Salles de conversation
- `chat_messages` : Messages échangés
- `chat_participants` : Participants aux conversations
- `chat_read_receipts` : Accusés de lecture
### Permissions par rôle
| Rôle | Permissions |
|------|------------|
| **1 - Utilisateur** | Conversations privées et groupes avec membres de son entité |
| **2 - Admin entité** | Toutes conversations de son entité + création de diffusions |
| **> 2 - Super admin** | Accès total à toutes les conversations |
## Flux d'utilisation du module Chat
### 📱 Vue d'ensemble du flux
Le module Chat fonctionne en mode **chargement dynamique** : les données sont récupérées à la demande, pas toutes en une fois au login.
### 1. Au login (`/api/login`)
La réponse du login contient un objet `chat` avec les informations de base :
```json
{
"status": "success",
"user": {...},
"amicale": {...},
"chat": {
"total_rooms": 5, // Nombre total de conversations
"unread_messages": 12, // Total messages non lus
"chat_enabled": true, // Module activé pour cet utilisateur
"last_active_room": { // Dernière conversation active
"id": "uuid-room-123",
"title": "Discussion équipe",
"type": "group",
"last_message": "À demain !",
"last_message_at": "2025-01-17 18:30:00"
}
}
}
```
→ Permet d'afficher un **badge de notification** et de savoir si le chat est disponible
### 2. Ouverture de la page Chat
#### Étape 1 : Chargement initial
```
GET /api/chat/rooms
```
→ Récupère la liste des conversations avec aperçu du dernier message
#### Étape 2 : Sélection d'une conversation
```
GET /api/chat/rooms/{room_id}/messages?limit=50
```
→ Charge les 50 derniers messages (pagination disponible)
#### Étape 3 : Marquage comme lu
```
POST /api/chat/rooms/{room_id}/read
```
→ Met à jour les compteurs de messages non lus
### 3. Actions utilisateur
| Action | Endpoint | Description |
|--------|----------|-------------|
| **Envoyer un message** | `POST /api/chat/rooms/{id}/messages` | Envoie et retourne le message créé |
| **Créer une conversation** | `POST /api/chat/rooms` | Crée une nouvelle room |
| **Obtenir les destinataires** | `GET /api/chat/recipients` | Liste des contacts disponibles |
| **Charger plus de messages** | `GET /api/chat/rooms/{id}/messages?before={msg_id}` | Pagination |
### 4. Stratégies de rafraîchissement
#### Polling (recommandé pour débuter)
- Rafraîchir `/api/chat/rooms` toutes les 30 secondes
- Rafraîchir les messages de la conversation active toutes les 10 secondes
#### Pull to refresh
- Permettre à l'utilisateur de rafraîchir manuellement
#### Lifecycle events
- Recharger quand l'app revient au premier plan
- Rafraîchir après envoi d'un message
### 5. Exemple d'implémentation Flutter
```dart
class ChatService {
Timer? _roomsTimer;
Timer? _messagesTimer;
// 1. Au login, stocker les infos de base
void initFromLogin(Map<String, dynamic> chatData) {
_unreadCount = chatData['unread_messages'];
_chatEnabled = chatData['chat_enabled'];
notifyListeners();
}
// 2. À l'ouverture du chat
Future<void> openChatPage() async {
// Charger les conversations
final rooms = await api.get('/api/chat/rooms');
_rooms = rooms['rooms'];
// Démarrer le polling
_startPolling();
}
// 3. Sélection d'une conversation
Future<void> selectRoom(String roomId) async {
// Charger les messages
final response = await api.get('/api/chat/rooms/$roomId/messages');
_currentMessages = response['messages'];
// Marquer comme lu
await api.post('/api/chat/rooms/$roomId/read');
// Rafraîchir plus fréquemment cette conversation
_startMessagePolling(roomId);
}
// 4. Polling automatique
void _startPolling() {
_roomsTimer = Timer.periodic(Duration(seconds: 30), (_) {
_refreshRooms();
});
}
// 5. Nettoyage
void dispose() {
_roomsTimer?.cancel();
_messagesTimer?.cancel();
}
}
```
## Endpoints API
### 1. GET /api/chat/rooms
**Description** : Récupère la liste des conversations de l'utilisateur
**Réponse** :
```json
{
"status": "success",
"rooms": [
{
"id": "uuid-room-1",
"title": "Discussion équipe",
"type": "group",
"created_at": "2025-01-17 10:00:00",
"created_by": 123,
"updated_at": "2025-01-17 14:30:00",
"last_message": "Bonjour tout le monde",
"last_message_at": "2025-01-17 14:30:00",
"unread_count": 3,
"participant_count": 5,
"participants": [
{
"user_id": 123,
"name": "Jean Dupont",
"first_name": "Jean",
"is_admin": true
}
]
}
]
}
```
### 2. POST /api/chat/rooms
**Description** : Crée une nouvelle conversation
**Body** :
```json
{
"type": "private|group|broadcast",
"title": "Titre optionnel (requis pour group/broadcast)",
"participants": [456, 789], // IDs des participants
"initial_message": "Message initial optionnel"
}
```
**Règles** :
- `private` : Maximum 2 participants (incluant le créateur)
- `group` : Plusieurs participants possibles
- `broadcast` : Réservé aux admins (rôle >= 2)
**Réponse** :
```json
{
"status": "success",
"room": {
"id": "uuid-new-room",
"title": "Nouvelle conversation",
"type": "group",
"created_at": "2025-01-17 15:00:00",
"participants": [...]
},
"existing": false // true si conversation privée existante trouvée
}
```
### 3. GET /api/chat/rooms/{id}/messages
**Description** : Récupère les messages d'une conversation
**Paramètres** :
- `limit` : Nombre de messages (défaut: 50, max: 100)
- `before` : ID du message pour pagination
**Réponse** :
```json
{
"status": "success",
"messages": [
{
"id": "uuid-message-1",
"content": "Bonjour !",
"sender_id": 123,
"sender_name": "Jean Dupont",
"sender_first_name": "Jean",
"sent_at": "2025-01-17 14:00:00",
"edited_at": null,
"is_deleted": false,
"is_read": true,
"is_mine": false,
"read_count": 3
}
],
"has_more": true
}
```
### 4. POST /api/chat/rooms/{id}/messages
**Description** : Envoie un message dans une conversation
**Body** :
```json
{
"content": "Contenu du message (max 5000 caractères)"
}
```
**Réponse** :
```json
{
"status": "success",
"message": {
"id": "uuid-new-message",
"content": "Message envoyé",
"sender_id": 123,
"sender_name": "Jean Dupont",
"sent_at": "2025-01-17 15:30:00",
"is_mine": true,
"is_read": false,
"read_count": 0
}
}
```
### 5. POST /api/chat/rooms/{id}/read
**Description** : Marque les messages comme lus
**Body (optionnel)** :
```json
{
"message_ids": ["uuid-1", "uuid-2"] // Si omis, marque tous les messages
}
```
**Réponse** :
```json
{
"status": "success",
"unread_count": 0 // Nombre de messages non lus restants
}
```
### 6. GET /api/chat/recipients
**Description** : Liste des destinataires possibles pour créer une conversation
**Réponse** :
```json
{
"status": "success",
"recipients": [
{
"id": 456,
"name": "Marie Martin",
"first_name": "Marie",
"role": 1,
"entite_id": 5
}
],
"recipients_by_entity": {
"Amicale de Grenoble": [
{...}
],
"Amicale de Lyon": [
{...}
]
}
}
```
## Fonctionnalités clés
### 1. Types de conversations
#### Private (Conversation privée)
- Entre 2 utilisateurs uniquement
- Détection automatique de conversation existante
- Pas de titre requis
#### Group (Groupe)
- Plusieurs participants
- Titre optionnel mais recommandé
- Admin de groupe (créateur)
#### Broadcast (Diffusion)
- Réservé aux admins (rôle >= 2)
- Communication unidirectionnelle possible
- Pour annonces importantes
### 2. Gestion des permissions
Le système vérifie automatiquement :
- L'appartenance à une conversation avant lecture/écriture
- Les droits de création selon le type de conversation
- La visibilité des destinataires selon le rôle
### 3. Statuts de lecture
- **Accusés de lecture individuels** : Chaque message peut être marqué comme lu
- **Compteur de non-lus** : Par conversation et global
- **Last read** : Timestamp de dernière lecture par participant
### 4. Optimisations
- **Pagination** : Chargement progressif des messages
- **Index optimisés** : Pour les requêtes fréquentes
- **Vue SQL** : Pour récupération rapide du dernier message
## Sécurité
### Chiffrement
- Les noms d'utilisateurs sont stockés chiffrés (AES-256)
- Déchiffrement à la volée lors de la lecture
### Validation
- Longueur maximale des messages : 5000 caractères
- Trim automatique du contenu
- Vérification des permissions à chaque action
### Isolation
- Les utilisateurs ne voient que leurs conversations autorisées
- Filtrage par entité selon le rôle
- Soft delete pour conservation de l'historique
## Migration
Exécuter le script SQL :
```bash
mysql -u root -p geo_app < scripts/sql/create_chat_tables.sql
```
## Évolutions futures possibles
1. **Notifications push** : Intégration avec Firebase/WebSocket
2. **Fichiers joints** : Support d'images et documents
3. **Réactions** : Emojis sur les messages
4. **Mentions** : @username pour notifier
5. **Recherche** : Dans l'historique des messages
6. **Chiffrement E2E** : Pour conversations sensibles
7. **Statuts de présence** : En ligne/Hors ligne
8. **Indicateur de frappe** : "X est en train d'écrire..."
## Tests
### Cas de test recommandés
1. **Création de conversation privée**
- Vérifier la détection de conversation existante
- Tester avec utilisateurs de différentes entités
2. **Envoi de messages**
- Messages avec caractères UTF-8 (émojis, accents)
- Messages très longs (limite 5000)
- Messages vides (doivent être rejetés)
3. **Marquage comme lu**
- Marquer messages spécifiques
- Marquer tous les messages d'une room
- Vérifier les compteurs
4. **Permissions**
- Utilisateur simple ne peut pas créer de broadcast
- Accès refusé aux conversations non autorisées
- Filtrage correct des destinataires
## Support
Pour toute question ou problème :
- Vérifier les logs dans `/logs/`
- Consulter les tables `chat_*` en base de données
- Tester avec les scripts de test fournis

View File

@@ -1,138 +0,0 @@
# Gestion du champ chk_user_delete_pass
## 📋 Description
Le champ `chk_user_delete_pass` permet de contrôler si les membres d'une amicale peuvent supprimer des passages.
## 🔄 Modifications API
### 1. Base de données
- **Table** : `entites`
- **Champ** : `chk_user_delete_pass` TINYINT(1) DEFAULT 0
- **Valeurs** :
- `0` : Les membres NE peuvent PAS supprimer de passages (par défaut)
- `1` : Les membres PEUVENT supprimer des passages
### 2. Endpoints modifiés
#### POST /api/entites (Création)
- Le champ est automatiquement initialisé à `0` (false) lors de la création
- Non modifiable à la création
#### PUT /api/entites/{id} (Modification)
**Entrée JSON :**
```json
{
"chk_user_delete_pass": 1
}
```
- **Type** : Boolean (0 ou 1)
- **Obligatoire** : Non
- **Accès** : Administrateurs uniquement (fk_role > 1)
#### GET /api/entites/{id} (Récupération)
**Sortie JSON :**
```json
{
"id": 5,
"name": "Amicale de Pompiers",
"code_postal": "75001",
"ville": "Paris",
"chk_active": 1,
"chk_user_delete_pass": 0
}
```
#### GET /api/entites (Liste)
Retourne `chk_user_delete_pass` pour chaque entité dans la liste.
### 3. Route /api/login
Le champ `chk_user_delete_pass` est maintenant inclus dans la réponse de login dans les objets `amicale` :
**Réponse JSON :**
```json
{
"user": { ... },
"amicale": {
"id": 5,
"name": "Amicale de Pompiers",
"code_postal": "75001",
"ville": "Paris",
"chk_demo": 0,
"chk_mdp_manuel": 0,
"chk_username_manuel": 0,
"chk_copie_mail_recu": 0,
"chk_accept_sms": 0,
"chk_active": 1,
"chk_stripe": 0,
"chk_user_delete_pass": 0 // ← NOUVEAU CHAMP
}
}
```
## 🎯 Utilisation côté client
### Flutter/Web
Le client doit :
1. **Récupérer** la valeur de `chk_user_delete_pass` depuis la réponse login
2. **Stocker** cette valeur dans l'état de l'application
3. **Conditionner** l'affichage du bouton de suppression selon cette valeur
**Exemple Flutter :**
```dart
// Dans le modèle Amicale
class Amicale {
final int id;
final String name;
final bool chkUserDeletePass; // Nouveau champ
bool get canUserDeletePassage => chkUserDeletePass;
}
// Dans l'UI
if (amicale.canUserDeletePassage) {
// Afficher le bouton de suppression
IconButton(
icon: Icon(Icons.delete),
onPressed: () => deletePassage(passageId),
)
}
```
## ⚠️ Points importants
1. **Valeur par défaut** : Toujours `0` (false) pour la sécurité
2. **Modification** : Seuls les administrateurs (fk_role > 1) peuvent modifier ce champ
3. **Rétrocompatibilité** : Les entités existantes ont la valeur `0` par défaut
4. **Validation côté serveur** : L'API vérifiera également ce droit lors de la tentative de suppression
## 📝 Script SQL
Le script de migration est disponible dans :
```
/scripts/sql/add_chk_user_delete_pass.sql
```
## ✅ Checklist d'implémentation
### Côté API (déjà fait) :
- [x] Ajout du champ en base de données
- [x] Modification EntiteController (create, update, get)
- [x] Modification LoginController (réponse login)
- [x] Script SQL de migration
### Côté Client (à faire) :
- [ ] Ajouter le champ dans le modèle Amicale
- [ ] Parser le champ depuis la réponse login
- [ ] Stocker dans l'état de l'application
- [ ] Conditionner l'affichage du bouton suppression
- [ ] Tester avec des valeurs 0 et 1
## 🔒 Sécurité
Même si `chk_user_delete_pass = 1`, l'API devra vérifier :
- L'authentification de l'utilisateur
- L'appartenance à l'entité
- Le droit de suppression sur le passage spécifique
- Les règles métier (ex: pas de suppression après export)
---
**Date :** 20/08/2025
**Version API :** 3.1.4

View File

@@ -1,165 +0,0 @@
# API DELETE /passages/{id} - Documentation des permissions
## 📋 Endpoint
```
DELETE /api/passages/{id}
```
## 🔒 Authentification
- **Requise** : OUI (Bearer token)
- **Session** : Doit être valide
## 📊 Logique de permissions
### Règles par rôle :
| fk_role | Description | Peut supprimer ? | Conditions |
|---------|------------|------------------|------------|
| 1 | Membre | ✅ Conditionnel | Si `entites.chk_user_delete_pass = 1` |
| 2 | Admin amicale | ✅ OUI | Toujours autorisé |
| 3+ | Super admin | ✅ OUI | Toujours autorisé |
### Détail du contrôle pour les membres (fk_role = 1) :
```sql
-- L'API vérifie :
SELECT chk_user_delete_pass
FROM entites
WHERE id = {user.fk_entite}
-- Si chk_user_delete_pass = 0 → Erreur 403
-- Si chk_user_delete_pass = 1 → Continue
```
## 🔄 Flux de vérification
```mermaid
graph TD
A[DELETE /passages/{id}] --> B{Utilisateur authentifié ?}
B -->|Non| C[Erreur 401]
B -->|Oui| D{Récupérer fk_role}
D --> E{fk_role = 1 ?}
E -->|Non| F[Autorisé - Admin]
E -->|Oui| G{Vérifier chk_user_delete_pass}
G -->|= 0| H[Erreur 403 - Non autorisé]
G -->|= 1| F
F --> I{Passage existe ?}
I -->|Non| J[Erreur 404]
I -->|Oui| K{Passage appartient à l'entité ?}
K -->|Non| L[Erreur 404]
K -->|Oui| M[Soft delete : chk_active = 0]
M --> N[Succès 200]
```
## 📝 Réponses
### ✅ Succès (200)
```json
{
"status": "success",
"message": "Passage supprimé avec succès"
}
```
### ❌ Erreur 401 - Non authentifié
```json
{
"status": "error",
"message": "Vous devez être connecté pour effectuer cette action"
}
```
### ❌ Erreur 403 - Permission refusée (membre sans autorisation)
```json
{
"status": "error",
"message": "Vous n'avez pas l'autorisation de supprimer des passages"
}
```
### ❌ Erreur 404 - Passage non trouvé
```json
{
"status": "error",
"message": "Passage non trouvé"
}
```
## 📊 Logging
L'API enregistre :
### En cas de tentative non autorisée :
```php
LogService::log('Tentative de suppression de passage non autorisée', [
'level' => 'warning',
'userId' => $userId,
'userRole' => $userRole,
'entiteId' => $entiteId,
'passageId' => $passageId,
'chk_user_delete_pass' => 0
]);
```
### En cas de succès :
```php
LogService::log('Suppression d\'un passage', [
'level' => 'info',
'userId' => $userId,
'passageId' => $passageId
]);
```
## 🎯 Exemple d'utilisation
### Requête
```bash
curl -X DELETE https://api.geosector.fr/api/passages/19500576 \
-H "Authorization: Bearer {session_token}" \
-H "Content-Type: application/json"
```
### Scénarios
#### Scénario 1 : Membre avec permission ✅
- Utilisateur : fk_role = 1
- Entité : chk_user_delete_pass = 1
- **Résultat** : Suppression autorisée
#### Scénario 2 : Membre sans permission ❌
- Utilisateur : fk_role = 1
- Entité : chk_user_delete_pass = 0
- **Résultat** : Erreur 403
#### Scénario 3 : Admin amicale ✅
- Utilisateur : fk_role = 2
- **Résultat** : Suppression autorisée (pas de vérification chk_user_delete_pass)
## ⚠️ Notes importantes
1. **Soft delete** : Le passage n'est pas supprimé physiquement, seulement `chk_active = 0`
2. **Traçabilité** : `updated_at` et `fk_user_modif` sont mis à jour
3. **Contrôle entité** : Un utilisateur ne peut supprimer que les passages de son entité
4. **Log warning** : Toute tentative non autorisée est loggée en niveau WARNING
## 🔧 Configuration côté amicale
Pour autoriser les membres à supprimer des passages :
```sql
UPDATE entites
SET chk_user_delete_pass = 1
WHERE id = {entite_id};
```
Cette modification ne peut être faite que par un administrateur (fk_role > 1) via l'endpoint :
```
PUT /api/entites/{id}
{
"chk_user_delete_pass": 1
}
```
---
**Version API** : 3.1.4
**Date** : 20/08/2025

View File

@@ -1,495 +0,0 @@
# Système de logs d'événements JSONL
## 📋 Vue d'ensemble
Système de traçabilité des événements métier pour statistiques et audit, stocké en fichiers JSONL (JSON Lines) sans impact sur la base de données principale.
**Créé le :** 26 Octobre 2025
**Rétention :** 15 mois
**Format :** JSONL (une ligne = un événement JSON)
## 🎯 Objectifs
### Événements tracés
**Authentification**
- Connexions réussies (user_id, entity_id, plateforme, IP)
- Tentatives échouées (username, raison, IP, nb tentatives)
**CRUD métier**
- **Passages** : création, modification, suppression
- **Secteurs** : création, modification, suppression
- **Membres** : création, modification, suppression
- **Entités** : création, modification, suppression
### Cas d'usage
**1. Admin entité**
- Stats de son entité : connexions, passages, secteurs sur 1 jour/semaine/mois
- Activité des membres de l'entité
**2. Super-admin**
- Stats globales : tous les passages modifiés sur 2 semaines
- Événements toutes entités sur période donnée
- Détection d'anomalies
## 📁 Architecture de stockage
### Structure des répertoires
```
/logs/events/
├── 2025-10-26.jsonl # Fichier du jour (écriture append)
├── 2025-10-25.jsonl
├── 2025-10-24.jsonl
├── 2025-09-30.jsonl
├── 2025-09-29.jsonl.gz # Compression auto après 30 jours
└── archive/
├── 2025-09.jsonl.gz # Archive mensuelle
├── 2025-08.jsonl.gz
└── 2024-07.jsonl.gz # Supprimé auto après 15 mois
```
### Cycle de vie des fichiers
| Âge | État | Taille estimée | Accès |
|-----|------|----------------|-------|
| 0-30 jours | `.jsonl` non compressé | 1-10 MB/jour | Lecture directe rapide |
| 30 jours-15 mois | `.jsonl.gz` compressé | ~100 KB/jour | Décompression à la volée |
| > 15 mois | Supprimé automatiquement | - | - |
### Rotation et rétention
**CRON mensuel** : `scripts/cron/rotate_event_logs.php`
- **Fréquence** : 1er du mois à 3h00
- **Actions** :
1. Compresser les fichiers `.jsonl` de plus de 30 jours en `.jsonl.gz`
2. Supprimer les fichiers `.jsonl.gz` de plus de 15 mois
3. Logger le résumé de rotation
**Commande manuelle** :
```bash
php scripts/cron/rotate_event_logs.php
```
## 📊 Format des événements
### Structure commune
Tous les événements partagent ces champs :
```json
{
"timestamp": "2025-10-26T14:32:15Z", // ISO 8601 UTC
"event": "nom_evenement", // Type d'événement
"user_id": 123, // ID utilisateur (si authentifié)
"entity_id": 5, // ID entité (si applicable)
"ip": "192.168.1.100", // IP client
"platform": "ios|android|web", // Plateforme
"app_version": "3.3.6" // Version app (mobile uniquement)
}
```
### Événements d'authentification
#### Login réussi
```jsonl
{"timestamp":"2025-10-26T14:32:15Z","event":"login_success","user_id":123,"entity_id":5,"platform":"ios","app_version":"3.3.6","ip":"192.168.1.100","username":"user123"}
```
#### Login échoué
```jsonl
{"timestamp":"2025-10-26T14:35:22Z","event":"login_failed","username":"test","reason":"invalid_password","ip":"192.168.1.101","attempt":3,"platform":"web"}
```
**Raisons possibles** : `invalid_password`, `user_not_found`, `account_inactive`, `blocked_ip`
#### Logout
```jsonl
{"timestamp":"2025-10-26T16:45:00Z","event":"logout","user_id":123,"entity_id":5,"platform":"android","session_duration":7800}
```
### Événements Passages
#### Création
```jsonl
{"timestamp":"2025-10-26T14:40:10Z","event":"passage_created","passage_id":45678,"user_id":123,"entity_id":5,"operation_id":789,"sector_id":12,"amount":50.00,"payment_type":"cash","platform":"android"}
```
#### Modification
```jsonl
{"timestamp":"2025-10-26T14:42:05Z","event":"passage_updated","passage_id":45678,"user_id":123,"entity_id":5,"changes":{"amount":{"old":50.00,"new":75.00},"payment_type":{"old":"cash","new":"stripe"}},"platform":"ios"}
```
#### Suppression
```jsonl
{"timestamp":"2025-10-26T14:45:30Z","event":"passage_deleted","passage_id":45678,"user_id":123,"entity_id":5,"operation_id":789,"deleted_by":123,"soft_delete":true,"platform":"web"}
```
### Événements Secteurs
#### Création
```jsonl
{"timestamp":"2025-10-26T15:10:00Z","event":"sector_created","sector_id":456,"operation_id":789,"entity_id":5,"user_id":123,"sector_name":"Secteur A","platform":"web"}
```
#### Modification
```jsonl
{"timestamp":"2025-10-26T15:12:00Z","event":"sector_updated","sector_id":456,"operation_id":789,"entity_id":5,"user_id":123,"changes":{"sector_name":{"old":"Secteur A","new":"Secteur Alpha"}},"platform":"web"}
```
#### Suppression
```jsonl
{"timestamp":"2025-10-26T15:15:00Z","event":"sector_deleted","sector_id":456,"operation_id":789,"entity_id":5,"user_id":123,"deleted_by":123,"soft_delete":true,"platform":"web"}
```
### Événements Membres (Users)
#### Création
```jsonl
{"timestamp":"2025-10-26T15:20:00Z","event":"user_created","new_user_id":789,"entity_id":5,"created_by":123,"role_id":1,"username":"newuser","platform":"web"}
```
#### Modification
```jsonl
{"timestamp":"2025-10-26T15:25:00Z","event":"user_updated","user_id":789,"entity_id":5,"updated_by":123,"changes":{"role_id":{"old":1,"new":2},"encrypted_phone":true},"platform":"web"}
```
**Note** : Les champs chiffrés sont indiqués par un booléen `true` sans exposer les valeurs
#### Suppression
```jsonl
{"timestamp":"2025-10-26T15:30:00Z","event":"user_deleted","user_id":789,"entity_id":5,"deleted_by":123,"soft_delete":true,"platform":"web"}
```
### Événements Entités
#### Création
```jsonl
{"timestamp":"2025-10-26T15:35:00Z","event":"entity_created","entity_id":25,"created_by":1,"entity_type_id":1,"postal_code":"75001","platform":"web"}
```
#### Modification
```jsonl
{"timestamp":"2025-10-26T15:40:00Z","event":"entity_updated","entity_id":25,"user_id":123,"updated_by":123,"changes":{"encrypted_name":true,"encrypted_email":true,"chk_stripe":{"old":0,"new":1}},"platform":"web"}
```
#### Suppression (rare)
```jsonl
{"timestamp":"2025-10-26T15:45:00Z","event":"entity_deleted","entity_id":25,"deleted_by":1,"soft_delete":true,"reason":"duplicate","platform":"web"}
```
### Événements Opérations
#### Création
```jsonl
{"timestamp":"2025-10-26T16:00:00Z","event":"operation_created","operation_id":999,"entity_id":5,"created_by":123,"date_start":"2025-11-01","date_end":"2025-11-30","platform":"web"}
```
#### Modification
```jsonl
{"timestamp":"2025-10-26T16:05:00Z","event":"operation_updated","operation_id":999,"entity_id":5,"updated_by":123,"changes":{"date_end":{"old":"2025-11-30","new":"2025-12-15"},"chk_active":{"old":0,"new":1}},"platform":"web"}
```
#### Suppression
```jsonl
{"timestamp":"2025-10-26T16:10:00Z","event":"operation_deleted","operation_id":999,"entity_id":5,"deleted_by":123,"soft_delete":true,"platform":"web"}
```
## 🛠️ Implémentation
### Service EventLogService.php
**Emplacement** : `src/Services/EventLogService.php`
**Méthodes publiques** :
```php
EventLogService::logLoginSuccess($userId, $entityId, $username)
EventLogService::logLoginFailed($username, $reason, $attempt)
EventLogService::logLogout($userId, $entityId, $sessionDuration)
EventLogService::logPassageCreated($passageId, $operationId, $sectorId, $amount, $paymentType)
EventLogService::logPassageUpdated($passageId, $changes)
EventLogService::logPassageDeleted($passageId, $operationId, $softDelete)
EventLogService::logSectorCreated($sectorId, $operationId, $sectorName)
EventLogService::logSectorUpdated($sectorId, $operationId, $changes)
EventLogService::logSectorDeleted($sectorId, $operationId, $softDelete)
EventLogService::logUserCreated($newUserId, $entityId, $roleId, $username)
EventLogService::logUserUpdated($userId, $changes)
EventLogService::logUserDeleted($userId, $softDelete)
EventLogService::logEntityCreated($entityId, $entityTypeId, $postalCode)
EventLogService::logEntityUpdated($entityId, $changes)
EventLogService::logEntityDeleted($entityId, $reason)
EventLogService::logOperationCreated($operationId, $dateStart, $dateEnd)
EventLogService::logOperationUpdated($operationId, $changes)
EventLogService::logOperationDeleted($operationId, $softDelete)
```
**Enrichissement automatique** :
- `timestamp` : Généré automatiquement (UTC)
- `user_id`, `entity_id` : Récupérés depuis `Session`
- `ip` : Récupérée via `ClientDetector`
- `platform` : Détecté via `ClientDetector` (ios/android/web)
- `app_version` : Extrait du User-Agent pour mobile
### Intégration dans les Controllers
**Exemple dans PassageController** :
```php
public function createPassage(Request $request, Response $response): void {
// ... validation et création ...
$passageId = $db->lastInsertId();
// Log de l'événement
EventLogService::logPassageCreated(
$passageId,
$data['fk_operation'],
$data['fk_sector'],
$data['montant'],
$data['fk_type_reglement']
);
// ... suite du code ...
}
```
### Scripts d'analyse
#### 1. Stats entité
**Fichier** : `scripts/stats/entity_stats.php`
**Usage** :
```bash
# Stats entité 5 sur 7 derniers jours
php scripts/stats/entity_stats.php --entity-id=5 --days=7
# Stats entité 5 entre deux dates
php scripts/stats/entity_stats.php --entity-id=5 --from=2025-10-01 --to=2025-10-26
# Résultat JSON
{
"entity_id": 5,
"period": {"from": "2025-10-20", "to": "2025-10-26"},
"stats": {
"logins": {"success": 45, "failed": 2},
"passages": {"created": 120, "updated": 15, "deleted": 3},
"sectors": {"created": 2, "updated": 8, "deleted": 0},
"users": {"created": 1, "updated": 5, "deleted": 0}
},
"top_users": [
{"user_id": 123, "actions": 85},
{"user_id": 456, "actions": 42}
]
}
```
#### 2. Stats globales super-admin
**Fichier** : `scripts/stats/global_stats.php`
**Usage** :
```bash
# Tous les passages modifiés sur 2 semaines
php scripts/stats/global_stats.php --event=passage_updated --days=14
# Toutes les connexions échouées du mois
php scripts/stats/global_stats.php --event=login_failed --month=2025-10
# Résultat JSON
{
"event": "passage_updated",
"period": {"from": "2025-10-13", "to": "2025-10-26"},
"total_events": 342,
"by_entity": [
{"entity_id": 5, "count": 120},
{"entity_id": 12, "count": 85},
{"entity_id": 18, "count": 67}
],
"by_day": {
"2025-10-26": 45,
"2025-10-25": 38,
"2025-10-24": 52
}
}
```
#### 3. Export CSV pour analyse externe
**Fichier** : `scripts/stats/export_events_csv.php`
**Usage** :
```bash
# Exporter toutes les connexions du mois en CSV
php scripts/stats/export_events_csv.php \
--event=login_success \
--month=2025-10 \
--output=/tmp/logins_october.csv
```
### CRON de rotation
**Fichier** : `scripts/cron/rotate_event_logs.php`
**Configuration crontab** :
```cron
# Rotation des logs d'événements - 1er du mois à 3h
0 3 1 * * cd /var/www/geosector/api && php scripts/cron/rotate_event_logs.php
```
**Actions** :
1. Compresser fichiers > 30 jours : `gzip logs/events/2025-09-*.jsonl`
2. Supprimer archives > 15 mois : `rm logs/events/*-2024-06-*.jsonl.gz`
3. Logger résumé dans `logs/rotation.log`
## 📈 Performances et volumétrie
### Estimations
**Volume quotidien moyen** (pour 50 entités actives) :
- 500 connexions/jour = 500 lignes
- 2000 passages créés/modifiés = 2000 lignes
- 100 autres événements = 100 lignes
- **Total : ~2600 événements/jour**
**Taille fichier** :
- 1 événement ≈ 200-400 bytes JSON
- 2600 événements ≈ 0.8-1 MB/jour non compressé
- Compression gzip : ratio ~10:1 → **~100 KB/jour compressé**
**Rétention 15 mois** :
- Non compressé (30 jours) : 30 MB
- Compressé (14.5 mois) : 45 MB
- **Total stockage : ~75 MB** pour 15 mois
### Optimisation lecture
**Lecture mono-fichier** : < 50ms pour analyser 1 jour (2600 événements)
**Lecture période 7 jours** :
- 7 fichiers × 1 MB = 7 MB à lire
- Filtrage `jq` ou PHP : ~200-300ms
**Lecture période 2 semaines (super-admin)** :
- 14 fichiers × 1 MB = 14 MB à lire
- Filtrage sur type événement : ~500ms
**Lecture archive compressée** :
- Décompression à la volée : +100-200ms
- Total : ~700-800ms pour 1 mois compressé
## 🔒 Sécurité et confidentialité
### Données sensibles
** Jamais loggé en clair** :
- Mots de passe
- Contenu chiffré (noms, emails, téléphones, IBAN)
- Tokens d'authentification
** Loggé** :
- IDs (user_id, entity_id, passage_id, etc.)
- Montants financiers
- Dates et timestamps
- Types de modifications (indicateur booléen pour champs chiffrés)
### Exemple champ chiffré
```json
{
"event": "user_updated",
"changes": {
"encrypted_name": true, // Indique modification sans valeur
"encrypted_email": true,
"role_id": {"old": 1, "new": 2} // Champ non sensible = valeurs OK
}
}
```
### Permissions d'accès
**Fichiers logs** :
- Propriétaire : `nginx:nginx`
- Permissions : `0640` (lecture nginx, écriture nginx, aucun autre)
- Dossier `/logs/events/` : `0750`
**Scripts d'analyse** :
- Exécution : root ou nginx uniquement
- Pas d'accès direct via endpoints API (pour l'instant)
## 🚀 Roadmap et évolutions futures
### Phase 1 - MVP (actuel) ✅
- [x] Architecture JSONL quotidienne
- [x] Service EventLogService.php
- [x] Intégration dans controllers (LoginController, PassageController, UserController, SectorController, OperationController, EntiteController)
- [ ] CRON de rotation 15 mois
- [ ] Scripts d'analyse de base
### Phase 2 - Dashboards (Q1 2026)
- [ ] Endpoints API : `GET /api/stats/entity/{id}`, `GET /api/stats/global`
- [ ] Interface web admin : graphiques connexions, passages
- [ ] Filtres avancés (période, plateforme, utilisateur)
### Phase 3 - Alertes (Q2 2026)
- [ ] Détection anomalies (pics de connexions échouées)
- [ ] Alertes email super-admins
- [ ] Seuils configurables par entité
### Phase 4 - Migration TimescaleDB (si besoin)
- [ ] Évaluation volume : si > 50k événements/jour
- [ ] Import JSONL → TimescaleDB
- [ ] Rétention hybride : 90j TimescaleDB, archives JSONL
## 📝 Statut implémentation
**Date : 28 Octobre 2025**
### ✅ Terminé
- Service `EventLogService.php` créé avec toutes les méthodes de logging
- Intégration complète dans les 6 controllers principaux :
- **LoginController** : login réussi/échoué, logout
- **PassageController** : création, modification, suppression passages
- **UserController** : création, modification, suppression utilisateurs
- **SectorController** : création, modification, suppression secteurs
- **OperationController** : création, modification, suppression opérations
- **EntiteController** : création, modification entités
- Enrichissement automatique : timestamp UTC, user_id, entity_id, IP, platform, app_version
- Sécurité : champs sensibles loggés en booléen uniquement (pas de valeurs chiffrées)
- Script de déploiement `deploy-api.sh` crée automatiquement `/logs/events/` avec permissions 0750
### 🔄 En attente
- Scripts d'analyse (`entity_stats.php`, `global_stats.php`, `export_events_csv.php`)
- CRON de rotation 15 mois (`rotate_event_logs.php`)
- Tests en environnement DEV
## 📝 Checklist déploiement
### Environnement DEV (dva-geo)
- [x] Créer dossier `/logs/events/` (permissions 0750) - Intégré dans deploy-api.sh
- [x] Déployer `EventLogService.php`
- [ ] Déployer scripts stats et rotation
- [ ] Configurer CRON rotation
- [ ] Tests : générer événements manuellement
- [ ] Valider format JSONL et rotation
### Environnement RECETTE (rca-geo)
- [ ] Déployer depuis DEV validé
- [ ] Tests de charge : 10k événements/jour
- [ ] Valider performances scripts d'analyse
- [ ] Valider compression et suppression auto
### Environnement PRODUCTION (pra-geo)
- [ ] Déployer depuis RECETTE validée
- [ ] Monitoring volumétrie
- [ ] Backups quotidiens `/logs/events/` (via CRON général)
---
**Dernière mise à jour :** 28 Octobre 2025
**Version :** 1.1
**Statut :** ✅ Service implémenté et intégré - Scripts d'analyse à développer

View File

@@ -1,176 +0,0 @@
# Correction des erreurs 400 lors de la création d'utilisateurs
## Problème identifié
Un administrateur (fk_role=2) rencontrait des erreurs 400 répétées lors de tentatives de création de membre, menant à un bannissement par fail2ban :
- 17:09:39 - POST /api/users HTTP/1.1 400 (Bad Request)
- 17:10:44 - POST /api/users/check-username HTTP/1.1 400 (Bad Request)
- 17:11:21 - POST /api/users HTTP/1.1 400 (Bad Request)
## Causes identifiées
### 1. Conflit de routage (CRITIQUE)
**Problème:** La route `/api/users/check-username` était déclarée APRÈS la route générique `/api/users` dans Router.php, causant une mauvaise interprétation où "check-username" était traité comme un ID utilisateur.
**Solution:** Déplacer la déclaration de la route spécifique AVANT les routes avec paramètres.
### 2. Messages d'erreur non informatifs
**Problème:** Les erreurs 400 retournaient des messages génériques sans détails sur le champ problématique.
**Solution:** Ajout de messages d'erreur détaillés incluant :
- Le champ en erreur (`field`)
- La valeur problématique (`value`)
- Le format attendu (`format`)
- La raison de l'erreur (`reason`)
### 3. Manque de logs de débogage
**Problème:** Aucun log n'était généré pour tracer les erreurs de validation.
**Solution:** Ajout de logs détaillés à chaque point de validation.
## Modifications apportées
### 1. Router.php (ligne 36-44)
```php
// AVANT (incorrect)
$this->post('users', ['UserController', 'createUser']);
$this->post('users/check-username', ['UserController', 'checkUsername']);
// APRÈS (correct)
$this->post('users/check-username', ['UserController', 'checkUsername']); // Route spécifique en premier
$this->post('users', ['UserController', 'createUser']);
```
### 2. UserController.php - Amélioration des validations
#### Validation de l'email
```php
// Réponse améliorée
Response::json([
'status' => 'error',
'message' => 'Email requis',
'field' => 'email' // Indique clairement le champ problématique
], 400);
```
#### Validation du username manuel
```php
// Réponse améliorée
Response::json([
'status' => 'error',
'message' => 'Le nom d\'utilisateur est requis pour cette entité',
'field' => 'username',
'reason' => 'L\'entité requiert la saisie manuelle des identifiants'
], 400);
```
#### Format du username
```php
// Réponse améliorée
Response::json([
'status' => 'error',
'message' => 'Format du nom d\'utilisateur invalide',
'field' => 'username',
'format' => '10-30 caractères, commence par une lettre, caractères autorisés: a-z, 0-9, ., -, _',
'value' => $username // Montre la valeur soumise
], 400);
```
### 3. Ajout de logs détaillés
Chaque point de validation génère maintenant un log avec :
- Le type d'erreur
- L'utilisateur qui fait la requête
- Les données reçues (sans données sensibles)
- Le contexte de l'erreur
Exemple :
```php
LogService::log('Erreur création utilisateur : Format username invalide', [
'level' => 'warning',
'createdBy' => $currentUserId,
'email' => $email,
'username' => $username,
'username_length' => strlen($username)
]);
```
## Cas d'erreur 400 possibles
### Pour /api/users (création)
1. **Email manquant ou vide**
- Message: "Email requis"
- Field: "email"
2. **Nom manquant ou vide**
- Message: "Nom requis"
- Field: "name"
3. **Format email invalide**
- Message: "Format d'email invalide"
- Field: "email"
- Value: [email soumis]
4. **Username manuel requis mais manquant** (si chk_username_manuel=1)
- Message: "Le nom d'utilisateur est requis pour cette entité"
- Field: "username"
- Reason: "L'entité requiert la saisie manuelle des identifiants"
5. **Format username invalide**
- Message: "Format du nom d'utilisateur invalide"
- Field: "username"
- Format: "10-30 caractères, commence par une lettre..."
- Value: [username soumis]
6. **Mot de passe manuel requis mais manquant** (si chk_mdp_manuel=1)
- Message: "Le mot de passe est requis pour cette entité"
- Field: "password"
- Reason: "L'entité requiert la saisie manuelle des mots de passe"
### Pour /api/users/check-username
1. **Username manquant**
- Message: "Username requis pour la vérification"
- Field: "username"
2. **Format username invalide**
- Message: "Format invalide"
- Field: "username"
- Format: "10-30 caractères, commence par une lettre..."
- Value: [username soumis]
## Test de la solution
Un script de test a été créé : `/tests/test_user_creation.php`
Il teste tous les cas d'erreur possibles et vérifie que :
1. Les codes HTTP sont corrects
2. Les messages d'erreur sont informatifs
3. Les champs en erreur sont identifiés
## Recommandations pour éviter le bannissement fail2ban
1. **Côté client (application Flutter)** :
- Valider les données AVANT l'envoi
- Afficher clairement les erreurs à l'utilisateur
- Implémenter un délai entre les tentatives (rate limiting côté client)
2. **Côté API** :
- Les messages d'erreur détaillés permettent maintenant de corriger rapidement les problèmes
- Les logs permettent de diagnostiquer les problèmes récurrents
3. **Configuration fail2ban** :
- Considérer d'augmenter le seuil pour les erreurs 400 (ex: 5 tentatives au lieu de 3)
- Exclure certaines IP de confiance si nécessaire
## Suivi des logs
Les logs sont maintenant générés dans :
- `/logs/geosector-[environment]-[date].log` : Logs généraux avec détails des erreurs
Format des logs :
```
timestamp;browser;os;client_type;level;metadata;message
```
Les erreurs de validation sont loggées avec le niveau "warning" pour permettre un suivi sans être critiques.

View File

@@ -24,78 +24,24 @@ Ce document décrit le système de gestion des secteurs dans l'API Geosector, in
- Contient toutes les tables de l'application
- Tables concernées : `ope_sectors`, `sectors_adresses`, `ope_pass`, `ope_users_sectors`, `x_departements_contours`
2. **Base adresses** (dans conteneurs maria3/maria4)
- **DVA** : maria3 (13.23.33.4) - base `adresses`
- User : `adr_geo_user` / `d66,AdrGeoDev.User`
- **RCA** : maria3 (13.23.33.4) - base `adresses`
- User : `adr_geo_user` / `d66,AdrGeoRec.User`
- **PROD** : maria4 (13.23.33.4) - base `adresses`
- User : `adr_geo_user` / `d66,AdrGeoPrd.User`
2. **Base adresses** (dans conteneurs Incus séparés)
- DVA : `dva-maria` (13.23.33.46) - base `adresses`
- RCA : `rca-maria` (13.23.33.36) - base `adresses`
- PRA : `pra-maria` (13.23.33.26) - base `adresses`
- Credentials : `adr_geo_user` / `d66,AdrGeoDev.User`
- Tables par département : `cp22`, `cp23`, etc.
3. **Base bâtiments** (dans conteneurs maria3/maria4)
- **DVA** : maria3 (13.23.33.4) - base `batiments`
- User : `adr_geo_user` / `d66,AdrGeoDev.User`
- **RCA** : maria3 (13.23.33.4) - base `batiments`
- User : `adr_geo_user` / `d66,AdrGeoRec.User`
- **PROD** : maria4 (13.23.33.4) - base `batiments`
- User : `adr_geo_user` / `d66,AdrGeoPrd.User`
- Tables par département : `bat22`, `bat23`, etc.
- Colonnes principales : `batiment_groupe_id`, `cle_interop_adr`, `nb_log`, `nb_niveau`, `residence`, `altitude_sol_mean`
- Lien avec adresses : `bat{dept}.cle_interop_adr = cp{dept}.id`
### Configuration
Dans `src/Config/AppConfig.php` :
```php
// DÉVELOPPEMENT
'addresses_database' => [
'host' => '13.23.33.4', // Container maria3 sur IN3
'host' => '13.23.33.46', // Varie selon l'environnement
'name' => 'adresses',
'username' => 'adr_geo_user',
'password' => 'd66,AdrGeoDev.User',
],
// RECETTE
'addresses_database' => [
'host' => '13.23.33.4', // Container maria3 sur IN3
'name' => 'adresses',
'username' => 'adr_geo_user',
'password' => 'd66,AdrGeoRec.User',
],
// PRODUCTION
'addresses_database' => [
'host' => '13.23.33.4', // Container maria4 sur IN4
'name' => 'adresses',
'username' => 'adr_geo_user',
'password' => 'd66,AdrGeoPrd.User',
],
// DÉVELOPPEMENT - Bâtiments
'buildings_database' => [
'host' => '13.23.33.4', // Container maria3 sur IN3
'name' => 'batiments',
'username' => 'adr_geo_user',
'password' => 'd66,AdrGeoDev.User',
],
// RECETTE - Bâtiments
'buildings_database' => [
'host' => '13.23.33.4', // Container maria3 sur IN3
'name' => 'batiments',
'username' => 'adr_geo_user',
'password' => 'd66,AdrGeoRec.User',
],
// PRODUCTION - Bâtiments
'buildings_database' => [
'host' => '13.23.33.4', // Container maria4 sur IN4
'name' => 'batiments',
'username' => 'adr_geo_user',
'password' => 'd66,AdrGeoPrd.User',
],
```
## Gestion des contours départementaux
@@ -172,46 +118,6 @@ class DepartmentBoundaryService {
]
```
### BuildingService
Enrichit les adresses avec les données bâtiments :
```php
namespace App\Services;
class BuildingService {
// Enrichit une liste d'adresses avec les métadonnées des bâtiments
public function enrichAddresses(array $addresses): array
}
```
**Fonctionnement** :
- Connexion à la base `batiments` externe
- Interrogation des tables `bat{dept}` par département
- JOIN sur `bat{dept}.cle_interop_adr = cp{dept}.id`
- Ajout des métadonnées : `fk_batiment`, `fk_habitat`, `nb_niveau`, `nb_log`, `residence`, `alt_sol`
- Fallback : `fk_habitat=1` (maison individuelle) si pas de bâtiment trouvé
**Données retournées** :
```php
[
'id' => 'cp22.123456',
'numero' => '10',
'voie' => 'Rue Victor Hugo',
'code_postal' => '22000',
'commune' => 'Saint-Brieuc',
'latitude' => 48.5149,
'longitude' => -2.7658,
// Données bâtiment enrichies :
'fk_batiment' => 'BAT_123456', // null si maison
'fk_habitat' => 2, // 1=individuel, 2=collectif
'nb_niveau' => 4, // null si maison
'nb_log' => 12, // null si maison
'residence' => 'Résidence Les Pins', // '' si maison
'alt_sol' => 25.5 // null si maison
]
```
## Processus de création de secteur
### 1. Structure du payload
@@ -244,77 +150,13 @@ class BuildingService {
- Recherche des passages avec `fk_sector = 0` dans le polygone
- Mise à jour de leur `fk_sector` vers le nouveau secteur
- Exclusion des passages ayant déjà une `fk_adresse`
7. **Récupération** des adresses via `AddressService::getAddressesInPolygon()`
8. **Enrichissement** avec données bâtiments via `AddressService::enrichAddressesWithBuildings()`
9. **Stockage** des adresses dans `sectors_adresses` avec colonnes bâtiment :
- `fk_batiment`, `fk_habitat`, `nb_niveau`, `nb_log`, `residence`, `alt_sol`
10. **Création** des passages dans `ope_pass` :
- **Maisons individuelles** (fk_habitat=1) : 1 passage par adresse
- **Immeubles** (fk_habitat=2) : nb_log passages par adresse (1 par appartement)
- Champs ajoutés : `residence`, `appt` (numéro 1 à nb_log), `fk_habitat`
7. **Récupération** des adresses via `AddressService`
8. **Stockage** des adresses dans `sectors_adresses`
9. **Création** des passages dans `ope_pass` pour chaque adresse :
- Affectés au premier utilisateur de la liste
- Avec toutes les FK nécessaires (entité, opération, secteur, user)
- Données d'adresse complètes
11. **Commit** de la transaction ou **rollback** en cas d'erreur
## Processus de modification de secteur
### 1. Structure du payload UPDATE
```json
{
"libelle": "Secteur Centre-Ville Modifié",
"color": "#00FF00",
"sector": "48.117266/-1.6777926#48.118500/-1.6750000#...",
"users": [12, 34],
"chk_adresses_change": 1
}
```
### 2. Paramètre chk_adresses_change
**Valeurs** :
- `0` : Ne pas recalculer les adresses et passages (modification simple)
- `1` : Recalculer les adresses et passages (défaut)
**Cas d'usage** :
#### chk_adresses_change = 0
Modification rapide sans toucher aux adresses/passages :
- ✅ Modification du libellé
- ✅ Modification de la couleur
- ✅ Modification des coordonnées du polygone (visuel uniquement)
- ✅ Modification des membres affectés
- ❌ Pas de recalcul des adresses dans sectors_adresses
- ❌ Pas de mise à jour des passages (orphelins, créés, supprimés)
-**Réponse sans passages_sector** (tableau vide)
**Utilité** : Permet aux admins de corriger rapidement un libellé, une couleur, ou d'ajuster légèrement le périmètre visuel sans déclencher un recalcul complet qui pourrait prendre plusieurs secondes.
**Réponse API** :
```json
{
"status": "success",
"message": "Secteur modifié avec succès",
"sector": { "id": 123, "libelle": "...", "color": "...", "sector": "..." },
"passages_sector": [], // Vide car chk_adresses_change = 0
"passages_orphaned": 0,
"passages_deleted": 0,
"passages_updated": 0,
"passages_created": 0,
"passages_total": 0,
"users_sectors": [...]
}
```
#### chk_adresses_change = 1 (défaut)
Modification complète avec recalcul :
- ✅ Modification du libellé/couleur/polygone
- ✅ Modification des membres
- ✅ Suppression et recréation de sectors_adresses
- ✅ Application des règles de gestion des bâtiments
- ✅ Mise en orphelin des passages hors périmètre
- ✅ Création de nouveaux passages pour nouvelles adresses
10. **Commit** de la transaction ou **rollback** en cas d'erreur
### 3. Réponse API pour CREATE
@@ -445,28 +287,14 @@ $coordinates = [
### sectors_adresses
- `fk_sector` : Lien vers le secteur
- `fk_adresse` : ID de l'adresse dans la base externe
- `numero`, `rue`, `rue_bis`, `cp`, `ville`
- `gps_lat`, `gps_lng`
- **Colonnes bâtiment** :
- `fk_batiment` : ID bâtiment (VARCHAR 50, null si maison)
- `fk_habitat` : 1=individuel, 2=collectif (TINYINT UNSIGNED)
- `nb_niveau` : Nombre d'étages (INT, null)
- `nb_log` : Nombre de logements (INT, null)
- `residence` : Nom résidence/copropriété (VARCHAR 75)
- `alt_sol` : Altitude sol en mètres (DECIMAL 10,2, null)
- `fk_address` : ID de l'adresse dans la base externe
- `numero`, `voie`, `code_postal`, `commune`
- `latitude`, `longitude`
### ope_pass (passages)
- `fk_operation`, `fk_sector`, `fk_user`, `fk_adresse`
- `numero`, `rue`, `rue_bis`, `ville`
- `gps_lat`, `gps_lng`
- **Colonnes bâtiment** :
- `residence` : Nom résidence (VARCHAR 75)
- `appt` : Numéro appartement (VARCHAR 10, saisie libre)
- `niveau` : Étage (VARCHAR 10, saisie libre)
- `fk_habitat` : 1=individuel, 2=collectif (TINYINT UNSIGNED)
- `fk_type` : Type passage (2=à faire, autres valeurs pour fait/refus)
- `encrypted_name`, `encrypted_email`, `encrypted_phone` : Données cryptées
- `fk_entite`, `fk_operation`, `fk_sector`, `fk_user`
- `numero`, `voie`, `code_postal`, `commune`
- `latitude`, `longitude`
- `created_at`, `fk_user_creat`, `chk_active`
### ope_users_sectors
@@ -475,103 +303,6 @@ $coordinates = [
- `fk_sector` : Lien vers le secteur
- `created_at`, `fk_user_creat`, `chk_active`
## Règles de gestion des bâtiments lors de l'UPDATE
### Principe général
Lors de la mise à jour d'un secteur, le système applique une logique intelligente pour gérer les passages en fonction du type d'habitat (maison/immeuble) et du nombre de logements.
### Clé d'identification unique
**Tous les passages** sont identifiés par la clé : `numero|rue|rue_bis|ville`
Cette clé ne contient **pas** `residence` ni `appt` car ces champs sont en **saisie libre** par l'utilisateur.
### Cas 1 : Maison individuelle (fk_habitat=1)
#### Si 0 passage existant :
```
→ INSERT 1 nouveau passage
- fk_habitat = 1
- residence = ''
- appt = ''
```
#### Si 1+ passages existants :
```
→ UPDATE le premier passage
- fk_habitat = 1
- residence = ''
→ Les autres passages restent INTACTS
(peuvent correspondre à plusieurs habitants saisis manuellement)
```
### Cas 2 : Immeuble (fk_habitat=2)
#### Étape 1 : UPDATE systématique
```
→ UPDATE TOUS les passages existants à cette adresse
- fk_habitat = 2
- residence = sectors_adresses.residence (si non vide)
```
#### Étape 2a : Si nb_existants < nb_log (ex: 3 passages, nb_log=6)
```
→ INSERT (nb_log - nb_existants) nouveaux passages
- fk_habitat = 2
- residence = sectors_adresses.residence
- appt = '' (pas de numéro prédéfini)
- fk_type = 2 (à faire)
Résultat : 6 passages total (3 conservés + 3 créés)
```
#### Étape 2b : Si nb_existants > nb_log (ex: 10 passages, nb_log=6)
```
→ DELETE max (nb_existants - nb_log) passages
Conditions de suppression :
- fk_type = 2 (à faire)
- ET encrypted_name vide (non visité)
- Tri par created_at ASC (les plus anciens d'abord)
Résultat : Entre 6 et 10 passages (selon combien sont visités)
```
### Points importants
**Préservation des données utilisateur** :
- `appt` et `niveau` ne sont **JAMAIS modifiés** (saisie libre conservée)
- Les passages visités (encrypted_name rempli) ne sont **JAMAIS supprimés**
**Mise à jour conditionnelle** :
- `residence` est mis à jour **uniquement si non vide** dans sectors_adresses
- Permet de conserver une saisie manuelle si la base bâtiments n'a pas l'info
**Gestion des transitions** :
- Une adresse peut passer de maison (fk_habitat=1) à immeuble (fk_habitat=2) ou inversement
- La logique s'adapte automatiquement au nouveau type d'habitat
**Uniformisation GPS** :
- **Tous les passages d'une même adresse partagent les mêmes coordonnées GPS** (gps_lat, gps_lng)
- Ces coordonnées proviennent de `sectors_adresses` (enrichies depuis la base externe `adresses`)
- Cette règle s'applique lors de la **création** et de la **mise à jour** avec `chk_adresses_change=1`
- Garantit la cohérence géographique pour tous les passages d'un même immeuble
### Exemple concret
**Situation initiale** :
- Adresse : "10 rue Victor Hugo, 22000 Saint-Brieuc"
- 8 passages existants (dont 3 visités)
- nb_log passe de 8 à 5
**Actions** :
1. UPDATE les 8 passages → fk_habitat=2, residence="Les Chênes"
2. Tentative suppression de (8-5) = 3 passages
3. Recherche des passages avec fk_type=2 ET encrypted_name vide
4. Suppose 5 passages non visités trouvés
5. Suppression des 3 plus anciens non visités
6. **Résultat** : 5 passages restants (3 visités + 2 non visités)
## Logs et monitoring
Le système génère des logs détaillés pour :

View File

@@ -1,90 +0,0 @@
# Installation de FPDF pour la génération des reçus PDF avec logo
## Installation via Composer (RECOMMANDÉ)
Sur chaque serveur (DEV, REC, PROD), exécuter :
```bash
cd /var/www/geosector/api
composer require setasign/fpdf
```
Ou si composer.json est déjà mis à jour :
```bash
cd /var/www/geosector/api
composer update
```
## Fichiers à déployer
1. **Nouveaux fichiers** :
- `/src/Services/ReceiptPDFGenerator.php` - Nouvelle classe de génération PDF avec FPDF
- `/docs/_logo_recu.png` - Logo par défaut (casque de pompier)
2. **Fichiers modifiés** :
- `/src/Services/ReceiptService.php` - Utilise maintenant ReceiptPDFGenerator
- `/composer.json` - Ajout de la dépendance FPDF
## Vérification
Après installation, tester la génération d'un reçu :
```bash
# Vérifier que FPDF est installé
ls -la vendor/setasign/fpdf/
# Tester la génération d'un PDF
php -r "
require 'vendor/autoload.php';
\$pdf = new FPDF();
\$pdf->AddPage();
\$pdf->SetFont('Arial','B',16);
\$pdf->Cell(40,10,'Test FPDF OK');
echo 'FPDF fonctionne' . PHP_EOL;
"
```
## Fonctionnalités du nouveau générateur
**Support des vrais logos PNG/JPG**
**Logo par défaut** si l'entité n'a pas de logo
**Taille du logo** : 40x40mm
**Mise en page professionnelle** avec cadre pour le montant
**Conversion automatique** des caractères UTF-8
**PDF léger** (~20-30KB avec logo)
## Structure du reçu généré
1. **En-tête** :
- Logo (40x40mm) à gauche
- Nom et ville de l'entité à droite du logo
2. **Titre** :
- "REÇU FISCAL DE DON"
- Numéro du reçu
- Article 200 CGI
3. **Corps** :
- Informations du donateur
- Montant en gros dans un cadre grisé
- Date du don
- Mode de règlement et campagne
4. **Pied de page** :
- Mentions légales (réduction 66%)
- Date et signature
## Résolution de problèmes
Si erreur "Class 'FPDF' not found" :
```bash
composer dump-autoload
```
Si problème avec le logo :
- Vérifier que `/docs/_logo_recu.png` existe
- Vérifier les permissions : `chmod 644 docs/_logo_recu.png`
Si caractères accentués mal affichés :
- FPDF utilise ISO-8859-1, la conversion est automatique dans ReceiptPDFGenerator

View File

@@ -1,818 +0,0 @@
# PLANNING STRIPE - DÉVELOPPEUR BACKEND PHP
## API PHP 8.3 - Intégration Stripe Tap to Pay (Mobile uniquement)
### Période : 25/08/2024 - 05/09/2024
### Mise à jour : Janvier 2025 - Simplification architecture
---
## 📅 LUNDI 25/08 - Setup et architecture (8h)
### 🌅 Matin (4h)
```bash
# Installation Stripe PHP SDK
cd api
composer require stripe/stripe-php
```
#### ✅ Configuration environnement
- [x] Créer configuration Stripe dans `AppConfig.php` avec clés TEST
- [x] Ajouter variables de configuration :
```php
'stripe' => [
'public_key_test' => 'pk_test_51QwoVN00pblGEgsXkf8qlXm...',
'secret_key_test' => 'sk_test_51QwoVN00pblGEgsXnvqi8qf...',
'webhook_secret_test' => 'whsec_test_...',
'api_version' => '2024-06-20',
'application_fee_percent' => 0, // DECISION: 0% commission
'mode' => 'test'
]
```
- [x] Créer service `StripeService.php` singleton
- [x] Configurer authentification Session-based API
#### ✅ Base de données
```sql
-- Modification de la table ope_pass existante (JANVIER 2025)
ALTER TABLE `ope_pass`
DROP COLUMN IF EXISTS `is_striped`,
ADD COLUMN `stripe_payment_id` VARCHAR(50) DEFAULT NULL COMMENT 'ID du PaymentIntent Stripe (pi_xxx)',
ADD INDEX `idx_stripe_payment` (`stripe_payment_id`);
-- Tables à créer (simplifiées)
CREATE TABLE stripe_accounts (
id INT PRIMARY KEY AUTO_INCREMENT,
amicale_id INT NOT NULL,
stripe_account_id VARCHAR(255) UNIQUE,
charges_enabled BOOLEAN DEFAULT FALSE,
payouts_enabled BOOLEAN DEFAULT FALSE,
onboarding_completed BOOLEAN DEFAULT FALSE,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
FOREIGN KEY (amicale_id) REFERENCES amicales(id)
);
-- NOTE: Table payment_intents SUPPRIMÉE - on utilise directement stripe_payment_id dans ope_pass
-- NOTE: Table terminal_readers SUPPRIMÉE - Tap to Pay uniquement, pas de terminaux externes
CREATE TABLE android_certified_devices (
id INT PRIMARY KEY AUTO_INCREMENT,
manufacturer VARCHAR(100),
model VARCHAR(200),
model_identifier VARCHAR(200),
tap_to_pay_certified BOOLEAN DEFAULT FALSE,
certification_date DATE,
min_android_version INT,
country VARCHAR(2) DEFAULT 'FR',
last_verified TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
INDEX idx_manufacturer_model (manufacturer, model)
);
```
### 🌆 Après-midi (4h)
#### ✅ Endpoints Connect - Onboarding (RÉALISÉS)
```php
// POST /api/stripe/accounts - IMPLEMENTED
public function createAccount() {
$amicale = Amicale::find($amicaleId);
$account = \Stripe\Account::create([
'type' => 'express',
'country' => 'FR',
'email' => $amicale->email,
'capabilities' => [
'card_payments' => ['requested' => true],
'transfers' => ['requested' => true],
],
'business_type' => 'non_profit',
'business_profile' => [
'name' => $amicale->name,
'product_description' => 'Vente de calendriers des pompiers',
],
]);
// Sauvegarder stripe_account_id
return $account;
}
// GET /api/amicales/{id}/onboarding-link
public function getOnboardingLink($amicaleId) {
$accountLink = \Stripe\AccountLink::create([
'account' => $amicale->stripe_account_id,
'refresh_url' => config('app.url') . '/stripe/refresh',
'return_url' => config('app.url') . '/stripe/success',
'type' => 'account_onboarding',
]);
return ['url' => $accountLink->url];
}
```
---
## 📅 MARDI 26/08 - Webhooks et Terminal (8h)
### 🌅 Matin (4h)
#### ✅ Webhooks handler
```php
// POST /api/webhooks/stripe
public function handleWebhook(Request $request) {
$payload = $request->getContent();
$sig_header = $request->header('Stripe-Signature');
try {
$event = \Stripe\Webhook::constructEvent(
$payload, $sig_header, config('stripe.webhook_secret')
);
} catch(\Exception $e) {
return response('Invalid signature', 400);
}
switch ($event->type) {
case 'account.updated':
$this->handleAccountUpdated($event->data->object);
break;
case 'account.application.authorized':
$this->handleAccountAuthorized($event->data->object);
break;
case 'payment_intent.succeeded':
$this->handlePaymentSucceeded($event->data->object);
break;
}
return response('Webhook handled', 200);
}
```
#### ✅ Configuration Tap to Pay
```php
// POST /api/stripe/tap-to-pay/init
public function initTapToPay(Request $request) {
$userId = Session::getUserId();
$entityId = Session::getEntityId();
// Vérifier que l'entité a un compte Stripe
$account = $this->getStripeAccount($entityId);
return [
'stripe_account_id' => $account->stripe_account_id,
'tap_to_pay_enabled' => true
];
}
```
### 🌆 Après-midi (4h)
#### ✅ Vérification compatibilité Device
```php
// POST /api/stripe/devices/check-tap-to-pay
public function checkTapToPayCapability(Request $request) {
$platform = $request->input('platform');
$model = $request->input('device_model');
$osVersion = $request->input('os_version');
if ($platform === 'iOS') {
// iPhone XS et ultérieurs avec iOS 16.4+
$supported = $this->checkiOSCompatibility($model, $osVersion);
} else {
// Android certifié pour la France
$supported = $this->checkAndroidCertification($model);
}
return [
'tap_to_pay_supported' => $supported,
'message' => $supported ?
'Tap to Pay disponible' :
'Appareil non compatible'
];
}
```
---
## 📅 MERCREDI 27/08 - Paiements et fees (8h)
### 🌅 Matin (4h)
#### ✅ Création PaymentIntent avec association au passage
```php
// POST /api/payments/create-intent
public function createPaymentIntent(Request $request) {
$validated = $request->validate([
'amount' => 'required|integer|min:100', // en centimes
'passage_id' => 'required|integer', // ID du passage ope_pass
'entity_id' => 'required|integer',
]);
$userId = Session::getUserId();
$entity = $this->getEntity($validated['entity_id']);
// Commission à 0% (décision client)
$applicationFee = 0;
$paymentIntent = \Stripe\PaymentIntent::create([
'amount' => $validated['amount'],
'currency' => 'eur',
'payment_method_types' => ['card_present'],
'capture_method' => 'automatic',
'application_fee_amount' => $applicationFee,
'transfer_data' => [
'destination' => $entity->stripe_account_id,
],
'metadata' => [
'passage_id' => $validated['passage_id'],
'user_id' => $userId,
'entity_id' => $entity->id,
'year' => date('Y'),
],
]);
// Mise à jour directe dans ope_pass
$this->db->prepare("
UPDATE ope_pass
SET stripe_payment_id = :stripe_id,
date_modified = NOW()
WHERE id = :passage_id
")->execute([
':stripe_id' => $paymentIntent->id,
':passage_id' => $validated['passage_id']
]);
return [
'client_secret' => $paymentIntent->client_secret,
'payment_intent_id' => $paymentIntent->id,
];
}
```
### 🌆 Après-midi (4h)
#### ✅ Capture et confirmation
```php
// POST /api/payments/{id}/capture
public function capturePayment($paymentIntentId) {
// Récupérer le passage depuis ope_pass
$stmt = $this->db->prepare("
SELECT id, stripe_payment_id, montant
FROM ope_pass
WHERE stripe_payment_id = :stripe_id
");
$stmt->execute([':stripe_id' => $paymentIntentId]);
$passage = $stmt->fetch();
$paymentIntent = \Stripe\PaymentIntent::retrieve($paymentIntentId);
if ($paymentIntent->status === 'requires_capture') {
$paymentIntent->capture();
}
// Mettre à jour le statut dans ope_pass si nécessaire
if ($paymentIntent->status === 'succeeded' && $passage) {
$this->db->prepare("
UPDATE ope_pass
SET date_stripe_validated = NOW()
WHERE id = :passage_id
")->execute([':passage_id' => $passage['id']]);
// Envoyer email reçu si configuré
$this->sendReceipt($passage['id']);
}
return $paymentIntent;
}
// GET /api/passages/{id}/stripe-status
public function getPassageStripeStatus($passageId) {
$stmt = $this->db->prepare("
SELECT stripe_payment_id, montant, date_creat
FROM ope_pass
WHERE id = :id
");
$stmt->execute([':id' => $passageId]);
$passage = $stmt->fetch();
if (!$passage['stripe_payment_id']) {
return ['status' => 'no_stripe_payment'];
}
// Récupérer le statut depuis Stripe
$paymentIntent = \Stripe\PaymentIntent::retrieve($passage['stripe_payment_id']);
return [
'stripe_payment_id' => $passage['stripe_payment_id'],
'status' => $paymentIntent->status,
'amount' => $paymentIntent->amount,
'currency' => $paymentIntent->currency,
'created_at' => $passage['date_creat']
];
}
```
---
## 📅 JEUDI 28/08 - Reporting et Android compatibility (8h)
### 🌅 Matin (4h)
#### ✅ Gestion appareils Android certifiés
```php
// POST /api/devices/check-tap-to-pay
public function checkTapToPayCapability(Request $request) {
$validated = $request->validate([
'platform' => 'required|in:ios,android',
'manufacturer' => 'required_if:platform,android',
'model' => 'required_if:platform,android',
'os_version' => 'required',
]);
if ($validated['platform'] === 'ios') {
// iPhone XS et ultérieurs avec iOS 15.4+
$supportedModels = ['iPhone11,', 'iPhone12,', 'iPhone13,', 'iPhone14,', 'iPhone15,', 'iPhone16,'];
$modelSupported = false;
foreach ($supportedModels as $prefix) {
if (str_starts_with($validated['model'], $prefix)) {
$modelSupported = true;
break;
}
}
$osVersion = explode('.', $validated['os_version']);
$osSupported = $osVersion[0] > 15 ||
($osVersion[0] == 15 && isset($osVersion[1]) && $osVersion[1] >= 4);
return [
'tap_to_pay_supported' => $modelSupported && $osSupported,
'message' => $modelSupported && $osSupported ?
'Tap to Pay disponible' :
'iPhone XS ou ultérieur avec iOS 15.4+ requis'
];
}
// Android - vérifier dans la base de données
$device = DB::table('android_certified_devices')
->where('manufacturer', $validated['manufacturer'])
->where('model', $validated['model'])
->where('tap_to_pay_certified', true)
->first();
return [
'tap_to_pay_supported' => $device !== null,
'message' => $device ?
'Tap to Pay disponible sur cet appareil' :
'Appareil non certifié pour Tap to Pay en France',
'alternative' => !$device ? 'Utilisez un iPhone compatible' : null
];
}
// GET /api/devices/certified-android
public function getCertifiedAndroidDevices() {
return DB::table('android_certified_devices')
->where('tap_to_pay_certified', true)
->where('country', 'FR')
->orderBy('manufacturer')
->orderBy('model')
->get();
}
```
#### ✅ Seeder pour appareils certifiés
```php
// database/seeders/AndroidCertifiedDevicesSeeder.php
public function run() {
$devices = [
// Samsung
['manufacturer' => 'Samsung', 'model' => 'Galaxy S21', 'model_identifier' => 'SM-G991B', 'min_android_version' => 11],
['manufacturer' => 'Samsung', 'model' => 'Galaxy S21+', 'model_identifier' => 'SM-G996B', 'min_android_version' => 11],
['manufacturer' => 'Samsung', 'model' => 'Galaxy S21 Ultra', 'model_identifier' => 'SM-G998B', 'min_android_version' => 11],
['manufacturer' => 'Samsung', 'model' => 'Galaxy S22', 'model_identifier' => 'SM-S901B', 'min_android_version' => 12],
['manufacturer' => 'Samsung', 'model' => 'Galaxy S23', 'model_identifier' => 'SM-S911B', 'min_android_version' => 13],
['manufacturer' => 'Samsung', 'model' => 'Galaxy S24', 'model_identifier' => 'SM-S921B', 'min_android_version' => 14],
// Google Pixel
['manufacturer' => 'Google', 'model' => 'Pixel 6', 'model_identifier' => 'oriole', 'min_android_version' => 12],
['manufacturer' => 'Google', 'model' => 'Pixel 6 Pro', 'model_identifier' => 'raven', 'min_android_version' => 12],
['manufacturer' => 'Google', 'model' => 'Pixel 7', 'model_identifier' => 'panther', 'min_android_version' => 13],
['manufacturer' => 'Google', 'model' => 'Pixel 8', 'model_identifier' => 'shiba', 'min_android_version' => 14],
];
foreach ($devices as $device) {
DB::table('android_certified_devices')->insert([
'manufacturer' => $device['manufacturer'],
'model' => $device['model'],
'model_identifier' => $device['model_identifier'],
'tap_to_pay_certified' => true,
'certification_date' => now(),
'min_android_version' => $device['min_android_version'],
'country' => 'FR',
]);
}
}
```
#### ✅ Endpoints statistiques
```php
// GET /api/amicales/{id}/stats
public function getAmicaleStats($amicaleId) {
$stats = DB::table('payment_intents')
->where('amicale_id', $amicaleId)
->where('status', 'succeeded')
->selectRaw('
COUNT(*) as total_ventes,
SUM(amount) as total_montant,
SUM(application_fee) as total_commissions,
DATE(created_at) as date
')
->groupBy('date')
->get();
return $stats;
}
// GET /api/pompiers/{id}/ventes
public function getPompierVentes($pompierId) {
return PaymentIntent::where('pompier_id', $pompierId)
->where('status', 'succeeded')
->orderBy('created_at', 'desc')
->paginate(20);
}
```
### 🌆 Après-midi (4h)
#### ✅ Gestion des remboursements
```php
// POST /api/payments/{id}/refund
public function refundPayment($paymentIntentId, Request $request) {
$validated = $request->validate([
'amount' => 'integer|min:100', // optionnel, remboursement partiel
'reason' => 'string|in:duplicate,fraudulent,requested_by_customer',
]);
$payment = PaymentIntent::where('stripe_payment_intent_id', $paymentIntentId)->first();
$refund = \Stripe\Refund::create([
'payment_intent' => $paymentIntentId,
'amount' => $validated['amount'] ?? null, // null = remboursement total
'reason' => $validated['reason'] ?? 'requested_by_customer',
'reverse_transfer' => true, // Important pour Connect
'refund_application_fee' => true, // Rembourser aussi la commission
]);
$payment->update(['status' => 'refunded']);
return $refund;
}
```
---
## 📅 VENDREDI 29/08 - Mode offline et sync (8h)
### 🌅 Matin (4h)
#### ✅ Queue de synchronisation
```php
// POST /api/payments/batch-sync
public function batchSync(Request $request) {
$validated = $request->validate([
'transactions' => 'required|array',
'transactions.*.local_id' => 'required|string',
'transactions.*.amount' => 'required|integer',
'transactions.*.created_at' => 'required|date',
'transactions.*.payment_method' => 'required|in:card,cash',
]);
$results = [];
foreach ($validated['transactions'] as $transaction) {
if ($transaction['payment_method'] === 'cash') {
// Enregistrer paiement cash uniquement en DB
$results[] = $this->recordCashPayment($transaction);
} else {
// Créer PaymentIntent a posteriori (si possible)
$results[] = $this->createOfflinePayment($transaction);
}
}
return ['synced' => $results];
}
```
### 🌆 Après-midi (4h)
#### ✅ Tests unitaires critiques
```php
class StripePaymentTest extends TestCase {
public function test_create_payment_intent_with_fees() {
// Test création PaymentIntent avec commission
}
public function test_webhook_signature_validation() {
// Test sécurité webhook
}
public function test_refund_reverses_transfer() {
// Test remboursement avec annulation virement
}
}
```
---
## 📅 LUNDI 01/09 - Sécurité et optimisations (8h)
### 🌅 Matin (4h)
#### ✅ Rate limiting et sécurité
```php
// Middleware RateLimiter pour endpoints sensibles
Route::middleware(['throttle:10,1'])->group(function () {
Route::post('/payments/create-intent', 'PaymentController@createIntent');
});
// Validation des montants
public function validateAmount($amount) {
if ($amount < 100 || $amount > 50000) { // 1€ - 500€
throw new ValidationException('Montant invalide');
}
}
```
### 🌆 Après-midi (4h)
#### ✅ Logs et monitoring
```php
// Logger tous les événements Stripe
Log::channel('stripe')->info('Payment created', [
'payment_intent_id' => $paymentIntent->id,
'amount' => $paymentIntent->amount,
'pompier_id' => $pompier->id,
]);
```
---
## 📅 MARDI 02/09 - Documentation API (4h)
#### ✅ Documentation OpenAPI/Swagger
```yaml
/api/payments/create-intent:
post:
summary: Créer une intention de paiement
parameters:
- name: amount
type: integer
required: true
description: Montant en centimes
responses:
200:
description: PaymentIntent créé
```
---
## 📅 MERCREDI 03/09 - Tests d'intégration (8h)
#### ✅ Tests end-to-end
- [ ] Parcours complet onboarding amicale
- [ ] Création paiement → capture → confirmation
- [ ] Test remboursement complet et partiel
- [ ] Test webhooks avec ngrok
---
## 📅 JEUDI 04/09 - Mise en production (8h)
---
## 📅 VENDREDI 05/09 - Support et livraison finale (8h)
### 🌅 Matin (4h)
#### ✅ Déploiement final
- [ ] Migration DB production
- [ ] Variables environnement LIVE
- [ ] Smoke tests production
- [ ] Vérification des webhooks en production
### 🌆 Après-midi (4h)
#### ✅ Support et monitoring
- [ ] Monitoring des premiers paiements réels
- [ ] Support hotline pour équipes terrain
- [ ] Documentation de passation
- [ ] Réunion de clôture et retour d'expérience
---
## 📊 RÉCAPITULATIF
- **Total heures** : 72h sur 10 jours
- **Endpoints créés** : 15
- **Tables DB** : 3
- **Tests** : 20+
## 🔧 DÉPENDANCES
```json
{
"require": {
"php": "^8.3",
"stripe/stripe-php": "^13.0",
"laravel/framework": "^10.0"
}
}
```
## ⚠️ CHECKLIST SÉCURITÉ
- [ ] ❌ JAMAIS logger les clés secrètes
- [ ] ✅ TOUJOURS valider signature webhooks
- [ ] ✅ TOUJOURS utiliser HTTPS
- [ ] ✅ Rate limiting sur endpoints paiement
- [ ] ✅ Logs détaillés pour audit
---
## 🎯 BILAN DÉVELOPPEMENT API (01/09/2024)
### ✅ ENDPOINTS IMPLÉMENTÉS (TAP TO PAY UNIQUEMENT)
#### **Stripe Connect - Comptes**
- **POST /api/stripe/accounts** ✅
- Création compte Stripe Express pour amicales
- Gestion déchiffrement données (encrypted_email, encrypted_name)
- Support des comptes existants
- **GET /api/stripe/accounts/:entityId/status** ✅
- Récupération statut complet du compte
- Vérification charges_enabled et payouts_enabled
- Retour JSON avec informations détaillées
- **POST /api/stripe/accounts/:accountId/onboarding-link** ✅
- Génération liens d'onboarding Stripe
- URLs de retour configurées
- Gestion des erreurs et timeouts
#### **Configuration et Utilitaires**
- **GET /api/stripe/config** ✅
- Configuration publique Stripe
- Clés publiques et paramètres client
- Adaptation par environnement
- **POST /api/stripe/webhook** ✅
- Réception événements Stripe
- Vérification signatures webhook
- Traitement des événements Connect
### 🔧 CORRECTIONS TECHNIQUES RÉALISÉES
#### **StripeController.php**
- Fixed `Database::getInstance()` → `$this->db`
- Fixed `$db->prepare()` → `$this->db->prepare()`
- Removed `details_submitted` column from SQL UPDATE
- Added proper exit statements after JSON responses
- Commented out Logger class calls (class not found)
#### **StripeService.php**
- Added proper Stripe SDK imports (`use Stripe\Account`)
- Fixed `Account::retrieve()` → `$this->stripe->accounts->retrieve()`
- **CRUCIAL**: Added data decryption support:
```php
$nom = !empty($entite['encrypted_name']) ?
\ApiService::decryptData($entite['encrypted_name']) : '';
$email = !empty($entite['encrypted_email']) ?
\ApiService::decryptSearchableData($entite['encrypted_email']) : null;
```
- Fixed address mapping (adresse1, adresse2 vs adresse)
- **REMOVED commission calculation - set to 0%**
#### **Router.php**
- Commented out excessive debug logging causing nginx 502 errors:
```php
// error_log("Recherche de route pour: méthode=$method, uri=$uri");
// error_log("Test pattern: $pattern contre uri: $uri");
```
#### **AppConfig.php**
- Set `application_fee_percent` to 0 (was 2.5)
- Set `application_fee_minimum` to 0 (was 50)
- **Policy**: 100% of payments go to amicales
### 📊 TESTS ET VALIDATION
#### **Tests Réussis**
1. **POST /api/stripe/accounts** → 200 OK (Compte créé: acct_1S2YfNP63A07c33Y)
2. **GET /api/stripe/accounts/5/status** → 200 OK (charges_enabled: true)
3. **POST /api/stripe/locations** → 200 OK (Location: tml_GLJ21w7KCYX4Wj)
4. **POST /api/stripe/accounts/.../onboarding-link** → 200 OK (Link generated)
5. **Onboarding Stripe** → Completed successfully by user
#### **Erreurs Résolues**
- ❌ 500 "Class App\Controllers\Database not found" → ✅ Fixed
- ❌ 400 "Invalid email address: " → ✅ Fixed (decryption added)
- ❌ 502 "upstream sent too big header" → ✅ Fixed (logs removed)
- ❌ SQL "Column not found: details_submitted" → ✅ Fixed
### 🚀 ARCHITECTURE TECHNIQUE
#### **Services Implémentés**
- **StripeService**: Singleton pour interactions Stripe API
- **StripeController**: Endpoints REST avec gestion sessions
- **StripeWebhookController**: Handler événements webhook
- **ApiService**: Déchiffrement données encrypted fields
#### **Sécurité**
- Validation signatures webhook Stripe
- Authentification session-based pour APIs privées
- Public endpoints: webhook uniquement
- Pas de stockage clés secrètes en base
#### **Base de données (MISE À JOUR JANVIER 2025)**
- **Modification table `ope_pass`** : `stripe_payment_id` VARCHAR(50) remplace `is_striped`
- **Table `payment_intents` supprimée** : Intégration directe dans `ope_pass`
- Utilisation tables existantes (entites)
- Champs encrypted_email et encrypted_name supportés
- Déchiffrement automatique avant envoi Stripe
### 🎯 PROCHAINES ÉTAPES API
1. **Tests paiements réels** avec PaymentIntents
2. **Endpoints statistiques** pour dashboard amicales
3. **Webhooks production** avec clés live
4. **Monitoring et logs** des transactions
5. **Rate limiting** sur endpoints sensibles
---
## 📱 FLOW TAP TO PAY SIMPLIFIÉ (Janvier 2025)
### Architecture
```
Flutter App (Tap to Pay) ↔ API PHP ↔ Stripe API
```
### Étape 1: Création PaymentIntent
**Flutter → API**
```json
POST /api/stripe/payments/create-intent
{
"amount": 1500,
"passage_id": 123,
"entity_id": 5
}
```
**API → Stripe → Base de données**
```php
// 1. Créer le PaymentIntent
$paymentIntent = Stripe\PaymentIntent::create([...]);
// 2. Sauvegarder dans ope_pass
UPDATE ope_pass SET stripe_payment_id = 'pi_xxx' WHERE id = 123;
```
**API → Flutter**
```json
{
"client_secret": "pi_xxx_secret_yyy",
"payment_intent_id": "pi_xxx"
}
```
### Étape 2: Collecte du paiement (Flutter)
- L'app Flutter utilise le SDK Stripe Terminal
- Le téléphone devient le terminal de paiement (Tap to Pay)
- Utilise le client_secret pour collecter le paiement
### Étape 3: Confirmation (Webhook)
**Stripe → API**
- Event: `payment_intent.succeeded`
- Met à jour le statut dans la base de données
### Tables nécessaires
- ✅ `ope_pass.stripe_payment_id` - Association passage/paiement
- ✅ `stripe_accounts` - Comptes Connect des amicales
- ✅ `android_certified_devices` - Vérification compatibilité
- ❌ ~~`stripe_payment_intents`~~ - Supprimée
- ❌ ~~`terminal_readers`~~ - Pas de terminaux externes
### Endpoints essentiels
1. `POST /api/stripe/payments/create-intent` - Créer PaymentIntent
2. `POST /api/stripe/devices/check-tap-to-pay` - Vérifier compatibilité
3. `POST /api/stripe/webhook` - Recevoir confirmations
4. `GET /api/passages/{id}/stripe-status` - Vérifier statut
---
## 📝 CHANGELOG
### Janvier 2025 - Refactoring base de données
- **Suppression** de la table `payment_intents` (non nécessaire)
- **Migration** : `is_striped` → `stripe_payment_id` VARCHAR(50) dans `ope_pass`
- **Simplification** : Association directe PaymentIntent ↔ Passage
- **Avantage** : Traçabilité directe sans table intermédiaire
---
*Document créé le 24/08/2024 - Dernière mise à jour : 09/01/2025*

View File

@@ -1,237 +0,0 @@
# PRÉPARATION PRODUCTION - Process Email Queue + Permissions Suppression Passages
## 📅 Date de mise en production prévue : _____________
## 🎯 Objectif
1. Mettre en place le système de traitement automatique de la queue d'emails pour l'envoi des reçus fiscaux de dons.
2. Ajouter le champ de permission pour autoriser les membres à supprimer des passages.
## ✅ Prérequis
- [ ] Backup de la base de données effectué
- [ ] Accès SSH au serveur PROD
- [ ] Accès à la base de données PROD
- [ ] Droits pour éditer le crontab
## 📝 Fichiers à déployer
Les fichiers suivants doivent être présents sur le serveur PROD :
- `/scripts/cron/process_email_queue.php`
- `/scripts/cron/process_email_queue_with_daily_log.sh`
- `/scripts/cron/test_email_queue.php`
- `/src/Services/ReceiptPDFGenerator.php` (nouveau)
- `/src/Services/ReceiptService.php` (mis à jour)
- `/src/Core/MonitoredDatabase.php` (mis à jour)
- `/src/Controllers/EntiteController.php` (mis à jour)
- `/src/Controllers/LoginController.php` (mis à jour)
- `/scripts/sql/add_chk_user_delete_pass.sql` (nouveau)
---
## 🔧 ÉTAPES DE MISE EN PRODUCTION
### 1⃣ Mise à jour de la base de données
Se connecter à la base de données PROD et exécuter :
```sql
-- Vérifier d'abord la structure actuelle de email_queue
DESCRIBE email_queue;
-- Ajouter les champs manquants pour email_queue si nécessaire
ALTER TABLE `email_queue`
ADD COLUMN IF NOT EXISTS `sent_at` TIMESTAMP NULL DEFAULT NULL
COMMENT 'Date/heure d\'envoi effectif de l\'email'
AFTER `status`;
ALTER TABLE `email_queue`
ADD COLUMN IF NOT EXISTS `error_message` TEXT NULL DEFAULT NULL
COMMENT 'Message d\'erreur en cas d\'échec'
AFTER `attempts`;
-- Ajouter les index pour optimiser les performances
ALTER TABLE `email_queue`
ADD INDEX IF NOT EXISTS `idx_status_attempts` (`status`, `attempts`);
ALTER TABLE `email_queue`
ADD INDEX IF NOT EXISTS `idx_sent_at` (`sent_at`);
-- Vérifier les modifications email_queue
DESCRIBE email_queue;
-- ⚠️ IMPORTANT : Ajouter le nouveau champ chk_user_delete_pass dans entites
source /var/www/geosector/api/scripts/sql/add_chk_user_delete_pass.sql;
```
### 2⃣ Test du script avant mise en production
```bash
# Se connecter au serveur PROD
ssh user@prod-server
# Aller dans le répertoire de l'API
cd /var/www/geosector/api
# Rendre les scripts exécutables
chmod +x scripts/cron/process_email_queue.php
chmod +x scripts/cron/test_email_queue.php
# Tester l'état de la queue (lecture seule)
php scripts/cron/test_email_queue.php
# Si tout est OK, faire un test d'envoi sur 1 email
# (modifier temporairement BATCH_SIZE à 1 dans le script si nécessaire)
php scripts/cron/process_email_queue.php
```
### 3⃣ Configuration du CRON avec logs journaliers
```bash
# Rendre le script wrapper exécutable
chmod +x /var/www/geosector/api/scripts/cron/process_email_queue_with_daily_log.sh
# Éditer le crontab
crontab -e
# Ajouter cette ligne pour exécution toutes les 5 minutes avec logs journaliers
*/5 * * * * /var/www/geosector/api/scripts/cron/process_email_queue_with_daily_log.sh
# Sauvegarder et quitter (:wq sous vi/vim)
# Vérifier que le cron est bien enregistré
crontab -l | grep email_queue
# Vérifier que le service cron est actif
systemctl status cron
```
**Note** : Les logs seront créés automatiquement dans `/var/www/geosector/api/logs/` avec le format : `email_queue_20250820.log`, `email_queue_20250821.log`, etc. Les logs de plus de 30 jours sont supprimés automatiquement.
### 4⃣ Surveillance post-déploiement
Pendant les premières heures après la mise en production :
```bash
# Surveiller les logs en temps réel (fichier du jour)
tail -f /var/www/geosector/api/logs/email_queue_$(date +%Y%m%d).log
# Vérifier le statut de la queue
php scripts/cron/test_email_queue.php
# Compter les emails traités
mysql -u geo_app_user_prod -p geo_app -e "
SELECT status, COUNT(*) as count
FROM email_queue
WHERE DATE(created_at) = CURDATE()
GROUP BY status;"
# Vérifier les erreurs éventuelles
mysql -u geo_app_user_prod -p geo_app -e "
SELECT id, to_email, subject, attempts, error_message
FROM email_queue
WHERE status='failed'
ORDER BY created_at DESC
LIMIT 10;"
```
---
## 🚨 ROLLBACK (si nécessaire)
En cas de problème, voici comment revenir en arrière :
```bash
# 1. Stopper le cron
crontab -e
# Commenter la ligne du process_email_queue
# 2. Marquer les emails en attente pour traitement manuel
mysql -u geo_app_user_prod -p geo_app -e "
UPDATE email_queue
SET status='pending', attempts=0
WHERE status='failed' AND DATE(created_at) = CURDATE();"
# 3. Informer l'équipe pour traitement manuel si nécessaire
```
---
## 📊 VALIDATION POST-DÉPLOIEMENT
### Critères de succès :
- [ ] Aucune erreur dans les logs
- [ ] Les emails sont envoyés dans les 5 minutes
- [ ] Les reçus PDF sont correctement attachés
- [ ] Le champ `date_sent_recu` est mis à jour dans `ope_pass`
- [ ] Pas d'accumulation d'emails en status 'pending'
### Commandes de vérification :
```bash
# Statistiques générales
mysql -u geo_app_user_prod -p geo_app -e "
SELECT
status,
COUNT(*) as count,
MIN(created_at) as oldest,
MAX(created_at) as newest
FROM email_queue
GROUP BY status;"
# Vérifier les passages avec reçus envoyés aujourd'hui
mysql -u geo_app_user_prod -p geo_app -e "
SELECT COUNT(*) as recus_envoyes_aujourdhui
FROM ope_pass
WHERE DATE(date_sent_recu) = CURDATE();"
# Performance du cron (dernières exécutions du jour)
tail -20 /var/www/geosector/api/logs/email_queue_$(date +%Y%m%d).log | grep "Traitement terminé"
```
---
## 📞 CONTACTS EN CAS DE PROBLÈME
- **Responsable technique** : _____________
- **DBA** : _____________
- **Support O2Switch** : support@o2switch.fr
---
## 📋 NOTES IMPORTANTES
1. **Limite d'envoi** : 1500 emails/heure max (limite O2Switch)
2. **Batch size** : 50 emails par exécution (toutes les 5 min = 600/heure max)
3. **Lock file** : `/tmp/process_email_queue.lock` empêche l'exécution simultanée
4. **Nettoyage auto** : Les emails envoyés > 30 jours sont supprimés automatiquement
## 🔒 SÉCURITÉ
- Les mots de passe SMTP ne sont jamais loggués
- Les emails en erreur conservent le message d'erreur pour diagnostic
- Le PDF est envoyé en pièce jointe encodée en base64
---
## ✅ CHECKLIST FINALE
### Email Queue :
- [ ] Table email_queue mise à jour (sent_at, error_message, index)
- [ ] Scripts cron testés avec succès
- [ ] Cron configuré et actif
- [ ] Logs accessibles et fonctionnels
- [ ] Premier batch d'emails envoyé avec succès
### Permissions Suppression Passages :
- [ ] Champ chk_user_delete_pass ajouté dans la table entites
- [ ] EntiteController.php mis à jour pour gérer le nouveau champ
- [ ] LoginController.php mis à jour pour retourner le champ dans amicale
- [ ] Test de modification de permissions via l'interface admin
### Général :
- [ ] Documentation mise à jour
- [ ] Équipe informée de la mise en production
---
**Date de mise en production** : _______________
**Validé par** : _______________
**Signature** : _______________

View File

@@ -1,149 +0,0 @@
# Instructions de mise en place du CRON pour la queue d'emails
## Problème résolu
Les emails de reçus étaient insérés dans la table `email_queue` mais n'étaient jamais envoyés car il manquait le script de traitement.
## Fichiers créés
1. `/scripts/cron/process_email_queue.php` - Script principal de traitement
2. `/scripts/cron/test_email_queue.php` - Script de test/diagnostic
3. `/scripts/sql/add_email_queue_fields.sql` - Migration SQL pour les champs manquants
## Installation sur les serveurs (DVA, REC, PROD)
### 1. Appliquer la migration SQL
Se connecter à la base de données et exécuter :
```bash
mysql -u [user] -p [database] < /path/to/api/scripts/sql/add_email_queue_fields.sql
```
Ou directement dans MySQL :
```sql
-- Ajouter les champs manquants
ALTER TABLE `email_queue`
ADD COLUMN IF NOT EXISTS `sent_at` TIMESTAMP NULL DEFAULT NULL AFTER `status`;
ALTER TABLE `email_queue`
ADD COLUMN IF NOT EXISTS `error_message` TEXT NULL DEFAULT NULL AFTER `attempts`;
-- Ajouter les index pour les performances
ALTER TABLE `email_queue`
ADD INDEX IF NOT EXISTS `idx_status_attempts` (`status`, `attempts`);
ALTER TABLE `email_queue`
ADD INDEX IF NOT EXISTS `idx_sent_at` (`sent_at`);
```
### 2. Tester le script
Avant de mettre en place le cron, tester que tout fonctionne :
```bash
# Vérifier l'état de la queue
php /path/to/api/scripts/cron/test_email_queue.php
# Tester l'envoi (traite jusqu'à 50 emails)
php /path/to/api/scripts/cron/process_email_queue.php
```
### 3. Configurer le CRON
Ajouter la ligne suivante dans le crontab du serveur :
```bash
# Éditer le crontab
crontab -e
# Ajouter cette ligne (exécution toutes les 5 minutes)
*/5 * * * * /usr/bin/php /path/to/api/scripts/cron/process_email_queue.php >> /var/log/email_queue.log 2>&1
```
**Options de fréquence :**
- `*/5 * * * *` - Toutes les 5 minutes (recommandé)
- `*/10 * * * *` - Toutes les 10 minutes
- `*/2 * * * *` - Toutes les 2 minutes (si volume important)
### 4. Monitoring
Le script génère des logs via `LogService`. Vérifier les logs dans :
- `/path/to/api/logs/` (selon la configuration)
Points à surveiller :
- Nombre d'emails traités
- Emails en échec après 3 tentatives
- Erreurs de connexion SMTP
### 5. Configuration SMTP
Vérifier que la configuration SMTP est correcte dans `AppConfig` :
- Host SMTP
- Port (587 pour TLS, 465 pour SSL)
- Username/Password
- Encryption (tls ou ssl)
- From Email/Name
## Fonctionnement du script
### Caractéristiques
- **Batch size** : 50 emails par exécution
- **Max tentatives** : 3 essais par email
- **Lock file** : Empêche l'exécution simultanée
- **Nettoyage** : Supprime les emails envoyés > 30 jours
- **Pause** : 0.5s entre chaque email (anti-spam)
### Workflow
1. Récupère les emails avec `status = 'pending'` et `attempts < 3`
2. Pour chaque email :
- Incrémente le compteur de tentatives
- Envoie via PHPMailer avec la config SMTP
- Si succès : `status = 'sent'` + mise à jour du passage
- Si échec : réessai à la prochaine exécution
- Après 3 échecs : `status = 'failed'`
### Tables mises à jour
- `email_queue` : status, attempts, sent_at, error_message
- `ope_pass` : date_sent_recu, chk_email_sent
## Commandes utiles
```bash
# Voir les emails en attente
mysql -e "SELECT COUNT(*) FROM email_queue WHERE status='pending'" [database]
# Voir les emails échoués
mysql -e "SELECT * FROM email_queue WHERE status='failed' ORDER BY created_at DESC LIMIT 10" [database]
# Réinitialiser un email échoué pour réessai
mysql -e "UPDATE email_queue SET status='pending', attempts=0 WHERE id=[ID]" [database]
# Voir les logs du cron
tail -f /var/log/email_queue.log
# Vérifier que le cron est actif
crontab -l | grep process_email_queue
```
## Troubleshooting
### Le cron ne s'exécute pas
- Vérifier les permissions : `chmod +x process_email_queue.php`
- Vérifier le chemin PHP : `which php`
- Vérifier les logs système : `/var/log/syslog` ou `/var/log/cron`
### Emails en échec
- Vérifier la config SMTP avec `test_email_queue.php`
- Vérifier les logs pour les messages d'erreur
- Tester la connexion SMTP : `telnet [smtp_host] [port]`
### Lock bloqué
Si le message "Le processus est déjà en cours" persiste :
```bash
rm /tmp/process_email_queue.lock
```
## Contact support
En cas de problème, vérifier :
1. Les logs de l'application
2. La table `email_queue` pour les messages d'erreur
3. La configuration SMTP dans AppConfig

View File

@@ -1,464 +0,0 @@
# 🔧 Migration Backend Stripe - Option A (Tout en 1)
## 📋 Objectif
Optimiser la création de compte Stripe Connect en **1 seule requête** côté Flutter qui crée :
1. Le compte Stripe Connect
2. La Location Terminal
3. Le lien d'onboarding
---
## 🗄️ 1. Modification de la base de données
### **Ajouter la colonne `stripe_location_id`**
```sql
ALTER TABLE amicales
ADD COLUMN stripe_location_id VARCHAR(255) NULL
AFTER stripe_id;
```
**Vérification** :
```sql
DESCRIBE amicales;
```
Doit afficher :
```
+-------------------+--------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+-------------------+--------------+------+-----+---------+-------+
| stripe_id | varchar(255) | YES | | NULL | |
| stripe_location_id| varchar(255) | YES | | NULL | |
+-------------------+--------------+------+-----+---------+-------+
```
---
## 🔧 2. Modification de l'endpoint `POST /stripe/accounts`
### **Fichier** : `app/Http/Controllers/StripeController.php` (ou similaire)
### **Méthode** : `createAccount()` ou `store()`
### **Code proposé** :
```php
<?php
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use App\Models\Amicale;
/**
* Créer un compte Stripe Connect avec Location Terminal et lien d'onboarding
*
* @param Request $request
* @return \Illuminate\Http\JsonResponse
*/
public function createStripeAccount(Request $request)
{
$request->validate([
'fk_entite' => 'required|integer|exists:amicales,id',
'return_url' => 'required|string|url',
'refresh_url' => 'required|string|url',
]);
$fkEntite = $request->fk_entite;
$amicale = Amicale::findOrFail($fkEntite);
// Vérifier si un compte existe déjà
if (!empty($amicale->stripe_id)) {
return $this->handleExistingAccount($amicale, $request);
}
DB::beginTransaction();
try {
// Configurer la clé Stripe (selon environnement)
\Stripe\Stripe::setApiKey(config('services.stripe.secret'));
// 1⃣ Créer le compte Stripe Connect Express
$account = \Stripe\Account::create([
'type' => 'express',
'country' => 'FR',
'email' => $amicale->email,
'business_type' => 'non_profit', // ou 'company' selon le cas
'business_profile' => [
'name' => $amicale->name,
'url' => config('app.url'),
],
'capabilities' => [
'card_payments' => ['requested' => true],
'transfers' => ['requested' => true],
],
]);
\Log::info('Stripe account created', [
'amicale_id' => $amicale->id,
'account_id' => $account->id,
]);
// 2⃣ Créer la Location Terminal pour Tap to Pay
$location = \Stripe\Terminal\Location::create([
'display_name' => $amicale->name,
'address' => [
'line1' => $amicale->adresse1 ?: 'Non renseigné',
'line2' => $amicale->adresse2,
'city' => $amicale->ville ?: 'Non renseigné',
'postal_code' => $amicale->code_postal ?: '00000',
'country' => 'FR',
],
], [
'stripe_account' => $account->id, // ← Important : Connect account
]);
\Log::info('Stripe Terminal Location created', [
'amicale_id' => $amicale->id,
'location_id' => $location->id,
]);
// 3⃣ Créer le lien d'onboarding
$accountLink = \Stripe\AccountLink::create([
'account' => $account->id,
'refresh_url' => $request->refresh_url,
'return_url' => $request->return_url,
'type' => 'account_onboarding',
]);
\Log::info('Stripe onboarding link created', [
'amicale_id' => $amicale->id,
'account_id' => $account->id,
]);
// 4⃣ Sauvegarder TOUT en base de données
$amicale->stripe_id = $account->id;
$amicale->stripe_location_id = $location->id;
$amicale->chk_stripe = true;
$amicale->save();
DB::commit();
// 5⃣ Retourner TOUTES les informations
return response()->json([
'success' => true,
'account_id' => $account->id,
'location_id' => $location->id,
'onboarding_url' => $accountLink->url,
'charges_enabled' => $account->charges_enabled,
'payouts_enabled' => $account->payouts_enabled,
'existing' => false,
'message' => 'Compte Stripe Connect créé avec succès',
], 201);
} catch (\Stripe\Exception\ApiErrorException $e) {
DB::rollBack();
\Log::error('Stripe API error', [
'amicale_id' => $amicale->id,
'error' => $e->getMessage(),
'type' => get_class($e),
]);
return response()->json([
'success' => false,
'message' => 'Erreur Stripe : ' . $e->getMessage(),
], 500);
} catch (\Exception $e) {
DB::rollBack();
\Log::error('Stripe account creation failed', [
'amicale_id' => $amicale->id,
'error' => $e->getMessage(),
'trace' => $e->getTraceAsString(),
]);
return response()->json([
'success' => false,
'message' => 'Erreur lors de la création du compte Stripe',
], 500);
}
}
/**
* Gérer le cas d'un compte Stripe existant
*/
private function handleExistingAccount(Amicale $amicale, Request $request)
{
try {
\Stripe\Stripe::setApiKey(config('services.stripe.secret'));
// Récupérer les infos du compte existant
$account = \Stripe\Account::retrieve($amicale->stripe_id);
// Si pas de location_id, la créer maintenant
if (empty($amicale->stripe_location_id)) {
$location = \Stripe\Terminal\Location::create([
'display_name' => $amicale->name,
'address' => [
'line1' => $amicale->adresse1 ?: 'Non renseigné',
'city' => $amicale->ville ?: 'Non renseigné',
'postal_code' => $amicale->code_postal ?: '00000',
'country' => 'FR',
],
], [
'stripe_account' => $amicale->stripe_id,
]);
$amicale->stripe_location_id = $location->id;
$amicale->save();
\Log::info('Location created for existing account', [
'amicale_id' => $amicale->id,
'location_id' => $location->id,
]);
}
// Si le compte est déjà complètement configuré
if ($account->charges_enabled && $account->payouts_enabled) {
return response()->json([
'success' => true,
'account_id' => $amicale->stripe_id,
'location_id' => $amicale->stripe_location_id,
'onboarding_url' => null,
'charges_enabled' => true,
'payouts_enabled' => true,
'existing' => true,
'message' => 'Compte Stripe déjà configuré et actif',
]);
}
// Compte existant mais configuration incomplète : générer un nouveau lien
$accountLink = \Stripe\AccountLink::create([
'account' => $amicale->stripe_id,
'refresh_url' => $request->refresh_url,
'return_url' => $request->return_url,
'type' => 'account_onboarding',
]);
return response()->json([
'success' => true,
'account_id' => $amicale->stripe_id,
'location_id' => $amicale->stripe_location_id,
'onboarding_url' => $accountLink->url,
'charges_enabled' => $account->charges_enabled,
'payouts_enabled' => $account->payouts_enabled,
'existing' => true,
'message' => 'Compte existant, configuration à finaliser',
]);
} catch (\Exception $e) {
\Log::error('Error handling existing account', [
'amicale_id' => $amicale->id,
'error' => $e->getMessage(),
]);
return response()->json([
'success' => false,
'message' => 'Erreur lors de la vérification du compte existant',
], 500);
}
}
```
---
## 📡 3. Modification de l'endpoint `GET /stripe/accounts/{id}/status`
Ajouter `location_id` dans la réponse :
```php
public function checkAccountStatus($amicaleId)
{
$amicale = Amicale::findOrFail($amicaleId);
if (empty($amicale->stripe_id)) {
return response()->json([
'has_account' => false,
'account_id' => null,
'location_id' => null,
'charges_enabled' => false,
'payouts_enabled' => false,
'onboarding_completed' => false,
]);
}
try {
\Stripe\Stripe::setApiKey(config('services.stripe.secret'));
$account = \Stripe\Account::retrieve($amicale->stripe_id);
return response()->json([
'has_account' => true,
'account_id' => $amicale->stripe_id,
'location_id' => $amicale->stripe_location_id, // ← Ajouté
'charges_enabled' => $account->charges_enabled,
'payouts_enabled' => $account->payouts_enabled,
'onboarding_completed' => $account->details_submitted,
]);
} catch (\Exception $e) {
return response()->json([
'has_account' => false,
'error' => $e->getMessage(),
], 500);
}
}
```
---
## 🗑️ 4. Endpoint à SUPPRIMER (devenu inutile)
### **❌ `POST /stripe/locations`**
Cet endpoint n'est plus nécessaire car la Location est créée automatiquement dans `POST /stripe/accounts`.
**Option 1** : Supprimer complètement
**Option 2** : Le garder pour compatibilité temporaire (si utilisé ailleurs)
---
## 📝 5. Modification du modèle Eloquent
### **Fichier** : `app/Models/Amicale.php`
Ajouter le champ `stripe_location_id` :
```php
protected $fillable = [
// ... autres champs
'stripe_id',
'stripe_location_id', // ← Ajouté
'chk_stripe',
];
protected $casts = [
'chk_stripe' => 'boolean',
];
```
---
## ✅ 6. Tests à effectuer
### **Test 1 : Nouvelle amicale**
```bash
curl -X POST http://localhost/api/stripe/accounts \
-H "Content-Type: application/json" \
-H "Authorization: Bearer {token}" \
-d '{
"fk_entite": 123,
"return_url": "https://app.geosector.fr/stripe/success",
"refresh_url": "https://app.geosector.fr/stripe/refresh"
}'
```
**Réponse attendue** :
```json
{
"success": true,
"account_id": "acct_xxxxxxxxxxxxx",
"location_id": "tml_xxxxxxxxxxxxx",
"onboarding_url": "https://connect.stripe.com/setup/...",
"charges_enabled": false,
"payouts_enabled": false,
"existing": false,
"message": "Compte Stripe Connect créé avec succès"
}
```
### **Test 2 : Amicale avec compte existant**
```bash
curl -X POST http://localhost/api/stripe/accounts \
-H "Content-Type: application/json" \
-H "Authorization: Bearer {token}" \
-d '{
"fk_entite": 456,
"return_url": "https://app.geosector.fr/stripe/success",
"refresh_url": "https://app.geosector.fr/stripe/refresh"
}'
```
**Réponse attendue** :
```json
{
"success": true,
"account_id": "acct_xxxxxxxxxxxxx",
"location_id": "tml_xxxxxxxxxxxxx",
"onboarding_url": null,
"charges_enabled": true,
"payouts_enabled": true,
"existing": true,
"message": "Compte Stripe déjà configuré et actif"
}
```
### **Test 3 : Vérifier la BDD**
```sql
SELECT id, name, stripe_id, stripe_location_id, chk_stripe
FROM amicales
WHERE id = 123;
```
**Résultat attendu** :
```
+-----+------------------+-------------------+-------------------+------------+
| id | name | stripe_id | stripe_location_id| chk_stripe |
+-----+------------------+-------------------+-------------------+------------+
| 123 | Pompiers Paris15 | acct_xxxxxxxxxxxxx| tml_xxxxxxxxxxxxx | 1 |
+-----+------------------+-------------------+-------------------+------------+
```
---
## 🚀 7. Déploiement
### **Étapes** :
1. ✅ Appliquer la migration SQL
2. ✅ Déployer le code Backend modifié
3. ✅ Tester avec Postman/curl
4. ✅ Déployer le code Flutter modifié
5. ✅ Tester le flow complet depuis l'app
---
## 📊 Comparaison Avant/Après
| Aspect | Avant | Après |
|--------|-------|-------|
| **Appels API Flutter → Backend** | 3 | 1 |
| **Appels Backend → Stripe** | 3 | 3 (mais atomiques) |
| **Latence totale** | ~3-5s | ~1-2s |
| **Gestion erreurs** | Complexe | Simplifié avec transaction |
| **Atomicité** | ❌ Non | ✅ Oui (DB transaction) |
| **Location ID sauvegardé** | ❌ Non | ✅ Oui |
---
## 🎯 Bénéfices
1.**Performance** : Latence divisée par 2-3
2.**Fiabilité** : Transaction BDD garantit la cohérence
3.**Simplicité** : Code Flutter plus simple
4.**Maintenance** : Moins de code à maintenir
5.**Traçabilité** : Logs centralisés côté Backend
6.**Tap to Pay prêt** : `location_id` disponible immédiatement
---
## ⚠️ Points d'attention
1. **Rollback** : Si la transaction échoue, rien n'est sauvegardé (bon comportement)
2. **Logs** : Bien logger chaque étape pour le debug
3. **Stripe Connect limitations** : Respecter les rate limits Stripe
4. **Tests** : Tester avec des comptes Stripe de test d'abord
---
## 📚 Ressources
- [Stripe Connect Express Accounts](https://stripe.com/docs/connect/express-accounts)
- [Stripe Terminal Locations](https://stripe.com/docs/terminal/fleet/locations)
- [Stripe Account Links](https://stripe.com/docs/connect/account-links)

View File

@@ -1,343 +0,0 @@
# Flow de paiement Stripe Tap to Pay
## Vue d'ensemble
Ce document décrit le flow complet pour les paiements Stripe Tap to Pay dans l'application GeoSector, depuis la création du compte Stripe Connect jusqu'au paiement final.
---
## 🏢 PRÉALABLE : Création d'un compte Amicale Stripe Connect
Avant de pouvoir utiliser les paiements Stripe, chaque amicale doit créer son compte Stripe Connect.
### 📋 Flow de création du compte
#### 1. Initiation depuis l'application web admin
**Endpoint :** `POST /api/stripe/accounts/create`
**Requête :**
```json
{
"amicale_id": 45,
"type": "express", // Type de compte Stripe Connect
"country": "FR",
"email": "contact@amicale-pompiers-paris.fr",
"business_profile": {
"name": "Amicale des Pompiers de Paris",
"product_description": "Vente de calendriers des pompiers",
"mcc": "8398", // Code activité : organisations civiques
"url": "https://www.amicale-pompiers-paris.fr"
}
}
```
#### 2. Création du compte Stripe
**Actions API :**
1. Appel Stripe API pour créer un compte Express
2. Génération d'un lien d'onboarding personnalisé
3. Sauvegarde en base de données
**Réponse :**
```json
{
"success": true,
"stripe_account_id": "acct_1O3ABC456DEF789",
"onboarding_url": "https://connect.stripe.com/express/oauth/authorize?...",
"status": "pending"
}
```
#### 3. Processus d'onboarding Stripe
**Actions utilisateur (dirigeant amicale) :**
1. Clic sur le lien d'onboarding
2. Connexion/création compte Stripe
3. Saisie des informations légales :
- **Entité** : Association loi 1901
- **SIRET** de l'amicale
- **RIB** pour les virements
- **Pièce d'identité** du représentant légal
4. Validation des conditions d'utilisation
#### 4. Vérification et activation
**Webhook Stripe → API :**
```json
POST /api/stripe/webhooks
{
"type": "account.updated",
"data": {
"object": {
"id": "acct_1O3ABC456DEF789",
"charges_enabled": true,
"payouts_enabled": true,
"details_submitted": true
}
}
}
```
**Actions API :**
1. Mise à jour du statut en base
2. Notification email à l'amicale
3. Activation des fonctionnalités de paiement
#### 5. Structure en base de données
**Table `stripe_accounts` :**
```sql
CREATE TABLE `stripe_accounts` (
`id` int(10) unsigned NOT NULL AUTO_INCREMENT,
`fk_entite` int(10) unsigned NOT NULL,
`stripe_account_id` varchar(50) NOT NULL,
`account_type` enum('express','standard','custom') DEFAULT 'express',
`charges_enabled` tinyint(1) DEFAULT 0,
`payouts_enabled` tinyint(1) DEFAULT 0,
`details_submitted` tinyint(1) DEFAULT 0,
`country` varchar(2) DEFAULT 'FR',
`default_currency` varchar(3) DEFAULT 'eur',
`business_name` varchar(255) DEFAULT NULL,
`support_email` varchar(255) DEFAULT NULL,
`onboarding_completed_at` timestamp NULL DEFAULT NULL,
`created_at` timestamp NOT NULL DEFAULT current_timestamp(),
`updated_at` timestamp NULL DEFAULT NULL ON UPDATE current_timestamp(),
PRIMARY KEY (`id`),
UNIQUE KEY `stripe_account_id` (`stripe_account_id`),
KEY `fk_entite` (`fk_entite`),
CONSTRAINT `stripe_accounts_ibfk_1` FOREIGN KEY (`fk_entite`) REFERENCES `entites` (`id`)
);
```
### 🔐 Sécurité et validation
#### Prérequis pour créer un compte :
- ✅ Utilisateur administrateur de l'amicale
- ✅ Amicale active avec statut validé
- ✅ Email de contact vérifié
- ✅ Informations légales complètes (SIRET, adresse)
#### Validation avant paiements :
-`charges_enabled = 1` (peut recevoir des paiements)
-`payouts_enabled = 1` (peut recevoir des virements)
-`details_submitted = 1` (onboarding terminé)
### 📊 États du compte Stripe
| État | Description | Actions possibles |
|------|-------------|-------------------|
| `pending` | Compte créé, onboarding en cours | Compléter l'onboarding |
| `restricted` | Informations manquantes | Fournir documents manquants |
| `restricted_soon` | Vérification en cours | Attendre validation Stripe |
| `active` | Compte opérationnel | Recevoir des paiements ✅ |
| `rejected` | Compte refusé par Stripe | Contacter support |
### 🚨 Gestion des erreurs
#### Erreurs courantes lors de la création :
- **400** : Données manquantes ou invalides
- **409** : Compte Stripe déjà existant pour cette amicale
- **403** : Utilisateur non autorisé
#### Erreurs durant l'onboarding :
- Documents manquants ou invalides
- Informations bancaires incorrectes
- Activité non autorisée par Stripe
### 📞 Support et résolution
#### Pour les amicales :
1. **Email support** : support@geosector.fr
2. **Documentation** : Guides d'onboarding disponibles
3. **Assistance téléphonique** : Disponible aux heures ouvrables
#### Pour les développeurs :
1. **Stripe Dashboard** : Accès aux comptes et statuts
2. **Logs API** : Traçabilité complète des opérations
3. **Webhook monitoring** : Suivi des événements Stripe
---
## 🚨 IMPORTANT : Nouveau Flow (v2)
**Le passage est TOUJOURS créé/modifié EN PREMIER** pour obtenir un ID réel, PUIS le PaymentIntent est créé avec cet ID.
## Flow détaillé
### 1. Sauvegarde du passage EN PREMIER
L'application crée ou modifie d'abord le passage pour obtenir un ID réel :
```
POST /api/passages/create // Nouveau passage
PUT /api/passages/456 // Mise à jour passage existant
```
**Réponse avec l'ID réel :**
```json
{
"status": "success",
"passage_id": 456 // ID RÉEL du passage créé/modifié
}
```
### 2. Création du PaymentIntent AVEC l'ID réel
Ensuite seulement, création du PaymentIntent avec le `passage_id` réel :
```
POST /api/stripe/payments/create-intent
```
```json
{
"amount": 2500, // En centimes (25€)
"passage_id": 456, // ID RÉEL du passage (JAMAIS 0)
"payment_method_types": ["card_present"], // Tap to Pay
"location_id": "tml_xxx", // Terminal reader location
"amicale_id": 45,
"member_id": 67,
"stripe_account": "acct_xxx"
}
```
#### Réponse
```json
{
"status": "success",
"data": {
"client_secret": "pi_3QaXYZ_secret_xyz",
"payment_intent_id": "pi_3QaXYZ123ABC456",
"amount": 2500,
"currency": "eur",
"passage_id": 789, // 0 pour nouveau passage
"type": "tap_to_pay"
}
}
```
### 2. Traitement du paiement côté client
L'application utilise le SDK Stripe pour traiter le paiement via NFC :
```dart
// Flutter - Utilisation du client_secret
final paymentResult = await stripe.collectPaymentMethod(
clientSecret: response['client_secret'],
// ... configuration Tap to Pay
);
```
### 3. Traitement du paiement Tap to Pay
L'application utilise le SDK Stripe Terminal avec le `client_secret` pour collecter le paiement via NFC.
### 4. Mise à jour du passage avec stripe_payment_id
Après succès du paiement, l'app met à jour le passage avec le `stripe_payment_id` :
```json
PUT /api/passages/456
{
"stripe_payment_id": "pi_3QaXYZ123ABC456", // ← LIEN AVEC STRIPE
// ... autres champs si nécessaire
}
```
## Points clés du nouveau flow
### ✅ Avantages
1. **Passage toujours existant** : Le passage existe toujours avec un ID réel avant le paiement
2. **Traçabilité garantie** : Le `passage_id` dans Stripe est toujours valide
3. **Gestion d'erreur robuste** : Si le paiement échoue, le passage existe déjà
4. **Cohérence des données** : Pas de passage "orphelin" ou de paiement sans passage
### ❌ Ce qui n'est plus supporté
1. **passage_id=0** : Plus jamais utilisé dans `/create-intent`
2. **operation_id** : Plus nécessaire car le passage existe déjà
3. **Création conditionnelle** : Le passage est toujours créé avant
## Schéma de séquence (Nouveau Flow v2)
```
┌─────────┐ ┌─────────┐ ┌────────┐ ┌────────────┐
│ App │ │ API │ │ Stripe │ │ ope_pass │
└────┬────┘ └────┬────┘ └────┬───┘ └─────┬──────┘
│ │ │ │
│ 1. CREATE/UPDATE passage │ │
├──────────────>│ │ │
│ ├────────────────┼───────────────>│
│ │ │ INSERT/UPDATE │
│ │ │ │
│ 2. passage_id: 456 (réel) │ │
│<──────────────│ │ │
│ │ │ │
│ 3. create-intent (id=456) │ │
├──────────────>│ │ │
│ │ │ │
│ │ 4. Create PI │ │
│ ├───────────────>│ │
│ │ │ │
│ │ 5. PI created │ │
│ │<───────────────│ │
│ │ │ │
│ │ 6. UPDATE │ │
│ ├────────────────┼───────────────>│
│ │ stripe_payment_id = pi_xxx │
│ │ │ │
│ 7. client_secret + pi_id │ │
│<──────────────│ │ │
│ │ │ │
│ 8. Tap to Pay │ │ │
├───────────────┼───────────────>│ │
│ avec SDK │ │ │
│ │ │ │
│ 9. Payment OK │ │ │
│<──────────────┼────────────────│ │
│ │ │ │
│ 10. UPDATE passage (optionnel) │ │
├──────────────>│ │ │
│ ├────────────────┼───────────────>│
│ │ Confirmer stripe_payment_id │
│ │ │ │
│ 11. Success │ │ │
│<──────────────│ │ │
│ │ │ │
```
## Points importants (Nouveau Flow v2)
1. **Passage créé en premier** : Le passage est TOUJOURS créé/modifié AVANT le PaymentIntent
2. **ID réel obligatoire** : Le `passage_id` ne peut jamais être 0 dans `/create-intent`
3. **Lien Stripe automatique** : Le `stripe_payment_id` est ajouté automatiquement lors de la création du PaymentIntent
4. **Idempotence** : Un passage ne peut avoir qu'un seul `stripe_payment_id`
5. **Validation stricte** : Vérification du montant, propriété et existence du passage
## Erreurs possibles
- **400** :
- `passage_id` manquant ou ≤ 0
- Montant invalide (< 1 ou > 999€)
- Passage déjà payé par Stripe
- Montant ne correspond pas au passage
- **401** : Non authentifié
- **403** : Passage non autorisé (pas le bon utilisateur)
- **404** : Passage non trouvé
## Migration base de données
La colonne `stripe_payment_id VARCHAR(50)` a été ajoutée via :
```sql
ALTER TABLE `ope_pass` ADD COLUMN `stripe_payment_id` VARCHAR(50) DEFAULT NULL;
ALTER TABLE `ope_pass` ADD INDEX `idx_stripe_payment` (`stripe_payment_id`);
```
## Environnements
- **DEV** : dva-geo sur IN3 - Base mise à jour ✅
- **REC** : rca-geo sur IN3 - Base mise à jour ✅
- **PROD** : pra-geo sur IN4 - À mettre à jour

View File

@@ -1,197 +0,0 @@
# Stripe Tap to Pay - Requirements officiels
> Document basé sur la documentation officielle Stripe - Dernière vérification : 29 septembre 2025
## 📱 iOS - Tap to Pay sur iPhone
### Configuration minimum requise
| Composant | Requirement | Notes |
|-----------|------------|--------|
| **Appareil** | iPhone XS ou plus récent | iPhone XS, XR, 11, 12, 13, 14, 15, 16 |
| **iOS** | iOS 16.4 ou plus récent | Pour support PIN complet |
| **SDK** | Terminal iOS SDK 2.23.0+ | Version 3.6.0+ pour Interac (Canada) |
| **Entitlement** | Apple Tap to Pay | À demander sur Apple Developer |
### Fonctionnalités par version iOS
- **iOS 16.0-16.3** : Tap to Pay basique (sans PIN)
- **iOS 16.4+** : Support PIN complet pour toutes les cartes
- **Versions beta** : NON SUPPORTÉES
### Méthodes de paiement supportées
- ✅ Cartes sans contact : Visa, Mastercard, American Express
- ✅ Wallets NFC : Apple Pay, Google Pay, Samsung Pay
- ✅ Discover (USA uniquement)
- ✅ Interac (Canada uniquement, SDK 3.6.0+)
- ✅ eftpos (Australie uniquement)
### Limitations importantes
- ❌ iPad non supporté (pas de NFC)
- ❌ Puerto Rico non disponible
- ❌ Versions iOS beta non supportées
## 🤖 Android - Tap to Pay
### Configuration minimum requise
| Composant | Requirement | Notes |
|-----------|------------|--------|
| **Android** | Android 11 ou plus récent | API level 30+ |
| **NFC** | Capteur NFC fonctionnel | Obligatoire |
| **Processeur** | ARM | x86 non supporté |
| **Sécurité** | Appareil non rooté | Bootloader verrouillé |
| **Services** | Google Mobile Services | GMS obligatoire |
| **Keystore** | Hardware keystore intégré | Pour sécurité |
| **OS** | OS constructeur non modifié | Pas de ROM custom |
### Appareils certifiés en France (liste non exhaustive)
#### Samsung
- Galaxy S21, S21+, S21 Ultra, S21 FE (Android 11+)
- Galaxy S22, S22+, S22 Ultra (Android 12+)
- Galaxy S23, S23+, S23 Ultra, S23 FE (Android 13+)
- Galaxy S24, S24+, S24 Ultra (Android 14+)
- Galaxy Z Fold 3, 4, 5, 6
- Galaxy Z Flip 3, 4, 5, 6
- Galaxy Note 20, Note 20 Ultra
- Galaxy A54, A73 (haut de gamme)
#### Google Pixel
- Pixel 6, 6 Pro, 6a (Android 12+)
- Pixel 7, 7 Pro, 7a (Android 13+)
- Pixel 8, 8 Pro, 8a (Android 14+)
- Pixel 9, 9 Pro, 9 Pro XL (Android 14+)
- Pixel Fold (Android 13+)
- Pixel Tablet (Android 13+)
#### OnePlus
- OnePlus 9, 9 Pro (Android 11+)
- OnePlus 10 Pro, 10T (Android 12+)
- OnePlus 11, 11R (Android 13+)
- OnePlus 12, 12R (Android 14+)
- OnePlus Open (Android 13+)
#### Xiaomi
- Mi 11, 11 Ultra (Android 11+)
- Xiaomi 12, 12 Pro, 12T Pro (Android 12+)
- Xiaomi 13, 13 Pro, 13T Pro (Android 13+)
- Xiaomi 14, 14 Pro, 14 Ultra (Android 14+)
#### Autres marques
- OPPO Find X3/X5/X6 Pro, Find N2/N3
- Realme GT 2 Pro, GT 3, GT 5 Pro
- Honor Magic5/6 Pro, 90
- ASUS Zenfone 9/10, ROG Phone 7
- Nothing Phone (1), (2), (2a)
## 🌍 Disponibilité par pays
### Europe
- ✅ France : Disponible
- ✅ Royaume-Uni : Disponible
- ✅ Allemagne : Disponible
- ✅ Pays-Bas : Disponible
- ✅ Irlande : Disponible
- ✅ Italie : Disponible (récent)
- ✅ Espagne : Disponible (récent)
### Amérique
- ✅ États-Unis : Disponible (+ Discover)
- ✅ Canada : Disponible (+ Interac)
- ❌ Puerto Rico : Non disponible
- ❌ Mexique : Non disponible
### Asie-Pacifique
- ✅ Australie : Disponible (+ eftpos)
- ✅ Nouvelle-Zélande : Disponible
- ✅ Singapour : Disponible
- ✅ Japon : Disponible (récent)
## 🔧 Intégration technique
### SDK Requirements
```javascript
// iOS
pod 'StripeTerminal', '~> 2.23.0' // Minimum pour Tap to Pay
pod 'StripeTerminal', '~> 3.6.0' // Pour support Interac
// Android
implementation 'com.stripe:stripeterminal-taptopay:3.7.1'
implementation 'com.stripe:stripeterminal-core:3.7.1'
// React Native
"@stripe/stripe-terminal-react-native": "^0.0.1-beta.17"
// Flutter
stripe_terminal: ^3.2.0
```
### Capacités requises
#### iOS Info.plist
```xml
<key>NSBluetoothAlwaysUsageDescription</key>
<string>Bluetooth nécessaire pour Tap to Pay</string>
<key>NFCReaderUsageDescription</key>
<string>NFC nécessaire pour lire les cartes</string>
<key>com.apple.developer.proximity-reader</key>
<true/>
```
#### Android Manifest
```xml
<uses-permission android:name="android.permission.NFC" />
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-feature android:name="android.hardware.nfc" android:required="true" />
```
## 📊 Limites techniques
| Limite | Valeur | Notes |
|--------|--------|-------|
| **Montant min** | 1€ / $1 | Selon devise |
| **Montant max** | Variable par pays | France : 50€ sans PIN, illimité avec PIN |
| **Timeout transaction** | 60 secondes | Après présentation carte |
| **Distance NFC** | 4cm max | Distance optimale |
| **Tentatives PIN** | 3 max | Puis carte bloquée |
## 🔐 Sécurité
### Certifications
- PCI-DSS Level 1
- EMV Contactless Level 1
- Apple ProximityReader Framework
- Google SafetyNet Attestation
### Données sensibles
- Les données de carte ne transitent JAMAIS par l'appareil
- Tokenisation end-to-end par Stripe
- Pas de stockage local des données carte
- PIN chiffré directement vers Stripe
## 📚 Ressources officielles
- [Documentation Stripe Terminal](https://docs.stripe.com/terminal)
- [Tap to Pay sur iPhone - Apple Developer](https://developer.apple.com/tap-to-pay/)
- [Guide d'intégration iOS](https://docs.stripe.com/terminal/payments/setup-reader/tap-to-pay?platform=ios)
- [Guide d'intégration Android](https://docs.stripe.com/terminal/payments/setup-reader/tap-to-pay?platform=android)
- [SDK Terminal iOS](https://github.com/stripe/stripe-terminal-ios)
- [SDK Terminal Android](https://github.com/stripe/stripe-terminal-android)
## 🔄 Historique des versions
| Date | Version iOS | Changement |
|------|-------------|------------|
| Sept 2022 | iOS 16.0 | Lancement initial Tap to Pay |
| Mars 2023 | iOS 16.4 | Ajout support PIN |
| Sept 2023 | iOS 17.0 | Améliorations performances |
| Sept 2024 | iOS 18.0 | Support étendu international |
---
*Document maintenu par l'équipe GeoSector - Dernière mise à jour : 29/09/2025*

File diff suppressed because one or more lines are too long

View File

@@ -1,175 +1,614 @@
# Documentation Technique API GeoSector
# Documentation Technique API RESTful PHP 8.3
## 🏗️ Infrastructure
## Table des matières
**Stack** : PHP 8.3 | NGINX | MariaDB 10.11 | Alpine Linux (Incus)
1. [Structure du projet](#structure-du-projet)
2. [Configuration du serveur](#configuration-du-serveur)
3. [Flux d'une requête](#flux-dune-requête)
4. [Architecture des composants](#architecture-des-composants)
5. [Base de données](#base-de-données)
6. [Sécurité](#sécurité)
7. [Endpoints API](#endpoints-api)
8. [Changements récents](#changements-récents)
| Environnement | Container | DB (IP) | URL | Serveur |
|---------------|-----------|---------|-----|---------|
| **DEV** | dva-geo | maria3 (13.23.33.4) | https://dapp.geosector.fr | IN3 (195.154.80.116) |
| **REC** | rca-geo | maria3 (13.23.33.4) | https://rapp.geosector.fr | IN3 (195.154.80.116) |
| **PROD** | pra-geo | maria4 (13.23.33.4) | https://app3.geosector.fr | IN4 (51.159.7.190) |
## Structure du projet
**Architecture** : MVC sans framework | Point d'entrée : `index.php` | Config : `AppConfig.php` singleton
## 🗄️ Base de données
### Modèle d'isolation par opération (CRITIQUE)
**Principe** : Chaque opération est un **univers fermé** isolé de la table centrale `users`.
```
users (table centrale, conservée après suppression opération)
└── ope_users (id, fk_user, fk_operation) ← PIVOT par opération
├── ope_users_sectors (fk_user → ope_users.id)
└── ope_pass (fk_user → ope_users.id)
```plaintext
/api/
├── docs/
│ └── TECHBOOK.md
├── src/
│ ├── Controllers/
│ │ └── UserController.php
│ ├── Core/
│ │ ├── Router.php
│ │ ├── Request.php
│ │ ├── Response.php
├── Session.php
└── Database.php
│ └── Config/
│ └── config.php
├── index.php
└── .htaccess
```
**⚠️ IMPORTANT pour Flutter** :
- **`users.id`** = Identifiant global (gestion membres, login)
- **`ope_users.id`** = Identifiant opération (passages, secteurs)
- **Flutter doit gérer les 2 IDs** lors du login et des CRUD
## Configuration du serveur
### Prérequis
- Debian 12
- NGINX
- PHP 8.3-FPM
- MariaDB 10.11
### Configuration NGINX
Le serveur NGINX est configuré pour rediriger toutes les requêtes vers le point d'entrée `index.php` de l'API.
### Configuration PHP-FPM
PHP-FPM est configuré pour gérer les processus PHP avec des paramètres optimisés pour une API.
## Flux d'une requête
Exemple détaillé du parcours d'une requête POST /api/users :
1. **Entrée de la requête**
- La requête arrive sur le serveur NGINX
- NGINX redirige vers PHP-FPM via le socket unix
- Le fichier .htaccess redirige vers index.php
2. **Initialisation (index.php)**
- Chargement des dépendances
- Initialisation de la configuration
- Démarrage de la session
- Configuration des headers CORS
- Initialisation du routeur
3. **Routage**
- Le Router analyse la méthode HTTP (POST)
- Analyse de l'URI (/api/users)
- Correspondance avec les routes enregistrées
- Instanciation du Controller approprié
4. **Traitement (UserController)**
- Vérification de l'authentification
- Récupération des données JSON
- Validation des données reçues
- Traitement métier
- Interaction avec la base de données
- Préparation de la réponse
5. **Réponse**
- Formatage de la réponse en JSON
- Configuration des headers de réponse
- Envoi au client
## Architecture des composants
### Core Components
#### Router
- Gère le routage des requêtes
- Associe les URLs aux Controllers
- Gère les paramètres d'URL
- Dispatch vers les méthodes appropriées
#### Request
- Parse les données entrantes
- Gère les différents types de contenu
- Nettoie et valide les entrées
- Fournit une interface unifiée pour accéder aux données
#### Response
- Formate les réponses en JSON
- Gère les codes HTTP
- Configure les headers de réponse
- Assure la cohérence des réponses
#### Session
- Gère l'état des sessions
- Stocke les données d'authentification
- Vérifie les permissions
- Sécurise les données de session
#### Database
- Gère la connexion à MariaDB
- Fournit une interface PDO
- Gère le pool de connexions
- Assure la sécurité des requêtes
## Base de données
### Structure des tables principales
#### Table `users`
- `encrypted_user_name` : Identifiant de connexion chiffré (unique)
- `encrypted_email` : Email chiffré (unique)
- `user_pass_hash` : Hash du mot de passe
- `encrypted_name`, `encrypted_phone`, `encrypted_mobile` : Données personnelles chiffrées
- Autres champs : `first_name`, `sect_name`, `fk_role`, `fk_entite`, etc.
#### Table `entites` (Amicales)
- `chk_mdp_manuel` (DEFAULT 0) : Gestion manuelle des mots de passe
- `chk_username_manuel` (DEFAULT 0) : Gestion manuelle des identifiants
- `chk_stripe` : Activation des paiements Stripe
- Données chiffrées : `encrypted_name`, `encrypted_email`, `encrypted_phone`, etc.
#### Table `medias`
- `support` : Type de support (entite, user, operation, passage)
- `support_id` : ID de l'élément associé
- `file_category` : Catégorie (logo, export, carte, etc.)
- `file_path` : Chemin complet du fichier
- `processed_width/height` : Dimensions après traitement
- Utilisée pour stocker les logos des entités
### Chiffrement des données
Toutes les données sensibles sont chiffrées avec AES-256-CBC :
- Emails, noms, téléphones
- Identifiants de connexion
- Informations bancaires (IBAN, BIC)
### Migration de base de données
Script SQL pour ajouter les nouveaux champs :
```sql
-- Ajout de la gestion manuelle des usernames
ALTER TABLE `entites`
ADD COLUMN `chk_username_manuel` tinyint(1) unsigned NOT NULL DEFAULT 0
COMMENT 'Gestion des usernames manuelle (1) ou automatique (0)'
AFTER `chk_mdp_manuel`;
-- Index pour optimiser la vérification d'unicité
ALTER TABLE `users`
ADD INDEX `idx_encrypted_user_name` (`encrypted_user_name`);
```
## Sécurité
### Mesures implémentées
- Validation stricte des entrées
- Protection contre les injections SQL (PDO)
- Hachage sécurisé des mots de passe
- Headers de sécurité HTTP
- Gestion des CORS
- Session sécurisée
- Authentification requise
- Chiffrement AES-256 des données sensibles
- Envoi séparé des identifiants par email
## Endpoints API
### Routes Publiques vs Privées
L'API distingue deux types de routes :
#### Routes Publiques
- POST /api/login
- POST /api/register
- GET /api/health
#### Routes Privées (Nécessitent une session authentifiée)
- Toutes les autres routes
### Authentification
L'authentification utilise le système de session PHP natif.
#### Login
```http
POST /api/login
Content-Type: application/json
**Réponse login :**
```json
{
"users_sectors": [
{
"id": 123, // users.id (gestion membres)
"ope_user_id": 50, // ope_users.id (passages/secteurs)
"name": "John Doe",
"fk_sector": 456
}
]
"email": "user@example.com",
"password": "SecurePassword123"
}
```
**Requêtes API depuis Flutter :**
**Réponse réussie :**
```json
// ✅ Création secteur : envoyer ope_users.id
POST /api/sectors { "users": [50, 51] } // ope_users.id
// ✅ Création passage : fk_user = ope_users.id
POST /api/passages { "fk_user": 50 } // ope_users.id
// ✅ Modification membre : utiliser users.id
PUT /api/users/123 // users.id
{
"message": "Connecté avec succès",
"user": {
"id": 123,
"email": "user@example.com"
}
}
```
### Tables principales
**Notes importantes :**
- **`entites`** : Amicales (chiffrement AES-256-CBC sur nom, email, IBAN)
- **`users`** : Table centrale utilisateurs (conservée même si opération supprimée)
- **`operations`** : Campagnes liées à une entité
- **`ope_users`** : **PIVOT** users ↔ opérations (ON DELETE CASCADE depuis operations)
- **`ope_sectors`** : Secteurs géographiques (polygones)
- **`ope_users_sectors`** : Affectation users ↔ secteurs (FK → `ope_users.id`)
- **`ope_pass`** : Passages (FK → `ope_users.id`, ON DELETE CASCADE)
- **`medias`** : Fichiers (logos, exports, reçus) - Stockage : `/uploads/`
- Un cookie de session PHP sécurisé est automatiquement créé
- Le cookie est httpOnly, secure et SameSite=Strict
- L'ID de session est régénéré à chaque login réussi
## 🔒 Sécurité
#### Logout
- **Auth** : Sessions PHP (httpOnly, secure, SameSite=Strict)
- **Mots de passe** : NIST SP 800-63B, bcrypt, HIBP check (k-anonymity)
- **Chiffrement** : AES-256-CBC (noms, emails, téléphones, IBAN)
- **Protection** : Brute force (8 tentatives/5min), IP blocking, PDO prepared statements
- **Monitoring** : `SecurityMonitor`, `AlertService`, `IPBlocker`
## 💳 Stripe Connect
- **DEV** : Clés TEST Pierre
- **REC** : Clés TEST client + webhook `webhook-rca`
- **PROD** : Clés LIVE client + webhook `webhook-pra`
- **API** : `2025-08-27.basil`
- **Tap to Pay** : iOS 16.4+ (iPhone XS+) | Android 11+ (95+ devices certifiés)
- **Flow** : Passage créé → PaymentIntent → Tap to Pay → Mise à jour `stripe_payment_id`
## 📦 Fonctionnalités
1. **Reçus fiscaux** : PDF auto (<5KB) pour dons, envoi email queue
2. **Logos entités** : Upload PNG/JPG, redimensionnement 250x250px, base64
3. **Migration** : Endpoints REST par entité (9 phases)
4. **CRONs** : Email queue (*/5), cleanup sécurité (2h), Stripe devices (dim 3h)
## 🚀 Déploiement
```bash
./deploy-api.sh # Local → dva-geo (DEV)
./deploy-api.sh rca # dva-geo → rca-geo (REC)
./deploy-api.sh pra # rca-geo → pra-geo (PROD)
```http
POST /api/logout
```
- Backup auto (10 versions)
- Préservation `/logs/` et `/uploads/`
- Permissions : `nginx:nginx` (code), `nginx:nginx` (logs/uploads)
- Composer install avec `--optimize-autoloader`
**Réponse réussie :**
## ⚠️ Points d'attention API ↔ Flutter
### 1. Isolation opérations (depuis Oct 2025)
**Avant** : `ope_pass.fk_user` `users.id` (table centrale)
**Après** : `ope_pass.fk_user` `ope_users.id` (pivot opération)
**Impact Flutter** :
- Login retourne **2 IDs** : `id` (users.id) + `ope_user_id` (ope_users.id)
- Création secteur/passage : envoyer `ope_user_id`
- Affichage passages : mapper avec `ope_user_id`
### 2. Endpoints critiques modifiés
| Endpoint | Body envoyé | Mapping |
|----------|-------------|---------|
| `POST /api/sectors` | `users: [50, 51]` | ope_users.id |
| `PUT /api/sectors/{id}` | `users: [50, 51]` | ope_users.id |
| `POST /api/passages` | `fk_user: 50` | ope_users.id |
| `PUT /api/passages/{id}` | `fk_user: 50` | ope_users.id |
| `POST /api/users` | - | Retourne `ope_user_id` |
### 3. Requête SQL typique
```sql
-- ❌ AVANT (CASSÉ)
SELECT op.*, u.encrypted_name
FROM ope_pass op
JOIN users u ON op.fk_user = u.id
-- ✅ APRÈS (CORRECT)
SELECT op.*, u.encrypted_name
FROM ope_pass op
JOIN ope_users ou ON op.fk_user = ou.id
JOIN users u ON ou.fk_user = u.id
```json
{
"message": "Déconnecté avec succès"
}
```
### 4. Suppression en cascade
### Sécurité des Sessions
```sql
DELETE FROM operations WHERE id = 850;
-- Supprime automatiquement (CASCADE) :
-- - ope_users
-- - ope_users_sectors
-- - ope_pass
-- - ope_sectors
-- ✅ users conservé (table centrale)
La configuration des sessions inclut :
- Sessions PHP natives sécurisées
- Protection contre la fixation de session
- Cookies httpOnly (protection XSS)
- Mode strict pour les cookies
- Validation côté serveur à chaque requête
- use_strict_mode = 1
- cookie_httponly = 1
- cookie_secure = 1
- cookie_samesite = Strict
- Régénération de l'ID de session après login
- Destruction complète de la session au logout
### Users
#### Création d'utilisateur
La création d'utilisateur s'adapte aux paramètres de l'entité (amicale) :
```http
POST /api/users
Content-Type: application/json
Authorization: Bearer {session_id}
{
"email": "john@example.com",
"name": "John Doe",
"first_name": "John",
"role": 1,
"fk_entite": 5,
"username": "j.doe38", // Requis si chk_username_manuel=1 pour l'entité
"password": "SecurePass123", // Requis si chk_mdp_manuel=1 pour l'entité
"phone": "0476123456",
"mobile": "0612345678",
"sect_name": "Secteur A",
"date_naissance": "1990-01-15",
"date_embauche": "2020-03-01"
}
```
## 📝 Changelog critique
**Comportement selon les paramètres de l'entité :**
**Version 3.3.7 (26 Oct 2025)** :
- 🔧 Correction bug `SectorController::update()` : Recherche users par `ope_users.id` au lieu de `users.id`
- 🔧 Permissions logs corrigées : `nginx:nginx` + `750/640`
- 🔧 PHP `display_errors = Off` (warnings loggés dans `/var/log/php83/error.log`)
| chk_username_manuel | chk_mdp_manuel | Comportement |
|---------------------|----------------|--------------|
| 0 | 0 | Username et password générés automatiquement |
| 0 | 1 | Username généré, password requis dans le payload |
| 1 | 0 | Username requis dans le payload, password généré |
| 1 | 1 | Username et password requis dans le payload |
**Version 3.3.6 (21 Oct 2025)** :
- Validation inscription : Code postal + ville (doublon)
**Validation du username (si manuel) :**
- Format : 10-30 caractères
- Commence par une lettre
- Caractères autorisés : a-z, 0-9, ., -, _
- Doit être unique dans toute la base
**Version 3.2.7 (16 Oct 2025)** :
- Migration RCA-GEO vers maria3 complétée
- URL PROD : `app3.geosector.fr`
**Réponse réussie :**
**Version 3.2.4-3.2.6 (Sep 2025)** :
- Stripe Connect complet (Tap to Pay, webhooks multi-env)
```json
{
"status": "success",
"message": "Utilisateur créé avec succès",
"id": 123,
"username": "j.doe38", // Toujours retourné
"password": "xY7#mK9@pL2" // Retourné seulement si généré automatiquement
}
```
---
**Envoi d'emails :**
- **Email 1** : Identifiant de connexion (toujours envoyé)
- **Email 2** : Mot de passe (toujours envoyé, 1 seconde après le premier)
**Mis à jour : 26 Octobre 2025**
**Codes de statut :**
- 201: Création réussie
- 400: Données invalides ou username/password manquant si requis
- 401: Non authentifié
- 403: Accès non autorisé (rôle insuffisant)
- 409: Email ou username déjà utilisé
- 500: Erreur serveur
#### Vérification de disponibilité du username
```http
POST /api/users/check-username
Content-Type: application/json
Authorization: Bearer {session_id}
{
"username": "j.doe38"
}
```
**Réponse si disponible :**
```json
{
"status": "success",
"available": true,
"message": "Nom d'utilisateur disponible",
"username": "j.doe38"
}
```
**Réponse si déjà pris :**
```json
{
"status": "success",
"available": false,
"message": "Ce nom d'utilisateur est déjà utilisé",
"suggestions": ["j.doe38_42", "j.doe381234", "j.doe3825"]
}
```
#### Autres endpoints
- GET /api/users
- GET /api/users/{id}
- PUT /api/users/{id}
- DELETE /api/users/{id}
- POST /api/users/{id}/reset-password
### Entités (Amicales)
#### Upload du logo d'une entité
```http
POST /api/entites/{id}/logo
Content-Type: multipart/form-data
Authorization: Bearer {session_id}
Body:
logo: File (image/png, image/jpeg, image/jpg)
```
**Restrictions :**
- Réservé aux administrateurs d'amicale (fk_role == 2)
- L'admin ne peut uploader que le logo de sa propre amicale
- Un seul logo actif par entité (le nouveau remplace l'ancien)
**Traitement de l'image :**
- Formats acceptés : PNG, JPG, JPEG
- Redimensionnement automatique : 250x250px maximum (ratio conservé)
- Résolution : 72 DPI (standard web)
- Préservation de la transparence pour les PNG
**Stockage :**
- Chemin : `/uploads/entites/{id}/logo/logo_{id}_{timestamp}.{ext}`
- Enregistrement dans la table `medias`
- Suppression automatique de l'ancien logo
**Réponse réussie :**
```json
{
"status": "success",
"message": "Logo uploadé avec succès",
"media_id": 42,
"file_name": "logo_5_1234567890.jpg",
"file_path": "/entites/5/logo/logo_5_1234567890.jpg",
"dimensions": {
"width": 250,
"height": 180
}
}
```
#### Récupération du logo d'une entité
```http
GET /api/entites/{id}/logo
Authorization: Bearer {session_id}
```
**Réponse :**
```json
{
"status": "success",
"logo": {
"id": 42,
"data_url": "data:image/png;base64,iVBORw0KGgoAAAANS...",
"file_name": "logo_5_1234567890.png",
"mime_type": "image/png",
"width": 250,
"height": 180,
"size": 15234
}
}
```
**Note :** Le logo est également inclus automatiquement dans la réponse du login si disponible.
#### Mise à jour d'une entité
```http
PUT /api/entites/{id}
Content-Type: application/json
Authorization: Bearer {session_id}
{
"name": "Amicale de Grenoble",
"adresse1": "123 rue de la Caserne",
"adresse2": "",
"code_postal": "38000",
"ville": "Grenoble",
"phone": "0476123456",
"mobile": "0612345678",
"email": "contact@amicale38.fr",
"chk_stripe": true, // Activation paiement Stripe
"chk_mdp_manuel": false, // Génération auto des mots de passe
"chk_username_manuel": false, // Génération auto des usernames
"chk_copie_mail_recu": true,
"chk_accept_sms": false
}
```
**Paramètres de gestion des membres :**
| Paramètre | Type | Description |
|-----------|------|-------------|
| chk_mdp_manuel | boolean | `true`: L'admin saisit les mots de passe<br>`false`: Génération automatique |
| chk_username_manuel | boolean | `true`: L'admin saisit les identifiants<br>`false`: Génération automatique |
| chk_stripe | boolean | Active/désactive les paiements Stripe |
**Note :** Ces paramètres sont modifiables uniquement par les administrateurs (fk_role > 1).
#### Réponse du login avec paramètres entité
Lors du login, les paramètres de l'entité sont retournés dans le groupe `amicale` :
```json
{
"status": "success",
"session_id": "abc123...",
"session_expiry": "2025-01-09T15:30:00+00:00",
"user": {
"id": 9999980,
"fk_entite": 5,
"fk_role": 2,
"fk_titre": null,
"first_name": "Pierre",
"sect_name": "",
"date_naissance": "1990-01-15", // Maintenant correctement récupéré
"date_embauche": "2020-03-01", // Maintenant correctement récupéré
"username": "pv_admin",
"name": "VALERY ADM",
"phone": "0476123456", // Maintenant correctement récupéré
"mobile": "0612345678", // Maintenant correctement récupéré
"email": "contact@resalice.com"
},
"amicale": {
"id": 5,
"name": "Amicale de Grenoble",
"chk_mdp_manuel": 0,
"chk_username_manuel": 0,
"chk_stripe": 1,
"logo": { // Logo de l'entité (si disponible)
"id": 42,
"data_url": "data:image/png;base64,iVBORw0KGgoAAAANS...",
"file_name": "logo_5_1234567890.png",
"mime_type": "image/png",
"width": 250,
"height": 180
}
// ... autres champs
}
}
```
Ces paramètres permettent à l'application Flutter d'adapter dynamiquement le formulaire de création de membre.
## Intégration Frontend
### Configuration des Requêtes
Toutes les requêtes API depuis le frontend doivent inclure :
```javascript
fetch('/api/endpoint', {
credentials: 'include', // Important pour les cookies de session
// ... autres options
});
```
### Gestion des Sessions
- Les cookies de session sont automatiquement gérés par le navigateur
- Pas besoin de stocker ou gérer des tokens manuellement
- Redirection vers /login si session expirée (401)
## Maintenance et Déploiement
### Logs
- Logs d'accès NGINX : /var/log/nginx/api-access.log
- Logs d'erreur NGINX : /var/log/nginx/api-error.log
- Logs PHP : /var/log/php/php-error.log
### Déploiement
1. Pull du repository
2. Vérification des permissions
3. Configuration de l'environnement
4. Tests des endpoints
5. Redémarrage des services
### Surveillance
- Monitoring des processus PHP-FPM
- Surveillance de la base de données
- Monitoring des performances
- Alertes sur erreurs critiques
## Changements récents
### Version 3.0.6 (Janvier 2025)
#### 1. Correction des rôles administrateurs
- **Avant :** Les administrateurs d'amicale devaient avoir `fk_role > 2`
- **Après :** Les administrateurs d'amicale ont `fk_role > 1` (donc rôle 2 et plus)
- **Impact :** Les champs `chk_stripe`, `chk_mdp_manuel`, `chk_username_manuel` sont maintenant modifiables par les admins d'amicale (rôle 2)
#### 2. Envoi systématique des deux emails lors de la création d'utilisateur
- **Avant :** Le 2ème email (mot de passe) n'était envoyé que si le mot de passe était généré automatiquement
- **Après :** Les deux emails sont toujours envoyés lors de la création d'un membre
- Email 1 : Identifiant (username)
- Email 2 : Mot de passe (1 seconde après)
- **Raison :** Le nouveau membre a toujours besoin des deux informations pour se connecter
#### 3. Ajout des champs manquants dans la réponse du login
- **Champs ajoutés dans la requête SQL :**
- `fk_titre`
- `date_naissance`
- `date_embauche`
- `encrypted_phone`
- `encrypted_mobile`
- **Impact :** Ces données sont maintenant correctement retournées dans l'objet `user` lors du login
#### 4. Système de gestion des logos d'entité
- **Nouvelle fonctionnalité :** Upload et gestion des logos pour les amicales
- **Routes ajoutées :**
- `POST /api/entites/{id}/logo` : Upload d'un nouveau logo
- `GET /api/entites/{id}/logo` : Récupération du logo
- **Caractéristiques :**
- Réservé aux administrateurs d'amicale (fk_role == 2)
- Un seul logo actif par entité
- Redimensionnement automatique (250x250px max)
- Format base64 dans les réponses JSON (compatible Flutter)
- Logo inclus automatiquement dans la réponse du login
#### 5. Amélioration de l'intégration Flutter
- **Format d'envoi des images :** Base64 data URL pour compatibilité multiplateforme
- **Structure de réponse enrichie :** Le logo est inclus dans l'objet `amicale` lors du login
- **Optimisation :** Pas de requête HTTP supplémentaire nécessaire pour afficher le logo

View File

@@ -1,155 +0,0 @@
# 📋 RÉCAPITULATIF - Migration Arborescence Uploads
## ✅ Modifications effectuées
### 1. **EntiteController.php** (ligne 736)
```php
// Avant : "/entites/{$entiteId}/logo"
// Après : "/{$entiteId}/logo"
```
✅ Les logos sont maintenant stockés dans : `uploads/{entite_id}/logo/`
### 2. **ReceiptService.php** (ligne 95)
```php
// Avant : "/entites/{$entiteId}/recus/{$operationId}"
// Après : "/{$entiteId}/recus/{$operationId}"
```
✅ Les reçus PDF sont maintenant stockés dans : `uploads/{entite_id}/recus/{operation_id}/`
### 3. **ExportService.php** (lignes 40 et 141)
```php
// Avant Excel : "/{$entiteId}/operations/{$operationId}/exports/excel"
// Après Excel : "/{$entiteId}/operations/{$operationId}"
// Avant JSON : "/{$entiteId}/operations/{$operationId}/exports/json"
// Après JSON : "/{$entiteId}/operations/{$operationId}"
```
✅ Les exports sont maintenant stockés directement dans : `uploads/{entite_id}/operations/{operation_id}/`
## 📂 Nouvelle structure complète
```
uploads/
└── {entite_id}/ # Ex: 5, 1230, etc.
├── logo/ # Logo de l'entité
│ └── logo_{entite_id}_{timestamp}.{jpg|png}
├── operations/ # Exports d'opérations
│ └── {operation_id}/ # Ex: 1525, 3124
│ ├── geosector-export-{operation_id}-{timestamp}.xlsx
│ └── backup-{operation_id}-{timestamp}.json.enc
└── recus/ # Reçus fiscaux
└── {operation_id}/ # Ex: 3124
└── recu_{passage_id}.pdf
```
## 🔧 Script de migration
Un script a été créé pour migrer les fichiers existants :
**Fichier :** `/scripts/migrate_uploads_structure.php`
**Usage :**
```bash
# Mode simulation (voir ce qui sera fait sans modifier)
php scripts/migrate_uploads_structure.php --dry-run
# Mode réel (effectue la migration)
php scripts/migrate_uploads_structure.php
```
**Ce que fait le script :**
1. Déplace tout le contenu de `uploads/entites/*` vers `uploads/*`
2. Fusionne les dossiers si nécessaire
3. Simplifie la structure des exports (supprime `/documents/exports/excel/`)
4. Applique les bonnes permissions (nginx:nobody 775/664)
5. Crée un log détaillé dans `/logs/migration_uploads_YYYYMMDD_HHMMSS.log`
## 🚀 Procédure de déploiement
### Sur DEV (déjà fait)
✅ Code modifié
✅ Script de migration créé
### Sur REC
```bash
# 1. Déployer le nouveau code
./livre-api.sh rec
# 2. Faire un backup des uploads actuels
cd /var/www/geosector/api
tar -czf uploads_backup_$(date +%Y%m%d).tar.gz uploads/
# 3. Tester en mode dry-run
php scripts/migrate_uploads_structure.php --dry-run
# 4. Si OK, lancer la migration
php scripts/migrate_uploads_structure.php
# 5. Vérifier la nouvelle structure
ls -la uploads/
ls -la uploads/*/
```
### Sur PROD
Même procédure que REC après validation
## ⚠️ Points d'attention
1. **Backup obligatoire** avant migration
2. **Vérifier l'espace disque** disponible
3. **Tester d'abord en dry-run**
4. **Surveiller les logs** après migration
5. **Tester** upload logo, génération reçu, et export Excel
## 📊 Gains obtenus
| Aspect | Avant | Après |
|--------|-------|-------|
| **Profondeur max** | 8 niveaux | 4 niveaux |
| **Complexité** | 2 structures parallèles | 1 structure unique |
| **Clarté** | Confus (entites + racine) | Simple et logique |
| **Navigation** | Difficile | Intuitive |
## 🔍 Vérification post-migration
Après la migration, vérifier :
```bash
# Structure attendue pour l'entité 5
tree uploads/5/
# Devrait afficher :
# uploads/5/
# ├── logo/
# │ └── logo_5_*.png
# ├── operations/
# │ ├── 1525/
# │ │ └── *.xlsx
# │ └── 3124/
# │ └── *.xlsx
# └── recus/
# └── 3124/
# └── recu_*.pdf
# Vérifier les permissions
ls -la uploads/*/
# Devrait montrer : nginx:nobody avec 775 pour dossiers, 664 pour fichiers
```
## ✅ Checklist finale
- [ ] Code modifié et testé en DEV
- [ ] Script de migration créé
- [ ] Documentation mise à jour
- [ ] Backup effectué sur REC
- [ ] Migration testée en dry-run sur REC
- [ ] Migration exécutée sur REC
- [ ] Tests fonctionnels sur REC
- [ ] Backup effectué sur PROD
- [ ] Migration exécutée sur PROD
- [ ] Tests fonctionnels sur PROD
---
**Date de création :** 20/08/2025
**Auteur :** Assistant Claude
**Status :** Prêt pour déploiement

View File

@@ -1,93 +0,0 @@
# Réorganisation de l'arborescence des uploads
## 📅 Date : 20/08/2025
## 🎯 Objectif
Uniformiser et simplifier l'arborescence des fichiers uploads pour une meilleure organisation et maintenance.
## 📂 Arborescence actuelle (PROBLÈME)
```
uploads/
├── entites/
│ └── 5/
│ ├── logo/
│ ├── operations/
│ │ └── 1525/
│ │ └── documents/
│ │ └── exports/
│ │ └── excel/
│ │ └── geosector-export-*.xlsx
│ └── recus/
│ └── 3124/
│ └── recu_*.pdf
└── 5/
└── operations/
├── 1525/
└── 2021/
```
**Problèmes identifiés :**
- Duplication des structures (dossier `5` à la racine ET dans `entites/`)
- Chemins trop profonds pour les exports Excel (6 niveaux)
- Incohérence dans les chemins
## ✅ Nouvelle arborescence (SOLUTION)
```
uploads/
└── {entite_id}/ # Un seul dossier par entité à la racine
├── logo/ # Logo de l'entité
│ └── logo_*.{jpg,png}
├── operations/ # Exports par opération
│ └── {operation_id}/
│ └── *.xlsx # Exports Excel directement ici
└── recus/ # Reçus par opération
└── {operation_id}/
└── recu_*.pdf
```
## 📝 Fichiers à modifier
### 1. EntiteController.php (Upload logo)
**Actuel :** `/entites/{$entiteId}/logo`
**Nouveau :** `/{$entiteId}/logo`
### 2. ReceiptService.php (Stockage reçus PDF)
**Actuel :** `/entites/{$entiteId}/recus/{$operationId}`
**Nouveau :** `/{$entiteId}/recus/{$operationId}`
### 3. ExportService.php (Export Excel)
**Actuel :** `/{$entiteId}/operations/{$operationId}/exports/excel`
**Nouveau :** `/{$entiteId}/operations/{$operationId}`
### 4. ExportService.php (Export JSON)
**Actuel :** `/{$entiteId}/operations/{$operationId}/exports/json`
**Nouveau :** `/{$entiteId}/operations/{$operationId}` (ou supprimer si non utilisé)
## 🔄 Plan de migration
### Étape 1 : Modifier le code
1. Mettre à jour tous les chemins dans les contrôleurs et services
2. Tester en environnement DEV
### Étape 2 : Script de migration des fichiers existants
Créer un script PHP pour :
1. Lister tous les fichiers existants
2. Les déplacer vers la nouvelle structure
3. Supprimer les anciens dossiers vides
### Étape 3 : Déploiement
1. Exécuter le script de migration sur REC
2. Vérifier le bon fonctionnement
3. Exécuter sur PROD
## 🚀 Avantages de la nouvelle structure
- **Plus simple** : Chemins plus courts et plus logiques
- **Plus cohérent** : Une seule structure pour toutes les entités
- **Plus maintenable** : Facile de naviguer et comprendre
- **Performance** : Moins de niveaux de dossiers à parcourir
## ⚠️ Points d'attention
- Vérifier les permissions (nginx:nobody 775/664)
- S'assurer que les anciens fichiers sont bien migrés
- Mettre à jour la documentation
- Informer l'équipe du changement

View File

@@ -1,135 +0,0 @@
# Changements de validation des usernames - Version ultra-souple
## Date : 17 janvier 2025
## Contexte
Suite aux problèmes d'erreurs 400 et au besoin d'avoir une approche plus moderne et inclusive, les règles de validation des usernames ont été assouplies pour accepter tous les caractères UTF-8, similaire à l'approche NIST pour les mots de passe.
## Anciennes règles (trop restrictives)
- ❌ 10-30 caractères
- ❌ Doit commencer par une lettre minuscule
- ❌ Seulement : a-z, 0-9, ., -, _
- ❌ Pas d'espaces
- ❌ Pas de majuscules
- ❌ Pas d'accents ou caractères spéciaux
## Nouvelles règles (ultra-souples)
-**8-30 caractères UTF-8**
-**Tous caractères acceptés** :
- Lettres (majuscules/minuscules)
- Chiffres
- Espaces
- Caractères spéciaux (!@#$%^&*()_+-=[]{}|;:'"<>,.?/)
- Accents (é, è, à, ñ, ü, etc.)
- Émojis (😀, 🎉, ❤️, etc.)
- Caractères non-latins (中文, العربية, Русский, etc.)
-**Sensible à la casse** (Jean ≠ jean)
-**Trim automatique** des espaces début/fin
-**Unicité vérifiée** dans toute la base
## Exemples de usernames valides
### Noms classiques
- `Jean-Pierre`
- `Marie Claire` (avec espace)
- `O'Connor`
- `José García`
### Avec chiffres et caractères spéciaux
- `admin2024`
- `user@company`
- `test_user#1`
- `Marie*123!`
### International
- `李明` (chinois)
- `محمد` (arabe)
- `Владимир` (russe)
- `さくら` (japonais)
- `Παύλος` (grec)
### Modernes/Fun
- `🦄Unicorn`
- `Player_1 🎮`
- `☕Coffee.Lover`
- `2024_User`
## Exemples de usernames invalides
- `short` ❌ (moins de 8 caractères)
- ` ` ❌ (espaces seulement)
- `very_long_username_that_exceeds_thirty_chars` ❌ (plus de 30 caractères)
## Modifications techniques
### 1. Code PHP (UserController.php)
```php
// Avant (restrictif)
if (!preg_match('/^[a-z][a-z0-9._-]{9,29}$/', $username))
// Après (ultra-souple)
$username = trim($data['username']);
$usernameLength = mb_strlen($username, 'UTF-8');
if ($usernameLength < 8) {
// Erreur : trop court
}
if ($usernameLength > 30) {
// Erreur : trop long
}
// C'est tout ! Pas d'autre validation
```
### 2. Base de données
```sql
-- Script à exécuter : scripts/sql/migration_username_utf8_support.sql
ALTER TABLE `users`
MODIFY COLUMN `encrypted_user_name` varchar(255) DEFAULT '';
```
### 3. Messages d'erreur simplifiés
- Avant : "Format du nom d'utilisateur invalide (10-30 caractères, commence par une lettre, caractères autorisés: a-z, 0-9, ., -, _)"
- Après :
- "Identifiant trop court" + "Minimum 8 caractères"
- "Identifiant trop long" + "Maximum 30 caractères"
- "Identifiant déjà utilisé"
## Impact sur l'expérience utilisateur
### Avantages
1. **Inclusivité** : Support de toutes les langues et cultures
2. **Modernité** : Permet les émojis et caractères spéciaux
3. **Simplicité** : Règles faciles à comprendre (juste la longueur)
4. **Flexibilité** : Les utilisateurs peuvent choisir l'identifiant qu'ils veulent
5. **Moins d'erreurs** : Moins de rejets pour format invalide
### Points d'attention
1. **Support client** : Former le support aux nouveaux formats possibles
2. **Affichage** : S'assurer que l'UI supporte bien l'UTF-8
3. **Recherche** : La recherche d'utilisateurs doit gérer la casse et l'UTF-8
4. **Export** : Vérifier que les exports CSV/Excel gèrent bien l'UTF-8
## Sécurité
### Pas d'impact sur la sécurité
- ✅ Les usernames sont toujours chiffrés en base (AES-256-CBC)
- ✅ L'unicité est toujours vérifiée
- ✅ Les injections SQL sont impossibles (prepared statements)
- ✅ Le trim empêche les espaces invisibles
### Recommandations
- Continuer à générer automatiquement des usernames simples (ASCII) pour éviter les problèmes
- Mais permettre la saisie manuelle de tout format
- Logger les usernames "exotiques" pour détecter d'éventuels abus
## Tests
- Script de test disponible : `/tests/test_username_validation.php`
- Teste tous les cas limites et formats internationaux
## Rollback si nécessaire
Si besoin de revenir en arrière :
1. Restaurer l'ancienne validation dans UserController
2. Les usernames UTF-8 existants continueront de fonctionner
3. Seuls les nouveaux seront restreints
## Conclusion
Cette approche ultra-souple aligne les usernames sur les standards modernes d'inclusivité et d'accessibilité, tout en maintenant la sécurité grâce au chiffrement et à la validation de l'unicité.

Binary file not shown.

View File

@@ -1,53 +0,0 @@
-- Table pour stocker les informations des devices des utilisateurs
CREATE TABLE IF NOT EXISTS `user_devices` (
`id` int(10) unsigned NOT NULL AUTO_INCREMENT,
`fk_user` int(10) unsigned NOT NULL COMMENT 'Référence vers la table users',
-- Informations générales du device
`platform` varchar(20) NOT NULL COMMENT 'Plateforme: iOS, Android, etc.',
`device_model` varchar(100) DEFAULT NULL COMMENT 'Modèle du device (ex: iPhone13,2)',
`device_name` varchar(255) DEFAULT NULL COMMENT 'Nom personnalisé du device',
`device_manufacturer` varchar(100) DEFAULT NULL COMMENT 'Fabricant (Apple, Samsung, etc.)',
`device_identifier` varchar(100) DEFAULT NULL COMMENT 'Identifiant unique du device',
-- Informations réseau (IPv4 uniquement)
`device_ip_local` varchar(15) DEFAULT NULL COMMENT 'Adresse IP locale IPv4',
`device_ip_public` varchar(15) DEFAULT NULL COMMENT 'Adresse IP publique IPv4',
`device_wifi_name` varchar(255) DEFAULT NULL COMMENT 'Nom du réseau WiFi (SSID)',
`device_wifi_bssid` varchar(17) DEFAULT NULL COMMENT 'BSSID du point d\'accès (format
XX:XX:XX:XX:XX:XX)',
-- Capacités et version OS
`ios_version` varchar(20) DEFAULT NULL COMMENT 'Version iOS/Android OS',
`device_nfc_capable` tinyint(1) DEFAULT NULL COMMENT 'Support NFC (1=oui, 0=non)',
`device_supports_tap_to_pay` tinyint(1) DEFAULT NULL COMMENT 'Support Tap to Pay (1=oui, 0=non)',
-- État batterie
`battery_level` tinyint(3) unsigned DEFAULT NULL COMMENT 'Niveau batterie en pourcentage (0-100)',
`battery_charging` tinyint(1) DEFAULT NULL COMMENT 'En charge (1=oui, 0=non)',
`battery_state` varchar(20) DEFAULT NULL COMMENT 'État batterie (charging, discharging, full)',
-- Versions application
`app_version` varchar(20) DEFAULT NULL COMMENT 'Version de l\'application (ex: 3.2.8)',
`app_build` varchar(20) DEFAULT NULL COMMENT 'Numéro de build (ex: 328)',
-- Timestamps
`last_device_info_check` timestamp NULL DEFAULT NULL COMMENT 'Dernier check des infos device côté
app',
`created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT 'Date de création de
l\'enregistrement',
`updated_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT
'Date de dernière modification',
PRIMARY KEY (`id`),
KEY `idx_fk_user` (`fk_user`) COMMENT 'Index pour recherche par utilisateur',
KEY `idx_updated_at` (`updated_at`) COMMENT 'Index pour tri par date de mise à jour',
KEY `idx_last_check` (`last_device_info_check`) COMMENT 'Index pour recherche par dernière
vérification',
UNIQUE KEY `unique_user_device` (`fk_user`, `device_identifier`) COMMENT 'Un seul enregistrement
par device/user',
CONSTRAINT `fk_user_devices_user` FOREIGN KEY (`fk_user`)
REFERENCES `users` (`id`) ON DELETE CASCADE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='Informations des devices
utilisateurs';

View File

@@ -18,39 +18,168 @@
/*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;
-- Tables préfixées "chat_"
CREATE TABLE chat_rooms (
id VARCHAR(36) PRIMARY KEY,
title VARCHAR(255),
type ENUM('private', 'group', 'broadcast'),
created_at TIMESTAMP,
created_by INT
);
CREATE TABLE `chat_anonymous_users` (
`id` varchar(50) NOT NULL,
`device_id` varchar(100) NOT NULL,
`name` varchar(100) DEFAULT NULL,
`email` varchar(100) DEFAULT NULL,
`created_at` timestamp NOT NULL DEFAULT current_timestamp(),
`converted_to_user_id` int(10) unsigned DEFAULT NULL,
`metadata` longtext CHARACTER SET utf8mb4 COLLATE utf8mb4_bin DEFAULT NULL CHECK (json_valid(`metadata`)),
PRIMARY KEY (`id`),
KEY `idx_device_id` (`device_id`),
KEY `idx_converted_user` (`converted_to_user_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci `PAGE_COMPRESSED`='ON';
CREATE TABLE chat_messages (
id VARCHAR(36) PRIMARY KEY,
room_id VARCHAR(36),
content TEXT,
sender_id INT,
sent_at TIMESTAMP,
FOREIGN KEY (room_id) REFERENCES chat_rooms(id)
);
CREATE TABLE `chat_attachments` (
`id` varchar(50) NOT NULL,
`fk_message` varchar(50) NOT NULL,
`file_name` varchar(255) NOT NULL,
`file_path` varchar(500) NOT NULL,
`file_type` varchar(100) NOT NULL,
`file_size` int(10) unsigned NOT NULL,
`created_at` timestamp NOT NULL DEFAULT current_timestamp(),
PRIMARY KEY (`id`),
KEY `idx_message` (`fk_message`),
CONSTRAINT `fk_chat_attachments_message` FOREIGN KEY (`fk_message`) REFERENCES `chat_messages` (`id`) ON DELETE CASCADE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci `PAGE_COMPRESSED`='ON';
CREATE TABLE chat_participants (
room_id VARCHAR(36),
user_id INT,
role INT,
entite_id INT,
joined_at TIMESTAMP,
PRIMARY KEY (room_id, user_id)
);
CREATE TABLE `chat_audience_targets` (
`id` int(10) unsigned NOT NULL AUTO_INCREMENT,
`fk_room` varchar(50) NOT NULL,
`target_type` enum('role','entity','all','combined') NOT NULL DEFAULT 'all',
`target_id` varchar(50) DEFAULT NULL,
`role_filter` varchar(20) DEFAULT NULL,
`entity_filter` varchar(50) DEFAULT NULL,
`date_creation` timestamp NOT NULL DEFAULT current_timestamp(),
PRIMARY KEY (`id`),
KEY `idx_room` (`fk_room`),
KEY `idx_type` (`target_type`),
CONSTRAINT `fk_chat_audience_targets_room` FOREIGN KEY (`fk_room`) REFERENCES `chat_rooms` (`id`) ON DELETE CASCADE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci `PAGE_COMPRESSED`='ON';
CREATE TABLE chat_read_receipts (
message_id VARCHAR(36),
user_id INT,
read_at TIMESTAMP,
PRIMARY KEY (message_id, user_id)
);
CREATE TABLE `chat_broadcast_lists` (
`id` int(10) unsigned NOT NULL AUTO_INCREMENT,
`fk_room` varchar(50) NOT NULL,
`name` varchar(100) NOT NULL,
`description` text DEFAULT NULL,
`fk_user_creator` int(10) unsigned NOT NULL,
`date_creation` timestamp NOT NULL DEFAULT current_timestamp(),
PRIMARY KEY (`id`),
KEY `idx_room` (`fk_room`),
KEY `idx_user_creator` (`fk_user_creator`),
CONSTRAINT `fk_chat_broadcast_lists_room` FOREIGN KEY (`fk_room`) REFERENCES `chat_rooms` (`id`) ON DELETE CASCADE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci `PAGE_COMPRESSED`='ON';
CREATE TABLE `chat_messages` (
`id` varchar(50) NOT NULL,
`fk_room` varchar(50) NOT NULL,
`fk_user` int(10) unsigned DEFAULT NULL,
`sender_type` enum('user','anonymous','system') NOT NULL DEFAULT 'user',
`content` text DEFAULT NULL,
`content_type` enum('text','image','file') NOT NULL DEFAULT 'text',
`date_sent` timestamp NOT NULL DEFAULT current_timestamp(),
`date_delivered` timestamp NULL DEFAULT NULL,
`date_read` timestamp NULL DEFAULT NULL,
`statut` enum('envoye','livre','lu','error') NOT NULL DEFAULT 'envoye',
`is_announcement` tinyint(1) unsigned NOT NULL DEFAULT 0,
PRIMARY KEY (`id`),
KEY `idx_room` (`fk_room`),
KEY `idx_user` (`fk_user`),
KEY `idx_date` (`date_sent`),
KEY `idx_status` (`statut`),
KEY `idx_messages_unread` (`fk_room`,`statut`),
CONSTRAINT `fk_chat_messages_room` FOREIGN KEY (`fk_room`) REFERENCES `chat_rooms` (`id`) ON DELETE CASCADE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci `PAGE_COMPRESSED`='ON';
CREATE TABLE `chat_notifications` (
`id` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
`fk_user` int(10) unsigned NOT NULL,
`fk_message` varchar(50) DEFAULT NULL,
`fk_room` varchar(50) DEFAULT NULL,
`type` varchar(50) NOT NULL,
`contenu` text DEFAULT NULL,
`date_creation` timestamp NOT NULL DEFAULT current_timestamp(),
`date_lecture` timestamp NULL DEFAULT NULL,
`statut` enum('non_lue','lue') NOT NULL DEFAULT 'non_lue',
PRIMARY KEY (`id`),
KEY `idx_user` (`fk_user`),
KEY `idx_message` (`fk_message`),
KEY `idx_room` (`fk_room`),
KEY `idx_statut` (`statut`),
KEY `idx_notifications_unread` (`fk_user`,`statut`),
CONSTRAINT `fk_chat_notifications_message` FOREIGN KEY (`fk_message`) REFERENCES `chat_messages` (`id`) ON DELETE SET NULL,
CONSTRAINT `fk_chat_notifications_room` FOREIGN KEY (`fk_room`) REFERENCES `chat_rooms` (`id`) ON DELETE SET NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci `PAGE_COMPRESSED`='ON';
CREATE TABLE `chat_offline_queue` (
`id` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
`user_id` int(10) unsigned NOT NULL,
`operation_type` varchar(50) NOT NULL,
`operation_data` longtext CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL CHECK (json_valid(`operation_data`)),
`created_at` timestamp NOT NULL DEFAULT current_timestamp(),
`processed_at` timestamp NULL DEFAULT NULL,
`status` enum('pending','processing','completed','failed') NOT NULL DEFAULT 'pending',
`error_message` text DEFAULT NULL,
PRIMARY KEY (`id`),
KEY `idx_user_id` (`user_id`),
KEY `idx_status` (`status`),
KEY `idx_created_at` (`created_at`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci `PAGE_COMPRESSED`='ON';
CREATE TABLE `chat_participants` (
`id` int(10) unsigned NOT NULL AUTO_INCREMENT,
`id_room` varchar(50) NOT NULL,
`id_user` int(10) unsigned DEFAULT NULL,
`anonymous_id` varchar(50) DEFAULT NULL,
`role` enum('administrateur','participant','en_lecture_seule') NOT NULL DEFAULT 'participant',
`date_ajout` timestamp NOT NULL DEFAULT current_timestamp(),
`notification_activee` tinyint(1) unsigned NOT NULL DEFAULT 1,
`last_read_message_id` varchar(50) DEFAULT NULL,
`via_target` tinyint(1) unsigned NOT NULL DEFAULT 0,
`can_reply` tinyint(1) unsigned DEFAULT NULL,
PRIMARY KEY (`id`),
UNIQUE KEY `uc_room_user` (`id_room`,`id_user`),
KEY `idx_room` (`id_room`),
KEY `idx_user` (`id_user`),
KEY `idx_anonymous_id` (`anonymous_id`),
KEY `idx_participants_active` (`id_room`,`id_user`,`notification_activee`),
CONSTRAINT `fk_chat_participants_room` FOREIGN KEY (`id_room`) REFERENCES `chat_rooms` (`id`) ON DELETE CASCADE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci `PAGE_COMPRESSED`='ON';
CREATE TABLE `chat_read_messages` (
`id` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
`fk_message` varchar(50) NOT NULL,
`fk_user` int(10) unsigned NOT NULL,
`date_read` timestamp NOT NULL DEFAULT current_timestamp(),
PRIMARY KEY (`id`),
UNIQUE KEY `uc_message_user` (`fk_message`,`fk_user`),
KEY `idx_message` (`fk_message`),
KEY `idx_user` (`fk_user`),
CONSTRAINT `fk_chat_read_messages_message` FOREIGN KEY (`fk_message`) REFERENCES `chat_messages` (`id`) ON DELETE CASCADE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci `PAGE_COMPRESSED`='ON';
CREATE TABLE `chat_rooms` (
`id` varchar(50) NOT NULL,
`type` enum('privee','groupe','liste_diffusion','broadcast','announcement') NOT NULL,
`title` varchar(100) DEFAULT NULL,
`date_creation` timestamp NOT NULL DEFAULT current_timestamp(),
`fk_user` int(10) unsigned NOT NULL,
`fk_entite` int(10) unsigned DEFAULT NULL,
`statut` enum('active','archive') NOT NULL DEFAULT 'active',
`description` text DEFAULT NULL,
`reply_permission` enum('all','admins_only','sender_only','none') NOT NULL DEFAULT 'all',
`is_pinned` tinyint(1) unsigned NOT NULL DEFAULT 0,
`expiry_date` timestamp NULL DEFAULT NULL,
`updated_at` timestamp NULL DEFAULT NULL ON UPDATE current_timestamp(),
PRIMARY KEY (`id`),
KEY `idx_user` (`fk_user`),
KEY `idx_entite` (`fk_entite`),
KEY `idx_type` (`type`),
KEY `idx_statut` (`statut`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci `PAGE_COMPRESSED`='ON';
CREATE TABLE `email_counter` (
`id` int(10) unsigned NOT NULL DEFAULT 1,

619
api/docs/geosector_app.sql Executable file
View File

@@ -0,0 +1,619 @@
-- Création de la base de données geo_app si elle n'existe pas
DROP DATABASE IF EXISTS `geo_app`;
CREATE DATABASE IF NOT EXISTS `geo_app` DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
-- Création de l'utilisateur et attribution des droits
CREATE USER IF NOT EXISTS 'geo_app_user'@'localhost' IDENTIFIED BY 'QO:96df*?k{4W6m';
GRANT SELECT, INSERT, UPDATE, DELETE ON `geo_app`.* TO 'geo_app_user'@'localhost';
FLUSH PRIVILEGES;
USE geo_app;
--
-- Table structure for table `email_counter`
--
DROP TABLE IF EXISTS `email_counter`;
/*!40101 SET @saved_cs_client = @@character_set_client */;
/*!50503 SET character_set_client = utf8mb4 */;
CREATE TABLE `email_counter` (
`id` int unsigned NOT NULL DEFAULT '1',
`hour_start` timestamp NULL DEFAULT NULL,
`count` int unsigned DEFAULT '0',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
/*!40101 SET character_set_client = @saved_cs_client */;
DROP TABLE IF EXISTS `x_devises`;
/*!40101 SET @saved_cs_client = @@character_set_client */;
/*!50503 SET character_set_client = utf8mb4 */;
CREATE TABLE `x_devises` (
`id` int unsigned NOT NULL AUTO_INCREMENT,
`code` varchar(3) DEFAULT NULL,
`symbole` varchar(6) DEFAULT NULL,
`libelle` varchar(45) DEFAULT NULL,
`chk_active` tinyint(1) unsigned DEFAULT '1',
PRIMARY KEY (`id`),
UNIQUE KEY `id_UNIQUE` (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
/*!40101 SET character_set_client = @saved_cs_client */;
--
-- Table structure for table `x_entites_types`
--
DROP TABLE IF EXISTS `x_entites_types`;
/*!40101 SET @saved_cs_client = @@character_set_client */;
/*!50503 SET character_set_client = utf8mb4 */;
CREATE TABLE `x_entites_types` (
`id` int unsigned NOT NULL AUTO_INCREMENT,
`libelle` varchar(45) DEFAULT NULL,
`chk_active` tinyint(1) unsigned DEFAULT NULL,
PRIMARY KEY (`id`),
UNIQUE KEY `id_UNIQUE` (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
/*!40101 SET character_set_client = @saved_cs_client */;
--
-- Table structure for table `x_types_passages`
--
DROP TABLE IF EXISTS `x_types_passages`;
/*!40101 SET @saved_cs_client = @@character_set_client */;
/*!50503 SET character_set_client = utf8mb4 */;
CREATE TABLE `x_types_passages` (
`id` int unsigned NOT NULL AUTO_INCREMENT,
`libelle` varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT NULL,
`color_button` varchar(15) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT NULL,
`color_mark` varchar(15) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT NULL,
`color_table` varchar(15) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT NULL,
`chk_active` tinyint(1) unsigned NOT NULL DEFAULT '1',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
/*!40101 SET character_set_client = @saved_cs_client */;
--
-- Table structure for table `x_types_reglements`
--
DROP TABLE IF EXISTS `x_types_reglements`;
/*!40101 SET @saved_cs_client = @@character_set_client */;
/*!50503 SET character_set_client = utf8mb4 */;
CREATE TABLE `x_types_reglements` (
`id` int unsigned NOT NULL AUTO_INCREMENT,
`libelle` varchar(45) DEFAULT NULL,
`chk_active` tinyint(1) unsigned DEFAULT '1',
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
/*!40101 SET character_set_client = @saved_cs_client */;
--
-- Table structure for table `x_users_roles`
--
DROP TABLE IF EXISTS `x_users_roles`;
CREATE TABLE `x_users_roles` (
`id` int unsigned NOT NULL AUTO_INCREMENT,
`libelle` varchar(45) DEFAULT NULL,
`chk_active` tinyint(1) unsigned DEFAULT '1',
PRIMARY KEY (`id`),
UNIQUE KEY `id_UNIQUE` (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=10 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='Les différents rôles des utilisateurs';
/*!40101 SET character_set_client = @saved_cs_client */;
DROP TABLE IF EXISTS `x_users_titres`;
/*!40101 SET @saved_cs_client = @@character_set_client */;
/*!50503 SET character_set_client = utf8mb4 */;
CREATE TABLE `x_users_titres` (
`id` int unsigned NOT NULL AUTO_INCREMENT,
`libelle` varchar(45) DEFAULT NULL,
`chk_active` tinyint(1) unsigned DEFAULT '1',
PRIMARY KEY (`id`),
UNIQUE KEY `id_UNIQUE` (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='Les différents titres des utilisateurs';
DROP TABLE IF EXISTS `x_pays`;
/*!40101 SET @saved_cs_client = @@character_set_client */;
/*!50503 SET character_set_client = utf8mb4 */;
CREATE TABLE `x_pays` (
`id` int unsigned NOT NULL AUTO_INCREMENT,
`code` varchar(3) DEFAULT NULL,
`fk_continent` int unsigned DEFAULT NULL,
`fk_devise` int unsigned DEFAULT '1',
`libelle` varchar(45) DEFAULT NULL,
`chk_active` tinyint(1) unsigned DEFAULT '1',
PRIMARY KEY (`id`),
UNIQUE KEY `id_UNIQUE` (`id`),
CONSTRAINT `x_pays_ibfk_1` FOREIGN KEY (`fk_devise`) REFERENCES `x_devises` (`id`) ON DELETE RESTRICT ON UPDATE CASCADE
) ENGINE=InnoDB AUTO_INCREMENT=10 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='Table des pays avec leurs codes';
/*!40101 SET character_set_client = @saved_cs_client */;
DROP TABLE IF EXISTS `x_regions`;
/*!40101 SET @saved_cs_client = @@character_set_client */;
/*!50503 SET character_set_client = utf8mb4 */;
CREATE TABLE `x_regions` (
`id` int unsigned NOT NULL AUTO_INCREMENT,
`fk_pays` int unsigned DEFAULT '1',
`libelle` varchar(45) DEFAULT NULL,
`libelle_long` varchar(45) DEFAULT NULL,
`table_osm` varchar(45) DEFAULT NULL,
`departements` varchar(45) DEFAULT NULL,
`chk_active` tinyint(1) unsigned DEFAULT '1',
PRIMARY KEY (`id`),
UNIQUE KEY `id_UNIQUE` (`id`),
CONSTRAINT `x_regions_ibfk_1` FOREIGN KEY (`fk_pays`) REFERENCES `x_pays` (`id`) ON DELETE RESTRICT ON UPDATE CASCADE
) ENGINE=InnoDB AUTO_INCREMENT=29 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
/*!40101 SET character_set_client = @saved_cs_client */;
DROP TABLE IF EXISTS `x_departements`;
/*!40101 SET @saved_cs_client = @@character_set_client */;
/*!50503 SET character_set_client = utf8mb4 */;
CREATE TABLE `x_departements` (
`id` int unsigned NOT NULL AUTO_INCREMENT,
`code` varchar(3) DEFAULT NULL,
`fk_region` int unsigned DEFAULT '1',
`libelle` varchar(45) DEFAULT NULL,
`chk_active` tinyint(1) unsigned DEFAULT '1',
PRIMARY KEY (`id`),
UNIQUE KEY `id_UNIQUE` (`id`),
CONSTRAINT `x_departements_ibfk_1` FOREIGN KEY (`fk_region`) REFERENCES `x_regions` (`id`) ON DELETE RESTRICT ON UPDATE CASCADE
) ENGINE=InnoDB AUTO_INCREMENT=105 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
/*!40101 SET character_set_client = @saved_cs_client */;
DROP TABLE IF EXISTS `entites`;
/*!40101 SET @saved_cs_client = @@character_set_client */;
/*!50503 SET character_set_client = utf8mb4 */;
CREATE TABLE `entites` (
`id` int unsigned NOT NULL AUTO_INCREMENT,
`encrypted_name` varchar(255) DEFAULT NULL,
`adresse1` varchar(45) DEFAULT '',
`adresse2` varchar(45) DEFAULT '',
`code_postal` varchar(5) DEFAULT '',
`ville` varchar(45) DEFAULT '',
`fk_region` int unsigned DEFAULT NULL,
`fk_type` int unsigned DEFAULT '1',
`encrypted_phone` varchar(128) DEFAULT '',
`encrypted_mobile` varchar(128) DEFAULT '',
`encrypted_email` varchar(255) DEFAULT '',
`gps_lat` varchar(20) NOT NULL DEFAULT '',
`gps_lng` varchar(20) NOT NULL DEFAULT '',
`encrypted_stripe_id` varchar(255) DEFAULT '',
`encrypted_iban` varchar(255) DEFAULT '',
`encrypted_bic` varchar(128) DEFAULT '',
`chk_demo` tinyint(1) unsigned DEFAULT '1',
`chk_mdp_manuel` tinyint(1) unsigned NOT NULL DEFAULT '1' COMMENT 'Gestion des mots de passe manuelle O/N',
`chk_copie_mail_recu` tinyint(1) unsigned NOT NULL DEFAULT '0',
`chk_accept_sms` tinyint(1) unsigned NOT NULL DEFAULT '0',
`created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT 'Date de création',
`fk_user_creat` int unsigned DEFAULT NULL,
`updated_at` timestamp NULL DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP COMMENT 'Date de modification',
`fk_user_modif` int unsigned DEFAULT NULL,
`chk_active` tinyint(1) unsigned DEFAULT '1',
PRIMARY KEY (`id`),
CONSTRAINT `entites_ibfk_1` FOREIGN KEY (`fk_region`) REFERENCES `x_regions` (`id`) ON DELETE RESTRICT ON UPDATE CASCADE,
CONSTRAINT `entites_ibfk_2` FOREIGN KEY (`fk_type`) REFERENCES `x_entites_types` (`id`) ON DELETE RESTRICT ON UPDATE CASCADE
) ENGINE=InnoDB AUTO_INCREMENT=0 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
/*!40101 SET character_set_client = @saved_cs_client */;
DROP TABLE IF EXISTS `x_villes`;
/*!40101 SET @saved_cs_client = @@character_set_client */;
/*!50503 SET character_set_client = utf8mb4 */;
CREATE TABLE `x_villes` (
`id` int unsigned NOT NULL AUTO_INCREMENT,
`fk_departement` int unsigned DEFAULT '1',
`libelle` varchar(65) DEFAULT NULL,
`cp` varchar(5) DEFAULT NULL,
`code_insee` varchar(5) DEFAULT NULL,
`departement` varchar(65) DEFAULT NULL,
`chk_active` tinyint(1) unsigned DEFAULT '1',
PRIMARY KEY (`id`),
UNIQUE KEY `id_UNIQUE` (`id`),
CONSTRAINT `x_villes_ibfk_1` FOREIGN KEY (`fk_departement`) REFERENCES `x_departements` (`id`) ON DELETE RESTRICT ON UPDATE CASCADE
) ENGINE=InnoDB AUTO_INCREMENT=0 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
/*!40101 SET character_set_client = @saved_cs_client */;
DROP TABLE IF EXISTS `users`;
/*!40101 SET @saved_cs_client = @@character_set_client */;
/*!50503 SET character_set_client = utf8mb4 */;
CREATE TABLE `users` (
`id` int unsigned NOT NULL AUTO_INCREMENT,
`fk_entite` int unsigned DEFAULT '1',
`fk_role` int unsigned DEFAULT '1',
`fk_titre` int unsigned DEFAULT '1',
`encrypted_name` varchar(255) DEFAULT NULL,
`first_name` varchar(45) DEFAULT NULL,
`sect_name` varchar(60) DEFAULT '',
`encrypted_user_name` varchar(128) DEFAULT '',
`user_pass_hash` varchar(60) DEFAULT NULL,
`encrypted_phone` varchar(128) DEFAULT NULL,
`encrypted_mobile` varchar(128) DEFAULT NULL,
`encrypted_email` varchar(255) DEFAULT '',
`chk_alert_email` tinyint(1) unsigned DEFAULT '1',
`chk_suivi` tinyint(1) unsigned DEFAULT '0',
`date_naissance` date DEFAULT NULL,
`date_embauche` date DEFAULT NULL,
`created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT 'Date de création',
`fk_user_creat` int unsigned DEFAULT NULL,
`updated_at` timestamp NULL DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP COMMENT 'Date de modification',
`fk_user_modif` int unsigned DEFAULT NULL,
`chk_active` tinyint(1) unsigned DEFAULT '1',
PRIMARY KEY (`id`),
KEY `fk_entite` (`fk_entite`),
KEY `username` (`encrypted_user_name`),
CONSTRAINT `users_ibfk_1` FOREIGN KEY (`fk_entite`) REFERENCES `entites` (`id`) ON DELETE RESTRICT ON UPDATE CASCADE,
CONSTRAINT `users_ibfk_2` FOREIGN KEY (`fk_role`) REFERENCES `x_users_roles` (`id`) ON DELETE RESTRICT ON UPDATE CASCADE,
CONSTRAINT `users_ibfk_3` FOREIGN KEY (`fk_titre`) REFERENCES `x_users_titres` (`id`) ON DELETE RESTRICT ON UPDATE CASCADE
) ENGINE=InnoDB AUTO_INCREMENT=0 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
/*!40101 SET character_set_client = @saved_cs_client */;
DROP TABLE IF EXISTS `operations`;
/*!40101 SET @saved_cs_client = @@character_set_client */;
/*!50503 SET character_set_client = utf8mb4 */;
CREATE TABLE `operations` (
`id` int unsigned NOT NULL AUTO_INCREMENT,
`fk_entite` int unsigned NOT NULL DEFAULT '1',
`libelle` varchar(75) NOT NULL DEFAULT '',
`date_deb` date NOT NULL DEFAULT '0000-00-00',
`date_fin` date NOT NULL DEFAULT '0000-00-00',
`chk_distinct_sectors` tinyint(1) unsigned NOT NULL DEFAULT '0',
`created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT 'Date de création',
`fk_user_creat` int unsigned NOT NULL DEFAULT '0',
`updated_at` timestamp NULL DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP COMMENT 'Date de modification',
`fk_user_modif` int unsigned NOT NULL DEFAULT '0',
`chk_active` tinyint(1) unsigned NOT NULL DEFAULT '1',
PRIMARY KEY (`id`),
KEY `fk_entite` (`fk_entite`),
KEY `date_deb` (`date_deb`),
CONSTRAINT `operations_ibfk_1` FOREIGN KEY (`fk_entite`) REFERENCES `entites` (`id`) ON DELETE RESTRICT ON UPDATE CASCADE
) ENGINE=InnoDB AUTO_INCREMENT=0 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
/*!40101 SET character_set_client = @saved_cs_client */;
DROP TABLE IF EXISTS `ope_sectors`;
/*!40101 SET @saved_cs_client = @@character_set_client */;
/*!50503 SET character_set_client = utf8mb4 */;
CREATE TABLE `ope_sectors` (
`id` int unsigned NOT NULL AUTO_INCREMENT,
`fk_operation` int unsigned NOT NULL DEFAULT '0',
`fk_old_sector` int unsigned NOT NULL DEFAULT '0',
`libelle` varchar(75) NOT NULL DEFAULT '',
`sector` text NOT NULL DEFAULT '',
`color` varchar(7) NOT NULL DEFAULT '#4B77BE',
`created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT 'Date de création',
`fk_user_creat` int unsigned NOT NULL DEFAULT '0',
`updated_at` timestamp NULL DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP COMMENT 'Date de modification',
`fk_user_modif` int unsigned NOT NULL DEFAULT '0',
`chk_active` tinyint(1) unsigned NOT NULL DEFAULT '1',
PRIMARY KEY (`id`),
UNIQUE KEY `id` (`id`),
KEY `fk_operation` (`fk_operation`),
CONSTRAINT `ope_sectors_ibfk_1` FOREIGN KEY (`fk_operation`) REFERENCES `operations` (`id`) ON DELETE RESTRICT ON UPDATE CASCADE
) ENGINE=InnoDB AUTO_INCREMENT=0 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
DROP TABLE IF EXISTS `ope_users`;
/*!40101 SET @saved_cs_client = @@character_set_client */;
/*!50503 SET character_set_client = utf8mb4 */;
CREATE TABLE `ope_users` (
`id` int unsigned NOT NULL AUTO_INCREMENT,
`fk_operation` int unsigned NOT NULL DEFAULT '0',
`fk_user` int unsigned NOT NULL DEFAULT '0',
`created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT 'Date de création',
`fk_user_creat` int unsigned DEFAULT NULL,
`updated_at` timestamp NULL DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP COMMENT 'Date de modification',
`fk_user_modif` int unsigned DEFAULT NULL,
`chk_active` tinyint(1) unsigned NOT NULL DEFAULT '1',
PRIMARY KEY (`id`),
UNIQUE KEY `id_UNIQUE` (`id`),
CONSTRAINT `ope_users_ibfk_1` FOREIGN KEY (`fk_operation`) REFERENCES `operations` (`id`) ON DELETE RESTRICT ON UPDATE CASCADE,
CONSTRAINT `ope_users_ibfk_2` FOREIGN KEY (`fk_user`) REFERENCES `users` (`id`) ON DELETE RESTRICT ON UPDATE CASCADE
) ENGINE=InnoDB AUTO_INCREMENT=0 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
/*!40101 SET character_set_client = @saved_cs_client */;
DROP TABLE IF EXISTS `email_queue`;
/*!40101 SET @saved_cs_client = @@character_set_client */;
/*!50503 SET character_set_client = utf8mb4 */;
CREATE TABLE `email_queue` (
`id` int unsigned NOT NULL AUTO_INCREMENT,
`fk_pass` int unsigned NOT NULL DEFAULT '0',
`to_email` varchar(255) COLLATE utf8mb4_unicode_ci DEFAULT NULL,
`subject` varchar(255) COLLATE utf8mb4_unicode_ci DEFAULT NULL,
`body` text COLLATE utf8mb4_unicode_ci,
`headers` text COLLATE utf8mb4_unicode_ci,
`created_at` timestamp NULL DEFAULT CURRENT_TIMESTAMP,
`status` enum('pending','sent','failed') COLLATE utf8mb4_unicode_ci DEFAULT 'pending',
`attempts` int unsigned DEFAULT '0',
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=0 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
/*!40101 SET character_set_client = @saved_cs_client */;
DROP TABLE IF EXISTS `ope_users_sectors`;
/*!40101 SET @saved_cs_client = @@character_set_client */;
/*!50503 SET character_set_client = utf8mb4 */;
CREATE TABLE `ope_users_sectors` (
`id` int unsigned NOT NULL AUTO_INCREMENT,
`fk_operation` int unsigned NOT NULL DEFAULT '0',
`fk_user` int unsigned NOT NULL DEFAULT '0',
`fk_sector` int unsigned NOT NULL DEFAULT '0',
`created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT 'Date de création',
`fk_user_creat` int unsigned NOT NULL DEFAULT '0',
`updated_at` timestamp NULL DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP COMMENT 'Date de modification',
`fk_user_modif` int unsigned DEFAULT NULL,
`chk_active` tinyint(1) unsigned DEFAULT '1',
PRIMARY KEY (`id`),
UNIQUE KEY `id` (`id`),
KEY `fk_operation` (`fk_operation`),
KEY `fk_user` (`fk_user`),
KEY `fk_sector` (`fk_sector`),
CONSTRAINT `ope_users_sectors_ibfk_1` FOREIGN KEY (`fk_operation`) REFERENCES `operations` (`id`) ON DELETE RESTRICT ON UPDATE CASCADE,
CONSTRAINT `ope_users_sectors_ibfk_2` FOREIGN KEY (`fk_user`) REFERENCES `users` (`id`) ON DELETE RESTRICT ON UPDATE CASCADE,
CONSTRAINT `ope_users_sectors_ibfk_3` FOREIGN KEY (`fk_sector`) REFERENCES `ope_sectors` (`id`) ON DELETE RESTRICT ON UPDATE CASCADE
) ENGINE=InnoDB AUTO_INCREMENT=0 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
/*!40101 SET character_set_client = @saved_cs_client */;
DROP TABLE IF EXISTS `ope_users_suivis`;
/*!40101 SET @saved_cs_client = @@character_set_client */;
/*!50503 SET character_set_client = utf8mb4 */;
CREATE TABLE `ope_users_suivis` (
`id` int unsigned NOT NULL AUTO_INCREMENT,
`fk_operation` int unsigned NOT NULL DEFAULT '0',
`fk_user` int unsigned NOT NULL DEFAULT '0',
`date_suivi` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT 'Date du suivi',
`gps_lat` varchar(20) NOT NULL DEFAULT '',
`gps_lng` varchar(20) NOT NULL DEFAULT '',
`vitesse` varchar(20) NOT NULL DEFAULT '',
`created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT 'Date de création',
`fk_user_creat` int unsigned NOT NULL DEFAULT '0',
`updated_at` timestamp NULL DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP COMMENT 'Date de modification',
`fk_user_modif` int unsigned NOT NULL DEFAULT '0',
PRIMARY KEY (`id`),
UNIQUE KEY `id_UNIQUE` (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=0 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
/*!40101 SET character_set_client = @saved_cs_client */;
DROP TABLE IF EXISTS `sectors_adresses`;
/*!40101 SET @saved_cs_client = @@character_set_client */;
/*!50503 SET character_set_client = utf8mb4 */;
CREATE TABLE `sectors_adresses` (
`id` int unsigned NOT NULL AUTO_INCREMENT,
`fk_adresse` varchar(25) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT NULL COMMENT 'adresses.cp??.id',
`osm_id` int unsigned NOT NULL DEFAULT '0',
`fk_sector` int unsigned NOT NULL DEFAULT '0',
`osm_name` varchar(50) NOT NULL DEFAULT '',
`numero` varchar(5) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL DEFAULT '',
`rue_bis` varchar(5) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL DEFAULT '',
`rue` varchar(60) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL DEFAULT '',
`cp` varchar(5) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL DEFAULT '',
`ville` varchar(60) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL DEFAULT '',
`gps_lat` varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL DEFAULT '',
`gps_lng` varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL DEFAULT '',
`osm_date_creat` timestamp NOT NULL DEFAULT '0000-00-00 00:00:00',
`created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT 'Date de création',
`updated_at` timestamp NULL DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP COMMENT 'Date de modification',
PRIMARY KEY (`id`),
KEY `sectors_adresses_fk_sector_index` (`fk_sector`),
KEY `sectors_adresses_numero_index` (`numero`),
KEY `sectors_adresses_rue_index` (`rue`),
KEY `sectors_adresses_ville_index` (`ville`),
CONSTRAINT `sectors_adresses_ibfk_1` FOREIGN KEY (`fk_sector`) REFERENCES `ope_sectors` (`id`) ON DELETE RESTRICT ON UPDATE CASCADE
) ENGINE=InnoDB AUTO_INCREMENT=0 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
DROP TABLE IF EXISTS `ope_pass`;
/*!40101 SET @saved_cs_client = @@character_set_client */;
/*!50503 SET character_set_client = utf8mb4 */;
CREATE TABLE `ope_pass` (
`id` int unsigned NOT NULL AUTO_INCREMENT,
`fk_operation` int unsigned NOT NULL DEFAULT '0',
`fk_sector` int unsigned DEFAULT '0',
`fk_user` int unsigned NOT NULL DEFAULT '0',
`fk_adresse` varchar(25) DEFAULT '' COMMENT 'adresses.cp??.id',
`passed_at` timestamp NULL DEFAULT NULL COMMENT 'Date du passage',
`fk_type` int unsigned DEFAULT '0',
`numero` varchar(10) NOT NULL DEFAULT '',
`rue` varchar(75) NOT NULL DEFAULT '',
`rue_bis` varchar(1) NOT NULL DEFAULT '',
`ville` varchar(75) NOT NULL DEFAULT '',
`fk_habitat` int unsigned DEFAULT '1',
`appt` varchar(5) DEFAULT '',
`niveau` varchar(5) DEFAULT '',
`residence` varchar(75) DEFAULT '',
`gps_lat` varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL DEFAULT '',
`gps_lng` varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL DEFAULT '',
`encrypted_name` varchar(255) NOT NULL DEFAULT '',
`montant` decimal(7,2) NOT NULL DEFAULT '0.00',
`fk_type_reglement` int unsigned DEFAULT '1',
`remarque` text DEFAULT '',
`encrypted_email` varchar(255) DEFAULT '',
`nom_recu` varchar(50) COLLATE utf8mb4_unicode_ci DEFAULT NULL,
`date_recu` timestamp NULL DEFAULT NULL COMMENT 'Date de réception',
`date_creat_recu` timestamp NULL DEFAULT NULL COMMENT 'Date de création du reçu',
`date_sent_recu` timestamp NULL DEFAULT NULL COMMENT 'Date envoi du reçu',
`email_erreur` varchar(30) DEFAULT '',
`chk_email_sent` tinyint(1) unsigned NOT NULL DEFAULT '0',
`encrypted_phone` varchar(128) NOT NULL DEFAULT '',
`chk_striped` tinyint(1) unsigned DEFAULT '0',
`docremis` tinyint(1) unsigned DEFAULT '0',
`date_repasser` timestamp NULL DEFAULT NULL COMMENT 'Date prévue pour repasser',
`nb_passages` int DEFAULT '1' COMMENT 'Nb passages pour les a repasser',
`chk_gps_maj` tinyint(1) unsigned DEFAULT '0',
`chk_map_create` tinyint(1) unsigned DEFAULT '0',
`chk_mobile` tinyint(1) unsigned DEFAULT '0',
`chk_synchro` tinyint(1) unsigned DEFAULT '1' COMMENT 'chk synchro entre web et appli',
`chk_api_adresse` tinyint(1) unsigned DEFAULT '0',
`chk_maj_adresse` tinyint(1) unsigned DEFAULT '0',
`anomalie` tinyint(1) unsigned DEFAULT '0',
`created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT 'Date de création',
`fk_user_creat` int unsigned DEFAULT NULL,
`updated_at` timestamp NULL DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP COMMENT 'Date de modification',
`fk_user_modif` int unsigned DEFAULT NULL,
`chk_active` tinyint(1) unsigned NOT NULL DEFAULT '1',
PRIMARY KEY (`id`),
KEY `fk_operation` (`fk_operation`),
KEY `fk_sector` (`fk_sector`),
KEY `fk_user` (`fk_user`),
KEY `fk_type` (`fk_type`),
KEY `fk_type_reglement` (`fk_type_reglement`),
KEY `email` (`email`),
CONSTRAINT `ope_pass_ibfk_1` FOREIGN KEY (`fk_operation`) REFERENCES `operations` (`id`) ON DELETE RESTRICT ON UPDATE CASCADE,
CONSTRAINT `ope_pass_ibfk_2` FOREIGN KEY (`fk_sector`) REFERENCES `ope_sectors` (`id`) ON DELETE RESTRICT ON UPDATE CASCADE,
CONSTRAINT `ope_pass_ibfk_3` FOREIGN KEY (`fk_user`) REFERENCES `users` (`id`) ON DELETE RESTRICT ON UPDATE CASCADE,
CONSTRAINT `ope_pass_ibfk_4` FOREIGN KEY (`fk_type_reglement`) REFERENCES `x_types_reglements` (`id`) ON DELETE RESTRICT ON UPDATE CASCADE
) ENGINE=InnoDB AUTO_INCREMENT=0 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
/*!40101 SET character_set_client = @saved_cs_client */;
DROP TABLE IF EXISTS `ope_pass_histo`;
/*!40101 SET @saved_cs_client = @@character_set_client */;
/*!50503 SET character_set_client = utf8mb4 */;
CREATE TABLE `ope_pass_histo` (
`id` int unsigned NOT NULL AUTO_INCREMENT,
`fk_pass` int unsigned NOT NULL DEFAULT '0',
`date_histo` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT 'Date historique',
`sujet` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT NULL,
`remarque` varchar(250) NOT NULL DEFAULT '',
PRIMARY KEY (`id`),
KEY `ope_pass_histo_fk_pass_IDX` (`fk_pass`) USING BTREE,
KEY `ope_pass_histo_date_histo_IDX` (`date_histo`) USING BTREE,
CONSTRAINT `ope_pass_histo_ibfk_1` FOREIGN KEY (`fk_pass`) REFERENCES `ope_pass` (`id`) ON DELETE CASCADE ON UPDATE CASCADE
) ENGINE=InnoDB AUTO_INCREMENT=0 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
/*!40101 SET character_set_client = @saved_cs_client */;
DROP TABLE IF EXISTS `medias`;
/*!40101 SET @saved_cs_client = @@character_set_client */;
/*!50503 SET character_set_client = utf8mb4 */;
CREATE TABLE `medias` (
`id` int unsigned NOT NULL AUTO_INCREMENT,
`support` varchar(45) NOT NULL DEFAULT '',
`support_id` int unsigned NOT NULL DEFAULT '0',
`fichier` varchar(250) NOT NULL DEFAULT '',
`description` varchar(100) NOT NULL DEFAULT '',
`created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
`fk_user_creat` int unsigned NOT NULL DEFAULT '0',
`updated_at` timestamp NULL DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP,
`fk_user_modif` int unsigned NOT NULL DEFAULT '0',
PRIMARY KEY (`id`),
UNIQUE KEY `id_UNIQUE` (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=0 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
/*!40101 SET character_set_client = @saved_cs_client */;
-- Création des tables pour le système de chat
DROP TABLE IF EXISTS `chat_rooms`;
-- Table des salles de discussion
CREATE TABLE chat_rooms (
id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
name VARCHAR(100) NOT NULL,
type ENUM('privee', 'groupe', 'liste_diffusion') NOT NULL,
date_creation timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT 'Date de création',
fk_user INT UNSIGNED NOT NULL,
fk_entite INT UNSIGNED,
statut ENUM('active', 'archive') NOT NULL DEFAULT 'active',
description TEXT,
INDEX idx_user (fk_user),
INDEX idx_entite (fk_entite)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
DROP TABLE IF EXISTS `chat_participants`;
-- Table des participants aux salles de discussion
CREATE TABLE chat_participants (
id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
id_room INT UNSIGNED NOT NULL,
id_user INT UNSIGNED NOT NULL,
role ENUM('administrateur', 'participant', 'en_lecture_seule') NOT NULL DEFAULT 'participant',
date_ajout timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT 'Date ajout',
notification_activee BOOLEAN NOT NULL DEFAULT TRUE,
INDEX idx_room (id_room),
INDEX idx_user (id_user),
CONSTRAINT uc_room_user UNIQUE (id_room, id_user),
FOREIGN KEY (id_room) REFERENCES chat_rooms(id) ON DELETE CASCADE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
DROP TABLE IF EXISTS `chat_messages`;
-- Table des messages
CREATE TABLE chat_messages (
id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
fk_room INT UNSIGNED NOT NULL,
fk_user INT UNSIGNED NOT NULL,
content TEXT,
date_sent timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT 'Date envoi',
type ENUM('texte', 'media', 'systeme') NOT NULL DEFAULT 'texte',
statut ENUM('envoye', 'livre', 'lu') NOT NULL DEFAULT 'envoye',
INDEX idx_room (fk_room),
INDEX idx_user (fk_user),
INDEX idx_date (date_sent),
FOREIGN KEY (fk_room) REFERENCES chat_rooms(id) ON DELETE CASCADE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
DROP TABLE IF EXISTS `chat_listes_diffusion`;
-- Table des listes de diffusion
CREATE TABLE chat_listes_diffusion (
id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
fk_room INT UNSIGNED NOT NULL,
name VARCHAR(100) NOT NULL,
description TEXT,
fk_user INT UNSIGNED NOT NULL,
date_creation timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT 'Date de création',
INDEX idx_room (fk_room),
INDEX idx_user (fk_user),
FOREIGN KEY (fk_room) REFERENCES chat_rooms(id) ON DELETE CASCADE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
DROP TABLE IF EXISTS `chat_read_messages`;
-- Table pour suivre la lecture des messages
CREATE TABLE chat_read_messages (
id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
fk_message INT UNSIGNED NOT NULL,
fk_user INT UNSIGNED NOT NULL,
date_read timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT 'Date de lecture',
INDEX idx_message (fk_message),
INDEX idx_user (fk_user),
CONSTRAINT uc_message_user UNIQUE (fk_message, fk_user),
FOREIGN KEY (fk_message) REFERENCES chat_messages(id) ON DELETE CASCADE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
DROP TABLE IF EXISTS `chat_notifications`;
-- Table des notifications
CREATE TABLE chat_notifications (
id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
fk_user INT UNSIGNED NOT NULL,
fk_message INT UNSIGNED,
fk_room INT UNSIGNED,
type VARCHAR(50) NOT NULL,
contenu TEXT,
date_creation timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT 'Date de création',
date_lecture timestamp NULL DEFAULT NULL COMMENT 'Date de lecture',
statut ENUM('non_lue', 'lue') NOT NULL DEFAULT 'non_lue',
INDEX idx_user (fk_user),
INDEX idx_message (fk_message),
INDEX idx_room (fk_room),
FOREIGN KEY (fk_message) REFERENCES chat_messages(id) ON DELETE SET NULL,
FOREIGN KEY (fk_room) REFERENCES chat_rooms(id) ON DELETE SET NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
DROP TABLE IF EXISTS `z_params`;
/*!40101 SET @saved_cs_client = @@character_set_client */;
/*!50503 SET character_set_client = utf8mb4 */;
CREATE TABLE `params` (
`id` int unsigned NOT NULL AUTO_INCREMENT,
`libelle` varchar(35) NOT NULL DEFAULT '',
`valeur` varchar(255) NOT NULL DEFAULT '',
`aide` varchar(150) NOT NULL DEFAULT '',
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
/*!40101 SET character_set_client = @saved_cs_client */;
DROP TABLE IF EXISTS `z_sessions`;
/*!40101 SET @saved_cs_client = @@character_set_client */;
/*!50503 SET character_set_client = utf8mb4 */;
CREATE TABLE `z_sessions` (
`sid` text NOT NULL,
`fk_user` int NOT NULL,
`role` varchar(10) DEFAULT NULL,
`date_modified` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
`ip` varchar(50) NOT NULL,
`browser` varchar(150) NOT NULL,
`data` mediumtext
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
/*!40101 SET character_set_client = @saved_cs_client */;

View File

@@ -1,19 +0,0 @@
# Configuration logrotate pour email_queue.log
# À placer dans /etc/logrotate.d/geosector-email-queue
/var/www/geosector/api/logs/email_queue.log {
daily # Rotation journalière
rotate 30 # Garder 30 jours d'historique
compress # Compresser les anciens logs
delaycompress # Compresser le jour suivant
missingok # Pas d'erreur si le fichier n'existe pas
notifempty # Ne pas tourner si vide
create 664 www-data www-data # Créer nouveau fichier avec permissions
dateext # Ajouter la date au nom du fichier
dateformat -%Y%m%d # Format de date YYYYMMDD
maxsize 100M # Rotation si dépasse 100MB même avant la fin du jour
postrotate
# Optionnel : envoyer un signal au process si nécessaire
# /usr/bin/killall -SIGUSR1 php 2>/dev/null || true
endscript
}

View File

@@ -1,166 +0,0 @@
1. Route /session/refresh/all
Méthode : POSTAuthentification : Requise (via session_id dans headers ou cookies)
Headers requis :
Authorization: Bearer {session_id}
// ou
Cookie: session_id={session_id}
Réponse attendue :
{
"status": "success",
"message": "Session refreshed",
"user": {
// Mêmes données que le login
"id": 123,
"email": "user@example.com",
"name": "John Doe",
"fk_role": 2,
"fk_entite": 1,
// ...
},
"amicale": {
// Données de l'amicale
"id": 1,
"name": "Amicale Pompiers",
// ...
},
"operations": [...],
"sectors": [...],
"passages": [...],
"membres": [...],
"session_id": "current_session_id",
"session_expiry": "2024-01-20T10:00:00Z"
}
Code PHP suggéré :
// routes/session.php
Route::post('/session/refresh/all', function(Request $request) {
$user = Auth::user();
if (!$user) {
return response()->json(['status' => 'error', 'message' => 'Not authenticated'], 401);
}
// Retourner les mêmes données qu'un login normal
return response()->json([
'status' => 'success',
'user' => $user->toArray(),
'amicale' => $user->amicale,
'operations' => Operation::where('fk_entite', $user->fk_entite)->get(),
'sectors' => Sector::where('fk_entite', $user->fk_entite)->get(),
'passages' => Passage::where('fk_entite', $user->fk_entite)->get(),
'membres' => Membre::where('fk_entite', $user->fk_entite)->get(),
'session_id' => session()->getId(),
'session_expiry' => now()->addDays(7)->toIso8601String()
]);
});
2. Route /session/refresh/partial
Méthode : POSTAuthentification : Requise
Body requis :
{
"last_sync": "2024-01-19T10:00:00Z"
}
Réponse attendue :
{
"status": "success",
"message": "Partial refresh completed",
"sectors": [
// Uniquement les secteurs modifiés après last_sync
{
"id": 45,
"name": "Secteur A",
"updated_at": "2024-01-19T15:00:00Z",
// ...
}
],
"passages": [
// Uniquement les passages modifiés après last_sync
{
"id": 789,
"fk_sector": 45,
"updated_at": "2024-01-19T14:30:00Z",
// ...
}
],
"operations": [...], // Si modifiées
"membres": [...] // Si modifiés
}
Code PHP suggéré :
// routes/session.php
Route::post('/session/refresh/partial', function(Request $request) {
$user = Auth::user();
if (!$user) {
return response()->json(['status' => 'error', 'message' => 'Not authenticated'], 401);
}
$lastSync = Carbon::parse($request->input('last_sync'));
// Récupérer uniquement les données modifiées après last_sync
$response = [
'status' => 'success',
'message' => 'Partial refresh completed'
];
// Secteurs modifiés
$sectors = Sector::where('fk_entite', $user->fk_entite)
->where('updated_at', '>', $lastSync)
->get();
if ($sectors->count() > 0) {
$response['sectors'] = $sectors;
}
// Passages modifiés
$passages = Passage::where('fk_entite', $user->fk_entite)
->where('updated_at', '>', $lastSync)
->get();
if ($passages->count() > 0) {
$response['passages'] = $passages;
}
// Opérations modifiées
$operations = Operation::where('fk_entite', $user->fk_entite)
->where('updated_at', '>', $lastSync)
->get();
if ($operations->count() > 0) {
$response['operations'] = $operations;
}
// Membres modifiés
$membres = Membre::where('fk_entite', $user->fk_entite)
->where('updated_at', '>', $lastSync)
->get();
if ($membres->count() > 0) {
$response['membres'] = $membres;
}
return response()->json($response);
});
Points importants pour l'API :
1. Vérification de session : Les deux routes doivent vérifier que le session_id est valide et non expiré
2. Timestamps : Assurez-vous que toutes vos tables ont des colonnes updated_at qui sont mises à jour automatiquement
3. Gestion des suppressions : Pour le refresh partiel, vous pourriez ajouter un champ pour les éléments supprimés :
{
"deleted": {
"sectors": [12, 34], // IDs des secteurs supprimés
"passages": [567, 890]
}
}
4. Optimisation : Pour éviter de surcharger, limitez le refresh partiel aux dernières 24-48h maximum
5. Gestion d'erreurs :
{
"status": "error",
"message": "Session expired",
"code": "SESSION_EXPIRED"
}
L'app Flutter s'attend à ces formats de réponse et utilisera automatiquement le refresh partiel si la dernière sync
date de moins de 24h, sinon elle fera un refresh complet.

Binary file not shown.

View File

@@ -1,93 +0,0 @@
%PDF-1.4
%âãÏÓ
1 0 obj
<< /Type /Catalog /Pages 2 0 R >>
endobj
2 0 obj
<< /Type /Pages /Kids [3 0 R] /Count 1 >>
endobj
3 0 obj
<< /Type /Page /Parent 2 0 R /MediaBox [0 0 595 842] /Resources << /Font << /F1 4 0 R >> >> /Contents 5 0 R >>
endobj
4 0 obj
<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica-Bold /Encoding /WinAnsiEncoding >>
endobj
5 0 obj
<< /Length 599 >>
stream
BT
/F1 14 Tf
217 792 Td
(AMICALE TEST DEV PIERRE) Tj
ET
BT
/F1 11 Tf
281 770 Td
(RENNES) Tj
ET
BT
/F1 14 Tf
213.5 726 Td
(RECU FISCAL N 19500582) Tj
ET
BT
/F1 9 Tf
263.75 704 Td
(Article 200 CGI) Tj
ET
BT
/F1 12 Tf
50 657 Td
(Dugues) Tj
ET
BT
/F1 11 Tf
50 637 Td
(8 le Petit Monthelon Acigne) Tj
ET
BT
/F1 16 Tf
257.5 598 Td
(8,00 euros) Tj
ET
BT
/F1 12 Tf
267.5 559 Td
(20/08/2025) Tj
ET
BT
/F1 10 Tf
277.5 529 Td
(OPE 2025) Tj
ET
BT
/F1 9 Tf
198.5 476 Td
(Don ouvrant droit a reduction d'impot de 66%) Tj
ET
BT
/F1 10 Tf
50 419 Td
(Le 20/08/2025) Tj
ET
BT
/F1 10 Tf
50 401 Td
(Le President) Tj
ET
endstream
endobj
xref
0 6
0000000000 65535 f
0000000019 00000 n
0000000068 00000 n
0000000125 00000 n
0000000251 00000 n
0000000353 00000 n
trailer
<< /Size 6 /Root 1 0 R >>
startxref
1003
%%EOF

View File

@@ -1,75 +0,0 @@
%PDF-1.3
1 0 obj
<< /Type /Catalog /Pages 2 0 R >>
endobj
2 0 obj
<< /Type /Pages /Kids [3 0 R] /Count 1 >>
endobj
3 0 obj
<< /Type /Page /Parent 2 0 R /MediaBox [0 0 595 842] /Resources << /Font << /F1 4 0 R >> >> /Contents 5 0 R >>
endobj
4 0 obj
<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>
endobj
5 0 obj
<< /Length 767 >>
stream
BT
/F1 12 Tf
50 750 Td
(AMICALE TEST DEV PIERRE) Tj
0 -20 Td
(17 place hoche 35000 RENNES) Tj
/F1 16 Tf
0 -40 Td
(RECU DE DON N° 19500586) Tj
/F1 10 Tf
0 -15 Td
(Article 200 du Code General des Impots) Tj
/F1 12 Tf
0 -45 Td
(DONATEUR) Tj
/F1 11 Tf
0 -20 Td
(Nom : M. Hermann) Tj
0 -15 Td
(Adresse : 12 le Petit Monthelon Acigne) Tj
0 -15 Td
(Email : pierre.vaissaire@gmail.com) Tj
0 -30 Td
/F1 12 Tf
(DETAILS DU DON) Tj
/F1 11 Tf
0 -20 Td
(Date : 19/08/2025) Tj
0 -15 Td
(Montant : 12,00 EUR) Tj
0 -15 Td
(Mode de reglement : Espece) Tj
0 -15 Td
(Campagne : OPE 2025) Tj
/F1 9 Tf
0 -40 Td
(Reduction d'impot egale a 66% du montant verse dans la limite de 20% du revenu imposable) Tj
/F1 11 Tf
0 -30 Td
(Fait a RENNES, le 19/08/2025) Tj
0 -20 Td
(Le President) Tj
ET
endstream
endobj
xref
0 6
0000000000 65535 f
0000000009 00000 n
0000000058 00000 n
0000000115 00000 n
0000000241 00000 n
0000000311 00000 n
trailer
<< /Size 6 /Root 1 0 R >>
startxref
1129
%%EOF

Binary file not shown.

Binary file not shown.

View File

@@ -1,193 +0,0 @@
USE batiments;
-- Table temp pour FFO (nb_niveau, nb_log)
DROP TABLE IF EXISTS tmp_ffo_999;
CREATE TABLE tmp_ffo_999 (
batiment_groupe_id VARCHAR(50),
code_departement_insee VARCHAR(5),
nb_niveau INT,
annee_construction INT,
usage_niveau_1_txt VARCHAR(100),
mat_mur_txt VARCHAR(100),
mat_toit_txt VARCHAR(100),
nb_log INT,
KEY (batiment_groupe_id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
LOAD DATA LOCAL INFILE '/var/osm/csv/batiment_groupe_ffo_bat.csv'
INTO TABLE tmp_ffo_999
CHARACTER SET 'UTF8mb4'
FIELDS TERMINATED BY ','
OPTIONALLY ENCLOSED BY '"'
IGNORE 1 LINES;
-- Table temp pour Adresse (lien BAN)
DROP TABLE IF EXISTS tmp_adr_999;
CREATE TABLE tmp_adr_999 (
wkt TEXT,
batiment_groupe_id VARCHAR(50),
cle_interop_adr VARCHAR(50),
code_departement_insee VARCHAR(5),
classe VARCHAR(50),
lien_valide TINYINT,
origine VARCHAR(50),
KEY (batiment_groupe_id),
KEY (cle_interop_adr)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
LOAD DATA LOCAL INFILE '/var/osm/csv/rel_batiment_groupe_adresse.csv'
INTO TABLE tmp_adr_999
CHARACTER SET 'UTF8mb4'
FIELDS TERMINATED BY ','
OPTIONALLY ENCLOSED BY '"'
IGNORE 1 LINES;
-- Table temp pour RNC (copropriétés)
DROP TABLE IF EXISTS tmp_rnc_999;
CREATE TABLE tmp_rnc_999 (
batiment_groupe_id VARCHAR(50),
code_departement_insee VARCHAR(5),
numero_immat_principal VARCHAR(50),
periode_construction_max VARCHAR(50),
l_annee_construction VARCHAR(100),
nb_lot_garpark INT,
nb_lot_tot INT,
nb_log INT,
nb_lot_tertiaire INT,
l_nom_copro VARCHAR(200),
l_siret VARCHAR(50),
copro_dans_pvd TINYINT,
KEY (batiment_groupe_id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
LOAD DATA LOCAL INFILE '/var/osm/csv/batiment_groupe_rnc.csv'
INTO TABLE tmp_rnc_999
CHARACTER SET 'UTF8mb4'
FIELDS TERMINATED BY ','
OPTIONALLY ENCLOSED BY '"'
IGNORE 1 LINES;
-- Table temp pour BDTOPO (altitude)
DROP TABLE IF EXISTS tmp_topo_999;
CREATE TABLE tmp_topo_999 (
batiment_groupe_id VARCHAR(50),
code_departement_insee VARCHAR(5),
l_nature VARCHAR(200),
l_usage_1 VARCHAR(200),
l_usage_2 VARCHAR(200),
l_etat VARCHAR(100),
hauteur_mean DECIMAL(10,2),
max_hauteur DECIMAL(10,2),
altitude_sol_mean DECIMAL(10,2),
KEY (batiment_groupe_id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
LOAD DATA LOCAL INFILE '/var/osm/csv/batiment_groupe_bdtopo_bat.csv'
INTO TABLE tmp_topo_999
CHARACTER SET 'UTF8mb4'
FIELDS TERMINATED BY ','
OPTIONALLY ENCLOSED BY '"'
IGNORE 1 LINES;
-- Table temp pour Usage principal
DROP TABLE IF EXISTS tmp_usage_999;
CREATE TABLE tmp_usage_999 (
batiment_groupe_id VARCHAR(50),
code_departement_insee VARCHAR(5),
usage_principal_bdnb_open VARCHAR(100),
KEY (batiment_groupe_id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
LOAD DATA LOCAL INFILE '/var/osm/csv/batiment_groupe_synthese_propriete_usage.csv'
INTO TABLE tmp_usage_999
CHARACTER SET 'UTF8mb4'
FIELDS TERMINATED BY ','
OPTIONALLY ENCLOSED BY '"'
IGNORE 1 LINES;
-- Table temp pour DLE Enedis (compteurs électriques)
DROP TABLE IF EXISTS tmp_dle_999;
CREATE TABLE tmp_dle_999 (
batiment_groupe_id VARCHAR(50),
code_departement_insee VARCHAR(5),
millesime VARCHAR(10),
nb_pdl_res INT,
nb_pdl_pro INT,
nb_pdl_tot INT,
conso_res DECIMAL(12,2),
conso_pro DECIMAL(12,2),
conso_tot DECIMAL(12,2),
conso_res_par_pdl DECIMAL(12,2),
conso_pro_par_pdl DECIMAL(12,2),
conso_tot_par_pdl DECIMAL(12,2),
KEY (batiment_groupe_id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
LOAD DATA LOCAL INFILE '/var/osm/csv/batiment_groupe_dle_elec_multimillesime.csv'
INTO TABLE tmp_dle_999
CHARACTER SET 'UTF8mb4'
FIELDS TERMINATED BY ','
OPTIONALLY ENCLOSED BY '"'
IGNORE 1 LINES;
-- Création de la table finale avec jointure et filtre
DROP TABLE IF EXISTS bat999;
CREATE TABLE bat999 (
batiment_groupe_id VARCHAR(50) PRIMARY KEY,
code_departement_insee VARCHAR(5),
cle_interop_adr VARCHAR(50),
nb_niveau INT,
nb_log INT,
nb_pdl_tot INT,
annee_construction INT,
residence VARCHAR(200),
usage_principal VARCHAR(100),
altitude_sol_mean DECIMAL(10,2),
gps_lat DECIMAL(10,7),
gps_lng DECIMAL(10,7),
KEY (cle_interop_adr),
KEY (usage_principal),
KEY (nb_log)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
INSERT INTO bat999
SELECT
f.batiment_groupe_id,
f.code_departement_insee,
a.cle_interop_adr,
f.nb_niveau,
f.nb_log,
d.nb_pdl_tot,
f.annee_construction,
REPLACE(REPLACE(REPLACE(REPLACE(r.l_nom_copro, '[', ''), ']', ''), '"', ''), ' ', ' ') as residence,
u.usage_principal_bdnb_open as usage_principal,
t.altitude_sol_mean,
NULL as gps_lat,
NULL as gps_lng
FROM tmp_ffo_999 f
INNER JOIN tmp_adr_999 a ON f.batiment_groupe_id = a.batiment_groupe_id AND a.lien_valide = 1
LEFT JOIN tmp_rnc_999 r ON f.batiment_groupe_id = r.batiment_groupe_id
LEFT JOIN tmp_topo_999 t ON f.batiment_groupe_id = t.batiment_groupe_id
LEFT JOIN tmp_usage_999 u ON f.batiment_groupe_id = u.batiment_groupe_id
LEFT JOIN tmp_dle_999 d ON f.batiment_groupe_id = d.batiment_groupe_id
WHERE u.usage_principal_bdnb_open IN ('Résidentiel individuel', 'Résidentiel collectif', 'Secondaire', 'Tertiaire')
AND f.nb_log > 1
AND a.cle_interop_adr IS NOT NULL
GROUP BY f.batiment_groupe_id;
-- Mise à jour des coordonnées GPS depuis la base adresses
UPDATE bat999 b
JOIN adresses.cp999 a ON b.cle_interop_adr = a.id
SET b.gps_lat = a.gps_lat, b.gps_lng = a.gps_lng
WHERE b.cle_interop_adr IS NOT NULL;
-- Nettoyage des tables temporaires
DROP TABLE IF EXISTS tmp_ffo_999;
DROP TABLE IF EXISTS tmp_adr_999;
DROP TABLE IF EXISTS tmp_rnc_999;
DROP TABLE IF EXISTS tmp_topo_999;
DROP TABLE IF EXISTS tmp_usage_999;
DROP TABLE IF EXISTS tmp_dle_999;
-- Historique
INSERT INTO _histo SET date_import=NOW(), dept='999', nb_batiments=(SELECT COUNT(*) FROM bat999);

View File

@@ -15,18 +15,6 @@ require_once __DIR__ . '/src/Core/Response.php';
require_once __DIR__ . '/src/Utils/ClientDetector.php';
require_once __DIR__ . '/src/Services/LogService.php';
// Chargement des services
require_once __DIR__ . '/src/Services/StripeService.php';
// Chargement des services de sécurité
require_once __DIR__ . '/src/Services/Security/PerformanceMonitor.php';
require_once __DIR__ . '/src/Services/Security/IPBlocker.php';
require_once __DIR__ . '/src/Services/Security/SecurityMonitor.php';
require_once __DIR__ . '/src/Services/Security/AlertService.php';
// Chargement de la classe Controller de base
require_once __DIR__ . '/src/Core/Controller.php';
// Chargement des contrôleurs
require_once __DIR__ . '/src/Controllers/LogController.php';
require_once __DIR__ . '/src/Controllers/LoginController.php';
@@ -37,13 +25,6 @@ require_once __DIR__ . '/src/Controllers/PassageController.php';
require_once __DIR__ . '/src/Controllers/VilleController.php';
require_once __DIR__ . '/src/Controllers/FileController.php';
require_once __DIR__ . '/src/Controllers/SectorController.php';
require_once __DIR__ . '/src/Controllers/PasswordController.php';
require_once __DIR__ . '/src/Controllers/ChatController.php';
require_once __DIR__ . '/src/Controllers/SecurityController.php';
require_once __DIR__ . '/src/Controllers/StripeController.php';
require_once __DIR__ . '/src/Controllers/StripeWebhookController.php';
require_once __DIR__ . '/src/Controllers/MigrationController.php';
require_once __DIR__ . '/src/Controllers/HealthController.php';
// Initialiser la configuration
$appConfig = AppConfig::getInstance();
@@ -75,132 +56,8 @@ if ($_SERVER['REQUEST_METHOD'] === 'OPTIONS') {
// Initialiser la session
Session::start();
// ===== DÉBUT DU MONITORING DE SÉCURITÉ =====
use App\Services\Security\PerformanceMonitor;
use App\Services\Security\IPBlocker;
use App\Services\Security\SecurityMonitor;
use App\Services\Security\AlertService;
// Obtenir l'IP du client
$clientIp = $_SERVER['REMOTE_ADDR'] ?? 'unknown';
// Vérifier si l'IP est bloquée
if (IPBlocker::isBlocked($clientIp)) {
http_response_code(403);
Response::json([
'status' => 'error',
'message' => 'Access denied. Your IP has been blocked.',
'error_code' => 'IP_BLOCKED'
], 403);
exit;
}
// Vérifier le rate limiting
if (!SecurityMonitor::checkRateLimit($clientIp)) {
http_response_code(429);
Response::json([
'status' => 'error',
'message' => 'Too many requests. Please try again later.',
'error_code' => 'RATE_LIMIT_EXCEEDED'
], 429);
exit;
}
// Démarrer le monitoring de performance
PerformanceMonitor::startRequest();
// Capturer le endpoint pour le monitoring
$requestUri = $_SERVER['REQUEST_URI'] ?? '/';
$requestMethod = $_SERVER['REQUEST_METHOD'] ?? 'GET';
// Vérifier les patterns de scan
if (!SecurityMonitor::checkScanPattern($requestUri)) {
// Pattern suspect détecté, bloquer l'IP temporairement
IPBlocker::block($clientIp, 3600, 'Suspicious scan pattern detected');
http_response_code(404);
Response::json([
'status' => 'error',
'message' => 'Not found'
], 404);
exit;
}
// Vérifier les paramètres pour injection SQL
$allParams = array_merge($_GET, $_POST, json_decode(file_get_contents('php://input'), true) ?? []);
if (!empty($allParams) && !SecurityMonitor::checkRequestParameters($allParams)) {
// Injection SQL détectée, bloquer l'IP définitivement
IPBlocker::blockPermanent($clientIp, 'SQL injection attempt');
http_response_code(400);
Response::json([
'status' => 'error',
'message' => 'Bad request'
], 400);
exit;
}
// Créer l'instance de routeur
$router = new Router();
// Enregistrer une fonction de shutdown pour capturer les métriques
register_shutdown_function(function() use ($requestUri, $requestMethod) {
$statusCode = http_response_code();
// Terminer le monitoring de performance
PerformanceMonitor::endRequest($requestUri, $requestMethod, $statusCode);
// Vérifier les patterns 404
if ($statusCode === 404) {
$clientIp = $_SERVER['REMOTE_ADDR'] ?? 'unknown';
SecurityMonitor::check404Pattern($clientIp);
}
// Alerter sur les erreurs 500
if ($statusCode >= 500) {
$error = error_get_last();
AlertService::trigger('HTTP_500', [
'endpoint' => $requestUri,
'method' => $requestMethod,
'error_message' => $error['message'] ?? 'Unknown error',
'error_file' => $error['file'] ?? 'Unknown',
'error_line' => $error['line'] ?? 0,
'message' => "Erreur serveur 500 sur $requestUri"
], 'ERROR');
}
// Nettoyer périodiquement les IPs expirées (1% de chance)
if (rand(1, 100) === 1) {
IPBlocker::cleanupExpired();
}
});
// Gérer les erreurs non capturées
set_exception_handler(function($exception) use ($requestUri, $requestMethod) {
// Logger l'erreur
error_log("Uncaught exception: " . $exception->getMessage());
// Créer une alerte
AlertService::trigger('UNCAUGHT_EXCEPTION', [
'endpoint' => $requestUri,
'method' => $requestMethod,
'exception' => get_class($exception),
'message' => $exception->getMessage(),
'file' => $exception->getFile(),
'line' => $exception->getLine(),
'trace' => substr($exception->getTraceAsString(), 0, 1000)
], 'ERROR');
// Retourner une erreur 500
http_response_code(500);
Response::json([
'status' => 'error',
'message' => 'Internal server error'
], 500);
});
// Gérer la requête
try {
$router->handle();
} catch (Exception $e) {
// Les exceptions sont gérées par le handler ci-dessus
throw $e;
}
$router->handle();

158
api/livre-api.sh Executable file
View File

@@ -0,0 +1,158 @@
#!/bin/bash
# Vérification des arguments
if [ $# -ne 1 ]; then
echo "Usage: $0 <environment>"
echo " rec : Livrer de DVA (dva-geo) vers RECETTE (rca-geo)"
echo " prod : Livrer de RECETTE (rca-geo) vers PRODUCTION (pra-geo)"
echo ""
echo "Examples:"
echo " $0 rec # DVA → RECETTE"
echo " $0 prod # RECETTE → PRODUCTION"
exit 1
fi
HOST_IP="195.154.80.116"
HOST_USER=root
HOST_KEY=/home/pierre/.ssh/id_rsa_mbpi
HOST_PORT=22
# Mapping des environnements
ENVIRONMENT=$1
case $ENVIRONMENT in
"rca")
SOURCE_CONTAINER="dva-geo"
DEST_CONTAINER="rca-geo"
ENV_NAME="RECETTE"
;;
"pra")
SOURCE_CONTAINER="rca-geo"
DEST_CONTAINER="pra-geo"
ENV_NAME="PRODUCTION"
;;
*)
echo "❌ Environnement '$ENVIRONMENT' non reconnu"
echo "Utilisez 'rec' pour RECETTE ou 'prod' pour PRODUCTION"
exit 1
;;
esac
API_PATH="/var/www/geosector/api"
TIMESTAMP=$(date +"%Y%m%d_%H%M%S")
BACKUP_DIR="${API_PATH}_backup_${TIMESTAMP}"
PROJECT="default"
echo "🔄 Livraison vers $ENV_NAME : $SOURCE_CONTAINER$DEST_CONTAINER (projet: $PROJECT)"
# Vérifier si les containers existent
echo "🔍 Vérification des containers..."
ssh -i $HOST_KEY -p $HOST_PORT $HOST_USER@$HOST_IP "incus info $SOURCE_CONTAINER --project $PROJECT" > /dev/null 2>&1
if [ $? -ne 0 ]; then
echo "❌ Erreur: Le container source $SOURCE_CONTAINER n'existe pas ou n'est pas accessible dans le projet $PROJECT"
exit 1
fi
ssh -i $HOST_KEY -p $HOST_PORT $HOST_USER@$HOST_IP "incus info $DEST_CONTAINER --project $PROJECT" > /dev/null 2>&1
if [ $? -ne 0 ]; then
echo "❌ Erreur: Le container destination $DEST_CONTAINER n'existe pas ou n'est pas accessible dans le projet $PROJECT"
exit 1
fi
# Créer une sauvegarde du dossier de destination avant de le remplacer
echo "📦 Création d'une sauvegarde sur $DEST_CONTAINER..."
# Vérifier si le dossier API existe
ssh -i $HOST_KEY -p $HOST_PORT $HOST_USER@$HOST_IP "incus exec $DEST_CONTAINER --project $PROJECT -- test -d $API_PATH"
if [ $? -eq 0 ]; then
# Le dossier existe, créer une sauvegarde
ssh -i $HOST_KEY -p $HOST_PORT $HOST_USER@$HOST_IP "incus exec $DEST_CONTAINER --project $PROJECT -- cp -r $API_PATH $BACKUP_DIR"
echo "✅ Sauvegarde créée dans $BACKUP_DIR"
else
echo "⚠️ Le dossier API n'existe pas sur la destination"
fi
# Copier le dossier API entre les containers
echo "📋 Copie des fichiers en cours..."
# Nettoyage sélectif : supprimer seulement le code, pas les données (logs et uploads)
echo "🧹 Nettoyage sélectif (préservation de logs et uploads)..."
ssh -i $HOST_KEY -p $HOST_PORT $HOST_USER@$HOST_IP "incus exec $DEST_CONTAINER --project $PROJECT -- find $API_PATH -mindepth 1 -maxdepth 1 ! -name 'uploads' ! -name 'logs' -exec rm -rf {} \;"
# Copier directement du container source vers le container destination (en excluant logs et uploads)
echo "📤 Transfert du code (hors logs et uploads)..."
ssh -i $HOST_KEY -p $HOST_PORT $HOST_USER@$HOST_IP "incus exec $SOURCE_CONTAINER --project $PROJECT -- tar -cf - -C $API_PATH --exclude='uploads' --exclude='logs' . | incus exec $DEST_CONTAINER --project $PROJECT -- tar -xf - -C $API_PATH"
if [ $? -ne 0 ]; then
echo "❌ Erreur lors du transfert entre containers"
echo "⚠️ Tentative de restauration de la sauvegarde..."
# Vérifier si la sauvegarde existe
ssh -i $HOST_KEY -p $HOST_PORT $HOST_USER@$HOST_IP "incus exec $DEST_CONTAINER --project $PROJECT -- test -d $BACKUP_DIR"
if [ $? -eq 0 ]; then
# La sauvegarde existe, la restaurer
ssh -i $HOST_KEY -p $HOST_PORT $HOST_USER@$HOST_IP "incus exec $DEST_CONTAINER --project $PROJECT -- rm -rf $API_PATH"
ssh -i $HOST_KEY -p $HOST_PORT $HOST_USER@$HOST_IP "incus exec $DEST_CONTAINER --project $PROJECT -- cp -r $BACKUP_DIR $API_PATH"
echo "✅ Restauration réussie"
else
echo "❌ Échec de la restauration"
fi
exit 1
fi
echo "✅ Code transféré avec succès (logs et uploads préservés)"
# Changer le propriétaire et les permissions des fichiers
echo "👤 Application des droits et permissions pour tous les fichiers..."
# Définir le propriétaire pour tous les fichiers
ssh -i $HOST_KEY -p $HOST_PORT $HOST_USER@$HOST_IP "incus exec $DEST_CONTAINER --project $PROJECT -- chown -R nginx:nginx $API_PATH"
# Appliquer les permissions de base pour les dossiers (755)
ssh -i $HOST_KEY -p $HOST_PORT $HOST_USER@$HOST_IP "incus exec $DEST_CONTAINER --project $PROJECT -- find $API_PATH -type d -exec chmod 755 {} \;"
# Appliquer les permissions pour les fichiers (644)
ssh -i $HOST_KEY -p $HOST_PORT $HOST_USER@$HOST_IP "incus exec $DEST_CONTAINER --project $PROJECT -- find $API_PATH -type f -exec chmod 644 {} \;"
# Appliquer des permissions spécifiques pour le dossier logs (pour permettre à PHP-FPM de l'utilisateur nobody d'y écrire)
ssh -i $HOST_KEY -p $HOST_PORT $HOST_USER@$HOST_IP "incus exec $DEST_CONTAINER --project $PROJECT -- test -d $API_PATH/logs"
if [ $? -eq 0 ]; then
# Changer le groupe du dossier logs à nobody (utilisateur PHP-FPM)
ssh -i $HOST_KEY -p $HOST_PORT $HOST_USER@$HOST_IP "incus exec $DEST_CONTAINER --project $PROJECT -- chown -R nginx:nobody $API_PATH/logs"
# Appliquer les permissions 775 pour le dossier
ssh -i $HOST_KEY -p $HOST_PORT $HOST_USER@$HOST_IP "incus exec $DEST_CONTAINER --project $PROJECT -- chmod -R 775 $API_PATH/logs"
# Appliquer les permissions 664 pour les fichiers
ssh -i $HOST_KEY -p $HOST_PORT $HOST_USER@$HOST_IP "incus exec $DEST_CONTAINER --project $PROJECT -- find $API_PATH/logs -type f -exec chmod 664 {} \;"
echo "✅ Droits spécifiques appliqués au dossier logs (nginx:nobody avec permissions 775/664)"
else
echo "⚠️ Le dossier logs n'existe pas"
fi
# Vérifier et corriger les permissions du dossier uploads s'il existe
ssh -i $HOST_KEY -p $HOST_PORT $HOST_USER@$HOST_IP "incus exec $DEST_CONTAINER --project $PROJECT -- test -d $API_PATH/uploads"
if [ $? -eq 0 ]; then
# S'assurer que uploads a les bonnes permissions
ssh -i $HOST_KEY -p $HOST_PORT $HOST_USER@$HOST_IP "incus exec $DEST_CONTAINER --project $PROJECT -- chown -R nginx:nobody $API_PATH/uploads"
ssh -i $HOST_KEY -p $HOST_PORT $HOST_USER@$HOST_IP "incus exec $DEST_CONTAINER --project $PROJECT -- chmod -R 775 $API_PATH/uploads"
ssh -i $HOST_KEY -p $HOST_PORT $HOST_USER@$HOST_IP "incus exec $DEST_CONTAINER --project $PROJECT -- find $API_PATH/uploads -type f -exec chmod 664 {} \;"
echo "✅ Droits vérifiés pour le dossier uploads (nginx:nginx avec permissions 775)"
else
# Créer le dossier uploads s'il n'existe pas
ssh -i $HOST_KEY -p $HOST_PORT $HOST_USER@$HOST_IP "incus exec $DEST_CONTAINER --project $PROJECT -- mkdir -p $API_PATH/uploads"
ssh -i $HOST_KEY -p $HOST_PORT $HOST_USER@$HOST_IP "incus exec $DEST_CONTAINER --project $PROJECT -- chown -R nginx:nobody $API_PATH/uploads"
ssh -i $HOST_KEY -p $HOST_PORT $HOST_USER@$HOST_IP "incus exec $DEST_CONTAINER --project $PROJECT -- chmod -R 775 $API_PATH/uploads"
ssh -i $HOST_KEY -p $HOST_PORT $HOST_USER@$HOST_IP "incus exec $DEST_CONTAINER --project $PROJECT -- find $API_PATH/uploads -type f -exec chmod 664 {} \;"
echo "✅ Dossier uploads créé avec les bonnes permissions (nginx:nginx avec permissions 775/664)"
fi
echo "✅ Propriétaire et permissions appliqués avec succès"
# Vérifier la copie
echo "✅ Vérification de la copie..."
ssh -i $HOST_KEY -p $HOST_PORT $HOST_USER@$HOST_IP "incus exec $DEST_CONTAINER --project $PROJECT -- test -d $API_PATH"
if [ $? -eq 0 ]; then
echo "✅ Copie réussie"
else
echo "❌ Erreur: Le dossier API n'a pas été copié correctement"
fi
echo "✅ Livraison vers $ENV_NAME terminée avec succès!"
echo "📤 Source: $SOURCE_CONTAINER → Destination: $DEST_CONTAINER"
echo "📁 Sauvegarde créée: $BACKUP_DIR sur $DEST_CONTAINER"
echo "🔒 Données préservées: logs/ et uploads/ intouchés"
echo "👤 Permissions: nginx:nginx (755/644) + logs (nginx:nobody 775/664)"

View File

@@ -1,290 +0,0 @@
# 🔧 CORRECTIONS CRITIQUES - migrate_from_backup.php
## ❌ ERREURS DÉTECTÉES
### 1. **migrateUsers** (ligne 456)
```sql
-- ERREUR
u.nom, u.prenom, u.nom_sect, u.username, u.password, u.phone, u.mobile
-- CORRECTION (noms réels dans geosector.users)
u.libelle, u.prenom, u.nom_tournee, u.username, u.userpass, u.telephone, u.mobile
```
### 2. **migrateOpePass** (ligne 1043)
```sql
-- ERREUR
p.passed_at, p.libelle, p.email, p.phone
-- CORRECTION (noms réels dans geosector.ope_pass)
p.date_eve AS passed_at, p.libelle AS encrypted_name, p.email, p.phone
```
### 3. **migrateSectorsAdresses** (ligne 777)
```sql
-- ERREUR
sa.osm_id, sa.osm_name, sa.osm_date_creat
-- CORRECTION (ces champs n'existent PAS dans geosector.sectors_adresses)
-- Ces champs doivent être mis à 0 ou NULL dans la cible
0 AS osm_id, '' AS osm_name, NULL AS osm_date_creat
```
### 4. **migrateOpeUsersSectors** (ligne 955)
```sql
-- ERREUR
ous.date_creat, ous.fk_user_creat, ous.date_modif, ous.fk_user_modif
-- CORRECTION (geosector.ope_users_sectors n'a PAS ces champs)
NULL AS created_at, NULL AS fk_user_creat, NULL AS updated_at, NULL AS fk_user_modif
```
### 5. **migrateMedias** (à vérifier)
```sql
-- ERREUR potentielle
m.support_rowid
-- CORRECTION
m.support_rowid AS support_id
```
### 6. **migrateOperations** (erreur NOT NULL)
```sql
-- PROBLÈME: Column 'fk_user_modif' cannot be null
-- CORRECTION: Utiliser 0 au lieu de NULL
'fk_user_modif' => $row['fk_user_modif'] ?? 0
```
---
## ✅ SOLUTION RAPIDE
Créez un script `HOTFIX_migrate.sql` pour corriger rapidement :
```sql
-- Permettre NULL sur les champs problématiques
ALTER TABLE operations MODIFY COLUMN fk_user_modif INT(10) UNSIGNED NULL DEFAULT NULL;
ALTER TABLE ope_sectors MODIFY COLUMN fk_user_modif INT(10) UNSIGNED NULL DEFAULT NULL;
ALTER TABLE ope_users MODIFY COLUMN fk_user_creat INT(10) UNSIGNED NULL DEFAULT NULL;
ALTER TABLE ope_users MODIFY COLUMN fk_user_modif INT(10) UNSIGNED NULL DEFAULT NULL;
ALTER TABLE ope_users_sectors MODIFY COLUMN fk_user_creat INT(10) UNSIGNED NULL DEFAULT NULL;
ALTER TABLE ope_users_sectors MODIFY COLUMN fk_user_modif INT(10) UNSIGNED NULL DEFAULT NULL;
```
OU utiliser `0` à la place de `NULL` systématiquement dans le script PHP.
---
## 📋 STATUT DES CORRECTIONS (10/10/2025)
1.**migrateEntites** - CORRIGÉ (cp, tel1, tel2, demo)
2.**migrateUsers** - CORRIGÉ (libelle, nom_tournee, telephone, userpass, alert_email) - Lignes 455-537
3.**migrateOperations** - CORRIGÉ (fk_user_modif ?? 0, fk_user_creat ?? 0) - Lignes 614-625
4.**migrateOpeSectors** - CORRIGÉ (fk_user_modif ?? 0, fk_user_creat ?? 0) - Lignes 727-738
5.**migrateSectorsAdresses** - CORRIGÉ (osm_id=0, osm_name='', osm_date_creat=null, created_at/updated_at=null) - Lignes 776-855
6.**migrateOpeUsers** - CORRIGÉ (vérification existence user dans TARGET avant insertion) - Lignes 960-1020
7.**migrateOpeUsersSectors** - CORRIGÉ (date_creat, fk_user_creat, date_modif, fk_user_modif = null + vérification user) - Lignes 1054-1135
8.**migrateOpePass** - CORRIGÉ (date_eve, libelle, recu + fk_type_reglement forcé à 4 si invalide + vérification user) - Lignes 1215-1330
9.**migrateMedias** - CORRIGÉ (support_rowid, type_fichier, hauteur/largeur) - Lignes 1281-1343
10.**countTargetRows()** - CORRIGÉ (requêtes SQL spécifiques par table avec JOINs corrects) - Lignes 303-355
---
## ✅ CORRECTIONS APPLIQUÉES
**Toutes les erreurs ont été corrigées dans `migrate_from_backup.php`.**
Les corrections incluent :
- Utilisation des vrais noms de colonnes SOURCE (`geosector-structure.sql`)
- Gestion des champs manquants dans SOURCE avec valeurs par défaut
- Utilisation de `?? 0` au lieu de `?? null` pour les FK NOT NULL
- Suppression des champs inexistants dans les requêtes SELECT
**ATTENTION** : Les noms de colonnes TARGET n'ont PAS été vérifiés contre `geo_app_structure.sql`.
Le script utilise peut-être les mauvais noms TARGET (à vérifier avec `migrate_users.php` et autres `migrate_*.php` de référence).
---
## 🔧 CORRECTIONS RÉCENTES (Session actuelle)
### 10. **Vérification FK users** (lignes 1008-1015, 1117-1125, 1257-1266)
**Problème** : Violations de contraintes FK car certains `fk_user` référencent des utilisateurs absents dans TARGET.
**Solution** : Ajout de vérification d'existence avant insertion :
```php
// Vérifier que fk_user existe dans users de la TARGET
$checkUser = $this->targetDb->prepare("SELECT id FROM users WHERE id = ?");
$checkUser->execute([$row['fk_user']]);
if (!$checkUser->fetch()) {
$this->log(" ⚠ Record {$row['rowid']}: user {$row['fk_user']} non trouvé, ignoré", 'WARNING');
continue;
}
```
**Appliqué sur** :
- `migrateOpeUsers()` - ligne 1008
- `migrateOpeUsersSectors()` - ligne 1117
- `migrateOpePass()` - ligne 1257
**Résultat** : Les enregistrements avec FK invalides sont ignorés avec un WARNING au lieu de provoquer une erreur fatale.
### 11. **countTargetRows() - Requêtes SQL spécifiques** (lignes 303-355)
**Problème** : Erreurs SQL car toutes les tables n'ont pas les mêmes colonnes/relations :
- `Unknown column 'fk_entite' in 'WHERE'` pour `entites`
- `Unknown column 't.fk_operation' in 'ON'` pour `operations`, `ope_pass_histo`, `medias`
**Solution** : Requêtes SQL personnalisées par table :
```php
// Pour entites : pas de FK, juste l'ID
if ($tableName === 'entites') {
$sql = "SELECT COUNT(*) as count FROM $tableName WHERE id = :entity_id";
}
// Pour operations : FK directe vers entites
else if ($tableName === 'operations') {
$sql = "SELECT COUNT(*) as count FROM $tableName WHERE fk_entite = :entity_id";
}
// Pour sectors_adresses : JOIN via ope_sectors -> operations
else if ($tableName === 'sectors_adresses') {
$sql = "SELECT COUNT(*) as count FROM $tableName sa
INNER JOIN ope_sectors s ON sa.fk_sector = s.id
INNER JOIN operations o ON s.fk_operation = o.id
WHERE o.fk_entite = :entity_id";
}
// Pour tables avec fk_operation directe
else if (in_array($tableName, ['ope_sectors', 'ope_users', 'ope_users_sectors', 'ope_pass', 'ope_pass_histo', 'medias'])) {
$sql = "SELECT COUNT(*) as count FROM $tableName t
INNER JOIN operations o ON t.fk_operation = o.id
WHERE o.fk_entite = :entity_id";
}
```
**Résultat** : Comptages TARGET précis et sans erreurs SQL pour toutes les tables.
### 12. **fk_type_reglement validation** (lignes 1237-1241)
**Problème** : FK violations car certains `fk_type_reglement` référencent des IDs inexistants dans `x_types_reglements` (IDs valides : 1, 2, 3).
**Solution** : Forcer à 4 ("-") si valeur invalide (comme dans `migrate_ope_pass.php`) :
```php
// Vérification et correction du type de règlement
$fkTypeReglement = $row['fk_type_reglement'] ?? 1;
if (!in_array($fkTypeReglement, [1, 2, 3])) {
$fkTypeReglement = 4; // Forcer à 4 ("-") si différent de 1, 2 ou 3
}
```
**Résultat** : Tous les `ope_pass` sont migrés sans violation de FK sur `fk_type_reglement`.
### 13. **Limitation aux 3 dernières opérations** (lignes 646-647) ⚠️ IMPORTANT
**Problème** : Migration de TOUTES les opérations au lieu des 3 dernières uniquement.
**Solution** : Ajout de `ORDER BY rowid DESC LIMIT 3` dans la requête :
```php
// Ne migrer que les 3 dernières opérations (plus récentes)
$sql .= " ORDER BY rowid DESC LIMIT 3";
```
**Résultat** : Seules les 3 opérations les plus récentes (par rowid DESC) sont migrées par entité.
**Impact** : Réduit considérablement le volume de données migrées et toutes les tables liées (ope_sectors, ope_users, ope_users_sectors, ope_pass, medias, sectors_adresses).
### 14. **Option de suppression avant migration** (lignes 127-200, 1692, 1722, 1776) ⭐ NOUVELLE FONCTIONNALITÉ
**Besoin** : Permettre de supprimer les données existantes d'une entité dans TARGET avant migration pour repartir à zéro.
**Solution** : Ajout du paramètre `--delete-before` :
**Script bash** (lignes 174-183) :
```bash
# Demander si suppression des données de l'entité avant migration
echo -ne "${YELLOW}3⃣ Supprimer les données existantes de cette entité dans la TARGET avant migration ? (y/N): ${NC}"
read -r DELETE_BEFORE
DELETE_FLAG=""
if [[ $DELETE_BEFORE =~ ^[Yy]$ ]]; then
echo -e "${GREEN}${NC} Les données seront supprimées avant migration"
DELETE_FLAG="--delete-before"
fi
```
**Script PHP** - Méthode `deleteEntityData()` (lignes 127-200) :
```php
private function deleteEntityData($entityId) {
// Ordre de suppression inverse pour respecter les FK
$deletionOrder = [
'medias', 'ope_pass_histo', 'ope_pass', 'ope_users_sectors',
'ope_users', 'sectors_adresses', 'ope_sectors', 'operations', 'users'
];
foreach ($deletionOrder as $table) {
// Suppression via JOIN avec operations pour respecter FK
DELETE t FROM $table t
INNER JOIN operations o ON t.fk_operation = o.id
WHERE o.fk_entite = ?
}
}
```
**Résultat** :
- En mode interactif, l'utilisateur peut choisir de supprimer les données existantes avant migration
- Suppression propre dans l'ordre inverse des FK (pas d'erreur de contrainte)
- L'entité elle-même n'est PAS supprimée (car peut avoir d'autres données liées)
- Transaction avec rollback en cas d'erreur
**Usage** :
```bash
# Interactif
./scripts/migrate_batch.sh
# Choisir option d) puis répondre 'y' à la question de suppression
# Direct
php migrate_from_backup.php --source-db=geosector_20251008 --mode=entity --entity-id=5 --delete-before
```
---
## 📊 RÉSULTATS MIGRATION TEST (Entité #5)
Dernière exécution avec toutes les corrections :
-**Entités** : 1 SOURCE → 1 TARGET
-**Users** : 21 SOURCE → 21 TARGET (100%)
-**Operations** : 4 SOURCE → 4 TARGET (100%)
-**Ope_sectors** : 64 SOURCE → 64 TARGET (100%)
- ⚠️ **Sectors_adresses** : 1975 SOURCE → 1040 TARGET (différence de -935, à investiguer)
-**Ope_users** : 20 migrés (0 erreurs après vérification FK)
-**Ope_users_sectors** : 20 migrés (0 erreurs après vérification FK)
- ⚠️ **Ope_pass** : 466 erreurs (users manquants - comportement attendu avec validation FK)
-**Medias** : Migration réussie
### 15. **Ajout de contraintes UNIQUE pour éviter les doublons** (10/10/2025) ⭐ CONTRAINTES MANQUANTES
**Problème** : Les tables `ope_users` et `ope_users_sectors` n'avaient PAS de contrainte UNIQUE sur leurs combinaisons de FK, permettant des doublons massifs.
**Diagnostic** :
- Table `ope_users` : 186+ doublons pour la même paire (fk_operation, fk_user)
- Table `ope_users_sectors` : Risque de doublons sur (fk_operation, fk_user, fk_sector)
- Le `ON DUPLICATE KEY UPDATE` ne fonctionnait pas car aucune contrainte UNIQUE n'existait
**Solution** : Création du script `scripts/sql/add_unique_constraints_ope_tables.sql` qui :
1. Supprime les doublons existants (garde la première occurrence, supprime les duplicatas)
2. Ajoute `UNIQUE KEY idx_operation_user (fk_operation, fk_user)` sur `ope_users`
3. Ajoute `UNIQUE KEY idx_operation_user_sector (fk_operation, fk_user, fk_sector)` sur `ope_users_sectors`
4. Vérifie les contraintes et compte les doublons restants
**Fichiers modifiés** :
- `scripts/sql/add_unique_constraints_ope_tables.sql` - Script SQL d'ajout des contraintes
- `scripts/php/geo_app_structure.sql` - Documentation de la structure cible avec contraintes
**À exécuter AVANT la prochaine migration** :
```bash
mysql -u root -p pra_geo < scripts/sql/add_unique_constraints_ope_tables.sql
```
**Puis re-migrer l'entité** :
```bash
php migrate_from_backup.php --source-db=geosector_20251008 --mode=entity --entity-id=5 --delete-before
```
---
**Prochaines étapes** :
1. ✅ Exécuter le script SQL pour ajouter les contraintes UNIQUE
2. ✅ Re-migrer l'entité #5 avec `--delete-before` pour vérifier l'absence de doublons
3. Investiguer la différence de -935 sur `sectors_adresses`
4. Analyser les 466 erreurs sur `ope_pass` (probablement des références à des users d'autres entités)
5. Tester sur une autre entité pour valider la stabilité des corrections

View File

@@ -1,350 +0,0 @@
# Instructions de modification des scripts de migration
## Modifications à effectuer
### 1. migrate_from_backup.php
#### A. Remplacer les lignes 31-50 (configuration DB)
**ANCIEN** :
```php
private $sourceDbName;
private $targetDbName;
private $sourceDb;
private $targetDb;
private $mode;
private $entityId;
private $logFile;
private $deleteBefore;
// Configuration MariaDB (maria4 sur IN4)
// pra-geo se connecte à maria4 via l'IP du container
private const DB_HOST = '13.23.33.4'; // maria4 sur IN4
private const DB_PORT = 3306;
private const DB_USER = 'pra_geo_user';
private const DB_PASS = 'd2jAAGGWi8fxFrWgXjOA';
// Pour la base source (backup), on utilise pra_geo_user (avec SELECT sur geosector_*)
// L'utilisateur root n'est pas accessible depuis pra-geo (13.23.33.22)
private const DB_USER_ROOT = 'pra_geo_user';
private const DB_PASS_ROOT = 'd2jAAGGWi8fxFrWgXjOA';
```
**NOUVEAU** :
```php
private $sourceDbName;
private $targetDbName;
private $sourceDb;
private $targetDb;
private $mode;
private $entityId;
private $logFile;
private $deleteBefore;
private $env;
// Configuration multi-environnement
private const ENVIRONMENTS = [
'rca' => [
'host' => '13.23.33.3', // maria3 sur IN3
'port' => 3306,
'user' => 'rca_geo_user',
'pass' => 'UPf3C0cQ805LypyM71iW',
'target_db' => 'rca_geo',
'source_db' => 'geosector' // Base synchronisée par PM7
],
'pra' => [
'host' => '13.23.33.4', // maria4 sur IN4
'port' => 3306,
'user' => 'pra_geo_user',
'pass' => 'd2jAAGGWi8fxFrWgXjOA',
'target_db' => 'pra_geo',
'source_db' => 'geosector' // Base synchronisée par PM7
]
];
```
#### B. Modifier le constructeur (ligne 67)
**ANCIEN** :
```php
public function __construct($sourceDbName, $targetDbName, $mode = 'global', $entityId = null, $logFile = null, $deleteBefore = false) {
$this->sourceDbName = $sourceDbName;
$this->targetDbName = $targetDbName;
$this->mode = $mode;
$this->entityId = $entityId;
$this->logFile = $logFile ?? '/var/back/migration_' . date('Ymd_His') . '.log';
$this->deleteBefore = $deleteBefore;
$this->log("=== Migration depuis backup PM7 ===");
$this->log("Source: {$sourceDbName}");
$this->log("Cible: {$targetDbName}");
$this->log("Mode: {$mode}");
```
**NOUVEAU** :
```php
public function __construct($env, $mode = 'global', $entityId = null, $logFile = null, $deleteBefore = false) {
// Validation de l'environnement
if (!isset(self::ENVIRONMENTS[$env])) {
throw new Exception("Invalid environment: $env. Use 'rca' or 'pra'");
}
$this->env = $env;
$config = self::ENVIRONMENTS[$env];
$this->sourceDbName = $config['source_db'];
$this->targetDbName = $config['target_db'];
$this->mode = $mode;
$this->entityId = $entityId;
$this->logFile = $logFile ?? '/var/back/migration_' . date('Ymd_His') . '.log';
$this->deleteBefore = $deleteBefore;
$this->log("=== Migration depuis backup PM7 ===");
$this->log("Environment: {$env}");
$this->log("Source: {$this->sourceDbName} → Cible: {$this->targetDbName}");
$this->log("Mode: {$mode}");
```
#### C. Modifier connect() (lignes 90-112)
**Remplacer toutes les constantes** :
- `self::DB_HOST``self::ENVIRONMENTS[$this->env]['host']`
- `self::DB_PORT``self::ENVIRONMENTS[$this->env]['port']`
- `self::DB_USER_ROOT``self::ENVIRONMENTS[$this->env]['user']`
- `self::DB_PASS_ROOT``self::ENVIRONMENTS[$this->env]['pass']`
- `self::DB_USER``self::ENVIRONMENTS[$this->env]['user']`
- `self::DB_PASS``self::ENVIRONMENTS[$this->env]['pass']`
#### D. Modifier parseArguments() (vers la fin du fichier)
**ANCIEN** :
```php
$args = [
'source-db' => null,
'target-db' => 'pra_geo',
'mode' => 'global',
'entity-id' => null,
'log' => null,
'delete-before' => true,
'help' => false
];
```
**NOUVEAU** :
```php
$args = [
'env' => 'rca', // Défaut: recette
'mode' => 'global',
'entity-id' => null,
'log' => null,
'delete-before' => true,
'help' => false
];
```
#### E. Modifier showHelp()
**ANCIEN** :
```php
--source-db=NAME Nom de la base source (backup restauré, ex: geosector_20251007) [REQUIS]
--target-db=NAME Nom de la base cible (défaut: pra_geo)
```
**NOUVEAU** :
```php
--env=ENV Environment: 'rca' (recette) ou 'pra' (production) [défaut: rca]
```
**ANCIEN** (exemples) :
```php
php migrate_from_backup.php --source-db=geosector_20251007 --target-db=pra_geo --mode=global
```
**NOUVEAU** :
```php
php migrate_from_backup.php --env=pra --mode=global
php migrate_from_backup.php --env=rca --mode=entity --entity-id=45
```
#### F. Modifier validation des arguments
**ANCIEN** :
```php
if (!$args['source-db']) {
echo "Erreur: --source-db est requis\n\n";
showHelp();
exit(1);
}
```
**NOUVEAU** :
```php
if (!in_array($args['env'], ['rca', 'pra'])) {
echo "Erreur: --env doit être 'rca' ou 'pra'\n\n";
showHelp();
exit(1);
}
```
#### G. Modifier instanciation BackupMigration
**ANCIEN** :
```php
$migration = new BackupMigration(
$args['source-db'],
$args['target-db'],
$args['mode'],
$args['entity-id'],
$args['log'],
(bool)$args['delete-before']
);
```
**NOUVEAU** :
```php
$migration = new BackupMigration(
$args['env'],
$args['mode'],
$args['entity-id'],
$args['log'],
(bool)$args['delete-before']
);
```
---
### 2. migrate_batch.sh
#### A. Ajouter détection automatique de l'environnement (après ligne 22)
**AJOUTER** :
```bash
# Détection automatique de l'environnement
if [ -f "/etc/hostname" ]; then
CONTAINER_NAME=$(cat /etc/hostname)
case $CONTAINER_NAME in
rca-geo)
ENV="rca"
;;
pra-geo)
ENV="pra"
;;
*)
ENV="rca" # Défaut
;;
esac
else
ENV="rca" # Défaut
fi
```
#### B. Remplacer lignes 26-27
**ANCIEN** :
```bash
SOURCE_DB="geosector_20251013_13"
TARGET_DB="pra_geo"
```
**NOUVEAU** :
```bash
# SOURCE_DB et TARGET_DB ne sont plus utilisés
# Ils sont déduits de --env dans migrate_from_backup.php
```
#### C. Ajouter option --env dans le parsing (ligne 68)
**AJOUTER avant `--interactive|-i)` ** :
```bash
--env)
ENV="$2"
shift 2
;;
```
#### D. Modifier les appels PHP - ligne 200-206
**ANCIEN** :
```bash
php "$MIGRATION_SCRIPT" \
--source-db="$SOURCE_DB" \
--target-db="$TARGET_DB" \
--mode=entity \
--entity-id="$SPECIFIC_ENTITY_ID" \
--log="$ENTITY_LOG" \
$DELETE_FLAG
```
**NOUVEAU** :
```bash
php "$MIGRATION_SCRIPT" \
--env="$ENV" \
--mode=entity \
--entity-id="$SPECIFIC_ENTITY_ID" \
--log="$ENTITY_LOG" \
$DELETE_FLAG
```
#### E. Modifier les appels PHP - ligne 374-379
**ANCIEN** :
```bash
php "$MIGRATION_SCRIPT" \
--source-db="$SOURCE_DB" \
--target-db="$TARGET_DB" \
--mode=entity \
--entity-id="$ENTITY_ID" \
--log="$ENTITY_LOG" > /tmp/migration_output_$$.txt 2>&1
```
**NOUVEAU** :
```bash
php "$MIGRATION_SCRIPT" \
--env="$ENV" \
--mode=entity \
--entity-id="$ENTITY_ID" \
--log="$ENTITY_LOG" > /tmp/migration_output_$$.txt 2>&1
```
#### F. Modifier les messages de log (lignes 289-291)
**ANCIEN** :
```bash
log "📅 Date: $(date '+%Y-%m-%d %H:%M:%S')"
log "📁 Source: $SOURCE_DB"
log "📁 Cible: $TARGET_DB"
```
**NOUVEAU** :
```bash
log "📅 Date: $(date '+%Y-%m-%d %H:%M:%S')"
log "🌍 Environment: $ENV"
log "📁 Source: geosector → Target: (déduit de \$ENV)"
```
---
## Nouveaux usages
### Sur rca-geo (IN3)
```bash
# Détection automatique
./migrate_batch.sh
# Ou explicite
./migrate_batch.sh --env=rca
# Migration PHP directe
php php/migrate_from_backup.php --env=rca --mode=entity --entity-id=45
```
### Sur pra-geo (IN4)
```bash
# Détection automatique
./migrate_batch.sh
# Ou explicite
./migrate_batch.sh --env=pra
# Migration PHP directe
php php/migrate_from_backup.php --env=pra --mode=entity --entity-id=45
```

File diff suppressed because it is too large Load Diff

View File

@@ -1,165 +0,0 @@
#!/bin/bash
##############################################################################
# Script de mise à jour des paramètres PHP-FPM pour GeoSector
#
# Usage:
# ./update_php_fpm_settings.sh dev # Pour DVA
# ./update_php_fpm_settings.sh rec # Pour RCA
# ./update_php_fpm_settings.sh prod # Pour PRA
##############################################################################
set -e
# Couleurs
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m' # No Color
# Déterminer l'environnement
ENV=${1:-dev}
case $ENV in
dev)
CONTAINER="dva-geo"
TIMEOUT=180
MAX_REQUESTS=1000
MEMORY_LIMIT=512M
;;
rec)
CONTAINER="rca-geo"
TIMEOUT=120
MAX_REQUESTS=2000
MEMORY_LIMIT=256M
;;
prod)
CONTAINER="pra-geo"
TIMEOUT=120
MAX_REQUESTS=2000
MEMORY_LIMIT=256M
;;
*)
echo -e "${RED}Erreur: Environnement invalide '$ENV'${NC}"
echo "Usage: $0 [dev|rec|prod]"
exit 1
;;
esac
echo -e "${GREEN}=== Mise à jour PHP-FPM pour $ENV ($CONTAINER) ===${NC}"
echo ""
# Vérifier que le container existe
if ! incus list | grep -q "$CONTAINER"; then
echo -e "${RED}Erreur: Container $CONTAINER non trouvé${NC}"
exit 1
fi
# Trouver le fichier de configuration
echo "Recherche du fichier de configuration PHP-FPM..."
POOL_FILE=$(incus exec $CONTAINER -- find /etc/php* -name "www.conf" 2>/dev/null | grep fpm/pool | head -1)
if [ -z "$POOL_FILE" ]; then
echo -e "${RED}Erreur: Fichier pool PHP-FPM non trouvé${NC}"
exit 1
fi
echo -e "${GREEN}✓ Fichier trouvé: $POOL_FILE${NC}"
echo ""
# Sauvegarder le fichier original
BACKUP_FILE="${POOL_FILE}.backup.$(date +%Y%m%d_%H%M%S)"
echo "Création d'une sauvegarde..."
incus exec $CONTAINER -- cp "$POOL_FILE" "$BACKUP_FILE"
echo -e "${GREEN}✓ Sauvegarde créée: $BACKUP_FILE${NC}"
echo ""
# Afficher les valeurs actuelles
echo "Valeurs actuelles:"
incus exec $CONTAINER -- grep -E "^(request_terminate_timeout|pm.max_requests|memory_limit)" "$POOL_FILE" || echo " (non définies)"
echo ""
# Créer un fichier temporaire avec les nouvelles valeurs
TMP_FILE="/tmp/php_fpm_update_$$.conf"
cat > $TMP_FILE << EOF
; === Configuration GeoSector - Modifié le $(date +%Y-%m-%d) ===
; Timeout des requêtes
request_terminate_timeout = ${TIMEOUT}s
; Nombre max de requêtes avant recyclage du worker
pm.max_requests = ${MAX_REQUESTS}
; Limite mémoire PHP
php_admin_value[memory_limit] = ${MEMORY_LIMIT}
; Log des requêtes lentes
slowlog = /var/log/php8.3-fpm-slow.log
request_slowlog_timeout = 10s
EOF
echo "Nouvelles valeurs à appliquer:"
cat $TMP_FILE
echo ""
# Demander confirmation
read -p "Appliquer ces modifications ? (y/N) " -n 1 -r
echo ""
if [[ ! $REPLY =~ ^[Yy]$ ]]; then
echo "Annulé."
rm $TMP_FILE
exit 0
fi
# Supprimer les anciennes valeurs si présentes
echo "Suppression des anciennes valeurs..."
incus exec $CONTAINER -- sed -i '/^request_terminate_timeout/d' "$POOL_FILE"
incus exec $CONTAINER -- sed -i '/^pm.max_requests/d' "$POOL_FILE"
incus exec $CONTAINER -- sed -i '/^php_admin_value\[memory_limit\]/d' "$POOL_FILE"
incus exec $CONTAINER -- sed -i '/^slowlog/d' "$POOL_FILE"
incus exec $CONTAINER -- sed -i '/^request_slowlog_timeout/d' "$POOL_FILE"
# Ajouter les nouvelles valeurs à la fin du fichier
echo "Ajout des nouvelles valeurs..."
incus file push $TMP_FILE $CONTAINER/tmp/php_fpm_settings.conf
incus exec $CONTAINER -- bash -c "cat /tmp/php_fpm_settings.conf >> $POOL_FILE"
incus exec $CONTAINER -- rm /tmp/php_fpm_settings.conf
rm $TMP_FILE
echo -e "${GREEN}✓ Configuration mise à jour${NC}"
echo ""
# Tester la configuration
echo "Test de la configuration PHP-FPM..."
if incus exec $CONTAINER -- php-fpm8.3 -t; then
echo -e "${GREEN}✓ Configuration valide${NC}"
else
echo -e "${RED}✗ Configuration invalide !${NC}"
echo "Restauration de la sauvegarde..."
incus exec $CONTAINER -- cp "$BACKUP_FILE" "$POOL_FILE"
exit 1
fi
echo ""
echo "Redémarrage de PHP-FPM..."
incus exec $CONTAINER -- rc-service php-fpm8.3 restart
if [ $? -eq 0 ]; then
echo -e "${GREEN}✓ PHP-FPM redémarré avec succès${NC}"
else
echo -e "${RED}✗ Erreur lors du redémarrage${NC}"
echo "Restauration de la sauvegarde..."
incus exec $CONTAINER -- cp "$BACKUP_FILE" "$POOL_FILE"
incus exec $CONTAINER -- rc-service php-fpm8.3 restart
exit 1
fi
echo ""
echo -e "${GREEN}=== Mise à jour terminée avec succès ===${NC}"
echo ""
echo "Vérification des nouvelles valeurs:"
incus exec $CONTAINER -- grep -E "^(request_terminate_timeout|pm.max_requests|php_admin_value\[memory_limit\])" "$POOL_FILE"
echo ""
echo "Sauvegarde disponible: $BACKUP_FILE"

View File

@@ -1,273 +0,0 @@
# Documentation des tâches CRON - API Geosector
Ce dossier contient les scripts automatisés de maintenance et de traitement pour l'API Geosector.
## Scripts disponibles
### 1. `process_email_queue.php`
**Fonction** : Traite la queue d'emails en attente (reçus fiscaux, notifications)
**Caractéristiques** :
- Traite 50 emails maximum par exécution
- 3 tentatives maximum par email
- Lock file pour éviter l'exécution simultanée
- Nettoyage automatique des emails envoyés de plus de 30 jours
**Fréquence recommandée** : Toutes les 5 minutes
**Ligne crontab** :
```bash
*/5 * * * * /usr/bin/php /var/www/geosector/api/scripts/cron/process_email_queue.php >> /var/www/geosector/api/logs/email_queue.log 2>&1
```
---
### 2. `cleanup_security_data.php`
**Fonction** : Purge les données de sécurité obsolètes selon la politique de rétention
**Données nettoyées** :
- Métriques de performance : 30 jours
- Tentatives de login échouées : 7 jours
- Alertes résolues : 90 jours
- IPs expirées : Déblocage immédiat
**Fréquence recommandée** : Quotidien à 2h du matin
**Ligne crontab** :
```bash
0 2 * * * /usr/bin/php /var/www/geosector/api/scripts/cron/cleanup_security_data.php >> /var/www/geosector/api/logs/cleanup_security.log 2>&1
```
---
### 3. `cleanup_logs.php`
**Fonction** : Supprime les fichiers de logs de plus de 10 jours
**Caractéristiques** :
- Cible tous les fichiers `*.log` dans `/api/logs/`
- Exclut le dossier `/logs/events/` (rétention 15 mois)
- Rétention : 10 jours
- Logs détaillés des fichiers supprimés et taille libérée
- Lock file pour éviter l'exécution simultanée
**Fréquence recommandée** : Quotidien à 3h du matin
**Ligne crontab** :
```bash
0 3 * * * /usr/bin/php /var/www/geosector/api/scripts/cron/cleanup_logs.php >> /var/www/geosector/api/logs/cleanup_logs.log 2>&1
```
---
### 4. `rotate_event_logs.php`
**Fonction** : Rotation des logs d'événements JSONL (système EventLogService)
**Politique de rétention (15 mois)** :
- 0-15 mois : fichiers `.jsonl` conservés (non compressés pour accès API)
- > 15 mois : suppression automatique
**Caractéristiques** :
- Suppression des fichiers > 15 mois
- Pas de compression (fichiers accessibles par l'API)
- Logs détaillés des suppressions
- Lock file pour éviter l'exécution simultanée
**Fréquence recommandée** : Mensuel le 1er à 3h du matin
**Ligne crontab** :
```bash
0 3 1 * * /usr/bin/php /var/www/geosector/api/scripts/cron/rotate_event_logs.php >> /var/www/geosector/api/logs/rotation_events.log 2>&1
```
---
### 5. `update_stripe_devices.php`
**Fonction** : Met à jour la liste des appareils Android certifiés pour Tap to Pay
**Caractéristiques** :
- Liste de 95+ devices intégrée
- Ajoute les nouveaux appareils certifiés
- Met à jour les versions Android minimales
- Désactive les appareils obsolètes
- Notification email si changements importants
- Possibilité de personnaliser via `/data/stripe_certified_devices.json`
**Fréquence recommandée** : Hebdomadaire le dimanche à 3h
**Ligne crontab** :
```bash
0 3 * * 0 /usr/bin/php /var/www/geosector/api/scripts/cron/update_stripe_devices.php >> /var/www/geosector/api/logs/stripe_devices.log 2>&1
```
---
### 6. `sync_databases.php`
**Fonction** : Synchronise les bases de données entre environnements
**Note** : Ce script est spécifique à un cas d'usage particulier. Vérifier son utilité avant activation.
**Fréquence recommandée** : À définir selon les besoins
**Ligne crontab** :
```bash
# À configurer selon les besoins
# 0 4 * * * /usr/bin/php /var/www/geosector/api/scripts/cron/sync_databases.php >> /var/www/geosector/api/logs/sync_databases.log 2>&1
```
---
## Installation sur les containers Incus
### 1. Déployer les scripts sur les environnements
```bash
# DEV (dva-geo sur IN3)
./deploy-api.sh
# RECETTE (rca-geo sur IN3)
./deploy-api.sh rca
# PRODUCTION (pra-geo sur IN4)
./deploy-api.sh pra
```
### 2. Configurer le crontab sur chaque container
```bash
# Se connecter au container
incus exec dva-geo -- sh # ou rca-geo, pra-geo
# Éditer le crontab
crontab -e
# Ajouter les lignes ci-dessous (adapter les chemins si nécessaire)
```
### 3. Configuration complète recommandée
```bash
# Traitement de la queue d'emails (toutes les 5 minutes)
*/5 * * * * /usr/bin/php /var/www/geosector/api/scripts/cron/process_email_queue.php >> /var/www/geosector/api/logs/email_queue.log 2>&1
# Nettoyage des données de sécurité (quotidien à 2h)
0 2 * * * /usr/bin/php /var/www/geosector/api/scripts/cron/cleanup_security_data.php >> /var/www/geosector/api/logs/cleanup_security.log 2>&1
# Nettoyage des anciens logs (quotidien à 3h)
0 3 * * * /usr/bin/php /var/www/geosector/api/scripts/cron/cleanup_logs.php >> /var/www/geosector/api/logs/cleanup_logs.log 2>&1
# Rotation des logs événements (mensuel le 1er à 3h)
0 3 1 * * /usr/bin/php /var/www/geosector/api/scripts/cron/rotate_event_logs.php >> /var/www/geosector/api/logs/rotation_events.log 2>&1
# Mise à jour des devices Stripe (hebdomadaire dimanche à 3h)
0 3 * * 0 /usr/bin/php /var/www/geosector/api/scripts/cron/update_stripe_devices.php >> /var/www/geosector/api/logs/stripe_devices.log 2>&1
```
### 4. Vérifier que les CRONs sont actifs
```bash
# Lister les CRONs configurés
crontab -l
# Vérifier les logs pour s'assurer qu'ils s'exécutent
tail -f /var/www/geosector/api/logs/email_queue.log
tail -f /var/www/geosector/api/logs/cleanup_logs.log
```
---
## Surveillance et monitoring
### Emplacement des logs
Tous les logs CRON sont stockés dans `/var/www/geosector/api/logs/` :
- `email_queue.log` : Traitement de la queue d'emails
- `cleanup_security.log` : Nettoyage des données de sécurité
- `cleanup_logs.log` : Nettoyage des anciens fichiers logs
- `rotation_events.log` : Rotation des logs événements JSONL
- `stripe_devices.log` : Mise à jour des devices Tap to Pay
### Vérification de l'exécution
```bash
# Voir les dernières exécutions du processeur d'emails
tail -n 50 /var/www/geosector/api/logs/email_queue.log
# Voir les derniers nettoyages de logs
tail -n 50 /var/www/geosector/api/logs/cleanup_logs.log
# Voir les dernières rotations des logs événements
tail -n 50 /var/www/geosector/api/logs/rotation_events.log
# Voir les dernières mises à jour Stripe
tail -n 50 /var/www/geosector/api/logs/stripe_devices.log
```
---
## Notes importantes
1. **Détection d'environnement** : Tous les scripts détectent automatiquement l'environnement via `gethostname()` :
- `pra-geo` → Production (app3.geosector.fr)
- `rca-geo` → Recette (rapp.geosector.fr)
- `dva-geo` → Développement (dapp.geosector.fr)
2. **Lock files** : Les scripts critiques utilisent des fichiers de lock dans `/tmp/` pour éviter l'exécution simultanée
3. **Permissions** : Les scripts doivent être exécutables (`chmod +x script.php`)
4. **Logs** : Tous les scripts loggent via `LogService` pour traçabilité complète
---
## Dépannage
### Le CRON ne s'exécute pas
```bash
# Vérifier que le service cron est actif
rc-service crond status # Alpine Linux
# Relancer le service si nécessaire
rc-service crond restart
```
### Erreur de permissions
```bash
# Vérifier les permissions du script
ls -l /var/www/geosector/api/scripts/cron/
# Rendre exécutable si nécessaire
chmod +x /var/www/geosector/api/scripts/cron/*.php
# Vérifier les permissions du dossier logs
ls -ld /var/www/geosector/api/logs/
```
### Lock file bloqué
```bash
# Si un script semble bloqué, supprimer le lock file
rm /tmp/process_email_queue.lock
rm /tmp/cleanup_logs.lock
```

View File

@@ -1,165 +0,0 @@
#!/usr/bin/env php
<?php
/**
* Script CRON pour nettoyer les anciens fichiers de logs
* Supprime les fichiers .log de plus de 10 jours dans le dossier /logs/
*
* À exécuter quotidiennement via crontab :
* 0 3 * * * /usr/bin/php /var/www/geosector/api/scripts/cron/cleanup_logs.php >> /var/www/geosector/api/logs/cleanup_logs.log 2>&1
*/
declare(strict_types=1);
// Configuration
define('LOG_RETENTION_DAYS', 10);
define('LOCK_FILE', '/tmp/cleanup_logs.lock');
// Empêcher l'exécution multiple simultanée
if (file_exists(LOCK_FILE)) {
$lockTime = filemtime(LOCK_FILE);
// Si le lock a plus de 30 minutes, on le supprime (processus probablement bloqué)
if (time() - $lockTime > 1800) {
unlink(LOCK_FILE);
} else {
die("Le processus est déjà en cours d'exécution\n");
}
}
// Créer le fichier de lock
file_put_contents(LOCK_FILE, getmypid());
// Enregistrer un handler pour supprimer le lock en cas d'arrêt
register_shutdown_function(function() {
if (file_exists(LOCK_FILE)) {
unlink(LOCK_FILE);
}
});
// Simuler l'environnement web pour AppConfig en CLI
if (php_sapi_name() === 'cli') {
// Détecter l'environnement basé sur le hostname
$hostname = gethostname();
if (strpos($hostname, 'pra') !== false) {
$_SERVER['SERVER_NAME'] = 'app3.geosector.fr';
} elseif (strpos($hostname, 'rca') !== false) {
$_SERVER['SERVER_NAME'] = 'rapp.geosector.fr';
} else {
$_SERVER['SERVER_NAME'] = 'dapp.geosector.fr'; // DVA par défaut
}
$_SERVER['HTTP_HOST'] = $_SERVER['HTTP_HOST'] ?? $_SERVER['SERVER_NAME'];
$_SERVER['REMOTE_ADDR'] = $_SERVER['REMOTE_ADDR'] ?? '127.0.0.1';
// Définir getallheaders si elle n'existe pas (CLI)
if (!function_exists('getallheaders')) {
function getallheaders() {
return [];
}
}
}
// Chargement de l'environnement
require_once __DIR__ . '/../../vendor/autoload.php';
require_once __DIR__ . '/../../src/Config/AppConfig.php';
require_once __DIR__ . '/../../src/Services/LogService.php';
try {
// Initialisation de la configuration
$appConfig = AppConfig::getInstance();
$environment = $appConfig->getEnvironment();
// Définir le chemin du dossier logs
$logDir = __DIR__ . '/../../logs';
if (!is_dir($logDir)) {
echo "Le dossier de logs n'existe pas : {$logDir}\n";
exit(0);
}
// Date limite (10 jours en arrière)
$cutoffDate = time() - (LOG_RETENTION_DAYS * 24 * 60 * 60);
// Lister tous les fichiers .log (exclure le dossier events/)
$logFiles = glob($logDir . '/*.log');
// Exclure explicitement les logs du sous-dossier events/
$logFiles = array_filter($logFiles, function($file) {
return strpos($file, '/events/') === false;
});
if (empty($logFiles)) {
echo "Aucun fichier .log trouvé dans {$logDir}\n";
exit(0);
}
$deletedCount = 0;
$deletedSize = 0;
$deletedFiles = [];
foreach ($logFiles as $file) {
$fileTime = filemtime($file);
// Vérifier si le fichier est plus vieux que la date limite
if ($fileTime < $cutoffDate) {
$fileSize = filesize($file);
$fileName = basename($file);
if (unlink($file)) {
$deletedCount++;
$deletedSize += $fileSize;
$deletedFiles[] = $fileName;
echo "Supprimé : {$fileName} (" . number_format($fileSize / 1024, 2) . " KB)\n";
} else {
echo "ERREUR : Impossible de supprimer {$fileName}\n";
}
}
}
// Logger le résumé
if ($deletedCount > 0) {
$message = sprintf(
"Nettoyage des logs terminé - %d fichier(s) supprimé(s) - %.2f MB libérés",
$deletedCount,
$deletedSize / (1024 * 1024)
);
LogService::log($message, [
'level' => 'info',
'script' => 'cleanup_logs.php',
'environment' => $environment,
'deleted_count' => $deletedCount,
'deleted_size_mb' => round($deletedSize / (1024 * 1024), 2),
'deleted_files' => $deletedFiles
]);
echo "\n" . $message . "\n";
} else {
echo "Aucun fichier à supprimer (tous les logs ont moins de " . LOG_RETENTION_DAYS . " jours)\n";
}
} catch (Exception $e) {
$errorMsg = 'Erreur lors du nettoyage des logs : ' . $e->getMessage();
LogService::log($errorMsg, [
'level' => 'error',
'script' => 'cleanup_logs.php',
'trace' => $e->getTraceAsString()
]);
echo $errorMsg . "\n";
// Supprimer le lock en cas d'erreur
if (file_exists(LOCK_FILE)) {
unlink(LOCK_FILE);
}
exit(1);
}
// Supprimer le lock
if (file_exists(LOCK_FILE)) {
unlink(LOCK_FILE);
}
exit(0);

View File

@@ -1,150 +0,0 @@
#!/usr/bin/env php
<?php
/**
* Script de nettoyage des données de sécurité
* À exécuter via cron quotidiennement
* Exemple crontab: 0 2 * * * /usr/bin/php /var/www/geosector/api/scripts/cron/cleanup_security_data.php
*/
declare(strict_types=1);
// Configuration
require_once __DIR__ . '/../../bootstrap.php';
require_once __DIR__ . '/../../src/Config/AppConfig.php';
require_once __DIR__ . '/../../src/Core/Database.php';
// Initialiser la configuration
$appConfig = AppConfig::getInstance();
$config = $appConfig->getFullConfig();
// Initialiser la base de données
Database::init($config['database']);
$db = Database::getInstance();
// Configuration de rétention (en jours)
$RETENTION_DAYS = [
'performance_metrics' => 30, // Garder 30 jours de métriques
'failed_login_attempts' => 7, // Garder 7 jours de tentatives
'resolved_alerts' => 90, // Garder 90 jours d'alertes résolues
'expired_blocks' => 0 // Débloquer immédiatement les IPs expirées
];
echo "[" . date('Y-m-d H:i:s') . "] Début du nettoyage des données de sécurité\n";
try {
$totalDeleted = 0;
// 1. Nettoyer les métriques de performance
echo "- Nettoyage des métriques de performance (>" . $RETENTION_DAYS['performance_metrics'] . " jours)...\n";
$stmt = $db->prepare('
DELETE FROM sec_performance_metrics
WHERE created_at < DATE_SUB(NOW(), INTERVAL :days DAY)
');
$stmt->execute(['days' => $RETENTION_DAYS['performance_metrics']]);
$deleted = $stmt->rowCount();
echo "$deleted lignes supprimées\n";
$totalDeleted += $deleted;
// 2. Nettoyer les tentatives de login échouées
echo "- Nettoyage des tentatives de login (>" . $RETENTION_DAYS['failed_login_attempts'] . " jours)...\n";
$stmt = $db->prepare('
DELETE FROM sec_failed_login_attempts
WHERE attempt_time < DATE_SUB(NOW(), INTERVAL :days DAY)
');
$stmt->execute(['days' => $RETENTION_DAYS['failed_login_attempts']]);
$deleted = $stmt->rowCount();
echo "$deleted lignes supprimées\n";
$totalDeleted += $deleted;
// 3. Nettoyer les alertes résolues
echo "- Nettoyage des alertes résolues (>" . $RETENTION_DAYS['resolved_alerts'] . " jours)...\n";
$stmt = $db->prepare('
DELETE FROM sec_alerts
WHERE resolved = 1
AND resolved_at < DATE_SUB(NOW(), INTERVAL :days DAY)
');
$stmt->execute(['days' => $RETENTION_DAYS['resolved_alerts']]);
$deleted = $stmt->rowCount();
echo "$deleted lignes supprimées\n";
$totalDeleted += $deleted;
// 4. Débloquer les IPs expirées
echo "- Déblocage des IPs expirées...\n";
$stmt = $db->prepare('
UPDATE sec_blocked_ips
SET unblocked_at = NOW()
WHERE blocked_until <= NOW()
AND unblocked_at IS NULL
AND permanent = 0
');
$stmt->execute();
$unblocked = $stmt->rowCount();
echo "$unblocked IPs débloquées\n";
// 5. Supprimer les anciennes IPs débloquées (optionnel, garder 180 jours d'historique)
echo "- Suppression des anciennes IPs débloquées (>180 jours)...\n";
$stmt = $db->prepare('
DELETE FROM sec_blocked_ips
WHERE unblocked_at IS NOT NULL
AND unblocked_at < DATE_SUB(NOW(), INTERVAL 180 DAY)
');
$stmt->execute();
$deleted = $stmt->rowCount();
echo "$deleted lignes supprimées\n";
$totalDeleted += $deleted;
// 6. Optimiser les tables (optionnel, peut être long sur de grosses tables)
if ($totalDeleted > 1000) {
echo "- Optimisation des tables...\n";
$tables = [
'sec_performance_metrics',
'sec_failed_login_attempts',
'sec_alerts',
'sec_blocked_ips'
];
foreach ($tables as $table) {
try {
$db->exec("OPTIMIZE TABLE $table");
echo " → Table $table optimisée\n";
} catch (Exception $e) {
echo " ⚠ Impossible d'optimiser $table: " . $e->getMessage() . "\n";
}
}
}
// 7. Statistiques finales
echo "\n=== RÉSUMÉ ===\n";
echo "Total supprimé: $totalDeleted lignes\n";
echo "IPs débloquées: $unblocked\n";
// Obtenir les statistiques actuelles
$stats = [];
$tables = [
'sec_alerts' => "SELECT COUNT(*) as total, SUM(resolved = 0) as active FROM sec_alerts",
'sec_performance_metrics' => "SELECT COUNT(*) as total FROM sec_performance_metrics",
'sec_failed_login_attempts' => "SELECT COUNT(*) as total FROM sec_failed_login_attempts",
'sec_blocked_ips' => "SELECT COUNT(*) as total, SUM(permanent = 1) as permanent FROM sec_blocked_ips WHERE unblocked_at IS NULL"
];
echo "\nÉtat actuel des tables:\n";
foreach ($tables as $table => $query) {
$result = $db->query($query)->fetch(PDO::FETCH_ASSOC);
if ($table === 'sec_alerts') {
echo "- $table: {$result['total']} total, {$result['active']} actives\n";
} elseif ($table === 'sec_blocked_ips') {
$permanent = $result['permanent'] ?? 0;
echo "- $table: {$result['total']} bloquées, $permanent permanentes\n";
} else {
echo "- $table: {$result['total']} enregistrements\n";
}
}
echo "\n[" . date('Y-m-d H:i:s') . "] Nettoyage terminé avec succès\n";
} catch (Exception $e) {
echo "\n❌ ERREUR: " . $e->getMessage() . "\n";
echo "Stack trace:\n" . $e->getTraceAsString() . "\n";
exit(1);
}

View File

@@ -1,323 +0,0 @@
#!/usr/bin/env php
<?php
/**
* Script CRON pour traiter la queue d'emails
* Envoie les emails en attente dans la table email_queue
*
* À exécuter toutes les 5 minutes via crontab :
* Exemple: [asterisk]/5 [asterisk] [asterisk] [asterisk] [asterisk] /usr/bin/php /path/to/api/scripts/cron/process_email_queue.php
*/
declare(strict_types=1);
// Configuration
define('MAX_ATTEMPTS', 3);
define('BATCH_SIZE', 50);
define('LOCK_FILE', '/tmp/process_email_queue.lock');
// Empêcher l'exécution multiple simultanée
if (file_exists(LOCK_FILE)) {
$lockTime = filemtime(LOCK_FILE);
// Si le lock a plus de 30 minutes, on le supprime (processus probablement bloqué)
if (time() - $lockTime > 1800) {
unlink(LOCK_FILE);
} else {
die("Le processus est déjà en cours d'exécution\n");
}
}
// Créer le fichier de lock
file_put_contents(LOCK_FILE, getmypid());
// Enregistrer un handler pour supprimer le lock en cas d'arrêt
register_shutdown_function(function() {
if (file_exists(LOCK_FILE)) {
unlink(LOCK_FILE);
}
});
// Simuler l'environnement web pour AppConfig en CLI
if (php_sapi_name() === 'cli') {
// Détecter l'environnement basé sur le hostname ou un paramètre
$hostname = gethostname();
if (strpos($hostname, 'pra') !== false) {
$_SERVER['SERVER_NAME'] = 'app3.geosector.fr';
} elseif (strpos($hostname, 'rca') !== false) {
$_SERVER['SERVER_NAME'] = 'rapp.geosector.fr';
} else {
$_SERVER['SERVER_NAME'] = 'dapp.geosector.fr'; // DVA par défaut
}
$_SERVER['HTTP_HOST'] = $_SERVER['HTTP_HOST'] ?? $_SERVER['SERVER_NAME'];
$_SERVER['REMOTE_ADDR'] = $_SERVER['REMOTE_ADDR'] ?? '127.0.0.1';
// Définir getallheaders si elle n'existe pas (CLI)
if (!function_exists('getallheaders')) {
function getallheaders() {
return [];
}
}
}
// Chargement de l'environnement
require_once __DIR__ . '/../../vendor/autoload.php';
require_once __DIR__ . '/../../src/Config/AppConfig.php';
require_once __DIR__ . '/../../src/Core/Database.php';
require_once __DIR__ . '/../../src/Services/LogService.php';
use PHPMailer\PHPMailer\PHPMailer;
use PHPMailer\PHPMailer\SMTP;
use PHPMailer\PHPMailer\Exception;
use App\Services\LogService;
try {
// Initialisation de la configuration
$appConfig = AppConfig::getInstance();
$dbConfig = $appConfig->getDatabaseConfig();
// Initialiser la base de données avec la configuration
Database::init($dbConfig);
$db = Database::getInstance();
// Log uniquement si mode debug activé
// LogService::log('Démarrage du processeur de queue d\'emails', [
// 'level' => 'info',
// 'script' => 'process_email_queue.php'
// ]);
// Récupérer les emails en attente
$stmt = $db->prepare('
SELECT id, fk_pass, to_email, subject, body, headers, attempts
FROM email_queue
WHERE status = ? AND attempts < ?
ORDER BY created_at ASC
LIMIT ?
');
$stmt->execute(['pending', MAX_ATTEMPTS, BATCH_SIZE]);
$emails = $stmt->fetchAll(PDO::FETCH_ASSOC);
if (empty($emails)) {
// Ne pas logger quand il n'y a rien à faire (toutes les 5 minutes)
// LogService::log('Aucun email en attente dans la queue', [
// 'level' => 'debug'
// ]);
exit(0);
}
LogService::log('Emails à traiter', [
'level' => 'info',
'count' => count($emails)
]);
// Configuration SMTP
$smtpConfig = $appConfig->getSmtpConfig();
$emailConfig = $appConfig->getEmailConfig();
$successCount = 0;
$failureCount = 0;
// Traiter chaque email
foreach ($emails as $emailData) {
$emailId = $emailData['id'];
$passageId = $emailData['fk_pass'];
try {
// Incrémenter le compteur de tentatives
$stmt = $db->prepare('UPDATE email_queue SET attempts = attempts + 1 WHERE id = ?');
$stmt->execute([$emailId]);
// Créer l'instance PHPMailer
$mail = new PHPMailer(true);
// Configuration du serveur SMTP
$mail->isSMTP();
$mail->Host = $smtpConfig['host'];
$mail->SMTPAuth = $smtpConfig['auth'] ?? true;
$mail->Username = $smtpConfig['user'];
$mail->Password = $smtpConfig['pass'];
$mail->SMTPSecure = $smtpConfig['secure'];
$mail->Port = $smtpConfig['port'];
$mail->CharSet = 'UTF-8';
// Configuration de l'expéditeur
$fromName = 'Amicale Sapeurs-Pompiers'; // Nom par défaut
$mail->setFrom($emailConfig['from'], $fromName);
// Destinataire
$mail->addAddress($emailData['to_email']);
// Sujet
$mail->Subject = $emailData['subject'];
// Headers personnalisés si présents
if (!empty($emailData['headers'])) {
// Les headers contiennent déjà les informations MIME pour la pièce jointe
// On doit extraire le boundary et reconstruire le message
if (preg_match('/boundary="([^"]+)"/', $emailData['headers'], $matches)) {
$boundary = $matches[1];
// Le body contient déjà le message complet avec pièce jointe
$mail->isHTML(false);
$mail->Body = $emailData['body'];
// Extraire le contenu HTML et la pièce jointe
$parts = explode("--$boundary", $emailData['body']);
foreach ($parts as $part) {
if (strpos($part, 'Content-Type: text/html') !== false) {
// Extraire le contenu HTML
$htmlContent = trim(substr($part, strpos($part, "\r\n\r\n") + 4));
$mail->isHTML(true);
$mail->Body = $htmlContent;
} elseif (strpos($part, 'Content-Type: application/pdf') !== false) {
// Extraire le PDF encodé en base64
if (preg_match('/filename="([^"]+)"/', $part, $fileMatches)) {
$filename = $fileMatches[1];
$pdfContent = trim(substr($part, strpos($part, "\r\n\r\n") + 4));
// Supprimer les retours à la ligne du base64
$pdfContent = str_replace(["\r", "\n"], '', $pdfContent);
// Ajouter la pièce jointe
$mail->addStringAttachment(
base64_decode($pdfContent),
$filename,
'base64',
'application/pdf'
);
}
}
}
}
} else {
// Email simple sans pièce jointe
$mail->isHTML(true);
$mail->Body = $emailData['body'];
}
// Ajouter une copie si configuré
if (!empty($emailConfig['contact'])) {
$mail->addBCC($emailConfig['contact']);
}
// Envoyer l'email
if ($mail->send()) {
// Marquer comme envoyé
$stmt = $db->prepare('
UPDATE email_queue
SET status = ?, sent_at = NOW()
WHERE id = ?
');
$stmt->execute(['sent', $emailId]);
// Mettre à jour le passage si nécessaire
if ($passageId > 0) {
$stmt = $db->prepare('
UPDATE ope_pass
SET date_sent_recu = NOW(), chk_email_sent = 1
WHERE id = ?
');
$stmt->execute([$passageId]);
}
$successCount++;
LogService::log('Email envoyé avec succès', [
'level' => 'info',
'emailId' => $emailId,
'passageId' => $passageId,
'to' => $emailData['to_email']
]);
} else {
throw new Exception('Échec de l\'envoi');
}
} catch (Exception $e) {
$failureCount++;
LogService::log('Erreur lors de l\'envoi de l\'email', [
'level' => 'error',
'emailId' => $emailId,
'passageId' => $passageId,
'error' => $e->getMessage(),
'attempts' => $emailData['attempts'] + 1
]);
// Si on a atteint le nombre max de tentatives, marquer comme échoué
if ($emailData['attempts'] + 1 >= MAX_ATTEMPTS) {
$stmt = $db->prepare('
UPDATE email_queue
SET status = ?, error_message = ?
WHERE id = ?
');
$stmt->execute(['failed', $e->getMessage(), $emailId]);
LogService::log('Email marqué comme échoué après ' . MAX_ATTEMPTS . ' tentatives', [
'level' => 'warning',
'emailId' => $emailId,
'passageId' => $passageId
]);
}
}
// Pause courte entre chaque email pour éviter la surcharge
usleep(500000); // 0.5 seconde
}
// Logger uniquement s'il y avait des emails à traiter
if (count($emails) > 0) {
LogService::log('Traitement de la queue terminé', [
'level' => 'info',
'success' => $successCount,
'failures' => $failureCount,
'total' => count($emails)
]);
}
} catch (Exception $e) {
LogService::log('Erreur fatale dans le processeur de queue', [
'level' => 'critical',
'error' => $e->getMessage(),
'trace' => $e->getTraceAsString()
]);
// Supprimer le lock en cas d'erreur
if (file_exists(LOCK_FILE)) {
unlink(LOCK_FILE);
}
exit(1);
}
// Nettoyer les vieux emails traités (optionnel)
try {
// Supprimer les emails envoyés de plus de 30 jours
$stmt = $db->prepare('
DELETE FROM email_queue
WHERE status = ? AND sent_at < DATE_SUB(NOW(), INTERVAL 30 DAY)
');
$stmt->execute(['sent']);
$deleted = $stmt->rowCount();
if ($deleted > 0) {
LogService::log('Nettoyage des anciens emails', [
'level' => 'info',
'deleted' => $deleted
]);
}
} catch (Exception $e) {
LogService::log('Erreur lors du nettoyage des anciens emails', [
'level' => 'warning',
'error' => $e->getMessage()
]);
}
// Supprimer le lock
if (file_exists(LOCK_FILE)) {
unlink(LOCK_FILE);
}
echo "Traitement terminé : $successCount envoyés, $failureCount échecs\n";
exit(0);

View File

@@ -1,31 +0,0 @@
#!/bin/bash
# Script wrapper pour process_email_queue avec logs journaliers
# Crée automatiquement un nouveau fichier log chaque jour
# Configuration
LOG_DIR="/var/www/geosector/api/logs"
LOG_FILE="$LOG_DIR/email_queue_$(date +%Y%m%d).log"
PHP_SCRIPT="/var/www/geosector/api/scripts/cron/process_email_queue.php"
# Créer le répertoire de logs s'il n'existe pas
mkdir -p "$LOG_DIR"
# Ajouter un timestamp au début de l'exécution
echo "[$(date '+%Y-%m-%d %H:%M:%S')] Démarrage du processeur de queue d'emails" >> "$LOG_FILE"
# Exécuter le script PHP
/usr/bin/php "$PHP_SCRIPT" >> "$LOG_FILE" 2>&1
# Ajouter le statut de sortie
EXIT_CODE=$?
if [ $EXIT_CODE -eq 0 ]; then
echo "[$(date '+%Y-%m-%d %H:%M:%S')] Fin du traitement (succès)" >> "$LOG_FILE"
else
echo "[$(date '+%Y-%m-%d %H:%M:%S')] Fin du traitement (erreur: $EXIT_CODE)" >> "$LOG_FILE"
fi
# Nettoyer les logs de plus de 30 jours
find "$LOG_DIR" -name "email_queue_*.log" -type f -mtime +30 -delete 2>/dev/null
exit $EXIT_CODE

View File

@@ -1,169 +0,0 @@
#!/usr/bin/env php
<?php
/**
* Script CRON pour rotation des logs d'événements JSONL
*
* Politique de rétention : 15 mois
* - 0-15 mois : fichiers .jsonl conservés (non compressés pour accès API)
* - > 15 mois : suppression
*
* À exécuter mensuellement via crontab (1er du mois à 3h) :
* 0 3 1 * * /usr/bin/php /var/www/geosector/api/scripts/cron/rotate_event_logs.php >> /var/www/geosector/api/logs/rotation_events.log 2>&1
*/
declare(strict_types=1);
// Configuration
define('RETENTION_MONTHS', 15); // Conserver 15 mois
define('LOCK_FILE', '/tmp/rotate_event_logs.lock');
// Empêcher l'exécution multiple simultanée
if (file_exists(LOCK_FILE)) {
$lockTime = filemtime(LOCK_FILE);
// Si le lock a plus de 2 heures, on le supprime (processus probablement bloqué)
if (time() - $lockTime > 7200) {
unlink(LOCK_FILE);
} else {
die("Le processus est déjà en cours d'exécution\n");
}
}
// Créer le fichier de lock
file_put_contents(LOCK_FILE, getmypid());
// Enregistrer un handler pour supprimer le lock en cas d'arrêt
register_shutdown_function(function() {
if (file_exists(LOCK_FILE)) {
unlink(LOCK_FILE);
}
});
// Simuler l'environnement web pour AppConfig en CLI
if (php_sapi_name() === 'cli') {
// Détecter l'environnement basé sur le hostname
$hostname = gethostname();
if (strpos($hostname, 'pra') !== false) {
$_SERVER['SERVER_NAME'] = 'app3.geosector.fr';
} elseif (strpos($hostname, 'rca') !== false) {
$_SERVER['SERVER_NAME'] = 'rapp.geosector.fr';
} else {
$_SERVER['SERVER_NAME'] = 'dapp.geosector.fr'; // DVA par défaut
}
$_SERVER['HTTP_HOST'] = $_SERVER['HTTP_HOST'] ?? $_SERVER['SERVER_NAME'];
$_SERVER['REMOTE_ADDR'] = $_SERVER['REMOTE_ADDR'] ?? '127.0.0.1';
// Définir getallheaders si elle n'existe pas (CLI)
if (!function_exists('getallheaders')) {
function getallheaders() {
return [];
}
}
}
// Chargement de l'environnement
require_once __DIR__ . '/../../vendor/autoload.php';
require_once __DIR__ . '/../../src/Config/AppConfig.php';
require_once __DIR__ . '/../../src/Services/LogService.php';
try {
// Initialisation de la configuration
$appConfig = AppConfig::getInstance();
$environment = $appConfig->getEnvironment();
// Définir le chemin du dossier des logs événements
$eventLogDir = __DIR__ . '/../../logs/events';
if (!is_dir($eventLogDir)) {
echo "Le dossier de logs événements n'existe pas : {$eventLogDir}\n";
exit(0);
}
// Date limite de suppression
$deletionDate = strtotime('-' . RETENTION_MONTHS . ' months');
// Lister tous les fichiers .jsonl
$jsonlFiles = glob($eventLogDir . '/*.jsonl');
if (empty($jsonlFiles)) {
echo "Aucun fichier .jsonl trouvé dans {$eventLogDir}\n";
exit(0);
}
$deletedCount = 0;
$deletedSize = 0;
$deletedFiles = [];
// ========================================
// Suppression des fichiers > 15 mois
// ========================================
foreach ($jsonlFiles as $file) {
$fileTime = filemtime($file);
// Vérifier si le fichier est plus vieux que la date de rétention
if ($fileTime < $deletionDate) {
$fileSize = filesize($file);
$fileName = basename($file);
if (unlink($file)) {
$deletedCount++;
$deletedSize += $fileSize;
$deletedFiles[] = $fileName;
echo "Supprimé : {$fileName} (> " . RETENTION_MONTHS . " mois, " .
number_format($fileSize / 1024, 2) . " KB)\n";
} else {
echo "ERREUR : Impossible de supprimer {$fileName}\n";
}
}
}
// ========================================
// RÉSUMÉ ET LOGGING
// ========================================
if ($deletedCount > 0) {
$message = sprintf(
"Rotation des logs événements terminée - %d fichier(s) supprimé(s) - %.2f MB libérés",
$deletedCount,
$deletedSize / (1024 * 1024)
);
LogService::log($message, [
'level' => 'info',
'script' => 'rotate_event_logs.php',
'environment' => $environment,
'deleted_count' => $deletedCount,
'deleted_size_mb' => round($deletedSize / (1024 * 1024), 2),
'deleted_files' => $deletedFiles
]);
echo "\n" . $message . "\n";
} else {
echo "Aucune rotation nécessaire - Tous les fichiers .jsonl ont moins de " . RETENTION_MONTHS . " mois\n";
}
} catch (Exception $e) {
$errorMsg = 'Erreur lors de la rotation des logs événements : ' . $e->getMessage();
LogService::log($errorMsg, [
'level' => 'error',
'script' => 'rotate_event_logs.php',
'trace' => $e->getTraceAsString()
]);
echo $errorMsg . "\n";
// Supprimer le lock en cas d'erreur
if (file_exists(LOCK_FILE)) {
unlink(LOCK_FILE);
}
exit(1);
}
// Supprimer le lock
if (file_exists(LOCK_FILE)) {
unlink(LOCK_FILE);
}
exit(0);

View File

@@ -1,444 +0,0 @@
#!/usr/bin/env php
<?php
/**
* Script CRON pour mettre à jour la liste des appareils certifiés Stripe Tap to Pay
*
* Ce script récupère et met à jour la liste des appareils Android certifiés
* pour Tap to Pay en France dans la table stripe_android_certified_devices
*
* À exécuter hebdomadairement via crontab :
* Exemple: 0 3 * * 0 /usr/bin/php /path/to/api/scripts/cron/update_stripe_devices.php
*/
declare(strict_types=1);
// Configuration
define('LOCK_FILE', '/tmp/update_stripe_devices.lock');
define('DEVICES_JSON_URL', 'https://raw.githubusercontent.com/stripe/stripe-terminal-android/master/tap-to-pay/certified-devices.json');
define('DEVICES_LOCAL_FILE', __DIR__ . '/../../data/stripe_certified_devices.json');
// Empêcher l'exécution multiple simultanée
if (file_exists(LOCK_FILE)) {
$lockTime = filemtime(LOCK_FILE);
if (time() - $lockTime > 3600) { // Lock de plus d'1 heure = processus bloqué
unlink(LOCK_FILE);
} else {
die("[" . date('Y-m-d H:i:s') . "] Le processus est déjà en cours d'exécution\n");
}
}
// Créer le fichier de lock
file_put_contents(LOCK_FILE, getmypid());
// Enregistrer un handler pour supprimer le lock en cas d'arrêt
register_shutdown_function(function() {
if (file_exists(LOCK_FILE)) {
unlink(LOCK_FILE);
}
});
// Simuler l'environnement web pour AppConfig en CLI
if (php_sapi_name() === 'cli') {
$hostname = gethostname();
if (strpos($hostname, 'prod') !== false || strpos($hostname, 'pra') !== false) {
$_SERVER['SERVER_NAME'] = 'app3.geosector.fr';
} elseif (strpos($hostname, 'rec') !== false || strpos($hostname, 'rca') !== false) {
$_SERVER['SERVER_NAME'] = 'rapp.geosector.fr';
} else {
$_SERVER['SERVER_NAME'] = 'dapp.geosector.fr'; // DVA par défaut
}
$_SERVER['REQUEST_URI'] = '/cron/update_stripe_devices';
$_SERVER['REQUEST_METHOD'] = 'CLI';
$_SERVER['HTTP_HOST'] = $_SERVER['SERVER_NAME'];
$_SERVER['REMOTE_ADDR'] = '127.0.0.1';
// Définir getallheaders si elle n'existe pas (CLI)
if (!function_exists('getallheaders')) {
function getallheaders() {
return [];
}
}
}
// Charger l'environnement
require_once dirname(dirname(__DIR__)) . '/vendor/autoload.php';
require_once dirname(dirname(__DIR__)) . '/src/Config/AppConfig.php';
require_once dirname(dirname(__DIR__)) . '/src/Core/Database.php';
require_once dirname(dirname(__DIR__)) . '/src/Services/LogService.php';
use App\Services\LogService;
try {
echo "[" . date('Y-m-d H:i:s') . "] Début de la mise à jour des devices Stripe certifiés\n";
// Initialiser la configuration et la base de données
$appConfig = AppConfig::getInstance();
$dbConfig = $appConfig->getDatabaseConfig();
Database::init($dbConfig);
$db = Database::getInstance();
// Logger le début
LogService::log("Début de la mise à jour des devices Stripe certifiés", [
'source' => 'cron',
'script' => 'update_stripe_devices.php'
]);
// Étape 1: Récupérer la liste des devices
$devicesData = fetchCertifiedDevices();
if (empty($devicesData)) {
echo "[" . date('Y-m-d H:i:s') . "] Aucune donnée de devices récupérée\n";
LogService::log("Aucune donnée de devices récupérée", ['level' => 'warning']);
exit(1);
}
// Étape 2: Traiter et mettre à jour la base de données
$stats = updateDatabase($db, $devicesData);
// Étape 3: Logger les résultats
$message = sprintf(
"Mise à jour terminée : %d ajoutés, %d modifiés, %d désactivés, %d inchangés",
$stats['added'],
$stats['updated'],
$stats['disabled'],
$stats['unchanged']
);
echo "[" . date('Y-m-d H:i:s') . "] $message\n";
LogService::log($message, [
'source' => 'cron',
'stats' => $stats
]);
// Étape 4: Envoyer une notification si changements significatifs
if ($stats['added'] > 0 || $stats['disabled'] > 0) {
sendNotification($stats);
}
echo "[" . date('Y-m-d H:i:s') . "] Mise à jour terminée avec succès\n";
} catch (Exception $e) {
$errorMsg = "Erreur lors de la mise à jour des devices: " . $e->getMessage();
echo "[" . date('Y-m-d H:i:s') . "] $errorMsg\n";
LogService::log($errorMsg, [
'level' => 'error',
'trace' => $e->getTraceAsString()
]);
exit(1);
}
/**
* Récupère la liste des devices certifiés
* Essaie d'abord depuis une URL externe, puis depuis un fichier local en fallback
*/
function fetchCertifiedDevices(): array {
// Liste maintenue manuellement des devices certifiés en France
// Source: Documentation Stripe Terminal et tests confirmés
$frenchCertifiedDevices = [
// Samsung Galaxy S Series
['manufacturer' => 'Samsung', 'model' => 'Galaxy S21', 'model_identifier' => 'SM-G991B', 'min_android_version' => 11],
['manufacturer' => 'Samsung', 'model' => 'Galaxy S21+', 'model_identifier' => 'SM-G996B', 'min_android_version' => 11],
['manufacturer' => 'Samsung', 'model' => 'Galaxy S21 Ultra', 'model_identifier' => 'SM-G998B', 'min_android_version' => 11],
['manufacturer' => 'Samsung', 'model' => 'Galaxy S21 FE', 'model_identifier' => 'SM-G990B', 'min_android_version' => 11],
['manufacturer' => 'Samsung', 'model' => 'Galaxy S22', 'model_identifier' => 'SM-S901B', 'min_android_version' => 12],
['manufacturer' => 'Samsung', 'model' => 'Galaxy S22+', 'model_identifier' => 'SM-S906B', 'min_android_version' => 12],
['manufacturer' => 'Samsung', 'model' => 'Galaxy S22 Ultra', 'model_identifier' => 'SM-S908B', 'min_android_version' => 12],
['manufacturer' => 'Samsung', 'model' => 'Galaxy S23', 'model_identifier' => 'SM-S911B', 'min_android_version' => 13],
['manufacturer' => 'Samsung', 'model' => 'Galaxy S23+', 'model_identifier' => 'SM-S916B', 'min_android_version' => 13],
['manufacturer' => 'Samsung', 'model' => 'Galaxy S23 Ultra', 'model_identifier' => 'SM-S918B', 'min_android_version' => 13],
['manufacturer' => 'Samsung', 'model' => 'Galaxy S23 FE', 'model_identifier' => 'SM-S711B', 'min_android_version' => 13],
['manufacturer' => 'Samsung', 'model' => 'Galaxy S24', 'model_identifier' => 'SM-S921B', 'min_android_version' => 14],
['manufacturer' => 'Samsung', 'model' => 'Galaxy S24+', 'model_identifier' => 'SM-S926B', 'min_android_version' => 14],
['manufacturer' => 'Samsung', 'model' => 'Galaxy S24 Ultra', 'model_identifier' => 'SM-S928B', 'min_android_version' => 14],
// Samsung Galaxy Note
['manufacturer' => 'Samsung', 'model' => 'Galaxy Note 20', 'model_identifier' => 'SM-N980F', 'min_android_version' => 10],
['manufacturer' => 'Samsung', 'model' => 'Galaxy Note 20 Ultra', 'model_identifier' => 'SM-N986B', 'min_android_version' => 10],
// Samsung Galaxy Z Fold
['manufacturer' => 'Samsung', 'model' => 'Galaxy Z Fold3', 'model_identifier' => 'SM-F926B', 'min_android_version' => 11],
['manufacturer' => 'Samsung', 'model' => 'Galaxy Z Fold4', 'model_identifier' => 'SM-F936B', 'min_android_version' => 12],
['manufacturer' => 'Samsung', 'model' => 'Galaxy Z Fold5', 'model_identifier' => 'SM-F946B', 'min_android_version' => 13],
['manufacturer' => 'Samsung', 'model' => 'Galaxy Z Fold6', 'model_identifier' => 'SM-F956B', 'min_android_version' => 14],
// Samsung Galaxy Z Flip
['manufacturer' => 'Samsung', 'model' => 'Galaxy Z Flip3', 'model_identifier' => 'SM-F711B', 'min_android_version' => 11],
['manufacturer' => 'Samsung', 'model' => 'Galaxy Z Flip4', 'model_identifier' => 'SM-F721B', 'min_android_version' => 12],
['manufacturer' => 'Samsung', 'model' => 'Galaxy Z Flip5', 'model_identifier' => 'SM-F731B', 'min_android_version' => 13],
['manufacturer' => 'Samsung', 'model' => 'Galaxy Z Flip6', 'model_identifier' => 'SM-F741B', 'min_android_version' => 14],
// Samsung Galaxy A Series (haut de gamme)
['manufacturer' => 'Samsung', 'model' => 'Galaxy A54', 'model_identifier' => 'SM-A546B', 'min_android_version' => 13],
['manufacturer' => 'Samsung', 'model' => 'Galaxy A73', 'model_identifier' => 'SM-A736B', 'min_android_version' => 12],
// Google Pixel
['manufacturer' => 'Google', 'model' => 'Pixel 6', 'model_identifier' => 'oriole', 'min_android_version' => 12],
['manufacturer' => 'Google', 'model' => 'Pixel 6 Pro', 'model_identifier' => 'raven', 'min_android_version' => 12],
['manufacturer' => 'Google', 'model' => 'Pixel 6a', 'model_identifier' => 'bluejay', 'min_android_version' => 12],
['manufacturer' => 'Google', 'model' => 'Pixel 7', 'model_identifier' => 'panther', 'min_android_version' => 13],
['manufacturer' => 'Google', 'model' => 'Pixel 7 Pro', 'model_identifier' => 'cheetah', 'min_android_version' => 13],
['manufacturer' => 'Google', 'model' => 'Pixel 7a', 'model_identifier' => 'lynx', 'min_android_version' => 13],
['manufacturer' => 'Google', 'model' => 'Pixel 8', 'model_identifier' => 'shiba', 'min_android_version' => 14],
['manufacturer' => 'Google', 'model' => 'Pixel 8 Pro', 'model_identifier' => 'husky', 'min_android_version' => 14],
['manufacturer' => 'Google', 'model' => 'Pixel 8a', 'model_identifier' => 'akita', 'min_android_version' => 14],
['manufacturer' => 'Google', 'model' => 'Pixel 9', 'model_identifier' => 'tokay', 'min_android_version' => 14],
['manufacturer' => 'Google', 'model' => 'Pixel 9 Pro', 'model_identifier' => 'caiman', 'min_android_version' => 14],
['manufacturer' => 'Google', 'model' => 'Pixel 9 Pro XL', 'model_identifier' => 'komodo', 'min_android_version' => 14],
['manufacturer' => 'Google', 'model' => 'Pixel Fold', 'model_identifier' => 'felix', 'min_android_version' => 13],
['manufacturer' => 'Google', 'model' => 'Pixel Tablet', 'model_identifier' => 'tangorpro', 'min_android_version' => 13],
// OnePlus
['manufacturer' => 'OnePlus', 'model' => '9', 'model_identifier' => 'LE2113', 'min_android_version' => 11],
['manufacturer' => 'OnePlus', 'model' => '9 Pro', 'model_identifier' => 'LE2123', 'min_android_version' => 11],
['manufacturer' => 'OnePlus', 'model' => '10 Pro', 'model_identifier' => 'NE2213', 'min_android_version' => 12],
['manufacturer' => 'OnePlus', 'model' => '10T', 'model_identifier' => 'CPH2413', 'min_android_version' => 12],
['manufacturer' => 'OnePlus', 'model' => '11', 'model_identifier' => 'CPH2449', 'min_android_version' => 13],
['manufacturer' => 'OnePlus', 'model' => '11R', 'model_identifier' => 'CPH2487', 'min_android_version' => 13],
['manufacturer' => 'OnePlus', 'model' => '12', 'model_identifier' => 'CPH2581', 'min_android_version' => 14],
['manufacturer' => 'OnePlus', 'model' => '12R', 'model_identifier' => 'CPH2585', 'min_android_version' => 14],
['manufacturer' => 'OnePlus', 'model' => 'Open', 'model_identifier' => 'CPH2551', 'min_android_version' => 13],
// Xiaomi
['manufacturer' => 'Xiaomi', 'model' => 'Mi 11', 'model_identifier' => 'M2011K2G', 'min_android_version' => 11],
['manufacturer' => 'Xiaomi', 'model' => 'Mi 11 Ultra', 'model_identifier' => 'M2102K1G', 'min_android_version' => 11],
['manufacturer' => 'Xiaomi', 'model' => '12', 'model_identifier' => '2201123G', 'min_android_version' => 12],
['manufacturer' => 'Xiaomi', 'model' => '12 Pro', 'model_identifier' => '2201122G', 'min_android_version' => 12],
['manufacturer' => 'Xiaomi', 'model' => '12T Pro', 'model_identifier' => '2207122MC', 'min_android_version' => 12],
['manufacturer' => 'Xiaomi', 'model' => '13', 'model_identifier' => '2211133G', 'min_android_version' => 13],
['manufacturer' => 'Xiaomi', 'model' => '13 Pro', 'model_identifier' => '2210132G', 'min_android_version' => 13],
['manufacturer' => 'Xiaomi', 'model' => '13T Pro', 'model_identifier' => '23078PND5G', 'min_android_version' => 13],
['manufacturer' => 'Xiaomi', 'model' => '14', 'model_identifier' => '23127PN0CG', 'min_android_version' => 14],
['manufacturer' => 'Xiaomi', 'model' => '14 Pro', 'model_identifier' => '23116PN5BG', 'min_android_version' => 14],
['manufacturer' => 'Xiaomi', 'model' => '14 Ultra', 'model_identifier' => '24030PN60G', 'min_android_version' => 14],
// OPPO
['manufacturer' => 'OPPO', 'model' => 'Find X3 Pro', 'model_identifier' => 'CPH2173', 'min_android_version' => 11],
['manufacturer' => 'OPPO', 'model' => 'Find X5 Pro', 'model_identifier' => 'CPH2305', 'min_android_version' => 12],
['manufacturer' => 'OPPO', 'model' => 'Find X6 Pro', 'model_identifier' => 'CPH2449', 'min_android_version' => 13],
['manufacturer' => 'OPPO', 'model' => 'Find N2', 'model_identifier' => 'CPH2399', 'min_android_version' => 13],
['manufacturer' => 'OPPO', 'model' => 'Find N3', 'model_identifier' => 'CPH2499', 'min_android_version' => 13],
// Realme
['manufacturer' => 'Realme', 'model' => 'GT 2 Pro', 'model_identifier' => 'RMX3301', 'min_android_version' => 12],
['manufacturer' => 'Realme', 'model' => 'GT 3', 'model_identifier' => 'RMX3709', 'min_android_version' => 13],
['manufacturer' => 'Realme', 'model' => 'GT 5 Pro', 'model_identifier' => 'RMX3888', 'min_android_version' => 14],
// Honor
['manufacturer' => 'Honor', 'model' => 'Magic5 Pro', 'model_identifier' => 'PGT-N19', 'min_android_version' => 13],
['manufacturer' => 'Honor', 'model' => 'Magic6 Pro', 'model_identifier' => 'BVL-N49', 'min_android_version' => 14],
['manufacturer' => 'Honor', 'model' => '90', 'model_identifier' => 'REA-NX9', 'min_android_version' => 13],
// ASUS
['manufacturer' => 'ASUS', 'model' => 'Zenfone 9', 'model_identifier' => 'AI2202', 'min_android_version' => 12],
['manufacturer' => 'ASUS', 'model' => 'Zenfone 10', 'model_identifier' => 'AI2302', 'min_android_version' => 13],
['manufacturer' => 'ASUS', 'model' => 'ROG Phone 7', 'model_identifier' => 'AI2205', 'min_android_version' => 13],
// Nothing
['manufacturer' => 'Nothing', 'model' => 'Phone (1)', 'model_identifier' => 'A063', 'min_android_version' => 12],
['manufacturer' => 'Nothing', 'model' => 'Phone (2)', 'model_identifier' => 'A065', 'min_android_version' => 13],
['manufacturer' => 'Nothing', 'model' => 'Phone (2a)', 'model_identifier' => 'A142', 'min_android_version' => 14],
];
// Essayer de charger depuis un fichier JSON local si présent
if (file_exists(DEVICES_LOCAL_FILE)) {
$localData = json_decode(file_get_contents(DEVICES_LOCAL_FILE), true);
if (!empty($localData)) {
echo "[" . date('Y-m-d H:i:s') . "] Données chargées depuis le fichier local\n";
return array_merge($frenchCertifiedDevices, $localData);
}
}
echo "[" . date('Y-m-d H:i:s') . "] Utilisation de la liste intégrée des devices certifiés\n";
return $frenchCertifiedDevices;
}
/**
* Met à jour la base de données avec les nouvelles données
*/
function updateDatabase($db, array $devices): array {
$stats = [
'added' => 0,
'updated' => 0,
'disabled' => 0,
'unchanged' => 0,
'total' => 0
];
// Récupérer tous les devices existants
$stmt = $db->prepare("SELECT * FROM stripe_android_certified_devices WHERE country = 'FR'");
$stmt->execute();
$existingDevices = [];
while ($row = $stmt->fetch(PDO::FETCH_ASSOC)) {
$key = $row['manufacturer'] . '|' . $row['model'] . '|' . $row['model_identifier'];
$existingDevices[$key] = $row;
}
// Marquer tous les devices pour tracking
$processedKeys = [];
// Traiter chaque device de la nouvelle liste
foreach ($devices as $device) {
$key = $device['manufacturer'] . '|' . $device['model'] . '|' . $device['model_identifier'];
$processedKeys[$key] = true;
if (isset($existingDevices[$key])) {
// Le device existe, vérifier s'il faut le mettre à jour
$existing = $existingDevices[$key];
// Vérifier si des champs ont changé
$needsUpdate = false;
if ($existing['min_android_version'] != $device['min_android_version']) {
$needsUpdate = true;
}
if ($existing['tap_to_pay_certified'] != 1) {
$needsUpdate = true;
}
if ($needsUpdate) {
$stmt = $db->prepare("
UPDATE stripe_android_certified_devices
SET min_android_version = :min_version,
tap_to_pay_certified = 1,
last_verified = NOW(),
updated_at = NOW()
WHERE manufacturer = :manufacturer
AND model = :model
AND model_identifier = :model_identifier
AND country = 'FR'
");
$stmt->execute([
'min_version' => $device['min_android_version'],
'manufacturer' => $device['manufacturer'],
'model' => $device['model'],
'model_identifier' => $device['model_identifier']
]);
$stats['updated']++;
LogService::log("Device mis à jour", [
'device' => $device['manufacturer'] . ' ' . $device['model']
]);
} else {
// Juste mettre à jour last_verified
$stmt = $db->prepare("
UPDATE stripe_android_certified_devices
SET last_verified = NOW()
WHERE manufacturer = :manufacturer
AND model = :model
AND model_identifier = :model_identifier
AND country = 'FR'
");
$stmt->execute([
'manufacturer' => $device['manufacturer'],
'model' => $device['model'],
'model_identifier' => $device['model_identifier']
]);
$stats['unchanged']++;
}
} else {
// Nouveau device, l'ajouter
$stmt = $db->prepare("
INSERT INTO stripe_android_certified_devices
(manufacturer, model, model_identifier, tap_to_pay_certified,
certification_date, min_android_version, country, notes, last_verified)
VALUES
(:manufacturer, :model, :model_identifier, 1,
NOW(), :min_version, 'FR', 'Ajouté automatiquement via CRON', NOW())
");
$stmt->execute([
'manufacturer' => $device['manufacturer'],
'model' => $device['model'],
'model_identifier' => $device['model_identifier'],
'min_version' => $device['min_android_version']
]);
$stats['added']++;
LogService::log("Nouveau device ajouté", [
'device' => $device['manufacturer'] . ' ' . $device['model']
]);
}
}
// Désactiver les devices qui ne sont plus dans la liste
foreach ($existingDevices as $key => $existing) {
if (!isset($processedKeys[$key]) && $existing['tap_to_pay_certified'] == 1) {
$stmt = $db->prepare("
UPDATE stripe_android_certified_devices
SET tap_to_pay_certified = 0,
notes = CONCAT(IFNULL(notes, ''), ' | Désactivé le ', NOW(), ' (non présent dans la mise à jour)'),
updated_at = NOW()
WHERE id = :id
");
$stmt->execute(['id' => $existing['id']]);
$stats['disabled']++;
LogService::log("Device désactivé", [
'device' => $existing['manufacturer'] . ' ' . $existing['model'],
'reason' => 'Non présent dans la liste mise à jour'
]);
}
}
$stats['total'] = count($devices);
return $stats;
}
/**
* Envoie une notification email aux administrateurs si changements importants
*/
function sendNotification(array $stats): void {
try {
// Récupérer la configuration
$appConfig = AppConfig::getInstance();
$emailConfig = $appConfig->getEmailConfig();
if (empty($emailConfig['admin_email'])) {
return; // Pas d'email admin configuré
}
$db = Database::getInstance();
// Préparer le contenu de l'email
$subject = "Mise à jour des devices Stripe Tap to Pay";
$body = "Bonjour,\n\n";
$body .= "La mise à jour automatique de la liste des appareils certifiés Stripe Tap to Pay a été effectuée.\n\n";
$body .= "Résumé des changements :\n";
$body .= "- Nouveaux appareils ajoutés : " . $stats['added'] . "\n";
$body .= "- Appareils mis à jour : " . $stats['updated'] . "\n";
$body .= "- Appareils désactivés : " . $stats['disabled'] . "\n";
$body .= "- Appareils inchangés : " . $stats['unchanged'] . "\n";
$body .= "- Total d'appareils traités : " . $stats['total'] . "\n\n";
if ($stats['added'] > 0) {
$body .= "Les nouveaux appareils ont été automatiquement ajoutés à la base de données.\n";
}
if ($stats['disabled'] > 0) {
$body .= "Certains appareils ont été désactivés car ils ne sont plus certifiés.\n";
}
$body .= "\nConsultez les logs pour plus de détails.\n";
$body .= "\nCordialement,\nLe système GeoSector";
// Insérer dans la queue d'emails
$stmt = $db->prepare("
INSERT INTO email_queue
(to_email, subject, body, status, created_at, attempts)
VALUES
(:to_email, :subject, :body, 'pending', NOW(), 0)
");
$stmt->execute([
'to_email' => $emailConfig['admin_email'],
'subject' => $subject,
'body' => $body
]);
echo "[" . date('Y-m-d H:i:s') . "] Notification ajoutée à la queue d'emails\n";
} catch (Exception $e) {
// Ne pas faire échouer le script si l'email ne peut pas être envoyé
echo "[" . date('Y-m-d H:i:s') . "] Impossible d'envoyer la notification: " . $e->getMessage() . "\n";
}
}

View File

@@ -1,467 +0,0 @@
#!/bin/bash
###############################################################################
# Script de migration en batch des entités depuis geosector_20251008
#
# Usage: ./migrate_batch.sh [options]
#
# Options:
# --start N Commencer à partir de l'entité N (défaut: 1)
# --limit N Migrer seulement N entités (défaut: toutes)
# --dry-run Simuler sans exécuter
# --continue Continuer après une erreur (défaut: s'arrêter)
# --interactive Mode interactif (défaut si aucune option)
#
# Exemple:
# ./migrate_batch.sh --start 10 --limit 5
# ./migrate_batch.sh --continue
# ./migrate_batch.sh --interactive
###############################################################################
# Configuration
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
JSON_FILE="${SCRIPT_DIR}/migrations_entites.json"
LOG_DIR="/var/www/geosector/api/logs/migrations"
MIGRATION_SCRIPT="${SCRIPT_DIR}/php/migrate_from_backup.php"
SOURCE_DB="geosector_20251013_13"
TARGET_DB="pra_geo"
# Paramètres par défaut
START_INDEX=1
LIMIT=0
DRY_RUN=0
CONTINUE_ON_ERROR=0
INTERACTIVE_MODE=0
SPECIFIC_ENTITY_ID=""
SPECIFIC_CP=""
# Couleurs
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
CYAN='\033[0;36m'
NC='\033[0m' # No Color
# Sauvegarder le nombre d'arguments avant le parsing
INITIAL_ARGS=$#
# Parse des arguments
while [[ $# -gt 0 ]]; do
case $1 in
--start)
START_INDEX="$2"
shift 2
;;
--limit)
LIMIT="$2"
shift 2
;;
--dry-run)
DRY_RUN=1
shift
;;
--continue)
CONTINUE_ON_ERROR=1
shift
;;
--interactive|-i)
INTERACTIVE_MODE=1
shift
;;
--help)
grep "^#" "$0" | grep -v "^#!/bin/bash" | sed 's/^# //'
exit 0
;;
*)
echo "Option inconnue: $1"
echo "Utilisez --help pour l'aide"
exit 1
;;
esac
done
# Activer le mode interactif si aucun argument n'a été fourni
if [ $INITIAL_ARGS -eq 0 ]; then
INTERACTIVE_MODE=1
fi
# Vérifications préalables
if [ ! -f "$JSON_FILE" ]; then
echo -e "${RED}❌ Fichier JSON introuvable: $JSON_FILE${NC}"
exit 1
fi
if [ ! -f "$MIGRATION_SCRIPT" ]; then
echo -e "${RED}❌ Script de migration introuvable: $MIGRATION_SCRIPT${NC}"
exit 1
fi
# Créer le répertoire de logs
mkdir -p "$LOG_DIR"
# Fichiers de log
BATCH_LOG="${LOG_DIR}/batch_$(date +%Y%m%d_%H%M%S).log"
SUCCESS_LOG="${LOG_DIR}/success.log"
ERROR_LOG="${LOG_DIR}/errors.log"
# MODE INTERACTIF
if [ $INTERACTIVE_MODE -eq 1 ]; then
echo ""
echo -e "${CYAN}═══════════════════════════════════════════════════════════${NC}"
echo -e "${CYAN} 🔧 Mode interactif - Migration d'entités GeoSector${NC}"
echo -e "${CYAN}═══════════════════════════════════════════════════════════${NC}"
echo ""
# Question 1: Migration globale ou ciblée ?
echo -e "${YELLOW}1⃣ Type de migration :${NC}"
echo -e " ${CYAN}a)${NC} Migration globale (toutes les entités)"
echo -e " ${CYAN}b)${NC} Migration par lot (plage d'entités)"
echo -e " ${CYAN}c)${NC} Migration par code postal"
echo -e " ${CYAN}d)${NC} Migration d'une entité spécifique (ID)"
echo ""
echo -ne "${YELLOW}Votre choix (a/b/c/d) : ${NC}"
read -r MIGRATION_TYPE
echo ""
case $MIGRATION_TYPE in
a|A)
# Migration globale - garder les valeurs par défaut
START_INDEX=1
LIMIT=0
echo -e "${GREEN}${NC} Migration globale sélectionnée"
;;
b|B)
# Migration par lot
echo -e "${YELLOW}2⃣ Configuration du lot :${NC}"
echo -ne " Première entité (index, défaut=1) : "
read -r USER_START
if [ -n "$USER_START" ]; then
START_INDEX=$USER_START
fi
echo -ne " Limite (nombre d'entités, défaut=toutes) : "
read -r USER_LIMIT
if [ -n "$USER_LIMIT" ]; then
LIMIT=$USER_LIMIT
fi
echo ""
echo -e "${GREEN}${NC} Migration par lot : de l'index $START_INDEX, limite de $LIMIT entités"
;;
c|C)
# Migration par code postal
echo -ne "${YELLOW}2⃣ Code postal à migrer : ${NC}"
read -r SPECIFIC_CP
echo ""
if [ -z "$SPECIFIC_CP" ]; then
echo -e "${RED}❌ Code postal requis${NC}"
exit 1
fi
echo -e "${GREEN}${NC} Migration pour le code postal : $SPECIFIC_CP"
;;
d|D)
# Migration d'une entité spécifique - bypass complet du JSON
echo -ne "${YELLOW}2⃣ ID de l'entité à migrer : ${NC}"
read -r SPECIFIC_ENTITY_ID
echo ""
if [ -z "$SPECIFIC_ENTITY_ID" ]; then
echo -e "${RED}❌ ID d'entité requis${NC}"
exit 1
fi
echo -e "${GREEN}${NC} Migration de l'entité ID : $SPECIFIC_ENTITY_ID"
echo ""
# Demander si suppression des données de l'entité avant migration
echo -ne "${YELLOW}3⃣ Supprimer les données existantes de cette entité dans la TARGET avant migration ? (y/N): ${NC}"
read -r DELETE_BEFORE
DELETE_FLAG=""
if [[ $DELETE_BEFORE =~ ^[Yy]$ ]]; then
echo -e "${GREEN}${NC} Les données seront supprimées avant migration"
DELETE_FLAG="--delete-before"
else
echo -e "${BLUE}${NC} Les données seront conservées (ON DUPLICATE KEY UPDATE)"
fi
echo ""
# Confirmer la migration
echo -ne "${YELLOW}⚠️ Confirmer la migration de l'entité #${SPECIFIC_ENTITY_ID} ? (y/N): ${NC}"
read -r CONFIRM
if [[ ! $CONFIRM =~ ^[Yy]$ ]]; then
echo -e "${RED}❌ Migration annulée${NC}"
exit 0
fi
# Exécuter directement la migration sans passer par le JSON
ENTITY_LOG="${LOG_DIR}/entity_${SPECIFIC_ENTITY_ID}_$(date +%Y%m%d_%H%M%S).log"
echo ""
echo -e "${BLUE}⏳ Migration de l'entité #${SPECIFIC_ENTITY_ID} en cours...${NC}"
php "$MIGRATION_SCRIPT" \
--source-db="$SOURCE_DB" \
--target-db="$TARGET_DB" \
--mode=entity \
--entity-id="$SPECIFIC_ENTITY_ID" \
--log="$ENTITY_LOG" \
$DELETE_FLAG
EXIT_CODE=$?
if [ $EXIT_CODE -eq 0 ]; then
echo -e "${GREEN}✅ Entité #${SPECIFIC_ENTITY_ID} migrée avec succès${NC}"
echo -e "${BLUE}📋 Log détaillé : $ENTITY_LOG${NC}"
else
echo -e "${RED}❌ Erreur lors de la migration de l'entité #${SPECIFIC_ENTITY_ID}${NC}"
echo -e "${RED}📋 Voir le log : $ENTITY_LOG${NC}"
exit 1
fi
exit 0
;;
*)
echo -e "${RED}❌ Choix invalide${NC}"
exit 1
;;
esac
echo ""
fi
# Fonctions utilitaires
log() {
echo -e "$1" | tee -a "$BATCH_LOG"
}
log_success() {
echo "$1" >> "$SUCCESS_LOG"
log "${GREEN}${NC} $1"
}
log_error() {
echo "$1" >> "$ERROR_LOG"
log "${RED}${NC} $1"
}
# Extraire les entity_id du JSON (compatible sans jq)
get_entity_ids() {
if [ -n "$SPECIFIC_ENTITY_ID" ]; then
# Entité spécifique par ID - chercher exactement "entity_id" : ID,
grep "\"entity_id\" : ${SPECIFIC_ENTITY_ID}," "$JSON_FILE" | sed 's/.*: \([0-9]*\).*/\1/'
elif [ -n "$SPECIFIC_CP" ]; then
# Entités par code postal
grep -B 2 "\"code_postal\" : \"$SPECIFIC_CP\"" "$JSON_FILE" | grep '"entity_id"' | sed 's/.*: \([0-9]*\).*/\1/'
else
# Toutes les entités
grep '"entity_id"' "$JSON_FILE" | sed 's/.*: \([0-9]*\).*/\1/'
fi
}
# Compter le nombre total d'entités
TOTAL_ENTITIES=$(get_entity_ids | wc -l)
# Vérifier si des entités ont été trouvées
if [ $TOTAL_ENTITIES -eq 0 ]; then
if [ -n "$SPECIFIC_ENTITY_ID" ]; then
echo -e "${RED}❌ Entité #${SPECIFIC_ENTITY_ID} introuvable dans le fichier JSON${NC}"
elif [ -n "$SPECIFIC_CP" ]; then
echo -e "${RED}❌ Aucune entité trouvée pour le code postal ${SPECIFIC_CP}${NC}"
else
echo -e "${RED}❌ Aucune entité trouvée${NC}"
fi
exit 1
fi
# Calculer le nombre d'entités à migrer
if [ $LIMIT -gt 0 ]; then
END_INDEX=$((START_INDEX + LIMIT - 1))
if [ $END_INDEX -gt $TOTAL_ENTITIES ]; then
END_INDEX=$TOTAL_ENTITIES
fi
else
END_INDEX=$TOTAL_ENTITIES
fi
# Bannière de démarrage
echo ""
log "${BLUE}═══════════════════════════════════════════════════════════${NC}"
log "${BLUE} Migration en batch des entités GeoSector${NC}"
log "${BLUE}═══════════════════════════════════════════════════════════${NC}"
log "📅 Date: $(date '+%Y-%m-%d %H:%M:%S')"
log "📁 Source: $SOURCE_DB"
log "📁 Cible: $TARGET_DB"
# Afficher les informations selon le mode
if [ -n "$SPECIFIC_ENTITY_ID" ]; then
log "🎯 Mode: Migration d'une entité spécifique"
log "📊 Entité ID: $SPECIFIC_ENTITY_ID"
elif [ -n "$SPECIFIC_CP" ]; then
log "🎯 Mode: Migration par code postal"
log "📮 Code postal: $SPECIFIC_CP"
log "📊 Entités trouvées: $TOTAL_ENTITIES"
else
TOTAL_AVAILABLE=$(grep '"entity_id"' "$JSON_FILE" | wc -l)
log "📊 Total entités disponibles: $TOTAL_AVAILABLE"
log "🎯 Entités à migrer: $START_INDEX à $END_INDEX"
fi
if [ $DRY_RUN -eq 1 ]; then
log "${YELLOW}🔍 Mode DRY-RUN (simulation)${NC}"
fi
log "${BLUE}═══════════════════════════════════════════════════════════${NC}"
echo ""
# Confirmation utilisateur
if [ $DRY_RUN -eq 0 ]; then
echo -ne "${YELLOW}⚠️ Confirmer la migration ? (y/N): ${NC}"
read -r CONFIRM
if [[ ! $CONFIRM =~ ^[Yy]$ ]]; then
log "❌ Migration annulée par l'utilisateur"
exit 0
fi
echo ""
fi
# Compteurs
SUCCESS_COUNT=0
ERROR_COUNT=0
SKIPPED_COUNT=0
CURRENT_INDEX=0
# Début de la migration
START_TIME=$(date +%s)
# Lire les entity_id et migrer
get_entity_ids | while read -r ENTITY_ID; do
CURRENT_INDEX=$((CURRENT_INDEX + 1))
# Filtrer par index
if [ $CURRENT_INDEX -lt $START_INDEX ]; then
continue
fi
if [ $CURRENT_INDEX -gt $END_INDEX ]; then
break
fi
# Récupérer les détails de l'entité depuis le JSON (match exact avec la virgule)
ENTITY_INFO=$(grep -A 8 "\"entity_id\" : ${ENTITY_ID}," "$JSON_FILE")
ENTITY_NAME=$(echo "$ENTITY_INFO" | grep '"nom"' | sed 's/.*: "\(.*\)".*/\1/')
ENTITY_CP=$(echo "$ENTITY_INFO" | grep '"code_postal"' | sed 's/.*: "\(.*\)".*/\1/')
NB_USERS=$(echo "$ENTITY_INFO" | grep '"nb_users"' | sed 's/.*: \([0-9]*\).*/\1/')
NB_PASSAGES=$(echo "$ENTITY_INFO" | grep '"nb_passages"' | sed 's/.*: \([0-9]*\).*/\1/')
# Afficher la progression
PROGRESS=$((CURRENT_INDEX - START_INDEX + 1))
TOTAL=$((END_INDEX - START_INDEX + 1))
PERCENT=$((PROGRESS * 100 / TOTAL))
log ""
log "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
log "${BLUE}[$PROGRESS/$TOTAL - ${PERCENT}%]${NC} Entité #${ENTITY_ID}: ${ENTITY_NAME} (${ENTITY_CP})"
log " 👥 Users: ${NB_USERS} | 📍 Passages: ${NB_PASSAGES}"
# Mode dry-run
if [ $DRY_RUN -eq 1 ]; then
log "${YELLOW} 🔍 [DRY-RUN] Simulation de la migration${NC}"
SKIPPED_COUNT=$((SKIPPED_COUNT + 1))
continue
fi
# Exécuter la migration
ENTITY_LOG="${LOG_DIR}/entity_${ENTITY_ID}_$(date +%Y%m%d_%H%M%S).log"
log " ⏳ Migration en cours..."
php "$MIGRATION_SCRIPT" \
--source-db="$SOURCE_DB" \
--target-db="$TARGET_DB" \
--mode=entity \
--entity-id="$ENTITY_ID" \
--log="$ENTITY_LOG" > /tmp/migration_output_$$.txt 2>&1
EXIT_CODE=$?
if [ $EXIT_CODE -eq 0 ]; then
# Succès
SUCCESS_COUNT=$((SUCCESS_COUNT + 1))
log_success "Entité #${ENTITY_ID} (${ENTITY_NAME}) migrée avec succès"
# Afficher un résumé du log avec détails
if [ -f "$ENTITY_LOG" ]; then
# Chercher la ligne avec les marqueurs #STATS#
STATS_LINE=$(grep "#STATS#" "$ENTITY_LOG" 2>/dev/null)
if [ -n "$STATS_LINE" ]; then
# Extraire chaque compteur
OPE=$(echo "$STATS_LINE" | grep -oE 'OPE:[0-9]+' | cut -d: -f2)
USERS=$(echo "$STATS_LINE" | grep -oE 'USER:[0-9]+' | cut -d: -f2)
SECTORS=$(echo "$STATS_LINE" | grep -oE 'SECTOR:[0-9]+' | cut -d: -f2)
PASSAGES=$(echo "$STATS_LINE" | grep -oE 'PASS:[0-9]+' | cut -d: -f2)
# Valeurs par défaut si extraction échoue
OPE=${OPE:-0}
USERS=${USERS:-0}
SECTORS=${SECTORS:-0}
PASSAGES=${PASSAGES:-0}
log " 📊 ope: ${OPE} | users: ${USERS} | sectors: ${SECTORS} | passages: ${PASSAGES}"
else
log " 📊 Statistiques non disponibles"
fi
fi
else
# Erreur
ERROR_COUNT=$((ERROR_COUNT + 1))
log_error "Entité #${ENTITY_ID} (${ENTITY_NAME}) - Erreur code $EXIT_CODE"
# Afficher les dernières lignes du log d'erreur
if [ -f "/tmp/migration_output_$$.txt" ]; then
log "${RED} 📋 Dernières erreurs:${NC}"
tail -5 "/tmp/migration_output_$$.txt" | sed 's/^/ /' | tee -a "$BATCH_LOG"
fi
# Arrêter ou continuer ?
if [ $CONTINUE_ON_ERROR -eq 0 ]; then
log ""
log "${RED}❌ Migration interrompue suite à une erreur${NC}"
log " Utilisez --continue pour continuer malgré les erreurs"
exit 1
fi
fi
# Nettoyage
rm -f "/tmp/migration_output_$$.txt"
# Pause entre les migrations (pour éviter de surcharger)
sleep 1
done
# Fin de la migration
END_TIME=$(date +%s)
DURATION=$((END_TIME - START_TIME))
HOURS=$((DURATION / 3600))
MINUTES=$(((DURATION % 3600) / 60))
SECONDS=$((DURATION % 60))
# Résumé final
log ""
log "${BLUE}═══════════════════════════════════════════════════════════${NC}"
log "${BLUE} Résumé de la migration${NC}"
log "${BLUE}═══════════════════════════════════════════════════════════${NC}"
log "✅ Succès: ${GREEN}${SUCCESS_COUNT}${NC}"
log "❌ Erreurs: ${RED}${ERROR_COUNT}${NC}"
log "⏭️ Ignorées: ${YELLOW}${SKIPPED_COUNT}${NC}"
log "⏱️ Durée: ${HOURS}h ${MINUTES}m ${SECONDS}s"
log ""
log "📋 Logs détaillés:"
log " - Batch: $BATCH_LOG"
log " - Succès: $SUCCESS_LOG"
log " - Erreurs: $ERROR_LOG"
log " - Individuels: $LOG_DIR/entity_*.log"
log "${BLUE}═══════════════════════════════════════════════════════════${NC}"
# Code de sortie
if [ $ERROR_COUNT -gt 0 ]; then
exit 1
else
exit 0
fi

View File

@@ -1,248 +0,0 @@
#!/bin/bash
# Script de migration des bases de données vers les containers MariaDB
# Date: Janvier 2025
# Auteur: Pierre (avec l'aide de Claude)
#
# Ce script migre les bases de données depuis les containers applicatifs
# vers les containers MariaDB dédiés (maria3 sur IN3, maria4 sur IN4)
set -euo pipefail
# Configuration SSH
HOST_KEY="/home/pierre/.ssh/id_rsa_mbpi"
HOST_PORT="22"
HOST_USER="root"
# Serveurs
RCA_HOST="195.154.80.116" # IN3
PRA_HOST="51.159.7.190" # IN4
# Configuration MariaDB
MARIA_ROOT_PASS="MyAlpLocal,90b" # Mot de passe root pour maria3 et maria4
# Couleurs
GREEN='\033[0;32m'
RED='\033[0;31m'
YELLOW='\033[0;33m'
BLUE='\033[0;34m'
NC='\033[0m'
echo_step() {
echo -e "${GREEN}==>${NC} $1"
}
echo_info() {
echo -e "${BLUE}Info:${NC} $1"
}
echo_warning() {
echo -e "${YELLOW}Warning:${NC} $1"
}
echo_error() {
echo -e "${RED}Error:${NC} $1"
exit 1
}
# Fonction pour créer une base de données et un utilisateur
create_database_and_user() {
local HOST=$1
local CONTAINER=$2
local DB_NAME=$3
local DB_USER=$4
local DB_PASS=$5
local SOURCE_CONTAINER=$6
echo_step "Creating database ${DB_NAME} in ${CONTAINER} on ${HOST}..."
# Commandes SQL pour créer la base et l'utilisateur
SQL_COMMANDS="
CREATE DATABASE IF NOT EXISTS ${DB_NAME} CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
CREATE USER IF NOT EXISTS '${DB_USER}'@'%' IDENTIFIED BY '${DB_PASS}';
GRANT ALL PRIVILEGES ON ${DB_NAME}.* TO '${DB_USER}'@'%';
FLUSH PRIVILEGES;
"
if [ "$HOST" = "local" ]; then
# Pour local (non utilisé actuellement)
incus exec ${CONTAINER} -- mysql -u root -p${MARIA_ROOT_PASS} -e "${SQL_COMMANDS}"
else
# Pour serveur distant
ssh -i ${HOST_KEY} -p ${HOST_PORT} ${HOST_USER}@${HOST} \
"incus exec ${CONTAINER} -- mysql -u root -p${MARIA_ROOT_PASS} -e \"${SQL_COMMANDS}\""
fi
echo_info "Database ${DB_NAME} and user ${DB_USER} created"
}
# Fonction pour migrer les données
migrate_data() {
local HOST=$1
local SOURCE_CONTAINER=$2
local TARGET_CONTAINER=$3
local SOURCE_DB=$4
local TARGET_DB=$5
local TARGET_USER=$6
local TARGET_PASS=$7
echo_step "Migrating data from ${SOURCE_CONTAINER}/${SOURCE_DB} to ${TARGET_CONTAINER}/${TARGET_DB}..."
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
DUMP_FILE="/tmp/${SOURCE_DB}_dump_${TIMESTAMP}.sql"
# Créer le dump depuis le container source
echo_info "Creating database dump..."
# Déterminer si le container source utilise root avec mot de passe
# Les containers d'app (dva-geo, rca-geo, pra-geo) n'ont probablement pas de mot de passe root
ssh -i ${HOST_KEY} -p ${HOST_PORT} ${HOST_USER}@${HOST} \
"incus exec ${SOURCE_CONTAINER} -- mysqldump --single-transaction --routines --triggers ${SOURCE_DB} > ${DUMP_FILE} 2>/dev/null || \
incus exec ${SOURCE_CONTAINER} -- mysqldump -u root -p${MARIA_ROOT_PASS} --single-transaction --routines --triggers ${SOURCE_DB} > ${DUMP_FILE}"
# Importer dans le container cible
echo_info "Importing data into ${TARGET_CONTAINER}..."
ssh -i ${HOST_KEY} -p ${HOST_PORT} ${HOST_USER}@${HOST} \
"cat ${DUMP_FILE} | incus exec ${TARGET_CONTAINER} -- mysql -u ${TARGET_USER} -p${TARGET_PASS} ${TARGET_DB}"
# Nettoyer
ssh -i ${HOST_KEY} -p ${HOST_PORT} ${HOST_USER}@${HOST} "rm -f ${DUMP_FILE}"
echo_info "Migration completed for ${TARGET_DB}"
}
# Fonction pour migrer les données entre serveurs différents (pour PRODUCTION)
migrate_data_cross_server() {
local SOURCE_HOST=$1
local SOURCE_CONTAINER=$2
local TARGET_HOST=$3
local TARGET_CONTAINER=$4
local SOURCE_DB=$5
local TARGET_DB=$6
local TARGET_USER=$7
local TARGET_PASS=$8
echo_step "Migrating data from ${SOURCE_HOST}/${SOURCE_CONTAINER}/${SOURCE_DB} to ${TARGET_HOST}/${TARGET_CONTAINER}/${TARGET_DB}..."
echo_info "Using WireGuard VPN tunnel (IN3 → IN4)..."
# Option 1: Streaming direct via VPN avec agent forwarding
echo_info "Streaming database directly through VPN tunnel..."
echo_warning "Note: This requires SSH agent forwarding (ssh -A) when connecting to IN3"
# Utiliser -A pour activer l'agent forwarding vers IN3
# Utilise l'alias 'in4' défini dans /root/.ssh/config sur IN3
ssh -A -i ${HOST_KEY} -p ${HOST_PORT} ${HOST_USER}@${SOURCE_HOST} "
# Dump depuis maria3 avec mot de passe root et pipe direct vers IN4 via VPN
incus exec ${SOURCE_CONTAINER} -- mysqldump -u root -p${MARIA_ROOT_PASS} --single-transaction --routines --triggers ${SOURCE_DB} | \
ssh in4 'incus exec ${TARGET_CONTAINER} -- mysql -u ${TARGET_USER} -p${TARGET_PASS} ${TARGET_DB}'
"
if [ $? -eq 0 ]; then
echo_info "Direct VPN streaming migration completed successfully!"
else
echo_warning "VPN streaming failed, falling back to file transfer method..."
# Option 2: Fallback avec fichiers temporaires si le streaming échoue
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
DUMP_FILE="/tmp/${SOURCE_DB}_dump_${TIMESTAMP}.sql"
# Créer le dump sur IN3
echo_info "Creating database dump..."
ssh -A -i ${HOST_KEY} -p ${HOST_PORT} ${HOST_USER}@${SOURCE_HOST} \
"incus exec ${SOURCE_CONTAINER} -- mysqldump -u root -p${MARIA_ROOT_PASS} --single-transaction --routines --triggers ${SOURCE_DB} > ${DUMP_FILE}"
# Transférer via VPN depuis IN3 vers IN4 (utilise l'alias 'in4')
echo_info "Transferring dump file through VPN..."
ssh -A -i ${HOST_KEY} -p ${HOST_PORT} ${HOST_USER}@${SOURCE_HOST} \
"scp ${DUMP_FILE} in4:${DUMP_FILE}"
# Importer sur IN4 (utilise l'alias 'in4')
echo_info "Importing data on IN4..."
ssh -A -i ${HOST_KEY} -p ${HOST_PORT} ${HOST_USER}@${SOURCE_HOST} \
"ssh in4 'cat ${DUMP_FILE} | incus exec ${TARGET_CONTAINER} -- mysql -u ${TARGET_USER} -p${TARGET_PASS} ${TARGET_DB}'"
# Nettoyer
ssh -A -i ${HOST_KEY} -p ${HOST_PORT} ${HOST_USER}@${SOURCE_HOST} "rm -f ${DUMP_FILE}"
ssh -A -i ${HOST_KEY} -p ${HOST_PORT} ${HOST_USER}@${SOURCE_HOST} \
"ssh in4 'rm -f ${DUMP_FILE}'"
fi
echo_info "Cross-server migration completed for ${TARGET_DB}"
}
# Menu de sélection
echo_step "Database Migration to MariaDB Containers"
echo ""
echo "Select environment to migrate:"
echo "1) DEV - dva-geo → maria3/dva_geo"
echo "2) RCA - rca-geo → maria3/rca_geo"
echo "3) PROD - rca_geo (IN3/maria3) → maria4/pra_geo (copy from RECETTE)"
echo "4) ALL - Migrate all environments"
echo ""
read -p "Your choice [1-4]: " choice
case $choice in
1)
echo_step "Migrating DEV environment..."
create_database_and_user "${RCA_HOST}" "maria3" "dva_geo" "dva_geo_user" "CBq9tKHj6PGPZuTmAHV7" "dva-geo"
migrate_data "${RCA_HOST}" "dva-geo" "maria3" "geo_app" "dva_geo" "dva_geo_user" "CBq9tKHj6PGPZuTmAHV7"
echo_step "DEV migration completed!"
;;
2)
echo_step "Migrating RECETTE environment..."
create_database_and_user "${RCA_HOST}" "maria3" "rca_geo" "rca_geo_user" "UPf3C0cQ805LypyM71iW" "rca-geo"
migrate_data "${RCA_HOST}" "rca-geo" "maria3" "geo_app" "rca_geo" "rca_geo_user" "UPf3C0cQ805LypyM71iW"
echo_step "RECETTE migration completed!"
;;
3)
echo_step "Migrating PRODUCTION environment (copying from RECETTE)..."
echo_warning "Note: PRODUCTION will be duplicated from rca_geo on IN3/maria3"
# Créer la base et l'utilisateur sur IN4/maria4
create_database_and_user "${PRA_HOST}" "maria4" "pra_geo" "pra_geo_user" "d2jAAGGWi8fxFrWgXjOA" "pra-geo"
# Copier les données depuis rca_geo (IN3/maria3) vers pra_geo (IN4/maria4)
migrate_data_cross_server "${RCA_HOST}" "maria3" "${PRA_HOST}" "maria4" "rca_geo" "pra_geo" "pra_geo_user" "d2jAAGGWi8fxFrWgXjOA"
echo_step "PRODUCTION migration completed (duplicated from RECETTE)!"
;;
4)
echo_step "Migrating ALL environments..."
echo_info "Starting DEV migration..."
create_database_and_user "${RCA_HOST}" "maria3" "dva_geo" "dva_geo_user" "CBq9tKHj6PGPZuTmAHV7" "dva-geo"
migrate_data "${RCA_HOST}" "dva-geo" "maria3" "geo_app" "dva_geo" "dva_geo_user" "CBq9tKHj6PGPZuTmAHV7"
echo_info "Starting RECETTE migration..."
create_database_and_user "${RCA_HOST}" "maria3" "rca_geo" "rca_geo_user" "UPf3C0cQ805LypyM71iW" "rca-geo"
migrate_data "${RCA_HOST}" "rca-geo" "maria3" "geo_app" "rca_geo" "rca_geo_user" "UPf3C0cQ805LypyM71iW"
echo_info "Starting PRODUCTION migration (copying from RECETTE)..."
echo_warning "Note: PRODUCTION will be duplicated from rca_geo on IN3/maria3"
create_database_and_user "${PRA_HOST}" "maria4" "pra_geo" "pra_geo_user" "d2jAAGGWi8fxFrWgXjOA" "pra-geo"
migrate_data_cross_server "${RCA_HOST}" "maria3" "${PRA_HOST}" "maria4" "rca_geo" "pra_geo" "pra_geo_user" "d2jAAGGWi8fxFrWgXjOA"
echo_step "All migrations completed!"
;;
*)
echo_error "Invalid choice"
;;
esac
echo ""
echo_step "Migration Summary:"
echo ""
echo "┌─────────────┬──────────────┬──────────────┬─────────────┬──────────────────────┐"
echo "│ Environment │ Source │ Target │ Database │ User │"
echo "├─────────────┼──────────────┼──────────────┼─────────────┼──────────────────────┤"
echo "│ DEV │ dva-geo │ maria3 (IN3) │ dva_geo │ dva_geo_user │"
echo "│ RECETTE │ rca-geo │ maria3 (IN3) │ rca_geo │ rca_geo_user │"
echo "│ PRODUCTION │ pra-geo │ maria4 (IN4) │ pra_geo │ pra_geo_user │"
echo "└─────────────┴──────────────┴──────────────┴─────────────┴──────────────────────┘"
echo ""
echo_warning "Remember to:"
echo " 1. Test database connectivity from application containers"
echo " 2. Deploy the updated AppConfig.php"
echo " 3. Monitor application logs after migration"
echo " 4. Keep old databases for rollback if needed"

View File

@@ -1,298 +0,0 @@
#!/usr/bin/env php
<?php
/**
* Script de migration de l'arborescence des uploads
* Réorganise les fichiers existants vers la nouvelle structure simplifiée
*
* Ancienne structure : uploads/entites/{id}/* et uploads/{id}/*
* Nouvelle structure : uploads/{id}/*
*
* Usage: php scripts/migrate_uploads_structure.php [--dry-run]
*/
declare(strict_types=1);
// Chemin de base des uploads
const BASE_PATH = '/var/www/geosector/api/uploads';
const LOG_FILE = '/var/www/geosector/api/logs/migration_uploads_' . date('Ymd_His') . '.log';
// Mode dry-run (simulation sans modification)
$dryRun = in_array('--dry-run', $argv);
// Fonction pour logger
function logMessage(string $message, string $level = 'INFO'): void {
$timestamp = date('Y-m-d H:i:s');
$log = "[$timestamp] [$level] $message" . PHP_EOL;
echo $log;
if (!$GLOBALS['dryRun']) {
file_put_contents(LOG_FILE, $log, FILE_APPEND);
}
}
// Fonction pour déplacer un fichier ou dossier
function moveItem(string $source, string $destination): bool {
global $dryRun;
if (!file_exists($source)) {
logMessage("Source n'existe pas: $source", 'WARNING');
return false;
}
// Créer le dossier de destination si nécessaire
$destDir = dirname($destination);
if (!is_dir($destDir)) {
logMessage("Création du dossier: $destDir");
if (!$dryRun) {
mkdir($destDir, 0775, true);
chown($destDir, 'nginx');
chgrp($destDir, 'nobody');
}
}
// Déplacer l'élément
logMessage("Déplacement: $source -> $destination");
if (!$dryRun) {
if (is_dir($source)) {
// Pour un dossier, utiliser rename
return rename($source, $destination);
} else {
// Pour un fichier
return rename($source, $destination);
}
}
return true;
}
// Fonction pour copier récursivement un dossier
function copyDirectory(string $source, string $dest): bool {
global $dryRun;
if (!is_dir($source)) {
return false;
}
if (!$dryRun) {
if (!is_dir($dest)) {
mkdir($dest, 0775, true);
chown($dest, 'nginx');
chgrp($dest, 'nobody');
}
}
$dir = opendir($source);
while (($file = readdir($dir)) !== false) {
if ($file === '.' || $file === '..') {
continue;
}
$srcPath = "$source/$file";
$destPath = "$dest/$file";
if (is_dir($srcPath)) {
copyDirectory($srcPath, $destPath);
} else {
logMessage("Copie: $srcPath -> $destPath");
if (!$dryRun) {
copy($srcPath, $destPath);
chmod($destPath, 0664);
chown($destPath, 'nginx');
chgrp($destPath, 'nobody');
}
}
}
closedir($dir);
return true;
}
// Fonction principale de migration
function migrateUploads(): void {
global $dryRun;
logMessage("=== Début de la migration des uploads ===");
logMessage($dryRun ? "MODE DRY-RUN (simulation)" : "MODE RÉEL (modifications effectives)");
// 1. Migrer uploads/entites/* vers uploads/*
$entitesPath = BASE_PATH . '/entites';
if (is_dir($entitesPath)) {
logMessage("Traitement du dossier entites/");
$entites = scandir($entitesPath);
foreach ($entites as $entiteId) {
if ($entiteId === '.' || $entiteId === '..') continue;
$oldPath = "$entitesPath/$entiteId";
$newPath = BASE_PATH . "/$entiteId";
if (!is_dir($oldPath)) continue;
logMessage("Migration entité $entiteId");
// Si le dossier destination existe déjà, fusionner
if (is_dir($newPath)) {
logMessage("Le dossier $entiteId existe déjà à la racine, fusion nécessaire", 'INFO');
// Migrer les sous-dossiers
$subDirs = scandir($oldPath);
foreach ($subDirs as $subDir) {
if ($subDir === '.' || $subDir === '..') continue;
$oldSubPath = "$oldPath/$subDir";
$newSubPath = "$newPath/$subDir";
if ($subDir === 'operations') {
// Traiter spécialement le dossier operations
migrateOperations($oldSubPath, $newSubPath);
} else {
// Pour logo et recus, déplacer directement
if (!is_dir($newSubPath)) {
moveItem($oldSubPath, $newSubPath);
} else {
logMessage("Le dossier $newSubPath existe déjà, fusion du contenu");
copyDirectory($oldSubPath, $newSubPath);
if (!$dryRun) {
// Supprimer l'ancien après copie
exec("rm -rf " . escapeshellarg($oldSubPath));
}
}
}
}
} else {
// Déplacer simplement le dossier entier
moveItem($oldPath, $newPath);
}
}
// Supprimer le dossier entites vide
if (!$dryRun) {
if (count(scandir($entitesPath)) === 2) { // Seulement . et ..
rmdir($entitesPath);
logMessage("Suppression du dossier entites/ vide");
}
}
}
// 2. Nettoyer la structure des dossiers operations
logMessage("Nettoyage de la structure des dossiers operations");
cleanupOperationsStructure();
logMessage("=== Migration terminée ===");
if (!$dryRun) {
logMessage("Logs sauvegardés dans: " . LOG_FILE);
}
}
// Fonction pour migrer le dossier operations avec simplification
function migrateOperations(string $oldPath, string $newPath): void {
global $dryRun;
if (!is_dir($oldPath)) return;
logMessage("Migration du dossier operations: $oldPath");
if (!$dryRun && !is_dir($newPath)) {
mkdir($newPath, 0775, true);
chown($newPath, 'nginx');
chgrp($newPath, 'nobody');
}
$operations = scandir($oldPath);
foreach ($operations as $opId) {
if ($opId === '.' || $opId === '..') continue;
$oldOpPath = "$oldPath/$opId";
$newOpPath = "$newPath/$opId";
// Simplifier la structure: déplacer les xlsx directement dans operations/{id}/
if (is_dir("$oldOpPath/documents/exports/excel")) {
$excelPath = "$oldOpPath/documents/exports/excel";
$files = scandir($excelPath);
foreach ($files as $file) {
if ($file === '.' || $file === '..' || !str_ends_with($file, '.xlsx')) continue;
$oldFilePath = "$excelPath/$file";
$newFilePath = "$newOpPath/$file";
logMessage("Déplacement Excel: $oldFilePath -> $newFilePath");
if (!$dryRun) {
if (!is_dir($newOpPath)) {
mkdir($newOpPath, 0775, true);
chown($newOpPath, 'nginx');
chgrp($newOpPath, 'nobody');
}
rename($oldFilePath, $newFilePath);
chmod($newFilePath, 0664);
chown($newFilePath, 'nginx');
chgrp($newFilePath, 'nobody');
}
}
}
}
}
// Fonction pour nettoyer la structure après migration
function cleanupOperationsStructure(): void {
global $dryRun;
$uploadsDir = BASE_PATH;
$entites = scandir($uploadsDir);
foreach ($entites as $entiteId) {
if ($entiteId === '.' || $entiteId === '..' || $entiteId === 'entites') continue;
$operationsPath = "$uploadsDir/$entiteId/operations";
if (!is_dir($operationsPath)) continue;
$operations = scandir($operationsPath);
foreach ($operations as $opId) {
if ($opId === '.' || $opId === '..') continue;
$opPath = "$operationsPath/$opId";
// Supprimer l'ancienne structure documents/exports/excel si elle est vide
$oldStructure = "$opPath/documents";
if (is_dir($oldStructure)) {
logMessage("Suppression de l'ancienne structure: $oldStructure");
if (!$dryRun) {
exec("rm -rf " . escapeshellarg($oldStructure));
}
}
}
}
}
// Vérifier les permissions
if (!is_dir(BASE_PATH)) {
die("ERREUR: Le dossier " . BASE_PATH . " n'existe pas\n");
}
if (!is_writable(BASE_PATH) && !$dryRun) {
die("ERREUR: Le dossier " . BASE_PATH . " n'est pas accessible en écriture\n");
}
// Lancer la migration
try {
migrateUploads();
if ($dryRun) {
echo "\n";
echo "========================================\n";
echo "SIMULATION TERMINÉE\n";
echo "Pour exécuter réellement la migration:\n";
echo "php " . $argv[0] . "\n";
echo "========================================\n";
} else {
echo "\n";
echo "========================================\n";
echo "MIGRATION TERMINÉE AVEC SUCCÈS\n";
echo "Vérifiez les logs: " . LOG_FILE . "\n";
echo "========================================\n";
}
} catch (Exception $e) {
logMessage("ERREUR FATALE: " . $e->getMessage(), 'ERROR');
exit(1);
}

View File

@@ -1,410 +0,0 @@
# Migration v2 - Architecture modulaire
## Vue d'ensemble
Cette nouvelle architecture simplifie la migration en utilisant :
- **Source fixe** : `geosector` (synchronisée 2x/jour par PM7 depuis nx4)
- **Multi-environnement** : `--env=dva` (développement), `--env=rca` (recette) ou `--env=pra` (production)
- **Auto-détection** : L'environnement est détecté automatiquement selon le serveur
- **Classes réutilisables** : Configuration, Logger, Connexion
## Structure modulaire
```
migration2/
├── README.md # Ce fichier
├── logs/ # Logs de migration (auto-créé)
│ └── .gitignore
├── php/
│ ├── migrate_from_backup.php # Script principal orchestrateur
│ └── lib/
│ ├── DatabaseConfig.php # Configuration multi-env
│ ├── MigrationLogger.php # Gestion des logs
│ ├── DatabaseConnection.php # Connexions PDO
│ ├── OperationMigrator.php # Migration des opérations
│ ├── UserMigrator.php # Migration des ope_users
│ ├── SectorMigrator.php # Migration des secteurs
│ └── PassageMigrator.php # Migration des passages
```
**Architecture modulaire** : Chaque type de données a son propre migrator spécialisé, orchestré par le script principal.
## ⚠️ AVERTISSEMENT IMPORTANT
**Par défaut, le script SUPPRIME toutes les données de l'entité dans la base cible avant la migration.**
Cela inclut :
- ✅ Toutes les opérations de l'entité
- ✅ Tous les utilisateurs de l'entité
- ✅ Tous les secteurs et passages
- ✅ Tous les médias associés
- L'entité elle-même est conservée (seules les données liées sont supprimées)
Pour **désactiver** la suppression et conserver les données existantes :
```bash
php php/migrate_from_backup.php --mode=entity --entity-id=45 --delete-before=false
```
⚠️ **Attention** : Sans suppression préalable, risque de doublons si les données existent déjà.
---
## Utilisation
### Migration d'une entité spécifique
#### Sur dva-geo (IN3)
```bash
# Auto-détection de l'environnement (recommandé)
php php/migrate_from_backup.php --mode=entity --entity-id=45
# Ou avec environnement explicite
php php/migrate_from_backup.php --env=dva --mode=entity --entity-id=45
```
#### Sur rca-geo (IN3)
```bash
# Auto-détection de l'environnement (recommandé)
php php/migrate_from_backup.php --mode=entity --entity-id=45
# Ou avec environnement explicite
php php/migrate_from_backup.php --env=rca --mode=entity --entity-id=45
```
#### Sur pra-geo (IN4)
```bash
# Auto-détection de l'environnement (recommandé)
php php/migrate_from_backup.php --mode=entity --entity-id=45
# Ou avec environnement explicite
php php/migrate_from_backup.php --env=pra --mode=entity --entity-id=45
```
### Migration globale (toutes les entités)
```bash
# Sur dva-geo, rca-geo ou pra-geo
php php/migrate_from_backup.php --mode=global
```
### Options disponibles
```bash
--env=ENV # 'dva' (développement), 'rca' (recette) ou 'pra' (production)
# Par défaut : auto-détection selon le hostname
--mode=MODE # 'global' ou 'entity' (défaut: global)
--entity-id=ID # ID de l'entité à migrer (requis si mode=entity)
--log=PATH # Fichier de log personnalisé
# Par défaut : logs/migration_YYYYMMDD_HHMMSS.log
--delete-before # Supprimer les données existantes avant migration (défaut: true)
--help # Afficher l'aide complète
```
### Exemples d'utilisation
```bash
# Migration STANDARD (avec suppression des données existantes - recommandé)
php php/migrate_from_backup.php --mode=entity --entity-id=45
# Migration SANS suppression (pour ajout/mise à jour uniquement - risque de doublons)
php php/migrate_from_backup.php --mode=entity --entity-id=45 --delete-before=false
# Migration avec log personnalisé
php php/migrate_from_backup.php --mode=entity --entity-id=45 --log=/custom/path/entity_45.log
# Afficher l'aide complète
php php/migrate_from_backup.php --help
```
## Différences avec l'ancienne version
| Aspect | Ancien | Nouveau |
|--------|--------|---------|
| **Source** | `--source-db=geosector_YYYYMMDD_HH` | Toujours `geosector` (fixe) |
| **Cible** | `--target-db=pra_geo` | Déduite de `--env` ou auto-détectée (dva_geo, rca_geo, pra_geo) |
| **Config** | Constantes hardcodées | Classes configurables |
| **Environnement** | Manuel | Auto-détection par hostname (dva-geo, rca-geo, pra-geo) |
| **Arguments** | 2 arguments DB requis | 1 seul `--env` (optionnel) |
## Avantages
**Plus simple** : Plus besoin de spécifier les noms de bases
**Plus sûr** : Moins de risques d'erreurs de saisie
**Plus flexible** : Fonctionne sur dva-geo, rca-geo et pra-geo sans modification
**Plus maintenable** : Configuration centralisée dans DatabaseConfig
**Meilleurs logs** : Séparateurs, niveaux (info/warning/error/success)
## Déploiement
### Copier vers dva-geo (IN3)
```bash
scp -r migration2 root@195.154.80.116:/tmp/
ssh root@195.154.80.116 "incus file push -r /tmp/migration2 dva-geo/var/www/geosector/api/scripts/"
```
### Copier vers rca-geo (IN3)
```bash
scp -r migration2 root@195.154.80.116:/tmp/
ssh root@195.154.80.116 "incus file push -r /tmp/migration2 rca-geo/var/www/geosector/api/scripts/"
```
### Copier vers pra-geo (IN4)
```bash
scp -r migration2 root@51.159.7.190:/tmp/
ssh root@51.159.7.190 "incus file push -r /tmp/migration2 pra-geo/var/www/geosector/api/scripts/"
```
### Test après déploiement
```bash
# Se connecter au container
incus exec dva-geo -- bash # ou rca-geo, ou pra-geo
# Tester avec une entité
cd /var/www/geosector/api/scripts/migration2
php php/migrate_from_backup.php --mode=entity --entity-id=45
```
## Logs
Les logs sont enregistrés par défaut dans :
```
scripts/migration2/logs/migration_[MODE]_YYYYMMDD_HHMMSS.log
```
**Nommage automatique selon le mode :**
- Migration globale : `migration_global_20251021_143045.log`
- Migration d'une entité : `migration_entite_45_20251021_143045.log`
Format des logs :
- `[INFO]` : Informations générales
- `[SUCCESS]` : Opérations réussies
- `[WARNING]` : Avertissements
- `[ERROR]` : Erreurs
Le dossier `logs/` est créé automatiquement si nécessaire.
**Note :** Vous pouvez toujours spécifier un fichier de log personnalisé avec l'option `--log=PATH`.
## Récapitulatif de migration
À la fin de chaque migration, un **récapitulatif détaillé** est automatiquement affiché et enregistré dans le fichier de log.
### Format du récapitulatif
```
========================================
📊 RÉCAPITULATIF DE LA MIGRATION
========================================
Entité: Nom de l'entité (ID: XX)
Date: YYYY-MM-DD HH:MM:SS
Opérations migrées: 3
Opération #1: "Adhésions 2024" (ID: 850)
├─ Utilisateurs: 12
├─ Secteurs: 5
├─ Passages totaux: 245
└─ Détail par secteur:
├─ Centre-ville (ID: 5400)
│ ├─ Utilisateurs affectés: 3
│ └─ Passages: 67
├─ Quartier Est (ID: 5401)
│ ├─ Utilisateurs affectés: 5
│ └─ Passages: 98
└─ Nord (ID: 5402)
├─ Utilisateurs affectés: 4
└─ Passages: 80
Opération #2: "Collecte Printemps" (ID: 851)
├─ Utilisateurs: 8
├─ Secteurs: 3
├─ Passages totaux: 156
└─ Détail par secteur:
[...]
========================================
```
### Informations fournies
Le récapitulatif inclut pour chaque migration :
**Au niveau de l'entité :**
- Nom et ID de l'entité
- Date et heure de la migration
- Nombre total d'opérations migrées
**Pour chaque opération :**
- Nom et nouvel ID
- Nombre d'utilisateurs migrés
- Nombre de secteurs migrés
- Nombre total de passages migrés
**Pour chaque secteur :**
- Nom et nouvel ID
- Nombre d'utilisateurs affectés au secteur
- Nombre de passages effectués dans le secteur
### Utilisation du récapitulatif
Ce récapitulatif permet de :
- ✅ Vérifier rapidement que toutes les données ont été migrées
- ✅ Comparer avec les données source pour validation
- ✅ Identifier d'éventuelles anomalies (secteurs vides, passages manquants)
- ✅ Documenter précisément ce qui a été migré
- ✅ Tracer les migrations pour audit
Le récapitulatif est présent à la fois :
- **À l'écran** (stdout) en temps réel
- **Dans le fichier de log** pour conservation
## Dépannage
### Erreur "env doit être 'dva', 'rca' ou 'pra'"
L'auto-détection a échoué. Spécifiez manuellement :
```bash
php php/migrate_from_backup.php --env=dva --mode=entity --entity-id=45
```
### Erreur de connexion
Vérifiez que vous êtes bien dans le bon container (dva-geo, rca-geo ou pra-geo).
### Données dupliquées après migration
Si vous avez des doublons, c'est que vous avez utilisé `--delete-before=false` sur des données existantes.
**Solution** : Refaire la migration avec suppression (défaut) :
```bash
php php/migrate_from_backup.php --mode=entity --entity-id=45
```
### Vérifier ce qui sera supprimé avant migration
Consultez la section "Ordre de suppression" ci-dessous pour voir exactement quelles tables seront affectées.
### Logs non créés
Vérifiez les permissions du dossier `logs/` :
```bash
ls -la scripts/migration2/logs/
```
## Détails techniques
### Architecture hiérarchique de migration
La migration fonctionne par **opération** avec une hiérarchie complète :
```
Pour chaque opération de l'entité:
migrateOperation($oldOperationId)
├── Créer operation
├── Migrer ope_users (DISTINCT depuis ope_users_sectors)
│ └── Mapper oldUserId → newOpeUserId
├── Pour chaque secteur DISTINCT de l'opération:
│ └── migrateSector($oldOperationId, $newOperationId, $oldSectorId)
│ ├── Créer ope_sectors
│ ├── Mapper "opId_sectId" → newOpeSectorId
│ ├── Migrer sectors_adresses (fk_sector = newOpeSectorId)
│ ├── Migrer ope_users_sectors (avec mappings users + sector)
│ ├── Migrer ope_pass (avec mappings users + sector)
│ │ └── Pour chaque passage:
│ │ └── migratePassageHisto($oldPassId, $newPassId)
│ └── Migrer médias des passages
└── Migrer médias de l'opération
```
### Changement d'organisation des données : Exemple concret
#### Contexte : Opération de collecte des adhésions 2024
**Ancienne organisation** (base geosector - partagée) :
- 1 opération "Adhésions 2024" avec ID 450
- 3 utilisateurs affectés : Jean (ID 100), Marie (ID 101), Paul (ID 102)
- 2 secteurs utilisés : Centre-ville (ID 1004) et Quartier Est (ID 1005)
- Jean travaille sur Centre-ville, Marie et Paul sur Quartier Est
Dans l'ancienne base :
- Les 3 users existent UNE SEULE FOIS dans la table centrale `users`
- Les 2 secteurs existent UNE SEULE FOIS dans la table centrale `sectors`
- Les liens entre users et secteurs sont dans `ope_users_sectors`
- Les passages font référence directement aux users (ID 100, 101, 102)
**Nouvelle organisation** (base rca_geo/pra_geo - isolée par opération) :
Après migration, **CHAQUE opération devient autonome** :
- L'opération "Adhésions 2024" reçoit un nouvel ID (exemple : 850)
- Les 3 utilisateurs sont **dupliqués** dans `ope_users` avec de nouveaux IDs :
- Jean → ope_users.id = 2500 (avec fk_user = 100 et fk_operation = 850)
- Marie → ope_users.id = 2501 (avec fk_user = 101 et fk_operation = 850)
- Paul → ope_users.id = 2502 (avec fk_user = 102 et fk_operation = 850)
- Les 2 secteurs sont **dupliqués** dans `ope_sectors` :
- Centre-ville → ope_sectors.id = 5400 (avec fk_operation = 850)
- Quartier Est → ope_sectors.id = 5401 (avec fk_operation = 850)
- Tous les passages sont mis à jour pour référencer les NOUVEAUX IDs (2500, 2501, 2502)
**Pourquoi cette duplication ?**
**Isolation complète** : Si l'opération est supprimée, tout part avec (secteurs, users, passages)
**Performance** : Pas de jointures complexes entre opérations
**Historique** : Les données de l'opération restent figées dans le temps
**Simplicité** : Chaque opération est indépendante
**Impact pour un utilisateur qui travaille sur 3 opérations différentes** :
- Il existera 1 seule fois dans la table centrale `users` (ID 100)
- Il existera 3 fois dans `ope_users` (1 enregistrement par opération)
- Chaque enregistrement `ope_users` garde la référence vers `users.id = 100`
Cette architecture permet de **fermer** une opération complètement sans impacter les autres.
### Sélection des opérations à migrer
Pour chaque entité, **maximum 3 opérations** sont migrées :
1. **1 opération active** (`active = 1`)
2. **2 dernières opérations inactives** (`active = 0`) ayant au moins **10 passages effectués** (`fk_type = 1`)
### Ordre de suppression (si --delete-before=true)
Les données sont supprimées dans cet ordre pour respecter les contraintes de clés étrangères :
1. `medias` - Médias associés à l'entité ou aux opérations
2. `ope_pass_histo` - Historique des passages
3. `ope_pass` - Passages
4. `ope_users_sectors` - Associations utilisateurs/secteurs
5. `ope_users` - Utilisateurs d'opérations
6. `sectors_adresses` - Adresses de secteurs
7. `ope_sectors` - Secteurs d'opérations
8. `operations` - Opérations
9. `users` - Utilisateurs de l'entité
⚠️ **L'entité elle-même** (`entites`) **n'est jamais supprimée**.
### Tables de référence non migrées
Les tables suivantes ne sont **pas** migrées car déjà remplies dans la cible :
- `x_*` - Tables de référence (secteurs, adresses, etc.)
## Notes importantes
1. **Configuration centralisée** : Les paramètres de connexion DB sont récupérés depuis `AppConfig.php` - pas de duplication
2. **Chiffrement** : ApiService est toujours utilisé pour les mots de passe
3. **Logique métier** : Inchangée (migrateEntites, migrateUsers, etc.)
4. **Mappings** : Secteurs et adresses sont toujours mappés automatiquement
5. **Backup** : Un backup de l'ancien script est disponible dans `migrate_from_backup.php.backup`
6. **Suppression par défaut** : Activée pour éviter les doublons et garantir une migration propre
## Statut
**Architecture modulaire v2** :
- ✅ DatabaseConfig.php - Configuration multi-environnement
- ✅ MigrationLogger.php - Gestion des logs
- ✅ DatabaseConnection.php - Connexions PDO
- ✅ OperationMigrator.php - Migration hiérarchique des opérations
- ✅ UserMigrator.php - Migration des utilisateurs par opération
- ✅ SectorMigrator.php - Migration des secteurs par opération
- ✅ PassageMigrator.php - Migration des passages et historiques
- ✅ migrate_from_backup.php - Script principal orchestrateur
- ⏳ Tests sur rca-geo
- ⏳ Tests sur pra-geo
## Support
En cas de problème, consulter les logs détaillés ou contacter l'équipe technique.

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@@ -1 +0,0 @@
*.log

Some files were not shown because too many files have changed in this diff Show More