server1/common/DataManager/SystemConfig.cpp

#include "SystemConfig.h"

#include "spdlog/spdlog.h"
#include "commonDefine.h"
#include <string>






/* 解析设置从数据库读取到的配置信息 */
void SystemConfigInfo::parseConfigFromDatabase(const QMap<std::string, std::string>& baseSettings)
{
    /* 将获取到的配置转换成结构体 */
    for(auto it = baseSettings.begin(); it != baseSettings.end(); ++it)
    {

        if(Config_Base == it.key())
        {
            if(!SysConfig.getBaseConfigFromJson(it.value()))
            {
                SPDLOG_ERROR("获取基础配置失败");
            }
        }
        else if(Config_CompareAI == it.key())
        {
            if(!SysConfig.getAICompareConfigFromJson(it.value()))
            {
                SPDLOG_ERROR("获取AI对比配置失败");
            }
        }
        else if(Config_NoiseBase == it.key())
        {
            if(!SysConfig.getNoiseDetectBaseConfigFromJson(it.value()))
            {
                SPDLOG_ERROR("获取噪音检测基础配置失败");
            }
        }
        else if(Config_NoiseParam == it.key())
        {
            if(!SysConfig.getNoiseDetectParamFromJson(it.value()))
            {
                SPDLOG_ERROR("获取噪音检测参数失败");
            }
        }
        else if(Config_Database == it.key())
        {
            if(!SysConfig.getDatabaseConfigFromJson(it.value()))
            {
                SPDLOG_ERROR("获取数据库设置失败");
            }
        }
        else
        {
            SPDLOG_DEBUG("未知的系统配置项: {}", it.key());
        }
    }

}




/* 设置基础配置 */
void SystemConfigInfo::setBaseConfig(const BaseConfig_t& config)
{
    m_baseConfigSrc = config;
}


/* 将数据库的json转换成结构体 */
bool SystemConfigInfo::getBaseConfigFromJson(const std::string& jsonStr)
{
    try {
        nJson jsonConfig = nJson::parse(jsonStr);
        m_baseConfigSrc.strServerIP = QString::fromStdString(jsonConfig["ServerIP"].get<std::string>());
        m_baseConfigSrc.nRecordMode = jsonConfig["RecordMode"].get<int>();
        m_baseConfigSrc.strDriverName = QString::fromStdString(jsonConfig["DriverName"].get<std::string>());
        m_baseConfigSrc.nNotConsistency = jsonConfig["NotConsistency"].get<int>();
        m_baseConfigSrc.isEnableMultiCore = jsonConfig["EnableMultiCore"].get<bool>();
        m_baseConfigSrc.isEnableDebugLog = jsonConfig["EnableDebugLog"].get<bool>();
        m_baseConfigSrc.isClearDirSystemOn = jsonConfig["ClearHistryDirOnStart"].get<bool>();
        m_baseConfigSrc.isUsingSoundCardName = jsonConfig["useSoundCardName"].get<bool>();
    }nJsonCatch

    return true;
}

/* 将结构体转换成json */
bool SystemConfigInfo::setBaseConfigToJson(const BaseConfig_t& baseConfig, std::string& strJson) const
{
    try {
        nJson jsonConfig;
        jsonConfig["ServerIP"] = baseConfig.strServerIP.toStdString();
        jsonConfig["RecordMode"] = baseConfig.nRecordMode;
        jsonConfig["DriverName"] = baseConfig.strDriverName.toStdString();
        jsonConfig["NotConsistency"] = baseConfig.nNotConsistency;
        jsonConfig["EnableMultiCore"] = baseConfig.isEnableMultiCore;
        jsonConfig["EnableDebugLog"] = baseConfig.isEnableDebugLog;
        jsonConfig["ClearHistryDirOnStart"] = baseConfig.isClearDirSystemOn;
        jsonConfig["useSoundCardName"] = baseConfig.isUsingSoundCardName;

        strJson = jsonConfig.dump();
    }nJsonCatch

    return true;
}


/* 设置AI对比配置 */
void SystemConfigInfo::setAICompareConfig(const AICompareConfig_t& config)
{
    m_aiCompareConfig = config;
}

