实现HTTP服务架构

src/database/Dao.cpp

@@ -1,5 +1,9 @@
 #include "Dao.h"
 #include "common/Utils.h"
+#include "common/Snowflake.h"
+#include "common/JsonN.h"
+#include "app/Application.h"
+#include "app/AppData.h"
 
 std::string DAO::sqlPageLimit(int index, int size)
 {
@@ -8,19 +12,19 @@ std::string DAO::sqlPageLimit(int index, int size)
     return " LIMIT " + std::to_string(startIndex) + "," + std::to_string(size);
 }
 
-bool DAO::count(DaoEntity& dao, std::string tableName, std::string condition, int& count)
+Errcode 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)
+    int ret = dao.exec(sql, result);
+    if (ret == 0)
     {
         count = (result.size() > 0) ? result[0].get<int>("count") : 0;
     }
-    return ret;
+    return Errcode(ret);
 }
 
 Errcode DAO::exec(std::shared_ptr<DaoEntity> dao, std::string sql)
@@ -31,7 +35,7 @@ Errcode DAO::exec(std::shared_ptr<DaoEntity> dao, std::string sql)
         return Errcode::ERR_DB_CONN;
     }
     auto ret = dao->exec(sql);
-    return ret ? Errcode::OK : Errcode::ERR_DB_SQL;
+    return Errcode(ret);
 }
 
 Errcode DAO::exec(std::shared_ptr<DaoEntity> dao, std::string sql, vector<Fields>& result)
@@ -42,68 +46,109 @@ Errcode DAO::exec(std::shared_ptr<DaoEntity> dao, std::string sql, vector<Fields
         return Errcode::ERR_DB_CONN;
     }
     auto ret = dao->exec(sql, result);
-    return ret ? Errcode::OK : Errcode::ERR_DB_SQL;
+    return Errcode(ret);
 }
-
-static bool QueryCount(DaoEntity& dao, std::string sqlFrom, int& count)
+Errcode DAO::query(std::shared_ptr<DaoEntity> dao, std::string tableName, std::vector<std::string> keys, std::string condition)
+{
+    std::string sql;
+    return DAO::exec(dao, sql);
+}
+Errcode DAO::queryPagination(std::shared_ptr<DaoEntity> dao, std::string tableName, std::vector<std::string> keys, std::string condition)
+{
+    std::string sql;
+    return DAO::exec(dao, sql);
+}
+Errcode DAO::insert(std::shared_ptr<DaoEntity> dao, std::string tableName, Fields params)
+{
+    return DAO::exec(dao, params.toSqlInsert(tableName));
+}
+Errcode DAO::update(std::shared_ptr<DaoEntity> dao, std::string tableName, Fields params, std::string primaryKey)
+{
+    std::string primaryVal = params.remove(primaryKey);
+    if (primaryVal.empty())
+    {
+        XLOGE() << "DAO update [" + tableName + "] failed, " << primaryKey << "=NULL.";
+        return Errcode::ERR_PARAM;
+    }
+    if (params.size() == 0)
+    {
+        XLOGE() << "DAO update [" + tableName + "] failed, params size=0.";
+        return Errcode::ERR_PARAM_NUL;
+    }
+    std::string condition = "WHERE " + primaryKey + "='" + primaryVal + "'";
+    string sql = params.toSqlUpdate(tableName, condition);
+    return DAO::exec(dao, sql);
+}
+Errcode DAO::remove(std::shared_ptr<DaoEntity> dao, std::string tableName, std::string primaryKey, std::string val)
+{
+    std::string sql = "DELETE from `" + tableName + "` WHERE " + primaryKey + "='" + val + "';";
+    return DAO::exec(dao, sql);
+}
+static Errcode QueryCount(DaoEntity& dao, std::string sqlFrom, int& count)
 {
     std::vector<Fields> result;
-    bool ret = dao.exec("SELECT COUNT(*) count " + sqlFrom, result);
-    if (ret)
+    int ret = dao.exec("SELECT COUNT(*) count " + sqlFrom, result);
+    if (ret != 0)
     {
         count = (result.size() > 0) ? result[0].get<int>("count") : 0;
     }
-    return ret;
+    return Errcode(ret);
 }
 
 
