Merge remote-tracking branch 'origin/yw.1.2.fixbug' into yw.1.2

pansen

2019-02-28 bcf8d8c62fdf61c4c3091bbf0db32383cbd5ea9e

Merge remote-tracking branch 'origin/yw.1.2.fixbug' into yw.1.2

 QiaoJiaSystem/DataManagerServer/CMakeLists.txt

@@ -49,6 +49,9 @@

    #glog
    ../../../BasicPlatForm/libs/glog/include
    ../../../BasicPlatForm/libs/mysqlpp/include
    ../../../BasicPlatForm/libs/mysql/include/mysql/
    ../../../BasicPlatForm/basic/util/app/

)

@@ -76,6 +79,7 @@

    ../../../BasicPlatForm/basic/db/sqlite/
    ../../../BasicPlatForm/basic/db/sqlite/sqlite-v-3220000
    ../../../BasicPlatForm/libs/mysqlpp/lib
)

add_executable(DataWebServer
@@ -150,6 +154,7 @@
    HCCore
    hcnetsdk
    pthread
    mysqlpp
    )

#add_executable(Apptest

 QiaoJiaSystem/DataManagerServer/http_configserver.cpp

@@ -23,6 +23,12 @@
#include <dirent.h>
#include "basic/pipe_element/ffmpeg/basic_struct_for_video_image.h"

#include "vss/controller/VssDevTblController.h"
#include "vss/controller/VssChannelTblController.h"
#include "vss/controller/VssDomainUnitTblController.h"
#include "vss/controller/VssLocalSettingTblController.h"
#include "vss/controller/VssUpperSvrTblController.h"

using namespace std;

devHttpServer_c::devHttpServer_c()
@@ -243,6 +249,14 @@
                                         std::placeholders::_3, std::placeholders::_4));


    BaseDao::initConnection();
    VssLocalSettingTblSqliteDao::instance()->setLDBTool(&db_c);
    VssDevTblController::instance()->registerHttpServices(_HttpSrvRetRecieve);
    VssChannelTblController::instance()->registerHttpServices(_HttpSrvRetRecieve);
    VssDomainUnitTblController::instance()->registerHttpServices(_HttpSrvRetRecieve);
    VssLocalSettingTblController::instance()->registerHttpServices(_HttpSrvRetRecieve);
    VssUpperSvrTblController::instance()->registerHttpServices(_HttpSrvRetRecieve);

    _HttpSrvRetRecieve.start();
    _HttpSrvRetRecieve.waitForShutDown();
}

 QiaoJiaSystem/DataManagerServer/vss/controller/VssBaseController.h

New file
@@ -0,0 +1,20 @@

#ifndef QIAOJIASYSTEM_VSSBASECONTROLLER_H
#define QIAOJIASYSTEM_VSSBASECONTROLLER_H

#include <libs/jsoncpp/include/jsoncpp/json/json.h>

class VssBaseController {
public:
    template <typename Iterable>
    Json::Value iterable2json(Iterable const& cont) {
        Json::Value v;
        for (auto&& element: cont) {
            v.append(element);
        }
        return v;
    }
};


#endif //QIAOJIASYSTEM_VSSBASECONTROLLER_H

 QiaoJiaSystem/DataManagerServer/vss/controller/VssChannelTblController.h

New file
@@ -0,0 +1,624 @@
#ifndef VSSCHANNELTBL_CONTROLLER_H

#define VSSCHANNELTBL_CONTROLLER_H



#include <string>

#include <DataManagerServer/http_configserver.h>

#include "vss/dao/VssChannelTblDao.h"

#include "vss/model/VssChannelTblBuilder.h"

#include "vss/model/VssChannelTbl.h"

#include "VssBaseController.h"

#include <mysql++.h>



using namespace std;



/**

 * 创建二级设备表

 */

class VssChannelTblController : public VssBaseController {

private:

    /** 创建二级设备表构造函数 */

    VssChannelTblController() {}

public:

    /** 创建二级设备表单例模式 */

    static VssChannelTblController* instance() {

        static VssChannelTblController instance;

        return &instance;

    }

public:

    /** 注册{label}http服务 */

    void registerHttpServices(HttpSrvRetRecieve& _HttpSrvRetRecieve) {



        _HttpSrvRetRecieve.setInfo("^/addVssChannelTbl$", "POST",

                                   std::bind(&VssChannelTblController::addVssChannelTbl, this,

                                             std::placeholders::_1, std::placeholders::_2,

                                             std::placeholders::_3, std::placeholders::_4));



        _HttpSrvRetRecieve.setInfo("^/delVssChannelTbl$", "POST",

                                   std::bind(&VssChannelTblController::delVssChannelTbl, this,

                                             std::placeholders::_1, std::placeholders::_2,

                                             std::placeholders::_3, std::placeholders::_4));



        _HttpSrvRetRecieve.setInfo("^/updateVssChannelTbl$", "POST",

                                   std::bind(&VssChannelTblController::updateVssChannelTbl, this,

                                             std::placeholders::_1, std::placeholders::_2,

                                             std::placeholders::_3, std::placeholders::_4));



        _HttpSrvRetRecieve.setInfo("^/findVssChannelTbl$", "POST",

                                   std::bind(&VssChannelTblController::findVssChannelTbl, this,

                                             std::placeholders::_1, std::placeholders::_2,

                                             std::placeholders::_3, std::placeholders::_4));



        _HttpSrvRetRecieve.setInfo("^/findVssChannelTblList$", "POST",

                                   std::bind(&VssChannelTblController::findVssChannelTblList, this,

                                             std::placeholders::_1, std::placeholders::_2,

                                             std::placeholders::_3, std::placeholders::_4));



    }

public:

    /** 添加创建二级设备表 */

    std::string addVssChannelTbl(std::string ip, unsigned int port, std::string content, PResponse &response) {

        Json::Reader requestJsonReader;

        Json::Value requestJsonValue;

        Json::Value responseJsonValue;

        responseJsonValue["message"] = "添加失败！";

        responseJsonValue["success"] = "false";

        if (requestJsonReader.parse(content, requestJsonValue)) {

            VssChannelTblBuilder vssChannelTblBuilder;



            Json::Value iDJsonValue = requestJsonValue[VssChannelTbl_ID];

            if (iDJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addID(std::stoi((iDJsonValue.asString())));

            }



            Json::Value devPubIDJsonValue = requestJsonValue[VssChannelTbl_DevPubID];

            if (devPubIDJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addDevPubID((devPubIDJsonValue.asString()));

            }



            Json::Value nicknameJsonValue = requestJsonValue[VssChannelTbl_Nickname];

            if (nicknameJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addNickname((nicknameJsonValue.asString()));

            }



            Json::Value chanPubIDJsonValue = requestJsonValue[VssChannelTbl_ChanPubID];

            if (chanPubIDJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addChanPubID((chanPubIDJsonValue.asString()));

            }



            Json::Value aliveJsonValue = requestJsonValue[VssChannelTbl_Alive];

            if (aliveJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addAlive(std::stoi((aliveJsonValue.asString())));

            }



            Json::Value corpIDJsonValue = requestJsonValue[VssChannelTbl_CorpID];

            if (corpIDJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addCorpID((corpIDJsonValue.asString()));

            }



            Json::Value modelJsonValue = requestJsonValue[VssChannelTbl_Model];

            if (modelJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addModel((modelJsonValue.asString()));

            }



            Json::Value ownerJsonValue = requestJsonValue[VssChannelTbl_Owner];

            if (ownerJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addOwner((ownerJsonValue.asString()));

            }



            Json::Value civilCodeJsonValue = requestJsonValue[VssChannelTbl_CivilCode];

            if (civilCodeJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addCivilCode((civilCodeJsonValue.asString()));

            }



            Json::Value addressJsonValue = requestJsonValue[VssChannelTbl_Address];

            if (addressJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addAddress((addressJsonValue.asString()));

            }



            Json::Value parentalJsonValue = requestJsonValue[VssChannelTbl_Parental];

            if (parentalJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addParental(std::stoi((parentalJsonValue.asString())));

            }



            Json::Value parentIdJsonValue = requestJsonValue[VssChannelTbl_ParentId];

            if (parentIdJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addParentId((parentIdJsonValue.asString()));

            }



            Json::Value iPJsonValue = requestJsonValue[VssChannelTbl_IP];

            if (iPJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addIP((iPJsonValue.asString()));

            }



            Json::Value portJsonValue = requestJsonValue[VssChannelTbl_Port];

            if (portJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addPort(std::stoi((portJsonValue.asString())));

            }



            Json::Value longitudeJsonValue = requestJsonValue[VssChannelTbl_Longitude];

            if (longitudeJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addLongitude(std::stod((longitudeJsonValue.asString())));

            }



            Json::Value latitudeJsonValue = requestJsonValue[VssChannelTbl_Latitude];

            if (latitudeJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addLatitude(std::stod((latitudeJsonValue.asString())));

            }



            Json::Value altitudeJsonValue = requestJsonValue[VssChannelTbl_Altitude];

            if (altitudeJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addAltitude(std::stod((altitudeJsonValue.asString())));

            }



            Json::Value pTZTypeJsonValue = requestJsonValue[VssChannelTbl_PTZType];

            if (pTZTypeJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addPTZType(std::stoi((pTZTypeJsonValue.asString())));

            }



            Json::Value roomTypeJsonValue = requestJsonValue[VssChannelTbl_RoomType];

            if (roomTypeJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addRoomType(std::stoi((roomTypeJsonValue.asString())));

            }



            Json::Value directionTypeJsonValue = requestJsonValue[VssChannelTbl_DirectionType];

            if (directionTypeJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addDirectionType(std::stoi((directionTypeJsonValue.asString())));

            }



            Json::Value streamTypeJsonValue = requestJsonValue[VssChannelTbl_StreamType];

            if (streamTypeJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addStreamType(std::stoi((streamTypeJsonValue.asString())));

            }



            Json::Value dMarkerJsonValue = requestJsonValue[VssChannelTbl_DMarker];

            if (dMarkerJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addDMarker(std::stoi((dMarkerJsonValue.asString())));

            }



            Json::Value updateTimeJsonValue = requestJsonValue[VssChannelTbl_UpdateTime];

            if (updateTimeJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addUpdateTime((updateTimeJsonValue.asString()));

            }

            auto keyValuesToAdd = vssChannelTblBuilder.buildVssChannelTblMap();

            if (keyValuesToAdd.size() > 0) {

                mysqlpp::SimpleResult addVssChannelTblResult = VssChannelTblDao::instance()->addVssChannelTbl(keyValuesToAdd);

                if (addVssChannelTblResult.rows() > 0) {

                    responseJsonValue["success"] = "true";

                    responseJsonValue["message"] = "添加成功！";

                }

            }

        }

        return responseJsonValue.toStyledString();

    }



    /** 删除创建二级设备表 */

    std::string delVssChannelTbl(std::string ip, unsigned int port, std::string content, PResponse &response) {

        Json::Reader requestJsonReader;

        Json::Value requestJsonValue;

        Json::Value responseJsonValue;

        responseJsonValue["message"] = "删除失败！";

        responseJsonValue["success"] = "false";

        if (requestJsonReader.parse(content, requestJsonValue)) {

            Json::Value iDJsonValue = requestJsonValue[VssChannelTbl_ID];

            if (iDJsonValue.type() != Json::ValueType::nullValue) {

                string iDValue = iDJsonValue.asString();

                if (iDValue.size() > 0 && VssChannelTblDao::instance()->deleteByColumn("ID", iDValue)) {

                    responseJsonValue["success"] = "true";

                    responseJsonValue["message"] = "删除成功!";

                }

            }



        }

        return responseJsonValue.toStyledString();

    }



    /** 更新创建二级设备表 */

    std::string updateVssChannelTbl(std::string ip, unsigned int port, std::string content, PResponse &response) {

        Json::Reader requestJsonReader;

        Json::Value requestJsonValue;

        Json::Value responseJsonValue;

        responseJsonValue["message"] = "更新失败！";

        responseJsonValue["success"] = "false";

        if (requestJsonReader.parse(content, requestJsonValue)) {

            VssChannelTblBuilder vssChannelTblBuilder;



            Json::Value iDJsonValue = requestJsonValue[VssChannelTbl_ID];

            if (iDJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addID(std::stoi((iDJsonValue.asString())));

            }



            Json::Value devPubIDJsonValue = requestJsonValue[VssChannelTbl_DevPubID];

            if (devPubIDJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addDevPubID((devPubIDJsonValue.asString()));

            }



            Json::Value nicknameJsonValue = requestJsonValue[VssChannelTbl_Nickname];

            if (nicknameJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addNickname((nicknameJsonValue.asString()));

            }



            Json::Value chanPubIDJsonValue = requestJsonValue[VssChannelTbl_ChanPubID];

            if (chanPubIDJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addChanPubID((chanPubIDJsonValue.asString()));

            }



            Json::Value aliveJsonValue = requestJsonValue[VssChannelTbl_Alive];

            if (aliveJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addAlive(std::stoi((aliveJsonValue.asString())));

            }



            Json::Value corpIDJsonValue = requestJsonValue[VssChannelTbl_CorpID];

            if (corpIDJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addCorpID((corpIDJsonValue.asString()));

            }



            Json::Value modelJsonValue = requestJsonValue[VssChannelTbl_Model];

            if (modelJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addModel((modelJsonValue.asString()));

            }



            Json::Value ownerJsonValue = requestJsonValue[VssChannelTbl_Owner];

            if (ownerJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addOwner((ownerJsonValue.asString()));

            }



            Json::Value civilCodeJsonValue = requestJsonValue[VssChannelTbl_CivilCode];

            if (civilCodeJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addCivilCode((civilCodeJsonValue.asString()));

            }



            Json::Value addressJsonValue = requestJsonValue[VssChannelTbl_Address];

            if (addressJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addAddress((addressJsonValue.asString()));

            }



            Json::Value parentalJsonValue = requestJsonValue[VssChannelTbl_Parental];

            if (parentalJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addParental(std::stoi((parentalJsonValue.asString())));

            }



            Json::Value parentIdJsonValue = requestJsonValue[VssChannelTbl_ParentId];

            if (parentIdJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addParentId((parentIdJsonValue.asString()));

            }



            Json::Value iPJsonValue = requestJsonValue[VssChannelTbl_IP];

            if (iPJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addIP((iPJsonValue.asString()));

            }



            Json::Value portJsonValue = requestJsonValue[VssChannelTbl_Port];

            if (portJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addPort(std::stoi((portJsonValue.asString())));

            }



            Json::Value longitudeJsonValue = requestJsonValue[VssChannelTbl_Longitude];

            if (longitudeJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addLongitude(std::stod((longitudeJsonValue.asString())));

            }



            Json::Value latitudeJsonValue = requestJsonValue[VssChannelTbl_Latitude];

            if (latitudeJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addLatitude(std::stod((latitudeJsonValue.asString())));

            }



            Json::Value altitudeJsonValue = requestJsonValue[VssChannelTbl_Altitude];

            if (altitudeJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addAltitude(std::stod((altitudeJsonValue.asString())));

            }



            Json::Value pTZTypeJsonValue = requestJsonValue[VssChannelTbl_PTZType];

            if (pTZTypeJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addPTZType(std::stoi((pTZTypeJsonValue.asString())));

            }



            Json::Value roomTypeJsonValue = requestJsonValue[VssChannelTbl_RoomType];

            if (roomTypeJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addRoomType(std::stoi((roomTypeJsonValue.asString())));

            }



            Json::Value directionTypeJsonValue = requestJsonValue[VssChannelTbl_DirectionType];

            if (directionTypeJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addDirectionType(std::stoi((directionTypeJsonValue.asString())));

            }



            Json::Value streamTypeJsonValue = requestJsonValue[VssChannelTbl_StreamType];

            if (streamTypeJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addStreamType(std::stoi((streamTypeJsonValue.asString())));

            }



            Json::Value dMarkerJsonValue = requestJsonValue[VssChannelTbl_DMarker];

            if (dMarkerJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addDMarker(std::stoi((dMarkerJsonValue.asString())));

            }



            Json::Value updateTimeJsonValue = requestJsonValue[VssChannelTbl_UpdateTime];

            if (updateTimeJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addUpdateTime((updateTimeJsonValue.asString()));

            }

            if (iDJsonValue.type() != Json::ValueType::nullValue) {

                string iDValue = iDJsonValue.asString();

                if (iDValue.size() > 0 && VssChannelTblDao::instance()->updateVssChannelTbl(vssChannelTblBuilder.buildVssChannelTblMap(), "ID", iDValue)) {

                    responseJsonValue["success"] = "true";

                    responseJsonValue["message"] = "更新成功！";

                }

            }

        }

        return responseJsonValue.toStyledString();

    }



    /** 查找单个创建二级设备表 */

    std::string findVssChannelTbl(std::string ip, unsigned int port, std::string content, PResponse &response) {

        Json::Reader requestJsonReader;

        Json::Value requestJsonValue;

        Json::Value responseJsonValue;

        responseJsonValue["message"] = "查询失败！";

        responseJsonValue["success"] = "false";

        if (requestJsonReader.parse(content, requestJsonValue)) {

            VssChannelTblBuilder vssChannelTblBuilder;



            Json::Value iDJsonValue = requestJsonValue[VssChannelTbl_ID];

            if (iDJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addID(std::stoi((iDJsonValue.asString())));

            }



            Json::Value devPubIDJsonValue = requestJsonValue[VssChannelTbl_DevPubID];

            if (devPubIDJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addDevPubID((devPubIDJsonValue.asString()));

            }



            Json::Value nicknameJsonValue = requestJsonValue[VssChannelTbl_Nickname];

            if (nicknameJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addNickname((nicknameJsonValue.asString()));

            }



            Json::Value chanPubIDJsonValue = requestJsonValue[VssChannelTbl_ChanPubID];

            if (chanPubIDJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addChanPubID((chanPubIDJsonValue.asString()));

            }



            Json::Value aliveJsonValue = requestJsonValue[VssChannelTbl_Alive];

            if (aliveJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addAlive(std::stoi((aliveJsonValue.asString())));

            }



            Json::Value corpIDJsonValue = requestJsonValue[VssChannelTbl_CorpID];

            if (corpIDJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addCorpID((corpIDJsonValue.asString()));

            }



            Json::Value modelJsonValue = requestJsonValue[VssChannelTbl_Model];

            if (modelJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addModel((modelJsonValue.asString()));

            }



            Json::Value ownerJsonValue = requestJsonValue[VssChannelTbl_Owner];

            if (ownerJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addOwner((ownerJsonValue.asString()));

            }



            Json::Value civilCodeJsonValue = requestJsonValue[VssChannelTbl_CivilCode];

            if (civilCodeJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addCivilCode((civilCodeJsonValue.asString()));

            }



            Json::Value addressJsonValue = requestJsonValue[VssChannelTbl_Address];

            if (addressJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addAddress((addressJsonValue.asString()));

            }



            Json::Value parentalJsonValue = requestJsonValue[VssChannelTbl_Parental];

            if (parentalJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addParental(std::stoi((parentalJsonValue.asString())));

            }



            Json::Value parentIdJsonValue = requestJsonValue[VssChannelTbl_ParentId];

            if (parentIdJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addParentId((parentIdJsonValue.asString()));

            }



            Json::Value iPJsonValue = requestJsonValue[VssChannelTbl_IP];

            if (iPJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addIP((iPJsonValue.asString()));

            }



            Json::Value portJsonValue = requestJsonValue[VssChannelTbl_Port];

            if (portJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addPort(std::stoi((portJsonValue.asString())));

            }



            Json::Value longitudeJsonValue = requestJsonValue[VssChannelTbl_Longitude];

            if (longitudeJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addLongitude(std::stod((longitudeJsonValue.asString())));

            }



            Json::Value latitudeJsonValue = requestJsonValue[VssChannelTbl_Latitude];

            if (latitudeJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addLatitude(std::stod((latitudeJsonValue.asString())));

            }



            Json::Value altitudeJsonValue = requestJsonValue[VssChannelTbl_Altitude];

            if (altitudeJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addAltitude(std::stod((altitudeJsonValue.asString())));

            }



            Json::Value pTZTypeJsonValue = requestJsonValue[VssChannelTbl_PTZType];

            if (pTZTypeJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addPTZType(std::stoi((pTZTypeJsonValue.asString())));

            }



            Json::Value roomTypeJsonValue = requestJsonValue[VssChannelTbl_RoomType];

            if (roomTypeJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addRoomType(std::stoi((roomTypeJsonValue.asString())));

            }



            Json::Value directionTypeJsonValue = requestJsonValue[VssChannelTbl_DirectionType];

            if (directionTypeJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addDirectionType(std::stoi((directionTypeJsonValue.asString())));

            }



            Json::Value streamTypeJsonValue = requestJsonValue[VssChannelTbl_StreamType];

            if (streamTypeJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addStreamType(std::stoi((streamTypeJsonValue.asString())));

            }



            Json::Value dMarkerJsonValue = requestJsonValue[VssChannelTbl_DMarker];

            if (dMarkerJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addDMarker(std::stoi((dMarkerJsonValue.asString())));

            }



            Json::Value updateTimeJsonValue = requestJsonValue[VssChannelTbl_UpdateTime];

            if (updateTimeJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addUpdateTime((updateTimeJsonValue.asString()));

            }

            responseJsonValue["message"] = "查询成功！";

            responseJsonValue["success"] = "true";

            responseJsonValue["data"] = VssChannelTblDao::instance()->findJsonArray(string("select * from ") + VSSChannelTbl_TABLE_NAME + " where 1 = 1 limit 1");

        }

        return responseJsonValue.toStyledString();

    }



    /** 查找创建二级设备表列表 */

    std::string findVssChannelTblList(std::string ip, unsigned int port, std::string content, PResponse &response) {

        Json::Reader requestJsonReader;

        Json::Value requestJsonValue;

        Json::Value responseJsonValue;

        responseJsonValue["message"] = "查询失败！";

        responseJsonValue["success"] = "false";

        if (content == "" || requestJsonReader.parse(content, requestJsonValue)) {

            VssChannelTblBuilder vssChannelTblBuilder;



            Json::Value iDJsonValue = requestJsonValue[VssChannelTbl_ID];

            if (iDJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addID(std::stoi((iDJsonValue.asString())));

            }



            Json::Value devPubIDJsonValue = requestJsonValue[VssChannelTbl_DevPubID];

            if (devPubIDJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addDevPubID((devPubIDJsonValue.asString()));

            }



            Json::Value nicknameJsonValue = requestJsonValue[VssChannelTbl_Nickname];

            if (nicknameJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addNickname((nicknameJsonValue.asString()));

            }



            Json::Value chanPubIDJsonValue = requestJsonValue[VssChannelTbl_ChanPubID];

            if (chanPubIDJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addChanPubID((chanPubIDJsonValue.asString()));

            }



            Json::Value aliveJsonValue = requestJsonValue[VssChannelTbl_Alive];

            if (aliveJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addAlive(std::stoi((aliveJsonValue.asString())));

            }



            Json::Value corpIDJsonValue = requestJsonValue[VssChannelTbl_CorpID];

            if (corpIDJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addCorpID((corpIDJsonValue.asString()));

            }



            Json::Value modelJsonValue = requestJsonValue[VssChannelTbl_Model];

            if (modelJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addModel((modelJsonValue.asString()));

            }



            Json::Value ownerJsonValue = requestJsonValue[VssChannelTbl_Owner];

            if (ownerJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addOwner((ownerJsonValue.asString()));

            }



            Json::Value civilCodeJsonValue = requestJsonValue[VssChannelTbl_CivilCode];

            if (civilCodeJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addCivilCode((civilCodeJsonValue.asString()));

            }



            Json::Value addressJsonValue = requestJsonValue[VssChannelTbl_Address];

            if (addressJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addAddress((addressJsonValue.asString()));

            }



            Json::Value parentalJsonValue = requestJsonValue[VssChannelTbl_Parental];

            if (parentalJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addParental(std::stoi((parentalJsonValue.asString())));

            }



            Json::Value parentIdJsonValue = requestJsonValue[VssChannelTbl_ParentId];

            if (parentIdJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addParentId((parentIdJsonValue.asString()));

            }



            Json::Value iPJsonValue = requestJsonValue[VssChannelTbl_IP];

            if (iPJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addIP((iPJsonValue.asString()));

            }



            Json::Value portJsonValue = requestJsonValue[VssChannelTbl_Port];

            if (portJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addPort(std::stoi((portJsonValue.asString())));

            }



            Json::Value longitudeJsonValue = requestJsonValue[VssChannelTbl_Longitude];

            if (longitudeJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addLongitude(std::stod((longitudeJsonValue.asString())));

            }



            Json::Value latitudeJsonValue = requestJsonValue[VssChannelTbl_Latitude];

            if (latitudeJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addLatitude(std::stod((latitudeJsonValue.asString())));

            }



            Json::Value altitudeJsonValue = requestJsonValue[VssChannelTbl_Altitude];

            if (altitudeJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addAltitude(std::stod((altitudeJsonValue.asString())));

            }



            Json::Value pTZTypeJsonValue = requestJsonValue[VssChannelTbl_PTZType];

            if (pTZTypeJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addPTZType(std::stoi((pTZTypeJsonValue.asString())));

            }



            Json::Value roomTypeJsonValue = requestJsonValue[VssChannelTbl_RoomType];

            if (roomTypeJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addRoomType(std::stoi((roomTypeJsonValue.asString())));

            }



            Json::Value directionTypeJsonValue = requestJsonValue[VssChannelTbl_DirectionType];

            if (directionTypeJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addDirectionType(std::stoi((directionTypeJsonValue.asString())));

            }



            Json::Value streamTypeJsonValue = requestJsonValue[VssChannelTbl_StreamType];

            if (streamTypeJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addStreamType(std::stoi((streamTypeJsonValue.asString())));

            }



            Json::Value dMarkerJsonValue = requestJsonValue[VssChannelTbl_DMarker];

            if (dMarkerJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addDMarker(std::stoi((dMarkerJsonValue.asString())));

            }



            Json::Value updateTimeJsonValue = requestJsonValue[VssChannelTbl_UpdateTime];

            if (updateTimeJsonValue.type() != Json::ValueType::nullValue) {

                vssChannelTblBuilder.addUpdateTime((updateTimeJsonValue.asString()));

            }

            responseJsonValue["message"] = "查询成功！";

            responseJsonValue["success"] = "true";

            responseJsonValue["data"] = VssChannelTblDao::instance()->findJsonArray(string("select * from ") + VSSChannelTbl_TABLE_NAME + " where 1 = 1");



        }

        return responseJsonValue.toStyledString();

    }

};













