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

improoved rule engine and rule verification

Browse Source
This commit is contained in:
Simon Stürz 2016-04-01 16:19:39 +02:00 committed by Michael Zanetti
parent a4d6f58f3c
commit af500f353c
14 changed files with 458 additions and 548 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

273
server/jsonrpc/jsontypes.cpp
View File

@ -148,7 +148,7 @@ void JsonTypes::init()
s_param.insert("value", basicTypeRef()); s_param.insert("value", basicTypeRef());
// RuleAction // RuleAction
s_ruleAction.insert(" actionTypeId", basicTypeToString(Uuid)); s_ruleAction.insert("actionTypeId", basicTypeToString(Uuid));
s_ruleAction.insert("deviceId", basicTypeToString(Uuid)); s_ruleAction.insert("deviceId", basicTypeToString(Uuid));
s_ruleAction.insert("o:ruleActionParams", QVariantList() << ruleActionParamRef()); s_ruleAction.insert("o:ruleActionParams", QVariantList() << ruleActionParamRef());
@ -265,6 +265,7 @@ void JsonTypes::init()
s_rule.insert("actions", QVariantList() << ruleActionRef()); s_rule.insert("actions", QVariantList() << ruleActionRef());
s_rule.insert("exitActions", QVariantList() << ruleActionRef()); s_rule.insert("exitActions", QVariantList() << ruleActionRef());
s_rule.insert("stateEvaluator", stateEvaluatorRef()); s_rule.insert("stateEvaluator", stateEvaluatorRef());
s_rule.insert("timeDescriptor", timeDescriptorRef());
// RuleDescription // RuleDescription
s_ruleDescription.insert("id", basicTypeToString(Uuid)); s_ruleDescription.insert("id", basicTypeToString(Uuid));
@ -531,7 +532,6 @@ QVariantMap JsonTypes::packStateEvaluator(const StateEvaluator &stateEvaluator)
foreach (const StateEvaluator &childEvaluator, stateEvaluator.childEvaluators()) { foreach (const StateEvaluator &childEvaluator, stateEvaluator.childEvaluators()) {
childEvaluators.append(packStateEvaluator(childEvaluator)); childEvaluators.append(packStateEvaluator(childEvaluator));
} }
qCDebug(dcJsonRpc) << "state operator:" << stateOperator() << stateEvaluator.operatorType();
variantMap.insert("operator", stateOperator().at(stateEvaluator.operatorType())); variantMap.insert("operator", stateOperator().at(stateEvaluator.operatorType()));
if (childEvaluators.count() > 0) { if (childEvaluators.count() > 0) {
variantMap.insert("childEvaluators", childEvaluators); variantMap.insert("childEvaluators", childEvaluators);
@ -702,6 +702,7 @@ QVariantMap JsonTypes::packRule(const Rule &rule)
ruleMap.insert("enabled", rule.enabled()); ruleMap.insert("enabled", rule.enabled());
ruleMap.insert("active", rule.active()); ruleMap.insert("active", rule.active());
ruleMap.insert("executable", rule.executable()); ruleMap.insert("executable", rule.executable());
ruleMap.insert("timeDescriptor", JsonTypes::packTimeDescriptor(rule.timeDescriptor()));
QVariantList eventDescriptorList; QVariantList eventDescriptorList;
foreach (const EventDescriptor &eventDescriptor, rule.eventDescriptors()) { foreach (const EventDescriptor &eventDescriptor, rule.eventDescriptors()) {
@ -870,8 +871,10 @@ QVariantMap JsonTypes::packTimeDescriptor(const TimeDescriptor &timeDescriptor)
foreach (const CalendarItem &calendarItem, timeDescriptor.calendarItems()) { foreach (const CalendarItem &calendarItem, timeDescriptor.calendarItems()) {
calendarItems.append(packCalendarItem(calendarItem)); calendarItems.append(packCalendarItem(calendarItem));
} }
timeDescriptorVariant.insert("calendarItems", calendarItems);
} }
// TODO: TimeEventItems // TODO: TimeEventItems
return timeDescriptorVariant; return timeDescriptorVariant;
@ -1047,6 +1050,68 @@ ParamList JsonTypes::unpackParams(const QVariantList &paramList)
return params; return params;
} }
Rule JsonTypes::unpackRule(const QVariantMap &ruleMap)
{
// The rule id will only be valid if unpacking for edit
RuleId ruleId = RuleId(ruleMap.value("ruleId").toString());
QString name = ruleMap.value("name", QString()).toString();
// By default enabled
bool enabled = ruleMap.value("enabled", true).toBool();
// By default executable
bool executable = ruleMap.value("executable", true).toBool();
StateEvaluator stateEvaluator = JsonTypes::unpackStateEvaluator(ruleMap.value("stateEvaluator").toMap());
TimeDescriptor timeDescriptor = JsonTypes::unpackTimeDescriptor(ruleMap.value("timeDescriptor").toMap());
QList<EventDescriptor> eventDescriptors;
if (ruleMap.contains("eventDescriptors")) {
QVariantList eventDescriptorVariantList = ruleMap.value("eventDescriptors").toList();
qCDebug(dcJsonRpc) << "unpacking eventDescriptors:" << eventDescriptorVariantList;
foreach (const QVariant &eventDescriptorVariant, eventDescriptorVariantList) {
eventDescriptors.append(JsonTypes::unpackEventDescriptor(eventDescriptorVariant.toMap()));
}
}
QList<RuleAction> actions;
if (ruleMap.contains("actions")) {
QVariantList actionsVariantList = ruleMap.value("actions").toList();
foreach (const QVariant &actionVariant, actionsVariantList) {
actions.append(JsonTypes::unpackRuleAction(actionVariant.toMap()));
}
}
QList<RuleAction> exitActions;
if (ruleMap.contains("exitActions")) {
QVariantList exitActionsVariantList = ruleMap.value("exitActions").toList();
foreach (const QVariant &exitActionVariant, exitActionsVariantList) {
exitActions.append(JsonTypes::unpackRuleAction(exitActionVariant.toMap()));
}
}
Rule rule;
rule.setId(ruleId);
rule.setName(name);
rule.setTimeDescriptor(timeDescriptor);
rule.setStateEvaluator(stateEvaluator);
rule.setEventDescriptors(eventDescriptors);
rule.setActions(actions);
rule.setExitActions(exitActions);
rule.setEnabled(enabled);
rule.setExecutable(executable);
return rule;
}
RuleAction JsonTypes::unpackRuleAction(const QVariantMap &ruleActionMap)
{
RuleAction action(ActionTypeId(ruleActionMap.value("actionTypeId").toString()), DeviceId(ruleActionMap.value("deviceId").toString()));
RuleActionParamList actionParamList = JsonTypes::unpackRuleActionParams(ruleActionMap.value("ruleActionParams").toList());
action.setRuleActionParams(actionParamList);
return action;
}
/*! Returns a \l{RuleActionParam} created from the given \a ruleActionParamMap. */ /*! Returns a \l{RuleActionParam} created from the given \a ruleActionParamMap. */
RuleActionParam JsonTypes::unpackRuleActionParam(const QVariantMap &ruleActionParamMap) RuleActionParam JsonTypes::unpackRuleActionParam(const QVariantMap &ruleActionParamMap)
{ {
@ -1485,6 +1550,30 @@ QPair<bool, QString> JsonTypes::validateVariant(const QVariant &templateVariant,
qCWarning(dcJsonRpc) << "LogEntry not matching"; qCWarning(dcJsonRpc) << "LogEntry not matching";
return result; return result;
} }
} else if (refName == timeDescriptorRef()) {
QPair<bool, QString> result = validateMap(timeDescriptorDescription(), variant.toMap());
if (!result.first) {
qCWarning(dcJsonRpc) << "TimeDescriptor not matching";
return result;
}
} else if (refName == calendarItemRef()) {
QPair<bool, QString> result = validateMap(calendarItemDescription(), variant.toMap());
if (!result.first) {
qCWarning(dcJsonRpc) << "CalendarItem not matching";
return result;
}
} else if (refName == timeDescriptorRef()) {
QPair<bool, QString> result = validateMap(timeEventItemDescription(), variant.toMap());
if (!result.first) {
qCWarning(dcJsonRpc) << "TimeEventItem not matching";
return result;
}
} else if (refName == repeatingOptionRef()) {
QPair<bool, QString> result = validateMap(repeatingOptionDescription(), variant.toMap());
if (!result.first) {
qCWarning(dcJsonRpc) << "RepeatingOption not matching";
return result;
}
} else if (refName == basicTypeRef()) { } else if (refName == basicTypeRef()) {
QPair<bool, QString> result = validateBasicType(variant); QPair<bool, QString> result = validateBasicType(variant);
if (!result.first) { if (!result.first) {
@ -1575,6 +1664,12 @@ QPair<bool, QString> JsonTypes::validateVariant(const QVariant &templateVariant,
qCWarning(dcJsonRpc) << QString("Value %1 not allowed in %2").arg(variant.toString()).arg(deviceIconRef()); qCWarning(dcJsonRpc) << QString("Value %1 not allowed in %2").arg(variant.toString()).arg(deviceIconRef());
return result; return result;
} }
} else if (refName == repeatingModeRef()) {
QPair<bool, QString> result = validateEnum(s_repeatingMode, variant);
if (!result.first) {
qCWarning(dcJsonRpc) << QString("Value %1 not allowed in %2").arg(variant.toString()).arg(repeatingModeRef());
return result;
}
} else { } else {
Q_ASSERT_X(false, "JsonTypes", QString("Unhandled ref: %1").arg(refName).toLatin1().data()); Q_ASSERT_X(false, "JsonTypes", QString("Unhandled ref: %1").arg(refName).toLatin1().data());
return report(false, QString("Unhandled ref %1. Server implementation incomplete.").arg(refName)); return report(false, QString("Unhandled ref %1. Server implementation incomplete.").arg(refName));
@ -1640,180 +1735,6 @@ QPair<bool, QString> JsonTypes::validateBasicType(const QVariant &variant)
return report(false, QString("Error validating basic type %1.").arg(variant.toString())); 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()) {
foreach (const ActionType &actionType, deviceClass.actionTypes()) {
if (actionType.id() == actionTypeId) {
foreach (const ParamType &paramType, actionType.paramTypes()) {
if (paramType.name() == paramName) {
return paramType.type();
}
}
}
}
}
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()) {
foreach (const EventType &eventType, deviceClass.eventTypes()) {
if (eventType.id() == eventTypeId) {
foreach (const ParamType &paramType, eventType.paramTypes()) {
// get ParamType of Event
if (paramType.name() == paramName) {
return paramType.type();
}
}
}
}
}
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) {
if (eventDescriptor.eventTypeId() == eventTypeId) {
return true;
}
}
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
if (params.contains("eventDescriptor") && params.contains("eventDescriptorList")) {
qCWarning(dcJsonRpc) << "Only one of eventDesciptor or eventDescriptorList may be used.";
return RuleEngine::RuleErrorInvalidParameter;
}
// check if this rules is based on any event and contains exit actions
if (params.contains("eventDescriptor") || params.contains("eventDescriptorList")) {
if (params.contains("exitActions")) {
qCWarning(dcJsonRpc) << "The exitActions will never be executed if the rule contains an eventDescriptor.";
return RuleEngine::RuleErrorInvalidRuleFormat;
}
}
// check if there are any actions
if (params.value("actions").toList().isEmpty()) {
qCWarning(dcJsonRpc) << "Rule actions missing. A rule without actions has no effect.";
return RuleEngine::RuleErrorMissingParameter;
}
// TODO: check if events and stateEvaluators are missing
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
QList<EventDescriptor> eventDescriptorList = QList<EventDescriptor>();
if (params.contains("eventDescriptor")) {
QVariantMap eventMap = params.value("eventDescriptor").toMap();
qCDebug(dcJsonRpc) << "unpacking eventDescriptor" << eventMap;
eventDescriptorList.append(JsonTypes::unpackEventDescriptor(eventMap));
} else if (params.contains("eventDescriptorList")) {
QVariantList eventDescriptors = params.value("eventDescriptorList").toList();
qCDebug(dcJsonRpc) << "unpacking eventDescriptorList:" << eventDescriptors;
foreach (const QVariant &eventVariant, eventDescriptors) {
QVariantMap eventMap = eventVariant.toMap();
eventDescriptorList.append(JsonTypes::unpackEventDescriptor(eventMap));
}
}
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;
QVariantList actionList = params.value("actions").toList();
if (actionList.isEmpty()) {
qCWarning(dcJsonRpc) << "Rule has no actions. This rule will do nothing.";
return QPair<QList<RuleAction>, RuleEngine::RuleError>(actions, RuleEngine::RuleErrorInvalidRuleFormat);
}
qCDebug(dcJsonRpc) << "unpacking actions:" << actionList;
foreach (const QVariant &actionVariant, actionList) {
QVariantMap actionMap = actionVariant.toMap();
RuleAction action(ActionTypeId(actionMap.value("actionTypeId").toString()), DeviceId(actionMap.value("deviceId").toString()));
RuleActionParamList actionParamList = JsonTypes::unpackRuleActionParams(actionMap.value("ruleActionParams").toList());
foreach (const RuleActionParam &ruleActionParam, actionParamList) {
if (!ruleActionParam.isValid()) {
qCWarning(dcJsonRpc) << "got an actionParam with value AND eventTypeId!";
return QPair<QList<RuleAction>, RuleEngine::RuleError>(actions, RuleEngine::RuleErrorInvalidRuleActionParameter);
}
}
qCDebug(dcJsonRpc) << "params in exitAction" << action.ruleActionParams();
action.setRuleActionParams(actionParamList);
actions.append(action);
}
// check possible eventTypeIds in params
foreach (const RuleAction &ruleAction, actions) {
if (ruleAction.isEventBased()) {
foreach (const RuleActionParam &ruleActionParam, ruleAction.ruleActionParams()) {
if (ruleActionParam.eventTypeId() != EventTypeId()) {
// We have an eventTypeId
if (eventDescriptorList.isEmpty()) {
qCWarning(dcJsonRpc) << "RuleAction" << ruleAction.actionTypeId() << "contains an eventTypeId, but there are no eventDescriptors.";
return QPair<QList<RuleAction>, RuleEngine::RuleError>(actions, RuleEngine::RuleErrorInvalidRuleActionParameter);
}
// now check if this eventType is in the eventDescriptorList of this rule
if (!checkEventDescriptors(eventDescriptorList, ruleActionParam.eventTypeId())) {
qCWarning(dcJsonRpc) << "eventTypeId from RuleAction" << ruleAction.actionTypeId() << "missing in eventDescriptors.";
return QPair<QList<RuleAction>, RuleEngine::RuleError>(actions, RuleEngine::RuleErrorInvalidRuleActionParameter);
}
// check if the param type of the event and the action match
QVariant::Type eventParamType = getEventParamType(ruleActionParam.eventTypeId(), ruleActionParam.eventParamName());
QVariant::Type actionParamType = getActionParamType(ruleAction.actionTypeId(), ruleActionParam.name());
if (eventParamType != actionParamType) {
qCWarning(dcJsonRpc) << "RuleActionParam" << ruleActionParam.name() << " and given event param " << ruleActionParam.eventParamName() << "have not the same type:";
qCWarning(dcJsonRpc) << " -> actionParamType:" << actionParamType;
qCWarning(dcJsonRpc) << " -> eventParamType:" << eventParamType;
return QPair<QList<RuleAction>, RuleEngine::RuleError>(actions, RuleEngine::RuleErrorTypesNotMatching);
}
}
}
}
}
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;
if (params.contains("exitActions")) {
QVariantList exitActionList = params.value("exitActions").toList();
qCDebug(dcJsonRpc) << "unpacking exitActions:" << exitActionList;
foreach (const QVariant &actionVariant, exitActionList) {
QVariantMap actionMap = actionVariant.toMap();
RuleAction action(ActionTypeId(actionMap.value("actionTypeId").toString()), DeviceId(actionMap.value("deviceId").toString()));
if (action.isEventBased()) {
qCWarning(dcJsonRpc) << "got exitAction with a param value containing an eventTypeId!";
return QPair<QList<RuleAction>, RuleEngine::RuleError>(exitActions, RuleEngine::RuleErrorInvalidRuleActionParameter);
}
qCDebug(dcJsonRpc) << "params in exitAction" << action.ruleActionParams();
action.setRuleActionParams(JsonTypes::unpackRuleActionParams(actionMap.value("ruleActionParams").toList()));
exitActions.append(action);
}
}
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 /*! 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. */ the enum does not contain the given \a value. */
QPair<bool, QString> JsonTypes::validateEnum(const QVariantList &enumDescription, const QVariant &value) QPair<bool, QString> JsonTypes::validateEnum(const QVariantList &enumDescription, const QVariant &value)

