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

complete source code documentation

Browse Source
This commit is contained in:
Simon Stürz 2016-03-09 15:22:07 +01:00 committed by Michael Zanetti
parent c95e6ebeb0
commit 92a5060de6
22 changed files with 364 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
libguh/coap/coapoption.cpp
View File

@ -34,31 +34,20 @@
Represents the known CoAP options according to \l{https://tools.ietf.org/html/rfc7252#section-3.1}{RFC7252}.
\value IfMatch
\value UriHost
\value ETag
\value IfNoneMatch
\value Observe
\l{https://tools.ietf.org/html/rfc7641}
\value UriPort
\value LocationPath
\value UriPath
\value ContentFormat
\value MaxAge
\value UriQuery
\value Accept
\value LocationQuery
\value Block2
\l{https://tools.ietf.org/html/draft-ietf-core-block-18}
@ -66,24 +55,33 @@
\l{https://tools.ietf.org/html/draft-ietf-core-block-18}
\value ProxyUri
\value ProxyScheme
\value Size1
*/
/*! \fn CoapOption::CoapOption();
Constructs a \l{CoapOption}.
*/
/*! \fn CoapOption::CoapOption(const Option &option, const QByteArray &data);
Constructs a \l{CoapOption} with the given \a option and option \a data.
*/
/*! \fn void CoapOption::setOption(const Option &option);
Sets the \l{CoapOption::Option} of this CoapOption to the given \a option.
*/
#include "coapoption.h"
#include <QMetaEnum>
/*! Constructs a CoapOption. */
CoapOption::CoapOption()
{
}
/*! Constructs a CoapOption with the given \a option and option \a data. */
CoapOption::CoapOption(const CoapOption::Option &option, const QByteArray &data) :
m_option(option),
m_data(data)
@ -91,7 +89,6 @@ CoapOption::CoapOption(const CoapOption::Option &option, const QByteArray &data)
}
/*! Sets the \l{CoapOption::Option} of this CoapOption to the given \a option. */
void CoapOption::setOption(const CoapOption::Option &option)
{
m_option = option;

26
libguh/coap/coappdu.cpp
View File

@ -123,9 +123,31 @@
\value InvalidOptionDeltaError
\value InvalidOptionLengthError
\value UnknownOptionError
};
*/
/*! \fn void CoapPdu::getStatusCodeString(const StatusCode &statusCode);
Returns the human readable status code for the given \a statusCode.
*/
/*! \fn void CoapPdu::setContentType(const ContentType &contentType);
Sets the content type of this \l{CoapPdu} to the given \a contentType.
\sa CoapPdu::ContentType
*/
/*! \fn void CoapPdu::setMessageType(const MessageType &messageType);
Sets the message type of this \l{CoapPdu} to the given \a messageType.
\sa CoapPdu::MessageType
*/
/*! \fn void CoapPdu::setStatusCode(const StatusCode &statusCode);
Sets the message type of this \l{CoapPdu} to the given \a statusCode.
\sa CoapPdu::StatusCode
*/
#include "coappdu.h"
#include "coapoption.h"

19
libguh/devicemanager.cpp
View File

@ -99,6 +99,10 @@
Couldn't find the PairingTransactionId for the given id.
\value DeviceErrorAuthentificationFailure
The device could not authentificate with something.
\value DeviceErrorDeviceIsChild
The device is a child device and can not be deleted directly.
\value DeviceErrorDeviceInRule
The device is in a rule and can not be deleted withou \l{guhserver::RuleEngine::RemovePolicy}.
\value DeviceErrorParameterNotWritable
One of the given device params is not writable.
*/
@ -368,7 +372,7 @@ DeviceManager::DeviceError DeviceManager::discoverDevices(const DeviceClassId &d
return ret;
}
/*! Add a new configured device for the given \l{DeviceClass}, the given parameters and \a id.
/*! Add a new configured device for the given \l{DeviceClass}, the given parameters, \a name and \a id.
* \a deviceClassId must refer to an existing \{DeviceClass} and \a params must match the parameter description in the \l{DeviceClass}.
* 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.
@ -387,7 +391,7 @@ DeviceManager::DeviceError DeviceManager::addConfiguredDevice(const DeviceClassI
/*! Add a new configured device for the given \l{DeviceClass} the given DeviceDescriptorId and \a deviceId. Only devices with \l{DeviceClass}{CreateMethodDiscovery}
* 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.
* from the discovery. The \a name parameter should contain the device name.
* Returns \l{DeviceError} to inform about the result. */
DeviceManager::DeviceError DeviceManager::addConfiguredDevice(const DeviceClassId &deviceClassId, const QString &name, const DeviceDescriptorId &deviceDescriptorId, const DeviceId &deviceId)
{
@ -512,6 +516,9 @@ DeviceManager::DeviceError DeviceManager::reconfigureDevice(const DeviceId &devi
return reconfigureDevice(deviceId, descriptor.params(), true);
}
/*! Edit the \a name of the \l{Device} with the given \a deviceId.
Returns \l{DeviceManager::DeviceError}{DeviceError} to inform about the result.
*/
DeviceManager::DeviceError DeviceManager::editDevice(const DeviceId &deviceId, const QString &name)
{
Device *device = findConfiguredDevice(deviceId);
@ -525,7 +532,7 @@ DeviceManager::DeviceError DeviceManager::editDevice(const DeviceId &deviceId, c
return DeviceErrorNoError;
}
/*! Initiates a pairing with a \l{DeviceClass}{Device} with the given \a pairingTransactionId, \a deviceClassId and \a params.
/*! Initiates a pairing with a \l{DeviceClass}{Device} with the given \a pairingTransactionId, \a deviceClassId, \a name and \a params.
* Returns \l{DeviceManager::DeviceError}{DeviceError} to inform about the result. */
DeviceManager::DeviceError DeviceManager::pairDevice(const PairingTransactionId &pairingTransactionId, const DeviceClassId &deviceClassId, const QString &name, const ParamList &params)
{
@ -556,7 +563,7 @@ DeviceManager::DeviceError DeviceManager::pairDevice(const PairingTransactionId
return DeviceErrorNoError;
}
/*! Initiates a pairing with a \l{DeviceClass}{Device} with the given \a pairingTransactionId, \a deviceClassId and \a deviceDescriptorId.
/*! Initiates a pairing with a \l{DeviceClass}{Device} with the given \a pairingTransactionId, \a deviceClassId, \a name and \a deviceDescriptorId.
* Returns \l{DeviceManager::DeviceError}{DeviceError} to inform about the result. */
DeviceManager::DeviceError DeviceManager::pairDevice(const PairingTransactionId &pairingTransactionId, const DeviceClassId &deviceClassId, const QString &name, const DeviceDescriptorId &deviceDescriptorId)
{
@ -787,6 +794,8 @@ DeviceClass DeviceManager::findDeviceClass(const DeviceClassId &deviceClassId) c
return DeviceClass();
}
/*! Verify if the given \a params matche the given \a paramTypes. Ith \a requireAll
* is true, all \l{ParamList}{Params} has to be valid. Returns \l{DeviceError} to inform about the result.*/
DeviceManager::DeviceError DeviceManager::verifyParams(const QList<ParamType> paramTypes, ParamList &params, bool requireAll)
{
foreach (const Param &param, params) {
@ -820,6 +829,7 @@ DeviceManager::DeviceError DeviceManager::verifyParams(const QList<ParamType> pa
return DeviceErrorNoError;
}
/*! Verify if the given \a param matches one of the given \a paramTypes. Returns \l{DeviceError} to inform about the result.*/
DeviceManager::DeviceError DeviceManager::verifyParam(const QList<ParamType> paramTypes, const Param &param)
{
foreach (const ParamType &paramType, paramTypes) {
@ -831,6 +841,7 @@ DeviceManager::DeviceError DeviceManager::verifyParam(const QList<ParamType> par
return DeviceErrorInvalidParameter;
}
/*! Verify if the given \a param matches the given \a paramType. Returns \l{DeviceError} to inform about the result.*/
DeviceManager::DeviceError DeviceManager::verifyParam(const ParamType &paramType, const Param &param)
{
if (paramType.name() == param.name()) {

1
libguh/guhsettings.cpp
View File

@ -169,6 +169,7 @@ QString GuhSettings::logPath()
return logPath;
}
/*! Returns the path to the folder where the GuhSettings will be saved. */
QString GuhSettings::settingsPath()
{
QString path;

1
libguh/network/upnpdiscovery/upnpdiscovery.cpp
View File

@ -95,6 +95,7 @@ UpnpDiscovery::UpnpDiscovery(QObject *parent) :
sendAliveMessage();
}
/*! Destruct this \l{UpnpDiscovery} object. */
UpnpDiscovery::~UpnpDiscovery()
{
qCDebug(dcApplication) << "Shutting down \"UPnP Server\"";

2
libguh/plugin/device.cpp
View File

@ -153,7 +153,7 @@ bool Device::hasParam(const QString &paramName) const
return false;
}
DeviceId m_id;
/*! Set the \l{State}{States} of this \l{Device} to the given \a states.*/
void Device::setStates(const QList<State> &states)
{
m_states = states;

8
libguh/plugin/deviceclass.cpp
View File

@ -112,6 +112,7 @@
he can bring it's own icon for a special DeviceClassId. If there is no special icon
defined, he can fallback to the default icon.
\value DeviceIconNone
\value DeviceIconBed
\value DeviceIconBlinds
\value DeviceIconCeilingLamp
@ -147,6 +148,13 @@
\value DeviceIconCloud
*/
/*! \fn void DeviceClass::setBasicTags(const QList<BasicTag> &basicTags);
Set the list of \a basicTags of this DeviceClass.
*/
/*! \fn void DeviceClass::setDeviceIcon(const DeviceIcon &deviceIcon);
Set the \a deviceIcon of this DeviceClass.
*/
#include "deviceclass.h"

16
server/guhapplication.cpp
View File

@ -18,6 +18,21 @@
* *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*!
\class guhserver::GuhApplication
\brief Application class of the guh server.
\ingroup core
\inmodule server
The \l{GuhApplication} is a subclass of the \{http://doc.qt.io/qt-5/qcoreapplication.html}{QCoreApplication}
and is responsable to catch system signals like SIGQUIT, SIGINT, SIGTERM, SIGHUP, SIGSEGV. This class
will provide a backtrace on a segmentation fault (SIGSEGV).
\sa GuhService
*/
#include "guhapplication.h"
#include "loggingcategories.h"
#include "guhcore.h"
@ -150,6 +165,7 @@ static void catchUnixSignals(const std::vector<int>& quitSignals, const std::vec
/*! Constructs a GuhApplication with the given argument count \a argc and argument vector \a argv. */
GuhApplication::GuhApplication(int &argc, char **argv) :
QCoreApplication(argc, argv)
{

5
server/guhcore.cpp
View File

@ -58,7 +58,7 @@
/*! \fn void guhserver::GuhCore::devicesDiscovered(const DeviceClassId &deviceClassId, const QList<DeviceDescriptor> deviceDescriptors);
This signal is emitted when the discovery of a \a deviceClassId is finished. The \a deviceDescriptors parameter describes the
list of \l{DeviceDescriptor}{DeviceDescriptors} of all discovered \l{Device}{Devices}.
\sa discoverDevices()
\sa DeviceManager::discoverDevices()
*/
/*! \fn void guhserver::GuhCore::deviceSetupFinished(Device *device, DeviceManager::DeviceError status);
@ -222,6 +222,8 @@ QPair<DeviceManager::DeviceError, QList<RuleId> > GuhCore::removeConfiguredDevic
return QPair<DeviceManager::DeviceError, QList<RuleId> > (DeviceManager::DeviceErrorNoError, QList<RuleId>());
}
/*! Removes a configured \l{Device} with the given \a deviceId and \a removePolicy. */
DeviceManager::DeviceError GuhCore::removeConfiguredDevice(const DeviceId &deviceId, const RuleEngine::RemovePolicy &removePolicy)
{
// Check if this is a child device
@ -303,6 +305,7 @@ DeviceManager::DeviceError GuhCore::executeAction(const Action &action)
return ret;
}
/*! Execute the given \a ruleActions. */
void GuhCore::executeRuleActions(const QList<RuleAction> ruleActions)
{
foreach (const RuleAction &ruleAction, ruleActions) {

19
server/httpreply.cpp
View File

@ -111,10 +111,24 @@
This signal is emitted when this async \l{HttpReply} is finished.
*/
/*! \fn guhserver::HttpReply::HttpReply(QObject *parent);
Construct an empty \l{HttpReply} with the given \a parent.
*/
/*! \fn guhserver::HttpReply::HttpReply(const HttpStatusCode &statusCode, const Type &type, QObject *parent);
Construct a \l{HttpReply} with the given \a statusCode, \a type and \a parent.
*/
/*! \fn void guhserver::HttpReply::setHttpStatusCode(const HttpStatusCode &statusCode);
Set the \l{HttpStatusCode} of this \l{HttpReply} to the given \a statusCode.
*/
/*! \fn QDebug guhserver::operator<< (QDebug debug, const HttpReply &httpReply);
Writes the given \l{HttpReply} \a httpReply to the given \a debug. This method gets used just for debugging.
*/
#include "httpreply.h"
#include <QDateTime>
@ -123,7 +137,6 @@
namespace guhserver {
/*! Construct an empty \l{HttpReply} with the given \a parent. */
HttpReply::HttpReply(QObject *parent) :
QObject(parent),
m_statusCode(HttpReply::Ok),
@ -148,7 +161,6 @@ HttpReply::HttpReply(QObject *parent) :
packReply();
}
/*! Construct a \l{HttpReply} with the given \a statusCode, \a type and \a parent. */
HttpReply::HttpReply(const HttpReply::HttpStatusCode &statusCode, const HttpReply::Type &type, QObject *parent):
QObject(parent),
m_statusCode(statusCode),
@ -172,9 +184,6 @@ HttpReply::HttpReply(const HttpReply::HttpStatusCode &statusCode, const HttpRepl
packReply();
}
/*! Set the \l{HttpStatusCode} of this \l{HttpReply} to the given \a statusCode.
\sa httpStatusCode()
*/
void HttpReply::setHttpStatusCode(const HttpReply::HttpStatusCode &statusCode)
{
m_statusCode = statusCode;

2
server/jsonrpc/actionhandler.cpp
View File

@ -43,6 +43,7 @@
namespace guhserver {
/*! Constructs a new \l ActionHandler with the given \a parent. */
ActionHandler::ActionHandler(QObject *parent) :
JsonHandler(parent)
{
@ -66,6 +67,7 @@ ActionHandler::ActionHandler(QObject *parent) :
connect(GuhCore::instance(), &GuhCore::actionExecuted, this, &ActionHandler::actionExecuted);
}
/*! Returns the name of the \l{ActionHandler}. In this case \b Actions.*/
QString ActionHandler::name() const
{
return "Actions";

22
server/jsonrpc/devicehandler.cpp
View File

@ -33,6 +33,26 @@
*/
/*! \fn void guhserver::DeviceHandler::StateChanged(const QVariantMap &params);
This signal is emitted to the API notifications when a \l{State} has changed.
The \a params contain the map for the notification.
*/
/*! \fn void guhserver::DeviceHandler::DeviceRemoved(const QVariantMap &params);
This signal is emitted to the API notifications when a \l{Device} has been removed.
The \a params contain the map for the notification.
*/
/*! \fn void guhserver::DeviceHandler::DeviceAdded(const QVariantMap &params);
This signal is emitted to the API notifications when a \l{Device} has been added.
The \a params contain the map for the notification.
*/
/*! \fn void guhserver::DeviceHandler::DeviceChanged(const QVariantMap &params);
This signal is emitted to the API notifications when a \l{Device} has been changed or reconfigured.
The \a params contain the map for the notification.
*/
#include "devicehandler.h"
#include "guhcore.h"
#include "devicemanager.h"
@ -45,6 +65,7 @@
namespace guhserver {
/*! Constructs a new \l DeviceHandler with the given \a parent. */
DeviceHandler::DeviceHandler(QObject *parent) :
JsonHandler(parent)
{
@ -280,6 +301,7 @@ DeviceHandler::DeviceHandler(QObject *parent) :
connect(GuhCore::instance(), &GuhCore::pairingFinished, this, &DeviceHandler::pairingFinished);
}
/*! Returns the name of the \l{DeviceHandler}. In this case \b Devices.*/
QString DeviceHandler::name() const
{
return "Devices";

7
server/jsonrpc/eventhandler.cpp
View File

@ -32,12 +32,18 @@
\sa Event, JsonHandler, JsonRPCServer
*/
/*! \fn void guhserver::EventHandler::EventTriggered(const QVariantMap &params);
This signal is emitted to the API notifications when an \l{Event} triggered.
The \a params contain the map for the notification.
*/
#include "eventhandler.h"
#include "guhcore.h"
#include "loggingcategories.h"
namespace guhserver {
/*! Constructs a new \l EventHandler with the given \a parent. */
EventHandler::EventHandler(QObject *parent) :
JsonHandler(parent)
{
@ -61,6 +67,7 @@ EventHandler::EventHandler(QObject *parent) :
connect(GuhCore::instance(), &GuhCore::eventTriggered, this, &EventHandler::eventTriggered);
}
/*! Returns the name of the \l{EventHandler}. In this case \b Events.*/
QString EventHandler::name() const
{
return "Events";

60
server/jsonrpc/jsonhandler.cpp
View File

@ -29,6 +29,15 @@
\sa JsonRPCServer, JsonReply
*/
/*! \fn QString guhserver::JsonHandler::name() const;
Pure virtual method for a JSON RPC handler. Returns the namespace of the handler.
*/
/*! \fn void guhserver::JsonHandler::asyncReply(int id, const QVariantMap &params);
This signal will be emitted when a reply with the given \a id and \a params is finished.
*/
#include "jsonhandler.h"
#include "loggingcategories.h"
@ -94,18 +103,24 @@ bool JsonHandler::hasMethod(const QString &methodName)
return m_descriptions.contains(methodName) && m_params.contains(methodName) && m_returns.contains(methodName);
}
/*! Validates the given \a params for the given \a methodName. Returns the error string and false if
the params are not valid. */
QPair<bool, QString> JsonHandler::validateParams(const QString &methodName, const QVariantMap &params)
{
QVariantMap paramTemplate = m_params.value(methodName);
return JsonTypes::validateMap(paramTemplate, params);
}
/*! Validates the given \a returns for the given \a methodName. Returns the error string and false if
the params are not valid. */
QPair<bool, QString> JsonHandler::validateReturns(const QString &methodName, const QVariantMap &returns)
{
QVariantMap returnsTemplate = m_returns.value(methodName);
return JsonTypes::validateMap(returnsTemplate, returns);
}
/*! Sets the \a description of the method with the given \a methodName. */
void JsonHandler::setDescription(const QString &methodName, const QString &description)
{
for(int i = 0; i < metaObject()->methodCount(); ++i) {
@ -118,6 +133,7 @@ void JsonHandler::setDescription(const QString &methodName, const QString &descr
qCWarning(dcJsonRpc) << "Cannot set description. No such method:" << methodName;
}
/*! Sets the \a params of the method with the given \a methodName. */
void JsonHandler::setParams(const QString &methodName, const QVariantMap &params)
{
for(int i = 0; i < metaObject()->methodCount(); ++i) {
@ -130,6 +146,7 @@ void JsonHandler::setParams(const QString &methodName, const QVariantMap &params
qCWarning(dcJsonRpc) << "Cannot set params. No such method:" << methodName;
}
/*! Sets the \a returns of the method with the given \a methodName. */
void JsonHandler::setReturns(const QString &methodName, const QVariantMap &returns)
{
for(int i = 0; i < metaObject()->methodCount(); ++i) {
@ -142,16 +159,22 @@ void JsonHandler::setReturns(const QString &methodName, const QVariantMap &retur
qCWarning(dcJsonRpc) << "Cannot set returns. No such method:" << methodName;
}
/*! Returns the pointer to a new \l{JsonReply} with the given \a data. */
JsonReply *JsonHandler::createReply(const QVariantMap &data) const
{
return JsonReply::createReply(const_cast<JsonHandler*>(this), data);
}
/*! Returns the pointer to an asynchronous new \l{JsonReply} with the given \a method. */
JsonReply* JsonHandler::createAsyncReply(const QString &method) const
{
return JsonReply::createAsyncReply(const_cast<JsonHandler*>(this), method);
}
/*! Returns the formated error map for the given \a status.
*
* \sa DeviceManager::DeviceError
*/
QVariantMap JsonHandler::statusToReply(DeviceManager::DeviceError status) const
{
QVariantMap returns;
@ -159,6 +182,10 @@ QVariantMap JsonHandler::statusToReply(DeviceManager::DeviceError status) const
return returns;
}
/*! Returns the formated error map for the given \a status.
*
* \sa RuleEngine::RuleError
*/
QVariantMap JsonHandler::statusToReply(RuleEngine::RuleError status) const
{
QVariantMap returns;
@ -166,6 +193,10 @@ QVariantMap JsonHandler::statusToReply(RuleEngine::RuleError status) const
return returns;
}
/*! Returns the formated error map for the given \a status.
*
* \sa Logging::LoggingError
*/
QVariantMap JsonHandler::statusToReply(Logging::LoggingError status) const
{
QVariantMap returns;
@ -184,8 +215,24 @@ QVariantMap JsonHandler::statusToReply(Logging::LoggingError status) const
\sa JsonHandler, JsonRPCServer
*/
/*! \enum guhserver::JsonReply::Type
This enum type specifies the type of a JsonReply.
\value TypeSync
The response is synchronous.
\value TypeAsync
The response is asynchronous.
*/
/*! \fn void guhserver::JsonReply::finished();
This signal will be emitted when a JsonReply is finished. A JsonReply is finished when
the response is ready or then the reply timed out.
*/
/*! Constructs a new \l JsonReply with the given \a type, \a handler, \a method and \a data. */
JsonReply::JsonReply(Type type, JsonHandler *handler, const QString &method, const QVariantMap &data):
m_type(type),
m_data(data),
@ -196,61 +243,73 @@ JsonReply::JsonReply(Type type, JsonHandler *handler, const QString &method, con
connect(&m_timeout, &QTimer::timeout, this, &JsonReply::timeout);
}
/*! Returns the pointer to a new \l{JsonReply} for the given \a handler and \a data. */
JsonReply *JsonReply::createReply(JsonHandler *handler, const QVariantMap &data)
{
return new JsonReply(TypeSync, handler, QString(), data);
}
/*! Returns the pointer to a new asynchronous \l{JsonReply} for the given \a handler and \a method. */
JsonReply *JsonReply::createAsyncReply(JsonHandler *handler, const QString &method)
{
return new JsonReply(TypeAsync, handler, method);
}
/*! Returns the type of this \l{JsonReply}.*/
JsonReply::Type JsonReply::type() const
{
return m_type;
}
/*! Returns the data of this \l{JsonReply}.*/
QVariantMap JsonReply::data() const
{
return m_data;
}
/*! Sets the \a data of this \l{JsonReply}.*/
void JsonReply::setData(const QVariantMap &data)
{
m_data = data;
}
/*! Returns the handler of this \l{JsonReply}.*/
JsonHandler *JsonReply::handler() const
{
return m_handler;
}
/*! Returns the method of this \l{JsonReply}.*/
QString JsonReply::method() const
{
return m_method;
}
/*! Returns the client ID of this \l{JsonReply}.*/
QUuid JsonReply::clientId() const
{
return m_clientId;
}
/*! Sets the \a clientId of this \l{JsonReply}.*/
void JsonReply::setClientId(const QUuid &clientId)
{
m_clientId = clientId;
}
/*! Returns the command ID of this \l{JsonReply}.*/
int JsonReply::commandId() const
{
return m_commandId;
}
/*! Returns the \a commandId of this \l{JsonReply}.*/
void JsonReply::setCommandId(int commandId)
{
m_commandId = commandId;
}
/*! Start the timeout timer for this \l{JsonReply}. The default timeout is 10 seconds. */
void JsonReply::startWait()
{
m_timeout.start(10000);
@ -262,6 +321,7 @@ void JsonReply::timeout()
emit finished();
}
/*! Returns true if this \l{JsonReply} timed out.*/
bool JsonReply::timedOut() const
{
return m_timedOut;

93
server/jsonrpc/jsontypes.cpp
View File

@ -19,6 +19,33 @@
* *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*!
\class guhserver::JsonTypes
\brief This class represents the types for the JSON-RPC API.
\ingroup json
\inmodule core
This class represents all JSON-RPC API types and allowes to transform Json
objects into c++ objects and vers visa.
*/
/*! \enum guhserver::JsonTypes::BasicType
This enum type specifies the basic types of a JSON RPC API.
\value Uuid
\value String
\value Int
\value Uint
\value Double
\value Bool
\value Variant
\value Color
\value Object
*/
#include "jsontypes.h"
#include "plugin/device.h"
@ -270,6 +297,7 @@ QVariantList JsonTypes::enumToStrings(const QMetaObject &metaObject, const QStri
return enumStrings;
}
/*! Returns a map containing all API types. */
QVariantMap JsonTypes::allTypes()
{
QVariantMap allTypes;
@ -315,6 +343,7 @@ QVariantMap JsonTypes::allTypes()
return allTypes;
}
/*! Returns a variant map of the given \a eventType. */
QVariantMap JsonTypes::packEventType(const EventType &eventType)
{
QVariantMap variant;
@ -328,6 +357,7 @@ QVariantMap JsonTypes::packEventType(const EventType &eventType)
return variant;
}
/*! Returns a variant map of the given \a event. */
QVariantMap JsonTypes::packEvent(const Event &event)
{
QVariantMap variant;
@ -341,6 +371,7 @@ QVariantMap JsonTypes::packEvent(const Event &event)
return variant;
}
/*! Returns a variant map of the given \a eventDescriptor. */
QVariantMap JsonTypes::packEventDescriptor(const EventDescriptor &eventDescriptor)
{
QVariantMap variant;
@ -354,6 +385,7 @@ QVariantMap JsonTypes::packEventDescriptor(const EventDescriptor &eventDescripto
return variant;
}
/*! Returns a variant map of the given \a actionType. */
QVariantMap JsonTypes::packActionType(const ActionType &actionType)
{
QVariantMap variantMap;
@ -367,6 +399,7 @@ QVariantMap JsonTypes::packActionType(const ActionType &actionType)
return variantMap;
}
/*! Returns a variant map of the given \a action. */
QVariantMap JsonTypes::packAction(const Action &action)
{
QVariantMap variant;
@ -380,6 +413,7 @@ QVariantMap JsonTypes::packAction(const Action &action)
return variant;
}
/*! Returns a variant map of the given \a ruleAction. */
QVariantMap JsonTypes::packRuleAction(const RuleAction &ruleAction)
{
QVariantMap variant;
@ -393,6 +427,7 @@ QVariantMap JsonTypes::packRuleAction(const RuleAction &ruleAction)
return variant;
}
/*! Returns a variant map of the given \a ruleActionParam. */
QVariantMap JsonTypes::packRuleActionParam(const RuleActionParam &ruleActionParam)
{
QVariantMap variantMap;
@ -407,6 +442,7 @@ QVariantMap JsonTypes::packRuleActionParam(const RuleActionParam &ruleActionPara
return variantMap;
}
/*! Returns a variant map of the given \a state. */
QVariantMap JsonTypes::packState(const State &state)
{
QVariantMap stateMap;
@ -415,6 +451,7 @@ QVariantMap JsonTypes::packState(const State &state)
return stateMap;
}
/*! Returns a variant map of the given \a stateType. */
QVariantMap JsonTypes::packStateType(const StateType &stateType)
{
QVariantMap variantMap;
@ -438,6 +475,7 @@ QVariantMap JsonTypes::packStateType(const StateType &stateType)
return variantMap;
}
/*! Returns a variant map of the given \a stateDescriptor. */
QVariantMap JsonTypes::packStateDescriptor(const StateDescriptor &stateDescriptor)
{
QVariantMap variantMap;
@ -448,6 +486,7 @@ QVariantMap JsonTypes::packStateDescriptor(const StateDescriptor &stateDescripto
return variantMap;
}
/*! Returns a variant map of the given \a stateEvaluator. */
QVariantMap JsonTypes::packStateEvaluator(const StateEvaluator &stateEvaluator)
{
QVariantMap variantMap;
@ -467,6 +506,7 @@ QVariantMap JsonTypes::packStateEvaluator(const StateEvaluator &stateEvaluator)
return variantMap;
}
/*! Returns a variant map of the given \a param. */
QVariantMap JsonTypes::packParam(const Param &param)
{
QVariantMap variantMap;
@ -475,6 +515,7 @@ QVariantMap JsonTypes::packParam(const Param &param)
return variantMap;
}
/*! Returns a variant map of the given \a paramDescriptor. */
QVariantMap JsonTypes::packParamDescriptor(const ParamDescriptor &paramDescriptor)
{
QVariantMap variantMap;
@ -484,6 +525,7 @@ QVariantMap JsonTypes::packParamDescriptor(const ParamDescriptor &paramDescripto
return variantMap;
}
/*! Returns a variant map of the given \a paramType. */
QVariantMap JsonTypes::packParamType(const ParamType &paramType)
{
QVariantMap variantMap;
@ -515,6 +557,7 @@ QVariantMap JsonTypes::packParamType(const ParamType &paramType)
return variantMap;
}
/*! Returns a variant map of the given \a vendor. */
QVariantMap JsonTypes::packVendor(const Vendor &vendor)
{
QVariantMap variantMap;
@ -523,6 +566,7 @@ QVariantMap JsonTypes::packVendor(const Vendor &vendor)
return variantMap;
}
/*! Returns a variant map of the given \a deviceClass. */
QVariantMap JsonTypes::packDeviceClass(const DeviceClass &deviceClass)
{
QVariantMap variant;
@ -568,6 +612,7 @@ QVariantMap JsonTypes::packDeviceClass(const DeviceClass &deviceClass)
return variant;
}
/*! Returns a variant map of the given \a plugin. */
QVariantMap JsonTypes::packPlugin(DevicePlugin *plugin)
{
QVariantMap pluginMap;
@ -583,6 +628,7 @@ QVariantMap JsonTypes::packPlugin(DevicePlugin *plugin)
return pluginMap;
}
/*! Returns a variant map of the given \a device. */
QVariantMap JsonTypes::packDevice(Device *device)
{
QVariantMap variant;
@ -603,6 +649,7 @@ QVariantMap JsonTypes::packDevice(Device *device)
return variant;
}
/*! Returns a variant map of the given \a descriptor. */
QVariantMap JsonTypes::packDeviceDescriptor(const DeviceDescriptor &descriptor)
{
QVariantMap variant;
@ -612,6 +659,7 @@ QVariantMap JsonTypes::packDeviceDescriptor(const DeviceDescriptor &descriptor)
return variant;
}
/*! Returns a variant map of the given \a rule. */
QVariantMap JsonTypes::packRule(const Rule &rule)
{
QVariantMap ruleMap;
@ -642,6 +690,7 @@ QVariantMap JsonTypes::packRule(const Rule &rule)
return ruleMap;
}
/*! Returns a variant map of the given \a rules. */
QVariantList JsonTypes::packRules(const QList<Rule> rules)
{
QVariantList rulesList;
@ -651,6 +700,7 @@ QVariantList JsonTypes::packRules(const QList<Rule> rules)
return rulesList;
}
/*! Returns a variant map of the given \a rule. */
QVariantMap JsonTypes::packRuleDescription(const Rule &rule)
{
QVariantMap ruleDescriptionMap;
@ -662,6 +712,7 @@ QVariantMap JsonTypes::packRuleDescription(const Rule &rule)
return ruleDescriptionMap;
}
/*! Returns a variant map of the given \a logEntry. */
QVariantMap JsonTypes::packLogEntry(const LogEntry &logEntry)
{
QVariantMap logEntryMap;
@ -710,6 +761,7 @@ QVariantMap JsonTypes::packLogEntry(const LogEntry &logEntry)
return logEntryMap;
}
/*! Returns a variant list of the given \a createMethods. */
QVariantList JsonTypes::packCreateMethods(DeviceClass::CreateMethods createMethods)
{
QVariantList ret;
@ -725,6 +777,7 @@ QVariantList JsonTypes::packCreateMethods(DeviceClass::CreateMethods createMetho
return ret;
}
/*! Returns a variant list of the supported vendors. */
QVariantList JsonTypes::packSupportedVendors()
{
QVariantList supportedVendors;
@ -734,6 +787,7 @@ QVariantList JsonTypes::packSupportedVendors()
return supportedVendors;
}
/*! Returns a variant list of the supported devices with the given \a vendorId. */
QVariantList JsonTypes::packSupportedDevices(const VendorId &vendorId)
{
QVariantList supportedDeviceList;
@ -743,6 +797,7 @@ QVariantList JsonTypes::packSupportedDevices(const VendorId &vendorId)
return supportedDeviceList;
}
/*! Returns a variant list of configured devices. */
QVariantList JsonTypes::packConfiguredDevices()
{
QVariantList configuredDeviceList;
@ -752,6 +807,7 @@ QVariantList JsonTypes::packConfiguredDevices()
return configuredDeviceList;
}
/*! Returns a variant list of States from the given \a device. */
QVariantList JsonTypes::packDeviceStates(Device *device)
{
DeviceClass deviceClass = GuhCore::instance()->deviceManager()->findDeviceClass(device->deviceClassId());
@ -765,6 +821,7 @@ QVariantList JsonTypes::packDeviceStates(Device *device)
return stateValues;
}
/*! Returns a variant list of the given \a deviceDescriptors. */
QVariantList JsonTypes::packDeviceDescriptors(const QList<DeviceDescriptor> deviceDescriptors)
{
QVariantList deviceDescriptorList;
@ -774,6 +831,7 @@ QVariantList JsonTypes::packDeviceDescriptors(const QList<DeviceDescriptor> devi
return deviceDescriptorList;
}
/*! Returns a variant list containing all rule descriptions. */
QVariantList JsonTypes::packRuleDescriptions()
{
QVariantList rulesList;
@ -783,6 +841,7 @@ QVariantList JsonTypes::packRuleDescriptions()
return rulesList;
}
/*! Returns a variant list of the given \a rules. */
QVariantList JsonTypes::packRuleDescriptions(const QList<Rule> &rules)
{
QVariantList rulesList;
@ -792,6 +851,7 @@ QVariantList JsonTypes::packRuleDescriptions(const QList<Rule> &rules)
return rulesList;
}
/*! Returns a variant list of action types for the given \a deviceClass. */
QVariantList JsonTypes::packActionTypes(const DeviceClass &deviceClass)
{
QVariantList actionTypes;
@ -801,6 +861,7 @@ QVariantList JsonTypes::packActionTypes(const DeviceClass &deviceClass)
return actionTypes;
}
/*! Returns a variant list of state types for the given \a deviceClass. */
QVariantList JsonTypes::packStateTypes(const DeviceClass &deviceClass)
{
QVariantList stateTypes;
@ -810,6 +871,7 @@ QVariantList JsonTypes::packStateTypes(const DeviceClass &deviceClass)
return stateTypes;
}
/*! Returns a variant list of event types for the given \a deviceClass. */
QVariantList JsonTypes::packEventTypes(const DeviceClass &deviceClass)
{
QVariantList eventTypes;
@ -819,6 +881,7 @@ QVariantList JsonTypes::packEventTypes(const DeviceClass &deviceClass)
return eventTypes;
}
/*! Returns a variant list containing all plugins. */
QVariantList JsonTypes::packPlugins()
{
QVariantList pluginsList;
@ -829,6 +892,7 @@ QVariantList JsonTypes::packPlugins()
return pluginsList;
}
/*! Returns the type string for the given \a type. */
QString JsonTypes::basicTypeToString(const QVariant::Type &type)
{
switch (type) {
@ -859,6 +923,7 @@ QString JsonTypes::basicTypeToString(const QVariant::Type &type)
}
}
/*! Returns a \l{Param} created from the given \a paramMap. */
Param JsonTypes::unpackParam(const QVariantMap &paramMap)
{
if (paramMap.keys().count() == 0) {
@ -869,6 +934,7 @@ Param JsonTypes::unpackParam(const QVariantMap &paramMap)
return Param(name, value);
}
/*! Returns a \l{ParamList} created from the given \a paramList. */
ParamList JsonTypes::unpackParams(const QVariantList &paramList)
{
ParamList params;
@ -878,6 +944,7 @@ ParamList JsonTypes::unpackParams(const QVariantList &paramList)
return params;
}
/*! Returns a \l{RuleActionParam} created from the given \a ruleActionParamMap. */
RuleActionParam JsonTypes::unpackRuleActionParam(const QVariantMap &ruleActionParamMap)
{
if (ruleActionParamMap.keys().count() == 0)
@ -890,6 +957,7 @@ RuleActionParam JsonTypes::unpackRuleActionParam(const QVariantMap &ruleActionPa
return RuleActionParam(name, value, eventTypeId, eventParamName);
}
/*! Returns a \l{RuleActionParamList} created from the given \a ruleActionParamList. */
RuleActionParamList JsonTypes::unpackRuleActionParams(const QVariantList &ruleActionParamList)
{
RuleActionParamList ruleActionParams;
@ -899,6 +967,7 @@ RuleActionParamList JsonTypes::unpackRuleActionParams(const QVariantList &ruleAc
return ruleActionParams;
}
/*! Returns a \l{ParamDescriptor} created from the given \a paramMap. */
ParamDescriptor JsonTypes::unpackParamDescriptor(const QVariantMap &paramMap)
{
ParamDescriptor param(paramMap.value("name").toString(), paramMap.value("value"));
@ -911,6 +980,7 @@ ParamDescriptor JsonTypes::unpackParamDescriptor(const QVariantMap &paramMap)
return param;
}
/*! Returns a list of \l{ParamDescriptor} created from the given \a paramList. */
QList<ParamDescriptor> JsonTypes::unpackParamDescriptors(const QVariantList &paramList)
{
QList<ParamDescriptor> params;
@ -920,6 +990,7 @@ QList<ParamDescriptor> JsonTypes::unpackParamDescriptors(const QVariantList &par
return params;
}
/*! Returns a \l{EventDescriptor} created from the given \a eventDescriptorMap. */
EventDescriptor JsonTypes::unpackEventDescriptor(const QVariantMap &eventDescriptorMap)
{
EventTypeId eventTypeId(eventDescriptorMap.value("eventTypeId").toString());
@ -929,6 +1000,7 @@ EventDescriptor JsonTypes::unpackEventDescriptor(const QVariantMap &eventDescrip
return eventDescriptor;
}
/*! Returns a \l{StateEvaluator} created from the given \a stateEvaluatorMap. */
StateEvaluator JsonTypes::unpackStateEvaluator(const QVariantMap &stateEvaluatorMap)
{
StateEvaluator ret(unpackStateDescriptor(stateEvaluatorMap.value("stateDescriptor").toMap()));
@ -943,6 +1015,7 @@ StateEvaluator JsonTypes::unpackStateEvaluator(const QVariantMap &stateEvaluator
return ret;
}
/*! Returns a \l{StateDescriptor} created from the given \a stateDescriptorMap. */
StateDescriptor JsonTypes::unpackStateDescriptor(const QVariantMap &stateDescriptorMap)
{
StateTypeId stateTypeId(stateDescriptorMap.value("stateTypeId").toString());
@ -953,6 +1026,7 @@ StateDescriptor JsonTypes::unpackStateDescriptor(const QVariantMap &stateDescrip
return stateDescriptor;
}
/*! Returns a \l{LogFilter} created from the given \a logFilterMap. */
LogFilter JsonTypes::unpackLogFilter(const QVariantMap &logFilterMap)
{
LogFilter filter;
@ -1011,6 +1085,8 @@ LogFilter JsonTypes::unpackLogFilter(const QVariantMap &logFilterMap)
return filter;
}
/*! Compairs the given \a map with the given \a templateMap. Returns the error string and false if
the params are not valid. */
QPair<bool, QString> JsonTypes::validateMap(const QVariantMap &templateMap, const QVariantMap &map)
{
s_lastError.clear();
@ -1049,6 +1125,8 @@ QPair<bool, QString> JsonTypes::validateMap(const QVariantMap &templateMap, cons
return report(true, "");
}
/*! Compairs the given \a value with the given \a templateValue. Returns the error string and false if
the params are not valid. */
QPair<bool, QString> JsonTypes::validateProperty(const QVariant &templateValue, const QVariant &value)
{
QString strippedTemplateValue = templateValue.toString();
@ -1077,6 +1155,8 @@ QPair<bool, QString> JsonTypes::validateProperty(const QVariant &templateValue,
return report(false, errorString);
}
/*! Compairs the given \a list with the given \a templateList. Returns the error string and false if
the params are not valid. */
QPair<bool, QString> JsonTypes::validateList(const QVariantList &templateList, const QVariantList &list)
{
Q_ASSERT(templateList.count() == 1);
@ -1093,6 +1173,8 @@ QPair<bool, QString> JsonTypes::validateList(const QVariantList &templateList, c
return report(true, "");
}
/*! Compairs the given \a variant with the given \a templateVariant. Returns the error string and false if
the params are not valid. */
QPair<bool, QString> JsonTypes::validateVariant(const QVariant &templateVariant, const QVariant &variant)
{
switch(templateVariant.type()) {
@ -1352,6 +1434,8 @@ QPair<bool, QString> JsonTypes::validateVariant(const QVariant &templateVariant,
return report(true, "");
}
/*! Verify the given \a variant with the possible \l{BasicType}. Returns the error string and false if
the params are not valid. */
QPair<bool, QString> JsonTypes::validateBasicType(const QVariant &variant)
{
if (variant.canConvert(QVariant::Uuid) && QVariant(variant).convert(QVariant::Uuid)) {
@ -1378,6 +1462,7 @@ QPair<bool, QString> JsonTypes::validateBasicType(const QVariant &variant)
return report(false, QString("Error validating basic type %1.").arg(variant.toString()));
}
/*! Returns the type of the \l{Param} with the given \a paramName of the \l{ActionType} with the given \a actionTypeId. */
QVariant::Type JsonTypes::getActionParamType(const ActionTypeId &actionTypeId, const QString &paramName)
{
foreach (const DeviceClass &deviceClass, GuhCore::instance()->deviceManager()->supportedDevices()) {
@ -1394,6 +1479,7 @@ QVariant::Type JsonTypes::getActionParamType(const ActionTypeId &actionTypeId, c
return QVariant::Invalid;
}
/*! Returns the type of the \l{Param} with the given \a paramName of the \l{EventType} with the given \a eventTypeId. */
QVariant::Type JsonTypes::getEventParamType(const EventTypeId &eventTypeId, const QString &paramName)
{
foreach (const DeviceClass &deviceClass, GuhCore::instance()->deviceManager()->supportedDevices()) {
@ -1411,6 +1497,7 @@ QVariant::Type JsonTypes::getEventParamType(const EventTypeId &eventTypeId, cons
return QVariant::Invalid;
}
/*! Returns true if the given \a eventTypeId is in the given \a eventDescriptors.*/
bool JsonTypes::checkEventDescriptors(const QList<EventDescriptor> eventDescriptors, const EventTypeId &eventTypeId)
{
foreach (const EventDescriptor eventDescriptor, eventDescriptors) {
@ -1421,6 +1508,7 @@ bool JsonTypes::checkEventDescriptors(const QList<EventDescriptor> eventDescript
return false;
}
/*! Verifies if the given \a params contain a valid rule. Returns \l{RuleEngine::RuleError} to inform about the result.*/
RuleEngine::RuleError JsonTypes::verifyRuleConsistency(const QVariantMap &params)
{
// check if there are an eventDescriptor and an eventDescriptorList
@ -1448,6 +1536,7 @@ RuleEngine::RuleError JsonTypes::verifyRuleConsistency(const QVariantMap &params
return RuleEngine::RuleErrorNoError;
}
/*! Verifies if the given \a params contain a valid rule. Returns \l{RuleEngine::RuleError} to inform about the result.*/
QPair<QList<EventDescriptor>, RuleEngine::RuleError> JsonTypes::verifyEventDescriptors(const QVariantMap &params)
{
// Check and unpack eventDescriptors
@ -1467,6 +1556,7 @@ QPair<QList<EventDescriptor>, RuleEngine::RuleError> JsonTypes::verifyEventDescr
return QPair<QList<EventDescriptor>, RuleEngine::RuleError>(eventDescriptorList, RuleEngine::RuleErrorNoError);
}
/*! Verifies if the given \a eventDescriptorList corresponds to an action in the given \a params. Returns \l{RuleEngine::RuleError} and \l{RuleAction} list to inform about the result.*/
QPair<QList<RuleAction>, RuleEngine::RuleError> JsonTypes::verifyActions(const QVariantMap &params, const QList<EventDescriptor> &eventDescriptorList)
{
QList<RuleAction> actions;
@ -1524,6 +1614,7 @@ QPair<QList<RuleAction>, RuleEngine::RuleError> JsonTypes::verifyActions(const Q
return QPair<QList<RuleAction>, RuleEngine::RuleError>(actions, RuleEngine::RuleErrorNoError);
}
/*! Verifies if exit actions of the rule in the given \a params. Returns \l{RuleEngine::RuleError} and \l{RuleAction} list to inform about the result. */
QPair<QList<RuleAction>, RuleEngine::RuleError> JsonTypes::verifyExitActions(const QVariantMap &params)
{
QList<RuleAction> exitActions;
@ -1545,6 +1636,8 @@ QPair<QList<RuleAction>, RuleEngine::RuleError> JsonTypes::verifyExitActions(con
return QPair<QList<RuleAction>, RuleEngine::RuleError>(exitActions, RuleEngine::RuleErrorNoError);
}
/*! Compairs the given \a value with the given \a enumDescription. Returns the error string and false if
the enum does not contain the given \a value. */
QPair<bool, QString> JsonTypes::validateEnum(const QVariantList &enumDescription, const QVariant &value)
{
QStringList enumStrings;

12
server/jsonrpc/logginghandler.cpp
View File

@ -32,6 +32,16 @@
\sa LogEngine, JsonHandler, JsonRPCServer
*/
/*! \fn void guhserver::LoggingHandler::LogEntryAdded(const QVariantMap &params);
This signal is emitted to the API notifications when a \l{LogEntry} was added to the database.
The \a params contain the map for the notification.
*/
/*! \fn void guhserver::LoggingHandler::LogDatabaseUpdated(const QVariantMap &params);
This signal is emitted to the API notifications when the logging aatabase has been updated (i.e. \l{Device} or \l{Rule} removed).
The \a params contain the map for the notification.
*/
#include "logginghandler.h"
#include "logging/logengine.h"
#include "logging/logfilter.h"
@ -40,6 +50,7 @@
namespace guhserver {
/*! Constructs a new \l LoggingHandler with the given \a parent. */
LoggingHandler::LoggingHandler(QObject *parent) :
JsonHandler(parent)
{
@ -84,6 +95,7 @@ LoggingHandler::LoggingHandler(QObject *parent) :
connect(GuhCore::instance()->logEngine(), &LogEngine::logDatabaseUpdated, this, &LoggingHandler::logDatabaseUpdated);
}
/*! Returns the name of the \l{LoggingHandler}. In this case \b Logging.*/
QString LoggingHandler::name() const
{
return "Logging";

22
server/jsonrpc/ruleshandler.cpp
View File

@ -32,6 +32,26 @@
\sa RuleEngine, JsonHandler, JsonRPCServer
*/
/*! \fn void guhserver::RulesHandler::RuleRemoved(const QVariantMap &params);
This signal is emitted to the API notifications when a \l{Rule} was removed.
The \a params contain the map for the notification.
*/
/*! \fn void guhserver::RulesHandler::RuleAdded(const QVariantMap &params);
This signal is emitted to the API notifications when a \l{Rule} was added.
The \a params contain the map for the notification.
*/
/*! \fn void guhserver::RulesHandler::RuleActiveChanged(const QVariantMap &params);
This signal is emitted to the API notifications when a \l{Rule} has changed the active status.
The \a params contain the map for the notification.
*/
/*! \fn void guhserver::RulesHandler::RuleConfigurationChanged(const QVariantMap &params);
This signal is emitted to the API notifications when a \l{Rule} has changed the configuration.
The \a params contain the map for the notification.
*/
#include "ruleshandler.h"
#include "guhcore.h"
#include "ruleengine.h"
@ -41,6 +61,7 @@
namespace guhserver {
/*! Constructs a new \l{RulesHandler} with the given \a parent. */
RulesHandler::RulesHandler(QObject *parent) :
JsonHandler(parent)
{
@ -173,6 +194,7 @@ RulesHandler::RulesHandler(QObject *parent) :
connect(GuhCore::instance(), &GuhCore::ruleConfigurationChanged, this, &RulesHandler::ruleConfigurationChangedNotification);
}
/*! Returns the name of the \l{RulesHandler}. In this case \b Rules.*/
QString RulesHandler::name() const
{
return "Rules";

2
server/jsonrpc/statehandler.cpp
View File

@ -38,6 +38,7 @@
namespace guhserver {
/*! Constructs a new \l{StateHandler} with the given \a parent. */
StateHandler::StateHandler(QObject *parent) :
JsonHandler(parent)
{
@ -53,6 +54,7 @@ StateHandler::StateHandler(QObject *parent) :
setReturns("GetStateType", returns);
}
/*! Returns the name of the \l{StateHandler}. In this case \b States.*/
QString StateHandler::name() const
{
return "States";

12
server/logging/logengine.cpp
View File

@ -56,6 +56,10 @@
\sa LogEngine, LogEntry, LogFilter
*/
/*! \fn guhserver::Logging::Logging(QObject *parent)
Constructs the \l{Logging} object with the given \a parent.
*/
/*! \enum guhserver::Logging::LoggingError
Represents the possible errors from the \l{LogEngine}.
@ -73,7 +77,12 @@
\value LoggingEventTypeTrigger
This event type describes an \l{Event} which has triggered.
\value LoggingEventTypeActiveChange
This event type describes an \l{Rule} which has changed its active status.
This event type describes a \l{Rule} which has changed its active status.
\value LoggingEventTypeActionsExecuted
This event type describes the actions execution of a \l{Rule}.
\value LoggingEventTypeExitActionsExecuted
This event type describes the exit actions execution of a \l{Rule}.
*/
/*! \enum guhserver::Logging::LoggingLevel
@ -145,6 +154,7 @@ LogEngine::LogEngine(QObject *parent):
initDB();
}
/*! Destructs the \l{LogEngine}. */
LogEngine::~LogEngine()
{
qCDebug(dcApplication) << "Shutting down \"Log Engine\"";

17
server/logging/logentry.cpp
View File

@ -43,6 +43,7 @@
namespace guhserver {
/*! Constructs a \l{LogEntry} with the given \a timestamp, \a level, \a source and \a errorCode.*/
LogEntry::LogEntry(QDateTime timestamp, Logging::LoggingLevel level, Logging::LoggingSource source, int errorCode):
m_timestamp(timestamp),
m_level(level),
@ -54,83 +55,99 @@ LogEntry::LogEntry(QDateTime timestamp, Logging::LoggingLevel level, Logging::Lo
}
/*! Constructs a \l{LogEntry} with the given \a level, \a source and \a errorCode.*/
LogEntry::LogEntry(Logging::LoggingLevel level, Logging::LoggingSource source, int errorCode):
LogEntry(QDateTime::currentDateTime(), level, source, errorCode)
{
}
/*! Constructs a \l{LogEntry} with the given \a source.*/
LogEntry::LogEntry(Logging::LoggingSource source):
LogEntry(Logging::LoggingLevelInfo, source)
{
}
/*! Returns the timestamp of this \l{LogEntry}. */
QDateTime LogEntry::timestamp() const
{
return m_timestamp;
}
/*! Returns the level of this \l{LogEntry}. */
Logging::LoggingLevel LogEntry::level() const
{
return m_level;
}
/*! Returns the source of this \l{LogEntry}. */
Logging::LoggingSource LogEntry::source() const
{
return m_source;
}
/*! Returns the type ID of this \l{LogEntry}. */
QUuid LogEntry::typeId() const
{
return m_typeId;
}
/*! Sets the \a typeId of this \l{LogEntry}. */
void LogEntry::setTypeId(const QUuid &typeId) {
m_typeId = typeId;
}
/*! Returns the deviceId of this \l{LogEntry}. */
DeviceId LogEntry::deviceId() const
{
return m_deviceId;
}
/*! Sets the \a deviceId of this \l{LogEntry}. */
void LogEntry::setDeviceId(const DeviceId &deviceId)
{
m_deviceId = deviceId;
}
/*! Returns the value of this \l{LogEntry}. */
QString LogEntry::value() const
{
return m_value;
}
/*! Sets the \a value of this \l{LogEntry}. */
void LogEntry::setValue(const QString &value)
{
m_value = value;
}
/*! Returns the event type of this \l{LogEntry}. */
Logging::LoggingEventType LogEntry::eventType() const
{
return m_eventType;
}
/*! Returns true if this \l{LogEntry} is a system active type. */
bool LogEntry::active() const
{
return m_active;
}
/*! Sets this \l{LogEntry} to \a active. */
void LogEntry::setActive(bool active)
{
m_eventType = Logging::LoggingEventTypeActiveChange;
m_active = active;
}
/*! Returns the error code of this \l{LogEntry}. */
int LogEntry::errorCode() const
{
return m_errorCode;
}
QDebug operator<<(QDebug dbg, const LogEntry &entry)
{
dbg.nospace() << "LogEntry (count:" << entry.timestamp().toString() << endl;

17
server/logging/logfilter.cpp
View File

@ -36,11 +36,13 @@
namespace guhserver {
/*! Constructs a new \l{LogFilter}.*/
LogFilter::LogFilter()
{
}
/*! Returns the database query string for this \l{LogFilter}.*/
QString LogFilter::queryString() const
{
if (isEmpty()) {
@ -83,6 +85,7 @@ QString LogFilter::queryString() const
return query;
}
/*! Add a new time filter with the given \a startDate and \a endDate. */
void LogFilter::addTimeFilter(const QDateTime &startDate, const QDateTime &endDate)
{
QPair<QDateTime, QDateTime> timeFilter(startDate, endDate);
@ -90,77 +93,91 @@ void LogFilter::addTimeFilter(const QDateTime &startDate, const QDateTime &endDa
m_timeFilters.append(timeFilter);
}
/*! Returns the list of time filters from this \l{LogFilter}. */
QList<QPair<QDateTime, QDateTime> > LogFilter::timeFilters() const
{
return m_timeFilters;
}
/*! Add a new \a source to this \l{LogFilter}. */
void LogFilter::addLoggingSource(const Logging::LoggingSource &source)
{
if (!m_sources.contains(source))
m_sources.append(source);
}
/*! Returns the list of logging sources from this \l{LogFilter}. */
QList<Logging::LoggingSource> LogFilter::loggingSources() const
{
return m_sources;
}
/*! Add a new \a level to this \l{LogFilter}. */
void LogFilter::addLoggingLevel(const Logging::LoggingLevel &level)
{
if (!m_levels.contains(level))
m_levels.append(level);
}
/*! Returns the list of logging levels from this \l{LogFilter}. */
QList<Logging::LoggingLevel> LogFilter::loggingLevels() const
{
return m_levels;
}
/*! Add a new \a eventType to this \l{LogFilter}. */
void LogFilter::addLoggingEventType(const Logging::LoggingEventType &eventType)
{
if (!m_eventTypes.contains(eventType))
m_eventTypes.append(eventType);
}
/*! Returns the list of event types from this \l{LogFilter}. */
QList<Logging::LoggingEventType> LogFilter::loggingEventTypes() const
{
return m_eventTypes;
}
/*! Add a new \a typeId to this \l{LogFilter}. */
void LogFilter::addTypeId(const QUuid &typeId)
{
if (!m_typeIds.contains(typeId))
m_typeIds.append(typeId);
}
/*! Returns the list of type id's from this \l{LogFilter}. */
QList<QUuid> LogFilter::typeIds() const
{
return m_typeIds;
}
/*! Add a new \a deviceId to this \l{LogFilter}. */
void LogFilter::addDeviceId(const DeviceId &deviceId)
{
if (!m_deviceIds.contains(deviceId))
m_deviceIds.append(deviceId);
}
/*! Returns the list of device id's from this \l{LogFilter}. */
QList<DeviceId> LogFilter::deviceIds() const
{
return m_deviceIds;
}
/*! Add a new \a value to this \l{LogFilter}. */
void LogFilter::addValue(const QString &value)
{
if (!m_values.contains(value))
m_values.append(value);
}
/*! Returns the list of values from this \l{LogFilter}. */
QList<QString> LogFilter::values() const
{
return m_values;
}
/*! Returns true if this \l{LogFilter} is empty. */
bool LogFilter::isEmpty() const
{
return m_timeFilters.isEmpty() &&

1
server/ruleengine.cpp
View File

@ -213,6 +213,7 @@ RuleEngine::RuleEngine(QObject *parent) :
}
}
/*! Destructor of the \l{RuleEngine}. */
RuleEngine::~RuleEngine()
{
qCDebug(dcApplication) << "Shutting down \"Rule Engine\"";