refactor json api declaration a bit

server/jsonrpc/devicehandler.cpp

@@ -24,7 +24,7 @@ DeviceHandler::DeviceHandler(QObject *parent) :
     setDescription("GetPlugins", "Returns a list of loaded plugins.");
     setParams("GetPlugins", params);
     QVariantList plugins;
-    plugins.append(JsonTypes::pluginTypeRef());
+    plugins.append(JsonTypes::pluginRef());
     returns.insert("plugins", plugins);
     setReturns("GetPlugins", returns);
 

server/jsonrpc/jsontypes.cpp

@@ -2,11 +2,104 @@
 
 #include "device.h"
 
+#include <QStringList>
 #include <QDebug>
 
-namespace JsonTypes {
+bool JsonTypes::s_initialized = false;
 
-QVariantMap allTypes()
+QVariantList JsonTypes::s_basicTypes;
+QVariantList JsonTypes::s_ruleTypes;
+
+QVariantMap JsonTypes::s_paramType;
+QVariantMap JsonTypes::s_param;
+QVariantMap JsonTypes::s_stateType;
+QVariantMap JsonTypes::s_state;
+QVariantMap JsonTypes::s_triggerType;
+QVariantMap JsonTypes::s_trigger;
+QVariantMap JsonTypes::s_actionType;
+QVariantMap JsonTypes::s_action;
+QVariantMap JsonTypes::s_plugin;
+QVariantMap JsonTypes::s_deviceClass;
+QVariantMap JsonTypes::s_device;
+QVariantMap JsonTypes::s_rule;
+
+void JsonTypes::init()
+{
+    // BasicTypes
+    s_basicTypes << "uuid" << "string" << "integer" << "double" << "bool";
+    s_ruleTypes << "RuleTypeMatchAll" << "RuleTypeMatchAny";
+
+    // ParamType
+    s_paramType.insert("name", "string");
+    s_paramType.insert("type", basicTypesRef());
+//    s_paramType.insert("default", "value");
+//    s_paramType.insert("value", "value");
+
+    // Param
+    s_param.insert("name", "string");
+    s_param.insert("value", basicTypesRef());
+
+    // StateType
+    s_stateType.insert("id", "uuid");
+    s_stateType.insert("name", "string");
+    s_stateType.insert("type", basicTypesRef());
+//    s_stateType.insert("default", "value");
+
+    // State
+    s_state.insert("stateTypeId", "uuid");
+    s_state.insert("deviceId", "uuid");
+    s_state.insert("value", "variant");
+
+    // TriggerType
+    s_triggerType.insert("id", "uuid");
+    s_triggerType.insert("name", "string");
+    s_triggerType.insert("params", QVariantList() << paramTypeRef());
+
+    // Trigger
+    s_trigger.insert("triggerTypeId", "uuid");
+    s_trigger.insert("deviceId", "uuid");
+    s_trigger.insert("params", QVariantList() << paramRef());
+
+    // ActionType
+    s_actionType.insert("id", "uuid");
+    s_actionType.insert("name", "string");
+    s_actionType.insert("params", QVariantList() << paramTypeRef());
+
+    // Action
+    s_action.insert("actionTypeId", "uuid");
+    s_action.insert("deviceId", "uuid");
+    s_action.insert("params", QVariantList() << paramRef());
+
+    // Pugin
+    s_plugin.insert("id", "uuid");
+    s_plugin.insert("name", "string");
+    s_plugin.insert("params", QVariantList() << paramTypeRef());
+
+    // DeviceClass
+    s_deviceClass.insert("id", "uuid");
+    s_deviceClass.insert("name", "string");
+    s_deviceClass.insert("states", QVariantList() << stateTypeRef());
+    s_deviceClass.insert("triggers", QVariantList() << triggerTypeRef());
+    s_deviceClass.insert("actions", QVariantList() << actionTypeRef());
+    s_deviceClass.insert("params", QVariantList() << paramTypeRef());
+
+    // Device
+    s_device.insert("id", "uuid");
+    s_device.insert("deviceClassId", "uuid");
+    s_device.insert("name", "string");
+    s_device.insert("params", QVariantList() << paramRef());
+
+    s_rule.insert("id", "uuid");
+    s_rule.insert("ruleType", ruleTypesRef());
+    s_rule.insert("trigger", triggerRef());
+    s_rule.insert("actions", QVariantList() << actionRef());
+    s_rule.insert("states", QVariantList() << stateRef());
+
+
+    s_initialized = true;
+}
+
+QVariantMap JsonTypes::allTypes()
 {
     QVariantMap allTypes;
     allTypes.insert("BasicType", basicTypes());
@@ -15,107 +108,18 @@ QVariantMap allTypes()
     allTypes.insert("TriggerType", triggerTypeDescription());
     allTypes.insert("ActionType", actionTypeDescription());
     allTypes.insert("DeviceClass", deviceClassDescription());
-    allTypes.insert("PluginType", pluginTypeDescription());
+    allTypes.insert("Plugin", pluginDescription());
     allTypes.insert("Param", paramDescription());
     allTypes.insert("State", stateDescription());
     allTypes.insert("Trigger", triggerDescription());
     allTypes.insert("Device", deviceDescription());
     allTypes.insert("Action", actionDescription());
+    allTypes.insert("RuleType", ruleTypes());
     allTypes.insert("Rule", ruleDescription());
     return allTypes;
 }
 
-QString basicTypesRef()
+QVariantMap JsonTypes::packTriggerType(const TriggerType &triggerType)
-{
-    return "$ref:BasicType";
-}
-
-QVariantList basicTypes()
-{
-    QVariantList basicTypes;
-    basicTypes.append("uuid");
-    basicTypes.append("string");
-    basicTypes.append("integer");
-    basicTypes.append("double");
-    basicTypes.append("bool");
-    return basicTypes;
-}
-
-QString paramTypeRef()
-{
-    return "$ref:ParamType";
-}
-
-QVariantMap paramTypeDescription()
-{
-    QVariantMap paramType;
-    paramType.insert("name", "string");
-    paramType.insert("type", basicTypesRef());
-//    paramType.insert("default", "value");
-//    paramType.insert("value", "value");
-    return paramType;
-}
-
-QString paramRef()
-{
-    return "$ref:Param";
-}
-
-QVariantMap paramDescription()
-{
-    QVariantMap param;
-    param.insert("name", "string");
-    param.insert("value", basicTypesRef());
-    return param;
-}
-
-QString stateTypeRef()
-{
-    return "$ref:StateType";
-}
-
-QVariantMap stateTypeDescription()
-{
-    QVariantMap stateTypeDescription;
-    stateTypeDescription.insert("id", "uuid");
-    stateTypeDescription.insert("name", "string");
-    stateTypeDescription.insert("type", basicTypesRef());
-//    stateTypeDescription.insert("default", "value");
-    return stateTypeDescription;
-}
-
-QString stateRef()
-{
-    return "$ref:Sate";
-}
-
-QVariantMap stateDescription()
-{
-    QVariantMap stateDescription;
-    stateDescription.insert("stateTypeId", "uuid");
-    stateDescription.insert("deviceId", "uuid");
-    stateDescription.insert("value", "variant");
-    return stateDescription;
-}
-
-
-QString triggerTypeRef()
-{
-    return "$ref:TriggerType";
-}
-
-QVariantMap triggerTypeDescription()
-{
-    QVariantMap triggerTypeDescription;
-    triggerTypeDescription.insert("id", "uuid");
-    triggerTypeDescription.insert("name", "string");
-    QVariantList params;
-    params.append(paramTypeRef());
-    triggerTypeDescription.insert("params", params);
-    return triggerTypeDescription;
-}
-
-QVariantMap packTriggerType(const TriggerType &triggerType)
 {
     QVariantMap variant;
     variant.insert("id", triggerType.id());
@@ -124,23 +128,7 @@ QVariantMap packTriggerType(const TriggerType &triggerType)
     return variant;
 }
 
-QString triggerRef()
+QVariantMap JsonTypes::packTrigger(const Trigger &trigger)
-{
-    return "$ref:Trigger";
-}
-
-QVariantMap triggerDescription()
-{
-    QVariantMap triggerDescription;
-    triggerDescription.insert("triggerTypeId", "uuid");
-    triggerDescription.insert("deviceId", "uuid");
-    QVariantList params;
-    params.append(paramRef());
-    triggerDescription.insert("params", params);
-    return triggerDescription;
-}
-
-QVariantMap packTrigger(const Trigger &trigger)
 {
     QVariantMap variant;
     variant.insert("triggerTypeId", trigger.triggerTypeId());
@@ -149,23 +137,7 @@ QVariantMap packTrigger(const Trigger &trigger)
     return variant;
 }
 
-QString actionTypeRef()
+QVariantMap JsonTypes::packActionType(const ActionType &actionType)
-{
-    return "$ref:ActionType";
-}
-
-QVariantMap actionTypeDescription()
-{
-    QVariantMap actionTypeDescription;
-    actionTypeDescription.insert("id", "uuid");
-    actionTypeDescription.insert("name", "string");
-    QVariantList params;
-    params.append(paramTypeRef());
-    actionTypeDescription.insert("params", params);
-    return actionTypeDescription;
-}
-
-QVariantMap packActionType(const ActionType &actionType)
 {
     QVariantMap variantMap;
     variantMap.insert("id", actionType.id());
@@ -174,23 +146,7 @@ QVariantMap packActionType(const ActionType &actionType)
     return variantMap;
 }
 
-QString actionRef()
+QVariantMap JsonTypes::packAction(const Action &action)
-{
-    return "$ref:Action";
-}
-
-QVariantMap actionDescription()
-{
-    QVariantMap actionDescription;
-    actionDescription.insert("actionTypeId", "uuid");
-    actionDescription.insert("deviceId", "uuid");
-    QVariantList params;
-    params.append(paramRef());
-    actionDescription.insert("params", params);
-    return actionDescription;
-}
-
-QVariantMap packAction(const Action &action)
 {
     QVariantMap variant;
     variant.insert("actionTypeId", action.actionTypeId());
@@ -199,32 +155,7 @@ QVariantMap packAction(const Action &action)
     return variant;
 }
 
-QString deviceClassRef()
+QVariantMap JsonTypes::packDeviceClass(const DeviceClass &deviceClass)
-{
-    return "$ref:DeviceClass";
-}
-
-QVariantMap deviceClassDescription()
-{
-    QVariantMap deviceClass;
-    deviceClass.insert("id", "uuid");
-    deviceClass.insert("name", "string");
-    QVariantList states;
-    states.append(stateTypeRef());
-    deviceClass.insert("states", states);
-    QVariantList triggers;
-    triggers.append(triggerTypeRef());
-    deviceClass.insert("triggers", triggers);
-    QVariantList actions;
-    actions.append(actionTypeRef());
-    deviceClass.insert("actions", actions);
-    QVariantList params;
-    params.append(paramTypeRef());
-    deviceClass.insert("params", params);
-    return deviceClass;
-}
-
-QVariantMap packDeviceClass(const DeviceClass &deviceClass)
 {
     QVariantMap variant;
     variant.insert("name", deviceClass.name());
@@ -263,45 +194,12 @@ QVariantMap packDeviceClass(const DeviceClass &deviceClass)
     return variant;
 }
 
-QString pluginTypeRef()
+QVariantMap JsonTypes::packPlugin(DevicePlugin *plugin)
-{
-    return "$ref:PluginType";
-}
-
-QVariantMap pluginTypeDescription()
-{
-    QVariantMap pluginDescription;
-    pluginDescription.insert("id", "uuid");
-    pluginDescription.insert("name", "string");
-    QVariantList params;
-    params.append(paramTypeRef());
-    pluginDescription.insert("params", params);
-    return pluginDescription;
-}
-
-QVariantMap packPlugin(DevicePlugin *plugin)
 {
 
 }
 
-QString deviceRef()
+QVariantMap JsonTypes::packDevice(Device *device)
-{
-    return "$ref:Device";
-}
-
-QVariantMap deviceDescription()
-{
-    QVariantMap deviceDescription;
-    deviceDescription.insert("id", "uuid");
-    deviceDescription.insert("deviceClassId", "uuid");
-    deviceDescription.insert("name", "string");
-    QVariantList params;
-    params.append(paramRef());
-    deviceDescription.insert("params", params);
-    return deviceDescription;
-}
-
-QVariantMap packDevice(Device *device)
 {
     QVariantMap variant;
     variant.insert("id", device->id());
@@ -311,28 +209,24 @@ QVariantMap packDevice(Device *device)
     return variant;
 }
 
-QString ruleRef()
+QVariantMap JsonTypes::packRule(const Rule &rule)
 {
-    return "$ref:Rule";
+    QVariantMap ruleMap;
-}
+    ruleMap.insert("id", rule.id());
+    ruleMap.insert("trigger", JsonTypes::packTrigger(rule.trigger()));
+    ruleMap.insert("ruleType", s_ruleTypes.at(rule.ruleType()));
+    QVariantList actionList;
+    foreach (const Action &action, rule.actions()) {
+        actionList.append(JsonTypes::packAction(action));
+    }
+    ruleMap.insert("actions", actionList);
 
-QVariantMap ruleDescription()
-{
-    QVariantMap ruleDescription;
-    ruleDescription.insert("id", "uuid");
-    ruleDescription.insert("trigger", triggerRef());
-    QVariantList actions;
-    actions.append(actionRef());
-    ruleDescription.insert("actions", actions);
     QVariantList states;
-    states.append(stateRef());
+    ruleMap.insert("states", states);
-    ruleDescription.insert("states", states);
+    return ruleMap;
-    return ruleDescription;
 }
 
-//QVariantMap packRule(const Rule &rule);
+bool JsonTypes::validateMap(const QVariantMap &templateMap, const QVariantMap &map)
-
-bool validateMap(const QVariantMap &templateMap, const QVariantMap &map)
 {
     foreach (const QString &key, templateMap.keys()) {
         if (!map.contains(key)) {
@@ -347,7 +241,7 @@ bool validateMap(const QVariantMap &templateMap, const QVariantMap &map)
     return true;
 }
 
-bool validateProperty(const QVariant &templateValue, const QVariant &value)
+bool JsonTypes::validateProperty(const QVariant &templateValue, const QVariant &value)
 {
     if (templateValue == "uuid") {
         return value.canConvert(QVariant::Uuid);
@@ -362,7 +256,7 @@ bool validateProperty(const QVariant &templateValue, const QVariant &value)
     return false;
 }
 
-bool validateList(const QVariantList &templateList, const QVariantList &list)
+bool JsonTypes::validateList(const QVariantList &templateList, const QVariantList &list)
 {
     Q_ASSERT(templateList.count() == 1);
     QVariant entryTemplate = templateList.first();
@@ -379,7 +273,7 @@ bool validateList(const QVariantList &templateList, const QVariantList &list)
     return true;
 }
 
-bool validateVariant(const QVariant &templateVariant, const QVariant &variant)
+bool JsonTypes::validateVariant(const QVariant &templateVariant, const QVariant &variant)
 {
     switch(templateVariant.type()) {
     case QVariant::String:
@@ -426,9 +320,9 @@ bool validateVariant(const QVariant &templateVariant, const QVariant &variant)
                     qDebug() << "state type not matching";
                     return false;
                 }
-            } else if (refName == pluginTypeRef()) {
+            } else if (refName == pluginRef()) {
-                if (!validateMap(pluginTypeDescription(), variant.toMap())) {
+                if (!validateMap(pluginDescription(), variant.toMap())) {
-                    qDebug() << "plugin type not matching";
+                    qDebug() << "plugin not matching";
                     return false;
                 }
             } else if (refName == ruleRef()) {
@@ -441,6 +335,11 @@ bool validateVariant(const QVariant &templateVariant, const QVariant &variant)
                     qDebug() << "value not allowed in" << basicTypesRef();
                     return false;
                 }
+            } else if (refName == ruleTypesRef()) {
+                if (!validateRuleType(variant)) {
+                    qDebug() << "value not allowed in" << ruleTypesRef();
+                    return false;
+                }
             } else {
                 qDebug() << "unhandled ref:" << refName;
                 return false;
@@ -470,7 +369,7 @@ bool validateVariant(const QVariant &templateVariant, const QVariant &variant)
     return true;
 }
 
-bool validateBasicType(const QVariant &variant)
+bool JsonTypes::validateBasicType(const QVariant &variant)
 {
     if (variant.canConvert(QVariant::Uuid)) {
         return true;
@@ -489,4 +388,8 @@ bool validateBasicType(const QVariant &variant)
     }
     return false;
 }
+
+bool JsonTypes::validateRuleType(const QVariant &variant)
+{
+    return s_ruleTypes.contains(variant.toString());
 }

server/jsonrpc/jsontypes.h

@@ -5,70 +5,78 @@
 #include "trigger.h"
 #include "action.h"
 #include "actiontype.h"
+#include "rule.h"
 
 #include <QObject>
 
 #include <QVariantMap>
+#include <QString>
 
 class DevicePlugin;
 class Device;
 
-namespace JsonTypes
+#define DECLARE_OBJECT(typeName, jsonName) \
+    public: \
+    static QString typeName##Ref() { return QStringLiteral("$ref:") + QStringLiteral(jsonName); } \
+    static QVariantMap typeName##Description() { \
+        if (!s_initialized) { init(); } \
+        return s_##typeName; \
+    } \
+    private: \
+    static QVariantMap s_##typeName; \
+    public:
+
+#define DECLARE_TYPE(typeName, jsonName) \
+    public: \
+    static QString typeName##Ref() { return QStringLiteral("$ref:") + QStringLiteral(jsonName); } \
+    static QVariantList typeName() { \
+        if (!s_initialized) { init(); } \
+        return s_##typeName; \
+    } \
+    private: \
+    static QVariantList s_##typeName; \
+    public:
+
+class JsonTypes
 {
-    QVariantMap allTypes();
+public:
+    static QVariantMap allTypes();
 
-    QString basicTypesRef();
+    DECLARE_TYPE(basicTypes, "BasicType")
-    QVariantList basicTypes();
+    DECLARE_TYPE(ruleTypes, "RuleType")
 
-    QString paramTypeRef();
+    DECLARE_OBJECT(paramType, "ParamType")
-    QVariantMap paramTypeDescription();
+    DECLARE_OBJECT(param, "Param")
+    DECLARE_OBJECT(stateType, "StateType")
+    DECLARE_OBJECT(state, "State")
+    DECLARE_OBJECT(triggerType, "TriggerType")
+    DECLARE_OBJECT(trigger, "Trigger")
+    DECLARE_OBJECT(actionType, "ActionType")
+    DECLARE_OBJECT(action, "Action")
+    DECLARE_OBJECT(plugin, "Plugin")
+    DECLARE_OBJECT(deviceClass, "DeviceClass")
+    DECLARE_OBJECT(device, "Device")
+    DECLARE_OBJECT(rule, "Rule")
 
-    QString paramRef();
+    static QVariantMap packTriggerType(const TriggerType &triggerType);
-    QVariantMap paramDescription();
+    static QVariantMap packTrigger(const Trigger &trigger);
+    static QVariantMap packActionType(const ActionType &actionType);
+    static QVariantMap packAction(const Action &action);
+    static QVariantMap packDeviceClass(const DeviceClass &deviceClass);
+    static QVariantMap packPlugin(DevicePlugin *plugin);
+    static QVariantMap packDevice(Device *device);
+    static QVariantMap packRule(const Rule &rule);
 
-    QString stateTypeRef();
+    static bool validateMap(const QVariantMap &templateMap, const QVariantMap &map);
-    QVariantMap stateTypeDescription();
+    static bool validateProperty(const QVariant &templateValue, const QVariant &value);
+    static bool validateList(const QVariantList &templateList, const QVariantList &list);
+    static bool validateVariant(const QVariant &templateVariant, const QVariant &variant);
+    static bool validateBasicType(const QVariant &variant);
+    static bool validateRuleType(const QVariant &variant);
 
-    QString stateRef();
+private:
-    QVariantMap stateDescription();
+    static bool s_initialized;
-
+    static void init();
-    QString triggerTypeRef();
+};
-    QVariantMap triggerTypeDescription();
-    QVariantMap packTriggerType(const TriggerType &triggerType);
-
-    QString triggerRef();
-    QVariantMap triggerDescription();
-    QVariantMap packTrigger(const Trigger &trigger);
-
-    QString actionTypeRef();
-    QVariantMap actionTypeDescription();
-    QVariantMap packActionType(const ActionType &actionType);
-
-    QString actionRef();
-    QVariantMap actionDescription();
-    QVariantMap packAction(const Action &action);
-
-    QString deviceClassRef();
-    QVariantMap deviceClassDescription();
-    QVariantMap packDeviceClass(const DeviceClass &deviceClass);
-
-    QString pluginTypeRef();
-    QVariantMap pluginTypeDescription();
-    QVariantMap packPlugin(DevicePlugin *plugin);
-
-    QString deviceRef();
-    QVariantMap deviceDescription();
-    QVariantMap packDevice(Device *device);
-
-    QString ruleRef();
-    QVariantMap ruleDescription();
-//    QVariantMap packRule(const Rule &rule);
-
-    bool validateMap(const QVariantMap &templateMap, const QVariantMap &map);
-    bool validateProperty(const QVariant &templateValue, const QVariant &value);
-    bool validateList(const QVariantList &templateList, const QVariantList &list);
-    bool validateVariant(const QVariant &templateVariant, const QVariant &variant);
-    bool validateBasicType(const QVariant &variant);
-}
 
 #endif // JSONTYPES_H

server/jsonrpc/ruleshandler.cpp

@@ -47,18 +47,7 @@ QVariantMap RulesHandler::GetRules(const QVariantMap &params)
     QVariantList rulesList;
     foreach (const Rule &rule, HiveCore::instance()->ruleEngine()->rules()) {
         qDebug() << "got rule" << rule.id();
-        QVariantMap ruleMap;
+        QVariantMap ruleMap = JsonTypes::packRule(rule);
-        ruleMap.insert("id", rule.id());
-        ruleMap.insert("trigger", JsonTypes::packTrigger(rule.trigger()));
-        QVariantList actionList;
-        foreach (const Action &action, rule.actions()) {
-            actionList.append(JsonTypes::packAction(action));
-        }
-        ruleMap.insert("actions", actionList);
-
-        QVariantList states;
-        ruleMap.insert("states", states);
-
         rulesList.append(ruleMap);
     }
     QVariantMap returns;