Warrior_EA/Database/DatabaseManager.mqh

//+------------------------------------------------------------------+
//|                                                       Warrior_EA |
//|                                                     AnimateDread |
//|                                                                  |
//+------------------------------------------------------------------+
#include "DatabaseConnectionManager.mqh"
#include "DatabaseOperationsManager.mqh"
#include "DatabaseFileSystemManager.mqh"
#include "DatabaseVersionManager.mqh"
class CDatabaseManager
  {
private:
   string            m_dbPath;
   int               m_databaseHandle;
   bool              m_isDatabaseOpen; // Tracks if the database is currently open

   CDatabaseConnectionManager m_dbConnectionManager;
   CDatabaseVersionManager m_dbVersionManager;
   CDatabaseFileSystemManager m_dbFileSystemManager;
   CDatabaseOperationsManager m_dbOperationsManager;

public:
                     CDatabaseManager()
     {
      m_isDatabaseOpen = false;
     }

                    ~CDatabaseManager()
     {
      CloseDatabase();
     }

   bool              Init(const string& dbVersion, string& dirStructureArray[], const string& dbName)
     {
      string currentPath;
      // Build the database folder path
      for(int i = 0; i < ArraySize(dirStructureArray); ++i)
        {
         currentPath += (i == 0) ? dirStructureArray[i] : "\\" + dirStructureArray[i];
        }
      string dbFolderPath = currentPath;
      string versionFilePath = dbFolderPath + "\\" + "DatabaseVersion";
      m_dbPath = dbFolderPath + "\\" + dbName;
      string storedDbVersion = m_dbVersionManager.ReadStoredDbVersion(versionFilePath);
      // Handling when the stored database version is "NA"
      if(storedDbVersion == "NA")
        {
         if(!m_dbFileSystemManager.CreateDirectory(dbFolderPath))
           {
            return false;
           }
         m_dbFileSystemManager.CleanDirectory(dbFolderPath);
         m_dbVersionManager.UpdateStoredDbVersion(versionFilePath, dbVersion);
        }
      else
         if(storedDbVersion == "ERROR")
           {
            // Retry mechanism for "ERROR" case
            int attempts = 0;
            while(attempts < 5 && storedDbVersion == "ERROR")
              {
               Sleep(1000); // Sleep for a second
               storedDbVersion = m_dbVersionManager.ReadStoredDbVersion(versionFilePath);
               attempts++;
              }
            if(storedDbVersion == "ERROR")
              {
               return false; // Give up after 5 attempts
              }
           }
      // If current version doesn't match the stored version (and it's not "NA" or "ERROR")
      if(storedDbVersion != dbVersion && storedDbVersion != "")
        {
         m_dbFileSystemManager.CleanDirectory(dbFolderPath);
         m_dbVersionManager.UpdateStoredDbVersion(versionFilePath, dbVersion);
        }
      // Special handling for training mode
      if(trainingMode == true)
        {
         m_dbFileSystemManager.DeleteFile(m_dbPath);
        }
      // Attempt to initialize the database connection
      if(!m_dbConnectionManager.Init(m_dbPath))
        {
         return false;
        }
      return true;
     }

   bool              Deinit()
     {
      m_dbConnectionManager.TransactionCommit();
      m_dbConnectionManager.CloseDatabase();
      return(true);
     }

   bool              OpenDatabase()
     {
      // Check if the database is already open
      if(m_isDatabaseOpen)
        {
         // Database is already open, no need to open it again
         PrintVerbose("Database already open.");
         return true;
        }
      if(m_dbConnectionManager.OpenDatabase())
        {
         m_databaseHandle = m_dbConnectionManager.GetDatabaseHandle();
         m_dbOperationsManager.SetDatabaseHandle(m_databaseHandle);
         m_isDatabaseOpen = true; // Update the state to reflect that the database is now open
         return true;
        }
      else
         return false;
     }

   bool              CloseDatabase()
     {
      if(m_dbConnectionManager.CloseDatabase())
        {
         m_databaseHandle = 0; // Reset database handle
         m_dbOperationsManager.SetDatabaseHandle(m_databaseHandle);
         m_isDatabaseOpen = false; // Update the state to reflect that the database is now closed
         return true;
        }
      else
         return false;
     }

   bool              BeginTransaction()
     {
      if(!m_isDatabaseOpen)
        {
         if(!OpenDatabase())
            return false;
        }
      return m_dbConnectionManager.TransactionBegin();
     }

   bool              CommitTransaction()
     {
      return m_dbConnectionManager.TransactionCommit();
     }

   bool              CreateTable(string tableName, string tableSchema)
     {
      return m_dbOperationsManager.CreateTable(tableName, tableSchema);
     }

   bool              DeleteTable(string tableName)
     {
      return m_dbOperationsManager.DeleteTable(tableName);
     }

   bool              InsertTradeRecord(string tableName, const string &columns[], const string &values[])
     {
      return m_dbOperationsManager.InsertTradeRecord(tableName, columns, values);
     }

   template <typename T>
   bool              FetchTradeRecords(string tableName, T &tradeRecordStructure, T &tradeRecords[])
     {
      return m_dbOperationsManager.FetchTradeRecords(tableName, tradeRecordStructure, tradeRecords);
     }

   bool              UpdateTradeRecord(string tableName, const string &columns[], const string &values[], const string &condition)
     {
      return m_dbOperationsManager.UpdateTradeRecord(tableName, columns, values, condition);
     }

   bool              DeleteOldestEntry(string tableName)
     {
      return m_dbOperationsManager.DeleteOldestEntry(tableName);
     }
  };
//+------------------------------------------------------------------+