server1/common/Network/FromWebAPI.cpp

#include "FromWebAPI.h"

#include "GlobalVariable.h"
#include "commonDefine.h"
#include "spdlog.h"

#include <QString>



FromWebAPI::FromWebAPI()
{
    m_logger = spdlog::get("FromWebAPI");
    if(m_logger == nullptr)
    {
        fmt::print("FromWebAPI: Logger FromWebAPI not found\n");
        return;
    }
}

FromWebAPI::~FromWebAPI()
{

}

/* 获取数据库中的对比项信息 */
bool FromWebAPI::getCompareItemInfo(QList<CompareItemInfo_t>& listItems)
{
    /* 先获取对比项信息 */
    nJson json0;
    json0["opName"] = "ACAS_GetCompareItem";
    QString strCmd1 = QString::fromStdString(json0.dump());
    QString strRet1;
    int ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_Select, strCmd1, strRet1, true);
    if(ret != 0)
    {
        SPDLOG_LOGGER_ERROR(m_logger, "获取对比项信息失败: {}, {}", ret, m_httpApi->DoGetLastError(&ret).toStdString());
        return false;
    }

    // SPDLOG_LOGGER_DEBUG(m_logger, "获取对比项信息成功: {}", nJson::parse(strRet1.toStdString()).dump(4));

    /* 再获取对比项的通道信息 */
    nJson json1;
    json1["opName"] = "ACAS_GetCompareItemRoad";
    QString strCmd2 = QString::fromStdString(json1.dump());
    QString strRet2;
    ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_Select, strCmd2, strRet2, true);
    if(ret != 0)
    {
        SPDLOG_LOGGER_ERROR(m_logger, "获取对比项通道信息失败: {}, {}", ret, m_httpApi->DoGetLastError(&ret).toStdString());
        return false;
    }


    listItems.clear();
    /*---------------------------------- 解析对比项信息 ------------------------------*/
    try
    {
        nJson jsonRet;
        /* 将json的key全部转换成小写 */
        if(!convertJsonKeyToLower(nJson::parse(strRet1.toStdString()), jsonRet))
        {
            SPDLOG_LOGGER_ERROR(m_logger, "转换JSON键名为小写失败");
            return false;
        }
        int code = jsonRet["code"].get<int>();
        if(code != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger, "获取对比项信息失败，错误码: {}, 错误信息: {}", code, jsonRet["message"].get<std::string>());
            return false;
        }
        nJson jsonResult = jsonRet["result"];
        
        for(const auto& item : jsonResult)
        {
            CompareItemInfo_t compareItem;
            compareItem.nID = item["itemid"].get<int>();
            compareItem.strName = QString::fromStdString(item["itemname"].get<std::string>());
            compareItem.isEnable = item["itemenable"].get<bool>();
            compareItem.paramMute.isEnable = item["silentenable"].get<bool>();
            compareItem.paramMute.nLen = item["silentduration"].get<int>();
            compareItem.paramMute.threshold.nThreshold = item["silentthreshold"].get<uint64_t>();
            compareItem.paramMute.nSensitivity = item["silentsensitivity"].get<int>();

            compareItem.paramOverload.isEnable = item["overloadenable"].get<bool>();
            compareItem.paramOverload.nLen = item["overloadduration"].get<int>();
            compareItem.paramOverload.threshold.nThreshold = item["overloadthreshold"].get<uint64_t>();
            compareItem.paramOverload.nSensitivity = item["overloadsensitivity"].get<int>();

            compareItem.paramPhase.isEnable = item["phaseenable"].get<bool>();
            compareItem.paramPhase.nLen = item["phaseduration"].get<int>();
            compareItem.paramPhase.threshold.dThreshold = item["phasethreshold"].get<double>();
            compareItem.paramPhase.nSensitivity = item["phasesensitivity"].get<int>();

            listItems.append(compareItem);
        }
    }nJsonCatch

    /*---------------------------------- 解析对比项录音通道信息 ------------------------------*/
    try
    {
        /* 将json的key全部转换成小写 */
        nJson jsonRet;
        if(!convertJsonKeyToLower(nJson::parse(strRet2.toStdString()), jsonRet))
        {
            SPDLOG_LOGGER_ERROR(m_logger, "转换JSON键名为小写失败");
            return false;
        }
        // SPDLOG_LOGGER_DEBUG(m_logger, "获取对比项通道信息: {}", jsonRet.dump(4));

        int code = jsonRet["code"].get<int>();
        if(code != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger, "获取对比项通道信息失败，错误码: {}, 错误信息: {}", code, jsonRet["message"].get<std::string>());
            return false;
        }
        nJson jsonResult = jsonRet["result"];
        /* 使用迭代器获取对比项信息 */
        auto it = listItems.begin();
        for(const auto& item : jsonResult)
        {
            CompareItemRoadInfo_t roadInfo;
            int itemID = item["itemid"].get<int>();
            roadInfo.nCompareRoadNum = item["roadnum"].get<int>();
            roadInfo.strCompareRoadName = QString::fromStdString(item["roadname"].get<std::string>());
            roadInfo.isEnableRecord = item["roadrecordenable"].get<bool>();
            roadInfo.scRoadInfo.strSoundCardName = item["soundcardname"].get<std::string>();
            roadInfo.scRoadInfo.pcmInfo.strPCMName = item["soundcardpcmname"].get<std::string>();

            /* 如果这个通道是当前迭代器的，就直接插入，如果不是则重新寻找 */
            if(it->nID == itemID)
            {
                it->mapRoad.insert(roadInfo.nCompareRoadNum, roadInfo);
            }else {
                for(it = listItems.begin(); it != listItems.end(); ++it)
                {
                    if(it->nID == itemID)
                    {
                        it->mapRoad.insert(roadInfo.nCompareRoadNum, roadInfo);
                        break;
                    }
                }
            }
        }
    }nJsonCatch


    return true;
}

