布控相关接口，表结构变更。

pansen

2019-01-24 0380d646c7338ac25bfbbbaf49ce9e2745eff57f

布控相关接口，表结构变更。

 QiaoJiaSystem/DataManagerServer/http_configserver.cpp

@@ -395,7 +395,7 @@
    /*sdk login*/
    ulRet = IMOS_MW_Login(username, passwd, ip, 0, szUserID);
    if (ERR_COMMON_SUCCEED != ulRet) {
         (VOID) IMOS_MW_Cleanup();
        (VOID) IMOS_MW_Cleanup();
        printf("Login error ulRet[%lu]", ulRet);
        return false;
    }
@@ -1000,8 +1000,10 @@
    std::string out = value.size() > 0 ? value.toStyledString() : "[]";
    return out;
}

#define ADD_CAMERA 0
#define EDIT_CAMERA 1

//编辑摄像机
std::string devHttpServer_c::cam_edit(std::string ip, unsigned int port, std::string content, PResponse &response) {
    DBG("ip:" << ip << "; port:" << port);
@@ -1013,7 +1015,7 @@
    Record_Cam_Dev rec;
    Record_Cam_Sdk rec_sdk_old;
    Record_Cam_Sdk rec_sdk;
    int type=-1;
    int type = -1;
    int dev_type = db_c.searchDevTypeFromConfigTable();
    if (DEV_STORAGE == dev_type) {
        return "{\"ret_status\": \"内容有误，请检查！\"}";
@@ -1039,45 +1041,34 @@
        rec.str_username = QString::fromStdString(value["str_username"].asString());
        rec.str_password = QString::fromStdString(value["str_password"].asString());
        rec.str_brand = QString::fromStdString(value["str_brand"].asString());
        type=value["n_type"].asInt();
        type = value["n_type"].asInt();
//        rec_sdk_old = db_c.searchCamSdkTableByCamId(rec.str_cam_dev_id);

//        rec_sdk.str_cam_dev_id = rec.str_cam_dev_id;
//        rec_sdk.str_sdks = QString::fromStdString(value["str_sdks"].asString());
//        rec_sdk.str_det_thr = QString::fromStdString(value["str_det_thr"].asString());
//        rec_sdk.str_cmp_thr = QString::fromStdString(value["str_cmp_thr"].asString());
        bool is_exist=db_c.searchCamDevByCamId(rec.str_cam_dev_id);
        if(ADD_CAMERA == type )
        {
           if(is_exist)
           {
               return "{\"ret_status\": \"请勿重复添加!\"}";
           }
           else
           {
               ret =db_c.insertCamDevTable(rec);
               if (!ret) {
                   return "err_db_content";
               }
           }
        }
        else if(EDIT_CAMERA == type )
        {
            if(is_exist)
            {
                ret = db_c.updateCamDevTable(rec);
        bool is_exist = db_c.searchCamDevByCamId(rec.str_cam_dev_id);
        if (ADD_CAMERA == type) {
            if (is_exist) {
                return "{\"ret_status\": \"请勿重复添加!\"}";
            } else {
                ret = db_c.insertCamDevTable(rec);
                if (!ret) {
                    return "err_db_content";
                }
            }
            else
            {
                 return "{\"ret_status\": \"内容有误，请检查！\"}";
        } else if (EDIT_CAMERA == type) {
            if (is_exist) {
                ret = db_c.updateCamDevTable(rec);
                if (!ret) {
                    return "err_db_content";
                }
            } else {
                return "{\"ret_status\": \"内容有误，请检查！\"}";
            }
        }
        else
        {
             return "{\"ret_status\": \"内容有误，请检查！\"}";
        } else {
            return "{\"ret_status\": \"内容有误，请检查！\"}";
        }


@@ -1089,7 +1080,7 @@
        db_c.updateConfigTableByDevType(DEV_CAMERA);
        runAllApp();
    }
    //edit camera's sdks
        //edit camera's sdks
    else/* if ((rec_sdk_old.str_sdks != rec_sdk.str_sdks) ||
             (rec_sdk_old.str_det_thr != rec_sdk.str_det_thr) ||
             (rec_sdk_old.str_cmp_thr != rec_sdk.str_cmp_thr)) */
@@ -1863,30 +1854,51 @@
//    bool ret = false;

    if (reader.parse(content, value)) {
        std::string Uuid = value["uuid"].asString();
        std::string TableType = value["TableType"].asString();
        std::string TableName = value["TableName"].asString();
        int SyncType = atoi(value["SyncType"].asCString());
        std::string BwType = value["BwType"].asString();
        std::string StartTime = value["StartTime"].asString();
        std::string EndTime = value["EndTime"].asString();

        std::string UploadFlag = value["IsSync"].asString();
        std::string CmpThreshold = value["threshold"].asString();
        std::string Enabled = value["enabled"].asString();
        bool ret = false;
        if (SyncType == 1) {
            //同步库
            ret = erlangDbTool->createDatabase(TableType, TableName, SyncType, BwType, StartTime, EndTime);
        } else if (SyncType == 0) {
            TableName.insert(0, "lt_");
            //本地库
            FieldValues fieldValues;
            fieldValues.insert(std::make_pair("uuid", GetUUId::getUUID()));
            fieldValues.insert(std::make_pair("tableName", TableName));
            fieldValues.insert(std::make_pair("tableDesc", "ceshi"));
            fieldValues.insert(std::make_pair("tableType", TableType));
            fieldValues.insert(std::make_pair("bwType", BwType));
            fieldValues.insert(std::make_pair("startTime", StartTime));
            fieldValues.insert(std::make_pair("endTime", EndTime));
            fieldValues.insert(std::make_pair("create_by", "who"));
            ret = m_SqliteFaceEncap.createTable(TableName, fieldValues);
        FieldValues fieldValues;
        fieldValues.insert(std::make_pair("uuid", Uuid));
        fieldValues.insert(std::make_pair("tableName", TableName));
        fieldValues.insert(std::make_pair("tableDesc", "ceshi"));
        fieldValues.insert(std::make_pair("tableType", TableType));
        fieldValues.insert(std::make_pair("bwType", BwType));
        fieldValues.insert(std::make_pair("startTime", StartTime));
        fieldValues.insert(std::make_pair("endTime", EndTime));
        fieldValues.insert(std::make_pair("create_by", "who"));

        fieldValues.insert(std::make_pair("uploadFlag", UploadFlag));
        fieldValues.insert(std::make_pair("cmpThreshold", CmpThreshold));
        fieldValues.insert(std::make_pair("enabled", Enabled));


        if (TableType == "person") {
            if (SyncType == 1) {
                //同步库
                ret = erlangDbTool->createDatabase(Uuid, fieldValues);
            } else if (SyncType == 0) {
                TableName.insert(0, "lt_");
                //本地库
                ret = m_SqliteFaceEncap.createTable(TableName, fieldValues);
            }
        } else if (TableType == "car") {
            ERR(" not not_implemented");
            response->write(SimpleWeb::StatusCode::server_error_not_implemented, "{\"error\":\"类型错误，未实现！ \"}");
            return "";
        } else {
            response->write(SimpleWeb::StatusCode::server_error_not_implemented, "{\"error\":\"类型错误，未识别！ \"}");
            return "";
        }


        erlangDbTool->sendMessage();
        std::string str_result = std::string("{\"result\":").append("\"" + std::to_string(ret) + "\"}");
@@ -1899,6 +1911,7 @@
    }
}

//#todo
std::string devHttpServer_c::deleteDatabase(std::string ip, unsigned int port, std::string content,
                                            PResponse &response) {
    DBG("ip:" << ip << "; port:" << port);
@@ -1920,16 +1933,26 @@
        int SyncType = atoi(value["SyncType"].asCString());

        bool ret = false;
        if (SyncType == 1) {
            //同步库
            ret = erlangDbTool->deleteDatabase(TableType, TableName, SyncType);
        } else if (SyncType == 0) {
            //本地库
            if (TableName.find("lt_") != 0) {
                TableName.insert(0, "lt_");
        if (TableType == "person") {
            if (SyncType == 1) {
                //同步库
                ret = erlangDbTool->deleteDatabase(uuid);
            } else if (SyncType == 0) {
                //本地库
                if (TableName.find("lt_") != 0) {
                    TableName.insert(0, "lt_");
                }
                ret = m_SqliteFaceEncap.deleteTable(TableName);
            }
            ret = m_SqliteFaceEncap.deleteTable(TableName);
        } else if (TableType == "car") {
            ERR(" not not_implemented");
            response->write(SimpleWeb::StatusCode::server_error_not_implemented, "{\"error\":\"类型错误，未实现！ \"}");
            return "";
        } else {
            response->write(SimpleWeb::StatusCode::server_error_not_implemented, "{\"error\":\"类型错误，未识别！ \"}");
            return "";
        }

        erlangDbTool->sendMessage();
        std::string str_result = std::string("{\"result\":").append("\"" + std::to_string(ret) + "\"}");
        return str_result;
@@ -1969,6 +1992,10 @@
            //#todo modify
            subJson.append("\"start_time\":\"" + item.second.startTime + "\",");
            subJson.append("\"end_time\":\"" + item.second.endTime + "\"");

            subJson.append("\"IsSync\":\"" + item.second.uploadFlag + "\"");
            subJson.append("\"threshold\":\"" + item.second.cmpThreshold + "\"");
            subJson.append("\"enabled\":\"" + item.second.enabled + "\"");
            subJson.append("},");
            json.append(subJson);
        }
@@ -2011,6 +2038,9 @@
            subJson.append("\"bwType\":\"" + item.bwType + "\",");
            subJson.append("\"start_time\":\"" + item.startTime + "\",");
            subJson.append("\"end_time\":\"" + item.endTime + "\"");
            subJson.append("\"IsSync\":\"" + item.uploadFlag + "\"");
            subJson.append("\"threshold\":\"" + item.cmpThreshold + "\"");
            subJson.append("\"enabled\":\"" + item.enabled + "\"");
            subJson.append("},");
            json.append(subJson);
        }
@@ -2048,34 +2078,15 @@
        std::string img_base64 = value["img_base64"].asString();
        std::string idcard = value["idcard"].asString();
        std::string strUUID = value["uuid"].asString();
//        if (strUUID.size() > 0) {
//            bool ret_addPerson = false;
//            if (TableName.find("lt_") == 0) {
//                FieldValues fieldValues;
//                AddFaceData addFaceData;
//                //#todo update table
//                addFaceData.uuid = strUUID;
//                addFaceData.faceUrl = img_url;
//
//                fieldValues.insert(std::make_pair("uuid", strUUID));
//                fieldValues.insert(std::make_pair("idCard", idcard));
//                m_SqliteFaceEncap.updateFace(TableName, addFaceData, fieldValues);
//            } else {
//                ret_addPerson = erlangDbTool->addPerson(strUUID, TableName, feature_base64, img_url, idcard);
//            }
//        }
        std::string UploadFlag = value["IsSync"].asString();

        cv::Mat image;
        if (img_url.size() > 0) {

            if (img_url.find("ManCarAnaly") != string::npos && img_url.find("group") != string::npos) {
                auto pos = img_url.find("group");
                auto img_tmp = img_url.substr(pos);
                std::string img_str = "http://";
                if (fdfsClient.fastFds != nullptr) {
                    img_str.append(fdfsClient.fastFds->getIp() + "/").append(img_tmp);
                    img_url.swap(img_str);
                }
            std::string img_str = "http://";
            if (fdfsClient.fastFds != nullptr) {
                img_str.append(fdfsClient.fastFds->getIp() + "/").append(img_url);
                img_url.swap(img_str);
            }

            auto t_results = m_curlDownloadImg.download_jpeg(const_cast<char *>(img_url.c_str()));
@@ -2119,8 +2130,6 @@

        for (auto &item : faceResults) {
            feature_base64 = base64.Encode(item.feature.data(), item.feature.size());


            int x = item.left;
            int y = item.top;
            int w = item.width;
@@ -2144,6 +2153,7 @@
                }
            }
            fdfsClient.rwLock.unlock();
            break;
        }
        auto size = feature_base64.size();
//        std::string uuid = "";
@@ -2190,37 +2200,12 @@
//            usleep(100);
            erlangDbTool->sendMessage();
            //todo send person to backServer
            HttpRequestWithCrul m_requestWithCrul;

            std::thread sendPerson([&](std::string parm_uuid, std::string parm_img_url, std::string parm_idcard,
                                       std::string parm_fea) {
                Json::Value perInfos;
                Json::Value perInfo;
//                #todo get string from config.json file
//                 get
                perInfo["id"] = parm_uuid;
                perInfo["distributionIds"] = m_cluster_id;
                perInfo["distributionNames"] = m_cluster_name;
                auto rec = db_c.searchConfigTableWithinServerInfo();
                perInfo["deviceId"] = rec.dev_id.toStdString();
                perInfo["photos"] = parm_img_url;
//                perInfo["featureBase"] = feature_base64;
                perInfo["featureBase64"] = parm_fea;
                perInfo["cardId"] = parm_idcard;
                perInfos.append(perInfo);

                std::string str_serIp = GET_STR_CONFIG("mainServerIp");
                std::string str_serPort = GET_STR_CONFIG("mainServerPort");

//                string sendUrl = "192.168.1.203:3697/addPerson/uploadToTemporary";
                string sendUrl = str_serIp;
                sendUrl.append(":").append(str_serPort).append("/addPerson/uploadToTemporary");
                string postParams = perInfos.toStyledString();
                string str_addRes;

                m_requestWithCrul.curl_post_req(sendUrl, postParams, str_addRes);
            }, strUUID, img_url, idcard, feature_base64);
            sendPerson.detach();
            if (UploadFlag == "1") {
//                #todo db queue upload to server
                std::thread sendPerson(uploadPersonToServer, this, strUUID, img_url, idcard, feature_base64);
                sendPerson.detach();
            }

            return str_result;
        } else {
@@ -2332,28 +2317,47 @@
        std::string BwType = value["BwType"].asString();
        std::string StartTime = value["StartTime"].asString();
        std::string EndTime = value["EndTime"].asString();
//        #todo new filed
        std::string UploadFlag = value["IsSync"].asString();
        std::string CmpThreshold = value["threshold"].asString();
        std::string Enabled = value["enabled"].asString();

        bool ret = false;
        if (SyncType == 1) {
            //同步库
            ret = erlangDbTool->updateDatabase(Uuid, TableType, TableName, SyncType, BwType, StartTime, EndTime);
        } else if (SyncType == 0) {
            //本地库
            //#更新底库管理表
            FieldValues fieldValues;
            fieldValues.insert(std::make_pair("uuid", Uuid));
            if (TableName.find("lt_") != 0) {
                TableName.insert(0, "lt_");
            }
            fieldValues.insert(std::make_pair("tableName", TableName));
//            fieldValues.insert(std::make_pair("tableDesc", "ceshi2"));
            fieldValues.insert(std::make_pair("tableType", TableType));
            fieldValues.insert(std::make_pair("bwType", BwType));
            fieldValues.insert(std::make_pair("startTime", StartTime));
            fieldValues.insert(std::make_pair("endTime", EndTime));
//            fieldValues.insert(std::make_pair("create_by", "who"));
            ret = m_SqliteFaceEncap.updateTable("sys_o_tables", fieldValues);
        //#更新底库管理表
        FieldValues fieldValues;
        fieldValues.insert(std::make_pair("uuid", Uuid));
        if (TableName.find("lt_") != 0) {
            TableName.insert(0, "lt_");
        }
        fieldValues.insert(std::make_pair("tableName", TableName));
//            fieldValues.insert(std::make_pair("tableDesc", "ceshi2"));
        fieldValues.insert(std::make_pair("tableType", TableType));
        fieldValues.insert(std::make_pair("bwType", BwType));
        fieldValues.insert(std::make_pair("startTime", StartTime));
        fieldValues.insert(std::make_pair("endTime", EndTime));
//            fieldValues.insert(std::make_pair("create_by", "who"));

        fieldValues.insert(std::make_pair("uploadFlag", UploadFlag));
        fieldValues.insert(std::make_pair("cmpThreshold", CmpThreshold));
        fieldValues.insert(std::make_pair("enabled", Enabled));

        if (TableType == "person") {
            if (SyncType == 1) {
                //同步库
                ret = erlangDbTool->updateDatabase("sys_o_tables", fieldValues);
            } else if (SyncType == 0) {
                //本地库
                ret = m_SqliteFaceEncap.updateTable("sys_o_tables", fieldValues);
            }
        } else if (TableType == "car") {
            ERR(" not not_implemented");
            response->write(SimpleWeb::StatusCode::server_error_not_implemented, "{\"error\":\"类型错误，未实现！ \"}");
            return "";
        } else {
            response->write(SimpleWeb::StatusCode::server_error_not_implemented, "{\"error\":\"类型错误，未识别！ \"}");
            return "";
        }


        erlangDbTool->sendMessage();
        std::string str_result = std::string("{\"result\":").append("\"" + std::to_string(ret) + "\"}");
@@ -3046,8 +3050,7 @@
        std::string pass = value["str_password"].asString();
        std::string brand = value["str_brand"].asString();
        std::string rtsp_url = rtspAddrBuild(ip, port, username, pass, brand);
        if (rtsp_url.empty() )
        {
        if (rtsp_url.empty()) {
            return "{\"ret_status\":\"内容有误，请检查！\"}";
        }
//        unsigned char serialnumber[SERIALNO_LEN] = {0};
@@ -3065,8 +3068,8 @@
        if (str_imgName.back() != '/') {
            str_imgName.push_back('/');
        }
        str_imgName +=ip;
        str_imgName +="-";
        str_imgName += ip;
        str_imgName += "-";
        str_imgName += "snapshot.jpg";
        //admin:a1234567@192.168.1.201:554/h264/ch1/main/av_stream -r 1/25 -f image2 -s 1920*1080 /home/basic/work_src/a.jpg
        std::string cmd("ffmpeg -i " + rtsp_url + " -r 1/25  -f image2 -s 1920*1080 -y " + str_imgName);
@@ -3102,3 +3105,34 @@
    }
}

void devHttpServer_c::uploadPersonToServer(devHttpServer_c *t_ptrThis, std::string parm_uuid, std::string parm_img_url,
                                           std::string parm_idcard,
                                           std::string parm_fea) {
    HttpRequestWithCrul m_requestWithCrul;
    Json::Value perInfos;
    Json::Value perInfo;
//                #todo get string from config.json file
//                 get
    perInfo["id"] = parm_uuid;
    perInfo["distributionIds"] = t_ptrThis->m_cluster_id;
    perInfo["distributionNames"] = t_ptrThis->m_cluster_name;
    auto rec = t_ptrThis->db_c.searchConfigTableWithinServerInfo();
    perInfo["deviceId"] = rec.dev_id.toStdString();
    perInfo["photos"] = parm_img_url;
//                perInfo["featureBase"] = feature_base64;
    perInfo["featureBase64"] = parm_fea;
    perInfo["cardId"] = parm_idcard;//图片描述
    perInfos.append(perInfo);

    std::string str_serIp = GET_STR_CONFIG("mainServerIp");
    std::string str_serPort = GET_STR_CONFIG("mainServerPort");

//                string sendUrl = "192.168.1.203:3697/addPerson/uploadToTemporary";
    string sendUrl = str_serIp;
    sendUrl.append(":").append(str_serPort).append("/addPerson/uploadToTemporary");
    string postParams = perInfos.toStyledString();
    string str_addRes;

    m_requestWithCrul.curl_post_req(sendUrl, postParams, str_addRes);
}


 QiaoJiaSystem/DataManagerServer/http_configserver.h

@@ -182,6 +182,9 @@
    std::vector<std::string> forEachFile(const std::string &dir_name);

    qint64 getVideoTime(/*const std::string& videoPath*/std::string &str_tmpTime);

    static void uploadPersonToServer(devHttpServer_c *t_ptrThis, std::string parm_uuid, std::string parm_img_url,
                                     std::string parm_idcard, std::string parm_fea);
};

#endif

 QiaoJiaSystem/DataManagerServer/web-server½Ó¿Ú.txt

@@ -1,3 +1,13 @@
/***
 * DataWebServer接口文档
 *
 * 2019.01.23 æ–°å¢župdatePerson接口，修改createDatabase，updateDatabase，deleteDatabase接口
 *
 *
 *
 ***/


标准返回值：
{"ret_status": "内容有误，请检查！"}：内容错误
{"ret_status": "传输错误，请检查！"}：json格式错误

 QiaoJiaSystem/LocalDBTool/SqliteFaceEncap.cpp

@@ -370,6 +370,9 @@
            tableInfo.bwType = query.value(3).toString().toStdString();
            tableInfo.startTime = query.value(4).toString().toStdString();
            tableInfo.endTime = query.value(5).toString().toStdString();
            tableInfo.uploadFlag = query.value(6).toString().toStdString();
            tableInfo.cmpThreshold = query.value(7).toString().toStdString();
            tableInfo.enabled = query.value(8).toString().toStdString();
            tableInfos.push_back(tableInfo);
        }
    }

 QiaoJiaSystem/LocalDBTool/SqliteToolkit.hpp

@@ -49,6 +49,10 @@
    std::string startTime;
    std::string endTime;
    std::string createBy;

    std::string uploadFlag;
    std::string cmpThreshold;
    std::string enabled;
};
typedef std::vector<TableInfo> TableInfos;
typedef std::map<std::string, TableInfo> TableInfosCache;
@@ -103,8 +107,9 @@

    std::string getTableInfosSql() {
        //uuid,tableName,tableDesc,tableType,bwType,startTime,endTime
        std::string sql = "select uuid,tableName,tableType,bwType,startTime,endTime from " + g_tableName +
                          " where del_flag = 0";
        std::string sql =
            "select uuid,tableName,tableType,bwType,startTime,endTime,uploadFlag,cmpThreshold,enabled from " +
            g_tableName + " where del_flag = 0";
        return sql;
    }

@@ -205,7 +210,10 @@
        sql.append(" create_time BLOB default (datetime('now', 'localtime')),");
        sql.append(" update_time varchar(255) DEFAULT NULL,");
        sql.append(" create_by   varchar(255) DEFAULT NULL,");
        sql.append(" del_flag    varchar(255) DEFAULT 0");
        sql.append(" del_flag    varchar(255) DEFAULT 0,");
        sql.append(" uploadFlag  varchar(255) DEFAULT 0,");
        sql.append(" cmpThreshold    varchar(255) DEFAULT 60,");
        sql.append(" enabled     varchar(255) DEFAULT 1");
        sql.append(");");
        return sql;
    }

 QiaoJiaSystem/build/DataWebServer

