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

lzz

2024-11-09 1f1d6d154cc4a6311b74032af525031851b872b6

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

 Client/¼½ºÆêÆ/document/×ܽá.docx

Binary files differ

 Client/¼½ºÆêÆ/log/×ܽá.docx

Binary files differ

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

Binary files differ

 Client/½ª¿É¸ý/document/ÏîÄ¿Ä£¿é½â¾öÎÊÌâ˼·.docx

Binary files differ

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

Binary files differ

 Client/Ö캽/document/×ܽá.docx

Binary files differ

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

Binary files differ

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

Binary files differ

 Client/ÍõöÎöÎ/document/µØͼ±ê×¢×ܽá.docx

Binary files differ

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

Binary files differ

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

Binary files differ

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

File was deleted

 Client/ÀèºëÁØ/log/É豸¹ÜÀíÄ£¿é×ܽá.docx

Binary files differ

 Server/ºú¼ÒÃ÷/document/×ܽá.docx

Binary files differ

 Server/ÂíÓ庼/document/ÏîÄ¿×ܽá_ÂíÓ庼.docx

Binary files differ

 common.h

@@ -5,103 +5,111 @@

enum TypeInfo {

    //注册登录
    LOGIN_REQ, // ç™»å½•è¯·æ±‚
    LOGIN_RES, // ç™»å½•å“åº”
    REGISTER_REQ, //注册请求
    REGISTER_RES, //注册响应
    RESET_REQ, //重置密码请求
    RESET_RES, //重置密码响应
    //注册登录
    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,     // æƒé™æ›´æ–°ç»“果响应体
    //权限管理
    QUERY_PMS_REQ,      // æŒ‰å‘˜å·¥ç¼–号、名字或职位查询人员权限信息请求
    UPDATE_PMS_REQ,     // æŒ‰è§’色id更新权限信息请求
    QUERY_PMS_RES,      // æŸ¥è¯¢äººå‘˜å’Œè§’色信息的响应结构体
    UPDATE_PMS_RES,     // æƒé™æ›´æ–°ç»“果响应体

    //设备管理
    AD_REQ,//添加设备请求
    AD_RES,//添加设备响应
    MD_REQ,//修改设备请求
    MD_RES,//修改设备响应
    QD_REQ,//查询设备请求
    QD_RES,//查询设备响应
    //设备管理
    AD_REQ,//添加设备请求
    AD_RES,//添加设备响应
    MD_REQ,//修改设备请求
    MD_RES,//修改设备响应
    QD_REQ,//查询设备请求
    QD_RES,//查询设备响应

    //地图标注
    MML_REQ,//地图标注加载请求
    MML_RES,//地图标注加载响应	
    MMI_REQ,//地图标注插入请求
    MMI_RES,//地图标注插入响应	
    MMD_REQ,//地图标注删除请求
    MMD_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_REQ,//环境数据请求
    ENVIRONMENT_RES,//环境数据响应
    DEVICESTATUS_REQ,//设备状态请求
    DEVICESTATUS_RES,//设备状态响应
    MOVEMENTRECORD_REQ,//操作日志请求
    MOVEMENTRECORD_RES,//操作日志响应
    ALARMRECORD_REQ,//警报记录请求
    ALARMRECORD_RES,//警报记录响应
    YIELD_REQ,//煤矿产量请求
    YIELD_RES,//煤矿产量响应
    COAL_MINE_RODER_REQ,//煤矿订单请求
    COAL_MINE_RODER_RES,//煤矿订单响应

    //警报管理
    WARNING_REQ, // è­¦æŠ¥è¯·æ±‚
    WARNING_RES, // è­¦æŠ¥å“åº”
    DATA_REQ,  // æ•°æ®è¯·æ±‚
    DATA_RES,  // æ•°æ®å“åº”
    THRESHOLD_REQ, //阈值请求
    THRESHOLD_RES, //阈值响应
    //警报管理
    WARNING_REQ, // è­¦æŠ¥è¯·æ±‚
    WARNING_RES, // è­¦æŠ¥å“åº”
    DATA_REQ,  // æ•°æ®è¯·æ±‚
    DATA_RES,  // æ•°æ®å“åº”
    THRESHOLD_REQ, //阈值请求
    THRESHOLD_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,//查询一条生产计划的响应结构体

