feat: Version 3.5.2 - Configuration Stripe et gestion des immeubles

- Configuration complète Stripe pour les 3 environnements (DEV/REC/PROD)
  * DEV: Clés TEST Pierre (mode test)
  * REC: Clés TEST Client (mode test)
  * PROD: Clés LIVE Client (mode live)
- Ajout de la gestion des bases de données immeubles/bâtiments
  * Configuration buildings_database pour DEV/REC/PROD
  * Service BuildingService pour enrichissement des adresses
- Optimisations pages et améliorations ergonomie
- Mises à jour des dépendances Composer
- Nettoyage des fichiers obsolètes

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

Co-Authored-By: Claude <noreply@anthropic.com>

api/scripts/migration2/php/lib/DataMigrator.php

@@ -0,0 +1,176 @@
+<?php
+
+/**
+ * Classe abstraite de base pour tous les migrators
+ *
+ * Fournit les méthodes communes pour migrer des données d'une table
+ */
+abstract class DataMigrator
+{
+    protected $connection;
+    protected $logger;
+    protected $sourceDb;
+    protected $targetDb;
+
+    /**
+     * Constructeur
+     *
+     * @param DatabaseConnection $connection Connexion aux bases
+     * @param MigrationLogger $logger Logger
+     */
+    public function __construct(DatabaseConnection $connection, MigrationLogger $logger)
+    {
+        $this->connection = $connection;
+        $this->logger = $logger;
+        $this->sourceDb = $connection->getSourceDb();
+        $this->targetDb = $connection->getTargetDb();
+    }
+
+    /**
+     * Méthode principale de migration (à implémenter dans chaque migrator)
+     *
+     * @param int|null $entityId ID de l'entité à migrer (null = toutes)
+     * @param bool $deleteBefore Supprimer les données existantes avant migration
+     * @return array ['success' => int, 'errors' => int]
+     */
+    abstract public function migrate(?int $entityId = null, bool $deleteBefore = false): array;
+
+    /**
+     * Retourne le nom de la table gérée par ce migrator
+     */
+    abstract public function getTableName(): string;
+
+    /**
+     * Supprime les données d'une entité dans la cible
+     * À surcharger si la logique de suppression est spécifique
+     *
+     * @param int $entityId ID de l'entité
+     * @return int Nombre de lignes supprimées
+     */
+    protected function deleteEntityData(int $entityId): int
+    {
+        $table = $this->getTableName();
+
+        try {
+            // Par défaut: suppression simple avec fk_entite
+            $stmt = $this->targetDb->prepare("DELETE FROM $table WHERE fk_entite = ?");
+            $stmt->execute([$entityId]);
+            $deleted = $stmt->rowCount();
+
+            if ($deleted > 0) {
+                $this->logger->debug("  Supprimé $deleted ligne(s) de $table pour entité #$entityId");
+            }
+
+            return $deleted;
+
+        } catch (PDOException $e) {
+            $this->logger->warning("  Erreur suppression $table: " . $e->getMessage());
+            return 0;
+        }
+    }
+
+    /**
+     * Compte les lignes dans la source
+     *
+     * @param int|null $entityId ID de l'entité (null = toutes)
+     * @return int Nombre de lignes
+     */
+    protected function countSourceRows(?int $entityId = null): int
+    {
+        return $this->connection->countSourceRows($this->getTableName(), $entityId);
+    }
+
+    /**
+     * Compte les lignes dans la cible
+     *
+     * @param int|null $entityId ID de l'entité (null = toutes)
+     * @return int Nombre de lignes
+     */
+    protected function countTargetRows(?int $entityId = null): int
+    {
+        return $this->connection->countTargetRows($this->getTableName(), $entityId);
+    }
+
+    /**
+     * Log le début de la migration d'une table
+     */
+    protected function logStart(?int $entityId = null): void
+    {
+        $table = $this->getTableName();
+        $entityStr = $entityId ? " pour entité #$entityId" : " (toutes les entités)";
+        $this->logger->info("🔄 Migration de $table{$entityStr}...");
+    }
+
+    /**
+     * Log la fin de la migration avec statistiques
+     *
+     * @param int $success Nombre de succès
+     * @param int $errors Nombre d'erreurs
+     * @param int|null $entityId ID de l'entité
+     */
+    protected function logEnd(int $success, int $errors, ?int $entityId = null): void
+    {
+        $table = $this->getTableName();
+        $sourceCount = $this->countSourceRows($entityId);
+        $targetCount = $this->countTargetRows($entityId);
+        $diff = $targetCount - $sourceCount;
+        $diffStr = $diff >= 0 ? "+$diff" : "$diff";
+
+        if ($errors > 0) {
+            $this->logger->warning("  ⚠️  $table: $success succès, $errors erreurs");
+        } else {
+            $this->logger->success("  ✓ $table: $success enregistrement(s) migré(s)");
+        }
+
+        $this->logger->info("  📊 SOURCE: $sourceCount → CIBLE: $targetCount (différence: $diffStr)");
+    }
+
+    /**
+     * Exécute une requête INSERT avec ON DUPLICATE KEY UPDATE
+     *
+     * @param string $insertSql SQL d'insertion
+     * @param array $data Données à insérer
+     * @return bool True si succès
+     */
+    protected function insertOrUpdate(string $insertSql, array $data): bool
+    {
+        try {
+            $stmt = $this->targetDb->prepare($insertSql);
+            $stmt->execute($data);
+            return true;
+        } catch (PDOException $e) {
+            $this->logger->debug("  Erreur INSERT: " . $e->getMessage());
+            return false;
+        }
+    }
+
+    /**
+     * Démarre une transaction sur la cible
+     */
+    protected function beginTransaction(): void
+    {
+        if (!$this->targetDb->inTransaction()) {
+            $this->targetDb->beginTransaction();
+        }
+    }
+
+    /**
+     * Commit la transaction
+     */
+    protected function commit(): void
+    {
+        if ($this->targetDb->inTransaction()) {
+            $this->targetDb->commit();
+        }
+    }
+
+    /**
+     * Rollback la transaction
+     */
+    protected function rollback(): void
+    {
+        if ($this->targetDb->inTransaction()) {
+            $this->targetDb->rollBack();
+        }
+    }
+}

api/scripts/migration2/php/lib/DatabaseConfig.php

