energy_storage/src/widgets/WebHandler.cpp

#include "WebHandler.h"

#include <fstream>
#include <filesystem>
#include <iostream>
#include "common/Utils.h"
#include "common/Logger.h"
#include "Snowflake.h"
#include "app/Dao.h"
#include "app/Admin.h"
#include "app/Device.h"

static void VariantListRes(std::vector<DataFields>& data, QVariantList& listRes)
{
    for (auto& fields: data)
    {
        QVariantMap row;
        for (auto& field: fields.fields())
        {
            row[field.first.c_str()] = field.second.c_str();
        }
        listRes << row;
    }
}

static void JSsetResPaginaion(QVariantMap& result, std::vector<DataFields>& data, int page, int pageSize, int count, int code, string err)
{
    result["code"] = code;
    result["err"] = "操作成功";
    result["count"] = count;
    result["page"] = page;
    result["pageSize"] = pageSize;

    QVariantList listRow;
    for (auto& fields: data)
    {
        QVariantMap row;
        for (auto& field: fields.fields())
        {
            row[field.first.c_str()] = field.second.c_str();
        }
        listRow << row;
    }
    result["data"] = listRow;
}

static void JSgetReqParam(QString key, QVariantMap& params, DataFields& fields)
{
    if (params.contains(key)) fields.set(key.toStdString(), params[key].toString().toStdString());
}

void MyWebHandler::setNativeText(const QString& text)
{
    nativeText_ = text;
    emit signalNativeTextChanged(text);
}

void MyWebHandler::log(const QString& text)
{
    XLOGD() << "[JS] " << text.toStdString();
}

QString MyWebHandler::readFile(const QString& filename)
{
    std::string fileName = filename.toStdString();
    XLOGD() << "[cppNative] readFile: " << fileName;
    std::filesystem::path filePath = std::filesystem::u8path(fileName);
    std::ifstream ifs(filePath);
    if (ifs.is_open())
    {
        // 获取文件大小
        ifs.seekg(0, std::ios::end);
        std::streamsize size = ifs.tellg();
        XLOGD() << "[cppNative] readFile [" << fileName << "] success, data size=" << size;

        // 定位回文件开始，读取文件内容到缓冲区
        ifs.seekg(0, std::ios::beg);
        std::string buf(size, '\0');
        ifs.read(&buf[0], size);
        ifs.close();
        return buf.c_str();
    }
    else
    {
        XLOGD() << "[cppNative] readFile [" << fileName << "] failed.";
    }
    return "";
}

void MyWebHandler::login(const QString& username, const QString& passwd)
{
    XLOGI() << "login request: " << username.toStdString();
    Errcode ecode = Admin::instance().longin(username.toStdString(), passwd.toStdString());

    //std::this_thread::sleep_for(std::chrono::milliseconds(10000));
    emit signalLongin(username, int(ecode));
}

void MyWebHandler::loginOut(const QString& username)
{
}

QVariantMap MyWebHandler::queryUserList(int page, int pageSize)
{
    XLOGD() << "[cppNative] queryUserList";
    std::vector<DataFields> res;
    DAO::queryUser(res);

    QVariantMap result;
    JSsetResPaginaion(result, res, page, pageSize, res.size(), 0, "操作成功");
    return result;
}

int MyWebHandler::insertUser(QVariantMap params)
{
    DataFields fields;
    JSgetReqParam("account", params, fields);
    fields.set("passwd", "123456");
    JSgetReqParam("name", params, fields);
    JSgetReqParam("gender", params, fields);
    JSgetReqParam("age", params, fields);
    JSgetReqParam("phone", params, fields);
    JSgetReqParam("email", params, fields);
    JSgetReqParam("is_open", params, fields);
    XLOGD() << "[cppNative] insertUser: params=" << fields.to_str();

    bool ret = DAO::insertUser(fields);



    // 设置用户角色
    std::string user_id = fields.getStr("user_id");
    if (params.contains("role_id")) {

        int role_id = params["role_id"].toInt();
        DataFields fieldsUserRole;
        fieldsUserRole.set("user_id", user_id);
        fieldsUserRole.set("role_id", role_id);
        fieldsUserRole.set("create_time", Utils::timeNowStr());
        auto dao = DAO::get("user_role");
        ret = dao->insertFields(fieldsUserRole);
    }
    return ret;
}

