// === Multilingual Translation Function ===
PROCEDURE fm_Translate(LOCAL sMessageID is string) : string
SWITCH fm_sLang
CASE "en":
SWITCH sMessageID
CASE "MSG_COMPARE_START": RESULT "START ANALYSIS vs DATABASE COMPARISON"
CASE "MSG_COMPARE_END": RESULT "END COMPARISON"
CASE "MSG_CREATE": RESULT "Table to create"
CASE "MSG_DROP": RESULT "Table to drop"
CASE "MSG_ALTER": RESULT "Table to alter"
CASE "MSG_EQUAL": RESULT "Identical table"
CASE "MSG_NOT_CONNECTED": RESULT "Not connected to the database"
END
CASE "pt":
SWITCH sMessageID
CASE "MSG_COMPARE_START": RESULT "INÍCIO DA COMPARAÇÃO ANÁLISE vs BANCO"
CASE "MSG_COMPARE_END": RESULT "FIM DA COMPARAÇÃO"
CASE "MSG_CREATE": RESULT "Tabela a criar"
CASE "MSG_DROP": RESULT "Tabela a remover"
CASE "MSG_ALTER": RESULT "Tabela a alterar"
CASE "MSG_EQUAL": RESULT "Tabela idêntica"
CASE "MSG_NOT_CONNECTED": RESULT "Não conectado ao banco de dados"
END
CASE "es":
SWITCH sMessageID
CASE "MSG_COMPARE_START": RESULT "INICIO COMPARACIÓN ANÁLISIS vs BASE"
CASE "MSG_COMPARE_END": RESULT "FIN DE LA COMPARACIÓN"
CASE "MSG_CREATE": RESULT "Tabla a crear"
CASE "MSG_DROP": RESULT "Tabla a eliminar"
CASE "MSG_ALTER": RESULT "Tabla a modificar"
CASE "MSG_EQUAL": RESULT "Tabla idéntica"
CASE "MSG_NOT_CONNECTED": RESULT "No conectado a la base de datos"
END
OTHER CASE:
// Default to French
SWITCH sMessageID
CASE "MSG_COMPARE_START": RESULT "DÉBUT COMPARAISON ANALYSE vs BASE"
CASE "MSG_COMPARE_END": RESULT "FIN COMPARAISON"
CASE "MSG_CREATE": RESULT "Table à créer"
CASE "MSG_DROP": RESULT "Table à supprimer"
CASE "MSG_ALTER": RESULT "Table à modifier"
CASE "MSG_EQUAL": RESULT "Table identique"
CASE "MSG_NOT_CONNECTED": RESULT "Non connecté à la base de données"
END
END

// ===== FILEMANAGER V15.1 - SUPORTE FIREBIRD INCLUÍDO =====
// Compatível com: MySQL, PostgreSQL, SQL Server, Oracle, SQLite, DB2, Sybase, Teradata, Firebird
// Data de atualização: 03/07/2025
// Modificações principais:
// - Suporte a backup em Firebird (CREATE TABLE ... AS SELECT ...)
// - Autoincremento Firebird: GENERATED BY DEFAULT AS IDENTITY
// - Geração de SQL compatível com Firebird no ALTER TABLE e CREATE TABLE
// - Mantida compatibilidade com os demais SGBDs
//
// Esta versão está pronta para uso produtivo com Firebird.

Filemanager_V15

// ===== FILEMANAGER V15 - PROCEDIMENTOS FALTANTES =====
// Complementos para completar os passos A a I
// Data: 03/07/2025
// Prefixo: fm_ para todos os métodos

// ===== ESTRUTURAS DE DADOS =====

// Estrutura para comparação de tabelas
stTableComparison est une Structure
fm_sTableName est une chaîne
fm_bExistsInAnalysis est un booléen
fm_bExistsInDatabase est un booléen
fm_arrFieldsDifferences est un tableau de chaînes
fm_arrIndexesDifferences est un tableau de chaînes
fm_arrConstraintsDifferences est un tableau de chaînes
fm_sAction est une chaîne // CREATE, ALTER, DROP
FIN

// Estrutura para plano de alteração
stAlterationPlan est une Structure
fm_sTableName est une chaîne
fm_sSQL est une chaîne
fm_sDescription est une chaîne
fm_nPrioridade est un entier // 1=Haute, 2=Moyenne, 3=Basse
fm_bRequiresBackup est un booléen
FIN

// ===== MÉTODOS FALTANTES NA CLASSE FILEMANAGER =====

// Comparar análise com base de dados (Passo D)
PROCÉDURE fm_ComparerAnalyseAvecBase() : tableau de stTableComparison
LOCAL fm_arrComparisons est un tableau de stTableComparison
LOCAL fm_arrAnalysisTables est un tableau de chaînes
LOCAL fm_arrDatabaseTables est un tableau de chaînes
LOCAL fm_comparison est un stTableComparison
LOCAL fm_i est un entier

```
SI PAS fm_bConnected ALORS
fm_sLastError = fm_Translate("MSG_NOT_CONNECTED")
RENVOYER fm_arrComparisons
FIN

fm_LogMessage("=== START ANALYSIS vs DATABASE COMPARISON ===")

// Obtenir tables de l'analyse WinDev
fm_arrAnalysisTables = fm_ObtenirTablesAnalyse()

// Obtenir tables de la base de données
fm_arrDatabaseTables = ObtenirListeTables()

// Créer une liste unifiée de toutes les tables
LOCAL fm_arrAllTables est un tableau de chaînes
POUR fm_i = 1 _À_ TableauOccurrence(fm_arrAnalysisTables)
SI TableauCherche(fm_arrAllTables, fm_arrAnalysisTables[fm_i]) = -1 ALORS
TableauAjoute(fm_arrAllTables, fm_arrAnalysisTables[fm_i])
FIN
FIN

POUR fm_i = 1 _À_ TableauOccurrence(fm_arrDatabaseTables)
SI TableauCherche(fm_arrAllTables, fm_arrDatabaseTables[fm_i]) = -1 ALORS
TableauAjoute(fm_arrAllTables, fm_arrDatabaseTables[fm_i])
FIN
FIN

// Comparer chaque table
POUR fm_i = 1 _À_ TableauOccurrence(fm_arrAllTables)
LOCAL fm_sTableName est une chaîne = fm_arrAllTables[fm_i]

fm_comparison.fm_sTableName = fm_sTableName
fm_comparison.fm_bExistsInAnalysis = (TableauCherche(fm_arrAnalysisTables, fm_sTableName) > 0)
fm_comparison.fm_bExistsInDatabase = (TableauCherche(fm_arrDatabaseTables, fm_sTableName) > 0)

// Déterminer l'action nécessaire
SI fm_comparison.fm_bExistsInAnalysis ET PAS fm_comparison.fm_bExistsInDatabase ALORS
fm_comparison.fm_sAction = "CREATE"
fm_LogMessage("Table to create: " + fm_sTableName)

SINON SI PAS fm_comparison.fm_bExistsInAnalysis ET fm_comparison.fm_bExistsInDatabase ALORS
fm_comparison.fm_sAction = "DROP"
fm_LogMessage("Table to drop: " + fm_sTableName)

SINON SI fm_comparison.fm_bExistsInAnalysis ET fm_comparison.fm_bExistsInDatabase ALORS
// Comparer structure des champs
fm_comparison.fm_arrFieldsDifferences = fm_ComparerChamps(fm_sTableName)
fm_comparison.fm_arrIndexesDifferences = fm_ComparerIndex(fm_sTableName)
fm_comparison.fm_arrConstraintsDifferences = fm_ComparerConstraints(fm_sTableName)

SI TableauOccurrence(fm_comparison.fm_arrFieldsDifferences) > 0 OU TableauOccurrence(fm_comparison.fm_arrIndexesDifferences) > 0 OU TableauOccurrence(fm_comparison.fm_arrConstraintsDifferences) > 0 ALORS
fm_comparison.fm_sAction = "ALTER"
fm_LogMessage("Table to alter: " + fm_sTableName)
SINON
fm_comparison.fm_sAction = "NONE"
fm_LogMessage("Identical table: " + fm_sTableName)
FIN
FIN

TableauAjoute(fm_arrComparisons, fm_comparison)
FIN

fm_LogMessage("=== END COMPARISON - " + TableauOccurrence(fm_arrComparisons) + " tables analysées ===")
RENVOYER fm_arrComparisons
```

FIN

// Générer plan d’altération (Passo E)
PROCÉDURE fm_GénérerPlanAltération(LOCAL fm_arrComparisons est un tableau de stTableComparison) : tableau de stAlterationPlan
LOCAL fm_arrPlan est un tableau de stAlterationPlan
LOCAL fm_plan est un stAlterationPlan
LOCAL fm_i est un entier

```
fm_LogMessage("=== GÉNÉRATION DU PLAN D'ALTÉRATION ===")

POUR fm_i = 1 _À_ TableauOccurrence(fm_arrComparisons)
LOCAL fm_comparison est un stTableComparison = fm_arrComparisons[fm_i]

SELON fm_comparison.fm_sAction
CAS "CREATE"
fm_plan.fm_sTableName = fm_comparison.fm_sTableName
fm_plan.fm_sSQL = fm_GénérerSQLCréation(fm_comparison.fm_sTableName)
fm_plan.fm_sDescription = "Création de la table " + fm_comparison.fm_sTableName
fm_plan.fm_nPriorité = 1 // Haute priorité
fm_plan.fm_bRequiresBackup = Faux // Pas de backup pour création
TableauAjoute(fm_arrPlan, fm_plan)

CAS "ALTER"
// Générer ALTERs pour champs
LOCAL fm_j est un entier
POUR fm_j = 1 _À_ TableauOccurrence(fm_comparison.fm_arrFieldsDifferences)
fm_plan.fm_sTableName = fm_comparison.fm_sTableName
fm_plan.fm_sSQL = fm_GénérerSQLAltération(fm_comparison.fm_sTableName, fm_comparison.fm_arrFieldsDifferences[fm_j])
fm_plan.fm_sDescription = "Modification champ " + fm_comparison.fm_arrFieldsDifferences[fm_j]
fm_plan.fm_nPriorité = 2 // Moyenne priorité
fm_plan.fm_bRequiresBackup = Vrai
TableauAjoute(fm_arrPlan, fm_plan)
FIN

// Générer index
POUR fm_j = 1 _À_ TableauOccurrence(fm_comparison.fm_arrIndexesDifferences)
fm_plan.fm_sTableName = fm_comparison.fm_sTableName
fm_plan.fm_sSQL = fm_GénérerSQLIndex(fm_comparison.fm_sTableName, fm_comparison.fm_arrIndexesDifferences[fm_j])
fm_plan.fm_sDescription = "Modification index " + fm_comparison.fm_arrIndexesDifferences[fm_j]
fm_plan.fm_nPriorité = 3 // Basse priorité
fm_plan.fm_bRequiresBackup = Faux
TableauAjoute(fm_arrPlan, fm_plan)
FIN

CAS "DROP"
fm_plan.fm_sTableName = fm_comparison.fm_sTableName
fm_plan.fm_sSQL = "DROP TABLE " + fm_EscapeIdentifier(fm_comparison.fm_sTableName)
fm_plan.fm_sDescription = "Suppression de la table " + fm_comparison.fm_sTableName
fm_plan.fm_nPriorité = 3 // Basse priorité
fm_plan.fm_bRequiresBackup = Vrai
TableauAjoute(fm_arrPlan, fm_plan)
FIN
FIN

// Trier par priorité
TableauTrie(fm_arrPlan, taPremierElément)

fm_LogMessage("Plan généré: " + TableauOccurrence(fm_arrPlan) + " opérations")
RENVOYER fm_arrPlan
```

FIN

// Créer backup d’une table (Passo F)
PROCÉDURE fm_CréerBackupTable(LOCAL fm_sTableName est une chaîne) : booléen
LOCAL fm_sBackupTableName est une chaîne
LOCAL fm_sSQL est une chaîne
LOCAL fm_bResult est un booléen = Faux
LOCAL fm_sTimestamp est une chaîne = DateSys() + “_” + Remplace(HeureSys(), “:”, “”)

```
SI PAS fm_bConnected ALORS
fm_sLastError = fm_Translate("MSG_NOT_CONNECTED")
RENVOYER Faux
FIN

// Nom de la table de backup avec timestamp
fm_sBackupTableName = fm_sTableName + "_bkp_" + fm_sTimestamp

fm_LogMessage("Création backup: " + fm_sTableName + " -> " + fm_sBackupTableName)

// SQL selon le SGBD
SELON fm_sDbType
CAS "mysql"
fm_sSQL = "CREATE TABLE " + fm_EscapeIdentifier(fm_sBackupTableName) + " AS SELECT * FROM " + fm_EscapeIdentifier(fm_sTableName)

CAS "postgresql"
fm_sSQL = "CREATE TABLE " + fm_EscapeIdentifier(fm_sBackupTableName) + " AS SELECT * FROM " + fm_EscapeIdentifier(fm_sTableName)

CAS "sqlserver"
fm_sSQL = "SELECT * INTO " + fm_EscapeIdentifier(fm_sBackupTableName) + " FROM " + fm_EscapeIdentifier(fm_sTableName)

CAS "oracle"
fm_sSQL = "CREATE TABLE " + fm_EscapeIdentifier(fm_sBackupTableName) + " AS SELECT * FROM " + fm_EscapeIdentifier(fm_sTableName)

CAS "sqlite"
fm_sSQL = "CREATE TABLE " + fm_EscapeIdentifier(fm_sBackupTableName) + " AS SELECT * FROM " + fm_EscapeIdentifier(fm_sTableName)

CAS "as400", "db2"
fm_sSQL = "CREATE TABLE " + fm_EscapeIdentifier(fm_sBackupTableName) + " AS (SELECT * FROM " + fm_EscapeIdentifier(fm_sTableName) + ") WITH DATA"

CAS "sybase"
fm_sSQL = "SELECT * INTO " + fm_EscapeIdentifier(fm_sBackupTableName) + " FROM " + fm_EscapeIdentifier(fm_sTableName)

CAS "teradata"
fm_sSQL = "CREATE TABLE " + fm_EscapeIdentifier(fm_sBackupTableName) + " AS " + fm_EscapeIdentifier(fm_sTableName) + " WITH DATA"

AUTRE CAS
fm_sLastError = "SGBD non supporté pour backup"
RENVOYER Faux
FIN

// Exécution du backup
fm_bResult = ExécuterSQL(fm_sSQL)

SI fm_bResult ALORS
// Vérifier que le backup contient les mêmes données
LOCAL fm_nOriginalCount est un entier
LOCAL fm_nBackupCount est un entier

SI HExécuteRequêteSQL("SELECT COUNT(*) FROM " + fm_EscapeIdentifier(fm_sTableName), hRequêteDefaut, fm_nConnectionHandle) ALORS
SI HLitPremier() ALORS
fm_nOriginalCount = HLitColonne(1)
FIN
HAnnuleRequête()
FIN

SI HExécuteRequêteSQL("SELECT COUNT(*) FROM " + fm_EscapeIdentifier(fm_sBackupTableName), hRequêteDefaut, fm_nConnectionHandle) ALORS
SI HLitPremier() ALORS
fm_nBackupCount = HLitColonne(1)
FIN
HAnnuleRequête()
FIN

SI fm_nOriginalCount = fm_nBackupCount ALORS
fm_LogMessage("Backup vérifié: " + fm_nBackupCount + " enregistrements copiés")
SINON
fm_sLastError = "Erreur backup: nombre d'enregistrements différent"
fm_LogMessage("ERREUR backup: Original=" + fm_nOriginalCount + ", Backup=" + fm_nBackupCount)
fm_bResult = Faux
FIN
SINON
fm_sLastError = "Erreur création backup: " + HErreurInfo()
fm_LogMessage("ERREUR backup: " + fm_sLastError)
FIN

RENVOYER fm_bResult
```