@@ -0,0 +1,192 @@
+<?php
+
+/**
+ * Configuration des environnements de migration
+ *
+ * Utilise AppConfig pour récupérer la configuration DB
+ * Source: geosector (synchronisée par PM7)
+ * Cibles: dva_geo (IN3/maria3), rca_geo (IN3/maria3) ou pra_geo (IN4/maria4)
+ */
+class DatabaseConfig
+{
+    private const ENV_MAPPING = [
+        'dva' => [
+            'name' => 'DÉVELOPPEMENT',
+            'hostname' => 'dapp.geosector.fr',
+            'source_db' => 'geosector',
+            'target_db' => 'dva_geo'
+        ],
+        'rca' => [
+            'name' => 'RECETTE',
+            'hostname' => 'rapp.geosector.fr',
+            'source_db' => 'geosector',
+            'target_db' => 'rca_geo'
+        ],
+        'pra' => [
+            'name' => 'PRODUCTION',
+            'hostname' => 'app3.geosector.fr',
+            'source_db' => 'geosector',
+            'target_db' => 'pra_geo'
+        ]
+    ];
+
+    private $env;
+    private $config;
+    private $appConfig;
+
+    /**
+     * Constructeur
+     *
+     * @param string $env Environnement: 'dva', 'rca' ou 'pra'
+     * @throws Exception Si l'environnement est invalide
+     */
+    public function __construct(string $env)
+    {
+        if (!isset(self::ENV_MAPPING[$env])) {
+            throw new Exception("Invalid environment: $env. Use 'dva', 'rca' or 'pra'");
+        }
+
+        $this->env = $env;
+
+        // Charger AppConfig (remonter de 4 niveaux: lib -> php -> migration2 -> scripts -> api)
+        $appConfigPath = dirname(__DIR__, 4) . '/src/Config/AppConfig.php';
+        if (!file_exists($appConfigPath)) {
+            throw new Exception("AppConfig not found at: $appConfigPath");
+        }
+        require_once $appConfigPath;
+
+        // Simuler le host pour AppConfig en CLI
+        $hostname = self::ENV_MAPPING[$env]['hostname'];
+        $_SERVER['SERVER_NAME'] = $hostname;
+        $_SERVER['HTTP_HOST'] = $hostname;
+
+        $this->appConfig = AppConfig::getInstance();
+
+        // Récupérer la config DB depuis AppConfig
+        $dbConfig = $this->appConfig->getDatabaseConfig();
+
+        if (!$dbConfig || !isset($dbConfig['host'])) {
+            throw new Exception("Database configuration not found for hostname: $hostname");
+        }
+
+        // Construire la config pour la migration
+        $this->config = [
+            'name' => self::ENV_MAPPING[$env]['name'],
+            'host' => $dbConfig['host'],
+            'port' => $dbConfig['port'] ?? 3306,
+            'user' => $dbConfig['username'],
+            'pass' => $dbConfig['password'],
+            'source_db' => self::ENV_MAPPING[$env]['source_db'],
+            'target_db' => self::ENV_MAPPING[$env]['target_db']
+        ];
+    }
+
+    /**
+     * Retourne l'environnement actuel
+     */
+    public function getEnv(): string
+    {
+        return $this->env;
+    }
+
+    /**
+     * Retourne le nom complet de l'environnement
+     */
+    public function getEnvName(): string
+    {
+        return $this->config['name'];
+    }
+
+    /**
+     * Retourne l'hôte de la base de données
+     */
+    public function getHost(): string
+    {
+        return $this->config['host'];
+    }
+
+    /**
+     * Retourne le port de la base de données
+     */
+    public function getPort(): int
+    {
+        return $this->config['port'];
+    }
+
+    /**
+     * Retourne l'utilisateur de la base de données
+     */
+    public function getUser(): string
+    {
+        return $this->config['user'];
+    }
+
+    /**
+     * Retourne le mot de passe de la base de données
+     */
+    public function getPassword(): string
+    {
+        return $this->config['pass'];
+    }
+
+    /**
+     * Retourne le nom de la base source
+     */
+    public function getSourceDb(): string
+    {
+        return $this->config['source_db'];
+    }
+
+    /**
+     * Retourne le nom de la base cible
+     */
+    public function getTargetDb(): string
+    {
+        return $this->config['target_db'];
+    }
+
+    /**
+     * Retourne toute la configuration
+     */
+    public function getConfig(): array
+    {
+        return $this->config;
+    }
+
+    /**
+     * Détecte automatiquement l'environnement depuis le hostname
+     *
+     * @return string 'dva', 'rca' ou 'pra' (défaut: 'dva')
+     */
+    public static function autoDetect(): string
+    {
+        $hostname = gethostname();
+
+        switch ($hostname) {
+            case 'dva-geo':
+                return 'dva';
+            case 'rca-geo':
+                return 'rca';
+            case 'pra-geo':
+                return 'pra';
+            default:
+                return 'dva'; // Défaut
+        }
+    }
+
+    /**
+     * Vérifie si un environnement existe
+     */
+    public static function exists(string $env): bool
+    {
+        return isset(self::ENV_MAPPING[$env]);
+    }
+
+    /**
+     * Retourne la liste des environnements disponibles
+     */
+    public static function getAvailableEnvironments(): array
+    {
+        return array_keys(self::ENV_MAPPING);
+    }
+}

api/scripts/migration2/php/lib/DatabaseConnection.php

@@ -0,0 +1,201 @@
+<?php
+
+/**
+ * Gestion des connexions PDO
+ *
+ * Crée et maintient les connexions aux bases source et cible
+ */
+class DatabaseConnection
+{
+    private $config;
+    private $logger;
+    private $sourceDb;
+    private $targetDb;
+
+    /**
+     * Constructeur
+     *
+     * @param DatabaseConfig $config Configuration de l'environnement
+     * @param MigrationLogger $logger Logger pour les messages
+     */
+    public function __construct(DatabaseConfig $config, MigrationLogger $logger)
+    {
+        $this->config = $config;
+        $this->logger = $logger;
+    }
+
+    /**
+     * Établit les connexions aux bases source et cible
+     *
+     * @return bool True si succès
+     */
+    public function connect(): bool
+    {
+        try {
+            // Connexion à la base source
+            $this->connectSource();
+
+            // Connexion à la base cible
+            $this->connectTarget();
+
+            // Vérifier les versions MariaDB
+            $this->checkVersions();
+
+            return true;
+
+        } catch (PDOException $e) {
+            $this->logger->error("Erreur de connexion: " . $e->getMessage());
+            return false;
+        }
+    }
+
+    /**
+     * Connexion à la base source
+     */
+    private function connectSource(): void
+    {
+        $dsn = sprintf(
+            'mysql:host=%s;port=%d;dbname=%s;charset=utf8mb4',
+            $this->config->getHost(),
+            $this->config->getPort(),
+            $this->config->getSourceDb()
+        );
+
+        $this->sourceDb = new PDO($dsn, $this->config->getUser(), $this->config->getPassword(), [
+            PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
+            PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
+            PDO::ATTR_TIMEOUT => 600,
+            PDO::MYSQL_ATTR_INIT_COMMAND => "SET NAMES utf8mb4"
+        ]);
+
+        $this->logger->success("✓ Connexion SOURCE: {$this->config->getSourceDb()} sur {$this->config->getHost()}");
+    }
+
+    /**
+     * Connexion à la base cible
+     */
+    private function connectTarget(): void
+    {
+        $dsn = sprintf(
+            'mysql:host=%s;port=%d;dbname=%s;charset=utf8mb4',
+            $this->config->getHost(),
+            $this->config->getPort(),
+            $this->config->getTargetDb()
+        );
+
+        $this->targetDb = new PDO($dsn, $this->config->getUser(), $this->config->getPassword(), [
+            PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
+            PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
+            PDO::ATTR_TIMEOUT => 600,
+            PDO::MYSQL_ATTR_INIT_COMMAND => "SET NAMES utf8mb4"
+        ]);
+
+        $this->logger->success("✓ Connexion CIBLE: {$this->config->getTargetDb()} sur {$this->config->getHost()}");
+    }
+
+    /**
+     * Vérifie et affiche les versions MariaDB
+     */
+    private function checkVersions(): void
+    {
+        $sourceVersion = $this->sourceDb->query("SELECT VERSION()")->fetchColumn();
+        $targetVersion = $this->targetDb->query("SELECT VERSION()")->fetchColumn();
+
+        $this->logger->info("  Version SOURCE: $sourceVersion");
+        $this->logger->info("  Version CIBLE: $targetVersion");
+    }
+
+    /**
+     * Retourne la connexion à la base source
+     */
+    public function getSourceDb(): PDO
+    {
+        if (!$this->sourceDb) {
+            throw new Exception("Source database not connected. Call connect() first.");
+        }
+        return $this->sourceDb;
+    }
+
+    /**
+     * Retourne la connexion à la base cible
+     */
+    public function getTargetDb(): PDO
+    {
+        if (!$this->targetDb) {
+            throw new Exception("Target database not connected. Call connect() first.");
+        }
+        return $this->targetDb;
+    }
+
+    /**
+     * Compte le nombre de lignes dans une table de la source
+     *
+     * @param string $table Nom de la table
+     * @param int|null $entityId Filtrer par fk_entite (optionnel)
+     * @return int Nombre de lignes
+     */
+    public function countSourceRows(string $table, ?int $entityId = null): int
+    {
+        $sql = "SELECT COUNT(*) FROM $table";
+
+        if ($entityId !== null) {
+            // Tables avec fk_entite direct
+            if (in_array($table, ['users', 'operations', 'entites'])) {
+                $sql .= " WHERE fk_entite = :entity_id";
+            }
+            // Tables liées via operations
+            elseif (in_array($table, ['ope_sectors', 'ope_users', 'ope_pass'])) {
+                $sql .= " WHERE fk_operation IN (SELECT id FROM operations WHERE fk_entite = :entity_id)";
+            }
+        }
+
+        $stmt = $this->sourceDb->prepare($sql);
+        if ($entityId !== null) {
+            $stmt->execute(['entity_id' => $entityId]);
+        } else {
+            $stmt->execute();
+        }
+
+        return (int) $stmt->fetchColumn();
+    }
+
+    /**
+     * Compte le nombre de lignes dans une table de la cible
+     *
+     * @param string $table Nom de la table
+     * @param int|null $entityId Filtrer par fk_entite (optionnel)
+     * @return int Nombre de lignes
+     */
+    public function countTargetRows(string $table, ?int $entityId = null): int
+    {
+        $sql = "SELECT COUNT(*) FROM $table";
+
+        if ($entityId !== null) {
+            if (in_array($table, ['users', 'operations', 'entites'])) {
+                $sql .= " WHERE fk_entite = :entity_id";
+            }
+            elseif (in_array($table, ['ope_sectors', 'ope_users', 'ope_pass'])) {
+                $sql .= " WHERE fk_operation IN (SELECT id FROM operations WHERE fk_entite = :entity_id)";
+            }
+        }
+
+        $stmt = $this->targetDb->prepare($sql);
+        if ($entityId !== null) {
+            $stmt->execute(['entity_id' => $entityId]);
+        } else {
+            $stmt->execute();
+        }
+
+        return (int) $stmt->fetchColumn();
+    }
+
+    /**
+     * Ferme les connexions
+     */
+    public function close(): void
+    {
+        $this->sourceDb = null;
+        $this->targetDb = null;
+        $this->logger->info("Connexions fermées");
+    }
+}