/* 添加对比项信息 */
bool FromWebAPI::insertCompareItem(const QList<CompareItemInfo_t>& listItems)
{
    /*---------------------------------- 插入对比项信息 ------------------------------*/
    try
    {
        int key = 1;
        nJson jsonArray = nJson::array();
        for(const auto& item : listItems)
        {
            nJson json0;
            json0["opName"] = "ACAS_InsertCompareItem";
            json0["Key"] = key++;

            nJson jsonItem;
            jsonItem["itemID"] = item.nID;
            jsonItem["itemName"] = item.strName.toStdString();
            jsonItem["itemEnable"] = item.isEnable;
            jsonItem["roadCount"] = item.mapRoad.size();

            jsonItem["silentEnable"] = item.paramMute.isEnable;
            jsonItem["silentDuration"] = item.paramMute.nLen;
            jsonItem["silentThreshold"] = item.paramMute.threshold.nThreshold;
            jsonItem["silentSensitivity"] = item.paramMute.nSensitivity;

            jsonItem["overloadEnable"] = item.paramOverload.isEnable;
            jsonItem["overloadDuration"] = item.paramOverload.nLen;
            jsonItem["overloadThreshold"] = item.paramOverload.threshold.nThreshold;
            jsonItem["overloadSensitivity"] = item.paramOverload.nSensitivity;

            jsonItem["phaseEnable"] = item.paramPhase.isEnable;
            jsonItem["phaseDuration"] = item.paramPhase.nLen;
            jsonItem["phaseThreshold"] = item.paramPhase.threshold.dThreshold;
            jsonItem["phaseSensitivity"] = item.paramPhase.nSensitivity;

            json0["paramList"] = jsonItem;
            jsonArray.push_back(json0);
        }

        QString strSend = QString::fromStdString(jsonArray.dump());
        QString strRet;
        int ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_BatchTransAction, strSend, strRet, true);
        if(ret != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger, "添加对比项信息失败: {}, {}", ret, strRet.toStdString());
            return false;
        }
    }nJsonCatch

    /*---------------------------------- 插入对比项通道信息 ------------------------------*/
    if(!insertCompareItemRoad(listItems))
    {
        return false;
    }

    return true;
}

/* 插入对比项通道信息 */
bool FromWebAPI::insertCompareItemRoad(const QList<CompareItemInfo_t>& listItems)
{
    try
    {
        int Key = 1;
        nJson jsonArray = nJson::array();
        for(const auto& item : listItems)
        {
            for(const auto& road : item.mapRoad)
            {
                nJson json1;
                json1["opName"] = "ACAS_InsertCompareItemRoad";
                json1["Key"] = Key++;

                nJson jsonRoad;
                jsonRoad["itemID"] = item.nID;
                jsonRoad["roadNum"] = road.nCompareRoadNum;
                jsonRoad["roadName"] = road.strCompareRoadName.toStdString();
                jsonRoad["roadRecordEnable"] = road.isEnableRecord;

                jsonRoad["soundCardName"] = road.scRoadInfo.strSoundCardName;
                jsonRoad["soundCardPCMName"] = road.scRoadInfo.pcmInfo.strPCMName;

                json1["paramList"] = jsonRoad;
                jsonArray.push_back(json1);
            }
        }
        // SPDLOG_LOGGER_DEBUG(m_logger, "插入对比项通道信息: {}", jsonArray.dump(4));
        QString strSend = QString::fromStdString(jsonArray.dump());
        QString strRet;
        int ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_BatchTransAction, strSend, strRet, true);
        if(ret != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger, "添加对比项通道信息失败: {}, {}", ret, m_httpApi->DoGetLastError(&ret).toStdString());
            return false;
        }

    }nJsonCatch

    return true;
}

/* 修改对比项信息 */
bool FromWebAPI::updateCompareItemOnly(const QList<CompareItemInfo_t>& listItems)
{
    /*---------------------------------- 更新对比项信息 ------------------------------*/
    try
    {
        int key = 1;
        nJson jsonArray = nJson::array();
        for(const auto& item : listItems)
        {
            nJson json0;
            json0["opName"] = "ACAS_UpdateCompareItem";
            json0["Key"] = key++;

            nJson jsonItem;
            jsonItem["itemID"] = item.nID;
            jsonItem["itemName"] = item.strName.toStdString();
            jsonItem["itemEnable"] = item.isEnable;
            jsonItem["roadCount"] = item.mapRoad.size();

            jsonItem["silentEnable"] = item.paramMute.isEnable;
            jsonItem["silentDuration"] = item.paramMute.nLen;
            jsonItem["silentThreshold"] = item.paramMute.threshold.nThreshold;
            jsonItem["silentSensitivity"] = item.paramMute.nSensitivity;

            jsonItem["overloadEnable"] = item.paramOverload.isEnable;
            jsonItem["overloadDuration"] = item.paramOverload.nLen;
            jsonItem["overloadThreshold"] = item.paramOverload.threshold.nThreshold;
            jsonItem["overloadSensitivity"] = item.paramOverload.nSensitivity;

            jsonItem["phaseEnable"] = item.paramPhase.isEnable;
            jsonItem["phaseDuration"] = item.paramPhase.nLen;
            jsonItem["phaseThreshold"] = item.paramPhase.threshold.dThreshold;
            jsonItem["phaseSensitivity"] = item.paramPhase.nSensitivity;

            json0["paramList"] = jsonItem;
            jsonArray.push_back(json0);
        }

        QString strSend = QString::fromStdString(jsonArray.dump());
        QString strRet;
        int ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_BatchTransAction, strSend, strRet, true);
        if(ret != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger, "更新对比项信息失败: {}, {}", ret, m_httpApi->DoGetLastError(&ret).toStdString());
            return false;
        }
    }nJsonCatch

    

    return true;
}


