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

wangky

2024-11-02 1e9cd1cdf91c4ba4bb4a18781806d01a2c960f96

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

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

Binary files differ

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

Binary files differ

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

Binary files differ

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

Binary files differ

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

Binary files differ

 Client/Ö캽/log/Ö캽1030.doc

Binary files differ

 Client/Ö캽/log/Ö캽1031.doc

Binary files differ

 Client/Ö캽/log/Ö캽1101.doc

Binary files differ

 Client/Ö캽/log/Ö캽1102..doc

Binary files differ

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

Binary files differ

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

Binary files differ

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

Binary files differ

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

Binary files differ

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

Binary files differ

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

@@ -1,121 +1,88 @@
#pragma once
enum TypeInfo
{
    AD_Req,//添加设备请求
    AD_Res,//添加设备响应
    CD_Req,//关闭设备请求
    CD_Res,//关闭设备请求
    PD_Req,//暂停设备请求
    PD_Res,//暂停设备请求
    AD_REQ,//添加设备请求
    AD_RES,//添加设备响应
    MD_REQ,//修改设备请求
    MD_RES,//修改设备响应
    QD_REQ,//查询设备请求
    QD_RES,//查询设备响应
};
struct Head
{
    int type;
    int len;
};

struct DevicesInfo
{
    int deviceID;
    char deviceName[32];//设备名称
    char deviceStatus[32];//设备状态
    char manufacturer[100];//厂家
    char devicesType[32];//设备类型
    double longitude;//经度
    double latitude;//纬度
    char purchasingTime[15];//购买时间
    char installTime[15];//安装时间
    char devicesSerialNumber[32];//设备编码
};
//添加设备
struct ADReq
struct ADReq//添加请求
{
    Head head;
    char Device_Name[32];
    char deviceName[32];
    ADReq() {
        head.type = AD_Req;
        head.len = sizeof(AD_Req);
        head.type = AD_REQ;
        head.len = sizeof(ADReq);
    }

};
struct ADPermission
{
    char Device_Name[32];
    char Device_Status[32];
    char Manufacturer[100];
    char Devices_Type[32];
    double Longitude;
    double Latitude;
};
struct ADRes

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;
    int type;
    ADRes() {
        head.type = AD_Res;
        head.type = AD_RES;
        head.len = sizeof(ADRes);
    }

};

//关闭设备
struct CDReq
//修改设备
struct MDRes//修改请求
{
    Head head;
    char Device_Name[32];
    CDReq() {
        head.type = CD_Req;
        head.len = sizeof(CDReq);
    DevicesInfo info;
    MDRes() {
        head.type = MD_RES;
        head.len = sizeof(MDRes);
    }
};
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
struct MDReq//修改响应
{
    Head head;
    char Device_Status[32];
    int status;
    CDPermission per;
    CDRes() {
        head.type = CD_Res;
        head.len = sizeof(CDRes);
    int type;
    MDReq() {
        head.type = MD_REQ;
        head.len = sizeof(MDReq);
    }
};

//暂停设备
struct PDReq
//查询设备
struct QDReq//查询请求
{
    Head head;
    char Device_Name[32];
    PDReq() {
        head.type = PD_Req;
        head.len = sizeof(PDReq);
    DevicesInfo info;
    QDReq() {
        head.type = QD_REQ;
        head.len = sizeof(QDReq);
    }
};
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
struct QDRes//查询响应
{
    Head head;
    char Device_Status[32];
    char Work_Time[32];
    int status;
    PDPermission per;
    PDRes() {
        head.type = PD_Res;
        head.len = sizeof(PDRes);
    int type;
    QDRes() {
        head.type = QD_RES;
        head.len = sizeof(QDRes);
    }
};

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

Binary files differ

 Client/¹¨ÆôÏé/log/ÈÕ־ģ°å_¹¨ÆôÏé_1102.doc

Binary files differ

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

Binary files differ

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

Binary files differ

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

Binary files differ

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

Binary files differ

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

copy from "Client/\351\203\221\345\207\257\346\226\207/document/\346\230\206\344\273\2211031_\351\241\271\347\233\256\346\227\245\346\212\245.doc"
copy to "Server/\351\251\254\346\270\235\346\235\255/log/20241102\346\230\206\344\273\221\346\227\245\346\212\245.doc"
Binary files differ

 Server/ÂíÓ庼/log/ÈÕÖ¾_ÂíÓ庼_20241031.doc

Binary files differ

 Server/ÂíÓ庼/log/ÈÕÖ¾_ÂíÓ庼_20241101.doc

Binary files differ

