Kgapi

calendarservice.cpp
1/*
2 * This file is part of LibKGAPI library
3 *
4 * SPDX-FileCopyrightText: 2013 Daniel Vrátil <dvratil@redhat.com>
5 *
6 * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
7 */
8
9#include "calendarservice.h"
10#include "calendar.h"
11#include "debug.h"
12#include "event.h"
13#include "reminder.h"
14#include "utils.h"
15
16#include <KCalendarCore/Alarm>
17#include <KCalendarCore/Attendee>
18#include <KCalendarCore/Event>
19#include <KCalendarCore/ICalFormat>
20#include <KCalendarCore/Person>
21#include <KCalendarCore/Recurrence>
22#include <KCalendarCore/RecurrenceRule>
23
24#include <QJsonDocument>
25#include <QNetworkRequest>
26#include <QTimeZone>
27#include <QUrlQuery>
28#include <QVariant>
29
30#include <map>
31#include <memory>
32
33namespace KGAPI2
34{
35
36namespace CalendarService
37{
38
39namespace Private
40{
41KCalendarCore::DateList parseRDate(const QString &rule);
42
43ObjectPtr JSONToCalendar(const QVariantMap &data);
44ObjectPtr JSONToEvent(const QVariantMap &data, const QString &timezone = QString());
45
46/**
47 * Checks whether TZID is in Olson format and converts it to it if necessary
48 *
49 * This is mainly to handle crazy Microsoft TZIDs like
50 * "(GMT) Greenwich Mean Time/Dublin/Edinburgh/London", because Google only
51 * accepts TZIDs in Olson format ("Europe/London").
52 *
53 * It first tries to match the given \p tzid to all TZIDs in KTimeZones::zones().
54 * If it fails, it parses the \p event, looking for X-MICROSOFT-CDO-TZID
55 * property and than matches it to Olson-formatted TZID using a table.
56 *
57 * When the method fails to process the TZID, it returns the original \p tzid
58 * in hope, that Google will cope with it.
59 */
60QString checkAndConverCDOTZID(const QString &tzid, const EventPtr &event);
61
62static const QUrl GoogleApisUrl(QStringLiteral("https://www.googleapis.com"));
63static const QString CalendarListBasePath(QStringLiteral("/calendar/v3/users/me/calendarList"));
64static const QString CalendarBasePath(QStringLiteral("/calendar/v3/calendars"));
65}
66
67QNetworkRequest prepareRequest(const QUrl &url)
68{
69 QNetworkRequest request(url);
70 request.setRawHeader("GData-Version", CalendarService::APIVersion().toLatin1());
71
72 return request;
73}
74
75/************* URLS **************/
76
77QUrl fetchCalendarsUrl()
78{
79 QUrl url(Private::GoogleApisUrl);
80 url.setPath(Private::CalendarListBasePath);
81 return url;
82}
83
84QUrl fetchCalendarUrl(const QString &calendarID)
85{
86 QUrl url(Private::GoogleApisUrl);
87 url.setPath(Private::CalendarListBasePath % QLatin1Char('/') % calendarID);
88 return url;
89}
90
91QUrl updateCalendarUrl(const QString &calendarID)
92{
93 QUrl url(Private::GoogleApisUrl);
94 url.setPath(Private::CalendarBasePath % QLatin1Char('/') % calendarID);
95 return url;
96}
97
98QUrl createCalendarUrl()
99{
100 QUrl url(Private::GoogleApisUrl);
101 url.setPath(Private::CalendarBasePath);
102 return url;
103}
104
105QUrl removeCalendarUrl(const QString &calendarID)
106{
107 QUrl url(Private::GoogleApisUrl);
108 url.setPath(Private::CalendarBasePath % QLatin1Char('/') % calendarID);
109 return url;
110}
111
112QUrl fetchEventsUrl(const QString &calendarID)
113{
114 QUrl url(Private::GoogleApisUrl);
115 url.setPath(Private::CalendarBasePath % QLatin1Char('/') % calendarID % QLatin1StringView("/events"));
116 return url;
117}
118
119QUrl fetchEventUrl(const QString &calendarID, const QString &eventID)
120{
121 QUrl url(Private::GoogleApisUrl);
122 url.setPath(Private::CalendarBasePath % QLatin1Char('/') % calendarID % QLatin1StringView("/events/") % eventID);
123 return url;
124}
125
126namespace
127{
128
129QString sendUpdatesPolicyToString(SendUpdatesPolicy policy)
130{
131 switch (policy) {
132 case SendUpdatesPolicy::All:
133 return QStringLiteral("all");
134 case SendUpdatesPolicy::ExternalOnly:
135 return QStringLiteral("externalOnly");
136 case SendUpdatesPolicy::None:
137 return QStringLiteral("none");
138 }
139 Q_UNREACHABLE();
140}
141
142static const QString sendUpatesQueryParam = QStringLiteral("sendUpdates");
143static const QString destinationQueryParam = QStringLiteral("destination");
144}
145
146QUrl updateEventUrl(const QString &calendarID, const QString &eventID, SendUpdatesPolicy updatePolicy)
147{
148 QUrl url(Private::GoogleApisUrl);
149 url.setPath(Private::CalendarBasePath % QLatin1Char('/') % calendarID % QLatin1StringView("/events/") % eventID);
150 QUrlQuery query(url);
151 query.addQueryItem(sendUpatesQueryParam, sendUpdatesPolicyToString(updatePolicy));
152 url.setQuery(query);
153 return url;
154}
155
156QUrl createEventUrl(const QString &calendarID, SendUpdatesPolicy updatePolicy)
157{
158 QUrl url(Private::GoogleApisUrl);
159 url.setPath(Private::CalendarBasePath % QLatin1Char('/') % calendarID % QLatin1StringView("/events"));
160 QUrlQuery query(url);
161 query.addQueryItem(sendUpatesQueryParam, sendUpdatesPolicyToString(updatePolicy));
162 url.setQuery(query);
163 return url;
164}
165
166QUrl importEventUrl(const QString &calendarID, SendUpdatesPolicy updatePolicy)
167{
168 QUrl url(Private::GoogleApisUrl);
169 url.setPath(Private::CalendarBasePath % QLatin1Char('/') % calendarID % QLatin1StringView("/events") % QLatin1StringView("/import"));
170 QUrlQuery query(url);
171 query.addQueryItem(sendUpatesQueryParam, sendUpdatesPolicyToString(updatePolicy));
172 url.setQuery(query);
173 return url;
174}
175
176QUrl removeEventUrl(const QString &calendarID, const QString &eventID)
177{
178 QUrl url(Private::GoogleApisUrl);
179 url.setPath(Private::CalendarBasePath % QLatin1Char('/') % calendarID % QLatin1StringView("/events/") % eventID);
180 return url;
181}
182
183QUrl moveEventUrl(const QString &sourceCalendar, const QString &destCalendar, const QString &eventID)
184{
185 QUrl url(Private::GoogleApisUrl);
186 url.setPath(Private::CalendarBasePath % QLatin1Char('/') % sourceCalendar % QLatin1StringView("/events/") % eventID % QLatin1StringView("/move"));
187 QUrlQuery query(url);
188 query.addQueryItem(destinationQueryParam, destCalendar);
189 url.setQuery(query);
190 return url;
191}
192
193QUrl freeBusyQueryUrl()
194{
195 QUrl url(Private::GoogleApisUrl);
196 url.setPath(QStringLiteral("/calendar/v3/freeBusy"));
197 return url;
198}
199
200namespace
201{
202
203static const auto kindParam = QStringLiteral("kind");
204static const auto idParam = QStringLiteral("id");
205static const auto etagParam = QStringLiteral("etag");
206
207static const auto nextSyncTokenParam = QStringLiteral("nextSyncToken");
208static const auto nextPageTokenParam = QStringLiteral("nextPageToken");
209static const auto pageTokenParam = QStringLiteral("pageToken");
210static const auto itemsParam = QStringLiteral("items");
211
212static const auto calendarSummaryParam = QStringLiteral("summary");
213static const auto calendarDescriptionParam = QStringLiteral("description");
214static const auto calendarLocationParam = QStringLiteral("location");
215static const auto calendarTimezoneParam = QStringLiteral("timeZone");
216static const auto calendarBackgroundColorParam = QStringLiteral("backgroundColor");
217static const auto calendarForegroundColorParam = QStringLiteral("foregroundColor");
218static const auto calendarAccessRoleParam = QStringLiteral("accessRole");
219static const auto calendarDefaultRemindersParam = QStringLiteral("defaultReminders");
220static const auto reminderMethodParam = QStringLiteral("method");
221static const auto reminderMinutesParam = QStringLiteral("minutes");
222
223static const auto eventiCalUIDParam = QStringLiteral("iCalUID");
224static const auto eventStatusParam = QStringLiteral("status");
225static const auto eventCreatedParam = QStringLiteral("created");
226static const auto eventUpdatedParam = QStringLiteral("updated");
227static const auto eventSummaryParam = QStringLiteral("summary");
228static const auto eventDescriptionParam = QStringLiteral("description");
229static const auto eventLocationParam = QStringLiteral("location");
230static const auto eventStartPram = QStringLiteral("start");
231static const auto eventEndParam = QStringLiteral("end");
232static const auto eventOriginalStartTimeParam = QStringLiteral("originalStartTime");
233static const auto eventTransparencyParam = QStringLiteral("transparency");
234static const auto eventOrganizerParam = QStringLiteral("organizer");
235static const auto eventAttendeesParam = QStringLiteral("attendees");
236static const auto eventRecurrenceParam = QStringLiteral("recurrence");
237static const auto eventRemindersParam = QStringLiteral("reminders");
238static const auto eventExtendedPropertiesParam = QStringLiteral("extendedProperties");
239static const auto eventRecurringEventIdParam = QStringLiteral("recurringEventId");
240
241static const auto attendeeDisplayNameParam = QStringLiteral("displayName");
242static const auto attendeeEmailParam = QStringLiteral("email");
243static const auto attendeeResponseStatusParam = QStringLiteral("responseStatus");
244static const auto attendeeOptionalParam = QStringLiteral("optional");
245
246static const auto organizerDisplayNameParam = QStringLiteral("displayName");
247static const auto organizerEmailParam = QStringLiteral("email");
248
249static const auto reminderUseDefaultParam = QStringLiteral("useDefault");
250static const auto reminderOverridesParam = QStringLiteral("overrides");
251
252static const auto propertyPrivateParam = QStringLiteral("private");
253static const auto propertySharedParam = QStringLiteral("shared");
254
255static const auto dateParam = QStringLiteral("date");
256static const auto dateTimeParam = QStringLiteral("dateTime");
257static const auto timeZoneParam = QStringLiteral("timeZone");
258
259static const auto calendarListKind = QLatin1StringView("calendar#calendarList");
260static const auto calendarListEntryKind = QLatin1StringView("calendar#calendarListEntry");
261static const auto calendarKind = QLatin1StringView("calendar#calendar");
262static const auto eventKind = QLatin1StringView("calendar#event");
263static const auto eventsKind = QLatin1StringView("calendar#events");
264
265static const auto writerAccessRole = QLatin1StringView("writer");
266static const auto ownerAccessRole = QLatin1StringView("owner");
267static const auto emailMethod = QLatin1StringView("email");
268static const auto popupMethod = QLatin1StringView("popup");
269
270static const auto confirmedStatus = QLatin1StringView("confirmed");
271static const auto canceledStatus = QLatin1StringView("cancelled");
272static const auto tentativeStatus = QLatin1StringView("tentative");
273static const auto acceptedStatus = QLatin1StringView("accepted");
274static const auto needsActionStatus = QLatin1StringView("needsAction");
275static const auto transparentTransparency = QLatin1StringView("transparent");
276static const auto opaqueTransparency = QLatin1StringView("opaque");
277static const auto declinedStatus = QLatin1StringView("declined");
278static const auto categoriesProperty = QLatin1StringView("categories");
279
280static const auto hangoutLinkParam = QStringLiteral("hangoutLink");
281
282static const auto eventTypeParam = QStringLiteral("eventType");
283
284}
285
286QString APIVersion()
287{
288 return QStringLiteral("3");
289}
290
291CalendarPtr JSONToCalendar(const QByteArray &jsonData)
292{
293 const auto document = QJsonDocument::fromJson(jsonData);
294 const auto calendar = document.toVariant().toMap();
295
296 if (calendar.value(kindParam).toString() != calendarListEntryKind && calendar.value(kindParam).toString() != calendarKind) {
297 return CalendarPtr();
298 }
299
300 return Private::JSONToCalendar(calendar).staticCast<Calendar>();
301}
302
303ObjectPtr Private::JSONToCalendar(const QVariantMap &data)
304{
305 auto calendar = CalendarPtr::create();
306
307 const auto id = QUrl::fromPercentEncoding(data.value(idParam).toByteArray());
308 calendar->setUid(id);
309 calendar->setEtag(data.value(etagParam).toString());
310 calendar->setTitle(data.value(calendarSummaryParam).toString());
311 calendar->setDetails(data.value(calendarDescriptionParam).toString());
312 calendar->setLocation(data.value(calendarLocationParam).toString());
313 calendar->setTimezone(data.value(calendarTimezoneParam).toString());
314 calendar->setBackgroundColor(QColor(data.value(calendarBackgroundColorParam).toString()));
315 calendar->setForegroundColor(QColor(data.value(calendarForegroundColorParam).toString()));
316
317 if ((data.value(calendarAccessRoleParam).toString() == writerAccessRole) || (data.value(calendarAccessRoleParam).toString() == ownerAccessRole)) {
318 calendar->setEditable(true);
319 } else {
320 calendar->setEditable(false);
321 }
322
323 const auto reminders = data.value(calendarDefaultRemindersParam).toList();
324 for (const auto &r : reminders) {
325 const auto reminder = r.toMap();
326
327 auto rem = ReminderPtr::create();
328 if (reminder.value(reminderMethodParam).toString() == emailMethod) {
329 rem->setType(KCalendarCore::Alarm::Email);
330 } else if (reminder.value(reminderMethodParam).toString() == popupMethod) {
331 rem->setType(KCalendarCore::Alarm::Display);
332 } else {
333 rem->setType(KCalendarCore::Alarm::Invalid);
334 }
335
336 rem->setStartOffset(KCalendarCore::Duration(reminder.value(reminderMinutesParam).toInt() * (-60)));
337
338 calendar->addDefaultReminer(rem);
339 }
340
341 return calendar.dynamicCast<Object>();
342}
343
344QByteArray calendarToJSON(const CalendarPtr &calendar)
345{
346 QVariantMap entry;
347
348 if (!calendar->uid().isEmpty()) {
349 entry.insert(idParam, calendar->uid());
350 }
351
352 entry.insert(calendarSummaryParam, calendar->title());
353 entry.insert(calendarDescriptionParam, calendar->details());
354 entry.insert(calendarLocationParam, calendar->location());
355 if (!calendar->timezone().isEmpty()) {
356 entry.insert(calendarTimezoneParam, calendar->timezone());
357 }
358
359 const auto document = QJsonDocument::fromVariant(entry);
360 return document.toJson(QJsonDocument::Compact);
361}
362
363ObjectsList parseCalendarJSONFeed(const QByteArray &jsonFeed, FeedData &feedData)
364{
365 const auto document = QJsonDocument::fromJson(jsonFeed);
366 const auto data = document.toVariant().toMap();
367
368 ObjectsList list;
369
370 if (data.value(kindParam).toString() == calendarListKind) {
371 if (data.contains(nextPageTokenParam)) {
372 feedData.nextPageUrl = fetchCalendarsUrl();
373 QUrlQuery query(feedData.nextPageUrl);
374 query.addQueryItem(pageTokenParam, data.value(nextPageTokenParam).toString());
375 feedData.nextPageUrl.setQuery(query);
376 }
377 } else {
378 return {};
379 }
380
381 const auto items = data.value(itemsParam).toList();
382 list.reserve(items.size());
383 for (const auto &i : items) {
384 list.push_back(Private::JSONToCalendar(i.toMap()));
385 }
386
387 return list;
388}
389
390EventPtr JSONToEvent(const QByteArray &jsonData)
391{
392 QJsonParseError error;
393 QJsonDocument document = QJsonDocument::fromJson(jsonData, &error);
394 if (error.error != QJsonParseError::NoError) {
395 qCWarning(KGAPIDebug) << "Error parsing event JSON: " << error.errorString();
396 }
397 QVariantMap data = document.toVariant().toMap();
398 if (data.value(kindParam).toString() != eventKind) {
399 return EventPtr();
400 }
401
402 return Private::JSONToEvent(data).staticCast<Event>();
403}
404
405namespace
406{
407
408struct ParsedDt {
409 QDateTime dt;
410 bool isAllDay;
411};
412
413ParsedDt parseDt(const QVariantMap &data, const QString &timezone, bool isDtEnd)
414{
415 if (data.contains(dateParam)) {
416 auto dt = QDateTime::fromString(data.value(dateParam).toString(), Qt::ISODate);
417 if (isDtEnd) {
418 // Google reports all-day events to end on the next day, e.g. a
419 // Monday all-day event will be reporting as starting on Monday and
420 // ending on Tuesday, while KCalendarCore/iCal uses the same day for
421 // dtEnd, so adjust the end date here.
422 dt = dt.addDays(-1);
423 }
424 return {dt, true};
425 } else if (data.contains(dateTimeParam)) {
426 auto dt = Utils::rfc3339DateFromString(data.value(dateTimeParam).toString());
427 // If there's a timezone specified in the "start" entity, then use it
428 if (data.contains(timeZoneParam)) {
429 const QTimeZone tz = QTimeZone(data.value(timeZoneParam).toString().toUtf8());
430 if (tz.isValid()) {
431 dt = dt.toTimeZone(tz);
432 } else {
433 qCWarning(KGAPIDebug) << "Invalid timezone" << data.value(timeZoneParam).toString();
434 }
435
436 // Otherwise try to fallback to calendar-wide timezone
437 } else if (!timezone.isEmpty()) {
438 const QTimeZone tz(timezone.toUtf8());
439 if (tz.isValid()) {
440 dt.setTimeZone(tz);
441 } else {
442 qCWarning(KGAPIDebug) << "Invalid timezone" << timezone;
443 }
444 }
445 return {dt, false};
446 } else {
447 return {{}, false};
448 }
449}
450
451void setEventCategories(EventPtr &event, const QVariantMap &properties)
452{
453 for (auto iter = properties.cbegin(), end = properties.cend(); iter != end; ++iter) {
454 if (iter.key() == categoriesProperty) {
455 event->setCategories(iter.value().toString());
456 }
457 }
458}
459
460} // namespace
461
462ObjectPtr Private::JSONToEvent(const QVariantMap &data, const QString &timezone)
463{
464 auto event = EventPtr::create();
465
466 event->setId(data.value(idParam).toString());
467 event->setHangoutLink(data.value(hangoutLinkParam).toString());
468 event->setUid(data.value(eventiCalUIDParam).toString());
469 event->setEtag(data.value(etagParam).toString());
470
471 if (data.value(eventStatusParam).toString() == confirmedStatus) {
472 event->setStatus(KCalendarCore::Incidence::StatusConfirmed);
473 } else if (data.value(eventStatusParam).toString() == canceledStatus) {
474 event->setStatus(KCalendarCore::Incidence::StatusCanceled);
475 event->setDeleted(true);
476 } else if (data.value(eventStatusParam).toString() == tentativeStatus) {
477 event->setStatus(KCalendarCore::Incidence::StatusTentative);
478 } else {
479 event->setStatus(KCalendarCore::Incidence::StatusNone);
480 }
481
482 event->setCreated(Utils::rfc3339DateFromString(data.value(eventCreatedParam).toString()));
483 event->setLastModified(Utils::rfc3339DateFromString(data.value(eventUpdatedParam).toString()));
484 event->setSummary(data.value(eventSummaryParam).toString());
485 event->setDescription(data.value(eventDescriptionParam).toString());
486 event->setLocation(data.value(eventLocationParam).toString());
487
488 const auto dtStart = parseDt(data.value(eventStartPram).toMap(), timezone, false);
489 event->setDtStart(dtStart.dt);
490 event->setAllDay(dtStart.isAllDay);
491
492 const auto dtEnd = parseDt(data.value(eventEndParam).toMap(), timezone, true);
493 event->setDtEnd(dtEnd.dt);
494
495 if (data.contains(eventOriginalStartTimeParam)) {
496 const auto recurrenceId = parseDt(data.value(eventOriginalStartTimeParam).toMap(), timezone, false);
497 event->setRecurrenceId(recurrenceId.dt);
498 }
499
500 if (data.value(eventTransparencyParam).toString() == transparentTransparency) {
501 event->setTransparency(Event::Transparent);
502 } else { /* Assume opaque as default transparency */
503 event->setTransparency(Event::Opaque);
504 }
505
506 const auto attendees = data.value(eventAttendeesParam).toList();
507 for (const auto &a : attendees) {
508 const auto att = a.toMap();
509 KCalendarCore::Attendee attendee(att.value(attendeeDisplayNameParam).toString(), att.value(attendeeEmailParam).toString());
510 const auto responseStatus = att.value(attendeeResponseStatusParam).toString();
511 if (responseStatus == acceptedStatus) {
512 attendee.setStatus(KCalendarCore::Attendee::Accepted);
513 } else if (responseStatus == declinedStatus) {
514 attendee.setStatus(KCalendarCore::Attendee::Declined);
515 } else if (responseStatus == tentativeStatus) {
516 attendee.setStatus(KCalendarCore::Attendee::Tentative);
517 } else {
518 attendee.setStatus(KCalendarCore::Attendee::NeedsAction);
519 }
520
521 if (att.value(attendeeOptionalParam).toBool()) {
522 attendee.setRole(KCalendarCore::Attendee::OptParticipant);
523 }
524 const auto uid = att.value(idParam).toString();
525 if (!uid.isEmpty()) {
526 attendee.setUid(uid);
527 } else {
528 // Set some UID, just so that the results are reproducible
529 attendee.setUid(QString::number(qHash(attendee.email())));
530 }
531 event->addAttendee(attendee, true);
532 }
533
534 /* According to RFC, only events with attendees can have an organizer.
535 * Google seems to ignore it, so we must take care of it here */
536 if (event->attendeeCount() > 0) {
537 KCalendarCore::Person organizer;
538 const auto organizerData = data.value(eventOrganizerParam).toMap();
539 organizer.setName(organizerData.value(organizerDisplayNameParam).toString());
540 organizer.setEmail(organizerData.value(organizerEmailParam).toString());
541 event->setOrganizer(organizer);
542 }
543
544 const QStringList recrs = data.value(eventRecurrenceParam).toStringList();
545 for (const QString &rec : recrs) {
546 KCalendarCore::ICalFormat format;
547 const QStringView recView(rec);
548 if (recView.left(5) == QLatin1StringView("RRULE")) {
549 auto recurrenceRule = std::make_unique<KCalendarCore::RecurrenceRule>();
550 const auto ok = format.fromString(recurrenceRule.get(), rec.mid(6));
551 Q_UNUSED(ok)
552 recurrenceRule->setRRule(rec);
553 event->recurrence()->addRRule(recurrenceRule.release());
554 } else if (recView.left(6) == QLatin1StringView("EXRULE")) {
555 auto recurrenceRule = std::make_unique<KCalendarCore::RecurrenceRule>();
556 const auto ok = format.fromString(recurrenceRule.get(), rec.mid(7));
557 Q_UNUSED(ok)
558 recurrenceRule->setRRule(rec);
559 event->recurrence()->addExRule(recurrenceRule.release());
560 } else if (recView.left(6) == QLatin1StringView("EXDATE")) {
561 KCalendarCore::DateList exdates = Private::parseRDate(rec);
562 event->recurrence()->setExDates(exdates);
563 } else if (recView.left(5) == QLatin1StringView("RDATE")) {
564 KCalendarCore::DateList rdates = Private::parseRDate(rec);
565 event->recurrence()->setRDates(rdates);
566 }
567 }
568
569 const auto reminders = data.value(eventRemindersParam).toMap();
570 if (reminders.contains(reminderUseDefaultParam) && reminders.value(reminderUseDefaultParam).toBool()) {
571 event->setUseDefaultReminders(true);
572 } else {
573 event->setUseDefaultReminders(false);
574 }
575
576 const auto overrides = reminders.value(reminderOverridesParam).toList();
577 for (const auto &r : overrides) {
578 const auto reminderOverride = r.toMap();
579 auto alarm = KCalendarCore::Alarm::Ptr::create(static_cast<KCalendarCore::Incidence *>(event.data()));
580 alarm->setTime(event->dtStart());
581
582 if (reminderOverride.value(reminderMethodParam).toString() == popupMethod) {
583 alarm->setType(KCalendarCore::Alarm::Display);
584 } else if (reminderOverride.value(reminderMethodParam).toString() == emailMethod) {
585 alarm->setType(KCalendarCore::Alarm::Email);
586 } else {
587 alarm->setType(KCalendarCore::Alarm::Invalid);
588 continue;
589 }
590
591 alarm->setStartOffset(KCalendarCore::Duration(reminderOverride.value(reminderMinutesParam).toInt() * (-60)));
592 alarm->setEnabled(true);
593 event->addAlarm(alarm);
594 }
595
596 const auto extendedProperties = data.value(eventExtendedPropertiesParam).toMap();
597 setEventCategories(event, extendedProperties.value(propertyPrivateParam).toMap());
598 setEventCategories(event, extendedProperties.value(propertySharedParam).toMap());
599
600 if (const auto eventType = data.value(eventTypeParam).toString(); !eventType.isEmpty()) {
601 event->setEventType(eventTypeFromString(eventType));
602 } else {
603 event->setEventType(Event::EventType::Default);
604 }
605
606 return event.dynamicCast<Object>();
607}
608
609namespace
610{
611
612enum class SerializeDtFlag { AllDay = 1 << 0, IsDtEnd = 1 << 1, HasRecurrence = 1 << 2 };
613using SerializeDtFlags = QFlags<SerializeDtFlag>;
614
615QVariantMap serializeDt(const EventPtr &event, const QDateTime &dt, SerializeDtFlags flags)
616{
617 QVariantMap rv;
618 if (flags & SerializeDtFlag::AllDay) {
619 /* For Google, all-day events starts on Monday and ends on Tuesday,
620 * while in KDE, it both starts and ends on Monday. */
621 const auto adjusted = dt.addDays((flags & SerializeDtFlag::IsDtEnd) ? 1 : 0);
622 rv.insert(dateParam, adjusted.toString(QStringLiteral("yyyy-MM-dd")));
623 } else {
624 rv.insert(dateTimeParam, Utils::rfc3339DateToString(dt));
625 QString tzEnd = QString::fromUtf8(dt.timeZone().id());
626 if (flags & SerializeDtFlag::HasRecurrence && tzEnd.isEmpty()) {
627 tzEnd = QString::fromUtf8(QTimeZone::utc().id());
628 }
629 if (!tzEnd.isEmpty()) {
630 rv.insert(timeZoneParam, Private::checkAndConverCDOTZID(tzEnd, event));
631 }
632 }
633
634 return rv;
635}
636
637} // namespace
638
639QByteArray eventToJSON(const EventPtr &event, EventSerializeFlags flags)
640{
641 QVariantMap data;
642
643 data.insert(kindParam, eventKind);
644
645 if (!(flags & EventSerializeFlag::NoID)) {
646 data.insert(idParam, event->id());
647 }
648
649 data.insert(eventiCalUIDParam, event->uid());
650
651 if (event->status() == KCalendarCore::Incidence::StatusConfirmed) {
652 data.insert(eventStatusParam, confirmedStatus);
653 } else if (event->status() == KCalendarCore::Incidence::StatusCanceled) {
654 data.insert(eventStatusParam, canceledStatus);
655 } else if (event->status() == KCalendarCore::Incidence::StatusTentative) {
656 data.insert(eventStatusParam, tentativeStatus);
657 }
658
659 data.insert(eventSummaryParam, event->summary());
660 data.insert(eventDescriptionParam, event->description());
661 data.insert(eventLocationParam, event->location());
662
663 QVariantList recurrence;
664 KCalendarCore::ICalFormat format;
665 const auto exRules = event->recurrence()->exRules();
666 const auto rRules = event->recurrence()->rRules();
667 recurrence.reserve(rRules.size() + rRules.size() + 2);
668 for (KCalendarCore::RecurrenceRule *rRule : rRules) {
669 recurrence.push_back(format.toString(rRule).remove(QStringLiteral("\r\n")));
670 }
671 for (KCalendarCore::RecurrenceRule *rRule : exRules) {
672 recurrence.push_back(format.toString(rRule).remove(QStringLiteral("\r\n")));
673 }
674
675 QStringList dates;
676 const auto rDates = event->recurrence()->rDates();
677 dates.reserve(rDates.size());
678 for (const auto &rDate : rDates) {
679 dates.push_back(rDate.toString(QStringLiteral("yyyyMMdd")));
680 }
681
682 if (!dates.isEmpty()) {
683 recurrence.push_back(QString(QStringLiteral("RDATE;VALUE=DATA:") + dates.join(QLatin1Char(','))));
684 }
685
686 dates.clear();
687 const auto exDates = event->recurrence()->exDates();
688 dates.reserve(exDates.size());
689 for (const auto &exDate : exDates) {
690 dates.push_back(exDate.toString(QStringLiteral("yyyyMMdd")));
691 }
692
693 if (!dates.isEmpty()) {
694 recurrence.push_back(QString(QStringLiteral("EXDATE;VALUE=DATE:") + dates.join(QLatin1Char(','))));
695 }
696
697 if (!recurrence.isEmpty()) {
698 data.insert(eventRecurrenceParam, recurrence);
699 }
700
701 SerializeDtFlags dtFlags;
702 if (event->allDay()) {
703 dtFlags |= SerializeDtFlag::AllDay;
704 }
705 if (!recurrence.isEmpty()) {
706 dtFlags |= SerializeDtFlag::HasRecurrence;
707 }
708
709 data.insert(eventStartPram, serializeDt(event, event->dtStart(), dtFlags));
710 data.insert(eventEndParam, serializeDt(event, event->dtEnd(), dtFlags | SerializeDtFlag::IsDtEnd));
711
712 if (event->hasRecurrenceId()) {
713 data.insert(eventOrganizerParam, serializeDt(event, event->recurrenceId(), dtFlags));
714 data.insert(eventRecurringEventIdParam, event->id());
715 }
716
717 if (event->transparency() == Event::Transparent) {
718 data.insert(eventTransparencyParam, transparentTransparency);
719 } else {
720 data.insert(eventTransparencyParam, opaqueTransparency);
721 }
722
723 QVariantList atts;
724 const auto attendees = event->attendees();
725 for (const auto &attee : attendees) {
726 QVariantMap att{{attendeeDisplayNameParam, attee.name()}, {attendeeEmailParam, attee.email()}};
727
728 if (attee.status() == KCalendarCore::Attendee::Accepted) {
729 att.insert(attendeeResponseStatusParam, acceptedStatus);
730 } else if (attee.status() == KCalendarCore::Attendee::Declined) {
731 att.insert(attendeeResponseStatusParam, declinedStatus);
732 } else if (attee.status() == KCalendarCore::Attendee::Tentative) {
733 att.insert(attendeeResponseStatusParam, tentativeStatus);
734 } else {
735 att.insert(attendeeResponseStatusParam, needsActionStatus);
736 }
737
738 if (attee.role() == KCalendarCore::Attendee::OptParticipant) {
739 att.insert(attendeeOptionalParam, true);
740 }
741 if (!attee.uid().isEmpty()) {
742 att.insert(idParam, attee.uid());
743 }
744 atts.append(att);
745 }
746
747 if (!atts.isEmpty()) {
748 data.insert(eventAttendeesParam, atts);
749
750 /* According to RFC, event without attendees should not have
751 * any organizer. */
752 const auto organizer = event->organizer();
753 if (!organizer.isEmpty()) {
754 data.insert(eventOrganizerParam, QVariantMap{{organizerDisplayNameParam, organizer.fullName()}, {organizerEmailParam, organizer.email()}});
755 }
756 }
757
758 QVariantList overrides;
759 const auto alarms = event->alarms();
760 for (const auto &alarm : alarms) {
761 QVariantMap reminderOverride;
762 if (alarm->type() == KCalendarCore::Alarm::Display) {
763 reminderOverride.insert(reminderMethodParam, popupMethod);
764 } else if (alarm->type() == KCalendarCore::Alarm::Email) {
765 reminderOverride.insert(reminderMethodParam, emailMethod);
766 } else {
767 continue;
768 }
769 reminderOverride.insert(reminderMinutesParam, (int)(alarm->startOffset().asSeconds() / -60));
770
771 overrides.push_back(reminderOverride);
772 }
773
774 data.insert(eventRemindersParam, QVariantMap{{reminderUseDefaultParam, false}, {reminderOverridesParam, overrides}});
775
776 if (!event->categories().isEmpty()) {
777 data.insert(eventExtendedPropertiesParam, QVariantMap{{propertySharedParam, QVariantMap{{categoriesProperty, event->categoriesStr()}}}});
778 }
779
780 // eventType not allowed in update, only in create
781 if (!data.contains(idParam)) {
782 data.insert(eventTypeParam, eventTypeToString(event->eventType()));
783 }
784
785 /* TODO: Implement support for additional features:
786 * https://developers.google.com/calendar/api/v3/reference/events/insert
787 */
788
789 const auto document = QJsonDocument::fromVariant(data);
790 return document.toJson(QJsonDocument::Compact);
791}
792
793ObjectsList parseEventJSONFeed(const QByteArray &jsonFeed, FeedData &feedData)
794{
795 const auto document = QJsonDocument::fromJson(jsonFeed);
796 const auto data = document.toVariant().toMap();
797
798 QString timezone;
799 if (data.value(kindParam) == eventsKind) {
800 if (data.contains(nextPageTokenParam)) {
801 QString calendarId = feedData.requestUrl.toString().remove(QStringLiteral("https://www.googleapis.com/calendar/v3/calendars/"));
802 calendarId = calendarId.left(calendarId.indexOf(QLatin1Char('/')));
803 feedData.nextPageUrl = feedData.requestUrl;
804 // replace the old pageToken with a new one
805 QUrlQuery query(feedData.nextPageUrl);
806 query.removeQueryItem(pageTokenParam);
807 query.addQueryItem(pageTokenParam, data.value(nextPageTokenParam).toString());
808 feedData.nextPageUrl.setQuery(query);
809 }
810 if (data.contains(timeZoneParam)) {
811 // This should always be in Olson format
812 timezone = data.value(timeZoneParam).toString();
813 }
814 if (data.contains(nextSyncTokenParam)) {
815 feedData.syncToken = data[nextSyncTokenParam].toString();
816 }
817 } else {
818 return {};
819 }
820
821 ObjectsList list;
822 const auto items = data.value(itemsParam).toList();
823 list.reserve(items.size());
824 for (const auto &i : items) {
825 list.push_back(Private::JSONToEvent(i.toMap(), timezone));
826 }
827
828 return list;
829}
830
831QString eventTypeToString(Event::EventType eventType)
832{
833 switch (eventType) {
834 case Event::EventType::Default:
835 return QStringLiteral("default");
836 case Event::EventType::FocusTime:
837 return QStringLiteral("focusTime");
838 case Event::EventType::OutOfOffice:
839 return QStringLiteral("outOfOffice");
840 case Event::EventType::WorkingLocation:
841 return QStringLiteral("workingLocation");
842 }
843
844 Q_UNREACHABLE();
845 return {};
846}
847
848Event::EventType eventTypeFromString(const QString &eventType)
849{
850 const auto eventTypeLc = eventType.toLower();
851 if (eventTypeLc == u"default") {
852 return Event::EventType::Default;
853 }
854 if (eventTypeLc == u"outofoffice") {
855 return Event::EventType::OutOfOffice;
856 }
857 if (eventTypeLc == u"focustime") {
858 return Event::EventType::FocusTime;
859 }
860 if (eventTypeLc == u"workinglocation") {
861 return Event::EventType::WorkingLocation;
862 }
863
864 return Event::EventType::Default;
865}
866
867/******************************** PRIVATE ***************************************/
868
869KCalendarCore::DateList Private::parseRDate(const QString &rule)
870{
871 KCalendarCore::DateList list;
872 QTimeZone tz;
873 QStringView value;
874 const auto left = QStringView(rule).left(rule.indexOf(QLatin1Char(':')));
875
876 const auto params = left.split(QLatin1Char(';'));
877 for (const auto &param : params) {
878 if (param.startsWith(QLatin1StringView("VALUE"))) {
879 value = param.mid(param.indexOf(QLatin1Char('=')) + 1);
880 } else if (param.startsWith(QLatin1StringView("TZID"))) {
881 auto _name = param.mid(param.indexOf(QLatin1Char('=')) + 1);
882 tz = QTimeZone(_name.toUtf8());
883 }
884 }
885 const auto datesStr = QStringView(rule).mid(rule.lastIndexOf(QLatin1Char(':')) + 1);
886 const auto dates = datesStr.split(QLatin1Char(','));
887 for (const auto &date : dates) {
888 QDate dt;
889
890 if (value == QLatin1StringView("DATE")) {
891 dt = QDate::fromString(date.toString(), QStringLiteral("yyyyMMdd"));
892 } else if (value == QLatin1StringView("PERIOD")) {
893 const auto start = date.left(date.indexOf(QLatin1Char('/')));
894 QDateTime kdt = Utils::rfc3339DateFromString(start.toString());
895 if (tz.isValid()) {
896 kdt.setTimeZone(tz);
897 }
898
899 dt = kdt.date();
900 } else {
901 QDateTime kdt = Utils::rfc3339DateFromString(date.toString());
902 if (tz.isValid()) {
903 kdt.setTimeZone(tz);
904 }
905
906 dt = kdt.date();
907 }
908
909 list.push_back(dt);
910 }
911
912 return list;
913}
914
915namespace
916{
917
918/* Based on "Time Zone to CdoTimeZoneId Map"
919 * https://docs.microsoft.com/en-us/previous-versions/office/developer/exchange-server-2007/aa563018(v=exchg.80)
920 *
921 * The mapping is not exact, since the CdoTimeZoneId usually refers to a
922 * region of multiple countries, so I always picked one of the countries
923 * in the specified region and used it's TZID.
924 */
925static const std::map<int, QLatin1StringView> MSCDOTZIDTable = {
926 {0, QLatin1StringView("UTC")},
927 {1, QLatin1StringView("Europe/London")}, /* GMT Greenwich Mean Time; Dublin, Edinburgh, London */
928 /* Seriously? *sigh* Let's handle these two in checkAndConvertCDOTZID() */
929 //{2, QLatin1StringView("Europe/Lisbon")}, /* GMT Greenwich Mean Time: Dublin, Edinburgh, Lisbon, London */
930 //{2, QLatin1StringView("Europe/Sarajevo")}, /* GMT+01:00 Sarajevo, Skopje, Sofija, Vilnius, Warsaw, Zagreb */
931 {3, QLatin1StringView("Europe/Paris")}, /* GMT+01:00 Paris, Madrid, Brussels, Copenhagen */
932 {4, QLatin1StringView("Europe/Berlin")}, /* GMT+01:00 Amsterdam, Berlin, Bern, Rome, Stockholm, Vienna */
933 {5, QLatin1StringView("Europe/Bucharest")}, /* GMT+02:00 Bucharest */
934 {6, QLatin1StringView("Europe/Prague")}, /* GMT+01:00 Prague, Central Europe */
935 {7, QLatin1StringView("Europe/Athens")}, /* GMT+02:00 Athens, Istanbul, Minsk */
936 {8, QLatin1StringView("America/Brazil")}, /* GMT-03:00 Brasilia */
937 {9, QLatin1StringView("America/Halifax")}, /* GMT-04:00 Atlantic time (Canada) */
938 {10, QLatin1StringView("America/New_York")}, /* GMT-05:00 Eastern Time (US & Canada) */
939 {11, QLatin1StringView("America/Chicago")}, /* GMT-06:00 Central Time (US & Canada) */
940 {12, QLatin1StringView("America/Denver")}, /* GMT-07:00 Mountain Time (US & Canada) */
941 {13, QLatin1StringView("America/Los_Angeles")}, /* GMT-08:00 Pacific Time (US & Canada); Tijuana */
942 {14, QLatin1StringView("America/Anchorage")}, /* GMT-09:00 Alaska */
943 {15, QLatin1StringView("Pacific/Honolulu")}, /* GMT-10:00 Hawaii */
944 {16, QLatin1StringView("Pacific/Apia")}, /* GMT-11:00 Midway Island, Samoa */
945 {17, QLatin1StringView("Pacific/Auckland")}, /* GMT+12:00 Auckland, Wellington */
946 {18, QLatin1StringView("Australia/Brisbane")}, /* GMT+10:00 Brisbane, East Australia */
947 {19, QLatin1StringView("Australia/Adelaide")}, /* GMT+09:30 Adelaide, Central Australia */
948 {20, QLatin1StringView("Asia/Tokyo")}, /* GMT+09:00 Osaka, Sapporo, Tokyo */
949 {21, QLatin1StringView("Asia/Singapore")}, /* GMT+08:00 Kuala Lumpur, Singapore */
950 {22, QLatin1StringView("Asia/Bangkok")}, /* GMT+07:00 Bangkok, Hanoi, Jakarta */
951 {23, QLatin1StringView("Asia/Calcutta")}, /* GMT+05:30 Kolkata, Chennai, Mumbai, New Delhi, India Standard Time */
952 {24, QLatin1StringView("Asia/Dubai")}, /* GMT+04:00 Abu Dhabi, Muscat */
953 {25, QLatin1StringView("Asia/Tehran")}, /* GMT+03:30 Tehran */
954 {26, QLatin1StringView("Asia/Baghdad")}, /* GMT+03:00 Baghdad */
955 {27, QLatin1StringView("Asia/Jerusalem")}, /* GMT+02:00 Israel, Jerusalem Standard Time */
956 {28, QLatin1StringView("America/St_Johns")}, /* GMT-03:30 Newfoundland */
957 {29, QLatin1StringView("Atlantic/Portugal")}, /* GMT-01:00 Azores */
958 {30, QLatin1StringView("America/Noronha")}, /* GMT-02:00 Mid-Atlantic */
959 {31, QLatin1StringView("Africa/Monrovia")}, /* GMT Casablanca, Monrovia */
960 {32, QLatin1StringView("America/Argentina/Buenos_Aires")}, /* GMT-03:00 Buenos Aires, Georgetown */
961 {33, QLatin1StringView("America/La_Paz")}, /* GMT-04:00 Caracas, La Paz */
962 {34, QLatin1StringView("America/New_York")}, /* GMT-05:00 Indiana (East) */
963 {35, QLatin1StringView("America/Bogota")}, /* GMT-05:00 Bogota, Lima, Quito */
964 {36, QLatin1StringView("America/Winnipeg")}, /* GMT-06:00 Saskatchewan */
965 {37, QLatin1StringView("America/Mexico_City")}, /* GMT-06:00 Mexico City, Tegucigalpa */
966 {38, QLatin1StringView("America/Phoenix")}, /* GMT-07:00 Arizona */
967 {39, QLatin1StringView("Pacific/Kwajalein")}, /* GMT-12:00 Eniwetok, Kwajalein, Dateline Time */
968 {40, QLatin1StringView("Pacific/Fiji")}, /* GMT+12:00 Fušál, Kamchatka, Mashall Is. */
969 {41, QLatin1StringView("Pacific/Noumea")}, /* GMT+11:00 Magadan, Solomon Is., New Caledonia */
970 {42, QLatin1StringView("Australia/Hobart")}, /* GMT+10:00 Hobart, Tasmania */
971 {43, QLatin1StringView("Pacific/Guam")}, /* GMT+10:00 Guam, Port Moresby */
972 {44, QLatin1StringView("Australia/Darwin")}, /* GMT+09:30 Darwin */
973 {45, QLatin1StringView("Asia/Shanghai")}, /* GMT+08:00 Beijing, Chongqing, Hong Kong SAR, Urumqi */
974 {46, QLatin1StringView("Asia/Omsk")}, /* GMT+06:00 Almaty, Novosibirsk, North Central Asia */
975 {47, QLatin1StringView("Asia/Karachi")}, /* GMT+05:00 Islamabad, Karachi, Tashkent */
976 {48, QLatin1StringView("Asia/Kabul")}, /* GMT+04:30 Kabul */
977 {49, QLatin1StringView("Africa/Cairo")}, /* GMT+02:00 Cairo */
978 {50, QLatin1StringView("Africa/Harare")}, /* GMT+02:00 Harare, Pretoria */
979 {51, QLatin1StringView("Europe/Moscow")}, /* GMT+03:00 Moscow, St. Petersburg, Volgograd */
980 {53, QLatin1StringView("Atlantic/Cape_Verde")}, /* GMT-01:00 Cape Verde Is. */
981 {54, QLatin1StringView("Asia/Tbilisi")}, /* GMT+04:00 Baku, Tbilisi, Yerevan */
982 {55, QLatin1StringView("America/Tegucigalpa")}, /* GMT-06:00 Central America */
983 {56, QLatin1StringView("Africa/Nairobi")}, /* GMT+03:00 East Africa, Nairobi */
984 {58, QLatin1StringView("Asia/Yekaterinburg")}, /* GMT+05:00 Ekaterinburg */
985 {59, QLatin1StringView("Europe/Helsinki")}, /* GMT+02:00 Helsinki, Riga, Tallinn */
986 {60, QLatin1StringView("America/Greenland")}, /* GMT-03:00 Greenland */
987 {61, QLatin1StringView("Asia/Rangoon")}, /* GMT+06:30 Yangon (Rangoon) */
988 {62, QLatin1StringView("Asia/Katmandu")}, /* GMT+05:45 Kathmandu, Nepal */
989 {63, QLatin1StringView("Asia/Irkutsk")}, /* GMT+08:00 Irkutsk, Ulaan Bataar */
990 {64, QLatin1StringView("Asia/Krasnoyarsk")}, /* GMT+07:00 Krasnoyarsk */
991 {65, QLatin1StringView("America/Santiago")}, /* GMT-04:00 Santiago */
992 {66, QLatin1StringView("Asia/Colombo")}, /* GMT+06:00 Sri Jayawardenepura, Sri Lanka */
993 {67, QLatin1StringView("Pacific/Tongatapu")}, /* GMT+13:00 Nuku'alofa, Tonga */
994 {68, QLatin1StringView("Asia/Vladivostok")}, /* GMT+10:00 Vladivostok */
995 {69, QLatin1StringView("Africa/Bangui")}, /* GMT+01:00 West Central Africa */
996 {70, QLatin1StringView("Asia/Yakutsk")}, /* GMT+09:00 Yakutsk */
997 {71, QLatin1StringView("Asia/Dhaka")}, /* GMT+06:00 Astana, Dhaka */
998 {72, QLatin1StringView("Asia/Seoul")}, /* GMT+09:00 Seoul, Korea Standard time */
999 {73, QLatin1StringView("Australia/Perth")}, /* GMT+08:00 Perth, Western Australia */
1000 {74, QLatin1StringView("Asia/Kuwait")}, /* GMT+03:00 Arab, Kuwait, Riyadh */
1001 {75, QLatin1StringView("Asia/Taipei")}, /* GMT+08:00 Taipei */
1002 {76, QLatin1StringView("Australia/Sydney")} /* GMT+10:00 Canberra, Melbourne, Sydney */
1003};
1004
1005/* Based on "Microsoft Time Zone Index Values"
1006 * https://support.microsoft.com/en-gb/help/973627/microsoft-time-zone-index-values
1007 *
1008 * The mapping is not exact, since the TZID usually refers to a
1009 * region of multiple countries, so I always picked one of the countries
1010 * in the specified region and used it's TZID.
1011 *
1012 * The Olson timezones are taken from https://en.wikipedia.org/wiki/List_of_tz_database_time_zones
1013 *
1014 * Note: using std::map, because it allows heterogeneous lookup, i.e. I can lookup the QLatin1StringView
1015 * keys by using QString value, which is not possible with Qt containers.
1016 */
1017static const std::map<QLatin1StringView, QLatin1StringView, std::less<>> MSSTTZTable = {
1018 {QLatin1StringView("Dateline Standard Time"), QLatin1StringView("Pacific/Kwajalein")}, /* (GMT-12:00) International Date Line West */
1019 {QLatin1StringView("Samoa Standard Time"), QLatin1StringView("Pacific/Apia")}, /* (GMT-11:00) Midway Island, Samoa */
1020 {QLatin1StringView("Hawaiian Standard Time"), QLatin1StringView("Pacific/Honolulu")}, /* (GMT-10:00) Hawaii */
1021 {QLatin1StringView("Alaskan Standard Time"), QLatin1StringView("America/Anchorage")}, /* (GMT-09:00) Alaska */
1022 {QLatin1StringView("Pacific Standard Time"), QLatin1StringView("America/Los_Angeles")}, /* (GMT-08:00) Pacific Time (US and Canada); Tijuana */
1023 {QLatin1StringView("Mountain Standard Time"), QLatin1StringView("America/Denver")}, /* (GMT-07:00) Mountain Time (US and Canada) */
1024 {QLatin1StringView("Mexico Standard Time 2"), QLatin1StringView("America/Chihuahua")}, /* (GMT-07:00) Chihuahua, La Paz, Mazatlan */
1025 {QLatin1StringView("U.S. Mountain Standard Time"), QLatin1StringView("America/Phoenix")}, /* (GMT-07:00) Arizona */
1026 {QLatin1StringView("Central Standard Time"), QLatin1StringView("America/Chicago")}, /* (GMT-06:00) Central Time (US and Canada */
1027 {QLatin1StringView("Canada Central Standard Time"), QLatin1StringView("America/Winnipeg")}, /* (GMT-06:00) Saskatchewan */
1028 {QLatin1StringView("Mexico Standard Time"), QLatin1StringView("America/Mexico_City")}, /* (GMT-06:00) Guadalajara, Mexico City, Monterrey */
1029 {QLatin1StringView("Central America Standard Time"), QLatin1StringView("America/Chicago")}, /* (GMT-06:00) Central America */
1030 {QLatin1StringView("Eastern Standard Time"), QLatin1StringView("America/New_York")}, /* (GMT-05:00) Eastern Time (US and Canada) */
1031 {QLatin1StringView("U.S. Eastern Standard Time"), QLatin1StringView("America/New_York")}, /* (GMT-05:00) Indiana (East) */
1032 {QLatin1StringView("S.A. Pacific Standard Time"), QLatin1StringView("America/Bogota")}, /* (GMT-05:00) Bogota, Lima, Quito */
1033 {QLatin1StringView("Atlantic Standard Time"), QLatin1StringView("America/Halifax")}, /* (GMT-04:00) Atlantic Time (Canada) */
1034 {QLatin1StringView("S.A. Western Standard Time"), QLatin1StringView("America/La_Paz")}, /* (GMT-04:00) Caracas, La Paz */
1035 {QLatin1StringView("Pacific S.A. Standard Time"), QLatin1StringView("America/Santiago")}, /* (GMT-04:00) Santiago */
1036 {QLatin1StringView("Newfoundland and Labrador Standard Time"), QLatin1StringView("America/St_Johns")}, /* (GMT-03:30) Newfoundland and Labrador */
1037 {QLatin1StringView("E. South America Standard Time"), QLatin1StringView("America/Brazil")}, /* (GMT-03:00) Brasilia */
1038 {QLatin1StringView("S.A. Eastern Standard Time"), QLatin1StringView("America/Argentina/Buenos_Aires")}, /* (GMT-03:00) Buenos Aires, Georgetown */
1039 {QLatin1StringView("Greenland Standard Time"), QLatin1StringView("America/Greenland")}, /* (GMT-03:00) Greenland */
1040 {QLatin1StringView("Mid-Atlantic Standard Time"), QLatin1StringView("America/Noronha")}, /* (GMT-02:00) Mid-Atlantic */
1041 {QLatin1StringView("Azores Standard Time"), QLatin1StringView("Atlantic/Portugal")}, /* (GMT-01:00) Azores */
1042 {QLatin1StringView("Cape Verde Standard Time"), QLatin1StringView("Atlantic/Cape_Verde")}, /* (GMT-01:00) Cape Verde Islands */
1043 {QLatin1StringView("GMT Standard Time"), QLatin1StringView("Europe/London")}, /* (GMT) Greenwich Mean Time: Dublin, Edinburgh, Lisbon, London */
1044 {QLatin1StringView("Greenwich Standard Time"), QLatin1StringView("Africa/Casablanca")}, /* (GMT) Casablanca, Monrovia */
1045 {QLatin1StringView("Central Europe Standard Time"), QLatin1StringView("Europe/Prague")}, /* (GMT+01:00) Belgrade, Bratislava, Budapest, Ljubljana, Prague */
1046 {QLatin1StringView("Central European Standard Time"), QLatin1StringView("Europe/Sarajevo")}, /* (GMT+01:00) Sarajevo, Skopje, Warsaw, Zagreb */
1047 {QLatin1StringView("Romance Standard Time"), QLatin1StringView("Europe/Brussels")}, /* (GMT+01:00) Brussels, Copenhagen, Madrid, Paris */
1048 {QLatin1StringView("W. Europe Standard Time"), QLatin1StringView("Europe/Amsterdam")}, /* (GMT+01:00) Amsterdam, Berlin, Bern, Rome, Stockholm, Vienna */
1049 {QLatin1StringView("W. Central Africa Standard Time"), QLatin1StringView("Africa/Bangui")}, /* (GMT+01:00) West Central Africa */
1050 {QLatin1StringView("E. Europe Standard Time"), QLatin1StringView("Europe/Bucharest")}, /* (GMT+02:00) Bucharest */
1051 {QLatin1StringView("Egypt Standard Time"), QLatin1StringView("Africa/Cairo")}, /* (GMT+02:00) Cairo */
1052 {QLatin1StringView("FLE Standard Time"), QLatin1StringView("Europe/Helsinki")}, /* (GMT+02:00) Helsinki, Kiev, Riga, Sofia, Tallinn, Vilnius */
1053 {QLatin1StringView("GTB Standard Time"), QLatin1StringView("Europe/Athens")}, /* (GMT+02:00) Athens, Istanbul, Minsk */
1054 {QLatin1StringView("Israel Standard Time"), QLatin1StringView("Europe/Athens")}, /* (GMT+02:00) Jerusalem */
1055 {QLatin1StringView("South Africa Standard Time"), QLatin1StringView("Africa/Harare")}, /* (GMT+02:00) Harare, Pretoria */
1056 {QLatin1StringView("Russian Standard Time"), QLatin1StringView("Europe/Moscow")}, /* (GMT+03:00) Moscow, St. Petersburg, Volgograd */
1057 {QLatin1StringView("Arab Standard Time"), QLatin1StringView("Asia/Kuwait")}, /* (GMT+03:00) Kuwait, Riyadh */
1058 {QLatin1StringView("E. Africa Standard Time"), QLatin1StringView("Africa/Nairobi")}, /* (GMT+03:00) Nairobi */
1059 {QLatin1StringView("Arabic Standard Time"), QLatin1StringView("Asia/Baghdad")}, /* (GMT+03:00) Baghdad */
1060 {QLatin1StringView("Iran Standard Time"), QLatin1StringView("Asia/Tehran")}, /* (GMT+03:30) Tehran */
1061 {QLatin1StringView("Arabian Standard Time"), QLatin1StringView("Asia/Dubai")}, /* (GMT+04:00) Abu Dhabi, Muscat */
1062 {QLatin1StringView("Caucasus Standard Time"), QLatin1StringView("Asia/Tbilisi")}, /* (GMT+04:00) Baku, Tbilisi, Yerevan */
1063 {QLatin1StringView("Transitional Islamic State of Afghanistan Standard Time"), QLatin1StringView("Asia/Kabul")}, /* (GMT+04:30) Kabul */
1064 {QLatin1StringView("Ekaterinburg Standard Time"), QLatin1StringView("Asia/Yekaterinburg")}, /* (GMT+05:00) Ekaterinburg */
1065 {QLatin1StringView("West Asia Standard Time"), QLatin1StringView("Asia/Karachi")}, /* (GMT+05:00) Islamabad, Karachi, Tashkent */
1066 {QLatin1StringView("India Standard Time"), QLatin1StringView("Asia/Calcutta")}, /* (GMT+05:30) Chennai, Kolkata, Mumbai, New Delhi */
1067 {QLatin1StringView("Nepal Standard Time"), QLatin1StringView("Asia/Calcutta")}, /* (GMT+05:45) Kathmandu */
1068 {QLatin1StringView("Central Asia Standard Time"), QLatin1StringView("Asia/Dhaka")}, /* (GMT+06:00) Astana, Dhaka */
1069 {QLatin1StringView("Sri Lanka Standard Time"), QLatin1StringView("Asia/Colombo")}, /* (GMT+06:00) Sri Jayawardenepura */
1070 {QLatin1StringView("N. Central Asia Standard Time"), QLatin1StringView("Asia/Omsk")}, /* (GMT+06:00) Almaty, Novosibirsk */
1071 {QLatin1StringView("Myanmar Standard Time"), QLatin1StringView("Asia/Rangoon")}, /* (GMT+06:30) Yangon Rangoon */
1072 {QLatin1StringView("S.E. Asia Standard Time"), QLatin1StringView("Asia/Bangkok")}, /* (GMT+07:00) Bangkok, Hanoi, Jakarta */
1073 {QLatin1StringView("North Asia Standard Time"), QLatin1StringView("Asia/Krasnoyarsk")}, /* (GMT+07:00) Krasnoyarsk */
1074 {QLatin1StringView("China Standard Time"), QLatin1StringView("Asia/Shanghai")}, /* (GMT+08:00) Beijing, Chongqing, Hong Kong SAR, Urumqi */
1075 {QLatin1StringView("Singapore Standard Time"), QLatin1StringView("Asia/Singapore")}, /* (GMT+08:00) Kuala Lumpur, Singapore */
1076 {QLatin1StringView("Taipei Standard Time"), QLatin1StringView("Asia/Taipei")}, /* (GMT+08:00) Taipei */
1077 {QLatin1StringView("W. Australia Standard Time"), QLatin1StringView("Australia/Perth")}, /* (GMT+08:00) Perth */
1078 {QLatin1StringView("North Asia East Standard Time"), QLatin1StringView("Asia/Irkutsk")}, /* (GMT+08:00) Irkutsk, Ulaanbaatar */
1079 {QLatin1StringView("Korea Standard Time"), QLatin1StringView("Asia/Seoul")}, /* (GMT+09:00) Seoul */
1080 {QLatin1StringView("Tokyo Standard Time"), QLatin1StringView("Asia/Tokyo")}, /* (GMT+09:00) Osaka, Sapporo, Tokyo */
1081 {QLatin1StringView("Yakutsk Standard Time"), QLatin1StringView("Asia/Yakutsk")}, /* (GMT+09:00) Yakutsk */
1082 {QLatin1StringView("A.U.S. Central Standard Time"), QLatin1StringView("Australia/Darwin")}, /* (GMT+09:30) Darwin */
1083 {QLatin1StringView("Cen. Australia Standard Time"), QLatin1StringView("Australia/Adelaide")}, /* (GMT+09:30) Adelaide */
1084 {QLatin1StringView("A.U.S. Eastern Standard Time"), QLatin1StringView("Australia/Sydney")}, /* (GMT+10:00) Canberra, Melbourne, Sydney */
1085 {QLatin1StringView("E. Australia Standard Time"), QLatin1StringView("Australia/Brisbane")}, /* (GMT+10:00) Brisbane */
1086 {QLatin1StringView("Tasmania Standard Time"), QLatin1StringView("Australia/Hobart")}, /* (GMT+10:00) Hobart */
1087 {QLatin1StringView("Vladivostok Standard Time"), QLatin1StringView("Asia/Vladivostok")}, /* (GMT+10:00) Vladivostok */
1088 {QLatin1StringView("West Pacific Standard Time"), QLatin1StringView("Pacific/Guam")}, /* (GMT+10:00) Guam, Port Moresby */
1089 {QLatin1StringView("Central Pacific Standard Time"), QLatin1StringView("Pacific/Noumea")}, /* (GMT+11:00) Magadan, Solomon Islands, New Caledonia */
1090 {QLatin1StringView("Fiji Islands Standard Time"), QLatin1StringView("Pacific/Fiji")}, /* (GMT+12:00) Fiji Islands, Kamchatka, Marshall Islands */
1091 {QLatin1StringView("New Zealand Standard Time"), QLatin1StringView("Pacific/Auckland")}, /* (GMT+12:00) Auckland, Wellington */
1092 {QLatin1StringView("Tonga Standard Time"), QLatin1StringView("Pacific/Tongatapu")}, /* (GMT+13:00) Nuku'alofa */
1093 {QLatin1StringView("Azerbaijan Standard Time"), QLatin1StringView("America/Argentina/Buenos_Aires")}, /* (GMT-03:00) Buenos Aires */
1094 {QLatin1StringView("Middle East Standard Time"), QLatin1StringView("Asia/Beirut")}, /* (GMT+02:00) Beirut */
1095 {QLatin1StringView("Jordan Standard Time"), QLatin1StringView("Asia/Amman")}, /* (GMT+02:00) Amman */
1096 {QLatin1StringView("Central Standard Time (Mexico)"), QLatin1StringView("America/Mexico_City")}, /* (GMT-06:00) Guadalajara, Mexico City, Monterrey - New */
1097 {QLatin1StringView("Mountain Standard Time (Mexico)"), QLatin1StringView("America/Ojinaga")}, /* (GMT-07:00) Chihuahua, La Paz, Mazatlan - New */
1098 {QLatin1StringView("Pacific Standard Time (Mexico)"), QLatin1StringView("America/Tijuana")}, /* (GMT-08:00) Tijuana, Baja California */
1099 {QLatin1StringView("Namibia Standard Time"), QLatin1StringView("Africa/Windhoek")}, /* (GMT+02:00) Windhoek */
1100 {QLatin1StringView("Georgian Standard Time"), QLatin1StringView("Asia/Tbilisi")}, /* (GMT+03:00) Tbilisi */
1101 {QLatin1StringView("Central Brazilian Standard Time"), QLatin1StringView("America/Manaus")}, /*(GMT-04:00) Manaus */
1102 {QLatin1StringView("Montevideo Standard Time"), QLatin1StringView("America/Montevideo")}, /* (GMT-03:00) Montevideo */
1103 {QLatin1StringView("Armenian Standard Time"), QLatin1StringView("Asia/Yerevan")}, /* (GMT+04:00) Yerevan */
1104 {QLatin1StringView("Venezuela Standard Time"), QLatin1StringView("America/Caracas")}, /* (GMT-04:30) Caracas */
1105 {QLatin1StringView("Argentina Standard Time"), QLatin1StringView("America/Argentina/Buenos_Aires")}, /* (GMT-03:00) Buenos Aires */
1106 {QLatin1StringView("Morocco Standard Time"), QLatin1StringView("Africa/Casablanca")}, /* (GMT) Casablanca */
1107 {QLatin1StringView("Pakistan Standard Time"), QLatin1StringView("Asia/Karachi")}, /* (GMT+05:00) Islamabad, Karachi */
1108 {QLatin1StringView("Mauritius Standard Time"), QLatin1StringView("Indian/Mauritius")}, /* (GMT+04:00) Port Louis */
1109 {QLatin1StringView("UTC"), QLatin1StringView("UTC")}, /* (GMT) Coordinated Universal Time */
1110 {QLatin1StringView("Paraguay Standard Time"), QLatin1StringView("America/Asuncion")}, /* (GMT-04:00) Asuncion */
1111 {QLatin1StringView("Kamchatka Standard Time"), QLatin1StringView("Asia/Kamchatka")}, /* (GMT+12:00) Petropavlovsk-Kamchatsky */
1112};
1113} // namespace
1114
1115QString Private::checkAndConverCDOTZID(const QString &tzid, const EventPtr &event)
1116{
1117 /* Try to match the @tzid to any valid timezone we know. */
1118 QTimeZone tz(tzid.toLatin1());
1119 if (tz.isValid()) {
1120 /* Yay, @tzid is a valid TZID in Olson format */
1121 return tzid;
1122 }
1123
1124 /* Damn, no match. Parse the iCal and try to find X-MICROSOFT-CDO-TZID
1125 * property that we can match against the MSCDOTZIDTable */
1126 KCalendarCore::ICalFormat format;
1127 /* Use a copy of @event, otherwise it would be deleted when ptr is destroyed */
1128 KCalendarCore::Incidence::Ptr incidence = event.dynamicCast<KCalendarCore::Incidence>();
1129 const QString vcard = format.toICalString(incidence);
1130 const QStringList properties = vcard.split(QLatin1Char('\n'));
1131 int CDOId = -1;
1132 for (const QString &property : properties) {
1133 if (property.startsWith(u"X-MICROSOFT-CDO-TZID")) {
1134 QStringList parsed = property.split(QLatin1Char(':'));
1135 if (parsed.length() != 2) {
1136 break;
1137 }
1138
1139 CDOId = parsed.at(1).toInt();
1140 break;
1141 }
1142 }
1143
1144 /* Wheeee, we have X-MICROSOFT-CDO-TZID, try to map it to Olson format */
1145 if (CDOId > -1) {
1146 /* *sigh* Some expert in MS assigned the same ID to two different timezones... */
1147 if (CDOId == 2) {
1148 /* GMT Greenwich Mean Time: Dublin, Edinburgh, Lisbon, London */
1149 if (tzid.contains(QLatin1StringView("Dublin")) || tzid.contains(QLatin1StringView("Edinburgh")) || tzid.contains(QLatin1StringView("Lisbon"))
1150 || tzid.contains(QLatin1StringView("London"))) {
1151 return QStringLiteral("Europe/London");
1152 }
1153
1154 /* GMT+01:00 Sarajevo, Skopje, Sofija, Vilnius, Warsaw, Zagreb */
1155 else if (tzid.contains(QLatin1StringView("Sarajevo")) || tzid.contains(QLatin1StringView("Skopje")) || tzid.contains(QLatin1StringView("Sofija"))
1156 || tzid.contains(QLatin1StringView("Vilnius")) || tzid.contains(QLatin1StringView("Warsaw")) || tzid.contains(QLatin1StringView("Zagreb"))) {
1157 return QStringLiteral("Europe/Sarajevo");
1158 }
1159 }
1160
1161 const auto it = MSCDOTZIDTable.find(CDOId);
1162 if (it != MSCDOTZIDTable.cend()) {
1163 return it->second;
1164 }
1165 }
1166
1167 /* We failed to map to X-MICROSOFT-CDO-TZID. Let's try mapping the TZID
1168 * onto the Microsoft Standard Time Zones */
1169 const auto it = MSSTTZTable.find(tzid);
1170 if (it != MSSTTZTable.cend()) {
1171 return it->second;
1172 }
1173
1174 /* Fail/ Just return the original TZID and hope Google will accept it
1175 * (though we know it won't) */
1176 return tzid;
1177}
1178
1179} // namespace CalendarService
1180
1181} // namespace KGAPI2
KCalendarCore::ICalFormat::toString
QString toString(const Calendar::Ptr &calendar) override
KCalendarCore::ICalFormat::toICalString
QString toICalString(const Incidence::Ptr &incidence)
KCalendarCore::ICalFormat::fromString
bool fromString(const Calendar::Ptr &calendar, const QString &string)
KCalendarCore::Person::email
QString email() const
KCalendarCore::Person::setEmail
void setEmail(const QString &email)
KCalendarCore::Person::fullName
QString fullName() const
KCalendarCore::Person::setName
void setName(const QString &name)
KCalendarCore::Person::isEmpty
bool isEmpty() const
KGAPI2::Calendar
An object that represents a Google calendar.
Definition calendar.h:28
KGAPI2::Event
Represents a single event from Google Calendar.
Definition calendar/event.h:29
KGAPI2::FeedData
Structure to store additional information about a feed.
Definition types.h:24
KGAPI2::FeedData::syncToken
QString syncToken
Sync token that can be used for incremental updates by some of the services.
Definition types.h:42
KGAPI2::FeedData::requestUrl
QUrl requestUrl
Original URL of the request.
Definition types.h:39
KGAPI2::FeedData::nextPageUrl
QUrl nextPageUrl
Link to next page of feed.
Definition types.h:38
start
Q_SCRIPTABLE Q_NOREPLY void start()
Akonadi::CalendarUtils::incidence
AKONADI_CALENDAR_EXPORT KCalendarCore::Incidence::Ptr incidence(const Akonadi::Item &item)
Akonadi::CalendarUtils::event
AKONADI_CALENDAR_EXPORT KCalendarCore::Event::Ptr event(const Akonadi::Item &item)
KCalendarCore::qHash
KCALENDARCORE_EXPORT size_t qHash(const KCalendarCore::Period &key, size_t seed=0)
KGAPI2::CalendarService::eventToJSON
QByteArray eventToJSON(const EventPtr &event, EventSerializeFlags flags)
Serializes Event into JSON.
Definition calendarservice.cpp:639
KGAPI2::CalendarService::updateCalendarUrl
QUrl updateCalendarUrl(const QString &calendarID)
Returns URL for updating existing calendar.
Definition calendarservice.cpp:91
KGAPI2::CalendarService::fetchCalendarsUrl
QUrl fetchCalendarsUrl()
Returns URL for fetching calendars list.
Definition calendarservice.cpp:77
KGAPI2::CalendarService::removeCalendarUrl
QUrl removeCalendarUrl(const QString &calendarID)
Returns URL for removing an existing calendar.
Definition calendarservice.cpp:105
KGAPI2::CalendarService::updateEventUrl
QUrl updateEventUrl(const QString &calendarID, const QString &eventID, SendUpdatesPolicy updatePolicy)
Returns URL for updating a single event.
Definition calendarservice.cpp:146
KGAPI2::CalendarService::createEventUrl
QUrl createEventUrl(const QString &calendarID, SendUpdatesPolicy updatePolicy)
Returns URL creating new events.
Definition calendarservice.cpp:156
KGAPI2::CalendarService::parseEventJSONFeed
ObjectsList parseEventJSONFeed(const QByteArray &jsonFeed, FeedData &feedData)
Parses JSON feed into list of Events.
Definition calendarservice.cpp:793
KGAPI2::CalendarService::importEventUrl
QUrl importEventUrl(const QString &calendarID, SendUpdatesPolicy updatePolicy)
Returns URL importing private copies of existing events.
Definition calendarservice.cpp:166
KGAPI2::CalendarService::createCalendarUrl
QUrl createCalendarUrl()
Returns URL for creating a new calendar.
Definition calendarservice.cpp:98
KGAPI2::CalendarService::moveEventUrl
QUrl moveEventUrl(const QString &sourceCalendar, const QString &destCalendar, const QString &eventID)
Returns URL for moving event between calendars.
Definition calendarservice.cpp:183
KGAPI2::CalendarService::calendarToJSON
QByteArray calendarToJSON(const CalendarPtr &calendar)
Serializes calendar into JSON.
Definition calendarservice.cpp:344
KGAPI2::CalendarService::fetchCalendarUrl
QUrl fetchCalendarUrl(const QString &calendarID)
Returns URL for fetching single calendar.
Definition calendarservice.cpp:84
KGAPI2::CalendarService::JSONToCalendar
CalendarPtr JSONToCalendar(const QByteArray &jsonData)
Parses calendar JSON data into Calendar object.
Definition calendarservice.cpp:291
KGAPI2::CalendarService::prepareRequest
QNetworkRequest prepareRequest(const QUrl &url)
Preparse a QNetworkRequest for given URL.
Definition calendarservice.cpp:67
KGAPI2::CalendarService::eventTypeToString
QString eventTypeToString(Event::EventType eventType)
Converts event type enum value to string.
Definition calendarservice.cpp:831
KGAPI2::CalendarService::JSONToEvent
EventPtr JSONToEvent(const QByteArray &jsonData)
Parses event JSON into Event object.
Definition calendarservice.cpp:390
KGAPI2::CalendarService::parseCalendarJSONFeed
ObjectsList parseCalendarJSONFeed(const QByteArray &jsonFeed, FeedData &feedData)
Parses JSON feed into list of Calendars.
Definition calendarservice.cpp:363
KGAPI2::CalendarService::APIVersion
QString APIVersion()
Supported API version.
Definition calendarservice.cpp:286
KGAPI2::CalendarService::freeBusyQueryUrl
QUrl freeBusyQueryUrl()
Returns URL for freebusy queries.
Definition calendarservice.cpp:193
KGAPI2::CalendarService::fetchEventsUrl
QUrl fetchEventsUrl(const QString &calendarID)
Returns URL for fetching all events from a specific calendar.
Definition calendarservice.cpp:112
KGAPI2::CalendarService::eventTypeFromString
Event::EventType eventTypeFromString(const QString &eventType)
Converts event type string to enum value.
Definition calendarservice.cpp:848
KGAPI2::CalendarService::fetchEventUrl
QUrl fetchEventUrl(const QString &calendarID, const QString &eventID)
Returns URL for fetching a single event from a specific calendar.
Definition calendarservice.cpp:119
KGAPI2::CalendarService::removeEventUrl
QUrl removeEventUrl(const QString &calendarID, const QString &eventID)
Returns URL for removing events.
Definition calendarservice.cpp:176
KGAPI2
A job to fetch a single map tile described by a StaticMapUrl.
Definition blog.h:16
KGAPI2::SendUpdatesPolicy
SendUpdatesPolicy
Determines whether Google Calendar should send updates to participants.
Definition enums.h:22
KGAPI2::SendUpdatesPolicy::ExternalOnly
@ ExternalOnly
Send updates to all attendees.
KGAPI2::SendUpdatesPolicy::None
@ None
Only send updates to non-Google Calendar participants.
KRecentDirs::list
KIOCORE_EXPORT QStringList list(const QString &fileClass)
KStandardGuiItem::properties
KGuiItem properties()
QByteArray::insert
QByteArray & insert(qsizetype i, QByteArrayView data)
QDate::fromString
QDate fromString(QStringView string, QStringView format, QCalendar cal)
QDateTime::addDays
QDateTime addDays(qint64 ndays) const const
QDateTime::date
QDate date() const const
QDateTime::fromString
QDateTime fromString(QStringView string, QStringView format, QCalendar cal)
QDateTime::setTimeZone
void setTimeZone(const QTimeZone &toZone)
QDateTime::timeZone
QTimeZone timeZone() const const
QDateTime::toTimeZone
QDateTime toTimeZone(const QTimeZone &timeZone) const const
QJsonDocument::fromJson
QJsonDocument fromJson(const QByteArray &json, QJsonParseError *error)
QJsonDocument::fromVariant
QJsonDocument fromVariant(const QVariant &variant)
QJsonDocument::toVariant
QVariant toVariant() const const
QList::at
const_reference at(qsizetype i) const const
QList::clear
void clear()
QList::isEmpty
bool isEmpty() const const
QList::length
qsizetype length() const const
QList::push_back
void push_back(parameter_type value)
QList::reserve
void reserve(qsizetype size)
QList::value
T value(qsizetype i) const const
QNetworkRequest::setRawHeader
void setRawHeader(const QByteArray &headerName, const QByteArray &headerValue)
QSharedPointer::create
QSharedPointer< T > create(Args &&... args)
QSharedPointer::data
T * data() const const
QSharedPointer::dynamicCast
QSharedPointer< X > dynamicCast() const const
QString::contains
bool contains(QChar ch, Qt::CaseSensitivity cs) const const
QString::fromUtf8
QString fromUtf8(QByteArrayView str)
QString::indexOf
qsizetype indexOf(QChar ch, qsizetype from, Qt::CaseSensitivity cs) const const
QString::isEmpty
bool isEmpty() const const
QString::lastIndexOf
qsizetype lastIndexOf(QChar ch, Qt::CaseSensitivity cs) const const
QString::left
QString left(qsizetype n) const const
QString::number
QString number(double n, char format, int precision)
QString::remove
QString & remove(QChar ch, Qt::CaseSensitivity cs)
QString::toLatin1
QByteArray toLatin1() const const
QString::toLower
QString toLower() const const
QString::toUtf8
QByteArray toUtf8() const const
QStringList::join
QString join(QChar separator) const const
QStringView::left
QStringView left(qsizetype length) const const
QStringView::mid
QStringView mid(qsizetype start, qsizetype length) const const
QStringView::split
QList< QStringView > split(QChar sep, Qt::SplitBehavior behavior, Qt::CaseSensitivity cs) const const
QTimeZone::id
QByteArray id() const const
QTimeZone::isValid
bool isValid() const const
QTimeZone::utc
QTimeZone utc()
QUrl::fromPercentEncoding
QString fromPercentEncoding(const QByteArray &input)
QUrl::setPath
void setPath(const QString &path, ParsingMode mode)
QUrl::setQuery
void setQuery(const QString &query, ParsingMode mode)
QUrl::toString
QString toString(FormattingOptions options) const const
QVariant::toMap
QMap< QString, QVariant > toMap() const const
This file is part of the KDE documentation.
Documentation copyright © 1996-2024 The KDE developers.
Generated on Mon Nov 4 2024 16:36:13 by doxygen 1.12.0 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.