V0.1.1

1、添加了http的类，通讯正常
2、添加了redis类，可以获取到值

SecurePlayAuxServer/CMakeLists.txt

@@ -49,6 +49,11 @@ target_link_libraries(${execName1} PRIVATE
     spdlog::spdlog
     CURL::libcurl
     ${SM_LIBRARY}
+    hiredis::hiredis
 )
 
-
+#连接stdc++fs库，如果编译器版本低于GCC9.0，则需要连接这个库
+#GCC9.0以上包含进了标准库
+if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 9.0)
+    target_link_libraries(${execName1} PRIVATE stdc++fs)
+endif()

SecurePlayAuxServer/SPAServer.cpp

@@ -9,9 +9,22 @@
 
 SPAServer::SPAServer()
 {
-    // std::filesystem::path full_path = std::filesystem::current_path();
-    // SPDLOG_INFO("current_path:{}", full_path.string());
+    m_logger = spdlog::get("SPAServer");
+    if(m_logger == nullptr)
+    {
+        SPDLOG_ERROR("APAServer logger is nullptr");
+        return;
+    }
+
     m_fromSuperBrain.getToken();
+    // m_fromSuperBrain.getTaskTypeList();
+    m_fromRedis.setRedisIPAndPort("172.16.36.80", 32222);
+    m_fromRedis.setRedisPassword("Ff1z@TOFr^iwd%Ra");
+    m_fromRedis.connectRedis();
+    std::string value;
+    m_fromRedis.getRedisString("113:P100104000", value);
+    SPDLOG_LOGGER_INFO(m_logger, "{}", value);
+    m_fromRedis.disConnectRedis();
 }
 
 SPAServer::~SPAServer()

SecurePlayAuxServer/SPAServer.h

@@ -1,9 +1,14 @@
 #ifndef SPASERVER_H
 #define SPASERVER_H
 
-#include <iostream>
 #include "FromSuperBrain.h"
+#include "FromRedis.h"
 
+
+/**
+ * 安播辅助提示系统服务类
+ * 
+ */
 class SPAServer
 {
 public:
@@ -11,8 +16,10 @@ public:
     ~SPAServer();
 
 private:
-    FromSuperBrain m_fromSuperBrain;
+    std::shared_ptr<spdlog::logger> m_logger = nullptr;
 
+    FromSuperBrain m_fromSuperBrain;
+    FromRedis m_fromRedis;
 };
 
 #endif /* SPASERVER_H */

SecurePlayAuxServer/common/LHLog/LHLogInit.cpp

@@ -5,12 +5,16 @@
 #include "LHLog_file_sink.h"
 
 
-#include <QString>
-#include <QApplication>
+#include <string>
+#include <filesystem>
+
 
 /* 初始化spdlog，输入的是模组名称，可以为空
  * lhQLog是一个全局函数，在库LHQLog中定义
+ * 这里获取可执行文件文件夹的路径，使用的是C++17新引入的特性
+ * GCC9会在标准库中，GCC8.3需要手动链接库stdc++fs才可以使用
  */
