jsyhsec/energy_storage
7
0
Fork 0
mirror of https://gitee.com/js-yhsec/energy_storage.git synced 2026-05-28 03:09:24 +08:00
Code Issues Packages Projects Releases Wiki Activity

修改运行监控场站及设备信息查询接口

Browse Source
This commit is contained in:
lixiaoyuan
2025-09-06 15:23:07 +08:00
parent aca9a8f0ae
commit 566a3b050c
17 changed files with 468 additions and 302 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
src/app/AppData.cpp
View File

@@ -11,19 +11,19 @@
void ElectPeriod::parse(std::string jsonstr) void ElectPeriod::parse(std::string jsonstr)
{ {
NJsonNode jsonroot; njson jsonroot;
NJson::parse(jsonstr, jsonroot); JSON::parse(jsonstr, jsonroot);
NJson::read(jsonroot, "price_super_peak", this->priceSuperPeak); JSON::read(jsonroot, "price_super_peak", this->priceSuperPeak);
NJson::read(jsonroot, "price_peak", this->pricePeak); JSON::read(jsonroot, "price_peak", this->pricePeak);
NJson::read(jsonroot, "price_shoulder", this->priceShoulder); JSON::read(jsonroot, "price_shoulder", this->priceShoulder);
NJson::read(jsonroot, "price_off_peak", this->priceOffPeak); JSON::read(jsonroot, "price_off_peak", this->priceOffPeak);
NJson::read<std::vector<std::vector<std::string>>>(jsonroot, "periods", this->vecPeriods); JSON::read<std::vector<std::vector<std::string>>>(jsonroot, "periods", this->vecPeriods);
} }
std::string ElectPeriod::dump() std::string ElectPeriod::dump()
{ {
NJsonNode jsonroot; njson jsonroot;
jsonroot["price_super_peak"] = this->priceSuperPeak; jsonroot["price_super_peak"] = this->priceSuperPeak;
jsonroot["price_peak"] = this->pricePeak; jsonroot["price_peak"] = this->pricePeak;
jsonroot["price_shoulder"] = this->priceShoulder; jsonroot["price_shoulder"] = this->priceShoulder;
@@ -130,8 +130,6 @@ void AppData::initFromDB()
if (station) if (station)
{ {
auto device = Device::create(fields); auto device = Device::create(fields);
auto deviceTypeDef = this->getDeviceTypeDef(device->type);
device->group = deviceTypeDef->group;
station->addDevice(deviceId, device); station->addDevice(deviceId, device);
} }
else else

20
src/app/Config.cpp
View File

@@ -10,8 +10,8 @@ AppOption Config::option;
bool Config::init(std::string filename) bool Config::init(std::string filename)
{ {
NJsonNode jsonroot; njson jsonroot;
bool ret = NJson::load(filename, jsonroot); bool ret = JSON::load(filename, jsonroot);
if (!ret) if (!ret)
{ {
spdlog::error("[config] load config file failed, filename={}", filename); spdlog::error("[config] load config file failed, filename={}", filename);
@@ -21,7 +21,7 @@ bool Config::init(std::string filename)
if (jsonroot.contains("database")) if (jsonroot.contains("database"))
{ {
NJsonNode json = jsonroot.at("database"); njson json = jsonroot.at("database");
option.database.host = json.contains("host") ? json.at("host") : ""; option.database.host = json.contains("host") ? json.at("host") : "";
option.database.port = json.contains("port") ? json.at("port") : 0; option.database.port = json.contains("port") ? json.at("port") : 0;
option.database.user = json.contains("user") ? json.at("user") : ""; option.database.user = json.contains("user") ? json.at("user") : "";
@@ -37,11 +37,11 @@ bool Config::init(std::string filename)
if (jsonroot.contains("http")) if (jsonroot.contains("http"))
{ {
NJsonNode json = jsonroot.at("http"); njson json = jsonroot.at("http");
std:string token; std:string token;
NJson::read(json, "token", token); JSON::read(json, "token", token);
option.http.useToken = !token.empty(); option.http.useToken = !token.empty();
NJson::read(json, "port", option.http.port); JSON::read(json, "port", option.http.port);
} }
else else
{ {
@@ -50,10 +50,10 @@ bool Config::init(std::string filename)
if (jsonroot.contains("mqtt")) if (jsonroot.contains("mqtt"))
{ {
NJsonNode json = jsonroot.at("mqtt"); njson json = jsonroot.at("mqtt");
NJson::read(json, "host", option.mqtt.host); JSON::read(json, "host", option.mqtt.host);
NJson::read(json, "username", option.mqtt.username); JSON::read(json, "username", option.mqtt.username);
NJson::read(json, "password", option.mqtt.password); JSON::read(json, "password", option.mqtt.password);
} }
else else
{ {

52
src/app/DataStruct.cpp
View File

@@ -2,37 +2,37 @@
void EMSYX::fromJson(const std::string& str) void EMSYX::fromJson(const std::string& str)
{ {
NJsonNode jsonroot; njson jsonroot;
auto ret = NJson::parse(str, jsonroot); auto ret = JSON::parse(str, jsonroot);
if (!ret) { return; } if (!ret) { return; }
NJson::read(jsonroot, "mcu", mcu); JSON::read(jsonroot, "mcu", mcu);
NJson::read(jsonroot, "pcs", pcs); JSON::read(jsonroot, "pcs", pcs);
NJson::read(jsonroot, "electMeterMainPoint", electMeterMainPoint); JSON::read(jsonroot, "electMeterMainPoint", electMeterMainPoint);
NJson::read(jsonroot, "electMeter", electMeter); JSON::read(jsonroot, "electMeter", electMeter);
NJson::read(jsonroot, "fireSystem", fireSystem); JSON::read(jsonroot, "fireSystem", fireSystem);
NJson::read(jsonroot, "ups", ups); JSON::read(jsonroot, "ups", ups);
NJson::read(jsonroot, "temHumMainPoint", temHumMainPoint); JSON::read(jsonroot, "temHumMainPoint", temHumMainPoint);
NJson::read(jsonroot, "temHum", temHum); JSON::read(jsonroot, "temHum", temHum);
NJson::read(jsonroot, "aircMainPoint", aircMainPoint); JSON::read(jsonroot, "aircMainPoint", aircMainPoint);
NJson::read(jsonroot, "airc", airc); JSON::read(jsonroot, "airc", airc);
NJson::read(jsonroot, "controlDryContact", controlDryContact); JSON::read(jsonroot, "controlDryContact", controlDryContact);
NJson::read(jsonroot, "statusDryContact", statusDryContact); JSON::read(jsonroot, "statusDryContact", statusDryContact);
NJson::read(jsonroot, "bcuMain", bcuMain); JSON::read(jsonroot, "bcuMain", bcuMain);
NJson::read(jsonroot, "pcuMain", pcuMain); JSON::read(jsonroot, "pcuMain", pcuMain);
NJson::read(jsonroot, "electMeterMain", electMeterMain); JSON::read(jsonroot, "electMeterMain", electMeterMain);
NJson::read(jsonroot, "fireSystemMain", fireSystemMain); JSON::read(jsonroot, "fireSystemMain", fireSystemMain);
NJson::read(jsonroot, "upsMain", upsMain); JSON::read(jsonroot, "upsMain", upsMain);
NJson::read(jsonroot, "temHumMain", temHumMain); JSON::read(jsonroot, "temHumMain", temHumMain);
NJson::read(jsonroot, "aircMain", aircMain); JSON::read(jsonroot, "aircMain", aircMain);
NJson::read(jsonroot, "emu", emu); JSON::read(jsonroot, "emu", emu);
NJson::read(jsonroot, "chillerMain", chillerMain); JSON::read(jsonroot, "chillerMain", chillerMain);
NJson::read(jsonroot, "chillerMainPoint", chillerMainPoint); JSON::read(jsonroot, "chillerMainPoint", chillerMainPoint);
NJson::read(jsonroot, "chiller", chiller); JSON::read(jsonroot, "chiller", chiller);
} }
std::string EMSYX::toJson() std::string EMSYX::toJson()
{ {
NJsonNode jsonroot; njson jsonroot;
jsonroot["bms"] = bms; jsonroot["bms"] = bms;
jsonroot["bcu"] = bcu; jsonroot["bcu"] = bcu;
jsonroot["mcu"] = mcu; jsonroot["mcu"] = mcu;

114
src/app/Device.cpp
View File

@@ -1,6 +1,6 @@
#include "Device.h" #include "Device.h"
#include "common/Logger.h" #include "common/Spdlogger.h"
#include "common/Utils.h" #include "common/Utils.h"
#include "protocol/CommEntity.h" #include "protocol/CommEntity.h"
#include "common/JsonN.h" #include "common/JsonN.h"
@@ -44,26 +44,66 @@ int Device::startComm()
return 0; return 0;
} }
// 从属性列表中获取通讯方式和通讯地址、端口 //// 从属性列表中获取通讯方式和通讯地址、端口
std::string commType = attrs.value("commType"); //std::string commType = attrs.value("commType");
//
// 如果entity的通讯协议类型当前配置不一致，需要关闭连接删除通讯后创建新的通讯 //// 如果entity的通讯协议类型当前配置不一致，需要关闭连接删除通讯后创建新的通讯
if (commEntity && commEntity->type != commType) //if (commEntity && commEntity->type != commType)
{ //{
commEntity->close(); // commEntity->close();
commEntity = nullptr; // commEntity = nullptr;
} //}
// 创建新的通讯 //// 创建新的通讯
if (!commEntity) //if (!commEntity)
{ //{
commEntity = CommEntity::create(attrs); // commEntity = CommEntity::create(attrs);
if (!commEntity) { return -1; } // if (!commEntity) { return -1; }
} //}
//commEntity->start();
commEntity->start();
return 0; return 0;
} }
void Device::getRuntimeParams(std::vector<std::pair<std::string, std::string>>& params)
{
params.push_back({"额定电压", "0.0V"});
params.push_back({"实时电压", "0.0V"});
params.push_back({"额定电流", "0.0A"});
params.push_back({"实时电流", "0.0A"});
params.push_back({"额定功率", "0.0kW"});
params.push_back({"实时功率", "0.0A"});
}
void Device::getCacheVoltage(std::vector<std::string>& vec)
{
vec.resize(mapCacheVoltage.size());
int i = 0;
for (auto iter = mapCacheVoltage.begin(); iter != mapCacheVoltage.end(); ++iter)
{
vec[i] = Utils::toStr(iter->second);
i++;
}
}
void Device::getCacheCurrent(std::vector<std::string>& vec)
{
vec.resize(mapCacheCurrent.size());
int i = 0;
for (auto iter = mapCacheCurrent.begin(); iter != mapCacheCurrent.end(); ++iter)
{
vec[i] = Utils::toStr(iter->second);
i++;
}
}
void Device::getCachePower(std::vector<std::string>& vec)
{
vec.resize(mapCachePower.size());
int i = 0;
for (auto iter = mapCachePower.begin(); iter != mapCachePower.end(); ++iter)
{
vec[i] = Utils::toStr(iter->second);
i++;
}
}
std::shared_ptr<Device> Device::create(Fields& fields) std::shared_ptr<Device> Device::create(Fields& fields)
{ {
auto device = std::make_shared<Device>(); auto device = std::make_shared<Device>();
@@ -73,13 +113,14 @@ std::shared_ptr<Device> Device::create(Fields& fields)
device->code = fields.value("code"); device->code = fields.value("code");
device->isOpen = fields.get<int>("is_open"); device->isOpen = fields.get<int>("is_open");
device->attrsJson = fields.value("attrs"); device->attrsJson = fields.value("attrs");
device->category = fields.get<int>("category");
// 解析属性的JSON字符串，转换成键值对 // 解析属性的JSON字符串，转换成键值对
NJsonNode jsonroot; njson jsonroot;
bool ret = NJson::parse(device->attrsJson, jsonroot); bool ret = JSON::parse(device->attrsJson, jsonroot);
if (!ret) // 解析错误 if (!ret) // 解析错误
{ {
XLOGE() << "device attr json parse error, device_id=" << device->deviceId; spdlog::error("[device] device attr json parse error, device_id={}", device->deviceId);
} }
else else
{ {
@@ -92,30 +133,23 @@ std::shared_ptr<Device> Device::create(Fields& fields)
device->attrs.set(key, val.get<int>()); device->attrs.set(key, val.get<int>());
} }
else { else {
XLOGE() << key << ": [" << valType << "]"; spdlog::error("[device] device attr unknown type: key={}, valtype={}", key, valType);
} }
} }
} }
int step = 600;
for (int i = 0; i*600<86400; ++i)
{
double voltage = double(Utils::random(20000, 30000))*0.01;
double current = double(Utils::random(1000, 2000))*0.01;
device->mapCacheVoltage[i*step] = voltage;
device->mapCacheCurrent[i*step] = current;
device->mapCachePower[i*step] = voltage * current;
}
// 启动通讯，该函数中会自动判断isOpen状态，选择是否进行通讯连接 // 启动通讯，该函数中会自动判断isOpen状态，选择是否进行通讯连接
device->startComm(); //device->startComm();
return device; return device;
} }
//
//std::vector<std::shared_ptr<DeviceEntity>> Device::getDeviceByType(int type)
//{
// std::vector<std::shared_ptr<DeviceEntity>> vecDevice;
// for (auto iter = mapDevices.begin(); iter!=mapDevices.end(); ++iter)
// {
// auto device = iter->second;
// if (device && (type<=0 || device->type == type))
// {
// vecDevice.push_back(device);
// }
// }
// return vecDevice;
//}

12
src/app/Device.h
View File

@@ -16,13 +16,13 @@ public:
int type = -1; int type = -1;
std::string name; std::string name;
std::string code; std::string code;
std::string group; int category;
bool isOpen = false; bool isOpen = false;
std::string attrsJson = ""; std::string attrsJson = "";
int err = 0; int err = 0;
int online = 0; int online = 0;
int status = 0; int running = 0;
//std::map<std::string, std::string> mapAttrs; //std::map<std::string, std::string> mapAttrs;
Fields attrs; Fields attrs;
@@ -37,10 +37,16 @@ public:
int64_t tsDataDate {}; int64_t tsDataDate {};
std::map<int, double> mapCacheData; std::map<int, double> mapCacheVoltage;
std::map<int, double> mapCacheCurrent;
std::map<int, double> mapCachePower;
// 启动通讯 // 启动通讯
int startComm(); int startComm();
void getRuntimeParams(std::vector<std::pair<std::string, std::string>>& params);
void getCacheVoltage(std::vector<std::string>& vec);
void getCacheCurrent(std::vector<std::string>& vec);
void getCachePower(std::vector<std::string>& vec);
static std::shared_ptr<Device> create(Fields& fields); static std::shared_ptr<Device> create(Fields& fields);
}; };

17
src/app/Station.cpp
View File

@@ -42,7 +42,7 @@ void Station::setFields(Fields& fields)
void Station::addDevice(int deviceId, std::shared_ptr<Device> device) void Station::addDevice(int deviceId, std::shared_ptr<Device> device)
{ {
mapDevice[deviceId] = device; mapDevice[deviceId] = device;
mapDeviceGroupNum[device->group]++; mapDeviceGroup[device->category].push_back(device);
} }
std::shared_ptr<Device> Station::getDevice(int deviceId) std::shared_ptr<Device> Station::getDevice(int deviceId)
@@ -67,20 +67,17 @@ void Station::getDeviceByType(int typeId, std::vector<std::shared_ptr<Device>>&
} }
} }
int Station::getDeviceNumByGroup(std::string name) int Station::getDeviceNumByGroup(int category)
{ {
return mapDeviceGroupNum[name]; return 0;
} }
void Station::getDeviceByGroup(std::string name, std::vector<std::shared_ptr<Device>>& res) void Station::getDeviceByGroup(int category, std::vector<std::shared_ptr<Device>>& res)
{ {
for (auto iter = mapDevice.begin(); iter!=mapDevice.end(); ++iter) auto iter = mapDeviceGroup.find(category);
if (iter != mapDeviceGroup.end())
{ {
auto device = iter->second; res = iter->second;
if (device->group == name)
{
res.push_back(device);
}
} }
} }

8
src/app/Station.h
View File

@@ -98,8 +98,8 @@ public:
std::shared_ptr<Device> getDevice(int deviceId); std::shared_ptr<Device> getDevice(int deviceId);
void getDeviceByType(int typeId, std::vector<std::shared_ptr<Device>>& res); void getDeviceByType(int typeId, std::vector<std::shared_ptr<Device>>& res);
int getDeviceNumByGroup(std::string name); int getDeviceNumByGroup(int category);
void getDeviceByGroup(std::string name, std::vector<std::shared_ptr<Device>>& res); void getDeviceByGroup(int category, std::vector<std::shared_ptr<Device>>& res);
void setWorkMode(int modeId); void setWorkMode(int modeId);
void setPolicy(int policyId); void setPolicy(int policyId);
@@ -169,8 +169,8 @@ public:
/////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////
/// === 设备信息 === /// === 设备信息 ===
std::unordered_map<int, std::shared_ptr<Device>> mapDevice; std::unordered_map<int, std::shared_ptr<Device>> mapDevice;
std::map<int, std::vector<std::shared_ptr<Device>>> mapDeviceGroup;
std::map<std::string, int> mapDeviceGroupNum;
// 温湿度信息 // 温湿度信息
std::map<int, TempHumUnit> mapTempHumUnit; std::map<int, TempHumUnit> mapTempHumUnit;
@@ -184,4 +184,6 @@ public:
/////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////
/// === MQTT client /// === MQTT client
std::shared_ptr<MqttClient> mqttCli {nullptr}; std::shared_ptr<MqttClient> mqttCli {nullptr};
}; };