11
server/jsonrpc/jsontypes.h
View File

@ -201,6 +201,8 @@ public:
// unpack Types // unpack Types
static Param unpackParam(const QVariantMap &paramMap); static Param unpackParam(const QVariantMap &paramMap);
static ParamList unpackParams(const QVariantList &paramList); static ParamList unpackParams(const QVariantList &paramList);
static Rule unpackRule(const QVariantMap &ruleMap);
static RuleAction unpackRuleAction(const QVariantMap &ruleActionMap);
static RuleActionParam unpackRuleActionParam(const QVariantMap &ruleActionParamMap); static RuleActionParam unpackRuleActionParam(const QVariantMap &ruleActionParamMap);
static RuleActionParamList unpackRuleActionParams(const QVariantList &ruleActionParamList); static RuleActionParamList unpackRuleActionParams(const QVariantList &ruleActionParamList);
static ParamDescriptor unpackParamDescriptor(const QVariantMap &paramDescriptorMap); static ParamDescriptor unpackParamDescriptor(const QVariantMap &paramDescriptorMap);
@ -222,15 +224,6 @@ public:
static QPair<bool, QString> validateEnum(const QVariantList &enumList, const QVariant &value); static QPair<bool, QString> validateEnum(const QVariantList &enumList, const QVariant &value);
static QPair<bool, QString> validateBasicType(const QVariant &variant); static QPair<bool, QString> validateBasicType(const QVariant &variant);
// rule validation helper methods
static bool checkEventDescriptors(const QList<EventDescriptor> eventDescriptors, const EventTypeId &eventTypeId);
static QVariant::Type getActionParamType(const ActionTypeId &actionTypeId, const QString &paramName);
static QVariant::Type getEventParamType(const EventTypeId &eventTypeId, const QString &paramName);
static RuleEngine::RuleError verifyRuleConsistency(const QVariantMap &params);
static QPair<QList<EventDescriptor>, RuleEngine::RuleError> verifyEventDescriptors(const QVariantMap &params);
static QPair<QList<RuleAction>, RuleEngine::RuleError> verifyActions(const QVariantMap &params, const QList<EventDescriptor> &eventDescriptorList);
static QPair<QList<RuleAction>, RuleEngine::RuleError> verifyExitActions(const QVariantMap &params);
private: private:
static bool s_initialized; static bool s_initialized;
static void init(); static void init();

127
server/jsonrpc/ruleshandler.cpp
View File

