ETM-Schurig
/
nymea
mirror of https://github.com/nymea/nymea.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

drop all pack/unpack methds

pull/228/head
Michael Zanetti 2019-11-03 21:24:16 +01:00
parent 9c5d21270e
commit 3cbd01c1d2
66 changed files with 631 additions and 938 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
libnymea-core/devices/translator.cpp
View File

@ -48,6 +48,10 @@ Translator::~Translator()
QString Translator::translate(const PluginId &pluginId, const QString &string, const QLocale &locale)
{
DevicePlugin *plugin = m_deviceManager->plugins().findById(pluginId);
if (!plugin) {
qCWarning(dcDeviceManager()) << "Unable to translate" << string << "Plugin not found";
return string;
}
if (!m_translatorContexts.contains(plugin->pluginId()) || !m_translatorContexts.value(plugin->pluginId()).translators.contains(locale.name())) {
loadTranslator(plugin, locale);

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

@ -33,7 +33,6 @@
*/
#include "actionhandler.h"
#include "devicehandler.h"
#include "nymeacore.h"
#include "devices/devicemanager.h"
@ -105,7 +104,7 @@ JsonReply* ActionHandler::ExecuteAction(const QVariantMap &params)
{
DeviceId deviceId(params.value("deviceId").toString());
ActionTypeId actionTypeId(params.value("actionTypeId").toString());
ParamList actionParams = DeviceHandler::unpackParams(params.value("params").toList());
ParamList actionParams = unpack<ParamList>(params.value("params"));
QLocale locale = params.value("locale").toLocale();
Action action(actionTypeId, deviceId);
@ -174,7 +173,7 @@ JsonReply *ActionHandler::ExecuteBrowserItemAction(const QVariantMap &params)
DeviceId deviceId = DeviceId(params.value("deviceId").toString());
QString itemId = params.value("itemId").toString();
ActionTypeId actionTypeId = ActionTypeId(params.value("actionTypeId").toString());
ParamList paramList = DeviceHandler::unpackParams(params.value("params").toList());
ParamList paramList = unpack<ParamList>(params.value("params"));
BrowserItemAction browserItemAction(deviceId, itemId, actionTypeId, paramList);
JsonReply *jsonReply = createAsyncReply("ExecuteBrowserItemAction");

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

@ -90,7 +90,7 @@ DeviceHandler::DeviceHandler(QObject *parent) :
// Objects
registerObject<ParamType, ParamTypes>();
registerObject<Param, ParamList>();
registerObject<DevicePlugin>();
registerUncreatableObject<DevicePlugin>();
registerObject<Vendor>();
registerObject<EventType, EventTypes>();
registerObject<StateType, StateTypes>();
@ -98,7 +98,7 @@ DeviceHandler::DeviceHandler(QObject *parent) :
registerObject<DeviceClass>();
registerObject<DeviceDescriptor>();
registerObject<State, States>();
registerObject<Device>();
registerUncreatableObject<Device>();
// Regsitering browseritem manually for now. Not sure how to deal with the
// polymorphism in int (e.g MediaBrowserItem)
@ -409,8 +409,7 @@ JsonReply *DeviceHandler::GetDiscoveredDevices(const QVariantMap &params) const
QVariantMap returns;
DeviceClassId deviceClassId = DeviceClassId(params.value("deviceClassId").toString());
ParamList discoveryParams = unpackParams(params.value("discoveryParams").toList());
ParamList discoveryParams = unpack<ParamList>(params.value("discoveryParams"));
JsonReply *reply = createAsyncReply("GetDiscoveredDevices");
DeviceDiscoveryInfo *info = NymeaCore::instance()->deviceManager()->discoverDevices(deviceClassId, discoveryParams);
@ -476,7 +475,7 @@ JsonReply* DeviceHandler::SetPluginConfiguration(const QVariantMap &params)
{
QVariantMap returns;
PluginId pluginId = PluginId(params.value("pluginId").toString());
ParamList pluginParams = unpackParams(params.value("configuration").toList());
ParamList pluginParams = unpack<ParamList>(params.value("configuration"));
Device::DeviceError result = NymeaCore::instance()->deviceManager()->setPluginConfig(pluginId, pluginParams);
returns.insert("deviceError",enumValueName<Device::DeviceError>(result));
return createReply(returns);
@ -486,7 +485,7 @@ JsonReply* DeviceHandler::AddConfiguredDevice(const QVariantMap &params)
{
DeviceClassId deviceClassId(params.value("deviceClassId").toString());
QString deviceName = params.value("name").toString();
ParamList deviceParams = unpackParams(params.value("deviceParams").toList());
ParamList deviceParams = unpack<ParamList>(params.value("deviceParams"));
DeviceDescriptorId deviceDescriptorId(params.value("deviceDescriptorId").toString());
QLocale locale = params.value("locale").toLocale();
@ -519,7 +518,7 @@ JsonReply* DeviceHandler::AddConfiguredDevice(const QVariantMap &params)
JsonReply *DeviceHandler::PairDevice(const QVariantMap &params)
{
QString deviceName = params.value("name").toString();
ParamList deviceParams = unpackParams(params.value("deviceParams").toList());
ParamList deviceParams = unpack<ParamList>(params.value("deviceParams"));
QLocale locale = params.value("locale").toLocale();
DevicePairingInfo *info;
@ -598,11 +597,11 @@ JsonReply* DeviceHandler::GetConfiguredDevices(const QVariantMap &params) const
returns.insert("deviceError", enumValueName<Device::DeviceError>(Device::DeviceErrorDeviceNotFound));
return createReply(returns);
} else {
configuredDeviceList.append(packDevice(device));
configuredDeviceList.append(pack(device));
}
} else {
foreach (Device *device, NymeaCore::instance()->deviceManager()->configuredDevices()) {
configuredDeviceList.append(packDevice(device));
configuredDeviceList.append(pack(device));
}
}
returns.insert("devices", configuredDeviceList);
@ -612,7 +611,7 @@ JsonReply* DeviceHandler::GetConfiguredDevices(const QVariantMap &params) const
JsonReply *DeviceHandler::ReconfigureDevice(const QVariantMap &params)
{
DeviceId deviceId = DeviceId(params.value("deviceId").toString());
ParamList deviceParams = unpackParams(params.value("deviceParams").toList());
ParamList deviceParams = unpack<ParamList>(params.value("deviceParams"));
DeviceDescriptorId deviceDescriptorId(params.value("deviceDescriptorId").toString());
QLocale locale = params.value("locale").toLocale();
@ -692,34 +691,32 @@ JsonReply* DeviceHandler::RemoveConfiguredDevice(const QVariantMap &params)
JsonReply *DeviceHandler::SetDeviceSettings(const QVariantMap &params)
{
DeviceId deviceId = DeviceId(params.value("deviceId").toString());
ParamList settings = unpackParams(params.value("settings").toList());
ParamList settings = unpack<ParamList>(params.value("settings"));
Device::DeviceError status = NymeaCore::instance()->deviceManager()->setDeviceSettings(deviceId, settings);
return createReply(statusToReply(status));
}
JsonReply* DeviceHandler::GetEventTypes(const QVariantMap &params) const
{
QVariantMap returns;
QLocale locale = params.value("locale").toLocale();
QVariantList eventList;
DeviceClass deviceClass = NymeaCore::instance()->deviceManager()->findDeviceClass(DeviceClassId(params.value("deviceClassId").toString()));
foreach (const EventType &eventType, deviceClass.eventTypes()) {
eventList.append(packEventType(eventType, deviceClass.pluginId(), params.value("locale").toLocale()));
}
returns.insert("eventTypes", eventList);
DeviceClass translatedDeviceClass = NymeaCore::instance()->deviceManager()->translateDeviceClass(deviceClass, locale);
QVariantMap returns;
returns.insert("eventTypes", pack(translatedDeviceClass.eventTypes()));
return createReply(returns);
}
JsonReply* DeviceHandler::GetActionTypes(const QVariantMap &params) const
{
QVariantMap returns;
QLocale locale = params.value("locale").toLocale();
QVariantList actionList;
DeviceClass deviceClass = NymeaCore::instance()->deviceManager()->findDeviceClass(DeviceClassId(params.value("deviceClassId").toString()));
foreach (const ActionType &actionType, deviceClass.actionTypes()) {
actionList.append(packActionType(actionType, deviceClass.pluginId(), params.value("locale").toLocale()));
}
returns.insert("actionTypes", actionList);
DeviceClass translatedDeviceClass = NymeaCore::instance()->deviceManager()->translateDeviceClass(deviceClass, locale);
QVariantMap returns;
returns.insert("actionTypes", pack(translatedDeviceClass.actionTypes()));
return createReply(returns);
}
@ -727,15 +724,11 @@ JsonReply* DeviceHandler::GetStateTypes(const QVariantMap &params) const
{
QLocale locale = params.value("locale").toLocale();
QVariantMap returns;
QVariantList stateList;
DeviceClass deviceClass = NymeaCore::instance()->deviceManager()->findDeviceClass(DeviceClassId(params.value("deviceClassId").toString()));
foreach (StateType stateType, deviceClass.stateTypes()) {
stateType.setDisplayName(NymeaCore::instance()->deviceManager()->translate(deviceClass.pluginId(), stateType.displayName(), locale));
stateList.append(pack(stateType));
}
returns.insert("stateTypes", stateList);
DeviceClass translatedDeviceClass = NymeaCore::instance()->deviceManager()->translateDeviceClass(deviceClass, locale);
QVariantMap returns;
returns.insert("stateTypes", pack(translatedDeviceClass.stateTypes()));
return createReply(returns);
}
@ -763,7 +756,7 @@ JsonReply *DeviceHandler::GetStateValues(const QVariantMap &params) const
}
QVariantMap returns = statusToReply(Device::DeviceErrorNoError);
returns.insert("values", packDeviceStates(device));
returns.insert("values", pack(device->states()));
return createReply(returns);
}
@ -811,73 +804,6 @@ JsonReply *DeviceHandler::GetBrowserItem(const QVariantMap &params) const
return jsonReply;
}
Param DeviceHandler::unpackParam(const QVariantMap &param)
{
if (param.keys().count() == 0)
return Param();
ParamTypeId paramTypeId = param.value("paramTypeId").toUuid();
QVariant value = param.value("value");
return Param(paramTypeId, value);
}
ParamList DeviceHandler::unpackParams(const QVariantList &params)
{
ParamList paramList;
foreach (const QVariant &paramVariant, params) {
paramList.append(unpackParam(paramVariant.toMap()));
}
return paramList;
}
QVariantMap DeviceHandler::packParam(const Param &param)
{
QVariantMap variantMap;
variantMap.insert("paramTypeId", param.paramTypeId().toString());
variantMap.insert("value", param.value());
return variantMap;
}
QVariantList DeviceHandler::packParams(const ParamList &paramList)
{
QVariantList ret;
foreach (const Param &param, paramList) {
ret << packParam(param);
}
return ret;
}
QVariantMap DeviceHandler::packDevice(Device *device)
{
QVariantMap variant;
variant.insert("id", device->id().toString());
variant.insert("deviceClassId", device->deviceClassId().toString());
variant.insert("name", device->name());
variant.insert("params", packParams(device->params()));
variant.insert("settings", packParams(device->settings()));
if (!device->parentId().isNull())
variant.insert("parentId", device->parentId().toString());
variant.insert("states", packDeviceStates(device));
variant.insert("setupComplete", device->setupComplete());
return variant;
}
QVariantList DeviceHandler::packDeviceStates(Device *device)
{
DeviceClass deviceClass = NymeaCore::instance()->deviceManager()->findDeviceClass(device->deviceClassId());
QVariantList stateValues;
foreach (const StateType &stateType, deviceClass.stateTypes()) {
QVariantMap stateValue;
stateValue.insert("stateTypeId", stateType.id().toString());
stateValue.insert("value", device->stateValue(stateType.id()));
stateValues.append(stateValue);
}
return stateValues;
}
QVariantMap DeviceHandler::packBrowserItem(const BrowserItem &item)
{
QVariantMap ret;
@ -900,67 +826,13 @@ QVariantMap DeviceHandler::packBrowserItem(const BrowserItem &item)
return ret;
}
QVariantMap DeviceHandler::packParamType(const ParamType &paramType, const PluginId &pluginId, const QLocale &locale) const
{
ParamType translatedParamType = paramType;
translatedParamType.setDisplayName(NymeaCore::instance()->deviceManager()->translate(pluginId, paramType.displayName(), locale));
return pack(translatedParamType).toMap();
}
QVariantMap DeviceHandler::packEventType(const EventType &eventType, const PluginId &pluginId, const QLocale &locale) const
{
QVariantMap variant;
variant.insert("id", eventType.id().toString());
variant.insert("name", eventType.name());
variant.insert("displayName", NymeaCore::instance()->deviceManager()->translate(pluginId, eventType.displayName(), locale));
variant.insert("index", eventType.index());
QVariantList paramTypes;
foreach (const ParamType &paramType, eventType.paramTypes())
paramTypes.append(packParamType(paramType, pluginId, locale));
variant.insert("paramTypes", paramTypes);
return variant;
}
QVariantMap DeviceHandler::packActionType(const ActionType &actionType, const PluginId &pluginId, const QLocale &locale) const
{
QVariantMap variantMap;
variantMap.insert("id", actionType.id().toString());
variantMap.insert("name", actionType.name());
variantMap.insert("displayName", NymeaCore::instance()->deviceManager()->translate(pluginId, actionType.displayName(), locale));
variantMap.insert("index", actionType.index());
QVariantList paramTypes;
foreach (const ParamType &paramType, actionType.paramTypes())
paramTypes.append(packParamType(paramType, pluginId, locale));
variantMap.insert("paramTypes", paramTypes);
return variantMap;
}
QVariantList DeviceHandler::packCreateMethods(DeviceClass::CreateMethods createMethods) const
{
QVariantList ret;
if (createMethods.testFlag(DeviceClass::CreateMethodUser))
ret << "CreateMethodUser";
if (createMethods.testFlag(DeviceClass::CreateMethodAuto))
ret << "CreateMethodAuto";
if (createMethods.testFlag(DeviceClass::CreateMethodDiscovery))
ret << "CreateMethodDiscovery";
return ret;
}
void DeviceHandler::pluginConfigChanged(const PluginId &id, const ParamList &config)
{
QVariantMap params;
params.insert("pluginId", id);
QVariantList configList;
foreach (const Param &param, config) {
configList << packParam(param);
configList << pack(param);
}
params.insert("configuration", configList);
emit PluginConfigurationChanged(params);
@ -985,14 +857,14 @@ void DeviceHandler::deviceRemovedNotification(const QUuid &deviceId)
void DeviceHandler::deviceAddedNotification(Device *device)
{
QVariantMap params;
params.insert("device", packDevice(device));
params.insert("device", pack(device));
emit DeviceAdded(params);
}
void DeviceHandler::deviceChangedNotification(Device *device)
{
QVariantMap params;
params.insert("device", packDevice(device));
params.insert("device", pack(device));
emit DeviceChanged(params);
}

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

@ -60,27 +60,8 @@ public:
Q_INVOKABLE JsonReply *BrowseDevice(const QVariantMap &params) const;
Q_INVOKABLE JsonReply *GetBrowserItem(const QVariantMap &params) const;
QVariantMap packParamType(const ParamType &paramType, const PluginId &pluginId, const QLocale &locale) const;
// QVariantMap packPlugin(DevicePlugin *plugin, const QLocale &locale) const;
QVariantMap packEventType(const EventType &eventType, const PluginId &pluginId, const QLocale &locale) const;
// QVariantMap packStateType(const StateType &stateType, const PluginId &pluginId, const QLocale &locale) const;
QVariantMap packActionType(const ActionType &actionType, const PluginId &pluginId, const QLocale &locale) const;
QVariantList packCreateMethods(DeviceClass::CreateMethods createMethods) const;
// QVariantMap packDeviceClass(const DeviceClass &deviceClass, const QLocale &locale) const;
QVariantMap packDeviceDescriptor(const DeviceDescriptor &descriptor) const;
static QVariantMap packParam(const Param &param);
static QVariantList packParams(const ParamList &paramList);
static QVariantMap packDevice(Device *device);
static QVariantList packDeviceStates(Device *device);
static QVariantMap packBrowserItem(const BrowserItem &item);
static Param unpackParam(const QVariantMap &param);
static ParamList unpackParams(const QVariantList &params);
signals:
void PluginConfigurationChanged(const QVariantMap &params);
void StateChanged(const QVariantMap &params);

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

@ -38,7 +38,6 @@
*/
#include "eventhandler.h"
#include "devicehandler.h"
#include "nymeacore.h"
#include "loggingcategories.h"

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

@ -58,6 +58,7 @@
#include "loggingcategories.h"
#include <QDebug>
#include <QJsonDocument>
namespace nymeaserver {
@ -245,13 +246,14 @@ JsonReply *RulesHandler::GetRuleDetails(const QVariantMap &params)
}
QVariantMap returns;
returns.insert("ruleError", enumValueName<RuleEngine::RuleError>(RuleEngine::RuleErrorNoError));
returns.insert("rule", packRule(rule));
returns.insert("rule", pack(rule));
return createReply(returns);
}
JsonReply* RulesHandler::AddRule(const QVariantMap &params)
{
Rule rule = unpackRule(params);
Rule rule = unpack<Rule>(params);
qWarning() << "Unpacked rule" << rule;
rule.setId(RuleId::createRuleId());
RuleEngine::RuleError status = NymeaCore::instance()->ruleEngine()->addRule(rule);
@ -265,11 +267,15 @@ JsonReply* RulesHandler::AddRule(const QVariantMap &params)
JsonReply *RulesHandler::EditRule(const QVariantMap &params)
{
Rule rule = unpackRule(params);
Rule rule = unpack<Rule>(params);
// FIXME: Edit rule API currently has "ruleId" while the Rule type has "id". Auto unpacking will fail for this property
rule.setId(params.value("ruleId").toUuid());
RuleEngine::RuleError status = NymeaCore::instance()->ruleEngine()->editRule(rule);
QVariantMap returns;
if (status == RuleEngine::RuleErrorNoError) {
returns.insert("rule", packRule(NymeaCore::instance()->ruleEngine()->findRule(rule.id())));
returns.insert("rule", pack(NymeaCore::instance()->ruleEngine()->findRule(rule.id())));
}
returns.insert("ruleError", enumValueName<RuleEngine::RuleError>(status));
return createReply(returns);
@ -344,7 +350,7 @@ void RulesHandler::ruleRemovedNotification(const RuleId &ruleId)
void RulesHandler::ruleAddedNotification(const Rule &rule)
{
QVariantMap params;
params.insert("rule", packRule(rule));
params.insert("rule", pack(rule));
emit RuleAdded(params);
}
@ -361,7 +367,7 @@ void RulesHandler::ruleActiveChangedNotification(const Rule &rule)
void RulesHandler::ruleConfigurationChangedNotification(const Rule &rule)
{
QVariantMap params;
params.insert("rule", packRule(rule));
params.insert("rule", pack(rule));
emit RuleConfigurationChanged(params);
}
@ -377,468 +383,4 @@ QVariantMap RulesHandler::packRuleDescription(const Rule &rule)
return ruleDescriptionMap;
}
QVariantMap RulesHandler::packParamDescriptor(const ParamDescriptor &paramDescriptor)
{
QVariantMap variantMap;
if (!paramDescriptor.paramTypeId().isNull()) {
variantMap.insert("paramTypeId", paramDescriptor.paramTypeId().toString());
} else {
variantMap.insert("paramName", paramDescriptor.paramName());
}
variantMap.insert("value", paramDescriptor.value());
variantMap.insert("operator", enumValueName<Types::ValueOperator>(paramDescriptor.operatorType()));
return variantMap;
}
QVariantMap RulesHandler::packEventDescriptor(const EventDescriptor &eventDescriptor)
{
QVariantMap variant;
if (eventDescriptor.type() == EventDescriptor::TypeDevice) {
variant.insert("eventTypeId", eventDescriptor.eventTypeId().toString());
variant.insert("deviceId", eventDescriptor.deviceId().toString());
} else {
variant.insert("interface", eventDescriptor.interface());
variant.insert("interfaceEvent", eventDescriptor.interfaceEvent());
}
QVariantList params;
foreach (const ParamDescriptor &paramDescriptor, eventDescriptor.paramDescriptors())
params.append(packParamDescriptor(paramDescriptor));
variant.insert("paramDescriptors", params);
return variant;
}
QVariantMap RulesHandler::packStateEvaluator(const StateEvaluator &stateEvaluator)
{
QVariantMap variantMap;
if (stateEvaluator.stateDescriptor().isValid())
variantMap.insert("stateDescriptor", packStateDescriptor(stateEvaluator.stateDescriptor()));
QVariantList childEvaluators;
foreach (const StateEvaluator &childEvaluator, stateEvaluator.childEvaluators())
childEvaluators.append(packStateEvaluator(childEvaluator));
if (!childEvaluators.isEmpty() || stateEvaluator.stateDescriptor().isValid())
variantMap.insert("operator", enumValueName<Types::StateOperator>(stateEvaluator.operatorType()));
if (childEvaluators.count() > 0)
variantMap.insert("childEvaluators", childEvaluators);
return variantMap;
}
QVariantMap RulesHandler::packStateDescriptor(const StateDescriptor &stateDescriptor)
{
QVariantMap variantMap;
if (stateDescriptor.type() == StateDescriptor::TypeDevice) {
variantMap.insert("stateTypeId", stateDescriptor.stateTypeId().toString());
variantMap.insert("deviceId", stateDescriptor.deviceId().toString());
} else {
variantMap.insert("interface", stateDescriptor.interface());
variantMap.insert("interfaceState", stateDescriptor.interfaceState());
}
variantMap.insert("value", stateDescriptor.stateValue());
variantMap.insert("operator", enumValueName<Types::ValueOperator>(stateDescriptor.operatorType()));
return variantMap;
}
QVariantMap RulesHandler::packTimeDescriptor(const TimeDescriptor &timeDescriptor)
{
QVariantMap timeDescriptorVariant;
if (!timeDescriptor.calendarItems().isEmpty()) {
QVariantList calendarItems;
foreach (const CalendarItem &calendarItem, timeDescriptor.calendarItems())
calendarItems.append(packCalendarItem(calendarItem));
timeDescriptorVariant.insert("calendarItems", calendarItems);
}
if (!timeDescriptor.timeEventItems().isEmpty()) {
QVariantList timeEventItems;
foreach (const TimeEventItem &timeEventItem, timeDescriptor.timeEventItems())
timeEventItems.append(packTimeEventItem(timeEventItem));
timeDescriptorVariant.insert("timeEventItems", timeEventItems);
}
return timeDescriptorVariant;
}
QVariantMap RulesHandler::packCalendarItem(const CalendarItem &calendarItem)
{
QVariantMap calendarItemVariant;
calendarItemVariant.insert("duration", calendarItem.duration());
if (!calendarItem.dateTime().isNull() && calendarItem.dateTime().toTime_t() != 0)
calendarItemVariant.insert("datetime", calendarItem.dateTime().toTime_t());
if (!calendarItem.startTime().isNull())
calendarItemVariant.insert("startTime", calendarItem.startTime().toString("hh:mm"));
if (!calendarItem.repeatingOption().isEmtpy())
calendarItemVariant.insert("repeating", packRepeatingOption(calendarItem.repeatingOption()));
return calendarItemVariant;
}
QVariantMap RulesHandler::packRepeatingOption(const RepeatingOption &option)
{
QVariantMap optionVariant;
optionVariant.insert("mode", enumValueName<RepeatingOption::RepeatingMode>(option.mode()));
if (!option.weekDays().isEmpty()) {
QVariantList weekDaysVariantList;
foreach (const int& weekDay, option.weekDays())
weekDaysVariantList.append(QVariant(weekDay));
optionVariant.insert("weekDays", weekDaysVariantList);
}
if (!option.monthDays().isEmpty()) {
QVariantList monthDaysVariantList;
foreach (const int& monthDay, option.monthDays())
monthDaysVariantList.append(QVariant(monthDay));
optionVariant.insert("monthDays", monthDaysVariantList);
}
return optionVariant;
}
QVariantMap RulesHandler::packTimeEventItem(const TimeEventItem &timeEventItem)
{
QVariantMap timeEventItemVariant;
if (!timeEventItem.dateTime().isNull() && timeEventItem.dateTime().toTime_t() != 0)
timeEventItemVariant.insert("datetime", timeEventItem.dateTime().toTime_t());
if (!timeEventItem.time().isNull())
timeEventItemVariant.insert("time", timeEventItem.time().toString("hh:mm"));
if (!timeEventItem.repeatingOption().isEmtpy())
timeEventItemVariant.insert("repeating", packRepeatingOption(timeEventItem.repeatingOption()));
return timeEventItemVariant;
}
QVariantMap RulesHandler::packRuleActionParam(const RuleActionParam &ruleActionParam)
{
QVariantMap variantMap;
if (!ruleActionParam.paramTypeId().isNull()) {
variantMap.insert("paramTypeId", ruleActionParam.paramTypeId().toString());
} else {
variantMap.insert("paramName", ruleActionParam.paramName());
}
if (ruleActionParam.isEventBased()) {
variantMap.insert("eventTypeId", ruleActionParam.eventTypeId().toString());
variantMap.insert("eventParamTypeId", ruleActionParam.eventParamTypeId().toString());
} else if (ruleActionParam.isStateBased()) {
variantMap.insert("stateDeviceId", ruleActionParam.stateDeviceId().toString());
variantMap.insert("stateTypeId", ruleActionParam.stateTypeId().toString());
} else {
variantMap.insert("value", ruleActionParam.value());
}
return variantMap;
}
QVariantMap RulesHandler::packRuleAction(const RuleAction &ruleAction)
{
QVariantMap variant;
if (ruleAction.type() == RuleAction::TypeDevice) {
variant.insert("deviceId", ruleAction.deviceId().toString());
variant.insert("actionTypeId", ruleAction.actionTypeId().toString());
} else if (ruleAction.type() == RuleAction::TypeBrowser) {
variant.insert("deviceId", ruleAction.deviceId().toString());
variant.insert("browserItemId", ruleAction.browserItemId());
} else {
variant.insert("interface", ruleAction.interface());
variant.insert("interfaceAction", ruleAction.interfaceAction());
}
QVariantList params;
foreach (const RuleActionParam &ruleActionParam, ruleAction.ruleActionParams())
params.append(packRuleActionParam(ruleActionParam));
variant.insert("ruleActionParams", params);
return variant;
}
QVariantMap RulesHandler::packRule(const Rule &rule)
{
QVariantMap ruleMap;
ruleMap.insert("id", rule.id().toString());
ruleMap.insert("name", rule.name());
ruleMap.insert("enabled", rule.enabled());
ruleMap.insert("active", rule.active());
ruleMap.insert("executable", rule.executable());
ruleMap.insert("timeDescriptor", packTimeDescriptor(rule.timeDescriptor()));
QVariantList eventDescriptorList;
foreach (const EventDescriptor &eventDescriptor, rule.eventDescriptors())
eventDescriptorList.append(packEventDescriptor(eventDescriptor));
ruleMap.insert("eventDescriptors", eventDescriptorList);
ruleMap.insert("stateEvaluator", packStateEvaluator(rule.stateEvaluator()));
QVariantList actionList;
foreach (const RuleAction &action, rule.actions())
actionList.append(packRuleAction(action));
ruleMap.insert("actions", actionList);
QVariantList exitActionList;
foreach (const RuleAction &action, rule.exitActions())
exitActionList.append(packRuleAction(action));
ruleMap.insert("exitActions", exitActionList);
return ruleMap;
}
QList<ParamDescriptor> RulesHandler::unpackParamDescriptors(const QVariantList &paramList)
{
QList<ParamDescriptor> params;
foreach (const QVariant &paramVariant, paramList)
params.append(unpackParamDescriptor(paramVariant.toMap()));
return params;
}
ParamDescriptor RulesHandler::unpackParamDescriptor(const QVariantMap &paramMap)
{
QString operatorString = paramMap.value("operator").toString();
Types::ValueOperator valueOperator = enumNameToValue<Types::ValueOperator>(operatorString);
if (paramMap.contains("paramTypeId")) {
ParamDescriptor param = ParamDescriptor(ParamTypeId(paramMap.value("paramTypeId").toString()), paramMap.value("value"));
param.setOperatorType(valueOperator);
return param;
}
ParamDescriptor param = ParamDescriptor(paramMap.value("paramName").toString(), paramMap.value("value"));
param.setOperatorType(valueOperator);
return param;
}
EventDescriptor RulesHandler::unpackEventDescriptor(const QVariantMap &eventDescriptorMap)
{
EventTypeId eventTypeId(eventDescriptorMap.value("eventTypeId").toString());
DeviceId eventDeviceId(eventDescriptorMap.value("deviceId").toString());
QString interface = eventDescriptorMap.value("interface").toString();
QString interfaceEvent = eventDescriptorMap.value("interfaceEvent").toString();
QList<ParamDescriptor> eventParams = unpackParamDescriptors(eventDescriptorMap.value("paramDescriptors").toList());
if (!eventDeviceId.isNull() && !eventTypeId.isNull()) {
return EventDescriptor(eventTypeId, eventDeviceId, eventParams);
}
return EventDescriptor(interface, interfaceEvent, eventParams);
}
RepeatingOption RulesHandler::unpackRepeatingOption(const QVariantMap &repeatingOptionMap)
{
RepeatingOption::RepeatingMode mode = enumNameToValue<RepeatingOption::RepeatingMode>(repeatingOptionMap.value("mode").toString());
QList<int> weekDays;
if (repeatingOptionMap.contains("weekDays")) {
foreach (const QVariant weekDayVariant, repeatingOptionMap.value("weekDays").toList()) {
weekDays.append(weekDayVariant.toInt());
}
}
QList<int> monthDays;
if (repeatingOptionMap.contains("monthDays")) {
foreach (const QVariant monthDayVariant, repeatingOptionMap.value("monthDays").toList()) {
monthDays.append(monthDayVariant.toInt());
}
}
return RepeatingOption(mode, weekDays, monthDays);
}
CalendarItem RulesHandler::unpackCalendarItem(const QVariantMap &calendarItemMap)
{
CalendarItem calendarItem;
calendarItem.setDuration(calendarItemMap.value("duration").toUInt());
if (calendarItemMap.contains("datetime"))
calendarItem.setDateTime(QDateTime::fromTime_t(calendarItemMap.value("datetime").toUInt()));
if (calendarItemMap.contains("startTime"))
calendarItem.setStartTime(QTime::fromString(calendarItemMap.value("startTime").toString(), "hh:mm"));
if (calendarItemMap.contains("repeating"))
calendarItem.setRepeatingOption(unpackRepeatingOption(calendarItemMap.value("repeating").toMap()));
return calendarItem;
}
TimeDescriptor RulesHandler::unpackTimeDescriptor(const QVariantMap &timeDescriptorMap)
{
TimeDescriptor timeDescriptor;
if (timeDescriptorMap.contains("calendarItems")) {
QList<CalendarItem> calendarItems;
foreach (const QVariant &calendarItemValiant, timeDescriptorMap.value("calendarItems").toList()) {
calendarItems.append(unpackCalendarItem(calendarItemValiant.toMap()));
}
timeDescriptor.setCalendarItems(calendarItems);
}
if (timeDescriptorMap.contains("timeEventItems")) {
QList<TimeEventItem> timeEventItems;
foreach (const QVariant &timeEventItemValiant, timeDescriptorMap.value("timeEventItems").toList()) {
timeEventItems.append(unpackTimeEventItem(timeEventItemValiant.toMap()));
}
timeDescriptor.setTimeEventItems(timeEventItems);
}
return timeDescriptor;
}
TimeEventItem RulesHandler::unpackTimeEventItem(const QVariantMap &timeEventItemMap)
{
TimeEventItem timeEventItem;
if (timeEventItemMap.contains("datetime"))
timeEventItem.setDateTime(QDateTime::fromTime_t(timeEventItemMap.value("datetime").toUInt()));
if (timeEventItemMap.contains("time"))
timeEventItem.setTime(timeEventItemMap.value("time").toTime());
if (timeEventItemMap.contains("repeating"))
timeEventItem.setRepeatingOption(unpackRepeatingOption(timeEventItemMap.value("repeating").toMap()));
return timeEventItem;
}
StateDescriptor RulesHandler::unpackStateDescriptor(const QVariantMap &stateDescriptorMap)
{
StateTypeId stateTypeId(stateDescriptorMap.value("stateTypeId").toString());
DeviceId deviceId(stateDescriptorMap.value("deviceId").toString());
QString interface(stateDescriptorMap.value("interface").toString());
QString interfaceState(stateDescriptorMap.value("interfaceState").toString());
QVariant value = stateDescriptorMap.value("value");
Types::ValueOperator operatorType = enumNameToValue<Types::ValueOperator>(stateDescriptorMap.value("operator").toString());
if (!deviceId.isNull() && !stateTypeId.isNull()) {
StateDescriptor stateDescriptor(stateTypeId, deviceId, value, operatorType);
return stateDescriptor;
}
StateDescriptor stateDescriptor(interface, interfaceState, value, operatorType);
return stateDescriptor;
}
StateEvaluator RulesHandler::unpackStateEvaluator(const QVariantMap &stateEvaluatorMap)
{
StateEvaluator ret(unpackStateDescriptor(stateEvaluatorMap.value("stateDescriptor").toMap()));
if (stateEvaluatorMap.contains("operator")) {
ret.setOperatorType(enumNameToValue<Types::StateOperator>(stateEvaluatorMap.value("operator").toString()));
} else {
ret.setOperatorType(Types::StateOperatorAnd);
}
QList<StateEvaluator> childEvaluators;
foreach (const QVariant &childEvaluator, stateEvaluatorMap.value("childEvaluators").toList())
childEvaluators.append(unpackStateEvaluator(childEvaluator.toMap()));
ret.setChildEvaluators(childEvaluators);
return ret;
}
RuleActionParam RulesHandler::unpackRuleActionParam(const QVariantMap &ruleActionParamMap)
{
if (ruleActionParamMap.keys().count() == 0)
return RuleActionParam();
ParamTypeId paramTypeId = ParamTypeId(ruleActionParamMap.value("paramTypeId").toString());
QString paramName = ruleActionParamMap.value("paramName").toString();
RuleActionParam param;
if (paramTypeId.isNull()) {
param = RuleActionParam(paramName);
} else {
param = RuleActionParam(paramTypeId);
}
param.setValue(ruleActionParamMap.value("value"));
param.setEventTypeId(EventTypeId(ruleActionParamMap.value("eventTypeId").toString()));
param.setEventParamTypeId(ParamTypeId(ruleActionParamMap.value("eventParamTypeId").toString()));
param.setStateDeviceId(DeviceId(ruleActionParamMap.value("stateDeviceId").toString()));
param.setStateTypeId(StateTypeId(ruleActionParamMap.value("stateTypeId").toString()));
return param;
}
RuleActionParams RulesHandler::unpackRuleActionParams(const QVariantList &ruleActionParamList)
{
RuleActionParams ruleActionParams;
foreach (const QVariant &paramVariant, ruleActionParamList)
ruleActionParams.append(unpackRuleActionParam(paramVariant.toMap()));
return ruleActionParams;
}
RuleAction RulesHandler::unpackRuleAction(const QVariantMap &ruleActionMap)
{
ActionTypeId actionTypeId(ruleActionMap.value("actionTypeId").toString());
DeviceId actionDeviceId(ruleActionMap.value("deviceId").toString());
QString interface = ruleActionMap.value("interface").toString();
QString interfaceAction = ruleActionMap.value("interfaceAction").toString();
QString browserItemId = ruleActionMap.value("browserItemId").toString();
RuleActionParams actionParamList = unpackRuleActionParams(ruleActionMap.value("ruleActionParams").toList());
if (!actionDeviceId.isNull() && !actionTypeId.isNull()) {
return RuleAction(actionTypeId, actionDeviceId, actionParamList);
} else if (!actionDeviceId.isNull() && !browserItemId.isNull()) {
return RuleAction(actionDeviceId, browserItemId);
}
return RuleAction(interface, interfaceAction, actionParamList);
}
Rule RulesHandler::unpackRule(const QVariantMap &ruleMap)
{
// The rule id will only be valid if unpacking for edit
RuleId ruleId = RuleId(ruleMap.value("ruleId").toString());
QString name = ruleMap.value("name", QString()).toString();
// By default enabled
bool enabled = ruleMap.value("enabled", true).toBool();
// By default executable
bool executable = ruleMap.value("executable", true).toBool();
StateEvaluator stateEvaluator = unpackStateEvaluator(ruleMap.value("stateEvaluator").toMap());
TimeDescriptor timeDescriptor = unpackTimeDescriptor(ruleMap.value("timeDescriptor").toMap());
QList<EventDescriptor> eventDescriptors;
if (ruleMap.contains("eventDescriptors")) {
QVariantList eventDescriptorVariantList = ruleMap.value("eventDescriptors").toList();
foreach (const QVariant &eventDescriptorVariant, eventDescriptorVariantList) {
eventDescriptors.append(unpackEventDescriptor(eventDescriptorVariant.toMap()));
}
}
QList<RuleAction> actions;
if (ruleMap.contains("actions")) {
QVariantList actionsVariantList = ruleMap.value("actions").toList();
foreach (const QVariant &actionVariant, actionsVariantList) {
actions.append(unpackRuleAction(actionVariant.toMap()));
}
}
QList<RuleAction> exitActions;
if (ruleMap.contains("exitActions")) {
QVariantList exitActionsVariantList = ruleMap.value("exitActions").toList();
foreach (const QVariant &exitActionVariant, exitActionsVariantList) {
exitActions.append(unpackRuleAction(exitActionVariant.toMap()));
}
}
Rule rule;
rule.setId(ruleId);
rule.setName(name);
rule.setTimeDescriptor(timeDescriptor);
rule.setStateEvaluator(stateEvaluator);
rule.setEventDescriptors(eventDescriptors);
rule.setActions(actions);
rule.setExitActions(exitActions);
rule.setEnabled(enabled);
rule.setExecutable(executable);
return rule;
}
}

31
libnymea-core/jsonrpc/ruleshandler.h
View File

@ -63,36 +63,7 @@ private slots:
void ruleConfigurationChangedNotification(const Rule &rule);
private:
static QVariantMap packRuleDescription(const Rule &rule);
static QVariantMap packParamDescriptor(const ParamDescriptor &paramDescriptor);
static QVariantMap packEventDescriptor(const EventDescriptor &eventDescriptor);
static QVariantMap packStateEvaluator(const StateEvaluator &stateEvaluator);
static QVariantMap packStateDescriptor(const StateDescriptor &stateDescriptor);
static QVariantMap packTimeDescriptor(const TimeDescriptor &timeDescriptor);
static QVariantMap packCalendarItem(const CalendarItem &calendarItem);
static QVariantMap packRepeatingOption(const RepeatingOption &option);
static QVariantMap packTimeEventItem(const TimeEventItem &timeEventItem);
static QVariantMap packRuleActionParam(const RuleActionParam &ruleActionParam);
static QVariantMap packRuleAction(const RuleAction &ruleAction);
static QVariantMap packRule(const Rule &rule);
static QList<ParamDescriptor> unpackParamDescriptors(const QVariantList &paramList);
static ParamDescriptor unpackParamDescriptor(const QVariantMap &paramMap);
static EventDescriptor unpackEventDescriptor(const QVariantMap &eventDescriptorMap);
static RepeatingOption unpackRepeatingOption(const QVariantMap &repeatingOptionMap);
static CalendarItem unpackCalendarItem(const QVariantMap &calendarItemMap);
static TimeDescriptor unpackTimeDescriptor(const QVariantMap &timeDescriptorMap);
static TimeEventItem unpackTimeEventItem(const QVariantMap &timeEventItemMap);
static StateDescriptor unpackStateDescriptor(const QVariantMap &stateDescriptorMap);
static StateEvaluator unpackStateEvaluator(const QVariantMap &stateEvaluatorMap);
static RuleActionParam unpackRuleActionParam(const QVariantMap &ruleActionParamMap);
static RuleActionParams unpackRuleActionParams(const QVariantList &ruleActionParamList);
static RuleAction unpackRuleAction(const QVariantMap &ruleActionMap);
static Rule unpackRule(const QVariantMap &ruleMap);
QVariantMap packRuleDescription(const Rule &rule);
};
}

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