#endif //VSSCHANNELTBL_CONTROLLER_H












 QiaoJiaSystem/DataManagerServer/vss/controller/VssDevTblController.h

New file
@@ -0,0 +1,384 @@
#ifndef VSSDEVTBL_CONTROLLER_H

#define VSSDEVTBL_CONTROLLER_H



#include <string>

#include <DataManagerServer/http_configserver.h>

#include "vss/dao/VssDevTblDao.h"

#include "vss/model/VssDevTblBuilder.h"

#include "vss/model/VssDevTbl.h"

#include "VssBaseController.h"

#include <mysql++.h>



using namespace std;



/**

 * 创建一级设备表

 */

class VssDevTblController : public VssBaseController {

private:

    /** 创建一级设备表构造函数 */

    VssDevTblController() {}

public:

    /** 创建一级设备表单例模式 */

    static VssDevTblController* instance() {

        static VssDevTblController instance;

        return &instance;

    }

public:

    /** 注册{label}http服务 */

    void registerHttpServices(HttpSrvRetRecieve& _HttpSrvRetRecieve) {



        _HttpSrvRetRecieve.setInfo("^/addVssDevTbl$", "POST",

                                   std::bind(&VssDevTblController::addVssDevTbl, this,

                                             std::placeholders::_1, std::placeholders::_2,

                                             std::placeholders::_3, std::placeholders::_4));



        _HttpSrvRetRecieve.setInfo("^/delVssDevTbl$", "POST",

                                   std::bind(&VssDevTblController::delVssDevTbl, this,

                                             std::placeholders::_1, std::placeholders::_2,

                                             std::placeholders::_3, std::placeholders::_4));



        _HttpSrvRetRecieve.setInfo("^/updateVssDevTbl$", "POST",

                                   std::bind(&VssDevTblController::updateVssDevTbl, this,

                                             std::placeholders::_1, std::placeholders::_2,

                                             std::placeholders::_3, std::placeholders::_4));



        _HttpSrvRetRecieve.setInfo("^/findVssDevTbl$", "POST",

                                   std::bind(&VssDevTblController::findVssDevTbl, this,

                                             std::placeholders::_1, std::placeholders::_2,

                                             std::placeholders::_3, std::placeholders::_4));



        _HttpSrvRetRecieve.setInfo("^/findVssDevTblList$", "POST",

                                   std::bind(&VssDevTblController::findVssDevTblList, this,

                                             std::placeholders::_1, std::placeholders::_2,

                                             std::placeholders::_3, std::placeholders::_4));



    }

public:

    /** 添加创建一级设备表 */

    std::string addVssDevTbl(std::string ip, unsigned int port, std::string content, PResponse &response) {

        Json::Reader requestJsonReader;

        Json::Value requestJsonValue;

        Json::Value responseJsonValue;

        responseJsonValue["message"] = "添加失败！";

        responseJsonValue["success"] = "false";

        if (requestJsonReader.parse(content, requestJsonValue)) {

            VssDevTblBuilder vssDevTblBuilder;



            Json::Value iDJsonValue = requestJsonValue[VssDevTbl_ID];

            if (iDJsonValue.type() != Json::ValueType::nullValue) {

                vssDevTblBuilder.addID(std::stoi((iDJsonValue.asString())));

            }



            Json::Value devPubIDJsonValue = requestJsonValue[VssDevTbl_DevPubID];

            if (devPubIDJsonValue.type() != Json::ValueType::nullValue) {

                vssDevTblBuilder.addDevPubID((devPubIDJsonValue.asString()));

            }



            Json::Value devNicknameJsonValue = requestJsonValue[VssDevTbl_DevNickname];

            if (devNicknameJsonValue.type() != Json::ValueType::nullValue) {

                vssDevTblBuilder.addDevNickname((devNicknameJsonValue.asString()));

            }



            Json::Value userNameJsonValue = requestJsonValue[VssDevTbl_UserName];

            if (userNameJsonValue.type() != Json::ValueType::nullValue) {

                vssDevTblBuilder.addUserName((userNameJsonValue.asString()));

            }



            Json::Value passwdJsonValue = requestJsonValue[VssDevTbl_Passwd];

            if (passwdJsonValue.type() != Json::ValueType::nullValue) {

                vssDevTblBuilder.addPasswd((passwdJsonValue.asString()));

            }



            Json::Value corpIDJsonValue = requestJsonValue[VssDevTbl_CorpID];

            if (corpIDJsonValue.type() != Json::ValueType::nullValue) {

                vssDevTblBuilder.addCorpID((corpIDJsonValue.asString()));

            }



            Json::Value iPJsonValue = requestJsonValue[VssDevTbl_IP];

            if (iPJsonValue.type() != Json::ValueType::nullValue) {

                vssDevTblBuilder.addIP((iPJsonValue.asString()));

            }



            Json::Value portJsonValue = requestJsonValue[VssDevTbl_Port];

            if (portJsonValue.type() != Json::ValueType::nullValue) {

                vssDevTblBuilder.addPort(std::stoi((portJsonValue.asString())));

            }



            Json::Value aliveJsonValue = requestJsonValue[VssDevTbl_Alive];

            if (aliveJsonValue.type() != Json::ValueType::nullValue) {

                vssDevTblBuilder.addAlive(std::stoi((aliveJsonValue.asString())));

            }



            Json::Value dMarkerJsonValue = requestJsonValue[VssDevTbl_DMarker];

            if (dMarkerJsonValue.type() != Json::ValueType::nullValue) {

                vssDevTblBuilder.addDMarker(std::stoi((dMarkerJsonValue.asString())));

            }



            Json::Value updateTimeJsonValue = requestJsonValue[VssDevTbl_UpdateTime];

            if (updateTimeJsonValue.type() != Json::ValueType::nullValue) {

                vssDevTblBuilder.addUpdateTime((updateTimeJsonValue.asString()));

            }

            auto keyValuesToAdd = vssDevTblBuilder.buildVssDevTblMap();

            if (keyValuesToAdd.size() > 0) {

                mysqlpp::SimpleResult addVssDevTblResult = VssDevTblDao::instance()->addVssDevTbl(keyValuesToAdd);

                if (addVssDevTblResult.rows() > 0) {

                    responseJsonValue["success"] = "true";

                    responseJsonValue["message"] = "添加成功！";

                }

            }

        }

        return responseJsonValue.toStyledString();

    }



    /** 删除创建一级设备表 */

    std::string delVssDevTbl(std::string ip, unsigned int port, std::string content, PResponse &response) {

        Json::Reader requestJsonReader;

        Json::Value requestJsonValue;

        Json::Value responseJsonValue;

        responseJsonValue["message"] = "删除失败！";

        responseJsonValue["success"] = "false";

        if (requestJsonReader.parse(content, requestJsonValue)) {

            Json::Value iDJsonValue = requestJsonValue[VssDevTbl_ID];

            if (iDJsonValue.type() != Json::ValueType::nullValue) {

                string iDValue = iDJsonValue.asString();

                if (iDValue.size() > 0 && VssDevTblDao::instance()->deleteByColumn("ID", iDValue)) {

                    responseJsonValue["success"] = "true";

                    responseJsonValue["message"] = "删除成功!";

                }

            }



        }

        return responseJsonValue.toStyledString();

    }



    /** 更新创建一级设备表 */

    std::string updateVssDevTbl(std::string ip, unsigned int port, std::string content, PResponse &response) {

        Json::Reader requestJsonReader;

        Json::Value requestJsonValue;

        Json::Value responseJsonValue;

        responseJsonValue["message"] = "更新失败！";

        responseJsonValue["success"] = "false";

        if (requestJsonReader.parse(content, requestJsonValue)) {

            VssDevTblBuilder vssDevTblBuilder;



            Json::Value iDJsonValue = requestJsonValue[VssDevTbl_ID];

            if (iDJsonValue.type() != Json::ValueType::nullValue) {

                vssDevTblBuilder.addID(std::stoi((iDJsonValue.asString())));

            }



            Json::Value devPubIDJsonValue = requestJsonValue[VssDevTbl_DevPubID];

            if (devPubIDJsonValue.type() != Json::ValueType::nullValue) {

                vssDevTblBuilder.addDevPubID((devPubIDJsonValue.asString()));

            }



            Json::Value devNicknameJsonValue = requestJsonValue[VssDevTbl_DevNickname];

            if (devNicknameJsonValue.type() != Json::ValueType::nullValue) {

                vssDevTblBuilder.addDevNickname((devNicknameJsonValue.asString()));

            }



            Json::Value userNameJsonValue = requestJsonValue[VssDevTbl_UserName];

            if (userNameJsonValue.type() != Json::ValueType::nullValue) {

                vssDevTblBuilder.addUserName((userNameJsonValue.asString()));

            }



            Json::Value passwdJsonValue = requestJsonValue[VssDevTbl_Passwd];

            if (passwdJsonValue.type() != Json::ValueType::nullValue) {

                vssDevTblBuilder.addPasswd((passwdJsonValue.asString()));

            }



            Json::Value corpIDJsonValue = requestJsonValue[VssDevTbl_CorpID];

            if (corpIDJsonValue.type() != Json::ValueType::nullValue) {

                vssDevTblBuilder.addCorpID((corpIDJsonValue.asString()));

            }



            Json::Value iPJsonValue = requestJsonValue[VssDevTbl_IP];

            if (iPJsonValue.type() != Json::ValueType::nullValue) {

                vssDevTblBuilder.addIP((iPJsonValue.asString()));

            }



            Json::Value portJsonValue = requestJsonValue[VssDevTbl_Port];

            if (portJsonValue.type() != Json::ValueType::nullValue) {

                vssDevTblBuilder.addPort(std::stoi((portJsonValue.asString())));

            }



            Json::Value aliveJsonValue = requestJsonValue[VssDevTbl_Alive];

            if (aliveJsonValue.type() != Json::ValueType::nullValue) {

                vssDevTblBuilder.addAlive(std::stoi((aliveJsonValue.asString())));

            }



            Json::Value dMarkerJsonValue = requestJsonValue[VssDevTbl_DMarker];

            if (dMarkerJsonValue.type() != Json::ValueType::nullValue) {

                vssDevTblBuilder.addDMarker(std::stoi((dMarkerJsonValue.asString())));

            }



            Json::Value updateTimeJsonValue = requestJsonValue[VssDevTbl_UpdateTime];

            if (updateTimeJsonValue.type() != Json::ValueType::nullValue) {

                vssDevTblBuilder.addUpdateTime((updateTimeJsonValue.asString()));

            }

            if (iDJsonValue.type() != Json::ValueType::nullValue) {

                string iDValue = iDJsonValue.asString();

                if (iDValue.size() > 0 && VssDevTblDao::instance()->updateVssDevTbl(vssDevTblBuilder.buildVssDevTblMap(), "ID", iDValue)) {

                    responseJsonValue["success"] = "true";

                    responseJsonValue["message"] = "更新成功！";

                }

            }

        }

        return responseJsonValue.toStyledString();

    }



    /** 查找单个创建一级设备表 */

    std::string findVssDevTbl(std::string ip, unsigned int port, std::string content, PResponse &response) {

        Json::Reader requestJsonReader;

        Json::Value requestJsonValue;

        Json::Value responseJsonValue;

        responseJsonValue["message"] = "查询失败！";

        responseJsonValue["success"] = "false";

        if (requestJsonReader.parse(content, requestJsonValue)) {

            VssDevTblBuilder vssDevTblBuilder;



            Json::Value iDJsonValue = requestJsonValue[VssDevTbl_ID];

            if (iDJsonValue.type() != Json::ValueType::nullValue) {

                vssDevTblBuilder.addID(std::stoi((iDJsonValue.asString())));

            }



            Json::Value devPubIDJsonValue = requestJsonValue[VssDevTbl_DevPubID];

            if (devPubIDJsonValue.type() != Json::ValueType::nullValue) {

                vssDevTblBuilder.addDevPubID((devPubIDJsonValue.asString()));

            }



            Json::Value devNicknameJsonValue = requestJsonValue[VssDevTbl_DevNickname];

            if (devNicknameJsonValue.type() != Json::ValueType::nullValue) {

                vssDevTblBuilder.addDevNickname((devNicknameJsonValue.asString()));

            }



            Json::Value userNameJsonValue = requestJsonValue[VssDevTbl_UserName];

            if (userNameJsonValue.type() != Json::ValueType::nullValue) {

                vssDevTblBuilder.addUserName((userNameJsonValue.asString()));

            }



            Json::Value passwdJsonValue = requestJsonValue[VssDevTbl_Passwd];

            if (passwdJsonValue.type() != Json::ValueType::nullValue) {

                vssDevTblBuilder.addPasswd((passwdJsonValue.asString()));

            }



            Json::Value corpIDJsonValue = requestJsonValue[VssDevTbl_CorpID];

            if (corpIDJsonValue.type() != Json::ValueType::nullValue) {

                vssDevTblBuilder.addCorpID((corpIDJsonValue.asString()));

            }



            Json::Value iPJsonValue = requestJsonValue[VssDevTbl_IP];

            if (iPJsonValue.type() != Json::ValueType::nullValue) {

                vssDevTblBuilder.addIP((iPJsonValue.asString()));

            }



            Json::Value portJsonValue = requestJsonValue[VssDevTbl_Port];

            if (portJsonValue.type() != Json::ValueType::nullValue) {

                vssDevTblBuilder.addPort(std::stoi((portJsonValue.asString())));

            }



            Json::Value aliveJsonValue = requestJsonValue[VssDevTbl_Alive];

            if (aliveJsonValue.type() != Json::ValueType::nullValue) {

                vssDevTblBuilder.addAlive(std::stoi((aliveJsonValue.asString())));

            }



            Json::Value dMarkerJsonValue = requestJsonValue[VssDevTbl_DMarker];

            if (dMarkerJsonValue.type() != Json::ValueType::nullValue) {

                vssDevTblBuilder.addDMarker(std::stoi((dMarkerJsonValue.asString())));

            }



            Json::Value updateTimeJsonValue = requestJsonValue[VssDevTbl_UpdateTime];

            if (updateTimeJsonValue.type() != Json::ValueType::nullValue) {

                vssDevTblBuilder.addUpdateTime((updateTimeJsonValue.asString()));

            }

            responseJsonValue["message"] = "查询成功！";

            responseJsonValue["success"] = "true";

            responseJsonValue["data"] = VssDevTblDao::instance()->findJsonArray(string("select * from ") + VSSDevTbl_TABLE_NAME + " where 1 = 1 limit 1");

        }

        return responseJsonValue.toStyledString();

    }



    /** 查找创建一级设备表列表 */

    std::string findVssDevTblList(std::string ip, unsigned int port, std::string content, PResponse &response) {

        Json::Reader requestJsonReader;

        Json::Value requestJsonValue;

        Json::Value responseJsonValue;

        responseJsonValue["message"] = "查询失败！";

        responseJsonValue["success"] = "false";

        if (content == "" || requestJsonReader.parse(content, requestJsonValue)) {

            VssDevTblBuilder vssDevTblBuilder;



            Json::Value iDJsonValue = requestJsonValue[VssDevTbl_ID];

            if (iDJsonValue.type() != Json::ValueType::nullValue) {

                vssDevTblBuilder.addID(std::stoi((iDJsonValue.asString())));

            }



            Json::Value devPubIDJsonValue = requestJsonValue[VssDevTbl_DevPubID];

            if (devPubIDJsonValue.type() != Json::ValueType::nullValue) {

                vssDevTblBuilder.addDevPubID((devPubIDJsonValue.asString()));

            }



            Json::Value devNicknameJsonValue = requestJsonValue[VssDevTbl_DevNickname];

            if (devNicknameJsonValue.type() != Json::ValueType::nullValue) {

                vssDevTblBuilder.addDevNickname((devNicknameJsonValue.asString()));

            }



            Json::Value userNameJsonValue = requestJsonValue[VssDevTbl_UserName];

            if (userNameJsonValue.type() != Json::ValueType::nullValue) {

                vssDevTblBuilder.addUserName((userNameJsonValue.asString()));

            }



            Json::Value passwdJsonValue = requestJsonValue[VssDevTbl_Passwd];

            if (passwdJsonValue.type() != Json::ValueType::nullValue) {

                vssDevTblBuilder.addPasswd((passwdJsonValue.asString()));

            }



            Json::Value corpIDJsonValue = requestJsonValue[VssDevTbl_CorpID];

            if (corpIDJsonValue.type() != Json::ValueType::nullValue) {

                vssDevTblBuilder.addCorpID((corpIDJsonValue.asString()));

            }



            Json::Value iPJsonValue = requestJsonValue[VssDevTbl_IP];

            if (iPJsonValue.type() != Json::ValueType::nullValue) {

                vssDevTblBuilder.addIP((iPJsonValue.asString()));

            }



            Json::Value portJsonValue = requestJsonValue[VssDevTbl_Port];

            if (portJsonValue.type() != Json::ValueType::nullValue) {

                vssDevTblBuilder.addPort(std::stoi((portJsonValue.asString())));

            }



            Json::Value aliveJsonValue = requestJsonValue[VssDevTbl_Alive];

            if (aliveJsonValue.type() != Json::ValueType::nullValue) {

                vssDevTblBuilder.addAlive(std::stoi((aliveJsonValue.asString())));

            }



            Json::Value dMarkerJsonValue = requestJsonValue[VssDevTbl_DMarker];

            if (dMarkerJsonValue.type() != Json::ValueType::nullValue) {

                vssDevTblBuilder.addDMarker(std::stoi((dMarkerJsonValue.asString())));

            }



            Json::Value updateTimeJsonValue = requestJsonValue[VssDevTbl_UpdateTime];

            if (updateTimeJsonValue.type() != Json::ValueType::nullValue) {

                vssDevTblBuilder.addUpdateTime((updateTimeJsonValue.asString()));

            }

            responseJsonValue["message"] = "查询成功！";

            responseJsonValue["success"] = "true";

            responseJsonValue["data"] = VssDevTblDao::instance()->findJsonArray(string("select * from ") + VSSDevTbl_TABLE_NAME + " where 1 = 1");



        }

        return responseJsonValue.toStyledString();

    }

};













#endif //VSSDEVTBL_CONTROLLER_H












 QiaoJiaSystem/DataManagerServer/vss/controller/VssDomainUnitTblController.h

New file
@@ -0,0 +1,324 @@
#ifndef VSSDOMAINUNITTBL_CONTROLLER_H

#define VSSDOMAINUNITTBL_CONTROLLER_H



#include <string>

#include <DataManagerServer/http_configserver.h>

#include "vss/dao/VssDomainUnitTblDao.h"

#include "vss/model/VssDomainUnitTblBuilder.h"

#include "vss/model/VssDomainUnitTbl.h"

#include "VssBaseController.h"

#include <mysql++.h>



using namespace std;



/**

 * 创建一级设备表

 */

class VssDomainUnitTblController : public VssBaseController {

private:

    /** 创建一级设备表构造函数 */

    VssDomainUnitTblController() {}

public:

    /** 创建一级设备表单例模式 */

    static VssDomainUnitTblController* instance() {

        static VssDomainUnitTblController instance;

        return &instance;

    }

public:

    /** 注册{label}http服务 */

    void registerHttpServices(HttpSrvRetRecieve& _HttpSrvRetRecieve) {



        _HttpSrvRetRecieve.setInfo("^/addVssDomainUnitTbl$", "POST",

                                   std::bind(&VssDomainUnitTblController::addVssDomainUnitTbl, this,

                                             std::placeholders::_1, std::placeholders::_2,

                                             std::placeholders::_3, std::placeholders::_4));



        _HttpSrvRetRecieve.setInfo("^/delVssDomainUnitTbl$", "POST",

                                   std::bind(&VssDomainUnitTblController::delVssDomainUnitTbl, this,

                                             std::placeholders::_1, std::placeholders::_2,

                                             std::placeholders::_3, std::placeholders::_4));



        _HttpSrvRetRecieve.setInfo("^/updateVssDomainUnitTbl$", "POST",

                                   std::bind(&VssDomainUnitTblController::updateVssDomainUnitTbl, this,

                                             std::placeholders::_1, std::placeholders::_2,

                                             std::placeholders::_3, std::placeholders::_4));



        _HttpSrvRetRecieve.setInfo("^/findVssDomainUnitTbl$", "POST",

                                   std::bind(&VssDomainUnitTblController::findVssDomainUnitTbl, this,

                                             std::placeholders::_1, std::placeholders::_2,

                                             std::placeholders::_3, std::placeholders::_4));



        _HttpSrvRetRecieve.setInfo("^/findVssDomainUnitTblList$", "POST",

                                   std::bind(&VssDomainUnitTblController::findVssDomainUnitTblList, this,

                                             std::placeholders::_1, std::placeholders::_2,

                                             std::placeholders::_3, std::placeholders::_4));



    }

public:

    /** 添加创建一级设备表 */