-static bool QueryPagination(std::string sqlFields, std::string sqlCondition, PageInfo& page, vector<Fields>& result)
+static Errcode QueryPagination(std::string sqlFields, std::string sqlCondition, PageInfo& page, vector<Fields>& result)
 {
     DaoEntity dao("");
-
-    int count {0};
-    if (!QueryCount(dao, sqlCondition, count))
+    if (!dao.isConnected())
     {
-        return false;
+        return Errcode::ERR_DB_CONN;
+    }
+    int count {0};
+    Errcode err = QueryCount(dao, sqlCondition, count);
+    if (err != Errcode::OK)
+    {
+        return err;
     }
     
     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;
+    int ret = dao.exec(sql, result);
+    return Errcode(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)
+    if (account.empty())
     {
-        return Errcode::ERR_DB_CONN;
+        return Errcode::ERR_PARAM;
+    }
+
+    // step1: 查询检查登录名是否已经存在
+    std::vector<Fields> result;
+    auto dao = DaoEntity::create(DMUser::TABLENAME);
+    int ret = dao->exec("SELECT * from user WHERE account='" + account + "';", result);
+    if (ret != 0)
+    {
+        return Errcode(ret);
     }
     if (result.size() > 0)
     {
         return Errcode::ERR_DB_DUPLICATE;
     }
+
+    std::string createTime = Utils::timeStr();
+    params.set(DMUser::USER_ID, Snowflake::instance().getIdStr());
     params.set(DMUser::CREATETIME, createTime);
+    params.set(DMUser::PASSWD, "123456");
     ret = dao->insertFields(params);
-    if (!ret)
+    if (ret != 0)
     {
-        return Errcode::ERR_DB_SQL;
+        return Errcode(ret);
     }
+
+    std::string userRoleId = params.remove(DMRole::ROLE_ID);
     if (!userRoleId.empty())
     {
         Fields paramsUserRole;
@@ -115,20 +160,79 @@ Errcode DAO::insertUser(Fields& params)
     return Errcode::OK;
 }
 
+Errcode DAO::login(std::shared_ptr<DaoEntity> dao, std::string account, std::string passwd, Fields& fields)
+{
+    if (!dao) { dao = std::make_shared<DaoEntity>(""); }
+    if (!dao->isConnected())
+    {
+
+        //DAO1::writeSystemLog(dao, 2, "", account, "用户登录失败:" + err);
+        return Errcode::ERR_DB_CONN;
+    }
+    std::string t = Utils::timeStr();
+
+    std::string sql = "SELECT u.*, ur.role_id FROM `user` u"
+        " LEFT JOIN user_role ur ON u.user_id = ur.user_id WHERE u.account='" + account + "';";
+    std::vector<Fields> result;
+    int ret = dao->exec(sql, result);
+    if (ret != 0)
+    { 
+        //DAO1::writeSystemLog(dao, 2, "", account, "用户登录失败:" + err);
+        return Errcode(ret);
+    }
+    if (result.size() <=0)
+    {
+        //DAO1::writeSystemLog(dao, 2, "", account, "用户登录失败:" + err);
+        return Errcode::ERR_LOGIN_USER_NOTEXIST;
+    }
+    fields = result[0];
+    std::string userId = fields.value("user_id");
+    int loginCount = fields.get<int>("login_count");
+
+    // 判断密码
+    if (passwd != fields.remove("passwd"))
+    {
+        //DAO1::writeSystemLog(dao, 2, userId, account, "用户登录失败:" + err);
+        return Errcode::ERR_LOGIN_PASSWD;
+    }
+
+    // 数据库更新用户登录信息
+    //sql = "UPDATE user SET login_time='" + t + "', login_count='" + std::to_string(loginCount + 1) + "' WHERE user_id = '" +  userId + "'; ";
+    //ret = dao->exec(sql);
+    //if (ret != 0)
+    //{
+    //    XLOGE() << "更新用户登录信息失败：sql=" << sql;
+    //}
+
+    //DAO1::writeSystemLog(dao, 2, userId, account, "用户登录成功");
+    return Errcode::OK;
+}
+
+Errcode DAO::queryRolePermission(std::shared_ptr<DaoEntity> dao, int roleId, vector<Fields>& result)
+{
+    std::string sql = "SELECT rp.role_id, rp.permission_id, p.name FROM role_permission rp"
+        " LEFT JOIN permission p ON p.permission_id = rp.permission_id"
+        " WHERE rp.is_open='1' AND rp.role_id ='" + std::to_string(roleId) + "';";
+    return DAO::exec(dao, sql, result);
+}
+
+Errcode DAO::queryRolePermission(std::shared_ptr<DaoEntity> dao, vector<Fields>& result)
+{
+    // 查询 role 的 permission
+    std::string sql = "SELECT rp.role_id, rp.permission_id, rp.is_open, r.name role_name, p.name permission_name FROM role_permission rp"
+        " LEFT JOIN `role` r ON r.role_id = rp.role_id"
+        " LEFT JOIN permission p ON p.permission_id = rp.permission_id"
+        " WHERE rp.is_open='1';";
+    return DAO::exec(dao, sql, result);
+}
 
 // 分页查询用户信息列表
-bool DAO::queryUserList(PageInfo& pageInfo, vector<Fields>& result)
+Errcode DAO::queryUserList(PageInfo& pageInfo, vector<Fields>& result)
 {
-    std::string sqlFields = "u.*, r.role_id , r.name role_name";
+    std::string sqlFields = "u.user_id, u.account, u.name, u.phone, u.age, u.email, u.gender, u.is_open, u.create_time, u.update_time, 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;
+    return QueryPagination(sqlFields, sqlCondition, pageInfo, result);
 }
 
 Errcode DAO::updateUserById(Fields& params)
@@ -141,10 +245,10 @@ Errcode DAO::updateUserById(Fields& params)
 
     if (params.size() > 0)
     {
-        bool ret = dao->updateFields(params, "WHERE " + DMUser::USER_ID + "='" + userId + "'");
-        if (!ret)
+        int ret = dao->updateFields(params, "WHERE " + DMUser::USER_ID + "='" + userId + "'");
+        if (ret != 0)
         {
-            return Errcode::ERR_DB_SQL;
+            return Errcode(ret);
         }
     }
     if (!roleId.empty())
@@ -154,43 +258,137 @@ Errcode DAO::updateUserById(Fields& params)
         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)
