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");
    /* 模拟违禁品算法ID，后续需要动态调整 */
    m_keyContraband = "OD210_026_005246_001-IZRTKyEx";
    
}

SPAServer::~SPAServer()
{

}

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

    /* 测试Redis读取并解析数据线程 */
    CameraThreadInfo info;
    info.RedisIP = "172.16.36.80";
    info.RedisPort = 32222;
    info.RedisPWD = "Ff1z@TOFr^iwd%Ra";
    info.DeviceID = 117;
    info.vecAction.push_back("OD210_026_005246_001-IZRTKyEx");
    m_keyContraband = "OD210_026_005246_001-IZRTKyEx";
    // CPPTP.add_task(&SPAServer::threadFromRedis, this, info);
    threadFromRedis(info);
}


/**
 * @brief 从基础平台获取算法信息和设备信息的线程函数
 * 
 */
void SPAServer::threadFromSuperBrain()
{
    SPDLOG_LOGGER_INFO(m_logger, "开启 fromSuperBrainThread 线程");
    /* 创建变量 */
    std::vector<AlgorithmInfo> vecAlgNewInfo;
    std::vector<DeviceInfo> vecDevNewInfo;

    /* 获取一次token，后续失效了再获取 */
    m_fromSuperBrain.getToken();
    while (m_threadRunning)
    {
        SPDLOG_LOGGER_INFO(m_logger, "刷新算法和设备信息");
        /* 先更新数据库的信息，防止从其他地方更改了数据库，这里没有刷新本地缓存 */
        m_toEQMDataBase.getAlgorithmInfo(m_vecEqmAlgInfo);
        m_toEQMDataBase.getDeviceInfo(m_vecEqmDevInfo);
        m_toEQMDataBase.getDeviceAlgorithmInfo(m_vecEqmDevInfo, m_listDevIDDelete);
        /* 从超脑获取基础信息 */
        m_fromSuperBrain.getTaskTypeList(vecAlgNewInfo);
        m_fromSuperBrain.getDeviceList(vecDevNewInfo);

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

        vecAlgNewInfo.clear();
        vecDevNewInfo.clear();
        /* 更新关联关系 */
        m_mutexCameraActionID.lock();
        m_toEQMDataBase.getDeviceAlgorithmInfo(m_mapCameraActionID);
        m_mutexCameraActionID.unlock();
        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;
    }

    vecDevUpdate.clear();
    /* 对比现有的设备是否需要更新算法 */
    compareDeviceAlgorithmInfo(vecNewDevInfo, vecDevUpdate);
    if(vecDevUpdate.size() > 0)
    {
        SPDLOG_LOGGER_DEBUG(m_logger, "更新设备和算法关联表, 更新设备数目:{}", vecDevUpdate.size());
        m_toEQMDataBase.updateDeviceAlgorithmInfo(vecDevUpdate);
    }
    
    
    /* 删除tActionCamer表中消失的设备信息 */
    if(m_listDevIDDelete.size() > 0)
    {
        SPDLOG_LOGGER_DEBUG(m_logger, "删除消失的设备关联的算法");
        m_toEQMDataBase.deleteDeviceAlgorithmInfo(m_listDevIDDelete);
        isUpdate = true;
    }


    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;
    }
}


/**
 * @brief 对比设备和算法关联表是否需要更新
 *        对比规则：
 *        1、这里只对比已有的设备ID，需要删除的ID在获取到tActionCamer表是就已经取出来了
 *        2、如果设备ID相等，那么进一步对比算法信息是否相等
 *        3、如果设备ID相等，但是算法信息数目不相等，那么直接加入更新列表
 *        4、如果设备ID相等，算法信息数目相等，进一步对比算法信息
 * 
 * @param vecNewInfo 
 * @param vecDevUpdate 
 */