    std::string addVssDomainUnitTbl(std::string ip, unsigned int port, std::string content, PResponse &response) {

        Json::Reader requestJsonReader;

        Json::Value requestJsonValue;

        Json::Value responseJsonValue;

        responseJsonValue["message"] = "添加失败！";

        responseJsonValue["success"] = "false";

        if (requestJsonReader.parse(content, requestJsonValue)) {

            VssDomainUnitTblBuilder vssDomainUnitTblBuilder;



            Json::Value iDJsonValue = requestJsonValue[VssDomainUnitTbl_ID];

            if (iDJsonValue.type() != Json::ValueType::nullValue) {

                vssDomainUnitTblBuilder.addID(std::stoi((iDJsonValue.asString())));

            }



            Json::Value devPubIDJsonValue = requestJsonValue[VssDomainUnitTbl_DevPubID];

            if (devPubIDJsonValue.type() != Json::ValueType::nullValue) {

                vssDomainUnitTblBuilder.addDevPubID((devPubIDJsonValue.asString()));

            }



            Json::Value domainPubIDJsonValue = requestJsonValue[VssDomainUnitTbl_DomainPubID];

            if (domainPubIDJsonValue.type() != Json::ValueType::nullValue) {

                vssDomainUnitTblBuilder.addDomainPubID((domainPubIDJsonValue.asString()));

            }



            Json::Value nameJsonValue = requestJsonValue[VssDomainUnitTbl_Name];

            if (nameJsonValue.type() != Json::ValueType::nullValue) {

                vssDomainUnitTblBuilder.addName((nameJsonValue.asString()));

            }



            Json::Value businessGroupIDJsonValue = requestJsonValue[VssDomainUnitTbl_BusinessGroupID];

            if (businessGroupIDJsonValue.type() != Json::ValueType::nullValue) {

                vssDomainUnitTblBuilder.addBusinessGroupID((businessGroupIDJsonValue.asString()));

            }



            Json::Value parentIdJsonValue = requestJsonValue[VssDomainUnitTbl_ParentId];

            if (parentIdJsonValue.type() != Json::ValueType::nullValue) {

                vssDomainUnitTblBuilder.addParentId((parentIdJsonValue.asString()));

            }



            Json::Value domainTypeJsonValue = requestJsonValue[VssDomainUnitTbl_DomainType];

            if (domainTypeJsonValue.type() != Json::ValueType::nullValue) {

                vssDomainUnitTblBuilder.addDomainType(std::stoi((domainTypeJsonValue.asString())));

            }



            Json::Value updateTimeJsonValue = requestJsonValue[VssDomainUnitTbl_UpdateTime];

            if (updateTimeJsonValue.type() != Json::ValueType::nullValue) {

                vssDomainUnitTblBuilder.addUpdateTime((updateTimeJsonValue.asString()));

            }

            auto keyValuesToAdd = vssDomainUnitTblBuilder.buildVssDomainUnitTblMap();

            if (keyValuesToAdd.size() > 0) {

                mysqlpp::SimpleResult addVssDomainUnitTblResult = VssDomainUnitTblDao::instance()->addVssDomainUnitTbl(keyValuesToAdd);

                if (addVssDomainUnitTblResult.rows() > 0) {

                    responseJsonValue["success"] = "true";

                    responseJsonValue["message"] = "添加成功！";

                }

            }

        }

        return responseJsonValue.toStyledString();

    }



    /** 删除创建一级设备表 */

    std::string delVssDomainUnitTbl(std::string ip, unsigned int port, std::string content, PResponse &response) {

        Json::Reader requestJsonReader;

        Json::Value requestJsonValue;

        Json::Value responseJsonValue;

        responseJsonValue["message"] = "删除失败！";

        responseJsonValue["success"] = "false";

        if (requestJsonReader.parse(content, requestJsonValue)) {

            Json::Value iDJsonValue = requestJsonValue[VssDomainUnitTbl_ID];

            if (iDJsonValue.type() != Json::ValueType::nullValue) {

                string iDValue = iDJsonValue.asString();

                if (iDValue.size() > 0 && VssDomainUnitTblDao::instance()->deleteByColumn("ID", iDValue)) {

                    responseJsonValue["success"] = "true";

                    responseJsonValue["message"] = "删除成功!";

                }

            }



        }

        return responseJsonValue.toStyledString();

    }



    /** 更新创建一级设备表 */

    std::string updateVssDomainUnitTbl(std::string ip, unsigned int port, std::string content, PResponse &response) {

        Json::Reader requestJsonReader;

        Json::Value requestJsonValue;

        Json::Value responseJsonValue;

        responseJsonValue["message"] = "更新失败！";

        responseJsonValue["success"] = "false";

        if (requestJsonReader.parse(content, requestJsonValue)) {

            VssDomainUnitTblBuilder vssDomainUnitTblBuilder;



            Json::Value iDJsonValue = requestJsonValue[VssDomainUnitTbl_ID];

            if (iDJsonValue.type() != Json::ValueType::nullValue) {

                vssDomainUnitTblBuilder.addID(std::stoi((iDJsonValue.asString())));

            }



            Json::Value devPubIDJsonValue = requestJsonValue[VssDomainUnitTbl_DevPubID];

            if (devPubIDJsonValue.type() != Json::ValueType::nullValue) {

                vssDomainUnitTblBuilder.addDevPubID((devPubIDJsonValue.asString()));

            }



            Json::Value domainPubIDJsonValue = requestJsonValue[VssDomainUnitTbl_DomainPubID];

            if (domainPubIDJsonValue.type() != Json::ValueType::nullValue) {

                vssDomainUnitTblBuilder.addDomainPubID((domainPubIDJsonValue.asString()));

            }



            Json::Value nameJsonValue = requestJsonValue[VssDomainUnitTbl_Name];

            if (nameJsonValue.type() != Json::ValueType::nullValue) {

                vssDomainUnitTblBuilder.addName((nameJsonValue.asString()));

            }



            Json::Value businessGroupIDJsonValue = requestJsonValue[VssDomainUnitTbl_BusinessGroupID];

            if (businessGroupIDJsonValue.type() != Json::ValueType::nullValue) {

                vssDomainUnitTblBuilder.addBusinessGroupID((businessGroupIDJsonValue.asString()));

            }



            Json::Value parentIdJsonValue = requestJsonValue[VssDomainUnitTbl_ParentId];

            if (parentIdJsonValue.type() != Json::ValueType::nullValue) {

                vssDomainUnitTblBuilder.addParentId((parentIdJsonValue.asString()));

            }



            Json::Value domainTypeJsonValue = requestJsonValue[VssDomainUnitTbl_DomainType];

            if (domainTypeJsonValue.type() != Json::ValueType::nullValue) {

                vssDomainUnitTblBuilder.addDomainType(std::stoi((domainTypeJsonValue.asString())));

            }



            Json::Value updateTimeJsonValue = requestJsonValue[VssDomainUnitTbl_UpdateTime];

            if (updateTimeJsonValue.type() != Json::ValueType::nullValue) {

                vssDomainUnitTblBuilder.addUpdateTime((updateTimeJsonValue.asString()));

            }

            if (iDJsonValue.type() != Json::ValueType::nullValue) {

                string iDValue = iDJsonValue.asString();

                if (iDValue.size() > 0 && VssDomainUnitTblDao::instance()->updateVssDomainUnitTbl(vssDomainUnitTblBuilder.buildVssDomainUnitTblMap(), "ID", iDValue)) {

                    responseJsonValue["success"] = "true";

                    responseJsonValue["message"] = "更新成功！";

                }

            }

        }

        return responseJsonValue.toStyledString();

    }



    /** 查找单个创建一级设备表 */

    std::string findVssDomainUnitTbl(std::string ip, unsigned int port, std::string content, PResponse &response) {

        Json::Reader requestJsonReader;

        Json::Value requestJsonValue;

        Json::Value responseJsonValue;

        responseJsonValue["message"] = "查询失败！";

        responseJsonValue["success"] = "false";

        if (requestJsonReader.parse(content, requestJsonValue)) {

            VssDomainUnitTblBuilder vssDomainUnitTblBuilder;



            Json::Value iDJsonValue = requestJsonValue[VssDomainUnitTbl_ID];

            if (iDJsonValue.type() != Json::ValueType::nullValue) {

                vssDomainUnitTblBuilder.addID(std::stoi((iDJsonValue.asString())));

            }



            Json::Value devPubIDJsonValue = requestJsonValue[VssDomainUnitTbl_DevPubID];

            if (devPubIDJsonValue.type() != Json::ValueType::nullValue) {

                vssDomainUnitTblBuilder.addDevPubID((devPubIDJsonValue.asString()));

            }



            Json::Value domainPubIDJsonValue = requestJsonValue[VssDomainUnitTbl_DomainPubID];

            if (domainPubIDJsonValue.type() != Json::ValueType::nullValue) {

                vssDomainUnitTblBuilder.addDomainPubID((domainPubIDJsonValue.asString()));

            }



            Json::Value nameJsonValue = requestJsonValue[VssDomainUnitTbl_Name];

            if (nameJsonValue.type() != Json::ValueType::nullValue) {

                vssDomainUnitTblBuilder.addName((nameJsonValue.asString()));

            }



            Json::Value businessGroupIDJsonValue = requestJsonValue[VssDomainUnitTbl_BusinessGroupID];

            if (businessGroupIDJsonValue.type() != Json::ValueType::nullValue) {

                vssDomainUnitTblBuilder.addBusinessGroupID((businessGroupIDJsonValue.asString()));

            }



            Json::Value parentIdJsonValue = requestJsonValue[VssDomainUnitTbl_ParentId];

            if (parentIdJsonValue.type() != Json::ValueType::nullValue) {

                vssDomainUnitTblBuilder.addParentId((parentIdJsonValue.asString()));

            }



            Json::Value domainTypeJsonValue = requestJsonValue[VssDomainUnitTbl_DomainType];

            if (domainTypeJsonValue.type() != Json::ValueType::nullValue) {

                vssDomainUnitTblBuilder.addDomainType(std::stoi((domainTypeJsonValue.asString())));

            }



            Json::Value updateTimeJsonValue = requestJsonValue[VssDomainUnitTbl_UpdateTime];

            if (updateTimeJsonValue.type() != Json::ValueType::nullValue) {

                vssDomainUnitTblBuilder.addUpdateTime((updateTimeJsonValue.asString()));

            }

            responseJsonValue["message"] = "查询成功！";

            responseJsonValue["success"] = "true";

            responseJsonValue["data"] = VssDomainUnitTblDao::instance()->findJsonArray(string("select * from ") + VSSDomainUnitTbl_TABLE_NAME + " where 1 = 1 limit 1");

        }

        return responseJsonValue.toStyledString();

    }



    /** 查找创建一级设备表列表 */

    std::string findVssDomainUnitTblList(std::string ip, unsigned int port, std::string content, PResponse &response) {

        Json::Reader requestJsonReader;

        Json::Value requestJsonValue;

        Json::Value responseJsonValue;

        responseJsonValue["message"] = "查询失败！";

        responseJsonValue["success"] = "false";

        if (content == "" || requestJsonReader.parse(content, requestJsonValue)) {

            VssDomainUnitTblBuilder vssDomainUnitTblBuilder;



            Json::Value iDJsonValue = requestJsonValue[VssDomainUnitTbl_ID];

            if (iDJsonValue.type() != Json::ValueType::nullValue) {

                vssDomainUnitTblBuilder.addID(std::stoi((iDJsonValue.asString())));

            }



            Json::Value devPubIDJsonValue = requestJsonValue[VssDomainUnitTbl_DevPubID];

            if (devPubIDJsonValue.type() != Json::ValueType::nullValue) {

                vssDomainUnitTblBuilder.addDevPubID((devPubIDJsonValue.asString()));

            }



            Json::Value domainPubIDJsonValue = requestJsonValue[VssDomainUnitTbl_DomainPubID];

            if (domainPubIDJsonValue.type() != Json::ValueType::nullValue) {

                vssDomainUnitTblBuilder.addDomainPubID((domainPubIDJsonValue.asString()));

            }



            Json::Value nameJsonValue = requestJsonValue[VssDomainUnitTbl_Name];

            if (nameJsonValue.type() != Json::ValueType::nullValue) {

                vssDomainUnitTblBuilder.addName((nameJsonValue.asString()));

            }



            Json::Value businessGroupIDJsonValue = requestJsonValue[VssDomainUnitTbl_BusinessGroupID];

            if (businessGroupIDJsonValue.type() != Json::ValueType::nullValue) {

                vssDomainUnitTblBuilder.addBusinessGroupID((businessGroupIDJsonValue.asString()));

            }



            Json::Value parentIdJsonValue = requestJsonValue[VssDomainUnitTbl_ParentId];

            if (parentIdJsonValue.type() != Json::ValueType::nullValue) {

                vssDomainUnitTblBuilder.addParentId((parentIdJsonValue.asString()));

            }



            Json::Value domainTypeJsonValue = requestJsonValue[VssDomainUnitTbl_DomainType];

            if (domainTypeJsonValue.type() != Json::ValueType::nullValue) {

                vssDomainUnitTblBuilder.addDomainType(std::stoi((domainTypeJsonValue.asString())));

            }



            Json::Value updateTimeJsonValue = requestJsonValue[VssDomainUnitTbl_UpdateTime];

            if (updateTimeJsonValue.type() != Json::ValueType::nullValue) {

                vssDomainUnitTblBuilder.addUpdateTime((updateTimeJsonValue.asString()));

            }

            responseJsonValue["message"] = "查询成功！";

            responseJsonValue["success"] = "true";

            responseJsonValue["data"] = VssDomainUnitTblDao::instance()->findJsonArray(string("select * from ") + VSSDomainUnitTbl_TABLE_NAME + " where 1 = 1");



        }

        return responseJsonValue.toStyledString();

    }

};













#endif //VSSDOMAINUNITTBL_CONTROLLER_H












 QiaoJiaSystem/DataManagerServer/vss/controller/VssLocalSettingTblController.h

New file
@@ -0,0 +1,298 @@
#ifndef VSSLOCALSETTINGTBL_CONTROLLER_H

#define VSSLOCALSETTINGTBL_CONTROLLER_H



#include <string>

#include <DataManagerServer/http_configserver.h>

#include "vss/dao/VssLocalSettingTblDao.h"

#include "vss/dao/VssLocalSettingTblSqliteDao.h"

#include "vss/model/VssLocalSettingTblBuilder.h"

#include "vss/model/VssLocalSettingTbl.h"

#include "VssBaseController.h"

#include <mysql++.h>



using namespace std;



/**

 * 本地国标配置

 */

class VssLocalSettingTblController : public VssBaseController {

private:

    /** 本地国标配置构造函数 */

    VssLocalSettingTblController() {}

public:

    /** 本地国标配置单例模式 */

    static VssLocalSettingTblController* instance() {

        static VssLocalSettingTblController instance;

        return &instance;

    }

public:

    /** 注册{label}http服务 */

    void registerHttpServices(HttpSrvRetRecieve& _HttpSrvRetRecieve) {



        _HttpSrvRetRecieve.setInfo("^/addVssLocalSettingTbl$", "POST",

                                   std::bind(&VssLocalSettingTblController::addVssLocalSettingTbl, this,

                                             std::placeholders::_1, std::placeholders::_2,

                                             std::placeholders::_3, std::placeholders::_4));

	
        _HttpSrvRetRecieve.setInfo("^/delVssLocalSettingTbl$", "POST",

                                   std::bind(&VssLocalSettingTblController::delVssLocalSettingTbl, this,

                                             std::placeholders::_1, std::placeholders::_2,

                                             std::placeholders::_3, std::placeholders::_4));

	
        _HttpSrvRetRecieve.setInfo("^/updateVssLocalSettingTbl$", "POST",

                                   std::bind(&VssLocalSettingTblController::updateVssLocalSettingTbl, this,

                                             std::placeholders::_1, std::placeholders::_2,

                                             std::placeholders::_3, std::placeholders::_4));

	
        _HttpSrvRetRecieve.setInfo("^/findVssLocalSettingTbl$", "POST",

                                   std::bind(&VssLocalSettingTblController::findVssLocalSettingTbl, this,

                                             std::placeholders::_1, std::placeholders::_2,

                                             std::placeholders::_3, std::placeholders::_4));

	
        _HttpSrvRetRecieve.setInfo("^/findVssLocalSettingTblList$", "POST",

                                   std::bind(&VssLocalSettingTblController::findVssLocalSettingTblList, this,

                                             std::placeholders::_1, std::placeholders::_2,

                                             std::placeholders::_3, std::placeholders::_4));



    }

public:

    /** 添加本地国标配置 */

    std::string addVssLocalSettingTbl(std::string ip, unsigned int port, std::string content, PResponse &response) {

        Json::Reader requestJsonReader;

        Json::Value requestJsonValue;

        Json::Value responseJsonValue;

        responseJsonValue["message"] = "添加失败！";

        responseJsonValue["success"] = "false";

        if (requestJsonReader.parse(content, requestJsonValue)) {

            VssLocalSettingTblBuilder vssLocalSettingTblBuilder;

	    
            Json::Value iDJsonValue = requestJsonValue[VssLocalSettingTbl_ID];

            if (iDJsonValue.type() != Json::ValueType::nullValue) {

                vssLocalSettingTblBuilder.addID(std::stoi(iDJsonValue.asString()));

            }



            Json::Value serverIpJsonValue = requestJsonValue[VssLocalSettingTbl_ServerIp];

            if (serverIpJsonValue.type() != Json::ValueType::nullValue) {

                vssLocalSettingTblBuilder.addServerIp(serverIpJsonValue.asString());

            }



            Json::Value serverPortJsonValue = requestJsonValue[VssLocalSettingTbl_ServerPort];

            if (serverPortJsonValue.type() != Json::ValueType::nullValue) {

                vssLocalSettingTblBuilder.addServerPort(serverPortJsonValue.asString());

            }



            Json::Value serverIdJsonValue = requestJsonValue[VssLocalSettingTbl_ServerId];

            if (serverIdJsonValue.type() != Json::ValueType::nullValue) {

                vssLocalSettingTblBuilder.addServerId(serverIdJsonValue.asString());

            }



            Json::Value userAuthIdJsonValue = requestJsonValue[VssLocalSettingTbl_UserAuthId];

            if (userAuthIdJsonValue.type() != Json::ValueType::nullValue) {

                vssLocalSettingTblBuilder.addUserAuthId(userAuthIdJsonValue.asString());

            }



            Json::Value passwordJsonValue = requestJsonValue[VssLocalSettingTbl_Password];

            if (passwordJsonValue.type() != Json::ValueType::nullValue) {

                vssLocalSettingTblBuilder.addPassword(passwordJsonValue.asString());

            }



            Json::Value updateTimeJsonValue = requestJsonValue[VssLocalSettingTbl_UpdateTime];

            if (updateTimeJsonValue.type() != Json::ValueType::nullValue) {

                vssLocalSettingTblBuilder.addUpdateTime(updateTimeJsonValue.asString());

            }

            auto keyValuesToAdd = vssLocalSettingTblBuilder.buildVssLocalSettingTblMap();

            if (keyValuesToAdd.size() > 0) {

                responseJsonValue = VssLocalSettingTblSqliteDao::instance()->addVssLocalSettingTbl(keyValuesToAdd);

            }

        }

        return responseJsonValue.toStyledString();

    }



    /** 删除本地国标配置 */

    std::string delVssLocalSettingTbl(std::string ip, unsigned int port, std::string content, PResponse &response) {

        Json::Reader requestJsonReader;

        Json::Value requestJsonValue;

        Json::Value responseJsonValue;

        responseJsonValue["message"] = "删除失败！";

        responseJsonValue["success"] = "false";

        if (requestJsonReader.parse(content, requestJsonValue)) {

            Json::Value iDJsonValue = requestJsonValue[VssLocalSettingTbl_ID];

            if (iDJsonValue.type() != Json::ValueType::nullValue) {

                string iDValue = iDJsonValue.asString();

                responseJsonValue = VssLocalSettingTblSqliteDao::instance()->deleteByColumn("ID", iDValue);

            }



        }

        return responseJsonValue.toStyledString();

    }



    /** 更新本地国标配置 */

    std::string updateVssLocalSettingTbl(std::string ip, unsigned int port, std::string content, PResponse &response) {

        Json::Reader requestJsonReader;

        Json::Value requestJsonValue;

        Json::Value responseJsonValue;

        responseJsonValue["message"] = "更新失败！";

        responseJsonValue["success"] = "false";

        if (requestJsonReader.parse(content, requestJsonValue)) {

            VssLocalSettingTblBuilder vssLocalSettingTblBuilder;



            Json::Value iDJsonValue = requestJsonValue[VssLocalSettingTbl_ID];

            if (iDJsonValue.type() != Json::ValueType::nullValue) {

                vssLocalSettingTblBuilder.addID(std::stoi(iDJsonValue.asString()));

            }



            Json::Value serverIpJsonValue = requestJsonValue[VssLocalSettingTbl_ServerIp];

            if (serverIpJsonValue.type() != Json::ValueType::nullValue) {

                vssLocalSettingTblBuilder.addServerIp(serverIpJsonValue.asString());

            }



            Json::Value serverPortJsonValue = requestJsonValue[VssLocalSettingTbl_ServerPort];

            if (serverPortJsonValue.type() != Json::ValueType::nullValue) {

                vssLocalSettingTblBuilder.addServerPort(serverPortJsonValue.asString());

            }



            Json::Value serverIdJsonValue = requestJsonValue[VssLocalSettingTbl_ServerId];

            if (serverIdJsonValue.type() != Json::ValueType::nullValue) {

                vssLocalSettingTblBuilder.addServerId(serverIdJsonValue.asString());

            }



            Json::Value userAuthIdJsonValue = requestJsonValue[VssLocalSettingTbl_UserAuthId];

            if (userAuthIdJsonValue.type() != Json::ValueType::nullValue) {

                vssLocalSettingTblBuilder.addUserAuthId(userAuthIdJsonValue.asString());

            }



            Json::Value passwordJsonValue = requestJsonValue[VssLocalSettingTbl_Password];

            if (passwordJsonValue.type() != Json::ValueType::nullValue) {

                vssLocalSettingTblBuilder.addPassword(passwordJsonValue.asString());

            }



            Json::Value updateTimeJsonValue = requestJsonValue[VssLocalSettingTbl_UpdateTime];

            if (updateTimeJsonValue.type() != Json::ValueType::nullValue) {

                vssLocalSettingTblBuilder.addUpdateTime(updateTimeJsonValue.asString());

            }

            if (iDJsonValue.type() != Json::ValueType::nullValue) {

                string iDValue = iDJsonValue.asString();

                if (iDValue.size() > 0 && VssLocalSettingTblSqliteDao::instance()->updateVssLocalSettingTbl(vssLocalSettingTblBuilder.buildVssLocalSettingTblMap(), "ID", iDValue)) {

                    responseJsonValue["success"] = "true";

                    responseJsonValue["message"] = "更新成功！";

                }

            }

        }

        return responseJsonValue.toStyledString();

    }



    /** 查找单个本地国标配置 */

    std::string findVssLocalSettingTbl(std::string ip, unsigned int port, std::string content, PResponse &response) {

        Json::Reader requestJsonReader;

        Json::Value requestJsonValue;

        Json::Value responseJsonValue;

        responseJsonValue["message"] = "查询失败！";

        responseJsonValue["success"] = "false";

        if (requestJsonReader.parse(content, requestJsonValue)) {

            VssLocalSettingTblBuilder vssLocalSettingTblBuilder;



            Json::Value iDJsonValue = requestJsonValue[VssLocalSettingTbl_ID];

            if (iDJsonValue.type() != Json::ValueType::nullValue) {

                vssLocalSettingTblBuilder.addID(std::stoi(iDJsonValue.asString()));

            }



            Json::Value serverIpJsonValue = requestJsonValue[VssLocalSettingTbl_ServerIp];

            if (serverIpJsonValue.type() != Json::ValueType::nullValue) {

                vssLocalSettingTblBuilder.addServerIp(serverIpJsonValue.asString());

            }



            Json::Value serverPortJsonValue = requestJsonValue[VssLocalSettingTbl_ServerPort];

            if (serverPortJsonValue.type() != Json::ValueType::nullValue) {

                vssLocalSettingTblBuilder.addServerPort(serverPortJsonValue.asString());

            }



            Json::Value serverIdJsonValue = requestJsonValue[VssLocalSettingTbl_ServerId];

            if (serverIdJsonValue.type() != Json::ValueType::nullValue) {

                vssLocalSettingTblBuilder.addServerId(serverIdJsonValue.asString());

            }



            Json::Value userAuthIdJsonValue = requestJsonValue[VssLocalSettingTbl_UserAuthId];

            if (userAuthIdJsonValue.type() != Json::ValueType::nullValue) {

                vssLocalSettingTblBuilder.addUserAuthId(userAuthIdJsonValue.asString());

            }



            Json::Value passwordJsonValue = requestJsonValue[VssLocalSettingTbl_Password];

            if (passwordJsonValue.type() != Json::ValueType::nullValue) {

                vssLocalSettingTblBuilder.addPassword(passwordJsonValue.asString());

            }



            Json::Value updateTimeJsonValue = requestJsonValue[VssLocalSettingTbl_UpdateTime];

            if (updateTimeJsonValue.type() != Json::ValueType::nullValue) {

                vssLocalSettingTblBuilder.addUpdateTime(updateTimeJsonValue.asString());

            }

            responseJsonValue["message"] = "查询成功！";

            responseJsonValue["success"] = "true";

            responseJsonValue["data"] = VssLocalSettingTblSqliteDao::instance()->findJsonArray(string("select * from ") + VSSLocalSettingTbl_TABLE_NAME + " where 1 = 1 limit 1");

        }

        return responseJsonValue.toStyledString();

    }



