pimsettingexporter/core/mail/importmailjob.cpp

   1 /*
   2   Copyright (c) 2012-2015 Montel Laurent <montel@kde.org>
   3
   4   This program is free software; you can redistribute it and/or modify it
   5   under the terms of the GNU General Public License, version 2, as
   6   published by the Free Software Foundation.
   7
   8   This program is distributed in the hope that it will be useful, but
   9   WITHOUT ANY WARRANTY; without even the implied warranty of
  10   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11   General Public License for more details.
  12
  13   You should have received a copy of the GNU General Public License along
  14   with this program; if not, write to the Free Software Foundation, Inc.,
  15   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  16 */
  17
  18 #include "importmailjob.h"
  19 #include "akonadidatabase.h"
  20 #include "archivestorage.h"
  21
  22 #include "MailCommon/FilterManager"
  23 #include "MailCommon/FilterImporterExporter"
  24 #include "MailCommon/MailUtil"
  25 #include "PimCommon/CreateResource"
  26
  27 #include <MailTransport/mailtransport/transportmanager.h>
  28
  29 #include <KIdentityManagement/kidentitymanagement/identitymanager.h>
  30 #include <KIdentityManagement/kidentitymanagement/identity.h>
  31
  32 #include <KLocalizedString>
  33 #include <KProcess>
  34 #include <QTemporaryFile>
  35 #include <KSharedConfig>
  36 #include <KConfigGroup>
  37 #include <KMessageBox>
  38 #include <KArchiveFile>
  39 #include <KZip>
  40 #include "pimsettingexportcore_debug.h"
  41
  42 #include <AkonadiCore/agenttype.h>
  43 #include <AkonadiCore/agentmanager.h>
  44 #include <AkonadiCore/agentinstancecreatejob.h>
  45
  46 #include <QMetaMethod>
  47 #include <QDir>
  48 #include <QStandardPaths>
  49 #include <QTimer>
  50 #include <qregularexpression.h>
  51
  52 using namespace Akonadi;
  53 namespace
  54 {
  55 inline const QString storeMails()
  56 {
  57     return QStringLiteral("backupmail/");
  58 }
  59 }
  60
  61 ImportMailJob::ImportMailJob(QObject *parent, Utils::StoredTypes typeSelected, ArchiveStorage *archiveStorage, int numberOfStep)
  62     : AbstractImportExportJob(parent, archiveStorage, typeSelected, numberOfStep)
  63 {
  64     initializeImportJob();
  65 }
  66
  67 ImportMailJob::~ImportMailJob()
  68 {
  69 }
  70
  71 void ImportMailJob::start()
  72 {
  73     Q_EMIT title(i18n("Start import KMail settings..."));
  74     createProgressDialog(i18n("Import KMail settings"));
  75     mArchiveDirectory = archive()->directory();
  76     searchAllMailsFiles(mArchiveDirectory, QString());
  77     if (!mFileList.isEmpty() || !mListResourceFile.isEmpty()) {
  78         initializeListStep();
  79         QTimer::singleShot(0, this, &ImportMailJob::slotNextStep);
  80     } else {
  81         Q_EMIT jobFinished();
  82     }
  83 }
  84
  85 void ImportMailJob::slotNextStep()
  86 {
  87     ++mIndex;
  88     if (mIndex < mListStep.count()) {
  89         const Utils::StoredType type = mListStep.at(mIndex);
  90         if (type == Utils::MailTransport) {
  91             restoreTransports();
  92         } else if (type == Utils::Mails) {
  93             restoreMails();
  94         } else if (type == Utils::Resources) {
  95             restoreResources();
  96         } else if (type == Utils::Identity) {
  97             restoreIdentity();
  98         } else if (type == Utils::Config) {
  99             restoreConfig();
 100         } else if (type == Utils::AkonadiDb) {
 101             restoreAkonadiDb();
 102         } else {
 103             qCDebug(PIMSETTINGEXPORTERCORE_LOG) << Q_FUNC_INFO << " not supported type " << type;
 104             slotNextStep();
 105         }
 106     } else {
 107         Q_EMIT jobFinished();
 108     }
 109 }
 110
 111 void ImportMailJob::searchAllMailsFiles(const KArchiveDirectory *dir, const QString &prefix)
 112 {
 113     Q_FOREACH (const QString &entryName, dir->entries()) {
 114         const KArchiveEntry *entry = dir->entry(entryName);
 115         if (entry && entry->isDirectory()) {
 116             const QString newPrefix = (prefix.isEmpty() ? prefix : prefix + QLatin1Char('/')) + entryName;
 117             if (entryName == QLatin1String("mails")) {
 118                 storeMailArchiveResource(static_cast<const KArchiveDirectory *>(entry), entryName);
 119             } else {
 120                 searchAllMailsFiles(static_cast<const KArchiveDirectory *>(entry), newPrefix);
 121             }
 122         } else if (entry) {
 123             const QString fileName = prefix.isEmpty() ? entry->name() : prefix + QLatin1Char('/') + entry->name();
 124             mFileList << fileName;
 125         }
 126     }
 127 }
 128
 129 void ImportMailJob::storeMailArchiveResource(const KArchiveDirectory *dir, const QString &prefix)
 130 {
 131     Q_FOREACH (const QString &entryName, dir->entries()) {
 132         const KArchiveEntry *entry = dir->entry(entryName);
 133         if (entry && entry->isDirectory()) {
 134             const KArchiveDirectory *resourceDir = static_cast<const KArchiveDirectory *>(entry);
 135             const QStringList lst = resourceDir->entries();
 136             if (lst.count() >= 2) {
 137                 const QString archPath(prefix + QLatin1Char('/') + entryName + QLatin1Char('/'));
 138                 resourceFiles files;
 139                 Q_FOREACH (const QString &name, lst) {
 140                     if (name.endsWith(QLatin1String("rc")) &&
 141                             (name.contains(QStringLiteral("akonadi_mbox_resource_")) ||
 142                              name.contains(QStringLiteral("akonadi_mixedmaildir_resource_")) ||
 143                              name.contains(QStringLiteral("akonadi_maildir_resource_")))) {
 144                         files.akonadiConfigFile = archPath + name;
 145                     } else if (name.startsWith(Utils::prefixAkonadiConfigFile())) {
 146                         files.akonadiAgentConfigFile = archPath + name;
 147                     } else {
 148                         files.akonadiResources = archPath + name;
 149                     }
 150                 }
 151                 //Show debug:
 152                 files.debug();
 153                 mListResourceFile.append(files);
 154             } else {
 155                 qCDebug(PIMSETTINGEXPORTERCORE_LOG) << " Problem in archive. number of file " << lst.count();
 156             }
 157         }
 158     }
 159 }
 160
 161 void ImportMailJob::restoreTransports()
 162 {
 163     setProgressDialogLabel(i18n("Restore transports..."));
 164     increaseProgressDialog();
 165     const QString path = Utils::transportsPath() + QLatin1String("mailtransports");
 166     if (!mFileList.contains(path)) {
 167         Q_EMIT error(i18n("mailtransports file could not be found in the archive."));
 168     } else {
 169         Q_EMIT info(i18n("Restore transports..."));
 170
 171         const KArchiveEntry *transport = mArchiveDirectory->entry(path);
 172         if (transport && transport->isFile()) {
 173             const KArchiveFile *fileTransport = static_cast<const KArchiveFile *>(transport);
 174
 175             fileTransport->copyTo(mTempDirName);
 176             KSharedConfig::Ptr transportConfig = KSharedConfig::openConfig(mTempDirName + QLatin1Char('/') + QLatin1String("mailtransports"));
 177
 178             int defaultTransport = -1;
 179             if (transportConfig->hasGroup(QStringLiteral("General"))) {
 180                 KConfigGroup group = transportConfig->group(QStringLiteral("General"));
 181                 defaultTransport = group.readEntry(QStringLiteral("default-transport"), -1);
 182             }
 183
 184             const QStringList transportList = transportConfig->groupList().filter(QRegularExpression(QLatin1String("Transport \\d+")));
 185             Q_FOREACH (const QString &transport, transportList) {
 186                 KConfigGroup group = transportConfig->group(transport);
 187                 const int transportId = group.readEntry(QStringLiteral("id"), -1);
 188                 MailTransport::Transport *mt = MailTransport::TransportManager::self()->createTransport();
 189                 mt->setName(group.readEntry(QStringLiteral("name")));
 190                 const QString hostStr(QStringLiteral("host"));
 191                 if (group.hasKey(hostStr)) {
 192                     mt->setHost(group.readEntry(hostStr));
 193                 }
 194                 const QString portStr(QStringLiteral("port"));
 195                 if (group.hasKey(portStr)) {
 196                     mt->setPort(group.readEntry(portStr, -1));
 197                 }
 198                 const QString userNameStr(QStringLiteral("userName"));
 199                 if (group.hasKey(userNameStr)) {
 200                     mt->setUserName(group.readEntry(userNameStr));
 201                 }
 202                 const QString precommandStr(QStringLiteral("precommand"));
 203                 if (group.hasKey(precommandStr)) {
 204                     mt->setPrecommand(group.readEntry(precommandStr));
 205                 }
 206                 const QString requiresAuthenticationStr(QStringLiteral("requiresAuthentication"));
 207                 if (group.hasKey(requiresAuthenticationStr)) {
 208                     mt->setRequiresAuthentication(group.readEntry(requiresAuthenticationStr, false));
 209                 }
 210                 const QString specifyHostnameStr(QStringLiteral("specifyHostname"));
 211                 if (group.hasKey(specifyHostnameStr)) {
 212                     mt->setSpecifyHostname(group.readEntry(specifyHostnameStr, false));
 213                 }
 214                 const QString localHostnameStr(QStringLiteral("localHostname"));
 215                 if (group.hasKey(localHostnameStr)) {
 216                     mt->setLocalHostname(group.readEntry(localHostnameStr));
 217                 }
 218                 const QString specifySenderOverwriteAddressStr(QStringLiteral("specifySenderOverwriteAddress"));
 219                 if (group.hasKey(specifySenderOverwriteAddressStr)) {
 220                     mt->setSpecifySenderOverwriteAddress(group.readEntry(specifySenderOverwriteAddressStr, false));
 221                 }
 222                 const QString storePasswordStr(QStringLiteral("storePassword"));
 223                 if (group.hasKey(storePasswordStr)) {
 224                     mt->setStorePassword(group.readEntry(storePasswordStr, false));
 225                 }
 226                 const QString senderOverwriteAddressStr(QStringLiteral("senderOverwriteAddress"));
 227                 if (group.hasKey(senderOverwriteAddressStr)) {
 228                     mt->setSenderOverwriteAddress(group.readEntry(senderOverwriteAddressStr));
 229                 }
 230                 const QString encryptionStr(QStringLiteral("encryption"));
 231                 if (group.hasKey(encryptionStr)) {
 232                     mt->setEncryption(group.readEntry(encryptionStr, 1)); //TODO verify
 233                 }
 234                 const QString authenticationTypeStr(QStringLiteral("authenticationType"));
 235                 if (group.hasKey(authenticationTypeStr)) {
 236                     mt->setAuthenticationType(group.readEntry(authenticationTypeStr, 1)); //TODO verify
 237                 }
 238
 239                 mt->forceUniqueName();
 240                 mt->save();
 241                 MailTransport::TransportManager::self()->addTransport(mt);
 242                 if (transportId == defaultTransport) {
 243                     MailTransport::TransportManager::self()->setDefaultTransport(mt->id());
 244                 }
 245                 mHashTransport.insert(transportId, mt->id());
 246             }
 247             Q_EMIT info(i18n("Transports restored."));
 248         } else {
 249             Q_EMIT error(i18n("Failed to restore transports file."));
 250         }
 251     }
 252     QTimer::singleShot(0, this, &ImportMailJob::slotNextStep);
 253 }
 254
 255 void ImportMailJob::restoreResources()
 256 {
 257     increaseProgressDialog();
 258     setProgressDialogLabel(i18n("Restore resources..."));
 259     Q_EMIT info(i18n("Restore resources..."));
 260
 261     QDir dir(mTempDirName);
 262     dir.mkdir(Utils::resourcesPath());
 263     Q_FOREACH (const QString &filename, mFileList) {
 264         if (filename.startsWith(Utils::resourcesPath())) {
 265             const KArchiveEntry *fileEntry = mArchiveDirectory->entry(filename);
 266             if (fileEntry && fileEntry->isFile()) {
 267                 const KArchiveFile *file = static_cast<const KArchiveFile *>(fileEntry);
 268                 const QString destDirectory = mTempDirName + QLatin1Char('/') + Utils::resourcesPath();
 269
 270                 file->copyTo(destDirectory);
 271
 272                 const QString filename(file->name());
 273                 const QString resourceFileName = destDirectory + QLatin1Char('/') + filename;
 274                 KSharedConfig::Ptr resourceConfig = KSharedConfig::openConfig(resourceFileName);
 275                 QMap<QString, QVariant> settings;
 276                 if (filename.contains(QStringLiteral("pop3"))) {
 277                     KConfigGroup general = resourceConfig->group(QStringLiteral("General"));
 278                     if (general.hasKey(QStringLiteral("login"))) {
 279                         settings.insert(QStringLiteral("Login"), general.readEntry("login"));
 280                     }
 281                     if (general.hasKey(QStringLiteral("host"))) {
 282                         settings.insert(QStringLiteral("Host"), general.readEntry("host"));
 283                     }
 284                     if (general.hasKey(QStringLiteral("port"))) {
 285                         settings.insert(QStringLiteral("Port"), general.readEntry("port", 110));
 286                     }
 287                     if (general.hasKey(QStringLiteral("authenticationMethod"))) {
 288                         settings.insert(QStringLiteral("AuthenticationMethod"), general.readEntry("authenticationMethod", 7));
 289                     }
 290                     if (general.hasKey(QStringLiteral("useSSL"))) {
 291                         settings.insert(QStringLiteral("UseSSL"), general.readEntry("useSSL", false));
 292                     }
 293                     if (general.hasKey(QStringLiteral("useTLS"))) {
 294                         settings.insert(QStringLiteral("UseTLS"), general.readEntry("useTLS", false));
 295                     }
 296                     if (general.hasKey(QStringLiteral("pipelining"))) {
 297                         settings.insert(QStringLiteral("Pipelining"), general.readEntry("pipelining", false));
 298                     }
 299                     if (general.hasKey(QStringLiteral("leaveOnServer"))) {
 300                         settings.insert(QStringLiteral("LeaveOnServer"), general.readEntry("leaveOnServer", false));
 301                     }
 302                     if (general.hasKey(QStringLiteral("leaveOnServerDays"))) {
 303                         settings.insert(QStringLiteral("LeaveOnServerDays"), general.readEntry("leaveOnServerDays", -1));
 304                     }
 305                     if (general.hasKey(QStringLiteral("leaveOnServerCount"))) {
 306                         settings.insert(QStringLiteral("LeaveOnServerCount"), general.readEntry("leaveOnServerCount", -1));
 307                     }
 308                     if (general.hasKey(QStringLiteral("leaveOnServerSize"))) {
 309                         settings.insert(QStringLiteral("LeaveOnServerSize"), general.readEntry("leaveOnServerSize", -1));
 310                     }
 311                     if (general.hasKey(QStringLiteral("filterOnServer"))) {
 312                         settings.insert(QStringLiteral("FilterOnServer"), general.readEntry("filterOnServer", false));
 313                     }
 314                     if (general.hasKey(QStringLiteral("filterCheckSize"))) {
 315                         settings.insert(QStringLiteral("FilterCheckSize"), general.readEntry("filterCheckSize"));
 316                     }
 317                     if (general.hasKey(QStringLiteral("targetCollection"))) {
 318                         const Akonadi::Collection::Id collection = convertPathToId(general.readEntry("targetCollection"));
 319                         if (collection != -1) {
 320                             settings.insert(QStringLiteral("TargetCollection"), collection);
 321                         }
 322                     }
 323                     if (general.hasKey(QStringLiteral("precommand"))) {
 324                         settings.insert(QStringLiteral("Precommand"), general.readEntry("precommand"));
 325                     }
 326                     if (general.hasKey(QStringLiteral("intervalCheckEnabled"))) {
 327                         settings.insert(QStringLiteral("IntervalCheckEnabled"), general.readEntry("intervalCheckEnabled", false));
 328                     }
 329                     if (general.hasKey(QStringLiteral("intervalCheckInterval"))) {
 330                         settings.insert(QStringLiteral("IntervalCheckInterval"), general.readEntry("intervalCheckInterval", 5));
 331                     }
 332
 333                     KConfigGroup leaveOnserver = resourceConfig->group(QStringLiteral("LeaveOnServer"));
 334
 335                     if (leaveOnserver.hasKey(QStringLiteral("seenUidList"))) {
 336                         settings.insert(QStringLiteral("SeenUidList"), leaveOnserver.readEntry("seenUidList", QStringList()));
 337                     }
 338 #if 0
 339                     if (leaveOnserver.hasKey(QStringLiteral("seenUidTimeList"))) {
 340                         //FIXME
 341                         //settings.insert(QLatin1String("SeenUidTimeList"),QVariant::fromValue<QList<int> >(leaveOnserver.readEntry("seenUidTimeList",QList<int>())));
 342                     }
 343 #endif
 344                     if (leaveOnserver.hasKey(QStringLiteral("downloadLater"))) {
 345                         settings.insert(QStringLiteral("DownloadLater"), leaveOnserver.readEntry("downloadLater", QStringList()));
 346                     }
 347                     const QString newResource = mCreateResource->createResource(QStringLiteral("akonadi_pop3_resource"), filename, settings);
 348                     if (!newResource.isEmpty()) {
 349                         mHashResources.insert(filename, newResource);
 350                         infoAboutNewResource(newResource);
 351                     }
 352                 } else if (filename.contains(QStringLiteral("imap")) || filename.contains(QStringLiteral("kolab_")) || filename.contains(QStringLiteral("gmail_"))) {
 353                     KConfigGroup network = resourceConfig->group(QStringLiteral("network"));
 354                     if (network.hasKey(QStringLiteral("Authentication"))) {
 355                         settings.insert(QStringLiteral("Authentication"), network.readEntry("Authentication", 1));
 356                     }
 357                     if (network.hasKey(QStringLiteral("ImapPort"))) {
 358                         settings.insert(QStringLiteral("ImapPort"), network.readEntry("ImapPort", 993));
 359                     }
 360                     if (network.hasKey(QStringLiteral("ImapServer"))) {
 361                         settings.insert(QStringLiteral("ImapServer"), network.readEntry("ImapServer"));
 362                     }
 363                     if (network.hasKey(QStringLiteral("Safety"))) {
 364                         settings.insert(QStringLiteral("Safety"), network.readEntry("Safety", "SSL"));
 365                     }
 366                     if (network.hasKey(QStringLiteral("SubscriptionEnabled"))) {
 367                         settings.insert(QStringLiteral("SubscriptionEnabled"), network.readEntry("SubscriptionEnabled", false));
 368                     }
 369                     if (network.hasKey(QStringLiteral("UserName"))) {
 370                         settings.insert(QStringLiteral("UserName"), network.readEntry("UserName"));
 371                     }
 372
 373                     if (network.hasKey(QStringLiteral("SessionTimeout"))) {
 374                         settings.insert(QStringLiteral("SessionTimeout"), network.readEntry("SessionTimeout", 30));
 375                     }
 376
 377                     KConfigGroup cache = resourceConfig->group(QStringLiteral("cache"));
 378
 379                     if (cache.hasKey(QStringLiteral("AccountIdentity"))) {
 380                         const int identity = cache.readEntry("AccountIdentity", -1);
 381                         if (identity != -1) {
 382                             if (mHashIdentity.contains(identity)) {
 383                                 settings.insert(QStringLiteral("AccountIdentity"), mHashIdentity.value(identity));
 384                             } else {
 385                                 settings.insert(QStringLiteral("AccountIdentity"), identity);
 386                             }
 387                         }
 388                     }
 389                     if (cache.hasKey(QStringLiteral("IntervalCheckEnabled"))) {
 390                         settings.insert(QStringLiteral("IntervalCheckEnabled"), cache.readEntry("IntervalCheckEnabled", true));
 391                     }
 392                     if (cache.hasKey(QStringLiteral("RetrieveMetadataOnFolderListing"))) {
 393                         settings.insert(QStringLiteral("RetrieveMetadataOnFolderListing"), cache.readEntry("RetrieveMetadataOnFolderListing", true));
 394                     }
 395                     if (cache.hasKey(QStringLiteral("AutomaticExpungeEnabled"))) {
 396                         settings.insert(QStringLiteral("AutomaticExpungeEnabled"), cache.readEntry("AutomaticExpungeEnabled", true));
 397                     }
 398                     if (cache.hasKey(QLatin1String(""))) {
 399                         settings.insert(QLatin1String(""), cache.readEntry(""));
 400                     }
 401                     if (cache.hasKey(QStringLiteral("DisconnectedModeEnabled"))) {
 402                         settings.insert(QStringLiteral("DisconnectedModeEnabled"), cache.readEntry("DisconnectedModeEnabled", false));
 403                     }
 404                     if (cache.hasKey(QStringLiteral("IntervalCheckTime"))) {
 405                         settings.insert(QStringLiteral("IntervalCheckTime"), cache.readEntry("IntervalCheckTime", -1));
 406                     }
 407                     if (cache.hasKey(QStringLiteral("UseDefaultIdentity"))) {
 408                         settings.insert(QStringLiteral("UseDefaultIdentity"), cache.readEntry("UseDefaultIdentity", true));
 409                     }
 410                     if (cache.hasKey(QStringLiteral("TrashCollection"))) {
 411                         const Akonadi::Collection::Id collection = convertPathToId(cache.readEntry("TrashCollection"));
 412                         if (collection != -1) {
 413                             settings.insert(QStringLiteral("TrashCollection"), collection);
 414                         } else {
 415                             qCDebug(PIMSETTINGEXPORTERCORE_LOG) << " Use default trash folder";
 416                         }
 417                     }
 418
 419                     KConfigGroup siever = resourceConfig->group(QStringLiteral("siever"));
 420                     if (siever.hasKey(QStringLiteral("SieveSupport"))) {
 421                         settings.insert(QStringLiteral("SieveSupport"), siever.readEntry("SieveSupport", false));
 422                     }
 423                     if (siever.hasKey(QStringLiteral("SieveReuseConfig"))) {
 424                         settings.insert(QStringLiteral("SieveReuseConfig"), siever.readEntry("SieveReuseConfig", true));
 425                     }
 426                     if (siever.hasKey(QStringLiteral("SievePort"))) {
 427                         settings.insert(QStringLiteral("SievePort"), siever.readEntry("SievePort", 4190));
 428                     }
 429                     if (siever.hasKey(QStringLiteral("SieveAlternateUrl"))) {
 430                         settings.insert(QStringLiteral("SieveAlternateUrl"), siever.readEntry("SieveAlternateUrl"));
 431                     }
 432                     if (siever.hasKey(QStringLiteral("AlternateAuthentication"))) {
 433                         settings.insert(QStringLiteral("AlternateAuthentication"), siever.readEntry("AlternateAuthentication"));
 434                     }
 435                     if (siever.hasKey(QStringLiteral("SieveVacationFilename"))) {
 436                         settings.insert(QStringLiteral("SieveVacationFilename"), siever.readEntry("SieveVacationFilename"));
 437                     }
 438                     if (siever.hasKey(QStringLiteral("SieveCustomUsername"))) {
 439                         settings.insert(QStringLiteral("SieveCustomUsername"), siever.readEntry("SieveCustomUsername"));
 440                     }
 441                     if (siever.hasKey(QStringLiteral("SieveCustomAuthentification"))) {
 442                         settings.insert(QStringLiteral("SieveCustomAuthentification"), siever.readEntry("SieveCustomAuthentification"));
 443                     }
 444
 445                     QString newResource;
 446                     if (filename.contains(QStringLiteral("kolab_"))) {
 447                         newResource = mCreateResource->createResource(QStringLiteral("akonadi_kolab_resource"), filename, settings);
 448                     } else if (filename.contains(QStringLiteral("gmail_"))) {
 449                         newResource = mCreateResource->createResource(QStringLiteral("akonadi_gmail_resource"), filename, settings);
 450                     } else {
 451                         newResource = mCreateResource->createResource(QStringLiteral("akonadi_imap_resource"), filename, settings);
 452                     }
 453                     if (!newResource.isEmpty()) {
 454                         mHashResources.insert(filename, newResource);
 455                         infoAboutNewResource(newResource);
 456                     }
 457                 } else {
 458                     qCDebug(PIMSETTINGEXPORTERCORE_LOG) << " problem with resource";
 459                 }
 460             }
 461         }
 462     }
 463     //TODO synctree ?
 464
 465     Q_EMIT info(i18n("Resources restored."));
 466     QTimer::singleShot(0, this, &ImportMailJob::slotNextStep);
 467 }
 468
 469 void ImportMailJob::restoreMails()
 470 {
 471     increaseProgressDialog();
 472     setProgressDialogLabel(i18n("Restore mails..."));
 473     QStringList listResourceToSync;
 474     Q_EMIT info(i18n("Restore mails..."));
 475
 476     QDir dir(mTempDirName);
 477     dir.mkdir(Utils::mailsPath());
 478     const QString copyToDirName(mTempDirName + QLatin1Char('/') + Utils::mailsPath());
 479     const int numberOfResourceFile = mListResourceFile.size();
 480     for (int i = 0; i < numberOfResourceFile; ++i) {
 481
 482         resourceFiles value = mListResourceFile.at(i);
 483         value.debug();
 484         const QString resourceFile = value.akonadiConfigFile;
 485         const KArchiveEntry *fileResouceEntry = mArchiveDirectory->entry(resourceFile);
 486         if (fileResouceEntry && fileResouceEntry->isFile()) {
 487             const KArchiveFile *file = static_cast<const KArchiveFile *>(fileResouceEntry);
 488             file->copyTo(copyToDirName);
 489             QString resourceName(file->name());
 490             QString filename(file->name());
 491             //qCDebug(PIMSETTINGEXPORTERCORE_LOG)<<" filename "<<filename<<" resourceName"<<resourceName;
 492             KSharedConfig::Ptr resourceConfig = KSharedConfig::openConfig(copyToDirName + QLatin1Char('/') + resourceName);
 493
 494             const QString newUrl = Utils::adaptResourcePath(resourceConfig, storeMails());
 495
 496             const QString agentConfigFile = value.akonadiAgentConfigFile;
 497             if (!agentConfigFile.isEmpty()) {
 498                 const KArchiveEntry *akonadiAgentConfigEntry = mArchiveDirectory->entry(agentConfigFile);
 499                 if (akonadiAgentConfigEntry->isFile()) {
 500                     const KArchiveFile *file = static_cast<const KArchiveFile *>(akonadiAgentConfigEntry);
 501                     file->copyTo(copyToDirName);
 502                     resourceName = file->name();
 503                     filename = Utils::akonadiAgentName(copyToDirName + QLatin1Char('/') + resourceName);
 504                 }
 505             }
 506
 507             QMap<QString, QVariant> settings;
 508             if (resourceName.contains(QStringLiteral("akonadi_mbox_resource_"))) {
 509                 const QString dataFile = value.akonadiResources;
 510                 const KArchiveEntry *dataResouceEntry = mArchiveDirectory->entry(dataFile);
 511                 if (dataResouceEntry->isFile()) {
 512                     const KArchiveFile *file = static_cast<const KArchiveFile *>(dataResouceEntry);
 513                     file->copyTo(newUrl);
 514                 }
 515                 settings.insert(QStringLiteral("Path"), newUrl);
 516
 517                 KConfigGroup general = resourceConfig->group(QStringLiteral("General"));
 518                 if (general.hasKey(QStringLiteral("DisplayName"))) {
 519                     settings.insert(QStringLiteral("DisplayName"), general.readEntry(QStringLiteral("DisplayName")));
 520                 }
 521                 if (general.hasKey(QStringLiteral("ReadOnly"))) {
 522                     settings.insert(QStringLiteral("ReadOnly"), general.readEntry(QStringLiteral("ReadOnly"), false));
 523                 }
 524                 if (general.hasKey(QStringLiteral("MonitorFile"))) {
 525                     settings.insert(QStringLiteral("MonitorFile"), general.readEntry(QStringLiteral("MonitorFile"), false));
 526                 }
 527                 if (resourceConfig->hasGroup(QStringLiteral("Locking"))) {
 528                     KConfigGroup locking = resourceConfig->group(QStringLiteral("Locking"));
 529                     if (locking.hasKey(QStringLiteral("Lockfile"))) {
 530                         settings.insert(QStringLiteral("Lockfile"), locking.readEntry(QStringLiteral("Lockfile")));
 531                     }
 532                     //TODO verify
 533                     if (locking.hasKey(QStringLiteral("LockfileMethod"))) {
 534                         settings.insert(QStringLiteral("LockfileMethod"), locking.readEntry(QStringLiteral("LockfileMethod"), 4));
 535                     }
 536                 }
 537                 if (resourceConfig->hasGroup(QStringLiteral("Compacting"))) {
 538                     KConfigGroup compacting = resourceConfig->group(QStringLiteral("Compacting"));
 539                     if (compacting.hasKey(QStringLiteral("CompactFrequency"))) {
 540                         settings.insert(QStringLiteral("CompactFrequency"), compacting.readEntry(QStringLiteral("CompactFrequency"), 1));
 541                     }
 542                     if (compacting.hasKey(QStringLiteral("MessageCount"))) {
 543                         settings.insert(QStringLiteral("MessageCount"), compacting.readEntry(QStringLiteral("MessageCount"), 50));
 544                     }
 545                 }
 546                 const QString newResource = mCreateResource->createResource(QStringLiteral("akonadi_mbox_resource"), filename, settings);
 547                 if (!newResource.isEmpty()) {
 548                     mHashResources.insert(filename, newResource);
 549                     infoAboutNewResource(newResource);
 550                 }
 551
 552             } else if (resourceName.contains(QStringLiteral("akonadi_maildir_resource_")) ||
 553                        resourceName.contains(QStringLiteral("akonadi_mixedmaildir_resource_"))) {
 554                 settings.insert(QStringLiteral("Path"), newUrl);
 555                 KConfigGroup general = resourceConfig->group(QStringLiteral("General"));
 556                 if (general.hasKey(QStringLiteral("TopLevelIsContainer"))) {
 557                     settings.insert(QStringLiteral("TopLevelIsContainer"), general.readEntry(QStringLiteral("TopLevelIsContainer"), false));
 558                 }
 559                 if (general.hasKey(QStringLiteral("ReadOnly"))) {
 560                     settings.insert(QStringLiteral("ReadOnly"), general.readEntry(QStringLiteral("ReadOnly"), false));
 561                 }
 562                 if (general.hasKey(QStringLiteral("MonitorFilesystem"))) {
 563                     settings.insert(QStringLiteral("MonitorFilesystem"), general.readEntry(QStringLiteral("MonitorFilesystem"), true));
 564                 }
 565
 566                 const QString newResource = mCreateResource->createResource(resourceName.contains(QStringLiteral("akonadi_mixedmaildir_resource_")) ?
 567                                             QStringLiteral("akonadi_mixedmaildir_resource")
 568                                             : QStringLiteral("akonadi_maildir_resource")
 569                                             , filename, settings);
 570                 if (!newResource.isEmpty()) {
 571                     mHashResources.insert(filename, newResource);
 572                     infoAboutNewResource(newResource);
 573                 }
 574
 575                 const QString mailFile = value.akonadiResources;
 576                 const KArchiveEntry *dataResouceEntry = mArchiveDirectory->entry(mailFile);
 577                 if (dataResouceEntry && dataResouceEntry->isFile()) {
 578                     const KArchiveFile *file = static_cast<const KArchiveFile *>(dataResouceEntry);
 579                     //TODO Fix me not correct zip filename.
 580                     extractZipFile(file, copyToDirName, newUrl);
 581                 }
 582                 listResourceToSync << newResource;
 583             } else {
 584                 qCDebug(PIMSETTINGEXPORTERCORE_LOG) << " resource name not supported " << resourceName;
 585             }
 586             //qCDebug(PIMSETTINGEXPORTERCORE_LOG)<<"url "<<url;
 587         }
 588     }
 589     Q_EMIT info(i18n("Mails restored."));
 590     startSynchronizeResources(listResourceToSync);
 591 }
 592
 593 void ImportMailJob::restoreConfig()
 594 {
 595
 596     increaseProgressDialog();
 597     setProgressDialogLabel(i18n("Restore config..."));
 598     const QString filtersPath(Utils::configsPath() + QLatin1String("filters"));
 599     if (!mFileList.contains(filtersPath)) {
 600         Q_EMIT error(i18n("filters file could not be found in the archive."));
 601     } else {
 602         const KArchiveEntry *filter = mArchiveDirectory->entry(filtersPath);
 603         if (filter && filter->isFile()) {
 604             const KArchiveFile *fileFilter = static_cast<const KArchiveFile *>(filter);
 605
 606             fileFilter->copyTo(mTempDirName);
 607             const QString filterFileName(mTempDirName + QLatin1Char('/') + QLatin1String("filters"));
 608             KSharedConfig::Ptr filtersConfig = KSharedConfig::openConfig(filterFileName);
 609             const QStringList filterList = filtersConfig->groupList().filter(QRegularExpression(QStringLiteral("Filter #\\d+")));
 610             Q_FOREACH (const QString &filterStr, filterList) {
 611                 KConfigGroup group = filtersConfig->group(filterStr);
 612                 const QString accountStr(QStringLiteral("accounts-set"));
 613                 if (group.hasKey(accountStr)) {
 614                     const QString accounts = group.readEntry(accountStr);
 615                     if (!accounts.isEmpty()) {
 616                         const QStringList lstAccounts = accounts.split(QLatin1Char(','));
 617                         QStringList newLstAccounts;
 618                         Q_FOREACH (const QString &acc, lstAccounts) {
 619                             if (mHashResources.contains(acc)) {
 620                                 newLstAccounts.append(mHashResources.value(acc));
 621                             } else {
 622                                 newLstAccounts.append(acc);
 623                             }
 624                         }
 625                         group.writeEntry(accountStr, newLstAccounts);
 626                     }
 627                 }
 628                 const int numActions = group.readEntry("actions", 0);
 629                 QString actName;
 630                 QString argsName;
 631                 for (int i = 0; i < numActions; ++i) {
 632                     actName.sprintf("action-name-%d", i);
 633                     argsName.sprintf("action-args-%d", i);
 634                     const QString actValue = group.readEntry(actName);
 635                     if (actValue == QLatin1String("set identity")) {
 636                         const int argsValue = group.readEntry(argsName, -1);
 637                         if (argsValue != -1) {
 638                             if (mHashIdentity.contains(argsValue)) {
 639                                 group.writeEntry(argsName, mHashIdentity.value(argsValue));
 640                             }
 641                         }
 642                     } else if (actValue == QLatin1String("set transport")) {
 643                         const int argsValue = group.readEntry(argsName, -1);
 644                         if (argsValue != -1) {
 645                             if (mHashTransport.contains(argsValue)) {
 646                                 group.writeEntry(argsName, mHashTransport.value(argsValue));
 647                             }
 648                         }
 649                     }
 650                 }
 651             }
 652             filtersConfig->sync();
 653
 654             bool canceled = false;
 655             MailCommon::FilterImporterExporter exportFilters;
 656             QList<MailCommon::MailFilter *> lstFilter = exportFilters.importFilters(canceled, MailCommon::FilterImporterExporter::KMailFilter, filterFileName);
 657             if (canceled) {
 658                 MailCommon::FilterManager::instance()->appendFilters(lstFilter);
 659             }
 660         }
 661     }
 662     const QString kmailsnippetrcStr(QStringLiteral("kmailsnippetrc"));
 663     const KArchiveEntry *kmailsnippetentry  = mArchiveDirectory->entry(Utils::configsPath() + kmailsnippetrcStr);
 664     if (kmailsnippetentry && kmailsnippetentry->isFile()) {
 665         const KArchiveFile *kmailsnippet = static_cast<const KArchiveFile *>(kmailsnippetentry);
 666         const QString kmailsnippetrc = QStandardPaths::writableLocation(QStandardPaths::ConfigLocation) + QLatin1Char('/') + kmailsnippetrcStr;
 667         if (QFile(kmailsnippetrc).exists()) {
 668             //TODO 4.13 allow to merge config.
 669             if (overwriteConfigMessageBox(kmailsnippetrcStr)) {
 670                 copyToFile(kmailsnippet, kmailsnippetrc, kmailsnippetrcStr, Utils::configsPath());
 671             }
 672         } else {
 673             copyToFile(kmailsnippet, kmailsnippetrc, kmailsnippetrcStr, Utils::configsPath());
 674         }
 675     }
 676
 677     const QString labldaprcStr(QStringLiteral("kabldaprc"));
 678     const KArchiveEntry *kabldapentry  = mArchiveDirectory->entry(Utils::configsPath() + labldaprcStr);
 679     if (kabldapentry && kabldapentry->isFile()) {
 680         const KArchiveFile *kabldap = static_cast<const KArchiveFile *>(kabldapentry);
 681         const QString kabldaprc = QStandardPaths::writableLocation(QStandardPaths::ConfigLocation) + QLatin1Char('/') + labldaprcStr;
 682         if (QFile(kabldaprc).exists()) {
 683             const int result = mergeConfigMessageBox(labldaprcStr);
 684             if (result == KMessageBox::Yes) {
 685                 copyToFile(kabldap, kabldaprc, labldaprcStr, Utils::configsPath());
 686             } else if (result == KMessageBox::No) {
 687                 mergeLdapConfig(kabldap, labldaprcStr, Utils::configsPath());
 688             }
 689         } else {
 690             copyToFile(kabldap, kabldaprc, labldaprcStr, Utils::configsPath());
 691         }
 692     }
 693     const QString archiveconfigurationrcStr(QStringLiteral("akonadi_archivemail_agentrc"));
 694     const KArchiveEntry *archiveconfigurationentry  = mArchiveDirectory->entry(Utils::configsPath() + archiveconfigurationrcStr);
 695     if (archiveconfigurationentry &&  archiveconfigurationentry->isFile()) {
 696         const KArchiveFile *archiveconfiguration = static_cast<const KArchiveFile *>(archiveconfigurationentry);
 697         const QString archiveconfigurationrc = QStandardPaths::writableLocation(QStandardPaths::ConfigLocation) + QLatin1Char('/') + archiveconfigurationrcStr;
 698         if (QFile(archiveconfigurationrc).exists()) {
 699             const int result = mergeConfigMessageBox(archiveconfigurationrcStr);
 700             if (result == KMessageBox::Yes) {
 701                 importArchiveConfig(archiveconfiguration, archiveconfigurationrc, archiveconfigurationrcStr, Utils::configsPath());
 702             } else if (result == KMessageBox::No) {
 703                 mergeArchiveMailAgentConfig(archiveconfiguration, archiveconfigurationrcStr, Utils::configsPath());
 704             }
 705         } else {
 706             importArchiveConfig(archiveconfiguration, archiveconfigurationrc, archiveconfigurationrcStr, Utils::configsPath());
 707         }
 708     }
 709
 710     const QString templatesconfigurationrcStr(QStringLiteral("templatesconfigurationrc"));
 711     const KArchiveEntry *templatesconfigurationentry  = mArchiveDirectory->entry(Utils::configsPath() + templatesconfigurationrcStr);
 712     if (templatesconfigurationentry &&  templatesconfigurationentry->isFile()) {
 713         const KArchiveFile *templatesconfiguration = static_cast<const KArchiveFile *>(templatesconfigurationentry);
 714         const QString templatesconfigurationrc = QStandardPaths::writableLocation(QStandardPaths::ConfigLocation) + QLatin1Char('/') + templatesconfigurationrcStr;
 715         if (QFile(templatesconfigurationrc).exists()) {
 716             //TODO 4.13 allow to merge config.
 717             if (overwriteConfigMessageBox(templatesconfigurationrcStr)) {
 718                 importTemplatesConfig(templatesconfiguration, templatesconfigurationrc, templatesconfigurationrcStr, Utils::configsPath());
 719             }
 720         } else {
 721             importTemplatesConfig(templatesconfiguration, templatesconfigurationrc, templatesconfigurationrcStr, Utils::configsPath());
 722         }
 723     }
 724
 725     const QString kmailStr(QStringLiteral("kmail2rc"));
 726     const KArchiveEntry *kmail2rcentry  = mArchiveDirectory->entry(Utils::configsPath() + kmailStr);
 727     if (kmail2rcentry && kmail2rcentry->isFile()) {
 728         const KArchiveFile *kmailrc = static_cast<const KArchiveFile *>(kmail2rcentry);
 729         const QString kmail2rc = QStandardPaths::writableLocation(QStandardPaths::ConfigLocation) + QLatin1Char('/') + kmailStr;
 730         if (QFile(kmail2rc).exists()) {
 731             if (overwriteConfigMessageBox(kmailStr)) {
 732                 importKmailConfig(kmailrc, kmail2rc, kmailStr, Utils::configsPath());
 733             }
 734         } else {
 735             importKmailConfig(kmailrc, kmail2rc, kmailStr, Utils::configsPath());
 736         }
 737     }
 738
 739     const QString sievetemplatercStr(QStringLiteral("sievetemplaterc"));
 740     const KArchiveEntry *sievetemplatentry  = mArchiveDirectory->entry(Utils::configsPath() + sievetemplatercStr);
 741     if (sievetemplatentry &&  sievetemplatentry->isFile()) {
 742         const KArchiveFile *sievetemplateconfiguration = static_cast<const KArchiveFile *>(sievetemplatentry);
 743         const QString sievetemplaterc = QStandardPaths::writableLocation(QStandardPaths::ConfigLocation) + QLatin1Char('/') + sievetemplatercStr;
 744         if (QFile(sievetemplaterc).exists()) {
 745             const int result = mergeConfigMessageBox(sievetemplatercStr);
 746             if (result == KMessageBox::Yes) {
 747                 copyToFile(sievetemplateconfiguration, sievetemplaterc, sievetemplatercStr, Utils::configsPath());
 748             } else if (result == KMessageBox::No) {
 749                 mergeSieveTemplate(sievetemplateconfiguration, sievetemplatercStr, Utils::configsPath());
 750             }
 751         } else {
 752             copyToFile(sievetemplateconfiguration, sievetemplaterc, sievetemplatercStr, Utils::configsPath());
 753         }
 754     }
 755
 756     const QString customTemplateStr(QStringLiteral("customtemplatesrc"));
 757     const KArchiveEntry *customtemplatentry  = mArchiveDirectory->entry(Utils::configsPath() + customTemplateStr);
 758     if (customtemplatentry &&  customtemplatentry->isFile()) {
 759         const KArchiveFile *customtemplateconfiguration = static_cast<const KArchiveFile *>(customtemplatentry);
 760         const QString customtemplaterc = QStandardPaths::writableLocation(QStandardPaths::ConfigLocation) + QLatin1Char('/') + customTemplateStr;
 761         if (QFile(customtemplaterc).exists()) {
 762             //TODO 4.13 allow to merge config.
 763             if (overwriteConfigMessageBox(customTemplateStr)) {
 764                 copyToFile(customtemplateconfiguration, customtemplaterc, customTemplateStr, Utils::configsPath());
 765             }
 766         } else {
 767             copyToFile(customtemplateconfiguration, customtemplaterc, customTemplateStr, Utils::configsPath());
 768         }
 769     }
 770
 771     const QString adblockStr(QStringLiteral("messagevieweradblockrc"));
 772     const KArchiveEntry *adblockentry  = mArchiveDirectory->entry(Utils::configsPath() + adblockStr);
 773     if (adblockentry &&  adblockentry->isFile()) {
 774         const KArchiveFile *adblockconfiguration = static_cast<const KArchiveFile *>(adblockentry);
 775         const QString adblockrc = QStandardPaths::writableLocation(QStandardPaths::ConfigLocation) + QLatin1Char('/') + adblockStr;
 776         if (QFile(adblockrc).exists()) {
 777             //TODO 4.13 allow to merge config.
 778             if (overwriteConfigMessageBox(adblockStr)) {
 779                 copyToFile(adblockconfiguration, adblockrc, adblockStr, Utils::configsPath());
 780             }
 781         } else {
 782             copyToFile(adblockconfiguration, adblockrc, adblockStr, Utils::configsPath());
 783         }
 784     }
 785
 786     restoreUiRcFile(QStringLiteral("sieveeditorui.rc"), QStringLiteral("sieveeditor"));
 787     restoreUiRcFile(QStringLiteral("storageservicemanagerui.rc"), QStringLiteral("storageservicemanager"));
 788
 789     restoreUiRcFile(QStringLiteral("kmreadermainwin.rc"), QStringLiteral("kmail2"));
 790     restoreUiRcFile(QStringLiteral("kmcomposerui.rc"), QStringLiteral("kmail2"));
 791     restoreUiRcFile(QStringLiteral("kmmainwin.rc"), QStringLiteral("kmail2"));
 792     restoreUiRcFile(QStringLiteral("kmail_part.rc"), QStringLiteral("kmail2"));
 793     restoreUiRcFile(QStringLiteral("kontactui.rc"), QStringLiteral("kontact"));
 794     restoreUiRcFile(QStringLiteral("kleopatra.rc"), QStringLiteral("kleopatra"));
 795
 796     restoreConfigFile(QStringLiteral("kontactrc"));
 797
 798     restoreConfigFile(QStringLiteral("kontact_summaryrc"));
 799     restoreConfigFile(QStringLiteral("storageservicerc"));
 800     restoreConfigFile(QStringLiteral("kpimbalooblacklist"));
 801     restoreConfigFile(QStringLiteral("kleopatrarc"));
 802     restoreConfigFile(QStringLiteral("sieveeditorrc"));
 803     //Restore notify file
 804     QStringList lstNotify;
 805     lstNotify << QStringLiteral("akonadi_mailfilter_agent.notifyrc")
 806               << QStringLiteral("akonadi_sendlater_agent.notifyrc")
 807               << QStringLiteral("akonadi_archivemail_agent.notifyrc")
 808               << QStringLiteral("kmail2.notifyrc")
 809               << QStringLiteral("akonadi_newmailnotifier_agent.notifyrc")
 810               << QStringLiteral("akonadi_maildispatcher_agent.notifyrc")
 811               << QStringLiteral("akonadi_followupreminder_agent.notifyrc")
 812               << QStringLiteral("messageviewer.notifyrc");
 813
 814     //We can't merge it.
 815     Q_FOREACH (const QString &filename, lstNotify) {
 816         restoreConfigFile(filename);
 817     }
 818
 819     importSimpleFilesInDirectory(QStringLiteral("/autocorrect/"));
 820     importSimpleFilesInDirectory(QStringLiteral("/gravatar/"));
 821     const KArchiveEntry *kmail2Entry  = mArchiveDirectory->entry(Utils::dataPath() + QLatin1String("kmail2/adblockrules_local"));
 822     if (kmail2Entry && kmail2Entry->isFile()) {
 823         const KArchiveFile *entry = static_cast<const KArchiveFile *>(kmail2Entry);
 824         const QString adblockPath = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + QLatin1Char('/') + QLatin1String("kmail2/adblockrules_local");
 825         if (QFile(adblockPath).exists()) {
 826             if (overwriteConfigMessageBox(QStringLiteral("adblockrules_local"))) {
 827                 copyToFile(entry, QString(QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + QLatin1String("/") + QLatin1String("kmail2/adblockrules_local")), QStringLiteral("adblockrules_local"), Utils::dataPath() + QLatin1String("kmail2/"));
 828             }
 829         } else {
 830             copyToFile(entry, QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + QLatin1Char('/') + QLatin1String("kmail2/adblockrules_local"), QStringLiteral("adblockrules_local"), Utils::dataPath() + QLatin1String("kmail2/"));
 831         }
 832     }
 833
 834     importDataSubdirectory(QStringLiteral("/messageviewer/themes/"));
 835
 836     Q_EMIT info(i18n("Config restored."));
 837     QTimer::singleShot(0, this, &ImportMailJob::slotNextStep);
 838 }
 839
 840 void ImportMailJob::importSimpleFilesInDirectory(const QString &relativePath)
 841 {
 842     const KArchiveEntry *autocorrectionEntry  = mArchiveDirectory->entry(Utils::dataPath() + relativePath);
 843     if (autocorrectionEntry && autocorrectionEntry->isDirectory()) {
 844         const KArchiveDirectory *autoCorrectionDir = static_cast<const KArchiveDirectory *>(autocorrectionEntry);
 845         Q_FOREACH (const QString &entryName, autoCorrectionDir->entries()) {
 846             const KArchiveEntry *entry = autoCorrectionDir->entry(entryName);
 847             if (entry && entry->isFile()) {
 848                 const KArchiveFile *autocorrectionFile = static_cast<const KArchiveFile *>(entry);
 849                 const QString name = autocorrectionFile->name();
 850                 QString autocorrectionPath = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + QLatin1Char('/') + relativePath + QLatin1Char('/') + name;
 851                 if (QFile(autocorrectionPath).exists()) {
 852                     if (overwriteConfigMessageBox(name)) {
 853                         copyToFile(autocorrectionFile, autocorrectionPath, name, Utils::dataPath() + relativePath);
 854                     }
 855                 } else {
 856                     autocorrectionPath = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + QLatin1Char('/') + relativePath;
 857                     copyToFile(autocorrectionFile, autocorrectionPath + QLatin1Char('/') + name, name, Utils::dataPath() + relativePath);
 858                 }
 859             }
 860         }
 861     }
 862 }
 863
 864 void ImportMailJob::restoreIdentity()
 865 {
 866     increaseProgressDialog();
 867     setProgressDialogLabel(i18n("Restore identities..."));
 868     const QString path(Utils::identitiesPath() + QLatin1String("emailidentities"));
 869     if (!mFileList.contains(path)) {
 870         Q_EMIT error(i18n("emailidentities file could not be found in the archive."));
 871     } else {
 872         Q_EMIT info(i18n("Restore identities..."));
 873
 874         const KArchiveEntry *identity = mArchiveDirectory->entry(path);
 875         if (identity && identity->isFile()) {
 876             const KArchiveFile *fileIdentity = static_cast<const KArchiveFile *>(identity);
 877             fileIdentity->copyTo(mTempDirName);
 878             KSharedConfig::Ptr identityConfig = KSharedConfig::openConfig(mTempDirName + QLatin1Char('/') + QLatin1String("emailidentities"));
 879             KConfigGroup general = identityConfig->group(QStringLiteral("General"));
 880             const int defaultIdentity = general.readEntry(QStringLiteral("Default Identity"), -1);
 881
 882             const QStringList identityList = identityConfig->groupList().filter(QRegularExpression(QStringLiteral("Identity #\\d+")));
 883             Q_FOREACH (const QString &identityStr, identityList) {
 884                 KConfigGroup group = identityConfig->group(identityStr);
 885                 int oldUid = -1;
 886                 const QString uidStr(QStringLiteral("uoid"));
 887                 if (group.hasKey(uidStr)) {
 888                     oldUid = group.readEntry(uidStr).toUInt();
 889                     group.deleteEntry(uidStr);
 890                 }
 891                 const QString fcc(QStringLiteral("Fcc"));
 892                 convertRealPathToCollection(group, fcc);
 893
 894                 const QString draft = QStringLiteral("Drafts");
 895                 convertRealPathToCollection(group, draft);
 896
 897                 const QString templates = QStringLiteral("Templates");
 898                 convertRealPathToCollection(group, templates);
 899
 900                 if (oldUid != -1) {
 901                     const QString vcard = QStringLiteral("VCardFile");
 902                     if (group.hasKey(vcard)) {
 903                         const QString vcardFileName = group.readEntry(vcard);
 904                         if (!vcardFileName.isEmpty()) {
 905
 906                             QFileInfo fileInfo(vcardFileName);
 907                             QFile file(vcardFileName);
 908                             const KArchiveEntry *vcardEntry = mArchiveDirectory->entry(Utils::identitiesPath() + QString::number(oldUid) + QDir::separator() + file.fileName());
 909                             if (vcardEntry && vcardEntry->isFile()) {
 910                                 const KArchiveFile *vcardFile = static_cast<const KArchiveFile *>(vcardEntry);
 911                                 QString vcardFilePath = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + QLatin1Char('/') + QStringLiteral("kmail2/%1").arg(fileInfo.fileName());
 912                                 int i = 1;
 913                                 while (QFile(vcardFileName).exists()) {
 914                                     vcardFilePath = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + QLatin1Char('/') + QStringLiteral("kmail2/%1_%2").arg(i).arg(fileInfo.fileName());
 915                                     ++i;
 916                                 }
 917                                 vcardFile->copyTo(QFileInfo(vcardFilePath).absolutePath());
 918                                 group.writeEntry(vcard, vcardFilePath);
 919                             }
 920                         }
 921                     }
 922                 }
 923                 QString name =  group.readEntry(QStringLiteral("Name"));
 924
 925                 KIdentityManagement::Identity *identity = &mIdentityManager->newFromScratch(uniqueIdentityName(name));
 926                 group.writeEntry(QStringLiteral("Name"), name);
 927                 group.sync();
 928
 929                 identity->readConfig(group);
 930
 931                 if (oldUid != -1) {
 932                     mHashIdentity.insert(oldUid, identity->uoid());
 933                     if (oldUid == defaultIdentity) {
 934                         mIdentityManager->setAsDefault(identity->uoid());
 935                     }
 936                 }
 937                 mIdentityManager->commit();
 938             }
 939             Q_EMIT info(i18n("Identities restored."));
 940         } else {
 941             Q_EMIT error(i18n("Failed to restore identity file."));
 942         }
 943     }
 944     QTimer::singleShot(0, this, &ImportMailJob::slotNextStep);
 945 }
 946
 947 QString ImportMailJob::uniqueIdentityName(const QString &name)
 948 {
 949     QString newName(name);
 950     int i = 0;
 951     while (!mIdentityManager->isUnique(newName)) {
 952         newName = QStringLiteral("%1_%2").arg(name).arg(i);
 953         ++i;
 954     }
 955     return newName;
 956 }
 957
 958 void ImportMailJob::restoreAkonadiDb()
 959 {
 960     const QString akonadiDbPath(Utils::akonadiPath() + QLatin1String("akonadidatabase.sql"));
 961     if (!mFileList.contains(akonadiDbPath)) {
 962         Q_EMIT error(i18n("Akonadi database file could not be found in the archive."));
 963     } else {
 964         Q_EMIT info(i18n("Restore Akonadi Database..."));
 965
 966         const KArchiveEntry *akonadiDataBaseEntry = mArchiveDirectory->entry(akonadiDbPath);
 967         if (akonadiDataBaseEntry && akonadiDataBaseEntry->isFile()) {
 968
 969             const KArchiveFile *akonadiDataBaseFile = static_cast<const KArchiveFile *>(akonadiDataBaseEntry);
 970
 971             QTemporaryFile tmp;
 972             tmp.open();
 973
 974             akonadiDataBaseFile->copyTo(tmp.fileName());
 975
 976             /* Restore the database */
 977             AkonadiDataBase akonadiDataBase;
 978
 979             const QString dbDriver(akonadiDataBase.driver());
 980             QStringList params;
 981             QString dbRestoreAppName;
 982             if (dbDriver == QLatin1String("QPSQL")) {
 983                 dbRestoreAppName = QStringLiteral("pg_restore");
 984                 params << akonadiDataBase.options()
 985                        << QStringLiteral("--dbname=") + akonadiDataBase.name()
 986                        << QStringLiteral("--format=custom")
 987                        << QStringLiteral("--clean")
 988                        << QStringLiteral("--no-owner")
 989                        << QStringLiteral("--no-privileges")
 990                        << tmp.fileName();
 991             } else if (dbDriver == QLatin1String("QMYSQL")) {
 992                 dbRestoreAppName = QStringLiteral("mysql");
 993                 params << akonadiDataBase.options()
 994                        << QStringLiteral("--database=") + akonadiDataBase.name();
 995             } else {
 996                 Q_EMIT error(i18n("Database driver \"%1\" not supported.", dbDriver));
 997                 slotNextStep();
 998                 return;
 999             }
1000
1001             const QString dbRestoreApp = QStandardPaths::findExecutable(dbRestoreAppName);
1002
1003             if (dbRestoreApp.isEmpty()) {
1004                 Q_EMIT error(i18n("Could not find \"%1\" necessary to restore database.", dbRestoreAppName));
1005                 slotNextStep();
1006                 return;
1007             }
1008             KProcess *proc = new KProcess(this);
1009             proc->setProgram(QStandardPaths::findExecutable(dbRestoreApp), params);
1010             proc->setStandardInputFile(tmp.fileName());
1011             const int result = proc->execute();
1012             delete proc;
1013             if (result != 0) {
1014                 Q_EMIT error(i18n("Failed to restore Akonadi Database."));
1015                 slotNextStep();
1016                 return;
1017             }
1018         }
1019         Q_EMIT info(i18n("Akonadi Database restored."));
1020     }
1021     slotNextStep();
1022 }
1023
1024 void ImportMailJob::importArchiveConfig(const KArchiveFile *archiveconfiguration, const QString &archiveconfigurationrc, const QString &filename, const QString &prefix)
1025 {
1026     copyToFile(archiveconfiguration, archiveconfigurationrc, filename, prefix);
1027     KSharedConfig::Ptr archiveConfig = KSharedConfig::openConfig(archiveconfigurationrc);
1028
1029     copyArchiveMailAgentConfigGroup(archiveConfig, archiveConfig);
1030     archiveConfig->sync();
1031 }
1032
1033 void ImportMailJob::importFolderArchiveConfig(const KArchiveFile *archiveconfiguration, const QString &archiveconfigurationrc, const QString &filename, const QString &prefix)
1034 {
1035     copyToFile(archiveconfiguration, archiveconfigurationrc, filename, prefix);
1036     KSharedConfig::Ptr archiveConfig = KSharedConfig::openConfig(archiveconfigurationrc);
1037
1038     const QStringList archiveList = archiveConfig->groupList().filter(QRegularExpression(QLatin1String("FolderArchiveAccount ")));
1039
1040     Q_FOREACH (const QString &str, archiveList) {
1041         KConfigGroup oldGroup = archiveConfig->group(str);
1042         const Akonadi::Collection::Id id = convertPathToId(oldGroup.readEntry(QStringLiteral("topLevelCollectionId")));
1043         if (id != -1) {
1044             oldGroup.writeEntry(QStringLiteral("topLevelCollectionId"), id);
1045         }
1046     }
1047
1048     archiveConfig->sync();
1049 }
1050
1051 void ImportMailJob::copyArchiveMailAgentConfigGroup(KSharedConfig::Ptr archiveConfigOrigin, KSharedConfig::Ptr archiveConfigDestination)
1052 {
1053     //adapt id
1054     const QString archiveGroupPattern = QStringLiteral("ArchiveMailCollection ");
1055     const QStringList archiveList = archiveConfigOrigin->groupList().filter(archiveGroupPattern);
1056     Q_FOREACH (const QString &str, archiveList) {
1057         const QString path = str.right(str.length() - archiveGroupPattern.length());
1058         if (!path.isEmpty()) {
1059             KConfigGroup oldGroup = archiveConfigOrigin->group(str);
1060             const Akonadi::Collection::Id id = convertPathToId(path);
1061             if (id != -1) {
1062                 KConfigGroup newGroup(archiveConfigDestination, archiveGroupPattern + QString::number(id));
1063                 oldGroup.copyTo(&newGroup);
1064                 newGroup.writeEntry(QStringLiteral("saveCollectionId"), id);
1065                 QUrl path = newGroup.readEntry("storePath", QUrl());
1066                 if (!QDir(path.path()).exists()) {
1067                     newGroup.writeEntry(QStringLiteral("storePath"), QUrl::fromLocalFile(QDir::homePath()));
1068                 }
1069             }
1070             oldGroup.deleteGroup();
1071         }
1072     }
1073 }
1074
1075 void ImportMailJob::importTemplatesConfig(const KArchiveFile *templatesconfiguration, const QString &templatesconfigurationrc, const QString &filename, const QString &prefix)
1076 {
1077     copyToFile(templatesconfiguration, templatesconfigurationrc, filename, prefix);
1078     KSharedConfig::Ptr templateConfig = KSharedConfig::openConfig(templatesconfigurationrc);
1079
1080     //adapt id
1081     const QString templateGroupPattern = QStringLiteral("Templates #");
1082     const QStringList templateList = templateConfig->groupList().filter(templateGroupPattern);
1083     Q_FOREACH (const QString &str, templateList) {
1084         const QString path = str.right(str.length() - templateGroupPattern.length());
1085         if (!path.isEmpty()) {
1086             KConfigGroup oldGroup = templateConfig->group(str);
1087             const Akonadi::Collection::Id id = convertPathToId(path);
1088             if (id != -1) {
1089                 KConfigGroup newGroup(templateConfig, templateGroupPattern + QString::number(id));
1090                 oldGroup.copyTo(&newGroup);
1091             }
1092             oldGroup.deleteGroup();
1093         }
1094     }
1095     //adapt identity
1096     const QString templateGroupIdentityPattern = QStringLiteral("Templates #IDENTITY_");
1097     const QStringList templateListIdentity = templateConfig->groupList().filter(templateGroupIdentityPattern);
1098     Q_FOREACH (const QString &str, templateListIdentity) {
1099         bool found = false;
1100         const int identity = str.rightRef(str.length() - templateGroupIdentityPattern.length()).toInt(&found);
1101         if (found) {
1102             KConfigGroup oldGroup = templateConfig->group(str);
1103             if (mHashIdentity.contains(identity)) {
1104                 KConfigGroup newGroup(templateConfig, templateGroupPattern + QString::number(mHashIdentity.value(identity)));
1105                 oldGroup.copyTo(&newGroup);
1106             }
1107             oldGroup.deleteGroup();
1108         }
1109     }
1110     templateConfig->sync();
1111 }
1112
1113 void ImportMailJob::importKmailConfig(const KArchiveFile *kmailsnippet, const QString &kmail2rc, const QString &filename, const QString &prefix)
1114 {
1115     copyToFile(kmailsnippet, kmail2rc, filename, prefix);
1116     KSharedConfig::Ptr kmailConfig = KSharedConfig::openConfig(kmail2rc);
1117
1118     //Be sure to delete Search group
1119     const QString search(QStringLiteral("Search"));
1120     if (kmailConfig->hasGroup(search)) {
1121         KConfigGroup searchGroup = kmailConfig->group(search);
1122         searchGroup.deleteGroup();
1123     }
1124
1125     //adapt folder id
1126     const QString folderGroupPattern = QStringLiteral("Folder-");
1127     const QStringList folderList = kmailConfig->groupList().filter(folderGroupPattern);
1128     Q_FOREACH (const QString &str, folderList) {
1129         const QString path = str.right(str.length() - folderGroupPattern.length());
1130         if (!path.isEmpty()) {
1131             KConfigGroup oldGroup = kmailConfig->group(str);
1132             const Akonadi::Collection::Id id = convertPathToId(path);
1133             if (id != -1) {
1134                 KConfigGroup newGroup(kmailConfig, folderGroupPattern + QString::number(id));
1135                 oldGroup.copyTo(&newGroup);
1136             }
1137             oldGroup.deleteGroup();
1138         }
1139     }
1140     const QString accountOrder(QStringLiteral("AccountOrder"));
1141     if (kmailConfig->hasGroup(accountOrder)) {
1142         KConfigGroup group = kmailConfig->group(accountOrder);
1143         QStringList orderList = group.readEntry(QStringLiteral("order"), QStringList());
1144         QStringList newOrderList;
1145         if (!orderList.isEmpty()) {
1146             Q_FOREACH (const QString &account, orderList) {
1147                 if (mHashResources.contains(account)) {
1148                     newOrderList.append(mHashResources.value(account));
1149                 } else {
1150                     newOrderList.append(account);
1151                 }
1152             }
1153         }
1154     }
1155
1156     const QString composerStr(QStringLiteral("Composer"));
1157     if (kmailConfig->hasGroup(composerStr)) {
1158         KConfigGroup composerGroup = kmailConfig->group(composerStr);
1159         const QString previousStr(QStringLiteral("previous-fcc"));
1160         convertRealPathToCollection(composerGroup, previousStr);
1161
1162         const QString previousIdentityStr(QStringLiteral("previous-identity"));
1163         if (composerGroup.hasKey(previousIdentityStr)) {
1164             const int identityValue = composerGroup.readEntry(previousIdentityStr, -1);
1165             if (identityValue != -1) {
1166                 if (mHashIdentity.contains(identityValue)) {
1167                     composerGroup.writeEntry(previousIdentityStr, mHashIdentity.value(identityValue));
1168                 } else {
1169                     composerGroup.writeEntry(previousIdentityStr, identityValue);
1170                 }
1171             }
1172         }
1173     }
1174
1175     const QString collectionFolderViewStr(QStringLiteral("CollectionFolderView"));
1176     if (kmailConfig->hasGroup(collectionFolderViewStr)) {
1177         KConfigGroup favoriteGroup = kmailConfig->group(collectionFolderViewStr);
1178         const QString currentKey(QStringLiteral("Current"));
1179         convertRealPathToCollection(favoriteGroup, currentKey, true);
1180
1181         const QString expensionKey(QStringLiteral("Expansion"));
1182         convertRealPathToCollectionList(favoriteGroup, expensionKey);
1183     }
1184
1185     const QString generalStr(QStringLiteral("General"));
1186     if (kmailConfig->hasGroup(generalStr)) {
1187         KConfigGroup generalGroup = kmailConfig->group(generalStr);
1188         //Be sure to delete default domain
1189         const QString defaultDomainStr(QStringLiteral("Default domain"));
1190         if (generalGroup.hasKey(defaultDomainStr)) {
1191             generalGroup.deleteEntry(defaultDomainStr);
1192         }
1193
1194         const QString startupFolderStr(QStringLiteral("startupFolder"));
1195         convertRealPathToCollection(generalGroup, startupFolderStr);
1196     }
1197
1198     const QString resourceGroupPattern = QStringLiteral("Resource ");
1199     const QStringList resourceList = kmailConfig->groupList().filter(resourceGroupPattern);
1200     Q_FOREACH (const QString &str, resourceList) {
1201         const QString res = str.right(str.length() - resourceGroupPattern.length());
1202         if (!res.isEmpty()) {
1203             KConfigGroup oldGroup = kmailConfig->group(str);
1204             if (mHashResources.contains(res)) {
1205                 KConfigGroup newGroup(kmailConfig, folderGroupPattern + mHashResources.value(res));
1206                 oldGroup.copyTo(&newGroup);
1207             }
1208             oldGroup.deleteGroup();
1209         }
1210     }
1211
1212     kmailConfig->sync();
1213 }
1214
1215 void ImportMailJob::mergeLdapConfig(const KArchiveFile *archivefile, const QString &filename, const QString &prefix)
1216 {
1217     QDir dir(mTempDirName);
1218     dir.mkdir(prefix);
1219
1220     const QString copyToDirName(mTempDirName + QLatin1Char('/') + prefix);
1221     archivefile->copyTo(copyToDirName);
1222
1223     KSharedConfig::Ptr existingConfig = KSharedConfig::openConfig(filename);
1224     KConfigGroup grpExisting = existingConfig->group(QStringLiteral("LDAP"));
1225     int existingNumberHosts = grpExisting.readEntry(QStringLiteral("NumHosts"), 0);
1226     int existingNumberSelectedHosts = grpExisting.readEntry(QStringLiteral("NumSelectedHosts"), 0);
1227
1228     KSharedConfig::Ptr importingLdapConfig = KSharedConfig::openConfig(copyToDirName + QLatin1Char('/') + filename);
1229     KConfigGroup grpImporting = importingLdapConfig->group(QStringLiteral("LDAP"));
1230     int importingNumberHosts = grpImporting.readEntry(QStringLiteral("NumHosts"), 0);
1231     int importingNumberSelectedHosts = grpImporting.readEntry(QStringLiteral("NumSelectedHosts"), 0);
1232
1233     grpExisting.writeEntry(QStringLiteral("NumHosts"), (existingNumberHosts + importingNumberHosts));
1234     grpExisting.writeEntry(QStringLiteral("NumSelectedHosts"), (existingNumberSelectedHosts + importingNumberSelectedHosts));
1235
1236     for (int i = 0; i < importingNumberSelectedHosts; ++i) {
1237         const QString auth = grpImporting.readEntry(QStringLiteral("SelectedAuth%1").arg(i), QString());
1238         grpExisting.writeEntry(QStringLiteral("SelectedAuth%1").arg(existingNumberSelectedHosts + i + 1), auth);
1239         grpExisting.writeEntry(QStringLiteral("SelectedBase%1").arg(existingNumberSelectedHosts + i + 1), grpImporting.readEntry(QStringLiteral("SelectedBase%1").arg(i), QString()));
1240         grpExisting.writeEntry(QStringLiteral("SelectedBind%1").arg(existingNumberSelectedHosts + i + 1), grpImporting.readEntry(QStringLiteral("SelectedBind%1").arg(i), QString()));
1241         grpExisting.writeEntry(QStringLiteral("SelectedHost%1").arg(existingNumberSelectedHosts + i + 1), grpImporting.readEntry(QStringLiteral("SelectedHost%1").arg(i), QString()));
1242         grpExisting.writeEntry(QStringLiteral("SelectedMech%1").arg(existingNumberSelectedHosts + i + 1), grpImporting.readEntry(QStringLiteral("SelectedMech%1").arg(i), QString()));
1243         grpExisting.writeEntry(QStringLiteral("SelectedPageSize%1").arg(existingNumberSelectedHosts + i + 1), grpImporting.readEntry(QStringLiteral("SelectedPageSize%1").arg(i), 0));
1244         grpExisting.writeEntry(QStringLiteral("SelectedPort%1").arg(existingNumberSelectedHosts + i + 1), grpImporting.readEntry(QStringLiteral("SelectedPort%1").arg(i), 0));
1245         grpExisting.writeEntry(QStringLiteral("SelectedPwdBind%1").arg(existingNumberSelectedHosts + i + 1), grpImporting.readEntry(QStringLiteral("SelectedPwdBind%1").arg(i), QString()));
1246         grpExisting.writeEntry(QStringLiteral("SelectedSecurity%1").arg(existingNumberSelectedHosts + i + 1), grpImporting.readEntry(QStringLiteral("SelectedSecurity%1").arg(i), QString()));
1247         grpExisting.writeEntry(QStringLiteral("SelectedSizeLimit%1").arg(existingNumberSelectedHosts + i + 1), grpImporting.readEntry(QStringLiteral("SelectedSizeLimit%1").arg(i), 0));
1248         grpExisting.writeEntry(QStringLiteral("SelectedTimeLimit%1").arg(existingNumberSelectedHosts + i + 1), grpImporting.readEntry(QStringLiteral("SelectedTimeLimit%1").arg(i), 0));
1249         grpExisting.writeEntry(QStringLiteral("SelectedUser%1").arg(existingNumberSelectedHosts + i + 1), grpImporting.readEntry(QStringLiteral("SelectedUser%1").arg(i), QString()));
1250         grpExisting.writeEntry(QStringLiteral("SelectedVersion%1").arg(existingNumberSelectedHosts + i + 1), grpImporting.readEntry(QStringLiteral("SelectedVersion%1").arg(i), 0));
1251         grpExisting.writeEntry(QStringLiteral("SelectedUserFilter%1").arg(existingNumberSelectedHosts + i + 1), grpImporting.readEntry(QStringLiteral("SelectedUserFilter%1").arg(i), 0));
1252     }
1253
1254     for (int i = 0; i < importingNumberHosts; ++i) {
1255         grpExisting.writeEntry(QStringLiteral("Auth%1").arg(existingNumberHosts + i + 1), grpImporting.readEntry(QStringLiteral("Auth%1").arg(i), QString()));
1256         grpExisting.writeEntry(QStringLiteral("Base%1").arg(existingNumberHosts + i + 1), grpImporting.readEntry(QStringLiteral("Base%1").arg(i), QString()));
1257         grpExisting.writeEntry(QStringLiteral("Bind%1").arg(existingNumberHosts + i + 1), grpImporting.readEntry(QStringLiteral("Bind%1").arg(i), QString()));
1258         grpExisting.writeEntry(QStringLiteral("Host%1").arg(existingNumberHosts + i + 1), grpImporting.readEntry(QStringLiteral("Host%1").arg(i), QString()));
1259         grpExisting.writeEntry(QStringLiteral("Mech%1").arg(existingNumberHosts + i + 1), grpImporting.readEntry(QStringLiteral("Mech%1").arg(i), QString()));
1260         grpExisting.writeEntry(QStringLiteral("PageSize%1").arg(existingNumberHosts + i + 1), grpImporting.readEntry(QStringLiteral("PageSize%1").arg(i), 0));
1261         grpExisting.writeEntry(QStringLiteral("Port%1").arg(existingNumberHosts + i + 1), grpImporting.readEntry(QStringLiteral("Port%1").arg(i), 0));
1262         grpExisting.writeEntry(QStringLiteral("PwdBind%1").arg(existingNumberHosts + i + 1), grpImporting.readEntry(QStringLiteral("PwdBind%1").arg(i), QString()));
1263         grpExisting.writeEntry(QStringLiteral("Security%1").arg(existingNumberHosts + i + 1), grpImporting.readEntry(QStringLiteral("Security%1").arg(i), QString()));
1264         grpExisting.writeEntry(QStringLiteral("SizeLimit%1").arg(existingNumberHosts + i + 1), grpImporting.readEntry(QStringLiteral("SizeLimit%1").arg(i), 0));
1265         grpExisting.writeEntry(QStringLiteral("TimeLimit%1").arg(existingNumberHosts + i + 1), grpImporting.readEntry(QStringLiteral("TimeLimit%1").arg(i), 0));
1266         grpExisting.writeEntry(QStringLiteral("User%1").arg(existingNumberHosts + i + 1), grpImporting.readEntry(QStringLiteral("User%1").arg(i), QString()));
1267         grpExisting.writeEntry(QStringLiteral("Version%1").arg(existingNumberHosts + i + 1), grpImporting.readEntry(QStringLiteral("Version%1").arg(i), 0));
1268         grpExisting.writeEntry(QStringLiteral("UserFilter%1").arg(existingNumberSelectedHosts + i + 1), grpImporting.readEntry(QStringLiteral("UserFilter%1").arg(i), 0));
1269     }
1270
1271     grpExisting.sync();
1272 }
1273
1274 void ImportMailJob::mergeKmailSnippetConfig(const KArchiveFile *archivefile, const QString &filename, const QString &prefix)
1275 {
1276     //TODO
1277     QDir dir(mTempDirName);
1278     dir.mkdir(prefix);
1279
1280     const QString copyToDirName(mTempDirName + QLatin1Char('/') + prefix);
1281     archivefile->copyTo(copyToDirName);
1282
1283     KSharedConfig::Ptr existingConfig = KSharedConfig::openConfig(filename);
1284
1285     KSharedConfig::Ptr importingKMailSnipperConfig = KSharedConfig::openConfig(copyToDirName + QLatin1Char('/') + filename);
1286 }
1287
1288 void ImportMailJob::mergeArchiveMailAgentConfig(const KArchiveFile *archivefile, const QString &filename, const QString &prefix)
1289 {
1290     QDir dir(mTempDirName);
1291     dir.mkdir(prefix);
1292
1293     const QString copyToDirName(mTempDirName + QLatin1Char('/') + prefix);
1294     archivefile->copyTo(copyToDirName);
1295
1296     KSharedConfig::Ptr existingConfig = KSharedConfig::openConfig(filename);
1297
1298     KSharedConfig::Ptr importingArchiveMailAgentConfig = KSharedConfig::openConfig(copyToDirName + QLatin1Char('/') + filename);
1299
1300     copyArchiveMailAgentConfigGroup(importingArchiveMailAgentConfig, existingConfig);
1301     existingConfig->sync();
1302 }
1303
1304 void ImportMailJob::mergeSieveTemplate(const KArchiveFile *archivefile, const QString &filename, const QString &prefix)
1305 {
1306     QDir dir(mTempDirName);
1307     dir.mkdir(prefix);
1308
1309     const QString copyToDirName(mTempDirName + QLatin1Char('/') + prefix);
1310     archivefile->copyTo(copyToDirName);
1311
1312     KSharedConfig::Ptr existingConfig = KSharedConfig::openConfig(filename);
1313
1314     KSharedConfig::Ptr importingSieveTemplateConfig = KSharedConfig::openConfig(copyToDirName + QLatin1Char('/') + filename);
1315
1316     KConfigGroup grpExisting = existingConfig->group(QStringLiteral("template"));
1317     int numberOfExistingTemplate = grpExisting.readEntry(QStringLiteral("templateCount"), 0);
1318
1319     KConfigGroup grpImportExisting = importingSieveTemplateConfig->group(QStringLiteral("template"));
1320     const int numberOfImportingTemplate = grpImportExisting.readEntry(QStringLiteral("templateCount"), 0);
1321
1322     for (int i = 0; i < numberOfImportingTemplate; ++i) {
1323         KConfigGroup templateDefine = importingSieveTemplateConfig->group(QStringLiteral("templateDefine_%1").arg(i));
1324
1325         KConfigGroup newTemplateDefineGrp = existingConfig->group(QStringLiteral("templateDefine_%1").arg(numberOfExistingTemplate));
1326         newTemplateDefineGrp.writeEntry(QStringLiteral("Name"), templateDefine.readEntry(QStringLiteral("Name")));
1327         newTemplateDefineGrp.writeEntry(QStringLiteral("Text"), templateDefine.readEntry(QStringLiteral("Text")));
1328         ++numberOfExistingTemplate;
1329         newTemplateDefineGrp.sync();
1330     }
1331     grpExisting.writeEntry(QStringLiteral("templateCount"), numberOfExistingTemplate);
1332     grpExisting.sync();
1333 }