Merge pull request #126 from saturneric/dev/2.1.1/main

Develop 2.1.2.1

1 files changed, 140 insertions, 273 deletions

diff --git a/src/ui/dialog/import_export/KeyServerImportDialog.cpp b/src/ui/dialog/import_export/KeyServerImportDialog.cpp
index cf4fbe55..599d512d 100644
--- a/src/ui/dialog/import_export/KeyServerImportDialog.cpp
+++ b/src/ui/dialog/import_export/KeyServerImportDialog.cpp
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2021 Saturneric
+ * Copyright (C) 2021 Saturneric <[email protected]>
  *
  * This file is part of GpgFrontend.
  *
@@ -20,7 +20,7 @@
  * 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.
+ * Saturneric <[email protected]> starting on May 12, 2021.
  *
  * SPDX-License-Identifier: GPL-3.0-or-later
  *
@@ -29,169 +29,115 @@
 #include "KeyServerImportDialog.h"
 
 #include <QRegExp>
-#include <string>
-#include <utility>
 
+#include "core/GpgModel.h"
 #include "core/function/GlobalSettingStation.h"
 #include "core/function/gpg/GpgKeyImportExporter.h"
-#include "thread/KeyServerImportTask.h"
-#include "ui/SignalStation.h"
+#include "ui/UISignalStation.h"
 #include "ui/struct/SettingsObject.h"