/* 只更新对比项通道信息，通过先删除所有的itemID的对比项，再插入所有的itemID的对比项来实现 */
bool FromWebAPI::updateCompareItemRoadOnly(const QList<CompareItemInfo_t>& listItems)
{
    /*---------------------------------- 删除对比项通道信息 ------------------------------*/
    QList<int> listItemIDs;
    for(const auto& item : listItems)
    {
        listItemIDs.append(item.nID);
    }
    if(!deleteCompareItemRoad(listItemIDs))
    {
        return false;
    }

    /*---------------------------------- 插入对比项通道信息 ------------------------------*/
    if(!insertCompareItemRoad(listItems))
    {
        return false;
    }

    return true;
}


/* 更新一条对比项通道信息 */
bool FromWebAPI::updateCompareItemOneRoadOnly(const QList<CompareItemInfo_t>& listItems)
{
    /*---------------------------------- 更新对比项通道信息 ------------------------------*/
    try
    {
        int Key = 1;
        nJson jsonArray = nJson::array();
        for(const auto& item : listItems)
        {
            for(const auto& road : item.mapRoad)
            {
                nJson json1;
                json1["opName"] = "ACAS_UpdateCompareItemOneRoad";
                json1["Key"] = Key++;

                nJson jsonRoad;
                jsonRoad["itemID"] = item.nID;
                jsonRoad["roadNum"] = road.nCompareRoadNum;
                jsonRoad["roadName"] = road.strCompareRoadName.toStdString();
                jsonRoad["roadRecordEnable"] = road.isEnableRecord;

                jsonRoad["soundCardName"] = road.scRoadInfo.strSoundCardName;
                jsonRoad["soundCardPCMName"] = road.scRoadInfo.pcmInfo.strPCMName;

                json1["paramList"] = jsonRoad;
                jsonArray.push_back(json1);
            }
        }
        QString strSend = QString::fromStdString(jsonArray.dump());
        QString strRet;
        int ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_BatchTransAction, strSend, strRet, true);
        if(ret != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger, "更新对比项通道信息失败: {}, {}", ret, m_httpApi->DoGetLastError(&ret).toStdString());
            return false;
        }

    }nJsonCatch

    return true;
}


/* 删除对比项信息 */
bool FromWebAPI::deleteCompareItem(const QList<int> listIDs)
{
    /*---------------------------------- 删除对比项信息 ------------------------------*/
    try
    {
        int Key = 1;
        nJson jsonArray = nJson::array();
        for(int id : listIDs)
        {
            nJson json0;
            json0["opName"] = "ACAS_DeleteCompareItem";
            json0["Key"] = Key++;
            nJson jsonItem;
            jsonItem["itemID"] = id;
            json0["paramList"] = jsonItem;
            jsonArray.push_back(json0);
        }
        QString strSend = QString::fromStdString(jsonArray.dump());
        QString strRet;
        int ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_BatchTransAction, strSend, strRet, true);
        if(ret != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger, "删除对比项信息失败: {}, {}", ret, m_httpApi->DoGetLastError(&ret).toStdString());
            return false;
        }
    }nJsonCatch

    /*---------------------------------- 删除对比项通道信息 ------------------------------*/
    deleteCompareItemRoad(listIDs);

    return true;
}

/* 删除对比项通道信息 */
bool FromWebAPI::deleteCompareItemRoad(const QList<int>& listIDs)
{
    /* 在创建表格的时候，设置了ItemID的关联关系，在上面删除对比项ID的时候，这个表格里的项目应该也会自动删除 */
    try
    {
        int Key = 1;
        nJson jsonArray = nJson::array();
        for(int id : listIDs)
        {
            nJson json1;
            json1["opName"] = "ACAS_DeleteCompareItemAllRoad";
            json1["Key"] = Key++;
            nJson jsonRoad;
            jsonRoad["itemID"] = id;
            json1["paramList"] = jsonRoad;
            jsonArray.push_back(json1);
        }
        QString strSend = QString::fromStdString(jsonArray.dump());
        QString strRet;
        int ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_BatchTransAction, strSend, strRet, true);
        if(ret != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger, "删除对比项通道信息失败: {}, {}", ret, m_httpApi->DoGetLastError(&ret).toStdString());
            return false;
        }
    }nJsonCatch

    return true;
}

/* 只删除对比项通道信息，int是对比项ID */
bool FromWebAPI::deleteCompareItemRoad(QMap<int, QList<int>>& mapItemRoads)
{
    /*---------------------------------- 删除对比项通道信息 ------------------------------*/
    try
    {
        int Key = 1;
        nJson jsonArray = nJson::array();
        for(auto it = mapItemRoads.begin(); it != mapItemRoads.end(); ++it)
        {
            int itemID = it.key();
            for(int roadNum : it.value())
            {
                nJson json1;
                json1["opName"] = "ACAS_DeleteCompareItemOneRoad";
                json1["Key"] = Key++;
                nJson jsonRoad;
                jsonRoad["itemID"] = itemID;
                jsonRoad["roadNum"] = roadNum;
                json1["paramList"] = jsonRoad;
                jsonArray.push_back(json1);
            }
        }
        QString strSend = QString::fromStdString(jsonArray.dump());
        QString strRet;
        int ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_BatchTransAction, strSend, strRet, true);
        if(ret != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger, "删除对比项通道信息失败: {}, {}", ret, m_httpApi->DoGetLastError(&ret).toStdString());
            return false;
        }
    }nJsonCatch

    return true;
}

/* 获取系统配置信息 */
bool FromWebAPI::getSystemConfig(QMap<std::string, std::string>& mapConfig)
{
    try
    {
        nJson json0;
        json0["opName"] = "ACAS_GetSystemConfigInfo";
        QString strSend = QString::fromStdString(json0.dump());
        QString strRet;
        int ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_Select, strSend, strRet, true);
        if(ret != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger, "获取系统配置信息失败, 错误码: {}, {}", ret, strRet.toStdString());
            return false;
        }

        nJson jsonRet;
        /* 将json的key全部转换成小写 */
        convertJsonKeyToLower(nJson::parse(strRet.toStdString()), jsonRet);
        int code = jsonRet["code"].get<int>();
        if(code != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger, "获取系统配置信息失败，错误码: {}, 错误信息: {}", code, jsonRet["message"].get<std::string>()); 
            return false;
        }
        nJson jsonResult = jsonRet["result"];
        for(const auto& item : jsonResult)
        {
            std::string key = item["configkey"].get<std::string>();
            std::string value = item["configvalue"].get<std::string>();
            mapConfig.insert(key, value);
        }

    }nJsonCatch

    return true;
}

