Merge branch 'master' of ssh://115.28.86.8:29418/~admin/昆仑_1025

wangky

2024-11-01 1fea4c3b112aefc7076092b34eeec7de1a67a50c

Merge branch 'master' of ssh://115.28.86.8:29418/~admin/昆仑_1025

 Client/¼½ºÆêÆ/document/Éú²ú¼Æ»®¹ÜÀí_ÐèÇó·ÖÎö.docx

Binary files differ

 Client/¼½ºÆêÆ/log/ÈÕÖ¾_¼½ºÆêÆ_1031.doc

Binary files differ

 Client/Áõ×Óº½/log/ÈÕÖ¾_Áõ×Óº½_1101.doc

Binary files differ

 Client/½ª¿É¸ý/code/2024kunlun_project_permisson/2024kunlun_project_permisson.pro.user

@@ -1,6 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE QtCreatorProject>
<!-- Written by QtCreator 4.5.0, 2024-10-31T15:06:39. -->
<!-- Written by QtCreator 4.5.0, 2024-10-31T16:02:45. -->
<qtcreator>
 <data>
  <variable>EnvironmentId</variable>

 Client/½ª¿É¸ý/code/2024kunlun_project_permisson/PmsClientSocket.cpp

@@ -68,10 +68,9 @@
          res = (QueryPmsResponse *)buf.data();
          if(res->success){
              vector<PmsQueryResult> vecs;

              for(int i =0;i<100;i++){
                  PmsRes structRes =res->pmsList[i];
                  if(*(int *)&structRes){
              int pmsLen = res->head.len-sizeof(QueryPmsResponse);
              for(int i =0;i<pmsLen;i+=sizeof(PmsRes)){
                  PmsRes structRes = *(PmsRes*)(res + sizeof(QueryPmsResponse) + i*sizeof(PmsRes));
                      PmsQueryResult res;
                      res.setName(string(structRes.name));
                      res.setUserNo(string(structRes.userNo));
@@ -83,12 +82,8 @@
                      res.setDevManage(structRes.devManage);
                      res.setProductPlan(structRes.productPlan);
                      res.setQueryHistory(structRes.queryHistory);

                      res.setPermissonType(string(structRes.permissonType));

                      vecs.push_back(res);

                  }else break;
              }
              if(!vecs.empty()){
                  emit notifyDateChange(vecs);

 Client/½ª¿É¸ý/code/2024kunlun_project_permisson/PmsClientSocket.h

@@ -72,11 +72,12 @@
typedef struct UserAboutPmsResponse{
    Head head;
    int success; // 1为成功 ,0为失败
    PmsRes  pmsList[100];
    //PmsRes pmsList[100];
    char pmsList[0];
    UserAboutPmsResponse(){
        head.type=QUERY_PMS_RES;
        memset(pmsList,0,sizeof(PmsRes));
        head.len = sizeof(UserAboutPmsResponse);
//        memset(pmsList,0,sizeof(PmsRes));
//        head.len = sizeof(UserAboutPmsResponse);
    }
} QueryPmsResponse;


 Client/½ª¿É¸ý/code/2024kunlun_project_permisson/main.cpp

@@ -6,6 +6,8 @@
    QApplication a(argc, argv);
    PermissonWindow w;
    w.show();
    QString dlgTitle = "更新结果";
    QString strInfo = "权限信息更新成功";

    return a.exec();
}

 Client/½ª¿É¸ý/code/2024kunlun_project_permisson/permissondialog.cpp

@@ -66,6 +66,8 @@
    btnList[3][res.getDevManage()]->setChecked(true);
    btnList[4][res.getProductPlan()]->setChecked(true);

    curRes = res;

}


@@ -80,7 +82,7 @@
    param.setDevManage(findBoxCheck(btnList[3]));
    param.setProductPlan(findBoxCheck(btnList[4]));


    param.setRoleId(curRes.getRoleId());
    client->updatePmsByParam(param);

}

 Client/½ª¿É¸ý/code/2024kunlun_project_permisson/permissondialog.h

@@ -28,6 +28,8 @@

    int findBoxCheck(map<int,QRadioButton *> map);

    PmsQueryResult curRes;

private slots:
    void recvUserNo(PmsQueryResult pms);
    void on_buttonBox_accepted();

 Client/½ª¿É¸ý/code/2024kunlun_project_permisson/permissonwindow.cpp

