← Back to branch summary

~ubuntu-branches/ubuntu/vivid/kdepim/vivid

« back to all changes in this revision

Viewing changes to backupmail/importmailjob.cpp

  • Committer: Package Import Robot
  • Author(s): Scott Kitterman, Jonathan Riddell, Rohan Garg, Scott Kitterman
  • Date: 2012-11-21 13:12:36 UTC
  • mfrom: (0.2.33)
  • Revision ID: package-import@ubuntu.com-20121121131236-32ijw9a2txrar80k
Tags: 4:4.9.80-0ubuntu1
[ Jonathan Riddell ]
* New upstream beta release

[ Rohan Garg ]
* Add nepomuk-core-dev to build-deps

[ Scott Kitterman ]
* Add new package, libpimcommon4
  - Add libpimcommon4.install
  - Add to debian/control, including kdepim-dbg and kdepim-dev depends
  - Add to kdepim-dev.install
* Remove usr/bin/backupmail and related files from kmail.install as they are
  not provided by upstream anymore
* Add usr/bin/pimsettingexporter and related files to kmail.install
* Add libnepomukwidgets-dev to build-depends

Show diffs side-by-side

added added

removed removed

Lines of Context:
backupmail/importmailjob.cpp
1
 
/*
2
 
  Copyright (c) 2012 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
 
 
21
 
#include "mailcommon/filter/filtermanager.h"
22
 
#include "mailcommon/filter/filterimporterexporter.h"
23
 
#include "mailcommon/mailutil.h"
24
 
#include "mailcommon/createresource.h"
25
 
 
26
 
#include "messageviewer/kcursorsaver.h"
27
 
 
28
 
 
29
 
#include <mailtransport/transportmanager.h>
30
 
 
31
 
#include <kpimidentities/identitymanager.h>
32
 
#include <kpimidentities/identity.h>
33
 
#include <KZip>
34
 
#include <KStandardDirs>
35
 
#include <KLocale>
36
 
#include <KProcess>
37
 
#include <KTempDir>
38
 
#include <KTemporaryFile>
39
 
#include <KSharedConfig>
40
 
#include <KConfigGroup>
41
 
#include <KMessageBox>
42
 
 
43
 
#include <akonadi/agenttype.h>
44
 
#include <akonadi/agentmanager.h>
45
 
#include <akonadi/agentinstancecreatejob.h>
46
 
 
47
 
#include <QDBusReply>
48
 
#include <QDBusInterface>
49
 
#include <QMetaMethod>
50
 
#include <QDir>
51
 
 
52
 
using namespace Akonadi;
53
 
 
54
 
static const QString storeMails = QLatin1String("backupmail/");
55
 
 
56
 
ImportMailJob::ImportMailJob(QWidget *parent, BackupMailUtil::BackupTypes typeSelected,const QString& filename, int numberOfStep)
57
 
  :AbstractImportExportJob(parent,filename,typeSelected,numberOfStep), mArchiveDirectory(0)
58
 
{
59
 
  mTempDir = new KTempDir();
60
 
  mTempDirName = mTempDir->name();
61
 
  mCreateResource = new MailCommon::CreateResource();
62
 
  connect(mCreateResource,SIGNAL(createResourceInfo(QString)),SIGNAL(info(QString)));
63
 
  connect(mCreateResource,SIGNAL(createResourceError(QString)),SIGNAL(error(QString)));
64
 
}
65
 
 
66
 
ImportMailJob::~ImportMailJob()
67
 
{
68
 
  delete mTempDir;
69
 
  delete mCreateResource;
70
 
}
71
 
 
72
 
void ImportMailJob::start()
73
 
{
74
 
  startRestore();
75
 
}
76
 
 
77
 
void ImportMailJob::startRestore()
78
 
{
79
 
  if(!openArchive(false /*readonly*/))
80
 
    return;
81
 
  mArchiveDirectory = mArchive->directory();
82
 
  searchAllFiles(mArchiveDirectory,QString());
83
 
  if(!mFileList.isEmpty()|| !mHashMailArchive.isEmpty()) {
84
 
    if(mTypeSelected & BackupMailUtil::MailTransport)
85
 
      restoreTransports();
86
 
    if(mTypeSelected & BackupMailUtil::Resources)
87
 
      restoreResources();
88
 
    if(mTypeSelected & BackupMailUtil::Mails)
89
 
      restoreMails();
90
 
    if(mTypeSelected & BackupMailUtil::Identity)
91
 
      restoreIdentity();
92
 
    if(mTypeSelected & BackupMailUtil::Config)
93
 
      restoreConfig();
94
 
    if(mTypeSelected & BackupMailUtil::AkonadiDb)
95
 
      restoreAkonadiDb();
96
 
    if(mTypeSelected & BackupMailUtil::Nepomuk)
97
 
      restoreNepomuk();
98
 
  }
99
 
  closeArchive();
100
 
}
101
 
 
102
 
void ImportMailJob::searchAllFiles(const KArchiveDirectory*dir,const QString&prefix)
103
 
{
104
 
  Q_FOREACH(const QString& entryName, dir->entries()) {
105
 
    const KArchiveEntry *entry = dir->entry(entryName);
106
 
    if (entry && entry->isDirectory()) {
107
 
      const QString newPrefix = (prefix.isEmpty() ? prefix : prefix + QLatin1Char('/')) + entryName;
108
 
      if(entryName == QLatin1String("mails")) {
109
 
        storeMailArchiveResource(static_cast<const KArchiveDirectory*>(entry),entryName);
110
 
      } else {
111
 
        searchAllFiles(static_cast<const KArchiveDirectory*>(entry), newPrefix);
112
 
      }
113
 
    } else {
114
 
      QString fileName = prefix.isEmpty() ? entry->name() : prefix + QLatin1Char('/') + entry->name();
115
 
      mFileList<<fileName;
116
 
    }
117
 
  }
118
 
}
119
 
 
120
 
void ImportMailJob::storeMailArchiveResource(const KArchiveDirectory*dir, const QString& prefix)
121
 
{
122
 
  Q_FOREACH(const QString& entryName, dir->entries()) {
123
 
    const KArchiveEntry *entry = dir->entry(entryName);
124
 
    if (entry && entry->isDirectory()) {
125
 
      const KArchiveDirectory*resourceDir = static_cast<const KArchiveDirectory*>(entry);
126
 
      const QStringList lst = resourceDir->entries();
127
 
      if(lst.count() == 2) {
128
 
        const QString archPath(prefix + QLatin1Char('/') + entryName + QLatin1Char('/'));
129
 
        const QString name(lst.at(0));
130
 
        if(name.endsWith(QLatin1String("rc"))&&
131
 
           (name.contains(QLatin1String("akonadi_mbox_resource_")) ||
132
 
            name.contains(QLatin1String("akonadi_mixedmaildir_resource_")) ||
133
 
            name.contains(QLatin1String("akonadi_maildir_resource_")))) {
134
 
          mHashMailArchive.insert(archPath + name,archPath +lst.at(1));
135
 
        } else {
136
 
          mHashMailArchive.insert(archPath +lst.at(1),archPath + name);
137
 
        }
138
 
      } else {
139
 
        kDebug()<<" lst.at(0)"<<lst.at(0);
140
 
        kDebug()<<" Problem in archive. number of file "<<lst.count();
141
 
      }
142
 
    }
143
 
  }
144
 
}
145
 
 
146
 
