HM-SPMS/product/src/gui/plugin/ISCSAlarmWidget/CAiAlarmTreeItem.cpp

#include "CAiAlarmTreeItem.h"
#include "CAiAlarmMsgInfo.h"
#include "CAlarmMsgInfo.h"
#include "CAlarmCommon.h"
#include "pub_logger_api/logger.h"

CAiAlarmTreeItem::CAiAlarmTreeItem(const QVector<QVariant> &data, CAiAlarmTreeItem *parent)
    : m_parent(parent),
      m_aialarmPtr(NULL),
      m_alarmPtr(NULL),
      m_data(data),
      m_bIsAi(false),
      m_uuid(QString())
     // m_checkState(Qt::Unchecked)
{

}

CAiAlarmTreeItem::~CAiAlarmTreeItem()
{
    qDeleteAll(m_child);
    m_child.clear();
}

CAiAlarmTreeItem *CAiAlarmTreeItem::child(int row)
{
    return m_child.at(row);
}

CAiAlarmTreeItem *CAiAlarmTreeItem::parent()
{
    return m_parent;
}

int CAiAlarmTreeItem::childCount() const
{
    return m_child.count();
}

int CAiAlarmTreeItem::columnCount() const
{
    return m_data.count();
}

int CAiAlarmTreeItem::childNumber() const
{
    if(m_parent)
    {
        return m_parent->m_child.indexOf(const_cast<CAiAlarmTreeItem*>(this));
    }
    return 0;
}

QVariant CAiAlarmTreeItem::data(int column, int role)
{
    if(E_DisplayRole == role)
    {
        if(m_bIsAi == true)
        {
            return aigetDataByColumn(column);
        }else
        {
            return getDataByColumn(column);
        }
    }
    else
    {
        return QVariant();
    }
}

bool CAiAlarmTreeItem::setData(int column, const QVariant &value, int role)
{
    Q_UNUSED(role)
    Q_UNUSED(value)
    if (column < 0 || column >= m_data.size())
        return false;
//    if(E_IfAiFlag == role)
//    {
//        m_bIsAi = value.toBool();
//        return true;
//    }
//    else if(E_UserRole == role)
//    {
//        m_uuid = value.toString();
//       return true;
//    }
//    else if(E_DisplayRole == role)
//    {
//        m_data[column] = value;
//        return true;
//    }
    return true;
}

bool CAiAlarmTreeItem::setPtr(AlarmMsgPtr ptr)
{
    m_alarmPtr = ptr;
    m_bIsAi = false;
    m_uuid = ptr->uuid_base64;
    return true;
}

bool CAiAlarmTreeItem::setAiPtr(AiAlarmMsgPtr aiPtr)
{
    m_aialarmPtr = aiPtr;
    m_bIsAi = true;
    m_uuid = aiPtr->uuid_base64;
    return true;
}

bool CAiAlarmTreeItem::insertChildren(int position, int count, int columns)
{
    if (position < 0 || position > m_child.size())
        return false;

    for (int row = 0; row < count; ++row) {
        QVector<QVariant> data(columns);
        CAiAlarmTreeItem *item = new CAiAlarmTreeItem(data, this);
        m_child.insert(position, item);
    }

    return true;
}

bool CAiAlarmTreeItem::removeChildren(int position, int count, int columns)
{
    Q_UNUSED(columns)
    if (position < 0 || position + count > m_child.size())
        return false;

    for (int row = 0; row < count; ++row)
        delete m_child.takeAt(position);

    return true;
}

bool CAiAlarmTreeItem::isAi()
{
    return m_bIsAi;
}

AlarmMsgPtr CAiAlarmTreeItem::ptr()
{
    if(m_alarmPtr == NULL)
        return NULL;
    else
        return m_alarmPtr;
}

bool CAiAlarmTreeItem::getPtr(AlarmMsgPtr &ptr)
{
    if(!m_bIsAi &&m_alarmPtr != NULL)
    {
        ptr = m_alarmPtr;
        return true;
    }
    else
    {
        ptr = NULL;
        return false;
    }
}

