lp-data-alarm/EngineAlarm/DeviceManagerProxy.cpp

#include "DeviceManagerProxy.h"
#include <QJsonArray>
#include <QJsonObject>
#include <QJsonDocument>
#include <QtCore/QTextCodec>
#include <fstream>

#define DEVICE_NODE "devices"

std::string loadContent(std::string szFilename)
{
    szFilename = QString::fromLocal8Bit(szFilename.c_str()).toLocal8Bit().toStdString();
    std::ifstream inStream(szFilename.c_str(),std::ios::in | std::ios::binary);
    if( inStream.is_open() != true )
    {
        return "";
    }

    return std::string((std::istreambuf_iterator<char>(inStream)),std::istreambuf_iterator<char>());
}

DeviceManagerProxy::DeviceManagerProxy(RedisAgent* redis)
{
    m_pRedis = redis;
}

bool DeviceManagerProxy::parse(QString cfg,AlarmRuler& ar)
{
    //qDebug() << __FILE__ << __LINE__ << cfg;

    //通过网页传来的 json内承运商中文名是 utf-8 编码
    QTextCodec *utf8 = QTextCodec::codecForName("UTF-8");
    QTextCodec::setCodecForLocale(utf8);

    QJsonDocument jsonDoc(QJsonDocument::fromJson(cfg.toLocal8Bit()));
    QJsonObject jsonObject = jsonDoc.object();
    QStringList keys = jsonObject.keys();
    foreach (QString key, keys)
    {
        if( key.compare("code",Qt::CaseInsensitive) == 0)
        {
            ar.alarmRuleId = jsonObject["code"].toString().toLocal8Bit().toStdString();
        }
        else if( key.compare("nodeCode",Qt::CaseInsensitive) == 0)
        {
            ar.NodeCode = jsonObject["nodeCode"].toString().toLocal8Bit().toStdString();
        }
        else if( key.compare("dataItemCode",Qt::CaseInsensitive) == 0)
        {
            ar.DataItemCode = jsonObject["dataItemCode"].toString().toLocal8Bit().toStdString();
        }
        else if( key.compare("operator",Qt::CaseInsensitive) == 0)
        {
            ar.Operator = jsonObject["operator"].toString().toLocal8Bit().toStdString();
        }
        else if( key.compare("operator1",Qt::CaseInsensitive) == 0)
        {
            ar.dbOperator1 = jsonObject["operator1"].toDouble();
        }
        else if( key.compare("operator2",Qt::CaseInsensitive) == 0)
        {
            ar.dbOperator2 = jsonObject["operator2"].toDouble();
        }
        else if( key.compare("continuousTimes",Qt::CaseInsensitive) == 0)
        {
            ar.nKeepTimes = jsonObject["continuousTimes"].toInt();
        }
        else if( key.compare("version",Qt::CaseInsensitive) == 0)
        {
            ar.alarmRuleVersion = jsonObject["version"].toInt();
        }
        else if( key.compare("level",Qt::CaseInsensitive) == 0)
        {
            ar.level = jsonObject["level"].toInt();
        }
    }
    ar.object = ar.NodeCode + "." + ar.DataItemCode;
    ar.status = 0;

    return true;
}

DeviceInfo DeviceManagerProxy::loadDataAlarm(std::string id,std::string app)
{
    DeviceInfo di;
    if( m_pRedis == nullptr)
    {
        return di;
    }

    ModuleInfo mi;
    mi.Code = "active";
    mi.AssemblyName = app;

    DataItem oDT;
    oDT.Code = "alarm";
    mi.Properties.push_back(oDT);
    QStringList lst = m_pRedis->hvals(id.c_str());
    foreach (QString str, lst)
    {
        if( str.isEmpty() )
        {
            continue;
        }

        AlarmRuler ar;
        if( parse(str,ar) )
        {
            QString szJson;
            szJson += "{";
            szJson += QString("\"TableName\":\"%1\",").arg(ar.NodeCode.c_str());
            szJson += QString("\"DataName\":\"%1\",").arg(ar.DataItemCode.c_str());
            szJson += QString("\"Operator\":\"%1\",").arg(ar.Operator.c_str());
            szJson += QString("\"Operator1\":%1,").arg(ar.dbOperator1);
            szJson += QString("\"Operator2\":%1,").arg(ar.dbOperator2);
            szJson += QString("\"KeepTimes\":%1,").arg(ar.nKeepTimes);
            szJson += QString("\"alarmRuleId\":\"%1\",").arg(ar.alarmRuleId.c_str());
            szJson += QString("\"alarmRuleVersion\":%1,").arg(ar.alarmRuleVersion);
            szJson += QString("\"level\":%1,").arg(ar.level);
            szJson += QString("\"object\":\"%1\"").arg(ar.object.c_str());
            szJson += "}";
            Setting oSet;
            oSet.Name = ar.NodeCode;
            oSet.qValue = szJson;

            mi.vSettings.push_back(oSet);
        }
    }

    di.ModuleInfo = mi;
    return di;
}

DeviceInfo DeviceManagerProxy::loadCommAlarm(std::string id,std::string app)
{
    DeviceInfo di;
    if( m_pRedis == nullptr)
    {
        return di;
    }

    ModuleInfo mi;
    mi.Code = "device";
    mi.AssemblyName = app;

    DataItem oDT;
    oDT.Code = "alarm";
    mi.Properties.push_back(oDT);
    QHash<QString, QString> mps = m_pRedis->hgetall(id.c_str());
    QHash<QString, QString>::iterator itr;
    for( itr = mps.begin(); itr != mps.end(); ++itr)
    {
        if( itr.key().isEmpty() || itr.value().isEmpty() )
        {
            continue;
        }

        if( itr.key().compare(DEVICE_NODE,Qt::CaseInsensitive) != 0 )
        {
            continue;
        }

        Setting oSet;
        oSet.Name = itr.key().toLocal8Bit().toStdString();
        oSet.qValue = itr.value();
        mi.vSettings.push_back(oSet);
        break;
    }
    di.ModuleInfo = mi;
    return di;
}