void ImportMailJob::restoreTransports()
147
 
{
148
 
  const QString path = BackupMailUtil::transportsPath()+QLatin1String("mailtransports");
149
 
  if(!mFileList.contains(path)) {
150
 
    Q_EMIT error(i18n("mailtransports file could not be found in the archive."));
151
 
    return;
152
 
  }
153
 
  Q_EMIT info(i18n("Restore transports..."));
154
 
  MessageViewer::KCursorSaver busy( MessageViewer::KBusyPtr::busy() );
155
 
  const KArchiveEntry* transport = mArchiveDirectory->entry(path);
156
 
  if(transport && transport->isFile()) {
157
 
    const KArchiveFile* fileTransport = static_cast<const KArchiveFile*>(transport);
158
 
 
159
 
    fileTransport->copyTo(mTempDirName);
160
 
    KSharedConfig::Ptr transportConfig = KSharedConfig::openConfig(mTempDirName + QLatin1Char('/') +QLatin1String("mailtransports"));
161
 
 
162
 
    int defaultTransport = -1;
163
 
    if(transportConfig->hasGroup(QLatin1String("General"))) {
164
 
      KConfigGroup group = transportConfig->group(QLatin1String("General"));
165
 
      defaultTransport = group.readEntry(QLatin1String("default-transport"),-1);
166
 
    }
167
 
 
168
 
    const QStringList transportList = transportConfig->groupList().filter( QRegExp( "Transport \\d+" ) );
169
 
    Q_FOREACH(const QString&transport, transportList) {
170
 
      KConfigGroup group = transportConfig->group(transport);
171
 
      const int transportId = group.readEntry(QLatin1String("id"), -1);
172
 
      MailTransport::Transport* mt = MailTransport::TransportManager::self()->createTransport();
173
 
      mt->setName(group.readEntry(QLatin1String("name")));
174
 
      const QString hostStr(QLatin1String("host"));
175
 
      if(group.hasKey(hostStr)) {
176
 
        mt->setHost(group.readEntry(hostStr));
177
 
      }
178
 
      const QString portStr(QLatin1String("port"));
179
 
      if(group.hasKey(portStr)) {
180
 
        mt->setPort(group.readEntry(portStr,-1));
181
 
      }
182
 
      const QString userNameStr(QLatin1String("userName"));
183
 
      if(group.hasKey(userNameStr)) {
184
 
        mt->setUserName(group.readEntry(userNameStr));
185
 
      }
186
 
      const QString precommandStr(QLatin1String("precommand"));
187
 
      if(group.hasKey(precommandStr)) {
188
 
        mt->setPrecommand(group.readEntry(precommandStr));
189
 
      }
190
 
      const QString requiresAuthenticationStr(QLatin1String("requiresAuthentication"));
191
 
      if(group.hasKey(requiresAuthenticationStr)) {
192
 
        mt->setRequiresAuthentication(group.readEntry(requiresAuthenticationStr,false));
193
 
      }
194
 
      const QString specifyHostnameStr(QLatin1String("specifyHostname"));
195
 
      if(group.hasKey(specifyHostnameStr)) {
196
 
        mt->setSpecifyHostname(group.readEntry(specifyHostnameStr,false));
197
 
      }
198
 
      const QString localHostnameStr(QLatin1String("localHostname"));
199
 
      if(group.hasKey(localHostnameStr)) {
200
 
        mt->setLocalHostname(group.readEntry(localHostnameStr));
201
 
      }
202
 
      const QString specifySenderOverwriteAddressStr(QLatin1String("specifySenderOverwriteAddress"));
203
 
      if(group.hasKey(specifySenderOverwriteAddressStr)) {
204
 
        mt->setSpecifySenderOverwriteAddress(group.readEntry(specifySenderOverwriteAddressStr,false));
205
 
      }
206
 
      const QString storePasswordStr(QLatin1String("storePassword"));
207
 
      if(group.hasKey(storePasswordStr)) {
208
 
        mt->setStorePassword(group.readEntry(storePasswordStr,false));
209
 
      }
210
 
      const QString senderOverwriteAddressStr(QLatin1String("senderOverwriteAddress"));
211
 
      if(group.hasKey(senderOverwriteAddressStr)) {
212
 
        mt->setSenderOverwriteAddress(group.readEntry(senderOverwriteAddressStr));
213
 
      }
214
 
      const QString encryptionStr(QLatin1String("encryption"));
215
 
      if(group.hasKey(encryptionStr)) {
216
 
        mt->setEncryption(group.readEntry(encryptionStr,1)); //TODO verify
217
 
      }
218
 
      const QString authenticationTypeStr(QLatin1String("authenticationType"));
219
 
      if(group.hasKey(authenticationTypeStr)) {
220
 
        mt->setAuthenticationType(group.readEntry(authenticationTypeStr,1));//TODO verify
221
 
      }
222
 
 
223
 
      mt->forceUniqueName();
224
 
      mt->writeConfig();
225
 
      MailTransport::TransportManager::self()->addTransport( mt );
226
 
      if ( transportId == defaultTransport )
227
 
        MailTransport::TransportManager::self()->setDefaultTransport( mt->id() );
228
 
      mHashTransport.insert(transportId, mt->id());
229
 
    }
230
 
    Q_EMIT info(i18n("Transports restored."));
231
 
  } else {
232
 
    Q_EMIT error(i18n("Failed to restore transports file."));
233
 
  }
234
 
}
235
 
 
236
 
void ImportMailJob::restoreResources()
237
 
