~chenluhua/Bond2.git

#include "stdafx.h"
#include "SECSRuntimeManager.h"
 
// ³£Á¿
const std::string DATABASE_FILE = R"(SECSDataManager.db)";
 
// ¾²Ì¬³ÉÔ±³õÊ¼»¯
std::mutex SECSRuntimeManager::m_mutex;
 
// »ñÈ¡µ¥ÀýÊµÀý
SECSRuntimeManager& SECSRuntimeManager::getInstance() {
    static SECSRuntimeManager instance;
    return instance;
}
 
// ¹¹Ôìº¯Êý
SECSRuntimeManager::SECSRuntimeManager() {
    m_pDB = new BL::SQLiteDatabase();
}
 
// Îö¹¹º¯Êý
SECSRuntimeManager::~SECSRuntimeManager() {
    termRuntimeSetting();
 
    if (m_pDB != nullptr) {
        delete m_pDB;
        m_pDB = nullptr;
    }
}
 
// ´ÓÊý¾Ý¿âÖÐ»ñÈ¡ÕûÊý
int SECSRuntimeManager::getIntFromDB(const std::string& query) {
    auto results = m_pDB->fetchResults(query);
    if (!results.empty() && !results[0].empty()) {
        // ×ª»»µÚÒ»¸ö²éÑ¯½á¹ûÎªÕûÊý
        return std::stoi(results[0][0]);
    }
 
    return 0;
}
 
// ÉèÖÃÊý¾Ý¿âÁ¬½Ó
void SECSRuntimeManager::setDatabase(BL::Database* db) {
    std::lock_guard<std::mutex> lock(m_mutex);
    m_pDB = db;
}
 
// ³õÊ¼»¯SECSÉèÖÃ¹ÜÀí¿â
bool SECSRuntimeManager::initRuntimeSetting() {
    char path[MAX_PATH];
    GetModuleFileName(NULL, path, MAX_PATH);
    std::string exePath(path);
    std::string dbFileDir = exePath.substr(0, exePath.find_last_of("\\/")) + "\\DB";
    if (!CreateDirectory(dbFileDir.c_str(), NULL) && ERROR_ALREADY_EXISTS != GetLastError()) {
        throw std::runtime_error("Failed to create database directory.");
    }
 
    std::string dbFilePath = dbFileDir + "\\" + DATABASE_FILE;
    if (!m_pDB->connect(dbFilePath, true)) {
        return false;
    }
 
    // ³õÊ¼»¯ SystemSV ±í
    initSystemSVTable();
 
    // ³õÊ¼»¯ EqpSV ±í
    initEqpSVTable();
 
    // ³õÊ¼»¯ SystemDV ±í
    initSystemDVTable();
 
    // ³õÊ¼»¯ EqpDV ±í
    initEqpDVTable();
 
    // ³õÊ¼»¯ SystemEC ±í
    initSystemECTable();
 
    // ³õÊ¼»¯ EqpEC ±í
    initEqpECTable();
 
    // ³õÊ¼»¯ SystemECID ±í
    initSystemEventTable();
 
    // ³õÊ¼»¯ EqpECID ±í
    initEqpEventTable();
 
    // ³õÊ¼»¯ SystemEventLink ±í
    initEventLinkTable();
 
    // ³õÊ¼»¯ PPID ±í
    initPPIDTable();
 
    // ³õÊ¼»¯ RPTID ±í
    initRPTIDTable();
 
    return true;
}
 
// Ïú»ÙSECSÉèÖÃ¹ÜÀí¿â
void SECSRuntimeManager::termRuntimeSetting() {
    if (m_pDB != nullptr) {
        m_pDB->disconnect();
    }
}
 
