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

wxx

2024-11-09 1485c3a9a48b454de8f2a5542a153b957ef60a52

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/ËÎ껕i/log/ÈÕÖ¾_ËÎ껕i_1107.doc

Binary files differ

 Client/Ö캽/code/kunlunclient/clientmainwindow.cpp

File was deleted

 Client/Ö캽/code/kunlunclient/clientmainwindow.h

File was deleted

 Client/Ö캽/code/kunlunclient/clientmainwindow.ui

File was deleted

 Client/Ö캽/code/kunlunclient/common.h

File was deleted

 Client/Ö캽/code/kunlunclient/kunlunclient.pro

File was deleted

 Client/Ö캽/code/kunlunclient/kunlunclient.pro.user

File was deleted

 Client/Ö캽/code/kunlunclient/logquery.cpp

File was deleted

 Client/Ö캽/code/kunlunclient/logquery.h

File was deleted

 Client/Ö캽/code/kunlunclient/logquery.ui

File was deleted

 Client/Ö캽/code/kunlunclient/main.cpp

File was deleted

 Client/Ö캽/code/·þÎñ¶Ë/LogSearch.cpp

File was deleted

 Client/Ö캽/code/·þÎñ¶Ë/LogSearch.h

File was deleted

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

Binary files differ

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

Binary files differ

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

Binary files differ

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

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/Àîתת/log/ÅäÖùÜÀí_Àîתת_1108.doc

Binary files differ

 Server/ÍõçûÔª/code/MysqlConn.cpp

@@ -11,8 +11,6 @@
        cout << "Failed to initialize MySQL." << endl;
        return;
    }
    // è®¾ç½®å­—符集
    if (m_mysql) mysql_set_character_set(m_mysql, "gbk");
    // ä½¿ç”¨å†™æ­»çš„参数连接数据库
    m_mysql = mysql_real_connect(m_mysql, "127.0.0.1", "root", "123456", "mayi_kunlun", 3306, nullptr, 0);
    if (!m_mysql) {
@@ -22,25 +20,13 @@
        m_mysql = nullptr;
    }
    // åˆå§‹åŒ– row_ å’Œ res_
    if (m_mysql) mysql_set_character_set(m_mysql, "gbk");
    m_row = nullptr;
    m_res = nullptr;
}
bool MysqlConn::isConnected() {
    return m_mysql != nullptr;
}
// è¿žæŽ¥æ•°æ®åº“
//bool MysqlConn::connect() {
//    string ip = "127.0.0.1";
//    string userName = "root";
//    string passwd = "123456";
//    string db = "mayi_kunlun";
//    int port = 3306;
//    m_mysql = mysql_real_connect(mysql_, ip.c_str(), userName.c_str(), passwd.c_str(), db.c_str(), port, nullptr, 0);
//    if (!m_mysql) {
//        return false;
//    }
//    return true;
//}

// é‡Šæ”¾èµ„源
MysqlConn::~MysqlConn() {
@@ -64,7 +50,6 @@
    }
    int paramCount = mysql_stmt_param_count(stmt);
    if (paramCount > 0) {
        // å¦‚果有参数，需要进行参数绑定等操作，这里暂不实现
        mysql_stmt_close(stmt);
        return false;
    }