void SPAServer::compareDeviceAlgorithmInfo(const std::vector<DeviceInfo>& vecNewInfo, std::vector<DeviceInfo>& vecDevUpdate)
{
    vecDevUpdate.clear();
    for(const auto& it0 : vecNewInfo)
    {
        for(const auto& it1 : m_vecEqmDevInfo)
        {
            if(it0.DeviceID == it1.DeviceID)
            {
                /* 设备的算法信息数目不相等，直接加入更新列表 */
                if(it0.vecAlgorithmInfo.size() != it1.vecAlgorithmInfo.size())
                {
                    vecDevUpdate.push_back(it0);
                    break;
                }
                /* 设备的算法信息数目相等，进一步对比算法信息 */
                bool isEquality = true;
                for(const auto& it2 : it0.vecAlgorithmInfo)
                {
                    bool isEq2 = false;
                    for(const auto& it3 : it1.vecAlgorithmInfo)
                    {
                        /* 这里只对比算法ID */
                        if(it2.ActionID != it3.ActionID)
                        {
                            continue;
                        }else {
                            isEq2 = true;
                            break;
                        }
                    }
                    if(!isEq2)
                    {
                        isEquality = false;
                        break;
                    }
                }
                if(!isEquality)
                {
                    vecDevUpdate.push_back(it0);
                    break;
                }
            }
        }
    }
}



/**
 * @brief 从Redis获取数据线程函数，这个是摄像机线程
 *        一个设备一个线程，这个线程的相关变量只在这个线程中使用
 * 
 * @param info 
 */
void SPAServer::threadFromRedis(const CameraThreadInfo& info)
{
    SPDLOG_LOGGER_INFO(m_logger, "开启 fromRedisThread 线程，设备ID:{}", info.DeviceID);
    FromRedis fromRedis;
    fromRedis.setRedisIPAndPort(info.RedisIP, info.RedisPort);
    fromRedis.setRedisPassword(info.RedisPWD);
    if(fromRedis.connectRedis())
    {
        SPDLOG_LOGGER_INFO(m_logger, "连接Redis成功");
    }else {
        SPDLOG_LOGGER_ERROR(m_logger, "连接Redis失败");
        return;
    }
    CameraThreadInfo threadInfo = info;
    // std::string strKey = "117:OD210_026_005246_001-IZRTKyEx";
    /* 取出该设备的Key */
    std::vector<std::string> vecKey;
    for(const auto& it : info.vecAction)
    {
        std::string strKey = std::to_string(info.DeviceID) + ":" + it;
        vecKey.push_back(strKey);
    }
    std::string strRetValue;
    /* 进入线程循环 */
    while (m_threadRunning)
    {
        /* 循环读取这个设备关联的算法信息 */
        for(const auto& it : vecKey)
        {
            SPDLOG_LOGGER_INFO(m_logger, "读取Redis信息, Key: {}", it);
            fromRedis.getRedisString(it, strRetValue);
            SPDLOG_LOGGER_TRACE(m_logger, "Redis Value:\n{}", strRetValue);
            /* 解析数据 */
            AlarmInfo alarmInfo;
            alarmInfo.ActionID = it.substr(it.find(":") + 1);
            /* 解析数据 */
            parseRedisData(strRetValue, alarmInfo);
            /* 信息时间有的效性判断，主要是记录Redis数据的有效性，是否长时间没有变化，排查错误时用的
             * 如果数据长时间数据不变，那么超脑那里就挂了，写入日志 */
            isEventTimeVaild(alarmInfo.EventTime);
            
            /* 是否需要写入EQM数据库判断
             * 人员计数和区域人员检测需要多次判断，其他的直接写入即可 */
            
        }


        std::this_thread::sleep_for(std::chrono::seconds(2));
    }
    
    return;
}