+
 void initLog(QString ModuleName, CLHQLogApi& lhQLog)
 {
 
@@ -20,16 +24,18 @@ void initLog(QString ModuleName, CLHQLogApi& lhQLog)
         /* 创建一个文件sink，每天一个，00:00创建新的 */
         // auto sink_file = std::make_shared<spdlog::sinks::daily_file_sink_mt>("FlowChartLog/log.txt",0,0);
         /* 自定义的sink */
+        std::filesystem::path execPath = std::filesystem::current_path();
     #if defined(Q_OS_WIN32)
         #if C_DEBUG
-            QString libName = QApplication::applicationDirPath() + "/LHQLogd.dll";
+            std::string libName = execPath.string() + "/LHQLogd.dll";
         #elif C_RELEASE
-            QString libName = QApplication::applicationDirPath() + "/LHQLog.dll";
+            std::string libName = execPath.string() + "/LHQLog.dll";
         #endif
     #elif defined(Q_OS_LINUX)
-        QString libName = QApplication::applicationDirPath() + "/libLHQLog.so";
+        std::string libName = execPath.string() + "/libLHQLog.so";
     #endif
-        auto sink_custom = std::make_shared<spdlog::sinks::LHLog_file_sink_mt>(&lhQLog, libName, ModuleName);
+        /* 写入文件的sink */
+        auto sink_custom = std::make_shared<spdlog::sinks::LHLog_file_sink_mt>(&lhQLog, QString(libName.c_str()), ModuleName);
         /* 给默认记录器用的sink */
         auto sink_default = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
  
@@ -58,13 +64,19 @@ void initLog(QString ModuleName, CLHQLogApi& lhQLog)
         auto logger_main = std::make_shared<spdlog::logger>("main",begin(sinks),end(sinks));
         /* 创建一个WebAPI logger */
         auto logger_WebAPI = std::make_shared<spdlog::logger>("WebAPI",begin(sinks),end(sinks));
-        /* 创建一个发射机通用 Logger */
-        auto logger_SuperBrain = std::make_shared<spdlog::logger>("SuperBrain",begin(sinks),end(sinks));
+        /* 创建一个FromSuperBrain Logger */
+        auto logger_FromSuperBrain = std::make_shared<spdlog::logger>("FromSuperBrain",begin(sinks),end(sinks));
+        /* 创建一个SPAServer logger */
+        auto logger_SPAServer = std::make_shared<spdlog::logger>("SPAServer",begin(sinks),end(sinks));
+        /* 创建一个FromRedis logger */
+        auto logger_FromRedis = std::make_shared<spdlog::logger>("FromRedis",begin(sinks),end(sinks));
 
         /* 注册到注册表 */
         spdlog::register_logger(logger_main);
         spdlog::register_logger(logger_WebAPI);
-        spdlog::register_logger(logger_SuperBrain);
+        spdlog::register_logger(logger_FromSuperBrain);
+        spdlog::register_logger(logger_SPAServer);
+        spdlog::register_logger(logger_FromRedis);
 
         /* 设置spdlog输出级别，默认的估计不输出debug这个级别
          * 这是默认的设置，可以在外面单数设置输出方式

SecurePlayAuxServer/communication/FromRedis.cpp

@@ -0,0 +1,130 @@
+#include "FromRedis.h"
+#include "fmtlog.h"
+
+
+FromRedis::FromRedis()
+{
+
+}
+
+
+FromRedis::~FromRedis()
+{
+
+}
+
+/* 设置IP和端口 */
+void FromRedis::setRedisIPAndPort(const std::string& ip, int port)
+{
+    m_redisIP = ip;
+    m_redisPort = port;
+}
+
+/* 设置密码 */
+void FromRedis::setRedisPassword(const std::string& password)
+{
+    m_redisPassword = password;
+}
+
+/* 连接Redis */
+bool FromRedis::connectRedis()
+{
+    if(m_redisContext != nullptr)
+    {
+        redisFree(m_redisContext);
+        m_redisContext = nullptr;
+    }
+    if(m_redisIP.empty())
+    {
+        FMTLOG_ERROR( "Redis IP is empty");
+        return false;
+    }
+    /* 连接Redis */
+    m_redisContext = redisConnect(m_redisIP.c_str(), m_redisPort);
+    if( (m_redisContext == nullptr) || ( m_redisContext->err != 0) )
+    {
+        FMTLOG_ERROR( "Connect redis failed:{}", m_redisContext->errstr);
+        return false;
+    }
+    FMTLOG_INFO("Connect redis success");
+    /* 登录认证 */
+    if(!m_redisPassword.empty())
+    {
+        if(!authRedis(m_redisPassword))
+        {
+            FMTLOG_ERROR( "Auth redis failed");
+            return false;
+        }
+        // FMTLOG_INFO( "Auth redis success");
+    }
+    return true;
+}
+
+/* 断开Redis连接 */
+void FromRedis::disConnectRedis()
+{
+    if(m_redisContext != nullptr)
+    {
+        redisFree(m_redisContext);
+        m_redisContext = nullptr;
+    }
+}
+
+
+
+/* 获取redis中的String数据 */
+bool FromRedis::getRedisString(const std::string& key, std::string& value)
+{
+    if(m_redisContext == nullptr)
+    {
+        FMTLOG_ERROR( "Redis no connect");
+        return false;
+    }
+    /* 获取数据 */
+    auto reply = (redisReply*)redisCommand(m_redisContext, "GET %s", key.c_str());
+    // auto reply = (redisReply*)redisCommand(m_redisContext, "GET 113:P100104000");
+    if(reply == nullptr)
+    {
+        FMTLOG_ERROR( "Get redis string data failed");
+        return false;
+    }
+    if(reply->type != REDIS_REPLY_STRING)
+    {
+        FMTLOG_ERROR( "Get redis data failed, type is not string, type: {}, error str: {}", reply->type, reply->str);
+        freeReplyObject(reply);
+        return false;
+    }
+    value = reply->str;
+    freeReplyObject(reply);
+    return true;
+}
+
+
+/* 登录认证Redis，这个需要在连接成功后调用 */
+bool FromRedis::authRedis(const std::string& password)
+{
+    if(m_redisContext == nullptr)
+    {
+        FMTLOG_ERROR( "Redis no connect");
+        return false;
+    }
+    auto reply = (redisReply*)redisCommand(m_redisContext, "AUTH %s", password.c_str());
+    if(reply == nullptr)
+    {
+        FMTLOG_ERROR( "Redis Auth failed");
+        return false;
+    }
+    /* 判断返回值 */
+    if( reply->type == REDIS_REPLY_STATUS && strcasecmp(reply->str, "OK") == 0)
+    {
+        FMTLOG_INFO( "Redis Auth success");
+        freeReplyObject(reply);
+        return true;
+    }
+    else
+    {
+        FMTLOG_ERROR( "Redis Auth failed:{}", reply->str);
+        freeReplyObject(reply);
+        return false;
+    }
+}

SecurePlayAuxServer/communication/FromRedis.h

@@ -0,0 +1,37 @@
+#ifndef FROMREDIS_H
+#define FROMREDIS_H
+
+#include <string>
+#include "hiredis/hiredis.h"
+
+
+class FromRedis
+{
+public:
+    FromRedis();
+    ~FromRedis();
+    /* 设置IP和端口 */
+    void setRedisIPAndPort(const std::string& ip, int port = 6379);
+    /* 设置密码 */
+    void setRedisPassword(const std::string& password);
+    /* 连接Redis */
+    bool connectRedis();
+    /* 断开Redis连接 */
+    void disConnectRedis();
+    /* 获取redis中的数据 */
+    bool getRedisString(const std::string& key, std::string& value);
+
+private:
+    /* 登录认证Redis，这个需要在连接成功后调用 */
+    bool authRedis(const std::string& password);
+
+private:
+
+    redisContext* m_redisContext = nullptr;
+
+    std::string m_redisIP;          /* Redis IP地址 */
+    int m_redisPort;                /* Redis默认端口 */
+    std::string m_redisPassword;    /* Redis密码 */
+};
+
+#endif /* FROMREDIS_H */

SecurePlayAuxServer/communication/FromSuperBrain.cpp

@@ -1,11 +1,19 @@
 #include "FromSuperBrain.h"
 
-#include "spdlog/spdlog.h"
+
 #include "CurlHttp.h"
+#include "fmt/format.h"
 
 
 FromSuperBrain::FromSuperBrain()
 {
+    m_logger = spdlog::get("FromSuperBrain");
+    if(m_logger == nullptr)
+    {
+        SPDLOG_ERROR("FromSuperBrain logger is nullptr");
+        return;
+    }
+
     m_url = "http://172.16.36.80:30000/vos";
 }
 
@@ -20,11 +28,62 @@ bool FromSuperBrain::getToken()
     std::string response;
     std::string httpBody = R"({"appSecret":"8zR9ug4WbKCtEgaQ08myRm5HqKIMwP83Ra24t921tO/mU0cTIFdm/t0C9Jxrd53x","appKey":"rili4l26"})";
     std::vector<std::string> vecHeader;
-    vecHeader.push_back("User-Agent: Apifox/1.0.0 (https://apifox.com)");
     vecHeader.push_back("Content-Type: application/json");
-    
-    CurlHttp::PostWithBody(m_url, vecHeader, httpBody, response);
-    SPDLOG_INFO("response:{}", response);
+    std::string url = m_url + m_tokenPath;
+    if(!CurlHttp::Post(url, vecHeader, httpBody, response))
+    {
+        SPDLOG_LOGGER_ERROR(m_logger, "Get Token failed");
+        return false;
+    }
+    SPDLOG_LOGGER_DEBUG(m_logger, "response:{}", response);
+    m_token = response;
+
+    return true;
+}
+
+
+/* 获取算法列表 */
+bool FromSuperBrain::getTaskTypeList()
+{
+    if(m_token.empty())
+    {
+        SPDLOG_LOGGER_ERROR(m_logger, "Token is empty");
+        return false;
+    }
+    std::string response;
+    std::vector<std::string> vecHeader;
+    vecHeader.push_back(fmt::format("accessToken: {}", m_token));
+    std::string url = m_url + m_taskTypeListPath;
+    if(!CurlHttp::Get(url, vecHeader, response))
+    {
+        SPDLOG_LOGGER_ERROR(m_logger, "Get TaskTypeList failed");
+        return false;
+    }
+    SPDLOG_LOGGER_DEBUG(m_logger, "response:{}", response);
+    m_taskTypeList = response;
 
     return true;
-}
+}
+
+/* 获取设备列表信息 */
+bool FromSuperBrain::getDeviceList()
+{
+    if(m_token.empty())
+    {
+        SPDLOG_LOGGER_ERROR(m_logger, "Token is empty");
+        return false;
+    }
+    std::string response;
+    std::vector<std::string> vecHeader;
+    vecHeader.push_back(fmt::format("accessToken: {}", m_token));
+    std::string url = m_url + m_deviceListPath;
+    if(!CurlHttp::Get(url, vecHeader, response))
+    {
+        SPDLOG_LOGGER_ERROR(m_logger, "Get TaskTypeList failed");
+        return false;
+    }
+    SPDLOG_LOGGER_DEBUG(m_logger, "response:{}", response);
+
+    return true;
+}
+

