lp-data-alarm/AlarmRecognition/Module.cpp

#include "Module.h"
#include <QJsonArray>
#include <QJsonObject>
#include <QJsonDocument>
#include <QtCore/QVariant>
#include <QtCore/QDebug>
#include <stdlib.h>
#include <math.h>

Module::Module()
    :BaseModule()
{
    m_pDataConsumer = nullptr;
    m_szOutputs.clear();
    m_mpRangeConfig.clear();
    m_mpDataValue.clear();
}

bool Module::isInheritedFrom(std::string tp)
{
    bool bEqual = (strcasecmp(tp.c_str(), "BaseModule") == 0);
    return bEqual;
}

void Module::regConsumer(DataConsumer* pDC)
{
    m_pDataConsumer = pDC;
}

void Module::Setup(ModuleInfo mi)
{
    std::list<DataItem>::iterator itrO;
    for( itrO = mi.Properties.begin(); itrO != mi.Properties.end(); ++itrO )
    {
        m_szOutputs.push_back(mi.Code + "_" + itrO->Code);
    }

    std::vector<Setting>::iterator itr;
    for( itr = mi.vSettings.begin(); itr != mi.vSettings.end(); ++itr )
    {
        QJsonDocument jsonDoc(QJsonDocument::fromJson(itr->qValue.toString().toLocal8Bit().toStdString().c_str()));
        QJsonObject json = jsonDoc.object();
        QStringList keys = json.keys();

        tagRange tr;
        tr.status = 0;
        if( keys.contains("KeepTimes",Qt::CaseInsensitive) )
        {
            tr.uWinSize = abs(json["KeepTimes"].toInt());
        }
        if( keys.contains("DataName",Qt::CaseInsensitive) )
        {
            tr.szName = json["DataName"].toString();
        }
        if( keys.contains("alarmRuleId",Qt::CaseInsensitive) )
        {
            tr.alarmRuleId = json["alarmRuleId"].toString().toLocal8Bit().toStdString();
        }
        if( keys.contains("alarmRuleVersion",Qt::CaseInsensitive) )
        {
            tr.alarmRuleVersion = json["alarmRuleVersion"].toInt();
        }
        if( keys.contains("level",Qt::CaseInsensitive) )
        {
            tr.level = json["level"].toInt();
        }
        if( keys.contains("object",Qt::CaseInsensitive) )
        {
            tr.object = json["object"].toString().toLocal8Bit().toStdString();
        }
        if( keys.contains("Operator",Qt::CaseInsensitive) )
        {
            double dbOperator1 = 0;
            if( keys.contains("Operator1",Qt::CaseInsensitive) )
            {
                dbOperator1 = json["Operator1"].toDouble();
            }

            double dbOperator2 = 0;
            if( keys.contains("Operator2",Qt::CaseInsensitive) )
            {
                dbOperator2 = json["Operator2"].toDouble();
            }

            std::string szOp = json["Operator"].toString().toLocal8Bit().toStdString();
            if( strcasecmp(szOp.c_str(), "range") == 0)
            {
                tr.dbMin = dbOperator1;
                tr.dbMax = dbOperator2;
            }
            else if( strcasecmp(szOp.c_str(), "above") == 0)
            {
                tr.dbMax = dbOperator1;
            }
            else if( strcasecmp(szOp.c_str(), "below") == 0)
            {
                tr.dbMin = dbOperator1;
            }
            m_mpRangeConfig[tr.szName.toLocal8Bit().toStdString()] = tr;
        }
    }
}

