refactor: reduce code duplication of gnupg file operations

7 files changed, 620 insertions, 760 deletions

diff --git a/src/core/function/gpg/GpgBasicOperator.cpp b/src/core/function/gpg/GpgBasicOperator.cpp
index cb933d33..55f08854 100644
--- a/src/core/function/gpg/GpgBasicOperator.cpp
+++ b/src/core/function/gpg/GpgBasicOperator.cpp
@@ -63,19 +63,15 @@ void SetSignersImpl(GpgContext& ctx_, const KeyArgsList& signers, bool ascii) {
 auto EncryptImpl(GpgContext& ctx_, const KeyArgsList& keys,
                  const GFBuffer& in_buffer, bool ascii,
                  const DataObjectPtr& data_object) -> GpgError {
-  if (keys.empty()) return GPG_ERR_CANCELED;
-
-  QContainer<gpgme_key_t> recipients(keys.begin(), keys.end());
-
-  // Last entry data_in array has to be nullptr
-  recipients.emplace_back(nullptr);
+  auto recipients = Convert2RawGpgMEKeyList(keys);
 
   GpgData data_in(in_buffer);
   GpgData data_out;
 
   auto* ctx = ascii ? ctx_.DefaultContext() : ctx_.BinaryContext();
-  auto err = CheckGpgError(gpgme_op_encrypt(
-      ctx, recipients.data(), GPGME_ENCRYPT_ALWAYS_TRUST, data_in, data_out));
+  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()});
 
@@ -102,26 +98,11 @@ auto GpgBasicOperator::EncryptSync(const KeyArgsList& keys,
       "gpgme_op_encrypt", "2.1.0");
 }
 
-auto EncryptSymmetricImpl(GpgContext& ctx_, const GFBuffer& in_buffer,
-                          bool ascii,
-                          const DataObjectPtr& data_object) -> GpgError {
-  GpgData data_in(in_buffer);
-  GpgData data_out;
-
-  auto* ctx = ascii ? ctx_.DefaultContext() : ctx_.BinaryContext();
-  auto err = CheckGpgError(gpgme_op_encrypt(
-      ctx, nullptr, GPGME_ENCRYPT_SYMMETRIC, data_in, data_out));
-  data_object->Swap({GpgEncryptResult(gpgme_op_encrypt_result(ctx)),
-                     data_out.Read2GFBuffer()});
-
-  return err;
-}
-
 void GpgBasicOperator::EncryptSymmetric(const GFBuffer& in_buffer, bool ascii,
                                         const GpgOperationCallback& cb) {
   RunGpgOperaAsync(
       [=](const DataObjectPtr& data_object) {
-        return EncryptSymmetricImpl(ctx_, in_buffer, ascii, data_object);
+        return EncryptImpl(ctx_, {}, in_buffer, ascii, data_object);
       },
       cb, "gpgme_op_encrypt_symmetric", "2.1.0");
 }
