energy_storage/src/app/Dao.cpp

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

enum class EnDatabaseErr
{
    SUCCESS = 0,
};

std::shared_ptr<DaoEntity> DAO::get(std::string tableName)
{
    return std::make_shared<DaoEntity>(tableName);
}

bool DAO::login(std::shared_ptr<DaoEntity> dao, std::string account, std::string passwd, std::string& err)
{
    std::string t = Utils::timeNowStr();
    if (!dao)
    {
        dao = std::make_shared<DaoEntity>("");
    }
    if (!dao->isConnected())
    {
        err = "数据库连接错误";
        DAO::writeSystemLog(dao, 2, "", account, "用户登录失败:" + err);
        return false;
    }

    std::string sql = "SELECT * FROM user WHERE account='" + account + "';";

    std::vector<DataFields> res;
    bool ret = dao->exec(sql, res);
    if (!ret)
    {
        err = "数据库操作错误";
        DAO::writeSystemLog(dao, 2, "", account, "用户登录失败:" + err);
        return false;
    }
    if (res.size() <=0)
    {
        err = "用户不存在";
        DAO::writeSystemLog(dao, 2, "", account, "用户登录失败:" + err);
        return false;
    }
    DataFields& fields = res[0];
    std::string userId = fields.get_str("user_id");
    int loginCount = fields.get_int("login_count");

    // 判断密码
    if (passwd != fields.get_str("passwd"))
    {
        err = "密码错误";
        DAO::writeSystemLog(dao, 2, userId, account, "用户登录失败:" + err);
        return false;
    }

    err = "登录成功";

    // 数据库更新用户登录信息
    sql = "UPDATE user SET login_time='" + t + "', login_count='" + std::to_string(loginCount + 1) + "' WHERE user_id = '" +  userId + "'; ";
    ret = dao->exec(sql);
    if (!ret)
    {
        XLOGE() << "更新用户登录信息失败：sql=" << sql;
    }

    DAO::writeSystemLog(dao, 2, userId, account, "用户登录成功");
    return true;
}

bool DAO::writeSystemLog(std::shared_ptr<DaoEntity> dao, int type, std::string userId, std::string account, std::string text)
{
    if (!dao)
    {
        dao = std::make_shared<DaoEntity>("");
    }
    if (!dao->isConnected())
    {
        return false;
    }

    // 数据库写入登录日志
    dao->setTableName("system_log");
    DataFields fieldsLog;
    fieldsLog.set("id", Snowflake::instance().nextIdStr());
    fieldsLog.set("type", 2);
    fieldsLog.set("user_id", userId);
    fieldsLog.set("user_account", account);
    fieldsLog.set("content", text);
    fieldsLog.set("log_time", Utils::timeNowStr());
    bool ret = dao->insertFields({fieldsLog});
    return ret;
}


bool DAO::queryUser(std::vector<DataFields>& res)
{
    std::shared_ptr<DaoEntity> dao = std::make_shared<DaoEntity>("");
    if (!dao->isConnected())
    {
        return false;
    }
    std::string sql = "SELECT u.*, r.role_id, r.name role_name from USER u LEFT JOIN user_role ur ON u.user_id = ur.user_id LEFT JOIN `role` r ON r.role_id = ur.role_id;";
    bool ret = dao->exec(sql, res);
    return ret;
}

int DAO::insertUser(DataFields& fields)
{
    std::shared_ptr<DaoEntity> dao = std::make_shared<DaoEntity>("user");
    if (!dao->isConnected())
    {
        return 1;
    }

    std::string account = fields.get_str("account");

    // step1: 查询
    std::vector<DataFields> res;
    bool ret = dao->exec("SELECT * from user WHERE account='" + account + "';", res);
    if (!ret)
    {
        return 1;
    }
    if (res.size() > 0)
    {
        return 1;
    }

    fields.set("user_id", Snowflake::instance().nextIdStr());
    fields.set("create_time", Utils::timeNowStr());
    ret = dao->insertFields(fields);
    return (ret) ? 0 : 1;
}

int DAO::updateUserById(std::string id, DataFields& fields)
{
    std::shared_ptr<DaoEntity> dao = std::make_shared<DaoEntity>("user");
    if (!dao->isConnected())
    {
        return 1;
    }
    string sqlC = "WHERE user_id='" + id + "'";
    bool ret = dao->updateFields(fields, sqlC);
    return (ret) ? 0 : 1;
}