/* 解析Redis基础数据 */
void SPAServer::parseRedisData(const std::string& strData, AlarmInfo& alarmInfo)
{
    try
    {
        nJson json0;
        json0 = nJson::parse(strData);
        alarmInfo.AlarmID = json0["alarmId"].get<int>();
        alarmInfo.ChannelID = json0["channel"].get<int>();
        alarmInfo.PicUrl = json0["picUrl"].get<std::string>();
        alarmInfo.ImageInfo = json0["imageInfo"].get<std::string>();
        
        /* 解析时间，需要将时间中的“T”换成空格 */
        alarmInfo.StartTime = json0["beginTime"].get<std::string>();
        std::replace(alarmInfo.StartTime.begin(), alarmInfo.StartTime.end(), 'T', ' ');
        alarmInfo.EndTime = json0["endTime"].get<std::string>();
        std::replace(alarmInfo.EndTime.begin(), alarmInfo.EndTime.end(), 'T', ' ');
        alarmInfo.EventTime = json0["eventTime"].get<std::string>();
        std::replace(alarmInfo.EventTime.begin(), alarmInfo.EventTime.end(), 'T', ' ');
        /* 判断bBoxes有无数据，有数据就解析，没数据就直接返回了 */
        nJson json1 = json0["bBoxes"];
        
        std::string labelList;              /* 记录违禁品 */
        std::string bboxList;               /* 记录bbox */
        if(!json1.empty())
        {
            for(auto& it0 : json1)
            {
                /* 如果status是true，就不是报警，直接跳过 */
                bool status = it0["status"].get<bool>();
                if(status)
                {
                    continue;
                }
                /* 这一条Box数据报警了将其内容存储起来 */
                alarmInfo.Is_Alarm = true;
                /* 解析label，违禁品关键字，先判断这个是不是违禁品检测的算法ID */
                if(alarmInfo.ActionID == m_keyContraband)
                {
                    /* 解析报警，取出报警类型 */
                    nJson label = it0["label"];
                    for(auto& it1 : label)
                    {
                        std::string strLabel = it1.get<std::string>();
                        /* 检测是否已经加入到字符串中了 */
                        strLabel += "|";
                        if(labelList.find(strLabel) != std::string::npos)
                        {
                            continue;
                        }
                        labelList += strLabel;
                    }
                }
                /* 解析bbox，貌似是在图像中的位置 */
                nJson bbox = it0["bbox"];
                std::string strBbox;
                for(auto& it1 : bbox)
                {
                    strBbox += std::to_string(it1.get<int>()) + ",";
                }
                /* 去掉最后一个“,” */
                if(!strBbox.empty())
                {
                    strBbox.pop_back();
                }
                bboxList += strBbox + "|";
            }
            /* 去掉最后一个“|” */
            if(!labelList.empty())
            {
                labelList.pop_back();
            }
            if(!bboxList.empty())
            {
                bboxList.pop_back();
            }
            SPDLOG_LOGGER_DEBUG(m_logger, "违禁品列表:{}", labelList);
            SPDLOG_LOGGER_DEBUG(m_logger, "bbox列表:{}", bboxList);
        }
        
        /* 如果有报警的Box */
        if(alarmInfo.Is_Alarm)
        {
            /* 添加报警信息的提示信息 */
            alarmInfo.BboxList = bboxList;
            if( (alarmInfo.ActionID == m_keyContraband) && !labelList.empty() )
            {
                alarmInfo.ActionDes = fmt::format("出现违禁品[{}]告警", labelList);
                SPDLOG_LOGGER_INFO(m_logger, "{}", alarmInfo.ActionDes);
            }else {
                alarmInfo.ActionDes = json0["actionDes"].get<std::string>();
            }
            /* 判断有没有报警数据 */
            if(alarmInfo.ImageInfo.empty())
            {
                SPDLOG_LOGGER_ERROR(m_logger, "有报警区域，但是没有图片信息");
                return;
            }
            /* 如果是人员报警，就存储人员报警信息 */
            if(alarmInfo.ActionID == m_KeyFace)
            {
                nJson jsonArray = json0["personList"];
                for(auto& it : jsonArray)
                {
                    PersonInfo personInfo;
                    personInfo.PersonID = it["personId"].get<std::string>();
                    personInfo.PersonName = it["personName"].get<std::string>();
                    alarmInfo.vecPersonInfo.push_back(personInfo);
                }
            }
        }

        
    }
    catch (const nJson::parse_error& e)
    {
        SPDLOG_LOGGER_ERROR(m_logger, "解析Redis数据失败:{}, 错误ID:{}", e.what(), e.id);
        return;
    }
    catch (const nJson::type_error& e)
    {
        SPDLOG_LOGGER_ERROR(m_logger, "解析Redis数据失败:{}, 错误ID:{}", e.what(), e.id);
        return;
    }

}


/* 判断时间是否长时间没有更新 */
bool SPAServer::isEventTimeVaild(const std::string& strTime)
{
    /* 获取当前时间 */
    time_t now = time(0);
    /* 字符串转成时间 */
    tm tmTime;
    strptime(strTime.c_str(), "%Y-%m-%d %H:%M:%S", &tmTime);
    time_t eventTime = mktime(&tmTime);
    /* 时间差 */
    double diff = difftime(now, eventTime);
    SPDLOG_LOGGER_DEBUG(m_logger, "now:{} eventTime: {} 时间差:{}秒",now, eventTime, diff);

    return true;
}


