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>

void split(const std::string source,const std::string delim,std::vector<std::string>& dest)
{
    long n = delim.length();
    long lt = source.length();

    long last = 0;
    size_t index = source.find_first_of(delim,last);
    while(index != std::string::npos)
    {
        dest.push_back(source.substr(last,index-last));
        last = index + n;
        index = source.find_first_of(delim,last);
    }

    long len = source.length();
    if( len - last > 0)
    {
        dest.push_back(source.substr(last,len - last));
    }
}

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;
        if( keys.contains("KeepTimes",Qt::CaseInsensitive) )
        {
            tr.uWinSize = abs(json["KeepTimes"].toInt());
        }
        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["topic_" + itr->Name] = tr;
        }
    }
}

void Module::OnSubData(std::string name,std::string val)
{
    if( m_mpRangeConfig.find(name) == m_mpRangeConfig.end())
    {
        return;
    }

    if( val.find(' ') != std::string::npos )
    {
        std::vector<std::string> dest;
        split(val," ",dest);
        val = *dest.rbegin();
    }
    uint nMaxWinSize = m_mpRangeConfig[name].uWinSize;
    if( nMaxWinSize <= 0 )
    {
        nMaxWinSize = 1;
    }

    // add data
    m_objDataLock.lockForWrite();
    if( m_mpDataValue.find(name) == m_mpDataValue.end())
    {
        m_mpDataValue[name].push_back(tagKeyValue(name,val.length()>0 ? std::stod(val):0));
    }
    else
    {
        while( m_mpDataValue[name].size() >= nMaxWinSize)
        {
            m_mpDataValue[name].erase(m_mpDataValue[name].begin());
        }
        m_mpDataValue[name].push_back(tagKeyValue(name,val.length()>0 ? std::stod(val):0));
    }

    // alarm recognition
    m_mpRangeConfig[name].nStatus = EAS_Both;
    std::list<tagKeyValue>::iterator itrV;
    for( itrV = m_mpDataValue[name].begin(); itrV != m_mpDataValue[name].end(); ++itrV)
    {
        tagKeyValue tKV = *itrV;

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

    //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[name].nStatus )
        {
        case EAS_Normal:
            szStatus = "Normal";
            break;
        case EAS_OverThan:
            szStatus = "OverThan";
            break;
        case EAS_UnderThan:
            szStatus = "OverThan";
            break;
        case EAS_Both:
            szStatus = "Both";
            break;
        }

        m_pDataConsumer->OnData(*itr,QVariant(szStatus));
    }
}

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

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