/* 将数据库的json转换成AI对比配置 */
bool SystemConfigInfo::getAICompareConfigFromJson(const std::string& jsonStr)
{
    try {
        nJson jsonConfig = nJson::parse(jsonStr);
        m_aiCompareConfig.nAiComputeDuration = jsonConfig["AiComputeDuration"].get<int>();
        m_aiCompareConfig.strAiCompareDir = jsonConfig["AiCompareDir"].is_null() ? "" : QString::fromStdString(jsonConfig["AiCompareDir"].get<std::string>());
    }nJsonCatch

    return true;
}

/* 将AI对比配置转换成json */
bool SystemConfigInfo::setAICompareConfigToJson(const AICompareConfig_t& aiCompareConfig, std::string& strJson) const
{
    try {
        nJson jsonConfig;
        jsonConfig["AiComputeDuration"] = aiCompareConfig.nAiComputeDuration;
        jsonConfig["AiCompareDir"] = aiCompareConfig.strAiCompareDir.toStdString();

        strJson = jsonConfig.dump();
    }nJsonCatch

    return true;
}


/* 设置噪音检测基础配置 */
void SystemConfigInfo::setNoiseDetectBaseConfig(const NoiseDetectBaseConfig_t& config)
{
    m_noiseDetectBaseConfig = config;
}

/* 将数据库的json转换成噪音检测基础配置 */
bool SystemConfigInfo::getNoiseDetectBaseConfigFromJson(const std::string& jsonStr)
{
    try {
        nJson jsonConfig = nJson::parse(jsonStr);
        m_noiseDetectBaseConfig.strNoiseServerAddr = jsonConfig["NoiseServerAddr"].is_null() ? "" : QString::fromStdString(jsonConfig["NoiseServerAddr"].get<std::string>());
        m_noiseDetectBaseConfig.strNoiseDetectDir = jsonConfig["NoiseDetectDir"].is_null() ? "" : QString::fromStdString(jsonConfig["NoiseDetectDir"].get<std::string>());
        m_noiseDetectBaseConfig.strServerPath = jsonConfig["ServerPath"].is_null() ? "" : QString::fromStdString(jsonConfig["ServerPath"].get<std::string>());
        m_noiseDetectBaseConfig.nNoiseDetectDuration = jsonConfig["NoiseDetectDuration"].get<int>();
        m_noiseDetectBaseConfig.isEnableNoiseDetect = jsonConfig["EnableNoiseDetect"].get<bool>();
        m_noiseDetectBaseConfig.isEnableMainRoadDetect = jsonConfig["EnableMainRoadDetect"].get<bool>();
    }nJsonCatch

    return true;
}

/* 将噪音检测基础配置转换成json */
bool SystemConfigInfo::setNoiseDetectBaseConfigToJson(const NoiseDetectBaseConfig_t& noiseDetectBaseConfig, std::string& strJson) const
{
    try {
        nJson jsonConfig;
        jsonConfig["NoiseServerAddr"] = noiseDetectBaseConfig.strNoiseServerAddr.toStdString();
        jsonConfig["NoiseDetectDir"] = noiseDetectBaseConfig.strNoiseDetectDir.toStdString();
        jsonConfig["ServerPath"] = noiseDetectBaseConfig.strServerPath.toStdString();
        jsonConfig["NoiseDetectDuration"] = noiseDetectBaseConfig.nNoiseDetectDuration;
        jsonConfig["EnableNoiseDetect"] = noiseDetectBaseConfig.isEnableNoiseDetect;
        jsonConfig["EnableMainRoadDetect"] = noiseDetectBaseConfig.isEnableMainRoadDetect;

        strJson = jsonConfig.dump();
    }nJsonCatch

    return true;
}


/* 设置噪音检测参数 */
void SystemConfigInfo::setNoiseDetectParam(const NoiseDetectParam_t& config)
{
    m_noiseDetectParam = config;
}