@ -33,7 +33,6 @@
*/
#include "statehandler.h"
#include "devicehandler.h"
#include "nymeacore.h"
#include "loggingcategories.h"

5
libnymea-core/logging/logentry.cpp
View File

@ -193,4 +193,9 @@ QVariant LogEntries::get(int index) const
return QVariant::fromValue(at(index));
}
void LogEntries::put(const QVariant &variant)
{
append(variant.value<LogEntry>());
}
}

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

@ -100,6 +100,7 @@ public:
LogEntries();
LogEntries(const QList<LogEntry> &other);
Q_INVOKABLE QVariant get(int index) const;
Q_INVOKABLE void put(const QVariant &variant);
};
QDebug operator<<(QDebug dbg, const LogEntry &entry);

19
libnymea-core/ruleengine/rule.cpp
View File

@ -49,7 +49,7 @@ Rule::Rule():
m_eventDescriptors(QList<EventDescriptor>()),
m_actions(QList<RuleAction>()),
m_exitActions(QList<RuleAction>()),
m_enabled(false),
m_enabled(true),
m_active(false),
m_statesActive(false),
m_timeActive(false),
@ -128,37 +128,37 @@ void Rule::setStateEvaluator(const StateEvaluator &stateEvaluator)
}
/*! Returns the \l{EventDescriptor} for this Rule.*/
QList<EventDescriptor> Rule::eventDescriptors() const
EventDescriptors Rule::eventDescriptors() const
{
return m_eventDescriptors;
}
/*! Sets the \a eventDescriptors of this \l{Rule}. */
void Rule::setEventDescriptors(const QList<EventDescriptor> &eventDescriptors)
void Rule::setEventDescriptors(const EventDescriptors &eventDescriptors)
{
m_eventDescriptors = eventDescriptors;
}
/*! Returns the \l{RuleAction}{RuleActions} to be executed when this Rule is matched and states match. */
QList<RuleAction> Rule::actions() const
RuleActions Rule::actions() const
{
return m_actions;
}
/*! Sets the \a actions of this \l{Rule}. */
void Rule::setActions(const QList<RuleAction> actions)
void Rule::setActions(const RuleActions actions)
{
m_actions = actions;
}
/*! Returns the \l{RuleAction}{RuleActions} to be executed when this Rule leaves the active state. */
QList<RuleAction> Rule::exitActions() const
RuleActions Rule::exitActions() const
{
return m_exitActions;
}
/*! Sets the \a exitActions of this \l{Rule}. */
void Rule::setExitActions(const QList<RuleAction> exitActions)
void Rule::setExitActions(const RuleActions exitActions)
{
m_exitActions = exitActions;
}
@ -265,4 +265,9 @@ QVariant Rules::get(int index) const
return QVariant::fromValue(at(index));
}
void Rules::put(const QVariant &variant)
{
append(variant.value<Rule>());
}
}

