server1/common/DataManager/SystemConfig.cpp

#include "SystemConfig.h"

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

/* 设置基础配置 */
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.strRegitrationCode = QString::fromStdString(jsonConfig["RegistrationCode"].get<std::string>());
        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.nFreqComponentMini = jsonConfig["FreqComponentMini"].is_null() ? 0 : jsonConfig["FreqComponentMini"].get<int>();
        m_noiseDetectParam.nFreqComponentMax = jsonConfig["FreqComponentMax"].is_null() ? 0 : jsonConfig["FreqComponentMax"].get<int>();   
        m_noiseDetectParam.fOneDBThreshold = jsonConfig["OneDBThreshold"].is_null() ? 0.0f : jsonConfig["OneDBThreshold"].get<float>();
        m_noiseDetectParam.nOneDBComponentMini = jsonConfig["OneDBComponentMini"].is_null() ? 0 : jsonConfig["OneDBComponentMini"].get<int>();
        m_noiseDetectParam.fNoiseThreshold = jsonConfig["NoiseThreshold"].is_null() ? 0.0f : jsonConfig["NoiseThreshold"].get<float>();
        m_noiseDetectParam.nNoiseComponentMini = jsonConfig["NoiseComponentMini"].is_null() ? 0 : jsonConfig["NoiseComponentMini"].get<int>();
        m_noiseDetectParam.nNoiseDetectDuration = jsonConfig["NoiseDetectDuration"].is_null() ? 0 : jsonConfig["NoiseDetectDuration"].get<int>();
        m_noiseDetectParam.nNoiseDetectPercent = jsonConfig["NoiseDetectPercent"].is_null() ? 0 : jsonConfig["NoiseDetectPercent"].get<int>();
        m_noiseDetectParam.nNoiseDBMax = jsonConfig["NoiseDBMax"].is_null() ? 0 : jsonConfig["NoiseDBMax"].get<int>();
    }nJsonCatch

    return true;
}

/* 将噪音检测参数转换成json */
bool SystemConfigInfo::setNoiseDetectParamToJson(const NoiseDetectParam_t& noiseDetectParam, std::string& strJson) const
{
    try {
        nJson jsonConfig;
        jsonConfig["RegistrationCode"] = noiseDetectParam.strRegitrationCode.toStdString();
        jsonConfig["NoiseDetectContinueCount"] = noiseDetectParam.nNoiseDetectContinueCount;
        jsonConfig["NoiseContinueCountIsWarn"] = noiseDetectParam.nNoiseContinueCountIsWarn;
        jsonConfig["NoiseContinueCountPercent"] = noiseDetectParam.nNoiseContinueCountPercent;
        jsonConfig["FreqComponentMini"] = noiseDetectParam.nFreqComponentMini;
        jsonConfig["FreqComponentMax"] = noiseDetectParam.nFreqComponentMax;
        jsonConfig["OneDBThreshold"] = noiseDetectParam.fOneDBThreshold;
        jsonConfig["OneDBComponentMini"] = noiseDetectParam.nOneDBComponentMini;
        jsonConfig["NoiseThreshold"] = noiseDetectParam.fNoiseThreshold;
        jsonConfig["NoiseComponentMini"] = noiseDetectParam.nNoiseComponentMini;
        jsonConfig["NoiseDetectDuration"] = noiseDetectParam.nNoiseDetectDuration;
        jsonConfig["NoiseDetectPercent"] = noiseDetectParam.nNoiseDetectPercent;
        jsonConfig["NoiseDBMax"] = noiseDetectParam.nNoiseDBMax;

        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>());
        
    }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();

        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;
}