api/scripts/migration2/php/lib/MigrationLogger.php

@@ -0,0 +1,219 @@
+<?php
+
+/**
+ * Gestion des logs de migration
+ *
+ * Écrit dans un fichier et affiche à l'écran avec timestamps
+ */
+class MigrationLogger
+{
+    private $logFile;
+    private $verbose;
+
+    /**
+     * Constructeur
+     *
+     * @param string|null $logFile Chemin du fichier de log (null = auto-généré)
+     * @param bool $verbose Afficher les logs à l'écran
+     */
+    public function __construct(?string $logFile = null, bool $verbose = true)
+    {
+        // Définir le répertoire de logs par défaut (migration2/logs/)
+        $defaultLogDir = dirname(__DIR__, 2) . '/logs';
+        $this->logFile = $logFile ?? $defaultLogDir . '/migration_' . date('Ymd_His') . '.log';
+        $this->verbose = $verbose;
+
+        // Créer le dossier parent si nécessaire
+        $dir = dirname($this->logFile);
+        if (!is_dir($dir)) {
+            mkdir($dir, 0755, true);
+        }
+
+        // Vérifier que le fichier est accessible en écriture
+        if (!is_writable(dirname($this->logFile))) {
+            throw new Exception("Log directory is not writable: " . dirname($this->logFile));
+        }
+    }
+
+    /**
+     * Log un message avec niveau INFO
+     */
+    public function info(string $message): void
+    {
+        $this->log($message, 'INFO');
+    }
+
+    /**
+     * Log un message avec niveau SUCCESS
+     */
+    public function success(string $message): void
+    {
+        $this->log($message, 'SUCCESS');
+    }
+
+    /**
+     * Log un message avec niveau WARNING
+     */
+    public function warning(string $message): void
+    {
+        $this->log($message, 'WARNING');
+    }
+
+    /**
+     * Log un message avec niveau ERROR
+     */
+    public function error(string $message): void
+    {
+        $this->log($message, 'ERROR');
+    }
+
+    /**
+     * Log un message avec niveau DEBUG
+     */
+    public function debug(string $message): void
+    {
+        $this->log($message, 'DEBUG');
+    }
+
+    /**
+     * Log une ligne de séparation
+     */
+    public function separator(): void
+    {
+        $this->log(str_repeat('=', 80), 'INFO');
+    }
+
+    /**
+     * Log générique
+     *
+     * @param string $message Message à logger
+     * @param string $level Niveau: INFO, SUCCESS, WARNING, ERROR, DEBUG
+     */
+    private function log(string $message, string $level = 'INFO'): void
+    {
+        $timestamp = date('Y-m-d H:i:s');
+        $logLine = "[{$timestamp}] [{$level}] {$message}\n";
+
+        // Écriture dans le fichier
+        file_put_contents($this->logFile, $logLine, FILE_APPEND);
+
+        // Affichage à l'écran si verbose
+        if ($this->verbose) {
+            $this->printColored($message, $level);
+        }
+    }
+
+    /**
+     * Affiche un message coloré selon le niveau
+     */
+    private function printColored(string $message, string $level): void
+    {
+        $colors = [
+            'INFO' => "\033[0;37m",    // Blanc
+            'SUCCESS' => "\033[0;32m", // Vert
+            'WARNING' => "\033[0;33m", // Jaune
+            'ERROR' => "\033[0;31m",   // Rouge
+            'DEBUG' => "\033[0;36m"    // Cyan
+        ];
+
+        $reset = "\033[0m";
+        $color = $colors[$level] ?? $colors['INFO'];
+
+        echo $color . $message . $reset . "\n";
+    }
+
+    /**
+     * Retourne le chemin du fichier de log
+     */
+    public function getLogFile(): string
+    {
+        return $this->logFile;
+    }
+
+    /**
+     * Log des statistiques de migration
+     *
+     * @param array $stats Tableau associatif [table => count]
+     */
+    public function logStats(array $stats): void
+    {
+        $this->separator();
+        $this->info("📊 Statistiques de migration:");
+
+        foreach ($stats as $table => $count) {
+            $this->info("  - {$table}: {$count} enregistrement(s)");
+        }
+
+        $this->separator();
+    }
+
+    /**
+     * Log une ligne spéciale pour parsing automatique
+     * Format: #STATS# KEY1:VAL1 KEY2:VAL2 ...
+     */
+    public function logParsableStats(array $stats): void
+    {
+        $pairs = [];
+        foreach ($stats as $key => $value) {
+            $pairs[] = strtoupper($key) . ':' . $value;
+        }
+
+        $line = '#STATS# ' . implode(' ', $pairs);
+        $this->log($line, 'INFO');
+    }
+
+    /**
+     * Affiche et log un récapitulatif complet de migration
+     *
+     * @param array $summary Tableau de statistiques hiérarchique
+     */
+    public function logMigrationSummary(array $summary): void
+    {
+        $this->separator();
+        $this->separator();
+        $this->info("📊 RÉCAPITULATIF DE LA MIGRATION");
+        $this->separator();
+
+        // Entité
+        if (isset($summary['entity'])) {
+            $this->info("Entité: {$summary['entity']['name']} (ID: {$summary['entity']['id']})");
+        }
+        $this->info("Date: " . date('Y-m-d H:i:s'));
+        $this->info("");
+
+        // Nombre total d'opérations
+        $totalOperations = count($summary['operations'] ?? []);
+        $this->success("Opérations migrées: {$totalOperations}");
+        $this->info("");
+
+        // Détail par opération
+        $operationNum = 1;
+        foreach ($summary['operations'] ?? [] as $operation) {
+            $this->info("Opération #{$operationNum}: \"{$operation['name']}\" (ID: {$operation['id']})");
+            $this->info("  ├─ Utilisateurs: {$operation['users']}");
+            $this->info("  ├─ Secteurs: {$operation['sectors']}");
+            $this->info("  ├─ Passages totaux: {$operation['total_passages']}");
+
+            if (!empty($operation['sectors_detail'])) {
+                $this->info("  └─ Détail par secteur:");
+
+                $sectorCount = count($operation['sectors_detail']);
+                $sectorNum = 0;
+                foreach ($operation['sectors_detail'] as $sector) {
+                    $sectorNum++;
+                    $isLast = ($sectorNum === $sectorCount);
+                    $prefix = $isLast ? "      └─" : "      ├─";
+
+                    $this->info("{$prefix} {$sector['name']} (ID: {$sector['id']})");
+                    $this->info("      " . ($isLast ? " " : "│") . "   ├─ Utilisateurs affectés: {$sector['users']}");
+                    $this->info("      " . ($isLast ? " " : "│") . "   └─ Passages: {$sector['passages']}");
+                }
+            }
+
+            $this->info("");
+            $operationNum++;
+        }
+
+        $this->separator();
+    }
+}

