SecurePlay/SecurePlayAuxServer/Application/FuncOrdinary.cpp

#include "FuncOrdinary.h"
#include "GlobalVariable.h"
#include "FromRedis.h"
#include "FromWebAPI.h"
#include "UniversalFunc.h"
#include "GlobalConfig.h"

FuncOrdinary::FuncOrdinary()
{
    m_logger = spdlog::get("SPAServer");
    if(m_logger == nullptr)
    {
        SPDLOG_LOGGER_ERROR(m_logger, "SPAServer logger is nullptr");
        return;
    }

}

FuncOrdinary::~FuncOrdinary()
{

}

/* 任务线程 */
void FuncOrdinary::task()
{
    /* 初始化WebAPI和Redis接口 */
    if(!initDataInterface())
    {
        return;
    }
    /* 保存上次获取时间段的时间 */
    QDateTime lastTime = QDateTime::fromString("2025-05-07 00:00:00", "yyyy-MM-dd hh:mm:ss");
    while (GThreadInfo.getRunning())
    {
        /* 休眠设置的时间 */
        std::this_thread::sleep_for(std::chrono::milliseconds(GVariable.ThreadSleepMS));

        /* 从全局的信息块中更新功能信息，如是否需要退出线程，主要是更新摄像机关联的算法信息 */
        GThreadInfo.updateFuncInfo(m_funcThreadInfo);
        /* 如果线程的运行状态为停止 */
        if(m_funcThreadInfo.RunState == RunTimeState::RUN_STATE_STOP)
        {
            /* 退出线程 */
            break;
        }

        /* 判断是否在检测时间段内 */
        if(!isInDetectTime(m_periodInfo))
        {
            continue;
        }
        // SPDLOG_LOGGER_DEBUG(m_logger, "{} 在检测时间段内", m_baseLog);

        /* 读取Redis数据 */
        for(const auto& roomInfo : m_funcThreadInfo.listRoomCamActInfo)
        {
            for(const auto& it : roomInfo.mapCameraAction)
            {
                for(const auto act : it.second)
                {
                    /* 读取Redis数据 */
                    std::string strKey = std::to_string(it.first) + ":" + act;
                    std::string strRetValue;
                    SPDLOG_LOGGER_DEBUG(m_logger, "读取Redis数据, Key:{}", strKey);
                    if(!m_fromRedis->getRedisString(strKey, strRetValue))
                    {
                        SPDLOG_LOGGER_ERROR(m_logger, "读取Redis数据失败, Key:{}", strKey);
                        std::this_thread::sleep_for(std::chrono::milliseconds(10));
                        continue;
                    }
                    SPDLOG_LOGGER_DEBUG(m_logger, "数据:{}", strRetValue);

                    /* 解析数据，先设置基础数据 */
                    // AlarmInfo newAlarmInfo;
                    // newAlarmInfo.ActionID = act;
                    // newAlarmInfo.appFunction = m_funcThreadInfo.appFunction;

                    // parseRedisBaseData(strRetValue, newAlarmInfo);
                    // parseRedisBBoxesData(strRetValue, newAlarmInfo);
                    /* 判断事件的时效性，超过多少秒不更新就可能是超脑挂了 */
                    // if(isEventTimeVaild(newAlarmInfo.EventTime))
                    // {
                    //     SPDLOG_LOGGER_WARN(m_logger, "Redis Key:{} 数据长时间没有更新，EventTime:{}",strKey, newAlarmInfo.EventTime);
                    //     std::this_thread::sleep_for(std::chrono::milliseconds(100));
                    //     continue;
                    // }

                }
            }
        }
        
        
        continue;
        /* 读取Redis信息，处理数据，第一层循环是根据房间读取，第二个循环是根据房间内的摄像机读取 */
        for(const auto& roomInfo : m_funcThreadInfo.listRoomCamActInfo)
        {
            for(const auto& it : roomInfo.mapCameraAction)
            {
                for(const auto act : it.second)
                {
                    /* 读取Redis数据 */
                    std::string strKey = std::to_string(it.first) + ":" + act;
                    std::string strRetValue;
                    if(!m_fromRedis->getRedisString(strKey, strRetValue))
                    {
                        SPDLOG_LOGGER_ERROR(m_logger, "读取Redis数据失败, Key:{}", strKey);
                        std::this_thread::sleep_for(std::chrono::milliseconds(10));
                        continue;
                    }
                    /* 解析数据，先设置基础数据 */
                    AlarmInfo newAlarmInfo;
                    newAlarmInfo.ActionID = act;
                    newAlarmInfo.appFunction = m_funcThreadInfo.appFunction;

                    parseRedisBaseData(strRetValue, newAlarmInfo);
                    parseRedisBBoxesData(strRetValue, newAlarmInfo);
                    /* 判断事件的时效性，超过多少秒不更新就可能是超脑挂了 */
                    if(isEventTimeVaild(newAlarmInfo.EventTime))
                    {
                        SPDLOG_LOGGER_WARN(m_logger, "Redis Key:{} 数据长时间没有更新，EventTime:{}",strKey, newAlarmInfo.EventTime);
                        std::this_thread::sleep_for(std::chrono::milliseconds(100));
                        continue;
                    }

                    /* -------------------------------------------------------------------------------
                    * 判断有无报警记录，新的报警就先创建一个报警信息，写入报警列表，超过报警的最小误报时间后，
                    * 再写入到EQM的tAlarmInfo表中，正在报警的记录就判断和更新，结束报警就更新tAlarmInfo的
                    * 报警数据的结束时间，并清空pAlarmInfo 
                    * ------------------------------------------------------------------------------- */

                    /* 找出数组中与当前报警ID相同的的报警信息 */
                    auto pAlarmInfo = m_listAlarm.findAlarmInfo(newAlarmInfo);
                    /* 没有找到报警记录，就新建一个 */
                    if(pAlarmInfo == nullptr)
                    {
                        /* 新记录有报警，新建报警记录 */
                        if(newAlarmInfo.Is_Alarm)
                        {
                            /* 图片不能是空，如果是空的，就不写入数据库 */
                            if(!newAlarmInfo.ImageInfo.empty())
                            {
                                /* 违禁品检测，开始时间是事件时间 */
                                newAlarmInfo.StartTime = newAlarmInfo.EventTime;
                                newAlarmInfo.EndTime = "";
                                /* 保存新的报警记录 */
                                newAlarmInfo.Is_InsertEQM = false;
                                m_listAlarm.addAlarmInfo(newAlarmInfo);
                            }else 
                            {
                                SPDLOG_LOGGER_WARN(m_logger, "频道:{}, 房间:{}, 摄像机:{}, 算法:{}, 有报警区域, 但是没有图片信息", m_funcThreadInfo.ChannelID, roomInfo.RoomID, it.first, act);
                            }
                        }
                    } 
                    /* 已有报警记录 */
                    else 
                    {
                        /* 更新图片信息 */
                        if(!newAlarmInfo.ImageInfo.empty())
                        {
                            pAlarmInfo->ImageInfo = newAlarmInfo.ImageInfo;
                        }
                        /* 判断是否还在报警中 */
                        if(newAlarmInfo.Is_Alarm)
                        {
                            /* 正在报警中，检查是否已经写入到数据库中 */
                            if(pAlarmInfo->Is_InsertEQM)
                            {
                                /* 已经写入到数据库中，不做处理 */
                            }else 
                            {
                                /* 判断报警时长间隔是否足够 */
                                if(!isAlarmTimeVaild(*pAlarmInfo))
                                {
                                    /* 不够报警时间，直接进行下一个循环 */
                                    continue;
                                }

                                /* 写入到数据库 */
                                pAlarmInfo->Is_InsertEQM = false;
                                if(m_fromWebAPI->insertAlarmInfo(*pAlarmInfo))
                                {
                                    pAlarmInfo->Is_InsertEQM = true;
                                }else {
                                    SPDLOG_LOGGER_ERROR(m_logger, "写入tAlarmInfo报警数据失败, 频率:{}, 房间:{}, 算法:{} ", m_funcThreadInfo.ChannelID, roomInfo.RoomID, act);
                                }
                            }
                            
                        } else 
                        {
                            /* 报警结束，判断时长，如果小于设置的最小间隔，可能是误报警
                            * 更新数据库结束时间，结束时间是此时电脑时间 */
                            if(isAlarmTimeVaild(*pAlarmInfo))
                            {
                                pAlarmInfo->EndTime = chronoToStrTime(std::chrono::system_clock::now());
                                /* 判断是否已经写入到数据库中 */
                                if(pAlarmInfo->Is_InsertEQM)
                                {
                                    /* 已经写入到数据库中，更新结束时间 */
                                    m_fromWebAPI->updateAlarmEndTime(*pAlarmInfo);
                                }else {
                                    /* 没有写入到数据库中，写入到数据库中 */
                                    m_fromWebAPI->insertAlarmInfo(*pAlarmInfo);
                                }
                                SPDLOG_LOGGER_INFO(m_logger, "频率:{}, 房间:{}, 摄像机:{}, 算法:{}, 报警结束", m_funcThreadInfo.ChannelID, roomInfo.RoomID, it.first, act);
                            }

                            /* 删除这个报警信息 */
                            m_listAlarm.deleteAlarmInfo(*pAlarmInfo);
                        }
                    }
                }
            }
        }
        
    }
}