@@ -78,9 +78,11 @@




    connect(ac1,&QAction::triggered,[=]{
         int row = ui->tableView->currentIndex().row();
         qDebug() << globalPms[row].getDevManage();
         qDebug() << "更新当前员工信息"
                  <<  QString::fromStdString( globalPms[row].getUserNo());
         // å‘送员工编号信息
         emit sendUserNo(globalPms[row]);

@@ -99,7 +101,9 @@
    if(watch == ui->tableView->viewport() || watch == ui->tableView->verticalHeader()->viewport()

            || watch == ui->tableView->horizontalHeader()->viewport()){
        if(event->type()==QEvent::MouseButtonPress && ((QMouseEvent *)event)->button()==Qt::RightButton){
        if(event->type()==QEvent::MouseButtonPress
                && ((QMouseEvent *)event)->button()==Qt::RightButton
                && m_model->rowCount() > 0){
            m->exec(QCursor::pos());
        }

@@ -132,12 +136,14 @@

void PermissonWindow::listenItemChange(QStandardItem *item)
{
    qDebug() << "数据开始更新";
    QString localText = item->text();
    PmsPlusParma pm;
    pm.setPermissonType(localText.toStdString());
    pm.setRoleId(roleMap[localText.toStdString()]);
    clientSocket->updatePmsByParam(pm);
    if(roleMap.count(localText.toStdString())){
        qDebug() << "发起职位更新请求";
        PmsPlusParma pm;
        pm.setPermissonType(localText.toStdString());
        pm.setRoleId(roleMap[localText.toStdString()]);
        clientSocket->updatePmsByParam(pm);
    }
}

void PermissonWindow::renderItemData(vector<PmsQueryResult> res)

 Client/½ª¿É¸ý/code/2024kunlun_project_permisson/permissonwindow.h

@@ -10,6 +10,8 @@
#include "syncdatatodb.h"
#include "PmsClientSocket.h"

#include <QMessageBox>



using namespace std;

 Client/½ª¿É¸ý/log/½ª¿É¸ý_1030.doc

Binary files differ

 Client/½ª¿É¸ý/log/½ª¿É¸ý_1031.doc

Binary files differ

 Client/½ª¿É¸ý/log/½ª¿É¸ý_1101.doc

Binary files differ

 Client/ËÎ껕i/log/ÈÕÖ¾_ËÎ껕i_1101.doc

Binary files differ

 Client/ÀîÏüÔö/document/ÀúÊ·²éѯ·ÖÎöÄ£¿éÐèÇó·ÖÎö.docx

Binary files differ

 Client/ÀîÏüÔö/log/ÀúÊ·²éѯ_ÀîÏüÔö_1030.doc

Binary files differ

 Client/ÀîÏüÔö/log/ÀúÊ·²éѯ_ÀîÏüÔö_1031.doc

Binary files differ

 Client/ÍõöÎöÎ/log/ÈÕÖ¾_ÍõöÎöÎ_1031.doc

Binary files differ

 Client/ÍõöÎöÎ/log/À¥ÂØ_1101ÏîÄ¿ÈÕ±¨.doc

Binary files differ

 Client/ÉêŸ@/log/ÈÕÖ¾_ÉêŸ@_1031.doc

Binary files differ

 Client/ÉêŸ@/log/ÈÕÖ¾_ÉêŸ@_1101.doc

Binary files differ

 Client/Ö£¿­ÎÄ/document/À¥ÂØ1031_ÏîÄ¿ÈÕ±¨.doc

Binary files differ

 Client/Ö£¿­ÎÄ/log/Ö£¿­ÎÄ1101.doc

Binary files differ

 Client/ÀèºëÁØ/code/Devices_Management_Struct.h

New file
@@ -0,0 +1,121 @@
#pragma once
enum TypeInfo
{
    AD_Req,//添加设备请求
    AD_Res,//添加设备响应
    CD_Req,//关闭设备请求
    CD_Res,//关闭设备请求
    PD_Req,//暂停设备请求
    PD_Res,//暂停设备请求
};
struct Head
{
    int type;
    int len;
};

//添加设备
struct ADReq
{
    Head head;
    char Device_Name[32];
    ADReq() {
        head.type = AD_Req;
        head.len = sizeof(AD_Req);
    }

};
struct ADPermission
{
    char Device_Name[32];
    char Device_Status[32];
    char Manufacturer[100];
    char Devices_Type[32];
    double Longitude;
    double Latitude;
};
struct ADRes
{
    Head head;
    char Device_Name[32];
    char Device_Status[32];
    char Start_Time[32];
    char Work_Time[32];
    char Manufacturer[100];
    char Devices_Type[32];
    double Longitude;
    double Latitude;
    ADPermission per;
    ADRes() {
        head.type = AD_Res;
        head.len = sizeof(ADRes);
    }

};

//关闭设备
struct CDReq
{
    Head head;
    char Device_Name[32];
    CDReq() {
        head.type = CD_Req;
        head.len = sizeof(CDReq);
    }
};
struct CDPermission
{
    char Device_Name[32];
    char Device_Status[32];
    char Start_Time[32];
    char Work_Time[32];
    char Manufacturer[100];
    char Devices_Type[32];
    double Longitude;
    double Latitude;
};
struct CDRes
{
    Head head;
    char Device_Status[32];
    int status;
    CDPermission per;
    CDRes() {
        head.type = CD_Res;
        head.len = sizeof(CDRes);
    }
};

//暂停设备
struct PDReq
{
    Head head;
    char Device_Name[32];
    PDReq() {
        head.type = PD_Req;
        head.len = sizeof(PDReq);
    }
};
struct PDPermission
{
    char Device_Name[32];
    char Device_Status[32];
    char Start_Time[32];
    char Work_Time[32];
    char Manufacturer[100];
    char Devices_Type[32];
    double Longitude;
    double Latitude;
};
struct PDRes
{
    Head head;
    char Device_Status[32];
    char Work_Time[32];
    int status;
    PDPermission per;
    PDRes() {
        head.type = PD_Res;
        head.len = sizeof(PDRes);
    }
};

 Client/ÀèºëÁØ/code/device_management.zip

Binary files differ

 Client/ÀèºëÁØ/log/É豸¹ÜÀí_ÀèºëÁØ_1031.doc

Binary files differ

 Client/ÀèºëÁØ/log/É豸¹ÜÀí_ÀèºëÁØ_1101.doc

Binary files differ

 Server/Àîתת/log/ÅäÖùÜÀí_1101.doc

Binary files differ

 Server/ºú¼ÒÃ÷/log/ÈÕÖ¾_ºú¼ÒÃ÷_1031.doc

Binary files differ

 Server/³Â³þµ¤/log/ÈÕÖ¾_³Â³þµ¤_1031.doc

Binary files differ

 Server/ÂíÀöƼ/code/log/log.cpp

@@ -1,21 +1,14 @@
#include <string.h>
#include <time.h>
#include <chrono>
#include <ctime>
#include <stdarg.h>
#include "log.h"
#include <sstream>
#include <fstream>
#include <iostream>
#include <chrono>

using namespace std;

// æž„造函数
Log::Log() {
    m_count = 0; // åˆå§‹åŒ–日志行数
    m_is_async = false; // åˆå§‹åŒ–为同步
}
Log::Log() : m_count(0), m_is_async(false) {}

// æžæž„函数
Log::~Log() {
@@ -24,31 +17,82 @@
    }
}

// æŽ¥æ”¶åŽŸå§‹æ—¥å¿—并解析
void Log::receiveLog(const std::string &raw_log) {
    ParsedLog parsed_log = parseLog(raw_log);
    write_log(levelToInt(parsed_log.level), "%s [%s] %s", parsed_log.timestamp.c_str(), parsed_log.device_id.c_str(), parsed_log.content.c_str());
//异步写入
void Log::async_write_log() {
    while (m_is_async) {
        char* log;
        if (m_log_queue->pop(log)) {
            ParsedLog parsed_log = parseLog(log); 
            write_log(INFO, "%s", log); // å…ˆå†™å…¥æ—¥å¿—文件
            writeLogToDatabase(parsed_log); // å†å†™å…¥æ•°æ®åº“
            delete[] log; // é‡Šæ”¾å†…å­˜
        }
    }
}

bool Log::check_log_size() {
    if (m_fp.tellp() >= max_size) {
        rotate_logs(); // å¦‚果日志文件大小超过最大值，轮换日志
        return true;
    }
    return false;
}


// æŽ¥æ”¶åŽŸå§‹æ—¥å¿—并解析
void Log::receiveLog(const char* raw_log) {
    ParsedLog parsed_log = parseLog(raw_log);
    write_log(levelToInt(parsed_log.level), "%s [%s] %s", 
               parsed_log.timestamp, 
               parsed_log.device_id, 
               parsed_log.content);
}

//写入数据库
void Log::writeLogToDatabase(const ParsedLog& log) {
    const char* sql = "INSERT INTO parsed_logs (timestamp, device_id, level, content, source, user_id) VALUES (?, ?, ?, ?, ?, ?)";
    sqlite3_stmt* stmt;

    if (sqlite3_prepare_v2(db, sql, -1, &stmt, NULL) != SQLITE_OK) {
        cerr << "Error: Failed to prepare statement: " << sqlite3_errmsg(db) << endl;
        return;
    }

    sqlite3_bind_text(stmt, 1, log.timestamp, -1, SQLITE_STATIC);
    sqlite3_bind_text(stmt, 2, log.device_id, -1, SQLITE_STATIC);
    sqlite3_bind_text(stmt, 3, log.level, -1, SQLITE_STATIC);
    sqlite3_bind_text(stmt, 4, log.content, -1, SQLITE_STATIC);
    sqlite3_bind_text(stmt, 5, log.source, -1, SQLITE_STATIC);
    sqlite3_bind_text(stmt, 6, log.user_id, -1, SQLITE_STATIC);

    if (sqlite3_step(stmt) != SQLITE_DONE) {
        cerr << "Error: Failed to execute statement: " << sqlite3_errmsg(db) << endl;
    }

    sqlite3_finalize(stmt); // æ¸…理准备语句
}


// è§£æžæ—¥å¿—字符串
ParsedLog Log::parseLog(const std::string &log) {
ParsedLog Log::parseLog(const char* log) {
    ParsedLog parsed_log;
    std::istringstream iss(log);
    std::string level;
    char level[16];

    // è¯»å–时间戳、设备ID和日志级别
    iss >> parsed_log.timestamp >> parsed_log.device_id >> level;
    std::getline(iss, parsed_log.content);
    parsed_log.level = level; // è®¾ç½®è§£æžåŽçš„级别
    sscanf(log, "%s %s %s %[^\n]", parsed_log.timestamp, parsed_log.device_id, level, parsed_log.content);
    // è®¾ç½®è§£æžåŽçš„级别
    for (int i = 0; i < 16; ++i) {
        parsed_log.level[i] = level[i];
    }

    return parsed_log;
}

// åˆå§‹åŒ–日志系统
bool Log::init(const std::string &file_name, int close_log, int log_buf_size, int split_lines, int max_queue_size) {
bool Log::init(const char* file_name, int close_log, int log_buf_size, int split_lines, int max_queue_size) {
    if (max_queue_size >= 1) {
        m_is_async = true; // å¯ç”¨å¼‚步写入
        m_log_queue = new block_queue<string>(max_queue_size); // åˆ›å»ºé˜»å¡žé˜Ÿåˆ—
        m_log_queue = new block_queue<char*>(max_queue_size); // åˆ›å»ºé˜»å¡žé˜Ÿåˆ—
        std::thread(&Log::flush_log_thread, this).detach(); // åˆ›å»ºåˆ·æ–°æ—¥å¿—线程
    }

@@ -60,43 +104,76 @@

    time_t t = time(NULL);
    struct tm *sys_tm = localtime(&t);
    std::string log_full_name;
    char log_full_name[256];

    // æ ¹æ®æ–‡ä»¶è·¯å¾„和当前日期生成完整日志文件名
    if (file_name.find('/') == std::string::npos) {
        log_full_name = to_string(sys_tm->tm_year + 1900) + "_" + to_string(sys_tm->tm_mon + 1) + "_" + to_string(sys_tm->tm_mday) + "_" + file_name;
    if (strchr(file_name, '/') == nullptr) {
        sprintf(log_full_name, "%d_%d_%d_%s",
                sys_tm->tm_year + 1900, sys_tm->tm_mon + 1, sys_tm->tm_mday, file_name);
    } else {
        std::string log_name = file_name.substr(file_name.find_last_of('/') + 1);
        std::string dir_name = file_name.substr(0, file_name.find_last_of('/') + 1);

        log_full_name = dir_name + to_string(sys_tm->tm_year + 1900) + "_" + to_string(sys_tm->tm_mon + 1) + "_" + to_string(sys_tm->tm_mday) + "_" + log_name;
        char log_name[128];
        char dir_name[128];
        char* last_slash = strrchr(file_name, '/');
        int dir_len = last_slash - file_name + 1;
        strncpy(dir_name, file_name, dir_len);
        dir_name[dir_len] = '\0';
        strcpy(log_name, last_slash + 1);
        
        sprintf(log_full_name, "%s%d_%d_%d_%s",
                dir_name, sys_tm->tm_year + 1900, sys_tm->tm_mon + 1, sys_tm->tm_mday, log_name);
    }

    m_today = sys_tm->tm_mday; // è®°å½•ä»Šå¤©çš„日期
    m_fp.open(log_full_name, std::ios::out | std::ios::app); // æ‰“开日志文件
    if (!m_fp.is_open()) {
        cerr << "Error: Could not open log file: " << log_full_name << endl;
        return false; // æ‰“开失败
    }

    return true; // åˆå§‹åŒ–成功
}

#include <chrono>
//查询日志草最
void Log::queryLogs(const char *device_id) {
    const char* sql = "SELECT * FROM parsed_logs WHERE device_id = ?";
    sqlite3_stmt* stmt;

    if (sqlite3_prepare_v2(db, sql, -1, &stmt, NULL) != SQLITE_OK) {
        cerr << "Error: Failed to prepare statement: " << sqlite3_errmsg(db) << endl;
        return;
    }

    sqlite3_bind_text(stmt, 1, device_id, -1, SQLITE_STATIC);
    
    while (sqlite3_step(stmt) == SQLITE_ROW) {
        cout << "Timestamp: " << sqlite3_column_text(stmt, 1) << ", "
             << "Device ID: " << sqlite3_column_text(stmt, 2) << ", "
             << "Level: " << sqlite3_column_text(stmt, 3) << ", "
             << "Content: " << sqlite3_column_text(stmt, 4) << ", "
             << "Source: " << sqlite3_column_text(stmt, 5) << ", "
             << "User ID: " << sqlite3_column_text(stmt, 6) << endl;
    }

    sqlite3_finalize(stmt); // æ¸…理准备语句
}



// å†™å…¥æ—¥å¿—
void Log::write_log(int level, const char *format, ...) {
    auto now = std::chrono::system_clock::now();
    auto now_time_t = std::chrono::system_clock::to_time_t(now);
    struct tm *sys_tm = localtime(&now_time_t);
    
    std::string s;
    char s[32];

    // æ ¹æ®æ—¥å¿—级别设置前缀
    switch (level) {
        case DEBUG: s = "[debug]: "; break;
        case INFO: s = "[info]: "; break;
        case WARN: s = "[warn]: "; break;
        case ERROR: s = "[error]: "; break;
        default: s = "[info]: "; break;
        case DEBUG: strcpy(s, "[debug]: "); break;
        case INFO: strcpy(s, "[info]: "); break;
        case WARN: strcpy(s, "[warn]: "); break;
        case ERROR: strcpy(s, "[error]: "); break;
        default: strcpy(s, "[info]: "); break;
    }

    m_mutex.lock(); // é”å®šäº’斥体
@@ -104,7 +181,7 @@

    // æ£€æŸ¥æ˜¯å¦éœ€è¦è½®æ¢æ—¥å¿—
    if (m_today != sys_tm->tm_mday || m_count % m_split_lines == 0) {
        // ... (日志轮换代码)
        rotate_logs(); // è°ƒç”¨æ—¥å¿—轮换函数
    }

    // å†™å…¥æ—¥å¿—内容
@@ -113,6 +190,7 @@
    vsnprintf(m_buf, m_log_buf_size, format, valist); // å†™å…¥æ—¥å¿—内容

    m_fp << s << m_buf << std::endl; // ä½¿ç”¨ofstream写入文件
    va_end(valist);

    m_mutex.unlock(); // è§£é”äº’斥体

@@ -133,18 +211,65 @@
void Log::flush_log_thread() {
    while (m_is_async) {
        // ä»Žé˜Ÿåˆ—中获取日志并写入
        string log;
        char* log;
        if (m_log_queue->pop(log)) {
            write_log(INFO, "%s", log.c_str());
            write_log(INFO, "%s", log);
        }
    }
}

//转换字符串
const char* Log::log_level_to_string(int level) {
    switch (level) {
        case DEBUG: return "[debug]: ";
        case INFO: return "[info]: ";
        case WARN: return "[warn]: ";
        case ERROR: return "[error]: ";
        default: return "[info]: "; // é»˜è®¤è¿”回INFO
    }
}

// æ—¥å¿—级别转换为整数
int Log::levelToInt(const std::string &level) {
    if (level == "[debug]:") return DEBUG;
    if (level == "[info]:") return INFO;
    if (level == "[warn]:") return WARN;
    if (level == "[error]:") return ERROR;
int Log::levelToInt(const char* level) {
    if (strcmp(level, "[debug]:") == 0) return DEBUG;
    if (strcmp(level, "[info]:") == 0) return INFO;
    if (strcmp(level, "[warn]:") == 0) return WARN;
    if (strcmp(level, "[error]:") == 0) return ERROR;
    return INFO; // é»˜è®¤è¿”回INFO
}

//打开关闭数据库
void Log::openDatabase(const char *db_name) {
    if (sqlite3_open(db_name, &db) != SQLITE_OK) {
        cerr << "打不开数据库！！错误： " << sqlite3_errmsg(db) << endl;
    }
}

void Log::closeDatabase() {
    if (db) {
        sqlite3_close(db);
    }
}

// æ—¥å¿—轮换函数
void Log::rotate_logs() {
    // å…³é—­å½“前文件
    m_fp.close();

    // ç”Ÿæˆæ–°æ–‡ä»¶å
    time_t t = time(NULL);
    struct tm *sys_tm = localtime(&t);
    char new_log_name[256];
    sprintf(new_log_name, "%d_%d_%d_log.txt",
            sys_tm->tm_year + 1900, sys_tm->tm_mon + 1, sys_tm->tm_mday);

    // æ‰“开新的日志文件
    m_fp.open(new_log_name, std::ios::out | std::ios::app);
    if (!m_fp.is_open()) {
        cerr << "Error: Could not open new log file: " << new_log_name << endl;
        return;
    }

    m_today = sys_tm->tm_mday; // æ›´æ–°ä»Šå¤©çš„日期
    m_count = 0; // é‡ç½®æ—¥å¿—计数
}

 Server/ÂíÀöƼ/code/log/log.h

@@ -3,12 +3,12 @@

#include <stdio.h>
#include <iostream>
#include <string>
#include <stdarg.h>
#include <thread> 
#include <thread>
#include "block_queue.h"
#include "locker.h" // ç¡®ä¿ locker.h è¢«åŒ…含
#include "locker.h"
#include <fstream>
#include <sqlite3.h> // æ·»åŠ  SQLite æ•°æ®åº“的头文件

using namespace std;

@@ -22,10 +22,12 @@

// å­˜å‚¨è§£æžæ—¥å¿—文件的结构体
struct ParsedLog {
    std::string timestamp; // æ—¶é—´æˆ³
    std::string device_id; // è®¾å¤‡ID
    std::string level;     // æ—¥å¿—级别
    std::string content;   // æ—¥å¿—内容
    char timestamp[64]; // æ—¶é—´æˆ³
    char device_id[64]; // è®¾å¤‡ID
    char level[16];     // æ—¥å¿—级别
    char content[256];  // æ—¥å¿—内容
    char source[64];    // æ¥æºæ¨¡å—
    char user_id[64];   // ç”¨æˆ·ID
};

class Log
@@ -42,17 +44,19 @@
    void flush_log_thread(); // ä¿®æ”¹ä¸ºéžé™æ€æˆå‘˜å‡½æ•°

    // åˆå§‹åŒ–日志系统，参数包括文件名、是否关闭日志、缓冲区大小、最大行数和最大队列大小
    bool Log::init(const char *file_name, int close_log, int log_buf_size, int split_lines, int max_queue_size);
    bool init(const char *file_name, int close_log, int log_buf_size, int split_lines, int max_queue_size);

    
    // å†™å…¥æ—¥å¿—
    void write_log(int level, const char *format, ...);
    
    // åˆ·æ–°æ—¥å¿—文件
    void flush(void);

    //接收原始的要公共类
    void receiveLog(const std::string& raw_log); // æŽ¥æ”¶åŽŸå§‹æ—¥å¿—
    // æŽ¥æ”¶åŽŸå§‹æ—¥å¿—
    void receiveLog(const char* raw_log);

    // å°†æ—¥å¿—写入数据库
    void writeLogToDatabase(const ParsedLog& log);

private:
    Log(); // æž„造函数
@@ -62,12 +66,12 @@
    bool check_log_size(); // æ£€æŸ¥æ—¥å¿—文件大小
    void rotate_logs(); // è½®æ¢æ—¥å¿—文件
    
    ParsedLog parseLog(const std::string& log); // è§£æžæ—¥å¿—
    bool init(const std::string &file_name, int close_log, int log_buf_size, int split_lines, int max_queue_size);
    void queryLogs(const std::string &device_id); // æŸ¥è¯¢æ—¥å¿—
    ParsedLog parseLog(const char* log); // è§£æžæ—¥å¿—
    bool init(const char *file_name, int close_log, int log_buf_size, int split_lines, int max_queue_size);
    void queryLogs(const char *device_id); // æŸ¥è¯¢æ—¥å¿—

    const char* log_level_to_string(int level); // å°†æ—¥å¿—级别转换为字符串
    int levelToInt(const std::string &level);
    int levelToInt(const char *level);

private:
    char dir_name[128]; // æ—¥å¿—文件目录
@@ -78,16 +82,18 @@
    int m_today;        // è®°å½•å½“前时间
    std::ofstream m_fp; // å°† FILE * m_fp æ›´æ”¹ä¸º std::ofstream m_fp
    char *m_buf;        // æ—¥å¿—缓冲区
    block_queue<string> *m_log_queue; // é˜»å¡žé˜Ÿåˆ—
    block_queue<char*> *m_log_queue; // é˜»å¡žé˜Ÿåˆ—
    bool m_is_async;                  // æ˜¯å¦å¼‚步标志位
    locker m_mutex;                   // äº’斥锁
    int m_close_log; // å…³é—­æ—¥å¿—的标志
    long max_size = 10 * 1024 * 1024; // 10MB
    //测试文件里面的
    int m_close_log; // ç¡®ä¿åœ¨è¿™é‡Œå®šä¹‰
    long max_size = 10 * 1024 * 1024; // å•ä¸ªæ—¥å¿—文件的大小 10MB

    // æ•°æ®åº“相关
    sqlite3 *db; // SQLite æ•°æ®åº“指针
    void openDatabase(const char *db_name); // æ‰“开数据库
    void closeDatabase(); // å…³é—­æ•°æ®åº“
};

// å®å®šä¹‰ç”¨äºŽä¸åŒçº§åˆ«çš„日志记录
#define LOG_DEBUG(format, ...) if(0 == m_close_log) {Log::get_instance()->write_log(DEBUG, format, ##__VA_ARGS__); Log::get_instance()->flush();}
#define LOG_INFO(format, ...) if(0 == m_close_log) {Log::get_instance()->write_log(INFO, format, ##__VA_ARGS__); Log::get_instance()->flush();}
#define LOG_WARN(format, ...) if(0 == m_close_log) {Log::get_instance()->write_log(WARN, format, ##__VA_ARGS__); Log::get_instance()->flush();}

 Server/ÂíÀöƼ/document/ÈÕÖ¾ÐèÇó·ÖÎöÎĵµ.docx

Binary files differ

 Server/ÂíÀöƼ/log/log_1031.doc

Binary files differ

 Server/ÂíÓ庼/log/20241031À¥ÂØÈÕ±¨.doc

Binary files differ

 common.h

New file
@@ -0,0 +1,873 @@
#ifndef COMMON_H
#define COMMON_H

#include <string.h>

enum TypeInfo{

    //注册登录
    LOGIN_REQ, // ç™»å½•è¯·æ±‚
    LOGIN_RES, // ç™»å½•å“åº”
    REGISTER_REQ, //注册请求
    REGISTER_RES, //注册响应
    RESET_REQ, //重置密码请求
    RESET_RES, //重置密码响应


    //权限管理
    QUERY_PMS_REQ,      // æŒ‰å‘˜å·¥ç¼–号、名字或职位查询人员权限信息请求
    UPDATE_PMS_REQ,     // æŒ‰è§’色id更新权限信息请求
    QUERY_PMS_RES,      // æŸ¥è¯¢äººå‘˜å’Œè§’色信息的响应结构体
    UPDATE_PMS_RES,     // æƒé™æ›´æ–°ç»“果响应体

    //设备管理
    AD_Req,//添加设备请求
    AD_Res,//添加设备响应
    CD_Req,//关闭设备请求
    CD_Res,//关闭设备请求
    PD_Req,//暂停设备请求
    PD_Res,//暂停设备请求

    //地图标注
    MAPMARK_REQ,//地图标注请求
    MAPMARK_RES//地图标注响应

    //大屏显示
    ENVIRONMENT_REQ,//环境数据请求
    ENVIRONMENT_RES,//环境数据响应
    DEVICESTATUS_REQ,//设备状态请求
    DEVICESTATUS_RES,//设备状态响应
    MOVEMENTRECORD_REQ,//操作日志请求
    MOVEMENTRECORD_RES,//操作日志响应
    ALARMRECORD_REQ,//警报记录请求
    ALARMRECORD_RES,//警报记录响应
    YIELD_REQ,//煤矿产量请求
    YIELD_RES,//煤矿产量响应

    //警报管理
    WARNING_REQ, // è­¦æŠ¥è¯·æ±‚
    WARNING_RES, // è­¦æŠ¥å“åº”


    //生产计划管理
    ADD_PRODUCTION_PLAN_REQ,//添加一行数据的请求结构体
    ADD_PRODUCTION_PLAN_RES,//添加一行数据的响应结构体
    UPDATE_PRODUCTION_PLAN_QUANTITY_REQ,// æ›´æ–°ç”Ÿäº§è®¡åˆ’（计划生产量）的请求结构体
    UPDATE_PRODUCTION_PLAN_QUANTITY_RES,// æ›´æ–°ç”Ÿäº§è®¡åˆ’（计划生产量）的响应结构体
    UPDATE_PRODUCTION_PLAN_LOG_REQ,//更新生产计划（日志）的请求结构体
    UPDATE_PRODUCTION_PLAN_LOG_RES,//更新生产计划（日志）的响应结构体
    PRODUCTION_PLAN_REQ,// æŸ¥è¯¢ç”Ÿäº§è®¡åˆ’信息的请求结构体
    PRODUCTION_PLAN_RES,// æŸ¥è¯¢ç”Ÿäº§è®¡åˆ’信息的响应结构体
    FORRECENT_FOURTEEN_PRODUCTION_PLANS_REQ,//查询近十四条的请求结构体
    FORRECENT_FOURTEEN_PRODUCTION_PLANS_RES //查询近十四条的响应结构体


    //历史查询分析
    HISTORY_QUERY_REQ, // åŽ†å²æŸ¥è¯¢è¯·æ±‚
    HISTORY_QUERY_RES, // åŽ†å²æŸ¥è¯¢å“åº”

    //自动升级
    VERSIONNUM_REQ,  // ç‰ˆæœ¬å·è¯·æ±‚
    VERSIONNUM_RES,   // ç‰ˆæœ¬å·å“åº”
    UPLOAD_FILE_REQ, // ä¸Šä¼ æ–‡ä»¶çš„请求
    UPLOAD_FILE_RES, // ä¸Šä¼ æ–‡ä»¶çš„响应
    VERSIONINFOENTRY_REQ,       // ç‰ˆæœ¬ä¿¡æ¯å½•å…¥è¯·æ±‚
    VERSIONINFOENTRY_RES,       //版本信息录入响应
    VERSIONUPDATE_REQ, // ç‰ˆæœ¬æ›´æ–°è¯·æ±‚
    VERSIONUPDATE_RES, // ç‰ˆæœ¬æ›´æ–°å“åº”
    FILEDOWNLOADS_REQ, // ç‰ˆæœ¬æ›´æ–°æ–‡ä»¶ä¸‹è½½è¯·æ±‚
    FILEDOWNLOADS_RES, // ç‰ˆæœ¬æ›´æ–°æ–‡ä»¶ä¸‹è½½å“åº”
    DOWNLOADSUCCESSFULLY_RES        // æ›´æ–°æ–‡ä»¶ä¸‹è½½æˆåŠŸçš„响应

    //日志
    LOGSEARCH_REQ;//日志查询请求
    LOGSEARCH_RES;//日志查询响应

		
};

struct Head{
    int type;
    int len;
};

//注册登录
//登录请求 
    struct LoginReq
    {
        Head head;
        char user_name[32];
        char password[32];
        LoginReq(){
            head.type = LOGIN_REQ;
            head.len = sizeof(LoginReq);
        }
    };
	
    struct Permission
    {
        int admin;
        int log_search; //日志查询
        int history; //历史记录
        int map_change;//地图
        int version_manage; // ç‰ˆæœ¬ç®¡ç†
        int warning; //警报
        int device_manage; //设备管理
        int pro_plan;//生产计划
        char role_name[32]; // è§’色名
    };
	
    //登录响应
    struct LoginRes
    {
        Head head;
        char user_name[32];
        int status; // ç™»å½•çŠ¶æ€
        // ç™»å½•æˆåŠŸæ—¶ï¼Œè¯¥è´¦å·å¯¹åº”的权限组合
        Permission per;
        LoginRes()
        {
            head.type = LOGIN_RES;
            head.len = sizeof(LoginRes);
        };
    };

    //注册请求 
    struct RegisterReq
    {
        Head head;
        char user_name[32];
        char password[32];
        char email[50];
        int telephone;
        RegisterReq(){
            head.type = REGISTER_REQ;
            head.len = sizeof(RegisterReq);
        }
    };

    //注册响应
    struct RegisterRes
    {
        Head head;
        char user_name[32];
        int status; // æ³¨å†ŒçŠ¶æ€
        //注册成功，默认最小权限组合
        Permission per;
        RegisterRes()
        {
            head.type = REGISTER_RES;
            head.len = sizeof(RegisterRes);
        };
    };

    //重置密码请求 
    struct ResetReq
    {
        Head head;
        char email[50];
        char password[32];
        ResetReq(){
            head.type = RESET_REQ;
            head.len = sizeof(ResetReq);
        }
    };

    //重置密码响应
    struct ResetRes
    {
        Head head;
        char user_name[32];
        int status; // é‡ç½®å¯†ç çŠ¶æ€
        ResetRes()
        {
            head.type = RESET_RES;
            head.len = sizeof(ResetRes);
        };
    };


//权限管理
// æŒ‰å‘˜å·¥ç¼–号、名字或职位查询人员权限信息请求
typedef struct QueryPmsRequest{
    Head head;
    char userNo[32];
    char name[32];
    char permissonType[32];
    QueryPmsRequest(){
        head.type=QUERY_PMS_REQ;
        memset(userNo,0,32);
        memset(permissonType,0,32);
        memset(name,0,32);
        head.len = sizeof(QueryPmsRequest);
    }
} QueryPmsRequest;

// æŒ‰è§’色id更新权限信息请求
typedef struct UpdatePmsRequest{
    Head head;
    int roleId;
    int queryHistory;
    int loggerSearch;
    int mapMark;
    int devManage;
    int productPlan;
    UpdatePmsRequest(){
        head.type=QUERY_PMS_RES;
        head.len = sizeof(UpdatePmsRequest);
    }
} UpdatePmsRequest;

// å•ä¸ªäººå‘˜æƒé™ç»“构体
typedef struct PmsRes{
    int queryHistory;
    int loggerSearch;
    int mapMark;
    int devManage;
    int productPlan;
    int roleId;
    char userNo[32];
    char name[32];
    char permissonType[32];
    char startDateTime[32];
    char endDateTime[32];
} PmsRes;

// æŸ¥è¯¢äººå‘˜å’Œè§’色信息的响应结构体
typedef struct QueryPmsResponse{
    Head head;
    int success; // 1为成功 ,0为失败
    char pmsList[0];
    QueryPmsResponse(){
        head.type=QUERY_PMS_RES;
    }
} QueryPmsResponse;

// æƒé™æ›´æ–°ç»“果响应体
struct UpdatePmsResponse{
    Head head;
    int success; // 1为成功 ,0为失败
    UpdatePmsResponse(){
        head.type = UPDATE_PMS_RES;
        head.len = sizeof(UpdatePmsResponse);
    }

} UpdatePmsResponse ;


//设备管理
//添加设备
struct ADReq
{
    Head head;
    char Device_Name[32];
    ADReq() {
        head.type = AD_Req;
        head.len = sizeof(AD_Req);
    }

};
struct ADPermission
{
    char Device_Name[32];
    char Device_Status[32];
    char Manufacturer[100];
    char Devices_Type[32];
    double Longitude;
    double Latitude;
};
struct ADRes
{
    Head head;
    char Device_Name[32];
    char Device_Status[32];
    char Start_Time[32];
    char Work_Time[32];
    char Manufacturer[100];
    char Devices_Type[32];
    double Longitude;
    double Latitude;
    ADPermission per;
    ADRes() {
        head.type = AD_Res;
        head.len = sizeof(ADRes);
    }

};

//关闭设备
struct CDReq
{
    Head head;
    char Device_Name[32];
    CDReq() {
        head.type = CD_Req;
        head.len = sizeof(CDReq);
    }
};
struct CDPermission
{
    char Device_Name[32];
    char Device_Status[32];
    char Start_Time[32];
    char Work_Time[32];
    char Manufacturer[100];
    char Devices_Type[32];
    double Longitude;
    double Latitude;
};
struct CDRes
{
    Head head;
    char Device_Status[32];
    int status;
    CDPermission per;
    CDRes() {
        head.type = CD_Res;
        head.len = sizeof(CDRes);
    }
};

//暂停设备
struct PDReq
{
    Head head;
    char Device_Name[32];
    PDReq() {
        head.type = PD_Req;
        head.len = sizeof(PDReq);
    }
};
struct PDPermission
{
    char Device_Name[32];
    char Device_Status[32];
    char Start_Time[32];
    char Work_Time[32];
    char Manufacturer[100];
    char Devices_Type[32];
    double Longitude;
    double Latitude;
};
struct PDRes
{
    Head head;
    char Device_Status[32];
    char Work_Time[32];
    int status;
    PDPermission per;
    PDRes() {
        head.type = PD_Res;
        head.len = sizeof(PDRes);
    }
};


//地图标注
struct MapMarkReq
{
    Head head;
    int marktype;//插入、删除、加载
    MaskInfo msg[0];//柔性数组
    MapMarkReq(){
        head.type = MAPMARK_REQ;
        head.len = sizeof(MapMarkReq);
    }
};
	
//地图响应：
struct MarkInfo
{
    int markId;//标注点id
    double latitude;//纬度
    double longitude;//经度
    int deviceId;//设备ID
    int deviceStatus;//设备状态
    char deviceName[32];//设备名称
};
	
struct MapMarkRes
{
    Head head;
    int markType;//插入还是删除
    int status; // æ“ä½œçŠ¶æ€_成功/失败
    MaskInfo info[0];//柔性数组
    MapMarkRes()
    {
        head.type = MAPMARK_RES;
        head.len = sizeof(MapMarkRes);
    };
};

//大屏显示
//环境数据请求
struct EnvironmentReq
{
    Head head;
    float temp;//温度
    float humidity;//湿度
    float oxygen;//氧气浓度
    float carbon;//一氧化碳浓度
        EnvironmentReq(){
        head.type = ENVIRONMENT_REQ;
        head.len = sizeof(EnvironmentReq);
    }
};
//设备状态请求
struct DeviceStatusReq
{
    Head head;
    int device_ID;//设备编号
    char device_Name[32];//设备名称
    char device_Status[32];//设备状态
        DeviceStatusReq(){
        head.type = DEVICESTATUS_REQ;
        head.len = sizeof(DeviceStatusReq);
    }
};
//操作日志请求
struct MovementRecordReq
{
    Head head;
    char user_Name;//操作用户名
    char operate_Time[32];//操作时间
    char device_Name[32];//操作设备
    char movement[256];//操作描述
        MovementRecordReq(){
        head.type = MOVEMENTRECORD_REQ;
        head.len = sizeof(MovementRecordReq);
    }
};
//警报记录请求
struct AlarmRecordReq
{
    Head head;
    char alarm_Time[32];//警报时间
    char alarm_type[32];//解决时间
    char alarm_Content[256];//警报内容
        AlarmRecordReq(){
        head.type = ALARMRECORD_REQ;
        head.len = sizeof(AlarmRecordReq);
    }
};
//煤矿产量请求
struct YieldReq
{
    Head head;
    int month;//月份
    int yield;//产量
        YieldReq(){
        head.type = YIELD_REQ;
        head.len = sizeof(YieldReq);
    }
};

//警报管理
// è­¦æŠ¥è¯·æ±‚结构体  
struct WarningReq {  
    Head head;  
    float oxygen;   // æ°§æ°”浓度  
    float carbon;   // ä¸€æ°§åŒ–碳浓度  
    float temp;     // æ¸©åº¦  
    float humidity; // æ¹¿åº¦  

    WarningReq() {  
        head.type = WARNING_REQ;  
        head.len = sizeof(WarningReq);  
    }  
};  

// è­¦æŠ¥å“åº”结构体  
struct WarningRes {  
    Head head;  
    int status;         // å“åº”状态（比如 0 è¡¨ç¤ºæˆåŠŸï¼Œ1 è¡¨ç¤ºå¤±è´¥ç­‰ï¼‰  
    const char* message; // å“åº”消息描述  

    WarningRes(int stat, const char* msg) {  
        head.type = WARNING_RES;  
        head.len = sizeof(WarningRes);  
        status = stat;  
        message = msg;  
    }  
}; 

//生产计划管理
//添加一行数据的请求结构体
struct AddProductionPlanReq {
    Head head;
    int type;
    char productionDate[32];
    int productionQuantity;
    int plannedProductionQuantity;
    int predictedProductionQuantity;
    char logText[256];
    AddProductionPlanReq() {
        head.type = ADD_PRODUCTION_PLAN_REQ;
        head.len = sizeof(AddProductionPlanReq);
    }
};
//添加一行数据的响应结构体
struct AddProductionPlanRes {
    Head head;
    int type;
    int status; // å¯ä»¥è¡¨ç¤ºæ·»åŠ æ˜¯å¦æˆåŠŸï¼Œ 0 è¡¨ç¤ºå¤±è´¥ï¼Œ1 è¡¨ç¤ºæˆåŠŸ
    AddProductionPlanRes() {
        head.type = ADD_PRODUCTION_PLAN_RES;
        head.len = sizeof(AddProductionPlanRes);
    }
};

// æ›´æ–°ç”Ÿäº§è®¡åˆ’（计划生产量）的请求结构体
struct UpdateProductionPlanQuantityReq {
    Head head;
    int type;
    int plannedProductionQuantity;
    char productionDate[32];
    UpdateProductionPlanQuantityReq() {
        head.type = UPDATE_PRODUCTION_PLAN_QUANTITY_REQ;
        head.len = sizeof(UpdateProductionPlanQuantityReq);
    }
};
// æ›´æ–°ç”Ÿäº§è®¡åˆ’（计划生产量）的响应结构体
struct UpdateProductionPlanQuantityRes {
    Head head;
    int type;
    int status; // å¯ä»¥è¡¨ç¤ºæ›´æ–°æ˜¯å¦æˆåŠŸï¼Œä¾‹å¦‚ 0 è¡¨ç¤ºå¤±è´¥ï¼Œ1 è¡¨ç¤ºæˆåŠŸ
    UpdateProductionPlanQuantityRes() {
        head.type = UPDATE_PRODUCTION_PLAN_QUANTITY_RES;
        head.len = sizeof(UpdateProductionPlanQuantityRes);
    }
};


// æ›´æ–°ç”Ÿäº§è®¡åˆ’（日志）的请求结构体
struct UpdateProductionPlanLogReq {
    Head head;
    int type;
    char logText[256];
    char productionDate[32];
    UpdateProductionPlanLogReq() {
        head.type = UPDATE_PRODUCTION_PLAN_LOG_REQ;
        head.len = sizeof(UpdateProductionPlanLogReq);
    }
};
// æ›´æ–°ç”Ÿäº§è®¡åˆ’请求（日志）的响应结构体
struct UpdateProductionPlanLogRes {
    Head head;
    int type;
    int status; // å¯ä»¥è¡¨ç¤ºæ›´æ–°æ˜¯å¦æˆåŠŸï¼Œä¾‹å¦‚ 0 è¡¨ç¤ºå¤±è´¥ï¼Œ1 è¡¨ç¤ºæˆåŠŸ
    UpdateProductionPlanLogRes() {
        head.type = UPDATE_PRODUCTION_PLAN_LOG_RES;
        head.len = sizeof(UpdateProductionPlanLogRes);
    }
};



// æŸ¥è¯¢ç”Ÿäº§è®¡åˆ’信息请求
struct ProductionPlanReq {
    Head head;
    int type;
    int len;
    char productionDate[32];
    int productionQuantity;
    int plannedProductionQuantity;
    int predictedProductionQuantity;
    char logText[256];
    ProductionPlanReq() {
        head.type = PRODUCTION_PLAN_REQ;
        head.len = sizeof(ProductionPlanReq);
    }
};
// æŸ¥è¯¢ç”Ÿäº§è®¡åˆ’信息的响应结构体
struct ProductionPlanRes {
    Head head;
    int type;
    int len;
    int productionQuantity;
    int plannedProductionQuantity;
    int predictedProductionQuantity;
    int roleId;
    char productionDate[32];
    char logText[256];
    ProductionPlanRes() {
        head.type = PRODUCTION_PLAN_REQ;
        head.len = sizeof(ProductionPlanRes);
    }
};



//查询近十四条的请求结构体
struct RecentFourteenProductionPlansReq {
    Head head;
    int requestType;
    RecentFourteenProductionPlansReq() {
        head.type = RECENTFOURTEENPRODUCTIONPLANS_REQ;
        head.len = sizeof(RecentFourteenProductionPlansReq);
    }
};
//查询近十四条的响应结构体
struct RecentFourteenProductionPlansRes {
    Head head;
    int responseType;
    int responseLength;
    int productionQuantities[14];
    int plannedProductionQuantities[14];
    int predictedProductionQuantities[14];
    int roleIds[14];
    char productionDates[14][32];
    char logTexts[14][256];
    RecentFourteenProductionPlansRes() {
        head.type = UPDATE_PRODUCTION_PLAN_QUANTITY_REQ;
        head.len = sizeof(RecentFourteenProductionPlansRes);
    }
};



//历史查询分析
// åŽ†å²æŸ¥è¯¢è¯·æ±‚结构体
struct HistoryQueryReq {
    Head head;
    //根据时间范围查询
    char start_time[32];
    char end_time[32];

    HistoryQueryReq() {
        // åˆå§‹åŒ–数据头
        head.type = HISTORY_QUERY_REQ;
        head.len = sizeof(HistoryQueryReq);
        // åˆå§‹åŒ–查询条件字段
        std::memset(start_time, 0, sizeof(start_time));
        std::memset(end_time, 0, sizeof(end_time));
    }
};

// ç³»ç»Ÿè¿è¡ŒçŠ¶æ€è¡¨ç›¸å…³ä¿¡æ¯
struct Histroy_Info{
        int sysId;  // å¯¹åº”系统运行状态表的记录编号
        char sysDataCollectionTime[50];  // æ•°æ®é‡‡é›†æ—¶é—´
        char sysDeviceType[50];  // è®¾å¤‡ç±»åž‹
        char sysDeviceId[50];  // è®¾å¤‡ç¼–号
        char sysDeviceStatus[50];  // è®¾å¤‡çŠ¶æ€
        char sysSystemStatus[50];  // ç³»ç»Ÿæ•´ä½“运行状态描述

        int devId;  // å¯¹åº”设备详细信息表的记录编号
        char devDeviceType[50];  // è®¾å¤‡ç±»åž‹ï¼ˆä¸Žç³»ç»Ÿè¿è¡ŒçŠ¶æ€è¡¨ä¸­çš„设备类型对应，可用于关联）
        char devDeviceId[50];  // è®¾å¤‡ç¼–号（与系统运行状态表中的设备编号对应，可用于关联）
        char devModel[50];  // è®¾å¤‡åž‹å·
        char runDeviceStatus[50];  // è®¾å¤‡çŠ¶æ€
        char runFaultAlarmTime[50];  // æ•…障报警时间
        char runFaultDescription[50];  // æ•…障详细描述

        int safetyId;  // å¯¹åº”设备安全状态表的记录编号
        char safetyDataCollectionTime[50];  // æ•°æ®é‡‡é›†æ—¶é—´ï¼ˆå¯ç”¨äºŽå…³è”不同表在同一时间点的数据情况）
        char safetyDeviceType[50];  // è®¾å¤‡ç±»åž‹ï¼ˆç”¨äºŽå…³è”）
        char safetyDeviceId[50];  // è®¾å¤‡ç¼–号（用于关联）
        char safetyStatus[50];  // è®¾å¤‡å®‰å…¨çŠ¶æ€
        char safetyParameter[50];  // å®‰å…¨å‚æ•°
};
// åŽ†å²æŸ¥è¯¢å“åº”结构体
// å®‰å…¨çŠ¶æ€è¡¨ç›¸å…³ä¿¡æ¯
struct HistoryQueryRes {
    Head head;
    Histroy_Info sys[0];

    HistoryQueryRes() {
        // åˆå§‹åŒ–数据头
        head.type = HISTORY_QUERY_RES;
        head.len = sizeof(HistoryQueryRes);
    }
    
};

//自动升级
struct VersionNumReq        // ç‰ˆæœ¬å·è¯·æ±‚
{
    Head head;
    VersionNumReq() {
        head.type = VERSIONNUM_REQ;
        head.len = sizeof(VersionNumReq);
    }
};

struct VersionNumRes        // ç‰ˆæœ¬å·å“åº”
{
    Head head;
    char version_id[64]; // ç‰ˆæœ¬å·
    VersionNumRes() {
        head.type = VERSIONNUM_RES;
        head.len = sizeof(VersionNumRes);
    }
};

// æ–‡ä»¶ä¼ è¾“
struct FileInfo
{
    char file_name[256];
    long long file_size;
    char s_filepath[128];
    char content[0];
};

struct UploadFileReq        // ä¸Šä¼ æ–‡ä»¶çš„请求
{
    Head head;
    FileInfo fileInfo;
    UploadFileReq() {
        head.type = UPLOAD_FILE_REQ;
        head.len = sizeof(UploadFileReq);
    }
};

struct UploadFileRes {      // ä¸Šä¼ æ–‡ä»¶çš„响应
    Head head;
    bool state = false;
    char file_name[256];
    long long file_size;
    UploadFileRes()
    {
        head.type = UPLOAD_FILE_RES;
        head.len = sizeof(UploadFileRes);
    }
};

// ç‰ˆæœ¬ä¿¡æ¯å½•å…¥
// è¯·æ±‚
struct VersionInfoEntryReq {
    Head head;
    char version_id[64]; // ç‰ˆæœ¬å·
    char version_id_old[64]; // ä¸Šä¸€ä¸ªç‰ˆæœ¬å·
    char s_filepath[16][128];    //服务器放最新版本的路径
    char version_description[256]; //更新内容
    char version_creattime[32]; // æ›´æ–°æ—¶é—´
    char filename[16][128];
    long long filesize[16];
    char c_filepath[16][128];
    int fileNum;

    VersionInfoEntryReq()
    {
        head.type = VERSIONINFOENTRY_REQ;
        head.len = sizeof(VersionInfoEntryReq);
    }
};

// ç‰ˆæœ¬ä¿¡æ¯å½•å…¥å“åº”
struct VersionInfoEntryRes {
    Head head;
    bool state = false;
    VersionInfoEntryRes()
    {
        head.type = VERSIONINFOENTRY_RES;
        head.len = sizeof(VersionInfoEntryRes);
    }
};

// ç‰ˆæœ¬æ›´æ–°è¯·æ±‚
struct VersionUpdateReq {
    Head head;

    char cur_version_id[64]; // ç‰ˆæœ¬å·
    VersionUpdateReq()
    {
        head.type = VERSIONUPDATE_REQ;
        head.len = sizeof(VersionUpdateReq);
    }
};

// ç‰ˆæœ¬æ›´æ–°å“åº”
struct VersionUpdateRes {
    Head head;
    bool state = false;
    char version_id[64]; // ç‰ˆæœ¬å·
    char update_date[32]; // æ›´æ–°æ—¶é—´
    char version_description[1024]; //更新描述

    VersionUpdateRes()
    {
        head.type = VERSIONUPDATE_RES;
        head.len = sizeof(VersionUpdateRes);
    }
};

// ç‰ˆæœ¬æ›´æ–°æ–‡ä»¶ä¸‹è½½è¯·æ±‚
struct FileDownloadsReq {
    Head head;
    char version_id[64]; // ç‰ˆæœ¬å·
    FileDownloadsReq()
    {
        head.type = FILEDOWNLOADS_REQ;
        head.len = sizeof(FileDownloadsReq);
    }
};

// ç‰ˆæœ¬æ›´æ–°æ–‡ä»¶ä¸‹è½½å“åº”
struct FileDownloadsRes {
    Head head;
    char version_id[64]; // ç‰ˆæœ¬å·
    char filename[128]; //文件名
    long long filesize; //文件大小
    char c_filepath[128];    //客户端放最新版本的本地路径
    int fileNum; // æ–‡ä»¶æ•°é‡
    long long all_fileSize; // æ–‡ä»¶æ€»å¤§å°
    char content[0];
    FileDownloadsRes()
    {
        head.type = FILEDOWNLOADS_RES;
        head.len = sizeof(FileDownloadsRes);
    }
};

// æ›´æ–°æ–‡ä»¶ä¸‹è½½æˆåŠŸçš„响应
struct DownloadSuccessfullyRes{
    Head head;
    bool state = false;
    char file_name[256];
    long long file_size;
    DownloadSuccessfullyRes()
    {
        head.type = DOWNLOADSUCCESSFULLY_RES;
        head.len = sizeof(DownloadSuccessfullyRes);
    }
};

//日志
struct ParsedLog { 
    char timestamp[64]; // æ—¶é—´æˆ³
    char device_id[64]; // è®¾å¤‡ID
    char level[16]; Â  Â  // æ—¥å¿—级别
    char content[256]; Â // æ—¥å¿—内容
    char source[64]; Â  Â // æ¥æºæ¨¡å—
    char user_id[64]; Â  // ç”¨æˆ·ID
};

// æ—¥å¿—查询请求结构体
struct LogQueryReq {
    Head head;                 // æ•°æ®å¤´
    char keyWords[32];            // å­˜å‚¨å…³é”®å­—的数组
    // æ— å‚构造函数
    LogQueryReq() {
        head.type = LOGSEARCH_REQ;
        head.len = sizeof(LogQueryReq);
    }
};

// æ—¥å¿—查询响应结构体
struct LogQueryRes {
    Head head;  
    int status;                    // å“åº”状态 (如 0 è¡¨ç¤ºæˆåŠŸï¼Œéž 0 è¡¨ç¤ºå¤±è´¥)
    char errorMessage[256];        // é”™è¯¯ä¿¡æ¯ï¼ˆå¦‚果有）
    
    // æ— å‚构造函数
    LogQueryRes() {
        head.type = LOGSEARCH_RES;
        head.len = sizeof(LogQueryRes);
    }
};




#endif // COMMON_H