00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033 #ifdef HAVE_CONFIG_H
00034 #include <config.h>
00035 #endif
00036
00037 #include "cachedimapjob.h"
00038 #include "imapaccountbase.h"
00039
00040 #include "kmfoldermgr.h"
00041 #include "kmfolder.h"
00042 #include "kmfoldercachedimap.h"
00043 #include "kmacctcachedimap.h"
00044 #include "kmmsgdict.h"
00045 #include "maildirjob.h"
00046
00047 #include <kio/scheduler.h>
00048 #include <kio/job.h>
00049
00050 #include <kmessagebox.h>
00051 #include <klocale.h>
00052 #include <kdebug.h>
00053
00054
00055 namespace KMail {
00056
00057
00058 CachedImapJob::CachedImapJob( const QValueList<MsgForDownload>& msgs,
00059 JobType type, KMFolderCachedImap* folder )
00060 : FolderJob( type ), mFolder( folder ), mMsgsForDownload( msgs ),
00061 mTotalBytes(0), mMsg(0), mParentFolder( 0 )
00062 {
00063 QValueList<MsgForDownload>::ConstIterator it = msgs.begin();
00064 for ( ; it != msgs.end() ; ++it )
00065 mTotalBytes += (*it).size;
00066 }
00067
00068
00069 CachedImapJob::CachedImapJob( const QPtrList<KMMessage>& msgs, JobType type,
00070 KMFolderCachedImap* folder )
00071 : FolderJob( msgs, QString::null, type, folder?folder->folder():0 ), mFolder( folder ),
00072 mTotalBytes( msgs.count() ),
00073 mMsg( 0 ), mParentFolder( 0 )
00074 {
00075 }
00076
00077 CachedImapJob::CachedImapJob( const QValueList<unsigned long>& msgs,
00078 JobType type, KMFolderCachedImap* folder )
00079 : FolderJob( QPtrList<KMMessage>(), QString::null, type, folder?folder->folder():0 ),
00080 mFolder( folder ), mSerNumMsgList( msgs ), mTotalBytes( msgs.count() ), mMsg( 0 ),
00081 mParentFolder ( 0 )
00082 {
00083 }
00084
00085
00086 CachedImapJob::CachedImapJob( const QValueList<KMFolderCachedImap*>& fList,
00087 JobType type, KMFolderCachedImap* folder )
00088 : FolderJob( type ), mFolder( folder ), mFolderList( fList ), mMsg( 0 ),
00089 mParentFolder ( 0 )
00090 {
00091 }
00092
00093
00094 CachedImapJob::CachedImapJob( const QString& string1, JobType type,
00095 KMFolderCachedImap* folder )
00096 : FolderJob( type ), mFolder(folder), mMsg( 0 ), mString( string1 ),
00097 mParentFolder ( 0 )
00098 {
00099 assert( folder );
00100 assert( type != tDeleteMessage );
00101 }
00102
00103
00104 CachedImapJob::CachedImapJob( const QStringList& foldersOrMsgs, JobType type,
00105 KMFolderCachedImap* folder )
00106 : FolderJob( type ), mFolder( folder ), mFoldersOrMessages( foldersOrMsgs ),
00107 mMsg( 0 ), mParentFolder( 0 )
00108 {
00109 assert( folder );
00110 }
00111
00112
00113 CachedImapJob::CachedImapJob( JobType type, KMFolderCachedImap* folder )
00114 : FolderJob( type ), mFolder( folder ), mMsg( 0 ), mParentFolder ( 0 )
00115 {
00116 assert( folder );
00117 }
00118
00119 CachedImapJob::~CachedImapJob()
00120 {
00121 mAccount->mJobList.remove(this);
00122 }
00123
00124 void CachedImapJob::execute()
00125 {
00126 mSentBytes = 0;
00127
00128 if( !mFolder ) {
00129 if( !mMsgList.isEmpty() ) {
00130 mFolder = static_cast<KMFolderCachedImap*>(mMsgList.first()->storage());
00131 }
00132 }
00133 assert( mFolder );
00134 mAccount = mFolder->account();
00135 assert( mAccount != 0 );
00136 if( mAccount->makeConnection() != ImapAccountBase::Connected ) {
00137
00138 kdDebug(5006) << "mAccount->makeConnection() failed" << endl;
00139 mPassiveDestructor = true;
00140 delete this;
00141 return;
00142 } else
00143 mPassiveDestructor = false;
00144
00145
00146 mAccount->mJobList.append(this);
00147
00148 switch( mType ) {
00149 case tGetMessage: slotGetNextMessage(); break;
00150 case tPutMessage: slotPutNextMessage(); break;
00151 case tDeleteMessage: slotDeleteNextMessages(); break;
00152 case tExpungeFolder: expungeFolder(); break;
00153 case tAddSubfolders: slotAddNextSubfolder(); break;
00154 case tDeleteFolders: slotDeleteNextFolder(); break;
00155 case tCheckUidValidity: checkUidValidity(); break;
00156 case tRenameFolder: renameFolder(mString); break;
00157 case tListMessages: listMessages(); break;
00158 default:
00159 assert( 0 );
00160 }
00161 }
00162
00163 void CachedImapJob::listMessages()
00164 {
00165 KURL url = mAccount->getUrl();
00166 url.setPath( mFolder->imapPath() + ";UID=1:*;SECTION=FLAGS RFC822.SIZE");
00167
00168 KIO::SimpleJob *job = KIO::get(url, false, false);
00169 KIO::Scheduler::assignJobToSlave( mAccount->slave(), job );
00170 ImapAccountBase::jobData jd( url.url(), mFolder->folder() );
00171 jd.cancellable = true;
00172 mAccount->insertJob( job, jd );
00173 connect( job, SIGNAL( result(KIO::Job *) ),
00174 this, SLOT( slotListMessagesResult( KIO::Job* ) ) );
00175
00176 connect( job, SIGNAL( data( KIO::Job*, const QByteArray& ) ),
00177 mFolder, SLOT( slotGetMessagesData( KIO::Job* , const QByteArray& ) ) );
00178 }
00179
00180 void CachedImapJob::slotDeleteNextMessages( KIO::Job* job )
00181 {
00182 if (job) {
00183 KMAcctCachedImap::JobIterator it = mAccount->findJob(job);
00184 if ( it == mAccount->jobsEnd() ) {
00185 delete this;
00186 return;
00187 }
00188
00189 if( job->error() ) {
00190 mAccount->handleJobError( job, i18n( "Error while deleting messages on the server: " ) + '\n' );
00191 delete this;
00192 return;
00193 }
00194 mAccount->removeJob(it);
00195 }
00196
00197 if( mFoldersOrMessages.isEmpty() ) {
00198
00199 delete this;
00200 return;
00201 }
00202
00203 QString uids = mFoldersOrMessages.front(); mFoldersOrMessages.pop_front();
00204
00205 KURL url = mAccount->getUrl();
00206 url.setPath( mFolder->imapPath() +
00207 QString::fromLatin1(";UID=%1").arg(uids) );
00208
00209 KIO::SimpleJob *simpleJob = KIO::file_delete( url, false );
00210 KIO::Scheduler::assignJobToSlave( mAccount->slave(), simpleJob );
00211 ImapAccountBase::jobData jd( url.url(), mFolder->folder() );
00212 mAccount->insertJob( simpleJob, jd );
00213 connect( simpleJob, SIGNAL( result(KIO::Job *) ),
00214 this, SLOT( slotDeleteNextMessages(KIO::Job *) ) );
00215 }
00216
00217 void CachedImapJob::expungeFolder()
00218 {
00219 KURL url = mAccount->getUrl();
00220
00221 url.setPath( mFolder->imapPath() + QString::fromLatin1(";UID=*") );
00222
00223 KIO::SimpleJob *job = KIO::file_delete( url, false );
00224 KIO::Scheduler::assignJobToSlave( mAccount->slave(), job );
00225 ImapAccountBase::jobData jd( url.url(), mFolder->folder() );
00226 mAccount->insertJob( job, jd );
00227 connect( job, SIGNAL( result(KIO::Job *) ),
00228 this, SLOT( slotExpungeResult(KIO::Job *) ) );
00229 }
00230
00231 void CachedImapJob::slotExpungeResult( KIO::Job * job )
00232 {
00233 KMAcctCachedImap::JobIterator it = mAccount->findJob(job);
00234 if ( it == mAccount->jobsEnd() ) {
00235 delete this;
00236 return;
00237 }
00238
00239 if (job->error()) {
00240 mErrorCode = job->error();
00241 mAccount->handleJobError( job, i18n( "Error while deleting messages on the server: " ) + '\n' );
00242 }
00243 else
00244 mAccount->removeJob(it);
00245
00246 delete this;
00247 }
00248
00249 void CachedImapJob::slotGetNextMessage(KIO::Job * job)
00250 {
00251 if (job) {
00252 KMAcctCachedImap::JobIterator it = mAccount->findJob(job);
00253 if ( it == mAccount->jobsEnd() ) {
00254 delete this;
00255 return;
00256 }
00257
00258 if (job->error()) {
00259 mErrorCode = job->error();
00260 mAccount->handleJobError( job, i18n( "Error while retrieving message on the server: " ) + '\n' );
00261 delete this;
00262 return;
00263 }
00264
00265 ulong size = 0;
00266 if ((*it).data.size() > 0) {
00267 ulong uid = mMsg->UID();
00268 size = mMsg->msgSizeServer();
00269
00270
00271 size_t dataSize = (*it).data.size();
00272 dataSize = FolderStorage::crlf2lf( (*it).data.data(), dataSize );
00273 (*it).data.resize( dataSize );
00274
00275 mMsg->setComplete( true );
00276 mMsg->fromByteArray( (*it).data );
00277 mMsg->setUID(uid);
00278 mMsg->setMsgSizeServer(size);
00279 mMsg->setTransferInProgress( false );
00280 int index = 0;
00281 mFolder->addMsgInternal( mMsg, true, &index );
00282 emit messageRetrieved( mMsg );
00283 if ( index > 0 ) mFolder->unGetMsg( index );
00284 } else {
00285 emit messageRetrieved( 0 );
00286 }
00287 mMsg = 0;
00288
00289 mSentBytes += size;
00290 emit progress( mSentBytes, mTotalBytes );
00291 mAccount->removeJob(it);
00292 }
00293
00294 if( mMsgsForDownload.isEmpty() ) {
00295 delete this;
00296 return;
00297 }
00298
00299 MsgForDownload mfd = mMsgsForDownload.front(); mMsgsForDownload.pop_front();
00300
00301 mMsg = new KMMessage;
00302 mMsg->setUID(mfd.uid);
00303 mMsg->setMsgSizeServer(mfd.size);
00304 if( mfd.flags > 0 )
00305 KMFolderImap::flagsToStatus(mMsg, mfd.flags);
00306 KURL url = mAccount->getUrl();
00307 url.setPath(mFolder->imapPath() + QString(";UID=%1;SECTION=BODY.PEEK[]").arg(mfd.uid));
00308
00309 ImapAccountBase::jobData jd( url.url(), mFolder->folder() );
00310 jd.cancellable = true;
00311 mMsg->setTransferInProgress(true);
00312 KIO::SimpleJob *simpleJob = KIO::get(url, false, false);
00313 KIO::Scheduler::assignJobToSlave(mAccount->slave(), simpleJob);
00314 mAccount->insertJob(simpleJob, jd);
00315 connect(simpleJob, SIGNAL(processedSize(KIO::Job *, KIO::filesize_t)),
00316 this, SLOT(slotProcessedSize(KIO::Job *, KIO::filesize_t)));
00317 connect(simpleJob, SIGNAL(result(KIO::Job *)),
00318 this, SLOT(slotGetNextMessage(KIO::Job *)));
00319 connect(simpleJob, SIGNAL(data(KIO::Job *, const QByteArray &)),
00320 mFolder, SLOT(slotSimpleData(KIO::Job *, const QByteArray &)));
00321 }
00322
00323 void CachedImapJob::slotProcessedSize(KIO::Job *, KIO::filesize_t processed)
00324 {
00325 emit progress( mSentBytes + processed, mTotalBytes );
00326 }
00327
00328 void CachedImapJob::slotPutNextMessage()
00329 {
00330 mMsg = 0;
00331
00332
00333 if( !mMsgList.isEmpty() ) {
00334 mMsg = mMsgList.first();
00335 mMsgList.removeFirst();
00336 }
00337
00338
00339 while( mMsg == 0 && !mSerNumMsgList.isEmpty() ) {
00340 unsigned long serNum = mSerNumMsgList.first();
00341 mSerNumMsgList.pop_front();
00342
00343
00344 int i = 0;
00345 KMFolder* aFolder = 0;
00346 kmkernel->msgDict()->getLocation( serNum, &aFolder, &i );
00347 if( mFolder->folder() != aFolder )
00348
00349 continue;
00350 mMsg = mFolder->getMsg( i );
00351 }
00352
00353 if( !mMsg ) {
00354
00355 delete this;
00356 return;
00357 }
00358
00359 KURL url = mAccount->getUrl();
00360 QString flags = KMFolderImap::statusToFlags( mMsg->status() );
00361 url.setPath( mFolder->imapPath() + ";SECTION=" + flags );
00362
00363 ImapAccountBase::jobData jd( url.url(), mFolder->folder() );
00364
00365 mMsg->setUID( 0 );
00366 QCString cstr(mMsg->asString());
00367 int a = cstr.find("\nX-UID: ");
00368 int b = cstr.find('\n', a);
00369 if (a != -1 && b != -1 && cstr.find("\n\n") > a) cstr.remove(a, b-a);
00370 QCString mData(cstr.length() + cstr.contains('\n'));
00371 unsigned int i = 0;
00372 for( char *ch = cstr.data(); *ch; ch++ ) {
00373 if ( *ch == '\n' ) {
00374 mData.at(i) = '\r';
00375 i++;
00376 }
00377 mData.at(i) = *ch; i++;
00378 }
00379 jd.data = mData;
00380 jd.msgList.append( mMsg );
00381
00382 mMsg->setTransferInProgress(true);
00383 KIO::SimpleJob *simpleJob = KIO::put(url, 0, false, false, false);
00384 KIO::Scheduler::assignJobToSlave(mAccount->slave(), simpleJob);
00385 mAccount->insertJob(simpleJob, jd);
00386 connect( simpleJob, SIGNAL( result(KIO::Job *) ),
00387 SLOT( slotPutMessageResult(KIO::Job *) ) );
00388 connect( simpleJob, SIGNAL( dataReq(KIO::Job *, QByteArray &) ),
00389 SLOT( slotPutMessageDataReq(KIO::Job *, QByteArray &) ) );
00390 connect( simpleJob, SIGNAL( data(KIO::Job *, const QByteArray &) ),
00391 mFolder, SLOT( slotSimpleData(KIO::Job *, const QByteArray &) ) );
00392 connect( simpleJob, SIGNAL(infoMessage(KIO::Job *, const QString &)),
00393 SLOT(slotPutMessageInfoData(KIO::Job *, const QString &)) );
00394
00395 }
00396
00397
00398
00399 void CachedImapJob::slotPutMessageDataReq(KIO::Job *job, QByteArray &data)
00400 {
00401 KMAcctCachedImap::JobIterator it = mAccount->findJob(job);
00402 if ( it == mAccount->jobsEnd() ) {
00403 delete this;
00404 return;
00405 }
00406 if ((*it).data.size() - (*it).offset > 0x8000) {
00407 data.duplicate((*it).data.data() + (*it).offset, 0x8000);
00408 (*it).offset += 0x8000;
00409 } else if ((*it).data.size() - (*it).offset > 0) {
00410 data.duplicate((*it).data.data() + (*it).offset,
00411 (*it).data.size() - (*it).offset);
00412 (*it).offset = (*it).data.size();
00413 } else
00414 data.resize(0);
00415 }
00416
00417
00418 void CachedImapJob::slotPutMessageInfoData(KIO::Job *job, const QString &data)
00419 {
00420 KMFolderCachedImap * imapFolder = static_cast<KMFolderCachedImap*>(mDestFolder->storage());
00421 KMAcctCachedImap *account = imapFolder->account();
00422 ImapAccountBase::JobIterator it = account->findJob( job );
00423 if ( it == account->jobsEnd() ) return;
00424
00425 if (data.find("UID") != -1 && mMsg)
00426 {
00427 int uid = (data.right(data.length()-4)).toInt();
00428 kdDebug( 5006 ) << k_funcinfo << "Server told us uid is: " << uid << endl;
00429 mMsg->setUID( uid );
00430 }
00431 }
00432
00433
00434
00435 void CachedImapJob::slotPutMessageResult(KIO::Job *job)
00436 {
00437 KMAcctCachedImap::JobIterator it = mAccount->findJob(job);
00438 if ( it == mAccount->jobsEnd() ) {
00439 delete this;
00440 return;
00441 }
00442
00443 if ( job->error() ) {
00444 bool cont = mAccount->handlePutError( job, *it, mFolder->folder() );
00445 if ( !cont ) {
00446 delete this;
00447 } else {
00448 mMsg = 0;
00449 slotPutNextMessage();
00450 }
00451 return;
00452 }
00453
00454 emit messageStored( mMsg );
00455
00456
00457 ++mSentBytes;
00458 emit progress( mSentBytes, mTotalBytes );
00459
00460 int i;
00461 if( ( i = mFolder->find(mMsg) ) != -1 ) {
00462
00463
00464
00465
00466
00467 if ( mMsg->UID() == 0 ) {
00468 mFolder->removeMsg(i);
00469 } else {
00470 mFolder->take( i );
00471 mFolder->addMsgKeepUID( mMsg );
00472 mMsg->setTransferInProgress( false );
00473 }
00474 }
00475 mMsg = NULL;
00476 mAccount->removeJob( it );
00477 slotPutNextMessage();
00478 }
00479
00480
00481 void CachedImapJob::slotAddNextSubfolder( KIO::Job * job )
00482 {
00483 if (job) {
00484 KMAcctCachedImap::JobIterator it = mAccount->findJob(job);
00485 if ( it == mAccount->jobsEnd() ) {
00486 delete this;
00487 return;
00488 }
00489
00490
00491 bool silentUpload = static_cast<KMFolderCachedImap*>((*it).parent->storage())->silentUpload();
00492 static_cast<KMFolderCachedImap*>((*it).parent->storage())->setSilentUpload( false );
00493
00494 if ( job->error() && !silentUpload ) {
00495 QString myError = "<p><b>" + i18n("Error while uploading folder")
00496 + "</b></p><p>" + i18n("Could not make the folder <b>%1</b> on the server.").arg((*it).items[0])
00497 + "</p><p>" + i18n("This could be because you do not have permission to do this, or because the folder is already present on the server; the error message from the server communication is here:") + "</p>";
00498 mAccount->handleJobError( job, myError );
00499 }
00500
00501 if( job->error() ) {
00502 delete this;
00503 return;
00504 }
00505 mAccount->removeJob( it );
00506 }
00507
00508 if (mFolderList.isEmpty()) {
00509
00510 delete this;
00511 return;
00512 }
00513
00514 KMFolderCachedImap *folder = mFolderList.front();
00515 mFolderList.pop_front();
00516 KURL url = mAccount->getUrl();
00517 url.setPath(mFolder->imapPath() + folder->name());
00518
00519
00520
00521
00522 ImapAccountBase::jobData jd( url.url(), mFolder->folder() );
00523 jd.items << folder->label();
00524 KIO::SimpleJob *simpleJob = KIO::mkdir(url);
00525 KIO::Scheduler::assignJobToSlave(mAccount->slave(), simpleJob);
00526 mAccount->insertJob(simpleJob, jd);
00527 connect( simpleJob, SIGNAL(result(KIO::Job *)),
00528 this, SLOT(slotAddNextSubfolder(KIO::Job *)) );
00529 }
00530
00531
00532 void CachedImapJob::slotDeleteNextFolder( KIO::Job *job )
00533 {
00534 if (job) {
00535 KMAcctCachedImap::JobIterator it = mAccount->findJob(job);
00536 if ( it == mAccount->jobsEnd() ) {
00537 delete this;
00538 return;
00539 }
00540
00541 if( job->error() ) {
00542 mAccount->handleJobError( job, i18n( "Error while deleting folder %1 on the server: " ).arg( (*it).path ) + '\n' );
00543 delete this;
00544 return;
00545 }
00546 mAccount->removeJob(it);
00547 }
00548
00549 if( mFoldersOrMessages.isEmpty() ) {
00550
00551 delete this;
00552 return;
00553 }
00554
00555 QString folderPath = mFoldersOrMessages.front(); mFoldersOrMessages.pop_front();
00556 KURL url = mAccount->getUrl();
00557 url.setPath(folderPath);
00558 ImapAccountBase::jobData jd( url.url(), mFolder->folder() );
00559 jd.path = url.path();
00560 KIO::SimpleJob *simpleJob = KIO::file_delete(url, false);
00561 KIO::Scheduler::assignJobToSlave(mAccount->slave(), simpleJob);
00562 mAccount->insertJob(simpleJob, jd);
00563 connect( simpleJob, SIGNAL( result(KIO::Job *) ),
00564 SLOT( slotDeleteNextFolder(KIO::Job *) ) );
00565 }
00566
00567 void CachedImapJob::checkUidValidity()
00568 {
00569 KURL url = mAccount->getUrl();
00570 url.setPath( mFolder->imapPath() + ";UID=0:0" );
00571
00572 ImapAccountBase::jobData jd( url.url(), mFolder->folder() );
00573 jd.cancellable = true;
00574
00575 KIO::SimpleJob *job = KIO::get( url, false, false );
00576 KIO::Scheduler::assignJobToSlave( mAccount->slave(), job );
00577 mAccount->insertJob( job, jd );
00578 connect( job, SIGNAL(result(KIO::Job *)),
00579 SLOT(slotCheckUidValidityResult(KIO::Job *)) );
00580 connect( job, SIGNAL(data(KIO::Job *, const QByteArray &)),
00581 mFolder, SLOT(slotSimpleData(KIO::Job *, const QByteArray &)));
00582 }
00583
00584 void CachedImapJob::slotCheckUidValidityResult(KIO::Job * job)
00585 {
00586 KMAcctCachedImap::JobIterator it = mAccount->findJob(job);
00587 if ( it == mAccount->jobsEnd() ) {
00588 delete this;
00589 return;
00590 }
00591
00592 if( job->error() ) {
00593 mErrorCode = job->error();
00594 mAccount->handleJobError( job, i18n( "Error while reading folder %1 on the server: " ).arg( (*it).parent->label() ) + '\n' );
00595 delete this;
00596 return;
00597 }
00598
00599
00600 QCString cstr((*it).data.data(), (*it).data.size() + 1);
00601 int a = cstr.find("X-uidValidity: ");
00602 if (a < 0) {
00603
00604
00605 kdDebug(5006) << "No uidvalidity available for folder "
00606 << mFolder->name() << endl;
00607 }
00608 else {
00609 int b = cstr.find("\r\n", a);
00610 if ( (b - a - 15) >= 0 ) {
00611 QString uidv = cstr.mid(a + 15, b - a - 15);
00612
00613
00614 if( !mFolder->uidValidity().isEmpty() && mFolder->uidValidity() != uidv ) {
00615
00616
00617 mFolder->expunge();
00618 mFolder->setLastUid( 0 );
00619 mFolder->clearUidMap();
00620 }
00621 } else
00622 kdDebug(5006) << "No uidvalidity available for folder "
00623 << mFolder->name() << endl;
00624 }
00625
00626 mAccount->removeJob(it);
00627 delete this;
00628 }
00629
00630
00631 void CachedImapJob::renameFolder( const QString &newName )
00632 {
00633
00634 KURL urlSrc = mAccount->getUrl();
00635 urlSrc.setPath( mFolder->imapPath() );
00636
00637
00638 KURL urlDst = mAccount->getUrl();
00639 QString imapPath( mFolder->imapPath() );
00640
00641 imapPath.truncate( imapPath.length() - mFolder->folder()->name().length() - 1);
00642 imapPath += newName + '/';
00643 urlDst.setPath( imapPath );
00644
00645 ImapAccountBase::jobData jd( newName, mFolder->folder() );
00646 jd.path = imapPath;
00647
00648 KIO::SimpleJob *simpleJob = KIO::rename( urlSrc, urlDst, false );
00649 KIO::Scheduler::assignJobToSlave( mAccount->slave(), simpleJob );
00650 mAccount->insertJob( simpleJob, jd );
00651 connect( simpleJob, SIGNAL(result(KIO::Job *)),
00652 SLOT(slotRenameFolderResult(KIO::Job *)) );
00653 }
00654
00655 static void renameChildFolders( KMFolderDir* dir, const QString& oldPath,
00656 const QString& newPath )
00657 {
00658 if( dir ) {
00659 KMFolderNode *node = dir->first();
00660 while( node ) {
00661 if( !node->isDir() ) {
00662 KMFolderCachedImap* imapFolder =
00663 static_cast<KMFolderCachedImap*>(static_cast<KMFolder*>(node)->storage());
00664 if ( !imapFolder->imapPath().isEmpty() )
00665
00666 if( imapFolder->imapPath().find( oldPath ) == 0 ) {
00667 QString p = imapFolder->imapPath();
00668 p = p.mid( oldPath.length() );
00669 p.prepend( newPath );
00670 imapFolder->setImapPath( p );
00671 renameChildFolders( imapFolder->folder()->child(), oldPath, newPath );
00672 }
00673 }
00674 node = dir->next();
00675 }
00676 }
00677 }
00678
00679 void CachedImapJob::slotRenameFolderResult( KIO::Job *job )
00680 {
00681 KMAcctCachedImap::JobIterator it = mAccount->findJob(job);
00682 if ( it == mAccount->jobsEnd() ) {
00683 delete this;
00684 return;
00685 }
00686
00687
00688 if( job->error() ) {
00689
00690 QMap<QString, KMAcctCachedImap::RenamedFolder>::ConstIterator renit = mAccount->renamedFolders().find( mFolder->imapPath() );
00691 Q_ASSERT( renit != mAccount->renamedFolders().end() );
00692 if ( renit != mAccount->renamedFolders().end() ) {
00693 mFolder->folder()->setLabel( (*renit).mOldLabel );
00694 mAccount->removeRenamedFolder( mFolder->imapPath() );
00695 }
00696 mAccount->handleJobError( job, i18n( "Error while trying to rename folder %1" ).arg( mFolder->label() ) + '\n' );
00697 } else {
00698
00699
00700 QString oldName = mFolder->name();
00701 QString oldPath = mFolder->imapPath();
00702 mAccount->removeRenamedFolder( oldPath );
00703 mFolder->setImapPath( (*it).path );
00704 mFolder->FolderStorage::rename( (*it).url );
00705
00706 if( oldPath.endsWith( "/" ) ) oldPath.truncate( oldPath.length() -1 );
00707 QString newPath = mFolder->imapPath();
00708 if( newPath.endsWith( "/" ) ) newPath.truncate( newPath.length() -1 );
00709 renameChildFolders( mFolder->folder()->child(), oldPath, newPath );
00710 kmkernel->dimapFolderMgr()->contentsChanged();
00711
00712 mAccount->removeJob(it);
00713 }
00714 delete this;
00715 }
00716
00717 void CachedImapJob::slotListMessagesResult( KIO::Job * job )
00718 {
00719 KMAcctCachedImap::JobIterator it = mAccount->findJob(job);
00720 if ( it == mAccount->jobsEnd() ) {
00721 delete this;
00722 return;
00723 }
00724
00725 if (job->error()) {
00726 mErrorCode = job->error();
00727 mAccount->handleJobError( job, i18n( "Error while deleting messages on the server: " ) + '\n' );
00728 }
00729 else
00730 mAccount->removeJob(it);
00731
00732 delete this;
00733 }
00734
00735
00736 void CachedImapJob::setParentFolder( const KMFolderCachedImap* parent )
00737 {
00738 mParentFolder = const_cast<KMFolderCachedImap*>( parent );
00739 }
00740
00741 }
00742
00743 #include "cachedimapjob.moc"