int MyWebHandler::deleteUser(const QString& userId) { return 1; }

int MyWebHandler::updateUser(const QString& userId, QVariantMap params) 
{
    XLOGD() << "[cppNative] updateUser";

    int ret = 1;
    DataFields fields;
    
    JSgetReqParam("account", params, fields);
    JSgetReqParam("name", params, fields);
    JSgetReqParam("gender", params, fields);
    JSgetReqParam("age", params, fields);
    JSgetReqParam("phone", params, fields);
    JSgetReqParam("email", params, fields);
    JSgetReqParam("is_open", params, fields);
    if (params.size() > 0)
    {
        ret = DAO::updateUserById(userId.toStdString(), fields);
        XLOGD() << "updateUser: ret=" << ret;
    }

    if (params.contains("role_id")) {
        int role_id = params["role_id"].toInt();
        fields.clear();
        fields.set("user_id", userId.toStdString());
        fields.set("role_id", role_id);
        fields.set("create_time", Utils::timeNowStr());
        fields.set("update_time", Utils::timeNowStr());
        //fields.set("update_by", "");

        auto dao = DAO::get("user_role");
        std::vector<std::string> keysUpdate = {"role_id", "update_time"};
        bool res = dao->duplicateUpdate(fields, keysUpdate);
        ret = ret ? 0 : 1;
        XLOGD() << "updateUser, update role, ret=" << ret;
    }
    return ret;
}


// ================================================================================================================
// 角色管理接口
QVariantMap MyWebHandler::queryRoleList(int page, int pageSize)
{
    QVariantMap result;

    std::vector<DataFields> res;
    auto dao = DAO::get("role");
    bool ret = dao->exec("SELECT * FROM role;", res);
    JSsetResPaginaion(result, res, page, pageSize, res.size(), 0, "操作成功");
    XLOGD() << "[cppNative] queryRoleList " << (ret ? "success." : "failed.");

    //QtConcurrent::run([this]() 
    //    {
    //        XLOGD() << "[cppNative] lxy ========== queryRoleList 1111111111111111111111 ";
    //        QThread::msleep(2000);
    //        XLOGD() << "[cppNative] lxy ========== queryRoleList 2222222222222222222222 ";
    //    });

    return result;
}

int MyWebHandler::insertRole(QVariantMap params) 
{
    DataFields fields;
    if (params.contains("name")) fields.set("name", params["name"].toString().toStdString());
    if (fields.size() == 0)
    {
        return 1;
    }
    if (params.contains("describe")) fields.set("describe", params["describe"].toString().toStdString());
    
    // 数据表 role_id 是自增id
    fields.set("create_time", Utils::timeNowStr());
    fields.set("update_time", Utils::timeNowStr());
    auto dao = DAO::get("role");
    bool ret = dao->insertFields(fields);
    return ret ? 0: 1;
}
int MyWebHandler::deleteRole(const QString& roleId) { return 1; }
int MyWebHandler::updateRole(const QString& roleId, QVariantMap params) 
{
    DataFields fields;
    JSgetReqParam("name", params, fields);
    JSgetReqParam("describe", params, fields);
    if (fields.size() <= 0)
    {
        return 0;
    }
    fields.set("update_time", Utils::timeNowStr());

    std::string sqlC = " WHERE role_id='" + roleId.toStdString() + "'";
    auto dao = DAO::get("role");
    bool ret = dao->updateFields(fields, sqlC);
    return ret ? 0 : 1;
}

