SCADATrainSys/CCGDServer/ElectrictiyServerQt/QThreadHttpClient - 副本.cpp

    #include "QThreadHttpClient.h"
#include "DataManager.h"
#include <QSettings>
#include <QDebug>
#include <QApplication>
#include "AsioUDPNetDLL.h"
#include "TaskMNG.h"
#include "ElectricityVOC.h"
#ifdef Q_OS_WIN
#pragma execution_character_set("utf-8")
#endif
QThreadHttpClient* QThreadHttpClient::g_HttpSingle;
QMutex QThreadHttpClient::m_clientMutex;
QThreadHttpClient& QThreadHttpClient::instance()
{
    if (g_HttpSingle == NULL)
    {
        QMutexLocker lock(&m_clientMutex);
        if (g_HttpSingle == NULL)
        {
            g_HttpSingle = new (std::nothrow) QThreadHttpClient(nullptr);
        }
    }
    return *g_HttpSingle;
}

void QThreadHttpClient::destroyInstance()
{
    QMutexLocker lock(&m_clientMutex);
    if (g_HttpSingle)
    {
        delete g_HttpSingle;
        g_HttpSingle = NULL;
    }
}

QThreadHttpClient::QThreadHttpClient(QObject *parent)
    : QObject(parent), pClient(nullptr)
{
    qRegisterMetaType<std::string>("std::string");
    connect(this, SIGNAL(signal_SignalData(std::string, std::string)), this, SLOT(slot_SendPost(std::string,std::string)),Qt::QueuedConnection);
}

QThreadHttpClient::~QThreadHttpClient()
{}

void QThreadHttpClient::initHttpClient()
{
    QString strHost="";
    int nPort = 0;
    QString strGetPath=QApplication::applicationDirPath();
    strGetPath.append("/config");
    QSettings settings(strGetPath, QSettings::IniFormat);
    settings.setIniCodec("GBK");
    int nTimeOut = READ_INI_INT("HttpClient/HttpTimeOut", 2);
    strHost = READ_INI_STR("HttpClient/IP", "127.0.0.1");
    nPort = READ_INI_INT("HttpClient/port", 8090);
    qDebug()<<"HttpClient:"<<strHost<<"  port:"<<nPort;
    pClient = new httplib::Client(strHost.toStdString(),nPort);
    pClient->set_connection_timeout(nTimeOut);
    pClient->set_write_timeout(nTimeOut);
    pClient->set_read_timeout(nTimeOut);
}

bool QThreadHttpClient::HttpPost(const std::string& strUrl, const std::string& strRequest, std::string& strResponse)
{
    QMutexLocker lock(&m_clientMutex);
    if (!pClient) {
        if (!reconnect()) {
            AddLogJson(strRequest, "Client is null, reconnect failed", strUrl, false);
            return false;
        }
    }

    try {
        auto result = pClient->Post(strUrl.c_str(), strRequest, "application/json");

        if (!result) {
            // 请求失败，尝试重连并重试一次
            if (reconnect()) {
                result = pClient->Post(strUrl.c_str(), strRequest, "application/json");
            }

            if (!result) {
                AddLogJson(strRequest, "Request failed or timeout", strUrl, false);
                return false;
            }
        }

        strResponse = result->body;
        AddLogJson(strRequest, strResponse, strUrl, result->status);
        return (result->status == 200);

    } catch (const std::exception& e) {
        AddLogJson(strRequest, std::string("Exception: ") + e.what(), strUrl, false);
        reconnect(); // 发生异常后重连
        return false;
    } catch (...) {
        AddLogJson(strRequest, "Unknown exception", strUrl, false);
        reconnect(); // 发生异常后重连
        return false;
    }
}

bool QThreadHttpClient::reconnect()
{
    //QMutexLocker lock(&m_clientMutex);

    if (pClient) {
        delete pClient;
        pClient = nullptr;
    }
    QString strHost="";
    int nPort = 0;
    QString strGetPath=QApplication::applicationDirPath();
    strGetPath.append("/config");
    QSettings settings(strGetPath, QSettings::IniFormat);
    settings.setIniCodec("GBK");
    int nTimeOut = READ_INI_INT("HttpClient/HttpTimeOut", 2);
    strHost = READ_INI_STR("HttpClient/IP", "127.0.0.1");
    nPort = READ_INI_INT("HttpClient/port", 8090);
    pClient = new httplib::Client(strHost.toStdString(),nPort);
    pClient->set_connection_timeout(nTimeOut);
    pClient->set_write_timeout(nTimeOut);
    pClient->set_read_timeout(nTimeOut);

    return (pClient != nullptr);
}

bool QThreadHttpClient::isConnected()
{
    QMutexLocker lock(&m_clientMutex);
    if (!pClient) return false;

    // 简单的连接测试
    auto result = pClient->Get("/");
    return (result != nullptr && result->status == 200);
}

void QThreadHttpClient::InitConnect(QObject* pCMD)
{
    qRegisterMetaType<OCCCOMMAND>("OCCCOMMAND");
    connect(pCMD, SIGNAL(signal_Command2Server(int, OCCCOMMAND)), this, SLOT(slot_CMDPop(int, OCCCOMMAND)),Qt::QueuedConnection);
}

