DiagramDesigner/diagramCavas/source/graphicsDataModel/fixedPortsModel.cpp

2407 lines
93 KiB
C++
Raw Normal View History

2026-03-23 11:06:17 +08:00
#include "graphicsDataModel/fixedPortsModel.h"
#include "graphicsItem/graphicsBaseItem.h"
#include "graphicsItem/electricBayItem.h"
#include "graphicsItem/electricBayItem.h"
#include "graphicsItem/functionModelItem/electricFunctionModelSvgItemCB.h"
#include "graphicsItem/functionModelItem/electricFunctionModelPortItem.h"
#include "graphicsItem/functionModelItem/electricFunctionModelSvgItemBus.h"
#include "graphicsItem/functionModelItem/electricFunctionModelSvgGroupCT.h"
#include "graphicsItem/functionModelItem/electricFunctionModelSvgGroupPT.h"
#include "graphicsItem/functionModelItem/electricFunctionModelSvgItemDS.h"
#include "graphicsItem/functionModelItem/electricFunctionModelSvgItemES.h"
#include "graphicsItem/functionModelItem/electricFunctionModelSvgItemFES.h"
#include "graphicsItem/functionModelItem/electricFunctionModelSvgItemDTEDS.h"
#include "graphicsItem/functionModelItem/electricFunctionModelSvgItemPI.h"
#include "graphicsItem/functionModelItem/electricFunctionModelSvgItemLA.h"
#include "graphicsItem/functionModelItem/electricFunctionModelSvgItemCableTer.h"
#include "graphicsItem/functionModelItem/electricFunctionModelSvgItemCableEnd.h"
#include "graphicsItem/functionModelItem/electricFunctionModelSvgItem2wTransformer.h"
#include "graphicsItem/functionModelItem/electricFunctionModelSvgItem3wTransformer.h"
#include "graphicsItem/functionModelItem/electricFunctionModelConnectLineItem.h"
#include "graphicsItem/itemPort.h"
#include "designerScene.h"
#include "dataBase.h"
#include "httpInterface.h"
#include "itemPropertyDlg.h"
#include "dataManager.h"
#include "powerEntity.h"
#include "topologyManager.h"
#include "basePropertyManager.h"
#include "diagramCavas.h"
#include <QJsonArray>
#include <QMessageBox>
#include <QRandomGenerator>
#include <QJsonDocument>
#include <QMdiSubWindow>
#include <QCryptographicHash>
#include "baseProperty.h"
#include "bayManagerDlg.h"
#include "projectModelManager.h"
#include "projectIconSetting.h"
#include "monitorPanel.h"
#include "designerView.h"
#include "uiCommunicationBus.h"
#include "instance/dataAccessor.h"
#include "graphicsItem/handleText.h"
#include "bayMeasureDlg.h"
#include "basePannelPropertyProxy.h"
#include "common/core_model/types.h"
bool FixedPortsModel::_dataInitialised = false;
FixedPortsModel::FixedPortsModel(PowerEntity* pEntity)
:_scene(nullptr)
,_widget(nullptr)
,_Interface(nullptr)
,_pEntity(pEntity)
,m_projectIconSettingDlg(nullptr)
,m_pBayManager(nullptr)
,m_curPropertyDlg(nullptr)
,m_dataTimer(nullptr)
,m_bayMeasureDlg(nullptr)
{
_cavas = nullptr;
loadNodeDataFromDataBase();
ProjectModelManager::instance().initialHMISourcr();
_Interface = new HttpInterface(this);
_timer = new QTimer(this);
m_dataTimer = new QTimer(this);
_modelStateInfo = DataManager::instance().modelState();
_modelDataInfo = DataManager::instance().modelData();
initialPropertyDlg();
connect(_timer,SIGNAL(timeout()),this,SLOT(onTimeOut()));
connect(m_dataTimer,&QTimer::timeout,this,&FixedPortsModel::onDataTimerOut);
m_dataTimer->setInterval(2000);
connect(_Interface,&HttpInterface::sendPointData,this,&FixedPortsModel::onSignal_GetPointData);
}
FixedPortsModel::~FixedPortsModel()
{
_cavas.clear();
}
QMap<QUuid,ItemPageInfo> FixedPortsModel::allNodePos() const
{
QMap<QUuid,ItemPageInfo> map;
for(auto pItem:_nodeItem)
{
if(pItem->getItemType() != GIT_link){
ItemPageInfo info;
double dWidth = pItem->boundingRect().width();
double dHeight = pItem->boundingRect().height();
info.pos = pItem->scenePos()/*+QPointF(dWidth*0.5,dHeight*0.5)*/;
info.dWidth = dWidth;
info.dHeight = dHeight;
info.dRotate = pItem->rotation();
map.insert(pItem->itemId(),info);
}
}
return map;
}
QVector<ModelProperty*> FixedPortsModel::allConnectionProperty()
{
QVector<ModelProperty*> vec;
for(auto pItem:_nodeItem)
{
if(pItem->getItemType() == GIT_link)
{
auto pLine = dynamic_cast<ElectricFunctionModelConnectLineItem*>(pItem);
if(pLine)
{
ModelProperty* pPro = pLine->getProperty();
if(pPro){
vec.push_back(pPro);
}
}
}
}
return vec;
}
QMap<QUuid,GraphicsFunctionModelItem*>& FixedPortsModel::allItems()
{
return _nodeItem;
}
GraphicsFunctionModelItem* FixedPortsModel::nodeItem(QUuid uuid)
{
return _nodeItem.value(uuid,nullptr);
}
bool FixedPortsModel::addNodeItem(QUuid uuid,GraphicsFunctionModelItem* pItem)
{
if(_nodeItem.contains(uuid))
return false;
else
{
pItem->setHandle(this);
_nodeItem.insert(uuid,pItem);
//connect(pItem,&GraphicsFunctionModelItem::ifExist,this,&FixedPortsModel::onSignal_ifExits);
connect(pItem,&GraphicsBaseItem::itemRotated,this,[this](GraphicsBaseItem* pBase){
if(pBase){
auto pPro = pBase->getProperty();
QUuid uid = pPro->uuid();
if(pPro->type() != 8){ //排除线
updateItemLinePort(uid,ModelFunctionType::ProjectModel); //hmi不改变拓扑结构继续使用系统图的连接关系
}
}
});
return true;
}
}
QString FixedPortsModel::addNodeItem(QUuid id,QPointF pos,double width,double height,double rotate)
{
//todo:load图形时必有拓扑实体关联到对应的entity
BaseProperty* pro = nullptr;
GraphicsFunctionModelItem* item = nullptr;
QMap<QUuid,BaseProperty*> mapData = BasePropertyManager::instance().getEntityData(); //加载的图形必定关联component(todo:完善判断条件,如判断拓扑节点)
if(mapData.contains(id))
{
pro = mapData.value(id);
if(pro)
{
int type = pro->graphicsType();
if(type == GIT_link) //连线对象外部处理
return QString("err");
QString sMeta = pro->metaModelName();
QString sProModel = pro->modelName();
ModelDataInfo mapValue = DataManager::instance().modelData()[sProModel];
PropertyValueInfo valueInfo; //属性组设置的数据 (ct,pt二次绕组)
if(mapValue.groupInfo.contains("base_extend"))
{
valueInfo = mapValue.groupInfo["base_extend"].mapInfo[id];
}
double dX = 0.0;
double dY = 0.0;
if(type == GIT_itemRect)
{
PropertyModel model = ProjectModelManager::instance().getData()[sMeta][sProModel];
QByteArray svg;
if(model.modelSetting.mapSvg.isEmpty()){
svg = DataBase::GetInstance()->ModelType()[3].icon;
}
else{
svg = ProjectModelManager::instance().getData()[sMeta][sProModel].modelSetting.mapUsedSvg["cb"];
}
if(width == 0 && height == 0){
dX = 30;
dY = 30;
}
else{
dX = width;
dY = height;
}
auto pCb = new ElectricFunctionModelSvgItemCB(QRect(-dX*0.5, -dY*0.5, dX, dY),false);
pCb->setItemType(GIT_itemRect);
pCb->loadSvg(svg);
item = pCb;
QJsonArray portArr = pro->context()["port"].toArray();
addPortsToItem_json(P_const,portArr,item);
}
else if(type == GIT_node)
{
auto pNode = new ElectricFunctionModelPortItem();
pNode->setItemType(GIT_node);
item = pNode;
QJsonArray portArr = pro->context()["port"].toArray();
addPortsToItem_json(p_movable,portArr,item);
}
else if(type == GIT_bus)
{
PropertyModel model = ProjectModelManager::instance().getData()[sMeta][sProModel];
QByteArray svg;
if(model.modelSetting.mapSvg.isEmpty()){
svg = DataBase::GetInstance()->ModelType()[1].icon;
}
else{
svg = ProjectModelManager::instance().getData()[sMeta][sProModel].modelSetting.mapUsedSvg["bus"];
}
if(width == 0 && height == 0){
dX = 200;
dY = 6;
}
else{
dX = width;
dY = height;
}
auto pBus = new ElectricFunctionModelSvgItemBus(QRect(0, 0, dX, dY));
pBus->setItemType(GIT_bus);
pBus->loadSvg(svg);
item = pBus;
QJsonArray portArr = pro->context()["port"].toArray();
addPortsToItem_json(p_movable,portArr,item);
}
else if(type == GIT_ctGroup)
{
PropertyModel model = ProjectModelManager::instance().getData()[sMeta][sProModel];
QByteArray svg;
if(model.modelSetting.mapSvg.isEmpty()){
svg = DataBase::GetInstance()->ModelType()[5].icon;
}
else{
svg = model.modelSetting.mapSvg.first();
}
if(width == 0 && height == 0){
dX = 20;
dY = 20;
}
else{
dX = width;
dY = height;
}
auto pCt = new ElectricFunctionModelSvgGroupCT(QRect(-dX*0.5, -dY*0.5, dX, dY));
pCt->updateMapSvg(ProjectModelManager::instance().getData()[sMeta][sProModel].modelSetting.mapUsedSvg);
pCt->setItemType(GIT_ctGroup);
item = pCt;
QJsonArray portArr = pro->context()["port"].toArray();
addPortsToItem_json(P_const,portArr,item);
if(!valueInfo.isEmpty()){ //使用设置的绕组数更新自己
int nCtSize = 0; //ct设置的个数
int nCtType = 0; //ct类型 1三相0零相
if(valueInfo.contains("ct_winding")){
PropertyStateInfo val = valueInfo.value("ct_winding");
QJsonDocument jsonDocument = QJsonDocument::fromJson(val.defaultValue.toString().toUtf8().data());
if(!jsonDocument.isNull()){
QJsonObject obj = jsonDocument.object();
if(obj.contains("winding")){
QJsonArray arr = obj["winding"].toArray();
nCtSize = arr.size();
}
}
}
if(valueInfo.contains("phase_num")){
PropertyStateInfo val = valueInfo.value("phase_num");
nCtType = val.defaultValue.toInt();
}
QPair<int,int> pair(nCtType,nCtSize);
QVariant var = QVariant::fromValue(pair);
pCt->setupFinish(var);
}
}
else if(type == GIT_ptGroup)
{
PropertyModel model = ProjectModelManager::instance().getData()[sMeta][sProModel];
QByteArray svg;
if(model.modelSetting.mapSvg.isEmpty()){
svg = DataBase::GetInstance()->ModelType()[6].icon;
}
else{
svg = model.modelSetting.mapSvg.first();
}
if(width == 0 && height == 0){
dX = 50;
dY = 50;
}
else{
dX = width;
dY = height;
}
auto pPt = new ElectricFunctionModelSvgGroupPT(QRect(-dX*0.5, -dY*0.5, dX, dY));
pPt->updateMapSvg(ProjectModelManager::instance().getData()[sMeta][sProModel].modelSetting.mapUsedSvg);
pPt->setItemType(GIT_ptGroup);
item = pPt;
QJsonArray portArr = pro->context()["port"].toArray();
addPortsToItem_json(P_const,portArr,item);
if(!valueInfo.isEmpty()){ //使用设置的绕组数更新自己
QList<int> lst; //二次绕组接法
if(valueInfo.contains("pt_sec_winding")){
PropertyStateInfo val = valueInfo.value("pt_sec_winding");
QJsonDocument jsonDocument = QJsonDocument::fromJson(val.defaultValue.toString().toUtf8().data());
if(!jsonDocument.isNull()){
QJsonObject obj = jsonDocument.object();
QJsonArray arr = obj["winding"].toArray();
for (QJsonValueRef jsonObj : arr)
{
QJsonObject node = jsonObj.toObject();
QString sWinding = node["windingConnectionMethod"].toString();
if(sWinding == "Y"){
lst.append(1);
}
else{
lst.append(0);
}
}
}
QVariant var = QVariant::fromValue(lst);
pPt->setupFinish(var);
}
}
}
else if(type == GIT_DS)
{
PropertyModel model = ProjectModelManager::instance().getData()[sMeta][sProModel];
QByteArray svg;
if(model.modelSetting.mapSvg.isEmpty()){
svg = DataBase::GetInstance()->ModelType()[7].icon;
}
else{
svg = ProjectModelManager::instance().getData()[sMeta][sProModel].modelSetting.mapUsedSvg["ds"];
}
if(width == 0 && height == 0){
dX = 30;
dY = 30;
}
else{
dX = width;
dY = height;
}
auto pDs = new ElectricFunctionModelSvgItemDS(QRect(-dX*0.5, -dY*0.5, dX, dY));
pDs->setItemType(GIT_DS);
pDs->loadSvg(svg);
item = pDs;
QJsonArray portArr = pro->context()["port"].toArray();
addPortsToItem_json(P_const,portArr,item);
}
else if(type == GIT_ES)
{
PropertyModel model = ProjectModelManager::instance().getData()[sMeta][sProModel];
QByteArray svg;
if(model.modelSetting.mapSvg.isEmpty()){
svg = DataBase::GetInstance()->ModelType()[8].icon;
}
else{
svg = ProjectModelManager::instance().getData()[sMeta][sProModel].modelSetting.mapUsedSvg["es"];
}
if(width == 0 && height == 0){
dX = 30;
dY = 60;
}
else{
dX = width;
dY = height;
}
auto pEs = new ElectricFunctionModelSvgItemES(QRect(-dX*0.5, -dY*0.5, dX, dY));
pEs->setItemType(GIT_ES);
pEs->loadSvg(svg);
item = pEs;
QJsonArray portArr = pro->context()["port"].toArray();
addPortsToItem_json(P_const,portArr,item);
}
else if(type == GIT_FES)
{
PropertyModel model = ProjectModelManager::instance().getData()[sMeta][sProModel];
QByteArray svg;
if(model.modelSetting.mapSvg.isEmpty()){
svg = DataBase::GetInstance()->ModelType()[9].icon;
}
else{
svg = ProjectModelManager::instance().getData()[sMeta][sProModel].modelSetting.mapUsedSvg["fes"];
}
if(width == 0 && height == 0){
dX = 30;
dY = 60;
}
else{
dX = width;
dY = height;
}
auto pFes = new ElectricFunctionModelSvgItemFES(QRect(-dX*0.5, -dY*0.5, dX, dY));
pFes->setItemType(GIT_FES);
pFes->loadSvg(svg);
item = pFes;
QJsonArray portArr = pro->context()["port"].toArray();
addPortsToItem_json(P_const,portArr,item);
}
else if(type == GIT_DTEDS)
{
PropertyModel model = ProjectModelManager::instance().getData()[sMeta][sProModel];
QByteArray svg;
if(model.modelSetting.mapSvg.isEmpty()){
svg = DataBase::GetInstance()->ModelType()[10].icon;
}
else{
svg = ProjectModelManager::instance().getData()[sMeta][sProModel].modelSetting.mapUsedSvg["dteds"];
}
if(width == 0 && height == 0){
dX = 60;
dY = 30;
}
else{
dX = width;
dY = height;
}
auto pDteds = new ElectricFunctionModelSvgItemDTEDS(QRect(-dX*0.5, -dY*0.5, dX, dY));
pDteds->setItemType(GIT_DTEDS);
pDteds->loadSvg(svg);
item = pDteds;
QJsonArray portArr = pro->context()["port"].toArray();
addPortsToItem_json(P_const,portArr,item);
}
else if(type == GIT_PI)
{
PropertyModel model = ProjectModelManager::instance().getData()[sMeta][sProModel];
QByteArray svg;
if(model.modelSetting.mapSvg.isEmpty()){
svg = DataBase::GetInstance()->ModelType()[11].icon;
}
else{
svg = ProjectModelManager::instance().getData()[sMeta][sProModel].modelSetting.mapUsedSvg["potential_indicator"];
}
if(width == 0 && height == 0){
dX = 30;
dY = 60;
}
else{
dX = width;
dY = height;
}
auto pPi = new ElectricFunctionModelSvgItemPI(QRect(-dX*0.5, -dY*0.5, dX, dY));
pPi->setItemType(GIT_PI);
pPi->loadSvg(svg);
item = pPi;
QJsonArray portArr = pro->context()["port"].toArray();
addPortsToItem_json(P_const,portArr,item);
}
else if(type == GIT_LA)
{
PropertyModel model = ProjectModelManager::instance().getData()[sMeta][sProModel];
QByteArray svg;
if(model.modelSetting.mapSvg.isEmpty()){
svg = DataBase::GetInstance()->ModelType()[12].icon;
}
else{
svg = ProjectModelManager::instance().getData()[sMeta][sProModel].modelSetting.mapUsedSvg["lightning_arrester"];
}
if(width == 0 && height == 0){
dX = 30;
dY = 60;
}
else{
dX = width;
dY = height;
}
auto pLa = new ElectricFunctionModelSvgItemLA(QRect(-dX*0.5, -dY*0.5, dX, dY));
pLa->setItemType(GIT_LA);
pLa->loadSvg(svg);
item = pLa;
QJsonArray portArr = pro->context()["port"].toArray();
addPortsToItem_json(P_const,portArr,item);
}
else if(type == GIT_cableTer)
{
PropertyModel model = ProjectModelManager::instance().getData()[sMeta][sProModel];
QByteArray svg;
if(model.modelSetting.mapSvg.isEmpty()){
svg = DataBase::GetInstance()->ModelType()[13].icon;
}
else{
svg = ProjectModelManager::instance().getData()[sMeta][sProModel].modelSetting.mapUsedSvg["cable_termination"];
}
if(width == 0 && height == 0){
dX = 20;
dY = 20;
}
else{
dX = width;
dY = height;
}
auto pCt = new ElectricFunctionModelSvgItemCableTer(QRect(-dX*0.5, -dY*0.5, dX, dY));
pCt->setItemType(GIT_cableTer);
pCt->loadSvg(svg);
item = pCt;
QJsonArray portArr = pro->context()["port"].toArray();
addPortsToItem_json(P_const,portArr,item);
}
else if(type == GIT_cableEnd)
{
PropertyModel model = ProjectModelManager::instance().getData()[sMeta][sProModel];
QByteArray svg;
if(model.modelSetting.mapSvg.isEmpty()){
svg = DataBase::GetInstance()->ModelType()[14].icon;
}
else{
svg = ProjectModelManager::instance().getData()[sMeta][sProModel].modelSetting.mapUsedSvg["cable_end"];
}
if(width == 0 && height == 0){
dX = 20;
dY = 20;
}
else{
dX = width;
dY = height;
}
auto pCe = new ElectricFunctionModelSvgItemCableEnd(QRect(-dX*0.5, -dY*0.5, dX, dY));
pCe->setItemType(GIT_cableEnd);
pCe->loadSvg(svg);
item = pCe;
QJsonArray portArr = pro->context()["port"].toArray();
addPortsToItem_json(P_const,portArr,item);
}
else if(type == GIT_2wTransformer)
{
PropertyModel model = ProjectModelManager::instance().getData()[sMeta][sProModel];
QByteArray svg;
if(model.modelSetting.mapSvg.isEmpty()){
svg = DataBase::GetInstance()->ModelType()[15].icon;
}
else{
svg = ProjectModelManager::instance().getData()[sMeta][sProModel].modelSetting.mapUsedSvg["transformer_2w"];
}
if(width == 0 && height == 0){
dX = 100;
dY = 100;
}
else{
dX = width;
dY = height;
}
auto p2w = new ElectricFunctionModelSvgItem2wTransformer(QRect(-dX*0.5, -dY*0.5, dX, dY));
p2w->setItemType(GIT_2wTransformer);
p2w->loadSvg(svg);
item = p2w;
QJsonArray portArr = pro->context()["port"].toArray();
addPortsToItem_json(P_const,portArr,item);
}
else if(type == GIT_3wTransformer)
{
PropertyModel model = ProjectModelManager::instance().getData()[sMeta][sProModel];
QByteArray svg;
if(model.modelSetting.mapSvg.isEmpty()){
svg = DataBase::GetInstance()->ModelType()[16].icon;
}
else{
svg = ProjectModelManager::instance().getData()[sMeta][sProModel].modelSetting.mapUsedSvg["transformer_3w"];
}
if(width == 0 && height == 0){
dX = 100;
dY = 100;
}
else{
dX = width;
dY = height;
}
auto p3w = new ElectricFunctionModelSvgItem3wTransformer(QRect(-dX*0.5, -dY*0.5, dX, dY));
p3w->setItemType(GIT_3wTransformer);
p3w->loadSvg(svg);
item = p3w;
QJsonArray portArr = pro->context()["port"].toArray();
addPortsToItem_json(P_const,portArr,item);
}
if(item)
{
item->setItemId(id);
item->editShape(0, pos);
item->setPos(pos);
item->setRotation(rotate);
_scene->addItem(item);
item->addPoint(pos);
item->setProperty(pro); //绑定模型
item->updateByProperty(); //使用模型更新自身
item->setHandle(this);
_nodeItem.insert(id,item);
//connect(item,&GraphicsFunctionModelItem::ifExist,this,&FixedPortsModel::onSignal_ifExits);
connect(item,&GraphicsBaseItem::itemRotated,this,[this](GraphicsBaseItem* pBase){
if(pBase){
auto pPro = pBase->getProperty();
QUuid uid = pPro->uuid();
if(pPro->type() != 8){ //排除线
updateItemLinePort(uid,ModelFunctionType::ProjectModel); //hmi不改变拓扑结构继续使用系统图的连接关系
}
}
});
}
return pro->name();
}
}
return QString("err");
}
BaseProperty* FixedPortsModel::addNodeData(QUuid id,int type,QString name,QString modelName)
{
BaseProperty* pData = BasePropertyManager::instance().findEntityData(id); //已存在不不创建
if(pData != nullptr)
return pData;
VariableProperty* item = new VariableProperty();
//todo:关联到对应data
if(item)
{
item->setUuid(id);
item->setModelName(modelName);
item->setType(type);
GraphicsItemType localType = typeToProGraphic[type]; //将通用类型转换为工程模图元
item->setGraphicsType(localType);
item->setTag(name);
item->setName(name);
item->setDataChanged(true);
BasePropertyManager::instance().insertEntityData(id,item);
}
return item;
}
void FixedPortsModel::loadNodeDataFromDataBase()
{
if(!_dataInitialised)
{
QList<ComponentInfo> lst= DataBase::GetInstance()->getAllComponents();
for(auto &info:lst)
{
QString preTag = removeSuffix(info.tag);
QString prePath = removeSuffix(info.nspath);
BaseProperty* pData = addNodeData(info.uuid,info.type,info.name,info.modelName);
pData->setTag(preTag);
pData->setName(info.name);
pData->setPath(prePath);
pData->setDescription(info.description);
pData->setInService(info.inService);
pData->setState(info.state);
pData->setStatus(info.status);
pData->setConnectedBus(info.connected_bus);
pData->setLabel(info.label);
pData->setContext(info.context);
pData->setGrid(info.grid);
pData->setZone(info.zone);
pData->setStation(info.station);
pData->setBay(prePath);
pData->setDataChanged(false);
QString sMeta = info.context["metaModel"].toString();
pData->setMetaModelName(sMeta);
double dVoltage = info.context["extraInfo"].toDouble();
pData->setVoltageLevel(dVoltage);
QJsonArray nodesJsonArray = info.context["subList"].toArray();
QList<QPair<int, QUuid>> lst;
for (QJsonValueRef nodeJson : nodesJsonArray)
{
QJsonObject node = nodeJson.toObject();
int nCategory = node["category"].toInt();
QUuid uid = QUuid(node["uuid"].toString());
lst.append(qMakePair(nCategory,uid));
}
pData->setSubList(lst);
PowerEntity* pEntity = TopologyManager::instance().createEntity(EntityType::Component,info.uuid.toString(),info.name); //首先load所有data和entity全局唯一
if(pEntity){
createTopoTerminalsByData(pEntity,info.context);
}
QList<MeasurementInfo> lstMeasure = DataBase::GetInstance()->getMeasurement(info.uuid); //添加设备量测
QMap<QString,MeasurementInfo> mapMeasure;
for(auto& info:lstMeasure)
{
info.tag = removeSuffix(info.tag);
mapMeasure.insert(info.name,info);
}
assignMeasureSymmetry(mapMeasure);
pData->setMeasurement(mapMeasure);
}
QList<TopologyInfo> lstTopo = DataBase::GetInstance()->getAllTopologics();
for(auto &info:lstTopo)
{
QString from_pin = info.context["from_pin"].toString();
QString to_pin = info.context["to_pin"].toString();
TopologyManager::instance().createConnection(QString::number(info.id),from_pin,to_pin,info.uuid_from.toString(),info.uuid_to.toString());
}
QList<BayInfo> lstBay = DataBase::GetInstance()->getAllBay();
for(auto& bay:lstBay)
{
QString showTag = removeSuffix(bay.tag);
BayProperty* pBay = addBayData(bay.uuid);
pBay->setName(bay.name);
pBay->setTag(showTag);
pBay->setType(bay.type);
pBay->setLstComponent(bay.components);
pBay->setVoltage(bay.unom);
pBay->setFla(bay.fla);
pBay->setCapacity(bay.capacity);
pBay->setInService(bay.inService);
auto fromLst = turnJsonArrToList(bay.fromUuid,"id","ids");
pBay->setLstFrom(fromLst);
auto toLst = turnJsonArrToList(bay.toUuid,"id","ids");
pBay->setLstTo(toLst);
auto proptecLst = turnJsonArrToList(bay.protect,"id","ids");
pBay->setLstProtect(proptecLst);
auto falRecLst = turnJsonArrToList(bay.faultRec,"id","ids");
pBay->setLstFaultRecord(falRecLst);
auto dynSenLst = turnJsonArrToList(bay.dynSense,"id","ids");
pBay->setLstDynSense(dynSenLst);
auto staLst = turnJsonArrToList(bay.status,"id","ids");
pBay->setLstStatus(staLst);
auto insLst = turnJsonArrToList(bay.instruct,"id","ids");
pBay->setLstInstruct(insLst);
auto etcLst = turnJsonArrToList(bay.etc,"id","ids");
pBay->setLstEtc(etcLst);
QMap<QString,MeasurementInfo> mapMeasure;
QList<MeasurementInfo> tempLst = DataBase::GetInstance()->getBayMeasurement(bay.uuid);
for(auto& info:tempLst){
if(info.componentUuid == QUuid("11111111-1111-1111-1111-111111111111")) //只处理间隔外量测
mapMeasure.insert(info.name,info);
}
pBay->setMeasurement(mapMeasure);
}
_dataInitialised = true;
}
else
{
//for(auto p:_nodeData)
{
int a = 1;
}
}
}
QString FixedPortsModel::addConnectLline(QUuid lineId,QUuid srcId,QUuid destId,QUuid srcPort,QUuid destPort)
{
GraphicsFunctionModelItem* src = nullptr;
if(_nodeItem.contains(srcId))
src = _nodeItem.value(srcId);
GraphicsFunctionModelItem* dest = nullptr;
if(_nodeItem.contains(destId))
dest = _nodeItem.value(destId);
QMap<QUuid,BaseProperty*> mapData = BasePropertyManager::instance().getEntityData();
if(mapData.contains(lineId))
{
BaseProperty* pPro = mapData.value(lineId);
if(src && dest && pPro)
{
ElectricFunctionModelConnectLineItem* pItem = new ElectricFunctionModelConnectLineItem();
pItem->setItemId(lineId);
pItem->setItemType(GIT_link);
_scene->addItem(pItem);
ItemPort* ptSrc = src->getPortById(srcPort.toString());
HandleType srcType = ptSrc->getType();
PortPos srcPos = ptSrc->portPos();
pItem->setStartPoint(ptSrc->scenePos());
ptSrc->setConnect(pItem);
ItemPort* ptDest = nullptr;
ptDest = dest->getPortById(destPort.toString());
pItem->setEndPoint(ptDest->scenePos());
if(ptDest != nullptr)
{
HandleType destType = ptDest->getType();
PortPos destPos = ptDest->portPos();
pItem->calculatePath();
pPro->setConnection(Connection(srcId,srcPort,srcType,srcPos,destId,destPort,destType,destPos));
ptDest->setConnect(pItem);
addNodeItem(pItem->itemId(),pItem);
pItem->setProperty(pPro);
}
return pPro->name();
}
}
return QString("err");
}
void FixedPortsModel::deleteNodeItem(GraphicsFunctionModelItem* pItem)
{
if(pItem->getItemType() == GIT_link)
{
auto pLine = dynamic_cast<ElectricFunctionModelConnectLineItem*>(pItem);
if(pLine)
{
QUuid conId = pLine->itemId();
TopologyManager::instance().removeConnection(conId.toString());
PowerConnection* pCon = TopologyManager::instance().connection(conId.toString());
if(pCon){
PowerEntity* itemFrom = TopologyManager::instance().getEntityByTerminal(pCon->fromTerminalId());
PowerEntity* itemTo = TopologyManager::instance().getEntityByTerminal(pCon->toTerminalId());
if(itemFrom && itemTo)
{
_nodeItem.value(QUuid(itemFrom->id()))->setItemChanged(true);
_nodeItem.value(QUuid(itemTo->id()))->setItemChanged(true);
}
}
_nodeItem.take(conId);
_scene->removeItem(pLine);
delete pLine;
}
}
else
{
QUuid srcId = pItem->itemId();
QList<PowerConnection*> lstCon = TopologyManager::instance().getConnectionsFor(srcId.toString());
for(auto &con:lstCon)
{
PowerEntity* pFrom = TopologyManager::instance().getEntityByTerminal(con->fromTerminalId());
PowerEntity* pTo = TopologyManager::instance().getEntityByTerminal(con->toTerminalId());
if(pFrom && pTo)
{
if(srcId.toString() == pFrom->id()) //对象是srcItem
_nodeItem.value(QUuid(pTo->id()))->setItemChanged(true);
else //对象是toItem
_nodeItem.value(QUuid(pFrom->id()))->setItemChanged(true);
}
//TopologyManager::instance().removeConnection(con->id()); //删除entity时会同时删除相关连接无需手动删除
}
TopologyManager::instance().deleteEntity(srcId.toString());
pItem->setItemChanged(true);
_nodeItem.take(srcId);
_scene->removeItem(pItem);
delete pItem;
}
}
void FixedPortsModel::saveNode(int nPageId)
{
QList<GridInfo> lstGrid = DataBase::GetInstance()->getAllGrid();
QList<ZoneInfo> lstZone = DataBase::GetInstance()->getAllZone();
QList<StationInfo> lstStation = DataBase::GetInstance()->getAllStation();
QMap<int,attributeGroup> groupMap = DataBase::GetInstance()->AttributeGroup(); //属性组名
bool bExist = DataBase::GetInstance()->componentExist(QUuid("11111111-1111-1111-1111-111111111111").toString());
bool bSaveFlag = false;
for(auto& bay:_bayItem)
{
AbstractProperty* pro = bay->getProperty(); //间隔
BayProperty* pBay = dynamic_cast<BayProperty*>(pro);
if(pBay){
bool val = DataBase::GetInstance()->ifBayExist(pBay->uuid());
QString tempTag = pBay->tag()+"_"+_pageName; //tag后加工程名保持全局唯一
if(!val){
QJsonObject objFrom = turnListToJson(pBay->getLstFrom(),"id","ids");
QJsonObject objTo= turnListToJson(pBay->getLstTo(),"id","ids");
QJsonObject objProtec= turnListToJson(pBay->getLstProtect(),"id","ids");
QJsonObject objFalRec= turnListToJson(pBay->getLstFaultRecord(),"id","ids");
QJsonObject objStatus= turnListToJson(pBay->getLstStatus(),"id","ids");
QJsonObject objDynSen= turnListToJson(pBay->getLstDynSense(),"id","ids");
QJsonObject objIns= turnListToJson(pBay->getLstInstruct(),"id","ids");
QJsonObject objEtc= turnListToJson(pBay->getLstEtc(),"id","ids");
DataBase::GetInstance()->insertBay(pBay->uuid(),pBay->name(),tempTag,pBay->getType(),pBay->getVoltage(),pBay->getFla(),pBay->getCapacity(),"1",pBay->getInService(),0,"1","1","1",QJsonObject(),objFrom,objTo,objProtec,objFalRec,objStatus,objDynSen,objIns,objEtc,pBay->getLstComponent(),QJsonObject());
}
else{
QJsonObject objFrom = turnListToJson(pBay->getLstFrom(),"id","ids");
QJsonObject objTo= turnListToJson(pBay->getLstTo(),"id","ids");
QJsonObject objProtec= turnListToJson(pBay->getLstProtect(),"id","ids");
QJsonObject objFalRec= turnListToJson(pBay->getLstFaultRecord(),"id","ids");
QJsonObject objStatus= turnListToJson(pBay->getLstStatus(),"id","ids");
QJsonObject objDynSen= turnListToJson(pBay->getLstDynSense(),"id","ids");
QJsonObject objIns= turnListToJson(pBay->getLstInstruct(),"id","ids");
QJsonObject objEtc= turnListToJson(pBay->getLstEtc(),"id","ids");
DataBase::GetInstance()->updateBay(pBay->uuid(),pBay->name(),tempTag,pBay->getVoltage(),pBay->getFla(),pBay->getCapacity(),"",pBay->getInService(),0,QJsonObject(),objFrom,objTo,objProtec,objFalRec,objStatus,objDynSen,objIns,objEtc,pBay->getLstComponent(),QJsonObject());
}
QString sGridTag;
QString sGridName;
QString sZoneTag;
QString sZoneName;
QString sStationTag;
QString sStationName;
QList<QUuid> lstId = pBay->getLstComponent(); //获取间隔下的所有item取一个item所属的层级关系
if(!lstId.isEmpty()){
auto pItemData = BasePropertyManager::instance().findEntityData(lstId.first());
if(pItemData){
for(auto& gridInfo:lstGrid){
if(pItemData->grid() == gridInfo.tagname){
sGridTag= gridInfo.tagname;
sGridName= gridInfo.name;
break;
}
}
for(auto& zoneInfo:lstZone){
if(pItemData->zone() == zoneInfo.tagname){
sZoneTag = zoneInfo.tagname;
sZoneName = zoneInfo.name;
break;
}
}
for(auto& stationInfo:lstStation){
if(pItemData->station() == stationInfo.tagname){
sStationTag = stationInfo.tagname;
sStationName = stationInfo.name;
break;
}
}
}
}
if(!bExist){
if(!bSaveFlag){
DataBase::GetInstance()->insertComponent(QUuid("11111111-1111-1111-1111-111111111111"),"","","","","","","",sStationTag,-1,false,-1,-1,QJsonObject(),QJsonObject(),QJsonObject(),1);
bSaveFlag = true;
}
}
QMap<QString,MeasurementInfo> mapMeasure = pBay->getMeasurement(); //量测
QList<ExtraProperty> lstTemp= DataBase::GetInstance()->getBayExtraProperty(tempTag); //component中的层级关系
QList<ExtraProperty> lstExtra;
for(auto& info:lstTemp){
if(info.component_uuid != QUuid("11111111-1111-1111-1111-111111111111")) //只判断设备外量测
continue;
info.bay_tag = removeSuffix(info.bay_tag);
lstExtra.append(info);
}
QList<MeasurementInfo> lstDataBase;
QList<MeasurementInfo> lstTempBase = DataBase::GetInstance()->getBayMeasurement(pBay->uuid()); //数据库中现有量测
for(auto& info:lstTempBase){
if(info.componentUuid != QUuid("11111111-1111-1111-1111-111111111111")) //只判断设备外量测
continue;
lstDataBase.append(info);
}
for(auto& info:mapMeasure)
{
int tpe = info.type; //todo:建立类型映射表
QJsonObject objDataSource;
QJsonObject objIoAddress;
if(info.nSource == 1){ //3611
objDataSource["type"] = 1;
objIoAddress["station"] = info.sStation;
objIoAddress["device"] = info.sDevice;
objIoAddress["channel"] = info.sChannel;
}
else if(info.nSource == 2){ //104
objDataSource["type"] = 2;
objIoAddress["station"] = info.sStation;
objIoAddress["packet"] = info.nPacket;
objIoAddress["offset"] = info.nOffset;
}
objDataSource["io_address"] = objIoAddress;
QJsonObject objEventPlan;
QJsonObject objCause;
QJsonObject objAction;
QJsonArray arrPara;
objEventPlan["enable"] = info.bEnable;
if(tpe == 0){ //遥测
for(auto iter = info.mapTE.begin();iter != info.mapTE.end();++iter){
objCause[iter.key()] = iter.value();
}
}
else if(tpe == 1){ //遥信
objCause["edge"] = info.sEdge;
}
objEventPlan["cause"] = objCause;
objAction["command"] = info.sCommand;
for(auto &para:info.lstParameter){
arrPara.append(para);
}
objAction["parameters"] = arrPara;
objEventPlan["action"] = objAction;
QJsonObject objBinding;
if(!info.sWindType.isEmpty()){
QJsonObject objWind;
objWind["ratio"] = info.nRatio;
objWind["polarity"] = info.nPolarity;
objWind["index"] = info.nIndex;
objBinding[info.sWindType] = objWind;
}
QString tempMeasure = info.tag+"_"+_pageName; //tag后加工程名保持全局唯一
bool val = DataBase::GetInstance()->ifBayMeasureExist(info.name,pBay->uuid());
if(val){
DataBase::GetInstance()->updateMeasurement(info.name,tpe,objDataSource,objEventPlan,objBinding,info.size,QUuid("11111111-1111-1111-1111-111111111111"));
}
else{
DataBase::GetInstance()->insertMeasurement(info.name,tempMeasure,tpe,objDataSource,objEventPlan,objBinding,info.size,info.bayUuid,QUuid("11111111-1111-1111-1111-111111111111"));
}
for(int i = 0;i < lstDataBase.size();++i) //从数据库记录中移除操作过的对象
{
if(lstDataBase[i].name == info.name){
lstDataBase.removeAt(i);
break;
}
}
for(int i = 0;i < lstExtra.size();++i){ //同步层级信息计数
if(lstExtra[i].name == info.name){
lstExtra.removeAt(i);
break;
}
}
ExtraProperty extraPro; //层级信息
extraPro.name = info.name;
extraPro.tag = tempMeasure;
extraPro.grid_tag = sGridTag;
extraPro.grid_name = sGridName;
extraPro.zone_tag = sZoneTag;
extraPro.zone_name = sZoneName;
extraPro.station_tag = sStationTag;
extraPro.station_name = sStationName;
extraPro.currentLevel = QString::number(pBay->getVoltage())+"kv";
extraPro.page_tag = _widget->pageName(); //暂时相同
extraPro.bay_name = pBay->name();
extraPro.bay_tag = tempTag;
extraPro.component_uuid = QUuid("11111111-1111-1111-1111-111111111111");
for(auto& groupInfo:groupMap){
if("bay" == groupInfo.groupType){
extraPro.group_name = groupInfo.groupName;
break;
}
}
if(tpe == 0){
extraPro.type_name = "遥测";
extraPro.type_tag = "telemetry";
}
else if(tpe == 1){
extraPro.type_name = "遥信";
extraPro.type_tag = "telesignal";
}
else if(tpe == 2){
extraPro.type_name = "遥控";
extraPro.type_tag = "telecontrol";
}
extraPro.code = extraPro.getFullName();
extraPro.sourceType = "measurement";
extraPro.connect_para = sGridTag+"."+sZoneTag+"."+sStationTag+"."+extraPro.bay_tag+"."+extraPro.tag;
//取data 量测tag
bool exist = DataBase::GetInstance()->ifExtraPropertyExist(extraPro.code);
if(exist)
DataBase::GetInstance()->updateExtraProperty(extraPro);
else
DataBase::GetInstance()->insertExtraProperty(extraPro);
}
for(auto& info:lstDataBase) //操作的记录小于数据库中的记录,删除库中多出的记录
{
DataBase::GetInstance()->delteMeasurement(info.name,info.componentUuid);
}
for(auto& info:lstExtra){ //删除库中多出的层级信息
DataBase::GetInstance()->deleteExtraProperty(info.code);
}
}
}
QMap<QUuid,GraphicsFunctionModelItem*> mapItems = allItems();
for(auto& pItem:mapItems)
{
BaseProperty* pData = dynamic_cast<BaseProperty*>(pItem->getProperty());
if(pData){
Connection con = pData->getConnection();
QString fromPin = con.nSrcPortId.toString();
QString toPin = con.nDestPortId.toString();
QJsonObject context;
context["from_pin"] = fromPin;
context["to_pin"] = toPin;
if(pData->prepareDelete())
{
DataBase::GetInstance()->deleteComponent(pData->uuid().toString());
if(pData->type() == 8){
PowerConnection* pCon = TopologyManager::instance().connection(fromPin,toPin);
if(pCon){
DataBase::GetInstance()->deleteTopologic(con.nSrcPortId,con.nDestPortId);
TopologyManager::instance().removeConnection(pCon->id());
}
}
continue;
}
if(pData->dataChanged())
{
pData->setDataChanged(false);
bool exist = DataBase::GetInstance()->componentExist(pData->uuid().toString());
VariableProperty* pVariable = dynamic_cast<VariableProperty*>(pData);
if(pVariable)
{
ModelDataInfo& dataInfo = pVariable->getPropertyValue();
QString tempTag = pData->tag()+"_"+_pageName; //tag后加工程名使得全局唯一
if(exist) //已存在更新
{
DataBase::GetInstance()->updateComponent(pData->uuid(),tempTag,pData->name(),pData->context(),pData->inService(),pData->state(),pData->status());
for(auto &val:dataInfo.groupInfo)
{
if(val.groupName == "component")
continue;
DataBase::GetInstance()->updateDynamicProperty(pData->uuid(),val);
if(val.mapInfo.contains(pData->uuid())){ //保存时将数据锁复原
auto& mapPro = val.mapInfo[pData->uuid()];
for(auto& pro:mapPro)
{
pro.lock = false;
}
}
}
}
else
{
QString tempPath = pData->path()+"_"+_pageName;
DataBase::GetInstance()->insertComponent(pData->uuid(),pData->modelName(),tempPath,tempTag,pData->name(),pData->description(),pData->grid(),pData->zone(),pData->station(),pData->type(),true,pData->state(),pData->status(),pData->connectedBus(),pData->label(),pData->context(),1);
for(auto &val:dataInfo.groupInfo)
{
if(val.groupName == "component")
continue;
DataBase::GetInstance()->insertDynamicProperty(pData->uuid(),val);
if(val.mapInfo.contains(pData->uuid())){ //保存时将数据锁复原
auto& mapPro = val.mapInfo[pData->uuid()];
for(auto& pro:mapPro)
{
pro.lock = false;
}
}
}
}
//层级关系与连接参数
BayProperty* bayPro = nullptr; //本data对应的bay
QMap<QUuid,ElectricBayItem*> mapBay = allBayItem();
for(auto& item:mapBay){
AbstractProperty* pPro = item->getProperty();
BayProperty* pBayPro = dynamic_cast<BayProperty*>(pPro);
if(pBayPro){
QList<QUuid> lstCompo = pBayPro->getLstComponent(); //获取间隔下的component找到本component对应的间隔
for(auto& id:lstCompo){
if(id == pData->uuid()){
bayPro = pBayPro;
break;
}
}
}
}
QString sGridTag;
QString sGridName;
QString sZoneTag;
QString sZoneName;
QString sStationTag;
QString sStationName;
for(auto& gridInfo:lstGrid){
if(pData->grid() == gridInfo.tagname){
sGridTag= gridInfo.tagname;
sGridName= gridInfo.name;
break;
}
}
for(auto& zoneInfo:lstZone){
if(pData->zone() == zoneInfo.tagname){
sZoneTag = zoneInfo.tagname;
sZoneName = zoneInfo.name;
break;
}
}
for(auto& stationInfo:lstStation){
if(pData->station() == stationInfo.tagname){
sStationTag = stationInfo.tagname;
sStationName = stationInfo.name;
break;
}
}
for(auto &val:dataInfo.groupInfo)
{
if(val.groupName == "component" || val.groupName == "bay")
continue;
if(val.mapInfo.contains(pData->uuid())){
auto mapPro = val.mapInfo[pData->uuid()];
for(auto& pro:mapPro)
{
ExtraProperty extraPro; //层级信息
extraPro.name = pro.name;
extraPro.tag = pro.tagName;
extraPro.grid_tag = sGridTag;
extraPro.grid_name = sGridName;
extraPro.zone_tag = sZoneTag;
extraPro.zone_name = sZoneName;
extraPro.station_tag = sStationTag;
extraPro.station_name = sStationName;
extraPro.currentLevel = QString::number(pData->getVoltageLevel())+"kv";
extraPro.page_tag = _widget->pageName(); //暂时相同
if(bayPro){
extraPro.bay_name = bayPro->name();
extraPro.bay_tag = bayPro->tag();
}
extraPro.component_name = pData->name();
extraPro.component_uuid = pData->uuid();
extraPro.component_tag = tempTag;
extraPro.group_tag = val.groupName;
for(auto& groupInfo:groupMap){
if(val.groupName == groupInfo.groupType){
extraPro.group_name = groupInfo.groupName;
break;
}
}
extraPro.type_name = "参量";
extraPro.type_tag = "parameter";
extraPro.code = extraPro.getFullName();
extraPro.sourceType = "property";
extraPro.sourceConfig.insert("modelName",pData->modelName());
extraPro.connect_para = sGridTag+"."+sZoneTag+"."+sStationTag+"."+extraPro.bay_tag+"."+tempTag+"."+extraPro.group_tag+"."+extraPro.tag;
//取data:模型.属性组.id.属性名
bool exist = DataBase::GetInstance()->ifExtraPropertyExist(extraPro.code);
if(exist)
DataBase::GetInstance()->updateExtraProperty(extraPro);
else
DataBase::GetInstance()->insertExtraProperty(extraPro);
}
}
}
QMap<QString,MeasurementInfo> mapMeasure = pData->getMeasurement(); //量测
QList<ExtraProperty> lstTemp= DataBase::GetInstance()->getCompoExtraProperty(pData->uuid()); //component中的层级关系
QList<ExtraProperty> lstExtra;
for(auto& info:lstTemp){
if(info.group_tag != "bay") //只对量测判断
continue;
info.bay_tag = removeSuffix(info.bay_tag);
lstExtra.append(info);
}
QList<MeasurementInfo> lstDataBase = DataBase::GetInstance()->getMeasurement(pData->uuid()); //数据库中现有量测
for(auto& info:mapMeasure)
{
int tpe = info.type; //todo:建立类型映射表
QJsonObject objDataSource;
QJsonObject objIoAddress;
if(info.nSource == 1){ //3611
objDataSource["type"] = 1;
objIoAddress["station"] = info.sStation;
objIoAddress["device"] = info.sDevice;
objIoAddress["channel"] = info.sChannel;
}
else if(info.nSource == 2){ //104
objDataSource["type"] = 2;
objIoAddress["station"] = info.sStation;
objIoAddress["packet"] = info.nPacket;
objIoAddress["offset"] = info.nOffset;
}
objDataSource["io_address"] = objIoAddress;
QJsonObject objEventPlan;
QJsonObject objCause;
QJsonObject objAction;
QJsonArray arrPara;
objEventPlan["enable"] = info.bEnable;
if(tpe == 0){ //遥测
for(auto iter = info.mapTE.begin();iter != info.mapTE.end();++iter){
objCause[iter.key()] = iter.value();
}
}
else if(tpe == 1){ //遥信
objCause["edge"] = info.sEdge;
}
objEventPlan["cause"] = objCause;
objAction["command"] = info.sCommand;
for(auto &para:info.lstParameter){
arrPara.append(para);
}
objAction["parameters"] = arrPara;
objEventPlan["action"] = objAction;
QJsonObject objBinding;
if(!info.sWindType.isEmpty()){
QJsonObject objWind;
objWind["ratio"] = info.nRatio;
objWind["polarity"] = info.nPolarity;
objWind["index"] = info.nIndex;
objBinding[info.sWindType] = objWind;
}
QString tempMeasure = info.tag+"_"+_pageName; //tag后加工程名保持全局唯一
bool val = DataBase::GetInstance()->ifMeasureExist(info.name,pData->uuid());
if(val){
DataBase::GetInstance()->updateMeasurement(info.name,tpe,objDataSource,objEventPlan,objBinding,info.size,pData->uuid());
}
else{
DataBase::GetInstance()->insertMeasurement(info.name,tempMeasure,tpe,objDataSource,objEventPlan,objBinding,info.size,info.bayUuid,info.componentUuid);
}
for(int i = 0;i < lstDataBase.size();++i) //从数据库记录中移除操作过的对象
{
if(lstDataBase[i].name == info.name){
lstDataBase.removeAt(i);
break;
}
}
for(int i = 0;i < lstExtra.size();++i){ //同步层级信息计数
if(lstExtra[i].name == info.name){
lstExtra.removeAt(i);
break;
}
}
ExtraProperty extraPro; //层级信息
extraPro.name = info.name;
extraPro.tag = tempMeasure;
extraPro.grid_tag = sGridTag;
extraPro.grid_name = sGridName;
extraPro.zone_tag = sZoneTag;
extraPro.zone_name = sZoneName;
extraPro.station_tag = sStationTag;
extraPro.station_name = sStationName;
extraPro.currentLevel = QString::number(pData->getVoltageLevel())+"kv";
extraPro.page_tag = _widget->pageName(); //暂时相同
if(bayPro){
extraPro.bay_name = bayPro->name();
extraPro.bay_tag = bayPro->tag();
}
extraPro.component_name = pData->name();
extraPro.component_uuid = pData->uuid();
extraPro.component_tag = tempTag;
extraPro.group_tag = "bay";
for(auto& groupInfo:groupMap){
if("bay" == groupInfo.groupType){
extraPro.group_name = groupInfo.groupName;
break;
}
}
if(tpe == 0){
extraPro.type_name = "遥测";
extraPro.type_tag = "telemetry";
}
else if(tpe == 1){
extraPro.type_name = "遥信";
extraPro.type_tag = "telesignal";
}
else if(tpe == 2){
extraPro.type_name = "遥控";
extraPro.type_tag = "telecontrol";
}
extraPro.code = extraPro.getFullName();
extraPro.sourceType = "measurement";
extraPro.connect_para = sGridTag+"."+sZoneTag+"."+sStationTag+"."+extraPro.bay_tag+"."+tempTag+"."+extraPro.group_tag+"."+extraPro.tag;
//取data 量测tag
bool exist = DataBase::GetInstance()->ifExtraPropertyExist(extraPro.code);
if(exist)
DataBase::GetInstance()->updateExtraProperty(extraPro);
else
DataBase::GetInstance()->insertExtraProperty(extraPro);
}
for(auto& info:lstDataBase) //操作的记录小于数据库中的记录,删除库中多出的记录
{
DataBase::GetInstance()->delteMeasurement(info.name,info.componentUuid);
}
for(auto& info:lstExtra){ //删除库中多出的层级信息
DataBase::GetInstance()->deleteExtraProperty(info.code);
}
}
if(pData->type() == 8){
PowerConnection* pCon = TopologyManager::instance().connection(fromPin,toPin);
if(pCon){
int id = DataBase::GetInstance()->topologicExist(con.nSrcNodeId,con.nDestNodeId);
if(id == -1)
DataBase::GetInstance()->insertTopologic(con.nSrcNodeId,con.nDestNodeId,context,0,"",0);
}
}
}
}
}
}
void FixedPortsModel::onSignal_ifExits(QUuid id,const QString& str,int type,GraphicsFunctionModelItem* pitem)
{
bool exist = false;
BaseProperty* pData = nullptr;
QMap<QUuid,BaseProperty*> mapData = BasePropertyManager::instance().getEntityData();
for(auto pro:mapData)
{
if(pro->tag() == str)
{
pData = pro;
exist = true;
break;
}
}
if(exist) //已存在将发出信号的item绑定到此data
{
if(_nodeItem.contains(id)) //发出信号对象id与data对象id相同已绑定,不做响应
return;
QMessageBox msgBox;
msgBox.setText(QString::fromWCharArray(L"提示"));
msgBox.setInformativeText(QString::fromWCharArray(L"此名称对象已存在,是否使用该对象?"));
msgBox.setStandardButtons(QMessageBox::Ok | QMessageBox::Cancel);
msgBox.setDefaultButton(QMessageBox::Cancel);
int ret = msgBox.exec();
switch (ret) {
case QMessageBox::Ok:
{
//todo:断开原来的连接关系
pitem->setProperty(pData);
pitem->setItemId(pData->uuid());
PowerEntity* pEntity = TopologyManager::instance().findEntity(pData->uuid().toString());
if(pEntity){
pitem->setEntity(pEntity); //item对象的逻辑接线点无需重复创建
}
_nodeItem.take(id);
_nodeItem.insert(pData->uuid(),pitem);
}
break;
case QMessageBox::Cancel:
// Cancel was clicked
break;
default:
// should never be reached
break;
}
}
else //创建新data并绑定
{
BaseProperty* pData = addNodeData(id,type,str,pitem->getModelName());
if(pData)
{
pitem->setProperty(pData);
pData->setDataChanged(true); //数据状态改变
}
PowerEntity* pEntity = TopologyManager::instance().createEntity(EntityType::Component,id.toString(),str);
if(pEntity)
pitem->setEntity(pEntity);
createTopoTerminalsByItem(pitem); //创建item对象的逻辑接线点
}
}
void FixedPortsModel::onTimeOut()
{
_Interface->getPointData("i");
_Interface->getPointData("v");
}
void FixedPortsModel::onSignal_GetPointData(QString type,QMap<qint64,double> map)
{
if(map.size() == 1) //实时数据
{
double d = map.first();
//for(auto pro:_nodeData) //demo版本只有一个数据
{
//int t = pro->type();
//if(t == GIT_itemRect)
{
//todo:根据id匹配数据
/*auto p = dynamic_cast<ElectricSvgItemRect_Property*>(pro);
if(p)
{
p->notifyUpdate(); //通知更新
}*/
}
}
}
}
void FixedPortsModel::onSignal_openBayManager()
{
if(m_pBayManager == nullptr){
m_pBayManager = new BayManagerDlg(_widget);
m_pBayManager->setModelController(this);
}
m_pBayManager->showDlg();
}
void FixedPortsModel::onDataTimerOut()
{
if(!_curRequestLst.isEmpty()){
auto pDataAccessor = _cavas->getDataAccessor();
if(pDataAccessor){
_curData = pDataAccessor->getTargetData(_curRequestLst);
if(!_curData.isEmpty())
updateMonitor(_curData);
}
}
}
void FixedPortsModel::onSelectionChanged()
{
QList<QGraphicsItem*> selectedItems = _scene->selectedItems();
if(_cavas){
if(selectedItems.count() != 1) {
if(_widget)
_cavas->onTargetSelected(_widget->getPropertyProxy());
return;
}
GraphicsBaseItem *item = static_cast<GraphicsBaseItem*>(selectedItems.first());
_cavas->onTargetSelected(item);
}
}
void FixedPortsModel::startHttpRequest()
{
if(_timer)
{
_timer->setInterval(1000);
_timer->start();
}
}
DiagramCavas* FixedPortsModel::getCavas()
{
if(_cavas)
return _cavas.data();;
return nullptr;
}
void FixedPortsModel::addPortsToItem_json(PortState sta,QJsonArray jArr,GraphicsBaseItem* pItem)
{
for(QJsonValueRef portJson:jArr)
{
QJsonObject portObj = portJson.toObject();
QString portId = portObj["portId"].toString();
double x = portObj["x"].toDouble();
double y = portObj["y"].toDouble();
if(sta == P_const){
HandleType tye = HandleType(portObj["portType"].toInt());
PortPos locate = PortPos(portObj["locate"].toInt());
double ratioX = 0.0;
double ratioY = 0.0;
if(portObj.contains("xRatio") || portObj.contains("yRatio")){
ratioX = portObj["xRatio"].toDouble();
ratioY = portObj["yRatio"].toDouble();
}
pItem->addPort(P_const,QPointF(x,y),portId,tye,locate,ratioX,ratioY);
}
else if(sta == p_movable){
pItem->addPort(p_movable,QPointF(x,y),portId);
}
}
}
void FixedPortsModel::autoSetModelName(GraphicsBaseModelItem* pItem)
{
ModelProperty* p = pItem->getProperty();
BaseModelProperty* pro = dynamic_cast<BaseModelProperty*>(p);
if(pro){
QString sMeta = pro->metaModelName();
QString sModel = sMeta+"_"+_pageName;
bool exist = ProjectModelManager::instance().getData()[sMeta].contains(sModel);
if(exist){
pro->setModelName(sModel);
pro->getModelProperty().modelSetting.modelName = sModel;
}
}
}
QString FixedPortsModel::removeSuffix(const QString& str)
{
int lastUnderscore = str.lastIndexOf('_');
if (lastUnderscore == -1) return str; // 没有下划线
return str.left(lastUnderscore);
}
ModelProperty* FixedPortsModel::getItemByUid(QList<GraphicsBaseItem*> lst,QUuid uid)
{
for(auto& item:lst){
auto pPro = item->getProperty();
if(pPro->uuid() == uid){
return pPro;
}
}
return nullptr;
}
void FixedPortsModel::updateMonitor(QMap<QString,QMap<quint64,double>> data)
{
for(auto iter = m_monitorPara.begin();iter != m_monitorPara.end();++iter){
for(auto &info:iter.value()){
//if(info.bSelected){
if(data.contains(info.sConnectPara)){
info.mapValue = data.value(info.sConnectPara);
}
//}
}
}
emit dataUpdated();
for(auto& item:_nodeItem){ //更新界面中的数据
QMap<QString,HandleText*> mapText = item->getDynamicText();
for(auto &pText:mapText){
QString sPara = pText->getPara();
if(data.contains(sPara)){
QString sVal= QString::number(data.value(sPara).last());
pText->setText(sVal);
pText->update();
}
}
}
}
void FixedPortsModel::assignMeasureSymmetry(QMap<QString, MeasurementInfo>& measurementMap)
{
// 用于存储每个键对应的tag
QMap<MeasurementKey, QString> keyToTagMap;
for (auto it = measurementMap.begin(); it != measurementMap.end(); ++it) {
MeasurementKey currentKey(it.value());
QString currentTag = it.key();
// 检查是否已经有相同的键
if (keyToTagMap.contains(currentKey)) {
QString otherTag = keyToTagMap[currentKey];
// 找到一对互相设置sSymmetry
measurementMap[currentTag].sSymmetry = measurementMap[otherTag].name;
measurementMap[otherTag].sSymmetry = measurementMap[currentTag].name;
// 从map中移除因为"有且仅有两个item"
keyToTagMap.remove(currentKey);
} else {
// 还没有配对的添加到map中
keyToTagMap[currentKey] = currentTag;
}
}
}
QWidget* FixedPortsModel::getTopWidget()
{
return dynamic_cast<QWidget*>(_widget);
}
QPointF FixedPortsModel::getTerminalPos(const QString& sTerminalId)
{
PowerEntity* pParent = TopologyManager::instance().getEntityByTerminal(sTerminalId);
if(pParent)
{
for(auto &item:_nodeItem)
{
if(pParent->id() == item->itemId().toString()) //找到terminal父图元
{
for(auto &pPort:item->getPorts())
{
if(pPort->getId() == sTerminalId)
{
return pPort->scenePos();
}
}
}
}
}
return QPointF(0,0);
}
ElectricFunctionModelConnectLineItem* FixedPortsModel::getLineItemById(const QString& terminalId)
{
for(auto &iter:_nodeItem) //获取id所在的lineitem
{
auto item = dynamic_cast<GraphicsFunctionModelItem*>(iter);
if(item)
{
if(item->getItemType() == GIT_link)
{
PowerConnection* pCon = TopologyManager::instance().getConnectionContainsTerminal(terminalId);
if(pCon)
{
ModelProperty* pPro = item->getProperty();
if(pPro){
Connection con = pPro->getConnection();
if((pCon->fromTerminalId() == con.nSrcPortId.toString() && pCon->toTerminalId() == con.nDestPortId.toString())
|| (pCon->fromTerminalId() == con.nDestPortId.toString() && pCon->toTerminalId() == con.nSrcPortId.toString())){ //port相同为同一条线
return dynamic_cast<ElectricFunctionModelConnectLineItem*>(item);
}
}
//QUuid uid = item->itemId();
//QUuid conId = QUuid(pCon->id());
//if(uid == conId) /************load的拓扑没有uid使用其他方式判断相等
}
}
}
}
return nullptr;
}
void FixedPortsModel::updateItemLinePort(QUuid uid,ModelFunctionType type)
{
QList<PowerConnection*> lstCon = TopologyManager::instance().getConnectionsFor(uid.toString(),type); //获取item的所有连接
for(auto &pCon:lstCon){
QString baseFromComponentId = pCon->fromComponent();
QString baseToComponentId = pCon->toComponent();
QString baseFromTerId = pCon->fromTerminalId();
QString baseToTerId = pCon->toTerminalId();
auto pLine = static_cast<ElectricFunctionModelConnectLineItem*>(nodeItem(QUuid(pCon->id())));
if(pLine){
if(uid.toString() == baseFromComponentId){
QPointF posFrom = getTerminalPos(baseFromTerId);
pLine->setStartPoint(posFrom);
pLine->calculatePath();
}
else if(uid.toString() == baseToComponentId){
QPointF posTo = getTerminalPos(baseToTerId);
pLine->setEndPoint(posTo);
pLine->calculatePath();
}
}
}
}
void FixedPortsModel::showModelDlg(const QString& sName,QUuid uuid,GraphicsFunctionModelItem* pItem)
{
ModelStateInfo stateInfo = _modelStateInfo[sName];
ModelDataMap mapData = DataManager::instance().modelData();
ItemPropertyDlg* pDlg = dynamic_cast<ItemPropertyDlg*>(stateInfo._PropertyDlg);
if(pDlg)
{
pDlg->showDlg(mapData[sName],uuid,pItem);
m_curPropertyDlg = pDlg;
}
else
qDebug()<<"showModelDlg err";
}
void FixedPortsModel::initialPropertyDlg()
{
for(auto &modelInfo:_modelStateInfo)
{
if(modelInfo._PropertyDlg == NULL)
{
generatePropertyDlg(modelInfo.modelName);
}
}
}
void FixedPortsModel::generatePropertyDlg(const QString& sModel)
{
ModelStateInfo info = _modelStateInfo[sModel];
if(info._PropertyDlg == NULL)
{
ItemPropertyDlg* dlg = new ItemPropertyDlg(_widget);
if(dlg)
{
dlg->setModelController(this);
dlg->loadGroupButton(info.groupInfo);
_modelStateInfo[sModel]._PropertyDlg = dlg;
}
}
}
ConfigurationDiagram* FixedPortsModel::getTopologyDiagram()
{
return dynamic_cast<ConfigurationDiagram*>(_pEntity);
}
void FixedPortsModel::createTopoTerminalsByData(PowerEntity* pParent,QJsonObject componentCon,ModelFunctionType funType)
{
QJsonArray portsArray = componentCon["port"].toArray();
for (QJsonValueRef portJson : portsArray) //每个属性的状态信息
{
QJsonObject node = portJson.toObject();
QString portId = node["portId"].toString();
int x = node["x"].toInt();
int y = node["y"].toInt();
PortPos locate = PortPos(node["locate"].toInt());
HandleType portType = HandleType(node["portType"].toInt());
TerminalType terType;
switch (portType) {
case T_lineIn:
terType = TerminalType::PowerInput;
break;
case T_lineOut:
terType = TerminalType::PowerOutput;
break;
case T_lineInOut:
terType = TerminalType::PowerConnect;
break;
case T_newTral:
terType = TerminalType::NewTral;
break;
default:
break;
}
auto pTer = TopologyManager::instance().createTerminal(pParent->id(),terType,"",QPointF(x,y),portId,funType);
if(pTer)
pTer->setPortLocate(locate);
}
}
bool FixedPortsModel::isItemValid(GraphicsFunctionModelItem* pItem)
{
ModelProperty* pData = pItem->getProperty();
PowerEntity* pEntity = pItem->entity();
return (pData != nullptr && pEntity != nullptr)?true:false;
}
void FixedPortsModel::insertProjectModelName(QString uuid,QString name)
{
if(!_projectModelName.contains(uuid))
_projectModelName.insert(uuid,name);
}
void FixedPortsModel::showProjectIconSettingDlg(GraphicsFunctionModelItem* pItem)
{
if(m_projectIconSettingDlg == nullptr)
{
m_projectIconSettingDlg = new ProjectIconSetting(_widget);
m_projectIconSettingDlg->setController(this);
}
m_projectIconSettingDlg->showDlg(pItem);
}
void FixedPortsModel::updateItemIcon(QString sMeta,QString sModel,QMap<QString,QByteArray> mapData,QString sIndex,int type,int slot)
{
/*if(sIndex.isEmpty()) //此处不再修改系统图图标
ProjectModelManager::instance().getData()[sMeta][sModel].modelSetting.mapUsedSvg = mapData;
else{
ProjectModelManager::instance().getData()[sMeta][sModel].modelSetting.mapUsedSvg[sIndex] = mapData[sIndex];
}*/
if(mapData.size() == 1){ //单项设置
QByteArray sha256Hash = QCryptographicHash::hash(mapData.first(), QCryptographicHash::Sha256).toHex();
QMap<QByteArray,HMIImageInfo>& mapResource = ProjectModelManager::instance().getHMIimageMap(); //更新总HMI资源
if(!mapResource.contains(sha256Hash)){ //库中不存在则新建
HMIImageInfo imageInfo;
imageInfo.baseType = type;
imageInfo.imageName = mapData.firstKey();
imageInfo.hash256 = sha256Hash;
imageInfo.svgData = mapData.first();
mapResource.insert(sha256Hash,imageInfo);
}
updateHMIRef(QUuid(_widget->getEntity()->id()),sModel,sha256Hash,slot); //更新本页的资源引用
}
updateModelIcon(sMeta,sModel,mapData,sIndex);
}
void FixedPortsModel::updateModelIcon(QString sMeta,QString sModel,QMap<QString,QByteArray> mapData,QString sIndex)
{
for(auto &pItem:_nodeItem){
auto pro = pItem->getProperty();
QString sMe = pro->metaModelName();
QString sMo = pro->modelName();
if(/*sMeta == sMe &&*/sModel == sMo){
auto pI = dynamic_cast<ElectricFunctionModelSvgItem*>(pItem);
auto pG = dynamic_cast<ElectricFunctionModelSvgGroup*>(pItem);
if(pI){
pI->updateMapSvg(mapData,sIndex);
}
if(pG){
pG->updateMapSvg(mapData,sIndex);
}
}
}
}
void FixedPortsModel::addBayItem(QUuid id,ModelFunctionType tpe)
{
if(tpe == ModelFunctionType::BaseModel){
QMap<QUuid,BayProperty*> mapData = BasePropertyManager::instance().getBaseBayData(); //加载的图形必定关联component(todo:完善判断条件,如判断拓扑节点)
if(mapData.contains(id))
{
BayProperty* pro = mapData.value(id);
if(pro)
{
addBayByData(pro,tpe);
}
}
}
else if(tpe == ModelFunctionType::ProjectModel)
{
QMap<QUuid,BayProperty*> mapData = BasePropertyManager::instance().getBayData(); //加载的图形必定关联component(todo:完善判断条件,如判断拓扑节点)
if(mapData.contains(id))
{
BayProperty* pro = mapData.value(id);
if(pro)
{
addBayByData(pro);
}
}
}
}
bool FixedPortsModel::addBayItem(QUuid id,ElectricBayItem* pBay,ModelFunctionType typ)
{
if(typ == ModelFunctionType::ProjectModel){
if(_bayItem.contains(id))
return false;
else
{
_bayItem.insert(id,pBay);
return true;
}
}
return false;
}
void FixedPortsModel::addItemsToBay(QList<GraphicsBaseItem*> lstItem,ElectricBayItem* pBay)
{
if(pBay == nullptr)
return;
BayProperty* proBay = dynamic_cast<BayProperty*>(pBay->getProperty());
if(proBay){
for(auto& item:lstItem){
if(item){
ModelProperty* p = item->getProperty();
auto lstCom = proBay->getLstComponent();
if(!lstCom.contains(p->uuid())){
proBay->getLstComponent().append(p->uuid());
}
}
}
}
}
BayProperty* FixedPortsModel::addBayData(QUuid uuid,ModelFunctionType typ)
{
if(typ == ModelFunctionType::BaseModel){
BayProperty* pData = BasePropertyManager::instance().findBaseBayData(uuid); //已存在不不创建
if(pData != nullptr)
return pData;
BayProperty* item = new BayProperty();
if(item)
{
item->setUuid(uuid);
BasePropertyManager::instance().insertBaseBayData(uuid,item);
}
return item;
}
else if(typ == ModelFunctionType::ProjectModel){
BayProperty* pData = BasePropertyManager::instance().findBayData(uuid); //已存在不不创建
if(pData != nullptr)
return pData;
BayProperty* item = new BayProperty();
if(item)
{
item->setUuid(uuid);
BasePropertyManager::instance().insertBayData(uuid,item);
}
return item;
}
return nullptr;
}
QMap<QUuid,ElectricBayItem*>& FixedPortsModel::allBayItem()
{
return _bayItem;
}
BayProperty* FixedPortsModel::generateBayData(BayProperty* pData,QList<BaseProperty*> lst)
{
BayProperty* p = addBayData(pData->uuid());
p->setTag(pData->tag());
p->setName(pData->name());
p->setType(pData->getType());
p->setVoltage(pData->getVoltage());
p->setFla(pData->getFla());
p->setCapacity(pData->getCapacity());
p->setInService(pData->getInService());
QList<QUuid> lstCompo = pData->getLstComponent();
QList<QUuid> lstNewCompo = getCorrespondId(lstCompo,lst); //将基模component替换为工程模component
p->setLstComponent(lstNewCompo);
QList<QUuid> lstFrom = pData->getLstFrom();
QList<QUuid> lstNewFrom = getCorrespondId(lstFrom,lst);
p->setLstFrom(lstNewFrom);
QList<QUuid> lstTo = pData->getLstTo();
QList<QUuid> lstNewTo = getCorrespondId(lstTo,lst);
p->setLstTo(lstNewTo);
QList<QUuid> lstProtect = pData->getLstProtect();
QList<QUuid> lstNewProtect = getCorrespondId(lstProtect,lst);
p->setLstProtect(lstNewProtect);
QList<QUuid> lstFaultRecord = pData->getLstFaultRecord();
QList<QUuid> lstNewFaultRecord = getCorrespondId(lstFaultRecord,lst);
p->setLstFaultRecord(lstNewFaultRecord);
QList<QUuid> lstDynSense = pData->getLstDynSense();
QList<QUuid> lstNewDynSense = getCorrespondId(lstDynSense,lst);
p->setLstDynSense(lstNewDynSense);
QList<QUuid> lstStatus = pData->getLstStatus();
QList<QUuid> lstNewStatus = getCorrespondId(lstStatus,lst);
p->setLstStatus(lstNewStatus);
QList<QUuid> lstInstruct = pData->getLstInstruct();
QList<QUuid> lstNewInstruct = getCorrespondId(lstInstruct,lst);
p->setLstInstruct(lstNewInstruct);
QList<QUuid> lstEtc = pData->getLstEtc();
QList<QUuid> lstNewEtc= getCorrespondId(lstEtc,lst);
p->setLstEtc(lstNewEtc);
return p;
}
QList<QUuid> FixedPortsModel::getCorrespondId(QList<QUuid> lstCompo,QList<BaseProperty*> lst)
{
QList<QUuid> lstNewCompo;
for(auto& uuid:lstCompo)
{
for(auto& basePro:lst)
{
if(basePro->getSourceItemId() == uuid.toString()){ //工程模sourceid等于基模存储的componentid
lstNewCompo.append(basePro->uuid());
break;
}
}
}
return lstNewCompo;
}
QRectF FixedPortsModel::calculateItemsBoundingRect(QList<GraphicsBaseItem*> items)
{
if (items.isEmpty())
return QRectF();
// 初始化矩形为第一个item的场景边界矩形
QRectF boundingRect = items.first()->sceneBoundingRect();
// 遍历剩余item扩展矩形以包含所有item
for (int i = 1; i < items.size(); ++i) {
QGraphicsItem* item = items.at(i);
// 确保item在场景中且有效
if (item && item->scene()) {
boundingRect = boundingRect.united(item->sceneBoundingRect());
}
}
return boundingRect.adjusted(-10,-10,10,10);
}
void FixedPortsModel::addBayByData(BayProperty* pData,ModelFunctionType typ)
{
if(typ == ModelFunctionType::ProjectModel){
QList<GraphicsBaseItem*> items;
QList<QUuid> lstCompo = pData->getLstComponent();
for(auto& id:lstCompo){
if(_nodeItem.contains(id)){
items.append(_nodeItem.value(id));
}
}
QRectF rec = calculateItemsBoundingRect(items);
auto pBay = new ElectricBayItem(rec);
pBay->setItemType(GIT_bay);
pBay->setProperty(pData);
pBay->setText(pData->name());
addBayItem(pData->uuid(),pBay);
getScene()->addItem(pBay);
}
}
void FixedPortsModel::showBayMeasureDlg(BayProperty* pPro)
{
if(m_bayMeasureDlg == nullptr)
{
m_bayMeasureDlg = new BayMeasureDlg(_widget);
}
m_bayMeasureDlg->showDlg(pPro);
}
QJsonObject FixedPortsModel::turnListToJson(QList<QUuid> lst,QString sInerTag,QString sOutTag)
{
QJsonObject o;
QJsonArray arr;
if(lst.isEmpty())
return QJsonObject();
for(auto id:lst)
{
QJsonObject obj;
obj[sInerTag] = id.toString();
arr.push_back(obj);
}
o[sOutTag] = arr;
return o;
}
QList<QUuid> FixedPortsModel::turnJsonArrToList(QJsonObject object,QString sInner,QString sOut)
{
QJsonArray jsonArray = object[sOut].toArray();
QList<QUuid> lst;
for (QJsonValueRef nodeJson : jsonArray)
{
QJsonObject node = nodeJson.toObject();
QUuid uid = QUuid(node[sInner].toString());
lst.append(uid);
}
return lst;
}
void FixedPortsModel::generateMonitorConfig(MonitorPanel* pPanel)
{
auto itemData = DataManager::instance().modelData();
auto itemState = DataManager::instance().modelState();
for(auto& pItem:_nodeItem){
auto pBasePro = pItem->getProperty();
auto pPro = dynamic_cast<BaseProperty*>(pBasePro);
if(pPro){
QString sModel = pPro->modelName();
QUuid uid = pPro->uuid();
QList<MonitorItemAttributeInfo> lstInfo;
if(itemState.contains(sModel)){ //动态表字段数据使用modelState初始化(兼容无值情况)
auto mapData = itemState.value(sModel).groupInfo;
for(auto iter = mapData.begin();iter != mapData.end();++iter){
if(iter.value().isPublic == true) //公共属性组暂不显示
continue;
for(auto& attr: iter.value().info){
MonitorItemAttributeInfo info;
info.sGroup = iter.key();
info.sTag = attr.tagName;
info.sName = attr.name;
info.nConnectType = 0;
lstInfo.append(info);
}
}
}
if(itemData.contains(sModel)){ //量测数据使用modelData初始化
auto mapData = itemData.value(sModel).groupInfo;
for(auto iter = mapData.begin();iter != mapData.end();iter++){ //遍历所有属性组
if(iter.key() == "bay"){ //量测数据放到间隔组
auto mapMeasure = pPro->getMeasurement();
for(auto it = mapMeasure.begin(); it != mapMeasure.end();++it){
MonitorItemAttributeInfo info;
info.sGroup = iter.key();
info.sTag = it->name;
info.sName = it->tag;
info.nConnectType = 1;
lstInfo.append(info);
}
}
}
}
if(!lstInfo.isEmpty()){
if(!pPanel->getModelController()->getMonitorPara().contains(uid)){
pPanel->getModelController()->getMonitorPara().insert(uid,lstInfo);
}
}
}
}
}
void FixedPortsModel::monitorItemSelected(QUuid uid)
{
auto pMonitor = dynamic_cast<MonitorPanel*>(_widget);
if(pMonitor){
pMonitor->itemSelected(uid);
}
}
void FixedPortsModel::monitorItemDetailAttr(QUuid uid)
{
auto pMonitor = dynamic_cast<MonitorPanel*>(_widget);
if(pMonitor){
pMonitor->detailItemSelected(uid);
}
}
void FixedPortsModel::monitorItemSet(QUuid uid)
{
if(_nodeItem.contains(uid)){
QList<QString> lstAdd; //需要向item添加的动态数据
auto pItem = _nodeItem.value(uid);
auto lst = m_monitorPara.value(uid);
for(auto& info:lst){
if(info.bShowDiagram && info.bSelected){
lstAdd.append(info.sTag);
}
}
pItem->removeAllDynamicText();
for(auto& str:lstAdd){
for(auto& info:lst){
if(info.sTag == str){
pItem->addDynamicText(info.sTag,info.sConnectPara);
continue;
}
}
}
}
}
void FixedPortsModel::updateMonitorDisplay()
{
for(auto& pItem:_nodeItem){
auto pPro = pItem->getProperty();
if(pPro){
QString sMeta = pPro->metaModelName();
for(auto iter = m_monitorDisplaySetting.begin();iter != m_monitorDisplaySetting.end();++iter){ //将设置的显示数据更新到item(显示数据不放入item的property)
if(iter.key().sTag == sMeta){
pItem->setMonitorDisplayInfo(iter.value());
pItem->updateCurState(MonitorItemState::Normal);
break;
}
}
}
}
}
void FixedPortsModel::startAcceptData()
{
QStringList lstTarget; //待订阅的对象
for(auto& lst:m_monitorPara){
for(auto& para:lst){
if(para.bSelected && !para.sConnectPara.isEmpty()){
if(!lstTarget.contains(para.sConnectPara))
lstTarget.append(para.sConnectPara);
}
}
}
QJsonObject obj; //构建开始请求
obj["action"] = "start";
QJsonArray arrMeasure;
QJsonObject objMeasure;
objMeasure["interval"] = "2s";
QJsonArray arrTargets;
for(auto& strTarget:lstTarget){
arrTargets.append(strTarget);
}
objMeasure["targets"] = arrTargets;
arrMeasure.append(objMeasure);
obj["measurements"] = arrMeasure;
QString sPath = "/monitors/data/subscriptions";
QJsonDocument doc(obj);
QVariant variant = doc.toVariant();
UiCommunicationBus::instance()->sendHttpRequest(sPath,variant,"POST");
QList<QPair<QString,QString>> requestLst; //等待请求的队列
for(auto& str:lstTarget){
requestLst.append(qMakePair(str,"request"));
}
UiCommunicationBus::instance()->insertTempRequest(_pageName,requestLst);
_curRequestLst = lstTarget;
m_dataTimer->start();
}
void FixedPortsModel::stopAcceptData(QString page)
{
if(UiCommunicationBus::instance()->getSesstionMap().contains(page)){
auto& curSession = UiCommunicationBus::instance()->getSesstionMap()[page];
QJsonObject obj; //构建开始请求
obj["action"] = "stop";
obj["client_id"] = curSession.first;
QJsonArray arrMeasure;
QJsonObject objMeasure;
objMeasure["interval"] = "2s";
QJsonArray arrTargets;
for(auto& pairTarget:curSession.second){
arrTargets.append(pairTarget.first);
pairTarget.second = "closing";
}
objMeasure["targets"] = arrTargets;
arrMeasure.append(objMeasure);
obj["measurements"] = arrMeasure;
QString sPath = "/monitors/data/subscriptions";
QJsonDocument doc(obj);
QVariant variant = doc.toVariant();
UiCommunicationBus::instance()->sendHttpRequest(sPath,variant,"POST");
}
m_dataTimer->stop();
}
int FixedPortsModel::imageRefExist(QString model,QByteArray hash256)
{
for(auto& info:_HMIimageRef)
{
if(model == info.model && hash256 == info.hash256)
return _HMIimageRef.indexOf(info);
}
return -1;
}
void FixedPortsModel::updateHMIRef(QUuid hmiId,QString model,QByteArray hash256,int slot)
{
HMIImageRef ref;
ref.hmiId = hmiId;
ref.model = model;
ref.hash256 = hash256;
ref.slot = slot;
int index = imageRefExist(model,hash256);
if(index != -1){ //已存在,替换
_HMIimageRef[index] = ref;
}
else{ //新建
_HMIimageRef.append(ref);
}
}