35
libnymea-core/ruleengine/rule.h
View File

@ -35,16 +35,16 @@ namespace nymeaserver {
class Rule
{
Q_GADGET
Q_PROPERTY(QUuid id READ id WRITE setId)
Q_PROPERTY(QUuid id READ id WRITE setId USER true)
Q_PROPERTY(QString name READ name WRITE setName)
Q_PROPERTY(bool active READ active)
Q_PROPERTY(bool enabled READ enabled WRITE setEnabled)
Q_PROPERTY(bool executable READ executable WRITE setExecutable)
Q_PROPERTY(EventDescriptors eventDescriptors READ eventDescriptors WRITE setEventDescriptors)
Q_PROPERTY(bool active READ active USER true)
Q_PROPERTY(bool enabled READ enabled WRITE setEnabled USER true)
Q_PROPERTY(bool executable READ executable WRITE setExecutable USER true)
Q_PROPERTY(EventDescriptors eventDescriptors READ eventDescriptors WRITE setEventDescriptors USER true)
Q_PROPERTY(RuleActions actions READ actions WRITE setActions)
Q_PROPERTY(RuleActions exitActions READ exitActions WRITE setExitActions)
Q_PROPERTY(StateEvaluator stateEvaluator READ stateEvaluator WRITE setStateEvaluator)
Q_PROPERTY(TimeDescriptor timeDescriptor READ timeDescriptor WRITE setTimeDescriptor)
Q_PROPERTY(RuleActions exitActions READ exitActions WRITE setExitActions USER true)
Q_PROPERTY(nymeaserver::StateEvaluator stateEvaluator READ stateEvaluator WRITE setStateEvaluator USER true)
Q_PROPERTY(TimeDescriptor timeDescriptor READ timeDescriptor WRITE setTimeDescriptor USER true)
public:
Rule();
@ -65,14 +65,14 @@ public:
StateEvaluator stateEvaluator() const;
void setStateEvaluator(const StateEvaluator &stateEvaluator);
QList<EventDescriptor> eventDescriptors() const;
void setEventDescriptors(const QList<EventDescriptor> &eventDescriptors);
EventDescriptors eventDescriptors() const;
void setEventDescriptors(const EventDescriptors &eventDescriptors);
QList<RuleAction> actions() const;
void setActions(const QList<RuleAction> actions);
RuleActions actions() const;
void setActions(const RuleActions actions);
QList<RuleAction> exitActions() const;
void setExitActions(const QList<RuleAction> exitActions);
RuleActions exitActions() const;
void setExitActions(const RuleActions exitActions);
bool enabled() const;
void setEnabled(const bool &enabled);
@ -95,9 +95,9 @@ private:
QString m_name;
TimeDescriptor m_timeDescriptor;
StateEvaluator m_stateEvaluator;
QList<EventDescriptor> m_eventDescriptors;
QList<RuleAction> m_actions;
QList<RuleAction> m_exitActions;
EventDescriptors m_eventDescriptors;
RuleActions m_actions;
RuleActions m_exitActions;
bool m_enabled;
bool m_active;
@ -114,6 +114,7 @@ public:
Rules();
Rules(const QList<Rule> &other);
Q_INVOKABLE QVariant get(int index) const;
Q_INVOKABLE void put(const QVariant &variant);
};
QDebug operator<<(QDebug dbg, const Rule &rule);

5
libnymea-core/ruleengine/ruleaction.cpp
View File

@ -300,3 +300,8 @@ QVariant RuleActions::get(int index) const
{
return QVariant::fromValue(at(index));
}
void RuleActions::put(const QVariant &variant)
{
append(variant.value<RuleAction>());
}

1
libnymea-core/ruleengine/ruleaction.h
View File

@ -102,6 +102,7 @@ public:
RuleActions();
RuleActions(const QList<RuleAction> &other);
Q_INVOKABLE QVariant get(int index) const;
Q_INVOKABLE void put(const QVariant &variant);
};
Q_DECLARE_METATYPE(RuleActions)

