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"

static NJsonNode FieldsToJsonArray(std::vector<Fields> vecFields)
{
    NJsonNode jsonnode = NJsonNode::array();
    for (auto& fields : vecFields)
    {
        NJsonNode 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)
{
    for (auto& key : vecKeys)
    {
        if (req.has_param(key))
        {
            fields.set(key, req.get_param_value(key));
        }
    }
}

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)
        {
            if (!req.has_param(key)) 
            { 
                if (!errmsg.empty()) { errmsg += ","; }
                errmsg += "缺少参数[" + key + "]"; 
            }
        }
        if (!errmsg.empty())
        {
            return false;
        }
        return true;
    }
    static void setPagination(PageInfo& pageinfo, std::vector<Fields> result, NJsonNode& json)
    {
        json["count"] = pageinfo.total;
        json["page"] = pageinfo.index;
        json["page_size"] = pageinfo.size;
        json["data"] = FieldsToJsonArray(result);
    }
};

using HandlerFunc = Errcode(HttpEntity::*)(const httplib::Request& req, httplib::Response& resp, NJsonNode& jnode);

struct HandlerOptions
{
    HandlerFunc func;
    std::vector<std::string> requiredKeys;
    std::vector<std::string> keys;


    HandlerOptions(HandlerFunc func, const std::vector<std::string>& requiredKeys)
        : func(func), requiredKeys(requiredKeys)
    {
    }
};

static std::map<std::string, HandlerOptions> g_mapHttpHandler =
{
    {"/login", HandlerOptions(&HttpEntity::login, {DMUser::ACCOUNT, DMUser::PASSWD})},
    {"/queryUserList", HandlerOptions(&HttpEntity::queryUserList, {"token"})},
    {"/insertUser", HandlerOptions(&HttpEntity::insertUser, {"token", DMUser::ACCOUNT})},
    {"/updateUser", HandlerOptions(&HttpEntity::updateUser, {"token", DMUser::USER_ID})},
    {"/deleteUser", HandlerOptions(&HttpEntity::deleteUser, {"token", DMUser::USER_ID})},
    
    {"/queryPermissionList", HandlerOptions(&HttpEntity::queryPermissionList, {"token"})},
    {"/insertPermission", HandlerOptions(&HttpEntity::insertPermission, {"token", DMPermission::NAME})},
    {"/updatePermission", HandlerOptions(&HttpEntity::updatePermission, {"token", DMPermission::PERMISSION_ID})},
    {"/deletePermission", HandlerOptions(&HttpEntity::deletePermission, {"token", DMPermission::PERMISSION_ID})},
    
    {"/queryRoleList", HandlerOptions(&HttpEntity::queryRoleList, {"token"})},
    {"/insertRole", HandlerOptions(&HttpEntity::insertRole, {"token", DMRole::NAME})},
    {"/updateRole", HandlerOptions(&HttpEntity::updateRole, {"token", DMRole::ROLE_ID})},
    {"/deleteRole", HandlerOptions(&HttpEntity::deleteRole, {"token", DMRole::ROLE_ID})},
    
    {"/queryStationList", HandlerOptions(&HttpEntity::queryStationList, {"token"})},
    {"/insertStation", HandlerOptions(&HttpEntity::insertStation, {"token", DMStation::NAME})},
    {"/updateStation", HandlerOptions(&HttpEntity::updateStation, {"token", DMStation::STATION_ID})},
    {"/deleteStation", HandlerOptions(&HttpEntity::deleteStation, {"token", DMStation::STATION_ID})},
    
    {"/queryDeviceList", HandlerOptions(&HttpEntity::queryDeviceList, {"token"})},
    {"/insertDevice", HandlerOptions(&HttpEntity::insertDevice, {"token", DMDevice::NAME})},
    {"/updateDevice", HandlerOptions(&HttpEntity::updateDevice, {"token", DMDevice::DEVICE_ID})},
    {"/deleteDevice", HandlerOptions(&HttpEntity::deleteDevice, {"token", DMDevice::DEVICE_ID})},
    {"/queryDevicTypeDef", HandlerOptions(&HttpEntity::queryDevicTypeDef, {"token"})},
    
    {"/queryPolicyList", HandlerOptions(&HttpEntity::queryPolicyList, {"token"})},
    {"/insertPolicy", HandlerOptions(&HttpEntity::insertPolicy, {"token", DMPolicy::NAME})},
    {"/updatePolicy", HandlerOptions(&HttpEntity::updatePolicy, {"token", DMPolicy::POLICY_ID})},
    {"/deletePolicy", HandlerOptions(&HttpEntity::deletePolicy, {"token", DMPolicy::POLICY_ID})},

    {"/querySystemLogList", HandlerOptions(&HttpEntity::querySystemLogList, {"token"})},
    
    {"/queryAlertLogList", HandlerOptions(&HttpEntity::queryAlertLogList, {"token"})},

    {"/queryPredictionDetail", HandlerOptions(&HttpEntity::queryPredictionDetail, {"token"})},
    
    //{"/insert", HandlerOptions(&HttpEntity::insert, {})},
    //{"/update", HandlerOptions(&HttpEntity::update, {})},
    //{"/delete", HandlerOptions(&HttpEntity::delete, {})},


};