 Server/ÂíÓ庼/log/ÈÕÖ¾_ÂíÓ庼_20241102.doc

Binary files differ

 common.h

@@ -3,9 +3,9 @@

#include <string.h>

enum TypeInfo{
enum TypeInfo {

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


    //权限管理
    QUERY_PMS_REQ,      // æŒ‰å‘˜å·¥ç¼–号、名字或职位查询人员权限信息请求
    UPDATE_PMS_REQ,     // æŒ‰è§’色id更新权限信息请求
    QUERY_PMS_RES,      // æŸ¥è¯¢äººå‘˜å’Œè§’色信息的响应结构体
    UPDATE_PMS_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,//暂停设备请求
    //设备管理
    AD_REQ,//添加设备请求
    AD_RES,//添加设备响应
    MD_REQ,//修改设备请求
    MD_RES,//修改设备响应
    QD_REQ,//查询设备请求
    QD_RES,//查询设备响应

    //地图标注
    MAPMARK_REQ,//地图标注请求
    MAPMARK_RES//地图标注响应
    //地图标注
    MML_REQ,//地图标注加载请求
    MML_RES,//地图标注加载响应	
    MMI_REQ,//地图标注插入请求
    MMI_RES,//地图标注插入响应	
    MMD_REQ,//地图标注删除请求
    MMD_RES,//地图标注删除响应

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

    //警报管理
    WARNING_REQ, // è­¦æŠ¥è¯·æ±‚
    WARNING_RES, // è­¦æŠ¥å“åº”
    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 //查询近十四条的响应结构体
    //生产计划管理
    ADD_PDPLAN_REQ,//添加一条生产计划的请求结构体
    ADD_PDPLAN_RES,//添加一条生产计划的响应结构体
    DEL_PDPLAN_REQ,//删除一条生产计划的请求结构体
    DEL_PDPLAN_RES,//删除一条生产计划的响应结构体
    UPDATE_PDPLAN_REQ,//更改一条生产计划的请求结构体
    UPDATE_PDPLAN_RES,//更改一条生产计划的响应结构体
    QUERY_PDPLAN_REQ,//查询一条生产计划的请求结构体
    QUERY_PDPLAN_RES,//查询一条生产计划的响应结构体


    //历史查询分析
    HISTORY_QUERY_REQ, // åŽ†å²æŸ¥è¯¢è¯·æ±‚
    HISTORY_QUERY_RES, // åŽ†å²æŸ¥è¯¢å“åº”
    ADD_MONOUTPUT_REQ,//添加月产量的请求结构体
    ADD_MONOUTPUT_RES,//添加月产量的响应结构体
    DEL_MONOUTPUT_REQ,//删除月产量的请求结构体
    DEL_MONOUTPUT_RES,//删除月产量的响应结构体
    UPDATE_MONOUTPUT_REQ,//更新月产量的请求结构体
    UPDATE_MONOUTPUT_RES,//更新月产量的响应结构体
    QUERY_MONOUTPUT_REQ,//查询月产量的请求结构体
    QUERY_MONOUTPUT_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;//日志查询响应
    //自动升级
    VERSION_NUM_REQ,  // ç‰ˆæœ¬å·è¯·æ±‚
    VERSION_NUM_RES,   // ç‰ˆæœ¬å·å“åº”
    UPLOAD_FILE_REQ, // ä¸Šä¼ æ–‡ä»¶çš„请求
    UPLOAD_FILE_RES, // ä¸Šä¼ æ–‡ä»¶çš„响应
    VERSION_INFOENTRY_REQ,       // ç‰ˆæœ¬ä¿¡æ¯å½•å…¥è¯·æ±‚
    VERSION_INFOENTRY_RES,       //版本信息录入响应
    VERSION_UPDATE_REQ, // ç‰ˆæœ¬æ›´æ–°è¯·æ±‚
    VERSION_UPDATE_RES, // ç‰ˆæœ¬æ›´æ–°å“åº”
    FILE_DOWNLOADS_REQ, // ç‰ˆæœ¬æ›´æ–°æ–‡ä»¶ä¸‹è½½è¯·æ±‚
    FILE_DOWNLOADS_RES, // ç‰ˆæœ¬æ›´æ–°æ–‡ä»¶ä¸‹è½½å“åº”
    DOWNLOAD_SUCCESSFULLY_RES,       // æ›´æ–°æ–‡ä»¶ä¸‹è½½æˆåŠŸçš„响应

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

};

struct Head{
    int type;
    int len;
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 LoginReq
{
    Head head;
    char userName[32];
    char password[32];
    LoginReq() {
        head.type = LOGIN_REQ;
        head.len = sizeof(LoginReq);
    }
};