    //生产计划管理
    ADD_PDPLAN_REQ,//添加生产计划的请求结构体
    ADD_PDPLAN_RES,//添加生产计划的响应结构体
    DEL_PDPLAN_REQ,//删除生产计划的请求结构体
    DEL_PDPLAN_RES,//删除生产计划的响应结构体
    UPDATE_PDPLAN_REQ,//更改生产计划的请求结构体
    UPDATE_PDPLAN_RES,//更改生产计划的响应结构体
    QUERY_PDPLAN_REQ,//查询生产计划的请求结构体
    QUERY_PDPLAN_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,//查询月产量的响应结构体
    ADD_MONOUTPUT_REQ,//添加日产量的请求结构体
    ADD_MONOUTPUT_RES,//添加日产量的响应结构体
    DEL_MONOUTPUT_REQ,//删除日产量的请求结构体
    DEL_MONOUTPUT_RES,//删除日产量的响应结构体
    UPDATE_MONOUTPUT_REQ,//更新日产量的请求结构体
    UPDATE_MONOUTPUT_RES,//更新日产量的响应结构体
    QUERY_MONOUTPUT_REQ,//查询日产量的请求结构体
    QUERY_MONOUTPUT_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,       // æ›´æ–°æ–‡ä»¶ä¸‹è½½æˆåŠŸçš„响应
    //历史查询
    HISTORY_DEV_REQ,        //历史查询硬件请求
    HISTORY_DEV_RES,        //历史查询硬件响应
    HISTORY_PRODUCE_REQ,    //历史查询生产请求
    HISTORY_PRODUCE_RES,    //历史查询生产响应
    HISTORY_ENV_REQ,    //历史查询环境请求
    HISTORY_ENV_RES,    //历史查询环境响应
    HISTORY_MON_REQ,    //历史查询月产量请求
    HISTORY_MON_RES,    //历史查询月产量响应

    //日志
    LOGSEARCH_REQ,//日志查询请求
    LOGSEARCH_RES,//日志查询响应
    
    //历史查询分析
    HISTORY_DEV_REQ,        //历史查询硬件请求
    HISTORY_DEV_RES,        //历史查询硬件响应
    HISTORY_PRODUCE_REQ,    //历史查询生产请求
    HISTORY_PRODUCE_RES,    //历史查询生产响应
    HISTORY_ENV_REQ,    //历史查询环境请求
    HISTORY_ENV_RES,    //历史查询环境响应
    //自动升级
    VERSION_UPDATE_REQ, // ç‰ˆæœ¬æ›´æ–°è¯·æ±‚
    VERSION_UPDATE_RES, // ç‰ˆæœ¬æ›´æ–°å“åº”
    FILE_DOWNLOADS_REQ, // ç‰ˆæœ¬æ›´æ–°æ–‡ä»¶ä¸‹è½½è¯·æ±‚
    FILE_DOWNLOADS_RES, // ç‰ˆæœ¬æ›´æ–°æ–‡ä»¶ä¸‹è½½å“åº”
    DOWNLOAD_SUCCESSFULLY_RES,       // æ›´æ–°æ–‡ä»¶ä¸‹è½½æˆåŠŸçš„响应
	
    //版本管理
    VERSION_NUM_REQ,  // ç‰ˆæœ¬å·è¯·æ±‚
    VERSION_NUM_RES,   // ç‰ˆæœ¬å·å“åº”
    UPLOAD_FILE_REQ, // ä¸Šä¼ æ–‡ä»¶çš„请求
    UPLOAD_FILE_RES, // ä¸Šä¼ æ–‡ä»¶çš„响应
    VERSION_INFOENTRY_REQ,       // ç‰ˆæœ¬ä¿¡æ¯å½•å…¥è¯·æ±‚
    VERSION_INFOENTRY_RES,       //版本信息录入响应

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

};

@@ -110,13 +118,13 @@
    int len;
};

