Merge branch 'yw.1.2.fixbug' of ssh://192.168.1.226:29418/development/c++ i...

pansen

2019-03-05 e634f49a3b619017a3d040d1bdf68aebad07ae4f

Merge branch 'yw.1.2.fixbug' of ssh://192.168.1.226:29418/development/c++ into yw.1.2

 QiaoJiaSystem/DataManagerServer/http_configserver.cpp

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

#ifdef  MYSQLRET
#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"
#endif
#include "vss/controller/CamDevController.h"

using namespace std;

@@ -250,15 +249,17 @@
                                         std::placeholders::_1, std::placeholders::_2,
                                         std::placeholders::_3, std::placeholders::_4));

#ifdef  MYSQLRET

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


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

 QiaoJiaSystem/DataManagerServer/vss/controller/CamDevController.h

New file
@@ -0,0 +1,412 @@
#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) {
                responseJsonValue = CamDevSqliteDao::instance()->addCamDev(keyValuesToAdd);
            }
        }
        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["id"];
            if (iDJsonValue.type() != Json::ValueType::nullValue) {
                string iDValue = iDJsonValue.asString();
                responseJsonValue = CamDevSqliteDao::instance()->deleteByColumn("id", iDValue);
            }

        }
        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) {
                responseJsonValue = CamDevSqliteDao::instance()->updateCamDev(camDevBuilder.buildCamDevMap(), "id", idJsonValue.asString());
            }
        }
        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 = CamDevSqliteDao::instance()->findCamDevList(camDevBuilder.buildCamDevMap());
        }
        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 = CamDevSqliteDao::instance()->findCamDevList(camDevBuilder.buildCamDevMap());

        }
        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,212 @@

#ifndef CAMDEV_MANAGER_H
#define CAMDEV_MANAGER_H

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

#define CamDev_TABLE_NAME "cam_dev"

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

    /** 添加摄像头设备 keyValuesToAdd 需要添加的列名和列值对map*/
    Json::Value addCamDev(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(CamDev_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("addCamDev 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 deleteCamDev(whereKeyValues);
    }

    /** 删除摄像头设备 whereKey 列名；whereValue 列值 */
    Json::Value deleteCamDev(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(CamDev_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 updateCamDev(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(CamDev_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 列名和列值条件 */
    Json::Value updateCamDev(std::map<std::string, std::string>& keyValuesToUpdate,
                             string whereKey,
                             string whereValue) {
        std::map<std::string, std::string> whereKeyValues;
        whereKeyValues[whereKey] = whereValue;
        return updateCamDev(keyValuesToUpdate, whereKeyValues);
    }

    /**查询摄像头设备列表 whereKeyValues 列名和列值对条件 */
    Json::Value findCamDevList(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(CamDev_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 findAllCamDevList() {
        std::map<std::string, std::string> whereKeyValues;
        return findCamDevList(whereKeyValues);
    }

};


#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


 QiaoJiaSystem/VideoServer/QiaoJia/DB/LDBTool.cpp

@@ -2732,3 +2732,40 @@

    return ruleMap;
}


/**
 * type 0 rtsp, 1 gb28181
 */
std::list<Record_Cam_Dev> LDBTool::searchCamDevTableByType(int type) {
    QMutexLocker mutexLocker(&m_mutexVisit);//TODO
    std::list<Record_Cam_Dev> lst;
    QSqlTableModel pModel(NULL, m_db);
    pModel.setTable("cam_dev");
    pModel.setFilter(QObject::tr((string("cam_dev_id != '' and cam_dev_id is not null and type='")+to_string(type)+"'").c_str()));
    pModel.setEditStrategy(QSqlTableModel::OnManualSubmit);//OnManualSubmit OnFieldChange
    pModel.select();

    int rowCount = pModel.rowCount();
    if (rowCount > 0) {
        for (int i = 0; i < rowCount; ++i) {
            Record_Cam_Dev lChannelRec;
            QSqlRecord rec = pModel.record(i);
            lChannelRec.n_id = rec.value("id").toInt();
            lChannelRec.str_cam_dev_id = rec.value("cam_dev_id").toString();
            lChannelRec.str_name = rec.value("name").toString();
            lChannelRec.str_addr = rec.value("addr").toString();
            lChannelRec.str_longitude = rec.value("longitude").toString();
            lChannelRec.str_latitude = rec.value("latitude").toString();
            lChannelRec.str_ip = rec.value("ip").toString();
            lChannelRec.n_port = rec.value("port").toInt();
            lChannelRec.str_username = rec.value("username").toString();
            lChannelRec.str_password = rec.value("password").toString();
            lChannelRec.str_brand = rec.value("brand").toString();
            lChannelRec.str_reserved = rec.value("reserved").toString();
            lst.push_back(lChannelRec);
        }
    }

    return lst;
}

 QiaoJiaSystem/VideoServer/QiaoJia/DB/LDBTool.h

@@ -50,6 +50,7 @@
    bool deleteCamDevandSdkByCamID(QString strCamId);
    bool updateCamDevTable(Record_Cam_Dev camRec);
    std::list<Record_Cam_Dev> searchCamDevTableAll(void);
    std::list<Record_Cam_Dev> searchCamDevTableByType(int type);
    int searchCamDevNumber(void);
    bool searchCamDevByCamId(QString strCamId);
    bool updateCamDevSnapshot(const QString& strIp ,const QString& imgUrl);

 QiaoJiaSystem/build/DataWebServer

Binary files differ

 QiaoJiaSystem/build/config.db

Binary files differ