File indexing completed on 2024-06-23 04:42:35

 // Copyright (c) 2018 Michael Bohlender <michael.bohlender@kdemail.net>
 // Copyright (c) 2018 Christian Mollekopf <mollekopf@kolabsys.com>
 // Copyright (c) 2018 Rémi Nicole <minijackson@riseup.net>
 // Copyright (c) 2021 Carl Schwan <carlschwan@kde.org>
 // Copyright (c) 2021 Claudio Cambra <claudio.cambra@gmail.com>
 // SPDX-License-Identifier: LGPL-2.0-or-later
 
 #include "incidenceoccurrencemodel.h"
 
 #include "../filter.h"
 #include <Akonadi/EntityTreeModel>
 #include <KCalendarCore/OccurrenceIterator>
 #include <KConfigGroup>
 #include <KLocalizedString>
 #include <KSharedConfig>
 #include <QMetaEnum>
 
 IncidenceOccurrenceModel::IncidenceOccurrenceModel(QObject *parent)
     : QAbstractListModel(parent)
     , m_coreCalendar(nullptr)
 {
     m_resetThrottlingTimer.setSingleShot(true);
     QObject::connect(&m_resetThrottlingTimer, &QTimer::timeout, this, &IncidenceOccurrenceModel::resetFromSource);
 
     KSharedConfig::Ptr config = KSharedConfig::openConfig();
     KConfigGroup rColorsConfig(config, QStringLiteral("Resources Colors"));
     m_colorWatcher = KConfigWatcher::create(config);
 
     // This is quite slow; would be nice to find a quicker way
     connect(m_colorWatcher.data(), &KConfigWatcher::configChanged, this, &IncidenceOccurrenceModel::resetFromSource);
 }
 
 void IncidenceOccurrenceModel::setStart(const QDate &start)
 {
     if(start == mStart) {
         return;
     }
 
     mStart = start;
     Q_EMIT startChanged();
 
     mEnd = mStart.addDays(mLength);
     scheduleReset();
 }
 
 QDate IncidenceOccurrenceModel::start() const
 {
     return mStart;
 }
 
 void IncidenceOccurrenceModel::setLength(int length)
 {
     if (mLength == length) {
         return;
     }
     mLength = length;
     Q_EMIT lengthChanged();
 
     mEnd = mStart.addDays(mLength);
     scheduleReset();
 }
 
 int IncidenceOccurrenceModel::length() const
 {
     return mLength;
 }
 
 Filter *IncidenceOccurrenceModel::filter() const
 {
     return mFilter;
 }
 
 void IncidenceOccurrenceModel::setFilter(Filter *filter)
 {
     mFilter = filter;
     Q_EMIT filterChanged();
 
     scheduleReset();
 }
 
 bool IncidenceOccurrenceModel::loading() const
 {
     return m_loading;
 }
 
 void IncidenceOccurrenceModel::setLoading(const bool loading)
 {
     if(loading == m_loading) {
         return;
     }
 
     m_loading = loading;
     Q_EMIT loadingChanged();
 }
 
 int IncidenceOccurrenceModel::resetThrottleInterval() const
 {
     return m_resetThrottleInterval;
 }
 
 void IncidenceOccurrenceModel::setResetThrottleInterval(const int resetThrottleInterval)
 {
     if(resetThrottleInterval == m_resetThrottleInterval) {
         return;
     }
 
     m_resetThrottleInterval = resetThrottleInterval;
     Q_EMIT resetThrottleIntervalChanged();
 }
 
 void IncidenceOccurrenceModel::scheduleReset()
 {
     if (!m_resetThrottlingTimer.isActive()) {
         // Instant update, but then only refresh every interval at most.
         m_resetThrottlingTimer.start(m_resetThrottleInterval);
     }
 }
 
 void IncidenceOccurrenceModel::resetFromSource()
 {
     if (!m_coreCalendar) {
         qWarning() << "Not resetting IOC from source as no core calendar set.";
         return;
     }
 
     setLoading(true);
 
     if (m_resetThrottlingTimer.isActive() || m_coreCalendar->isLoading()) {
         // If calendar is still loading then just schedule a refresh later
         // If refresh timer already active this won't restart it
         scheduleReset();
         return;
     }
 
     loadColors();
 
     beginResetModel();
 
     m_incidences.clear();
     m_occurrenceIndexHash.clear();
 
     KCalendarCore::OccurrenceIterator occurrenceIterator(*m_coreCalendar, QDateTime(mStart, {0, 0, 0}), QDateTime(mEnd, {12, 59, 59}));
 
     while (occurrenceIterator.hasNext()) {
         occurrenceIterator.next();
         const auto incidence = occurrenceIterator.incidence();
 
         if(!incidencePassesFilter(incidence)) {
             continue;
         }
 
         const auto occurrenceStartEnd = incidenceOccurrenceStartEnd(occurrenceIterator.occurrenceStartDate(), incidence);
         const auto start = occurrenceStartEnd.first;
         const auto end = occurrenceStartEnd.second;
         const auto occurrenceHashKey = incidenceOccurrenceHash(start, end, incidence->uid());
         const Occurrence occurrence{
             start,
             end,
             incidence,
             getColor(incidence),
             getCollectionId(incidence),
             incidence->allDay(),
         };
 
         const auto indexRow = m_incidences.count();
         m_incidences.append(occurrence);
 
         const auto occurrenceIndex = index(indexRow);
         const QPersistentModelIndex persistentIndex(occurrenceIndex);
 
         m_occurrenceIndexHash.insert(occurrenceHashKey, persistentIndex);
     }
 
     endResetModel();
 
     setLoading(false);
 }
 
 void IncidenceOccurrenceModel::slotSourceDataChanged(const QModelIndex &upperLeft, const QModelIndex &bottomRight)
 {
     if (!m_coreCalendar || !upperLeft.isValid() || !bottomRight.isValid() || m_resetThrottlingTimer.isActive()) {
         return;
     }
 
     setLoading(true);
 
     const auto startRow = upperLeft.row();
     const auto endRow = bottomRight.row();
 
     for (int i = startRow; i <= endRow; ++i) {
         const auto sourceModelIndex = m_coreCalendar->model()->index(i, 0, upperLeft.parent());
         const auto incidenceItem = sourceModelIndex.data(Akonadi::EntityTreeModel::ItemRole).value<Akonadi::Item>();
 
         if(!incidenceItem.isValid() || !incidenceItem.hasPayload<KCalendarCore::Incidence::Ptr>()) {
             continue;
         }
 
         const auto incidence = incidenceItem.payload<KCalendarCore::Incidence::Ptr>();
         KCalendarCore::OccurrenceIterator occurrenceIterator{*m_coreCalendar, incidence, QDateTime{mStart, {0, 0, 0}}, QDateTime{mEnd, {12, 59, 59}}};
 
         while (occurrenceIterator.hasNext()) {
             occurrenceIterator.next();
 
             const auto occurrenceStartEnd = incidenceOccurrenceStartEnd(occurrenceIterator.occurrenceStartDate(), incidence);
             const auto start = occurrenceStartEnd.first;
             const auto end = occurrenceStartEnd.second;
             const auto occurrenceHashKey = incidenceOccurrenceHash(start, end, incidence->uid());
 
             if(!m_occurrenceIndexHash.contains(occurrenceHashKey)) {
                 continue;
             }
 
             const Occurrence occurrence{
                 start,
                 end,
                 incidence,
                 getColor(incidence),
                 getCollectionId(incidence),
                 incidence->allDay(),
             };
 
             const auto existingOccurrenceIndex = m_occurrenceIndexHash.value(occurrenceHashKey);
             const auto existingOccurrenceRow = existingOccurrenceIndex.row();
 
             m_incidences.replace(existingOccurrenceRow, occurrence);
             Q_EMIT dataChanged(existingOccurrenceIndex, existingOccurrenceIndex);
         }
     }
 
     setLoading(false);
 }
 
 void IncidenceOccurrenceModel::slotSourceRowsInserted(const QModelIndex &parent, const int first, const int last)
 {
     if (!m_coreCalendar || m_resetThrottlingTimer.isActive()) {
         return;
     } else if (m_coreCalendar->isLoading()) {
         m_resetThrottlingTimer.start(m_resetThrottleInterval);
         return;
     }
 
     setLoading(true);
 
     for (int i = first; i <= last; ++i) {
         const auto sourceModelIndex = m_coreCalendar->model()->index(i, 0, parent);
         const auto incidenceItem = sourceModelIndex.data(Akonadi::EntityTreeModel::ItemRole).value<Akonadi::Item>();
 
         if(!incidenceItem.isValid() || !incidenceItem.hasPayload<KCalendarCore::Incidence::Ptr>()) {
             continue;
         }
 
         const auto incidence = incidenceItem.payload<KCalendarCore::Incidence::Ptr>();
 
         if(!incidencePassesFilter(incidence)) {
             continue;
         }
 
         KCalendarCore::OccurrenceIterator occurrenceIterator{*m_coreCalendar, incidence, QDateTime{mStart, {0, 0, 0}}, QDateTime{mEnd, {12, 59, 59}}};
 
         while (occurrenceIterator.hasNext()) {
             occurrenceIterator.next();
 
             const auto occurrenceStartEnd = incidenceOccurrenceStartEnd(occurrenceIterator.occurrenceStartDate(), incidence);
             const auto start = occurrenceStartEnd.first;
             const auto end = occurrenceStartEnd.second;
             const auto occurrenceHashKey = incidenceOccurrenceHash(start, end, incidence->uid());
 
             if(m_occurrenceIndexHash.contains(occurrenceHashKey)) {
                 continue;
             }
 
             const Occurrence occurrence{
                 start,
                 end,
                 incidence,
                 getColor(incidence),
                 getCollectionId(incidence),
                 incidence->allDay(),
             };
 
             const auto indexRow = m_incidences.count();
 
             beginInsertRows({}, indexRow, indexRow);
             m_incidences.append(occurrence);
             endInsertRows();
 
             const auto occurrenceIndex = index(indexRow);
             const QPersistentModelIndex persistentIndex(occurrenceIndex);
 
             m_occurrenceIndexHash.insert(occurrenceHashKey, persistentIndex);
         }
     }
 
     setLoading(false);
 }
 
 int IncidenceOccurrenceModel::rowCount(const QModelIndex &parent) const
 {
     if (!parent.isValid()) {
         return m_incidences.size();
     }
     return 0;
 }
 
 qint64 IncidenceOccurrenceModel::getCollectionId(const KCalendarCore::Incidence::Ptr &incidence)
 {
     auto item = m_coreCalendar->item(incidence);
     if (!item.isValid()) {
         return {};
     }
     auto collection = item.parentCollection();
     if (!collection.isValid()) {
         return {};
     }
     return collection.id();
 }
 
 QColor IncidenceOccurrenceModel::getColor(const KCalendarCore::Incidence::Ptr &incidence)
 {
     auto item = m_coreCalendar->item(incidence);
     if (!item.isValid()) {
         return {};
     }
     auto collection = item.parentCollection();
     if (!collection.isValid()) {
         return {};
     }
     const QString id = QString::number(collection.id());
     // qDebug() << "Collection id: " << collection.id();
 
     if (m_colors.contains(id)) {
         // qDebug() << collection.id() << "Found in m_colors";
         return m_colors[id];
     }
 
     return {};
 }
 
 QVariant IncidenceOccurrenceModel::data(const QModelIndex &idx, int role) const
 {
     if (!hasIndex(idx.row(), idx.column())) {
         return {};
     }
 
     const auto occurrence = m_incidences.at(idx.row());
     const auto incidence = occurrence.incidence;
 
     switch (role) {
     case Summary:
         return incidence->summary();
     case Description:
         return incidence->description();
     case Location:
         return incidence->location();
     case StartTime:
         return occurrence.start;
     case EndTime:
         return occurrence.end;
     case Duration:
     {
         const KCalendarCore::Duration duration(occurrence.start, occurrence.end);
         return QVariant::fromValue(duration);
     }
     case DurationString: {
         const KCalendarCore::Duration duration(occurrence.start, occurrence.end);
 
         if (duration.asSeconds() == 0) {
             return QString();
         }
 
         return m_format.formatSpelloutDuration(duration.asSeconds() * 1000);
     }
     case Recurs:
         return incidence->recurs();
     case HasReminders:
         return incidence->alarms().length() > 0;
     case Priority:
         return incidence->priority();
     case Color:
         return occurrence.color;
     case CollectionId:
         return occurrence.collectionId;
     case AllDay:
         return occurrence.allDay;
     case TodoCompleted: {
         if (incidence->type() != KCalendarCore::IncidenceBase::TypeTodo) {
             return false;
         }
 
         auto todo = incidence.staticCast<KCalendarCore::Todo>();
         return todo->isCompleted();
     }
     case IsOverdue: {
         if (incidence->type() != KCalendarCore::IncidenceBase::TypeTodo) {
             return false;
         }
 
         auto todo = incidence.staticCast<KCalendarCore::Todo>();
         return todo->isOverdue();
     }
     case IsReadOnly: {
         const auto collection = m_coreCalendar->collection(occurrence.collectionId);
         return collection.rights().testFlag(Akonadi::Collection::ReadOnly);
     }
     case IncidenceId:
         return incidence->uid();
     case IncidenceType:
         return incidence->type();
     case IncidenceTypeStr:
         return incidence->type() == KCalendarCore::Incidence::TypeTodo ? i18n("Task") : i18n(incidence->typeStr().constData());
     case IncidenceTypeIcon:
         return incidence->iconName();
     case IncidencePtr:
         return QVariant::fromValue(incidence);
     case IncidenceOccurrence:
         return QVariant::fromValue(occurrence);
     default:
         qWarning(
             
         ) << "Unknown role for occurrence:" << QMetaEnum::fromType<Roles>().valueToKey(role);
         return {};
     }
 }
 
 void IncidenceOccurrenceModel::setCalendar(Akonadi::ETMCalendar::Ptr calendar)
 {
     if (m_coreCalendar == calendar) {
         return;
     }
     m_coreCalendar = calendar;
 
     connect(m_coreCalendar->model(), &QAbstractItemModel::dataChanged, this, &IncidenceOccurrenceModel::slotSourceDataChanged);
     connect(m_coreCalendar->model(), &QAbstractItemModel::rowsInserted, this, &IncidenceOccurrenceModel::slotSourceRowsInserted);
     connect(m_coreCalendar->model(), &QAbstractItemModel::rowsRemoved, this, &IncidenceOccurrenceModel::scheduleReset);
     connect(m_coreCalendar->model(), &QAbstractItemModel::modelReset, this, &IncidenceOccurrenceModel::scheduleReset);
     connect(m_coreCalendar.get(), &Akonadi::ETMCalendar::collectionsRemoved, this, &IncidenceOccurrenceModel::scheduleReset);
 
     Q_EMIT calendarChanged();
 
     scheduleReset();
 }
 
 Akonadi::ETMCalendar::Ptr IncidenceOccurrenceModel::calendar() const
 {
     return m_coreCalendar;
 }
 
 void IncidenceOccurrenceModel::loadColors()
 {
     KSharedConfig::Ptr config = KSharedConfig::openConfig();
     KConfigGroup rColorsConfig(config, QStringLiteral("Resources Colors"));
     const QStringList colorKeyList = rColorsConfig.keyList();
 
     for (const QString &key : colorKeyList) {
         QColor color = rColorsConfig.readEntry(key, QColor("blue"));
         m_colors[key] = color;
     }
 }
 
 std::pair<QDateTime, QDateTime> IncidenceOccurrenceModel::incidenceOccurrenceStartEnd(const QDateTime &ocStart, const KCalendarCore::Incidence::Ptr &incidence)
 {
     auto start = ocStart;
     const auto end = incidence->endDateForStart(start);
 
     if (incidence->type() == KCalendarCore::Incidence::IncidenceType::TypeTodo) {
         KCalendarCore::Todo::Ptr todo = incidence.staticCast<KCalendarCore::Todo>();
 
         if (!start.isValid()) { // Todos are very likely not to have a set start date
             start = todo->dtDue();
         }
     }
 
     return {start, end};
 }
 
 uint IncidenceOccurrenceModel::incidenceOccurrenceHash(const QDateTime &ocStart, const QDateTime &ocEnd, const QString &incidenceUid)
 {
     return qHash(QString::number(ocStart.toSecsSinceEpoch()) +
                  QString::number(ocEnd.toSecsSinceEpoch()) +
                  incidenceUid);
 }
 
 bool IncidenceOccurrenceModel::incidencePassesFilter(const KCalendarCore::Incidence::Ptr &incidence)
 {
     if(!mFilter || mFilter->tags().empty()) {
         return true;
     }
 
     auto match = false;
     const auto tags = mFilter->tags();
     for (const auto &tag : tags) {
         if (incidence->categories().contains(tag)) {
             match = true;
             break;
         }
     }
 
     return match;
 }
 
 QHash<int, QByteArray> IncidenceOccurrenceModel::roleNames() const
 {
     return {
         {IncidenceOccurrenceModel::Summary, "summary"},
         {IncidenceOccurrenceModel::StartTime, "startTime"},
     };
 }