    //注册请求 
    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 Permission
{
    int admin;//超级管理员
    int loggerSearch; //日志查询
    int queryHistory; //历史记录
    int mapMark;//地图
    int versionManage; // ç‰ˆæœ¬ç®¡ç†
    int warning; //警报
    int devManage; //设备管理
    int productPlan;//生产计划
    char roleName[32]; // è§’色名
};

    //注册响应
    struct RegisterRes
//登录响应
struct LoginRes
{
    Head head;
    char userName[32];
    int status; // ç™»å½•çŠ¶æ€
    // ç™»å½•æˆåŠŸæ—¶ï¼Œè¯¥è´¦å·å¯¹åº”的权限组合
    Permission per;
    LoginRes()
    {
        Head head;
        char user_name[32];
        int status; // æ³¨å†ŒçŠ¶æ€
        //注册成功，默认最小权限组合
        Permission per;
        RegisterRes()
        {
            head.type = REGISTER_RES;
            head.len = sizeof(RegisterRes);
        };
    };
        head.type = LOGIN_RES;
        head.len = sizeof(LoginRes);
    }
};

    //重置密码请求 
    struct ResetReq
//注册请求 
struct RegisterReq
{
    Head head;
    char userName[32];
    char password[32];
    char email[50];
    char capcha[10];//验证码
    char telephone[32];
    RegisterReq() {
        head.type = REGISTER_REQ;
        head.len = sizeof(RegisterReq);
    }
};

//注册响应
struct RegisterRes
{
    Head head;
    char userName[32];
    int status; // æ³¨å†ŒçŠ¶æ€
    RegisterRes()
    {
        Head head;
        char email[50];
        char password[32];
        ResetReq(){
            head.type = RESET_REQ;
            head.len = sizeof(ResetReq);
        }
    };
        head.type = REGISTER_RES;
        head.len = sizeof(RegisterRes);
    }
};