/* 更新系统配置信息  */
bool FromWebAPI::updateSystemConfig(const std::string& key, const std::string& value, const std::string& desc)
{
    try
    {
        nJson json0;
        json0["opName"] = "ACAS_UpdateSystemConfigInfo";
        
        nJson jsonData;
        jsonData["configKey"] = key;
        jsonData["configValue"] = value;
        jsonData["configDesc"] = desc;
        json0["paramList"] = jsonData;
    
        QString strSend = QString::fromStdString(json0.dump());
        QString strRet;
        int ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_Update, strSend, strRet, true);
        if(ret != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger, "更新系统设置失败, 错误码:{}, {}", ret, strRet.toStdString());
            return false;
        }
    }nJsonCatch

    return true;
}

/* 获取检测时段配置 */
bool FromWebAPI::getDetectPeriodConfig(QMap<int, DetectPeriodConfig_t>& mapDetectConfig)
{
    try
    {
        nJson json0;
        json0["opName"] = "ACAS_GetDetectPeriod";
        QString strSend = QString::fromStdString(json0.dump());
        QString strRet;
        int ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_Select, strSend, strRet, true);
        if(ret != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger, "获取对比项检测时段信息失败, 错误码: {}, {}", ret, strRet.toStdString());
            return false;
        }

        nJson jsonRet;
        /* 将json的key全部转换成小写 */
        convertJsonKeyToLower(nJson::parse(strRet.toStdString()), jsonRet);
        int code = jsonRet["code"].get<int>();
        if(code != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger, "获取对比项检测时段信息失败，错误码: {}, 错误信息: {}", code, jsonRet["message"].get<std::string>()); 
            return false;
        }
        nJson jsonResult = jsonRet["result"];
        mapDetectConfig.clear();
        bool isOnceAsOthrer = true;
        for(const auto& it : jsonResult)
        {
            int id = it["itemid"].get<int>();
            /* 如果这个ID不存在，会默认创建一个 DetectPeriodConfig_t，以这个ID为键 */
            DetectPeriodConfig_t& detectConfig = mapDetectConfig[id];
            detectConfig.nID = id;
            bool isDetect = it["isdetect"].get<bool>();
            if(isDetect)
            {
                /* 是检测时段 */
                OnePlan_t plan;
                plan.weekType = static_cast<eWeekType>(it["weektype"].get<int>());
                plan.timeStart = QTime::fromString(QString::fromStdString(it["timestart"].get<std::string>()), "HH:mm:ss");
                plan.timeEnd = QTime::fromString(QString::fromStdString(it["timeend"].get<std::string>()), "HH:mm:ss");

                detectConfig.listDetect.append(plan);
            }else 
            {
                /* 不是检测时段 */
                OnePlan_t plan;
                plan.date = it["cdate"].is_null() ? QDate() : QDate::fromString(QString::fromStdString(it["cdate"].get<std::string>()), "yyyy-MM-dd");
                plan.timeStart = QTime::fromString(QString::fromStdString(it["timestart"].get<std::string>()), "HH:mm:ss");
                plan.timeEnd = QTime::fromString(QString::fromStdString(it["timeend"].get<std::string>()), "HH:mm:ss");

                detectConfig.listNoDetect.append(plan);

                
            }
            /* 获取计划是否应用于静音、过载、反相、噪音检测 */
            if(isOnceAsOthrer)
            {
                detectConfig.isApplySlient = it["applyslient"].get<bool>();
                detectConfig.isApplyOverload = it["applyoverload"].get<bool>();
                detectConfig.isApplyPhase = it["applyphase"].get<bool>();
                detectConfig.isApplyNoise = it["applynoise"].get<bool>();

                isOnceAsOthrer = false; // 只需要获取一次就行了
            }
        }

    }nJsonCatch

    return true;
}

/* 插入检测时段配置 */
bool FromWebAPI::insertDetectPeriodConfig(const QMap<int, DetectPeriodConfig_t>& mapDetectConfig)
{
    try
    {
        int Key = 1;
        nJson jsonArray = nJson::array();
        for(auto it = mapDetectConfig.begin(); it != mapDetectConfig.end(); ++it)
        {
            int itemID = it.key();
            /* 先添加检测计划 */
            for(auto& plan : it.value().listDetect)
            {
                nJson json1;
                json1["opName"] = "ACAS_InsertDetectPeriod";
                json1["Key"] = Key++;
                nJson jsonPlan;
                jsonPlan["itemID"] = itemID;
                jsonPlan["isDetect"] = true;
                jsonPlan["weekType"] = static_cast<int>(plan.weekType);
                jsonPlan["cDate"] = ""; // 检测计划没有日期
                jsonPlan["timeStart"] = plan.timeStart.toString("HH:mm:ss").toStdString();
                jsonPlan["timeEnd"] = plan.timeEnd.toString("HH:mm:ss").toStdString();

                /* 设置是否应用于其它检测 */
                jsonPlan["applySlient"] = it.value().isApplySlient;
                jsonPlan["applyOverload"] = it.value().isApplyOverload;
                jsonPlan["applyPhase"] = it.value().isApplyPhase;
                jsonPlan["applyNoise"] = it.value().isApplyNoise;

                json1["paramList"] = jsonPlan;
                jsonArray.push_back(json1);
            }

            /* 再添加非检测计划 */
            for(auto& plan : it.value().listNoDetect)
            {
                nJson json1;
                json1["opName"] = "ACAS_InsertDetectPeriod";
                json1["Key"] = Key++;
                nJson jsonPlan;
                jsonPlan["itemID"] = itemID;
                jsonPlan["isDetect"] = false;
                jsonPlan["weekType"] = static_cast<int>(eWeekType::Week_Special);
                jsonPlan["cDate"] = plan.date.isValid() ? plan.date.toString("yyyy-MM-dd").toStdString() : "";
                jsonPlan["timeStart"] = plan.timeStart.toString("HH:mm:ss").toStdString();
                jsonPlan["timeEnd"] = plan.timeEnd.toString("HH:mm:ss").toStdString();

                /* 设置是否应用于其它检测 */
                jsonPlan["applySlient"] = it.value().isApplySlient;
                jsonPlan["applyOverload"] = it.value().isApplyOverload;
                jsonPlan["applyPhase"] = it.value().isApplyPhase;
                jsonPlan["applyNoise"] = it.value().isApplyNoise;

                json1["paramList"] = jsonPlan;
                jsonArray.push_back(json1);
            }
        }
        QString strSend = QString::fromStdString(jsonArray.dump());
        QString strRet;
        int ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_BatchTransAction, strSend, strRet, true);
        if(ret != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger, "写入 对比项检测计划 信息失败: {}, {}", ret, m_httpApi->DoGetLastError(&ret).toStdString());
            return false;
        }
    }nJsonCatch

    return true;
}