{
238
 
  MessageViewer::KCursorSaver busy( MessageViewer::KBusyPtr::busy() );
239
 
  Q_FOREACH(const QString& filename, mFileList) {
240
 
    if(filename.startsWith(BackupMailUtil::resourcesPath())) {
241
 
      const KArchiveEntry* fileEntry = mArchiveDirectory->entry(filename);
242
 
      if(fileEntry && fileEntry->isFile()) {
243
 
        const KArchiveFile* file = static_cast<const KArchiveFile*>(fileEntry);
244
 
        KTemporaryFile tmp;
245
 
        tmp.open();
246
 
        file->copyTo(tmp.fileName());
247
 
        KSharedConfig::Ptr resourceConfig = KSharedConfig::openConfig(tmp.fileName());
248
 
        const QString filename(file->name());
249
 
        QMap<QString, QVariant> settings;
250
 
        if(filename.contains(QLatin1String("pop3"))) {
251
 
          KConfigGroup general = resourceConfig->group(QLatin1String("General"));
252
 
          if(general.hasKey(QLatin1String("login"))) {
253
 
            settings.insert(QLatin1String("Login"),general.readEntry("login"));
254
 
          }
255
 
          if(general.hasKey(QLatin1String("host"))) {
256
 
            settings.insert(QLatin1String("Host"),general.readEntry("host"));
257
 
          }
258
 
          if(general.hasKey(QLatin1String("port"))) {
259
 
            settings.insert(QLatin1String("Port"),general.readEntry("port",110));
260
 
          }
261
 
          if(general.hasKey(QLatin1String("authenticationMethod"))) {
262
 
            settings.insert(QLatin1String("AuthenticationMethod"),general.readEntry("authenticationMethod",7));
263
 
          }
264
 
          if(general.hasKey(QLatin1String("useSSL"))) {
265
 
            settings.insert(QLatin1String("UseSSL"),general.readEntry("useSSL",false));
266
 
          }
267
 
          if(general.hasKey(QLatin1String("useTLS"))) {
268
 
            settings.insert(QLatin1String("UseTLS"),general.readEntry("useTLS",false));
269
 
          }
270
 
          if(general.hasKey(QLatin1String("pipelining"))) {
271
 
            settings.insert(QLatin1String("Pipelining"),general.readEntry("pipelining",false));
272
 
          }
273
 
          if(general.hasKey(QLatin1String("leaveOnServer"))) {
274
 
            settings.insert(QLatin1String("LeaveOnServer"),general.readEntry("leaveOnServer",false));
275
 
          }
276
 
          if(general.hasKey(QLatin1String("leaveOnServerDays"))) {
277
 
            settings.insert(QLatin1String("LeaveOnServerDays"),general.readEntry("leaveOnServerDays",-1));
278
 
          }
279
 
          if(general.hasKey(QLatin1String("leaveOnServerCount"))) {
280
 
            settings.insert(QLatin1String("LeaveOnServerCount"),general.readEntry("leaveOnServerCount",-1));
281
 
          }
282
 
          if(general.hasKey(QLatin1String("leaveOnServerSize"))) {
283
 
            settings.insert(QLatin1String("LeaveOnServerSize"),general.readEntry("leaveOnServerSize",-1));
284
 
          }
285
 
          if(general.hasKey(QLatin1String("filterOnServer"))) {
286
 
            settings.insert(QLatin1String("FilterOnServer"),general.readEntry("filterOnServer",false));
287
 
          }
288
 
          if(general.hasKey(QLatin1String("filterCheckSize"))) {
289
 
            settings.insert(QLatin1String("FilterCheckSize"),general.readEntry("filterCheckSize"));
290
 
          }
291
 
          if(general.hasKey(QLatin1String("targetCollection"))) {
292
 
            const Akonadi::Collection::Id collection = convertPathToId(general.readEntry("targetCollection"));
293
 
            if(collection != -1) {
294
 
              settings.insert(QLatin1String("TargetCollection"),collection);
295
 
            }
296
 
          }
297
 
          if(general.hasKey(QLatin1String("precommand"))) {
298
 
            settings.insert(QLatin1String("Precommand"),general.readEntry("precommand"));
299
 
          }
300
 
          if(general.hasKey(QLatin1String("intervalCheckEnabled"))) {
301
 
            settings.insert(QLatin1String("IntervalCheckEnabled"),general.readEntry("intervalCheckEnabled",false));
302
 
          }
303
 
          if(general.hasKey(QLatin1String("intervalCheckInterval"))) {
304
 
            settings.insert(QLatin1String("IntervalCheckInterval"),general.readEntry("intervalCheckInterval",5));
305
 
          }
306
 
 
307
 
          KConfigGroup leaveOnserver = resourceConfig->group(QLatin1String("LeaveOnServer"));
308
 
 
309
 
          if(leaveOnserver.hasKey(QLatin1String("seenUidList"))) {
310
 
            settings.insert(QLatin1String("SeenUidList"),leaveOnserver.readEntry("seenUidList",QStringList()));
311
 
          }
312
 
          if(leaveOnserver.hasKey(QLatin1String("seenUidTimeList"))) {
313
 
            //FIXME
314
 
            //settings.insert(QLatin1String("SeenUidTimeList"),QVariant::fromValue<QList<int> >(leaveOnserver.readEntry("seenUidTimeList",QList<int>())));
315
 
          }
316
 
          if(leaveOnserver.hasKey(QLatin1String("downloadLater"))) {
317
 
            settings.insert(QLatin1String("DownloadLater"),leaveOnserver.readEntry("downloadLater",QStringList()));
318
 
          }
319
 
          const QString newResource = mCreateResource->createResource( QString::fromLatin1("akonadi_imap_resource"), filename, settings );
320
 
          if(!newResource.isEmpty())
321
 
            mHashResources.insert(filename,newResource);
322
 
        } else if(filename.contains(QLatin1String("imap"))) {
323
 
          KConfigGroup network = resourceConfig->group(QLatin1String("network"));
324
 
          if(network.hasKey(QLatin1String("Authentication"))) {
325
 
            settings.insert(QLatin1String("Authentication"),network.readEntry("Authentication",1));
326
 
          }
327
 
          if(network.hasKey(QLatin1String("ImapPort"))) {
328
 
            settings.insert(QLatin1String("ImapPort"),network.readEntry("ImapPort",993));
329
 
          }
330
 
          if(network.hasKey(QLatin1String("ImapServer"))) {
331
 
            settings.insert(QLatin1String("ImapServer"),network.readEntry("ImapServer"));
332
 
          }
333
 
          if(network.hasKey(QLatin1String("Safety"))) {
334
 
            settings.insert(QLatin1String("Safety"),network.readEntry("Safety","SSL"));
335
 
          }
336
 
          if(network.hasKey(QLatin1String("SubscriptionEnabled"))) {
337
 
            settings.insert(QLatin1String("SubscriptionEnabled"),network.readEntry("SubscriptionEnabled",false));
338
 
          }
339
 
          if(network.hasKey(QLatin1String("UserName"))) {
340
 
            settings.insert(QLatin1String("UserName"),network.readEntry("UserName"));
341
 
          }
342
 
 
343
 
          if(network.hasKey(QLatin1String("SessionTimeout"))) {
344
 
            settings.insert(QLatin1String("SessionTimeout"),network.readEntry("SessionTimeout",30));
345
 
          }
346
 
 
347
 
          KConfigGroup cache = resourceConfig->group(QLatin1String("cache"));
348
 
 
349
 
          if(cache.hasKey(QLatin1String("AccountIdentity"))) {
350
 
            const int identity = cache.readEntry("AccountIdentity",-1);
351
 
            if(identity!=-1) {
352
 
              if(mHashIdentity.contains(identity)) {
353
 
                settings.insert(QLatin1String("AccountIdentity"),mHashIdentity.value(identity));
354
 
              } else {
355
 
                settings.insert(QLatin1String("AccountIdentity"),identity);
356
 
              }
357
 
            }
358
 
          }
359
 
          if(cache.hasKey(QLatin1String("IntervalCheckEnabled"))) {
360
 
            settings.insert(QLatin1String("IntervalCheckEnabled"),cache.readEntry("IntervalCheckEnabled",true));
361
 
          }
362
 
          if(cache.hasKey(QLatin1String("RetrieveMetadataOnFolderListing"))) {
363
 
            settings.insert(QLatin1String("RetrieveMetadataOnFolderListing"),cache.readEntry("RetrieveMetadataOnFolderListing",true));
364
 
          }
365
 
          if(cache.hasKey(QLatin1String("AutomaticExpungeEnabled"))) {
366
 
            settings.insert(QLatin1String("AutomaticExpungeEnabled"),cache.readEntry("AutomaticExpungeEnabled",true));
367
 
          }
368
 
          if(cache.hasKey(QLatin1String(""))) {
369
 
            settings.insert(QLatin1String(""),cache.readEntry(""));
370
 
          }
371
 
          if(cache.hasKey(QLatin1String("DisconnectedModeEnabled"))) {
372
 
            settings.insert(QLatin1String("DisconnectedModeEnabled"),cache.readEntry("DisconnectedModeEnabled",false));
373
 
          }
374
 
          if(cache.hasKey(QLatin1String("IntervalCheckTime"))) {
375
 
            settings.insert(QLatin1String("IntervalCheckTime"),cache.readEntry("IntervalCheckTime",-1));
376
 
          }
377
 
          if(cache.hasKey(QLatin1String("UseDefaultIdentity"))) {
378
 
            settings.insert(QLatin1String("UseDefaultIdentity"),cache.readEntry("UseDefaultIdentity",true));
379
 
          }
380
 
          if(cache.hasKey(QLatin1String("TrashCollection"))) {
381
 
            const Akonadi::Collection::Id collection = convertPathToId(cache.readEntry("TrashCollection"));
382
 
            if(collection != -1) {
383
 
              settings.insert(QLatin1String("TrashCollection"),collection);
384
 
            } else {
385
 
              kDebug()<<" Use default trash folder";
386
 
            }
387
 
          }
388
 
 
389
 
 
390
 
          KConfigGroup siever = resourceConfig->group(QLatin1String("siever"));
391
 
          if(siever.hasKey(QLatin1String("SieveSupport"))) {
392
 
            settings.insert(QLatin1String("SieveSupport"),siever.readEntry("SieveSupport",false));
393
 
          }
394
 
          if(siever.hasKey(QLatin1String("SieveReuseConfig"))) {
395
 
            settings.insert(QLatin1String("SieveReuseConfig"),siever.readEntry("SieveReuseConfig",true));
396
 
          }
397
 
          if(siever.hasKey(QLatin1String("SievePort"))) {
398
 
            settings.insert(QLatin1String("SievePort"),siever.readEntry("SievePort",4190));
399
 
          }
400
 
          if(siever.hasKey(QLatin1String("SieveAlternateUrl"))) {
401
 
            settings.insert(QLatin1String("SieveAlternateUrl"),siever.readEntry("SieveAlternateUrl"));
402
 
          }
403
 
          if(siever.hasKey(QLatin1String("SieveVacationFilename"))) {
404
 
            settings.insert(QLatin1String("SieveVacationFilename"),siever.readEntry("SieveVacationFilename"));
405
 
          }
406
 
 
407
 
 
408
 
          const QString newResource = mCreateResource->createResource( QString::fromLatin1("akonadi_pop3_resource"), filename, settings );
409
 
          if(!newResource.isEmpty())
410
 
            mHashResources.insert(filename,newResource);
411
 
        } else {
412
 
          kDebug()<<" problem with resource";
413
 
        }
414
 
      }
415
 
    }
416
 
  }
417
 
}
418
 
 
419
 
