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

lzh

2024-11-01 74a7faf2cbde2efdc02df4f96cf4e15a33b5750c

 common.h

New file
@@ -0,0 +1,714 @@
#ifndef COMMON_H
#define COMMON_H
#include  <string.h>
#include <vector>

enum TypeInfo{

    //注册登录
   LOGIN_REQ, // 登录请求
   LOGIN_RES, // 登录响应
   REGISTER_REQ, //注册请求
   REGISTER_RES, //注册响应
   RESET_REQ, //重置密码请求
   RESET_RES, //重置密码响应

    //历史查询分析
    HISTORY_QUERY_REQ, // 历史查询请求
    HISTORY_QUERY_RES, // 历史查询响应

    //权限管理
    QUERY_PMS_REQ,      // 按员工编号、名字或职位查询人员权限信息请求
    UPDATE_PMS_REQ,     // 按角色id更新权限信息请求
    QUERY_PMS_RES,      // 查询人员和角色信息的响应结构体
    UPDATE_PMS_RES,     // 权限更新结果响应体

    //地图标注
    MAPMARK_REQ,//地图标注请求
   MAPMARK_RES//地图标注响应

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

    //生产计划管理
    ADDPRODUCTIONPLAN_REQ,//添加一行数据的请求结构体
   ADDPRODUCTIONPLAN_RES,//添加一行数据的响应结构体
   UPDATEPRODUCTIONPLANQUANTITY_REQ,// 更新生产计划（计划生产量）的请求结构体
   UPDATEPRODUCTIONPLANQUANTITY_RES,// 更新生产计划（计划生产量）的响应结构体
   UPDATEPRODUCTIONPLANLOG_REQ,//更新生产计划（日志）的请求结构体
   UPDATEPRODUCTIONPLANLOG_RES,//更新生产计划（日志）的响应结构体
   PRODUCTIONPLAN_REQ,// 查询生产计划信息的请求结构体
   PRODUCTIONPLAN_RES,// 查询生产计划信息的响应结构体
   FORRECENTFOURTEENPRODUCTIONPLANS_REQ,//查询近十四条的请求结构体
   FORRECENTFOURTEENPRODUCTIONPLANS_RES //查询近十四条的响应结构体

    //自动升级&版本管理
    VERSIONNUM_REQ,  // 版本号请求
    VERSIONNUM_RES,   // 版本号响应
    UPLOAD_FILE_REQ, // 上传文件的请求
    UPLOAD_FILE_RES, // 上传文件的响应
    VERSIONINFOENTRY_REQ,       // 版本信息录入请求
    VERSIONINFOENTRY_RES,       //版本信息录入响应
    VERSIONUPDATE_REQ, // 版本更新请求
    VERSIONUPDATE_RES, // 版本更新响应
    FILEDOWNLOADS_REQ, // 版本更新文件下载请求
    FILEDOWNLOADS_RES, // 版本更新文件下载响应
    DOWNLOADSUCCESSFULLY_RES        // 更新文件下载成功的响应

    //日志
    LOGSEARCH_REQ;//日志查询请求
   LOGSEARCH_RES;//日志查询响应
		
};

struct Head{
    int type;
    int len;
};

//登录请求 
   struct LoginReq
   {
      Head head;
      char user_name[32];
      char password[32];
      LoginReq(){
         head.type = LOGIN_REQ;
         head.len = sizeof(LoginReq);
      }
   };
	
   struct Permission
   {
      int admin;
      int log_search; //日志查询
      int history; //历史记录
      int map_change;//地图
      int version_manage; // 版本管理
      int warning; //警报
      int device_manage; //设备管理
      int pro_plan;//生产计划
      char role_name[32]; // 角色名
   };
	
   //登录响应
   struct LoginRes
   {
      Head head;
      char user_name[32];
      int status; // 登录状态
      // 登录成功时，该账号对应的权限组合
      Permission per;
      LoginRes()
      {
         head.type = LOGIN_RES;
         head.len = sizeof(LoginRes);
      };
   };

   //注册请求 
   struct RegisterReq
   {
      Head head;
      char user_name[32];
      char password[32];
      char email[50];
      int telephone;
      RegisterReq(){
         head.type = REGISTER_REQ;
         head.len = sizeof(RegisterReq);
      }
   };

   //注册响应
   struct RegisterRes
   {
      Head head;
      char user_name[32];
      int status; // 注册状态
      //注册成功，默认最小权限组合
      Permission per;
      RegisterRes()
      {
         head.type = REGISTER_RES;
         head.len = sizeof(RegisterRes);
      };
   };

   //重置密码请求 
   struct ResetReq
   {
      Head head;
      char email[50];
      char password[32];
      ResetReq(){
         head.type = RESET_REQ;
         head.len = sizeof(ResetReq);
      }
   };

   //重置密码响应
   struct ResetRes
   {
      Head head;
      char user_name[32];
      int status; // 重置密码状态
      ResetRes()
      {
         head.type = RESET_RES;
         head.len = sizeof(ResetRes);
      };
   };