5
libnymea-core/ruleengine/ruleactionparam.cpp
View File

@ -312,3 +312,8 @@ QVariant RuleActionParams::get(int index) const
{
return QVariant::fromValue(at(index));
}
void RuleActionParams::put(const QVariant &variant)
{
append(variant.value<RuleActionParam>());
}

1
libnymea-core/ruleengine/ruleactionparam.h
View File

@ -101,6 +101,7 @@ public:
bool hasParam(const ParamTypeId &ruleActionParamTypeId) const;
bool hasParam(const QString &ruleActionParamName) const;
Q_INVOKABLE QVariant get(int index) const;
Q_INVOKABLE void put(const QVariant &variant);
QVariant paramValue(const ParamTypeId &ruleActionParamName) const;
bool setParamValue(const ParamTypeId &ruleActionParamTypeId, const QVariant &value);
RuleActionParams operator<<(const RuleActionParam &ruleActionParam);

11
libnymea-core/ruleengine/stateevaluator.cpp
View File

@ -69,13 +69,13 @@ void StateEvaluator::setStateDescriptor(const StateDescriptor &stateDescriptor)
}
/*! Returns the list of child \l {StateEvaluator}{StateEvaluators} of this \l StateEvaluator. */
QList<StateEvaluator> StateEvaluator::childEvaluators() const
StateEvaluators StateEvaluator::childEvaluators() const
{
return m_childEvaluators;
}
/*! Sets the list of child evaluators of this \l StateEvaluator to the given \a stateEvaluators.*/
void StateEvaluator::setChildEvaluators(const QList<StateEvaluator> &stateEvaluators)
void StateEvaluator::setChildEvaluators(const StateEvaluators &stateEvaluators)
{
m_childEvaluators = stateEvaluators;
}
@ -389,7 +389,14 @@ StateEvaluators::StateEvaluators(const QList<StateEvaluator> &other): QList<Stat
QVariant StateEvaluators::get(int index) const
{
qWarning() << "getting" << index << "of" << count();
qWarning() << "at" << at(index);
return QVariant::fromValue(at(index));
}
void StateEvaluators::put(const QVariant &variant)
{
append(variant.value<StateEvaluator>());
}
}

28
libnymea-core/ruleengine/stateevaluator.h
View File

@ -30,12 +30,24 @@
class NymeaSettings;
namespace nymeaserver {
class StateEvaluator;
class StateEvaluators: public QList<StateEvaluator>
{
Q_GADGET
Q_PROPERTY(int count READ count)
public:
StateEvaluators();
StateEvaluators(const QList<StateEvaluator> &other);
Q_INVOKABLE QVariant get(int index) const;
Q_INVOKABLE void put(const QVariant &variant);
};
class StateEvaluator
{
Q_GADGET
Q_PROPERTY(StateDescriptor stateDescriptor READ stateDescriptor WRITE setStateDescriptor USER true)
Q_PROPERTY(StateEvaluators childEvaluators READ childEvaluators WRITE setChildEvaluators USER true)
Q_PROPERTY(nymeaserver::StateEvaluators childEvaluators READ childEvaluators WRITE setChildEvaluators USER true)
Q_PROPERTY(Types::StateOperator operator READ operatorType WRITE setOperatorType USER true)
public:
StateEvaluator(const StateDescriptor &stateDescriptor);
@ -44,8 +56,8 @@ public:
StateDescriptor stateDescriptor() const;
void setStateDescriptor(const StateDescriptor &stateDescriptor);
QList<StateEvaluator> childEvaluators() const;
void setChildEvaluators(const QList<StateEvaluator> &childEvaluators);
StateEvaluators childEvaluators() const;
void setChildEvaluators(const StateEvaluators &childEvaluators);
void appendEvaluator(const StateEvaluator &stateEvaluator);
Types::StateOperator operatorType() const;
@ -70,19 +82,11 @@ private:
Types::StateOperator m_operatorType;
};
class StateEvaluators: public QList<StateEvaluator>
{
Q_GADGET
Q_PROPERTY(int count READ count)
public:
StateEvaluators();
StateEvaluators(const QList<StateEvaluator> &other);
Q_INVOKABLE QVariant get(int index) const;
};
QDebug operator<<(QDebug dbg, const StateEvaluator &stateEvaluator);
}
Q_DECLARE_METATYPE(nymeaserver::StateEvaluator)
Q_DECLARE_METATYPE(nymeaserver::StateEvaluators)
#endif // STATEEVALUATOR_H

5
libnymea-core/tagging/tag.cpp
View File

@ -132,4 +132,9 @@ QVariant Tags::get(int index) const
return QVariant::fromValue(at(index));
}
void Tags::put(const QVariant &variant)
{
append(variant.value<Tag>());
}
}

1
libnymea-core/tagging/tag.h
View File

@ -74,6 +74,7 @@ public:
Tags();
Tags(const QList<Tag> &other);
Q_INVOKABLE QVariant get(int index) const;
Q_INVOKABLE void put(const QVariant &variant);
};
QDebug operator<<(QDebug dbg, const Tag &tag);

5
libnymea-core/usermanager/tokeninfo.cpp
View File