/* 将数据库的json转换成噪音检测参数 */
bool SystemConfigInfo::getNoiseDetectParamFromJson(const std::string& jsonStr)
{
    try {
        nJson jsonConfig = nJson::parse(jsonStr);
        m_noiseDetectParam.nNoiseOneDetectDuration = jsonConfig["NoiseOneDetectDuration"].is_null() ? 0 : jsonConfig["NoiseOneDetectDuration"].get<int>();
        m_noiseDetectParam.nNoiseDetectContinueCount = jsonConfig["NoiseDetectContinueCount"].is_null() ? 0 : jsonConfig["NoiseDetectContinueCount"].get<int>();
        m_noiseDetectParam.nNoiseContinueCountIsWarn = jsonConfig["NoiseContinueCountIsWarn"].is_null() ? 0 : jsonConfig["NoiseContinueCountIsWarn"].get<int>();
        m_noiseDetectParam.nNoiseContinueCountPercent = jsonConfig["NoiseContinueCountPercent"].is_null() ? 0 : jsonConfig["NoiseContinueCountPercent"].get<int>();
        m_noiseDetectParam.dThresholdSlient = jsonConfig["ThresholdSlient"].is_null() ? 0.0 : jsonConfig["ThresholdSlient"].get<double>();
        m_noiseDetectParam.dThresholdDB = jsonConfig["ThresholdDB"].is_null() ? 0.0 : jsonConfig["ThresholdDB"].get<double>();
        m_noiseDetectParam.dThresholdCV = jsonConfig["ThresholdCV"].is_null() ? 0.0 : jsonConfig["ThresholdCV"].get<double>();
        m_noiseDetectParam.nPerseg = jsonConfig["Perseg"].is_null() ? 0 : jsonConfig["Perseg"].get<int>();
        m_noiseDetectParam.nOverlap = jsonConfig["Overlap"].is_null() ? 0 : jsonConfig["Overlap"].get<int>();
        m_noiseDetectParam.nFFT = jsonConfig["FFT"].is_null() ? 0 : jsonConfig["FFT"].get<int>();
    }nJsonCatch

    return true;
}

/* 将噪音检测参数转换成json */
bool SystemConfigInfo::setNoiseDetectParamToJson(const NoiseDetectParam_t& noiseDetectParam, std::string& strJson) const
{
    try {
        nJson jsonConfig;
        jsonConfig["NoiseOneDetectDuration"] = noiseDetectParam.nNoiseOneDetectDuration;
        jsonConfig["NoiseDetectContinueCount"] = noiseDetectParam.nNoiseDetectContinueCount;
        jsonConfig["NoiseContinueCountIsWarn"] = noiseDetectParam.nNoiseContinueCountIsWarn;
        jsonConfig["NoiseContinueCountPercent"] = noiseDetectParam.nNoiseContinueCountPercent;
        jsonConfig["ThresholdSlient"] = noiseDetectParam.dThresholdSlient;
        jsonConfig["ThresholdDB"] = noiseDetectParam.dThresholdDB;
        jsonConfig["ThresholdCV"] = noiseDetectParam.dThresholdCV;
        jsonConfig["Perseg"] = noiseDetectParam.nPerseg;
        jsonConfig["Overlap"] = noiseDetectParam.nOverlap;
        jsonConfig["FFT"] = noiseDetectParam.nFFT;

        strJson = jsonConfig.dump();
    }nJsonCatch

    return true;
}


/* 设置数据库设置 */
void SystemConfigInfo::setDatabaseConfig(const DatabaseConfig_t& config)
{
    m_databaseConfig = config;
}

