SecurePlay/SecurePlayAuxServer/SPAServer.cpp

#include "SPAServer.h"

#include "spdlog/spdlog.h"
#include "CurlHttp.h"
#include <filesystem>
#include "CurlFtp.h"
#include "ThreadPool/ThreadPool.h"

#include <QVector>


SPAServer::SPAServer()
{
    m_logger = spdlog::get("SPAServer");
    if(m_logger == nullptr)
    {
        SPDLOG_ERROR("APAServer logger is nullptr");
        return;
    }

    m_threadRunning = true;
    /* 初始化WebAPI */
    m_toEQMDataBase.initWebApi("http://192.1.3.133:31000/v6/", "", "4c2f9fc91c22dd98331e47af2e2964f4");


    
}

SPAServer::~SPAServer()
{

}

/* 启动服务 */
void SPAServer::startServer()
{
    /* 添加获取基础信息的线程 */
    CPPTP.add_task(&SPAServer::fromSuperBrainThread, this);
}


/**
 * @brief 从基础平台获取算法信息和设备信息的线程函数
 * 
 */
void SPAServer::fromSuperBrainThread()
{
    SPDLOG_LOGGER_INFO(m_logger, "开启 fromSuperBrainThread 线程");
    /* 创建变量 */
    std::vector<AlgorithmInfo> vecAlgNewInfo;
    std::vector<DeviceInfo> vecDevNewInfo;
    
    /* 从EQM数据库中读取到数据信息到内存中，后续对比需要 */
    m_toEQMDataBase.getAlgorithmInfo(m_vecEqmAlgInfo);
    m_toEQMDataBase.getDeviceInfo(m_vecEqmDevInfo);
    m_toEQMDataBase.getDeviceAlgorithmInfo(m_vecEqmDevInfo);
    /* 获取一次token，后续失效了再获取 */
    m_fromSuperBrain.getToken();
    while (m_threadRunning)
    {
        SPDLOG_LOGGER_INFO(m_logger, "刷新算法和设备信息");
        /* 先更新数据库的信息，防止从其他地方并更改了数据库，这里没有刷新本地缓存 */
        m_toEQMDataBase.getAlgorithmInfo(m_vecEqmAlgInfo);
        m_toEQMDataBase.getDeviceInfo(m_vecEqmDevInfo);
        /* 获取基础信息 */
        m_fromSuperBrain.getTaskTypeList(vecAlgNewInfo);
        m_fromSuperBrain.getDeviceList(vecDevNewInfo);

        /* 处理算法信息 */
        bool algIsUpdate = processAlgorithmInfo(vecAlgNewInfo);
        /* 处理设备信息 */
        bool devIsUpdate = processDeviceInfo(vecDevNewInfo);

        vecAlgNewInfo.clear();
        vecDevNewInfo.clear();
        std::this_thread::sleep_for(std::chrono::seconds(10));
    }
}

/* 处理算法信息，返回值为true，说明有改变，需要重新读取 */
bool SPAServer::processAlgorithmInfo(std::vector<AlgorithmInfo> vecNewAlgInfo)
{
    std::vector<AlgorithmInfo> vecAlgUpdate;
    std::vector<AlgorithmInfo> vecAlgDelete;

    /* 对比数据库表格信息，这里只有插入和删除，没有更新 */
    compareAlgorithmInfo(vecNewAlgInfo, vecAlgUpdate, vecAlgDelete);
        
    /* 更新数据库，先删除，再写入刷新 */
    bool isUpdate = false;
    if(vecAlgDelete.size() > 0)
    {
        SPDLOG_LOGGER_DEBUG(m_logger, "删除算法信息");
        m_toEQMDataBase.deleteAlgorithmInfo(vecAlgDelete);
        isUpdate = true;
    }
    if(vecAlgUpdate.size() > 0)
    {
        SPDLOG_LOGGER_DEBUG(m_logger, "写入算法信息");
        m_toEQMDataBase.writeAlgorithmInfo(vecAlgUpdate);
        isUpdate = true;
    }

    return isUpdate;
}


/**
 * @brief 处理设备信息
 * 
 * @param vecNewDevInfo 传入新获取到的值
 * @return true 需要重新读取数据库，获取新的数据
 * @return false 无需读取数据库
 */