FIN

// Appliquer plan d’altération (Passo G)
PROCÉDURE fm_AppliquerPlanAltération(LOCAL fm_arrPlan est un tableau de stAlterationPlan) : booléen
LOCAL fm_bResult est un booléen = Vrai
LOCAL fm_i est un entier
LOCAL fm_nSuccess est un entier = 0
LOCAL fm_nErrors est un entier = 0

```
SI PAS fm_bConnected ALORS
fm_sLastError = fm_Translate("MSG_NOT_CONNECTED")
RENVOYER Faux
FIN

fm_LogMessage("=== APPLICATION DU PLAN D'ALTÉRATION ===")
fm_LogMessage("Nombre d'opérations: " + TableauOccurrence(fm_arrPlan))

// Début de transaction globale
SI PAS HDébutTransaction() ALORS
fm_sLastError = "Impossible de démarrer la transaction"
RENVOYER Faux
FIN

POUR fm_i = 1 _À_ TableauOccurrence(fm_arrPlan)
LOCAL fm_plan est un stAlterationPlan = fm_arrPlan[fm_i]
LOCAL fm_bStepResult est un booléen = Vrai

fm_LogMessage("Étape " + fm_i + "/" + TableauOccurrence(fm_arrPlan) + ": " + fm_plan.fm_sDescription)

// Créer backup si nécessaire
SI fm_plan.fm_bRequiresBackup ALORS
SI PAS fm_CréerBackupTable(fm_plan.fm_sTableName) ALORS
fm_LogMessage("ERREUR backup table " + fm_plan.fm_sTableName + ": " + fm_sLastError)
fm_bStepResult = Faux
FIN
FIN

// Exécuter l'altération si backup OK
SI fm_bStepResult ALORS
fm_bStepResult = ExécuterSQL(fm_plan.fm_sSQL)

SI fm_bStepResult ALORS
fm_nSuccess++
fm_LogMessage("SUCCÈS: " + fm_plan.fm_sDescription)

// Enregistrer dans log BD
fm_GraverLogBD(fm_plan.fm_sTableName, fm_plan.fm_sSQL, fm_plan.fm_sDescription, "SUCCESS")
SINON
fm_nErrors++
fm_LogMessage("ERREUR: " + fm_plan.fm_sDescription + " - " + fm_sLastError)

// Enregistrer erreur dans log BD
fm_GraverLogBD(fm_plan.fm_sTableName, fm_plan.fm_sSQL, fm_plan.fm_sDescription, "ERROR: " + fm_sLastError)

// Arrêt si erreur critique
SI fm_plan.fm_nPriorité = 1 ALORS // Haute priorité
fm_bResult = Faux
SORTIR
FIN
FIN
SINON
fm_nErrors++
fm_bResult = Faux
FIN
FIN

// Validation ou rollback de la transaction
SI fm_bResult ALORS
HValideTransaction()
fm_LogMessage("=== PLAN APPLIQUÉ AVEC SUCCÈS ===")
fm_LogMessage("Succès: " + fm_nSuccess + ", Erreurs: " + fm_nErrors)
SINON
HAnnuleTransaction()
fm_LogMessage("=== PLAN ANNULÉ - ROLLBACK EFFECTUÉ ===")
fm_LogMessage("Succès: " + fm_nSuccess + ", Erreurs: " + fm_nErrors)
FIN

RENVOYER fm_bResult
```

FIN

// Graver log dans la base de données (Passo I)
PROCÉDURE fm_GraverLogBD(LOCAL fm_sTableName est une chaîne, LOCAL fm_sSQL est une chaîne, LOCAL fm_sDescription est une chaîne, LOCAL fm_sResultat est une chaîne)
LOCAL fm_sLogSQL est une chaîne
LOCAL fm_sTimestamp est une chaîne = DateSys() + “ “ + HeureSys()
LOCAL fm_sStation est une chaîne = PosteNom()
LOCAL fm_sIP est une chaîne = AdresseIP()

```
// Créer la table de log si elle n'existe pas
fm_CréerTableLogSiNécessaire()

// Échappement des chaînes pour éviter injection SQL
fm_sTableName = Remplace(fm_sTableName, "'", "''")
fm_sSQL = Remplace(fm_sSQL, "'", "''")
fm_sDescription = Remplace(fm_sDescription, "'", "''")
fm_sResultat = Remplace(fm_sResultat, "'", "''")
fm_sStation = Remplace(fm_sStation, "'", "''")

// Construction du SQL d'insertion
fm_sLogSQL = "INSERT INTO Filemanager_Log (DataHora, Estacao, IP, NomeTabela, ComandoSQL, Descricao, Resultado) " + ...
"VALUES ('" + fm_sTimestamp + "', '" + fm_sStation + "', '" + fm_sIP + "', '" + fm_sTableName + "', '" + fm_sSQL + "', '" + fm_sDescription + "', '" + fm_sResultat + "')"

// Exécution sans échec (log ne doit pas faire échouer le processus principal)
SI PAS HExécuteSQL(fm_sLogSQL, fm_nConnectionHandle) ALORS
fm_LogMessage("ATTENTION: Erreur lors de l'écriture du log BD: " + HErreurInfo())
FIN
```

FIN

// Processus complet de synchronisation (Passos A à J)
PROCÉDURE fm_SynchroniserComplet() : booléen
LOCAL fm_bResult est un booléen = Faux
LOCAL fm_arrComparisons est un tableau de stTableComparison
LOCAL fm_arrPlan est un tableau de stAlterationPlan

```
fm_LogMessage("=== DÉBUT SYNCHRONISATION COMPLÈTE ===")

// Passo A: Vérifier connexion
SI PAS fm_bConnected ALORS
SI PAS Connecter() ALORS
fm_sLastError = "Échec de connexion: " + fm_sLastError
RENVOYER Faux
FIN
FIN

// Passo B & C: Analyser structures
SI PAS AnalyserFichierAnalyse() ALORS
fm_sLastError = "Échec analyse WinDev: " + fm_sLastError
RENVOYER Faux
FIN

// Passo D: Comparer
fm_arrComparisons = fm_ComparerAnalyseAvecBase()
SI TableauOccurrence(fm_arrComparisons) = 0 ALORS
fm_LogMessage("Aucune différence détectée")
RENVOYER Vrai
FIN

// Passo E: Générer plan
fm_arrPlan = fm_GénérerPlanAltération(fm_arrComparisons)
SI TableauOccurrence(fm_arrPlan) = 0 ALORS
fm_LogMessage("Aucune altération nécessaire")
RENVOYER Vrai
FIN

// Confirmation utilisateur
SI Confirme("Appliquer " + TableauOccurrence(fm_arrPlan) + " modifications à la base de données ?") ALORS
// Passos F & G: Backup et application
fm_bResult = fm_AppliquerPlanAltération(fm_arrPlan)

// Passo H: Message final
SI fm_bResult ALORS
Info("Synchronisation terminée avec succès!" + RC + "Consultez le log pour les détails.")

// Passo J: Envoyer notification e-mail
fm_EnvoyerEmailNotification(fm_arrPlan, "SUCCESS")
SINON
Erreur("Erreur lors de la synchronisation:" + RC + fm_sLastError)

// Envoyer e-mail d'erreur
fm_EnvoyerEmailNotification(fm_arrPlan, "ERROR")
FIN
SINON
fm_LogMessage("Synchronisation annulée par l'utilisateur")
fm_bResult = Faux
FIN

fm_LogMessage("=== FIN SYNCHRONISATION COMPLÈTE ===")
RENVOYER fm_bResult
```

FIN

// ===== MÉTHODES AUXILIAIRES =====

// Obtenir tables de l’analyse WinDev
PROCÉDURE PRIVÉ fm_ObtenirTablesAnalyse() : tableau de chaînes
LOCAL fm_arrTables est un tableau de chaînes

```
// Simulation - dans la version réelle, parser le XML/JSON de l'analyse
TableauAjoute(fm_arrTables, "customers")
TableauAjoute(fm_arrTables, "orders")
TableauAjoute(fm_arrTables, "products")
TableauAjoute(fm_arrTables, "categories")

RENVOYER fm_arrTables
```

FIN

// Comparer champs d’une table
PROCÉDURE PRIVÉ fm_ComparerChamps(LOCAL fm_sTableName est une chaîne) : tableau de chaînes
LOCAL fm_arrDifferences est un tableau de chaînes

```
// Simulation - comparer structure analyse vs BD
TableauAjoute(fm_arrDifferences, "email VARCHAR(200)") // Changement taille
TableauAjoute(fm_arrDifferences, "ADD COLUMN phone VARCHAR(20)") // Nouveau champ

RENVOYER fm_arrDifferences
```

FIN

// Comparer index d’une table
PROCÉDURE PRIVÉ fm_ComparerIndex(LOCAL fm_sTableName est une chaîne) : tableau de chaînes
LOCAL fm_arrDifferences est un tableau de chaînes

```
// Simulation
TableauAjoute(fm_arrDifferences, "CREATE INDEX idx_email ON " + fm_sTableName + "(email)")

RENVOYER fm_arrDifferences
```

FIN

// Comparer constraints d’une table
PROCÉDURE PRIVÉ fm_ComparerConstraints(LOCAL fm_sTableName est une chaîne) : tableau de chaînes
LOCAL fm_arrDifferences est un tableau de chaînes

```
// Simulation
TableauAjoute(fm_arrDifferences, "ADD CONSTRAINT chk_email CHECK (email LIKE '%@%')")

RENVOYER fm_arrDifferences
```

FIN

// Générer SQL de création
PROCÉDURE PRIVÉ fm_GénérerSQLCréation(LOCAL fm_sTableName est une chaîne) : chaîne
// Simulation - générer CREATE TABLE basé sur l’analyse
RENVOYER “CREATE TABLE “ + fm_EscapeIdentifier(fm_sTableName) + “ (id INT PRIMARY KEY, nom VARCHAR(100))”
FIN

// Générer SQL d’altération
PROCÉDURE PRIVÉ fm_GénérerSQLAltération(LOCAL fm_sTableName est une chaîne, LOCAL fm_sFieldChange est une chaîne) : chaîne
// Parser le changement et générer ALTER TABLE approprié
SI Commence(fm_sFieldChange, “ADD COLUMN”) ALORS
RENVOYER “ALTER TABLE “ + fm_EscapeIdentifier(fm_sTableName) + “ “ + fm_sFieldChange
SINON
RENVOYER “ALTER TABLE “ + fm_EscapeIdentifier(fm_sTableName) + “ MODIFY COLUMN “ + fm_sFieldChange
FIN
FIN

// Générer SQL d’index
PROCÉDURE PRIVÉ fm_GénérerSQLIndex(LOCAL fm_sTableName est une chaîne, LOCAL fm_sIndexChange est une chaîne) : chaîne
RENVOYER fm_sIndexChange
FIN

// Créer table de log si nécessaire
PROCÉDURE PRIVÉ fm_CréerTableLogSiNécessaire()
LOCAL fm_sSQL est une chaîne

```
// Vérifier si la table existe
LOCAL fm_arrTables est un tableau de chaînes = ObtenirListeTables()
SI TableauCherche(fm_arrTables, "Filemanager_Log") > 0 ALORS
RENVOYER // Table existe déjà
FIN

// Créer la table de log
fm_sSQL = "CREATE TABLE Filemanager_Log (" + ...
"ID INT PRIMARY KEY " + ...
SELON fm_sDbType
CAS "mysql": "AUTO_INCREMENT"
CAS "postgresql": "GENERATED BY DEFAULT AS IDENTITY"
CAS "sqlserver": "IDENTITY(1,1)"
CAS "oracle": "GENERATED BY DEFAULT AS IDENTITY"
CAS "sqlite": "AUTOINCREMENT"
AUTRE CAS: ""
FIN + ", " + ...
"DataHora DATETIME NOT NULL, " + ...
"Estacao VARCHAR(100), " + ...
"IP VARCHAR(50), " + ...
"NomeTabela VARCHAR(100), " + ...
"ComandoSQL TEXT, " + ...
"Descricao VARCHAR(500), " + ...
"Resultado VARCHAR(1000)" + ...
")"

HExécuteSQL(fm_sSQL, fm_nConnectionHandle)
```

FIN

// Envoyer notification par e-mail (Passo J)
PROCÉDURE fm_EnvoyerEmailNotification(LOCAL fm_arrPlan est un tableau de stAlterationPlan, LOCAL fm_sStatut est une chaîne) : booléen
LOCAL fm_bResult est un booléen = Faux
LOCAL fm_sEmailDBA est une chaîne
LOCAL fm_sSubject est une chaîne
LOCAL fm_sBody est une chaîne
LOCAL fm_sTimestamp est une chaîne = DateSys() + “ “ + HeureSys()
LOCAL fm_i est un entier