@ -34,6 +34,11 @@
namespace nymeaserver {
TokenInfo::TokenInfo()
{
}
/*! Constructs a new token info with the given \a id, \a username, \a creationTime and \a deviceName. */
TokenInfo::TokenInfo(const QUuid &id, const QString &username, const QDateTime &creationTime, const QString &deviceName):
m_id(id),

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

@ -23,7 +23,7 @@
#include <QUuid>
#include <QDateTime>
#include <QMetaObject>
#include <QMetaType>
namespace nymeaserver {
@ -36,6 +36,7 @@ class TokenInfo
Q_PROPERTY(QString deviveName READ deviceName)
public:
TokenInfo();
TokenInfo(const QUuid &id, const QString &username, const QDateTime &creationTime, const QString &deviceName);
QUuid id() const;
@ -51,5 +52,6 @@ private:
};
}
Q_DECLARE_METATYPE(nymeaserver::TokenInfo)
#endif // TOKENINFO_H

4
libnymea/devices/device.cpp
View File

@ -271,7 +271,7 @@ void Device::setSettingValue(const ParamTypeId &paramTypeId, const QVariant &val
}
/*! Returns the states of this Device. It must match the \l{StateType} description in the associated \l{DeviceClass}. */
QList<State> Device::states() const
States Device::states() const
{
return m_states;
}
@ -283,7 +283,7 @@ bool Device::hasParam(const ParamTypeId &paramTypeId) const
}
/*! Set the \l{State}{States} of this \l{Device} to the given \a states.*/
void Device::setStates(const QList<State> &states)
void Device::setStates(const States &states)
{
m_states = states;
}

6
libnymea/devices/device.h
View File

@ -106,9 +106,9 @@ public:
QVariant setting(const ParamTypeId &paramTypeId) const;
void setSettingValue(const ParamTypeId &paramTypeId, const QVariant &value);
QList<State> states() const;
States states() const;
bool hasState(const StateTypeId &stateTypeId) const;
void setStates(const QList<State> &states);
void setStates(const States &states);
QVariant stateValue(const StateTypeId &stateTypeId) const;
void setStateValue(const StateTypeId &stateTypeId, const QVariant &value);
@ -144,7 +144,7 @@ private:
QString m_name;
ParamList m_params;
ParamList m_settings;
QList<State> m_states;
States m_states;
bool m_setupComplete = false;
bool m_autoCreated = false;
};

5
libnymea/devices/devicemanager.cpp
View File

@ -37,5 +37,8 @@
DeviceManager::DeviceManager(QObject *parent) : QObject(parent)
{
qRegisterMetaType<Param>();
qRegisterMetaType<ParamList>();
qRegisterMetaType<ParamType>();
qRegisterMetaType<ParamTypes>();
}

4
libnymea/devices/deviceplugin.h
View File

@ -55,6 +55,7 @@
#include <QTranslator>
#include <QPair>
#include <QSettings>
#include <QMetaType>
class DeviceManager;
@ -140,8 +141,8 @@ private:
PluginMetadata m_metaData;
ParamList m_config;
};
Q_DECLARE_INTERFACE(DevicePlugin, "io.nymea.DevicePlugin")
Q_DECLARE_METATYPE(DevicePlugin*)
class LIBNYMEA_EXPORT DevicePlugins: public QList<DevicePlugin*>
@ -151,5 +152,6 @@ public:
DevicePlugins(const QList<DevicePlugin*> &other);
DevicePlugin* findById(const PluginId &id) const;
};
Q_DECLARE_METATYPE(DevicePlugins)
#endif // DEVICEPLUGIN_H

278
libnymea/jsonrpc/jsonhandler.cpp
View File

@ -27,6 +27,7 @@
JsonHandler::JsonHandler(QObject *parent) : QObject(parent)
{
qRegisterMetaType<QVariant::Type>();
registerEnum<BasicType>();
}
@ -155,13 +156,52 @@ JsonReply *JsonHandler::createAsyncReply(const QString &method) const
return JsonReply::createAsyncReply(const_cast<JsonHandler*>(this), method);
}
void JsonHandler::registerObject(const QMetaObject &metaObject)
{
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;
if (metaProperty.type() == QVariant::UserType) {
if (metaProperty.typeName() == QStringLiteral("QVariant::Type")) {
typeName = QString("$ref:BasicType");
} else if (QString(metaProperty.typeName()).startsWith("QList")) {
QString elementType = QString(metaProperty.typeName()).remove("QList<").remove(">");
QVariant::Type variantType = QVariant::nameToType(elementType.toUtf8());
typeName = QVariantList() << enumValueName(variantTypeToBasicType(variantType));
} 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);
}
QVariant JsonHandler::pack(const QMetaObject &metaObject, const void *value) const
{
QString className = QString(metaObject.className()).split("::").last();
if (m_listMetaObjects.contains(className)) {
QVariantList ret;
QMetaProperty countProperty = metaObject.property(metaObject.indexOfProperty("count"));
QMetaObject entryMetaObject = m_metaObjects.value(m_listEntryTypes.value(metaObject.className()));
QMetaObject entryMetaObject = m_metaObjects.value(m_listEntryTypes.value(className));
int count = countProperty.readOnGadget(value).toInt();
QMetaMethod getMethod = metaObject.method(metaObject.indexOfMethod("get(int)"));
for (int i = 0; i < count; i++) {
@ -182,12 +222,18 @@ QVariant JsonHandler::pack(const QMetaObject &metaObject, const void *value) con
continue;
}
QVariant propertyValue = metaProperty.readOnGadget(value);
// If it's optional and empty, we may skip it
if (metaProperty.isUser() && (!propertyValue.isValid() || propertyValue.isNull())) {
continue;
}
// Pack flags
if (metaProperty.isFlagType()) {
QString flagName = QString(metaProperty.typeName()).split("::").last();
Q_ASSERT_X(m_metaFlags.contains(flagName), this->metaObject()->className(), QString("Cannot pack %1. %2 is not registered in this handler.").arg(className).arg(flagName).toUtf8());
QMetaEnum metaFlag = m_metaFlags.value(flagName);
int flagValue = metaProperty.readOnGadget(value).toInt();
int flagValue = propertyValue.toInt();
QStringList flags;
for (int i = 0; i < metaFlag.keyCount(); i++) {
if ((metaFlag.value(i) & flagValue) > 0) {
@ -203,45 +249,74 @@ QVariant JsonHandler::pack(const QMetaObject &metaObject, const void *value) con
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 in this handler.").arg(className).arg(metaProperty.typeName()).toUtf8());
QMetaEnum metaEnum = m_metaEnums.value(enumName);
ret.insert(metaProperty.name(), metaEnum.key(metaProperty.readOnGadget(value).toInt()));
ret.insert(metaProperty.name(), metaEnum.key(propertyValue.toInt()));
continue;
}
// Basic type/Variant type
if (metaProperty.typeName() == QStringLiteral("QVariant::Type")) {
QMetaEnum metaEnum = QMetaEnum::fromType<BasicType>();
ret.insert(metaProperty.name(), metaEnum.key(variantTypeToBasicType(metaProperty.readOnGadget(value).template value<QVariant::Type>())));
ret.insert(metaProperty.name(), metaEnum.key(variantTypeToBasicType(propertyValue.template value<QVariant::Type>())));
continue;
}
// Our own objects
if (metaProperty.type() == QVariant::UserType) {
if (m_listMetaObjects.contains(metaProperty.typeName())) {
QMetaObject entryMetaObject = m_listMetaObjects.value(metaProperty.typeName());
ret.insert(metaProperty.name(), pack(entryMetaObject, metaProperty.readOnGadget(value).data()));
QString propertyTypeName = QString(metaProperty.typeName()).split("::").last();
if (m_listMetaObjects.contains(propertyTypeName)) {
QMetaObject entryMetaObject = m_listMetaObjects.value(propertyTypeName);
QVariant packed = pack(entryMetaObject, propertyValue.data());
if (!metaProperty.isUser() || packed.toList().count() > 0) {
ret.insert(metaProperty.name(), packed);
}
continue;
}
if (m_metaObjects.contains(metaProperty.typeName())) {
QMetaObject entryMetaObject = m_metaObjects.value(metaProperty.typeName());
ret.insert(metaProperty.name(), pack(entryMetaObject, metaProperty.readOnGadget(value).data()));
if (m_metaObjects.contains(propertyTypeName)) {
QMetaObject entryMetaObject = m_metaObjects.value(propertyTypeName);
QVariant packed = pack(entryMetaObject, propertyValue.data());
int isValidIndex = entryMetaObject.indexOfMethod("isValid()");
bool isValid = true;
if (isValidIndex >= 0) {
QMetaMethod isValidMethod = entryMetaObject.method(isValidIndex);
isValidMethod.invokeOnGadget(propertyValue.data(), Q_RETURN_ARG(bool, isValid));
}
if (isValid || !metaProperty.isUser()) {
ret.insert(metaProperty.name(), packed);
}
continue;
}
Q_ASSERT_X(false, this->metaObject()->className(), QString("Unregistered property type: %1").arg(metaProperty.typeName()).toUtf8());
qCWarning(dcJsonRpc()) << "Cannot pack property of unregistered object type" << metaProperty.typeName();
// Manually converting QList<int>... Only QVariantList is known to the meta system
if (propertyTypeName.startsWith("QList<int>")) {
qWarning() << "Packing list" << metaProperty.name() << propertyValue.toList();
QVariantList list;
foreach (int entry, propertyValue.value<QList<int>>()) {
list << entry;
}
if (!list.isEmpty() || !metaProperty.isUser()) {
ret.insert(metaProperty.name(), list);
}
continue;
}
// Standard properties, QString, int etc... If it's not optional, or if it's not empty, pack it up
if (!metaProperty.isUser() || !metaProperty.readOnGadget(value).isNull()) {
QVariant variant = metaProperty.readOnGadget(value);
Q_ASSERT_X(false, this->metaObject()->className(), QString("Unregistered property type: %1").arg(propertyTypeName).toUtf8());
qCWarning(dcJsonRpc()) << "Cannot pack property of unregistered object type" << propertyTypeName;
continue;
}
// Standard properties, QString, int etc...
// Special treatment for QDateTime (converting to time_t)
if (metaProperty.type() == QVariant::DateTime) {
variant = variant.toDateTime().toTime_t();
QDateTime dateTime = propertyValue.toDateTime();
if (metaProperty.isUser() && dateTime.toTime_t() == 0) {
continue;
}
ret.insert(metaProperty.name(), variant);
propertyValue = propertyValue.toDateTime().toTime_t();
} else if (metaProperty.type() == QVariant::Time) {
propertyValue = propertyValue.toTime().toString("hh:mm");
}
ret.insert(metaProperty.name(), propertyValue);
}
return ret;
}
@ -249,72 +324,107 @@ QVariant JsonHandler::pack(const QMetaObject &metaObject, const void *value) con
Q_ASSERT_X(false, this->metaObject()->className(), QString("Unregistered object type: %1").arg(className).toUtf8());
qCWarning(dcJsonRpc()) << "Cannot pack object of unregistered type" << className;
return QVariant();
// 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;
}
QVariant JsonHandler::unpack(const QMetaObject &metaObject, const QVariant &value) const
{
QString typeName = QString(metaObject.className()).split("::").last();
// If it's a list object, loop over count
if (m_listMetaObjects.contains(typeName)) {
qWarning() << "** Unpacking" << typeName;
if (value.type() != QVariant::List) {
qCWarning(dcJsonRpc()) << "Cannot unpack" << typeName << ". Value is not in list format:" << value;
return QVariant();
}
QVariantList list = value.toList();
int typeId = QMetaType::type(metaObject.className());
void* ptr = QMetaType::create(typeId);
Q_ASSERT_X(typeId != 0, this->metaObject()->className(), QString("Cannot handle unregistered meta type %1").arg(metaObject.className()).toUtf8());
QMetaObject entryMetaObject = m_metaObjects.value(m_listEntryTypes.value(typeName));
QMetaMethod putMethod = metaObject.method(metaObject.indexOfMethod("put(QVariant)"));
foreach (const QVariant &variant, list) {
QVariant value = unpack(entryMetaObject, variant);
qWarning() << "Putting" << value << putMethod.name() << ptr << typeId;
putMethod.invokeOnGadget(ptr, Q_ARG(QVariant, value));
}
QVariant ret = QVariant(typeId, ptr);
QMetaType::destroy(typeId, ptr);
return ret;
}
// if it's an object, loop over all properties
if (m_metaObjects.contains(typeName)) {
qWarning() << "*** Unpacking" << typeName;
QVariantMap map = value.toMap();
int typeId = QMetaType::type(metaObject.className());
Q_ASSERT_X(typeId != 0, this->metaObject()->className(), QString("Cannot handle unregistered meta type %1").arg(typeName).toUtf8());
void* ptr = QMetaType::create(typeId);
for (int i = 0; i < metaObject.propertyCount(); i++) {
QMetaProperty metaProperty = metaObject.property(i);
if (metaProperty.name() == QStringLiteral("objectName")) {
continue;
}
if (!metaProperty.isWritable()) {
continue;
}
if (!metaProperty.isUser()) {
Q_ASSERT_X(map.contains(metaProperty.name()), this->metaObject()->className(), QString("Missing property %1 in map.").arg(metaProperty.name()).toUtf8());
}
if (map.contains(metaProperty.name())) {
QString propertyTypeName = QString(metaProperty.typeName()).split("::").last();
QVariant variant = map.value(metaProperty.name());
// recurse into child lists
if (m_listMetaObjects.contains(propertyTypeName)) {
QMetaObject propertyMetaObject = m_listMetaObjects.value(propertyTypeName);
qWarning() << "Entering list object" << propertyTypeName << propertyMetaObject.className();
metaProperty.writeOnGadget(ptr, unpack(propertyMetaObject, variant));
continue;
}
// recurse into child objects
if (m_metaObjects.contains(propertyTypeName)) {
QMetaObject propertyMetaObject = m_metaObjects.value(propertyTypeName);
metaProperty.writeOnGadget(ptr, unpack(propertyMetaObject, variant));
continue;
}
if (metaProperty.typeName() == QStringLiteral("QList<int>")) {
QList<int> intList;
foreach (const QVariant &val, variant.toList()) {
intList.append(val.toInt());
}
metaProperty.writeOnGadget(ptr, QVariant::fromValue(intList));
continue;
}
// Special treatment for QDateTime (convert from time_t)
if (metaProperty.type() == QVariant::DateTime) {
variant = QDateTime::fromTime_t(variant.toUInt());
} else if (metaProperty.type() == QVariant::Time) {
variant = QTime::fromString(variant.toString(), "hh:mm");
}
// For basic properties just write the veriant as is
metaProperty.writeOnGadget(ptr, variant);
}
}
QVariant ret = QVariant(typeId, ptr);
QMetaType::destroy(typeId, ptr);
return ret;
}
return QVariant();
}

103
libnymea/jsonrpc/jsonhandler.h
View File

@ -72,13 +72,16 @@ public:
static QVariant::Type basicTypeToVariantType(BasicType basicType);
template<typename T> QVariant pack(const T &value) const;
template <typename T> T unpack(const QVariantMap &map) const;
template<typename T> QVariant pack(T *value) const;
template <typename T> T unpack(const QVariant &value) const;
protected:
template <typename Enum> void registerEnum();
template <typename Enum, typename Flags> void registerEnum();
template <typename ObjectType> void registerObject();
template <typename ObjectType> void registerUncreatableObject();
template <typename ObjectType, typename ListType> void registerObject();
template<typename ListType, typename BasicTypeName> void registerList(BasicTypeName typeName);
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 registerNotification(const QString &name, const QString &description, const QVariantMap &params, bool deprecated = false);
@ -87,7 +90,11 @@ protected:
JsonReply *createAsyncReply(const QString &method) const;
private:
void registerObject(const QMetaObject &metaObject);
QVariant pack(const QMetaObject &metaObject, const void *gadget) const;
QVariant unpack(const QMetaObject &metaObject, const QVariant &value) const;
private:
QVariantMap m_enums;
@ -130,50 +137,23 @@ void JsonHandler::registerEnum()
template<typename ObjectType>
void JsonHandler::registerObject()
{
qRegisterMetaType<QVariant::Type>();
qRegisterMetaType<ObjectType>();
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")) {
QString elementType = QString(metaProperty.typeName()).remove("QList<").remove(">");
QVariant::Type variantType = QVariant::nameToType(elementType.toUtf8());
typeName = QVariantList() << enumValueName(variantTypeToBasicType(variantType));
} 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);
registerObject(metaObject);
}
template<typename ObjectType>
void JsonHandler::registerUncreatableObject()
{
QMetaObject metaObject = ObjectType::staticMetaObject;
registerObject(metaObject);
}
template<typename ObjectType, typename ListType>
void JsonHandler::registerObject()
{
registerObject<ObjectType>();
qRegisterMetaType<ListType>();
QMetaObject metaObject = ObjectType::staticMetaObject;
QMetaObject listMetaObject = ListType::staticMetaObject;
QString listTypeName = QString(listMetaObject.className()).split("::").last();
@ -184,6 +164,19 @@ void JsonHandler::registerObject()
m_listEntryTypes.insert(listTypeName, objectTypeName);
Q_ASSERT_X(listMetaObject.indexOfProperty("count") >= 0, "JsonHandler", QString("List type %1 does not implement \"count\" property!").arg(listTypeName).toUtf8());
Q_ASSERT_X(listMetaObject.indexOfMethod("get(int)") >= 0, "JsonHandler", QString("List type %1 does not implement \"Q_INVOKABLE QVariant get(int index)\" method!").arg(listTypeName).toUtf8());
Q_ASSERT_X(listMetaObject.indexOfMethod("put(QVariant)") >= 0, "JsonHandler", QString("List type %1 does not implement \"Q_INVOKABLE void put(QVariant variant)\" method!").arg(listTypeName).toUtf8());
}
template<typename ListType, typename BasicTypeName>
void JsonHandler::registerList(BasicTypeName typeName)
{
QMetaObject listMetaObject = ListType::staticMetaObject;
QString listTypeName = QString(listMetaObject.className()).split("::").last();
m_metaObjects.insert(listTypeName, listMetaObject);
m_objects.insert(listTypeName, QVariantList() << QVariant(QString("$ref:%1").arg(enumValueName(typeName))));
Q_ASSERT_X(listMetaObject.indexOfProperty("count") >= 0, "JsonHandler", QString("List type %1 does not implement \"count\" property!").arg(listTypeName).toUtf8());
Q_ASSERT_X(listMetaObject.indexOfMethod("get(int)") >= 0, "JsonHandler", QString("List type %1 does not implement \"Q_INVOKABLE QVariant get(int index)\" method!").arg(listTypeName).toUtf8());
Q_ASSERT_X(listMetaObject.indexOfMethod("put(QVariant)") >= 0, "JsonHandler", QString("List type %1 does not implement \"Q_INVOKABLE void put(QVariant variant)\" method!").arg(listTypeName).toUtf8());
}
template<typename T>
@ -222,33 +215,19 @@ QVariant JsonHandler::pack(const T &value) const
}
template<typename T>
T JsonHandler::unpack(const QVariantMap &map) const
QVariant JsonHandler::pack(T *value) const
{
T ret;
QMetaObject metaObject = T::staticMetaObject;
for (int i = 0; i < metaObject.propertyCount(); i++) {
QMetaProperty metaProperty = metaObject.property(i);
if (metaProperty.name() == QStringLiteral("objectName")) {
continue;
}
if (!metaProperty.isWritable()) {
continue;
}
if (!metaProperty.isUser()) {
Q_ASSERT_X(map.contains(metaProperty.name()), this->metaObject()->className(), QString("Missing property %1 in map.").arg(metaProperty.name()).toUtf8());
}
if (map.contains(metaProperty.name())) {
// Special treatment for QDateTime (convert from time_t)
QVariant variant = map.value(metaProperty.name());
if (metaProperty.type() == QVariant::DateTime) {
variant = QDateTime::fromTime_t(variant.toUInt());
}
metaProperty.writeOnGadget(&ret, variant);
}
}
return ret;
return pack(metaObject, static_cast<const void*>(value));
}
template<typename T>
T JsonHandler::unpack(const QVariant &value) const
{
QMetaObject metaObject = T::staticMetaObject;
QVariant ret = unpack(metaObject, value);
return ret.value<T>();
}
#endif // JSONHANDLER_H

5
libnymea/platform/package.cpp
View File

@ -144,3 +144,8 @@ QVariant Packages::get(int index) const
{
return QVariant::fromValue(at(index));
}
void Packages::put(const QVariant &variant)
{
append(variant.value<Package>());
}

1
libnymea/platform/package.h
View File

@ -93,6 +93,7 @@ public:
Packages();
Packages(const QList<Package> &other);
Q_INVOKABLE QVariant get(int index) const;
Q_INVOKABLE void put(const QVariant &variant);
};
Q_DECLARE_METATYPE(Packages)

