SecurePlay/SecurePlayAuxServer/communication/FromWebAPI.cpp

#include "FromWebAPI.h"

#include <QJsonDocument>
#include <QString>
#include <QUuid>
#include "FuncOnAndOffWork.h"
#include "FuncRegionalPerson.h"
#include "UniversalFunc.h"


FromWebAPI::FromWebAPI()
{
    m_logger = spdlog::get("FromWebAPI");
    if(m_logger == nullptr)
    {
        fmt::print("FromWebAPI logger is nullptr");
        return;
    }
}

FromWebAPI::~FromWebAPI()
{
    if(m_httpApi != nullptr)
    {
        delete m_httpApi;
        m_httpApi = nullptr;
    }
}


/* 初始化WebApi */
bool FromWebAPI::initWebApi(const QString& url,const QString& serID, const QString appType, const QString& serverIP)
{
    if(m_httpApi == nullptr)
    {
        m_httpApi = new lhhttpapi;
    }
    
    if(!m_httpApi->Load())
    {
        SPDLOG_LOGGER_ERROR(m_logger, "Load WebAPI failed");
        return false;
    }
    SPDLOG_LOGGER_DEBUG(m_logger, "URL: {}", url.toStdString());
    SPDLOG_LOGGER_DEBUG(m_logger, "ServerID: {}", serID.toStdString());
    SPDLOG_LOGGER_DEBUG(m_logger, "ServerKey: {}", appType.toStdString());

    void* pHttp = nullptr;
    int i = 0;
    for(i = 0; i < 3; i++)
    {
        pHttp = m_httpApi->DBInit(url.toStdString().c_str(), true);
        if(pHttp != nullptr)
        {
            break;
        }
        SPDLOG_LOGGER_ERROR(m_logger, "设置WebAPI地址失败: {}", m_httpApi->DoGetLastError(&i).toStdString());
    }
    if(i >= 3)
    {
        SPDLOG_LOGGER_ERROR(m_logger, "WebAPI设置地址错误!");
        return false;
    }
    
    int ret = 0;

#ifdef QT_DEBUG
    /* 获取服务器列表 */
    // char serverList[8192]={0};
    // ret = m_httpApi->DBGetServerList(serverList, 8192-1);
    // if(ret != 0)
    // {
    //     SPDLOG_LOGGER_ERROR(m_logger, "Get server list failed: {}, error info: {}", ret, m_httpApi->DoGetLastError(&ret).toStdString());
    //     return false;
    // }
    // SPDLOG_LOGGER_INFO(m_logger, QString("\nGet server list success:%1").arg(serverList));
#endif

    /* 登录，第二个参数是限制的服务 */
    for(i = 0; i < 3; i++)
    {
        ret = m_httpApi->DBLogin("", serID, appType, m_userToken, true, pHttp);
        if(ret == 0)
        {
            break;
        }
        SPDLOG_LOGGER_ERROR(m_logger, "Login failed: {}, error info: {}", ret, m_httpApi->DoGetLastError(&ret).toStdString());
        /* 登录失败，等待一段时间 */
        QThread::msleep(200);
    }
    if(i >= 3)
    {
        SPDLOG_LOGGER_ERROR(m_logger, "登陆WebAPI失败！");
        return false;
    }

    SPDLOG_LOGGER_INFO(m_logger, "WebAPI Login success!");

    return true;
}


/**
 * @brief 写入算法信息，写入tAction表
 * 
 * @param vecInfo 要写入的表格数据
 * @param vecNowInfo 现有的表格数据,主要是为了重复利用已经删除的自增主键而传入的
 * @return true 
 * @return false 
 */
