static void populateRuleComponentModel(RuleComponentModel *component, QmlObject::Ptr object,
                                       const QMap<QString, QmlObject::Ptr> &mappers)
{
    if (!component) {
        return;
    }

    for (int i = 0; i < component->count(); ++i) {
        QVariant type = component->data(component->index(i), RuleComponentModel::Type);
        MetaProperty *meta = type.value<MetaProperty *>();
        if (meta) {
            QString key = meta->name();
            if (object->hasProperty(key)) {
                // TODO: migrate to MetaProperty
                QVariant value = object->property(key);
                if (value.canConvert<Reference::Ptr>()) {
                    Reference::Ptr reference = value.value<Reference::Ptr>();
                    if (mappers.contains(reference->identifier())) {
                        // Check mapper
                        QmlObject::Ptr mapper = mappers.value(reference->identifier());
                        if (mapper->type() == "TimeMapper") {
                            int hour = mapper->property("hour").toInt();
                            int minute = mapper->property("minute").toInt();
                            QTime time = QTime(hour, minute);
                            component->setValue(i, QVariant(time));
                        }
                    }
                } else {
                    component->setValue(i, value);
                }
            }
        }
    }
}
Beispiel #2
0
void TstParser::testDocument()
{
    QmlObject::Ptr root = QmlObject::create("Test");
    root->setId("test");

    QVariantMap properties;
    QVariantList intList;
    intList << 1 << 2 << 3 << 4;
    properties.insert("intList", intList);
    QString string = "My test string";
    properties.insert("string", string);
    root->setProperties(properties);
    qWarning() << root->toString(0);

    QmlObject::Ptr superRoot = QmlObject::create("Super");
    QVariantMap superProperties;
    QVariantList objectList;
    objectList << QVariant::fromValue(root);
    superProperties.insert("objectList", objectList);
    superRoot->setProperties(superProperties);
    qWarning() << superRoot->toString(0);
}
void RulesModel::reload()
{
    if (!m_data.isEmpty()) {
        beginRemoveRows(QModelIndex(), 0, rowCount() - 1);
        qDeleteAll(m_data);
        m_data.clear();
        endRemoveRows();
    }

    QStringList rules = m_proxy->Rules();
    for (const QString &rule : rules) {
        bool valid = true;

        // Parse rule
        QmlDocument::Ptr doc = QmlDocument::create(rule);

        if (doc->error() == QmlDocument::NoError) {
            RuleDefinition *ruleDefinition = new RuleDefinition(this);
            QmlObject::Ptr root = doc->rootObject();

            // 1. Get a list of mappers
            QMap<QString, QmlObject::Ptr> mappers;
            if (root->hasProperty("mappers")) {
                QVariantList mappersVariant = root->property("mappers").toList();
                for (const QVariant &mapperVariant : mappersVariant) {
                    if (mapperVariant.canConvert<QmlObject::Ptr>()) {
                        QmlObject::Ptr mapper = mapperVariant.value<QmlObject::Ptr>();
                        mappers.insert(mapper->id(), mapper);
                    }
                }
            }


            // 2. Name
            QString name = root->property("name").toString();

            // 3. Trigger and condition
            QString triggerType;
            if (root->hasProperty("trigger")) {
                QmlObject::Ptr trigger = root->property("trigger").value<QmlObject::Ptr>();
                if (!trigger.isNull()) {
                    triggerType = trigger->type();
                    RuleComponentModel *triggerComponent = ruleDefinition->createTempComponent(PhoneBotHelper::Trigger, -1, triggerType);
                    populateRuleComponentModel(triggerComponent, trigger, mappers);
                    valid = triggerComponent;
                }
            }

            QString conditionType;
            if (root->hasProperty("condition")) {
                QmlObject::Ptr condition = root->property("condition").value<QmlObject::Ptr>();
                if (!condition.isNull()) {
                    conditionType = condition->type();
                    RuleComponentModel *conditionComponent = ruleDefinition->createTempComponent(PhoneBotHelper::Condition, -1, conditionType);
                    populateRuleComponentModel(conditionComponent, condition, mappers);
                    valid = valid && conditionComponent;
                }
            }

            ruleDefinition->saveComponent(-1);
            ruleDefinition->setName(name);

            // 4. Actions
            if (root->hasProperty("actions")) {
                QVariantList actionsVariant = root->property("actions").toList();
                RuleDefinitionActionModel *actions = ruleDefinition->actions();
                for (const QVariant &actionVariant : actionsVariant) {
                    if (actionVariant.canConvert<QmlObject::Ptr>()) {
                        int index = actions->count();
                        QmlObject::Ptr action = actionVariant.value<QmlObject::Ptr>();
                        RuleComponentModel *actionModel = actions->createTempComponent(PhoneBotHelper::Action,
                                                                                       index, action->type());
                        populateRuleComponentModel(actionModel, action, mappers);
                        actions->saveComponent(index);
                        valid = valid && actionModel;
                    }
                }
            }

            // 5. Save everything
            RulesModelData *data = new RulesModelData;
            data->path = rule;
            data->definition = ruleDefinition;
            data->valid = valid;
            m_data.append(data);
        }
    }

    beginInsertRows(QModelIndex(), 0, m_data.count() - 1);
    emit countChanged();
    endInsertRows();
}
Beispiel #4
0
void TstParser::parseRule()
{
    QString fileName = ":/simpletest.qml";
    QmlDocument::Ptr document = QmlDocument::create(fileName);
    QVERIFY(!document.isNull());
    QCOMPARE(document->fileName(), fileName);

    // Verify imports
    QCOMPARE(document->imports().count(), 4);
    ImportStatement::Ptr import = document->imports()[0];
    QCOMPARE(import->importUri(), QString("QtQuick"));
    QVERIFY(import->importFile().isEmpty());
    QCOMPARE(import->version(), QString("2.0"));
    QVERIFY(import->importId().isEmpty());
    import = document->imports()[1];
    QVERIFY(import->importUri().isEmpty());
    QCOMPARE(import->importFile(), QString("Test.qml"));
    QCOMPARE(import->version(), QString("1.0"));
    QCOMPARE(import->importId(), QString("Test"));
    import = document->imports()[2];
    QCOMPARE(import->importUri(), QString("QtQuick"));
    QVERIFY(import->importFile().isEmpty());
    QCOMPARE(import->version(), QString("2.0"));
    QCOMPARE(import->importId(), QString("QQ"));
    import = document->imports()[3];
    QVERIFY(import->importUri().isEmpty());
    QCOMPARE(import->importFile(), QString("Test.qml"));
    QVERIFY(import->version().isEmpty());
    QVERIFY(import->importId().isEmpty());




    QmlObject::Ptr root = document->rootObject();
    QVERIFY(!root.isNull());
    QCOMPARE(root->properties().count(), 6);
    QCOMPARE(root->type(), QString("Rectangle"));
    QCOMPARE(root->id(), QString("test"));

    // Properties
    QVERIFY(root->hasProperty("width"));
    QCOMPARE(root->property("width"), QVariant(100));
    QVERIFY(root->hasProperty("text"));
    QCOMPARE(root->property("text"), QVariant("Test"));
    QVERIFY(root->hasProperty("item"));
    QmlObject::Ptr item = root->property("item").value<QmlObject::Ptr>();
    QVERIFY(!item.isNull());
    QCOMPARE(item->type(), QString("Item"));
    QCOMPARE(item->id(), QString("subTest"));
    QVERIFY(root->hasProperty("anchors.top"));
    QVariant anchorsTopProperty = root->property("anchors.top");
    QVERIFY(anchorsTopProperty.canConvert<Reference>());
    QCOMPARE(anchorsTopProperty.value<Reference>().value(), QString("parent.top"));
    QVERIFY(root->hasProperty("js"));
    QVariant jsProperty = root->property("js");
    QVERIFY(jsProperty.canConvert<Expression>());
    QCOMPARE(jsProperty.value<Expression>().value(), QString("new Date(1960, 1, 1)"));
    QVERIFY(root->hasProperty("array"));

    // Children
    QCOMPARE(root->children().count(), 2);
    QmlObject::Ptr child = root->children().first();
    QVERIFY(!child.isNull());
    QCOMPARE(child->type(), QString("Text"));
    QCOMPARE(child->properties().count(), 1);
    QVERIFY(child->hasProperty("text"));
    QCOMPARE(child->property("text").toString(), QString("Test 2"));

    child = root->children()[1];
    QCOMPARE(child->type(), QString("Test"));
    QCOMPARE(child->properties().count(), 1);
    QVERIFY(child->hasProperty("test.anchors.left"));
    QVariant testAnchorsLeft = child->property("test.anchors.left");
    QVERIFY(testAnchorsLeft.canConvert<Reference>());
    QCOMPARE(testAnchorsLeft.value<Reference>().value(), QString("test.anchors.right"));
}