ETM-Schurig/powersync-core
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Allow registering QMetaObjects on JSON api

Browse Source
This commit is contained in:
Michael Zanetti 2019-10-25 13:13:06 +02:00
parent e2cf9cb5c3
commit bdd9876a88
64 changed files with 762 additions and 519 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
libnymea-core/devices/devicemanagerimplementation.cpp
View File

@ -865,6 +865,43 @@ QString DeviceManagerImplementation::translate(const PluginId &pluginId, const Q
return m_translator->translate(pluginId, string, locale); return m_translator->translate(pluginId, string, locale);
} }
ParamType DeviceManagerImplementation::translateParamType(const PluginId &pluginId, const ParamType &paramType, const QLocale &locale)
{
ParamType translatedParamType = paramType;
translatedParamType.setDisplayName(translate(pluginId, paramType.displayName(), locale));
return translatedParamType;
}
DeviceClass DeviceManagerImplementation::translateDeviceClass(const DeviceClass &deviceClass, const QLocale &locale)
{
DeviceClass translatedDeviceClass = deviceClass;
translatedDeviceClass.setDisplayName(translate(deviceClass.pluginId(), deviceClass.displayName(), locale));
ParamTypes translatedSettingsTypes;
foreach (const ParamType &paramType, deviceClass.settingsTypes()) {
translatedSettingsTypes.append(translateParamType(deviceClass.pluginId(), paramType, locale));
}
translatedDeviceClass.setSettingsTypes(translatedSettingsTypes);
return translatedDeviceClass;
}
Vendor DeviceManagerImplementation::translateVendor(const Vendor &vendor, const QLocale &locale)
{
DevicePlugin *plugin = nullptr;
foreach (DevicePlugin *p, m_devicePlugins) {
if (p->supportedVendors().contains(vendor)) {
plugin = p;
}
}
if (!plugin) {
return vendor;
}
Vendor translatedVendor = vendor;
translatedVendor.setDisplayName(translate(plugin->pluginId(), vendor.displayName(), locale));
return translatedVendor;
}
/*! Returns the \l{Device} with the given \a id. Null if the id couldn't be found. */ /*! Returns the \l{Device} with the given \a id. Null if the id couldn't be found. */
Device *DeviceManagerImplementation::findConfiguredDevice(const DeviceId &id) const Device *DeviceManagerImplementation::findConfiguredDevice(const DeviceId &id) const
{ {

3
libnymea-core/devices/devicemanagerimplementation.h
View File

@ -107,6 +107,9 @@ public:
BrowserItemActionInfo *executeBrowserItemAction(const BrowserItemAction &browserItemAction) override; BrowserItemActionInfo *executeBrowserItemAction(const BrowserItemAction &browserItemAction) override;
QString translate(const PluginId &pluginId, const QString &string, const QLocale &locale) override; QString translate(const PluginId &pluginId, const QString &string, const QLocale &locale) override;
ParamType translateParamType(const PluginId &pluginId, const ParamType &paramType, const QLocale &locale) override;
DeviceClass translateDeviceClass(const DeviceClass &deviceClass, const QLocale &locale) override;
Vendor translateVendor(const Vendor &vendor, const QLocale &locale) override;
signals: signals:
void loaded(); void loaded();

20
libnymea-core/jsonrpc/actionhandler.cpp
View File

@ -41,6 +41,7 @@
#include "devices/browseractioninfo.h" #include "devices/browseractioninfo.h"
#include "devices/browseritemactioninfo.h" #include "devices/browseritemactioninfo.h"
#include "types/action.h" #include "types/action.h"
#include "types/actiontype.h"
#include "loggingcategories.h" #include "loggingcategories.h"
namespace nymeaserver { namespace nymeaserver {
@ -49,12 +50,15 @@ namespace nymeaserver {
ActionHandler::ActionHandler(QObject *parent) : ActionHandler::ActionHandler(QObject *parent) :
JsonHandler(parent) JsonHandler(parent)
{ {
// Enums
registerEnum<Types::InputType>();
registerEnum<Types::Unit>();
// Objects // Objects
QVariantMap action; registerObject<ParamType, ParamTypes>();
action.insert("actionTypeId", enumValueName(Uuid)); registerObject<Param, ParamList>();
action.insert("deviceId", enumValueName(Uuid)); registerObject<ActionType>();
action.insert("o:params", QVariantList() << objectRef("Param")); registerObject<Action>();
registerObject("Action", action);
// Methods // Methods
QString description; QVariantMap params; QVariantMap returns; QString description; QVariantMap params; QVariantMap returns;
@ -125,14 +129,18 @@ JsonReply* ActionHandler::ExecuteAction(const QVariantMap &params)
JsonReply *ActionHandler::GetActionType(const QVariantMap &params) const JsonReply *ActionHandler::GetActionType(const QVariantMap &params) const
{ {
QLocale locale = params.value("locale").toLocale();
qCDebug(dcJsonRpc) << "asked for action type" << params; qCDebug(dcJsonRpc) << "asked for action type" << params;
ActionTypeId actionTypeId(params.value("actionTypeId").toString()); ActionTypeId actionTypeId(params.value("actionTypeId").toString());
foreach (const DeviceClass &deviceClass, NymeaCore::instance()->deviceManager()->supportedDevices()) { foreach (const DeviceClass &deviceClass, NymeaCore::instance()->deviceManager()->supportedDevices()) {
foreach (const ActionType &actionType, deviceClass.actionTypes()) { foreach (const ActionType &actionType, deviceClass.actionTypes()) {
if (actionType.id() == actionTypeId) { if (actionType.id() == actionTypeId) {
ActionType translatedActionType = actionType;
translatedActionType.setDisplayName(NymeaCore::instance()->deviceManager()->translate(deviceClass.pluginId(), actionType.displayName(), locale));
QVariantMap data; QVariantMap data;
data.insert("deviceError", enumValueName<Device::DeviceError>(Device::DeviceErrorNoError)); data.insert("deviceError", enumValueName<Device::DeviceError>(Device::DeviceErrorNoError));
data.insert("actionType", DeviceHandler::packActionType(actionType, deviceClass.pluginId(), params.value("locale").toLocale())); data.insert("actionType", pack(translatedActionType));
return createReply(data); return createReply(data);
} }
} }

71
libnymea-core/jsonrpc/configurationhandler.cpp
View File

@ -72,25 +72,9 @@ ConfigurationHandler::ConfigurationHandler(QObject *parent):
registerEnum<NymeaConfiguration::ConfigurationError>(); registerEnum<NymeaConfiguration::ConfigurationError>();
// Objects // Objects
QVariantMap serverConfiguration; registerObject<ServerConfiguration>();
serverConfiguration.insert("id", enumValueName(String)); registerObject<WebServerConfiguration>();
serverConfiguration.insert("address", enumValueName(String)); registerObject<MqttPolicy>();
serverConfiguration.insert("port", enumValueName(Uint));
serverConfiguration.insert("sslEnabled", enumValueName(Bool));
serverConfiguration.insert("authenticationEnabled", enumValueName(Bool));
registerObject("ServerConfiguration", serverConfiguration);
QVariantMap webServerConfiguration = serverConfiguration;
webServerConfiguration.insert("publicFolder", enumValueName(String));
registerObject("WebServerConfiguration", webServerConfiguration);
QVariantMap mqttPolicy;
mqttPolicy.insert("clientId", enumValueName(String));
mqttPolicy.insert("username", enumValueName(String));
mqttPolicy.insert("password", enumValueName(String));
mqttPolicy.insert("allowedPublishTopicFilters", enumValueName(StringList));
mqttPolicy.insert("allowedSubscribeTopicFilters", enumValueName(StringList));
registerObject("MqttPolicy", mqttPolicy);
// Methods // Methods
QString description; QVariantMap params; QVariantMap returns; QString description; QVariantMap params; QVariantMap returns;
@ -327,20 +311,20 @@ JsonReply *ConfigurationHandler::GetConfigurations(const QVariantMap &params) co
returns.insert("basicConfiguration", packBasicConfiguration()); returns.insert("basicConfiguration", packBasicConfiguration());
QVariantList tcpServerConfigs; QVariantList tcpServerConfigs;
foreach (const ServerConfiguration &config, NymeaCore::instance()->configuration()->tcpServerConfigurations()) { foreach (const ServerConfiguration &config, NymeaCore::instance()->configuration()->tcpServerConfigurations()) {
tcpServerConfigs.append(packServerConfiguration(config)); tcpServerConfigs.append(pack(config));
} }
returns.insert("tcpServerConfigurations", tcpServerConfigs); returns.insert("tcpServerConfigurations", tcpServerConfigs);
QVariantList webServerConfigs; QVariantList webServerConfigs;
foreach (const WebServerConfiguration &config, NymeaCore::instance()->configuration()->webServerConfigurations()) { foreach (const WebServerConfiguration &config, NymeaCore::instance()->configuration()->webServerConfigurations()) {
webServerConfigs.append(packWebServerConfiguration(config)); webServerConfigs.append(pack(config));
} }
returns.insert("webServerConfigurations", webServerConfigs); returns.insert("webServerConfigurations", webServerConfigs);
QVariantList webSocketServerConfigs; QVariantList webSocketServerConfigs;
foreach (const ServerConfiguration &config, NymeaCore::instance()->configuration()->webSocketServerConfigurations()) { foreach (const ServerConfiguration &config, NymeaCore::instance()->configuration()->webSocketServerConfigurations()) {
webSocketServerConfigs.append(packServerConfiguration(config)); webSocketServerConfigs.append(pack(config));
} }
returns.insert("webSocketServerConfigurations", webSocketServerConfigs); returns.insert("webSocketServerConfigurations", webSocketServerConfigs);
@ -503,7 +487,7 @@ JsonReply *ConfigurationHandler::GetMqttServerConfigurations(const QVariantMap &
QVariantMap ret; QVariantMap ret;
QVariantList mqttServerConfigs; QVariantList mqttServerConfigs;
foreach (const ServerConfiguration &config, NymeaCore::instance()->configuration()->mqttServerConfigurations()) { foreach (const ServerConfiguration &config, NymeaCore::instance()->configuration()->mqttServerConfigurations()) {
mqttServerConfigs << packServerConfiguration(config); mqttServerConfigs << pack(config);
} }
ret.insert("mqttServerConfigurations", mqttServerConfigs); ret.insert("mqttServerConfigurations", mqttServerConfigs);
return createReply(ret); return createReply(ret);
@ -545,7 +529,7 @@ JsonReply *ConfigurationHandler::GetMqttPolicies(const QVariantMap &params) cons
Q_UNUSED(params) Q_UNUSED(params)
QVariantList mqttPolicies; QVariantList mqttPolicies;
foreach (const MqttPolicy &policy, NymeaCore::instance()->configuration()->mqttPolicies()) { foreach (const MqttPolicy &policy, NymeaCore::instance()->configuration()->mqttPolicies()) {
mqttPolicies << packMqttPolicy(policy); mqttPolicies << pack(policy);
} }
QVariantMap ret; QVariantMap ret;
ret.insert("mqttPolicies", mqttPolicies); ret.insert("mqttPolicies", mqttPolicies);
@ -592,7 +576,7 @@ void ConfigurationHandler::onTcpServerConfigurationChanged(const QString &id)
{ {
qCDebug(dcJsonRpc()) << "Notification: TCP server configuration changed"; qCDebug(dcJsonRpc()) << "Notification: TCP server configuration changed";
QVariantMap params; QVariantMap params;
params.insert("tcpServerConfiguration", packServerConfiguration(NymeaCore::instance()->configuration()->tcpServerConfigurations().value(id))); params.insert("tcpServerConfiguration", pack(NymeaCore::instance()->configuration()->tcpServerConfigurations().value(id)));
emit TcpServerConfigurationChanged(params); emit TcpServerConfigurationChanged(params);
} }
@ -608,7 +592,7 @@ void ConfigurationHandler::onWebServerConfigurationChanged(const QString &id)
{ {
qCDebug(dcJsonRpc()) << "Notification: web server configuration changed"; qCDebug(dcJsonRpc()) << "Notification: web server configuration changed";
QVariantMap params; QVariantMap params;
params.insert("webServerConfiguration", packWebServerConfiguration(NymeaCore::instance()->configuration()->webServerConfigurations().value(id))); params.insert("webServerConfiguration", pack(NymeaCore::instance()->configuration()->webServerConfigurations().value(id)));
emit WebServerConfigurationChanged(params); emit WebServerConfigurationChanged(params);
} }
@ -624,7 +608,7 @@ void ConfigurationHandler::onWebSocketServerConfigurationChanged(const QString &
{ {
qCDebug(dcJsonRpc()) << "Notification: web socket server configuration changed"; qCDebug(dcJsonRpc()) << "Notification: web socket server configuration changed";
QVariantMap params; QVariantMap params;
params.insert("webSocketServerConfiguration", packServerConfiguration(NymeaCore::instance()->configuration()->webSocketServerConfigurations().value(id))); params.insert("webSocketServerConfiguration", pack(NymeaCore::instance()->configuration()->webSocketServerConfigurations().value(id)));
emit WebSocketServerConfigurationChanged(params); emit WebSocketServerConfigurationChanged(params);
} }
@ -640,7 +624,7 @@ void ConfigurationHandler::onMqttServerConfigurationChanged(const QString &id)
{ {
qCDebug(dcJsonRpc()) << "Notification: MQTT server configuration changed"; qCDebug(dcJsonRpc()) << "Notification: MQTT server configuration changed";
QVariantMap params; QVariantMap params;
params.insert("mqttServerConfiguration", packServerConfiguration(NymeaCore::instance()->configuration()->mqttServerConfigurations().value(id))); params.insert("mqttServerConfiguration", pack(NymeaCore::instance()->configuration()->mqttServerConfigurations().value(id)));
emit MqttServerConfigurationChanged(params); emit MqttServerConfigurationChanged(params);
} }
@ -656,7 +640,7 @@ void ConfigurationHandler::onMqttPolicyChanged(const QString &clientId)
{ {
qCDebug(dcJsonRpc()) << "Notification: MQTT policy changed"; qCDebug(dcJsonRpc()) << "Notification: MQTT policy changed";
QVariantMap params; QVariantMap params;
params.insert("policy", packMqttPolicy(NymeaCore::instance()->configuration()->mqttPolicies().value(clientId))); params.insert("policy", pack(NymeaCore::instance()->configuration()->mqttPolicies().value(clientId)));
emit MqttPolicyChanged(params); emit MqttPolicyChanged(params);
} }
@ -680,34 +664,6 @@ QVariantMap ConfigurationHandler::packBasicConfiguration()
return basicConfiguration; return basicConfiguration;
} }
QVariantMap ConfigurationHandler::packServerConfiguration(const ServerConfiguration &config)
{
QVariantMap serverConfiguration;
serverConfiguration.insert("id", config.id);
serverConfiguration.insert("address", config.address.toString());
serverConfiguration.insert("port", config.port);
serverConfiguration.insert("sslEnabled", config.sslEnabled);
serverConfiguration.insert("authenticationEnabled", config.authenticationEnabled);
return serverConfiguration;
}
QVariantMap ConfigurationHandler::packWebServerConfiguration(const WebServerConfiguration &config)
{
QVariantMap webServerConfiguration = packServerConfiguration(config);
webServerConfiguration.insert("publicFolder", config.publicFolder);
return webServerConfiguration;
}
QVariantMap ConfigurationHandler::packMqttPolicy(const MqttPolicy &policy)
{
QVariantMap policyMap;
policyMap.insert("clientId", policy.clientId);
policyMap.insert("username", policy.username);
policyMap.insert("password", policy.password);
policyMap.insert("allowedPublishTopicFilters", policy.allowedPublishTopicFilters);
policyMap.insert("allowedSubscribeTopicFilters", policy.allowedSubscribeTopicFilters);
return policyMap;
}
MqttPolicy ConfigurationHandler::unpackMqttPolicy(const QVariantMap &mqttPolicyMap) MqttPolicy ConfigurationHandler::unpackMqttPolicy(const QVariantMap &mqttPolicyMap)
{ {
@ -741,6 +697,7 @@ WebServerConfiguration ConfigurationHandler::unpackWebServerConfiguration(const
webServerConfiguration.sslEnabled = tmp.sslEnabled; webServerConfiguration.sslEnabled = tmp.sslEnabled;
webServerConfiguration.authenticationEnabled = tmp.authenticationEnabled; webServerConfiguration.authenticationEnabled = tmp.authenticationEnabled;
webServerConfiguration.publicFolder = webServerConfigurationMap.value("publicFolder").toString(); webServerConfiguration.publicFolder = webServerConfigurationMap.value("publicFolder").toString();
qWarning() << "Unpacking web server config:" << webServerConfigurationMap;
return webServerConfiguration; return webServerConfiguration;
} }

3
libnymea-core/jsonrpc/configurationhandler.h
View File

@ -92,9 +92,6 @@ private slots:
private: private:
static QVariantMap packBasicConfiguration(); static QVariantMap packBasicConfiguration();
static QVariantMap packServerConfiguration(const ServerConfiguration &config);
static QVariantMap packWebServerConfiguration(const WebServerConfiguration &config);
static QVariantMap packMqttPolicy(const MqttPolicy &policy);
static ServerConfiguration unpackServerConfiguration(const QVariantMap &serverConfigurationMap); static ServerConfiguration unpackServerConfiguration(const QVariantMap &serverConfigurationMap);
static WebServerConfiguration unpackWebServerConfiguration(const QVariantMap &webServerConfigurationMap); static WebServerConfiguration unpackWebServerConfiguration(const QVariantMap &webServerConfigurationMap);

320
libnymea-core/jsonrpc/devicehandler.cpp
View File

@ -80,7 +80,7 @@ DeviceHandler::DeviceHandler(QObject *parent) :
// Enums // Enums
registerEnum<Device::DeviceError>(); registerEnum<Device::DeviceError>();
registerEnum<DeviceClass::SetupMethod>(); registerEnum<DeviceClass::SetupMethod>();
registerEnum<DeviceClass::CreateMethod>(); registerEnum<DeviceClass::CreateMethod, DeviceClass::CreateMethods>();
registerEnum<Types::Unit>(); registerEnum<Types::Unit>();
registerEnum<Types::InputType>(); registerEnum<Types::InputType>();
registerEnum<RuleEngine::RemovePolicy>(); registerEnum<RuleEngine::RemovePolicy>();
@ -88,109 +88,20 @@ DeviceHandler::DeviceHandler(QObject *parent) :
registerEnum<MediaBrowserItem::MediaBrowserIcon>(); registerEnum<MediaBrowserItem::MediaBrowserIcon>();
// Objects // Objects
QVariantMap paramType; registerObject<ParamType, ParamTypes>();
paramType.insert("id", enumValueName(Uuid)); registerObject<Param, ParamList>();
paramType.insert("name", enumValueName(String)); registerObject<DevicePlugin>();
paramType.insert("displayName", enumValueName(String)); registerObject<Vendor>();
paramType.insert("type", enumRef<BasicType>()); registerObject<EventType, EventTypes>();
paramType.insert("index", enumValueName(Int)); registerObject<StateType, StateTypes>();
paramType.insert("o:defaultValue", enumValueName(Variant)); registerObject<ActionType, ActionTypes>();
paramType.insert("o:minValue", enumValueName(Variant)); registerObject<DeviceClass>();
paramType.insert("o:maxValue", enumValueName(Variant)); registerObject<DeviceDescriptor>();
paramType.insert("o:allowedValues", QVariantList() << enumValueName(Variant)); registerObject<State, States>();
paramType.insert("o:inputType", enumRef<Types::InputType>()); registerObject<Device>();
paramType.insert("o:unit", enumRef<Types::Unit>());
paramType.insert("o:readOnly", enumValueName(Bool));
registerObject("ParamType", paramType);
QVariantMap param;
param.insert("paramTypeId", enumValueName(Uuid));
param.insert("value", enumValueName(Variant));
registerObject("Param", param);
QVariantMap plugin;
plugin.insert("id", enumValueName(Uuid));
plugin.insert("name", enumValueName(String));
plugin.insert("displayName", enumValueName(String));
plugin.insert("paramTypes", QVariantList() << objectRef("ParamType"));
registerObject("Plugin", plugin);
QVariantMap vendor;
vendor.insert("id", enumValueName(Uuid));
vendor.insert("name", enumValueName(String));
vendor.insert("displayName", enumValueName(String));
registerObject("Vendor", vendor);
QVariantMap eventType;
eventType.insert("id", enumValueName(Uuid));
eventType.insert("name", enumValueName(String));
eventType.insert("displayName", enumValueName(String));
eventType.insert("index", enumValueName(Int));
eventType.insert("paramTypes", QVariantList() << objectRef("ParamType"));
registerObject("EventType", eventType);
QVariantMap stateType;
stateType.insert("id", enumValueName(Uuid));
stateType.insert("name", enumValueName(String));
stateType.insert("displayName", enumValueName(String));
stateType.insert("type", enumRef<BasicType>());
stateType.insert("index", enumValueName(Int));
stateType.insert("defaultValue", enumValueName(Variant));
stateType.insert("o:unit", enumRef<Types::Unit>());
stateType.insert("o:minValue", enumValueName(Variant));
stateType.insert("o:maxValue", enumValueName(Variant));
stateType.insert("o:possibleValues", QVariantList() << enumValueName(Variant));
registerObject("StateType", stateType);
QVariantMap actionType;
actionType.insert("id", enumValueName(Uuid));
actionType.insert("name", enumValueName(String));
actionType.insert("displayName", enumValueName(String));
actionType.insert("index", enumValueName(Int));
actionType.insert("paramTypes", QVariantList() << objectRef("ParamType"));
registerObject("ActionType", actionType);
QVariantMap deviceClass;
deviceClass.insert("id", enumValueName(Uuid));
deviceClass.insert("vendorId", enumValueName(Uuid));
deviceClass.insert("pluginId", enumValueName(Uuid));
deviceClass.insert("name", enumValueName(String));
deviceClass.insert("displayName", enumValueName(String));
deviceClass.insert("interfaces", QVariantList() << enumValueName(String));
deviceClass.insert("browsable", enumValueName(Bool));
deviceClass.insert("setupMethod", enumRef<DeviceClass::SetupMethod>());
deviceClass.insert("createMethods", QVariantList() << enumRef<DeviceClass::CreateMethod>());
deviceClass.insert("stateTypes", QVariantList() << objectRef("StateType"));
deviceClass.insert("eventTypes", QVariantList() << objectRef("EventType"));
deviceClass.insert("actionTypes", QVariantList() << objectRef("ActionType"));
deviceClass.insert("browserItemActionTypes", QVariantList() << objectRef("ActionType"));
deviceClass.insert("paramTypes", QVariantList() << objectRef("ParamType"));
deviceClass.insert("settingsTypes", QVariantList() << objectRef("ParamType"));
deviceClass.insert("discoveryParamTypes", QVariantList() << objectRef("ParamType"));
registerObject("DeviceClass", deviceClass);
QVariantMap deviceDescriptor;
deviceDescriptor.insert("id", enumValueName(Uuid));
deviceDescriptor.insert("deviceId", enumValueName(Uuid));
deviceDescriptor.insert("title", enumValueName(String));
deviceDescriptor.insert("description", enumValueName(String));
deviceDescriptor.insert("deviceParams", QVariantList() << objectRef("Param"));
registerObject("DeviceDescriptor", deviceDescriptor);
QVariantMap device;
device.insert("id", enumValueName(Uuid));
device.insert("deviceClassId", enumValueName(Uuid));
device.insert("name", enumValueName(String));
device.insert("params", QVariantList() << objectRef("Param"));
device.insert("settings", QVariantList() << objectRef("Param"));
QVariantMap stateValues;
stateValues.insert("stateTypeId", enumValueName(Uuid));
stateValues.insert("value", enumValueName(Variant));
device.insert("states", QVariantList() << stateValues);
device.insert("setupComplete", enumValueName(Bool));
device.insert("o:parentId", enumValueName(Uuid));
registerObject("Device", device);
// Regsitering browseritem manually for now. Not sure how to deal with the
// polymorphism in int (e.g MediaBrowserItem)
QVariantMap browserItem; QVariantMap browserItem;
browserItem.insert("id", enumValueName(String)); browserItem.insert("id", enumValueName(String));
browserItem.insert("displayName", enumValueName(String)); browserItem.insert("displayName", enumValueName(String));
@ -219,7 +130,7 @@ DeviceHandler::DeviceHandler(QObject *parent) :
params.clear(); returns.clear(); params.clear(); returns.clear();
description = "Returns a list of loaded plugins."; description = "Returns a list of loaded plugins.";
returns.insert("plugins", QVariantList() << objectRef("Plugin")); returns.insert("plugins", QVariantList() << objectRef("DevicePlugin"));
registerMethod("GetPlugins", description, params, returns); registerMethod("GetPlugins", description, params, returns);
params.clear(); returns.clear(); params.clear(); returns.clear();
@ -467,18 +378,8 @@ JsonReply* DeviceHandler::GetSupportedVendors(const QVariantMap &params) const
QVariantList vendors; QVariantList vendors;
foreach (const Vendor &vendor, NymeaCore::instance()->deviceManager()->supportedVendors()) { foreach (const Vendor &vendor, NymeaCore::instance()->deviceManager()->supportedVendors()) {
Vendor translatedVendor = NymeaCore::instance()->deviceManager()->translateVendor(vendor, locale);
DevicePlugin *plugin = nullptr; vendors.append(pack(translatedVendor));
foreach (DevicePlugin *p, NymeaCore::instance()->deviceManager()->plugins()) {
if (p->supportedVendors().contains(vendor)) {
plugin = p;
}
}
QVariantMap variantMap;
variantMap.insert("id", vendor.id().toString());
variantMap.insert("name", vendor.name());
variantMap.insert("displayName", NymeaCore::instance()->deviceManager()->translate(plugin->pluginId(), vendor.displayName(), locale));
vendors.append(variantMap);
} }
QVariantMap returns; QVariantMap returns;
@ -492,8 +393,10 @@ JsonReply* DeviceHandler::GetSupportedDevices(const QVariantMap &params) const
VendorId vendorId = VendorId(params.value("vendorId").toString()); VendorId vendorId = VendorId(params.value("vendorId").toString());
QVariantMap returns; QVariantMap returns;
QVariantList deviceClasses; QVariantList deviceClasses;
foreach (const DeviceClass &deviceClass, NymeaCore::instance()->deviceManager()->supportedDevices(vendorId)) foreach (const DeviceClass &deviceClass, NymeaCore::instance()->deviceManager()->supportedDevices(vendorId)) {
deviceClasses.append(packDeviceClass(deviceClass, locale)); DeviceClass translatedDeviceClass = NymeaCore::instance()->deviceManager()->translateDeviceClass(deviceClass, locale);
deviceClasses.append(pack(translatedDeviceClass));
}
returns.insert("deviceClasses", deviceClasses); returns.insert("deviceClasses", deviceClasses);
return createReply(returns); return createReply(returns);
@ -511,14 +414,14 @@ JsonReply *DeviceHandler::GetDiscoveredDevices(const QVariantMap &params) const
JsonReply *reply = createAsyncReply("GetDiscoveredDevices"); JsonReply *reply = createAsyncReply("GetDiscoveredDevices");
DeviceDiscoveryInfo *info = NymeaCore::instance()->deviceManager()->discoverDevices(deviceClassId, discoveryParams); DeviceDiscoveryInfo *info = NymeaCore::instance()->deviceManager()->discoverDevices(deviceClassId, discoveryParams);
connect(info, &DeviceDiscoveryInfo::finished, reply, [reply, info, locale](){ connect(info, &DeviceDiscoveryInfo::finished, reply, [this, reply, info, locale](){
QVariantMap returns; QVariantMap returns;
returns.insert("deviceError", enumValueName<Device::DeviceError>(info->status())); returns.insert("deviceError", enumValueName<Device::DeviceError>(info->status()));
if (info->status() == Device::DeviceErrorNoError) { if (info->status() == Device::DeviceErrorNoError) {
QVariantList deviceDescriptorList; QVariantList deviceDescriptorList;
foreach (const DeviceDescriptor &deviceDescriptor, info->deviceDescriptors()) { foreach (const DeviceDescriptor &deviceDescriptor, info->deviceDescriptors()) {
deviceDescriptorList.append(packDeviceDescriptor(deviceDescriptor)); deviceDescriptorList.append(pack(deviceDescriptor));
} }
returns.insert("deviceDescriptors", deviceDescriptorList); returns.insert("deviceDescriptors", deviceDescriptorList);
} }
@ -540,7 +443,9 @@ JsonReply* DeviceHandler::GetPlugins(const QVariantMap &params) const
QVariantList plugins; QVariantList plugins;
foreach (DevicePlugin* plugin, NymeaCore::instance()->deviceManager()->plugins()) { foreach (DevicePlugin* plugin, NymeaCore::instance()->deviceManager()->plugins()) {
plugins.append(packPlugin(plugin, locale)); QVariantMap packedPlugin = pack(*plugin);
packedPlugin["displayName"] = NymeaCore::instance()->deviceManager()->translate(plugin->pluginId(), plugin->pluginDisplayName(), locale);
plugins.append(packedPlugin);
} }
QVariantMap returns; QVariantMap returns;
@ -560,7 +465,7 @@ JsonReply *DeviceHandler::GetPluginConfiguration(const QVariantMap &params) cons
QVariantList paramVariantList; QVariantList paramVariantList;
foreach (const Param &param, plugin->configuration()) { foreach (const Param &param, plugin->configuration()) {
paramVariantList.append(packParam(param)); paramVariantList.append(pack(param));
} }
returns.insert("configuration", paramVariantList); returns.insert("configuration", paramVariantList);
returns.insert("deviceError", enumValueName<Device::DeviceError>(Device::DeviceErrorNoError)); returns.insert("deviceError", enumValueName<Device::DeviceError>(Device::DeviceErrorNoError));
@ -820,12 +725,15 @@ JsonReply* DeviceHandler::GetActionTypes(const QVariantMap &params) const
JsonReply* DeviceHandler::GetStateTypes(const QVariantMap &params) const JsonReply* DeviceHandler::GetStateTypes(const QVariantMap &params) const
{ {
QLocale locale = params.value("locale").toLocale();
QVariantMap returns; QVariantMap returns;
QVariantList stateList; QVariantList stateList;
DeviceClass deviceClass = NymeaCore::instance()->deviceManager()->findDeviceClass(DeviceClassId(params.value("deviceClassId").toString())); DeviceClass deviceClass = NymeaCore::instance()->deviceManager()->findDeviceClass(DeviceClassId(params.value("deviceClassId").toString()));
foreach (const StateType &stateType, deviceClass.stateTypes()) { foreach (StateType stateType, deviceClass.stateTypes()) {
stateList.append(packStateType(stateType, deviceClass.pluginId(), NymeaCore::instance()->configuration()->locale())); stateType.setDisplayName(NymeaCore::instance()->deviceManager()->translate(deviceClass.pluginId(), stateType.displayName(), locale));
stateList.append(pack(stateType));
} }
returns.insert("stateTypes", stateList); returns.insert("stateTypes", stateList);
return createReply(returns); return createReply(returns);
@ -908,7 +816,7 @@ Param DeviceHandler::unpackParam(const QVariantMap &param)
if (param.keys().count() == 0) if (param.keys().count() == 0)
return Param(); return Param();
ParamTypeId paramTypeId = param.value("paramTypeId").toString(); ParamTypeId paramTypeId = param.value("paramTypeId").toUuid();
QVariant value = param.value("value"); QVariant value = param.value("value");
return Param(paramTypeId, value); return Param(paramTypeId, value);
} }
@ -992,56 +900,14 @@ QVariantMap DeviceHandler::packBrowserItem(const BrowserItem &item)
return ret; return ret;
} }
QVariantMap DeviceHandler::packParamType(const ParamType &paramType, const PluginId &pluginId, const QLocale &locale) QVariantMap DeviceHandler::packParamType(const ParamType &paramType, const PluginId &pluginId, const QLocale &locale) const
{ {
QVariantMap variantMap; ParamType translatedParamType = paramType;
variantMap.insert("id", paramType.id().toString()); translatedParamType.setDisplayName(NymeaCore::instance()->deviceManager()->translate(pluginId, paramType.displayName(), locale));
variantMap.insert("name", paramType.name()); return pack(translatedParamType);
variantMap.insert("displayName", NymeaCore::instance()->deviceManager()->translate(pluginId, paramType.displayName(), locale));
variantMap.insert("type", enumValueName<BasicType>(variantTypeToBasicType(paramType.type())));
variantMap.insert("index", paramType.index());
// Optional values
if (paramType.defaultValue().isValid())
variantMap.insert("defaultValue", paramType.defaultValue());
if (paramType.minValue().isValid())
variantMap.insert("minValue", paramType.minValue());
if (paramType.maxValue().isValid())
variantMap.insert("maxValue", paramType.maxValue());
if (!paramType.allowedValues().isEmpty())
variantMap.insert("allowedValues", paramType.allowedValues());
if (paramType.inputType() != Types::InputTypeNone)
variantMap.insert("inputType", enumValueName<Types::InputType>(paramType.inputType()));
if (paramType.unit() != Types::UnitNone)
variantMap.insert("unit", enumValueName<Types::Unit>(paramType.unit()));
if (paramType.readOnly())
variantMap.insert("readOnly", paramType.readOnly());
return variantMap;
} }
QVariantMap DeviceHandler::packPlugin(DevicePlugin *plugin, const QLocale &locale) QVariantMap DeviceHandler::packEventType(const EventType &eventType, const PluginId &pluginId, const QLocale &locale) const
{
QVariantMap pluginMap;
pluginMap.insert("id", plugin->pluginId().toString());
pluginMap.insert("name", plugin->pluginName());
pluginMap.insert("displayName", NymeaCore::instance()->deviceManager()->translate(plugin->pluginId(), plugin->pluginDisplayName(), locale));
QVariantList params;
foreach (const ParamType &param, plugin->configurationDescription())
params.append(packParamType(param, plugin->pluginId(), locale));
pluginMap.insert("paramTypes", params);
return pluginMap;
}
QVariantMap DeviceHandler::packEventType(const EventType &eventType, const PluginId &pluginId, const QLocale &locale)
{ {
QVariantMap variant; QVariantMap variant;
variant.insert("id", eventType.id().toString()); variant.insert("id", eventType.id().toString());
@ -1057,23 +923,7 @@ QVariantMap DeviceHandler::packEventType(const EventType &eventType, const Plugi
return variant; return variant;
} }
QVariantMap DeviceHandler::packVendor(const Vendor &vendor, const QLocale &locale) QVariantMap DeviceHandler::packActionType(const ActionType &actionType, const PluginId &pluginId, const QLocale &locale) const
{
DevicePlugin *plugin = nullptr;
foreach (DevicePlugin *p, NymeaCore::instance()->deviceManager()->plugins()) {
if (p->supportedVendors().contains(vendor)) {
plugin = p;
}
}
QVariantMap variantMap;
variantMap.insert("id", vendor.id().toString());
variantMap.insert("name", vendor.name());
variantMap.insert("displayName", NymeaCore::instance()->deviceManager()->translate(plugin->pluginId(), vendor.displayName(), locale));
return variantMap;
}
QVariantMap DeviceHandler::packActionType(const ActionType &actionType, const PluginId &pluginId, const QLocale &locale)
{ {
QVariantMap variantMap; QVariantMap variantMap;
variantMap.insert("id", actionType.id().toString()); variantMap.insert("id", actionType.id().toString());
@ -1088,7 +938,7 @@ QVariantMap DeviceHandler::packActionType(const ActionType &actionType, const Pl
return variantMap; return variantMap;
} }
QVariantList DeviceHandler::packCreateMethods(DeviceClass::CreateMethods createMethods) QVariantList DeviceHandler::packCreateMethods(DeviceClass::CreateMethods createMethods) const
{ {
QVariantList ret; QVariantList ret;
if (createMethods.testFlag(DeviceClass::CreateMethodUser)) if (createMethods.testFlag(DeviceClass::CreateMethodUser))
@ -1103,96 +953,6 @@ QVariantList DeviceHandler::packCreateMethods(DeviceClass::CreateMethods createM
return ret; return ret;
} }
QVariantMap DeviceHandler::packDeviceClass(const DeviceClass &deviceClass, const QLocale &locale)
{
QVariantMap variant;
variant.insert("id", deviceClass.id().toString());
variant.insert("name", deviceClass.name());
variant.insert("displayName", NymeaCore::instance()->deviceManager()->translate(deviceClass.pluginId(), deviceClass.displayName(), locale));
variant.insert("vendorId", deviceClass.vendorId().toString());
variant.insert("pluginId", deviceClass.pluginId().toString());
variant.insert("interfaces", deviceClass.interfaces());
variant.insert("browsable", deviceClass.browsable());
QVariantList stateTypes;
foreach (const StateType &stateType, deviceClass.stateTypes())
stateTypes.append(packStateType(stateType, deviceClass.pluginId(), locale));
QVariantList eventTypes;
foreach (const EventType &eventType, deviceClass.eventTypes())
eventTypes.append(packEventType(eventType, deviceClass.pluginId(), locale));
QVariantList actionTypes;
foreach (const ActionType &actionType, deviceClass.actionTypes())
actionTypes.append(packActionType(actionType, deviceClass.pluginId(), locale));
QVariantList browserItemActionTypes;
foreach (const ActionType &actionType, deviceClass.browserItemActionTypes())
browserItemActionTypes.append(packActionType(actionType, deviceClass.pluginId(), locale));
QVariantList paramTypes;
foreach (const ParamType &paramType, deviceClass.paramTypes())
paramTypes.append(packParamType(paramType, deviceClass.pluginId(), locale));
QVariantList settingsTypes;
foreach (const ParamType &settingsType, deviceClass.settingsTypes())
settingsTypes.append(packParamType(settingsType, deviceClass.pluginId(), locale));
QVariantList discoveryParamTypes;
foreach (const ParamType &paramType, deviceClass.discoveryParamTypes())
discoveryParamTypes.append(packParamType(paramType, deviceClass.pluginId(), locale));
variant.insert("paramTypes", paramTypes);
variant.insert("settingsTypes", settingsTypes);
variant.insert("discoveryParamTypes", discoveryParamTypes);
variant.insert("stateTypes", stateTypes);
variant.insert("eventTypes", eventTypes);
variant.insert("actionTypes", actionTypes);
variant.insert("browserItemActionTypes", browserItemActionTypes);
variant.insert("createMethods", packCreateMethods(deviceClass.createMethods()));
variant.insert("setupMethod", enumValueName<DeviceClass::SetupMethod>(deviceClass.setupMethod()));
return variant;
}
QVariantMap DeviceHandler::packDeviceDescriptor(const DeviceDescriptor &descriptor)
{
QVariantMap variant;
variant.insert("id", descriptor.id().toString());
variant.insert("deviceId", descriptor.deviceId().toString());
variant.insert("title", descriptor.title());
variant.insert("description", descriptor.description());
QVariantList params;
foreach (const Param &param, descriptor.params()) {
params.append(packParam(param));
}
variant.insert("deviceParams", params);
return variant;
}
QVariantMap DeviceHandler::packStateType(const StateType &stateType, const PluginId &pluginId, const QLocale &locale)
{
QVariantMap variantMap;
variantMap.insert("id", stateType.id().toString());
variantMap.insert("name", stateType.name());
variantMap.insert("displayName", NymeaCore::instance()->deviceManager()->translate(pluginId, stateType.displayName(), locale));
variantMap.insert("index", stateType.index());
variantMap.insert("type", enumValueName(variantTypeToBasicType(stateType.type())));
variantMap.insert("defaultValue", stateType.defaultValue());
if (stateType.maxValue().isValid())
variantMap.insert("maxValue", stateType.maxValue());
if (stateType.minValue().isValid())
variantMap.insert("minValue", stateType.minValue());
if (!stateType.possibleValues().isEmpty())
variantMap.insert("possibleValues", stateType.possibleValues());
if(stateType.unit() != Types::UnitNone)
variantMap.insert("unit", enumValueName<Types::Unit>(stateType.unit()));
return variantMap;
}
void DeviceHandler::pluginConfigChanged(const PluginId &id, const ParamList &config) void DeviceHandler::pluginConfigChanged(const PluginId &id, const ParamList &config)
{ {

17
libnymea-core/jsonrpc/devicehandler.h
View File

@ -60,15 +60,14 @@ public:
Q_INVOKABLE JsonReply *BrowseDevice(const QVariantMap &params) const; Q_INVOKABLE JsonReply *BrowseDevice(const QVariantMap &params) const;
Q_INVOKABLE JsonReply *GetBrowserItem(const QVariantMap &params) const; Q_INVOKABLE JsonReply *GetBrowserItem(const QVariantMap &params) const;
static QVariantMap packParamType(const ParamType &paramType, const PluginId &pluginId, const QLocale &locale); QVariantMap packParamType(const ParamType &paramType, const PluginId &pluginId, const QLocale &locale) const;
static QVariantMap packPlugin(DevicePlugin *plugin, const QLocale &locale); // QVariantMap packPlugin(DevicePlugin *plugin, const QLocale &locale) const;
static QVariantMap packVendor(const Vendor &vendor, const QLocale &locale); QVariantMap packEventType(const EventType &eventType, const PluginId &pluginId, const QLocale &locale) const;
static QVariantMap packEventType(const EventType &eventType, const PluginId &pluginId, const QLocale &locale); // QVariantMap packStateType(const StateType &stateType, const PluginId &pluginId, const QLocale &locale) const;
static QVariantMap packStateType(const StateType &stateType, const PluginId &pluginId, const QLocale &locale); QVariantMap packActionType(const ActionType &actionType, const PluginId &pluginId, const QLocale &locale) const;
static QVariantMap packActionType(const ActionType &actionType, const PluginId &pluginId, const QLocale &locale); QVariantList packCreateMethods(DeviceClass::CreateMethods createMethods) const;
static QVariantList packCreateMethods(DeviceClass::CreateMethods createMethods); // QVariantMap packDeviceClass(const DeviceClass &deviceClass, const QLocale &locale) const;
static QVariantMap packDeviceClass(const DeviceClass &deviceClass, const QLocale &locale); QVariantMap packDeviceDescriptor(const DeviceDescriptor &descriptor) const;
static QVariantMap packDeviceDescriptor(const DeviceDescriptor &descriptor);
static QVariantMap packParam(const Param &param); static QVariantMap packParam(const Param &param);
static QVariantList packParams(const ParamList &paramList); static QVariantList packParams(const ParamList &paramList);

27
libnymea-core/jsonrpc/eventhandler.cpp
View File

@ -48,12 +48,12 @@ namespace nymeaserver {
EventHandler::EventHandler(QObject *parent) : EventHandler::EventHandler(QObject *parent) :
JsonHandler(parent) JsonHandler(parent)
{ {
registerEnum<Types::InputType>();
registerEnum<Types::Unit>();
// Objects // Objects
QVariantMap event; registerObject<Param, ParamList>();
event.insert("eventTypeId", enumValueName(Uuid)); registerObject<Event>();
event.insert("deviceId", enumValueName(Uuid)); registerObject<ParamType, ParamTypes>();
event.insert("o:params", QVariantList() << objectRef("Param"));
registerObject("Event", event);
// Methods // Methods
QString description; QVariantMap params; QVariantMap returns; QString description; QVariantMap params; QVariantMap returns;
@ -80,30 +80,23 @@ QString EventHandler::name() const
void EventHandler::eventTriggered(const Event &event) void EventHandler::eventTriggered(const Event &event)
{ {
QVariantMap params; QVariantMap params;
params.insert("event", pack(event));
QVariantMap variant;
variant.insert("eventTypeId", event.eventTypeId().toString());
variant.insert("deviceId", event.deviceId().toString());
QVariantList eventParams;
foreach (const Param &param, event.params()) {
eventParams.append(DeviceHandler::packParam(param));
}
variant.insert("params", eventParams);
params.insert("event", variant);
emit EventTriggered(params); emit EventTriggered(params);
} }
JsonReply* EventHandler::GetEventType(const QVariantMap &params) const JsonReply* EventHandler::GetEventType(const QVariantMap &params) const
{ {
QLocale locale = params.value("locale").toLocale();
qCDebug(dcJsonRpc) << "asked for event type" << params; qCDebug(dcJsonRpc) << "asked for event type" << params;
EventTypeId eventTypeId(params.value("eventTypeId").toString()); EventTypeId eventTypeId(params.value("eventTypeId").toString());
foreach (const DeviceClass &deviceClass, NymeaCore::instance()->deviceManager()->supportedDevices()) { foreach (const DeviceClass &deviceClass, NymeaCore::instance()->deviceManager()->supportedDevices()) {
foreach (const EventType &eventType, deviceClass.eventTypes()) { foreach (const EventType &eventType, deviceClass.eventTypes()) {
if (eventType.id() == eventTypeId) { if (eventType.id() == eventTypeId) {
EventType translatedEventType = eventType;
translatedEventType.setDisplayName(NymeaCore::instance()->deviceManager()->translate(deviceClass.pluginId(), eventType.displayName(), locale));
QVariantMap data; QVariantMap data;
data.insert("deviceError", enumValueName<Device::DeviceError>(Device::DeviceErrorNoError)); data.insert("deviceError", enumValueName<Device::DeviceError>(Device::DeviceErrorNoError));
data.insert("eventType", DeviceHandler::packEventType(eventType, deviceClass.pluginId(), params.value("locale").toLocale())); data.insert("eventType", pack(translatedEventType));
return createReply(data); return createReply(data);
} }
} }

77
libnymea-core/jsonrpc/jsonrpcserverimplementation.cpp
View File

@ -80,12 +80,13 @@ JsonRPCServerImplementation::JsonRPCServerImplementation(const QSslConfiguration
registerEnum<CloudManager::CloudConnectionState>(); registerEnum<CloudManager::CloudConnectionState>();
// Objects // Objects
QVariantMap tokenInfo; // QVariantMap tokenInfo;
tokenInfo.insert("id", enumValueName(Uuid)); // tokenInfo.insert("id", enumValueName(Uuid));
tokenInfo.insert("userName", enumValueName(String)); // tokenInfo.insert("userName", enumValueName(String));
tokenInfo.insert("deviceName", enumValueName(String)); // tokenInfo.insert("deviceName", enumValueName(String));
tokenInfo.insert("creationTime", enumValueName(Uint)); // tokenInfo.insert("creationTime", enumValueName(Uint));
registerObject("TokenInfo", tokenInfo); // registerObject("TokenInfo", tokenInfo);
registerObject<TokenInfo>();
// Methods // Methods
QString description; QVariantMap returns; QVariantMap params; QString description; QVariantMap returns; QVariantMap params;
@ -355,14 +356,10 @@ JsonReply *JsonRPCServerImplementation::Tokens(const QVariantMap &params) const
QByteArray token = property("token").toByteArray(); QByteArray token = property("token").toByteArray();
QString username = NymeaCore::instance()->userManager()->userForToken(token); QString username = NymeaCore::instance()->userManager()->userForToken(token);
if (username.isEmpty()) {
// There *really* should be a user for the token in the DB
Q_ASSERT(false);
}
QList<TokenInfo> tokens = NymeaCore::instance()->userManager()->tokens(username); QList<TokenInfo> tokens = NymeaCore::instance()->userManager()->tokens(username);
QVariantList retList; QVariantList retList;
foreach (const TokenInfo &tokenInfo, tokens) { foreach (const TokenInfo &tokenInfo, tokens) {
retList << packTokenInfo(tokenInfo); retList << pack(tokenInfo);
} }
QVariantMap retMap; QVariantMap retMap;
retMap.insert("tokenInfoList", retList); retMap.insert("tokenInfoList", retList);
@ -682,16 +679,6 @@ void JsonRPCServerImplementation::processJsonPacket(TransportInterface *interfac
} }
} }
QVariantMap JsonRPCServerImplementation::packTokenInfo(const TokenInfo &tokenInfo)
{
QVariantMap ret;
ret.insert("id", tokenInfo.id().toString());
ret.insert("userName", tokenInfo.username());
ret.insert("deviceName", tokenInfo.deviceName());
ret.insert("creationTime", tokenInfo.creationTime().toTime_t());
return ret;
}
void JsonRPCServerImplementation::sendNotification(const QVariantMap &params) void JsonRPCServerImplementation::sendNotification(const QVariantMap &params)
{ {
JsonHandler *handler = qobject_cast<JsonHandler *>(sender()); JsonHandler *handler = qobject_cast<JsonHandler *>(sender());
@ -793,39 +780,57 @@ void JsonRPCServerImplementation::onPushButtonAuthFinished(int transactionId, bo
bool JsonRPCServerImplementation::registerHandler(JsonHandler *handler) bool JsonRPCServerImplementation::registerHandler(JsonHandler *handler)
{ {
// Sanity checks on API: // Sanity checks on API:
// * Make sure all $ref: entries are valid. A Handler can reference Types from previously loaded handlers or own ones. // * Make sure all $ref: entries are valid.
// * A handler must not register a type name that is already registered by a previously loaded handler. // * A handler must not register a type name that is already registered by a previously loaded handler with different content.
QVariantMap types = m_api.value("types").toMap();
QVariantMap methods = m_api.value("methods").toMap(); QVariantMap methods = m_api.value("methods").toMap();
QVariantMap notifications = m_api.value("notifications").toMap(); QVariantMap notifications = m_api.value("notifications").toMap();
QVariantMap apiIncludingThis = m_api;
// Verify enums name clash // Verify enums name clash
QVariantMap enums = m_api.value("enums").toMap();
foreach (const QString &enumName, handler->jsonEnums().keys()) { foreach (const QString &enumName, handler->jsonEnums().keys()) {
QVariantList list = handler->jsonEnums().value(enumName).toList(); QVariantList list = handler->jsonEnums().value(enumName).toList();
if (types.contains(enumName)) { if (enums.contains(enumName) && enums.value(enumName) != list) {
qCWarning(dcJsonRpc()) << "Enum type" << enumName << "is already registered. Not registering handler" << handler->name(); qCWarning(dcJsonRpc()) << "Enum type" << enumName << "is already registered. Not registering handler" << handler->name();
return false; return false;
} }
types.insert(enumName, list); enums.insert(enumName, list);
} }
apiIncludingThis["enums"] = enums;
QVariantMap flags = m_api.value("flags").toMap();
foreach (const QString &flagName, handler->jsonFlags().keys()) {
QVariant flagDescription = handler->jsonFlags().value(flagName);
if (enums.contains(flagName)) {
qCWarning(dcJsonRpc()) << "Enum with name" << flagName << "is already registered. Not registering handler" << handler->name();
return false;
}
if (flags.contains(flagName) && flags.value(flagName) != handler->jsonFlags().value(flagName)) {
qCWarning(dcJsonRpc()) << "Flags with name" << flagName << "is already registered. Not registering handler" << handler->name();
return false;
}
flags.insert(flagName, flagDescription);
}
apiIncludingThis["flags"] = flags;
// Verify objects // Verify objects
QVariantMap typesIncludingThis = types; QVariantMap existingTypes = m_api.value("types").toMap();
QVariantMap typesIncludingThis = existingTypes;
typesIncludingThis.unite(handler->jsonObjects()); typesIncludingThis.unite(handler->jsonObjects());
apiIncludingThis["types"] = typesIncludingThis;
foreach (const QString &objectName, handler->jsonObjects().keys()) { foreach (const QString &objectName, handler->jsonObjects().keys()) {
QVariantMap object = handler->jsonObjects().value(objectName).toMap(); QVariantMap object = handler->jsonObjects().value(objectName).toMap();
// Check for name clashes // Check for name clashes
if (types.contains(objectName)) { if (existingTypes.contains(objectName) && existingTypes.value(objectName) != handler->jsonObjects().value(objectName)) {
qCWarning(dcJsonRpc()) << "Object type" << objectName << "is already registered. Not registering handler" << handler->name(); qCWarning(dcJsonRpc()) << "Object type" << objectName << "is already registered. Not registering handler" << handler->name();
return false; return false;
} }
// Check for invalid $ref: entries // Check for invalid $ref: entries
if (!JsonValidator::checkRefs(object, typesIncludingThis)) { if (!JsonValidator::checkRefs(object, apiIncludingThis)) {
qCWarning(dcJsonRpc()).nospace() << "Invalid reference in object type " << objectName << ". Not registering handler " << handler->name(); qCWarning(dcJsonRpc()).nospace() << "Invalid reference in object type " << objectName << ". Not registering handler " << handler->name();
return false; return false;
} }
} }
types = typesIncludingThis;
// Verify methods // Verify methods
QVariantMap newMethods; QVariantMap newMethods;
@ -835,35 +840,35 @@ bool JsonRPCServerImplementation::registerHandler(JsonHandler *handler)
qCWarning(dcJsonRpc()).nospace().noquote() << "Invalid method \"" << methodName << "\". Method \"JsonReply* " + methodName + "(QVariantMap)\" does not exist. Not registering handler " << handler->name(); qCWarning(dcJsonRpc()).nospace().noquote() << "Invalid method \"" << methodName << "\". Method \"JsonReply* " + methodName + "(QVariantMap)\" does not exist. Not registering handler " << handler->name();
return false; return false;
} }
if (!JsonValidator::checkRefs(method.value("params").toMap(), types)) { if (!JsonValidator::checkRefs(method.value("params").toMap(), apiIncludingThis)) {
qCWarning(dcJsonRpc()).nospace() << "Invalid reference in params of method " << methodName << ". Not registering handler " << handler->name(); qCWarning(dcJsonRpc()).nospace() << "Invalid reference in params of method " << methodName << ". Not registering handler " << handler->name();
return false; return false;
} }
if (!JsonValidator::checkRefs(method.value("returns").toMap(), types)) { if (!JsonValidator::checkRefs(method.value("returns").toMap(), apiIncludingThis)) {
qCWarning(dcJsonRpc()).nospace() << "Invalid reference in return value of method " << methodName << ". Not registering handler " << handler->name(); qCWarning(dcJsonRpc()).nospace() << "Invalid reference in return value of method " << methodName << ". Not registering handler " << handler->name();
return false; return false;
} }
newMethods.insert(handler->name() + '.' + methodName, method); newMethods.insert(handler->name() + '.' + methodName, method);
} }
methods.unite(newMethods); methods.unite(newMethods);
apiIncludingThis["methods"] = methods;
// Verify notifications // Verify notifications
QVariantMap newNotifications; QVariantMap newNotifications;
foreach (const QString &notificationName, handler->jsonNotifications().keys()) { foreach (const QString &notificationName, handler->jsonNotifications().keys()) {
QVariantMap notification = handler->jsonNotifications().value(notificationName).toMap(); QVariantMap notification = handler->jsonNotifications().value(notificationName).toMap();
if (!JsonValidator::checkRefs(notification.value("params").toMap(), types)) { if (!JsonValidator::checkRefs(notification.value("params").toMap(), apiIncludingThis)) {
qCWarning(dcJsonRpc()).nospace() << "Invalid reference in params of notification " << notificationName << ". Not registering handler " << handler->name(); qCWarning(dcJsonRpc()).nospace() << "Invalid reference in params of notification " << notificationName << ". Not registering handler " << handler->name();
return false; return false;
} }
newNotifications.insert(handler->name() + '.' + notificationName, notification); newNotifications.insert(handler->name() + '.' + notificationName, notification);
} }
notifications.unite(newNotifications); notifications.unite(newNotifications);
apiIncludingThis["notifications"] = notifications;
// Checks completed. Store new API // Checks completed. Store new API
qCDebug(dcJsonRpc()) << "Registering JSON RPC handler:" << handler->name(); qCDebug(dcJsonRpc()) << "Registering JSON RPC handler:" << handler->name();
m_api["types"] = types; m_api = apiIncludingThis;
m_api["methods"] = methods;
m_api["notifications"] = notifications;
m_handlers.insert(handler->name(), handler); m_handlers.insert(handler->name(), handler);
for (int i = 0; i < handler->metaObject()->methodCount(); ++i) { for (int i = 0; i < handler->metaObject()->methodCount(); ++i) {

3
libnymea-core/jsonrpc/jsonrpcserverimplementation.h
View File

@ -84,9 +84,6 @@ private:
void processJsonPacket(TransportInterface *interface, const QUuid &clientId, const QByteArray &data); void processJsonPacket(TransportInterface *interface, const QUuid &clientId, const QByteArray &data);
static QVariantMap packTokenInfo(const TokenInfo &tokenInfo);
private slots: private slots:
void setup(); void setup();

67
libnymea-core/jsonrpc/jsonvalidator.cpp
View File

@ -9,18 +9,23 @@
namespace nymeaserver { namespace nymeaserver {
bool JsonValidator::checkRefs(const QVariantMap &map, const QVariantMap &types) bool JsonValidator::checkRefs(const QVariantMap &map, const QVariantMap &api)
{ {
QVariantMap enums = api.value("enums").toMap();
QVariantMap flags = api.value("flags").toMap();
QVariantMap types = api.value("types").toMap();
// qWarning() << "checkrefs enums" << enums.keys();
foreach (const QString &key, map.keys()) { foreach (const QString &key, map.keys()) {
// qWarning() << "checking prop" << key;
if (map.value(key).toString().startsWith("$ref:")) { if (map.value(key).toString().startsWith("$ref:")) {
QString refName = map.value(key).toString().remove("$ref:"); QString refName = map.value(key).toString().remove("$ref:");
if (!types.contains(refName)) { if (!enums.contains(refName) && !flags.contains(refName) && !types.contains(refName)) {
qCWarning(dcJsonRpc()) << "Invalid reference to" << refName; qCWarning(dcJsonRpc()) << "Invalid reference to" << refName;
return false; return false;
} }
} }
if (map.value(key).type() == QVariant::Map) { if (map.value(key).type() == QVariant::Map) {
bool ret = checkRefs(map.value(key).toMap(), types); bool ret = checkRefs(map.value(key).toMap(), api);
if (!ret) { if (!ret) {
return false; return false;
} }
@ -29,13 +34,13 @@ bool JsonValidator::checkRefs(const QVariantMap &map, const QVariantMap &types)
foreach (const QVariant &entry, map.value(key).toList()) { foreach (const QVariant &entry, map.value(key).toList()) {
if (entry.toString().startsWith("$ref:")) { if (entry.toString().startsWith("$ref:")) {
QString refName = entry.toString().remove("$ref:"); QString refName = entry.toString().remove("$ref:");
if (!types.contains(refName)) { if (!enums.contains(refName) && !flags.contains(refName) && !types.contains(refName)) {
qCWarning(dcJsonRpc()) << "Invalid reference to" << refName; qCWarning(dcJsonRpc()) << "Invalid reference to" << refName;
return false; return false;
} }
} }
if (entry.type() == QVariant::Map) { if (entry.type() == QVariant::Map) {
bool ret = checkRefs(map.value(key).toMap(), types); bool ret = checkRefs(map.value(key).toMap(), api);
if (!ret) { if (!ret) {
return false; return false;
} }
@ -50,7 +55,7 @@ bool JsonValidator::checkRefs(const QVariantMap &map, const QVariantMap &types)
JsonValidator::Result JsonValidator::validateParams(const QVariantMap &params, const QString &method, const QVariantMap &api) JsonValidator::Result JsonValidator::validateParams(const QVariantMap &params, const QString &method, const QVariantMap &api)
{ {
QVariantMap paramDefinition = api.value("methods").toMap().value(method).toMap().value("params").toMap(); QVariantMap paramDefinition = api.value("methods").toMap().value(method).toMap().value("params").toMap();
m_result = validateMap(params, paramDefinition, api.value("types").toMap()); m_result = validateMap(params, paramDefinition, api);
m_result.setWhere(method + ", param " + m_result.where()); m_result.setWhere(method + ", param " + m_result.where());
return m_result; return m_result;
} }
@ -58,7 +63,7 @@ JsonValidator::Result JsonValidator::validateParams(const QVariantMap &params, c
JsonValidator::Result JsonValidator::validateReturns(const QVariantMap &returns, const QString &method, const QVariantMap &api) JsonValidator::Result JsonValidator::validateReturns(const QVariantMap &returns, const QString &method, const QVariantMap &api)
{ {
QVariantMap returnsDefinition = api.value("methods").toMap().value(method).toMap().value("returns").toMap(); QVariantMap returnsDefinition = api.value("methods").toMap().value(method).toMap().value("returns").toMap();
m_result = validateMap(returns, returnsDefinition, api.value("types").toMap()); m_result = validateMap(returns, returnsDefinition, api);
m_result.setWhere(method + ", returns " + m_result.where()); m_result.setWhere(method + ", returns " + m_result.where());
return m_result; return m_result;
} }
@ -66,7 +71,7 @@ JsonValidator::Result JsonValidator::validateReturns(const QVariantMap &returns,
JsonValidator::Result JsonValidator::validateNotificationParams(const QVariantMap &params, const QString &notification, const QVariantMap &api) JsonValidator::Result JsonValidator::validateNotificationParams(const QVariantMap &params, const QString &notification, const QVariantMap &api)
{ {
QVariantMap paramDefinition = api.value("notifications").toMap().value(notification).toMap().value("params").toMap(); QVariantMap paramDefinition = api.value("notifications").toMap().value(notification).toMap().value("params").toMap();
m_result = validateMap(params, paramDefinition, api.value("types").toMap()); m_result = validateMap(params, paramDefinition, api);
m_result.setWhere(notification + ", param " + m_result.where()); m_result.setWhere(notification + ", param " + m_result.where());
return m_result; return m_result;
} }
@ -76,7 +81,7 @@ JsonValidator::Result JsonValidator::result() const
return m_result; return m_result;
} }
JsonValidator::Result JsonValidator::validateMap(const QVariantMap &map, const QVariantMap &definition, const QVariantMap &types) JsonValidator::Result JsonValidator::validateMap(const QVariantMap &map, const QVariantMap &definition, const QVariantMap &api)
{ {
// Make sure all required values are available // Make sure all required values are available
foreach (const QString &key, definition.keys()) { foreach (const QString &key, definition.keys()) {
@ -102,7 +107,7 @@ JsonValidator::Result JsonValidator::validateMap(const QVariantMap &map, const Q
// Validate content // Validate content
QVariant value = map.value(key); QVariant value = map.value(key);
Result result = validateEntry(value, expectedValue, types); Result result = validateEntry(value, expectedValue, api);
if (!result.success()) { if (!result.success()) {
result.setWhere(key + '.' + result.where()); result.setWhere(key + '.' + result.where());
result.setErrorString(result.errorString()); result.setErrorString(result.errorString());
@ -114,8 +119,11 @@ JsonValidator::Result JsonValidator::validateMap(const QVariantMap &map, const Q
return Result(true); return Result(true);
} }
JsonValidator::Result JsonValidator::validateEntry(const QVariant &value, const QVariant &definition, const QVariantMap &types) JsonValidator::Result JsonValidator::validateEntry(const QVariant &value, const QVariant &definition, const QVariantMap &api)
{ {
// qWarning() << "validating" << definition;
// qWarning() << "** enums:" << api.value("enums").toMap().keys();
// qWarning() << "** types:" << api.value("types").toMap().keys();
if (definition.type() == QVariant::String) { if (definition.type() == QVariant::String) {
QString expectedTypeName = definition.toString(); QString expectedTypeName = definition.toString();
@ -123,20 +131,39 @@ JsonValidator::Result JsonValidator::validateEntry(const QVariant &value, const
QString refName = expectedTypeName; QString refName = expectedTypeName;
refName.remove("$ref:"); refName.remove("$ref:");
QVariant refDefinition = types.value(refName);
// Refs might be enums // Refs might be enums
if (refDefinition.type() == QVariant::List) { QVariantMap enums = api.value("enums").toMap();
if (value.type() != QVariant::String) { if (enums.contains(refName)) {
return Result(false, "Expected enum " + refName + " but got " + value.toString()); QVariant refDefinition = enums.value(refName);
}
QVariantList enumList = refDefinition.toList(); QVariantList enumList = refDefinition.toList();
if (!enumList.contains(value.toString())) { if (!enumList.contains(value.toString())) {
return Result(false, "Expected enum " + refName + " but got " + value.toString()); return Result(false, "Expected enum " + refName + " but got " + value.toJsonDocument().toJson());
}
return Result(true);
}
// Or flags
QVariantMap flags = api.value("flags").toMap();
if (flags.contains(refName)) {
QVariant refDefinition = flags.value(refName);
qWarning() << "Flag:" << value.type();
if (value.type() != QVariant::StringList) {
return Result(false, "Expected flags " + refName + " but got " + value.toString());
}
QString flagEnum = refDefinition.toList().first().toString();
qWarning() << "Flag enum:" << flagEnum;
foreach (const QVariant &flagsEntry, value.toList()) {
Result result = validateEntry(flagsEntry, flagEnum, api);
if (!result.success()) {
return result;
}
} }
return Result(true); return Result(true);
} }
return validateEntry(value, refDefinition, types); QVariantMap types = api.value("types").toMap();
QVariant refDefinition = types.value(refName);
return validateEntry(value, refDefinition, api);
} }
JsonHandler::BasicType expectedBasicType = JsonHandler::enumNameToValue<JsonHandler::BasicType>(expectedTypeName); JsonHandler::BasicType expectedBasicType = JsonHandler::enumNameToValue<JsonHandler::BasicType>(expectedTypeName);
@ -199,7 +226,7 @@ JsonValidator::Result JsonValidator::validateEntry(const QVariant &value, const
if (value.type() != QVariant::Map) { if (value.type() != QVariant::Map) {
return Result(false, "Invalud value. Expected a map bug received: " + value.toString()); return Result(false, "Invalud value. Expected a map bug received: " + value.toString());
} }
return validateMap(value.toMap(), definition.toMap(), types); return validateMap(value.toMap(), definition.toMap(), api);
} }
if (definition.type() == QVariant::List) { if (definition.type() == QVariant::List) {
@ -209,7 +236,7 @@ JsonValidator::Result JsonValidator::validateEntry(const QVariant &value, const
return Result(false, "Expected list of " + entryDefinition.toString() + " but got value of type " + value.typeName() + "\n" + QJsonDocument::fromVariant(value).toJson()); return Result(false, "Expected list of " + entryDefinition.toString() + " but got value of type " + value.typeName() + "\n" + QJsonDocument::fromVariant(value).toJson());
} }
foreach (const QVariant &entry, value.toList()) { foreach (const QVariant &entry, value.toList()) {
Result result = validateEntry(entry, entryDefinition, types); Result result = validateEntry(entry, entryDefinition, api);
if (!result.success()) { if (!result.success()) {
return result; return result;
} }

6
libnymea-core/jsonrpc/jsonvalidator.h
View File

@ -30,7 +30,7 @@ public:
JsonValidator() {} JsonValidator() {}
static bool checkRefs(const QVariantMap &map, const QVariantMap &types); static bool checkRefs(const QVariantMap &map, const QVariantMap &api);
Result validateParams(const QVariantMap &params, const QString &method, const QVariantMap &api); Result validateParams(const QVariantMap &params, const QString &method, const QVariantMap &api);
Result validateReturns(const QVariantMap &returns, const QString &method, const QVariantMap &api); Result validateReturns(const QVariantMap &returns, const QString &method, const QVariantMap &api);
@ -38,8 +38,8 @@ public:
Result result() const; Result result() const;
private: private:
Result validateMap(const QVariantMap &map, const QVariantMap &definition, const QVariantMap &types); Result validateMap(const QVariantMap &map, const QVariantMap &definition, const QVariantMap &api);
Result validateEntry(const QVariant &value, const QVariant &definition, const QVariantMap &types); Result validateEntry(const QVariant &value, const QVariant &definition, const QVariantMap &api);
Result m_result; Result m_result;
}; };

17
libnymea-core/jsonrpc/logginghandler.cpp
View File

@ -62,18 +62,7 @@ LoggingHandler::LoggingHandler(QObject *parent) :
registerEnum<Logging::LoggingError>(); registerEnum<Logging::LoggingError>();
// Objects // Objects
QVariantMap logEntry; registerObject<LogEntry>();
logEntry.insert("timestamp", enumValueName(Int));
logEntry.insert("loggingLevel", enumRef<Logging::LoggingLevel>());
logEntry.insert("source", enumRef<Logging::LoggingSource>());
logEntry.insert("o:typeId", enumValueName(Uuid));
logEntry.insert("o:deviceId", enumValueName(Uuid));
logEntry.insert("o:itemId", enumValueName(String));
logEntry.insert("o:value", enumValueName(String));
logEntry.insert("o:active", enumValueName(Bool));
logEntry.insert("o:eventType", enumRef<Logging::LoggingEventType>());
logEntry.insert("o:errorCode", enumValueName(String));
registerObject("LogEntry", logEntry);
// Methods // Methods
QString description; QVariantMap params; QVariantMap returns; QString description; QVariantMap params; QVariantMap returns;
@ -198,8 +187,8 @@ QVariantMap LoggingHandler::packLogEntry(const LogEntry &logEntry)
case Logging::LoggingSourceActions: case Logging::LoggingSourceActions:
case Logging::LoggingSourceEvents: case Logging::LoggingSourceEvents:
case Logging::LoggingSourceStates: case Logging::LoggingSourceStates:
logEntryMap.insert("typeId", logEntry.typeId().toString()); logEntryMap.insert("typeId", logEntry.typeId());
logEntryMap.insert("deviceId", logEntry.deviceId().toString()); logEntryMap.insert("deviceId", logEntry.deviceId());
logEntryMap.insert("value", LogValueTool::convertVariantToString(logEntry.value())); logEntryMap.insert("value", LogValueTool::convertVariantToString(logEntry.value()));
break; break;
case Logging::LoggingSourceSystem: case Logging::LoggingSourceSystem:

7
libnymea-core/jsonrpc/ruleshandler.cpp
View File

@ -116,12 +116,7 @@ RulesHandler::RulesHandler(QObject *parent) :
repeatingOption.insert("o:monthDays", QVariantList() << enumValueName(Int)); repeatingOption.insert("o:monthDays", QVariantList() << enumValueName(Int));
registerObject("RepeatingOption", repeatingOption); registerObject("RepeatingOption", repeatingOption);
QVariantMap calendarItem; registerObject<CalendarItem>();
calendarItem.insert("o:datetime", enumValueName(Uint));
calendarItem.insert("o:startTime", enumValueName(Time));
calendarItem.insert("duration", enumValueName(Uint));
calendarItem.insert("o:repeating", objectRef("RepeatingOption"));
registerObject("CalendarItem", calendarItem);
QVariantMap timeEventItem; QVariantMap timeEventItem;
timeEventItem.insert("o:datetime", enumValueName(Uint)); timeEventItem.insert("o:datetime", enumValueName(Uint));

3
libnymea-core/jsonrpc/statehandler.cpp
View File

@ -73,7 +73,8 @@ JsonReply* StateHandler::GetStateType(const QVariantMap &params) const
if (stateType.id() == stateTypeId) { if (stateType.id() == stateTypeId) {
QVariantMap data; QVariantMap data;
data.insert("deviceError", enumValueName<Device::DeviceError>(Device::DeviceErrorNoError)); data.insert("deviceError", enumValueName<Device::DeviceError>(Device::DeviceErrorNoError));
data.insert("stateType", DeviceHandler::packStateType(stateType, deviceClass.pluginId(), params.value("locale").toLocale())); // FIXME TODO!!!
// data.insert("stateType", DeviceHandler::packStateType(stateType, deviceClass.pluginId(), params.value("locale").toLocale()));
return createReply(data); return createReply(data);
} }
} }

10
libnymea-core/logging/logentry.h
View File

@ -34,6 +34,16 @@ namespace nymeaserver {
class LogEntry class LogEntry
{ {
Q_GADGET Q_GADGET
Q_PROPERTY(QDateTime timestamp READ timestamp)
Q_PROPERTY(Logging::LoggingLevel loggingLevel READ level)
Q_PROPERTY(Logging::LoggingSource source READ source)
Q_PROPERTY(QUuid typeId READ typeId USER true)
Q_PROPERTY(QUuid deviceId READ deviceId USER true)
// Q_PROPERTY(QString itemId READ itemId USER true)
Q_PROPERTY(QVariant value READ value USER true)
Q_PROPERTY(bool active READ active USER true)
Q_PROPERTY(Logging::LoggingEventType eventType READ eventType USER true)
Q_PROPERTY(QString errorCode READ errorCode USER true)
public: public:
LogEntry(QDateTime timestamp, Logging::LoggingLevel level, Logging::LoggingSource source, int errorCode = 0); LogEntry(QDateTime timestamp, Logging::LoggingLevel level, Logging::LoggingSource source, int errorCode = 0);

16
libnymea-core/nymeaconfiguration.h
View File

@ -30,9 +30,16 @@
namespace nymeaserver { namespace nymeaserver {
class ServerConfiguration { class ServerConfiguration {
Q_GADGET
Q_PROPERTY(QString id MEMBER id)
Q_PROPERTY(QString address READ addressString)
Q_PROPERTY(uint port MEMBER port)
Q_PROPERTY(bool sslEnabled MEMBER sslEnabled)
Q_PROPERTY(bool authenticationEnabled MEMBER authenticationEnabled)
public: public:
QString id; QString id;
QHostAddress address; QHostAddress address;
QString addressString() { return address.toString(); }
uint port = 0; uint port = 0;
bool sslEnabled = true; bool sslEnabled = true;
bool authenticationEnabled = true; bool authenticationEnabled = true;
@ -50,6 +57,8 @@ QDebug operator <<(QDebug debug, const ServerConfiguration &configuration);
class WebServerConfiguration: public ServerConfiguration class WebServerConfiguration: public ServerConfiguration
{ {
Q_GADGET
Q_PROPERTY(QString publicFolder MEMBER publicFolder)
public: public:
QString publicFolder; QString publicFolder;
bool restServerEnabled = false; bool restServerEnabled = false;
@ -57,6 +66,13 @@ public:
class MqttPolicy class MqttPolicy
{ {
Q_GADGET
Q_PROPERTY(QString clientId MEMBER clientId)
Q_PROPERTY(QString username MEMBER username)
Q_PROPERTY(QString password MEMBER password)
Q_PROPERTY(QStringList allowedPublishTopicFilters MEMBER allowedPublishTopicFilters)
Q_PROPERTY(QStringList allowedSubscribeTopicFilters MEMBER allowedSubscribeTopicFilters)
public: public:
QString clientId; QString clientId;
QString username; QString username;

7
libnymea-core/usermanager/tokeninfo.h
View File

@ -23,11 +23,18 @@
#include <QUuid> #include <QUuid>
#include <QDateTime> #include <QDateTime>
#include <QMetaObject>
namespace nymeaserver { namespace nymeaserver {
class TokenInfo class TokenInfo
{ {
Q_GADGET
Q_PROPERTY(QUuid id READ id)
Q_PROPERTY(QString username READ username)
Q_PROPERTY(QDateTime createionTime READ creationTime)
Q_PROPERTY(QString deviveName READ deviceName)
public: public:
TokenInfo(const QUuid &id, const QString &username, const QDateTime &creationTime, const QString &deviceName); TokenInfo(const QUuid &id, const QString &username, const QDateTime &creationTime, const QString &deviceName);

13
libnymea/devices/device.h
View File

@ -41,9 +41,14 @@ class DevicePlugin;
class LIBNYMEA_EXPORT Device: public QObject class LIBNYMEA_EXPORT Device: public QObject
{ {
Q_OBJECT Q_OBJECT
Q_PROPERTY(QUuid id READ id)
friend class DeviceManager; Q_PROPERTY(QUuid deviceClassId READ deviceClassId)
friend class DeviceManagerImplementation; Q_PROPERTY(QString name READ name WRITE setName NOTIFY nameChanged)
Q_PROPERTY(ParamList params READ params WRITE setParams)
Q_PROPERTY(ParamList settings READ settings WRITE setSettings)
Q_PROPERTY(States states READ states WRITE setStates)
Q_PROPERTY(bool setupComplete READ setupComplete WRITE setSetupComplete)
Q_PROPERTY(QUuid parentId READ parentId WRITE setParentId USER true)
public: public:
enum DeviceError { enum DeviceError {
@ -122,6 +127,8 @@ signals:
void nameChanged(); void nameChanged();
private: private:
friend class DeviceManager;
friend class DeviceManagerImplementation;
Device(DevicePlugin *plugin, const DeviceClass &deviceClass, const DeviceId &id, QObject *parent = nullptr); Device(DevicePlugin *plugin, const DeviceClass &deviceClass, const DeviceId &id, QObject *parent = nullptr);
Device(DevicePlugin *plugin, const DeviceClass &deviceClass, QObject *parent = nullptr); Device(DevicePlugin *plugin, const DeviceClass &deviceClass, QObject *parent = nullptr);

7
libnymea/devices/devicedescriptor.h
View File

@ -32,6 +32,13 @@
class LIBNYMEA_EXPORT DeviceDescriptor class LIBNYMEA_EXPORT DeviceDescriptor
{ {
Q_GADGET
Q_PROPERTY(QUuid id READ id)
Q_PROPERTY(QUuid deviceId READ deviceId USER true)
Q_PROPERTY(QString title READ title)
Q_PROPERTY(QString description READ description)
Q_PROPERTY(ParamList deviceParams READ params)
public: public:
DeviceDescriptor(); DeviceDescriptor();
DeviceDescriptor(const DeviceClassId &deviceClassId, const QString &title = QString(), const QString &description = QString(), const DeviceId &parentDeviceId = DeviceId()); DeviceDescriptor(const DeviceClassId &deviceClassId, const QString &title = QString(), const QString &description = QString(), const DeviceId &parentDeviceId = DeviceId());

4
libnymea/devices/devicemanager.h
View File

@ -125,7 +125,9 @@ public:
virtual BrowserItemActionInfo* executeBrowserItemAction(const BrowserItemAction &browserItemAction) = 0; virtual BrowserItemActionInfo* executeBrowserItemAction(const BrowserItemAction &browserItemAction) = 0;
virtual QString translate(const PluginId &pluginId, const QString &string, const QLocale &locale) = 0; virtual QString translate(const PluginId &pluginId, const QString &string, const QLocale &locale) = 0;
virtual ParamType translateParamType(const PluginId &pluginId, const ParamType &paramType, const QLocale &locale) = 0;
virtual DeviceClass translateDeviceClass(const DeviceClass &deviceClass, const QLocale &locale) = 0;
virtual Vendor translateVendor(const Vendor &vendor, const QLocale &locale) = 0;
signals: signals:
void pluginConfigChanged(const PluginId &id, const ParamList &config); void pluginConfigChanged(const PluginId &id, const ParamList &config);
void eventTriggered(const Event &event); void eventTriggered(const Event &event);

10
libnymea/devices/deviceplugin.h
View File

@ -62,8 +62,10 @@ class LIBNYMEA_EXPORT DevicePlugin: public QObject
{ {
Q_OBJECT Q_OBJECT
friend class DeviceManager; Q_PROPERTY(QUuid id READ pluginId)
friend class DeviceManagerImplementation; Q_PROPERTY(QString name READ pluginName)
Q_PROPERTY(QString displayName READ pluginDisplayName)
Q_PROPERTY(ParamTypes paramTypes READ configurationDescription)
public: public:
DevicePlugin(QObject *parent = nullptr); DevicePlugin(QObject *parent = nullptr);
@ -115,6 +117,10 @@ protected:
QSettings *pluginStorage() const; QSettings *pluginStorage() const;
private: private:
friend class DeviceManager;
friend class DeviceManagerImplementation;
void setMetaData(const PluginMetadata &metaData); void setMetaData(const PluginMetadata &metaData);
void initPlugin(const PluginMetadata &metadata, DeviceManager *deviceManager, HardwareManager *hardwareManager); void initPlugin(const PluginMetadata &metadata, DeviceManager *deviceManager, HardwareManager *hardwareManager);

6
libnymea/devices/pluginmetadata.cpp
View File

@ -103,7 +103,7 @@ void PluginMetadata::parse(const QJsonObject &jsonObject)
return; return;
} }
m_pluginId = jsonObject.value("id").toString(); m_pluginId = PluginId(jsonObject.value("id").toString());
m_pluginName = jsonObject.value("name").toString(); m_pluginName = jsonObject.value("name").toString();
m_pluginDisplayName = jsonObject.value("displayName").toString(); m_pluginDisplayName = jsonObject.value("displayName").toString();
@ -192,7 +192,7 @@ void PluginMetadata::parse(const QJsonObject &jsonObject)
continue; continue;
} }
DeviceClassId deviceClassId = deviceClassObject.value("id").toString(); DeviceClassId deviceClassId = DeviceClassId(deviceClassObject.value("id").toString());
QString deviceClassName = deviceClassObject.value("name").toString(); QString deviceClassName = deviceClassObject.value("name").toString();
// Check if there are any unknown fields // Check if there are any unknown fields
@ -304,7 +304,7 @@ void PluginMetadata::parse(const QJsonObject &jsonObject)
continue; continue;
} }
StateTypeId stateTypeId = st.value("id").toString(); StateTypeId stateTypeId = StateTypeId(st.value("id").toString());
QString stateTypeName = st.value("name").toString(); QString stateTypeName = st.value("name").toString();
// Check if there are any unknown fields // Check if there are any unknown fields

78
libnymea/jsonrpc/jsonhandler.cpp
View File

@ -6,6 +6,7 @@
JsonHandler::JsonHandler(QObject *parent) : QObject(parent) JsonHandler::JsonHandler(QObject *parent) : QObject(parent)
{ {
registerEnum<BasicType>();
} }
QVariantMap JsonHandler::jsonEnums() const QVariantMap JsonHandler::jsonEnums() const
@ -13,6 +14,11 @@ QVariantMap JsonHandler::jsonEnums() const
return m_enums; return m_enums;
} }
QVariantMap JsonHandler::jsonFlags() const
{
return m_flags;
}
QVariantMap JsonHandler::jsonObjects() const QVariantMap JsonHandler::jsonObjects() const
{ {
return m_objects; return m_objects;
@ -62,6 +68,8 @@ JsonHandler::BasicType JsonHandler::variantTypeToBasicType(QVariant::Type varian
return Time; return Time;
case QVariant::Map: case QVariant::Map:
return Object; return Object;
case QVariant::DateTime:
return Uint; // DateTime is represented as time_t
default: default:
return Variant; return Variant;
} }
@ -132,3 +140,73 @@ JsonReply *JsonHandler::createAsyncReply(const QString &method) const
return JsonReply::createAsyncReply(const_cast<JsonHandler*>(this), method); return JsonReply::createAsyncReply(const_cast<JsonHandler*>(this), method);
} }
QVariantMap JsonHandler::pack(const QMetaObject &metaObject, const void *value) const
{
QVariantMap ret;
// qWarning() << "+ Packing" << metaObject.className();
for (int i = 0; i < metaObject.propertyCount(); i++) {
QMetaProperty metaProperty = metaObject.property(i);
if (metaProperty.name() == QStringLiteral("objectName")) {
continue; // Skip QObject's objectName property
}
QVariant val = metaProperty.readOnGadget(value);
// qWarning() << "|- Property:" << metaProperty.name() << metaProperty.readOnGadget(value) << metaProperty.type() << metaProperty.typeName();
// qWarning() << "|-- All list types:" << m_listMetaObjects.keys();
if (metaProperty.type() == QVariant::UserType) {
if (metaProperty.typeName() == QStringLiteral("QVariant::Type")) {
QMetaEnum metaEnum = QMetaEnum::fromType<BasicType>();
// qWarning() << "|--" << metaProperty.readOnGadget(value).toInt() << metaEnum.key(metaProperty.readOnGadget(value).toInt());
ret.insert(metaProperty.name(), metaEnum.key(variantTypeToBasicType(metaProperty.readOnGadget(value).template value<QVariant::Type>())));
} else if (m_listMetaObjects.contains(metaProperty.typeName())) {
QVariant listObject = metaProperty.readOnGadget(value);
QMetaObject listMetaObject = m_listMetaObjects.value(metaProperty.typeName());
QMetaProperty countProperty = listMetaObject.property(listMetaObject.indexOfProperty("count"));
int listCount = countProperty.readOnGadget(listObject.constData()).toInt();
// qWarning() << "Packing list type" << listObject << "count is" << listCount;
QMetaMethod metaMethod = listMetaObject.method(listMetaObject.indexOfMethod("get(int)"));
// qWarning() << "get method" << listMetaObject.indexOfMethod("get(int)") << listMetaObject.method(0).name() << QMetaObject::normalizedSignature("QVariant get(int)");
QMetaObject entryMetaObject = m_metaObjects.value(m_listEntryTypes.value(listMetaObject.className()));
QVariantList list;
for (int i = 0; i < listCount; i++) {
QVariant entry;
metaMethod.invokeOnGadget(listObject.data(), Q_RETURN_ARG(QVariant, entry), Q_ARG(int, i));
// qWarning() << "|---Feckin hell" << entry;
list.append(pack(entryMetaObject, entry.data()));
}
ret.insert(metaProperty.name(), list);
} else {
Q_ASSERT_X(false, this->metaObject()->className(), QString("Cannot pack %1. %2 is not registered in this handler.").arg(metaObject.className()).arg(metaProperty.typeName()).toUtf8());
}
} else if (metaProperty.isFlagType()) {
QMetaEnum metaFlag = m_metaFlags.value(QString(metaProperty.typeName()).split("::").last());
// QMetaEnum metaEnum = m_metaEnums.value(m_flagsEnums.value(metaFlag.name()));
int flagValue = metaProperty.readOnGadget(value).toInt();
// qWarning() << "|-- Flag" << flagValue << metaFlag.name() << metaFlag.keyCount() << metaProperty.type();
QStringList flags;
for (int i = 0; i < metaFlag.keyCount(); i++) {
// qWarning() << "|--- flag key:" << metaFlag.key(i) << metaFlag.value(i);
if ((metaFlag.value(i) & flagValue) > 0) {
flags.append(metaFlag.key(i));
}
}
ret.insert(metaProperty.name(), flags);
} else if (metaProperty.isEnumType()) {
QString enumName = QString(metaProperty.typeName()).split("::").last();
Q_ASSERT_X(m_metaEnums.contains(enumName), this->metaObject()->className(), QString("Cannot pack %1. %2 is not registered int this handler.").arg(metaObject.className()).arg(metaProperty.typeName()).toUtf8());
QMetaEnum metaEnum = m_metaEnums.value(enumName);
// qWarning() << "|-- Enum: Name:" << metaEnum.name() << "as int:" << metaEnum.key(metaProperty.readOnGadget(value).toInt()) << "All enums:" << m_metaEnums.keys();
ret.insert(metaProperty.name(), metaEnum.key(metaProperty.readOnGadget(value).toInt()));
} else if (!metaProperty.isUser() || !metaProperty.readOnGadget(value).isNull()) {
// qWarning() << "|-- property" << metaProperty.name() << metaProperty.readOnGadget(value);
ret.insert(metaProperty.name(), metaProperty.readOnGadget(value));
}
}
return ret;
}

104
libnymea/jsonrpc/jsonhandler.h
View File

@ -4,6 +4,8 @@
#include <QObject> #include <QObject>
#include <QVariantMap> #include <QVariantMap>
#include <QMetaMethod> #include <QMetaMethod>
#include <QDebug>
#include <QVariant>
#include "jsonreply.h" #include "jsonreply.h"
@ -32,6 +34,7 @@ public:
virtual QString name() const = 0; virtual QString name() const = 0;
QVariantMap jsonEnums() const; QVariantMap jsonEnums() const;
QVariantMap jsonFlags() const;
QVariantMap jsonObjects() const; QVariantMap jsonObjects() const;
QVariantMap jsonMethods() const; QVariantMap jsonMethods() const;
QVariantMap jsonNotifications() const; QVariantMap jsonNotifications() const;
@ -46,8 +49,13 @@ public:
static BasicType variantTypeToBasicType(QVariant::Type variantType); static BasicType variantTypeToBasicType(QVariant::Type variantType);
static QVariant::Type basicTypeToVariantType(BasicType basicType); static QVariant::Type basicTypeToVariantType(BasicType basicType);
template<typename T> QVariantMap pack(const T &value) const;
protected: protected:
template <typename T> void registerEnum(); template <typename Enum> void registerEnum();
template <typename Enum, typename Flags> void registerEnum();
template <typename ObjectType> void registerObject();
template <typename ObjectType, typename ListType> void registerObject();
void registerObject(const QString &name, const QVariantMap &object); void registerObject(const QString &name, const QVariantMap &object);
void registerMethod(const QString &name, const QString &description, const QVariantMap &params, const QVariantMap &returns, bool deprecated = false); void registerMethod(const QString &name, const QString &description, const QVariantMap &params, const QVariantMap &returns, bool deprecated = false);
void registerNotification(const QString &name, const QString &description, const QVariantMap &params, bool deprecated = false); void registerNotification(const QString &name, const QString &description, const QVariantMap &params, bool deprecated = false);
@ -55,13 +63,23 @@ protected:
JsonReply *createReply(const QVariantMap &data) const; JsonReply *createReply(const QVariantMap &data) const;
JsonReply *createAsyncReply(const QString &method) const; JsonReply *createAsyncReply(const QString &method) const;
private:
QVariantMap pack(const QMetaObject &metaObject, const void *gadget) const;
private: private:
QVariantMap m_enums; QVariantMap m_enums;
QHash<QString, QMetaEnum> m_metaEnums;
QVariantMap m_flags;
QHash<QString, QMetaEnum> m_metaFlags;
QHash<QString, QString> m_flagsEnums;
QVariantMap m_objects; QVariantMap m_objects;
QHash<QString, QMetaObject> m_metaObjects;
QHash<QString, QMetaObject> m_listMetaObjects;
QHash<QString, QString> m_listEntryTypes;
QVariantMap m_methods; QVariantMap m_methods;
QVariantMap m_notifications; QVariantMap m_notifications;
}; };
Q_DECLARE_METATYPE(QVariant::Type)
template<typename T> template<typename T>
void JsonHandler::registerEnum() void JsonHandler::registerEnum()
@ -72,9 +90,83 @@ void JsonHandler::registerEnum()
values << metaEnum.key(i); values << metaEnum.key(i);
} }
m_enums.insert(metaEnum.name(), values); m_enums.insert(metaEnum.name(), values);
m_metaEnums.insert(metaEnum.name(), metaEnum);
} }
template<typename Enum, typename Flags>
void JsonHandler::registerEnum()
{
registerEnum<Enum>();
QMetaEnum metaEnum = QMetaEnum::fromType<Enum>();
QMetaEnum metaFlags = QMetaEnum::fromType<Flags>();
m_metaFlags.insert(metaFlags.name(), metaFlags);
m_flagsEnums.insert(metaFlags.name(), metaEnum.name());
m_flags.insert(metaFlags.name(), QVariantList() << QString("$ref:%1").arg(metaEnum.name()));
}
template<typename ObjectType>
void JsonHandler::registerObject()
{
qRegisterMetaType<QVariant::Type>();
QMetaObject metaObject = ObjectType::staticMetaObject;
QString className = QString(metaObject.className()).split("::").last();
QVariantMap description;
for (int i = 0; i < metaObject.propertyCount(); i++) {
QMetaProperty metaProperty = metaObject.property(i);
QString name = metaProperty.name();
if (name == "objectName") {
continue; // Skip QObject's objectName property
}
if (metaProperty.isUser()) {
name.prepend("o:");
}
QVariant typeName;
// qWarning() << ".-.-.-.-.-" << metaProperty.name() << metaProperty.type() << metaProperty.typeName();
if (metaProperty.type() == QVariant::UserType) {
if (metaProperty.typeName() == QStringLiteral("QVariant::Type")) {
typeName = QString("$ref:BasicType");
} else if (QString(metaProperty.typeName()).startsWith("QList")) {
typeName = QVariantList() << "$ref:" + QString(metaProperty.typeName()).remove("QList<").remove(">");
} else {
typeName = QString("$ref:%1").arg(QString(metaProperty.typeName()).split("::").last());
}
} else if (metaProperty.isEnumType()) {
typeName = QString("$ref:%1").arg(QString(metaProperty.typeName()).split("::").last());
} else if (metaProperty.isFlagType()) {
typeName = QVariantList() << "$ref:" + m_flagsEnums.value(metaProperty.name());
} else if (metaProperty.type() == QVariant::List) {
typeName = QVariantList() << enumValueName(Variant);
} else {
typeName = enumValueName(variantTypeToBasicType(metaProperty.type()));
}
description.insert(name, typeName);
}
m_objects.insert(className, description);
m_metaObjects.insert(className, metaObject);
}
template<typename ObjectType, typename ListType>
void JsonHandler::registerObject()
{
registerObject<ObjectType>();
QMetaObject metaObject = ObjectType::staticMetaObject;
QMetaObject listMetaObject = ListType::staticMetaObject;
m_objects.insert(listMetaObject.className(), QVariantList() << QVariant(QString("$ref:%1").arg(metaObject.className())));
m_metaObjects.insert(listMetaObject.className(), listMetaObject);
m_listMetaObjects.insert(listMetaObject.className(), listMetaObject);
m_listEntryTypes.insert(listMetaObject.className(), metaObject.className());
Q_ASSERT_X(listMetaObject.indexOfProperty("count") >= 0, "JsonHandler", "List type does not implement \"count\" property!");
Q_ASSERT_X(listMetaObject.indexOfMethod("get(int)") >= 0, "JsonHandler", "List type does not implement \"Q_INVOKABLE QVariant get(int index)\" method!");
}
//template<typename T>
//void JsonHandler::registerList()
//{
// QMetaObject metaObject = T::staticMetaObject;
// m_lists.insert(metaObject.className(), metaObject);
// m_objects.insert(metaObject.classInfo(), QVariantList() << )
//}
template<typename T> template<typename T>
QString JsonHandler::enumRef() QString JsonHandler::enumRef()
{ {
@ -96,4 +188,12 @@ T JsonHandler::enumNameToValue(const QString &name)
return static_cast<T>(metaEnum.keyToValue(name.toUtf8())); return static_cast<T>(metaEnum.keyToValue(name.toUtf8()));
} }
template<typename T>
QVariantMap JsonHandler::pack(const T &value) const
{
QMetaObject metaObject = T::staticMetaObject;
return pack(metaObject, static_cast<const void*>(&value));
}
#endif // JSONHANDLER_H #endif // JSONHANDLER_H

6
libnymea/libnymea.pro
View File

@ -26,8 +26,7 @@ HEADERS += \
devices/browseresult.h \ devices/browseresult.h \
jsonrpc/jsonhandler.h \ jsonrpc/jsonhandler.h \
jsonrpc/jsonreply.h \ jsonrpc/jsonreply.h \
experiences/experienceplugin.h \ jsonrpc/jsonrpcserver.h \
jsonrpc/jsonrpcserver.h \
libnymea.h \ libnymea.h \
platform/package.h \ platform/package.h \
platform/repository.h \ platform/repository.h \
@ -109,8 +108,7 @@ SOURCES += \
devices/browseresult.cpp \ devices/browseresult.cpp \
jsonrpc/jsonhandler.cpp \ jsonrpc/jsonhandler.cpp \
jsonrpc/jsonreply.cpp \ jsonrpc/jsonreply.cpp \
experiences/experienceplugin.cpp \ jsonrpc/jsonrpcserver.cpp \
jsonrpc/jsonrpcserver.cpp \
loggingcategories.cpp \ loggingcategories.cpp \
nymeasettings.cpp \ nymeasettings.cpp \
platform/package.cpp \ platform/package.cpp \

7
libnymea/time/calendaritem.cpp
View File

@ -19,8 +19,8 @@
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*! /*!
\class nymeaserver::CalendarItem \class CalendarItem
\brief Describes a clendar item for a time based \l{nymeaserver::Rule}{Rule}. \brief Describes a clendar item.
\ingroup rules \ingroup rules
\inmodule core \inmodule core
@ -33,8 +33,6 @@
#include <QDebug> #include <QDebug>
namespace nymeaserver {
/*! Construct a invalid \l{CalendarItem}. */ /*! Construct a invalid \l{CalendarItem}. */
CalendarItem::CalendarItem(): CalendarItem::CalendarItem():
m_duration(0) m_duration(0)
@ -275,5 +273,4 @@ QDebug operator<<(QDebug dbg, const CalendarItem &calendarItem)
return dbg; return dbg;
} }
}

8
libnymea/time/calendaritem.h
View File

@ -25,10 +25,13 @@
#include "repeatingoption.h" #include "repeatingoption.h"
namespace nymeaserver {
class CalendarItem class CalendarItem
{ {
Q_GADGET
Q_PROPERTY(uint duration READ duration WRITE setDuration)
Q_PROPERTY(QDateTime datetime READ dateTime WRITE setDateTime USER true)
Q_PROPERTY(QTime startTime READ startTime WRITE setStartTime USER true)
Q_PROPERTY(RepeatingOption repeating READ repeatingOption WRITE setRepeatingOption USER true)
public: public:
CalendarItem(); CalendarItem();
@ -64,6 +67,5 @@ private:
}; };
QDebug operator<<(QDebug dbg, const CalendarItem &calendarItem); QDebug operator<<(QDebug dbg, const CalendarItem &calendarItem);
}
#endif // CALENDARITEM_H #endif // CALENDARITEM_H

4
libnymea/time/repeatingoption.cpp
View File

@ -83,8 +83,6 @@
#include <QDateTime> #include <QDateTime>
namespace nymeaserver {
/*! Constructs an empty \l{RepeatingOption}. */ /*! Constructs an empty \l{RepeatingOption}. */
RepeatingOption::RepeatingOption() : RepeatingOption::RepeatingOption() :
m_mode(RepeatingModeNone) m_mode(RepeatingModeNone)
@ -197,5 +195,3 @@ QDebug operator<<(QDebug dbg, const RepeatingOption &repeatingOption)
dbg.nospace() << "RepeatingOption(Mode:" << repeatingOption.mode() << ", Monthdays:" << repeatingOption.monthDays() << "Weekdays:" << repeatingOption.weekDays() << ")"; dbg.nospace() << "RepeatingOption(Mode:" << repeatingOption.mode() << ", Monthdays:" << repeatingOption.monthDays() << "Weekdays:" << repeatingOption.weekDays() << ")";
return dbg; return dbg;
} }
}

3
libnymea/time/repeatingoption.h
View File

@ -26,8 +26,6 @@
class QDateTime; class QDateTime;
namespace nymeaserver {
class RepeatingOption class RepeatingOption
{ {
Q_GADGET Q_GADGET
@ -66,6 +64,5 @@ private:
}; };
QDebug operator<<(QDebug dbg, const RepeatingOption &RepeatingOption); QDebug operator<<(QDebug dbg, const RepeatingOption &RepeatingOption);
}
#endif // REPEATINGOPTION_H #endif // REPEATINGOPTION_H

4
libnymea/time/timedescriptor.cpp
View File

@ -36,8 +36,6 @@
#include <QDebug> #include <QDebug>
namespace nymeaserver {
/*! Constructs an invalid \l{TimeDescriptor}.*/ /*! Constructs an invalid \l{TimeDescriptor}.*/
TimeDescriptor::TimeDescriptor() TimeDescriptor::TimeDescriptor()
{ {
@ -119,5 +117,3 @@ QDebug operator<<(QDebug dbg, const TimeDescriptor &timeDescriptor)
} }
return dbg; return dbg;
} }
}

3
libnymea/time/timedescriptor.h
View File

@ -24,8 +24,6 @@
#include "timeeventitem.h" #include "timeeventitem.h"
#include "calendaritem.h" #include "calendaritem.h"
namespace nymeaserver {
class TimeDescriptor class TimeDescriptor
{ {
public: public:
@ -54,6 +52,5 @@ private:
QDebug operator<<(QDebug dbg, const TimeDescriptor &timeDescriptor); QDebug operator<<(QDebug dbg, const TimeDescriptor &timeDescriptor);
}
#endif // TIMEDESCRIPTOR_H #endif // TIMEDESCRIPTOR_H

3
libnymea/time/timeeventitem.cpp
View File

@ -33,8 +33,6 @@
#include <QDebug> #include <QDebug>
namespace nymeaserver {
/*! Constructs an invalid \l{TimeEventItem}. */ /*! Constructs an invalid \l{TimeEventItem}. */
TimeEventItem::TimeEventItem() TimeEventItem::TimeEventItem()
{ {
@ -141,4 +139,3 @@ QDebug operator<<(QDebug dbg, const TimeEventItem &timeEventItem)
return dbg; return dbg;
} }
}

3
libnymea/time/timeeventitem.h
View File

@ -25,8 +25,6 @@
#include "repeatingoption.h" #include "repeatingoption.h"
namespace nymeaserver {
class TimeEventItem class TimeEventItem
{ {
public: public:
@ -56,6 +54,5 @@ private:
QDebug operator<<(QDebug dbg, const TimeEventItem &timeEventItem); QDebug operator<<(QDebug dbg, const TimeEventItem &timeEventItem);
}
#endif // TIMEEVENTITEM_H #endif // TIMEEVENTITEM_H

10
libnymea/types/action.cpp
View File

@ -73,12 +73,22 @@ ActionTypeId Action::actionTypeId() const
return m_actionTypeId; return m_actionTypeId;
} }
void Action::setActionTypeId(const ActionTypeId &actionTypeId)
{
m_actionTypeId = actionTypeId;
}
/*! Returns the deviceId this Action is associated with. */ /*! Returns the deviceId this Action is associated with. */
DeviceId Action::deviceId() const DeviceId Action::deviceId() const
{ {
return m_deviceId; return m_deviceId;
} }
void Action::setDeviceId(const DeviceId &deviceId)
{
m_deviceId = deviceId;
}
/*! Returns the parameters for this Action. */ /*! Returns the parameters for this Action. */
ParamList Action::params() const ParamList Action::params() const
{ {

7
libnymea/types/action.h
View File

@ -32,6 +32,11 @@
class LIBNYMEA_EXPORT Action class LIBNYMEA_EXPORT Action
{ {
Q_GADGET
Q_PROPERTY(QUuid actionTypeId READ actionTypeId WRITE setActionTypeId)
Q_PROPERTY(QUuid deviceId READ deviceId WRITE setDeviceId)
Q_PROPERTY(ParamList params READ params WRITE setParams USER true)
public: public:
explicit Action(const ActionTypeId &actionTypeId = ActionTypeId(), const DeviceId &deviceId = DeviceId()); explicit Action(const ActionTypeId &actionTypeId = ActionTypeId(), const DeviceId &deviceId = DeviceId());
Action(const Action &other); Action(const Action &other);
@ -41,7 +46,9 @@ public:
bool isValid() const; bool isValid() const;
ActionTypeId actionTypeId() const; ActionTypeId actionTypeId() const;
void setActionTypeId(const ActionTypeId &actionTypeId);
DeviceId deviceId() const; DeviceId deviceId() const;
void setDeviceId(const DeviceId &deviceId);
ParamList params() const; ParamList params() const;
void setParams(const ParamList &params); void setParams(const ParamList &params);

5
libnymea/types/actiontype.cpp
View File

@ -123,6 +123,11 @@ ActionTypes::ActionTypes(const QList<ActionType> &other)
} }
} }
QVariant ActionTypes::get(int index)
{
return QVariant::fromValue(at(index));
}
ActionType ActionTypes::findByName(const QString &name) ActionType ActionTypes::findByName(const QString &name)
{ {
foreach (const ActionType &actionType, *this) { foreach (const ActionType &actionType, *this) {

12
libnymea/types/actiontype.h
View File

@ -32,6 +32,13 @@
class LIBNYMEA_EXPORT ActionType class LIBNYMEA_EXPORT ActionType
{ {
Q_GADGET
Q_PROPERTY(QUuid id READ id)
Q_PROPERTY(QString name READ name WRITE setName)
Q_PROPERTY(QString displayName READ displayName WRITE setDisplayName)
Q_PROPERTY(int index READ index WRITE setIndex)
Q_PROPERTY(ParamTypes paramTypes READ paramTypes WRITE setParamTypes)
public: public:
ActionType(const ActionTypeId &id = ActionTypeId()); ActionType(const ActionTypeId &id = ActionTypeId());
@ -59,16 +66,21 @@ private:
int m_index; int m_index;
ParamTypes m_paramTypes; ParamTypes m_paramTypes;
}; };
Q_DECLARE_METATYPE(ActionType)
QDebug operator<<(QDebug dbg, const ActionType &actionType); QDebug operator<<(QDebug dbg, const ActionType &actionType);
class ActionTypes: public QList<ActionType> class ActionTypes: public QList<ActionType>
{ {
Q_GADGET
Q_PROPERTY(int count READ count)
public: public:
ActionTypes() = default; ActionTypes() = default;
ActionTypes(const QList<ActionType> &other); ActionTypes(const QList<ActionType> &other);
Q_INVOKABLE QVariant get(int index);
ActionType findByName(const QString &name); ActionType findByName(const QString &name);
ActionType findById(const ActionTypeId &id); ActionType findById(const ActionTypeId &id);
}; };
Q_DECLARE_METATYPE(ActionTypes)
#endif // ACTIONTYPE_H #endif // ACTIONTYPE_H

10
libnymea/types/browseritem.h
View File

@ -33,6 +33,16 @@
class LIBNYMEA_EXPORT BrowserItem class LIBNYMEA_EXPORT BrowserItem
{ {
Q_GADGET Q_GADGET
Q_PROPERTY(QString id READ id)
Q_PROPERTY(QString displayName READ displayName)
Q_PROPERTY(QString description READ description)
Q_PROPERTY(BrowserIcon icon READ icon)
Q_PROPERTY(QString thumbnail READ thumbnail)
Q_PROPERTY(bool executable READ executable)
Q_PROPERTY(bool browsable READ browsable)
Q_PROPERTY(bool disabled READ disabled)
Q_PROPERTY(QList<ActionTypeId> actionTypeIds READ actionTypeIds)
public: public:
enum BrowserIcon { enum BrowserIcon {
BrowserIconNone, BrowserIconNone,

17
libnymea/types/deviceclass.h
View File

@ -38,6 +38,22 @@
class LIBNYMEA_EXPORT DeviceClass class LIBNYMEA_EXPORT DeviceClass
{ {
Q_GADGET Q_GADGET
Q_PROPERTY(QUuid id READ id)
Q_PROPERTY(QUuid vendorId READ vendorId)
Q_PROPERTY(QUuid pluginId READ pluginId)
Q_PROPERTY(QString name READ name)
Q_PROPERTY(QString displayName READ displayName)
Q_PROPERTY(QStringList interfaces READ interfaces)
Q_PROPERTY(bool browsable READ browsable)
Q_PROPERTY(SetupMethod setupMethod READ setupMethod)
Q_PROPERTY(CreateMethods createMethods READ createMethods)
Q_PROPERTY(StateTypes stateTypes READ stateTypes)
Q_PROPERTY(EventTypes eventTypes READ eventTypes)
Q_PROPERTY(ActionTypes actionTypes READ actionTypes)
Q_PROPERTY(ActionTypes browserItemActionTypes READ browserItemActionTypes)
Q_PROPERTY(ParamTypes paramTypes READ paramTypes)
Q_PROPERTY(ParamTypes settingsTypes READ settingsTypes)
Q_PROPERTY(ParamTypes discoveryParamTypes READ discoveryParamTypes)
public: public:
enum CreateMethod { enum CreateMethod {
@ -47,6 +63,7 @@ public:
}; };
Q_ENUM(CreateMethod) Q_ENUM(CreateMethod)
Q_DECLARE_FLAGS(CreateMethods, CreateMethod) Q_DECLARE_FLAGS(CreateMethods, CreateMethod)
Q_FLAG(CreateMethods)
enum SetupMethod { enum SetupMethod {
SetupMethodJustAdd, SetupMethodJustAdd,

2
libnymea/types/event.cpp
View File

@ -108,7 +108,7 @@ Param Event::param(const ParamTypeId &paramTypeId) const
return param; return param;
} }
} }
return Param(QString()); return Param(paramTypeId);
} }
/*! Returns true if this event is autogenerated by a state change. */ /*! Returns true if this event is autogenerated by a state change. */

4
libnymea/types/event.h
View File

@ -34,6 +34,10 @@
class LIBNYMEA_EXPORT Event class LIBNYMEA_EXPORT Event
{ {
Q_GADGET
Q_PROPERTY(QUuid eventTypeId READ eventTypeId)
Q_PROPERTY(QUuid deviceId READ deviceId)
Q_PROPERTY(ParamList params READ params)
public: public:
Event(); Event();
Event(const EventTypeId &eventTypeId, const DeviceId &deviceId, const ParamList &params = ParamList(), bool isStateChangeEvent = false); Event(const EventTypeId &eventTypeId, const DeviceId &deviceId, const ParamList &params = ParamList(), bool isStateChangeEvent = false);

10
libnymea/types/eventtype.cpp
View File

@ -33,6 +33,11 @@
#include "eventtype.h" #include "eventtype.h"
EventType::EventType()
{
}
/*! Constructs a EventType object with the given \a id. */ /*! Constructs a EventType object with the given \a id. */
EventType::EventType(const EventTypeId &id): EventType::EventType(const EventTypeId &id):
m_id(id), m_id(id),
@ -123,6 +128,11 @@ EventTypes::EventTypes(const QList<EventType> &other)
} }
} }
QVariant EventTypes::get(int index)
{
return QVariant::fromValue(at(index));
}
EventType EventTypes::findByName(const QString &name) EventType EventTypes::findByName(const QString &name)
{ {
foreach (const EventType &eventType, *this) { foreach (const EventType &eventType, *this) {

13
libnymea/types/eventtype.h
View File

@ -32,7 +32,15 @@
class LIBNYMEA_EXPORT EventType class LIBNYMEA_EXPORT EventType
{ {
Q_GADGET
Q_PROPERTY(QUuid id READ id)
Q_PROPERTY(QString name READ name WRITE setName)
Q_PROPERTY(QString displayName READ displayName WRITE setDisplayName)
Q_PROPERTY(int index READ index)
Q_PROPERTY(ParamTypes paramTypes READ paramTypes WRITE setParamTypes)
public: public:
EventType();
EventType(const EventTypeId &id); EventType(const EventTypeId &id);
EventTypeId id() const; EventTypeId id() const;
@ -61,14 +69,19 @@ private:
int m_index; int m_index;
QList<ParamType> m_paramTypes; QList<ParamType> m_paramTypes;
}; };
Q_DECLARE_METATYPE(EventType)
class EventTypes: public QList<EventType> class EventTypes: public QList<EventType>
{ {
Q_GADGET
Q_PROPERTY(int count READ count)
public: public:
EventTypes() = default; EventTypes() = default;
EventTypes(const QList<EventType> &other); EventTypes(const QList<EventType> &other);
Q_INVOKABLE QVariant get(int index);
EventType findByName(const QString &name); EventType findByName(const QString &name);
EventType findById(const EventTypeId &id); EventType findById(const EventTypeId &id);
}; };
Q_DECLARE_METATYPE(EventTypes)
#endif // TRIGGERTYPE_H #endif // TRIGGERTYPE_H

2
libnymea/types/mediabrowseritem.h
View File

@ -28,6 +28,8 @@
class MediaBrowserItem: public BrowserItem class MediaBrowserItem: public BrowserItem
{ {
Q_GADGET Q_GADGET
Q_PROPERTY(MediaBrowserIcon mediaIcon READ mediaIcon)
public: public:
enum MediaBrowserIcon { enum MediaBrowserIcon {
MediaBrowserIconNone = 1, MediaBrowserIconNone = 1,

5
libnymea/types/param.cpp
View File

@ -109,6 +109,11 @@ ParamList::ParamList(const QList<Param> &other): QList<Param>(other)
} }
QVariant ParamList::get(int index)
{
return QVariant::fromValue(at(index));
}
/*! Returns true if this ParamList contains a Param with the given \a paramTypeId. */ /*! Returns true if this ParamList contains a Param with the given \a paramTypeId. */
bool ParamList::hasParam(const ParamTypeId &paramTypeId) const bool ParamList::hasParam(const ParamTypeId &paramTypeId) const
{ {

8
libnymea/types/param.h
View File

@ -32,6 +32,9 @@
class LIBNYMEA_EXPORT Param class LIBNYMEA_EXPORT Param
{ {
Q_GADGET
Q_PROPERTY(QUuid paramTypeId READ paramTypeId)
Q_PROPERTY(QVariant value READ value WRITE setValue)
public: public:
Param(const ParamTypeId &paramTypeId = ParamTypeId(), const QVariant &value = QVariant()); Param(const ParamTypeId &paramTypeId = ParamTypeId(), const QVariant &value = QVariant());
@ -52,9 +55,12 @@ QDebug operator<<(QDebug dbg, const Param &param);
class LIBNYMEA_EXPORT ParamList: public QList<Param> class LIBNYMEA_EXPORT ParamList: public QList<Param>
{ {
Q_GADGET
Q_PROPERTY(int count READ count)
public: public:
ParamList(); ParamList();
ParamList(const QList<Param> &other); ParamList(const QList<Param> &other);
Q_INVOKABLE QVariant get(int index);
bool hasParam(const ParamTypeId &paramTypeId) const; bool hasParam(const ParamTypeId &paramTypeId) const;
QVariant paramValue(const ParamTypeId &paramTypeId) const; QVariant paramValue(const ParamTypeId &paramTypeId) const;
bool setParamValue(const ParamTypeId &paramTypeId, const QVariant &value); bool setParamValue(const ParamTypeId &paramTypeId, const QVariant &value);
@ -64,7 +70,7 @@ private:
QList<ParamTypeId> m_ids; QList<ParamTypeId> m_ids;
}; };
Q_DECLARE_METATYPE(ParamList)
QDebug operator<<(QDebug dbg, const ParamList &params); QDebug operator<<(QDebug dbg, const ParamList &params);
#endif // PARAM_H #endif // PARAM_H

5
libnymea/types/paramtype.cpp
View File

@ -255,6 +255,11 @@ ParamTypes::ParamTypes(const QList<ParamType> &other): QList<ParamType>(other)
{ {
} }
QVariant ParamTypes::get(int index)
{
return QVariant::fromValue(at(index));
}
ParamType ParamTypes::findByName(const QString &name) ParamType ParamTypes::findByName(const QString &name)
{ {
foreach (const ParamType &paramType, *this) { foreach (const ParamType &paramType, *this) {

19
libnymea/types/paramtype.h
View File

@ -32,6 +32,20 @@
class LIBNYMEA_EXPORT ParamType class LIBNYMEA_EXPORT ParamType
{ {
Q_GADGET
Q_PROPERTY(QUuid id READ id)
Q_PROPERTY(QString name READ name WRITE setName)
Q_PROPERTY(QString displayName READ displayName WRITE setDisplayName)
Q_PROPERTY(QVariant::Type type READ type WRITE setType)
Q_PROPERTY(int index READ index WRITE setIndex)
Q_PROPERTY(QVariant defaultValue READ defaultValue WRITE setDefaultValue USER true)
Q_PROPERTY(QVariant minValue READ minValue WRITE setMinValue USER true)
Q_PROPERTY(QVariant maxValue READ maxValue WRITE setMaxValue USER true)
Q_PROPERTY(QVariantList allowedValues READ allowedValues WRITE setAllowedValues USER true)
Q_PROPERTY(Types::InputType inputType READ inputType WRITE setInputType USER true)
Q_PROPERTY(Types::Unit unit READ unit WRITE setUnit USER true)
Q_PROPERTY(bool readOnly READ readOnly WRITE setReadOnly USER true)
public: public:
ParamType() = default; ParamType() = default;
ParamType(const ParamTypeId &id, const QString &name, const QVariant::Type type, const QVariant &defaultValue = QVariant()); ParamType(const ParamTypeId &id, const QString &name, const QVariant::Type type, const QVariant &defaultValue = QVariant());
@ -96,12 +110,17 @@ private:
class ParamTypes: public QList<ParamType> class ParamTypes: public QList<ParamType>
{ {
Q_GADGET
Q_PROPERTY(int count READ count)
public: public:
ParamTypes() = default; ParamTypes() = default;
ParamTypes(const QList<ParamType> &other); ParamTypes(const QList<ParamType> &other);
Q_INVOKABLE QVariant get(int index);
ParamType findByName(const QString &name); ParamType findByName(const QString &name);
ParamType findById(const ParamTypeId &id); ParamType findById(const ParamTypeId &id);
}; };
Q_DECLARE_METATYPE(QList<ParamType>)
Q_DECLARE_METATYPE(ParamTypes)
QDebug operator<<(QDebug dbg, const ParamType &paramType); QDebug operator<<(QDebug dbg, const ParamType &paramType);
QDebug operator<<(QDebug dbg, const QList<ParamType> &paramTypes); QDebug operator<<(QDebug dbg, const QList<ParamType> &paramTypes);

20
libnymea/types/state.cpp
View File

@ -36,6 +36,11 @@
#include "state.h" #include "state.h"
State::State()
{
}
/*! Constructs a State reflecting the \l{StateType} given by \a stateTypeId /*! Constructs a State reflecting the \l{StateType} given by \a stateTypeId
* and associated with the \l{Device} given by \a deviceId */ * and associated with the \l{Device} given by \a deviceId */
State::State(const StateTypeId &stateTypeId, const DeviceId &deviceId): State::State(const StateTypeId &stateTypeId, const DeviceId &deviceId):
@ -92,3 +97,18 @@ QDebug operator<<(QDebug dbg, const QList<State> &states)
return dbg.space(); return dbg.space();
} }
States::States()
{
}
States::States(const QList<State> &other): QList<State>(other)
{
}
QVariant States::get(int index)
{
return QVariant::fromValue(at(index));
}

17
libnymea/types/state.h
View File

@ -32,7 +32,12 @@
class LIBNYMEA_EXPORT State class LIBNYMEA_EXPORT State
{ {
Q_GADGET
Q_PROPERTY(QUuid stateTypeId READ stateTypeId)
Q_PROPERTY(QVariant value READ value)
public: public:
State();
State(const StateTypeId &stateTypeId, const DeviceId &deviceId); State(const StateTypeId &stateTypeId, const DeviceId &deviceId);
StateId id() const; StateId id() const;
@ -49,6 +54,18 @@ private:
DeviceId m_deviceId; DeviceId m_deviceId;
QVariant m_value; QVariant m_value;
}; };
Q_DECLARE_METATYPE(State)
class States: public QList<State>
{
Q_GADGET
Q_PROPERTY(int count READ count)
public:
States();
States(const QList<State> &other);
Q_INVOKABLE QVariant get(int index);
};
Q_DECLARE_METATYPE(States)
QDebug operator<<(QDebug dbg, const State &event); QDebug operator<<(QDebug dbg, const State &event);
QDebug operator<<(QDebug dbg, const QList<State> &events); QDebug operator<<(QDebug dbg, const QList<State> &events);

10
libnymea/types/statetype.cpp
View File

@ -34,6 +34,11 @@
#include "statetype.h" #include "statetype.h"
StateType::StateType()
{
}
/*! Constructs a StateType with the given \a id. /*! Constructs a StateType with the given \a id.
* When creating a \l{DevicePlugin} generate a new uuid for each StateType you define and * When creating a \l{DevicePlugin} generate a new uuid for each StateType you define and
* hardcode it into the plugin json file. */ * hardcode it into the plugin json file. */
@ -193,6 +198,11 @@ StateTypes::StateTypes(const QList<StateType> &other)
} }
} }
QVariant StateTypes::get(int index)
{
return QVariant::fromValue(at(index));
}
StateType StateTypes::findByName(const QString &name) StateType StateTypes::findByName(const QString &name)
{ {
foreach (const StateType &stateType, *this) { foreach (const StateType &stateType, *this) {

18
libnymea/types/statetype.h
View File

@ -32,7 +32,20 @@
class LIBNYMEA_EXPORT StateType class LIBNYMEA_EXPORT StateType
{ {
Q_GADGET
Q_PROPERTY(QUuid id READ id)
Q_PROPERTY(QString name READ name WRITE setName)
Q_PROPERTY(QString displayName READ displayName WRITE setDisplayName)
Q_PROPERTY(QVariant::Type type READ type WRITE setType)
Q_PROPERTY(int index READ index WRITE setIndex)
Q_PROPERTY(QVariant defaultValue READ defaultValue WRITE setDefaultValue)
Q_PROPERTY(Types::Unit unit READ unit WRITE setUnit USER true)
Q_PROPERTY(QVariant minValue READ minValue WRITE setMinValue USER true)
Q_PROPERTY(QVariant maxValue READ maxValue WRITE setMaxValue USER true)
Q_PROPERTY(QVariantList possibleValues READ possibleValues WRITE setPossibleValues USER true)
public: public:
StateType();
StateType(const StateTypeId &id); StateType(const StateTypeId &id);
StateTypeId id() const; StateTypeId id() const;
@ -83,14 +96,19 @@ private:
Types::Unit m_unit = Types::UnitNone; Types::Unit m_unit = Types::UnitNone;
bool m_cached = true; bool m_cached = true;
}; };
Q_DECLARE_METATYPE(StateType)
class StateTypes: public QList<StateType> class StateTypes: public QList<StateType>
{ {
Q_GADGET
Q_PROPERTY(int count READ count)
public: public:
StateTypes() = default; StateTypes() = default;
StateTypes(const QList<StateType> &other); StateTypes(const QList<StateType> &other);
Q_INVOKABLE QVariant get(int index);
StateType findByName(const QString &name); StateType findByName(const QString &name);
StateType findById(const StateTypeId &id); StateType findById(const StateTypeId &id);
}; };
Q_DECLARE_METATYPE(StateTypes)
#endif // STATETYPE_H #endif // STATETYPE_H

5
libnymea/types/vendor.h
View File

@ -32,6 +32,11 @@
class LIBNYMEA_EXPORT Vendor class LIBNYMEA_EXPORT Vendor
{ {
Q_GADGET
Q_PROPERTY(QUuid id READ id WRITE setId)
Q_PROPERTY(QString name READ name WRITE setName)
Q_PROPERTY(QString displayName READ displayName WRITE setDisplayName)
public: public:
Vendor(const VendorId &id, const QString &name = QString()); Vendor(const VendorId &id, const QString &name = QString());

2
libnymea/typeutils.h
View File

@ -32,7 +32,7 @@
#define DECLARE_TYPE_ID(type) class type##Id: public QUuid \ #define DECLARE_TYPE_ID(type) class type##Id: public QUuid \
{ \ { \
public: \ public: \
type##Id(const QString &uuid): QUuid(uuid) {} \ type##Id(const QUuid &uuid): QUuid(uuid) {} \
type##Id(): QUuid() {} \ type##Id(): QUuid() {} \
static type##Id create##type##Id() { return type##Id(QUuid::createUuid().toString()); } \ static type##Id create##type##Id() { return type##Id(QUuid::createUuid().toString()); } \
static type##Id fromUuid(const QUuid &uuid) { return type##Id(uuid.toString()); } \ static type##Id fromUuid(const QUuid &uuid) { return type##Id(uuid.toString()); } \

8
tests/scripts/getactiontype.sh
View File

@ -2,6 +2,10 @@
if [ -z $2 ]; then if [ -z $2 ]; then
echo "usage: $0 host actionTypeId" echo "usage: $0 host actionTypeId"
else exit 1;
(echo '{"id":1, "method":"Actions.GetActionType", "params":{"actionTypeId":"'$2'"}}'; sleep 1) | nc $1 2222
fi fi
cat << EOD | nc $1 2222
{"id":0, "method":"JSONRPC.Hello"}
{"id":1, "method":"Actions.GetActionType", "params":{"actionTypeId":"$2"}}
EOD

9
tests/scripts/getactiontypes.sh
View File

@ -2,6 +2,11 @@
if [ -z $2 ]; then if [ -z $2 ]; then
echo "usage: $0 host deviceClassId" echo "usage: $0 host deviceClassId"
else exit 1
(echo '{"id":1, "method":"Devices.GetActionTypes", "params":{"deviceClassId":"'$2'"}}'; sleep 1) | nc $1 2222
fi fi
cat <<EOD | nc $1 2222
{"id":2, "method":"JSONRPC.Hello"}
{"id":1, "method":"Devices.GetActionTypes", "params":{"deviceClassId":"$2"}}
EOD

20
tests/scripts/getconfigureddevices.sh
View File

@ -1,7 +1,21 @@
#!/bin/bash #!/bin/bash
if [ -z $1 ]; then if [ -z $1 ]; then
echo "usage: $0 host" echo "usage: $0 host <token>"
else exit 1
(echo '{"id":1, "token": "'$2'", "method":"Devices.GetConfiguredDevices"}'; sleep 1) | nc $1 2222
fi fi
if [ -z $2 ]; then
cat <<EOD | nc $1 2222
{"id":0, "method":"JSONRPC.Hello"}
{"id":1, "method":"Devices.GetConfiguredDevices"}
EOD
exit 0
fi
cat <<EOD | nc $1 2222
{"id":0, "method":"JSONRPC.Hello"}
{"id":1, "token": "$2", "method":"Devices.GetConfiguredDevices"}
EOD

11
tests/scripts/geteventtype.sh Executable file
View File

@ -0,0 +1,11 @@
#!/bin/bash
if [ -z $2 ]; then
echo "usage: $0 host actionTypeId"
exit 1;
fi
cat << EOD | nc $1 2222
{"id":0, "method":"JSONRPC.Hello"}
{"id":1, "method":"Events.GetEventType", "params":{"eventTypeId":"$2"}}
EOD

8
tests/scripts/geteventtypes.sh
View File

@ -2,6 +2,10 @@
if [ -z $2 ]; then if [ -z $2 ]; then
echo "usage: $0 host deviceClassId" echo "usage: $0 host deviceClassId"
else exit 1
(echo '{"id":1, "method":"Devices.GetEventTypes", "params":{"deviceClassId":"'$2'"}}'; sleep 1) | nc $1 2222
fi fi
cat <<EOD | nc $1 2222
{"id":0, "method":"JSONRPC.Hello"}
{"id":1, "method":"Devices.GetEventTypes", "params":{"deviceClassId":"$2"}}
EOD

9
tests/scripts/getpluginconfig.sh
View File

@ -2,6 +2,11 @@
if [ -z $2 ]; then if [ -z $2 ]; then
echo "usage $0 host pluginid" echo "usage $0 host pluginid"
else exit 1
(echo '{"id":1, "method":"Devices.GetPluginConfiguration", "params":{"pluginId":"'$2'"}}'; sleep 1) | nc $1 2222
fi fi
cat << EOD | nc $1 2222
{"id":0, "method": "JSONRPC.Hello"}
{"id":1, "method":"Devices.GetPluginConfiguration", "params":{"pluginId":"$2"}}
EOD

8
tests/scripts/getplugins.sh
View File

@ -2,6 +2,10 @@
if [ -z $1 ]; then if [ -z $1 ]; then
echo "usage $0 host" echo "usage $0 host"
else exit 1
(echo '{"id":1, "method":"Devices.GetPlugins"}'; sleep 1) | nc $1 2222
fi fi
cat << EOD | nc $1 2222
{"id":0, "method": "JSONRPC.Hello"}
{"id":1, "method": "Devices.GetPlugins"}
EOD

22
tests/scripts/getsupporteddevices.sh
View File

@ -1,9 +1,21 @@
#!/bin/bash #!/bin/bash
if [ -z $1 ]; then if [ -z $1 ]; then
echo "usage $0 host" echo "usage $0 host [vendorId]"
elif [ -z $2 ]; then exit 1;
(echo '{"id":1, "method":"Devices.GetSupportedDevices"}'; sleep 1) | nc $1 2222
else
(echo '{"id":1, "method":"Devices.GetSupportedDevices", "params":{"vendorId":"'$2'"}}'; sleep 1) | nc $1 2222
fi fi
if [ -z $2 ]; then
cat << EOD | nc $1 2222
{"id":0, "method": "JSONRPC.Hello"}
{"id":1, "method": "Devices.GetSupportedDevices"}
EOD
else
cat << EOD | nc $1 2222
{"id":0, "method": "JSONRPC.Hello"}
{"id":1, "method": "Devices.GetSupportedDevices", "params":{"vendorId":"$2"}}
EOD
fi

11
tests/scripts/token.sh Executable file
View File

@ -0,0 +1,11 @@
#!/bin/bash
if [ -z $1 ]; then
echo "usage: $0 host"
exit 1;
fi
cat << EOD | nc $1 2222
{"id":0, "method":"JSONRPC.Hello"}
{"id":1, "method":"JSONRPC.Tokens"}
EOD