kmail

copyfolderjob.cpp

00001 
00029 #include "copyfolderjob.h"
00030 #include "folderstorage.h"
00031 #include "kmacctcachedimap.h"
00032 #include "kmfoldercachedimap.h"
00033 #include "kmfolder.h"
00034 #include "kmfolderdir.h"
00035 #include "kmfoldertype.h"
00036 #include "kmfoldermgr.h"
00037 #include "kmcommands.h"
00038 #include "kmmsgbase.h"
00039 #include "undostack.h"
00040 
00041 #include <kdebug.h>
00042 #include <klocale.h>
00043 #include <config.h>
00044 
00045 using namespace KMail;
00046 
00047 CopyFolderJob::CopyFolderJob( FolderStorage* const storage, KMFolderDir* const newParent )
00048  : FolderJob( 0, tOther, (storage ? storage->folder() : 0) ),
00049    mStorage( storage ), mNewParent( newParent ),
00050    mNewFolder( 0 ), mChildFolderNodeIterator( *mStorage->folder()->createChildFolder() ),
00051    mNextChildFolder( 0 )
00052 {
00053   mStorage->open("copyfolder");
00054 }
00055 
00056 CopyFolderJob::~CopyFolderJob()
00057 {
00058   kdDebug(5006) << k_funcinfo << endl;
00059   if ( mNewFolder )
00060     mNewFolder->setMoveInProgress( false );
00061   if ( mStorage )
00062     mStorage->close("copyfolder");
00063 }
00064 
00065 /*
00066  * The basic strategy is to first create the target folder, then copy all the mail
00067  * from the source to the target folder, then recurse for each of the folder's children
00068  */
00069 void CopyFolderJob::execute()
00070 {
00071   if ( createTargetDir() ) {
00072     copyMessagesToTargetDir();
00073   }
00074 }
00075 
00076 void CopyFolderJob::copyMessagesToTargetDir()
00077 {
00078   // Hmmmm. Tasty hack. Can I have fries with that?
00079   mStorage->blockSignals( true );
00080   // move all messages to the new folder
00081   QPtrList<KMMsgBase> msgList;
00082   for ( int i = 0; i < mStorage->count(); i++ )
00083   {
00084     const KMMsgBase* msgBase = mStorage->getMsgBase( i );
00085     assert( msgBase );
00086     msgList.append( msgBase );
00087   }
00088   if ( msgList.count() == 0 ) {
00089     slotCopyNextChild(); // no contents, check subfolders
00090     mStorage->blockSignals( false );
00091   } else {
00092     KMCommand *command = new KMCopyCommand( mNewFolder, msgList );
00093     connect( command, SIGNAL( completed( KMCommand * ) ),
00094         this, SLOT( slotCopyCompleted( KMCommand * ) ) );
00095     command->start();
00096   }
00097 }
00098 
00099 void CopyFolderJob::slotCopyCompleted( KMCommand* command )
00100 {
00101   kdDebug(5006) << k_funcinfo << (command?command->result():0) << endl;
00102   disconnect( command, SIGNAL( completed( KMCommand * ) ),
00103       this, SLOT( slotCopyCompleted( KMCommand * ) ) );
00104 
00105   mStorage->blockSignals( false );
00106 
00107   if ( command && command->result() != KMCommand::OK ) {
00108     rollback();
00109     return;
00110   }
00111   // if we have children, recurse
00112   if ( mStorage->folder()->child() ) {
00113     slotCopyNextChild();
00114   } else {
00115     emit folderCopyComplete( true );
00116     deleteLater();
00117   }
00118 }
00119 
00120 void CopyFolderJob::slotCopyNextChild( bool success )
00121 {
00122   //kdDebug(5006) << k_funcinfo << endl;
00123   if ( mNextChildFolder )
00124     mNextChildFolder->close("copyfoldernext"); // refcount
00125   // previous sibling failed
00126   if ( !success ) {
00127     kdDebug(5006) << "Failed to copy one subfolder, let's not continue:  " << mNewFolder->prettyURL() << endl;
00128     rollback();
00129     emit folderCopyComplete( false );
00130     deleteLater();
00131   }
00132 
00133   KMFolderNode* node = mChildFolderNodeIterator.current();
00134   while ( node && node->isDir() ) {
00135     ++mChildFolderNodeIterator;
00136     node = mChildFolderNodeIterator.current();
00137   }
00138   if ( node ) {
00139     mNextChildFolder = static_cast<KMFolder*>(node);
00140     ++mChildFolderNodeIterator;
00141   } else {
00142     // no more children, we are done
00143     emit folderCopyComplete( true );
00144     deleteLater();
00145     return;
00146   }
00147 
00148   KMFolderDir * const dir = mNewFolder->createChildFolder();
00149   if ( !dir ) {
00150     kdDebug(5006) << "Failed to create subfolders of:  " << mNewFolder->prettyURL() << endl;
00151     emit folderCopyComplete( false );
00152     deleteLater();
00153     return;
00154   }
00155   // let it do its thing and report back when we are ready to do the next sibling
00156   mNextChildFolder->open("copyfoldernext"); // refcount
00157   FolderJob* job = new CopyFolderJob( mNextChildFolder->storage(), dir);
00158   connect( job, SIGNAL( folderCopyComplete( bool ) ),
00159            this, SLOT( slotCopyNextChild( bool ) ) );
00160   job->start();
00161 }
00162 
00163 
00164 // FIXME factor into CreateFolderJob and make async, so it works with online imap
00165 // (create folder code taken from newfolderdialog.cpp)
00166 bool CopyFolderJob::createTargetDir()
00167 {
00168   // get the default mailbox type
00169   KConfig * const config = KMKernel::config();
00170   KConfigGroupSaver saver(config, "General");
00171   int deftype = config->readNumEntry("default-mailbox-format", 1);
00172   if ( deftype < 0 || deftype > 1 ) deftype = 1;
00173 
00174   // the type of the new folder
00175   KMFolderType typenew =
00176     ( deftype == 0 ) ? KMFolderTypeMbox : KMFolderTypeMaildir;
00177   if ( mNewParent->owner() )
00178     typenew = mNewParent->owner()->folderType();
00179 
00180   bool success = false, waitForFolderCreation = false;
00181 
00182   if ( mNewParent->owner() && mNewParent->owner()->folderType() == KMFolderTypeImap ) {
00183     KMFolderImap* selectedStorage = static_cast<KMFolderImap*>( mNewParent->owner()->storage() );
00184     KMAcctImap *anAccount = selectedStorage->account();
00185     // check if a connection is available BEFORE creating the folder
00186     if (anAccount->makeConnection() == ImapAccountBase::Connected) {
00187       mNewFolder = kmkernel->imapFolderMgr()->createFolder( mStorage->folder()->name(), false, typenew, mNewParent );
00188       if ( mNewFolder ) {
00189         QString imapPath;
00190         imapPath = anAccount->createImapPath( selectedStorage->imapPath(), mStorage->folder()->name() );
00191         KMFolderImap* newStorage = static_cast<KMFolderImap*>( mNewFolder->storage() );
00192         connect( selectedStorage, SIGNAL(folderCreationResult(const QString&, bool)),
00193                  this, SLOT(folderCreationDone(const QString&, bool)) );
00194         selectedStorage->createFolder(mStorage->folder()->name(), QString::null); // create it on the server
00195         newStorage->initializeFrom( selectedStorage, imapPath, QString::null );
00196         static_cast<KMFolderImap*>(mNewParent->owner()->storage())->setAccount( selectedStorage->account() );
00197         waitForFolderCreation = true;
00198         success = true;
00199       }
00200     }
00201   } else if ( mNewParent->owner() && mNewParent->owner()->folderType() == KMFolderTypeCachedImap ) {
00202     mNewFolder = kmkernel->dimapFolderMgr()->createFolder( mStorage->folder()->name(), false, typenew, mNewParent );
00203     if ( mNewFolder ) {
00204       KMFolderCachedImap* selectedStorage = static_cast<KMFolderCachedImap*>( mNewParent->owner()->storage() );
00205       KMFolderCachedImap* newStorage = static_cast<KMFolderCachedImap*>( mNewFolder->storage() );
00206       newStorage->initializeFrom( selectedStorage );
00207       success = true;
00208     }
00209   } else {
00210     // local folder
00211     mNewFolder = kmkernel->folderMgr()->createFolder(mStorage->folder()->name(), false, typenew, mNewParent );
00212     if ( mNewFolder )
00213       success = true;
00214   }
00215 
00216   if ( !success ) {
00217       kdWarning(5006) << k_funcinfo << "could not create folder" << endl;
00218       emit folderCopyComplete( false );
00219       deleteLater();
00220       return false;
00221   }
00222 
00223   mNewFolder->setMoveInProgress( true );
00224 
00225   // inherit the folder type
00226   // FIXME we should probably copy over most if not all settings
00227   mNewFolder->storage()->setContentsType( mStorage->contentsType(), true /*quiet*/ );
00228   mNewFolder->storage()->writeConfig();
00229   kdDebug(5006)<< "CopyJob::createTargetDir - " << mStorage->folder()->idString()
00230     << " |=> " << mNewFolder->idString() << endl;
00231   return !waitForFolderCreation;
00232 }
00233 
00234 
00235 void CopyFolderJob::rollback()
00236 {
00237   // copy failed - rollback the last transaction
00238 //   kmkernel->undoStack()->undo();
00239   // .. and delete the new folder
00240   if ( mNewFolder ) {
00241     if ( mNewFolder->folderType() == KMFolderTypeImap )
00242     {
00243       kmkernel->imapFolderMgr()->remove( mNewFolder );
00244     } else if ( mNewFolder->folderType() == KMFolderTypeCachedImap )
00245     {
00246       // tell the account (see KMFolderCachedImap::listDirectory2)
00247       KMFolderCachedImap* folder = static_cast<KMFolderCachedImap*>(mNewFolder->storage());
00248       KMAcctCachedImap* acct = folder->account();
00249       if ( acct )
00250         acct->addDeletedFolder( folder->imapPath() );
00251       kmkernel->dimapFolderMgr()->remove( mNewFolder );
00252     } else if ( mNewFolder->folderType() == KMFolderTypeSearch )
00253     {
00254       // invalid
00255       kdWarning(5006) << k_funcinfo << "cannot remove a search folder" << endl;
00256     } else {
00257       kmkernel->folderMgr()->remove( mNewFolder );
00258     }
00259   }
00260 
00261   emit folderCopyComplete( false );
00262   deleteLater();
00263 }
00264 
00265 void CopyFolderJob::folderCreationDone(const QString & name, bool success)
00266 {
00267   if ( mStorage->folder()->name() != name )
00268     return; // not our business
00269   kdDebug(5006) << k_funcinfo << success << endl;
00270 
00271   if ( !success ) {
00272     rollback();
00273   } else {
00274     copyMessagesToTargetDir();
00275   }
00276 }
00277 #include "copyfolderjob.moc"
KDE Home | KDE Accessibility Home | Description of Access Keys