diff --git a/src/extractorpostprocessor.cpp b/src/extractorpostprocessor.cpp
index 402a117..b757146 100644
--- a/src/extractorpostprocessor.cpp
+++ b/src/extractorpostprocessor.cpp
@@ -1,358 +1,358 @@
 /*
    Copyright (c) 2017 Volker Krause <vkrause@kde.org>
 
    This library is free software; you can redistribute it and/or modify it
    under the terms of the GNU Library General Public License as published by
    the Free Software Foundation; either version 2 of the License, or (at your
    option) any later version.
 
    This library is distributed in the hope that it will be useful, but WITHOUT
    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
    License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
 */
 
 #include "extractorpostprocessor.h"
 
 #include "airportdb/airportdb.h"
 #include "calendarhandler.h"
 #include "iatabcbpparser.h"
 #include "jsonlddocument.h"
 #include "logging.h"
 #include "mergeutil.h"
 
 #include <KItinerary/BusTrip>
 #include <KItinerary/Flight>
 #include <KItinerary/Organization>
 #include <KItinerary/Person>
 #include <KItinerary/Place>
 #include <KItinerary/Reservation>
 #include <KItinerary/Ticket>
 #include <KItinerary/TrainTrip>
 
 #include <QDebug>
 #include <QJsonArray>
 #include <QJsonDocument>
 #include <QTimeZone>
 #include <QUrl>
 
 #include <algorithm>
 
 using namespace KItinerary;
 namespace KItinerary {
 class ExtractorPostprocessorPrivate
 {
 public:
     void mergeOrAppend(const QVariant &elem);
 
     QVariant processFlightReservation(FlightReservation res) const;
     Flight processFlight(Flight flight) const;
     Airport processAirport(Airport airport) const;
     Airline processAirline(Airline airline) const;
-    void processFlightTime(Flight &flight, const char *timePropName, const Airport &airport) const;
+    void processFlightTime(Flight &flight, QDateTime(Flight::* getter)() const, void(Flight::* setter)(const QDateTime&), const Airport &airport) const;
     TrainReservation processTrainReservation(TrainReservation res) const;
     TrainTrip processTrainTrip(TrainTrip trip) const;
     TrainStation processTrainStation(TrainStation station) const;
     QVariant processReservation(QVariant res) const;
     Person processPerson(Person person) const;
 
     bool filterReservation(const QVariant &res) const;
     bool filterLodgingReservation(const LodgingReservation &res) const;
     bool filterFlight(const Flight &flight) const;
     bool filterAirport(const Airport &airport) const;
     bool filterTrainOrBusTrip(const QVariant &trip) const;
     bool filterTrainOrBusStation(const QVariant &station) const;
 
     QVector<QVariant> m_data;
     QDateTime m_contextDate;
     bool m_resultFinalized = false;
 };
 }
 
 ExtractorPostprocessor::ExtractorPostprocessor()
     : d(new ExtractorPostprocessorPrivate)
 {
 }
 
 ExtractorPostprocessor::ExtractorPostprocessor(ExtractorPostprocessor &&) = default;
 ExtractorPostprocessor::~ExtractorPostprocessor() = default;
 
 void ExtractorPostprocessor::process(const QVector<QVariant> &data)
 {
     d->m_resultFinalized = false;
     d->m_data.reserve(d->m_data.size() + data.size());
     for (auto elem : data) {
         if (elem.userType() == qMetaTypeId<FlightReservation>()) {
             elem = d->processFlightReservation(elem.value<FlightReservation>());
         } else if (elem.userType() == qMetaTypeId<TrainReservation>()) {
             elem = d->processTrainReservation(elem.value<TrainReservation>());
         }
 
         if (JsonLd::canConvert<Reservation>(elem)) {
             auto res = JsonLd::convert<Reservation>(elem);
             if (!res.underName().isNull()) {
                 const auto person = d->processPerson(res.underName().value<Person>());
                 res.setUnderName(person);
                 JsonLdDocument::writeProperty(elem, "underName", person);
             }
             elem = d->processReservation(elem);
         }
 
         d->mergeOrAppend(elem);
     }
 }
 
 QVector<QVariant> ExtractorPostprocessor::result() const
 {
     if (!d->m_resultFinalized) {
         for (auto it = d->m_data.begin(); it != d->m_data.end();) {
             if (d->filterReservation(*it)) {
                 ++it;
             } else {
                 //qCDebug(Log).noquote() << "Discarding element:" << QJsonDocument(JsonLdDocument::toJson({*it})).toJson();
                 it = d->m_data.erase(it);
             }
         }
         d->m_resultFinalized = true;
     }
 
     std::stable_sort(d->m_data.begin(), d->m_data.end(), [](const QVariant &lhs, const QVariant &rhs) {
         return CalendarHandler::startDateTime(lhs) < CalendarHandler::startDateTime(rhs);
     });
 
     return d->m_data;
 }
 
 void ExtractorPostprocessor::setContextDate(const QDateTime& dt)
 {
     d->m_contextDate = dt;
 }
 
 void ExtractorPostprocessorPrivate::mergeOrAppend(const QVariant &elem)
 {
     const auto it = std::find_if(m_data.begin(), m_data.end(), [elem](const QVariant &other) {
         return MergeUtil::isSameReservation(elem, other);
     });
 
     if (it == m_data.end()) {
         m_data.push_back(elem);
     } else {
         *it = JsonLdDocument::apply(*it, elem);
     }
 }
 
 QVariant ExtractorPostprocessorPrivate::processFlightReservation(FlightReservation res) const
 {
     // expand ticketToken for IATA BCBP data
     const auto bcbp = res.reservedTicket().value<Ticket>().ticketTokenData();
     if (!bcbp.isEmpty()) {
         const auto bcbpData = IataBcbpParser::parse(bcbp, m_contextDate.date());
         if (bcbpData.size() == 1) {
             res = JsonLdDocument::apply(bcbpData.at(0), res).value<FlightReservation>();
         }
     }
 
     res.setReservationFor(processFlight(res.reservationFor().value<Flight>()));
     return res;
 }
 
 Flight ExtractorPostprocessorPrivate::processFlight(Flight flight) const
 {
     flight.setDepartureAirport(processAirport(flight.departureAirport()));
     flight.setArrivalAirport(processAirport(flight.arrivalAirport()));
     flight.setAirline(processAirline(flight.airline()));
 
-    processFlightTime(flight, "boardingTime", flight.departureAirport());
-    processFlightTime(flight, "departureTime", flight.departureAirport());
-    processFlightTime(flight, "arrivalTime", flight.arrivalAirport());
+    processFlightTime(flight, &Flight::boardingTime, &Flight::setBoardingTime, flight.departureAirport());
+    processFlightTime(flight, &Flight::departureTime, &Flight::setDepartureTime, flight.departureAirport());
+    processFlightTime(flight, &Flight::arrivalTime, &Flight::setArrivalTime, flight.arrivalAirport());
 
     return flight;
 }
 
 Airport ExtractorPostprocessorPrivate::processAirport(Airport airport) const
 {
     // clean up name
     airport.setName(airport.name().trimmed());
 
     // complete missing IATA codes
     auto iataCode = airport.iataCode();
     if (iataCode.isEmpty()) {
         iataCode = AirportDb::iataCodeFromName(airport.name()).toString();
         if (!iataCode.isEmpty()) {
             airport.setIataCode(iataCode);
         }
     }
 
     // complete missing geo coordinates
     auto geo = airport.geo();
     if (!geo.isValid()) {
         const auto coord = AirportDb::coordinateForAirport(AirportDb::IataCode{iataCode});
         if (coord.isValid()) {
             geo.setLatitude(coord.latitude);
             geo.setLongitude(coord.longitude);
             airport.setGeo(geo);
         }
     }
 
     return airport;
 }
 
 Airline ExtractorPostprocessorPrivate::processAirline(Airline airline) const
 {
     airline.setName(airline.name().trimmed());
     return airline;
 }
 