```
// Configuration e-mail DBA (à personnaliser)
fm_sEmailDBA = "dba@empresa.com" // Configurer selon l'environnement

SI fm_sEmailDBA = "" ALORS
fm_LogMessage("ATTENTION: E-mail DBA non configuré")
RENVOYER Faux
FIN

// Construction du sujet
SI fm_sStatut = "SUCCESS" ALORS
fm_sSubject = "✅ Filemanager: Synchronisation réussie - " + fm_sDbType + " - " + DateSys()
SINON
fm_sSubject = "❌ Filemanager: ERREUR lors de la synchronisation - " + fm_sDbType + " - " + DateSys()
FIN

// Construction du corps de l'e-mail
fm_sBody = "" + RC
fm_sBody += "

Rapport Filemanager SQL V14

" + RC
fm_sBody += "

Timestamp: " + fm_sTimestamp + "

" + RC
fm_sBody += "

Estação: " + PosteNom() + " (" + AdresseIP() + ")

" + RC
fm_sBody += "

Base de données: " + fm_sDbType + "

" + RC
fm_sBody += "

Statut: " + fm_sStatut + "

" + RC
fm_sBody += "

---

" + RC

SI fm_sStatut = "SUCCESS" ALORS
fm_sBody += "

✅ Opérations exécutées avec succès:

" + RC
fm_sBody += "" + RC
fm_sBody += "" + RC
fm_sBody += "" + RC
fm_sBody += "" + RC
fm_sBody += "" + RC
fm_sBody += "" + RC
fm_sBody += "" + RC

POUR fm_i = 1 _À_ TableauOccurrence(fm_arrPlan)
LOCAL fm_plan est un stAlterationPlan = fm_arrPlan[fm_i]
fm_sBody += "" + RC
fm_sBody += "" + RC
fm_sBody += "" + RC
fm_sBody += "" + RC
fm_sBody += "" + RC
fm_sBody += "" + RC
FIN

fm_sBody += "

Table	Opération	Description	Priorité
" + fm_plan.fm_sTableName + "	" + Gauche(fm_plan.fm_sSQL, 50) + "...	" + fm_plan.fm_sDescription + "	" + (fm_plan.fm_nPriorité = 1 ? "HAUTE" : (fm_plan.fm_nPriorité = 2 ? "MOYENNE" : "BASSE")) + "

" + RC
fm_sBody += "

Total: " + TableauOccurrence(fm_arrPlan) + " opérations exécutées avec succès

" + RC

// Informations de sécurité
fm_sBody += "

🛡️ Mesures de sécurité appliquées:

" + RC
fm_sBody += "

" + RC
fm_sBody += "
• ✅ Backup automatique créé avant chaque modification
" + RC
fm_sBody += "
• ✅ Transaction globale avec rollback en cas d'erreur
" + RC
fm_sBody += "
• ✅ Validation de l'intégrité des backups
" + RC
fm_sBody += "
• ✅ Log complet dans la table Filemanager_Log
" + RC
fm_sBody += "
• ✅ Échappement SQL pour éviter injections
" + RC
fm_sBody += "

" + RC

SINON
fm_sBody += "

❌ Erreur détectée:

" + RC
fm_sBody += "

" + RC
fm_sBody += "Erreur: " + fm_sLastError + RC
fm_sBody += "

" + RC

fm_sBody += "

🔄 Actions de récupération:

" + RC
fm_sBody += "

" + RC
fm_sBody += "
• ✅ Rollback automatique effectué
" + RC
fm_sBody += "
• ✅ Base de données restaurée à l'état initial
" + RC
fm_sBody += "
• ⚠️ Vérifiez les logs pour plus de détails
" + RC
fm_sBody += "
• 🔧 Action manuelle requise du DBA
" + RC
fm_sBody += "

" + RC
FIN

// Informations système
fm_sBody += "

---

" + RC
fm_sBody += "

📊 Informations système:

" + RC
fm_sBody += "

" + RC
fm_sBody += "
• Version Filemanager: V14 Final
" + RC
fm_sBody += "
• SGBD: " + fm_sDbType + "
" + RC
fm_sBody += "
• Fichier de log: " + fm_sLogPath + "
" + RC
fm_sBody += "
• Chemin d'analyse: " + fm_sWinDevAnalysisPath + "
" + RC
fm_sBody += "

" + RC

// Recommandations
fm_sBody += "

---

" + RC
fm_sBody += "

💡 Recommandations:

" + RC
fm_sBody += "

" + RC

SI fm_sStatut = "SUCCESS" ALORS
fm_sBody += "
• ✅ Testez les applications utilisant les tables modifiées
" + RC
fm_sBody += "
• 📈 Surveillez les performances après les changements
" + RC
fm_sBody += "
• 🗃️ Les backups sont conservés avec suffixe _bkp_" + DateSys() + "
" + RC
fm_sBody += "
• 📋 Consultez la table Filemanager_Log pour l'audit complet
" + RC
SINON
fm_sBody += "
• 🔍 Analysez les logs détaillés dans " + fm_sLogPath + "
" + RC
fm_sBody += "
• 🔧 Vérifiez la configuration de la base de données
" + RC
fm_sBody += "
• 📞 Contactez l'équipe de développement si nécessaire
" + RC
fm_sBody += "
• ⚠️ Ne tentez pas de nouvelles synchronisations avant résolution
" + RC
FIN

fm_sBody += "

" + RC
fm_sBody += "

---

" + RC
fm_sBody += "

" + RC
fm_sBody += "E-mail automatique généré par Filemanager SQL V14
" + RC
fm_sBody += "Pour désactiver ces notifications, modifiez la configuration dans la classe Filemanager" + RC
fm_sBody += "

" + RC
fm_sBody += ""

// Tentative d'envoi via WinDev (EmailEnvoieMessage)
SI EmailDémarreSession("", "", "", "", "smtp.empresa.com", 587, Vrai, "sender@empresa.com", "password") ALORS
LOCAL fm_stEmail est un Email

fm_stEmail.Destinataire[1] = fm_sEmailDBA
fm_stEmail.Sujet = fm_sSubject
fm_stEmail.CorpsHTML = fm_sBody
fm_stEmail.Expéditeur = "filemanager@empresa.com"
fm_stEmail.NomExpéditeur = "Filemanager SQL V14"

SI EmailEnvoieMessage(fm_stEmail) ALORS
fm_bResult = Vrai
fm_LogMessage("E-mail de notification envoyé avec succès à " + fm_sEmailDBA)
SINON
fm_LogMessage("ERREUR envoi e-mail: " + ErreurInfo())
FIN

EmailFermeSession()
SINON
fm_LogMessage("ERREUR connexion SMTP: " + ErreurInfo())

// Fallback: tenter via ligne de commande ou API REST
fm_bResult = fm_EnvoyerEmailViaCURL(fm_sEmailDBA, fm_sSubject, fm_sBody)
FIN

RENVOYER fm_bResult
```

FIN

// Fallback pour envoi d’e-mail via cURL ou API REST
PROCÉDURE PRIVÉ fm_EnvoyerEmailViaCURL(LOCAL fm_sDestinataire est une chaîne, LOCAL fm_sSubject est une chaîne, LOCAL fm_sBody est une chaîne) : booléen
LOCAL fm_sJSONPayload est une chaîne
LOCAL fm_sCommand est une chaîne
LOCAL fm_bResult est un booléen = Faux

```
// Configuration pour service e-mail REST (ex: SendGrid, Mailgun, etc.)
fm_sJSONPayload = "{" + RC + ...
" ""to"": """ + fm_sDestinataire + """," + RC + ...
" ""from"": ""filemanager@empresa.com""," + RC + ...
" ""subject"": """ + Remplace(fm_sSubject, """", "\""") + """," + RC + ...
" ""html"": """ + Remplace(fm_sBody, """", "\""") + """" + RC + ...
"}"

// Sauvegarder JSON dans fichier temporaire
LOCAL fm_sTempFile est une chaîne = fRepTmp() + "\filemanager_email.json"
fSauveTexte(fm_sTempFile, fm_sJSONPayload)

// Commande cURL (adapter selon votre service e-mail)
fm_sCommand = "curl -X POST " + ...
"https://api.sendgrid.v3/mail/send " + ...
"-H ""Authorization: Bearer YOUR_API_KEY"" " + ...
"-H ""Content-Type: application/json"" " + ...
"-d @" + fm_sTempFile

// Exécuter commande (silencieusement)
LOCAL fm_nReturnCode est un entier = LanceAppli(fm_sCommand, LAAucun)

SI fm_nReturnCode = 0 ALORS
fm_bResult = Vrai
fm_LogMessage("E-mail envoyé via API REST")
SINON
fm_LogMessage("ERREUR envoi e-mail via API REST: code " + fm_nReturnCode)
FIN

// Nettoyer fichier temporaire
fSupprime(fm_sTempFile)

RENVOYER fm_bResult
```

FIN


——-



// ===== CONFIGURAÇÃO DE E-MAIL PARA FILEMANAGER V14 =====
// Adicionar na classe Filemanager - Atributos privados

// Atributos para configuração de e-mail
fm_sEmailDBA est une chaîne = “dba@empresa.com”
fm_sSMTPServer est une chaîne = “smtp.empresa.com”
fm_nSMTPPort est un entier = 587
fm_bSMTPSSL est un booléen = Vrai
fm_sEmailSender est une chaîne = “filemanager@empresa.com”
fm_sEmailPassword est une chaîne = “” // Encriptado
fm_bEmailEnabled est un booléen = Vrai
fm_sEmailAPIKey est une chaîne = “” // Para SendGrid/Mailgun
fm_sEmailAPIURL est une chaîne = “https://api.sendgrid.v3/mail/send”

// ===== MÉTODO PARA CONFIGURAÇÃO DE E-MAIL =====

// Configurar parametros de e-mail
PROCÉDURE fm_ConfigurerEmail(
LOCAL fm_sEmailDBA est une chaîne,
LOCAL fm_sSMTPServer est une chaîne = “smtp.gmail.com”,
LOCAL fm_nSMTPPort est un entier = 587,
LOCAL fm_sEmailSender est une chaîne = “”,
LOCAL fm_sEmailPassword est une chaîne = “”,
LOCAL fm_bSSL est un booléen = Vrai
)
SELF.fm_sEmailDBA = fm_sEmailDBA
SELF.fm_sSMTPServer = fm_sSMTPServer
SELF.fm_nSMTPPort = fm_nSMTPPort
SELF.fm_sEmailSender = fm_sEmailSender
SELF.fm_sEmailPassword = fm_EncryptPassword(fm_sEmailPassword)
SELF.fm_bSMTPSSL = fm_bSSL
SELF.fm_bEmailEnabled = (fm_sEmailDBA <> “”)

```
fm_LogMessage("Configuration e-mail mise à jour - DBA: " + fm_sEmailDBA + " - SMTP: " + fm_sSMTPServer)
```

FIN

// Configurar API de e-mail (SendGrid, Mailgun, etc.)
PROCÉDURE fm_ConfigurerEmailAPI(
LOCAL fm_sEmailDBA est une chaîne,
LOCAL fm_sAPIKey est une chaîne,
LOCAL fm_sAPIURL est une chaîne = “https://api.sendgrid.v3/mail/send”
)
SELF.fm_sEmailDBA = fm_sEmailDBA
SELF.fm_sEmailAPIKey = fm_sAPIKey
SELF.fm_sEmailAPIURL = fm_sAPIURL
SELF.fm_bEmailEnabled = (fm_sEmailDBA <> “” ET fm_sAPIKey <> “”)

```
fm_LogMessage("Configuration API e-mail mise à jour - DBA: " + fm_sEmailDBA + " - API: " + fm_sAPIURL)
```

FIN

// Desabilitar notificações por e-mail
PROCÉDURE fm_DesabiliterEmail()
fm_bEmailEnabled = Faux
fm_LogMessage(“Notifications e-mail désactivées”)
FIN

// ===== TEMPLATES DE E-MAIL PERSONALIZÁVEIS =====

// Template HTML para e-mail de sucesso
PROCÉDURE PRIVÉ fm_GerarTemplateEmailSucesso(
LOCAL fm_arrPlan est un tableau de stAlterationPlan,
LOCAL fm_sTimestamp est une chaîne
) : chaîne
LOCAL fm_sTemplate est une chaîne
LOCAL fm_i est un entier

```
fm_sTemplate = "" + RC + ...
"" + RC + ...
"" + RC + ...
" " + RC + ...
" " + RC + ...
" " + RC + ...
" " + RC + ...
"" + RC + ...
"" + RC + ...
" " + RC + ...
"" + RC + ...
""

RENVOYER fm_sTemplate
```

FIN

// Template HTML para e-mail de erro
PROCÉDURE PRIVÉ fm_GerarTemplateEmailErro(
LOCAL fm_arrPlan est un tableau de stAlterationPlan,
LOCAL fm_sTimestamp est une chaîne,
LOCAL fm_sErrorDetails est une chaîne
) : chaîne
LOCAL fm_sTemplate est une chaîne

```
fm_sTemplate = "" + RC + ...
"" + RC + ...
"" + RC + ...
" " + RC + ...
" " + RC + ...
" " + RC + ...
" " + RC + ...
"" + RC + ...
"" + RC + ...
" " + RC + ...
"" + RC + ...
""

RENVOYER fm_sTemplate
```

FIN

// ===== MÉTODOS AUXILIARES =====

// Detectar tipo de operação baseado no SQL
PROCÉDURE PRIVÉ fm_DetecterTypeOperation(LOCAL fm_sSQL est une chaîne) : chaîne
LOCAL fm_sSQLUpper est une chaîne = Majuscule(SansEspace(fm_sSQL, sscDébut))

```
SI Commence(fm_sSQLUpper, "CREATE TABLE") ALORS
RENVOYER "CREATE TABLE"
SINON SI Commence(fm_sSQLUpper, "ALTER TABLE") ALORS
RENVOYER "ALTER TABLE"
SINON SI Commence(fm_sSQLUpper, "DROP TABLE") ALORS
RENVOYER "DROP TABLE"
SINON SI Commence(fm_sSQLUpper, "CREATE INDEX") ALORS
RENVOYER "CREATE INDEX"
SINON SI Commence(fm_sSQLUpper, "DROP INDEX") ALORS
RENVOYER "DROP INDEX"
SINON
RENVOYER "OTHER"
FIN
```

FIN

// Chiffrement simple du mot de passe e-mail
PROCÉDURE PRIVÉ fm_EncryptPassword(LOCAL fm_sPassword est une chaîne) : chaîne
// Implémentation simple XOR (à remplacer par algo plus robuste en production)
LOCAL fm_sEncrypted est une chaîne = “”
LOCAL fm_i est un entier

```
POUR fm_i = 1 _À_ Taille(fm_sPassword)
LOCAL fm_nChar est un entier = Asc(fm_sPassword[[fm_i]])
LOCAL fm_nKey est un entier = Asc(fm_sEncryptionKey[[(fm_i % Taille(fm_sEncryptionKey)) + 1]])
fm_sEncrypted += Car(fm_nChar ~ fm_nKey)
FIN

RENVOYER fm_sEncrypted
```

FIN

// Déchiffrement du mot de passe e-mail
PROCÉDURE PRIVÉ fm_DecryptPassword(LOCAL fm_sEncrypted est une chaîne) : chaîne
// Même algorithme que le chiffrement (XOR est réversible)
RENVOYER fm_EncryptPassword(fm_sEncrypted)
FIN

// ===== EXEMPLE D’UTILISATION =====

// Configuration complète dans le constructeur ou méthode d’initialisation
PROCÉDURE ExempleConfigurationEmail()
LOCAL fm_oFilemanager est un Filemanager

