diff --git a/CMakeLists.txt b/CMakeLists.txt
index a5b032b78..8528583a4 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,204 +1,204 @@
 cmake_minimum_required(VERSION 3.16 FATAL_ERROR)
 
 set(RELEASE_SERVICE_VERSION_MAJOR "22")
 set(RELEASE_SERVICE_VERSION_MINOR "03")
 set(RELEASE_SERVICE_VERSION_MICRO "70")
 
 # The RELEASE_SERVICE_VERSION is used by Gpg4win to add the Gpg4win version
 if (NOT RELEASE_SERVICE_VERSION)
     set(RELEASE_SERVICE_VERSION "${RELEASE_SERVICE_VERSION_MAJOR}.${RELEASE_SERVICE_VERSION_MINOR}.${RELEASE_SERVICE_VERSION_MICRO}")
 endif()
 if(RELEASE_SERVICE_VERSION_MICRO LESS 10)
     set(KDE_APPLICATIONS_COMPACT_VERSION "${RELEASE_SERVICE_VERSION_MAJOR}${RELEASE_SERVICE_VERSION_MINOR}0${RELEASE_SERVICE_VERSION_MICRO}")
 else()
     set(KDE_APPLICATIONS_COMPACT_VERSION "${RELEASE_SERVICE_VERSION_MAJOR}${RELEASE_SERVICE_VERSION_MINOR}${RELEASE_SERVICE_VERSION_MICRO}")
 endif()
 
 set(KLEOPATRA_VERSION_MAJOR "3")
 set(KLEOPATRA_VERSION_MINOR "1")
 set(KLEOPATRA_VERSION_MICRO "19")
 
 set(kleopatra_version "${KLEOPATRA_VERSION_MAJOR}.${KLEOPATRA_VERSION_MINOR}.${KLEOPATRA_VERSION_MICRO}.${KDE_APPLICATIONS_COMPACT_VERSION}")
 # The following is for Windows
 set(kleopatra_version_win "${KLEOPATRA_VERSION_MAJOR}.${KLEOPATRA_VERSION_MINOR}.${KLEOPATRA_VERSION_MICRO}")
 set(kleopatra_fileversion_win "${KLEOPATRA_VERSION_MAJOR},${KLEOPATRA_VERSION_MINOR},${KLEOPATRA_VERSION_MICRO},0")
 
 project(kleopatra VERSION ${kleopatra_version})
 
 option(DISABLE_KWATCHGNUPG "Don't build the kwatchgnupg tool [default=OFF]" OFF)
 
 # Standalone build. Find / include everything necessary.
 set(KF5_MIN_VERSION "5.88.0")
 set(KMIME_VERSION "5.19.40")
