add and find by id for cam_dev

xuxiuxi

2019-03-04 845c62691a5b19faf67775f712f294fa0d1789f6

add and find by id for cam_dev

 QiaoJiaSystem/DataManagerServer/vss/controller/CamDevController.h

New file
@@ -0,0 +1,424 @@
#ifndef CAMDEV_CONTROLLER_H
#define CAMDEV_CONTROLLER_H

#include <string>
#include <DataManagerServer/http_configserver.h>
#include "vss/dao/CamDevSqliteDao.h"
#include "vss/model/CamDevBuilder.h"
#include "vss/model/CamDev.h"
#include "VssBaseController.h"
#include <mysql++.h>

using namespace std;

/**
 * 摄像头设备
 */
class CamDevController : public VssBaseController {
private:
    /** 摄像头设备构造函数 */
    CamDevController() {}
public:
    /** 摄像头设备单例模式 */
    static CamDevController* instance() {
        static CamDevController instance;
        return &instance;
    }
public:
    /** 注册{label}http服务 */
    void registerHttpServices(HttpSrvRetRecieve& _HttpSrvRetRecieve) {

        _HttpSrvRetRecieve.setInfo("^/addCamDev$", "POST",
                                   std::bind(&CamDevController::addCamDev, this,
                                             std::placeholders::_1, std::placeholders::_2,
                                             std::placeholders::_3, std::placeholders::_4));
	
        _HttpSrvRetRecieve.setInfo("^/delCamDev$", "POST",
                                   std::bind(&CamDevController::delCamDev, this,
                                             std::placeholders::_1, std::placeholders::_2,
                                             std::placeholders::_3, std::placeholders::_4));
	
        _HttpSrvRetRecieve.setInfo("^/updateCamDev$", "POST",
                                   std::bind(&CamDevController::updateCamDev, this,
                                             std::placeholders::_1, std::placeholders::_2,
                                             std::placeholders::_3, std::placeholders::_4));
	
        _HttpSrvRetRecieve.setInfo("^/findCamDev$", "POST",
                                   std::bind(&CamDevController::findCamDev, this,
                                             std::placeholders::_1, std::placeholders::_2,
                                             std::placeholders::_3, std::placeholders::_4));
	
        _HttpSrvRetRecieve.setInfo("^/findCamDevList$", "POST",
                                   std::bind(&CamDevController::findCamDevList, this,
                                             std::placeholders::_1, std::placeholders::_2,
                                             std::placeholders::_3, std::placeholders::_4));

    }
public:
    /** 添加摄像头设备 */
    std::string addCamDev(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)) {
            CamDevBuilder camDevBuilder;
	    
            Json::Value idJsonValue = requestJsonValue[CamDev_id];
            if (idJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addid(std::stoi((idJsonValue.asString())));
            }
	    
            Json::Value cam_dev_idJsonValue = requestJsonValue[CamDev_cam_dev_id];
            if (cam_dev_idJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addcam_dev_id((cam_dev_idJsonValue.asString()));
            }
	    
            Json::Value nameJsonValue = requestJsonValue[CamDev_name];
            if (nameJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addname((nameJsonValue.asString()));
            }
	    
            Json::Value addrJsonValue = requestJsonValue[CamDev_addr];
            if (addrJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addaddr((addrJsonValue.asString()));
            }
	    
            Json::Value longitudeJsonValue = requestJsonValue[CamDev_longitude];
            if (longitudeJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addlongitude((longitudeJsonValue.asString()));
            }
	    
            Json::Value latitudeJsonValue = requestJsonValue[CamDev_latitude];
            if (latitudeJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addlatitude((latitudeJsonValue.asString()));
            }
	    
            Json::Value ipJsonValue = requestJsonValue[CamDev_ip];
            if (ipJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addip((ipJsonValue.asString()));
            }
	    
            Json::Value portJsonValue = requestJsonValue[CamDev_port];
            if (portJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addport(std::stoi((portJsonValue.asString())));
            }
	    
            Json::Value usernameJsonValue = requestJsonValue[CamDev_username];
            if (usernameJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addusername((usernameJsonValue.asString()));
            }
	    
            Json::Value passwordJsonValue = requestJsonValue[CamDev_password];
            if (passwordJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addpassword((passwordJsonValue.asString()));
            }
	    
            Json::Value brandJsonValue = requestJsonValue[CamDev_brand];
            if (brandJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addbrand((brandJsonValue.asString()));
            }
	    
            Json::Value reservedJsonValue = requestJsonValue[CamDev_reserved];
            if (reservedJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addreserved((reservedJsonValue.asString()));
            }
	    
            Json::Value typeJsonValue = requestJsonValue[CamDev_type];
            if (typeJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addtype((typeJsonValue.asString()));
            }
            auto keyValuesToAdd = camDevBuilder.buildCamDevMap();
            if (keyValuesToAdd.size() > 0) {
                mysqlpp::SimpleResult addCamDevResult = CamDevSqliteDao::instance()->addCamDev(keyValuesToAdd);
                if (addCamDevResult.rows() > 0) {
                    responseJsonValue["success"] = "true";
                    responseJsonValue["message"] = "添加成功！";
                }
            }
        }
        return responseJsonValue.toStyledString();
    }
    
    /** 删除摄像头设备 */
    std::string delCamDev(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[CamDev_ID];
            if (iDJsonValue.type() != Json::ValueType::nullValue) {
                string iDValue = iDJsonValue.asString();
                if (iDValue.size() > 0 && CamDevSqliteDao::instance()->deleteByColumn("ID", iDValue)) {
                    responseJsonValue["success"] = "true";
                    responseJsonValue["message"] = "删除成功!";
                }
            }
            
        }
        return responseJsonValue.toStyledString();
    }
    
    /** 更新摄像头设备 */
    std::string updateCamDev(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)) {
            CamDevBuilder camDevBuilder;
	    
            Json::Value idJsonValue = requestJsonValue[CamDev_id];
            if (idJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addid(std::stoi((idJsonValue.asString())));
            }
	    
            Json::Value cam_dev_idJsonValue = requestJsonValue[CamDev_cam_dev_id];
            if (cam_dev_idJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addcam_dev_id((cam_dev_idJsonValue.asString()));
            }
	    
            Json::Value nameJsonValue = requestJsonValue[CamDev_name];
            if (nameJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addname((nameJsonValue.asString()));
            }
	    
            Json::Value addrJsonValue = requestJsonValue[CamDev_addr];
            if (addrJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addaddr((addrJsonValue.asString()));
            }
	    
            Json::Value longitudeJsonValue = requestJsonValue[CamDev_longitude];
            if (longitudeJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addlongitude((longitudeJsonValue.asString()));
            }
	    
            Json::Value latitudeJsonValue = requestJsonValue[CamDev_latitude];
            if (latitudeJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addlatitude((latitudeJsonValue.asString()));
            }
	    
            Json::Value ipJsonValue = requestJsonValue[CamDev_ip];
            if (ipJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addip((ipJsonValue.asString()));
            }
	    
            Json::Value portJsonValue = requestJsonValue[CamDev_port];
            if (portJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addport(std::stoi((portJsonValue.asString())));
            }
	    
            Json::Value usernameJsonValue = requestJsonValue[CamDev_username];
            if (usernameJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addusername((usernameJsonValue.asString()));
            }
	    
            Json::Value passwordJsonValue = requestJsonValue[CamDev_password];
            if (passwordJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addpassword((passwordJsonValue.asString()));
            }
	    
            Json::Value brandJsonValue = requestJsonValue[CamDev_brand];
            if (brandJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addbrand((brandJsonValue.asString()));
            }
	    
            Json::Value reservedJsonValue = requestJsonValue[CamDev_reserved];
            if (reservedJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addreserved((reservedJsonValue.asString()));
            }
	    
            Json::Value typeJsonValue = requestJsonValue[CamDev_type];
            if (typeJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addtype((typeJsonValue.asString()));
            }
            if (iDJsonValue.type() != Json::ValueType::nullValue) {
                string iDValue = iDJsonValue.asString();
                if (iDValue.size() > 0 && CamDevSqliteDao::instance()->updateCamDev(camDevBuilder.buildCamDevMap(), "ID", iDValue)) {
                    responseJsonValue["success"] = "true";
                    responseJsonValue["message"] = "更新成功！";
                }
            }
        }
        return responseJsonValue.toStyledString();
    }
    
    /** 查找单个摄像头设备 */
    std::string findCamDev(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)) {
            CamDevBuilder camDevBuilder;
	    
            Json::Value idJsonValue = requestJsonValue[CamDev_id];
            if (idJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addid(std::stoi((idJsonValue.asString())));
            }
	    
            Json::Value cam_dev_idJsonValue = requestJsonValue[CamDev_cam_dev_id];
            if (cam_dev_idJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addcam_dev_id((cam_dev_idJsonValue.asString()));
            }
	    
            Json::Value nameJsonValue = requestJsonValue[CamDev_name];
            if (nameJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addname((nameJsonValue.asString()));
            }
	    
            Json::Value addrJsonValue = requestJsonValue[CamDev_addr];
            if (addrJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addaddr((addrJsonValue.asString()));
            }
	    
            Json::Value longitudeJsonValue = requestJsonValue[CamDev_longitude];
            if (longitudeJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addlongitude((longitudeJsonValue.asString()));
            }
	    
            Json::Value latitudeJsonValue = requestJsonValue[CamDev_latitude];
            if (latitudeJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addlatitude((latitudeJsonValue.asString()));
            }
	    
            Json::Value ipJsonValue = requestJsonValue[CamDev_ip];
            if (ipJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addip((ipJsonValue.asString()));
            }
	    
            Json::Value portJsonValue = requestJsonValue[CamDev_port];
            if (portJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addport(std::stoi((portJsonValue.asString())));
            }
	    
            Json::Value usernameJsonValue = requestJsonValue[CamDev_username];
            if (usernameJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addusername((usernameJsonValue.asString()));
            }
	    
            Json::Value passwordJsonValue = requestJsonValue[CamDev_password];
            if (passwordJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addpassword((passwordJsonValue.asString()));
            }
	    
            Json::Value brandJsonValue = requestJsonValue[CamDev_brand];
            if (brandJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addbrand((brandJsonValue.asString()));
            }
	    
            Json::Value reservedJsonValue = requestJsonValue[CamDev_reserved];
            if (reservedJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addreserved((reservedJsonValue.asString()));
            }
	    
            Json::Value typeJsonValue = requestJsonValue[CamDev_type];
            if (typeJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addtype((typeJsonValue.asString()));
            }
            responseJsonValue["message"] = "查询成功！";
            responseJsonValue["success"] = "true";
            responseJsonValue["data"] = CamDevSqliteDao::instance()->findJsonArray(string("select * from ") + CamDev_TABLE_NAME + " where 1 = 1 limit 1");
        }
        return responseJsonValue.toStyledString();
    }
    
    /** 查找摄像头设备列表 */
    std::string findCamDevList(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)) {
            CamDevBuilder camDevBuilder;
	    
            Json::Value idJsonValue = requestJsonValue[CamDev_id];
            if (idJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addid(std::stoi((idJsonValue.asString())));
            }
	    
            Json::Value cam_dev_idJsonValue = requestJsonValue[CamDev_cam_dev_id];
            if (cam_dev_idJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addcam_dev_id((cam_dev_idJsonValue.asString()));
            }
	    
            Json::Value nameJsonValue = requestJsonValue[CamDev_name];
            if (nameJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addname((nameJsonValue.asString()));
            }
	    
            Json::Value addrJsonValue = requestJsonValue[CamDev_addr];
            if (addrJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addaddr((addrJsonValue.asString()));
            }
	    
            Json::Value longitudeJsonValue = requestJsonValue[CamDev_longitude];
            if (longitudeJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addlongitude((longitudeJsonValue.asString()));
            }
	    
            Json::Value latitudeJsonValue = requestJsonValue[CamDev_latitude];
            if (latitudeJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addlatitude((latitudeJsonValue.asString()));
            }
	    
            Json::Value ipJsonValue = requestJsonValue[CamDev_ip];
            if (ipJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addip((ipJsonValue.asString()));
            }
	    
            Json::Value portJsonValue = requestJsonValue[CamDev_port];
            if (portJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addport(std::stoi((portJsonValue.asString())));
            }
	    
            Json::Value usernameJsonValue = requestJsonValue[CamDev_username];
            if (usernameJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addusername((usernameJsonValue.asString()));
            }
	    
            Json::Value passwordJsonValue = requestJsonValue[CamDev_password];
            if (passwordJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addpassword((passwordJsonValue.asString()));
            }
	    
            Json::Value brandJsonValue = requestJsonValue[CamDev_brand];
            if (brandJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addbrand((brandJsonValue.asString()));
            }
	    
            Json::Value reservedJsonValue = requestJsonValue[CamDev_reserved];
            if (reservedJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addreserved((reservedJsonValue.asString()));
            }
	    
            Json::Value typeJsonValue = requestJsonValue[CamDev_type];
            if (typeJsonValue.type() != Json::ValueType::nullValue) {
                camDevBuilder.addtype((typeJsonValue.asString()));
            }
            responseJsonValue["message"] = "查询成功！";
            responseJsonValue["success"] = "true";
            responseJsonValue["data"] = CamDevSqliteDao::instance()->findJsonArray(string("select * from ") + CamDev_TABLE_NAME + " where 1 = 1");

        }
        return responseJsonValue.toStyledString();
    }
};






