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

change how actions are stored. they don't belong to a device but into the rules engine

Browse Source
This commit is contained in:
Michael Zanetti 2014-01-02 14:51:31 +01:00
parent 417a4e8573
commit 7a87dc7696
11 changed files with 88 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
libhive/action.cpp
View File

@ -1,7 +1,8 @@
#include "action.h"
Action::Action(const QUuid &id) :
m_id(id)
Action::Action(const QUuid &id, const QUuid &deviceId) :
m_id(id),
m_deviceId(deviceId)
{
}
@ -15,6 +16,11 @@ QUuid Action::id() const
return m_id;
}
QUuid Action::deviceId() const
{
return m_deviceId;
}
QString Action::name() const
{
return m_name;
@ -34,4 +40,3 @@ void Action::setParams(const QVariantList &params)
{
m_params = params;
}

4
libhive/action.h
View File

@ -7,10 +7,11 @@
class Action
{
public:
Action(const QUuid &id = QUuid());
Action(const QUuid &id = QUuid(), const QUuid &deviceId = QUuid());
bool isValid() const;
QUuid id() const;
QUuid deviceId() const;
QString name() const;
void setName(const QString &name);
@ -20,6 +21,7 @@ public:
private:
QUuid m_id;
QUuid m_deviceId;
QString m_name;
QVariantList m_params;
};

51
libhive/devicemanager.cpp
View File

@ -62,14 +62,6 @@ DeviceManager::DeviceError DeviceManager::addConfiguredDevice(const QUuid &devic
triggers.append(trigger);
}
device->setTriggers(triggers);
QList<Action> actions;
foreach (const ActionType &actionType, deviceClass.actions()) {
Action action(QUuid::createUuid());
action.setName(actionType.name());
action.setParams(actionType.parameters());
actions.append(action);
}
device->setActions(actions);
m_configuredDevices.append(device);
storeConfiguredDevices();
@ -127,21 +119,31 @@ Action DeviceManager::findAction(const QUuid &actionId)
return Action();
}
QList<Action> DeviceManager::allActions() const
{
QList<Action> ret;
foreach (Device *device, m_configuredDevices) {
foreach (const Action &action, device->actions()) {
ret << action;
}
}
return ret;
}
Radio433 *DeviceManager::radio433() const
{
return m_radio433;
}
void DeviceManager::executeAction(const QUuid &actionId, const QVariantMap &params)
DeviceManager::DeviceError DeviceManager::executeAction(const Action &action)
{
foreach (Device *device, m_configuredDevices) {
foreach (const Action &action, device->actions()) {
if (action.id() == actionId) {
m_devicePlugins.value(device->pluginId())->executeAction(device, action);
return;
}
if (action.deviceId() == device->id()) {
m_devicePlugins.value(device->pluginId())->executeAction(device, action);
return DeviceErrorNoError;
}
}
return DeviceErrorDeviceNotFound;
}
void DeviceManager::loadPlugins()
@ -185,19 +187,6 @@ void DeviceManager::loadConfiguredDevices()
}
device->setTriggers(triggerList);
settings.endGroup();
settings.beginGroup("actions");
QList<Action> actionList;
foreach (const QString &actionId, settings.childGroups()) {
settings.beginGroup(actionId);
QUuid id(actionId);
Action action(id);
action.setName(settings.value("actionname").toString());
action.setParams(settings.value("params").toList());
settings.endGroup();
actionList.append(action);
}
device->setActions(actionList);
settings.endGroup();
settings.endGroup();
m_configuredDevices.append(device);
}
@ -220,14 +209,6 @@ void DeviceManager::storeConfiguredDevices()
settings.endGroup();
}
settings.endGroup();
settings.beginGroup("actions");
foreach (const Action &action, device->actions()) {
settings.beginGroup(action.id().toString());
settings.setValue("actionname", action.name());
settings.setValue("params", action.params());
settings.endGroup();
}
settings.endGroup();
settings.endGroup();
}
}

4
libhive/devicemanager.h
View File

@ -36,13 +36,15 @@ public:
Trigger findTrigger(const QUuid &triggerId);
Action findAction(const QUuid &actionId);
QList<Action> allActions() const;
Radio433 *radio433() const;
signals:
void emitTrigger(const QUuid &triggerId, const QVariantMap &params);
public slots:
void executeAction(const QUuid &actionId, const QVariantMap &params);
DeviceError executeAction(const Action &action);
private slots:
void loadPlugins();

4
server/hivecore.cpp
View File

@ -54,7 +54,7 @@ void HiveCore::gotSignal(const QUuid &triggerId, const QVariantMap &params)
qDebug() << "id: " << triggerId;
qDebug() << params;
foreach (const QUuid &actionId, m_ruleEngine->evaluateTrigger(triggerId)) {
m_deviceManager->executeAction(actionId, params);
foreach (const Action &action, m_ruleEngine->evaluateTrigger(triggerId)) {
m_deviceManager->executeAction(action);
}
}

40
server/jsonrpcserver.cpp
View File

