实现MQTT功能, 修改HTTP接口

This commit is contained in:
lixiaoyuan
2025-09-04 19:31:04 +08:00
parent 61ed4f355f
commit d81bcd9983
30 changed files with 2029 additions and 697 deletions

View File

@@ -6,8 +6,17 @@
#include "app/Application.h"
#include "app/AppData.h"
#include "app/Config.h"
#include "app/Station.h"
static NJsonNode FieldsToJsonArray(std::vector<Fields> vecFields)
static void FieldsToJson(Fields& fields, NJsonNode& json)
{
for (auto& item : fields.map())
{
json[item.first] = item.second;
}
}
static NJsonNode FieldsToJsonArray(std::vector<Fields>& vecFields)
{
NJsonNode jsonnode = NJsonNode::array();
for (auto& fields : vecFields)
@@ -24,13 +33,45 @@ static NJsonNode FieldsToJsonArray(std::vector<Fields> vecFields)
static void GetRequestParam(const httplib::Request& req, const std::vector<std::string>& vecKeys, Fields& fields)
{
for (auto& key : vecKeys)
if (req.method == "GET")
{
if (req.has_param(key))
for (auto& key : vecKeys)
{
fields.set(key, req.get_param_value(key));
if (req.has_param(key))
{
fields.set(key, req.get_param_value(key));
}
}
}
else if (req.method == "POST")
{
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
@@ -77,86 +118,106 @@ struct HandlerOptions
}
};
static std::map<std::string, HandlerOptions> g_mapHttpHandler =
static std::map<std::string, HandlerOptions> g_mapHttpHandlerGet =
{
{"/login", HandlerOptions(&HttpEntity::login, {DMUser::ACCOUNT, DMUser::PASSWD})},
{"/queryUserList", HandlerOptions(&HttpEntity::queryUserList, {"token"})},
{"/insertUser", HandlerOptions(&HttpEntity::insertUser, {"token", DMUser::ACCOUNT})},
{"/updateUser", HandlerOptions(&HttpEntity::updateUser, {"token", DMUser::USER_ID})},
{"/deleteUser", HandlerOptions(&HttpEntity::deleteUser, {"token", DMUser::USER_ID})},
{"/queryUserList", HandlerOptions(&HttpEntity::queryUserList, {})},
{"/deleteUser", HandlerOptions(&HttpEntity::deleteUser, { DMUser::USER_ID})},
{"/queryPermissionList", HandlerOptions(&HttpEntity::queryPermissionList, {"token"})},
{"/insertPermission", HandlerOptions(&HttpEntity::insertPermission, {"token", DMPermission::NAME})},
{"/updatePermission", HandlerOptions(&HttpEntity::updatePermission, {"token", DMPermission::PERMISSION_ID})},
{"/deletePermission", HandlerOptions(&HttpEntity::deletePermission, {"token", DMPermission::PERMISSION_ID})},
{"/queryPermissionList", HandlerOptions(&HttpEntity::queryPermissionList, {})},
{"/deletePermission", HandlerOptions(&HttpEntity::deletePermission, { DMPermission::PERMISSION_ID})},
{"/queryRoleList", HandlerOptions(&HttpEntity::queryRoleList, {"token"})},
{"/insertRole", HandlerOptions(&HttpEntity::insertRole, {"token", DMRole::NAME})},
{"/updateRole", HandlerOptions(&HttpEntity::updateRole, {"token", DMRole::ROLE_ID})},
{"/deleteRole", HandlerOptions(&HttpEntity::deleteRole, {"token", DMRole::ROLE_ID})},
{"/queryRoleList", HandlerOptions(&HttpEntity::queryRoleList, {})},
{"/deleteRole", HandlerOptions(&HttpEntity::deleteRole, { DMRole::ROLE_ID})},
{"/queryStationList", HandlerOptions(&HttpEntity::queryStationList, {"token"})},
{"/insertStation", HandlerOptions(&HttpEntity::insertStation, {"token", DMStation::NAME})},
{"/updateStation", HandlerOptions(&HttpEntity::updateStation, {"token", DMStation::STATION_ID})},
{"/deleteStation", HandlerOptions(&HttpEntity::deleteStation, {"token", DMStation::STATION_ID})},
{"/queryDeviceList", HandlerOptions(&HttpEntity::queryDeviceList, {"token"})},
{"/insertDevice", HandlerOptions(&HttpEntity::insertDevice, {"token", DMDevice::NAME})},
{"/updateDevice", HandlerOptions(&HttpEntity::updateDevice, {"token", DMDevice::DEVICE_ID})},
{"/deleteDevice", HandlerOptions(&HttpEntity::deleteDevice, {"token", DMDevice::DEVICE_ID})},
{"/queryDevicTypeDef", HandlerOptions(&HttpEntity::queryDevicTypeDef, {"token"})},
{"/queryPolicyList", HandlerOptions(&HttpEntity::queryPolicyList, {"token"})},
{"/insertPolicy", HandlerOptions(&HttpEntity::insertPolicy, {"token", DMPolicy::NAME})},
{"/updatePolicy", HandlerOptions(&HttpEntity::updatePolicy, {"token", DMPolicy::POLICY_ID})},
{"/deletePolicy", HandlerOptions(&HttpEntity::deletePolicy, {"token", DMPolicy::POLICY_ID})},
{"/queryStationList", HandlerOptions(&HttpEntity::queryStationList, {})},
{"/deleteStation", HandlerOptions(&HttpEntity::deleteStation, { DMStation::STATION_ID})},
{"/querySystemLogList", HandlerOptions(&HttpEntity::querySystemLogList, {"token"})},
{"/queryStationInfo", HandlerOptions(&HttpEntity::queryStationInfo, { DMStation::STATION_ID})},
{"/queryStationRuntime", HandlerOptions(&HttpEntity::queryStationRuntime, { DMStation::STATION_ID})},
{"/queryAlertLogList", HandlerOptions(&HttpEntity::queryAlertLogList, {"token"})},
{"/queryDeviceList", HandlerOptions(&HttpEntity::queryDeviceList, {})},
{"/deleteDevice", HandlerOptions(&HttpEntity::deleteDevice, { DMDevice::DEVICE_ID})},
{"/queryDevicTypeDef", HandlerOptions(&HttpEntity::queryDevicTypeDef, {})},
{"/queryPolicyList", HandlerOptions(&HttpEntity::queryPolicyList, {})},
{"/queryPredictionDetail", HandlerOptions(&HttpEntity::queryPredictionDetail, {"token"})},
{"/deletePolicy", HandlerOptions(&HttpEntity::deletePolicy, { DMPolicy::POLICY_ID})},
{"/querySystemLogList", HandlerOptions(&HttpEntity::querySystemLogList, {})},
{"/queryStatSystem", HandlerOptions(&HttpEntity::queryStatSystem, {"token"})},
{"/queryStatTotal", HandlerOptions(&HttpEntity::queryStatTotal, {"token"})},
{"/queryStatDayList", HandlerOptions(&HttpEntity::queryStatDayList, {"token"})},
{"/queryAlertLogList", HandlerOptions(&HttpEntity::queryAlertLogList, {})},
{"/queryPredictionDetail", HandlerOptions(&HttpEntity::queryPredictionDetail, {})},
{"/queryStatSystem", HandlerOptions(&HttpEntity::queryStatSystem, {})},
{"/queryStatTotal", HandlerOptions(&HttpEntity::queryStatTotal, {})},
{"/queryStatStation", HandlerOptions(&HttpEntity::queryStatStation, {})},
{"/queryStatDayList", HandlerOptions(&HttpEntity::queryStatDayList, {})},
{"/queryEnvironment", HandlerOptions(&HttpEntity::queryEnvironment, { "station_id"})},
//{"/insert", HandlerOptions(&HttpEntity::insert, {})},
//{"/update", HandlerOptions(&HttpEntity::update, {})},
//{"/delete", HandlerOptions(&HttpEntity::delete, {})},
};
static std::map<std::string, HandlerOptions> g_mapHttpHandlerPost
{
{"/insertUser", HandlerOptions(&HttpEntity::insertUser, { DMUser::ACCOUNT})},
{"/updateUser", HandlerOptions(&HttpEntity::updateUser, { DMUser::USER_ID})},
{"/insertPermission", HandlerOptions(&HttpEntity::insertPermission, { DMPermission::NAME})},
{"/updatePermission", HandlerOptions(&HttpEntity::updatePermission, { DMPermission::PERMISSION_ID})},
{"/insertRole", HandlerOptions(&HttpEntity::insertRole, { DMRole::NAME})},
{"/updateRole", HandlerOptions(&HttpEntity::updateRole, { DMRole::ROLE_ID})},
{"/insertStation", HandlerOptions(&HttpEntity::insertStation, { DMStation::NAME})},
{"/updateStation", HandlerOptions(&HttpEntity::updateStation, { DMStation::STATION_ID})},
{"/insertDevice", HandlerOptions(&HttpEntity::insertDevice, { DMDevice::NAME})},
{"/updateDevice", HandlerOptions(&HttpEntity::updateDevice, { DMDevice::DEVICE_ID})},
{"/insertPolicy", HandlerOptions(&HttpEntity::insertPolicy, { DMPolicy::NAME})},
{"/updatePolicy", HandlerOptions(&HttpEntity::updatePolicy, { DMPolicy::POLICY_ID})},
};
bool CheckHttpToken(const httplib::Request& req)
{
// 验证token
std::string token = req.get_param_value("token");
if (!token.empty())
{
User user = Application::data().getUser(token);
if (!user.userId.empty())
{
return true;
}
}
return false;
}
HttpEntity::HttpEntity()
{
bool useToken = Config::option.http.useToken;
for (auto& item : g_mapHttpHandler)
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);
NJsonNode json;
Errcode errcode = Errcode::OK;
if (name != "/login" && useToken)
{
// 验证token
std::string token = req.get_param_value("token");
if (token.empty())
{
errcode = Errcode::ERR_TOKEN;
}
else
{
User user = Application::data().getUser(token);
if (user.userId.empty())
{
errcode = Errcode::ERR_TOKEN;
}
}
bool ret = CheckHttpToken(req);
errcode = ret ? Errcode::OK : Errcode::ERR_TOKEN;
}
NJsonNode json;
std::string errmsg;
if (errcode == Errcode::OK)
{
@@ -169,7 +230,38 @@ HttpEntity::HttpEntity()
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;
});
}
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");
@@ -383,6 +475,61 @@ Errcode HttpEntity::deleteStation(const httplib::Request& req, httplib::Response
return DAO::remove(NULL, DMStation::TABLENAME, primaryKey, req.get_param_value(primaryKey));
};
Errcode HttpEntity::queryStationInfo(const httplib::Request& req, httplib::Response& resp, NJsonNode& json)
{
// 查询场站的基础配置信息
std::string stationId = req.get_param_value("station_id");
if (stationId.empty())
{
return Errcode::ERR_PARAM;
}
std::string sql = "SELECT * FROM " + DMStation::TABLENAME + " WHERE station_id=" + stationId + ";";
std::vector<Fields> result;
Errcode err = DAO::exec(NULL, sql, result);
if (err != Errcode::OK)
{
return err;
}
if (result.size() == 0)
{
return Errcode::ERR_DATA_NUL;
}
auto& fields = result[0];
NJsonNode jsondata;
std::string attr = fields.remove(DMStation::ATTR);
NJson::parse(attr, jsondata);
FieldsToJson(fields, jsondata);
json["data"] = jsondata;
return Errcode::OK;
// work_mode: 运行模式:
// capacity: 储能容量:
// {"batttey_type": "磷酸铁锂", "cooling_type":"风冷", "voltage_rated":"300", "power_rated": "1500"}
// batttey_type: 电池类型:
// cooling_type: 冷却方式:
// voltage_rated: 电池额定电压:
// power_rated: PCS额定功率
}
Errcode HttpEntity::queryStationData(const httplib::Request& req, httplib::Response& resp, NJsonNode& json)
{
// 温度, 电压、电流、功率、功率因数、
NJsonNode jsondata;
jsondata["voltage"] = Utils::toStr(200.32);
jsondata["current"] = Utils::toStr(20.56);
jsondata["power"] = Utils::toStr(200.32);
jsondata["powerFactor"] = Utils::toStr(1);
jsondata["envTemp"] = Utils::toStr(200.32);
jsondata["envhum"] = Utils::toStr(200.32);
jsondata["aircStatus"] = Utils::toStr(1);
jsondata["coolingStatus"] = Utils::toStr(0);
json["data"] = jsondata;
return Errcode::OK;
}
Errcode HttpEntity::queryDeviceList(const httplib::Request& req, httplib::Response& resp, NJsonNode& json)
{
@@ -513,40 +660,70 @@ Errcode HttpEntity::queryStatSystem(const httplib::Request& req, httplib::Respon
{
auto& appdata = Application::data();
json["launch_date"] = "2025-01-01"; //: 系统上线启用日期格式yyyy-mm-dd
json["income_total"] = "0.00"; // : 累计收益精度0.01
json["station_num"] = Utils::toStr(appdata.getStationCount()); // : 能源站数量
json["storage_device_num "] = Utils::toStr(appdata.getStationCount()); //: 储能设备数量
json["solar_device_num"] = "0"; // : 光伏设备数量
json["capacity_total"] = "0.000"; // : 储能总容量kWh精度0.001
json["elect_gen"] = "0.000"; // : 发电总电kWh精度0.001
json["elect_grid"] = "0.000"; // : 入网种电量kWh精度0.001
json["storage_elect_in"] = "0.000"; // : 储能充电总电量kWh精度0.001
json["storage_elect_out"] = "0.000"; // : 储能电总电量kWh精度0.001
NJsonNode jsondata;
jsondata["launch_date"] = "2025-01-01"; //: 系统上线启用日期格式yyyy-mm-dd
jsondata["income_total"] = std::to_string(Utils::random(100, 200)); // : 累计收益精度0.01
jsondata["station_num"] = Utils::toStr(appdata.getStationCount()); // : 能源站数量
jsondata["storage_device_num "] = Utils::toStr(appdata.getStationCount()); //: 储能设备数量
jsondata["solar_device_num"] = "0"; // : 光伏设备数量
jsondata["capacity_total"] = std::to_string(Utils::random(100, 200)); // : 储能总容kWh精度0.001
jsondata["solar_elect_gen"] = std::to_string(Utils::random(100, 200)); // : 发电总电量kWh精度0.001
jsondata["solar_elect_grid"] = std::to_string(Utils::random(100, 200)); // : 入网种电量kWh精度0.001
jsondata["storage_elect_in"] = std::to_string(Utils::random(100, 200)); // : 储能电总电量kWh精度0.001
jsondata["storage_elect_out"] = std::to_string(Utils::random(100, 200)); // : 储能放电总电量kWh精度0.001
json["data"] = jsondata;
return Errcode::OK;
}
Errcode HttpEntity::queryStatTotal(const httplib::Request& req, httplib::Response& resp, NJsonNode& json)
{
std::string station_id = req.get_param_value("station_id");
std::string category = req.get_param_value("category");
json["dt"] = "2025-01-01"; //日期
json["storage_elect_in"] = "123.123"; //储能充电电量kWh精度0.001
json["storage_elect_out"] = "123.123"; //储能放电电量kWh精度0.001
json["storage_num_in"] = "1"; //储能设备充电次数
json["storage_num_out"] = "1"; //储能设备放电次数
json["storage_num_err"] = "1"; //储能设备故障次数
json["solar_elect_gen"] = "123.123"; //光伏发电电量kWh精度0.001
json["solar_elect_grid"] = "123.123"; //光伏入网电量kWh精度0.001
json["solar_num_err"] = "1"; //光伏设备故障次数
json["charge_elect"] = "123.123"; //充电设备充电电量kWh精度0.001
json["charge_num"] = "1"; //充电设备充电次数
json["charge_num_err"] = "1"; //充电设备故障次数
json["income_elect"] = ""; //发电收益(元精度0.01
json["income_charge"] = ""; //充电收益精度0.01
json["usage"] = "";
NJsonNode jsondata;
jsondata["station_id"] = "1";
jsondata["launch_date"] = "2025-01-01"; //场站上线日期
jsondata["usage_rate"] = "12";
jsondata["storage_elect_in"] = "123.123"; //储能充电电量kWh精度0.001
jsondata["storage_elect_out"] = "123.123"; //储能放电电量kWh精度0.001
jsondata["storage_num_in"] = "1"; //储能设备充电次数
jsondata["storage_num_out"] = "1"; //储能设备放电次数
jsondata["storage_num_err"] = "1"; //储能设备故障次数
jsondata["solar_elect_gen"] = "123.123"; //光伏发电电量kWh精度0.001
jsondata["solar_elect_grid"] = "123.123"; //光伏入网电量kWh精度0.001
jsondata["solar_num_err"] = "1"; //光伏设备故障次数
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
json["data"] = jsondata;
return Errcode::OK;
}
Errcode HttpEntity::queryStatStation(const httplib::Request& req, httplib::Response& resp, NJsonNode& json)
{
std::string station_id = req.get_param_value("station_id");
std::string category = req.get_param_value("category");
NJsonNode jsondata;
jsondata["station_id"] = "1";
jsondata["launch_date"] = "2025-01-01"; //场站上线日期
jsondata["usage_rate"] = "12";
jsondata["storage_elect_in"] = "123.123"; //储能充电电量kWh精度0.001
jsondata["storage_elect_out"] = "123.123"; //储能放电电量kWh精度0.001
jsondata["storage_num_in"] = "1"; //储能设备充电次数
jsondata["storage_num_out"] = "1"; //储能设备放电次数
jsondata["storage_num_err"] = "1"; //储能设备故障次数
jsondata["solar_elect_gen"] = "123.123"; //光伏发电电量kWh精度0.001
jsondata["solar_elect_grid"] = "123.123"; //光伏入网电量kWh精度0.001
jsondata["solar_num_err"] = "1"; //光伏设备故障次数
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
json["data"] = jsondata;
return Errcode::OK;
}
@@ -554,12 +731,124 @@ Errcode HttpEntity::queryStatDayList(const httplib::Request& req, httplib::Respo
{
std::string station_id = req.get_param_value("station_id");
std::string category = req.get_param_value("category");
std::string dt_start = req.get_param_value("dt_start");
std::string dt_end = req.get_param_value("dt_end");
std::string dt_start = req.get_param_value("start_date");
std::string dt_end = req.get_param_value("end_date");
if (!dt_start.empty() && dt_end.empty())
int64_t t1 = Utils::time(dt_start)/1000;
int64_t t2 = Utils::time(dt_end)/1000;
int64_t tMax = t1+ 86400 * 30;
NJsonNode jsondata = NJsonNode::array();
for (int64_t t = t1; t<=t2 && t<=tMax; t += 86400)
{
NJsonNode jnode;
jnode["station_id"] = station_id;
if (!category.empty()) jnode["category"] = category;
jnode["dt"] = Utils::dateStr(t*1000); //日期
jnode["storage_elect_in"] = std::to_string(Utils::random(100, 200)); //储能充电电量kWh精度0.001
jnode["storage_elect_out"] = std::to_string(Utils::random(100, 200)); //储能放电电量kWh精度0.001
jnode["storage_num_in"] = std::to_string(Utils::random(1,5)); //储能设备充电次数
jnode["storage_num_out"] = std::to_string(Utils::random(1, 5)); //储能设备放电次数
jnode["storage_num_err"] = std::to_string(Utils::random(1, 5)); //储能设备故障次数
jnode["solar_elect_gen"] = std::to_string(Utils::random(100, 200)); //光伏发电电量kWh精度0.001
jnode["solar_elect_grid "] = std::to_string(Utils::random(100, 200)); //光伏入网电量kWh精度0.001
jnode["solar_num_err"] = std::to_string(Utils::random(1, 5)); //光伏设备故障次数
jnode["charge_elect"] = std::to_string(Utils::random(100, 200)); //充电设备充电电量kWh精度0.001
jnode["charge_num"] = std::to_string(Utils::random(1, 5)); //充电设备充电次数
jnode["charge_num_err"] = std::to_string(Utils::random(1, 5)); //充电设备故障次数
jnode["income_elect"] = std::to_string(Utils::random(100, 200)); //发电收益精度0.01
jnode["income_charge"] = std::to_string(Utils::random(100, 200)); //充电收益精度0.01
jnode["usage_rate"] = std::to_string(Utils::random(10, 50)); //利用率
jsondata.push_back(jnode);
}
json["data"] = jsondata;
return Errcode::OK;
}
Errcode HttpEntity::queryEnvironment(const httplib::Request& req, httplib::Response& resp, NJsonNode& json)
{
std::string stationId = req.get_param_value("station_id");
auto& appdata = Application::data();
auto station = appdata.getStation(Utils::toInt(stationId));
if (!station)
{
spdlog::error("[http] request queryEnvironment failed, get station info error, station_id={}", stationId);
return Errcode::ERR_PARAM;
}
NJsonNode jsondata;
{ // 温湿度
auto& mapTempHumUnit = station->mapTempHumUnit;
NJsonNode nodearray = NJsonNode::array();
for (auto iter = mapTempHumUnit.begin(); iter!=mapTempHumUnit.end(); iter++)
{
auto& unit = iter->second;
NJsonNode node;
node["pos"] = "#" + std::to_string(iter->first);
node["temp"] = unit.temp;
node["hum"] = unit.hum;
nodearray.push_back(node);
}
jsondata["temp_hum"] = nodearray;
}
{ //空调
auto& mapAircUnit = station->mapAircUnit;
AircUnit unitTmp;
AircUnit* unit = (mapAircUnit.size() > 0) ? &(mapAircUnit[0]) : &unitTmp;
NJsonNode nodearray = NJsonNode::array();
if (unit)
{
NJsonNode node;
nodearray.push_back({{"pos", "开关"}, {"status", unit->powerOn == 0 ? "关机" : "开机"}});
nodearray.push_back({{"pos", "启动制冷指令"}, {"status", unit->cooling == 0 ? "启动" : "关闭"}});
nodearray.push_back({{"pos", "启动送风指令"}, {"status", unit->airSupply == 0 ? "关闭" : "启动"}});
nodearray.push_back({{"pos", "启动待机指令"}, {"status", unit->standby == 0 ? "关闭" : "启动"}});
nodearray.push_back({{"pos", "启动加热指令"}, {"status", unit->heating == 0 ? "关闭" : "启动"}});
nodearray.push_back({{"pos", "传感器故障"}, {"status", unit->sensorAlarm == 0 ? "正常" : "告警"}});
nodearray.push_back({{"pos", "高低电压告警"}, {"status", unit->voltageAlarm == 0 ? "正常" : "告警"}});
nodearray.push_back({{"pos", "高低温告警"}, {"status", unit->tempAlarm == 0 ? "正常" : "告警"}});
nodearray.push_back({{"pos", "高低压告警"}, {"status", unit->pressureAlarm == 0 ? "正常" : "告警"}});
nodearray.push_back({{"pos", "压缩机告警"}, {"status", unit->compressorAlarm == 0 ? "正常" : "告警"}});
nodearray.push_back({{"pos", "当前温度"}, {"status", std::to_string(unit->temp) + ""}});
nodearray.push_back({{"pos", "当前湿度"}, {"status", std::to_string(unit->hum) + "%"}});
}
jsondata["airc"] = nodearray;
}
{ // 消防
static std::map<int, std::string> mapFireStatusDef = { {0, "正常"}, {1,"预警"}, {2,"火警"} };
auto& mapFire40Unit = station->mapFire40Unit;
NJsonNode nodearray = NJsonNode::array();
for (auto iter = mapFire40Unit.begin(); iter!=mapFire40Unit.end(); ++iter)
{
NJsonNode node;
node["pos"] = "#" + std::to_string(iter->first);
node["status"] = mapFireStatusDef[iter->second]; // 0正常 1预警 2火警
nodearray.push_back(node);
}
jsondata["fire40"] = nodearray;
}
{ // 冷机
auto& mapCoolingUnit = station->mapCoolingUnit;
CoolingUnit unitTmp;
CoolingUnit* unit = (mapCoolingUnit.size() > 0) ? &(mapCoolingUnit[0]) : &unitTmp;
NJsonNode nodearray = NJsonNode::array();
if (unit)
{
NJsonNode node;
nodearray.push_back({{"pos", "开关"}, {"status", unit->powerOn == 0 ? "关机" : "开机"}});
nodearray.push_back({{"pos", "采样模式"}, {"status", unit->mode == 0 ? "出水温度" : "电芯温度"}});
nodearray.push_back({{"pos", "制冷状态"}, {"status", unit->cooling == 0 ? "关闭" : "启动"}});
nodearray.push_back({{"pos", "制热状态"}, {"status", unit->heating == 0 ? "关闭" : "启动"}});
nodearray.push_back({{"pos", "高温告警"}, {"status", unit->highTemp == 0 ? "正常" : "告警"}});
nodearray.push_back({{"pos", "低温告警"}, {"status", unit->lowTemp == 0 ? "正常" : "告警"}});
nodearray.push_back({{"pos", "高压告警"}, {"status", unit->highPressure == 0 ? "正常" : "告警"}});
nodearray.push_back({{"pos", "低压告警"}, {"status", unit->lowPressure == 0 ? "正常" : "告警"}});
}
jsondata["cooling"] = nodearray;
}
json["data"] = jsondata;
return Errcode::OK;
}