refactor: reduce code duplication of gnupg operations

10 files changed, 503 insertions, 435 deletions

diff --git a/src/core/function/gpg/GpgBasicOperator.cpp b/src/core/function/gpg/GpgBasicOperator.cpp
index 55f08854..fe84336d 100644
--- a/src/core/function/gpg/GpgBasicOperator.cpp
+++ b/src/core/function/gpg/GpgBasicOperator.cpp
@@ -72,8 +72,10 @@ auto EncryptImpl(GpgContext& ctx_, const KeyArgsList& keys,
   auto err = CheckGpgError(
       gpgme_op_encrypt(ctx, keys.isEmpty() ? nullptr : recipients.data(),
                        GPGME_ENCRYPT_ALWAYS_TRUST, data_in, data_out));
-  data_object->Swap({GpgEncryptResult(gpgme_op_encrypt_result(ctx)),
-                     data_out.Read2GFBuffer()});
+  data_object->Swap({
+      GpgEncryptResult(gpgme_op_encrypt_result(ctx)),
+      data_out.Read2GFBuffer(),
+  });
 
   return err;
 }
@@ -124,9 +126,10 @@ auto DecryptImpl(GpgContext& ctx_, const GFBuffer& in_buffer,
 
   auto err =
       CheckGpgError(gpgme_op_decrypt(ctx_.DefaultContext(), data_in, data_out));
-  data_object->Swap(
-      {GpgDecryptResult(gpgme_op_decrypt_result(ctx_.DefaultContext())),
-       data_out.Read2GFBuffer()});
+  data_object->Swap({
+      GpgDecryptResult(gpgme_op_decrypt_result(ctx_.DefaultContext())),
+      data_out.Read2GFBuffer(),
+  });
 
   return err;
 }