//注册登录
//登录请求 
//注册登录
//登录请求 
struct LoginReq
{
    Head head;
    char userName[32];
    char password[32];
    char password[100];
    LoginReq() {
        head.type = LOGIN_REQ;
        head.len = sizeof(LoginReq);
@@ -125,24 +133,24 @@

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

//登录响应
//登录响应
struct LoginRes
{
    Head head;
    char userName[32];
    int status; // ç™»å½•çŠ¶æ€
    // ç™»å½•æˆåŠŸæ—¶ï¼Œè¯¥è´¦å·å¯¹åº”的权限组合
    int status; // ç™»å½•çŠ¶æ€
    // ç™»å½•æˆåŠŸæ—¶ï¼Œè¯¥è´¦å·å¯¹åº”的权限组合
    Permission per;
    LoginRes()
    {
@@ -151,14 +159,13 @@
    }
};

//注册请求 
//注册请求 
struct RegisterReq
{
    Head head;
    char userName[32];
    char password[32];
    char email[50];
    char capcha[10];//验证码
    char password[100];
    char email[32];
    char telephone[32];
    RegisterReq() {
        head.type = REGISTER_REQ;
@@ -166,12 +173,12 @@
    }
};

//注册响应
//注册响应
struct RegisterRes
{
    Head head;
    char userName[32];
    int status; // æ³¨å†ŒçŠ¶æ€
    int status; // æ³¨å†ŒçŠ¶æ€
    RegisterRes()
    {
        head.type = REGISTER_RES;
@@ -179,26 +186,25 @@
    }
};

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

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

//权限管理
// æŒ‰å‘˜å·¥ç¼–号、名字或职位查询人员权限信息请求
//权限管理
// æŒ‰å‘˜å·¥ç¼–号、名字或职位查询人员权限信息请求
typedef struct QueryPmsReq {
    Head head;
    char userNo[32];
@@ -222,10 +228,10 @@
    }
} QueryPmsReq;

// æŒ‰è§’色id更新权限信息请求
// æŒ‰è§’色id更新权限信息请求
typedef struct UpdatePmsReq {
    Head head;
    // äººå‘˜è¡¨ä¸»é”®id
    // äººå‘˜è¡¨ä¸»é”®id
    int id;
    int queryHistory;
    int loggerSearch;
@@ -233,74 +239,81 @@
    int devManage;
    int productPlan;
    int warningManage;
    int versionManage; //版本管理
    int admin; //系统管理员
    int versionManage; //版本管理
    int admin; //系统管理员

    char permissonType[32];
    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 versionManage; //版本管理
    int warningManage;
    int admin; //系统管理员

    int id;

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

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

    char department[32];
    char loginTime[32];
    char registerTime[32];
} PmsRes;

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

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

} UpdatePmsRes;
};




//设备管理

//设备管理
struct DevicesInfo
{
    char deviceName[32];//设备名称
    char deviceStatus[32];//设备状态
    char area[32]; // åœ°åŒº
    double longitude;//经度
    double latitude;//纬度
    char purchasingTime[15];//购买时间
    char installTime[15];//安装时间
    char manufacturer[100];//厂家
    char devicesSerialNumber[32];//设备编码
    char devicesType[32];//设备类型
    int id;//设备ID
    char deviceName[32];//设备名称
    char deviceType[32];//设备类型
    char deviceSerialNumber[32];//设备编码
    char deviceStatus[32];//设备状态
    char area[100];//地区
    double longitude;//经度
    double latitude;//纬度
    char purchasingTime[15];//购买时间
    char installTime[15];//安装时间
    char manufacturer[100];//厂家
};
//添加设备
struct ADReq//添加请求
//添加设备
struct ADReq//添加请求
{
    Head head;
    DevicesInfo devInfo[0];
@@ -311,7 +324,7 @@

};

struct ADRes//添加响应
struct ADRes//添加响应
{
    Head head;
    int status;
@@ -321,37 +334,46 @@
    }

};
//修改设备
struct MDReq//修改请求
//修改设备
struct MDReq//修改请求
{
    Head head;
    DevicesInfo info;
    char condition[32];
    char modifiedContent[100];
    double laOrLo;
    MDReq() {
        head.type = MD_REQ;
        head.len = sizeof(MDReq);
    }
};
struct MDRes//修改响应
struct MDRes//修改响应
{
    Head head;
    DevicesInfo info;
    int status;
    char conditon[32];
    char modifiedContent[100];
    double laOrLo;
    MDRes() {
        head.type = MD_RES;
        head.len = sizeof(MDRes);
    }
};
//查询设备
struct QDReq//查询请求
//查询设备
struct QDReq//查询请求
{
    Head head;
    DevicesInfo info;
    char buyTimeBegin[15];
    char buyTimeEnd[15];
    char installTimeBegin[15];
    char installTimeEnd[15];
    QDReq() {
        head.type = QD_REQ;
        head.len = sizeof(QDReq);
    }
};
struct QDRes//查询响应
struct QDRes//查询响应
{
    Head head;
    int status;
@@ -363,18 +385,17 @@
};


