summaryrefslogtreecommitdiffstats
path: root/libkcal/scheduler.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'libkcal/scheduler.cpp')
-rw-r--r--libkcal/scheduler.cpp444
1 files changed, 444 insertions, 0 deletions
diff --git a/libkcal/scheduler.cpp b/libkcal/scheduler.cpp
new file mode 100644
index 000000000..5a29ad8c8
--- /dev/null
+++ b/libkcal/scheduler.cpp
@@ -0,0 +1,444 @@
+/*
+ This file is part of libkcal.
+
+ Copyright (c) 2001,2004 Cornelius Schumacher <schumacher@kde.org>
+ Copyright (C) 2004 Reinhold Kainhofer <reinhold@kainhofer.com>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public
+ License as published by the Free Software Foundation; either
+ version 2 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public License
+ along with this library; see the file COPYING.LIB. If not, write to
+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
+*/
+
+#include <klocale.h>
+#include <kdebug.h>
+#include <kmessagebox.h>
+#include <kstandarddirs.h>
+
+#include "event.h"
+#include "todo.h"
+#include "freebusy.h"
+#include "icalformat.h"
+#include "calendar.h"
+#include "freebusycache.h"
+
+#include "scheduler.h"
+
+using namespace KCal;
+
+ScheduleMessage::ScheduleMessage(IncidenceBase *incidence,int method,ScheduleMessage::Status status)
+{
+ mIncidence = incidence;
+ mMethod = method;
+ mStatus = status;
+}
+
+QString ScheduleMessage::statusName(ScheduleMessage::Status status)
+{
+ switch (status) {
+ case PublishUpdate:
+ return i18n("Updated Publish");
+ case PublishNew:
+ return i18n("Publish");
+ case Obsolete:
+ return i18n("Obsolete");
+ case RequestNew:
+ return i18n("New Request");
+ case RequestUpdate:
+ return i18n("Updated Request");
+ default:
+ return i18n("Unknown Status: %1").arg(QString::number(status));
+ }
+}
+
+struct Scheduler::Private
+{
+ Private() : mFreeBusyCache( 0 ) {}
+
+ FreeBusyCache *mFreeBusyCache;
+};
+
+Scheduler::Scheduler(Calendar *calendar)
+{
+ mCalendar = calendar;
+ mFormat = new ICalFormat();
+ mFormat->setTimeZone( calendar->timeZoneId(), !calendar->isLocalTime() );
+
+ d = new Private;
+}
+
+Scheduler::~Scheduler()
+{
+ delete d;
+
+ delete mFormat;
+}
+
+void Scheduler::setFreeBusyCache( FreeBusyCache *c )
+{
+ d->mFreeBusyCache = c;
+}
+
+FreeBusyCache *Scheduler::freeBusyCache() const
+{
+ return d->mFreeBusyCache;
+}
+
+bool Scheduler::acceptTransaction(IncidenceBase *incidence,Method method,ScheduleMessage::Status status)
+{
+ kdDebug(5800) << "Scheduler::acceptTransaction, method="
+ << methodName( method ) << endl;
+
+ switch (method) {
+ case Publish:
+ return acceptPublish(incidence, status, method);
+ case Request:
+ return acceptRequest(incidence, status);
+ case Add:
+ return acceptAdd(incidence, status);
+ case Cancel:
+ return acceptCancel(incidence, status);
+ case Declinecounter:
+ return acceptDeclineCounter(incidence, status);
+ case Reply:
+ return acceptReply(incidence, status, method);
+ case Refresh:
+ return acceptRefresh(incidence, status);
+ case Counter:
+ return acceptCounter(incidence, status);
+ default:
+ break;
+ }
+ deleteTransaction(incidence);
+ return false;
+}
+
+QString Scheduler::methodName(Method method)
+{
+ switch (method) {
+ case Publish:
+ return QString::fromLatin1("Publish");
+ case Request:
+ return QString::fromLatin1("Request");
+ case Refresh:
+ return QString::fromLatin1("Refresh");
+ case Cancel:
+ return QString::fromLatin1("Cancel");
+ case Add:
+ return QString::fromLatin1("Add");
+ case Reply:
+ return QString::fromLatin1("Reply");
+ case Counter:
+ return QString::fromLatin1("Counter");
+ case Declinecounter:
+ return QString::fromLatin1("Decline Counter");
+ default:
+ return QString::fromLatin1("Unknown");
+ }
+}
+
+QString Scheduler::translatedMethodName(Method method)
+{
+ switch (method) {
+ case Publish:
+ return i18n("Publish");
+ case Request:
+ return i18n("Request");
+ case Refresh:
+ return i18n("Refresh");
+ case Cancel:
+ return i18n("Cancel");
+ case Add:
+ return i18n("Add");
+ case Reply:
+ return i18n("Reply");
+ case Counter:
+ return i18n("counter proposal","Counter");
+ case Declinecounter:
+ return i18n("decline counter proposal","Decline Counter");
+ default:
+ return i18n("Unknown");
+ }
+}
+
+bool Scheduler::deleteTransaction(IncidenceBase *)
+{
+ return true;
+}
+
+bool Scheduler::acceptPublish( IncidenceBase *newIncBase,
+ ScheduleMessage::Status status, Method method )
+{
+ if( newIncBase->type() == "FreeBusy" ) {
+ return acceptFreeBusy( newIncBase, method );
+ }
+
+ bool res = false;
+ kdDebug(5800) << "Scheduler::acceptPublish, status="
+ << ScheduleMessage::statusName( status ) << endl;
+ Incidence *newInc = static_cast<Incidence *>( newIncBase );
+ Incidence *calInc = mCalendar->incidence( newIncBase->uid() );
+ switch ( status ) {
+ case ScheduleMessage::Unknown:
+ case ScheduleMessage::PublishNew:
+ case ScheduleMessage::PublishUpdate:
+ res = true;
+ if ( calInc ) {
+ if ( (newInc->revision() > calInc->revision()) ||
+ (newInc->revision() == calInc->revision() &&
+ newInc->lastModified() > calInc->lastModified() ) ) {
+ mCalendar->deleteIncidence( calInc );
+ } else
+ res = false;
+ }
+ if ( res )
+ mCalendar->addIncidence( newInc );
+ break;
+ case ScheduleMessage::Obsolete:
+ res = true;
+ break;
+ default:
+ break;
+ }
+ deleteTransaction( newIncBase );
+ return res;
+}
+
+bool Scheduler::acceptRequest(IncidenceBase *newIncBase, ScheduleMessage::Status /* status */)
+{
+ if (newIncBase->type()=="FreeBusy") {
+ // reply to this request is handled in korganizer's incomingdialog
+ return true;
+ }
+ Incidence *newInc = dynamic_cast<Incidence *>( newIncBase );
+ if ( newInc ) {
+ bool res = true;
+ Incidence *exInc = mCalendar->incidenceFromSchedulingID( newIncBase->uid() );
+ if ( exInc ) {
+ res = false;
+ if ( (newInc->revision() > exInc->revision()) ||
+ (newInc->revision() == exInc->revision() &&
+ newInc->lastModified()>exInc->lastModified()) ) {
+ mCalendar->deleteIncidence( exInc );
+ res = true;
+ }
+ }
+ if ( res ) {
+ // Move the uid to be the schedulingID and make a unique UID
+ newInc->setSchedulingID( newInc->uid() );
+ newInc->setUid( CalFormat::createUniqueId() );
+
+ mCalendar->addIncidence(newInc);
+ }
+ deleteTransaction( newIncBase );
+ return res;
+ }
+ return false;
+}
+
+bool Scheduler::acceptAdd(IncidenceBase *incidence,ScheduleMessage::Status /* status */)
+{
+ deleteTransaction(incidence);
+ return false;
+}
+
+bool Scheduler::acceptCancel(IncidenceBase *incidence,ScheduleMessage::Status /* status */)
+{
+ bool ret = false;
+ const IncidenceBase *toDelete = mCalendar->incidenceFromSchedulingID( incidence->uid() );
+ if ( toDelete ) {
+ Event *even = mCalendar->event(toDelete->uid());
+ if (even) {
+ mCalendar->deleteEvent(even);
+ ret = true;
+ } else {
+ Todo *todo = mCalendar->todo(toDelete->uid());
+ if (todo) {
+ mCalendar->deleteTodo(todo);
+ ret = true;
+ }
+ }
+ }
+ deleteTransaction(incidence);
+ return ret;
+}
+
+bool Scheduler::acceptDeclineCounter(IncidenceBase *incidence,ScheduleMessage::Status /* status */)
+{
+ deleteTransaction(incidence);
+ return false;
+}
+
+//bool Scheduler::acceptFreeBusy(Incidence *incidence,ScheduleMessage::Status status)
+//{
+// deleteTransaction(incidence);
+// return false;
+//}
+
+bool Scheduler::acceptReply(IncidenceBase *incidence,ScheduleMessage::Status /* status */, Method method)
+{
+ if(incidence->type()=="FreeBusy") {
+ return acceptFreeBusy(incidence, method);
+ }
+ bool ret = false;
+ Event *ev = mCalendar->event(incidence->uid());
+ Todo *to = mCalendar->todo(incidence->uid());
+
+ // try harder to find the correct incidence
+ if ( !ev && !to ) {
+ const Incidence::List list = mCalendar->incidences();
+ for ( Incidence::List::ConstIterator it = list.begin(), end = list.end(); it != end; ++it ) {
+ if ( (*it)->schedulingID() == incidence->uid() ) {
+ ev = dynamic_cast<Event*>( *it );
+ to = dynamic_cast<Todo*>( *it );
+ break;
+ }
+ }
+ }
+
+ if (ev || to) {
+ //get matching attendee in calendar
+ kdDebug(5800) << "Scheduler::acceptTransaction match found!" << endl;
+ Attendee::List attendeesIn = incidence->attendees();
+ Attendee::List attendeesEv;
+ Attendee::List attendeesNew;
+ if (ev) attendeesEv = ev->attendees();
+ if (to) attendeesEv = to->attendees();
+ Attendee::List::ConstIterator inIt;
+ Attendee::List::ConstIterator evIt;
+ for ( inIt = attendeesIn.begin(); inIt != attendeesIn.end(); ++inIt ) {
+ Attendee *attIn = *inIt;
+ bool found = false;
+ for ( evIt = attendeesEv.begin(); evIt != attendeesEv.end(); ++evIt ) {
+ Attendee *attEv = *evIt;
+ if (attIn->email().lower()==attEv->email().lower()) {
+ //update attendee-info
+ kdDebug(5800) << "Scheduler::acceptTransaction update attendee" << endl;
+ attEv->setStatus(attIn->status());
+ attEv->setDelegate(attIn->delegate());
+ attEv->setDelegator(attIn->delegator());
+ ret = true;
+ found = true;
+ }
+ }
+ if ( !found && attIn->status() != Attendee::Declined )
+ attendeesNew.append( attIn );
+ }
+
+ bool attendeeAdded = false;
+ for ( Attendee::List::ConstIterator it = attendeesNew.constBegin(); it != attendeesNew.constEnd(); ++it ) {
+ Attendee* attNew = *it;
+ QString msg = i18n("%1 wants to attend %2 but was not invited.").arg( attNew->fullName() )
+ .arg( ev ? ev->summary() : to->summary() );
+ if ( !attNew->delegator().isEmpty() )
+ msg = i18n("%1 wants to attend %2 on behalf of %3.").arg( attNew->fullName() )
+ .arg( ev ? ev->summary() : to->summary() )
+ .arg( attNew->delegator() );
+ if ( KMessageBox::questionYesNo( 0, msg, i18n("Uninvited attendee"),
+ KGuiItem(i18n("Accept Attendance")), KGuiItem(i18n("Reject Attendance")) )
+ != KMessageBox::Yes )
+ {
+ KCal::Incidence *cancel = dynamic_cast<Incidence*>( incidence );
+ if ( cancel )
+ cancel->addComment( i18n( "The organizer rejected your attendance at this meeting." ) );
+ performTransaction( cancel ? cancel : incidence, Scheduler::Cancel, attNew->fullName() );
+ delete cancel;
+ continue;
+ }
+
+ Attendee *a = new Attendee( attNew->name(), attNew->email(), attNew->RSVP(),
+ attNew->status(), attNew->role(), attNew->uid() );
+ a->setDelegate( attNew->delegate() );
+ a->setDelegator( attNew->delegator() );
+ if ( ev )
+ ev->addAttendee( a );
+ else if ( to )
+ to->addAttendee( a );
+ ret = true;
+ attendeeAdded = true;
+ }
+
+ // send update about new participants
+ if ( attendeeAdded ) {
+ if ( ev ) {
+ ev->setRevision( ev->revision() + 1 );
+ performTransaction( ev, Scheduler::Request );
+ }
+ if ( to ) {
+ to->setRevision( ev->revision() + 1 );
+ performTransaction( to, Scheduler::Request );
+ }
+ }
+
+ if ( ret ) {
+ // We set at least one of the attendees, so the incidence changed
+ // Note: This should not result in a sequence number bump
+ if ( ev )
+ ev->updated();
+ else if ( to )
+ to->updated();
+ }
+ if ( to ) {
+ // for VTODO a REPLY can be used to update the completion status of
+ // a task. see RFC2446 3.4.3
+ Todo *update = dynamic_cast<Todo*> ( incidence );
+ Q_ASSERT( update );
+ if ( update && ( to->percentComplete() != update->percentComplete() ) ) {
+ to->setPercentComplete( update->percentComplete() );
+ to->updated();
+ }
+ }
+ } else
+ kdError(5800) << "No incidence for scheduling\n";
+ if (ret) deleteTransaction(incidence);
+ return ret;
+}
+
+bool Scheduler::acceptRefresh(IncidenceBase *incidence,ScheduleMessage::Status /* status */)
+{
+ // handled in korganizer's IncomingDialog
+ deleteTransaction(incidence);
+ return false;
+}
+
+bool Scheduler::acceptCounter(IncidenceBase *incidence,ScheduleMessage::Status /* status */)
+{
+ deleteTransaction(incidence);
+ return false;
+}
+
+bool Scheduler::acceptFreeBusy(IncidenceBase *incidence, Method method)
+{
+ if ( !d->mFreeBusyCache ) {
+ kdError() << "KCal::Scheduler: no FreeBusyCache." << endl;
+ return false;
+ }
+
+ FreeBusy *freebusy = static_cast<FreeBusy *>(incidence);
+
+ kdDebug(5800) << "acceptFreeBusy:: freeBusyDirName: " << freeBusyDir() << endl;
+
+ Person from;
+ if(method == Scheduler::Publish) {
+ from = freebusy->organizer();
+ }
+ if((method == Scheduler::Reply) && (freebusy->attendeeCount() == 1)) {
+ Attendee *attendee = freebusy->attendees().first();
+ from = attendee->email();
+ }
+
+ if ( !d->mFreeBusyCache->saveFreeBusy( freebusy, from ) ) return false;
+
+ deleteTransaction(incidence);
+ return true;
+}