提交common.h

congmu

2024-10-31 60f147d3302b967cef0f68523877164bd38ed4a6

提交common.h

 common.h

New file
@@ -0,0 +1,640 @@
#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//地图标注响应

    //生产计划管理
    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 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