#endif //CAMDEV_CONTROLLER_H






 QiaoJiaSystem/DataManagerServer/vss/controller/VssLocalSettingTblController.h

@@ -172,10 +172,7 @@
            }

            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"] = "更新成功！";

                }

                responseJsonValue = VssLocalSettingTblSqliteDao::instance()->updateVssLocalSettingTbl(vssLocalSettingTblBuilder.buildVssLocalSettingTblMap(), "ID", iDValue);

            }

        }

        return responseJsonValue.toStyledString();

@@ -227,7 +224,7 @@
            }

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

            responseJsonValue["success"] = "true";

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

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

        }

        return responseJsonValue.toStyledString();

    }


 QiaoJiaSystem/DataManagerServer/vss/dao/BaseSqliteDao.h

New file
@@ -0,0 +1,28 @@
#ifndef QIAOJIASYSTEM_BASESQLITEDAO_H
#define QIAOJIASYSTEM_BASESQLITEDAO_H



class BaseSqliteDao {
protected:
public:

    static LDBTool* lDBTool;

    static QSqlDatabase* m_db;
    static QSqlTableModel *m_pModel;
    static QMutex* m_mutexVisit;
    static void setLDBTool(LDBTool* lDBTool) {
        BaseSqliteDao::lDBTool = lDBTool;
        BaseSqliteDao::m_db = lDBTool->get_m_db();
        BaseSqliteDao::m_pModel = lDBTool->get_m_pModel();
        BaseSqliteDao::m_mutexVisit = lDBTool->get_m_mutexVisit();
    }
};