    /** 查找本地国标配置列表 */

    std::string findVssLocalSettingTblList(std::string ip, unsigned int port, std::string content, PResponse &response) {

        Json::Reader requestJsonReader;

        Json::Value requestJsonValue;

        Json::Value responseJsonValue;

        responseJsonValue["message"] = "查询失败！";

        responseJsonValue["success"] = "false";

        if (content == "" || requestJsonReader.parse(content, requestJsonValue)) {

            VssLocalSettingTblBuilder vssLocalSettingTblBuilder;



            Json::Value iDJsonValue = requestJsonValue[VssLocalSettingTbl_ID];

            if (iDJsonValue.type() != Json::ValueType::nullValue) {

                vssLocalSettingTblBuilder.addID(std::stoi(iDJsonValue.asString()));

            }

	    
            Json::Value serverIpJsonValue = requestJsonValue[VssLocalSettingTbl_ServerIp];

            if (serverIpJsonValue.type() != Json::ValueType::nullValue) {

                vssLocalSettingTblBuilder.addServerIp(serverIpJsonValue.asString());

            }

	    
            Json::Value serverPortJsonValue = requestJsonValue[VssLocalSettingTbl_ServerPort];

            if (serverPortJsonValue.type() != Json::ValueType::nullValue) {

                vssLocalSettingTblBuilder.addServerPort(serverPortJsonValue.asString());

            }

	    
            Json::Value serverIdJsonValue = requestJsonValue[VssLocalSettingTbl_ServerId];

            if (serverIdJsonValue.type() != Json::ValueType::nullValue) {

                vssLocalSettingTblBuilder.addServerId(serverIdJsonValue.asString());

            }

	    
            Json::Value userAuthIdJsonValue = requestJsonValue[VssLocalSettingTbl_UserAuthId];

            if (userAuthIdJsonValue.type() != Json::ValueType::nullValue) {

                vssLocalSettingTblBuilder.addUserAuthId(userAuthIdJsonValue.asString());

            }

	    
            Json::Value passwordJsonValue = requestJsonValue[VssLocalSettingTbl_Password];

            if (passwordJsonValue.type() != Json::ValueType::nullValue) {

                vssLocalSettingTblBuilder.addPassword(passwordJsonValue.asString());

            }

	    
            Json::Value updateTimeJsonValue = requestJsonValue[VssLocalSettingTbl_UpdateTime];

            if (updateTimeJsonValue.type() != Json::ValueType::nullValue) {

                vssLocalSettingTblBuilder.addUpdateTime(updateTimeJsonValue.asString());

            }

            responseJsonValue["message"] = "查询成功！";

            responseJsonValue["success"] = "true";

            responseJsonValue = VssLocalSettingTblSqliteDao::instance()->findVssLocalSettingTblList(vssLocalSettingTblBuilder.buildVssLocalSettingTblMap());



        }

        return responseJsonValue.toStyledString();

    }

};













#endif //VSSLOCALSETTINGTBL_CONTROLLER_H












 QiaoJiaSystem/DataManagerServer/vss/controller/VssUpperSvrTblController.h

New file
@@ -0,0 +1,484 @@
#ifndef VSSUPPERSVRTBL_CONTROLLER_H

#define VSSUPPERSVRTBL_CONTROLLER_H



#include <string>

#include <DataManagerServer/http_configserver.h>

#include "vss/dao/VssUpperSvrTblDao.h"

#include "vss/model/VssUpperSvrTblBuilder.h"

#include "vss/model/VssUpperSvrTbl.h"

#include "VssBaseController.h"

#include <mysql++.h>



using namespace std;



/**

 * 创建上级平台服务器表

 */

class VssUpperSvrTblController : public VssBaseController {

private:

    /** 创建上级平台服务器表构造函数 */

    VssUpperSvrTblController() {}

public:

    /** 创建上级平台服务器表单例模式 */

    static VssUpperSvrTblController* instance() {

        static VssUpperSvrTblController instance;

        return &instance;

    }

public:

    /** 注册{label}http服务 */

    void registerHttpServices(HttpSrvRetRecieve& _HttpSrvRetRecieve) {



        _HttpSrvRetRecieve.setInfo("^/addVssUpperSvrTbl$", "POST",

                                   std::bind(&VssUpperSvrTblController::addVssUpperSvrTbl, this,

                                             std::placeholders::_1, std::placeholders::_2,

                                             std::placeholders::_3, std::placeholders::_4));



        _HttpSrvRetRecieve.setInfo("^/delVssUpperSvrTbl$", "POST",

                                   std::bind(&VssUpperSvrTblController::delVssUpperSvrTbl, this,

                                             std::placeholders::_1, std::placeholders::_2,

                                             std::placeholders::_3, std::placeholders::_4));



        _HttpSrvRetRecieve.setInfo("^/updateVssUpperSvrTbl$", "POST",

                                   std::bind(&VssUpperSvrTblController::updateVssUpperSvrTbl, this,

                                             std::placeholders::_1, std::placeholders::_2,

                                             std::placeholders::_3, std::placeholders::_4));



        _HttpSrvRetRecieve.setInfo("^/findVssUpperSvrTbl$", "POST",

                                   std::bind(&VssUpperSvrTblController::findVssUpperSvrTbl, this,

                                             std::placeholders::_1, std::placeholders::_2,

                                             std::placeholders::_3, std::placeholders::_4));



        _HttpSrvRetRecieve.setInfo("^/findVssUpperSvrTblList$", "POST",

                                   std::bind(&VssUpperSvrTblController::findVssUpperSvrTblList, this,

                                             std::placeholders::_1, std::placeholders::_2,

                                             std::placeholders::_3, std::placeholders::_4));



    }

public:

    /** 添加创建上级平台服务器表 */

    std::string addVssUpperSvrTbl(std::string ip, unsigned int port, std::string content, PResponse &response) {

        Json::Reader requestJsonReader;

        Json::Value requestJsonValue;

        Json::Value responseJsonValue;

        responseJsonValue["message"] = "添加失败！";

        responseJsonValue["success"] = "false";

        if (requestJsonReader.parse(content, requestJsonValue)) {

            VssUpperSvrTblBuilder vssUpperSvrTblBuilder;



            Json::Value iDJsonValue = requestJsonValue[VssUpperSvrTbl_ID];

            if (iDJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addID(std::stoi((iDJsonValue.asString())));

            }



            Json::Value nameJsonValue = requestJsonValue[VssUpperSvrTbl_Name];

            if (nameJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addName((nameJsonValue.asString()));

            }



            Json::Value publicIDJsonValue = requestJsonValue[VssUpperSvrTbl_PublicID];

            if (publicIDJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addPublicID((publicIDJsonValue.asString()));

            }



            Json::Value authUsernameJsonValue = requestJsonValue[VssUpperSvrTbl_AuthUsername];

            if (authUsernameJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addAuthUsername((authUsernameJsonValue.asString()));

            }



            Json::Value authPasswdJsonValue = requestJsonValue[VssUpperSvrTbl_AuthPasswd];

            if (authPasswdJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addAuthPasswd((authPasswdJsonValue.asString()));

            }



            Json::Value domainJsonValue = requestJsonValue[VssUpperSvrTbl_Domain];

            if (domainJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addDomain((domainJsonValue.asString()));

            }



            Json::Value iPJsonValue = requestJsonValue[VssUpperSvrTbl_IP];

            if (iPJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addIP((iPJsonValue.asString()));

            }



            Json::Value portJsonValue = requestJsonValue[VssUpperSvrTbl_Port];

            if (portJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addPort(std::stoi((portJsonValue.asString())));

            }



            Json::Value registerTimeJsonValue = requestJsonValue[VssUpperSvrTbl_RegisterTime];

            if (registerTimeJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addRegisterTime(std::stoi((registerTimeJsonValue.asString())));

            }



            Json::Value keepAliveTimeJsonValue = requestJsonValue[VssUpperSvrTbl_KeepAliveTime];

            if (keepAliveTimeJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addKeepAliveTime(std::stoi((keepAliveTimeJsonValue.asString())));

            }



            Json::Value aliveJsonValue = requestJsonValue[VssUpperSvrTbl_Alive];

            if (aliveJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addAlive(std::stoi((aliveJsonValue.asString())));

            }



            Json::Value isSyncTimeJsonValue = requestJsonValue[VssUpperSvrTbl_IsSyncTime];

            if (isSyncTimeJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addIsSyncTime(std::stoi((isSyncTimeJsonValue.asString())));

            }



            Json::Value pushProtocolJsonValue = requestJsonValue[VssUpperSvrTbl_PushProtocol];

            if (pushProtocolJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addPushProtocol(std::stoi((pushProtocolJsonValue.asString())));

            }



            Json::Value platformInfoJsonValue = requestJsonValue[VssUpperSvrTbl_PlatformInfo];

            if (platformInfoJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addPlatformInfo(std::stoi((platformInfoJsonValue.asString())));

            }



            Json::Value isEnableJsonValue = requestJsonValue[VssUpperSvrTbl_IsEnable];

            if (isEnableJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addIsEnable(std::stoi((isEnableJsonValue.asString())));

            }



            Json::Value updateTimeJsonValue = requestJsonValue[VssUpperSvrTbl_UpdateTime];

            if (updateTimeJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addUpdateTime((updateTimeJsonValue.asString()));

            }

            auto keyValuesToAdd = vssUpperSvrTblBuilder.buildVssUpperSvrTblMap();

            if (keyValuesToAdd.size() > 0) {

                mysqlpp::SimpleResult addVssUpperSvrTblResult = VssUpperSvrTblDao::instance()->addVssUpperSvrTbl(keyValuesToAdd);

                if (addVssUpperSvrTblResult.rows() > 0) {

                    responseJsonValue["success"] = "true";

                    responseJsonValue["message"] = "添加成功！";

                }

            }

        }

        return responseJsonValue.toStyledString();

    }



    /** 删除创建上级平台服务器表 */

    std::string delVssUpperSvrTbl(std::string ip, unsigned int port, std::string content, PResponse &response) {

        Json::Reader requestJsonReader;

        Json::Value requestJsonValue;

        Json::Value responseJsonValue;

        responseJsonValue["message"] = "删除失败！";

        responseJsonValue["success"] = "false";

        if (requestJsonReader.parse(content, requestJsonValue)) {

            Json::Value iDJsonValue = requestJsonValue[VssUpperSvrTbl_ID];

            if (iDJsonValue.type() != Json::ValueType::nullValue) {

                string iDValue = iDJsonValue.asString();

                if (iDValue.size() > 0 && VssUpperSvrTblDao::instance()->deleteByColumn("ID", iDValue)) {

                    responseJsonValue["success"] = "true";

                    responseJsonValue["message"] = "删除成功!";

                }

            }



        }

        return responseJsonValue.toStyledString();

    }



    /** 更新创建上级平台服务器表 */

    std::string updateVssUpperSvrTbl(std::string ip, unsigned int port, std::string content, PResponse &response) {

        Json::Reader requestJsonReader;

        Json::Value requestJsonValue;

        Json::Value responseJsonValue;

        responseJsonValue["message"] = "更新失败！";

        responseJsonValue["success"] = "false";

        if (requestJsonReader.parse(content, requestJsonValue)) {

            VssUpperSvrTblBuilder vssUpperSvrTblBuilder;



            Json::Value iDJsonValue = requestJsonValue[VssUpperSvrTbl_ID];

            if (iDJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addID(std::stoi((iDJsonValue.asString())));

            }



            Json::Value nameJsonValue = requestJsonValue[VssUpperSvrTbl_Name];

            if (nameJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addName((nameJsonValue.asString()));

            }



            Json::Value publicIDJsonValue = requestJsonValue[VssUpperSvrTbl_PublicID];

            if (publicIDJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addPublicID((publicIDJsonValue.asString()));

            }



            Json::Value authUsernameJsonValue = requestJsonValue[VssUpperSvrTbl_AuthUsername];

            if (authUsernameJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addAuthUsername((authUsernameJsonValue.asString()));

            }



            Json::Value authPasswdJsonValue = requestJsonValue[VssUpperSvrTbl_AuthPasswd];

            if (authPasswdJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addAuthPasswd((authPasswdJsonValue.asString()));

            }



            Json::Value domainJsonValue = requestJsonValue[VssUpperSvrTbl_Domain];

            if (domainJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addDomain((domainJsonValue.asString()));

            }



            Json::Value iPJsonValue = requestJsonValue[VssUpperSvrTbl_IP];

            if (iPJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addIP((iPJsonValue.asString()));

            }



            Json::Value portJsonValue = requestJsonValue[VssUpperSvrTbl_Port];

            if (portJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addPort(std::stoi((portJsonValue.asString())));

            }



            Json::Value registerTimeJsonValue = requestJsonValue[VssUpperSvrTbl_RegisterTime];

            if (registerTimeJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addRegisterTime(std::stoi((registerTimeJsonValue.asString())));

            }



            Json::Value keepAliveTimeJsonValue = requestJsonValue[VssUpperSvrTbl_KeepAliveTime];

            if (keepAliveTimeJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addKeepAliveTime(std::stoi((keepAliveTimeJsonValue.asString())));

            }



            Json::Value aliveJsonValue = requestJsonValue[VssUpperSvrTbl_Alive];

            if (aliveJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addAlive(std::stoi((aliveJsonValue.asString())));

            }



            Json::Value isSyncTimeJsonValue = requestJsonValue[VssUpperSvrTbl_IsSyncTime];

            if (isSyncTimeJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addIsSyncTime(std::stoi((isSyncTimeJsonValue.asString())));

            }



            Json::Value pushProtocolJsonValue = requestJsonValue[VssUpperSvrTbl_PushProtocol];

            if (pushProtocolJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addPushProtocol(std::stoi((pushProtocolJsonValue.asString())));

            }



            Json::Value platformInfoJsonValue = requestJsonValue[VssUpperSvrTbl_PlatformInfo];

            if (platformInfoJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addPlatformInfo(std::stoi((platformInfoJsonValue.asString())));

            }



            Json::Value isEnableJsonValue = requestJsonValue[VssUpperSvrTbl_IsEnable];

            if (isEnableJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addIsEnable(std::stoi((isEnableJsonValue.asString())));

            }



            Json::Value updateTimeJsonValue = requestJsonValue[VssUpperSvrTbl_UpdateTime];

            if (updateTimeJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addUpdateTime((updateTimeJsonValue.asString()));

            }

            if (iDJsonValue.type() != Json::ValueType::nullValue) {

                string iDValue = iDJsonValue.asString();

                if (iDValue.size() > 0 && VssUpperSvrTblDao::instance()->updateVssUpperSvrTbl(vssUpperSvrTblBuilder.buildVssUpperSvrTblMap(), "ID", iDValue)) {

                    responseJsonValue["success"] = "true";

                    responseJsonValue["message"] = "更新成功！";

                }

            }

        }

        return responseJsonValue.toStyledString();

    }



    /** 查找单个创建上级平台服务器表 */

    std::string findVssUpperSvrTbl(std::string ip, unsigned int port, std::string content, PResponse &response) {

        Json::Reader requestJsonReader;

        Json::Value requestJsonValue;

        Json::Value responseJsonValue;

        responseJsonValue["message"] = "查询失败！";

        responseJsonValue["success"] = "false";

        if (requestJsonReader.parse(content, requestJsonValue)) {

            VssUpperSvrTblBuilder vssUpperSvrTblBuilder;



            Json::Value iDJsonValue = requestJsonValue[VssUpperSvrTbl_ID];

            if (iDJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addID(std::stoi((iDJsonValue.asString())));

            }



            Json::Value nameJsonValue = requestJsonValue[VssUpperSvrTbl_Name];

            if (nameJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addName((nameJsonValue.asString()));

            }



            Json::Value publicIDJsonValue = requestJsonValue[VssUpperSvrTbl_PublicID];

            if (publicIDJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addPublicID((publicIDJsonValue.asString()));

            }



            Json::Value authUsernameJsonValue = requestJsonValue[VssUpperSvrTbl_AuthUsername];

            if (authUsernameJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addAuthUsername((authUsernameJsonValue.asString()));

            }



            Json::Value authPasswdJsonValue = requestJsonValue[VssUpperSvrTbl_AuthPasswd];

            if (authPasswdJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addAuthPasswd((authPasswdJsonValue.asString()));

            }



            Json::Value domainJsonValue = requestJsonValue[VssUpperSvrTbl_Domain];

            if (domainJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addDomain((domainJsonValue.asString()));

            }



            Json::Value iPJsonValue = requestJsonValue[VssUpperSvrTbl_IP];

            if (iPJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addIP((iPJsonValue.asString()));

            }



            Json::Value portJsonValue = requestJsonValue[VssUpperSvrTbl_Port];

            if (portJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addPort(std::stoi((portJsonValue.asString())));

            }



            Json::Value registerTimeJsonValue = requestJsonValue[VssUpperSvrTbl_RegisterTime];

            if (registerTimeJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addRegisterTime(std::stoi((registerTimeJsonValue.asString())));

            }



            Json::Value keepAliveTimeJsonValue = requestJsonValue[VssUpperSvrTbl_KeepAliveTime];

            if (keepAliveTimeJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addKeepAliveTime(std::stoi((keepAliveTimeJsonValue.asString())));

            }



            Json::Value aliveJsonValue = requestJsonValue[VssUpperSvrTbl_Alive];

            if (aliveJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addAlive(std::stoi((aliveJsonValue.asString())));

            }



            Json::Value isSyncTimeJsonValue = requestJsonValue[VssUpperSvrTbl_IsSyncTime];

            if (isSyncTimeJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addIsSyncTime(std::stoi((isSyncTimeJsonValue.asString())));

            }



            Json::Value pushProtocolJsonValue = requestJsonValue[VssUpperSvrTbl_PushProtocol];

            if (pushProtocolJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addPushProtocol(std::stoi((pushProtocolJsonValue.asString())));

            }



            Json::Value platformInfoJsonValue = requestJsonValue[VssUpperSvrTbl_PlatformInfo];

            if (platformInfoJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addPlatformInfo(std::stoi((platformInfoJsonValue.asString())));

            }



            Json::Value isEnableJsonValue = requestJsonValue[VssUpperSvrTbl_IsEnable];

            if (isEnableJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addIsEnable(std::stoi((isEnableJsonValue.asString())));

            }



            Json::Value updateTimeJsonValue = requestJsonValue[VssUpperSvrTbl_UpdateTime];

            if (updateTimeJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addUpdateTime((updateTimeJsonValue.asString()));

            }

            responseJsonValue["message"] = "查询成功！";

            responseJsonValue["success"] = "true";

            responseJsonValue["data"] = VssUpperSvrTblDao::instance()->findJsonArray(string("select * from ") + VSSUpperSvrTbl_TABLE_NAME + " where 1 = 1 limit 1");

        }

        return responseJsonValue.toStyledString();

    }



    /** 查找创建上级平台服务器表列表 */

    std::string findVssUpperSvrTblList(std::string ip, unsigned int port, std::string content, PResponse &response) {

        Json::Reader requestJsonReader;

        Json::Value requestJsonValue;

        Json::Value responseJsonValue;

        responseJsonValue["message"] = "查询失败！";

        responseJsonValue["success"] = "false";

        if (content == "" || requestJsonReader.parse(content, requestJsonValue)) {

            VssUpperSvrTblBuilder vssUpperSvrTblBuilder;



            Json::Value iDJsonValue = requestJsonValue[VssUpperSvrTbl_ID];

            if (iDJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addID(std::stoi((iDJsonValue.asString())));

            }



            Json::Value nameJsonValue = requestJsonValue[VssUpperSvrTbl_Name];

            if (nameJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addName((nameJsonValue.asString()));

            }



            Json::Value publicIDJsonValue = requestJsonValue[VssUpperSvrTbl_PublicID];

            if (publicIDJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addPublicID((publicIDJsonValue.asString()));

            }



            Json::Value authUsernameJsonValue = requestJsonValue[VssUpperSvrTbl_AuthUsername];

            if (authUsernameJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addAuthUsername((authUsernameJsonValue.asString()));

            }



            Json::Value authPasswdJsonValue = requestJsonValue[VssUpperSvrTbl_AuthPasswd];

            if (authPasswdJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addAuthPasswd((authPasswdJsonValue.asString()));

            }



            Json::Value domainJsonValue = requestJsonValue[VssUpperSvrTbl_Domain];

            if (domainJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addDomain((domainJsonValue.asString()));

            }



            Json::Value iPJsonValue = requestJsonValue[VssUpperSvrTbl_IP];

            if (iPJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addIP((iPJsonValue.asString()));

            }



            Json::Value portJsonValue = requestJsonValue[VssUpperSvrTbl_Port];

            if (portJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addPort(std::stoi((portJsonValue.asString())));

            }



            Json::Value registerTimeJsonValue = requestJsonValue[VssUpperSvrTbl_RegisterTime];

            if (registerTimeJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addRegisterTime(std::stoi((registerTimeJsonValue.asString())));

            }



            Json::Value keepAliveTimeJsonValue = requestJsonValue[VssUpperSvrTbl_KeepAliveTime];

            if (keepAliveTimeJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addKeepAliveTime(std::stoi((keepAliveTimeJsonValue.asString())));

            }



            Json::Value aliveJsonValue = requestJsonValue[VssUpperSvrTbl_Alive];

            if (aliveJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addAlive(std::stoi((aliveJsonValue.asString())));

            }



            Json::Value isSyncTimeJsonValue = requestJsonValue[VssUpperSvrTbl_IsSyncTime];

            if (isSyncTimeJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addIsSyncTime(std::stoi((isSyncTimeJsonValue.asString())));

            }



            Json::Value pushProtocolJsonValue = requestJsonValue[VssUpperSvrTbl_PushProtocol];

            if (pushProtocolJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addPushProtocol(std::stoi((pushProtocolJsonValue.asString())));

            }



            Json::Value platformInfoJsonValue = requestJsonValue[VssUpperSvrTbl_PlatformInfo];

            if (platformInfoJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addPlatformInfo(std::stoi((platformInfoJsonValue.asString())));

            }



            Json::Value isEnableJsonValue = requestJsonValue[VssUpperSvrTbl_IsEnable];

            if (isEnableJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addIsEnable(std::stoi((isEnableJsonValue.asString())));

            }



            Json::Value updateTimeJsonValue = requestJsonValue[VssUpperSvrTbl_UpdateTime];

            if (updateTimeJsonValue.type() != Json::ValueType::nullValue) {

                vssUpperSvrTblBuilder.addUpdateTime((updateTimeJsonValue.asString()));

            }

            responseJsonValue["message"] = "查询成功！";

            responseJsonValue["success"] = "true";

            responseJsonValue["data"] = VssUpperSvrTblDao::instance()->findJsonArray(string("select * from ") + VSSUpperSvrTbl_TABLE_NAME + " where 1 = 1");



        }

        return responseJsonValue.toStyledString();

    }

};













#endif //VSSUPPERSVRTBL_CONTROLLER_H












 QiaoJiaSystem/DataManagerServer/vss/dao/BaseDao.h

New file
@@ -0,0 +1,218 @@

#ifndef BASIC_BUSINESS_TABLE_BASEMANAGER_H
#define BASIC_BUSINESS_TABLE_BASEMANAGER_H

#include <list>
#include <vector>
#include <string>
#include <iostream>
#include <mysql++.h>
#include <AppConfig.h>

using namespace std;