void ImportMailJob::restoreMails()
420
 
{
421
 
  MessageViewer::KCursorSaver busy( MessageViewer::KBusyPtr::busy() );
422
 
  QDir dir(mTempDirName);
423
 
  dir.mkdir(BackupMailUtil::mailsPath());
424
 
  const QString copyToDirName(mTempDirName + QLatin1Char('/') + BackupMailUtil::mailsPath());
425
 
  QHashIterator<QString, QString> res(mHashMailArchive);
426
 
  while (res.hasNext()) {
427
 
    res.next();
428
 
    const QString resourceFile = res.key();
429
 
    const KArchiveEntry* fileResouceEntry = mArchiveDirectory->entry(resourceFile);
430
 
    if(fileResouceEntry && fileResouceEntry->isFile()) {
431
 
      const KArchiveFile* file = static_cast<const KArchiveFile*>(fileResouceEntry);
432
 
      file->copyTo(copyToDirName);
433
 
      const QString resourceName(file->name());
434
 
      KSharedConfig::Ptr resourceConfig = KSharedConfig::openConfig(copyToDirName + QLatin1Char('/') + resourceName);
435
 
      const KUrl url = BackupMailUtil::resourcePath(resourceConfig);
436
 
      const QString filename(file->name());
437
 
 
438
 
      KUrl newUrl = url;
439
 
      if(!url.path().contains(QDir::homePath())) {
440
 
          qDebug()<<" url "<<url.path();
441
 
          newUrl.setPath(QDir::homePath() + QLatin1Char('/') + storeMails + url.fileName());
442
 
      }
443
 
      if(QFile(newUrl.path()).exists()) {
444
 
        QString newFileName = newUrl.path();
445
 
        for(int i = 0;; ++i) {
446
 
          newFileName = newUrl.path() + QString::fromLatin1("_%1").arg(i);
447
 
          if(!QFile(newFileName).exists()) {
448
 
            break;
449
 
          }
450
 
        }
451
 
        newUrl=KUrl(newFileName);
452
 
      }
453
 
      QMap<QString, QVariant> settings;
454
 
      if(resourceName.contains(QLatin1String("akonadi_mbox_resource_"))) {
455
 
        const QString dataFile = res.value();
456
 
        const KArchiveEntry* dataResouceEntry = mArchiveDirectory->entry(dataFile);
457
 
        if(dataResouceEntry->isFile()) {
458
 
          const KArchiveFile* file = static_cast<const KArchiveFile*>(dataResouceEntry);
459
 
          file->copyTo(newUrl.path());
460
 
        }
461
 
        settings.insert(QLatin1String("Path"),newUrl.path());
462
 
 
463
 
 
464
 
        KConfigGroup general = resourceConfig->group(QLatin1String("General"));
465
 
        if(general.hasKey(QLatin1String("DisplayName"))) {
466
 
          settings.insert(QLatin1String("DisplayName"),general.readEntry(QLatin1String("DisplayName")));
467
 
        }
468
 
        if(general.hasKey(QLatin1String("ReadOnly"))) {
469
 
          settings.insert(QLatin1String("ReadOnly"),general.readEntry(QLatin1String("ReadOnly"),false));
470
 
        }
471
 
        if(general.hasKey(QLatin1String("MonitorFile"))) {
472
 
          settings.insert(QLatin1String("MonitorFile"),general.readEntry(QLatin1String("MonitorFile"),false));
473
 
        }
474
 
        if(resourceConfig->hasGroup(QLatin1String("Locking"))) {
475
 
          KConfigGroup locking = resourceConfig->group(QLatin1String("Locking"));
476
 
          if(locking.hasKey(QLatin1String("Lockfile"))) {
477
 
            settings.insert(QLatin1String("Lockfile"),locking.readEntry(QLatin1String("Lockfile")));
478
 
          }
479
 
          //TODO verify
480
 
          if(locking.hasKey(QLatin1String("LockfileMethod"))) {
481
 
            settings.insert(QLatin1String("LockfileMethod"),locking.readEntry(QLatin1String("LockfileMethod"),4));
482
 
          }
483
 
        }
484
 
        if(resourceConfig->hasGroup(QLatin1String("Compacting"))) {
485
 
          KConfigGroup compacting = resourceConfig->group(QLatin1String("Compacting"));
486
 
          if(compacting.hasKey(QLatin1String("CompactFrequency"))) {
487
 
            settings.insert(QLatin1String("CompactFrequency"),compacting.readEntry(QLatin1String("CompactFrequency"),1));
488
 
          }
489
 
          if(compacting.hasKey(QLatin1String("MessageCount"))) {
490
 
            settings.insert(QLatin1String("MessageCount"),compacting.readEntry(QLatin1String("MessageCount"),50));
491
 
          }
492
 
        }
493
 
        const QString newResource = mCreateResource->createResource( QString::fromLatin1("akonadi_mbox_resource"), filename, settings );
494
 
        if(!newResource.isEmpty())
495
 
          mHashResources.insert(filename,newResource);
496
 
      } else if(resourceName.contains(QLatin1String("akonadi_maildir_resource_")) ||
497
 
                resourceName.contains(QLatin1String("akonadi_mixedmaildir_resource_"))) {
498
 
        settings.insert(QLatin1String("Path"),newUrl.path());
499
 
        KConfigGroup general = resourceConfig->group(QLatin1String("General"));
500
 
        if(general.hasKey(QLatin1String("TopLevelIsContainer"))) {
501
 
          settings.insert(QLatin1String("TopLevelIsContainer"),general.readEntry(QLatin1String("TopLevelIsContainer"),false));
502
 
        }
503
 
        if(general.hasKey(QLatin1String("ReadOnly"))) {
504
 
          settings.insert(QLatin1String("ReadOnly"),general.readEntry(QLatin1String("ReadOnly"),false));
505
 
        }
506
 
        if(general.hasKey(QLatin1String("MonitorFilesystem"))) {
507
 
          settings.insert(QLatin1String("MonitorFilesystem"),general.readEntry(QLatin1String("MonitorFilesystem"),true));
508
 
        }
509
 
 
510
 
        const QString newResource = mCreateResource->createResource( resourceName.contains(QLatin1String("akonadi_mixedmaildir_resource_")) ?
511
 
                                                                       QString::fromLatin1("akonadi_mixedmaildir_resource")
512
 
                                                                     : QString::fromLatin1("akonadi_maildir_resource")
513
 
                                                                       , filename, settings );
514
 
        if(!newResource.isEmpty())
515
 
          mHashResources.insert(filename,newResource);
516
 
 
517
 
        const QString mailFile = res.value();
518
 
        //TODO import them
519
 
      } else {
520
 
        kDebug()<<" resource name not supported "<<resourceName;
521
 
      }
522
 
      //qDebug()<<"url "<<url;
523
 
    }
524
 
  }
525
 
}
526
 
 
527
 