// ³õÊ¼»¯ SystemSV ±í
void SECSRuntimeManager::initSystemSVTable() {
    std::lock_guard<std::mutex> lock(m_mutex);
    if (m_pDB == nullptr) {
        throw std::runtime_error("Database not connected.");
    }
 
    // ´´½¨ SystemSV ±í£¨Èç¹û²»´æÔÚ£©
    std::string createTableSQL =
        "CREATE TABLE IF NOT EXISTS SystemSV ("
        "ID INTEGER PRIMARY KEY, "
        "Name TEXT UNIQUE NOT NULL, "
        "DataType TEXT NOT NULL, "
        "Length INTEGER NULL, "
        "Unit TEXT NULL, "
        "Remark TEXT, "
        "SystemID INTEGER);";
 
    if (!m_pDB->executeQuery(createTableSQL)) {
        throw std::runtime_error("Failed to create SystemSV table.");
    }
 
    // Ô¤¶¨ÒåµÄ SV Êý¾Ý
    std::vector<std::tuple<int, std::string, std::string, int, std::string, std::string, int>> svData = {
        {1, "SYS_LICENSE_CODE", "ASCII", 0, "NULL", "License code (Formal; Evaluation; NoLicense)", 1},
        {2, "SYS_LICENSE_STATUS", "UINT_1", 0, "NULL", "License status(0:Unauthorized; 1:Authorized; 2:Evaluation; 3:Evaluation Expiring; 4:Trial; 5:Trial End)", 2},
        {3, "GEM_CLOCK", "ASCII", 0, "NULL", "System Clock", 3},
        {4, "SYS_SECS_COMM_MODE", "UINT_1", 0, "NULL", "SECS Communication Mode(0:HSMS Mode; 1:SECSI Mode)", 4},
        {5, "SYS_SECS_DRIVER_CONNECT_STATE", "UINT_1", 0, "NULL", "Initial SECS Driver Connect State(0:Stop; 1:Start)", 5}
    };
 
    for (const auto& entry : svData) {
        int nID, nLength, nSystemID;
        std::string sName, sDataType, sRemark, sUnit;
        std::tie(nID, sName, sDataType, nLength, sUnit, sRemark, nSystemID) = entry;
 
        // ¼ì²é Name ÊÇ·ñÒÑ´æÔÚ
        int count = getIntFromDB("SELECT COUNT(*) FROM SystemSV WHERE Name = '" + sName + "';");
        if (count == 0) {
            // ²åÈëÊý¾Ý
            std::string insertSQL = "INSERT INTO SystemSV (ID, Name, DataType, Length, Unit, Remark, SystemID) VALUES ("
                + std::to_string(nID) + ", '"
                + sName + "', '"
                + sDataType + "', "
                + (nLength > 0 ? std::to_string(nLength) : "NULL") + ", "
                + ((sUnit == "NULL") ? "NULL" : "'" + sUnit + "'") + ", '"
                + sRemark + "', "
                + std::to_string(nSystemID) + ");";
 
            if (!m_pDB->executeQuery(insertSQL)) {
                throw std::runtime_error("Failed to insert SystemSV data.");
            }
        }
    }
}
 
// ³õÊ¼»¯ EqpSV ±í
void SECSRuntimeManager::initEqpSVTable() {
    std::lock_guard<std::mutex> lock(m_mutex);
    if (m_pDB == nullptr) {
        throw std::runtime_error("Database not connected.");
    }
 
    // ´´½¨ EqpSV ±í
    std::string createTableSQL =
        "CREATE TABLE IF NOT EXISTS EqpSV ("
        "ID INTEGER PRIMARY KEY, "
        "Name TEXT UNIQUE NOT NULL, "
        "DataType TEXT NOT NULL, "
        "Length INTEGER NULL, "
        "Unit TEXT NULL, "
        "Remark TEXT, "
        "SeqNo INTEGER);";
 
    if (!m_pDB->executeQuery(createTableSQL)) {
        throw std::runtime_error("Failed to create EqpSV table.");
    }
}
 
// ³õÊ¼»¯ SystemDV ±í
void SECSRuntimeManager::initSystemDVTable() {
    std::lock_guard<std::mutex> lock(m_mutex);
    if (m_pDB == nullptr) {
        throw std::runtime_error("Database not connected.");
    }
 
    // ´´½¨ SystemDV ±í
    std::string createTableSQL =
        "CREATE TABLE IF NOT EXISTS SystemDV ("
        "ID INTEGER PRIMARY KEY, "
        "Name TEXT UNIQUE NOT NULL, "
        "DataType TEXT NOT NULL, "
        "Length INTEGER NULL, "
        "Unit TEXT NULL, "
        "Remark TEXT, "
        "SystemID INTEGER);";
 
    if (!m_pDB->executeQuery(createTableSQL)) {
        throw std::runtime_error("Failed to create SystemDV table.");
    }
}
 