static mysqlpp::Connection* conn;
class BaseDao {
public:
    static mysqlpp::SimpleResult add(std::map<std::string, std::string>& columns, string tableName) {
        initConnection();
        mysqlpp::SimpleResult simpleResult;
        try {
            mysqlpp::Query query = conn->query(getInsertSql(columns, tableName));
            simpleResult = query.execute();
            if (simpleResult.insert_id() <= 0) {
                cout << "add error " << query.error() << endl;
            }
        } catch (exception &e) {
            cout << e.what() << endl;
        }
        return simpleResult;
    }
    static bool del(string tableName, std::map<std::string, std::string>& whereColumns) {
        initConnection();
        string sql = "DELETE FROM " + tableName + " where 1=1 " + getWhereColumnNameValuePair(whereColumns);
        mysqlpp::Query query = conn->query(sql);
        bool ret = query.exec();
        if (!ret) {
            cout << "error " <<query.error() << endl;
        }
        return ret;
    }
    static bool update(std::map<std::string, std::string>& columns, string tableName, std::map<std::string, std::string>& whereColumns) {
        string updateSql = getUpdateSql(columns, tableName, whereColumns);
        initConnection();
        mysqlpp::Query query = conn->query(updateSql);
        bool ret = query.exec();
        if (!ret) {
            cout << "add error " << query.error() << endl;
        }
        return ret;
    }

    static vector<map<string, string>> findList(string sql) {
        initConnection();
        vector<map<string, string>> rowDataList;
        mysqlpp::Query query = conn->query(sql);
        if (auto res = query.store()) {
            for (auto it = res.begin(); it != res.end(); ++it) {
                map<string, string> rowData;
                mysqlpp::Row row = *it;
                auto field_list = row.field_list();
                const mysqlpp::FieldNames* fieldNames = field_list.list;
                for (int i = 0; i < fieldNames->size(); i++) {
                    string columnValue;
                    row[i].to_string(columnValue);
                    string columnName = fieldNames[0].at(i);
                    rowData[columnName] = columnValue;
                }
                rowDataList.emplace_back(rowData);
            }
        } else {
            cout << "query failed" << endl;
        }
        return rowDataList;
    }

    static Json::Value findJsonArray(string sql) {
        initConnection();
        mysqlpp::Query query = conn->query(sql);
        Json::Value rowList;
        if (auto res = query.store()) {
            for (auto it = res.begin(); it != res.end(); ++it) {
                Json::Value row;
                const mysqlpp::FieldNames* fieldNames = it->field_list().list;
                for (int i = 0; i < fieldNames->size(); i++) {
                    string columnValue;
                    (*it)[i].to_string(columnValue);
                    if (columnValue == "NULL") {
                        columnValue = "";
                    }
                    string columnName = fieldNames[0].at(i);
                    row[columnName] = columnValue;
                }
                rowList.append(row);
            }
        } else {
            cout << "query failed" << endl;
        }
        return rowList;
    }

    static bool exec(string sql) {
        initConnection();
        mysqlpp::Query query = conn->query(sql);
        bool ret = query.exec();
        if (!ret) {
            cout << "error " <<query.error() << endl;
        }
        return ret;
    }
    static string getInsertSql(std::map<std::string, std::string>& columns, string tableName) {
        string insertSql = "INSERT INTO "+tableName+" ("
                           + getColumnNames(columns) +
                           " ) values ( "
                           + getColumnValues(columns) +
                           " )";
        cout << "insertSql " << insertSql << endl;
        return insertSql;
    }
    static string getUpdateSql(std::map<std::string, std::string>& columns, string tableName, std::map<std::string, std::string>& whereColumns) {
        string updateSql = "update "+tableName+" set "
                           + getColumnNameValuePair(columns) +
                           " where 1=1 "+
                           getWhereColumnNameValuePair(whereColumns)
        ;
        cout << "updateSql " << updateSql << endl;
        return updateSql;
    }
    static void doConnect() {
        //            if (conn->connect(
//                    appConfig.getStringProperty("database").c_str(),
//                    appConfig.getStringProperty("db_host").c_str(),
//                    appConfig.getStringProperty("db_user").c_str(),
//                    appConfig.getStringProperty("db_password").c_str(),
//                    appConfig.getIntProperty("db_port")
//            )) {
        if (conn->connect(
                "basic_business_table",
                "127.0.0.1",
                "root",
                "root",
                3306
        )) {
            cout << "connect success" << endl;
        } else {
            cout << "connect failed" << endl;
        }
    }
    static void initConnection() {
        static bool inited = false;
        if (!inited) {
            inited = true;
            conn = new mysqlpp::Connection(false);
            doConnect();
        }
        if (!conn->connected() || !conn->ping()) {
            doConnect();
        }
    }
    static string getColumnNames(std::map<std::string, std::string>& columns) {
        string columnNames;
        auto size = columns.size();
        int i = 0;
        for (auto column : columns) {
            columnNames.append(column.first);
            if (i != size - 1) {
                columnNames.append(",");
            }
            i++;
        }
        return columnNames;
    }
    static string getColumnValues(std::map<std::string, std::string>& columns) {
        string columnValues;
        auto size = columns.size();
        int i = 0;
        for (auto column : columns) {
            columnValues.append("'"+column.second+"'");
            if (i != columns.size() - 1) {
                columnValues.append(",");
            }
            i++;
        }
        return columnValues;
    }
    static string getColumnNameValuePair(std::map<std::string, std::string>& columns) {
        string columnNameValuePair;
        auto size = columns.size();
        int i = 0;
        for (auto column : columns) {
            columnNameValuePair.append(column.first);
            columnNameValuePair.append("=");
            columnNameValuePair.append("'"+column.second+"'");

            if (i != size - 1) {
                columnNameValuePair.append(",");
            }
            i++;
        }
        return columnNameValuePair;
    }
    static string getWhereColumnNameValuePair(std::map<std::string, std::string>& columns) {
        string columnNameValuePair;
        auto size = columns.size();
        int i = 0;
        for (auto column : columns) {
            columnNameValuePair.append(" and ");
            columnNameValuePair.append(column.first);
            columnNameValuePair.append("=");
            columnNameValuePair.append("'"+column.second+"' ");

            i++;
        }
        return columnNameValuePair;
    }
};


#endif //BASIC_BUSINESS_TABLE_BASEMANAGER_H

 QiaoJiaSystem/DataManagerServer/vss/dao/VssChannelTblDao.h

New file
@@ -0,0 +1,190 @@


#ifndef VSSCHANNELTBL_MANAGER_H

#define VSSCHANNELTBL_MANAGER_H



#include "../model/VssChannelTbl.h"

#include "BaseDao.h"



#define VSSChannelTbl_TABLE_NAME "VSSChannelTbl"



/**

 * 创建二级设备表管理类

 */

class VssChannelTblDao : public BaseDao {

private:

    /** 创建二级设备表构造函数 */

    VssChannelTblDao() {}

public:

    /** 创建二级设备表单例模式 */

    static VssChannelTblDao* instance() {

        static VssChannelTblDao instance;

        return &instance;

    }

    
    /** 添加创建二级设备表 keyValuesToAdd 需要添加的列名和列值对map*/

    mysqlpp::SimpleResult addVssChannelTbl(std::map<std::string, std::string>& keyValuesToAdd) {

        return add(keyValuesToAdd, VSSChannelTbl_TABLE_NAME);

    }

    
    /** 删除创建二级设备表 whereKey 列名；whereValue 列值 */

    bool deleteByColumn(string whereKey, string whereValue) {

        std::map<std::string, std::string> whereKeyValues;

        whereKeyValues[whereKey] = whereValue;

        return deleteVssChannelTbl(whereKeyValues);

    }



    /** 删除创建二级设备表 whereColumnNameValues 列名和列值对条件 */

    bool deleteVssChannelTbl(std::map<std::string, std::string>& whereKeyValues) {

        return del(VSSChannelTbl_TABLE_NAME, whereKeyValues);

    }

    
    /** 更新创建二级设备表 keyValuesToUpdate 需要更新的列名和列值对； whereKeyValues 列名和列值条件 */

    bool updateVssChannelTbl(std::map<std::string, std::string>& keyValuesToUpdate, 
                                    std::map<std::string, std::string>& whereKeyValues) {

        return update(keyValuesToUpdate, VSSChannelTbl_TABLE_NAME, whereKeyValues);

    }

	
    /** 更新创建二级设备表 keyValuesToUpdate 需要更新的列名和列值对； whereKeyValues 列名和列值条件 */

    bool updateVssChannelTbl(std::map<std::string, std::string>& keyValuesToUpdate,

                             string whereKey,

                             string whereValue) {

        std::map<std::string, std::string> whereKeyValues;

        whereKeyValues[whereKey] = whereValue;

        return update(keyValuesToUpdate, VSSChannelTbl_TABLE_NAME, whereKeyValues);

    }

	
    /** 查询创建二级设备表列表  querySql 要查询的sql语句 */

    vector<VssChannelTbl> findVssChannelTblList(string querySql) {

        vector<VssChannelTbl> vssChannelTblVec;

        vector<map<string, string>> rowDatList = findList(querySql);

        vssChannelTblVec.reserve(rowDatList.size());

        for (auto rowData : rowDatList) {

            vssChannelTblVec.emplace_back(mapToModel(rowData));

        }

        return vssChannelTblVec;

    }

	
    /**查询创建二级设备表列表 whereKeyValues 列名和列值对条件 */

    vector<VssChannelTbl> findVssChannelTblList(std::map<std::string, std::string>& whereKeyValues) {

        return findVssChannelTblList(string("select * from ") + VSSChannelTbl_TABLE_NAME + " where 1=1 " + getWhereColumnNameValuePair(whereKeyValues));

    }

    
    /**查询所有创建二级设备表列表 */

    vector<VssChannelTbl> findAllVssChannelTblList() {

        return findVssChannelTblList(string("select * from ") + VSSChannelTbl_TABLE_NAME + " where 1=1 ");

    }

	
    /** 查询map列表 querySql 要查询的sql语句 */

    vector<map<string, string>> findMapList(string querySql) {

        return findList(querySql);

    }

    
    /** 执行sql语句 */

    bool execute(string sql) {

        return exec(move(sql));

    }

    
    /** map转model类 */

    VssChannelTbl mapToModel(map<string, string>& rowData) {

        VssChannelTbl vssChannelTbl;

        string IDValue = rowData[VssChannelTbl_ID];

        if (IDValue.length() != 0 && IDValue != "NULL") {

            vssChannelTbl.ID = std::stoi(IDValue);

        }

        string DevPubIDValue = rowData[VssChannelTbl_DevPubID];

        if (DevPubIDValue.length() != 0 && DevPubIDValue != "NULL") {

            vssChannelTbl.DevPubID = DevPubIDValue;

        }

        string NicknameValue = rowData[VssChannelTbl_Nickname];

        if (NicknameValue.length() != 0 && NicknameValue != "NULL") {

            vssChannelTbl.Nickname = NicknameValue;

        }

        string ChanPubIDValue = rowData[VssChannelTbl_ChanPubID];

        if (ChanPubIDValue.length() != 0 && ChanPubIDValue != "NULL") {

            vssChannelTbl.ChanPubID = ChanPubIDValue;

        }

        string AliveValue = rowData[VssChannelTbl_Alive];

        if (AliveValue.length() != 0 && AliveValue != "NULL") {

            vssChannelTbl.Alive = std::stoi(AliveValue);

        }

        string CorpIDValue = rowData[VssChannelTbl_CorpID];

        if (CorpIDValue.length() != 0 && CorpIDValue != "NULL") {

            vssChannelTbl.CorpID = CorpIDValue;

        }

        string ModelValue = rowData[VssChannelTbl_Model];

        if (ModelValue.length() != 0 && ModelValue != "NULL") {

            vssChannelTbl.Model = ModelValue;

        }

        string OwnerValue = rowData[VssChannelTbl_Owner];

        if (OwnerValue.length() != 0 && OwnerValue != "NULL") {

            vssChannelTbl.Owner = OwnerValue;

        }

        string CivilCodeValue = rowData[VssChannelTbl_CivilCode];

        if (CivilCodeValue.length() != 0 && CivilCodeValue != "NULL") {

            vssChannelTbl.CivilCode = CivilCodeValue;

        }

        string AddressValue = rowData[VssChannelTbl_Address];

        if (AddressValue.length() != 0 && AddressValue != "NULL") {

            vssChannelTbl.Address = AddressValue;

        }

        string ParentalValue = rowData[VssChannelTbl_Parental];

        if (ParentalValue.length() != 0 && ParentalValue != "NULL") {

            vssChannelTbl.Parental = std::stoi(ParentalValue);

        }

        string ParentIdValue = rowData[VssChannelTbl_ParentId];

        if (ParentIdValue.length() != 0 && ParentIdValue != "NULL") {

            vssChannelTbl.ParentId = ParentIdValue;

        }

        string IPValue = rowData[VssChannelTbl_IP];

        if (IPValue.length() != 0 && IPValue != "NULL") {

            vssChannelTbl.IP = IPValue;

        }

        string PortValue = rowData[VssChannelTbl_Port];

        if (PortValue.length() != 0 && PortValue != "NULL") {

            vssChannelTbl.Port = std::stoi(PortValue);

        }

        string LongitudeValue = rowData[VssChannelTbl_Longitude];

        if (LongitudeValue.length() != 0 && LongitudeValue != "NULL") {

            vssChannelTbl.Longitude = std::stod(LongitudeValue);

        }

        string LatitudeValue = rowData[VssChannelTbl_Latitude];

        if (LatitudeValue.length() != 0 && LatitudeValue != "NULL") {

            vssChannelTbl.Latitude = std::stod(LatitudeValue);

        }

        string AltitudeValue = rowData[VssChannelTbl_Altitude];

        if (AltitudeValue.length() != 0 && AltitudeValue != "NULL") {

            vssChannelTbl.Altitude = std::stod(AltitudeValue);

        }

        string PTZTypeValue = rowData[VssChannelTbl_PTZType];

        if (PTZTypeValue.length() != 0 && PTZTypeValue != "NULL") {

            vssChannelTbl.PTZType = std::stoi(PTZTypeValue);

        }

        string RoomTypeValue = rowData[VssChannelTbl_RoomType];

        if (RoomTypeValue.length() != 0 && RoomTypeValue != "NULL") {

            vssChannelTbl.RoomType = std::stoi(RoomTypeValue);

        }

        string DirectionTypeValue = rowData[VssChannelTbl_DirectionType];

        if (DirectionTypeValue.length() != 0 && DirectionTypeValue != "NULL") {

            vssChannelTbl.DirectionType = std::stoi(DirectionTypeValue);

        }

        string StreamTypeValue = rowData[VssChannelTbl_StreamType];

        if (StreamTypeValue.length() != 0 && StreamTypeValue != "NULL") {

            vssChannelTbl.StreamType = std::stoi(StreamTypeValue);

        }

        string DMarkerValue = rowData[VssChannelTbl_DMarker];

        if (DMarkerValue.length() != 0 && DMarkerValue != "NULL") {

            vssChannelTbl.DMarker = std::stoi(DMarkerValue);

        }

        string UpdateTimeValue = rowData[VssChannelTbl_UpdateTime];

        if (UpdateTimeValue.length() != 0 && UpdateTimeValue != "NULL") {

            vssChannelTbl.UpdateTime = UpdateTimeValue;

        }

        return vssChannelTbl;

    }

   
};





#endif //VSSCHANNELTBL_MANAGER_H






 QiaoJiaSystem/DataManagerServer/vss/dao/VssDevTblDao.h

New file
@@ -0,0 +1,142 @@


#ifndef VSSDEVTBL_MANAGER_H

#define VSSDEVTBL_MANAGER_H



#include "../model/VssDevTbl.h"

#include "BaseDao.h"



#define VSSDevTbl_TABLE_NAME "VSSDevTbl"



/**

 * 创建一级设备表管理类

 */

class VssDevTblDao : public BaseDao {

private:

    /** 创建一级设备表构造函数 */

    VssDevTblDao() {}

public:

    /** 创建一级设备表单例模式 */

    static VssDevTblDao* instance() {

        static VssDevTblDao instance;

        return &instance;

    }

    
    /** 添加创建一级设备表 keyValuesToAdd 需要添加的列名和列值对map*/

    mysqlpp::SimpleResult addVssDevTbl(std::map<std::string, std::string>& keyValuesToAdd) {

        return add(keyValuesToAdd, VSSDevTbl_TABLE_NAME);

    }

    
    /** 删除创建一级设备表 whereKey 列名；whereValue 列值 */

    bool deleteByColumn(string whereKey, string whereValue) {

        std::map<std::string, std::string> whereKeyValues;

        whereKeyValues[whereKey] = whereValue;

        return deleteVssDevTbl(whereKeyValues);

    }



    /** 删除创建一级设备表 whereColumnNameValues 列名和列值对条件 */

    bool deleteVssDevTbl(std::map<std::string, std::string>& whereKeyValues) {

        return del(VSSDevTbl_TABLE_NAME, whereKeyValues);

    }

    
    /** 更新创建一级设备表 keyValuesToUpdate 需要更新的列名和列值对； whereKeyValues 列名和列值条件 */

    bool updateVssDevTbl(std::map<std::string, std::string>& keyValuesToUpdate, 
                                    std::map<std::string, std::string>& whereKeyValues) {

        return update(keyValuesToUpdate, VSSDevTbl_TABLE_NAME, whereKeyValues);

    }

	
    /** 更新创建二级设备表 keyValuesToUpdate 需要更新的列名和列值对； whereKeyValues 列名和列值条件 */

    bool updateVssDevTbl(std::map<std::string, std::string>& keyValuesToUpdate,

                             string whereKey,

                             string whereValue) {

        std::map<std::string, std::string> whereKeyValues;

        whereKeyValues[whereKey] = whereValue;

        return update(keyValuesToUpdate, VSSDevTbl_TABLE_NAME, whereKeyValues);

    }

	
    /** 查询创建一级设备表列表  querySql 要查询的sql语句 */

    vector<VssDevTbl> findVssDevTblList(string querySql) {

        vector<VssDevTbl> vssDevTblVec;

        vector<map<string, string>> rowDatList = findList(querySql);

        vssDevTblVec.reserve(rowDatList.size());

        for (auto rowData : rowDatList) {

            vssDevTblVec.emplace_back(mapToModel(rowData));

        }

        return vssDevTblVec;

    }

	
    /**查询创建一级设备表列表 whereKeyValues 列名和列值对条件 */

    vector<VssDevTbl> findVssDevTblList(std::map<std::string, std::string>& whereKeyValues) {

        return findVssDevTblList(string("select * from ") + VSSDevTbl_TABLE_NAME + " where 1=1 " + getWhereColumnNameValuePair(whereKeyValues));

    }

    
    /**查询所有创建一级设备表列表 */

    vector<VssDevTbl> findAllVssDevTblList() {

        return findVssDevTblList(string("select * from ") + VSSDevTbl_TABLE_NAME + " where 1=1 ");

    }

	
    /** 查询map列表 querySql 要查询的sql语句 */

    vector<map<string, string>> findMapList(string querySql) {

        return findList(querySql);

    }

    
    /** 执行sql语句 */

    bool execute(string sql) {

        return exec(move(sql));

    }

    
    /** map转model类 */

    VssDevTbl mapToModel(map<string, string>& rowData) {

        VssDevTbl vssDevTbl;

        string IDValue = rowData[VssDevTbl_ID];

        if (IDValue.length() != 0 && IDValue != "NULL") {

            vssDevTbl.ID = std::stoi(IDValue);

        }

        string DevPubIDValue = rowData[VssDevTbl_DevPubID];

        if (DevPubIDValue.length() != 0 && DevPubIDValue != "NULL") {

            vssDevTbl.DevPubID = DevPubIDValue;

        }

        string DevNicknameValue = rowData[VssDevTbl_DevNickname];

        if (DevNicknameValue.length() != 0 && DevNicknameValue != "NULL") {

            vssDevTbl.DevNickname = DevNicknameValue;

        }

        string UserNameValue = rowData[VssDevTbl_UserName];

        if (UserNameValue.length() != 0 && UserNameValue != "NULL") {

            vssDevTbl.UserName = UserNameValue;

        }

        string PasswdValue = rowData[VssDevTbl_Passwd];

        if (PasswdValue.length() != 0 && PasswdValue != "NULL") {

            vssDevTbl.Passwd = PasswdValue;

        }

        string CorpIDValue = rowData[VssDevTbl_CorpID];

        if (CorpIDValue.length() != 0 && CorpIDValue != "NULL") {

            vssDevTbl.CorpID = CorpIDValue;

        }

        string IPValue = rowData[VssDevTbl_IP];

        if (IPValue.length() != 0 && IPValue != "NULL") {

            vssDevTbl.IP = IPValue;

        }

        string PortValue = rowData[VssDevTbl_Port];

        if (PortValue.length() != 0 && PortValue != "NULL") {

            vssDevTbl.Port = std::stoi(PortValue);

        }

        string AliveValue = rowData[VssDevTbl_Alive];

        if (AliveValue.length() != 0 && AliveValue != "NULL") {

            vssDevTbl.Alive = std::stoi(AliveValue);

        }

        string DMarkerValue = rowData[VssDevTbl_DMarker];

        if (DMarkerValue.length() != 0 && DMarkerValue != "NULL") {

            vssDevTbl.DMarker = std::stoi(DMarkerValue);

        }

        string UpdateTimeValue = rowData[VssDevTbl_UpdateTime];

        if (UpdateTimeValue.length() != 0 && UpdateTimeValue != "NULL") {

            vssDevTbl.UpdateTime = UpdateTimeValue;

        }

        return vssDevTbl;

    }

   
};





#endif //VSSDEVTBL_MANAGER_H






 QiaoJiaSystem/DataManagerServer/vss/dao/VssDomainUnitTblDao.h

New file
@@ -0,0 +1,130 @@


#ifndef VSSDOMAINUNITTBL_MANAGER_H

#define VSSDOMAINUNITTBL_MANAGER_H



#include "../model/VssDomainUnitTbl.h"

#include "BaseDao.h"



#define VSSDomainUnitTbl_TABLE_NAME "VSSDomainUnitTbl"



/**

 * 创建一级设备表管理类

 */

class VssDomainUnitTblDao : public BaseDao {

private:

    /** 创建一级设备表构造函数 */

    VssDomainUnitTblDao() {}

public:

    /** 创建一级设备表单例模式 */

    static VssDomainUnitTblDao* instance() {

        static VssDomainUnitTblDao instance;

        return &instance;

    }

    
    /** 添加创建一级设备表 keyValuesToAdd 需要添加的列名和列值对map*/

    mysqlpp::SimpleResult addVssDomainUnitTbl(std::map<std::string, std::string>& keyValuesToAdd) {

        return add(keyValuesToAdd, VSSDomainUnitTbl_TABLE_NAME);

    }

    
    /** 删除创建一级设备表 whereKey 列名；whereValue 列值 */

    bool deleteByColumn(string whereKey, string whereValue) {

        std::map<std::string, std::string> whereKeyValues;

        whereKeyValues[whereKey] = whereValue;

        return deleteVssDomainUnitTbl(whereKeyValues);

    }



    /** 删除创建一级设备表 whereColumnNameValues 列名和列值对条件 */

    bool deleteVssDomainUnitTbl(std::map<std::string, std::string>& whereKeyValues) {

        return del(VSSDomainUnitTbl_TABLE_NAME, whereKeyValues);

    }

    
    /** 更新创建一级设备表 keyValuesToUpdate 需要更新的列名和列值对； whereKeyValues 列名和列值条件 */

    bool updateVssDomainUnitTbl(std::map<std::string, std::string>& keyValuesToUpdate, 
                                    std::map<std::string, std::string>& whereKeyValues) {

        return update(keyValuesToUpdate, VSSDomainUnitTbl_TABLE_NAME, whereKeyValues);

    }

	
    /** 更新创建二级设备表 keyValuesToUpdate 需要更新的列名和列值对； whereKeyValues 列名和列值条件 */

    bool updateVssDomainUnitTbl(std::map<std::string, std::string>& keyValuesToUpdate,

                             string whereKey,

                             string whereValue) {

        std::map<std::string, std::string> whereKeyValues;

        whereKeyValues[whereKey] = whereValue;

        return update(keyValuesToUpdate, VSSDomainUnitTbl_TABLE_NAME, whereKeyValues);

    }

	
    /** 查询创建一级设备表列表  querySql 要查询的sql语句 */

    vector<VssDomainUnitTbl> findVssDomainUnitTblList(string querySql) {

        vector<VssDomainUnitTbl> vssDomainUnitTblVec;

        vector<map<string, string>> rowDatList = findList(querySql);

        vssDomainUnitTblVec.reserve(rowDatList.size());

        for (auto rowData : rowDatList) {

            vssDomainUnitTblVec.emplace_back(mapToModel(rowData));

        }

        return vssDomainUnitTblVec;

    }

	
    /**查询创建一级设备表列表 whereKeyValues 列名和列值对条件 */