@ -87,36 +87,33 @@ RulesHandler::RulesHandler(QObject *parent) :
setDescription("AddRule", "Add a rule. You can describe rules by one or many EventDesciptors and a StateEvaluator. Note that only " setDescription("AddRule", "Add a rule. You can describe rules by one or many EventDesciptors and a StateEvaluator. Note that only "
"one of either eventDescriptor or eventDescriptorList may be passed at a time. A rule can be created but left disabled, " "one of either eventDescriptor or eventDescriptorList may be passed at a time. A rule can be created but left disabled, "
"meaning it won't actually be executed until set to enabled. If not given, enabled defaults to true."); "meaning it won't actually be executed until set to enabled. If not given, enabled defaults to true.");
params.insert("o:eventDescriptor", JsonTypes::eventDescriptorRef()); params.insert("name", JsonTypes::basicTypeToString(JsonTypes::String));
params.insert("o:eventDescriptorList", QVariantList() << JsonTypes::eventDescriptorRef()); params.insert("actions", QVariantList() << JsonTypes::ruleActionRef());
params.insert("o:timeDescriptor", JsonTypes::timeDescriptorRef());
params.insert("o:stateEvaluator", JsonTypes::stateEvaluatorRef()); params.insert("o:stateEvaluator", JsonTypes::stateEvaluatorRef());
params.insert("o:eventDescriptors", QVariantList() << JsonTypes::eventDescriptorRef());
params.insert("o:exitActions", QVariantList() << JsonTypes::ruleActionRef()); params.insert("o:exitActions", QVariantList() << JsonTypes::ruleActionRef());
params.insert("o:enabled", JsonTypes::basicTypeToString(JsonTypes::Bool)); params.insert("o:enabled", JsonTypes::basicTypeToString(JsonTypes::Bool));
params.insert("o:executable", JsonTypes::basicTypeToString(JsonTypes::Bool)); params.insert("o:executable", JsonTypes::basicTypeToString(JsonTypes::Bool));
params.insert("name", JsonTypes::basicTypeToString(JsonTypes::String));
QVariantList actions;
actions.append(JsonTypes::ruleActionRef());
params.insert("actions", actions);
setParams("AddRule", params); setParams("AddRule", params);
returns.insert("ruleError", JsonTypes::ruleErrorRef()); returns.insert("ruleError", JsonTypes::ruleErrorRef());
returns.insert("o:ruleId", JsonTypes::basicTypeToString(JsonTypes::Uuid)); returns.insert("o:ruleId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
setReturns("AddRule", returns); setReturns("AddRule", returns);
params.clear(); returns.clear(); actions.clear(); params.clear(); returns.clear();
setDescription("EditRule", "Edit the parameters of a rule. The configuration of the rule with the given ruleId " setDescription("EditRule", "Edit the parameters of a rule. The configuration of the rule with the given ruleId "
"will be replaced with the new given configuration. In ordert to enable or disable a Rule, please use the " "will be replaced with the new given configuration. In ordert to enable or disable a Rule, please use the "
"methods \"Rules.EnableRule\" and \"Rules.DisableRule\". If successfull, the notification \"Rule.RuleConfigurationChanged\" " "methods \"Rules.EnableRule\" and \"Rules.DisableRule\". If successfull, the notification \"Rule.RuleConfigurationChanged\" "
"will be emitted."); "will be emitted.");
params.insert("ruleId", JsonTypes::basicTypeToString(JsonTypes::Uuid)); params.insert("ruleId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
params.insert("name", JsonTypes::basicTypeToString(JsonTypes::String)); params.insert("name", JsonTypes::basicTypeToString(JsonTypes::String));
params.insert("o:eventDescriptor", JsonTypes::eventDescriptorRef()); params.insert("actions", QVariantList() << JsonTypes::ruleActionRef());
params.insert("o:eventDescriptorList", QVariantList() << JsonTypes::eventDescriptorRef()); params.insert("o:timeDescriptor", JsonTypes::timeDescriptorRef());
params.insert("o:stateEvaluator", JsonTypes::stateEvaluatorRef()); params.insert("o:stateEvaluator", JsonTypes::stateEvaluatorRef());
params.insert("o:eventDescriptors", QVariantList() << JsonTypes::eventDescriptorRef());
params.insert("o:exitActions", QVariantList() << JsonTypes::ruleActionRef()); params.insert("o:exitActions", QVariantList() << JsonTypes::ruleActionRef());
params.insert("o:enabled", JsonTypes::basicTypeToString(JsonTypes::Bool)); params.insert("o:enabled", JsonTypes::basicTypeToString(JsonTypes::Bool));
params.insert("o:executable", JsonTypes::basicTypeToString(JsonTypes::Bool)); params.insert("o:executable", JsonTypes::basicTypeToString(JsonTypes::Bool));
actions.append(JsonTypes::ruleActionRef());
params.insert("actions", actions);
setParams("EditRule", params); setParams("EditRule", params);
returns.insert("ruleError", JsonTypes::ruleErrorRef()); returns.insert("ruleError", JsonTypes::ruleErrorRef());
returns.insert("o:rule", JsonTypes::ruleRef()); returns.insert("o:rule", JsonTypes::ruleRef());
@ -224,59 +221,13 @@ JsonReply *RulesHandler::GetRuleDetails(const QVariantMap &params)
JsonReply* RulesHandler::AddRule(const QVariantMap &params) JsonReply* RulesHandler::AddRule(const QVariantMap &params)
{ {
// check rule consistency Rule rule = JsonTypes::unpackRule(params);
RuleEngine::RuleError ruleConsistencyError = JsonTypes::verifyRuleConsistency(params); rule.setId(RuleId::createRuleId());
if (ruleConsistencyError != RuleEngine::RuleErrorNoError) {
QVariantMap returns;
returns.insert("ruleError", JsonTypes::ruleErrorToString(ruleConsistencyError));
return createReply(returns);
}
// Check and upack eventDescriptorList RuleEngine::RuleError status = GuhCore::instance()->ruleEngine()->addRule(rule);
QPair<QList<EventDescriptor>, RuleEngine::RuleError> eventDescriptorVerification = JsonTypes::verifyEventDescriptors(params);
QList<EventDescriptor> eventDescriptorList = eventDescriptorVerification.first;
if (eventDescriptorVerification.second != RuleEngine::RuleErrorNoError) {
QVariantMap returns;
returns.insert("ruleError", JsonTypes::ruleErrorToString(eventDescriptorVerification.second));
return createReply(returns);
}
// Check and unpack stateEvaluator
qCDebug(dcJsonRpc) << "unpacking stateEvaluator:" << params.value("stateEvaluator").toMap();
StateEvaluator stateEvaluator = JsonTypes::unpackStateEvaluator(params.value("stateEvaluator").toMap());
if (!stateEvaluator.isValid()) {
QVariantMap returns;
returns.insert("ruleError", JsonTypes::ruleErrorToString(RuleEngine::RuleErrorInvalidStateEvaluatorValue));
return createReply(returns);
}
// Check and unpack actions
QPair<QList<RuleAction>, RuleEngine::RuleError> actionsVerification = JsonTypes::verifyActions(params, eventDescriptorList);
QList<RuleAction> actions = actionsVerification.first;
if (actionsVerification.second != RuleEngine::RuleErrorNoError) {
QVariantMap returns;
returns.insert("ruleError", JsonTypes::ruleErrorToString(actionsVerification.second));
return createReply(returns);
}
// Check and unpack exitActions
QPair<QList<RuleAction>, RuleEngine::RuleError> exitActionsVerification = JsonTypes::verifyExitActions(params);
QList<RuleAction> exitActions = exitActionsVerification.first;
if (exitActionsVerification.second != RuleEngine::RuleErrorNoError) {
QVariantMap returns;
returns.insert("ruleError", JsonTypes::ruleErrorToString(exitActionsVerification.second));
return createReply(returns);
}
QString name = params.value("name", QString()).toString();
bool enabled = params.value("enabled", true).toBool();
bool executable = params.value("executable", true).toBool();
RuleId newRuleId = RuleId::createRuleId();
RuleEngine::RuleError status = GuhCore::instance()->ruleEngine()->addRule(newRuleId, name, eventDescriptorList, stateEvaluator, actions, exitActions, enabled, executable);
QVariantMap returns; QVariantMap returns;
if (status == RuleEngine::RuleErrorNoError) { if (status == RuleEngine::RuleErrorNoError) {
returns.insert("ruleId", newRuleId.toString()); returns.insert("ruleId", rule.id().toString());
} }
returns.insert("ruleError", JsonTypes::ruleErrorToString(status)); returns.insert("ruleError", JsonTypes::ruleErrorToString(status));
return createReply(returns); return createReply(returns);
@ -284,59 +235,11 @@ JsonReply* RulesHandler::AddRule(const QVariantMap &params)
JsonReply *RulesHandler::EditRule(const QVariantMap &params) JsonReply *RulesHandler::EditRule(const QVariantMap &params)
{ {
// check rule consistency Rule rule = JsonTypes::unpackRule(params);
RuleEngine::RuleError ruleConsistencyError = JsonTypes::verifyRuleConsistency(params); RuleEngine::RuleError status = GuhCore::instance()->ruleEngine()->editRule(rule);
if (ruleConsistencyError != RuleEngine::RuleErrorNoError) {
QVariantMap returns;
returns.insert("ruleError", JsonTypes::ruleErrorToString(ruleConsistencyError));
return createReply(returns);
}
// Check and upack eventDescriptorList
QPair<QList<EventDescriptor>, RuleEngine::RuleError> eventDescriptorVerification = JsonTypes::verifyEventDescriptors(params);
QList<EventDescriptor> eventDescriptorList = eventDescriptorVerification.first;
if (eventDescriptorVerification.second != RuleEngine::RuleErrorNoError) {
QVariantMap returns;
returns.insert("ruleError", JsonTypes::ruleErrorToString(eventDescriptorVerification.second));
return createReply(returns);
}
// Check and unpack stateEvaluator
qCDebug(dcJsonRpc) << "unpacking stateEvaluator:" << params.value("stateEvaluator").toMap();
StateEvaluator stateEvaluator = JsonTypes::unpackStateEvaluator(params.value("stateEvaluator").toMap());
if (!stateEvaluator.isValid()) {
QVariantMap returns;
returns.insert("ruleError", JsonTypes::ruleErrorToString(RuleEngine::RuleErrorInvalidStateEvaluatorValue));
return createReply(returns);
}
// Check and unpack actions
QPair<QList<RuleAction>, RuleEngine::RuleError> actionsVerification = JsonTypes::verifyActions(params, eventDescriptorList);
QList<RuleAction> actions = actionsVerification.first;
if (actionsVerification.second != RuleEngine::RuleErrorNoError) {
QVariantMap returns;
returns.insert("ruleError", JsonTypes::ruleErrorToString(actionsVerification.second));
return createReply(returns);
}
// Check and unpack exitActions
QPair<QList<RuleAction>, RuleEngine::RuleError> exitActionsVerification = JsonTypes::verifyExitActions(params);
QList<RuleAction> exitActions = exitActionsVerification.first;
if (exitActionsVerification.second != RuleEngine::RuleErrorNoError) {
QVariantMap returns;
returns.insert("ruleError", JsonTypes::ruleErrorToString(exitActionsVerification.second));
return createReply(returns);
}
QString name = params.value("name", QString()).toString();
bool enabled = params.value("enabled", true).toBool();
bool executable = params.value("executable", true).toBool();
RuleId ruleId = RuleId(params.value("ruleId").toString());
RuleEngine::RuleError status = GuhCore::instance()->ruleEngine()->editRule(ruleId, name, eventDescriptorList, stateEvaluator, actions, exitActions, enabled, executable);
QVariantMap returns; QVariantMap returns;
if (status == RuleEngine::RuleErrorNoError) { if (status == RuleEngine::RuleErrorNoError) {
returns.insert("rule", JsonTypes::packRule(GuhCore::instance()->ruleEngine()->findRule(ruleId))); returns.insert("rule", JsonTypes::packRule(GuhCore::instance()->ruleEngine()->findRule(rule.id())));
} }
returns.insert("ruleError", JsonTypes::ruleErrorToString(status)); returns.insert("ruleError", JsonTypes::ruleErrorToString(status));
return createReply(returns); return createReply(returns);

96
server/rest/rulesresource.cpp
View File

@ -75,8 +75,10 @@ HttpReply *RulesResource::proccessRequest(const HttpRequest &request, const QStr
return createRuleErrorReply(HttpReply::BadRequest, RuleEngine::RuleErrorRuleNotFound); return createRuleErrorReply(HttpReply::BadRequest, RuleEngine::RuleErrorRuleNotFound);
} }
if (GuhCore::instance()->ruleEngine()->findRule(m_ruleId).id().isNull()) if (!GuhCore::instance()->ruleEngine()->findRule(m_ruleId).isValid()) {
qCWarning(dcRest) << "Could not find rule with id" << m_ruleId.toString();
return createRuleErrorReply(HttpReply::NotFound, RuleEngine::RuleErrorRuleNotFound); return createRuleErrorReply(HttpReply::NotFound, RuleEngine::RuleErrorRuleNotFound);
}
} }
@ -201,7 +203,7 @@ HttpReply *RulesResource::getRules(const DeviceId &deviceId) const
QList<Rule> ruleList; QList<Rule> ruleList;
foreach (const RuleId &ruleId, ruleIdsList) { foreach (const RuleId &ruleId, ruleIdsList) {
Rule rule = GuhCore::instance()->ruleEngine()->findRule(ruleId); Rule rule = GuhCore::instance()->ruleEngine()->findRule(ruleId);
if (!rule.id().isNull()) if (rule.isValid())
ruleList.append(rule); ruleList.append(rule);
} }
reply->setHeader(HttpReply::ContentTypeHeader, "application/json; charset=\"utf-8\";"); reply->setHeader(HttpReply::ContentTypeHeader, "application/json; charset=\"utf-8\";");
@ -212,11 +214,11 @@ HttpReply *RulesResource::getRules(const DeviceId &deviceId) const
HttpReply *RulesResource::getRuleDetails(const RuleId &ruleId) const HttpReply *RulesResource::getRuleDetails(const RuleId &ruleId) const
{ {
Rule rule = GuhCore::instance()->ruleEngine()->findRule(ruleId);
if (rule.id().isNull())
return createRuleErrorReply(HttpReply::NotFound, RuleEngine::RuleErrorRuleNotFound);
qCDebug(dcRest) << "Get rule details"; qCDebug(dcRest) << "Get rule details";
// Note: rule existence already checked
Rule rule = GuhCore::instance()->ruleEngine()->findRule(ruleId);
HttpReply *reply = createSuccessReply(); HttpReply *reply = createSuccessReply();
reply->setHeader(HttpReply::ContentTypeHeader, "application/json; charset=\"utf-8\";"); reply->setHeader(HttpReply::ContentTypeHeader, "application/json; charset=\"utf-8\";");
reply->setPayload(QJsonDocument::fromVariant(JsonTypes::packRule(rule)).toJson()); reply->setPayload(QJsonDocument::fromVariant(JsonTypes::packRule(rule)).toJson());
@ -228,7 +230,6 @@ HttpReply *RulesResource::removeRule(const RuleId &ruleId) const
qCDebug(dcRest) << "Remove rule with id" << ruleId.toString(); qCDebug(dcRest) << "Remove rule with id" << ruleId.toString();
RuleEngine::RuleError status = GuhCore::instance()->removeRule(ruleId); RuleEngine::RuleError status = GuhCore::instance()->removeRule(ruleId);
if (status != RuleEngine::RuleErrorNoError) if (status != RuleEngine::RuleErrorNoError)
return createRuleErrorReply(HttpReply::InternalServerError, status); return createRuleErrorReply(HttpReply::InternalServerError, status);
@ -244,45 +245,12 @@ HttpReply *RulesResource::addRule(const QByteArray &payload) const
return createErrorReply(HttpReply::BadRequest); return createErrorReply(HttpReply::BadRequest);
QVariantMap params = verification.second.toMap(); QVariantMap params = verification.second.toMap();
Rule rule = JsonTypes::unpackRule(params);
rule.setId(RuleId::createRuleId());
// check rule consistency RuleEngine::RuleError status = GuhCore::instance()->ruleEngine()->addRule(rule);
RuleEngine::RuleError ruleConsistencyError = JsonTypes::verifyRuleConsistency(params);
if (ruleConsistencyError != RuleEngine::RuleErrorNoError)
return createRuleErrorReply(HttpReply::BadRequest, ruleConsistencyError);
// Check and upack eventDescriptorList
QPair<QList<EventDescriptor>, RuleEngine::RuleError> eventDescriptorVerification = JsonTypes::verifyEventDescriptors(params);
QList<EventDescriptor> eventDescriptorList = eventDescriptorVerification.first;
if (eventDescriptorVerification.second != RuleEngine::RuleErrorNoError)
return createRuleErrorReply(HttpReply::BadRequest, eventDescriptorVerification.second);
// Check and unpack stateEvaluator
qCDebug(dcRest) << "unpacking stateEvaluator:" << params.value("stateEvaluator").toMap();
StateEvaluator stateEvaluator = JsonTypes::unpackStateEvaluator(params.value("stateEvaluator").toMap());
if (!stateEvaluator.isValid())
return createRuleErrorReply(HttpReply::BadRequest, RuleEngine::RuleErrorInvalidStateEvaluatorValue);
// Check and unpack actions
QPair<QList<RuleAction>, RuleEngine::RuleError> actionsVerification = JsonTypes::verifyActions(params, eventDescriptorList);
QList<RuleAction> actions = actionsVerification.first;
if (actionsVerification.second != RuleEngine::RuleErrorNoError)
return createRuleErrorReply(HttpReply::BadRequest, actionsVerification.second);
// Check and unpack exitActions
QPair<QList<RuleAction>, RuleEngine::RuleError> exitActionsVerification = JsonTypes::verifyExitActions(params);
QList<RuleAction> exitActions = exitActionsVerification.first;
if (exitActionsVerification.second != RuleEngine::RuleErrorNoError)
return createRuleErrorReply(HttpReply::BadRequest, exitActionsVerification.second);
QString name = params.value("name", QString()).toString();
bool enabled = params.value("enabled", true).toBool();
bool executable = params.value("executable", true).toBool();
RuleId newRuleId = RuleId::createRuleId();
RuleEngine::RuleError status = GuhCore::instance()->ruleEngine()->addRule(newRuleId, name, eventDescriptorList, stateEvaluator, actions, exitActions, enabled, executable);
if (status == RuleEngine::RuleErrorNoError) { if (status == RuleEngine::RuleErrorNoError) {
QVariant returns = JsonTypes::packRule(GuhCore::instance()->ruleEngine()->findRule(newRuleId)); QVariant returns = JsonTypes::packRule(GuhCore::instance()->ruleEngine()->findRule(rule.id()));
HttpReply *reply = createSuccessReply(); HttpReply *reply = createSuccessReply();
reply->setHeader(HttpReply::ContentTypeHeader, "application/json; charset=\"utf-8\";"); reply->setHeader(HttpReply::ContentTypeHeader, "application/json; charset=\"utf-8\";");
reply->setPayload(QJsonDocument::fromVariant(returns).toJson()); reply->setPayload(QJsonDocument::fromVariant(returns).toJson());
@ -297,7 +265,6 @@ HttpReply *RulesResource::enableRule(const RuleId &ruleId) const
qCDebug(dcRest) << "Enable rule with id" << ruleId.toString(); qCDebug(dcRest) << "Enable rule with id" << ruleId.toString();
RuleEngine::RuleError status = GuhCore::instance()->ruleEngine()->enableRule(ruleId); RuleEngine::RuleError status = GuhCore::instance()->ruleEngine()->enableRule(ruleId);
if (status != RuleEngine::RuleErrorNoError) if (status != RuleEngine::RuleErrorNoError)
return createRuleErrorReply(HttpReply::InternalServerError, status); return createRuleErrorReply(HttpReply::InternalServerError, status);
@ -309,7 +276,6 @@ HttpReply *RulesResource::disableRule(const RuleId &ruleId) const
qCDebug(dcRest) << "Disable rule with id" << ruleId.toString(); qCDebug(dcRest) << "Disable rule with id" << ruleId.toString();
RuleEngine::RuleError status = GuhCore::instance()->ruleEngine()->disableRule(ruleId); RuleEngine::RuleError status = GuhCore::instance()->ruleEngine()->disableRule(ruleId);
if (status != RuleEngine::RuleErrorNoError) if (status != RuleEngine::RuleErrorNoError)
return createRuleErrorReply(HttpReply::InternalServerError, status); return createRuleErrorReply(HttpReply::InternalServerError, status);
@ -321,7 +287,6 @@ HttpReply *RulesResource::executeActions(const RuleId &ruleId) const
qCDebug(dcRest) << "Execute actions of rule with id" << ruleId.toString(); qCDebug(dcRest) << "Execute actions of rule with id" << ruleId.toString();
RuleEngine::RuleError status = GuhCore::instance()->ruleEngine()->executeActions(ruleId); RuleEngine::RuleError status = GuhCore::instance()->ruleEngine()->executeActions(ruleId);
if (status != RuleEngine::RuleErrorNoError) if (status != RuleEngine::RuleErrorNoError)
return createRuleErrorReply(HttpReply::InternalServerError, status); return createRuleErrorReply(HttpReply::InternalServerError, status);
@ -333,7 +298,6 @@ HttpReply *RulesResource::executeExitActions(const RuleId &ruleId) const
qCDebug(dcRest) << "Execute exit actions of rule with id" << ruleId.toString(); qCDebug(dcRest) << "Execute exit actions of rule with id" << ruleId.toString();
RuleEngine::RuleError status = GuhCore::instance()->ruleEngine()->executeExitActions(ruleId); RuleEngine::RuleError status = GuhCore::instance()->ruleEngine()->executeExitActions(ruleId);
if (status != RuleEngine::RuleErrorNoError) if (status != RuleEngine::RuleErrorNoError)
return createRuleErrorReply(HttpReply::InternalServerError, status); return createRuleErrorReply(HttpReply::InternalServerError, status);
@ -349,41 +313,9 @@ HttpReply *RulesResource::editRule(const RuleId &ruleId, const QByteArray &paylo
return createErrorReply(HttpReply::BadRequest); return createErrorReply(HttpReply::BadRequest);
QVariantMap params = verification.second.toMap(); QVariantMap params = verification.second.toMap();
Rule rule = JsonTypes::unpackRule(params);
// check rule consistency RuleEngine::RuleError status = GuhCore::instance()->ruleEngine()->editRule(rule);
RuleEngine::RuleError ruleConsistencyError = JsonTypes::verifyRuleConsistency(params);
if (ruleConsistencyError != RuleEngine::RuleErrorNoError)
return createRuleErrorReply(HttpReply::BadRequest, ruleConsistencyError);
// Check and upack eventDescriptorList
QPair<QList<EventDescriptor>, RuleEngine::RuleError> eventDescriptorVerification = JsonTypes::verifyEventDescriptors(params);
QList<EventDescriptor> eventDescriptorList = eventDescriptorVerification.first;
if (eventDescriptorVerification.second != RuleEngine::RuleErrorNoError)
return createRuleErrorReply(HttpReply::BadRequest, eventDescriptorVerification.second);
// Check and unpack stateEvaluator
qCDebug(dcRest) << "unpacking stateEvaluator:" << params.value("stateEvaluator").toMap();
StateEvaluator stateEvaluator = JsonTypes::unpackStateEvaluator(params.value("stateEvaluator").toMap());
if (!stateEvaluator.isValid())
return createRuleErrorReply(HttpReply::BadRequest, RuleEngine::RuleErrorInvalidStateEvaluatorValue);
// Check and unpack actions
QPair<QList<RuleAction>, RuleEngine::RuleError> actionsVerification = JsonTypes::verifyActions(params, eventDescriptorList);
QList<RuleAction> actions = actionsVerification.first;
if (actionsVerification.second != RuleEngine::RuleErrorNoError)
return createRuleErrorReply(HttpReply::BadRequest, actionsVerification.second);
// Check and unpack exitActions
QPair<QList<RuleAction>, RuleEngine::RuleError> exitActionsVerification = JsonTypes::verifyExitActions(params);
QList<RuleAction> exitActions = exitActionsVerification.first;
if (exitActionsVerification.second != RuleEngine::RuleErrorNoError)
return createRuleErrorReply(HttpReply::BadRequest, exitActionsVerification.second);
QString name = params.value("name", QString()).toString();
bool enabled = params.value("enabled", true).toBool();
RuleEngine::RuleError status = GuhCore::instance()->ruleEngine()->editRule(ruleId, name, eventDescriptorList, stateEvaluator, actions, exitActions, enabled);
if (status == RuleEngine::RuleErrorNoError) { if (status == RuleEngine::RuleErrorNoError) {
qCDebug(dcRest) << "Edit rule successfully finished"; qCDebug(dcRest) << "Edit rule successfully finished";
return createRuleErrorReply(HttpReply::Ok, status); return createRuleErrorReply(HttpReply::Ok, status);

153
server/rule.cpp
View File

@ -33,6 +33,7 @@
*/ */
#include "rule.h" #include "rule.h"
#include "loggingcategories.h"
#include <QDebug> #include <QDebug>
@ -40,17 +41,13 @@ namespace guhserver {
/*! Constructs an empty, invalid rule. */ /*! Constructs an empty, invalid rule. */
Rule::Rule(): Rule::Rule():
Rule(RuleId(), QString(), QList<EventDescriptor>(), StateEvaluator(), QList<RuleAction>(), QList<RuleAction>()) m_id(RuleId()),
{ m_name(QString()),
} m_timeDescriptor(TimeDescriptor()),
m_stateEvaluator(StateEvaluator()),
/*! Constructs a Rule with the given \a id, \a name, \a eventDescriptorList, \a stateEvaluator and \a actions.*/ m_eventDescriptors(QList<EventDescriptor>()),
Rule::Rule(const RuleId &id, const QString &name, const QList<EventDescriptor> &eventDescriptorList, const StateEvaluator &stateEvaluator, const QList<RuleAction> &actions) : m_actions(QList<RuleAction>()),
m_id(id), m_exitActions(QList<RuleAction>()),
m_name(name),
m_eventDescriptors(eventDescriptorList),
m_stateEvaluator(stateEvaluator),
m_actions(actions),
m_enabled(false), m_enabled(false),
m_active(false), m_active(false),
m_executable(false) m_executable(false)
@ -58,45 +55,43 @@ Rule::Rule(const RuleId &id, const QString &name, const QList<EventDescriptor> &
} }
/*! Constructs a Rule with the given \a id, \a name, \a eventDescriptorList, \a stateEvaluator, \a actions and \a exitActions.*/ /*! Returns the id of this Rule. */
Rule::Rule(const RuleId &id, const QString &name, const QList<EventDescriptor> &eventDescriptorList, const StateEvaluator &stateEvaluator, const QList<RuleAction> &actions, const QList<RuleAction> &exitActions):
m_id(id),
m_name(name),
m_eventDescriptors(eventDescriptorList),
m_stateEvaluator(stateEvaluator),
m_actions(actions),
m_exitActions(exitActions),
m_enabled(false),
m_active(false),
m_executable(false)
{
}
/*! Constructs a Rule with the given \a id, \a name, \a stateEvaluator, \a actions and \a exitActions. This type of rule
* works only state based and executes the \a actions once the rule enters the active state and executes the \a exitActions
* once the rule exits the active state.*/
Rule::Rule(const RuleId &id, const QString &name, const StateEvaluator &stateEvaluator, const QList<RuleAction> &actions, const QList<RuleAction> &exitActions) :
m_id(id),
m_name(name),
m_stateEvaluator(stateEvaluator),
m_actions(actions),
m_exitActions(exitActions),
m_enabled(false),
m_active(false),
m_executable(false)
{
}
/*! Returns the id or the Rule. */
RuleId Rule::id() const RuleId Rule::id() const
{ {
return m_id; return m_id;
} }
/*! Returns the \l{EventDescriptor} for this Rule.*/ void Rule::setId(const RuleId &ruleId)
QList<EventDescriptor> Rule::eventDescriptors() const
{ {
return m_eventDescriptors; m_id = ruleId;
}
/*! Returns the name of this rule. */
QString Rule::name() const
{
return m_name;
}
void Rule::setName(const QString &name)
{
m_name = name;
}
/*! Returns true if the rule is active. */
bool Rule::active() const
{
return m_active;
}
/*! Returns the \l{TimeDescriptor} or this Rule. */
TimeDescriptor Rule::timeDescriptor() const
{
return m_timeDescriptor;
}
void Rule::setTimeDescriptor(const TimeDescriptor &timeDescriptor)
{
m_timeDescriptor = timeDescriptor;
} }
/*! Returns the StateEvaluator that needs to evaluate successfully in order for this to Rule apply. */ /*! Returns the StateEvaluator that needs to evaluate successfully in order for this to Rule apply. */
@ -105,22 +100,42 @@ StateEvaluator Rule::stateEvaluator() const
return m_stateEvaluator; return m_stateEvaluator;
} }
void Rule::setStateEvaluator(const StateEvaluator &stateEvaluator)
{
m_stateEvaluator = stateEvaluator;
}
/*! Returns the \l{EventDescriptor} for this Rule.*/
QList<EventDescriptor> Rule::eventDescriptors() const
{
return m_eventDescriptors;
}
void Rule::setEventDescriptors(const QList<EventDescriptor> &eventDescriptors)
{
m_eventDescriptors = eventDescriptors;
}
/*! Returns the \l{RuleAction}{RuleActions} to be executed when this Rule is matched and states match. */ /*! Returns the \l{RuleAction}{RuleActions} to be executed when this Rule is matched and states match. */
QList<RuleAction> Rule::actions() const QList<RuleAction> Rule::actions() const
{ {
return m_actions; return m_actions;
} }
void Rule::setActions(const QList<RuleAction> actions)
{
m_actions = actions;
}
/*! Returns the \l{RuleAction}{RuleActions} to be executed when this Rule leaves the active state. */ /*! Returns the \l{RuleAction}{RuleActions} to be executed when this Rule leaves the active state. */
QList<RuleAction> Rule::exitActions() const QList<RuleAction> Rule::exitActions() const
{ {
return m_exitActions; return m_exitActions;
} }
/*! Returns the name of this rule. */ void Rule::setExitActions(const QList<RuleAction> exitActions)
QString Rule::name() const
{ {
return m_name; m_exitActions = exitActions;
} }
/*! Returns true if the rule is enabled. */ /*! Returns true if the rule is enabled. */
@ -130,35 +145,47 @@ bool Rule::enabled() const {
/*! Set the \a enabled flag of this rule. In order to actually enable/disable the rule you still need to /*! Set the \a enabled flag of this rule. In order to actually enable/disable the rule you still need to
* update the \l{RuleEngine} */ * update the \l{RuleEngine} */
void Rule::setEnabled(bool enabled) void Rule::setEnabled(const bool &enabled)
{ {
m_enabled = enabled; m_enabled = enabled;
} }
/*! Returns true if the rule is active. */
bool Rule::active() const
{
return m_active;
}
/*! Set the rule \a executable. */
void Rule::setExecutable(const bool &executable)
{
m_executable = executable;
}
/*! Returns true if the rule is executable. */ /*! Returns true if the rule is executable. */
bool Rule::executable() const bool Rule::executable() const
{ {
return m_executable; return m_executable;
} }
void Rule::setName(const QString &name) /*! Set the rule \a executable. */
void Rule::setExecutable(const bool &executable)
{ {
m_name = name; m_executable = executable;
} }
void Rule::setActive(bool active) bool Rule::isValid() const
{
return !m_id.isNull();
}
bool Rule::isConsistent() const
{
// check if this rules is based on any event and contains exit actions
if (!eventDescriptors().isEmpty() && !exitActions().isEmpty()) {
qCWarning(dcRuleEngine) << "Rule not consistent. The exitActions will never be executed if the rule contains an eventDescriptor.";
return false;
}
// check if there are any actions
if (actions().isEmpty()) {
qCWarning(dcRuleEngine) << "Rule not consistent. A rule without actions has no effect.";
return false;
}
return true;
}
void Rule::setActive(const bool &active)
{ {
m_active = active; m_active = active;
} }

42
server/rule.h
View File

@ -26,6 +26,7 @@
#include "types/ruleaction.h" #include "types/ruleaction.h"
#include "types/eventdescriptor.h" #include "types/eventdescriptor.h"
#include "stateevaluator.h" #include "stateevaluator.h"
#include "time/timedescriptor.h"
#include <QUuid> #include <QUuid>
@ -35,35 +36,50 @@ class Rule
{ {
public: public:
Rule(); Rule();
Rule(const RuleId &id, const QString &name, const QList<EventDescriptor> &eventDescriptorList, const StateEvaluator &stateEvaluator, const QList<RuleAction> &actions);
Rule(const RuleId &id, const QString &name, const QList<EventDescriptor> &eventDescriptorList, const StateEvaluator &stateEvaluator, const QList<RuleAction> &actions, const QList<RuleAction> &exitActions);
Rule(const RuleId &id, const QString &name, const StateEvaluator &stateEvaluator, const QList<RuleAction> &actions, const QList<RuleAction> &exitActions);
RuleId id() const; RuleId id() const;
QList<EventDescriptor> eventDescriptors() const; void setId(const RuleId &ruleId);
StateEvaluator stateEvaluator() const;
QList<RuleAction> actions() const;
QList<RuleAction> exitActions() const;
QString name() const; QString name() const;
bool enabled() const; void setName(const QString &name);
void setEnabled(bool enabled);
bool active() const; bool active() const;
void setExecutable(const bool &executable); TimeDescriptor timeDescriptor() const;
void setTimeDescriptor(const TimeDescriptor &timeDescriptor);
StateEvaluator stateEvaluator() const;
void setStateEvaluator(const StateEvaluator &stateEvaluator);
QList<EventDescriptor> eventDescriptors() const;
void setEventDescriptors(const QList<EventDescriptor> &eventDescriptors);
QList<RuleAction> actions() const;
void setActions(const QList<RuleAction> actions);
QList<RuleAction> exitActions() const;
void setExitActions(const QList<RuleAction> exitActions);
bool enabled() const;
void setEnabled(const bool &enabled);
bool executable() const; bool executable() const;
void setExecutable(const bool &executable);
// verification methods
bool isValid() const;
bool isConsistent() const;
private: private:
friend class RuleEngine; friend class RuleEngine;
void setName(const QString &name); void setActive(const bool &active);
void setActive(bool active);
private: private:
RuleId m_id; RuleId m_id;
QString m_name; QString m_name;
QList<EventDescriptor> m_eventDescriptors; TimeDescriptor m_timeDescriptor;
StateEvaluator m_stateEvaluator; StateEvaluator m_stateEvaluator;
QList<EventDescriptor> m_eventDescriptors;
QList<RuleAction> m_actions; QList<RuleAction> m_actions;
QList<RuleAction> m_exitActions; QList<RuleAction> m_exitActions;

219
server/ruleengine.cpp
View File

@ -205,7 +205,13 @@ RuleEngine::RuleEngine(QObject *parent) :
} }
settings.endGroup(); settings.endGroup();
Rule rule = Rule(RuleId(idString), name, eventDescriptorList, stateEvaluator, actions, exitActions); Rule rule;
rule.setId(RuleId(idString));
rule.setName(name);
rule.setEventDescriptors(eventDescriptorList);
rule.setStateEvaluator(stateEvaluator);
rule.setActions(actions);
rule.setExitActions(exitActions);
rule.setEnabled(enabled); rule.setEnabled(enabled);
rule.setExecutable(executable); rule.setExecutable(executable);
appendRule(rule); appendRule(rule);
@ -272,35 +278,40 @@ QList<Rule> RuleEngine::evaluateEvent(const Event &event)
return rules; return rules;
} }
/*! Add a new \l{Rule} with the given \a ruleId , \a name, \a eventDescriptorList, \a actions and \a enabled value to the engine. QList<Rule> RuleEngine::evaluateTime(const QDateTime &dateTime)
For convenience, this creates a Rule without any \l{State} comparison.
*/
RuleEngine::RuleError RuleEngine::addRule(const RuleId &ruleId, const QString &name, const QList<EventDescriptor> &eventDescriptorList, const QList<RuleAction> &actions, bool enabled)
{ {
return addRule(ruleId, name, eventDescriptorList, StateEvaluator(), actions, QList<RuleAction>(), enabled); Q_UNUSED(dateTime)
QList<Rule> rules;
return rules;
} }
/*! Add a new \l{Rule} with the given \a ruleId, \a name, \a eventDescriptorList, \a stateEvaluator, the list of \a actions, the list of \a exitActions, the \a enabled and the \a executable value to the engine. RuleEngine::RuleError RuleEngine::addRule(const Rule &rule, bool fromEdit)
If \a fromEdit is true, the notification Rules. RuleAdded will not be emitted.
*/
RuleEngine::RuleError RuleEngine::addRule(const RuleId &ruleId, const QString &name, const QList<EventDescriptor> &eventDescriptorList, const StateEvaluator &stateEvaluator, const QList<RuleAction> &actions, const QList<RuleAction> &exitActions, bool enabled, bool executable, bool fromEdit)
{ {
if (ruleId.isNull()) if (rule.id().isNull())
return RuleErrorInvalidRuleId; return RuleErrorInvalidRuleId;
if (!findRule(ruleId).id().isNull()) { if (!findRule(rule.id()).id().isNull()) {
qCWarning(dcRuleEngine) << "Already have a rule with this id!"; qCWarning(dcRuleEngine) << "Already have a rule with this id.";
return RuleErrorInvalidRuleId; return RuleErrorInvalidRuleId;
} }
foreach (const EventDescriptor &eventDescriptor, eventDescriptorList) { if (!rule.isConsistent()) {
qCWarning(dcRuleEngine) << "Rule inconsistent.";
return RuleErrorInvalidRuleFormat;
}
// Check IDs in each EventDescriptor
foreach (const EventDescriptor &eventDescriptor, rule.eventDescriptors()) {
// check deviceId
Device *device = GuhCore::instance()->deviceManager()->findConfiguredDevice(eventDescriptor.deviceId()); Device *device = GuhCore::instance()->deviceManager()->findConfiguredDevice(eventDescriptor.deviceId());
if (!device) { if (!device) {
qCWarning(dcRuleEngine) << "Cannot create rule. No configured device for eventTypeId" << eventDescriptor.eventTypeId(); qCWarning(dcRuleEngine) << "Cannot create rule. No configured device for eventTypeId" << eventDescriptor.eventTypeId();
return RuleErrorDeviceNotFound; return RuleErrorDeviceNotFound;
} }
DeviceClass deviceClass = GuhCore::instance()->deviceManager()->findDeviceClass(device->deviceClassId());
// Check eventTypeId for this deivce
DeviceClass deviceClass = GuhCore::instance()->deviceManager()->findDeviceClass(device->deviceClassId());
bool eventTypeFound = false; bool eventTypeFound = false;
foreach (const EventType &eventType, deviceClass.eventTypes()) { foreach (const EventType &eventType, deviceClass.eventTypes()) {
if (eventType.id() == eventDescriptor.eventTypeId()) { if (eventType.id() == eventDescriptor.eventTypeId()) {
@ -313,45 +324,84 @@ RuleEngine::RuleError RuleEngine::addRule(const RuleId &ruleId, const QString &n
} }
} }
// Check state evaluator
if (!rule.stateEvaluator().isValid()) {
qCWarning(dcRuleEngine) << "Got an invalid StateEvaluator.";
return RuleErrorInvalidStateEvaluatorValue;
}
// Check actions
foreach (const RuleAction &action, actions) { foreach (const RuleAction &action, rule.actions()) {
Device *device = GuhCore::instance()->deviceManager()->findConfiguredDevice(action.deviceId()); Device *device = GuhCore::instance()->deviceManager()->findConfiguredDevice(action.deviceId());
if (!device) { if (!device) {
qCWarning(dcRuleEngine) << "Cannot create rule. No configured device for actionTypeId" << action.actionTypeId(); qCWarning(dcRuleEngine) << "Cannot create rule. No configured device for action with actionTypeId" << action.actionTypeId();
return RuleErrorDeviceNotFound; return RuleErrorDeviceNotFound;
} }
DeviceClass deviceClass = GuhCore::instance()->deviceManager()->findDeviceClass(device->deviceClassId()); DeviceClass deviceClass = GuhCore::instance()->deviceManager()->findDeviceClass(device->deviceClassId());
if (!deviceClass.hasActionType(action.actionTypeId())) { if (!deviceClass.hasActionType(action.actionTypeId())) {
qCWarning(dcRuleEngine) << "Cannot create rule. Device " + device->name() + " has no action type:" << action.actionTypeId(); qCWarning(dcRuleEngine) << "Cannot create rule. Device " + device->name() + " has no action type:" << action.actionTypeId();
return RuleErrorActionTypeNotFound; return RuleErrorActionTypeNotFound;
} }
// if the action is eventbased, it is already checked // check possible eventTypeIds in params
if (!action.isEventBased()) { if (action.isEventBased()) {
foreach (const RuleActionParam &ruleActionParam, action.ruleActionParams()) {
if (ruleActionParam.eventTypeId() != EventTypeId()) {
// We have an eventTypeId
if (rule.eventDescriptors().isEmpty()) {
qCWarning(dcRuleEngine) << "Cannot create rule. RuleAction" << action.actionTypeId() << "contains an eventTypeId, but there are no eventDescriptors.";
return RuleErrorInvalidRuleActionParameter;
}
// now check if this eventType is in the eventDescriptorList of this rule
if (!checkEventDescriptors(rule.eventDescriptors(), ruleActionParam.eventTypeId())) {
qCWarning(dcRuleEngine) << "Cannot create rule. EventTypeId from RuleAction" << action.actionTypeId() << "not in eventDescriptors.";
return RuleErrorInvalidRuleActionParameter;
}
// check if the param type of the event and the action match
QVariant::Type eventParamType = getEventParamType(ruleActionParam.eventTypeId(), ruleActionParam.eventParamName());
QVariant::Type actionParamType = getActionParamType(action.actionTypeId(), ruleActionParam.name());
if (eventParamType != actionParamType) {
qCWarning(dcRuleEngine) << "Cannot create rule. RuleActionParam" << ruleActionParam.name() << " and given event param " << ruleActionParam.eventParamName() << "have not the same type:";
qCWarning(dcRuleEngine) << " -> actionParamType:" << actionParamType;
qCWarning(dcRuleEngine) << " -> eventParamType:" << eventParamType;
return RuleErrorTypesNotMatching;
}
}
}
} else {
// verify action params // verify action params
foreach (const ActionType &actionType, deviceClass.actionTypes()) { foreach (const ActionType &actionType, deviceClass.actionTypes()) {
if (actionType.id() == action.actionTypeId()) { if (actionType.id() == action.actionTypeId()) {
ParamList finalParams = action.toAction().params(); ParamList finalParams = action.toAction().params();
DeviceManager::DeviceError paramCheck = GuhCore::instance()->deviceManager()->verifyParams(actionType.paramTypes(), finalParams); DeviceManager::DeviceError paramCheck = GuhCore::instance()->deviceManager()->verifyParams(actionType.paramTypes(), finalParams);
if (paramCheck != DeviceManager::DeviceErrorNoError) if (paramCheck != DeviceManager::DeviceErrorNoError) {
qCWarning(dcRuleEngine) << "Cannot create rule. Got an invalid actionParam.";
return RuleErrorInvalidRuleActionParameter; return RuleErrorInvalidRuleActionParameter;
}
} }
} }
} }
foreach (const RuleActionParam &ruleActionParam, action.ruleActionParams()) {
if (!ruleActionParam.isValid()) {
qCWarning(dcRuleEngine) << "Cannot create rule. Got an actionParam with \"value\" AND \"eventTypeId\".";
return RuleEngine::RuleErrorInvalidRuleActionParameter;
}
}
} }
if (actions.count() > 0) // Check exit actions
qCDebug(dcRuleEngine) << "actions" << actions.last().actionTypeId() << actions.last().ruleActionParams(); foreach (const RuleAction &action, rule.exitActions()) {
foreach (const RuleAction &action, exitActions) {
Device *device = GuhCore::instance()->deviceManager()->findConfiguredDevice(action.deviceId()); Device *device = GuhCore::instance()->deviceManager()->findConfiguredDevice(action.deviceId());
if (!device) { if (!device) {
qCWarning(dcRuleEngine) << "Cannot create rule. No configured device for actionTypeId" << action.actionTypeId(); qCWarning(dcRuleEngine) << "Cannot create rule. No configured device for exit action with actionTypeId" << action.actionTypeId();
return RuleErrorDeviceNotFound; return RuleErrorDeviceNotFound;
} }
DeviceClass deviceClass = GuhCore::instance()->deviceManager()->findDeviceClass(device->deviceClassId());
DeviceClass deviceClass = GuhCore::instance()->deviceManager()->findDeviceClass(device->deviceClassId());
if (!deviceClass.hasActionType(action.actionTypeId())) { if (!deviceClass.hasActionType(action.actionTypeId())) {
qCWarning(dcRuleEngine) << "Cannot create rule. Device " + device->name() + " has no action type:" << action.actionTypeId(); qCWarning(dcRuleEngine) << "Cannot create rule. Device " + device->name() + " has no action type:" << action.actionTypeId();
return RuleErrorActionTypeNotFound; return RuleErrorActionTypeNotFound;
@ -362,60 +412,67 @@ RuleEngine::RuleError RuleEngine::addRule(const RuleId &ruleId, const QString &n
if (actionType.id() == action.actionTypeId()) { if (actionType.id() == action.actionTypeId()) {
ParamList finalParams = action.toAction().params(); ParamList finalParams = action.toAction().params();
DeviceManager::DeviceError paramCheck = GuhCore::instance()->deviceManager()->verifyParams(actionType.paramTypes(), finalParams); DeviceManager::DeviceError paramCheck = GuhCore::instance()->deviceManager()->verifyParams(actionType.paramTypes(), finalParams);
if (paramCheck != DeviceManager::DeviceErrorNoError) if (paramCheck != DeviceManager::DeviceErrorNoError) {
qCWarning(dcRuleEngine) << "Cannot create rule. Got an invalid exit actionParam.";
return RuleErrorInvalidRuleActionParameter; return RuleErrorInvalidRuleActionParameter;
}
}
}
// Exit action can never be event based.
if (action.isEventBased()) {
qCWarning(dcRuleEngine) << "Cannot create rule. Got exitAction with an actionParam containing an eventTypeId. ";
return RuleErrorInvalidRuleActionParameter;
}
foreach (const RuleActionParam &ruleActionParam, action.ruleActionParams()) {
if (!ruleActionParam.isValid()) {
qCWarning(dcRuleEngine) << "Cannot create rule. Got an actionParam with \"value\" AND \"eventTypeId\".";
return RuleEngine::RuleErrorInvalidRuleActionParameter;
} }
} }
} }
if (exitActions.count() > 0)
qCDebug(dcRuleEngine) << "exit actions" << exitActions.last().actionTypeId() << exitActions.last().ruleActionParams();
Rule rule = Rule(ruleId, name, eventDescriptorList, stateEvaluator, actions, exitActions);
rule.setEnabled(enabled);
rule.setExecutable(executable);
appendRule(rule); appendRule(rule);
saveRule(rule); saveRule(rule);
if (!fromEdit) if (!fromEdit)
emit ruleAdded(rule); emit ruleAdded(rule);
return RuleErrorNoError; return RuleErrorNoError;
} }
/*! Edit a \l{Rule} with the given \a ruleId, \a name, \a eventDescriptorList, \a stateEvaluator, RuleEngine::RuleError RuleEngine::editRule(const Rule &rule)
the list of \a actions, the list of \a exitActions, the \a enabled and the \a executable in the engine.
*/
RuleEngine::RuleError RuleEngine::editRule(const RuleId &ruleId, const QString &name, const QList<EventDescriptor> &eventDescriptorList, const StateEvaluator &stateEvaluator, const QList<RuleAction> &actions, const QList<RuleAction> &exitActions, bool enabled, bool executable)
{ {
if (ruleId.isNull()) if (rule.id().isNull())
return RuleErrorInvalidRuleId; return RuleErrorInvalidRuleId;
// Store rule in case the add new rule fails // Store rule in case the add new rule fails
Rule rule = findRule(ruleId); Rule oldRule = findRule(rule.id());
if (oldRule.id().isNull()) {
if (rule.id().isNull()) { qCWarning(dcRuleEngine) << "Cannot edit rule. There is no rule with id:" << rule.id().toString();
qCWarning(dcRuleEngine) << "Cannot edit rule. There is no rule with id:" << ruleId.toString();
return RuleErrorRuleNotFound; return RuleErrorRuleNotFound;
} }
// First remove old rule with this id // First remove old rule with this id
RuleError removeResult = removeRule(ruleId, true); RuleError removeResult = removeRule(oldRule.id(), true);
if (removeResult != RuleErrorNoError) { if (removeResult != RuleErrorNoError) {
qCWarning(dcRuleEngine) << "Cannot edit rule. Could not remove the old rule.";
// no need to restore, rule is still in system // no need to restore, rule is still in system
return removeResult; return removeResult;
} }
// The rule is removed, now add it with the same id and new vonfiguration // The rule is removed, now add the new one
RuleError addResult = addRule(ruleId, name, eventDescriptorList, stateEvaluator, actions, exitActions, enabled, executable, true); RuleError addResult = addRule(rule);
if (addResult != RuleErrorNoError) { if (addResult != RuleErrorNoError) {
// restore rule qCWarning(dcRuleEngine) << "Cannot edit rule. Could not add the new rule. Restoring the old rule.";
appendRule(rule); // restore old rule
appendRule(oldRule);
return addResult; return addResult;
} }
emit ruleConfigurationChanged(m_rules.value(ruleId)); // Successfully changed the rule
emit ruleConfigurationChanged(rule);
return RuleErrorNoError; return RuleErrorNoError;
} }
@ -449,6 +506,7 @@ RuleEngine::RuleError RuleEngine::removeRule(const RuleId &ruleId, bool fromEdit
m_ruleIds.takeAt(index); m_ruleIds.takeAt(index);
m_rules.remove(ruleId); m_rules.remove(ruleId);
m_activeRules.removeAll(ruleId);
GuhSettings settings(GuhSettings::SettingsRoleRules); GuhSettings settings(GuhSettings::SettingsRoleRules);
settings.beginGroup(ruleId.toString()); settings.beginGroup(ruleId.toString());
@ -568,12 +626,10 @@ RuleEngine::RuleError RuleEngine::executeExitActions(const RuleId &ruleId)
/*! Returns the \l{Rule} with the given \a ruleId. If the \l{Rule} does not exist, it will return \l{Rule::Rule()} */ /*! Returns the \l{Rule} with the given \a ruleId. If the \l{Rule} does not exist, it will return \l{Rule::Rule()} */
Rule RuleEngine::findRule(const RuleId &ruleId) Rule RuleEngine::findRule(const RuleId &ruleId)
{ {
foreach (const Rule &rule, m_rules) { if (!m_rules.contains(ruleId))
if (rule.id() == ruleId) { return Rule();
return rule;
} return m_rules.value(ruleId);
}
return Rule();
} }
/*! Returns a list of all \l{Rule}{Rules} loaded in this Engine, which contains a \l{Device} with the given \a deviceId. */ /*! Returns a list of all \l{Rule}{Rules} loaded in this Engine, which contains a \l{Device} with the given \a deviceId. */
@ -670,7 +726,12 @@ void RuleEngine::removeDeviceFromRule(const RuleId &id, const DeviceId &deviceId
settings.remove(""); settings.remove("");
settings.endGroup(); settings.endGroup();
Rule newRule(id, rule.name(), eventDescriptors, stateEvalatuator, actions); Rule newRule;
newRule.setId(id);
newRule.setName(rule.name());
newRule.setEventDescriptors(eventDescriptors);
newRule.setStateEvaluator(stateEvalatuator);
newRule.setActions(actions);
m_rules[id] = newRule; m_rules[id] = newRule;
// save it // save it
@ -702,6 +763,48 @@ bool RuleEngine::containsState(const StateEvaluator &stateEvaluator, const Event
return false; return false;
} }
bool RuleEngine::checkEventDescriptors(const QList<EventDescriptor> eventDescriptors, const EventTypeId &eventTypeId)
{
foreach (const EventDescriptor eventDescriptor, eventDescriptors) {
if (eventDescriptor.eventTypeId() == eventTypeId) {
return true;
}
}
return false;
}
QVariant::Type RuleEngine::getActionParamType(const ActionTypeId &actionTypeId, const QString &paramName)
{
foreach (const DeviceClass &deviceClass, GuhCore::instance()->deviceManager()->supportedDevices()) {
foreach (const ActionType &actionType, deviceClass.actionTypes()) {
if (actionType.id() == actionTypeId) {
foreach (const ParamType &paramType, actionType.paramTypes()) {
if (paramType.name() == paramName) {
return paramType.type();
}
}
}
}
}
return QVariant::Invalid;
}
QVariant::Type RuleEngine::getEventParamType(const EventTypeId &eventTypeId, const QString &paramName)
{
foreach (const DeviceClass &deviceClass, GuhCore::instance()->deviceManager()->supportedDevices()) {
foreach (const EventType &eventType, deviceClass.eventTypes()) {
if (eventType.id() == eventTypeId) {
foreach (const ParamType &paramType, eventType.paramTypes()) {
if (paramType.name() == paramName) {
return paramType.type();
}
}
}
}
}
return QVariant::Invalid;
}
void RuleEngine::appendRule(const Rule &rule) void RuleEngine::appendRule(const Rule &rule)
{ {
m_rules.insert(rule.id(), rule); m_rules.insert(rule.id(), rule);

14
server/ruleengine.h
View File

@ -67,10 +67,14 @@ public:
~RuleEngine(); ~RuleEngine();
QList<Rule> evaluateEvent(const Event &event); QList<Rule> evaluateEvent(const Event &event);
QList<Rule> evaluateTime(const QDateTime &dateTime);
RuleError addRule(const RuleId &ruleId, const QString &name, const QList<EventDescriptor> &eventDescriptorList, const QList<RuleAction> &actions, bool enabled = true); RuleError addRule(const Rule &rule, bool fromEdit = false);
RuleError addRule(const RuleId &ruleId, const QString &name, const QList<EventDescriptor> &eventDescriptorList, const StateEvaluator &stateEvaluator, const QList<RuleAction> &actions, const QList<RuleAction> &exitActions, bool enabled = true, bool executable = true, bool fromEdit = false); // RuleError addRule(const RuleId &ruleId, const QString &name, const QList<EventDescriptor> &eventDescriptorList, const QList<RuleAction> &actions, bool enabled = true);
RuleError editRule(const RuleId &ruleId, const QString &name, const QList<EventDescriptor> &eventDescriptorList, const StateEvaluator &stateEvaluator, const QList<RuleAction> &actions, const QList<RuleAction> &exitActions, bool enabled = true, bool executable = true); // RuleError addRule(const RuleId &ruleId, const QString &name, const QList<EventDescriptor> &eventDescriptorList, const StateEvaluator &stateEvaluator, const QList<RuleAction> &actions, const QList<RuleAction> &exitActions, bool enabled = true, bool executable = true, bool fromEdit = false);
RuleError editRule(const Rule &rule);
// RuleError editRule(const RuleId &ruleId, const QString &name, const QList<EventDescriptor> &eventDescriptorList, const StateEvaluator &stateEvaluator, const QList<RuleAction> &actions, const QList<RuleAction> &exitActions, bool enabled = true, bool executable = true);
QList<Rule> rules() const; QList<Rule> rules() const;
QList<RuleId> ruleIds() const; QList<RuleId> ruleIds() const;
@ -97,6 +101,10 @@ private:
bool containsEvent(const Rule &rule, const Event &event); bool containsEvent(const Rule &rule, const Event &event);
bool containsState(const StateEvaluator &stateEvaluator, const Event &stateChangeEvent); bool containsState(const StateEvaluator &stateEvaluator, const Event &stateChangeEvent);
bool checkEventDescriptors(const QList<EventDescriptor> eventDescriptors, const EventTypeId &eventTypeId);
QVariant::Type getActionParamType(const ActionTypeId &actionTypeId, const QString &paramName);
QVariant::Type getEventParamType(const EventTypeId &eventTypeId, const QString &paramName);
void appendRule(const Rule &rule); void appendRule(const Rule &rule);
void saveRule(const Rule &rule); void saveRule(const Rule &rule);

2
server/servermanager.h
View File

@ -50,9 +50,7 @@ private:
QSslKey m_certificateKey; QSslKey m_certificateKey;
QSslCertificate m_certificate; QSslCertificate m_certificate;
bool loadCertificate(const QString &certificateKeyFileName, const QString &certificateFileName); bool loadCertificate(const QString &certificateKeyFileName, const QString &certificateFileName);
}; };
} }

8
server/time/timemanager.cpp
View File

@ -100,6 +100,14 @@ QDate TimeManager::currentDate() const
return QDateTime::currentDateTimeUtc().toTimeZone(m_timeZone).date(); return QDateTime::currentDateTimeUtc().toTimeZone(m_timeZone).date();
} }
#ifdef TESTING_ENABLED
void TimeManager::stopTimer()
{
// Stop clock (used for testing)
m_guhTimer->stop();
}
#endif
void TimeManager::guhTimeout() void TimeManager::guhTimeout()
{ {
// tick for deviceManager // tick for deviceManager

4
server/time/timemanager.h
View File

@ -41,6 +41,10 @@ public:
QTime currentTime() const; QTime currentTime() const;
QDate currentDate() const; QDate currentDate() const;
#ifdef TESTING_ENABLED
void stopTimer();
#endif
private: private:
QTimeZone m_timeZone; QTimeZone m_timeZone;
QDateTime m_dateTime; QDateTime m_dateTime;

23
tests/auto/restrules/testrestrules.cpp
View File

@ -220,7 +220,7 @@ void TestRestRules::findRule()
RuleId ruleId = RuleId(response.toMap().value("id").toString()); RuleId ruleId = RuleId(response.toMap().value("id").toString());
QVERIFY(!ruleId.isNull()); QVERIFY(!ruleId.isNull());
QUrl url(QString("http://localhost:3333/api/v1/rules/%1").arg(ruleId.toString())); QUrl url(QString("http://localhost:3333/api/v1/rules"));
QUrlQuery query; QUrlQuery query;
query.addQueryItem("deviceId", m_mockDeviceId.toString()); query.addQueryItem("deviceId", m_mockDeviceId.toString());
url.setQuery(query); url.setQuery(query);
@ -462,7 +462,6 @@ void TestRestRules::addRemoveRules_data()
QTest::newRow("valid rule. enabled, 1 EventDescriptor, StateEvaluator, 1 Action, name") << true << validActionNoParams << QVariantMap() << validEventDescriptor1 << QVariantList() << validStateEvaluator << 200 << true << "TestRule"; QTest::newRow("valid rule. enabled, 1 EventDescriptor, StateEvaluator, 1 Action, name") << true << validActionNoParams << QVariantMap() << validEventDescriptor1 << QVariantList() << validStateEvaluator << 200 << true << "TestRule";
QTest::newRow("valid rule. diabled, 1 EventDescriptor, StateEvaluator, 1 Action, name") << false << validActionNoParams << QVariantMap() << validEventDescriptor1 << QVariantList() << validStateEvaluator << 200 << true << "TestRule"; QTest::newRow("valid rule. diabled, 1 EventDescriptor, StateEvaluator, 1 Action, name") << false << validActionNoParams << QVariantMap() << validEventDescriptor1 << QVariantList() << validStateEvaluator << 200 << true << "TestRule";
QTest::newRow("valid rule. 2 EventDescriptors, 1 Action, name") << true << validActionNoParams << QVariantMap() << QVariantMap() << eventDescriptorList << validStateEvaluator << 200 << true << "TestRule"; QTest::newRow("valid rule. 2 EventDescriptors, 1 Action, name") << true << validActionNoParams << QVariantMap() << QVariantMap() << eventDescriptorList << validStateEvaluator << 200 << true << "TestRule";
QTest::newRow("invalid rule: eventDescriptor and eventDescriptorList used") << true << validActionNoParams << QVariantMap() << validEventDescriptor1 << eventDescriptorList << validStateEvaluator << 400 << false << "TestRule";
QTest::newRow("invalid action") << true << invalidAction << QVariantMap() << validEventDescriptor1 << QVariantList() << validStateEvaluator << 400 << false << "TestRule"; QTest::newRow("invalid action") << true << invalidAction << QVariantMap() << validEventDescriptor1 << QVariantList() << validStateEvaluator << 400 << false << "TestRule";
QTest::newRow("invalid event descriptor") << true << validActionNoParams << QVariantMap() << invalidEventDescriptor << QVariantList() << validStateEvaluator << 400 << false << "TestRule"; QTest::newRow("invalid event descriptor") << true << validActionNoParams << QVariantMap() << invalidEventDescriptor << QVariantList() << validStateEvaluator << 400 << false << "TestRule";
} }
@ -490,10 +489,10 @@ void TestRestRules::addRemoveRules()
params.insert("actions", actions); params.insert("actions", actions);
if (!eventDescriptor.isEmpty()) { if (!eventDescriptor.isEmpty()) {
params.insert("eventDescriptor", eventDescriptor); params.insert("eventDescriptors", QVariantList() << eventDescriptor);
} }
if (!eventDescriptorList.isEmpty()) { if (!eventDescriptorList.isEmpty()) {
params.insert("eventDescriptorList", eventDescriptorList); params.insert("eventDescriptors", eventDescriptorList);
} }
QVariantList exitActions; QVariantList exitActions;
@ -523,9 +522,11 @@ void TestRestRules::addRemoveRules()
RuleId ruleId = RuleId(response.toMap().value("id").toString()); RuleId ruleId = RuleId(response.toMap().value("id").toString());
QVERIFY(!ruleId.isNull()); QVERIFY(!ruleId.isNull());
qDebug() << QJsonDocument::fromVariant(response).toJson();
// GET rule details // GET rule details
request = QNetworkRequest(QUrl(QString("http://localhost:3333/api/v1/rules/%1").arg(ruleId.toString()))); request = QNetworkRequest(QUrl(QString("http://localhost:3333/api/v1/rules/%1").arg(ruleId.toString())));
request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json"); //request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json");
response = getAndWait(request); response = getAndWait(request);
QVERIFY(!response.isNull()); QVERIFY(!response.isNull());
@ -548,8 +549,7 @@ void TestRestRules::emptyRule()
request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json"); request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json");
QVariant response = postAndWait(request, params, 400); QVariant response = postAndWait(request, params, 400);
QCOMPARE(response.toMap().value("error").toString(), JsonTypes::ruleErrorToString(RuleEngine::RuleErrorMissingParameter)); QCOMPARE(response.toMap().value("error").toString(), JsonTypes::ruleErrorToString(RuleEngine::RuleErrorInvalidRuleFormat));
} }
void TestRestRules::editRules_data() void TestRestRules::editRules_data()
@ -694,7 +694,6 @@ void TestRestRules::editRules_data()
QTest::newRow("valid rule. enabled, 1 EventDescriptor, StateEvaluator, 1 Action, name") << true << validActionNoParams << QVariantMap() << validEventDescriptor1 << QVariantList() << validStateEvaluator << 200 << "TestRule"; QTest::newRow("valid rule. enabled, 1 EventDescriptor, StateEvaluator, 1 Action, name") << true << validActionNoParams << QVariantMap() << validEventDescriptor1 << QVariantList() << validStateEvaluator << 200 << "TestRule";
QTest::newRow("valid rule. diabled, 1 EventDescriptor, StateEvaluator, 1 Action, name") << false << validActionNoParams << QVariantMap() << validEventDescriptor1 << QVariantList() << validStateEvaluator << 200 << "TestRule"; QTest::newRow("valid rule. diabled, 1 EventDescriptor, StateEvaluator, 1 Action, name") << false << validActionNoParams << QVariantMap() << validEventDescriptor1 << QVariantList() << validStateEvaluator << 200 << "TestRule";
QTest::newRow("valid rule. 2 EventDescriptors, 1 Action, name") << true << validActionNoParams << QVariantMap() << QVariantMap() << eventDescriptorList << validStateEvaluator << 200 << "TestRule"; QTest::newRow("valid rule. 2 EventDescriptors, 1 Action, name") << true << validActionNoParams << QVariantMap() << QVariantMap() << eventDescriptorList << validStateEvaluator << 200 << "TestRule";
QTest::newRow("invalid rule: eventDescriptor and eventDescriptorList used") << true << validActionNoParams << QVariantMap() << validEventDescriptor1 << eventDescriptorList << validStateEvaluator << 400 << "TestRule";
} }
void TestRestRules::editRules() void TestRestRules::editRules()
@ -796,7 +795,7 @@ void TestRestRules::editRules()
actions.append(action1); actions.append(action1);
actions.append(action2); actions.append(action2);
params.insert("actions", actions); params.insert("actions", actions);
params.insert("eventDescriptorList", eventDescriptorList1); params.insert("eventDescriptors", eventDescriptorList1);
params.insert("stateEvaluator", stateEvaluator0); params.insert("stateEvaluator", stateEvaluator0);
params.insert("name", "TestRule"); params.insert("name", "TestRule");
@ -821,10 +820,10 @@ void TestRestRules::editRules()
params.insert("name", name); params.insert("name", name);
if (!eventDescriptor.isEmpty()) { if (!eventDescriptor.isEmpty()) {
params.insert("eventDescriptor", eventDescriptor); params.insert("eventDescriptors", QVariantList() << eventDescriptor);
} }
if (!eventDescriptorList.isEmpty()) { if (!eventDescriptorList.isEmpty()) {
params.insert("eventDescriptorList", eventDescriptorList); params.insert("eventDescriptors", eventDescriptorList);
} }
actions.clear(); actions.clear();
actions.append(action); actions.append(action);
@ -872,7 +871,7 @@ void TestRestRules::enableDisableRule()
event1.insert("eventTypeId", mockEvent1Id); event1.insert("eventTypeId", mockEvent1Id);
event1.insert("deviceId", m_mockDeviceId); event1.insert("deviceId", m_mockDeviceId);
events.append(event1); events.append(event1);
addRuleParams.insert("eventDescriptorList", events); addRuleParams.insert("eventDescriptors", events);
addRuleParams.insert("name", "TestRule"); addRuleParams.insert("name", "TestRule");
QVariantList actions; QVariantList actions;

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

@ -116,7 +116,7 @@ void TestRules::emptyRule()
params.insert("name", QString()); params.insert("name", QString());
params.insert("actions", QVariantList()); params.insert("actions", QVariantList());
QVariant response = injectAndWait("Rules.AddRule", params); QVariant response = injectAndWait("Rules.AddRule", params);
verifyRuleError(response, RuleEngine::RuleErrorMissingParameter); verifyRuleError(response, RuleEngine::RuleErrorInvalidRuleFormat);
} }
void TestRules::getInvalidRule() void TestRules::getInvalidRule()
@ -342,7 +342,7 @@ void TestRules::addRemoveRules_data()
QTest::newRow("invalid rule. enabled, 1 Action (eventBased), types not matching, name") << true << invalidActionEventBased3 << QVariantMap() << validEventDescriptor1 << QVariantList() << QVariantMap() << RuleEngine::RuleErrorTypesNotMatching << false << "TestRule"; QTest::newRow("invalid rule. enabled, 1 Action (eventBased), types not matching, name") << true << invalidActionEventBased3 << QVariantMap() << validEventDescriptor1 << QVariantList() << QVariantMap() << RuleEngine::RuleErrorTypesNotMatching << false << "TestRule";
QTest::newRow("invalid rule. enabled, 1 Action (eventBased), 1 EventDescriptor, name") << true << invalidActionEventBased << QVariantMap() << validEventDescriptor2 << QVariantList() << QVariantMap() << RuleEngine::RuleErrorInvalidRuleActionParameter << false << "TestRule"; QTest::newRow("invalid rule. enabled, 1 Action (eventBased), 1 EventDescriptor, name") << true << invalidActionEventBased << QVariantMap() << validEventDescriptor2 << QVariantList() << QVariantMap() << RuleEngine::RuleErrorTypesNotMatching << false << "TestRule";
QTest::newRow("invalid rule. enabled, 1 Action (eventBased), 1 StateEvaluator, name") << true << validActionEventBased << QVariantMap() << QVariantMap() << QVariantList() << validStateEvaluator << RuleEngine::RuleErrorInvalidRuleActionParameter << false << "TestRule"; QTest::newRow("invalid rule. enabled, 1 Action (eventBased), 1 StateEvaluator, name") << true << validActionEventBased << QVariantMap() << QVariantMap() << QVariantList() << validStateEvaluator << RuleEngine::RuleErrorInvalidRuleActionParameter << false << "TestRule";
QTest::newRow("invalid rule. enabled, 1 Action (eventBased), 1 EventDescriptor, name") << true << validActionEventBased << validActionEventBased << validEventDescriptor2 << QVariantList() << QVariantMap() << RuleEngine::RuleErrorInvalidRuleFormat << false << "TestRule"; QTest::newRow("invalid rule. enabled, 1 Action (eventBased), 1 EventDescriptor, name") << true << validActionEventBased << validActionEventBased << validEventDescriptor2 << QVariantList() << QVariantMap() << RuleEngine::RuleErrorInvalidRuleFormat << false << "TestRule";
QTest::newRow("invalid rule. enabled, 1 Action, 1 ExitAction (EventBased), name") << true << validActionNoParams << validActionEventBased << validEventDescriptor2 << QVariantList() << QVariantMap() << RuleEngine::RuleErrorInvalidRuleFormat << false << "TestRule"; QTest::newRow("invalid rule. enabled, 1 Action, 1 ExitAction (EventBased), name") << true << validActionNoParams << validActionEventBased << validEventDescriptor2 << QVariantList() << QVariantMap() << RuleEngine::RuleErrorInvalidRuleFormat << false << "TestRule";
@ -358,7 +358,6 @@ void TestRules::addRemoveRules_data()
QTest::newRow("valid rule. enabled, 1 EventDescriptor, StateEvaluator, 1 Action, name") << true << validActionNoParams << QVariantMap() << validEventDescriptor1 << QVariantList() << validStateEvaluator << RuleEngine::RuleErrorNoError << true << "TestRule"; QTest::newRow("valid rule. enabled, 1 EventDescriptor, StateEvaluator, 1 Action, name") << true << validActionNoParams << QVariantMap() << validEventDescriptor1 << QVariantList() << validStateEvaluator << RuleEngine::RuleErrorNoError << true << "TestRule";
QTest::newRow("valid rule. diabled, 1 EventDescriptor, StateEvaluator, 1 Action, name") << false << validActionNoParams << QVariantMap() << validEventDescriptor1 << QVariantList() << validStateEvaluator << RuleEngine::RuleErrorNoError << true << "TestRule"; QTest::newRow("valid rule. diabled, 1 EventDescriptor, StateEvaluator, 1 Action, name") << false << validActionNoParams << QVariantMap() << validEventDescriptor1 << QVariantList() << validStateEvaluator << RuleEngine::RuleErrorNoError << true << "TestRule";
QTest::newRow("valid rule. 2 EventDescriptors, 1 Action, name") << true << validActionNoParams << QVariantMap() << QVariantMap() << eventDescriptorList << validStateEvaluator << RuleEngine::RuleErrorNoError << true << "TestRule"; QTest::newRow("valid rule. 2 EventDescriptors, 1 Action, name") << true << validActionNoParams << QVariantMap() << QVariantMap() << eventDescriptorList << validStateEvaluator << RuleEngine::RuleErrorNoError << true << "TestRule";
QTest::newRow("invalid rule: eventDescriptor and eventDescriptorList used") << true << validActionNoParams << QVariantMap() << validEventDescriptor1 << eventDescriptorList << validStateEvaluator << RuleEngine::RuleErrorInvalidParameter << false << "TestRule";
QTest::newRow("invalid action") << true << invalidAction << QVariantMap() << validEventDescriptor1 << QVariantList() << validStateEvaluator << RuleEngine::RuleErrorActionTypeNotFound << false << "TestRule"; QTest::newRow("invalid action") << true << invalidAction << QVariantMap() << validEventDescriptor1 << QVariantList() << validStateEvaluator << RuleEngine::RuleErrorActionTypeNotFound << false << "TestRule";
QTest::newRow("invalid event descriptor") << true << validActionNoParams << QVariantMap() << invalidEventDescriptor << QVariantList() << validStateEvaluator << RuleEngine::RuleErrorDeviceNotFound << false << "TestRule"; QTest::newRow("invalid event descriptor") << true << validActionNoParams << QVariantMap() << invalidEventDescriptor << QVariantList() << validStateEvaluator << RuleEngine::RuleErrorDeviceNotFound << false << "TestRule";
QTest::newRow("invalid StateDescriptor") << true << validActionNoParams << QVariantMap() << validEventDescriptor1 << QVariantList() << invalidStateEvaluator << RuleEngine::RuleErrorInvalidParameter << true << "TestRule"; QTest::newRow("invalid StateDescriptor") << true << validActionNoParams << QVariantMap() << validEventDescriptor1 << QVariantList() << invalidStateEvaluator << RuleEngine::RuleErrorInvalidParameter << true << "TestRule";
@ -384,10 +383,10 @@ void TestRules::addRemoveRules()
params.insert("actions", actions); params.insert("actions", actions);
if (!eventDescriptor.isEmpty()) { if (!eventDescriptor.isEmpty()) {
params.insert("eventDescriptor", eventDescriptor); params.insert("eventDescriptors", QVariantList() << eventDescriptor);
} }
if (!eventDescriptorList.isEmpty()) { if (!eventDescriptorList.isEmpty()) {
params.insert("eventDescriptorList", eventDescriptorList); params.insert("eventDescriptors", eventDescriptorList);
} }
QVariantList exitActions; QVariantList exitActions;
if (!exitAction1.isEmpty()) { if (!exitAction1.isEmpty()) {
@ -587,7 +586,7 @@ void TestRules::editRules_data()
QTest::newRow("invalid rule. enabled, 1 Action (eventBased), types not matching, name") << true << invalidActionEventBased3 << QVariantMap() << validEventDescriptor1 << QVariantList() << QVariantMap() << RuleEngine::RuleErrorTypesNotMatching << "TestRule"; QTest::newRow("invalid rule. enabled, 1 Action (eventBased), types not matching, name") << true << invalidActionEventBased3 << QVariantMap() << validEventDescriptor1 << QVariantList() << QVariantMap() << RuleEngine::RuleErrorTypesNotMatching << "TestRule";
QTest::newRow("invalid rule. enabled, 1 Action (eventBased), 1 EventDescriptor, name") << true << invalidActionEventBased << QVariantMap() << validEventDescriptor2 << QVariantList() << QVariantMap() << RuleEngine::RuleErrorInvalidRuleActionParameter << "TestRule"; QTest::newRow("invalid rule. enabled, 1 Action (eventBased), 1 EventDescriptor, name") << true << invalidActionEventBased << QVariantMap() << validEventDescriptor2 << QVariantList() << QVariantMap() << RuleEngine::RuleErrorTypesNotMatching << "TestRule";
QTest::newRow("invalid rule. enabled, 1 Action (eventBased), 1 StateEvaluator, name") << true << validActionEventBased << QVariantMap() << QVariantMap() << QVariantList() << validStateEvaluator << RuleEngine::RuleErrorInvalidRuleActionParameter << "TestRule"; QTest::newRow("invalid rule. enabled, 1 Action (eventBased), 1 StateEvaluator, name") << true << validActionEventBased << QVariantMap() << QVariantMap() << QVariantList() << validStateEvaluator << RuleEngine::RuleErrorInvalidRuleActionParameter << "TestRule";
QTest::newRow("invalid rule. enabled, 1 Action (eventBased), 1 EventDescriptor, name") << true << validActionEventBased << validActionEventBased << validEventDescriptor2 << QVariantList() << QVariantMap() << RuleEngine::RuleErrorInvalidRuleFormat << "TestRule"; QTest::newRow("invalid rule. enabled, 1 Action (eventBased), 1 EventDescriptor, name") << true << validActionEventBased << validActionEventBased << validEventDescriptor2 << QVariantList() << QVariantMap() << RuleEngine::RuleErrorInvalidRuleFormat << "TestRule";
QTest::newRow("invalid rule. enabled, 1 Action, 1 ExitAction (EventBased), name") << true << validActionNoParams << validActionEventBased << validEventDescriptor2 << QVariantList() << QVariantMap() << RuleEngine::RuleErrorInvalidRuleFormat << "TestRule"; QTest::newRow("invalid rule. enabled, 1 Action, 1 ExitAction (EventBased), name") << true << validActionNoParams << validActionEventBased << validEventDescriptor2 << QVariantList() << QVariantMap() << RuleEngine::RuleErrorInvalidRuleFormat << "TestRule";
@ -602,7 +601,6 @@ void TestRules::editRules_data()
QTest::newRow("valid rule. enabled, 1 EventDescriptor, StateEvaluator, 1 Action, name") << true << validActionNoParams << QVariantMap() << validEventDescriptor1 << QVariantList() << validStateEvaluator << RuleEngine::RuleErrorNoError << "TestRule"; QTest::newRow("valid rule. enabled, 1 EventDescriptor, StateEvaluator, 1 Action, name") << true << validActionNoParams << QVariantMap() << validEventDescriptor1 << QVariantList() << validStateEvaluator << RuleEngine::RuleErrorNoError << "TestRule";
QTest::newRow("valid rule. diabled, 1 EventDescriptor, StateEvaluator, 1 Action, name") << false << validActionNoParams << QVariantMap() << validEventDescriptor1 << QVariantList() << validStateEvaluator << RuleEngine::RuleErrorNoError << "TestRule"; QTest::newRow("valid rule. diabled, 1 EventDescriptor, StateEvaluator, 1 Action, name") << false << validActionNoParams << QVariantMap() << validEventDescriptor1 << QVariantList() << validStateEvaluator << RuleEngine::RuleErrorNoError << "TestRule";
QTest::newRow("valid rule. 2 EventDescriptors, 1 Action, name") << true << validActionNoParams << QVariantMap() << QVariantMap() << eventDescriptorList << validStateEvaluator << RuleEngine::RuleErrorNoError << "TestRule"; QTest::newRow("valid rule. 2 EventDescriptors, 1 Action, name") << true << validActionNoParams << QVariantMap() << QVariantMap() << eventDescriptorList << validStateEvaluator << RuleEngine::RuleErrorNoError << "TestRule";
QTest::newRow("invalid rule: eventDescriptor and eventDescriptorList used") << true << validActionNoParams << QVariantMap() << validEventDescriptor1 << eventDescriptorList << validStateEvaluator << RuleEngine::RuleErrorInvalidParameter << "TestRule";
} }
void TestRules::editRules() void TestRules::editRules()
@ -704,7 +702,7 @@ void TestRules::editRules()
actions.append(action1); actions.append(action1);
actions.append(action2); actions.append(action2);
params.insert("actions", actions); params.insert("actions", actions);
params.insert("eventDescriptorList", eventDescriptorList1); params.insert("eventDescriptors", eventDescriptorList1);
params.insert("stateEvaluator", stateEvaluator0); params.insert("stateEvaluator", stateEvaluator0);
params.insert("name", "TestRule"); params.insert("name", "TestRule");
QVariant response = injectAndWait("Rules.AddRule", params); QVariant response = injectAndWait("Rules.AddRule", params);
@ -721,10 +719,10 @@ void TestRules::editRules()
params.insert("name", name); params.insert("name", name);
if (!eventDescriptor.isEmpty()) { if (!eventDescriptor.isEmpty()) {
params.insert("eventDescriptor", eventDescriptor); params.insert("eventDescriptors", QVariantList() << eventDescriptor);
} }
if (!eventDescriptorList.isEmpty()) { if (!eventDescriptorList.isEmpty()) {
params.insert("eventDescriptorList", eventDescriptorList); params.insert("eventDescriptors", eventDescriptorList);
} }
actions.clear(); actions.clear();
actions.append(action); actions.append(action);
@ -989,7 +987,7 @@ void TestRules::loadStoreConfig()
actions.append(action1); actions.append(action1);
actions.append(action2); actions.append(action2);
params.insert("actions", actions); params.insert("actions", actions);
params.insert("eventDescriptorList", eventDescriptorList); params.insert("eventDescriptors", eventDescriptorList);
params.insert("stateEvaluator", stateEvaluator1); params.insert("stateEvaluator", stateEvaluator1);
params.insert("name", "TestRule"); params.insert("name", "TestRule");
QVariant response = injectAndWait("Rules.AddRule", params); QVariant response = injectAndWait("Rules.AddRule", params);
@ -1017,7 +1015,7 @@ void TestRules::loadStoreConfig()
QVariantList actions3; QVariantList actions3;
actions3.append(validActionEventBased); actions3.append(validActionEventBased);
params3.insert("actions", actions3); params3.insert("actions", actions3);
params3.insert("eventDescriptorList", validEventDescriptors3); params3.insert("eventDescriptors", validEventDescriptors3);
params3.insert("name", "TestRule3"); params3.insert("name", "TestRule3");
QVariant response3 = injectAndWait("Rules.AddRule", params3); QVariant response3 = injectAndWait("Rules.AddRule", params3);
@ -1223,7 +1221,7 @@ void TestRules::evaluateEvent()
event1.insert("eventTypeId", mockEvent1Id); event1.insert("eventTypeId", mockEvent1Id);
event1.insert("deviceId", m_mockDeviceId); event1.insert("deviceId", m_mockDeviceId);
events.append(event1); events.append(event1);
addRuleParams.insert("eventDescriptorList", events); addRuleParams.insert("eventDescriptors", events);
QVariantList actions; QVariantList actions;
QVariantMap action; QVariantMap action;
@ -1424,7 +1422,7 @@ void TestRules::enableDisableRule()
event1.insert("eventTypeId", mockEvent1Id); event1.insert("eventTypeId", mockEvent1Id);
event1.insert("deviceId", m_mockDeviceId); event1.insert("deviceId", m_mockDeviceId);
events.append(event1); events.append(event1);
addRuleParams.insert("eventDescriptorList", events); addRuleParams.insert("eventDescriptors", events);
addRuleParams.insert("name", "TestRule"); addRuleParams.insert("name", "TestRule");
QVariantList actions; QVariantList actions;
@ -1494,7 +1492,7 @@ void TestRules::testEventBasedAction()
QVariantMap eventDescriptor; QVariantMap eventDescriptor;
eventDescriptor.insert("eventTypeId", mockIntStateId); eventDescriptor.insert("eventTypeId", mockIntStateId);
eventDescriptor.insert("deviceId", m_mockDeviceId); eventDescriptor.insert("deviceId", m_mockDeviceId);
addRuleParams.insert("eventDescriptor", eventDescriptor); addRuleParams.insert("eventDescriptors", QVariantList() << eventDescriptor);
addRuleParams.insert("name", "TestRule"); addRuleParams.insert("name", "TestRule");
addRuleParams.insert("enabled", true); addRuleParams.insert("enabled", true);

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

@ -40,11 +40,11 @@ private slots:
void changeTimeZone_data(); void changeTimeZone_data();
void changeTimeZone(); void changeTimeZone();
void addTimeDescriptor_data();
void addTimeDescriptor();
}; };
void TestTimeManager::changeTimeZone_data() void TestTimeManager::changeTimeZone_data()
{ {
QTest::addColumn<QByteArray>("timeZoneId"); QTest::addColumn<QByteArray>("timeZoneId");