Better account status aggregation.

Only ever enter error state on non-recoverable errors.
Otherwise:
* Busy state while busy, then go back to online/offline/error.
* If we failed connect during replay/sync we assume we're offline.
* If we failed to login but could connect we have a known error
  condition.
* If we succeeded to replay/sync something we are apprently online.

At the core we have the problem that we have no way of telling wether
we can connect to the server until we actually try (network is not
enough: vpns, firewalls, ....). Further the status always reflects the
latest status, so even if we were in an error state, once we retry we go
out of the error state and either end up back in the error state or not.

When aggregating states we have to similarly adjust the state to the
most relevant among the resources. The states are ordered like this:
* Error
* Busy
* Connected
* Offline

1 files changed, 14 insertions, 21 deletions

diff --git a/common/resourcefacade.cpp b/common/resourcefacade.cpp
index c702777..dee0711 100644
--- a/common/resourcefacade.cpp
+++ b/common/resourcefacade.cpp
@@ -351,7 +351,7 @@ QPair<KAsync::Job<void>, typename Sink::ResultEmitter<typename ApplicationDomain
         const auto resources = Store::read<ApplicationDomain::SinkResource>(query);
         SinkTraceCtx(ctx) << "Found resource belonging to the account " << account.identifier() << " : " << resources;
         auto accountIdentifier = account.identifier();
-        ApplicationDomain::Status status = ApplicationDomain::ConnectedStatus;
+        QList<int> states;
         for (const auto &resource : resources) {
             auto resourceAccess = ResourceAccessFactory::instance().getAccess(resource.identifier(), ResourceConfig::getResourceType(resource.identifier()));
             if (!monitoredResources->contains(resource.identifier())) {
@@ -364,27 +364,20 @@ QPair<KAsync::Job<void>, typename Sink::ResultEmitter<typename ApplicationDomain
                 Q_ASSERT(ret);
                 monitoredResources->insert(resource.identifier());
             }
-
-            //Figure out overall status
-            auto s = resourceAccess->getResourceStatus();
-            switch (s) {
-                case ApplicationDomain::ErrorStatus:
-                    status = ApplicationDomain::ErrorStatus;
-                    break;
-                case ApplicationDomain::OfflineStatus:
-                    if (status == ApplicationDomain::ConnectedStatus) {
-                        status = ApplicationDomain::OfflineStatus;
-                    }
-                    break;
-                case ApplicationDomain::ConnectedStatus:
-                    break;
-                case ApplicationDomain::BusyStatus:
-                    if (status != ApplicationDomain::ErrorStatus) {
-                        status = ApplicationDomain::BusyStatus;
-                    }
-                    break;
-            }
+            states << resourceAccess->getResourceStatus();
         }
+        const auto status = [&] {
+            if (states.contains(ApplicationDomain::ErrorStatus)) {
+                return ApplicationDomain::ErrorStatus;
+            }
+            if (states.contains(ApplicationDomain::BusyStatus)) {
+                return ApplicationDomain::BusyStatus;
+            }
+            if (states.contains(ApplicationDomain::ConnectedStatus)) {
+                return ApplicationDomain::ConnectedStatus;
+            }
+            return ApplicationDomain::OfflineStatus;
+        }();
         account.setStatusStatus(status);
     });
     return qMakePair(KAsync::null<void>(), runner->emitter());