/* 删除某些对比项的检测时段 */
bool FromWebAPI::deleteDetectPeriodConfig(const QList<int>& listIDs)
{
    try
    {
        int Key = 1;
        nJson jsonArray = nJson::array();
        for(auto it : listIDs)
        {
            int itemID = it;
            nJson json1;
            json1["opName"] = "ACAS_DeleteDetectPeriod";
            json1["Key"] = Key++;
            nJson josnItem;
            josnItem["itemID"] = itemID;
            json1["paramList"] = josnItem;
            
            jsonArray.push_back(json1);
        }
        QString strSend = QString::fromStdString(jsonArray.dump());
        QString strRet;
        int ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_BatchTransAction, strSend, strRet, true);
        if(ret != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger, "删除对比项检测时段信息失败: {}, {}", ret, m_httpApi->DoGetLastError(&ret).toStdString());
            return false;
        }
    }nJsonCatch

    return true;
}


/* 写入报警信息 */
bool FromWebAPI::insertAlarmInfo(const std::list<AlarmInfo_t>& listAlarm)
{
    try
    {
        int Key = 1;
        nJson jsonArray = nJson::array();
        for(auto it : listAlarm)
        {
            nJson json1;
            json1["opName"] = "ACAS_InsertAlarmInfo";
            json1["Key"] = Key++;
            nJson jsonAlarm;
            jsonAlarm["itemID"] = it.CompareItemID;
            jsonAlarm["itemName"] = it.strCompareItemName.toStdString();
            jsonAlarm["alarmType"] = static_cast<int>(it.AlarmType);
            jsonAlarm["soundCardName"] = it.RoadInfo.scRoadInfo.strSoundCardName;
            jsonAlarm["soundCardPCMName"] = it.RoadInfo.scRoadInfo.pcmInfo.strPCMName;
            jsonAlarm["compareRoadNum"] = it.RoadInfo.nCompareRoadNum;
            jsonAlarm["compareRoadName"] = it.RoadInfo.strCompareRoadName.toStdString();
            jsonAlarm["compareRoadType"] = static_cast<int>(it.RoadType);
            jsonAlarm["alarmStartTime"] = it.StartTime.toString("yyyy-MM-dd HH:mm:ss").toStdString();
            jsonAlarm["alarmEndTime"] = it.EndTime.toString("yyyy-MM-dd HH:mm:ss").toStdString();
            jsonAlarm["alarmDuration"] = it.StartTime.secsTo(it.EndTime);
            jsonAlarm["alarmFilePath"] = it.strAlarmFilePath.toStdString();
            jsonAlarm["fileAlarmStartPos"] = it.AlarmStartPos;
            jsonAlarm["fileState"] = static_cast<int>(it.fileState);

            json1["paramList"] = jsonAlarm;
            
            jsonArray.push_back(json1);
        }
        QString strSend = QString::fromStdString(jsonArray.dump());
        QString strRet;
        int ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_BatchTransAction, strSend, strRet, true);
        if(ret != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger, "写入报警数据失败: {}, {}", ret, m_httpApi->DoGetLastError(&ret).toStdString());
            return false;
        }
    }nJsonCatch

    return true;
}