Binary files differ

 syncDBTool/ErlangDbTool.cpp

@@ -639,6 +639,14 @@
    return false;
}

bool ErlangTool::ErlangDbTool::createDatabase(std::string t_tableName, FieldValues &fieldValues) {
//    #todo è®°å¾—测试中文
    std::string strSql = getCreateFaceTableSql(t_tableName);
    strSql.append(getInsertSql("sys_o_tables", fieldValues));
    getExecSqlResult(strSql);
}


bool ErlangTool::ErlangDbTool::updateDatabase(std::string UUID, std::string TableType, std::string TableName,
                                              bool SyncType, std::string BwType, std::string StartTime,
                                              std::string EndTime) {
@@ -722,6 +730,86 @@
    return false;
}

bool ErlangTool::ErlangDbTool::updateDatabase(std::string t_tableName, FieldValues &fieldValues) {
    //    #todo è®°å¾—测试中文
    std::string strSql = getUpdateFaceTableSql(t_tableName, fieldValues);
    return getExecSqlResult(strSql);

}

bool ErlangTool::ErlangDbTool::getExecSqlResult(const std::string &strSql) {
    ErlangTool::LockG lock(m_mutex);
//            m_mutex.lock();
    m_ret = resetConn();
    if (!m_ret) {
        //#todo error message
        std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " error " << this->m_ret << "  " << this->m_fd
                  << std::endl;
        return false;
    }

    ErlMessage emsg;             /* Incoming message */
    int ret = -1;
    ETERM *arrlist[7];
    arrlist[0] = erl_mk_atom(strSql.c_str());
    ETERM *list = erl_mk_list(arrlist, 1);

    ret = erl_rpc_to(m_fd, "syncDB", "exeSomeSql", list);
    if (ret == ERL_TICK) {
        ret = erl_rpc_from(m_fd, TIMEOUT, &emsg);
        //erl_close_connection(m_fd);
//                m_mutex.unlock();
        if (ret == ERL_MSG) {
            std::map<std::__cxx11::string, std::__cxx11::string> t_results;

            ETERM *tail_list;
            ETERM *list_ret[1000], *arr_ret[2];
            ETERM *key, *value;
            ETERM *tuplep[6];

            arr_ret[0] = erl_element(2, emsg.msg);
            int erlLength = erl_length(arr_ret[0]);
            printf("arr_ret[0]:%d\n", erlLength);
            list_ret[0] = erl_hd(arr_ret[0]);
            tail_list = erl_tl(arr_ret[0]);
            for (int i = 0; i < erlLength; i++) {
                if (i > 0) {
                    list_ret[i] = erl_hd(tail_list);
                    tail_list = erl_tl(tail_list);
                }
//                    printf("list_ret[%d]:%d\n", i, erl_length(list_ret[i]));
                tuplep[0] = erl_hd(list_ret[i]);
                key = erl_element(1, list_ret[i]);
                value = erl_element(2, list_ret[i]);
//                    printf("key:%s\n", ERL_ATOM_PTR(key));

                switch (ErlangTool::checkETERMType(value)) {
                    case ERL_ATOM: {
//                            int atomSize = ERL_ATOM_SIZE(value);
                        char *atomValue = ERL_ATOM_PTR(value);
//                            printf("value is a atom: atomSize:%d, atomValue:%s \n\r", atomSize, atomValue);
                        t_results.insert(std::make_pair(ERL_ATOM_PTR(key), atomValue));
                        break;
                    }
                    default:
                        printf("error add case todo \n\r");
                }
                ErlangTool::erlangFreeEterm(4, key, value, tuplep[0], list_ret[i]);
            }
            ErlangTool::erlangFreeEterm(2, tail_list, arr_ret[0]);
            erl_eterm_release();
            auto it = t_results.find("atomic");
            if (t_results.size() > 0 && t_results.end() != it && it->second == "ok") {
                return true;
            }
        }
    }
    erl_free_array(arrlist, 1);
//            erlangFreeEterm(4, emsg.to, emsg.msg, emsg.from, list);
    erl_eterm_release();
    return false;
}