@@ -91,6 +76,7 @@
    //int col_cnt = m_mysql->field_count;
    int col_cnt = mysql_field_count(m_mysql);
    cout << col_cnt << endl;
    MYSQL_ROW m_row;
    while (m_row = mysql_fetch_row(m_res)) {
        vector<string> tmp;
        for (int i = 0; i < col_cnt; i++) {
@@ -104,7 +90,7 @@
// æŸ¥è¯¢æ•°æ®åº“
bool MysqlConn::query(string sql) {
    freeRes();
    // å‚数化查询优化后的安全检查
     //参数化查询优化后的安全检查
    MYSQL_STMT* stmt = mysql_stmt_init(m_mysql);
    if (!stmt) {
        return false;

 Server/ÍõçûÔª/code/MysqlConn.h

@@ -51,4 +51,5 @@
    MYSQL_RES* m_res;
    MYSQL_ROW m_row;
    chrono::steady_clock::time_point  m_activeTime;

};

 Server/ÍõçûÔª/log/ÈÕ־ģ°å_ÍõçûÔª_1107.doc

Binary files differ

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

Binary files differ

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

Binary files differ

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

Binary files differ

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

Binary files differ

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

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,//日志查询响应

    //自动升级
    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,    //历史查询环境响应
    //版本管理
    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];//确认密码
    ResetReq() {
        head.type = RESET_REQ;
        head.len = sizeof(ResetReq);
    }
    Head head;
    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,264 +458,307 @@
    }
};