4
src/common/Fields.cpp
View File

@@ -182,8 +182,8 @@ string Fields::toSqlUpdate(string tableName, std::vector<std::string> vecKeys, s
void Fields::parseJson(std::string jsonstr) void Fields::parseJson(std::string jsonstr)
{ {
NJsonNode jsonroot; njson jsonroot;
NJson::parse(jsonstr, jsonroot); JSON::parse(jsonstr, jsonroot);
for (auto& item : jsonroot.items()) for (auto& item : jsonroot.items())
{ {
this->set(item.key(), item.value()); this->set(item.key(), item.value());

16
src/common/JsonN.h
View File

@@ -5,7 +5,7 @@
#include <memory> #include <memory>
#include <iostream> #include <iostream>
using NJsonNode = nlohmann::json; using njson = nlohmann::json;
/// ============================================================================================= /// =============================================================================================
/// 使用说明： /// 使用说明：
@@ -48,10 +48,10 @@ using NJsonNode = nlohmann::json;
// std::vector<int> v1; // std::vector<int> v1;
// v1 = j.at["data"].get<std::vector<int>>() // v1 = j.at["data"].get<std::vector<int>>()
class NJson class JSON
{ {
public: public:
static bool load(std::string jsonfile, NJsonNode& json) static bool load(std::string jsonfile, njson& json)
{ {
std::ifstream ifs(jsonfile); std::ifstream ifs(jsonfile);
if (!ifs.is_open()) { return false; } if (!ifs.is_open()) { return false; }
@@ -60,11 +60,11 @@ public:
return true; return true;
} }
static bool parse(std::string jsonstr, NJsonNode& json) static bool parse(std::string jsonstr, njson& json)
{ {
try try
{ {
if (!jsonstr.empty()) { json = NJsonNode::parse(jsonstr); } if (!jsonstr.empty()) { json = njson::parse(jsonstr); }
} }
catch (nlohmann::json::parse_error& e) catch (nlohmann::json::parse_error& e)
{ {
@@ -75,7 +75,7 @@ public:
} }
template <typename T> template <typename T>
static void read(NJsonNode& json, std::string k, T& v) static void read(njson& json, std::string k, T& v)
{ {
try try
{ {
@@ -89,8 +89,8 @@ public:
static void parse(std::string jsonstr, std::vector<std::string>& vd) static void parse(std::string jsonstr, std::vector<std::string>& vd)
{ {
NJsonNode jsonroot; njson jsonroot;
if (NJson::parse(jsonstr, jsonroot)) if (JSON::parse(jsonstr, jsonroot))
{ {
vd = jsonroot.get<std::vector<std::string>>(); vd = jsonroot.get<std::vector<std::string>>();
} }

3
src/database/Dao.cpp
View File

@@ -111,6 +111,7 @@ static Errcode QueryPagination(std::string sqlFields, std::string sqlCondition,
} }
if (page.index < 1) page.index = 1; if (page.index < 1) page.index = 1;
if (page.size <= 0) page.size = 10;
page.total = count; page.total = count;
std::string sql = "SELECT " + sqlFields + " " + sqlCondition + DAO::sqlPageLimit(page.index -1, page.size); std::string sql = "SELECT " + sqlFields + " " + sqlCondition + DAO::sqlPageLimit(page.index -1, page.size);
int ret = dao.exec(sql, result); int ret = dao.exec(sql, result);
@@ -416,7 +417,7 @@ Errcode DAO::updateStationById(Fields& params)
// 查询设备信息列表 // 查询设备信息列表
Errcode DAO::queryDeviceList(std::shared_ptr<DaoEntity> dao, vector<Fields>& result) Errcode DAO::queryDeviceList(std::shared_ptr<DaoEntity> dao, vector<Fields>& result)
{ {
std::string sql = "SELECT * FROM " + DMDevice::TABLENAME; std::string sql = "SELECT d.*, ddt.category FROM device d LEFT JOIN def_device_type ddt ON d.`type`=ddt.device_type_id;";
return DAO::exec(dao, sql, result); return DAO::exec(dao, sql, result);
} }

63
src/database/DaoEntity.cpp
View File

@@ -12,18 +12,18 @@ DaoEntity::DaoEntity(string tb_name)
//opts.password = "123456"; //opts.password = "123456";
//opts.port = 3306; //opts.port = 3306;
//opts.dbname = "pvb"; //opts.dbname = "pvb";
db_ = make_shared<MysqlClient>(DaoEntity::option); db = make_shared<MysqlClient>(DaoEntity::option);
if (!db_->isConnected()) if (!db->isConnected())
{ {
//Global::data().status_msg = "数据库连接异常！"; //Global::data().status_msg = "数据库连接异常！";
//PvInstance::send_user_event(nullptr, EUserEvent::ALARM_DB, "数据库连接异常！"); //PvInstance::send_user_event(nullptr, EUserEvent::ALARM_DB, "数据库连接异常！");
} }
tableName_ = tb_name; tableName = tb_name;
} }
DaoEntity::~DaoEntity() DaoEntity::~DaoEntity()
{ {
db_ = nullptr; db = nullptr;
} }
MysqlOption& DaoEntity::mysqlOption() MysqlOption& DaoEntity::mysqlOption()
@@ -58,34 +58,34 @@ bool DaoEntity::execOnce(string sql, vector<Fields>& result)
void DaoEntity::setTableName(string tb_name) void DaoEntity::setTableName(string tb_name)
{ {
tableName_ = tb_name; tableName = tb_name;
} }
bool DaoEntity::isConnected() bool DaoEntity::isConnected()
{ {
return db_->isConnected(); return db->isConnected();
} }
int DaoEntity::exec(string sql) int DaoEntity::exec(string sql)
{ {
return db_->exec(sql); return db->exec(sql);
} }
int DaoEntity::exec(string sql, vector<Fields>& result) int DaoEntity::exec(string sql, vector<Fields>& result)
{ {
return db_->exec(sql, result); return db->exec(sql, result);
} }
int DaoEntity::insertFields(Fields& fields) int DaoEntity::insertFields(Fields& fields)
{ {
string sql = fields.toSqlInsert(tableName_); string sql = fields.toSqlInsert(tableName);
return this->db_->exec(sql); return this->db->exec(sql);
} }
int DaoEntity::insertFields(vector<Fields>& vec_fields) int DaoEntity::insertFields(vector<Fields>& vec_fields)
{ {
//"insert into TABLE () values ()"; //"insert into TABLE () values ()";
string sql = "insert into " + tableName_; string sql = "insert into " + tableName;
bool first = true; bool first = true;
string keys; string keys;
string values; string values;
@@ -100,16 +100,10 @@ int DaoEntity::insertFields(vector<Fields>& vec_fields)
const string& v = item.second; const string& v = item.second;
if (first) if (first)
{ {
if (!keys.empty()) if (!keys.empty()) { keys += ","; }
{
keys += ",";
}
keys += k; keys += k;
} }
if (!values.empty()) if (!values.empty()) { values += ","; }
{
values += ",";
}
values += ("'" + v + "'"); values += ("'" + v + "'");
} }
if (first) if (first)
@@ -124,7 +118,7 @@ int DaoEntity::insertFields(vector<Fields>& vec_fields)
} }
} }
sql += ";"; sql += ";";
return this->db_->exec(sql); return this->db->exec(sql);
} }
int DaoEntity::duplicateUpdate(Fields& fields, const vector<string>& keys) int DaoEntity::duplicateUpdate(Fields& fields, const vector<string>& keys)
@@ -150,8 +144,8 @@ int DaoEntity::duplicateUpdate(Fields& fields, const vector<string>& keys)
} }
str += (k + "='" + fields.value(k) + "'"); str += (k + "='" + fields.value(k) + "'");
} }
string sql = "INSERT INTO " + tableName_ + "(" + key + ") VALUES (" + val + ") ON duplicate KEY UPDATE " + str; string sql = "INSERT INTO " + tableName + "(" + key + ") VALUES (" + val + ") ON duplicate KEY UPDATE " + str;
return this->db_->exec(sql); return this->db->exec(sql);
} }
//void DaoEntity::queryFields(const string& condition, DaoPageinfo& pageinfo, vector<map<string, string>>& result) //void DaoEntity::queryFields(const string& condition, DaoPageinfo& pageinfo, vector<map<string, string>>& result)
@@ -164,18 +158,18 @@ int DaoEntity::duplicateUpdate(Fields& fields, const vector<string>& keys)
int DaoEntity::queryFields(string keys, const string& condition, vector<Fields>& result) int DaoEntity::queryFields(string keys, const string& condition, vector<Fields>& result)
{ {
ostringstream oss; ostringstream oss;
oss << "SELECT " + keys + " FROM " << tableName_ << (" " + condition) << "; "; oss << "SELECT " + keys + " FROM " << tableName << (" " + condition) << "; ";
return this->db_->exec(oss.str(), result); return this->db->exec(oss.str(), result);
} }
int DaoEntity::queryFields(string keys, const string& condition, PageInfo& page, vector<Fields>& result) int DaoEntity::queryFields(string keys, const string& condition, PageInfo& page, vector<Fields>& result)
{ {
int err = 0; int err = 0;
ostringstream oss; ostringstream oss;
oss << "SELECT count(1) total FROM `" << tableName_ << "` " << condition << ";"; oss << "SELECT count(1) total FROM `" << tableName << "` " << condition << ";";
vector<Fields> res_total; vector<Fields> res_total;
if (err = this->db_->exec(oss.str().c_str(), res_total)) if (err = this->db->exec(oss.str().c_str(), res_total))
{ {
return err; return err;
} }
@@ -192,23 +186,20 @@ int DaoEntity::queryFields(string keys, const string& condition, PageInfo& page,
} }
oss.str(""); oss.str("");
if (page.index <= 0) if (page.index <= 0) { page.index = 1; }
{
page.index = 1;
}
int start = (page.index - 1) * page.size; int start = (page.index - 1) * page.size;
oss << "SELECT " << keys << " FROM `" << tableName_ << "` " << condition << " LIMIT " << start << "," << page.size << ";"; oss << "SELECT " << keys << " FROM `" << tableName << "` " << condition << " LIMIT " << start << "," << page.size << ";";
return this->db_->exec(oss.str().c_str(), result); return this->db->exec(oss.str().c_str(), result);
} }
int DaoEntity::updateFields(Fields& fields, const string& condition) int DaoEntity::updateFields(Fields& fields, const string& condition)
{ {
string sql = fields.toSqlUpdate(tableName_, condition); string sql = fields.toSqlUpdate(tableName, condition);
return this->db_->exec(sql); return this->db->exec(sql);
} }
int DaoEntity::updateFields(Fields& fields, vector<string> vecKeys, const string& condition) int DaoEntity::updateFields(Fields& fields, vector<string> vecKeys, const string& condition)
{ {
string sql = fields.toSqlUpdate(tableName_, vecKeys, condition); string sql = fields.toSqlUpdate(tableName, vecKeys, condition);
return this->db_->exec(sql); return this->db->exec(sql);
} }

