HM-SPMS/product/src/application/sequence_server/CRdbSeqRunningAccess.cpp

#include "CRdbSeqRunningAccess.h"
#include <iostream>
#include "CSqlDbCtrl.h"

CRdbSeqRunningAccess::CRdbSeqRunningAccess()
{
}

CRdbSeqRunningAccess::~CRdbSeqRunningAccess()
{
    if (isOpen())
    {
        close();
    }
}

bool CRdbSeqRunningAccess::open(int nAppID)
{
    BOOST_ASSERT(!isOpen());
    return crt_ex.open(nAppID, "sequence_running");
}

bool CRdbSeqRunningAccess::close()
{
    //BOOST_ASSERT(isOpen());
    return crt_ex.close();
}

bool CRdbSeqRunningAccess::isOpen()
{
    return crt_ex.isOpen();
}

bool CRdbSeqRunningAccess::remapRunningTable(CRecoverNodeContainer& info)
{
    if (!isOpen())
    {
        LOGERROR("实时服务RunningTable未打开");
        return false;
    }

    using namespace iot_dbms;

    std::vector<std::string> selColnumn;
    selColnumn.push_back(std::string("seq_name"));
    selColnumn.push_back(std::string("func_name"));
    selColnumn.push_back(std::string("action_name"));
    selColnumn.push_back(std::string("node_desc"));
    selColnumn.push_back(std::string("action_no"));
    selColnumn.push_back(std::string("func_no"));
    selColnumn.push_back(std::string("node_type"));
    selColnumn.push_back(std::string("status"));
    selColnumn.push_back(std::string("checked"));
    selColnumn.push_back(std::string("start_time"));
    selColnumn.push_back(std::string("user_id"));
    selColnumn.push_back(std::string("user_groupid"));
    selColnumn.push_back(std::string("host_name"));
    selColnumn.push_back(std::string("user_name"));
    selColnumn.push_back(std::string("timeflag"));
    selColnumn.push_back(std::string("relation"));
    selColnumn.push_back(std::string("delay_time"));
    selColnumn.push_back(std::string("fail_strage"));
    selColnumn.push_back(std::string("isses"));
    selColnumn.push_back(std::string("key_id_tag"));
    selColnumn.push_back(std::string("targetvalue"));
    selColnumn.push_back(std::string("location_id"));
    selColnumn.push_back(std::string("seq_type"));

    std::vector<CONDINFO> condInfo;
    std::vector<SSeqCtrlRunning> vecResult;

    if (!crt_ex.selectAllVec(condInfo, vecResult, selColnumn))
    {
        LOGERROR("实时服务读取数据 remapRunningTable 失败");
        return false;
    }

    std::vector<SSeqCtrlRunning>::iterator iter = vecResult.begin();
    for (; iter != vecResult.end(); ++iter)
    {
        SSeqCtrlRunning* data = new SSeqCtrlRunning(*iter);
        info.pushData(data);
    }

    info.createModel();
    return true;
}

void CRdbSeqRunningAccess::lockTable()
{
    m_muLock.lock();
    crt_ex.lock(); 
}