@@ -131,7 +112,7 @@ auto GpgBasicOperator::EncryptSymmetricSync(const GFBuffer& in_buffer,
     -> std::tuple<GpgError, DataObjectPtr> {
   return RunGpgOperaSync(
       [=](const DataObjectPtr& data_object) {
-        return EncryptSymmetricImpl(ctx_, in_buffer, ascii, data_object);
+        return EncryptImpl(ctx_, {}, in_buffer, ascii, data_object);
       },
       "gpgme_op_encrypt_symmetric", "2.1.0");
 }
diff --git a/src/ui/function/GpgOperaHelper.cpp b/src/ui/function/GpgOperaHelper.cpp
new file mode 100644
index 00000000..35c4ba35
--- /dev/null
+++ b/src/ui/function/GpgOperaHelper.cpp
@@ -0,0 +1,346 @@
+/**
+ * Copyright (C) 2021-2024 Saturneric <[email protected]>
+ *
+ * This file is part of GpgFrontend.
+ *
+ * GpgFrontend is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * GpgFrontend is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GpgFrontend. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * The initial version of the source code is inherited from
+ * the gpg4usb project, which is under GPL-3.0-or-later.
+ *
+ * All the source code of GpgFrontend was modified and released by
+ * Saturneric <[email protected]> starting on May 12, 2021.
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ */
+
+#include "GpgOperaHelper.h"
+
+#include "core/function/gpg/GpgFileOpera.h"
+#include "core/function/result_analyse/GpgDecryptResultAnalyse.h"
+#include "core/function/result_analyse/GpgEncryptResultAnalyse.h"
+#include "core/function/result_analyse/GpgSignResultAnalyse.h"
+#include "core/model/GpgDecryptResult.h"
+#include "core/model/GpgEncryptResult.h"
+#include "core/model/GpgSignResult.h"
+#include "core/utils/GpgUtils.h"
+#include "ui/dialog/WaitingDialog.h"
+
+namespace GpgFrontend::UI {
+
+void GpgOperaHelper::BuildOperas(QSharedPointer<GpgOperaContextBasement>& base,
+                                 int category, int channel,
+                                 const GpgOperaFactory& f) {
+  assert(base != nullptr);
+
+  auto context = GetGpgOperaContextFromBasement(base, category);
+  if (context == nullptr) return;
+
+  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));
+  }
+}
+
+template <typename AnalyseType>
+void HandleExtraLogicIfNeeded(const QSharedPointer<GpgOperaContext>& context,
+                              const AnalyseType& analyse) {}
+
+template <>
+void HandleExtraLogicIfNeeded<GpgVerifyResultAnalyse>(
+    const QSharedPointer<GpgOperaContext>& context,
+    const GpgVerifyResultAnalyse& analyse) {
+  context->base->unknown_fprs.append(analyse.GetUnknownSignatures());
+}
+
+template <typename ResultType, typename AnalyseType, typename OperaFunc>
+auto GpgOperaHelper::BuildSimpleGpgFileOperasHelper(
+    QSharedPointer<GpgOperaContext>& context, int channel, int index,
+    OperaFunc opera_func) -> OperaWaitingCb {
+  const auto& path = context->paths[index];
+  const auto& o_path = context->o_paths[index];
+  auto& opera_results = context->base->opera_results;
+
+  return [=, &opera_results](const OperaWaitingHd& op_hd) {
+    opera_func(
+        path, o_path,
+        [=, &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>()) {
+            opera_results.append(
+                {-1, "# " + tr("Critical Error"), QFileInfo(path).fileName()});
+            return;
+          }
+
+          auto result = ExtractParams<ResultType>(data_obj, 0);
+          auto result_analyse = AnalyseType(channel, err, result);
+          result_analyse.Analyse();
+
+          HandleExtraLogicIfNeeded(context, result_analyse);
+
+          opera_results.append(
+              {result_analyse.GetStatus(), result_analyse.GetResultReport(),
+               QFileInfo(path.isEmpty() ? o_path : path).fileName()});
+        });
+  };
+}
+
+template <typename ResultTypeA, typename AnalyseTypeA, typename ResultTypeB,
+          typename AnalyseTypeB, typename OperaFunc>
+auto GpgOperaHelper::BuildComplexGpgFileOperasHelper(
+    QSharedPointer<GpgOperaContext>& context, int channel, int index,
+    OperaFunc opera_func) -> OperaWaitingCb {
+  const auto& path = context->paths[index];
+  const auto& o_path = context->o_paths[index];
+  auto& opera_results = context->base->opera_results;
+
+  return [=, &opera_results](const OperaWaitingHd& op_hd) {
+    opera_func(
+        path, o_path,
+        [=, &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>()) {
+            opera_results.append(
+                {-1, "# " + tr("Critical Error"), QFileInfo(path).fileName()});
+            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);
+
+          opera_results.append(
+              {std::min(result_analyse_1.GetStatus(),
+                        result_analyse_2.GetStatus()),
+               result_analyse_1.GetResultReport() +
+                   result_analyse_2.GetResultReport(),
+               QFileInfo(path.isEmpty() ? o_path : path).fileName()});
+        });
+  };
+}
+
+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::BuildSimpleGpgFileOperasHelper<
+        GpgEncryptResult, GpgEncryptResultAnalyse>(
+        context, channel, index,
+        [=](const QString& path, const QString& o_path, const auto& callback) {
+          encrypt_symmetric(path, o_path, callback);
+        });
+  }
+
+  return GpgOperaHelper::BuildSimpleGpgFileOperasHelper<
+      GpgEncryptResult, GpgEncryptResultAnalyse>(
+      context, channel, index,
+      [=](const QString& path, const QString& o_path, const auto& callback) {
+        encrypt_with_keys(path, o_path, callback);
+      });
+}
+
+auto GpgOperaHelper::BuildOperasFileEncrypt(
+    QSharedPointer<GpgOperaContext>& context, int channel,
+    int index) -> OperaWaitingCb {
+  return BuildOperasEncryptHelper(
+      context, channel, index,
+      [context, channel](const QString& path, const QString& o_path,
+                         const auto& callback) {
+        GpgFileOpera::GetInstance(channel).EncryptFileSymmetric(
+            path, context->base->ascii, o_path, callback);
+      },
+      [context, channel](const QString& path, const QString& o_path,
+                         const auto& callback) {
+        GpgFileOpera::GetInstance(channel).EncryptFile(
+            context->base->keys, path, context->base->ascii, o_path, callback);
+      });
+}
+
+auto GpgOperaHelper::BuildOperasDirectoryEncrypt(
+    QSharedPointer<GpgOperaContext>& context, int channel,
+    int index) -> OperaWaitingCb {
+  return BuildOperasEncryptHelper(
+      context, channel, index,
+      [context, channel](const QString& path, const QString& o_path,
+                         const auto& callback) {
+        GpgFileOpera::GetInstance(channel).EncryptDirectorySymmetric(
+            path, context->base->ascii, o_path, callback);
+      },
+      [context, channel](const QString& path, const QString& o_path,
+                         const auto& callback) {
+        GpgFileOpera::GetInstance(channel).EncryptDirectory(
+            context->base->keys, path, context->base->ascii, o_path, callback);
+      });
+}
+
+auto GpgOperaHelper::BuildOperasFileDecrypt(
+    QSharedPointer<GpgOperaContext>& context, int channel,
+    int index) -> OperaWaitingCb {
+  return BuildSimpleGpgFileOperasHelper<GpgDecryptResult,
+                                        GpgDecryptResultAnalyse>(
+      context, channel, index,
+      [channel](const QString& path, const QString& o_path,
+                const auto& callback) {
+        GpgFileOpera::GetInstance(channel).DecryptFile(path, o_path, callback);
+      });
+}
+
+auto GpgOperaHelper::BuildOperasArchiveDecrypt(
+    QSharedPointer<GpgOperaContext>& context, int channel,
+    int index) -> OperaWaitingCb {
+  return BuildSimpleGpgFileOperasHelper<GpgDecryptResult,
+                                        GpgDecryptResultAnalyse>(
+      context, channel, index,
+      [channel](const QString& path, const QString& o_path,
+                const auto& callback) {
+        GpgFileOpera::GetInstance(channel).DecryptArchive(path, o_path,
+                                                          callback);
+      });
+}
+
+auto GpgOperaHelper::BuildOperasFileSign(
+    QSharedPointer<GpgOperaContext>& context, int channel,
+    int index) -> OperaWaitingCb {
+  return BuildSimpleGpgFileOperasHelper<GpgSignResult, GpgSignResultAnalyse>(
+      context, channel, index,
+      [channel, context](const QString& path, const QString& o_path,
+                         const auto& callback) {
+        GpgFileOpera::GetInstance(channel).SignFile(
+            context->base->keys, path, context->base->ascii, o_path, callback);
+      });
+}
+
+auto GpgOperaHelper::BuildOperasFileVerify(
+    QSharedPointer<GpgOperaContext>& context, int channel,
+    int index) -> OperaWaitingCb {
+  return BuildSimpleGpgFileOperasHelper<GpgVerifyResult,
+                                        GpgVerifyResultAnalyse>(
+      context, channel, index,
+      [channel](const QString& path, const QString& o_path,
+                const auto& callback) {
+        GpgFileOpera::GetInstance(channel).VerifyFile(o_path, path, callback);
+      });
+}
+
+auto GpgOperaHelper::BuildOperasFileEncryptSign(
+    QSharedPointer<GpgOperaContext>& context, int channel,
+    int index) -> OperaWaitingCb {
+  return BuildComplexGpgFileOperasHelper<GpgEncryptResult,
+                                         GpgEncryptResultAnalyse, GpgSignResult,
+                                         GpgSignResultAnalyse>(
+      context, channel, index,
+      [channel, context](const QString& path, const QString& o_path,
+                         const auto& callback) {
+        GpgFileOpera::GetInstance(channel).EncryptSignFile(
+            context->base->keys, context->base->singer_keys, path,
+            context->base->ascii, o_path, callback);
+      });
+}
+
+auto GpgOperaHelper::BuildOperasDirectoryEncryptSign(
+    QSharedPointer<GpgOperaContext>& context, int channel,
+    int index) -> OperaWaitingCb {
+  return BuildComplexGpgFileOperasHelper<GpgEncryptResult,
+                                         GpgEncryptResultAnalyse, GpgSignResult,
+                                         GpgSignResultAnalyse>(
+      context, channel, index,
+      [channel, context](const QString& path, const QString& o_path,
+                         const auto& callback) {
+        GpgFileOpera::GetInstance(channel).EncryptSignDirectory(
+            context->base->keys, context->base->singer_keys, path,
+            context->base->ascii, o_path, callback);
+      });
+}
+
+auto GpgOperaHelper::BuildOperasFileDecryptVerify(
+    QSharedPointer<GpgOperaContext>& context, int channel,
+    int index) -> OperaWaitingCb {
+  return BuildComplexGpgFileOperasHelper<
+      GpgDecryptResult, GpgDecryptResultAnalyse, GpgVerifyResult,
+      GpgVerifyResultAnalyse>(
+      context, channel, index,
+      [channel](const QString& path, const QString& o_path,
+                const auto& callback) {
+        GpgFileOpera::GetInstance(channel).DecryptVerifyFile(path, o_path,
+                                                             callback);
+      });
+}
+
+auto GpgOperaHelper::BuildOperasArchiveDecryptVerify(
+    QSharedPointer<GpgOperaContext>& context, int channel,
+    int index) -> OperaWaitingCb {
+  return BuildComplexGpgFileOperasHelper<
+      GpgDecryptResult, GpgDecryptResultAnalyse, GpgVerifyResult,
+      GpgVerifyResultAnalyse>(
+      context, channel, index,
+      [channel](const QString& path, const QString& o_path,
+                const auto& callback) {
+        GpgFileOpera::GetInstance(channel).DecryptVerifyArchive(path, o_path,
+                                                                callback);
+      });
+}
+
+void GpgOperaHelper::WaitForMultipleOperas(
+    QWidget* parent, const QString& title,
+    const QContainer<OperaWaitingCb>& operas) {
+  QEventLoop looper;
+  QPointer<WaitingDialog> const dialog = new WaitingDialog(title, true, parent);
+  connect(dialog, &QDialog::finished, &looper, &QEventLoop::quit);
+  connect(dialog, &QDialog::finished, dialog, &QDialog::deleteLater);
+  dialog->show();
+
+  std::atomic<int> remaining_tasks(static_cast<int>(operas.size()));
+  const auto tasks_count = operas.size();
+
+  for (const auto& opera : operas) {
+    QTimer::singleShot(64, parent, [=, &remaining_tasks]() {
+      opera([dialog, &remaining_tasks, tasks_count]() {
+        if (dialog == nullptr) return;
+
+        const auto pg_value =
+            static_cast<double>(tasks_count - remaining_tasks + 1) * 100.0 /
+            static_cast<double>(tasks_count);
+        emit dialog->SignalUpdateValue(static_cast<int>(pg_value));
+        QCoreApplication::processEvents();
+
+        if (--remaining_tasks == 0) {
+          dialog->close();
+          dialog->accept();
+        }
+      });
+    });
+  }
+
+  looper.exec();
+}
+}  // namespace GpgFrontend::UI
diff --git a/src/ui/function/GpgOperaHelper.h b/src/ui/function/GpgOperaHelper.h
new file mode 100644
index 00000000..ca620574
--- /dev/null
+++ b/src/ui/function/GpgOperaHelper.h
@@ -0,0 +1,185 @@
+/**
+ * Copyright (C) 2021-2024 Saturneric <[email protected]>
+ *
+ * This file is part of GpgFrontend.
+ *
+ * GpgFrontend is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * GpgFrontend is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GpgFrontend. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * The initial version of the source code is inherited from
+ * the gpg4usb project, which is under GPL-3.0-or-later.
+ *
+ * All the source code of GpgFrontend was modified and released by
+ * Saturneric <[email protected]> starting on May 12, 2021.
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ */
+
+#pragma once
+
+#include "GpgFrontendUI.h"
+#include "ui/struct/GpgOperaResultContext.h"
+
+namespace GpgFrontend::UI {
+
+class GpgOperaHelper : QObject {
+  Q_OBJECT
+ public:
+  using GpgOperaFactory = std::function<OperaWaitingCb(
+      QSharedPointer<GpgOperaContext>& context, int channel, int index)>;
+
+  template <typename ResultType, typename AnalyseType, typename OperaFunc>
+  static auto BuildSimpleGpgFileOperasHelper(
+      QSharedPointer<GpgOperaContext>& context, int channel, int index,
+      OperaFunc opera_func) -> OperaWaitingCb;
+
+  template <typename ResultTypeA, typename AnalyseTypeA, typename ResultTypeB,
+            typename AnalyseTypeB, typename OperaFunc>
+  static auto BuildComplexGpgFileOperasHelper(
+      QSharedPointer<GpgOperaContext>& context, int channel, int index,
+      OperaFunc opera_func) -> OperaWaitingCb;
+
+  /**
+   * @brief
+   *
+   * @param base
+   * @param category
+   * @param channel
+   * @param f
+   */
+  static void BuildOperas(QSharedPointer<GpgOperaContextBasement>& base,
+                          int category, int channel, const GpgOperaFactory& f);
+
+  /**
+   * @brief
+   *
+   * @param context
+   * @param channel
+   * @param index
+   * @return OperaWaitingCb
+   */
+  static auto BuildOperasFileEncrypt(QSharedPointer<GpgOperaContext>& context,
+                                     int channel, int index) -> OperaWaitingCb;
+
+  /**
+   * @brief
+   *
+   * @param context
+   * @param channel
+   * @param index
+   * @return OperaWaitingCb
+   */
+  static auto BuildOperasDirectoryEncrypt(
+      QSharedPointer<GpgOperaContext>& context, int channel,
+      int index) -> OperaWaitingCb;
+
+  /**
+   * @brief
+   *
+   * @param context
+   */
+  static auto BuildOperasFileDecrypt(QSharedPointer<GpgOperaContext>& context,
+                                     int channel, int index) -> OperaWaitingCb;
+
+  /**
+   * @brief
+   *
+   * @param context
+   * @param channel
+   * @param index
+   * @return OperaWaitingCb
+   */
+  static auto BuildOperasArchiveDecrypt(
+      QSharedPointer<GpgOperaContext>& context, int channel,
+      int index) -> OperaWaitingCb;
+
+  /**
+   * @brief
+   *
+   * @param context
+   * @return OperaWaitingCb
+   */
+  static auto BuildOperasFileSign(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;
+
+  /**
+   * @brief
+   *
+   * @param context
+   * @param channel
+   * @param index
+   */
+  static auto BuildOperasFileEncryptSign(
+      QSharedPointer<GpgOperaContext>& context, int channel,
+      int index) -> OperaWaitingCb;
+
+  /**
+   * @brief
+   *
+   * @param context
+   * @param channel
+   * @param index
+   * @return OperaWaitingCb
+   */
+  static auto BuildOperasDirectoryEncryptSign(
+      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;
+
+  /**
+   * @brief
+   *
+   * @param context
+   * @param channel
+   * @param index
+   * @return OperaWaitingCb
+   */
+  static auto BuildOperasArchiveDecryptVerify(
+      QSharedPointer<GpgOperaContext>& context, int channel,
+      int index) -> OperaWaitingCb;
+
+  /**
+   * @brief
+   *
+   * @param parent
+   * @param title
+   * @param operas
+   */
+  static void WaitForMultipleOperas(QWidget* parent, const QString& title,
+                                    const QContainer<OperaWaitingCb>& operas);
+};
+
+}  // namespace GpgFrontend::UI
\ No newline at end of file
diff --git a/src/ui/main_window/MainWindow.h b/src/ui/main_window/MainWindow.h
index 8f8cd05e..8dbb9376 100644
--- a/src/ui/main_window/MainWindow.h
+++ b/src/ui/main_window/MainWindow.h
@@ -45,7 +45,7 @@ class KeyList;
 class TextEdit;
 class InfoBoardWidget;
 struct GpgOperaContext;
-struct GpgOperaContexts;
+struct GpgOperaContextBasement;
 
 /**
  * @brief
@@ -634,97 +634,9 @@ class MainWindow : public GeneralMainWindow {
    * @param context
    * @return auto
    */
-  auto execute_operas_helper(const QString& task,
-                             const QSharedPointer<GpgOperaContexts>& contexts);
-
-  /**
-   * @brief
-   *
-   * @param context
-   */
-  void build_operas_file_symmetric_encrypt(
-      QSharedPointer<GpgOperaContext>& context);
-
-  /**
-   * @brief
-   *
-   * @param context
-   */
-  void build_operas_file_encrypt(QSharedPointer<GpgOperaContext>& context);
-
-  /**
-   * @brief
-   *
-   * @param context
-   */
-  void build_operas_directory_symmetric_encrypt(
-      QSharedPointer<GpgOperaContext>& context);
-
-  /**
-   * @brief
-   *
-   * @param context
-   */
-  void build_operas_directory_encrypt(QSharedPointer<GpgOperaContext>& context);
-
-  /**
-   * @brief
-   *
-   * @param context
-   */
-  void build_operas_file_decrypt(QSharedPointer<GpgOperaContext>& context);
-
-  /**
-   * @brief
-   *
-   * @param context
-   */
-  void build_operas_archive_decrypt(QSharedPointer<GpgOperaContext>& context);
-
-  /**
-   * @brief
-   *
-   * @param context
-   */
-  void build_operas_file_sign(QSharedPointer<GpgOperaContext>& context);
-
-  /**
-   * @brief
-   *
-   * @param context
-   */
-  void build_operas_file_verify(QSharedPointer<GpgOperaContext>& context);
-
-  /**
-   * @brief
-   *
-   * @param context
-   */
-  void build_operas_file_encrypt_sign(QSharedPointer<GpgOperaContext>& context);
-
-  /**
-   * @brief
-   *
-   * @param context
-   */
-  void build_operas_directory_encrypt_sign(
-      QSharedPointer<GpgOperaContext>& context);
-
-  /**
-   * @brief
-   *
-   * @param context
-   */
-  void build_operas_file_decrypt_verify(
-      QSharedPointer<GpgOperaContext>& context);
-
-  /**
-   * @brief
-   *
-   * @param context
-   */
-  void build_operas_archive_decrypt_verify(
-      QSharedPointer<GpgOperaContext>& context);
+  auto execute_operas_helper(
+      const QString& task,
+      const QSharedPointer<GpgOperaContextBasement>& contexts);
 
   TextEdit* edit_{};          ///< Tabwidget holding the edit-windows
   QMenu* file_menu_{};        ///<  Submenu for file-operations
diff --git a/src/ui/main_window/MainWindowFileSlotFunction.cpp b/src/ui/main_window/MainWindowFileSlotFunction.cpp
index d6a651c8..ba6a6ec2 100644
--- a/src/ui/main_window/MainWindowFileSlotFunction.cpp
+++ b/src/ui/main_window/MainWindowFileSlotFunction.cpp
@@ -28,18 +28,11 @@
 
 #include "MainWindow.h"
 #include "core/function/GlobalSettingStation.h"
-#include "core/function/gpg/GpgFileOpera.h"
 #include "core/function/gpg/GpgKeyGetter.h"
-#include "core/function/result_analyse/GpgDecryptResultAnalyse.h"
-#include "core/function/result_analyse/GpgEncryptResultAnalyse.h"
-#include "core/function/result_analyse/GpgSignResultAnalyse.h"
-#include "core/function/result_analyse/GpgVerifyResultAnalyse.h"
-#include "core/module/ModuleManager.h"
 #include "core/utils/GpgUtils.h"
 #include "core/utils/IOUtils.h"
-#include "ui/UserInterfaceUtils.h"
 #include "ui/dialog/SignersPicker.h"
-#include "ui/struct/GpgOperaResult.h"
+#include "ui/function/GpgOperaHelper.h"
 #include "ui/struct/GpgOperaResultContext.h"
 #include "ui/widgets/KeyList.h"
 
@@ -139,179 +132,20 @@ auto MainWindow::check_keys_helper(
 }
 
 auto MainWindow::execute_operas_helper(
-    const QString& task, const QSharedPointer<GpgOperaContexts>& contexts) {
-  CommonUtils::WaitForMultipleOperas(this, task, contexts->operas);
+    const QString& task,
+    const QSharedPointer<GpgOperaContextBasement>& contexts) {
+  GpgOperaHelper::WaitForMultipleOperas(this, task, contexts->operas);
   slot_result_analyse_show_helper(contexts->opera_results);
 }
 
-void MainWindow::build_operas_file_symmetric_encrypt(
-    QSharedPointer<GpgOperaContext>& context) {
-  assert(context->paths.size() == context->o_paths.size());
-
-  for (int i = 0; i < context->paths.size(); i++) {
-    const auto& path = context->paths[i];
-    const auto& o_path = context->o_paths[i];
-
-    auto opera = [=, &opera_results =
-                         context->opera_results](const OperaWaitingHd& op_hd) {
-      GpgFileOpera::GetInstance(m_key_list_->GetCurrentGpgContextChannel())
-          .EncryptFileSymmetric(
-              path, context->ascii, o_path,
-              [=, &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<GpgEncryptResult>()) {
-                  QMessageBox::critical(this, tr("Error"),
-                                        tr("Unknown error occurred"));
-                  return;
-                }
-
-                auto result = ExtractParams<GpgEncryptResult>(data_obj, 0);
-                auto result_analyse = GpgEncryptResultAnalyse(
-                    m_key_list_->GetCurrentGpgContextChannel(), err, result);
-                result_analyse.Analyse();
-
-                opera_results.append({result_analyse.GetStatus(),
-                                      result_analyse.GetResultReport(),
-                                      QFileInfo(path).fileName()});
-              });
-    };
-
-    context->operas.push_back(opera);
-  }
-}
-
-void MainWindow::build_operas_file_encrypt(
-    QSharedPointer<GpgOperaContext>& context) {
-  assert(context->paths.size() == context->o_paths.size());
-
-  for (int i = 0; i < context->paths.size(); i++) {
-    const auto& path = context->paths[i];
-    const auto& o_path = context->o_paths[i];
-
-    auto opera = [=, &opera_results =
-                         context->opera_results](const OperaWaitingHd& op_hd) {
-      GpgFileOpera::GetInstance(m_key_list_->GetCurrentGpgContextChannel())
-          .EncryptFile(
-              context->keys, path, context->ascii, o_path,
-              [=, &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<GpgEncryptResult>()) {
-                  QMessageBox::critical(this, tr("Error"),
-                                        tr("Unknown error occurred"));
-                  return;
-                }
-
-                auto result = ExtractParams<GpgEncryptResult>(data_obj, 0);
-                auto result_analyse = GpgEncryptResultAnalyse(
-                    m_key_list_->GetCurrentGpgContextChannel(), err, result);
-                result_analyse.Analyse();
-
-                opera_results.append({result_analyse.GetStatus(),
-                                      result_analyse.GetResultReport(),
-                                      QFileInfo(path).fileName()});
-              });
-    };
-
-    context->operas.push_back(opera);
-  }
-}
-
-void MainWindow::build_operas_directory_symmetric_encrypt(
-    QSharedPointer<GpgOperaContext>& context) {
-  assert(context->paths.size() == context->o_paths.size());
-
-  for (int i = 0; i < context->paths.size(); i++) {
-    const auto& path = context->paths[i];
-    const auto& o_path = context->o_paths[i];
-
-    auto opera = [=, &opera_results =
-                         context->opera_results](const OperaWaitingHd& op_hd) {
-      GpgFileOpera::GetInstance(m_key_list_->GetCurrentGpgContextChannel())
-          .EncryptDirectorySymmetric(
-              path, context->ascii, o_path,
-              [=, &opera_results](GpgError err, const DataObjectPtr& data_obj) {
-                // stop waiting
-                op_hd();
-
-                if (data_obj == nullptr ||
-                    !data_obj->Check<GpgEncryptResult>()) {
-                  QMessageBox::critical(this, tr("Error"),
-                                        tr("Unknown error occurred"));
-                  return;
-                }
-
-                auto result = ExtractParams<GpgEncryptResult>(data_obj, 0);
-                auto result_analyse = GpgEncryptResultAnalyse(
-                    m_key_list_->GetCurrentGpgContextChannel(), err, result);
-                result_analyse.Analyse();
-
-                opera_results.append({result_analyse.GetStatus(),
-                                      result_analyse.GetResultReport(),
-                                      QFileInfo(path).fileName()});
-              });
-    };
-
-    context->operas.push_back(opera);
-  }
-}
-
-void MainWindow::build_operas_directory_encrypt(
-    QSharedPointer<GpgOperaContext>& context) {
-  assert(context->paths.size() == context->o_paths.size());
-
-  for (int i = 0; i < context->paths.size(); i++) {
-    const auto& path = context->paths[i];
-    const auto& o_path = context->o_paths[i];
-
-    auto opera = [=, &opera_results =
-                         context->opera_results](const OperaWaitingHd& op_hd) {
-      GpgFileOpera::GetInstance(m_key_list_->GetCurrentGpgContextChannel())
-          .EncryptDirectory(
-              context->keys, path, context->ascii, o_path,
-              [=, &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<GpgEncryptResult>()) {
-                  QMessageBox::critical(this, tr("Error"),
-                                        tr("Unknown error occurred"));
-                  return;
-                }
-
-                auto result = ExtractParams<GpgEncryptResult>(data_obj, 0);
-                auto result_analyse = GpgEncryptResultAnalyse(
-                    m_key_list_->GetCurrentGpgContextChannel(), err, result);
-                result_analyse.Analyse();
-
-                opera_results.append({result_analyse.GetStatus(),
-                                      result_analyse.GetResultReport(),
-                                      QFileInfo(path).fileName()});
-              });
-    };
-
-    context->operas.push_back(opera);
-  }
-}
-
 void MainWindow::SlotFileEncrypt(const QStringList& paths) {
-  auto contexts = QSharedPointer<GpgOperaContexts>::create();
+  auto contexts = QSharedPointer<GpgOperaContextBasement>::create();
 
   bool const non_ascii_at_file_operation =
       GetSettings().value("gnupg/non_ascii_at_file_operation", true).toBool();
 
   contexts->ascii = !non_ascii_at_file_operation;
 
-  bool is_symmetric = false;
   auto key_ids = m_key_list_->GetChecked();
 
   // Symmetric Encrypt
@@ -322,7 +156,8 @@ void MainWindow::SlotFileEncrypt(const QStringList& paths) {
            "symmetric cipher using a passphrase?"),
         QMessageBox::Ok | QMessageBox::Cancel);
     if (ret == QMessageBox::Cancel) return;