@ -45,14 +45,14 @@ void JsonRPCServer::processData(int clientId, const QByteArray &jsonData)
return;
}
QString targetNamspace = commandList.first();
QString targetNamespace = commandList.first();
QString method = commandList.last();
QVariantMap params = message.value("params").toMap();
qDebug() << "got:" << targetNamspace << method << params;
emit commandReceived(targetNamspace, method, params);
qDebug() << "got:" << targetNamespace << method << params;
emit commandReceived(targetNamespace, method, params);
if (targetNamspace == "Devices") {
if (targetNamespace == "Devices") {
if (method == "GetSupportedDevices") {
QVariantMap params;
QVariantList supportedDeviceList;
@ -87,10 +87,12 @@ void JsonRPCServer::processData(int clientId, const QByteArray &jsonData)
} else {
sendErrorResponse(clientId, commandId, "No such method");
}
} else if (targetNamspace == "Rules") {
} else if (targetNamespace == "Rules") {
handleRulesMessage(clientId, commandId, method, params);
} else if (targetNamespace == "Actions") {
handleActionMessage(clientId, commandId, method, params);
} else {
qDebug() << "got unknown namespace" << targetNamspace;
qDebug() << "got unknown namespace" << targetNamespace;
}
}
@ -102,7 +104,7 @@ void JsonRPCServer::handleRulesMessage(int clientId, int commandId, const QStrin
QVariantMap ruleMap;
ruleMap.insert("id", rule.id());
ruleMap.insert("triggerId", rule.triggerId());
ruleMap.insert("actionId", rule.actionId());
ruleMap.insert("action", packAction(rule.action()));
rulesList.append(ruleMap);
}
QVariantMap rspParams;
@ -125,6 +127,20 @@ void JsonRPCServer::handleRulesMessage(int clientId, int commandId, const QStrin
}
}
void JsonRPCServer::handleActionMessage(int clientId, int commandId, const QString &method, const QVariantMap &params)
{
if (method == "ExecuteAction") {
QUuid deviceId = QUuid(params.value("deviceId").toUuid());
QVariantList actionParams = params.value("params").toList();
Action action(QUuid::createUuid(), deviceId);
action.setParams(actionParams);
HiveCore::instance()->deviceManager()->executeAction(action);
}
}
QVariantMap JsonRPCServer::packDeviceClass(const DeviceClass &deviceClass)
{
QVariantMap variant;
@ -175,6 +191,16 @@ QVariantMap JsonRPCServer::packDevice(Device *device)
return variant;
}
QVariantMap JsonRPCServer::packAction(const Action &action)
{
QVariantMap variant;
variant.insert("id", action.id());
variant.insert("deviceId", action.deviceId());
variant.insert("name", action.name());
variant.insert("params", action.params());
return variant;
}
void JsonRPCServer::sendResponse(int clientId, int commandId, const QVariantMap &params)
{
QVariantMap rsp;

3
server/jsonrpcserver.h
View File

@ -2,6 +2,7 @@
#define JSONRPCSERVER_H
#include "deviceclass.h"
#include "action.h"
#include <QObject>
#include <QVariantMap>
@ -24,9 +25,11 @@ private slots:
private:
void handleRulesMessage(int clientId, int commandId, const QString &method, const QVariantMap &params);
void handleActionMessage(int clientId, int commandId, const QString &method, const QVariantMap &params);
QVariantMap packDeviceClass(const DeviceClass &deviceClass);
QVariantMap packDevice(Device *device);
QVariantMap packAction(const Action &action);
void sendResponse(int clientId, int commandId, const QVariantMap &params = QVariantMap());
void sendErrorResponse(int clientId, int commandId, const QString &error);

8
server/rule.cpp
View File

@ -1,9 +1,9 @@
#include "rule.h"
Rule::Rule(const QUuid &id, const QUuid &triggerId, const QUuid &actionId):
Rule::Rule(const QUuid &id, const QUuid &triggerId, const Action &action):
m_id(id),
m_triggerId(triggerId),
m_actionId(actionId)
m_action(action)
{
}
@ -17,7 +17,7 @@ QUuid Rule::triggerId() const
return m_triggerId;
}
QUuid Rule::actionId() const
Action Rule::action() const
{
return m_actionId;
return m_action;
}

8
server/rule.h
View File

@ -1,21 +1,23 @@
#ifndef RULE_H
#define RULE_H
#include "action.h"
#include <QUuid>
class Rule
{
public:
Rule(const QUuid &id, const QUuid &triggerId, const QUuid &actionId);
Rule(const QUuid &id, const QUuid &triggerId, const Action &action);
QUuid id() const;
QUuid triggerId() const;
QUuid actionId() const;
Action action() const;
private:
QUuid m_id;
QUuid m_triggerId;
QUuid m_actionId;
Action m_action;
};
#endif // RULE_H

14
server/ruleengine.cpp
View File

@ -25,12 +25,12 @@ RuleEngine::RuleEngine(QObject *parent) :
}
QList<QUuid> RuleEngine::evaluateTrigger(const QUuid &triggerId)
QList<Action> RuleEngine::evaluateTrigger(const QUuid &triggerId)
{
QList<QUuid> actions;
QList<Action> actions;
for (int i = 0; i < m_rules.count(); ++i) {
if (m_rules.at(i).triggerId() == triggerId) {
actions << m_rules.at(i).actionId();
actions << m_rules.at(i).action();
}
}
return actions;
@ -53,7 +53,13 @@ RuleEngine::RuleError RuleEngine::addRule(const QUuid &triggerId, const QUuid &a
QSettings settings(rulesFileName);
settings.beginGroup(rule.id().toString());
settings.setValue("triggerId", rule.triggerId());
settings.setValue("actionId", rule.actionId());
settings.beginGroup("action");
settings.setValue("id", rule.action().id());
settings.setValue("deviceId", rule.action().deviceId());
settings.setValue("name", rule.action().name());
settings.setValue("params", rule.action().params());
settings.endGroup();
return RuleErrorNoError;
}

2
server/ruleengine.h
View File

@ -19,7 +19,7 @@ public:
explicit RuleEngine(QObject *parent = 0);
QList<QUuid> evaluateTrigger(const QUuid &triggerId);
QList<Action> evaluateTrigger(const QUuid &triggerId);
RuleError addRule(const QUuid &triggerId, const QUuid &actionId);
QList<Rule> rules() const;