bool CRdbSeqRunningAccess::updateRecord(
    const SSeqCtrlRunning& record)
{
    if (!isOpen())
    {
        LOGERROR("实时服务RunningTable未打开");
        return false;
    }

    BOOST_ASSERT(record.timeflag != 0);

    using namespace iot_dbms;
    std::vector<RSQL_UPD_COLUMN> updColumn;
    CRdbPublic::addUpColumnInfo(updColumn, "node_desc", record.node_desc);
    CRdbPublic::addUpColumnInfo(updColumn, "action_no", record.action_no);
    CRdbPublic::addUpColumnInfo(updColumn, "func_no", record.func_no);
    CRdbPublic::addUpColumnInfo(updColumn, "node_type", record.node_type);
    CRdbPublic::addUpColumnInfo(updColumn, "status", record.status);
    CRdbPublic::addUpColumnInfo(updColumn, "checked", record.checked);
    CRdbPublic::addUpColumnInfo(updColumn, "start_time", record.start_time);
    CRdbPublic::addUpColumnInfo(updColumn, "user_id", record.user_id);
    CRdbPublic::addUpColumnInfo(updColumn, "user_groupid", record.user_groupid);
    CRdbPublic::addUpColumnInfo(updColumn, "host_name", record.host_name);
    CRdbPublic::addUpColumnInfo(updColumn, "user_name", record.user_name);
    CRdbPublic::addUpColumnInfo(updColumn, "timeflag", record.timeflag);
    CRdbPublic::addUpColumnInfo(updColumn, "relation", record.relation);
    CRdbPublic::addUpColumnInfo(updColumn, "delay_time", record.delay_time);
    CRdbPublic::addUpColumnInfo(updColumn, "fail_strage", record.fail_strage);
    CRdbPublic::addUpColumnInfo(updColumn, "isses", record.isses);
    CRdbPublic::addUpColumnInfo(updColumn, "key_id_tag", record.key_id_tag);
    CRdbPublic::addUpColumnInfo(updColumn, "targetvalue", record.targetvalue);
    CRdbPublic::addUpColumnInfo(updColumn, "location_id", record.location_id);
    CRdbPublic::addUpColumnInfo(updColumn, "seq_type", record.seq_type);

    std::vector<CONDINFO> condInfo;
    CRdbPublic::addCondInfo(condInfo, "seq_name", record.seq_name);
    CRdbPublic::addCondInfo(condInfo, "func_name", record.func_name);
    CRdbPublic::addCondInfo(condInfo, "action_name", record.action_name);

    if (crt_ex.update(updColumn, condInfo))
    {
        return true;
    }

    LOGERROR("实时服务更新 SeqRunningRecord 失败");
    return false;
}

void CRdbSeqRunningAccess::unLockTable()
{   
    crt_ex.unLock();
    m_muLock.unlock();
}

bool CRdbSeqRunningAccess::addSeqRunningRecord(const SSeqCtrlRunning& record)
{
    if (!isOpen())
    {
        LOGERROR("实时服务RunningTable未打开");
        return false;
    }

    BOOST_ASSERT(record.timeflag != 0);

    using namespace iot_dbms;
    if (crt_ex.addRecordEX(record)) {
        return true;
    }

    LOGERROR("实时服务添加 SeqRunningRecord 失败");
    return false;
}

bool CRdbSeqRunningAccess::updateRecordOnlyState(const SSeqCtrlRunning& record)
{
    if (!isOpen())
    {
        LOGERROR("实时服务RunningTable未打开");
        return false;
    }

    using namespace iot_dbms;
    std::vector<RSQL_UPD_COLUMN> updColumn;
    CRdbPublic::addUpColumnInfo(updColumn, "status", record.status);

    std::vector<CONDINFO> condInfo;
    CRdbPublic::addCondInfo(condInfo, "seq_name", record.seq_name);
    CRdbPublic::addCondInfo(condInfo, "func_name", record.func_name);
    CRdbPublic::addCondInfo(condInfo, "action_name", record.action_name);

    if (crt_ex.update(updColumn, condInfo))
    {
        return true;
    }

    LOGERROR("实时服务更新 SeqRunningRecordState 失败");
    return false;
}

bool CRdbSeqRunningAccess::deleteOneRecord(const std::string& seq)
{
    if (!isOpen())
    {
        LOGERROR("实时服务RunningTable未打开");
        return false;
    }

    using namespace iot_dbms;
    std::vector<CONDINFO>  condInfop;
    CRdbPublic::addCondInfo(condInfop, "seq_name", seq);

    return crt_ex.remove(condInfop);
}

bool CRdbSeqRunningAccess::deleteAllRecord()
{
    if (!isOpen())
    {
        LOGERROR("实时服务RunningTable未打开");
        return false;
    }

    using namespace iot_dbms;
    std::vector<CONDINFO>  condInfop;

    return crt_ex.remove(condInfop);
}