void ImportMailJob::copyToFile(const KArchiveFile * archivefile, const QString& dest, const QString&filename, const QString&prefix)
528
 
{
529
 
  QDir dir(mTempDirName);
530
 
  dir.mkdir(prefix);
531
 
 
532
 
  const QString copyToDirName(mTempDirName + QLatin1Char('/') + prefix);
533
 
  archivefile->copyTo(copyToDirName);
534
 
  QFile file;
535
 
  file.setFileName(copyToDirName + QLatin1Char('/') + filename);
536
 
 
537
 
  if(!file.copy(dest)) {
538
 
    KMessageBox::error(mParent,i18n("File \"%1\" can not be copied to \"%2\".",filename,dest),i18n("Copy file"));
539
 
  }
540
 
}
541
 
 
542
 
void ImportMailJob::restoreConfig()
543
 
{
544
 
  const QString filtersPath(BackupMailUtil::configsPath() + QLatin1String("filters"));
545
 
  if(!mFileList.contains(filtersPath)) {
546
 
    Q_EMIT error(i18n("filters file could not be found in the archive."));
547
 
    return;
548
 
  }
549
 
  MessageViewer::KCursorSaver busy( MessageViewer::KBusyPtr::busy() );
550
 
  const KArchiveEntry* filter = mArchiveDirectory->entry(filtersPath);
551
 
  if(filter && filter->isFile()) {
552
 
    const KArchiveFile* fileFilter = static_cast<const KArchiveFile*>(filter);
553
 
 
554
 
    fileFilter->copyTo(mTempDirName);
555
 
    const QString filterFileName(mTempDirName + QLatin1Char('/') +QLatin1String("filters"));
556
 
    KSharedConfig::Ptr filtersConfig = KSharedConfig::openConfig(filterFileName);
557
 
    const QStringList filterList = filtersConfig->groupList().filter( QRegExp( "Filter #\\d+" ) );
558
 
    Q_FOREACH(const QString&filterStr, filterList) {
559
 
      KConfigGroup group = filtersConfig->group(filterStr);
560
 
      const QString accountStr("accounts-set");
561
 
      if(group.hasKey(accountStr)) {
562
 
        const QString accounts = group.readEntry(accountStr);
563
 
        if(!accounts.isEmpty()) {
564
 
          const QStringList lstAccounts = accounts.split(QLatin1Char(','));
565
 
          QStringList newLstAccounts;
566
 
          Q_FOREACH(const QString&acc, lstAccounts) {
567
 
            if(mHashResources.contains(acc)) {
568
 
              newLstAccounts.append(mHashResources.value(acc));
569
 
            } else {
570
 
              newLstAccounts.append(acc);
571
 
            }
572
 
          }
573
 
          group.writeEntry(accountStr,newLstAccounts);
574
 
        }
575
 
      }
576
 
      const int numActions = group.readEntry( "actions", 0 );
577
 
      QString actName;
578
 
      QString argsName;
579
 
      for ( int i=0 ; i < numActions ; ++i ) {
580
 
        actName.sprintf("action-name-%d", i);
581
 
        argsName.sprintf("action-args-%d", i);
582
 
        const QString actValue = group.readEntry(actName);
583
 
        if(actValue==QLatin1String("set identity")) {
584
 
          const int argsValue = group.readEntry(argsName,-1);
585
 
          if(argsValue!=-1) {
586
 
            if(mHashIdentity.contains(argsValue)) {
587
 
              group.writeEntry(argsName,mHashIdentity.value(argsValue));
588
 
            }
589
 
          }
590
 
        } else if(actValue==QLatin1String("set transport")) {
591
 
          const int argsValue = group.readEntry(argsName,-1);
592
 
          if(argsValue!=-1) {
593
 
            if(mHashTransport.contains(argsValue)) {
594
 
              group.writeEntry(argsName,mHashTransport.value(argsValue));
595
 
            }
596
 
          }
597
 
        }
598
 
      }
599
 
    }
600
 
    filtersConfig->sync();
601
 
 
602
 
    bool canceled = false;
603
 
    MailCommon::FilterImporterExporter exportFilters;
604
 
    QList<MailCommon::MailFilter*> lstFilter = exportFilters.importFilters(canceled, MailCommon::FilterImporterExporter::KMailFilter, filterFileName);
605
 
    if(canceled) {
606
 
      MailCommon::FilterManager::instance()->appendFilters(lstFilter);
607
 
    }
608
 
  }
609
 
  const QString kmailsnippetrcStr("kmailsnippetrc");
610
 
  const KArchiveEntry* kmailsnippetentry  = mArchiveDirectory->entry(BackupMailUtil::configsPath() + kmailsnippetrcStr);
611
 
  if(kmailsnippetentry && kmailsnippetentry->isFile()) {
612
 
    const KArchiveFile* kmailsnippet = static_cast<const KArchiveFile*>(kmailsnippetentry);
613
 
    const QString kmailsnippetrc = KStandardDirs::locateLocal( "config",  kmailsnippetrcStr);
614
 
    if(QFile(kmailsnippetrc).exists()) {
615
 
      //TODO 4.10 allow to merge config.
616
 
      if(KMessageBox::warningYesNo(mParent,i18n("\"%1\" already exists. Do you want to overwrite it ?",kmailsnippetrcStr),i18n("Restore"))== KMessageBox::Yes) {
617
 
        copyToFile(kmailsnippet, kmailsnippetrc,kmailsnippetrcStr,BackupMailUtil::configsPath());
618
 
      }
619
 
    } else {
620
 
      copyToFile(kmailsnippet, kmailsnippetrc,kmailsnippetrcStr,BackupMailUtil::configsPath());
621
 
    }
622
 
  }
623
 
 
624
 
  const QString labldaprcStr("kabldaprc");
625
 
  const KArchiveEntry* kabldapentry  = mArchiveDirectory->entry(BackupMailUtil::configsPath() + labldaprcStr);
626
 
  if(kabldapentry && kabldapentry->isFile()) {
627
 
    const KArchiveFile* kabldap= static_cast<const KArchiveFile*>(kabldapentry);
628
 
    const QString kabldaprc = KStandardDirs::locateLocal( "config",  labldaprcStr);
629
 
    if(QFile(kabldaprc).exists()) {
630
 
      //TODO 4.10 allow to merge config.
631
 
      if(KMessageBox::warningYesNo(mParent,i18n("\"%1\" already exists. Do you want to overwrite it ?",labldaprcStr),i18n("Restore"))== KMessageBox::Yes) {
632
 
        copyToFile(kabldap, kabldaprc, labldaprcStr,BackupMailUtil::configsPath());
633
 
      }
634
 
    } else {
635
 
      copyToFile(kabldap, kabldaprc, labldaprcStr,BackupMailUtil::configsPath());
636
 
    }
637
 
  }
638
 
  const QString archiveconfigurationrcStr("akonadi_archivemail_agentrc");
639
 
  const KArchiveEntry* archiveconfigurationentry  = mArchiveDirectory->entry(BackupMailUtil::configsPath() + archiveconfigurationrcStr);
640
 
  if( archiveconfigurationentry &&  archiveconfigurationentry->isFile()) {
641
 
    const KArchiveFile* archiveconfiguration = static_cast<const KArchiveFile*>(archiveconfigurationentry);
642
 
    const QString archiveconfigurationrc = KStandardDirs::locateLocal( "config",  archiveconfigurationrcStr);
643
 
    if(QFile(archiveconfigurationrc).exists()) {
644
 
      //TODO 4.10 allow to merge config.
645
 
      if(KMessageBox::warningYesNo(mParent,i18n("\"%1\" already exists. Do you want to overwrite it ?",archiveconfigurationrcStr),i18n("Restore"))== KMessageBox::Yes) {
646
 
        importArchiveConfig(archiveconfiguration, archiveconfigurationrc, archiveconfigurationrcStr, BackupMailUtil::configsPath());
647
 
      }
648
 
    } else {
649
 
      importArchiveConfig(archiveconfiguration, archiveconfigurationrc, archiveconfigurationrcStr, BackupMailUtil::configsPath());
650
 
    }
651
 
  }
652
 
 
653
 
 
654
 
 
655
 
  const QString templatesconfigurationrcStr("templatesconfigurationrc");
656
 
  const KArchiveEntry* templatesconfigurationentry  = mArchiveDirectory->entry(BackupMailUtil::configsPath() + templatesconfigurationrcStr);
657
 
  if( templatesconfigurationentry &&  templatesconfigurationentry->isFile()) {
658
 
    const KArchiveFile* templatesconfiguration = static_cast<const KArchiveFile*>(templatesconfigurationentry);
659
 
    const QString templatesconfigurationrc = KStandardDirs::locateLocal( "config",  templatesconfigurationrcStr);
660
 
    if(QFile(templatesconfigurationrc).exists()) {
661
 
      //TODO 4.10 allow to merge config.
662
 
      if(KMessageBox::warningYesNo(mParent,i18n("\"%1\" already exists. Do you want to overwrite it ?",templatesconfigurationrcStr),i18n("Restore"))== KMessageBox::Yes) {
663
 
        importTemplatesConfig(templatesconfiguration, templatesconfigurationrc, templatesconfigurationrcStr, BackupMailUtil::configsPath());
664
 
      }
665
 
    } else {
666
 
      importTemplatesConfig(templatesconfiguration, templatesconfigurationrc, templatesconfigurationrcStr, BackupMailUtil::configsPath());
667
 
    }
668
 
  }
669
 
 
670
 
 
671
 
 
672
 
 
673
 
 
674
 
  const QString kmailStr("kmail2rc");
675
 
  const KArchiveEntry* kmail2rcentry  = mArchiveDirectory->entry(BackupMailUtil::configsPath() + kmailStr);
676
 
  if(kmail2rcentry && kmail2rcentry->isFile()) {
677
 
    const KArchiveFile* kmailrc = static_cast<const KArchiveFile*>(kmail2rcentry);
678
 
    const QString kmail2rc = KStandardDirs::locateLocal( "config",  kmailStr);
679
 
    if(QFile(kmail2rc).exists()) {
680
 
      if(KMessageBox::warningYesNo(mParent,i18n("\"%1\" already exists. Do you want to overwrite it ?",kmailStr),i18n("Restore"))== KMessageBox::Yes) {
681
 
        importKmailConfig(kmailrc,kmail2rc,kmailStr,BackupMailUtil::configsPath());
682
 
      }
683
 
    } else {
684
 
      importKmailConfig(kmailrc,kmail2rc,kmailStr,BackupMailUtil::configsPath());
685
 
    }
686
 
  }
687
 
 
688
 
  Q_EMIT info(i18n("Config restored."));
689
 
}
690
 
 
691
 
