lp-data-alarm/EngineAlarm/DataEngine.cpp

#include "DataEngine.h"
#include "DeviceManagerProxy.h"
#include <QJsonArray>
#include <QJsonObject>
#include <QJsonDocument>
#include <fstream>
#include <QtCore/QVariant>
#include <QtCore/QDebug>
#include <QtWidgets/QApplication>

extern std::string loadContent(std::string szFilename);

DataEngine::DataEngine()
    :QObject()
{
    m_pRedis = nullptr;
    m_pTDengine = nullptr;
    m_mpDevControler.clear();
}

void DataEngine::OnData(std::string name,QVariant val)
{
//    if( m_pRedis != nullptr )
//    {
//        m_pRedis->Publish(name, val);
//    }
//    else
//    {
//        qCritical() << __FILE__ << __LINE__ << " " << "no publisher.";
//    }
    if( m_pTDengine != nullptr )
    {
        m_pTDengine->Publish(name, val);
    }
    else
    {
        qCritical() << __FILE__ << __LINE__ << " " << "no publisher.";
    }
}

void DataEngine::sltSubData(char* topic, char* msg)
{
    if(m_mpDevControler.find(topic) == m_mpDevControler.end())
    {
        return;
    }

    m_mpDevControler[topic]->OnSubData(topic,msg);
}

void loadConfig(std::string szFile,Config& config)
{
    std::string cfg = loadContent(szFile);
    QJsonDocument jsonDoc(QJsonDocument::fromJson(cfg.c_str()));
    QJsonObject json = jsonDoc.object();
    QStringList keys = json.keys();
    if( keys.contains("serverid",Qt::CaseInsensitive))
    {
        config.serverId = json["serverid"].toString().toLocal8Bit().toStdString();
    }
    if( keys.contains("module",Qt::CaseInsensitive))
    {
        config.appName = json["module"].toString().toLocal8Bit().toStdString();
    }
}

void DataEngine::Startup()
{
    // merge file name
    QString szWorkDir = qApp->applicationDirPath();
    if( szWorkDir.right(1).contains("/") == false && szWorkDir.right(1).contains("\\") == false)
    {
        szWorkDir += "/";
    }
    std::string szFile = szWorkDir.toLocal8Bit().toStdString() + "config/server.json";

    // load server config
    std::map<std::string,tagSetup> mpConfig;
    std::string cfg = loadContent(szFile);
    QJsonDocument jsonDoc(QJsonDocument::fromJson(cfg.c_str()));
    QJsonArray ja = jsonDoc.array();
    for(auto i : ja)
    {
        QJsonObject json = i.toObject();
        QStringList items = json.keys();
        if( items.contains("ignore",Qt::CaseInsensitive) && json["ignore"].type() == QJsonValue::Bool && json["ignore"].toBool())
        {
            continue;
        }

        tagSetup ts;
        ts.addr = json["addr"].toString().toLocal8Bit().toStdString();
        ts.user = json["user"].toString().toLocal8Bit().toStdString();
        ts.password = json["password"].toString().toLocal8Bit().toStdString();
        ts.db = json["database"].toString().toLocal8Bit().toStdString();
        ts.port = json["port"].toInt();

        std::string szName = json["name"].toString().toLocal8Bit().toStdString();
        mpConfig[szName] = ts;
    }

    m_pRedis = new RedisAgent();
    m_pRedis->Connect(mpConfig["redis"]);           // redis

    m_pTDengine = new TDAgent();
    m_pTDengine->Connect(mpConfig["tdengine"]);       // td

    // server.id
    Config config;
    loadConfig(szWorkDir.toLocal8Bit().toStdString() + "config/alarm.json",config);

    DeviceManagerProxy dm(m_pRedis);
    std::list<AlarmRuler> lstRulers = dm.loadDevices(config.serverId, config.appName);

    DeviceController* pControler = new DeviceController();
    pControler->regConsumer(this);
    pControler->CreateDevice(config.appName,lstRulers);

    std::list<std::string> topics;
    std::list<AlarmRuler>::iterator itr;
    for( itr = lstRulers.begin(); itr != lstRulers.end(); ++itr )
    {
        std::string szTopic = itr->NodeCode + "." + itr->DataItemCode;
        m_mpDevControler[szTopic] = pControler;
        topics.push_back(szTopic);
    }

    m_pTDengine->Subscribe(topics);
    connect(m_pTDengine,SIGNAL(sigEvent(char*, char*)),this,SLOT(sltSubData(char*, char*)));
}