00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 #include <kdebug.h>
00024 #include <dcopclient.h>
00025 #include <kapplication.h>
00026 #include <kdcopservicestarter.h>
00027 #include <klocale.h>
00028
00029 #include <libkcal/vcaldrag.h>
00030 #include <libkcal/vcalformat.h>
00031 #include <libkcal/exceptions.h>
00032 #include <libkcal/incidence.h>
00033 #include <libkcal/event.h>
00034 #include <libkcal/todo.h>
00035 #include <libkcal/journal.h>
00036
00037 #include <kabc/locknull.h>
00038
00039 #include <kresources/configwidget.h>
00040 #include <kresources/resource.h>
00041
00042 #include "kmailicalIface_stub.h"
00043
00044
00045 #include "resourceimapconfig.h"
00046 #include "resourceimap.h"
00047
00048 using namespace KCal;
00049
00050 static const QCString dcopObjectId = "KMailICalIface";
00051
00052 extern "C"
00053 {
00054 void *init_kcal_imap()
00055 {
00056 return new KRES::PluginFactory<ResourceIMAP,ResourceIMAPConfig>();
00057 }
00058 }
00059
00060
00061 ResourceIMAP::ResourceIMAP( const KConfig* config )
00062 : DCOPObject("ResourceIMAP"), ResourceCalendar( config )
00063 {
00064 if ( config ) {
00065 mServer = config->readEntry( "Servername" );
00066 }
00067 init();
00068
00069
00070 mKMailIcalIfaceStub = 0;
00071 kapp->dcopClient()->setNotifications( true );
00072 connect( kapp->dcopClient(), SIGNAL( applicationRemoved( const QCString& ) ),
00073 this, SLOT( unregisteredFromDCOP( const QCString& ) ) );
00074 }
00075
00076 void ResourceIMAP::writeConfig( KConfig* config )
00077 {
00078 ResourceCalendar::writeConfig( config );
00079 config->writeEntry( "Servername", mServer );
00080 }
00081
00082 void ResourceIMAP::init()
00083 {
00084 mSilent = false;
00085
00086 mDCOPClient = new DCOPClient();
00087 mDCOPClient->attach();
00088 mDCOPClient->registerAs( "resourceimap", true );
00089 }
00090
00091
00092 ResourceIMAP::~ResourceIMAP()
00093 {
00094 kapp->dcopClient()->setNotifications( false );
00095 delete mKMailIcalIfaceStub;
00096 close();
00097 delete mDCOPClient;
00098 }
00099
00100 bool ResourceIMAP::getIncidenceList( QStringList& lst, const QString& type )
00101 {
00102 if ( !connectToKMail() ) {
00103 kdError() << "DCOP error during incidences(QString)\n";
00104 return false;
00105 }
00106
00107 lst = mKMailIcalIfaceStub->incidences( type );
00108 if ( !mKMailIcalIfaceStub->ok() ) {
00109 kdError() << "Communication problem in ResourceIMAP::getIncidenceList()\n";
00110 return false;
00111 }
00112
00113 return true;
00114 }
00115
00116 bool ResourceIMAP::doOpen()
00117 {
00118 return true;
00119 }
00120
00121 bool ResourceIMAP::load()
00122 {
00123
00124
00125 return loadAllEvents() & loadAllTasks() & loadAllJournals();
00126 }
00127
00128 bool ResourceIMAP::loadAllEvents()
00129 {
00130
00131 QStringList lst;
00132 if ( !getIncidenceList( lst, "Calendar" ) )
00133
00134 return false;
00135
00136
00137 mCalendar.deleteAllEvents();
00138
00139
00140 for ( QStringList::Iterator it = lst.begin(); it != lst.end(); ++it ) {
00141 Incidence* i = parseIncidence( *it );
00142 if ( i ) {
00143 if ( i->type() == "Event" ) {
00144 mCalendar.addEvent(static_cast<Event*>(i));
00145 i->registerObserver( this );
00146 } else {
00147 kdDebug() << "Unknown incidence type " << i->type();
00148 delete i;
00149 }
00150 }
00151 }
00152
00153 return true;
00154 }
00155
00156 bool ResourceIMAP::loadAllTasks()
00157 {
00158
00159 QStringList lst;
00160 if ( !getIncidenceList( lst, "Task" ) )
00161
00162 return false;
00163
00164
00165 mCalendar.deleteAllTodos();
00166
00167
00168 for ( QStringList::Iterator it = lst.begin(); it != lst.end(); ++it ) {
00169 Incidence* i = parseIncidence( *it );
00170 if ( i ) {
00171 if ( i->type() == "Todo" ) {
00172 mCalendar.addTodo(static_cast<Todo*>(i));
00173 i->registerObserver( this );
00174 } else {
00175 kdDebug() << "Unknown incidence type " << i->type();
00176 delete i;
00177 }
00178 }
00179 }
00180
00181 return true;
00182 }
00183
00184 bool ResourceIMAP::loadAllJournals()
00185 {
00186
00187 QStringList lst;
00188 if ( !getIncidenceList( lst, "Journal" ) )
00189
00190 return false;
00191
00192
00193 mCalendar.deleteAllJournals();
00194
00195
00196 for ( QStringList::Iterator it = lst.begin(); it != lst.end(); ++it ) {
00197 Incidence* i = parseIncidence( *it );
00198 if ( i ) {
00199 if ( i->type() == "Journal" ) {
00200 mCalendar.addJournal(static_cast<Journal*>(i));
00201 i->registerObserver( this );
00202 } else {
00203 kdDebug() << "Unknown incidence type " << i->type();
00204 delete i;
00205 }
00206 }
00207 }
00208
00209 return true;
00210 }
00211
00212 bool ResourceIMAP::save()
00213 {
00214 return false;
00215 }
00216
00217 KABC::Lock *ResourceIMAP::lock()
00218 {
00219 return new KABC::LockNull( true );
00220 }
00221
00222
00223
00224
00225
00226 bool ResourceIMAP::addEvent(Event *anEvent)
00227 {
00228 mCalendar.addEvent(anEvent);
00229 anEvent->registerObserver( this );
00230
00231 if ( mSilent ) return true;
00232
00233
00234 if ( !connectToKMail() ) {
00235 kdError() << "DCOP error during addIncidence(QString)\n";
00236 return false;
00237 }
00238
00239 mCurrentUID = anEvent->uid();
00240 QString vCal = mFormat.createScheduleMessage( anEvent, Scheduler::Request );
00241 bool rc = mKMailIcalIfaceStub->addIncidence( "Calendar", mCurrentUID, vCal );
00242 mCurrentUID = QString::null;
00243
00244 if ( !mKMailIcalIfaceStub->ok() ) {
00245 kdError() << "Communication problem in ResourceIMAP::addEvent()\n";
00246 return false;
00247 }
00248
00249 return rc;
00250 }
00251
00252
00253 void ResourceIMAP::deleteEvent(Event *event)
00254 {
00255
00256 if ( !mSilent ) {
00257 if ( !connectToKMail() ) {
00258 kdError() << "DCOP error during "
00259 << "ResourceIMAP::deleteIncidence(QString)\n";
00260 } else {
00261 mCurrentUID = event->uid();
00262 mKMailIcalIfaceStub->deleteIncidence( "Calendar", mCurrentUID );
00263 }
00264 }
00265
00266 mCalendar.deleteEvent(event);
00267 mCurrentUID = QString::null;
00268 }
00269
00270
00271
00272
00273
00274
00275 Event *ResourceIMAP::event( const QString &uid )
00276 {
00277 return mCalendar.event(uid);
00278 }
00279
00280
00281
00282 Event::List ResourceIMAP::rawEventsForDate( const QDate &qd, bool sorted )
00283 {
00284 return mCalendar.rawEventsForDate( qd, sorted );
00285 }
00286
00287
00288 Event::List ResourceIMAP::rawEvents( const QDate &start, const QDate &end,
00289 bool inclusive )
00290 {
00291 return mCalendar.rawEvents( start, end, inclusive );
00292 }
00293
00294 Event::List ResourceIMAP::rawEventsForDate(const QDateTime &qdt)
00295 {
00296 return mCalendar.rawEventsForDate( qdt );
00297 }
00298
00299 Event::List ResourceIMAP::rawEvents()
00300 {
00301 return mCalendar.rawEvents();
00302 }
00303
00304
00305
00306
00307
00308 bool ResourceIMAP::addTodo(Todo *todo)
00309 {
00310 mCalendar.addTodo(todo);
00311 todo->registerObserver( this );
00312
00313 if ( mSilent ) return true;
00314
00315 if ( !connectToKMail() ) {
00316 kdError() << "DCOP error during addTodo(QString)\n";
00317 return false;
00318 }
00319
00320 mCurrentUID = todo->uid();
00321 QString vCal = mFormat.createScheduleMessage( todo, Scheduler::Request );
00322 bool rc = mKMailIcalIfaceStub->addIncidence( "Task", mCurrentUID, vCal );
00323 mCurrentUID = QString::null;
00324
00325 if ( !mKMailIcalIfaceStub->ok() ) {
00326 kdError() << "Communication problem in ResourceIMAP::addTodo()\n";
00327 return false;
00328 }
00329
00330 return rc;
00331 }
00332
00333 void ResourceIMAP::deleteTodo(Todo *todo)
00334 {
00335
00336 if ( !mSilent ) {
00337 if ( !connectToKMail() ) {
00338 kdError() << "DCOP error during ResourceIMAP::deleteTodo(QString)\n";
00339 } else {
00340 mCurrentUID = todo->uid();
00341 mKMailIcalIfaceStub->deleteIncidence( "Task", mCurrentUID );
00342 mCurrentUID = QString::null;
00343 }
00344 }
00345 mCalendar.deleteTodo(todo);
00346 }
00347
00348
00349
00350
00351
00352 Todo::List ResourceIMAP::rawTodos()
00353 {
00354 return mCalendar.rawTodos();
00355 }
00356
00357 Todo *ResourceIMAP::todo( const QString &uid )
00358 {
00359 return mCalendar.todo(uid);
00360 }
00361
00362 Todo::List ResourceIMAP::todos( const QDate &date )
00363 {
00364 return mCalendar.todos(date);
00365 }
00366
00367
00368
00369
00370
00371 bool ResourceIMAP::addJournal(Journal *journal)
00372 {
00373 mCalendar.addJournal(journal);
00374 journal->registerObserver( this );
00375
00376 if ( mSilent ) return true;
00377
00378
00379 if ( !connectToKMail() ) {
00380 kdError() << "DCOP error during addTodo(QString)\n";
00381 return false;
00382 }
00383
00384 mCurrentUID = journal->uid();
00385 QString vCal = mFormat.createScheduleMessage( journal, Scheduler::Request );
00386 bool rc = mKMailIcalIfaceStub->addIncidence( "Journal", mCurrentUID, vCal );
00387 mCurrentUID = QString::null;
00388
00389 if ( !mKMailIcalIfaceStub->ok() ) {
00390 kdError() << "Communication problem in ResourceIMAP::addJournal()\n";
00391 return false;
00392 }
00393
00394 return rc;
00395 }
00396
00397 void ResourceIMAP::deleteJournal(Journal *journal)
00398 {
00399 if( !journal )
00400 return;
00401
00402 if ( !mSilent ) {
00403 if ( !connectToKMail() ) {
00404 kdError() << "DCOP error during ResourceIMAP::deleteJournal(QString)\n";
00405 } else {
00406 mCurrentUID = journal->uid();
00407 mKMailIcalIfaceStub->deleteIncidence( "Journal", mCurrentUID );
00408 mCurrentUID = QString::null;
00409 }
00410 }
00411 mCalendar.deleteJournal(journal);
00412 }
00413
00414
00415 Journal *ResourceIMAP::journal(const QDate &date)
00416 {
00417 return mCalendar.journal(date);
00418 }
00419
00420 Journal *ResourceIMAP::journal(const QString &uid)
00421 {
00422 return mCalendar.journal(uid);
00423 }
00424
00425 Journal::List ResourceIMAP::journals()
00426 {
00427 return mCalendar.journals();
00428 }
00429
00430
00431
00432
00433
00434 Alarm::List ResourceIMAP::alarmsTo( const QDateTime &to )
00435 {
00436 return mCalendar.alarmsTo(to);
00437 }
00438
00439 Alarm::List ResourceIMAP::alarms( const QDateTime &from, const QDateTime &to )
00440 {
00441 return mCalendar.alarms( from, to );
00442 }
00443
00444
00445
00446
00447
00448
00449 void ResourceIMAP::update(IncidenceBase *incidencebase)
00450 {
00451 if ( !connectToKMail() ) {
00452 kdError() << "DCOP error during ResourceIMAP::update(QString)\n";
00453 return;
00454 }
00455
00456 QString type = incidencebase->type();
00457 if ( type == "Event" ) type = "Calendar";
00458 else if ( type == "Todo" ) type = "Task";
00459 else if ( type != "Journal" ) return;
00460
00461 incidencebase->setSyncStatus(Event::SYNCMOD);
00462 incidencebase->setLastModified(QDateTime::currentDateTime());
00463
00464
00465
00466
00467
00468 mCurrentUID = incidencebase->uid();
00469 QString vCal = mFormat.createScheduleMessage( incidencebase,
00470 Scheduler::Request );
00471 mKMailIcalIfaceStub->deleteIncidence( type, mCurrentUID );
00472 mKMailIcalIfaceStub->addIncidence( type, mCurrentUID, vCal );
00473 mCurrentUID = QString::null;
00474
00475 if ( !mKMailIcalIfaceStub->ok() ) {
00476 kdError() << "Communication problem in ResourceIMAP::addJournal()\n";
00477 }
00478 }
00479
00480 KCal::Incidence* ResourceIMAP::parseIncidence( const QString& str )
00481 {
00482 Incidence* i = mFormat.fromString( str );
00483 return i;
00484 }
00485
00486 bool ResourceIMAP::addIncidence( const QString& type, const QString& ical )
00487 {
00488 if( type != "Calendar" && type != "Task" && type != "Journal" )
00489
00490 return false;
00491
00492 Incidence* i = parseIncidence( ical );
00493 if ( !i ) return false;
00494
00495 if ( !mCurrentUID.isNull() && mCurrentUID == i->uid() ) return true;
00496
00497 mSilent = true;
00498 if ( type == "Calendar" && i->type() == "Event" ) {
00499 addEvent( static_cast<Event*>(i) );
00500 emit resourceChanged( this );
00501 } else if ( type == "Task" && i->type() == "Todo" ) {
00502 addTodo( static_cast<Todo*>(i) );
00503 emit resourceChanged( this );
00504 } else if ( type == "Journal" && i->type() == "Journal" ) {
00505 addJournal( static_cast<Journal*>(i) );
00506 emit resourceChanged( this );
00507 }
00508 mSilent = false;
00509
00510 return true;
00511 }
00512
00513 void ResourceIMAP::deleteIncidence( const QString& type, const QString& uid )
00514 {
00515 if( type != "Calendar" && type != "Task" && type != "Journal" )
00516
00517 return;
00518
00519
00520 if ( !mCurrentUID.isNull() && mCurrentUID == uid ) return;
00521
00522 mSilent = true;
00523 if ( type == "Calendar" ) {
00524 Event* e = event( uid );
00525 if( e ) {
00526 deleteEvent( e );
00527 emit resourceChanged( this );
00528 }
00529 } else if ( type == "Task" ) {
00530 Todo* t = todo( uid );
00531 if( t ) {
00532 deleteTodo( t );
00533 emit resourceChanged( this );
00534 }
00535 } else if ( type == "Journal" ) {
00536 Journal* j = journal( uid );
00537 if( j ) {
00538 deleteJournal( j );
00539 emit resourceChanged( this );
00540 }
00541 }
00542 mSilent = false;
00543 }
00544
00545 void ResourceIMAP::slotRefresh( const QString& type )
00546 {
00547 if ( type == "Calendar" )
00548 loadAllEvents();
00549 else if ( type == "Task" )
00550 loadAllTasks();
00551 else if ( type == "Journal" )
00552 loadAllJournals();
00553 }
00554
00555 bool ResourceIMAP::connectToKMail() const
00556 {
00557 if ( !mKMailIcalIfaceStub ) {
00558 QString error;
00559 QCString dcopService;
00560 int result = KDCOPServiceStarter::self()->
00561 findServiceFor( "DCOP/ResourceBackend/IMAP", QString::null,
00562 QString::null, &error, &dcopService );
00563 if ( result != 0 ) {
00564 kdDebug(5800) << "Couldn't connect to the IMAP resource backend\n";
00565
00566 return false;
00567 }
00568
00569 mKMailIcalIfaceStub = new KMailICalIface_stub( kapp->dcopClient(),
00570 dcopService, dcopObjectId );
00571
00572
00573 if ( !connectKMailSignal( "incidenceAdded(QString,QString)",
00574 "addIncidence(QString,QString)" ) ) {
00575 kdError() << "DCOP connection to incidenceAdded failed" << endl;
00576 }
00577 if ( !connectKMailSignal( "incidenceDeleted(QString,QString)",
00578 "deleteIncidence(QString,QString)" ) ) {
00579 kdError() << "DCOP connection to incidenceDeleted failed" << endl;
00580 }
00581 if ( !connectKMailSignal( "signalRefresh(QString)",
00582 "slotRefresh(QString)" ) ) {
00583 kdError() << "DCOP connection to signalRefresh failed" << endl;
00584 }
00585 }
00586
00587 return ( mKMailIcalIfaceStub != 0 );
00588 }
00589
00590 bool ResourceIMAP::connectKMailSignal( const QCString& signal,
00591 const QCString& method ) const
00592 {
00593 ResourceIMAP* _this = const_cast<ResourceIMAP*>( this );
00594 return _this->connectDCOPSignal( "kmail", dcopObjectId, signal, method,
00595 false );
00596 }
00597
00598 void ResourceIMAP::unregisteredFromDCOP( const QCString& appId )
00599 {
00600 if ( mKMailIcalIfaceStub && mKMailIcalIfaceStub->app() == appId ) {
00601
00602
00603 delete mKMailIcalIfaceStub;
00604 mKMailIcalIfaceStub = 0;
00605 }
00606 }
00607
00608
00609 void ResourceIMAP::setTimeZoneId( const QString& tzid )
00610 {
00611 mCalendar.setTimeZoneId( tzid );
00612 }
00613
00614 #include "resourceimap.moc"
00615