void ImportMailJob::restoreIdentity()
692
 
{
693
 
  const QString path(BackupMailUtil::identitiesPath() +QLatin1String("emailidentities"));
694
 
  if(!mFileList.contains(path)) {
695
 
    Q_EMIT error(i18n("emailidentities file could not be found in the archive."));
696
 
    return;
697
 
  }
698
 
  Q_EMIT info(i18n("Restore identities..."));
699
 
  MessageViewer::KCursorSaver busy( MessageViewer::KBusyPtr::busy() );
700
 
  const KArchiveEntry* identity = mArchiveDirectory->entry(path);
701
 
  if(identity && identity->isFile()) {
702
 
    const KArchiveFile* fileIdentity = static_cast<const KArchiveFile*>(identity);
703
 
    fileIdentity->copyTo(mTempDirName);
704
 
    KSharedConfig::Ptr identityConfig = KSharedConfig::openConfig(mTempDirName + QLatin1Char('/') +QLatin1String("emailidentities"));
705
 
    KConfigGroup general = identityConfig->group(QLatin1String("General"));
706
 
    const int defaultIdentity = general.readEntry(QLatin1String("Default Identity"),-1);
707
 
 
708
 
    const QStringList identityList = identityConfig->groupList().filter( QRegExp( "Identity #\\d+" ) );
709
 
    Q_FOREACH(const QString&identityStr, identityList) {
710
 
      KConfigGroup group = identityConfig->group(identityStr);
711
 
      int oldUid = -1;
712
 
      const QString uidStr("uoid");
713
 
      if(group.hasKey(uidStr)) {
714
 
        oldUid = group.readEntry(uidStr).toUInt();
715
 
        group.deleteEntry(uidStr);
716
 
      }
717
 
      const QString fcc(QLatin1String("Fcc"));
718
 
      if(group.hasKey(fcc)) {
719
 
        const Akonadi::Collection::Id fccId = convertPathToId(group.readEntry(fcc));
720
 
        if(fccId != -1 )
721
 
          group.writeEntry(fcc,fccId);
722
 
        else
723
 
          group.deleteEntry(fcc);
724
 
      }
725
 
      const QString draft = QLatin1String("Drafts");
726
 
      if(group.hasKey(draft)) {
727
 
        const Akonadi::Collection::Id draftId = convertPathToId(group.readEntry(draft));
728
 
        if(draftId != -1)
729
 
          group.writeEntry(draft,draftId);
730
 
        else
731
 
          group.deleteEntry(draft);
732
 
      }
733
 
      const QString templates = QLatin1String("Templates");
734
 
      if(group.hasKey(templates)) {
735
 
        const Akonadi::Collection::Id templateId = convertPathToId(group.readEntry(templates));
736
 
        if(templateId != -1)
737
 
          group.writeEntry(templates,templateId);
738
 
        else
739
 
          group.deleteEntry(templates);
740
 
      }
741
 
      group.sync();
742
 
      KPIMIdentities::Identity* identity = &mIdentityManager->newFromScratch( QString() );
743
 
 
744
 
      identity->readConfig(group);
745
 
      if(oldUid != -1) {
746
 
        mHashIdentity.insert(oldUid,identity->uoid());
747
 
        if(oldUid == defaultIdentity) {
748
 
          mIdentityManager->setAsDefault(identity->uoid());
749
 
        }
750
 
      }
751
 
      mIdentityManager->commit();
752
 
    }
753
 
    Q_EMIT info(i18n("Identities restored."));
754
 
  } else {
755
 
    Q_EMIT error(i18n("Failed to restore identity file."));
756
 
  }
757
 
}
758
 
 
759
 
