//
|
// Created by ps on 8/9/18.
|
//
|
|
#ifndef UNTITLED_SYNCDB_HPP
|
#define UNTITLED_SYNCDB_HPP
|
|
#include <iostream>
|
#include <map>
|
#include <basic/debug/Debug.h>
|
|
namespace SyncDB {
|
|
// Value-Defintions of the different String values
|
enum Feature_InfoStringValue {
|
evNotDefined,
|
id,
|
feature,
|
create_by,
|
create_time,
|
update_time,
|
img,
|
idcard,
|
enable,
|
monLevel,
|
evEnd
|
};
|
|
// Map to associate the strings with the enum values
|
typedef std::map<std::string, Feature_InfoStringValue> Map_Fea_InfoString2Values;
|
static Map_Fea_InfoString2Values map_Fea_InfoString2Values;
|
|
static void Initialize() {
|
map_Fea_InfoString2Values["id"] = Feature_InfoStringValue::id;
|
map_Fea_InfoString2Values["feature"] = Feature_InfoStringValue::feature;
|
map_Fea_InfoString2Values["create_by"] = Feature_InfoStringValue::create_by;
|
map_Fea_InfoString2Values["create_time"] = Feature_InfoStringValue::create_time;
|
map_Fea_InfoString2Values["update_time"] = Feature_InfoStringValue::update_time;
|
map_Fea_InfoString2Values["img"] = Feature_InfoStringValue::img;
|
map_Fea_InfoString2Values["idcard"] = Feature_InfoStringValue::idcard;
|
map_Fea_InfoString2Values["enable"] = Feature_InfoStringValue::enable;
|
map_Fea_InfoString2Values["monitorLevel"] = Feature_InfoStringValue::monLevel;
|
map_Fea_InfoString2Values["end"] = evEnd;
|
}
|
|
// Intialization
|
static bool ret = (Initialize(), true);
|
|
struct Feature_Info {
|
public:
|
Feature_Info() {
|
// Initialize();
|
}
|
|
// ~Feature_Info() {
|
// for (auto &item:map_Fea_InfoString2Values) {
|
// map_Fea_InfoString2Values.erase(item.first);
|
// }
|
// }
|
|
bool setValue(std::string key, std::string value) {
|
try {
|
switch (map_Fea_InfoString2Values[key]) {
|
case Feature_InfoStringValue::evNotDefined:
|
//#todo error info
|
return false;
|
case Feature_InfoStringValue::id:
|
id = value;
|
break;
|
case Feature_InfoStringValue::feature:
|
feature = value;
|
break;
|
case Feature_InfoStringValue::create_by:
|
create_by = value;
|
break;
|
case Feature_InfoStringValue::create_time:
|
create_time = value;
|
break;
|
case Feature_InfoStringValue::update_time:
|
update_time = value;
|
break;
|
case Feature_InfoStringValue::img:
|
img = value;
|
break;
|
case Feature_InfoStringValue::idcard:
|
idcard = value;
|
break;
|
case Feature_InfoStringValue::enable:
|
enable = value;
|
break;
|
case Feature_InfoStringValue::monLevel:
|
monLevel = value;
|
break;
|
default:
|
ERR(key << " is an invalid string. s_mapStringValues now contains "
|
<< map_Fea_InfoString2Values.size() << " entries.");
|
return false;
|
}
|
return true;
|
} catch (std::exception ex) {
|
return false;
|
}
|
}
|
|
public:
|
|
public:
|
std::string id;
|
std::string feature;
|
std::string create_by;
|
std::string create_time;
|
std::string update_time;
|
std::string img;
|
std::string idcard;
|
std::string enable;
|
std::string monLevel;
|
|
|
// value is a atom: atomSize:19, atomValue:test@192.168.50.216
|
// value is a list:2018-08-08 20:17:11
|
// value is a atom: atomSize:36, atomValue:ce386825-76f4-42bc-a0e1-cd9484cb7a8c
|
// value is a list:6eda59e2-d884-5ffb-89d9-84dcffda2ad6
|
// value is a list:2018-08-08 20:17:11
|
|
private:
|
};
|
|
//----------------------------------------------------------------------------
|
//----------------------------------------------------------------------------
|
//---------------------------DEVICE_INFO--------------------------------------
|
//----------------------------------------------------------------------------
|
|
// key:create_by string :za@192.168.50.216
|
// key:create_time string :2018-08-12 16:56:08
|
// key:del_flag bool :0
|
// key:dev_address string :DevAddress
|
// key:device_name string :
|
// key:father_node string :
|
// key:node_id string :za@192.168.50.216
|
// key:node_online bool: 1
|
// key:update_time string :2018-08-12 16:56:08
|
// key:uuid string :19633f6f-acd9-5482-a0c8-74a44a576edf
|
// Value-Defintions of the different String values
|
enum Device_InfoStringValue {
|
dev_evNotDefined,
|
dev_create_by,
|
dev_create_time,
|
dev_del_flag,
|
dev_cluster_id,
|
dev_cluster_name,
|
dev_device_id,
|
dev_node_id,
|
dev_node_online,
|
dev_update_time,
|
dev_uuid,
|
dev_evEnd
|
};
|
|
// Map to associate the strings with the enum values
|
typedef std::map<std::string, Device_InfoStringValue> Map_Dev_InfoString2Values;
|
|
static Map_Dev_InfoString2Values map_Dev_InfoString2Values;
|
|
static void DevInitialize() {
|
//#todo
|
map_Dev_InfoString2Values["create_by"] = Device_InfoStringValue::dev_create_by;
|
map_Dev_InfoString2Values["create_time"] = Device_InfoStringValue::dev_create_time;
|
map_Dev_InfoString2Values["del_flag"] = Device_InfoStringValue::dev_del_flag;
|
map_Dev_InfoString2Values["cluster_id"] = Device_InfoStringValue::dev_cluster_id;
|
map_Dev_InfoString2Values["cluster_name"] = Device_InfoStringValue::dev_cluster_name;
|
map_Dev_InfoString2Values["device_id"] = Device_InfoStringValue::dev_device_id;
|
map_Dev_InfoString2Values["node_id"] = Device_InfoStringValue::dev_node_id;
|
map_Dev_InfoString2Values["update_time"] = Device_InfoStringValue::dev_update_time;
|
map_Dev_InfoString2Values["uuid"] = Device_InfoStringValue::dev_uuid;
|
map_Dev_InfoString2Values["end"] = Device_InfoStringValue::dev_evEnd;
|
}
|
|
// Intialization
|
static bool devRet = (DevInitialize(), true);
|
|
struct Device_Info {
|
public:
|
Device_Info() :
|
create_by(""), create_time(""), del_flag(""), device_id(""), cluster_id(""), cluster_name(""), node_id(""),
|
update_time(""),
|
uuid("") {
|
// Initialize();
|
}
|
|
~Device_Info() {
|
// for (auto &item:map_Fea_InfoString2Values) {
|
// map_Fea_InfoString2Values.erase(item.first);
|
// }
|
}
|
|
bool setValue(std::string key, std::string value) {
|
try {
|
//#todo
|
int type = map_Dev_InfoString2Values[key];
|
switch (type) {
|
case Device_InfoStringValue::dev_evNotDefined:
|
//#todo error info
|
return false;
|
case Device_InfoStringValue::dev_create_by:
|
create_by = value;
|
break;
|
case Device_InfoStringValue::dev_create_time:
|
create_time = value;
|
break;
|
case Device_InfoStringValue::dev_del_flag:
|
del_flag = value;
|
break;
|
case Device_InfoStringValue::dev_cluster_id:
|
cluster_id = value;
|
break;
|
case Device_InfoStringValue::dev_cluster_name:
|
cluster_name = value;
|
break;
|
case Device_InfoStringValue::dev_device_id:
|
device_id = value;
|
break;
|
case Device_InfoStringValue::dev_node_id:
|
node_id = value;
|
break;
|
case Device_InfoStringValue::dev_update_time:
|
update_time = value;
|
break;
|
case Device_InfoStringValue::dev_uuid:
|
uuid = value;
|
break;
|
default:
|
ERR(key << " is an invalid string. s_mapStringValues now contains "
|
<< map_Fea_InfoString2Values.size() << " entries.");
|
return false;
|
}
|
return true;
|
} catch (std::exception ex) {
|
return false;
|
}
|
}
|
|
public:
|
|
public:
|
std::string create_by;
|
std::string create_time;
|
std::string del_flag;
|
std::string device_id;
|
std::string cluster_id;
|
std::string cluster_name;
|
std::string node_id;
|
std::string update_time;
|
std::string uuid;
|
|
private:
|
};
|
|
|
//----------------------------------------------------------------------------
|
//----------------------------------------------------------------------------
|
//---------------------------Table_INFO--------------------------------------
|
//----------------------------------------------------------------------------
|
|
|
//{"create_by",'za@192.168.50.216'},
|
//{"create_time","2018-08-13 10:14:39"},
|
//{"del_flag","0"},
|
//{"tableDesc",test},
|
//{"tableName",aaa1},
|
//{"tableType",person},
|
//{"update_time","2018-08-13 10:14:39"},
|
//{"uuid","b1c19f77-623b-5294-9b65-9a766af1f77d"}
|
// Value-Defintions of the different String values
|
enum Table_InfoStringValue {
|
tab_evNotDefined,
|
tab_create_by,
|
tab_create_time,
|
tab_del_flag,
|
tab_tableDesc,
|
tab_tableName,
|
tab_tableType,
|
tab_bwType,
|
tab_update_time,
|
tab_uuid,
|
tab_startTime,
|
tab_endTime,
|
tab_uploadFlag,
|
tab_cmpThreshold,
|
tab_enabled,
|
tab_evEnd
|
};
|
|
// Map to associate the strings with the enum values
|
typedef std::map<std::string, Table_InfoStringValue> Map_Tab_InfoString2Values;
|
static Map_Tab_InfoString2Values map_Tab_InfoString2Values;
|
|
static void TabInitialize() {
|
map_Tab_InfoString2Values["create_by"] = Table_InfoStringValue::tab_create_by;
|
map_Tab_InfoString2Values["create_time"] = Table_InfoStringValue::tab_create_time;
|
map_Tab_InfoString2Values["del_flag"] = Table_InfoStringValue::tab_del_flag;
|
map_Tab_InfoString2Values["tableDesc"] = Table_InfoStringValue::tab_tableDesc;
|
map_Tab_InfoString2Values["tableName"] = Table_InfoStringValue::tab_tableName;
|
map_Tab_InfoString2Values["tableType"] = Table_InfoStringValue::tab_tableType;
|
map_Tab_InfoString2Values["bwType"] = Table_InfoStringValue::tab_bwType;
|
map_Tab_InfoString2Values["update_time"] = Table_InfoStringValue::tab_update_time;
|
map_Tab_InfoString2Values["uuid"] = Table_InfoStringValue::tab_uuid;
|
map_Tab_InfoString2Values["startTime"] = Table_InfoStringValue::tab_startTime;
|
map_Tab_InfoString2Values["endTime"] = Table_InfoStringValue::tab_endTime;
|
map_Tab_InfoString2Values["uploadFlag"] = Table_InfoStringValue::tab_uploadFlag;
|
map_Tab_InfoString2Values["cmpThreshold"] = Table_InfoStringValue::tab_cmpThreshold;
|
map_Tab_InfoString2Values["enabled"] = Table_InfoStringValue::tab_enabled;
|
map_Tab_InfoString2Values["end"] = Table_InfoStringValue::tab_evEnd;
|
}
|
|
// Intialization
|
static bool tabRet = (TabInitialize(), true);
|
|
struct Table_Info {
|
public:
|
Table_Info() :
|
create_by(""), create_time(""), del_flag(""), tableDesc(""), tableName(""), tableType(""), update_time(""),
|
uuid(""), bwType(""), startTime(""), endTime(""), uploadFlag(""), cmpThreshold(""), enabled("") {
|
// Initialize();
|
}
|
|
~Table_Info() {
|
// for (auto &item:map_Fea_InfoString2Values) {
|
// map_Fea_InfoString2Values.erase(item.first);
|
// }
|
}
|
|
bool setValue(std::string key, std::string value) {
|
try {
|
//#todo
|
int type = map_Tab_InfoString2Values[key];
|
switch (type) {
|
case Table_InfoStringValue::tab_evNotDefined:
|
//#todo error info
|
return false;
|
case Table_InfoStringValue::tab_create_by:
|
create_by = value;
|
break;
|
case Table_InfoStringValue::tab_create_time:
|
create_time = value;
|
break;
|
case Table_InfoStringValue::tab_del_flag:
|
del_flag = value;
|
break;
|
case Table_InfoStringValue::tab_tableDesc:
|
tableDesc = value;
|
break;
|
case Table_InfoStringValue::tab_tableName:
|
tableName = value;
|
break;
|
case Table_InfoStringValue::tab_tableType:
|
tableType = value;
|
break;
|
case Table_InfoStringValue::tab_bwType:
|
bwType = value;
|
break;
|
case Table_InfoStringValue::tab_uuid:
|
uuid = value;
|
break;
|
case Table_InfoStringValue::tab_update_time:
|
update_time = value;
|
break;
|
case Table_InfoStringValue::tab_startTime:
|
startTime = value;
|
break;
|
case Table_InfoStringValue::tab_endTime:
|
endTime = value;
|
break;
|
case Table_InfoStringValue::tab_uploadFlag:
|
uploadFlag = value;
|
break;
|
case Table_InfoStringValue::tab_cmpThreshold:
|
cmpThreshold = value;
|
break;
|
case Table_InfoStringValue::tab_enabled:
|
enabled = value;
|
break;
|
default:
|
ERR(key << " is an invalid string. s_mapStringValues now contains "
|
<< map_Fea_InfoString2Values.size() << " entries.");
|
return false;
|
}
|
return true;
|
} catch (std::exception ex) {
|
return false;
|
}
|
}
|
|
public:
|
|
public:
|
std::string create_by;
|
std::string create_time;
|
std::string del_flag;
|
std::string tableDesc;
|
std::string tableName;
|
std::string tableType;
|
std::string update_time;
|
std::string uuid;
|
std::string bwType;
|
std::string startTime;
|
std::string endTime;
|
std::string uploadFlag;
|
std::string cmpThreshold;
|
std::string enabled;
|
|
private:
|
};
|
|
|
//----------------------------------------------------------------------------
|
//----------------------------------------------------------------------------
|
//---------------------------Bw_INFO--------------------------------------
|
//----------------------------------------------------------------------------
|
|
|
//{"bwType",'0'},
|
//{"create_by",'za@192.168.50.216'},
|
//{"create_time","2018-08-13 10:14:39"},
|
//{"tableName",aaa1},
|
//{"update_time","2018-08-13 10:14:39"},
|
//{"uuid","e0eb30e9-f595-5651-8895-6f07f3851fcf"}
|
// Value-Defintions of the different String values
|
enum Bw_InfoStringValue {
|
bw_evNotDefined,
|
bw_bwType,
|
bw_create_by,
|
bw_create_time,
|
bw_tableName,
|
bw_update_time,
|
bw_uuid,
|
bw_evEnd
|
};
|
|
// Map to associate the strings with the enum values
|
typedef std::map<std::string, Bw_InfoStringValue> Map_Bw_InfoString2Values;
|
static Map_Bw_InfoString2Values map_Bw_InfoString2Values;
|
|
static void BwInitialize() {
|
map_Bw_InfoString2Values["bwType"] = bw_bwType;
|
map_Bw_InfoString2Values["create_by"] = bw_create_by;
|
map_Bw_InfoString2Values["create_time"] = bw_create_time;
|
map_Bw_InfoString2Values["tableName"] = bw_tableName;
|
map_Bw_InfoString2Values["update_time"] = bw_update_time;
|
map_Bw_InfoString2Values["uuid"] = bw_uuid;
|
map_Bw_InfoString2Values["end"] = bw_evEnd;
|
}
|
|
// Intialization
|
static bool bwRet = (BwInitialize(), true);
|
|
struct Bw_Info {
|
public:
|
Bw_Info() :
|
bwType(""), create_by(""), create_time(""), tableName(""), update_time(""),
|
uuid("") {
|
// Initialize();
|
}
|
|
~Bw_Info() {
|
// for (auto &item:map_Fea_InfoString2Values) {
|
// map_Fea_InfoString2Values.erase(item.first);
|
// }
|
}
|
|
bool setValue(std::string key, std::string value) {
|
try {
|
//#todo
|
int type = map_Bw_InfoString2Values[key];
|
switch (type) {
|
case bw_evNotDefined:
|
//#todo error info
|
return false;
|
case bw_bwType:
|
bwType = value;
|
break;
|
case bw_create_by:
|
create_by = value;
|
break;
|
case bw_create_time:
|
create_time = value;
|
break;
|
case bw_tableName:
|
tableName = value;
|
break;
|
case bw_uuid:
|
uuid = value;
|
break;
|
case bw_update_time:
|
update_time = value;
|
break;
|
default:
|
ERR(key << " is an invalid string. s_mapStringValues now contains "
|
<< map_Fea_InfoString2Values.size() << " entries.");
|
return false;
|
}
|
return true;
|
} catch (std::exception ex) {
|
return false;
|
}
|
}
|
|
public:
|
|
public:
|
std::string create_by;
|
std::string create_time;
|
std::string bwType;
|
std::string tableName;
|
std::string update_time;
|
std::string uuid;
|
|
private:
|
};
|
|
|
struct AddPersonInfo {
|
std::string personid;
|
std::string idcard;
|
std::string personPic;
|
std::string feature;
|
};
|
|
enum AddPersRetStringValue {
|
ap_evNotDefined,
|
ap_PersonId,
|
ap_Result,
|
ap_msg,
|
ap_evEnd
|
};
|
|
// Map to associate the strings with the enum values
|
typedef std::map<std::string, AddPersRetStringValue> Map_AddPersRetString2Values;
|
static Map_AddPersRetString2Values map_AddPersRetString2Values;
|
|
static void AddRetInitialize() {
|
map_AddPersRetString2Values["PersonId"] = ap_PersonId;
|
map_AddPersRetString2Values["Result"] = ap_Result;
|
map_AddPersRetString2Values["msg"] = ap_msg;
|
map_AddPersRetString2Values["end"] = ap_evEnd;
|
}
|
|
// Intialization
|
static bool addPerRet = (AddRetInitialize(), true);
|
|
struct AddPersRet {
|
public:
|
AddPersRet() :
|
PersonId(""), Result(""), msg("") {
|
// Initialize();
|
}
|
|
~AddPersRet() {
|
}
|
|
bool setValue(std::string key, std::string value) {
|
try {
|
//#todo
|
int type = map_AddPersRetString2Values[key];
|
switch (type) {
|
case ap_evNotDefined:
|
//#todo error info
|
return false;
|
case ap_PersonId:
|
PersonId = value;
|
break;
|
case ap_Result:
|
Result = value;
|
break;
|
case ap_msg:
|
msg = value;
|
break;
|
default:
|
ERR(key << " is an invalid string. s_mapStringValues now contains "
|
<< map_AddPersRetString2Values.size() << " entries.");
|
return false;
|
}
|
return true;
|
} catch (std::exception ex) {
|
return false;
|
}
|
}
|
|
public:
|
|
public:
|
std::string PersonId;
|
std::string Result;
|
std::string msg;
|
|
private:
|
};
|
|
|
enum PerExistRetStringValue {
|
pe_evNotDefined,
|
pe_tableName,
|
pe_tableUuid,
|
pe_uuid,
|
pe_evEnd
|
};
|
|
// Map to associate the strings with the enum values
|
typedef std::map<std::string, PerExistRetStringValue> Map_PerExistRetString2Values;
|
static Map_PerExistRetString2Values map_PerExistRetString2Values;
|
|
static void PerExistRetInitialize() {
|
map_PerExistRetString2Values["tableName"] = pe_tableName;
|
map_PerExistRetString2Values["tableUuid"] = pe_tableUuid;
|
map_PerExistRetString2Values["uuid"] = pe_uuid;
|
map_PerExistRetString2Values["end"] = pe_evEnd;
|
}
|
|
// Intialization
|
static bool perExistsRet = (PerExistRetInitialize(), true);
|
|
struct PerExistRet {
|
public:
|
PerExistRet() :
|
tableName(""), uuid(""), tableUuid("") {
|
// Initialize();
|
}
|
|
~PerExistRet() {
|
}
|
|
bool setValue(std::string key, std::string value) {
|
try {
|
//#todo
|
int type = map_PerExistRetString2Values[key];
|
switch (type) {
|
case pe_evNotDefined:
|
//#todo error info
|
return false;
|
case pe_tableName:
|
tableName = value;
|
break;
|
case pe_tableUuid:
|
tableUuid = value;
|
break;
|
case pe_uuid:
|
uuid = value;
|
break;
|
default:
|
ERR(key << " is an invalid string. s_mapStringValues now contains "
|
<< map_PerExistRetString2Values.size() << " entries.");
|
return false;
|
}
|
return true;
|
} catch (std::exception ex) {
|
return false;
|
}
|
}
|
|
public:
|
|
public:
|
std::string tableName;
|
std::string tableUuid;
|
std::string uuid;
|
|
private:
|
};
|
|
|
enum UpdPersRetStringValue {
|
up_evNotDefined,
|
up_tableName,
|
up_tableUuid,
|
up_result,
|
up_oldId,
|
up_evEnd
|
};
|
|
// Map to associate the strings with the enum values
|
typedef std::map<std::string, UpdPersRetStringValue> Map_UpdPersRetStringValue;
|
static Map_UpdPersRetStringValue map_UpdPersRetStringValue;
|
|
static void UpdPersRetInitialize() {
|
map_UpdPersRetStringValue["tableName"] = up_tableName;
|
map_UpdPersRetStringValue["tableUuid"] = up_tableUuid;
|
map_UpdPersRetStringValue["result"] = up_result;
|
map_UpdPersRetStringValue["oldId"] = up_oldId;
|
map_UpdPersRetStringValue["end"] = up_evEnd;
|
}
|
|
// Intialization
|
static bool updPerRet = (UpdPersRetInitialize(), true);
|
|
struct UpdPersRet {
|
public:
|
UpdPersRet() :
|
tableName(""), result(""), oldId(""), tableUuid("") {
|
// Initialize();
|
}
|
|
~UpdPersRet() {
|
}
|
|
bool setValue(std::string key, std::string value) {
|
try {
|
//#todo
|
int type = map_UpdPersRetStringValue[key];
|
switch (type) {
|
case up_evNotDefined:
|
//#todo error info
|
return false;
|
case up_tableName:
|
tableName = value;
|
break;
|
case up_tableUuid:
|
tableUuid = value;
|
break;
|
case up_result:
|
result = value;
|
break;
|
case up_oldId:
|
oldId = value;
|
break;
|
default:
|
ERR(key << " is an invalid string. s_mapStringValues now contains "
|
<< map_UpdPersRetStringValue.size() << " entries.");
|
return false;
|
}
|
return true;
|
} catch (std::exception ex) {
|
return false;
|
}
|
}
|
|
public:
|
|
public:
|
std::string tableName;
|
std::string tableUuid;
|
std::string result;
|
std::string oldId;
|
|
private:
|
};
|
|
|
}
|
|
#endif //UNTITLED_SYNCDB_HPP
|