QVariantList MyWebHandler::queryRolePermissionList(int roleId)
{
    std::vector<DataFields> result;
    std::string sql = "SELECT p.permission_id, p.name, rp.role_id, rp.is_open FROM permission p "
        "LEFT JOIN role_permission rp ON(rp.permission_id = p.permission_id AND rp.role_id = '" + std::to_string(roleId) +"') WHERE p.is_open='1';";

    auto dao = DAO::get("role_permission");
    bool ret = dao->exec(sql, result);

    QVariantList listRow;
    for (auto& fields: result)
    {
        QVariantMap row;
        for (auto& field: fields.fields())
        {
            row[field.first.c_str()] = field.second.c_str();
        }
        listRow << row;
    }
    return listRow;
};
int MyWebHandler::updateRolePermission(int roleId, QVariantList params)
{
    auto dao = DAO::get("role_permission");

    std::string sql = "DELETE FROM role_permission WHERE role_id='" + std::to_string(roleId) + "';";
    bool ret = dao->exec(sql);

    std::vector<DataFields> vecFields;
    for (QVariant& item: params)
    {
        if (item.canConvert<QVariantMap>())
        {
            QVariantMap itemMap = item.toMap();
            DataFields fields;
            fields.set("role_id", roleId);
            JSgetReqParam("permission_id", itemMap, fields);
            JSgetReqParam("is_open", itemMap, fields);
            vecFields.push_back(fields);
        }
    }
    ret = dao->insertFields(vecFields);
    return ret ? 0 : 1;
};

// ================================================================================================================
// 权限管理接口
QVariantMap MyWebHandler::queryPermissionList(int page, int pageSize)
{
    std::vector<DataFields> res;
    auto dao = DAO::get("permission");
    bool ret = dao->exec("SELECT * FROM permission;", res);

    QVariantMap result;
    JSsetResPaginaion(result, res, page, pageSize, res.size(), 0, "操作成功");
    return result;
}

int MyWebHandler::insertPermission(QVariantMap params) 
{
    DataFields fields; 
    JSgetReqParam("name", params, fields);
    JSgetReqParam("describe", params, fields);
    JSgetReqParam("is_open", params, fields);
    fields.set("create_time", Utils::timeNowStr());
    fields.set("update_time", Utils::timeNowStr());

    auto dao = DAO::get("permission");
    bool ret = dao->insertFields(fields);
    return ret ? 0 : 1;
}

int MyWebHandler::deletePermission(const QString& permissionId) { return 1; }
int MyWebHandler::updatePermission(const QString& permissionId, QVariantMap params) 
{
    DataFields fields;
    JSgetReqParam("name", params, fields);
    JSgetReqParam("describe", params, fields);
    JSgetReqParam("is_open", params, fields);
    if (fields.size() <= 0)
    {
        return 0;
    }
    fields.set("update_time", Utils::timeNowStr());

    auto dao = DAO::get("permission");
    std::string sqlC = " WHERE permission_id='" + permissionId.toStdString() + "'";
    bool ret = dao->updateFields(fields, sqlC);
    return ret ? 0 : 1;
}

// ================================================================================================================
// 设备管理接口
QVariantMap MyWebHandler::queryDeviceList(int page, int pageSize)
{
    XLOGD() << "queryDeviceList:";

    std::vector<DataFields> res;
    auto dao = DAO::get("device");
    bool ret = dao->exec("SELECT * FROM device;", res);
    XLOGD() << "queryDeviceList: size=" << res.size();

    QVariantMap result;
    JSsetResPaginaion(result, res, page, pageSize, res.size(), 0, "操作成功");
    return result;
}