    //重置密码响应
    struct ResetRes
//重置密码请求 
struct ResetReq
{
    Head head;
    char email[50];
    char capcha[10];//验证码
    char password[32];//新密码
    char confirmPassword[32];//确认密码
    ResetReq() {
        head.type = RESET_REQ;
        head.len = sizeof(ResetReq);
    }
};

//重置密码响应
struct ResetRes
{
    Head head;
    char user_name[32];
    int status; // é‡ç½®å¯†ç çŠ¶æ€
    ResetRes()
    {
        Head head;
        char user_name[32];
        int status; // é‡ç½®å¯†ç çŠ¶æ€
        ResetRes()
        {
            head.type = RESET_RES;
            head.len = sizeof(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;
typedef struct QueryPmsReq {
    Head head;
    char userNo[32];
    char name[32];
    char permissonType[32];
    QueryPmsReq() {
        head.type = QUERY_PMS_REQ;
        memset(userNo, 0, 32);
        memset(permissonType, 0, 32);
        memset(name, 0, 32);
        head.len = sizeof(QueryPmsReq);
    }
} QueryPmsReq;

// æŒ‰è§’色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 UpdatePmsReq {
    Head head;
    // äººå‘˜è¡¨ä¸»é”®id
    int id;
    int queryHistory;
    int loggerSearch;
    int mapMark;
    int devManage;
    int productPlan;
    int warningManage;
    int versionManage; //版本管理
    int admin; //系统管理员
    UpdatePmsReq() {
        head.type = QUERY_PMS_RES;
        head.len = sizeof(UpdatePmsReq);
    }
} UpdatePmsReq;

// å•ä¸ªäººå‘˜æƒé™ç»“构体
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];
// å•ä¸ªäººå‘˜å’Œæƒé™è”合查询结构体
typedef struct PmsRes {
    int queryHistory;
    int loggerSearch;
    int mapMark;
    int devManage;
    int productPlan;
    int id;

    char userNo[32];
    char name[32];

    char permissonType[32];  // è§’色类型
    int versionManage; //版本管理
    int admin; //系统管理员
    char department[32];
    char loginTime[32];
    char registerTime[32];
} PmsRes;

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

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

} UpdatePmsResponse ;
} UpdatePmsRes;




//设备管理
struct DevicesInfo
{
    int deviceID;
    char deviceName[32];//设备名称
    char deviceStatus[32];//设备状态
    char manufacturer[100];//厂家
    char devicesType[32];//设备类型
    double longitude;//经度
    double latitude;//纬度
    char purchasingTime[15];//购买时间
    char installTime[15];//安装时间
    char devicesSerialNumber[32];//设备编码
};
//添加设备
struct ADReq
struct ADReq//添加请求
{
    Head head;
    char Device_Name[32];
    char deviceName[32];
    ADReq() {
        head.type = AD_Req;
        head.len = sizeof(AD_Req);
        head.type = AD_REQ;
        head.len = sizeof(ADReq);
    }

};
struct ADPermission
{
    char Device_Name[32];
    char Device_Status[32];
    char Manufacturer[100];
    char Devices_Type[32];
    double Longitude;
    double Latitude;
};
struct ADRes

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;
    int type;
    ADRes() {
        head.type = AD_Res;
        head.type = AD_RES;
        head.len = sizeof(ADRes);
    }

};

//关闭设备
struct CDReq
//修改设备
struct MDRes//修改请求
{
    Head head;
    char Device_Name[32];
    CDReq() {
        head.type = CD_Req;
        head.len = sizeof(CDReq);
    DevicesInfo info;
    MDRes() {
        head.type = MD_RES;
        head.len = sizeof(MDRes);
    }
};
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
struct MDReq//修改响应
{
    Head head;
    char Device_Status[32];
    int status;
    CDPermission per;
    CDRes() {
        head.type = CD_Res;
        head.len = sizeof(CDRes);
    int type;
    MDReq() {
        head.type = MD_REQ;
        head.len = sizeof(MDReq);
    }
};

//暂停设备
struct PDReq
//查询设备
struct QDReq//查询请求
{
    Head head;
    char Device_Name[32];
    PDReq() {
        head.type = PD_Req;
        head.len = sizeof(PDReq);
    DevicesInfo info;
    QDReq() {
        head.type = QD_REQ;
        head.len = sizeof(QDReq);
    }
};
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
struct QDRes//查询响应
{
    Head head;
    char Device_Status[32];
    char Work_Time[32];
    int status;
    PDPermission per;
    PDRes() {
        head.type = PD_Res;
        head.len = sizeof(PDRes);
    int type;
    QDRes() {
        head.type = QD_RES;
        head.len = sizeof(QDRes);
    }
};


//地图标注
struct MapMarkReq
{
    Head head;
    int marktype;//插入、删除、加载
    MaskInfo msg[0];//柔性数组
    MapMarkReq(){
        head.type = MAPMARK_REQ;
        head.len = sizeof(MapMarkReq);
    }
};
	
//地图响应：
struct MarkInfo
{
    int markId;//标注点id
@@ -385,242 +359,453 @@
    int deviceStatus;//设备状态
    char deviceName[32];//设备名称
};
	
struct MapMarkRes
//地图标注加载请求
struct MMLReq//地图
{
    Head head;
    int markType;//插入还是删除
    int status; // æ“ä½œçŠ¶æ€_成功/失败
    MaskInfo info[0];//柔性数组
    MapMarkRes()
    {
        head.type = MAPMARK_RES;
        head.len = sizeof(MapMarkRes);
    };
    MMLReq() {
        head.type = MML_REQ;
        head.len = sizeof(MMLReq);
    }
};
//地图标注加载响应：
struct MMLRes
{
    Head head;
    int status;//操作状态
    MarkInfo info[0];
    MMLRes() {
        head.type = MML_RES;
        head.len = sizeof(MMLRes);
    }
};
//地图标注插入请求
struct MMIReq//地图
{
    Head head;
    MarkInfo info[0];
    MMIReq() {
        head.type = MMI_REQ;
        head.len = sizeof(MMIReq);
    }
};
//地图标注插入响应：
struct MMIRes
{
    Head head;
    int status;//操作状态
    MarkInfo info[0];
    MMIRes() {
        head.type = MMI_RES;
        head.len = sizeof(MMIRes);
    }
};

//地图标注删除请求
struct MMDReq//地图
{
    Head head;
    MarkInfo info[0];
    MMDReq() {
        head.type = MMD_REQ;
        head.len = sizeof(MMDReq);
    }
};
//地图标注删除响应：
struct MMDRes
{
    Head head;
    int status;//操作状态
    MarkInfo info[0];
    MMDRes() {
        head.type = MMD_RES;
        head.len = sizeof(MMDRes);
    }
};

//大屏显示
//环境数据请求
struct EnvironmentReq
{
    Head head;
    float temp;//温度
    float humidity;//湿度
    float oxygen;//氧气浓度
    float carbon;//一氧化碳浓度
        EnvironmentReq(){
        head.type = ENVIRONMENT_REQ;
        head.len = sizeof(EnvironmentReq);
    }
    Head head;
    EnvironmentReq() {
        head.type = ENVIRONMENT_REQ;
        head.len = sizeof(EnvironmentReq);
    }
};
//环境数据响应
struct Environment
{
    float temp;//温度
    float humidity;//湿度
    float oxygen;//氧气浓度
    float carbon;//一氧化碳浓度
};
struct EnvironmentRes
{
    Head head;
    int status;
    Environment environment[0];
    EnvironmentRes() {
        head.type = ENVIRONMENT_RES;
        head.len = sizeof(EnvironmentRes);
    }
};
//设备状态请求
struct DeviceStatusReq
{
    Head head;
    int device_ID;//设备编号
    char device_Name[32];//设备名称
    char device_Status[32];//设备状态
        DeviceStatusReq(){
        head.type = DEVICESTATUS_REQ;
        head.len = sizeof(DeviceStatusReq);
    }
    Head head;
    DeviceStatusReq() {
        head.type = DEVICESTATUS_REQ;
        head.len = sizeof(DeviceStatusReq);
    }
};
//设备状态响应
struct DeviceStatus
{
    int deviceID;//设备编号
    char deviceName[32];//设备名称
    char deviceStatus[32];//设备状态
};
struct DeviceStatusRes
{
    Head head;
    int status;
    DeviceStatus deviceStatus[0];
    DeviceStatusRes() {
        head.type = DEVICESTATUS_RES;
        head.len = sizeof(DeviceStatusRes);
    }
};
//操作日志请求
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);
    }
    Head head;
    MovementRecordReq() {
        head.type = MOVEMENTRECORD_REQ;
        head.len = sizeof(MovementRecordReq);
    }
};
//操作日志响应
struct MovementRecord
{
    char userName;//操作用户名
    char operateTime[32];//操作时间
    char deviceName[32];//操作设备
    char movement[256];//操作描述
};
struct MovementRecordRes
{
    Head head;
    int status;
    MovementRecord movementRecord[0];
    MovementRecordRes() {
        head.type = MOVEMENTRECORD_RES;
        head.len = sizeof(MovementRecordRes);
    }
};
//警报记录请求
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);
    }
    Head head;
    AlarmRecordReq() {
        head.type = ALARMRECORD_REQ;
        head.len = sizeof(AlarmRecordReq);
    }
};
//警报记录响应
struct AlarmRecord
{
    char alarmTime[32];//警报时间
    char alarmtype[32];//通知时间
    char alarmContent[256];//警报内容
};
struct AlarmRecordRes
{
    Head head;
    int status;
    AlarmRecord alarmRecord[0];
    AlarmRecordRes() {
        head.type = ALARMRECORD_RES;
        head.len = sizeof(AlarmRecordRes);
    }
};
//煤矿产量请求
struct YieldReq
{
    Head head;
    int month;//月份
    int yield;//产量
        YieldReq(){
        head.type = YIELD_REQ;
        head.len = sizeof(YieldReq);
    }
    Head head;
    YieldReq() {
        head.type = YIELD_REQ;
        head.len = sizeof(YieldReq);
    }
};
//煤矿产量响应
struct Yield
{
    int month;//月份
    int output;//产量
};
struct YieldRes
{
    Head head;
    int status;
    Yield yield[0];
    YieldRes() {
        head.type = YIELD_RES;
        head.len = sizeof(YieldRes);
    }
};

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