bool CAiAlarmTreeItem::getAiPtr(AiAlarmMsgPtr &aiPtr)
{
    if(m_bIsAi &&m_aialarmPtr != NULL)
    {
        aiPtr = m_aialarmPtr;
        return true;
    }
    else
    {
        aiPtr = NULL;
        return false;
    }
}

QList<AlarmMsgPtr> CAiAlarmTreeItem::getChildAlarmPtr()
{
    QList<AlarmMsgPtr> ptrList;
    foreach (CAiAlarmTreeItem* item, m_child) {
        if(item->ptr() != NULL)
        {
            ptrList.append(item->ptr());
        }
    }
    return ptrList;
}

int CAiAlarmTreeItem::index(const QString uuid)
{
    for(int index(0);index<m_child.count();index++)
    {
        if(m_child.at(index)->m_uuid == uuid)
        {
            return index;
        }
    }
    return -1;
}

bool CAiAlarmTreeItem::lessThan(CAiAlarmTreeItem *info, E_ALARM_SORTKEY sortkey)
{
    AiAlarmMsgPtr aiptr = NULL;
    AlarmMsgPtr ptr= NULL;
    if(m_bIsAi)
    {
        if(info->isAi())
        {
            if(info->getAiPtr(aiptr) && aiptr != NULL)
                return m_aialarmPtr->ailessThan(aiptr,sortkey);
        }else
        {
            if(info->getPtr(ptr) && ptr != NULL)
                return m_aialarmPtr->ailessThan(ptr,sortkey);
        }

    }else
    {
        if(info->isAi())
        {
            if(info->getAiPtr(aiptr) && aiptr != NULL)
            return m_alarmPtr->ailessThan(aiptr,sortkey);
        }else
        {
            if(info->getPtr(ptr) && ptr != NULL)
            return m_alarmPtr->ailessThan(ptr,sortkey);
        }
    }
    LOGERROR("lessThan():比较大小出错!");
    return false;
}

bool CAiAlarmTreeItem::moreThan(CAiAlarmTreeItem *info, E_ALARM_SORTKEY sortkey)
{
    AiAlarmMsgPtr aiptr = NULL;
    AlarmMsgPtr ptr= NULL;
    if(m_bIsAi)
    {
        if(info->isAi())
        {
            if(info->getAiPtr(aiptr) && aiptr != NULL)
                return m_aialarmPtr->aimoreThan(aiptr,sortkey);
        }else
        {
            if(info->getPtr(ptr) && ptr != NULL)
                return m_aialarmPtr->aimoreThan(ptr,sortkey);
        }
    }else
    {
        if(info->isAi())
        {
            if(info->getAiPtr(aiptr) && aiptr != NULL)
            return m_alarmPtr->aimoreThan(aiptr,sortkey);
        }else
        {
            if(info->getPtr(ptr) && ptr != NULL)
            return m_alarmPtr->aimoreThan(ptr,sortkey);
        }
    }
    LOGERROR("moreThan():比较大小出错!");
    return false;
}

QList<CAiAlarmTreeItem *> CAiAlarmTreeItem::getChild()
{
    return m_child;
}

void CAiAlarmTreeItem::setChild(QList<CAiAlarmTreeItem *> itemList)
{
    m_child.clear();
    m_child = itemList;
}

QList<CAiAlarmTreeItem *> CAiAlarmTreeItem::getChildItemList()
{
    return m_child;
}