-    is_symmetric = true;
+
+    contexts->keys = {};
   } else {
     contexts->keys = check_keys_helper(
         key_ids,
@@ -348,113 +183,19 @@ void MainWindow::SlotFileEncrypt(const QStringList& paths) {
 
   if (!check_write_file_paths_helper(contexts->GetAllOutPath())) return;
 
-  // Symmetric Encrypt
-  if (is_symmetric) {
-    auto f_context = contexts->GetContext(0);
-    if (f_context != nullptr) build_operas_file_symmetric_encrypt(f_context);
-
-    auto d_context = contexts->GetContext(1);
-    if (d_context != nullptr) {
-      build_operas_directory_symmetric_encrypt(d_context);
-    }
-  } else {
-    auto f_context = contexts->GetContext(0);
-    if (f_context != nullptr) build_operas_file_encrypt(f_context);
+  GpgOperaHelper::BuildOperas(contexts, 0,
+                              m_key_list_->GetCurrentGpgContextChannel(),
+                              GpgOperaHelper::BuildOperasFileEncrypt);
 
-    auto d_context = contexts->GetContext(1);
-    if (d_context != nullptr) build_operas_directory_encrypt(d_context);
-  }
+  GpgOperaHelper::BuildOperas(contexts, 1,
+                              m_key_list_->GetCurrentGpgContextChannel(),
+                              GpgOperaHelper::BuildOperasDirectoryEncrypt);
 
   execute_operas_helper(tr("Encrypting"), contexts);
 }
 
-/**
- * @brief
- *
- * @param context
- */
-void MainWindow::build_operas_file_decrypt(
-    QSharedPointer<GpgOperaContext>& context) {
-  assert(context->paths.size() == context->o_paths.size());
-
-  for (int i = 0; i < context->paths.size(); i++) {
-    const auto& path = context->paths[i];
-    const auto& o_path = context->o_paths[i];
-
-    auto opera = [=, &opera_results =
-                         context->opera_results](const OperaWaitingHd& op_hd) {
-      GpgFileOpera::GetInstance(m_key_list_->GetCurrentGpgContextChannel())
-          .DecryptFile(
-              path, o_path,
-              [=, &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<GpgDecryptResult>()) {
-                  QMessageBox::critical(this, tr("Error"),
-                                        tr("Unknown error occurred"));
-                  return;
-                }
-
-                auto result = ExtractParams<GpgDecryptResult>(data_obj, 0);
-                auto result_analyse = GpgDecryptResultAnalyse(
-                    m_key_list_->GetCurrentGpgContextChannel(), err, result);
-                result_analyse.Analyse();
-
-                opera_results.append({result_analyse.GetStatus(),
-                                      result_analyse.GetResultReport(),
-                                      QFileInfo(path).fileName()});
-              });
-    };
-
-    context->operas.push_back(opera);
-  }
-}
-
-void MainWindow::build_operas_archive_decrypt(
-    QSharedPointer<GpgOperaContext>& context) {
-  assert(context->paths.size() == context->o_paths.size());
-
-  for (int i = 0; i < context->paths.size(); i++) {
-    const auto& path = context->paths[i];
-    const auto& o_path = context->o_paths[i];
-
-    auto opera = [=, &opera_results =
-                         context->opera_results](const OperaWaitingHd& op_hd) {
-      GpgFileOpera::GetInstance(m_key_list_->GetCurrentGpgContextChannel())
-          .DecryptArchive(
-              path, o_path,
-              [=, &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<GpgDecryptResult>()) {
-                  QMessageBox::critical(this, tr("Error"),
-                                        tr("Unknown error occurred"));
-                  return;
-                }
-
-                auto result = ExtractParams<GpgDecryptResult>(data_obj, 0);
-                auto result_analyse = GpgDecryptResultAnalyse(
-                    m_key_list_->GetCurrentGpgContextChannel(), err, result);
-                result_analyse.Analyse();
-
-                opera_results.append({result_analyse.GetStatus(),
-                                      result_analyse.GetResultReport(),
-                                      QFileInfo(path).fileName()});
-              });
-    };
-
-    context->operas.push_back(opera);
-  }
-}
-
 void MainWindow::SlotFileDecrypt(const QStringList& paths) {
-  auto contexts = QSharedPointer<GpgOperaContexts>::create();
+  auto contexts = QSharedPointer<GpgOperaContextBasement>::create();
 
   contexts->ascii = true;
 
@@ -477,58 +218,19 @@ void MainWindow::SlotFileDecrypt(const QStringList& paths) {
 
   if (!check_write_file_paths_helper(contexts->GetAllOutPath())) return;
 
-  auto f_context = contexts->GetContext(0);
-  if (f_context != nullptr) build_operas_file_decrypt(f_context);
+  GpgOperaHelper::BuildOperas(contexts, 0,
+                              m_key_list_->GetCurrentGpgContextChannel(),
+                              GpgOperaHelper::BuildOperasFileDecrypt);
 
-  auto d_context = contexts->GetContext(1);
-  if (d_context != nullptr) {
-    build_operas_archive_decrypt(d_context);
-  }
+  GpgOperaHelper::BuildOperas(contexts, 1,
+                              m_key_list_->GetCurrentGpgContextChannel(),
+                              GpgOperaHelper::BuildOperasArchiveDecrypt);
 
   execute_operas_helper(tr("Decrypting"), contexts);
 }
 
-void MainWindow::build_operas_file_sign(
-    QSharedPointer<GpgOperaContext>& context) {
-  assert(context->paths.size() == context->o_paths.size());
-
-  for (int i = 0; i < context->paths.size(); i++) {
-    const auto& path = context->paths[i];
-    const auto& o_path = context->o_paths[i];
-
-    auto opera = [=, &opera_results =
-                         context->opera_results](const OperaWaitingHd& op_hd) {
-      GpgFileOpera::GetInstance(m_key_list_->GetCurrentGpgContextChannel())
-          .SignFile(
-              context->keys, path, context->ascii, o_path,
-              [=, &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<GpgSignResult>()) {
-                  QMessageBox::critical(this, tr("Error"),
-                                        tr("Unknown error occurred"));
-                  return;
-                }
-
-                auto result = ExtractParams<GpgSignResult>(data_obj, 0);
-                auto result_analyse = GpgSignResultAnalyse(
-                    m_key_list_->GetCurrentGpgContextChannel(), err, result);
-                result_analyse.Analyse();
-
-                opera_results.append({result_analyse.GetStatus(),
-                                      result_analyse.GetResultReport(),
-                                      QFileInfo(path).fileName()});
-              });
-    };
-
-    context->operas.push_back(opera);
-  }
-}
-
 void MainWindow::SlotFileSign(const QStringList& paths) {
-  auto contexts = QSharedPointer<GpgOperaContexts>::create();
+  auto contexts = QSharedPointer<GpgOperaContextBasement>::create();
 
   bool const non_ascii_at_file_operation =
       GetSettings().value("gnupg/non_ascii_at_file_operation", true).toBool();
@@ -536,12 +238,11 @@ void MainWindow::SlotFileSign(const QStringList& paths) {
   contexts->ascii = !non_ascii_at_file_operation;
 
   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."));
+      tr("The selected key contains a key that does not actually have a "
+         "sign usage."));
   if (contexts->keys.empty()) return;
 
   if (!check_read_file_paths_helper(paths)) return;
@@ -555,59 +256,15 @@ void MainWindow::SlotFileSign(const QStringList& paths) {
 
   if (!check_write_file_paths_helper(contexts->GetAllOutPath())) return;
 
-  auto f_context = contexts->GetContext(0);
-  if (f_context != nullptr) build_operas_file_sign(f_context);
+  GpgOperaHelper::BuildOperas(contexts, 0,
+                              m_key_list_->GetCurrentGpgContextChannel(),
+                              GpgOperaHelper::BuildOperasFileSign);
 
   execute_operas_helper(tr("Signing"), contexts);
 }
 
-void MainWindow::build_operas_file_verify(
-    QSharedPointer<GpgOperaContext>& context) {
-  assert(context->paths.size() == context->o_paths.size());
-
-  for (int i = 0; i < context->paths.size(); i++) {
-    const auto& path = context->paths[i];
-    const auto& o_path = context->o_paths[i];
-
-    auto opera = [=, &opera_results =
-                         context->opera_results](const OperaWaitingHd& op_hd) {
-      GpgFileOpera::GetInstance(m_key_list_->GetCurrentGpgContextChannel())
-          .VerifyFile(
-              o_path, path,
-              [=, &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<GpgVerifyResult>()) {
-                  QMessageBox::critical(this, tr("Error"),
-                                        tr("Unknown error occurred"));
-                  return;
-                }
-
-                auto result = ExtractParams<GpgVerifyResult>(data_obj, 0);
-                auto result_analyse = GpgVerifyResultAnalyse(
-                    m_key_list_->GetCurrentGpgContextChannel(), err, result);
-                result_analyse.Analyse();
-
-                slot_result_analyse_show_helper(result_analyse);
-
-                opera_results.append(
-                    {result_analyse.GetStatus(),
-                     result_analyse.GetResultReport(),
-                     QFileInfo(path.isEmpty() ? o_path : path).fileName()});
-
-                context->unknown_fprs = result_analyse.GetUnknownSignatures();
-              });
-    };
-
-    context->operas.push_back(opera);
-  }
-}
-
 void MainWindow::SlotFileVerify(const QStringList& paths) {
-  auto contexts = QSharedPointer<GpgOperaContexts>::create();
+  auto contexts = QSharedPointer<GpgOperaContextBasement>::create();
 
   if (!check_read_file_paths_helper(paths)) return;
 
@@ -645,121 +302,19 @@ void MainWindow::SlotFileVerify(const QStringList& paths) {
     contexts->GetContextOutPath(0).append(data_file_path);
   }
 
-  auto f_context = contexts->GetContext(0);
-  if (f_context != nullptr) build_operas_file_verify(f_context);
+  GpgOperaHelper::BuildOperas(contexts, 0,
+                              m_key_list_->GetCurrentGpgContextChannel(),
+                              GpgOperaHelper::BuildOperasFileVerify);
 
   execute_operas_helper(tr("Verifying"), contexts);
 
-  if (!contexts->unknown_fprs.isEmpty() &&
-      Module::IsModuleActivate(kKeyServerSyncModuleID)) {
+  if (!contexts->unknown_fprs.isEmpty()) {
     slot_verifying_unknown_signature_helper(contexts->unknown_fprs);
   }
 }
 
-void MainWindow::build_operas_file_encrypt_sign(
-    QSharedPointer<GpgOperaContext>& context) {
-  assert(context->paths.size() == context->o_paths.size());
-
-  for (int i = 0; i < context->paths.size(); i++) {
-    const auto& path = context->paths[i];
-    const auto& o_path = context->o_paths[i];
-
-    auto opera = [=, &opera_results =
-                         context->opera_results](const OperaWaitingHd& op_hd) {
-      GpgFileOpera::GetInstance(m_key_list_->GetCurrentGpgContextChannel())
-          .EncryptSignFile(
-              context->keys, context->singer_keys, path, context->ascii, o_path,
-              [=, &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<GpgEncryptResult, GpgSignResult>()) {
-                  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 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();
-
-                opera_results.append(
-                    {std::min(encrypt_result_analyse.GetStatus(),
-                              sign_result_analyse.GetStatus()),
-                     encrypt_result_analyse.GetResultReport() +
-                         sign_result_analyse.GetResultReport(),
-                     QFileInfo(path).fileName()});
-              });
-    };
-
-    context->operas.push_back(opera);
-  }
-}
-
-void MainWindow::build_operas_directory_encrypt_sign(
-    QSharedPointer<GpgOperaContext>& context) {
-  assert(context->paths.size() == context->o_paths.size());
-
-  for (int i = 0; i < context->paths.size(); i++) {
-    const auto& path = context->paths[i];
-    const auto& o_path = context->o_paths[i];
-
-    auto opera = [=, &opera_results =
-                         context->opera_results](const OperaWaitingHd& op_hd) {
-      GpgFileOpera::GetInstance(m_key_list_->GetCurrentGpgContextChannel())
-          .EncryptSignDirectory(
-              context->keys, context->singer_keys, path, context->ascii, o_path,
-              [=, &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<GpgEncryptResult, GpgSignResult>()) {
-                  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 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();
-
-                opera_results.append(
-                    {std::min(encrypt_result_analyse.GetStatus(),
-                              sign_result_analyse.GetStatus()),
-                     encrypt_result_analyse.GetResultReport() +
-                         sign_result_analyse.GetResultReport(),
-                     QFileInfo(path).fileName()});
-              });
-    };
-
-    context->operas.push_back(opera);
-  }
-}
-
 void MainWindow::SlotFileEncryptSign(const QStringList& paths) {
-  auto contexts = QSharedPointer<GpgOperaContexts>::create();
+  auto contexts = QSharedPointer<GpgOperaContextBasement>::create();
 
   bool const non_ascii_at_file_operation =
       GetSettings().value("gnupg/non_ascii_at_file_operation", true).toBool();
@@ -809,127 +364,19 @@ void MainWindow::SlotFileEncryptSign(const QStringList& paths) {
 
   if (!check_write_file_paths_helper(contexts->GetAllOutPath())) return;
 
-  auto f_context = contexts->GetContext(0);
-  if (f_context != nullptr) build_operas_file_encrypt_sign(f_context);
+  GpgOperaHelper::BuildOperas(contexts, 0,
+                              m_key_list_->GetCurrentGpgContextChannel(),
+                              GpgOperaHelper::BuildOperasFileEncryptSign);
 
-  auto d_context = contexts->GetContext(1);
-  if (d_context != nullptr) build_operas_directory_encrypt_sign(d_context);
+  GpgOperaHelper::BuildOperas(contexts, 1,
+                              m_key_list_->GetCurrentGpgContextChannel(),
+                              GpgOperaHelper::BuildOperasDirectoryEncryptSign);
 
   execute_operas_helper(tr("Encrypting and Signing"), contexts);
 }
 
-void MainWindow::build_operas_file_decrypt_verify(
-    QSharedPointer<GpgOperaContext>& context) {
-  assert(context->paths.size() == context->o_paths.size());
-
-  for (int i = 0; i < context->paths.size(); i++) {
-    const auto& path = context->paths[i];
-    const auto& o_path = context->o_paths[i];
-
-    auto opera = [=, &opera_results =
-                         context->opera_results](const OperaWaitingHd& op_hd) {
-      GpgFileOpera::GetInstance(m_key_list_->GetCurrentGpgContextChannel())
-          .DecryptVerifyFile(
-              path, o_path,
-              [=, &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<GpgDecryptResult, GpgVerifyResult>()) {
-                  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 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();
-
-                opera_results.append(
-                    {std::min(decrypt_result_analyse.GetStatus(),
-                              verify_result_analyse.GetStatus()),
-                     decrypt_result_analyse.GetResultReport() +
-                         verify_result_analyse.GetResultReport(),
-                     QFileInfo(path).fileName()});
-
-                context->unknown_fprs =
-                    verify_result_analyse.GetUnknownSignatures();
-              });
-    };
-
-    context->operas.push_back(opera);
-  }
-}
-
-void MainWindow::build_operas_archive_decrypt_verify(
-    QSharedPointer<GpgOperaContext>& context) {
-  assert(context->paths.size() == context->o_paths.size());
-
-  for (int i = 0; i < context->paths.size(); i++) {
-    const auto& path = context->paths[i];
-    const auto& o_path = context->o_paths[i];
-
-    auto opera = [=, &opera_results =
-                         context->opera_results](const OperaWaitingHd& op_hd) {
-      GpgFileOpera::GetInstance(m_key_list_->GetCurrentGpgContextChannel())
-          .DecryptVerifyArchive(
-              path, o_path,
-              [=, &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<GpgDecryptResult, GpgVerifyResult>()) {
-                  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 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();
-
-                opera_results.append(
-                    {std::min(decrypt_result_analyse.GetStatus(),
-                              verify_result_analyse.GetStatus()),
-                     decrypt_result_analyse.GetResultReport() +
-                         verify_result_analyse.GetResultReport(),
-                     QFileInfo(path).fileName()});
-
-                context->unknown_fprs =
-                    verify_result_analyse.GetUnknownSignatures();
-              });
-    };
-
-    context->operas.push_back(opera);
-  }
-}
-
 void MainWindow::SlotFileDecryptVerify(const QStringList& paths) {
-  auto contexts = QSharedPointer<GpgOperaContexts>::create();
+  auto contexts = QSharedPointer<GpgOperaContextBasement>::create();
 
   contexts->ascii = true;
 
@@ -952,18 +399,17 @@ void MainWindow::SlotFileDecryptVerify(const QStringList& paths) {
 
   if (!check_write_file_paths_helper(contexts->GetAllOutPath())) return;
 
-  auto f_context = contexts->GetContext(0);
-  if (f_context != nullptr) build_operas_file_decrypt_verify(f_context);
+  GpgOperaHelper::BuildOperas(contexts, 0,
+                              m_key_list_->GetCurrentGpgContextChannel(),
+                              GpgOperaHelper::BuildOperasFileDecryptVerify);
 
-  auto d_context = contexts->GetContext(1);
-  if (d_context != nullptr) {
-    build_operas_archive_decrypt_verify(d_context);
-  }
+  GpgOperaHelper::BuildOperas(contexts, 1,
+                              m_key_list_->GetCurrentGpgContextChannel(),
+                              GpgOperaHelper::BuildOperasArchiveDecryptVerify);
 
   execute_operas_helper(tr("Decrypting and Verifying"), contexts);
 
-  if (!contexts->unknown_fprs.isEmpty() &&
-      Module::IsModuleActivate(kKeyServerSyncModuleID)) {
+  if (!contexts->unknown_fprs.isEmpty()) {
     slot_verifying_unknown_signature_helper(contexts->unknown_fprs);
   }
 };
@@ -978,10 +424,10 @@ void MainWindow::SlotFileVerifyEML(const QString& path) {
 
   QFileInfo file_info(path);
   if (file_info.size() > static_cast<qint64>(1024 * 1024 * 32)) {
-    QMessageBox::warning(
-        this, tr("EML File Too Large"),
-        tr("The EML file \"%1\" is larger than 32MB and will not be opened.")
-            .arg(file_info.fileName()));
+    QMessageBox::warning(this, tr("EML File Too Large"),
+                         tr("The EML file \"%1\" is larger than 32MB and "
+                            "will not be opened.")
+                             .arg(file_info.fileName()));
     return;
   }
 
diff --git a/src/ui/struct/GpgOperaResultContext.cpp b/src/ui/struct/GpgOperaResultContext.cpp
index b1dfba63..5640a204 100644
--- a/src/ui/struct/GpgOperaResultContext.cpp
+++ b/src/ui/struct/GpgOperaResultContext.cpp
@@ -28,30 +28,24 @@
 
 #include "GpgOperaResultContext.h"
 
+#include <utility>
+
 namespace GpgFrontend::UI {
 
-GpgOperaContext::GpgOperaContext(QContainer<OperaWaitingCb>& operas,
-                                 QContainer<GpgOperaResult>& opera_results,
-                                 GpgKeyList& keys, GpgKeyList& singer_keys,
-                                 QStringList& unknown_fprs, bool ascii)
-    : operas(operas),
-      opera_results(opera_results),
-      keys(keys),
-      singer_keys(singer_keys),
-      unknown_fprs(unknown_fprs),
-      ascii(ascii) {}
+GpgOperaContext::GpgOperaContext(QSharedPointer<GpgOperaContextBasement> base)
+    : base(std::move(base)) {}
 
-auto GpgOperaContexts::GetContextPath(int category) -> QStringList& {
+auto GpgOperaContextBasement::GetContextPath(int category) -> QStringList& {
   if (!categories.contains(category)) categories[category] = {};
   return categories[category].paths;
 }
 
-auto GpgOperaContexts::GetContextOutPath(int category) -> QStringList& {
+auto GpgOperaContextBasement::GetContextOutPath(int category) -> QStringList& {
   if (!categories.contains(category)) categories[category] = {};
   return categories[category].o_paths;
 }
 
-auto GpgOperaContexts::GetAllPath() -> QStringList {
+auto GpgOperaContextBasement::GetAllPath() -> QStringList {
   QStringList res;
 
   for (auto& category : categories) {
@@ -60,7 +54,7 @@ auto GpgOperaContexts::GetAllPath() -> QStringList {
   return res;
 }
 
-auto GpgOperaContexts::GetAllOutPath() -> QStringList {
+auto GpgOperaContextBasement::GetAllOutPath() -> QStringList {
   QStringList res;
 
   for (auto& category : categories) {
@@ -69,16 +63,15 @@ auto GpgOperaContexts::GetAllOutPath() -> QStringList {
   return res;
 }
 
-auto GpgOperaContexts::GetContext(int category)
-    -> QSharedPointer<GpgOperaContext> {
-  if (GetContextPath(category).empty()) return nullptr;
+auto GetGpgOperaContextFromBasement(
+    const QSharedPointer<GpgOperaContextBasement>& base,
+    int category) -> QSharedPointer<GpgOperaContext> {
+  if (base->GetContextPath(category).empty()) return nullptr;
 
-  auto context = QSharedPointer<GpgOperaContext>::create(
-      operas, opera_results, keys, singer_keys, unknown_fprs, ascii);
-  context->ascii = ascii;
+  auto context = QSharedPointer<GpgOperaContext>::create(base);
 
-  context->paths = GetContextPath(category);
-  context->o_paths = GetContextOutPath(category);
+  context->paths = base->GetContextPath(category);
+  context->o_paths = base->GetContextOutPath(category);
   return context;
 }
 }  // namespace GpgFrontend::UI
\ No newline at end of file
diff --git a/src/ui/struct/GpgOperaResultContext.h b/src/ui/struct/GpgOperaResultContext.h
index 25a6ff28..526c1ef7 100644
--- a/src/ui/struct/GpgOperaResultContext.h
+++ b/src/ui/struct/GpgOperaResultContext.h
@@ -38,23 +38,9 @@ struct GpgOperaCategory {
   QStringList o_paths;
 };
 
-struct GpgOperaContext {
-  QContainer<OperaWaitingCb>& operas;
-  QContainer<GpgOperaResult>& opera_results;
-  GpgKeyList& keys;
-  GpgKeyList& singer_keys;
-  QStringList& unknown_fprs;
-  bool ascii;
-
-  QStringList paths;
-  QStringList o_paths;
-
-  GpgOperaContext(QContainer<OperaWaitingCb>& operas,
-                  QContainer<GpgOperaResult>& opera_results, GpgKeyList& keys,
-                  GpgKeyList& singer_keys, QStringList& unknown_fprs, bool ascii);
-};
+struct GpgOperaContext;
 
-struct GpgOperaContexts {
+struct GpgOperaContextBasement {
   QContainer<OperaWaitingCb> operas;
   QContainer<GpgOperaResult> opera_results;
   GpgKeyList keys;
@@ -71,8 +57,19 @@ struct GpgOperaContexts {
   auto GetAllPath() -> QStringList;
 
   auto GetAllOutPath() -> QStringList;
+};
+
+struct GpgOperaContext {
+  QSharedPointer<GpgOperaContextBasement> base;
 
-  auto GetContext(int category) -> QSharedPointer<GpgOperaContext>;
+  QStringList paths;
+  QStringList o_paths;
+
+  explicit GpgOperaContext(QSharedPointer<GpgOperaContextBasement> base);
 };
 
+auto GetGpgOperaContextFromBasement(
+    const QSharedPointer<GpgOperaContextBasement>& base,
+    int category) -> QSharedPointer<GpgOperaContext>;
+
 }  // namespace GpgFrontend::UI
\ No newline at end of file