SecurePlayAuxServer/communication/FromSuperBrain.h

@@ -3,6 +3,7 @@
 
 #include <string>
 
+#include "spdlog/spdlog.h"
 
 class FromSuperBrain
 {
@@ -11,16 +12,23 @@ public:
     ~FromSuperBrain();
     /* 获取token */
     bool getToken();
+    /* 获取算法列表 */
+    bool getTaskTypeList();
+    /* 获取设备列表信息 */
+    bool getDeviceList();
 
 private:
+    std::shared_ptr<spdlog::logger> m_logger = nullptr;
+
     std::string m_url;
     std::string m_username;
     std::string m_password;
 
-
-    std::string m_token;
-    const std::string m_tokenKey = "/external/broadcastToken";              /* 获取token数据 */
-    const std::string m_taskTypeListKey = "/external/getTaskTypeList";      /* 获取任务类型数据 */
+    std::string m_token;                            /* token */
+    std::string m_taskTypeList;                     /* 任务类型列表 */
+    const std::string m_tokenPath = "/external/broadcastToken";              /* 获取token数据 */
+    const std::string m_taskTypeListPath = "/external/getTaskTypeList";      /* 获取任务类型数据 */
+    const std::string m_deviceListPath = "/external/getBaseDeviceList";      /* 获取设备列表数据 */
 };
 
 

SecurePlayAuxServer/main.cpp

@@ -10,6 +10,7 @@
 
 int main(int argc, char* argv[])
 {
+    QCoreApplication app(argc, argv);
     /* 初始化日志库 */
     initLog("SecurePlayAuxServer", g_apiLhQLog);
     auto logger = spdlog::get("main");
@@ -22,6 +23,6 @@ int main(int argc, char* argv[])
 
     SPAServer server;
 
-    return 0;
+    return app.exec();
 }