//地图标注
//地图标注
struct MarkInfo
{
    int markId;//标注点id
    double latitude;//纬度
    double longitude;//经度
    int deviceId;//设备ID
    int deviceStatus;//设备状态
    char deviceName[32];//设备名称
    char markId[32];//标注点id设备编号
    double latitude;//纬度
    double longitude;//经度
    char deviceStatus[32];//设备状态
    char deviceName[32];//设备名称
};
//地图标注加载请求
struct MMLReq//地图
//地图标注加载请求
struct MMLReq//地图
{
    Head head;
    MMLReq() {
@@ -382,19 +403,19 @@
        head.len = sizeof(MMLReq);
    }
};
//地图标注加载响应：
//地图标注加载响应：
struct MMLRes
{
    Head head;
    int status;//操作状态
    int status;//操作状态
    MarkInfo info[0];
    MMLRes() {
        head.type = MML_RES;
        head.len = sizeof(MMLRes);
    }
};
//地图标注插入请求
struct MMIReq//地图
//地图标注插入请求
struct MMIReq//地图
{
    Head head;
    MarkInfo info[0];
@@ -403,11 +424,11 @@
        head.len = sizeof(MMIReq);
    }
};
//地图标注插入响应：
//地图标注插入响应：
struct MMIRes
{
    Head head;
    int status;//操作状态
    int status;//操作状态
    MarkInfo info[0];
    MMIRes() {
        head.type = MMI_RES;
@@ -415,8 +436,8 @@
    }
};

//地图标注删除请求
struct MMDReq//地图
//地图标注删除请求
struct MMDReq//地图
{
    Head head;
    MarkInfo info[0];
@@ -425,11 +446,11 @@
        head.len = sizeof(MMDReq);
    }
};
//地图标注删除响应：
//地图标注删除响应：
struct MMDRes
{
    Head head;
    int status;//操作状态
    int status;//操作状态
    MarkInfo info[0];
    MMDRes() {
        head.type = MMD_RES;
@@ -437,25 +458,23 @@
    }
};

//大屏显示
//环境数据请求
//大屏显示
//环境数据请求
struct EnvironmentReq
{
    Head head;
    char place[32];//地区
    char nowTime[32];//当时时间
    EnvironmentReq() {
        head.type = ENVIRONMENT_REQ;
        head.len = sizeof(EnvironmentReq);
    }
};
//环境数据响应
//环境数据响应
struct Environment
{
    double longitude;//经度
    double latitude;//纬度
    float temp;//温度
    float humidity;//湿度
    float oxygen;//氧气浓度
    float carbon;//一氧化碳浓度
    char dataType[32];//数据类型
    float envdata;//数据
};
struct EnvironmentRes
{
@@ -467,7 +486,7 @@
        head.len = sizeof(EnvironmentRes);
    }
};
//设备状态请求
//设备状态请求
struct DeviceStatusReq
{
    Head head;
@@ -476,14 +495,21 @@
        head.len = sizeof(DeviceStatusReq);
    }
};
//设备状态响应
//设备状态响应
struct Area
{
    double longitude;//经度
    double latitude;//纬度AA
    char area[64];//地区
};
struct DeviceStatus
{
    double longitude;//经度
    double latitude;//纬度
    int deviceID;//设备编号
    char deviceName[32];//设备名称
    char deviceStatus[32];//设备状态
    int deviceID;//设备编号
    char deviceName[32];//设备名称
    double longitude;//经度
    double latitude;//纬度AA
    char deviceStatus[32];//设备状态
    char area[64];//地区
};
struct DeviceStatusRes
{
@@ -495,7 +521,7 @@
        head.len = sizeof(DeviceStatusRes);
    }
};
//操作日志请求
//操作日志请求
struct MovementRecordReq
{
    Head head;
@@ -504,15 +530,15 @@
        head.len = sizeof(MovementRecordReq);
    }
};
//操作日志响应
//操作日志响应
struct MovementRecord
{
    double longitude;//经度
    double latitude;//纬度
    char userName;//操作用户名
    char operateTime[32];//操作时间
    char deviceName[32];//操作设备
    char movement[256];//操作描述
    char userName[32];//操作用户名
    char operateTime[32];//操作时间
    char deviceName[32];//操作设备
    double longitude;//经度
    double latitude;//纬度
    char movement[256];//操作描述
};
struct MovementRecordRes
{
@@ -524,7 +550,7 @@
        head.len = sizeof(MovementRecordRes);
    }
};
//警报记录请求
//警报记录请求
struct AlarmRecordReq
{
    Head head;
@@ -533,14 +559,14 @@
        head.len = sizeof(AlarmRecordReq);
    }
};
//警报记录响应
//警报记录响应
struct AlarmRecord
{
    double longitude;//经度
    double latitude;//纬度
    char alarmTime[32];//警报时间
    char alarmtype[32];//处理时间
    char alarmContent[256];//警报内容
    char alarmTime[32];//警报时间
    char alarmtype[32];//处理状态
    double longitude;//经度
    double latitude;//纬度
    char alarmContent[256];//警报内容
};
struct AlarmRecordRes
{
@@ -552,20 +578,23 @@
        head.len = sizeof(AlarmRecordRes);
    }
};
//煤矿产量请求
//煤矿产量请求
struct YieldReq
{
    Head head;
    char startTime[64];//开始时间
    char finishTime[64];//结束时间
    YieldReq() {
        head.type = YIELD_REQ;
        head.len = sizeof(YieldReq);
    }
};
//煤矿产量响应
//煤矿产量响应
struct Yield
{
    int month;//月份
    int output;//产量
    double sumA;//A产量
    double sumB;//B产量
    double sumC;//C产量
};
struct YieldRes
{
@@ -577,33 +606,62 @@
        head.len = sizeof(YieldRes);
    }
};
//订单查询请求
struct CoaMinRodReq
{
    Head head;
    char planName[64];//订单名
        CoaMinRodReq(){
        head.type = COAL_MINE_RODER_REQ;
        head.len = sizeof(CoaMinRodReq);
    }
};
//订单查询响应
struct CoaMinRod
{
    char startTime[64];//起始日期
    char finishTime[64];//交付日期
    char proName[64];//产品名
    double planPro;//计划生产量
    double actPro;//实际生产量
};
struct CoaMinRodRes
{
    Head head;
    int status;
    CoaMinRod coaMinRod[0];
        CoaMinRodRes(){
        head.type = COAL_MINE_RODER_RES;
        head.len = sizeof(CoaMinRodReS);
    }
};

