添加结构体

Administrator

2024-11-08 6c8e687de55119d16cc0a8e3393224f79be81f4c

添加结构体

 common.h

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

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,       // 更新文件下载成功的响应

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

};

@@ -110,13 +110,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 +125,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 +151,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 +165,12 @@
    }
};

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

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

// 按角色id更新权限信息请求
// 按角色id更新权限信息请求
typedef struct UpdatePmsReq {
    Head head;
    // 人员表主键id
    // 人员表主键id
    int id;
    int queryHistory;
    int loggerSearch;
@@ -233,74 +231,80 @@
    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];//设备类型
    char deviceName[32];//设备名称
    char deviceStatus[32];//设备状态
    char area[32];//地区
    double longitude;//经度
    double latitude;//纬度
    char purchasingTime[15];//购买时间
    char installTime[15];//安装时间
    char manufacturer[100];//厂家
    char deviceSerialNumber[32];//设备编码
    char deviceType[32];//设备类型
};
//添加设备
struct ADReq//添加请求
//添加设备
struct ADReq//添加请求
{
    Head head;
    DevicesInfo devInfo[0];
@@ -311,7 +315,7 @@

};

struct ADRes//添加响应
struct ADRes//添加响应
{
    Head head;
    int status;
@@ -321,8 +325,8 @@
    }

};
//修改设备
struct MDReq//修改请求
//修改设备
struct MDReq//修改请求
{
    Head head;
    DevicesInfo info;
@@ -331,27 +335,30 @@
        head.len = sizeof(MDReq);
    }
};
struct MDRes//修改响应
struct MDRes//修改响应
{
    Head head;
    DevicesInfo info;
    int status;
    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 +370,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 +388,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 +409,11 @@
        head.len = sizeof(MMIReq);
    }
};
//地图标注插入响应：
//地图标注插入响应：
struct MMIRes
{
    Head head;
    int status;//操作状态
    int status;//操作状态
    MarkInfo info[0];
    MMIRes() {
        head.type = MMI_RES;
@@ -415,8 +421,8 @@
    }
};

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

//大屏显示
//环境数据请求
//大屏显示
//环境数据请求
struct EnvironmentReq
{
    Head head;
    EnvironmentReq() {
        head.type = ENVIRONMENT_REQ;
        head.len = sizeof(EnvironmentReq);
    }
    Head head;
    char place[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;
    int status;
    Yield yield[0];
    YieldRes() {
        head.type = YIELD_RES;
        head.len = sizeof(YieldRes);
    }
    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;
    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;//月份
    double aOutput;//a产品月产量
    double bOutput;//b产品月产量
    double cOutput;//c产品月产量
    int date;//日期
    double aOutput;//a产品月产量
    double bOutput;//b产品月产量
    double cOutput;//c产品月产量
};

//添加一条生产计划的请求结构体
//添加生产计划的请求结构体
struct AddPdplanReq
{
    Head head;
@@ -704,19 +744,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 +766,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 +831,7 @@
};


//添加月产量的请求结构体
//添加日产量的请求结构体
struct AddMonoutputReq
{
    Head head;
@@ -804,18 +842,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 +864,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 +886,11 @@
    }
};

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



//历史查询分析

//历史查询分析

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() {
        // 初始化数据头
        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() {
        // 初始化数据头
        head.type = HISTORY_PRODUCE_REQ;
        head.len = sizeof(HistoryProReq);
        // 初始化查询条件字段
    }
};
// 历史查询环境信息请求结构体
// 历史查询月产量请求结构体
struct HistoryMonReq {
    Head head;
    //根据时间范围查询
    char startTime[32];
    char endTime[32];
    //关键字查询
    char keyWord[32];
    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() {
        // 初始化数据头
        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 +1044,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 +1060,10 @@
    }
};

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

// 更新文件下载成功的响应
// 更新文件下载成功的响应
struct DownloadSuccessfullyRes {
    Head head;
    bool state = false;
@@ -1124,41 +1101,41 @@
    }
};


//日志
//日志
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 +1145,5 @@




#endif // COMMON_H