```
// Initialiser Filemanager
fm_oFilemanager = allouer un Filemanager("connection_string", "mysql", "analysis.wdd")

// Option 1: Configuration SMTP classique
fm_oFilemanager.fm_ConfigurerEmail(
"dba@empresa.com", // E-mail DBA
"smtp.gmail.com", // Serveur SMTP
587, // Port
"filemanager@empresa.com", // E-mail expéditeur
"app_password_gmail", // Mot de passe d'application
Vrai // SSL activé
)

// Option 2: Configuration via API (SendGrid, Mailgun, etc.)
fm_oFilemanager.fm_ConfigurerEmailAPI(
"dba@empresa.com", // E-mail DBA
"SG.xxxxxxxxxx.yyyyyyyyyy", // Clé API SendGrid
"https://api.sendgrid.v3/mail/send" // URL API
)

// Option 3: Désactiver notifications
// fm_oFilemanager.fm_DesabiliterEmail()

// Connecter et synchroniser
SI fm_oFilemanager.Connecter() ALORS
fm_oFilemanager.fm_SynchroniserComplet() // E-mail sera envoyé automatiquement
fm_oFilemanager.Déconnecter()
FIN

libérer fm_oFilemanager
```

FIN


————


// ===== CONFIGURAÇÃO DE E-MAIL PARA FILEMANAGER V14 =====
// Adicionar na classe Filemanager - Atributos privados

// Atributos para configuração de e-mail
fm_sEmailDBA est une chaîne = “dba@empresa.com”
fm_sSMTPServer est une chaîne = “smtp.empresa.com”
fm_nSMTPPort est un entier = 587
fm_bSMTPSSL est un booléen = Vrai
fm_sEmailSender est une chaîne = “filemanager@empresa.com”
fm_sEmailPassword est une chaîne = “” // Encriptado
fm_bEmailEnabled est un booléen = Vrai
fm_sEmailAPIKey est une chaîne = “” // Para SendGrid/Mailgun
fm_sEmailAPIURL est une chaîne = “https://api.sendgrid.v3/mail/send”

// ===== MÉTODO PARA CONFIGURAÇÃO DE E-MAIL =====

// Configurar parametros de e-mail
PROCÉDURE fm_ConfigurerEmail(
LOCAL fm_sEmailDBA est une chaîne,
LOCAL fm_sSMTPServer est une chaîne = “smtp.gmail.com”,
LOCAL fm_nSMTPPort est un entier = 587,
LOCAL fm_sEmailSender est une chaîne = “”,
LOCAL fm_sEmailPassword est une chaîne = “”,
LOCAL fm_bSSL est un booléen = Vrai
)
SELF.fm_sEmailDBA = fm_sEmailDBA
SELF.fm_sSMTPServer = fm_sSMTPServer
SELF.fm_nSMTPPort = fm_nSMTPPort
SELF.fm_sEmailSender = fm_sEmailSender
SELF.fm_sEmailPassword = fm_EncryptPassword(fm_sEmailPassword)
SELF.fm_bSMTPSSL = fm_bSSL
SELF.fm_bEmailEnabled = (fm_sEmailDBA <> “”)

```
fm_LogMessage("Configuration e-mail mise à jour - DBA: " + fm_sEmailDBA + " - SMTP: " + fm_sSMTPServer)
```

FIN

// Configurar API de e-mail (SendGrid, Mailgun, etc.)
PROCÉDURE fm_ConfigurerEmailAPI(
LOCAL fm_sEmailDBA est une chaîne,
LOCAL fm_sAPIKey est une chaîne,
LOCAL fm_sAPIURL est une chaîne = “https://api.sendgrid.v3/mail/send”
)
SELF.fm_sEmailDBA = fm_sEmailDBA
SELF.fm_sEmailAPIKey = fm_sAPIKey
SELF.fm_sEmailAPIURL = fm_sAPIURL
SELF.fm_bEmailEnabled = (fm_sEmailDBA <> “” ET fm_sAPIKey <> “”)

```
fm_LogMessage("Configuration API e-mail mise à jour - DBA: " + fm_sEmailDBA + " - API: " + fm_sAPIURL)
```

FIN

// Desabilitar notificações por e-mail
PROCÉDURE fm_DesabiliterEmail()
fm_bEmailEnabled = Faux
fm_LogMessage(“Notifications e-mail désactivées”)
FIN

// ===== TEMPLATES DE E-MAIL PERSONALIZÁVEIS =====

// Template HTML para e-mail de sucesso
PROCÉDURE PRIVÉ fm_GerarTemplateEmailSucesso(
LOCAL fm_arrPlan est un tableau de stAlterationPlan,
LOCAL fm_sTimestamp est une chaîne
) : chaîne
LOCAL fm_sTemplate est une chaîne
LOCAL fm_i est un entier

```
fm_sTemplate = "" + RC + ...
"" + RC + ...
"" + RC + ...
" " + RC + ...
" " + RC + ...
" " + RC + ...
" " + RC + ...
"" + RC + ...
"" + RC + ...
" " + RC + ...
"" + RC + ...
""

RENVOYER fm_sTemplate
```

FIN

// Template HTML para e-mail de erro
PROCÉDURE PRIVÉ fm_GerarTemplateEmailErro(
LOCAL fm_arrPlan est un tableau de stAlterationPlan,
LOCAL fm_sTimestamp est une chaîne,
LOCAL fm_sErrorDetails est une chaîne
) : chaîne
LOCAL fm_sTemplate est une chaîne

```
fm_sTemplate = "" + RC + ...
"" + RC + ...
"" + RC + ...
" " + RC + ...
" " + RC + ...
" " + RC + ...
" " + RC + ...
"" + RC + ...
"" + RC + ...
" " + RC + ...
"" + RC + ...
""

RENVOYER fm_sTemplate
```

FIN

// ===== MÉTODOS AUXILIARES =====

// Detectar tipo de operação baseado no SQL
PROCÉDURE PRIVÉ fm_DetecterTypeOperation(LOCAL fm_sSQL est une chaîne) : chaîne
LOCAL fm_sSQLUpper est une chaîne = Majuscule(SansEspace(fm_sSQL, sscDébut))

```
SI Commence(fm_sSQLUpper, "CREATE TABLE") ALORS
RENVOYER "CREATE TABLE"
SINON SI Commence(fm_sSQLUpper, "ALTER TABLE") ALORS
RENVOYER "ALTER TABLE"
SINON SI Commence(fm_sSQLUpper, "DROP TABLE") ALORS
RENVOYER "DROP TABLE"
SINON SI Commence(fm_sSQLUpper, "CREATE INDEX") ALORS
RENVOYER "CREATE INDEX"
SINON SI Commence(fm_sSQLUpper, "DROP INDEX") ALORS
RENVOYER "DROP INDEX"
SINON
RENVOYER "OTHER"
FIN
```

FIN

// Chiffrement simple du mot de passe e-mail
PROCÉDURE PRIVÉ fm_EncryptPassword(LOCAL fm_sPassword est une chaîne) : chaîne
// Implémentation simple XOR (à remplacer par algo plus robuste en production)
LOCAL fm_sEncrypted est une chaîne = “”
LOCAL fm_i est un entier

```
POUR fm_i = 1 _À_ Taille(fm_sPassword)
LOCAL fm_nChar est un entier = Asc(fm_sPassword[[fm_i]])
LOCAL fm_nKey est un entier = Asc(fm_sEncryptionKey[[(fm_i % Taille(fm_sEncryptionKey)) + 1]])
fm_sEncrypted += Car(fm_nChar ~ fm_nKey)
FIN

RENVOYER fm_sEncrypted
```

FIN

// Déchiffrement du mot de passe e-mail
PROCÉDURE PRIVÉ fm_DecryptPassword(LOCAL fm_sEncrypted est une chaîne) : chaîne
// Même algorithme que le chiffrement (XOR est réversible)
RENVOYER fm_EncryptPassword(fm_sEncrypted)
FIN

// ===== EXEMPLE D’UTILISATION =====

// Configuration complète dans le constructeur ou méthode d’initialisation
PROCÉDURE ExempleConfigurationEmail()
LOCAL fm_oFilemanager est un Filemanager

```
// Initialiser Filemanager
fm_oFilemanager = allouer un Filemanager("connection_string", "mysql", "analysis.wdd")

// Option 1: Configuration SMTP classique
fm_oFilemanager.fm_ConfigurerEmail(
"dba@empresa.com", // E-mail DBA
"smtp.gmail.com", // Serveur SMTP
587, // Port
"filemanager@empresa.com", // E-mail expéditeur
"app_password_gmail", // Mot de passe d'application
Vrai // SSL activé
)

// Option 2: Configuration via API (SendGrid, Mailgun, etc.)
fm_oFilemanager.fm_ConfigurerEmailAPI(
"dba@empresa.com", // E-mail DBA
"SG.xxxxxxxxxx.yyyyyyyyyy", // Clé API SendGrid
"https://api.sendgrid.v3/mail/send" // URL API
)

// Option 3: Désactiver notifications
// fm_oFilemanager.fm_DesabiliterEmail()

// Connecter et synchroniser
SI fm_oFilemanager.Connecter() ALORS
fm_oFilemanager.fm_SynchroniserComplet() // E-mail sera envoyé automatiquement
fm_oFilemanager.Déconnecter()
FIN

libérer fm_oFilemanager
```

FIN

// ===== MÉTODOS COMPLEMENTARES ADICIONAIS - FILEMANAGER V15.1 =====
// Métodos específicos para cada SGBD e funcionalidades avançadas
// Data: 05/07/2025 - Complemento final para parametrização

// ===== DETECÇÃO AUTOMÁTICA DE SGBD =====

// Detectar tipo de SGBD pela connection string
PROCÉDURE fm_DetectarSGBD(LOCAL fm_sConnectionString est une chaîne) : chaîne
LOCAL fm_sDetectedType est une chaîne = “”
LOCAL fm_sConnUpper est une chaîne = Majuscule(fm_sConnectionString)

```
// MySQL
SI Contient(fm_sConnUpper, "MYSQL") OU Contient(fm_sConnUpper, "SERVER=") ET Contient(fm_sConnUpper, "DATABASE=") ALORS
fm_sDetectedType = "mysql"

// PostgreSQL
SINON SI Contient(fm_sConnUpper, "HOST=") ET Contient(fm_sConnUpper, "DBNAME=") OU Contient(fm_sConnUpper, "POSTGRES") ALORS
fm_sDetectedType = "postgresql"

// SQL Server
SINON SI Contient(fm_sConnUpper, "DATA SOURCE=") OU Contient(fm_sConnUpper, "SQLSERVER") OU Contient(fm_sConnUpper, "INTEGRATED SECURITY") ALORS
fm_sDetectedType = "sqlserver"

// Oracle
SINON SI Contient(fm_sConnUpper, "ORACLE") OU Contient(fm_sConnUpper, "ORA") OU Contient(fm_sConnUpper, "TNSNAME") ALORS
fm_sDetectedType = "oracle"

// SQLite
SINON SI Contient(fm_sConnUpper, ".DB") OU Contient(fm_sConnUpper, ".SQLITE") OU Contient(fm_sConnUpper, "DATA SOURCE=") ET Contient(fm_sConnUpper, ".") ALORS
fm_sDetectedType = "sqlite"

// Firebird
SINON SI Contient(fm_sConnUpper, "FIREBIRD") OU Contient(fm_sConnUpper, ".FDB") OU Contient(fm_sConnUpper, ".GDB") ALORS
fm_sDetectedType = "firebird"

// DB2
SINON SI Contient(fm_sConnUpper, "DB2") OU Contient(fm_sConnUpper, "AS400") ALORS
fm_sDetectedType = "db2"

// Sybase
SINON SI Contient(fm_sConnUpper, "SYBASE") OU Contient(fm_sConnUpper, "ASE") ALORS
fm_sDetectedType = "sybase"

// Teradata
SINON SI Contient(fm_sConnUpper, "TERADATA") OU Contient(fm_sConnUpper, "TDPID") ALORS
fm_sDetectedType = "teradata"
FIN

SI fm_sDetectedType <> "" ALORS
fm_LogMessage("🔍 SGBD detectado automaticamente: " + Majuscule(fm_sDetectedType))
SINON
fm_LogMessage("⚠️ Não foi possível detectar o SGBD automaticamente")
FIN

RENVOYER fm_sDetectedType
```

FIN

// ===== CONFIGURAÇÕES ESPECÍFICAS POR SGBD =====

// Aplicar configurações específicas do MySQL
PROCÉDURE PRIVÉ fm_ConfigurarMySQL()
// Configurações otimizadas para MySQL
fm_oConfig.fm_nTimeoutSeconds = 300
fm_oConfig.fm_nMaxTableSize = 2000 // 2GB para MySQL

```
// Tabelas de sistema MySQL a ignorar
LOCAL fm_arrMySQLSystemTables est un tableau de chaînes = [
"information_schema.*", "mysql.*", "performance_schema.*", "sys.*"
]

// Adicionar às tabelas excluídas
LOCAL fm_i est un entier
POUR fm_i = 1 _À_ TableauOccurrence(fm_arrMySQLSystemTables)
SI TableauCherche(fm_oConfig.fm_arrExcludeTables, fm_arrMySQLSystemTables[fm_i]) = -1 ALORS
TableauAjoute(fm_oConfig.fm_arrExcludeTables, fm_arrMySQLSystemTables[fm_i])
FIN
FIN

fm_LogMessage("🐬 Configurações específicas MySQL aplicadas")
```

FIN

// Aplicar configurações específicas do PostgreSQL
PROCÉDURE PRIVÉ fm_ConfigurarPostgreSQL()
fm_oConfig.fm_nTimeoutSeconds = 600 // PostgreSQL pode ser mais lento
fm_oConfig.fm_nMaxTableSize = 5000 // 5GB para PostgreSQL

```
LOCAL fm_arrPgSystemTables est un tableau de chaînes = [
"information_schema.*", "pg_catalog.*", "pg_toast.*"
]

LOCAL fm_i est un entier
POUR fm_i = 1 _À_ TableauOccurrence(fm_arrPgSystemTables)
SI TableauCherche(fm_oConfig.fm_arrExcludeTables, fm_arrPgSystemTables[fm_i]) = -1 ALORS
TableauAjoute(fm_oConfig.fm_arrExcludeTables, fm_arrPgSystemTables[fm_i])
FIN
FIN

fm_LogMessage("🐘 Configurações específicas PostgreSQL aplicadas")
```

FIN

// Aplicar configurações específicas do SQL Server
PROCÉDURE PRIVÉ fm_ConfigurarSQLServer()
fm_oConfig.fm_nTimeoutSeconds = 900 // SQL Server pode precisar mais tempo
fm_oConfig.fm_nMaxTableSize = 10000 // 10GB para SQL Server

```
LOCAL fm_arrSQLServerSystemTables est un tableau de chaînes = [
"sys.*", "INFORMATION_SCHEMA.*", "master.*", "msdb.*", "tempdb.*", "model.*"
]

LOCAL fm_i est un entier
POUR fm_i = 1 _À_ TableauOccurrence(fm_arrSQLServerSystemTables)
SI TableauCherche(fm_oConfig.fm_arrExcludeTables, fm_arrSQLServerSystemTables[fm_i]) = -1 ALORS
TableauAjoute(fm_oConfig.fm_arrExcludeTables, fm_arrSQLServerSystemTables[fm_i])
FIN
FIN

fm_LogMessage("🏢 Configurações específicas SQL Server aplicadas")
```

