项目总结

lzx

2024-11-09 204ed8bff86568e57acae30cd905a4ba70f5f0f0

 common.h

@@ -5,99 +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, // 警报响应
   //警报管理
   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,//日志查询响应

};

@@ -106,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);
@@ -121,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()
   {
@@ -147,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;
@@ -162,12 +173,12 @@
   }
};

//注册响应
//注册响应
struct RegisterRes
{
   Head head;
   char userName[32];
   int status; // 注册状态
   int status; // 注册状态
   RegisterRes()
   {
      head.type = REGISTER_RES;
@@ -175,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;
@@ -202,8 +212,8 @@
   }
};

//权限管理
// 按员工编号、名字或职位查询人员权限信息请求
//权限管理
// 按员工编号、名字或职位查询人员权限信息请求
typedef struct QueryPmsReq {
   Head head;
   char userNo[32];
@@ -218,10 +228,10 @@
   }
} QueryPmsReq;

// 按角色id更新权限信息请求
// 按角色id更新权限信息请求
typedef struct UpdatePmsReq {
   Head head;
   // 人员表主键id
   // 人员表主键id
   int id;
   int queryHistory;
   int loggerSearch;
@@ -229,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];
@@ -307,7 +324,7 @@

};

struct ADRes//添加响应
struct ADRes//添加响应
{
   Head head;
   int status;
@@ -317,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;
@@ -359,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() {
@@ -378,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];
@@ -399,11 +424,11 @@
      head.len = sizeof(MMIReq);
   }
};
//地图标注插入响应：
//地图标注插入响应：
struct MMIRes
{
   Head head;
   int status;//操作状态
   int status;//操作状态
   MarkInfo info[0];
   MMIRes() {
      head.type = MMI_RES;
@@ -411,8 +436,8 @@
   }
};

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

//大屏显示
//环境数据请求
//大屏显示
//环境数据请求
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];//警报状态
};

struct dataInfo {
   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];//阈值修改时间
};

//警报请求结构体
struct WarningReq {
   Head head;

   float oxygenWarning;
   float carbonWarning;
   float tempWarning;
   float humidityWarning;
   warningInfo info[0];

   WarningReq() {
      head.type = WARNING_REQ;
@@ -590,59 +672,93 @@
   }
};


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

struct Data {
   float oxygen;   // 氧气浓度  
   float carbon;   // 一氧化碳浓度  
   float temp;     // 温度  
   float humidity; // 湿度 
};

// 警报响应结构体  
struct WarningRes {
//数据请求结构体
struct DataReq {
   Head head;
   int status;         // 响应状态（比如 0 表示成功，1 表示失败等）  
   const char* message; // 响应消息描述  
   dataInfo Info[0];

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

//生产计划管理
//阈值请求结构体
struct ThresholdReq {
   Head head;
   threshInfo threInfo[0];

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


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

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

struct DataRes {
   Head head;
   int status;// 响应状态
   dataInfo datainfo[0];

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

struct ThresholdRes {
   Head head;
   int status;// 响应状态
   threshInfo threInfo[0];

   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;
@@ -652,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;
@@ -675,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;
@@ -741,7 +855,7 @@
};


//添加月产量的请求结构体
//添加日产量的请求结构体
struct AddMonoutputReq
{
   Head head;
@@ -752,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;
@@ -774,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;
@@ -796,11 +910,11 @@
   }
};

//更改月产量的响应结构体
//更改日产量的响应结构体
struct UpdateMonoutputRes
{
   Head head;
   int status;//表示是否更新成功，0否1是
   int status;//表示是否更新成功，0否1是
   MonoutputInfo info[0];
   UpdateMonoutputRes() {
      head.type = UPDATE_MONOUTPUT_RES;
@@ -808,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;
@@ -836,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;
@@ -1016,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()
   {
@@ -1031,10 +1088,10 @@
   }
};

// 版本更新文件下载请求
// 版本更新文件下载请求
struct FileDownloadsReq {
   Head head;
   char versionId[64]; // 版本号
   char versionId[64]; // 版本号
   FileDownloadsReq()
   {
      head.type = FILE_DOWNLOADS_REQ;
@@ -1042,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()
   {
@@ -1059,7 +1116,7 @@
   }
};

// 更新文件下载成功的响应
// 更新文件下载成功的响应
struct DownloadSuccessfullyRes {
   Head head;
   bool state = false;
@@ -1072,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);
@@ -1116,4 +1253,5 @@




#endif // COMMON_H