DiagramDesigner/diagramCavas/source/structDataSource.cpp

#include "structDataSource.h"
#include "dataBase.h"
#include "global.h"

StructDataSource::StructDataSource(QObject* parent) : QObject(parent) {

}

// 根据code获取属性
ExtraProperty* StructDataSource::getPropertyByCode(const QString& code) {
    auto it = allProperties.find(code);
    if (it != allProperties.end()) {
        return &it.value();
    }
    return nullptr;
}

// 根据tag获取属性
ExtraProperty* StructDataSource::getPropertyByTag(const QString& tag) {
    for (auto it = allProperties.begin(); it != allProperties.end(); ++it) {
        if (it.value().tag == tag) {
            return &it.value();
        }
    }
    return nullptr;
}

// 根据group获取属性列表
QVector<ExtraProperty> StructDataSource::getPropertiesByGroup(const QString& groupTag, const QString& modelName) {
    QVector<ExtraProperty> result;
    for (auto it = allProperties.begin(); it != allProperties.end(); ++it) {
        const ExtraProperty& prop = it.value();
        if (prop.group_tag == groupTag &&
            (modelName.isEmpty() || prop.sourceConfig.value("modelName").toString() == modelName)) {
            result.append(prop);
        }
    }
    return result;
}

// 根据sourceType获取属性列表
QVector<ExtraProperty> StructDataSource::getPropertiesBySourceType(const QString& sourceType) {
    QVector<ExtraProperty> result;
    for (auto it = allProperties.begin(); it != allProperties.end(); ++it) {
        if (it.value().sourceType == sourceType) {
            result.append(it.value());
        }
    }
    return result;
}

// 添加或更新属性
bool StructDataSource::addOrUpdateProperty(const ExtraProperty& prop) {
    if (prop.code.isEmpty()) {
        qWarning() << "Property code is empty";
        return false;
    }

    bool isNew = !allProperties.contains(prop.code);
    allProperties[prop.code] = prop;

    emit propertyUpdated(prop, isNew);
    return true;
}

// 更新单个属性
bool StructDataSource::updateProperty(const ExtraProperty& updatedProp) {
    if (updatedProp.code.isEmpty()) {
        qWarning() << "Property code is empty";
        return false;
    }

    if (!allProperties.contains(updatedProp.code)) {
        qWarning() << "Property not found:" << updatedProp.code;
        return false;
    }

    allProperties[updatedProp.code] = updatedProp;
    emit propertyUpdated(updatedProp, false);
    return true;
}

// 更新connect_para
bool StructDataSource::updateConnectPara(const QString& code, const QString& newConnectPara) {
    auto it = allProperties.find(code);
    if (it != allProperties.end()) {
        it.value().connect_para = newConnectPara;
        emit propertyUpdated(it.value(), false);
        return true;
    }
    return false;
}

// 批量更新
void StructDataSource::updateProperties(const QVector<ExtraProperty>& updatedProps) {
    for (const auto& prop : updatedProps) {
        updateProperty(prop);
    }
}

// 删除属性
bool StructDataSource::removeProperty(const QString& code) {
    if (allProperties.contains(code)) {
        ExtraProperty removedProp = allProperties[code];
        allProperties.remove(code);
        emit propertyRemoved(removedProp);
        return true;
    }
    return false;
}

// 批量删除
int StructDataSource::removeProperties(const QVector<QString>& codes) {
    int count = 0;
    for (const QString& code : codes) {
        if (removeProperty(code)) {
            count++;
        }
    }
    return count;
}