    WarningReq() {  
        head.type = WARNING_REQ;  
        head.len = sizeof(WarningReq);  
    }  
};  
    float oxygenWarning;
    float carbonWarning;
    float tempWarning;
    float humidityWarning;

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


struct DataThreshold {
    //阈值
    float oxygenThreshold;
    float carbonThreshold;
    float tempThreshold;
    float humidityThreshold;
};

struct Data {
    float oxygen;   // æ°§æ°”浓度  
    float carbon;   // ä¸€æ°§åŒ–碳浓度  
    float temp;     // æ¸©åº¦  
    float humidity; // æ¹¿åº¦ 
};

// è­¦æŠ¥å“åº”结构体  
struct WarningRes {  
    Head head;  
    int status;         // å“åº”状态（比如 0 è¡¨ç¤ºæˆåŠŸï¼Œ1 è¡¨ç¤ºå¤±è´¥ç­‰ï¼‰  
    const char* message; // å“åº”消息描述  
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;  
    }  
}; 
    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 PdplanInfo
{
    int id;//生产计划编号
    char planName[32];//生产计划名字
    char startDate[32];//起始日期
    char closingDate[32];//截至日期
    double plannedPd;//计划生产量
    double actualPd;//实际生产量
    double progress;//生产进度
    int finishOntime;//是否按期完成
};
//添加一行数据的响应结构体
struct AddProductionPlanRes {

struct MonoutputInfo
{
    int month;//月份
    double output;//月产量
};

//添加一条生产计划的请求结构体
struct AddPdplanReq
{
    Head head;
    int type;
    int status; // å¯ä»¥è¡¨ç¤ºæ·»åŠ æ˜¯å¦æˆåŠŸï¼Œ 0 è¡¨ç¤ºå¤±è´¥ï¼Œ1 è¡¨ç¤ºæˆåŠŸ
    AddProductionPlanRes() {
        head.type = ADD_PRODUCTION_PLAN_RES;
        head.len = sizeof(AddProductionPlanRes);
    PdplanInfo info[0];
    AddPdplanReq() {
        head.type = ADD_PDPLAN_REQ;
        head.len = sizeof(AddPdplanReq);
    }
};

// æ›´æ–°ç”Ÿäº§è®¡åˆ’（计划生产量）的请求结构体
struct UpdateProductionPlanQuantityReq {
//添加一条生产计划的响应结构体
struct AddPdplanRes
{
    Head head;
    int type;
    int plannedProductionQuantity;
    char productionDate[32];
    UpdateProductionPlanQuantityReq() {
        head.type = UPDATE_PRODUCTION_PLAN_QUANTITY_REQ;
        head.len = sizeof(UpdateProductionPlanQuantityReq);
    int status;//表示是否添加成功，0否1是
    AddPdplanRes() {
        head.type = ADD_PDPLAN_RES;
        head.len = sizeof(AddPdplanRes);
    }
};
// æ›´æ–°ç”Ÿäº§è®¡åˆ’（计划生产量）的响应结构体
struct UpdateProductionPlanQuantityRes {

//删除一条生产计划的请求结构体
struct DelPdplanReq
{
    Head head;
    int type;
    int status; // å¯ä»¥è¡¨ç¤ºæ›´æ–°æ˜¯å¦æˆåŠŸï¼Œä¾‹å¦‚ 0 è¡¨ç¤ºå¤±è´¥ï¼Œ1 è¡¨ç¤ºæˆåŠŸ
    UpdateProductionPlanQuantityRes() {
        head.type = UPDATE_PRODUCTION_PLAN_QUANTITY_RES;
        head.len = sizeof(UpdateProductionPlanQuantityRes);
    PdplanInfo info[0];
    DelPdplanReq() {
        head.type = DEL_PDPLAN_REQ;
        head.len = sizeof(DelPdplanReq);
    }
};

//删除一条生产计划的响应结构体
struct DelPdplanRes
{
    Head head;
    int status;//表示是否删除成功，0否1是
    DelPdplanRes() {
        head.type = DEL_PDPLAN_RES;
        head.len = sizeof(DelPdplanRes);
    }
};

//更改一条生产计划的请求结构体.
struct UpdatePdplanReq
{
    Head head;
    PdplanInfo info[0];
    UpdatePdplanReq() {
        head.type = UPDATE_PDPLAN_REQ;
        head.len = sizeof(UpdatePdplanReq);
    }
};

//更改一条生产计划的响应结构体
struct UpdatePdplanRes
{
    Head head;
    int status;//表示是否更新成功，0否1是
    PdplanInfo info[0];
    UpdatePdplanRes() {
        head.type = UPDATE_PDPLAN_RES;
        head.len = sizeof(UpdatePdplanRes);
    }
};

//查询一条生产计划的请求结构体
struct QueryPdplanReq
{
    Head head;
    int id;//生产计划编号
    char planName[32];//生产计划名字
    char startDate[32];//起始日期
    char closingDate[32];//截至日期
    double plannedPd;//计划生产量
    double actualPd;//实际生产量
    int finishOntime;//是否按期完成
    QueryPdplanReq() {
        head.type = QUERY_PDPLAN_REQ;
        head.len = sizeof(QueryPdplanReq);
    }
};

//查询一条生产计划的响应结构体
struct QueryPdplanRes
{
    Head head;
    int status;//表示是否添加成功，0否1是
    PdplanInfo info[0];
    QueryPdplanRes() {
        head.type = QUERY_PDPLAN_RES;
        head.len = sizeof(QueryPdplanRes);
    }
};


// æ›´æ–°ç”Ÿäº§è®¡åˆ’（日志）的请求结构体
struct UpdateProductionPlanLogReq {
//添加月产量的请求结构体
struct AddMonoutputReq
{
    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);
    MonoutputInfo info[0];
    AddMonoutputReq() {
        head.type = ADD_MONOUTPUT_REQ;
        head.len = sizeof(AddMonoutputReq);
    }
};



// æŸ¥è¯¢ç”Ÿäº§è®¡åˆ’信息请求
struct ProductionPlanReq {
//添加月产量的响应结构体
struct AddMonoutputRes
{
    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);
    int status;//表示是否添加成功，0否1是
    AddMonoutputRes() {
        head.type = ADD_MONOUTPUT_RES;
        head.len = sizeof(AddMonoutputRes);
    }
};



//查询近十四条的请求结构体
struct RecentFourteenProductionPlansReq {
//删除月产量的请求结构体
struct DelMonoutputReq
{
    Head head;
    int requestType;
    RecentFourteenProductionPlansReq() {
        head.type = RECENTFOURTEENPRODUCTIONPLANS_REQ;
        head.len = sizeof(RecentFourteenProductionPlansReq);
    MonoutputInfo info[0];
    DelMonoutputReq() {
        head.type = DEL_MONOUTPUT_REQ;
        head.len = sizeof(DelMonoutputReq);
    }
};
//查询近十四条的响应结构体
struct RecentFourteenProductionPlansRes {

//删除月产量的响应结构体
struct DelMonoutputRes
{
    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);
    int status;//表示是否删除成功，0否1是
    DelMonoutputRes() {
        head.type = DEL_MONOUTPUT_RES;
        head.len = sizeof(DelMonoutputRes);
    }
};

//更改月产量的请求结构体.
struct UpdateMonoutputReq
{
    Head head;
    MonoutputInfo info[0];
    UpdateMonoutputReq() {
        head.type = UPDATE_MONOUTPUT_REQ;
        head.len = sizeof(UpdateMonoutputReq);
    }
};

//更改月产量的响应结构体
struct UpdateMonoutputRes
{
    Head head;
    int status;//表示是否更新成功，0否1是
    MonoutputInfo info[0];
    UpdateMonoutputRes() {
        head.type = UPDATE_MONOUTPUT_RES;
        head.len = sizeof(UpdateMonoutputRes);
    }
};

//查询月产量的请求结构体
struct QueryMonoutputReq
{
    Head head;
    int month;//月份
    double output;//月产量
    QueryMonoutputReq() {
        head.type = QUERY_MONOUTPUT_REQ;
        head.len = sizeof(QueryMonoutputReq);
    }
};

//查询月产量的响应结构体
struct QueryMonoutputRes
{
    Head head;
    int status;//表示是否添加成功，0否1是
    MonoutputInfo info[0];
    QueryMonoutputRes() {
        head.type = QUERY_MONOUTPUT_RES;
        head.len = sizeof(QueryMonoutputRes);
    }
};

@@ -629,65 +814,48 @@
//历史查询分析
// åŽ†å²æŸ¥è¯¢è¯·æ±‚结构体
struct HistoryQueryReq {
    Head head;
    //根据时间范围查询
    char start_time[32];
    char end_time[32];
    Head head;
    //根据时间范围查询
    char startTime[32];
    char endTime[32];
    //关键字查询
    char keyWord[32];
    HistoryQueryReq() {
        // åˆå§‹åŒ–数据头
        head.type = QUERY_MONOUTPUT_REQ;
        head.len = sizeof(HistoryQueryReq);
        // åˆå§‹åŒ–查询条件字段
        std::memset(startTime, 0, sizeof(startTime));
        std::memset(endTime, 0, sizeof(endTime));

    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 HistroyInfo {
    WarningRes warn;//警报查询
    QDRes dev;//设备查询
    QueryPdplanRes  pro;//生产计划查询
};
// åŽ†å²æŸ¥è¯¢å“åº”结构体
// å®‰å…¨çŠ¶æ€è¡¨ç›¸å…³ä¿¡æ¯
struct HistoryQueryRes {
    Head head;
    Histroy_Info sys[0];

    HistoryQueryRes() {
        // åˆå§‹åŒ–数据头
        head.type = HISTORY_QUERY_RES;
        head.len = sizeof(HistoryQueryRes);
    }
    
    Head head;
    HistroyInfo sys[0];
    HistoryQueryRes() {
        // åˆå§‹åŒ–数据头
        head.type = QUERY_MONOUTPUT_RES;
        head.len = sizeof(HistoryQueryRes);
    }
};


//自动升级
struct VersionNumReq        // ç‰ˆæœ¬å·è¯·æ±‚
{
    Head head;
    VersionNumReq() {
        head.type = VERSIONNUM_REQ;
        head.type = VERSION_NUM_REQ;
        head.len = sizeof(VersionNumReq);
    }
};
@@ -695,9 +863,9 @@
struct VersionNumRes        // ç‰ˆæœ¬å·å“åº”
{
    Head head;
    char version_id[64]; // ç‰ˆæœ¬å·
    char versionId[64]; // ç‰ˆæœ¬å·
    VersionNumRes() {
        head.type = VERSIONNUM_RES;
        head.type = VERSION_NUM_RES;
        head.len = sizeof(VersionNumRes);
    }
};
@@ -705,9 +873,9 @@
// æ–‡ä»¶ä¼ è¾“
struct FileInfo
{
    char file_name[256];
    long long file_size;
    char s_filepath[128];
    char fileName[256];
    long long fileSize;
    char s_filepath[128];
    char content[0];
};

@@ -722,149 +890,151 @@
};

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);
    }
    Head head;
    bool state = false;
    char fileName[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;
    Head head;
    char versionId[64]; // ç‰ˆæœ¬å·
    char versionIdOld[64]; // ä¸Šä¸€ä¸ªç‰ˆæœ¬å·
    int fileNum;
    char context[0];        //包含下载文件信息

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

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

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

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

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

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

// ç‰ˆæœ¬æ›´æ–°æ–‡ä»¶ä¸‹è½½è¯·æ±‚
struct FileDownloadsReq {
    Head head;
    char version_id[64]; // ç‰ˆæœ¬å·
    FileDownloadsReq()
    {
        head.type = FILEDOWNLOADS_REQ;
        head.len = sizeof(FileDownloadsReq);
    }
    Head head;
    char versionId[64]; // ç‰ˆæœ¬å·
    FileDownloadsReq()
    {
        head.type = FILE_DOWNLOADS_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);
    }
    Head head;
    char versionId[64]; // ç‰ˆæœ¬å·
    char filename[128]; //文件名
    long long filesize; //文件大小
    char c_filepath[128];    //客户端放最新版本的本地路径
    int fileNum; // æ–‡ä»¶æ•°é‡
    long long allFileSize; // æ–‡ä»¶æ€»å¤§å°
    char content[0];
    FileDownloadsRes()
    {
        head.type = FILE_DOWNLOADS_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 DownloadSuccessfullyRes {
    Head head;
    bool state = false;
    char fileName[256];
    long long fileSize;
    DownloadSuccessfullyRes()
    {
        head.type = DOWNLOAD_SUCCESSFULLY_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 ParsedLog {
    char timeStamp[64]; // æ—¶é—´æˆ³
    char deviceId[64]; // è®¾å¤‡ID
    char level[16];    // æ—¥å¿—级别
    char content[256];  // æ—¥å¿—内容
    char userId[64];    // ç”¨æˆ·ID
    char fileName[32];   //文件名
    char functionName[32];  //函数名
    int problemLine;    //产生错误行号
};

// æ—¥å¿—查询请求结构体
// æ—¥å¿—查询请求结构体
struct LogQueryReq {
    Head head;                 // æ•°æ®å¤´
    char keyWords[32];            // å­˜å‚¨å…³é”®å­—的数组
    // æ— å‚构造函数
    LogQueryReq() {
        head.type = LOGSEARCH_REQ;
        head.len = sizeof(LogQueryReq);
    }
    Head head;                      // æ•°æ®å¤´
    char timeStamp[64];             // æ—¶é—´æˆ³
    char content[256];           // æ—¥å¿—内容
    char level[16];                 //日志级别
    char deviceId[64];             // è®¾å¤‡ID
    // æ— å‚构造函数
    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 head;
    int status;                    // å“åº”状态 (如 0 è¡¨ç¤ºæˆåŠŸï¼Œéž 0 è¡¨ç¤ºå¤±è´¥)
    char errorMessage[256];        // é”™è¯¯ä¿¡æ¯ï¼ˆå¦‚果有）

    // æ— å‚构造函数
    LogQueryRes() {
        head.type = LOGSEARCH_RES;
        head.len = sizeof(LogQueryRes);
    }
    }
};