5
libnymea/platform/repository.cpp
View File

@ -69,3 +69,8 @@ QVariant Repositories::get(int index) const
{
return QVariant::fromValue(at(index));
}
void Repositories::put(const QVariant &variant)
{
append(variant.value<Repository>());
}

1
libnymea/platform/repository.h
View File

@ -57,6 +57,7 @@ public:
Repositories();
Repositories(const QList<Repository> &other);
Q_INVOKABLE QVariant get(int index) const;
Q_INVOKABLE void put(const QVariant &variant);
};
#endif // REPOSITORY_H

8
libnymea/time/calendaritem.cpp
View File

@ -285,7 +285,13 @@ CalendarItems::CalendarItems(const QList<CalendarItem> &other): QList<CalendarIt
}
QVariant CalendarItems::get(int index)
QVariant CalendarItems::get(int index) const
{
return QVariant::fromValue(at(index));
}
void CalendarItems::put(const QVariant &variant)
{
qWarning() << "Putting!" << variant;
append(variant.value<CalendarItem>());
}

3
libnymea/time/calendaritem.h
View File

@ -74,7 +74,8 @@ class CalendarItems: public QList<CalendarItem>
public:
CalendarItems();
CalendarItems(const QList<CalendarItem> &other);
Q_INVOKABLE QVariant get(int index);
Q_INVOKABLE QVariant get(int index) const;
Q_INVOKABLE void put(const QVariant &variant);
};
Q_DECLARE_METATYPE(CalendarItems)

40
libnymea/time/repeatingoption.cpp
View File

@ -210,3 +210,43 @@ QDebug operator<<(QDebug dbg, const RepeatingOption &repeatingOption)
dbg.nospace() << "RepeatingOption(Mode:" << repeatingOption.mode() << ", Monthdays:" << repeatingOption.monthDays() << "Weekdays:" << repeatingOption.weekDays() << ")";
return dbg;
}
WeekDays::WeekDays()
{
}
WeekDays::WeekDays(const QList<int> &other): QList<int>(other)
{
}
QVariant WeekDays::get(int index) const
{
return at(index);
}
void WeekDays::put(const QVariant &value)
{
append(value.toInt());
}
MonthDays::MonthDays()
{
}
MonthDays::MonthDays(const QList<int> &other): QList<int>(other)
{
}
QVariant MonthDays::get(int index) const
{
return at(index);
}
void MonthDays::put(const QVariant &value)
{
append(value.toInt());
}

25
libnymea/time/repeatingoption.h
View File

@ -23,9 +23,34 @@
#include <QList>
#include <QMetaType>
#include <QVariant>
class QDateTime;
class WeekDays: public QList<int>
{
Q_GADGET
Q_PROPERTY(int count READ count)
public:
WeekDays();
WeekDays(const QList<int> &other);
Q_INVOKABLE QVariant get(int index) const;
Q_INVOKABLE void put(const QVariant &value);
};
Q_DECLARE_METATYPE(WeekDays)
class MonthDays: public QList<int>
{
Q_GADGET
Q_PROPERTY(int count READ count)
public:
MonthDays();
MonthDays(const QList<int> &other);
Q_INVOKABLE QVariant get(int index) const;
Q_INVOKABLE void put(const QVariant &value);
};
Q_DECLARE_METATYPE(MonthDays)
class RepeatingOption
{
Q_GADGET

8
libnymea/time/timedescriptor.cpp
View File

@ -43,25 +43,25 @@ TimeDescriptor::TimeDescriptor()
}
/*! Returns the list of \l{TimeEventItem}{TimeEventItems} of this \l{TimeDescriptor}.*/
QList<TimeEventItem> TimeDescriptor::timeEventItems() const
TimeEventItems TimeDescriptor::timeEventItems() const
{
return m_timeEventItems;
}
/*! Set the list of \l{TimeEventItem}{TimeEventItems} of this \l{TimeDescriptor} to the given \a timeEventItems.*/
void TimeDescriptor::setTimeEventItems(const QList<TimeEventItem> &timeEventItems)
void TimeDescriptor::setTimeEventItems(const TimeEventItems &timeEventItems)
{
m_timeEventItems = timeEventItems;
}
/*! Returns the list of \l{CalendarItem}{CalendarItems} of this \l{TimeDescriptor}.*/
QList<CalendarItem> TimeDescriptor::calendarItems() const
CalendarItems TimeDescriptor::calendarItems() const
{
return m_calendarItems;
}
/*! Set the list of \l{CalendarItem}{CalendarItems} of this \l{TimeDescriptor} to the given \a calendarItems.*/
void TimeDescriptor::setCalendarItems(const QList<CalendarItem> &calendarItems)
void TimeDescriptor::setCalendarItems(const CalendarItems &calendarItems)
{
m_calendarItems = calendarItems;
}

14
libnymea/time/timedescriptor.h
View File

@ -32,13 +32,13 @@ class TimeDescriptor
public:
explicit TimeDescriptor();
QList<TimeEventItem> timeEventItems() const;
void setTimeEventItems(const QList<TimeEventItem> &timeEventItems);
TimeEventItems timeEventItems() const;
void setTimeEventItems(const TimeEventItems &timeEventItems);
QList<CalendarItem> calendarItems() const;
void setCalendarItems(const QList<CalendarItem> &calendarItems);
CalendarItems calendarItems() const;
void setCalendarItems(const CalendarItems &calendarItems);
bool isValid() const;
Q_INVOKABLE bool isValid() const;
bool isEmpty() const;
bool evaluate(const QDateTime &lastEvaluationTime, const QDateTime &dateTime) const;
@ -48,8 +48,8 @@ public:
private:
QList<TimeEventItem> m_timeEventItems;
QList<CalendarItem> m_calendarItems;
TimeEventItems m_timeEventItems;
CalendarItems m_calendarItems;
};