FIN

// Aplicar configurações específicas do Firebird
PROCÉDURE PRIVÉ fm_ConfigurarFirebird()
fm_oConfig.fm_nTimeoutSeconds = 300
fm_oConfig.fm_nMaxTableSize = 1000 // Firebird tem limitações de tamanho

```
LOCAL fm_arrFirebirdSystemTables est un tableau de chaînes = [
"RDB$*", "MON$*"
]

LOCAL fm_i est un entier
POUR fm_i = 1 _À_ TableauOccurrence(fm_arrFirebirdSystemTables)
SI TableauCherche(fm_oConfig.fm_arrExcludeTables, fm_arrFirebirdSystemTables[fm_i]) = -1 ALORS
TableauAjoute(fm_oConfig.fm_arrExcludeTables, fm_arrFirebirdSystemTables[fm_i])
FIN
FIN

fm_LogMessage("🔥 Configurações específicas Firebird aplicadas")
```

FIN

// ===== VALIDAÇÕES ESPECÍFICAS POR SGBD =====

// Validar connection string específica
PROCÉDURE fm_ValidarConnectionString(LOCAL fm_sConnString est une chaîne, LOCAL fm_sDbType est une chaîne) : booléen
LOCAL fm_bValid est un booléen = Vrai
LOCAL fm_sError est une chaîne = “”

```
SELON Minuscule(fm_sDbType)
CAS "mysql"
SI PAS Contient(Majuscule(fm_sConnString), "SERVER=") ALORS
fm_sError = "MySQL: SERVER= não encontrado na connection string"
fm_bValid = Faux
FIN
SI PAS Contient(Majuscule(fm_sConnString), "DATABASE=") ALORS
fm_sError = "MySQL: DATABASE= não encontrado na connection string"
fm_bValid = Faux
FIN

CAS "postgresql"
SI PAS Contient(Majuscule(fm_sConnString), "HOST=") ALORS
fm_sError = "PostgreSQL: HOST= não encontrado na connection string"
fm_bValid = Faux
FIN
SI PAS Contient(Majuscule(fm_sConnString), "DATABASE=") ET PAS Contient(Majuscule(fm_sConnString), "DBNAME=") ALORS
fm_sError = "PostgreSQL: DATABASE= ou DBNAME= não encontrado"
fm_bValid = Faux
FIN

CAS "sqlserver"
SI PAS Contient(Majuscule(fm_sConnString), "DATA SOURCE=") ET PAS Contient(Majuscule(fm_sConnString), "SERVER=") ALORS
fm_sError = "SQL Server: DATA SOURCE= ou SERVER= não encontrado"
fm_bValid = Faux
FIN

CAS "oracle"
SI PAS Contient(Majuscule(fm_sConnString), "DATA SOURCE=") ET PAS Contient(Majuscule(fm_sConnString), "TNS") ALORS
fm_sError = "Oracle: DATA SOURCE= ou TNS não encontrado"
fm_bValid = Faux
FIN

CAS "sqlite"
SI PAS Contient(Majuscule(fm_sConnString), "DATA SOURCE=") ALORS
fm_sError = "SQLite: DATA SOURCE= não encontrado"
fm_bValid = Faux
FIN

CAS "firebird"
SI PAS Contient(Majuscule(fm_sConnString), "DATABASE=") ET PAS Contient(fm_sConnString, ".fdb") ET PAS Contient(fm_sConnString, ".gdb") ALORS
fm_sError = "Firebird: DATABASE= ou arquivo .fdb/.gdb não encontrado"
fm_bValid = Faux
FIN
FIN

SI PAS fm_bValid ALORS
fm_sLastError = fm_sError
fm_LogMessage("❌ " + fm_sError)
SINON
fm_LogMessage("✅ Connection string válida para " + Majuscule(fm_sDbType))
FIN

RENVOYER fm_bValid
```

FIN

// ===== MÉTODOS DE CONFIGURAÇÃO AUTOMÁTICA =====

// Configuração automática baseada no SGBD detectado
PROCÉDURE fm_ConfiguracaoAutomatica(LOCAL fm_sConnectionString est une chaîne, LOCAL fm_sAnalysisPath est une chaîne) : booléen
LOCAL fm_sDetectedDB est une chaîne
LOCAL fm_bResult est un booléen = Faux

```
// Detectar SGBD automaticamente
fm_sDetectedDB = fm_DetectarSGBD(fm_sConnectionString)

SI fm_sDetectedDB = "" ALORS
fm_sLastError = "Não foi possível detectar o tipo de SGBD. Especifique manualmente."
RENVOYER Faux
FIN

// Parametrização básica
fm_bResult = fm_Parametrizar(
fm_sConnectionString,
fm_sDetectedDB,
fm_sAnalysisPath,
"pt", // Português padrão
Vrai, // Backup habilitado
Faux, // DROP não permitido por segurança
Vrai // Confirmação obrigatória
)

SI fm_bResult ALORS
// Aplicar configurações específicas do SGBD
SELON fm_sDetectedDB
CAS "mysql": fm_ConfigurarMySQL()
CAS "postgresql": fm_ConfigurarPostgreSQL()
CAS "sqlserver": fm_ConfigurarSQLServer()
CAS "firebird": fm_ConfigurarFirebird()
// Outros SGBDs usam configuração padrão
FIN

fm_LogMessage("🤖 Configuração automática concluída para " + Majuscule(fm_sDetectedDB))
FIN

RENVOYER fm_bResult
```

FIN

// ===== MÉTODOS DE BACKUP AVANÇADO =====

// Configurar estratégia de backup baseada no tamanho da base
PROCÉDURE fm_ConfigurarBackupInteligente() : booléen
LOCAL fm_bResult est un booléen = Vrai
LOCAL fm_nTotalSize est un entier = 0

```
SI PAS fm_bConnected ALORS
SI PAS Connecter() ALORS
RENVOYER Faux
FIN
FIN

// Calcular tamanho total da base de dados
fm_nTotalSize = fm_CalcularTamanhoBaseDados()

// Ajustar estratégia baseada no tamanho
SI fm_nTotalSize < 100 ALORS // Menos de 100MB
fm_oConfig.fm_bCompressBackup = Faux
fm_oConfig.fm_sBackupPrefix = "small_bkp_"
fm_LogMessage("📦 Backup simples configurado (base < 100MB)")

SINON SI fm_nTotalSize < 1000 ALORS // Entre 100MB e 1GB
fm_oConfig.fm_bCompressBackup = Vrai
fm_oConfig.fm_sBackupPrefix = "medium_bkp_"
fm_LogMessage("📦 Backup comprimido configurado (base < 1GB)")

SINON // Maior que 1GB
fm_oConfig.fm_bCompressBackup = Vrai
fm_oConfig.fm_sBackupPrefix = "large_bkp_"
// Para bases grandes, considerar backup seletivo
fm_LogMessage("📦 Backup otimizado configurado (base > 1GB)")
fm_LogMessage("⚠️ Considerando backup seletivo para melhor performance")
FIN

RENVOYER fm_bResult
```

FIN

// Calcular tamanho total da base de dados
PROCÉDURE PRIVÉ fm_CalcularTamanhoBaseDados() : entier
LOCAL fm_nTotalSize est un entier = 0
LOCAL fm_sSQL est une chaîne

```
// SQL específico por SGBD para calcular tamanho
SELON fm_oConfig.fm_sDbType
CAS "mysql"
fm_sSQL = "SELECT ROUND(SUM(data_length + index_length) / 1024 / 1024, 1) AS 'size_mb' " + ...
"FROM information_schema.TABLES WHERE table_schema = DATABASE()"

CAS "postgresql"
fm_sSQL = "SELECT pg_size_pretty(pg_database_size(current_database()))"

CAS "sqlserver"
fm_sSQL = "SELECT SUM(size) * 8 / 1024 AS size_mb FROM sys.database_files"

CAS "sqlite"
// Para SQLite, usar tamanho do arquivo
fm_nTotalSize = fTaille(fm_ExtrairNomeArquivoSQLite()) / 1024 / 1024
RENVOYER fm_nTotalSize

CAS "firebird"
// Para Firebird, usar tamanho do arquivo .fdb
fm_nTotalSize = fTaille(fm_ExtrairNomeArquivoFirebird()) / 1024 / 1024
RENVOYER fm_nTotalSize

AUTRE CAS
// Para outros SGBDs, estimar baseado no número de tabelas
fm_nTotalSize = 100 // Estimativa padrão de 100MB
RENVOYER fm_nTotalSize
FIN

// Executar query e obter resultado
SI HExécuteRequêteSQL(fm_sSQL, hRequêteDefaut, fm_nConnectionHandle) ALORS
SI HLitPremier() ALORS
fm_nTotalSize = HLitColonne(1)
FIN
HAnnuleRequête()
FIN

fm_LogMessage("📊 Tamanho da base calculado: " + fm_nTotalSize + "MB")

RENVOYER fm_nTotalSize
```

FIN

// ===== MÉTODOS DE VALIDAÇÃO AVANÇADA =====

// Validar versão mínima do SGBD
PROCÉDURE fm_ValidarVersaoSGBD() : booléen
LOCAL fm_bValid est un booléen = Vrai
LOCAL fm_sVersion est une chaîne
LOCAL fm_sSQL est une chaîne

```
SI PAS fm_bConnected ALORS
RENVOYER Vrai // Não pode validar sem conexão
FIN

// SQL específico para obter versão
SELON fm_oConfig.fm_sDbType
CAS "mysql"
fm_sSQL = "SELECT VERSION()"

CAS "postgresql"
fm_sSQL = "SELECT version()"

CAS "sqlserver"
fm_sSQL = "SELECT @@VERSION"

CAS "oracle"
fm_sSQL = "SELECT * FROM v$version WHERE banner LIKE 'Oracle%'"

CAS "firebird"
fm_sSQL = "SELECT rdb$get_context('SYSTEM', 'ENGINE_VERSION') FROM rdb$database"

AUTRE CAS
fm_LogMessage("⚠️ Validação de versão não implementada para " + fm_oConfig.fm_sDbType)
RENVOYER Vrai
FIN

// Executar query de versão
SI HExécuteRequêteSQL(fm_sSQL, hRequêteDefaut, fm_nConnectionHandle) ALORS
SI HLitPremier() ALORS
fm_sVersion = HLitColonne(1)
fm_LogMessage("📋 Versão do SGBD: " + fm_sVersion)

// Validar versão mínima (implementação simplificada)
fm_bValid = fm_ValidarVersaoMinima(fm_sVersion)
FIN
HAnnuleRequête()
SINON
fm_LogMessage("⚠️ Não foi possível obter versão do SGBD")
FIN

RENVOYER fm_bValid
```

FIN

// Validar se a versão atende aos requisitos mínimos
PROCÉDURE PRIVÉ fm_ValidarVersaoMinima(LOCAL fm_sVersion est une chaîne) : booléen
LOCAL fm_bValid est un booléen = Vrai
LOCAL fm_sVersionUpper est une chaîne = Majuscule(fm_sVersion)

```
SELON fm_oConfig.fm_sDbType
CAS "mysql"
// MySQL 5.7+ recomendado
SI Contient(fm_sVersionUpper, "5.6") OU Contient(fm_sVersionUpper, "5.5") ALORS
fm_LogMessage("⚠️ MySQL versão antiga detectada. Recomendado 5.7+")
FIN

CAS "postgresql"
// PostgreSQL 10+ recomendado
SI Contient(fm_sVersionUpper, "9.") ALORS
fm_LogMessage("⚠️ PostgreSQL versão antiga detectada. Recomendado 10+")
FIN

CAS "sqlserver"
// SQL Server 2016+ recomendado
SI Contient(fm_sVersionUpper, "2014") OU Contient(fm_sVersionUpper, "2012") ALORS
fm_LogMessage("⚠️ SQL Server versão antiga detectada. Recomendado 2016+")
FIN

CAS "firebird"
// Firebird 3.0+ recomendado
SI Contient(fm_sVersionUpper, "2.") ALORS
fm_LogMessage("⚠️ Firebird versão antiga detectada. Recomendado 3.0+")
FIN
FIN

RENVOYER fm_bValid
```

FIN

// ===== MÉTODOS AUXILIARES ESPECÍFICOS =====

// Extrair nome do arquivo SQLite da connection string
PROCÉDURE PRIVÉ fm_ExtrairNomeArquivoSQLite() : chaîne
LOCAL fm_sFile est une chaîne = “”
LOCAL fm_nPos est un entier

```
fm_nPos = Position(Majuscule(fm_oConfig.fm_sConnectionString), "DATA SOURCE=")
SI fm_nPos > 0 ALORS
fm_sFile = Milieu(fm_oConfig.fm_sConnectionString, fm_nPos + 12)
fm_nPos = Position(fm_sFile, ";")
SI fm_nPos > 0 ALORS
fm_sFile = Gauche(fm_sFile, fm_nPos - 1)
FIN
FIN

RENVOYER fm_sFile
```

FIN

// Extrair nome do arquivo Firebird da connection string
PROCÉDURE PRIVÉ fm_ExtrairNomeArquivoFirebird() : chaîne
LOCAL fm_sFile est une chaîne = “”
LOCAL fm_nPos est un entier

```
// Procurar por .fdb ou .gdb na connection string
SI Contient(fm_oConfig.fm_sConnectionString, ".fdb") ALORS
fm_nPos = Position(fm_oConfig.fm_sConnectionString, ".fdb")
fm_sFile = Gauche(fm_oConfig.fm_sConnectionString, fm_nPos + 3)
SINON SI Contient(fm_oConfig.fm_sConnectionString, ".gdb") ALORS
fm_nPos = Position(fm_oConfig.fm_sConnectionString, ".gdb")
fm_sFile = Gauche(fm_oConfig.fm_sConnectionString, fm_nPos + 3)
FIN

// Extrair apenas o nome do arquivo
fm_nPos = Position(fm_sFile, "=")
SI fm_nPos > 0 ALORS
fm_sFile = Droite(fm_sFile, Taille(fm_sFile) - fm_nPos)
FIN

RENVOYER fm_sFile
```

FIN

// ===== CONFIGURAÇÃO DE PERFORMANCE POR SGBD =====

// Otimizar configurações baseadas no SGBD e ambiente
PROCÉDURE fm_OtimizarParaSGBD()
SELON fm_oConfig.fm_sDbType
CAS “mysql”
// MySQL: Otimizações específicas
fm_oConfig.fm_nTimeoutSeconds = 300
fm_oConfig.fm_bOptimizeAfter = Vrai // OPTIMIZE TABLE no MySQL