/* 判断报警时长是否符合不同应用的最小间隔 */
bool FuncOrdinary::isAlarmTimeVaild(const AlarmInfo& info)
{
    /* 违禁品物品 */
    if(info.appFunction == AppFunction::APP_Contraband)
    {
        if(timeDiffWithNow(info.EventTime) < GVariable.AppContraband_Time)
        {
            return false;
        }
    }
    /* 玩手机识别 */
    else if(info.appFunction == AppFunction::APP_PlayPhone)
    {
        if(timeDiffWithNow(info.EventTime) < GVariable.AppPlayPhone)
        {
            return false;
        }
    }
    /* 老鼠识别 */
    else if(info.appFunction == AppFunction::APP_Mouse)
    {
        if(timeDiffWithNow(info.EventTime) < GVariable.AppMouse)
        {
            return false;
        }
    }
    /* 未戴口罩识别 */
    else if(info.appFunction == AppFunction::APP_NoMask)
    {
        if(timeDiffWithNow(info.EventTime) < GVariable.AppMask)
        {
            return false;
        }
    }
    /* 疲劳检测 */
    else if(info.appFunction == AppFunction::APP_Fatigue)
    {
        if(timeDiffWithNow(info.EventTime) < GVariable.AppTired_Time)
        {
            return false;
        }
    }
    /* 摔倒识别 */
    else if(info.appFunction == AppFunction::APP_AllDown)
    {
        return true;
    }
    
    return true;
}