update error code

src/iflytop/components/iflytop_front_end_service/iflytop_front_end_service.cpp

@@ -150,8 +150,8 @@ void IflytopFrontEndService::processRxMessage(weak_ptr<WebSocket> webSocket, con
       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::error_code_get_get_ecode(err::kce, err::kparse_json_err);
-        receipt["ackcodeInfo"]   = err::error_code_get_desc(err::kce, err::kparse_json_err, e.what());
+        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));
       }

src/iflytop/core/error/error_code.cpp

@@ -5,42 +5,34 @@ namespace err {
 
 using namespace std;
 
-// static set<error_code_desc_t> ecode_desc_set = {
-//     {kce, kovertime, "overtime"},
-//     {kce, kdevice_offline, "kdevice_offline"},
-//     {kce, kpasswd_error, "kpasswd_error"},
-// };
+typedef struct {
+  string errordesc;
+} error_desc_t;
 
-// kovertime
-// kdevice_offline
-// kparse_json_err
-// kcatch_exception
-// kpasswd_error
-// kuser_not_exist
-static vector<error_code_desc_t> ecode_desc_set = {
-    {kce, kovertime, "overtime"},
-    {kce, kfail, "fail"},
-    {kce, knoack, "noack"},
-    {kce, kerrorack, "errorack"},
-    {kce, kdevice_offline, "kdevice_offline"},
-    {kce, kparse_json_err, "kparse_json_err"},
-    {kce, kcatch_exception, "kcatch_exception"},
-    {kce, kpasswd_error, "kpasswd_error"},
-    {kce, kuser_not_exist, "kuser_not_exist"},
-    {kce, kdb_operate_error, "kuser_not_exist"},
+static map<error_t, error_desc_t> errormap = {
+    // {kovertime, {.errordesc = "overtime"}},
+    {kfail, {.errordesc = "fail"}},
+    {kce_overtime, {.errordesc = "overtime"}},
+    {kce_noack, {.errordesc = "noack"}},
+    {kce_errorack, {.errordesc = "errorack"}},
+    {kce_device_offline, {.errordesc = "device_offline"}},
+    {kce_parse_json_err, {.errordesc = "parse_json_err"}},
+    {kdbe_user_not_exist, {.errordesc = "user_not_exist"}},
+    {kdbe_catch_exception, {.errordesc = "catch_exception"}},
+    {kharde_unfound, {.errordesc = "unfound"}},
+    {kre_catch_exception, {.errordesc = "catch_exception"}},
+    {kinteraction_error_passwd_error, {.errordesc = "passwd_error"}},
+    {kinteraction_error_user_not_exist, {.errordesc = "user_not_exist"}}
 
 };
 
-int32_t error_code_get_get_ecode(error_type_t error_type, int sub_error_code) {  //
-  return error_type * 1000 + sub_error_code;
-}
-string error_code_get_desc(error_type_t error_type, int sub_error_code, string extdes) {  //
-  for (auto& ecode_desc : ecode_desc_set) {
-    if (ecode_desc.error_type == error_type && ecode_desc.sub_error_code == sub_error_code) {
-      return fmt::format("{},{}", ecode_desc.desc, extdes);
-    }
+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("unkown_e({}-{}),{}", (int)error_type, sub_error_code, extdes);
+  return fmt::format("{},{}", ret, extdes);
 }
+
 }  // namespace err
 }  // namespace iflytop

src/iflytop/core/error/error_code.hpp

@@ -13,44 +13,59 @@
 #include "iflytop/core/basic/nod/nod.hpp"
 #include "iflytop/core/spdlogfactory/logger.hpp"
 namespace iflytop {
-
 namespace err {
 using namespace std;
-typedef enum {
-  kovertime = 1,
-  kfail,
-  knoack,
-  kerrorack,
-  kdevice_offline,
-  kparse_json_err,
-  kcatch_exception,
-  kpasswd_error,
-  kuser_not_exist,
-  kdb_operate_error,
-} common_error_code_t;
 
 typedef enum {
-  kce = 1,  // common error code
-} error_type_t;
-
-class error_code_desc_t {
- public:
-  error_type_t error_type;
-  int          sub_error_code;
-  string       desc;
-};
-
-int32_t               error_code_get_get_ecode(error_type_t error_type, int sub_error_code);
-static inline int32_t zecode(error_type_t error_type, int sub_error_code) { return error_code_get_get_ecode(error_type, sub_error_code); }
-static inline int32_t zecode(common_error_code_t sub_error_code) { return error_code_get_get_ecode(kce, sub_error_code); }
-
-string               error_code_get_desc(error_type_t error_type, int sub_error_code, string extdes);
-static inline string zecode_desc(int32_t ecode, string extdes) {
-  error_type_t error_type     = (error_type_t)(ecode / 1000);
-  int          sub_error_code = ecode % 1000;
-  return error_code_get_desc(error_type, sub_error_code, extdes);
-}
+  kfail = 1,
 
-}  // namespace err
+  /**
+   * @brief 通信错误
+   */
+  kce_overtime = 1000,
+  kce_noack,
+  kce_errorack,
+  kce_device_offline,
+  kce_parse_json_err,
+
+  /**
+   * @brief 数据库错误
+   */
+  kdbe_user_not_exist = 2000,
+  kdbe_catch_exception,
+
+  /**
+   * @brief 硬件错误
+   */
+  kharde_unfound = 3000,
+
+  /**
+   * @brief 程序运行错误
+   * runntime error
+   */
+  kre_catch_exception = 4000,
 
+  /**
+   * @brief 应用交互基本错误
+   */
+  kinteraction_error_passwd_error = 5000,
+  kinteraction_error_user_not_exist,
+
+} 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 iflytop