// ³õÊ¼»¯ EqpDV ±í
void SECSRuntimeManager::initEqpDVTable() {
    std::lock_guard<std::mutex> lock(m_mutex);
    if (m_pDB == nullptr) {
        throw std::runtime_error("Database not connected.");
    }
 
    // ´´½¨ EqpDV ±í
    std::string createTableSQL =
        "CREATE TABLE IF NOT EXISTS EqpDV ("
        "ID INTEGER PRIMARY KEY, "
        "Name TEXT UNIQUE NOT NULL, "
        "DataType TEXT NOT NULL, "
        "Length INTEGER NULL, "
        "Unit TEXT NULL, "
        "Remark TEXT, "
        "SeqNo INTEGER);";
 
    if (!m_pDB->executeQuery(createTableSQL)) {
        throw std::runtime_error("Failed to create EqpDV table.");
    }
}
 
// ³õÊ¼»¯ SystemEC ±í
void SECSRuntimeManager::initSystemECTable() {
    std::lock_guard<std::mutex> lock(m_mutex);
    if (m_pDB == nullptr) {
        throw std::runtime_error("Database not connected.");
    }
 
    // ´´½¨ SystemEC ±í
    std::string createTableSQL =
        "CREATE TABLE IF NOT EXISTS SystemEC ("
        "ID INTEGER PRIMARY KEY, "
        "Name TEXT UNIQUE NOT NULL, "
        "DataType TEXT NOT NULL, "
        "MinValue INTEGER NULL, "
        "MaxValue INTEGER NULL, "
        "DefaultVal INTEGER NULL, "
        "Unit TEXT NULL, "
        "Remark TEXT, "
        "SystemID INTEGER);";
 
    if (!m_pDB->executeQuery(createTableSQL)) {
        throw std::runtime_error("Failed to create SystemEC table.");
    }
}
 
// ³õÊ¼»¯ EqpEC ±í
void SECSRuntimeManager::initEqpECTable() {
    std::lock_guard<std::mutex> lock(m_mutex);
    if (m_pDB == nullptr) {
        throw std::runtime_error("Database not connected.");
    }
 
    // ´´½¨ EqpEC ±í
    std::string createTableSQL =
        "CREATE TABLE IF NOT EXISTS EqpEC ("
        "ID INTEGER PRIMARY KEY, "
        "Name TEXT UNIQUE NOT NULL, "
        "DataType TEXT NOT NULL, "
        "MinValue INTEGER NULL, "
        "MaxValue INTEGER NULL, "
        "DefaultValue INTEGER NULL, "
        "Unit TEXT NULL, "
        "Remark TEXT, "
        "SeqNo INTEGER NOT NULL, "
        "Length INTEGER NOT NULL, "
        "CanUpdateByHost INTEGER NOT NULL);";
 
    if (!m_pDB->executeQuery(createTableSQL)) {
        throw std::runtime_error("Failed to create EqpEC table.");
    }
}
 
// ³õÊ¼»¯ SystemEvent ±í
void SECSRuntimeManager::initSystemEventTable() {
    std::lock_guard<std::mutex> lock(m_mutex);
    if (m_pDB == nullptr) {
        throw std::runtime_error("Database not connected.");
    }
 
    // ´´½¨ SystemEvent ±í
    std::string createTableSQL =
        "CREATE TABLE IF NOT EXISTS SystemEvent ("
        "CEID INTEGER PRIMARY KEY, "
        "Name TEXT UNIQUE NOT NULL, "
        "Remark TEXT, "
        "SystemID INTEGER);";
 
    if (!m_pDB->executeQuery(createTableSQL)) {
        throw std::runtime_error("Failed to create SystemEvent table.");
    }
}
 
