jsyhsec/energy_storage
7
0
Fork 0
mirror of https://gitee.com/js-yhsec/energy_storage.git synced 2026-05-27 18:59:26 +08:00
Code Issues Packages Projects Releases Wiki Activity

调试修改HTTP接口

Browse Source
This commit is contained in:
lixiaoyuan
2025-09-05 19:44:26 +08:00
parent c1cce63c85
commit aca9a8f0ae
34 changed files with 2142 additions and 179 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/CMakeLists.txt
View File

@@ -18,7 +18,7 @@ macro(ADD_SOURCE_GROUP srcpath)
endmacro(ADD_SOURCE_GROUP)
###############################################################################
set(PROJECT_NAME EES)
set(PROJECT_NAME ESS)
project(${PROJECT_NAME})
set(CMAKE_CXX_STANDARD 17)

2
src/app/AppData.cpp
View File

@@ -40,7 +40,7 @@ void AppData::initFromDB()
auto dao = DaoEntity::create("");
if (!dao->isConnected())
{
spdlog::info("Database connected error.");
spdlog::error("Init app data failed, database connected error.");
return;
}

3
src/app/Application.cpp
View File

@@ -16,6 +16,9 @@ void Application::init()
// 初始化系统配置，读取配置文件
Config::init("assets/config/app.json");
// MQTT 数据结构
MqttClient::loadDataStruct("assets/config/registeraddr.json");
// 设置数据库配置
DaoEntity::setOption(Config::option.database.host,
Config::option.database.port,

8
src/app/DataStruct.h
View File

@@ -3,12 +3,6 @@
#include <cstdint>
#include "common/JsonN.h"
struct REGInfo
{
std::string name;
int byte;
std::string remark;
};
// EMS遥信
struct EMSYX
@@ -43,7 +37,7 @@ struct EMSYX
uint16_t energyStatus; //判断总表的三相总有功 < -5.0fkW 充电 >5.0fkW放电 否则停机 R uint16 0:充电 1 : 放电 2 : 停机 储能状态
void fromJson(const std::string& str);
void toJson();
std::string toJson();
};
// EMS遥测

19
src/app/errcode.h
View File