void ImportMailJob::restoreAkonadiDb()
760
 
{
761
 
  const QString akonadiDbPath(BackupMailUtil::akonadiPath() + QLatin1String("akonadidatabase.sql"));
762
 
  if(!mFileList.contains(akonadiDbPath)) {
763
 
    Q_EMIT error(i18n("akonadi database file could not be found in the archive."));
764
 
    return;
765
 
  }
766
 
 
767
 
  MessageViewer::KCursorSaver busy( MessageViewer::KBusyPtr::busy() );
768
 
 
769
 
  const KArchiveEntry* akonadiDataBaseEntry = mArchiveDirectory->entry(akonadiDbPath);
770
 
  if(akonadiDataBaseEntry && akonadiDataBaseEntry->isFile()) {
771
 
 
772
 
    const KArchiveFile* akonadiDataBaseFile = static_cast<const KArchiveFile*>(akonadiDataBaseEntry);
773
 
 
774
 
    KTemporaryFile tmp;
775
 
    tmp.open();
776
 
 
777
 
    akonadiDataBaseFile->copyTo(tmp.fileName());
778
 
 
779
 
    /* Restore the database */
780
 
    AkonadiDataBase akonadiDataBase;
781
 
 
782
 
    const QString dbDriver(akonadiDataBase.driver());
783
 
    QStringList params;
784
 
    QString dbRestoreAppName;
785
 
    if( dbDriver == QLatin1String("QPSQL") ) {
786
 
      dbRestoreAppName = QLatin1String("pg_restore");
787
 
      params << akonadiDataBase.options()
788
 
             << QLatin1String("--dbname=") + akonadiDataBase.name()
789
 
             << QLatin1String("--format=custom")
790
 
             << QLatin1String("--clean")
791
 
             << QLatin1String("--no-owner")
792
 
             << QLatin1String("--no-privileges")
793
 
             << tmp.fileName();
794
 
    }
795
 
    else if (dbDriver == QLatin1String("QMYSQL") ) {
796
 
      dbRestoreAppName = QLatin1String("mysql");
797
 
      params << akonadiDataBase.options()
798
 
             << QLatin1String("--database=") + akonadiDataBase.name();
799
 
    } else {
800
 
      Q_EMIT error(i18n("Database driver \"%1\" not supported.",dbDriver));
801
 
      return;
802
 
    }
803
 
    const QString dbRestoreApp = KStandardDirs::findExe( dbRestoreAppName );
804
 
    if(dbRestoreApp.isEmpty()) {
805
 
      Q_EMIT error(i18n("Could not find \"%1\" necessary to restore database.",dbRestoreAppName));
806
 
      return;
807
 
    }
808
 
    KProcess *proc = new KProcess( this );
809
 
    proc->setProgram( KStandardDirs::findExe( dbRestoreApp ), params );
810
 
    proc->setStandardInputFile(tmp.fileName());
811
 
    const int result = proc->execute();
812
 
    delete proc;
813
 
    if ( result != 0 ) {
814
 
      Q_EMIT error(i18n("Failed to restore Akonadi Database."));
815
 
      return;
816
 
    }
817
 
  }
818
 
  Q_EMIT info(i18n("Akonadi Database restored."));
819
 
}
820
 
 
821
 
void ImportMailJob::restoreNepomuk()
822
 
{
823
 
  MessageViewer::KCursorSaver busy( MessageViewer::KBusyPtr::busy() );
824
 
  Q_EMIT info(i18n("Nepomuk Database restored."));
825
 
  Q_EMIT error(i18n("Failed to restore Nepomuk Database."));
826
 
  //TODO
827
 
}
828
 
 
829
 
 
830
 
void ImportMailJob::importArchiveConfig(const KArchiveFile* archiveconfiguration, const QString& archiveconfigurationrc, const QString&filename,const QString& prefix)
831
 
{
832
 
  copyToFile(archiveconfiguration,archiveconfigurationrc,filename,prefix);
833
 
  KSharedConfig::Ptr archiveConfig = KSharedConfig::openConfig(archiveconfigurationrc);
834
 
 
835
 
  //adapt id
836
 
  const QString archiveGroupPattern = QLatin1String( "ArchiveMailCollection " );
837
 
  const QStringList archiveList = archiveConfig->groupList().filter( archiveGroupPattern );
838
 
  Q_FOREACH(const QString& str, archiveList) {
839
 
    const QString path = str.right(str.length()-archiveGroupPattern.length());
840
 
    if(!path.isEmpty())
841
 
    {
842
 
      KConfigGroup oldGroup = archiveConfig->group(str);
843
 
      const Akonadi::Collection::Id id = convertPathToId(path);
844
 
      if(id!=-1) {
845
 
        KConfigGroup newGroup( archiveConfig, archiveGroupPattern + QString::number(id));
846
 
        oldGroup.copyTo( &newGroup );
847
 
        newGroup.writeEntry(QLatin1String("saveCollectionId"),id);
848
 
        KUrl path = newGroup.readEntry("storePath",KUrl());
849
 
        if(!QDir(path.path()).exists()) {
850
 
          newGroup.writeEntry(QLatin1String("storePath"),KUrl(QDir::homePath()));
851
 
        }
852
 
      }
853
 
      oldGroup.deleteGroup();
854
 
    }
855
 
  }
856
 
  archiveConfig->sync();
857
 
}
858
 
 
859
 
 
860
 
 
861
 
void ImportMailJob::importTemplatesConfig(const KArchiveFile* templatesconfiguration, const QString& templatesconfigurationrc, const QString&filename,const QString& prefix)
862
 