```
CAS "postgresql"
// PostgreSQL: Otimizações específicas
fm_oConfig.fm_nTimeoutSeconds = 600
fm_oConfig.fm_bOptimizeAfter = Vrai // VACUUM ANALYZE no PostgreSQL

CAS "sqlserver"
// SQL Server: Otimizações específicas
fm_oConfig.fm_nTimeoutSeconds = 900
fm_oConfig.fm_bOptimizeAfter = Vrai // UPDATE STATISTICS no SQL Server

CAS "oracle"
// Oracle: Otimizações específicas
fm_oConfig.fm_nTimeoutSeconds = 1200
fm_oConfig.fm_bOptimizeAfter = Vrai // ANALYZE TABLE no Oracle

CAS "sqlite"
// SQLite: Otimizações específicas
fm_oConfig.fm_nTimeoutSeconds = 60
fm_oConfig.fm_bOptimizeAfter = Vrai // VACUUM no SQLite

CAS "firebird"
// Firebird: Otimizações específicas
fm_oConfig.fm_nTimeoutSeconds = 300
fm_oConfig.fm_bOptimizeAfter = Faux // Firebird não precisa otimização frequente

AUTRE CAS
// Configuração padrão para outros SGBDs
fm_oConfig.fm_nTimeoutSeconds = 300
fm_oConfig.fm_bOptimizeAfter = Faux
FIN

fm_LogMessage("⚡ Otimizações específicas aplicadas para " + Majuscule(fm_oConfig.fm_sDbType))
```

FIN

// ===== MÉTODO DE CONFIGURAÇÃO WIZARD =====

// Wizard de configuração interativo
PROCÉDURE fm_WizardConfiguracao() : booléen
LOCAL fm_bResult est un booléen = Faux
LOCAL fm_sConnectionString est une chaîne
LOCAL fm_sDbType est une chaîne
LOCAL fm_sAnalysisPath est une chaîne
LOCAL fm_nEnvironment est un entier

```
// Passo 1: Escolher ambiente
fm_nEnvironment = Questão("Escolha o ambiente:", "1 - Desenvolvimento", "2 - Teste", "3 - Produção")

SI fm_nEnvironment = 0 ALORS
RENVOYER Faux // Cancelado
FIN

// Passo 2: Connection String
fm_sConnectionString = Saisie("Digite a connection string:")
SI fm_sConnectionString = "" ALORS
RENVOYER Faux
FIN

// Passo 3: Detectar ou escolher SGBD
fm_sDbType = fm_DetectarSGBD(fm_sConnectionString)
SI fm_sDbType = "" ENTÃO
fm_sDbType = Saisie("SGBD não detectado. Digite o tipo (mysql, postgresql, sqlserver, oracle, sqlite, firebird):")
SI fm_sDbType = "" ALORS
RENVOYER Faux
FIN
FIN

// Passo 4: Arquivo de análise
fm_sAnalysisPath = fSélecteur("", "", "Selecione o arquivo de análise WinDev", "Análise WinDev" + TAB + "*.wdd", "wdd")
SI fm_sAnalysisPath = "" ALORS
RENVOYER Faux
FIN

// Passo 5: Aplicar configuração baseada no ambiente
SELON fm_nEnvironment
CAS 1 // Desenvolvimento
fm_bResult = fm_ConfiguracaoDesenvolvimento(fm_sConnectionString, fm_sDbType, fm_sAnalysisPath)

CAS 2 // Teste
fm_bResult = fm_ConfiguracaoSimulacao(fm_sConnectionString, fm_sDbType, fm_sAnalysisPath)

CAS 3 // Produção
LOCAL fm_sEmailDBA est une chaîne = Saisie("Digite o e-mail do DBA:")
fm_bResult = fm_ConfiguracaoProducao(fm_sConnectionString, fm_sDbType, fm_sAnalysisPath, fm_sEmailDBA)
FIN

SI fm_bResult ALORS
// Aplicar otimizações específicas
fm_OtimizarParaSGBD()

// Confirmar configuração
SI Confirme("Configuração concluída!" + RC + fm_ObterStatus() + RC + RC + "Executar diagnóstico?") ALORS
fm_ExecutarDiagnostico()
FIN
FIN

RENVOYER fm_bResult
```

FIN

// ===== EXEMPLO DE USO DOS MÉTODOS ADICIONAIS =====

PROCÉDURE ExemploUsoMetodosAdicionais()
LOCAL fm_oFilemanager est un Filemanager

```
fm_oFilemanager = allouer un Filemanager()

// Opção 1: Configuração automática (mais simples)
SI fm_oFilemanager.fm_ConfiguracaoAutomatica(
"Server=localhost;Database=empresa;Uid=dev;Pwd=dev123;",
"C:\Projetos\App\App.wdd"
) ALORS

// Otimizar configurações
fm_oFilemanager.fm_OtimizarParaSGBD()

// Configurar backup inteligente
fm_oFilemanager.fm_ConfigurarBackupInteligente()

// Validar versão do SGBD
fm_oFilemanager.fm_ValidarVersaoSGBD()

// Executar
fm_oFilemanager.fm_SynchroniserComplet()

SINON
// Opção 2: Wizard interativo
SI fm_oFilemanager.fm_WizardConfiguracao() ALORS
fm_oFilemanager.fm_SynchroniserComplet()
SINON
Erreur("Configuração cancelada ou falhou")
FIN
FIN

libérer fm_oFilemanager
```

FIN

// ===== FILEMANAGER V15.1 - MÉTODOS COMPLEMENTARES PARA EXTRAÇÃO DA ANÁLISE =====
// Métodos auxiliares para o processo completo de extração e análise
// Data: 05/07/2025

// ===== PARSERS ESPECÍFICOS PARA FORMATO WDD =====

// Parser para propriedades da tabela (formato WDD)
PROCÉDURE PRIVÉ fm_ParserTablePropertiesWDD(fm_table est un stAnalysisTable, LOCAL fm_sLigne est une chaîne)
LOCAL fm_arrParts est un tableau de chaînes
LOCAL fm_sProperty est une chaîne
LOCAL fm_sValue est une chaîne

```
// Format: PROPERTY=VALUE
SI Position(fm_sLigne, "=") > 0 ALORS
ExtraitChaîne(fm_sLigne, "=", fm_arrParts)
SI TableauOccurrence(fm_arrParts) >= 2 ALORS
fm_sProperty = Majuscule(SansEspace(fm_arrParts[1]))
fm_sValue = SansEspace(fm_arrParts[2])

SELON fm_sProperty
CAS "COMMENT"
fm_table.fm_sComment = fm_sValue
CAS "ENGINE"
fm_table.fm_sEngine = fm_sValue
CAS "CHARSET"
fm_table.fm_sCharset = fm_sValue
CAS "COLLATION"
fm_table.fm_sCollation = fm_sValue
CAS "TABLESPACE"
fm_table.fm_sTablespace = fm_sValue
CAS "TEMPORARY"
fm_table.fm_bTemporary = (Majuscule(fm_sValue) = "TRUE")
CAS "PARTITIONING"
fm_table.fm_sPartitioning = fm_sValue
FIN
FIN
FIN
```

FIN

// Parser pour champ (formato WDD)
PROCÉDURE PRIVÉ fm_ParserFieldWDD(fm_table est un stAnalysisTable, LOCAL fm_sLigne est une chaîne)
LOCAL fm_arrParts est un tableau de chaînes
LOCAL fm_field est un stAnalysisField
LOCAL fm_i est un entier

```
// Format: FIELDNAME|TYPE|SIZE|PRECISION|NOTNULL|PK|AI|DEFAULT|COMMENT|...
ExtraitChaîne(fm_sLigne, "|", fm_arrParts)

SI TableauOccurrence(fm_arrParts) >= 3 ALORS
fm_field.fm_sFieldName = SansEspace(fm_arrParts[1])
fm_field.fm_sOriginalWinDevType = SansEspace(fm_arrParts[2])

// Tamanho
SI TableauOccurrence(fm_arrParts) >= 3 ET fm_arrParts[3] <> "" ALORS
fm_field.fm_nFieldSize = Val(fm_arrParts[3])
FIN

// Precisão
SI TableauOccurrence(fm_arrParts) >= 4 ET fm_arrParts[4] <> "" ALORS
fm_field.fm_nFieldPrecision = Val(fm_arrParts[4])
FIN

// Not Null
SI TableauOccurrence(fm_arrParts) >= 5 ALORS
fm_field.fm_bNotNull = (Majuscule(SansEspace(fm_arrParts[5])) = "TRUE")
FIN

// Primary Key
SI TableauOccurrence(fm_arrParts) >= 6 ALORS
fm_field.fm_bPrimaryKey = (Majuscule(SansEspace(fm_arrParts[6])) = "TRUE")
FIN

// Auto Increment
SI TableauOccurrence(fm_arrParts) >= 7 ALORS
fm_field.fm_bAutoIncrement = (Majuscule(SansEspace(fm_arrParts[7])) = "TRUE")
FIN

// Default Value
SI TableauOccurrence(fm_arrParts) >= 8 ALORS
fm_field.fm_sDefaultValue = SansEspace(fm_arrParts[8])
FIN

// Comment
SI TableauOccurrence(fm_arrParts) >= 9 ALORS
fm_field.fm_sComment = SansEspace(fm_arrParts[9])
FIN

// Collation
SI TableauOccurrence(fm_arrParts) >= 10 ALORS
fm_field.fm_sCollation = SansEspace(fm_arrParts[10])
FIN

// Unsigned
SI TableauOccurrence(fm_arrParts) >= 11 ALORS
fm_field.fm_bUnsigned = (Majuscule(SansEspace(fm_arrParts[11])) = "TRUE")
FIN

// Enum Values
SI TableauOccurrence(fm_arrParts) >= 12 ALORS
fm_field.fm_sEnumValues = SansEspace(fm_arrParts[12])
FIN

// Check Constraint
SI TableauOccurrence(fm_arrParts) >= 13 ALORS
fm_field.fm_sCheckConstraint = SansEspace(fm_arrParts[13])
FIN

// Converter tipo WinDev para SQL
fm_field.fm_sFieldType = fm_ConvertirTypeWinDevVersSQL(fm_field.fm_sOriginalWinDevType, fm_field.fm_nFieldSize, fm_field.fm_nFieldPrecision)

TableauAjoute(fm_table.fm_arrFields, fm_field)
FIN
```

FIN

// Parser pour index (formato WDD)
PROCÉDURE PRIVÉ fm_ParserIndexWDD(fm_table est un stAnalysisTable, LOCAL fm_sLigne est une chaîne)
LOCAL fm_arrParts est un tableau de chaînes
LOCAL fm_arrFields est un tableau de chaînes
LOCAL fm_index est un stAnalysisIndex
LOCAL fm_i est un entier

```
// Format: INDEXNAME|UNIQUE|PRIMARYKEY|FIELDS|TYPE|COMMENT|WHERE
ExtraitChaîne(fm_sLigne, "|", fm_arrParts)

SI TableauOccurrence(fm_arrParts) >= 4 ALORS
fm_index.fm_sIndexName = SansEspace(fm_arrParts[1])

// Unique
SI TableauOccurrence(fm_arrParts) >= 2 ALORS
fm_index.fm_bUnique = (Majuscule(SansEspace(fm_arrParts[2])) = "TRUE")
FIN

// Primary Key
SI TableauOccurrence(fm_arrParts) >= 3 ALORS
fm_index.fm_bPrimaryKey = (Majuscule(SansEspace(fm_arrParts[3])) = "TRUE")
FIN

// Fields (format: field1:ASC,field2:DESC)
SI TableauOccurrence(fm_arrParts) >= 4 ET fm_arrParts[4] <> "" ALORS
ExtraitChaîne(fm_arrParts[4], ",", fm_arrFields)
POUR fm_i = 1 _À_ TableauOccurrence(fm_arrFields)
LOCAL fm_arrFieldOrder est un tableau de chaînes
ExtraitChaîne(fm_arrFields[fm_i], ":", fm_arrFieldOrder)

SI TableauOccurrence(fm_arrFieldOrder) >= 1 ALORS
TableauAjoute(fm_index.fm_arrIndexFields, SansEspace(fm_arrFieldOrder[1]))

SI TableauOccurrence(fm_arrFieldOrder) >= 2 ALORS
TableauAjoute(fm_index.fm_arrIndexOrder, Majuscule(SansEspace(fm_arrFieldOrder[2])))
SINON
TableauAjoute(fm_index.fm_arrIndexOrder, "ASC")
FIN
FIN
FIN
FIN

// Type
SI TableauOccurrence(fm_arrParts) >= 5 ALORS
fm_index.fm_sIndexType = SansEspace(fm_arrParts[5])
FIN

// Comment
SI TableauOccurrence(fm_arrParts) >= 6 ALORS
fm_index.fm_sComment = SansEspace(fm_arrParts[6])
FIN

// Where Clause
SI TableauOccurrence(fm_arrParts) >= 7 ALORS
fm_index.fm_sWhereClause = SansEspace(fm_arrParts[7])
FIN

TableauAjoute(fm_table.fm_arrIndexes, fm_index)
FIN
```

FIN

// Parser pour foreign key (formato WDD)
PROCÉDURE PRIVÉ fm_ParserForeignKeyWDD(fm_table est un stAnalysisTable, LOCAL fm_sLigne est une chaîne)
LOCAL fm_arrParts est un tableau de chaînes
LOCAL fm_fk est un stAnalysisForeignKey

```
// Format: FKNAME|LOCALFIELD|REFTABLE|REFFIELD|ONDELETE|ONUPDATE|DEFERRABLE|COMMENT
ExtraitChaîne(fm_sLigne, "|", fm_arrParts)

SI TableauOccurrence(fm_arrParts) >= 4 ALORS
fm_fk.fm_sFKName = SansEspace(fm_arrParts[1])
fm_fk.fm_sLocalField = SansEspace(fm_arrParts[2])
fm_fk.fm_sReferencedTable = SansEspace(fm_arrParts[3])
fm_fk.fm_sReferencedField = SansEspace(fm_arrParts[4])

// On Delete
SI TableauOccurrence(fm_arrParts) >= 5 ALORS
fm_fk.fm_sOnDelete = SansEspace(fm_arrParts[5])
FIN

// On Update
SI TableauOccurrence(fm_arrParts) >= 6 ALORS
fm_fk.fm_sOnUpdate = SansEspace(fm_arrParts[6])
FIN

// Deferrable
SI TableauOccurrence(fm_arrParts) >= 7 ALORS
fm_fk.fm_bDeferrable = (Majuscule(SansEspace(fm_arrParts[7])) = "TRUE")
FIN

// Comment
SI TableauOccurrence(fm_arrParts) >= 8 ALORS
fm_fk.fm_sComment = SansEspace(fm_arrParts[8])
FIN

TableauAjoute(fm_table.fm_arrForeignKeys, fm_fk)
FIN
```

FIN