    vector<VssDomainUnitTbl> findVssDomainUnitTblList(std::map<std::string, std::string>& whereKeyValues) {

        return findVssDomainUnitTblList(string("select * from ") + VSSDomainUnitTbl_TABLE_NAME + " where 1=1 " + getWhereColumnNameValuePair(whereKeyValues));

    }

    
    /**查询所有创建一级设备表列表 */

    vector<VssDomainUnitTbl> findAllVssDomainUnitTblList() {

        return findVssDomainUnitTblList(string("select * from ") + VSSDomainUnitTbl_TABLE_NAME + " where 1=1 ");

    }

	
    /** 查询map列表 querySql 要查询的sql语句 */

    vector<map<string, string>> findMapList(string querySql) {

        return findList(querySql);

    }

    
    /** 执行sql语句 */

    bool execute(string sql) {

        return exec(move(sql));

    }

    
    /** map转model类 */

    VssDomainUnitTbl mapToModel(map<string, string>& rowData) {

        VssDomainUnitTbl vssDomainUnitTbl;

        string IDValue = rowData[VssDomainUnitTbl_ID];

        if (IDValue.length() != 0 && IDValue != "NULL") {

            vssDomainUnitTbl.ID = std::stoi(IDValue);

        }

        string DevPubIDValue = rowData[VssDomainUnitTbl_DevPubID];

        if (DevPubIDValue.length() != 0 && DevPubIDValue != "NULL") {

            vssDomainUnitTbl.DevPubID = DevPubIDValue;

        }

        string DomainPubIDValue = rowData[VssDomainUnitTbl_DomainPubID];

        if (DomainPubIDValue.length() != 0 && DomainPubIDValue != "NULL") {

            vssDomainUnitTbl.DomainPubID = DomainPubIDValue;

        }

        string NameValue = rowData[VssDomainUnitTbl_Name];

        if (NameValue.length() != 0 && NameValue != "NULL") {

            vssDomainUnitTbl.Name = NameValue;

        }

        string BusinessGroupIDValue = rowData[VssDomainUnitTbl_BusinessGroupID];

        if (BusinessGroupIDValue.length() != 0 && BusinessGroupIDValue != "NULL") {

            vssDomainUnitTbl.BusinessGroupID = BusinessGroupIDValue;

        }

        string ParentIdValue = rowData[VssDomainUnitTbl_ParentId];

        if (ParentIdValue.length() != 0 && ParentIdValue != "NULL") {

            vssDomainUnitTbl.ParentId = ParentIdValue;

        }

        string DomainTypeValue = rowData[VssDomainUnitTbl_DomainType];

        if (DomainTypeValue.length() != 0 && DomainTypeValue != "NULL") {

            vssDomainUnitTbl.DomainType = std::stoi(DomainTypeValue);

        }

        string UpdateTimeValue = rowData[VssDomainUnitTbl_UpdateTime];

        if (UpdateTimeValue.length() != 0 && UpdateTimeValue != "NULL") {

            vssDomainUnitTbl.UpdateTime = UpdateTimeValue;

        }

        return vssDomainUnitTbl;

    }

   
};





#endif //VSSDOMAINUNITTBL_MANAGER_H






 QiaoJiaSystem/DataManagerServer/vss/dao/VssLocalSettingTblDao.h

New file
@@ -0,0 +1,126 @@


#ifndef VSSLOCALSETTINGTBL_MANAGER_H

#define VSSLOCALSETTINGTBL_MANAGER_H



#include "../model/VssLocalSettingTbl.h"

#include "BaseDao.h"



#define VSSLocalSettingTbl_TABLE_NAME "VSSLocalSettingTbl"



/**

 * 本地国标配置管理类

 */

class VssLocalSettingTblDao : public BaseDao {

private:

    /** 本地国标配置构造函数 */

    VssLocalSettingTblDao() {}

public:

    /** 本地国标配置单例模式 */

    static VssLocalSettingTblDao* instance() {

        static VssLocalSettingTblDao instance;

        return &instance;

    }

    
    /** 添加本地国标配置 keyValuesToAdd 需要添加的列名和列值对map*/

    mysqlpp::SimpleResult addVssLocalSettingTbl(std::map<std::string, std::string>& keyValuesToAdd) {

        return add(keyValuesToAdd, VSSLocalSettingTbl_TABLE_NAME);

    }

    
    /** 删除本地国标配置 whereKey 列名；whereValue 列值 */

    bool deleteByColumn(string whereKey, string whereValue) {

        std::map<std::string, std::string> whereKeyValues;

        whereKeyValues[whereKey] = whereValue;

        return deleteVssLocalSettingTbl(whereKeyValues);

    }



    /** 删除本地国标配置 whereColumnNameValues 列名和列值对条件 */

    bool deleteVssLocalSettingTbl(std::map<std::string, std::string>& whereKeyValues) {

        return del(VSSLocalSettingTbl_TABLE_NAME, whereKeyValues);

    }

    
    /** 更新本地国标配置 keyValuesToUpdate 需要更新的列名和列值对； whereKeyValues 列名和列值条件 */

    bool updateVssLocalSettingTbl(std::map<std::string, std::string>& keyValuesToUpdate, 
                                    std::map<std::string, std::string>& whereKeyValues) {

        return update(keyValuesToUpdate, VSSLocalSettingTbl_TABLE_NAME, whereKeyValues);

    }

	
    /** 更新创建二级设备表 keyValuesToUpdate 需要更新的列名和列值对； whereKeyValues 列名和列值条件 */

    bool updateVssLocalSettingTbl(std::map<std::string, std::string>& keyValuesToUpdate,

                             string whereKey,

                             string whereValue) {

        std::map<std::string, std::string> whereKeyValues;

        whereKeyValues[whereKey] = whereValue;

        return update(keyValuesToUpdate, VSSLocalSettingTbl_TABLE_NAME, whereKeyValues);

    }

	
    /** 查询本地国标配置列表  querySql 要查询的sql语句 */

    vector<VssLocalSettingTbl> findVssLocalSettingTblList(string querySql) {

        vector<VssLocalSettingTbl> vssLocalSettingTblVec;

        vector<map<string, string>> rowDatList = findList(querySql);

        vssLocalSettingTblVec.reserve(rowDatList.size());

        for (auto rowData : rowDatList) {

            vssLocalSettingTblVec.emplace_back(mapToModel(rowData));

        }

        return vssLocalSettingTblVec;

    }

	
    /**查询本地国标配置列表 whereKeyValues 列名和列值对条件 */

    vector<VssLocalSettingTbl> findVssLocalSettingTblList(std::map<std::string, std::string>& whereKeyValues) {

        return findVssLocalSettingTblList(string("select * from ") + VSSLocalSettingTbl_TABLE_NAME + " where 1=1 " + getWhereColumnNameValuePair(whereKeyValues));

    }

    
    /**查询所有本地国标配置列表 */

    vector<VssLocalSettingTbl> findAllVssLocalSettingTblList() {

        return findVssLocalSettingTblList(string("select * from ") + VSSLocalSettingTbl_TABLE_NAME + " where 1=1 ");

    }

	
    /** 查询map列表 querySql 要查询的sql语句 */

    vector<map<string, string>> findMapList(string querySql) {

        return findList(querySql);

    }

    
    /** 执行sql语句 */

    bool execute(string sql) {

        return exec(move(sql));

    }

    
    /** map转model类 */

    VssLocalSettingTbl mapToModel(map<string, string>& rowData) {

        VssLocalSettingTbl vssLocalSettingTbl;

        string IDValue = rowData[VssLocalSettingTbl_ID];

        if (IDValue.length() != 0 && IDValue != "NULL") {

            vssLocalSettingTbl.ID = std::stoi(IDValue);

        }

        string ServerIpValue = rowData[VssLocalSettingTbl_ServerIp];

        if (ServerIpValue.length() != 0 && ServerIpValue != "NULL") {

            vssLocalSettingTbl.ServerIp = ServerIpValue;

        }

        string ServerPortValue = rowData[VssLocalSettingTbl_ServerPort];

        if (ServerPortValue.length() != 0 && ServerPortValue != "NULL") {

            vssLocalSettingTbl.ServerPort = ServerPortValue;

        }

        string ServerIdValue = rowData[VssLocalSettingTbl_ServerId];

        if (ServerIdValue.length() != 0 && ServerIdValue != "NULL") {

            vssLocalSettingTbl.ServerId = ServerIdValue;

        }

        string UserAuthIdValue = rowData[VssLocalSettingTbl_UserAuthId];

        if (UserAuthIdValue.length() != 0 && UserAuthIdValue != "NULL") {

            vssLocalSettingTbl.UserAuthId = UserAuthIdValue;

        }

        string PasswordValue = rowData[VssLocalSettingTbl_Password];

        if (PasswordValue.length() != 0 && PasswordValue != "NULL") {

            vssLocalSettingTbl.Password = PasswordValue;

        }

        string UpdateTimeValue = rowData[VssLocalSettingTbl_UpdateTime];

        if (UpdateTimeValue.length() != 0 && UpdateTimeValue != "NULL") {

            vssLocalSettingTbl.UpdateTime = UpdateTimeValue;

        }

        return vssLocalSettingTbl;

    }

   
};





#endif //VSSLOCALSETTINGTBL_MANAGER_H






 QiaoJiaSystem/DataManagerServer/vss/dao/VssLocalSettingTblSqliteDao.h

New file
@@ -0,0 +1,271 @@


#ifndef VSSLOCALSETTINGTBL_Sqlite_MANAGER_H

#define VSSLOCALSETTINGTBL_Sqlite_MANAGER_H



#include "../model/VssLocalSettingTbl.h"

#include "BaseDao.h"



#define VSSLocalSettingTbl_Sqlite_TABLE_NAME "VSSLocalSettingTbl"



#include <qsqlfield.h>

/**

 * 本地国标配置管理类

 */

class VssLocalSettingTblSqliteDao : public BaseDao {

private:

    /** 本地国标配置构造函数 */

    VssLocalSettingTblSqliteDao() {}

private:

    LDBTool* lDBTool;



    QSqlDatabase* m_db;

    QSqlTableModel *m_pModel;

    QMutex* m_mutexVisit;

public:

    void setLDBTool(LDBTool* lDBTool) {

        this->lDBTool = lDBTool;

        this->m_db = lDBTool->get_m_db();

        this->m_pModel = lDBTool->get_m_pModel();

        this->m_mutexVisit = lDBTool->get_m_mutexVisit();

    }

public:

    /** 本地国标配置单例模式 */

    static VssLocalSettingTblSqliteDao* instance() {

        static VssLocalSettingTblSqliteDao instance;

        return &instance;

    }



    /** 添加本地国标配置 keyValuesToAdd 需要添加的列名和列值对map*/

    Json::Value addVssLocalSettingTbl(std::map<std::string, std::string>& keyValuesToAdd) {

        Json::Value responseJsonValue;

        responseJsonValue["message"] = "添加失败！";

        responseJsonValue["success"] = "false";

        QMutexLocker mutexLocker(m_mutexVisit);//TODO

        QSqlTableModel pModel(NULL, *m_db);



        pModel.setTable(VSSLocalSettingTbl_Sqlite_TABLE_NAME);

        pModel.setEditStrategy(QSqlTableModel::OnManualSubmit);



        QSqlRecord rec = pModel.record();

        for (auto keyValueToAdd : keyValuesToAdd) {

            rec.setValue(QString::fromUtf8(keyValueToAdd.first.c_str()), QString::fromUtf8(keyValueToAdd.second.c_str()));

        }

        rec.setGenerated("ID", false);



        pModel.insertRecord(-1, rec);//TODO



        m_db->transaction();//开始事务操作



        if (pModel.submitAll()) {

            m_db->commit();//提交

            responseJsonValue["success"] = "true";

            responseJsonValue["message"] = "添加成功！";

        } else {

            m_db->rollback();//回滚

            ERR("addVssLocalSettingTbl err ,Database Error: " << pModel.lastError().text().toStdString());

        }

        return responseJsonValue;

    }



    /** 删除本地国标配置 whereKey 列名；whereValue 列值 */

    Json::Value deleteByColumn(string whereKey, string whereValue) {





        std::map<std::string, std::string> whereKeyValues;

        whereKeyValues[whereKey] = whereValue;

        return deleteVssLocalSettingTbl(whereKeyValues);

    }



    /** 删除本地国标配置 whereColumnNameValues 列名和列值对条件 */

    Json::Value deleteVssLocalSettingTbl(std::map<std::string, std::string>& whereKeyValues) {



        Json::Value responseJsonValue;

        responseJsonValue["message"] = "删除失败！";

        responseJsonValue["success"] = "false";

        QMutexLocker mutexLocker(m_mutexVisit);//TODO

        QSqlTableModel pModel(NULL, *m_db);

        pModel.setTable(VSSLocalSettingTbl_Sqlite_TABLE_NAME);

        for (auto whereKeyValue : whereKeyValues ) {

            pModel.setFilter(QObject::tr((string(whereKeyValue.first)+" = '%1'").c_str()).arg(QString::fromUtf8(whereKeyValue.second.c_str())));

        }

        pModel.setEditStrategy(QSqlTableModel::OnManualSubmit);//OnManualSubmit OnFieldChange

        pModel.select();



        int rowCount = pModel.rowCount();



        if (rowCount >= 1) {

            for (int i = 0; i < rowCount; i++) {

                pModel.removeRow(i);//TODO

            }

        } else {

            return responseJsonValue;

        }



        m_db->transaction();//开始事务操作



        if (pModel.submitAll()) {

            m_db->commit();//提交

            responseJsonValue["success"] = "true";

            responseJsonValue["message"] = "删除成功！";

        } else {

            m_db->rollback();//回滚

            ERR("deleteLDeviceTable ,pModel_load Error: " << pModel.lastError().text().toStdString());

        }



        return responseJsonValue;

    }



    /** 更新本地国标配置 keyValuesToUpdate 需要更新的列名和列值对； whereKeyValues 列名和列值条件 */

    Json::Value updateVssLocalSettingTbl(std::map<std::string, std::string>& keyValuesToUpdate,

                                    std::map<std::string, std::string>& whereKeyValues) {

        Json::Value responseJsonValue;

        responseJsonValue["message"] = "删除失败！";

        responseJsonValue["success"] = "false";

        QMutexLocker mutexLocker(m_mutexVisit);//TODO

        QSqlTableModel pModel(NULL, *m_db);

        pModel.setTable(VSSLocalSettingTbl_Sqlite_TABLE_NAME);

        for (auto whereKeyValue : whereKeyValues) {

            pModel.setFilter(QObject::tr((whereKeyValue.first + " = '%1'").c_str()).arg(QString::fromStdString(whereKeyValue.second)));

        }

        pModel.setEditStrategy(QSqlTableModel::OnManualSubmit);//OnManualSubmit OnFieldChange

        pModel.select();



        /*QSqlRecord rec =  pModel.record();

        rec.setValue("dst_path",QString::fromStdString(dst_path));

        rec.setValue("total",total);

        rec.setValue("finish_flag",1);

        rec.setValue("update_time",QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss"));*/



        int rowCount = pModel.rowCount();

        if (rowCount > 0) {

            QSqlRecord rec = pModel.record(0);

            for (auto keyValueToUpdate : keyValuesToUpdate) {

                rec.setValue(keyValueToUpdate.first.c_str(), keyValueToUpdate.second.c_str());

            }

//            rec.setValue("dst_path", QString::fromStdString(dst_path));

//            rec.setValue("total", total);

//            rec.setValue("finish_flag", 1);

            rec.setValue("UpdateTime", QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss"));



            pModel.setRecord(0, rec);

        } else {

            return responseJsonValue;

        }



        m_db->transaction();//开始事务操作



        if (pModel.submitAll()) {

            m_db->commit();//提交

            responseJsonValue["success"] = "true";

            responseJsonValue["message"] = "删除成功！";

        } else {

            m_db->rollback();//回滚

            ERR("updateLDeviceTable ,pModel_load Error: " << pModel.lastError().text().toStdString());

        }

        return responseJsonValue;

    }



    /** 更新创建二级设备表 keyValuesToUpdate 需要更新的列名和列值对； whereKeyValues 列名和列值条件 */

    bool updateVssLocalSettingTbl(std::map<std::string, std::string>& keyValuesToUpdate,

                             string whereKey,

                             string whereValue) {

        std::map<std::string, std::string> whereKeyValues;

        whereKeyValues[whereKey] = whereValue;

        return update(keyValuesToUpdate, VSSLocalSettingTbl_TABLE_NAME, whereKeyValues);

    }



    /** 查询本地国标配置列表  querySql 要查询的sql语句 */

    Json::Value findVssLocalSettingTblList(std::map<std::string, std::string>& whereKeyValues) {



        Json::Value responseJsonValue;

        responseJsonValue["message"] = "查询失败！";

        responseJsonValue["success"] = "false";

        responseJsonValue["data"] = Json::arrayValue;



        QMutexLocker mutexLocker(m_mutexVisit);//TODO

        std::list<Record_Cut_Video_info> lst;

        QSqlTableModel pModel(NULL, *m_db);

        pModel.setTable(VSSLocalSettingTbl_Sqlite_TABLE_NAME);;

        for (auto whereKeyValue : whereKeyValues ) {

            pModel.setFilter(QObject::tr((string(whereKeyValue.first)+" = '%1'").c_str()).arg(QString::fromUtf8(whereKeyValue.second.c_str())));

        }

        pModel.setEditStrategy(QSqlTableModel::OnManualSubmit);//OnManualSubmit OnFieldChange

        pModel.select();



        int rowCount = pModel.rowCount();

        if (rowCount > 0) {

            Json::Value rowDataList = Json::arrayValue;

            for (int i = 0; i < rowCount; ++i) {

                Json::Value rowData = Json::objectValue;

                Record_Cut_Video_info lRec;

                QSqlRecord rec = pModel.record(i);

                for (int i = 0; i < rec.count(); i++) {

                    QSqlField field = rec.field(i);

                    rowData[field.name().toStdString()] = field.value().toString().toStdString();

                }

                rowDataList.append(rowData);

            }

            responseJsonValue["data"] = rowDataList;

        }



        responseJsonValue["message"] = "查询成功！";

        responseJsonValue["success"] = "true";

        return responseJsonValue;

    }



    /**查询所有本地国标配置列表 */

    Json::Value findAllVssLocalSettingTblList() {

        std::map<std::string, std::string> whereKeyValues;

        return findVssLocalSettingTblList(whereKeyValues);

    }



    /** 查询map列表 querySql 要查询的sql语句 */

    vector<map<string, string>> findMapList(string querySql) {

        return findList(querySql);

    }



    /** 执行sql语句 */

    bool execute(string sql) {

        return exec(move(sql));

    }



    /** map转model类 */

    VssLocalSettingTbl mapToModel(map<string, string>& rowData) {

        VssLocalSettingTbl vssLocalSettingTbl;

        string IDValue = rowData[VssLocalSettingTbl_ID];

        if (IDValue.length() != 0 && IDValue != "NULL") {

            vssLocalSettingTbl.ID = std::stoi(IDValue);

        }

        string ServerIpValue = rowData[VssLocalSettingTbl_ServerIp];

        if (ServerIpValue.length() != 0 && ServerIpValue != "NULL") {

            vssLocalSettingTbl.ServerIp = ServerIpValue;

        }

        string ServerPortValue = rowData[VssLocalSettingTbl_ServerPort];

        if (ServerPortValue.length() != 0 && ServerPortValue != "NULL") {

            vssLocalSettingTbl.ServerPort = ServerPortValue;

        }

        string ServerIdValue = rowData[VssLocalSettingTbl_ServerId];

        if (ServerIdValue.length() != 0 && ServerIdValue != "NULL") {

            vssLocalSettingTbl.ServerId = ServerIdValue;

        }

        string UserAuthIdValue = rowData[VssLocalSettingTbl_UserAuthId];

        if (UserAuthIdValue.length() != 0 && UserAuthIdValue != "NULL") {

            vssLocalSettingTbl.UserAuthId = UserAuthIdValue;

        }

        string PasswordValue = rowData[VssLocalSettingTbl_Password];

        if (PasswordValue.length() != 0 && PasswordValue != "NULL") {

            vssLocalSettingTbl.Password = PasswordValue;

        }

        string UpdateTimeValue = rowData[VssLocalSettingTbl_UpdateTime];

        if (UpdateTimeValue.length() != 0 && UpdateTimeValue != "NULL") {

            vssLocalSettingTbl.UpdateTime = UpdateTimeValue;

        }

        return vssLocalSettingTbl;

    }



};





#endif //VSSLOCALSETTINGTBL_Sqlite_MANAGER_H






 QiaoJiaSystem/DataManagerServer/vss/dao/VssUpperSvrTblDao.h

New file
@@ -0,0 +1,162 @@


#ifndef VSSUPPERSVRTBL_MANAGER_H

#define VSSUPPERSVRTBL_MANAGER_H



#include "../model/VssUpperSvrTbl.h"

#include "BaseDao.h"



#define VSSUpperSvrTbl_TABLE_NAME "VSSUpperSvrTbl"



/**

 * 创建上级平台服务器表管理类

 */

class VssUpperSvrTblDao : public BaseDao {

private:

    /** 创建上级平台服务器表构造函数 */

    VssUpperSvrTblDao() {}

public:

    /** 创建上级平台服务器表单例模式 */

    static VssUpperSvrTblDao* instance() {

        static VssUpperSvrTblDao instance;

        return &instance;

    }

    
    /** 添加创建上级平台服务器表 keyValuesToAdd 需要添加的列名和列值对map*/

    mysqlpp::SimpleResult addVssUpperSvrTbl(std::map<std::string, std::string>& keyValuesToAdd) {

        return add(keyValuesToAdd, VSSUpperSvrTbl_TABLE_NAME);

    }

    
    /** 删除创建上级平台服务器表 whereKey 列名；whereValue 列值 */

    bool deleteByColumn(string whereKey, string whereValue) {

        std::map<std::string, std::string> whereKeyValues;

        whereKeyValues[whereKey] = whereValue;

        return deleteVssUpperSvrTbl(whereKeyValues);

    }



    /** 删除创建上级平台服务器表 whereColumnNameValues 列名和列值对条件 */

    bool deleteVssUpperSvrTbl(std::map<std::string, std::string>& whereKeyValues) {

        return del(VSSUpperSvrTbl_TABLE_NAME, whereKeyValues);

    }

    
    /** 更新创建上级平台服务器表 keyValuesToUpdate 需要更新的列名和列值对； whereKeyValues 列名和列值条件 */

    bool updateVssUpperSvrTbl(std::map<std::string, std::string>& keyValuesToUpdate, 
                                    std::map<std::string, std::string>& whereKeyValues) {

        return update(keyValuesToUpdate, VSSUpperSvrTbl_TABLE_NAME, whereKeyValues);

    }

	
    /** 更新创建二级设备表 keyValuesToUpdate 需要更新的列名和列值对； whereKeyValues 列名和列值条件 */

    bool updateVssUpperSvrTbl(std::map<std::string, std::string>& keyValuesToUpdate,

                             string whereKey,

                             string whereValue) {

        std::map<std::string, std::string> whereKeyValues;

        whereKeyValues[whereKey] = whereValue;

        return update(keyValuesToUpdate, VSSUpperSvrTbl_TABLE_NAME, whereKeyValues);

    }

	
    /** 查询创建上级平台服务器表列表  querySql 要查询的sql语句 */

    vector<VssUpperSvrTbl> findVssUpperSvrTblList(string querySql) {

        vector<VssUpperSvrTbl> vssUpperSvrTblVec;

        vector<map<string, string>> rowDatList = findList(querySql);

        vssUpperSvrTblVec.reserve(rowDatList.size());

        for (auto rowData : rowDatList) {

            vssUpperSvrTblVec.emplace_back(mapToModel(rowData));

        }

        return vssUpperSvrTblVec;

    }

	
    /**查询创建上级平台服务器表列表 whereKeyValues 列名和列值对条件 */

    vector<VssUpperSvrTbl> findVssUpperSvrTblList(std::map<std::string, std::string>& whereKeyValues) {

        return findVssUpperSvrTblList(string("select * from ") + VSSUpperSvrTbl_TABLE_NAME + " where 1=1 " + getWhereColumnNameValuePair(whereKeyValues));

    }

    
    /**查询所有创建上级平台服务器表列表 */