// 历史查询请求结构体
struct HistoryQueryReq {
    Head head;
    //根据时间范围查询
    char start_time[32];
    char end_time[32];

    HistoryQueryReq() {
        // 初始化数据头
        head.type = HISTORY_QUERY_REQ;
        head.len = sizeof(HistoryQueryReq);
        // 初始化查询条件字段
        std::memset(start_time, 0, sizeof(start_time));
        std::memset(end_time, 0, sizeof(end_time));
    }
};


// 历史查询响应结构体
struct HistoryQueryRes {
    Head head;

    char results[1024][32];
    int result_count;

    HistoryQueryRes() {
        // 初始化数据头
        head.type = HISTORY_QUERY_RES;
        head.len = sizeof(HistoryQueryRes);
        // 初始化结果相关字段
        result_count = 0;
        std::memset(results, 0, sizeof(results));
    }
};


// 按员工编号、名字或职位查询人员权限信息请求
typedef struct QueryPmsRequest{
    Head head;
    char userNo[32];
    char name[32];
    char permissonType[32];
    QueryPmsRequest(){
        head.type=QUERY_PMS_REQ;
        userNo[32] = {0};
        name[32] = {0};
        permissonType[32] = {0};
        head.len = sizeof(QueryPmsRequest);
    }
} QueryPmsRequest;

// 按角色id更新权限信息请求
typedef struct UpdatePmsRequest{
    Head head;
    int roleId;
    int queryHistory;
    int loggerSearch;
    int mapMark;
    int devManage;
    int productPlan;
    UpdatePmsRequest(){
        head.type=QUERY_PMS_RES;
        head.len = sizeof(UpdatePmsRequest);
    }
} UpdatePmsRequest;

// 单个人员权限结构体
typedef struct UserAboutPms{

    int queryHistory;
    int loggerSearch;
    int mapMark;
    int devManage;
    int productPlan;
    int roleId;
    char userNo[32];
    char name[32];
    char permissonType[32];
    char startDateTime[32];
    char endDateTime[32];

} PmsRes;

// 查询人员和角色信息的响应结构体
typedef struct UserAboutPmsResponse{
    Head head;
    int success; // 1为成功 ,0为失败
    PmsRes pmsList[100];
    UserAboutPmsResponse(){
        head.type=QUERY_PMS_RES;
        head.len = sizeof(UserAboutPmsResponse);
    }
} QueryPmsResponse;

// 权限更新结果响应体
typedef struct UpdatePmsResponse{
    Head head;
    int success; // 1为成功 ,0为失败
    UpdatePmsResponse(){
        head.type = UPDATE_PMS_RES;
        head.len = sizeof(UpdatePmsResponse);
    }

} UpdatePmsResponse ;

//地图标注请求 
struct MapMarkReq
{
   Head head;
   int marktype;//插入、删除、
   char msg[0];//柔性数组
      LoginReq(){
      head.type = MAPMARK_REQ;
      head.len = sizeof(MapMarkReq);
   }
};
	
//地图响应：
struct MarkInfo
{
   int mark_id;//标注点id
   string latitude;//纬度
   string longitude;//经度
   int device_id;//设备ID
   int device_status;//设备状态
   string device_name;//设备名称
};
	
struct MapMarkRes  ////地图标注响应
{
   Head head;
   int marktype;//插入还是删除
   int status; // 操作状态_成功/失败
   MaskInfo info[0];//柔性数组
   MapMarkRes()
   {
      head.type = MAPMARK_RES;
      head.len = sizeof(MapMarkRes);
   };
};


//环境数据请求
struct EnvironmentReq
{
    Head head;
    float temp;//温度
    float humidity;//湿度
    float oxygen;//氧气浓度
    float carbon;//一氧化碳浓度
        EnvironmentReq(){
        head.type = ENVIRONMENT_REQ;
        head.len = sizeof(EnvironmentReq);
    }
};
//设备状态请求
struct DeviceStatusReq
{
    Head head;
    int device_ID;//设备编号
    char device_Name[32];//设备名称
    char device_Status[32];//设备状态
        DeviceStatusReq(){
        head.type = DEVICESTATUS_REQ;
        head.len = sizeof(DeviceStatusReq);
    }
};
//操作日志请求
struct MovementRecordReq
{
    Head head;
    char user_Name;//操作用户名
    char alarm_Time[32];//操作时间
    char device_Name[32];//操作设备
    char movement[256];//操作描述
        MovementRecordReq(){
        head.type = MOVEMENTRECORD_REQ;
        head.len = sizeof(MovementRecordReq);
    }
};
//警报记录请求
struct AlarmRecordReq
{
    Head head;
    char alarm_Time[32];//警报时间
    char alarm_type[32];//解决时间
    char alarm_Content[256];//警报内容
        AlarmRecordReq(){
        head.type = ALARMRECORD_REQ;
        head.len = sizeof(AlarmRecordReq);
    }
};
//煤矿产量请求
struct YieldReq
{
    Head head;
    int month;//月份
    int yield;//产量
        YieldReq(){
        head.type = YIELD_REQ;
        head.len = sizeof(YieldReq);
    }
};