LDBTool* BaseSqliteDao::lDBTool = nullptr;
QSqlDatabase* BaseSqliteDao::m_db = nullptr;
QSqlTableModel *BaseSqliteDao::m_pModel = nullptr;
QMutex* BaseSqliteDao::m_mutexVisit = nullptr;

#endif //QIAOJIASYSTEM_BASESQLITEDAO_H

 QiaoJiaSystem/DataManagerServer/vss/dao/CamDevSqliteDao.h

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

#ifndef CAMDEV_MANAGER_H
#define CAMDEV_MANAGER_H

#include "../model/CamDev.h"
#include "BaseSqliteDao.h"

#define CamDev_TABLE_NAME "CamDev"

/**
 * 摄像头设备管理类
 */
class CamDevSqliteDao : public BaseSqliteDao {
private:
    /** 摄像头设备构造函数 */
    CamDevSqliteDao() {}
public:
    /** 摄像头设备单例模式 */
    static CamDevSqliteDao* instance() {
        static CamDevSqliteDao instance;
        return &instance;
    }
    
    /** 添加摄像头设备 keyValuesToAdd 需要添加的列名和列值对map*/
    mysqlpp::SimpleResult addCamDev(std::map<std::string, std::string>& keyValuesToAdd) {
        return add(keyValuesToAdd, CamDev_TABLE_NAME);
    }
    