    vector<VssUpperSvrTbl> findAllVssUpperSvrTblList() {

        return findVssUpperSvrTblList(string("select * from ") + VSSUpperSvrTbl_TABLE_NAME + " where 1=1 ");

    }

	
    /** 查询map列表 querySql 要查询的sql语句 */

    vector<map<string, string>> findMapList(string querySql) {

        return findList(querySql);

    }

    
    /** 执行sql语句 */

    bool execute(string sql) {

        return exec(move(sql));

    }

    
    /** map转model类 */

    VssUpperSvrTbl mapToModel(map<string, string>& rowData) {

        VssUpperSvrTbl vssUpperSvrTbl;

        string IDValue = rowData[VssUpperSvrTbl_ID];

        if (IDValue.length() != 0 && IDValue != "NULL") {

            vssUpperSvrTbl.ID = std::stoi(IDValue);

        }

        string NameValue = rowData[VssUpperSvrTbl_Name];

        if (NameValue.length() != 0 && NameValue != "NULL") {

            vssUpperSvrTbl.Name = NameValue;

        }

        string PublicIDValue = rowData[VssUpperSvrTbl_PublicID];

        if (PublicIDValue.length() != 0 && PublicIDValue != "NULL") {

            vssUpperSvrTbl.PublicID = PublicIDValue;

        }

        string AuthUsernameValue = rowData[VssUpperSvrTbl_AuthUsername];

        if (AuthUsernameValue.length() != 0 && AuthUsernameValue != "NULL") {

            vssUpperSvrTbl.AuthUsername = AuthUsernameValue;

        }

        string AuthPasswdValue = rowData[VssUpperSvrTbl_AuthPasswd];

        if (AuthPasswdValue.length() != 0 && AuthPasswdValue != "NULL") {

            vssUpperSvrTbl.AuthPasswd = AuthPasswdValue;

        }

        string DomainValue = rowData[VssUpperSvrTbl_Domain];

        if (DomainValue.length() != 0 && DomainValue != "NULL") {

            vssUpperSvrTbl.Domain = DomainValue;

        }

        string IPValue = rowData[VssUpperSvrTbl_IP];

        if (IPValue.length() != 0 && IPValue != "NULL") {

            vssUpperSvrTbl.IP = IPValue;

        }

        string PortValue = rowData[VssUpperSvrTbl_Port];

        if (PortValue.length() != 0 && PortValue != "NULL") {

            vssUpperSvrTbl.Port = std::stoi(PortValue);

        }

        string RegisterTimeValue = rowData[VssUpperSvrTbl_RegisterTime];

        if (RegisterTimeValue.length() != 0 && RegisterTimeValue != "NULL") {

            vssUpperSvrTbl.RegisterTime = std::stoi(RegisterTimeValue);

        }

        string KeepAliveTimeValue = rowData[VssUpperSvrTbl_KeepAliveTime];

        if (KeepAliveTimeValue.length() != 0 && KeepAliveTimeValue != "NULL") {

            vssUpperSvrTbl.KeepAliveTime = std::stoi(KeepAliveTimeValue);

        }

        string AliveValue = rowData[VssUpperSvrTbl_Alive];

        if (AliveValue.length() != 0 && AliveValue != "NULL") {

            vssUpperSvrTbl.Alive = std::stoi(AliveValue);

        }

        string IsSyncTimeValue = rowData[VssUpperSvrTbl_IsSyncTime];

        if (IsSyncTimeValue.length() != 0 && IsSyncTimeValue != "NULL") {

            vssUpperSvrTbl.IsSyncTime = std::stoi(IsSyncTimeValue);

        }

        string PushProtocolValue = rowData[VssUpperSvrTbl_PushProtocol];

        if (PushProtocolValue.length() != 0 && PushProtocolValue != "NULL") {

            vssUpperSvrTbl.PushProtocol = std::stoi(PushProtocolValue);

        }

        string PlatformInfoValue = rowData[VssUpperSvrTbl_PlatformInfo];

        if (PlatformInfoValue.length() != 0 && PlatformInfoValue != "NULL") {

            vssUpperSvrTbl.PlatformInfo = std::stoi(PlatformInfoValue);

        }

        string IsEnableValue = rowData[VssUpperSvrTbl_IsEnable];

        if (IsEnableValue.length() != 0 && IsEnableValue != "NULL") {

            vssUpperSvrTbl.IsEnable = std::stoi(IsEnableValue);

        }

        string UpdateTimeValue = rowData[VssUpperSvrTbl_UpdateTime];

        if (UpdateTimeValue.length() != 0 && UpdateTimeValue != "NULL") {

            vssUpperSvrTbl.UpdateTime = UpdateTimeValue;

        }

        return vssUpperSvrTbl;

    }

   
};





#endif //VSSUPPERSVRTBL_MANAGER_H






 QiaoJiaSystem/DataManagerServer/vss/model/VssChannelTbl.h

New file
@@ -0,0 +1,92 @@


#ifndef VSSCHANNELTBL_H

#define VSSCHANNELTBL_H

#include <mysql++.h>

#include <string>

using std::string;



#define VssChannelTbl_ID "ID"

#define VssChannelTbl_DevPubID "DevPubID"

#define VssChannelTbl_Nickname "Nickname"

#define VssChannelTbl_ChanPubID "ChanPubID"

#define VssChannelTbl_Alive "Alive"

#define VssChannelTbl_CorpID "CorpID"

#define VssChannelTbl_Model "Model"

#define VssChannelTbl_Owner "Owner"

#define VssChannelTbl_CivilCode "CivilCode"

#define VssChannelTbl_Address "Address"

#define VssChannelTbl_Parental "Parental"

#define VssChannelTbl_ParentId "ParentId"

#define VssChannelTbl_IP "IP"

#define VssChannelTbl_Port "Port"

#define VssChannelTbl_Longitude "Longitude"

#define VssChannelTbl_Latitude "Latitude"

#define VssChannelTbl_Altitude "Altitude"

#define VssChannelTbl_PTZType "PTZType"

#define VssChannelTbl_RoomType "RoomType"

#define VssChannelTbl_DirectionType "DirectionType"

#define VssChannelTbl_StreamType "StreamType"

#define VssChannelTbl_DMarker "DMarker"

#define VssChannelTbl_UpdateTime "UpdateTime"



/**

 * 创建二级设备表

 */

class VssChannelTbl {

public:

    int ID                   ; 
    std::string DevPubID     ; 
    std::string Nickname     ; 
    std::string ChanPubID    ; 
    int Alive                ; 
    std::string CorpID       ; 
    std::string Model        ; 
    std::string Owner        ; 
    std::string CivilCode    ; 
    std::string Address      ; 
    int Parental             ; 
    std::string ParentId     ; 
    std::string IP           ; 
    int Port                 ; 
    double Longitude         ; 
    double Latitude          ; 
    double Altitude          ; 
    int PTZType              ; 
    int RoomType             ; 
    int DirectionType        ; 
    int StreamType           ; 
    int DMarker              ; 
    std::string UpdateTime   ; 
public:

    /** 创建二级设备表 构造函数*/

    VssChannelTbl() {

        ID = 0                   ;

        DevPubID = ""            ;

        Nickname = ""            ;

        ChanPubID = ""           ;

        Alive = 0                ;

        CorpID = ""              ;

        Model = ""               ;

        Owner = ""               ;

        CivilCode = ""           ;

        Address = ""             ;

        Parental = 0             ;

        ParentId = ""            ;

        IP = ""                  ;

        Port = 0                 ;

        Longitude = 0.0          ;

        Latitude = 0.0           ;

        Altitude = 0.0           ;

        PTZType = 0              ;

        RoomType = 0             ;

        DirectionType = 0        ;

        StreamType = 0           ;

        DMarker = 0              ;

        UpdateTime = ""          ;

    }

};





#endif //VSSCHANNELTBL_H






 QiaoJiaSystem/DataManagerServer/vss/model/VssChannelTblBuilder.h

New file
@@ -0,0 +1,116 @@


#ifndef VSSCHANNELTBL_BUILDER_H

#define VSSCHANNELTBL_BUILDER_H

#include <string>

#include <vector>

#include "VssChannelTbl.h"

using namespace std;



/**

 * 创建二级设备表构建器

 */

class VssChannelTblBuilder {

public:

    VssChannelTblBuilder& addID(int ID) {

        vssChannelTblMap[VssChannelTbl_ID] = to_string(ID);

        return *this;

    }

    VssChannelTblBuilder& addDevPubID(std::string DevPubID) {

        vssChannelTblMap[VssChannelTbl_DevPubID] = DevPubID;

        return *this;

    }

    VssChannelTblBuilder& addNickname(std::string Nickname) {

        vssChannelTblMap[VssChannelTbl_Nickname] = Nickname;

        return *this;

    }

    VssChannelTblBuilder& addChanPubID(std::string ChanPubID) {

        vssChannelTblMap[VssChannelTbl_ChanPubID] = ChanPubID;

        return *this;

    }

    VssChannelTblBuilder& addAlive(int Alive) {

        vssChannelTblMap[VssChannelTbl_Alive] = to_string(Alive);

        return *this;

    }

    VssChannelTblBuilder& addCorpID(std::string CorpID) {

        vssChannelTblMap[VssChannelTbl_CorpID] = CorpID;

        return *this;

    }

    VssChannelTblBuilder& addModel(std::string Model) {

        vssChannelTblMap[VssChannelTbl_Model] = Model;

        return *this;

    }

    VssChannelTblBuilder& addOwner(std::string Owner) {

        vssChannelTblMap[VssChannelTbl_Owner] = Owner;

        return *this;

    }

    VssChannelTblBuilder& addCivilCode(std::string CivilCode) {

        vssChannelTblMap[VssChannelTbl_CivilCode] = CivilCode;

        return *this;

    }

    VssChannelTblBuilder& addAddress(std::string Address) {

        vssChannelTblMap[VssChannelTbl_Address] = Address;

        return *this;

    }

    VssChannelTblBuilder& addParental(int Parental) {

        vssChannelTblMap[VssChannelTbl_Parental] = to_string(Parental);

        return *this;

    }

    VssChannelTblBuilder& addParentId(std::string ParentId) {

        vssChannelTblMap[VssChannelTbl_ParentId] = ParentId;

        return *this;

    }

    VssChannelTblBuilder& addIP(std::string IP) {

        vssChannelTblMap[VssChannelTbl_IP] = IP;

        return *this;

    }

    VssChannelTblBuilder& addPort(int Port) {

        vssChannelTblMap[VssChannelTbl_Port] = to_string(Port);

        return *this;

    }

    VssChannelTblBuilder& addLongitude(double Longitude) {

        vssChannelTblMap[VssChannelTbl_Longitude] = to_string(Longitude);

        return *this;

    }

    VssChannelTblBuilder& addLatitude(double Latitude) {

        vssChannelTblMap[VssChannelTbl_Latitude] = to_string(Latitude);

        return *this;

    }

    VssChannelTblBuilder& addAltitude(double Altitude) {

        vssChannelTblMap[VssChannelTbl_Altitude] = to_string(Altitude);

        return *this;

    }

    VssChannelTblBuilder& addPTZType(int PTZType) {

        vssChannelTblMap[VssChannelTbl_PTZType] = to_string(PTZType);

        return *this;

    }

    VssChannelTblBuilder& addRoomType(int RoomType) {

        vssChannelTblMap[VssChannelTbl_RoomType] = to_string(RoomType);

        return *this;

    }

    VssChannelTblBuilder& addDirectionType(int DirectionType) {

        vssChannelTblMap[VssChannelTbl_DirectionType] = to_string(DirectionType);

        return *this;

    }

    VssChannelTblBuilder& addStreamType(int StreamType) {

        vssChannelTblMap[VssChannelTbl_StreamType] = to_string(StreamType);

        return *this;

    }

    VssChannelTblBuilder& addDMarker(int DMarker) {

        vssChannelTblMap[VssChannelTbl_DMarker] = to_string(DMarker);

        return *this;

    }

    VssChannelTblBuilder& addUpdateTime(std::string UpdateTime) {

        vssChannelTblMap[VssChannelTbl_UpdateTime] = UpdateTime;

        return *this;

    }

    /** 创建二级设备表 map */

    std::map<std::string, std::string>& buildVssChannelTblMap() {

        return vssChannelTblMap;

    }

public:

    std::map<std::string, std::string> vssChannelTblMap;

};



#endif //VSSCHANNELTBL_BUILDER_H






 QiaoJiaSystem/DataManagerServer/vss/model/VssDevTbl.h

New file
@@ -0,0 +1,56 @@


#ifndef VSSDEVTBL_H

#define VSSDEVTBL_H

#include <mysql++.h>

#include <string>

using std::string;



#define VssDevTbl_ID "ID"

#define VssDevTbl_DevPubID "DevPubID"

#define VssDevTbl_DevNickname "DevNickname"

#define VssDevTbl_UserName "UserName"

#define VssDevTbl_Passwd "Passwd"

#define VssDevTbl_CorpID "CorpID"

#define VssDevTbl_IP "IP"

#define VssDevTbl_Port "Port"

#define VssDevTbl_Alive "Alive"

#define VssDevTbl_DMarker "DMarker"

#define VssDevTbl_UpdateTime "UpdateTime"



/**

 * 创建一级设备表

 */

class VssDevTbl {

public:

    int ID                   ; 
    std::string DevPubID     ; 
    std::string DevNickname  ; 
    std::string UserName     ; 
    std::string Passwd       ; 
    std::string CorpID       ; 
    std::string IP           ; 
    int Port                 ; 
    int Alive                ; 
    int DMarker              ; 
    std::string UpdateTime   ; 
public:

    /** 创建一级设备表 构造函数*/

    VssDevTbl() {

        ID = 0                   ;

        DevPubID = ""            ;

        DevNickname = ""         ;

        UserName = ""            ;

        Passwd = ""              ;

        CorpID = ""              ;

        IP = ""                  ;

        Port = 0                 ;

        Alive = 0                ;

        DMarker = 0              ;

        UpdateTime = ""          ;

    }

};





#endif //VSSDEVTBL_H






 QiaoJiaSystem/DataManagerServer/vss/model/VssDevTblBuilder.h

New file
@@ -0,0 +1,68 @@


#ifndef VSSDEVTBL_BUILDER_H

#define VSSDEVTBL_BUILDER_H

#include <string>

#include <vector>

#include "VssDevTbl.h"

using namespace std;



/**

 * 创建一级设备表构建器

 */

class VssDevTblBuilder {

public:

    VssDevTblBuilder& addID(int ID) {

        vssDevTblMap[VssDevTbl_ID] = to_string(ID);

        return *this;

    }

    VssDevTblBuilder& addDevPubID(std::string DevPubID) {

        vssDevTblMap[VssDevTbl_DevPubID] = DevPubID;

        return *this;

    }

    VssDevTblBuilder& addDevNickname(std::string DevNickname) {

        vssDevTblMap[VssDevTbl_DevNickname] = DevNickname;

        return *this;

    }

    VssDevTblBuilder& addUserName(std::string UserName) {

        vssDevTblMap[VssDevTbl_UserName] = UserName;

        return *this;

    }

    VssDevTblBuilder& addPasswd(std::string Passwd) {

        vssDevTblMap[VssDevTbl_Passwd] = Passwd;

        return *this;

    }

    VssDevTblBuilder& addCorpID(std::string CorpID) {

        vssDevTblMap[VssDevTbl_CorpID] = CorpID;

        return *this;

    }

    VssDevTblBuilder& addIP(std::string IP) {

        vssDevTblMap[VssDevTbl_IP] = IP;

        return *this;

    }

    VssDevTblBuilder& addPort(int Port) {

        vssDevTblMap[VssDevTbl_Port] = to_string(Port);

        return *this;

    }

    VssDevTblBuilder& addAlive(int Alive) {

        vssDevTblMap[VssDevTbl_Alive] = to_string(Alive);

        return *this;

    }

    VssDevTblBuilder& addDMarker(int DMarker) {

        vssDevTblMap[VssDevTbl_DMarker] = to_string(DMarker);

        return *this;

    }

    VssDevTblBuilder& addUpdateTime(std::string UpdateTime) {

        vssDevTblMap[VssDevTbl_UpdateTime] = UpdateTime;

        return *this;

    }

    /** 创建一级设备表 map */

    std::map<std::string, std::string>& buildVssDevTblMap() {

        return vssDevTblMap;

    }

public:

    std::map<std::string, std::string> vssDevTblMap;

};



#endif //VSSDEVTBL_BUILDER_H






 QiaoJiaSystem/DataManagerServer/vss/model/VssDomainUnitTbl.h

New file
@@ -0,0 +1,47 @@


#ifndef VSSDOMAINUNITTBL_H

#define VSSDOMAINUNITTBL_H

#include <mysql++.h>

#include <string>

using std::string;



#define VssDomainUnitTbl_ID "ID"

#define VssDomainUnitTbl_DevPubID "DevPubID"

#define VssDomainUnitTbl_DomainPubID "DomainPubID"

#define VssDomainUnitTbl_Name "Name"

#define VssDomainUnitTbl_BusinessGroupID "BusinessGroupID"

#define VssDomainUnitTbl_ParentId "ParentId"

#define VssDomainUnitTbl_DomainType "DomainType"

#define VssDomainUnitTbl_UpdateTime "UpdateTime"



/**

 * 创建一级设备表

 */

class VssDomainUnitTbl {

public:

    int ID                   ; 
    std::string DevPubID     ; 
    std::string DomainPubID  ; 
    std::string Name         ; 
    std::string BusinessGroupID; 
    std::string ParentId     ; 
    int DomainType           ; 
    std::string UpdateTime   ; 
public:

    /** 创建一级设备表 构造函数*/

    VssDomainUnitTbl() {

        ID = 0                   ;

        DevPubID = ""            ;

        DomainPubID = ""         ;

        Name = ""                ;

        BusinessGroupID = ""     ;

        ParentId = ""            ;

        DomainType = 0           ;

        UpdateTime = ""          ;

    }

};





#endif //VSSDOMAINUNITTBL_H






 QiaoJiaSystem/DataManagerServer/vss/model/VssDomainUnitTblBuilder.h

New file
@@ -0,0 +1,56 @@


#ifndef VSSDOMAINUNITTBL_BUILDER_H

#define VSSDOMAINUNITTBL_BUILDER_H

#include <string>

#include <vector>

#include "VssDomainUnitTbl.h"

using namespace std;



/**

 * 创建一级设备表构建器

 */

class VssDomainUnitTblBuilder {

public:

    VssDomainUnitTblBuilder& addID(int ID) {

        vssDomainUnitTblMap[VssDomainUnitTbl_ID] = to_string(ID);

        return *this;

    }

    VssDomainUnitTblBuilder& addDevPubID(std::string DevPubID) {

        vssDomainUnitTblMap[VssDomainUnitTbl_DevPubID] = DevPubID;

        return *this;

    }

    VssDomainUnitTblBuilder& addDomainPubID(std::string DomainPubID) {

        vssDomainUnitTblMap[VssDomainUnitTbl_DomainPubID] = DomainPubID;

        return *this;

    }

    VssDomainUnitTblBuilder& addName(std::string Name) {

        vssDomainUnitTblMap[VssDomainUnitTbl_Name] = Name;

        return *this;

    }

    VssDomainUnitTblBuilder& addBusinessGroupID(std::string BusinessGroupID) {

        vssDomainUnitTblMap[VssDomainUnitTbl_BusinessGroupID] = BusinessGroupID;

        return *this;

    }

    VssDomainUnitTblBuilder& addParentId(std::string ParentId) {

        vssDomainUnitTblMap[VssDomainUnitTbl_ParentId] = ParentId;

        return *this;

    }

    VssDomainUnitTblBuilder& addDomainType(int DomainType) {

        vssDomainUnitTblMap[VssDomainUnitTbl_DomainType] = to_string(DomainType);

        return *this;

    }

    VssDomainUnitTblBuilder& addUpdateTime(std::string UpdateTime) {

        vssDomainUnitTblMap[VssDomainUnitTbl_UpdateTime] = UpdateTime;

        return *this;

    }

    /** 创建一级设备表 map */

    std::map<std::string, std::string>& buildVssDomainUnitTblMap() {

        return vssDomainUnitTblMap;

    }

public:

    std::map<std::string, std::string> vssDomainUnitTblMap;

};



#endif //VSSDOMAINUNITTBL_BUILDER_H






 QiaoJiaSystem/DataManagerServer/vss/model/VssLocalSettingTbl.h

New file
@@ -0,0 +1,44 @@


#ifndef VSSLOCALSETTINGTBL_H

#define VSSLOCALSETTINGTBL_H

#include <mysql++.h>

#include <string>

using std::string;



#define VssLocalSettingTbl_ID "ID"

#define VssLocalSettingTbl_ServerIp "ServerIp"

#define VssLocalSettingTbl_ServerPort "ServerPort"

#define VssLocalSettingTbl_ServerId "ServerId"

#define VssLocalSettingTbl_UserAuthId "UserAuthId"

#define VssLocalSettingTbl_Password "Password"

#define VssLocalSettingTbl_UpdateTime "UpdateTime"



/**

 * 本地国标配置

 */

class VssLocalSettingTbl {

public:

    int ID                   ; 
    std::string ServerIp     ; 
    std::string ServerPort   ; 
    std::string ServerId     ; 
    std::string UserAuthId   ; 
    std::string Password     ; 
    std::string UpdateTime   ; 
public:

    /** 本地国标配置 构造函数*/

    VssLocalSettingTbl() {

        ID = 0                   ;

        ServerIp = ""            ;

        ServerPort = ""          ;

        ServerId = ""            ;

        UserAuthId = ""          ;

        Password = ""            ;

        UpdateTime = ""          ;

    }

};





#endif //VSSLOCALSETTINGTBL_H






 QiaoJiaSystem/DataManagerServer/vss/model/VssLocalSettingTblBuilder.h

New file
@@ -0,0 +1,52 @@


#ifndef VSSLOCALSETTINGTBL_BUILDER_H

#define VSSLOCALSETTINGTBL_BUILDER_H

#include <string>

#include <vector>

#include "VssLocalSettingTbl.h"

using namespace std;



/**

 * 本地国标配置构建器

 */

class VssLocalSettingTblBuilder {

public:

    VssLocalSettingTblBuilder& addID(int ID) {

        vssLocalSettingTblMap[VssLocalSettingTbl_ID] = to_string(ID);

        return *this;

    }

    VssLocalSettingTblBuilder& addServerIp(std::string ServerIp) {

        vssLocalSettingTblMap[VssLocalSettingTbl_ServerIp] = ServerIp;

        return *this;

    }

    VssLocalSettingTblBuilder& addServerPort(std::string ServerPort) {

        vssLocalSettingTblMap[VssLocalSettingTbl_ServerPort] = ServerPort;

        return *this;

    }

    VssLocalSettingTblBuilder& addServerId(std::string ServerId) {

        vssLocalSettingTblMap[VssLocalSettingTbl_ServerId] = ServerId;

        return *this;

    }

    VssLocalSettingTblBuilder& addUserAuthId(std::string UserAuthId) {

        vssLocalSettingTblMap[VssLocalSettingTbl_UserAuthId] = UserAuthId;

        return *this;

    }

    VssLocalSettingTblBuilder& addPassword(std::string Password) {

        vssLocalSettingTblMap[VssLocalSettingTbl_Password] = Password;

        return *this;

    }

    VssLocalSettingTblBuilder& addUpdateTime(std::string UpdateTime) {

        vssLocalSettingTblMap[VssLocalSettingTbl_UpdateTime] = UpdateTime;

        return *this;

    }

    /** 本地国标配置 map */

    std::map<std::string, std::string>& buildVssLocalSettingTblMap() {

        return vssLocalSettingTblMap;

    }

public:

    std::map<std::string, std::string> vssLocalSettingTblMap;

};



#endif //VSSLOCALSETTINGTBL_BUILDER_H