4
src/database/DaoEntity.h
View File

@@ -103,10 +103,10 @@ protected:
static MysqlOption option; static MysqlOption option;
// mysql 数据库操作对象 // mysql 数据库操作对象
std::shared_ptr<MysqlClient> db_ = nullptr; std::shared_ptr<MysqlClient> db = nullptr;
// 数据库表名称 // 数据库表名称
string tableName_; string tableName;
}; };
#endif // !!! _DaoBase_H_ #endif // !!! _DaoBase_H_

302
src/protocol/HttpEntity.cpp
View File

@@ -7,15 +7,16 @@
#include "app/AppData.h" #include "app/AppData.h"
#include "app/Config.h" #include "app/Config.h"
#include "app/Station.h" #include "app/Station.h"
#include "app/Device.h"
static void FieldsToJson(Fields& fields, NJsonNode& json) static void FieldsToJson(Fields& fields, njson& json)
{ {
for (auto& item : fields.map()) for (auto& item : fields.map())
{ {
json[item.first] = item.second; json[item.first] = item.second;
} }
} }
static void JsonToFields(NJsonNode& json, std::vector<std::string> vecKeys, Fields& fields) static void JsonToFields(njson& json, std::vector<std::string> vecKeys, Fields& fields)
{ {
if (vecKeys.empty()) if (vecKeys.empty())
{ {
@@ -32,16 +33,16 @@ static void JsonToFields(NJsonNode& json, std::vector<std::string> vecKeys, Fiel
switch (json[key].type()) switch (json[key].type())
{ {
case NJsonNode::value_t::string: { fields.set(key, json[key].get<std::string>()); } break; case njson::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 njson::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 njson::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 njson::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 njson::value_t::number_float: { fields.set(key, json[key].get<float>()); } break;
case NJsonNode::value_t::null: {} break; case njson::value_t::null: {} break;
case NJsonNode::value_t::object: {} break; case njson::value_t::object: {} break;
case NJsonNode::value_t::array: {} break; case njson::value_t::array: {} break;
case NJsonNode::value_t::binary: {} break; case njson::value_t::binary: {} break;
case NJsonNode::value_t::discarded: {} break; case njson::value_t::discarded: {} break;
default: default:
break; break;
} }
@@ -50,12 +51,12 @@ static void JsonToFields(NJsonNode& json, std::vector<std::string> vecKeys, Fiel
} }
} }
static NJsonNode FieldsToJsonArray(std::vector<Fields>& vecFields) static njson FieldsToJsonArray(std::vector<Fields>& vecFields)
{ {
NJsonNode jsonnode = NJsonNode::array(); njson jsonnode = njson::array();
for (auto& fields : vecFields) for (auto& fields : vecFields)
{ {
NJsonNode jnode; njson jnode;
for (auto& item : fields.map()) for (auto& item : fields.map())
{ {
jnode[item.first] = item.second; jnode[item.first] = item.second;
@@ -79,8 +80,8 @@ static void GetRequestParam(const httplib::Request& req, const std::vector<std::
} }
else if (req.method == "POST") else if (req.method == "POST")
{ {
NJsonNode json; njson json;
NJson::parse(req.body, json); JSON::parse(req.body, json);
} }
} }
@@ -114,7 +115,7 @@ public:
} }
return true; return true;
} }
static void setPagination(PageInfo& pageinfo, std::vector<Fields> result, NJsonNode& json) static void setPagination(PageInfo& pageinfo, std::vector<Fields> result, njson& json)
{ {
json["count"] = pageinfo.total; json["count"] = pageinfo.total;
json["page"] = pageinfo.index; json["page"] = pageinfo.index;
@@ -142,10 +143,15 @@ static std::map<std::string, HandlerOptions> g_mapHttpHandlerGet =
{"/queryStationInfo", HandlerOptions(&HttpEntity::queryStationInfo, { DMStation::STATION_ID})}, {"/queryStationInfo", HandlerOptions(&HttpEntity::queryStationInfo, { DMStation::STATION_ID})},
{"/queryStationData", HandlerOptions(&HttpEntity::queryStationData, { DMStation::STATION_ID})}, {"/queryStationData", HandlerOptions(&HttpEntity::queryStationData, { DMStation::STATION_ID})},
{"/queryStationOverview", HandlerOptions(&HttpEntity::queryStationOverview, {DMStation::STATION_ID})},
{"/queryDeviceList", HandlerOptions(&HttpEntity::queryDeviceList, {})}, {"/queryDeviceList", HandlerOptions(&HttpEntity::queryDeviceList, {})},
{"/deleteDevice", HandlerOptions(&HttpEntity::deleteDevice, { DMDevice::DEVICE_ID})}, {"/deleteDevice", HandlerOptions(&HttpEntity::deleteDevice, { DMDevice::DEVICE_ID})},
{"/queryDevicTypeDef", HandlerOptions(&HttpEntity::queryDevicTypeDef, {})}, {"/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, {})}, {"/queryPolicyList", HandlerOptions(&HttpEntity::queryPolicyList, {})},
@@ -248,7 +254,7 @@ void HttpEntity::runHandler(std::string name, const HandlerOptions& handler, con
errcode = ret ? Errcode::OK : Errcode::ERR_TOKEN; errcode = ret ? Errcode::OK : Errcode::ERR_TOKEN;
} }
NJsonNode jsonresp; njson jsonresp;
if (errcode == Errcode::OK) if (errcode == Errcode::OK)
{ {
if (!HttpHelper::CheckRequestParam(req, resp, handler.requiredKeys, errmsg)) if (!HttpHelper::CheckRequestParam(req, resp, handler.requiredKeys, errmsg))
@@ -257,7 +263,7 @@ void HttpEntity::runHandler(std::string name, const HandlerOptions& handler, con
} }
else else
{ {
errcode = (this->*(handler.func))(req, resp, jsonresp); errcode = (this->*(handler.func))(req, jsonresp, errmsg);
} }
} }
jsonresp["errcode"] = errcode; jsonresp["errcode"] = errcode;
@@ -271,7 +277,7 @@ void HttpEntity::registGet(std::string name, void (HttpEntity::* func)(const htt
this->httpsvr.Get(name, std::bind(func, this, std::placeholders::_1, std::placeholders::_2)); this->httpsvr.Get(name, std::bind(func, this, std::placeholders::_1, std::placeholders::_2));
} }
Errcode HttpEntity::login(const httplib::Request& req, httplib::Response& resp, NJsonNode& json) Errcode HttpEntity::login(const httplib::Request& req, njson& json, std::string& errmsg)
{ {
std::string userId; std::string userId;
std::string token; std::string token;
@@ -291,10 +297,10 @@ Errcode HttpEntity::login(const httplib::Request& req, httplib::Response& resp,
int roleId = fields.get<int>(DMRole::ROLE_ID); int roleId = fields.get<int>(DMRole::ROLE_ID);
DAO::queryRolePermission(dao, roleId, vecPermission); DAO::queryRolePermission(dao, roleId, vecPermission);
NJsonNode nodePermission = NJsonNode::array(); njson nodePermission = njson::array();
for (auto& item : vecPermission) for (auto& item : vecPermission)
{ {
NJsonNode node; njson node;
FieldsToJson(item, node); FieldsToJson(item, node);
nodePermission.push_back(node); nodePermission.push_back(node);
} }
@@ -305,7 +311,7 @@ Errcode HttpEntity::login(const httplib::Request& req, httplib::Response& resp,
return err; return err;
} }
Errcode HttpEntity::queryUserList(const httplib::Request& req, httplib::Response& resp, NJsonNode& json) Errcode HttpEntity::queryUserList(const httplib::Request& req, njson& json, std::string& errmsg)
{ {
std::string token = req.get_param_value("token"); std::string token = req.get_param_value("token");
PageInfo pageinfo; PageInfo pageinfo;
@@ -322,27 +328,27 @@ Errcode HttpEntity::queryUserList(const httplib::Request& req, httplib::Response
return err; return err;
} }
Errcode HttpEntity::insertUser(const httplib::Request& req, httplib::Response& resp, NJsonNode& json) Errcode HttpEntity::insertUser(const httplib::Request& req, njson& json, std::string& errmsg)
{ {
Fields params; Fields params;
GetRequestParam(req, {"account", "name", "gender", "age", "phone", "email", "role_id"}, params); GetRequestParam(req, {"account", "name", "gender", "age", "phone", "email", "role_id"}, params);
return DAO::insertUser(params); return DAO::insertUser(params);
} }
Errcode HttpEntity::updateUser(const httplib::Request& req, httplib::Response& resp, NJsonNode& json) Errcode HttpEntity::updateUser(const httplib::Request& req, njson& json, std::string& errmsg)
{ {
Fields params; Fields params;
GetRequestParam(req, {"user_id", "account", "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); return DAO::updateUserById(params);
} }
Errcode HttpEntity::deleteUser(const httplib::Request& req, httplib::Response& resp, NJsonNode& json) Errcode HttpEntity::deleteUser(const httplib::Request& req, njson& json, std::string& errmsg)
{ {
std::string userId = req.get_param_value("user_id"); std::string userId = req.get_param_value("user_id");
return DAO::deleteUserById(userId); return DAO::deleteUserById(userId);
} }
Errcode HttpEntity::queryPermissionList(const httplib::Request& req, httplib::Response& resp, NJsonNode& json) Errcode HttpEntity::queryPermissionList(const httplib::Request& req, njson& json, std::string& errmsg)
{ {
PageInfo pageinfo; PageInfo pageinfo;
pageinfo.index = Utils::toInt(req.get_param_value("page")); pageinfo.index = Utils::toInt(req.get_param_value("page"));
@@ -354,28 +360,28 @@ Errcode HttpEntity::queryPermissionList(const httplib::Request& req, httplib::Re
return err; return err;
} }
Errcode HttpEntity::insertPermission(const httplib::Request& req, httplib::Response& resp, NJsonNode& json) Errcode HttpEntity::insertPermission(const httplib::Request& req, njson& json, std::string& errmsg)
{ {
Fields params; Fields params;
GetRequestParam(req, {"name", "describe", "is_open"}, params); GetRequestParam(req, {"name", "describe", "is_open"}, params);
return DAO::insertPermission(params); return DAO::insertPermission(params);
} }
Errcode HttpEntity::updatePermission(const httplib::Request& req, httplib::Response& resp, NJsonNode& json) Errcode HttpEntity::updatePermission(const httplib::Request& req, njson& json, std::string& errmsg)
{ {
Fields params; Fields params;
GetRequestParam(req, {"permission_id", "name", "describe", "is_open"}, params); GetRequestParam(req, {"permission_id", "name", "describe", "is_open"}, params);
return DAO::updatePermissionById(params); return DAO::updatePermissionById(params);
} }
Errcode HttpEntity::deletePermission(const httplib::Request& req, httplib::Response& resp, NJsonNode& json) Errcode HttpEntity::deletePermission(const httplib::Request& req, njson& json, std::string& errmsg)
{ {
std::string permissionId = req.get_param_value("permission_id"); std::string permissionId = req.get_param_value("permission_id");
return DAO::deletePermissionById(permissionId); return DAO::deletePermissionById(permissionId);
} }
Errcode HttpEntity::queryRoleList(const httplib::Request& req, httplib::Response& resp, NJsonNode& json) Errcode HttpEntity::queryRoleList(const httplib::Request& req, njson& json, std::string& errmsg)
{ {
std::string token = req.get_param_value("page"); std::string token = req.get_param_value("page");
PageInfo pageinfo; PageInfo pageinfo;
@@ -394,12 +400,12 @@ Errcode HttpEntity::queryRoleList(const httplib::Request& req, httplib::Response
return err; return err;
} }
std::map<std::string, std::vector<NJsonNode>> mapPermission; std::map<std::string, std::vector<njson>> mapPermission;
for (auto& fields: vecPermission) for (auto& fields: vecPermission)
{ {
std::string roleId = fields.value("role_id"); std::string roleId = fields.value("role_id");
auto& v = mapPermission[roleId]; auto& v = mapPermission[roleId];
NJsonNode node; njson node;
FieldsToJson(fields, node); FieldsToJson(fields, node);
v.push_back(node); v.push_back(node);
} }
@@ -417,19 +423,19 @@ Errcode HttpEntity::queryRoleList(const httplib::Request& req, httplib::Response
return err; return err;
} }
Errcode HttpEntity::insertRole(const httplib::Request& req, httplib::Response& resp, NJsonNode& json) Errcode HttpEntity::insertRole(const httplib::Request& req, njson& json, std::string& errmsg)
{ {
Fields params; Fields params;
GetRequestParam(req, {"name", "describe", "is_open", "permission"}, params); GetRequestParam(req, {"name", "describe", "is_open", "permission"}, params);
return DAO::insertRole(params); return DAO::insertRole(params);
}; };
Errcode HttpEntity::updateRole(const httplib::Request& req, httplib::Response& resp, NJsonNode& json) Errcode HttpEntity::updateRole(const httplib::Request& req, njson& json, std::string& errmsg)
{ {
Fields params; Fields params;
//GetRequestParam(req, {"role_id", "name", "describe", "is_open", "permission"}, params); //GetRequestParam(req, {"role_id", "name", "describe", "is_open", "permission"}, params);
NJsonNode jsonparam; njson jsonparam;
if (!NJson::parse(req.body, jsonparam)) if (!JSON::parse(req.body, jsonparam))
{ {
return Errcode::ERR_PARAM; return Errcode::ERR_PARAM;
} }
@@ -459,13 +465,13 @@ Errcode HttpEntity::updateRole(const httplib::Request& req, httplib::Response& r
} }
return err; return err;
}; };
Errcode HttpEntity::deleteRole(const httplib::Request& req, httplib::Response& resp, NJsonNode& json) Errcode HttpEntity::deleteRole(const httplib::Request& req, njson& json, std::string& errmsg)
{ {
std::string roleId = req.get_param_value(DMRole::ROLE_ID); std::string roleId = req.get_param_value(DMRole::ROLE_ID);
return DAO::remove(NULL, DMRole::TABLENAME, DMRole::ROLE_ID, roleId); return DAO::remove(NULL, DMRole::TABLENAME, DMRole::ROLE_ID, roleId);
}; };
Errcode HttpEntity::queryStationList(const httplib::Request& req, httplib::Response& resp, NJsonNode& json) Errcode HttpEntity::queryStationList(const httplib::Request& req, njson& json, std::string& errmsg)
{ {
PageInfo pageinfo; PageInfo pageinfo;
pageinfo.index = Utils::toInt(req.get_param_value("page")); pageinfo.index = Utils::toInt(req.get_param_value("page"));
@@ -477,7 +483,7 @@ Errcode HttpEntity::queryStationList(const httplib::Request& req, httplib::Respo
return err; return err;
}; };
Errcode HttpEntity::insertStation(const httplib::Request& req, httplib::Response& resp, NJsonNode& json) Errcode HttpEntity::insertStation(const httplib::Request& req, njson& json, std::string& errmsg)
{ {
Fields params; Fields params;
@@ -485,20 +491,80 @@ Errcode HttpEntity::insertStation(const httplib::Request& req, httplib::Response
return DAO::insertStation(params); return DAO::insertStation(params);
}; };
Errcode HttpEntity::updateStation(const httplib::Request& req, httplib::Response& resp, NJsonNode& json) Errcode HttpEntity::updateStation(const httplib::Request& req, njson& json, std::string& errmsg)
{ {
Fields params; Fields params;
GetRequestParam(req, {"station_id", "name", "address", "lon", "lat", "tel", "capacity", "status"}, params); GetRequestParam(req, {"station_id", "name", "address", "lon", "lat", "tel", "capacity", "status"}, params);
return DAO::updateStationById(params); return DAO::updateStationById(params);
}; };
Errcode HttpEntity::deleteStation(const httplib::Request& req, httplib::Response& resp, NJsonNode& json) Errcode HttpEntity::deleteStation(const httplib::Request& req, njson& json, std::string& errmsg)
{ {
std::string primaryKey = DMStation::STATION_ID; std::string primaryKey = DMStation::STATION_ID;
return DAO::remove(NULL, DMStation::TABLENAME, primaryKey, req.get_param_value(primaryKey)); return DAO::remove(NULL, DMStation::TABLENAME, primaryKey, req.get_param_value(primaryKey));
}; };
Errcode HttpEntity::queryStationInfo(const httplib::Request& req, httplib::Response& resp, NJsonNode& json) 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"); std::string stationId = req.get_param_value("station_id");
@@ -520,9 +586,9 @@ Errcode HttpEntity::queryStationInfo(const httplib::Request& req, httplib::Respo
} }
auto& fields = result[0]; auto& fields = result[0];
NJsonNode jsondata; njson jsondata;
std::string attr = fields.remove(DMStation::ATTR); std::string attr = fields.remove(DMStation::ATTR);
NJson::parse(attr, jsondata); JSON::parse(attr, jsondata);
FieldsToJson(fields, jsondata); FieldsToJson(fields, jsondata);
json["data"] = jsondata; json["data"] = jsondata;
@@ -537,10 +603,10 @@ Errcode HttpEntity::queryStationInfo(const httplib::Request& req, httplib::Respo
// voltage_rated: 电池额定电压： // voltage_rated: 电池额定电压：
// power_rated: PCS额定功率 // power_rated: PCS额定功率
} }
Errcode HttpEntity::queryStationData(const httplib::Request& req, httplib::Response& resp, NJsonNode& json) Errcode HttpEntity::queryStationData(const httplib::Request& req, njson& json, std::string& errmsg)
{ {
// 温度， 电压、电流、功率、功率因数、 // 温度， 电压、电流、功率、功率因数、
NJsonNode jsondata; njson jsondata;
jsondata["voltage"] = Utils::toStr(200.32); jsondata["voltage"] = Utils::toStr(200.32);
jsondata["current"] = Utils::toStr(20.56); jsondata["current"] = Utils::toStr(20.56);
jsondata["power"] = Utils::toStr(200.32); jsondata["power"] = Utils::toStr(200.32);
@@ -554,7 +620,7 @@ Errcode HttpEntity::queryStationData(const httplib::Request& req, httplib::Respo
return Errcode::OK; return Errcode::OK;
} }
Errcode HttpEntity::queryDeviceList(const httplib::Request& req, httplib::Response& resp, NJsonNode& json) Errcode HttpEntity::queryDeviceList(const httplib::Request& req, njson& json, std::string& errmsg)
{ {
PageInfo pageinfo; PageInfo pageinfo;
pageinfo.index = Utils::toInt(req.get_param_value("page")); pageinfo.index = Utils::toInt(req.get_param_value("page"));
@@ -566,24 +632,24 @@ Errcode HttpEntity::queryDeviceList(const httplib::Request& req, httplib::Respon
return err; return err;
}; };
Errcode HttpEntity::insertDevice(const httplib::Request& req, httplib::Response& resp, NJsonNode& json) Errcode HttpEntity::insertDevice(const httplib::Request& req, njson& json, std::string& errmsg)
{ {
Fields params; Fields params;
GetRequestParam(req, {"station_id", "type", "name", "code", "model", "factory", "factory_tel", "is_open", "attrs"}, params); GetRequestParam(req, {"station_id", "type", "name", "code", "model", "factory", "factory_tel", "is_open", "attrs"}, params);
return DAO::insertDevice(params); return DAO::insertDevice(params);
}; };
Errcode HttpEntity::updateDevice(const httplib::Request& req, httplib::Response& resp, NJsonNode& json) Errcode HttpEntity::updateDevice(const httplib::Request& req, njson& json, std::string& errmsg)
{ {
Fields params; Fields params;
GetRequestParam(req, {"device_id", "station_id", "type", "name", "code", "model", "factory", "factory_tel", "is_open", "attrs"}, params); GetRequestParam(req, {"device_id", "station_id", "type", "name", "code", "model", "factory", "factory_tel", "is_open", "attrs"}, params);
return DAO::updateDeviceById(params); return DAO::updateDeviceById(params);
}; };
Errcode HttpEntity::deleteDevice(const httplib::Request& req, httplib::Response& resp, NJsonNode& json) Errcode HttpEntity::deleteDevice(const httplib::Request& req, njson& json, std::string& errmsg)
{ {
std::string primaryKey = DMDevice::DEVICE_ID; std::string primaryKey = DMDevice::DEVICE_ID;
return DAO::remove(NULL, DMDevice::TABLENAME, primaryKey, req.get_param_value(primaryKey)); return DAO::remove(NULL, DMDevice::TABLENAME, primaryKey, req.get_param_value(primaryKey));
}; };
Errcode HttpEntity::queryDevicTypeDef(const httplib::Request& req, httplib::Response& resp, NJsonNode& json) 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::string sql = "SELECT device_type_id, name FROM def_device_type;";
std::vector<Fields> result; std::vector<Fields> result;
@@ -591,8 +657,76 @@ Errcode HttpEntity::queryDevicTypeDef(const httplib::Request& req, httplib::Resp
json["data"] = FieldsToJsonArray(result); json["data"] = FieldsToJsonArray(result);
return err; 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; }
Errcode HttpEntity::queryPolicyList(const httplib::Request& req, httplib::Response& resp, NJsonNode& json) 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["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 pageinfo;
pageinfo.index = Utils::toInt(req.get_param_value("page")); pageinfo.index = Utils::toInt(req.get_param_value("page"));
@@ -603,26 +737,26 @@ Errcode HttpEntity::queryPolicyList(const httplib::Request& req, httplib::Respon
HttpHelper::setPagination(pageinfo, result, json); HttpHelper::setPagination(pageinfo, result, json);
return err; return err;
}; };
Errcode HttpEntity::insertPolicy(const httplib::Request& req, httplib::Response& resp, NJsonNode& json) Errcode HttpEntity::insertPolicy(const httplib::Request& req, njson& json, std::string& errmsg)
{ {
Fields params; Fields params;
GetRequestParam(req, {"type", "name", "describe", "value", "is_open"}, params); GetRequestParam(req, {"type", "name", "describe", "value", "is_open"}, params);
return DAO::insertPolicy(params); return DAO::insertPolicy(params);
}; };
Errcode HttpEntity::updatePolicy(const httplib::Request& req, httplib::Response& resp, NJsonNode& json) Errcode HttpEntity::updatePolicy(const httplib::Request& req, njson& json, std::string& errmsg)
{ {
Fields params; Fields params;
GetRequestParam(req, {"policy_id", "type", "describe", "value", "is_open"}, params); GetRequestParam(req, {"policy_id", "type", "describe", "value", "is_open"}, params);
return DAO::updatePolicyById(params); return DAO::updatePolicyById(params);
}; };
Errcode HttpEntity::deletePolicy(const httplib::Request& req, httplib::Response& resp, NJsonNode& json) Errcode HttpEntity::deletePolicy(const httplib::Request& req, njson& json, std::string& errmsg)
{ {
Fields params; Fields params;
GetRequestParam(req, {"policy_id"}, params); GetRequestParam(req, {"policy_id"}, params);
return DAO::deletePolicyById(params.value("policy_id")); return DAO::deletePolicyById(params.value("policy_id"));
}; };
Errcode HttpEntity::querySystemLogList(const httplib::Request& req, httplib::Response& resp, NJsonNode& json) Errcode HttpEntity::querySystemLogList(const httplib::Request& req, njson& json, std::string& errmsg)
{ {
PageInfo pageinfo; PageInfo pageinfo;
pageinfo.index = Utils::toInt(req.get_param_value("page")); pageinfo.index = Utils::toInt(req.get_param_value("page"));
@@ -635,14 +769,14 @@ Errcode HttpEntity::querySystemLogList(const httplib::Request& req, httplib::Res
} }
//Errcode insertSystemLog(const httplib::Request& req, httplib::Response& resp, NJsonNode& json); //Errcode insertSystemLog(const httplib::Request& req, httplib::Response& resp, NJsonNode& json);
Errcode HttpEntity::updateSystemLog(const httplib::Request& req, httplib::Response& resp, NJsonNode& json) Errcode HttpEntity::updateSystemLog(const httplib::Request& req, njson& json, std::string& errmsg)
{ {
Fields params; Fields params;
GetRequestParam(req, {"log_id", "status"}, params); GetRequestParam(req, {"log_id", "status"}, params);
return DAO::updateSystemLogById(params); return DAO::updateSystemLogById(params);
} }
Errcode HttpEntity::queryAlertLogList(const httplib::Request& req, httplib::Response& resp, NJsonNode& json) Errcode HttpEntity::queryAlertLogList(const httplib::Request& req, njson& json, std::string& errmsg)
{ {
PageInfo pageinfo; PageInfo pageinfo;
pageinfo.index = Utils::toInt(req.get_param_value("page")); pageinfo.index = Utils::toInt(req.get_param_value("page"));
@@ -655,21 +789,21 @@ Errcode HttpEntity::queryAlertLogList(const httplib::Request& req, httplib::Resp
} }
//Errcode insertAlertLog(const httplib::Request& req, httplib::Response& resp, NJsonNode& json); //Errcode insertAlertLog(const httplib::Request& req, httplib::Response& resp, NJsonNode& json);
Errcode HttpEntity::updateAlertLog(const httplib::Request& req, httplib::Response& resp, NJsonNode& json) Errcode HttpEntity::updateAlertLog(const httplib::Request& req, njson& json, std::string& errmsg)
{ {
Fields params; Fields params;
GetRequestParam(req, {"log_id", "status"}, params); GetRequestParam(req, {"log_id", "status"}, params);
return DAO::updateAlertLogById(params); return DAO::updateAlertLogById(params);
} }
Errcode HttpEntity::queryPredictionDetail(const httplib::Request& req, httplib::Response& resp, NJsonNode& json) Errcode HttpEntity::queryPredictionDetail(const httplib::Request& req, njson& json, std::string& errmsg)
{ {
NJsonNode jsonData = NJsonNode::array(); njson jsonData = njson::array();
for (int i = 1; i<=5; i++) for (int i = 1; i<=5; i++)
{ {
NJsonNode jnode; njson jnode;
jnode["datatype"] = i; jnode["datatype"] = i;
NJsonNode jsonValues = NJsonNode::array(); njson jsonValues = njson::array();
for (int i = 0; i<1440; ++i) for (int i = 0; i<1440; ++i)
{ {
jsonValues.push_back(float(Utils::random(50, 100))); jsonValues.push_back(float(Utils::random(50, 100)));
@@ -681,11 +815,11 @@ Errcode HttpEntity::queryPredictionDetail(const httplib::Request& req, httplib::
return Errcode::OK; return Errcode::OK;
} }
Errcode HttpEntity::queryStatSystem(const httplib::Request& req, httplib::Response& resp, NJsonNode& json) Errcode HttpEntity::queryStatSystem(const httplib::Request& req, njson& json, std::string& errmsg)
{ {
auto& appdata = Application::data(); auto& appdata = Application::data();
NJsonNode jsondata; njson jsondata;
jsondata["launch_date"] = "2025-01-01"; //: 系统上线启用日期，格式：yyyy-mm-dd jsondata["launch_date"] = "2025-01-01"; //: 系统上线启用日期，格式：yyyy-mm-dd
jsondata["income_total"] = std::to_string(Utils::random(100, 200)); // : 累计收益（元），精度0.01 jsondata["income_total"] = std::to_string(Utils::random(100, 200)); // : 累计收益（元），精度0.01
jsondata["station_num"] = Utils::toStr(appdata.getStationCount()); // : 能源站数量 jsondata["station_num"] = Utils::toStr(appdata.getStationCount()); // : 能源站数量
@@ -700,12 +834,12 @@ Errcode HttpEntity::queryStatSystem(const httplib::Request& req, httplib::Respon
json["data"] = jsondata; json["data"] = jsondata;
return Errcode::OK; return Errcode::OK;
} }
Errcode HttpEntity::queryStatTotal(const httplib::Request& req, httplib::Response& resp, NJsonNode& json) Errcode HttpEntity::queryStatTotal(const httplib::Request& req, njson& json, std::string& errmsg)
{ {
std::string station_id = req.get_param_value("station_id"); std::string station_id = req.get_param_value("station_id");
std::string category = req.get_param_value("category"); std::string category = req.get_param_value("category");
NJsonNode jsondata; njson jsondata;
jsondata["station_id"] = "1"; jsondata["station_id"] = "1";
jsondata["launch_date"] = "2025-01-01"; //场站上线日期 jsondata["launch_date"] = "2025-01-01"; //场站上线日期
jsondata["usage_rate"] = "12"; jsondata["usage_rate"] = "12";
@@ -726,11 +860,11 @@ Errcode HttpEntity::queryStatTotal(const httplib::Request& req, httplib::Respons
json["data"] = jsondata; json["data"] = jsondata;
return Errcode::OK; return Errcode::OK;
} }
Errcode HttpEntity::queryStatStation(const httplib::Request& req, httplib::Response& resp, NJsonNode& json) Errcode HttpEntity::queryStatStation(const httplib::Request& req, njson& json, std::string& errmsg)
{ {
std::string station_id = req.get_param_value("station_id"); std::string station_id = req.get_param_value("station_id");
std::string category = req.get_param_value("category"); std::string category = req.get_param_value("category");
NJsonNode jsondata; njson jsondata;
jsondata["station_id"] = "1"; jsondata["station_id"] = "1";
jsondata["launch_date"] = "2025-01-01"; //场站上线日期 jsondata["launch_date"] = "2025-01-01"; //场站上线日期
jsondata["usage_rate"] = "12"; jsondata["usage_rate"] = "12";
@@ -752,7 +886,7 @@ Errcode HttpEntity::queryStatStation(const httplib::Request& req, httplib::Respo
return Errcode::OK; return Errcode::OK;
} }
Errcode HttpEntity::queryStatDayList(const httplib::Request& req, httplib::Response& resp, NJsonNode& json) Errcode HttpEntity::queryStatDayList(const httplib::Request& req, njson& json, std::string& errmsg)
{ {
std::string station_id = req.get_param_value("station_id"); std::string station_id = req.get_param_value("station_id");
std::string category = req.get_param_value("category"); std::string category = req.get_param_value("category");
@@ -763,10 +897,10 @@ Errcode HttpEntity::queryStatDayList(const httplib::Request& req, httplib::Respo
int64_t t2 = Utils::time(dt_end)/1000; int64_t t2 = Utils::time(dt_end)/1000;
int64_t tMax = t1+ 86400 * 30; int64_t tMax = t1+ 86400 * 30;
NJsonNode jsondata = NJsonNode::array(); njson jsondata = njson::array();
for (int64_t t = t1; t<=t2 && t<=tMax; t += 86400) for (int64_t t = t1; t<=t2 && t<=tMax; t += 86400)
{ {
NJsonNode jnode; njson jnode;
jnode["station_id"] = station_id; jnode["station_id"] = station_id;
if (!category.empty()) jnode["category"] = category; if (!category.empty()) jnode["category"] = category;
jnode["dt"] = Utils::dateStr(t*1000); //日期 jnode["dt"] = Utils::dateStr(t*1000); //日期
@@ -790,7 +924,7 @@ Errcode HttpEntity::queryStatDayList(const httplib::Request& req, httplib::Respo
return Errcode::OK; return Errcode::OK;
} }
Errcode HttpEntity::queryEnvironment(const httplib::Request& req, httplib::Response& resp, NJsonNode& json) Errcode HttpEntity::queryEnvironment(const httplib::Request& req, njson& json, std::string& errmsg)
{ {
std::string stationId = req.get_param_value("station_id"); std::string stationId = req.get_param_value("station_id");
auto& appdata = Application::data(); auto& appdata = Application::data();
@@ -802,15 +936,15 @@ Errcode HttpEntity::queryEnvironment(const httplib::Request& req, httplib::Respo
return Errcode::ERR_PARAM; return Errcode::ERR_PARAM;
} }
NJsonNode jsondata; njson jsondata;
{ // 温湿度 { // 温湿度
auto& mapTempHumUnit = station->mapTempHumUnit; auto& mapTempHumUnit = station->mapTempHumUnit;
NJsonNode nodearray = NJsonNode::array(); njson nodearray = njson::array();
for (auto iter = mapTempHumUnit.begin(); iter!=mapTempHumUnit.end(); iter++) for (auto iter = mapTempHumUnit.begin(); iter!=mapTempHumUnit.end(); iter++)
{ {
auto& unit = iter->second; auto& unit = iter->second;
NJsonNode node; njson node;
node["pos"] = "#" + std::to_string(iter->first); node["pos"] = "#" + std::to_string(iter->first);
node["temp"] = unit.temp; node["temp"] = unit.temp;
node["hum"] = unit.hum; node["hum"] = unit.hum;
@@ -822,10 +956,10 @@ Errcode HttpEntity::queryEnvironment(const httplib::Request& req, httplib::Respo
auto& mapAircUnit = station->mapAircUnit; auto& mapAircUnit = station->mapAircUnit;
AircUnit unitTmp; AircUnit unitTmp;
AircUnit* unit = (mapAircUnit.size() > 0) ? &(mapAircUnit[0]) : &unitTmp; AircUnit* unit = (mapAircUnit.size() > 0) ? &(mapAircUnit[0]) : &unitTmp;
NJsonNode nodearray = NJsonNode::array(); njson nodearray = njson::array();
if (unit) if (unit)
{ {
NJsonNode node; njson node;
nodearray.push_back({{"pos", "开关"}, {"status", unit->powerOn == 0 ? "关机" : "开机"}}); nodearray.push_back({{"pos", "开关"}, {"status", unit->powerOn == 0 ? "关机" : "开机"}});
nodearray.push_back({{"pos", "启动制冷指令"}, {"status", unit->cooling == 0 ? "启动" : "关闭"}}); nodearray.push_back({{"pos", "启动制冷指令"}, {"status", unit->cooling == 0 ? "启动" : "关闭"}});
nodearray.push_back({{"pos", "启动送风指令"}, {"status", unit->airSupply == 0 ? "关闭" : "启动"}}); nodearray.push_back({{"pos", "启动送风指令"}, {"status", unit->airSupply == 0 ? "关闭" : "启动"}});
@@ -845,10 +979,10 @@ Errcode HttpEntity::queryEnvironment(const httplib::Request& req, httplib::Respo
static std::map<int, std::string> mapFireStatusDef = { {0, "正常"}, {1,"预警"}, {2,"火警"} }; static std::map<int, std::string> mapFireStatusDef = { {0, "正常"}, {1,"预警"}, {2,"火警"} };
auto& mapFire40Unit = station->mapFire40Unit; auto& mapFire40Unit = station->mapFire40Unit;
NJsonNode nodearray = NJsonNode::array(); njson nodearray = njson::array();
for (auto iter = mapFire40Unit.begin(); iter!=mapFire40Unit.end(); ++iter) for (auto iter = mapFire40Unit.begin(); iter!=mapFire40Unit.end(); ++iter)
{ {
NJsonNode node; njson node;
node["pos"] = "#" + std::to_string(iter->first); node["pos"] = "#" + std::to_string(iter->first);
node["status"] = mapFireStatusDef[iter->second]; // 0：正常 1：预警 2：火警 node["status"] = mapFireStatusDef[iter->second]; // 0：正常 1：预警 2：火警
nodearray.push_back(node); nodearray.push_back(node);
@@ -859,10 +993,10 @@ Errcode HttpEntity::queryEnvironment(const httplib::Request& req, httplib::Respo
auto& mapCoolingUnit = station->mapCoolingUnit; auto& mapCoolingUnit = station->mapCoolingUnit;
CoolingUnit unitTmp; CoolingUnit unitTmp;
CoolingUnit* unit = (mapCoolingUnit.size() > 0) ? &(mapCoolingUnit[0]) : &unitTmp; CoolingUnit* unit = (mapCoolingUnit.size() > 0) ? &(mapCoolingUnit[0]) : &unitTmp;
NJsonNode nodearray = NJsonNode::array(); njson nodearray = njson::array();
if (unit) if (unit)
{ {
NJsonNode node; njson node;
nodearray.push_back({{"pos", "开关"}, {"status", unit->powerOn == 0 ? "关机" : "开机"}}); nodearray.push_back({{"pos", "开关"}, {"status", unit->powerOn == 0 ? "关机" : "开机"}});
nodearray.push_back({{"pos", "采样模式"}, {"status", unit->mode == 0 ? "出水温度" : "电芯温度"}}); nodearray.push_back({{"pos", "采样模式"}, {"status", unit->mode == 0 ? "出水温度" : "电芯温度"}});
nodearray.push_back({{"pos", "制冷状态"}, {"status", unit->cooling == 0 ? "关闭" : "启动"}}); nodearray.push_back({{"pos", "制冷状态"}, {"status", unit->cooling == 0 ? "关闭" : "启动"}});

81
src/protocol/HttpEntity.h
View File

@@ -4,7 +4,7 @@
#include <functional> #include <functional>
class HttpEntity; class HttpEntity;
using HandlerFunc = Errcode(HttpEntity::*)(const httplib::Request& req, httplib::Response& resp, NJsonNode& jnode); using HandlerFunc = Errcode(HttpEntity::*)(const httplib::Request& req, njson& jnode, std::string& errmsg);
struct HandlerOptions struct HandlerOptions
{ {
@@ -29,57 +29,60 @@ public:
//void onGet(const httplib::Request& req, httplib::Response& resp); //void onGet(const httplib::Request& req, httplib::Response& resp);
Errcode login(const httplib::Request& req, httplib::Response& resp, NJsonNode& json); Errcode login(const httplib::Request& req, njson& json, std::string& errmsg);
Errcode queryUserList(const httplib::Request& req, httplib::Response& resp, NJsonNode& json); Errcode queryUserList(const httplib::Request& req, njson& json, std::string& errmsg);
Errcode insertUser(const httplib::Request& req, httplib::Response& resp, NJsonNode& json); Errcode insertUser(const httplib::Request& req, njson& json, std::string& errmsg);
Errcode updateUser(const httplib::Request& req, httplib::Response& resp, NJsonNode& json); Errcode updateUser(const httplib::Request& req, njson& json, std::string& errmsg);
Errcode deleteUser(const httplib::Request& req, httplib::Response& resp, NJsonNode& json); Errcode deleteUser(const httplib::Request& req, njson& json, std::string& errmsg);
Errcode queryPermissionList(const httplib::Request& req, httplib::Response& resp, NJsonNode& json); Errcode queryPermissionList(const httplib::Request& req, njson& json, std::string& errmsg);
Errcode insertPermission(const httplib::Request& req, httplib::Response& resp, NJsonNode& json); Errcode insertPermission(const httplib::Request& req, njson& json, std::string& errmsg);
Errcode updatePermission(const httplib::Request& req, httplib::Response& resp, NJsonNode& json); Errcode updatePermission(const httplib::Request& req, njson& json, std::string& errmsg);
Errcode deletePermission(const httplib::Request& req, httplib::Response& resp, NJsonNode& json); Errcode deletePermission(const httplib::Request& req, njson& json, std::string& errmsg);
Errcode queryRoleList(const httplib::Request& req, httplib::Response& resp, NJsonNode& json); Errcode queryRoleList(const httplib::Request& req, njson& json, std::string& errmsg);
Errcode insertRole(const httplib::Request& req, httplib::Response& resp, NJsonNode& json); Errcode insertRole(const httplib::Request& req, njson& json, std::string& errmsg);
Errcode updateRole(const httplib::Request& req, httplib::Response& resp, NJsonNode& json); Errcode updateRole(const httplib::Request& req, njson& json, std::string& errmsg);
Errcode deleteRole(const httplib::Request& req, httplib::Response& resp, NJsonNode& json); Errcode deleteRole(const httplib::Request& req, njson& json, std::string& errmsg);
Errcode queryStationList(const httplib::Request& req, httplib::Response& resp, NJsonNode& json); Errcode queryStationList(const httplib::Request& req, njson& json, std::string& errmsg);
Errcode insertStation(const httplib::Request& req, httplib::Response& resp, NJsonNode& json); Errcode insertStation(const httplib::Request& req, njson& json, std::string& errmsg);
Errcode updateStation(const httplib::Request& req, httplib::Response& resp, NJsonNode& json); Errcode updateStation(const httplib::Request& req, njson& json, std::string& errmsg);
Errcode deleteStation(const httplib::Request& req, httplib::Response& resp, NJsonNode& json); Errcode deleteStation(const httplib::Request& req, njson& json, std::string& errmsg);
Errcode queryStationInfo(const httplib::Request& req, httplib::Response& resp, NJsonNode& json); Errcode queryStationOverview(const httplib::Request& req, njson& json, std::string& errmsg);
Errcode queryStationData(const httplib::Request& req, httplib::Response& resp, NJsonNode& json); Errcode queryStationInfo(const httplib::Request& req, njson& json, std::string& errmsg);
Errcode queryStationData(const httplib::Request& req, njson& json, std::string& errmsg);
Errcode queryDeviceList(const httplib::Request& req, httplib::Response& resp, NJsonNode& json); Errcode queryDeviceList(const httplib::Request& req, njson& json, std::string& errmsg);
Errcode insertDevice(const httplib::Request& req, httplib::Response& resp, NJsonNode& json); Errcode insertDevice(const httplib::Request& req, njson& json, std::string& errmsg);
Errcode updateDevice(const httplib::Request& req, httplib::Response& resp, NJsonNode& json); Errcode updateDevice(const httplib::Request& req, njson& json, std::string& errmsg);
Errcode deleteDevice(const httplib::Request& req, httplib::Response& resp, NJsonNode& json); Errcode deleteDevice(const httplib::Request& req, njson& json, std::string& errmsg);
Errcode queryDevicTypeDef(const httplib::Request& req, httplib::Response& resp, NJsonNode& json); Errcode queryDevicTypeDef(const httplib::Request& req, njson& json, std::string& errmsg);
Errcode queryDevicByCategory(const httplib::Request& req, njson& json, std::string& errmsg);
Errcode queryDevicCharts(const httplib::Request& req, njson& json, std::string& errmsg);
Errcode queryPolicyList(const httplib::Request& req, httplib::Response& resp, NJsonNode& json); Errcode queryPolicyList(const httplib::Request& req, njson& json, std::string& errmsg);
Errcode insertPolicy(const httplib::Request& req, httplib::Response& resp, NJsonNode& json); Errcode insertPolicy(const httplib::Request& req, njson& json, std::string& errmsg);
Errcode updatePolicy(const httplib::Request& req, httplib::Response& resp, NJsonNode& json); Errcode updatePolicy(const httplib::Request& req, njson& json, std::string& errmsg);
Errcode deletePolicy(const httplib::Request& req, httplib::Response& resp, NJsonNode& json); Errcode deletePolicy(const httplib::Request& req, njson& json, std::string& errmsg);
Errcode querySystemLogList(const httplib::Request& req, httplib::Response& resp, NJsonNode& json); Errcode querySystemLogList(const httplib::Request& req, njson& json, std::string& errmsg);
//Errcode insertSystemLog(const httplib::Request& req, httplib::Response& resp, NJsonNode& json); //Errcode insertSystemLog(const httplib::Request& req, httplib::Response& resp, NJsonNode& json);
Errcode updateSystemLog(const httplib::Request& req, httplib::Response& resp, NJsonNode& json); Errcode updateSystemLog(const httplib::Request& req, njson& json, std::string& errmsg);
Errcode queryAlertLogList(const httplib::Request& req, httplib::Response& resp, NJsonNode& json); Errcode queryAlertLogList(const httplib::Request& req, njson& json, std::string& errmsg);
//Errcode insertAlertLog(const httplib::Request& req, httplib::Response& resp, NJsonNode& json); //Errcode insertAlertLog(const httplib::Request& req, httplib::Response& resp, NJsonNode& json);
Errcode updateAlertLog(const httplib::Request& req, httplib::Response& resp, NJsonNode& json); Errcode updateAlertLog(const httplib::Request& req, njson& json, std::string& errmsg);
Errcode queryPredictionDetail(const httplib::Request& req, httplib::Response& resp, NJsonNode& json); Errcode queryPredictionDetail(const httplib::Request& req, njson& json, std::string& errmsg);
Errcode queryStatSystem(const httplib::Request& req, httplib::Response& resp, NJsonNode& json); Errcode queryStatSystem(const httplib::Request& req, njson& json, std::string& errmsg);
Errcode queryStatTotal(const httplib::Request& req, httplib::Response& resp, NJsonNode& json); Errcode queryStatTotal(const httplib::Request& req, njson& json, std::string& errmsg);
Errcode queryStatStation(const httplib::Request& req, httplib::Response& resp, NJsonNode& json); Errcode queryStatStation(const httplib::Request& req, njson& json, std::string& errmsg);
Errcode queryStatDayList(const httplib::Request& req, httplib::Response& resp, NJsonNode& json); Errcode queryStatDayList(const httplib::Request& req, njson& json, std::string& errmsg);
Errcode queryEnvironment(const httplib::Request& req, httplib::Response& resp, NJsonNode& json); Errcode queryEnvironment(const httplib::Request& req, njson& json, std::string& errmsg);
}; };

6
src/protocol/MqttEntity.cpp
View File

@@ -10,8 +10,8 @@ static std::map<std::string, std::map<std::string, REGInfo>> g_mapRegInfo;
void MqttClient::loadDataStruct(std::string filename) void MqttClient::loadDataStruct(std::string filename)
{ {
NJsonNode json; njson json;
NJson::load(filename, json); JSON::load(filename, json);
// 遍历 JSON 对象 // 遍历 JSON 对象
for (auto& jsonitem : json.items()) for (auto& jsonitem : json.items())
@@ -321,6 +321,6 @@ void MqttClient::parseTQ(std::string& text) {};
string MQTT::packEquipmentInfo() string MQTT::packEquipmentInfo()
{ {
NJsonNode jsonroot; njson jsonroot;
return jsonroot.dump(); return jsonroot.dump();
} }

6
src/pv/pages/MaskPageRunning.cpp
View File

@@ -245,7 +245,7 @@ void MaskPageRunning::initModule(Module& module, std::string name, int x, int y,
{ {
module.name = name; module.name = name;
int deviceNum = activeStation->getDeviceNumByGroup(name); int deviceNum = activeStation->getDeviceNumByGroup(1);
int pid = module.widget = PvApp::label(p, 0, x, y, w, h, "", QSS::LABEL_BOX); int pid = module.widget = PvApp::label(p, 0, x, y, w, h, "", QSS::LABEL_BOX);
PvApp::label(p, module.widget, 10, 20, w, 30, module.name, QSS::LABEL_TITLE); PvApp::label(p, module.widget, 10, 20, w, 30, module.name, QSS::LABEL_TITLE);
pvSetAlignment(p, module.widget, AlignTop | AlignLeft); pvSetAlignment(p, module.widget, AlignTop | AlignLeft);
@@ -283,7 +283,7 @@ void MaskPageRunning::activeBoxPanel(Module* module)
{ {
// 更新卡片： // 更新卡片：
std::vector<std::shared_ptr<Device>> vecDevice; std::vector<std::shared_ptr<Device>> vecDevice;
activeStation->getDeviceByGroup(module->name, vecDevice); activeStation->getDeviceByGroup(1, vecDevice);
pvSetText(p, module->labelNum, std::to_string(vecDevice.size()).c_str()); pvSetText(p, module->labelNum, std::to_string(vecDevice.size()).c_str());
@@ -298,7 +298,7 @@ void MaskPageRunning::activeBoxPanel(Module* module)
if (typeDef) if (typeDef)
{ {
std::vector<std::string> vecKeys; std::vector<std::string> vecKeys;
NJson::parse(typeDef->fieldsAttr.value("key"), vecKeys); JSON::parse(typeDef->fieldsAttr.value("key"), vecKeys);
card->setCard(typeDef->name, device->name, device->code); card->setCard(typeDef->name, device->name, device->code);
card->setParamkeys(vecKeys); card->setParamkeys(vecKeys);
} }

44
src/pv/pages/PanelPolicy.cpp
View File

@@ -265,14 +265,14 @@ void PanelPolicyPeak::setTimeText(int id, std::string s)
void PanelPolicyPeak::parseAttr(std::string str) void PanelPolicyPeak::parseAttr(std::string str)
{ {
NJsonNode jsonroot; njson jsonroot;
bool ret = NJson::parse(str, jsonroot); bool ret = JSON::parse(str, jsonroot);
if (!ret) if (!ret)
{ {
return; return;
} }
NJson::read(jsonroot, "times", data.times); JSON::read(jsonroot, "times", data.times);
// 更新UI (充电策略) // 更新UI (充电策略)
if (data.times == 2) if (data.times == 2)
{ {
@@ -286,7 +286,7 @@ void PanelPolicyPeak::parseAttr(std::string str)
} }
std::vector<std::vector<int>> vecTmp; std::vector<std::vector<int>> vecTmp;
NJson::read<std::vector<std::vector<int>>>(jsonroot, "period", vecTmp); JSON::read<std::vector<std::vector<int>>>(jsonroot, "period", vecTmp);
for (int row = 0; row < data.vecPeriods.size(); ++row) for (int row = 0; row < data.vecPeriods.size(); ++row)
{ {
auto& vecRows = data.vecPeriods[row]; auto& vecRows = data.vecPeriods[row];
@@ -358,13 +358,13 @@ void PanelPolicyPeak::parseAttr(std::string str)
std::string PanelPolicyPeak::dumpAttr() std::string PanelPolicyPeak::dumpAttr()
{ {
NJsonNode jsonroot; njson jsonroot;
jsonroot["period"] = data.vecPeriods; jsonroot["period"] = data.vecPeriods;
jsonroot["times"] = data.times; jsonroot["times"] = data.times;
NJsonNode nodeCycle = NJsonNode::array(); njson nodeCycle = njson::array();
NJsonNode nodeAttr1; njson nodeAttr1;
nodeAttr1["charge_start"] = data.attr1.chargeTimeStart; nodeAttr1["charge_start"] = data.attr1.chargeTimeStart;
nodeAttr1["charge_end"] = data.attr1.chargeTimeEnd; nodeAttr1["charge_end"] = data.attr1.chargeTimeEnd;
nodeAttr1["charge_power"] = data.attr1.chargePower; nodeAttr1["charge_power"] = data.attr1.chargePower;
@@ -374,7 +374,7 @@ std::string PanelPolicyPeak::dumpAttr()
nodeCycle.push_back(nodeAttr1); nodeCycle.push_back(nodeAttr1);
if (data.times > 1) if (data.times > 1)
{ {
NJsonNode nodeAttr2; njson nodeAttr2;
nodeAttr2["charge_start"] = data.attr2.chargeTimeStart; nodeAttr2["charge_start"] = data.attr2.chargeTimeStart;
nodeAttr2["charge_end"] = data.attr2.chargeTimeEnd; nodeAttr2["charge_end"] = data.attr2.chargeTimeEnd;
nodeAttr2["charge_power"] = data.attr2.chargePower; nodeAttr2["charge_power"] = data.attr2.chargePower;
@@ -423,17 +423,17 @@ PanelPolicyRequire::PanelPolicyRequire(PARAM* p, int parent, int ix, int iy, int
void PanelPolicyRequire::parseAttr(std::string str) void PanelPolicyRequire::parseAttr(std::string str)
{ {
NJsonNode jsonroot; njson jsonroot;
bool ret = NJson::parse(str, jsonroot); bool ret = JSON::parse(str, jsonroot);
if (!ret) if (!ret)
{ {
return; return;
} }
NJson::read(jsonroot, "charge_soc", data.chargeSoc); JSON::read(jsonroot, "charge_soc", data.chargeSoc);
NJson::read(jsonroot, "charge_power", data.chargePower); JSON::read(jsonroot, "charge_power", data.chargePower);
NJson::read(jsonroot, "discharge_soc", data.dischargeSoc); JSON::read(jsonroot, "discharge_soc", data.dischargeSoc);
NJson::read(jsonroot, "discharge_power", data.dischargePower); JSON::read(jsonroot, "discharge_power", data.dischargePower);
// 更新UI // 更新UI
pvSetText(p, ui.chargeSoc, std::to_string(data.chargeSoc).c_str()); pvSetText(p, ui.chargeSoc, std::to_string(data.chargeSoc).c_str());
@@ -444,7 +444,7 @@ void PanelPolicyRequire::parseAttr(std::string str)
std::string PanelPolicyRequire::dumpAttr() std::string PanelPolicyRequire::dumpAttr()
{ {
NJsonNode jsonroot; njson jsonroot;
jsonroot["discharge_soc"] = data.dischargeSoc; jsonroot["discharge_soc"] = data.dischargeSoc;
jsonroot["discharge_power"] = data.dischargePower; jsonroot["discharge_power"] = data.dischargePower;
jsonroot["charge_soc"] = data.chargeSoc; jsonroot["charge_soc"] = data.chargeSoc;
@@ -471,17 +471,17 @@ PanelPolicySelf::PanelPolicySelf(PARAM* p, int parent, int ix, int iy, int iw, i
void PanelPolicySelf::parseAttr(std::string str) void PanelPolicySelf::parseAttr(std::string str)
{ {
NJsonNode jsonroot; njson jsonroot;
bool ret = NJson::parse(str, jsonroot); bool ret = JSON::parse(str, jsonroot);
if (!ret) if (!ret)
{ {
return; return;
} }
NJson::read(jsonroot, "used_soc", data.usedSoc); JSON::read(jsonroot, "used_soc", data.usedSoc);
NJson::read(jsonroot, "grid_soc", data.gridSoc); JSON::read(jsonroot, "grid_soc", data.gridSoc);
NJson::read(jsonroot, "charge_power", data.chargePower); JSON::read(jsonroot, "charge_power", data.chargePower);
NJson::read(jsonroot, "discharge_power", data.dischargePower); JSON::read(jsonroot, "discharge_power", data.dischargePower);
// 更新UI // 更新UI
pvSetText(p, ui.usedSoc, std::to_string(data.usedSoc).c_str()); pvSetText(p, ui.usedSoc, std::to_string(data.usedSoc).c_str());
@@ -492,7 +492,7 @@ void PanelPolicySelf::parseAttr(std::string str)
std::string PanelPolicySelf::dumpAttr() std::string PanelPolicySelf::dumpAttr()
{ {
NJsonNode jsonroot; njson jsonroot;
jsonroot["used_soc"] = data.usedSoc; jsonroot["used_soc"] = data.usedSoc;
jsonroot["grid_soc"] = data.gridSoc; jsonroot["grid_soc"] = data.gridSoc;
jsonroot["charge_power"] = data.chargePower; jsonroot["charge_power"] = data.chargePower;