    /** 删除摄像头设备 whereKey 列名；whereValue 列值 */
    bool deleteByColumn(string whereKey, string whereValue) {
        std::map<std::string, std::string> whereKeyValues;
        whereKeyValues[whereKey] = whereValue;
        return deleteCamDev(whereKeyValues);
    }

    /** 删除摄像头设备 whereColumnNameValues 列名和列值对条件 */
    bool deleteCamDev(std::map<std::string, std::string>& whereKeyValues) {
        return del(CamDev_TABLE_NAME, whereKeyValues);
    }
    
    /** 更新摄像头设备 keyValuesToUpdate 需要更新的列名和列值对； whereKeyValues 列名和列值条件 */
    bool updateCamDev(std::map<std::string, std::string>& keyValuesToUpdate, 
                                    std::map<std::string, std::string>& whereKeyValues) {
        return update(keyValuesToUpdate, CamDev_TABLE_NAME, whereKeyValues);
    }
	
    /** 更新创建二级设备表 keyValuesToUpdate 需要更新的列名和列值对； whereKeyValues 列名和列值条件 */
    bool updateCamDev(std::map<std::string, std::string>& keyValuesToUpdate,
                             string whereKey,
                             string whereValue) {
        std::map<std::string, std::string> whereKeyValues;
        whereKeyValues[whereKey] = whereValue;
        return update(keyValuesToUpdate, CamDev_TABLE_NAME, whereKeyValues);
    }
	