bool ErlangTool::ErlangDbTool::deleteDatabase(std::string TableType, std::string TableName, bool SyncType) {
    LockG lock(m_mutex);
//            m_mutex.lock();
@@ -791,6 +879,19 @@
    erl_free_array(arrlist, 2);
    erlangFreeEterm(4, emsg.to, emsg.msg, emsg.from, list);
    return false;
}


bool ErlangTool::ErlangDbTool::deleteDatabase(std::string t_tableName) {

    FieldValues fieldValues;
    fieldValues.insert(std::make_pair("uuid", t_tableName));
    fieldValues.insert(std::make_pair("del_flag", "1"));
    std::string strSql = getUpdateFaceTableSql("sys_o_tables", fieldValues);
    strSql.append("DROP TABLE '" + t_tableName + "';DROP TABLE '" + t_tableName + "_fea';");
    //    #todo è®°å¾—测试中文
    return getExecSqlResult(strSql);

}

// å’Œerlang交互
@@ -894,7 +995,7 @@
    map_TabDataCache tabDataCache;

    QString sql = QString::fromStdString(
        "SELECT  uuid,tableName,tableType,bwType,startTime,endTime FROM sys_o_tables where del_flag=0;");
        "SELECT  uuid,tableName,tableType,bwType,startTime,endTime,uploadFlag,cmpThreshold,enabled FROM sys_o_tables where del_flag=0;");
    QSqlQuery query(g_syncDbFile);
    query.prepare(sql);
    if (!query.exec()) {
@@ -908,6 +1009,9 @@
            t_table_info.bwType = query.value(3).toString().toStdString();
            t_table_info.startTime = query.value(4).toString().toStdString();
            t_table_info.endTime = query.value(5).toString().toStdString();
            t_table_info.uploadFlag = query.value(6).toString().toStdString();
            t_table_info.cmpThreshold = query.value(7).toString().toStdString();
            t_table_info.enabled = query.value(8).toString().toStdString();

            tabDataCache.insert(std::make_pair(t_table_info.uuid, t_table_info));
        }

 syncDBTool/ErlangDbTool.h