+        int ret = dao->duplicateUpdate(paramsUserRole, {DMUserRole::ROLE_ID});
+        if (ret != 0)
         {
-            return Errcode::ERR_DB_SQL;
+            return Errcode(ret);
         }
     }
     return Errcode::OK;
 }
 
+Errcode DAO::deleteUserById(std::string userId)
+{
+    std::string sql = "DELETE from user WHERE user_id='" + userId + "';";
+    return DAO::exec(NULL, sql);
+}
+
+Errcode DAO::queryPermissionList(PageInfo& pageInfo, vector<Fields>& result)
+{
+    std::string sqlFrom = "FROM " + DMPermission::TABLENAME;
+    return QueryPagination("*", sqlFrom, pageInfo, result);
+}
+
+Errcode DAO::insertPermission(Fields& params)
+{
+    return DAO::exec(NULL, params.toSqlInsert(DMPermission::TABLENAME));
+}
+
+Errcode DAO::updatePermissionById(Fields& params)
+{
+    std::string primaryKey = DMPermission::PERMISSION_ID;
+    std::string primaryVal = params.remove(primaryKey);
+    if (primaryVal.empty())
+    {
+        return Errcode::ERR_DB_SQL;
+    }
+    std::string condition = "WHERE " + primaryKey + "='" + primaryVal + "'";
+    string sql = params.toSqlUpdate(DMPermission::TABLENAME, condition);
+    return DAO::exec(NULL, sql);
+}
+
+Errcode DAO::deletePermissionById(std::string permissionId)
+{
+    std::string sql = "DELETE from permission WHERE permission_id='" + permissionId + "';";
+    return DAO::exec(NULL, sql);
+}
+
 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)
+Errcode 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;
+    std::string sqlFields = "";
+    std::string sqlCondition = "FROM " + DMRole::TABLENAME;
+    return QueryPagination("*", sqlCondition, pageInfo, result);
 }
 
