673 lines
18 KiB
C++
673 lines
18 KiB
C++
#include "DataMng.h"
|
|
#include "pub_utility_api/FileUtil.h"
|
|
#include "pub_utility_api/CommonConfigParse.h"
|
|
#include "boost/asio/ip/host_name.hpp"
|
|
|
|
#include <QDomDocument>
|
|
#include <QJsonObject>
|
|
#include <QJsonDocument>
|
|
#include <QByteArray>
|
|
#include <QJsonArray>
|
|
#include <QFile>
|
|
#include <QApplication>
|
|
#include <QDebug>
|
|
#include <QTextCodec>
|
|
#include <QDir>
|
|
|
|
using namespace sys_startup;
|
|
using namespace std;
|
|
using namespace iot_public;
|
|
|
|
DataMng *DataMng::m_pInstance = Q_NULLPTR;
|
|
|
|
DataMng *DataMng::instance()
|
|
{
|
|
if(m_pInstance == Q_NULLPTR)
|
|
{
|
|
m_pInstance = new DataMng();
|
|
}
|
|
return m_pInstance;
|
|
}
|
|
|
|
void DataMng::destory()
|
|
{
|
|
if(m_mutex)
|
|
{
|
|
delete m_mutex;
|
|
}
|
|
m_mutex = Q_NULLPTR;
|
|
if(m_mutexApp)
|
|
{
|
|
delete m_mutexApp;
|
|
}
|
|
m_mutexApp = Q_NULLPTR;
|
|
|
|
if(m_mutexProc)
|
|
{
|
|
delete m_mutexProc;
|
|
}
|
|
m_mutexProc = Q_NULLPTR;
|
|
|
|
m_pInstance = Q_NULLPTR;
|
|
|
|
delete this;
|
|
}
|
|
|
|
bool DataMng::loadJson()
|
|
{
|
|
QFile loadFile(iot_public::CFileUtil::getPathOfCfgFile("sys_startup.json").c_str());
|
|
if(!loadFile.exists() || !loadFile.open(QIODevice::ReadOnly | QIODevice::Text))
|
|
{
|
|
return false;
|
|
}
|
|
QString allData = loadFile.readAll();
|
|
|
|
loadFile.close();
|
|
|
|
QJsonParseError error;
|
|
QJsonDocument document = QJsonDocument::fromJson(allData.toUtf8(),&error);
|
|
if(error.error != QJsonParseError::NoError)
|
|
{
|
|
qDebug()<<error.errorString();
|
|
return false;
|
|
}
|
|
QJsonObject rootObj = document.object();
|
|
if(!rootObj.contains("buttoninfo"))
|
|
{
|
|
return false;
|
|
}
|
|
QJsonObject buttonObj = rootObj.value("buttoninfo").toObject();
|
|
int buttonCount = buttonObj["count"].toInt();
|
|
for(int index = 0;index<buttonCount;index++)
|
|
{
|
|
QString name = QString("num%1").arg(index);
|
|
if(!buttonObj.contains(name))
|
|
{
|
|
return false;
|
|
}
|
|
QJsonObject button = buttonObj.value(name).toObject();
|
|
SButtonInfo buttonInfo;
|
|
buttonInfo.m_zh = button["zh"].toString();
|
|
buttonInfo.m_en = button["en"].toString();
|
|
buttonInfo.m_cmd = button["cmd"].toString();
|
|
buttonInfo.m_param = button["param"].toString();
|
|
buttonInfo.m_icon = button["icon"].toString();
|
|
buttonInfo.m_enable = button["enable"].toBool();
|
|
buttonInfo.m_name = name;
|
|
m_buttonInfoMap[name] = buttonInfo;
|
|
}
|
|
if(rootObj.contains("page1"))
|
|
{
|
|
QJsonArray page1Array = rootObj.value("page1").toArray();
|
|
for(int index(0);index<page1Array.size();index++)
|
|
{
|
|
m_page1ButtonInfoVec.append(page1Array.at(index).toString());
|
|
}
|
|
}
|
|
if(rootObj.contains("page3"))
|
|
{
|
|
QJsonObject page3Obj = rootObj.value("page3").toObject();
|
|
int groupCount = page3Obj["count"].toInt();
|
|
|
|
for(int index(0);index <groupCount;index++)
|
|
{
|
|
QString groupName = QString("group%1").arg(index);
|
|
if(!page3Obj.contains(groupName))
|
|
{
|
|
return false;
|
|
}
|
|
QJsonObject button = page3Obj.value(groupName).toObject();
|
|
SButtonGroup buttonGroup;
|
|
buttonGroup.m_zh = button["zh"].toString();
|
|
buttonGroup.m_en = button["en"].toString();
|
|
buttonGroup.m_groupId = index;
|
|
|
|
QJsonArray buttonArray = button["value"].toArray();
|
|
for(int i = 0;i <buttonArray.size();i++)
|
|
{
|
|
buttonGroup.m_buttonVec.append(buttonArray.at(i).toString());
|
|
}
|
|
m_page3ButtonInfoMap[index] = buttonGroup;
|
|
}
|
|
}
|
|
if(rootObj.contains("startpng"))
|
|
{
|
|
m_stStartPng = rootObj["startpng"].toString();
|
|
}
|
|
if(rootObj.contains("stoppng"))
|
|
{
|
|
m_stStopPng = rootObj["stoppng"].toString();
|
|
}
|
|
if(rootObj.contains("startbarbodercolor"))
|
|
{
|
|
m_stStartBorderColor = rootObj["startbarbodercolor"].toString();
|
|
}
|
|
if(rootObj.contains("stopbarbodercolor"))
|
|
{
|
|
m_stStopBorderColor = rootObj["stopbarbodercolor"].toString();
|
|
}
|
|
if(rootObj.contains("startbarwatercolor"))
|
|
{
|
|
m_stStartWaterColor = rootObj["startbarwatercolor"].toString();
|
|
}
|
|
if(rootObj.contains("stopbarwatercolor"))
|
|
{
|
|
m_stStopWaterColor = rootObj["stopbarwatercolor"].toString();
|
|
}
|
|
if(rootObj.contains("sysicon"))
|
|
{
|
|
m_stSysIcon = rootObj["sysicon"].toString();
|
|
}
|
|
if(rootObj.contains("restartpng"))
|
|
{
|
|
m_stRestartPng = rootObj["restartpng"].toString();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void DataMng::loadVersion()
|
|
{
|
|
m_versionMap.clear();
|
|
CCommonConfigParse config;
|
|
config.load(iot_public::CFileUtil::getPathOfCfgFile(VERSIONXMLNAME));
|
|
std::string strValue;
|
|
config.getStringValue(MODULENAME,SOFTWARE_VERSION,strValue);
|
|
m_versionMap.insert(QString::fromStdString(SOFTWARE_VERSION),QString::fromStdString(strValue));
|
|
config.getStringValue(MODULENAME,SOFTWARE_ISMAIN,strValue);
|
|
m_versionMap.insert(QString::fromStdString(SOFTWARE_ISMAIN),QString::fromStdString(strValue));
|
|
config.getStringValue(MODULENAME,SOFTWARE_ISDB,strValue);
|
|
m_versionMap.insert(QString::fromStdString(SOFTWARE_ISDB),QString::fromStdString(strValue));
|
|
config.getStringValue(MODULENAME,SOFTWARE_ISWEB,strValue);
|
|
m_versionMap.insert(QString::fromStdString(SOFTWARE_ISWEB),QString::fromStdString(strValue));
|
|
config.getStringValue(MODULENAME,SOFTWARE_MAINPATH,strValue);
|
|
m_versionMap.insert(QString::fromStdString(SOFTWARE_MAINPATH),QString::fromStdString(strValue));
|
|
#ifdef OS_WINDOWS
|
|
config.getStringValue(MODULENAME,SOFTWARE_DBPATH,strValue);
|
|
m_versionMap.insert(QString::fromStdString(SOFTWARE_DBPATH),QString::fromStdString(strValue));
|
|
#endif
|
|
|
|
config.getStringValue(MODULENAME,SOFTWARE_NAME_EN,strValue);
|
|
m_enTitle = QString::fromStdString(strValue);
|
|
config.getStringValue(MODULENAME,SOFTWARE_NAME_ZH,strValue);
|
|
m_zhTitle = QString::fromStdString(strValue);
|
|
config.getStringValue(MODULENAME,"ProjectName",strValue);
|
|
m_title= QString::fromStdString(strValue);
|
|
config.getStringValue(MODULENAME,"ProjectPng",strValue);
|
|
m_png= QString::fromStdString(strValue);
|
|
}
|
|
|
|
void DataMng::loadLocInfo()
|
|
{
|
|
m_locIdDomainOdMap.clear();
|
|
QString filename = "../../data/sys_model_info/SYS_MODEL_LOCATION_INFO.xml";
|
|
|
|
QFile file( filename );
|
|
if( !file.open(QIODevice::ReadOnly | QIODevice::Text) )
|
|
{
|
|
return ;
|
|
}
|
|
|
|
QDomDocument document;
|
|
if(!document.setContent(&file))
|
|
{
|
|
qDebug()<<"error";
|
|
return ;
|
|
}
|
|
QDomElement table = document.documentElement();//返回根节点table
|
|
QDomNode node = table.firstChild();
|
|
while (!node.isNull()) {
|
|
m_locIdDomainOdMap[node.toElement().attribute("LOCATION_ID").toInt()] = node.toElement().attribute("DOMAIN_ID").toInt();
|
|
node = node.nextSibling();
|
|
}
|
|
}
|
|
|
|
void DataMng::loadUsedNode()
|
|
{
|
|
m_nodeVec.clear();
|
|
m_nodeLocIdMap.clear();
|
|
QString filename = "../../data/sys_model_info/SYS_MODEL_NODE_INFO.xml";
|
|
|
|
QFile file( filename );
|
|
if( !file.open(QIODevice::ReadOnly | QIODevice::Text) )
|
|
{
|
|
return ;
|
|
}
|
|
|
|
QDomDocument document;
|
|
if(!document.setContent(&file))
|
|
{
|
|
qDebug()<<"error";
|
|
return ;
|
|
}
|
|
QDomElement table = document.documentElement();//返回根节点table
|
|
QDomNode node = table.firstChild();
|
|
while (!node.isNull()) {
|
|
if(node.toElement().hasAttribute("IS_USED"))
|
|
{
|
|
if(node.toElement().attribute("IS_USED").toInt() == 1)
|
|
{
|
|
if ( node.toElement().attribute("NODE_TYPE").toInt() == ENodeType::ENodeType_ApplicationServer ||
|
|
node.toElement().attribute("NODE_TYPE").toInt() == ENodeType::ENodeType_Workstation )
|
|
{
|
|
m_nodeVec.append(node.toElement().attribute("NODE_NAME"));
|
|
}
|
|
}
|
|
m_nodeLocIdMap[node.toElement().attribute("NODE_NAME")] = node.toElement().attribute("LOCATION_ID").toInt();
|
|
}
|
|
node = node.nextSibling();
|
|
}
|
|
}
|
|
|
|
void DataMng::loadModelAppInfo()
|
|
{
|
|
m_modelAppInfoMap.clear();
|
|
QString filename = "../../data/sys_model_info/SYS_MODEL_APP_INFO.xml";
|
|
|
|
QFile file( filename );
|
|
if( !file.open(QIODevice::ReadOnly | QIODevice::Text) )
|
|
{
|
|
return ;
|
|
}
|
|
|
|
QDomDocument document;
|
|
if(!document.setContent(&file))
|
|
{
|
|
qDebug()<<"error";
|
|
return ;
|
|
}
|
|
QDomElement table = document.documentElement();//返回根节点table
|
|
QDomNode node = table.firstChild();
|
|
while (!node.isNull()) {
|
|
SSysModelAppInfo modelAppInfo;
|
|
modelAppInfo.m_appId = node.toElement().attribute("APP_ID").toInt();
|
|
modelAppInfo.m_tagName = node.toElement().attribute("TAG_NAME").toStdString(); //标签
|
|
modelAppInfo.m_desc = node.toElement().attribute("DESCRIPTION").toStdString(); //描述
|
|
m_modelAppInfoMap[modelAppInfo.m_appId] = modelAppInfo;
|
|
node = node.nextSibling();
|
|
}
|
|
}
|
|
|
|
void DataMng::loadModelDeployInfo()
|
|
{
|
|
m_modelDeployInfoMap.clear();
|
|
for( int index(0);index< m_nodeVec.size();index++)
|
|
{
|
|
SApp a;
|
|
a.m_appId = CN_AppId_BASE;
|
|
a.m_appName = m_modelAppInfoMap.value(CN_AppId_BASE).m_tagName;
|
|
a.m_desc = m_modelAppInfoMap.value(CN_AppId_BASE).m_desc;
|
|
a.m_nodeName =m_nodeVec.at(index).toStdString();
|
|
QMap<int ,SApp> appMap;
|
|
appMap[CN_AppId_BASE] = a;
|
|
m_modelDeployInfoMap[m_nodeVec.at(index)] = appMap;
|
|
}
|
|
|
|
QString filename = "../../data/sys_model_info/SYS_MODEL_DEPLOY_INFO.xml";
|
|
|
|
QFile file( filename );
|
|
if( !file.open(QIODevice::ReadOnly | QIODevice::Text) )
|
|
{
|
|
return ;
|
|
}
|
|
|
|
QDomDocument document;
|
|
if(!document.setContent(&file))
|
|
{
|
|
qDebug()<<"error";
|
|
return ;
|
|
}
|
|
QDomElement table = document.documentElement();//返回根节点table
|
|
QDomNode node = table.firstChild();
|
|
while (!node.isNull()) {
|
|
int num = node.toElement().attribute("NUM").toInt();
|
|
int app_id = node.toElement().attribute("APP_ID").toInt();
|
|
QString app_desc = QString::fromStdString(m_modelAppInfoMap.value(app_id).m_desc);
|
|
|
|
for(int i = 1;i <= num; i++)
|
|
{
|
|
QString nodeName = node.toElement().attribute(QString("NODE%1").arg(i));
|
|
QMap<QString, QMap<int ,SApp> >::iterator it = m_modelDeployInfoMap.find(nodeName);
|
|
if(it!= m_modelDeployInfoMap.end())
|
|
{
|
|
QMap<int ,SApp> &info = it.value();
|
|
SApp a;
|
|
a.m_appId = app_id;
|
|
a.m_appName = m_modelAppInfoMap.value(app_id).m_tagName;
|
|
a.m_desc = app_desc.toStdString();
|
|
a.m_nodeName =node.toElement().attribute(QString("NODE%1").arg(i)).toStdString();
|
|
if(nodeIsUsed(a.m_nodeName))
|
|
{
|
|
info[a.m_appId] = a;
|
|
}
|
|
}else
|
|
{
|
|
QMap<int ,SApp> info;
|
|
SApp a;
|
|
a.m_appId = app_id;
|
|
a.m_appName = m_modelAppInfoMap.value(app_id).m_tagName;
|
|
a.m_desc = app_desc.toStdString();
|
|
a.m_nodeName =node.toElement().attribute(QString("NODE%1").arg(i)).toStdString();
|
|
if(nodeIsUsed(a.m_nodeName))
|
|
{
|
|
info[a.m_appId] = a;
|
|
m_modelDeployInfoMap[nodeName] = info;
|
|
}
|
|
}
|
|
}
|
|
node = node.nextSibling();
|
|
}
|
|
}
|
|
|
|
bool DataMng::nodeIsUsed(const std::string &nodeName)
|
|
{
|
|
bool res = false;
|
|
for(int index(0);index<m_nodeVec.size();index++)
|
|
{
|
|
if(nodeName == m_nodeVec.at(index).toStdString())
|
|
{
|
|
res = true;
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
|
|
void DataMng::loadXml()
|
|
{
|
|
loadLocInfo();
|
|
loadUsedNode();
|
|
loadModelAppInfo();
|
|
loadModelDeployInfo();
|
|
loadLocalProcInfo();
|
|
}
|
|
|
|
int DataMng::getLocalProcNum()
|
|
{
|
|
return m_nLocalProcNum;
|
|
}
|
|
|
|
QMap<QString, QString> DataMng::getVersionInfo()
|
|
{
|
|
return m_versionMap;
|
|
}
|
|
|
|
QString DataMng::getZhTitle()
|
|
{
|
|
return m_zhTitle;
|
|
}
|
|
|
|
QString DataMng::getEnTitle()
|
|
{
|
|
return m_enTitle;
|
|
}
|
|
|
|
void DataMng::loadLocalProcInfo()
|
|
{
|
|
QList<int > localAppIdList;
|
|
localAppIdList.clear();
|
|
m_sysRunProcInfoVec.clear();
|
|
m_modelProcInfoVec.clear();
|
|
QMap<QString,QMap<int,SApp> >::iterator it = m_modelDeployInfoMap.find(getHostName());
|
|
if(it != m_modelDeployInfoMap.end())
|
|
{
|
|
localAppIdList.append(it.value().keys());
|
|
}
|
|
QString filename = "../../data/sys_model_info/SYS_MODEL_PROCESS_INFO.xml";
|
|
|
|
QFile file( filename );
|
|
if( !file.open(QIODevice::ReadOnly | QIODevice::Text) )
|
|
{
|
|
return ;
|
|
}
|
|
|
|
QDomDocument document;
|
|
if(!document.setContent(&file))
|
|
{
|
|
qDebug()<<"error";
|
|
return ;
|
|
}
|
|
QDomElement table = document.documentElement();//返回根节点table
|
|
QDomNode node = table.firstChild();
|
|
while (!(node.isNull())) {
|
|
int app_id = node.toElement().attribute("APP_ID").toInt();
|
|
if(node.toElement().attribute("NOT_USED").toInt() == 1)
|
|
{
|
|
node = node.nextSibling();
|
|
continue;
|
|
}
|
|
if(localAppIdList.contains(app_id))
|
|
{
|
|
SProcess proc;
|
|
proc.m_appId = app_id;
|
|
proc.m_appDesc = m_modelAppInfoMap.value(app_id).m_desc;
|
|
proc.m_nodeName = getHostName().toStdString();
|
|
proc.m_procName = node.toElement().attribute("PROC_NAME").toStdString();
|
|
proc.m_procDesc = node.toElement().attribute("DESCRIPTION").toStdString();
|
|
|
|
m_sysRunProcInfoVec.push_back(proc);
|
|
m_modelProcInfoVec.push_back(proc);
|
|
}
|
|
node = node.nextSibling();
|
|
}
|
|
m_nLocalProcNum = (int)m_sysRunProcInfoVec.size();
|
|
LOGINFO("本机一共需要启动%d个进程.",m_nLocalProcNum);
|
|
}
|
|
|
|
QVector<QString> DataMng::getPage1ButtonInfo()
|
|
{
|
|
return m_page1ButtonInfoVec;
|
|
}
|
|
QString DataMng::getTitle()
|
|
{
|
|
return m_title;
|
|
}
|
|
QString DataMng::getPng()
|
|
{
|
|
return m_png;
|
|
}
|
|
|
|
QMap<int,sys_startup::SButtonGroup> DataMng::getPage3ButtonInfo()
|
|
{
|
|
return m_page3ButtonInfoMap;
|
|
}
|
|
|
|
bool DataMng::getButtonInfoByName(const QString &name, SButtonInfo &buttonInfo)
|
|
{
|
|
QMap<QString,sys_startup::SButtonInfo>::iterator it = m_buttonInfoMap.find(name);
|
|
if(it != m_buttonInfoMap.end())
|
|
{
|
|
buttonInfo = it.value();
|
|
return true;
|
|
}else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
QString DataMng::getStartPng()
|
|
{
|
|
return m_stStartPng;
|
|
}
|
|
|
|
QString DataMng::getStopPng()
|
|
{
|
|
return m_stStopPng;
|
|
}
|
|
|
|
QString DataMng::getStartBorderColor()
|
|
{
|
|
return m_stStartBorderColor;
|
|
}
|
|
|
|
QString DataMng::getStopBorderColor()
|
|
{
|
|
return m_stStopBorderColor;
|
|
}
|
|
|
|
QString DataMng::getStartWaterColor()
|
|
{
|
|
return m_stStartWaterColor;
|
|
}
|
|
|
|
QString DataMng::getStopWaterColor()
|
|
{
|
|
return m_stStopWaterColor;
|
|
}
|
|
|
|
QString DataMng::getSysIcon()
|
|
{
|
|
return m_stSysIcon;
|
|
}
|
|
|
|
QString DataMng::getRestartPng()
|
|
{
|
|
return m_stRestartPng;
|
|
}
|
|
|
|
void DataMng::setBaseStatus(bool runStatus)
|
|
{
|
|
QMutexLocker lock(m_mutex);
|
|
m_bBaseIsRun = runStatus;
|
|
}
|
|
|
|
bool DataMng::getBaseStatus()
|
|
{
|
|
QMutexLocker lock(m_mutex);
|
|
return m_bBaseIsRun;
|
|
}
|
|
|
|
QString DataMng::getHostName()
|
|
{
|
|
return QString::fromStdString(boost::asio::ip::host_name());
|
|
}
|
|
|
|
bool DataMng::getSysStatus()
|
|
{
|
|
QMutexLocker lock(m_mutex);
|
|
return m_bSysIsRun;
|
|
}
|
|
|
|
void DataMng::setSysStatus(bool runStatus)
|
|
{
|
|
QMutexLocker lock(m_mutex);
|
|
m_bSysIsRun = runStatus;
|
|
}
|
|
|
|
bool DataMng::getAllowedStatus()
|
|
{
|
|
QMutexLocker lock(m_mutex);
|
|
return m_bIsAllowedOpt;
|
|
}
|
|
|
|
void DataMng::setAllowedStatus(bool allowed)
|
|
{
|
|
QMutexLocker lock(m_mutex);
|
|
m_bIsAllowedOpt = allowed;
|
|
}
|
|
|
|
SSysModelAppInfo DataMng::getModelAppInfoById(int appId)
|
|
{
|
|
SSysModelAppInfo appInfo;
|
|
return m_modelAppInfoMap.value(appId,appInfo);
|
|
}
|
|
|
|
QMap<QString, QMap<int, SApp> > DataMng::getDeployInfo()
|
|
{
|
|
return m_modelDeployInfoMap;
|
|
}
|
|
|
|
std::vector<SProcess> DataMng::getProcInfo()
|
|
{
|
|
return m_modelProcInfoVec;
|
|
}
|
|
|
|
void DataMng::setRunAppInfo(const vector<SApp> &runAppVec)
|
|
{
|
|
QMutexLocker lock(m_mutexApp);
|
|
m_sysRunAppInfoVec = runAppVec;
|
|
}
|
|
|
|
vector<SApp> DataMng::getRunAppInfo()
|
|
{
|
|
QMutexLocker lock(m_mutexApp);
|
|
return m_sysRunAppInfoVec;
|
|
}
|
|
|
|
void DataMng::setRunProcInfo(const std::vector<SProcess> &runProcVec,const float &disk)
|
|
{
|
|
QMutexLocker lock(m_mutexProc);
|
|
m_sysRunProcInfoVec = runProcVec;
|
|
m_fDisk = disk;
|
|
}
|
|
|
|
void DataMng::getRunProcInfo(std::vector<SProcess> &procVec, float &disk)
|
|
{
|
|
QMutexLocker lock(m_mutexProc);
|
|
procVec = m_sysRunProcInfoVec;
|
|
disk = m_fDisk;
|
|
}
|
|
|
|
int DataMng::getDomainId()
|
|
{
|
|
return m_locIdDomainOdMap.value(m_nodeLocIdMap.value(getHostName(),1),1);
|
|
}
|
|
|
|
std::vector<SApp> DataMng::getInitAppInfoVec()
|
|
{
|
|
std::vector<sys_startup::SApp> initAppInfoVec;
|
|
QMap<QString,QMap<int ,sys_startup::SApp> >::iterator it = m_modelDeployInfoMap.begin();
|
|
while (it != m_modelDeployInfoMap.end()) {
|
|
QMap<int ,sys_startup::SApp> appMap = it.value();
|
|
QMap<int ,sys_startup::SApp>::iterator pos = appMap.begin();
|
|
while (pos != appMap.end()) {
|
|
initAppInfoVec.push_back(pos.value());
|
|
pos++;
|
|
}
|
|
it++;
|
|
}
|
|
return initAppInfoVec;
|
|
}
|
|
|
|
std::vector<SProcess> DataMng::getInitProcInfoVec()
|
|
{
|
|
return m_modelProcInfoVec;
|
|
}
|
|
|
|
std::string DataMng::getAppDescByAppId(int appId)
|
|
{
|
|
return m_modelAppInfoMap.value(appId).m_desc;
|
|
}
|
|
|
|
string DataMng::getAppNameByAppId(int appId)
|
|
{
|
|
return m_modelAppInfoMap.value(appId).m_tagName;
|
|
}
|
|
|
|
std::string DataMng::getProcDescByAppIdAndProcName(int appId, const std::string &procName)
|
|
{
|
|
for(int index(0);index<(int)m_modelProcInfoVec.size();index++)
|
|
{
|
|
if(m_modelProcInfoVec[index].m_appId == appId && m_modelProcInfoVec[index].m_procName == procName)
|
|
{
|
|
return m_modelProcInfoVec[index].m_procDesc;
|
|
}
|
|
}
|
|
return "";
|
|
}
|
|
|
|
DataMng::DataMng():
|
|
m_mutex(Q_NULLPTR),
|
|
m_mutexApp(Q_NULLPTR),
|
|
m_mutexProc(Q_NULLPTR)
|
|
{
|
|
loadJson();
|
|
loadXml();
|
|
loadVersion();
|
|
m_bBaseIsRun = false;
|
|
m_bSysIsRun = false;
|
|
m_bIsAllowedOpt = true;
|
|
m_mutex = new QMutex;
|
|
m_mutexApp = new QMutex;
|
|
m_mutexProc = new QMutex;
|
|
m_fDisk = 0.0;
|
|
}
|