energy_storage/src/database/Dao.cpp

#include "Dao.h"
#include "common/Utils.h"

std::string DAO::sqlPageLimit(int index, int size)
{
    int startIndex = index * size;
    if (startIndex < 0) { startIndex = 0; }
    return " LIMIT " + std::to_string(startIndex) + "," + std::to_string(size);
}

bool DAO::count(DaoEntity& dao, std::string tableName, std::string condition, int& count)
{
    std::string sql = "SELECT COUNT(*) count FROM " + tableName;
    if (!condition.empty()) { sql += " WHERE " + condition; };
    sql += ";";

    std::vector<Fields> result;
    bool ret = dao.exec(sql, result);
    if (ret)
    {
        count = (result.size() > 0) ? result[0].get<int>("count") : 0;
    }
    return ret;
}

Errcode DAO::exec(std::shared_ptr<DaoEntity> dao, std::string sql)
{
    if (!dao) { dao = DaoEntity::create(""); }
    if (!dao->isConnected())
    {
        return Errcode::ERR_DB_CONN;
    }
    auto ret = dao->exec(sql);
    return ret ? Errcode::OK : Errcode::ERR_DB_SQL;
}

Errcode DAO::exec(std::shared_ptr<DaoEntity> dao, std::string sql, vector<Fields>& result)
{
    if (!dao) { dao = DaoEntity::create(""); }
    if (!dao->isConnected())
    {
        return Errcode::ERR_DB_CONN;
    }
    auto ret = dao->exec(sql, result);
    return ret ? Errcode::OK : Errcode::ERR_DB_SQL;
}

static bool QueryCount(DaoEntity& dao, std::string sqlFrom, int& count)
{
    std::vector<Fields> result;
    bool ret = dao.exec("SELECT COUNT(*) count " + sqlFrom, result);
    if (ret)
    {
        count = (result.size() > 0) ? result[0].get<int>("count") : 0;
    }
    return ret;
}


static bool QueryPagination(std::string sqlFields, std::string sqlCondition, PageInfo& page, vector<Fields>& result)
{
    DaoEntity dao("");

    int count {0};
    if (!QueryCount(dao, sqlCondition, count))
    {
        return false;
    }
    
    page.total = count;
    std::string sql = "SELECT " + sqlFields + " " + sqlCondition + DAO::sqlPageLimit(page.index, page.size);
    bool ret = dao.exec(sql, result);
    if (!ret)
    {
        XLOGE() << "DAO database error: sql=" << sql;
    }
    return ret;
}

// 新增用户信息
Errcode DAO::insertUser(Fields& params)
{
    std::string createTime = Utils::timeStr();
    auto dao = DaoEntity::create(DMUser::TABLENAME);
    std::string account = params.value(DMUser::ACCOUNT);

    std::string userRoleId = params.remove(DMRole::ROLE_ID);
    

    // step1: 查询
    std::vector<Fields> result;
    bool ret = dao->exec("SELECT * from user WHERE account='" + account + "';", result);
    if (!ret)
    {
        return Errcode::ERR_DB_CONN;
    }
    if (result.size() > 0)
    {
        return Errcode::ERR_DB_DUPLICATE;
    }
    params.set(DMUser::CREATETIME, createTime);
    ret = dao->insertFields(params);
    if (!ret)
    {
        return Errcode::ERR_DB_SQL;
    }
    if (!userRoleId.empty())
    {
        Fields paramsUserRole;
        paramsUserRole.set(DMUser::USER_ID, params.value(DMUser::USER_ID));
        paramsUserRole.set(DMRole::ROLE_ID, userRoleId);
        paramsUserRole.set(DMUser::UPDATETIME, createTime);
        ret = dao->duplicateUpdate(paramsUserRole, {DMUser::USER_ID});
    }
    return Errcode::OK;
}


// 分页查询用户信息列表
bool DAO::queryUserList(PageInfo& pageInfo, vector<Fields>& result)
{
    std::string sqlFields = "u.*, r.role_id , r.name role_name";
    std::string sqlCondition = "FROM USER u LEFT JOIN user_role ur ON ur.user_id = u.user_id LEFT JOIN ROLE r ON r.role_id =ur.role_id";

    DaoEntity dao("");
    bool ret = QueryPagination(sqlFields, sqlCondition, pageInfo, result);
    if (!ret)
    {
        XLOGE() << "DAO database error: queryUserList failed.";
    }
    return ret;
}