static void JSgetReqParamSql(QString key, QVariantMap& params, std::string& sql)
{
    if (params.contains(key)) 
    {
        auto& v = params[key];
        std::string typeName = v.typeName();


        XLOGD() << key.toStdString() << " : " << typeName;
        if (!sql.empty()) sql += ",";
        
        if ("QVariantList" == typeName)
        {
            std::string str = "";
            for (auto& item : v.toList()) 
            {
                if (!str.empty()) str += ",";
                str += ("'" + item.toString().toStdString() + "'");
            }
            sql += ("`" + key.toStdString() + "` IN (" + str + ")");
            XLOGD() << "QVariantList";
        }
        else if ("QString" == typeName)
        {
            // 如果是数组, 需要处理数组格式： ["","",""]
            sql += ("`" + key.toStdString() + "`='" + v.toString().toStdString() + "'");
            XLOGD() << "QString";
        }
        else {
            XLOGD() << "???";
        }
    }
}

QVariantList MyWebHandler::queryDevice(QVariantMap params)
{
    XLOGD() << "MyWebHandler::queryDevice -- params.size=" << params.size();

    QVariantList result;

    std::string sqlc = "";
    JSgetReqParamSql("type", params, sqlc);

    if (sqlc.empty()) {
        return result;
    }

    std::string sql = "SELECT * FROM device WHERE " + sqlc + ";";
    auto dao = DAO::get("device");
    std::vector<DataFields> res;
    bool ret = dao->exec(sql, res);
    XLOGD() << "sql=" << sql;
    XLOGD() << "queryDevice: size=" << res.size();

    VariantListRes(res, result);

    XLOGD() << "queryDevice: result size=" << result.size();
    return result;
}

int MyWebHandler::insertDevice(QVariantMap params) 
{ 
    DataFields fields;
    JSgetReqParam("type", params, fields);
    JSgetReqParam("name", params, fields);
    JSgetReqParam("code", params, fields);
    JSgetReqParam("model", params, fields);
    JSgetReqParam("factory", params, fields);
    JSgetReqParam("is_open", params, fields);
    if (fields.size() == 0)
    {
        return 0;
    }
    fields.set("create_time", Utils::timeNowStr());
    fields.set("update_time", Utils::timeNowStr());

    auto dao = DAO::get("device");
    bool ret = dao->insertFields(fields);
    return ret ? 0 : 1;
}
int MyWebHandler::deleteDevice(const QString& deviceId) { return 1; }
int MyWebHandler::updateDevice(const QString& deviceId, QVariantMap params) 
{
    DataFields fields;
    JSgetReqParam("type", params, fields);
    JSgetReqParam("name", params, fields);
    JSgetReqParam("code", params, fields);
    JSgetReqParam("model", params, fields);
    JSgetReqParam("factory", params, fields);
    JSgetReqParam("is_open", params, fields);
    if (fields.size() == 0)
    {
        return 0;
    }
    fields.set("update_time", Utils::timeNowStr());

    auto dao = DAO::get("device");
    std::string sqlC = "WHERE device_id='" + deviceId.toStdString() + "'";
    auto ret = dao->updateFields(fields, sqlC);
    return ret ? 0 : 1;
}
QVariantList MyWebHandler::queryDeviceTypeList()
{
    const std::vector<std::pair<int, std::string>> vecTypeDef =
    {
        {1, "光伏设备"},
        {2, "储能设备"},
        {3, "充电设备"},
        {4, "逆变器"},
        {5, "汇流箱"},
        {6, "电表"},
    };

    QVariantList result;
    for (auto& item: vecTypeDef)
    {
        QVariantMap row;
        row["id"] = item.first;
        row["name"] = item.second.c_str();
        result << row;
    }
    return result;
}

