improve and add api for networkmanager

server/jsonrpc/jsonhandler.cpp

@@ -220,6 +220,14 @@ QVariantMap JsonHandler::statusToReply(GuhConfiguration::ConfigurationError stat
     return returns;
 }
 
+/*! Returns the formated error map for the given \a status. */
+QVariantMap JsonHandler::statusToReply(NetworkManager::NetworkManagerError status) const
+{
+    QVariantMap returns;
+    returns.insert("networkManagerError", JsonTypes::networkManagerErrorToString(status));
+    return returns;
+}
+
 
 /*!
     \class guhserver::JsonReply

server/jsonrpc/jsonhandler.h

@@ -113,6 +113,7 @@ protected:
     QVariantMap statusToReply(Logging::LoggingError status) const;
     QVariantMap statusToReply(Cloud::CloudError status) const;
     QVariantMap statusToReply(GuhConfiguration::ConfigurationError status) const;
+    QVariantMap statusToReply(NetworkManager::NetworkManagerError status) const;
 
 private:
     QHash<QString, QString> m_descriptions;

server/jsonrpc/jsontypes.cpp

@@ -84,6 +84,7 @@ QVariantList JsonTypes::s_loggingEventType;
 QVariantList JsonTypes::s_repeatingMode;
 QVariantList JsonTypes::s_cloudError;
 QVariantList JsonTypes::s_configurationError;
+QVariantList JsonTypes::s_networkManagerError;
 QVariantList JsonTypes::s_networkManagerState;
 
 QVariantMap JsonTypes::s_paramType;
@@ -137,6 +138,7 @@ void JsonTypes::init()
     s_repeatingMode = enumToStrings(RepeatingOption::staticMetaObject, "RepeatingMode");
     s_cloudError = enumToStrings(Cloud::staticMetaObject, "CloudError");
     s_configurationError = enumToStrings(GuhConfiguration::staticMetaObject, "ConfigurationError");
+    s_networkManagerError = enumToStrings(NetworkManager::staticMetaObject, "NetworkManagerError");
     s_networkManagerState = enumToStrings(NetworkManager::staticMetaObject, "NetworkManagerState");
 
     // ParamType
@@ -349,9 +351,9 @@ QVariantList JsonTypes::enumToStrings(const QMetaObject &metaObject, const QStri
     QMetaEnum metaEnum = metaObject.enumerator(enumIndex);
 
     QVariantList enumStrings;
-    for (int i = 0; i < metaEnum.keyCount(); i++) {
+    for (int i = 0; i < metaEnum.keyCount(); i++)
         enumStrings << metaEnum.valueToKey(metaEnum.value(i));
-    }
+
     return enumStrings;
 }
 
@@ -379,6 +381,7 @@ QVariantMap JsonTypes::allTypes()
     allTypes.insert("RepeatingMode", repeatingMode());
     allTypes.insert("CloudError", cloudError());
     allTypes.insert("ConfigurationError", configurationError());
+    allTypes.insert("NetworkManagerError", networkManagerError());
     allTypes.insert("NetworkManagerState", networkManagerState());
 
     allTypes.insert("StateType", stateTypeDescription());
@@ -426,9 +429,9 @@ QVariantMap JsonTypes::packEventType(const EventType &eventType)
         variant.insert("graphRelevant", true);
 
     QVariantList paramTypes;
-    foreach (const ParamType &paramType, eventType.paramTypes()) {
+    foreach (const ParamType &paramType, eventType.paramTypes())
         paramTypes.append(packParamType(paramType));
-    }
+
     variant.insert("paramTypes", paramTypes);
     return variant;
 }
@@ -440,9 +443,9 @@ QVariantMap JsonTypes::packEvent(const Event &event)
     variant.insert("eventTypeId", event.eventTypeId());
     variant.insert("deviceId", event.deviceId());
     QVariantList params;
-    foreach (const Param &param, event.params()) {
+    foreach (const Param &param, event.params())
         params.append(packParam(param));
-    }
+
     variant.insert("params", params);
     return variant;
 }
@@ -454,9 +457,9 @@ QVariantMap JsonTypes::packEventDescriptor(const EventDescriptor &eventDescripto
     variant.insert("eventTypeId", eventDescriptor.eventTypeId());
     variant.insert("deviceId", eventDescriptor.deviceId());
     QVariantList params;
-    foreach (const ParamDescriptor &paramDescriptor, eventDescriptor.paramDescriptors()) {
+    foreach (const ParamDescriptor &paramDescriptor, eventDescriptor.paramDescriptors())
         params.append(packParamDescriptor(paramDescriptor));
-    }
+
     variant.insert("paramDescriptors", params);
     return variant;
 }
@@ -469,9 +472,9 @@ QVariantMap JsonTypes::packActionType(const ActionType &actionType)
     variantMap.insert("name", actionType.name());
     variantMap.insert("index", actionType.index());
     QVariantList paramTypes;
-    foreach (const ParamType &paramType, actionType.paramTypes()) {
+    foreach (const ParamType &paramType, actionType.paramTypes())
         paramTypes.append(packParamType(paramType));
-    }
+
     variantMap.insert("paramTypes", paramTypes);
     return variantMap;
 }
@@ -483,9 +486,9 @@ QVariantMap JsonTypes::packAction(const Action &action)
     variant.insert("actionTypeId", action.actionTypeId());
     variant.insert("deviceId", action.deviceId());
     QVariantList params;
-    foreach (const Param &param, action.params()) {
+    foreach (const Param &param, action.params())
         params.append(packParam(param));
-    }
+
     variant.insert("params", params);
     return variant;
 }
@@ -497,9 +500,9 @@ QVariantMap JsonTypes::packRuleAction(const RuleAction &ruleAction)
     variant.insert("actionTypeId", ruleAction.actionTypeId());
     variant.insert("deviceId", ruleAction.deviceId());
     QVariantList params;
-    foreach (const RuleActionParam &ruleActionParam, ruleAction.ruleActionParams()) {
+    foreach (const RuleActionParam &ruleActionParam, ruleAction.ruleActionParams())
         params.append(packRuleActionParam(ruleActionParam));
-    }
+
     variant.insert("ruleActionParams", params);
     return variant;
 }
@@ -574,20 +577,18 @@ QVariantMap JsonTypes::packStateDescriptor(const StateDescriptor &stateDescripto
 QVariantMap JsonTypes::packStateEvaluator(const StateEvaluator &stateEvaluator)
 {
     QVariantMap variantMap;
-    if (stateEvaluator.stateDescriptor().isValid()) {
+    if (stateEvaluator.stateDescriptor().isValid())
         variantMap.insert("stateDescriptor", packStateDescriptor(stateEvaluator.stateDescriptor()));
-    }
+
     QVariantList childEvaluators;
-    foreach (const StateEvaluator &childEvaluator, stateEvaluator.childEvaluators()) {
+    foreach (const StateEvaluator &childEvaluator, stateEvaluator.childEvaluators())
         childEvaluators.append(packStateEvaluator(childEvaluator));
-    }
 
     if (!childEvaluators.isEmpty() || stateEvaluator.stateDescriptor().isValid())
         variantMap.insert("operator", s_stateOperator.at(stateEvaluator.operatorType()));
 
-    if (childEvaluators.count() > 0) {
+    if (childEvaluators.count() > 0)
         variantMap.insert("childEvaluators", childEvaluators);
-    }
 
     return variantMap;
 }
@@ -621,27 +622,27 @@ QVariantMap JsonTypes::packParamType(const ParamType &paramType)
     variantMap.insert("index", paramType.index());
 
     // Optional values
-    if (paramType.defaultValue().isValid()) {
+    if (paramType.defaultValue().isValid())
         variantMap.insert("defaultValue", paramType.defaultValue());
-    }
+
-    if (paramType.minValue().isValid()) {
+    if (paramType.minValue().isValid())
         variantMap.insert("minValue", paramType.minValue());
-    }
+
-    if (paramType.maxValue().isValid()) {
+    if (paramType.maxValue().isValid())
         variantMap.insert("maxValue", paramType.maxValue());
-    }
+
-    if (!paramType.allowedValues().isEmpty()) {
+    if (!paramType.allowedValues().isEmpty())
         variantMap.insert("allowedValues", paramType.allowedValues());
-    }
+
-    if (paramType.inputType() != Types::InputTypeNone) {
+    if (paramType.inputType() != Types::InputTypeNone)
         variantMap.insert("inputType", s_inputType.at(paramType.inputType()));
-    }
+
-    if (paramType.unit() != Types::UnitNone) {
+    if (paramType.unit() != Types::UnitNone)
         variantMap.insert("unit", s_unit.at(paramType.unit()));
-    }
+
-    if (paramType.readOnly()) {
+    if (paramType.readOnly())
         variantMap.insert("readOnly", paramType.readOnly());
-    }
+
     return variantMap;
 }
 
@@ -665,29 +666,28 @@ QVariantMap JsonTypes::packDeviceClass(const DeviceClass &deviceClass)
     variant.insert("deviceIcon", s_deviceIcon.at(deviceClass.deviceIcon()));
 
     QVariantList basicTags;
-    foreach (const DeviceClass::BasicTag &basicTag, deviceClass.basicTags()) {
+    foreach (const DeviceClass::BasicTag &basicTag, deviceClass.basicTags())
         basicTags.append(s_basicTag.at(basicTag));
-    }
+
     QVariantList stateTypes;
-    foreach (const StateType &stateType, deviceClass.stateTypes()) {
+    foreach (const StateType &stateType, deviceClass.stateTypes())
         stateTypes.append(packStateType(stateType));
-    }
+
     QVariantList eventTypes;
-    foreach (const EventType &eventType, deviceClass.eventTypes()) {
+    foreach (const EventType &eventType, deviceClass.eventTypes())
         eventTypes.append(packEventType(eventType));
-    }
+
     QVariantList actionTypes;
-    foreach (const ActionType &actionType, deviceClass.actionTypes()) {
+    foreach (const ActionType &actionType, deviceClass.actionTypes())
         actionTypes.append(packActionType(actionType));
-    }
+
     QVariantList paramTypes;
-    foreach (const ParamType &paramType, deviceClass.paramTypes()) {
+    foreach (const ParamType &paramType, deviceClass.paramTypes())
         paramTypes.append(packParamType(paramType));
-    }
+
     QVariantList discoveryParamTypes;
-    foreach (const ParamType &paramType, deviceClass.discoveryParamTypes()) {
+    foreach (const ParamType &paramType, deviceClass.discoveryParamTypes())
         discoveryParamTypes.append(packParamType(paramType));
-    }
 
     if (!deviceClass.criticalStateTypeId().isNull())
         variant.insert("criticalStateTypeId", deviceClass.criticalStateTypeId());
@@ -717,9 +717,9 @@ QVariantMap JsonTypes::packPlugin(DevicePlugin *plugin)
     pluginMap.insert("name", plugin->pluginName());
 
     QVariantList params;
-    foreach (const ParamType &param, plugin->configurationDescription()) {
+    foreach (const ParamType &param, plugin->configurationDescription())
         params.append(packParamType(param));
-    }
+
     pluginMap.insert("paramTypes", params);
     return pluginMap;
 }
@@ -732,9 +732,8 @@ QVariantMap JsonTypes::packDevice(Device *device)
     variant.insert("deviceClassId", device->deviceClassId());
     variant.insert("name", device->name());
     QVariantList params;
-    foreach (const Param &param, device->params()) {
+    foreach (const Param &param, device->params())
         params.append(packParam(param));
-    }
 
     if (!device->parentId().isNull())
         variant.insert("parentId", device->parentId());
@@ -767,22 +766,22 @@ QVariantMap JsonTypes::packRule(const Rule &rule)
     ruleMap.insert("timeDescriptor", JsonTypes::packTimeDescriptor(rule.timeDescriptor()));
 
     QVariantList eventDescriptorList;
-    foreach (const EventDescriptor &eventDescriptor, rule.eventDescriptors()) {
+    foreach (const EventDescriptor &eventDescriptor, rule.eventDescriptors())
         eventDescriptorList.append(JsonTypes::packEventDescriptor(eventDescriptor));
-    }
+
     ruleMap.insert("eventDescriptors", eventDescriptorList);
     ruleMap.insert("stateEvaluator", JsonTypes::packStateEvaluator(rule.stateEvaluator()));
 
     QVariantList actionList;
-    foreach (const RuleAction &action, rule.actions()) {
+    foreach (const RuleAction &action, rule.actions())
         actionList.append(JsonTypes::packRuleAction(action));
-    }
+
     ruleMap.insert("actions", actionList);
 
     QVariantList exitActionList;
-    foreach (const RuleAction &action, rule.exitActions()) {
+    foreach (const RuleAction &action, rule.exitActions())
         exitActionList.append(JsonTypes::packRuleAction(action));
-    }
+
     ruleMap.insert("exitActions", exitActionList);
     return ruleMap;
 }
@@ -791,9 +790,9 @@ QVariantMap JsonTypes::packRule(const Rule &rule)
 QVariantList JsonTypes::packRules(const QList<Rule> rules)
 {
     QVariantList rulesList;
-    foreach (const Rule &rule, rules) {
+    foreach (const Rule &rule, rules)
         rulesList.append(JsonTypes::packRule(rule));
-    }
+
     return rulesList;
 }
 
@@ -818,13 +817,11 @@ QVariantMap JsonTypes::packLogEntry(const LogEntry &logEntry)
     logEntryMap.insert("source", s_loggingSource.at(logEntry.source()));
     logEntryMap.insert("eventType", s_loggingEventType.at(logEntry.eventType()));
 
-    if (logEntry.eventType() == Logging::LoggingEventTypeActiveChange) {
+    if (logEntry.eventType() == Logging::LoggingEventTypeActiveChange)
         logEntryMap.insert("active", logEntry.active());
-    }
 
-    if (logEntry.eventType() == Logging::LoggingEventTypeEnabledChange) {
+    if (logEntry.eventType() == Logging::LoggingEventTypeEnabledChange)
         logEntryMap.insert("active", logEntry.active());
-    }
 
     if (logEntry.level() == Logging::LoggingLevelAlert) {
         switch (logEntry.source()) {
@@ -866,15 +863,15 @@ QVariantMap JsonTypes::packLogEntry(const LogEntry &logEntry)
 QVariantList JsonTypes::packCreateMethods(DeviceClass::CreateMethods createMethods)
 {
     QVariantList ret;
-    if (createMethods.testFlag(DeviceClass::CreateMethodUser)) {
+    if (createMethods.testFlag(DeviceClass::CreateMethodUser))
         ret << "CreateMethodUser";
-    }
+
-    if (createMethods.testFlag(DeviceClass::CreateMethodAuto)) {
+    if (createMethods.testFlag(DeviceClass::CreateMethodAuto))
         ret << "CreateMethodAuto";
-    }
+
-    if (createMethods.testFlag(DeviceClass::CreateMethodDiscovery)) {
+    if (createMethods.testFlag(DeviceClass::CreateMethodDiscovery))
         ret << "CreateMethodDiscovery";
-    }
+
     return ret;
 }
 
@@ -885,17 +882,17 @@ QVariantMap JsonTypes::packRepeatingOption(const RepeatingOption &option)
     optionVariant.insert("mode", s_repeatingMode.at(option.mode()));
     if (!option.weekDays().isEmpty()) {
         QVariantList weekDaysVariantList;
-        foreach (const int& weekDay, option.weekDays()) {
+        foreach (const int& weekDay, option.weekDays())
             weekDaysVariantList.append(QVariant(weekDay));
-        }
+
         optionVariant.insert("weekDays", weekDaysVariantList);
     }
 
     if (!option.monthDays().isEmpty()) {
         QVariantList monthDaysVariantList;
-        foreach (const int& monthDay, option.monthDays()) {
+        foreach (const int& monthDay, option.monthDays())
             monthDaysVariantList.append(QVariant(monthDay));
-        }
+
         optionVariant.insert("monthDays", monthDaysVariantList);
     }
     return optionVariant;
@@ -943,17 +940,17 @@ QVariantMap JsonTypes::packTimeDescriptor(const TimeDescriptor &timeDescriptor)
 
     if (!timeDescriptor.calendarItems().isEmpty()) {
         QVariantList calendarItems;
-        foreach (const CalendarItem &calendarItem, timeDescriptor.calendarItems()) {
+        foreach (const CalendarItem &calendarItem, timeDescriptor.calendarItems())
             calendarItems.append(packCalendarItem(calendarItem));
-        }
+
         timeDescriptorVariant.insert("calendarItems", calendarItems);
     }
 
     if (!timeDescriptor.timeEventItems().isEmpty()) {
         QVariantList timeEventItems;
-        foreach (const TimeEventItem &timeEventItem, timeDescriptor.timeEventItems()) {
+        foreach (const TimeEventItem &timeEventItem, timeDescriptor.timeEventItems())
             timeEventItems.append(packTimeEventItem(timeEventItem));
-        }
+
         timeDescriptorVariant.insert("timeEventItems", timeEventItems);
     }
 
@@ -984,9 +981,9 @@ QVariantMap JsonTypes::packNetworkDevice(NetworkDevice *networkDevice)
 QVariantList JsonTypes::packSupportedVendors()
 {
     QVariantList supportedVendors;
-    foreach (const Vendor &vendor, GuhCore::instance()->deviceManager()->supportedVendors()) {
+    foreach (const Vendor &vendor, GuhCore::instance()->deviceManager()->supportedVendors())
         supportedVendors.append(packVendor(vendor));
-    }
+
     return supportedVendors;
 }
 
@@ -994,9 +991,9 @@ QVariantList JsonTypes::packSupportedVendors()
 QVariantList JsonTypes::packSupportedDevices(const VendorId &vendorId)
 {
     QVariantList supportedDeviceList;
-    foreach (const DeviceClass &deviceClass, GuhCore::instance()->deviceManager()->supportedDevices(vendorId)) {
+    foreach (const DeviceClass &deviceClass, GuhCore::instance()->deviceManager()->supportedDevices(vendorId))
         supportedDeviceList.append(packDeviceClass(deviceClass));
-    }
+
     return supportedDeviceList;
 }
 
@@ -1004,9 +1001,9 @@ QVariantList JsonTypes::packSupportedDevices(const VendorId &vendorId)
 QVariantList JsonTypes::packConfiguredDevices()
 {
     QVariantList configuredDeviceList;
-    foreach (Device *device, GuhCore::instance()->deviceManager()->configuredDevices()) {
+    foreach (Device *device, GuhCore::instance()->deviceManager()->configuredDevices())
         configuredDeviceList.append(packDevice(device));
-    }
+
     return configuredDeviceList;
 }
 
@@ -1028,9 +1025,9 @@ QVariantList JsonTypes::packDeviceStates(Device *device)
 QVariantList JsonTypes::packDeviceDescriptors(const QList<DeviceDescriptor> deviceDescriptors)
 {
     QVariantList deviceDescriptorList;
-    foreach (const DeviceDescriptor &deviceDescriptor, deviceDescriptors) {
+    foreach (const DeviceDescriptor &deviceDescriptor, deviceDescriptors)
         deviceDescriptorList.append(JsonTypes::packDeviceDescriptor(deviceDescriptor));
-    }
+
     return deviceDescriptorList;
 }
 
@@ -1073,9 +1070,9 @@ QVariantMap JsonTypes::packWebSocketServerConfiguration()
 QVariantList JsonTypes::packRuleDescriptions()
 {
     QVariantList rulesList;
-    foreach (const Rule &rule, GuhCore::instance()->ruleEngine()->rules()) {
+    foreach (const Rule &rule, GuhCore::instance()->ruleEngine()->rules())
         rulesList.append(JsonTypes::packRuleDescription(rule));
-    }
+
     return rulesList;
 }
 
@@ -1083,9 +1080,9 @@ QVariantList JsonTypes::packRuleDescriptions()
 QVariantList JsonTypes::packRuleDescriptions(const QList<Rule> &rules)
 {
     QVariantList rulesList;
-    foreach (const Rule &rule, rules) {
+    foreach (const Rule &rule, rules)
         rulesList.append(JsonTypes::packRuleDescription(rule));
-    }
+
     return rulesList;
 }
 
@@ -1093,9 +1090,9 @@ QVariantList JsonTypes::packRuleDescriptions(const QList<Rule> &rules)
 QVariantList JsonTypes::packActionTypes(const DeviceClass &deviceClass)
 {
     QVariantList actionTypes;
-    foreach (const ActionType &actionType, deviceClass.actionTypes()) {
+    foreach (const ActionType &actionType, deviceClass.actionTypes())
         actionTypes.append(JsonTypes::packActionType(actionType));
-    }
+
     return actionTypes;
 }
 
@@ -1103,9 +1100,9 @@ QVariantList JsonTypes::packActionTypes(const DeviceClass &deviceClass)
 QVariantList JsonTypes::packStateTypes(const DeviceClass &deviceClass)
 {
     QVariantList stateTypes;
-    foreach (const StateType &stateType, deviceClass.stateTypes()) {
+    foreach (const StateType &stateType, deviceClass.stateTypes())
         stateTypes.append(JsonTypes::packStateType(stateType));
-    }
+
     return stateTypes;
 }
 
@@ -1113,9 +1110,9 @@ QVariantList JsonTypes::packStateTypes(const DeviceClass &deviceClass)
 QVariantList JsonTypes::packEventTypes(const DeviceClass &deviceClass)
 {
     QVariantList eventTypes;
-    foreach (const EventType &eventType, deviceClass.eventTypes()) {
+    foreach (const EventType &eventType, deviceClass.eventTypes())
         eventTypes.append(JsonTypes::packEventType(eventType));
-    }
+
     return eventTypes;
 }
 
@@ -1167,9 +1164,9 @@ QString JsonTypes::basicTypeToString(const QVariant::Type &type)
 /*! Returns a \l{Param} created from the given \a paramMap. */
 Param JsonTypes::unpackParam(const QVariantMap &paramMap)
 {
-    if (paramMap.keys().count() == 0) {
+    if (paramMap.keys().count() == 0)
         return Param();
-    }
+
     ParamTypeId paramTypeId = paramMap.value("paramTypeId").toString();
     QVariant value = paramMap.value("value");
     return Param(paramTypeId, value);
@@ -1179,9 +1176,9 @@ Param JsonTypes::unpackParam(const QVariantMap &paramMap)
 ParamList JsonTypes::unpackParams(const QVariantList &paramList)
 {
     ParamList params;
-    foreach (const QVariant &paramVariant, paramList) {
+    foreach (const QVariant &paramVariant, paramList)
         params.append(unpackParam(paramVariant.toMap()));
-    }
+
     return params;
 }
 
@@ -1266,9 +1263,9 @@ RuleActionParam JsonTypes::unpackRuleActionParam(const QVariantMap &ruleActionPa
 RuleActionParamList JsonTypes::unpackRuleActionParams(const QVariantList &ruleActionParamList)
 {
     RuleActionParamList ruleActionParams;
-    foreach (const QVariant &paramVariant, ruleActionParamList) {
+    foreach (const QVariant &paramVariant, ruleActionParamList)
         ruleActionParams.append(unpackRuleActionParam(paramVariant.toMap()));
-    }
+
     return ruleActionParams;
 }
 
@@ -1289,9 +1286,9 @@ ParamDescriptor JsonTypes::unpackParamDescriptor(const QVariantMap &paramMap)
 QList<ParamDescriptor> JsonTypes::unpackParamDescriptors(const QVariantList &paramList)
 {
     QList<ParamDescriptor> params;
-    foreach (const QVariant &paramVariant, paramList) {
+    foreach (const QVariant &paramVariant, paramList)
         params.append(unpackParamDescriptor(paramVariant.toMap()));
-    }
+
     return params;
 }
 
@@ -1309,13 +1306,13 @@ EventDescriptor JsonTypes::unpackEventDescriptor(const QVariantMap &eventDescrip
 StateEvaluator JsonTypes::unpackStateEvaluator(const QVariantMap &stateEvaluatorMap)
 {
     StateEvaluator ret(unpackStateDescriptor(stateEvaluatorMap.value("stateDescriptor").toMap()));
-    if (stateEvaluatorMap.contains("operator")) {
+    if (stateEvaluatorMap.contains("operator"))
         ret.setOperatorType((Types::StateOperator)s_stateOperator.indexOf(stateEvaluatorMap.value("operator").toString()));
-    }
+
     QList<StateEvaluator> childEvaluators;
-    foreach (const QVariant &childEvaluator, stateEvaluatorMap.value("childEvaluators").toList()) {
+    foreach (const QVariant &childEvaluator, stateEvaluatorMap.value("childEvaluators").toList())
         childEvaluators.append(unpackStateEvaluator(childEvaluator.toMap()));
-    }
+
     ret.setChildEvaluators(childEvaluators);
     return ret;
 }
@@ -1340,12 +1337,12 @@ LogFilter JsonTypes::unpackLogFilter(const QVariantMap &logFilterMap)
         foreach (const QVariant &timeFilter, timeFilters) {
             QVariantMap timeFilterMap = timeFilter.toMap();
             QDateTime startDate; QDateTime endDate;
-            if (timeFilterMap.contains("startDate")) {
+            if (timeFilterMap.contains("startDate"))
                 startDate = QDateTime::fromTime_t(timeFilterMap.value("startDate").toInt());
-            }
+
-            if (timeFilterMap.contains("endDate")) {
+            if (timeFilterMap.contains("endDate"))
                 endDate = QDateTime::fromTime_t(timeFilterMap.value("endDate").toInt());
-            }
+
             filter.addTimeFilter(startDate, endDate);
         }
     }
@@ -1864,6 +1861,12 @@ QPair<bool, QString> JsonTypes::validateVariant(const QVariant &templateVariant,
                     qCWarning(dcJsonRpc) << QString("Value %1 not allowed in %2").arg(variant.toString()).arg(networkManagerStateRef());
                     return result;
                 }
+            } else if (refName == networkManagerErrorRef()) {
+                QPair<bool, QString> result = validateEnum(s_networkManagerError, variant);
+                if (!result.first) {
+                    qCWarning(dcJsonRpc) << QString("Value %1 not allowed in %2").arg(variant.toString()).arg(networkManagerErrorRef());
+                    return result;
+                }
             } else {
                 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));