api/scripts/migration2/php/lib/OperationMigrator.php

@@ -0,0 +1,312 @@
+<?php
+
+/**
+ * Migration des opérations complètes
+ *
+ * Orchestre la migration d'une opération avec tous ses utilisateurs,
+ * secteurs, passages et médias. Utilise UserMigrator et SectorMigrator.
+ */
+class OperationMigrator
+{
+    private PDO $sourceDb;
+    private PDO $targetDb;
+    private MigrationLogger $logger;
+    private UserMigrator $userMigrator;
+    private SectorMigrator $sectorMigrator;
+
+    /**
+     * Constructeur
+     *
+     * @param PDO $sourceDb Connexion source
+     * @param PDO $targetDb Connexion cible
+     * @param MigrationLogger $logger Logger
+     * @param UserMigrator $userMigrator Migrator d'utilisateurs
+     * @param SectorMigrator $sectorMigrator Migrator de secteurs
+     */
+    public function __construct(
+        PDO $sourceDb,
+        PDO $targetDb,
+        MigrationLogger $logger,
+        UserMigrator $userMigrator,
+        SectorMigrator $sectorMigrator
+    ) {
+        $this->sourceDb = $sourceDb;
+        $this->targetDb = $targetDb;
+        $this->logger = $logger;
+        $this->userMigrator = $userMigrator;
+        $this->sectorMigrator = $sectorMigrator;
+    }
+
+    /**
+     * Récupère les opérations à migrer pour une entité
+     * - 1 opération active
+     * - 2 dernières opérations inactives avec au moins 10 passages effectués
+     *
+     * @param int $entityId ID de l'entité
+     * @return array Liste des IDs d'opérations à migrer
+     */
+    public function getOperationsToMigrate(int $entityId): array
+    {
+        $operationIds = [];
+
+        // 1. Récupérer l'opération active (pour vérification)
+        $stmt = $this->sourceDb->prepare("
+            SELECT rowid
+            FROM operations
+            WHERE fk_entite = :entity_id AND active = 1
+            LIMIT 1
+        ");
+        $stmt->execute([':entity_id' => $entityId]);
+        $activeOp = $stmt->fetch(PDO::FETCH_COLUMN);
+
+        // 2. Récupérer les 2 dernières opérations inactives avec >= 10 passages effectués
+        // ORDER BY DESC pour avoir les plus récentes, puis on inverse
+        $stmt = $this->sourceDb->prepare("
+            SELECT o.rowid, COUNT(p.rowid) as nb_passages
+            FROM operations o
+            LEFT JOIN ope_pass p ON p.fk_operation = o.rowid AND p.fk_type = 1
+            WHERE o.fk_entite = :entity_id
+            AND o.active = 0
+            " . ($activeOp ? "AND o.rowid != :active_id" : "") . "
+            GROUP BY o.rowid
+            HAVING nb_passages >= 10
+            ORDER BY o.rowid DESC
+            LIMIT 2
+        ");
+
+        $params = [':entity_id' => $entityId];
+        if ($activeOp) {
+            $params[':active_id'] = $activeOp;
+        }
+
+        $stmt->execute($params);
+        $inactiveOps = $stmt->fetchAll(PDO::FETCH_ASSOC);
+
+        // Inverser pour avoir l'ordre chronologique (plus ancienne → plus récente)
+        $inactiveOps = array_reverse($inactiveOps);
+
+        foreach ($inactiveOps as $op) {
+            $operationIds[] = $op['rowid'];
+            $this->logger->info("✓ Opération inactive trouvée: {$op['rowid']} ({$op['nb_passages']} passages)");
+        }
+
+        // 3. Ajouter l'opération active EN DERNIER
+        if ($activeOp) {
+            $operationIds[] = $activeOp;
+            $this->logger->info("✓ Opération active trouvée: {$activeOp}");
+        }
+
+        $this->logger->info("📊 Total: " . count($operationIds) . " opération(s) à migrer");
+
+        return $operationIds;
+    }
+
+    /**
+     * Migre une opération complète avec tous ses utilisateurs et secteurs
+     *
+     * @param int $oldOperationId ID de l'opération dans l'ancienne base
+     * @return array|null Tableau de statistiques ou null en cas d'erreur
+     */
+    public function migrateOperation(int $oldOperationId): ?array
+    {
+        $this->logger->separator();
+        $this->logger->info("🔄 Migration de l'opération ID: {$oldOperationId}");
+
+        try {
+            // 1. Récupérer l'opération source
+            $stmt = $this->sourceDb->prepare("
+                SELECT * FROM operations
+                WHERE rowid = :id
+            ");
+            $stmt->execute([':id' => $oldOperationId]);
+            $operation = $stmt->fetch(PDO::FETCH_ASSOC);
+
+            if (!$operation) {
+                $this->logger->warning("Opération {$oldOperationId} non trouvée");
+                return null;
+            }
+
+            // 2. Créer l'opération dans la nouvelle base
+            $newOperationId = $this->createOperation($operation);
+
+            if (!$newOperationId) {
+                return null;
+            }
+
+            $this->logger->success("✓ Opération créée avec ID: {$newOperationId}");
+
+            // 3. Migrer les utilisateurs de l'opération
+            // Pour opération active : tous les users actifs de l'entité
+            // Pour opération inactive : uniquement ceux dans ope_users_sectors
+            $entityId = (int)$operation['fk_entite'];
+            $isActiveOperation = (int)$operation['active'] === 1;
+
+            $userResult = $this->userMigrator->migrateOperationUsers(
+                $oldOperationId,
+                $newOperationId,
+                $entityId,
+                $isActiveOperation
+            );
+            $userMapping = $userResult['mapping'];
+            $usersCount = $userResult['count'];
+
+            if (empty($userMapping)) {
+                $this->logger->warning("Aucun utilisateur migré, abandon de l'opération {$oldOperationId}");
+                return null;
+            }
+
+            // 4. Récupérer les secteurs DISTINCTS de l'opération
+            $stmt = $this->sourceDb->prepare("
+                SELECT DISTINCT fk_sector
+                FROM ope_users_sectors
+                WHERE fk_operation = :operation_id AND active = 1
+            ");
+            $stmt->execute([':operation_id' => $oldOperationId]);
+            $sectors = $stmt->fetchAll(PDO::FETCH_COLUMN);
+
+            $this->logger->info("📍 " . count($sectors) . " secteur(s) distinct(s) à migrer");
+
+            // 5. Migrer chaque secteur et collecter les stats
+            $sectorsDetail = [];
+            $totalPassages = 0;
+
+            foreach ($sectors as $oldSectorId) {
+                $sectorStats = $this->sectorMigrator->migrateSector(
+                    $oldOperationId,
+                    $newOperationId,
+                    $oldSectorId,
+                    $userMapping
+                );
+
+                if ($sectorStats) {
+                    $sectorsDetail[] = $sectorStats;
+                    $totalPassages += $sectorStats['passages'];
+                }
+            }
+
+            // 6. Migrer les médias de l'opération (support='operations')
+            $this->migrateOperationMedias($oldOperationId, $newOperationId);
+
+            $this->logger->success("✅ Migration de l'opération {$oldOperationId} terminée");
+
+            // 7. Retourner les statistiques
+            return [
+                'id' => $newOperationId,
+                'name' => $operation['libelle'],
+                'users' => $usersCount,
+                'sectors' => count($sectorsDetail),
+                'total_passages' => $totalPassages,
+                'sectors_detail' => $sectorsDetail
+            ];
+
+        } catch (Exception $e) {
+            $this->logger->error("❌ Erreur migration opération {$oldOperationId}: " . $e->getMessage());
+            return null;
+        }
+    }
+
+    /**
+     * Crée une opération dans la nouvelle base
+     *
+     * @param array $operation Données de l'opération
+     * @return int|null ID de la nouvelle opération ou null en cas d'erreur
+     */
+    private function createOperation(array $operation): ?int
+    {
+        try {
+            $stmt = $this->targetDb->prepare("
+                INSERT INTO operations (
+                    fk_entite, libelle, date_deb, date_fin,
+                    chk_distinct_sectors,
+                    created_at, fk_user_creat, updated_at, fk_user_modif, chk_active
+                ) VALUES (
+                    :fk_entite, :libelle, :date_deb, :date_fin,
+                    :chk_distinct_sectors,
+                    :created_at, :fk_user_creat, :updated_at, :fk_user_modif, :chk_active
+                )
+            ");
+
+            $stmt->execute([
+                ':fk_entite' => $operation['fk_entite'],
+                ':libelle' => $operation['libelle'],
+                ':date_deb' => $operation['date_deb'],
+                ':date_fin' => $operation['date_fin'],
+                ':chk_distinct_sectors' => $operation['chk_distinct_sectors'],
+                ':created_at' => $operation['date_creat'],
+                ':fk_user_creat' => $operation['fk_user_creat'],
+                ':updated_at' => $operation['date_modif'],
+                ':fk_user_modif' => $operation['fk_user_modif'] ?? 0,
+                ':chk_active' => $operation['active']
+            ]);
+
+            return (int)$this->targetDb->lastInsertId();
+
+        } catch (Exception $e) {
+            $this->logger->error("❌ Erreur création opération: " . $e->getMessage());
+            return null;
+        }
+    }
+
+    /**
+     * Migre les médias d'une opération
+     *
+     * @param int $oldOperationId ID ancienne opération
+     * @param int $newOperationId ID nouvelle opération
+     * @return int Nombre de médias migrés
+     */
+    private function migrateOperationMedias(int $oldOperationId, int $newOperationId): int
+    {
+        $stmt = $this->sourceDb->prepare("
+            SELECT * FROM medias
+            WHERE support = 'operations' AND support_rowid = :operation_id
+        ");
+        $stmt->execute([':operation_id' => $oldOperationId]);
+        $medias = $stmt->fetchAll(PDO::FETCH_ASSOC);
+
+        if (empty($medias)) {
+            return 0;
+        }
+
+        $count = 0;
+        foreach ($medias as $media) {
+            $stmt = $this->targetDb->prepare("
+                INSERT INTO medias (
+                    dir0, dir1, dir2, support, support_rowid,
+                    fichier, type_fichier, description, position,
+                    hauteur, largeur, niveaugris,
+                    created_at, fk_user_creat, updated_at, fk_user_modif
+                ) VALUES (
+                    :dir0, :dir1, :dir2, :support, :support_rowid,
+                    :fichier, :type_fichier, :description, :position,
+                    :hauteur, :largeur, :niveaugris,
+                    :created_at, :fk_user_creat, :updated_at, :fk_user_modif
+                )
+            ");
+
+            $stmt->execute([
+                ':dir0' => $media['dir0'],
+                ':dir1' => $media['dir1'],
+                ':dir2' => $media['dir2'],
+                ':support' => $media['support'],
+                ':support_rowid' => $newOperationId,
+                ':fichier' => $media['fichier'],
+                ':type_fichier' => $media['type_fichier'],
+                ':description' => $media['description'],
+                ':position' => $media['position'],
+                ':hauteur' => $media['hauteur'],
+                ':largeur' => $media['largeur'],
+                ':niveaugris' => $media['niveaugris'],
+                ':created_at' => $media['date_creat'],
+                ':fk_user_creat' => $media['fk_user_creat'],
+                ':updated_at' => $media['date_modif'],
+                ':fk_user_modif' => $media['fk_user_modif']
+            ]);
+
+            $count++;
+        }
+
+        $this->logger->success("✓ {$count} média(s) migré(s)");
+
+        return $count;
+    }
+}

api/scripts/migration2/php/lib/PassageMigrator.php

@@ -0,0 +1,256 @@
+<?php
+
+/**
+ * Migration des passages (ope_pass) et historiques (ope_pass_histo)
+ *
+ * Gère la migration des passages avec vérification du trio
+ * (operation, user, sector) et migration des historiques associés
+ */
+class PassageMigrator
+{
+    private PDO $sourceDb;
+    private PDO $targetDb;
+    private MigrationLogger $logger;
+
+    /**
+     * Constructeur
+     *
+     * @param PDO $sourceDb Connexion source
+     * @param PDO $targetDb Connexion cible
+     * @param MigrationLogger $logger Logger
+     */
+    public function __construct(PDO $sourceDb, PDO $targetDb, MigrationLogger $logger)
+    {
+        $this->sourceDb = $sourceDb;
+        $this->targetDb = $targetDb;
+        $this->logger = $logger;
+    }
+
+    /**
+     * Migre les passages d'un secteur dans une opération
+     *
+     * @param int $oldOperationId ID ancienne opération
+     * @param int $newOperationId ID nouvelle opération
+     * @param int $oldSectorId ID ancien secteur
+     * @param int $newOpeSectorId ID nouveau ope_sectors
+     * @param array $userMapping Mapping oldUserId => newOpeUserId
+     * @return int Nombre de passages migrés
+     */
+    public function migratePassages(
+        int $oldOperationId,
+        int $newOperationId,
+        int $oldSectorId,
+        int $newOpeSectorId,
+        array $userMapping
+    ): int {
+        $stmt = $this->sourceDb->prepare("
+            SELECT * FROM ope_pass
+            WHERE fk_operation = :operation_id
+            AND fk_sector = :sector_id
+        ");
+        $stmt->execute([
+            ':operation_id' => $oldOperationId,
+            ':sector_id' => $oldSectorId
+        ]);
+        $passages = $stmt->fetchAll(PDO::FETCH_ASSOC);
+
+        if (empty($passages)) {
+            return 0;
+        }
+
+        $count = 0;
+        foreach ($passages as $passage) {
+            // Vérifier que l'utilisateur a été migré
+            if (!isset($userMapping[$passage['fk_user']])) {
+                $this->logger->warning("  ⚠ Passage {$passage['rowid']}: User {$passage['fk_user']} non trouvé dans mapping");
+                continue;
+            }
+
+            // Récupérer l'ID de ope_users depuis le mapping
+            $newOpeUserId = $userMapping[$passage['fk_user']];
+
+            // Vérifier que le trio (operation, user, sector) existe dans ope_users_sectors
+            if (!$this->verifyUserSectorAssociation($newOperationId, $newOpeUserId, $newOpeSectorId)) {
+                $this->logger->warning("  ⚠ Passage {$passage['rowid']}: Trio (op={$newOperationId}, user={$newOpeUserId}, sector={$newOpeSectorId}) inexistant");
+                continue;
+            }
+
+            // Insérer le passage avec l'ID de ope_users
+            $newPassId = $this->insertPassage($passage, $newOperationId, $newOpeSectorId, $newOpeUserId);
+
+            if ($newPassId) {
+                // Migrer l'historique du passage
+                $this->migratePassageHisto($passage['rowid'], $newPassId, $userMapping);
+                $count++;
+            }
+        }
+
+        if ($count > 0) {
+            $this->logger->success("  ✓ {$count} passage(s) migré(s)");
+        }
+
+        return $count;
+    }
+
+    /**
+     * Vérifie qu'une association user-sector existe dans ope_users_sectors
+     *
+     * @param int $operationId ID opération
+     * @param int $userId ID ope_users (mapping)
+     * @param int $sectorId ID ope_sectors
+     * @return bool True si l'association existe
+     */
+    private function verifyUserSectorAssociation(int $operationId, int $userId, int $sectorId): bool
+    {
+        $stmt = $this->targetDb->prepare("
+            SELECT COUNT(*) FROM ope_users_sectors
+            WHERE fk_operation = :operation_id
+            AND fk_user = :user_id
+            AND fk_sector = :sector_id
+        ");
+        $stmt->execute([
+            ':operation_id' => $operationId,
+            ':user_id' => $userId,
+            ':sector_id' => $sectorId
+        ]);
+
+        return $stmt->fetchColumn() > 0;
+    }
+
+    /**
+     * Insère un passage dans la nouvelle base
+     *
+     * @param array $passage Données du passage
+     * @param int $newOperationId ID nouvelle opération
+     * @param int $newOpeSectorId ID nouveau secteur
+     * @param int $userId ID de ope_users (mapping)
+     * @return int|null ID du nouveau passage ou null en cas d'erreur
+     */
+    private function insertPassage(
+        array $passage,
+        int $newOperationId,
+        int $newOpeSectorId,
+        int $userId
+    ): ?int {
+        try {
+            $stmt = $this->targetDb->prepare("
+                INSERT INTO ope_pass (
+                    fk_operation, fk_sector, fk_user, fk_adresse,
+                    passed_at, fk_type, numero, rue, rue_bis, ville,
+                    fk_habitat, appt, niveau, residence,
+                    gps_lat, gps_lng, encrypted_name, montant, fk_type_reglement,
+                    remarque, nom_recu, encrypted_email, email_erreur, chk_email_sent,
+                    encrypted_phone, docremis, date_repasser, nb_passages,
+                    chk_gps_maj, chk_map_create, chk_mobile, chk_synchro,
+                    chk_api_adresse, chk_maj_adresse, anomalie,
+                    created_at, fk_user_creat, updated_at, fk_user_modif, chk_active
+                ) VALUES (
+                    :fk_operation, :fk_sector, :fk_user, :fk_adresse,
+                    :passed_at, :fk_type, :numero, :rue, :rue_bis, :ville,
+                    :fk_habitat, :appt, :niveau, :residence,
+                    :gps_lat, :gps_lng, :encrypted_name, :montant, :fk_type_reglement,
+                    :remarque, :nom_recu, :encrypted_email, :email_erreur, :chk_email_sent,
+                    :encrypted_phone, :docremis, :date_repasser, :nb_passages,
+                    :chk_gps_maj, :chk_map_create, :chk_mobile, :chk_synchro,
+                    :chk_api_adresse, :chk_maj_adresse, :anomalie,
+                    :created_at, :fk_user_creat, :updated_at, :fk_user_modif, :chk_active
+                )
+            ");
+
+            // Chiffrer les données sensibles
+            require_once dirname(__DIR__, 4) . '/src/Services/ApiService.php';
+
+            $stmt->execute([
+                ':fk_operation' => $newOperationId,
+                ':fk_sector' => $newOpeSectorId,
+                ':fk_user' => $userId, // ID de ope_users (mapping)
+                ':fk_adresse' => $passage['fk_adresse'],
+                ':passed_at' => $passage['date_eve'],
+                ':fk_type' => $passage['fk_type'],
+                ':numero' => $passage['numero'],
+                ':rue' => $passage['rue'],
+                ':rue_bis' => $passage['rue_bis'],
+                ':ville' => $passage['ville'],
+                ':fk_habitat' => $passage['fk_habitat'],
+                ':appt' => $passage['appt'],
+                ':niveau' => $passage['niveau'],
+                ':residence' => $passage['lieudit'] ?? null,
+                ':gps_lat' => $passage['gps_lat'],
+                ':gps_lng' => $passage['gps_lng'],
+                ':encrypted_name' => $passage['libelle'] ? ApiService::encryptData($passage['libelle']) : '', // Chiffrer avec IV aléatoire
+                ':montant' => $passage['montant'],
+                ':fk_type_reglement' => (!empty($passage['fk_type_reglement']) && $passage['fk_type_reglement'] > 0) ? $passage['fk_type_reglement'] : 4,
+                ':remarque' => $passage['remarque'],
+                ':nom_recu' => $passage['recu'] ?? null,
+                ':encrypted_email' => $passage['email'] ? ApiService::encryptSearchableData($passage['email']) : null,
+                ':email_erreur' => $passage['email_erreur'],
+                ':chk_email_sent' => $passage['chk_email_sent'],
+                ':encrypted_phone' => $passage['phone'] ? ApiService::encryptData($passage['phone']) : '',
+                ':docremis' => $passage['docremis'],
+                ':date_repasser' => $passage['date_repasser'],
+                ':nb_passages' => ($passage['fk_type'] == 2) ? 0 : $passage['nb_passages'],
+                ':chk_gps_maj' => $passage['chk_gps_maj'],
+                ':chk_map_create' => $passage['chk_map_create'],
+                ':chk_mobile' => $passage['chk_mobile'],
+                ':chk_synchro' => $passage['chk_synchro'],
+                ':chk_api_adresse' => $passage['chk_api_adresse'],
+                ':chk_maj_adresse' => $passage['chk_maj_adresse'],
+                ':anomalie' => $passage['anomalie'],
+                ':created_at' => $passage['date_creat'],
+                ':fk_user_creat' => $passage['fk_user_creat'] ?? 0,
+                ':updated_at' => $passage['date_modif'],
+                ':fk_user_modif' => $passage['fk_user_modif'] ?? 0,
+                ':chk_active' => $passage['active']
+            ]);
+
+            return (int)$this->targetDb->lastInsertId();
+
+        } catch (Exception $e) {
+            $this->logger->error("  ❌ Erreur insertion passage {$passage['rowid']}: " . $e->getMessage());
+            return null;
+        }
+    }
+
+    /**
+     * Migre l'historique d'un passage
+     *
+     * @param int $oldPassId ID ancien passage
+     * @param int $newPassId ID nouveau passage
+     * @param array $userMapping Non utilisé (conservé pour compatibilité)
+     * @return int Nombre d'entrées d'historique migrées
+     */
+    public function migratePassageHisto(int $oldPassId, int $newPassId, array $userMapping): int
+    {
+        $stmt = $this->sourceDb->prepare("
+            SELECT * FROM ope_pass_histo WHERE fk_pass = :pass_id
+        ");
+        $stmt->execute([':pass_id' => $oldPassId]);
+        $histos = $stmt->fetchAll(PDO::FETCH_ASSOC);
+
+        if (empty($histos)) {
+            return 0;
+        }
+
+        $count = 0;
+        foreach ($histos as $histo) {
+            $stmt = $this->targetDb->prepare("
+                INSERT INTO ope_pass_histo (
+                    fk_pass, date_histo, sujet, remarque
+                ) VALUES (
+                    :fk_pass, :date_histo, :sujet, :remarque
+                )
+            ");
+
+            $stmt->execute([
+                ':fk_pass' => $newPassId,
+                ':date_histo' => $histo['date_histo'],
+                ':sujet' => $histo['sujet'],
+                ':remarque' => $histo['remarque']
+            ]);
+
+            $count++;
+        }
+
+        return $count;
+    }
+}

api/scripts/migration2/php/lib/SectorMigrator.php

@@ -0,0 +1,289 @@
+<?php
+
+/**
+ * Migration des secteurs (ope_sectors) et données associées
+ *
+ * Gère la migration des secteurs avec leurs adresses, associations
+ * utilisateurs-secteurs, et passages. Utilise PassageMigrator pour les passages.
+ */
+class SectorMigrator
+{
+    private PDO $sourceDb;
+    private PDO $targetDb;
+    private MigrationLogger $logger;
+    private PassageMigrator $passageMigrator;
+    private array $sectorMapping = [];
+
+    /**
+     * Constructeur
+     *
+     * @param PDO $sourceDb Connexion source
+     * @param PDO $targetDb Connexion cible
+     * @param MigrationLogger $logger Logger
+     * @param PassageMigrator $passageMigrator Migrator de passages
+     */
+    public function __construct(
+        PDO $sourceDb,
+        PDO $targetDb,
+        MigrationLogger $logger,
+        PassageMigrator $passageMigrator
+    ) {
+        $this->sourceDb = $sourceDb;
+        $this->targetDb = $targetDb;
+        $this->logger = $logger;
+        $this->passageMigrator = $passageMigrator;
+    }
+
+    /**
+     * Migre un secteur dans le contexte d'une opération
+     *
+     * @param int $oldOperationId ID ancienne opération
+     * @param int $newOperationId ID nouvelle opération
+     * @param int $oldSectorId ID ancien secteur
+     * @param array $userMapping Mapping oldUserId => newOpeUserId
+     * @return array|null ['id' => int, 'name' => string, 'users' => int, 'passages' => int] ou null en cas d'erreur
+     */
+    public function migrateSector(
+        int $oldOperationId,
+        int $newOperationId,
+        int $oldSectorId,
+        array $userMapping
+    ): ?array {
+        $this->logger->info("  📍 Migration secteur ID: {$oldSectorId}");
+
+        try {
+            // 1. Récupérer le secteur source
+            $stmt = $this->sourceDb->prepare("
+                SELECT * FROM sectors WHERE rowid = :id
+            ");
+            $stmt->execute([':id' => $oldSectorId]);
+            $sector = $stmt->fetch(PDO::FETCH_ASSOC);
+
+            if (!$sector) {
+                $this->logger->warning("  Secteur {$oldSectorId} non trouvé");
+                return null;
+            }
+
+            // 2. Créer dans ope_sectors
+            $newOpeSectorId = $this->createOpeSector($sector, $newOperationId);
+
+            if (!$newOpeSectorId) {
+                return null;
+            }
+
+            // 3. Mapper "operationId_sectorId" → newOpeSectorId
+            $mappingKey = "{$oldOperationId}_{$oldSectorId}";
+            $this->sectorMapping[$mappingKey] = $newOpeSectorId;
+
+            $this->logger->success("  ✓ Secteur créé avec ID: {$newOpeSectorId}");
+
+            // 4. Migrer sectors_adresses
+            $this->migrateSectorAddresses($oldSectorId, $newOpeSectorId);
+
+            // 5. Migrer ope_users_sectors
+            $usersCount = $this->migrateUsersSectors($oldOperationId, $newOperationId, $oldSectorId, $newOpeSectorId, $userMapping);
+
+            // 6. Migrer ope_pass
+            $passagesCount = $this->passageMigrator->migratePassages(
+                $oldOperationId,
+                $newOperationId,
+                $oldSectorId,
+                $newOpeSectorId,
+                $userMapping
+            );
+
+            return [
+                'id' => $newOpeSectorId,
+                'name' => $sector['libelle'],
+                'users' => $usersCount,
+                'passages' => $passagesCount
+            ];
+
+        } catch (Exception $e) {
+            $this->logger->error("  ❌ Erreur migration secteur {$oldSectorId}: " . $e->getMessage());
+            return null;
+        }
+    }
+
+    /**
+     * Crée un secteur dans ope_sectors
+     *
+     * @param array $sector Données du secteur
+     * @param int $newOperationId ID nouvelle opération
+     * @return int|null ID du nouveau secteur ou null en cas d'erreur
+     */
+    private function createOpeSector(array $sector, int $newOperationId): ?int
+    {
+        try {
+            $stmt = $this->targetDb->prepare("
+                INSERT INTO ope_sectors (
+                    fk_operation, libelle, sector, color,
+                    created_at, fk_user_creat, updated_at, fk_user_modif, chk_active
+                ) VALUES (
+                    :fk_operation, :libelle, :sector, :color,
+                    :created_at, :fk_user_creat, :updated_at, :fk_user_modif, :chk_active
+                )
+            ");
+
+            $stmt->execute([
+                ':fk_operation' => $newOperationId,
+                ':libelle' => $sector['libelle'],
+                ':sector' => $sector['sector'],
+                ':color' => $sector['color'],
+                ':created_at' => $sector['date_creat'],
+                ':fk_user_creat' => $sector['fk_user_creat'] ?? 0,
+                ':updated_at' => $sector['date_modif'],
+                ':fk_user_modif' => $sector['fk_user_modif'] ?? 0,
+                ':chk_active' => $sector['active']
+            ]);
+
+            return (int)$this->targetDb->lastInsertId();
+
+        } catch (Exception $e) {
+            $this->logger->error("  ❌ Erreur création secteur: " . $e->getMessage());
+            return null;
+        }
+    }
+
+    /**
+     * Migre les adresses d'un secteur
+     *
+     * @param int $oldSectorId ID ancien secteur
+     * @param int $newOpeSectorId ID nouveau ope_sectors
+     * @return int Nombre d'adresses migrées
+     */
+    private function migrateSectorAddresses(int $oldSectorId, int $newOpeSectorId): int
+    {
+        $stmt = $this->sourceDb->prepare("
+            SELECT * FROM sectors_adresses WHERE fk_sector = :sector_id
+        ");
+        $stmt->execute([':sector_id' => $oldSectorId]);
+        $addresses = $stmt->fetchAll(PDO::FETCH_ASSOC);
+
+        if (empty($addresses)) {
+            return 0;
+        }
+
+        $count = 0;
+        foreach ($addresses as $address) {
+            $stmt = $this->targetDb->prepare("
+                INSERT INTO sectors_adresses (
+                    fk_adresse, fk_sector, numero, rue_bis, rue, cp, ville,
+                    gps_lat, gps_lng
+                ) VALUES (
+                    :fk_adresse, :fk_sector, :numero, :rue_bis, :rue, :cp, :ville,
+                    :gps_lat, :gps_lng
+                )
+            ");
+
+            $stmt->execute([
+                ':fk_adresse' => $address['fk_adresse'], // Garde la valeur telle quelle
+                ':fk_sector' => $newOpeSectorId,
+                ':numero' => $address['numero'],
+                ':rue_bis' => $address['rue_bis'],
+                ':rue' => $address['rue'],
+                ':cp' => $address['cp'],
+                ':ville' => $address['ville'],
+                ':gps_lat' => $address['gps_lat'],
+                ':gps_lng' => $address['gps_lng']
+            ]);
+
+            $count++;
+        }
+
+        $this->logger->success("  ✓ {$count} adresse(s) migrée(s)");
+
+        return $count;
+    }
+
+    /**
+     * Migre les associations utilisateurs-secteurs
+     *
+     * @param int $oldOperationId ID ancienne opération
+     * @param int $newOperationId ID nouvelle opération
+     * @param int $oldSectorId ID ancien secteur
+     * @param int $newOpeSectorId ID nouveau ope_sectors
+     * @param array $userMapping Mapping oldUserId => newOpeUserId
+     * @return int Nombre d'associations migrées
+     */
+    private function migrateUsersSectors(
+        int $oldOperationId,
+        int $newOperationId,
+        int $oldSectorId,
+        int $newOpeSectorId,
+        array $userMapping
+    ): int {
+        $stmt = $this->sourceDb->prepare("
+            SELECT * FROM ope_users_sectors
+            WHERE fk_operation = :operation_id
+            AND fk_sector = :sector_id
+            AND active = 1
+        ");
+        $stmt->execute([
+            ':operation_id' => $oldOperationId,
+            ':sector_id' => $oldSectorId
+        ]);
+        $usersSectors = $stmt->fetchAll(PDO::FETCH_ASSOC);
+
+        if (empty($usersSectors)) {
+            return 0;
+        }
+
+        $count = 0;
+        foreach ($usersSectors as $us) {
+            // Vérifier que l'utilisateur existe dans le mapping
+            // (le mapping sert juste à vérifier que l'user a été migré)
+            if (!isset($userMapping[$us['fk_user']])) {
+                $this->logger->warning("  ⚠ User {$us['fk_user']} non trouvé dans mapping");
+                continue;
+            }
+
+            $stmt = $this->targetDb->prepare("
+                INSERT INTO ope_users_sectors (
+                    fk_operation, fk_user, fk_sector,
+                    created_at, fk_user_creat, updated_at, fk_user_modif, chk_active
+                ) VALUES (
+                    :fk_operation, :fk_user, :fk_sector,
+                    :created_at, :fk_user_creat, :updated_at, :fk_user_modif, :chk_active
+                )
+            ");
+
+            $stmt->execute([
+                ':fk_operation' => $newOperationId,
+                ':fk_user' => $userMapping[$us['fk_user']], // ID de ope_users (mapping)
+                ':fk_sector' => $newOpeSectorId,
+                ':created_at' => date('Y-m-d H:i:s'),
+                ':fk_user_creat' => 0,
+                ':updated_at' => null,
+                ':fk_user_modif' => null,
+                ':chk_active' => $us['active']
+            ]);
+
+            $count++;
+        }
+
+        $this->logger->success("  ✓ {$count} association(s) user-secteur migrée(s)");
+
+        return $count;
+    }
+
+    /**
+     * Retourne le mapping des secteurs
+     *
+     * @return array "operationId_sectorId" => newOpeSectorId
+     */
+    public function getSectorMapping(): array
+    {
+        return $this->sectorMapping;
+    }
+
+    /**
+     * Définit le mapping des secteurs (utile pour réutilisation)
+     *
+     * @param array $mapping "operationId_sectorId" => newOpeSectorId
+     */
+    public function setSectorMapping(array $mapping): void
+    {
+        $this->sectorMapping = $mapping;
+    }
+}

api/scripts/migration2/php/lib/UserMigrator.php

@@ -0,0 +1,163 @@
+<?php
+
+/**
+ * Migration des utilisateurs d'opérations (ope_users)
+ *
+ * Gère la création des utilisateurs par opération et le mapping
+ * oldUserId (users.rowid) → newOpeUserId (ope_users.id)
+ */
+class UserMigrator
+{
+    private PDO $sourceDb;
+    private PDO $targetDb;
+    private MigrationLogger $logger;
+    private array $userMapping = [];
+
+    /**
+     * Constructeur
+     *
+     * @param PDO $sourceDb Connexion source
+     * @param PDO $targetDb Connexion cible
+     * @param MigrationLogger $logger Logger
+     */
+    public function __construct(PDO $sourceDb, PDO $targetDb, MigrationLogger $logger)
+    {
+        $this->sourceDb = $sourceDb;
+        $this->targetDb = $targetDb;
+        $this->logger = $logger;
+    }
+
+    /**
+     * Migre les utilisateurs d'une opération
+     * - Si opération active : TOUS les users actifs de l'entité
+     * - Si opération inactive : Uniquement ceux dans ope_users_sectors
+     *
+     * @param int $oldOperationId ID ancienne opération
+     * @param int $newOperationId ID nouvelle opération
+     * @param int $entityId ID de l'entité
+     * @param bool $isActiveOperation True si opération active
+     * @return array ['mapping' => array, 'count' => int]
+     */
+    public function migrateOperationUsers(
+        int $oldOperationId,
+        int $newOperationId,
+        int $entityId,
+        bool $isActiveOperation
+    ): array {
+        $this->logger->info("👥 Migration des utilisateurs de l'opération...");
+
+        // Réinitialiser le mapping pour cette opération
+        $this->userMapping = [];
+
+        // Récupérer les utilisateurs selon le type d'opération
+        if ($isActiveOperation) {
+            // Pour l'opération active : TOUS les users actifs de l'entité
+            $this->logger->info("  ℹ Opération ACTIVE : migration de tous les users actifs de l'entité");
+            $stmt = $this->sourceDb->prepare("
+                SELECT rowid
+                FROM users
+                WHERE fk_entite = :entity_id AND active = 1
+            ");
+            $stmt->execute([':entity_id' => $entityId]);
+            $userIds = $stmt->fetchAll(PDO::FETCH_COLUMN);
+        } else {
+            // Pour les opérations inactives : uniquement ceux dans ope_users_sectors
+            $this->logger->info("  ℹ Opération INACTIVE : migration des users affectés aux secteurs");
+            $stmt = $this->sourceDb->prepare("
+                SELECT DISTINCT fk_user
+                FROM ope_users_sectors
+                WHERE fk_operation = :operation_id AND active = 1
+            ");
+            $stmt->execute([':operation_id' => $oldOperationId]);
+            $userIds = $stmt->fetchAll(PDO::FETCH_COLUMN);
+        }
+
+        if (empty($userIds)) {
+            $this->logger->warning("Aucun utilisateur trouvé pour l'opération {$oldOperationId}");
+            return ['mapping' => [], 'count' => 0];
+        }
+
+        $count = 0;
+        foreach ($userIds as $oldUserId) {
+            // Récupérer les infos utilisateur depuis la table users
+            $stmt = $this->sourceDb->prepare("
+                SELECT * FROM users WHERE rowid = :id AND active = 1
+            ");
+            $stmt->execute([':id' => $oldUserId]);
+            $user = $stmt->fetch(PDO::FETCH_ASSOC);
+
+            if (!$user) {
+                $this->logger->warning("  ⚠ Utilisateur {$oldUserId} non trouvé ou inactif");
+                continue;
+            }
+
+            // Créer dans ope_users de la nouvelle base
+            $stmt = $this->targetDb->prepare("
+                INSERT INTO ope_users (
+                    fk_operation, fk_user, fk_role,
+                    first_name, encrypted_name, sect_name,
+                    created_at, fk_user_creat, updated_at, fk_user_modif, chk_active
+                ) VALUES (
+                    :fk_operation, :fk_user, :fk_role,
+                    :first_name, :encrypted_name, :sect_name,
+                    :created_at, :fk_user_creat, :updated_at, :fk_user_modif, :chk_active
+                )
+            ");
+
+            $stmt->execute([
+                ':fk_operation' => $newOperationId,
+                ':fk_user' => $oldUserId, // Référence vers users.id
+                ':fk_role' => $user['fk_role'],
+                ':first_name' => $user['prenom'],
+                ':encrypted_name' => ApiService::encryptData($user['libelle']), // Chiffrer le nom avec IV aléatoire
+                ':sect_name' => $user['nom_tournee'],
+                ':created_at' => $user['date_creat'],
+                ':fk_user_creat' => $user['fk_user_creat'],
+                ':updated_at' => $user['date_modif'],
+                ':fk_user_modif' => $user['fk_user_modif'],
+                ':chk_active' => $user['active']
+            ]);
+
+            $newOpeUserId = (int)$this->targetDb->lastInsertId();
+
+            // Mapper oldUserId → newOpeUserId
+            $this->userMapping[$oldUserId] = $newOpeUserId;
+            $count++;
+        }
+
+        $this->logger->success("  ✓ {$count} utilisateur(s) migré(s)");
+
+        return ['mapping' => $this->userMapping, 'count' => $count];
+    }
+
+    /**
+     * Retourne le mapping des utilisateurs
+     *
+     * @return array oldUserId => newOpeUserId
+     */
+    public function getUserMapping(): array
+    {
+        return $this->userMapping;
+    }
+
+    /**
+     * Définit le mapping des utilisateurs (utile pour réutilisation)
+     *
+     * @param array $mapping oldUserId => newOpeUserId
+     */
+    public function setUserMapping(array $mapping): void
+    {
+        $this->userMapping = $mapping;
+    }
+
+    /**
+     * Récupère le nouvel ID ope_users depuis le mapping
+     *
+     * @param int $oldUserId ID ancien utilisateur
+     * @return int|null Nouvel ID ope_users ou null si non trouvé
+     */
+    public function getMappedUserId(int $oldUserId): ?int
+    {
+        return $this->userMapping[$oldUserId] ?? null;
+    }
+}