    /** 查询摄像头设备列表  querySql 要查询的sql语句 */
    vector<CamDev> findCamDevList(string querySql) {
        vector<CamDev> camDevVec;
        vector<map<string, string>> rowDatList = findList(querySql);
        camDevVec.reserve(rowDatList.size());
        for (auto rowData : rowDatList) {
            camDevVec.emplace_back(mapToModel(rowData));
        }
        return camDevVec;
    }
	
    /**查询摄像头设备列表 whereKeyValues 列名和列值对条件 */
    vector<CamDev> findCamDevList(std::map<std::string, std::string>& whereKeyValues) {
        return findCamDevList(string("select * from ") + CamDev_TABLE_NAME + " where 1=1 " + getWhereColumnNameValuePair(whereKeyValues));
    }
    
    /**查询所有摄像头设备列表 */
    vector<CamDev> findAllCamDevList() {
        return findCamDevList(string("select * from ") + CamDev_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类 */
    CamDev mapToModel(map<string, string>& rowData) {
        CamDev camDev;
        string idValue = rowData[CamDev_id];
        if (idValue.length() != 0 && idValue != "NULL") {
            camDev.id = std::stoi(idValue);
        }
        string cam_dev_idValue = rowData[CamDev_cam_dev_id];
        if (cam_dev_idValue.length() != 0 && cam_dev_idValue != "NULL") {
            camDev.cam_dev_id = cam_dev_idValue;
        }
        string nameValue = rowData[CamDev_name];
        if (nameValue.length() != 0 && nameValue != "NULL") {
            camDev.name = nameValue;
        }
        string addrValue = rowData[CamDev_addr];
        if (addrValue.length() != 0 && addrValue != "NULL") {
            camDev.addr = addrValue;
        }
        string longitudeValue = rowData[CamDev_longitude];
        if (longitudeValue.length() != 0 && longitudeValue != "NULL") {
            camDev.longitude = longitudeValue;
        }
        string latitudeValue = rowData[CamDev_latitude];
        if (latitudeValue.length() != 0 && latitudeValue != "NULL") {
            camDev.latitude = latitudeValue;
        }
        string ipValue = rowData[CamDev_ip];
        if (ipValue.length() != 0 && ipValue != "NULL") {
            camDev.ip = ipValue;
        }
        string portValue = rowData[CamDev_port];
        if (portValue.length() != 0 && portValue != "NULL") {
            camDev.port = std::stoi(portValue);
        }
        string usernameValue = rowData[CamDev_username];
        if (usernameValue.length() != 0 && usernameValue != "NULL") {
            camDev.username = usernameValue;
        }
        string passwordValue = rowData[CamDev_password];
        if (passwordValue.length() != 0 && passwordValue != "NULL") {
            camDev.password = passwordValue;
        }
        string brandValue = rowData[CamDev_brand];
        if (brandValue.length() != 0 && brandValue != "NULL") {
            camDev.brand = brandValue;
        }
        string reservedValue = rowData[CamDev_reserved];
        if (reservedValue.length() != 0 && reservedValue != "NULL") {
            camDev.reserved = reservedValue;
        }
        string typeValue = rowData[CamDev_type];
        if (typeValue.length() != 0 && typeValue != "NULL") {
            camDev.type = typeValue;
        }
        return camDev;
    }
   
};


#endif //CAMDEV_MANAGER_H



 QiaoJiaSystem/DataManagerServer/vss/dao/VssLocalSettingTblSqliteDao.h

@@ -3,7 +3,7 @@
#define VSSLOCALSETTINGTBL_Sqlite_MANAGER_H



#include "../model/VssLocalSettingTbl.h"

#include "BaseDao.h"

#include "BaseSqliteDao.h"



#define VSSLocalSettingTbl_Sqlite_TABLE_NAME "VSSLocalSettingTbl"



@@ -11,23 +11,11 @@
/**

 * 本地国标配置管理类

 */

class VssLocalSettingTblSqliteDao : public BaseDao {

class VssLocalSettingTblSqliteDao : public BaseSqliteDao {

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() {

@@ -119,7 +107,7 @@
    Json::Value updateVssLocalSettingTbl(std::map<std::string, std::string>& keyValuesToUpdate,

                                    std::map<std::string, std::string>& whereKeyValues) {

        Json::Value responseJsonValue;

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

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

        responseJsonValue["success"] = "false";

        QMutexLocker mutexLocker(m_mutexVisit);//TODO

        QSqlTableModel pModel(NULL, *m_db);

@@ -157,7 +145,7 @@
        if (pModel.submitAll()) {

            m_db->commit();//提交

            responseJsonValue["success"] = "true";

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

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

        } else {

            m_db->rollback();//回滚

            ERR("updateLDeviceTable ,pModel_load Error: " << pModel.lastError().text().toStdString());

@@ -166,12 +154,12 @@
    }



    /** 更新创建二级设备表 keyValuesToUpdate 需要更新的列名和列值对； whereKeyValues 列名和列值条件 */

    bool updateVssLocalSettingTbl(std::map<std::string, std::string>& keyValuesToUpdate,

    Json::Value 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);

        return updateVssLocalSettingTbl(keyValuesToUpdate, whereKeyValues);

    }



    /** 查询本地国标配置列表  querySql 要查询的sql语句 */

@@ -219,49 +207,6 @@
        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;

    }



};




 QiaoJiaSystem/DataManagerServer/vss/model/CamDev.h

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

#ifndef CAMDEV_H
#define CAMDEV_H
#include <mysql++.h>
#include <string>
using std::string;

#define CamDev_id "id"
#define CamDev_cam_dev_id "cam_dev_id"
#define CamDev_name "name"
#define CamDev_addr "addr"
#define CamDev_longitude "longitude"
#define CamDev_latitude "latitude"
#define CamDev_ip "ip"
#define CamDev_port "port"
#define CamDev_username "username"
#define CamDev_password "password"
#define CamDev_brand "brand"
#define CamDev_reserved "reserved"
#define CamDev_type "type"

/**
 * 摄像头设备
 */
class CamDev {
public:
    int id                   ; 
    std::string cam_dev_id   ; 
    std::string name         ; 
    std::string addr         ; 
    std::string longitude    ; 
    std::string latitude     ; 
    std::string ip           ; 
    int port                 ; 
    std::string username     ; 
    std::string password     ; 
    std::string brand        ; 
    std::string reserved     ; 
    std::string type         ; 
public:
    /** 摄像头设备 构造函数*/
    CamDev() {
        id = 0                   ;
        cam_dev_id = ""          ;
        name = ""                ;
        addr = ""                ;
        longitude = ""           ;
        latitude = ""            ;
        ip = ""                  ;
        port = 0                 ;
        username = ""            ;
        password = ""            ;
        brand = ""               ;
        reserved = ""            ;
        type = ""                ;
    }
};


#endif //CAMDEV_H



 QiaoJiaSystem/DataManagerServer/vss/model/CamDevBuilder.h

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

#ifndef CAMDEV_BUILDER_H
#define CAMDEV_BUILDER_H
#include <string>
#include <vector>
#include "CamDev.h"
using namespace std;

/**
 * 摄像头设备构建器
 */
class CamDevBuilder {
public:
    CamDevBuilder& addid(int id) {
        camDevMap[CamDev_id] = to_string(id);
        return *this;
    }
    CamDevBuilder& addcam_dev_id(std::string cam_dev_id) {
        camDevMap[CamDev_cam_dev_id] = cam_dev_id;
        return *this;
    }
    CamDevBuilder& addname(std::string name) {
        camDevMap[CamDev_name] = name;
        return *this;
    }
    CamDevBuilder& addaddr(std::string addr) {
        camDevMap[CamDev_addr] = addr;
        return *this;
    }
    CamDevBuilder& addlongitude(std::string longitude) {
        camDevMap[CamDev_longitude] = longitude;
        return *this;
    }
    CamDevBuilder& addlatitude(std::string latitude) {
        camDevMap[CamDev_latitude] = latitude;
        return *this;
    }
    CamDevBuilder& addip(std::string ip) {
        camDevMap[CamDev_ip] = ip;
        return *this;
    }
    CamDevBuilder& addport(int port) {
        camDevMap[CamDev_port] = to_string(port);
        return *this;
    }
    CamDevBuilder& addusername(std::string username) {
        camDevMap[CamDev_username] = username;
        return *this;
    }
    CamDevBuilder& addpassword(std::string password) {
        camDevMap[CamDev_password] = password;
        return *this;
    }
    CamDevBuilder& addbrand(std::string brand) {
        camDevMap[CamDev_brand] = brand;
        return *this;
    }
    CamDevBuilder& addreserved(std::string reserved) {
        camDevMap[CamDev_reserved] = reserved;
        return *this;
    }
    CamDevBuilder& addtype(std::string type) {
        camDevMap[CamDev_type] = type;
        return *this;
    }
    /** 摄像头设备 map */
    std::map<std::string, std::string>& buildCamDevMap() {
        return camDevMap;
    }
public:
    std::map<std::string, std::string> camDevMap;
};

#endif //CAMDEV_BUILDER_H



 QiaoJiaSystem/DataManagerServer/vss/test/CamDevSqliteDaoTest.h

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

#ifndef CAMDEV_MANAGER_TEST_H
#define CAMDEV_MANAGER_TEST_H

#include "../model/CamDev.h"
#include "../model/CamDevBuilder.h"
#include "../dao/CamDevSqliteDao.h"
#include <basic/debug/Debug.h>

/**
 * 测试摄像头设备管理类
 */
class CamDevSqliteDaoTest {
private:
    /** 摄像头设备SqliteDaoTest构造函数 */
    CamDevSqliteDaoTest() {}
public:
    /** 摄像头设备SqliteDaoTest单例模式 */
    static CamDevSqliteDaoTest* instance() {
        static CamDevSqliteDaoTest instance;
        return &instance;
    }

    /** 测试添加摄像头设备 */
    void testAddCamDev() {
        CamDevBuilder camDevBuilder;
        camDevBuilder.addid(0);
        camDevBuilder.addcam_dev_id("");
        camDevBuilder.addname("");
        camDevBuilder.addaddr("");
        camDevBuilder.addlongitude("");
        camDevBuilder.addlatitude("");
        camDevBuilder.addip("");
        camDevBuilder.addport(0);
        camDevBuilder.addusername("");
        camDevBuilder.addpassword("");
        camDevBuilder.addbrand("");
        camDevBuilder.addreserved("");
        camDevBuilder.addtype("");
        CamDevSqliteDao::instance()->addCamDev(camDevBuilder.buildCamDevMap());
    }
    
    /** 测试更新摄像头设备 */
    void testUpdateCamDev() {
        CamDevBuilder camDevBuilder;
        camDevBuilder.addid(0);
        camDevBuilder.addcam_dev_id("");
        camDevBuilder.addname("");
        camDevBuilder.addaddr("");
        camDevBuilder.addlongitude("");
        camDevBuilder.addlatitude("");
        camDevBuilder.addip("");
        camDevBuilder.addport(0);
        camDevBuilder.addusername("");
        camDevBuilder.addpassword("");
        camDevBuilder.addbrand("");
        camDevBuilder.addreserved("");
        camDevBuilder.addtype("");
    
        CamDevSqliteDao::instance()->updateCamDev(camDevBuilder.buildCamDevMap(),
                                                  camDevBuilder.buildCamDevMap());
    }
    
    /** 测试查询摄像头设备列表*/
    void testFindCamDevList() {
        vector<CamDev> camDevVec = CamDevSqliteDao::instance()->findAllCamDevList();
    }
    
private:
	
};

#endif //CAMDEV_MANAGER_TEST_H