bool FromWebAPI::writeAlgorithmInfo(std::vector<AlgorithmInfo>& vecInfo)
{
    if(m_httpApi == nullptr)
    {
        SPDLOG_LOGGER_ERROR(m_logger,"WebApi is nullptr");
        return false;
    }
    /* 取出可用的自增主键,从0开始计算 */
    // std::list<int> listPKID;
    // int nPKID = 0;
    // for(const auto& it : vecNowInfo)
    // {
    //     while(it.ActionTaskID == nPKID)
    //     {
    //         if(it.PKID != nPKID)
    //         {
    //             listPKID.push_back(nPKID);
    //             break;
    //         }
    //         nPKID ++;
    //     }
    // }
    /* 循环写入数据 */
    try
    {
        nJson json0 = nJson::array();
        for(const auto& it : vecInfo)
        {
            /* 操作名称，现在一次性将设备位置和线条信息都下载下来 */
            nJson json1;
            json1["opName"] = "SPSS_InsertToAction";
            json1["Key"] = QUuid::createUuid().toString().toStdString();
            nJson json2;
            json2["actionID"] = it.ActionID;                    /* 算法ID */
            json2["actionName"] = it.ActionName;                /* 算法名称 */
            json2["actionTaskID"] = it.ActionTaskID;            /* 算法类型 */
            json1["paramList"] = json2;

            json0.push_back(json1);
        }
        QString retStr;
        QString strCmd = QString::fromStdString(json0.dump());
        int ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_BatchTransAction, strCmd, retStr, true);
        if(ret != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger,"写入tAction失败:{}, 错误信息:{}",ret,m_httpApi->DoGetLastError(&ret).toStdString());
        }

    }
    catch (const nJson::parse_error& e) {
        SPDLOG_LOGGER_ERROR(m_logger,"创建 算法JSON 数据失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch (const nJson::type_error& e) {
        SPDLOG_LOGGER_ERROR(m_logger,"创建 算法JSON 数据失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch(...) {
        SPDLOG_LOGGER_ERROR(m_logger,"创建 算法JSON 数据失败");
        return false;
    }

    return true;
}

/* 删除算法信息 */
bool FromWebAPI::deleteAlgorithmInfo(std::vector<AlgorithmInfo>& vecDeleteInfo)
{
    if(m_httpApi == nullptr)
    {
        SPDLOG_LOGGER_ERROR(m_logger,"WebApi is nullptr");
        return false;
    }

    try
    {
        nJson json0 = nJson::array();

        for(const auto& it : vecDeleteInfo)
        {
            nJson json1;
            json0["opName"] = "SPSS_DeleteFromAction";
            json1["Key"] = QUuid::createUuid().toString().toStdString();
            nJson json2;
            json2["actionID"] = it.ActionID;
            json0["paramList"] = json2;

            json0.push_back(json1);
        }
        QString strCmd = QString::fromStdString(json0.dump());
        QString strRet;
        int ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_BatchTransAction, strCmd, strRet, true);
        if(ret != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger,"删除tAction失败:{}, 错误信息:{}",ret,m_httpApi->DoGetLastError(&ret).toStdString());
            return false;
        }
    }
    catch (const nJson::parse_error& e) {
        SPDLOG_LOGGER_ERROR(m_logger,"创建 删除算法的JSON 数据失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch (const nJson::type_error& e) {
        SPDLOG_LOGGER_ERROR(m_logger,"创建 删除算法的JSON 数据失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch(...) {
        SPDLOG_LOGGER_ERROR(m_logger,"创建 删除算法的JSON 数据失败");
        return false;
    }


    return true;
}

/* 获取tAction数据 */
bool FromWebAPI::getAlgorithmInfo(std::vector<AlgorithmInfo>& vecInfo)
{
    if(m_httpApi == nullptr)
    {
        SPDLOG_LOGGER_ERROR(m_logger, "WebAPI is nullptr");
        return false;
    }
    /* 清空内容 */
    vecInfo.clear();

    nJson json0;
    json0["opName"] = "SPSS_SelectFromAction";
    QString strCmd = QString::fromStdString(json0.dump());
    QString strRet;
    auto ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_Select, strCmd, strRet, true);
    if(ret != 0)
    {
        SPDLOG_LOGGER_DEBUG(m_logger,"获取tAction失败:{}, 错误信息:{}",ret,m_httpApi->DoGetLastError(&ret).toStdString());
        return false;
    }
    /* 解析获取到的JSON数据 */
    // SPDLOG_LOGGER_DEBUG(m_logger,"\n{}",strRet.toStdString());
    try {
        nJson json1 = nJson::parse(strRet.toStdString());
        int retCode = json1["code"].get<int>();
        if(retCode != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger,"获取tAction失败");
            return false;
        }
        nJson result = json1["result"];
        for(auto& it : result)
        {
            AlgorithmInfo info;
            info.ActionID = it["actionId"].is_null() ? "" : it["actionId"].get<std::string>();
            info.ActionName = it["actionName"].get<std::string>();
            info.ActionTaskID = it["actionTaskid"].get<int>();
            // SPDLOG_LOGGER_DEBUG(m_logger,"ActionID:{}, ActionName:{}, ActionTaskID:{}",info.ActionID,info.ActionName,info.ActionTaskID);
            vecInfo.push_back(info);
        }
    }
    catch (const nJson::parse_error& e) {
        SPDLOG_LOGGER_ERROR(m_logger,"创建 tAction 数据失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch (const nJson::type_error& e) {
        SPDLOG_LOGGER_ERROR(m_logger,"创建 tAction 数据失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch(...) {
        SPDLOG_LOGGER_ERROR(m_logger,"创建 tAction 数据失败");
        return false;
    }

    return true;
}


/* 插入设备信息 */
bool FromWebAPI::insertDeviceInfo(std::vector<DeviceInfo>& vecInfo)
{
    if(m_httpApi == nullptr)
    {
        SPDLOG_LOGGER_ERROR(m_logger,"WebApi is nullptr");
        return false;
    }
    if(vecInfo.empty())
    {
        return false;
    }
    bool isSuccess = true;
    try
    {
        nJson json0 = nJson::array();
        for(const auto& it : vecInfo)
        {
            nJson json1;
            json1["opName"] = "SPSS_InsertToCamerInfo";
            json1["Key"] = QUuid::createUuid().toString().toStdString();
            nJson json2;
            /* 这里不知道是不是“?”运算符的等级是不是不够，不加括号会报错 */
            json2["camerID"] = it.DeviceID;
            json2["camerName"] =  it.DeviceName;
            json2["camerIP"] = it.DeviceIP;
            json2["camerPort"] = it.DevicePort;
            json2["camerUser"] = it.UserAccount;
            json2["camerPwd"] = it.UserPassword;
            json2["camerType"] = it.DeviceType;
            json2["camerSerial"] = it.DeviceSerial;
            json2["camerChannel"] = nullptr;
            json2["camerUrl"] = nullptr;

            json1["paramList"] = json2;
            
            json0.push_back(json1);
        }
        QString strCmd = QString::fromStdString(json0.dump());
        QString strRet;
        auto ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_BatchTransAction, strCmd, strRet, true);
        if(ret != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger,"插入设备信息失败:{}, 错误信息:{}",ret,m_httpApi->DoGetLastError(&ret).toStdString());
            isSuccess = false;
        }
        
        // /* 插入信息到tActionCamer表 */
        // json0.clear();
        // for(const auto& it0 : vecInfo)
        // {
        //     for(const auto& it1 : it0.vecAlgorithmInfo)
        //     {
        //         nJson json1;
        //         json1["opName"] = "SPSS_InsertToActionCamer";
        //         json1["Key"] = QUuid::createUuid().toString().toStdString();
        //         nJson json2;
        //         json2["actionID"] = it1.ActionID;
        //         json2["camerID"] = it0.DeviceID;
        //         json1["paramList"] = json1;
                
        //         json0.push_back(json1);
        //     }
        // }
        // strCmd.clear();
        // strRet.clear();
        // ret = 0;
        // strCmd = QString::fromStdString(json0.dump());
        // ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_Insert, strCmd, strRet, true);
        // if(ret != 0)
        // {
        //     SPDLOG_LOGGER_DEBUG(m_logger,"插入设备信息到tActionCamer失败:{}, 错误信息:{}",ret,m_httpApi->DoGetLastError(&ret).toStdString());
        //     isSuccess = false;
        // }

    }
    catch (const nJson::parse_error& e) {
        SPDLOG_LOGGER_ERROR(m_logger,"创建 设备信息JSON 数据失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch (const nJson::type_error& e) {
        SPDLOG_LOGGER_ERROR(m_logger,"创建 设备信息JSON 数据失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch(...) {
        SPDLOG_LOGGER_ERROR(m_logger,"创建 设备信息JSON 数据失败");
        return false;
    }

    return isSuccess;
}


/* 更新设备信息 */
bool FromWebAPI::updateDeviceInfo(std::vector<DeviceInfo>& vecUpdateInfo)
{
    if(m_httpApi == nullptr)
    {
        SPDLOG_LOGGER_ERROR(m_logger,"WebApi is nullptr");
        return false;
    }
    if(vecUpdateInfo.empty())
    {
        return false;
    }
    bool isSuccess = true;
    try
    {
        nJson json0 = nJson::array();
        for(const auto& it : vecUpdateInfo)
        {
            nJson json1;
            json1["opName"] = "SPSS_UpdateToCamerInfo";
            json1["Key"] = QUuid::createUuid().toString().toStdString();
            nJson json2;
            json2["camerID"] = it.DeviceID;
            json2["camerName"] =  it.DeviceName;
            json2["camerIP"] = it.DeviceIP;
            json2["camerPort"] = it.DevicePort;
            json2["camerUser"] = it.UserAccount;
            json2["camerPwd"] = it.UserPassword;
            json2["camerType"] = it.DeviceType;
            json2["camerSerial"] = it.DeviceSerial;
            json2["camerChannel"] = nullptr;
            json2["camerUrl"] = nullptr;

            json1["paramList"] = json2;
            
            json0.push_back(json1);
        }

        QString strCmd = QString::fromStdString(json0.dump());
        QString strRet;
        auto ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_BatchTransAction, strCmd, strRet, true);
        if(ret != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger,"更新设备信息失败:{}, 错误信息:{}",ret,m_httpApi->DoGetLastError(&ret).toStdString());
            isSuccess = false;
        }

    }
    catch (const nJson::parse_error& e) {
        SPDLOG_LOGGER_ERROR(m_logger,"创建 更新设备信息JSON 数据失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch (const nJson::type_error& e) {
        SPDLOG_LOGGER_ERROR(m_logger,"创建 更新设备信息JSON 数据失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch(...) {
        SPDLOG_LOGGER_ERROR(m_logger,"创建 更新设备信息JSON 数据失败");
        return false;
    }


    return isSuccess;
}


/* 删除设备信息 */
bool FromWebAPI::deleteDeviceInfo(std::vector<DeviceInfo>& vecDeleteInfo)
{
    if(m_httpApi == nullptr)
    {
        SPDLOG_LOGGER_ERROR(m_logger,"WebApi is nullptr");
        return false;
    }
    if(vecDeleteInfo.empty())
    {
        return true;
    }
    bool isSuccess = true;

    try
    {
        nJson json0 = nJson::array();
        for(const auto& it : vecDeleteInfo)
        {
            nJson json1;
            json1["opName"] = "SPSS_DeleteFromCamerInfo";
            json1["Key"] = QUuid::createUuid().toString().toStdString();

            nJson json2;
            json2["camerID"] = it.DeviceID;
            json1["paramList"] = json2;
            
            json0.push_back(json1);
        }
        QString strCmd = QString::fromStdString(json0.dump());
        QString strRet;
        auto ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_BatchTransAction, strCmd, strRet, true);
        if(ret != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger,"删除tCamerinfo设备信息失败:{}, 错误信息:{}",ret,m_httpApi->DoGetLastError(&ret).toStdString());
            isSuccess = false;
        }

    }
    catch (const nJson::parse_error& e) {
        SPDLOG_LOGGER_ERROR(m_logger,"创建 删除设备信息JSON 数据失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch (const nJson::type_error& e) {
        SPDLOG_LOGGER_ERROR(m_logger,"创建 删除设备信息JSON 数据失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch(...) {
        SPDLOG_LOGGER_ERROR(m_logger,"创建 删除设备信息JSON 数据失败");
        return false;
    }

    return isSuccess;
}

/* 从EQM获取CamerInfo信息 */
bool FromWebAPI::getDeviceInfo(std::vector<DeviceInfo>& vecInfo)
{
    if(m_httpApi == nullptr)
    {
        SPDLOG_LOGGER_ERROR(m_logger,"WebApi is nullptr");
        return false;
    }

    vecInfo.clear();
    nJson json0;
    json0["opName"] = "SPSS_SelectFromCamerInfo";
    QString strCmd = QString::fromStdString(json0.dump());
    QString strRet;
    auto ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_Select, strCmd, strRet, true);
    if(ret != 0)
    {
        SPDLOG_LOGGER_DEBUG(m_logger,"获取CamerInfo失败:{}, 错误信息:{}",ret,m_httpApi->DoGetLastError(&ret).toStdString());
        return false;
    }

    // SPDLOG_LOGGER_TRACE(m_logger, "摄像机信息:\n{}", nJson::parse(strRet.toStdString()).dump(4));

    /* 解析信息 */
    try {
        nJson json1 = nJson::parse(strRet.toStdString());
        int retCode = json1["code"].get<int>();
        if(retCode != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger,"获取CamerInfo失败");
            return false;
        }
        nJson result = json1["result"];
        if(result.empty())
        {
            return false;
        }
        for(const auto& it : result)
        {
            // SPDLOG_LOGGER_DEBUG(m_logger,"camerID:{}",it["camerId"].get<int>());
            DeviceInfo info;
            info.DeviceID = it["camerId"].get<int>();
            info.DeviceName = it["camerName"].is_null() ? "" : it["camerName"].get<std::string>();
            info.DeviceIP = it["camerIp"].is_null() ? "" : it["camerIp"].get<std::string>();
            info.DevicePort = it["camerPort"].is_null() ? 0 : it["camerPort"].get<int>();
            info.UserAccount = it["camerUsr"].is_null() ? "" : it["camerUsr"].get<std::string>();
            info.UserPassword = it["camerPwd"].is_null() ? "" : it["camerPwd"].get<std::string>();
            info.DeviceType = it["camerType"].is_null() ? "" : it["camerType"].get<std::string>();
            info.DeviceSerial = it["camerSerial"].is_null() ? "" : it["camerSerial"].get<std::string>();

            vecInfo.push_back(info);
        }
    }
    catch (const nJson::parse_error& e) {
        SPDLOG_LOGGER_ERROR(m_logger,"解析 CamerInfo数据失败 数据失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch (const nJson::type_error& e) {
        SPDLOG_LOGGER_ERROR(m_logger,"解析 CamerInfo数据失败 数据失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch(...) {
        SPDLOG_LOGGER_ERROR(m_logger,"解析 CamerInfo数据失败 数据失败");
        return false;
    }


    return true;
}

/* 获取通道信息 */
bool FromWebAPI::getChannelInfo(std::map<int, std::string>& mapChannelName)
{
    if(m_httpApi == nullptr)
    {
        SPDLOG_LOGGER_ERROR(m_logger,"WebApi is nullptr");
        return false;
    }
    nJson json0;
    json0["opName"] = "SPSS_SelectChannelInfo";
    QString strCmd = QString::fromStdString(json0.dump());
    QString strRet;
    auto ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_Select, strCmd, strRet, true);
    if(ret != 0)
    {
        SPDLOG_LOGGER_DEBUG(m_logger,"获取通道信息失败:{}, 错误信息:{}",ret,m_httpApi->DoGetLastError(&ret).toStdString());
        return false;
    }
    /* 解析信息 */
    try
    {
        nJson json1 = nJson::parse(strRet.toStdString());
        int retCode = json1["code"].get<int>();
        if(retCode != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger,"获取通道信息失败");
            return false;
        }
        nJson result = json1["result"];
        if(result.empty())
        {
            return false;
        }
        for(const auto& it : result)
        {
            int id = it["chnID"].get<int>();
            std::string chnName = it["chnName"].is_null() ? "" : it["chnName"].get<std::string>();
            mapChannelName.insert(std::make_pair(id, chnName));
        }
    }
    catch (const nJson::parse_error& e) {
        SPDLOG_LOGGER_ERROR(m_logger,"解析 tChannel数据失败 数据失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch (const nJson::type_error& e) {
        SPDLOG_LOGGER_ERROR(m_logger,"解析 tChannel数据失败 数据失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch(...) {
        SPDLOG_LOGGER_ERROR(m_logger,"解析 tChannel数据失败 数据失败");
        return false;
    }

    return true;
}

std::string FromWebAPI::getChannelInfo(int chnID)
{
    if(m_httpApi == nullptr)
    {
        SPDLOG_LOGGER_ERROR(m_logger,"WebApi is nullptr");
        return "";
    }
    nJson json0;
    json0["opName"] = "SPSS_SelectChannelInfo";
    QString strCmd = QString::fromStdString(json0.dump());
    QString strRet;
    auto ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_Select, strCmd, strRet, true);
    if(ret != 0)
    {
        SPDLOG_LOGGER_DEBUG(m_logger,"获取通道信息失败:{}, 错误信息:{}",ret,m_httpApi->DoGetLastError(&ret).toStdString());
        return "false;";
    }
    /* 解析信息 */
    try
    {
        nJson json1 = nJson::parse(strRet.toStdString());
        int retCode = json1["code"].get<int>();
        if(retCode != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger,"获取通道信息失败");
            return "";
        }
        nJson result = json1["result"];
        if(result.empty())
        {
            return "";
        }
        for(const auto& it : result)
        {
            int id = it["chnID"].get<int>();
            if(id == chnID)
            {
                return it.dump();
            }
        }
        
    }
    catch (const nJson::parse_error& e) {
        SPDLOG_LOGGER_ERROR(m_logger,"解析 tChannel数据失败 数据失败:{}, 错误ID:{}",e.what(), e.id);
        return "";
    }
    catch (const nJson::type_error& e) {
        SPDLOG_LOGGER_ERROR(m_logger,"解析 tChannel数据失败 数据失败:{}, 错误ID:{}",e.what(), e.id);
        return "";
    }
    catch(...) {
        SPDLOG_LOGGER_ERROR(m_logger,"解析 tChannel数据失败 数据失败");
        return "";
    }

    return "";
}