// ================================================================================================================
// 计费管理接口
QVariantMap MyWebHandler::queryPriceList(int page, int pageSize)
{
    std::vector<DataFields> res;
    auto dao = DAO::get("price");
    bool ret = dao->exec("SELECT * FROM price;", res);
    XLOGD() << "queryPriceList: size=" << res.size();

    QVariantMap result; 
    JSsetResPaginaion(result, res, page, pageSize, res.size(), 0, "操作成功");
    return result;
}
int MyWebHandler::insertPrice(QVariantMap params) 
{
    DataFields fields;
    JSgetReqParam("type", params, fields);
    JSgetReqParam("describe", params, fields);
    JSgetReqParam("is_open", params, fields);
    if (fields.size() == 0)
    {
        return 0;
    }
    fields.set("create_time", Utils::timeNowStr());
    fields.set("update_time", Utils::timeNowStr());

    auto dao = DAO::get("price");
    bool ret = dao->insertFields(fields);
    return ret ? 0 : 1;
}
int MyWebHandler::deletePrice(const QString& priceId) { return 1; }
int MyWebHandler::updatePrice(const QString& priceId, QVariantMap params) 
{ 
    DataFields fields;
    JSgetReqParam("name", params, fields);
    JSgetReqParam("type", params, fields);
    JSgetReqParam("describe", params, fields);
    JSgetReqParam("is_open", params, fields);
    if (fields.size() == 0)
    {
        return 0;
    }
    fields.set("update_time", Utils::timeNowStr());

    std::string sqlC = "WHERE price_id='" + priceId.toStdString() + "'";
    auto dao = DAO::get("price");
    auto ret = dao->updateFields(fields, sqlC);
    return ret ? 0 : 1;
}

QVariantList MyWebHandler::queryPriceTypeList()
{
    const std::vector<std::pair<int, std::string>> vecTypeDef =
    {
        {1, "充电计费"},
    };

    QVariantList result;
    for (auto& item: vecTypeDef)
    {
        QVariantMap row;
        row["id"] = item.first;
        row["name"] = item.second.c_str();
        result << row;
    }
    return result;
}

QVariantMap MyWebHandler::queryPolicyList(int page, int pageSize)
{
    std::vector<DataFields> res;
    auto dao = DAO::get("policy");
    bool ret = dao->exec("SELECT * FROM policy;", res);
    XLOGD() << "queryPolicyList: size=" << res.size();

    QVariantMap result;
    JSsetResPaginaion(result, res, page, pageSize, res.size(), 0, "操作成功");
    return result;
}

int MyWebHandler::insertPolicy(QVariantMap params) 
{ 
    DataFields fields;
    JSgetReqParam("type", params, fields);
    JSgetReqParam("name", params, fields);
    JSgetReqParam("value", params, fields);
    JSgetReqParam("describe", params, fields);
    JSgetReqParam("is_open", params, fields);
    if (fields.size() == 0)
    {
        return 0;
    }
    fields.set("create_time", Utils::timeNowStr());
    fields.set("update_time", Utils::timeNowStr());

    auto dao = DAO::get("policy");
    bool ret = dao->insertFields(fields);
    return ret ? 0 : 1;
}

int MyWebHandler::deletePolicy(const QString& policyId) { return 1; }

int MyWebHandler::updatePolicy(const QString& policyId, QVariantMap params) 
{
    DataFields fields;
    JSgetReqParam("type", params, fields);
    JSgetReqParam("name", params, fields);
    JSgetReqParam("value", params, fields);
    JSgetReqParam("describe", params, fields);
    JSgetReqParam("is_open", params, fields);
    if (fields.size() == 0)
    {
        return 0;
    }
    fields.set("update_time", Utils::timeNowStr());

    std::string sqlC = "WHERE policy_id='" + policyId.toStdString() + "'";
    auto dao = DAO::get("policy");
    auto ret = dao->updateFields(fields, sqlC);
    return ret ? 0 : 1;
}

QVariantList MyWebHandler::queryPolicyTypeList()
{
    const std::vector<std::pair<int, std::string>> vecTypeDef =
    {
        {1, "发电策略"},
        {2, "储能策略"},
        {3, "充电策略"},
    };

    QVariantList result;
    for (auto& item: vecTypeDef)
    {
        QVariantMap row;
        row["id"] = item.first;
        row["name"] = item.second.c_str();
        result << row;
    }
    return result;
}