5
libnymea/time/timeeventitem.cpp
View File

@ -154,3 +154,8 @@ QVariant TimeEventItems::get(int index) const
{
return QVariant::fromValue(at(index));
}
void TimeEventItems::put(const QVariant &variant)
{
append(variant.value<TimeEventItem>());
}

1
libnymea/time/timeeventitem.h
View File

@ -66,6 +66,7 @@ public:
TimeEventItems();
TimeEventItems(const QList<TimeEventItem> &other);
Q_INVOKABLE QVariant get(int index) const;
Q_INVOKABLE void put(const QVariant &variant);
};
Q_DECLARE_METATYPE(TimeEventItems)

7
libnymea/types/actiontype.cpp
View File

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

3
libnymea/types/actiontype.h
View File

@ -77,7 +77,8 @@ class ActionTypes: public QList<ActionType>
public:
ActionTypes() = default;
ActionTypes(const QList<ActionType> &other);
Q_INVOKABLE QVariant get(int index);
Q_INVOKABLE QVariant get(int index) const;
Q_INVOKABLE void put(const QVariant &variant);
ActionType findByName(const QString &name);
ActionType findById(const ActionTypeId &id);
};

5
libnymea/types/eventdescriptor.cpp
View File

@ -204,3 +204,8 @@ QVariant EventDescriptors::get(int index) const
{
return QVariant::fromValue(at(index));
}
void EventDescriptors::put(const QVariant &variant)
{
append(variant.value<EventDescriptor>());
}

1
libnymea/types/eventdescriptor.h
View File

@ -89,6 +89,7 @@ public:
EventDescriptors();
EventDescriptors(const QList<EventDescriptor> &other);
Q_INVOKABLE QVariant get(int index) const;
Q_INVOKABLE void put(const QVariant &variant);
};
Q_DECLARE_METATYPE(EventDescriptors)

7
libnymea/types/eventtype.cpp
View File

@ -128,11 +128,16 @@ EventTypes::EventTypes(const QList<EventType> &other)
}
}
QVariant EventTypes::get(int index)
QVariant EventTypes::get(int index) const
{
return QVariant::fromValue(at(index));
}
void EventTypes::put(const QVariant &variant)
{
append(variant.value<EventType>());
}
EventType EventTypes::findByName(const QString &name)
{
foreach (const EventType &eventType, *this) {

3
libnymea/types/eventtype.h
View File

@ -78,7 +78,8 @@ class EventTypes: public QList<EventType>
public:
EventTypes() = default;
EventTypes(const QList<EventType> &other);
Q_INVOKABLE QVariant get(int index);
Q_INVOKABLE QVariant get(int index) const;
Q_INVOKABLE void put(const QVariant &variant);
EventType findByName(const QString &name);
EventType findById(const EventTypeId &id);
};

10
libnymea/types/param.cpp
View File

@ -48,6 +48,11 @@ ParamTypeId Param::paramTypeId() const
return m_paramTypeId;
}
void Param::setParamTypeId(const ParamTypeId &paramTypeId)
{
m_paramTypeId = paramTypeId;
}
/*! Returns the value of this \l Param. */
QVariant Param::value() const
{
@ -114,6 +119,11 @@ QVariant ParamList::get(int index)
return QVariant::fromValue(at(index));
}
void ParamList::put(const QVariant &variant)
{
append(variant.value<Param>());
}
/*! Returns true if this ParamList contains a Param with the given \a paramTypeId. */
bool ParamList::hasParam(const ParamTypeId &paramTypeId) const
{

4
libnymea/types/param.h
View File

@ -33,12 +33,13 @@
class LIBNYMEA_EXPORT Param
{
Q_GADGET
Q_PROPERTY(QUuid paramTypeId READ paramTypeId USER true)
Q_PROPERTY(QUuid paramTypeId READ paramTypeId WRITE setParamTypeId USER true)
Q_PROPERTY(QVariant value READ value WRITE setValue)
public:
Param(const ParamTypeId &paramTypeId = ParamTypeId(), const QVariant &value = QVariant());
ParamTypeId paramTypeId() const;
void setParamTypeId(const ParamTypeId &paramTypeId);
QVariant value() const;
void setValue(const QVariant &value);
@ -61,6 +62,7 @@ public:
ParamList();
ParamList(const QList<Param> &other);
Q_INVOKABLE QVariant get(int index);
Q_INVOKABLE void put(const QVariant &variant);
bool hasParam(const ParamTypeId &paramTypeId) const;
QVariant paramValue(const ParamTypeId &paramTypeId) const;
bool setParamValue(const ParamTypeId &paramTypeId, const QVariant &value);

5
libnymea/types/paramdescriptor.cpp
View File

@ -101,3 +101,8 @@ QVariant ParamDescriptors::get(int index) const
{
return QVariant::fromValue(at(index));
}
void ParamDescriptors::put(const QVariant &variant)
{
append(variant.value<ParamDescriptor>());
}

1
libnymea/types/paramdescriptor.h
View File

@ -59,6 +59,7 @@ public:
ParamDescriptors();
ParamDescriptors(const QList<ParamDescriptor> &other);
Q_INVOKABLE QVariant get(int index) const;
Q_INVOKABLE void put(const QVariant &variant);
};
Q_DECLARE_METATYPE(ParamDescriptors)

7
libnymea/types/paramtype.cpp
View File

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

3
libnymea/types/paramtype.h
View File

@ -115,7 +115,8 @@ class ParamTypes: public QList<ParamType>
public:
ParamTypes() = default;
ParamTypes(const QList<ParamType> &other);
Q_INVOKABLE QVariant get(int index);
Q_INVOKABLE QVariant get(int index) const;
Q_INVOKABLE void put(const QVariant &variant);
ParamType findByName(const QString &name);
ParamType findById(const ParamTypeId &id);
};

7
libnymea/types/state.cpp
View File

@ -108,7 +108,12 @@ States::States(const QList<State> &other): QList<State>(other)
}
QVariant States::get(int index)
QVariant States::get(int index) const
{
return QVariant::fromValue(at(index));
}
void States::put(const QVariant &variant)
{
append(variant.value<State>());
}

3
libnymea/types/state.h
View File

@ -63,7 +63,8 @@ class States: public QList<State>
public:
States();
States(const QList<State> &other);
Q_INVOKABLE QVariant get(int index);
Q_INVOKABLE QVariant get(int index) const;
Q_INVOKABLE void put(const QVariant &variant);
};
Q_DECLARE_METATYPE(States)

5
libnymea/types/statedescriptor.h
View File

@ -73,7 +73,7 @@ public:
Types::ValueOperator operatorType() const;
void setOperatorType(Types::ValueOperator opertatorType);
bool isValid() const;
Q_INVOKABLE bool isValid() const;
bool operator ==(const StateDescriptor &other) const;
@ -86,8 +86,9 @@ private:
QString m_interface;
QString m_interfaceState;
QVariant m_stateValue;
Types::ValueOperator m_operatorType;
Types::ValueOperator m_operatorType = Types::ValueOperatorEquals;
};
Q_DECLARE_METATYPE(StateDescriptor)
QDebug operator<<(QDebug dbg, const StateDescriptor &stateDescriptor);

7
libnymea/types/statetype.cpp
View File

@ -198,11 +198,16 @@ StateTypes::StateTypes(const QList<StateType> &other)
}
}
QVariant StateTypes::get(int index)
QVariant StateTypes::get(int index) const
{
return QVariant::fromValue(at(index));
}
void StateTypes::put(const QVariant &variant)
{
append(variant.value<StateType>());
}
StateType StateTypes::findByName(const QString &name)
{
foreach (const StateType &stateType, *this) {

3
libnymea/types/statetype.h
View File

@ -105,7 +105,8 @@ class StateTypes: public QList<StateType>
public:
StateTypes() = default;
StateTypes(const QList<StateType> &other);
Q_INVOKABLE QVariant get(int index);
Q_INVOKABLE QVariant get(int index) const;
Q_INVOKABLE void put(const QVariant &variant);
StateType findByName(const QString &name);
StateType findById(const StateTypeId &id);
};

5
libnymea/types/vendor.cpp
View File

@ -33,6 +33,11 @@
#include "vendor.h"
Vendor::Vendor()
{
}
/*! Constructs an Vendor with the given \a id and the given \a name. */
Vendor::Vendor(const VendorId &id, const QString &name):
m_id(id),

3
libnymea/types/vendor.h
View File

@ -38,6 +38,7 @@ class LIBNYMEA_EXPORT Vendor
Q_PROPERTY(QString displayName READ displayName WRITE setDisplayName)
public:
Vendor();
Vendor(const VendorId &id, const QString &name = QString());
VendorId id() const;
@ -56,6 +57,7 @@ private:
QString m_name;
QString m_displayName;
};
Q_DECLARE_METATYPE(Vendor)
class LIBNYMEA_EXPORT Vendors: public QList<Vendor>
{
@ -65,5 +67,6 @@ public:
Vendor findById(const VendorId &vendorId) const;
};
Q_DECLARE_METATYPE(Vendors)
#endif // VENDOR_H

7
tests/auto/devices/testdevices.cpp
View File

@ -353,7 +353,10 @@ void TestDevices::addConfiguredDevice_data()
QTest::newRow("User, JustAdd, wrong param") << mockDeviceClassId << invalidDeviceParams << true << Device::DeviceErrorInvalidParameter;
deviceParams.clear(); deviceParams << httpportParam << fakeparam;
QTest::newRow("USer, JustAdd, additional invalid param") << mockDeviceClassId << deviceParams << Device::DeviceErrorNoError;
QTest::newRow("USer, JustAdd, additional invalid param") << mockDeviceClassId << deviceParams << false << Device::DeviceErrorNoError;
deviceParams.clear(); deviceParams << httpportParam << fakeparam2;
QTest::newRow("USer, JustAdd, additional param, valid but unused") << mockDeviceClassId << deviceParams << true << Device::DeviceErrorNoError;
}
@ -655,8 +658,8 @@ void TestDevices::parentChildDevices()
if (deviceMap.value("deviceClassId").toString() == mockChildDeviceClassId.toString()) {
if (deviceMap.value("parentId") == parentDeviceId.toString()) {
//qDebug() << QJsonDocument::fromVariant(deviceVariant).toJson();
childDeviceId = DeviceId(deviceMap.value("id").toString());
break;
}
}
}

47
tests/auto/rules/testrules.cpp
View File

