Differential D28560 Diff 79580 resources/google-groupware/calendarhandler.cpp

Changeset View

Standalone View

View Options

resources/google-groupware/calendarhandler.cpp

  • This file was added.
1​/*
2​ Copyright (C) 2011-2013 Daniel Vrátil <dvratil@redhat.com>
3​ 2020 Igor Poboiko <igor.poboiko@gmail.com>
4​
5​ This program is free software: you can redistribute it and/or modify
6​ it under the terms of the GNU General Public License as published by
7​ the Free Software Foundation, either version 3 of the License, or
8​ (at your option) any later version.
9​
10​ This program is distributed in the hope that it will be useful,
11​ but WITHOUT ANY WARRANTY; without even the implied warranty of
12​ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13​ GNU General Public License for more details.
14​
15​ You should have received a copy of the GNU General Public License
16​ along with this program. If not, see <https://www.gnu.org/licenses/>.
17​*/
18​
19​#include "calendarhandler.h"
20​#include "defaultreminderattribute.h"
21​#include "googleresource.h"
22​#include "googlesettings.h"
23​
24​#include <AkonadiCore/CollectionColorAttribute>
25​#include <AkonadiCore/CollectionModifyJob>
26​#include <AkonadiCore/EntityDisplayAttribute>
27​#include <AkonadiCore/ItemModifyJob>
28​#include <Akonadi/Calendar/BlockAlarmsAttribute>
29​
30​#include <KGAPI/Account>
31​#include <KGAPI/Calendar/Calendar>
32​#include <KGAPI/Calendar/CalendarCreateJob>
33​#include <KGAPI/Calendar/CalendarDeleteJob>
34​#include <KGAPI/Calendar/CalendarFetchJob>
35​#include <KGAPI/Calendar/CalendarModifyJob>
36​#include <KGAPI/Calendar/Event>
37​#include <KGAPI/Calendar/EventCreateJob>
38​#include <KGAPI/Calendar/EventDeleteJob>
39​#include <KGAPI/Calendar/EventFetchJob>
40​#include <KGAPI/Calendar/EventModifyJob>
41​#include <KGAPI/Calendar/EventMoveJob>
42​#include <KGAPI/Calendar/FreeBusyQueryJob>
43​
44​#include <KCalendarCore/Calendar>
45​#include <KCalendarCore/FreeBusy>
46​#include <KCalendarCore/ICalFormat>
47​
48​#include "googlecalendar_debug.h"
49​
50​using namespace KGAPI2;
51​using namespace Akonadi;
52​
53​static constexpr uint32_t KGAPIEventVersion = 1;
54​
55​QString CalendarHandler::mimetype()
56​{
57​ return KCalendarCore::Event::eventMimeType();
58​}
59​
60​bool CalendarHandler::canPerformTask(const Item &item)
61​{
62​ return m_resource->canPerformTask<KCalendarCore::Event::Ptr>(item, mimetype());
63​}
64​
65​void CalendarHandler::setupCollection(Collection &collection, const CalendarPtr &calendar)
66​{
67​ collection.setContentMimeTypes({ mimetype() });
68​ collection.setName(calendar->uid());
69​ collection.setParentCollection(m_resource->rootCollection());
70​ collection.setRemoteId(calendar->uid());
71​ if (calendar->editable()) {
72​ collection.setRights(Collection::CanChangeCollection
73​ |Collection::CanDeleteCollection
74​ |Collection::CanCreateItem
75​ |Collection::CanChangeItem
76​ |Collection::CanDeleteItem);
77​ } else {
78​ collection.setRights(Collection::ReadOnly);
79​ }
80​ // TODO: for some reason, KOrganizer creates virtual collections
81​ //newCollection.setVirtual(false);
82​ // Setting icon
83​ auto attr = collection.attribute<EntityDisplayAttribute>(Collection::AddIfMissing);
84​ attr->setDisplayName(calendar->title());
85​ attr->setIconName(QStringLiteral("view-calendar"));
86​ // Setting color
87​ if (calendar->backgroundColor().isValid()) {
88​ auto colorAttr = collection.attribute<CollectionColorAttribute>(Collection::AddIfMissing);
89​ colorAttr->setColor(calendar->backgroundColor());
90​ }
91​ // Setting default remoinders
92​ auto reminderAttr = collection.attribute<DefaultReminderAttribute>(Collection::AddIfMissing);
93​ reminderAttr->setReminders(calendar->defaultReminders());
94​ // Block email reminders, since Google sends them for us
95​ auto blockAlarms = collection.attribute<BlockAlarmsAttribute>(Collection::AddIfMissing);
96​ blockAlarms->blockAlarmType(KCalendarCore::Alarm::Audio, false);
97​ blockAlarms->blockAlarmType(KCalendarCore::Alarm::Display, false);
98​ blockAlarms->blockAlarmType(KCalendarCore::Alarm::Procedure, false);
99​}
100​
101​void CalendarHandler::retrieveCollections()
102​{
103​ Q_EMIT m_resource->status(AgentBase::Running, i18nc("@info:status", "Retrieving calendars"));
104​ qCDebug(GOOGLE_CALENDAR_LOG) << "Retrieving calendars...";
105​ auto job = new CalendarFetchJob(m_settings->accountPtr(), this);
106​ connect(job, &CalendarFetchJob::finished, this, &CalendarHandler::slotCollectionsRetrieved);
107​}
108​
109​void CalendarHandler::slotCollectionsRetrieved(KGAPI2::Job *job)
110​{
mlaurentUnsubmitted
Done

coding style Job *job

mlaurent: coding style Job *job
111​ if (!m_resource->handleError(job)) {
112​ return;
113​ }
114​ qCDebug(GOOGLE_CALENDAR_LOG) << "Calendars retrieved";
115​
116​ const ObjectsList calendars = qobject_cast<CalendarFetchJob *>(job)->items();
117​ Collection::List collections;
118​ collections.reserve(calendars.count());
119​ const QStringList activeCalendars = m_settings->calendars();
120​ for (const auto &object : calendars) {
121​ const CalendarPtr &calendar = object.dynamicCast<Calendar>();
122​ qCDebug(GOOGLE_CALENDAR_LOG) << " -" << calendar->title() << "(" << calendar->uid() << ")";
123​ if (!activeCalendars.contains(calendar->uid())) {
124​ qCDebug(GOOGLE_CALENDAR_LOG) << "Skipping, not subscribed";
125​ continue;
126​ }
127​ Collection collection;
128​ setupCollection(collection, calendar);
129​ collections << collection;
130​ }
131​
132​ m_resource->collectionsRetrievedFromHandler(collections);
133​}
134​
135​void CalendarHandler::retrieveItems(const Collection &collection)
136​{
137​ qCDebug(GOOGLE_CALENDAR_LOG) << "Retrieving events for calendar" << collection.remoteId();
138​ QString syncToken = collection.remoteRevision();
139​ auto job = new EventFetchJob(collection.remoteId(), m_settings->accountPtr(), this);
140​ if (!syncToken.isEmpty()) {
141​ qCDebug(GOOGLE_CALENDAR_LOG) << "Using sync token" << syncToken;
142​ job->setSyncToken(syncToken);
143​ job->setFetchDeleted(true);
144​ } else {
145​ // No need to fetch deleted items for non-incremental update
146​ job->setFetchDeleted(false);
147​ if (!m_settings->eventsSince().isEmpty()) {
148​ const QDate date = QDate::fromString(m_settings->eventsSince(), Qt::ISODate);
149​#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
150​ job->setTimeMin(QDateTime(date).toSecsSinceEpoch());
151​#else
152​ job->setTimeMin(QDateTime(date.startOfDay()).toSecsSinceEpoch());
153​#endif
154​ }
155​ }
156​
157​ job->setProperty(COLLECTION_PROPERTY, QVariant::fromValue(collection));
158​ connect(job, &EventFetchJob::finished, this, &CalendarHandler::slotItemsRetrieved);
159​
160​ Q_EMIT m_resource->status(AgentBase::Running, i18nc("@info:status", "Retrieving events for calendar '%1'", collection.displayName()));
161​}
162​
163​void CalendarHandler::slotItemsRetrieved(KGAPI2::Job *job)
164​{
165​ if (!m_resource->handleError(job)) {
166​ return;
167​ }
168​ Item::List changedItems, removedItems;
169​ Collection collection = job->property(COLLECTION_PROPERTY).value<Collection>();
170​ DefaultReminderAttribute *attr = collection.attribute<DefaultReminderAttribute>();
171​
172​ auto fetchJob = qobject_cast<EventFetchJob *>(job);
173​ const ObjectsList objects = fetchJob->items();
174​ bool isIncremental = !fetchJob->syncToken().isEmpty();
175​ qCDebug(GOOGLE_CALENDAR_LOG) << "Retrieved" << objects.count() << "events for calendar" << collection.remoteId();
176​ for (const ObjectPtr &object : objects) {
177​ const EventPtr event = object.dynamicCast<Event>();
178​ if (event->useDefaultReminders() && attr) {
179​ const KCalendarCore::Alarm::List alarms = attr->alarms(event.data());
180​ for (const KCalendarCore::Alarm::Ptr &alarm : alarms) {
181​ event->addAlarm(alarm);
182​ }
183​ }
184​
185​ Item item;
186​ item.setMimeType(KCalendarCore::Event::eventMimeType());
187​ item.setParentCollection(collection);
188​ item.setRemoteId(event->id());
189​ item.setRemoteRevision(event->etag());
190​ item.setPayload<KCalendarCore::Event::Ptr>(event.dynamicCast<KCalendarCore::Event>());
191​
192​ if (event->deleted()) {
193​ qCDebug(GOOGLE_CALENDAR_LOG) << " - removed" << event->uid();
194​ removedItems << item;
195​ } else {
196​ qCDebug(GOOGLE_CALENDAR_LOG) << " - changed" << event->uid();
197​ changedItems << item;
198​ }
199​ }
200​
201​ if (!isIncremental) {
202​ m_resource->itemsRetrieved(changedItems);
203​ } else {
204​ m_resource->itemsRetrievedIncremental(changedItems, removedItems);
205​ }
206​ qCDebug(GOOGLE_CALENDAR_LOG) << "Next sync token:" << fetchJob->syncToken();
207​ collection.setRemoteRevision(fetchJob->syncToken());
208​ new CollectionModifyJob(collection, this);
209​
210​ m_resource->emitReadyStatus();
211​}
212​
213​void CalendarHandler::itemAdded(const Item &item, const Collection &collection)
214​{
215​ Q_EMIT m_resource->status(AgentBase::Running, i18nc("@info:status", "Adding event to calendar '%1'", collection.name()));
216​ qCDebug(GOOGLE_CALENDAR_LOG) << "Event added to calendar" << collection.remoteId();
217​ KCalendarCore::Event::Ptr event = item.payload<KCalendarCore::Event::Ptr>();
218​ EventPtr kevent(new Event(*event));
219​ auto *job = new EventCreateJob(kevent, collection.remoteId(), m_settings->accountPtr(), this);
220​ job->setSendUpdates(SendUpdatesPolicy::None);
221​ connect(job, &EventCreateJob::finished, this, [this, item](KGAPI2::Job *job){
222​ if (!m_resource->handleError(job)) {
223​ return;
224​ }
225​ Item newItem(item);
226​ const EventPtr event = qobject_cast<EventCreateJob *>(job)->items().first().dynamicCast<Event>();
227​ qCDebug(GOOGLE_CALENDAR_LOG) << "Event added";
228​ newItem.setRemoteId(event->id());
229​ newItem.setRemoteRevision(event->etag());
230​ newItem.setGid(event->uid());
231​ m_resource->changeCommitted(newItem);
232​ newItem.setPayload<KCalendarCore::Event::Ptr>(event.dynamicCast<KCalendarCore::Event>());
233​ new ItemModifyJob(newItem, this);
234​ m_resource->emitReadyStatus();
235​ });
236​}
237​
238​void CalendarHandler::itemChanged(const Item &item, const QSet< QByteArray > &partIdentifiers)
239​{
240​ Q_UNUSED(partIdentifiers);
241​ Q_EMIT m_resource->status(AgentBase::Running, i18nc("@info:status", "Changing event in calendar '%1'", item.parentCollection().displayName()));
242​ qCDebug(GOOGLE_CALENDAR_LOG) << "Changing event" << item.remoteId();
243​ KCalendarCore::Event::Ptr event = item.payload<KCalendarCore::Event::Ptr>();
244​ EventPtr kevent(new Event(*event));
245​ auto job = new EventModifyJob(kevent, item.parentCollection().remoteId(), m_settings->accountPtr(), this);
246​ job->setSendUpdates(SendUpdatesPolicy::None);
247​ job->setProperty(ITEM_PROPERTY, QVariant::fromValue(item));
248​ connect(job, &EventModifyJob::finished, m_resource, &GoogleResource::slotGenericJobFinished);
249​}
250​
251​void CalendarHandler::itemsRemoved(const Item::List &items)
252​{
253​ Q_EMIT m_resource->status(AgentBase::Running, i18ncp("@info:status", "Removing %1 events", "Removing %1 event", items.count()));
254​ QStringList eventIds;
255​ eventIds.reserve(items.count());
256​ std::transform(items.cbegin(), items.cend(), std::back_inserter(eventIds),
257​ [](const Item &item){
258​ return item.remoteId();
259​ });
260​ qCDebug(GOOGLE_CALENDAR_LOG) << "Removing events:" << eventIds;
261​ // TODO: what if events are from diferent calendars?
262​ auto job = new EventDeleteJob(eventIds, items.first().parentCollection().remoteId(), m_settings->accountPtr(), this);
263​ job->setProperty(ITEMS_PROPERTY, QVariant::fromValue(items));
264​ connect(job, &EventDeleteJob::finished, m_resource, &GoogleResource::slotGenericJobFinished);
265​}
266​
267​void CalendarHandler::itemsMoved(const Item::List &items, const Collection &collectionSource, const Collection &collectionDestination)
268​{
269​ Q_EMIT m_resource->status(AgentBase::Running, i18ncp("@info:status", "Moving %1 events from calendar '%2' to calendar '%3'",
270​ "Moving %1 event from calendar '%2' to calendar '%3'",
271​ items.count(), collectionSource.displayName(), collectionDestination.displayName()));
272​ QStringList eventIds;
273​ eventIds.reserve(items.count());
274​ std::transform(items.cbegin(), items.cend(), std::back_inserter(eventIds),
275​ [](const Item &item){
276​ return item.remoteId();
277​ });
278​ qCDebug(GOOGLE_CALENDAR_LOG) << "Moving events" << eventIds << "from" << collectionSource.remoteId() << "to" << collectionDestination.remoteId();
279​ auto job = new EventMoveJob(eventIds, collectionSource.remoteId(), collectionDestination.remoteId(), m_settings->accountPtr(), this);
280​ job->setProperty(ITEMS_PROPERTY, QVariant::fromValue(items));
281​ connect(job, &EventMoveJob::finished, m_resource, &GoogleResource::slotGenericJobFinished);
282​}
283​
284​void CalendarHandler::collectionAdded(const Collection &collection, const Collection &parent)
285​{
286​ Q_UNUSED(parent);
287​ Q_EMIT m_resource->status(AgentBase::Running, i18nc("@info:status", "Creating calendar '%1'", collection.displayName()));
288​ qCDebug(GOOGLE_CALENDAR_LOG) << "Adding calendar" << collection.displayName();
289​ CalendarPtr calendar(new Calendar());
290​ calendar->setTitle(collection.displayName());
291​ calendar->setEditable(true);
292​
293​ auto job = new CalendarCreateJob(calendar, m_settings->accountPtr(), this);
294​ connect(job, &CalendarCreateJob::finished, this, [this, collection](KGAPI2::Job *job){
295​ if (!m_resource->handleError(job)) {
296​ return;
297​ }
298​ CalendarPtr calendar = qobject_cast<CalendarCreateJob *>(job)->items().first().dynamicCast<Calendar>();
299​ qCDebug(GOOGLE_CALENDAR_LOG) << "Created calendar" << calendar->uid();
300​ // Enable newly added calendar in settings, otherwise user won't see it
301​ m_settings->addCalendar(calendar->uid());
302​ // TODO: the calendar returned by google is almost empty, i.e. it's not "editable",
303​ // does not contain the color, etc
304​ calendar->setEditable(true);
305​ // Populate remoteId & other stuff
306​ Collection newCollection(collection);
307​ setupCollection(newCollection, calendar);
308​ m_resource->changeCommitted(newCollection);
309​ m_resource->emitReadyStatus();
310​
311​ });
312​}
313​
314​void CalendarHandler::collectionChanged(const Collection &collection)
315​{
316​ Q_EMIT m_resource->status(AgentBase::Running, i18nc("@info:status", "Changing calendar '%1'", collection.displayName()));
317​ qCDebug(GOOGLE_CALENDAR_LOG) << "Changing calendar" << collection.remoteId();
318​ CalendarPtr calendar(new Calendar());
319​ calendar->setUid(collection.remoteId());
320​ calendar->setTitle(collection.displayName());
321​ calendar->setEditable(true);
322​ auto job = new CalendarModifyJob(calendar, m_settings->accountPtr(), this);
323​ job->setProperty(COLLECTION_PROPERTY, QVariant::fromValue(collection));
324​ connect(job, &CalendarModifyJob::finished, m_resource, &GoogleResource::slotGenericJobFinished);
325​}
326​
327​void CalendarHandler::collectionRemoved(const Collection &collection)
328​{
329​ Q_EMIT m_resource->status(AgentBase::Running, i18nc("@info:status", "Removing calendar '%1'", collection.displayName()));
330​ qCDebug(GOOGLE_CALENDAR_LOG) << "Removing calendar" << collection.remoteId();
331​ auto job = new CalendarDeleteJob(collection.remoteId(), m_settings->accountPtr(), this);
332​ job->setProperty(COLLECTION_PROPERTY, QVariant::fromValue(collection));
333​ connect(job, &CalendarDeleteJob::finished, m_resource, &GoogleResource::slotGenericJobFinished);
334​}
335​
336​QDateTime CalendarHandler::lastCacheUpdate() const
337​{
338​ return QDateTime();
339​}
340​
341​void CalendarHandler::canHandleFreeBusy(const QString &email) const
342​{
343​ if (m_resource->canPerformTask()) {
344​ m_resource->handlesFreeBusy(email, false);
345​ return;
346​ }
347​
348​ auto job = new FreeBusyQueryJob(email,
349​ QDateTime::currentDateTimeUtc(),
350​ QDateTime::currentDateTimeUtc().addSecs(3600),
351​ m_settings->accountPtr(),
352​ const_cast<CalendarHandler*>(this));
353​ connect(job, &FreeBusyQueryJob::finished, this, [this](KGAPI2::Job *job){
354​ auto queryJob = qobject_cast<FreeBusyQueryJob *>(job);
355​ if (!m_resource->handleError(job, false)) {
356​ m_resource->handlesFreeBusy(queryJob->id(), false);
357​ return;
358​ }
359​ m_resource->handlesFreeBusy(queryJob->id(), true);
360​ });
361​}
362​
363​void CalendarHandler::retrieveFreeBusy(const QString &email, const QDateTime &start, const QDateTime &end)
364​{
365​ if (m_resource->canPerformTask()) {
366​ m_resource->freeBusyRetrieved(email, QString(), false, QString());
367​ return;
368​ }
369​
370​ auto job = new FreeBusyQueryJob(email, start, end, m_settings->accountPtr(), this);
371​ connect(job, &FreeBusyQueryJob::finished, this, [this](KGAPI2::Job *job) {
372​ auto queryJob = qobject_cast<FreeBusyQueryJob *>(job);
373​
374​ if (!m_resource->handleError(job, false)) {
375​ m_resource->freeBusyRetrieved(queryJob->id(), QString(), false, QString());
376​ return;
377​ }
378​
379​ KCalendarCore::FreeBusy::Ptr fb(new KCalendarCore::FreeBusy);
380​ fb->setUid(QStringLiteral("%1%2@google.com").arg(QDateTime::currentDateTimeUtc().toString(QStringLiteral("yyyyMMddTHHmmssZ"))));
381​ fb->setOrganizer(job->account()->accountName());
382​ fb->addAttendee(KCalendarCore::Attendee(QString(), queryJob->id()));
383​ // FIXME: is it really sort?
384​ fb->setDateTime(QDateTime::currentDateTimeUtc(), KCalendarCore::IncidenceBase::RoleSort);
385​ const auto ranges = queryJob->busy();
386​ for (const auto &range : ranges) {
387​ fb->addPeriod(range.busyStart, range.busyEnd);
388​ }
389​
390​ KCalendarCore::ICalFormat format;
391​ const QString fbStr = format.createScheduleMessage(fb, KCalendarCore::iTIPRequest);
392​
393​ m_resource->freeBusyRetrieved(queryJob->id(), fbStr, true, QString());
394​ });
395​}