@@ -4,22 +4,21 @@
enum class Errcode
{
OK = 0,
ERR = 1,
ERR_TOKEN, // TOKEN错误
ERR_PARAM, // 参数错误
ERR_PARAM_NUL, // 缺少参数
ERR_DATA_NUL, // 数据不存在
OK = 0, // 成功
ERR = 1, // 系统错误
ERR_TOKEN = 2, // TOKEN错误
ERR_PARAM = 3, // 参数错误
ERR_PARAM_NUL = 4, // 缺少参数
ERR_DATA_NUL = 5, // 数据不存在
ERR_USER = 100,
ERR_LOGIN_USER_NOTEXIST, // 登入错误，用户不存在
ERR_LOGIN_PASSWD, // 登入错误，密码不正确
ERR_LOGIN_USER_NOTEXIST = 101, // 登入错误，用户不存在
ERR_LOGIN_PASSWD = 102, // 登入错误，密码不正确
ERR_DEVICE = 200,
ERR_DB_CONN = 1001, // 数据库连接错误
ERR_DB_CONN = 1001, // 数据库连接错误
ERR_DB_DUPLICATE = 1062, // Duplicate entry for key
ERR_DB_SQL = 1064, // 数据库查询SQL错误
ERR_DB_VAL = 1366, // 1366,Incorrect decimal value，通常为参数值错误，例如空值、值类型错误

60
src/database/Dao.cpp
View File

@@ -143,19 +143,21 @@ Errcode DAO::insertUser(Fields& params)
params.set(DMUser::USER_ID, Snowflake::instance().getIdStr());
params.set(DMUser::CREATETIME, createTime);
params.set(DMUser::PASSWD, "123456");
std::string userRoleId = params.remove(DMRole::ROLE_ID);
ret = dao->insertFields(params);
if (ret != 0)
{
return Errcode(ret);
}
std::string userRoleId = params.remove(DMRole::ROLE_ID);
if (!userRoleId.empty())
{
Fields paramsUserRole;
paramsUserRole.set(DMUser::USER_ID, params.value(DMUser::USER_ID));
paramsUserRole.set(DMRole::ROLE_ID, userRoleId);
paramsUserRole.set(DMUser::UPDATETIME, createTime);
dao->setTableName(DMUserRole::TABLENAME);
ret = dao->duplicateUpdate(paramsUserRole, {DMUser::USER_ID});
}
return Errcode::OK;
@@ -211,19 +213,20 @@ Errcode DAO::login(std::shared_ptr<DaoEntity> dao, std::string account, std::str
Errcode DAO::queryRolePermission(std::shared_ptr<DaoEntity> dao, int roleId, vector<Fields>& result)
{
std::string sql = "SELECT rp.role_id, rp.permission_id, p.name FROM role_permission rp"
" LEFT JOIN permission p ON p.permission_id = rp.permission_id"
" WHERE rp.is_open='1' AND rp.role_id ='" + std::to_string(roleId) + "';";
std::string sql = R"(SELECT rp.role_id, p.permission_id, p.parent_id, p.route, p.name, rp.is_view, rp.is_add, rp.is_edit, rp.is_del
FROM role_permission rp
LEFT JOIN permission p ON p.permission_id = rp.permission_id
WHERE rp.is_open='1' AND rp.role_id =')" + std::to_string(roleId) + "';";
return DAO::exec(dao, sql, result);
}
Errcode DAO::queryRolePermission(std::shared_ptr<DaoEntity> dao, vector<Fields>& result)
{
// 查询 role 的 permission
std::string sql = "SELECT rp.role_id, rp.permission_id, rp.is_open, r.name role_name, p.name permission_name FROM role_permission rp"
" LEFT JOIN `role` r ON r.role_id = rp.role_id"
" LEFT JOIN permission p ON p.permission_id = rp.permission_id"
" WHERE rp.is_open='1';";
std::string sql = R"(SELECT rp.role_id, r.name role_name, rp.permission_id, p.parent_id, p.route, p.name, rp.is_view, rp.is_add, rp.is_edit, rp.is_del FROM role_permission rp
LEFT JOIN `role` r ON r.role_id = rp.role_id
LEFT JOIN permission p ON p.permission_id = rp.permission_id
WHERE rp.is_open='1';)";
return DAO::exec(dao, sql, result);
}
@@ -317,29 +320,14 @@ Errcode DAO::queryRoleList(PageInfo& pageInfo, vector<Fields>& result)
return QueryPagination("*", sqlCondition, pageInfo, result);
}
Errcode DAO::updateRolePermission(std::shared_ptr<DaoEntity> dao, std::string roleId, std::string permission)
Errcode DAO::updateRolePermission(std::shared_ptr<DaoEntity> dao, std::string roleId, vector<Fields>& vecFields)
{
NJsonNode jnode;
NJson::parse(permission, jnode);
std::vector<Fields> vec;
for (auto& item: jnode)
{
std::string permissionId;
if (item.is_number()) { permissionId = std::to_string(item.get<int>()); }
if (item.is_string()) { permissionId = item.get<std::string>(); }
if (!permissionId.empty())
{
Fields field;
field.set("role_id", roleId);
field.set("permission_id", permissionId);
vec.emplace_back(field);
}
}
if (!dao) dao = DaoEntity::create("");
dao->setTableName(DMRolePermission::TABLENAME);
std::string sqlDel = "DELETE from " + DMRolePermission::TABLENAME + " WHERE role_id='" + roleId + "';";
int ret = dao->exec(sqlDel);
if (ret != 0 ){ return Errcode(ret); };
ret = dao->insertFields(vec);
ret = dao->insertFields(vecFields);
if (ret != 0) { return Errcode(ret); };
return Errcode::OK;
}
@@ -360,29 +348,31 @@ Errcode DAO::insertRole(Fields& params)
err = DAO::exec(dao, sql, res);
if (err == Errcode::OK && res.size() > 0)
{
std::string roleId = res[0].value("role_id");
err = DAO::updateRolePermission(dao, roleId, permission);
//std::string roleId = res[0].value("role_id");
//err = DAO::updateRolePermission(dao, roleId, permission);
}
}
return err;
}
// 更新角色
Errcode DAO::updateRoleById(Fields& params)
Errcode DAO::updateRoleById(std::shared_ptr<DaoEntity> dao, Fields& params)
{
if (!dao) dao = DaoEntity::create("");
dao->setTableName(DMRole::TABLENAME);
auto roleId = params.value(DMRole::ROLE_ID);
if (roleId.empty())
{
return Errcode::ERR_DB_SQL;
}
auto permission = params.remove("permission");
auto dao = DaoEntity::create(DMRole::TABLENAME);
auto err = DAO::update(dao, DMRole::TABLENAME, params, DMRole::ROLE_ID);
if (err == Errcode::OK && !permission.empty())
{
err = DAO::updateRolePermission(dao, roleId, permission);
}
//if (err == Errcode::OK && !permission.empty())
//{
// err = DAO::updateRolePermission(dao, roleId, permission);
//}
return err;
}

