Differential D28560 Diff 80527 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 "googleresourcestate.h"
21​#include "googlesettings.h"
22​#include "googlesettingsdialog.h"
23​#include "googleresource_debug.h"
24​#include "settingsadaptor.h"
25​
26​#include "calendarhandler.h"
27​#include "contacthandler.h"
28​#include "taskhandler.h"
29​
30​#include "defaultreminderattribute.h"
31​
32​#include <AkonadiCore/AttributeFactory>
33​#include <AkonadiCore/CachePolicy>
34​#include <AkonadiCore/ChangeRecorder>
35​#include <AkonadiCore/CollectionFetchScope>
36​#include <AkonadiCore/EntityDisplayAttribute>
37​#include <AkonadiCore/ItemFetchScope>
38​
39​#include <KCalendarCore/Event>
40​
41​#include <QDialog>
42​#include <QIcon>
43​#include <KLocalizedString>
44​
45​#include <KGAPI/Account>
46​#include <KGAPI/AccountInfoFetchJob>
47​#include <KGAPI/AccountInfo>
48​#include <KGAPI/AuthJob>
49​
50​#include <algorithm>
51​
52​
53​#define CALENDARS_PROPERTY "_KGAPI2CalendarPtr"
54​#define ROOT_COLLECTION_REMOTEID QStringLiteral("RootCollection")
55​
56​
57​Q_DECLARE_METATYPE(KGAPI2::Job *)
58​
59​using namespace KGAPI2;
60​using namespace Akonadi;
61​
62​GoogleResource::GoogleResource(const QString &id)
63​ : ResourceBase(id)
64​ , AgentBase::ObserverV3()
65​ , m_iface(new GoogleResourceState(this))
66​{
67​ AttributeFactory::registerAttribute< DefaultReminderAttribute >();
68​
69​ connect(this, &GoogleResource::reloadConfiguration, this, &GoogleResource::reloadConfig);
70​
71​ setNeedsNetwork(true);
72​
73​ changeRecorder()->itemFetchScope().fetchFullPayload(true);
74​ changeRecorder()->itemFetchScope().setAncestorRetrieval(ItemFetchScope::All);
75​ changeRecorder()->fetchCollection(true);
76​ changeRecorder()->collectionFetchScope().setAncestorRetrieval(CollectionFetchScope::All);
77​
78​ m_settings = new GoogleSettings();
79​ m_settings->setWindowId(winIdForDialogs());
80​ connect(m_settings, &GoogleSettings::accountReady, this, [this](bool ready){
81​ if (accountId() > 0) {
82​ return;
83​ }
84​ if (!ready) {
85​ Q_EMIT status(Broken, i18n("Can't access KWallet"));
86​ return;
87​ }
88​ if (m_settings->accountPtr().isNull()) {
89​ Q_EMIT status(NotConfigured);
90​ return;
91​ }
92​ emitReadyStatus();
93​ synchronize();
94​ });
95​
96​ Q_EMIT status(NotConfigured, i18n("Waiting for KWallet..."));
97​ updateResourceName();
98​
99​ m_freeBusyHandler.reset(new FreeBusyHandler(m_iface, m_settings));
100​ m_handlers.clear();
101​ m_handlers.push_back(GenericHandler::Ptr(new CalendarHandler(m_iface, m_settings)));
102​ m_handlers.push_back(GenericHandler::Ptr(new ContactHandler(m_iface, m_settings)));
103​ m_handlers.push_back(GenericHandler::Ptr(new TaskHandler(m_iface, m_settings)));
104​
105​ new SettingsAdaptor(m_settings);
106​ QDBusConnection::sessionBus().registerObject(QStringLiteral("/Settings"),
107​ m_settings, QDBusConnection::ExportAdaptors);
108​}
109​
110​GoogleResource::~GoogleResource()
111​{
112​ delete m_iface;
113​}
114​
115​void GoogleResource::cleanup()
116​{
117​ m_settings->cleanup();
118​ ResourceBase::cleanup();
119​}
120​
121​void GoogleResource::emitReadyStatus()
122​{
123​ Q_EMIT status(Idle, i18nc("@info:status", "Ready"));
124​}
125​
126​void GoogleResource::configure(WId windowId)
127​{
128​ if (!m_settings->isReady() || m_isConfiguring) {
129​ Q_EMIT configurationDialogAccepted();
130​ return;
131​ }
132​
133​ m_isConfiguring = true;
134​
135​ QScopedPointer<GoogleSettingsDialog> settingsDialog(new GoogleSettingsDialog(this, m_settings, windowId));
136​ settingsDialog->setWindowIcon(QIcon::fromTheme(QStringLiteral("im-google")));
137​ if (settingsDialog->exec() == QDialog::Accepted) {
138​ updateResourceName();
139​
140​ Q_EMIT configurationDialogAccepted();
141​
142​ if (m_settings->accountPtr().isNull()) {
143​ Q_EMIT status(NotConfigured, i18n("Configured account does not exist"));
144​ m_isConfiguring = false;
145​ return;
146​ }
147​
148​ emitReadyStatus();
149​ synchronize();
150​ } else {
151​ updateResourceName();
152​
153​ Q_EMIT configurationDialogRejected();
154​ }
155​
156​ m_isConfiguring = false;
157​}
158​
159​QList<QUrl> GoogleResource::scopes() const
160​{
161​ // TODO: determine it based on what user wants?
162​ const QList< QUrl > scopes = {Account::accountInfoScopeUrl(), Account::calendarScopeUrl(),
163​ Account::contactsScopeUrl(), Account::tasksScopeUrl()};
164​ return scopes;
165​}
166​
167​void GoogleResource::updateResourceName()
168​{
169​ const QString accountName = m_settings->account();
170​ setName(i18nc("%1 is account name (user@gmail.com)", "Google Groupware (%1)", accountName.isEmpty() ? i18n("not configured") : accountName));
171​}
172​
173​void GoogleResource::reloadConfig()
174​{
175​ const AccountPtr account = m_settings->accountPtr();
176​ if (account.isNull() || account->accountName().isEmpty()) {
177​ Q_EMIT status(NotConfigured, i18n("Configured account does not exist"));
178​ } else {
179​ emitReadyStatus();
180​ }
181​}
182​
183​bool GoogleResource::handleError(KGAPI2::Job *job, bool _cancelTask)
184​{
185​ if ((job->error() == KGAPI2::NoError) || (job->error() == KGAPI2::OK)) {
186​ return true;
187​ }
188​ qCWarning(GOOGLE_LOG) << "Got error:" << job << job->errorString();
189​ AccountPtr account = job->account();
190​ if (job->error() == KGAPI2::Unauthorized) {
191​ const QList<QUrl> resourceScopes = scopes();
192​ for (const QUrl &scope : resourceScopes) {
193​ if (!account->scopes().contains(scope)) {
194​ account->addScope(scope);
195​ }
196​ }
197​
198​ AuthJob *authJob = new AuthJob(account, m_settings->clientId(), m_settings->clientSecret(), this);
199​ authJob->setProperty(JOB_PROPERTY, QVariant::fromValue(job));
200​ connect(authJob, &AuthJob::finished, this, &GoogleResource::slotAuthJobFinished);
201​ return false;
202​ }
203​
204​ if (_cancelTask) {
205​ cancelTask(job->errorString());
206​ }
207​ return false;
208​}
209​
210​bool GoogleResource::canPerformTask()
211​{
212​ if (!m_settings->accountPtr() && accountId() == 0) {
213​ cancelTask(i18nc("@info:status", "Resource is not configured"));
214​ Q_EMIT status(NotConfigured, i18nc("@info:status", "Resource is not configured"));
215​ return false;
216​ }
217​
218​ return true;
219​}
220​
221​void GoogleResource::slotAuthJobFinished(KGAPI2::Job *job)
222​{
223​ if (job->error() != KGAPI2::NoError) {
224​ cancelTask(i18n("Failed to refresh tokens"));
225​ return;
226​ }
227​
228​ AuthJob *authJob = qobject_cast<AuthJob *>(job);
229​ AccountPtr account = authJob->account();
230​ if (!m_settings->storeAccount(account)) {
231​ qCWarning(GOOGLE_LOG) << "Failed to store account in KWallet";
232​ }
233​
234​ KGAPI2::Job *otherJob = job->property(JOB_PROPERTY).value<KGAPI2::Job *>();
235​ if (otherJob) {
236​ otherJob->setAccount(account);
237​ otherJob->restart();
238​ }
239​}
240​
241​int GoogleResource::accountId() const
242​{
243​ return 0;
244​}
245​
246​GenericHandler *GoogleResource::fetchHandlerByMimetype(const QString &mimeType)
247​{
248​ auto it = std::find_if(m_handlers.cbegin(), m_handlers.cend(),
249​ [&mimeType](const GenericHandler::Ptr &handler){
250​ return handler->mimeType() == mimeType;
251​ });
252​
253​ if (it != m_handlers.cend()) {
254​ return it->get();
255​ } else {
256​ return nullptr;
257​ }
258​}
259​
260​GenericHandler *GoogleResource::fetchHandlerForCollection(const Akonadi::Collection &collection)
261​{
262​ auto it = std::find_if(m_handlers.cbegin(), m_handlers.cend(),
263​ [&collection](const GenericHandler::Ptr &handler){
264​ return collection.contentMimeTypes().contains(handler->mimeType());
265​ });
266​ if (it != m_handlers.cend()) {
267​ return it->get();
268​ } else {
269​ return nullptr;
270​ }
271​}
272​
273​/*
274​ * FreeBusy handling
275​ */
276​
277​QDateTime GoogleResource::lastCacheUpdate() const
278​{
279​ if (m_freeBusyHandler) {
280​ return m_freeBusyHandler->lastCacheUpdate();
281​ }
282​ return QDateTime();
283​}
284​
285​void GoogleResource::canHandleFreeBusy(const QString &email) const
286​{
287​ if (m_freeBusyHandler) {
288​ m_freeBusyHandler->canHandleFreeBusy(email);
289​ } else {
290​ handlesFreeBusy(email, false);
291​ }
292​}
293​
294​void GoogleResource::retrieveFreeBusy(const QString &email, const QDateTime &start, const QDateTime &end)
295​{
296​ if (m_freeBusyHandler) {
297​ m_freeBusyHandler->retrieveFreeBusy(email, start, end);
298​ } else {
299​ freeBusyRetrieved(email, QString(), false, QString());
300​ }
301​}
302​
303​/*
304​ * Collection handling
305​ */
306​void GoogleResource::retrieveCollections()
307​{
308​ if (!canPerformTask()) {
309​ return;
310​ }
311​ qCDebug(GOOGLE_LOG) << "Retrieve Collections";
312​
313​ setCollectionStreamingEnabled(true);
314​ CachePolicy cachePolicy;
315​ if (m_settings->enableIntervalCheck()) {
316​ cachePolicy.setInheritFromParent(false);
317​ cachePolicy.setIntervalCheckTime(m_settings->intervalCheckTime());
318​ }
319​
320​ // Setting up root collection
321​ m_rootCollection = Collection();
322​ m_rootCollection.setContentMimeTypes({ Collection::mimeType(), Collection::virtualMimeType() });
323​ m_rootCollection.setRemoteId(ROOT_COLLECTION_REMOTEID);
324​ m_rootCollection.setName(m_settings->accountPtr()->accountName());
325​ m_rootCollection.setParentCollection(Collection::root());
326​ m_rootCollection.setRights(Collection::CanCreateCollection);
327​ m_rootCollection.setCachePolicy(cachePolicy);
328​
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​ EntityDisplayAttribute *attr = m_rootCollection.attribute<EntityDisplayAttribute>(Collection::AddIfMissing);
330​ attr->setDisplayName(m_settings->accountPtr()->accountName());
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​ attr->setIconName(QStringLiteral("im-google"));
332​
333​ collectionsRetrieved({ m_rootCollection });
334​
335​ m_jobs = m_handlers.size();
336​ for (const auto &handler : m_handlers) {
337​ handler->retrieveCollections(m_rootCollection);
338​ }
339​}
340​
341​void GoogleResource::collectionsRetrievedFromHandler(const Collection::List &collections)
342​{
343​ collectionsRetrieved(collections);
344​ m_jobs--;
345​ if (m_jobs == 0) {
346​ qCDebug(GOOGLE_LOG) << "All collections retrieved!";
347​ collectionsRetrievalDone();
348​ //taskDone(); // ???
349​ emitReadyStatus();
350​ }
351​}
352​
353​void GoogleResource::retrieveItems(const Collection &collection)
354​{
355​ if (!canPerformTask()) {
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​ return;
357​ }
358​
359​ auto handler = fetchHandlerForCollection(collection);
360​ if (handler) {
361​ handler->retrieveItems(collection);
362​ } else {
363​ qCWarning(GOOGLE_LOG) << "Unknown collection" << collection.name();
364​ itemsRetrieved({});
365​ }
366​}
367​
368​void GoogleResource::itemAdded(const Item &item, const Collection &collection)
369​{
370​ if (!canPerformTask()) {
371​ return;
372​ }
373​
374​ auto handler = fetchHandlerByMimetype(item.mimeType());
375​ if (handler && handler->canPerformTask(item)) {
376​ handler->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​ if (!canPerformTask()) {
386​ return;
387​ }
388​ auto handler = fetchHandlerByMimetype(item.mimeType());
389​ if (handler && handler->canPerformTask(item)) {
390​ handler->itemChanged(item, partIdentifiers);
391​ } else {
392​ qCWarning(GOOGLE_LOG) << "Could not change item" << item.mimeType();
393​ cancelTask(i18n("Invalid payload type"));
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​ }
395​}
396​
397​void GoogleResource::itemsRemoved(const Item::List &items)
398​{
399​ if (!canPerformTask()) {
400​ return;
401​ }
402​ auto handler = fetchHandlerByMimetype(items.first().mimeType());
403​ if (handler && handler->canPerformTask(items)) {
404​ handler->itemsRemoved(items);
405​ } else {
406​ qCWarning(GOOGLE_LOG) << "Could not remove item" << items.first().mimeType();
407​ cancelTask(i18n("Invalid payload type"));
408​ }
409​}
410​
411​void GoogleResource::itemsMoved(const Item::List &items, const Collection &collectionSource, const Collection &collectionDestination)
412​{
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​ if (!canPerformTask()) {
414​ return;
415​ }
416​ auto handler = fetchHandlerByMimetype(items.first().mimeType());
417​ if (handler && handler->canPerformTask(items)) {
418​ handler->itemsMoved(items, collectionSource, collectionDestination);
419​ } else if (!handler) {
420​ qCWarning(GOOGLE_LOG) << "Could not move item" << items.first().mimeType() << "from" << collectionSource.remoteId() << "to" << collectionDestination.remoteId();
421​ cancelTask(i18n("Invalid payload type"));
422​ }
423​}
424​
425​void GoogleResource::itemsLinked(const Item::List &items, const Collection &collection)
426​{
427​ if (!canPerformTask()) {
428​ return;
429​ }
430​ auto handler = fetchHandlerByMimetype(items.first().mimeType());
431​ if (handler && handler->canPerformTask(items)) {
432​ handler->itemsLinked(items, collection);
433​ } else if (!handler) {
434​ qCWarning(GOOGLE_LOG) << "Could not link item" << items.first().mimeType() << "to" << collection.remoteId();
435​ cancelTask(i18n("Invalid payload type"));
436​ }
437​}
438​
439​void GoogleResource::itemsUnlinked(const Item::List &items, const Collection &collection)
440​{
441​ if (!canPerformTask()) {
442​ return;
443​ }
444​ auto handler = fetchHandlerByMimetype(items.first().mimeType());
445​ if (handler && handler->canPerformTask(items)) {
446​ handler->itemsUnlinked(items, collection);
447​ } else if (!handler) {
448​ qCWarning(GOOGLE_LOG) << "Could not unlink item mimetype" << items.first().mimeType() << "from" << collection.remoteId();
449​ cancelTask(i18n("Invalid payload type"));
450​ }
451​}
452​
453​void GoogleResource::collectionAdded(const Collection &collection, const Collection &parent)
454​{
455​ if (!canPerformTask()) {
456​ return;
457​ }
458​ auto handler = fetchHandlerForCollection(collection);
459​ if (handler) {
460​ handler->collectionAdded(collection, parent);
461​ } else {
462​ qCWarning(GOOGLE_LOG) << "Could not add collection" << collection.displayName() << "mimetypes:" << collection.contentMimeTypes();
463​ cancelTask(i18n("Unknown collection mimetype"));
464​ }
465​}
466​
467​void GoogleResource::collectionChanged(const Collection &collection)
468​{
469​ if (!canPerformTask()) {
470​ return;
471​ }
472​ auto handler = fetchHandlerForCollection(collection);
473​ if (handler) {
474​ handler->collectionChanged(collection);
475​ } else {
476​ qCWarning(GOOGLE_LOG) << "Could not change collection" << collection.displayName() << "mimetypes:" << collection.contentMimeTypes();
477​ cancelTask(i18n("Unknown collection mimetype"));
478​ }
479​}
480​
481​void GoogleResource::collectionRemoved(const Collection &collection)
482​{
483​ if (!canPerformTask()) {
484​ return;
485​ }
486​ auto handler = fetchHandlerForCollection(collection);
487​ if (handler) {
488​ handler->collectionRemoved(collection);
489​ } else {
490​ qCWarning(GOOGLE_LOG) << "Could not remove collection" << collection.displayName() << "mimetypes:" << collection.contentMimeTypes();
491​ cancelTask(i18n("Unknown collection mimetype"));
492​ }
493​}
494​
495​AKONADI_RESOURCE_MAIN(GoogleResource)