-set(LIBKLEO_VERSION "5.19.41")
+set(LIBKLEO_VERSION "5.19.42")
 set(QT_REQUIRED_VERSION "5.15.2")
 set(GPGME_REQUIRED_VERSION "1.13.1")
 set(BOOST_REQUIRED_VERSION "1.58")
 
 if (WIN32)
   set(KF5_WANT_VERSION "5.70.0")
   set(KMIME_WANT_VERSION "5.12.0")
 else ()
   set(KF5_WANT_VERSION ${KF5_MIN_VERSION})
   set(KMIME_WANT_VERSION ${KMIME_VERSION})
 endif ()
 
 find_package(ECM ${KF5_WANT_VERSION} CONFIG REQUIRED)
 set(CMAKE_MODULE_PATH ${ECM_MODULE_PATH})
 set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules ${CMAKE_MODULE_PATH})
 
 include(ECMInstallIcons)
 include(ECMSetupVersion)
 include(ECMAddTests)
 include(GenerateExportHeader)
 include(ECMGenerateHeaders)
 include(FeatureSummary)
 include(CheckFunctionExists)
 include(KDEInstallDirs)
 include(KDECMakeSettings)
 include(KDECompilerSettings NO_POLICY_SCOPE)
 include(ECMAddAppIcon)
 include(ECMQtDeclareLoggingCategory)
 
 # Find KF5 packages
 find_package(KF5WidgetsAddons ${KF5_WANT_VERSION} CONFIG REQUIRED)
 find_package(KF5ConfigWidgets ${KF5_WANT_VERSION} CONFIG REQUIRED)
 find_package(KF5CoreAddons ${KF5_WANT_VERSION} CONFIG REQUIRED)
 find_package(KF5Codecs ${KF5_WANT_VERSION} CONFIG REQUIRED)
 find_package(KF5Config ${KF5_WANT_VERSION} CONFIG REQUIRED)
 find_package(KF5I18n ${KF5_WANT_VERSION} CONFIG REQUIRED)
 find_package(KF5IconThemes ${KF5_WANT_VERSION} CONFIG REQUIRED)
 find_package(KF5ItemModels ${KF5_WANT_VERSION} CONFIG REQUIRED)
 find_package(KF5XmlGui ${KF5_WANT_VERSION} CONFIG REQUIRED)
 find_package(KF5WindowSystem ${KF5_WANT_VERSION} CONFIG REQUIRED)
 find_package(KF5DocTools ${KF5_WANT_VERSION} CONFIG)
 find_package(KF5Crash ${KF5_WANT_VERSION} REQUIRED)
 
 set_package_properties(KF5DocTools PROPERTIES
     DESCRIPTION "Documentation tools"
     PURPOSE "Required to generate Kleopatra documentation."
     TYPE OPTIONAL)
 
 # Optional packages
 if (WIN32)
   # Only a replacement available for Windows so this
   # is required on other platforms.
   find_package(KF5DBusAddons ${KF5_WANT_VERSION} CONFIG)
   set_package_properties(KF5DBusAddons PROPERTIES DESCRIPTION "Support library to work with DBus"
                          PURPOSE "DBus session integration"
                          URL "https://inqlude.org/libraries/kdbusaddons.html"
                          TYPE OPTIONAL)
 else()
   find_package(KF5DBusAddons ${KF5_WANT_VERSION} CONFIG REQUIRED)
   set(_kleopatra_dbusaddons_libs KF5::DBusAddons)
 endif()
 
 set(HAVE_QDBUS ${Qt5DBus_FOUND})
 
 find_package(Gpgmepp ${GPGME_REQUIRED_VERSION} CONFIG REQUIRED)
 if (Gpgmepp_VERSION VERSION_GREATER_EQUAL "1.16.0")
     set(GPGMEPP_SUPPORTS_TRUST_SIGNATURES 1)
 endif()
 find_package(QGpgme ${GPGME_REQUIRED_VERSION} CONFIG REQUIRED)
 if (QGpgme_VERSION VERSION_GREATER_EQUAL "1.16.0")
     set(QGPGME_SUPPORTS_TRUST_SIGNATURES 1)
     set(QGPGME_SUPPORTS_SIGNATURE_EXPIRATION 1)
 endif()
 if (QGpgme_VERSION VERSION_GREATER_EQUAL "1.16.1")
     set(QGPGME_SUPPORTS_CHANGING_EXPIRATION_OF_COMPLETE_KEY 1)
     set(QGPGME_CRYPTOCONFIGENTRY_HAS_DEFAULT_VALUE 1)
 endif()
 
 # Kdepimlibs packages
 find_package(KF5Libkleo ${LIBKLEO_VERSION} CONFIG REQUIRED)
 find_package(KF5Mime ${KMIME_WANT_VERSION} CONFIG REQUIRED)
 
 find_package(Qt5 ${QT_REQUIRED_VERSION} CONFIG REQUIRED Widgets Test Network PrintSupport)
 
 find_package(Assuan2 REQUIRED)
 
 
 find_package(Boost ${BOOST_REQUIRED_VERSION} MODULE REQUIRED)
 
 find_path(Boost_TOPOLOGICAL_SORT_DIR NAMES boost/graph/topological_sort.hpp PATHS ${Boost_INCLUDE_DIRS})
 if(NOT Boost_TOPOLOGICAL_SORT_DIR)
     message(FATAL_ERROR "The Boost Topological_sort header was NOT found. Should be part of Boost graph module.")
 endif()
 
 set(kleopatra_release FALSE)
 
 if(NOT kleopatra_release)
     find_package(Git)
     if(GIT_FOUND)
         execute_process(COMMAND ${GIT_EXECUTABLE} rev-parse
                         WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
                         RESULT_VARIABLE rc
                         ERROR_QUIET)
         if(rc EQUAL 0)
             execute_process(COMMAND ${GIT_EXECUTABLE} log -1 --oneline --format=%h ${CMAKE_CURRENT_SOURCE_DIR}
                 WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
                 OUTPUT_VARIABLE Kleopatra_WC_REVISION)
             string(REGEX REPLACE "\n" "" Kleopatra_WC_REVISION "${Kleopatra_WC_REVISION}")
 
             execute_process(COMMAND ${GIT_EXECUTABLE} log -1 --oneline --format=%cI ${CMAKE_CURRENT_SOURCE_DIR}
                 WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
                 OUTPUT_VARIABLE Kleopatra_WC_LAST_CHANGED_DATE)
             string(REGEX REPLACE "^([0-9]+)-([0-9]+)-([0-9]+)T([0-9]+):([0-9]+):([0-9]+).*$" "\\1\\2\\3T\\4\\5\\6"
                    Kleopatra_WC_LAST_CHANGED_DATE "${Kleopatra_WC_LAST_CHANGED_DATE}")
 
             set(kleopatra_version "${kleopatra_version}+git${Kleopatra_WC_LAST_CHANGED_DATE}~${Kleopatra_WC_REVISION}")
         endif()
     endif()
 endif()
 
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/version-kleopatra.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/version-kleopatra.h)
 
 include (ConfigureChecks.cmake)
 
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/config-kleopatra.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-kleopatra.h)
 include_directories(
     ${CMAKE_CURRENT_BINARY_DIR}
     ${CMAKE_CURRENT_SOURCE_DIR}
     ${Boost_INCLUDE_DIRS}
     ${ASSUAN2_INCLUDES}
     )
 
 add_definitions(-D_ASSUAN_ONLY_GPG_ERRORS)
 add_definitions(-DQT_DISABLE_DEPRECATED_BEFORE=0x050e00)
 add_definitions(-DKF_DISABLE_DEPRECATED_BEFORE_AND_AT=0x055800)
 if(CMAKE_COMPILER_IS_GNUCXX)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-missing-braces -Wno-parentheses -Wno-ignored-qualifiers")
 endif()
 add_definitions(-DQT_NO_EMIT)
 remove_definitions(-DQT_NO_FOREACH)
 
 kde_enable_exceptions()
 option(USE_UNITY_CMAKE_SUPPORT "Use UNITY cmake support (speedup compile time)" OFF)
 
 set(COMPILE_WITH_UNITY_CMAKE_SUPPORT OFF)
 if (USE_UNITY_CMAKE_SUPPORT)
     set(COMPILE_WITH_UNITY_CMAKE_SUPPORT ON)
 endif()
 
 
 add_subdirectory(pics)
 add_subdirectory(src)
 
 if(BUILD_TESTING)
     add_subdirectory(tests)
     add_subdirectory(autotests)
 endif()
 
 ecm_qt_install_logging_categories(
         EXPORT KLEOPATRA
         FILE kleopatra.categories
         DESTINATION ${KDE_INSTALL_LOGGINGCATEGORIESDIR}
         )
 
 ki18n_install(po)
 if(KF5DocTools_FOUND)
     kdoctools_install(po)
     add_subdirectory(doc)
 endif()
 feature_summary(WHAT ALL FATAL_ON_MISSING_REQUIRED_PACKAGES)
 
diff --git a/src/commands/exportgroupscommand.cpp b/src/commands/exportgroupscommand.cpp
index 6b1722421..f4319e988 100644
--- a/src/commands/exportgroupscommand.cpp
+++ b/src/commands/exportgroupscommand.cpp
@@ -1,302 +1,309 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     exportgroupscommand.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2021 g10 Code GmbH
     SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "exportgroupscommand.h"
 #include "command_p.h"
 
 #include "utils/filedialog.h"
 
 #include <Libkleo/Algorithm>
 #include <Libkleo/KeyGroup>
