diff --git a/CMakeLists.txt b/CMakeLists.txt
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -5,6 +5,8 @@
 
 project(kgapi VERSION ${KGAPI_LIB_VERSION})
 
+set(CMAKE_CXX_STANDARD 14)
+
 # ECM setup
 set(KF5_MIN_VERSION "5.62.0")
 
diff --git a/src/calendar/calendar.h b/src/calendar/calendar.h
--- a/src/calendar/calendar.h
+++ b/src/calendar/calendar.h
@@ -28,6 +28,7 @@
 #include "kgapicalendar_export.h"
 
 #include <QColor>
+#include <QScopedPointer>
 
 namespace KGAPI2
 {
@@ -184,7 +185,7 @@
 
   protected:
     class Private;
-    Private * const d;
+    QScopedPointer<Private> const d;
 
 };
 
diff --git a/src/calendar/calendar.cpp b/src/calendar/calendar.cpp
--- a/src/calendar/calendar.cpp
+++ b/src/calendar/calendar.cpp
@@ -29,9 +29,8 @@
 class Q_DECL_HIDDEN Calendar::Private
 {
   public:
-    Private();
-    Private(const Private &other);
-    ~Private() {}
+    Private() = default;
+    Private(const Private &other) = default;
 
     QString uid;
     QString title;
@@ -45,39 +44,19 @@
     RemindersList reminders;
 };
 
-Calendar::Private::Private()
-{
-}
-
-Calendar::Private::Private(const Private &other) :
-    uid(other.uid),
-    title(other.title),
-    details(other.details),
-    timezone(other.timezone),
-    location(other.location),
-    editable(other.editable),
-    backgroundColor(other.backgroundColor),
-    foregroundColor(other.foregroundColor),
-    reminders(other.reminders)
-{
-}
-
 Calendar::Calendar() :
     Object(),
     d(new Private)
 {
 }
 
 Calendar::Calendar(const Calendar &other) :
     Object(other),
-    d(new Private(*(other.d)))
+    d(new Private(*(other.d.get())))
 {
 }
 
-Calendar::~Calendar()
-{
-    delete d;
-}
+Calendar::~Calendar() = default;
 
 bool Calendar::operator==(const Calendar &other) const
 {
diff --git a/src/calendar/calendarcreatejob.h b/src/calendar/calendarcreatejob.h
--- a/src/calendar/calendarcreatejob.h
+++ b/src/calendar/calendarcreatejob.h
@@ -26,6 +26,8 @@
 #include "createjob.h"
 #include "kgapicalendar_export.h"
 
+#include <QScopedPointer>
+
 namespace KGAPI2 {
 
 /**
@@ -42,7 +44,7 @@
   public:
 
     /**
-     * @brief Constructs a job that will create given @p calendar in user's 
+     * @brief Constructs a job that will create given @p calendar in user's
      *        Google Calendar account
      *
      * @param calendar Calendar to create
@@ -86,7 +88,7 @@
 
   private:
     class Private;
-    Private * const d;
+    QScopedPointer<Private> const d;
     friend class Private;
 
 };
diff --git a/src/calendar/calendarcreatejob.cpp b/src/calendar/calendarcreatejob.cpp
--- a/src/calendar/calendarcreatejob.cpp
+++ b/src/calendar/calendarcreatejob.cpp
@@ -56,32 +56,19 @@
 }
 
 
-CalendarCreateJob::~CalendarCreateJob()
-{
-    delete d;
-}
+CalendarCreateJob::~CalendarCreateJob() = default;
 
 void CalendarCreateJob::start()
 {
     if (d->calendars.atEnd()) {
         emitFinished();
         return;
     }
 
-    CalendarPtr calendar = d->calendars.current();
-    const QUrl url = CalendarService::createCalendarUrl();
-    QNetworkRequest request(url);
-    request.setRawHeader("GData-Version", CalendarService::APIVersion().toLatin1());
-
+    const CalendarPtr calendar = d->calendars.current();
+    const auto request = CalendarService::prepareRequest(CalendarService::createCalendarUrl());
     const QByteArray rawData = CalendarService::calendarToJSON(calendar);
 
-    QStringList headers;
-    const auto rawHeaderList = request.rawHeaderList();
-    headers.reserve(rawHeaderList.size());
-    for (const QByteArray &str : qAsConst(rawHeaderList)) {
-        headers << QLatin1String(str) + QLatin1String(": ") + QLatin1String(request.rawHeader(str));
-    }
-
     enqueueRequest(request, rawData, QStringLiteral("application/json"));
 }
 
diff --git a/src/calendar/calendardeletejob.h b/src/calendar/calendardeletejob.h
--- a/src/calendar/calendardeletejob.h
+++ b/src/calendar/calendardeletejob.h
@@ -25,6 +25,8 @@
 #include "deletejob.h"
 #include "kgapicalendar_export.h"
 
+#include <QScopedPointer>
+
 namespace KGAPI2 {
 
 /**
@@ -108,7 +110,7 @@
     void handleReply(const QNetworkReply* reply, const QByteArray& rawData) override;
   private:
     class Private;
-    Private * const d;
+    QScopedPointer<Private> const d;
     friend class Private;
 
 };
diff --git a/src/calendar/calendardeletejob.cpp b/src/calendar/calendardeletejob.cpp
--- a/src/calendar/calendardeletejob.cpp
+++ b/src/calendar/calendardeletejob.cpp
@@ -68,10 +68,7 @@
 }
 
 
-CalendarDeleteJob::~CalendarDeleteJob()
-{
-    delete d;
-}
+CalendarDeleteJob::~CalendarDeleteJob() = default;
 
 void CalendarDeleteJob::start()
 {
@@ -81,16 +78,7 @@
     }
 
     const QString calendarId = d->calendarsIds.current();
-    const QUrl url = CalendarService::removeCalendarUrl(calendarId);
-    QNetworkRequest request(url);
-    request.setRawHeader("GData-Version", CalendarService::APIVersion().toLatin1());
-
-    QStringList headers;
-    const auto rawHeaderList = request.rawHeaderList();
-    headers.reserve(rawHeaderList.size());
-    for (const QByteArray &str : qAsConst(rawHeaderList)) {
-        headers << QLatin1String(str) + QLatin1String(": ") + QLatin1String(request.rawHeader(str));
-    }
+    const auto request = CalendarService::prepareRequest(CalendarService::removeCalendarUrl(calendarId));
 
     enqueueRequest(request);
 }
diff --git a/src/calendar/calendarfetchjob.h b/src/calendar/calendarfetchjob.h
--- a/src/calendar/calendarfetchjob.h
+++ b/src/calendar/calendarfetchjob.h
@@ -26,6 +26,8 @@
 #include "fetchjob.h"
 #include "kgapicalendar_export.h"
 
+#include <QScopedPointer>
+
 namespace KGAPI2 {
 
 /**
@@ -83,7 +85,7 @@
 
   private:
     class Private;
-    Private * const d;
+    QScopedPointer<Private> const d;
     friend class Private;
 
 };
diff --git a/src/calendar/calendarfetchjob.cpp b/src/calendar/calendarfetchjob.cpp
--- a/src/calendar/calendarfetchjob.cpp
+++ b/src/calendar/calendarfetchjob.cpp
@@ -36,54 +36,24 @@
 
 class Q_DECL_HIDDEN CalendarFetchJob::Private
 {
-  public:
-    Private(CalendarFetchJob *parent);
-
-    QNetworkRequest createRequest(const QUrl &url);
-
+public:
     QString calendarId;
-
-  private:
-    CalendarFetchJob * const q;
 };
 
-CalendarFetchJob::Private::Private(CalendarFetchJob* parent):
-    q(parent)
-{
-}
-
-QNetworkRequest CalendarFetchJob::Private::createRequest(const QUrl& url)
-{
-    QNetworkRequest request(url);
-    request.setRawHeader("GData-Version", CalendarService::APIVersion().toLatin1());
-
-    QStringList headers;
-    const auto rawHeaderList = request.rawHeaderList();
-    headers.reserve(rawHeaderList.size());
-    for (const QByteArray &str : qAsConst(rawHeaderList)) {
-        headers << QLatin1String(str) + QLatin1String(": ") + QLatin1String(request.rawHeader(str));
-    }
-
-    return request;
-}
-
 CalendarFetchJob::CalendarFetchJob(const AccountPtr& account, QObject* parent):
     FetchJob(account, parent),
-    d(new Private(this))
+    d(new Private())
 {
 }
 
 CalendarFetchJob::CalendarFetchJob(const QString& calendarId, const AccountPtr& account, QObject* parent):
     FetchJob(account, parent),
-    d(new Private(this))
+    d(new Private())
 {
     d->calendarId = calendarId;
 }
 
-CalendarFetchJob::~CalendarFetchJob()
-{
-    delete d;
-}
+CalendarFetchJob::~CalendarFetchJob() = default;
 
 void CalendarFetchJob::start()
 {
@@ -93,7 +63,7 @@
     } else {
         url = CalendarService::fetchCalendarUrl(d->calendarId);
     }
-    const QNetworkRequest request = d->createRequest(url);
+    const auto request = CalendarService::prepareRequest(url);
     enqueueRequest(request);
 }
 
@@ -119,7 +89,7 @@
     }
 
     if (feedData.nextPageUrl.isValid()) {
-        const QNetworkRequest request = d->createRequest(feedData.nextPageUrl);
+        const auto request = CalendarService::prepareRequest(feedData.nextPageUrl);
         enqueueRequest(request);
     }
 
diff --git a/src/calendar/calendarmodifyjob.h b/src/calendar/calendarmodifyjob.h
--- a/src/calendar/calendarmodifyjob.h
+++ b/src/calendar/calendarmodifyjob.h
@@ -26,6 +26,8 @@
 #include "modifyjob.h"
 #include "kgapicalendar_export.h"
 
+#include <QScopedPointer>
+
 namespace KGAPI2 {
 
 /**
@@ -81,11 +83,11 @@
      * @param rawData
      */
     ObjectsList handleReplyWithItems(const QNetworkReply *reply,
-                                             const QByteArray& rawData) override;
+                                     const QByteArray& rawData) override;
 
   private:
     class Private;
-    Private * const d;
+    QScopedPointer<Private> const d;
     friend class Private;
 };
 
diff --git a/src/calendar/calendarmodifyjob.cpp b/src/calendar/calendarmodifyjob.cpp
--- a/src/calendar/calendarmodifyjob.cpp
+++ b/src/calendar/calendarmodifyjob.cpp
@@ -54,10 +54,7 @@
     d->calendars = calendars;
 }
 
-CalendarModifyJob::~CalendarModifyJob()
-{
-    delete d;
-}
+CalendarModifyJob::~CalendarModifyJob() = default;
 
 void CalendarModifyJob::start()
 {
@@ -67,20 +64,9 @@
     }
 
     const CalendarPtr calendar = d->calendars.current();
-
-    const QUrl url = CalendarService::updateCalendarUrl(calendar->uid());
-    QNetworkRequest request(url);
-    request.setRawHeader("GData-Version", CalendarService::APIVersion().toLatin1());
-
+    const auto request = CalendarService::prepareRequest(CalendarService::updateCalendarUrl(calendar->uid()));
     const QByteArray rawData = CalendarService::calendarToJSON(calendar);
 
-    QStringList headers;
-    const auto rawHeaderList = request.rawHeaderList();
-    headers.reserve(rawHeaderList.size());
-    for (const QByteArray &str : qAsConst(rawHeaderList)) {
-        headers << QLatin1String(str) + QLatin1String(": ") + QLatin1String(request.rawHeader(str));
-    }
-
     enqueueRequest(request, rawData, QStringLiteral("application/json"));
 }
 
diff --git a/src/calendar/calendarservice.h b/src/calendar/calendarservice.h
--- a/src/calendar/calendarservice.h
+++ b/src/calendar/calendarservice.h
@@ -29,6 +29,8 @@
 
 #include <QFlags>
 
+class QNetworkRequest;
+
 namespace KGAPI2
 {
 
@@ -45,6 +47,13 @@
     };
     using EventSerializeFlags = QFlags<EventSerializeFlag>;
 
+    /**
+     * @vrief Preparse a QNetworkRequest for given URL
+     *
+     * @param url
+     */
+    KGAPICALENDAR_EXPORT QNetworkRequest prepareRequest(const QUrl &url);
+
     /**
      * @brief Parses calendar JSON data into Calendar object
      *
diff --git a/src/calendar/calendarservice.cpp b/src/calendar/calendarservice.cpp
--- a/src/calendar/calendarservice.cpp
+++ b/src/calendar/calendarservice.cpp
@@ -40,6 +40,10 @@
 #include <QTimeZone>
 #include <QVariant>
 #include <QFlags>
+#include <QNetworkRequest>
+
+#include <map>
+#include <memory>
 
 namespace KGAPI2
 {
@@ -55,26 +59,34 @@
 ObjectPtr JSONToEvent(const QVariantMap &data, const QString &timezone = QString());
 
 /**
-     * Checks whether TZID is in Olson format and converts it to it if neccessary
-     *
-     * This is mainly to handle crazy Microsoft TZIDs like
-     * "(GMT) Greenwich Mean Time/Dublin/Edinburgh/London", because Google only
-     * accepts TZIDs in Olson format ("Europe/London").
-     *
-     * It first tries to match the given \p tzid to all TZIDs in KTimeZones::zones().
-     * If it fails, it parses the \p event, looking for X-MICROSOFT-CDO-TZID
-     * property and than matches it to Olson-formatted TZID using a table.
-     *
-     * When the method fails to process the TZID, it returns the original \p tzid
-     * in hope, that Google will cope with it.
-     */
+ * Checks whether TZID is in Olson format and converts it to it if neccessary
+ *
+ * This is mainly to handle crazy Microsoft TZIDs like
+ * "(GMT) Greenwich Mean Time/Dublin/Edinburgh/London", because Google only
+ * accepts TZIDs in Olson format ("Europe/London").
+ *
+ * It first tries to match the given \p tzid to all TZIDs in KTimeZones::zones().
+ * If it fails, it parses the \p event, looking for X-MICROSOFT-CDO-TZID
+ * property and than matches it to Olson-formatted TZID using a table.
+ *
+ * When the method fails to process the TZID, it returns the original \p tzid
+ * in hope, that Google will cope with it.
+ */
 QString checkAndConverCDOTZID(const QString &tzid, const EventPtr& event);
 
 static const QUrl GoogleApisUrl(QStringLiteral("https://www.googleapis.com"));
 static const QString CalendarListBasePath(QStringLiteral("/calendar/v3/users/me/calendarList"));
 static const QString CalendarBasePath(QStringLiteral("/calendar/v3/calendars"));
 }
 
+QNetworkRequest prepareRequest(const QUrl &url)
+{
+    QNetworkRequest request(url);
+    request.setRawHeader("GData-Version", CalendarService::APIVersion().toLatin1());
+
+    return request;
+}
+
 /************* URLS **************/
 
 QUrl fetchCalendarsUrl()
@@ -141,14 +153,16 @@
     Q_UNREACHABLE();
 }
 
+static const QString sendUpatesQueryParam = QStringLiteral("sendUpdates");
+static const QString destinationQueryParam = QStringLiteral("destination");
 }
 
 QUrl updateEventUrl(const QString& calendarID, const QString& eventID, SendUpdatesPolicy updatePolicy)
 {
     QUrl url(Private::GoogleApisUrl);
     url.setPath(Private::CalendarBasePath % QLatin1Char('/') % calendarID % QLatin1String("/events/") % eventID);
     QUrlQuery query(url);
-    query.addQueryItem(QStringLiteral("sendUpdates"), sendUpdatesPolicyToString(updatePolicy));
+    query.addQueryItem(sendUpatesQueryParam, sendUpdatesPolicyToString(updatePolicy));
     url.setQuery(query);
     return url;
 }
@@ -158,7 +172,7 @@
     QUrl url(Private::GoogleApisUrl);
     url.setPath(Private::CalendarBasePath % QLatin1Char('/') % calendarID % QLatin1String("/events"));
     QUrlQuery query(url);
-    query.addQueryItem(QStringLiteral("sendUpdates"), sendUpdatesPolicyToString(updatePolicy));
+    query.addQueryItem(sendUpatesQueryParam, sendUpdatesPolicyToString(updatePolicy));
     url.setQuery(query);
     return url;
 }
@@ -175,7 +189,7 @@
     QUrl url(Private::GoogleApisUrl);
     url.setPath(Private::CalendarBasePath % QLatin1Char('/') % sourceCalendar % QLatin1String("/events/") % eventID);
     QUrlQuery query(url);
-    query.addQueryItem(QStringLiteral("destination"), destCalendar);
+    query.addQueryItem(destinationQueryParam, destCalendar);
     url.setQuery(query);
     return url;
 }
@@ -187,59 +201,139 @@
     return url;
 }
 