//警报管理
//警报管理
struct warningInfo {
    char device_name[32];//设备名称
    char des[32];//警报描述
    char time[32];//警报时间
    float warningdata;//警报数据
    char type[16];//警报类型
    char status[16];//警报状态
    char device_name[32];//设备名称
    char des[32];//警报描述
    char time[32];//警报时间
    float warningdata;//警报数据
    char type[16];//警报类型
    char status[16];//警报状态
};

struct dataInfo {
    char device_name[32];
    char type[16];//环境数据类型
    char type[16];//环境数据类型
    float data;
    char time[32];//上传数据时间
    char time[32];//上传数据时间
};

struct threshInfo {
    char device_name[32];
    char type[16];//环境类型
    float min;//最小阈值
    float max;//最大阈值
    char time[32];//阈值修改时间
    char type[16];//环境类型
    float min;//最小阈值
    float max;//最大阈值
    char time[32];//阈值修改时间
};

//警报请求结构体
//警报请求结构体
struct WarningReq {
    Head head;
    warningInfo info[0];
@@ -614,7 +672,7 @@
    }
};

//数据请求结构体
//数据请求结构体
struct DataReq {
    Head head;
    dataInfo Info[0];
@@ -625,7 +683,7 @@
    }
};

//阈值请求结构体
//阈值请求结构体
struct ThresholdReq {
    Head head;
    threshInfo threInfo[0];
@@ -637,10 +695,10 @@
};


//警报响应结构体
//警报响应结构体
struct WarningRes {
    Head head;
    int status;// å“åº”状态
    int status;// å“åº”状态
    warningInfo warninginfo[0];

    WarningRes() {
@@ -651,7 +709,7 @@

struct DataRes {
    Head head;
    int status;// å“åº”状态
    int status;// å“åº”状态
    dataInfo datainfo[0];

    DataRes() {
@@ -662,7 +720,7 @@

struct ThresholdRes {
    Head head;
    int status;// å“åº”状态
    int status;// å“åº”状态
    threshInfo threInfo[0];

    ThresholdRes() {
@@ -672,29 +730,35 @@
};


//生产计划管理
//生产计划管理
struct PdplanInfo
{
    int planId;//订单编号
    char planName[32];//订单名字
    char startDate[32];//起始日期
    char closingDate[32];//交付日期
    char pdName[8];//产品名
    double plannedPd;//计划生产量
    double actualPd;//实际生产量
    double progress;//生产进度
    int finishOntime;//是否按期完成
    char planName[32];//订单划名字
    char startDate[32];//起始日期
    char closingDate[32];//交付日期
    char pdName[8];//产品名
    double plannedPd;//计划生产量
    double actualPd;//实际生产量
    double progress;//生产进度
    int finishOntime;//是否按期完成
};

struct MonoutputInfo
{
    int month;//月份
<<<<<<< HEAD
    char month[32];//月份
    double aOutput;//a产品月产量
    double bOutput;//b产品月产量
    double cOutput;//c产品月产量
=======
    char date[32];//日期
    double aOutput;//a产品月产量
    double bOutput;//b产品月产量
    double cOutput;//c产品月产量
>>>>>>> 83817169914cd859e4a7e0b5f0685dd0c072a974
};

//添加一条生产计划的请求结构体
//添加生产计划的请求结构体
struct AddPdplanReq
{
    Head head;
@@ -704,19 +768,18 @@
        head.len = sizeof(AddPdplanReq);
    }
};

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

//删除一条生产计划的请求结构体
//删除生产计划的请求结构体
struct DelPdplanReq
{
    Head head;
@@ -727,64 +790,63 @@
    }
};

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

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

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

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

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


//添加月产量的请求结构体
//添加日产量的请求结构体
struct AddMonoutputReq
{
    Head head;
@@ -804,18 +866,18 @@
    }
};

//添加月产量的响应结构体
//添加日产量的响应结构体
struct AddMonoutputRes
{
    Head head;
    int status;//表示是否添加成功，0否1是
    int status;//表示是否添加成功，0否1是
    AddMonoutputRes() {
        head.type = ADD_MONOUTPUT_RES;
        head.len = sizeof(AddMonoutputRes);
    }
};

//删除月产量的请求结构体
//删除日产量的请求结构体
struct DelMonoutputReq
{
    Head head;
@@ -826,18 +888,18 @@
    }
};

//删除月产量的响应结构体
//删除日产量的响应结构体
struct DelMonoutputRes
{
    Head head;
    int status;//表示是否删除成功，0否1是
    int status;//表示是否删除成功，0否1是
    DelMonoutputRes() {
        head.type = DEL_MONOUTPUT_RES;
        head.len = sizeof(DelMonoutputRes);
    }
};

//更改月产量的请求结构体.
//更改日产量的请求结构体.
struct UpdateMonoutputReq
{
    Head head;
@@ -848,11 +910,11 @@
    }
};