-bool DAO::queryPermissionList(PageInfo& pageInfo, vector<Fields>& result)
+Errcode DAO::updateRolePermission(std::shared_ptr<DaoEntity> dao, std::string roleId, std::string permission)
 {
-    DaoEntity dao("");
-    std::string sqlFrom = "FROM " + DMPermission::TABLENAME;
-    bool ret = QueryPagination("*", sqlFrom, pageInfo, result);
-    if (!ret)
+    NJsonNode jnode;
+    NJson::parse(permission, jnode);
+    std::vector<Fields> vec;
+    for (auto& item: jnode)
     {
-        XLOGE() << "DAO database error: queryPermissionList failed.";
+        std::string permissionId;
+        if (item.is_number()) { permissionId = std::to_string(item.get<int>()); }
+        if (item.is_string()) { permissionId = item.get<std::string>(); }
+        if (!permissionId.empty())
+        {
+            Fields field;
+            field.set("role_id", roleId);
+            field.set("permission_id", permissionId);
+            vec.emplace_back(field);
+        }
     }
-    return ret;
+    dao->setTableName(DMRolePermission::TABLENAME);
+    std::string sqlDel = "DELETE from " + DMRolePermission::TABLENAME + " WHERE role_id='" + roleId + "';";
+    int ret = dao->exec(sqlDel);
+    if (ret != 0 ){ return Errcode(ret); };
+    ret = dao->insertFields(vec);
+    if (ret != 0) { return Errcode(ret); };
+    return Errcode::OK;
+}
+
+// 新增角色
+Errcode DAO::insertRole(Fields& params) 
+{
+    std::string permission = params.remove("permission");
+    std::string name = params.value("name");
+    auto dao = DaoEntity::create(DMRole::TABLENAME);
+    auto err = DAO::insert(dao, DMRole::TABLENAME, params);
+    
+    if (err == Errcode::OK && !permission.empty())
+    {
+        // 查询获取 roleId
+        std::vector<Fields> res;
+        std::string sql = "SELECT * FROM " + DMRole::TABLENAME + " WHERE name='" + name + "';";
+        err = DAO::exec(dao, sql, res);
+        if (err == Errcode::OK && res.size() > 0)
+        {
+            std::string roleId = res[0].value("role_id");
+            err = DAO::updateRolePermission(dao, roleId, permission);
+        }
+    }
+    return err;
+}
+
+// 更新角色
+Errcode DAO::updateRoleById(Fields& params)
+{
+    auto roleId = params.value(DMRole::ROLE_ID);
+    if (roleId.empty())
+    {
+        return Errcode::ERR_DB_SQL;
+    }
+    auto permission = params.remove("permission");
+
+    auto dao = DaoEntity::create(DMRole::TABLENAME);
+    auto err = DAO::update(dao, DMRole::TABLENAME, params, DMRole::ROLE_ID);
+    if (err == Errcode::OK && !permission.empty())
+    {
+        err = DAO::updateRolePermission(dao, roleId, permission);
+    }
+    return err;
+}
+
+// 删除角色
+Errcode DAO::deleteRoleById(std::string userId)
+{
+    return DAO::remove(NULL, DMRole::TABLENAME, DMRole::ROLE_ID, userId);
 }
 
 Errcode DAO::insertStation(Fields& params)
@@ -201,7 +399,7 @@ Errcode DAO::insertStation(Fields& params)
     params.check(DMStation::LONGITUDE, "", "NULL");
 
     std::string sql = params.toSqlInsert(DMStation::TABLENAME);
-    return DAO::exec(dao, sql);
+    return DAO::insert(NULL, DMStation::TABLENAME, params);
 }
 
 // 查询场站信息列表
@@ -212,33 +410,16 @@ Errcode DAO::queryStationList(std::shared_ptr<DaoEntity> dao, vector<Fields>& re
 }
 
 // 分页查询场站信息列表
-bool DAO::queryStationList(PageInfo& pageInfo, vector<Fields>& result)
+Errcode 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;
+    return QueryPagination("*", sqlFrom, pageInfo, result);
 }
 
 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;
+    std::string primaryKey = DMStation::STATION_ID;
+    return DAO::update(NULL, DMStation::TABLENAME, params, primaryKey);
 }
 
 // 查询设备信息列表
@@ -249,16 +430,10 @@ Errcode DAO::queryDeviceList(std::shared_ptr<DaoEntity> dao, vector<Fields>& res
 }
 
 // 分页查询设备信息列表
-bool DAO::queryDeviceList(PageInfo& pageInfo, vector<Fields>& result)
+Errcode 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;
+    return QueryPagination("*", sqlFrom, pageInfo, result);
 }
 
 // 查询设备类型定义
