mirror of
https://gitee.com/js-yhsec/energy_storage.git
synced 2026-05-27 18:59:26 +08:00
1070 lines
42 KiB
C++
1070 lines
42 KiB
C++
#include "HttpEntity.h"
|
||
#include "database/Dao.h"
|
||
#include <functional>
|
||
#include "common/Utils.h"
|
||
#include "common/Snowflake.h"
|
||
#include "app/Application.h"
|
||
#include "app/AppData.h"
|
||
#include "app/Config.h"
|
||
#include "app/Station.h"
|
||
#include "app/Device.h"
|
||
|
||
static void FieldsToJson(Fields& fields, njson& json)
|
||
{
|
||
for (auto& item : fields.map())
|
||
{
|
||
json[item.first] = item.second;
|
||
}
|
||
}
|
||
static void JsonToFields(njson& 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 njson::value_t::string: { fields.set(key, json[key].get<std::string>()); } break;
|
||
case njson::value_t::boolean: { fields.set(key, json[key].get<bool>()); } break;
|
||
case njson::value_t::number_integer: { fields.set(key, json[key].get<int>()); } break;
|
||
case njson::value_t::number_unsigned: { fields.set(key, json[key].get<int>()); } break;
|
||
case njson::value_t::number_float: { fields.set(key, json[key].get<float>()); } break;
|
||
case njson::value_t::null: {} break;
|
||
case njson::value_t::object: {} break;
|
||
case njson::value_t::array: {} break;
|
||
case njson::value_t::binary: {} break;
|
||
case njson::value_t::discarded: {} break;
|
||
default:
|
||
break;
|
||
}
|
||
|
||
}
|
||
}
|
||
}
|
||
|
||
static njson FieldsToJsonArray(std::vector<Fields>& vecFields)
|
||
{
|
||
njson jsonnode = njson::array();
|
||
for (auto& fields : vecFields)
|
||
{
|
||
njson jnode;
|
||
for (auto& item : fields.map())
|
||
{
|
||
jnode[item.first] = item.second;
|
||
}
|
||
jsonnode.push_back(jnode);
|
||
}
|
||
return jsonnode;
|
||
}
|
||
|
||
static void GetRequestParam(const httplib::Request& req, const std::vector<std::string>& vecKeys, Fields& fields)
|
||
{
|
||
if (req.method == "GET")
|
||
{
|
||
for (auto& key : vecKeys)
|
||
{
|
||
if (req.has_param(key))
|
||
{
|
||
fields.set(key, req.get_param_value(key));
|
||
}
|
||
}
|
||
}
|
||
else if (req.method == "POST")
|
||
{
|
||
njson json;
|
||
JSON::parse(req.body, json);
|
||
JsonToFields(json, vecKeys, fields);
|
||
}
|
||
}
|
||
|
||
class HttpHelper
|
||
{
|
||
public:
|
||
static bool CheckRequestParam(const httplib::Request& req, httplib::Response& resp, const std::vector<std::string>& vecKeys, std::string& errmsg)
|
||
{
|
||
errmsg = "";
|
||
for (auto& key : vecKeys)
|
||
{
|
||
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 + "]";
|
||
}
|
||
}
|
||
if (!errmsg.empty())
|
||
{
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
static void setPagination(PageInfo& pageinfo, std::vector<Fields> result, njson& json)
|
||
{
|
||
json["count"] = pageinfo.total;
|
||
json["page"] = pageinfo.index;
|
||
json["page_size"] = pageinfo.size;
|
||
json["data"] = FieldsToJsonArray(result);
|
||
}
|
||
};
|
||
|
||
|
||
|
||
static std::map<std::string, HandlerOptions> g_mapHttpHandlerGet =
|
||
{
|
||
{"/login", HandlerOptions(&HttpEntity::login, {DMUser::ACCOUNT, DMUser::PASSWD})},
|
||
{"/queryUserList", HandlerOptions(&HttpEntity::queryUserList, {})},
|
||
{"/deleteUser", HandlerOptions(&HttpEntity::deleteUser, { DMUser::USER_ID})},
|
||
|
||
{"/queryPermissionList", HandlerOptions(&HttpEntity::queryPermissionList, {})},
|
||
{"/deletePermission", HandlerOptions(&HttpEntity::deletePermission, { DMPermission::PERMISSION_ID})},
|
||
|
||
{"/queryRoleList", HandlerOptions(&HttpEntity::queryRoleList, {})},
|
||
{"/deleteRole", HandlerOptions(&HttpEntity::deleteRole, { DMRole::ROLE_ID})},
|
||
|
||
{"/queryStationList", HandlerOptions(&HttpEntity::queryStationList, {})},
|
||
{"/deleteStation", HandlerOptions(&HttpEntity::deleteStation, { DMStation::STATION_ID})},
|
||
|
||
{"/queryStationInfo", HandlerOptions(&HttpEntity::queryStationInfo, { DMStation::STATION_ID})},
|
||
{"/queryStationData", HandlerOptions(&HttpEntity::queryStationData, { DMStation::STATION_ID})},
|
||
{"/queryStationOverview", HandlerOptions(&HttpEntity::queryStationOverview, {DMStation::STATION_ID})},
|
||
|
||
|
||
{"/queryDeviceList", HandlerOptions(&HttpEntity::queryDeviceList, {})},
|
||
{"/deleteDevice", HandlerOptions(&HttpEntity::deleteDevice, { DMDevice::DEVICE_ID})},
|
||
{"/queryDevicTypeDef", HandlerOptions(&HttpEntity::queryDevicTypeDef, {})},
|
||
{"/queryDevicByCategory", HandlerOptions(&HttpEntity::queryDevicByCategory, {DMStation::STATION_ID, "category"})},
|
||
{"/queryDevicCharts", HandlerOptions(&HttpEntity::queryDevicCharts, {DMStation::STATION_ID, "device_id"})},
|
||
|
||
|
||
{"/queryPolicyList", HandlerOptions(&HttpEntity::queryPolicyList, {})},
|
||
|
||
{"/deletePolicy", HandlerOptions(&HttpEntity::deletePolicy, { DMPolicy::POLICY_ID})},
|
||
|
||
{"/querySystemLogList", HandlerOptions(&HttpEntity::querySystemLogList, {})},
|
||
|
||
{"/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"})},
|
||
|
||
|
||
{"/queryServiceApiList", HandlerOptions(&HttpEntity::queryServiceApiList, {})},
|
||
{"/deleteServiceApi", HandlerOptions(&HttpEntity::deleteServiceApi, {"api_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})},
|
||
|
||
{"/insertServiceApi", HandlerOptions(&HttpEntity::insertServiceApi, {})},
|
||
{"/updateServiceApi", HandlerOptions(&HttpEntity::updateServiceApi, {"api_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()
|
||
{
|
||
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)
|
||
{
|
||
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)
|
||
{
|
||
this->runHandler(name, handler, req, resp);
|
||
});
|
||
}
|
||
}
|
||
|
||
void HttpEntity::listen(std::string addr, int port)
|
||
{
|
||
if (addr.empty()) addr = "0.0.0.0";
|
||
spdlog::info("[http] start listen: addr={}:{},token={}", addr, port, Config::option.http.useToken);
|
||
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;
|
||
}
|
||
|
||
njson jsonresp;
|
||
if (errcode == Errcode::OK)
|
||
{
|
||
if (!HttpHelper::CheckRequestParam(req, resp, handler.requiredKeys, errmsg))
|
||
{
|
||
errcode = Errcode::ERR_PARAM;
|
||
}
|
||
else
|
||
{
|
||
errcode = (this->*(handler.func))(req, jsonresp, errmsg);
|
||
}
|
||
}
|
||
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));
|
||
}
|
||
|
||
Errcode HttpEntity::login(const httplib::Request& req, njson& json, std::string& errmsg)
|
||
{
|
||
std::string userId;
|
||
std::string token;
|
||
std::string account = req.get_param_value("account");
|
||
std::string passwd = req.get_param_value("passwd");
|
||
|
||
Fields fields;
|
||
auto dao = DaoEntity::create("");
|
||
Errcode err = DAO::login(dao, account, passwd, fields);
|
||
userId = fields.value(DMUser::USER_ID);
|
||
token = Application::data().userLogin(userId, account);
|
||
if (err == Errcode::OK)
|
||
{
|
||
json["token"] = token;
|
||
|
||
std::vector<Fields> vecPermission;
|
||
int roleId = fields.get<int>(DMRole::ROLE_ID);
|
||
DAO::queryRolePermission(dao, roleId, vecPermission);
|
||
|
||
njson nodePermission = njson::array();
|
||
for (auto& item : vecPermission)
|
||
{
|
||
njson node;
|
||
FieldsToJson(item, node);
|
||
nodePermission.push_back(node);
|
||
}
|
||
json["permission"] = nodePermission;
|
||
}
|
||
|
||
DAO::insertSystemLogUser(token, "用户登录：" + ErrcodeStr(err), (err==Errcode::OK) ? 0: 1);
|
||
return err;
|
||
}
|
||
|
||
Errcode HttpEntity::queryUserList(const httplib::Request& req, njson& json, std::string& errmsg)
|
||
{
|
||
std::string token = req.get_param_value("token");
|
||
PageInfo pageinfo;
|
||
pageinfo.index = Utils::toInt(req.get_param_value("page"));
|
||
pageinfo.size = Utils::toInt(req.get_param_value("page_size"));
|
||
|
||
std::vector<Fields> result;
|
||
auto err = DAO::queryUserList(pageinfo, result);
|
||
if (err == Errcode::OK)
|
||
{
|
||
HttpHelper::setPagination(pageinfo, result, json);
|
||
}
|
||
DAO::insertSystemLogUser(token, "查询用户列表：" + ErrcodeStr(err), (err==Errcode::OK) ? 0 : 1);
|
||
return err;
|
||
}
|
||
|
||
Errcode HttpEntity::insertUser(const httplib::Request& req, njson& json, std::string& errmsg)
|
||
{
|
||
Fields params;
|
||
GetRequestParam(req, {"account", "name", "gender", "age", "phone", "email", "role_id"}, params);
|
||
return DAO::insertUser(params);
|
||
}
|
||
|
||
Errcode HttpEntity::updateUser(const httplib::Request& req, njson& json, std::string& errmsg)
|
||
{
|
||
Fields params;
|
||
GetRequestParam(req, {"user_id", "account", "name", "gender", "age", "phone", "email", "role_id"}, params);
|
||
return DAO::updateUserById(params);
|
||
}
|
||
|
||
Errcode HttpEntity::deleteUser(const httplib::Request& req, njson& json, std::string& errmsg)
|
||
{
|
||
std::string userId = req.get_param_value("user_id");
|
||
return DAO::deleteUserById(userId);
|
||
}
|
||
|
||
Errcode HttpEntity::queryPermissionList(const httplib::Request& req, njson& json, std::string& errmsg)
|
||
{
|
||
PageInfo pageinfo;
|
||
pageinfo.index = Utils::toInt(req.get_param_value("page"));
|
||
pageinfo.size = Utils::toInt(req.get_param_value("page_size"));
|
||
|
||
std::vector<Fields> result;
|
||
auto err = DAO::queryPermissionList(pageinfo, result);
|
||
HttpHelper::setPagination(pageinfo, result, json);
|
||
return err;
|
||
}
|
||
|
||
Errcode HttpEntity::insertPermission(const httplib::Request& req, njson& json, std::string& errmsg)
|
||
{
|
||
Fields params;
|
||
GetRequestParam(req, {"name", "describe", "is_open"}, params);
|
||
return DAO::insertPermission(params);
|
||
}
|
||
|
||
Errcode HttpEntity::updatePermission(const httplib::Request& req, njson& json, std::string& errmsg)
|
||
{
|
||
Fields params;
|
||
GetRequestParam(req, {"permission_id", "name", "describe", "is_open"}, params);
|
||
return DAO::updatePermissionById(params);
|
||
}
|
||
|
||
Errcode HttpEntity::deletePermission(const httplib::Request& req, njson& json, std::string& errmsg)
|
||
{
|
||
std::string permissionId = req.get_param_value("permission_id");
|
||
return DAO::deletePermissionById(permissionId);
|
||
}
|
||
|
||
|
||
Errcode HttpEntity::queryRoleList(const httplib::Request& req, njson& json, std::string& errmsg)
|
||
{
|
||
std::string token = req.get_param_value("page");
|
||
PageInfo pageinfo;
|
||
pageinfo.index = Utils::toInt(req.get_param_value("page"));
|
||
pageinfo.size = Utils::toInt(req.get_param_value("page_size"));
|
||
|
||
std::vector<Fields> result;
|
||
auto err = DAO::queryRoleList(pageinfo, result);
|
||
// 查询所有的角色权限关联
|
||
if (err == Errcode::OK)
|
||
{
|
||
std::vector<Fields> vecPermission;
|
||
err = DAO::queryRolePermission(NULL, vecPermission);
|
||
if (err != Errcode::OK)
|
||
{
|
||
return err;
|
||
}
|
||
|
||
std::map<std::string, std::vector<njson>> mapPermission;
|
||
for (auto& fields: vecPermission)
|
||
{
|
||
std::string roleId = fields.value("role_id");
|
||
auto& v = mapPermission[roleId];
|
||
njson node;
|
||
FieldsToJson(fields, node);
|
||
v.push_back(node);
|
||
}
|
||
|
||
HttpHelper::setPagination(pageinfo, result, json);
|
||
if (json.contains("data"))
|
||
{
|
||
for (auto& item : json["data"])
|
||
{
|
||
std::string roleId = item["role_id"];
|
||
item["permission"] = mapPermission[roleId];
|
||
}
|
||
}
|
||
}
|
||
return err;
|
||
}
|
||
|
||
Errcode HttpEntity::insertRole(const httplib::Request& req, njson& json, std::string& errmsg)
|
||
{
|
||
Fields params;
|
||
GetRequestParam(req, {"name", "describe", "is_open", "permission"}, params);
|
||
return DAO::insertRole(params);
|
||
};
|
||
Errcode HttpEntity::updateRole(const httplib::Request& req, njson& json, std::string& errmsg)
|
||
{
|
||
Fields params;
|
||
//GetRequestParam(req, {"role_id", "name", "describe", "is_open", "permission"}, params);
|
||
|
||
njson jsonparam;
|
||
if (!JSON::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, njson& json, std::string& errmsg)
|
||
{
|
||
std::string roleId = req.get_param_value(DMRole::ROLE_ID);
|
||
return DAO::remove(NULL, DMRole::TABLENAME, DMRole::ROLE_ID, roleId);
|
||
};
|
||
|
||
Errcode HttpEntity::queryStationList(const httplib::Request& req, njson& json, std::string& errmsg)
|
||
{
|
||
PageInfo pageinfo;
|
||
pageinfo.index = Utils::toInt(req.get_param_value("page"));
|
||
pageinfo.size = Utils::toInt(req.get_param_value("page_size"));
|
||
|
||
std::vector<Fields> result;
|
||
auto err = DAO::queryStationList(pageinfo, result);
|
||
HttpHelper::setPagination(pageinfo, result, json);
|
||
return err;
|
||
};
|
||
|
||
Errcode HttpEntity::insertStation(const httplib::Request& req, njson& json, std::string& errmsg)
|
||
{
|
||
|
||
Fields params;
|
||
GetRequestParam(req, {"name", "address", "lon", "lat", "tel", "capacity", "status"}, params);
|
||
return DAO::insertStation(params);
|
||
};
|
||
|
||
Errcode HttpEntity::updateStation(const httplib::Request& req, njson& json, std::string& errmsg)
|
||
{
|
||
Fields params;
|
||
GetRequestParam(req, {"station_id", "name", "address", "lon", "lat", "tel", "capacity", "status"}, params);
|
||
params.check("capacity", "", "0.0");
|
||
params.check("lon", "", "0.0");
|
||
params.check("lat", "", "0.0");
|
||
params.check("status", "", "1");
|
||
return DAO::updateStationById(params);
|
||
};
|
||
|
||
Errcode HttpEntity::deleteStation(const httplib::Request& req, njson& json, std::string& errmsg)
|
||
{
|
||
std::string primaryKey = DMStation::STATION_ID;
|
||
return DAO::remove(NULL, DMStation::TABLENAME, primaryKey, req.get_param_value(primaryKey));
|
||
};
|
||
|
||
Errcode HttpEntity::queryStationOverview(const httplib::Request& req, njson& json, std::string& errmsg)
|
||
{
|
||
Fields params;
|
||
GetRequestParam(req, {"station_id"}, params);
|
||
std::string stationId = params.value("station_id");
|
||
if (stationId.empty())
|
||
{
|
||
return Errcode::ERR_PARAM;
|
||
}
|
||
|
||
auto dao = DaoEntity::create("");
|
||
std::vector<Fields> result;
|
||
|
||
// 运行模式
|
||
std::string sql = "SELECT * FROM station WHERE station_id='" + stationId + "';";
|
||
int ret = dao->exec(sql, result);
|
||
if (ret != 0)
|
||
{
|
||
return Errcode(ret);
|
||
}
|
||
if (result.size() > 0)
|
||
{
|
||
json["data"]["work_mode"] = result[0].get<int>("work_mode");
|
||
}
|
||
|
||
// 储能设备：总功率，数量
|
||
// 充电设备：总功率，数量
|
||
// 光伏设备：总功率，数量
|
||
sql = R"(SELECT d.`type`, count(1) count, ddt.name typename, ddt.category FROM device d
|
||
LEFT JOIN def_device_type ddt ON ddt.device_type_id=d.`type` WHERE d.station_id=')" + stationId + "' GROUP BY `type`;";
|
||
ret = dao->exec(sql, result);
|
||
if (ret != 0)
|
||
{
|
||
return Errcode(ret);
|
||
}
|
||
njson jsonStorage = njson::parse(R"({"category":1, "count":0, "power":0.0})");
|
||
njson jsonCharge = njson::parse(R"({"category":2, "count":0, "power":0.0})");
|
||
njson jsonSolar = njson::parse(R"({"category":3, "count":0, "power":0.0})");
|
||
njson jsonSecurity = njson::parse(R"({"category":4, "count":0, "power":0.0})");
|
||
for (auto& fields : result)
|
||
{
|
||
int category = fields.get<int>("category");
|
||
int count = fields.get<int>("count");
|
||
switch (category)
|
||
{
|
||
case 1: { jsonStorage["count"] = jsonStorage["count"].get<int>() + count; } break;
|
||
case 2: { jsonCharge["count"] = jsonCharge["count"].get<int>() + count; } break;
|
||
case 3: { jsonSolar["count"] = jsonSolar["count"].get<int>() + count; } break;
|
||
case 4: { jsonSecurity["count"] = jsonSecurity["count"].get<int>() + count; } break;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
// 从运行数据中读取功率信息（待补充）
|
||
|
||
json["data"]["device_group"] = {jsonStorage, jsonCharge, jsonSolar, jsonSecurity};
|
||
return Errcode::OK;
|
||
}
|
||
|
||
Errcode HttpEntity::queryStationInfo(const httplib::Request& req, njson& json, std::string& errmsg)
|
||
{
|
||
// 查询场站的基础配置信息
|
||
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];
|
||
|
||
njson jsondata;
|
||
std::string attr = fields.remove(DMStation::ATTR);
|
||
JSON::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, njson& json, std::string& errmsg)
|
||
{
|
||
// 温度， 电压、电流、功率、功率因数、
|
||
njson 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, njson& json, std::string& errmsg)
|
||
{
|
||
PageInfo pageinfo;
|
||
pageinfo.index = Utils::toInt(req.get_param_value("page"));
|
||
pageinfo.size = Utils::toInt(req.get_param_value("page_size"));
|
||
|
||
std::vector<Fields> result;
|
||
auto err = DAO::queryDeviceList(pageinfo, result);
|
||
HttpHelper::setPagination(pageinfo, result, json);
|
||
return err;
|
||
};
|
||
|
||
Errcode HttpEntity::insertDevice(const httplib::Request& req, njson& json, std::string& errmsg)
|
||
{
|
||
Fields params;
|
||
GetRequestParam(req, {"station_id", "type", "name", "code", "model", "factory", "factory_tel", "is_open", "attrs"}, params);
|
||
return DAO::insertDevice(params);
|
||
};
|
||
Errcode HttpEntity::updateDevice(const httplib::Request& req, njson& json, std::string& errmsg)
|
||
{
|
||
Fields params;
|
||
GetRequestParam(req, {"device_id", "station_id", "type", "name", "code", "model", "factory", "factory_tel", "is_open", "attrs"}, params);
|
||
return DAO::updateDeviceById(params);
|
||
};
|
||
Errcode HttpEntity::deleteDevice(const httplib::Request& req, njson& json, std::string& errmsg)
|
||
{
|
||
std::string primaryKey = DMDevice::DEVICE_ID;
|
||
return DAO::remove(NULL, DMDevice::TABLENAME, primaryKey, req.get_param_value(primaryKey));
|
||
};
|
||
Errcode HttpEntity::queryDevicTypeDef(const httplib::Request& req, njson& json, std::string& errmsg)
|
||
{
|
||
std::string sql = "SELECT device_type_id, name FROM def_device_type;";
|
||
std::vector<Fields> result;
|
||
auto err = DAO::exec(NULL, sql, result);
|
||
json["data"] = FieldsToJsonArray(result);
|
||
return err;
|
||
}
|
||
Errcode HttpEntity::queryDevicByCategory(const httplib::Request& req, njson& json, std::string& errmsg)
|
||
{
|
||
Fields params;
|
||
GetRequestParam(req, {"station_id", "category"}, params);
|
||
if (!params.contains("station_id")) { errmsg = "缺少参数[station_id]"; return Errcode::ERR_PARAM; }
|
||
if (!params.contains("category")) { errmsg = "缺少参数[category]"; return Errcode::ERR_PARAM; }
|
||
|
||
int stationId = params.get<int>("station_id");
|
||
int category = params.get<int>("category");
|
||
|
||
njson jsondata = njson::array();
|
||
auto station = Application::data().getStation(stationId);
|
||
if (station)
|
||
{
|
||
std::vector<std::shared_ptr<Device>> vecDevice;
|
||
station->getDeviceByGroup(category, vecDevice);
|
||
|
||
for(auto& device: vecDevice)
|
||
{
|
||
njson jsonnode;
|
||
jsonnode["stationId"] = stationId;
|
||
jsonnode["category"] = category;
|
||
jsonnode["device_id"] = device->deviceId;
|
||
jsonnode["name"] = device->name;
|
||
jsonnode["code"] = device->code;
|
||
jsonnode["type"] = device->type;
|
||
jsonnode["typename"] = Application::data().getDeviceNameById(device->type);
|
||
jsonnode["view"] = 1;
|
||
|
||
jsonnode["is_online"] = device->online;// ? "在线" : "离线";
|
||
jsonnode["is_error"] = device->err;// ? "故障" : "正常";
|
||
jsonnode["is_running"] = device->running;// ? "工作" : "空闲";
|
||
|
||
njson jsonarrayParams = njson::array();
|
||
VecPairSS vec;
|
||
device->getRuntimeParams(vec);
|
||
for (auto& item: vec)
|
||
{
|
||
jsonarrayParams.push_back({{"k", item.first}, {"v", item.second}});
|
||
}
|
||
|
||
jsonnode["params"] = jsonarrayParams;
|
||
jsondata.push_back(jsonnode);
|
||
}
|
||
}
|
||
json["data"] = jsondata;
|
||
return Errcode::OK;
|
||
}
|
||
|
||
Errcode HttpEntity::queryDevicCharts(const httplib::Request& req, njson& json, std::string& errmsg)
|
||
{
|
||
Fields params;
|
||
GetRequestParam(req, {"station_id", "device_id"}, params);
|
||
if (!params.contains("station_id")) { errmsg = "缺少参数[station_id]"; return Errcode::ERR_PARAM; }
|
||
if (!params.contains("device_id")) { errmsg = "缺少参数[device_id]"; return Errcode::ERR_PARAM; }
|
||
|
||
int stationId = params.get<int>("station_id");
|
||
int deviceId = params.get<int>("device_id");
|
||
auto device = Application::data().getDevice(stationId, deviceId);
|
||
|
||
std::vector<std::string> vecV, vecI, vecP;
|
||
if (device)
|
||
{
|
||
device->getCacheVoltage(vecV);
|
||
device->getCacheCurrent(vecI);
|
||
device->getCachePower(vecP);
|
||
}
|
||
json["data"] = {{"V", vecV}, {"I", vecI}, {"P", vecP}};
|
||
return Errcode::OK;
|
||
}
|
||
|
||
Errcode HttpEntity::queryPolicyList(const httplib::Request& req, njson& json, std::string& errmsg)
|
||
{
|
||
PageInfo pageinfo;
|
||
pageinfo.index = Utils::toInt(req.get_param_value("page"));
|
||
pageinfo.size = Utils::toInt(req.get_param_value("page_size"));
|
||
|
||
std::vector<Fields> result;
|
||
auto err = DAO::queryPolicyList(pageinfo, result);
|
||
HttpHelper::setPagination(pageinfo, result, json);
|
||
return err;
|
||
};
|
||
Errcode HttpEntity::insertPolicy(const httplib::Request& req, njson& json, std::string& errmsg)
|
||
{
|
||
Fields params;
|
||
GetRequestParam(req, {"type", "name", "describe", "value", "is_open"}, params);
|
||
return DAO::insertPolicy(params);
|
||
};
|
||
Errcode HttpEntity::updatePolicy(const httplib::Request& req, njson& json, std::string& errmsg)
|
||
{
|
||
Fields params;
|
||
GetRequestParam(req, {"policy_id", "type", "describe", "value", "is_open"}, params);
|
||
return DAO::updatePolicyById(params);
|
||
};
|
||
Errcode HttpEntity::deletePolicy(const httplib::Request& req, njson& json, std::string& errmsg)
|
||
{
|
||
Fields params;
|
||
GetRequestParam(req, {"policy_id"}, params);
|
||
return DAO::deletePolicyById(params.value("policy_id"));
|
||
};
|
||
|
||
Errcode HttpEntity::querySystemLogList(const httplib::Request& req, njson& json, std::string& errmsg)
|
||
{
|
||
PageInfo pageinfo;
|
||
pageinfo.index = Utils::toInt(req.get_param_value("page"));
|
||
pageinfo.size = Utils::toInt(req.get_param_value("page_size"));
|
||
|
||
std::vector<Fields> result;
|
||
auto err = DAO::querySystemLogList(pageinfo, result);
|
||
HttpHelper::setPagination(pageinfo, result, json);
|
||
return err;
|
||
}
|
||
|
||
//Errcode insertSystemLog(const httplib::Request& req, httplib::Response& resp, NJsonNode& json);
|
||
Errcode HttpEntity::updateSystemLog(const httplib::Request& req, njson& json, std::string& errmsg)
|
||
{
|
||
Fields params;
|
||
GetRequestParam(req, {"log_id", "status"}, params);
|
||
return DAO::updateSystemLogById(params);
|
||
}
|
||
|
||
Errcode HttpEntity::queryAlertLogList(const httplib::Request& req, njson& json, std::string& errmsg)
|
||
{
|
||
PageInfo pageinfo;
|
||
pageinfo.index = Utils::toInt(req.get_param_value("page"));
|
||
pageinfo.size = Utils::toInt(req.get_param_value("page_size"));
|
||
|
||
std::vector<Fields> result;
|
||
auto err = DAO::queryAlertLogList(pageinfo, result);
|
||
HttpHelper::setPagination(pageinfo, result, json);
|
||
return err;
|
||
}
|
||
|
||
//Errcode insertAlertLog(const httplib::Request& req, httplib::Response& resp, NJsonNode& json);
|
||
Errcode HttpEntity::updateAlertLog(const httplib::Request& req, njson& json, std::string& errmsg)
|
||
{
|
||
Fields params;
|
||
GetRequestParam(req, {"log_id", "status"}, params);
|
||
return DAO::updateAlertLogById(params);
|
||
}
|
||
|
||
Errcode HttpEntity::queryPredictionDetail(const httplib::Request& req, njson& json, std::string& errmsg)
|
||
{
|
||
njson jsonData = njson::array();
|
||
|
||
std::vector<std::string> vecStoreIn(144), vecStoreOut(144), vecCharge(144), vecSolar(144), vecSolarP(144);
|
||
for (int i = 0; i<144; ++i)
|
||
{
|
||
vecStoreIn[i] = Utils::toStr(float(Utils::random(50, 100)));
|
||
vecStoreOut[i] = Utils::toStr(float(Utils::random(50, 100)));
|
||
vecCharge[i] = Utils::toStr(float(Utils::random(50, 100)));
|
||
vecSolar[i] = Utils::toStr(float(Utils::random(50, 100)));
|
||
vecSolarP[i] = Utils::toStr(float(Utils::random(50, 100)));
|
||
}
|
||
|
||
json["data"] = jsonData;
|
||
json["data"] = {
|
||
{"W_store_in", vecStoreIn},
|
||
{"W_store_out", vecStoreOut},
|
||
{"W_charge", vecCharge},
|
||
{"W_solar", vecSolar},
|
||
{"P_solar", vecSolarP }
|
||
};
|
||
return Errcode::OK;
|
||
}
|
||
|
||
Errcode HttpEntity::queryStatSystem(const httplib::Request& req, njson& json, std::string& errmsg)
|
||
{
|
||
auto& appdata = Application::data();
|
||
|
||
njson 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, njson& json, std::string& errmsg)
|
||
{
|
||
std::string station_id = req.get_param_value("station_id");
|
||
std::string category = req.get_param_value("category");
|
||
|
||
njson 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, njson& json, std::string& errmsg)
|
||
{
|
||
std::string station_id = req.get_param_value("station_id");
|
||
std::string category = req.get_param_value("category");
|
||
njson 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::queryStatDayList(const httplib::Request& req, njson& json, std::string& errmsg)
|
||
{
|
||
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("start_date");
|
||
std::string dt_end = req.get_param_value("end_date");
|
||
|
||
int64_t t1 = Utils::time(dt_start)/1000;
|
||
int64_t t2 = Utils::time(dt_end)/1000;
|
||
|
||
int64_t tMax = t1+ 86400 * 30;
|
||
njson jsondata = njson::array();
|
||
for (int64_t t = t1; t<=t2 && t<=tMax; t += 86400)
|
||
{
|
||
njson 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, njson& json, std::string& errmsg)
|
||
{
|
||
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;
|
||
}
|
||
|
||
njson jsondata;
|
||
|
||
{ // 温湿度
|
||
auto& mapTempHumUnit = station->mapTempHumUnit;
|
||
njson nodearray = njson::array();
|
||
for (auto iter = mapTempHumUnit.begin(); iter!=mapTempHumUnit.end(); iter++)
|
||
{
|
||
auto& unit = iter->second;
|
||
njson 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;
|
||
njson nodearray = njson::array();
|
||
if (unit)
|
||
{
|
||
njson 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;
|
||
njson nodearray = njson::array();
|
||
for (auto iter = mapFire40Unit.begin(); iter!=mapFire40Unit.end(); ++iter)
|
||
{
|
||
njson 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;
|
||
njson nodearray = njson::array();
|
||
if (unit)
|
||
{
|
||
njson 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;
|
||
}
|
||
|
||
|
||
Errcode HttpEntity::queryServiceApiList(const httplib::Request& req, njson& json, std::string& errmsg)
|
||
{
|
||
PageInfo pageinfo;
|
||
pageinfo.index = Utils::toInt(req.get_param_value("page"));
|
||
pageinfo.size = Utils::toInt(req.get_param_value("page_size"));
|
||
std::vector<Fields> result;
|
||
std::string sql = "SELECT * FROM serviceapi;" ;
|
||
auto err = DAO::exec(NULL, sql, result);
|
||
HttpHelper::setPagination(pageinfo, result, json);
|
||
return err;
|
||
}
|
||
|
||
Errcode HttpEntity::insertServiceApi(const httplib::Request& req, njson& json, std::string& errmsg)
|
||
{
|
||
Fields params;
|
||
GetRequestParam(req, {"name", "describe", "params", "is_open"}, params);
|
||
if (params.size() == 0) { return Errcode::ERR_PARAM; }
|
||
|
||
return DAO::insert(NULL, "serviceapi", params);
|
||
}
|
||
|
||
Errcode HttpEntity::updateServiceApi(const httplib::Request& req, njson& json, std::string& errmsg)
|
||
{
|
||
Fields params;
|
||
GetRequestParam(req, {"api_id", "name", "describe", "params", "is_open"}, params);
|
||
if (params.size() == 0) { return Errcode::ERR_PARAM; }
|
||
|
||
return DAO::update(NULL, "serviceapi", params, "api_id");
|
||
}
|
||
|
||
Errcode HttpEntity::deleteServiceApi(const httplib::Request& req, njson& json, std::string& errmsg)
|
||
{
|
||
Fields params;
|
||
GetRequestParam(req, {"api_id"}, params);
|
||
return DAO::remove(NULL, "serviceapi", "api_id", params.value("api_id"));
|
||
} |