Differential D28560 Diff 79760 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​#include "googlecalendar_debug.h"
24​
25​#include <AkonadiCore/CollectionColorAttribute>
26​#include <AkonadiCore/CollectionModifyJob>
27​#include <AkonadiCore/EntityDisplayAttribute>
28​#include <AkonadiCore/ItemModifyJob>
29​#include <Akonadi/Calendar/BlockAlarmsAttribute>
30​
31​#include <KGAPI/Account>
32​#include <KGAPI/Calendar/Calendar>
33​#include <KGAPI/Calendar/CalendarCreateJob>
34​#include <KGAPI/Calendar/CalendarDeleteJob>
35​#include <KGAPI/Calendar/CalendarFetchJob>
36​#include <KGAPI/Calendar/CalendarModifyJob>
37​#include <KGAPI/Calendar/Event>
38​#include <KGAPI/Calendar/EventCreateJob>
39​#include <KGAPI/Calendar/EventDeleteJob>
40​#include <KGAPI/Calendar/EventFetchJob>
41​#include <KGAPI/Calendar/EventModifyJob>
42​#include <KGAPI/Calendar/EventMoveJob>
43​#include <KGAPI/Calendar/FreeBusyQueryJob>
44​
45​#include <KCalendarCore/Calendar>
46​#include <KCalendarCore/FreeBusy>
47​#include <KCalendarCore/ICalFormat>
48​
49​using namespace KGAPI2;
50​using namespace Akonadi;
51​
52​static constexpr uint32_t KGAPIEventVersion = 1;
53​
54​QString CalendarHandler::mimeType()
55​{
56​ return KCalendarCore::Event::eventMimeType();
57​}
58​
59​bool CalendarHandler::canPerformTask(const Item &item)
60​{
61​ return GenericHandler::canPerformTask<KCalendarCore::Event::Ptr>(item);
62​}
63​
64​bool CalendarHandler::canPerformTask(const Item::List &items)
65​{
66​ return GenericHandler::canPerformTask<KCalendarCore::Event::Ptr>(items);
67​}
68​
69​void CalendarHandler::setupCollection(Collection &collection, const CalendarPtr &calendar)
70​{
71​ collection.setContentMimeTypes({ mimeType() });
72​ collection.setName(calendar->uid());
73​ collection.setRemoteId(calendar->uid());
74​ if (calendar->editable()) {
75​ collection.setRights(Collection::CanChangeCollection
76​ |Collection::CanDeleteCollection
77​ |Collection::CanCreateItem
78​ |Collection::CanChangeItem
79​ |Collection::CanDeleteItem);
80​ } else {
81​ collection.setRights(Collection::ReadOnly);
82​ }
83​ // TODO: for some reason, KOrganizer creates virtual collections
84​ //newCollection.setVirtual(false);
85​ // Setting icon
86​ auto attr = collection.attribute<EntityDisplayAttribute>(Collection::AddIfMissing);
87​ attr->setDisplayName(calendar->title());
88​ attr->setIconName(QStringLiteral("view-calendar"));
89​ // Setting color
90​ if (calendar->backgroundColor().isValid()) {
91​ auto colorAttr = collection.attribute<CollectionColorAttribute>(Collection::AddIfMissing);
92​ colorAttr->setColor(calendar->backgroundColor());
93​ }
94​ // Setting default remoinders
95​ auto reminderAttr = collection.attribute<DefaultReminderAttribute>(Collection::AddIfMissing);
96​ reminderAttr->setReminders(calendar->defaultReminders());
97​ // Block email reminders, since Google sends them for us
98​ auto blockAlarms = collection.attribute<BlockAlarmsAttribute>(Collection::AddIfMissing);
99​ blockAlarms->blockAlarmType(KCalendarCore::Alarm::Audio, false);
100​ blockAlarms->blockAlarmType(KCalendarCore::Alarm::Display, false);
101​ blockAlarms->blockAlarmType(KCalendarCore::Alarm::Procedure, false);
102​}
103​
104​void CalendarHandler::retrieveCollections(const Collection &rootCollection)
105​{
106​ m_iface->emitStatus(AgentBase::Running, i18nc("@info:status", "Retrieving calendars"));
107​ qCDebug(GOOGLE_CALENDAR_LOG) << "Retrieving calendars...";
108​ auto job = new CalendarFetchJob(m_settings->accountPtr(), this);
109​ connect(job, &CalendarFetchJob::finished, this, [this, rootCollection](KGAPI2::Job *job){
110​ if (!m_iface->handleError(job)) {
mlaurentUnsubmitted
Done

coding style Job *job

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