// ³õÊ¼»¯ EqpEvent ±í
void SECSRuntimeManager::initEqpEventTable() {
    std::lock_guard<std::mutex> lock(m_mutex);
    if (m_pDB == nullptr) {
        throw std::runtime_error("Database not connected.");
    }
 
    // ´´½¨ EqpEvent ±í
    std::string createTableSQL =
        "CREATE TABLE IF NOT EXISTS EqpEvent ("
        "CEID INTEGER PRIMARY KEY AUTOINCREMENT, "
        "Name TEXT UNIQUE NOT NULL, "
        "Remark TEXT, "
        "BitNo INTEGER);";
 
    if (!m_pDB->executeQuery(createTableSQL)) {
        throw std::runtime_error("Failed to create EqpEvent table.");
    }
}
 
// ³õÊ¼»¯ EventLink ±í
void SECSRuntimeManager::initEventLinkTable() {
    std::lock_guard<std::mutex> lock(m_mutex);
    if (m_pDB == nullptr) {
        throw std::runtime_error("Database not connected.");
    }
 
    // ´´½¨ EventLink ±í
    std::string createEventLinkSQL =
        "CREATE TABLE IF NOT EXISTS EventLink ("
        "CEID INTEGER, "
        "RPTID INTEGER, "
        "FOREIGN KEY (CEID) REFERENCES EqpEvent(CEID));";
 
    if (!m_pDB->executeQuery(createEventLinkSQL)) {
        throw std::runtime_error("Failed to create EventLink table.");
    }
}
 
// ³õÊ¼»¯ PPID ±í
void SECSRuntimeManager::initPPIDTable() {
    std::lock_guard<std::mutex> lock(m_mutex);
    if (m_pDB == nullptr) {
        throw std::runtime_error("Database not connected.");
    }
 
    // ´´½¨ EqpPPID ±í
    std::string createTableSQL =
        "CREATE TABLE IF NOT EXISTS EqpPPID ("
        "BitNo INTEGER PRIMARY KEY AUTOINCREMENT, "
        "PPID INTEGER NULL);";
    if (!m_pDB->executeQuery(createTableSQL)) {
        throw std::runtime_error("Failed to create EqpPPID table.");
    }
 
    // ÏÈ¼ì²é±íÊÇ·ñÎª¿Õ
    int nCount = getIntFromDB("SELECT COUNT(*) FROM EqpPPID;");
    if (nCount == 0) {
        // ²åÈë³õÊ¼Êý¾Ý£¨512 ÐÐ£©
        for (int nBitNo = 0; nBitNo < 512; ++nBitNo) {
            std::string insertSQL = "INSERT INTO EqpPPID (BitNo) VALUES (" + std::to_string(nBitNo) + ");";
            if (!m_pDB->executeQuery(insertSQL)) {
                throw std::runtime_error("Failed to insert data into EqpPPID table.");
            }
        }
    }
}
 
// ³õÊ¼»¯ RPTID ±í
void SECSRuntimeManager::initRPTIDTable() {
    std::lock_guard<std::mutex> lock(m_mutex);
    if (m_pDB == nullptr) {
        throw std::runtime_error("Database not connected.");
    }
 
    // ´´½¨ RPTID Ïà¹Ø±í
    std::string createReportTableSQL =
        "CREATE TABLE IF NOT EXISTS Report ("
        "RPTID INTEGER PRIMARY KEY);";
 
    std::string createReportVIDsTableSQL =
        "CREATE TABLE IF NOT EXISTS ReportVIDs ("
        "ID INTEGER PRIMARY KEY AUTOINCREMENT, "
        "RPTID INTEGER NOT NULL, "
        "VID INTEGER NOT NULL, "
        "FOREIGN KEY (RPTID) REFERENCES Report(RPTID));";
 
    if (!m_pDB->executeQuery(createReportTableSQL)) {
        throw std::runtime_error("Failed to create Report table.");
    }
    if (!m_pDB->executeQuery(createReportVIDsTableSQL)) {
        throw std::runtime_error("Failed to create ReportVIDs table.");
    }
}