energy_storage/src/protocol/HttpEntity.cpp

#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"})},
    {"/queryDeviceBCUDetail", HandlerOptions(&HttpEntity::queryDeviceBCUDetail, {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();
        std::map<std::string, int> mapParentPos;
        for (int i=0; i<vecPermission.size(); ++i)
        {
            auto& item = vecPermission[i];
            if (item.value("parent_id") == "")
            {
                mapParentPos[item.value("permission_id")] = i;
                njson node;
                FieldsToJson(item, node);
                node["children"] = njson::array();
                nodePermission.push_back(node);
            }
        }
        // 重新遍历处理二级子权限，防止父权限信息还未创建时导致错误
        for (int i = 0; i<vecPermission.size(); ++i)
        {
            auto& item = vecPermission[i];
            std::string id = item.value("permission_id");
            std::string parentId = item.value("parent_id");
            if (parentId != "")
            {
                auto iter = mapParentPos.find(parentId);
                if (iter != mapParentPos.end())
                {
                    njson node;
                    FieldsToJson(item, node);
                    nodePermission[iter->second]["children"].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<Fields>> mapP;

        for (int i = 0; i<vecPermission.size(); ++i)
        {
            auto& item = vecPermission[i];
            std::string roleId = item.value("role_id");
            std::string id = item.value("permission_id");
            std::string parentId = item.value("parent_id");

            mapP[roleId].push_back(vecPermission[i]);
        }

        HttpHelper::setPagination(pageinfo, result, json);
        for (auto& item : json["data"])
        {
            auto jsonpermission = njson::array();
            std::string roleId = item["role_id"];
            std::vector<Fields>& vecP = mapP[roleId];
            
            std::map<std::string, int> mapParentPos;
            for (int i = 0; i<vecP.size(); ++i)
            {
                auto& item = vecPermission[i];
                if (item.value("parent_id") == "")
                {
                    mapParentPos[item.value("permission_id")] = i;
                    njson node;
                    FieldsToJson(item, node);
                    node["children"] = njson::array();
                    jsonpermission.push_back(node);
                }
            }
            // 重新遍历处理二级子权限，防止父权限信息还未创建时导致错误
            for (int i = 0; i<vecP.size(); ++i)
            {
                auto& item = vecP[i];
                std::string id = item.value("permission_id");
                std::string parentId = item.value("parent_id");
                if (parentId != "")
                {
                    auto iter = mapParentPos.find(parentId);
                    if (iter != mapParentPos.end())
                    {
                        njson node;
                        FieldsToJson(item, node);
                        jsonpermission[iter->second]["children"].push_back(node);
                    }
                }
            }
            item["permission"] = jsonpermission;
        }
    }
    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", "work_mode"}, 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::queryDeviceBCUDetail(const httplib::Request& req, njson& json, std::string& errmsg)
{
    njson jsondata = njson::array();
    for (int i = 0; i<=100; ++i)
    {
        jsondata.push_back({{"SOC", "1"}, {"SOH", "1"}, {"V", "1"}, {"T", "1"}, {"R_i", "1"}});
    }
    json["data"] = jsondata;
    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"));
}