// Parser pour constraint (formato WDD)
PROCÉDURE PRIVÉ fm_ParserConstraintWDD(fm_table est un stAnalysisTable, LOCAL fm_sLigne est une chaîne)
LOCAL fm_arrParts est un tableau de chaînes
LOCAL fm_arrFields est un tableau de chaînes
LOCAL fm_constraint est un stAnalysisConstraint
LOCAL fm_i est un entier

```
// Format: CONSTRAINTNAME|TYPE|EXPRESSION|FIELDS|COMMENT
ExtraitChaîne(fm_sLigne, "|", fm_arrParts)

SI TableauOccurrence(fm_arrParts) >= 3 ALORS
fm_constraint.fm_sConstraintName = SansEspace(fm_arrParts[1])
fm_constraint.fm_sConstraintType = SansEspace(fm_arrParts[2])
fm_constraint.fm_sExpression = SansEspace(fm_arrParts[3])

// Fields
SI TableauOccurrence(fm_arrParts) >= 4 ET fm_arrParts[4] <> "" ALORS
ExtraitChaîne(fm_arrParts[4], ",", fm_arrFields)
POUR fm_i = 1 _À_ TableauOccurrence(fm_arrFields)
TableauAjoute(fm_constraint.fm_arrFields, SansEspace(fm_arrFields[fm_i]))
FIN
FIN

// Comment
SI TableauOccurrence(fm_arrParts) >= 5 ALORS
fm_constraint.fm_sComment = SansEspace(fm_arrParts[5])
FIN

TableauAjoute(fm_table.fm_arrConstraints, fm_constraint)
FIN
```

FIN

// Parser pour trigger (formato WDD)
PROCÉDURE PRIVÉ fm_ParserTriggerWDD(fm_table est un stAnalysisTable, LOCAL fm_sLigne est une chaîne)
LOCAL fm_arrParts est un tableau de chaînes
LOCAL fm_trigger est un stAnalysisTrigger

```
// Format: TRIGGERNAME|TIMING|EVENT|BODY|COMMENT
ExtraitChaîne(fm_sLigne, "|", fm_arrParts)

SI TableauOccurrence(fm_arrParts) >= 4 ALORS
fm_trigger.fm_sTriggerName = SansEspace(fm_arrParts[1])
fm_trigger.fm_sTiming = SansEspace(fm_arrParts[2])
fm_trigger.fm_sEvent = SansEspace(fm_arrParts[3])
fm_trigger.fm_sBody = SansEspace(fm_arrParts[4])

// Comment
SI TableauOccurrence(fm_arrParts) >= 5 ALORS
fm_trigger.fm_sComment = SansEspace(fm_arrParts[5])
FIN

TableauAjoute(fm_table.fm_arrTriggers, fm_trigger)
FIN
```

FIN

// ===== EXTRATORES PARA FORMATO JSON =====

// Extrair campos do JSON
PROCÉDURE PRIVÉ fm_ExtraireFieldsJSON(LOCAL fm_tableJSON est un Variant) : tableau de stAnalysisField
LOCAL fm_arrFields est un tableau de stAnalysisField
LOCAL fm_arrFieldsJSON est un tableau de Variant
LOCAL fm_i est un entier

```
SI VariantType(fm_tableJSON..fields) = wlTableau ALORS
fm_arrFieldsJSON = fm_tableJSON..fields

POUR fm_i = 1 _À_ TableauOccurrence(fm_arrFieldsJSON)
LOCAL fm_fieldJSON est un Variant = fm_arrFieldsJSON[fm_i]
LOCAL fm_field est un stAnalysisField

fm_field.fm_sFieldName = fm_fieldJSON..name
fm_field.fm_sOriginalWinDevType = fm_fieldJSON..type
fm_field.fm_nFieldSize = fm_fieldJSON..size
fm_field.fm_nFieldPrecision = fm_fieldJSON..precision
fm_field.fm_bNotNull = fm_fieldJSON..notNull
fm_field.fm_bPrimaryKey = fm_fieldJSON..primaryKey
fm_field.fm_bAutoIncrement = fm_fieldJSON..autoIncrement
fm_field.fm_sDefaultValue = fm_fieldJSON..defaultValue
fm_field.fm_sComment = fm_fieldJSON..comment
fm_field.fm_sCollation = fm_fieldJSON..collation
fm_field.fm_bUnsigned = fm_fieldJSON..unsigned
fm_field.fm_sEnumValues = fm_fieldJSON..enumValues
fm_field.fm_sCheckConstraint = fm_fieldJSON..checkConstraint

// Converter tipo
fm_field.fm_sFieldType = fm_ConvertirTypeWinDevVersSQL(fm_field.fm_sOriginalWinDevType, fm_field.fm_nFieldSize, fm_field.fm_nFieldPrecision)

TableauAjoute(fm_arrFields, fm_field)
FIN
FIN

RENVOYER fm_arrFields
```

FIN

// Extrair indexes do JSON
PROCÉDURE PRIVÉ fm_ExtraireIndexesJSON(LOCAL fm_tableJSON est un Variant) : tableau de stAnalysisIndex
LOCAL fm_arrIndexes est un tableau de stAnalysisIndex
LOCAL fm_arrIndexesJSON est un tableau de Variant
LOCAL fm_i, fm_j est un entier

```
SI VariantType(fm_tableJSON..indexes) = wlTableau ALORS
fm_arrIndexesJSON = fm_tableJSON..indexes

POUR fm_i = 1 _À_ TableauOccurrence(fm_arrIndexesJSON)
LOCAL fm_indexJSON est un Variant = fm_arrIndexesJSON[fm_i]
LOCAL fm_index est un stAnalysisIndex

fm_index.fm_sIndexName = fm_indexJSON..name
fm_index.fm_bUnique = fm_indexJSON..unique
fm_index.fm_bPrimaryKey = fm_indexJSON..primaryKey
fm_index.fm_sIndexType = fm_indexJSON..type
fm_index.fm_sComment = fm_indexJSON..comment
fm_index.fm_sWhereClause = fm_indexJSON..whereClause

// Extrair campos do índice
SI VariantType(fm_indexJSON..fields) = wlTableau ALORS
LOCAL fm_arrFieldsJSON est un tableau de Variant = fm_indexJSON..fields
POUR fm_j = 1 _À_ TableauOccurrence(fm_arrFieldsJSON)
LOCAL fm_fieldJSON est un Variant = fm_arrFieldsJSON[fm_j]
TableauAjoute(fm_index.fm_arrIndexFields, fm_fieldJSON..name)
TableauAjoute(fm_index.fm_arrIndexOrder, fm_fieldJSON..order)
FIN
FIN

TableauAjoute(fm_arrIndexes, fm_index)
FIN
FIN

RENVOYER fm_arrIndexes
```

FIN

// Extrair foreign keys do JSON
PROCÉDURE PRIVÉ fm_ExtraireForeignKeysJSON(LOCAL fm_tableJSON est un Variant) : tableau de stAnalysisForeignKey
LOCAL fm_arrForeignKeys est un tableau de stAnalysisForeignKey
LOCAL fm_arrFKsJSON est un tableau de Variant
LOCAL fm_i est un entier

```
SI VariantType(fm_tableJSON..foreignKeys) = wlTableau ALORS
fm_arrFKsJSON = fm_tableJSON..foreignKeys

POUR fm_i = 1 _À_ TableauOccurrence(fm_arrFKsJSON)
LOCAL fm_fkJSON est un Variant = fm_arrFKsJSON[fm_i]
LOCAL fm_fk est un stAnalysisForeignKey

fm_fk.fm_sFKName = fm_fkJSON..name
fm_fk.fm_sLocalField = fm_fkJSON..localField
fm_fk.fm_sReferencedTable = fm_fkJSON..referencedTable
fm_fk.fm_sReferencedField = fm_fkJSON..referencedField
fm_fk.fm_sOnDelete = fm_fkJSON..onDelete
fm_fk.fm_sOnUpdate = fm_fkJSON..onUpdate
fm_fk.fm_bDeferrable = fm_fkJSON..deferrable
fm_fk.fm_sComment = fm_fkJSON..comment

TableauAjoute(fm_arrForeignKeys, fm_fk)
FIN
FIN

RENVOYER fm_arrForeignKeys
```

FIN

// Extrair constraints do JSON
PROCÉDURE PRIVÉ fm_ExtraireConstraintsJSON(LOCAL fm_tableJSON est un Variant) : tableau de stAnalysisConstraint
LOCAL fm_arrConstraints est un tableau de stAnalysisConstraint
LOCAL fm_arrConstraintsJSON est un tableau de Variant
LOCAL fm_i, fm_j est un entier

```
SI VariantType(fm_tableJSON..constraints) = wlTableau ALORS
fm_arrConstraintsJSON = fm_tableJSON..constraints

POUR fm_i = 1 _À_ TableauOccurrence(fm_arrConstraintsJSON)
LOCAL fm_constraintJSON est un Variant = fm_arrConstraintsJSON[fm_i]
LOCAL fm_constraint est un stAnalysisConstraint

fm_constraint.fm_sConstraintName = fm_constraintJSON..name
fm_constraint.fm_sConstraintType = fm_constraintJSON..type
fm_constraint.fm_sExpression = fm_constraintJSON..expression
fm_constraint.fm_sComment = fm_constraintJSON..comment

// Extrair campos
SI VariantType(fm_constraintJSON..fields) = wlTableau ALORS
LOCAL fm_arrFieldsJSON est un tableau de Variant = fm_constraintJSON..fields
POUR fm_j = 1 _À_ TableauOccurrence(fm_arrFieldsJSON)
TableauAjoute(fm_constraint.fm_arrFields, fm_arrFieldsJSON[fm_j])
FIN
FIN

TableauAjoute(fm_arrConstraints, fm_constraint)
FIN
FIN

RENVOYER fm_arrConstraints
```

FIN

// Extrair triggers do JSON
PROCÉDURE PRIVÉ fm_ExtraireTriggersJSON(LOCAL fm_tableJSON est un Variant) : tableau de stAnalysisTrigger
LOCAL fm_arrTriggers est un tableau de stAnalysisTrigger
LOCAL fm_arrTriggersJSON est un tableau de Variant
LOCAL fm_i est un entier

```
SI VariantType(fm_tableJSON..triggers) = wlTableau ALORS
fm_arrTriggersJSON = fm_tableJSON..triggers

POUR fm_i = 1 _À_ TableauOccurrence(fm_arrTriggersJSON)
LOCAL fm_triggerJSON est un Variant = fm_arrTriggersJSON[fm_i]
LOCAL fm_trigger est un stAnalysisTrigger

fm_trigger.fm_sTriggerName = fm_triggerJSON..name
fm_trigger.fm_sTiming = fm_triggerJSON..timing
fm_trigger.fm_sEvent = fm_triggerJSON..event
fm_trigger.fm_sBody = fm_triggerJSON..body
fm_trigger.fm_sComment = fm_triggerJSON..comment

TableauAjoute(fm_arrTriggers, fm_trigger)
FIN
FIN

RENVOYER fm_arrTriggers
```

FIN

// ===== EXTRATORES PARA XML (COMPLEMENTARES) =====

// Extrair constraints do XML
PROCÉDURE PRIVÉ fm_ExtraireConstraintsXML(LOCAL fm_oTableNode est un xmlNode) : tableau de stAnalysisConstraint
LOCAL fm_arrConstraints est un tableau de stAnalysisConstraint
LOCAL fm_oConstraintNodes est un xmlNode
LOCAL fm_oConstraintNode est un xmlNode

```
fm_oConstraintNodes = XMLPremier(fm_oTableNode, "Constraints")
SI fm_oConstraintNodes <> Null ALORS
fm_oConstraintNode = XMLPremier(fm_oConstraintNodes, "Constraint")

TANTQUE fm_oConstraintNode <> Null
LOCAL fm_constraint est un stAnalysisConstraint

fm_constraint.fm_sConstraintName = XMLLitTexte(XMLPremier(fm_oConstraintNode, "Name"))
fm_constraint.fm_sConstraintType = XMLLitTexte(XMLPremier(fm_oConstraintNode, "Type"))
fm_constraint.fm_sExpression = XMLLitTexte(XMLPremier(fm_oConstraintNode, "Expression"))
fm_constraint.fm_sComment = XMLLitTexte(XMLPremier(fm_oConstraintNode, "Comment"))

// Extrair campos envolvidos
LOCAL fm_oFieldsNode est un xmlNode = XMLPremier(fm_oConstraintNode, "Fields")
SI fm_oFieldsNode <> Null ALORS
LOCAL fm_oFieldNode est un xmlNode = XMLPremier(fm_oFieldsNode, "Field")
TANTQUE fm_oFieldNode <> Null
TableauAjoute(fm_constraint.fm_arrFields, XMLLitTexte(fm_oFieldNode))
fm_oFieldNode = XMLSuivant(fm_oFieldsNode, "Field")
FIN
FIN

TableauAjoute(fm_arrConstraints, fm_constraint)

fm_oConstraintNode = XMLSuivant(fm_oConstraintNodes, "Constraint")
FIN
FIN

RENVOYER fm_arrConstraints
```

FIN

// Extrair triggers do XML
PROCÉDURE PRIVÉ fm_ExtraireTriggersXML(LOCAL fm_oTableNode est un xmlNode) : tableau de stAnalysisTrigger
LOCAL fm_arrTriggers est un tableau de stAnalysisTrigger
LOCAL fm_oTriggerNodes est un xmlNode
LOCAL fm_oTriggerNode est un xmlNode

```
fm_oTriggerNodes = XMLPremier(fm_oTableNode, "Triggers")
SI fm_oTriggerNodes <> Null ALORS
fm_oTriggerNode = XMLPremier(fm_oTriggerNodes, "Trigger")

TANTQUE fm_oTriggerNode <> Null
LOCAL fm_trigger est un stAnalysisTrigger

fm_trigger.fm_sTriggerName = XMLLitTexte(XMLPremier(fm_oTriggerNode, "Name"))
fm_trigger.fm_sTiming = XMLLitTexte(XMLPremier(fm_oTriggerNode, "Timing"))
fm_trigger.fm_sEvent = XMLLitTexte(XMLPremier(fm_oTriggerNode, "Event"))
fm_trigger.fm_sBody = XMLLitTexte(XMLPremier(fm_oTriggerNode, "Body"))
fm_trigger.fm_sComment = XMLLitTexte(XMLPremier(fm_oTriggerNode, "Comment"))

TableauAjoute(fm_arrTriggers, fm_trigger)

fm_oTriggerNode = XMLSuivant(fm_oTriggerNodes, "Trigger")
FIN
FIN

RENVOYER fm_arrTriggers
```

FIN

// ===== MÉTODOS DE UTILIDADE E VALIDAÇÃO =====

// Validar nome de identificador SQL
PROCÉDURE PRIVÉ fm_ValidarNomeIdentificador(LOCAL fm_sNome est une chaîne) : booléen
LOCAL fm_i est un entier
LOCAL fm_sChar est une chaîne