-#include <Libkleo/KeyGroupConfig>
+#include <Libkleo/KeyGroupImportExport>
 #include <Libkleo/KeyHelpers>
 
 #include <KConfigGroup>
 #include <KLocalizedString>
 #include <KSharedConfig>
 
 #include <QGpgME/Protocol>
 #include <QGpgME/ExportJob>
 
 #include <QFileInfo>
 #include <QStandardPaths>
 
 #include <memory>
 #include <vector>
 
 using namespace Kleo;
 using namespace GpgME;
 using namespace QGpgME;
 
 namespace
 {
 
 static const QString certificateGroupFileExtension{QLatin1String{".kgrp"}};
 
 QString getLastUsedExportDirectory()
 {
     KConfigGroup config{KSharedConfig::openConfig(), "ExportDialog"};
     return config.readEntry("LastDirectory", QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation));
 }
 
 void updateLastUsedExportDirectory(const QString &path)
 {
     KConfigGroup config{KSharedConfig::openConfig(), "ExportDialog"};
     config.writeEntry("LastDirectory", QFileInfo{path}.absolutePath());
 }
 
 QString proposeFilename(const std::vector<KeyGroup> &groups)
 {
     QString filename;
 
     filename = getLastUsedExportDirectory() + QLatin1Char{'/'};
     if (groups.size() == 1) {
         filename += groups.front().name().replace(QLatin1Char{'/'}, QLatin1Char{'_'});
     } else {
         filename += i18nc("A generic filename for exported certificate groups", "certificate groups");
     }
 
     return filename + certificateGroupFileExtension;
 }
 
 QString requestFilename(QWidget *parent, const std::vector<KeyGroup> &groups)
 {
     const QString proposedFilename = proposeFilename(groups);
 
     auto filename = FileDialog::getSaveFileNameEx(
         parent,
         i18ncp("@title:window", "Export Certificate Group", "Export Certificate Groups", groups.size()),
         QStringLiteral("imp"),
         proposedFilename,
         i18nc("filename filter like Certificate Groups (*.foo)", "Certificate Groups (*%1)", certificateGroupFileExtension));
     if (!filename.isEmpty()) {
         const QFileInfo fi{filename};
         if (fi.suffix().isEmpty()) {
             filename += certificateGroupFileExtension;
         }
         updateLastUsedExportDirectory(filename);
     }
 
     return filename;
 }
 
 }
 
 class ExportGroupsCommand::Private : public Command::Private
 {
     friend class ::ExportGroupsCommand;
     ExportGroupsCommand *q_func() const
     {
         return static_cast<ExportGroupsCommand *>(q);
     }
 public:
     explicit Private(ExportGroupsCommand *qq);
     ~Private() override;
 
     void start();
 
-    void exportGroups();
+    bool exportGroups();
     bool startExportJob(GpgME::Protocol protocol, const std::vector<Key> &keys);
 
     void onExportJobResult(const QGpgME::Job *job, const GpgME::Error &err, const QByteArray &keyData);
 
     void cancelJobs();
     void showError(const GpgME::Error &err);
 
     void finishedIfLastJob(const QGpgME::Job *job);
 
 private:
     std::vector<KeyGroup> groups;
     QString filename;
     std::vector<QPointer<QGpgME::Job>> exportJobs;
 };
 
 ExportGroupsCommand::Private *ExportGroupsCommand::d_func()
 {
     return static_cast<Private *>(d.get());
 }
 const ExportGroupsCommand::Private *ExportGroupsCommand::d_func() const
 {
     return static_cast<const Private *>(d.get());
 }
 
 #define d d_func()
 #define q q_func()
 
 ExportGroupsCommand::Private::Private(ExportGroupsCommand *qq)
     : Command::Private(qq)
 {
 }
 
 ExportGroupsCommand::Private::~Private() = default;
 
 void ExportGroupsCommand::Private::start()
 {
     if (groups.empty()) {
         finished();
         return;
     }
 
     filename = requestFilename(parentWidgetOrView(), groups);
     if (filename.isEmpty()) {
         canceled();
         return;
     }
 
     const auto groupKeys = std::accumulate(std::begin(groups), std::end(groups),
                                            KeyGroup::Keys{},
                                            [](auto &allKeys, const auto &group) {
                                                 const auto keys = group.keys();
                                                 allKeys.insert(std::begin(keys), std::end(keys));
                                                 return allKeys;
                                            });
 
     std::vector<Key> openpgpKeys;
     std::vector<Key> cmsKeys;
     std::partition_copy(std::begin(groupKeys), std::end(groupKeys),
                         std::back_inserter(openpgpKeys),
                         std::back_inserter(cmsKeys),
                         [](const GpgME::Key &key) {
                             return key.protocol() == GpgME::OpenPGP;
                         });
 
     // remove/overwrite existing file
     if (QFile::exists(filename) && !QFile::remove(filename)) {
         error(xi18n("Cannot overwrite existing <filename>%1</filename>.", filename),
               i18nc("@title:window", "Export Failed"));
         finished();
         return;
     }
-    exportGroups();
+    if (!exportGroups()) {
+        finished();
+        return;
+    }
     if (!openpgpKeys.empty()) {
         if (!startExportJob(GpgME::OpenPGP, openpgpKeys)) {
             finished();
             return;
         }
     }
     if (!cmsKeys.empty()) {
         if (!startExportJob(GpgME::CMS, cmsKeys)) {
             finishedIfLastJob(nullptr);
         }
     }
 }
 