@@ -168,6 +171,7 @@ auto VerifyImpl(GpgContext& ctx_, const GFBuffer& in_buffer,
 
   data_object->Swap({
       GpgVerifyResult(gpgme_op_verify_result(ctx_.DefaultContext())),
+      GFBuffer(),
   });
 
   return err;
@@ -209,8 +213,10 @@ auto SignImpl(GpgContext& ctx_, const KeyArgsList& signers,
   auto* ctx = ascii ? ctx_.DefaultContext() : ctx_.BinaryContext();
   err = CheckGpgError(gpgme_op_sign(ctx, data_in, data_out, mode));
 
-  data_object->Swap(
-      {GpgSignResult(gpgme_op_sign_result(ctx)), data_out.Read2GFBuffer()});
+  data_object->Swap({
+      GpgSignResult(gpgme_op_sign_result(ctx)),
+      data_out.Read2GFBuffer(),
+  });
   return err;
 }
 
@@ -244,10 +250,11 @@ auto DecryptVerifyImpl(GpgContext& ctx_, const GFBuffer& in_buffer,
   err = CheckGpgError(
       gpgme_op_decrypt_verify(ctx_.DefaultContext(), data_in, data_out));
 
-  data_object->Swap(
-      {GpgDecryptResult(gpgme_op_decrypt_result(ctx_.DefaultContext())),
-       GpgVerifyResult(gpgme_op_verify_result(ctx_.DefaultContext())),
-       data_out.Read2GFBuffer()});
+  data_object->Swap({
+      GpgDecryptResult(gpgme_op_decrypt_result(ctx_.DefaultContext())),
+      GpgVerifyResult(gpgme_op_verify_result(ctx_.DefaultContext())),
+      data_out.Read2GFBuffer(),
+  });
 
   return err;
 }
@@ -290,9 +297,11 @@ auto EncryptSignImpl(GpgContext& ctx_, const KeyArgsList& keys,
   err = CheckGpgError(gpgme_op_encrypt_sign(
       ctx, recipients.data(), GPGME_ENCRYPT_ALWAYS_TRUST, data_in, data_out));
 
-  data_object->Swap({GpgEncryptResult(gpgme_op_encrypt_result(ctx)),
-                     GpgSignResult(gpgme_op_sign_result(ctx)),
-                     data_out.Read2GFBuffer()});
+  data_object->Swap({
+      GpgEncryptResult(gpgme_op_encrypt_result(ctx)),
+      GpgSignResult(gpgme_op_sign_result(ctx)),
+      data_out.Read2GFBuffer(),
+  });
   return err;
 }
 
diff --git a/src/ui/function/GpgOperaHelper.cpp b/src/ui/function/GpgOperaHelper.cpp
index 35c4ba35..f762996d 100644
--- a/src/ui/function/GpgOperaHelper.cpp
+++ b/src/ui/function/GpgOperaHelper.cpp
@@ -48,10 +48,18 @@ void GpgOperaHelper::BuildOperas(QSharedPointer<GpgOperaContextBasement>& base,
   auto context = GetGpgOperaContextFromBasement(base, category);
   if (context == nullptr) return;
 
-  assert(context->paths.size() == context->o_paths.size());
+  if (!context->paths.isEmpty()) {
+    assert(context->paths.size() == context->o_paths.size());
 
-  for (int i = 0; i < context->paths.size(); i++) {
-    context->base->operas.push_back(f(context, channel, i));
+    for (int i = 0; i < context->paths.size(); i++) {
+      context->base->operas.push_back(f(context, channel, i));
+    }
+  }
+
+  if (!context->buffers.isEmpty()) {
+    for (int i = 0; i < context->buffers.size(); i++) {
+      context->base->operas.push_back(f(context, channel, i));
+    }
   }
 }
 
@@ -147,8 +155,92 @@ auto GpgOperaHelper::BuildComplexGpgFileOperasHelper(
   };
 }
 
+template <typename ResultType, typename AnalyseType, typename OperaFunc>
+auto GpgOperaHelper::BuildSimpleGpgOperasHelper(
+    QSharedPointer<GpgOperaContext>& context, int channel, int index,
+    OperaFunc opera_func) -> OperaWaitingCb {
+  const auto& buffer = context->buffers[index];
+  auto& opera_results = context->base->opera_results;
+
+  return [=, &opera_results](const OperaWaitingHd& op_hd) {
+    opera_func(buffer, [=, &opera_results](GpgError err,
+                                           const DataObjectPtr& data_obj) {
+      // stop waiting
+      op_hd();
+
+      if (CheckGpgError(err) == GPG_ERR_USER_1 || data_obj == nullptr ||
+          !data_obj->Check<ResultType, GFBuffer>()) {
+        opera_results.append({-1, "# " + tr("Critical Error"), {}});
+        return;
+      }
+
+      auto result = ExtractParams<ResultType>(data_obj, 0);
+
+      auto result_analyse = AnalyseType(channel, err, result);
+      result_analyse.Analyse();
+
+      HandleExtraLogicIfNeeded(context, result_analyse);
+
+      auto opera_result = GpgOperaResult{
+          result_analyse.GetStatus(), result_analyse.GetResultReport(), {}};
+
+      auto o_buffer = ExtractParams<GFBuffer>(data_obj, 1);
+      opera_result.o_buffer = o_buffer;
+
+      opera_results.append(opera_result);
+    });
+  };
+}
+
+template <typename ResultTypeA, typename AnalyseTypeA, typename ResultTypeB,
+          typename AnalyseTypeB, typename OperaFunc>
+auto GpgOperaHelper::BuildComplexGpgOperasHelper(
+    QSharedPointer<GpgOperaContext>& context, int channel, int index,
+    OperaFunc opera_func) -> OperaWaitingCb {
+  const auto& buffer = context->buffers[index];
+  auto& opera_results = context->base->opera_results;
+
+  return [=, &opera_results](const OperaWaitingHd& op_hd) {
+    opera_func(buffer, [=, &opera_results](GpgError err,
+                                           const DataObjectPtr& data_obj) {
+      // stop waiting
+      op_hd();
+
+      if (CheckGpgError(err) == GPG_ERR_USER_1 || data_obj == nullptr ||
+          !data_obj->Check<ResultTypeA, ResultTypeB, GFBuffer>()) {
+        opera_results.append({-1, "# " + tr("Critical Error"), {}});
+        return;
+      }
+
+      auto result_1 = ExtractParams<ResultTypeA>(data_obj, 0);
+      auto result_2 = ExtractParams<ResultTypeB>(data_obj, 1);
+
+      auto result_analyse_1 = AnalyseTypeA(channel, err, result_1);
+      result_analyse_1.Analyse();
+
+      HandleExtraLogicIfNeeded(context, result_analyse_1);
+
+      auto result_analyse_2 = AnalyseTypeB(channel, err, result_2);
+      result_analyse_2.Analyse();
+
+      HandleExtraLogicIfNeeded(context, result_analyse_2);
+
+      auto opera_result = GpgOperaResult{
+          std::min(result_analyse_1.GetStatus(), result_analyse_2.GetStatus()),
+          result_analyse_1.GetResultReport() +
+              result_analyse_2.GetResultReport(),
+          {}};
+
+      auto o_buffer = ExtractParams<GFBuffer>(data_obj, 2);
+      opera_result.o_buffer = o_buffer;
+
+      opera_results.append(opera_result);
+    });
+  };
+}
+
 template <typename EncryptFuncSymmetric, typename EncryptFuncKeys>
-auto BuildOperasEncryptHelper(
+auto BuildOperasFileEncryptHelper(
     QSharedPointer<GpgOperaContext>& context, int channel, int index,
     EncryptFuncSymmetric encrypt_symmetric,
     EncryptFuncKeys encrypt_with_keys) -> OperaWaitingCb {
@@ -169,10 +261,32 @@ auto BuildOperasEncryptHelper(
       });
 }
 
+template <typename EncryptFuncSymmetric, typename EncryptFuncKeys>
+auto BuildOperasEncryptHelper(
+    QSharedPointer<GpgOperaContext>& context, int channel, int index,
+    EncryptFuncSymmetric encrypt_symmetric,
+    EncryptFuncKeys encrypt_with_keys) -> OperaWaitingCb {
+  if (context->base->keys.isEmpty()) {
+    return GpgOperaHelper::BuildSimpleGpgOperasHelper<GpgEncryptResult,
+                                                      GpgEncryptResultAnalyse>(
+        context, channel, index,
+        [=](const GFBuffer& buffer, const auto& callback) {
+          encrypt_symmetric(buffer, callback);
+        });
+  }
+
+  return GpgOperaHelper::BuildSimpleGpgOperasHelper<GpgEncryptResult,
+                                                    GpgEncryptResultAnalyse>(
+      context, channel, index,
+      [=](const GFBuffer& buffer, const auto& callback) {
+        encrypt_with_keys(buffer, callback);
+      });
+}
+
 auto GpgOperaHelper::BuildOperasFileEncrypt(
     QSharedPointer<GpgOperaContext>& context, int channel,
     int index) -> OperaWaitingCb {
-  return BuildOperasEncryptHelper(
+  return BuildOperasFileEncryptHelper(
       context, channel, index,
       [context, channel](const QString& path, const QString& o_path,
                          const auto& callback) {
@@ -189,7 +303,7 @@ auto GpgOperaHelper::BuildOperasFileEncrypt(
 auto GpgOperaHelper::BuildOperasDirectoryEncrypt(
     QSharedPointer<GpgOperaContext>& context, int channel,
     int index) -> OperaWaitingCb {
-  return BuildOperasEncryptHelper(
+  return BuildOperasFileEncryptHelper(
       context, channel, index,
       [context, channel](const QString& path, const QString& o_path,
                          const auto& callback) {
@@ -313,6 +427,8 @@ auto GpgOperaHelper::BuildOperasArchiveDecryptVerify(
 void GpgOperaHelper::WaitForMultipleOperas(
     QWidget* parent, const QString& title,
     const QContainer<OperaWaitingCb>& operas) {
+  if (operas.isEmpty()) return;
+
   QEventLoop looper;
   QPointer<WaitingDialog> const dialog = new WaitingDialog(title, true, parent);
   connect(dialog, &QDialog::finished, &looper, &QEventLoop::quit);
@@ -343,4 +459,75 @@ void GpgOperaHelper::WaitForMultipleOperas(
 
   looper.exec();
 }
+
+auto GpgOperaHelper::BuildOperasEncrypt(
+    QSharedPointer<GpgOperaContext>& context, int channel,
+    int index) -> OperaWaitingCb {
+  return BuildOperasEncryptHelper(
+      context, channel, index,
+      [context, channel](const GFBuffer& buffer, const auto& callback) {
+        GpgBasicOperator::GetInstance(channel).EncryptSymmetric(
+            buffer, context->base->ascii, callback);
+      },
+      [context, channel](const GFBuffer& buffer, const auto& callback) {
+        GpgBasicOperator::GetInstance(channel).Encrypt(
+            context->base->keys, buffer, context->base->ascii, callback);
+      });
+}
+
+auto GpgOperaHelper::BuildOperasDecrypt(
+    QSharedPointer<GpgOperaContext>& context, int channel,
+    int index) -> OperaWaitingCb {
+  return BuildSimpleGpgOperasHelper<GpgDecryptResult, GpgDecryptResultAnalyse>(
+      context, channel, index,
+      [channel](const GFBuffer& buffer, const auto& callback) {
+        GpgBasicOperator::GetInstance(channel).Decrypt(buffer, callback);
+      });
+}
+
+auto GpgOperaHelper::BuildOperasSign(QSharedPointer<GpgOperaContext>& context,
+                                     int channel, int index) -> OperaWaitingCb {
+  return BuildSimpleGpgOperasHelper<GpgSignResult, GpgSignResultAnalyse>(
+      context, channel, index,
+      [channel, context](const GFBuffer& buffer, const auto& callback) {
+        GpgBasicOperator::GetInstance(channel).Sign(
+            context->base->keys, buffer, GPGME_SIG_MODE_CLEAR,
+            context->base->ascii, callback);
+      });
+}
+
+auto GpgOperaHelper::BuildOperasVerify(QSharedPointer<GpgOperaContext>& context,
+                                       int channel,
+                                       int index) -> OperaWaitingCb {
+  return BuildSimpleGpgOperasHelper<GpgVerifyResult, GpgVerifyResultAnalyse>(
+      context, channel, index,
+      [channel, context](const GFBuffer& buffer, const auto& callback) {
+        GpgBasicOperator::GetInstance(channel).Verify(buffer, GFBuffer(),
+                                                      callback);
+      });
+}
+
+auto GpgOperaHelper::BuildOperasEncryptSign(
+    QSharedPointer<GpgOperaContext>& context, int channel,
+    int index) -> OperaWaitingCb {
+  return BuildComplexGpgOperasHelper<GpgEncryptResult, GpgEncryptResultAnalyse,
+                                     GpgSignResult, GpgSignResultAnalyse>(
+      context, channel, index,
+      [channel, context](const GFBuffer& buffer, const auto& callback) {
+        GpgBasicOperator::GetInstance(channel).EncryptSign(
+            context->base->keys, context->base->singer_keys, buffer,
+            context->base->ascii, callback);
+      });
+}
+
+auto GpgOperaHelper::BuildOperasDecryptVerify(
+    QSharedPointer<GpgOperaContext>& context, int channel,
+    int index) -> OperaWaitingCb {
+  return BuildComplexGpgOperasHelper<GpgDecryptResult, GpgDecryptResultAnalyse,
+                                     GpgVerifyResult, GpgVerifyResultAnalyse>(
+      context, channel, index,
+      [channel](const GFBuffer& buffer, const auto& callback) {
+        GpgBasicOperator::GetInstance(channel).DecryptVerify(buffer, callback);
+      });
+}
 }  // namespace GpgFrontend::UI
diff --git a/src/ui/function/GpgOperaHelper.h b/src/ui/function/GpgOperaHelper.h
index ca620574..bf11b37b 100644
--- a/src/ui/function/GpgOperaHelper.h
+++ b/src/ui/function/GpgOperaHelper.h
@@ -39,11 +39,37 @@ class GpgOperaHelper : QObject {
   using GpgOperaFactory = std::function<OperaWaitingCb(
       QSharedPointer<GpgOperaContext>& context, int channel, int index)>;
 
+  /**
+   * @brief
+   *
+   * @tparam ResultType
+   * @tparam AnalyseType
+   * @tparam OperaFunc
+   * @param context
+   * @param channel
+   * @param index
+   * @param opera_func
+   * @return OperaWaitingCb
+   */
   template <typename ResultType, typename AnalyseType, typename OperaFunc>
   static auto BuildSimpleGpgFileOperasHelper(
       QSharedPointer<GpgOperaContext>& context, int channel, int index,
       OperaFunc opera_func) -> OperaWaitingCb;
 
+  /**
+   * @brief
+   *
+   * @tparam ResultTypeA
+   * @tparam AnalyseTypeA
+   * @tparam ResultTypeB
+   * @tparam AnalyseTypeB
+   * @tparam OperaFunc
+   * @param context
+   * @param channel
+   * @param index
+   * @param opera_func
+   * @return OperaWaitingCb
+   */
   template <typename ResultTypeA, typename AnalyseTypeA, typename ResultTypeB,
             typename AnalyseTypeB, typename OperaFunc>
   static auto BuildComplexGpgFileOperasHelper(
@@ -53,6 +79,43 @@ class GpgOperaHelper : QObject {
   /**
    * @brief
    *
+   * @tparam ResultType
+   * @tparam AnalyseType
+   * @tparam OperaFunc
+   * @param context
+   * @param channel
+   * @param index
+   * @param opera_func
+   * @return OperaWaitingCb
+   */
+  template <typename ResultType, typename AnalyseType, typename OperaFunc>
+  static auto BuildSimpleGpgOperasHelper(
+      QSharedPointer<GpgOperaContext>& context, int channel, int index,
+      OperaFunc opera_func) -> OperaWaitingCb;
+
+  /**
+   * @brief
+   *
+   * @tparam ResultTypeA
+   * @tparam AnalyseTypeA
+   * @tparam ResultTypeB
+   * @tparam AnalyseTypeB
+   * @tparam OperaFunc
+   * @param context
+   * @param channel
+   * @param index
+   * @param opera_func
+   * @return OperaWaitingCb
+   */
+  template <typename ResultTypeA, typename AnalyseTypeA, typename ResultTypeB,
+            typename AnalyseTypeB, typename OperaFunc>
+  static auto BuildComplexGpgOperasHelper(
+      QSharedPointer<GpgOperaContext>& context, int channel, int index,
+      OperaFunc opera_func) -> OperaWaitingCb;
+
+  /**
+   * @brief
+   *
    * @param base
    * @param category
    * @param channel
@@ -69,6 +132,17 @@ class GpgOperaHelper : QObject {
    * @param index
    * @return OperaWaitingCb
    */
+  static auto BuildOperasEncrypt(QSharedPointer<GpgOperaContext>& context,
+                                 int channel, int index) -> OperaWaitingCb;
+
+  /**
+   * @brief
+   *
+   * @param context
+   * @param channel
+   * @param index
+   * @return OperaWaitingCb
+   */
   static auto BuildOperasFileEncrypt(QSharedPointer<GpgOperaContext>& context,
                                      int channel, int index) -> OperaWaitingCb;
 
@@ -88,6 +162,17 @@ class GpgOperaHelper : QObject {
    * @brief
    *
    * @param context
+   * @param channel
+   * @param index
+   * @return OperaWaitingCb
+   */
+  static auto BuildOperasDecrypt(QSharedPointer<GpgOperaContext>& context,
+                                 int channel, int index) -> OperaWaitingCb;
+
+  /**
+   * @brief
+   *
+   * @param context
    */
   static auto BuildOperasFileDecrypt(QSharedPointer<GpgOperaContext>& context,
                                      int channel, int index) -> OperaWaitingCb;
@@ -108,6 +193,17 @@ class GpgOperaHelper : QObject {
    * @brief
    *
    * @param context
+   * @param channel
+   * @param index
+   * @return OperaWaitingCb
+   */
+  static auto BuildOperasSign(QSharedPointer<GpgOperaContext>& context,
+                              int channel, int index) -> OperaWaitingCb;
+
+  /**
+   * @brief
+   *
+   * @param context
    * @return OperaWaitingCb
    */
   static auto BuildOperasFileSign(QSharedPointer<GpgOperaContext>& context,
@@ -121,6 +217,17 @@ class GpgOperaHelper : QObject {
    * @param index
    * @return OperaWaitingCb
    */
+  static auto BuildOperasVerify(QSharedPointer<GpgOperaContext>& context,
+                                int channel, int index) -> OperaWaitingCb;
+
+  /**
+   * @brief
+   *
+   * @param context
+   * @param channel
+   * @param index
+   * @return OperaWaitingCb
+   */
   static auto BuildOperasFileVerify(QSharedPointer<GpgOperaContext>& context,
                                     int channel, int index) -> OperaWaitingCb;
 
@@ -130,6 +237,17 @@ class GpgOperaHelper : QObject {
    * @param context
    * @param channel
    * @param index
+   * @return OperaWaitingCb
+   */
+  static auto BuildOperasEncryptSign(QSharedPointer<GpgOperaContext>& context,
+                                     int channel, int index) -> OperaWaitingCb;
+
+  /**
+   * @brief
+   *
+   * @param context
+   * @param channel
+   * @param index
    */
   static auto BuildOperasFileEncryptSign(
       QSharedPointer<GpgOperaContext>& context, int channel,
@@ -155,6 +273,18 @@ class GpgOperaHelper : QObject {
    * @param index
    * @return OperaWaitingCb
    */
+  static auto BuildOperasDecryptVerify(QSharedPointer<GpgOperaContext>& context,
+                                       int channel,
+                                       int index) -> OperaWaitingCb;
+
+  /**
+   * @brief
+   *
+   * @param context
+   * @param channel
+   * @param index
+   * @return OperaWaitingCb
+   */
   static auto BuildOperasFileDecryptVerify(
       QSharedPointer<GpgOperaContext>& context, int channel,
       int index) -> OperaWaitingCb;
diff --git a/src/ui/main_window/MainWindow.h b/src/ui/main_window/MainWindow.h
index 8dbb9376..cc032f70 100644
--- a/src/ui/main_window/MainWindow.h
+++ b/src/ui/main_window/MainWindow.h
@@ -164,14 +164,6 @@ class MainWindow : public GeneralMainWindow {
   /**
    * @brief
    *
-   * @param raw_data
-   * @param signature
-   */
-  void SlotVerify(const QByteArray& raw_data, const QByteArray& signature);
-
-  /**
-   * @brief
-   *
    */
   void SlotVerifyEML();
 
@@ -634,10 +626,18 @@ class MainWindow : public GeneralMainWindow {
    * @param context
    * @return auto
    */
-  auto execute_operas_helper(
+  void exec_operas_helper(
       const QString& task,
       const QSharedPointer<GpgOperaContextBasement>& contexts);
 
+  /**
+   * @brief
+   *
+   * @param results
+   */
+  void slot_gpg_opera_buffer_show_helper(
+      const QContainer<GpgOperaResult>& results);
+
   TextEdit* edit_{};          ///< Tabwidget holding the edit-windows
   QMenu* file_menu_{};        ///<  Submenu for file-operations
   QMenu* edit_menu_{};        ///<  Submenu for text-operations
diff --git a/src/ui/main_window/MainWindowFileSlotFunction.cpp b/src/ui/main_window/MainWindowFileSlotFunction.cpp
index ba6a6ec2..b46034b7 100644
--- a/src/ui/main_window/MainWindowFileSlotFunction.cpp
+++ b/src/ui/main_window/MainWindowFileSlotFunction.cpp
@@ -131,13 +131,6 @@ auto MainWindow::check_keys_helper(
   return keys;
 }
 
-auto MainWindow::execute_operas_helper(
-    const QString& task,
-    const QSharedPointer<GpgOperaContextBasement>& contexts) {
-  GpgOperaHelper::WaitForMultipleOperas(this, task, contexts->operas);
-  slot_result_analyse_show_helper(contexts->opera_results);
-}
-
 void MainWindow::SlotFileEncrypt(const QStringList& paths) {
   auto contexts = QSharedPointer<GpgOperaContextBasement>::create();
 
@@ -191,7 +184,7 @@ void MainWindow::SlotFileEncrypt(const QStringList& paths) {
                               m_key_list_->GetCurrentGpgContextChannel(),
                               GpgOperaHelper::BuildOperasDirectoryEncrypt);
 
-  execute_operas_helper(tr("Encrypting"), contexts);
+  exec_operas_helper(tr("Encrypting"), contexts);
 }
 
 void MainWindow::SlotFileDecrypt(const QStringList& paths) {
@@ -226,7 +219,7 @@ void MainWindow::SlotFileDecrypt(const QStringList& paths) {
                               m_key_list_->GetCurrentGpgContextChannel(),
                               GpgOperaHelper::BuildOperasArchiveDecrypt);
 
-  execute_operas_helper(tr("Decrypting"), contexts);
+  exec_operas_helper(tr("Decrypting"), contexts);
 }
 
 void MainWindow::SlotFileSign(const QStringList& paths) {
@@ -260,7 +253,7 @@ void MainWindow::SlotFileSign(const QStringList& paths) {
                               m_key_list_->GetCurrentGpgContextChannel(),
                               GpgOperaHelper::BuildOperasFileSign);
 
-  execute_operas_helper(tr("Signing"), contexts);
+  exec_operas_helper(tr("Signing"), contexts);
 }
 
 void MainWindow::SlotFileVerify(const QStringList& paths) {
@@ -306,7 +299,7 @@ void MainWindow::SlotFileVerify(const QStringList& paths) {
                               m_key_list_->GetCurrentGpgContextChannel(),
                               GpgOperaHelper::BuildOperasFileVerify);
 
-  execute_operas_helper(tr("Verifying"), contexts);
+  exec_operas_helper(tr("Verifying"), contexts);
 
   if (!contexts->unknown_fprs.isEmpty()) {
     slot_verifying_unknown_signature_helper(contexts->unknown_fprs);
@@ -372,7 +365,7 @@ void MainWindow::SlotFileEncryptSign(const QStringList& paths) {
                               m_key_list_->GetCurrentGpgContextChannel(),
                               GpgOperaHelper::BuildOperasDirectoryEncryptSign);
 
-  execute_operas_helper(tr("Encrypting and Signing"), contexts);
+  exec_operas_helper(tr("Encrypting and Signing"), contexts);
 }
 
 void MainWindow::SlotFileDecryptVerify(const QStringList& paths) {
@@ -407,7 +400,7 @@ void MainWindow::SlotFileDecryptVerify(const QStringList& paths) {
                               m_key_list_->GetCurrentGpgContextChannel(),
                               GpgOperaHelper::BuildOperasArchiveDecryptVerify);
 
-  execute_operas_helper(tr("Decrypting and Verifying"), contexts);
+  exec_operas_helper(tr("Decrypting and Verifying"), contexts);
 
   if (!contexts->unknown_fprs.isEmpty()) {
     slot_verifying_unknown_signature_helper(contexts->unknown_fprs);
diff --git a/src/ui/main_window/MainWindowGpgOperaFunction.cpp b/src/ui/main_window/MainWindowGpgOperaFunction.cpp
index d9d2000f..a2daa06b 100644
--- a/src/ui/main_window/MainWindowGpgOperaFunction.cpp
+++ b/src/ui/main_window/MainWindowGpgOperaFunction.cpp
@@ -39,6 +39,8 @@
 #include "core/utils/GpgUtils.h"
 #include "ui/UserInterfaceUtils.h"
 #include "ui/dialog/SignersPicker.h"
+#include "ui/function/GpgOperaHelper.h"
+#include "ui/struct/GpgOperaResultContext.h"
 #include "ui/widgets/KeyList.h"
 #include "ui/widgets/TextEdit.h"
 
@@ -47,326 +49,115 @@ namespace GpgFrontend::UI {
 void MainWindow::SlotEncrypt() {
   if (edit_->CurPageTextEdit() == nullptr) return;
 
+  auto contexts = QSharedPointer<GpgOperaContextBasement>::create();
+  contexts->ascii = true;
+
   auto key_ids = m_key_list_->GetChecked();
 
-  if (key_ids.empty()) {
-    // Symmetric Encrypt
+  // Symmetric Encrypt
+  if (key_ids.isEmpty()) {
     auto ret = QMessageBox::information(
         this, tr("Symmetric Encryption"),
-        tr("No Key Checked. Do you want to encrypt with a "
+        tr("No Key Selected. Do you want to encrypt with a "
            "symmetric cipher using a passphrase?"),
         QMessageBox::Ok | QMessageBox::Cancel);
-
     if (ret == QMessageBox::Cancel) return;
 
-    auto buffer = GFBuffer(edit_->CurPlainText());
-    CommonUtils::WaitForOpera(
-        this, tr("Symmetrically Encrypting"),
-        [this, buffer](const OperaWaitingHd& op_hd) {
-          GpgFrontend::GpgBasicOperator::GetInstance(
-              m_key_list_->GetCurrentGpgContextChannel())
-              .EncryptSymmetric(
-                  buffer, true,
-                  [this, op_hd](GpgError err, const DataObjectPtr& data_obj) {
-                    // stop waiting
-                    op_hd();
-
-                    if (CheckGpgError(err) == GPG_ERR_USER_1 ||
-                        data_obj == nullptr ||
-                        !data_obj->Check<GpgEncryptResult, GFBuffer>()) {
-                      QMessageBox::critical(this, tr("Error"),
-                                            tr("Unknown error occurred"));
-                      return;
-                    }
-
-                    auto result = ExtractParams<GpgEncryptResult>(data_obj, 0);
-                    auto buffer = ExtractParams<GFBuffer>(data_obj, 1);
-
-                    auto result_analyse = GpgEncryptResultAnalyse(
-                        m_key_list_->GetCurrentGpgContextChannel(), err,
-                        result);
-                    result_analyse.Analyse();
-                    slot_result_analyse_show_helper(result_analyse);
-
-                    if (CheckGpgError(err) == GPG_ERR_NO_ERROR) {
-                      edit_->SlotFillTextEditWithText(
-                          buffer.ConvertToQByteArray());
-                    }
-                    info_board_->ResetOptionActionsMenu();
-                  });
-        });
-
-    return;
+    contexts->keys = {};
+  } else {
+    contexts->keys = check_keys_helper(
+        key_ids,
+        [](const GpgKey& key) { return key.IsHasActualEncryptionCapability(); },
+        tr("The selected keypair cannot be used for encryption."));
+    if (contexts->keys.empty()) return;
   }
 
-  auto keys =
-      GpgKeyGetter::GetInstance(m_key_list_->GetCurrentGpgContextChannel())
-          .GetKeys(key_ids);
-  assert(std::all_of(keys.begin(), keys.end(),
-                     [](const auto& key) { return key.IsGood(); }));
-
-  for (const auto& key : keys) {
-    if (!key.IsHasActualEncryptionCapability()) {
-      QMessageBox::information(
-          this, tr("Invalid Operation"),
-          tr("The selected key contains a key that does not actually have a "
-             "encrypt usage.") +
-              "<br/><br/>" + tr("For example the Following Key:") + " <br/>" +
-              key.GetUIDs()->front().GetUID());
-      return;
-    }
-  }
+  contexts->GetContextBuffer(0).append(GFBuffer(edit_->CurPlainText()));
+  GpgOperaHelper::BuildOperas(contexts, 0,
+                              m_key_list_->GetCurrentGpgContextChannel(),
+                              GpgOperaHelper::BuildOperasEncrypt);
 
-  auto buffer = GFBuffer(edit_->CurPlainText());
-  CommonUtils::WaitForOpera(
-      this, tr("Encrypting"),
-      [this, keys, buffer](const OperaWaitingHd& op_hd) {
-        GpgFrontend::GpgBasicOperator::GetInstance(
-            m_key_list_->GetCurrentGpgContextChannel())
-            .Encrypt(
-                {keys.begin(), keys.end()}, buffer, true,
-                [this, op_hd](GpgError err, const DataObjectPtr& data_obj) {
-                  // stop waiting
-                  op_hd();
-
-                  if (data_obj == nullptr ||
-                      !data_obj->Check<GpgEncryptResult, GFBuffer>()) {
-                    QMessageBox::critical(this, tr("Error"),
-                                          tr("Unknown error occurred"));
-                    return;
-                  }
-
-                  auto result = ExtractParams<GpgEncryptResult>(data_obj, 0);
-                  auto buffer = ExtractParams<GFBuffer>(data_obj, 1);
-
-                  auto result_analyse = GpgEncryptResultAnalyse(
-                      m_key_list_->GetCurrentGpgContextChannel(), err, result);
-                  result_analyse.Analyse();
-                  slot_result_analyse_show_helper(result_analyse);
-
-                  if (CheckGpgError(err) == GPG_ERR_NO_ERROR) {
-                    edit_->SlotFillTextEditWithText(
-                        buffer.ConvertToQByteArray());
-                  }
-                  info_board_->ResetOptionActionsMenu();
-                });
-      });
+  exec_operas_helper(tr("Encrypting"), contexts);
 }
 
 void MainWindow::SlotSign() {
   if (edit_->CurPageTextEdit() == nullptr) return;
 
-  auto key_ids = m_key_list_->GetCheckedPrivateKey();
-  if (key_ids.empty()) {
-    QMessageBox::critical(
-        this, tr("No Key Checked"),
-        tr("Please check the key in the key toolbox on the right."));
-    return;
-  }
-
-  auto keys =
-      GpgKeyGetter::GetInstance(m_key_list_->GetCurrentGpgContextChannel())
-          .GetKeys(key_ids);
-  assert(std::all_of(keys.begin(), keys.end(),
-                     [](const auto& key) { return key.IsGood(); }));
+  auto contexts = QSharedPointer<GpgOperaContextBasement>::create();
+  contexts->ascii = true;
 
-  for (const auto& key : keys) {
-    if (!key.IsHasActualSigningCapability()) {
-      QMessageBox::information(
-          this, tr("Invalid Operation"),
-          tr("The selected key contains a key that does not actually have a "
-             "signature usage.") +
-              "<br/><br/>" + tr("For example the Following Key:") + "<br/>" +
-              key.GetUIDs()->front().GetUID());
-      return;
-    }
-  }
-
-  // set input buffer
-  auto buffer = GFBuffer(edit_->CurPlainText());
-  CommonUtils::WaitForOpera(
-      this, tr("Signing"), [this, keys, buffer](const OperaWaitingHd& hd) {
-        GpgFrontend::GpgBasicOperator::GetInstance(
-            m_key_list_->GetCurrentGpgContextChannel())
-            .Sign(
-                {keys.begin(), keys.end()}, buffer, GPGME_SIG_MODE_CLEAR, true,
-                [this, hd](GpgError err, const DataObjectPtr& data_obj) {
-                  // stop waiting
-                  hd();
-
-                  if (CheckGpgError(err) == GPG_ERR_USER_1 ||
-                      data_obj == nullptr ||
-                      !data_obj->Check<GpgSignResult, GFBuffer>()) {
-                    QMessageBox::critical(this, tr("Error"),
-                                          tr("Unknown error occurred"));
-                    return;
-                  }
-                  auto sign_result = ExtractParams<GpgSignResult>(data_obj, 0);
-                  auto sign_out_buffer = ExtractParams<GFBuffer>(data_obj, 1);
-                  auto result_analyse = GpgSignResultAnalyse(
-                      m_key_list_->GetCurrentGpgContextChannel(), err,
-                      sign_result);
-                  result_analyse.Analyse();
-                  slot_result_analyse_show_helper(result_analyse);
-
-                  if (CheckGpgError(err) == GPG_ERR_NO_ERROR) {
-                    edit_->SlotFillTextEditWithText(
-                        sign_out_buffer.ConvertToQByteArray());
-                  }
-                });
-      });
+  auto key_ids = m_key_list_->GetChecked();
+  contexts->keys = check_keys_helper(
+      key_ids,
+      [](const GpgKey& key) { return key.IsHasActualSigningCapability(); },
+      tr("The selected key contains a key that does not actually have a "
+         "sign usage."));
+  if (contexts->keys.empty()) return;
+
+  contexts->GetContextBuffer(0).append(GFBuffer(edit_->CurPlainText()));
+  GpgOperaHelper::BuildOperas(contexts, 0,
+                              m_key_list_->GetCurrentGpgContextChannel(),
+                              GpgOperaHelper::BuildOperasSign);
+
+  exec_operas_helper(tr("Signing"), contexts);
 }
 
 void MainWindow::SlotDecrypt() {
   if (edit_->CurPageTextEdit() == nullptr) return;
 
-  // data to transfer into task
-  auto buffer = GFBuffer(edit_->CurPlainText());
-
-  CommonUtils::WaitForOpera(
-      this, tr("Decrypting"), [this, buffer](const OperaWaitingHd& hd) {
-        GpgFrontend::GpgBasicOperator::GetInstance(
-            m_key_list_->GetCurrentGpgContextChannel())
-            .Decrypt(buffer, [this, hd](GpgError err,
-                                        const DataObjectPtr& data_obj) {
-              // stop waiting
-              hd();
-
-              if (CheckGpgError(err) == GPG_ERR_USER_1 || data_obj == nullptr ||
-                  !data_obj->Check<GpgDecryptResult, GFBuffer>()) {
-                QMessageBox::critical(this, tr("Error"),
-                                      tr("Unknown error occurred"));
-                return;
-              }
-              auto decrypt_result =
-                  ExtractParams<GpgDecryptResult>(data_obj, 0);
-              auto out_buffer = ExtractParams<GFBuffer>(data_obj, 1);
-              auto result_analyse = GpgDecryptResultAnalyse(
-                  m_key_list_->GetCurrentGpgContextChannel(), err,
-                  decrypt_result);
-              result_analyse.Analyse();
-              slot_result_analyse_show_helper(result_analyse);
-
-              if (CheckGpgError(err) == GPG_ERR_NO_ERROR) {
-                edit_->SlotFillTextEditWithText(
-                    out_buffer.ConvertToQByteArray());
-              }
-            });
-      });
+  auto contexts = QSharedPointer<GpgOperaContextBasement>::create();
+  contexts->ascii = true;
+
+  contexts->GetContextBuffer(0).append(GFBuffer(edit_->CurPlainText()));
+  GpgOperaHelper::BuildOperas(contexts, 0,
+                              m_key_list_->GetCurrentGpgContextChannel(),
+                              GpgOperaHelper::BuildOperasDecrypt);
+
+  exec_operas_helper(tr("Decrypting"), contexts);
 }
 
 void MainWindow::SlotVerify() {
   if (edit_->CurPageTextEdit() == nullptr) return;
 
-  // set input buffer
-  auto buffer = GFBuffer(edit_->CurPlainText());
-
-  CommonUtils::WaitForOpera(
-      this, tr("Verifying"), [this, buffer](const OperaWaitingHd& hd) {
-        GpgFrontend::GpgBasicOperator::GetInstance(
-            m_key_list_->GetCurrentGpgContextChannel())
-            .Verify(buffer, GFBuffer(),
-                    [this, hd](GpgError err, const DataObjectPtr& data_obj) {
-                      // stop waiting
-                      hd();
-
-                      if (CheckGpgError(err) == GPG_ERR_USER_1 ||
-                          data_obj == nullptr ||
-                          !data_obj->Check<GpgVerifyResult>()) {
-                        QMessageBox::critical(this, tr("Error"),
-                                              tr("Unknown error occurred"));
-                        return;
-                      }
-                      auto verify_result =
-                          ExtractParams<GpgVerifyResult>(data_obj, 0);
-
-                      // analyse result
-                      auto result_analyse = GpgVerifyResultAnalyse(
-                          m_key_list_->GetCurrentGpgContextChannel(), err,
-                          verify_result);
-                      result_analyse.Analyse();
-                      slot_result_analyse_show_helper(result_analyse);
-
-                      if (!result_analyse.GetUnknownSignatures().isEmpty() &&
-                          Module::IsModuleActivate(kKeyServerSyncModuleID)) {
-                        slot_verifying_unknown_signature_helper(
-                            result_analyse.GetUnknownSignatures());
-                      }
-                    });
-      });
-}
+  auto contexts = QSharedPointer<GpgOperaContextBasement>::create();
+  contexts->ascii = true;
+
+  contexts->GetContextBuffer(0).append(GFBuffer(edit_->CurPlainText()));
+  GpgOperaHelper::BuildOperas(contexts, 0,
+                              m_key_list_->GetCurrentGpgContextChannel(),
+                              GpgOperaHelper::BuildOperasVerify);
 
-void MainWindow::SlotVerify(const QByteArray& raw_data,
-                            const QByteArray& signature) {
-  // set input buffer
-  auto raw_data_buffer = GFBuffer(raw_data);
-  auto signature_buffer = GFBuffer(signature);
-
-  CommonUtils::WaitForOpera(
-      this, tr("Verifying"),
-      [this, raw_data_buffer, signature_buffer](const OperaWaitingHd& hd) {
-        GpgFrontend::GpgBasicOperator::GetInstance(
-            m_key_list_->GetCurrentGpgContextChannel())
-            .Verify(raw_data_buffer, signature_buffer,
-                    [this, hd](GpgError err, const DataObjectPtr& data_obj) {
-                      // stop waiting
-                      hd();
-
-                      if (CheckGpgError(err) == GPG_ERR_USER_1 ||
-                          data_obj == nullptr ||
-                          !data_obj->Check<GpgVerifyResult>()) {
-                        QMessageBox::critical(this, tr("Error"),
-                                              tr("Unknown error occurred"));
-                        return;
-                      }
-                      auto verify_result =
-                          ExtractParams<GpgVerifyResult>(data_obj, 0);
-
-                      // analyse result
-                      auto result_analyse = GpgVerifyResultAnalyse(
-                          m_key_list_->GetCurrentGpgContextChannel(), err,
-                          verify_result);
-                      result_analyse.Analyse();
-                      slot_result_analyse_show_helper(result_analyse);
-
-                      if (!result_analyse.GetUnknownSignatures().isEmpty() &&
-                          Module::IsModuleActivate(kKeyServerSyncModuleID)) {
-                        slot_verifying_unknown_signature_helper(
-                            result_analyse.GetUnknownSignatures());
-                      }
-                    });
-      });
+  exec_operas_helper(tr("Verifying"), contexts);
+
+  if (!contexts->unknown_fprs.isEmpty()) {
+    slot_verifying_unknown_signature_helper(contexts->unknown_fprs);
+  }
 }
 
 void MainWindow::SlotEncryptSign() {
   if (edit_->CurPageTextEdit() == nullptr) return;
 
-  auto key_ids = m_key_list_->GetChecked();
+  auto contexts = QSharedPointer<GpgOperaContextBasement>::create();
+  contexts->ascii = true;
 
-  if (key_ids.empty()) {
-    QMessageBox::critical(
-        this, tr("No Key Checked"),
-        tr("Please check some key in the key toolbox on the right."));
-    return;
-  }
+  auto key_ids = m_key_list_->GetChecked();
 
-  auto keys =
-      GpgKeyGetter::GetInstance(m_key_list_->GetCurrentGpgContextChannel())
-          .GetKeys(key_ids);
-  assert(std::all_of(keys.begin(), keys.end(),
-                     [](const auto& key) { return key.IsGood(); }));
+  // Symmetric Encrypt
+  if (key_ids.isEmpty()) {
+    auto ret = QMessageBox::information(
+        this, tr("Symmetric Encryption"),
+        tr("No Key Selected. Do you want to encrypt with a "
+           "symmetric cipher using a passphrase?"),
+        QMessageBox::Ok | QMessageBox::Cancel);
+    if (ret == QMessageBox::Cancel) return;
 
-  for (const auto& key : keys) {
-    bool key_can_encrypt = key.IsHasActualEncryptionCapability();
-
-    if (!key_can_encrypt) {
-      QMessageBox::critical(
-          this, tr("Invalid KeyPair"),
-          tr("The selected keypair cannot be used for encryption.") +
-              "<br/><br/>" + tr("For example the Following Key:") + " <br/>" +
-              key.GetUIDs()->front().GetUID());
-      return;
-    }
+    contexts->keys = {};
+  } else {
+    contexts->keys = check_keys_helper(
+        key_ids,
+        [](const GpgKey& key) { return key.IsHasActualEncryptionCapability(); },
+        tr("The selected keypair cannot be used for encryption."));
+    if (contexts->keys.empty()) return;
   }
 
   auto* signers_picker =
@@ -382,116 +173,35 @@ void MainWindow::SlotEncryptSign() {
   auto signer_keys =
       GpgKeyGetter::GetInstance(m_key_list_->GetCurrentGpgContextChannel())
           .GetKeys(signer_key_ids);
-  for (const auto& key : signer_keys) {
-    assert(key.IsGood());
-  }
+  assert(std::all_of(signer_keys.begin(), signer_keys.end(),
+                     [](const auto& key) { return key.IsGood(); }));
+
+  contexts->singer_keys = signer_keys;
+
+  contexts->GetContextBuffer(0).append(GFBuffer(edit_->CurPlainText()));
+  GpgOperaHelper::BuildOperas(contexts, 0,
+                              m_key_list_->GetCurrentGpgContextChannel(),
+                              GpgOperaHelper::BuildOperasEncryptSign);
 
-  // data to transfer into task
-  auto buffer = GFBuffer(edit_->CurPlainText());
-
-  CommonUtils::WaitForOpera(
-      this, tr("Encrypting and Signing"),
-      [this, keys, signer_keys, buffer](const OperaWaitingHd& hd) {
-        GpgFrontend::GpgBasicOperator::GetInstance(
-            m_key_list_->GetCurrentGpgContextChannel())
-            .EncryptSign(
-                {keys.begin(), keys.end()},
-                {signer_keys.begin(), signer_keys.end()}, buffer, true,
-                [this, hd](GpgError err, const DataObjectPtr& data_obj) {
-                  // stop waiting
-                  hd();
-
-                  if (CheckGpgError(err) == GPG_ERR_USER_1 ||
-                      data_obj == nullptr ||
-                      !data_obj->Check<GpgEncryptResult, GpgSignResult,
-                                       GFBuffer>()) {
-                    QMessageBox::critical(this, tr("Error"),
-                                          tr("Unknown error occurred"));
-                    return;
-                  }
-                  auto encrypt_result =
-                      ExtractParams<GpgEncryptResult>(data_obj, 0);
-                  auto sign_result = ExtractParams<GpgSignResult>(data_obj, 1);
-                  auto out_buffer = ExtractParams<GFBuffer>(data_obj, 2);
-
-                  // analyse result
-                  auto encrypt_result_analyse = GpgEncryptResultAnalyse(
-                      m_key_list_->GetCurrentGpgContextChannel(), err,
-                      encrypt_result);
-                  encrypt_result_analyse.Analyse();
-
-                  auto sign_result_analyse = GpgSignResultAnalyse(
-                      m_key_list_->GetCurrentGpgContextChannel(), err,
-                      sign_result);
-                  sign_result_analyse.Analyse();
-
-                  // show analyse result
-                  slot_result_analyse_show_helper(encrypt_result_analyse,
-                                                  sign_result_analyse);
-
-                  if (CheckGpgError(err) == GPG_ERR_NO_ERROR) {
-                    edit_->SlotFillTextEditWithText(
-                        out_buffer.ConvertToQByteArray());
-                  }
-                });
-      });
+  exec_operas_helper(tr("Encrypting and Signing"), contexts);
 }
 
 void MainWindow::SlotDecryptVerify() {
   if (edit_->CurPageTextEdit() == nullptr) return;
 
-  // data to transfer into task
-  auto buffer = GFBuffer(edit_->CurPlainText());
-
-  CommonUtils::WaitForOpera(
-      this, tr("Decrypting and Verifying"),
-      [this, buffer](const OperaWaitingHd& hd) {
-        GpgFrontend::GpgBasicOperator::GetInstance(
-            m_key_list_->GetCurrentGpgContextChannel())
-            .DecryptVerify(buffer, [this, hd](GpgError err,
-                                              const DataObjectPtr& data_obj) {
-              // stop waiting
-              hd();
-
-              if (CheckGpgError(err) == GPG_ERR_USER_1 || data_obj == nullptr ||
-                  !data_obj
-                       ->Check<GpgDecryptResult, GpgVerifyResult, GFBuffer>()) {
-                QMessageBox::critical(this, tr("Error"),
-                                      tr("Unknown error occurred"));
-                return;
-              }
-              auto decrypt_result =
-                  ExtractParams<GpgDecryptResult>(data_obj, 0);
-              auto verify_result = ExtractParams<GpgVerifyResult>(data_obj, 1);
-              auto out_buffer = ExtractParams<GFBuffer>(data_obj, 2);
-
-              // analyse result
-              auto decrypt_result_analyse = GpgDecryptResultAnalyse(
-                  m_key_list_->GetCurrentGpgContextChannel(), err,
-                  decrypt_result);
-              decrypt_result_analyse.Analyse();
-
-              auto verify_result_analyse = GpgVerifyResultAnalyse(
-                  m_key_list_->GetCurrentGpgContextChannel(), err,
-                  verify_result);
-              verify_result_analyse.Analyse();
-
-              // show analyse result
-              slot_result_analyse_show_helper(decrypt_result_analyse,
-                                              verify_result_analyse);
-
-              if (CheckGpgError(err) == GPG_ERR_NO_ERROR) {
-                edit_->SlotFillTextEditWithText(
-                    out_buffer.ConvertToQByteArray());
-              }
-
-              if (!verify_result_analyse.GetUnknownSignatures().isEmpty() &&
-                  Module::IsModuleActivate(kKeyServerSyncModuleID)) {
-                slot_verifying_unknown_signature_helper(
-                    verify_result_analyse.GetUnknownSignatures());
-              }
-            });
-      });
+  auto contexts = QSharedPointer<GpgOperaContextBasement>::create();
+  contexts->ascii = true;
+
+  contexts->GetContextBuffer(0).append(GFBuffer(edit_->CurPlainText()));
+  GpgOperaHelper::BuildOperas(contexts, 0,
+                              m_key_list_->GetCurrentGpgContextChannel(),
+                              GpgOperaHelper::BuildOperasDecryptVerify);
+
+  exec_operas_helper(tr("Decrypting and Verifying"), contexts);
+
+  if (!contexts->unknown_fprs.isEmpty()) {
+    slot_verifying_unknown_signature_helper(contexts->unknown_fprs);
+  }
 }
 
 }  // namespace GpgFrontend::UI
\ No newline at end of file
diff --git a/src/ui/main_window/MainWindowSlotFunction.cpp b/src/ui/main_window/MainWindowSlotFunction.cpp
index a5a56c1f..825f74f5 100644
--- a/src/ui/main_window/MainWindowSlotFunction.cpp
+++ b/src/ui/main_window/MainWindowSlotFunction.cpp
@@ -47,6 +47,7 @@
 #include "ui/dialog/help/AboutDialog.h"
 #include "ui/dialog/import_export/KeyUploadDialog.h"
 #include "ui/dialog/keypair_details/KeyDetailsDialog.h"
+#include "ui/function/GpgOperaHelper.h"
 #include "ui/function/SetOwnerTrustLevel.h"
 #include "ui/struct/GpgOperaResult.h"
 #include "ui/widgets/FindWidget.h"
@@ -559,6 +560,7 @@ void MainWindow::slot_result_analyse_show_helper(
     const QContainer<GpgOperaResult>& opera_results) {
   if (opera_results.empty()) {
     slot_refresh_info_board(0, "");
+    return;
   }
 
   int overall_status = 1;  // Initialize to OK
@@ -1093,4 +1095,20 @@ auto MainWindow::handle_module_error(QMap<QString, QString> p) -> bool {
   return false;
 }
 
+void MainWindow::slot_gpg_opera_buffer_show_helper(
+    const QContainer<GpgOperaResult>& results) {
+  for (const auto& result : results) {
+    if (result.o_buffer.Empty()) continue;
+    edit_->SlotFillTextEditWithText(result.o_buffer.ConvertToQByteArray());
+  }
+}
+
+void MainWindow::exec_operas_helper(
+    const QString& task,
+    const QSharedPointer<GpgOperaContextBasement>& contexts) {
+  GpgOperaHelper::WaitForMultipleOperas(this, task, contexts->operas);
+  slot_gpg_opera_buffer_show_helper(contexts->opera_results);
+  slot_result_analyse_show_helper(contexts->opera_results);
+}
+
 }  // namespace GpgFrontend::UI
diff --git a/src/ui/struct/GpgOperaResult.h b/src/ui/struct/GpgOperaResult.h
index 7ee6ad37..18eef96a 100644
--- a/src/ui/struct/GpgOperaResult.h
+++ b/src/ui/struct/GpgOperaResult.h
@@ -28,12 +28,14 @@
 
 #pragma once
 
+#include "core/model/GFBuffer.h"
 namespace GpgFrontend::UI {
 
 struct GpgOperaResult {
   int status;
   QString report;
   QString tag;
+  GFBuffer o_buffer;
 
   GpgOperaResult(int status, QString report, QString tag);
 };
diff --git a/src/ui/struct/GpgOperaResultContext.cpp b/src/ui/struct/GpgOperaResultContext.cpp
index 5640a204..b01f8788 100644
--- a/src/ui/struct/GpgOperaResultContext.cpp
+++ b/src/ui/struct/GpgOperaResultContext.cpp
@@ -45,6 +45,12 @@ auto GpgOperaContextBasement::GetContextOutPath(int category) -> QStringList& {
   return categories[category].o_paths;
 }
 
+auto GpgOperaContextBasement::GetContextBuffer(int category)
+    -> QContainer<GFBuffer>& {
+  if (!categories.contains(category)) categories[category] = {};
+  return categories[category].buffers;
+}
+
 auto GpgOperaContextBasement::GetAllPath() -> QStringList {
   QStringList res;
 
@@ -66,12 +72,21 @@ auto GpgOperaContextBasement::GetAllOutPath() -> QStringList {
 auto GetGpgOperaContextFromBasement(
     const QSharedPointer<GpgOperaContextBasement>& base,
     int category) -> QSharedPointer<GpgOperaContext> {
-  if (base->GetContextPath(category).empty()) return nullptr;
+  if (!base->GetContextPath(category).isEmpty()) {
+    auto context = QSharedPointer<GpgOperaContext>::create(base);
 
-  auto context = QSharedPointer<GpgOperaContext>::create(base);
+    context->paths = base->GetContextPath(category);
+    context->o_paths = base->GetContextOutPath(category);
+    return context;
+  }
+
+  if (!base->GetContextBuffer(category).isEmpty()) {
+    auto context = QSharedPointer<GpgOperaContext>::create(base);
+
+    context->buffers = base->GetContextBuffer(category);
+    return context;
+  }
 
-  context->paths = base->GetContextPath(category);
-  context->o_paths = base->GetContextOutPath(category);
-  return context;
+  return nullptr;
 }
 }  // namespace GpgFrontend::UI
\ No newline at end of file
diff --git a/src/ui/struct/GpgOperaResultContext.h b/src/ui/struct/GpgOperaResultContext.h
index 526c1ef7..47333b73 100644
--- a/src/ui/struct/GpgOperaResultContext.h
+++ b/src/ui/struct/GpgOperaResultContext.h
@@ -36,6 +36,7 @@ namespace GpgFrontend::UI {
 struct GpgOperaCategory {
   QStringList paths;
   QStringList o_paths;
+  QContainer<GFBuffer> buffers;
 };
 
 struct GpgOperaContext;
@@ -54,6 +55,8 @@ struct GpgOperaContextBasement {
 
   auto GetContextOutPath(int category) -> QStringList&;
 
+  auto GetContextBuffer(int category) -> QContainer<GFBuffer>&;
+
   auto GetAllPath() -> QStringList;
 
   auto GetAllOutPath() -> QStringList;
@@ -64,6 +67,7 @@ struct GpgOperaContext {
 
   QStringList paths;
   QStringList o_paths;
+  QContainer<GFBuffer> buffers;
 
   explicit GpgOperaContext(QSharedPointer<GpgOperaContextBasement> base);
 };