 QiaoJiaSystem/DataManagerServer/vss/model/VssUpperSvrTbl.h

New file
@@ -0,0 +1,71 @@


#ifndef VSSUPPERSVRTBL_H

#define VSSUPPERSVRTBL_H

#include <mysql++.h>

#include <string>

using std::string;



#define VssUpperSvrTbl_ID "ID"

#define VssUpperSvrTbl_Name "Name"

#define VssUpperSvrTbl_PublicID "PublicID"

#define VssUpperSvrTbl_AuthUsername "AuthUsername"

#define VssUpperSvrTbl_AuthPasswd "AuthPasswd"

#define VssUpperSvrTbl_Domain "Domain"

#define VssUpperSvrTbl_IP "IP"

#define VssUpperSvrTbl_Port "Port"

#define VssUpperSvrTbl_RegisterTime "RegisterTime"

#define VssUpperSvrTbl_KeepAliveTime "KeepAliveTime"

#define VssUpperSvrTbl_Alive "Alive"

#define VssUpperSvrTbl_IsSyncTime "IsSyncTime"

#define VssUpperSvrTbl_PushProtocol "PushProtocol"

#define VssUpperSvrTbl_PlatformInfo "PlatformInfo"

#define VssUpperSvrTbl_IsEnable "IsEnable"

#define VssUpperSvrTbl_UpdateTime "UpdateTime"



/**

 * 创建上级平台服务器表

 */

class VssUpperSvrTbl {

public:

    int ID                   ; 
    std::string Name         ; 
    std::string PublicID     ; 
    std::string AuthUsername ; 
    std::string AuthPasswd   ; 
    std::string Domain       ; 
    std::string IP           ; 
    int Port                 ; 
    int RegisterTime         ; 
    int KeepAliveTime        ; 
    int Alive                ; 
    int IsSyncTime           ; 
    int PushProtocol         ; 
    int PlatformInfo         ; 
    int IsEnable             ; 
    std::string UpdateTime   ; 
public:

    /** 创建上级平台服务器表 构造函数*/

    VssUpperSvrTbl() {

        ID = 0                   ;

        Name = ""                ;

        PublicID = ""            ;

        AuthUsername = ""        ;

        AuthPasswd = ""          ;

        Domain = ""              ;

        IP = ""                  ;

        Port = 0                 ;

        RegisterTime = 0         ;

        KeepAliveTime = 0        ;

        Alive = 0                ;

        IsSyncTime = 0           ;

        PushProtocol = 0         ;

        PlatformInfo = 0         ;

        IsEnable = 0             ;

        UpdateTime = ""          ;

    }

};





#endif //VSSUPPERSVRTBL_H






 QiaoJiaSystem/DataManagerServer/vss/model/VssUpperSvrTblBuilder.h

New file
@@ -0,0 +1,88 @@


#ifndef VSSUPPERSVRTBL_BUILDER_H

#define VSSUPPERSVRTBL_BUILDER_H

#include <string>

#include <vector>

#include "VssUpperSvrTbl.h"

using namespace std;



/**

 * 创建上级平台服务器表构建器

 */

class VssUpperSvrTblBuilder {

public:

    VssUpperSvrTblBuilder& addID(int ID) {

        vssUpperSvrTblMap[VssUpperSvrTbl_ID] = to_string(ID);

        return *this;

    }

    VssUpperSvrTblBuilder& addName(std::string Name) {

        vssUpperSvrTblMap[VssUpperSvrTbl_Name] = Name;

        return *this;

    }

    VssUpperSvrTblBuilder& addPublicID(std::string PublicID) {

        vssUpperSvrTblMap[VssUpperSvrTbl_PublicID] = PublicID;

        return *this;

    }

    VssUpperSvrTblBuilder& addAuthUsername(std::string AuthUsername) {

        vssUpperSvrTblMap[VssUpperSvrTbl_AuthUsername] = AuthUsername;

        return *this;

    }

    VssUpperSvrTblBuilder& addAuthPasswd(std::string AuthPasswd) {

        vssUpperSvrTblMap[VssUpperSvrTbl_AuthPasswd] = AuthPasswd;

        return *this;

    }

    VssUpperSvrTblBuilder& addDomain(std::string Domain) {

        vssUpperSvrTblMap[VssUpperSvrTbl_Domain] = Domain;

        return *this;

    }

    VssUpperSvrTblBuilder& addIP(std::string IP) {

        vssUpperSvrTblMap[VssUpperSvrTbl_IP] = IP;

        return *this;

    }

    VssUpperSvrTblBuilder& addPort(int Port) {

        vssUpperSvrTblMap[VssUpperSvrTbl_Port] = to_string(Port);

        return *this;

    }

    VssUpperSvrTblBuilder& addRegisterTime(int RegisterTime) {

        vssUpperSvrTblMap[VssUpperSvrTbl_RegisterTime] = to_string(RegisterTime);

        return *this;

    }

    VssUpperSvrTblBuilder& addKeepAliveTime(int KeepAliveTime) {

        vssUpperSvrTblMap[VssUpperSvrTbl_KeepAliveTime] = to_string(KeepAliveTime);

        return *this;

    }

    VssUpperSvrTblBuilder& addAlive(int Alive) {

        vssUpperSvrTblMap[VssUpperSvrTbl_Alive] = to_string(Alive);

        return *this;

    }

    VssUpperSvrTblBuilder& addIsSyncTime(int IsSyncTime) {

        vssUpperSvrTblMap[VssUpperSvrTbl_IsSyncTime] = to_string(IsSyncTime);

        return *this;

    }

    VssUpperSvrTblBuilder& addPushProtocol(int PushProtocol) {

        vssUpperSvrTblMap[VssUpperSvrTbl_PushProtocol] = to_string(PushProtocol);

        return *this;

    }

    VssUpperSvrTblBuilder& addPlatformInfo(int PlatformInfo) {

        vssUpperSvrTblMap[VssUpperSvrTbl_PlatformInfo] = to_string(PlatformInfo);

        return *this;

    }

    VssUpperSvrTblBuilder& addIsEnable(int IsEnable) {

        vssUpperSvrTblMap[VssUpperSvrTbl_IsEnable] = to_string(IsEnable);

        return *this;

    }

    VssUpperSvrTblBuilder& addUpdateTime(std::string UpdateTime) {

        vssUpperSvrTblMap[VssUpperSvrTbl_UpdateTime] = UpdateTime;

        return *this;

    }

    /** 创建上级平台服务器表 map */

    std::map<std::string, std::string>& buildVssUpperSvrTblMap() {

        return vssUpperSvrTblMap;

    }

public:

    std::map<std::string, std::string> vssUpperSvrTblMap;

};



#endif //VSSUPPERSVRTBL_BUILDER_H






 QiaoJiaSystem/DataManagerServer/vss/test/VssChannelTblControllerTest.h

New file
@@ -0,0 +1,22 @@
//
// Created by xiuxi on 19-2-25.
//

#ifndef QIAOJIASYSTEM_VSSCHANNELTBLCONTROLLERTEST_H
#define QIAOJIASYSTEM_VSSCHANNELTBLCONTROLLERTEST_H


#include <DataManagerServer/vss/controller/VssChannelTblController.h>

class VssChannelTblControllerTest {
public:
    static void testAddVssChannelTbl() {
        PResponse pResponse;
        VssChannelTblController::instance()->addVssChannelTbl("192.168.1.149", 30, "{}", pResponse);
    }


};


#endif //QIAOJIASYSTEM_VSSCHANNELTBLCONTROLLERTEST_H

 QiaoJiaSystem/DataManagerServer/vss/test/VssChannelTblDaoTest.h

New file
@@ -0,0 +1,94 @@


#ifndef VSSCHANNELTBL_MANAGER_TEST_H

#define VSSCHANNELTBL_MANAGER_TEST_H



#include "../model/VssChannelTbl.h"

#include "../model/VssChannelTblBuilder.h"

#include "../dao/VssChannelTblDao.h"

#include <basic/debug/Debug.h>



/**

 * 测试创建二级设备表管理类

 */

class VssChannelTblDaoTest {

private:

    /** 创建二级设备表DaoTest构造函数 */

    VssChannelTblDaoTest() {}

public:

    /** 创建二级设备表DaoTest单例模式 */

    static VssChannelTblDaoTest* instance() {

        static VssChannelTblDaoTest instance;

        return &instance;

    }



    /** 测试添加创建二级设备表 */

    void testAddVssChannelTbl() {

        VssChannelTblBuilder vssChannelTblBuilder;

        vssChannelTblBuilder.addID(0);

        vssChannelTblBuilder.addDevPubID("");

        vssChannelTblBuilder.addNickname("");

        vssChannelTblBuilder.addChanPubID("");

        vssChannelTblBuilder.addAlive(0);

        vssChannelTblBuilder.addCorpID("");

        vssChannelTblBuilder.addModel("");

        vssChannelTblBuilder.addOwner("");

        vssChannelTblBuilder.addCivilCode("");

        vssChannelTblBuilder.addAddress("");

        vssChannelTblBuilder.addParental(0);

        vssChannelTblBuilder.addParentId("");

        vssChannelTblBuilder.addIP("");

        vssChannelTblBuilder.addPort(0);

        vssChannelTblBuilder.addLongitude(0.0);

        vssChannelTblBuilder.addLatitude(0.0);

        vssChannelTblBuilder.addAltitude(0.0);

        vssChannelTblBuilder.addPTZType(0);

        vssChannelTblBuilder.addRoomType(0);

        vssChannelTblBuilder.addDirectionType(0);

        vssChannelTblBuilder.addStreamType(0);

        vssChannelTblBuilder.addDMarker(0);

        vssChannelTblBuilder.addUpdateTime("");

        VssChannelTblDao::instance()->addVssChannelTbl(vssChannelTblBuilder.buildVssChannelTblMap());

    }

    
    /** 测试更新创建二级设备表 */

    void testUpdateVssChannelTbl() {

        VssChannelTblBuilder vssChannelTblBuilder;

        vssChannelTblBuilder.addID(0);

        vssChannelTblBuilder.addDevPubID("");

        vssChannelTblBuilder.addNickname("");

        vssChannelTblBuilder.addChanPubID("");

        vssChannelTblBuilder.addAlive(0);

        vssChannelTblBuilder.addCorpID("");

        vssChannelTblBuilder.addModel("");

        vssChannelTblBuilder.addOwner("");

        vssChannelTblBuilder.addCivilCode("");

        vssChannelTblBuilder.addAddress("");

        vssChannelTblBuilder.addParental(0);

        vssChannelTblBuilder.addParentId("");

        vssChannelTblBuilder.addIP("");

        vssChannelTblBuilder.addPort(0);

        vssChannelTblBuilder.addLongitude(0.0);

        vssChannelTblBuilder.addLatitude(0.0);

        vssChannelTblBuilder.addAltitude(0.0);

        vssChannelTblBuilder.addPTZType(0);

        vssChannelTblBuilder.addRoomType(0);

        vssChannelTblBuilder.addDirectionType(0);

        vssChannelTblBuilder.addStreamType(0);

        vssChannelTblBuilder.addDMarker(0);

        vssChannelTblBuilder.addUpdateTime("");

    
        VssChannelTblDao::instance()->updateVssChannelTbl(vssChannelTblBuilder.buildVssChannelTblMap(),

                                                  vssChannelTblBuilder.buildVssChannelTblMap());

    }

    
    /** 测试查询创建二级设备表列表*/

    void testFindVssChannelTblList() {

        vector<VssChannelTbl> vssChannelTblVec = VssChannelTblDao::instance()->findAllVssChannelTblList();

    }

    
private:

	
};



#endif //VSSCHANNELTBL_MANAGER_TEST_H




 QiaoJiaSystem/DataManagerServer/vss/test/VssDevTblDaoTest.h

New file
@@ -0,0 +1,70 @@


#ifndef VSSDEVTBL_MANAGER_TEST_H

#define VSSDEVTBL_MANAGER_TEST_H



#include "../model/VssDevTbl.h"

#include "../model/VssDevTblBuilder.h"

#include "../dao/VssDevTblDao.h"

#include <basic/debug/Debug.h>



/**

 * 测试创建一级设备表管理类

 */

class VssDevTblDaoTest {

private:

    /** 创建一级设备表DaoTest构造函数 */

    VssDevTblDaoTest() {}

public:

    /** 创建一级设备表DaoTest单例模式 */

    static VssDevTblDaoTest* instance() {

        static VssDevTblDaoTest instance;

        return &instance;

    }



    /** 测试添加创建一级设备表 */

    void testAddVssDevTbl() {

        VssDevTblBuilder vssDevTblBuilder;

        vssDevTblBuilder.addID(0);

        vssDevTblBuilder.addDevPubID("");

        vssDevTblBuilder.addDevNickname("");

        vssDevTblBuilder.addUserName("");

        vssDevTblBuilder.addPasswd("");

        vssDevTblBuilder.addCorpID("");

        vssDevTblBuilder.addIP("");

        vssDevTblBuilder.addPort(0);

        vssDevTblBuilder.addAlive(0);

        vssDevTblBuilder.addDMarker(0);

        vssDevTblBuilder.addUpdateTime("");

        VssDevTblDao::instance()->addVssDevTbl(vssDevTblBuilder.buildVssDevTblMap());

    }

    
    /** 测试更新创建一级设备表 */

    void testUpdateVssDevTbl() {

        VssDevTblBuilder vssDevTblBuilder;

        vssDevTblBuilder.addID(0);

        vssDevTblBuilder.addDevPubID("");

        vssDevTblBuilder.addDevNickname("");

        vssDevTblBuilder.addUserName("");

        vssDevTblBuilder.addPasswd("");

        vssDevTblBuilder.addCorpID("");

        vssDevTblBuilder.addIP("");

        vssDevTblBuilder.addPort(0);

        vssDevTblBuilder.addAlive(0);

        vssDevTblBuilder.addDMarker(0);

        vssDevTblBuilder.addUpdateTime("");

    
        VssDevTblDao::instance()->updateVssDevTbl(vssDevTblBuilder.buildVssDevTblMap(),

                                                  vssDevTblBuilder.buildVssDevTblMap());

    }

    
    /** 测试查询创建一级设备表列表*/

    void testFindVssDevTblList() {

        vector<VssDevTbl> vssDevTblVec = VssDevTblDao::instance()->findAllVssDevTblList();

    }

    
private:

	
};



#endif //VSSDEVTBL_MANAGER_TEST_H




 QiaoJiaSystem/DataManagerServer/vss/test/VssDomainUnitTblDaoTest.h

New file
@@ -0,0 +1,64 @@


#ifndef VSSDOMAINUNITTBL_MANAGER_TEST_H

#define VSSDOMAINUNITTBL_MANAGER_TEST_H



#include "../model/VssDomainUnitTbl.h"

#include "../model/VssDomainUnitTblBuilder.h"

#include "../dao/VssDomainUnitTblDao.h"

#include <basic/debug/Debug.h>



/**

 * 测试创建一级设备表管理类

 */

class VssDomainUnitTblDaoTest {

private:

    /** 创建一级设备表DaoTest构造函数 */

    VssDomainUnitTblDaoTest() {}

public:

    /** 创建一级设备表DaoTest单例模式 */

    static VssDomainUnitTblDaoTest* instance() {

        static VssDomainUnitTblDaoTest instance;

        return &instance;

    }



    /** 测试添加创建一级设备表 */

    void testAddVssDomainUnitTbl() {

        VssDomainUnitTblBuilder vssDomainUnitTblBuilder;

        vssDomainUnitTblBuilder.addID(0);

        vssDomainUnitTblBuilder.addDevPubID("");

        vssDomainUnitTblBuilder.addDomainPubID("");

        vssDomainUnitTblBuilder.addName("");

        vssDomainUnitTblBuilder.addBusinessGroupID("");

        vssDomainUnitTblBuilder.addParentId("");

        vssDomainUnitTblBuilder.addDomainType(0);

        vssDomainUnitTblBuilder.addUpdateTime("");

        VssDomainUnitTblDao::instance()->addVssDomainUnitTbl(vssDomainUnitTblBuilder.buildVssDomainUnitTblMap());

    }

    
    /** 测试更新创建一级设备表 */

    void testUpdateVssDomainUnitTbl() {

        VssDomainUnitTblBuilder vssDomainUnitTblBuilder;

        vssDomainUnitTblBuilder.addID(0);

        vssDomainUnitTblBuilder.addDevPubID("");

        vssDomainUnitTblBuilder.addDomainPubID("");

        vssDomainUnitTblBuilder.addName("");

        vssDomainUnitTblBuilder.addBusinessGroupID("");

        vssDomainUnitTblBuilder.addParentId("");

        vssDomainUnitTblBuilder.addDomainType(0);

        vssDomainUnitTblBuilder.addUpdateTime("");

    
        VssDomainUnitTblDao::instance()->updateVssDomainUnitTbl(vssDomainUnitTblBuilder.buildVssDomainUnitTblMap(),

                                                  vssDomainUnitTblBuilder.buildVssDomainUnitTblMap());

    }

    
    /** 测试查询创建一级设备表列表*/

    void testFindVssDomainUnitTblList() {

        vector<VssDomainUnitTbl> vssDomainUnitTblVec = VssDomainUnitTblDao::instance()->findAllVssDomainUnitTblList();

    }

    
private:

	
};



#endif //VSSDOMAINUNITTBL_MANAGER_TEST_H




 QiaoJiaSystem/DataManagerServer/vss/test/VssLocalSettingTblDaoTest.h

New file
@@ -0,0 +1,62 @@


#ifndef VSSLOCALSETTINGTBL_MANAGER_TEST_H

#define VSSLOCALSETTINGTBL_MANAGER_TEST_H



#include "../model/VssLocalSettingTbl.h"

#include "../model/VssLocalSettingTblBuilder.h"

#include "../dao/VssLocalSettingTblDao.h"

#include <basic/debug/Debug.h>



/**

 * 测试本地国标配置管理类

 */

class VssLocalSettingTblDaoTest {

private:

    /** 本地国标配置DaoTest构造函数 */

    VssLocalSettingTblDaoTest() {}

public:

    /** 本地国标配置DaoTest单例模式 */

    static VssLocalSettingTblDaoTest* instance() {

        static VssLocalSettingTblDaoTest instance;

        return &instance;

    }



    /** 测试添加本地国标配置 */

    void testAddVssLocalSettingTbl() {

        VssLocalSettingTblBuilder vssLocalSettingTblBuilder;

        vssLocalSettingTblBuilder.addID(0);

        vssLocalSettingTblBuilder.addServerIp("");

        vssLocalSettingTblBuilder.addServerPort("");

        vssLocalSettingTblBuilder.addServerId("");

        vssLocalSettingTblBuilder.addUserAuthId("");

        vssLocalSettingTblBuilder.addPassword("");

        vssLocalSettingTblBuilder.addUpdateTime("");

        VssLocalSettingTblDao::instance()->addVssLocalSettingTbl(vssLocalSettingTblBuilder.buildVssLocalSettingTblMap());

    }

    
    /** 测试更新本地国标配置 */

    void testUpdateVssLocalSettingTbl() {

        VssLocalSettingTblBuilder vssLocalSettingTblBuilder;

        vssLocalSettingTblBuilder.addID(0);

        vssLocalSettingTblBuilder.addServerIp("");

        vssLocalSettingTblBuilder.addServerPort("");

        vssLocalSettingTblBuilder.addServerId("");

        vssLocalSettingTblBuilder.addUserAuthId("");

        vssLocalSettingTblBuilder.addPassword("");

        vssLocalSettingTblBuilder.addUpdateTime("");

    
        VssLocalSettingTblDao::instance()->updateVssLocalSettingTbl(vssLocalSettingTblBuilder.buildVssLocalSettingTblMap(),

                                                  vssLocalSettingTblBuilder.buildVssLocalSettingTblMap());

    }

    
    /** 测试查询本地国标配置列表*/

    void testFindVssLocalSettingTblList() {

        vector<VssLocalSettingTbl> vssLocalSettingTblVec = VssLocalSettingTblDao::instance()->findAllVssLocalSettingTblList();

    }

    
private:

	
};



#endif //VSSLOCALSETTINGTBL_MANAGER_TEST_H




 QiaoJiaSystem/DataManagerServer/vss/test/VssUpperSvrTblDaoTest.h

New file
@@ -0,0 +1,80 @@


#ifndef VSSUPPERSVRTBL_MANAGER_TEST_H

#define VSSUPPERSVRTBL_MANAGER_TEST_H



#include "../model/VssUpperSvrTbl.h"

#include "../model/VssUpperSvrTblBuilder.h"

#include "../dao/VssUpperSvrTblDao.h"

#include <basic/debug/Debug.h>



/**

 * 测试创建上级平台服务器表管理类

 */

class VssUpperSvrTblDaoTest {

private:

    /** 创建上级平台服务器表DaoTest构造函数 */

    VssUpperSvrTblDaoTest() {}

public:

    /** 创建上级平台服务器表DaoTest单例模式 */

    static VssUpperSvrTblDaoTest* instance() {

        static VssUpperSvrTblDaoTest instance;

        return &instance;

    }



    /** 测试添加创建上级平台服务器表 */

    void testAddVssUpperSvrTbl() {

        VssUpperSvrTblBuilder vssUpperSvrTblBuilder;

        vssUpperSvrTblBuilder.addID(0);

        vssUpperSvrTblBuilder.addName("");

        vssUpperSvrTblBuilder.addPublicID("");

        vssUpperSvrTblBuilder.addAuthUsername("");

        vssUpperSvrTblBuilder.addAuthPasswd("");

        vssUpperSvrTblBuilder.addDomain("");

        vssUpperSvrTblBuilder.addIP("");

        vssUpperSvrTblBuilder.addPort(0);

        vssUpperSvrTblBuilder.addRegisterTime(0);

        vssUpperSvrTblBuilder.addKeepAliveTime(0);

        vssUpperSvrTblBuilder.addAlive(0);

        vssUpperSvrTblBuilder.addIsSyncTime(0);

        vssUpperSvrTblBuilder.addPushProtocol(0);

        vssUpperSvrTblBuilder.addPlatformInfo(0);

        vssUpperSvrTblBuilder.addIsEnable(0);

        vssUpperSvrTblBuilder.addUpdateTime("");

        VssUpperSvrTblDao::instance()->addVssUpperSvrTbl(vssUpperSvrTblBuilder.buildVssUpperSvrTblMap());

    }

    
    /** 测试更新创建上级平台服务器表 */

    void testUpdateVssUpperSvrTbl() {

        VssUpperSvrTblBuilder vssUpperSvrTblBuilder;

        vssUpperSvrTblBuilder.addID(0);

        vssUpperSvrTblBuilder.addName("");

        vssUpperSvrTblBuilder.addPublicID("");

        vssUpperSvrTblBuilder.addAuthUsername("");

        vssUpperSvrTblBuilder.addAuthPasswd("");

        vssUpperSvrTblBuilder.addDomain("");

        vssUpperSvrTblBuilder.addIP("");

        vssUpperSvrTblBuilder.addPort(0);

        vssUpperSvrTblBuilder.addRegisterTime(0);

        vssUpperSvrTblBuilder.addKeepAliveTime(0);

        vssUpperSvrTblBuilder.addAlive(0);

        vssUpperSvrTblBuilder.addIsSyncTime(0);

        vssUpperSvrTblBuilder.addPushProtocol(0);

        vssUpperSvrTblBuilder.addPlatformInfo(0);

        vssUpperSvrTblBuilder.addIsEnable(0);

        vssUpperSvrTblBuilder.addUpdateTime("");

    
        VssUpperSvrTblDao::instance()->updateVssUpperSvrTbl(vssUpperSvrTblBuilder.buildVssUpperSvrTblMap(),

                                                  vssUpperSvrTblBuilder.buildVssUpperSvrTblMap());

    }

    
    /** 测试查询创建上级平台服务器表列表*/

    void testFindVssUpperSvrTblList() {

        vector<VssUpperSvrTbl> vssUpperSvrTblVec = VssUpperSvrTblDao::instance()->findAllVssUpperSvrTblList();

    }

    
private:

	
};



#endif //VSSUPPERSVRTBL_MANAGER_TEST_H




 QiaoJiaSystem/VideoServer/QiaoJia/DB/LDBTool.h

@@ -135,6 +135,17 @@
    QSqlTableModel *m_pModel;

    QMutex m_mutexVisit;
public:
    QSqlDatabase* get_m_db() {
        return &m_db;
    }
    QSqlTableModel* get_m_pModel() {
        return m_pModel;
    }
    QMutex* get_m_mutexVisit() {
        return &m_mutexVisit;
    }

};

#endif // LDBTOOL_H

 QiaoJiaSystem/build/DataWebServer

Binary files differ

 QiaoJiaSystem/build/config.db

Binary files differ