-void ExportGroupsCommand::Private::exportGroups()
+bool ExportGroupsCommand::Private::exportGroups()
 {
-    KeyGroupConfig config{filename};
-    config.writeGroups(groups);
+    const auto result = writeKeyGroups(filename, groups);
+    if (result != WriteKeyGroups::Success) {
+        error(xi18n("Writing groups to file <filename>%1</filename> failed.", filename),
+              i18nc("@title:window", "Export Failed"));
+    }
+    return result == WriteKeyGroups::Success;
 }
 
 bool ExportGroupsCommand::Private::startExportJob(GpgME::Protocol protocol, const std::vector<Key> &keys)
 {
     const QGpgME::Protocol *const backend = (protocol == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
     Q_ASSERT(backend);
     std::unique_ptr<ExportJob> jobOwner(backend->publicKeyExportJob(/*armor=*/ true));
     auto job = jobOwner.get();
     Q_ASSERT(job);
 
     connect(job, &ExportJob::result,
             q, [this, job](const GpgME::Error &err, const QByteArray &keyData) {
                 onExportJobResult(job, err, keyData);
             });
     connect(job, &Job::progress,
             q, &Command::progress);
 
     const GpgME::Error err = job->start(Kleo::getFingerprints(keys));
     if (err) {
         showError(err);
         return false;
     }
     Q_EMIT q->info(i18n("Exporting certificate groups..."));
 
     exportJobs.push_back(jobOwner.release());
     return true;
 }
 
 void ExportGroupsCommand::Private::onExportJobResult(const QGpgME::Job *job, const GpgME::Error &err, const QByteArray &keyData)
 {
     Q_ASSERT(Kleo::contains(exportJobs, job));
 
     if (err) {
         showError(err);
         finishedIfLastJob(job);
         return;
     }
 
     QFile f{filename};
     if (!f.open(QIODevice::WriteOnly | QIODevice::Append)) {
         error(xi18n("Cannot open file <filename>%1</filename> for writing.", filename),
               i18nc("@title:window", "Export Failed"));
         finishedIfLastJob(job);
         return;
     }
 
     const auto bytesWritten = f.write(keyData);
     if (bytesWritten != keyData.size()) {
         error(xi18n("Writing certificates to file <filename>%1</filename> failed.", filename),
               i18nc("@title:window", "Export Failed"));
     }
 
     finishedIfLastJob(job);
 }
 
 void ExportGroupsCommand::Private::showError(const GpgME::Error &err)
 {
     error(xi18n("<para>An error occurred during the export:</para>"
                 "<para><message>%1</message></para>",
                 QString::fromLocal8Bit(err.asString())),
           i18nc("@title:window", "Export Failed"));
 }
 
 void ExportGroupsCommand::Private::finishedIfLastJob(const QGpgME::Job *job)
 {
     if (job) {
         exportJobs.erase(std::remove(exportJobs.begin(), exportJobs.end(), job), exportJobs.end());
     }
     if (exportJobs.size() == 0) {
         finished();
     }
 }
 
 void ExportGroupsCommand::Private::cancelJobs()
 {
     std::for_each(std::cbegin(exportJobs), std::cend(exportJobs),
                   [](const auto &job) {
                       if (job) {
                           job->slotCancel();
                       }
                   });
     exportJobs.clear();
 }
 
 ExportGroupsCommand::ExportGroupsCommand(const std::vector<KeyGroup> &groups)
     : Command{new Private{this}}
 {
     d->groups = groups;
 }
 
 ExportGroupsCommand::~ExportGroupsCommand() = default;
 
 void ExportGroupsCommand::doStart()
 {
     d->start();
 }
 
 void ExportGroupsCommand::doCancel()
 {
     d->cancelJobs();
 }
 
 #undef d
 #undef q
 
 #include "moc_exportgroupscommand.cpp"
diff --git a/src/commands/importcertificatescommand.cpp b/src/commands/importcertificatescommand.cpp
index fb014c762..95fdbcb8e 100644
--- a/src/commands/importcertificatescommand.cpp
+++ b/src/commands/importcertificatescommand.cpp
@@ -1,768 +1,767 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     commands/importcertificatescommand.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007, 2008 Klarälvdalens Datakonsult AB
     SPDX-FileCopyrightText: 2016 Bundesamt für Sicherheit in der Informationstechnik
     SPDX-FileContributor: Intevation GmbH
     SPDX-FileCopyrightText: 2021 g10 Code GmbH
     SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "importcertificatescommand.h"
 #include "importcertificatescommand_p.h"
 
 #include "certifycertificatecommand.h"
 #include "kleopatra_debug.h"
 
 #include <Libkleo/Algorithm>
 #include <Libkleo/KeyList>
 #include <Libkleo/KeyListSortFilterProxyModel>
 #include <Libkleo/KeyCache>
-#include <Libkleo/KeyGroupConfig>
+#include <Libkleo/KeyGroupImportExport>
 #include <Libkleo/Predicates>
 #include <Libkleo/Formatting>
 #include <Libkleo/Stl_Util>
 
 #include <QGpgME/KeyListJob>
 #include <QGpgME/Protocol>
 #include <QGpgME/ImportJob>
 #include <QGpgME/ImportFromKeyserverJob>
 #include <QGpgME/ChangeOwnerTrustJob>
 
 #include <gpgme++/global.h>
 #include <gpgme++/importresult.h>
 #include <gpgme++/context.h>
 #include <gpgme++/key.h>
 #include <gpgme++/keylistresult.h>
 
 #include <KLocalizedString>
 #include <KMessageBox>
 
 #include <QByteArray>
 #include <QEventLoop>
 #include <QString>
 #include <QWidget>
 #include <QTreeView>
 #include <QTextDocument> // for Qt::escape
 
 #include <memory>
 #include <algorithm>
 #include <map>
 #include <set>
 
 using namespace GpgME;
 using namespace Kleo;
 using namespace QGpgME;
 
 bool operator==(const ImportJobData &lhs, const ImportJobData &rhs)
 {
     return lhs.job == rhs.job;
 }
 
 namespace
 {
 
 make_comparator_str(ByImportFingerprint, .fingerprint());
 
 class ImportResultProxyModel : public AbstractKeyListSortFilterProxyModel
 {
     Q_OBJECT
 public:
     ImportResultProxyModel(const std::vector<ImportResultData> &results, QObject *parent = nullptr)
         : AbstractKeyListSortFilterProxyModel(parent)
     {
         updateFindCache(results);
     }
 
     ~ImportResultProxyModel() override {}
 
     ImportResultProxyModel *clone() const override
     {
         // compiler-generated copy ctor is fine!
         return new ImportResultProxyModel(*this);
     }
 
     void setImportResults(const std::vector<ImportResultData> &results)
     {
         updateFindCache(results);
         invalidateFilter();
     }
 
 protected:
     QVariant data(const QModelIndex &index, int role) const override
     {
         if (!index.isValid() || role != Qt::ToolTipRole) {
             return AbstractKeyListSortFilterProxyModel::data(index, role);
         }
         const QString fpr = index.data(KeyList::FingerprintRole).toString();
         // find information:
         const std::vector<Import>::const_iterator it
             = Kleo::binary_find(m_importsByFingerprint.begin(), m_importsByFingerprint.end(),
                                 fpr.toLatin1().constData(),
                                 ByImportFingerprint<std::less>());
         if (it == m_importsByFingerprint.end()) {
             return AbstractKeyListSortFilterProxyModel::data(index, role);
         } else {
             QStringList rv;
             const auto ids = m_idsByFingerprint[it->fingerprint()];
             rv.reserve(ids.size());
             std::copy(ids.cbegin(), ids.cend(), std::back_inserter(rv));
             return Formatting::importMetaData(*it, rv);
         }
     }
     bool filterAcceptsRow(int source_row, const QModelIndex &source_parent) const override
     {
         //
         // 0. Keep parents of matching children:
         //
         const QModelIndex index = sourceModel()->index(source_row, 0, source_parent);
         Q_ASSERT(index.isValid());
         for (int i = 0, end = sourceModel()->rowCount(index); i != end; ++i)
             if (filterAcceptsRow(i, index)) {
                 return true;
             }
         //
         // 1. Check that this is an imported key:
         //
         const QString fpr = index.data(KeyList::FingerprintRole).toString();
 
         return std::binary_search(m_importsByFingerprint.begin(), m_importsByFingerprint.end(),
                                   fpr.toLatin1().constData(),
                                   ByImportFingerprint<std::less>());
     }
 
 private:
     void updateFindCache(const std::vector<ImportResultData> &results)
     {
         m_importsByFingerprint.clear();
         m_idsByFingerprint.clear();
         m_results = results;
         for (const auto &r : results) {
             const std::vector<Import> imports = r.result.imports();
             m_importsByFingerprint.insert(m_importsByFingerprint.end(), imports.begin(), imports.end());
             for (std::vector<Import>::const_iterator it = imports.begin(), end = imports.end(); it != end; ++it) {
                 m_idsByFingerprint[it->fingerprint()].insert(r.id);
             }
         }
         std::sort(m_importsByFingerprint.begin(), m_importsByFingerprint.end(),
                   ByImportFingerprint<std::less>());
     }
 
 private:
     mutable std::vector<Import> m_importsByFingerprint;
     mutable std::map< const char *, std::set<QString>, ByImportFingerprint<std::less> > m_idsByFingerprint;
     std::vector<ImportResultData> m_results;
 };
 
 bool importFailed(const ImportResultData &r)
 {
     // ignore GPG_ERR_EOF error to handle the "failed" import of files
     // without X.509 certificates by gpgsm gracefully
     return r.result.error().code() != GPG_ERR_NO_ERROR
         && r.result.error().code() != GPG_ERR_EOF;
 }
 
 }
 
 ImportCertificatesCommand::Private::Private(ImportCertificatesCommand *qq, KeyListController *c)
     : Command::Private(qq, c)
 {
 }
 
 ImportCertificatesCommand::Private::~Private() = default;
 
 #define d d_func()
 #define q q_func()
 
 ImportCertificatesCommand::ImportCertificatesCommand(KeyListController *p)
     : Command(new Private(this, p))
 {
 }
 
 ImportCertificatesCommand::ImportCertificatesCommand(QAbstractItemView *v, KeyListController *p)
     : Command(v, new Private(this, p))
 {
 }
 
 ImportCertificatesCommand::~ImportCertificatesCommand() = default;
 
 static QString format_ids(const std::vector<QString> &ids)
 {
     QStringList escapedIds;
     for (const QString &id : ids) {
         if (!id.isEmpty()) {
             escapedIds << id.toHtmlEscaped();
         }
     }
     return escapedIds.join(QLatin1String("<br>"));
 }
 
 static QString make_tooltip(const std::vector<ImportResultData> &results)
 {
     if (results.empty()) {
         return {};
     }
 
     std::vector<QString> ids;
     ids.reserve(results.size());
     std::transform(std::begin(results), std::end(results),
                    std::back_inserter(ids),
                    [](const auto &r) { return r.id; });
     std::sort(std::begin(ids), std::end(ids));
     ids.erase(std::unique(std::begin(ids), std::end(ids)), std::end(ids));
 
     if (ids.size() == 1)
         if (ids.front().isEmpty()) {
             return {};
         } else
             return i18nc("@info:tooltip",
                          "Imported Certificates from %1",
                          ids.front().toHtmlEscaped());
     else
         return i18nc("@info:tooltip",
                      "Imported certificates from these sources:<br/>%1",
                      format_ids(ids));
 }
 
 void ImportCertificatesCommand::Private::setImportResultProxyModel(const std::vector<ImportResultData> &results)
 {
     if (std::none_of(std::begin(results), std::end(results),
                      [](const auto &r) { return r.result.numConsidered() > 0; })) {
         return;
     }
     q->addTemporaryView(i18nc("@title:tab", "Imported Certificates"),
                         new ImportResultProxyModel(results),
                         make_tooltip(results));
     if (QTreeView *const tv = qobject_cast<QTreeView *>(parentWidgetOrView())) {
         tv->expandAll();
     }
 }
 
 int sum(const std::vector<ImportResult> &res, int (ImportResult::*fun)() const)
 {
     return kdtools::accumulate_transform(res.begin(), res.end(), std::mem_fn(fun), 0);
 }
 
 static QString make_report(const std::vector<ImportResultData> &results,
                            const std::vector<ImportedGroup> &groups)
 {
     const KLocalizedString normalLine = ki18n("<tr><td align=\"right\">%1</td><td>%2</td></tr>");
     const KLocalizedString boldLine = ki18n("<tr><td align=\"right\"><b>%1</b></td><td>%2</td></tr>");
     const KLocalizedString headerLine = ki18n("<tr><th colspan=\"2\" align=\"center\">%1</th></tr>");
 
     std::vector<ImportResult> res;
     res.reserve(results.size());
     std::transform(std::begin(results), std::end(results),
                    std::back_inserter(res),
                    [](const auto &r) { return r.result; });
 
     const auto numProcessedCertificates = sum(res, &ImportResult::numConsidered);
 
     QStringList lines;
 
     if (numProcessedCertificates > 0 || groups.size() == 0) {
         lines.push_back(headerLine.subs(i18n("Certificates")).toString());
         lines.push_back(normalLine.subs(i18n("Total number processed:"))
                         .subs(numProcessedCertificates).toString());
         lines.push_back(normalLine.subs(i18n("Imported:"))
                         .subs(sum(res, &ImportResult::numImported)).toString());
         if (const int n = sum(res, &ImportResult::newSignatures))
             lines.push_back(normalLine.subs(i18n("New signatures:"))
                             .subs(n).toString());
         if (const int n = sum(res, &ImportResult::newUserIDs))
             lines.push_back(normalLine.subs(i18n("New user IDs:"))
                             .subs(n).toString());
         if (const int n = sum(res, &ImportResult::numKeysWithoutUserID))
             lines.push_back(normalLine.subs(i18n("Certificates without user IDs:"))
                             .subs(n).toString());
         if (const int n = sum(res, &ImportResult::newSubkeys))
             lines.push_back(normalLine.subs(i18n("New subkeys:"))
                             .subs(n).toString());
         if (const int n = sum(res, &ImportResult::newRevocations))
             lines.push_back(boldLine.subs(i18n("Newly revoked:"))
                             .subs(n).toString());
         if (const int n = sum(res, &ImportResult::notImported))
             lines.push_back(boldLine.subs(i18n("Not imported:"))
                             .subs(n).toString());
         if (const int n = sum(res, &ImportResult::numUnchanged))
             lines.push_back(normalLine.subs(i18n("Unchanged:"))
                             .subs(n).toString());
         if (const int n = sum(res, &ImportResult::numSecretKeysConsidered))
             lines.push_back(normalLine.subs(i18n("Secret keys processed:"))
                             .subs(n).toString());
         if (const int n = sum(res, &ImportResult::numSecretKeysImported))
             lines.push_back(normalLine.subs(i18n("Secret keys imported:"))
                             .subs(n).toString());
         if (const int n = sum(res, &ImportResult::numSecretKeysConsidered) - sum(res, &ImportResult::numSecretKeysImported) - sum(res, &ImportResult::numSecretKeysUnchanged))
             if (n > 0)
                 lines.push_back(boldLine.subs(i18n("Secret keys <em>not</em> imported:"))
                                 .subs(n).toString());
         if (const int n = sum(res, &ImportResult::numSecretKeysUnchanged))
             lines.push_back(normalLine.subs(i18n("Secret keys unchanged:"))
                             .subs(n).toString());
         if (const int n = sum(res, &ImportResult::numV3KeysSkipped))
             lines.push_back(normalLine.subs(i18n("Deprecated PGP-2 keys skipped:"))
                             .subs(n).toString());
     }
 
     if (!lines.empty()) {
         lines.push_back(headerLine.subs(QLatin1String{"&nbsp;"}).toString());
     }
 
     if (groups.size() > 0) {
         const auto newGroups = std::count_if(std::begin(groups), std::end(groups),
                                              [](const auto &g) {
                                                  return g.status == ImportedGroup::Status::New;
                                              });
         const auto updatedGroups = groups.size() - newGroups;
         lines.push_back(headerLine.subs(i18n("Certificate Groups")).toString());
         lines.push_back(normalLine.subs(i18n("Total number processed:"))
                         .subs(groups.size()).toString());
         lines.push_back(normalLine.subs(i18n("New groups:"))
                         .subs(newGroups).toString());
         lines.push_back(normalLine.subs(i18n("Updated groups:"))
                         .subs(updatedGroups).toString());
     }
 
     return lines.join(QLatin1String{});
 }
 
 static QString make_message_report(const std::vector<ImportResultData> &res,
                                    const std::vector<ImportedGroup> &groups)
 {
     QString report{QLatin1String{"<html>"}};
     if (res.empty()) {
         report += i18n("No imports (should not happen, please report a bug).");
     } else {
         const bool singleSource = (res.size() == 1) || (res.size() == 2 && res[0].id == res[1].id);
         const QString title = singleSource && !res.front().id.isEmpty() ?
                               i18n("Detailed results of importing %1:", res.front().id) :
                               i18n("Detailed results of import:");
         report += QLatin1String{"<p>"} + title + QLatin1String{"</p>"};
         report += QLatin1String{"<p><table width=\"100%\">"};
         report += make_report(res, groups);
         report += QLatin1String{"</table></p>"};
     }
     report += QLatin1String{"</html>"};
     return report;
 }
 
 // Returns false on error, true if please certify was shown.
 bool ImportCertificatesCommand::Private::showPleaseCertify(const GpgME::Import &imp)
 {
     const char *fpr = imp.fingerprint();
     if (!fpr) {
         // WTF
         qCWarning(KLEOPATRA_LOG) << "Import without fingerprint";
         return false;
     }
     // Exactly one public key imported. Let's see if it is openpgp. We are async here so
     // we can just fetch it.
 
     auto ctx = GpgME::Context::createForProtocol(GpgME::OpenPGP);
     if (!ctx) {
         // WTF
         qCWarning(KLEOPATRA_LOG) << "Failed to create OpenPGP proto";
         return false;
     }
     GpgME::Error err;
     auto key = ctx->key(fpr, err, false);
     delete ctx;
 
     if (key.isNull() || err) {
         // No such key most likely not OpenPGP
         return false;
     }
 
     for (const auto &uid: key.userIDs()) {
         if (uid.validity() >= GpgME::UserID::Marginal) {
             // Already marginal so don't bug the user
             return false;
         }
     }
 
     const QStringList suggestions = QStringList() << i18n("A phone call to the person.")
         << i18n("Using a business card.")
         << i18n("Confirming it on a trusted website.");
 
     auto sel = KMessageBox::questionYesNo(parentWidgetOrView(),
                 i18n("In order to mark the certificate as valid (green) it needs to be certified.") + QStringLiteral("<br>") +
                 i18n("Certifying means that you check the Fingerprint.") + QStringLiteral("<br>") +
                 i18n("Some suggestions to do this are:") +
                 QStringLiteral("<li><ul>%1").arg(suggestions.join(QStringLiteral("</ul><ul>"))) +
                 QStringLiteral("</ul></li>") +
                 i18n("Do you wish to start this process now?"),
                 i18nc("@title", "You have imported a new certificate (public key)"),
                 KStandardGuiItem::yes(), KStandardGuiItem::no(), QStringLiteral("CertifyQuestion"));
     if (sel == KMessageBox::Yes) {
         QEventLoop loop;
         auto cmd = new Commands::CertifyCertificateCommand(key);
         cmd->setParentWidget(parentWidgetOrView());
         loop.connect(cmd, SIGNAL(finished()), SLOT(quit()));
         QMetaObject::invokeMethod(cmd, &Commands::CertifyCertificateCommand::start, Qt::QueuedConnection);
         loop.exec();
     }
     return true;
 }
 
 void ImportCertificatesCommand::Private::showDetails(const std::vector<ImportResultData> &res,
                                                      const std::vector<ImportedGroup> &groups)
 {
     if (res.size() == 1 && res[0].result.numImported() == 1 && res[0].result.imports().size() == 1) {
         if (showPleaseCertify(res[0].result.imports()[0])) {
             return;
         }
     }
     setImportResultProxyModel(res);
     information(make_message_report(res, groups),
                 i18n("Certificate Import Result"));
 }
 
 static QString make_error_message(const Error &err, const QString &id)
 {
     Q_ASSERT(err);
     Q_ASSERT(!err.isCanceled());
     return id.isEmpty()
            ? i18n("<qt><p>An error occurred while trying "
                   "to import the certificate:</p>"
                   "<p><b>%1</b></p></qt>",
                   QString::fromLocal8Bit(err.asString()))
            : i18n("<qt><p>An error occurred while trying "
                   "to import the certificate %1:</p>"
                   "<p><b>%2</b></p></qt>",
                   id, QString::fromLocal8Bit(err.asString()));
 }
 
 void ImportCertificatesCommand::Private::showError(QWidget *parent, const Error &err, const QString &id)
 {
     if (parent) {
         KMessageBox::error(parent, make_error_message(err, id), i18n("Certificate Import Failed"));
     } else {
         showError(err, id);
     }
 }
 
 void ImportCertificatesCommand::Private::showError(const Error &err, const QString &id)
 {
     error(make_error_message(err, id), i18n("Certificate Import Failed"));
 }
 
 void ImportCertificatesCommand::Private::setWaitForMoreJobs(bool wait)
 {
     if (wait == waitForMoreJobs) {
         return;
     }
     waitForMoreJobs = wait;
     if (!waitForMoreJobs) {
         tryToFinish();
     }
 }
 
 void ImportCertificatesCommand::Private::importResult(const ImportResult &result)
 {
     const auto finishedJob = q->sender();
     auto it = std::find_if(std::cbegin(jobs), std::cend(jobs),
                            [finishedJob](const auto &job) { return job.job == finishedJob; });
     Q_ASSERT(it != std::cend(jobs));
     if (it == std::cend(jobs)) {
         qCWarning(KLEOPATRA_LOG) << __func__ << "Error: Finished job not found";
     }
     const auto job = *it;
     jobs.erase(std::remove(std::begin(jobs), std::end(jobs), job), std::end(jobs));
 
     importResult({job.id, job.protocol, job.type, result});
 }
 
 void ImportCertificatesCommand::Private::importResult(const ImportResultData &result)
 {
     qCDebug(KLEOPATRA_LOG) << __func__ << result.id;
     results.push_back(result);
 
     tryToFinish();
 }
 
 static void handleOwnerTrust(const std::vector<ImportResultData> &results)
 {
     //iterate over all imported certificates
     for (const auto &r: results) {
         //when a new certificate got a secret key
         if (r.result.numSecretKeysImported() >= 1) {
             const char *fingerPr = r.result.imports()[0].fingerprint();
             GpgME::Error err;
             QScopedPointer<Context>
                 ctx(Context::createForProtocol(GpgME::Protocol::OpenPGP));
 
             if (!ctx){
                 qCWarning(KLEOPATRA_LOG) << "Failed to get context";
                 continue;
             }
 
             const Key toTrustOwner = ctx->key(fingerPr, err , false);
 
             if (toTrustOwner.isNull()) {
                 return;
             }
 
             QStringList uids;
             const auto toTrustOwnerUserIDs{toTrustOwner.userIDs()};
             uids.reserve(toTrustOwnerUserIDs.size());
             for (const UserID &uid : toTrustOwnerUserIDs) {
                 uids << Formatting::prettyNameAndEMail(uid);
             }
 
             const QString str = xi18nc("@info",
                 "<title>You have imported a Secret Key.</title>"
                 "<para>The key has the fingerprint:<nl/>"
                 "<numid>%1</numid>"
                 "</para>"
                 "<para>And claims the User IDs:"
                 "<list><item>%2</item></list>"
                 "</para>"
                 "Is this your own key? (Set trust level to ultimate)",
                 QString::fromUtf8(fingerPr),
                 uids.join(QLatin1String("</item><item>")));
 
             int k = KMessageBox::questionYesNo(nullptr, str, i18nc("@title:window",
                                                                "Secret key imported"));
 
             if (k == KMessageBox::Yes) {
                 //To use the ChangeOwnerTrustJob over
                 //the CryptoBackendFactory
                 const QGpgME::Protocol *const backend = QGpgME::openpgp();
 
                 if (!backend){
                     qCWarning(KLEOPATRA_LOG) << "Failed to get CryptoBackend";
                     return;
                 }
 
                 ChangeOwnerTrustJob *const j = backend->changeOwnerTrustJob();
                 j->start(toTrustOwner, Key::Ultimate);
             }
         }
     }
 }
 
 static void validateImportedCertificate(const GpgME::Import &import)
 {
     if (const auto fpr = import.fingerprint()) {
         auto key = KeyCache::instance()->findByFingerprint(fpr);
         if (!key.isNull()) {
             // this triggers a keylisting with validation for this certificate
             key.update();
         } else {
             qCWarning(KLEOPATRA_LOG) << __func__ << "Certificate with fingerprint" << fpr << "not found";
         }
     }
 }
 
 static void handleExternalCMSImports(const std::vector<ImportResultData> &results)
 {
     // For external CMS Imports we have to manually do a keylist
     // with validation to get the intermediate and root ca imported
     // automatically if trusted-certs and extra-certs are used.
     for (const auto &r : results) {
         if (r.protocol == GpgME::CMS && r.type == ImportType::External && !importFailed(r)) {
             const auto imports = r.result.imports();
             std::for_each(std::begin(imports), std::end(imports), &validateImportedCertificate);
         }
     }
 }
 
 void ImportCertificatesCommand::Private::processResults()
 {
     handleExternalCMSImports(results);
 
     handleOwnerTrust(results);
 
     importGroups();
 
     showDetails(results, importedGroups);
 
     auto tv = dynamic_cast<QTreeView *> (view());
     if (!tv) {
         qCDebug(KLEOPATRA_LOG) << "Failed to find treeview";
     } else {
         tv->expandAll();
     }
     finished();
 }
 
 void ImportCertificatesCommand::Private::tryToFinish()
 {
 
     if (waitForMoreJobs || !jobs.empty()) {
         return;
     }
 
     auto keyCache = KeyCache::mutableInstance();
     connect(keyCache.get(), &KeyCache::keyListingDone,
             q, [this]() { keyCacheUpdated(); });
     keyCache->startKeyListing();
 }
 
 void ImportCertificatesCommand::Private::keyCacheUpdated()
 {
     keyCacheAutoRefreshSuspension.reset();
 
     if (std::any_of(std::cbegin(results), std::cend(results), &importFailed)) {
         setImportResultProxyModel(results);
         if (std::all_of(std::cbegin(results), std::cend(results),
                         [](const auto &r) {
                             return r.result.error().isCanceled();
                         })) {
             Q_EMIT q->canceled();
         } else {
             for (const auto &r : results) {
                 if (importFailed(r)) {
                     showError(r.result.error(), r.id);
                 }
             }
         }
         finished();
         return;
     }
 
     processResults();
 }
 
 static ImportedGroup storeGroup(const KeyGroup &group, const QString &id)
 {
     const auto status = KeyCache::instance()->group(group.id()).isNull() ?
                         ImportedGroup::Status::New :
                         ImportedGroup::Status::Updated;
     if (status == ImportedGroup::Status::New) {
         KeyCache::mutableInstance()->insert(group);
     } else {
         KeyCache::mutableInstance()->update(group);
     }
     return {id, group, status};
 }
 
 void ImportCertificatesCommand::Private::importGroups()
 {
     for (const auto &path : filesToImportGroupsFrom) {
         const bool certificateImportSucceeded =
             std::any_of(std::cbegin(results), std::cend(results),
                         [path](const auto &r) {
                             return r.id == path && !importFailed(r);
                         });
         if (certificateImportSucceeded) {
             qCDebug(KLEOPATRA_LOG) << __func__ << "Importing groups from file" << path;
-            const KeyGroupConfig config{path};
-            const auto groups = config.readGroups();
+            const auto groups = readKeyGroups(path);
             std::transform(std::begin(groups), std::end(groups),
                            std::back_inserter(importedGroups),
                            [path](const auto &group) {
                                return storeGroup(group, path);
                            });
         }
     }
 }
 
 static std::unique_ptr<ImportJob> get_import_job(GpgME::Protocol protocol)
 {
     Q_ASSERT(protocol != UnknownProtocol);
     if (const auto backend = (protocol == GpgME::OpenPGP ? QGpgME::openpgp() : QGpgME::smime())) {
         return std::unique_ptr<ImportJob>(backend->importJob());
     } else {
         return std::unique_ptr<ImportJob>();
     }
 }
 
 void ImportCertificatesCommand::Private::startImport(GpgME::Protocol protocol, const QByteArray &data, const QString &id)
 {
     Q_ASSERT(protocol != UnknownProtocol);
 
     if (std::find(nonWorkingProtocols.cbegin(), nonWorkingProtocols.cend(), protocol) != nonWorkingProtocols.cend()) {
         return;
     }
 
     std::unique_ptr<ImportJob> job = get_import_job(protocol);
     if (!job.get()) {
         nonWorkingProtocols.push_back(protocol);
         error(i18n("The type of this certificate (%1) is not supported by this Kleopatra installation.",
                    Formatting::displayName(protocol)),
               i18n("Certificate Import Failed"));
         importResult({id, protocol, ImportType::Local, ImportResult{}});
         return;
     }
 
     keyCacheAutoRefreshSuspension = KeyCache::mutableInstance()->suspendAutoRefresh();
 
     connect(job.get(), SIGNAL(result(GpgME::ImportResult)),
             q, SLOT(importResult(GpgME::ImportResult)));
     connect(job.get(), &Job::progress,
             q, &Command::progress);
     const GpgME::Error err = job->start(data);
     if (err.code()) {
         importResult({id, protocol, ImportType::Local, ImportResult{err}});
     } else {
         jobs.push_back({id, protocol, ImportType::Local, job.release()});
     }
 }
 
 static std::unique_ptr<ImportFromKeyserverJob> get_import_from_keyserver_job(GpgME::Protocol protocol)
 {
     Q_ASSERT(protocol != UnknownProtocol);
     if (const auto backend = (protocol == GpgME::OpenPGP ? QGpgME::openpgp() : QGpgME::smime())) {
         return std::unique_ptr<ImportFromKeyserverJob>(backend->importFromKeyserverJob());
     } else {
         return std::unique_ptr<ImportFromKeyserverJob>();
     }
 }
 
 void ImportCertificatesCommand::Private::startImport(GpgME::Protocol protocol, const std::vector<Key> &keys, const QString &id)
 {
     Q_ASSERT(protocol != UnknownProtocol);
 
     if (std::find(nonWorkingProtocols.cbegin(), nonWorkingProtocols.cend(), protocol) != nonWorkingProtocols.cend()) {
         return;
     }
 
     std::unique_ptr<ImportFromKeyserverJob> job = get_import_from_keyserver_job(protocol);
     if (!job.get()) {
         nonWorkingProtocols.push_back(protocol);
         error(i18n("The type of this certificate (%1) is not supported by this Kleopatra installation.",
                    Formatting::displayName(protocol)),
               i18n("Certificate Import Failed"));
         importResult({id, protocol, ImportType::External, ImportResult{}});
         return;
     }
 
     keyCacheAutoRefreshSuspension = KeyCache::mutableInstance()->suspendAutoRefresh();
 
     connect(job.get(), SIGNAL(result(GpgME::ImportResult)),
             q, SLOT(importResult(GpgME::ImportResult)));
     connect(job.get(), &Job::progress,
             q, &Command::progress);
     const GpgME::Error err = job->start(keys);
     if (err.code()) {
         importResult({id, protocol, ImportType::External, ImportResult{err}});
     } else {
         jobs.push_back({id, protocol, ImportType::External, job.release()});
     }
 }
 
 void ImportCertificatesCommand::Private::importGroupsFromFile(const QString &filename)
 {
     filesToImportGroupsFrom.push_back(filename);
 }
 
 void ImportCertificatesCommand::doCancel()
 {
     std::for_each(std::cbegin(d->jobs), std::cend(d->jobs),
                   [](const auto &job) { job.job->slotCancel(); });
     d->jobs.clear();
 }
 
 #undef d
 #undef q
 
 #include "moc_importcertificatescommand.cpp"
 #include "importcertificatescommand.moc"