```
// Verificar se não está vazio
SI fm_sNome = "" ALORS
RENVOYER Faux
FIN

// Verificar se não excede limite de caracteres (63 para MySQL/PostgreSQL)
SI Taille(fm_sNome) > 63 ALORS
RENVOYER Faux
FIN

// Verificar primeiro caractere (deve ser letra ou underscore)
fm_sChar = fm_sNome[[1]]
SI PAS ((fm_sChar >= "A" ET fm_sChar <= "Z") OU (fm_sChar >= "a" ET fm_sChar <= "z") OU fm_sChar = "_") ALORS
RENVOYER Faux
FIN

// Verificar caracteres restantes (letras, números, underscore)
POUR fm_i = 2 _À_ Taille(fm_sNome)
fm_sChar = fm_sNome[[fm_i]]
SI PAS ((fm_sChar >= "A" ET fm_sChar <= "Z") OU (fm_sChar >= "a" ET fm_sChar <= "z") OU (fm_sChar >= "0" ET fm_sChar <= "9") OU fm_sChar = "_") ALORS
RENVOYER Faux
FIN
FIN

// Verificar se não é palavra reservada
SI fm_EstMotReservé(fm_sNome) ALORS
RENVOYER Faux
FIN

RENVOYER Vrai
```

FIN

// Verificar se é palavra reservada SQL
PROCÉDURE PRIVÉ fm_EstMotReservé(LOCAL fm_sNome est une chaîne) : booléen
LOCAL fm_arrMotsReservés est un tableau de chaînes
LOCAL fm_sNomeMaj est une chaîne = Majuscule(fm_sNome)

```
// Lista de palavras reservadas comuns
fm_arrMotsReservés = ["SELECT", "FROM", "WHERE", "INSERT", "UPDATE", "DELETE", "CREATE", "DROP", "ALTER",
"TABLE", "INDEX", "PRIMARY", "KEY", "FOREIGN", "REFERENCES", "CONSTRAINT", "NULL",
"NOT", "DEFAULT", "AUTO_INCREMENT", "UNIQUE", "CHECK", "AND", "OR", "ORDER", "BY",
"GROUP", "HAVING", "UNION", "JOIN", "INNER", "LEFT", "RIGHT", "ON", "AS", "DISTINCT",
"COUNT", "SUM", "AVG", "MIN", "MAX", "CASE", "WHEN", "THEN", "ELSE", "END", "IF",
"BEGIN", "COMMIT", "ROLLBACK", "TRANSACTION", "TRIGGER", "PROCEDURE", "FUNCTION",
"VARCHAR", "INT", "INTEGER", "DECIMAL", "FLOAT", "DOUBLE", "DATE", "TIME", "DATETIME",
"TIMESTAMP", "BOOLEAN", "BLOB", "TEXT", "CHAR", "BINARY", "VARBINARY"]

RENVOYER (TableauCherche(fm_arrMotsReservés, fm_sNomeMaj) > 0)
```

FIN

// Normalizar nome de identificador
PROCÉDURE fm_NormalizarNomeIdentificador(LOCAL fm_sNome est une chaîne) : chaîne
LOCAL fm_sNormalizado est une chaîne = “”
LOCAL fm_i est un entier
LOCAL fm_sChar est une chaîne

```
// Remover espaços e caracteres especiais
POUR fm_i = 1 _À_ Taille(fm_sNome)
fm_sChar = fm_sNome[[fm_i]]

SI (fm_sChar >= "A" ET fm_sChar <= "Z") OU (fm_sChar >= "a" ET fm_sChar <= "z") OU (fm_sChar >= "0" ET fm_sChar <= "9") ALORS
fm_sNormalizado += fm_sChar
SINON SI fm_sChar = " " OU fm_sChar = "-" OU fm_sChar = "." ALORS
fm_sNormalizado += "_"
FIN
FIN

// Garantir que começa com letra ou underscore
SI fm_sNormalizado <> "" ET fm_sNormalizado[[1]] >= "0" ET fm_sNormalizado[[1]] <= "9" ALORS
fm_sNormalizado = "_" + fm_sNormalizado
FIN

// Verificar se é palavra reservada e adicionar sufixo se necessário
SI fm_EstMotReservé(fm_sNormalizado) ALORS
fm_sNormalizado += "_field"
FIN

// Limitar tamanho
SI Taille(fm_sNormalizado) > 63 ALORS
fm_sNormalizado = Gauche(fm_sNormalizado, 60) + "_tr"
FIN

RENVOYER fm_sNormalizado
```

FIN

// ===== MÉTODOS DE COMPARAÇÃO AVANÇADA =====

// Comparar estruturas de campos entre análise e BD
PROCÉDURE fm_ComparerChampsAvance(LOCAL fm_sTableName est une chaîne) : tableau de chaînes
LOCAL fm_arrDifferences est un tableau de chaînes
LOCAL fm_arrAnalysisFields est un tableau de stAnalysisField
LOCAL fm_arrDatabaseFields est un tableau de stAnalysisField
LOCAL fm_i, fm_j est un entier
LOCAL fm_bFieldFound est un booléen

```
// Obter campos da análise
LOCAL fm_arrTables est un tableau de stAnalysisTable = fm_ObtenirStructureAnalyseComplete()
POUR fm_i = 1 _À_ TableauOccurrence(fm_arrTables)
SI fm_arrTables[fm_i].fm_sTableName = fm_sTableName ALORS
fm_arrAnalysisFields = fm_arrTables[fm_i].fm_arrFields
SORTIR
FIN
FIN

// Obter campos da base de données
fm_arrDatabaseFields = fm_ObtenirChampsBaseDados(fm_sTableName)

// Comparar campos da análise com BD
POUR fm_i = 1 _À_ TableauOccurrence(fm_arrAnalysisFields)
LOCAL fm_analysisField est un stAnalysisField = fm_arrAnalysisFields[fm_i]
fm_bFieldFound = Faux

POUR fm_j = 1 _À_ TableauOccurrence(fm_arrDatabaseFields)
LOCAL fm_dbField est un stAnalysisField = fm_arrDatabaseFields[fm_j]

SI fm_analysisField.fm_sFieldName = fm_dbField.fm_sFieldName ALORS
fm_bFieldFound = Vrai

// Comparar propriedades do campo
SI fm_analysisField.fm_sFieldType <> fm_dbField.fm_sFieldType ALORS
TableauAjoute(fm_arrDifferences, "ALTER COLUMN " + fm_EscapeIdentifier(fm_analysisField.fm_sFieldName) + " TYPE " + fm_analysisField.fm_sFieldType)
FIN

SI fm_analysisField.fm_bNotNull <> fm_dbField.fm_bNotNull ALORS
SI fm_analysisField.fm_bNotNull ALORS
TableauAjoute(fm_arrDifferences, "ALTER COLUMN " + fm_EscapeIdentifier(fm_analysisField.fm_sFieldName) + " SET NOT NULL")
SINON
TableauAjoute(fm_arrDifferences, "ALTER COLUMN " + fm_EscapeIdentifier(fm_analysisField.fm_sFieldName) + " DROP NOT NULL")
FIN
FIN

SI fm_analysisField.fm_sDefaultValue <> fm_dbField.fm_sDefaultValue ALORS
SI fm_analysisField.fm_sDefaultValue <> "" ALORS
TableauAjoute(fm_arrDifferences, "ALTER COLUMN " + fm_EscapeIdentifier(fm_analysisField.fm_sFieldName) + " SET DEFAULT " + fm_analysisField.fm_sDefaultValue)
SINON
TableauAjoute(fm_arrDifferences, "ALTER COLUMN " + fm_EscapeIdentifier(fm_analysisField.fm_sFieldName) + " DROP DEFAULT")
FIN
FIN

SORTIR
FIN
FIN

// Campo não existe na BD - precisa ser adicionado
SI PAS fm_bFieldFound ALORS
LOCAL fm_sAddColumn est une chaîne = "ADD COLUMN " + fm_EscapeIdentifier(fm_analysisField.fm_sFieldName) + " " + fm_analysisField.fm_sFieldType

SI fm_analysisField.fm_bNotNull ALORS
fm_sAddColumn += " NOT NULL"
FIN

SI fm_analysisField.fm_sDefaultValue <> "" ALORS
fm_sAddColumn += " DEFAULT " + fm_analysisField.fm_sDefaultValue
FIN

TableauAjoute(fm_arrDifferences, fm_sAddColumn)
FIN
FIN

// Verificar campos que existem na BD mas não na análise
POUR fm_j = 1 _À_ TableauOccurrence(fm_arrDatabaseFields)
LOCAL fm_dbField est un stAnalysisField = fm_arrDatabaseFields[fm_j]
fm_bFieldFound = Faux

POUR fm_i = 1 _À_ TableauOccurrence(fm_arrAnalysisFields)
SI fm_arrAnalysisFields[fm_i].fm_sFieldName = fm_dbField.fm_sFieldName ALORS
fm_bFieldFound = Vrai
SORTIR
FIN
FIN

// Campo existe na BD mas não na análise - precisa ser removido
SI PAS fm_bFieldFound ALORS
TableauAjoute(fm_arrDifferences, "DROP COLUMN " + fm_EscapeIdentifier(fm_dbField.fm_sFieldName))
FIN
FIN

RENVOYER fm_arrDifferences
```

FIN

// Obter campos da base de dados
PROCÉDURE PRIVÉ fm_ObtenirChampsBaseDados(LOCAL fm_sTableName est une chaîne) : tableau de stAnalysisField
LOCAL fm_arrFields est un tableau de stAnalysisField
LOCAL fm_sSQL est une chaîne

```
SELON fm_sDbType
CAS "mysql"
fm_sSQL = "SELECT COLUMN_NAME, DATA_TYPE, CHARACTER_MAXIMUM_LENGTH, NUMERIC_PRECISION, " +
"IS_NULLABLE, COLUMN_DEFAULT, COLUMN_COMMENT, EXTRA " +
"FROM INFORMATION_SCHEMA.COLUMNS " +
"WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = '" + fm_sTableName + "' " +
"ORDER BY ORDINAL_POSITION"

CAS "postgresql"
fm_sSQL = "SELECT column_name, data_type, character_maximum_length, numeric_precision, " +
"is_nullable, column_default, '' as column_comment, '' as extra " +
"FROM information_schema.columns " +
"WHERE table_schema = 'public' AND table_name = '" + fm_sTableName + "' " +
"ORDER BY ordinal_position"

CAS "sqlserver"
fm_sSQL = "SELECT c.COLUMN_NAME, c.DATA_TYPE, c.CHARACTER_MAXIMUM_LENGTH, c.NUMERIC_PRECISION, " +
"c.IS_NULLABLE, c.COLUMN_DEFAULT, ep.value as COLUMN_COMMENT, '' as EXTRA " +
"FROM INFORMATION_SCHEMA.COLUMNS c " +
"LEFT JOIN sys.extended_properties ep ON ep.major_id = OBJECT_ID(c.TABLE_SCHEMA + '.' + c.TABLE_NAME) " +
"AND ep.minor_id = c.ORDINAL_POSITION AND ep.name = 'MS_Description' " +
"WHERE c.TABLE_NAME = '" + fm_sTableName + "' " +
"ORDER BY c.ORDINAL_POSITION"

AUTRE CAS
fm_LogMessage("SGBD não suportado para obtenção de estrutura: " + fm_sDbType)
RENVOYER fm_arrFields
FIN

// Executar consulta e processar resultados
SI HExécuteRequêteSQL(fm_sSQL, hRequêteDefaut, fm_nConnectionHandle) ALORS
TANTQUE HLitSuivant()
LOCAL fm_field est un stAnalysisField

fm_field.fm_sFieldName = HLitColonne(1)
fm_field.fm_sOriginalWinDevType = HLitColonne(2)
fm_field.fm_sFieldType = HLitColonne(2)

SI HLitColonne(3) <> Null ALORS
fm_field.fm_nFieldSize = HLitColonne(3)
FIN

SI HLitColonne(4) <> Null ALORS
fm_field.fm_nFieldPrecision = HLitColonne(4)
FIN

fm_field.fm_bNotNull = (HLitColonne(5) = "NO")
fm_field.fm_sDefaultValue = HLitColonne(6)
fm_field.fm_sComment = HLitColonne(7)

// Verificar auto increment (MySQL)
SI fm_sDbType = "mysql" ET Position(Majuscule(HLitColonne(8)), "AUTO_INCREMENT") > 0 ALORS
fm_field.fm_bAutoIncrement = Vrai
FIN

TableauAjoute(fm_arrFields, fm_field)
FIN

HAnnuleRequête()
SINON
fm_sLastError = "Erreur lors de l'obtention des champs: " + HErreurInfo()
fm_LogMessage("ERREUR: " + fm_sLastError)
FIN

RENVOYER fm_arrFields
```

FIN

// ===== CACHE E PERFORMANCE =====

// Cache para estrutura da análise
fm_arrCacheAnalyse est un tableau de stAnalysisTable
fm_bCacheValide est un booléen = Faux
fm_sLastAnalysisHash est une chaîne = “”

// Obter estrutura com cache
PROCÉDURE fm_ObtenirStructureAnalyseAvecCache() : tableau de stAnalysisTable
LOCAL fm_sCurrentHash est une chaîne

```
// Calcular hash do arquivo de análise para detectar mudanças
fm_sCurrentHash = fm_CalculerHashFichier(fm_sWinDevAnalysisPath)

// Verificar se o cache ainda é válido
SI fm_bCacheValide ET fm_sCurrentHash = fm_sLastAnalysisHash ALORS
fm_LogMessage("Utilisation du cache pour la structure d'analyse")
RENVOYER fm_arrCacheAnalyse
FIN

// Recarregar estrutura
fm_LogMessage("Rechargement de la structure d'analyse")
fm_arrCacheAnalyse = fm_ObtenirStructureAnalyseComplete()
fm_sLastAnalysisHash = fm_sCurrentHash
fm_bCacheValide = Vrai

RENVOYER fm_arrCacheAnalyse
```

FIN

// Calcular hash de arquivo
PROCÉDURE PRIVÉ fm_CalculerHashFichier(LOCAL fm_sCheminFichier est une chaîne) : chaîne
LOCAL fm_sContenu est une chaîne
LOCAL fm_sHash est une chaîne

```
SI fFichierExiste(fm_sCheminFichier) ALORS
// Para arquivos grandes, usar apenas informações do arquivo
LOCAL fm_stInfo est un Fichier = fInfos(fm_sCheminFichier)
fm_sHash = fm_stInfo.Taille + "_" + fm_stInfo.DateModification + "_" + fm_stInfo.HeureModification
SINON
fm_sHash = ""
FIN

RENVOYER fm_sHash
```

FIN

// Invalidar cache
PROCÉDURE fm_InvaliderCacheAnalyse()
fm_bCacheValide = Faux
fm_sLastAnalysisHash = “”
fm_LogMessage(“Cache d’analyse invalidé”)
FIN