Errcode DAO::updateUserById(Fields& params)
{
    auto dao = DaoEntity::create(DMUser::TABLENAME);

    std::string createTime = Utils::timeStr();
    std::string userId = params.remove(DMUser::USER_ID);
    std::string roleId = params.remove(DMRole::ROLE_ID);

    if (params.size() > 0)
    {
        bool ret = dao->updateFields(params, "WHERE " + DMUser::USER_ID + "='" + userId + "'");
        if (!ret)
        {
            return Errcode::ERR_DB_SQL;
        }
    }
    if (!roleId.empty())
    {
        dao->setTableName(DMUserRole::TABLENAME);
        Fields paramsUserRole;
        paramsUserRole.set(DMUserRole::USER_ID, userId);
        paramsUserRole.set(DMUserRole::ROLE_ID, roleId);
        paramsUserRole.set(DMUserRole::UPDATETIME, createTime);
        bool ret = dao->duplicateUpdate(paramsUserRole, {DMUserRole::ROLE_ID});
        if (!ret)
        {
            return Errcode::ERR_DB_SQL;
        }
    }
    return Errcode::OK;
}

Errcode DAO::queryRoleList(std::shared_ptr<DaoEntity> dao, vector<Fields>& result)
{
    std::string sql = "SELECT * FROM " + DMRole::TABLENAME + ";";
    return DAO::exec(dao, sql, result);
}

bool DAO::queryRoleList(PageInfo& pageInfo, vector<Fields>& result)
{
    DaoEntity dao("");
    std::string sqlFrom = "FROM " + DMRole::TABLENAME;
    bool ret = QueryPagination("*", sqlFrom, pageInfo, result);
    if (!ret)
    {
        XLOGE() << "DAO database error: queryRoleList failed.";
    }
    return ret;
}

bool DAO::queryPermissionList(PageInfo& pageInfo, vector<Fields>& result)
{
    DaoEntity dao("");
    std::string sqlFrom = "FROM " + DMPermission::TABLENAME;
    bool ret = QueryPagination("*", sqlFrom, pageInfo, result);
    if (!ret)
    {
        XLOGE() << "DAO database error: queryPermissionList failed.";
    }
    return ret;
}

Errcode DAO::insertStation(Fields& params)
{
    auto dao = DaoEntity::create(DMStation::TABLENAME);
    params.remove(DMStation::STATION_ID);
    params.check(DMStation::LATITUDE, "", "NULL");
    params.check(DMStation::LONGITUDE, "", "NULL");

    std::string sql = params.toSqlInsert(DMStation::TABLENAME);
    return DAO::exec(dao, sql);
}

// 查询场站信息列表
Errcode DAO::queryStationList(std::shared_ptr<DaoEntity> dao, vector<Fields>& result)
{
    std::string sql = "SELECT * FROM " + DMStation::TABLENAME;
    return DAO::exec(dao, sql, result);
}

// 分页查询场站信息列表
bool DAO::queryStationList(PageInfo& pageInfo, vector<Fields>& result)
{
    DaoEntity dao("");
    std::string sqlFrom = "FROM " + DMStation::TABLENAME;
    bool ret = QueryPagination("*", sqlFrom, pageInfo, result);
    if (!ret)
    {
        XLOGE() << "DAO database error: queryStationList failed.";
    }
    return ret;
}

Errcode DAO::updateStationById(Fields& params)
{
    std::string stationId = params.value(DMStation::STATION_ID);
    if (stationId.empty())
    {
        return Errcode::ERR_DB_SQL;
    }
    params.remove(DMStation::STATION_ID);
    auto dao = DaoEntity::create(DMStation::TABLENAME);
    bool ret = dao->updateFields(params, "WHERE " + DMStation::STATION_ID + "='" + stationId + "'");
    if (!ret)
    {
        return Errcode::ERR_DB_SQL;
    }
    return Errcode::OK;
}

