server1/common/DataManager/SystemConfig.cpp

#include "SystemConfig.h"

#include "spdlog/spdlog.h"
#include "commonDefine.h"
#include <qchar.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.strSoundCardName = QString::fromStdString(jsonConfig["SoundCardName"].get<std::string>());
        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["SoundCardName"] = baseConfig.strSoundCardName.toStdString();
        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.nAiCompareCount = jsonConfig["AiCompareCount"].get<int>();
        m_aiCompareConfig.fSimilarThrehold = jsonConfig["SimilarThrehold"].get<float>();
        m_aiCompareConfig.fNotSimilarThrehold = jsonConfig["NotSimilarThrehold"].get<float>();
        m_aiCompareConfig.bNoConsistencyAlarmOtherAlarm = jsonConfig["NoConsistencyAlarmOtherAlarm"].get<bool>();
        
    }nJsonCatch

    return true;
}

/* 将AI对比配置转换成json */
bool SystemConfigInfo::setAICompareConfigToJson(const AICompareConfig_t& aiCompareConfig, std::string& strJson) const
{
    try {
        nJson jsonConfig;
        jsonConfig["AiComputeDuration"] = aiCompareConfig.nAiComputeDuration;
        jsonConfig["AiCompareCount"] = aiCompareConfig.nAiCompareCount;
        jsonConfig["SimilarThrehold"] = aiCompareConfig.fSimilarThrehold;
        jsonConfig["NotSimilarThrehold"] = aiCompareConfig.fNotSimilarThrehold;
        jsonConfig["NoConsistencyAlarmOtherAlarm"] = aiCompareConfig.bNoConsistencyAlarmOtherAlarm;

        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.nNoiseDetectInterval = jsonConfig["NoiseDetectInterval"].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["NoiseDetectInterval"] = noiseDetectBaseConfig.nNoiseDetectInterval;
        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.nAlarmLogRetain = jsonConfig["AlarmLogRetain"].is_null() ? 0 : jsonConfig["AlarmLogRetain"].get<int>();
        m_databaseConfig.nAlarmFileRetain = jsonConfig["AlarmFileRetain"].is_null() ? 0 : jsonConfig["AlarmFileRetain"].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>());
        m_databaseConfig.strFtpUser = jsonConfig["FtpUser"].is_null() ? "" : QString::fromStdString(jsonConfig["FtpUser"].get<std::string>());
        m_databaseConfig.strFtpPassword = jsonConfig["FtpPassword"].is_null() ? "" : QString::fromStdString(jsonConfig["FtpPassword"].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["AlarmLogRetain"] = databaseConfig.nAlarmLogRetain;
        jsonConfig["AlarmFileRetain"] = databaseConfig.nAlarmFileRetain;
        jsonConfig["ListenPort"] = databaseConfig.nListenPort;
        jsonConfig["RecordFilePath"] = databaseConfig.strRecordFilePath.toStdString();
        jsonConfig["FtpPath"] = databaseConfig.strFtpPath.toStdString();
        jsonConfig["FtpUser"] = databaseConfig.strFtpUser.toStdString();
        jsonConfig["FtpPassword"] = databaseConfig.strFtpPassword.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;
// }

/* 将PCM信息转换成json */
bool SystemConfigInfo::setSoundCardPCMInfoToJson(const std::list<AudioDeviceDesc_t>& soundCardPCMInfo, std::string& strJson) const
{
    try {
        nJson jsonConfig = nJson::array();
        for (const auto& device : soundCardPCMInfo) 
        {
            nJson deviceJson;
            deviceJson["PCMName"] = device.DeviceName;
            deviceJson["PCMDesc"] = device.DeviceDesc;
            deviceJson["IOID"] = device.IOID;
            deviceJson["CardNum"] = device.Card;
            deviceJson["SubDevNum"] = device.DevNum;

            jsonConfig.push_back(deviceJson);
        }
        strJson = jsonConfig.dump();
    }nJsonCatch

    return true;
}

/* 将json转换成声卡信息 */
bool SystemConfigInfo::getSoundCardPCMInfoFromJson(const std::string& jsonStr, std::list<AudioDeviceDesc_t>& soundCardPCMInfo)
{
    try {
        nJson jsonConfig = nJson::parse(jsonStr);
        soundCardPCMInfo.clear();

        for (const auto& item : jsonConfig) 
        {
            AudioDeviceDesc_t device;
            device.DeviceName = item["PCMName"].get<std::string>();
            device.DeviceDesc = item["PCMDesc"].get<std::string>();
            device.IOID = item["IOID"].get<std::string>();
            device.Card = item["CardNum"].get<int>();
            device.DevNum = item["SubDevNum"].get<int>();

            soundCardPCMInfo.push_back(device);
        }
    }nJsonCatch

    return true;
}