//添加一行数据的请求结构体
struct AddProductionPlanReq {
   Head head;
   int type;
   char productionDate[32];
   int productionQuantity;
   int plannedProductionQuantity;
   int predictedProductionQuantity;
   char logText[256];
   AddProductionPlanReq() {
      head.type = ADDPRODUCTIONPLAN_REQ;
      head.len = sizeof(AddProductionPlanReq);
   }
};
//添加一行数据的响应结构体
struct AddProductionPlanRes {
   Head head;
   int type;
   int status; // 可以表示添加是否成功， 0 表示失败，1 表示成功
   AddProductionPlanRes() {
      head.type = ADDPRODUCTIONPLAN_RES;
      head.len = sizeof(AddProductionPlanRes);
   }
};

// 更新生产计划（计划生产量）的请求结构体
struct UpdateProductionPlanQuantityReq {
   Head head;
   int type;
   int plannedProductionQuantity;
   char productionDate[32];
   UpdateProductionPlanQuantityReq() {
      head.type = UPDATEPRODUCTIONPLANQUANTITY_REQ;
      head.len = sizeof(UpdateProductionPlanQuantityReq);
   }
};
// 更新生产计划（计划生产量）的响应结构体
struct UpdateProductionPlanQuantityRes {
   Head head;
   int type;
   int status; // 可以表示更新是否成功，例如 0 表示失败，1 表示成功
   UpdateProductionPlanQuantityRes() {
      head.type = UPDATEPRODUCTIONPLANQUANTITY_RES;
      head.len = sizeof(UpdateProductionPlanQuantityRes);
   }
};


// 更新生产计划（日志）的请求结构体
struct UpdateProductionPlanLogReq {
   Head head;
   int type;
   char logText[256];
   char productionDate[32];
   UpdateProductionPlanLogReq() {
      head.type = UPDATEPRODUCTIONPLANLOG_REQ;
      head.len = sizeof(UpdateProductionPlanLogReq);
   }
};
// 更新生产计划请求（日志）的响应结构体
struct UpdateProductionPlanLogRes {
   Head head;
   int type;
   int status; // 可以表示更新是否成功，例如 0 表示失败，1 表示成功
   UpdateProductionPlanLogRes() {
      head.type = UPDATEPRODUCTIONPLANLOG_RES;
      head.len = sizeof(UpdateProductionPlanLogRes);
   }
};



// 查询生产计划信息请求
struct ProductionPlanReq {
   Head head;
   int type;
   int len;
   char productionDate[32];
   int productionQuantity;
   int plannedProductionQuantity;
   int predictedProductionQuantity;
   char logText[256];
   ProductionPlanReq() {
      head.type = PRODUCTIONPLAN_REQ;
      head.len = sizeof(ProductionPlanReq);
   }
};
// 查询生产计划信息的响应结构体
struct ProductionPlanRes {
   Head head;
   int type;
   int len;
   int productionQuantity;
   int plannedProductionQuantity;
   int predictedProductionQuantity;
   int roleId;
   char productionDate[32];
   char logText[256];
   ProductionPlanRes() {
      head.type = PRODUCTIONPLAN_REQ;
      head.len = sizeof(ProductionPlanRes);
   }
};



//查询近十四条的请求结构体
struct RecentFourteenProductionPlansReq {
   Head head;
   int requestType;
   RecentFourteenProductionPlansReq() {
      head.type = RECENTFOURTEENPRODUCTIONPLANS_REQ;
      head.len = sizeof(RecentFourteenProductionPlansReq);
   }
};
//查询近十四条的响应结构体
struct RecentFourteenProductionPlansRes {
   Head head;
   int responseType;
   int responseLength;
   int productionQuantities[14];
   int plannedProductionQuantities[14];
   int predictedProductionQuantities[14];
   int roleIds[14];
   char productionDates[14][32];
   char logTexts[14][256];
   RecentFourteenProductionPlansRes() {
      head.type = UPDATEPRODUCTIONPLANQUANTITY_REQ;
      head.len = sizeof(RecentFourteenProductionPlansRes);
   }
};



struct VersionNumReq        // 版本号请求
{
   Head head;
   VersionNumReq() {
      head.type = VERSIONNUM_REQ;
      head.len = sizeof(VersionNumReq);
   }
};