/* 获取摄像机信息 */
bool FromWebAPI::getCameraInfo(std::map<int, std::string>& mapCameraName)
{
    if(m_httpApi == nullptr)
    {
        SPDLOG_LOGGER_ERROR(m_logger,"WebApi is nullptr");
        return false;
    }
    nJson json0;
    json0["opName"] = "SPSS_SelectCameraInfo";
    QString strCmd = QString::fromStdString(json0.dump());
    QString strRet;
    auto ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_Select, strCmd, strRet, true);
    if(ret != 0)
    {
        SPDLOG_LOGGER_DEBUG(m_logger,"获取通道信息失败:{}, 错误信息:{}",ret,m_httpApi->DoGetLastError(&ret).toStdString());
        return false;
    }
    /* 解析信息 */
    try
    {
        nJson json1 = nJson::parse(strRet.toStdString());
        int retCode = json1["code"].get<int>();
        if(retCode != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger,"获取通道信息失败");
            return false;
        }
        nJson result = json1["result"];
        if(result.empty())
        {
            return false;
        }
        for(const auto& it : result)
        {
            int id = it["camerId"].get<int>();
            std::string camerName = it["camerName"].is_null() ? "" : it["camerName"].get<std::string>();
            mapCameraName.insert(std::make_pair(id, camerName));
        }
    }
    catch (const nJson::parse_error& e) {
        SPDLOG_LOGGER_ERROR(m_logger,"解析 tChannel数据失败 数据失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch (const nJson::type_error& e) {
        SPDLOG_LOGGER_ERROR(m_logger,"解析 tChannel数据失败 数据失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch(...) {
        SPDLOG_LOGGER_ERROR(m_logger,"解析 tChannel数据失败 数据失败");
        return false;
    }

    return true;
}

/* 插入设备和算法关联信息 */
bool FromWebAPI::insertDeviceAlgorithmInfo(std::vector<DeviceInfo>& vecInfo)
{
    if(m_httpApi == nullptr)
    {
        SPDLOG_LOGGER_ERROR(m_logger,"WebApi is nullptr");
        return false;
    }
    /* 插入信息到tActionCamer表 */
    try
    {
        nJson json0 = nJson::array();
        for(const auto& it0 : vecInfo)
        {
            for(const auto& it1 : it0.vecAlgorithmInfo)
            {
                nJson json1;
                json1["opName"] = "SPSS_InsertToActionCamer";
                json1["Key"] = QUuid::createUuid().toString().toStdString();
                nJson json2;
                json2["actionID"] = it1.ActionID;
                json2["camerID"] = it0.DeviceID;
                json1["paramList"] = json1;
                
                json0.push_back(json1);
            }
        }
        QString strRet;
        QString strCmd = QString::fromStdString(json0.dump());
        int ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_BatchTransAction, strCmd, strRet, true);
        if(ret != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger,"插入设备信息到tActionCamer失败:{}, 错误信息:{}",ret,m_httpApi->DoGetLastError(&ret).toStdString());
            return false;
        }
    }
    catch (const nJson::parse_error& e) {
        SPDLOG_LOGGER_ERROR(m_logger,"创建 写入tActionCamer JSON失败 数据失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch (const nJson::type_error& e) {
        SPDLOG_LOGGER_ERROR(m_logger,"创建 写入tActionCamer JSON失败 数据失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch(...) {
        SPDLOG_LOGGER_ERROR(m_logger,"创建 写入tActionCamer JSON失败 数据失败");
        return false;
    }

    return true;
}

/* 更新设备和算法关联表 */
bool FromWebAPI::updateDeviceAlgorithmInfo(std::vector<DeviceInfo>& vecInfo)
{
    if(m_httpApi == nullptr)
    {
        SPDLOG_LOGGER_ERROR(m_logger,"WebApi is nullptr");
        return false;
    }
    /* 更新之前先删除相关的信息 */
    if(!deleteDeviceAlgorithmInfo(vecInfo))
    {
        SPDLOG_LOGGER_ERROR(m_logger,"删除 tActionCamer 关联表失败");
        return false;
    }
    /* 插入信息到tActionCamer表 */
    bool isSuccess = true;
    try
    {
        nJson json0 = nJson::array();
        for(const auto& it0 : vecInfo)
        {
            for(const auto& it1 : it0.vecAlgorithmInfo)
            {
                nJson json1;
                json1["opName"] = "SPSS_InsertToActionCamer";
                json1["Key"] = QUuid::createUuid().toString().toStdString();
                nJson json2;
                json2["actionID"] = it1.ActionID;
                json2["camerID"] = it0.DeviceID;
                json1["paramList"] = json2;

                json0.push_back(json1);
            }
        }
        QString strCmd = QString::fromStdString(json0.dump());
        QString strRet;
        auto ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_BatchTransAction, strCmd, strRet, true);
        if(ret != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger,"插入设备信息到tActionCamer失败:{}, 错误信息:{}",ret,m_httpApi->DoGetLastError(&ret).toStdString());
            isSuccess = false;
        }
        // SPDLOG_LOGGER_DEBUG(m_logger,"插入数据到ActionCamer 成功! 数目: {}", json0.size());
    }
    catch (const nJson::parse_error& e) {
        SPDLOG_LOGGER_ERROR(m_logger,"创建 插入tActionCamer JSON失败 数据失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch (const nJson::type_error& e) {
        SPDLOG_LOGGER_ERROR(m_logger,"创建 插入tActionCamer JSON失败 数据失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch(...) {
        SPDLOG_LOGGER_ERROR(m_logger,"创建 插入tActionCamer JSON失败 数据失败");
        return false;
    }


    return isSuccess;
}

/* 删除设备和算法关联表 */
bool FromWebAPI::deleteDeviceAlgorithmInfo(std::vector<DeviceInfo>& vecInfo)
{
    if(m_httpApi == nullptr)
    {
        SPDLOG_LOGGER_ERROR(m_logger,"WebApi is nullptr");
        return false;
    }
    bool isSuccess = true;
    /* 更新之前先删除相关的信息 */
    try
    {
        nJson json0 = nJson::array();
        /* 更新之前先删除相关的信息 */
        for(const auto& it : vecInfo)
        {
            nJson json1;
            json1["opName"] = "SPSS_DeleteFromActionCamer";
            json1["Key"] = QUuid::createUuid().toString().toStdString();
            nJson json2;
            json2["camerID"] = it.DeviceID;
            json1["paramList"] = json2;
            
            json0.push_back(json1);
        }

        QString strCmd = QString::fromStdString(json0.dump());
        QString strRet;
        auto ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_BatchTransAction, strCmd, strRet, true);
        if(ret != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger,"删除设备信息到tActionCamer失败:{}, 错误信息:{}",ret,m_httpApi->DoGetLastError(&ret).toStdString());
            // return false;
            isSuccess = false;
        }
        // SPDLOG_LOGGER_DEBUG(m_logger,"从 ActionCamer 删除成功! 数目:{}", vecInfo.size());
    }
    catch (const nJson::parse_error& e) {
        SPDLOG_LOGGER_ERROR(m_logger,"创建 删除tActionCamer JSON失败 数据失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch (const nJson::type_error& e) {
        SPDLOG_LOGGER_ERROR(m_logger,"创建 删除tActionCamer JSON失败 数据失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch(...) {
        SPDLOG_LOGGER_ERROR(m_logger,"创建 删除tActionCamer JSON失败 数据失败");
        return false;
    }

    return isSuccess;
}


/* 删除设备和算法关联表 */
bool FromWebAPI::deleteDeviceAlgorithmInfo(std::list<int>& vecID)
{
    if(m_httpApi == nullptr)
    {
        SPDLOG_LOGGER_ERROR(m_logger,"WebApi is nullptr");
        return false;
    }
    bool isSuccess = true;
    
    try
    {
        nJson json0 = nJson::array();
        /* 更新之前先删除相关的信息 */
        for(const auto& it : vecID)
        {
            nJson json1;
            json1["opName"] = "SPSS_DeleteFromActionCamer";
            json1["Key"] = QUuid::createUuid().toString().toStdString();
            nJson json2;
            json2["camerID"] = it;
            json1["paramList"] = json2;
            
            json0.push_back(json1);
        }

        QString strCmd = QString::fromStdString(json0.dump());
        QString strRet;
        auto ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_BatchTransAction, strCmd, strRet, true);
        if(ret != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger,"删除设备信息到tActionCamer失败:{}, 错误信息:{}",ret,m_httpApi->DoGetLastError(&ret).toStdString());
            // return false;
            isSuccess = false;
        }
        // SPDLOG_LOGGER_DEBUG(m_logger,"从 ActionCamer 删除成功! 数目:{}", vecID.size());
    }
    catch (const nJson::parse_error& e) {
        SPDLOG_LOGGER_ERROR(m_logger,"创建 删除tActionCamer JSON失败 数据失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch (const nJson::type_error& e) {
        SPDLOG_LOGGER_ERROR(m_logger,"创建 删除tActionCamer JSON失败 数据失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch(...) {
        SPDLOG_LOGGER_ERROR(m_logger,"创建 删除tActionCamer JSON失败 数据失败");
        return false;
    }
    

    return isSuccess;
}

/* 获取设备和算法信息关联表，需要先从EQM数据库中获取到设备信息 */
bool FromWebAPI::getDeviceAlgorithmInfo(std::vector<DeviceInfo>& vecInfo, std::list<int>& listDevIDDelete)
{
    if(m_httpApi == nullptr)
    {
        SPDLOG_LOGGER_ERROR(m_logger,"WebApi is nullptr");
        return false;
    }
    if(vecInfo.empty())
    {
        SPDLOG_LOGGER_WARN(m_logger,"Device info is empty");
        return false;
    }
    listDevIDDelete.clear();

    nJson json0;
    json0["opName"] = "SPSS_SelectFromActionCamer";
    QString strCmd = QString::fromStdString(json0.dump());
    QString strRet;
    auto ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_Select, strCmd, strRet, true);
    if(ret != 0)
    {
        SPDLOG_LOGGER_DEBUG(m_logger,"获取ActionCamer失败:{}, 错误信息:{}",ret,m_httpApi->DoGetLastError(&ret).toStdString());
        return false;
    }
    /* 设备和算法关联信息容器 */
    std::vector<DeviceAlgorithmInfo> vecNewInfo;
    /* 解析信息 */
    try {
        nJson json1 = nJson::parse(strRet.toStdString());
        int retCode = json1["code"].get<int>();
        if(retCode != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger,"获取ActionCamer失败");
            return false;
        }
        nJson result = json1["result"];
        if(result.empty())
        {
            return false;
        }
        /* 取出所有的设备算法信息 */
        
        for(const auto& it : result)
        {
            DeviceAlgorithmInfo info;
            info.DeviceID = it["camerId"].get<int>();
            info.ActionID = it["actionId"].is_null() ? "" : it["actionId"].get<std::string>();
            info.ActionName = it["actionName"].is_null() ? "" : it["actionName"].get<std::string>();
            info.ActionTaskID = it["actionTaskid"].is_null() ? 0 : it["actionTaskid"].get<int>();
            vecNewInfo.push_back(info);
        }
    }
    catch (const nJson::parse_error& e) {
        SPDLOG_LOGGER_ERROR(m_logger,"解析ActionCamer数据失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch (const nJson::type_error& e) {
        SPDLOG_LOGGER_ERROR(m_logger,"解析ActionCamer数据失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }

    /* 根据缓存中的设备ID取出关联的算法 */
    for(auto& it0 : vecInfo)
    {
        for(auto& it1 : vecNewInfo)
        {
            /* 对比设备ID */
            if(it0.DeviceID == it1.DeviceID)
            {
                AlgorithmInfo info;
                info.ActionID = it1.ActionID;
                info.ActionName = it1.ActionName;
                info.ActionTaskID = it1.ActionTaskID;
                it0.vecAlgorithmInfo.push_back(info);
            }
        }
    }
    /* 取出关联表中已经消失的设备ID，在本轮循环中删除 */
    for(const auto& it : vecNewInfo)
    {
        bool isExist = false;
        for(const auto& it0 : vecInfo)
        {
            if(it.DeviceID == it0.DeviceID)
            {
                isExist = true;
                break;
            }
        }
        if(!isExist)
        {
            /* 检查是否重复，一个ID只需要记录一次 */
            if(std::find(listDevIDDelete.begin(), listDevIDDelete.end(), it.DeviceID) == listDevIDDelete.end())
            {
                listDevIDDelete.push_back(it.DeviceID);
            }
        }
    }


    return true;
}

/* 获取设备和算法关联信息，包括频率信息，房间信息，重载版，只获取关联关系 */
bool FromWebAPI::getActionInfo(ListActionInfo& listInfo)
{
    if(m_httpApi == nullptr)
    {
        SPDLOG_LOGGER_ERROR(m_logger,"WebApi is nullptr");
        return false;
    }
    listInfo.clear();
    nJson json0;
    json0["opName"] = "SPSS_SelectFromActionInfo";
    QString strCmd = QString::fromStdString(json0.dump());
    QString strRet;
    auto ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_Select, strCmd, strRet, true);
    if(ret != 0)
    {
        SPDLOG_LOGGER_DEBUG(m_logger,"获取ActionCamer失败:{}, 错误信息:{}",ret,m_httpApi->DoGetLastError(&ret).toStdString());
        return false;
    }
    /* 解析信息 */
    try
    {
        nJson json1 = nJson::parse(strRet.toStdString());
        int retCode = json1["code"].get<int>();
        if(retCode != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger,"获取ActionCamer失败");
            return false;
        }
        nJson result = json1["result"];
        if(result.empty())
        {
            return false;
        }
        /* 取出所有的设备算法信息 */
        for(const auto& it : result)
        {
            ActionInfo info;
            info.CameraID = it["camerId"].is_null() ? -1 : it["camerId"].get<int>();
            info.ActionID = it["actionId"].is_null() ? "" : it["actionId"].get<std::string>();
            info.RoomID = it["roomId"].is_null() ? -1 : it["roomId"].get<int>();
            info.ChannelID = it["chnId"].is_null() ? -1 : it["chnId"].get<int>();
            int roomType = it["rtype"].is_null() ? 0 : it["rtype"].get<int>();
            info.RoomType = static_cast<Enum_RoomType>(roomType);
            info.strRoomName = it["rname"].is_null() ? "" : it["rname"].get<std::string>();
            listInfo.insertActionInfo(&info);
        }
    }
    catch (const nJson::parse_error& e) {
        SPDLOG_LOGGER_ERROR(m_logger,"解析 ActionCamer 数据失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch (const nJson::type_error& e) {
        SPDLOG_LOGGER_ERROR(m_logger,"解析 ActionCamer 数据失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch(...)
    {
        SPDLOG_LOGGER_ERROR(m_logger,"解析 ActionCamer 数据失败");
        return false;
    }

    return true;
}


/* 获取摄像机和房间关联信息 */
bool FromWebAPI::getRoomCameraInfo(std::list<RoomCameraInfo>& vecInfo)
{
    if(m_httpApi == nullptr)
    {
        SPDLOG_LOGGER_ERROR(m_logger,"WebApi is nullptr");
        return false;
    }
    vecInfo.clear();
    nJson json0;
    json0["opName"] = "SPSS_SelectRoomCamer";
    QString strCmd = QString::fromStdString(json0.dump());
    QString strRet;
    auto ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_Select, strCmd, strRet, true);
    if(ret != 0)
    {
        SPDLOG_LOGGER_DEBUG(m_logger,"获取RoomCamer失败:{}, 错误信息:{}",ret,m_httpApi->DoGetLastError(&ret).toStdString());
        return false;
    }
    try
    {
        nJson json1 = nJson::parse(strRet.toStdString());
        int retCode = json1["code"].get<int>();
        if(retCode != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger,"获取RoomCamer失败");
            return false;
        }
        nJson result = json1["result"];
        if(result.empty())
        {
            return false;
        }
        for(const auto& it : result)
        {
            auto roomID = it["roomId"].get<int>();
            auto cameraID = it["camerId"].is_null() ? -1 : it["camerId"].get<int>();
            /* 先检查RoomID是否已经在列表中了 */
            bool isExist = false;
            for(auto& it0 : vecInfo)
            {
                if(it0.RoomID == roomID)
                {
                    it0.listCameraID.push_back(cameraID);
                    isExist = true;
                    break;
                }
            }
            /* 没有找到RoomID，创建一个新的 */
            if(!isExist)
            {
                RoomCameraInfo info;
                info.RoomID = roomID;
                info.listCameraID.push_back(cameraID);
            }
        }
    }
    catch (const nJson::parse_error& e) {
        SPDLOG_LOGGER_ERROR(m_logger,"解析ActionCamer数据失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch (const nJson::type_error& e) {
        SPDLOG_LOGGER_ERROR(m_logger,"解析ActionCamer数据失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch(const std::exception& e)
    {
        SPDLOG_LOGGER_ERROR(m_logger,"解析ActionCamer数据失败:{}",e.what());
        return false;
    }
    catch(...)
    {
        SPDLOG_LOGGER_ERROR(m_logger,"解析ActionCamer数据失败");
        return false;
    }

    return true;
}

/* 根据获取功能检测时间区间 */
bool FromWebAPI::getFuncDetectTime(int ChannelID, AppFunction app, DetectPeriodInfo& periodInfo)
{
    if(m_httpApi == nullptr)
    {
        SPDLOG_LOGGER_ERROR(m_logger,"WebApi is nullptr");
        return false;
    }

    
    try
    {
        /* 生成发送的字符串 */
        nJson json0;
        json0["opName"] = "SPSS_SelectPeriodByChannel";
        nJson json1;
        json1["channelID"] = ChannelID;
        json1["appType"] = getAppFunctionID(app);
        json0["paramList"] = json1;
        QString strCmd = QString::fromStdString(json0.dump());
        QString strRet;
        auto ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_Select, strCmd, strRet, true);
        if(ret != 0)
        {
            SPDLOG_LOGGER_WARN(m_logger,"获取Period信息失败:{}, 错误信息:{}",ret,m_httpApi->DoGetLastError(&ret).toStdString());
            return false;
        }

        /* 解析返回的数据 */
        nJson retJson = nJson::parse(strRet.toStdString());
        // SPDLOG_LOGGER_DEBUG(m_logger,"获取tPeriod信息成功:\n{}", retJson.dump(4));

        int retCode = retJson["code"].get<int>();
        if(retCode != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger,"获取Period信息失败");
            return false;
        }
        nJson resultJson = retJson["result"];
        if(resultJson.empty())
        {
            SPDLOG_LOGGER_WARN(m_logger,"获取Period信息失败，结果为空");
            SPDLOG_LOGGER_DEBUG(m_logger,"发送的字符串:{}\n", json0.dump(4));
            return false;
        }
        periodInfo.listWeekTime.clear();
        for(const auto& it : resultJson)
        {
            periodInfo.ChannelID = it["chnId"].get<int>();
            periodInfo.PeriodName = it["periodName"].is_null() ? "" : it["periodName"].get<std::string>();
            int PeriodType = it["type"].is_null() ? 0 : it["type"].get<int>();
            periodInfo.PeriodType = static_cast<Enum_PeriodType>(PeriodType);
            int appType = it["appType"].is_null() ? 0 : it["appType"].get<int>();
            periodInfo.appFunction = getAppFunctionID(appType);

            WeekTime wt;
            wt.WeekDay = it["week"].is_null() ? 0 : it["week"].get<int>();
            std::string st = it["startTime"].is_null() ? "" : it["startTime"].get<std::string>();
            wt.StartTime = QDateTime::fromString(QString::fromStdString(st), "yyyy-MM-dd hh:mm:ss");
            std::string et = it["endTime"].is_null() ? "" : it["endTime"].get<std::string>();
            wt.EndTime = QDateTime::fromString(QString::fromStdString(et), "yyyy-MM-dd hh:mm:ss");
            periodInfo.listWeekTime.push_back(wt);
        }
    }
    catch (const nJson::parse_error& e) {
        SPDLOG_LOGGER_ERROR(m_logger,"解析 tPeriod 数据失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch (const nJson::type_error& e) {
        SPDLOG_LOGGER_ERROR(m_logger,"解析 tPeriod 数据失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch(...)
    {
        SPDLOG_LOGGER_ERROR(m_logger,"解析 tPeriod 数据失败");
        return false;
    }

    return true;
}

/* 写入报警信息 */
bool FromWebAPI::insertAlarmInfo(const AlarmInfo& alarmInfo)
{
    int PKID = 0;
    return insertAlarmInfo(alarmInfo, PKID);
}


bool FromWebAPI::insertAlarmInfo(const AlarmInfo& alarmInfo, int& PKID)
{
    if(m_httpApi == nullptr)
    {
        SPDLOG_LOGGER_ERROR(m_logger,"WebApi is nullptr");
        return false;
    }
    /* 判断是否有图片，没有图片就取消报警 */
    if(alarmInfo.ImageInfo.empty())
    {
        SPDLOG_LOGGER_WARN(m_logger, "× 取消新增报警信息，因为没有图片，频道[{}]，房间[{}]，摄像头[{}]，{}，{}，有{}个区域，有{}个人脸",
                            alarmInfo.ChannelID, alarmInfo.RoomID, alarmInfo.DeviceID, alarmInfo.ActionDes, alarmInfo.ImageInfo, alarmInfo.listBbox.size(), alarmInfo.listPersonInfo.size());
        return false;
    }
    /* 拼接Bbox */
    std::string strBbox;
    for(const auto& it : alarmInfo.listBbox)
    {
        strBbox += it;
        strBbox += "|";
    }
    /* 去掉最后一个“|” */
    strBbox.pop_back();

    // printAlarmInfo(alarmInfo, strBbox);
    try
    {
        nJson json0;
        json0["opName"] = "SPSS_InsertToAlarm";
        nJson json1;
        json1["alarmID"] = alarmInfo.AlarmID;
        json1["startTime"] = alarmInfo.StartTime.toString("yyyy-MM-dd hh:mm:ss.zzz").toStdString();
        json1["createTime"] = alarmInfo.EventTime.toString("yyyy-MM-dd hh:mm:ss.zzz").toStdString();
        // std::string strEndTime = "";
        // /* 这里判断一下结束时间是否需要设置，如果不需要，则设置成小于2020年即可，写入数据库就是空 */
        // if(alarmInfo.EndTime > QDateTime::fromString("2020-01-01 00:00:00", "yyyy-MM-dd hh:mm:ss"))
        // {
        //     strEndTime = alarmInfo.EndTime.toString("yyyy-MM-dd hh:mm:ss.zzz").toStdString();
        // }
        json1["endTime"] = alarmInfo.EndTime.toString("yyyy-MM-dd hh:mm:ss.zzz").toStdString();
        json1["bbox"] = strBbox;
        json1["picUrl"] = alarmInfo.ImageInfo;
        json1["appID"] = getAppFunctionID(alarmInfo.appFunction);
        json1["actionID"] = alarmInfo.ActionID;
        json1["actionDes"] = alarmInfo.ActionDes;
        json1["camerID"] = alarmInfo.DeviceID;
        json1["roomID"] = alarmInfo.RoomID;
        json1["chnid"] = alarmInfo.ChannelID;
        json1["state"] = alarmInfo.State;
        json1["faceIDList"] = alarmInfo.FaceIDList;
        json1["faceNameList"] = alarmInfo.FaceNameList;
        json1["onWork"] = alarmInfo.OnWork;

        json0["paramList"] = json1;
        // SPDLOG_LOGGER_DEBUG(m_logger, "写入报警信息的字符串:{}\n", json0.dump(4));
        QString strCmd = QString::fromStdString(json0.dump());
        QString strRet;
        auto ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_Insert, strCmd, strRet, true);
        if(ret != 0)
        {
            SPDLOG_LOGGER_WARN(m_logger,"插入报警信息失败:{}, 错误信息:{}",ret,m_httpApi->DoGetLastError(&ret).toStdString());
            return false;
        }
        // SPDLOG_LOGGER_DEBUG(m_logger,"插入报警信息成功!");
        // SPDLOG_LOGGER_DEBUG(m_logger, "返回的数据:{}", strRet.toStdString());

        nJson retJson = nJson::parse(strRet.toStdString());
        int retCode = retJson["code"].get<int>();
        if(retCode != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger,"获取写入报警信息的PKID失败, 错误信息:{}", retJson["msg"].get<std::string>());
            return false;
        }
        /* 解析返回的报警ID */
        nJson result = retJson["result"];
        if(result.empty())
        {
            SPDLOG_LOGGER_ERROR(m_logger,"插入报警信息失败, 返回的结果为空");
            return false;
        }
        for(const auto& it : result)
        {
            PKID = it["pkid"].is_null() ? 0 : it["pkid"].get<int>();
        }

    }
    catch (const nJson::parse_error& e) {
        SPDLOG_LOGGER_ERROR(m_logger,"创建 写入报警信息 JSON失败 数据失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch (const nJson::type_error& e) {
        SPDLOG_LOGGER_ERROR(m_logger,"创建 写入报警信息 JSON失败 数据失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch(...) {
        SPDLOG_LOGGER_ERROR(m_logger,"创建 写入报警信息 JSON失败 数据失败");
        return false;
    }

    return true;
}

/* 打印报警数据信息 */
void FromWebAPI::printAlarmInfo(const AlarmInfo& alarmInfo, std::string strBBox)
{
    std::string strLog;
    strLog += "写入报警信息:\n";
    strLog += fmt::format("alarmID: {}\n", alarmInfo.AlarmID);
    strLog += fmt::format("startTime: {}\n", alarmInfo.StartTime.toString("yyyy-MM-dd hh:mm:ss.zzz").toStdString());
    strLog += fmt::format("createTime: {}\n", alarmInfo.EventTime.toString("yyyy-MM-dd hh:mm:ss.zzz").toStdString());
    strLog += fmt::format("endTime: {}\n", alarmInfo.EndTime.toString("yyyy-MM-dd hh:mm:ss.zzz").toStdString());
    strLog += fmt::format("bbox: {}\n", strBBox);
    strLog += fmt::format("picUrl: {}\n", alarmInfo.ImageInfo);
    strLog += fmt::format("appID: {}\n", getAppFunctionID(alarmInfo.appFunction));
    strLog += fmt::format("actionID: {}\n", alarmInfo.ActionID);
    strLog += fmt::format("actionDes: {}\n", alarmInfo.ActionDes);
    strLog += fmt::format("camerID: {}\n", alarmInfo.DeviceID);
    strLog += fmt::format("roomID: {}\n", alarmInfo.RoomID);
    strLog += fmt::format("chnid: {}\n", alarmInfo.ChannelID);
    strLog += fmt::format("state: {}\n", alarmInfo.State);
    strLog += fmt::format("faceIDList: {}\n", alarmInfo.FaceIDList);
    strLog += fmt::format("faceNameList: {}\n", alarmInfo.FaceNameList);
    strLog += fmt::format("onWork: {}", alarmInfo.OnWork);
    SPDLOG_LOGGER_DEBUG(m_logger, strLog);
}

/* 更新报警结束时间 */
// bool FromWebAPI::updateAlarmEndTime(const AlarmInfo& alarmInfo)
// {
//     if(m_httpApi == nullptr)
//     {
//         SPDLOG_LOGGER_ERROR(m_logger,"WebApi is nullptr");
//         return false;
//     }
//     try
//     {
//         nJson json0;
//         json0["opName"] = "SPSS_UpdateAlarmEndTime";
//         nJson json1;
//         json1["EndTime"] = alarmInfo.EndTime.toString("yyyy-MM-dd hh:mm:ss.zzz").toStdString();
//         json1["ChannelID"] = alarmInfo.ChannelID;
//         json1["RoomID"] = alarmInfo.RoomID;
//         json1["CamerID"] = alarmInfo.DeviceID;
//         json1["ActionID"] = alarmInfo.ActionID;
//         json0["paramList"] = json1;

//         QString strCmd = QString::fromStdString(json0.dump());
//         QString strRet;
//         int ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_Update, strCmd, strRet, true);
//         if(ret != 0)
//         {
//             SPDLOG_LOGGER_WARN(m_logger,"更新报警结束时间失败:{}, 错误信息:{}",ret,m_httpApi->DoGetLastError(&ret).toStdString());
//             return false;
//         }
//     }
//     catch (const nJson::parse_error& e) {
//         SPDLOG_LOGGER_ERROR(m_logger,"创建 更新报警结束时间 JSON失败 数据失败:{}, 错误ID:{}",e.what(), e.id);
//         return false;
//     }
//     catch (const nJson::type_error& e) {
//         SPDLOG_LOGGER_ERROR(m_logger,"创建 更新报警结束时间 JSON失败 数据失败:{}, 错误ID:{}",e.what(), e.id);
//         return false;
//     }
//     catch(...) {
//         SPDLOG_LOGGER_ERROR(m_logger,"创建 更新报警结束时间 JSON失败 数据失败");
//         return false;
//     }

//     return true;
// }

/**
 * @brief 根据PKID更新报警记录，用来结束报警，这个只需要PKID和结束时间
 * 
 * @param alarmInfo 
 * @return true 
 * @return false 
 */
bool FromWebAPI::endAlarmInfoByPKID(const int PKID, const QDateTime dateTime)
{
    if(m_httpApi == nullptr)
    {
        SPDLOG_LOGGER_ERROR(m_logger,"WebApi is nullptr");
        return false;
    }
    try
    {
        nJson json0;
        json0["opName"] = "SPSS_EndAlarmByPKID";
        nJson json1;
        json1["PKID"] = PKID;
        json1["endTime"] = dateTime.toString("yyyy-MM-dd hh:mm:ss").toStdString();
        json0["paramList"] = json1;

        QString strCmd = QString::fromStdString(json0.dump());
        QString strRet;
        int ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_Update, strCmd, strRet, true);
        if(ret != 0)
        {
            SPDLOG_LOGGER_WARN(m_logger,"更新报警结束时间失败:{}, 错误信息:{}",ret,m_httpApi->DoGetLastError(&ret).toStdString());
            return false;
        }
        // SPDLOG_LOGGER_DEBUG(m_logger,"更新报警结束时间成功!");
    }
    catch (const nJson::parse_error& e) {
        SPDLOG_LOGGER_ERROR(m_logger,"创建 更新报警结束时间 JSON失败 数据失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch (const nJson::type_error& e) {
        SPDLOG_LOGGER_ERROR(m_logger,"创建 更新报警结束时间 JSON失败 数据失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch(...) {
        SPDLOG_LOGGER_ERROR(m_logger,"创建 更新报警结束时间 JSON失败 数据失败");
        return false;
    }

    return true;
}


/* 更新人员信息 */
bool FromWebAPI::updatePersonInfo(RoomOnWorkInfo& roomInfo)
{
    if(m_httpApi == nullptr)
    {
        SPDLOG_LOGGER_ERROR(m_logger,"WebApi is nullptr");
        return false;
    }
    try
    {
        std::string strDes = fmt::format("人员在岗[{}][{}]", roomInfo.getFaceIDListString(), roomInfo.getFaceNameListString());
        nJson json0;
        json0["opName"] = "SPSS_UpdateFaceInfoByPKID";
        nJson json1;
        json1["pkid"] = roomInfo.PKID;
        json1["faceIDList"] = roomInfo.getFaceIDListString();
        json1["faceNameList"] = roomInfo.getFaceNameListString();
        json1["ActionDes"] = strDes;
        json0["paramList"] = json1;

        QString strCmd = QString::fromStdString(json0.dump());
        QString strRet;
        int ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_Update, strCmd, strRet, true);
        if(ret != 0)
        {
            SPDLOG_LOGGER_WARN(m_logger,"更新报警结束时间失败:{}, 错误信息:{}",ret,m_httpApi->DoGetLastError(&ret).toStdString());
            return false;
        }
        // SPDLOG_LOGGER_DEBUG(m_logger,"更新报警结束时间成功!");
    }
    catch (const nJson::parse_error& e) {
        SPDLOG_LOGGER_ERROR(m_logger,"创建 更新人员信息 JSON失败 数据失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch (const nJson::type_error& e) {
        SPDLOG_LOGGER_ERROR(m_logger,"创建 更新人员信息 JSON失败 数据失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch(...) {
        SPDLOG_LOGGER_ERROR(m_logger,"创建 更新人员信息 JSON失败 数据失败");
        return false;
    }

    return true;
}


/* 通过频率ID和应用ID获取最大的PKID报警 */
bool FromWebAPI::getMaxAlarmPKID(const int ChannelID, const AppFunction AppID, int& PKID)
{
    if(m_httpApi == nullptr)
    {
        SPDLOG_LOGGER_ERROR(m_logger,"WebApi is nullptr");
        return false;
    }
    PKID = 0;
    nJson json0;
    json0["opName"] = "SPSS_GetChnAlarmMaxPKID";
    nJson json1;
    json1["ChannelID"] = ChannelID;
    json1["AppID"] = static_cast<int>(AppID);
    json0["paramList"] = json1;

    QString strCmd = QString::fromStdString(json0.dump());
    QString strRet;
    auto ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_Select, strCmd, strRet, true);
    if(ret != 0)
    {
        SPDLOG_LOGGER_DEBUG(m_logger,"获取Alarma max PKID失败:{}, 错误信息:{}",ret,m_httpApi->DoGetLastError(&ret).toStdString());
        return false;
    }
    try 
    {
        nJson json1 = nJson::parse(strRet.toStdString());
        int retCode = json1["code"].get<int>();
        if(retCode != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger,"获取Alarma max PKID失败");
            return false;
        }
        nJson result = json1["result"];
        if(result.empty())
        {
            return false;
        }
        for(const auto& it : result)
        {
            PKID = it["maxPKID"].is_null() ? 0 : it["maxPKID"].get<int>();
        }
    } 
    catch (const nJson::parse_error& e) {
        SPDLOG_LOGGER_ERROR(m_logger,"解析 Alarma max PKID 失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch(const nJson::type_error& e)
    {
        SPDLOG_LOGGER_ERROR(m_logger,"解析 Alarma max PKID 失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch(...)
    {
        SPDLOG_LOGGER_ERROR(m_logger,"解析 Alarma max PKID 失败");
        return false;
    }

    return true;
}

/* 清空在岗离岗报警的在岗人员信息 */
bool FromWebAPI::clearOnWorkAlarmInfo(const int PKID, const bool onWork, const std::string actionDes)
{
    if(m_httpApi == nullptr)
    {
        SPDLOG_LOGGER_ERROR(m_logger,"WebApi is nullptr");
        return false;
    }

    nJson json0;
    json0["opName"] = "SPSS_ClearAlarmOnWorkPersonInfo";
    nJson json1;
    json1["pkid"] = PKID;
    json1["onWork"] = onWork;
    json1["actionDes"] = actionDes;
    json0["paramList"] = json1;
    QString strCmd = QString::fromStdString(json0.dump());
    QString strRet;
    auto ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_Update, strCmd, strRet, true);
    if(ret != 0)
    {
        SPDLOG_LOGGER_DEBUG(m_logger,"清空在岗离岗报警的在岗人员信息失败:{}, 错误信息:{}",ret,m_httpApi->DoGetLastError(&ret).toStdString());
        return false;
    }

    return true;
}



/* 获取报警规则表 */
bool FromWebAPI::getPersonCountRuleInfo(std::list<PersonCountRuleInfo>& list)
{
    if(m_httpApi == nullptr)
    {
        SPDLOG_LOGGER_ERROR(m_logger,"WebApi is nullptr");
        return false;
    }

    nJson json0;
    json0["opName"] = "SPSS_GetPersonCountRule";
    QString strCmd = QString::fromStdString(json0.dump());
    QString strRet;
    auto ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_Select, strCmd, strRet, true);
    if(ret != 0)
    {
        SPDLOG_LOGGER_DEBUG(m_logger,"获取AlarmRule失败:{}, 错误信息:{}",ret,m_httpApi->DoGetLastError(&ret).toStdString());
        return false;
    }
    try 
    {
        nJson json1 = nJson::parse(strRet.toStdString());
        int retCode = json1["code"].get<int>();
        if(retCode != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger,"获取tAlarmRule失败");
            return false;
        }
        nJson result = json1["result"];
        if(result.empty())
        {
            return false;
        }
        list.clear();
        for(const auto& it : result)
        {
            PersonCountRuleInfo info;
            info.ChannelID = it["chnId"].is_null() ? -1 : it["chnId"].get<int>();
            info.RuleName = it["periodName"].is_null() ? "" : it["periodName"].get<std::string>();

            info.RuleName = it["ruleName"].get<std::string>();
            info.LiveMinEnable = it["liveMinEnable"].get<int>() == 1 ? true : false;
            info.LiveMaxEnable = it["liveMaxEnable"].get<int>() == 1 ? true : false;
            info.DicMinEnable = it["dicMinEnable"].get<int>() == 1 ? true : false;
            info.DicMaxEnable = it["dicMaxEnable"].get<int>() == 1 ? true : false;
            info.LiveDicMinEnable = it["liveDicMinEnable"].get<int>() == 1 ? true : false;
            info.LiveDicMaxEnable = it["liveDicMaxEnable"].get<int>() == 1 ? true : false;
            info.LiveMin = it["liveMin"].is_null() ? 0 : it["liveMin"].get<int>();
            info.LiveMax = it["liveMax"].is_null() ? 0 : it["liveMax"].get<int>();
            info.DicMin = it["dicMin"].is_null() ? 0 : it["dicMin"].get<int>();
            info.DicMax = it["dicMax"].is_null() ? 0 : it["dicMax"].get<int>();
            info.LiveDicMin = it["liveDicMin"].is_null() ? 0 : it["liveDicMin"].get<int>();
            info.LiveDicMax = it["liveDicMax"].is_null() ? 0 : it["liveDicMax"].get<int>();
            list.push_back(info);
        }
    } 
    catch (const nJson::parse_error& e) {
        SPDLOG_LOGGER_ERROR(m_logger,"解析 tRuleInfo 数据失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch(const nJson::type_error& e)
    {
        SPDLOG_LOGGER_ERROR(m_logger,"解析 tRuleInfo 数据失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch(...)
    {
        SPDLOG_LOGGER_ERROR(m_logger,"解析 tRuleInfo 数据失败");
        return false;
    }

    return true;
}

/* 获取报警时段，也同时获取报警的应用信息，tPeriod表 */
bool FromWebAPI::getAlarmAppInfo(std::list<ChannelAppInfo>& listInfo)
{
    nJson json0;
    json0["opName"] = "SPSS_SelectChannelApp";
    QString strCmd = QString::fromStdString(json0.dump());
    QString strRet;
    auto ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_Select, strCmd, strRet, true);
    if(ret != 0)
    {
        SPDLOG_LOGGER_DEBUG(m_logger,"获取AlarmApp失败:{}, 错误信息:{}",ret,m_httpApi->DoGetLastError(&ret).toStdString());
        return false;
    }
    try 
    {
        nJson json1 = nJson::parse(strRet.toStdString());
        int retCode = json1["code"].get<int>();
        if(retCode != 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger,"获取tAlarmApp失败");
            return false;
        }
        nJson result = json1["result"];
        if(result.empty())
        {
            return false;
        }
        listInfo.clear();
        for(const auto& it : result)
        {
            ChannelAppInfo info;
            info.ChannelID = it["chnId"].get<int>();
            info.AppType = it["appType"].get<int>();
            info.strChannelName = it["chnName"].is_null() ? "" : it["chnName"].get<std::string>();
            info.strAppName = it["appName"].is_null() ? "" : it["appName"].get<std::string>();
            
            listInfo.push_back(info);
        }
    } 
    catch (const nJson::parse_error& e) {
        SPDLOG_LOGGER_ERROR(m_logger,"解析tPeriod数据失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch(const nJson::type_error& e)
    {
        SPDLOG_LOGGER_ERROR(m_logger,"解析tPeriod数据失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch(...)
    {
        SPDLOG_LOGGER_ERROR(m_logger,"解析tPeriod数据失败");
        return false;
    }

    return true;
}


/* 结束人员计数报警，通过频率ID和应用ID */
bool FromWebAPI::endPersonCountAlarm(int chnID, AppFunction appID)
{
    if(m_httpApi == nullptr)
    {
        SPDLOG_LOGGER_ERROR(m_logger,"WebApi is nullptr");
        return false;
    }
    try
    {
        nJson json0;
        json0["opName"] = "SPSS_EndPersonCountAlarm";
        nJson json1;
        json1["channelID"] = chnID;
        json1["appID"] = getAppFunctionID(appID);
        json0["paramList"] = json1;

        QString strCmd = QString::fromStdString(json0.dump());
        QString strRet;
        int ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_Update, strCmd, strRet, true);
        if(ret != 0)
        {
            SPDLOG_LOGGER_WARN(m_logger,"结束人员计数报警失败:{}, 错误信息:{}",ret,m_httpApi->DoGetLastError(&ret).toStdString());
            return false;
        }
    }
    catch (const nJson::parse_error& e) {
        SPDLOG_LOGGER_ERROR(m_logger,"创建 结束人员计数报警 JSON失败 数据失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch (const nJson::type_error& e) {
        SPDLOG_LOGGER_ERROR(m_logger,"创建 结束人员计数报警 JSON失败 数据失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch(...) {
        SPDLOG_LOGGER_ERROR(m_logger,"创建 结束人员计数报警 JSON失败 数据失败");
        return false;
    }

    return true;
}


/* 写入在岗信息 tWorkOnInfo */
bool FromWebAPI::insertOnWorkInfo(const RoomFaceInfo& onWorkInfo)
{
    if(m_httpApi == nullptr)
    {
        SPDLOG_LOGGER_ERROR(m_logger,"WebApi is nullptr");
        return false;
    }
    if(onWorkInfo.listPersonInfo.empty())
    {
        return false;
    }
    /* 拼接人脸ID和人脸名称 */
    std::string strFaceID;
    std::string strFaceName;
    for(const auto& it : onWorkInfo.listPersonInfo)
    {
        strFaceID += it.PersonID + ";";
        strFaceName += it.PersonName + ";";
    }
    /* 去掉最后的“;” */
    strFaceID = strFaceID.substr(0, strFaceID.size() - 1);
    strFaceName = strFaceName.substr(0, strFaceName.size() - 1);

    try
    {
        nJson json0;
        json0["opName"] = "SPSS_InsertToOnWork";
        nJson json1;
        json1["nChID"] = onWorkInfo.ChannelID;
        json1["CamerId"] = onWorkInfo.CameraID;
        json1["FaceIdList"] = strFaceID;
        json1["FaceNameList"] = strFaceName;
        json1["StartTime"] = onWorkInfo.StartTime.toString("yyyy-MM-dd hh:mm:ss").toStdString();
        json1["EndTime"] = onWorkInfo.EndTime.toString("yyyy-MM-dd hh:mm:ss").toStdString();
        json1["MaxNumber"] = onWorkInfo.MaxNum;
        json1["MinNumber"] = onWorkInfo.MinNum;

        json0["paramList"] = json1;

        QString strCmd = QString::fromStdString(json0.dump());
        QString strRet;
        auto ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_Insert, strCmd, strRet, true);
        if(ret != 0)
        {
            SPDLOG_LOGGER_WARN(m_logger,"插入 tWorkOnInfo 失败:{}, 错误信息:{}",ret,m_httpApi->DoGetLastError(&ret).toStdString());
            return false;
        }
        // SPDLOG_LOGGER_DEBUG(m_logger,"插入在岗信息成功!");
    }
    catch (const nJson::parse_error& e) {
        SPDLOG_LOGGER_ERROR(m_logger,"生成 tWorkOnInfo JSON 数据失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch(const nJson::type_error& e)
    {
        SPDLOG_LOGGER_ERROR(m_logger,"生成 tWorkOnInfo JSON 数据失败:{}, 错误ID:{}",e.what(), e.id);
        return false;
    }
    catch(...)
    {
        SPDLOG_LOGGER_ERROR(m_logger,"生成 tWorkOnInfo JSON 数据失败");
        return false;
    }

    return true;
}