// 保存到文件
void StructDataSource::saveAll() {
    for(auto& pro:allProperties){
        if(pro.bDataChanged){           //已修改，需要保存
            if(pro.sourceType == "measurement"){        //量测
                auto pMeasure = getMeasurementData(pro);
                if(pMeasure){
                    QJsonObject objDataSource;
                    QJsonObject objIoAddress;
                    if(pMeasure->nSource == 1){      //3611
                        objDataSource["type"] = 1;
                        objIoAddress["station"] = pMeasure->sStation;
                        objIoAddress["device"] = pMeasure->sDevice;
                        objIoAddress["channel"] = pMeasure->sChannel;
                    }
                    else if(pMeasure->nSource == 2){     //104
                        objDataSource["type"] = 2;
                        objIoAddress["station"] = pMeasure->sStation;
                        objIoAddress["packet"] = pMeasure->nPacket;
                        objIoAddress["offset"] = pMeasure->nOffset;
                    }
                    objDataSource["io_address"] = objIoAddress;

                    QJsonObject objEventPlan;
                    QJsonObject objCause;
                    QJsonObject objAction;
                    QJsonArray arrPara;
                    objEventPlan["enable"] = pMeasure->bEnable;
                    if(pMeasure->type == 0){       //遥测
                        for(auto iter = pMeasure->mapTE.begin();iter != pMeasure->mapTE.end();++iter){
                            objCause[iter.key()] = iter.value();
                        }
                    }
                    else if(pMeasure->type == 1){      //遥信
                        objCause["edge"] = pMeasure->sEdge;
                    }
                    objEventPlan["cause"] = objCause;

                    objAction["command"] = pMeasure->sCommand;
                    for(auto &para:pMeasure->lstParameter){
                        arrPara.append(para);
                    }
                    objAction["parameters"] = arrPara;
                    objEventPlan["action"] = objAction;

                    QJsonObject objBinding;
                    if(!pMeasure->sWindType.isEmpty()){
                        QJsonObject objWind;
                        objWind["ratio"] = pMeasure->nRatio;
                        objWind["polarity"] = pMeasure->nPolarity;
                        objWind["index"] = pMeasure->nIndex;
                        objBinding[pMeasure->sWindType] = objWind;
                    }

                    DataBase::GetInstance()->updateMeasurement(pMeasure->name,pMeasure->type,objDataSource,objEventPlan,objBinding,pMeasure->size,pMeasure->componentUuid);
                }
            }
        }
    }
}

// 加载数据

// 获取所有属性的code列表
QStringList StructDataSource::getAllCodes() const {
    return allProperties.keys();
}

// 获取所有属性
QVector<ExtraProperty> StructDataSource::getAllProperties() const {
    return allProperties.values();
}

// 获取property数据
propertyStateInfo* StructDataSource::getPropertyData(const ExtraProperty& prop) {
    QString modelName = prop.sourceConfig.value("modelName").toString();
    QString groupTag = prop.group_tag;
    QUuid componentUuid = prop.component_uuid;
    QString propertyTag = prop.tag;

    auto itModel = m_propertyData.find(modelName);
    if (itModel == m_propertyData.end()) return nullptr;

    auto itGroup = itModel->groupInfo.find(groupTag);
    if (itGroup == itModel->groupInfo.end()) return nullptr;

    auto itComponent = itGroup->mapInfo.find(componentUuid);
    if (itComponent == itGroup->mapInfo.end()) return nullptr;

    auto itProperty = itComponent->find(propertyTag);
    if (itProperty == itComponent->end()) return nullptr;

    return &itProperty.value();
}

// 获取measurement数据
MeasurementInfo* StructDataSource::getMeasurementData(const ExtraProperty& prop) {
    auto it = m_measurementData.find(prop.tag);
    if (it != m_measurementData.end()) {
        return &it.value();
    }
    return nullptr;
}

// 验证数据
bool StructDataSource::validateProperty(const ExtraProperty& prop) {
    if (prop.code.isEmpty()) {
        qWarning() << "Property code is empty";
        return false;
    }

    if (prop.name.isEmpty()) {
        qWarning() << "Property name is empty:" << prop.code;
        return false;
    }

    if (prop.tag.isEmpty()) {
        qWarning() << "Property tag is empty:" << prop.code;
        return false;
    }

    if (prop.sourceType.isEmpty()) {
        qWarning() << "Property sourceType is empty:" << prop.code;
        return false;
    }

    if (prop.sourceType != "property" && prop.sourceType != "measurement") {
        qWarning() << "Invalid sourceType:" << prop.sourceType << "for property:" << prop.code;
        return false;
    }

    return true;
}

void StructDataSource::loadExtrapro(QMap<QString, ExtraProperty> vec)
{
    allProperties = vec;
}

void StructDataSource::loadPropertyData(QMap<QString, modelDataInfo> map)
{
    m_propertyData = map;
}

void StructDataSource::loadMeasurementData(QMap<QString, MeasurementInfo> map)
{
    m_measurementData = map;
}