void HttpEntity::listen(std::string addr, int port)
{
    for (auto& item : g_mapHttpHandler)
    {
        std::string name = item.first;
        HandlerOptions& handler = item.second;
        this->httpsvr.Get(name, [=, &handler](const httplib::Request& req, httplib::Response& resp) 
        {
            NJsonNode json;
            Errcode errcode = Errcode::OK;

            if (name != "/login" && Config::option.useToken)
            {
                // 验证token
                std::string token =  req.get_param_value("token");
                if (token.empty()) 
                {
                    errcode = Errcode::ERR_TOKEN; 
                }
                else
                {
                    User user = Application::data().getUser(token);
                    if (user.userId.empty())
                    {
                        errcode = Errcode::ERR_TOKEN;
                    }
                }
            }

            std::string errmsg;
            if (errcode == Errcode::OK)
            {
                if (!HttpHelper::CheckRequestParam(req, resp, handler.requiredKeys, errmsg))
                {
                    errcode = Errcode::ERR_PARAM;
                }
                else
                {
                    errcode = (this->*(handler.func))(req, resp, json);
                }
            }

            json["errcode"] = errcode;
            json["errmsg"] = ErrcodeStr(errcode) + (errmsg.empty() ? "" : (":"+errmsg));
            resp.set_content(json.dump(), "text/plain; charset=utf-8");
            resp.status = 200;
        });
    }

    if (addr.empty()) addr = "0.0.0.0";
    httpsvr.listen(addr, port); 
}

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, httplib::Response& resp, NJsonNode& json)
{
    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);

        NJsonNode jnode = NJsonNode::array();
        for (auto& item : vecPermission) { jnode.push_back(item.value("name")); }
        json["permission"] = jnode;
    }

    DAO::insertSystemLogUser(token, "用户登录：" + ErrcodeStr(err), (err==Errcode::OK) ? 0: 1);
    return err;
}

Errcode HttpEntity::queryUserList(const httplib::Request& req, httplib::Response& resp, NJsonNode& json)
{
    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, httplib::Response& resp, NJsonNode& json)
{
    Fields params;
    GetRequestParam(req, {"account", "name", "gender", "age", "phone", "email", "role_id"}, params);
    return DAO::insertUser(params);
}

Errcode HttpEntity::updateUser(const httplib::Request& req, httplib::Response& resp, NJsonNode& json)
{
    Fields params;
    GetRequestParam(req, {"user_id", "name", "gender", "age", "phone", "email", "role_id"}, params);
    return DAO::updateUserById(params);
}

Errcode HttpEntity::deleteUser(const httplib::Request& req, httplib::Response& resp, NJsonNode& json)
{
    std::string userId = req.get_param_value("user_id");
    return DAO::deleteUserById(userId);
}

Errcode HttpEntity::queryPermissionList(const httplib::Request& req, httplib::Response& resp, NJsonNode& json)
{
    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, httplib::Response& resp, NJsonNode& json)
{
    Fields params;
    GetRequestParam(req, {"name", "describe", "is_open"}, params);
    return DAO::insertPermission(params);
}

Errcode HttpEntity::updatePermission(const httplib::Request& req, httplib::Response& resp, NJsonNode& json)
{
    Fields params;
    GetRequestParam(req, {"permission_id", "name", "describe", "is_open"}, params);
    return DAO::updatePermissionById(params);
}

Errcode HttpEntity::deletePermission(const httplib::Request& req, httplib::Response& resp, NJsonNode& json)
{
    std::string permissionId = req.get_param_value("permission_id");
    return DAO::deletePermissionById(permissionId);
}


