add userMgrService

README.md

@@ -3,6 +3,17 @@
 
 libwebsocket can/ uart logger ...
 
+```
+
+```
+错误码划分：
+
+
+APP_ERROR_CODE
+10000
+
+SYS_ERROR_CODE
+20000
 
 
 ```

app_protocols/apperrorcode/apperrorcode.hpp

@@ -13,15 +13,45 @@
 namespace iflytop {
 using namespace std;
 
+// // 驱动器错误
+// kerr_motor_reset_error        = 100,
+// kerr_motor_subdevice_offline  = 101,
+// kerr_motor_driver_error       = 102,
+// kerr_motor_undervoltage_error = 103,
+// kerr_motor_unkown_error       = 104,
+
+// kerr_AirBlowerError         = 200,  // 空压机异常
+// kerr_HeaterError            = 201,  // 加热片异常
+// kerr_BlowerError            = 202,  // 鼓风机异常
+// kerr_ProportionalValveError = 203,  // 气密性测试专用空压机异常
+
+// kerr_noerror              = 0,
+// kerr_overtime             = 1,
+// kerr_invalid_param        = 2,
+// kerr_invalid_param_num    = 3,
+// kerr_subdevice_offline    = 4,
+// kerr_function_not_support = 5,
+
+namespace err {
 typedef enum {
   ksucc = 0,
 
-  kappe_disinfectant_insufficient          = 1,  // 消毒液不足
-  kappe_the_bottom_of_the_device_has_water = 2,  // 设备底部有水
-  kappe_the_evaporation_bin_has_water      = 3,  // 蒸发仓有水
-  kappe_the_sensor_is_prehearting          = 4,  // 传感器正在预热
-  kappe_code_error                         = 5,  // 代码错误
+  kappe_begin = 10000,
+
+  kappe_disinfectant_insufficient          = 10001,  // 消毒液不足
+  kappe_the_bottom_of_the_device_has_water = 10002,  // 设备底部有水
+  kappe_the_evaporation_bin_has_water      = 10003,  // 蒸发仓有水
+  kappe_the_sensor_is_prehearting          = 10004,  // 传感器正在预热
+  kappe_code_error                         = 10005,  // 代码错误
+
+  kappe_user_not_exist  = 10006,
+  kappe_operate_error   = 10007,
+  kappe_passwd_error    = 10008,
+  kappe_cmd_not_support = 10009,
+  kappe_parse_json_err  = 10010,
+  kappe_std_exception   = 10011,
 
 } apperror_t;
+}
 
 }  // namespace iflytop

app_protocols/appexception/appexception.hpp

@@ -26,7 +26,12 @@ class appexception : public std::exception {
  public:
   string  description;
   string  whatstr;
-  int32_t ecode;
+  int32_t m_ecode;
+  appexception(int32_t ecode, const string &description) {
+    this->description = description;
+    this->m_ecode     = ecode;
+    this->whatstr     = description;
+  }
 
   appexception(int32_t ecode, const char *fmt, ...) {
     va_list args;
@@ -35,13 +40,16 @@ class appexception : public std::exception {
     vsnprintf(buffer, sizeof(buffer), fmt, args);
 
     this->description = buffer;
-
-    this->description = description;
-    this->ecode       = ecode;
-
-    this->whatstr = buffer;
+    this->m_ecode     = ecode;
+    this->whatstr     = buffer;
   }
   virtual ~appexception() {}
+  int         ecode() const { return m_ecode; }
   const char *what() const _GLIBCXX_USE_NOEXCEPT { return whatstr.c_str(); }
 };
+
+#define APPCHECK(expr, ecode, fmt, ...)               \
+  if (!(expr)) {                                   \
+    throw appexception(ecode, fmt, ##__VA_ARGS__); \
+  }
 }  // namespace iflytop

app_protocols/zscanprotocol

@@ -1 +1 @@
-Subproject commit 94c49f650f508e64b9e30e733dbb161c72ae2559
+Subproject commit d11d41c1062568f629d5ec2bc6435319b7ea83e3

appdep/components/uart_printer/uart_printer.hpp

@@ -30,6 +30,7 @@ class UartPrinter {
  public:
   UartPrinter();
   ~UartPrinter();
+  void initialize() {}
   void initialize(string path, string rate);
   void print(string str);
 };

appdep/components/zservice_container/zservice_container.hpp

@@ -190,7 +190,8 @@ class ServiceContrainer {
 #define BUILD_AND_REG_SERRVICE(type, ...)             \
   logger->info("build {}.....", #type);               \
   shared_ptr<type> type##_val(new type(__VA_ARGS__)); \
-  ServiceContrainer::get().regService(type##_val);
+  ServiceContrainer::get().regService(type##_val);\
+  GET_SERVICE(type)->initialize();
 
 #define REG_SERRVICE(type,object)             \
   shared_ptr<type> type##_val(object); \

appdep/iflytop/core/error/error_code.cpp

@@ -1,58 +0,0 @@
-#include "error_code.hpp"
-
-namespace iflytop {
-namespace err {
-
-using namespace std;
-
-typedef struct {
-  string errordesc;
-} error_desc_t;
-
-static map<error_t, error_desc_t> errormap = {
-    // {kovertime, {.errordesc = "overtime"}},
-
-    {ksucc, {.errordesc = "ksucc"}},
-    {kfail, {.errordesc = "kfail"}},
-    {kce_subboard_error_overtime, {.errordesc = "kce_subboard_error_overtime"}},
-    {kce_subboard_error_invalid_param, {.errordesc = "kce_subboard_error_invalid_param"}},
-    {kce_subboard_error_invalid_param_num, {.errordesc = "kce_subboard_error_invalid_param_num"}},
-    {kce_subboard_error_subdevice_offline, {.errordesc = "kce_subboard_error_subdevice_offline"}},
-    {kce_subboard_error_function_not_support, {.errordesc = "kce_subboard_error_function_not_support"}},
-    {kce_overtime, {.errordesc = "kce_overtime"}},
-    {kce_noack, {.errordesc = "kce_noack"}},
-    {kce_errorack, {.errordesc = "kce_errorack"}},
-    {kce_device_offline, {.errordesc = "kce_device_offline"}},
-    {kce_parse_json_err, {.errordesc = "kce_parse_json_err"}},
-    {kdbe_user_not_exist, {.errordesc = "kdbe_user_not_exist"}},
-    {kdbe_catch_exception, {.errordesc = "kdbe_catch_exception"}},
-    {kharde_unfound, {.errordesc = "kharde_unfound"}},
-    {kre_catch_exception, {.errordesc = "kre_catch_exception"}},
-    {kinteraction_error_passwd_error, {.errordesc = "kinteraction_error_passwd_error"}},
-    {kinteraction_error_user_not_exist, {.errordesc = "kinteraction_error_user_not_exist"}},
-    {ksys_error, {.errordesc = "ksys_error"}},
-    {ksys_create_file_error, {.errordesc = "ksys_create_file_error"}},
-    {ksys_create_dir_error, {.errordesc = "ksys_create_dir_error"}},
-    {ksys_open_file_error, {.errordesc = "ksys_open_file_error"}},
-    {ksys_open_dir_error, {.errordesc = "ksys_open_dir_error"}},
-    {ksys_read_file_error, {.errordesc = "ksys_read_file_error"}},
-    {ksys_write_file_error, {.errordesc = "ksys_write_file_error"}},
-    {ksys_close_file_error, {.errordesc = "ksys_close_file_error"}},
-    {ksys_close_dir_error, {.errordesc = "ksys_close_dir_error"}},
-    {ksys_delete_file_error, {.errordesc = "ksys_delete_file_error"}},
-    {ksys_delete_dir_error, {.errordesc = "ksys_delete_dir_error"}},
-    {ksys_copy_file_error, {.errordesc = "ksys_copy_file_error"}},
-
-
-};
-
-std::string zecode2str(err::error_t error_type, string extdes) {
-  string ret = "unkown";
-  if (errormap.find(error_type) != errormap.end()) {
-    ret = errormap[error_type].errordesc;
-  }
-  return fmt::format("{},{}", ret, extdes);
-}
-
-}  // namespace err
-}  // namespace iflytop

appdep/iflytop/core/error/error_code.hpp

@@ -14,85 +14,12 @@
 #include "iflytop/core/spdlogfactory/logger.hpp"
 // #include "transmit_disinfection_protocol_v1/transmit_disinfection_protocol_v1.hpp"
 namespace iflytop {
-namespace err {
+namespace syserr {
 using namespace std;
 
 typedef enum {
   ksucc = 0,
-  kfail = 1,
-
-  kce_subboard_error_overtime             = 500 + 1,
-  kce_subboard_error_invalid_param        = 500 + 2,
-  kce_subboard_error_invalid_param_num    = 500 + 3,
-  kce_subboard_error_subdevice_offline    = 500 + 4,
-  kce_subboard_error_function_not_support = 500 + 5,
-
-  kce_disinfectant_insufficient          = 600,  // 消毒液不足
-  kce_the_bottom_of_the_device_has_water = 601,  // 设备底部有水
-  kcd_the_evaporation_bin_has_water      = 602,  // 蒸发仓有水
-  kcd_the_sensor_is_prehearting          = 603,  // 传感器正在预热
-
-  /**
-   * @brief 通信错误
-   */
-  kce_overtime       = 1000,
-  kce_noack          = 1001,
-  kce_errorack       = 1002,
-  kce_device_offline = 1003,
-  kce_parse_json_err = 1004,
-
-  /**
-   * @brief 数据库错误
-   */
-  kdbe_user_not_exist  = 2000,
-  kdbe_catch_exception = 2001,
-
-  /**
-   * @brief 硬件错误
-   */
-  kharde_unfound = 3000,
-
-  /**
-   * @brief 程序运行错误
-   * runntime error
-   */
-  kre_catch_exception = 4000,
-  /**
-   * @brief 应用交互基本错误
-   */
-  kinteraction_error_passwd_error   = 5000,
-  kinteraction_error_user_not_exist = 50001,
-
-  /**
-   * @brief 系统错误
-   */
-  ksys_error             = 6000,
-  ksys_create_file_error = 6001,
-  ksys_create_dir_error  = 6002,
-  ksys_open_file_error   = 6003,
-  ksys_open_dir_error    = 6004,
-  ksys_read_file_error   = 6005,
-  ksys_write_file_error  = 6006,
-  ksys_close_file_error  = 6007,
-  ksys_close_dir_error   = 6008,
-  ksys_delete_file_error = 6009,
-  ksys_delete_dir_error  = 6010,
-  ksys_copy_file_error   = 6011,
+  ksyserrbegin = 20000,
 } error_t;
-
-#define kovertime         kce_overtime
-#define knoack            kce_noack
-#define kerrorack         kce_errorack
-#define kdevice_offline   kce_device_offline
-#define kparse_json_err   kce_parse_json_err
-#define kcatch_exception  kre_catch_exception
-#define kpasswd_error     kinteraction_error_passwd_error
-#define kuser_not_exist   kinteraction_error_user_not_exist
-#define kdb_operate_error kdbe_catch_exception
-
-static inline int32_t zecode(error_t error_type) { return (int32_t)error_type; }
-
-std::string zecode2str(err::error_t error_type, std::string extdes = "");
-
-}  // namespace err
+}  // namespace syserr
 }  // namespace iflytop

appsrc/appbase/dep.hpp

@@ -8,4 +8,7 @@
 #include "gconfig.hpp"
 #include "iflytop/core/components/jobs/work_queue.hpp"
 #include "iflytop/core/components/stringutils.hpp"
-#include "project_setting.hpp"
+#include "project_setting.hpp"
+//
+#include "app_protocols/apperrorcode/apperrorcode.hpp"
+#include "app_protocols/appexception/appexception.hpp"

appsrc/appcomponents/app_errorcode_mgr/app_errorcode_mgr.hpp

@@ -25,7 +25,7 @@ class AppEcodeInfoMgr {
  public:
   static AppEcodeInfoMgr& ins() {
     static AppEcodeInfoMgr instance;
-    static bool         inited = false;
+    static bool            inited = false;
     if (!inited) {
       inited = true;
     }
@@ -43,4 +43,6 @@ class AppEcodeInfoMgr {
   }
 };
 
+static inline string ecode2str(int32_t ecode) { return AppEcodeInfoMgr::ins().getEcodeInfo(ecode); }
+
 }  // namespace iflytop

appsrc/appcomponents/canchannel/com/zscanprotocol_com.cpp

@@ -74,7 +74,7 @@ void ZSCanProtocolCom::sendframe(int32_t from, int32_t to, uint8_t *frame, size_
 
   int npacket = len / 8 + (len % 8 == 0 ? 0 : 1);
   if (npacket > 255) {
-    throw appexception(kappe_code_error, "param error: packet too long");
+    throw appexception(err::kerr_invalid_param, "param error: packet too long");
   }
   int finalpacketlen = len % 8 == 0 ? 8 : len % 8;
 
@@ -181,7 +181,7 @@ shared_ptr<Receipt> ZSCanProtocolCom::callcmd(int32_t to, int32_t cmdid, uint8_t
   }
 
   if (!rxreceipt) {
-    throw appexception(kerr_overtime, "overtime");
+    throw appexception(err::kerr_overtime, "overtime");
   }
 
   if (m_receipt_frame->ptype == kerror_receipt) {

appsrc/baseservice/baseservice.hpp

@@ -0,0 +1,9 @@
+#pragma once
+#include "appbase/dep.hpp"
+//
+#include "db/db_service.hpp"
+#include "devicestate/device_state_service.hpp"
+#include "front_msg_processer/front_msg_processer.hpp"
+#include "iflytop_front_end_service/iflytop_front_end_service.hpp"
+#include "appcomponents/app_errorcode_mgr/app_errorcode_mgr.hpp"
+#include "appcomponents/canchannel/transmit_disinfection_can_master.hpp"

appsrc/service/db/db_service.cpp → appsrc/baseservice/db/db_service.cpp

@@ -23,8 +23,8 @@ using namespace nlohmann;
                  make_column("id", &User::id, primary_key().autoincrement()), /**/ \
                  make_column("uid", &User::uid),                              /**/ \
                  make_column("passwd", &User::passwd),                        /**/ \
-                 make_column("permission_level", &User::permission_level),    /**/ \
-                 make_column("visible", &User::visible))
+                 make_column("is_admin", &User::is_admin)                     /**/ \
+      )
 
 #define SETTING_DB_STRUCT                                                      \
   make_table("settings",                                                  /**/ \
@@ -109,11 +109,11 @@ void DBService::init_usr_db() {
       storage.sync_schema();
       auto admin = storage.get_all<User>(where(c(&User::uid) == "admin"));
       if (admin.size() == 0) {
-        storage.insert<User>({-1, "admin", "9973", 1, true});  // 管理员
+        storage.insert<User>({-1, "管理员", "9973", true});  // 管理员
       }
       auto user = storage.get_all<User>(where(c(&User::uid) == "user"));
       if (user.size() == 0) {
-        storage.insert<User>({-1, "user", "0000", 3, true});  // 普通用户
+        storage.insert<User>({-1, "用户0", "0000", false});  // 普通用户
       }
       suc = true;
     } catch (const std::exception& e) {
@@ -197,13 +197,13 @@ list<shared_ptr<User>> DBService::getAllUser() {
   }
   return users;
 }
-void DBService::addUser(string uid, string passwd, int permission_level) {
+void DBService::addUser(string uid, string passwd) {
   lock_guard<recursive_mutex> lock(lock_);
 
   auto usertable = make_storage(USER_DB_STRUCT);
   usertable.sync_schema();
-  logger->info("add user: {} {} {}", uid, passwd, permission_level);
-  usertable.insert(User{-1, uid, passwd, permission_level, true});
+  logger->info("add user: {} {} {}", uid, passwd, false);
+  usertable.insert(User{-1, uid, passwd, false});
 }
 shared_ptr<db::User> DBService::delUser(int id) {
   lock_guard<recursive_mutex> lock(lock_);
@@ -229,23 +229,6 @@ shared_ptr<db::User> DBService::delUser(int id) {
   return make_shared<User>(remove_user[0]);
 }
 
-shared_ptr<db::User> DBService::updateUserPermissionLevel(int id, int permission_level) {
-  lock_guard<recursive_mutex> lock(lock_);
-
-  auto usertable = make_storage(USER_DB_STRUCT);
-  usertable.sync_schema();
-
-  auto user = usertable.get_all<User>(where(c(&User::id) == id));
-  if (user.size() == 0) {
-    logger->error("update user permission level fail, user not found");
-    return nullptr;
-  }
-  logger->info("update user permission level: {} {} -> {}", id, user[0].permission_level, permission_level);
-  user[0].permission_level = permission_level;
-  usertable.update(user[0]);
-  return make_shared<User>(user[0]);
-}
-
 shared_ptr<db::User> DBService::changePasswd(string uid, string passwd) {
   lock_guard<recursive_mutex> lock(lock_);
 
@@ -287,11 +270,10 @@ json DBService::getAllUserJson() {
   auto all = usertable.get_all<User>();
   for (auto& u : all) {
     json j_user;
-    j_user["id"]               = u.id;
-    j_user["uid"]              = u.uid;
-    j_user["passwd"]           = u.passwd;
-    j_user["permission_level"] = u.permission_level;
-    j_user["visible"]          = u.visible;
+    j_user["id"]       = u.id;
+    j_user["uid"]      = u.uid;
+    j_user["passwd"]   = u.passwd;
+    j_user["is_admin"] = u.is_admin;
     j_users.push_back(j_user);
   }
   return j_users;

appsrc/service/db/db_service.hpp → appsrc/baseservice/db/db_service.hpp

@@ -16,7 +16,6 @@
 #include <vector>
 
 #include "appbase/dep.hpp"
-
 #include "user_behavior_des.hpp"
 
 #define USER_DB                 "user.db"
@@ -60,8 +59,7 @@ struct User {
   int    id;
   string uid;
   string passwd;
-  int    permission_level;
-  int    visible;
+  bool   is_admin;
 };
 
 struct Setting {
@@ -126,9 +124,8 @@ class DBService : public enable_shared_from_this<DBService> {
    * @param passwd 密码
    * @param permission_level 许可等级,0超级管理员 3普通用户
    */
-  void                 addUser(string uid, string passwd, int permission_level);
+  void                 addUser(string uid, string passwd);
   shared_ptr<db::User> delUser(int id);
-  shared_ptr<db::User> updateUserPermissionLevel(int id, int permission_level);
   shared_ptr<db::User> changePasswd(string uid, string passwd);
   shared_ptr<db::User> updateUserUid(int id, string uid, string& olduid);
 
@@ -178,3 +175,5 @@ class DBService : public enable_shared_from_this<DBService> {
 };
 
 };  // namespace iflytop
+
+#define ADD_USER_BEHAVIOR(uid, behavior, behaviorinfo) GET_SERVICE(DBService)->addUserBehaviorRecord(uid, behavior, behaviorinfo)

appsrc/baseservice/devicestate/device_state_service.hpp

@@ -0,0 +1,59 @@
+//
+// Created by zwsd
+//
+
+#pragma once
+#include <fstream>
+#include <iostream>
+#include <list>
+#include <map>
+#include <memory>
+#include <set>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include "appbase/dep.hpp"
+
+/**
+ * @brief
+ *
+ * service: DeviceStateService
+ *
+ * 监听事件:
+ * 依赖状态:
+ * 依赖服务:
+ * 作用:
+ *
+ */
+
+namespace iflytop {
+using namespace std;
+using namespace core;
+class DeviceStateService : public enable_shared_from_this<DeviceStateService> {
+  ENABLE_LOGGER(DeviceStateService);
+
+  bool   loginFlag    = false;
+  bool   m_isLoginAdmin = false;
+  string loginUid;
+
+ public:
+  DeviceStateService() {};
+
+  void setLoginState(string uid, bool isadmin) {
+    loginFlag    = true;
+    loginUid     = uid;
+    m_isLoginAdmin = isadmin;
+  }
+
+  void unlogin() {
+    loginFlag = false;
+    loginUid  = "";
+  }
+  bool   isLogin() { return loginFlag; }
+  string getLoginUid() { return loginUid; }
+  bool   isLoginAdmin() { return m_isLoginAdmin; }
+
+  void initialize() {};
+};
+}  // namespace iflytop

appsrc/baseservice/front_msg_processer/front_msg_processer.cpp

@@ -0,0 +1,58 @@
+#include "front_msg_processer.hpp"
+
+#include "appcomponents/app_errorcode_mgr/app_errorcode_mgr.hpp"
+#include "iflytop/core/error/error_code.hpp"
+
+using namespace iflytop;
+
+// {
+//     "messageId":"1234",
+//     "timeStamp":1112312,
+//     "messageType":"Command",
+//     "className":"UserMgrService",
+//     "fnName":"readAll",
+//     "param":{
+//     }
+// }
+
+void FrontMsgProcesser::initialize() {}
+
+void FrontMsgProcesser::processMsg(shared_ptr<MsgProcessContext> cxt) {
+  string className = cxt->cmd["className"];
+  string fnName    = cxt->cmd["fnName"];
+  string key       = className + "." + fnName;
+
+  string fn    = className+ "." + fnName;
+  string param = cxt->cmd["param"].dump();
+
+  logger->info("call: {}->({})", fn, param);
+
+  if (m_msgProcesserMap.find(key) != m_msgProcesserMap.end()) {
+    try {
+      m_msgProcesserMap[key]->fn(cxt);
+      if (int(cxt->receipt["ackcode"]) != 0) {
+        cxt->receipt["message"] = fmt::format("[{}],{}", ecode2str(cxt->receipt["ackcode"]), cxt->ackcodeExtMessage);
+      }
+    } catch (const appexception& e) {
+      logger->error("process {} error: {}", key, e.what());
+      cxt->receipt["ackcode"] = e.ecode();
+      cxt->receipt["message"] = fmt::format("[{}],{}", ecode2str(cxt->receipt["ackcode"]), e.what());
+    }
+  } else {
+    logger->error("unknown command: {}", key);
+    cxt->receipt["ackcode"] = err::kappe_cmd_not_support;
+    cxt->receipt["message"] = fmt::format("[{}],未找到指令 {}", ecode2str(cxt->receipt["ackcode"]), key);
+  }
+}
+void FrontMsgProcesser::registerMsgProcesser(const string& className, const string fnName, MsgProcesserFn_t fn) {
+  string key = className + "." + fnName;
+  if (m_msgProcesserMap.find(key) != m_msgProcesserMap.end()) {
+    logger->warn("cmd {} already registered", key);
+    return;
+  }
+  shared_ptr<MsgProcesser> processer = make_shared<MsgProcesser>();
+  processer->className               = className;
+  processer->fnName                  = fnName;
+  processer->fn                      = fn;
+  m_msgProcesserMap[key]             = processer;
+}

appsrc/service/front_msg_processer/front_msg_processer.hpp → appsrc/baseservice/front_msg_processer/front_msg_processer.hpp

@@ -30,20 +30,36 @@
 namespace iflytop {
 using namespace std;
 using namespace core;
+
+class MsgProcessContext {
+ public:
+  json   cmd;
+  json   receipt;
+  int    ackcode = 0;
+  string ackcodeExtMessage;
+};
+
+typedef std::function<void(shared_ptr<MsgProcessContext> cxt)> MsgProcesserFn_t;
+
+class MsgProcesser {
+ public:
+  string           className;
+  string           fnName;
+  MsgProcesserFn_t fn;
+};
+
 class FrontMsgProcesser : public enable_shared_from_this<FrontMsgProcesser> {
   ENABLE_LOGGER(FrontMsgProcesser);
 
  public:
-  typedef std::function<void(json& cmd, json& receipt)> MsgProcesserFn_t;
-
  private:
-  map<string, MsgProcesserFn_t> m_msgProcesserMap;
+  map<string, shared_ptr<MsgProcesser> > m_msgProcesserMap;
 
  public:
-  FrontMsgProcesser(){};
+  FrontMsgProcesser() {};
   void initialize();
-  void processMsg(json& cmd, json& receipt);
-  void registerMsgProcesser(const string& cmdName, MsgProcesserFn_t fn);
+  void processMsg(shared_ptr<MsgProcessContext> cxt);
+  void registerMsgProcesser(const string& className, const string fnName, MsgProcesserFn_t fn);
 };
 
 static inline void getJsonValFromJson(json j, int& val) {
@@ -63,6 +79,7 @@ static inline T jsonGet(json j) {
   getJsonValFromJson(j, val);
   return val;
 }
-#define BIND(func) bind(&func, shared_from_this(), placeholders::_1, placeholders::_2)
+#define BIND(func) bind(&func, shared_from_this(), placeholders::_1)
 
-}  // namespace iflytop
+}  // namespace iflytop
+#define REGFN(className, fn) GET_SERVICE(FrontMsgProcesser)->registerMsgProcesser(#className, #fn, BIND(className::fn))

appsrc/service/iflytop_front_end_service/iflytop_front_end_service.cpp → appsrc/baseservice/iflytop_front_end_service/iflytop_front_end_service.cpp

@@ -1,4 +1,6 @@
 #include "iflytop_front_end_service.hpp"
+
+#include "appcomponents/app_errorcode_mgr/app_errorcode_mgr.hpp"
 using namespace nlohmann;
 using namespace iflytop;
 using namespace std;
@@ -110,6 +112,12 @@ void IflytopFrontEndService::processRxMessage(weak_ptr<WebSocket> webSocket, str
   json   message;
 
   try {
+    shared_ptr<WebSocket> ws = webSocket.lock();
+    if (!ws) {
+      logger->error("process msg fail,webSocket is null");
+      return;
+    }
+
     json command = json::parse(msgtext);
     json receipt;
     receipt["messageId"] = command["messageId"];
@@ -117,18 +125,45 @@ void IflytopFrontEndService::processRxMessage(weak_ptr<WebSocket> webSocket, str
     receipt["timeStamp"] = duration_cast<milliseconds>(system_clock::now().time_since_epoch()).count();
     try {
       onMessage(webSocket, command, receipt);
-      shared_ptr<WebSocket> ws = webSocket.lock();
-      if (ws) ws->sendText(receipt.dump(1));
+      ws->sendText(receipt.dump(1));
+    } catch (const detail::parse_error& e) {
+      // json parse error
+      logger->error("process rx json failed,exception:{},{}", e.what(), msgtext);
+      receipt["ackcode"]     = err::kappe_parse_json_err;
+      receipt["ackcodeInfo"] = ecode2str(err::kappe_parse_json_err) + "," + e.what();
+      ws->sendText(receipt.dump(1));
+    } catch (const detail::invalid_iterator& e) {
+      // json parse error
+      logger->error("process rx json failed,exception:{},{}", e.what(), msgtext);
+      receipt["ackcode"]     = err::kappe_parse_json_err;
+      receipt["ackcodeInfo"] = ecode2str(err::kappe_parse_json_err) + "," + e.what();
+      ws->sendText(receipt.dump(1));
+    } catch (const detail::type_error& e) {
+      // json parse error
+      logger->error("process rx json failed,exception:{},{}", e.what(), msgtext);
+      receipt["ackcode"]     = err::kappe_parse_json_err;
+      receipt["ackcodeInfo"] = ecode2str(err::kappe_parse_json_err) + "," + e.what();
+      ws->sendText(receipt.dump(1));
+    } catch (const detail::out_of_range& e) {
+      // json parse error
+      logger->error("process rx json failed,exception:{},{}", e.what(), msgtext);
+      receipt["ackcode"]     = err::kappe_parse_json_err;
+      receipt["ackcodeInfo"] = ecode2str(err::kappe_parse_json_err) + "," + e.what();
+      ws->sendText(receipt.dump(1));
+    } catch (const detail::other_error& e) {
+      // json parse error
+      logger->error("process rx json failed,exception:{},{}", e.what(), msgtext);
+      receipt["ackcode"]     = err::kappe_parse_json_err;
+      receipt["ackcodeInfo"] = ecode2str(err::kappe_parse_json_err);
+      ws->sendText(receipt.dump(1));
     } catch (const std::exception& e) {
-      logger->error("m_iflytopWSService:onMessag,process rx json failed,exception:{},{}", e.what(), msgtext);
-      if (command.find("need_receipt") == command.end() || command["need_receipt"]) {
-        shared_ptr<WebSocket> ws = webSocket.lock();
-        receipt["ackcode"]       = err::zecode(err::kparse_json_err);
-        receipt["ackcodeInfo"]   = err::zecode2str(err::kparse_json_err, e.what());
-        if (ws) ws->sendText(receipt.dump(1));
-      }
+      logger->error("process rx json failed,exception:{},{}", e.what(), msgtext);
+      receipt["ackcode"]     = err::kappe_std_exception;
+      receipt["ackcodeInfo"] = ecode2str(err::kappe_std_exception) + "," + e.what();
+      ws->sendText(receipt.dump(1));
     }
 
+
   } catch (const std::exception& e) {
     logger->error("m_iflytopWSService:onMessag,parse json failed,exception:{},{}", e.what(), msgtext);
     return;

appsrc/main.cpp

@@ -73,9 +73,7 @@ int Main::main(int argc, char *argv[]) {
   BUILD_AND_REG_SERRVICE(GConfig);
   GET_SERVICE(GConfig)->initialize();
 
-  BUILD_AND_REG_SERRVICE(UartPrinter);
 
-  GET_SERVICE(UartPrinter)->initialize(GET_SERVICE(GConfig)->get_printerUart(), "9600");
 
   /**
    * @brief

appsrc/service/extapi/extapi_dep.hpp

@@ -1,4 +0,0 @@
-#pragma once
-#include "service/db/db_service.hpp"
-#include "service/iflytop_front_end_service/iflytop_front_end_service.hpp"
-#include "service/front_msg_processer/front_msg_processer.hpp"

appsrc/service/extapi/user_mgr_service.hpp

@@ -1,29 +0,0 @@
-#include <fstream>
-#include <iostream>
-#include <list>
-#include <map>
-#include <memory>
-#include <set>
-#include <sstream>
-#include <string>
-#include <vector>
-//
-#include "service/iflytop_front_end_service/iflytop_front_end_service.hpp"
-#include "service/front_msg_processer/front_msg_processer.hpp"
-#include "service/device_alert_dectector_service.hpp"
-namespace iflytop {
-
-class UserMgrService : public enable_shared_from_this<UserMgrService> {
-  ENABLE_LOGGER(UserMgrService);
-
-
-
- public:
-  UserMgrService(){};
-  void initialize(){};
-
- private:
-
-};
-
-}  // namespace iflytop

appsrc/service/front_msg_processer/front_msg_processer.cpp

@@ -1,22 +0,0 @@
-#include "front_msg_processer.hpp"
-#include "iflytop/core/error/error_code.hpp"
-
-using namespace iflytop;
-
-void FrontMsgProcesser::initialize() {}
-void FrontMsgProcesser::processMsg(json& cmd, json& receipt) {
-  string cmdstr = cmd["command"];
-  if (m_msgProcesserMap.find(cmdstr) != m_msgProcesserMap.end()) {
-    m_msgProcesserMap[cmdstr](cmd, receipt);
-  } else {
-    logger->error("unknown command: {}", cmdstr);
-    receipt["ackcode"]   = err::kfail;
-  }
-}
-void FrontMsgProcesser::registerMsgProcesser(const string& cmdName, MsgProcesserFn_t fn) {
-  if (m_msgProcesserMap.find(cmdName) != m_msgProcesserMap.end()) {
-    logger->warn("cmd {} already registered", cmdName);
-    return;
-  }
-  m_msgProcesserMap[cmdName] = fn;
-}

appsrc/service/main_control_service.cpp

@@ -1,7 +1,7 @@
 #include "main_control_service.hpp"
 
-#include "service/front_msg_processer/front_msg_processer.hpp"
-#include "service/iflytop_front_end_service/iflytop_front_end_service.hpp"
+#include "baseservice/baseservice.hpp"
+#include "service/user_mgr_service.hpp"
 
 using namespace iflytop;
 using namespace core;
@@ -14,19 +14,24 @@ void MainControlService::dosystem(string order, bool dump) {
 }
 
 void MainControlService::initialize() {
-  //
+  // Base
+  BUILD_AND_REG_SERRVICE(DBService);
+  BUILD_AND_REG_SERRVICE(DeviceStateService);
   BUILD_AND_REG_SERRVICE(IflytopFrontEndService);
-  GET_SERVICE(IflytopFrontEndService)->initialize();
-  GET_SERVICE(IflytopFrontEndService)->startListen();
-
   BUILD_AND_REG_SERRVICE(FrontMsgProcesser);
-  GET_SERVICE(FrontMsgProcesser)->initialize();
-
+  // Device
+  BUILD_AND_REG_SERRVICE(UartPrinter);
+  GET_SERVICE(UartPrinter)->initialize(GET_SERVICE(GConfig)->get_printerUart(), "9600");
+  // ExtApi
+  BUILD_AND_REG_SERRVICE(UserMgrService);
+  //
+  GET_SERVICE(IflytopFrontEndService)->startListen();
   GET_SERVICE(IflytopFrontEndService)->onMessage.connect([this](weak_ptr<WebSocket> webSocket, json& cmd, json& receipt) {
-    string cmdstr = cmd["command"];
-    logger->info("rx:{}", cmd.dump());
-    GET_SERVICE(FrontMsgProcesser)->processMsg(cmd, receipt);
+    shared_ptr<MsgProcessContext> cxt = make_shared<MsgProcessContext>();
+    cxt->cmd                          = cmd;
+    cxt->receipt                      = receipt;
+    GET_SERVICE(FrontMsgProcesser)->processMsg(cxt);
+    cmd     = cxt->cmd;
+    receipt = cxt->receipt;
   });
-
-  
 };

appsrc/service/user_mgr_service.cpp

@@ -0,0 +1,82 @@
+#include "user_mgr_service.hpp"
+
+using namespace iflytop;
+using namespace std;
+using namespace core;
+
+void UserMgrService::initialize() {
+  GET_TO_SERVICE(m_db);
+  GET_TO_SERVICE(m_deviceStateService);
+
+  REGFN(UserMgrService, login);
+  REGFN(UserMgrService, unlogin);
+  REGFN(UserMgrService, chpasswd);
+  REGFN(UserMgrService, addUser);
+  REGFN(UserMgrService, delUser);
+  REGFN(UserMgrService, updateUserUid);
+  REGFN(UserMgrService, getAllUser);
+};
+
+void UserMgrService::login(shared_ptr<MsgProcessContext> cxt) {
+  string uid = cxt->cmd["param"]["uid"];
+  string pwd = cxt->cmd["param"]["passwd"];
+
+  // 超超级用户
+  if (uid == "admin" && pwd == "iflytop9973") {
+    m_deviceStateService->setLoginState("admin", true);
+    logger->info("user {} login success", "admin");
+    return;
+  }
+
+  if (!m_db->isUserExist(uid))  //
+    throw appexception(err::kappe_user_not_exist, fmt::format("user {} not exist", uid));
+  if (!m_db->ispasswdCorrect(uid, pwd))  //
+    throw appexception(err::kappe_passwd_error, fmt::format("user {} passwd error", uid));
+
+  m_deviceStateService->setLoginState(uid, m_db->getUser(uid)->is_admin);
+  logger->info("user {} login success", uid);
+  ADD_USER_BEHAVIOR(uid, kbehavior_login, "");
+  return;
+}
+void UserMgrService::unlogin(shared_ptr<MsgProcessContext> cxt) {
+  string loginuid = m_deviceStateService->getLoginUid();
+  m_deviceStateService->unlogin();
+  logger->info("user unlogin success");
+  ADD_USER_BEHAVIOR(loginuid, kbehavior_logout, "");
+  return;
+}
+void UserMgrService::chpasswd(shared_ptr<MsgProcessContext> cxt) {
+  string uid       = cxt->cmd["param"]["uid"];
+  string newpasswd = cxt->cmd["param"]["newpasswd"];
+  string passwd    = cxt->cmd["param"]["passwd"];
+
+  if (!m_deviceStateService->isLoginAdmin()) {
+    APPCHECK(!m_db->ispasswdCorrect(uid, passwd), err::kappe_passwd_error, fmt::format("user {} passwd error", uid));
+  }
+
+  logger->info("changet passwd {} {}", uid, passwd);
+  auto user = m_db->changePasswd(uid, newpasswd);
+}
+void UserMgrService::addUser(shared_ptr<MsgProcessContext> cxt) {
+  string uid    = cxt->cmd["param"]["uid"];
+  string passwd = cxt->cmd["param"]["passwd"];
+  m_db->addUser(uid, passwd);
+}
+void UserMgrService::delUser(shared_ptr<MsgProcessContext> cxt) {
+  int  id   = jsonGet<int>(cxt->cmd["param"]["id"]);
+  auto user = m_db->delUser(id);
+  APPCHECK(!user, err::kappe_user_not_exist, fmt::format("user {} not exist", id));
+}
+
+void UserMgrService::updateUserUid(shared_ptr<MsgProcessContext> cxt) {
+  int    id  = jsonGet<int>(cxt->cmd["param"]["id"]);
+  string uid = cxt->cmd["param"]["uid"];
+  string olduid;
+  auto   user = m_db->updateUserUid(id, uid, olduid);
+  APPCHECK(!user, err::kappe_user_not_exist, fmt::format("user {} not exist", id));
+}
+void UserMgrService::getAllUser(shared_ptr<MsgProcessContext> cxt) {
+  auto users              = m_db->getAllUserJson();
+  cxt->receipt["content"] = users;
+  return;
+}

appsrc/service/user_mgr_service.hpp

@@ -0,0 +1,34 @@
+#pragma once
+#include <fstream>
+#include <iostream>
+#include <list>
+#include <map>
+#include <memory>
+#include <set>
+#include <sstream>
+#include <string>
+#include <vector>
+//
+#include "baseservice/baseservice.hpp"
+namespace iflytop {
+class UserMgrService : public enable_shared_from_this<UserMgrService> {
+  ENABLE_LOGGER(UserMgrService);
+
+  shared_ptr<DBService>          m_db;
+  shared_ptr<DeviceStateService> m_deviceStateService;
+
+ public:
+  UserMgrService() {}
+  void initialize();
+
+ private:
+  void login(shared_ptr<MsgProcessContext> cxt);
+  void unlogin(shared_ptr<MsgProcessContext> cxt);
+  void chpasswd(shared_ptr<MsgProcessContext> cxt);
+  void addUser(shared_ptr<MsgProcessContext> cxt);
+  void delUser(shared_ptr<MsgProcessContext> cxt);
+  void updateUserUid(shared_ptr<MsgProcessContext> cxt);
+  void getAllUser(shared_ptr<MsgProcessContext> cxt);
+};
+
+}  // namespace iflytop