//大屏显示
//环境数据请求
//大屏显示
//环境数据请求
struct EnvironmentReq
{
    Head head;
    EnvironmentReq() {
        head.type = ENVIRONMENT_REQ;
        head.len = sizeof(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
{
    Head head;
    int status;
    Environment environment[0];
    EnvironmentRes() {
        head.type = ENVIRONMENT_RES;
        head.len = sizeof(EnvironmentRes);
    }
    Head head;
    int status;
    Environment environment[0];
        EnvironmentRes(){
        head.type = ENVIRONMENT_RES;
        head.len = sizeof(EnvironmentRes);
    }
};
//设备状态请求
//设备状态请求
struct DeviceStatusReq
{
    Head head;
    DeviceStatusReq() {
        head.type = DEVICESTATUS_REQ;
        head.len = sizeof(DeviceStatusReq);
    }
    Head head;
        DeviceStatusReq(){
        head.type = DEVICESTATUS_REQ;
        head.len = sizeof(DeviceStatusReq);
    }
};
//设备状态响应
struct DeviceStatus
//设备状态响应
struct Area
{
    double longitude;//经度
    double latitude;//纬度
    int deviceID;//设备编号
    char deviceName[32];//设备名称
    char deviceStatus[32];//设备状态
    double longitude;//经度
    double latitude;//纬度AA
    char area[64];//地区
};
struct DeviceStatus
{  
    int deviceID;//设备编号
    char deviceName[32];//设备名称
    double longitude;//经度
    double latitude;//纬度AA
    char deviceStatus[32];//设备状态
    char area[64];//地区
};
struct DeviceStatusRes
{
    Head head;
    int status;
    DeviceStatus deviceStatus[0];
    DeviceStatusRes() {
        head.type = DEVICESTATUS_RES;
        head.len = sizeof(DeviceStatusRes);
    }
    Head head;
    int status;
    DeviceStatus deviceStatus[0];
        DeviceStatusRes(){
        head.type = DEVICESTATUS_RES;
        head.len = sizeof(DeviceStatusRes);
    }
};
//操作日志请求
//操作日志请求
struct MovementRecordReq
{
    Head head;
    MovementRecordReq() {
        head.type = MOVEMENTRECORD_REQ;
        head.len = sizeof(MovementRecordReq);
    }
    Head head;
        MovementRecordReq(){
        head.type = MOVEMENTRECORD_REQ;
        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
{
    Head head;
    int status;
    MovementRecord movementRecord[0];
    MovementRecordRes() {
        head.type = MOVEMENTRECORD_RES;
        head.len = sizeof(MovementRecordRes);
    }
    Head head;
    int status;
    MovementRecord movementRecord[0];
        MovementRecordRes(){
        head.type = MOVEMENTRECORD_RES;
        head.len = sizeof(MovementRecordRes);
    }
};
//警报记录请求
//警报记录请求
struct AlarmRecordReq
{
    Head head;
    AlarmRecordReq() {
        head.type = ALARMRECORD_REQ;
        head.len = sizeof(AlarmRecordReq);
    }
    Head head;
        AlarmRecordReq(){
        head.type = ALARMRECORD_REQ;
        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
{
    Head head;
    int status;
    AlarmRecord alarmRecord[0];
    AlarmRecordRes() {
        head.type = ALARMRECORD_RES;
        head.len = sizeof(AlarmRecordRes);
    }
    Head head;
    int status;
    AlarmRecord alarmRecord[0];
        AlarmRecordRes(){
        head.type = ALARMRECORD_RES;
        head.len = sizeof(AlarmRecordRes);
    }
};
//煤矿产量请求
//煤矿产量请求
struct YieldReq
{
    Head head;
    YieldReq() {
        head.type = YIELD_REQ;
        head.len = sizeof(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
{
    Head head;
    Head head;
    int status;
    Yield yield[0];
        YieldRes(){
        head.type = YIELD_RES;
        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;
    Yield yield[0];
    YieldRes() {
        head.type = YIELD_RES;
        head.len = sizeof(YieldRes);
    }
    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];//环境数据类型
    float data;
    char time[32];//上传数据时间
    char device_name[32];
    char type[16];//环境数据类型
    float data;
    char time[32];//上传数据时间
};

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

//警报请求结构体
//警报请求结构体
struct WarningReq {
    Head head;
    warningInfo info[0];
    Head head;
    warningInfo info[0];

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

//数据请求结构体
//数据请求结构体
struct DataReq {
    Head head;
    dataInfo Info[0];
    Head head;
    dataInfo Info[0];

    DataReq() {
        head.type = DATA_REQ;
        head.len = sizeof(DataReq);
    }
    DataReq() {
        head.type = DATA_REQ;
        head.len = sizeof(DataReq);
    }
};

//阈值请求结构体
//阈值请求结构体
struct ThresholdReq {
    Head head;
    threshInfo threInfo[0];
    Head head;
    threshInfo threInfo[0];

    ThresholdReq() {
        head.type = THRESHOLD_REQ;
        head.len = sizeof(ThresholdReq);
    }
    ThresholdReq() {
        head.type = THRESHOLD_REQ;
        head.len = sizeof(ThresholdReq);
    }
};


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

    WarningRes() {
        head.type = WARNING_RES;
        head.len = sizeof(WarningRes);
    }
    WarningRes() {
        head.type = WARNING_RES;
        head.len = sizeof(WarningRes);
    }
};

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

    DataRes() {
        head.type = DATA_RES;
        head.len = sizeof(DataRes);
    }
    DataRes() {
        head.type = DATA_RES;
        head.len = sizeof(DataRes);
    }
};

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

    ThresholdRes() {
        head.type = THRESHOLD_RES;
        head.len = sizeof(ThresholdRes);
    }
    ThresholdRes() {
        head.type = THRESHOLD_RES;
        head.len = sizeof(ThresholdRes);
    }
};


//生产计划管理
//生产计划管理
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() {
        // åˆå§‹åŒ–数据头
        head.type = HISTORY_DEV_REQ;
        head.len = sizeof(HISTORY_DEV_REQ);
        // åˆå§‹åŒ–查询条件字段
    }
    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() {
        // åˆå§‹åŒ–数据头
        head.type = HISTORY_PRODUCE_REQ;
        head.len = sizeof(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 HistoryMonReq {
    Head head;
    //根据时间范围查询
    char startTime[32];
    char endTime[32];
    //关键字查询
    char keyWord[32];
    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() {
        // åˆå§‹åŒ–数据头
        head.type = HISTORY_ENV_REQ;
        head.len = sizeof(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);
    }
    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);
    }
    Head head;
    PdplanInfo pro[0];
    HistoryProRes() {
        // åˆå§‹åŒ–数据头
        head.type = HISTORY_PRODUCE_RES;
        head.len = sizeof(HistoryProRes);
    }
};
//查询环境信息响应结构体

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


//自动升级
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];
    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 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];   //文件名
    char functionName[32];  //函数名
    int problemLine;    //产生错误行号
    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
    // æ— å‚构造函数
    LogQueryReq() {
        head.type = LOGSEARCH_REQ;
        head.len = sizeof(LogQueryReq);
    }
    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

@@ -44,21 +44,22 @@
  `area` varchar(50) DEFAULT NULL,
  `longitude` double DEFAULT NULL,
  `latitude` double DEFAULT NULL,
  `purchasing_time` varchar(50) DEFAULT NULL,
  `install_time` varchar(50) DEFAULT NULL,
  `purchasing_time` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci DEFAULT NULL,
  `install_time` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci DEFAULT NULL,
  `manufacturer` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci DEFAULT NULL,
  `mark_name` varchar(50) DEFAULT NULL,
  `mark_time` varchar(50) DEFAULT NULL,
  `mark_status` int DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=11 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;
) ENGINE=InnoDB AUTO_INCREMENT=13 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;

-- æ­£åœ¨å¯¼å‡ºè¡¨  mayi_kunlun.devices_management_info çš„数据：~5 rows (大约)
INSERT INTO `devices_management_info` (`id`, `devices_name`, `devices_type`, `devices_serial_number`, `devices_status`, `area`, `longitude`, `latitude`, `purchasing_time`, `install_time`, `manufacturer`, `mark_name`, `mark_time`) VALUES
-- æ­£åœ¨å¯¼å‡ºè¡¨  mayi_kunlun.devices_management_info çš„数据：~6 rows (大约)
INSERT INTO `devices_management_info` (`id`, `devices_name`, `devices_type`, `devices_serial_number`, `devices_status`, `area`, `longitude`, `latitude`, `purchasing_time`, `install_time`, `manufacturer`, `mark_time`, `mark_status`) VALUES
    (6, '6', '6', '6', '6', '8', 8, 8, '8', '8', '8', NULL, NULL),
    (7, '1', '4', '4', '2', '6', 6, 9, '9', '2', '2', NULL, NULL),
    (8, '1', '2', '3', '2', '3', 2, 2, '3', '3', '1', NULL, NULL),
    (9, '10', '2', '3', '2', '3', 2, 2, '3', '3', '1', NULL, NULL),
    (10, '6', '5', '5', '5', '5', 5, 5, '5', '5', '5', NULL, NULL);
    (10, '6', '5', '5', '5', '5', 5, 5, '5', '5', '5', NULL, NULL),
    (12, '312', '231', '324', '1321', '312', 312, 321, '2024-01-01', '2024-01-01', '3124', NULL, NULL);

-- å¯¼å‡º  è¡¨ mayi_kunlun.month_info ç»“æž„
CREATE TABLE IF NOT EXISTS `month_info` (
@@ -143,7 +144,7 @@
  `id` int NOT NULL AUTO_INCREMENT,
  `department` varchar(50) DEFAULT NULL,
  `user_name` varchar(32) DEFAULT NULL,
  `password` varchar(32) DEFAULT NULL,
  `password` varchar(256) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci DEFAULT NULL,
  `user_no` varchar(10) DEFAULT NULL,
  `age` int DEFAULT NULL,
  `sex` varchar(10) DEFAULT NULL,
@@ -154,6 +155,7 @@
  `login_time` datetime DEFAULT NULL,
  `register_time` datetime DEFAULT NULL,
  PRIMARY KEY (`id`),
  UNIQUE KEY `unique_constraint_name` (`user_name`),
  KEY `role_id` (`role_id`),
  CONSTRAINT `user_info_ibfk_1` FOREIGN KEY (`role_id`) REFERENCES `role_info` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;
@@ -209,11 +211,3 @@
/*!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) */;
<<<<<<< HEAD
<<<<<<< HEAD
z
=======
SELECT id,devices_name,longitude,latitude,devices_status FROM devices_management;
>>>>>>> 2e420a0a40cc3fcc62bcb42ee6a25f4ad4f22dd3
=======
>>>>>>> d4c3d3a2b8a3e1507ca835870073df807cdb87df

 ±í.docx

Binary files differ