4
src/database/Dao.h
View File

@@ -44,7 +44,7 @@ public:
static Errcode deletePermissionById(std::string userId);
static Errcode updateRolePermission(std::shared_ptr<DaoEntity> dao, std::string roleId, std::string permission);
static Errcode updateRolePermission(std::shared_ptr<DaoEntity> dao, std::string roleId, vector<Fields>& vecFields);
// 查询角色列表（分页）
static Errcode queryRoleList(PageInfo& pageInfo, vector<Fields>& result);
@@ -54,7 +54,7 @@ public:
// 新增角色
static Errcode insertRole(Fields& params);
// 更新角色
static Errcode updateRoleById(Fields& params);
static Errcode updateRoleById(std::shared_ptr<DaoEntity> dao, Fields& params);
// 删除角色
static Errcode deleteRoleById(std::string userId);

2
src/main.cpp
View File

@@ -128,6 +128,8 @@ int main(int argc, char** argv)
Spdlogger::init(spdlog::level::debug, "");
spdlog::info("[main] start ... ======================================================================");
spdlog::info("");
std::cout << Snowflake::instance().getId() << std::endl;
for (int i = 0; i<=10; ++i) {
std::cout << Snowflake::instance().getId() << std::endl;

235
src/protocol/HttpEntity.cpp
View File

@@ -15,6 +15,40 @@ static void FieldsToJson(Fields& fields, NJsonNode& json)
json[item.first] = item.second;
}
}
static void JsonToFields(NJsonNode& json, std::vector<std::string> vecKeys, Fields& fields)
{
if (vecKeys.empty())
{
for (auto& item: json.items())
{
auto key = item.key();
auto& val = json[key];
}
}
for (auto& key : vecKeys)
{
if (json.contains(key)) {
switch (json[key].type())
{
case NJsonNode::value_t::string: { fields.set(key, json[key].get<std::string>()); } break;
case NJsonNode::value_t::boolean: { fields.set(key, json[key].get<bool>()); } break;
case NJsonNode::value_t::number_integer: { fields.set(key, json[key].get<int>()); } break;
case NJsonNode::value_t::number_unsigned: { fields.set(key, json[key].get<int>()); } break;
case NJsonNode::value_t::number_float: { fields.set(key, json[key].get<float>()); } break;
case NJsonNode::value_t::null: {} break;
case NJsonNode::value_t::object: {} break;
case NJsonNode::value_t::array: {} break;
case NJsonNode::value_t::binary: {} break;
case NJsonNode::value_t::discarded: {} break;
default:
break;
}
}
}
}
static NJsonNode FieldsToJsonArray(std::vector<Fields>& vecFields)
{
@@ -33,7 +67,6 @@ static NJsonNode FieldsToJsonArray(std::vector<Fields>& vecFields)
static void GetRequestParam(const httplib::Request& req, const std::vector<std::string>& vecKeys, Fields& fields)
{
if (req.method == "GET")
{
for (auto& key : vecKeys)
@@ -48,30 +81,8 @@ static void GetRequestParam(const httplib::Request& req, const std::vector<std::
{
NJsonNode json;
NJson::parse(req.body, json);
for (auto& key : vecKeys)
{
if (json.contains(key)) {
switch (json[key].type())
{
case NJsonNode::value_t::string: { fields.set(key, json[key].get<std::string>()); } break;
case NJsonNode::value_t::boolean: { fields.set(key, json[key].get<bool>()); } break;
case NJsonNode::value_t::number_integer: { fields.set(key, json[key].get<int>()); } break;
case NJsonNode::value_t::number_unsigned: { fields.set(key, json[key].get<int>()); } break;
case NJsonNode::value_t::number_float: { fields.set(key, json[key].get<float>()); } break;
case NJsonNode::value_t::null: {} break;
case NJsonNode::value_t::object: {} break;
case NJsonNode::value_t::array: {} break;
case NJsonNode::value_t::binary: {} break;
case NJsonNode::value_t::discarded: {} break;
default:
break;
}
}
}
}
}
class HttpHelper
@@ -82,7 +93,16 @@ public:
errmsg = "";
for (auto& key : vecKeys)
{
if (!req.has_param(key))
bool hasParam = false;
if (req.method == "GET")
{
hasParam = req.has_param(key);
}
else
{
hasParam = (req.body.find("\"" + key + "\"") != std::string::npos);
}
if (!hasParam)
{
if (!errmsg.empty()) { errmsg += ","; }
errmsg += "缺少参数[" + key + "]";
@@ -103,20 +123,7 @@ public:
}
};
using HandlerFunc = Errcode(HttpEntity::*)(const httplib::Request& req, httplib::Response& resp, NJsonNode& jnode);
struct HandlerOptions
{
HandlerFunc func;
std::vector<std::string> requiredKeys;
std::vector<std::string> keys;
HandlerOptions(HandlerFunc func, const std::vector<std::string>& requiredKeys)
: func(func), requiredKeys(requiredKeys)
{
}
};
static std::map<std::string, HandlerOptions> g_mapHttpHandlerGet =
{
@@ -134,7 +141,7 @@ static std::map<std::string, HandlerOptions> g_mapHttpHandlerGet =
{"/deleteStation", HandlerOptions(&HttpEntity::deleteStation, { DMStation::STATION_ID})},
{"/queryStationInfo", HandlerOptions(&HttpEntity::queryStationInfo, { DMStation::STATION_ID})},
{"/queryStationRuntime", HandlerOptions(&HttpEntity::queryStationRuntime, { DMStation::STATION_ID})},
{"/queryStationData", HandlerOptions(&HttpEntity::queryStationData, { DMStation::STATION_ID})},
{"/queryDeviceList", HandlerOptions(&HttpEntity::queryDeviceList, {})},
{"/deleteDevice", HandlerOptions(&HttpEntity::deleteDevice, { DMDevice::DEVICE_ID})},
@@ -142,7 +149,6 @@ static std::map<std::string, HandlerOptions> g_mapHttpHandlerGet =
{"/queryPolicyList", HandlerOptions(&HttpEntity::queryPolicyList, {})},
{"/deletePolicy", HandlerOptions(&HttpEntity::deletePolicy, { DMPolicy::POLICY_ID})},
{"/querySystemLogList", HandlerOptions(&HttpEntity::querySystemLogList, {})},
@@ -202,70 +208,22 @@ bool CheckHttpToken(const httplib::Request& req)
HttpEntity::HttpEntity()
{
bool useToken = Config::option.http.useToken;
for (auto& item : g_mapHttpHandlerGet)
{
std::string name = item.first;
HandlerOptions& handler = item.second;
this->httpsvr.Get(name, [=, &handler](const httplib::Request& req, httplib::Response& resp)
{
spdlog::info("[http] request: {}", name);
Errcode errcode = Errcode::OK;
if (name != "/login" && useToken)
{
bool ret = CheckHttpToken(req);
errcode = ret ? Errcode::OK : Errcode::ERR_TOKEN;
}
NJsonNode json;
std::string errmsg;
if (errcode == Errcode::OK)
{
if (!HttpHelper::CheckRequestParam(req, resp, handler.requiredKeys, errmsg))
{
errcode = Errcode::ERR_PARAM;
}
else
{
errcode = (this->*(handler.func))(req, resp, json);
}
}
json["errcode"] = errcode;
json["errmsg"] = ErrcodeStr(errcode) + (errmsg.empty() ? "" : (":"+errmsg));
resp.set_content(json.dump(), "text/plain; charset=utf-8");
resp.status = 200;
this->runHandler(name, handler, req, resp);
});
}
for (auto& item : g_mapHttpHandlerPost)
{
std::string name = item.first;
HandlerOptions& handler = item.second;
this->httpsvr.Post(name, [=](const httplib::Request& req, httplib::Response& resp)
{
Errcode errcode = Errcode::OK;
std::string errmsg;
if (name != "/login" && useToken)
{
bool ret = CheckHttpToken(req);
errcode = ret ? Errcode::OK : Errcode::ERR_TOKEN;
}
if (errcode == Errcode::OK)
{
NJsonNode jsonparam;
bool ret = NJson::parse(req.body, jsonparam);
if (ret)
{
errcode = (this->*(handler.func))(req, resp, jsonparam);
}
}
NJsonNode json;
json["errcode"] = errcode;
json["errmsg"] = ErrcodeStr(errcode) + (errmsg.empty() ? "" : (":"+errmsg));
resp.set_content(json.dump(), "text/plain; charset=utf-8");
resp.status = 200;
this->runHandler(name, handler, req, resp);
});
}
}
@@ -277,6 +235,37 @@ void HttpEntity::listen(std::string addr, int port)
httpsvr.listen(addr, port); // 阻塞
}
void HttpEntity::runHandler(std::string name, const HandlerOptions& handler, const httplib::Request& req, httplib::Response& resp)
{
spdlog::info("[http] request: {}", name);
bool useToken = Config::option.http.useToken;
Errcode errcode = Errcode::OK;
std::string errmsg;
if (name != "/login" && useToken)
{
bool ret = CheckHttpToken(req);
errcode = ret ? Errcode::OK : Errcode::ERR_TOKEN;
}
NJsonNode jsonresp;
if (errcode == Errcode::OK)
{
if (!HttpHelper::CheckRequestParam(req, resp, handler.requiredKeys, errmsg))
{
errcode = Errcode::ERR_PARAM;
}
else
{
errcode = (this->*(handler.func))(req, resp, jsonresp);
}
}
jsonresp["errcode"] = errcode;
jsonresp["errmsg"] = ErrcodeStr(errcode) + (errmsg.empty() ? "" : (":"+errmsg));
resp.set_content(jsonresp.dump(), "text/plain; charset=utf-8");
resp.status = 200;
}
void HttpEntity::registGet(std::string name, void (HttpEntity::* func)(const httplib::Request& req, httplib::Response& resp))
{
this->httpsvr.Get(name, std::bind(func, this, std::placeholders::_1, std::placeholders::_2));
@@ -302,9 +291,14 @@ Errcode HttpEntity::login(const httplib::Request& req, httplib::Response& resp,
int roleId = fields.get<int>(DMRole::ROLE_ID);
DAO::queryRolePermission(dao, roleId, vecPermission);
NJsonNode jnode = NJsonNode::array();
for (auto& item : vecPermission) { jnode.push_back(item.value("name")); }
json["permission"] = jnode;
NJsonNode nodePermission = NJsonNode::array();
for (auto& item : vecPermission)
{
NJsonNode node;
FieldsToJson(item, node);
nodePermission.push_back(node);
}
json["permission"] = nodePermission;
}
DAO::insertSystemLogUser(token, "用户登录：" + ErrcodeStr(err), (err==Errcode::OK) ? 0: 1);
@@ -338,7 +332,7 @@ Errcode HttpEntity::insertUser(const httplib::Request& req, httplib::Response& r
Errcode HttpEntity::updateUser(const httplib::Request& req, httplib::Response& resp, NJsonNode& json)
{
Fields params;
GetRequestParam(req, {"user_id", "name", "gender", "age", "phone", "email", "role_id"}, params);
GetRequestParam(req, {"user_id", "account", "name", "gender", "age", "phone", "email", "role_id"}, params);
return DAO::updateUserById(params);
}
@@ -401,14 +395,13 @@ Errcode HttpEntity::queryRoleList(const httplib::Request& req, httplib::Response
}
std::map<std::string, std::vector<NJsonNode>> mapPermission;
for (auto& item: vecPermission)
for (auto& fields: vecPermission)
{
std::string roleId = item.value("role_id");
std::string roleId = fields.value("role_id");
auto& v = mapPermission[roleId];
NJsonNode jnode;
jnode["id"] = item.value("permission_id");
jnode["name"] = item.value("permission_name");
v.push_back(jnode);
NJsonNode node;
FieldsToJson(fields, node);
v.push_back(node);
}
HttpHelper::setPagination(pageinfo, result, json);
@@ -433,8 +426,38 @@ Errcode HttpEntity::insertRole(const httplib::Request& req, httplib::Response& r
Errcode HttpEntity::updateRole(const httplib::Request& req, httplib::Response& resp, NJsonNode& json)
{
Fields params;
GetRequestParam(req, {"role_id", "name", "describe", "is_open", "permission"}, params);
return DAO::updateRoleById(params);
//GetRequestParam(req, {"role_id", "name", "describe", "is_open", "permission"}, params);
NJsonNode jsonparam;
if (!NJson::parse(req.body, jsonparam))
{
return Errcode::ERR_PARAM;
}
JsonToFields(jsonparam, {"role_id", "name", "describe", "is_open"}, params);
auto roleId = params.value("role_id");
auto dao = DaoEntity::create("");
auto err = DAO::updateRoleById(dao, params);
if (err == Errcode::OK && jsonparam.contains("permission"))
{
if (jsonparam["permission"].is_array())
{
auto& jsonPermission = jsonparam["permission"];
std::vector<Fields> vecFields(jsonPermission.size());
int i = 0;
for (auto& item: jsonPermission)
{
auto& fields = vecFields[i];
i++;
JsonToFields(item, {"permission_id", "is_add", "is_del", "is_edit", "is_view"}, fields);
fields.set("role_id", roleId);
}
err = DAO::updateRolePermission(dao, roleId, vecFields);
}
}
return err;
};
Errcode HttpEntity::deleteRole(const httplib::Request& req, httplib::Response& resp, NJsonNode& json)
{
@@ -594,7 +617,9 @@ Errcode HttpEntity::updatePolicy(const httplib::Request& req, httplib::Response&
};
Errcode HttpEntity::deletePolicy(const httplib::Request& req, httplib::Response& resp, NJsonNode& json)
{
return DAO::deletePolicyById(req.get_param_value("prolicy_id"));
Fields params;
GetRequestParam(req, {"policy_id"}, params);
return DAO::deletePolicyById(params.value("policy_id"));
};
Errcode HttpEntity::querySystemLogList(const httplib::Request& req, httplib::Response& resp, NJsonNode& json)
@@ -695,8 +720,8 @@ Errcode HttpEntity::queryStatTotal(const httplib::Request& req, httplib::Respons
jsondata["charge_elect"] = "123.123"; //充电设备充电电量（kWh），精度：0.001
jsondata["charge_num"] = "1"; //充电设备充电次数
jsondata["charge_num_err"] = "1"; //充电设备故障次数
jsondata["income_elect"] = "123.123"; //发电收益（元），精度：0.01
jsondata["income_charge"] = "123.123"; //充电收益（元），精度：0.01
jsondata["income_elect"] = "123.123"; //发电收益（元），精度：0.01
jsondata["income_charge"] = "123.123"; //充电收益（元），精度：0.01
json["data"] = jsondata;
return Errcode::OK;

19
src/protocol/HttpEntity.h
View File

@@ -1,6 +1,22 @@
#include "httplib.h"
#include "httplib.h"
#include "common/JsonN.h"
#include "errcode.h"
#include <functional>
class HttpEntity;
using HandlerFunc = Errcode(HttpEntity::*)(const httplib::Request& req, httplib::Response& resp, NJsonNode& jnode);
struct HandlerOptions
{
HandlerFunc func;
std::vector<std::string> requiredKeys;
std::vector<std::string> keys;
HandlerOptions(HandlerFunc func, const std::vector<std::string>& requiredKeys)
: func(func), requiredKeys(requiredKeys)
{
}
};
class HttpEntity
{
@@ -8,6 +24,7 @@ public:
httplib::Server httpsvr;
HttpEntity();
void listen(std::string addr, int port);
void runHandler(std::string name, const HandlerOptions& handler, const httplib::Request& req, httplib::Response& resp);
void registGet(std::string name, void (HttpEntity::* func)(const httplib::Request& req, httplib::Response& resp));
//void onGet(const httplib::Request& req, httplib::Response& resp);

104
src/protocol/MqttEntity.cpp
View File

@@ -1,9 +1,31 @@
#include "MqttEntity.h"
#include "common/Spdlogger.h"
#include "common/JsonN.h"
#include "common/Utils.h"
#define TIMEOUT 10000L
static std::map<std::string, std::map<std::string, REGInfo>> g_mapRegInfo;
void MqttClient::loadDataStruct(std::string filename)
{
NJsonNode json;
NJson::load(filename, json);
// 遍历 JSON 对象
for (auto& jsonitem : json.items())
{
auto& mapItem = g_mapRegInfo[jsonitem.key()];
for (auto& itemaddrs : jsonitem.value().items())
{
auto& jsonreg = itemaddrs.value();
mapItem[jsonreg["key"]] = REGInfo(jsonreg["key"], jsonreg["datatype"], jsonreg["remark"]);
}
}
}
int MqttClient::init(string addr, string clientId, string username, string password)
{
this->addr = addr;
@@ -28,7 +50,8 @@ int MqttClient::init(string addr, string clientId, string username, string passw
int rc {0};
// "tcp://localhost:1883"
rc = MQTTAsync_create(&client, addr.c_str(), clientId.c_str(), MQTTCLIENT_PERSISTENCE_NONE, NULL);
std::string str = "ESS-" + std::to_string(Utils::random(1000, 9999)) + "-" +clientId;
rc = MQTTAsync_create(&client, addr.c_str(), str.c_str(), MQTTCLIENT_PERSISTENCE_NONE, NULL);
if (rc != MQTTASYNC_SUCCESS)
{
spdlog::error("[mqtt] MQTTAsync_create error: {}", rc);
@@ -87,10 +110,10 @@ int MqttClient::init(string addr, string clientId, string username, string passw
void MqttClient::destory()
{
return;
if (client)
{
MQTTAsync_destroy(&client);
client = nullptr;
}
}
@@ -154,7 +177,7 @@ int MqttClient::publish(string topic, string text)
void MqttClient::onConnectionLost(char* cause)
{
this->isConnected = false;
this->destory();
//this->destory();
spdlog::error("MQTT connection lost, cause={}", cause);
}
@@ -184,10 +207,47 @@ int MqttClient::onMessageArrived(char* topic, int topicLen, MQTTAsync_message* m
std::string command = GetSubStr("/", topicStr);
std::string deviceCode = GetSubStr("/", topicStr);
if (command == "EMS_YX") {}
else if (command == "EMS_YC") {}
//EMS遥信
//EMS遥测
//EMS遥调
//PCU遥信
//PCU遥测
//PCS遥信
//PCS遥测
//BMS遥测
//BCU遥信
//BCU遥测
//电表遥测
//温湿度遥测
//消防遥信4.0
//冷机遥信
//冷机遥测
//充电桩遥测
//网关遥信
//网关遥测
//网关遥调
//台区
if (command == "EMS_YX") { this->parseEMS_YX(payload); }
else if (command == "EMS_YC") { this->parseEMS_YC(payload); }
else if (command == "PCU_YX") { this->parsePCU_YX(payload); }
else if (command == "PCU_YC") {}
else if (command == "PCU_YC") { this->parsePCU_YC(payload); }
else if (command == "PCS_YX") { this->parsePCS_YX(payload); }
else if (command == "PCS_YC") { this->parsePCS_YC(payload); }
else if (command == "BMS_YC") { this->parseBMS_YC(payload); }
else if (command == "BCU_YX") { this->parseBCU_YX(payload); }
else if (command == "BCU_YC") { this->parseBCU_YC(payload); }
else if (command == "MEM_YC") { this->parseMEM_YC(payload); }
else if (command == "TH_YC") { this->parseTH_YC(payload); }
else if (command == "Fire40_YX") { this->parseFire40_YX(payload); }
else if (command == "Cooling_YX") { this->parseCooling_YX(payload); }
else if (command == "Cooling_YC") { this->parseCooling_YC(payload); }
else if (command == "Charger_YC") { this->parseCharger_YC(payload); }
else if (command == "Gateway_YX") { this->parseGateway_YX(payload); }
else if (command == "Gateway_YC") { this->parseGateway_YC(payload); }
else if (command == "Gateway_YT") { this->parseGateway_YT(payload); }
else if (command == "TQ") { this->parseTQ(payload); }
// 必须释放消息内存！
MQTTAsync_freeMessage(&msg);
@@ -205,7 +265,7 @@ void MqttClient::onDeliveryComplete(MQTTAsync_token token)
void MqttClient::onConnectSuccess( MQTTAsync_successData* resp)
{
spdlog::info("[mqtt] connect to {} success.", addr);
spdlog::info("[mqtt] connect to {} success, clientId={}.", addr, clientId);
this->isConnected = true;
this->subscribe();
//MQTTAsync_responseOptions options = MQTTAsync_responseOptions_initializer;
@@ -234,20 +294,30 @@ void MqttClient::onConnectSuccess( MQTTAsync_successData* resp)
}
void MqttClient::onConnectFaiure(MQTTAsync_failureData* resp)
{
spdlog::error("[mqtt] connect to {} error.", addr);
spdlog::error("[mqtt] connect to {} error, clientId={}.", addr, clientId);
this->isConnected = false;
this->destory();
}
void MqttClient::parseEMS_YC(std::string& text)
{
}
void MqttClient::parsePCU_YX(std::string& text)
{
}
void MqttClient::parseEMS_YX(std::string& text){}
void MqttClient::parseEMS_YC(std::string& text) {};
void MqttClient::parsePCU_YX(std::string& text) {};
void MqttClient::parsePCU_YC(std::string& text) {};
void MqttClient::parsePCS_YX(std::string& text) {};
void MqttClient::parsePCS_YC(std::string& text) {};
void MqttClient::parseBMS_YC(std::string& text) {};
void MqttClient::parseBCU_YX(std::string& text) {};
void MqttClient::parseBCU_YC(std::string& text) {};
void MqttClient::parseMEM_YC(std::string& text) {};
void MqttClient::parseTH_YC(std::string& text) {};
void MqttClient::parseFire40_YX(std::string& text) {};
void MqttClient::parseCooling_YX(std::string& text) {};
void MqttClient::parseCooling_YC(std::string& text) {};
void MqttClient::parseCharger_YC(std::string& text) {};
void MqttClient::parseGateway_YX(std::string& text) {};
void MqttClient::parseGateway_YC(std::string& text) {};
void MqttClient::parseGateway_YT(std::string& text) {};
void MqttClient::parseTQ(std::string& text) {};
string MQTT::packEquipmentInfo()
{

35
src/protocol/MqttEntity.h
View File

@@ -5,11 +5,29 @@
#include <functional>
#include "MQTTAsync.h"
struct REGInfo
{
std::string key;
std::string datatype;
int bytes {0};
std::string remark;
REGInfo() {}
REGInfo(std::string key, std::string datatype, std::string remark)
: key(key), datatype(datatype), remark(remark)
{
if (datatype == "uint16" || datatype == "int16") { bytes = 1; }
else if (datatype == "uint32" || datatype == "int32") { bytes = 2; }
}
};
using namespace std;
class MqttClient
{
public:
static void loadDataStruct(std::string filename);
int init(string addr, string clientId, string username, string password);
void destory();
@@ -23,8 +41,25 @@ public:
void onConnectSuccess(MQTTAsync_successData* resp);
void onConnectFaiure(MQTTAsync_failureData* resp);
void parseEMS_YX(std::string& text);
void parseEMS_YC(std::string& text);
void parsePCU_YX(std::string& text);
void parsePCU_YC(std::string& text);
void parsePCS_YX(std::string& text);
void parsePCS_YC(std::string& text);
void parseBMS_YC(std::string& text);
void parseBCU_YX(std::string& text);
void parseBCU_YC(std::string& text);
void parseMEM_YC(std::string& text);
void parseTH_YC(std::string& text);
void parseFire40_YX(std::string& text);
void parseCooling_YX(std::string& text);
void parseCooling_YC(std::string& text);
void parseCharger_YC(std::string& text);
void parseGateway_YX(std::string& text);
void parseGateway_YC(std::string& text);
void parseGateway_YT(std::string& text);
void parseTQ(std::string& text);
public:
std::string clientId;