/**
 * @brief 刷新房间和摄像机关联的线程
 *        线程定时刷新房间和摄像机的管理关系，以及和算法Action的关联关系
 */
void SPAServer::threadRoomCamera()
{
    /* 房间相机关联信息 */
    std::list<RoomCameraInfo> listRC;
    /* 创建连接数据库实例 */
    std::shared_ptr<ToEQMDataBase> toEQMDataBase = std::make_shared<ToEQMDataBase>();

    while (m_threadRunning)
    {
        /* 先获取EQM数据库信息，取出房间和摄像机关联信息 */
        toEQMDataBase->getRoomCameraInfo(listRC);
        /* 取出每个房间的所有算法，int是RoomID，string是Action */
        std::multimap<int, std::string> mapCameraActionID;
        m_mutexCameraActionID.lock();
        for(const auto& it0 : listRC)
        {
            /* 根据房间内的摄像机的ID寻找对应的算法 */
            for(const auto& it1 : it0.listCameraID)
            {
                for(const auto& it2 : m_mapCameraActionID)
                {
                    if(it1 == it2.first)
                    {
                    }
                }
            }
        }
        m_mutexCameraActionID.unlock();
        /* 根据每个房间的算法功能，匹配其对应的摄像机 */
        m_mutexRoomCameraInfo.lock();
        /* 循环查找每个房间的算法ID与之关联的设备 */
        for(const auto& it0 : mapCameraActionID)
        {
            /* 人员在岗识别 */
            if(it0.second == ActPersonWork)
            {
                SPDLOG_LOGGER_INFO(m_logger, "RoomID:{} 人员在岗识别", it0.first);
                /* 先查找这个算法ID是否已在列表中 */
                if(findActionIDInList(it0.first, it0.second) == nullptr)
                {
                    /* 不在列表中就创建一个 */
                    RoomActionInfo* roomActionInfo = new RoomActionInfo;
                    roomActionInfo->RoomID = it0.first;
                    roomActionInfo->ActionID = it0.second;
                    /* 将这个算法相关联的在这个房间内的相机加入其中 */
                    for(const auto& it1 : listRC)
                    {
                        if(it1.RoomID == it0.first)
                        {
                            /* 判断这些相机哪些有这个算法 */
                            for(const auto& it2 : it1.listCameraID)
                            {
                                if(isCameraHasAction(it2, it0.second))
                                {
                                    roomActionInfo->listCameraID.push_back(it2);
                                }
                            }
                        }
                    }
                    m_listRoomCameraInfo.push_back(roomActionInfo);
                } else 
                {
                    /* 算法在列表中，清空算法的摄像机列表，重新加入列表中 */
                    RoomActionInfo* roomActionInfo = findActionIDInList(it0.first, it0.second);
                    roomActionInfo->listCameraID.clear();
                    /* 将这个算法相关联的在这个房间内的相机加入其中 */
                    for(const auto& it1 : listRC)
                    {
                        if(it1.RoomID == it0.first)
                        {
                            /* 判断这些相机哪些有这个算法 */
                            for(const auto& it2 : it1.listCameraID)
                            {
                                if(isCameraHasAction(it2, it0.second))
                                {
                                    roomActionInfo->listCameraID.push_back(it2);
                                }
                            }
                        }
                    }
                }
            }
            /* 违禁物品识别 */
        }
    }
}


/* 查找算法ID是否已在列表中 */
RoomActionInfo* SPAServer::findActionIDInList(const int RoomID, const std::string& strActionID)
{
    for(const auto& it0 : m_listRoomCameraInfo)
    {
        if(it0->RoomID == RoomID)
        {
            if(it0->ActionID == strActionID)
            {
                return it0;
            }
        }
    }
    return nullptr;
}

/* 判断相机是否有这个算法 */
bool SPAServer::isCameraHasAction(const int CameraID, const std::string& strActionID)
{
    for(const auto& it : m_mapCameraActionID)
    {
        if(it.first == CameraID)
        {
            if(it.second == strActionID)
            {
                return true;
            }
        }
    }
    return false;
}