Differential D28560 Diff 79334 resources/google-groupware/googleresource.cpp

Changeset View

Standalone View

View Options

resources/google-groupware/googleresource.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 "googleresource.h"
20​#include "googlesettings.h"
21​#include "googlesettingsdialog.h"
22​#include "googleresource_debug.h"
23​#include "settingsadaptor.h"
24​
25​#include "calendarhandler.h"
26​#include "contacthandler.h"
27​#include "taskhandler.h"
28​
29​#include "defaultreminderattribute.h"
30​
31​#include <AkonadiCore/AttributeFactory>
32​#include <AkonadiCore/CachePolicy>
33​#include <AkonadiCore/ChangeRecorder>
34​#include <AkonadiCore/CollectionFetchScope>
35​#include <AkonadiCore/EntityDisplayAttribute>
36​#include <AkonadiCore/ItemFetchScope>
37​
38​#include <KCalendarCore/Event>
39​
40​#include <QDialog>
41​#include <QIcon>
42​#include <KLocalizedString>
43​
44​#include <KGAPI/Account>
45​#include <KGAPI/AccountInfoFetchJob>
46​#include <KGAPI/AccountInfo>
47​#include <KGAPI/AuthJob>
48​
49​#include <algorithm>
50​
51​
52​#define CALENDARS_PROPERTY "_KGAPI2CalendarPtr"
53​#define ROOT_COLLECTION_REMOTEID QStringLiteral("RootCollection")
54​
55​
56​Q_DECLARE_METATYPE(KGAPI2::Job *)
57​
58​using namespace KGAPI2;
59​using namespace Akonadi;
60​
61​GoogleResource::GoogleResource(const QString &id)
62​ : ResourceBase(id)
63​ , AgentBase::ObserverV3()
64​{
65​ AttributeFactory::registerAttribute< DefaultReminderAttribute >();
66​
67​ connect(this, &GoogleResource::reloadConfiguration, this, &GoogleResource::reloadConfig);
68​
69​ setNeedsNetwork(true);
70​
71​ changeRecorder()->itemFetchScope().fetchFullPayload(true);
72​ changeRecorder()->itemFetchScope().setAncestorRetrieval(ItemFetchScope::All);
73​ changeRecorder()->fetchCollection(true);
74​ changeRecorder()->collectionFetchScope().setAncestorRetrieval(CollectionFetchScope::All);
75​
76​ m_settings = new GoogleSettings();
77​ m_settings->setWindowId(winIdForDialogs());
78​ connect(m_settings, &GoogleSettings::accountReady, this, [this](bool ready){
79​ if (accountId() > 0) {
80​ return;
81​ }
82​ if (!ready) {
83​ Q_EMIT status(Broken, i18n("Can't access KWallet"));
84​ return;
85​ }
86​ if (m_settings->accountPtr().isNull()) {
87​ Q_EMIT status(NotConfigured);
88​ return;
89​ }
90​ emitReadyStatus();
91​ synchronize();
92​ });
93​
94​ Q_EMIT status(NotConfigured, i18n("Waiting for KWallet..."));
95​ updateResourceName();
96​
97​ m_freeBusyHandler.reset(new CalendarHandler(this, m_settings));
98​ m_handlers << m_freeBusyHandler;
99​ m_handlers << GenericHandler::Ptr(new ContactHandler(this, m_settings));
100​ m_handlers << GenericHandler::Ptr(new TaskHandler(this, m_settings));
101​
102​ new SettingsAdaptor(m_settings);
103​ QDBusConnection::sessionBus().registerObject(QStringLiteral("/Settings"),
104​ m_settings, QDBusConnection::ExportAdaptors);
105​}
106​
107​GoogleResource::~GoogleResource()
108​{
109​}
110​
111​void GoogleResource::cleanup()
112​{
113​ m_settings->cleanup();
114​ ResourceBase::cleanup();
115​}
116​
117​void GoogleResource::emitReadyStatus()
118​{
119​ Q_EMIT status(Idle, i18nc("@info:status", "Ready"));
120​}
121​
122​Collection GoogleResource::rootCollection() const
123​{
124​ return m_rootCollection;
125​}
126​
127​void GoogleResource::configure(WId windowId)
128​{
129​ if (!m_settings->isReady() || m_isConfiguring) {
130​ Q_EMIT configurationDialogAccepted();
131​ return;
132​ }
133​
134​ m_isConfiguring = true;
135​
136​ QScopedPointer<GoogleSettingsDialog> settingsDialog(new GoogleSettingsDialog(this, m_settings, windowId));
137​ settingsDialog->setWindowIcon(QIcon::fromTheme(QStringLiteral("im-google")));
138​ if (settingsDialog->exec() == QDialog::Accepted) {
139​ updateResourceName();
140​
141​ Q_EMIT configurationDialogAccepted();
142​
143​ if (m_settings->accountPtr().isNull()) {
144​ Q_EMIT status(NotConfigured, i18n("Configured account does not exist"));
145​ m_isConfiguring = false;
146​ return;
147​ }
148​
149​ emitReadyStatus();
150​ synchronize();
151​ } else {
152​ updateResourceName();
153​
154​ Q_EMIT configurationDialogRejected();
155​ }
156​
157​ m_isConfiguring = false;
158​}
159​
160​QList<QUrl> GoogleResource::scopes() const
161​{
162​ // TODO: determine it based on what user wants?
163​ const QList< QUrl > scopes = {Account::accountInfoScopeUrl(), Account::calendarScopeUrl(),
164​ Account::contactsScopeUrl(), Account::tasksScopeUrl()};
165​ return scopes;
166​}
167​
168​void GoogleResource::updateResourceName()
169​{
170​ const QString accountName = m_settings->account();
171​ setName(i18nc("%1 is account name (user@gmail.com)", "Google Groupware (%1)", accountName.isEmpty() ? i18n("not configured") : accountName));
172​}
173​
174​void GoogleResource::reloadConfig()
175​{
176​ const AccountPtr account = m_settings->accountPtr();
177​ if (account.isNull() || account->accountName().isEmpty()) {
178​ Q_EMIT status(NotConfigured, i18n("Configured account does not exist"));
179​ } else {
180​ emitReadyStatus();
181​ }
182​}
183​
184​bool GoogleResource::handleError(KGAPI2::Job *job, bool _cancelTask)
185​{
186​ if ((job->error() == KGAPI2::NoError) || (job->error() == KGAPI2::OK)) {
187​ return true;
188​ }
189​ qCWarning(GOOGLE_LOG) << "Got error:" << job << job->errorString();
190​ AccountPtr account = job->account();
191​ if (job->error() == KGAPI2::Unauthorized) {
192​ const QList<QUrl> resourceScopes = scopes();
193​ for (const QUrl &scope : resourceScopes) {
194​ if (!account->scopes().contains(scope)) {
195​ account->addScope(scope);
196​ }
197​ }
198​
199​ AuthJob *authJob = new AuthJob(account, m_settings->clientId(), m_settings->clientSecret(), this);
200​ authJob->setProperty(JOB_PROPERTY, QVariant::fromValue(job));
201​ connect(authJob, &AuthJob::finished, this, &GoogleResource::slotAuthJobFinished);
202​ return false;
203​ }
204​
205​ if (_cancelTask) {
206​ cancelTask(job->errorString());
207​ }
208​ return false;
209​}
210​
211​bool GoogleResource::canPerformTask()
212​{
213​ if (!m_settings->accountPtr() && accountId() == 0) {
214​ cancelTask(i18nc("@info:status", "Resource is not configured"));
215​ Q_EMIT status(NotConfigured, i18nc("@info:status", "Resource is not configured"));
216​ return false;
217​ }
218​
219​ return true;
220​}
221​
222​void GoogleResource::slotAuthJobFinished(KGAPI2::Job *job)
223​{
224​ if (job->error() != KGAPI2::NoError) {
225​ cancelTask(i18n("Failed to refresh tokens"));
226​ return;
227​ }
228​
229​ AuthJob *authJob = qobject_cast<AuthJob *>(job);
230​ AccountPtr account = authJob->account();
231​ if (!m_settings->storeAccount(account)) {
232​ qCWarning(GOOGLE_LOG) << "Failed to store account in KWallet";
233​ }
234​
235​ KGAPI2::Job *otherJob = job->property(JOB_PROPERTY).value<KGAPI2::Job *>();
236​ if (otherJob) {
237​ otherJob->setAccount(account);
238​ otherJob->restart();
239​ }
240​}
241​
242​void GoogleResource::slotGenericJobFinished(KGAPI2::Job *job)
243​{
244​ if (!handleError(job)) {
245​ return;
246​ }
247​ if (job->property(ITEM_PROPERTY).isValid()) {
248​ qCDebug(GOOGLE_LOG) << "Item change committed";
249​ changeCommitted(job->property(ITEM_PROPERTY).value<Item>());
250​ } else if (job->property(ITEMS_PROPERTY).isValid()) {
251​ qCDebug(GOOGLE_LOG) << "Items changes committed";
252​ changesCommitted(job->property(ITEMS_PROPERTY).value<Item::List>());
253​ } else if (job->property(COLLECTION_PROPERTY).isValid()) {
254​ qCDebug(GOOGLE_LOG) << "Collection change committed";
255​ changeCommitted(job->property(COLLECTION_PROPERTY).value<Collection>());
256​ } else {
257​ qCDebug(GOOGLE_LOG) << "Task done";
258​ taskDone();
259​ }
260​
261​ emitReadyStatus();
262​}
263​
264​int GoogleResource::accountId() const
265​{
266​ return 0;
267​}
268​
269​QDateTime GoogleResource::lastCacheUpdate() const
270​{
271​ if (m_freeBusyHandler) {
272​ return m_freeBusyHandler->lastCacheUpdate();
273​ }
274​ return QDateTime();
275​}
276​
277​void GoogleResource::canHandleFreeBusy(const QString &email) const
278​{
279​ if (m_freeBusyHandler) {
280​ m_freeBusyHandler->canHandleFreeBusy(email);
281​ } else {
282​ handlesFreeBusy(email, false);
283​ }
284​}
285​
286​void GoogleResource::retrieveFreeBusy(const QString &email, const QDateTime &start, const QDateTime &end)
287​{
288​ if (m_freeBusyHandler) {
289​ m_freeBusyHandler->retrieveFreeBusy(email, start, end);
290​ } else {
291​ freeBusyRetrieved(email, QString(), false, QString());
292​ }
293​}
294​
295​/*
296​ * Collection handling
297​ */
298​void GoogleResource::retrieveCollections()
299​{
300​ if (!canPerformTask()) {
301​ return;
302​ }
303​ qCDebug(GOOGLE_LOG) << "Retrieve Collections";
304​
305​ setCollectionStreamingEnabled(true);
306​ CachePolicy cachePolicy;
307​ if (m_settings->enableIntervalCheck()) {
308​ cachePolicy.setInheritFromParent(false);
309​ cachePolicy.setIntervalCheckTime(m_settings->intervalCheckTime());
310​ }
311​
312​ // Setting up root collection
313​ m_rootCollection = Collection();
314​ m_rootCollection.setContentMimeTypes({ Collection::mimeType(), Collection::virtualMimeType() });
315​ m_rootCollection.setRemoteId(ROOT_COLLECTION_REMOTEID);
316​ m_rootCollection.setName(m_settings->accountPtr()->accountName());
317​ m_rootCollection.setParentCollection(Collection::root());
318​ m_rootCollection.setRights(Collection::CanCreateCollection);
319​ m_rootCollection.setCachePolicy(cachePolicy);
320​
321​ EntityDisplayAttribute *attr = m_rootCollection.attribute<EntityDisplayAttribute>(Collection::AddIfMissing);
322​ attr->setDisplayName(m_settings->accountPtr()->accountName());
323​ attr->setIconName(QStringLiteral("im-google"));
324​
325​ collectionsRetrieved({ m_rootCollection });
326​
327​ m_jobs = m_handlers.count();
328​ for (auto &handler : m_handlers) {
dvratilUnsubmitted
Not Done

This is making me feel uneasy - we keep some global state here for a local task, but I do not have a better solution at the moment.

dvratil: This is making me feel uneasy - we keep some global state here for a local task, but I do not…
329​ handler->retrieveCollections();
330​ }
dvratilUnsubmitted
Done

I would propose passing the m_rootCollection into the GenericHandler::retrieveCollections() as an argument rather than allowing the Handlers to touch the Resource's private m_rootCollection.

dvratil: I would propose passing the `m_rootCollection` into the `GenericHandler::retrieveCollections()`…
331​}
332​
333​void GoogleResource::collectionsRetrievedFromHandler(const Collection::List &collections)
334​{
335​ collectionsRetrieved(collections);
336​ m_jobs--;
337​ if (m_jobs == 0) {
338​ qCDebug(GOOGLE_LOG) << "All collections retrieved!";
339​ collectionsRetrievalDone();
340​ //taskDone(); // ???
341​ emitReadyStatus();
342​ }
343​}
344​
345​void GoogleResource::retrieveItems(const Collection &collection)
346​{
347​ if (!canPerformTask()) {
348​ return;
349​ }
350​
351​ auto it = std::find_if(m_handlers.begin(), m_handlers.end(),
352​ [&collection](const GenericHandler::Ptr &handler){
353​ return collection.contentMimeTypes().contains(handler->mimetype());
354​ });
355​
dvratilUnsubmitted
Done

This variant of code keeps repeating - I propose a method for this, e.g. GenericHandler *GoogleResource::handlerForCollectionTask(const QString &mimeType)

dvratil: This variant of code keeps repeating - I propose a method for this, e.g. `GenericHandler…
356​ if (it != m_handlers.end()) {
357​ (*it)->retrieveItems(collection);
358​ } else {
359​ qCWarning(GOOGLE_LOG) << "Unknown collection" << collection.name();
360​ itemsRetrieved({});
361​ }
362​}
363​
364​void GoogleResource::itemAdded(const Item &item, const Collection &collection)
365​{
366​ if (!canPerformTask()) {
367​ return;
368​ }
369​
370​ auto it = std::find_if(m_handlers.begin(), m_handlers.end(),
371​ [&collection, &item](const GenericHandler::Ptr &handler){
372​ return collection.contentMimeTypes().contains(handler->mimetype())
373​ && handler->canPerformTask(item);
374​ });
375​ if (it != m_handlers.end()) {
376​ (*it)->itemAdded(item, collection);
377​ } else {
378​ qCWarning(GOOGLE_LOG) << "Could not add item" << item.mimeType();
379​ cancelTask(i18n("Invalid payload type"));
380​ }
381​}
382​
383​void GoogleResource::itemChanged(const Item &item, const QSet< QByteArray > &partIdentifiers)
384​{
385​ Q_UNUSED(partIdentifiers);
386​ if (!canPerformTask()) {
387​ return;
388​ }
389​ auto it = std::find_if(m_handlers.begin(), m_handlers.end(),
390​ [&item](const GenericHandler::Ptr &handler){
391​ return handler->canPerformTask(item);
392​ });
393​ if (it != m_handlers.end()) {
dvratilUnsubmitted
Done

Same thing with the handler here and in all the other tasks - should be a method of its own

dvratil: Same thing with the handler here and in all the other tasks - should be a method of its own
394​ (*it)->itemChanged(item, partIdentifiers);
395​ } else {
396​ qCWarning(GOOGLE_LOG) << "Could not change item" << item.mimeType();
397​ cancelTask(i18n("Invalid payload type"));
398​ }
399​}
400​
401​void GoogleResource::itemsRemoved(const Item::List &items)
402​{
403​ if (!canPerformTask()) {
404​ return;
405​ }
406​ // TODO: what if items have different mimetypes?
407​ const QString mimeType = items.first().mimeType();
408​ auto it = std::find_if(m_handlers.begin(), m_handlers.end(),
409​ [&mimeType](const GenericHandler::Ptr &handler){
410​ return handler->mimetype() == mimeType;
411​ });
412​ if (it != m_handlers.end()) {
dvratilUnsubmitted
Done

Akonadi guarantees that all items here belong to the same Collection, thus they are all managed by the same Handler.

dvratil: Akonadi guarantees that all `items` here belong to the same Collection, thus they are all…
413​ (*it)->itemsRemoved(items);
414​ } else {
415​ qCWarning(GOOGLE_LOG) << "Could not remove item" << mimeType;
416​ cancelTask(i18n("Invalid payload type"));
417​ }
418​}
419​
420​void GoogleResource::itemsMoved(const Item::List &items, const Collection &collectionSource, const Collection &collectionDestination)
421​{
422​ if (!canPerformTask()) {
423​ return;
424​ }
425​ // TODO: what if items have different mimetypes?
426​ auto it = std::find_if(m_handlers.begin(), m_handlers.end(),
427​ [&item = items.first()](const GenericHandler::Ptr &handler){
428​ return handler->canPerformTask(item);
429​ });
430​ if (it != m_handlers.end()) {
431​ (*it)->itemsMoved(items, collectionSource, collectionDestination);
432​ } else {
433​ qCWarning(GOOGLE_LOG) << "Could not move item" << items.first().mimeType() << "from" << collectionSource.remoteId() << "to" << collectionDestination.remoteId();
434​ cancelTask(i18n("Invalid payload type"));
435​ }
436​}
437​
438​void GoogleResource::itemsLinked(const Item::List &items, const Collection &collection)
439​{
440​ if (!canPerformTask()) {
441​ return;
442​ }
443​ // TODO: what if items have different mimetypes?
444​ auto it = std::find_if(m_handlers.begin(), m_handlers.end(),
445​ [&item = items.first()](const GenericHandler::Ptr &handler){
446​ return handler->canPerformTask(item);
447​ });
448​ if (it != m_handlers.end()) {
449​ (*it)->itemsLinked(items, collection);
450​ } else {
451​ qCWarning(GOOGLE_LOG) << "Could not link item" << items.first().mimeType() << "to" << collection.remoteId();
452​ cancelTask(i18n("Invalid payload type"));
453​ }
454​}
455​
456​void GoogleResource::itemsUnlinked(const Item::List &items, const Collection &collection)
457​{
458​ if (!canPerformTask()) {
459​ return;
460​ }
461​ // TODO: what if items have different mimetypes?
462​ auto it = std::find_if(m_handlers.begin(), m_handlers.end(),
463​ [&item = items.first()](const GenericHandler::Ptr &handler){
464​ return handler->canPerformTask(item);
465​ });
466​ if (it != m_handlers.end()) {
467​ (*it)->itemsUnlinked(items, collection);
468​ } else {
469​ qCWarning(GOOGLE_LOG) << "Could not unlink item mimetype" << items.first().mimeType() << "from" << collection.remoteId();
470​ cancelTask(i18n("Invalid payload type"));
471​ }
472​}
473​
474​void GoogleResource::collectionAdded(const Collection &collection, const Collection &parent)
475​{
476​ if (!canPerformTask()) {
477​ return;
478​ }
479​ auto it = std::find_if(m_handlers.begin(), m_handlers.end(),
480​ [&collection](const GenericHandler::Ptr &handler){
481​ return collection.contentMimeTypes().contains(handler->mimetype());
482​ });
483​ if (it != m_handlers.end()) {
484​ (*it)->collectionAdded(collection, parent);
485​ } else {
486​ qCWarning(GOOGLE_LOG) << "Could not add collection" << collection.displayName() << "mimetypes:" << collection.contentMimeTypes();
487​ cancelTask(i18n("Unknown collection mimetype"));
488​ }
489​}
490​
491​void GoogleResource::collectionChanged(const Collection &collection)
492​{
493​ if (!canPerformTask()) {
494​ return;
495​ }
496​ auto it = std::find_if(m_handlers.begin(), m_handlers.end(),
497​ [&collection](const GenericHandler::Ptr &handler){
498​ return collection.contentMimeTypes().contains(handler->mimetype());
499​ });
500​ if (it != m_handlers.end()) {
501​ (*it)->collectionChanged(collection);
502​ } else {
503​ qCWarning(GOOGLE_LOG) << "Could not change collection" << collection.displayName() << "mimetypes:" << collection.contentMimeTypes();
504​ cancelTask(i18n("Unknown collection mimetype"));
505​ }
506​}
507​
508​void GoogleResource::collectionRemoved(const Collection &collection)
509​{
510​ if (!canPerformTask()) {
511​ return;
512​ }
513​ auto it = std::find_if(m_handlers.begin(), m_handlers.end(),
514​ [&collection](const GenericHandler::Ptr &handler){
515​ return collection.contentMimeTypes().contains(handler->mimetype());
516​ });
517​ if (it != m_handlers.end()) {
518​ (*it)->collectionRemoved(collection);
519​ } else {
520​ qCWarning(GOOGLE_LOG) << "Could not remove collection" << collection.displayName() << "mimetypes:" << collection.contentMimeTypes();
521​ cancelTask(i18n("Unknown collection mimetype"));
522​ }
523​}
524​
525​AKONADI_RESOURCE_MAIN(GoogleResource)