//更改月产量的响应结构体
//更改日产量的响应结构体
struct UpdateMonoutputRes
{
    Head head;
    int status;//表示是否更新成功，0否1是
    int status;//表示是否更新成功，0否1是
    MonoutputInfo info[0];
    UpdateMonoutputRes() {
        head.type = UPDATE_MONOUTPUT_RES;
@@ -860,25 +922,26 @@
    }
};

//查询月产量的请求结构体
//查询日产量的请求结构体
struct QueryMonoutputReq
{
    Head head;
    int month;//月份
    double aOutput;//a产品月产量
    double bOutput;//b产品月产量
    double cOutput;//c产品月产量
    int date;//日期
    double aOutput;//a产品月产量
    double bOutput;//b产品月产量
    double cOutput;//c产品月产量

    QueryMonoutputReq() {
        head.type = QUERY_MONOUTPUT_REQ;
        head.len = sizeof(QueryMonoutputReq);
    }
};

//查询月产量的响应结构体
//查询日产量的响应结构体
struct QueryMonoutputRes
{
    Head head;
    int status;//表示是否添加成功，0否1是
    int status;//表示是否添加成功，0否1是
    MonoutputInfo info[0];
    QueryMonoutputRes() {
        head.type = QUERY_MONOUTPUT_RES;
@@ -888,179 +951,120 @@



//历史查询分析

//历史查询分析

struct warningInfo {
    int device_id;
    char des[32];
    char time[32];
    float data;
    char type[16];
    char status[16];
};
// åŽ†å²æŸ¥è¯¢è®¾å¤‡ä¿¡æ¯è¯·æ±‚结构体
//历史查询
// åŽ†å²æŸ¥è¯¢è®¾å¤‡ä¿¡æ¯è¯·æ±‚结构体
struct HistoryDevReq {
    Head head;
    //根据时间范围查询
    //根据时间范围查询
    char startTime[32];
    char endTime[32];
    //关键字查询
    //关键字查询
    char keyWord[32];
    HistoryDevReq() {
        // åˆå§‹åŒ–数据头
        // åˆå§‹åŒ–数据头
        memset(this,0,sizeof(HistoryDevReq));
        head.type = HISTORY_DEV_REQ;
        head.len = sizeof(HISTORY_DEV_REQ);
        // åˆå§‹åŒ–查询条件字段
        // åˆå§‹åŒ–查询条件字段
    }
};
// åŽ†å²æŸ¥è¯¢ç”Ÿäº§è®¡åˆ’请求结构体
// åŽ†å²æŸ¥è¯¢ç”Ÿäº§è®¡åˆ’请求结构体
struct HistoryProReq {
    Head head;
    //根据时间范围查询
    //根据时间范围查询
    char startTime[32];
    char endTime[32];
    //关键字查询
    //关键字查询
    char keyWord[32];
    HistoryProReq() {
        // åˆå§‹åŒ–数据头
        // åˆå§‹åŒ–数据头
        memset(this,0,sizeof(HistoryProReq ));
        head.type = HISTORY_PRODUCE_REQ;
        head.len = sizeof(HistoryProReq);
        // åˆå§‹åŒ–查询条件字段
        // åˆå§‹åŒ–查询条件字段
    }
};
// åŽ†å²æŸ¥è¯¢çŽ¯å¢ƒä¿¡æ¯è¯·æ±‚结构体
struct HistoryEnvReq {
// åŽ†å²æŸ¥è¯¢æœˆäº§é‡è¯·æ±‚结构体
struct HistoryMonReq {
    Head head;
    //根据时间范围查询
    //根据时间范围查询
    char startTime[32];
    char endTime[32];
    //关键字查询
    //关键字查询
    char keyWord[32];
    HistoryEnvReq() {
        // åˆå§‹åŒ–数据头
        head.type = HISTORY_ENV_REQ;
        head.len = sizeof(HistoryEnvReq);
        // åˆå§‹åŒ–查询条件字段
    HistoryMonReq() {
        // åˆå§‹åŒ–数据头
       memset(this,0,sizeof(HistoryMonReq));
        head.type = HISTORY_MON_REQ;
        head.len = sizeof(HistoryMonReq);
        // åˆå§‹åŒ–查询条件字段
    }
};

//查询设备信息响应结构体
// åŽ†å²æŸ¥è¯¢çŽ¯å¢ƒä¿¡æ¯è¯·æ±‚结构体
struct HistoryEnvReq {
    Head head;
    //根据时间范围查询
    char startTime[32];
    char endTime[32];
    //关键字查询
    char keyWord[32];
    HistoryEnvReq() {
        // åˆå§‹åŒ–数据头
        memset(this,0,sizeof(HistoryEnvReq));
        head.type = HISTORY_ENV_REQ;
        head.len = sizeof(HistoryEnvReq);
        // åˆå§‹åŒ–查询条件字段
    }
};
//查询设备信息响应结构体
struct HistoryDevRes {
    Head head;
    DevicesInfo dev[0];
    HistoryDevRes() {
        // åˆå§‹åŒ–数据头
        // åˆå§‹åŒ–数据头
        head.type = HISTORY_DEV_RES;
        head.len = sizeof(HistoryDevRes);
    }
};
//查询生产计划响应结构体
//查询生产计划响应结构体
struct HistoryProRes {
    Head head;
    PdplanInfo pro[0];
    HistoryProRes() {
        // åˆå§‹åŒ–数据头
        // åˆå§‹åŒ–数据头
        head.type = HISTORY_PRODUCE_RES;
        head.len = sizeof(HistoryProRes);
    }
};
//查询环境信息响应结构体

//查询环境信息响应结构体
struct HistoryEnvRes {
    Head head;
    warningInfo env[0];
    dataInfo env[0];
    HistoryEnvRes() {
        // åˆå§‹åŒ–数据头
        // åˆå§‹åŒ–数据头
        head.type = HISTORY_ENV_RES;
        head.len = sizeof(HistoryEnvRes);
    }
};


//自动升级
struct VersionNumReq        // ç‰ˆæœ¬å·è¯·æ±‚
{
//查询月产量
struct HistoryMonRes {
    Head head;
    VersionNumReq() {
        head.type = VERSION_NUM_REQ;
        head.len = sizeof(VersionNumReq);
    MonoutputInfo  mon[0];
    HistoryMonRes() {
        // åˆå§‹åŒ–数据头
        head.type = HISTORY_MON_RES;
        head.len = sizeof(HistoryMonRes);
    }
};

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

// æ–‡ä»¶ä¼ è¾“
struct FileInfo
{
    char fileName[256];
    long long fileSize;
    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 fileName[256];
    long long file_size;
    UploadFileRes()
    {
        head.type = UPLOAD_FILE_RES;
        head.len = sizeof(UploadFileRes);
    }
};

// ç‰ˆæœ¬ä¿¡æ¯å½•å…¥
// è¯·æ±‚
struct VersionInfoEntryReq {
    Head head;
    char versionId[64]; // ç‰ˆæœ¬å·
    char versionIdOld[64]; // ä¸Šä¸€ä¸ªç‰ˆæœ¬å·
    int fileNum;
    char context[0];        //包含下载文件信息

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

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

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

    char curVersionId[64]; // ç‰ˆæœ¬å·
    char curVersionId[64]; // ç‰ˆæœ¬å·
    VersionUpdateReq()
    {
        head.type = VERSION_UPDATE_REQ;
@@ -1068,13 +1072,14 @@
    }
};

// ç‰ˆæœ¬æ›´æ–°å“åº”

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

    VersionUpdateRes()
    {
@@ -1083,10 +1088,10 @@
    }
};

// ç‰ˆæœ¬æ›´æ–°æ–‡ä»¶ä¸‹è½½è¯·æ±‚
// ç‰ˆæœ¬æ›´æ–°æ–‡ä»¶ä¸‹è½½è¯·æ±‚
struct FileDownloadsReq {
    Head head;
    char versionId[64]; // ç‰ˆæœ¬å·
    char versionId[64]; // ç‰ˆæœ¬å·
    FileDownloadsReq()
    {
        head.type = FILE_DOWNLOADS_REQ;
@@ -1094,15 +1099,15 @@
    }
};

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

// æ›´æ–°æ–‡ä»¶ä¸‹è½½æˆåŠŸçš„响应
// æ›´æ–°æ–‡ä»¶ä¸‹è½½æˆåŠŸçš„响应
struct DownloadSuccessfullyRes {
    Head head;
    bool state = false;
@@ -1124,41 +1129,121 @@
    }
};


//日志
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 VersionNumReq        // ç‰ˆæœ¬å·è¯·æ±‚
{
    Head head;
    VersionNumReq() {
        head.type = VERSION_NUM_REQ;
        head.len = sizeof(VersionNumReq);
    }
};

// æ—¥å¿—查询请求结构体
// æ—¥å¿—查询请求结构体
struct VersionNumRes        // ç‰ˆæœ¬å·å“åº”
{
    Head head;
    char versionId[64]; // ç‰ˆæœ¬å·
    VersionNumRes() {
        head.type = VERSION_NUM_RES;
        head.len = sizeof(VersionNumRes);
    }
};

// æ–‡ä»¶ä¼ è¾“
struct FileInfo
{
    char fileName[256];
    long long fileSize;
    char s_filepath[128];
};

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

struct 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 versionId[64]; // ç‰ˆæœ¬å·
    char versionIdOld[64]; // ä¸Šä¸€ä¸ªç‰ˆæœ¬å·
    int fileNum;
    char c_filepath[32];    //服务器放最新版本的路径
    char versionDescription[256]; //更新内容
    char versionCreattime[32]; // æ›´æ–°æ—¶é—´
    FileInfo fileInfo[0] ;        //包含下载文件信息

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

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

//日志
struct ParsedLog {
    char timeStamp[64]; // æ—¶é—´æˆ³
    char deviceId[64]; // è®¾å¤‡ID
    char level[16];    // æ—¥å¿—级别
    char content[256];  // æ—¥å¿—内容
    char userId[64];    // ç”¨æˆ·ID
    char fileName[32];   //文件名
    int problemLine;    //产生错误行号
    char functionName[32];  //函数名
};

// æ—¥å¿—查询请求结构体
struct LogQueryReq {
    Head head;                      // æ•°æ®å¤´
    char timeStamp[64];             // æ—¶é—´æˆ³
    char content[256];           // æ—¥å¿—内容
    char level[16];                 //日志级别
    char deviceId[64];             // è®¾å¤‡ID
    // æ— å‚构造函数
    Head head;                      // æ•°æ®å¤´
    int logLimit;                   //服务端发送日志数量限制
    char startTime[20]; // æ ¹æ®å®žé™…需要调整大小
    char endTime[20];   // æ ¹æ®å®žé™…需要调整大小
    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];        // é”™è¯¯ä¿¡æ¯ï¼ˆå¦‚果有）
    int status;                    // å“åº”状态 (如 1 è¡¨ç¤ºæˆåŠŸ)
    ParsedLog parsedLog[0];  // ä½¿ç”¨æŸ”性数组存储查询结果

    // æ— å‚构造函数
    // æ— å‚构造函数
    LogQueryRes() {
        head.type = LOGSEARCH_RES;
        head.len = sizeof(LogQueryRes);
@@ -1168,4 +1253,5 @@




#endif // COMMON_H

 kunlun.sql

@@ -204,10 +204,12 @@
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='警报数据';

-- æ­£åœ¨å¯¼å‡ºè¡¨  mayi_kunlun.warning_info çš„数据：~0 rows (大约)

<<<<<<< HEAD
=======
/*!40103 SET TIME_ZONE=IFNULL(@OLD_TIME_ZONE, 'system') */;
/*!40101 SET SQL_MODE=IFNULL(@OLD_SQL_MODE, '') */;
/*!40014 SET FOREIGN_KEY_CHECKS=IFNULL(@OLD_FOREIGN_KEY_CHECKS, 1) */;
/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;
/*!40111 SET SQL_NOTES=IFNULL(@OLD_SQL_NOTES, 1) */;
>>>>>>> 3037ddc8c6e0519a9e1ae6d0a9cc002033047a02