/* 写入一致性报警信息，先写入主通道报警，获取返回的PKID，再写入次通道数据 */
bool FromWebAPI::insertConsistencyAlarmInfo(const AlarmInfo_t& mainAlarm, const AlarmInfo_t& subAlarm)
{
    try
    {
        nJson json0;
        json0["opName"] = "ACAS_InsertTwoAlarmInfo";
        nJson json1;
        json1["itemID1"] = mainAlarm.CompareItemID;
        json1["itemName1"] = mainAlarm.strCompareItemName.toStdString();
        json1["alarmType1"] = static_cast<int>(mainAlarm.AlarmType);
        json1["soundCardName1"] = mainAlarm.RoadInfo.scRoadInfo.strSoundCardName;
        json1["soundCardPCMName1"] = mainAlarm.RoadInfo.scRoadInfo.pcmInfo.strPCMName;
        json1["compareRoadNum1"] = mainAlarm.RoadInfo.nCompareRoadNum;
        json1["compareRoadName1"] = mainAlarm.RoadInfo.strCompareRoadName.toStdString();
        json1["compareRoadType1"] = static_cast<int>(mainAlarm.RoadType);
        json1["alarmStartTime1"] = mainAlarm.StartTime.toString("yyyy-MM-dd HH:mm:ss").toStdString();
        json1["alarmEndTime1"] = mainAlarm.EndTime.toString("yyyy-MM-dd HH:mm:ss").toStdString();
        json1["alarmDuration1"] = mainAlarm.StartTime.secsTo(mainAlarm.EndTime);
        json1["alarmFilePath1"] = mainAlarm.strAlarmFilePath.toStdString();
        json1["fileAlarmStartPos1"] = mainAlarm.AlarmStartPos;
        json1["fileState1"] = static_cast<int>(mainAlarm.fileState);

        json1["itemID2"] = subAlarm.CompareItemID;
        json1["itemName2"] = subAlarm.strCompareItemName.toStdString();
        json1["alarmType2"] = static_cast<int>(subAlarm.AlarmType);
        json1["soundCardName2"] = subAlarm.RoadInfo.scRoadInfo.strSoundCardName;
        json1["soundCardPCMName2"] = subAlarm.RoadInfo.scRoadInfo.pcmInfo.strPCMName;
        json1["compareRoadNum2"] = subAlarm.RoadInfo.nCompareRoadNum;
        json1["compareRoadName2"] = subAlarm.RoadInfo.strCompareRoadName.toStdString();
        json1["compareRoadType2"] = static_cast<int>(subAlarm.RoadType);
        json1["alarmStartTime2"] = subAlarm.StartTime.toString("yyyy-MM-dd HH:mm:ss").toStdString();
        json1["alarmEndTime2"] = subAlarm.EndTime.toString("yyyy-MM-dd HH:mm:ss").toStdString();
        json1["alarmDuration2"] = subAlarm.StartTime.secsTo(subAlarm.EndTime);
        json1["alarmFilePath2"] = subAlarm.strAlarmFilePath.toStdString();
        json1["fileAlarmStartPos2"] = subAlarm.AlarmStartPos;
        json1["fileState2"] = static_cast<int>(subAlarm.fileState);

        json0["paramList"] = json1;
        SPDLOG_LOGGER_DEBUG(m_logger, "写入一致性报警信息: {}", json0.dump(4));
        QString strSend = QString::fromStdString(json0.dump());
        QString strRet;
        int ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_Insert, strSend, strRet, true);
        if(ret != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger, "写入一致性报警信息失败: {}, {}", ret, m_httpApi->DoGetLastError(&ret).toStdString());
            return false;
        }
    }nJsonCatch

    return true;
}


/* 删除早于一定时间的报警信息 */
bool FromWebAPI::deleteAlarmInfoBeforeTime(const QDateTime& timePoint)
{
    try
    {
        nJson json0;
        json0["opName"] = "ACAS_DeleteAlarmFileInfoBeforeTime";
        nJson jsonParam;
        jsonParam["timePoint"] = timePoint.toString("yyyy-MM-dd HH:mm:ss").toStdString();
        json0["paramList"] = jsonParam;
        QString strSend = QString::fromStdString(json0.dump());
        QString strRet;
        int ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_Delete, strSend, strRet, true);
        if(ret != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger, "删除早于一定时间的报警信息失败: {}, {}", ret, m_httpApi->DoGetLastError(&ret).toStdString());
            return false;
        }
    }nJsonCatch

    return true;
}

/* 获取早于某个时间点的报警信息 */
bool FromWebAPI::getAlarmInfoBeforeTime(const QDateTime& timePoint, std::list<AlarmInfo_t>& listAlarm)
{
    try 
    {
        nJson json0;
        json0["opName"] = "ACAS_GetAlarmFileInfoBeforeTime";
        nJson jsonParam;
        jsonParam["timePoint"] = timePoint.toString("yyyy-MM-dd HH:mm:ss").toStdString();
        json0["paramList"] = jsonParam;
        QString strSend = QString::fromStdString(json0.dump());
        QString strRet;
        int ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_Select, strSend, strRet, true);
        if(ret != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger, "获取早于某个时间点的报警信息失败: {}, {}", ret, strRet.toStdString());
            return false;
        }
        nJson jsonRet;
        /* 将json的key全部转换成小写 */
        convertJsonKeyToLower(nJson::parse(strRet.toStdString()), jsonRet);
        int code = jsonRet["code"].get<int>();
        if(code != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger, "获取早于某个时间点的报警信息失败，错误码: {}, 错误信息: {}", code, jsonRet["message"].get<std::string>()); 
            return false;
        }
        nJson jsonResult = jsonRet["result"];
        listAlarm.clear();
        for(const auto& it : jsonResult)
        {
            AlarmInfo_t alarm;
            alarm.PKID = it["pkid"].get<int>();
            alarm.CompareItemID = it["itemid"].get<int>();
            alarm.strCompareItemName = QString::fromStdString(it["itemname"].get<std::string>());

            alarm.StartTime = QDateTime::fromString(QString::fromStdString(it["alarmstarttime"].get<std::string>()), "yyyy-MM-dd HH:mm:ss");
            alarm.EndTime = QDateTime::fromString(QString::fromStdString(it["alarmendtime"].get<std::string>()), "yyyy-MM-dd HH:mm:ss");
            alarm.strAlarmFilePath = QString::fromStdString(it["alarmfilepath"].get<std::string>());
            alarm.fileState = static_cast<eRecordState>(it["filestate"].get<int>());

            listAlarm.push_back(alarm);
        }

    } nJsonCatch

    return true;
}


/* 更新报警文件的状态 */ 
bool FromWebAPI::updateAlarmFileState(const std::list<AlarmInfo_t>& listAlarm)
{
    try 
    {
        nJson json0 = nJson::array();
        int Key = 1;
        for(const auto& alarm : listAlarm)
        {
            nJson jsonItem;
            jsonItem["opName"] = "ACAS_UpdateAlarmFileStateOne";
            jsonItem["Key"] = Key++;
            nJson jsonParam;
            jsonParam["pkid"] = alarm.PKID;
            jsonParam["fileState"] = static_cast<int>(alarm.fileState);
            jsonItem["paramList"] = jsonParam;

            json0.push_back(jsonItem);
        }
        // SPDLOG_LOGGER_DEBUG(m_logger, "更新报警文件状态: {}", json0.dump(4));
        QString strSend = QString::fromStdString(json0.dump());
        // SPDLOG_LOGGER_DEBUG(m_logger, "strSend Size: {}", strSend.size());
        QString strRet;
        int ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_BatchTransAction, strSend, strRet, true);
        if(ret != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger, "更新报警文件状态失败失败: {}, {}", ret, strRet.toStdString());
            return false;
        }
        

    } nJsonCatch

    return true;
}