@@ -275,26 +450,14 @@ Errcode DAO::insertDevice(Fields& params)
 
 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);
+    return DAO::update(NULL, DMDevice::TABLENAME, params, DMDevice::DEVICE_ID);
 }
 
 // 策略管理
-bool DAO::queryPolicyList(PageInfo& pageInfo, vector<Fields>& result)
+Errcode 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;
+    return QueryPagination("*", sqlFrom, pageInfo, result);
 }
 
 Errcode DAO::queryPolicyList(std::shared_ptr<DaoEntity> dao, vector<Fields>& result)
@@ -304,31 +467,77 @@ Errcode DAO::queryPolicyList(std::shared_ptr<DaoEntity> dao, vector<Fields>& res
 }
 Errcode DAO::insertPolicy(Fields& params)
 {
-    return DAO::exec(NULL, params.toSqlInsert(DMPolicy::TABLENAME));
+    return DAO::insert(NULL, DMPolicy::TABLENAME, params);
 }
 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);
+    return DAO::update(NULL, DMPolicy::TABLENAME, params, DMPolicy::POLICY_ID);
+}
+Errcode DAO::deletePolicyById(std::string policyId)
+{
+    return DAO::remove(NULL, DMPolicy::TABLENAME, DMPolicy::POLICY_ID, policyId);
 }
 
 // 系统日志管理
-bool DAO::querySystemLogList(PageInfo& pageInfo, vector<Fields>& result)
+Errcode 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;
+    std::string sqlFrom = "FROM " + DMLogSystem::TABLENAME;
+    return QueryPagination("*", sqlFrom, pageInfo, result);
 }
+Errcode DAO::insertSystemLog(Fields& params)
+{
+    params.set(DMLogAlert::LOG_ID, Snowflake::instance().getIdStr());
+    return DAO::insert(NULL, DMLogSystem::TABLENAME, params);
+}
+Errcode DAO::updateSystemLogById(Fields& params)
+{
+    return DAO::update(NULL, DMLogSystem::TABLENAME, params, DMLogSystem::LOG_ID);
+}
+
+Errcode DAO::insertSystemLogSys(std::string content, int status)
+{
+    Fields fields;
+    fields.set("type", 1);
+    fields.set("content", content);
+    fields.set("status", status);
+    return DAO::insertSystemLog(fields);
+}
+Errcode DAO::insertSystemLogUser(std::string token, std::string content, int status)
+{
+    User user = Application::data().getUser(token);
+    Fields fields;
+    fields.set("type", 2);
+    fields.set("content", content);
+    fields.set("status", status);
+    fields.set("user_id", user.userId);
+    fields.set("user_account", user.account);
+    return DAO::insertSystemLog(fields);
+}
+Errcode DAO::insertSystemLogDevice(std::string deviceId, std::string content, int status)
+{
+    Fields fields;
+    fields.set("type", 3);
+    fields.set("content", content);
+    fields.set("status", status);
+    fields.set("device_id", deviceId);
+    return DAO::insertSystemLog(fields);
+}
+
+Errcode DAO::queryAlertLogList(PageInfo& pageInfo, vector<Fields>& result)
+{
+    std::string sqlFrom = "FROM " + DMLogAlert::TABLENAME;
+    return QueryPagination("*", sqlFrom, pageInfo, result);
+}
+Errcode DAO::insertAlertLog(Fields& params)
+{
+    params.set(DMLogAlert::LOG_ID, Snowflake::instance().getIdStr());
+    return DAO::insert(NULL, DMLogAlert::TABLENAME, params);
+}
+Errcode DAO::updateAlertLogById(Fields& params)
+{
+    return DAO::update(NULL, DMLogAlert::TABLENAME, params, DMLogAlert::LOG_ID);
+}
+
 
 Errcode DAO::queryStatDataList(std::shared_ptr<DaoEntity> dao, std::string startDate, std::string endDate, vector<Fields>& result)
 {
@@ -342,7 +551,6 @@ Errcode DAO::queryWorkModeDef(std::shared_ptr<DaoEntity> dao, vector<Fields>& re
     return DAO::exec(dao, sql, result);
 }
 
-
 Errcode DAO::queryPolicyTypeDef(std::shared_ptr<DaoEntity> dao, vector<Fields>& result)
 {
     std::string sql = "SELECT * FROM " + DMDefPolicyType::TABLENAME + ";";