void QThreadHttpClient::slot_CMDPop(int nCmdID, OCCCOMMAND pCmdData)
{
    NetDll_SendUDPDataToMulti(HDDSType::HDDSType_sOCCCMD,&pCmdData,pCmdData.DateLen+32);
    
    switch (nCmdID)
    {
    case OCCCOMMAND::eUpdateEqpmtStatus:
    {
        ElectricityVOC* pElcVoc = (ElectricityVOC*)TaskMNG::instance()->pGetEleVOC();
        if (!pElcVoc)
        {
            return;
        }
        Json::Value pJson;
        pJson["LineID"] = pElcVoc->m_nRunLineID;
        pJson["CmdType"] = 0;//设备控制
        pJson["EqpmtID"]= pCmdData.Net_DH_EqpmtUpdate.EqpmtStrID;
        pJson["Status"] = pCmdData.Net_DH_EqpmtUpdate.Status;
        pJson["CtrlType"] = pCmdData.Net_DH_EqpmtUpdate.CtrlType;
        pJson["CtrlLock"] = pCmdData.Net_DH_EqpmtUpdate.CtrlLock;
        pJson["FaultLock"] = pCmdData.Net_DH_EqpmtUpdate.FaultLock;
        pJson["RemoteLock"] = pCmdData.Net_DH_EqpmtUpdate.RemoteLock;
        pJson["CtrlArea"] = pCmdData.Net_DH_EqpmtUpdate.CtrlArea;
        pJson["fValue"] = "";
        pJson["nValueType"] = "";
        pJson["IsReset"] = "";
        Json::FastWriter pfastW;
        std::string strJson=pfastW.write(pJson);
        emit signal_SignalData("/courserun/eqpmtstatus", strJson);

    }
    break;
    case OCCCOMMAND::eUpdateEqpmtTelemeteryValue:
    {
        ElectricityVOC* pElcVoc = (ElectricityVOC*)TaskMNG::instance()->pGetEleVOC();
        if (!pElcVoc)
        {
            return;
        }
        Json::Value pJson;
        pJson["LineID"] = pElcVoc->m_nRunLineID;
        pJson["CmdType"] = 1;//设备数据
        pJson["EqpmtID"] = pCmdData.Net_DH_EqpmtTelemtryValue.EqpmtStrID;
        pJson["Status"] = "";
        pJson["CtrlType"] = "";
        pJson["CtrlLock"] = "";
        pJson["FaultLock"] = "";
        pJson["RemoteLock"] = "";
        pJson["CtrlArea"] = "";
        pJson["fValue"] = pCmdData.Net_DH_EqpmtTelemtryValue.fValue;
        pJson["nValueType"] = pCmdData.Net_DH_EqpmtTelemtryValue.nType;
        pJson["IsReset"] = pCmdData.Net_DH_EqpmtTelemtryValue.IsReset;
        Json::FastWriter pfastW;
        std::string strJson = pfastW.write(pJson);
        emit signal_SignalData("/courserun/eqpmtstatus", strJson);
    }
    break;
    case OCCCOMMAND::eUpdateEvaOperStatus:
    {
        Json::Value pJson;
        pJson["CtrlType"] = pCmdData.Net_JY_UpdateEvaOperStatus.OperItemSubType1;
        pJson["CtrlSubType"] = pCmdData.Net_JY_UpdateEvaOperStatus.OperItemSubType2;
        pJson["CtrlFrom"] = pCmdData.Net_JY_UpdateEvaOperStatus.OperClientID;
        std::string strData = std::to_string(pCmdData.Net_JY_UpdateEvaOperStatus.OperStuID);
        pJson["CtrlUser"] = strData; 
        pJson["Param1"] = pCmdData.Net_JY_UpdateEvaOperStatus.AssociPara1;
        pJson["Param2"] = pCmdData.Net_JY_UpdateEvaOperStatus.AssociPara2;
        pJson["Param3"] = pCmdData.Net_JY_UpdateEvaOperStatus.AssociPara3;
        pJson["Param4"] = pCmdData.Net_JY_UpdateEvaOperStatus.AssociPara4;
        pJson["Param5"] = pCmdData.Net_JY_UpdateEvaOperStatus.AssociPara5;
        Json::FastWriter pfastW;
        std::string strJson = pfastW.write(pJson);
        emit signal_SignalData("/courserun/add_ctrl_log", strJson);

    }
    break;
    default:
        break;
    }
}


void QThreadHttpClient::slot_SendPost(std::string strUrl, std::string strRequest)
{
    std::string strReData;

    HttpPost(strUrl, strRequest, strReData);
}

void QThreadHttpClient::AddLogJson(std::string strRequest, std::string strResponse, std::string nAPIID, bool bStatus)
{
    std::string strShow = "", strRetrun = "";
    // 	strShow = UTF8_to_string(strRequest);
    // 	strRetrun = strResponse;
    if (!DataManager::JsonToStyled(strRequest, strShow))
    {
        strShow = DataManager::UTF8_to_string(strRequest);
    }
    else
    {
        strShow = DataManager::UTF8_to_string(strShow);
    }
    if (!DataManager::JsonToStyled(strResponse, strRetrun))
    {
        strRetrun = strResponse;
    }
    LogJson pData(strShow, strRetrun, nAPIID, bStatus);
    DataManager::instance().AddHttpLog(pData);

}