/* 插入录音文件信息 */
bool FromWebAPI::insertRecordFileInfo(const std::list<RecordFileInfo_t>& listRecordFile)
{
    try
    {
        int Key = 1;
        nJson jsonArray = nJson::array();
        for(auto it : listRecordFile)
        {
            nJson json1;
            json1["opName"] = "ACAS_InsertRecordFileInfo";
            json1["Key"] = Key++;
            nJson jsonRecord;
            jsonRecord["itemID"] = it.ItemID;
            jsonRecord["itemName"] = it.ItemName.toStdString();
            jsonRecord["itemRoadNum"] = it.ItemRoadNum;
            jsonRecord["itemRoadName"] = it.ItemRoadName.toStdString();
            jsonRecord["soundCardName"] = it.scRoadInfo.strSoundCardName;
            jsonRecord["soundCardPCMName"] = it.scRoadInfo.pcmInfo.strPCMName;

            jsonRecord["fileStartTime"] = it.FileStartTime.toString("yyyy-MM-dd HH:mm:ss").toStdString();
            jsonRecord["fileEndTime"] = it.FileEndTime.toString("yyyy-MM-dd HH:mm:ss").toStdString();
            jsonRecord["fileDuration"] = it.FileStartTime.secsTo(it.FileEndTime);
            jsonRecord["filePath"] = it.FilePath.toStdString();
            jsonRecord["fileState"] = static_cast<int>(it.fileState);

            json1["paramList"] = jsonRecord;
            
            jsonArray.push_back(json1);
        }

        // SPDLOG_LOGGER_DEBUG(m_logger, "写入录音文件信息: {}", jsonArray.dump(4));
        QString strSend = QString::fromStdString(jsonArray.dump());
        QString strRet;
        int ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_BatchTransAction, strSend, strRet, true);
        if(ret != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger, "写入录音文件数据失败: {}, {}", ret, m_httpApi->DoGetLastError(&ret).toStdString());
            return false;
        }
    }nJsonCatch


    return true;
}

/* 更新录音文件信息，更新结束时间和文件名，1分钟写入一次文件，也就更新一次 */
bool FromWebAPI::updateRecordFileInfo(const std::list<RecordFileInfo_t>& listRecordFile)
{
    try
    {
        int Key = 1;
        nJson jsonArray = nJson::array();
        for(auto it : listRecordFile)
        {
            nJson json1;
            json1["opName"] = "ACAS_UpdateRecordFileEndTime";
            json1["Key"] = Key++;
            nJson jsonRecord;
            jsonRecord["itemID"] = it.ItemID;
            jsonRecord["itemRoadNum"] = it.ItemRoadNum;
            jsonRecord["itemRoadName"] = it.ItemRoadName.toStdString();
            jsonRecord["soundCardName"] = it.scRoadInfo.strSoundCardName;
            jsonRecord["soundCardPCMName"] = it.scRoadInfo.pcmInfo.strPCMName;

            jsonRecord["fileStartTime"] = it.FileStartTime.toString("yyyy-MM-dd HH:mm:ss").toStdString();
            jsonRecord["fileEndTime"] = it.FileEndTime.toString("yyyy-MM-dd HH:mm:ss").toStdString();
            jsonRecord["fileDuration"] = it.FileStartTime.secsTo(it.FileEndTime);
            jsonRecord["filePath"] = it.FilePath.toStdString();
            jsonRecord["fileState"] = static_cast<int>(it.fileState);

            json1["paramList"] = jsonRecord;
            
            jsonArray.push_back(json1);
        }
        
        QString strSend = QString::fromStdString(jsonArray.dump());
        QString strRet;
        int ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_BatchTransAction, strSend, strRet, true);
        if(ret != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger, "更新录音文件数据失败: {}, {}", ret, m_httpApi->DoGetLastError(&ret).toStdString());
            return false;
        }
    }nJsonCatch

    return true;
}

/* 将所有的录音文件状态设置为已删除 */
bool FromWebAPI::deleteAllRecordFileInfo()
{
    try
    {
        nJson json0;
        json0["opName"] = "ACAS_DeleteAllRecordFileInfo";
        QString strSend = QString::fromStdString(json0.dump());
        QString strRet;
        int ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_Delete, strSend, strRet, true);
        if(ret != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger, "设置所有录音文件状态失败: {}, {}", ret, m_httpApi->DoGetLastError(&ret).toStdString());
            return false;
        }
    }nJsonCatch

    return true;
}

/* 删除早于一定时间的录音文件信息 */
bool FromWebAPI::deleteRecordFileInfoBeforeTime(const QDateTime& timePoint)
{
    try
    {
        nJson json0;
        json0["opName"] = "ACAS_DeleteRecordFileInfoBeforeTime";
        nJson jsonParam;
        jsonParam["timePoint"] = timePoint.toString("yyyy-MM-dd HH:mm:ss").toStdString();
        json0["paramList"] = jsonParam;
        QString strSend = QString::fromStdString(json0.dump());
        QString strRet;
        int ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_Delete, strSend, strRet, true);
        if(ret != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger, "删除早于一定时间的录音文件信息失败: {}, {}", ret, m_httpApi->DoGetLastError(&ret).toStdString());
            return false;
        }
    }nJsonCatch

    return true;
}