struct VersionNumRes        // 版本号响应
{
   Head head;
   char version_id[64]; // 版本号
   VersionNumRes() {
      head.type = VERSIONNUM_RES;
      head.len = sizeof(VersionNumRes);
   }
};

// 文件传输
struct FileInfo
{
   char file_name[256];
   long long file_size;
    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 file_name[256];
    long long file_size;
    UploadFileRes()
    {
        head.type = UPLOAD_FILE_RES;
        head.len = sizeof(UploadFileRes);
    }
};

// 版本信息录入
// 请求
struct VersionInfoEntryReq {
    Head head;
    char version_id[64]; // 版本号
    char version_id_old[64]; // 上一个版本号
    char s_filepath[16][128];   //服务器放最新版本的路径
    char version_description[256]; //更新内容
    char version_creattime[32]; // 更新时间
    char filename[16][128];
    long long filesize[16];
    char c_filepath[16][128];
    int fileNum;

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

// 版本信息录入响应
struct VersionInfoEntryRes {
    Head head;
    bool state = false;
    VersionInfoEntryRes()
    {
        head.type = VERSIONINFOENTRY_RES;
        head.len = sizeof(VersionInfoEntryRes);
    }
};

// 版本更新请求
struct VersionUpdateReq {
    Head head;

    char cur_version_id[64]; // 版本号
    VersionUpdateReq()
    {
        head.type = VERSIONUPDATE_REQ;
        head.len = sizeof(VersionUpdateReq);
    }
};

// 版本更新响应
struct VersionUpdateRes {
    Head head;
    bool state = false;
    char version_id[64]; // 版本号
    char update_date[32]; // 更新时间
    char version_description[1024]; //更新描述

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

// 版本更新文件下载请求
struct FileDownloadsReq {
    Head head;
    char version_id[64]; // 版本号
    FileDownloadsReq()
    {
        head.type = FILEDOWNLOADS_REQ;
        head.len = sizeof(FileDownloadsReq);
    }
};

// 版本更新文件下载响应
struct FileDownloadsRes {
    Head head;
    char version_id[64]; // 版本号
    char filename[128]; //文件名
    long long filesize; //文件大小
    char c_filepath[128];   //客户端放最新版本的本地路径
    int fileNum; // 文件数量
    long long all_fileSize; // 文件总大小
    char content[0];
    FileDownloadsRes()
    {
        head.type = FILEDOWNLOADS_RES;
        head.len = sizeof(FileDownloadsRes);
    }
};

// 更新文件下载成功的响应
struct DownloadSuccessfullyRes{
    Head head;
    bool state = false;
    char file_name[256];
    long long file_size;
    DownloadSuccessfullyRes()
    {
        head.type = DOWNLOADSUCCESSFULLY_RES;
        head.len = sizeof(DownloadSuccessfullyRes);
    }
};


struct LogQueryRequest {
    Head header;                // 数据头
    std::string* keywords;      // 存储多个关键字的柔性数组
    size_t keywordCount;         // 关键字数量
    std::string startDate;       // 开始日期 (格式: YYYY-MM-DD)
    std::string endDate;         // 结束日期 (格式: YYYY-MM-DD)
    int pageNumber;              // 当前页码
    int pageSize;                // 每页条目数

    // 构造函数
    LogQueryRequest(int type, int len, std::string* keywords, size_t keywordCount, const std::string& startDate, const std::string& endDate, int pageNumber, int pageSize)
        : header{type, len}, keywords(keywords), keywordCount(keywordCount), startDate(startDate), endDate(endDate), pageNumber(pageNumber), pageSize(pageSize) {}

    // 析构函数
    ~LogQueryRequest() {
        delete[] keywords; // 释放动态分配的内存
    }
};

//日志查询响应
// 定义日志条目结构体
struct LogEntry {
    int id;                  // 日志条目 ID
    string entryTime;       // 下井时间
    string name;            // 姓名
    string exitTime;        // 升井时间
    string department;       // 部门
    string position;        // 岗位
    //string workingTime;     // 工作时间 数据库自动生成

      // 构造函数
    LogEntry(int id, const string& entryTime, const string& name, 
              const string& exitTime, const string& department, 
              const string& position)
        : id(id), entryTime(entryTime), name(name), 
          exitTime(exitTime), department(department), position(position) {}
};

// 定义日志查询响应结构体
struct LogQueryResponse {
    int status;                    // 响应状态 (如 0 表示成功，非 0 表示失败)
    string errorMessage;           // 错误信息（如果有）
    vector<LogEntry> logEntries;   // 日志条目

    // 构造函数
    LogQueryResponse(int status, const string& errorMessage, const vector<LogEntry>& logEntries)
        : status(status), errorMessage(errorMessage), logEntries(logEntries) {}
};




#endif // COMMON_H