bool SPAServer::processDeviceInfo(std::vector<DeviceInfo> vecNewDevInfo)
{
    std::vector<DeviceInfo> vecDevInsert;
    std::vector<DeviceInfo> vecDevUpdate;
    std::vector<DeviceInfo> vecDevDelete;

    /**************************************************************************/
    /* 这里只对比设备信息，不对比设备的算法信息，算法信息在下面单独对比 */

    /* 如果本地缓存没有数据，那么就全部插入 */
    if(m_vecEqmDevInfo.size() > 0)
    {
        for(const auto& it : vecNewDevInfo)
        {
            bool isExist = false;
            for(const auto& it0 : m_vecEqmDevInfo)
            {
                if(it.DeviceID == it0.DeviceID)
                {
                    isExist = true;
                    /* 对比其他项是否相等，不相等就更新 */
                    if(it == it0)
                    {
                        continue;
                    }else {
                        vecDevUpdate.push_back(it);
                    }
                    break;
                }
            }
            if(!isExist)
            {
                vecDevInsert.push_back(it);
            }
        }
    }else {
        vecDevInsert = vecNewDevInfo;
    }

    /* 获取删除列表 */
    if(vecNewDevInfo.size() > 0)
    {
        bool isExist = false;
        for(const auto& it : m_vecEqmDevInfo)
        {
            isExist = false;
            for(const auto& it0 : vecNewDevInfo)
            {
                if(it.DeviceID == it0.DeviceID)
                {
                    isExist = true;
                    break;
                }
            }
            if(!isExist)
            {
                vecDevDelete.push_back(it);
            }
        }
    }else {
        vecDevDelete = m_vecEqmDevInfo;
    }

    bool isUpdate = false;
    /* 先删除多余的数据 */
    if(vecDevDelete.size() > 0)
    {
        SPDLOG_LOGGER_DEBUG(m_logger, "删除设备信息");
        m_toEQMDataBase.deleteDeviceInfo(vecDevDelete);
        isUpdate = true;
    }
    /* 更新数据 */
    if(vecDevUpdate.size() > 0)
    {
        SPDLOG_LOGGER_DEBUG(m_logger, "更新设备信息");
        m_toEQMDataBase.updateDeviceInfo(vecDevUpdate);
        isUpdate = true;
    }
    /* 插入数据 */
    if(vecDevInsert.size() > 0)
    {
        SPDLOG_LOGGER_DEBUG(m_logger, "插入设备信息");
        m_toEQMDataBase.insertDeviceInfo(vecDevInsert);
        isUpdate = true;
    }

    /**************************************************************************/
    /* 处理设备和算子关联的表格，单独对比设备的算法信息 */

    /* 插入新的设备信息 */
    if(vecDevInsert.size() > 0)
    {
        SPDLOG_LOGGER_DEBUG(m_logger, "插入设备和算法关联表");
        m_toEQMDataBase.insertDeviceAlgorithmInfo(vecDevInsert);
        isUpdate = true;
    }
    /* 删除消失的设备信息 */
    if(vecDevDelete.size() > 0)
    {
        SPDLOG_LOGGER_DEBUG(m_logger, "删除设备和算法关联表");
        m_toEQMDataBase.deleteDeviceAlgorithmInfo(vecDevDelete);
        isUpdate = true;
    }

    vecDevUpdate.clear();
    /* 取出需要更新的设备 */
    for(const auto& it0 : vecNewDevInfo)
    {
        /* 取出ID相等的设备 */
        for(const auto& it1 : m_vecEqmDevInfo)
        {
            if(!it0.isEqualAlgorithmInfo(it1))
            {
                vecDevUpdate.push_back(it0);
                break;
            }
        }
        
    }
    SPDLOG_LOGGER_DEBUG(m_logger, "更新设备和算法关联表, 更新设备数目:{}", vecDevUpdate.size());
    


    return isUpdate;
}

/* 对比现有的数据和新获取到的数据，取出要删除和添加的数据 */
void SPAServer::compareAlgorithmInfo(const std::vector<AlgorithmInfo>& vecNewInfo, std::vector<AlgorithmInfo>& vecAlgUpdate, std::vector<AlgorithmInfo>& vecAlgDelete)
{
    /* 取出要添加的，如果本地缓存是0，那么全部都要添加 */
    if(m_vecEqmAlgInfo.size() > 0)
    {
        for(const auto& it : vecNewInfo)
        {
            bool isExist = false;
            for(const auto& it0 : m_vecEqmAlgInfo)
            {
                /* 如果存在就退出循环 */
                if(it.ActionID == it0.ActionID)
                {
                    isExist = true;
                    break;
                }
            }
            if(!isExist)
            {
                vecAlgUpdate.push_back(it);
            }
        }
    }else {
        vecAlgUpdate = vecNewInfo;
    }
    /* 取出要删除的，如果新的数据是0，那么全部都要删除 */
    if(vecNewInfo.size() > 0)
    {
        bool isExist = false;
        for(const auto& it : m_vecEqmAlgInfo)
        {
            isExist = false;
            for(const auto& it0 : vecNewInfo)
            {
                if(it.ActionID == it0.ActionID)
                {
                    isExist = true;
                    break;
                }
            }
            if(!isExist)
            {
                vecAlgDelete.push_back(it);
            }
        }
    }else {
        vecAlgDelete = m_vecEqmAlgInfo;
    }
}