// 查询设备信息列表
Errcode DAO::queryDeviceList(std::shared_ptr<DaoEntity> dao, vector<Fields>& result)
{
    std::string sql = "SELECT * FROM " + DMDevice::TABLENAME;
    return DAO::exec(dao, sql, result);
}

// 分页查询设备信息列表
bool DAO::queryDeviceList(PageInfo& pageInfo, vector<Fields>& result)
{
    DaoEntity dao("");
    std::string sqlFrom = "FROM " + DMDevice::TABLENAME;
    bool ret = QueryPagination("*", sqlFrom, pageInfo, result);
    if (!ret)
    {
        XLOGE() << "DAO database error: queryDeviceList failed.";
    }
    return ret;
}

// 查询设备类型定义
Errcode DAO::queryDeviceTypeDef(std::shared_ptr<DaoEntity> dao, vector<Fields>& result)
{
    std::string sql = "SELECT * FROM " + DMDefDeviceType::TABLENAME + ";";
    return DAO::exec(dao, sql, result);
}

Errcode DAO::insertDevice(Fields& params)
{
    return DAO::exec(NULL, params.toSqlInsert(DMDevice::TABLENAME));
}

Errcode DAO::updateDeviceById(Fields& params)
{
    std::string deviceId = params.value(DMDevice::DEVICE_ID);
    if (deviceId.empty())
    {
        return Errcode::ERR_DB_SQL;
    }
    std::string sql = params.toSqlUpdate(DMDevice::TABLENAME, "WHERE " + DMDevice::DEVICE_ID + "='" + deviceId + "'");
    return DAO::exec(NULL, sql);
}

// 策略管理
bool DAO::queryPolicyList(PageInfo& pageInfo, vector<Fields>& result)
{
    auto dao = DaoEntity::create("");
    std::string sqlFrom = "FROM " + DMPolicy::TABLENAME;
    bool ret = QueryPagination("*", sqlFrom, pageInfo, result);
    if (!ret)
    {
        XLOGE() << "DAO database error: queryPolicyList failed.";
    }
    return ret;
}

Errcode DAO::queryPolicyList(std::shared_ptr<DaoEntity> dao, vector<Fields>& result)
{
    std::string sql = "SELECT * FROM " + DMPolicy::TABLENAME;
    return DAO::exec(dao, sql, result);
}
Errcode DAO::insertPolicy(Fields& params)
{
    return DAO::exec(NULL, params.toSqlInsert(DMPolicy::TABLENAME));
}
Errcode DAO::updatePolicyById(Fields& params)
{
    std::string policyId = params.value(DMPolicy::POLICY_ID);
    if (policyId.empty())
    {
        return Errcode::ERR_DB_SQL;
    }
    std::string sql = params.toSqlUpdate(DMPolicy::TABLENAME, "WHERE " + DMPolicy::POLICY_ID + "='" + policyId + "'");
    return DAO::exec(NULL, sql);
}

// 系统日志管理
bool DAO::querySystemLogList(PageInfo& pageInfo, vector<Fields>& result)
{
    DaoEntity dao("");
    std::string sqlFrom = "FROM " + DMSystemLog::TABLENAME;
    bool ret = QueryPagination("*", sqlFrom, pageInfo, result);
    if (!ret)
    {
        XLOGE() << "DAO database error: querySystemLogList failed.";
    }
    return ret;
}

Errcode DAO::queryStatDataList(std::shared_ptr<DaoEntity> dao, std::string startDate, std::string endDate, vector<Fields>& result)
{
    std::string sql = "SELECT * FROM " + DMStatStation::TABLENAME + " WHERE dt BETWEEN '" + startDate + "' AND '" + endDate + "';";
    return DAO::exec(dao, sql, result);
}

Errcode DAO::queryWorkModeDef(std::shared_ptr<DaoEntity> dao, vector<Fields>& result)
{
    std::string sql = "SELECT * FROM " + DMDefWorkMode::TABLENAME + ";";
    return DAO::exec(dao, sql, result);
}


Errcode DAO::queryPolicyTypeDef(std::shared_ptr<DaoEntity> dao, vector<Fields>& result)
{
    std::string sql = "SELECT * FROM " + DMDefPolicyType::TABLENAME + ";";
    return DAO::exec(dao, sql, result);
}