/* 获取早于某个时间点的录音文件信息 */
bool FromWebAPI::getRecordFileInfoBeforeTime(const QDateTime& timePoint, std::list<RecordFileInfo_t>& listRecordFile)
{
    try
    {
        nJson json0;
        json0["opName"] = "ACAS_GetRecordFileInfoBeforeTime";
        nJson jsonParam;
        jsonParam["timePoint"] = timePoint.toString("yyyy-MM-dd HH:mm:ss").toStdString();
        json0["paramList"] = jsonParam;
        QString strSend = QString::fromStdString(json0.dump());
        QString strRet;
        int ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_Select, strSend, strRet, true);
        if(ret != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger, "获取 录音文件信息 失败, 错误码: {}, {}", ret, strRet.toStdString());
            return false;
        }

        nJson jsonRet;
        /* 将json的key全部转换成小写 */
        convertJsonKeyToLower(nJson::parse(strRet.toStdString()), jsonRet);
        int code = jsonRet["code"].get<int>();
        if(code != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger, "获取 录音文件信息 失败，错误码: {}, 错误信息: {}", code, jsonRet["message"].get<std::string>()); 
            return false;
        }
        listRecordFile.clear();
        // SPDLOG_LOGGER_TRACE(m_logger, "获取 录音文件信息 成功，返回数据: {}", jsonRet.dump(4));
        nJson jsonResult = jsonRet["result"];
        for(const auto& item : jsonResult)
        {
            RecordFileInfo_t recordFile;
            recordFile.ItemID = item["itemid"].get<int>();
            recordFile.ItemName = QString::fromStdString(item["itemname"].get<std::string>());
            recordFile.ItemRoadNum = item["itemroadnum"].get<int>();
            recordFile.ItemRoadName = QString::fromStdString(item["itemroadname"].get<std::string>());
            recordFile.scRoadInfo.strSoundCardName = item["soundcardname"].get<std::string>();
            recordFile.scRoadInfo.pcmInfo.strPCMName = item["soundcardpcmname"].get<std::string>();
            recordFile.FileStartTime = QDateTime::fromString(QString::fromStdString(item["filestarttime"].get<std::string>()), "yyyy-MM-dd HH:mm:ss");
            recordFile.FileEndTime = QDateTime::fromString(QString::fromStdString(item["fileendtime"].get<std::string>()), "yyyy-MM-dd HH:mm:ss");
            recordFile.FilePath = QString::fromStdString(item["filepath"].get<std::string>());
            recordFile.FileDuration = item["fileduration"].get<int>();
            recordFile.fileState = static_cast<eRecordState>(item["filestate"].get<int>());

            listRecordFile.push_back(recordFile);
        }

    }nJsonCatch

    return true;
}


/* 获取声卡信息 */
bool FromWebAPI::getSoundCardInfo(std::map<std::string, SoundCardPCMInfo_t>& mapSoundCard)
{
    try
    {
        nJson json0;
        json0["opName"] = "ACAS_GetSoundCardPCMChannels";
        QString strSend = QString::fromStdString(json0.dump());
        QString strRet;
        int ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_Select, strSend, strRet, true);
        if(ret != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger, "获取声卡信息失败: {}, {}", ret, m_httpApi->DoGetLastError(&ret).toStdString());
            return false;
        }

        /* 解析并转换成小写key */
        nJson jsonRet;
        convertJsonKeyToLower(nJson::parse(strRet.toStdString()), jsonRet);
        int code = jsonRet["code"].get<int>();
        if(code != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger, "获取声卡信息失败，错误码: {}, 错误信息: {}", code, jsonRet["message"].get<std::string>());
            return false;
        }

        nJson jsonResult = jsonRet["result"];
        mapSoundCard.clear();

        for(const auto& item : jsonResult)
        {
            std::string soundCardName = item["soundcardname"].get<std::string>();
            auto it = mapSoundCard.find(soundCardName);
            if(it == mapSoundCard.end())
            {
                mapSoundCard[soundCardName] = SoundCardPCMInfo_t();
                it = mapSoundCard.find(soundCardName);
            }

            // 找到对应的声卡信息
            SoundCardPCMInfo_t& soundCardInfo = it->second;
            soundCardInfo.strSoundCardName = soundCardName;

            OnePCMChannelInfo_t pcmChannelInfo;
            pcmChannelInfo.strPCMName = item["pcmname"].get<std::string>();
            pcmChannelInfo.strPCMDesc = item["pcmdesc"].get<std::string>();
            pcmChannelInfo.strIO = item["ioid"].get<std::string>();
            soundCardInfo.listPCM.push_back(pcmChannelInfo);
            
        }

    } nJsonCatch

    return true;
}

/* 清空表格 */
bool FromWebAPI::clearSoundCardInfo()
{
    try
    {
        nJson json0;
        json0["opName"] = "ACAS_ClearSoundCardPCMInfo";
        QString strSend = QString::fromStdString(json0.dump());
        QString strRet;
        int ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_Delete, strSend, strRet, true);
        if(ret != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger, "清空声卡信息失败: {}, {}", ret, m_httpApi->DoGetLastError(&ret).toStdString());
            return false;
        }
    }nJsonCatch

    return true;
}

/* 插入PCM通道信息 */
bool FromWebAPI::insertPCMChannelInfo(const std::map<std::string, SoundCardPCMInfo_t>& mapSoundCard)
{
    try 
    {
        nJson jsonArray = nJson::array();
        int Key = 1;

        for(const auto& soundCard : mapSoundCard)
        {

            for(const auto& pcmChannel : soundCard.second.listPCM)
            {
                nJson jsonItem;
                jsonItem["Key"] = Key++;
                jsonItem["opName"] = "ACAS_InsertSoundCardPCMChannels";
                nJson jsonParam;
                jsonParam["soundCardName"] = soundCard.first;
                jsonParam["pcmName"] = pcmChannel.strPCMName;
                jsonParam["pcmDesc"] = pcmChannel.strPCMDesc;
                jsonParam["ioid"] = pcmChannel.strIO;
                jsonParam["soundCardNum"] = 0;
                jsonParam["soundCardRoadNum"] = 0;

                jsonItem["paramList"] = jsonParam;

                jsonArray.push_back(jsonItem);
            }
        }

        QString strSend = QString::fromStdString(jsonArray.dump());
        QString strRet;
        int ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_BatchTransAction, strSend, strRet, true);
        if(ret != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger, "插入PCM通道信息失败: {}, {}", ret, m_httpApi->DoGetLastError(&ret).toStdString());
            return false;
        }

    }nJsonCatch

    return true;
}