Merge branch 'dev/2.1.5/mingw' into develop

1 files changed, 454 insertions, 147 deletions

diff --git a/src/ui/main_window/MainWindowSlotFunction.cpp b/src/ui/main_window/MainWindowSlotFunction.cpp
index c7579ff9..ea772b3e 100644
--- a/src/ui/main_window/MainWindowSlotFunction.cpp
+++ b/src/ui/main_window/MainWindowSlotFunction.cpp
@@ -31,12 +31,18 @@
 #include "core/function/gpg/GpgKeyGetter.h"
 #include "core/function/gpg/GpgKeyImportExporter.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/module/ModuleManager.h"
 #include "core/typedef/GpgTypedef.h"
 #include "core/utils/CommonUtils.h"
 #include "core/utils/GpgUtils.h"
+#include "ui/UIModuleManager.h"
 #include "ui/UserInterfaceUtils.h"
+#include "ui/dialog/SignersPicker.h"
 #include "ui/dialog/help/AboutDialog.h"
 #include "ui/dialog/import_export/KeyUploadDialog.h"
 #include "ui/dialog/keypair_details/KeyDetailsDialog.h"
@@ -350,53 +356,31 @@ void MainWindow::slot_import_key_from_edit() {
 }
 
 void MainWindow::slot_verify_email_by_eml_data(const QByteArray& buffer) {
-  Module::TriggerEvent(
-      "EMAIL_VERIFY_EML_DATA",
-      {
-          {"eml_data", QString::fromLatin1(buffer.toBase64())},
-      },
-      [=](Module::EventIdentifier i, Module::Event::ListenerIdentifier ei,
-          Module::Event::Params p) {
-        LOG_D() << "EMAIL_VERIFY_EML_DATA callback: " << i << ei;
-        if (p["ret"] != "0" || !p["err"].isEmpty()) {
-          LOG_E() << "An error occurred trying to verify email, "
-                  << "error message: " << p["err"];
-
-          if (p["ret"] == "-2") {
-            QString detailed_error = p["err"];
-
-            QString info =
-                tr("# EML Data Error\n\n"
-                   "The provided EML data does not conform to the "
-                   "structure described in RFC 3156 and cannot be "
-                   "validated.\n\n"
-                   "Details: %1\n\n"
-                   "What is EML Data?\n"
-                   "EML is a file format used to represent email messages. "
-                   "It typically contains the entire contents of an email, "
-                   "including headers, "
-                   "body text, attachments, and metadata. In order to validate "
-                   "the email properly, it is necessary to provide the "
-                   "complete, original EML "
-                   "data.\n\n"
-                   "For more information about the expected EML structure, "
-                   "please refer to the RFC 3156 standard:\n"
-                   "%2\n\n"
-                   "Please ensure the EML data follows the standard and try "
-                   "again.")
-                    .arg(detailed_error)
-                    .arg("https://www.rfc-editor.org/rfc/rfc3156.txt");
-            slot_refresh_info_board(-2, info);
-          }
-
-          return;
-        }
+  CommonUtils::WaitForOpera(
+      this, tr("Verifying"), [this, buffer](const OperaWaitingHd& hd) {
+        Module::TriggerEvent(
+            "EMAIL_VERIFY_EML_DATA",
+            {
+                {"eml_data", QString::fromLatin1(buffer.toBase64())},
+                {"channel",
+                 QString::number(m_key_list_->GetCurrentGpgContextChannel())},
+            },
+            [=](Module::EventIdentifier i, Module::Event::ListenerIdentifier ei,
+                Module::Event::Params p) {
+              LOG_D() << "EMAIL_VERIFY_EML_DATA callback: " << i << ei;
+
+              // end waiting dialog
+              hd();
 
-        if (p.contains("signature") && p.contains("mime")) {
-          slot_verify_email_by_eml_data_result_helper(p);
-        }
+              // check if error occurred
+              if (slot_handle_module_error(p)) return -1;
 
-        LOG_E() << "mime or signature data is missing";
+              if (p.contains("signature") && p.contains("mime")) {
+                slot_verify_email_by_eml_data_result_helper(p);
+              }
+
+              return 0;
+            });
       });
 }
 
@@ -405,49 +389,21 @@ void MainWindow::slot_decrypt_email_by_eml_data(const QByteArray& buffer) {
       "EMAIL_DECRYPT_EML_DATA",
       {
           {"eml_data", QString::fromLatin1(buffer.toBase64())},
+          {"channel",
+           QString::number(m_key_list_->GetCurrentGpgContextChannel())},
       },
       [=](Module::EventIdentifier i, Module::Event::ListenerIdentifier ei,
           Module::Event::Params p) {
         LOG_D() << "EMAIL_DECRYPT_EML_DATA callback: " << i << ei;
-        if (p["ret"] != "0" || !p["err"].isEmpty()) {
-          LOG_E() << "An error occurred trying to decrypt email, "
-                  << "error message: " << p["err"];
-
-          if (p["ret"] == "-2") {
-            QString detailed_error = p["err"];
-
-            QString info =
-                tr("# EML Data Error\n\n"
-                   "The provided EML data does not conform to the "
-                   "structure described in RFC 3156 and cannot be "
-                   "validated.\n\n"
-                   "Details: %1\n\n"
-                   "What is EML Data?\n"
-                   "EML is a file format used to represent email messages. "
-                   "It typically contains the entire contents of an email, "
-                   "including headers, "
-                   "body text, attachments, and metadata. In order to validate "
-                   "the email properly, it is necessary to provide the "
-                   "complete, original EML "
-                   "data.\n\n"
-                   "For more information about the expected EML structure, "
-                   "please refer to the RFC 3156 standard:\n"
-                   "%2\n\n"
-                   "Please ensure the EML data follows the standard and try "
-                   "again.")
-                    .arg(detailed_error)
-                    .arg("https://www.rfc-editor.org/rfc/rfc3156.txt");
-            slot_refresh_info_board(-2, info);
-          }
-
-          return;
-        }
 
-        if (p.contains("encrypted")) {
+        // check if error occurred
+        if (slot_handle_module_error(p)) return -1;
+
+        if (p.contains("eml_data")) {
           slot_decrypt_email_by_eml_data_result_helper(p);
         }
 
-        LOG_E() << "mime or signature data is missing";
+        return 0;
       });
 }
 
@@ -540,50 +496,25 @@ void MainWindow::slot_verify_email_by_eml_data_result_helper(
                         .arg(prm_micalg_value));
   email_info.append("\n");
 
-  // set input buffer
-  auto raw_data_buffer = GFBuffer(mime);
-  auto signature_buffer = GFBuffer(signature);
+  if (!p["capsule_id"].isEmpty()) {
+    auto v =
+        UIModuleManager::GetInstance().GetCapsule(p.value("capsule_id", ""));
 
-  CommonUtils::WaitForOpera(
-      this, tr("Verifying"),
-      [this, email_info, raw_data_buffer,
-       signature_buffer](const OperaWaitingHd& hd) {
-        GpgFrontend::GpgBasicOperator::GetInstance(
-            m_key_list_->GetCurrentGpgContextChannel())
-            .Verify(
-                raw_data_buffer, signature_buffer,
-                [this, email_info, 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();
-                  auto verify_result_report = result_analyse.GetResultReport();
+    try {
+      auto sign_result = std::any_cast<GpgVerifyResult>(v);
+      auto result_analyse =
+          GpgVerifyResultAnalyse(m_key_list_->GetCurrentGpgContextChannel(),
+                                 GPG_ERR_NO_ERROR, sign_result);
+      result_analyse.Analyse();
 
-                  slot_refresh_info_board(result_analyse.GetStatus(),
-                                          email_info + verify_result_report);
+      slot_refresh_info_board(result_analyse.GetStatus(),
+                              email_info + result_analyse.GetResultReport());
 
-                  if (!result_analyse.GetUnknownSignatures().isEmpty() &&
-                      Module::IsModuleActivate(kKeyServerSyncModuleID)) {
-                    slot_verifying_unknown_signature_helper(result_analyse);
-                    return;
-                  }
-                });
-      });
+    } catch (const std::bad_any_cast& e) {
+      LOG_E() << "capsule" << p["capsule_id"] << "convert to real type failed"
+              << e.what();
+    }
+  }
 }
 
 void MainWindow::slot_eml_verify_show_helper(const QString& email_info,
@@ -628,14 +559,15 @@ void MainWindow::SlotDecryptEML() {
 
 void MainWindow::slot_decrypt_email_by_eml_data_result_helper(
     const QMap<QString, QString>& p) {
-  const auto encrypted = QByteArray::fromBase64(p["encrypted"].toLatin1());
-
   auto timestamp = p.value("datetime", "-1").toLongLong();
   auto datetime = tr("None");
   if (timestamp > 0) {
     datetime = QLocale().toString(QDateTime::fromMSecsSinceEpoch(timestamp));
   }
 
+  const auto eml_data = QByteArray::fromBase64(p["eml_data"].toLatin1());
+  edit_->SlotFillTextEditWithText(eml_data);
+
   QString email_info;
   email_info.append("# E-Mail Information\n\n");
   email_info.append(QString("- %1: %2\n")
@@ -654,39 +586,414 @@ void MainWindow::slot_decrypt_email_by_eml_data_result_helper(
 
   email_info.append("\n");
 
-  // data to transfer into task
-  auto buffer = GFBuffer(encrypted);
+  if (!p["capsule_id"].isEmpty()) {
+    auto v =
+        UIModuleManager::GetInstance().GetCapsule(p.value("capsule_id", ""));
+
+    try {
+      auto sign_result = std::any_cast<GpgDecryptResult>(v);
+      auto result_analyse =
+          GpgDecryptResultAnalyse(m_key_list_->GetCurrentGpgContextChannel(),
+                                  GPG_ERR_NO_ERROR, sign_result);
+      result_analyse.Analyse();
+
+      slot_refresh_info_board(result_analyse.GetStatus(),
+                              email_info + result_analyse.GetResultReport());
+
+    } catch (const std::bad_any_cast& e) {
+      LOG_E() << "capsule" << p["capsule_id"] << "convert to real type failed"
+              << e.what();
+    }
+  }
+}
+
+void MainWindow::SlotEncryptEML() {
+  if (edit_->TabCount() == 0 || edit_->CurEMailPage() == nullptr) return;
+  auto checked_keys = m_key_list_->GetCheckedKeys();
+
+  if (checked_keys.isEmpty()) {
+    QMessageBox::warning(this, tr("No Key Selected"),
+                         tr("Please select a key for encrypt the EML."));
+    return;
+  }
+  auto buffer = edit_->CurPlainText().toUtf8();
 
   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
+      this, tr("Encrypting"),
+      [this, buffer, checked_keys](const OperaWaitingHd& hd) {
+        Module::TriggerEvent(
+            "EMAIL_ENCRYPT_EML_DATA",
+            {
+                {"body_data", QString::fromLatin1(buffer.toBase64())},
+                {"channel",
+                 QString::number(m_key_list_->GetCurrentGpgContextChannel())},
+                {"encrypt_keys", checked_keys.join(';')},
+            },
+
+            [=](Module::EventIdentifier i, Module::Event::ListenerIdentifier ei,
+                Module::Event::Params p) {
+              LOG_D() << "EMAIL_ENCRYPT_EML_DATA callback: " << i << ei;
+
+              // close waiting dialog
               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"));
+              if (p["ret"] != "0" || !p["err"].isEmpty()) {
+                LOG_E() << "An error occurred trying to decrypt email, "
+                        << "error message: " << p["err"];
+
                 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());
+
+              if (!p["eml_data"].isEmpty()) {
+                edit_->SlotSetText2CurEMailPage(p.value("eml_data", ""));
+              }
+
+              if (!p["capsule_id"].isEmpty()) {
+                auto v = UIModuleManager::GetInstance().GetCapsule(
+                    p.value("capsule_id", ""));
+
+                try {
+                  auto encr_result = std::any_cast<GpgEncryptResult>(v);
+                  auto result_analyse = GpgEncryptResultAnalyse(
+                      m_key_list_->GetCurrentGpgContextChannel(),
+                      GPG_ERR_NO_ERROR, encr_result);
+                  result_analyse.Analyse();
+                  slot_result_analyse_show_helper(result_analyse);
+
+                } catch (const std::bad_any_cast& e) {
+                  LOG_E() << "capsule" << p["capsule_id"]
+                          << "convert to real type failed" << e.what();
+                }
+              }
+
+              LOG_E() << "mime or signature data is missing";
+            });
+      });
+}
+
+void MainWindow::SlotSignEML() {
+  if (edit_->TabCount() == 0 || edit_->CurEMailPage() == nullptr) return;
+  auto checked_keys = m_key_list_->GetCheckedKeys();
+
+  if (checked_keys.isEmpty()) {
+    QMessageBox::warning(this, tr("No Key Selected"),
+                         tr("Please select a key for signing the EML."));
+    return;
+  }
+
+  if (checked_keys.size() > 1) {
+    QMessageBox::warning(this, tr("Multiple Keys Selected"),
+                         tr("Please select only one key to sign the EML."));
+    return;
+  }
+
+  auto buffer = edit_->CurPlainText().toUtf8();
+
+  CommonUtils::WaitForOpera(
+      this, tr("Signing"),
+      [this, buffer, checked_keys](const OperaWaitingHd& hd) {
+        Module::TriggerEvent(
+            "EMAIL_SIGN_EML_DATA",
+            {
+                {"body_data", QString::fromLatin1(buffer.toBase64())},
+                {"channel",
+                 QString::number(m_key_list_->GetCurrentGpgContextChannel())},
+                {"sign_key", checked_keys.front()},
+            },
+            [=](Module::EventIdentifier i, Module::Event::ListenerIdentifier ei,
+                Module::Event::Params p) {
+              LOG_D() << "EMAIL_SIGN_EML_DATA callback: " << i << ei;
+
+              // close waiting dialog
+              hd();
+
+              // check if error occurred
+              if (slot_handle_module_error(p)) return -1;
+
+              if (!p["eml_data"].isEmpty()) {
+                edit_->SlotSetText2CurEMailPage(p.value("eml_data", ""));
+              }
+
+              if (!p["capsule_id"].isEmpty()) {
+                auto v = UIModuleManager::GetInstance().GetCapsule(
+                    p.value("capsule_id", ""));
+
+                try {
+                  auto sign_result = std::any_cast<GpgSignResult>(v);
+                  auto result_analyse = GpgSignResultAnalyse(
+                      m_key_list_->GetCurrentGpgContextChannel(),
+                      GPG_ERR_NO_ERROR, sign_result);
+                  result_analyse.Analyse();
+                  slot_result_analyse_show_helper(result_analyse);
+
+                } catch (const std::bad_any_cast& e) {
+                  LOG_E() << "capsule" << p["capsule_id"]
+                          << "convert to real type failed" << e.what();
+                }
               }
+
+              return 0;
             });
       });
 }
 
+void MainWindow::SlotEncryptSignEML() {
+  if (edit_->TabCount() == 0 || edit_->CurEMailPage() == nullptr) return;
+  auto checked_keys = m_key_list_->GetCheckedKeys();
+
+  if (checked_keys.isEmpty()) {
+    QMessageBox::warning(this, tr("No Key Selected"),
+                         tr("Please select a key for encrypt the EML."));
+    return;
+  }
+
+  auto* signers_picker =
+      new SignersPicker(m_key_list_->GetCurrentGpgContextChannel(), this);
+  QEventLoop loop;
+  connect(signers_picker, &SignersPicker::finished, &loop, &QEventLoop::quit);
+  loop.exec();
+
+  // return when canceled
+  if (!signers_picker->GetStatus()) return;
+
+  auto signer_keys = signers_picker->GetCheckedSignerKeyIds();
+
+  if (signer_keys.isEmpty()) {
+    QMessageBox::warning(this, tr("No Key Selected"),
+                         tr("Please select a key for signing the EML."));
+    return;
+  }
+
+  if (signer_keys.size() > 1) {
+    QMessageBox::warning(this, tr("Multiple Keys Selected"),
+                         tr("Please select only one key to sign the EML."));
+    return;
+  }
+
+  auto buffer = edit_->CurPlainText().toUtf8();
+
+  CommonUtils::WaitForOpera(
+      this, tr("Encrypting and Signing"),
+      [this, buffer, checked_keys, signer_keys](const OperaWaitingHd& hd) {
+        Module::TriggerEvent(
+            "EMAIL_ENCRYPT_SIGN_EML_DATA",
+            {
+                {"body_data", QString::fromLatin1(buffer.toBase64())},
+                {"channel",
+                 QString::number(m_key_list_->GetCurrentGpgContextChannel())},
+                {"sign_key", signer_keys.front()},
+                {"encrypt_keys", checked_keys.front()},
+            },
+            [=](Module::EventIdentifier i, Module::Event::ListenerIdentifier ei,
+                Module::Event::Params p) {
+              LOG_D() << "EMAIL_ENCRYPT_SIGN_EML_DATA callback: " << i << ei;
+
+              // close waiting dialog
+              hd();
+
+              // check if error occurred
+              if (slot_handle_module_error(p)) return -1;
+
+              if (!p["sign_capsule_id"].isEmpty() &&
+                  !p["encr_capsule_id"].isEmpty()) {
+                auto v1 = UIModuleManager::GetInstance().GetCapsule(
+                    p.value("sign_capsule_id", ""));
+                auto v2 = UIModuleManager::GetInstance().GetCapsule(
+                    p.value("encr_capsule_id", ""));
+
+                try {
+                  auto sign_result = std::any_cast<GpgSignResult>(v1);
+                  auto encr_result = std::any_cast<GpgSignResult>(v1);
+                  auto sign_result_analyse = GpgSignResultAnalyse(
+                      m_key_list_->GetCurrentGpgContextChannel(),
+                      GPG_ERR_NO_ERROR, sign_result);
+                  auto encr_result_analyse = GpgSignResultAnalyse(
+                      m_key_list_->GetCurrentGpgContextChannel(),
+                      GPG_ERR_NO_ERROR, sign_result);
+
+                  sign_result_analyse.Analyse();
+                  encr_result_analyse.Analyse();
+                  slot_result_analyse_show_helper(sign_result_analyse,
+                                                  encr_result_analyse);
+
+                } catch (const std::bad_any_cast& e) {
+                  LOG_E() << "capsule" << p["capsule_id"]
+                          << "convert to real type failed" << e.what();
+                }
+              }
+
+              return 0;
+            });
+      });
+}
+
+void MainWindow::SlotDecryptVerifyEML() {
+  if (edit_->TabCount() == 0 || edit_->CurEMailPage() == nullptr) return;
+
+  auto buffer = edit_->CurPlainText().toUtf8();
+
+  CommonUtils::WaitForOpera(
+      this, tr("Decrypting and Verifying"),
+      [this, buffer](const OperaWaitingHd& hd) {
+        Module::TriggerEvent(
+            "EMAIL_DECRYPT_VERIFY_EML_DATA",
+            {
+                {"eml_data", QString::fromLatin1(buffer.toBase64())},
+                {"channel",
+                 QString::number(m_key_list_->GetCurrentGpgContextChannel())},
+            },
+            [=](Module::EventIdentifier i, Module::Event::ListenerIdentifier ei,
+                Module::Event::Params p) {
+              LOG_D() << "EMAIL_DECRYPT_VERIFY_EML_DATA callback: " << i << ei;
+
+              // close waiting dialog
+              hd();
+
+              // check if error occurred
+              if (slot_handle_module_error(p)) return -1;
+
+              edit_->SlotSetText2CurEMailPage(p.value("eml_data", ""));
+
+              const auto mime = QByteArray::fromBase64(p["mime"].toLatin1());
+              const auto signature =
+                  QByteArray::fromBase64(p["signature"].toLatin1());
+              const auto part_mime_content_hash = p["mime_hash"];
+              const auto prm_micalg_value = p["micalg"];
+
+              auto timestamp = p.value("datetime", "-1").toLongLong();
+              auto datetime = tr("None");
+              if (timestamp > 0) {
+                datetime = QLocale().toString(
+                    QDateTime::fromMSecsSinceEpoch(timestamp));
+              }
+
+              QString email_info;
+              email_info.append("# E-Mail Information\n\n");
+              email_info.append(QString("- %1: %2\n")
+                                    .arg(tr("From"))
+                                    .arg(p.value("from", tr("Unknown"))));
+              email_info.append(QString("- %1: %2\n")
+                                    .arg(tr("To"))
+                                    .arg(p.value("to", tr("Unknown"))));
+              email_info.append(QString("- %1: %2\n")
+                                    .arg(tr("Subject"))
+                                    .arg(p.value("subject", tr("None"))));
+              email_info.append(QString("- %1: %2\n")
+                                    .arg(tr("CC"))
+                                    .arg(p.value("cc", tr("None"))));
+              email_info.append(QString("- %1: %2\n")
+                                    .arg(tr("BCC"))
+                                    .arg(p.value("bcc", tr("None"))));
+              email_info.append(
+                  QString("- %1: %2\n").arg(tr("Date")).arg(datetime));
+
+              email_info.append("\n");
+              email_info.append("# OpenPGP Information\n\n");
+              email_info.append(QString("- %1: %2\n")
+                                    .arg(tr("Signed EML Data Hash (SHA1)"))
+                                    .arg(part_mime_content_hash));
+              email_info.append(
+                  QString("- %1: %2\n")
+                      .arg(tr("Message Integrity Check Algorithm"))
+                      .arg(prm_micalg_value));
+              email_info.append("\n");
+
+              if (!p["decr_capsule_id"].isEmpty() &&
+                  !p["verify_capsule_id"].isEmpty()) {
+                auto v1 = UIModuleManager::GetInstance().GetCapsule(
+                    p.value("decr_capsule_id", ""));
+                auto v2 = UIModuleManager::GetInstance().GetCapsule(
+                    p.value("verify_capsule_id", ""));
+
+                try {
+                  auto decr_result = std::any_cast<GpgDecryptResult>(v1);
+                  auto verify_result = std::any_cast<GpgVerifyResult>(v2);
+                  auto decr_result_analyse = GpgDecryptResultAnalyse(
+                      m_key_list_->GetCurrentGpgContextChannel(),
+                      GPG_ERR_NO_ERROR, decr_result);
+                  auto verify_result_analyse = GpgVerifyResultAnalyse(
+                      m_key_list_->GetCurrentGpgContextChannel(),
+                      GPG_ERR_NO_ERROR, verify_result);
+
+                  decr_result_analyse.Analyse();
+                  verify_result_analyse.Analyse();
+                  slot_refresh_info_board(
+                      std::min(decr_result_analyse.GetStatus(),
+                               verify_result_analyse.GetStatus()),
+                      email_info + decr_result_analyse.GetResultReport() +
+                          verify_result_analyse.GetResultReport());
+
+                } catch (const std::bad_any_cast& e) {
+                  LOG_E() << "capsule" << p["capsule_id"]
+                          << "convert to real type failed" << e.what();
+                }
+              }
+
+              return 0;
+            });
+      });
+}
+
+auto MainWindow::slot_handle_module_error(const QMap<QString, QString>& p)
+    -> bool {
+  if (p["ret"] == "-2") {
+    QString detailed_error = p["err"];
+
+    QString info =
+        tr("# EML Data Error\n\n"
+           "The provided EML data does not conform to RFC 3156 standards and "
+           "cannot be processed.\n\n"
+           "**Details:** %1\n\n"
+           "### What is EML Data?\n"
+           "EML is a file format for representing email messages, typically "
+           "including headers, body text, attachments, and metadata. "
+           "Complete and properly structured EML data is required for "
+           "validation.\n\n"
+           "### Suggested Solutions\n"
+           "1. Verify the EML data is complete and matches the structure "
+           "outlined in RFC 3156.\n"
+           "2. Refer to the official documentation for the EML structure: "
+           "%2\n\n"
+           "After correcting the EML data, try the operation again.")
+            .arg(detailed_error)
+            .arg("https://www.rfc-editor.org/rfc/rfc3156.txt");
+    slot_refresh_info_board(-2, info);
+    return true;
+  }
+
+  if (p["ret"] != "0" || !p["err"].isEmpty()) {
+    LOG_E() << "An error occurred trying to operate email, "
+            << "error message: " << p["err"];
+
+    QString error_message =
+        tr("# Email Operation Error\n\n"
+           "An error occurred during the email operation. The process "
+           "could not be completed.\n\n"
+           "**Details:**\n"
+           "- **Error Code:** %1\n"
+           "- **Error Message:** %2\n\n"
+           "### Possible Causes\n"
+           "1. The email data may be incomplete or corrupted.\n"
+           "2. The selected GPG key does not have the necessary "
+           "permissions.\n"
+           "3. Issues in the GPG environment or configuration.\n\n"
+           "### Suggested Solutions\n"
+           "1. Ensure the email data is complete and follows the expected "
+           "format.\n"
+           "2. Verify the GPG key has the required access permissions.\n"
+           "3. Check your GPG environment and configuration settings.\n"
+           "4. Review the error details above or application logs for "
+           "further troubleshooting.\n\n"
+           "If the issue persists, consider seeking technical support or "
+           "consulting the documentation.")
+            .arg(p["ret"])
+            .arg(p["err"]);
+
+    slot_refresh_info_board(-1, error_message);
+    return true;
+  }
+
+  return false;
+}
+
 }  // namespace GpgFrontend::UI