+namespace {
+
+static const auto kindParam = QStringLiteral("kind");
+static const auto idParam = QStringLiteral("id");
+static const auto etagParam = QStringLiteral("etag");
+
+static const auto nextPageTokenParam = QStringLiteral("nextPageToken");
+static const auto pageTokenParam = QStringLiteral("pageToken");
+static const auto itemsParam = QStringLiteral("items");
+
+static const auto calendarSummaryParam = QStringLiteral("summary");
+static const auto calendarDescriptionParam = QStringLiteral("description");
+static const auto calendarLocationParam = QStringLiteral("location");
+static const auto calendarTimezoneParam = QStringLiteral("timeZone");
+static const auto calendarBackgroundColorParam = QStringLiteral("backgroundColor");
+static const auto calendarForegroundColorParam = QStringLiteral("foregroundColor");
+static const auto calendarAccessRoleParam = QStringLiteral("accessRole");
+static const auto calendarDefaultRemindersParam = QStringLiteral("defaultReminders");
+static const auto reminderMethodParam = QStringLiteral("method");
+static const auto reminderMinutesParam = QStringLiteral("minutes");
+
+static const auto eventiCalUIDParam = QStringLiteral("iCalUID");
+static const auto eventStatusParam = QStringLiteral("status");
+static const auto eventCreatedParam = QStringLiteral("created");
+static const auto eventUpdatedParam = QStringLiteral("updated");
+static const auto eventSummaryParam = QStringLiteral("summary");
+static const auto eventDescriptionParam = QStringLiteral("description");
+static const auto eventLocationParam = QStringLiteral("location");
+static const auto eventStartPram = QStringLiteral("start");
+static const auto eventEndParam = QStringLiteral("end");
+static const auto eventOriginalStartTimeParam = QStringLiteral("originalStartTime");
+static const auto eventTransparencyParam = QStringLiteral("transparency");
+static const auto eventOrganizerParam = QStringLiteral("organizer");
+static const auto eventAttendeesParam = QStringLiteral("attendees");
+static const auto eventRecurrenceParam = QStringLiteral("recurrence");
+static const auto eventRemindersParam = QStringLiteral("reminders");
+static const auto eventExtendedPropertiesParam = QStringLiteral("extendedProperties");
+static const auto eventRecurringEventIdParam = QStringLiteral("recurringEventId");
+
+static const auto attendeeDisplayNameParam = QStringLiteral("displayName");
+static const auto attendeeEmailParam = QStringLiteral("email");
+static const auto attendeeResponseStatusParam = QStringLiteral("responseStatus");
+static const auto attendeeOptionalParam = QStringLiteral("optional");
+
+static const auto organizerDisplayNameParam = QStringLiteral("displayName");
+static const auto organizerEmailParam = QStringLiteral("email");
+
+static const auto reminderUseDefaultParam = QStringLiteral("useDefault");
+static const auto reminderOverridesParam = QStringLiteral("overrides");
+
+static const auto propertyPrivateParam = QStringLiteral("private");
+static const auto propertySharedParam = QStringLiteral("shared");
+
+static const auto dateParam = QStringLiteral("date");
+static const auto dateTimeParam = QStringLiteral("dateTime");
+static const auto timeZoneParam = QStringLiteral("timeZone");
+
+
+static const auto calendarListKind = QLatin1String("calendar#calendarList");
+static const auto calendarListEntryKind = QLatin1String("calendar#calendarListEntry");
+static const auto calendarKind = QLatin1String("calendar#calendar");
+static const auto eventKind = QLatin1String("calendar#event");
+static const auto eventsKind = QLatin1String("calendar#events");
+
+static const auto writerAccessRole = QLatin1String("writer");
+static const auto ownerAccessRole = QLatin1String("owner");
+static const auto emailMethod = QLatin1String("email");
+static const auto popupMethod = QLatin1String("popup");
+
+static const auto confirmedStatus = QLatin1String("confirmed");
+static const auto canceledStatus = QLatin1String("cancalled");
+static const auto tentativeStatus = QLatin1String("tentative");
+static const auto acceptedStatus = QLatin1String("accepted");
+static const auto needsActionStatus = QLatin1String("needsAction");
+static const auto transparentTransparency = QLatin1String("transparent");
+static const auto opaqueTransparency = QLatin1String("opaque");
+static const auto declinedStatus = QLatin1String("declined");
+static const auto categoriesProperty = QLatin1String("categories");
+
+}
+
 QString APIVersion()
 {
     return QStringLiteral("3");
 }
 
 CalendarPtr JSONToCalendar(const QByteArray& jsonData)
 {
-    QJsonDocument document = QJsonDocument::fromJson(jsonData);
-    QVariantMap calendar = document.toVariant().toMap();
+    const auto document = QJsonDocument::fromJson(jsonData);
+    const auto calendar = document.toVariant().toMap();
 
-    if ((calendar.value(QStringLiteral("kind")) != QLatin1String("calendar#calendarListEntry")) &&
-            (calendar.value(QStringLiteral("kind")) != QLatin1String("calendar#calendar"))) {
+    if (calendar.value(kindParam).toString() != calendarListEntryKind && calendar.value(kindParam).toString() != calendarKind) {
         return CalendarPtr();
     }
 
     return Private::JSONToCalendar(calendar).staticCast<Calendar>();
 }
 
 ObjectPtr Private::JSONToCalendar(const QVariantMap& data)
 {
-    CalendarPtr calendar(new Calendar);
+    auto calendar = CalendarPtr::create();
 
-    QString id = QUrl::fromPercentEncoding(data.value(QStringLiteral("id")).toByteArray());
+    const auto id = QUrl::fromPercentEncoding(data.value(idParam).toByteArray());
     calendar->setUid(id);
-    calendar->setEtag(data.value(QStringLiteral("etag")).toString());
-    calendar->setTitle(data.value(QStringLiteral("summary")).toString());
-    calendar->setDetails(data.value(QStringLiteral("description")).toString());
-    calendar->setLocation(data.value(QStringLiteral("location")).toString());
-    calendar->setTimezone(data.value(QStringLiteral("timeZone")).toString());
-    calendar->setBackgroundColor(QColor(data.value(QStringLiteral("backgroundColor")).toString()));
-    calendar->setForegroundColor(QColor(data.value(QStringLiteral("foregroundColor")).toString()));
-
-    if ((data.value(QStringLiteral("accessRole")).toString() == QLatin1String("writer")) ||
-            (data.value(QStringLiteral("accessRole")).toString() == QLatin1String("owner"))) {
+    calendar->setEtag(data.value(etagParam).toString());
+    calendar->setTitle(data.value(calendarSummaryParam).toString());
+    calendar->setDetails(data.value(calendarDescriptionParam).toString());
+    calendar->setLocation(data.value(calendarLocationParam).toString());
+    calendar->setTimezone(data.value(calendarTimezoneParam).toString());
+    calendar->setBackgroundColor(QColor(data.value(calendarBackgroundColorParam).toString()));
+    calendar->setForegroundColor(QColor(data.value(calendarForegroundColorParam).toString()));
+
+    if ((data.value(calendarAccessRoleParam).toString() == writerAccessRole) ||
+            (data.value(calendarAccessRoleParam).toString() == ownerAccessRole)) {
         calendar->setEditable(true);
     } else {
         calendar->setEditable(false);
     }
 
-    const QVariantList reminders = data.value(QStringLiteral("defaultReminders")).toList();
-    for (const QVariant &r : reminders) {
-        QVariantMap reminder = r.toMap();
+    const auto reminders = data.value(calendarDefaultRemindersParam).toList();
+    for (const auto &r : reminders) {
+        const auto reminder = r.toMap();
 
-        ReminderPtr rem(new Reminder());
-        if (reminder.value(QStringLiteral("method")).toString() == QLatin1String("email")) {
+        auto rem = ReminderPtr::create();
+        if (reminder.value(reminderMethodParam).toString() == emailMethod) {
             rem->setType(KCalendarCore::Alarm::Email);
-        } else if (reminder.value(QStringLiteral("method")).toString() == QLatin1String("popup")) {
+        } else if (reminder.value(reminderMethodParam).toString() == popupMethod) {
             rem->setType(KCalendarCore::Alarm::Display);
         } else {
             rem->setType(KCalendarCore::Alarm::Invalid);
         }
 
-        rem->setStartOffset(KCalendarCore::Duration(reminder.value(QStringLiteral("minutes")).toInt() * (-60)));
+        rem->setStartOffset(KCalendarCore::Duration(reminder.value(reminderMinutesParam).toInt() * (-60)));
 
         calendar->addDefaultReminer(rem);
     }
@@ -252,42 +346,43 @@
     QVariantMap output, entry;
 
     if (!calendar->uid().isEmpty()) {
-        entry.insert(QStringLiteral("id"), calendar->uid());
+        entry.insert(idParam, calendar->uid());
     }
 
-    entry.insert(QStringLiteral("summary"), calendar->title());
-    entry.insert(QStringLiteral("description"), calendar->details());
-    entry.insert(QStringLiteral("location"), calendar->location());
+    entry.insert(calendarSummaryParam, calendar->title());
+    entry.insert(calendarDescriptionParam, calendar->details());
+    entry.insert(calendarLocationParam, calendar->location());
     if (!calendar->timezone().isEmpty()) {
-        entry.insert(QStringLiteral("timeZone"), calendar->timezone());
+        entry.insert(calendarTimezoneParam, calendar->timezone());
     }
 
-    QJsonDocument document = QJsonDocument::fromVariant(entry);
+    const auto document = QJsonDocument::fromVariant(entry);
     return document.toJson(QJsonDocument::Compact);
 }
 
+
 ObjectsList parseCalendarJSONFeed(const QByteArray& jsonFeed, FeedData& feedData)
 {
-    QJsonDocument document = QJsonDocument::fromJson(jsonFeed);
-    QVariantMap data = document.toVariant().toMap();
+    const auto document = QJsonDocument::fromJson(jsonFeed);
+    const auto data = document.toVariant().toMap();
 
     ObjectsList list;
 
-    if (data.value(QStringLiteral("kind")) == QLatin1String("calendar#calendarList")) {
-        if (data.contains(QLatin1String("nextPageToken"))) {
+    if (data.value(kindParam).toString() == calendarListKind) {
+        if (data.contains(nextPageTokenParam)) {
             feedData.nextPageUrl = fetchCalendarsUrl();
             QUrlQuery query(feedData.nextPageUrl);
-            query.addQueryItem(QStringLiteral("pageToken"), data.value(QStringLiteral("nextPageToken")).toString());
+            query.addQueryItem(pageTokenParam, data.value(nextPageTokenParam).toString());
             feedData.nextPageUrl.setQuery(query);
         }
     } else {
-        return ObjectsList();
+        return {};
     }
 
-    const QVariantList items = data.value(QStringLiteral("items")).toList();
+    const auto items = data.value(itemsParam).toList();
     list.reserve(items.size());
-    for (const QVariant &i : items) {
-        list.append(Private::JSONToCalendar(i.toMap()));
+    for (const auto &i : items) {
+        list.push_back(Private::JSONToCalendar(i.toMap()));
     }
 
     return list;
@@ -301,7 +396,7 @@
         qCWarning(KGAPIDebug) << "Error parsing event JSON: " << error.errorString();
     }
     QVariantMap data = document.toVariant().toMap();
-    if (data.value(QStringLiteral("kind")) != QLatin1String("calendar#event")) {
+    if (data.value(kindParam).toString() != eventKind) {
         return EventPtr();
     }
 
@@ -317,25 +412,25 @@
 
 ParsedDt parseDt(const QVariantMap &data, const QString &timezone, bool isDtEnd)
 {
-    if (data.contains(QLatin1String("date"))) {
-        auto dt = QDateTime::fromString(data.value(QStringLiteral("date")).toString(), Qt::ISODate);
+    if (data.contains(dateParam)) {
+        auto dt = QDateTime::fromString(data.value(dateParam).toString(), Qt::ISODate);
         if (isDtEnd) {
             // Google reports all-day events to end on the next day, e.g. a
             // Monday all-day event will be reporting as starting on Monday and
             // ending on Tuesday, while KCalendarCore/iCal uses the same day for
             // dtEnd, so adjust the end date here.
             dt = dt.addDays(-1);
         }
         return {dt, true};
-    } else if (data.contains(QLatin1String("dateTime"))) {
-        auto dt = Utils::rfc3339DateFromString(data.value(QStringLiteral("dateTime")).toString());
+    } else if (data.contains(dateTimeParam)) {
+        auto dt = Utils::rfc3339DateFromString(data.value(dateTimeParam).toString());
         // If there's a timezone specified in the "start" entity, then use it
-        if (data.contains(QLatin1String("timeZone"))) {
-            const QTimeZone tz = QTimeZone(data.value(QStringLiteral("timeZone")).toString().toUtf8());
+        if (data.contains(timeZoneParam)) {
+            const QTimeZone tz = QTimeZone(data.value(timeZoneParam).toString().toUtf8());
             if (tz.isValid()) {
                 dt = dt.toTimeZone(tz);
             } else {
-                qCWarning(KGAPIDebug) << "Invalid timezone" << data.value(QStringLiteral("timeZone")).toString();
+                qCWarning(KGAPIDebug) << "Invalid timezone" << data.value(timeZoneParam).toString();
             }
 
             // Otherwise try to fallback to calendar-wide timezone
@@ -353,91 +448,81 @@
     }
 }
 
+void setEventCategories(EventPtr &event, const QVariantMap &properties)
+{
+    for (auto iter = properties.cbegin(), end = properties.cend(); iter != end; ++iter) {
+        if (iter.key() == categoriesProperty) {
+            event->setCategories(iter.value().toString());
+        }
+    }
 }
 
+} // namespace
+
 ObjectPtr Private::JSONToEvent(const QVariantMap& data, const QString &timezone)
 {
-    EventPtr event(new Event);
+    auto event = EventPtr::create();
 
-    /* ID */
-    event->setId(data.value(QStringLiteral("id")).toString());
+    event->setId(data.value(idParam).toString());
+    event->setUid(data.value(eventiCalUIDParam).toString());
+    event->setEtag(data.value(etagParam).toString());
 
-    /* UID */
-    event->setUid(data.value(QStringLiteral("iCalUID")).toString());
-
-    /* ETAG */
-    event->setEtag(data.value(QStringLiteral("etag")).toString());
-
-    /* Status */
-    if (data.value(QStringLiteral("status")).toString() == QLatin1String("confirmed")) {
+    if (data.value(eventStatusParam).toString() == confirmedStatus) {
         event->setStatus(KCalendarCore::Incidence::StatusConfirmed);
-    } else if (data.value(QStringLiteral("status")).toString() == QLatin1String("cancelled")) {
+    } else if (data.value(eventStatusParam).toString() == canceledStatus) {
         event->setStatus(KCalendarCore::Incidence::StatusCanceled);
         event->setDeleted(true);
-    } else if (data.value(QStringLiteral("status")).toString() == QLatin1String("tentative")) {
+    } else if (data.value(eventStatusParam).toString() == tentativeStatus) {
         event->setStatus(KCalendarCore::Incidence::StatusTentative);
     } else {
         event->setStatus(KCalendarCore::Incidence::StatusNone);
     }
 
-    /* Created */
-    event->setCreated(Utils::rfc3339DateFromString(data.value(QStringLiteral("created")).toString()));
-
-    /* Last updated */
-    event->setLastModified(Utils::rfc3339DateFromString(data.value(QStringLiteral("updated")).toString()));
-
-    /* Summary */
-    event->setSummary(data.value(QStringLiteral("summary")).toString());
+    event->setCreated(Utils::rfc3339DateFromString(data.value(eventCreatedParam).toString()));
+    event->setLastModified(Utils::rfc3339DateFromString(data.value(eventUpdatedParam).toString()));
+    event->setSummary(data.value(eventSummaryParam).toString());
+    event->setDescription(data.value(eventDescriptionParam).toString());
+    event->setLocation(data.value(eventLocationParam).toString());
 
-    /* Description */
-    event->setDescription(data.value(QStringLiteral("description")).toString());
-
-    /* Location */
-    event->setLocation(data.value(QStringLiteral("location")).toString());
-
-    /* Start date */
-    const auto dtStart = parseDt(data.value(QStringLiteral("start")).toMap(), timezone, false);
+    const auto dtStart = parseDt(data.value(eventStartPram).toMap(), timezone, false);
     event->setDtStart(dtStart.dt);
     event->setAllDay(dtStart.isAllDay);
 
-    /* End date */
-    const auto dtEnd = parseDt(data.value(QStringLiteral("end")).toMap(), timezone, true);
+    const auto dtEnd = parseDt(data.value(eventEndParam).toMap(), timezone, true);
     event->setDtEnd(dtEnd.dt);
 
-    /* Recurrence ID */
-    if (data.contains(QLatin1String("originalStartTime"))) {
-        const auto recurrenceId = parseDt(data.value(QStringLiteral("originalStartTime")).toMap(), timezone, false);
+    if (data.contains(eventOriginalStartTimeParam)) {
+        const auto recurrenceId = parseDt(data.value(eventOriginalStartTimeParam).toMap(), timezone, false);
         event->setRecurrenceId(recurrenceId.dt);
     }
 
-    /* Transparency */
-    if (data.value(QStringLiteral("transparency")).toString() == QLatin1String("transparent")) {
+    if (data.value(eventTransparencyParam).toString() == transparentTransparency) {
         event->setTransparency(Event::Transparent);
     } else { /* Assume opaque as default transparency */
         event->setTransparency(Event::Opaque);
     }
 
-    /* Attendees */
-    const QVariantList attendees = data.value(QStringLiteral("attendees")).toList();
-    for (const QVariant & a : attendees) {
-        QVariantMap att = a.toMap();
+    const auto attendees = data.value(eventAttendeesParam).toList();
+    for (const auto &a : attendees) {
+        const auto att = a.toMap();
         KCalendarCore::Attendee attendee(
-                        att.value(QStringLiteral("displayName")).toString(),
-                        att.value(QStringLiteral("email")).toString());
-
-        if (att.value(QStringLiteral("responseStatus")).toString() == QLatin1String("accepted"))
+                        att.value(attendeeDisplayNameParam).toString(),
+                        att.value(attendeeEmailParam).toString());
+        const auto responseStatus = att.value(attendeeResponseStatusParam).toString();
+        if (responseStatus == acceptedStatus) {
             attendee.setStatus(KCalendarCore::Attendee::Accepted);
-        else if (att.value(QStringLiteral("responseStatus")).toString() == QLatin1String("declined"))
+        } else if (responseStatus == declinedStatus) {
             attendee.setStatus(KCalendarCore::Attendee::Declined);
-        else if (att.value(QStringLiteral("responseStatus")).toString() == QLatin1String("tentative"))
+        } else if (responseStatus == tentativeStatus) {
             attendee.setStatus(KCalendarCore::Attendee::Tentative);
-        else
+        } else {
             attendee.setStatus(KCalendarCore::Attendee::NeedsAction);
+        }
 
-        if (att.value(QStringLiteral("optional")).toBool()) {
+        if (att.value(attendeeOptionalParam).toBool()) {
             attendee.setRole(KCalendarCore::Attendee::OptParticipant);
         }
-        const auto uid = att.value(QStringLiteral("id")).toString();
+        const auto uid = att.value(idParam).toString();
         if (!uid.isEmpty()) {
             attendee.setUid(uid);
         } else {
@@ -451,84 +536,64 @@
      * Google seems to ignore it, so we must take care of it here */
     if (event->attendeeCount() > 0) {
         KCalendarCore::Person organizer;
-        QVariantMap organizerData = data.value(QStringLiteral("organizer")).toMap();
-        organizer.setName(organizerData.value(QStringLiteral("displayName")).toString());
-        organizer.setEmail(organizerData.value(QStringLiteral("email")).toString());
+        const auto organizerData = data.value(eventOrganizerParam).toMap();
+        organizer.setName(organizerData.value(organizerDisplayNameParam).toString());
+        organizer.setEmail(organizerData.value(organizerEmailParam).toString());
         event->setOrganizer(organizer);
     }
 
-    /* Recurrence */
-    const QStringList recrs = data.value(QStringLiteral("recurrence")).toStringList();
+    const QStringList recrs = data.value(eventRecurrenceParam).toStringList();
     for (const QString & rec : recrs) {
         KCalendarCore::ICalFormat format;
-        if (rec.left(5) == QLatin1String("RRULE")) {
-            KCalendarCore::RecurrenceRule *recurrenceRule = new KCalendarCore::RecurrenceRule();
-            format.fromString(recurrenceRule, rec.mid(6));
+        if (rec.leftRef(5) == QLatin1String("RRULE")) {
+            auto recurrenceRule = std::make_unique<KCalendarCore::RecurrenceRule>();
+            const auto ok = format.fromString(recurrenceRule.get(), rec.mid(6)); Q_UNUSED(ok);
             recurrenceRule->setRRule(rec);
-            event->recurrence()->addRRule(recurrenceRule);
-        } else if (rec.left(6) == QLatin1String("EXRULE")) {
-            KCalendarCore::RecurrenceRule *recurrenceRule = new KCalendarCore::RecurrenceRule();
-            format.fromString(recurrenceRule, rec.mid(7));
+            event->recurrence()->addRRule(recurrenceRule.release());
+        } else if (rec.leftRef(6) == QLatin1String("EXRULE")) {
+            auto recurrenceRule = std::make_unique<KCalendarCore::RecurrenceRule>();
+            const auto ok = format.fromString(recurrenceRule.get(), rec.mid(7)); Q_UNUSED(ok);
             recurrenceRule->setRRule(rec);
-            event->recurrence()->addExRule(recurrenceRule);
-        } else if (rec.left(6) == QLatin1String("EXDATE")) {
+            event->recurrence()->addExRule(recurrenceRule.release());
+        } else if (rec.leftRef(6) == QLatin1String("EXDATE")) {
             KCalendarCore::DateList exdates = Private::parseRDate(rec);
             event->recurrence()->setExDates(exdates);
-        } else if (rec.left(5) == QLatin1String("RDATE")) {
+        } else if (rec.leftRef(5) == QLatin1String("RDATE")) {
             KCalendarCore::DateList rdates = Private::parseRDate(rec);
             event->recurrence()->setRDates(rdates);
         }
     }
 
-    QVariantMap reminders = data.value(QStringLiteral("reminders")).toMap();
-    if (reminders.contains(QLatin1String("useDefault")) && reminders.value(QStringLiteral("useDefault")).toBool()) {
+    const auto reminders = data.value(eventRemindersParam).toMap();
+    if (reminders.contains(reminderUseDefaultParam) && reminders.value(reminderUseDefaultParam).toBool()) {
         event->setUseDefaultReminders(true);
     } else {
         event->setUseDefaultReminders(false);
     }
 
-    const QVariantList overrides = reminders.value(QStringLiteral("overrides")).toList();
-    for (const QVariant & r : overrides) {
-        QVariantMap override = r.toMap();
-        KCalendarCore::Alarm::Ptr alarm(new KCalendarCore::Alarm(static_cast<KCalendarCore::Incidence*>(event.data())));
+    const auto overrides = reminders.value(reminderOverridesParam).toList();
+    for (const auto &r : overrides) {
+        const auto reminderOverride = r.toMap();
+        auto alarm = KCalendarCore::Alarm::Ptr::create(static_cast<KCalendarCore::Incidence*>(event.data()));
         alarm->setTime(event->dtStart());
 
-        if (override.value(QStringLiteral("method")).toString() == QLatin1String("popup")) {
+        if (reminderOverride.value(reminderMethodParam).toString() == popupMethod) {
             alarm->setType(KCalendarCore::Alarm::Display);
-        } else if (override.value(QStringLiteral("method")).toString() == QLatin1String("email")) {
+        } else if (reminderOverride.value(reminderMethodParam).toString() == emailMethod) {
             alarm->setType(KCalendarCore::Alarm::Email);
         } else {
             alarm->setType(KCalendarCore::Alarm::Invalid);
             continue;
         }
 
-        alarm->setStartOffset(KCalendarCore::Duration(override.value(QStringLiteral("minutes")).toInt() * (-60)));
+        alarm->setStartOffset(KCalendarCore::Duration(reminderOverride.value(reminderMinutesParam).toInt() * (-60)));
         alarm->setEnabled(true);
         event->addAlarm(alarm);
     }
 
-    /* Extended properties */
-    QVariantMap extendedProperties = data.value(QStringLiteral("extendedProperties")).toMap();
-
-    QVariantMap privateProperties = extendedProperties.value(QStringLiteral("private")).toMap();
-    QMap< QString, QVariant >::const_iterator iter = privateProperties.constBegin();
-    while (iter != privateProperties.constEnd()) {
-        if (iter.key() == QLatin1String("categories")) {
-            event->setCategories(iter.value().toString());
-        }
-
-        ++iter;
-    }
-
-    QVariantMap sharedProperties = extendedProperties.value(QStringLiteral("shared")).toMap();
-    iter = sharedProperties.constBegin();
-    while (iter != sharedProperties.constEnd()) {
-        if (iter.key() == QLatin1String("categories")) {
-            event->setCategories(iter.value().toString());
-        }
-
-        ++iter;
-    }
+    const auto extendedProperties = data.value(eventExtendedPropertiesParam).toMap();
+    setEventCategories(event, extendedProperties.value(propertyPrivateParam).toMap());
+    setEventCategories(event, extendedProperties.value(propertySharedParam).toMap());
 
     return event.dynamicCast<Object>();
 }
@@ -542,24 +607,22 @@
 };
 using SerializeDtFlags = QFlags<SerializeDtFlag>;
 
-Q_DECLARE_OPERATORS_FOR_FLAGS(SerializeDtFlags)
-
 QVariantMap serializeDt(const EventPtr &event, const QDateTime &dt, SerializeDtFlags flags)
 {
     QVariantMap rv;
     if (flags & SerializeDtFlag::AllDay) {
         /* For Google, all-day events starts on Monday and ends on Tuesday,
          * while in KDE, it both starts and ends on Monday. */
-        auto adjusted = dt.addDays(flags & SerializeDtFlag::IsDtEnd ? 1 : 0);
-        rv.insert(QStringLiteral("date"), adjusted.toString(QStringLiteral("yyyy-MM-dd")));
+        const auto adjusted = dt.addDays(flags & SerializeDtFlag::IsDtEnd ? 1 : 0);
+        rv.insert(dateParam, adjusted.toString(QStringLiteral("yyyy-MM-dd")));
     } else {
-        rv.insert(QStringLiteral("dateTime"), Utils::rfc3339DateToString(dt));
+        rv.insert(dateTimeParam, Utils::rfc3339DateToString(dt));
         QString tzEnd = QString::fromUtf8(dt.timeZone().id());
         if (flags & SerializeDtFlag::HasRecurrence && tzEnd.isEmpty()) {
             tzEnd = QString::fromUtf8(QTimeZone::utc().id());
         }
         if (!tzEnd.isEmpty()) {
-            rv.insert(QStringLiteral("timeZone"), Private::checkAndConverCDOTZID(tzEnd, event));
+            rv.insert(timeZoneParam, Private::checkAndConverCDOTZID(tzEnd, event));
         }
     }
 
@@ -572,73 +635,62 @@
 {
     QVariantMap data;
 
-    /* Type */
-    data.insert(QStringLiteral("kind"), QStringLiteral("calendar#event"));
+    data.insert(kindParam, eventKind);
 
-    /* ID */
     if (!(flags & EventSerializeFlag::NoID)) {
-        data.insert(QStringLiteral("id"), event->id());
+        data.insert(idParam, event->id());
     }
 
-    /* UID */
-    data.insert(QStringLiteral("iCalUID"), event->uid());
+    data.insert(eventiCalUIDParam, event->uid());
 
-    /* Status */
     if (event->status() == KCalendarCore::Incidence::StatusConfirmed) {
-        data.insert(QStringLiteral("status"), QStringLiteral("confirmed"));
+        data.insert(eventStatusParam, confirmedStatus);
     } else if (event->status() == KCalendarCore::Incidence::StatusCanceled) {
-        data.insert(QStringLiteral("status"), QStringLiteral("canceled"));
+        data.insert(eventStatusParam, canceledStatus);
     } else if (event->status() == KCalendarCore::Incidence::StatusTentative) {
-        data.insert(QStringLiteral("status"), QStringLiteral("tentative"));
+        data.insert(eventStatusParam, tentativeStatus);
     }
 
-    /* Summary */
-    data.insert(QStringLiteral("summary"), event->summary());
-
-    /* Description */
-    data.insert(QStringLiteral("description"), event->description());
+    data.insert(eventSummaryParam, event->summary());
+    data.insert(eventDescriptionParam, event->description());
+    data.insert(eventLocationParam, event->location());
 
-    /* Location */
-    data.insert(QStringLiteral("location"), event->location());
-
-    /* Recurrence */
     QVariantList recurrence;
     KCalendarCore::ICalFormat format;
     const auto exRules = event->recurrence()->exRules();
     const auto rRules = event->recurrence()->rRules();
     recurrence.reserve(rRules.size() + rRules.size() + 2);
     for (KCalendarCore::RecurrenceRule *rRule : rRules) {
-        recurrence << format.toString(rRule).remove(QStringLiteral("\r\n"));
+        recurrence.push_back(format.toString(rRule).remove(QStringLiteral("\r\n")));
     }
-
     for (KCalendarCore::RecurrenceRule *rRule : exRules) {
-        recurrence << format.toString(rRule).remove(QStringLiteral("\r\n"));
+        recurrence.push_back(format.toString(rRule).remove(QStringLiteral("\r\n")));
     }
 
     QStringList dates;
     const auto rDates = event->recurrence()->rDates();
     dates.reserve(rDates.size());
-    for (const QDate & rDate : rDates) {
-        dates << rDate.toString(QStringLiteral("yyyyMMdd"));
+    for (const auto &rDate : rDates) {
+        dates.push_back(rDate.toString(QStringLiteral("yyyyMMdd")));
     }
 
     if (!dates.isEmpty()) {
-        recurrence << QString(QStringLiteral("RDATE;VALUE=DATA:") + dates.join(QLatin1Char(',')));
+        recurrence.push_back(QString(QStringLiteral("RDATE;VALUE=DATA:") + dates.join(QLatin1Char(','))));
     }
 
     dates.clear();
     const auto exDates = event->recurrence()->exDates();
     dates.reserve(exDates.size());
-    for (const QDate & exDate : exDates) {
-        dates << exDate.toString(QStringLiteral("yyyyMMdd"));
+    for (const auto &exDate : exDates) {
+        dates.push_back(exDate.toString(QStringLiteral("yyyyMMdd")));
     }
 
     if (!dates.isEmpty()) {
-        recurrence << QString(QStringLiteral("EXDATE;VALUE=DATE:") + dates.join(QLatin1Char(',')));
+        recurrence.push_back(QString(QStringLiteral("EXDATE;VALUE=DATE:") + dates.join(QLatin1Char(','))));
     }
 
     if (!recurrence.isEmpty()) {
-        data.insert(QStringLiteral("recurrence"), recurrence);
+        data.insert(eventRecurrenceParam, recurrence);
     }
 
     SerializeDtFlags dtFlags;
@@ -649,135 +701,121 @@
         dtFlags |= SerializeDtFlag::HasRecurrence;
     }
 
-    /* Start */
-    data.insert(QStringLiteral("start"), serializeDt(event, event->dtStart(), dtFlags));
-
-    /* End */
-    data.insert(QStringLiteral("end"), serializeDt(event, event->dtEnd(), dtFlags | SerializeDtFlag::IsDtEnd));
+    data.insert(eventStartPram, serializeDt(event, event->dtStart(), dtFlags));
+    data.insert(eventEndParam, serializeDt(event, event->dtEnd(), dtFlags | SerializeDtFlag::IsDtEnd));
 
     if (event->hasRecurrenceId()) {
-        data.insert(QStringLiteral("originalStartTime"), serializeDt(event, event->recurrenceId(), dtFlags));
-        data.insert(QStringLiteral("recurringEventId"), event->id());
+        data.insert(eventOrganizerParam, serializeDt(event, event->recurrenceId(), dtFlags));
+        data.insert(eventRecurringEventIdParam, event->id());
     }
 
-    /* Transparency */
     if (event->transparency() == Event::Transparent) {
-        data.insert(QStringLiteral("transparency"), QStringLiteral("transparent"));
+        data.insert(eventTransparencyParam, transparentTransparency);
     } else {
-        data.insert(QStringLiteral("transparency"), QStringLiteral("opaque"));
+        data.insert(eventTransparencyParam, opaqueTransparency);
     }
 
-    /* Attendees */
     QVariantList atts;
-    Q_FOREACH(const KCalendarCore::Attendee& attee, event->attendees()) {
-        QVariantMap att;
-
-        att.insert(QStringLiteral("displayName"), attee.name());
-        att.insert(QStringLiteral("email"), attee.email());
+    const auto attendees = event->attendees();
+    for (const auto &attee : attendees) {
+        QVariantMap att{{attendeeDisplayNameParam, attee.name()},
+                        {attendeeEmailParam, attee.email()}};
 
         if (attee.status() == KCalendarCore::Attendee::Accepted) {
-            att.insert(QStringLiteral("responseStatus"), QStringLiteral("accepted"));
+            att.insert(attendeeResponseStatusParam, acceptedStatus);
         } else if (attee.status() == KCalendarCore::Attendee::Declined) {
-            att.insert(QStringLiteral("responseStatus"), QStringLiteral("declined"));
+            att.insert(attendeeResponseStatusParam, declinedStatus);
         } else if (attee.status() == KCalendarCore::Attendee::Tentative) {
-            att.insert(QStringLiteral("responseStatus"), QStringLiteral("tentative"));
+            att.insert(attendeeResponseStatusParam, tentativeStatus);
         } else {
-            att.insert(QStringLiteral("responseStatus"), QStringLiteral("needsAction"));
+            att.insert(attendeeResponseStatusParam, needsActionStatus);
         }
 
         if (attee.role() == KCalendarCore::Attendee::OptParticipant) {
-            att.insert(QStringLiteral("optional"), true);
+            att.insert(attendeeOptionalParam, true);
         }
         if (!attee.uid().isEmpty()) {
-            att.insert(QStringLiteral("id"), attee.uid());
+            att.insert(idParam, attee.uid());
         }
         atts.append(att);
     }
 
     if (!atts.isEmpty()) {
-        data.insert(QStringLiteral("attendees"), atts);
+        data.insert(eventAttendeesParam, atts);
 
         /* According to RFC, event without attendees should not have
          * any organizer. */
-        KCalendarCore::Person organizer = event->organizer();
+        const auto organizer = event->organizer();
         if (!organizer.isEmpty()) {
-            QVariantMap org;
-            org.insert(QStringLiteral("displayName"), organizer.fullName());
-            org.insert(QStringLiteral("email"), organizer.email());
-            data.insert(QStringLiteral("organizer"), org);
+            data.insert(eventOrganizerParam,
+                        QVariantMap{{organizerDisplayNameParam, organizer.fullName()},
+                                    {organizerEmailParam, organizer.email()}});
         }
     }
 
-    /* Reminders */
     QVariantList overrides;
-    Q_FOREACH(const KCalendarCore::Alarm::Ptr &alarm, event->alarms()) {
-        QVariantMap override;
-
+    const auto alarms = event->alarms();
+    for (const auto &alarm : alarms) {
+        QVariantMap reminderOverride;
         if (alarm->type() == KCalendarCore::Alarm::Display) {
-            override.insert(QStringLiteral("method"), QLatin1String("popup"));
+            reminderOverride.insert(reminderMethodParam, popupMethod);
         } else if (alarm->type() == KCalendarCore::Alarm::Email) {
-            override.insert(QStringLiteral("method"), QLatin1String("email"));
+            reminderOverride.insert(reminderMethodParam, emailMethod);
         } else {
             continue;
         }
+        reminderOverride.insert(reminderMinutesParam, (int)(alarm->startOffset().asSeconds() / -60));
 
-        override.insert(QStringLiteral("minutes"),  (int)(alarm->startOffset().asSeconds() / -60));
-
-        overrides << override;
+        overrides.push_back(reminderOverride);
     }
 
-    QVariantMap reminders;
-    reminders.insert(QStringLiteral("useDefault"), false);
-    reminders.insert(QStringLiteral("overrides"), overrides);
-    data.insert(QStringLiteral("reminders"), reminders);
+    data.insert(eventRemindersParam,
+                QVariantMap{{reminderUseDefaultParam, false},
+                            {reminderOverridesParam, overrides}});
 
-    /* Store categories */
     if (!event->categories().isEmpty()) {
-        QVariantMap extendedProperties;
-        QVariantMap sharedProperties;
-        sharedProperties.insert(QStringLiteral("categories"), event->categoriesStr());
-        extendedProperties.insert(QStringLiteral("shared"), sharedProperties);
-        data.insert(QStringLiteral("extendedProperties"), extendedProperties);
+        data.insert(eventExtendedPropertiesParam,
+                    QVariantMap{{propertySharedParam, QVariantMap{{categoriesProperty, event->categoriesStr()}}}});
     }
 
     /* TODO: Implement support for additional features:
      * http://code.google.com/apis/gdata/docs/2.0/elements.html
      */
 
-    QJsonDocument document = QJsonDocument::fromVariant(data);
+    const auto document = QJsonDocument::fromVariant(data);
     return document.toJson(QJsonDocument::Compact);
 }
 
 ObjectsList parseEventJSONFeed(const QByteArray& jsonFeed, FeedData& feedData)
 {
-    QJsonDocument document = QJsonDocument::fromJson(jsonFeed);
-    QVariantMap data = document.toVariant().toMap();
+    const auto document = QJsonDocument::fromJson(jsonFeed);
+    const auto data = document.toVariant().toMap();
 
     QString timezone;
-    if (data.value(QStringLiteral("kind")) == QLatin1String("calendar#events")) {
-        if (data.contains(QLatin1String("nextPageToken"))) {
+    if (data.value(kindParam) == eventsKind) {
+        if (data.contains(nextPageTokenParam)) {
             QString calendarId = feedData.requestUrl.toString().remove(QStringLiteral("https://www.googleapis.com/calendar/v3/calendars/"));
             calendarId = calendarId.left(calendarId.indexOf(QLatin1Char('/')));
             feedData.nextPageUrl = feedData.requestUrl;
             // replace the old pageToken with a new one
             QUrlQuery query(feedData.nextPageUrl);
-            query.removeQueryItem(QStringLiteral("pageToken"));
-            query.addQueryItem(QStringLiteral("pageToken"), data.value(QStringLiteral("nextPageToken")).toString());
+            query.removeQueryItem(pageTokenParam);
+            query.addQueryItem(pageTokenParam, data.value(nextPageTokenParam).toString());
             feedData.nextPageUrl.setQuery(query);
         }
-        if (data.contains(QLatin1String("timeZone"))) {
+        if (data.contains(timeZoneParam)) {
             // This should always be in Olson format
-            timezone = data.value(QStringLiteral("timeZone")).toString();
+            timezone = data.value(timeZoneParam).toString();
         }
     } else {
-        return ObjectsList();
+        return {};
     }
 
     ObjectsList list;
-    const QVariantList items = data.value(QStringLiteral("items")).toList();
+    const auto items = data.value(itemsParam).toList();
     list.reserve(items.size());
-    for (const QVariant &i : items) {
-        list.append(Private::JSONToEvent(i.toMap(), timezone));
+    for (const auto &i : items) {
+        list.push_back(Private::JSONToEvent(i.toMap(), timezone));
     }
 
     return list;
@@ -788,262 +826,253 @@
 KCalendarCore::DateList Private::parseRDate(const QString& rule)
 {
     KCalendarCore::DateList list;
-    QString value;
+    QStringRef value;
     QTimeZone tz;
 
-    QString left = rule.left(rule.indexOf(QLatin1Char(':')));
-    const QStringList params = left.split(QLatin1Char(';'));
-    for (const QString &param : params) {
+    const auto left = rule.leftRef(rule.indexOf(QLatin1Char(':')));
+    const auto params = left.split(QLatin1Char(';'));
+    for (const auto &param : params) {
         if (param.startsWith(QLatin1String("VALUE"))) {
             value = param.mid(param.indexOf(QLatin1Char('=')) + 1);
         } else if (param.startsWith(QLatin1String("TZID"))) {
-            QString _name = param.mid(param.indexOf(QLatin1Char('=')) + 1);
+            auto _name = param.mid(param.indexOf(QLatin1Char('=')) + 1);
             tz = QTimeZone(_name.toUtf8());
         }
     }
 
-    QString datesStr = rule.mid(rule.lastIndexOf(QLatin1Char(':')) + 1);
-    const QStringList dates = datesStr.split(QLatin1Char(','));
-    for (const QString &date : dates) {
+    const auto datesStr = rule.midRef(rule.lastIndexOf(QLatin1Char(':')) + 1);
+    const auto dates = datesStr.split(QLatin1Char(','));
+    for (const auto &date : dates) {
         QDate dt;
 
         if (value == QLatin1String("DATE")) {
-            dt = QDate::fromString(date, QStringLiteral("yyyyMMdd"));
+            dt = QDate::fromString(date.toString(), QStringLiteral("yyyyMMdd"));
         } else if (value == QLatin1String("PERIOD")) {
-            QString start = date.left(date.indexOf(QLatin1Char('/')));
-            QDateTime kdt = Utils::rfc3339DateFromString(start);
+            const auto start = date.left(date.indexOf(QLatin1Char('/')));
+            QDateTime kdt = Utils::rfc3339DateFromString(start.toString());
             if (tz.isValid()) {
                 kdt.setTimeZone(tz);
             }
 
             dt = kdt.date();
         } else {
-            QDateTime kdt = Utils::rfc3339DateFromString(date);
+            QDateTime kdt = Utils::rfc3339DateFromString(date.toString());
             if (tz.isValid()) {
                 kdt.setTimeZone(tz);
             }
 
             dt = kdt.date();
         }
 
-        list << dt;
+        list.push_back(dt);
     }
 
     return list;
 }
 
+namespace {
 
-static QMap<int, QString> initMSCDOTZIDTable()
-{
-    QMap<int, QString> map;
-
-    /* Based on "Time Zone to CdoTimeZoneId Map"
-     * http://msdn.microsoft.com/en-us/library/aa563018%28loband%29.aspx
-     *
-     * The mapping is not exact, since the CdoTimeZoneId usually refers to a
-     * region of multiple countries, so I always picked one of the countries
-     * in the specified region and used it's TZID.
-     */
-    map.insert(0,  QStringLiteral("UTC"));
-    map.insert(1,  QStringLiteral("Europe/London"));                       /* GMT Greenwich Mean Time; Dublin, Edinburgh, London */
+/* Based on "Time Zone to CdoTimeZoneId Map"
+ * http://msdn.microsoft.com/en-us/library/aa563018%28loband%29.aspx
+ *
+ * The mapping is not exact, since the CdoTimeZoneId usually refers to a
+ * region of multiple countries, so I always picked one of the countries
+ * in the specified region and used it's TZID.
+ */
+static const std::map<int, QLatin1String> MSCDOTZIDTable = {
+    {0,  QLatin1String("UTC")},
+    {1,  QLatin1String("Europe/London")},             /* GMT Greenwich Mean Time; Dublin, Edinburgh, London */
     /* Seriously? *sigh* Let's handle these two in checkAndConvertCDOTZID() */
-    //map.insertMulti(2, QStringLiteral("Europe/Lisbon"));         /* GMT Greenwich Mean Time: Dublin, Edinburgh, Lisbon, London */
-    //map.insertMulti(2, QStringLiteral("Europe/Sarajevo"));       /* GMT+01:00 Sarajevo, Skopje, Sofija, Vilnius, Warsaw, Zagreb */
-    map.insert(3,  QStringLiteral("Europe/Paris"));              /* GMT+01:00 Paris, Madrid, Brussels, Copenhagen */
-    map.insert(4,  QStringLiteral("Europe/Berlin"));             /* GMT+01:00 Amsterdam, Berlin, Bern, Rome, Stockholm, Vienna */
-    map.insert(5,  QStringLiteral("Europe/Bucharest"));          /* GMT+02:00 Bucharest */
-    map.insert(6,  QStringLiteral("Europe/Prague"));             /* GMT+01:00 Prague, Central Europe */
-    map.insert(7,  QStringLiteral("Europe/Athens"));             /* GMT+02:00 Athens, Istanbul, Minsk */
-    map.insert(8,  QStringLiteral("America/Brazil"));            /* GMT-03:00 Brasilia */
-    map.insert(9,  QStringLiteral("America/Halifax"));           /* GMT-04:00 Atlantic time (Canada) */
-    map.insert(10, QStringLiteral("America/New_York"));          /* GMT-05:00 Eastern Time (US & Canada) */
-    map.insert(11, QStringLiteral("America/Chicago"));           /* GMT-06:00 Central Time (US & Canada) */
-    map.insert(12, QStringLiteral("America/Denver"));            /* GMT-07:00 Mountain Time (US & Canada) */
-    map.insert(13, QStringLiteral("America/Los_Angeles"));       /* GMT-08:00 Pacific Time (US & Canada); Tijuana */
-    map.insert(14, QStringLiteral("America/Anchorage"));         /* GMT-09:00 Alaska */
-    map.insert(15, QStringLiteral("Pacific/Honolulu"));          /* GMT-10:00 Hawaii */
-    map.insert(16, QStringLiteral("Pacific/Apia"));              /* GMT-11:00 Midway Island, Samoa */
-    map.insert(17, QStringLiteral("Pacific/Auckland"));          /* GMT+12:00 Auckland, Wellington */
-    map.insert(18, QStringLiteral("Australia/Brisbane"));        /* GMT+10:00 Brisbane, East Australia */
-    map.insert(19, QStringLiteral("Australia/Adelaide"));        /* GMT+09:30 Adelaide, Central Australia */
-    map.insert(20, QStringLiteral("Asia/Tokyo"));                /* GMT+09:00 Osaka, Sapporo, Tokyo */
-    map.insert(21, QStringLiteral("Asia/Singapore"));            /* GMT+08:00 Kuala Lumpur, Singapore */
-    map.insert(22, QStringLiteral("Asia/Bangkok"));              /* GMT+07:00 Bangkok, Hanoi, Jakarta */
-    map.insert(23, QStringLiteral("Asia/Calcutta"));             /* GMT+05:30 Kolkata, Chennai, Mumbai, New Delhi, India Standard Time */
-    map.insert(24, QStringLiteral("Asia/Dubai"));                /* GMT+04:00 Abu Dhabi, Muscat */
-    map.insert(25, QStringLiteral("Asia/Tehran"));               /* GMT+03:30 Tehran */
-    map.insert(26, QStringLiteral("Asia/Baghdad"));              /* GMT+03:00 Baghdad */
-    map.insert(27, QStringLiteral("Asia/Jerusalem"));            /* GMT+02:00 Israel, Jerusalem Standard Time */
-    map.insert(28, QStringLiteral("America/St_Johns"));          /* GMT-03:30 Newfoundland */
-    map.insert(29, QStringLiteral("Atlantic/Portugal"));         /* GMT-01:00 Azores */
-    map.insert(30, QStringLiteral("America/Noronha"));           /* GMT-02:00 Mid-Atlantic */
-    map.insert(31, QStringLiteral("Africa/Monrovia"));           /* GMT Casablanca, Monrovia */
-    map.insert(32, QStringLiteral("America/Argentina/Buenos_Aires")); /* GMT-03:00 Buenos Aires, Georgetown */
-    map.insert(33, QStringLiteral("America/La_Paz"));            /* GMT-04:00 Caracas, La Paz */
-    map.insert(34, QStringLiteral("America/New_York"));          /* GMT-05:00 Indiana (East) */
-    map.insert(35, QStringLiteral("America/Bogota"));            /* GMT-05:00 Bogota, Lima, Quito */
-    map.insert(36, QStringLiteral("America/Winnipeg"));          /* GMT-06:00 Saskatchewan */
-    map.insert(37, QStringLiteral("America/Mexico_City"));       /* GMT-06:00 Mexico City, Tegucigalpa */
-    map.insert(38, QStringLiteral("America/Phoenix"));           /* GMT-07:00 Arizona */
-    map.insert(39, QStringLiteral("Pacific/Kwajalein"));         /* GMT-12:00 Eniwetok, Kwajalein, Dateline Time */
-    map.insert(40, QStringLiteral("Pacific/Fiji"));              /* GMT+12:00 Fušál, Kamchatka, Mashall Is. */
-    map.insert(41, QStringLiteral("Pacific/Noumea"));            /* GMT+11:00 Magadan, Solomon Is., New Caledonia */
-    map.insert(42, QStringLiteral("Australia/Hobart"));          /* GMT+10:00 Hobart, Tasmania */
-    map.insert(43, QStringLiteral("Pacific/Guam"));              /* GMT+10:00 Guam, Port Moresby */
-    map.insert(44, QStringLiteral("Australia/Darwin"));          /* GMT+09:30 Darwin */
-    map.insert(45, QStringLiteral("Asia/Shanghai"));             /* GMT+08:00 Beijing, Chongqing, Hong Kong SAR, Urumqi */
-    map.insert(46, QStringLiteral("Asia/Omsk"));                 /* GMT+06:00 Almaty, Novosibirsk, North Central Asia */
-    map.insert(47, QStringLiteral("Asia/Karachi"));              /* GMT+05:00 Islamabad, Karachi, Tashkent */
-    map.insert(48, QStringLiteral("Asia/Kabul"));                /* GMT+04:30 Kabul */
-    map.insert(49, QStringLiteral("Africa/Cairo"));              /* GMT+02:00 Cairo */
-    map.insert(50, QStringLiteral("Africa/Harare"));             /* GMT+02:00 Harare, Pretoria */
-    map.insert(51, QStringLiteral("Europe/Moscow"));             /* GMT+03:00 Moscow, St. Petersburg, Volgograd */
-    map.insert(53, QStringLiteral("Atlantic/Cape_Verde"));       /* GMT-01:00 Cape Verde Is. */
-    map.insert(54, QStringLiteral("Asia/Tbilisi"));              /* GMT+04:00 Baku, Tbilisi, Yerevan */
-    map.insert(55, QStringLiteral("America/Tegucigalpa"));       /* GMT-06:00 Central America */
-    map.insert(56, QStringLiteral("Africa/Nairobi"));            /* GMT+03:00 East Africa, Nairobi */
-    map.insert(58, QStringLiteral("Asia/Yekaterinburg"));        /* GMT+05:00 Ekaterinburg */
-    map.insert(59, QStringLiteral("Europe/Helsinki"));           /* GMT+02:00 Helsinki, Riga, Tallinn */
-    map.insert(60, QStringLiteral("America/Greenland"));         /* GMT-03:00 Greenland */
-    map.insert(61, QStringLiteral("Asia/Rangoon"));              /* GMT+06:30 Yangon (Rangoon) */
-    map.insert(62, QStringLiteral("Asia/Katmandu"));             /* GMT+05:45 Kathmandu, Nepal */
-    map.insert(63, QStringLiteral("Asia/Irkutsk"));              /* GMT+08:00 Irkutsk, Ulaan Bataar */
-    map.insert(64, QStringLiteral("Asia/Krasnoyarsk"));          /* GMT+07:00 Krasnoyarsk */
-    map.insert(65, QStringLiteral("America/Santiago"));          /* GMT-04:00 Santiago */
-    map.insert(66, QStringLiteral("Asia/Colombo"));              /* GMT+06:00 Sri Jayawardenepura, Sri Lanka */
-    map.insert(67, QStringLiteral("Pacific/Tongatapu"));         /* GMT+13:00 Nuku'alofa, Tonga */
-    map.insert(68, QStringLiteral("Asia/Vladivostok"));          /* GMT+10:00 Vladivostok */
-    map.insert(69, QStringLiteral("Africa/Bangui"));             /* GMT+01:00 West Central Africa */
-    map.insert(70, QStringLiteral("Asia/Yakutsk"));              /* GMT+09:00 Yakutsk */
-    map.insert(71, QStringLiteral("Asia/Dhaka"));                /* GMT+06:00 Astana, Dhaka */
-    map.insert(72, QStringLiteral("Asia/Seoul"));                /* GMT+09:00 Seoul, Korea Standard time */
-    map.insert(73, QStringLiteral("Australia/Perth"));           /* GMT+08:00 Perth, Western Australia */
-    map.insert(74, QStringLiteral("Asia/Kuwait"));               /* GMT+03:00 Arab, Kuwait, Riyadh */
-    map.insert(75, QStringLiteral("Asia/Taipei"));               /* GMT+08:00 Taipei */
-    map.insert(76, QStringLiteral("Australia/Sydney"));          /* GMT+10:00 Canberra, Melbourne, Sydney */
-
-    return map;
-}
-
-static QMap<QString, QString> initMSStandardTimeTZTable()
-{
-    QMap<QString, QString> map;
-
-
-    /* Based on "Microsoft Time Zone Index Values"
-     * http://support.microsoft.com/kb/973627
-     *
-     * The mapping is not exact, since the TZID usually refers to a
-     * region of multiple countries, so I always picked one of the countries
-     * in the specified region and used it's TZID.
-     *
-     * The Olson timezones are taken from https://en.wikipedia.org/wiki/List_of_tz_database_time_zones
-     */
-    map.insert(QStringLiteral("Dateline Standard Time"), QStringLiteral("Pacific/Kwajalein"));    /* (GMT-12:00) International Date Line West */
-    map.insert(QStringLiteral("Samoa Standard Time"), QStringLiteral("Pacific/Apia"));            /* (GMT-11:00) Midway Island, Samoa */
-    map.insert(QStringLiteral("Hawaiian Standard Time"), QStringLiteral("Pacific/Honolulu"));     /* (GMT-10:00) Hawaii */
-    map.insert(QStringLiteral("Alaskan Standard Time"), QStringLiteral("America/Anchorage"));     /* (GMT-09:00) Alaska */
-    map.insert(QStringLiteral("Pacific Standard Time"), QStringLiteral("America/Los_Angeles"));   /* (GMT-08:00) Pacific Time (US and Canada); Tijuana */
-    map.insert(QStringLiteral("Mountain Standard Time"), QStringLiteral("America/Denver"));       /* (GMT-07:00) Mountain Time (US and Canada) */
-    map.insert(QStringLiteral("Mexico Standard Time 2"), QStringLiteral("America/Chihuahua"));    /* (GMT-07:00) Chihuahua, La Paz, Mazatlan */
-    map.insert(QStringLiteral("U.S. Mountain Standard Time"), QStringLiteral("America/Phoenix")); /* (GMT-07:00) Arizona */
-    map.insert(QStringLiteral("Central Standard Time"), QStringLiteral("America/Chicago"));       /* (GMT-06:00) Central Time (US and Canada */
-    map.insert(QStringLiteral("Canada Central Standard Time"), QStringLiteral("America/Winnipeg"));       /* (GMT-06:00) Saskatchewan */
-    map.insert(QStringLiteral("Mexico Standard Time"), QStringLiteral("America/Mexico_City"));    /* (GMT-06:00) Guadalajara, Mexico City, Monterrey */
-    map.insert(QStringLiteral("Central America Standard Time"), QStringLiteral("America/Chicago"));       /* (GMT-06:00) Central America */
-    map.insert(QStringLiteral("Eastern Standard Time"), QStringLiteral("America/New_York"));      /* (GMT-05:00) Eastern Time (US and Canada) */
-    map.insert(QStringLiteral("U.S. Eastern Standard Time"), QStringLiteral("America/New_York")); /* (GMT-05:00) Indiana (East) */
-    map.insert(QStringLiteral("S.A. Pacific Standard Time"), QStringLiteral("America/Bogota"));   /* (GMT-05:00) Bogota, Lima, Quito */
-    map.insert(QStringLiteral("Atlantic Standard Time"), QStringLiteral("America/Halifax"));      /* (GMT-04:00) Atlantic Time (Canada) */
-    map.insert(QStringLiteral("S.A. Western Standard Time"), QStringLiteral("America/La_Paz"));   /* (GMT-04:00) Caracas, La Paz */
-    map.insert(QStringLiteral("Pacific S.A. Standard Time"), QStringLiteral("America/Santiago")); /* (GMT-04:00) Santiago */
-    map.insert(QStringLiteral("Newfoundland and Labrador Standard Time"), QStringLiteral("America/St_Johns"));    /* (GMT-03:30) Newfoundland and Labrador */
-    map.insert(QStringLiteral("E. South America Standard Time"), QStringLiteral("America/Brazil"));       /* (GMT-03:00) Brasilia */
-    map.insert(QStringLiteral("S.A. Eastern Standard Time"), QStringLiteral("America/Argentina/Buenos_Aires"));   /* (GMT-03:00) Buenos Aires, Georgetown */
-    map.insert(QStringLiteral("Greenland Standard Time"), QStringLiteral("America/Greenland"));   /* (GMT-03:00) Greenland */
-    map.insert(QStringLiteral("Mid-Atlantic Standard Time"), QStringLiteral("America/Noronha"));  /* (GMT-02:00) Mid-Atlantic */
-    map.insert(QStringLiteral("Azores Standard Time"), QStringLiteral("Atlantic/Portugal"));      /* (GMT-01:00) Azores */
-    map.insert(QStringLiteral("Cape Verde Standard Time"), QStringLiteral("Atlantic/Cape_Verde"));        /* (GMT-01:00) Cape Verde Islands */
-    map.insert(QStringLiteral("GMT Standard Time"), QStringLiteral("Europe/London"));             /* (GMT) Greenwich Mean Time: Dublin, Edinburgh, Lisbon, London */
-    map.insert(QStringLiteral("Greenwich Standard Time"), QStringLiteral("Africa/Casablanca"));   /* (GMT) Casablanca, Monrovia */
-    map.insert(QStringLiteral("Central Europe Standard Time"), QStringLiteral("Europe/Prague"));  /* (GMT+01:00) Belgrade, Bratislava, Budapest, Ljubljana, Prague */
-    map.insert(QStringLiteral("Central European Standard Time"), QStringLiteral("Europe/Sarajevo"));      /* (GMT+01:00) Sarajevo, Skopje, Warsaw, Zagreb */
-    map.insert(QStringLiteral("Romance Standard Time"), QStringLiteral("Europe/Brussels"));       /* (GMT+01:00) Brussels, Copenhagen, Madrid, Paris */
-    map.insert(QStringLiteral("W. Europe Standard Time"), QStringLiteral("Europe/Amsterdam"));    /* (GMT+01:00) Amsterdam, Berlin, Bern, Rome, Stockholm, Vienna */
-    map.insert(QStringLiteral("W. Central Africa Standard Time"), QStringLiteral("Africa/Bangui"));       /* (GMT+01:00) West Central Africa */
-    map.insert(QStringLiteral("E. Europe Standard Time"), QStringLiteral("Europe/Bucharest"));    /* (GMT+02:00) Bucharest */
-    map.insert(QStringLiteral("Egypt Standard Time"), QStringLiteral("Africa/Cairo"));            /* (GMT+02:00) Cairo */
-    map.insert(QStringLiteral("FLE Standard Time"), QStringLiteral("Europe/Helsinki"));           /* (GMT+02:00) Helsinki, Kiev, Riga, Sofia, Tallinn, Vilnius */
-    map.insert(QStringLiteral("GTB Standard Time"), QStringLiteral("Europe/Athens"));             /* (GMT+02:00) Athens, Istanbul, Minsk */
-    map.insert(QStringLiteral("Israel Standard Time"), QStringLiteral("Europe/Athens"));          /* (GMT+02:00) Jerusalem */
-    map.insert(QStringLiteral("South Africa Standard Time"), QStringLiteral("Africa/Harare"));    /* (GMT+02:00) Harare, Pretoria */
-    map.insert(QStringLiteral("Russian Standard Time"), QStringLiteral("Europe/Moscow"));         /* (GMT+03:00) Moscow, St. Petersburg, Volgograd */
-    map.insert(QStringLiteral("Arab Standard Time"), QStringLiteral("Asia/Kuwait"));              /* (GMT+03:00) Kuwait, Riyadh */
-    map.insert(QStringLiteral("E. Africa Standard Time"), QStringLiteral("Africa/Nairobi"));      /* (GMT+03:00) Nairobi */
-    map.insert(QStringLiteral("Arabic Standard Time"), QStringLiteral("Asia/Baghdad"));           /* (GMT+03:00) Baghdad */
-    map.insert(QStringLiteral("Iran Standard Time"), QStringLiteral("Asia/Tehran"));              /* (GMT+03:30) Tehran */
-    map.insert(QStringLiteral("Arabian Standard Time"), QStringLiteral("Asia/Dubai"));            /* (GMT+04:00) Abu Dhabi, Muscat */
-    map.insert(QStringLiteral("Caucasus Standard Time"), QStringLiteral("Asia/Tbilisi"));         /* (GMT+04:00) Baku, Tbilisi, Yerevan */
-    map.insert(QStringLiteral("Transitional Islamic State of Afghanistan Standard Time"), QStringLiteral("Asia/Kabul"));  /* (GMT+04:30) Kabul */
-    map.insert(QStringLiteral("Ekaterinburg Standard Time"), QStringLiteral("Asia/Yekaterinburg"));       /* (GMT+05:00) Ekaterinburg */
-    map.insert(QStringLiteral("West Asia Standard Time"), QStringLiteral("Asia/Karachi"));        /* (GMT+05:00) Islamabad, Karachi, Tashkent */
-    map.insert(QStringLiteral("India Standard Time"), QStringLiteral("Asia/Calcutta"));           /* (GMT+05:30) Chennai, Kolkata, Mumbai, New Delhi */
-    map.insert(QStringLiteral("Nepal Standard Time"), QStringLiteral("Asia/Calcutta"));           /* (GMT+05:45) Kathmandu */
-    map.insert(QStringLiteral("Central Asia Standard Time"), QStringLiteral("Asia/Dhaka"));       /* (GMT+06:00) Astana, Dhaka */
-    map.insert(QStringLiteral("Sri Lanka Standard Time"), QStringLiteral("Asia/Colombo"));        /* (GMT+06:00) Sri Jayawardenepura */
-    map.insert(QStringLiteral("N. Central Asia Standard Time"), QStringLiteral("Asia/Omsk"));     /* (GMT+06:00) Almaty, Novosibirsk */
-    map.insert(QStringLiteral("Myanmar Standard Time"), QStringLiteral("Asia/Rangoon"));          /* (GMT+06:30) Yangon Rangoon */
-    map.insert(QStringLiteral("S.E. Asia Standard Time"), QStringLiteral("Asia/Bangkok"));        /* (GMT+07:00) Bangkok, Hanoi, Jakarta */
-    map.insert(QStringLiteral("North Asia Standard Time"), QStringLiteral("Asia/Krasnoyarsk"));   /* (GMT+07:00) Krasnoyarsk */
-    map.insert(QStringLiteral("China Standard Time"), QStringLiteral("Asia/Shanghai"));           /* (GMT+08:00) Beijing, Chongqing, Hong Kong SAR, Urumqi */
-    map.insert(QStringLiteral("Singapore Standard Time"), QStringLiteral("Asia/Singapore"));      /* (GMT+08:00) Kuala Lumpur, Singapore */
-    map.insert(QStringLiteral("Taipei Standard Time"), QStringLiteral("Asia/Taipei"));            /* (GMT+08:00) Taipei */
-    map.insert(QStringLiteral("W. Australia Standard Time"), QStringLiteral("Australia/Perth"));  /* (GMT+08:00) Perth */
-    map.insert(QStringLiteral("North Asia East Standard Time"), QStringLiteral("Asia/Irkutsk"));  /* (GMT+08:00) Irkutsk, Ulaanbaatar */
-    map.insert(QStringLiteral("Korea Standard Time"), QStringLiteral("Asia/Seoul"));              /* (GMT+09:00) Seoul */
-    map.insert(QStringLiteral("Tokyo Standard Time"), QStringLiteral("Asia/Tokyo"));              /* (GMT+09:00) Osaka, Sapporo, Tokyo */
-    map.insert(QStringLiteral("Yakutsk Standard Time"), QStringLiteral("Asia/Yakutsk"));          /* (GMT+09:00) Yakutsk */
-    map.insert(QStringLiteral("A.U.S. Central Standard Time"), QStringLiteral("Australia/Darwin"));       /* (GMT+09:30) Darwin */
-    map.insert(QStringLiteral("Cen. Australia Standard Time"), QStringLiteral("Australia/Adelaide"));     /* (GMT+09:30) Adelaide */
-    map.insert(QStringLiteral("A.U.S. Eastern Standard Time"), QStringLiteral("Australia/Sydney"));       /* (GMT+10:00) Canberra, Melbourne, Sydney */
-    map.insert(QStringLiteral("E. Australia Standard Time"), QStringLiteral("Australia/Brisbane"));       /* (GMT+10:00) Brisbane */
-    map.insert(QStringLiteral("Tasmania Standard Time"), QStringLiteral("Australia/Hobart"));     /* (GMT+10:00) Hobart */
-    map.insert(QStringLiteral("Vladivostok Standard Time"), QStringLiteral("Asia/Vladivostok"));  /* (GMT+10:00) Vladivostok */
-    map.insert(QStringLiteral("West Pacific Standard Time"), QStringLiteral("Pacific/Guam"));     /* (GMT+10:00) Guam, Port Moresby */
-    map.insert(QStringLiteral("Central Pacific Standard Time"), QStringLiteral("Pacific/Noumea"));        /* (GMT+11:00) Magadan, Solomon Islands, New Caledonia */
-    map.insert(QStringLiteral("Fiji Islands Standard Time"), QStringLiteral("Pacific/Fiji"));     /* (GMT+12:00) Fiji Islands, Kamchatka, Marshall Islands */
-    map.insert(QStringLiteral("New Zealand Standard Time"), QStringLiteral("Pacific/Auckland"));  /* (GMT+12:00) Auckland, Wellington */
-    map.insert(QStringLiteral("Tonga Standard Time"), QStringLiteral("Pacific/Tongatapu"));       /* (GMT+13:00) Nuku'alofa */
-    map.insert(QStringLiteral("Azerbaijan Standard Time"), QStringLiteral("America/Argentina/Buenos_Aires"));     /* (GMT-03:00) Buenos Aires */
-    map.insert(QStringLiteral("Middle East Standard Time"), QStringLiteral("Asia/Beirut"));       /* (GMT+02:00) Beirut */
-    map.insert(QStringLiteral("Jordan Standard Time"), QStringLiteral("Asia/Amman"));             /* (GMT+02:00) Amman */
-    map.insert(QStringLiteral("Central Standard Time (Mexico)"), QStringLiteral("America/Mexico_City"));  /* (GMT-06:00) Guadalajara, Mexico City, Monterrey - New */
-    map.insert(QStringLiteral("Mountain Standard Time (Mexico)"), QStringLiteral("America/Ojinaga"));     /* (GMT-07:00) Chihuahua, La Paz, Mazatlan - New */
-    map.insert(QStringLiteral("Pacific Standard Time (Mexico)"), QStringLiteral("America/Tijuana"));      /* (GMT-08:00) Tijuana, Baja California */
-    map.insert(QStringLiteral("Namibia Standard Time"), QStringLiteral("Africa/Windhoek"));       /* (GMT+02:00) Windhoek */
-    map.insert(QStringLiteral("Georgian Standard Time"), QStringLiteral("Asia/Tbilisi"));         /* (GMT+03:00) Tbilisi */
-    map.insert(QStringLiteral("Central Brazilian Standard Time"), QStringLiteral("America/Manaus"));      /*(GMT-04:00) Manaus */
-    map.insert(QStringLiteral("Montevideo Standard Time"), QStringLiteral("America/Montevideo"));        /* (GMT-03:00) Montevideo */
-    map.insert(QStringLiteral("Armenian Standard Time"), QStringLiteral("Asia/Yerevan"));         /* (GMT+04:00) Yerevan */
-    map.insert(QStringLiteral("Venezuela Standard Time"), QStringLiteral("America/Caracas"));     /* (GMT-04:30) Caracas */
-    map.insert(QStringLiteral("Argentina Standard Time"), QStringLiteral("America/Argentina/Buenos_Aires"));      /* (GMT-03:00) Buenos Aires */
-    map.insert(QStringLiteral("Morocco Standard Time"), QStringLiteral("Africa/Casablanca"));     /* (GMT) Casablanca */
-    map.insert(QStringLiteral("Pakistan Standard Time"), QStringLiteral("Asia/Karachi"));         /* (GMT+05:00) Islamabad, Karachi */
-    map.insert(QStringLiteral("Mauritius Standard Time"), QStringLiteral("Indian/Mauritius"));    /* (GMT+04:00) Port Louis */
-    map.insert(QStringLiteral("UTC"), QStringLiteral("UTC"));                                     /* (GMT) Coordinated Universal Time */
-    map.insert(QStringLiteral("Paraguay Standard Time"), QStringLiteral("America/Asuncion"));     /* (GMT-04:00) Asuncion */
-    map.insert(QStringLiteral("Kamchatka Standard Time"), QStringLiteral("Asia/Kamchatka"));      /* (GMT+12:00) Petropavlovsk-Kamchatsky */
-
-    return map;
-}
+    //{2, QLatin1String("Europe/Lisbon")},              /* GMT Greenwich Mean Time: Dublin, Edinburgh, Lisbon, London */
+    //{2, QLatin1String("Europe/Sarajevo")},            /* GMT+01:00 Sarajevo, Skopje, Sofija, Vilnius, Warsaw, Zagreb */
+    {3,  QLatin1String("Europe/Paris")},              /* GMT+01:00 Paris, Madrid, Brussels, Copenhagen */
+    {4,  QLatin1String("Europe/Berlin")},             /* GMT+01:00 Amsterdam, Berlin, Bern, Rome, Stockholm, Vienna */
+    {5,  QLatin1String("Europe/Bucharest")},          /* GMT+02:00 Bucharest */
+    {6,  QLatin1String("Europe/Prague")},             /* GMT+01:00 Prague, Central Europe */
+    {7,  QLatin1String("Europe/Athens")},             /* GMT+02:00 Athens, Istanbul, Minsk */
+    {8,  QLatin1String("America/Brazil")},            /* GMT-03:00 Brasilia */
+    {9,  QLatin1String("America/Halifax")},           /* GMT-04:00 Atlantic time (Canada) */
+    {10, QLatin1String("America/New_York")},          /* GMT-05:00 Eastern Time (US & Canada) */
+    {11, QLatin1String("America/Chicago")},           /* GMT-06:00 Central Time (US & Canada) */
+    {12, QLatin1String("America/Denver")},            /* GMT-07:00 Mountain Time (US & Canada) */
+    {13, QLatin1String("America/Los_Angeles")},       /* GMT-08:00 Pacific Time (US & Canada); Tijuana */
+    {14, QLatin1String("America/Anchorage")},         /* GMT-09:00 Alaska */
+    {15, QLatin1String("Pacific/Honolulu")},          /* GMT-10:00 Hawaii */
+    {16, QLatin1String("Pacific/Apia")},              /* GMT-11:00 Midway Island, Samoa */
+    {17, QLatin1String("Pacific/Auckland")},          /* GMT+12:00 Auckland, Wellington */
+    {18, QLatin1String("Australia/Brisbane")},        /* GMT+10:00 Brisbane, East Australia */
+    {19, QLatin1String("Australia/Adelaide")},        /* GMT+09:30 Adelaide, Central Australia */
+    {20, QLatin1String("Asia/Tokyo")},                /* GMT+09:00 Osaka, Sapporo, Tokyo */
+    {21, QLatin1String("Asia/Singapore")},            /* GMT+08:00 Kuala Lumpur, Singapore */
+    {22, QLatin1String("Asia/Bangkok")},              /* GMT+07:00 Bangkok, Hanoi, Jakarta */
+    {23, QLatin1String("Asia/Calcutta")},             /* GMT+05:30 Kolkata, Chennai, Mumbai, New Delhi, India Standard Time */
+    {24, QLatin1String("Asia/Dubai")},                /* GMT+04:00 Abu Dhabi, Muscat */
+    {25, QLatin1String("Asia/Tehran")},               /* GMT+03:30 Tehran */
+    {26, QLatin1String("Asia/Baghdad")},              /* GMT+03:00 Baghdad */
+    {27, QLatin1String("Asia/Jerusalem")},            /* GMT+02:00 Israel, Jerusalem Standard Time */
+    {28, QLatin1String("America/St_Johns")},          /* GMT-03:30 Newfoundland */
+    {29, QLatin1String("Atlantic/Portugal")},         /* GMT-01:00 Azores */
+    {30, QLatin1String("America/Noronha")},           /* GMT-02:00 Mid-Atlantic */
+    {31, QLatin1String("Africa/Monrovia")},           /* GMT Casablanca, Monrovia */
+    {32, QLatin1String("America/Argentina/Buenos_Aires")}, /* GMT-03:00 Buenos Aires, Georgetown */
+    {33, QLatin1String("America/La_Paz")},            /* GMT-04:00 Caracas, La Paz */
+    {34, QLatin1String("America/New_York")},          /* GMT-05:00 Indiana (East) */
+    {35, QLatin1String("America/Bogota")},            /* GMT-05:00 Bogota, Lima, Quito */
+    {36, QLatin1String("America/Winnipeg")},          /* GMT-06:00 Saskatchewan */
+    {37, QLatin1String("America/Mexico_City")},       /* GMT-06:00 Mexico City, Tegucigalpa */
+    {38, QLatin1String("America/Phoenix")},           /* GMT-07:00 Arizona */
+    {39, QLatin1String("Pacific/Kwajalein")},         /* GMT-12:00 Eniwetok, Kwajalein, Dateline Time */
+    {40, QLatin1String("Pacific/Fiji")},              /* GMT+12:00 Fušál, Kamchatka, Mashall Is. */
+    {41, QLatin1String("Pacific/Noumea")},            /* GMT+11:00 Magadan, Solomon Is., New Caledonia */
+    {42, QLatin1String("Australia/Hobart")},          /* GMT+10:00 Hobart, Tasmania */
+    {43, QLatin1String("Pacific/Guam")},              /* GMT+10:00 Guam, Port Moresby */
+    {44, QLatin1String("Australia/Darwin")},          /* GMT+09:30 Darwin */
+    {45, QLatin1String("Asia/Shanghai")},             /* GMT+08:00 Beijing, Chongqing, Hong Kong SAR, Urumqi */
+    {46, QLatin1String("Asia/Omsk")},                 /* GMT+06:00 Almaty, Novosibirsk, North Central Asia */
+    {47, QLatin1String("Asia/Karachi")},              /* GMT+05:00 Islamabad, Karachi, Tashkent */
+    {48, QLatin1String("Asia/Kabul")},                /* GMT+04:30 Kabul */
+    {49, QLatin1String("Africa/Cairo")},              /* GMT+02:00 Cairo */
+    {50, QLatin1String("Africa/Harare")},             /* GMT+02:00 Harare, Pretoria */
+    {51, QLatin1String("Europe/Moscow")},             /* GMT+03:00 Moscow, St. Petersburg, Volgograd */
+    {53, QLatin1String("Atlantic/Cape_Verde")},       /* GMT-01:00 Cape Verde Is. */
+    {54, QLatin1String("Asia/Tbilisi")},              /* GMT+04:00 Baku, Tbilisi, Yerevan */
+    {55, QLatin1String("America/Tegucigalpa")},       /* GMT-06:00 Central America */
+    {56, QLatin1String("Africa/Nairobi")},            /* GMT+03:00 East Africa, Nairobi */
+    {58, QLatin1String("Asia/Yekaterinburg")},        /* GMT+05:00 Ekaterinburg */
+    {59, QLatin1String("Europe/Helsinki")},           /* GMT+02:00 Helsinki, Riga, Tallinn */
+    {60, QLatin1String("America/Greenland")},         /* GMT-03:00 Greenland */
+    {61, QLatin1String("Asia/Rangoon")},              /* GMT+06:30 Yangon (Rangoon) */
+    {62, QLatin1String("Asia/Katmandu")},             /* GMT+05:45 Kathmandu, Nepal */
+    {63, QLatin1String("Asia/Irkutsk")},              /* GMT+08:00 Irkutsk, Ulaan Bataar */
+    {64, QLatin1String("Asia/Krasnoyarsk")},          /* GMT+07:00 Krasnoyarsk */
+    {65, QLatin1String("America/Santiago")},          /* GMT-04:00 Santiago */
+    {66, QLatin1String("Asia/Colombo")},              /* GMT+06:00 Sri Jayawardenepura, Sri Lanka */
+    {67, QLatin1String("Pacific/Tongatapu")},         /* GMT+13:00 Nuku'alofa, Tonga */
+    {68, QLatin1String("Asia/Vladivostok")},          /* GMT+10:00 Vladivostok */
+    {69, QLatin1String("Africa/Bangui")},             /* GMT+01:00 West Central Africa */
+    {70, QLatin1String("Asia/Yakutsk")},              /* GMT+09:00 Yakutsk */
+    {71, QLatin1String("Asia/Dhaka")},                /* GMT+06:00 Astana, Dhaka */
+    {72, QLatin1String("Asia/Seoul")},                /* GMT+09:00 Seoul, Korea Standard time */
+    {73, QLatin1String("Australia/Perth")},           /* GMT+08:00 Perth, Western Australia */
+    {74, QLatin1String("Asia/Kuwait")},               /* GMT+03:00 Arab, Kuwait, Riyadh */
+    {75, QLatin1String("Asia/Taipei")},               /* GMT+08:00 Taipei */
+    {76, QLatin1String("Australia/Sydney")}          /* GMT+10:00 Canberra, Melbourne, Sydney */
+};
 
-static const QMap<int, QString> MSCDOTZIDTable = initMSCDOTZIDTable();
-static const QMap<QString, QString> MSSTTZTable = initMSStandardTimeTZTable();
+/* Based on "Microsoft Time Zone Index Values"
+ * http://support.microsoft.com/kb/973627
+ *
+ * The mapping is not exact, since the TZID usually refers to a
+ * region of multiple countries, so I always picked one of the countries
+ * in the specified region and used it's TZID.
+ *
+ * The Olson timezones are taken from https://en.wikipedia.org/wiki/List_of_tz_database_time_zones
+ *
+ * Note: using std::map, because it allows heterogeneous lookup, i.e. I can lookup the QLatin1String
+ * keys by using QString value, which is not possible with Qt containers.
+ */
+static const std::map<QLatin1String, QLatin1String, std::less<>> MSSTTZTable = {
+    {QLatin1String("Dateline Standard Time"), QLatin1String("Pacific/Kwajalein")},    /* (GMT-12:00) International Date Line West */
+    {QLatin1String("Samoa Standard Time"), QLatin1String("Pacific/Apia")},            /* (GMT-11:00) Midway Island, Samoa */
+    {QLatin1String("Hawaiian Standard Time"), QLatin1String("Pacific/Honolulu")},     /* (GMT-10:00) Hawaii */
+    {QLatin1String("Alaskan Standard Time"), QLatin1String("America/Anchorage")},     /* (GMT-09:00) Alaska */
+    {QLatin1String("Pacific Standard Time"), QLatin1String("America/Los_Angeles")},   /* (GMT-08:00) Pacific Time (US and Canada); Tijuana */
+    {QLatin1String("Mountain Standard Time"), QLatin1String("America/Denver")},       /* (GMT-07:00) Mountain Time (US and Canada) */
+    {QLatin1String("Mexico Standard Time 2"), QLatin1String("America/Chihuahua")},    /* (GMT-07:00) Chihuahua, La Paz, Mazatlan */
+    {QLatin1String("U.S. Mountain Standard Time"), QLatin1String("America/Phoenix")}, /* (GMT-07:00) Arizona */
+    {QLatin1String("Central Standard Time"), QLatin1String("America/Chicago")},       /* (GMT-06:00) Central Time (US and Canada */
+    {QLatin1String("Canada Central Standard Time"), QLatin1String("America/Winnipeg")},       /* (GMT-06:00) Saskatchewan */
+    {QLatin1String("Mexico Standard Time"), QLatin1String("America/Mexico_City")},    /* (GMT-06:00) Guadalajara, Mexico City, Monterrey */
+    {QLatin1String("Central America Standard Time"), QLatin1String("America/Chicago")},       /* (GMT-06:00) Central America */
+    {QLatin1String("Eastern Standard Time"), QLatin1String("America/New_York")},      /* (GMT-05:00) Eastern Time (US and Canada) */
+    {QLatin1String("U.S. Eastern Standard Time"), QLatin1String("America/New_York")}, /* (GMT-05:00) Indiana (East) */
+    {QLatin1String("S.A. Pacific Standard Time"), QLatin1String("America/Bogota")},   /* (GMT-05:00) Bogota, Lima, Quito */
+    {QLatin1String("Atlantic Standard Time"), QLatin1String("America/Halifax")},      /* (GMT-04:00) Atlantic Time (Canada) */
+    {QLatin1String("S.A. Western Standard Time"), QLatin1String("America/La_Paz")},   /* (GMT-04:00) Caracas, La Paz */
+    {QLatin1String("Pacific S.A. Standard Time"), QLatin1String("America/Santiago")}, /* (GMT-04:00) Santiago */
+    {QLatin1String("Newfoundland and Labrador Standard Time"), QLatin1String("America/St_Johns")},    /* (GMT-03:30) Newfoundland and Labrador */
+    {QLatin1String("E. South America Standard Time"), QLatin1String("America/Brazil")},       /* (GMT-03:00) Brasilia */
+    {QLatin1String("S.A. Eastern Standard Time"), QLatin1String("America/Argentina/Buenos_Aires")},   /* (GMT-03:00) Buenos Aires, Georgetown */
+    {QLatin1String("Greenland Standard Time"), QLatin1String("America/Greenland")},   /* (GMT-03:00) Greenland */
+    {QLatin1String("Mid-Atlantic Standard Time"), QLatin1String("America/Noronha")},  /* (GMT-02:00) Mid-Atlantic */
+    {QLatin1String("Azores Standard Time"), QLatin1String("Atlantic/Portugal")},      /* (GMT-01:00) Azores */
+    {QLatin1String("Cape Verde Standard Time"), QLatin1String("Atlantic/Cape_Verde")},        /* (GMT-01:00) Cape Verde Islands */
+    {QLatin1String("GMT Standard Time"), QLatin1String("Europe/London")},             /* (GMT) Greenwich Mean Time: Dublin, Edinburgh, Lisbon, London */
+    {QLatin1String("Greenwich Standard Time"), QLatin1String("Africa/Casablanca")},   /* (GMT) Casablanca, Monrovia */
+    {QLatin1String("Central Europe Standard Time"), QLatin1String("Europe/Prague")},  /* (GMT+01:00) Belgrade, Bratislava, Budapest, Ljubljana, Prague */
+    {QLatin1String("Central European Standard Time"), QLatin1String("Europe/Sarajevo")},      /* (GMT+01:00) Sarajevo, Skopje, Warsaw, Zagreb */
+    {QLatin1String("Romance Standard Time"), QLatin1String("Europe/Brussels")},       /* (GMT+01:00) Brussels, Copenhagen, Madrid, Paris */
+    {QLatin1String("W. Europe Standard Time"), QLatin1String("Europe/Amsterdam")},    /* (GMT+01:00) Amsterdam, Berlin, Bern, Rome, Stockholm, Vienna */
+    {QLatin1String("W. Central Africa Standard Time"), QLatin1String("Africa/Bangui")},       /* (GMT+01:00) West Central Africa */
+    {QLatin1String("E. Europe Standard Time"), QLatin1String("Europe/Bucharest")},    /* (GMT+02:00) Bucharest */
+    {QLatin1String("Egypt Standard Time"), QLatin1String("Africa/Cairo")},            /* (GMT+02:00) Cairo */
+    {QLatin1String("FLE Standard Time"), QLatin1String("Europe/Helsinki")},           /* (GMT+02:00) Helsinki, Kiev, Riga, Sofia, Tallinn, Vilnius */
+    {QLatin1String("GTB Standard Time"), QLatin1String("Europe/Athens")},             /* (GMT+02:00) Athens, Istanbul, Minsk */
+    {QLatin1String("Israel Standard Time"), QLatin1String("Europe/Athens")},          /* (GMT+02:00) Jerusalem */
+    {QLatin1String("South Africa Standard Time"), QLatin1String("Africa/Harare")},    /* (GMT+02:00) Harare, Pretoria */
+    {QLatin1String("Russian Standard Time"), QLatin1String("Europe/Moscow")},         /* (GMT+03:00) Moscow, St. Petersburg, Volgograd */
+    {QLatin1String("Arab Standard Time"), QLatin1String("Asia/Kuwait")},              /* (GMT+03:00) Kuwait, Riyadh */
+    {QLatin1String("E. Africa Standard Time"), QLatin1String("Africa/Nairobi")},      /* (GMT+03:00) Nairobi */
+    {QLatin1String("Arabic Standard Time"), QLatin1String("Asia/Baghdad")},           /* (GMT+03:00) Baghdad */
+    {QLatin1String("Iran Standard Time"), QLatin1String("Asia/Tehran")},              /* (GMT+03:30) Tehran */
+    {QLatin1String("Arabian Standard Time"), QLatin1String("Asia/Dubai")},            /* (GMT+04:00) Abu Dhabi, Muscat */
+    {QLatin1String("Caucasus Standard Time"), QLatin1String("Asia/Tbilisi")},         /* (GMT+04:00) Baku, Tbilisi, Yerevan */
+    {QLatin1String("Transitional Islamic State of Afghanistan Standard Time"), QLatin1String("Asia/Kabul")},  /* (GMT+04:30) Kabul */
+    {QLatin1String("Ekaterinburg Standard Time"), QLatin1String("Asia/Yekaterinburg")},       /* (GMT+05:00) Ekaterinburg */
+    {QLatin1String("West Asia Standard Time"), QLatin1String("Asia/Karachi")},        /* (GMT+05:00) Islamabad, Karachi, Tashkent */
+    {QLatin1String("India Standard Time"), QLatin1String("Asia/Calcutta")},           /* (GMT+05:30) Chennai, Kolkata, Mumbai, New Delhi */
+    {QLatin1String("Nepal Standard Time"), QLatin1String("Asia/Calcutta")},           /* (GMT+05:45) Kathmandu */
+    {QLatin1String("Central Asia Standard Time"), QLatin1String("Asia/Dhaka")},       /* (GMT+06:00) Astana, Dhaka */
+    {QLatin1String("Sri Lanka Standard Time"), QLatin1String("Asia/Colombo")},        /* (GMT+06:00) Sri Jayawardenepura */
+    {QLatin1String("N. Central Asia Standard Time"), QLatin1String("Asia/Omsk")},     /* (GMT+06:00) Almaty, Novosibirsk */
+    {QLatin1String("Myanmar Standard Time"), QLatin1String("Asia/Rangoon")},          /* (GMT+06:30) Yangon Rangoon */
+    {QLatin1String("S.E. Asia Standard Time"), QLatin1String("Asia/Bangkok")},        /* (GMT+07:00) Bangkok, Hanoi, Jakarta */
+    {QLatin1String("North Asia Standard Time"), QLatin1String("Asia/Krasnoyarsk")},   /* (GMT+07:00) Krasnoyarsk */
+    {QLatin1String("China Standard Time"), QLatin1String("Asia/Shanghai")},           /* (GMT+08:00) Beijing, Chongqing, Hong Kong SAR, Urumqi */
+    {QLatin1String("Singapore Standard Time"), QLatin1String("Asia/Singapore")},      /* (GMT+08:00) Kuala Lumpur, Singapore */
+    {QLatin1String("Taipei Standard Time"), QLatin1String("Asia/Taipei")},            /* (GMT+08:00) Taipei */
+    {QLatin1String("W. Australia Standard Time"), QLatin1String("Australia/Perth")},  /* (GMT+08:00) Perth */
+    {QLatin1String("North Asia East Standard Time"), QLatin1String("Asia/Irkutsk")},  /* (GMT+08:00) Irkutsk, Ulaanbaatar */
+    {QLatin1String("Korea Standard Time"), QLatin1String("Asia/Seoul")},              /* (GMT+09:00) Seoul */
+    {QLatin1String("Tokyo Standard Time"), QLatin1String("Asia/Tokyo")},              /* (GMT+09:00) Osaka, Sapporo, Tokyo */
+    {QLatin1String("Yakutsk Standard Time"), QLatin1String("Asia/Yakutsk")},          /* (GMT+09:00) Yakutsk */
+    {QLatin1String("A.U.S. Central Standard Time"), QLatin1String("Australia/Darwin")},       /* (GMT+09:30) Darwin */
+    {QLatin1String("Cen. Australia Standard Time"), QLatin1String("Australia/Adelaide")},     /* (GMT+09:30) Adelaide */
+    {QLatin1String("A.U.S. Eastern Standard Time"), QLatin1String("Australia/Sydney")},       /* (GMT+10:00) Canberra, Melbourne, Sydney */
+    {QLatin1String("E. Australia Standard Time"), QLatin1String("Australia/Brisbane")},       /* (GMT+10:00) Brisbane */
+    {QLatin1String("Tasmania Standard Time"), QLatin1String("Australia/Hobart")},     /* (GMT+10:00) Hobart */
+    {QLatin1String("Vladivostok Standard Time"), QLatin1String("Asia/Vladivostok")},  /* (GMT+10:00) Vladivostok */
+    {QLatin1String("West Pacific Standard Time"), QLatin1String("Pacific/Guam")},     /* (GMT+10:00) Guam, Port Moresby */
+    {QLatin1String("Central Pacific Standard Time"), QLatin1String("Pacific/Noumea")},        /* (GMT+11:00) Magadan, Solomon Islands, New Caledonia */
+    {QLatin1String("Fiji Islands Standard Time"), QLatin1String("Pacific/Fiji")},     /* (GMT+12:00) Fiji Islands, Kamchatka, Marshall Islands */
+    {QLatin1String("New Zealand Standard Time"), QLatin1String("Pacific/Auckland")},  /* (GMT+12:00) Auckland, Wellington */
+    {QLatin1String("Tonga Standard Time"), QLatin1String("Pacific/Tongatapu")},       /* (GMT+13:00) Nuku'alofa */
+    {QLatin1String("Azerbaijan Standard Time"), QLatin1String("America/Argentina/Buenos_Aires")},     /* (GMT-03:00) Buenos Aires */
+    {QLatin1String("Middle East Standard Time"), QLatin1String("Asia/Beirut")},       /* (GMT+02:00) Beirut */
+    {QLatin1String("Jordan Standard Time"), QLatin1String("Asia/Amman")},             /* (GMT+02:00) Amman */
+    {QLatin1String("Central Standard Time (Mexico)"), QLatin1String("America/Mexico_City")},  /* (GMT-06:00) Guadalajara, Mexico City, Monterrey - New */
+    {QLatin1String("Mountain Standard Time (Mexico)"), QLatin1String("America/Ojinaga")},     /* (GMT-07:00) Chihuahua, La Paz, Mazatlan - New */
+    {QLatin1String("Pacific Standard Time (Mexico)"), QLatin1String("America/Tijuana")},      /* (GMT-08:00) Tijuana, Baja California */
+    {QLatin1String("Namibia Standard Time"), QLatin1String("Africa/Windhoek")},       /* (GMT+02:00) Windhoek */
+    {QLatin1String("Georgian Standard Time"), QLatin1String("Asia/Tbilisi")},         /* (GMT+03:00) Tbilisi */
+    {QLatin1String("Central Brazilian Standard Time"), QLatin1String("America/Manaus")},      /*(GMT-04:00) Manaus */
+    {QLatin1String("Montevideo Standard Time"), QLatin1String("America/Montevideo")},        /* (GMT-03:00) Montevideo */
+    {QLatin1String("Armenian Standard Time"), QLatin1String("Asia/Yerevan")},         /* (GMT+04:00) Yerevan */
+    {QLatin1String("Venezuela Standard Time"), QLatin1String("America/Caracas")},     /* (GMT-04:30) Caracas */
+    {QLatin1String("Argentina Standard Time"), QLatin1String("America/Argentina/Buenos_Aires")},      /* (GMT-03:00) Buenos Aires */
+    {QLatin1String("Morocco Standard Time"), QLatin1String("Africa/Casablanca")},     /* (GMT) Casablanca */
+    {QLatin1String("Pakistan Standard Time"), QLatin1String("Asia/Karachi")},         /* (GMT+05:00) Islamabad, Karachi */
+    {QLatin1String("Mauritius Standard Time"), QLatin1String("Indian/Mauritius")},    /* (GMT+04:00) Port Louis */
+    {QLatin1String("UTC"), QLatin1String("UTC")},                                     /* (GMT) Coordinated Universal Time */
+    {QLatin1String("Paraguay Standard Time"), QLatin1String("America/Asuncion")},     /* (GMT-04:00) Asuncion */
+    {QLatin1String("Kamchatka Standard Time"), QLatin1String("Asia/Kamchatka")},      /* (GMT+12:00) Petropavlovsk-Kamchatsky */
+};
+} // namespace
 
-QString Private::checkAndConverCDOTZID(const QString& tzid, const EventPtr& event)
+QString Private::checkAndConverCDOTZID(const QString &tzid, const EventPtr& event)
 {
     /* Try to match the @tzid to any valid timezone we know. */
-    QTimeZone tz(tzid.toUtf8());
+    QTimeZone tz(tzid.toLatin1());
     if (tz.isValid()) {
         /* Yay, @tzid is a valid TZID in Olson format */
         return tzid;
@@ -1058,7 +1087,7 @@
     const QStringList properties = vcard.split(QLatin1Char('\n'));
     int CDOId = -1;
     for (const QString &property : properties) {
-        if (property.startsWith(QLatin1String("X-MICROSOFT-CDO-TZID"))) {
+        if (property.startsWith(u"X-MICROSOFT-CDO-TZID")) {
             QStringList parsed = property.split(QLatin1Char(':'));
             if (parsed.length() != 2) {
                 break;
@@ -1096,15 +1125,17 @@
             }
         }
 
-        if (MSCDOTZIDTable.contains(CDOId)) {
-            return MSCDOTZIDTable.value(CDOId);
+        const auto it = MSCDOTZIDTable.find(CDOId);
+        if (it != MSCDOTZIDTable.cend()) {
+            return it->second;
         }
     }
 
     /* We failed to map to X-MICROSOFT-CDO-TZID. Let's try mapping the TZID
      * onto the Microsoft Standard Time Zones */
-    if (MSSTTZTable.contains(tzid)) {
-        return MSSTTZTable.value(tzid);
+    const auto it = MSSTTZTable.find(tzid);
+    if (it != MSSTTZTable.cend()) {
+        return it->second;
     }
 
     /* Fail/ Just return the original TZID and hope Google will accept it
diff --git a/src/calendar/event.h b/src/calendar/event.h
--- a/src/calendar/event.h
+++ b/src/calendar/event.h
@@ -29,6 +29,8 @@
 
 #include <KCalendarCore/Event>
 
+#include <QScopedPointer>
+
 namespace KGAPI2
 {
 
@@ -39,7 +41,7 @@
  * @since 0.1
  */
 class KGAPICALENDAR_EXPORT Event: public KGAPI2::Object,
-                              public KCalendarCore::Event
+                                  public KCalendarCore::Event
 {
   public:
     /**
@@ -102,7 +104,7 @@
 
   private:
     class Private;
-    Private * const d;
+    QScopedPointer<Private> const d;
 
 };
 
diff --git a/src/calendar/event.cpp b/src/calendar/event.cpp
--- a/src/calendar/event.cpp
+++ b/src/calendar/event.cpp
@@ -25,30 +25,18 @@
 
 using namespace KGAPI2;
 
+namespace {
+static constexpr const char *EventIdProperty = "EventId";
+}
+
 class Q_DECL_HIDDEN Event::Private
 {
   public:
-    explicit Private();
-    Private(const Private &other);
-
     QString id;
-    bool deleted;
-    bool useDefaultReminders;
+    bool deleted = false;
+    bool useDefaultReminders = false;
 };
 
-Event::Private::Private():
-    deleted(false),
-    useDefaultReminders(false)
-{
-}
-
-Event::Private::Private(const Private &other):
-    id(other.id),
-    deleted(other.deleted),
-    useDefaultReminders(other.useDefaultReminders)
-{
-}
-
 Event::Event():
     Object(),
     KCalendarCore::Event(),
@@ -70,10 +58,7 @@
 {
 }
 
-Event::~Event()
-{
-    delete d;
-}
+Event::~Event()= default;
 
 bool Event::operator==(const Event &other) const
 {
@@ -118,7 +103,7 @@
 
 QString Event::id() const
 {
-    QString val = customProperty("LIBKGAPI", "EventId");
+    const QString val = customProperty("LIBKGAPI", EventIdProperty);
     if (val.isEmpty()) {
         // Backwards compatibility: prior to introducing "id", UID was used for
         // remote identification: use it
@@ -129,5 +114,5 @@
 
 void Event::setId(const QString &id)
 {
-    setCustomProperty("LIBKGAPI", "EventId", id);
+    setCustomProperty("LIBKGAPI", EventIdProperty, id);
 }
diff --git a/src/calendar/eventcreatejob.h b/src/calendar/eventcreatejob.h
--- a/src/calendar/eventcreatejob.h
+++ b/src/calendar/eventcreatejob.h
@@ -27,6 +27,8 @@
 #include "enums.h"
 #include "kgapicalendar_export.h"
 
+#include <QScopedPointer>
+
 namespace KGAPI2 {
 
 /**
@@ -96,7 +98,7 @@
 
   private:
     class Private;
-    Private * const d;
+    QScopedPointer<Private> const d;
     friend class Private;
 
 };
diff --git a/src/calendar/eventcreatejob.cpp b/src/calendar/eventcreatejob.cpp
--- a/src/calendar/eventcreatejob.cpp
+++ b/src/calendar/eventcreatejob.cpp
@@ -59,10 +59,7 @@
     d->calendarId = calendarId;
 }
 
-EventCreateJob::~EventCreateJob()
-{
-    delete d;
-}
+EventCreateJob::~EventCreateJob() = default;
 
 void EventCreateJob::setSendUpdates(SendUpdatesPolicy policy)
 {
@@ -85,19 +82,9 @@
     }
 
     const EventPtr event = d->events.current();
-    const QUrl url = CalendarService::createEventUrl(d->calendarId, d->updatesPolicy);
-    QNetworkRequest request(url);
-    request.setRawHeader("GData-Version", CalendarService::APIVersion().toLatin1());
-
+    const auto request = CalendarService::prepareRequest(CalendarService::createEventUrl(d->calendarId, d->updatesPolicy));
     const QByteArray rawData = CalendarService::eventToJSON(event, CalendarService::EventSerializeFlag::NoID);
 
-    QStringList headers;
-    auto rawHeaderList = request.rawHeaderList();
-    headers.reserve(rawHeaderList.size());
-    for (const QByteArray &str : qAsConst(rawHeaderList)) {
-        headers << QLatin1String(str) + QLatin1String(": ") + QLatin1String(request.rawHeader(str));
-    }
-
     enqueueRequest(request, rawData, QStringLiteral("application/json"));
 }
 
diff --git a/src/calendar/eventdeletejob.h b/src/calendar/eventdeletejob.h
--- a/src/calendar/eventdeletejob.h
+++ b/src/calendar/eventdeletejob.h
@@ -26,6 +26,8 @@
 #include "deletejob.h"
 #include "kgapicalendar_export.h"
 
+#include <QScopedPointer>
+
 namespace KGAPI2 {
 
 /**
@@ -113,7 +115,7 @@
 
   private:
     class Private;
-    Private * const d;
+    QScopedPointer<Private> const d;
     friend class Private;
 
 };
diff --git a/src/calendar/eventdeletejob.cpp b/src/calendar/eventdeletejob.cpp
--- a/src/calendar/eventdeletejob.cpp
+++ b/src/calendar/eventdeletejob.cpp
@@ -73,10 +73,7 @@
 }
 
 
-EventDeleteJob::~EventDeleteJob()
-{
-    delete d;
-}
+EventDeleteJob::~EventDeleteJob() = default;
 
 void EventDeleteJob::start()
 {
@@ -86,16 +83,7 @@
     }
 
     const QString eventId = d->eventsIds.current();
-    const QUrl url = CalendarService::removeEventUrl(d->calendarId, eventId);
-    QNetworkRequest request(url);
-    request.setRawHeader("GData-Version", CalendarService::APIVersion().toLatin1());
-
-    QStringList headers;
-    auto rawHeaderList = request.rawHeaderList();
-    headers.reserve(rawHeaderList.size());
-    for (const QByteArray &str : qAsConst(rawHeaderList)) {
-        headers << QLatin1String(str) + QLatin1String(": ") + QLatin1String(request.rawHeader(str));
-    }
+    const auto request = CalendarService::prepareRequest(CalendarService::removeEventUrl(d->calendarId, eventId));
 
     enqueueRequest(request);
 }
diff --git a/src/calendar/eventfetchjob.h b/src/calendar/eventfetchjob.h
--- a/src/calendar/eventfetchjob.h
+++ b/src/calendar/eventfetchjob.h
@@ -26,6 +26,8 @@
 #include "fetchjob.h"
 #include "kgapicalendar_export.h"
 
+#include <QScopedPointer>
+
 namespace KGAPI2 {
 
 /**
@@ -230,7 +232,7 @@
 
   private:
     class Private;
-    Private * const d;
+    QScopedPointer<Private> const d;
     friend class Private;
 
 };
diff --git a/src/calendar/eventfetchjob.cpp b/src/calendar/eventfetchjob.cpp
--- a/src/calendar/eventfetchjob.cpp
+++ b/src/calendar/eventfetchjob.cpp
@@ -36,64 +36,31 @@
 class Q_DECL_HIDDEN EventFetchJob::Private
 {
   public:
-    Private(EventFetchJob *parent);
-    QNetworkRequest createRequest(const QUrl &url);
-
     QString calendarId;
     QString eventId;
     QString filter;
-    bool fetchDeleted;
-    quint64 updatedTimestamp;
-    quint64 timeMin;
-    quint64 timeMax;
-
-  private:
-    EventFetchJob * const q;
+    bool fetchDeleted = true;
+    quint64 updatedTimestamp = 0;
+    quint64 timeMin = 0;
+    quint64 timeMax = 0;
 };
 
-EventFetchJob::Private::Private(EventFetchJob* parent):
-    fetchDeleted(true),
-    updatedTimestamp(0),
-    timeMin(0),
-    timeMax(0),
-    q(parent)
-{
-}
-
-QNetworkRequest EventFetchJob::Private::createRequest(const QUrl& url)
-{
-    QNetworkRequest request(url);
-    request.setRawHeader("GData-Version", CalendarService::APIVersion().toLatin1());
-
-    QStringList headers;
-    auto rawHeaderList = request.rawHeaderList();
-    headers.reserve(rawHeaderList.size());
-    for (const QByteArray &str : qAsConst(rawHeaderList)) {
-        headers << QLatin1String(str) + QLatin1String(": ") + QLatin1String(request.rawHeader(str));
-    }
-
-    return request;
-}
-
 EventFetchJob::EventFetchJob(const QString& calendarId, const AccountPtr& account, QObject* parent):
     FetchJob(account, parent),
-    d(new Private(this))
+    d(new Private)
 {
     d->calendarId = calendarId;
 }
 
 EventFetchJob::EventFetchJob(const QString& eventId, const QString& calendarId, const AccountPtr& account, QObject* parent):
     FetchJob(account, parent),
-    d(new Private(this))
+    d(new Private)
 {
     d->calendarId = calendarId;
     d->eventId = eventId;
 }
 
-EventFetchJob::~EventFetchJob()
-{
-    delete d;
-}
+EventFetchJob::~EventFetchJob() = default;
 
 void EventFetchJob::setFetchDeleted(bool fetchDeleted)
 {
@@ -193,7 +160,7 @@
     } else {
         url = CalendarService::fetchEventUrl(d->calendarId, d->eventId);
     }
-    const QNetworkRequest request = d->createRequest(url);
+    const QNetworkRequest request = CalendarService::prepareRequest(url);
     enqueueRequest(request);
 }
 
@@ -218,7 +185,7 @@
     }
 
     if (feedData.nextPageUrl.isValid()) {
-        const QNetworkRequest request = d->createRequest(feedData.nextPageUrl);
+        const auto request = CalendarService::prepareRequest(feedData.nextPageUrl);
         enqueueRequest(request);
     }
 
diff --git a/src/calendar/eventmodifyjob.h b/src/calendar/eventmodifyjob.h
--- a/src/calendar/eventmodifyjob.h
+++ b/src/calendar/eventmodifyjob.h
@@ -27,6 +27,8 @@
 #include "enums.h"
 #include "kgapicalendar_export.h"
 
+#include <QScopedPointer>
+
 namespace KGAPI2 {
 
 /**
@@ -97,7 +99,7 @@
 
   private:
     class Private;
-    Private * const d;
+    QScopedPointer<Private> const d;
     friend class Private;
 
 };
diff --git a/src/calendar/eventmodifyjob.cpp b/src/calendar/eventmodifyjob.cpp
--- a/src/calendar/eventmodifyjob.cpp
+++ b/src/calendar/eventmodifyjob.cpp
@@ -58,10 +58,7 @@
     d->calendarId = calendarId;
 }
 
-EventModifyJob::~EventModifyJob()
-{
-    delete d;
-}
+EventModifyJob::~EventModifyJob() = default;
 
 void EventModifyJob::setSendUpdates(KGAPI2::SendUpdatesPolicy updatesPolicy)
 {
@@ -84,19 +81,9 @@
     }
 
     const EventPtr event = d->events.current();
-    const QUrl url = CalendarService::updateEventUrl(d->calendarId, event->id(), d->updatesPolicy);
-    QNetworkRequest request(url);
-    request.setRawHeader("GData-Version", CalendarService::APIVersion().toLatin1());
-
+    const auto request = CalendarService::prepareRequest(CalendarService::updateEventUrl(d->calendarId, event->id(), d->updatesPolicy));
     const QByteArray rawData = CalendarService::eventToJSON(event);
 
-    QStringList headers;
-    auto rawHeaderList = request.rawHeaderList();
-    headers.reserve(rawHeaderList.size());
-    for (const QByteArray &str : qAsConst(rawHeaderList)) {
-        headers << QLatin1String(str) + QLatin1String(": ") + QLatin1String(request.rawHeader(str));
-    }
-
     enqueueRequest(request, rawData, QStringLiteral("application/json"));
 }
 
diff --git a/src/calendar/eventmovejob.h b/src/calendar/eventmovejob.h
--- a/src/calendar/eventmovejob.h
+++ b/src/calendar/eventmovejob.h
@@ -26,6 +26,8 @@
 #include "modifyjob.h"
 #include "kgapicalendar_export.h"
 
+#include <QScopedPointer>
+
 namespace KGAPI2
 {
 
@@ -136,7 +138,7 @@
 
   private:
     class Private;
-    Private * const d;
+    QScopedPointer<Private> const d;
     friend class Private;
 
 };
diff --git a/src/calendar/eventmovejob.cpp b/src/calendar/eventmovejob.cpp
--- a/src/calendar/eventmovejob.cpp
+++ b/src/calendar/eventmovejob.cpp
@@ -36,50 +36,17 @@
 
 class Q_DECL_HIDDEN EventMoveJob::Private
 {
-  public:
-    explicit Private(EventMoveJob *parent);
-    void processNextEvent();
-
+public:
     QueueHelper<QString> eventsIds;
     QString source;
     QString destination;
-
-  private:
-    EventMoveJob * const q;
 };
 
-EventMoveJob::Private::Private(EventMoveJob *parent):
-    q(parent)
-{
-}
-
-void EventMoveJob::Private::processNextEvent()
-{
-   if (eventsIds.atEnd()) {
-        q->emitFinished();
-        return;
-    }
-
-    const QString eventId = eventsIds.current();
-    const QUrl url = CalendarService::moveEventUrl(source, destination, eventId);
-    QNetworkRequest request(url);
-    request.setRawHeader("GData-Version", CalendarService::APIVersion().toLatin1());
-
-    QStringList headers;
-    auto rawHeaderList = request.rawHeaderList();
-    headers.reserve(rawHeaderList.size());
-    for (const QByteArray &str : qAsConst(rawHeaderList)) {
-        headers << QLatin1String(str) + QLatin1String(": ") + QLatin1String(request.rawHeader(str));
-    }
-
-    q->enqueueRequest(request);
-}
-
 EventMoveJob::EventMoveJob(const EventPtr &event, const QString &sourceCalendarId,
                            const QString &destinationCalendarId, const AccountPtr &account,
                            QObject *parent):
     ModifyJob(account, parent),
-    d(new Private(this))
+    d(new Private())
 {
     d->eventsIds << event->id();
     d->source = sourceCalendarId;
@@ -90,7 +57,7 @@
                            const QString &destinationCalendarId, const AccountPtr &account,
                            QObject *parent):
     ModifyJob(account, parent),
-    d(new Private(this))
+    d(new Private())
 {
     for (const EventPtr &event : events) {
         d->eventsIds << event->id();
@@ -103,7 +70,7 @@
                            const QString &destinationCalendarId, const AccountPtr &account,
                            QObject *parent):
     ModifyJob(account, parent),
-    d(new Private(this))
+    d(new Private())
 {
     d->eventsIds << eventId;
     d->source = sourceCalendarId;
@@ -114,21 +81,26 @@
                            const QString &destinationCalendarId, const AccountPtr &account,
                            QObject *parent):
     ModifyJob(account, parent),
-    d(new Private(this))
+    d(new Private())
 {
     d->eventsIds = eventsIds;
     d->source = sourceCalendarId;
     d->destination = destinationCalendarId;
 }
 
-EventMoveJob::~EventMoveJob()
-{
-    delete d;
-}
+EventMoveJob::~EventMoveJob() = default;
 
 void EventMoveJob::start()
 {
-    d->processNextEvent();
+    if (d->eventsIds.atEnd()) {
+        emitFinished();
+        return;
+    }
+
+    const QString eventId = d->eventsIds.current();
+    const auto request = CalendarService::prepareRequest(CalendarService::moveEventUrl(d->source, d->destination, eventId));
+
+    enqueueRequest(request);
 }
 
 void EventMoveJob::dispatchRequest(QNetworkAccessManager *accessManager, const QNetworkRequest &request, const QByteArray &data, const QString &contentType)
@@ -154,7 +126,7 @@
     items << CalendarService::JSONToEvent(rawData).dynamicCast<Event>();
     d->eventsIds.currentProcessed();
     // Enqueue next item or finish
-    d->processNextEvent();
+    start();
 
     return items;
 }
diff --git a/src/calendar/freebusyqueryjob.h b/src/calendar/freebusyqueryjob.h
--- a/src/calendar/freebusyqueryjob.h
+++ b/src/calendar/freebusyqueryjob.h
@@ -26,15 +26,16 @@
 
 #include <QVector>
 #include <QDateTime>
+#include <QScopedPointer>
 
 namespace KGAPI2 {
 
 class KGAPICALENDAR_EXPORT FreeBusyQueryJob : public KGAPI2::FetchJob
 {
     Q_OBJECT
 public:
     struct BusyRange {
-        BusyRange() {};
+        BusyRange() = default;
         BusyRange(const QDateTime &busyStart, const QDateTime &busyEnd)
             : busyStart(busyStart), busyEnd(busyEnd)
         {}
@@ -49,12 +50,12 @@
     };
     typedef QVector<BusyRange> BusyRangeList;
 
-    explicit FreeBusyQueryJob(const QString &id, 
+    explicit FreeBusyQueryJob(const QString &id,
                               const QDateTime &timeMin,
                               const QDateTime &timeMax,
                               const AccountPtr &account,
                               QObject* parent = nullptr);
-    ~FreeBusyQueryJob();
+    ~FreeBusyQueryJob() override;
 
     QString id() const;
     QDateTime timeMin() const;
@@ -69,7 +70,7 @@
 
 private:
     class Private;
-    Private * const d;
+    QScopedPointer<Private> const d;
     friend class Private;
 
 };
diff --git a/src/calendar/freebusyqueryjob.cpp b/src/calendar/freebusyqueryjob.cpp
--- a/src/calendar/freebusyqueryjob.cpp
+++ b/src/calendar/freebusyqueryjob.cpp
@@ -54,10 +54,7 @@
 {
 }
 
-FreeBusyQueryJob::~FreeBusyQueryJob()
-{
-    delete d;
-}
+FreeBusyQueryJob::~FreeBusyQueryJob() = default;
 
 FreeBusyQueryJob::BusyRangeList FreeBusyQueryJob::busy() const
 {
@@ -84,16 +81,15 @@
     QVariantMap requestData({
         { QStringLiteral("timeMin"), Utils::rfc3339DateToString(d->timeMin) },
         { QStringLiteral("timeMax"), Utils::rfc3339DateToString(d->timeMax) },
-        { QStringLiteral("items"), 
+        { QStringLiteral("items"),
             QVariantList({
                 QVariantMap({ { QStringLiteral("id"), d->id } })
             })
         }});
     QJsonDocument document = QJsonDocument::fromVariant(requestData);
     const QByteArray json = document.toJson(QJsonDocument::Compact);
 
-    QNetworkRequest request(CalendarService::freeBusyQueryUrl());
-    request.setRawHeader("GData-Version", CalendarService::APIVersion().toLatin1());
+    const auto request = CalendarService::prepareRequest(CalendarService::freeBusyQueryUrl());
     enqueueRequest(request, json, QStringLiteral("application/json"));
 }
 
@@ -126,7 +122,7 @@
             const QVariantList busyList = cal[QStringLiteral("busy")].toList();
             for (const QVariant &busyV : busyList) {
                 const QVariantMap busy = busyV.toMap();
-                d->busy << BusyRange{ 
+                d->busy << BusyRange{
                     Utils::rfc3339DateFromString(busy[QStringLiteral("start")].toString()),
                     Utils::rfc3339DateFromString(busy[QStringLiteral("end")].toString())
                 };
diff --git a/src/calendar/reminder.h b/src/calendar/reminder.h
--- a/src/calendar/reminder.h
+++ b/src/calendar/reminder.h
@@ -30,6 +30,8 @@
 #include <KCalendarCore/Alarm>
 #include <KCalendarCore/Incidence>
 
+#include <QScopedPointer>
+
 namespace KGAPI2
 {
 
@@ -54,13 +56,13 @@
      * @param type Type of the reminder (email, notification, etc.)
      * @param startOffset How long before the event should the reminder be shown
      */
-    explicit Reminder( const KCalendarCore::Alarm::Type &type,
-                       const KCalendarCore::Duration &startOffset = KCalendarCore::Duration( 0 ) );
+    explicit Reminder(const KCalendarCore::Alarm::Type &type,
+                      const KCalendarCore::Duration &startOffset = KCalendarCore::Duration(0));
 
     /**
      * @brief Copy constructor
      */
-    Reminder( const Reminder &other );
+    Reminder(const Reminder &other);
 
     /**
      * @brief Destructor
@@ -79,7 +81,7 @@
      *
      * @param type
      */
-    void setType(KCalendarCore::Alarm::Type type );
+    void setType(KCalendarCore::Alarm::Type type);
 
     /**
      * @brief Returns how long before the event should reminder be shown
@@ -89,19 +91,19 @@
     /**
      * @brief Sets how long before the event should reminder be shown
      */
-    void setStartOffset( const KCalendarCore::Duration &startOffset );
+    void setStartOffset(const KCalendarCore::Duration &startOffset);
 
     /**
      * @brief Converts the reminder to a KCalendarCore::Alarm
      *
      * @param incidence An incidence on which the reminder should be applied
      * @return Returns a new KCalendarCore::Alarm
      */
-    KCalendarCore::Alarm *toAlarm( KCalendarCore::Incidence *incidence ) const;
+    KCalendarCore::Alarm *toAlarm(KCalendarCore::Incidence *incidence) const;
 
   private:
     class Private;
-    Private *const d;
+    QScopedPointer<Private> const d;
 };
 
 } // namespace KGAPI2
diff --git a/src/calendar/reminder.cpp b/src/calendar/reminder.cpp
--- a/src/calendar/reminder.cpp
+++ b/src/calendar/reminder.cpp
@@ -29,47 +29,29 @@
 
 class Q_DECL_HIDDEN Reminder::Private
 {
-  public:
-    Private();
-    Private(const Private &other);
-    ~Private() {}
-
-    Alarm::Type type;
+public:
+    Alarm::Type type = Alarm::Invalid;
     Duration offset;
 };
 
-Reminder::Private::Private():
-    type(Alarm::Invalid)
-{
-}
-
-Reminder::Private::Private(const Private &other):
-    type(other.type),
-    offset(other.offset)
-{
-}
-
 Reminder::Reminder():
     d(new Private)
 {
 }
 
-Reminder::Reminder (const Alarm::Type &type, const Duration& startOffset):
+Reminder::Reminder(const Alarm::Type &type, const Duration& startOffset):
     d(new Private)
 {
     d->type = type;
     d->offset = startOffset;
 }
 
-Reminder::Reminder (const Reminder& other):
+Reminder::Reminder(const Reminder& other):
     d(new Private(*(other.d)))
 {
 }
 
-Reminder::~Reminder()
-{
-    delete d;
-}
+Reminder::~Reminder() = default;
 
 bool Reminder::operator==(const Reminder &other) const
 {
@@ -84,8 +66,7 @@
     return true;
 }
 
-
-void Reminder::setType (Alarm::Type type)
+void Reminder::setType(Alarm::Type type)
 {
     d->type = type;
 }
@@ -95,7 +76,7 @@
     return d->type;
 }
 
-void Reminder::setStartOffset (const Duration& startOffset)
+void Reminder::setStartOffset(const Duration &startOffset)
 {
     d->offset = startOffset;
 }
@@ -106,13 +87,11 @@
 }
 
 // In LibKGAPI1 we return AlarmPtr
-Alarm* Reminder::toAlarm (Incidence* incidence) const
+Alarm *Reminder::toAlarm(Incidence *incidence) const
 {
-    Alarm* alarm = new Alarm(incidence);
-
+    auto alarm = new Alarm(incidence);
     alarm->setType(d->type);
     alarm->setStartOffset(d->offset);
-
     return alarm;
 }