QVector<QString> CAiAlarmTreeItem::getContent()
{
    QVector<QString> vec;
    if(m_bIsAi)
    {
        for(int index(0);index<m_data.size();index++)
        {
            vec.append(m_data[index].toString());
        }
        return vec;
    }else
    {

        vec.append(QDateTime::fromMSecsSinceEpoch(m_alarmPtr->time_stamp).toString("yyyy-MM-dd hh:mm:ss.zzz"));
        vec.append(CAlarmMsgManage::instance()->queryPriorityDesc(m_alarmPtr->priority));
        vec.append(CAlarmMsgManage::instance()->queryLocationDesc(m_alarmPtr->location_id));
        vec.append(CAlarmMsgManage::instance()->queryRegionDesc(m_alarmPtr->region_id));
        vec.append(CAlarmMsgManage::instance()->queryAlarmTypeDesc(m_alarmPtr->alm_type));
        vec.append(CAlarmMsgManage::instance()->queryAlarmStatusDesc(m_alarmPtr->alm_status));
        if(E_ALS_ALARM == m_alarmPtr->logic_state || E_ALS_RETURN == m_alarmPtr->logic_state
                || E_ALS_ALARM_DEL == m_alarmPtr->logic_state || E_ALS_RETURN_DEL == m_alarmPtr->logic_state) //< 未确认
        {
            vec.append(QObject::tr("未确认"));
        }
        else
        {
            vec.append(QObject::tr("已确认"));
        }
         vec.append("");
        vec.append(m_alarmPtr->content);
    }
    return vec;
}

QVariant CAiAlarmTreeItem::aigetDataByColumn(int column)
{
    if(m_aialarmPtr != NULL)
    {
        switch (column) {
        case TIME:
            m_data[0] = QDateTime::fromMSecsSinceEpoch(m_aialarmPtr->time_stamp).toString("yyyy-MM-dd hh:mm:ss.zzz");
            return m_data[0];
        case PRIORITY:
            m_data[1] = CAlarmMsgManage::instance()->queryPriorityDesc(m_aialarmPtr->priority);
            return m_data[1];
        case LOCATION:
            m_data[2] = CAlarmMsgManage::instance()->queryLocationDesc(m_aialarmPtr->uuid_base64);
            return m_data[2];
        case REGION:
            m_data[3] ="-";
            return m_data[3];
        case TYPE:
            m_data[4] ="-";
            return "-";
        case STATUS:
            m_data[5] ="-";
            return "-";
        case CONFIRM:
            m_data[6] =CAlarmMsgManage::instance()->queryConfirm(m_aialarmPtr->uuid_base64);
            return m_data[6];

        case CONTENT:
            m_data[7] = m_aialarmPtr->content;
            return m_data[7];
        default:
            break;
        }
    }
    return QVariant();
}

QVariant CAiAlarmTreeItem::getDataByColumn(int column)
{
    if(m_alarmPtr != NULL)
    {
        switch (column) {
        case TIME:
            m_data[0] = QDateTime::fromMSecsSinceEpoch(m_alarmPtr->time_stamp).toString("yyyy-MM-dd hh:mm:ss.zzz");
            return m_data[0];
        case PRIORITY:
            m_data[1] = CAlarmMsgManage::instance()->queryPriorityDesc(m_alarmPtr->priority);
            return m_data[1];
        case LOCATION:
            m_data[2] = CAlarmMsgManage::instance()->queryLocationDesc(m_alarmPtr->location_id);
            return m_data[2];
        case REGION:
            m_data[3] = CAlarmMsgManage::instance()->queryRegionDesc(m_alarmPtr->region_id);
            return m_data[3];
        case TYPE:
            m_data[4] = CAlarmMsgManage::instance()->queryAlarmTypeDesc(m_alarmPtr->alm_type);
            return m_data[4];
        case STATUS:
            m_data[5] = CAlarmMsgManage::instance()->queryAlarmStatusDesc(m_alarmPtr->alm_status);
            return m_data[5];
        case CONFIRM:
            if(E_ALS_ALARM == m_alarmPtr->logic_state || E_ALS_RETURN == m_alarmPtr->logic_state
                    || E_ALS_ALARM_DEL == m_alarmPtr->logic_state || E_ALS_RETURN_DEL == m_alarmPtr->logic_state) //< 未确认
            {
                m_data[6] = QObject::tr("未确认");
                return m_data[6];
            }
            else
            {
                m_data[6] = QObject::tr("已确认");
                return m_data[6];
            }
        case CONTENT:
            m_data[7] = m_alarmPtr->content;
            return m_data[7];
        default:
            break;
        }
    }
    return QVariant();
}