@ -410,23 +410,19 @@ void TestRules::addRemoveRules_data()
QVariantMap validActionNoParams;
validActionNoParams.insert("actionTypeId", mockWithoutParamsActionTypeId);
validActionNoParams.insert("deviceId", m_mockDeviceId);
validActionNoParams.insert("ruleActionParams", QVariantList());
QVariantMap invalidAction;
invalidAction.insert("actionTypeId", ActionTypeId("f32c7efb-38b6-4576-a496-c75bbb23132f"));
invalidAction.insert("deviceId", m_mockDeviceId);
invalidAction.insert("ruleActionParams", QVariantList());
// RuleExitAction
QVariantMap validExitActionNoParams;
validExitActionNoParams.insert("actionTypeId", mockWithoutParamsActionTypeId);
validExitActionNoParams.insert("deviceId", m_mockDeviceId);
validExitActionNoParams.insert("ruleActionParams", QVariantList());
QVariantMap invalidExitAction;
invalidExitAction.insert("actionTypeId", ActionTypeId("f32c7efb-38b6-4576-a496-c75bbb23132f"));
invalidExitAction.insert("deviceId", m_mockDeviceId);
invalidExitAction.insert("ruleActionParams", QVariantList());
// StateDescriptor
QVariantMap stateDescriptor;
@ -448,7 +444,6 @@ void TestRules::addRemoveRules_data()
QVariantMap validEventDescriptor1;
validEventDescriptor1.insert("eventTypeId", mockEvent1EventTypeId);
validEventDescriptor1.insert("deviceId", m_mockDeviceId);
validEventDescriptor1.insert("paramDescriptors", QVariantList());
QVariantMap validEventDescriptor2;
validEventDescriptor2.insert("eventTypeId", mockEvent2EventTypeId);
@ -464,7 +459,6 @@ void TestRules::addRemoveRules_data()
QVariantMap validEventDescriptor3;
validEventDescriptor3.insert("eventTypeId", mockEvent2EventTypeId);
validEventDescriptor3.insert("deviceId", m_mockDeviceId);
validEventDescriptor3.insert("paramDescriptors", QVariantList());
// EventDescriptorList
QVariantList eventDescriptorList;
@ -474,7 +468,6 @@ void TestRules::addRemoveRules_data()
QVariantMap invalidEventDescriptor;
invalidEventDescriptor.insert("eventTypeId", mockEvent1EventTypeId);
invalidEventDescriptor.insert("deviceId", DeviceId("2c4825c8-dfb9-4ba4-bd0e-1d827d945d41"));
invalidEventDescriptor.insert("paramDescriptors", QVariantList());
// RuleAction event based
QVariantMap validActionEventBased;
@ -617,7 +610,10 @@ void TestRules::addRemoveRules()
QVariantList eventDescriptors = rule.value("eventDescriptors").toList();
if (!eventDescriptor.isEmpty()) {
QVERIFY2(eventDescriptors.count() == 1, "There should be exactly one eventDescriptor");
QVERIFY2(eventDescriptors.first().toMap() == eventDescriptor, "Event descriptor doesn't match");
QVERIFY2(eventDescriptors.first().toMap() == eventDescriptor,
QString("Event descriptor doesn't match:\nExpected: %1\nGot: %2")
.arg(QString(QJsonDocument::fromVariant(eventDescriptor).toJson()))
.arg(QString(QJsonDocument::fromVariant(eventDescriptors.first().toMap()).toJson())).toUtf8());
} else if (eventDescriptorList.isEmpty()){
QVERIFY2(eventDescriptors.count() == eventDescriptorList.count(), QString("There should be exactly %1 eventDescriptor").arg(eventDescriptorList.count()).toLatin1().data());
foreach (const QVariant &eventDescriptorVariant, eventDescriptorList) {
@ -634,7 +630,11 @@ void TestRules::addRemoveRules()
}
QVariantList replyActions = rule.value("actions").toList();
QVERIFY2(actions == replyActions, "Actions don't match");
QVERIFY2(actions == replyActions,
QString("Actions don't match.\nExpected: %1\nGot: %2")
.arg(QString(QJsonDocument::fromVariant(actions).toJson()))
.arg(QString(QJsonDocument::fromVariant(replyActions).toJson()))
.toUtf8());
QVariantList replyExitActions = rule.value("exitActions").toList();
QVERIFY2(exitActions == replyExitActions, "ExitActions don't match");
@ -655,23 +655,19 @@ void TestRules::editRules_data()
QVariantMap validActionNoParams;
validActionNoParams.insert("actionTypeId", mockWithoutParamsActionTypeId);
validActionNoParams.insert("deviceId", m_mockDeviceId);
validActionNoParams.insert("ruleActionParams", QVariantList());
QVariantMap invalidAction;
invalidAction.insert("actionTypeId", ActionTypeId());
invalidAction.insert("deviceId", m_mockDeviceId);
invalidAction.insert("ruleActionParams", QVariantList());
// RuleExitAction
QVariantMap validExitActionNoParams;
validExitActionNoParams.insert("actionTypeId", mockWithoutParamsActionTypeId);
validExitActionNoParams.insert("deviceId", m_mockDeviceId);
validExitActionNoParams.insert("ruleActionParams", QVariantList());
QVariantMap invalidExitAction;
invalidExitAction.insert("actionTypeId", ActionTypeId());
invalidExitAction.insert("deviceId", m_mockDeviceId);
invalidExitAction.insert("ruleActionParams", QVariantList());
// StateDescriptor
QVariantMap stateDescriptor;
@ -693,7 +689,6 @@ void TestRules::editRules_data()
QVariantMap validEventDescriptor1;
validEventDescriptor1.insert("eventTypeId", mockEvent1EventTypeId);
validEventDescriptor1.insert("deviceId", m_mockDeviceId);
validEventDescriptor1.insert("paramDescriptors", QVariantList());
QVariantMap validEventDescriptor2;
validEventDescriptor2.insert("eventTypeId", mockEvent2EventTypeId);
@ -709,7 +704,6 @@ void TestRules::editRules_data()
QVariantMap validEventDescriptor3;
validEventDescriptor3.insert("eventTypeId", mockEvent2EventTypeId);
validEventDescriptor3.insert("deviceId", m_mockDeviceId);
validEventDescriptor3.insert("paramDescriptors", QVariantList());
// EventDescriptorList
QVariantList eventDescriptorList;
@ -719,7 +713,6 @@ void TestRules::editRules_data()
QVariantMap invalidEventDescriptor;
invalidEventDescriptor.insert("eventTypeId", mockEvent1EventTypeId);
invalidEventDescriptor.insert("deviceId", DeviceId());
invalidEventDescriptor.insert("paramDescriptors", QVariantList());
// RuleAction event based
QVariantMap validActionEventBased;
@ -809,11 +802,9 @@ void TestRules::editRules()
QVariantMap eventDescriptor1;
eventDescriptor1.insert("eventTypeId", mockEvent1EventTypeId);
eventDescriptor1.insert("deviceId", m_mockDeviceId);
eventDescriptor1.insert("paramDescriptors", QVariantList());
QVariantMap eventDescriptor2;
eventDescriptor2.insert("eventTypeId", mockEvent2EventTypeId);
eventDescriptor2.insert("deviceId", m_mockDeviceId);
eventDescriptor2.insert("paramDescriptors", QVariantList());
QVariantMap eventParam1;
eventParam1.insert("paramTypeId", mockEvent2EventIntParamParamTypeId);
eventParam1.insert("value", 3);
@ -948,7 +939,10 @@ void TestRules::editRules()
QVariantList eventDescriptors = rule.value("eventDescriptors").toList();
if (!eventDescriptor.isEmpty()) {
QVERIFY2(eventDescriptors.count() == 1, "There should be exactly one eventDescriptor");
QVERIFY2(eventDescriptors.first().toMap() == eventDescriptor, "Event descriptor doesn't match");
QVERIFY2(eventDescriptors.first().toMap() == eventDescriptor,
QString("Event descriptor doesn't match.\nExpected:%1\nGot:%2")
.arg(QString(QJsonDocument::fromVariant(eventDescriptor).toJson()))
.arg(QString(QJsonDocument::fromVariant(eventDescriptors.first().toMap()).toJson())).toUtf8());
} else if (eventDescriptorList.isEmpty()){
QVERIFY2(eventDescriptors.count() == eventDescriptorList.count(), QString("There should be exactly %1 eventDescriptor").arg(eventDescriptorList.count()).toLatin1().data());
foreach (const QVariant &eventDescriptorVariant, eventDescriptorList) {
@ -965,7 +959,11 @@ void TestRules::editRules()
}
QVariantList replyActions = rule.value("actions").toList();
QVERIFY2(actions == replyActions, "Actions don't match");
QVERIFY2(actions == replyActions,
QString("Actions don't match.\nExpected: %1\nGot: %2")
.arg(QString(QJsonDocument::fromVariant(actions).toJson()))
.arg(QString(QJsonDocument::fromVariant(replyActions).toJson()))
.toUtf8());
QVariantList replyExitActions = rule.value("exitActions").toList();
QVERIFY2(exitActions == replyExitActions, "ExitActions don't match");
@ -1103,12 +1101,10 @@ void TestRules::loadStoreConfig()
QVariantMap eventDescriptor1;
eventDescriptor1.insert("eventTypeId", mockEvent1EventTypeId);
eventDescriptor1.insert("deviceId", m_mockDeviceId);
eventDescriptor1.insert("paramDescriptors", QVariantList());
QVariantMap eventDescriptor2;
eventDescriptor2.insert("eventTypeId", mockEvent2EventTypeId);
eventDescriptor2.insert("deviceId", m_mockDeviceId);
eventDescriptor2.insert("paramDescriptors", QVariantList());
QVariantList eventParamDescriptors;
QVariantMap eventParam1;
eventParam1.insert("paramTypeId", mockEvent2EventIntParamParamTypeId);
@ -1195,7 +1191,6 @@ void TestRules::loadStoreConfig()
QVariantMap validEventDescriptor3;
validEventDescriptor3.insert("eventTypeId", mockEvent2EventTypeId);
validEventDescriptor3.insert("deviceId", m_mockDeviceId);
validEventDescriptor3.insert("paramDescriptors", QVariantList());
validEventDescriptors3.append(validEventDescriptor3);
// Interface based event descriptor
@ -1332,7 +1327,11 @@ void TestRules::loadStoreConfig()
expectedEventDescriptorVariant.toMap().value("deviceId") == replyEventDescriptorVariant.toMap().value("deviceId")) {
found = true;
qDebug() << endl << replyEventDescriptorVariant << endl << expectedEventDescriptorVariant;
QVERIFY2(replyEventDescriptorVariant == expectedEventDescriptorVariant, "EventDescriptor doesn't match");
QVERIFY2(replyEventDescriptorVariant == expectedEventDescriptorVariant,
QString("EventDescriptor doesn't match.\nExpected: %1\nGot: %2")
.arg(QString(QJsonDocument::fromVariant(expectedEventDescriptorVariant).toJson()))
.arg(QString(QJsonDocument::fromVariant(replyEventDescriptorVariant).toJson()))
.toUtf8());
}
}
QVERIFY2(found, "missing eventdescriptor");

17
tests/auto/timemanager/testtimemanager.cpp
View File

@ -204,7 +204,7 @@ void TestTimeManager::loadSaveTimeDescriptor_data()
QTest::addColumn<QVariantMap>("timeDescriptor");
QTest::newRow("calendarItems") << createTimeDescriptorCalendar(calendarItems);
QTest::newRow("timeEventItems") << createTimeDescriptorTimeEvent(timeEventItems);
// QTest::newRow("timeEventItems") << createTimeDescriptorTimeEvent(timeEventItems);
}
void TestTimeManager::loadSaveTimeDescriptor()
@ -225,6 +225,7 @@ void TestTimeManager::loadSaveTimeDescriptor()
ruleMap.insert("actions", QVariantList() << action);
// Add the rule
qCDebug(dcTests()) << "Adding rule:" << qUtf8Printable(QJsonDocument::fromVariant(ruleMap).toJson());
QVariant response = injectAndWait("Rules.AddRule", ruleMap);
verifyRuleError(response);
@ -237,6 +238,12 @@ void TestTimeManager::loadSaveTimeDescriptor()
QVariantMap timeDescriptorMap = response.toMap().value("params").toMap().value("rule").toMap().value("timeDescriptor").toMap();
QVERIFY2(timeDescriptorMap == timeDescriptor,
QString("TimeDescriptor not matching:\nExpected: %1\nGot: %2")
.arg(QString(QJsonDocument::fromVariant(timeDescriptor).toJson()))
.arg(QString(QJsonDocument::fromVariant(timeDescriptorMap).toJson()))
.toUtf8());
// Restart the server
restartServer();
@ -246,8 +253,14 @@ void TestTimeManager::loadSaveTimeDescriptor()
QVariantMap timeDescriptorMapLoaded = response.toMap().value("params").toMap().value("rule").toMap().value("timeDescriptor").toMap();
QCOMPARE(timeDescriptorMap, timeDescriptorMapLoaded);
QVERIFY2(timeDescriptorMap == timeDescriptorMapLoaded,
QString("TimeDescriptor not matching:\nExpected: %1\nGot: %2")
.arg(QString(QJsonDocument::fromVariant(timeDescriptorMap).toJson()))
.arg(QString(QJsonDocument::fromVariant(timeDescriptorMapLoaded).toJson()))
.toUtf8());
// qWarning() << "+++" << QString(QJsonDocument::fromVariant(timeDescriptorMap).toJson());
// qWarning() << "---" << QString(QJsonDocument::fromVariant(timeDescriptorMapLoaded).toJson());
// REMOVE rule
QVariantMap removeParams;
removeParams.insert("ruleId", ruleId);

9
tests/scripts/getruledetails.sh
View File

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

8
tests/scripts/getrules.sh
View File

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

9
tests/scripts/snoopnotifications.sh
View File

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

8
tests/testlib/nymeatestbase.cpp
View File

@ -46,10 +46,9 @@ NymeaTestBase::NymeaTestBase(QObject *parent) :
void NymeaTestBase::initTestCase()
{
qDebug() << "NymeaTestBase starting.";
qCDebug(dcTests) << "NymeaTestBase starting.";
// If testcase asserts cleanup won't do. Lets clear any previous test run settings leftovers
qDebug() << "Reset test settings";
NymeaSettings rulesSettings(NymeaSettings::SettingsRoleRules);
rulesSettings.clear();
NymeaSettings deviceSettings(NymeaSettings::SettingsRoleDevices);
@ -66,12 +65,14 @@ void NymeaTestBase::initTestCase()
QLoggingCategory::setFilterRules("*.debug=false\nTests.debug=true\nMockDevice.debug=true");
// Start the server
qCDebug(dcTests()) << "Setting up nymea core instance";
NymeaCore::instance()->init();
// Wait unitl the server is initialized
QSignalSpy coreInitializedSpy(NymeaCore::instance(), SIGNAL(initialized()));
QVERIFY(coreInitializedSpy.wait());
qApp->processEvents();
qCDebug(dcTests()) << "Nymea core instance initialized. Creating dummy user.";
// Yes, we're intentionally mixing upper/lower case email here... username should not be case sensitive
NymeaCore::instance()->userManager()->removeUser("dummy@guh.io");
@ -79,7 +80,7 @@ void NymeaTestBase::initTestCase()
m_apiToken = NymeaCore::instance()->userManager()->authenticate("Dummy@guh.io", "DummyPW1!", "testcase");
if (MockTcpServer::servers().isEmpty()) {
qWarning() << "no mock tcp server found";
qCWarning(dcTests) << "no mock tcp server found";
exit(-1);
}
@ -88,6 +89,7 @@ void NymeaTestBase::initTestCase()
m_clientId = QUuid::createUuid();
m_mockTcpServer->clientConnected(m_clientId);
qCDebug(dcTests()) << "Starting JSON handshake";
QVariant response = injectAndWait("JSONRPC.Hello");
createMockDevice();