#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
|
