Ajout du dossier api avec la géolocalisation automatique des casernes de pompiers
This commit is contained in:
d6soft
35
api/scripts/php/MigrationConfig.php
Normal file
35
api/scripts/php/MigrationConfig.php
Normal file
@@ -0,0 +1,35 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* Configuration simplifiée pour les scripts de migration
|
||||
* Fournit les clés de chiffrement et autres paramètres nécessaires
|
||||
* sans dépendre des en-têtes HTTP
|
||||
*/
|
||||
class AppConfig {
|
||||
private static ?self $instance = null;
|
||||
|
||||
// Configuration spécifique pour la migration
|
||||
private array $config = [
|
||||
'encryption_key' => 'Qga2M8Ov6tyx2fIQRWHQ1U6oMK/bAFdTL7A8VRtiDhk=', // Clé de GeoSector
|
||||
'app_identifier' => 'geosector', // Identifiant de l'application
|
||||
];
|
||||
|
||||
private function __construct() {
|
||||
// Constructeur simplifié sans validation d'application
|
||||
}
|
||||
|
||||
public static function getInstance(): self {
|
||||
if (self::$instance === null) {
|
||||
self::$instance = new self();
|
||||
}
|
||||
return self::$instance;
|
||||
}
|
||||
|
||||
public function getEncryptionKey(): string {
|
||||
return $this->config['encryption_key'];
|
||||
}
|
||||
|
||||
public function getAppIdentifier(): string {
|
||||
return $this->config['app_identifier'];
|
||||
}
|
||||
}
|
||||
357
api/scripts/php/migrate.php
Normal file
357
api/scripts/php/migrate.php
Normal file
@@ -0,0 +1,357 @@
|
||||
<?php
|
||||
/**
|
||||
* Script de migration générique pour transférer des données entre les bases geosector et geosector_app
|
||||
*
|
||||
* Usage:
|
||||
* php migrate.php - Exécute toutes les migrations dans l'ordre
|
||||
* php migrate.php <table_name> - Exécute la migration pour une table spécifique
|
||||
*
|
||||
* Options:
|
||||
* --truncate Vide la table cible avant la migration
|
||||
* --create-table Crée la table cible si elle n'existe pas
|
||||
* --help Affiche l'aide
|
||||
*/
|
||||
|
||||
require_once dirname(__DIR__) . '/config.php';
|
||||
|
||||
// Définition des mappages de colonnes pour chaque table
|
||||
$tableMappings = [
|
||||
'x_devises' => [
|
||||
'source_to_target' => [
|
||||
'rowid' => 'id',
|
||||
'active' => 'chk_active'
|
||||
],
|
||||
'primary_key' => 'rowid', // Clé primaire dans la table source
|
||||
'target_primary_key' => 'id' // Clé primaire dans la table cible
|
||||
],
|
||||
'users' => [
|
||||
'source_to_target' => [
|
||||
'id' => 'id',
|
||||
'user_pass_hash' => 'password_hash',
|
||||
'encrypted_user_name' => 'encrypted_last_name',
|
||||
'lang' => 'preferred_language',
|
||||
'chk_active' => 'is_active'
|
||||
],
|
||||
'primary_key' => 'id',
|
||||
'target_primary_key' => 'id',
|
||||
'encrypted_fields' => [
|
||||
'email' => ['field' => 'encrypted_email', 'searchable' => true],
|
||||
'user_name' => ['field' => 'encrypted_last_name', 'searchable' => false],
|
||||
'phone' => ['field' => 'encrypted_phone', 'searchable' => false],
|
||||
'mobile' => ['field' => 'encrypted_mobile', 'searchable' => false]
|
||||
]
|
||||
],
|
||||
// Ajoutez d'autres tables selon les besoins
|
||||
];
|
||||
|
||||
// Fonction pour afficher l'aide
|
||||
function showHelp() {
|
||||
echo "Usage: php migrate.php <table_name> [--truncate] [--create-table]\n";
|
||||
echo "\nOptions disponibles:\n";
|
||||
echo " --truncate Vide la table cible avant la migration\n";
|
||||
echo " --create-table Crée la table cible si elle n'existe pas\n";
|
||||
echo " --help Affiche cette aide\n";
|
||||
echo "\nTables disponibles:\n";
|
||||
|
||||
global $tableMappings;
|
||||
foreach (array_keys($tableMappings) as $table) {
|
||||
echo " - $table\n";
|
||||
}
|
||||
|
||||
exit(0);
|
||||
}
|
||||
|
||||
// Définition des scripts de migration disponibles dans l'ordre d'exécution
|
||||
$migrationScripts = [
|
||||
'x_devises' => __DIR__ . '/migrate_x_devises.php',
|
||||
'x_entites_types' => __DIR__ . '/migrate_x_entites_types.php',
|
||||
'x_types_passages' => __DIR__ . '/migrate_x_types_passages.php',
|
||||
'x_types_reglements' => __DIR__ . '/migrate_x_types_reglements.php',
|
||||
'x_users_roles' => __DIR__ . '/migrate_x_users_roles.php',
|
||||
'x_pays' => __DIR__ . '/migrate_x_pays.php',
|
||||
'x_regions' => __DIR__ . '/migrate_x_regions.php',
|
||||
'x_departements' => __DIR__ . '/migrate_x_departements.php',
|
||||
'x_villes' => __DIR__ . '/migrate_x_villes.php',
|
||||
'entites' => __DIR__ . '/migrate_entites.php',
|
||||
'users' => __DIR__ . '/migrate_users.php',
|
||||
'operations' => __DIR__ . '/migrate_operations.php',
|
||||
'ope_sectors' => __DIR__ . '/migrate_ope_sectors.php',
|
||||
'sectors_adresses' => __DIR__ . '/migrate_sectors_adresses.php',
|
||||
'ope_users' => __DIR__ . '/migrate_ope_users.php',
|
||||
'ope_users_sectors' => __DIR__ . '/migrate_ope_users_sectors.php',
|
||||
'ope_pass' => __DIR__ . '/migrate_ope_pass.php',
|
||||
'ope_pass_histo' => __DIR__ . '/migrate_ope_pass_histo.php',
|
||||
'medias' => __DIR__ . '/migrate_medias.php'
|
||||
// Ajoutez d'autres scripts de migration au fur et à mesure
|
||||
];
|
||||
|
||||
// Fonction pour exécuter un script de migration spécifique
|
||||
function executeMigrationScript($scriptPath) {
|
||||
echo "\nExécution du script: " . basename($scriptPath) . "\n";
|
||||
echo "------------------------------------------------\n";
|
||||
|
||||
// Exécuter le script PHP
|
||||
include $scriptPath;
|
||||
|
||||
echo "\n";
|
||||
return true;
|
||||
}
|
||||
|
||||
// Traitement des arguments de ligne de commande
|
||||
$tableName = null;
|
||||
$truncateTable = false;
|
||||
$createTable = false;
|
||||
$runAllScripts = true;
|
||||
|
||||
for ($i = 1; $i < $_SERVER['argc']; $i++) {
|
||||
$arg = $_SERVER['argv'][$i];
|
||||
|
||||
if ($arg === '--help') {
|
||||
showHelp();
|
||||
} elseif ($arg === '--truncate') {
|
||||
$truncateTable = true;
|
||||
} elseif ($arg === '--create-table') {
|
||||
$createTable = true;
|
||||
} elseif (substr($arg, 0, 2) !== '--') {
|
||||
$tableName = $arg;
|
||||
$runAllScripts = false;
|
||||
}
|
||||
}
|
||||
|
||||
// Si aucune table n'est spécifiée, exécuter tous les scripts de migration dans l'ordre
|
||||
if ($runAllScripts) {
|
||||
echo "\nDémarrage de la migration complète de la base de données\n";
|
||||
echo "=======================================================\n";
|
||||
|
||||
$startTime = microtime(true);
|
||||
$successCount = 0;
|
||||
$failCount = 0;
|
||||
|
||||
foreach ($migrationScripts as $table => $scriptPath) {
|
||||
if (file_exists($scriptPath)) {
|
||||
try {
|
||||
executeMigrationScript($scriptPath);
|
||||
$successCount++;
|
||||
} catch (Exception $e) {
|
||||
echo "\nErreur lors de la migration de la table $table: " . $e->getMessage() . "\n";
|
||||
$failCount++;
|
||||
}
|
||||
} else {
|
||||
echo "\nScript de migration introuvable pour la table $table: $scriptPath\n";
|
||||
$failCount++;
|
||||
}
|
||||
}
|
||||
|
||||
$endTime = microtime(true);
|
||||
$executionTime = round($endTime - $startTime, 2);
|
||||
|
||||
echo "\n=======================================================\n";
|
||||
echo "Migration terminée en $executionTime secondes\n";
|
||||
echo "Tables migrées avec succès: $successCount\n";
|
||||
echo "Tables en échec: $failCount\n";
|
||||
|
||||
exit(0);
|
||||
}
|
||||
|
||||
// Si une table spécifique est demandée, vérifier si un script dédié existe
|
||||
if (isset($migrationScripts[$tableName])) {
|
||||
$scriptPath = $migrationScripts[$tableName];
|
||||
if (file_exists($scriptPath)) {
|
||||
executeMigrationScript($scriptPath);
|
||||
exit(0);
|
||||
}
|
||||
}
|
||||
|
||||
// Sinon, utiliser la méthode générique de migration (code existant)
|
||||
if (!isset($tableMappings[$tableName])) {
|
||||
echo "Erreur: La table '$tableName' n'est pas configurée pour la migration.\n";
|
||||
echo "Tables disponibles: " . implode(', ', array_keys($tableMappings)) . "\n";
|
||||
exit(1);
|
||||
}
|
||||
|
||||
// Création du dossier de logs si nécessaire
|
||||
if (!is_dir(dirname(__DIR__) . '/logs')) {
|
||||
mkdir(dirname(__DIR__) . '/logs', 0755, true);
|
||||
}
|
||||
|
||||
logOperation("Démarrage de la migration de la table $tableName");
|
||||
|
||||
try {
|
||||
// Connexion aux bases de données
|
||||
$sourceDb = getSourceConnection();
|
||||
$targetDb = getTargetConnection();
|
||||
|
||||
// Obtenir le service API pour le chiffrement si nécessaire
|
||||
$apiService = null;
|
||||
if (isset($tableMappings[$tableName]['encrypted_fields'])) {
|
||||
$container = $GLOBALS['container'];
|
||||
$apiService = $container->get('ApiService');
|
||||
}
|
||||
|
||||
// Récupération des données de la source
|
||||
$stmt = $sourceDb->query("SELECT * FROM $tableName");
|
||||
$records = $stmt->fetchAll();
|
||||
|
||||
logOperation("Nombre d'enregistrements à migrer: " . count($records));
|
||||
|
||||
// Vérifier si la table existe dans la cible
|
||||
try {
|
||||
$targetDb->query("SELECT 1 FROM $tableName LIMIT 1");
|
||||
$tableExists = true;
|
||||
} catch (PDOException $e) {
|
||||
$tableExists = false;
|
||||
}
|
||||
|
||||
// Créer la table si elle n'existe pas et si l'option est activée
|
||||
if (!$tableExists && $createTable) {
|
||||
logOperation("La table $tableName n'existe pas dans la base cible. Création de la table...");
|
||||
|
||||
// Récupérer la structure de la table source
|
||||
$stmt = $sourceDb->query("SHOW CREATE TABLE $tableName");
|
||||
$tableStructure = $stmt->fetch(PDO::FETCH_ASSOC);
|
||||
|
||||
if (isset($tableStructure['Create Table'])) {
|
||||
$createTableSql = $tableStructure['Create Table'];
|
||||
|
||||
// Adapter les noms de colonnes selon le mapping
|
||||
$mapping = $tableMappings[$tableName]['source_to_target'];
|
||||
foreach ($mapping as $sourceCol => $targetCol) {
|
||||
$createTableSql = str_replace("`$sourceCol`", "`$targetCol`", $createTableSql);
|
||||
}
|
||||
|
||||
// Remplacer le nom de la clé primaire si nécessaire
|
||||
$sourcePk = $tableMappings[$tableName]['primary_key'];
|
||||
$targetPk = $tableMappings[$tableName]['target_primary_key'];
|
||||
if ($sourcePk !== $targetPk) {
|
||||
$createTableSql = str_replace("PRIMARY KEY (`$sourcePk`)", "PRIMARY KEY (`$targetPk`)", $createTableSql);
|
||||
}
|
||||
|
||||
// Créer la table
|
||||
$targetDb->exec($createTableSql);
|
||||
logOperation("Table $tableName créée avec succès");
|
||||
} else {
|
||||
throw new Exception("Impossible de récupérer la structure de la table source");
|
||||
}
|
||||
}
|
||||
|
||||
// Vider la table cible si l'option est activée
|
||||
if ($truncateTable && $tableExists) {
|
||||
logOperation("Vidage de la table cible $tableName...");
|
||||
$targetDb->exec("TRUNCATE TABLE $tableName");
|
||||
}
|
||||
|
||||
// Construire la requête d'insertion dynamiquement
|
||||
$mapping = $tableMappings[$tableName]['source_to_target'];
|
||||
|
||||
// Récupérer les colonnes de la table cible
|
||||
$stmt = $targetDb->query("DESCRIBE $tableName");
|
||||
$targetColumns = $stmt->fetchAll(PDO::FETCH_COLUMN);
|
||||
|
||||
// Construire les listes de colonnes pour l'insertion
|
||||
$insertColumns = [];
|
||||
$insertPlaceholders = [];
|
||||
$updateClauses = [];
|
||||
|
||||
foreach ($targetColumns as $column) {
|
||||
$insertColumns[] = "`$column`";
|
||||
$insertPlaceholders[] = ":$column";
|
||||
$updateClauses[] = "`$column` = VALUES(`$column`)";
|
||||
}
|
||||
|
||||
$insertColumnsSql = implode(", ", $insertColumns);
|
||||
$insertPlaceholdersSql = implode(", ", $insertPlaceholders);
|
||||
$updateClausesSql = implode(", ", $updateClauses);
|
||||
|
||||
$insertQuery = "INSERT INTO $tableName ($insertColumnsSql) "
|
||||
. "VALUES ($insertPlaceholdersSql) "
|
||||
. "ON DUPLICATE KEY UPDATE $updateClausesSql";
|
||||
|
||||
$insertStmt = $targetDb->prepare($insertQuery);
|
||||
|
||||
// Compteurs
|
||||
$successCount = 0;
|
||||
$errorCount = 0;
|
||||
|
||||
// Traitement de chaque enregistrement
|
||||
foreach ($records as $record) {
|
||||
try {
|
||||
$data = [];
|
||||
|
||||
// Mappage des colonnes selon la configuration
|
||||
foreach ($targetColumns as $targetCol) {
|
||||
// Trouver la colonne source correspondante
|
||||
$sourceCol = array_search($targetCol, $mapping);
|
||||
|
||||
if ($sourceCol !== false) {
|
||||
// La colonne existe dans le mapping
|
||||
$data[$targetCol] = $record[$sourceCol];
|
||||
} elseif (isset($record[$targetCol])) {
|
||||
// La colonne a le même nom dans les deux tables
|
||||
$data[$targetCol] = $record[$targetCol];
|
||||
} else {
|
||||
// Colonne non trouvée, utiliser NULL ou une valeur par défaut
|
||||
$data[$targetCol] = null;
|
||||
}
|
||||
}
|
||||
|
||||
// Traitement des champs chiffrés si nécessaire
|
||||
if (isset($tableMappings[$tableName]['encrypted_fields']) && $apiService) {
|
||||
foreach ($tableMappings[$tableName]['encrypted_fields'] as $sourceField => $config) {
|
||||
$targetField = $config['field'];
|
||||
$isSearchable = $config['searchable'];
|
||||
|
||||
if (isset($record[$sourceField]) && !empty($record[$sourceField])) {
|
||||
// Vérifier si le champ est déjà chiffré
|
||||
if (isset($record["encrypted_$sourceField"])) {
|
||||
$data[$targetField] = $record["encrypted_$sourceField"];
|
||||
} else {
|
||||
// Chiffrer la donnée selon qu'elle est recherchable ou non
|
||||
if ($isSearchable) {
|
||||
$data[$targetField] = $apiService->encryptSearchableData($record[$sourceField]);
|
||||
} else {
|
||||
$data[$targetField] = $apiService->encryptData($record[$sourceField]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Gestion spécifique pour certaines tables
|
||||
if ($tableName === 'users') {
|
||||
// Conversion de chk_active (0,1,2) vers is_active (booléen)
|
||||
if (isset($record['chk_active'])) {
|
||||
$data['is_active'] = ($record['chk_active'] > 0) ? 1 : 0;
|
||||
}
|
||||
}
|
||||
|
||||
// Insertion dans la base cible
|
||||
$insertStmt->execute($data);
|
||||
$successCount++;
|
||||
|
||||
// Identifiant pour le log
|
||||
$pkField = $tableMappings[$tableName]['primary_key'];
|
||||
$recordId = $record[$pkField] ?? 'inconnu';
|
||||
|
||||
logOperation("Enregistrement ID $recordId migré avec succès", "INFO");
|
||||
} catch (Exception $e) {
|
||||
$errorCount++;
|
||||
$pkField = $tableMappings[$tableName]['primary_key'];
|
||||
$recordId = $record[$pkField] ?? 'inconnu';
|
||||
|
||||
logOperation("Erreur lors de la migration de l'enregistrement ID $recordId: " . $e->getMessage(), "ERROR");
|
||||
}
|
||||
}
|
||||
|
||||
logOperation("Migration terminée. Succès: $successCount, Erreurs: $errorCount");
|
||||
|
||||
// Fermer le tunnel SSH
|
||||
closeSshTunnel();
|
||||
|
||||
} catch (Exception $e) {
|
||||
logOperation("Erreur critique: " . $e->getMessage(), "ERROR");
|
||||
|
||||
// Fermer le tunnel SSH en cas d'erreur
|
||||
closeSshTunnel();
|
||||
|
||||
exit(1);
|
||||
}
|
||||
201
api/scripts/php/migrate_entites.php
Normal file
201
api/scripts/php/migrate_entites.php
Normal file
@@ -0,0 +1,201 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* Script de migration pour la table entites (users_entites → entites)
|
||||
* Transfert les données de la base source (geosector) vers la base cible (geosector_app)
|
||||
* Gère le chiffrement des données sensibles
|
||||
*/
|
||||
|
||||
require_once dirname(__DIR__) . '/config.php';
|
||||
require_once __DIR__ . '/MigrationConfig.php';
|
||||
require_once dirname(dirname(__DIR__)) . '/src/Services/ApiService.php';
|
||||
|
||||
try {
|
||||
// Création du tunnel SSH si nécessaire
|
||||
createSshTunnel();
|
||||
|
||||
// Connexion aux bases de données
|
||||
$sourceDb = getSourceConnection();
|
||||
$targetDb = getTargetConnection();
|
||||
|
||||
// Utilisation directe de la classe ApiService pour le chiffrement
|
||||
|
||||
// Récupération des entités depuis la base source
|
||||
$stmt = $sourceDb->query("SELECT * FROM users_entites");
|
||||
$entites = $stmt->fetchAll(PDO::FETCH_ASSOC);
|
||||
|
||||
echo "Nombre d'entités à migrer: " . count($entites) . PHP_EOL;
|
||||
|
||||
// Préparation de la requête d'insertion
|
||||
$insertQuery = "INSERT INTO entites (
|
||||
id,
|
||||
encrypted_name,
|
||||
adresse1,
|
||||
adresse2,
|
||||
code_postal,
|
||||
ville,
|
||||
fk_region,
|
||||
fk_type,
|
||||
encrypted_phone,
|
||||
encrypted_mobile,
|
||||
encrypted_email,
|
||||
gps_lat,
|
||||
gps_lng,
|
||||
encrypted_iban,
|
||||
encrypted_bic,
|
||||
chk_demo,
|
||||
chk_mdp_manuel,
|
||||
chk_copie_mail_recu,
|
||||
chk_accept_sms,
|
||||
fk_user_creat,
|
||||
fk_user_modif,
|
||||
chk_active
|
||||
) VALUES (
|
||||
:id,
|
||||
:encrypted_name,
|
||||
:adresse1,
|
||||
:adresse2,
|
||||
:code_postal,
|
||||
:ville,
|
||||
:fk_region,
|
||||
:fk_type,
|
||||
:encrypted_phone,
|
||||
:encrypted_mobile,
|
||||
:encrypted_email,
|
||||
:gps_lat,
|
||||
:gps_lng,
|
||||
:encrypted_iban,
|
||||
:encrypted_bic,
|
||||
:chk_demo,
|
||||
:chk_mdp_manuel,
|
||||
:chk_copie_mail_recu,
|
||||
:chk_accept_sms,
|
||||
:fk_user_creat,
|
||||
:fk_user_modif,
|
||||
:chk_active
|
||||
) ON DUPLICATE KEY UPDATE
|
||||
encrypted_name = VALUES(encrypted_name),
|
||||
adresse1 = VALUES(adresse1),
|
||||
adresse2 = VALUES(adresse2),
|
||||
code_postal = VALUES(code_postal),
|
||||
ville = VALUES(ville),
|
||||
fk_region = VALUES(fk_region),
|
||||
fk_type = VALUES(fk_type),
|
||||
encrypted_phone = VALUES(encrypted_phone),
|
||||
encrypted_mobile = VALUES(encrypted_mobile),
|
||||
encrypted_email = VALUES(encrypted_email),
|
||||
gps_lat = VALUES(gps_lat),
|
||||
gps_lng = VALUES(gps_lng),
|
||||
encrypted_iban = VALUES(encrypted_iban),
|
||||
encrypted_bic = VALUES(encrypted_bic),
|
||||
chk_demo = VALUES(chk_demo),
|
||||
chk_mdp_manuel = VALUES(chk_mdp_manuel),
|
||||
chk_copie_mail_recu = VALUES(chk_copie_mail_recu),
|
||||
chk_accept_sms = VALUES(chk_accept_sms),
|
||||
fk_user_modif = VALUES(fk_user_modif),
|
||||
chk_active = VALUES(chk_active)";
|
||||
|
||||
$insertStmt = $targetDb->prepare($insertQuery);
|
||||
|
||||
// Compteurs
|
||||
$successCount = 0;
|
||||
$errorCount = 0;
|
||||
|
||||
// Traitement de chaque entité
|
||||
foreach ($entites as $entite) {
|
||||
try {
|
||||
// Mappage des champs entre les deux structures
|
||||
$id = isset($entite['rowid']) ? $entite['rowid'] : $entite['id'];
|
||||
$chkActive = isset($entite['active']) ? $entite['active'] : (isset($entite['chk_active']) ? $entite['chk_active'] : 1);
|
||||
|
||||
// Chiffrement des données sensibles (uniquement si non vides)
|
||||
$libelle = $entite['libelle'] ?? '';
|
||||
$encryptedName = !empty($libelle) ? ApiService::encryptData($libelle) : '';
|
||||
|
||||
// Traitement des numéros de téléphone
|
||||
$tel1 = $entite['tel1'] ?? '';
|
||||
$tel2 = $entite['tel2'] ?? '';
|
||||
|
||||
// Initialisation des variables
|
||||
$encryptedPhone = '';
|
||||
$encryptedMobile = '';
|
||||
|
||||
// Vérification si tel1 commence par 06 ou 07 (mobile)
|
||||
if (preg_match('/^0[67]/', $tel1)) {
|
||||
$encryptedMobile = ApiService::encryptData($tel1);
|
||||
} elseif (!empty($tel1)) {
|
||||
$encryptedPhone = ApiService::encryptData($tel1);
|
||||
}
|
||||
|
||||
// Vérification si tel2 commence par 06 ou 07 (mobile)
|
||||
if (preg_match('/^0[67]/', $tel2)) {
|
||||
// Si encryptedMobile est déjà rempli, on garde le premier mobile trouvé
|
||||
if (empty($encryptedMobile)) {
|
||||
$encryptedMobile = ApiService::encryptData($tel2);
|
||||
} elseif (empty($encryptedPhone)) {
|
||||
// Si on a déjà un mobile mais pas de téléphone fixe, on met le second mobile comme téléphone
|
||||
$encryptedPhone = ApiService::encryptData($tel2);
|
||||
}
|
||||
} elseif (!empty($tel2)) {
|
||||
// Si encryptedPhone est déjà rempli, on garde le premier fixe trouvé
|
||||
if (empty($encryptedPhone)) {
|
||||
$encryptedPhone = ApiService::encryptData($tel2);
|
||||
}
|
||||
}
|
||||
|
||||
// Chiffrement des autres données sensibles (uniquement si non vides)
|
||||
$email = $entite['email'] ?? '';
|
||||
$iban = $entite['iban'] ?? '';
|
||||
$bic = $entite['bic'] ?? '';
|
||||
|
||||
$encryptedEmail = !empty($email) ? ApiService::encryptSearchableData($email) : '';
|
||||
$encryptedIban = !empty($iban) ? ApiService::encryptData($iban) : '';
|
||||
$encryptedBic = !empty($bic) ? ApiService::encryptData($bic) : '';
|
||||
|
||||
// Préparation des données pour l'insertion
|
||||
$entiteData = [
|
||||
'id' => $id,
|
||||
'encrypted_name' => $encryptedName,
|
||||
'adresse1' => $entite['adresse1'] ?? '',
|
||||
'adresse2' => $entite['adresse2'] ?? '',
|
||||
'code_postal' => $entite['cp'] ?? '',
|
||||
'ville' => $entite['ville'] ?? '',
|
||||
'fk_region' => $entite['fk_region'] ?? null,
|
||||
'fk_type' => $entite['fk_type'] ?? 1,
|
||||
'encrypted_phone' => $encryptedPhone,
|
||||
'encrypted_mobile' => $encryptedMobile,
|
||||
'encrypted_email' => $encryptedEmail,
|
||||
'gps_lat' => $entite['gps_lat'] ?? '',
|
||||
'gps_lng' => $entite['gps_lng'] ?? '',
|
||||
'encrypted_iban' => $encryptedIban,
|
||||
'encrypted_bic' => $encryptedBic,
|
||||
'chk_demo' => 0, // Valeur par défaut à 0 comme demandé
|
||||
'chk_mdp_manuel' => $entite['chk_mdp_manuel'] ?? 1,
|
||||
'chk_copie_mail_recu' => $entite['chk_copie_mail_recu'] ?? 0,
|
||||
'chk_accept_sms' => $entite['chk_accept_sms'] ?? 0,
|
||||
'fk_user_creat' => $entite['fk_user_modif'] ?? null,
|
||||
'fk_user_modif' => $entite['fk_user_modif'] ?? null,
|
||||
'chk_active' => $chkActive
|
||||
];
|
||||
|
||||
// Insertion dans la base cible
|
||||
$insertStmt->execute($entiteData);
|
||||
$successCount++;
|
||||
} catch (Exception $e) {
|
||||
$errorCount++;
|
||||
echo "Erreur lors de la migration de l'entité ID {$id}: " . $e->getMessage() . PHP_EOL;
|
||||
}
|
||||
}
|
||||
|
||||
echo "Migration terminée. Succès: $successCount, Erreurs: $errorCount" . PHP_EOL;
|
||||
|
||||
// Fermer le tunnel SSH
|
||||
closeSshTunnel();
|
||||
} catch (Exception $e) {
|
||||
echo "Erreur critique: " . $e->getMessage() . PHP_EOL;
|
||||
|
||||
// Fermer le tunnel SSH en cas d'erreur
|
||||
closeSshTunnel();
|
||||
|
||||
exit(1);
|
||||
}
|
||||
123
api/scripts/php/migrate_medias.php
Normal file
123
api/scripts/php/migrate_medias.php
Normal file
@@ -0,0 +1,123 @@
|
||||
<?php
|
||||
/**
|
||||
* Script de migration de la table medias
|
||||
* Ce script migre les médias en tenant compte des changements de structure
|
||||
* et de la transformation de support_rowid en support_id
|
||||
*/
|
||||
|
||||
// Inclusion des fichiers nécessaires
|
||||
require_once __DIR__ . '/../config.php';
|
||||
|
||||
// Fonction principale de migration
|
||||
try {
|
||||
// Établissement des connexions aux bases de données
|
||||
$sourceDb = getSourceConnection();
|
||||
$targetDb = getTargetConnection();
|
||||
|
||||
// Début de la migration silencieuse (n'affiche que les erreurs)
|
||||
|
||||
// Suppression de toutes les données existantes dans la table medias
|
||||
$deleteQuery = "DELETE FROM medias";
|
||||
$targetDb->exec($deleteQuery);
|
||||
|
||||
// Récupération des IDs des utilisateurs qui ont été migrés
|
||||
$stmt = $targetDb->query("SELECT id FROM users");
|
||||
$migratedUsers = $stmt->fetchAll(PDO::FETCH_COLUMN);
|
||||
|
||||
if (empty($migratedUsers)) {
|
||||
echo "ERREUR: Aucun utilisateur n'a été migré. Veuillez d'abord migrer la table users." . PHP_EOL;
|
||||
closeSshTunnel();
|
||||
exit(1);
|
||||
}
|
||||
|
||||
// Récupération des médias depuis la source
|
||||
$query = "SELECT * FROM medias";
|
||||
$stmt = $sourceDb->query($query);
|
||||
$medias = $stmt->fetchAll(PDO::FETCH_ASSOC);
|
||||
|
||||
// Préparation de la requête d'insertion
|
||||
$insertQuery = "INSERT INTO medias (
|
||||
support,
|
||||
support_id,
|
||||
fichier,
|
||||
description,
|
||||
created_at,
|
||||
fk_user_creat,
|
||||
updated_at,
|
||||
fk_user_modif
|
||||
) VALUES (
|
||||
:support,
|
||||
:support_id,
|
||||
:fichier,
|
||||
:description,
|
||||
:created_at,
|
||||
:fk_user_creat,
|
||||
:updated_at,
|
||||
:fk_user_modif
|
||||
)";
|
||||
|
||||
$insertStmt = $targetDb->prepare($insertQuery);
|
||||
|
||||
// Compteurs pour le suivi
|
||||
$inserted = 0;
|
||||
$skipped = 0;
|
||||
$errors = 0;
|
||||
|
||||
// Traitement de chaque média
|
||||
foreach ($medias as $media) {
|
||||
// Vérifier si l'utilisateur de création existe dans la table users de la cible
|
||||
$fkUserCreat = $media['fk_user_creat'] ?? 0;
|
||||
if ($fkUserCreat > 0 && !in_array($fkUserCreat, $migratedUsers)) {
|
||||
// L'utilisateur n'a pas été migré, on utilise 0 (système)
|
||||
$fkUserCreat = 0;
|
||||
}
|
||||
|
||||
// Vérifier si l'utilisateur de modification existe dans la table users de la cible
|
||||
$fkUserModif = $media['fk_user_modif'] ?? 0;
|
||||
if ($fkUserModif > 0 && !in_array($fkUserModif, $migratedUsers)) {
|
||||
// L'utilisateur n'a pas été migré, on utilise 0 (système)
|
||||
$fkUserModif = 0;
|
||||
}
|
||||
|
||||
// Conversion des dates
|
||||
$createdAt = !empty($media['date_creat']) ? date('Y-m-d H:i:s', strtotime($media['date_creat'])) : date('Y-m-d H:i:s');
|
||||
$updatedAt = !empty($media['date_modif']) ? date('Y-m-d H:i:s', strtotime($media['date_modif'])) : null;
|
||||
|
||||
// Préparation des données pour l'insertion
|
||||
$mediaData = [
|
||||
'support' => $media['support'] ?? '',
|
||||
'support_id' => $media['support_rowid'] ?? 0, // Transformation de support_rowid en support_id
|
||||
'fichier' => $media['fichier'] ?? '',
|
||||
'description' => $media['description'] ?? '',
|
||||
'created_at' => $createdAt,
|
||||
'fk_user_creat' => $fkUserCreat,
|
||||
'updated_at' => $updatedAt,
|
||||
'fk_user_modif' => $fkUserModif
|
||||
];
|
||||
|
||||
try {
|
||||
// Insertion dans la table cible
|
||||
$insertStmt->execute($mediaData);
|
||||
$inserted++;
|
||||
} catch (PDOException $e) {
|
||||
echo "ERREUR: Migration du média : " . $e->getMessage() . "\n";
|
||||
$errors++;
|
||||
}
|
||||
}
|
||||
|
||||
// Afficher uniquement s'il y a des erreurs
|
||||
if ($errors > 0) {
|
||||
echo "ERREUR: $errors erreurs lors de la migration de la table medias." . PHP_EOL;
|
||||
}
|
||||
|
||||
// Fermer le tunnel SSH
|
||||
closeSshTunnel();
|
||||
|
||||
} catch (Exception $e) {
|
||||
echo "ERREUR CRITIQUE: " . $e->getMessage() . PHP_EOL;
|
||||
|
||||
// Fermer le tunnel SSH en cas d'erreur
|
||||
closeSshTunnel();
|
||||
|
||||
exit(1);
|
||||
}
|
||||
586
api/scripts/php/migrate_ope_pass.php
Normal file
586
api/scripts/php/migrate_ope_pass.php
Normal file
@@ -0,0 +1,586 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* Script de migration pour la table ope_pass
|
||||
* Transfert les données depuis la table ope_pass de la base source vers la table ope_pass de la base cible
|
||||
* Ne migre que les passages liés aux opérations qui ont été migrées
|
||||
* Fait la correspondance entre les anciens secteurs (fk_old_sector) et les nouveaux secteurs (id) dans la table ope_sectors
|
||||
* Effectue les changements de champs demandés (date_eve=>passed_at, libelle=>encrypted_name, email=>encrypted_email, phone=>encrypted_phone)
|
||||
*/
|
||||
|
||||
require_once dirname(__DIR__) . '/config.php';
|
||||
require_once __DIR__ . '/MigrationConfig.php';
|
||||
require_once dirname(dirname(__DIR__)) . '/src/Services/ApiService.php';
|
||||
|
||||
try {
|
||||
// Vérifier si un processus utilise déjà le port du tunnel SSH
|
||||
echo "Vérification du port SSH..." . PHP_EOL;
|
||||
|
||||
// Création du tunnel SSH avec une meilleure gestion des erreurs
|
||||
try {
|
||||
// Tuer tout processus existant qui utilise le port 13306
|
||||
// Sous Linux/Mac
|
||||
@exec('kill $(lsof -t -i:13306) 2>/dev/null');
|
||||
// Attendre un moment pour s'assurer que le port est libéré
|
||||
sleep(1);
|
||||
|
||||
createSshTunnel();
|
||||
echo "Tunnel SSH créé avec succès." . PHP_EOL;
|
||||
} catch (Exception $e) {
|
||||
echo "ERREUR lors de la création du tunnel SSH: " . $e->getMessage() . PHP_EOL;
|
||||
exit(1);
|
||||
}
|
||||
|
||||
// Connexion aux bases de données avec paramètres pour éviter le timeout
|
||||
try {
|
||||
echo "Connexion à la base source..." . PHP_EOL;
|
||||
$sourceDb = getSourceConnection();
|
||||
echo "Connexion à la base source établie." . PHP_EOL;
|
||||
} catch (Exception $e) {
|
||||
echo "ERREUR de connexion à la base source: " . $e->getMessage() . PHP_EOL;
|
||||
closeSshTunnel();
|
||||
exit(1);
|
||||
}
|
||||
|
||||
// Configuration spéciale pour éviter les timeouts sur les grosses opérations
|
||||
try {
|
||||
echo "Connexion à la base cible..." . PHP_EOL;
|
||||
$targetDb = getTargetConnection();
|
||||
echo "Connexion à la base cible établie." . PHP_EOL;
|
||||
|
||||
// Configuration des timeouts adaptés à MariaDB 10.11
|
||||
$targetDb->setAttribute(PDO::ATTR_TIMEOUT, 600); // 10 minutes pour PDO
|
||||
|
||||
echo " - Configuration des timeouts pour MariaDB 10.11" . PHP_EOL;
|
||||
|
||||
// Configurations spécifiques à MariaDB 10.11
|
||||
$timeoutVars = [
|
||||
"wait_timeout" => 3600, // 1 heure
|
||||
"net_read_timeout" => 3600, // 1 heure
|
||||
"net_write_timeout" => 3600, // 1 heure
|
||||
"innodb_lock_wait_timeout" => 3600 // 1 heure
|
||||
];
|
||||
|
||||
// Configurer les variables de session
|
||||
foreach ($timeoutVars as $var => $value) {
|
||||
try {
|
||||
$sql = "SET SESSION $var=$value";
|
||||
$targetDb->exec($sql);
|
||||
echo " - Config MariaDB: $var = $value" . PHP_EOL;
|
||||
} catch (PDOException $e) {
|
||||
echo " - Impossible de configurer $var: " . $e->getMessage() . PHP_EOL;
|
||||
}
|
||||
}
|
||||
|
||||
echo "Paramètres de timeout configurés." . PHP_EOL;
|
||||
} catch (Exception $e) {
|
||||
echo "ERREUR de connexion à la base cible: " . $e->getMessage() . PHP_EOL;
|
||||
closeSshTunnel();
|
||||
exit(1);
|
||||
}
|
||||
|
||||
// Début de la migration
|
||||
|
||||
// Vérifions la version de la base de données cible (MariaDB)
|
||||
$versionTarget = $targetDb->query('SELECT VERSION() as version')->fetch();
|
||||
echo "Version de la base cible (MariaDB): " . $versionTarget['version'] . PHP_EOL;
|
||||
|
||||
// Vérifions la version de la base de données source (MySQL)
|
||||
$versionSource = $sourceDb->query('SELECT VERSION() as version')->fetch();
|
||||
echo "Version de la base source (MySQL): " . $versionSource['version'] . PHP_EOL;
|
||||
|
||||
// Note sur les privilèges de contraintes
|
||||
echo "NOTE: La suppression et recréation des contraintes nécessitent des privilèges SUPER ou ALTER TABLE." . PHP_EOL;
|
||||
echo " Ces opérations peuvent être ignorées si l'utilisateur n'a pas les privilèges suffisants." . PHP_EOL;
|
||||
echo " Il est recommandé d'exécuter ces opérations manuellement avec un utilisateur admin." . PHP_EOL;
|
||||
|
||||
// Suppression des contraintes relationnelles (tentatif)
|
||||
echo "Tentative de suppression des contraintes relationnelles... " . PHP_EOL;
|
||||
$dropConstraintsQueries = [
|
||||
"ALTER TABLE ope_pass DROP FOREIGN KEY ope_pass_ibfk_1",
|
||||
"ALTER TABLE ope_pass DROP FOREIGN KEY ope_pass_ibfk_2",
|
||||
"ALTER TABLE ope_pass DROP FOREIGN KEY ope_pass_ibfk_3",
|
||||
"ALTER TABLE ope_pass DROP FOREIGN KEY ope_pass_ibfk_4"
|
||||
];
|
||||
|
||||
$constraintDropFailed = false;
|
||||
foreach ($dropConstraintsQueries as $query) {
|
||||
try {
|
||||
$targetDb->exec($query);
|
||||
echo " - Contrainte supprimée avec succès : " . substr($query, 0, 60) . "..." . PHP_EOL;
|
||||
} catch (PDOException $e) {
|
||||
echo " - Erreur lors de la suppression de la contrainte : " . $e->getMessage() . PHP_EOL;
|
||||
$constraintDropFailed = true;
|
||||
}
|
||||
}
|
||||
|
||||
if ($constraintDropFailed) {
|
||||
echo "ATTENTION: Les contraintes n'ont pas pu être supprimées. La migration continue sans cette étape." . PHP_EOL;
|
||||
echo " Vous devrez peut-être désactiver les contraintes manuellement si la suppression échoue." . PHP_EOL;
|
||||
}
|
||||
|
||||
// Suppression de toutes les données existantes dans la table ope_pass par lots pour éviter les timeouts
|
||||
echo "Suppression des données existantes dans la table ope_pass (par lots)... " . PHP_EOL;
|
||||
|
||||
try {
|
||||
// Désactiver temporairement les vérifications de clés étrangères
|
||||
// Cela fonctionne à la fois dans MySQL et MariaDB
|
||||
try {
|
||||
$targetDb->exec("SET FOREIGN_KEY_CHECKS=0");
|
||||
echo " - Vérification des clés étrangères temporairement désactivée." . PHP_EOL;
|
||||
} catch (PDOException $e) {
|
||||
echo " - Erreur lors de la désactivation des clés étrangères: " . $e->getMessage() . PHP_EOL;
|
||||
}
|
||||
|
||||
// Suppression par lots
|
||||
$batchSize = 100000;
|
||||
$totalDeleted = 0;
|
||||
$continue = true;
|
||||
|
||||
echo " - Suppression par lots de $batchSize enregistrements:" . PHP_EOL;
|
||||
|
||||
while ($continue) {
|
||||
$deleteQuery = "DELETE FROM ope_pass LIMIT $batchSize";
|
||||
$rowCount = $targetDb->exec($deleteQuery);
|
||||
$totalDeleted += $rowCount;
|
||||
echo " * Lot supprimé: $rowCount enregistrements (Total: $totalDeleted)" . PHP_EOL;
|
||||
|
||||
// Vérifier si nous avons terminé
|
||||
if ($rowCount < $batchSize) {
|
||||
$continue = false;
|
||||
}
|
||||
|
||||
// Petit délai pour permettre des traitements serveur
|
||||
if ($continue) {
|
||||
usleep(100000); // 0.1 seconde
|
||||
}
|
||||
}
|
||||
|
||||
echo " - Total: $totalDeleted enregistrements supprimés." . PHP_EOL;
|
||||
|
||||
// Réactiver les vérifications de clés étrangères
|
||||
try {
|
||||
$targetDb->exec("SET FOREIGN_KEY_CHECKS=1");
|
||||
echo " - Vérification des clés étrangères réactivée." . PHP_EOL;
|
||||
} catch (PDOException $e) {
|
||||
echo " - Erreur lors de la réactivation des clés étrangères: " . $e->getMessage() . PHP_EOL;
|
||||
}
|
||||
|
||||
} catch (PDOException $e) {
|
||||
echo " - Erreur lors de la suppression des données : " . $e->getMessage() . PHP_EOL;
|
||||
|
||||
// Réactiver les vérifications de clés étrangères en cas d'erreur
|
||||
try {
|
||||
$targetDb->exec("SET FOREIGN_KEY_CHECKS=1");
|
||||
} catch (Exception $e2) {
|
||||
echo " - Erreur lors de la réactivation des clés étrangères : " . $e2->getMessage() . PHP_EOL;
|
||||
}
|
||||
|
||||
closeSshTunnel();
|
||||
exit(1);
|
||||
}
|
||||
|
||||
// Récupération des IDs des opérations qui ont été migrées
|
||||
$stmt = $targetDb->query("SELECT id FROM operations");
|
||||
$migratedOperations = $stmt->fetchAll(PDO::FETCH_COLUMN);
|
||||
|
||||
if (empty($migratedOperations)) {
|
||||
echo "ERREUR: Aucune opération n'a été migrée. Veuillez d'abord migrer la table operations." . PHP_EOL;
|
||||
closeSshTunnel();
|
||||
exit(1);
|
||||
}
|
||||
|
||||
// Récupération des IDs des utilisateurs qui ont été migrés
|
||||
$stmt = $targetDb->query("SELECT id FROM users");
|
||||
$migratedUsers = $stmt->fetchAll(PDO::FETCH_COLUMN);
|
||||
|
||||
if (empty($migratedUsers)) {
|
||||
echo "ERREUR: Aucun utilisateur n'a été migré. Veuillez d'abord migrer la table users." . PHP_EOL;
|
||||
closeSshTunnel();
|
||||
exit(1);
|
||||
}
|
||||
|
||||
// Récupération de la correspondance entre les anciens secteurs et les nouveaux
|
||||
$query = "SELECT id, fk_operation, fk_old_sector FROM ope_sectors WHERE fk_old_sector IS NOT NULL";
|
||||
$stmt = $targetDb->query($query);
|
||||
$sectorMapping = $stmt->fetchAll(PDO::FETCH_ASSOC);
|
||||
|
||||
if (empty($sectorMapping)) {
|
||||
echo "ERREUR: Aucun secteur n'a été migré. Veuillez d'abord migrer la table ope_sectors." . PHP_EOL;
|
||||
closeSshTunnel();
|
||||
exit(1);
|
||||
}
|
||||
|
||||
// Création d'un tableau associatif pour faciliter la recherche des correspondances
|
||||
$sectorMap = [];
|
||||
foreach ($sectorMapping as $mapping) {
|
||||
$key = $mapping['fk_operation'] . '_' . $mapping['fk_old_sector'];
|
||||
$sectorMap[$key] = $mapping['id'];
|
||||
}
|
||||
|
||||
// Pas d'affichage en mode silencieux
|
||||
|
||||
// Création de la liste des IDs d'opérations pour la requête IN
|
||||
$operationIds = implode(',', $migratedOperations);
|
||||
|
||||
// Compter le nombre total de passages à migrer pour estimer le volume
|
||||
$countQuery = "
|
||||
SELECT COUNT(*) as total
|
||||
FROM ope_pass p
|
||||
WHERE p.fk_operation IN ($operationIds)
|
||||
AND p.active = 1
|
||||
";
|
||||
$countStmt = $sourceDb->query($countQuery);
|
||||
$totalCount = $countStmt->fetch(PDO::FETCH_ASSOC)['total'];
|
||||
|
||||
echo "Nombre total de passages à migrer: $totalCount" . PHP_EOL;
|
||||
|
||||
// Définir la taille des lots pour éviter les problèmes de mémoire
|
||||
$batchSize = 5000;
|
||||
$totalBatches = ceil($totalCount / $batchSize);
|
||||
|
||||
echo "Traitement par lots de $batchSize passages ($totalBatches lots au total)" . PHP_EOL;
|
||||
|
||||
// Pas d'affichage du nombre de passages à migrer en mode silencieux
|
||||
|
||||
// Préparation de la requête d'insertion
|
||||
$insertQuery = "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,
|
||||
gps_lat,
|
||||
gps_lng,
|
||||
encrypted_name,
|
||||
montant,
|
||||
fk_type_reglement,
|
||||
remarque,
|
||||
encrypted_email,
|
||||
nom_recu,
|
||||
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,
|
||||
:gps_lat,
|
||||
:gps_lng,
|
||||
:encrypted_name,
|
||||
:montant,
|
||||
:fk_type_reglement,
|
||||
:remarque,
|
||||
:encrypted_email,
|
||||
:nom_recu,
|
||||
: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
|
||||
) ON DUPLICATE KEY UPDATE
|
||||
fk_sector = VALUES(fk_sector),
|
||||
passed_at = VALUES(passed_at),
|
||||
numero = VALUES(numero),
|
||||
rue = VALUES(rue),
|
||||
rue_bis = VALUES(rue_bis),
|
||||
ville = VALUES(ville),
|
||||
fk_habitat = VALUES(fk_habitat),
|
||||
appt = VALUES(appt),
|
||||
niveau = VALUES(niveau),
|
||||
gps_lat = VALUES(gps_lat),
|
||||
gps_lng = VALUES(gps_lng),
|
||||
encrypted_name = VALUES(encrypted_name),
|
||||
montant = VALUES(montant),
|
||||
fk_type_reglement = VALUES(fk_type_reglement),
|
||||
remarque = VALUES(remarque),
|
||||
encrypted_email = VALUES(encrypted_email),
|
||||
nom_recu = VALUES(nom_recu),
|
||||
email_erreur = VALUES(email_erreur),
|
||||
chk_email_sent = VALUES(chk_email_sent),
|
||||
encrypted_phone = VALUES(encrypted_phone),
|
||||
docremis = VALUES(docremis),
|
||||
date_repasser = VALUES(date_repasser),
|
||||
nb_passages = VALUES(nb_passages),
|
||||
chk_gps_maj = VALUES(chk_gps_maj),
|
||||
chk_map_create = VALUES(chk_map_create),
|
||||
chk_mobile = VALUES(chk_mobile),
|
||||
chk_synchro = VALUES(chk_synchro),
|
||||
chk_api_adresse = VALUES(chk_api_adresse),
|
||||
chk_maj_adresse = VALUES(chk_maj_adresse),
|
||||
anomalie = VALUES(anomalie),
|
||||
updated_at = VALUES(updated_at),
|
||||
fk_user_modif = VALUES(fk_user_modif),
|
||||
chk_active = VALUES(chk_active)";
|
||||
|
||||
$insertStmt = $targetDb->prepare($insertQuery);
|
||||
|
||||
// Compteurs
|
||||
$inserted = 0;
|
||||
$skipped = 0;
|
||||
$errors = 0;
|
||||
|
||||
// Traitement par lots pour éviter les problèmes de mémoire
|
||||
for ($batch = 0; $batch < $totalBatches; $batch++) {
|
||||
$offset = $batch * $batchSize;
|
||||
|
||||
echo "Traitement du lot " . ($batch + 1) . "/$totalBatches (offset: $offset)" . PHP_EOL;
|
||||
|
||||
// Récupération d'un lot de passages
|
||||
$query = "
|
||||
SELECT p.*
|
||||
FROM ope_pass p
|
||||
WHERE p.fk_operation IN ($operationIds)
|
||||
AND p.active = 1
|
||||
LIMIT $batchSize OFFSET $offset
|
||||
";
|
||||
|
||||
$stmt = $sourceDb->query($query);
|
||||
$passages = $stmt->fetchAll(PDO::FETCH_ASSOC);
|
||||
|
||||
echo " - " . count($passages) . " passages récupérés dans ce lot" . PHP_EOL;
|
||||
|
||||
// Libérer la mémoire après avoir récupéré les données
|
||||
$stmt->closeCursor();
|
||||
unset($stmt);
|
||||
|
||||
// Traitement des passages de ce lot
|
||||
$batchInserted = 0;
|
||||
$batchSkipped = 0;
|
||||
$batchErrors = 0;
|
||||
|
||||
// Commencer une transaction pour les insertions de ce lot
|
||||
$targetDb->beginTransaction();
|
||||
|
||||
foreach ($passages as $passage) {
|
||||
$fkOperation = $passage['fk_operation'];
|
||||
$fkOldSector = $passage['fk_sector'];
|
||||
|
||||
// Vérifier si le secteur existe dans la table ope_sectors de la cible
|
||||
// On utilise la requête pour trouver le secteur correspondant dans la table ope_sectors
|
||||
$sectorQuery = "SELECT id FROM ope_sectors WHERE fk_operation = :fk_operation AND fk_old_sector = :fk_old_sector";
|
||||
$sectorStmt = $targetDb->prepare($sectorQuery);
|
||||
$sectorStmt->execute([
|
||||
':fk_operation' => $fkOperation,
|
||||
':fk_old_sector' => $fkOldSector
|
||||
]);
|
||||
|
||||
$newSector = $sectorStmt->fetch(PDO::FETCH_ASSOC);
|
||||
|
||||
// Si le secteur n'a pas été migré, on ignore ce passage silencieusement
|
||||
if (!$newSector) {
|
||||
$skipped++;
|
||||
continue;
|
||||
}
|
||||
|
||||
$fkNewSector = $newSector['id'];
|
||||
|
||||
// Vérifier si l'utilisateur existe dans la table users de la cible
|
||||
$fkUser = $passage['fk_user'] ?? 0;
|
||||
if ($fkUser > 0 && !in_array($fkUser, $migratedUsers)) {
|
||||
// L'utilisateur n'a pas été migré, on ignore ce passage silencieusement
|
||||
$skipped++;
|
||||
continue;
|
||||
}
|
||||
|
||||
// Conversion des dates
|
||||
$passedAt = !empty($passage['date_eve']) ? date('Y-m-d H:i:s', strtotime($passage['date_eve'])) : null;
|
||||
$dateRepasser = !empty($passage['date_repasser']) ? date('Y-m-d H:i:s', strtotime($passage['date_repasser'])) : null;
|
||||
$createdAt = !empty($passage['date_creat']) ? date('Y-m-d H:i:s', strtotime($passage['date_creat'])) : date('Y-m-d H:i:s');
|
||||
$updatedAt = !empty($passage['date_modif']) ? date('Y-m-d H:i:s', strtotime($passage['date_modif'])) : null;
|
||||
|
||||
// Chiffrement des données sensibles
|
||||
// Validation et chiffrement du nom
|
||||
$encryptedName = '';
|
||||
if (!empty($passage['libelle'])) {
|
||||
$encryptedName = ApiService::encryptData($passage['libelle']);
|
||||
}
|
||||
|
||||
// Validation et chiffrement de l'email
|
||||
$encryptedEmail = '';
|
||||
if (!empty($passage['email'])) {
|
||||
// Vérifier si l'email est valide
|
||||
if (filter_var($passage['email'], FILTER_VALIDATE_EMAIL)) {
|
||||
$encryptedEmail = ApiService::encryptSearchableData($passage['email']);
|
||||
}
|
||||
}
|
||||
|
||||
$encryptedPhone = !empty($passage['phone']) ? ApiService::encryptData($passage['phone']) : '';
|
||||
|
||||
// Vérification et correction du type de règlement
|
||||
$fkTypeReglement = $passage['fk_type_reglement'] ?? 1;
|
||||
if (!in_array($fkTypeReglement, [1, 2, 3])) {
|
||||
$fkTypeReglement = 4; // Forcer à 4 si différent de 1, 2 ou 3
|
||||
}
|
||||
|
||||
// Préparation des données pour l'insertion
|
||||
$passageData = [
|
||||
'fk_operation' => $fkOperation,
|
||||
'fk_sector' => $fkNewSector,
|
||||
'fk_user' => $passage['fk_user'] ?? 0,
|
||||
'fk_adresse' => $passage['fk_adresse'] ?? '',
|
||||
'passed_at' => $passedAt, // Mapping date_eve => passed_at
|
||||
'fk_type' => (isset($passage['fk_type']) && $passage['fk_type'] == '9') ? 6 :
|
||||
((isset($passage['fk_type']) && $passage['fk_type'] == '8') ? 5 :
|
||||
(isset($passage['fk_type']) ? (int)$passage['fk_type'] : 0)),
|
||||
'numero' => $passage['numero'] ?? '',
|
||||
'rue' => $passage['rue'] ?? '',
|
||||
'rue_bis' => $passage['rue_bis'] ?? '',
|
||||
'ville' => $passage['ville'] ?? '',
|
||||
'fk_habitat' => $passage['fk_habitat'] ?? 1,
|
||||
'appt' => $passage['appt'] ?? '',
|
||||
'niveau' => $passage['niveau'] ?? '',
|
||||
'gps_lat' => $passage['gps_lat'] ?? '',
|
||||
'gps_lng' => $passage['gps_lng'] ?? '',
|
||||
'encrypted_name' => $encryptedName, // Mapping libelle => encrypted_name avec chiffrement
|
||||
'montant' => $passage['montant'] ?? 0,
|
||||
'fk_type_reglement' => $fkTypeReglement, // Valeur corrigée
|
||||
'remarque' => $passage['remarque'] ?? '',
|
||||
'encrypted_email' => $encryptedEmail, // Mapping email => encrypted_email avec chiffrement
|
||||
'nom_recu' => $passage['recu'] ?? null, // Mapping recu => nom_recu
|
||||
'email_erreur' => $passage['email_erreur'] ?? '',
|
||||
'chk_email_sent' => $passage['chk_email_sent'] ?? 0,
|
||||
'encrypted_phone' => $encryptedPhone, // Mapping phone => encrypted_phone avec chiffrement
|
||||
'docremis' => $passage['docremis'] ?? 0,
|
||||
'date_repasser' => $dateRepasser,
|
||||
'nb_passages' => $passage['nb_passages'] ?? 1,
|
||||
'chk_gps_maj' => $passage['chk_gps_maj'] ?? 0,
|
||||
'chk_map_create' => $passage['chk_map_create'] ?? 0,
|
||||
'chk_mobile' => $passage['chk_mobile'] ?? 0,
|
||||
'chk_synchro' => $passage['chk_synchro'] ?? 1,
|
||||
'chk_api_adresse' => $passage['chk_api_adresse'] ?? 0,
|
||||
'chk_maj_adresse' => $passage['chk_maj_adresse'] ?? 0,
|
||||
'anomalie' => $passage['anomalie'] ?? 0,
|
||||
'created_at' => $createdAt,
|
||||
'fk_user_creat' => $passage['fk_user_creat'] ?? null,
|
||||
'updated_at' => $updatedAt,
|
||||
'fk_user_modif' => $passage['fk_user_modif'] ?? null,
|
||||
'chk_active' => $passage['active'] ?? 1
|
||||
];
|
||||
|
||||
try {
|
||||
// Insertion dans la table cible
|
||||
$insertStmt->execute($passageData);
|
||||
$inserted++;
|
||||
$batchInserted++;
|
||||
|
||||
// Libérer un peu de mémoire entre chaque insertion
|
||||
if ($batchInserted % 100 == 0) {
|
||||
unset($passageData);
|
||||
gc_collect_cycles(); // Forcer le garbage collector
|
||||
}
|
||||
} catch (PDOException $e) {
|
||||
echo "ERREUR: Migration du passage (rowid " . $passage['rowid'] . ", opération $fkOperation) : " . $e->getMessage() . "\n";
|
||||
$errors++;
|
||||
$batchErrors++;
|
||||
}
|
||||
|
||||
// Libérer la mémoire du passage traité
|
||||
unset($passage);
|
||||
}
|
||||
|
||||
// Valider la transaction pour ce lot
|
||||
try {
|
||||
$targetDb->commit();
|
||||
echo " - Lot $batch commité avec succès: $batchInserted insérés, $batchSkipped ignorés, $batchErrors erreurs" . PHP_EOL;
|
||||
} catch (PDOException $e) {
|
||||
$targetDb->rollBack();
|
||||
echo "ERREUR lors du commit du lot $batch: " . $e->getMessage() . PHP_EOL;
|
||||
}
|
||||
|
||||
// Libérer la mémoire après chaque lot
|
||||
unset($passages);
|
||||
gc_collect_cycles(); // Forcer le garbage collector
|
||||
|
||||
// Petite pause entre les lots pour éviter de surcharger le serveur
|
||||
sleep(1);
|
||||
}
|
||||
|
||||
echo "Migration de la table ope_pass terminée. $inserted passages insérés, $skipped passages ignorés, $errors erreurs." . PHP_EOL;
|
||||
|
||||
// Recréation des contraintes relationnelles
|
||||
echo "Tentative de recréation des contraintes relationnelles... " . PHP_EOL;
|
||||
$addConstraintsQueries = [
|
||||
"ALTER TABLE ope_pass ADD CONSTRAINT ope_pass_ibfk_1 FOREIGN KEY (fk_operation) REFERENCES operations (id) ON DELETE RESTRICT ON UPDATE CASCADE",
|
||||
"ALTER TABLE ope_pass ADD CONSTRAINT ope_pass_ibfk_2 FOREIGN KEY (fk_sector) REFERENCES ope_sectors (id) ON DELETE RESTRICT ON UPDATE CASCADE",
|
||||
"ALTER TABLE ope_pass ADD CONSTRAINT ope_pass_ibfk_3 FOREIGN KEY (fk_user) REFERENCES users (id) ON DELETE RESTRICT ON UPDATE CASCADE",
|
||||
"ALTER TABLE ope_pass ADD CONSTRAINT ope_pass_ibfk_4 FOREIGN KEY (fk_type_reglement) REFERENCES x_types_reglements (id) ON DELETE RESTRICT ON UPDATE CASCADE"
|
||||
];
|
||||
|
||||
$constraintAddFailed = false;
|
||||
foreach ($addConstraintsQueries as $query) {
|
||||
try {
|
||||
$targetDb->exec($query);
|
||||
echo " - Contrainte recréée avec succès : " . substr($query, 0, 60) . "..." . PHP_EOL;
|
||||
} catch (PDOException $e) {
|
||||
echo " - Erreur lors de la recréation de la contrainte : " . $e->getMessage() . PHP_EOL;
|
||||
$constraintAddFailed = true;
|
||||
}
|
||||
}
|
||||
|
||||
if ($constraintAddFailed) {
|
||||
echo "ATTENTION: Certaines contraintes n'ont pas pu être recréées." . PHP_EOL;
|
||||
echo " Script SQL pour recréer manuellement les contraintes:" . PHP_EOL;
|
||||
echo "--------------------------------------------------------------" . PHP_EOL;
|
||||
foreach ($addConstraintsQueries as $query) {
|
||||
echo "$query;" . PHP_EOL;
|
||||
}
|
||||
echo "--------------------------------------------------------------" . PHP_EOL;
|
||||
}
|
||||
|
||||
// Fermer le tunnel SSH
|
||||
closeSshTunnel();
|
||||
} catch (Exception $e) {
|
||||
echo "ERREUR CRITIQUE: " . $e->getMessage() . PHP_EOL;
|
||||
|
||||
// Fermer le tunnel SSH en cas d'erreur
|
||||
closeSshTunnel();
|
||||
|
||||
exit(1);
|
||||
}
|
||||
126
api/scripts/php/migrate_ope_pass_histo.php
Normal file
126
api/scripts/php/migrate_ope_pass_histo.php
Normal file
@@ -0,0 +1,126 @@
|
||||
<?php
|
||||
/**
|
||||
* Script de migration de la table ope_pass_histo
|
||||
* Ce script ne migre que les historiques dont le fk_pass existe dans la table ope_pass de la base cible
|
||||
*/
|
||||
|
||||
// Inclusion des fichiers nécessaires
|
||||
require_once __DIR__ . '/../config.php';
|
||||
|
||||
// Fonction principale de migration
|
||||
try {
|
||||
// Établissement des connexions aux bases de données
|
||||
$sourceDb = getSourceConnection();
|
||||
$targetDb = getTargetConnection();
|
||||
|
||||
// Début de la migration silencieuse (n'affiche que les erreurs)
|
||||
|
||||
// Suppression de toutes les données existantes dans la table ope_pass_histo
|
||||
$deleteQuery = "DELETE FROM ope_pass_histo";
|
||||
$targetDb->exec($deleteQuery);
|
||||
|
||||
// Récupération des IDs des passages qui ont été migrés
|
||||
$stmt = $targetDb->query("SELECT id FROM ope_pass");
|
||||
$migratedPasses = $stmt->fetchAll(PDO::FETCH_COLUMN);
|
||||
|
||||
if (empty($migratedPasses)) {
|
||||
echo "ERREUR: Aucun passage n'a été migré. Veuillez d'abord migrer la table ope_pass." . PHP_EOL;
|
||||
closeSshTunnel();
|
||||
exit(1);
|
||||
}
|
||||
|
||||
// Récupération des IDs des utilisateurs qui ont été migrés
|
||||
$stmt = $targetDb->query("SELECT id FROM users");
|
||||
$migratedUsers = $stmt->fetchAll(PDO::FETCH_COLUMN);
|
||||
|
||||
if (empty($migratedUsers)) {
|
||||
echo "ERREUR: Aucun utilisateur n'a été migré. Veuillez d'abord migrer la table users." . PHP_EOL;
|
||||
closeSshTunnel();
|
||||
exit(1);
|
||||
}
|
||||
|
||||
// Récupération directe des IDs des passages dans la table cible
|
||||
$stmt = $targetDb->query("SELECT id FROM ope_pass");
|
||||
$migratedPassIds = $stmt->fetchAll(PDO::FETCH_COLUMN);
|
||||
|
||||
if (empty($migratedPassIds)) {
|
||||
echo "ERREUR: Aucun passage n'a été migré. Veuillez d'abord migrer la table ope_pass." . PHP_EOL;
|
||||
closeSshTunnel();
|
||||
exit(1);
|
||||
}
|
||||
|
||||
// Récupération des historiques de passages depuis la source
|
||||
$query = "SELECT * FROM ope_pass_histo";
|
||||
|
||||
$stmt = $sourceDb->query($query);
|
||||
$histos = $stmt->fetchAll(PDO::FETCH_ASSOC);
|
||||
|
||||
// Préparation de la requête d'insertion
|
||||
$insertQuery = "INSERT INTO ope_pass_histo (
|
||||
fk_pass,
|
||||
date_histo,
|
||||
sujet,
|
||||
remarque
|
||||
) VALUES (
|
||||
:fk_pass,
|
||||
:date_histo,
|
||||
:sujet,
|
||||
:remarque
|
||||
)";
|
||||
|
||||
$insertStmt = $targetDb->prepare($insertQuery);
|
||||
|
||||
// Compteurs pour le suivi
|
||||
$inserted = 0;
|
||||
$skipped = 0;
|
||||
$errors = 0;
|
||||
|
||||
// Traitement de chaque historique
|
||||
foreach ($histos as $histo) {
|
||||
// Vérifier si l'ID du passage existe dans la table cible
|
||||
$fkPass = $histo['fk_pass'];
|
||||
if (!in_array($fkPass, $migratedPassIds)) {
|
||||
// Le passage n'a pas été migré, on ignore cet historique
|
||||
$skipped++;
|
||||
continue;
|
||||
}
|
||||
|
||||
// On ignore le champ fk_user qui n'existe plus dans la table cible
|
||||
|
||||
// Conversion des dates
|
||||
$dateHisto = !empty($histo['date_histo']) ? date('Y-m-d H:i:s', strtotime($histo['date_histo'])) : null;
|
||||
|
||||
// Préparation des données pour l'insertion
|
||||
$histoData = [
|
||||
'fk_pass' => $fkPass,
|
||||
'date_histo' => $dateHisto,
|
||||
'sujet' => $histo['sujet'] ?? '',
|
||||
'remarque' => $histo['remarque'] ?? ''
|
||||
];
|
||||
|
||||
try {
|
||||
// Insertion dans la table cible
|
||||
$insertStmt->execute($histoData);
|
||||
$inserted++;
|
||||
} catch (PDOException $e) {
|
||||
echo "ERREUR: Migration de l'historique (rowid {$histo['rowid']}, passage {$fkPass}) : " . $e->getMessage() . "\n";
|
||||
$errors++;
|
||||
}
|
||||
}
|
||||
|
||||
// Afficher uniquement s'il y a des erreurs
|
||||
if ($errors > 0) {
|
||||
echo "ERREUR: $errors erreurs lors de la migration de la table ope_pass_histo." . PHP_EOL;
|
||||
}
|
||||
|
||||
// Fermer le tunnel SSH
|
||||
closeSshTunnel();
|
||||
|
||||
} catch (Exception $e) {
|
||||
echo "ERREUR CRITIQUE: " . $e->getMessage() . PHP_EOL;
|
||||
|
||||
// Fermer le tunnel SSH en cas d'erreur
|
||||
closeSshTunnel();
|
||||
|
||||
exit(1);
|
||||
}
|
||||
152
api/scripts/php/migrate_ope_sectors.php
Normal file
152
api/scripts/php/migrate_ope_sectors.php
Normal file
@@ -0,0 +1,152 @@
|
||||
<?php
|
||||
/**
|
||||
* Script de migration pour la table ope_sectors
|
||||
* Transfert les données depuis les tables sectors et ope_users_sectors de la base source vers la table ope_sectors de la base cible
|
||||
* Ne migre que les secteurs liés aux opérations qui ont été migrées
|
||||
*/
|
||||
|
||||
require_once dirname(__DIR__) . '/config.php';
|
||||
require_once __DIR__ . '/MigrationConfig.php';
|
||||
|
||||
try {
|
||||
// Création du tunnel SSH si nécessaire
|
||||
createSshTunnel();
|
||||
|
||||
// Connexion aux bases de données
|
||||
$sourceDb = getSourceConnection();
|
||||
$targetDb = getTargetConnection();
|
||||
|
||||
echo "Début de la migration de la table ope_sectors...\n";
|
||||
|
||||
// Récupération des IDs des opérations qui ont été migrées
|
||||
$stmt = $targetDb->query("SELECT id FROM operations");
|
||||
$migratedOperations = $stmt->fetchAll(PDO::FETCH_COLUMN);
|
||||
|
||||
if (empty($migratedOperations)) {
|
||||
echo "Aucune opération n'a été migrée. Veuillez d'abord migrer la table operations." . PHP_EOL;
|
||||
closeSshTunnel();
|
||||
exit(1);
|
||||
}
|
||||
|
||||
echo "Nombre d'opérations migrées : " . count($migratedOperations) . PHP_EOL;
|
||||
|
||||
// Création de la liste des IDs d'opérations pour la requête IN
|
||||
$operationIds = implode(',', $migratedOperations);
|
||||
|
||||
// Récupération des secteurs distincts liés aux opérations migrées
|
||||
$query = "
|
||||
SELECT DISTINCT ous.fk_operation, ous.fk_sector, s.libelle, s.sector, s.color
|
||||
FROM ope_users_sectors ous
|
||||
JOIN sectors s ON ous.fk_sector = s.rowid
|
||||
WHERE ous.fk_operation IN ($operationIds)
|
||||
AND ous.active = 1
|
||||
AND s.active = 1
|
||||
";
|
||||
|
||||
$stmt = $sourceDb->query($query);
|
||||
$sectors = $stmt->fetchAll(PDO::FETCH_ASSOC);
|
||||
|
||||
echo "Nombre de secteurs distincts à migrer : " . count($sectors) . PHP_EOL;
|
||||
|
||||
// Préparation de la requête d'insertion
|
||||
$insertQuery = "INSERT INTO ope_sectors (
|
||||
fk_operation,
|
||||
fk_old_sector,
|
||||
libelle,
|
||||
sector,
|
||||
color,
|
||||
created_at,
|
||||
fk_user_creat,
|
||||
updated_at,
|
||||
fk_user_modif,
|
||||
chk_active
|
||||
) VALUES (
|
||||
:fk_operation,
|
||||
:fk_old_sector,
|
||||
:libelle,
|
||||
:sector,
|
||||
:color,
|
||||
:created_at,
|
||||
:fk_user_creat,
|
||||
:updated_at,
|
||||
:fk_user_modif,
|
||||
:chk_active
|
||||
) ON DUPLICATE KEY UPDATE
|
||||
libelle = VALUES(libelle),
|
||||
sector = VALUES(sector),
|
||||
color = VALUES(color),
|
||||
updated_at = VALUES(updated_at),
|
||||
fk_user_modif = VALUES(fk_user_modif)";
|
||||
|
||||
$insertStmt = $targetDb->prepare($insertQuery);
|
||||
|
||||
// Compteurs
|
||||
$inserted = 0;
|
||||
$errors = 0;
|
||||
|
||||
// Traitement de chaque secteur
|
||||
foreach ($sectors as $sector) {
|
||||
// Récupération des informations du secteur source
|
||||
$fkOperation = $sector['fk_operation'];
|
||||
$fkOldSector = $sector['fk_sector'];
|
||||
$libelle = $sector['libelle'] ?? '';
|
||||
$sectorData = $sector['sector'] ?? '';
|
||||
$color = $sector['color'] ?? '#4B77BE';
|
||||
|
||||
// Vérification si le secteur existe déjà pour cette opération
|
||||
$checkQuery = "SELECT id FROM ope_sectors WHERE fk_operation = :fk_operation AND fk_old_sector = :fk_old_sector";
|
||||
$checkStmt = $targetDb->prepare($checkQuery);
|
||||
$checkStmt->execute([
|
||||
'fk_operation' => $fkOperation,
|
||||
'fk_old_sector' => $fkOldSector
|
||||
]);
|
||||
|
||||
$exists = $checkStmt->fetch(PDO::FETCH_ASSOC);
|
||||
|
||||
// Si le secteur existe déjà, passer au suivant
|
||||
if ($exists) {
|
||||
echo "Le secteur avec fk_operation=$fkOperation et fk_old_sector=$fkOldSector existe déjà. Mise à jour...\n";
|
||||
}
|
||||
|
||||
// Préparation des données pour l'insertion
|
||||
$sectorData = [
|
||||
'fk_operation' => $fkOperation,
|
||||
'fk_old_sector' => $fkOldSector,
|
||||
'libelle' => $libelle,
|
||||
'sector' => $sectorData,
|
||||
'color' => $color,
|
||||
'created_at' => date('Y-m-d H:i:s'),
|
||||
'fk_user_creat' => 1, // Utilisateur par défaut
|
||||
'updated_at' => date('Y-m-d H:i:s'),
|
||||
'fk_user_modif' => 1, // Utilisateur par défaut
|
||||
'chk_active' => 1
|
||||
];
|
||||
|
||||
try {
|
||||
// Insertion dans la table cible
|
||||
$insertStmt->execute($sectorData);
|
||||
$inserted++;
|
||||
|
||||
// Affichage du progrès
|
||||
if ($inserted % 10 === 0) {
|
||||
echo "Progression : $inserted secteurs migrés...\n";
|
||||
}
|
||||
} catch (PDOException $e) {
|
||||
echo "Erreur lors de la migration du secteur (opération $fkOperation, secteur $fkOldSector) : " . $e->getMessage() . "\n";
|
||||
$errors++;
|
||||
}
|
||||
}
|
||||
|
||||
echo "Migration terminée. $inserted secteurs migrés avec succès. $errors erreurs rencontrées." . PHP_EOL;
|
||||
|
||||
// Fermer le tunnel SSH
|
||||
closeSshTunnel();
|
||||
|
||||
} catch (Exception $e) {
|
||||
echo "Erreur critique: " . $e->getMessage() . PHP_EOL;
|
||||
|
||||
// Fermer le tunnel SSH en cas d'erreur
|
||||
closeSshTunnel();
|
||||
|
||||
exit(1);
|
||||
}
|
||||
143
api/scripts/php/migrate_ope_users.php
Normal file
143
api/scripts/php/migrate_ope_users.php
Normal file
@@ -0,0 +1,143 @@
|
||||
<?php
|
||||
/**
|
||||
* Script de migration pour la table ope_users
|
||||
* Transfert les données de la base source (geosector) vers la base cible (geosector_app)
|
||||
* Ne migre que les enregistrements liés aux opérations qui ont été migrées
|
||||
*/
|
||||
|
||||
require_once dirname(__DIR__) . '/config.php';
|
||||
require_once __DIR__ . '/MigrationConfig.php';
|
||||
|
||||
try {
|
||||
// Création du tunnel SSH si nécessaire
|
||||
createSshTunnel();
|
||||
|
||||
// Connexion aux bases de données
|
||||
$sourceDb = getSourceConnection();
|
||||
$targetDb = getTargetConnection();
|
||||
|
||||
// Récupération des IDs des opérations qui ont été migrées
|
||||
$stmt = $targetDb->query("SELECT id FROM operations");
|
||||
$migratedOperations = $stmt->fetchAll(PDO::FETCH_COLUMN);
|
||||
|
||||
if (empty($migratedOperations)) {
|
||||
echo "Aucune opération n'a été migrée. Veuillez d'abord migrer la table operations." . PHP_EOL;
|
||||
closeSshTunnel();
|
||||
exit(1);
|
||||
}
|
||||
|
||||
echo "Nombre d'opérations migrées : " . count($migratedOperations) . PHP_EOL;
|
||||
|
||||
// Récupération des IDs des utilisateurs qui ont été migrés
|
||||
$stmt = $targetDb->query("SELECT id FROM users");
|
||||
$migratedUsers = $stmt->fetchAll(PDO::FETCH_COLUMN);
|
||||
|
||||
if (empty($migratedUsers)) {
|
||||
echo "Aucun utilisateur n'a été migré. Veuillez d'abord migrer la table users." . PHP_EOL;
|
||||
closeSshTunnel();
|
||||
exit(1);
|
||||
}
|
||||
|
||||
echo "Nombre d'utilisateurs migrés : " . count($migratedUsers) . PHP_EOL;
|
||||
|
||||
// Création de la liste des IDs d'opérations pour la requête IN
|
||||
$operationIds = implode(',', $migratedOperations);
|
||||
|
||||
// Création de la liste des IDs d'utilisateurs pour la requête IN
|
||||
$userIds = implode(',', $migratedUsers);
|
||||
|
||||
// Récupération des associations utilisateurs-opérations depuis la base source
|
||||
// Ne récupérer que les associations qui concernent à la fois des opérations et des utilisateurs migrés
|
||||
$query = "SELECT * FROM ope_users WHERE fk_operation IN ($operationIds) AND fk_user IN ($userIds)";
|
||||
$stmt = $sourceDb->query($query);
|
||||
$opeUsers = $stmt->fetchAll(PDO::FETCH_ASSOC);
|
||||
|
||||
echo "Nombre d'associations utilisateurs-opérations à migrer : " . count($opeUsers) . PHP_EOL;
|
||||
|
||||
// Préparation de la requête d'insertion
|
||||
$insertQuery = "INSERT INTO ope_users (
|
||||
id,
|
||||
fk_operation,
|
||||
fk_user,
|
||||
created_at,
|
||||
fk_user_creat,
|
||||
updated_at,
|
||||
fk_user_modif,
|
||||
chk_active
|
||||
) VALUES (
|
||||
:id,
|
||||
:fk_operation,
|
||||
:fk_user,
|
||||
:created_at,
|
||||
:fk_user_creat,
|
||||
:updated_at,
|
||||
:fk_user_modif,
|
||||
:chk_active
|
||||
) ON DUPLICATE KEY UPDATE
|
||||
fk_operation = VALUES(fk_operation),
|
||||
fk_user = VALUES(fk_user),
|
||||
updated_at = VALUES(updated_at),
|
||||
fk_user_modif = VALUES(fk_user_modif),
|
||||
chk_active = VALUES(chk_active)";
|
||||
|
||||
$insertStmt = $targetDb->prepare($insertQuery);
|
||||
|
||||
// Compteurs
|
||||
$inserted = 0;
|
||||
$errors = 0;
|
||||
|
||||
// Traitement de chaque association utilisateur-opération
|
||||
foreach ($opeUsers as $opeUser) {
|
||||
// Mappage des champs
|
||||
$id = isset($opeUser['rowid']) ? $opeUser['rowid'] : $opeUser['id'];
|
||||
$chkActive = isset($opeUser['active']) ? $opeUser['active'] : (isset($opeUser['chk_active']) ? $opeUser['chk_active'] : 1);
|
||||
|
||||
// Gestion des dates
|
||||
$createdAt = isset($opeUser['date_creat']) && !empty($opeUser['date_creat']) ?
|
||||
date('Y-m-d H:i:s', strtotime($opeUser['date_creat'])) :
|
||||
date('Y-m-d H:i:s');
|
||||
|
||||
$updatedAt = isset($opeUser['date_modif']) && !empty($opeUser['date_modif']) ?
|
||||
date('Y-m-d H:i:s', strtotime($opeUser['date_modif'])) :
|
||||
null;
|
||||
|
||||
// Préparation des données pour l'insertion
|
||||
$opeUserData = [
|
||||
'id' => $id,
|
||||
'fk_operation' => $opeUser['fk_operation'],
|
||||
'fk_user' => $opeUser['fk_user'],
|
||||
'created_at' => $createdAt,
|
||||
'fk_user_creat' => $opeUser['fk_user_creat'] ?? 0,
|
||||
'updated_at' => $updatedAt,
|
||||
'fk_user_modif' => $opeUser['fk_user_modif'] ?? 0,
|
||||
'chk_active' => $chkActive
|
||||
];
|
||||
|
||||
try {
|
||||
// Insertion dans la table cible
|
||||
$insertStmt->execute($opeUserData);
|
||||
$inserted++;
|
||||
|
||||
// Affichage du progrès
|
||||
if ($inserted % 100 === 0) {
|
||||
echo "Progression : $inserted associations utilisateurs-opérations migrées..." . PHP_EOL;
|
||||
}
|
||||
} catch (PDOException $e) {
|
||||
echo "Erreur lors de la migration de l'association utilisateur-opération ID $id : " . $e->getMessage() . PHP_EOL;
|
||||
$errors++;
|
||||
}
|
||||
}
|
||||
|
||||
echo "Migration terminée. $inserted associations utilisateurs-opérations migrées avec succès. $errors erreurs rencontrées." . PHP_EOL;
|
||||
|
||||
// Fermer le tunnel SSH
|
||||
closeSshTunnel();
|
||||
|
||||
} catch (Exception $e) {
|
||||
echo "Erreur critique: " . $e->getMessage() . PHP_EOL;
|
||||
|
||||
// Fermer le tunnel SSH en cas d'erreur
|
||||
closeSshTunnel();
|
||||
|
||||
exit(1);
|
||||
}
|
||||
170
api/scripts/php/migrate_ope_users_sectors.php
Normal file
170
api/scripts/php/migrate_ope_users_sectors.php
Normal file
@@ -0,0 +1,170 @@
|
||||
<?php
|
||||
/**
|
||||
* Script de migration pour la table ope_users_sectors
|
||||
* Transfert les données depuis la table ope_users_sectors de la base source vers la table ope_users_sectors de la base cible
|
||||
* Ne migre que les associations liées aux opérations et utilisateurs qui ont été migrés
|
||||
* Fait la correspondance entre les anciens secteurs (fk_old_sector) et les nouveaux secteurs (id) dans la table ope_sectors
|
||||
*/
|
||||
|
||||
require_once dirname(__DIR__) . '/config.php';
|
||||
require_once __DIR__ . '/MigrationConfig.php';
|
||||
|
||||
try {
|
||||
// Création du tunnel SSH si nécessaire
|
||||
createSshTunnel();
|
||||
|
||||
// Connexion aux bases de données
|
||||
$sourceDb = getSourceConnection();
|
||||
$targetDb = getTargetConnection();
|
||||
|
||||
echo "Début de la migration de la table ope_users_sectors...\n";
|
||||
|
||||
// Récupération des IDs des opérations qui ont été migrées
|
||||
$stmt = $targetDb->query("SELECT id FROM operations");
|
||||
$migratedOperations = $stmt->fetchAll(PDO::FETCH_COLUMN);
|
||||
|
||||
if (empty($migratedOperations)) {
|
||||
echo "Aucune opération n'a été migrée. Veuillez d'abord migrer la table operations." . PHP_EOL;
|
||||
closeSshTunnel();
|
||||
exit(1);
|
||||
}
|
||||
|
||||
echo "Nombre d'opérations migrées : " . count($migratedOperations) . PHP_EOL;
|
||||
|
||||
// Récupération des IDs des utilisateurs qui ont été migrés
|
||||
$stmt = $targetDb->query("SELECT id FROM users");
|
||||
$migratedUsers = $stmt->fetchAll(PDO::FETCH_COLUMN);
|
||||
|
||||
if (empty($migratedUsers)) {
|
||||
echo "Aucun utilisateur n'a été migré. Veuillez d'abord migrer la table users." . PHP_EOL;
|
||||
closeSshTunnel();
|
||||
exit(1);
|
||||
}
|
||||
|
||||
echo "Nombre d'utilisateurs migrés : " . count($migratedUsers) . PHP_EOL;
|
||||
|
||||
// Récupération de la correspondance entre les anciens secteurs et les nouveaux
|
||||
$stmt = $targetDb->query("SELECT id, fk_operation, fk_old_sector FROM ope_sectors");
|
||||
$sectorMapping = $stmt->fetchAll(PDO::FETCH_ASSOC);
|
||||
|
||||
if (empty($sectorMapping)) {
|
||||
echo "Aucun secteur n'a été migré. Veuillez d'abord migrer la table ope_sectors." . PHP_EOL;
|
||||
closeSshTunnel();
|
||||
exit(1);
|
||||
}
|
||||
|
||||
echo "Nombre de secteurs migrés : " . count($sectorMapping) . PHP_EOL;
|
||||
|
||||
// Création d'un tableau associatif pour faciliter la recherche des correspondances
|
||||
$sectorMap = [];
|
||||
foreach ($sectorMapping as $mapping) {
|
||||
$key = $mapping['fk_operation'] . '_' . $mapping['fk_old_sector'];
|
||||
$sectorMap[$key] = $mapping['id'];
|
||||
}
|
||||
|
||||
// Création de la liste des IDs d'opérations pour la requête IN
|
||||
$operationIds = implode(',', $migratedOperations);
|
||||
|
||||
// Création de la liste des IDs d'utilisateurs pour la requête IN
|
||||
$userIds = implode(',', $migratedUsers);
|
||||
|
||||
// Récupération des associations utilisateurs-secteurs depuis la base source
|
||||
$query = "
|
||||
SELECT * FROM ope_users_sectors
|
||||
WHERE fk_operation IN ($operationIds)
|
||||
AND fk_user IN ($userIds)
|
||||
AND active = 1
|
||||
";
|
||||
|
||||
$stmt = $sourceDb->query($query);
|
||||
$userSectors = $stmt->fetchAll(PDO::FETCH_ASSOC);
|
||||
|
||||
echo "Nombre d'associations utilisateurs-secteurs à migrer : " . count($userSectors) . PHP_EOL;
|
||||
|
||||
// Préparation de la requête d'insertion
|
||||
$insertQuery = "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
|
||||
) ON DUPLICATE KEY UPDATE
|
||||
updated_at = VALUES(updated_at),
|
||||
fk_user_modif = VALUES(fk_user_modif),
|
||||
chk_active = VALUES(chk_active)";
|
||||
|
||||
$insertStmt = $targetDb->prepare($insertQuery);
|
||||
|
||||
// Compteurs
|
||||
$inserted = 0;
|
||||
$skipped = 0;
|
||||
$errors = 0;
|
||||
|
||||
// Traitement de chaque association utilisateur-secteur
|
||||
foreach ($userSectors as $userSector) {
|
||||
$fkOperation = $userSector['fk_operation'];
|
||||
$fkUser = $userSector['fk_user'];
|
||||
$fkOldSector = $userSector['fk_sector'];
|
||||
|
||||
// Recherche du nouvel ID de secteur
|
||||
$key = $fkOperation . '_' . $fkOldSector;
|
||||
if (!isset($sectorMap[$key])) {
|
||||
echo "Secteur non trouvé pour l'opération $fkOperation et le secteur $fkOldSector. Association ignorée.\n";
|
||||
$skipped++;
|
||||
continue;
|
||||
}
|
||||
|
||||
$fkNewSector = $sectorMap[$key];
|
||||
|
||||
// Préparation des données pour l'insertion
|
||||
$userSectorData = [
|
||||
'fk_operation' => $fkOperation,
|
||||
'fk_user' => $fkUser,
|
||||
'fk_sector' => $fkNewSector,
|
||||
'created_at' => date('Y-m-d H:i:s'),
|
||||
'fk_user_creat' => 1, // Utilisateur par défaut
|
||||
'updated_at' => date('Y-m-d H:i:s'),
|
||||
'fk_user_modif' => 1, // Utilisateur par défaut
|
||||
'chk_active' => 1
|
||||
];
|
||||
|
||||
try {
|
||||
// Insertion dans la table cible
|
||||
$insertStmt->execute($userSectorData);
|
||||
$inserted++;
|
||||
|
||||
// Affichage du progrès
|
||||
if ($inserted % 100 === 0) {
|
||||
echo "Progression : $inserted associations utilisateurs-secteurs migrées...\n";
|
||||
}
|
||||
} catch (PDOException $e) {
|
||||
echo "Erreur lors de la migration de l'association utilisateur-secteur (opération $fkOperation, utilisateur $fkUser, secteur $fkOldSector) : " . $e->getMessage() . "\n";
|
||||
$errors++;
|
||||
}
|
||||
}
|
||||
|
||||
echo "Migration terminée. $inserted associations utilisateurs-secteurs migrées avec succès, $skipped ignorées. $errors erreurs rencontrées." . PHP_EOL;
|
||||
|
||||
// Fermer le tunnel SSH
|
||||
closeSshTunnel();
|
||||
|
||||
} catch (Exception $e) {
|
||||
echo "Erreur critique: " . $e->getMessage() . PHP_EOL;
|
||||
|
||||
// Fermer le tunnel SSH en cas d'erreur
|
||||
closeSshTunnel();
|
||||
|
||||
exit(1);
|
||||
}
|
||||
183
api/scripts/php/migrate_operations.php
Normal file
183
api/scripts/php/migrate_operations.php
Normal file
@@ -0,0 +1,183 @@
|
||||
<?php
|
||||
/**
|
||||
* Script de migration de la table operations
|
||||
*
|
||||
* Ce script migre les données de la table operations de la base source vers la base cible
|
||||
*/
|
||||
|
||||
require_once dirname(__DIR__) . '/config.php';
|
||||
require_once __DIR__ . '/MigrationConfig.php';
|
||||
|
||||
try {
|
||||
// Création du tunnel SSH si nécessaire
|
||||
createSshTunnel();
|
||||
|
||||
// Connexion aux bases de données
|
||||
$sourceDb = getSourceConnection();
|
||||
$targetDb = getTargetConnection();
|
||||
echo "Début de la migration de la table operations...\n";
|
||||
|
||||
// Récupération des IDs des entités qui ont été migrées
|
||||
$stmt = $targetDb->query("SELECT id FROM entites");
|
||||
$migratedEntities = $stmt->fetchAll(PDO::FETCH_COLUMN);
|
||||
|
||||
if (empty($migratedEntities)) {
|
||||
echo "Aucune entité n'a été migrée. Veuillez d'abord migrer la table entites." . PHP_EOL;
|
||||
closeSshTunnel();
|
||||
exit(1);
|
||||
}
|
||||
|
||||
echo "Nombre d'entités migrées : " . count($migratedEntities) . PHP_EOL;
|
||||
|
||||
// Création de la liste des IDs d'entités pour la requête IN
|
||||
$entityIds = implode(',', $migratedEntities);
|
||||
|
||||
// Vérification si la table doit être tronquée avant migration
|
||||
$truncate = false; // Par défaut, ne pas tronquer
|
||||
|
||||
// Vérifier les arguments de ligne de commande
|
||||
if (isset($argv) && in_array('--truncate', $argv)) {
|
||||
$truncate = true;
|
||||
}
|
||||
|
||||
if ($truncate) {
|
||||
$targetDb->exec("TRUNCATE TABLE operations");
|
||||
echo "Table operations tronquée.\n";
|
||||
}
|
||||
|
||||
// Récupération des données de la table source
|
||||
// Ne récupérer que les opérations liées aux entités qui ont été migrées
|
||||
$query = "SELECT * FROM operations WHERE fk_entite IN ($entityIds) ORDER BY rowid DESC";
|
||||
$stmt = $sourceDb->query($query);
|
||||
$allOperations = $stmt->fetchAll(PDO::FETCH_ASSOC);
|
||||
|
||||
// Filtrer pour ne garder que les 3 dernières opérations par entité
|
||||
$operationsByEntity = [];
|
||||
$operations = [];
|
||||
|
||||
foreach ($allOperations as $operation) {
|
||||
$entityId = $operation['fk_entite'] ?? 1;
|
||||
|
||||
if (!isset($operationsByEntity[$entityId])) {
|
||||
$operationsByEntity[$entityId] = [];
|
||||
}
|
||||
|
||||
// Ne garder que les 3 premières opérations par entité (déjà triées par rowid DESC)
|
||||
if (count($operationsByEntity[$entityId]) < 3) {
|
||||
$operationsByEntity[$entityId][] = $operation;
|
||||
$operations[] = $operation;
|
||||
}
|
||||
}
|
||||
|
||||
echo "Nombre d'opérations à migrer : " . count($operations) . "\n";
|
||||
|
||||
// Préparation de la requête d'insertion
|
||||
$insertQuery = "INSERT INTO operations (
|
||||
id,
|
||||
fk_entite,
|
||||
libelle,
|
||||
date_deb,
|
||||
date_fin,
|
||||
chk_distinct_sectors,
|
||||
created_at,
|
||||
fk_user_creat,
|
||||
updated_at,
|
||||
fk_user_modif,
|
||||
chk_active
|
||||
) VALUES (
|
||||
:id,
|
||||
:fk_entite,
|
||||
:libelle,
|
||||
:date_deb,
|
||||
:date_fin,
|
||||
:chk_distinct_sectors,
|
||||
:created_at,
|
||||
:fk_user_creat,
|
||||
:updated_at,
|
||||
:fk_user_modif,
|
||||
:chk_active
|
||||
) ON DUPLICATE KEY UPDATE
|
||||
fk_entite = VALUES(fk_entite),
|
||||
libelle = VALUES(libelle),
|
||||
date_deb = VALUES(date_deb),
|
||||
date_fin = VALUES(date_fin),
|
||||
chk_distinct_sectors = VALUES(chk_distinct_sectors),
|
||||
updated_at = VALUES(updated_at),
|
||||
fk_user_modif = VALUES(fk_user_modif),
|
||||
chk_active = VALUES(chk_active)";
|
||||
|
||||
$insertStmt = $targetDb->prepare($insertQuery);
|
||||
|
||||
// Compteurs
|
||||
$inserted = 0;
|
||||
$errors = 0;
|
||||
|
||||
// Traitement de chaque opération
|
||||
foreach ($operations as $operation) {
|
||||
// Mappage des champs
|
||||
$id = isset($operation['rowid']) ? $operation['rowid'] : $operation['id'];
|
||||
$chkActive = isset($operation['active']) ? $operation['active'] : (isset($operation['chk_active']) ? $operation['chk_active'] : 1);
|
||||
|
||||
// Gestion des dates
|
||||
$createdAt = isset($operation['date_creat']) && !empty($operation['date_creat']) ?
|
||||
date('Y-m-d H:i:s', strtotime($operation['date_creat'])) :
|
||||
date('Y-m-d H:i:s');
|
||||
|
||||
$updatedAt = isset($operation['date_modif']) && !empty($operation['date_modif']) ?
|
||||
date('Y-m-d H:i:s', strtotime($operation['date_modif'])) :
|
||||
null;
|
||||
|
||||
// Formatage des dates début et fin
|
||||
$dateDeb = isset($operation['date_deb']) && !empty($operation['date_deb']) ?
|
||||
date('Y-m-d', strtotime($operation['date_deb'])) :
|
||||
'0000-00-00';
|
||||
|
||||
$dateFin = isset($operation['date_fin']) && !empty($operation['date_fin']) ?
|
||||
date('Y-m-d', strtotime($operation['date_fin'])) :
|
||||
'0000-00-00';
|
||||
|
||||
// Préparation des données pour l'insertion
|
||||
$operationData = [
|
||||
'id' => $id,
|
||||
'fk_entite' => $operation['fk_entite'] ?? 1,
|
||||
'libelle' => $operation['libelle'] ?? '',
|
||||
'date_deb' => $dateDeb,
|
||||
'date_fin' => $dateFin,
|
||||
'chk_distinct_sectors' => $operation['chk_distinct_sectors'] ?? 0,
|
||||
'created_at' => $createdAt,
|
||||
'fk_user_creat' => $operation['fk_user_creat'] ?? 0,
|
||||
'updated_at' => $updatedAt,
|
||||
'fk_user_modif' => $operation['fk_user_modif'] ?? 0,
|
||||
'chk_active' => $chkActive
|
||||
];
|
||||
|
||||
try {
|
||||
// Insertion dans la table cible
|
||||
$insertStmt->execute($operationData);
|
||||
$inserted++;
|
||||
|
||||
// Affichage du progrès
|
||||
if ($inserted % 100 === 0) {
|
||||
echo "Progression : $inserted opérations migrées...\n";
|
||||
}
|
||||
} catch (PDOException $e) {
|
||||
echo "Erreur lors de la migration de l'opération ID $id : " . $e->getMessage() . "\n";
|
||||
$errors++;
|
||||
}
|
||||
}
|
||||
|
||||
echo "Migration terminée. $inserted opérations migrées avec succès. $errors erreurs rencontrées." . PHP_EOL;
|
||||
|
||||
echo "Migration de la table operations terminée avec succès." . PHP_EOL;
|
||||
|
||||
// Fermer le tunnel SSH
|
||||
closeSshTunnel();
|
||||
|
||||
} catch (Exception $e) {
|
||||
echo "Erreur critique: " . $e->getMessage() . PHP_EOL;
|
||||
|
||||
// Fermer le tunnel SSH en cas d'erreur
|
||||
closeSshTunnel();
|
||||
|
||||
exit(1);
|
||||
}
|
||||
163
api/scripts/php/migrate_sectors_adresses.php
Normal file
163
api/scripts/php/migrate_sectors_adresses.php
Normal file
@@ -0,0 +1,163 @@
|
||||
<?php
|
||||
/**
|
||||
* Script de migration pour la table sectors_adresses
|
||||
* Transfert les données depuis la table sectors_adresses de la base source vers la table sectors_adresses de la base cible
|
||||
* Ne migre que les adresses liées aux secteurs qui ont été migrés
|
||||
* Fait la correspondance entre les anciens secteurs (fk_old_sector) et les nouveaux secteurs (id) dans la table ope_sectors
|
||||
*/
|
||||
|
||||
require_once dirname(__DIR__) . '/config.php';
|
||||
require_once __DIR__ . '/MigrationConfig.php';
|
||||
|
||||
try {
|
||||
// Création du tunnel SSH si nécessaire
|
||||
createSshTunnel();
|
||||
|
||||
// Connexion aux bases de données
|
||||
$sourceDb = getSourceConnection();
|
||||
$targetDb = getTargetConnection();
|
||||
|
||||
echo "Début de la migration de la table sectors_adresses...\n";
|
||||
|
||||
// Récupération de la correspondance entre les anciens secteurs et les nouveaux
|
||||
$query = "SELECT id, fk_old_sector FROM ope_sectors WHERE fk_old_sector IS NOT NULL";
|
||||
$stmt = $targetDb->query($query);
|
||||
$sectorMapping = $stmt->fetchAll(PDO::FETCH_ASSOC);
|
||||
|
||||
if (empty($sectorMapping)) {
|
||||
echo "Aucun secteur n'a été migré. Veuillez d'abord migrer la table ope_sectors." . PHP_EOL;
|
||||
closeSshTunnel();
|
||||
exit(1);
|
||||
}
|
||||
|
||||
echo "Nombre de secteurs migrés : " . count($sectorMapping) . PHP_EOL;
|
||||
|
||||
// Création d'un tableau associatif pour faciliter la recherche des correspondances
|
||||
$sectorMap = [];
|
||||
foreach ($sectorMapping as $mapping) {
|
||||
$sectorMap[$mapping['fk_old_sector']] = $mapping['id'];
|
||||
}
|
||||
|
||||
// Création de la liste des IDs de secteurs pour la requête IN
|
||||
$oldSectorIds = array_keys($sectorMap);
|
||||
$oldSectorIdsStr = implode(',', $oldSectorIds);
|
||||
|
||||
// Récupération des adresses liées aux secteurs migrés
|
||||
$query = "
|
||||
SELECT * FROM sectors_adresses
|
||||
WHERE fk_sector IN ($oldSectorIdsStr)
|
||||
";
|
||||
|
||||
$stmt = $sourceDb->query($query);
|
||||
$adresses = $stmt->fetchAll(PDO::FETCH_ASSOC);
|
||||
|
||||
echo "Nombre d'adresses à migrer : " . count($adresses) . PHP_EOL;
|
||||
|
||||
// Préparation de la requête d'insertion
|
||||
$insertQuery = "INSERT INTO sectors_adresses (
|
||||
fk_adresse,
|
||||
osm_id,
|
||||
fk_sector,
|
||||
osm_name,
|
||||
numero,
|
||||
rue_bis,
|
||||
rue,
|
||||
cp,
|
||||
ville,
|
||||
gps_lat,
|
||||
gps_lng,
|
||||
osm_date_creat,
|
||||
created_at,
|
||||
updated_at
|
||||
) VALUES (
|
||||
:fk_adresse,
|
||||
:osm_id,
|
||||
:fk_sector,
|
||||
:osm_name,
|
||||
:numero,
|
||||
:rue_bis,
|
||||
:rue,
|
||||
:cp,
|
||||
:ville,
|
||||
:gps_lat,
|
||||
:gps_lng,
|
||||
:osm_date_creat,
|
||||
:created_at,
|
||||
:updated_at
|
||||
) ON DUPLICATE KEY UPDATE
|
||||
fk_adresse = VALUES(fk_adresse),
|
||||
numero = VALUES(numero),
|
||||
rue_bis = VALUES(rue_bis),
|
||||
rue = VALUES(rue),
|
||||
cp = VALUES(cp),
|
||||
ville = VALUES(ville),
|
||||
gps_lat = VALUES(gps_lat),
|
||||
gps_lng = VALUES(gps_lng),
|
||||
updated_at = VALUES(updated_at)";
|
||||
|
||||
$insertStmt = $targetDb->prepare($insertQuery);
|
||||
|
||||
// Compteurs
|
||||
$inserted = 0;
|
||||
$skipped = 0;
|
||||
$errors = 0;
|
||||
|
||||
// Traitement de chaque adresse
|
||||
foreach ($adresses as $adresse) {
|
||||
$fkOldSector = $adresse['fk_sector'];
|
||||
|
||||
// Recherche du nouvel ID de secteur
|
||||
if (!isset($sectorMap[$fkOldSector])) {
|
||||
echo "Secteur non trouvé pour l'ID $fkOldSector. Adresse ignorée.\n";
|
||||
$skipped++;
|
||||
continue;
|
||||
}
|
||||
|
||||
$fkNewSector = $sectorMap[$fkOldSector];
|
||||
|
||||
// Préparation des données pour l'insertion
|
||||
$adresseData = [
|
||||
'fk_adresse' => $adresse['fk_adresse'] ?? '',
|
||||
'osm_id' => 0, // Valeur par défaut
|
||||
'fk_sector' => $fkNewSector,
|
||||
'osm_name' => '', // Valeur par défaut
|
||||
'numero' => $adresse['numero'] ?? '',
|
||||
'rue_bis' => $adresse['rue_bis'] ?? '',
|
||||
'rue' => $adresse['rue'] ?? '',
|
||||
'cp' => $adresse['cp'] ?? '',
|
||||
'ville' => $adresse['ville'] ?? '',
|
||||
'gps_lat' => $adresse['gps_lat'] ?? '',
|
||||
'gps_lng' => $adresse['gps_lng'] ?? '',
|
||||
'osm_date_creat' => '0000-00-00 00:00:00', // Valeur par défaut
|
||||
'created_at' => date('Y-m-d H:i:s'),
|
||||
'updated_at' => date('Y-m-d H:i:s')
|
||||
];
|
||||
|
||||
try {
|
||||
// Insertion dans la table cible
|
||||
$insertStmt->execute($adresseData);
|
||||
$inserted++;
|
||||
|
||||
// Affichage du progrès
|
||||
if ($inserted % 100 === 0) {
|
||||
echo "Progression : $inserted adresses migrées...\n";
|
||||
}
|
||||
} catch (PDOException $e) {
|
||||
echo "Erreur lors de la migration de l'adresse (rowid " . $adresse['rowid'] . ", secteur $fkOldSector) : " . $e->getMessage() . "\n";
|
||||
$errors++;
|
||||
}
|
||||
}
|
||||
|
||||
echo "Migration terminée. $inserted adresses migrées avec succès, $skipped ignorées. $errors erreurs rencontrées." . PHP_EOL;
|
||||
|
||||
// Fermer le tunnel SSH
|
||||
closeSshTunnel();
|
||||
|
||||
} catch (Exception $e) {
|
||||
echo "Erreur critique: " . $e->getMessage() . PHP_EOL;
|
||||
|
||||
// Fermer le tunnel SSH en cas d'erreur
|
||||
closeSshTunnel();
|
||||
|
||||
exit(1);
|
||||
}
|
||||
257
api/scripts/php/migrate_users.php
Normal file
257
api/scripts/php/migrate_users.php
Normal file
@@ -0,0 +1,257 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* Script de migration pour la table users
|
||||
* Transfert les données de la base source (geosector) vers la base cible (geosector_app)
|
||||
* Gère le chiffrement des données sensibles
|
||||
*/
|
||||
|
||||
require_once dirname(__DIR__) . '/config.php';
|
||||
require_once __DIR__ . '/MigrationConfig.php';
|
||||
require_once dirname(dirname(__DIR__)) . '/src/Services/ApiService.php';
|
||||
|
||||
try {
|
||||
// Création du tunnel SSH si nécessaire
|
||||
createSshTunnel();
|
||||
|
||||
// Connexion aux bases de données
|
||||
$sourceDb = getSourceConnection();
|
||||
$targetDb = getTargetConnection();
|
||||
|
||||
// Récupération des utilisateurs depuis la base source
|
||||
$stmt = $sourceDb->query("SELECT * FROM users");
|
||||
$users = $stmt->fetchAll(PDO::FETCH_ASSOC);
|
||||
|
||||
echo "Nombre d'utilisateurs à migrer: " . count($users) . PHP_EOL;
|
||||
|
||||
// Préparation de la requête d'insertion
|
||||
$insertQuery = "INSERT INTO users (
|
||||
id,
|
||||
fk_entite,
|
||||
fk_role,
|
||||
fk_titre,
|
||||
encrypted_name,
|
||||
first_name,
|
||||
sect_name,
|
||||
encrypted_user_name,
|
||||
user_pass_hash,
|
||||
encrypted_phone,
|
||||
encrypted_mobile,
|
||||
encrypted_email,
|
||||
chk_alert_email,
|
||||
chk_suivi,
|
||||
date_naissance,
|
||||
date_embauche,
|
||||
fk_user_creat,
|
||||
fk_user_modif,
|
||||
chk_active
|
||||
) VALUES (
|
||||
:id,
|
||||
:fk_entite,
|
||||
:fk_role,
|
||||
:fk_titre,
|
||||
:encrypted_name,
|
||||
:first_name,
|
||||
:sect_name,
|
||||
:encrypted_user_name,
|
||||
:user_pass_hash,
|
||||
:encrypted_phone,
|
||||
:encrypted_mobile,
|
||||
:encrypted_email,
|
||||
:chk_alert_email,
|
||||
:chk_suivi,
|
||||
:date_naissance,
|
||||
:date_embauche,
|
||||
:fk_user_creat,
|
||||
:fk_user_modif,
|
||||
:chk_active
|
||||
) ON DUPLICATE KEY UPDATE
|
||||
fk_entite = VALUES(fk_entite),
|
||||
fk_role = VALUES(fk_role),
|
||||
fk_titre = VALUES(fk_titre),
|
||||
encrypted_name = VALUES(encrypted_name),
|
||||
first_name = VALUES(first_name),
|
||||
sect_name = VALUES(sect_name),
|
||||
encrypted_user_name = VALUES(encrypted_user_name),
|
||||
user_pass_hash = VALUES(user_pass_hash),
|
||||
encrypted_phone = VALUES(encrypted_phone),
|
||||
encrypted_mobile = VALUES(encrypted_mobile),
|
||||
encrypted_email = VALUES(encrypted_email),
|
||||
chk_alert_email = VALUES(chk_alert_email),
|
||||
chk_suivi = VALUES(chk_suivi),
|
||||
date_naissance = VALUES(date_naissance),
|
||||
date_embauche = VALUES(date_embauche),
|
||||
fk_user_modif = VALUES(fk_user_modif),
|
||||
chk_active = VALUES(chk_active)";
|
||||
|
||||
$insertStmt = $targetDb->prepare($insertQuery);
|
||||
|
||||
// Préparation de la requête pour vérifier si un utilisateur existe
|
||||
$checkQuery = "SELECT COUNT(*) FROM users WHERE id = ?";
|
||||
$checkStmt = $targetDb->prepare($checkQuery);
|
||||
|
||||
// Préparation de la requête pour la mise à jour
|
||||
$updateQuery = "UPDATE users SET
|
||||
fk_entite = :fk_entite,
|
||||
fk_role = :fk_role,
|
||||
fk_titre = :fk_titre,
|
||||
encrypted_name = :encrypted_name,
|
||||
first_name = :first_name,
|
||||
sect_name = :sect_name,
|
||||
encrypted_user_name = :encrypted_user_name,
|
||||
user_pass_hash = :user_pass_hash,
|
||||
encrypted_phone = :encrypted_phone,
|
||||
encrypted_mobile = :encrypted_mobile,
|
||||
encrypted_email = :encrypted_email,
|
||||
chk_alert_email = :chk_alert_email,
|
||||
chk_suivi = :chk_suivi,
|
||||
date_naissance = :date_naissance,
|
||||
date_embauche = :date_embauche,
|
||||
fk_user_modif = :fk_user_modif,
|
||||
chk_active = :chk_active
|
||||
WHERE id = :id";
|
||||
$updateStmt = $targetDb->prepare($updateQuery);
|
||||
|
||||
// Compteurs
|
||||
$successCount = 0;
|
||||
$errorCount = 0;
|
||||
|
||||
// Compteur pour les 100 premiers utilisateurs
|
||||
$counter = 0;
|
||||
$maxTestUsers = 100;
|
||||
|
||||
// Traitement de chaque utilisateur
|
||||
foreach ($users as $user) {
|
||||
try {
|
||||
// Mappage des champs
|
||||
$id = isset($user['rowid']) ? $user['rowid'] : $user['id'];
|
||||
$chkActive = isset($user['active']) ? $user['active'] : (isset($user['chk_active']) ? $user['chk_active'] : 1);
|
||||
|
||||
// Test de déchiffrement pour les 100 premiers utilisateurs
|
||||
if ($counter < $maxTestUsers) {
|
||||
$counter++;
|
||||
|
||||
// Test pour l'email
|
||||
$email = $user['email'] ?? '';
|
||||
$encryptedEmail = !empty($email) ? ApiService::encryptSearchableData($email) : '';
|
||||
$decryptedEmail = !empty($encryptedEmail) ? ApiService::decryptSearchableData($encryptedEmail) : '';
|
||||
|
||||
// Test pour le nom d'utilisateur
|
||||
$username = $user['username'] ?? '';
|
||||
$encryptedUsername = !empty($username) ? ApiService::encryptSearchableData($username) : '';
|
||||
$decryptedUsername = !empty($encryptedUsername) ? ApiService::decryptSearchableData($encryptedUsername) : '';
|
||||
|
||||
// Afficher les résultats pour tous les utilisateurs testés
|
||||
echo "===== TEST UTILISATEUR ID $id =====\n";
|
||||
|
||||
// Toujours afficher les informations d'email
|
||||
echo "Email original: $email\n";
|
||||
echo "Email chiffré: $encryptedEmail\n";
|
||||
echo "Email déchiffré: $decryptedEmail\n";
|
||||
|
||||
// Toujours afficher les informations de nom d'utilisateur
|
||||
echo "Username original: $username\n";
|
||||
echo "Username chiffré: $encryptedUsername\n";
|
||||
echo "Username déchiffré: $decryptedUsername\n";
|
||||
|
||||
echo "=================================================\n";
|
||||
}
|
||||
|
||||
// Gestion du rôle utilisateur
|
||||
$fkRole = isset($user['fk_role']) ? $user['fk_role'] : 1;
|
||||
// Forcer fk_role=1 pour les utilisateurs avec fk_role=0
|
||||
if ($fkRole == 0) {
|
||||
$fkRole = 1;
|
||||
}
|
||||
|
||||
// Gestion du titre utilisateur
|
||||
$fkTitre = isset($user['fk_titre']) ? $user['fk_titre'] : 1;
|
||||
// Forcer fk_titre=1 si différent de 1 ou 2
|
||||
if ($fkTitre != 1 && $fkTitre != 2) {
|
||||
$fkTitre = 1;
|
||||
}
|
||||
|
||||
// Chiffrement des données sensibles (uniquement si non vides)
|
||||
$libelle = $user['libelle'] ?? '';
|
||||
$encryptedName = !empty($libelle) ? ApiService::encryptData($libelle) : '';
|
||||
|
||||
// Traitement du prénom
|
||||
$prenom = $user['prenom'] ?? '';
|
||||
|
||||
// Traitement du nom de tournée (sect_name)
|
||||
$sectName = $user['nom_tournee'] ?? '';
|
||||
|
||||
// Traitement du nom d'utilisateur
|
||||
$username = $user['username'] ?? '';
|
||||
// Utiliser encryptSearchableData car le nom d'utilisateur est utilisé comme clé de recherche
|
||||
$encryptedUserName = !empty($username) ? ApiService::encryptSearchableData($username) : '';
|
||||
|
||||
// Traitement du mot de passe
|
||||
// Utiliser userpswd s'il existe, sinon userpass
|
||||
$userPassHash = $user['userpswd'] ?? ($user['userpass'] ?? '');
|
||||
|
||||
// Traitement des numéros de téléphone
|
||||
$telephone = $user['telephone'] ?? '';
|
||||
$mobile = $user['mobile'] ?? '';
|
||||
|
||||
$encryptedPhone = !empty($telephone) ? ApiService::encryptData($telephone) : '';
|
||||
$encryptedMobile = !empty($mobile) ? ApiService::encryptData($mobile) : '';
|
||||
|
||||
// Chiffrement de l'email
|
||||
$email = $user['email'] ?? '';
|
||||
$encryptedEmail = !empty($email) ? ApiService::encryptSearchableData($email) : '';
|
||||
|
||||
// Préparation des données pour l'insertion
|
||||
$userData = [
|
||||
'id' => $id,
|
||||
'fk_entite' => $user['fk_entite'] ?? 1,
|
||||
'fk_role' => $fkRole,
|
||||
'fk_titre' => $fkTitre,
|
||||
'encrypted_name' => $encryptedName,
|
||||
'first_name' => $prenom,
|
||||
'sect_name' => $sectName,
|
||||
'encrypted_user_name' => $encryptedUserName,
|
||||
'user_pass_hash' => $userPassHash,
|
||||
'encrypted_phone' => $encryptedPhone,
|
||||
'encrypted_mobile' => $encryptedMobile,
|
||||
'encrypted_email' => $encryptedEmail,
|
||||
'chk_alert_email' => $user['alert_email'] ?? 1,
|
||||
'chk_suivi' => $user['chk_suivi'] ?? 0,
|
||||
'date_naissance' => $user['date_naissance'] ?? null,
|
||||
'date_embauche' => $user['date_embauche'] ?? null,
|
||||
'fk_user_creat' => $user['fk_user_creat'] ?? null,
|
||||
'fk_user_modif' => $user['fk_user_modif'] ?? null,
|
||||
'chk_active' => $chkActive
|
||||
];
|
||||
|
||||
// Vérifier si l'utilisateur existe déjà
|
||||
$checkStmt->execute([$id]);
|
||||
$exists = $checkStmt->fetchColumn() > 0;
|
||||
|
||||
if ($exists) {
|
||||
|
||||
// Mise à jour de l'utilisateur existant - utiliser insertStmt avec ON DUPLICATE KEY UPDATE
|
||||
$insertStmt->execute($userData);
|
||||
$successCount++;
|
||||
} else {
|
||||
// L'utilisateur n'existe pas, on ne peut pas le mettre à jour
|
||||
$errorCount++;
|
||||
}
|
||||
} catch (Exception $e) {
|
||||
$errorCount++;
|
||||
echo "Erreur lors de la migration de l'utilisateur ID {$id}: " . $e->getMessage() . PHP_EOL;
|
||||
}
|
||||
}
|
||||
|
||||
echo "Migration terminée. Succès: $successCount, Erreurs: $errorCount" . PHP_EOL;
|
||||
|
||||
// Fermer le tunnel SSH
|
||||
closeSshTunnel();
|
||||
} catch (Exception $e) {
|
||||
echo "Erreur critique: " . $e->getMessage() . PHP_EOL;
|
||||
|
||||
// Fermer le tunnel SSH en cas d'erreur
|
||||
closeSshTunnel();
|
||||
|
||||
exit(1);
|
||||
}
|
||||
87
api/scripts/php/migrate_x_departements.php
Normal file
87
api/scripts/php/migrate_x_departements.php
Normal file
@@ -0,0 +1,87 @@
|
||||
<?php
|
||||
/**
|
||||
* Script de migration pour la table x_departements
|
||||
* Transfert les données de la base source (geosector) vers la base cible (geosector_app)
|
||||
*/
|
||||
|
||||
require_once dirname(__DIR__) . '/config.php';
|
||||
|
||||
try {
|
||||
// Création du tunnel SSH si nécessaire
|
||||
createSshTunnel();
|
||||
|
||||
// Connexion aux bases de données
|
||||
$sourceDb = getSourceConnection();
|
||||
$targetDb = getTargetConnection();
|
||||
|
||||
// Récupération des départements depuis la base source
|
||||
$stmt = $sourceDb->query("SELECT * FROM x_departements");
|
||||
$departements = $stmt->fetchAll(PDO::FETCH_ASSOC);
|
||||
|
||||
echo "Nombre de départements à migrer: " . count($departements) . PHP_EOL;
|
||||
|
||||
// Préparation de la requête d'insertion
|
||||
$insertQuery = "INSERT INTO x_departements (
|
||||
id,
|
||||
code,
|
||||
fk_region,
|
||||
libelle,
|
||||
chk_active
|
||||
) VALUES (
|
||||
:id,
|
||||
:code,
|
||||
:fk_region,
|
||||
:libelle,
|
||||
:chk_active
|
||||
) ON DUPLICATE KEY UPDATE
|
||||
code = VALUES(code),
|
||||
fk_region = VALUES(fk_region),
|
||||
libelle = VALUES(libelle),
|
||||
chk_active = VALUES(chk_active)";
|
||||
|
||||
$insertStmt = $targetDb->prepare($insertQuery);
|
||||
|
||||
// Compteurs
|
||||
$successCount = 0;
|
||||
$errorCount = 0;
|
||||
|
||||
// Traitement de chaque département
|
||||
foreach ($departements as $departement) {
|
||||
try {
|
||||
// Mappage des champs entre les deux structures
|
||||
$id = isset($departement['rowid']) ? $departement['rowid'] : $departement['id'];
|
||||
$chkActive = isset($departement['active']) ? $departement['active'] :
|
||||
(isset($departement['chk_active']) ? $departement['chk_active'] : 1);
|
||||
|
||||
// Préparation des données pour l'insertion
|
||||
$departementData = [
|
||||
'id' => $id,
|
||||
'code' => $departement['code'],
|
||||
'fk_region' => $departement['fk_region'],
|
||||
'libelle' => $departement['libelle'],
|
||||
'chk_active' => $chkActive
|
||||
];
|
||||
|
||||
// Insertion dans la base cible
|
||||
$insertStmt->execute($departementData);
|
||||
$successCount++;
|
||||
|
||||
} catch (Exception $e) {
|
||||
$errorCount++;
|
||||
echo "Erreur lors de la migration du département ID {$id}: " . $e->getMessage() . PHP_EOL;
|
||||
}
|
||||
}
|
||||
|
||||
echo "Migration terminée. Succès: $successCount, Erreurs: $errorCount" . PHP_EOL;
|
||||
|
||||
// Fermer le tunnel SSH
|
||||
closeSshTunnel();
|
||||
|
||||
} catch (Exception $e) {
|
||||
echo "Erreur critique: " . $e->getMessage() . PHP_EOL;
|
||||
|
||||
// Fermer le tunnel SSH en cas d'erreur
|
||||
closeSshTunnel();
|
||||
|
||||
exit(1);
|
||||
}
|
||||
120
api/scripts/php/migrate_x_devises.php
Normal file
120
api/scripts/php/migrate_x_devises.php
Normal file
@@ -0,0 +1,120 @@
|
||||
<?php
|
||||
/**
|
||||
* Script de migration de la table x_devises de geosector vers geosector_app
|
||||
*
|
||||
* Ce script transfère les données de la table x_devises de geosector vers la nouvelle
|
||||
* structure de la table x_devises dans geosector_app, en adaptant les noms de champs.
|
||||
*/
|
||||
|
||||
require_once dirname(__DIR__) . '/config.php';
|
||||
|
||||
// Création du dossier de logs si nécessaire
|
||||
if (!is_dir(dirname(__DIR__) . '/logs')) {
|
||||
mkdir(dirname(__DIR__) . '/logs', 0755, true);
|
||||
}
|
||||
|
||||
logOperation("Démarrage de la migration de la table x_devises");
|
||||
|
||||
try {
|
||||
// Connexion aux bases de données
|
||||
$sourceDb = getSourceConnection();
|
||||
$targetDb = getTargetConnection();
|
||||
|
||||
// Récupération des devises de la source
|
||||
$stmt = $sourceDb->query("SELECT * FROM x_devises");
|
||||
$devises = $stmt->fetchAll();
|
||||
|
||||
logOperation("Nombre de devises à migrer: " . count($devises));
|
||||
|
||||
// Vérifier si la table existe dans la cible
|
||||
try {
|
||||
$targetDb->query("SELECT 1 FROM x_devises LIMIT 1");
|
||||
$tableExists = true;
|
||||
} catch (PDOException $e) {
|
||||
$tableExists = false;
|
||||
}
|
||||
|
||||
// Créer la table si elle n'existe pas
|
||||
if (!$tableExists) {
|
||||
logOperation("La table x_devises n'existe pas dans la base cible. Création de la table...");
|
||||
|
||||
$createTableSql = "CREATE TABLE `x_devises` (
|
||||
`id` int(11) NOT NULL AUTO_INCREMENT,
|
||||
`code` varchar(10) NOT NULL,
|
||||
`libelle` varchar(50) NOT NULL,
|
||||
`symbole` varchar(10) DEFAULT NULL,
|
||||
`chk_active` tinyint(1) UNSIGNED NOT NULL DEFAULT '1',
|
||||
PRIMARY KEY (`id`),
|
||||
UNIQUE KEY `code` (`code`)
|
||||
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;";
|
||||
|
||||
$targetDb->exec($createTableSql);
|
||||
logOperation("Table x_devises créée avec succès");
|
||||
}
|
||||
|
||||
// Préparation de la requête d'insertion
|
||||
$insertQuery = "INSERT INTO x_devises (
|
||||
id,
|
||||
code,
|
||||
libelle,
|
||||
symbole,
|
||||
chk_active
|
||||
) VALUES (
|
||||
:id,
|
||||
:code,
|
||||
:libelle,
|
||||
:symbole,
|
||||
:chk_active
|
||||
) ON DUPLICATE KEY UPDATE
|
||||
code = VALUES(code),
|
||||
libelle = VALUES(libelle),
|
||||
symbole = VALUES(symbole),
|
||||
chk_active = VALUES(chk_active)";
|
||||
|
||||
$insertStmt = $targetDb->prepare($insertQuery);
|
||||
|
||||
// Compteurs
|
||||
$successCount = 0;
|
||||
$errorCount = 0;
|
||||
|
||||
// Traitement de chaque devise
|
||||
foreach ($devises as $devise) {
|
||||
try {
|
||||
// Mappage des champs entre les deux structures
|
||||
$id = isset($devise['rowid']) ? $devise['rowid'] : $devise['id'];
|
||||
$chkActive = isset($devise['active']) ? $devise['active'] :
|
||||
(isset($devise['chk_active']) ? $devise['chk_active'] : 1);
|
||||
|
||||
// Préparation des données pour l'insertion
|
||||
$deviseData = [
|
||||
'id' => $id,
|
||||
'code' => $devise['code'],
|
||||
'libelle' => $devise['libelle'],
|
||||
'symbole' => $devise['symbole'] ?? null,
|
||||
'chk_active' => $chkActive
|
||||
];
|
||||
|
||||
// Insertion dans la base cible
|
||||
$insertStmt->execute($deviseData);
|
||||
$successCount++;
|
||||
|
||||
logOperation("Devise ID {$id} ({$devise['code']}) migrée avec succès", "INFO");
|
||||
} catch (Exception $e) {
|
||||
$errorCount++;
|
||||
logOperation("Erreur lors de la migration de la devise ID {$id} ({$devise['code']}): " . $e->getMessage(), "ERROR");
|
||||
}
|
||||
}
|
||||
|
||||
logOperation("Migration terminée. Succès: $successCount, Erreurs: $errorCount");
|
||||
|
||||
// Fermer le tunnel SSH
|
||||
closeSshTunnel();
|
||||
|
||||
} catch (Exception $e) {
|
||||
logOperation("Erreur critique: " . $e->getMessage(), "ERROR");
|
||||
|
||||
// Fermer le tunnel SSH en cas d'erreur
|
||||
closeSshTunnel();
|
||||
|
||||
exit(1);
|
||||
}
|
||||
75
api/scripts/php/migrate_x_entites_types.php
Normal file
75
api/scripts/php/migrate_x_entites_types.php
Normal file
@@ -0,0 +1,75 @@
|
||||
<?php
|
||||
/**
|
||||
* Script de migration de la table x_entites_types de geosector vers geosector_app
|
||||
*
|
||||
* Version simplifiée sans logs et contrôles de présence
|
||||
*/
|
||||
|
||||
require_once dirname(__DIR__) . '/config.php';
|
||||
|
||||
try {
|
||||
// Connexion aux bases de données
|
||||
$sourceDb = getSourceConnection();
|
||||
$targetDb = getTargetConnection();
|
||||
|
||||
// Récupération des types d'entités de la source
|
||||
$stmt = $sourceDb->query("SELECT * FROM x_entites_types");
|
||||
$entitesTypes = $stmt->fetchAll();
|
||||
|
||||
// Préparation de la requête d'insertion
|
||||
$insertQuery = "INSERT INTO x_entites_types (
|
||||
id,
|
||||
libelle,
|
||||
chk_active
|
||||
) VALUES (
|
||||
:id,
|
||||
:libelle,
|
||||
:chk_active
|
||||
) ON DUPLICATE KEY UPDATE
|
||||
libelle = VALUES(libelle),
|
||||
chk_active = VALUES(chk_active)";
|
||||
|
||||
$insertStmt = $targetDb->prepare($insertQuery);
|
||||
|
||||
// Compteurs
|
||||
$successCount = 0;
|
||||
$errorCount = 0;
|
||||
|
||||
// Traitement de chaque type d'entité
|
||||
foreach ($entitesTypes as $entiteType) {
|
||||
try {
|
||||
// Mappage des champs entre les deux structures
|
||||
$id = isset($entiteType['rowid']) ? $entiteType['rowid'] : $entiteType['id'];
|
||||
$chkActive = isset($entiteType['active']) ? $entiteType['active'] :
|
||||
(isset($entiteType['chk_active']) ? $entiteType['chk_active'] : 1);
|
||||
|
||||
// Préparation des données pour l'insertion
|
||||
$entiteTypeData = [
|
||||
'id' => $id,
|
||||
'libelle' => $entiteType['libelle'],
|
||||
'chk_active' => $chkActive
|
||||
];
|
||||
|
||||
// Insertion dans la base cible
|
||||
$insertStmt->execute($entiteTypeData);
|
||||
$successCount++;
|
||||
|
||||
} catch (Exception $e) {
|
||||
$errorCount++;
|
||||
echo "Erreur lors de la migration du type d'entité ID {$id}: " . $e->getMessage() . PHP_EOL;
|
||||
}
|
||||
}
|
||||
|
||||
echo "Migration terminée. Succès: $successCount, Erreurs: $errorCount" . PHP_EOL;
|
||||
|
||||
// Fermer le tunnel SSH
|
||||
closeSshTunnel();
|
||||
|
||||
} catch (Exception $e) {
|
||||
echo "Erreur critique: " . $e->getMessage() . PHP_EOL;
|
||||
|
||||
// Fermer le tunnel SSH en cas d'erreur
|
||||
closeSshTunnel();
|
||||
|
||||
exit(1);
|
||||
}
|
||||
87
api/scripts/php/migrate_x_pays.php
Normal file
87
api/scripts/php/migrate_x_pays.php
Normal file
@@ -0,0 +1,87 @@
|
||||
<?php
|
||||
/**
|
||||
* Script de migration de la table x_pays de geosector vers geosector_app
|
||||
*
|
||||
* Version simplifiée sans logs et contrôles de présence
|
||||
*/
|
||||
|
||||
require_once dirname(__DIR__) . '/config.php';
|
||||
|
||||
try {
|
||||
// Connexion aux bases de données
|
||||
$sourceDb = getSourceConnection();
|
||||
$targetDb = getTargetConnection();
|
||||
|
||||
// Récupération des pays de la source
|
||||
$stmt = $sourceDb->query("SELECT * FROM x_pays");
|
||||
$pays = $stmt->fetchAll();
|
||||
|
||||
// Préparation de la requête d'insertion
|
||||
$insertQuery = "INSERT INTO x_pays (
|
||||
id,
|
||||
code,
|
||||
fk_continent,
|
||||
fk_devise,
|
||||
libelle,
|
||||
chk_active
|
||||
) VALUES (
|
||||
:id,
|
||||
:code,
|
||||
:fk_continent,
|
||||
:fk_devise,
|
||||
:libelle,
|
||||
:chk_active
|
||||
) ON DUPLICATE KEY UPDATE
|
||||
code = VALUES(code),
|
||||
fk_continent = VALUES(fk_continent),
|
||||
fk_devise = VALUES(fk_devise),
|
||||
libelle = VALUES(libelle),
|
||||
chk_active = VALUES(chk_active)";
|
||||
|
||||
$insertStmt = $targetDb->prepare($insertQuery);
|
||||
|
||||
// Compteurs
|
||||
$successCount = 0;
|
||||
$errorCount = 0;
|
||||
|
||||
// Traitement de chaque pays
|
||||
foreach ($pays as $pay) {
|
||||
try {
|
||||
// Mappage des champs entre les deux structures
|
||||
$id = isset($pay['rowid']) ? $pay['rowid'] : $pay['id'];
|
||||
$chkActive = isset($pay['active']) ? $pay['active'] :
|
||||
(isset($pay['chk_active']) ? $pay['chk_active'] : 1);
|
||||
|
||||
// Préparation des données pour l'insertion
|
||||
$paysData = [
|
||||
'id' => $id,
|
||||
'code' => $pay['code'],
|
||||
'fk_continent' => $pay['fk_continent'],
|
||||
'fk_devise' => $pay['fk_devise'],
|
||||
'libelle' => $pay['libelle'],
|
||||
'chk_active' => $chkActive
|
||||
];
|
||||
|
||||
// Insertion dans la base cible
|
||||
$insertStmt->execute($paysData);
|
||||
$successCount++;
|
||||
|
||||
} catch (Exception $e) {
|
||||
$errorCount++;
|
||||
echo "Erreur lors de la migration du pays ID {$id}: " . $e->getMessage() . PHP_EOL;
|
||||
}
|
||||
}
|
||||
|
||||
echo "Migration terminée. Succès: $successCount, Erreurs: $errorCount" . PHP_EOL;
|
||||
|
||||
// Fermer le tunnel SSH
|
||||
closeSshTunnel();
|
||||
|
||||
} catch (Exception $e) {
|
||||
echo "Erreur critique: " . $e->getMessage() . PHP_EOL;
|
||||
|
||||
// Fermer le tunnel SSH en cas d'erreur
|
||||
closeSshTunnel();
|
||||
|
||||
exit(1);
|
||||
}
|
||||
95
api/scripts/php/migrate_x_regions.php
Normal file
95
api/scripts/php/migrate_x_regions.php
Normal file
@@ -0,0 +1,95 @@
|
||||
<?php
|
||||
/**
|
||||
* Script de migration pour la table x_regions
|
||||
* Transfert les données de la base source (geosector) vers la base cible (geosector_app)
|
||||
*/
|
||||
|
||||
require_once dirname(__DIR__) . '/config.php';
|
||||
|
||||
try {
|
||||
// Création du tunnel SSH si nécessaire
|
||||
createSshTunnel();
|
||||
|
||||
// Connexion aux bases de données
|
||||
$sourceDb = getSourceConnection();
|
||||
$targetDb = getTargetConnection();
|
||||
|
||||
// Récupération des régions depuis la base source
|
||||
$stmt = $sourceDb->query("SELECT * FROM x_regions");
|
||||
$regions = $stmt->fetchAll(PDO::FETCH_ASSOC);
|
||||
|
||||
echo "Nombre de régions à migrer: " . count($regions) . PHP_EOL;
|
||||
|
||||
// Préparation de la requête d'insertion
|
||||
$insertQuery = "INSERT INTO x_regions (
|
||||
id,
|
||||
fk_pays,
|
||||
libelle,
|
||||
libelle_long,
|
||||
table_osm,
|
||||
departements,
|
||||
chk_active
|
||||
) VALUES (
|
||||
:id,
|
||||
:fk_pays,
|
||||
:libelle,
|
||||
:libelle_long,
|
||||
:table_osm,
|
||||
:departements,
|
||||
:chk_active
|
||||
) ON DUPLICATE KEY UPDATE
|
||||
fk_pays = VALUES(fk_pays),
|
||||
libelle = VALUES(libelle),
|
||||
libelle_long = VALUES(libelle_long),
|
||||
table_osm = VALUES(table_osm),
|
||||
departements = VALUES(departements),
|
||||
chk_active = VALUES(chk_active)";
|
||||
|
||||
$insertStmt = $targetDb->prepare($insertQuery);
|
||||
|
||||
// Compteurs
|
||||
$successCount = 0;
|
||||
$errorCount = 0;
|
||||
|
||||
// Traitement de chaque région
|
||||
foreach ($regions as $region) {
|
||||
try {
|
||||
// Mappage des champs entre les deux structures
|
||||
$id = isset($region['rowid']) ? $region['rowid'] : $region['id'];
|
||||
$chkActive = isset($region['active']) ? $region['active'] :
|
||||
(isset($region['chk_active']) ? $region['chk_active'] : 1);
|
||||
|
||||
// Préparation des données pour l'insertion
|
||||
$regionData = [
|
||||
'id' => $id,
|
||||
'fk_pays' => $region['fk_pays'],
|
||||
'libelle' => $region['libelle'],
|
||||
'libelle_long' => $region['libelle_long'],
|
||||
'table_osm' => $region['table_osm'],
|
||||
'departements' => $region['departements'],
|
||||
'chk_active' => $chkActive
|
||||
];
|
||||
|
||||
// Insertion dans la base cible
|
||||
$insertStmt->execute($regionData);
|
||||
$successCount++;
|
||||
|
||||
} catch (Exception $e) {
|
||||
$errorCount++;
|
||||
echo "Erreur lors de la migration de la région ID {$id}: " . $e->getMessage() . PHP_EOL;
|
||||
}
|
||||
}
|
||||
|
||||
echo "Migration terminée. Succès: $successCount, Erreurs: $errorCount" . PHP_EOL;
|
||||
|
||||
// Fermer le tunnel SSH
|
||||
closeSshTunnel();
|
||||
|
||||
} catch (Exception $e) {
|
||||
echo "Erreur critique: " . $e->getMessage() . PHP_EOL;
|
||||
|
||||
// Fermer le tunnel SSH en cas d'erreur
|
||||
closeSshTunnel();
|
||||
|
||||
exit(1);
|
||||
}
|
||||
87
api/scripts/php/migrate_x_types_passages.php
Normal file
87
api/scripts/php/migrate_x_types_passages.php
Normal file
@@ -0,0 +1,87 @@
|
||||
<?php
|
||||
/**
|
||||
* Script de migration de la table x_types_passages de geosector vers geosector_app
|
||||
*
|
||||
* Version simplifiée sans logs et contrôles de présence
|
||||
*/
|
||||
|
||||
require_once dirname(__DIR__) . '/config.php';
|
||||
|
||||
try {
|
||||
// Connexion aux bases de données
|
||||
$sourceDb = getSourceConnection();
|
||||
$targetDb = getTargetConnection();
|
||||
|
||||
// Récupération des types de passages de la source
|
||||
$stmt = $sourceDb->query("SELECT * FROM x_types_passages");
|
||||
$typesPassages = $stmt->fetchAll();
|
||||
|
||||
// Préparation de la requête d'insertion
|
||||
$insertQuery = "INSERT INTO x_types_passages (
|
||||
id,
|
||||
libelle,
|
||||
color_button,
|
||||
color_mark,
|
||||
color_table,
|
||||
chk_active
|
||||
) VALUES (
|
||||
:id,
|
||||
:libelle,
|
||||
:color_button,
|
||||
:color_mark,
|
||||
:color_table,
|
||||
:chk_active
|
||||
) ON DUPLICATE KEY UPDATE
|
||||
libelle = VALUES(libelle),
|
||||
color_button = VALUES(color_button),
|
||||
color_mark = VALUES(color_mark),
|
||||
color_table = VALUES(color_table),
|
||||
chk_active = VALUES(chk_active)";
|
||||
|
||||
$insertStmt = $targetDb->prepare($insertQuery);
|
||||
|
||||
// Compteurs
|
||||
$successCount = 0;
|
||||
$errorCount = 0;
|
||||
|
||||
// Traitement de chaque type de passage
|
||||
foreach ($typesPassages as $typePassage) {
|
||||
try {
|
||||
// Mappage des champs entre les deux structures
|
||||
$id = isset($typePassage['rowid']) ? $typePassage['rowid'] : $typePassage['id'];
|
||||
$chkActive = isset($typePassage['active']) ? $typePassage['active'] :
|
||||
(isset($typePassage['chk_active']) ? $typePassage['chk_active'] : 1);
|
||||
|
||||
// Préparation des données pour l'insertion
|
||||
$typePassageData = [
|
||||
'id' => $id,
|
||||
'libelle' => $typePassage['libelle'],
|
||||
'color_button' => $typePassage['color_button'],
|
||||
'color_mark' => $typePassage['color_mark'],
|
||||
'color_table' => $typePassage['color_table'],
|
||||
'chk_active' => $chkActive
|
||||
];
|
||||
|
||||
// Insertion dans la base cible
|
||||
$insertStmt->execute($typePassageData);
|
||||
$successCount++;
|
||||
|
||||
} catch (Exception $e) {
|
||||
$errorCount++;
|
||||
echo "Erreur lors de la migration du type de passage ID {$id}: " . $e->getMessage() . PHP_EOL;
|
||||
}
|
||||
}
|
||||
|
||||
echo "Migration terminée. Succès: $successCount, Erreurs: $errorCount" . PHP_EOL;
|
||||
|
||||
// Fermer le tunnel SSH
|
||||
closeSshTunnel();
|
||||
|
||||
} catch (Exception $e) {
|
||||
echo "Erreur critique: " . $e->getMessage() . PHP_EOL;
|
||||
|
||||
// Fermer le tunnel SSH en cas d'erreur
|
||||
closeSshTunnel();
|
||||
|
||||
exit(1);
|
||||
}
|
||||
75
api/scripts/php/migrate_x_types_reglements.php
Normal file
75
api/scripts/php/migrate_x_types_reglements.php
Normal file
@@ -0,0 +1,75 @@
|
||||
<?php
|
||||
/**
|
||||
* Script de migration de la table x_types_reglements de geosector vers geosector_app
|
||||
*
|
||||
* Version simplifiée sans logs et contrôles de présence
|
||||
*/
|
||||
|
||||
require_once dirname(__DIR__) . '/config.php';
|
||||
|
||||
try {
|
||||
// Connexion aux bases de données
|
||||
$sourceDb = getSourceConnection();
|
||||
$targetDb = getTargetConnection();
|
||||
|
||||
// Récupération des types de règlements de la source
|
||||
$stmt = $sourceDb->query("SELECT * FROM x_types_reglements");
|
||||
$typesReglements = $stmt->fetchAll();
|
||||
|
||||
// Préparation de la requête d'insertion
|
||||
$insertQuery = "INSERT INTO x_types_reglements (
|
||||
id,
|
||||
libelle,
|
||||
chk_active
|
||||
) VALUES (
|
||||
:id,
|
||||
:libelle,
|
||||
:chk_active
|
||||
) ON DUPLICATE KEY UPDATE
|
||||
libelle = VALUES(libelle),
|
||||
chk_active = VALUES(chk_active)";
|
||||
|
||||
$insertStmt = $targetDb->prepare($insertQuery);
|
||||
|
||||
// Compteurs
|
||||
$successCount = 0;
|
||||
$errorCount = 0;
|
||||
|
||||
// Traitement de chaque type de règlement
|
||||
foreach ($typesReglements as $typeReglement) {
|
||||
try {
|
||||
// Mappage des champs entre les deux structures
|
||||
$id = isset($typeReglement['rowid']) ? $typeReglement['rowid'] : $typeReglement['id'];
|
||||
$chkActive = isset($typeReglement['active']) ? $typeReglement['active'] :
|
||||
(isset($typeReglement['chk_active']) ? $typeReglement['chk_active'] : 1);
|
||||
|
||||
// Préparation des données pour l'insertion
|
||||
$typeReglementData = [
|
||||
'id' => $id,
|
||||
'libelle' => $typeReglement['libelle'],
|
||||
'chk_active' => $chkActive
|
||||
];
|
||||
|
||||
// Insertion dans la base cible
|
||||
$insertStmt->execute($typeReglementData);
|
||||
$successCount++;
|
||||
|
||||
} catch (Exception $e) {
|
||||
$errorCount++;
|
||||
echo "Erreur lors de la migration du type de règlement ID {$id}: " . $e->getMessage() . PHP_EOL;
|
||||
}
|
||||
}
|
||||
|
||||
echo "Migration terminée. Succès: $successCount, Erreurs: $errorCount" . PHP_EOL;
|
||||
|
||||
// Fermer le tunnel SSH
|
||||
closeSshTunnel();
|
||||
|
||||
} catch (Exception $e) {
|
||||
echo "Erreur critique: " . $e->getMessage() . PHP_EOL;
|
||||
|
||||
// Fermer le tunnel SSH en cas d'erreur
|
||||
closeSshTunnel();
|
||||
|
||||
exit(1);
|
||||
}
|
||||
75
api/scripts/php/migrate_x_users_roles.php
Normal file
75
api/scripts/php/migrate_x_users_roles.php
Normal file
@@ -0,0 +1,75 @@
|
||||
<?php
|
||||
/**
|
||||
* Script de migration de la table x_users_roles de geosector vers geosector_app
|
||||
*
|
||||
* Version simplifiée sans logs et contrôles de présence
|
||||
*/
|
||||
|
||||
require_once dirname(__DIR__) . '/config.php';
|
||||
|
||||
try {
|
||||
// Connexion aux bases de données
|
||||
$sourceDb = getSourceConnection();
|
||||
$targetDb = getTargetConnection();
|
||||
|
||||
// Récupération des rôles utilisateurs de la source
|
||||
$stmt = $sourceDb->query("SELECT * FROM x_users_roles");
|
||||
$usersRoles = $stmt->fetchAll();
|
||||
|
||||
// Préparation de la requête d'insertion
|
||||
$insertQuery = "INSERT INTO x_users_roles (
|
||||
id,
|
||||
libelle,
|
||||
chk_active
|
||||
) VALUES (
|
||||
:id,
|
||||
:libelle,
|
||||
:chk_active
|
||||
) ON DUPLICATE KEY UPDATE
|
||||
libelle = VALUES(libelle),
|
||||
chk_active = VALUES(chk_active)";
|
||||
|
||||
$insertStmt = $targetDb->prepare($insertQuery);
|
||||
|
||||
// Compteurs
|
||||
$successCount = 0;
|
||||
$errorCount = 0;
|
||||
|
||||
// Traitement de chaque rôle utilisateur
|
||||
foreach ($usersRoles as $userRole) {
|
||||
try {
|
||||
// Mappage des champs entre les deux structures
|
||||
$id = isset($userRole['rowid']) ? $userRole['rowid'] : $userRole['id'];
|
||||
$chkActive = isset($userRole['active']) ? $userRole['active'] :
|
||||
(isset($userRole['chk_active']) ? $userRole['chk_active'] : 1);
|
||||
|
||||
// Préparation des données pour l'insertion
|
||||
$userRoleData = [
|
||||
'id' => $id,
|
||||
'libelle' => $userRole['libelle'],
|
||||
'chk_active' => $chkActive
|
||||
];
|
||||
|
||||
// Insertion dans la base cible
|
||||
$insertStmt->execute($userRoleData);
|
||||
$successCount++;
|
||||
|
||||
} catch (Exception $e) {
|
||||
$errorCount++;
|
||||
echo "Erreur lors de la migration du rôle utilisateur ID {$id}: " . $e->getMessage() . PHP_EOL;
|
||||
}
|
||||
}
|
||||
|
||||
echo "Migration terminée. Succès: $successCount, Erreurs: $errorCount" . PHP_EOL;
|
||||
|
||||
// Fermer le tunnel SSH
|
||||
closeSshTunnel();
|
||||
|
||||
} catch (Exception $e) {
|
||||
echo "Erreur critique: " . $e->getMessage() . PHP_EOL;
|
||||
|
||||
// Fermer le tunnel SSH en cas d'erreur
|
||||
closeSshTunnel();
|
||||
|
||||
exit(1);
|
||||
}
|
||||
94
api/scripts/php/migrate_x_villes.php
Normal file
94
api/scripts/php/migrate_x_villes.php
Normal file
@@ -0,0 +1,94 @@
|
||||
<?php
|
||||
/**
|
||||
* Script de migration pour la table x_villes
|
||||
* Transfert les données de la base source (geosector) vers la base cible (geosector_app)
|
||||
*/
|
||||
|
||||
require_once dirname(__DIR__) . '/config.php';
|
||||
|
||||
try {
|
||||
// Création du tunnel SSH si nécessaire
|
||||
createSshTunnel();
|
||||
|
||||
// Connexion aux bases de données
|
||||
$sourceDb = getSourceConnection();
|
||||
$targetDb = getTargetConnection();
|
||||
|
||||
// Récupération des villes depuis la base source
|
||||
$stmt = $sourceDb->query("SELECT * FROM x_villes");
|
||||
$villes = $stmt->fetchAll(PDO::FETCH_ASSOC);
|
||||
|
||||
echo "Nombre de villes à migrer: " . count($villes) . PHP_EOL;
|
||||
|
||||
// Préparation de la requête d'insertion
|
||||
$insertQuery = "INSERT INTO x_villes (
|
||||
id,
|
||||
fk_departement,
|
||||
libelle,
|
||||
code_postal,
|
||||
code_insee,
|
||||
chk_active
|
||||
) VALUES (
|
||||
:id,
|
||||
:fk_departement,
|
||||
:libelle,
|
||||
:code_postal,
|
||||
:code_insee,
|
||||
:chk_active
|
||||
) ON DUPLICATE KEY UPDATE
|
||||
fk_departement = VALUES(fk_departement),
|
||||
libelle = VALUES(libelle),
|
||||
code_postal = VALUES(code_postal),
|
||||
code_insee = VALUES(code_insee),
|
||||
chk_active = VALUES(chk_active)";
|
||||
|
||||
$insertStmt = $targetDb->prepare($insertQuery);
|
||||
|
||||
// Compteurs
|
||||
$successCount = 0;
|
||||
$errorCount = 0;
|
||||
|
||||
// Traitement de chaque ville
|
||||
foreach ($villes as $ville) {
|
||||
try {
|
||||
// Mappage des champs
|
||||
$id = isset($ville['rowid']) ? $ville['rowid'] : $ville['id'];
|
||||
$chkActive = isset($ville['active']) ? $ville['active'] : (isset($ville['chk_active']) ? $ville['chk_active'] : 1);
|
||||
|
||||
// Formatage du code postal (ajouter un 0 devant s'il ne contient que 4 chiffres)
|
||||
$codePostal = $ville['cp'] ?? '';
|
||||
if (strlen($codePostal) === 4 && is_numeric($codePostal)) {
|
||||
$codePostal = '0' . $codePostal;
|
||||
}
|
||||
|
||||
// Préparation des données pour l'insertion
|
||||
$villeData = [
|
||||
'id' => $id,
|
||||
'fk_departement' => $ville['fk_departement'] ?? 1,
|
||||
'libelle' => $ville['libelle'] ?? '',
|
||||
'code_postal' => $codePostal,
|
||||
'code_insee' => $ville['code_insee'] ?? '',
|
||||
'chk_active' => $chkActive
|
||||
];
|
||||
|
||||
// Insertion dans la base cible
|
||||
$insertStmt->execute($villeData);
|
||||
$successCount++;
|
||||
} catch (Exception $e) {
|
||||
$errorCount++;
|
||||
echo "Erreur lors de la migration de la ville ID {$id}: " . $e->getMessage() . PHP_EOL;
|
||||
}
|
||||
}
|
||||
|
||||
echo "Migration terminée. Succès: $successCount, Erreurs: $errorCount" . PHP_EOL;
|
||||
|
||||
// Fermer le tunnel SSH
|
||||
closeSshTunnel();
|
||||
} catch (Exception $e) {
|
||||
echo "Erreur critique: " . $e->getMessage() . PHP_EOL;
|
||||
|
||||
// Fermer le tunnel SSH en cas d'erreur
|
||||
closeSshTunnel();
|
||||
|
||||
exit(1);
|
||||
}
|
||||
Reference in New Issue
Block a user