/* 将数据库的json转换成数据库设置 */
bool SystemConfigInfo::getDatabaseConfigFromJson(const std::string& jsonStr)
{
    try {
        nJson jsonConfig = nJson::parse(jsonStr);
        m_databaseConfig.nRecordLogRetain = jsonConfig["RecordLogRetain"].is_null() ? 0 : jsonConfig["RecordLogRetain"].get<int>();
        m_databaseConfig.nOperatorLogRetain = jsonConfig["OperatorLogRetain"].is_null() ? 0 : jsonConfig["OperatorLogRetain"].get<int>();
        m_databaseConfig.nRecordFileRetain = jsonConfig["RecordFileRetain"].is_null() ? 0 : jsonConfig["RecordFileRetain"].get<int>();
        m_databaseConfig.nClientPort = jsonConfig["ClientPort"].is_null() ? 0 : jsonConfig["ClientPort"].get<int>();
        m_databaseConfig.nListenPort = jsonConfig["ListenPort"].is_null() ? 0 : jsonConfig["ListenPort"].get<int>();
        m_databaseConfig.strRecordFilePath = jsonConfig["RecordFilePath"].is_null() ? "" : QString::fromStdString(jsonConfig["RecordFilePath"].get<std::string>());
        m_databaseConfig.strFtpPath = jsonConfig["FtpPath"].is_null() ? "" : QString::fromStdString(jsonConfig["FtpPath"].get<std::string>());
        
    }nJsonCatch

    return true;
}
/* 将数据库设置转换成json */
bool SystemConfigInfo::setDatabaseConfigToJson(const DatabaseConfig_t& databaseConfig, std::string& strJson) const
{
    try {
        nJson jsonConfig;
        jsonConfig["RecordLogRetain"] = databaseConfig.nRecordLogRetain;
        jsonConfig["OperatorLogRetain"] = databaseConfig.nOperatorLogRetain;
        jsonConfig["RecordFileRetain"] = databaseConfig.nRecordFileRetain;
        jsonConfig["ClientPort"] = databaseConfig.nClientPort;
        jsonConfig["ListenPort"] = databaseConfig.nListenPort;
        jsonConfig["RecordFilePath"] = databaseConfig.strRecordFilePath.toStdString();
        jsonConfig["FtpPath"] = databaseConfig.strFtpPath.toStdString();

        strJson = jsonConfig.dump();
    }nJsonCatch

    return true;
}


/* 设置检测时段配置 */
void SystemConfigInfo::setDetectPeriodConfig(const QMap<int, DetectPeriodConfig_t>& config)
{
    m_mapDetectConfig.clear();
    m_mapDetectConfig = config;
}


/* 将声卡信息转换成json */
bool SystemConfigInfo::setSoundCardInfoToJson(const QMap<int, SoundCardInfo_t>& soundCardInfo, std::string& strJson) const
{
    try {
        nJson jsonConfig;
        for (const auto& soundCard : soundCardInfo) 
        {
            nJson soundCardJson;
            soundCardJson["SoundCardNum"] = soundCard.nSoundCardNum;
            soundCardJson["SoundCardID"] = soundCard.strSoundCardID.toStdString();
            soundCardJson["SoundCardName"] = soundCard.strSoundCardName.toStdString();
            soundCardJson["SoundCardDriver"] = soundCard.strSoundCardDriver.toStdString();

            nJson roadArray = nJson::array();
            for (const auto& road : soundCard.listRoad) {
                nJson roadJson;
                roadJson["RoadNum"] = road.nRoadNum;
                // roadJson["ChannelID"] = road.nChannelID;
                // roadJson["ChannelName"] = road.strChannelName.toStdString();
                roadArray.push_back(roadJson);
            }
            soundCardJson["Roads"] = roadArray;

            jsonConfig[std::to_string(soundCard.nSoundCardNum)] = soundCardJson;
        }

        strJson = jsonConfig.dump();
    }nJsonCatch

    return true;
}

/* 将json转换成声卡信息 */
bool SystemConfigInfo::getSoundCardInfoFromJson(const std::string& jsonStr, QMap<int, SoundCardInfo_t>& soundCardInfo)
{
    try {
        nJson jsonConfig = nJson::parse(jsonStr);
        soundCardInfo.clear();

        for (auto& item : jsonConfig) 
        {
            SoundCardInfo_t soundCard;
            soundCard.nSoundCardNum = item["SoundCardNum"].get<int>();
            soundCard.strSoundCardID = QString::fromStdString(item["SoundCardID"].get<std::string>());
            soundCard.strSoundCardName = QString::fromStdString(item["SoundCardName"].get<std::string>());
            soundCard.strSoundCardDriver = QString::fromStdString(item["SoundCardDriver"].get<std::string>());
            
            soundCard.listRoad.clear();
            auto roadsArray = item["Roads"];
            for (const auto& roadItem : roadsArray) 
            {
                OneRoadInfo_t road;
                road.nRoadNum = roadItem["RoadNum"].get<int>();
                // road.nChannelID = roadItem["ChannelID"].get<int>();
                // road.strChannelName = QString::fromStdString(roadItem["ChannelName"].get<std::string>());
                soundCard.listRoad.append(road);
            }

            soundCardInfo[soundCard.nSoundCardNum] = soundCard;
        }
    }nJsonCatch

    return true;
}