-void ExtractorPostprocessorPrivate::processFlightTime(Flight &flight, const char *timePropName, const Airport &airport) const
+void ExtractorPostprocessorPrivate::processFlightTime(Flight &flight, QDateTime(Flight::* getter)() const, void(Flight::* setter)(const QDateTime&), const Airport &airport) const
 {
-    auto dt = JsonLdDocument::readProperty(flight, timePropName).toDateTime();
+    auto dt = (flight.*getter)();
     if (!dt.isValid()) {
         return;
     }
 
     if (dt.date().year() <= 1970 && flight.departureDay().isValid()) { // we just have the time, but not the day
         dt.setDate(flight.departureDay());
-        JsonLdDocument::writeProperty(flight, timePropName, dt);
+        (flight.*setter)(dt);
     }
 
     if (dt.timeSpec() == Qt::TimeZone || airport.iataCode().isEmpty()) {
         return;
     }
 
     const auto tz = AirportDb::timezoneForAirport(AirportDb::IataCode{airport.iataCode()});
     if (!tz.isValid()) {
         return;
     }
 
     // prefer our timezone over externally provided UTC offset, if they match
     if (dt.timeSpec() == Qt::OffsetFromUTC && tz.offsetFromUtc(dt) != dt.offsetFromUtc()) {
         return;
     }
 
     if (dt.timeSpec() == Qt::OffsetFromUTC || dt.timeSpec() == Qt::LocalTime) {
         dt.setTimeSpec(Qt::TimeZone);
         dt.setTimeZone(tz);
     } else if (dt.timeSpec() == Qt::UTC) {
         dt = dt.toTimeZone(tz);
     }
     // if we updated from UTC offset to timezone spec here, QDateTime will compare equal
     // and the auto-generated property code will not actually update the property
     // so, clear the property first to force an update
-    JsonLdDocument::writeProperty(flight, timePropName, QDateTime());
-    JsonLdDocument::writeProperty(flight, timePropName, dt);
+    (flight.*setter)(QDateTime());
+    (flight.*setter)(dt);
 }
 
 TrainReservation ExtractorPostprocessorPrivate::processTrainReservation(TrainReservation res) const
 {
     res.setReservationFor(processTrainTrip(res.reservationFor().value<TrainTrip>()));
     return res;
 }
 
 TrainTrip ExtractorPostprocessorPrivate::processTrainTrip(TrainTrip trip) const
 {
     trip.setArrivalPlatform(trip.arrivalPlatform().trimmed());
     trip.setDeparturePlatform(trip.departurePlatform().trimmed());
     trip.setDeparatureStation(processTrainStation(trip.departureStation()));
     trip.setArrivalStation(processTrainStation(trip.arrivalStation()));
     return trip;
 }
 
 TrainStation ExtractorPostprocessorPrivate::processTrainStation(TrainStation station) const
 {
     const auto id = station.identifier();
     if (id.isEmpty()) { // empty -> null cleanup, to have more compact json-ld output
         station.setIdentifier(QString());
     } else if (id.startsWith(QLatin1String("sncf")) && id.size() == 10) {
         // Gare & Connexion ids start with a country code, propagate that to the station address field
         auto addr = station.address();
         if (addr.addressCountry().isEmpty()) {
             addr.setAddressCountry(id.mid(5, 2).toUpper());
             station.setAddress(addr);
         }
     }
 
     return station;
 }
 
 QVariant ExtractorPostprocessorPrivate::processReservation(QVariant res) const
 {
     const auto viewUrl = JsonLdDocument::readProperty(res, "url").toUrl();
     const auto modUrl = JsonLdDocument::readProperty(res, "modifyReservationUrl").toUrl();
     const auto cancelUrl = JsonLdDocument::readProperty(res, "cancelReservationUrl").toUrl();
     // remove duplicated urls
     if (modUrl.isValid() && viewUrl == modUrl) {
         JsonLdDocument::removeProperty(res, "modifyReservationUrl");
     }
     if (cancelUrl.isValid() && viewUrl == cancelUrl) {
         JsonLdDocument::removeProperty(res, "cancelReservationUrl");
     }
 
     return res;
 }
 
 Person ExtractorPostprocessorPrivate::processPerson(Person person) const
 {
     if (person.name().isEmpty() && !person.familyName().isEmpty() && !person.givenName().isEmpty()) {
         person.setName(person.givenName() + QLatin1Char(' ') + person.familyName());
     }
     return person;
 }
 
 bool ExtractorPostprocessorPrivate::filterReservation(const QVariant &res) const
 {
     const auto resFor = JsonLdDocument::readProperty(res, "reservationFor");
     if (resFor.isNull()) {
         return false;
     }
 
     if (resFor.userType() == qMetaTypeId<Flight>()) {
         return filterFlight(resFor.value<Flight>());
     } else if (resFor.userType() == qMetaTypeId<TrainTrip>()) {
         return filterTrainOrBusTrip(resFor);
     } else if (resFor.userType() == qMetaTypeId<BusTrip>()) {
         return filterTrainOrBusTrip(resFor);
     }
 
     if (res.userType() == qMetaTypeId<LodgingReservation>()) {
         return filterLodgingReservation(res.value<LodgingReservation>());
     }
     return true;
 }
 
 bool ExtractorPostprocessorPrivate::filterLodgingReservation(const LodgingReservation &res) const
 {
     return res.checkinTime().isValid() && res.checkoutTime().isValid();
 }
 
 bool ExtractorPostprocessorPrivate::filterFlight(const Flight &flight) const
 {
     // this will be valid if either boarding time, departure time or departure day is set
     const auto validDate = flight.departureDay().isValid();
     return filterAirport(flight.departureAirport())
            && filterAirport(flight.arrivalAirport())
            && validDate;
 }
 
 bool ExtractorPostprocessorPrivate::filterAirport(const Airport &airport) const
 {
     return !airport.iataCode().isEmpty() || !airport.name().isEmpty();
 }
 
 bool ExtractorPostprocessorPrivate::filterTrainOrBusTrip(const QVariant &trip) const
 {
     const auto depDt = JsonLdDocument::readProperty(trip, "departureTime").toDateTime();
     const auto arrDt = JsonLdDocument::readProperty(trip, "arrivalTime").toDateTime();
     return filterTrainOrBusStation(JsonLdDocument::readProperty(trip, "departureStation"))
            && filterTrainOrBusStation(JsonLdDocument::readProperty(trip, "arrivalStation"))
            && depDt.isValid() && arrDt.isValid();
 }
 
 bool ExtractorPostprocessorPrivate::filterTrainOrBusStation(const QVariant &station) const
 {
     return !JsonLdDocument::readProperty(station, "name").toString().isEmpty();
 }