@@ -21,6 +21,7 @@
#include <stdarg.h>
#include <jsoncpp/json/json.h>
#include <arpa/inet.h>
#include <SqliteToolkit.hpp>

#include "erl_interface.h"
#include "ei.h"
@@ -135,6 +136,8 @@
    private:
        void initCNode();

        bool getExecSqlResult(const std::string &strSql);

    public:
        //#todo setCNodeName

@@ -189,10 +192,27 @@
         * @param TableName
         * @param SyncType true 1||false 0
         * @param BwType   "Black"1||"White"0
         * @param StartTime
         * @param EndTime
         * @return åˆ›å»ºçŠ¶æ€
         */
        bool createDatabase(std::string TableType, std::string TableName, bool SyncType, std::string BwType,
                            std::string StartTime = "", std::string EndTime = "");

        /***
         * åˆ›å»ºåº•åº“表
         * @param TableType TableType car||person
         * @param TableName
         * @param SyncType  true 1||false 0
         * @param BwType    "Black"1||"White"0
         * @param UploadFlag æ˜¯å¦ä¸Šä¼ 
         * @param CmpThreshold å¯¹æ¯”阈值
         * @param Enabled æ˜¯å¦å¯ç”¨
         * @param StartTime
         * @param EndTime
         * @return
         */
        bool createDatabase(std::string t_tableName, FieldValues &fieldValues);

        /***
         * æ›´æ–°åº•åº“表
@@ -205,6 +225,8 @@
        bool updateDatabase(std::string UUID, std::string TableType, std::string TableName, bool SyncType,
                            std::string BwType, std::string StartTime = "", std::string EndTime = "");

        bool updateDatabase(std::string t_tableName, FieldValues &fieldValues);

        /***
         * åˆ é™¤æ•°æ®è¡¨
         * @param TableType car||person
@@ -214,6 +236,8 @@
         */
        bool deleteDatabase(std::string TableType, std::string TableName, bool SyncType);

        bool deleteDatabase(std::string t_tableName);

        /***
         * æŸ¥è¯¢æ‰€æœ‰æ•°æ®è¡¨
         * @return

 syncDBTool/SyncDB.hpp

@@ -271,6 +271,9 @@
        tab_uuid,
        tab_startTime,
        tab_endTime,
        tab_uploadFlag,
        tab_cmpThreshold,
        tab_enabled,
        tab_evEnd
    };

@@ -290,6 +293,9 @@
        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;
    }

@@ -299,8 +305,8 @@
    struct Table_Info {
    public:
        Table_Info() :
            create_by(""), create_time(""), del_flag(""), tableDesc(""), tableName(""), tableType(""),
            update_time(""), uuid(""), bwType(""), startTime(""), endTime("") {
            create_by(""), create_time(""), del_flag(""), tableDesc(""), tableName(""), tableType(""), update_time(""),
            uuid(""), bwType(""), startTime(""), endTime(""), uploadFlag(""), cmpThreshold(""), enabled("") {
//            Initialize();
        }

@@ -351,6 +357,15 @@
                    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.");
@@ -376,6 +391,9 @@
        std::string bwType;
        std::string startTime;
        std::string endTime;
        std::string uploadFlag;
        std::string cmpThreshold;
        std::string enabled;

    private:
    };