QVariantMap MyWebHandler::querySyslogList(int page, int pageSize)
{
    std::vector<DataFields> res;
    auto dao = DAO::get("system_log");
    bool ret = dao->exec("SELECT * FROM system_log;", res);
    XLOGD() << "querySyslogList: size=" << res.size();

    QVariantMap result;
    JSsetResPaginaion(result, res, page, pageSize, res.size(), 0, "操作成功");
    return result;
}

QVariantMap MyWebHandler::querySecPolicyList(int page, int pageSize)
{
    std::vector<DataFields> res;
    auto dao = DAO::get("sec_policy");
    bool ret = dao->exec("SELECT * FROM sec_policy;", res);
    XLOGD() << "querySecPolicyList: size=" << res.size();

    QVariantMap result;
    JSsetResPaginaion(result, res, page, pageSize, res.size(), 0, "操作成功");
    return result;
}

int MyWebHandler::insertSecPolicy(QVariantMap params)
{
    DataFields fields;
    JSgetReqParam("name", params, fields);
    JSgetReqParam("type", params, fields);
    JSgetReqParam("code", params, fields);
    JSgetReqParam("level", params, fields);
    JSgetReqParam("describe", params, fields);
    JSgetReqParam("action", params, fields);
    JSgetReqParam("is_open", params, fields);
    if (fields.size() == 0)
    {
        return 0;
    }
    fields.set("create_time", Utils::timeNowStr());
    fields.set("update_time", Utils::timeNowStr());

    auto dao = DAO::get("sec_policy");
    bool ret = dao->insertFields(fields);
    return ret ? 0 : 1;
}

int MyWebHandler::updateSecPolicy(const QString& policyId, QVariantMap params)
{
    DataFields fields;
    JSgetReqParam("name", params, fields);
    JSgetReqParam("type", params, fields);
    JSgetReqParam("code", params, fields);
    JSgetReqParam("level", params, fields);
    JSgetReqParam("describe", params, fields);
    JSgetReqParam("action", params, fields);
    JSgetReqParam("is_open", params, fields);
    if (fields.size() == 0)
    {
        return 0;
    }
    fields.set("update_time", Utils::timeNowStr());

    std::string sqlC = "WHERE sec_policy_id='" + policyId.toStdString() + "'";
    auto dao = DAO::get("sec_policy");
    auto ret = dao->updateFields(fields, sqlC);
    return ret ? 0 : 1;
}

QVariantMap MyWebHandler::querySecRecordList(int page, int pageSize) 
{
    std::vector<DataFields> res;
    auto dao = DAO::get("sec_record");
    bool ret = dao->exec("SELECT * FROM sec_record;", res);
    XLOGD() << "querySecRecordList: size=" << res.size();

    QVariantMap result;
    JSsetResPaginaion(result, res, page, pageSize, res.size(), 0, "操作成功");
    return result;
};

int MyWebHandler::insertSecRecord(QVariantMap params) { return 0; };
int MyWebHandler::updateSecRecord(const QString& policyId, QVariantMap params) { return 0; };


QVariantList MyWebHandler::getDeviceInfo(const QVariantList& types)
{
    std::vector<std::shared_ptr<DeviceEntity>> vecDevice;
    for (auto item: types) 
    {
        int deviceType = item.toInt();
        auto vecRes = Device::getDeviceByType(deviceType);
        vecDevice.insert(vecDevice.end(), vecRes.begin(), vecRes.end());
    }

    QVariantList result;
    for (auto& device: vecDevice)
    {
        QVariantMap row;
        row["device_id"] = device->deviceId;
        row["name"] = device->name.c_str();
        row["type"] = device->type;
        row["status"] = device->status;
        row["online"] = device->online;
        row["err"] = device->err;
        result << row;
    }
    return result;
}