void Module::OnSubData(std::string table,std::string val)
{
    // iterate data
    QJsonParseError err;
    QJsonDocument jsonDoc(QJsonDocument::fromJson(val.c_str(),&err));
    QJsonObject jsonObject = jsonDoc.object();
    QStringList keys = jsonObject.keys();
    foreach(QString dn,keys)
    {
        double dbDataValue = jsonObject[dn].toDouble();
        std::string szDataName = dn.toLocal8Bit().toStdString();
        // has table
        if( m_mpRangeConfig.find(szDataName) == m_mpRangeConfig.end())
        {
            continue;
        }

        // cache data
        m_objDataLock.lockForWrite();
        tagKeyValue kv(szDataName,dbDataValue);
        if( m_mpDataValue.find(szDataName) == m_mpDataValue.end())
        {
            m_mpDataValue[szDataName].push_back(kv);
        }
        else
        {
            // win size
            uint nMaxWinSize = m_mpRangeConfig[szDataName].uWinSize;
            if( nMaxWinSize <= 0 )
            {
                nMaxWinSize = 1;
            }

            while( m_mpDataValue[szDataName].size() >= nMaxWinSize)
            {
                m_mpDataValue[szDataName].erase(m_mpDataValue[szDataName].begin());
            }
            m_mpDataValue[szDataName].push_back(kv);
        }
        m_objDataLock.unlock();
    }

    // alarm recognition
    m_objDataLock.lockForRead();
    std::map<std::string,std::list<tagKeyValue>>::iterator itr;
    for( itr = m_mpDataValue.begin(); itr != m_mpDataValue.end(); ++itr )
    {
        std::string szDataName = itr->first;

        m_mpRangeConfig[szDataName].nStatus = EAS_Normal;
        std::list<tagKeyValue>::iterator itrV;
        for( itrV = m_mpDataValue[szDataName].begin(); itrV != m_mpDataValue[szDataName].end(); ++itrV)
        {
            tagKeyValue tKV = *itrV;

            if( itrV->value > m_mpRangeConfig[szDataName].dbMax )
            {
                m_mpRangeConfig[szDataName].nStatus |= 0x01;
            }
            else if( itrV->value < m_mpRangeConfig[szDataName].dbMin )
            {
                m_mpRangeConfig[szDataName].nStatus |= 0x02;
            }
            else
            {
                m_mpRangeConfig[szDataName].nStatus = EAS_Normal;
            }
        }

        //qDebug() << __FILE__ << __LINE__ << name.c_str() << m_mpRangeConfig[name].nStatus;
        std::vector<std::string>::iterator itr;
        for( itr = m_szOutputs.begin(); itr != m_szOutputs.end(); ++itr )
        {
            QString szStatus;
            switch( m_mpRangeConfig[szDataName].nStatus )
            {
            case EAS_Normal:
                szStatus = "[]";
                break;
            case EAS_OverThan:
                szStatus = ">";
                break;
            case EAS_UnderThan:
                szStatus = "<";
                break;
            case EAS_Both:
                szStatus = "><";
                break;
            }

            QString szJson;
            szJson += "{";
            szJson += QString("\"occurTime\":\"%1\",").arg(QDateTime::currentDateTime().toString("yyyy-MM-dd HH:mm:ss:zzz"));
            szJson += QString("\"status\":%1,").arg(m_mpRangeConfig[szDataName].status);
            szJson += QString("\"content\":\"%1 %2\",").arg(szDataName.c_str()).arg(szStatus);
            szJson += QString("\"alarmRuleId\":\"%1\",").arg(m_mpRangeConfig[szDataName].alarmRuleId.c_str());
            szJson += QString("\"alarmRuleVersion\":%1,").arg(m_mpRangeConfig[szDataName].alarmRuleVersion);
            szJson += QString("\"level\":%1,").arg(m_mpRangeConfig[szDataName].level);
            szJson += QString("\"object\":\"%1\"").arg(m_mpRangeConfig[szDataName].object.c_str());
            szJson += "}";
            m_pDataConsumer->OnData(*itr,QVariant(szJson));
        }
    }
    m_objDataLock.unlock();
}

BaseModule* instance()
{
    return new Module();
}

void destroy(BaseModule* pInstance)
{
    if( pInstance )
    {
        delete pInstance;
    }
}