Errcode HttpEntity::queryRoleList(const httplib::Request& req, httplib::Response& resp, NJsonNode& json)
{
    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<NJsonNode>> mapPermission;
        for (auto& item: vecPermission)
        {
            std::string roleId = item.value("role_id");
            auto& v = mapPermission[roleId];
            NJsonNode jnode;
            jnode["id"] = item.value("permission_id");
            jnode["name"] = item.value("permission_name");
            v.push_back(jnode);
        }

        HttpHelper::setPagination(pageinfo, result, json);
        if (json.contains("data"))
        {
            for (auto& item : json["data"]) 
            {
                std::string roleId = item["role_id"];
                item["permission"] = mapPermission[roleId];
            }
        }
    }
    return err;
}

Errcode HttpEntity::insertRole(const httplib::Request& req, httplib::Response& resp, NJsonNode& json)
{
    Fields params;
    GetRequestParam(req, {"name", "describe", "is_open", "permission"}, params);
    return DAO::insertRole(params);
};
Errcode HttpEntity::updateRole(const httplib::Request& req, httplib::Response& resp, NJsonNode& json)
{
    Fields params;
    GetRequestParam(req, {"role_id", "name", "describe", "is_open", "permission"}, params);
    return DAO::updateRoleById(params);
};
Errcode HttpEntity::deleteRole(const httplib::Request& req, httplib::Response& resp, NJsonNode& json)
{
    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, httplib::Response& resp, NJsonNode& json) 
{
    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, httplib::Response& resp, NJsonNode& json)
{
    
    Fields params;
    GetRequestParam(req, {"name", "address", "lon", "lat", "tel", "capacity", "status"}, params);
    return DAO::insertStation(params);
};

Errcode HttpEntity::updateStation(const httplib::Request& req, httplib::Response& resp, NJsonNode& json)
{
    Fields params;
    GetRequestParam(req, {"station_id", "name", "address", "lon", "lat", "tel", "capacity", "status"}, params);
    return DAO::updateStationById(params);
};

Errcode HttpEntity::deleteStation(const httplib::Request& req, httplib::Response& resp, NJsonNode& json)
{
    std::string primaryKey = DMStation::STATION_ID;
    return DAO::remove(NULL, DMStation::TABLENAME, primaryKey, req.get_param_value(primaryKey));
};


Errcode HttpEntity::queryDeviceList(const httplib::Request& req, httplib::Response& resp, NJsonNode& json) 
{
    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, httplib::Response& resp, NJsonNode& json)
{
    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, httplib::Response& resp, NJsonNode& json)
{
    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, httplib::Response& resp, NJsonNode& json)
{
    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, httplib::Response& resp, NJsonNode& json)
{
    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::queryPolicyList(const httplib::Request& req, httplib::Response& resp, NJsonNode& json) 
{ 
    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, httplib::Response& resp, NJsonNode& json) 
{ 
    Fields params;
    GetRequestParam(req, {"type", "name", "describe", "value", "is_open"}, params);
    return DAO::insertPolicy(params);
};
Errcode HttpEntity::updatePolicy(const httplib::Request& req, httplib::Response& resp, NJsonNode& json)
{
    Fields params;
    GetRequestParam(req, {"policy_id", "type", "describe", "value", "is_open"}, params);
    return DAO::updatePolicyById(params);
};
Errcode HttpEntity::deletePolicy(const httplib::Request& req, httplib::Response& resp, NJsonNode& json)
{
    return DAO::deletePolicyById(req.get_param_value("prolicy_id"));
};

Errcode HttpEntity::querySystemLogList(const httplib::Request& req, httplib::Response& resp, NJsonNode& json)
{
    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, httplib::Response& resp, NJsonNode& json)
{
    Fields params;
    GetRequestParam(req, {"log_id", "status"}, params);
    return DAO::updateSystemLogById(params);
}

Errcode HttpEntity::queryAlertLogList(const httplib::Request& req, httplib::Response& resp, NJsonNode& json)
{
    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, httplib::Response& resp, NJsonNode& json)
{
    Fields params;
    GetRequestParam(req, {"log_id", "status"}, params);
    return DAO::updateAlertLogById(params);
}

Errcode HttpEntity::queryPredictionDetail(const httplib::Request& req, httplib::Response& resp, NJsonNode& json)
{
    NJsonNode jsonData = NJsonNode::array();
    for (int i = 1; i<=5; i++)
    {
        NJsonNode jnode;
        jnode["datatype"] = i;
        NJsonNode jsonValues = NJsonNode::array();
        for (int i = 0; i<1440; ++i)
        {
            jsonValues.push_back(float(Utils::random(50, 100)));
        }
        jnode["values"] = jsonValues;
        jsonData.push_back(jnode);
    }
    json["data"] = jsonData;
    return Errcode::OK;
}