+#include "ui/struct/settings/KeyServerSO.h"
+#include "ui/thread/KeyServerImportTask.h"
 #include "ui/thread/KeyServerSearchTask.h"
 
 namespace GpgFrontend::UI {
 
-KeyServerImportDialog::KeyServerImportDialog(bool automatic, QWidget* parent)
-    : GeneralDialog("key_server_import_dialog", parent),
-      m_automatic_(automatic) {
-  // Layout for messagebox
-  auto* message_layout = new QHBoxLayout();
-
-  bool forbid_all_gnupg_connection =
-      GlobalSettingStation::GetInstance().LookupSettings(
-          "network.forbid_all_gnupg_connection", false);
-
+KeyServerImportDialog::KeyServerImportDialog(QWidget* parent)
+    : GeneralDialog("key_server_import_dialog", parent) {
+  auto forbid_all_gnupg_connection =
+      GlobalSettingStation::GetInstance()
+          .GetSettings()
+          .value("network/forbid_all_gnupg_connection", false)
+          .toBool();
   if (forbid_all_gnupg_connection) {
     QMessageBox::critical(this, "Forbidden", "GnuPG is in offline mode now.");
     this->close();
     this->deleteLater();
   }
 
-  if (automatic) {
-    setWindowFlags(Qt::Window | Qt::WindowTitleHint | Qt::CustomizeWindowHint);
-  } else {
-    // Buttons
-
-    close_button_ = new QPushButton(_("Close"));
-    connect(close_button_, &QPushButton::clicked, this,
-            &KeyServerImportDialog::close);
-    import_button_ = new QPushButton(_("Import ALL"));
-    connect(import_button_, &QPushButton::clicked, this,
-            &KeyServerImportDialog::slot_import);
-    import_button_->setDisabled(true);
-    search_button_ = new QPushButton(_("Search"));
-    connect(search_button_, &QPushButton::clicked, this,
-            &KeyServerImportDialog::slot_search);
-
-    // Line edits for search string
-    search_label_ = new QLabel(QString(_("Search String")) + _(": "));
-    search_line_edit_ = new QLineEdit();
-
-    // combobox for keyserver list
-    key_server_label_ = new QLabel(QString(_("Key Server")) + _(": "));
-    key_server_combo_box_ = create_comboBox();
-
-    // table containing the keys found
-    create_keys_table();
-    message_ = new QLabel();
-    message_->setFixedHeight(24);
-    icon_ = new QLabel();
-    icon_->setFixedHeight(24);
-
-    message_layout->addWidget(icon_);
-    message_layout->addWidget(message_);
-    message_layout->addStretch();
-  }
+  // Buttons
+  close_button_ = new QPushButton(tr("Close"));
+  connect(close_button_, &QPushButton::clicked, this,
+          &KeyServerImportDialog::close);
+  import_button_ = new QPushButton(tr("Import ALL"));
+  connect(import_button_, &QPushButton::clicked, this,
+          &KeyServerImportDialog::slot_import);
+  import_button_->setDisabled(true);
+  search_button_ = new QPushButton(tr("Search"));
+  connect(search_button_, &QPushButton::clicked, this,
+          &KeyServerImportDialog::slot_search);
+
+  // Line edits for search string
+  search_label_ = new QLabel(tr("Search String") + tr(": "));
+  search_line_edit_ = new QLineEdit();
+
+  // combobox for keyserver list
+  key_server_label_ = new QLabel(tr("Key Server") + tr(": "));
+  key_server_combo_box_ = create_combo_box();
+
+  // table containing the keys found
+  create_keys_table();
+  message_ = new QLabel();
+  message_->setFixedHeight(24);
+  icon_ = new QLabel();
+  icon_->setFixedHeight(24);
+
+  // Layout for messagebox
+  message_layout_ = new QHBoxLayout();
+  message_layout_->addWidget(icon_);
+  message_layout_->addWidget(message_);
+  message_layout_->addStretch();
 
   // Network Waiting
   waiting_bar_ = new QProgressBar();
   waiting_bar_->setVisible(false);
   waiting_bar_->setRange(0, 0);
   waiting_bar_->setFixedWidth(200);
-  message_layout->addWidget(waiting_bar_);
-
-  auto* mainLayout = new QGridLayout;
-
-  // 自动化调用界面布局
-  if (automatic) {
-    mainLayout->addLayout(message_layout, 0, 0, 1, 3);
-  } else {
-    mainLayout->addWidget(search_label_, 1, 0);
-    mainLayout->addWidget(search_line_edit_, 1, 1);
-    mainLayout->addWidget(search_button_, 1, 2);
-    mainLayout->addWidget(key_server_label_, 2, 0);
-    mainLayout->addWidget(key_server_combo_box_, 2, 1);
-    mainLayout->addWidget(keys_table_, 3, 0, 1, 3);
-    mainLayout->addLayout(message_layout, 4, 0, 1, 3);
-
-    // Layout for import and close button
-    auto* buttonsLayout = new QHBoxLayout;
-    buttonsLayout->addStretch();
-    buttonsLayout->addWidget(import_button_);
-    buttonsLayout->addWidget(close_button_);
-    mainLayout->addLayout(buttonsLayout, 6, 0, 1, 3);
-  }
-
-  this->setLayout(mainLayout);
-  if (automatic)
-    this->setWindowTitle(_("Update Keys from Keyserver"));
-  else
-    this->setWindowTitle(_("Import Keys from Keyserver"));
-
-  if (automatic) {
-    this->setFixedSize(240, 42);
-  }
 
+  auto* main_layout = new QGridLayout();
+
+  main_layout->addWidget(search_label_, 1, 0);
+  main_layout->addWidget(search_line_edit_, 1, 1);
+  main_layout->addWidget(search_button_, 1, 2);
+  main_layout->addWidget(key_server_label_, 2, 0);
+  main_layout->addWidget(key_server_combo_box_, 2, 1);
+  main_layout->addWidget(keys_table_, 3, 0, 1, 3);
+  main_layout->addWidget(waiting_bar_, 4, 0, 1, 3);
+  main_layout->addLayout(message_layout_, 5, 0, 1, 3);
+
+  // Layout for import and close button
+  auto* buttons_layout = new QHBoxLayout();
+  buttons_layout->addStretch();
+  buttons_layout->addWidget(import_button_);
+  buttons_layout->addWidget(close_button_);
+  main_layout->addLayout(buttons_layout, 6, 0, 1, 3);
+
+  this->setLayout(main_layout);
+  this->setWindowTitle(tr("Import Keys from Keyserver"));
   this->setModal(true);
 
-  connect(this, &KeyServerImportDialog::SignalKeyImported,
-          SignalStation::GetInstance(),
-          &SignalStation::SignalKeyDatabaseRefresh);
-}
-
-KeyServerImportDialog::KeyServerImportDialog(QWidget* parent)
-    : GeneralDialog("key_server_import_dialog", parent), m_automatic_(true) {
-  setWindowFlags(Qt::Window | Qt::WindowTitleHint | Qt::CustomizeWindowHint);
-
-  // Network Waiting
-  waiting_bar_ = new QProgressBar();
-  waiting_bar_->setVisible(false);
-  waiting_bar_->setRange(0, 0);
-  waiting_bar_->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
-  waiting_bar_->setTextVisible(false);
-
-  // Layout for messagebox
-  auto* layout = new QHBoxLayout();
-  layout->setContentsMargins(0, 0, 0, 0);
-  layout->setSpacing(0);
-  layout->addWidget(waiting_bar_);
-
-  key_server_combo_box_ = create_comboBox();
+  movePosition2CenterOfParent();
 
-  this->setLayout(layout);
-  this->setWindowTitle(_("Update Keys from Keyserver"));
-  this->setFixedSize(240, 42);
-  this->setModal(true);
+  connect(this, &KeyServerImportDialog::SignalKeyImported,
+          UISignalStation::GetInstance(),
+          &UISignalStation::SignalKeyDatabaseRefresh);
 }
 
-QComboBox* KeyServerImportDialog::create_comboBox() {
-  auto* comboBox = new QComboBox;
-  comboBox->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
+auto KeyServerImportDialog::create_combo_box() -> QComboBox* {
+  auto* combo_box = new QComboBox;
+  combo_box->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
 
   try {
-    SettingsObject key_server_json("key_server");
-
-    const auto key_server_list =
-        key_server_json.Check("server_list", nlohmann::json::array());
-
+    KeyServerSO key_server(SettingsObject("general_settings_state"));
+    const auto& key_server_list = key_server.server_list;
     for (const auto& key_server : key_server_list) {
-      const auto key_server_str = key_server.get<std::string>();
-      comboBox->addItem(key_server_str.c_str());
+      combo_box->addItem(key_server);
     }
-
-    int default_key_server_index = key_server_json.Check("default_server", 0);
-    if (default_key_server_index >= key_server_list.size()) {
-      throw std::runtime_error("default_server index out of range");
-    }
-    std::string default_key_server =
-        key_server_list[default_key_server_index].get<std::string>();
-
-    comboBox->setCurrentText(default_key_server.c_str());
+    combo_box->setCurrentText(key_server.GetTargetServer());
   } catch (...) {
-    SPDLOG_ERROR("setting operation error", "server_list", "default_server");
+    GF_UI_LOG_ERROR("setting operation error", "server_list", "default_server");
   }
 
-  return comboBox;
+  return combo_box;
 }
 
 void KeyServerImportDialog::create_keys_table() {
@@ -206,7 +152,7 @@ void KeyServerImportDialog::create_keys_table() {
   keys_table_->setSelectionMode(QAbstractItemView::SingleSelection);
 
   QStringList labels;
-  labels << _("UID") << _("Creation date") << _("KeyID") << _("Tag");
+  labels << tr("UID") << tr("Creation date") << tr("KeyID") << tr("Tag");
   keys_table_->horizontalHeader()->setSectionResizeMode(
       0, QHeaderView::ResizeToContents);
   keys_table_->setHorizontalHeaderLabels(labels);
@@ -217,27 +163,24 @@ void KeyServerImportDialog::create_keys_table() {
 }
 
 void KeyServerImportDialog::set_message(const QString& text, bool error) {
-  if (m_automatic_) return;
-
   message_->setText(text);
   if (error) {
-    icon_->setPixmap(
-        QPixmap(":error.png").scaled(QSize(24, 24), Qt::KeepAspectRatio));
+    icon_->setPixmap(QPixmap(":/icons/error.png")
+                         .scaled(QSize(24, 24), Qt::KeepAspectRatio));
   } else {
     icon_->setPixmap(
-        QPixmap(":info.png").scaled(QSize(24, 24), Qt::KeepAspectRatio));
+        QPixmap(":/icons/info.png").scaled(QSize(24, 24), Qt::KeepAspectRatio));
   }
 }
 
 void KeyServerImportDialog::slot_search() {
   if (search_line_edit_->text().isEmpty()) {
-    set_message("<h4>" + QString(_("Text is empty.")) + "</h4>", false);
+    set_message("<h4>" + tr("Text is empty.") + "</h4>", false);
     return;
   }
 
-  auto* task = new KeyServerSearchTask(
-      key_server_combo_box_->currentText().toStdString(),
-      search_line_edit_->text().toStdString());
+  auto* task = new KeyServerSearchTask(key_server_combo_box_->currentText(),
+                                       search_line_edit_->text());
 
   connect(task, &KeyServerSearchTask::SignalKeyServerSearchResult, this,
           &KeyServerImportDialog::slot_search_finished);
@@ -267,7 +210,7 @@ void KeyServerImportDialog::slot_search() {
 
 void KeyServerImportDialog::slot_search_finished(
     QNetworkReply::NetworkError error, QByteArray buffer) {
-  SPDLOG_DEBUG("search result {} {}", error, buffer.size());
+  GF_UI_LOG_DEBUG("search result {} {}", error, buffer.size());
 
   keys_table_->clearContents();
   keys_table_->setRowCount(0);
@@ -275,20 +218,20 @@ void KeyServerImportDialog::slot_search_finished(
   auto stream = QTextStream(buffer);
 
   if (error != QNetworkReply::NoError) {
-    SPDLOG_DEBUG("error from reply: {}", error);
+    GF_UI_LOG_DEBUG("error from reply: {}", error);
 
     switch (error) {
       case QNetworkReply::ContentNotFoundError:
-        set_message(_("Not Key Found"), true);
+        set_message(tr("Not Key Found"), true);
         break;
       case QNetworkReply::TimeoutError:
-        set_message(_("Timeout"), true);
+        set_message(tr("Timeout"), true);
         break;
       case QNetworkReply::HostNotFoundError:
-        set_message(_("Key Server Not Found"), true);
+        set_message(tr("Key Server Not Found"), true);
         break;
       default:
-        set_message(_("Connection Error"), true);
+        set_message(tr("Connection Error"), true);
     }
     return;
   }
@@ -297,36 +240,32 @@ void KeyServerImportDialog::slot_search_finished(
     auto text = stream.readLine(1024);
 
     if (text.contains("Too many responses")) {
-      set_message(
-          "<h4>" + QString(_("Too many responses from keyserver!")) + "</h4>",
-          true);
+      set_message("<h4>" + tr("Too many responses from keyserver!") + "</h4>",
+                  true);
       return;
     } else if (text.contains("No keys found")) {
       // if string looks like hex string, search again with 0x prepended
       QRegExp rx("[0-9A-Fa-f]*");
       QString query = search_line_edit_->text();
       if (rx.exactMatch(query)) {
-        set_message(
-            "<h4>" +
-                QString(_("No keys found, input may be kexId, retrying search "
-                          "with 0x.")) +
-                "</h4>",
-            true);
+        set_message("<h4>" +
+                        tr("No keys found, input may be kexId, retrying search "
+                           "with 0x.") +
+                        "</h4>",
+                    true);
         search_line_edit_->setText(query.prepend("0x"));
         this->slot_search();
         return;
-      } else {
-        set_message(
-            "<h4>" + QString(_("No keys found containing the search string!")) +
-                "</h4>",
-            true);
-        return;
       }
+      set_message(
+          "<h4>" + tr("No keys found containing the search string!") + "</h4>",
+          true);
+      return;
+
     } else if (text.contains("Insufficiently specific words")) {
-      set_message("<h4>" +
-                      QString(_("Insufficiently specific search string!")) +
-                      "</h4>",
-                  true);
+      set_message(
+          "<h4>" + tr("Insufficiently specific search string!") + "</h4>",
+          true);
       return;
     } else {
       set_message(text, true);
@@ -359,12 +298,10 @@ void KeyServerImportDialog::slot_search_finished(
                                  new QTableWidgetItem(QString("expired")));
           }
           if (flags.contains("r")) {
-            keys_table_->setItem(row, 3,
-                                 new QTableWidgetItem(QString(_("revoked"))));
+            keys_table_->setItem(row, 3, new QTableWidgetItem(tr("revoked")));
           }
           if (flags.contains("d")) {
-            keys_table_->setItem(row, 3,
-                                 new QTableWidgetItem(QString(_("disabled"))));
+            keys_table_->setItem(row, 3, new QTableWidgetItem(tr("disabled")));
           }
         }
 
@@ -377,14 +314,9 @@ void KeyServerImportDialog::slot_search_finished(
           uid->setText(line2[1]);
           keys_table_->setItem(row, 0, uid);
         }
-#ifdef GPGFRONTEND_GUI_QT6
         auto* creation_date =
             new QTableWidgetItem(QDateTime::fromSecsSinceEpoch(line[4].toInt())
                                      .toString("dd. MMM. yyyy"));
-#else
-        auto* creation_date = new QTableWidgetItem(
-            QDateTime::fromTime_t(line[4].toInt()).toString("dd. MMM. yyyy"));
-#endif
         keys_table_->setItem(row, 1, creation_date);
         auto* keyid = new QTableWidgetItem(line[1]);
         keys_table_->setItem(row, 2, keyid);
@@ -414,8 +346,7 @@ void KeyServerImportDialog::slot_search_finished(
       }
       set_message(
           QString("<h4>") +
-              QString(_("%1 keys found. Double click a key to import it."))
-                  .arg(row) +
+              tr("%1 keys found. Double click a key to import it.").arg(row) +
               "</h4>",
           false);
     }
@@ -425,142 +356,78 @@ void KeyServerImportDialog::slot_search_finished(
 }
 
 void KeyServerImportDialog::slot_import() {
-  std::vector<std::string> key_ids;
+  std::vector<QString> key_ids;
   const int row_count = keys_table_->rowCount();
   for (int i = 0; i < row_count; ++i) {
     if (keys_table_->item(i, 2)->isSelected()) {
       QString keyid = keys_table_->item(i, 2)->text();
-      key_ids.push_back(keyid.toStdString());
+      key_ids.push_back(keyid);
     }
   }
-  if (!key_ids.empty())
-    SlotImport(key_ids, key_server_combo_box_->currentText().toStdString());
+  if (!key_ids.empty()) {
+    SlotImport(key_ids, key_server_combo_box_->currentText());
+  } else {
+    QMessageBox::warning(
+        this, tr("Warning"),
+        tr("Please select one KeyPair before doing this operation."));
+  }
 }
 
 void KeyServerImportDialog::SlotImport(const KeyIdArgsListPtr& keys) {
   // keyserver host url
-  std::string target_keyserver;
+  QString target_keyserver;
 
   if (key_server_combo_box_ != nullptr) {
-    target_keyserver = key_server_combo_box_->currentText().toStdString();
+    target_keyserver = key_server_combo_box_->currentText();
   }
-  if (target_keyserver.empty()) {
-    try {
-      SettingsObject key_server_json("key_server");
-      const auto key_server_list =
-          key_server_json.Check("server_list", nlohmann::json::array());
-
-      int default_key_server_index = key_server_json.Check("default_server", 0);
-      if (default_key_server_index >= key_server_list.size()) {
-        throw std::runtime_error("default_server index out of range");
-      }
-      std::string default_key_server =
-          key_server_list[default_key_server_index].get<std::string>();
-
-      target_keyserver = default_key_server;
-    } catch (...) {
-      SPDLOG_ERROR("setting operation error", "server_list", "default_server");
-      QMessageBox::critical(
-          nullptr, _("Default Keyserver Not Found"),
-          _("Cannot read default keyserver from your settings, "
-            "please set a default keyserver first"));
-      return;
-    }
+  if (target_keyserver.isEmpty()) {
+    KeyServerSO key_server(SettingsObject("general_settings_state"));
+    target_keyserver = key_server.GetTargetServer();
   }
-  std::vector<std::string> key_ids;
+  std::vector<QString> key_ids;
   for (const auto& key_id : *keys) {
     key_ids.push_back(key_id);
   }
   SlotImport(key_ids, target_keyserver);
 }
 
-void KeyServerImportDialog::SlotImport(std::vector<std::string> key_ids,
-                                       std::string keyserver_url) {
-  auto* task = new KeyServerImportTask(keyserver_url, key_ids);
+void KeyServerImportDialog::SlotImport(std::vector<QString> key_ids,
+                                       QString keyserver_url) {
+  auto* task =
+      new KeyServerImportTask(std::move(keyserver_url), std::move(key_ids));
 
   connect(task, &KeyServerImportTask::SignalKeyServerImportResult, this,
           &KeyServerImportDialog::slot_import_finished);
 
+  set_loading(true);
   Thread::TaskRunnerGetter::GetInstance()
       .GetTaskRunner(Thread::TaskRunnerGetter::kTaskRunnerType_Network)
       ->PostTask(task);
 }
 
 void KeyServerImportDialog::slot_import_finished(
-    QNetworkReply::NetworkError error, QByteArray buffer) {
-  if (error != QNetworkReply::NoError) {
-    SPDLOG_ERROR("Error From Reply", buffer.toStdString());
-    if (!m_automatic_) {
-      switch (error) {
-        case QNetworkReply::ContentNotFoundError:
-          set_message(_("Key Not Found"), true);
-          break;
-        case QNetworkReply::TimeoutError:
-          set_message(_("Timeout"), true);
-          break;
-        case QNetworkReply::HostNotFoundError:
-          set_message(_("Key Server Not Found"), true);
-          break;
-        default:
-          set_message(_("Connection Error"), true);
-      }
-    } else {
-      switch (error) {
-        case QNetworkReply::ContentNotFoundError:
-          QMessageBox::critical(nullptr, _("Key Not Found"),
-                                QString(_("key not found in the Keyserver")));
-          break;
-        case QNetworkReply::TimeoutError:
-          QMessageBox::critical(nullptr, _("Timeout"), "Connection timeout");
-          break;
-        case QNetworkReply::HostNotFoundError:
-          QMessageBox::critical(nullptr, _("Host Not Found"),
-                                "cannot resolve the default Keyserver");
-          break;
-        default:
-          QMessageBox::critical(nullptr, _("Connection Error"),
-                                _("General Connection Error"));
-      }
-    }
-    if (m_automatic_) {
-      setWindowFlags(Qt::Window | Qt::WindowTitleHint |
-                     Qt::CustomizeWindowHint | Qt::WindowCloseButtonHint);
-    }
+    bool success, QString err_msg, QByteArray buffer,
+    std::shared_ptr<GpgImportInformation> info) {
+  set_loading(false);
+
+  if (!success) {
+    GF_UI_LOG_ERROR("Error From Reply", buffer.toStdString());
+    set_message(err_msg, true);
     return;
   }
 
-  this->import_keys(
-      std::make_unique<ByteArray>(buffer.constData(), buffer.length()));
-
-  if (!m_automatic_) {
-    set_message(QString("<h4>") + _("Key Imported") + "</h4>", false);
-  }
-}
-
-void KeyServerImportDialog::import_keys(ByteArrayPtr in_data) {
-  GpgImportInformation result =
-      GpgKeyImportExporter::GetInstance().ImportKey(std::move(in_data));
+  set_message(tr("Key Imported"), false);
 
   // refresh the key database
   emit SignalKeyImported();
 
-  QWidget* _parent = qobject_cast<QWidget*>(parent());
-  if (m_automatic_) {
-    auto dialog = new KeyImportDetailDialog(result, true, _parent);
-    dialog->show();
-    this->accept();
-  } else {
-    auto dialog = new KeyImportDetailDialog(result, false, this);
-    dialog->exec();
-  }
+  // show details
+  (new KeyImportDetailDialog(std::move(info), this))->exec();
 }
 
 void KeyServerImportDialog::set_loading(bool status) {
   waiting_bar_->setVisible(status);
-  if (!m_automatic_) {
-    icon_->setVisible(!status);
-    message_->setVisible(!status);
-  }
+  if (status) set_message(tr("Processing ..."), false);
 }
 
 }  // namespace GpgFrontend::UI