emitNotification function

3 files changed, 19 insertions, 34 deletions

diff --git a/common/synchronizer.cpp b/common/synchronizer.cpp
index c7c0af5..ff13783 100644
--- a/common/synchronizer.cpp
+++ b/common/synchronizer.cpp
@@ -292,6 +292,16 @@ void Synchronizer::flushComplete(const QByteArray &flushId)
     }
 }
 
+void Synchronizer::emitNotification(Notification::NoticationType type, int code, const QString &message, const QByteArray &id)
+{
+    Sink::Notification n;
+    n.id = id;
+    n.type = type;
+    n.message = message;
+    n.code = code;
+    emit notify(n);
+}
+
 KAsync::Job<void> Synchronizer::processRequest(const SyncRequest &request)
 {
     if (request.options & SyncRequest::RequestFlush) {
@@ -316,13 +326,8 @@ KAsync::Job<void> Synchronizer::processRequest(const SyncRequest &request)
         });
     } else if (request.requestType == Synchronizer::SyncRequest::Synchronization) {
         return KAsync::start([this, request] {
-            Sink::Notification n;
-            n.id = request.requestId;
-            n.type = Notification::Status;
-            n.message = "Synchronization has started.";
-            n.code = ApplicationDomain::BusyStatus;
-            emit notify(n);
             SinkLogCtx(mLogCtx) << "Synchronizing: " << request.query;
+            emitNotification(Notification::Status, ApplicationDomain::BusyStatus, "Synchronization has started.", request.requestId);
         }).then(synchronizeWithSource(request.query)).then([this] {
             //Commit after every request, so implementations only have to commit more if they add a lot of data.
             commit();
@@ -330,21 +335,11 @@ KAsync::Job<void> Synchronizer::processRequest(const SyncRequest &request)
             if (error) {
                 //Emit notification with error
                 SinkWarningCtx(mLogCtx) << "Synchronization failed: " << error.errorMessage;
-                Sink::Notification n;
-                n.id = request.requestId;
-                n.type = Notification::Status;
-                n.message = "Synchronization has ended.";
-                n.code = ApplicationDomain::ErrorStatus;
-                emit notify(n);
+                emitNotification(Notification::Status, ApplicationDomain::ErrorStatus, "Synchronization has ended.", request.requestId);
                 return KAsync::error(error);
             } else {
                 SinkLogCtx(mLogCtx) << "Done Synchronizing";
-                Sink::Notification n;
-                n.id = request.requestId;
-                n.type = Notification::Status;
-                n.message = "Synchronization has ended.";
-                n.code = ApplicationDomain::ConnectedStatus;
-                emit notify(n);
+                emitNotification(Notification::Status, ApplicationDomain::ConnectedStatus, "Synchronization has ended.", request.requestId);
                 return KAsync::null();
             }
         });
@@ -354,10 +349,7 @@ KAsync::Job<void> Synchronizer::processRequest(const SyncRequest &request)
             //FIXME it looks like this is emitted before the replay actually finishes
             if (request.flushType == Flush::FlushReplayQueue) {
                 SinkTraceCtx(mLogCtx) << "Emitting flush completion: " << request.requestId;
-                Sink::Notification n;
-                n.type = Sink::Notification::FlushCompletion;
-                n.id = request.requestId;
-                emit notify(n);
+                emitNotification(Notification::FlushCompletion, 0, "", request.requestId);
             } else {
                 flatbuffers::FlatBufferBuilder fbb;
                 auto flushId = fbb.CreateString(request.requestId.toStdString());
diff --git a/common/synchronizer.h b/common/synchronizer.h
index 45ec9e7..28fe645 100644
--- a/common/synchronizer.h
+++ b/common/synchronizer.h
@@ -180,8 +180,11 @@ protected:
      */
     virtual void mergeIntoQueue(const Synchronizer::SyncRequest &request, QList<Synchronizer::SyncRequest> &queue);
 
+    void emitNotification(Notification::NoticationType type, int code, const QString &message, const QByteArray &id = QByteArray{});
+
 protected:
     Sink::Log::Context mLogCtx;
+
 private:
     void modifyIfChanged(Storage::EntityStore &store, const QByteArray &bufferType, const QByteArray &sinkId, const Sink::ApplicationDomain::ApplicationDomainType &entity);
     KAsync::Job<void> processRequest(const SyncRequest &request);
diff --git a/examples/mailtransportresource/mailtransportresource.cpp b/examples/mailtransportresource/mailtransportresource.cpp
index a6460f1..72fe59d 100644
--- a/examples/mailtransportresource/mailtransportresource.cpp
+++ b/examples/mailtransportresource/mailtransportresource.cpp
@@ -81,20 +81,10 @@ public:
                 }
                 if (!MailTransport::sendMessage(msg, settings.server.toUtf8(), settings.username.toUtf8(), settings.password.toUtf8(), settings.cacert.toUtf8(), options)) {
                     SinkWarning() << "Failed to send message: " << mail;
-                    //Emit  failure notification
-                    Sink::Notification n;
-                    n.type = Notification::Warning;
-                    n.message = "Failed to send message.";
-                    n.code = Notification::TransmissionFailed;
-                    emit notify(n);
+                    emitNotification(Notification::Warning, Notification::TransmissionFailed, "Failed to send message.");
                     return KAsync::error("Failed to send the message.");
                 } else {
-                    //Emit success notification
-                    Sink::Notification n;
-                    n.type = Notification::Info;
-                    n.message = "Message successfully sent.";
-                    n.code = Notification::TransmissionSucceeded;
-                    emit notify(n);
+                    emitNotification(Notification::Info, Notification::TransmissionSucceeded, "Message successfully sent.");
                 }
             }
             syncStore().writeValue(mail.identifier(), "sent");