SCADATrainSys/CCGDServer/ElectrictiyServerQt/DataManager.cpp

#include "DataManager.h"
#include <QTextCodec>
#include <QFile>
#include <QApplication>
#ifdef Q_OS_WIN
#pragma execution_character_set("utf-8")
#endif
DataManager* DataManager::g_GlobalSingle = NULL;
std::mutex DataManager::m_Mutex;
DataManager::DataManager(QObject* parent)
    : QObject(parent)
{
    InitTestFileData();
    pRunThread = new TaskRunThread(this);
}

DataManager& DataManager::instance()
{
    if (g_GlobalSingle == NULL)
    {
        std::unique_lock<std::mutex> lock(m_Mutex);
        if (g_GlobalSingle == NULL)
        {
            g_GlobalSingle = new (std::nothrow) DataManager();
        }
    }
    return *g_GlobalSingle;
}

void DataManager::destroyInstance()
{
    std::unique_lock<std::mutex> lock(m_Mutex);
    if (g_GlobalSingle)
    {
        delete g_GlobalSingle;
        g_GlobalSingle = NULL;
    }
}

std::string DataManager::string_To_UTF8(const std::string& str)
{
    QTextCodec* codec = QTextCodec::codecForName("GBK"); // 根据实际情况调整源编码
    if (!codec) {
        return str;
    }

    QString unicodeStr = codec->toUnicode(str.c_str());
    QByteArray utf8Data = unicodeStr.toUtf8();
    return std::string(utf8Data.constData(), utf8Data.length());
}

std::string DataManager::UTF8_to_string(const std::string& str)
{
    QTextCodec* utf8Codec = QTextCodec::codecForName("UTF-8");
    if (!utf8Codec) {
        return str;
    }

    QString unicodeStr = utf8Codec->toUnicode(str.c_str());

    QTextCodec* localCodec = QTextCodec::codecForName("GBK"); // 根据实际情况调整目标编码
    if (!localCodec) {
        return str;
    }

    QByteArray localData = localCodec->fromUnicode(unicodeStr);
    return std::string(localData.constData(), localData.length());
}

bool DataManager::JsonToStyled(const std::string& str, std::string& strRetrun)
{
    Json::Reader reader;
    Json::Value root;

    if (reader.parse(str, root))
    {
        return JsonToStyled(root, strRetrun);
    }
    else
    {
        return false;
    }
}

bool DataManager::JsonToStyled(Json::Value& jValue, std::string& strRetrun)
{

    Json::StyledWriter jWriter;
    if (jValue.isNull())
    {
        return false;
    }
    else
    {
        strRetrun = jWriter.write(jValue);
        return true;
    }
}

void DataManager::AddHttpLog(LogJson& pNewLog)
{
    m_vectorLogJson.push_back(pNewLog);
    emit dataChanged(HttpLogList);
}

void DataManager::ClearHttpLog()
{
    m_vectorLogJson.clear();
    emit dataChanged(HttpLogList);
}

void DataManager::InitTestFileData()
{
    QString strPath=QApplication::applicationDirPath()+"/allData.txt";
    QFile pFile(strPath);
    if(pFile.open(QIODevice::ReadOnly|QIODevice::Text))
    {
        strAllDataFile=pFile.readAll();
    };
    SystemData pData;
    pData.nSystemID = 1001;
    pData.nSysType = 1;
    pData.strSysType = "Server";
    pData.strSysName = QString::fromStdString(string_To_UTF8("控制服务器"));
    pData.nStatus = 1;
    m_mapSystemStatus.insert(1001, pData);
    pData.nSystemID = 1002;
    pData.nSysType = 2;
    pData.strSysType = "IO";
    pData.strSysName = QString::fromStdString(string_To_UTF8("IO服务器"));
    pData.nStatus = 0;
    m_mapSystemStatus.insert(1002, pData);
//     pData.nSystemID = 1003;
//     pData.strSysName = QString::fromStdString(string_To_UTF8("信息化服务器"));
//     pData.nStatus = 0;
//     m_mapSystemStatus.insert(1003, pData);
}

void DataManager::setEqpmtStatus(int nSysID, int nStatus)
{
    auto iter = m_mapSystemStatus.find(nSysID);
    if (iter!=m_mapSystemStatus.end())
    {
        iter.value().nStatus = nStatus;
    }
}

bool DataManager::addEqpmFault(std::string strEqpmt,int nEqpmtType, int nFaultID)
{
    auto iters = m_mapEqpmtFault.find(strEqpmt);
    if (iters!=m_mapEqpmtFault.end())
    {
        bool bIsAdded=false;
        for (auto iter =iters.value().begin();iter!=iters.value().end();iter++)
        {
            if (iter->nFaultID==nFaultID)
            {
                bIsAdded = true;
            }
        }
        if (!bIsAdded)
        {
            EqpmtFault pFaultData;
            pFaultData.nFaultID = nFaultID;
            pFaultData.FaultTime = QDateTime::currentDateTime();
            iters.value().push_back(pFaultData);
        }
    }
    else
    {
        QList<EqpmtFault> mList;
        EqpmtFault pFaultData;
        pFaultData.nFaultID = nFaultID;
        pFaultData.FaultTime = QDateTime::currentDateTime();
        mList.push_back(pFaultData);
        m_mapEqpmtFault.insert(strEqpmt, mList);
        m_mapEqpmtType.insert(strEqpmt, nEqpmtType);
    }
    return true;
}

bool DataManager::DeleteEqpmtFault(std::string strEqpmt, int nFaultID)
{
    auto iters = m_mapEqpmtFault.find(strEqpmt);
    if (iters != m_mapEqpmtFault.end())
    {
        for (auto iter = iters.value().begin(); iter != iters.value().end(); iter++)
        {
            if (iter->nFaultID == nFaultID)
            {
                iters.value().erase(iter);
                break;
            }
        }
    }
    else
    {
        return false;
    }
    return true;
}

void DataManager::clearEqpmtFault()
{
    m_mapEqpmtFault.clear();
    m_mapEqpmtType.clear();
}