{
863
 
  copyToFile(templatesconfiguration,templatesconfigurationrc,filename,prefix);
864
 
  KSharedConfig::Ptr templateConfig = KSharedConfig::openConfig(templatesconfigurationrc);
865
 
 
866
 
  //adapt id
867
 
  const QString templateGroupPattern = QLatin1String( "Templates #" );
868
 
  const QStringList templateList = templateConfig->groupList().filter( templateGroupPattern );
869
 
  Q_FOREACH(const QString& str, templateList) {
870
 
    const QString path = str.right(str.length()-templateGroupPattern.length());
871
 
    if(!path.isEmpty())
872
 
    {
873
 
      KConfigGroup oldGroup = templateConfig->group(str);
874
 
      const Akonadi::Collection::Id id = convertPathToId(path);
875
 
      if(id!=-1) {
876
 
        KConfigGroup newGroup( templateConfig, templateGroupPattern + QString::number(id));
877
 
        oldGroup.copyTo( &newGroup );
878
 
      }
879
 
      oldGroup.deleteGroup();
880
 
    }
881
 
  }
882
 
  //adapt identity
883
 
  const QString templateGroupIdentityPattern = QLatin1String( "Templates #IDENTITY_" );
884
 
  const QStringList templateListIdentity = templateConfig->groupList().filter( templateGroupIdentityPattern );
885
 
  Q_FOREACH(const QString& str, templateListIdentity) {
886
 
    bool found = false;
887
 
    const int identity = str.right(str.length()-templateGroupIdentityPattern.length()).toInt(&found);
888
 
    if(found)
889
 
    {
890
 
      KConfigGroup oldGroup = templateConfig->group(str);
891
 
      if(mHashIdentity.contains(identity)) {
892
 
        KConfigGroup newGroup( templateConfig, templateGroupPattern + QString::number(mHashIdentity.value(identity)));
893
 
        oldGroup.copyTo( &newGroup );
894
 
      }
895
 
      oldGroup.deleteGroup();
896
 
    }
897
 
  }
898
 
  templateConfig->sync();
899
 
}
900
 
 
901
 
void ImportMailJob::importKmailConfig(const KArchiveFile* kmailsnippet, const QString& kmail2rc, const QString&filename,const QString& prefix)
902
 
{
903
 
  copyToFile(kmailsnippet,kmail2rc,filename,prefix);
904
 
  KSharedConfig::Ptr kmailConfig = KSharedConfig::openConfig(kmail2rc);
905
 
 
906
 
  //adapt folder id
907
 
  const QString folderGroupPattern = QLatin1String( "Folder-" );
908
 
  const QStringList folderList = kmailConfig->groupList().filter( folderGroupPattern );
909
 
  Q_FOREACH(const QString&str, folderList) {
910
 
    const QString path = str.right(str.length()-folderGroupPattern.length());
911
 
    if(!path.isEmpty()) {
912
 
      KConfigGroup oldGroup = kmailConfig->group(str);
913
 
      const Akonadi::Collection::Id id = convertPathToId(path);
914
 
      if(id!=-1) {
915
 
        KConfigGroup newGroup( kmailConfig, folderGroupPattern + QString::number(id));
916
 
        oldGroup.copyTo( &newGroup );
917
 
      }
918
 
      oldGroup.deleteGroup();
919
 
    }
920
 
  }
921
 
  const QString accountOrder("AccountOrder");
922
 
  if(kmailConfig->hasGroup(accountOrder)) {
923
 
    KConfigGroup group = kmailConfig->group(accountOrder);
924
 
    QStringList orderList = group.readEntry(QLatin1String("order"),QStringList());
925
 
    QStringList newOrderList;
926
 
    if(!orderList.isEmpty()) {
927
 
      Q_FOREACH(const QString&account, orderList) {
928
 
        if(mHashResources.contains(account)) {
929
 
          newOrderList.append(mHashResources.value(account));
930
 
        } else {
931
 
          newOrderList.append(account);
932
 
        }
933
 
      }
934
 
    }
935
 
  }
936
 
 
937
 
  const QString composerStr("Composer");
938
 
  if(kmailConfig->hasGroup(composerStr)) {
939
 
    KConfigGroup composerGroup = kmailConfig->group(composerStr);
940
 
    const QString previousStr("previous-fcc");
941
 
    if(composerGroup.hasKey(previousStr)) {
942
 
      const QString path = composerGroup.readEntry(previousStr);
943
 
      if(!path.isEmpty()) {
944
 
        const Akonadi::Collection::Id id = convertPathToId(path);
945
 
        if(id != -1) {
946
 
          composerGroup.writeEntry(previousStr,id);
947
 
        } else {
948
 
          composerGroup.deleteEntry(previousStr);
949
 
        }
950
 
      }
951
 
    }
952
 
    const QString previousIdentityStr("previous-identity");
953
 
    if(composerGroup.hasKey(previousIdentityStr)) {
954
 
      const int identityValue = composerGroup.readEntry(previousIdentityStr, -1);
955
 
      if(identityValue!=-1) {
956
 
        if(mHashIdentity.contains(identityValue)) {
957
 
          composerGroup.writeEntry(previousIdentityStr,mHashIdentity.value(identityValue));
958
 
        } else {
959
 
          composerGroup.writeEntry(previousIdentityStr,identityValue);
960
 
        }
961
 
      }
962
 
    }
963
 
  }
964
 
 
965
 
  const QString generalStr("General");
966
 
  if(kmailConfig->hasGroup(generalStr)) {
967
 
    KConfigGroup generalGroup = kmailConfig->group(generalStr);
968
 
    const QString startupFolderStr("startupFolder");
969
 
    if(generalGroup.hasKey(startupFolderStr)) {
970
 
      const QString path = generalGroup.readEntry(startupFolderStr);
971
 
      if(!path.isEmpty()) {
972
 
        const Akonadi::Collection::Id id = convertPathToId(path);
973
 
        if(id != -1) {
974
 
          generalGroup.writeEntry(startupFolderStr,id);
975
 
        } else {
976
 
          generalGroup.deleteEntry(startupFolderStr);
977
 
        }
978
 
      }
979
 
    }
980
 
  }
981
 
 
982
 
  const QString resourceGroupPattern = QLatin1String( "Resource " );
983
 
  const QStringList resourceList = kmailConfig->groupList().filter( resourceGroupPattern );
984
 
  Q_FOREACH(const QString&str, resourceList) {
985
 
    const QString res = str.right(str.length()-resourceGroupPattern.length());
986
 
    if(!res.isEmpty()) {
987
 
        KConfigGroup oldGroup = kmailConfig->group(str);
988
 
        if(mHashResources.contains(res)) {
989
 
          KConfigGroup newGroup( kmailConfig, folderGroupPattern + mHashResources.value(res));
990
 
          oldGroup.copyTo( &newGroup );
991
 
        }
992
 
        oldGroup.deleteGroup();
993
 
    }
994
 
  }
995
 
 
996
 
  kmailConfig->sync();
997
 
}
998
 
 
999
 
Akonadi::Collection::Id ImportMailJob::convertPathToId(const QString& path)
1000
 
{
1001
 
  if(mHashConvertPathCollectionId.contains(path)) {
1002
 
    return mHashConvertPathCollectionId.value(path);
1003
 
  }
1004
 
  const Akonadi::Collection::Id id = MailCommon::Util::convertFolderPathToCollectionId(path);
1005
 
  if(id != -1) {
1006
 
    mHashConvertPathCollectionId.insert(path,id);
1007
 
  }
1008
 
  return id;
1009
 
}