@@ -1935,9 +1938,8 @@ QPair<bool, QString> JsonTypes::validateBasicType(const QVariant &variant)
 QPair<bool, QString> JsonTypes::validateEnum(const QVariantList &enumDescription, const QVariant &value)
 {
     QStringList enumStrings;
-    foreach (const QVariant &variant, enumDescription) {
+    foreach (const QVariant &variant, enumDescription)
         enumStrings.append(variant.toString());
-    }
 
     return report(enumDescription.contains(value.toString()), QString("Value %1 not allowed in %2").arg(value.toString()).arg(enumStrings.join(", ")));
 }

server/jsonrpc/jsontypes.h

@@ -94,7 +94,6 @@ class JsonTypes
 {
     Q_GADGET
     Q_ENUMS(BasicType)
-    Q_ENUMS(JsonError)
 
 public:
     enum BasicType {
@@ -131,6 +130,7 @@ public:
     DECLARE_TYPE(repeatingMode, "RepeatingMode", RepeatingOption, RepeatingMode)
     DECLARE_TYPE(cloudError, "CloudError", Cloud, CloudError)
     DECLARE_TYPE(configurationError, "ConfigurationError", GuhConfiguration, ConfigurationError)
+    DECLARE_TYPE(networkManagerError, "NetworkManagerError", NetworkManager, NetworkManagerError)
     DECLARE_TYPE(networkManagerState, "NetworkManagerState", NetworkManager, NetworkManagerState)
 
     DECLARE_OBJECT(paramType, "ParamType")

server/jsonrpc/networkmanagerhandler.cpp

@@ -18,9 +18,10 @@
  *                                                                         *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
-#include "networkmanagerhandler.h"
-#include "loggingcategories.h"
 #include "guhcore.h"
+#include "jsontypes.h"
+#include "loggingcategories.h"
+#include "networkmanagerhandler.h"
 #include "networkmanager/networkmanager.h"
 
 
@@ -32,30 +33,49 @@ NetworkManagerHandler::NetworkManagerHandler(QObject *parent) :
     QVariantMap params;
     QVariantMap returns;
 
-    params.clear(); returns.clear();
-    setDescription("GetWirelessAccessPoints", "Get the current list of wireless network access points.");
-    setParams("GetWirelessAccessPoints", params);
-    returns.insert("wirelessAccessPoints", QVariantList() << JsonTypes::wirelessAccessPointRef());
-    returns.insert("o:networkError", QVariantList() << JsonTypes::wirelessAccessPointRef());
-    setReturns("GetWirelessAccessPoints", returns);
-
     params.clear(); returns.clear();
     setDescription("GetNetworkStatus", "Get the current network manager status.");
     setParams("GetNetworkStatus", params);
-    returns.insert("networkingEnabled", JsonTypes::basicTypeToString(QVariant::Bool));
+    QVariantMap status;
-    returns.insert("wirelessNetworkingEnabled", JsonTypes::basicTypeToString(QVariant::Bool));
+    status.insert("networkingEnabled", JsonTypes::basicTypeToString(QVariant::Bool));
-    returns.insert("state", JsonTypes::networkManagerStateRef());
+    status.insert("wirelessNetworkingEnabled", JsonTypes::basicTypeToString(QVariant::Bool));
+    status.insert("state", JsonTypes::networkManagerStateRef());
+    returns.insert("o:status", status);
+    returns.insert("o:networkManagerError", JsonTypes::networkManagerErrorRef());
     setReturns("GetNetworkStatus", returns);
 
+    params.clear(); returns.clear();
+    setDescription("EnableNetworking", "Enable or disable networking in the NetworkManager.");
+    params.insert("enable", JsonTypes::basicTypeToString(QVariant::Bool));
+    setParams("EnableNetworking", params);
+    returns.insert("networkManagerError", JsonTypes::networkManagerErrorRef());
+    setReturns("EnableNetworking", returns);
+
+    params.clear(); returns.clear();
+    setDescription("EnableWirelessNetworking", "Enable or disable wireless networking in the NetworkManager.");
+    params.insert("enable", JsonTypes::basicTypeToString(QVariant::Bool));
+    setParams("EnableWirelessNetworking", params);
+    returns.insert("networkManagerError", JsonTypes::networkManagerErrorRef());
+    setReturns("EnableWirelessNetworking", returns);
+
+    params.clear(); returns.clear();
+    setDescription("GetWirelessAccessPoints", "Get the current list of wireless network access points.");
+    setParams("GetWirelessAccessPoints", params);
+    returns.insert("o:wirelessAccessPoints", QVariantList() << JsonTypes::wirelessAccessPointRef());
+    returns.insert("o:networkManagerError", JsonTypes::networkManagerErrorRef());
+    setReturns("GetWirelessAccessPoints", returns);
+
     params.clear(); returns.clear();
     setDescription("GetNetworkDevices", "Get the list of current network devices.");
     setParams("GetNetworkDevices", params);
-    returns.insert("networkDevices",  QVariantList() << JsonTypes::networkDeviceRef());
+    returns.insert("o:networkDevices",  QVariantList() << JsonTypes::networkDeviceRef());
+    returns.insert("o:networkManagerError", JsonTypes::networkManagerErrorRef());
     setReturns("GetNetworkDevices", returns);
 
     params.clear(); returns.clear();
     setDescription("ScanWifiNetworks", "Start a wifi scan for searching new networks.");
     setParams("ScanWifiNetworks", params);
+    returns.insert("networkManagerError", JsonTypes::networkManagerErrorRef());
     setReturns("ScanWifiNetworks", returns);
 
     params.clear(); returns.clear();
@@ -63,7 +83,7 @@ NetworkManagerHandler::NetworkManagerHandler(QObject *parent) :
     params.insert("ssid", JsonTypes::basicTypeToString(QVariant::String));
     params.insert("o:password", JsonTypes::basicTypeToString(QVariant::String));
     setParams("ConnectWifiNetwork", params);
-    //returns.insert("networkDevices",  QVariantList() << JsonTypes::networkDeviceRef());
+    returns.insert("networkManagerError", JsonTypes::networkManagerErrorRef());
     setReturns("ConnectWifiNetwork", returns);
 }
 
@@ -76,16 +96,45 @@ JsonReply *NetworkManagerHandler::GetNetworkStatus(const QVariantMap &params)
 {
     Q_UNUSED(params);
 
-    // TODO: check available
+    // Check available
-    // TODO: returns (networkManager error)
+    if (!GuhCore::instance()->networkManager()->available())
+        return createReply(statusToReply(NetworkManager::NetworkManagerErrorNetworkManagerNotAvailable));
 
-    QVariantMap returns;
+    // Pack network manager status
-    returns.insert("networkingEnabled", GuhCore::instance()->networkManager()->networkingEnabled());
+    QVariantMap returns; QVariantMap status;
-    returns.insert("wirelessNetworkingEnabled", GuhCore::instance()->networkManager()->wirelessEnabled());
+    status.insert("networkingEnabled", GuhCore::instance()->networkManager()->networkingEnabled());
-    returns.insert("state", JsonTypes::networkManagerStateToString(GuhCore::instance()->networkManager()->state()));
+    status.insert("wirelessNetworkingEnabled", GuhCore::instance()->networkManager()->wirelessEnabled());
+    status.insert("state", JsonTypes::networkManagerStateToString(GuhCore::instance()->networkManager()->state()));
+    returns.insert("status", status);
     return createReply(returns);
 }
 
+JsonReply *NetworkManagerHandler::EnableNetworking(const QVariantMap &params)
+{
+    if (!GuhCore::instance()->networkManager()->available())
+        return createReply(statusToReply(NetworkManager::NetworkManagerErrorNetworkManagerNotAvailable));
+
+    bool enable = params.value("enable").toBool();
+
+    if (!GuhCore::instance()->networkManager()->enableNetworking(enable))
+        return createReply(statusToReply(NetworkManager::NetworkManagerErrorUnknownError));
+
+    return createReply(statusToReply(NetworkManager::NetworkManagerErrorNoError));
+}
+
+JsonReply *NetworkManagerHandler::EnableWirelessNetworking(const QVariantMap &params)
+{
+    if (!GuhCore::instance()->networkManager()->available())
+        return createReply(statusToReply(NetworkManager::NetworkManagerErrorNetworkManagerNotAvailable));
+
+    bool enable = params.value("enable").toBool();
+
+    if (!GuhCore::instance()->networkManager()->enableWireless(enable))
+        return createReply(statusToReply(NetworkManager::NetworkManagerErrorUnknownError));
+
+    return createReply(statusToReply(NetworkManager::NetworkManagerErrorNoError));
+}
+
 JsonReply *NetworkManagerHandler::GetWirelessAccessPoints(const QVariantMap &params)
 {
     Q_UNUSED(params);

server/jsonrpc/networkmanagerhandler.h

@@ -36,6 +36,8 @@ public:
     QString name() const;
 
     Q_INVOKABLE JsonReply *GetNetworkStatus(const QVariantMap &params);
+    Q_INVOKABLE JsonReply *EnableNetworking(const QVariantMap &params);
+    Q_INVOKABLE JsonReply *EnableWirelessNetworking(const QVariantMap &params);
     Q_INVOKABLE JsonReply *GetWirelessAccessPoints(const QVariantMap &params);
     Q_INVOKABLE JsonReply *GetNetworkDevices(const QVariantMap &params);
     Q_INVOKABLE JsonReply *ScanWifiNetworks(const QVariantMap &params);

server/networkmanager/networkconnection.cpp

@@ -32,13 +32,13 @@ NetworkConnection::NetworkConnection(const QDBusObjectPath &objectPath, QObject
 {
     qDBusRegisterMetaType<ConnectionSettings>();
 
-    QDBusInterface connectionInterface(serviceString, m_objectPath.path(), connectionsInterfaceString, QDBusConnection::systemBus());
+    m_connectionInterface = new QDBusInterface(serviceString, m_objectPath.path(), connectionsInterfaceString, QDBusConnection::systemBus(), this);
-    if(!connectionInterface.isValid()) {
+    if(!m_connectionInterface->isValid()) {
         qCWarning(dcNetworkManager()) << "Invalid connection dbus interface";
         return;
     }
 
-    QDBusMessage query = connectionInterface.call("GetSettings");
+    QDBusMessage query = m_connectionInterface->call("GetSettings");
     if(query.type() != QDBusMessage::ReplyMessage) {
         qCWarning(dcNetworkManager()) << query.errorName() << query.errorMessage();
         return;
@@ -49,6 +49,13 @@ NetworkConnection::NetworkConnection(const QDBusObjectPath &objectPath, QObject
 
     const QDBusArgument &argument = query.arguments().at(0).value<QDBusArgument>();
     m_connectionSettings = qdbus_cast<ConnectionSettings>(argument);
+}
+
+void NetworkConnection::deleteConnection()
+{
+    QDBusMessage query = m_connectionInterface->call("Delete");
+    if(query.type() != QDBusMessage::ReplyMessage)
+        qCWarning(dcNetworkManager()) << query.errorName() << query.errorMessage();
 
 }
 

server/networkmanager/networkconnection.h

@@ -41,8 +41,9 @@ class NetworkConnection : public QObject
 public:
     explicit NetworkConnection(const QDBusObjectPath &objectPath, QObject *parent = 0);
 
-    QDBusObjectPath objectPath() const;
+    void deleteConnection();
 
+    QDBusObjectPath objectPath() const;
     ConnectionSettings connectionSettings() const;
 
     QString id() const;
@@ -55,6 +56,7 @@ public:
 
 private:
     QDBusObjectPath m_objectPath;
+    QDBusInterface *m_connectionInterface;
 
     ConnectionSettings m_connectionSettings;
 

server/networkmanager/networkmanager.cpp

@@ -20,7 +20,6 @@
 
 #include "networkmanager.h"
 #include "loggingcategories.h"
-
 #include "networkconnection.h"
 
 #include <QMetaEnum>
@@ -45,13 +44,12 @@ NetworkManager::NetworkManager(QObject *parent) :
     }
 
     // Read properties
-    m_version = m_networkManagerInterface->property("Version").toString();
+    setVersion(m_networkManagerInterface->property("Version").toString());
-    m_state = NetworkManagerState(m_networkManagerInterface->property("State").toUInt());
+    setState((NetworkManagerState)m_networkManagerInterface->property("State").toUInt());
-    m_connectivityState = NetworkManagerConnectivityState(m_networkManagerInterface->property("Connectivity").toUInt());
+    setConnectivityState((NetworkManagerConnectivityState)m_networkManagerInterface->property("Connectivity").toUInt());
-    m_networkingEnabled = m_networkManagerInterface->property("NetworkingEnabled").toBool();
+    setNetworkingEnabled(m_networkManagerInterface->property("NetworkingEnabled").toBool());
-    m_wirelessEnabled = m_networkManagerInterface->property("WirelessEnabled").toBool();
+    setWirelessEnabled(m_networkManagerInterface->property("WirelessEnabled").toBool());
 
-    qCDebug(dcNetworkManager()) << "Networkmanager version" << m_version;
     loadDevices();
 
     // Connect signals
@@ -82,22 +80,6 @@ bool NetworkManager::available()
     return true;
 }
 
-QString NetworkManager::networkManagerStateToString(const NetworkManager::NetworkManagerState &state)
-{
-    QMetaObject metaObject = NetworkManager::staticMetaObject;
-    int enumIndex = metaObject.indexOfEnumerator(QString("NetworkManagerState").toLatin1().data());
-    QMetaEnum metaEnum = metaObject.enumerator(enumIndex);
-    return QString(metaEnum.valueToKey(state)).remove("NetworkManagerState");
-}
-
-QString NetworkManager::networkManagerConnectivityStateToString(const NetworkManager::NetworkManagerConnectivityState &state)
-{
-    QMetaObject metaObject = NetworkManager::staticMetaObject;
-    int enumIndex = metaObject.indexOfEnumerator(QString("NetworkManagerConnectivityState").toLatin1().data());
-    QMetaEnum metaEnum = metaObject.enumerator(enumIndex);
-    return QString(metaEnum.valueToKey(state)).remove("NetworkManagerConnectivityState");
-}
-
 QList<NetworkDevice *> NetworkManager::networkDevices() const
 {
     return m_networkDevices.values();
@@ -185,25 +167,12 @@ bool NetworkManager::networkingEnabled() const
     return m_networkingEnabled;
 }
 
-bool NetworkManager::enableNetworking()
+bool NetworkManager::enableNetworking(const bool &enabled)
 {
-    if (m_networkingEnabled)
+    if (m_networkingEnabled == enabled)
         return true;
 
-    QDBusMessage query = m_networkManagerInterface->call("Enable", true);
+    QDBusMessage query = m_networkManagerInterface->call("Enable", enabled);
-    if(query.type() != QDBusMessage::ReplyMessage) {
-        qCWarning(dcNetworkManager()) << query.errorName() << query.errorMessage();
-        return false;
-    }
-    return true;
-}
-
-bool NetworkManager::disableNetworking()
-{
-    if (!m_networkingEnabled)
-        return true;
-
-    QDBusMessage query = m_networkManagerInterface->call("Enable", false);
     if(query.type() != QDBusMessage::ReplyMessage) {
         qCWarning(dcNetworkManager()) << query.errorName() << query.errorMessage();
         return false;
@@ -223,9 +192,9 @@ bool NetworkManager::wirelessEnabled() const
     return m_wirelessEnabled;
 }
 
-bool NetworkManager::enableWireless()
+bool NetworkManager::enableWireless(const bool &enabled)
 {
-    if (m_wirelessEnabled)
+    if (m_wirelessEnabled == enabled)
         return true;
 
     return m_networkManagerInterface->setProperty("WirelessEnabled", true);
@@ -252,6 +221,22 @@ void NetworkManager::loadDevices()
     argument.endArray();
 }
 
+QString NetworkManager::networkManagerStateToString(const NetworkManager::NetworkManagerState &state)
+{
+    QMetaObject metaObject = NetworkManager::staticMetaObject;
+    int enumIndex = metaObject.indexOfEnumerator(QString("NetworkManagerState").toLatin1().data());
+    QMetaEnum metaEnum = metaObject.enumerator(enumIndex);
+    return QString(metaEnum.valueToKey(state)).remove("NetworkManagerState");
+}
+
+QString NetworkManager::networkManagerConnectivityStateToString(const NetworkManager::NetworkManagerConnectivityState &state)
+{
+    QMetaObject metaObject = NetworkManager::staticMetaObject;
+    int enumIndex = metaObject.indexOfEnumerator(QString("NetworkManagerConnectivityState").toLatin1().data());
+    QMetaEnum metaEnum = metaObject.enumerator(enumIndex);
+    return QString(metaEnum.valueToKey(state)).remove("NetworkManagerConnectivityState");
+}
+
 void NetworkManager::setVersion(const QString &version)
 {
     m_version = version;
@@ -315,7 +300,7 @@ void NetworkManager::onPropertiesChanged(const QVariantMap &properties)
         setVersion(properties.value("Version").toString());
 
     if (properties.contains("State"))
-        setState(NetworkManagerState(properties.value("State").toUInt()));
+        setState((NetworkManagerState)properties.value("State").toUInt());
 
     if (properties.contains("Connectivity"))
         setConnectivityState(NetworkManagerConnectivityState(properties.value("Connectivity").toUInt()));

server/networkmanager/networkmanager.h

@@ -66,6 +66,7 @@ public:
 
     enum NetworkManagerError {
         NetworkManagerErrorNoError,
+        NetworkManagerErrorUnknownError,
         NetworkManagerErrorWirelessNotAvailable,
         NetworkManagerErrorAccessPointNotFound,
         NetworkManagerErrorWirelessNetworkingDisabled,
@@ -77,15 +78,10 @@ public:
     explicit NetworkManager(QObject *parent = 0);
 
     static bool available();
-    static QString networkManagerStateToString(const NetworkManagerState &state);
-    static QString networkManagerConnectivityStateToString(const NetworkManagerConnectivityState &state);
 
     QList<NetworkDevice *> networkDevices() const;
-
     WirelessNetworkManager *wirelessNetworkManager() const;
 
-    QString stateToTranslatedString() const;
-
     // Properties
     QString version() const;
     NetworkManagerState state() const;
@@ -93,16 +89,13 @@ public:
 
     NetworkManagerError connectWifi(const QString &ssid, const QString &password);
 
-
     // Networking
     bool networkingEnabled() const;
-    bool enableNetworking();
+    bool enableNetworking(const bool &enabled);
-    bool disableNetworking();
 
     // Wireless Networking
     bool wirelessEnabled() const;
-    bool enableWireless();
+    bool enableWireless(const bool &enabled);
-    bool disableWireless();
 
 private:
     QDBusInterface *m_networkManagerInterface;
@@ -120,6 +113,9 @@ private:
 
     void loadDevices();
 
+    static QString networkManagerStateToString(const NetworkManagerState &state);
+    static QString networkManagerConnectivityStateToString(const NetworkManagerConnectivityState &state);
+
     void setVersion(const QString &version);
     void setNetworkingEnabled(const bool &enabled);
     void setWirelessEnabled(const bool &enabled);
@@ -142,4 +138,8 @@ private slots:
 
 }
 
+using namespace guhserver;
+Q_DECLARE_METATYPE(NetworkManager::NetworkManagerState)
+Q_DECLARE_METATYPE(NetworkManager::NetworkManagerError)
+
 #endif // NETWORKMANAGER_H

server/networkmanager/wirelessnetworkmanager.cpp

@@ -206,8 +206,6 @@ void WirelessNetworkManager::readWirelessDeviceProperties()
     m_driver = driverInterface.property("Driver").toString();
     m_driverVersion = driverInterface.property("DriverVersion").toString();
 
-    qCDebug(dcNetworkManager()) << qdbus_cast<QDBusObjectPath>(driverInterface.property("ActiveConnection")).path();
-
     setManaged(driverInterface.property("Managed").toBool());
     setState(DeviceState(driverInterface.property("State").toUInt()));
 }