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

add device name

Browse Source 
clean up guhCore
This commit is contained in:
Simon Stürz 2016-02-29 11:56:46 +01:00 committed by Michael Zanetti
parent 6aa4af88e0
commit b2763cafd0
23 changed files with 105 additions and 307 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
guh.pri
View File

@ -2,7 +2,7 @@
GUH_VERSION_STRING=$$system('dpkg-parsechangelog | sed -n -e "s/^Version: //p"')
# define protocol versions
JSON_PROTOCOL_VERSION=37
JSON_PROTOCOL_VERSION=38
REST_API_VERSION=1
DEFINES += GUH_VERSION_STRING=\\\"$${GUH_VERSION_STRING}\\\" \

18
libguh/devicemanager.cpp
View File

@ -374,14 +374,14 @@ DeviceManager::DeviceError DeviceManager::discoverDevices(const DeviceClassId &d
* Optionally you can supply an id yourself if you must keep track of the added device. If you don't supply it, a new one will
* be generated. Only devices with \l{DeviceClass}{CreateMethodUser} can be created using this method.
* Returns \l{DeviceError} to inform about the result. */
DeviceManager::DeviceError DeviceManager::addConfiguredDevice(const DeviceClassId &deviceClassId, const ParamList &params, const DeviceId id)
DeviceManager::DeviceError DeviceManager::addConfiguredDevice(const DeviceClassId &deviceClassId, const QString &name, const ParamList &params, const DeviceId id)
{
DeviceClass deviceClass = findDeviceClass(deviceClassId);
if (!deviceClass.isValid()) {
return DeviceErrorDeviceClassNotFound;
}
if (deviceClass.createMethods().testFlag(DeviceClass::CreateMethodUser)) {
return addConfiguredDeviceInternal(deviceClassId, params, id);
return addConfiguredDeviceInternal(deviceClassId, name, params, id);
}
return DeviceErrorCreationMethodNotSupported;
}
@ -390,7 +390,7 @@ DeviceManager::DeviceError DeviceManager::addConfiguredDevice(const DeviceClassI
* can be created using this method. The \a deviceClassId must refer to an existing \l{DeviceClass} and the \a deviceDescriptorId must refer to an existing DeviceDescriptorId
* from the discovery.
* Returns \l{DeviceError} to inform about the result. */
DeviceManager::DeviceError DeviceManager::addConfiguredDevice(const DeviceClassId &deviceClassId, const DeviceDescriptorId &deviceDescriptorId, const DeviceId &deviceId)
DeviceManager::DeviceError DeviceManager::addConfiguredDevice(const DeviceClassId &deviceClassId, const QString &name, const DeviceDescriptorId &deviceDescriptorId, const DeviceId &deviceId)
{
DeviceClass deviceClass = findDeviceClass(deviceClassId);
if (!deviceClass.isValid()) {
@ -405,7 +405,7 @@ DeviceManager::DeviceError DeviceManager::addConfiguredDevice(const DeviceClassI
return DeviceErrorDeviceDescriptorNotFound;
}
return addConfiguredDeviceInternal(deviceClassId, descriptor.params(), deviceId);
return addConfiguredDeviceInternal(deviceClassId, name, descriptor.params(), deviceId);
}
@ -620,9 +620,9 @@ DeviceManager::DeviceError DeviceManager::confirmPairing(const PairingTransactio
return DeviceErrorPairingTransactionIdNotFound;
}
/*! This method will only be used from the DeviceManager in order to add a \l{Device} with the given \a deviceClassId, \a params and \ id.
/*! This method will only be used from the DeviceManager in order to add a \l{Device} with the given \a deviceClassId, \a name, \a params and \ id.
* Returns \l{DeviceError} to inform about the result. */
DeviceManager::DeviceError DeviceManager::addConfiguredDeviceInternal(const DeviceClassId &deviceClassId, const ParamList &params, const DeviceId id)
DeviceManager::DeviceError DeviceManager::addConfiguredDeviceInternal(const DeviceClassId &deviceClassId, const QString &name, const ParamList &params, const DeviceId id)
{
ParamList effectiveParams = params;
DeviceClass deviceClass = findDeviceClass(deviceClassId);
@ -651,7 +651,11 @@ DeviceManager::DeviceError DeviceManager::addConfiguredDeviceInternal(const Devi
}
Device *device = new Device(plugin->pluginId(), id, deviceClassId, this);
device->setName(deviceClass.name());
if (name.isEmpty()) {
device->setName(deviceClass.name());
} else {
device->setName(name);
}
device->setParams(effectiveParams);
DeviceSetupStatus status = setupDevice(device);

6
libguh/devicemanager.h
View File

@ -112,8 +112,8 @@ public:
DeviceError discoverDevices(const DeviceClassId &deviceClassId, const ParamList &params);
QList<Device*> configuredDevices() const;
DeviceError addConfiguredDevice(const DeviceClassId &deviceClassId, const ParamList &params, const DeviceId id = DeviceId::createDeviceId());
DeviceError addConfiguredDevice(const DeviceClassId &deviceClassId, const DeviceDescriptorId &deviceDescriptorId, const DeviceId &id = DeviceId::createDeviceId());
DeviceError addConfiguredDevice(const DeviceClassId &deviceClassId, const QString &name, const ParamList &params, const DeviceId id = DeviceId::createDeviceId());
DeviceError addConfiguredDevice(const DeviceClassId &deviceClassId, const QString &name, const DeviceDescriptorId &deviceDescriptorId, const DeviceId &id = DeviceId::createDeviceId());
DeviceError editDevice(const DeviceId &deviceId, const ParamList &params, bool fromDiscovery = false);
DeviceError editDevice(const DeviceId &deviceId, const DeviceDescriptorId &deviceDescriptorId);
@ -175,7 +175,7 @@ private slots:
private:
bool verifyPluginMetadata(const QJsonObject &data);
DeviceError addConfiguredDeviceInternal(const DeviceClassId &deviceClassId, const ParamList &params, const DeviceId id = DeviceId::createDeviceId());
DeviceError addConfiguredDeviceInternal(const DeviceClassId &deviceClassId, const QString &name, const ParamList &params, const DeviceId id = DeviceId::createDeviceId());
DeviceSetupStatus setupDevice(Device *device);
void postSetupDevice(Device *device);

185
server/guhcore.cpp
View File

@ -133,39 +133,11 @@ void GuhCore::destroy()
s_instance = 0;
}
/*! Calls the metheod DeviceManager::plugins().
* \sa DeviceManager::plugins(), */
QList<DevicePlugin *> GuhCore::plugins() const
{
return m_deviceManager->plugins();
}
/*! Calls the metheod DeviceManager::setPluginConfig(\a pluginId, \a params).
* \sa DeviceManager::setPluginConfig(), */
DeviceManager::DeviceError GuhCore::setPluginConfig(const PluginId &pluginId, const ParamList &params)
{
return m_deviceManager->setPluginConfig(pluginId, params);
}
/*! Calls the metheod DeviceManager::supportedVendors().
* \sa DeviceManager::supportedVendors(), */
QList<Vendor> GuhCore::supportedVendors() const
{
return m_deviceManager->supportedVendors();
}
/*! Calls the metheod DeviceManager::supportedDevices(\a vendorId).
* \sa DeviceManager::supportedDevices(), */
QList<DeviceClass> GuhCore::supportedDevices(const VendorId &vendorId) const
{
return m_deviceManager->supportedDevices(vendorId);
}
/*! Removes a configured \l{Device} with the given \a deviceId and \a removePolicyList. */
QPair<DeviceManager::DeviceError, QList<RuleId> > GuhCore::removeConfiguredDevice(const DeviceId &deviceId, const QHash<RuleId, RuleEngine::RemovePolicy> &removePolicyList)
{
// Check if this is a child device
Device *device = findConfiguredDevice(deviceId);
Device *device = m_deviceManager->findConfiguredDevice(deviceId);
if (!device)
return QPair<DeviceManager::DeviceError, QList<RuleId> > (DeviceManager::DeviceErrorDeviceNotFound, QList<RuleId>());
@ -253,7 +225,7 @@ QPair<DeviceManager::DeviceError, QList<RuleId> > GuhCore::removeConfiguredDevic
DeviceManager::DeviceError GuhCore::removeConfiguredDevice(const DeviceId &deviceId, const RuleEngine::RemovePolicy &removePolicy)
{
// Check if this is a child device
Device *device = findConfiguredDevice(deviceId);
Device *device = m_deviceManager->findConfiguredDevice(deviceId);
if (!device)
return DeviceManager::DeviceErrorDeviceNotFound;
@ -316,30 +288,6 @@ DeviceManager::DeviceError GuhCore::removeConfiguredDevice(const DeviceId &devic
return removeError;
}
/*! Calls the metheod DeviceManager::pairDevice(\a pairingTransactionId, \a deviceClassId, \a deviceDescriptorId).
* Returns \l{DeviceManager::DeviceError}{DeviceError} to inform about the result.
* \sa DeviceManager::pairDevice(), */
DeviceManager::DeviceError GuhCore::pairDevice(const PairingTransactionId &pairingTransactionId, const DeviceClassId &deviceClassId, const DeviceDescriptorId &deviceDescriptorId)
{
return m_deviceManager->pairDevice(pairingTransactionId, deviceClassId, deviceDescriptorId);
}
/*! Calls the metheod DeviceManager::pairDevice(\a pairingTransactionId, \a deviceClassId, \a params).
* Returns \l{DeviceManager::DeviceError}{DeviceError} to inform about the result.
* \sa DeviceManager::pairDevice(), */
DeviceManager::DeviceError GuhCore::pairDevice(const PairingTransactionId &pairingTransactionId, const DeviceClassId &deviceClassId, const ParamList &params)
{
return m_deviceManager->pairDevice(pairingTransactionId, deviceClassId, params);
}
/*! Calls the metheod DeviceManager::confirmPairing(\a pairingTransactionId, \a secret).
* Returns \l{DeviceManager::DeviceError}{DeviceError} to inform about the result.
* \sa DeviceManager::confirmPairing(), */
DeviceManager::DeviceError GuhCore::confirmPairing(const PairingTransactionId &pairingTransactionId, const QString &secret)
{
return m_deviceManager->confirmPairing(pairingTransactionId, secret);
}
/*! Calls the metheod DeviceManager::executeAction(\a action).
* \sa DeviceManager::executeAction(), */
DeviceManager::DeviceError GuhCore::executeAction(const Action &action)
@ -382,104 +330,6 @@ void GuhCore::executeRuleActions(const QList<RuleAction> ruleActions)
}
}
/*! Calls the metheod DeviceManager::findDeviceClass(\a deviceClassId).
* \sa DeviceManager::findDeviceClass(), */
DeviceClass GuhCore::findDeviceClass(const DeviceClassId &deviceClassId) const
{
return m_deviceManager->findDeviceClass(deviceClassId);
}
/*! Calls the metheod DeviceManager::discoverDevices(\a deviceClassId, \a params).
* \sa DeviceManager::discoverDevices(), */
DeviceManager::DeviceError GuhCore::discoverDevices(const DeviceClassId &deviceClassId, const ParamList &params)
{
return m_deviceManager->discoverDevices(deviceClassId, params);
}
/*! Calls the metheod DeviceManager::addConfiguredDevice(\a deviceClassId, \a params, \a newId).
* \sa DeviceManager::addConfiguredDevice(), */
DeviceManager::DeviceError GuhCore::addConfiguredDevice(const DeviceClassId &deviceClassId, const ParamList &params, const DeviceId &newId)
{
return m_deviceManager->addConfiguredDevice(deviceClassId, params, newId);
}
/*! Calls the metheod DeviceManager::addConfiguredDevice(\a deviceClassId, \a deviceDescriptorId, \a newId).
* \sa DeviceManager::addConfiguredDevice(), */
DeviceManager::DeviceError GuhCore::addConfiguredDevice(const DeviceClassId &deviceClassId, const DeviceDescriptorId &deviceDescriptorId, const DeviceId &newId)
{
return m_deviceManager->addConfiguredDevice(deviceClassId, deviceDescriptorId, newId);
}
/*! Calls the metheod DeviceManager::configuredDevices().
* \sa DeviceManager::configuredDevices(), */
QList<Device *> GuhCore::configuredDevices() const
{
return m_deviceManager->configuredDevices();
}
/*! Calls the metheod DeviceManager::findConfiguredDevice(\a deviceId).
* \sa DeviceManager::findConfiguredDevice(), */
Device *GuhCore::findConfiguredDevice(const DeviceId &deviceId) const
{
return m_deviceManager->findConfiguredDevice(deviceId);
}
/*! Calls the metheod DeviceManager::findConfiguredDevice(\a deviceClassId).
* \sa DeviceManager::findConfiguredDevice(), */
QList<Device *> GuhCore::findConfiguredDevices(const DeviceClassId &deviceClassId) const
{
return m_deviceManager->findConfiguredDevices(deviceClassId);
}
/*! Calls the metheod DeviceManager::editDevice(\a deviceId, \a params).
* \sa DeviceManager::editDevice(), */
DeviceManager::DeviceError GuhCore::editDevice(const DeviceId &deviceId, const ParamList &params)
{
return m_deviceManager->editDevice(deviceId, params);
}
/*! Calls the metheod DeviceManager::editDevice(\a deviceId, \a deviceDescriptorId).
* \sa DeviceManager::editDevice(), */
DeviceManager::DeviceError GuhCore::editDevice(const DeviceId &deviceId, const DeviceDescriptorId &deviceDescriptorId)
{
return m_deviceManager->editDevice(deviceId, deviceDescriptorId);
}
/*! Calls the metheod RuleEngine::rules().
* \sa RuleEngine::rules(), */
QList<Rule> GuhCore::rules() const
{
return m_ruleEngine->rules();
}
/*! Calls the metheod RuleEngine::ruleIds().
* \sa RuleEngine::ruleIds(), */
QList<RuleId> GuhCore::ruleIds() const
{
return m_ruleEngine->ruleIds();
}
/*! Calls the metheod RuleEngine::findRule(\a ruleId).
* \sa RuleEngine::findRule(), */
Rule GuhCore::findRule(const RuleId &ruleId)
{
return m_ruleEngine->findRule(ruleId);
}
/*! Calls the metheod RuleEngine::addRule(\a id, \a name, \a eventDescriptorList, \a stateEvaluator \a actionList, \a exitActionList, \a enabled).
* \sa RuleEngine::addRule(), */
RuleEngine::RuleError GuhCore::addRule(const RuleId &id, const QString &name, const QList<EventDescriptor> &eventDescriptorList, const StateEvaluator &stateEvaluator, const QList<RuleAction> &actionList, const QList<RuleAction> &exitActionList, bool enabled, bool executable)
{
return m_ruleEngine->addRule(id, name, eventDescriptorList, stateEvaluator, actionList, exitActionList, enabled, executable);
}
/*! Calls the metheod RuleEngine::editRule(\a id, \a name, \a eventDescriptorList, \a stateEvaluator \a actionList, \a exitActionList, \a enabled).
* \sa RuleEngine::editRule(), */
RuleEngine::RuleError GuhCore::editRule(const RuleId &id, const QString &name, const QList<EventDescriptor> &eventDescriptorList, const StateEvaluator &stateEvaluator, const QList<RuleAction> &actionList, const QList<RuleAction> &exitActionList, bool enabled, bool executable)
{
return m_ruleEngine->editRule(id, name, eventDescriptorList, stateEvaluator, actionList, exitActionList, enabled, executable);
}
/*! Calls the metheod RuleEngine::removeRule(\a id).
* \sa RuleEngine, */
RuleEngine::RuleError GuhCore::removeRule(const RuleId &id)
@ -491,37 +341,6 @@ RuleEngine::RuleError GuhCore::removeRule(const RuleId &id)
return removeError;
}
/*! Calls the metheod RuleEngine::findRules(\a deviceId).
* \sa RuleEngine, */
QList<RuleId> GuhCore::findRules(const DeviceId &deviceId)
{
return m_ruleEngine->findRules(deviceId);
}
/*! Calls the metheod RuleEngine::enableRule(\a ruleId).
* \sa RuleEngine::enableRule(), */
RuleEngine::RuleError GuhCore::enableRule(const RuleId &ruleId)
{
return m_ruleEngine->enableRule(ruleId);
}
/*! Calls the metheod RuleEngine::disableRule(\a ruleId).
* \sa RuleEngine::disableRule(), */
RuleEngine::RuleError GuhCore::disableRule(const RuleId &ruleId)
{
return m_ruleEngine->disableRule(ruleId);
}
RuleEngine::RuleError GuhCore::executeRuleActions(const RuleId &ruleId)
{
return m_ruleEngine->executeActions(ruleId);
}
RuleEngine::RuleError GuhCore::executeRuleExitActions(const RuleId &ruleId)
{
return m_ruleEngine->executeExitActions(ruleId);
}
/*! Returns a pointer to the \l{DeviceManager} instance owned by GuhCore.*/
DeviceManager *GuhCore::deviceManager() const
{

34
server/guhcore.h
View File

@ -45,54 +45,29 @@ class LogEngine;
class GuhCore : public QObject
{
Q_OBJECT
friend class GuhTestBase;
public:
static GuhCore* instance();
~GuhCore();
void destroy();
QList<DevicePlugin *> plugins() const;
DeviceManager::DeviceError setPluginConfig(const PluginId &pluginId, const ParamList &params);
// Device handling
QList<Vendor> supportedVendors() const;
QList<DeviceClass> supportedDevices(const VendorId &vendorId = VendorId()) const;
DeviceClass findDeviceClass(const DeviceClassId &deviceClassId) const;
DeviceManager::DeviceError discoverDevices(const DeviceClassId &deviceClassId, const ParamList &params);
DeviceManager::DeviceError addConfiguredDevice(const DeviceClassId &deviceClassId, const ParamList &params, const DeviceId &newId);
DeviceManager::DeviceError addConfiguredDevice(const DeviceClassId &deviceClassId, const DeviceDescriptorId &deviceDescriptorId, const DeviceId &newId);
QList<Device *> configuredDevices() const;
Device *findConfiguredDevice(const DeviceId &deviceId) const;
QList<Device *> findConfiguredDevices(const DeviceClassId &deviceClassId) const;
DeviceManager::DeviceError editDevice(const DeviceId &deviceId, const ParamList &params);
DeviceManager::DeviceError editDevice(const DeviceId &deviceId, const DeviceDescriptorId &deviceDescriptorId);
QPair<DeviceManager::DeviceError, QList<RuleId> >removeConfiguredDevice(const DeviceId &deviceId, const QHash<RuleId, RuleEngine::RemovePolicy> &removePolicyList);
DeviceManager::DeviceError removeConfiguredDevice(const DeviceId &deviceId, const RuleEngine::RemovePolicy &removePolicy);
DeviceManager::DeviceError pairDevice(const PairingTransactionId &pairingTransactionId, const DeviceClassId &deviceClassId, const DeviceDescriptorId &deviceDescriptorId);
DeviceManager::DeviceError pairDevice(const PairingTransactionId &pairingTransactionId, const DeviceClassId &deviceClassId, const ParamList &params);
DeviceManager::DeviceError confirmPairing(const PairingTransactionId &pairingTransactionId, const QString &secret = QString());
DeviceManager::DeviceError executeAction(const Action &action);
void executeRuleActions(const QList<RuleAction> ruleActions);
QList<Rule> rules() const;
QList<RuleId> ruleIds() const;
Rule findRule(const RuleId &ruleId);
RuleEngine::RuleError addRule(const RuleId &id, const QString &name, const QList<EventDescriptor> &eventDescriptorList, const StateEvaluator &stateEvaluator, const QList<RuleAction> &actionList, const QList<RuleAction> &exitActionList, bool enabled = true, bool executable = true);
RuleEngine::RuleError editRule(const RuleId &id, const QString &name, const QList<EventDescriptor> &eventDescriptorList, const StateEvaluator &stateEvaluator, const QList<RuleAction> &actionList, const QList<RuleAction> &exitActionList, bool enabled = true, bool executable = true);
RuleEngine::RuleError removeRule(const RuleId &id);
QList<RuleId> findRules(const DeviceId &deviceId);
RuleEngine::RuleError enableRule(const RuleId &ruleId);
RuleEngine::RuleError disableRule(const RuleId &ruleId);
RuleEngine::RuleError executeRuleActions(const RuleId &ruleId);
RuleEngine::RuleError executeRuleExitActions(const RuleId &ruleId);
LogEngine* logEngine() const;
JsonRPCServer *jsonRPCServer() const;
RestServer *restServer() const;
DeviceManager *deviceManager() const;
RuleEngine *ruleEngine() const;
signals:
void eventTriggered(const Event &event);
@ -113,8 +88,6 @@ signals:
void ruleConfigurationChanged(const Rule &rule);
private:
RuleEngine *ruleEngine() const;
explicit GuhCore(QObject *parent = 0);
static GuhCore *s_instance;
@ -130,7 +103,6 @@ private slots:
void gotEvent(const Event &event);
void actionExecutionFinished(const ActionId &id, DeviceManager::DeviceError status);
friend class GuhTestBase;
};
}

2
server/jsonrpc/actionhandler.cpp
View File

@ -95,7 +95,7 @@ JsonReply *ActionHandler::GetActionType(const QVariantMap &params) const
{
qCDebug(dcJsonRpc) << "asked for action type" << params;
ActionTypeId actionTypeId(params.value("actionTypeId").toString());
foreach (const DeviceClass &deviceClass, GuhCore::instance()->supportedDevices()) {
foreach (const DeviceClass &deviceClass, GuhCore::instance()->deviceManager()->supportedDevices()) {
foreach (const ActionType &actionType, deviceClass.actionTypes()) {
if (actionType.id() == actionTypeId) {
QVariantMap data = statusToReply(DeviceManager::DeviceErrorNoError);

36
server/jsonrpc/devicehandler.cpp
View File

@ -102,6 +102,7 @@ DeviceHandler::DeviceHandler(QObject *parent) :
"CreateMethodDiscovery requires the use of a deviceDescriptorId."
);
params.insert("deviceClassId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
params.insert("name", JsonTypes::basicTypeToString(JsonTypes::String));
params.insert("o:deviceDescriptorId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
QVariantList deviceParams;
deviceParams.append(JsonTypes::paramRef());
@ -299,7 +300,7 @@ JsonReply *DeviceHandler::GetDiscoveredDevices(const QVariantMap &params) const
ParamList discoveryParams = JsonTypes::unpackParams(params.value("discoveryParams").toList());
DeviceManager::DeviceError status = GuhCore::instance()->discoverDevices(deviceClassId, discoveryParams);
DeviceManager::DeviceError status = GuhCore::instance()->deviceManager()->discoverDevices(deviceClassId, discoveryParams);
if (status == DeviceManager::DeviceErrorAsync ) {
JsonReply *reply = createAsyncReply("GetDiscoveredDevices");
m_discoverRequests.insert(deviceClassId, reply);
@ -321,7 +322,7 @@ JsonReply* DeviceHandler::GetPlugins(const QVariantMap &params) const
JsonReply *DeviceHandler::GetPluginConfiguration(const QVariantMap &params) const
{
DevicePlugin *plugin = 0;
foreach (DevicePlugin *p, GuhCore::instance()->plugins()) {
foreach (DevicePlugin *p, GuhCore::instance()->deviceManager()->plugins()) {
if (p->pluginId() == PluginId(params.value("pluginId").toString())) {
plugin = p;
}
@ -347,7 +348,7 @@ JsonReply* DeviceHandler::SetPluginConfiguration(const QVariantMap &params)
QVariantMap returns;
PluginId pluginId = PluginId(params.value("pluginId").toString());
ParamList pluginParams = JsonTypes::unpackParams(params.value("configuration").toList());
DeviceManager::DeviceError result = GuhCore::instance()->setPluginConfig(pluginId, pluginParams);
DeviceManager::DeviceError result = GuhCore::instance()->deviceManager()->setPluginConfig(pluginId, pluginParams);
returns.insert("deviceError", JsonTypes::deviceErrorToString(result));
return createReply(returns);
}
@ -355,14 +356,15 @@ JsonReply* DeviceHandler::SetPluginConfiguration(const QVariantMap &params)
JsonReply* DeviceHandler::AddConfiguredDevice(const QVariantMap &params)
{
DeviceClassId deviceClass(params.value("deviceClassId").toString());
QString deviceName = params.value("name").toString();
ParamList deviceParams = JsonTypes::unpackParams(params.value("deviceParams").toList());
DeviceDescriptorId deviceDescriptorId(params.value("deviceDescriptorId").toString());
DeviceId newDeviceId = DeviceId::createDeviceId();
DeviceManager::DeviceError status;
if (deviceDescriptorId.isNull()) {
status = GuhCore::instance()->addConfiguredDevice(deviceClass, deviceParams, newDeviceId);
status = GuhCore::instance()->deviceManager()->addConfiguredDevice(deviceClass, deviceName, deviceParams, newDeviceId);
} else {
status = GuhCore::instance()->addConfiguredDevice(deviceClass, deviceDescriptorId, newDeviceId);
status = GuhCore::instance()->deviceManager()->addConfiguredDevice(deviceClass, deviceName, deviceDescriptorId, newDeviceId);
}
QVariantMap returns;
switch (status) {
@ -382,16 +384,16 @@ JsonReply* DeviceHandler::AddConfiguredDevice(const QVariantMap &params)
JsonReply *DeviceHandler::PairDevice(const QVariantMap &params)
{
DeviceClassId deviceClassId(params.value("deviceClassId").toString());
DeviceClass deviceClass = GuhCore::instance()->findDeviceClass(deviceClassId);
DeviceClass deviceClass = GuhCore::instance()->deviceManager()->findDeviceClass(deviceClassId);
DeviceManager::DeviceError status;
PairingTransactionId pairingTransactionId = PairingTransactionId::createPairingTransactionId();
if (params.contains("deviceDescriptorId")) {
DeviceDescriptorId deviceDescriptorId(params.value("deviceDescriptorId").toString());
status = GuhCore::instance()->pairDevice(pairingTransactionId, deviceClassId, deviceDescriptorId);
status = GuhCore::instance()->deviceManager()->pairDevice(pairingTransactionId, deviceClassId, deviceDescriptorId);
} else {
ParamList deviceParams = JsonTypes::unpackParams(params.value("deviceParams").toList());
status = GuhCore::instance()->pairDevice(pairingTransactionId, deviceClassId, deviceParams);
status = GuhCore::instance()->deviceManager()->pairDevice(pairingTransactionId, deviceClassId, deviceParams);
}
QVariantMap returns;
@ -408,7 +410,7 @@ JsonReply *DeviceHandler::ConfirmPairing(const QVariantMap &params)
{
PairingTransactionId pairingTransactionId = PairingTransactionId(params.value("pairingTransactionId").toString());
QString secret = params.value("secret").toString();
DeviceManager::DeviceError status = GuhCore::instance()->confirmPairing(pairingTransactionId, secret);
DeviceManager::DeviceError status = GuhCore::instance()->deviceManager()->confirmPairing(pairingTransactionId, secret);
JsonReply *reply = 0;
if (status == DeviceManager::DeviceErrorAsync) {
@ -427,7 +429,7 @@ JsonReply* DeviceHandler::GetConfiguredDevices(const QVariantMap &params) const
Q_UNUSED(params)
QVariantMap returns;
QVariantList configuredDeviceList;
foreach (Device *device, GuhCore::instance()->configuredDevices()) {
foreach (Device *device, GuhCore::instance()->deviceManager()->configuredDevices()) {
configuredDeviceList.append(JsonTypes::packDevice(device));
}
returns.insert("devices", configuredDeviceList);
@ -443,9 +445,9 @@ JsonReply *DeviceHandler::EditDevice(const QVariantMap &params)
DeviceManager::DeviceError status;
DeviceDescriptorId deviceDescriptorId(params.value("deviceDescriptorId").toString());
if (deviceDescriptorId.isNull()) {
status = GuhCore::instance()->editDevice(deviceId, deviceParams);
status = GuhCore::instance()->deviceManager()->editDevice(deviceId, deviceParams);
} else {
status = GuhCore::instance()->editDevice(deviceId, deviceDescriptorId);
status = GuhCore::instance()->deviceManager()->editDevice(deviceId, deviceDescriptorId);
}
if (status == DeviceManager::DeviceErrorAsync) {
@ -498,7 +500,7 @@ JsonReply* DeviceHandler::GetEventTypes(const QVariantMap &params) const
QVariantMap returns;
QVariantList eventList;
DeviceClass deviceClass = GuhCore::instance()->findDeviceClass(DeviceClassId(params.value("deviceClassId").toString()));
DeviceClass deviceClass = GuhCore::instance()->deviceManager()->findDeviceClass(DeviceClassId(params.value("deviceClassId").toString()));
foreach (const EventType &eventType, deviceClass.eventTypes()) {
eventList.append(JsonTypes::packEventType(eventType));
}
@ -511,7 +513,7 @@ JsonReply* DeviceHandler::GetActionTypes(const QVariantMap &params) const
QVariantMap returns;
QVariantList actionList;
DeviceClass deviceClass = GuhCore::instance()->findDeviceClass(DeviceClassId(params.value("deviceClassId").toString()));
DeviceClass deviceClass = GuhCore::instance()->deviceManager()->findDeviceClass(DeviceClassId(params.value("deviceClassId").toString()));
foreach (const ActionType &actionType, deviceClass.actionTypes()) {
actionList.append(JsonTypes::packActionType(actionType));
}
@ -524,7 +526,7 @@ JsonReply* DeviceHandler::GetStateTypes(const QVariantMap &params) const
QVariantMap returns;
QVariantList stateList;
DeviceClass deviceClass = GuhCore::instance()->findDeviceClass(DeviceClassId(params.value("deviceClassId").toString()));
DeviceClass deviceClass = GuhCore::instance()->deviceManager()->findDeviceClass(DeviceClassId(params.value("deviceClassId").toString()));
foreach (const StateType &stateType, deviceClass.stateTypes()) {
stateList.append(JsonTypes::packStateType(stateType));
}
@ -536,7 +538,7 @@ JsonReply* DeviceHandler::GetStateValue(const QVariantMap &params) const
{
QVariantMap returns;
Device *device = GuhCore::instance()->findConfiguredDevice(DeviceId(params.value("deviceId").toString()));
Device *device = GuhCore::instance()->deviceManager()->findConfiguredDevice(DeviceId(params.value("deviceId").toString()));
if (!device) {
returns.insert("deviceError", JsonTypes::deviceErrorToString(DeviceManager::DeviceErrorDeviceNotFound));
return createReply(returns);
@ -556,7 +558,7 @@ JsonReply *DeviceHandler::GetStateValues(const QVariantMap &params) const
{
QVariantMap returns;
Device *device = GuhCore::instance()->findConfiguredDevice(DeviceId(params.value("deviceId").toString()));
Device *device = GuhCore::instance()->deviceManager()->findConfiguredDevice(DeviceId(params.value("deviceId").toString()));
if (!device) {
returns.insert("deviceError", JsonTypes::deviceErrorToString(DeviceManager::DeviceErrorDeviceNotFound));
return createReply(returns);

2
server/jsonrpc/eventhandler.cpp
View File

@ -77,7 +77,7 @@ JsonReply* EventHandler::GetEventType(const QVariantMap &params) const
{
qCDebug(dcJsonRpc) << "asked for event type" << params;
EventTypeId eventTypeId(params.value("eventTypeId").toString());
foreach (const DeviceClass &deviceClass, GuhCore::instance()->supportedDevices()) {
foreach (const DeviceClass &deviceClass, GuhCore::instance()->deviceManager()->supportedDevices()) {
foreach (const EventType &eventType, deviceClass.eventTypes()) {
if (eventType.id() == eventTypeId) {
QVariantMap data = statusToReply(DeviceManager::DeviceErrorNoError);

16
server/jsonrpc/jsontypes.cpp
View File

@ -728,7 +728,7 @@ QVariantList JsonTypes::packCreateMethods(DeviceClass::CreateMethods createMetho
QVariantList JsonTypes::packSupportedVendors()
{
QVariantList supportedVendors;
foreach (const Vendor &vendor, GuhCore::instance()->supportedVendors()) {
foreach (const Vendor &vendor, GuhCore::instance()->deviceManager()->supportedVendors()) {
supportedVendors.append(packVendor(vendor));
}
return supportedVendors;
@ -737,7 +737,7 @@ QVariantList JsonTypes::packSupportedVendors()
QVariantList JsonTypes::packSupportedDevices(const VendorId &vendorId)
{
QVariantList supportedDeviceList;
foreach (const DeviceClass &deviceClass, GuhCore::instance()->supportedDevices(vendorId)) {
foreach (const DeviceClass &deviceClass, GuhCore::instance()->deviceManager()->supportedDevices(vendorId)) {
supportedDeviceList.append(packDeviceClass(deviceClass));
}
return supportedDeviceList;
@ -746,7 +746,7 @@ QVariantList JsonTypes::packSupportedDevices(const VendorId &vendorId)
QVariantList JsonTypes::packConfiguredDevices()
{
QVariantList configuredDeviceList;
foreach (Device *device, GuhCore::instance()->configuredDevices()) {
foreach (Device *device, GuhCore::instance()->deviceManager()->configuredDevices()) {
configuredDeviceList.append(packDevice(device));
}
return configuredDeviceList;
@ -754,7 +754,7 @@ QVariantList JsonTypes::packConfiguredDevices()
QVariantList JsonTypes::packDeviceStates(Device *device)
{
DeviceClass deviceClass = GuhCore::instance()->findDeviceClass(device->deviceClassId());
DeviceClass deviceClass = GuhCore::instance()->deviceManager()->findDeviceClass(device->deviceClassId());
QVariantList stateValues;
foreach (const StateType &stateType, deviceClass.stateTypes()) {
QVariantMap stateValue;
@ -777,7 +777,7 @@ QVariantList JsonTypes::packDeviceDescriptors(const QList<DeviceDescriptor> devi
QVariantList JsonTypes::packRuleDescriptions()
{
QVariantList rulesList;
foreach (const Rule &rule, GuhCore::instance()->rules()) {
foreach (const Rule &rule, GuhCore::instance()->ruleEngine()->rules()) {
rulesList.append(JsonTypes::packRuleDescription(rule));
}
return rulesList;
@ -822,7 +822,7 @@ QVariantList JsonTypes::packEventTypes(const DeviceClass &deviceClass)
QVariantList JsonTypes::packPlugins()
{
QVariantList pluginsList;
foreach (DevicePlugin *plugin, GuhCore::instance()->plugins()) {
foreach (DevicePlugin *plugin, GuhCore::instance()->deviceManager()->plugins()) {
QVariantMap pluginMap = packPlugin(plugin);
pluginsList.append(pluginMap);
}
@ -1380,7 +1380,7 @@ QPair<bool, QString> JsonTypes::validateBasicType(const QVariant &variant)
QVariant::Type JsonTypes::getActionParamType(const ActionTypeId &actionTypeId, const QString &paramName)
{
foreach (const DeviceClass &deviceClass, GuhCore::instance()->supportedDevices()) {
foreach (const DeviceClass &deviceClass, GuhCore::instance()->deviceManager()->supportedDevices()) {
foreach (const ActionType &actionType, deviceClass.actionTypes()) {
if (actionType.id() == actionTypeId) {
foreach (const ParamType &paramType, actionType.paramTypes()) {
@ -1396,7 +1396,7 @@ QVariant::Type JsonTypes::getActionParamType(const ActionTypeId &actionTypeId, c
QVariant::Type JsonTypes::getEventParamType(const EventTypeId &eventTypeId, const QString &paramName)
{
foreach (const DeviceClass &deviceClass, GuhCore::instance()->supportedDevices()) {
foreach (const DeviceClass &deviceClass, GuhCore::instance()->deviceManager()->supportedDevices()) {
foreach (const EventType &eventType, deviceClass.eventTypes()) {
if (eventType.id() == eventTypeId) {
foreach (const ParamType &paramType, eventType.paramTypes()) {

18
server/jsonrpc/ruleshandler.cpp
View File

@ -191,7 +191,7 @@ JsonReply* RulesHandler::GetRules(const QVariantMap &params)
JsonReply *RulesHandler::GetRuleDetails(const QVariantMap &params)
{
RuleId ruleId = RuleId(params.value("ruleId").toString());
Rule rule = GuhCore::instance()->findRule(ruleId);
Rule rule = GuhCore::instance()->ruleEngine()->findRule(ruleId);
if (rule.id().isNull()) {
return createReply(statusToReply(RuleEngine::RuleErrorRuleNotFound));
}
@ -251,7 +251,7 @@ JsonReply* RulesHandler::AddRule(const QVariantMap &params)
bool executable = params.value("executable", true).toBool();
RuleId newRuleId = RuleId::createRuleId();
RuleEngine::RuleError status = GuhCore::instance()->addRule(newRuleId, name, eventDescriptorList, stateEvaluator, actions, exitActions, enabled, executable);
RuleEngine::RuleError status = GuhCore::instance()->ruleEngine()->addRule(newRuleId, name, eventDescriptorList, stateEvaluator, actions, exitActions, enabled, executable);
QVariantMap returns;
if (status == RuleEngine::RuleErrorNoError) {
returns.insert("ruleId", newRuleId.toString());
@ -311,10 +311,10 @@ JsonReply *RulesHandler::EditRule(const QVariantMap &params)
bool executable = params.value("executable", true).toBool();
RuleId ruleId = RuleId(params.value("ruleId").toString());
RuleEngine::RuleError status = GuhCore::instance()->editRule(ruleId, name, eventDescriptorList, stateEvaluator, actions, exitActions, enabled, executable);
RuleEngine::RuleError status = GuhCore::instance()->ruleEngine()->editRule(ruleId, name, eventDescriptorList, stateEvaluator, actions, exitActions, enabled, executable);
QVariantMap returns;
if (status == RuleEngine::RuleErrorNoError) {
returns.insert("rule", JsonTypes::packRule(GuhCore::instance()->findRule(ruleId)));
returns.insert("rule", JsonTypes::packRule(GuhCore::instance()->ruleEngine()->findRule(ruleId)));
}
returns.insert("ruleError", JsonTypes::ruleErrorToString(status));
return createReply(returns);
@ -332,7 +332,7 @@ JsonReply* RulesHandler::RemoveRule(const QVariantMap &params)
JsonReply *RulesHandler::FindRules(const QVariantMap &params)
{
DeviceId deviceId = DeviceId(params.value("deviceId").toString());
QList<RuleId> rules = GuhCore::instance()->findRules(deviceId);
QList<RuleId> rules = GuhCore::instance()->ruleEngine()->findRules(deviceId);
QVariantList rulesList;
foreach (const RuleId &ruleId, rules) {
@ -346,19 +346,19 @@ JsonReply *RulesHandler::FindRules(const QVariantMap &params)
JsonReply *RulesHandler::EnableRule(const QVariantMap &params)
{
return createReply(statusToReply(GuhCore::instance()->enableRule(RuleId(params.value("ruleId").toString()))));
return createReply(statusToReply(GuhCore::instance()->ruleEngine()->enableRule(RuleId(params.value("ruleId").toString()))));
}
JsonReply *RulesHandler::DisableRule(const QVariantMap &params)
{
return createReply(statusToReply(GuhCore::instance()->disableRule(RuleId(params.value("ruleId").toString()))));
return createReply(statusToReply(GuhCore::instance()->ruleEngine()->disableRule(RuleId(params.value("ruleId").toString()))));
}
JsonReply *RulesHandler::ExecuteActions(const QVariantMap &params)
{
QVariantMap returns;
RuleId ruleId(params.value("ruleId").toString());
RuleEngine::RuleError status = GuhCore::instance()->executeRuleActions(ruleId);
RuleEngine::RuleError status = GuhCore::instance()->ruleEngine()->executeActions(ruleId);
returns.insert("ruleError", JsonTypes::ruleErrorToString(status));
return createReply(returns);
}
@ -367,7 +367,7 @@ JsonReply *RulesHandler::ExecuteExitActions(const QVariantMap &params)
{
QVariantMap returns;
RuleId ruleId(params.value("ruleId").toString());
RuleEngine::RuleError status = GuhCore::instance()->executeRuleExitActions(ruleId);
RuleEngine::RuleError status = GuhCore::instance()->ruleEngine()->executeExitActions(ruleId);
returns.insert("ruleError", JsonTypes::ruleErrorToString(status));
return createReply(returns);
}

2
server/jsonrpc/statehandler.cpp
View File

@ -62,7 +62,7 @@ JsonReply* StateHandler::GetStateType(const QVariantMap &params) const
{
qCDebug(dcJsonRpc) << "asked for state type" << params;
StateTypeId stateTypeId(params.value("stateTypeId").toString());
foreach (const DeviceClass &deviceClass, GuhCore::instance()->supportedDevices()) {
foreach (const DeviceClass &deviceClass, GuhCore::instance()->deviceManager()->supportedDevices()) {
foreach (const StateType &stateType, deviceClass.stateTypes()) {
if (stateType.id() == stateTypeId) {
QVariantMap data = statusToReply(DeviceManager::DeviceErrorNoError);

4
server/rest/deviceclassesresource.cpp
View File

@ -76,7 +76,7 @@ HttpReply *DeviceClassesResource::proccessRequest(const HttpRequest &request, co
qCWarning(dcRest) << "Could not parse DeviceClassId:" << urlTokens.at(3);
return createDeviceErrorReply(HttpReply::BadRequest, DeviceManager::DeviceErrorDeviceClassNotFound);
}
m_deviceClass = GuhCore::instance()->findDeviceClass(deviceClassId);
m_deviceClass = GuhCore::instance()->deviceManager()->findDeviceClass(deviceClassId);
if (!m_deviceClass.isValid()) {
qCWarning(dcRest) << "DeviceClassId" << deviceClassId.toString() << "not found";
return createDeviceErrorReply(HttpReply::NotFound, DeviceManager::DeviceErrorDeviceClassNotFound);
@ -265,7 +265,7 @@ HttpReply *DeviceClassesResource::getDiscoverdDevices(const ParamList &discovery
qCDebug(dcRest) << "Discover devices for DeviceClass" << m_deviceClass.id();
qCDebug(dcRest) << discoveryParams;
DeviceManager::DeviceError status = GuhCore::instance()->discoverDevices(m_deviceClass.id(), discoveryParams);
DeviceManager::DeviceError status = GuhCore::instance()->deviceManager()->discoverDevices(m_deviceClass.id(), discoveryParams);
if (status == DeviceManager::DeviceErrorAsync) {
HttpReply *reply = createAsyncReply();

23
server/rest/devicesresource.cpp
View File

@ -81,7 +81,7 @@ HttpReply *DevicesResource::proccessRequest(const HttpRequest &request, const QS
qCWarning(dcRest) << "Could not parse DeviceId:" << urlTokens.at(3);
return createDeviceErrorReply(HttpReply::BadRequest, DeviceManager::DeviceErrorDeviceNotFound);
}
m_device = GuhCore::instance()->findConfiguredDevice(deviceId);
m_device = GuhCore::instance()->deviceManager()->findConfiguredDevice(deviceId);
if (!m_device) {
qCWarning(dcRest) << "Could find any device with DeviceId:" << urlTokens.at(3);
return createDeviceErrorReply(HttpReply::NotFound, DeviceManager::DeviceErrorDeviceNotFound);
@ -212,7 +212,7 @@ HttpReply *DevicesResource::proccessPostRequest(const HttpRequest &request, cons
return createDeviceErrorReply(HttpReply::BadRequest, DeviceManager::DeviceErrorActionTypeNotFound);
}
bool found = false;
DeviceClass deviceClass = GuhCore::instance()->findDeviceClass(m_device->deviceClassId());
DeviceClass deviceClass = GuhCore::instance()->deviceManager()->findDeviceClass(m_device->deviceClassId());
foreach (const ActionType actionType, deviceClass.actionTypes()) {
if (actionType.id() == actionTypeId) {
found = true;
@ -363,6 +363,7 @@ HttpReply *DevicesResource::addConfiguredDevice(const QByteArray &payload) const
if (deviceClassId.isNull())
return createDeviceErrorReply(HttpReply::BadRequest, DeviceManager::DeviceErrorDeviceClassNotFound);
QString deviceName = params.value("name").toString();
DeviceId newDeviceId = DeviceId::createDeviceId();
ParamList deviceParams = JsonTypes::unpackParams(params.value("deviceParams").toList());
DeviceDescriptorId deviceDescriptorId(params.value("deviceDescriptorId").toString());
@ -370,10 +371,10 @@ HttpReply *DevicesResource::addConfiguredDevice(const QByteArray &payload) const
DeviceManager::DeviceError status;
if (deviceDescriptorId.isNull()) {
qCDebug(dcRest) << "Adding device with " << deviceParams;
status = GuhCore::instance()->addConfiguredDevice(deviceClassId, deviceParams, newDeviceId);
status = GuhCore::instance()->deviceManager()->addConfiguredDevice(deviceClassId, deviceName, deviceParams, newDeviceId);
} else {
qCDebug(dcRest) << "Adding discovered device with DeviceDescriptorId" << deviceDescriptorId.toString();
status = GuhCore::instance()->addConfiguredDevice(deviceClassId, deviceDescriptorId, newDeviceId);
status = GuhCore::instance()->deviceManager()->addConfiguredDevice(deviceClassId, deviceName, deviceDescriptorId, newDeviceId);
}
if (status == DeviceManager::DeviceErrorAsync) {
HttpReply *reply = createAsyncReply();
@ -385,7 +386,7 @@ HttpReply *DevicesResource::addConfiguredDevice(const QByteArray &payload) const
if (status != DeviceManager::DeviceErrorNoError)
return createDeviceErrorReply(HttpReply::InternalServerError, status);
QVariant result = JsonTypes::packDevice(GuhCore::instance()->findConfiguredDevice(newDeviceId));
QVariant result = JsonTypes::packDevice(GuhCore::instance()->deviceManager()->findConfiguredDevice(newDeviceId));
HttpReply *reply = createSuccessReply();
reply->setHeader(HttpReply::ContentTypeHeader, "application/json; charset=\"utf-8\";");
reply->setPayload(QJsonDocument::fromVariant(result).toJson());
@ -401,7 +402,7 @@ HttpReply *DevicesResource::pairDevice(const QByteArray &payload) const
QVariantMap params = verification.second.toMap();
DeviceClassId deviceClassId(params.value("deviceClassId").toString());
DeviceClass deviceClass = GuhCore::instance()->findDeviceClass(deviceClassId);
DeviceClass deviceClass = GuhCore::instance()->deviceManager()->findDeviceClass(deviceClassId);
if (deviceClassId.isNull()) {
qCWarning(dcRest) << "Could not find deviceClassId" << params.value("deviceClassId").toString();
@ -414,10 +415,10 @@ HttpReply *DevicesResource::pairDevice(const QByteArray &payload) const
PairingTransactionId pairingTransactionId = PairingTransactionId::createPairingTransactionId();
if (params.contains("deviceDescriptorId")) {
DeviceDescriptorId deviceDescriptorId(params.value("deviceDescriptorId").toString());
status = GuhCore::instance()->pairDevice(pairingTransactionId, deviceClassId, deviceDescriptorId);
status = GuhCore::instance()->deviceManager()->pairDevice(pairingTransactionId, deviceClassId, deviceDescriptorId);
} else {
ParamList deviceParams = JsonTypes::unpackParams(params.value("deviceParams").toList());
status = GuhCore::instance()->pairDevice(pairingTransactionId, deviceClassId, deviceParams);
status = GuhCore::instance()->deviceManager()->pairDevice(pairingTransactionId, deviceClassId, deviceParams);
}
if (status != DeviceManager::DeviceErrorNoError)
@ -443,7 +444,7 @@ HttpReply *DevicesResource::confirmPairDevice(const QByteArray &payload) const
PairingTransactionId pairingTransactionId = PairingTransactionId(params.value("pairingTransactionId").toString());
QString secret = params.value("secret").toString();
DeviceManager::DeviceError status = GuhCore::instance()->confirmPairing(pairingTransactionId, secret);
DeviceManager::DeviceError status = GuhCore::instance()->deviceManager()->confirmPairing(pairingTransactionId, secret);
if (status == DeviceManager::DeviceErrorAsync) {
HttpReply *reply = createAsyncReply();
@ -472,10 +473,10 @@ HttpReply *DevicesResource::editDevice(Device *device, const QByteArray &payload
DeviceDescriptorId deviceDescriptorId(params.value("deviceDescriptorId").toString());
if (deviceDescriptorId.isNull()) {
qCDebug(dcRest) << "Edit device with params:" << deviceParams;
status = GuhCore::instance()->editDevice(device->id(), deviceParams);
status = GuhCore::instance()->deviceManager()->editDevice(device->id(), deviceParams);
} else {
qCDebug(dcRest) << "Edit device using the discovered device with descriptorId:" << deviceDescriptorId.toString();
status = GuhCore::instance()->editDevice(device->id(), deviceDescriptorId);
status = GuhCore::instance()->deviceManager()->editDevice(device->id(), deviceDescriptorId);
}
if (status == DeviceManager::DeviceErrorAsync) {

6
server/rest/pluginsresource.cpp
View File

@ -147,7 +147,7 @@ HttpReply *PluginsResource::getPlugin(const PluginId &pluginId) const
{
qCDebug(dcRest) << "Get plugin with id" << pluginId;
HttpReply *reply = createSuccessReply();
foreach (DevicePlugin *plugin, GuhCore::instance()->plugins()) {
foreach (DevicePlugin *plugin, GuhCore::instance()->deviceManager()->plugins()) {
if (plugin->pluginId() == pluginId) {
reply->setHeader(HttpReply::ContentTypeHeader, "application/json; charset=\"utf-8\";");
reply->setPayload(QJsonDocument::fromVariant(JsonTypes::packPlugin(plugin)).toJson());
@ -193,7 +193,7 @@ HttpReply *PluginsResource::setPluginConfiguration(const PluginId &pluginId, con
QVariantList configuration = verification.second.toList();
ParamList pluginParams = JsonTypes::unpackParams(configuration);
qCDebug(dcRest) << pluginParams;
DeviceManager::DeviceError result = GuhCore::instance()->setPluginConfig(pluginId, pluginParams);
DeviceManager::DeviceError result = GuhCore::instance()->deviceManager()->setPluginConfig(pluginId, pluginParams);
if (result != DeviceManager::DeviceErrorNoError)
return createDeviceErrorReply(HttpReply::BadRequest, result);
@ -203,7 +203,7 @@ HttpReply *PluginsResource::setPluginConfiguration(const PluginId &pluginId, con
DevicePlugin *PluginsResource::findPlugin(const PluginId &pluginId) const
{
foreach (DevicePlugin *plugin, GuhCore::instance()->plugins()) {
foreach (DevicePlugin *plugin, GuhCore::instance()->deviceManager()->plugins()) {
if (plugin->pluginId() == pluginId) {
return plugin;
}

22
server/rest/rulesresource.cpp
View File

@ -75,7 +75,7 @@ HttpReply *RulesResource::proccessRequest(const HttpRequest &request, const QStr
return createRuleErrorReply(HttpReply::BadRequest, RuleEngine::RuleErrorRuleNotFound);
}
if (GuhCore::instance()->findRule(m_ruleId).id().isNull())
if (GuhCore::instance()->ruleEngine()->findRule(m_ruleId).id().isNull())
return createRuleErrorReply(HttpReply::NotFound, RuleEngine::RuleErrorRuleNotFound);
}
@ -197,10 +197,10 @@ HttpReply *RulesResource::getRules(const DeviceId &deviceId) const
reply->setPayload(QJsonDocument::fromVariant(JsonTypes::packRuleDescriptions()).toJson());
} else {
qCDebug(dcRest) << "Get rule descriptions which contain the device with id" << deviceId.toString();
QList<RuleId> ruleIdsList = GuhCore::instance()->findRules(deviceId);
QList<RuleId> ruleIdsList = GuhCore::instance()->ruleEngine()->findRules(deviceId);
QList<Rule> ruleList;
foreach (const RuleId &ruleId, ruleIdsList) {
Rule rule = GuhCore::instance()->findRule(ruleId);
Rule rule = GuhCore::instance()->ruleEngine()->findRule(ruleId);
if (!rule.id().isNull())
ruleList.append(rule);
}
@ -212,7 +212,7 @@ HttpReply *RulesResource::getRules(const DeviceId &deviceId) const
HttpReply *RulesResource::getRuleDetails(const RuleId &ruleId) const
{
Rule rule = GuhCore::instance()->findRule(ruleId);
Rule rule = GuhCore::instance()->ruleEngine()->findRule(ruleId);
if (rule.id().isNull())
return createRuleErrorReply(HttpReply::NotFound, RuleEngine::RuleErrorRuleNotFound);
@ -279,10 +279,10 @@ HttpReply *RulesResource::addRule(const QByteArray &payload) const
bool executable = params.value("executable", true).toBool();
RuleId newRuleId = RuleId::createRuleId();
RuleEngine::RuleError status = GuhCore::instance()->addRule(newRuleId, name, eventDescriptorList, stateEvaluator, actions, exitActions, enabled, executable);
RuleEngine::RuleError status = GuhCore::instance()->ruleEngine()->addRule(newRuleId, name, eventDescriptorList, stateEvaluator, actions, exitActions, enabled, executable);
if (status == RuleEngine::RuleErrorNoError) {
QVariant returns = JsonTypes::packRule(GuhCore::instance()->findRule(newRuleId));
QVariant returns = JsonTypes::packRule(GuhCore::instance()->ruleEngine()->findRule(newRuleId));
HttpReply *reply = createSuccessReply();
reply->setHeader(HttpReply::ContentTypeHeader, "application/json; charset=\"utf-8\";");
reply->setPayload(QJsonDocument::fromVariant(returns).toJson());
@ -296,7 +296,7 @@ HttpReply *RulesResource::enableRule(const RuleId &ruleId) const
{
qCDebug(dcRest) << "Enable rule with id" << ruleId.toString();
RuleEngine::RuleError status = GuhCore::instance()->enableRule(ruleId);
RuleEngine::RuleError status = GuhCore::instance()->ruleEngine()->enableRule(ruleId);
if (status != RuleEngine::RuleErrorNoError)
return createRuleErrorReply(HttpReply::InternalServerError, status);
@ -308,7 +308,7 @@ HttpReply *RulesResource::disableRule(const RuleId &ruleId) const
{
qCDebug(dcRest) << "Disable rule with id" << ruleId.toString();
RuleEngine::RuleError status = GuhCore::instance()->disableRule(ruleId);
RuleEngine::RuleError status = GuhCore::instance()->ruleEngine()->disableRule(ruleId);
if (status != RuleEngine::RuleErrorNoError)
return createRuleErrorReply(HttpReply::InternalServerError, status);
@ -320,7 +320,7 @@ HttpReply *RulesResource::executeActions(const RuleId &ruleId) const
{
qCDebug(dcRest) << "Execute actions of rule with id" << ruleId.toString();
RuleEngine::RuleError status = GuhCore::instance()->executeRuleActions(ruleId);
RuleEngine::RuleError status = GuhCore::instance()->ruleEngine()->executeActions(ruleId);
if (status != RuleEngine::RuleErrorNoError)
return createRuleErrorReply(HttpReply::InternalServerError, status);
@ -332,7 +332,7 @@ HttpReply *RulesResource::executeExitActions(const RuleId &ruleId) const
{
qCDebug(dcRest) << "Execute exit actions of rule with id" << ruleId.toString();
RuleEngine::RuleError status = GuhCore::instance()->executeRuleExitActions(ruleId);
RuleEngine::RuleError status = GuhCore::instance()->ruleEngine()->executeExitActions(ruleId);
if (status != RuleEngine::RuleErrorNoError)
return createRuleErrorReply(HttpReply::InternalServerError, status);
@ -382,7 +382,7 @@ HttpReply *RulesResource::editRule(const RuleId &ruleId, const QByteArray &paylo
QString name = params.value("name", QString()).toString();
bool enabled = params.value("enabled", true).toBool();
RuleEngine::RuleError status = GuhCore::instance()->editRule(ruleId, name, eventDescriptorList, stateEvaluator, actions, exitActions, enabled);
RuleEngine::RuleError status = GuhCore::instance()->ruleEngine()->editRule(ruleId, name, eventDescriptorList, stateEvaluator, actions, exitActions, enabled);
if (status == RuleEngine::RuleErrorNoError) {
qCDebug(dcRest) << "Edit rule successfully finished";

4
server/rest/vendorsresource.cpp
View File

@ -110,7 +110,7 @@ HttpReply *VendorsResource::getVendors() const
HttpReply *reply = createSuccessReply();
QVariantList vendorsList;
foreach (const Vendor &vendor, GuhCore::instance()->supportedVendors()) {
foreach (const Vendor &vendor, GuhCore::instance()->deviceManager()->supportedVendors()) {
vendorsList.append(JsonTypes::packVendor(vendor));
}
reply->setHeader(HttpReply::ContentTypeHeader, "application/json; charset=\"utf-8\";");
@ -121,7 +121,7 @@ HttpReply *VendorsResource::getVendors() const
HttpReply *VendorsResource::getVendor(const VendorId &vendorId) const
{
qCDebug(dcRest) << "Get vendor with id" << vendorId;
foreach (const Vendor &vendor, GuhCore::instance()->supportedVendors()) {
foreach (const Vendor &vendor, GuhCore::instance()->deviceManager()->supportedVendors()) {
if (vendor.id() == vendorId) {
HttpReply *reply = createSuccessReply();
reply->setHeader(HttpReply::ContentTypeHeader, "application/json; charset=\"utf-8\";");

14
server/ruleengine.cpp
View File

@ -226,7 +226,7 @@ RuleEngine::~RuleEngine()
*/
QList<Rule> RuleEngine::evaluateEvent(const Event &event)
{
Device *device = GuhCore::instance()->findConfiguredDevice(event.deviceId());
Device *device = GuhCore::instance()->deviceManager()->findConfiguredDevice(event.deviceId());
qCDebug(dcRuleEngine) << "got event:" << event << device->name() << event.eventTypeId();
@ -293,12 +293,12 @@ RuleEngine::RuleError RuleEngine::addRule(const RuleId &ruleId, const QString &n
}
foreach (const EventDescriptor &eventDescriptor, eventDescriptorList) {
Device *device = GuhCore::instance()->findConfiguredDevice(eventDescriptor.deviceId());
Device *device = GuhCore::instance()->deviceManager()->findConfiguredDevice(eventDescriptor.deviceId());
if (!device) {
qCWarning(dcRuleEngine) << "Cannot create rule. No configured device for eventTypeId" << eventDescriptor.eventTypeId();
return RuleErrorDeviceNotFound;
}
DeviceClass deviceClass = GuhCore::instance()->findDeviceClass(device->deviceClassId());
DeviceClass deviceClass = GuhCore::instance()->deviceManager()->findDeviceClass(device->deviceClassId());
bool eventTypeFound = false;
foreach (const EventType &eventType, deviceClass.eventTypes()) {
@ -315,12 +315,12 @@ RuleEngine::RuleError RuleEngine::addRule(const RuleId &ruleId, const QString &n
foreach (const RuleAction &action, actions) {
Device *device = GuhCore::instance()->findConfiguredDevice(action.deviceId());
Device *device = GuhCore::instance()->deviceManager()->findConfiguredDevice(action.deviceId());
if (!device) {
qCWarning(dcRuleEngine) << "Cannot create rule. No configured device for actionTypeId" << action.actionTypeId();
return RuleErrorDeviceNotFound;
}
DeviceClass deviceClass = GuhCore::instance()->findDeviceClass(device->deviceClassId());
DeviceClass deviceClass = GuhCore::instance()->deviceManager()->findDeviceClass(device->deviceClassId());
if (!deviceClass.hasActionType(action.actionTypeId())) {
qCWarning(dcRuleEngine) << "Cannot create rule. Device " + device->name() + " has no action type:" << action.actionTypeId();
return RuleErrorActionTypeNotFound;
@ -344,12 +344,12 @@ RuleEngine::RuleError RuleEngine::addRule(const RuleId &ruleId, const QString &n
qCDebug(dcRuleEngine) << "actions" << actions.last().actionTypeId() << actions.last().ruleActionParams();
foreach (const RuleAction &action, exitActions) {
Device *device = GuhCore::instance()->findConfiguredDevice(action.deviceId());
Device *device = GuhCore::instance()->deviceManager()->findConfiguredDevice(action.deviceId());
if (!device) {
qCWarning(dcRuleEngine) << "Cannot create rule. No configured device for actionTypeId" << action.actionTypeId();
return RuleErrorDeviceNotFound;
}
DeviceClass deviceClass = GuhCore::instance()->findDeviceClass(device->deviceClassId());
DeviceClass deviceClass = GuhCore::instance()->deviceManager()->findDeviceClass(device->deviceClassId());
if (!deviceClass.hasActionType(action.actionTypeId())) {
qCWarning(dcRuleEngine) << "Cannot create rule. Device " + device->name() + " has no action type:" << action.actionTypeId();

6
server/stateevaluator.cpp
View File

@ -100,7 +100,7 @@ void StateEvaluator::setOperatorType(Types::StateOperator operatorType)
bool StateEvaluator::evaluate() const
{
if (m_stateDescriptor.isValid()) {
Device *device = GuhCore::instance()->findConfiguredDevice(m_stateDescriptor.deviceId());
Device *device = GuhCore::instance()->deviceManager()->findConfiguredDevice(m_stateDescriptor.deviceId());
if (!device) {
qCWarning(dcRuleEngine) << "Device not existing!";
return false;
@ -210,7 +210,7 @@ StateEvaluator StateEvaluator::loadFromSettings(GuhSettings &settings, const QSt
bool StateEvaluator::isValid() const
{
if (m_stateDescriptor.isValid()) {
Device *device = GuhCore::instance()->findConfiguredDevice(m_stateDescriptor.deviceId());
Device *device = GuhCore::instance()->deviceManager()->findConfiguredDevice(m_stateDescriptor.deviceId());
if (!device) {
qCWarning(dcRuleEngine) << "State evaluator device does not exist!";
return false;
@ -221,7 +221,7 @@ bool StateEvaluator::isValid() const
return false;
}
DeviceClass deviceClass = GuhCore::instance()->findDeviceClass(device->deviceClassId());
DeviceClass deviceClass = GuhCore::instance()->deviceManager()->findDeviceClass(device->deviceClassId());
foreach (const StateType &stateType, deviceClass.stateTypes()) {
if (stateType.id() == m_stateDescriptor.stateTypeId()) {

4
tests/auto/events/testevents.cpp
View File

@ -50,7 +50,7 @@ private slots:
void TestEvents::triggerEvent()
{
QList<Device*> devices = GuhCore::instance()->findConfiguredDevices(mockDeviceClassId);
QList<Device*> devices = GuhCore::instance()->deviceManager()->findConfiguredDevices(mockDeviceClassId);
QVERIFY2(devices.count() > 0, "There needs to be at least one configured Mock Device for this test");
Device *device = devices.first();
@ -77,7 +77,7 @@ void TestEvents::triggerEvent()
void TestEvents::triggerStateChangeEvent()
{
QList<Device*> devices = GuhCore::instance()->findConfiguredDevices(mockDeviceClassId);
QList<Device*> devices = GuhCore::instance()->deviceManager()->findConfiguredDevices(mockDeviceClassId);
QVERIFY2(devices.count() > 0, "There needs to be at least one configured Mock Device for this test");
Device *device = devices.first();

2
tests/auto/logging/testlogging.cpp
View File

@ -136,7 +136,7 @@ void TestLogging::invalidFilter()
void TestLogging::eventLogs()
{
QList<Device*> devices = GuhCore::instance()->findConfiguredDevices(mockDeviceClassId);
QList<Device*> devices = GuhCore::instance()->deviceManager()->findConfiguredDevices(mockDeviceClassId);
QVERIFY2(devices.count() > 0, "There needs to be at least one configured Mock Device for this test");
Device *device = devices.first();

2
tests/auto/restdevices/testrestdevices.cpp
View File

@ -483,7 +483,7 @@ void TestRestDevices::executeAction()
void TestRestDevices::getStateValue_data()
{
QList<Device*> devices = GuhCore::instance()->findConfiguredDevices(mockDeviceClassId);
QList<Device*> devices = GuhCore::instance()->deviceManager()->findConfiguredDevices(mockDeviceClassId);
QVERIFY2(devices.count() > 0, "There needs to be at least one configured Mock Device for this test");
Device *device = devices.first();

2
tests/auto/restlogging/testrestlogging.cpp
View File

@ -145,7 +145,7 @@ void TestRestLogging::invalidFilter()
void TestRestLogging::eventLogs()
{
QList<Device*> devices = GuhCore::instance()->findConfiguredDevices(mockDeviceClassId);
QList<Device*> devices = GuhCore::instance()->deviceManager()->findConfiguredDevices(mockDeviceClassId);
QVERIFY2(devices.count() > 0, "There needs to be at least one configured Mock Device for this test");
Device *device = devices.first();

2
tests/auto/states/teststates.cpp
View File

@ -56,7 +56,7 @@ void TestStates::getStateTypes()
void TestStates::getStateValue_data()
{
QList<Device*> devices = GuhCore::instance()->findConfiguredDevices(mockDeviceClassId);
QList<Device*> devices = GuhCore::instance()->deviceManager()->findConfiguredDevices(mockDeviceClassId);
QVERIFY2(devices.count() > 0, "There needs to be at least one configured Mock Device for this test");
Device *device = devices.first();