File indexing completed on 2024-05-12 04:58:06

 /* ============================================================
 * Falkon - Qt web browser
 * Copyright (C) 2010-2017 David Rosca <nowrep@gmail.com>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 * ============================================================ */
 #include "historymodel.h"
 #include "historyitem.h"
 #include "iconprovider.h"
 #include "sqldatabase.h"
 
 #include <QApplication>
 #include <QDateTime>
 #include <QTimeZone>
 #include <QTimer>
 
 static QString dateTimeToString(const QDateTime &dateTime)
 {
     const QDateTime current = QDateTime::currentDateTime();
     if (current.date() == dateTime.date()) {
         return dateTime.time().toString(QSL("h:mm"));
     }
 
     return dateTime.toString(QSL("d.M.yyyy h:mm"));
 }
 
 HistoryModel::HistoryModel(History* history)
     : QAbstractItemModel(history)
     , m_rootItem(new HistoryItem(nullptr))
     , m_todayItem(nullptr)
     , m_history(history)
 {
     init();
 
     connect(m_history, &History::resetHistory, this, &HistoryModel::resetHistory);
     connect(m_history, &History::historyEntryAdded, this, &HistoryModel::historyEntryAdded);
     connect(m_history, &History::historyEntryDeleted, this, &HistoryModel::historyEntryDeleted);
     connect(m_history, &History::historyEntryEdited, this, &HistoryModel::historyEntryEdited);
 }
 
 QVariant HistoryModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
     if (orientation == Qt::Horizontal && role == Qt::DisplayRole) {
         switch (section) {
         case 0:
             return tr("Title");
         case 1:
             return tr("Address");
         case 2:
             return tr("Visit Date");
         case 3:
             return tr("Visit Count");
         }
     }
 
     return QAbstractItemModel::headerData(section, orientation, role);
 }
 
 QVariant HistoryModel::data(const QModelIndex &index, int role) const
 {
     HistoryItem* item = itemFromIndex(index);
 
     if (index.row() < 0 || !item) {
         return {};
     }
 
     if (item->isTopLevel()) {
         switch (role) {
         case IsTopLevelRole:
             return true;
         case TimestampStartRole:
             return item->startTimestamp();
         case TimestampEndRole:
             return item->endTimestamp();
         case Qt::DisplayRole:
         case Qt::EditRole:
             return index.column() == 0 ? item->title : QVariant();
         case Qt::DecorationRole:
             return index.column() == 0 ? QIcon::fromTheme(QSL("view-calendar"), QIcon(QSL(":/icons/menu/history_entry.svg"))) : QVariant();
         }
 
         return {};
     }
 
     const HistoryEntry entry = item->historyEntry;
 
     switch (role) {
     case IdRole:
         return entry.id;
     case TitleRole:
         return entry.title;
     case UrlRole:
         return entry.url;
     case UrlStringRole:
         return entry.urlString;
     case IconRole:
         return item->icon();
     case IsTopLevelRole:
         return false;
     case TimestampStartRole:
         return -1;
     case TimestampEndRole:
         return -1;
     case Qt::ToolTipRole:
         if (index.column() == 0) {
             return QSL("%1\n%2").arg(entry.title, entry.urlString);
         }
         // fallthrough
     case Qt::DisplayRole:
     case Qt::EditRole:
         switch (index.column()) {
         case 0:
             return entry.title;
         case 1:
             return entry.urlString;
         case 2:
             return dateTimeToString(entry.date);
         case 3:
             return entry.count;
         }
         break;
     case Qt::DecorationRole:
         if (index.column() == 0) {
             return item->icon().isNull() ? IconProvider::emptyWebIcon() : item->icon();
         }
     }
 
     return {};
 }
 
 bool HistoryModel::setData(const QModelIndex &index, const QVariant &value, int role)
 {
     HistoryItem* item = itemFromIndex(index);
 
     if (index.row() < 0 || !item || item->isTopLevel()) {
         return false;
     }
 
     if (role == IconRole) {
         item->setIcon(value.value<QIcon>());
         Q_EMIT dataChanged(index, index);
         return true;
     }
 
     return false;
 }
 
 QModelIndex HistoryModel::index(int row, int column, const QModelIndex &parent) const
 {
     if (!hasIndex(row, column, parent)) {
         return {};
     }
 
     HistoryItem* parentItem = itemFromIndex(parent);
     HistoryItem* childItem = parentItem->child(row);
 
     return childItem ? createIndex(row, column, childItem) : QModelIndex();
 }
 
 QModelIndex HistoryModel::parent(const QModelIndex &index) const
 {
     if (!index.isValid()) {
         return {};
     }
 
     HistoryItem* childItem = itemFromIndex(index);
     HistoryItem* parentItem = childItem->parent();
 
     if (!parentItem || parentItem == m_rootItem) {
         return {};
     }
 
     return createIndex(parentItem->row(), 0, parentItem);
 }
 
 Qt::ItemFlags HistoryModel::flags(const QModelIndex &index) const
 {
     if (!index.isValid()) {
         return Qt::NoItemFlags;
     }
 
     return Qt::ItemIsEnabled | Qt::ItemIsSelectable;
 }
 
 int HistoryModel::rowCount(const QModelIndex &parent) const
 {
     if (parent.column() > 0) {
         return 0;
     }
 
     HistoryItem* parentItem = itemFromIndex(parent);
 
     return parentItem->childCount();
 }
 
 int HistoryModel::columnCount(const QModelIndex &parent) const
 {
     Q_UNUSED(parent)
 
     return 4;
 }
 
 bool HistoryModel::hasChildren(const QModelIndex &parent) const
 {
     if (!parent.isValid()) {
         return true;
     }
 
     HistoryItem* item = itemFromIndex(parent);
 
     return item ? item->isTopLevel() : false;
 }
 
 HistoryItem* HistoryModel::itemFromIndex(const QModelIndex &index) const
 {
     if (index.isValid()) {
         auto* item = static_cast<HistoryItem*>(index.internalPointer());
 
         if (item) {
             return item;
         }
     }
 
     return m_rootItem;
 }
 
 void HistoryModel::removeTopLevelIndexes(const QList<QPersistentModelIndex> &indexes)
 {
     for (const QPersistentModelIndex &index : indexes) {
         if (index.parent().isValid()) {
             continue;
         }
 
         int row = index.row();
         HistoryItem* item = m_rootItem->child(row);
 
         if (!item) {
             return;
         }
 
         beginRemoveRows(QModelIndex(), row, row);
         delete item;
         endRemoveRows();
 
         if (item == m_todayItem) {
             m_todayItem = nullptr;
         }
     }
 }
 
 void HistoryModel::resetHistory()
 {
     beginResetModel();
 
     delete m_rootItem;
     m_todayItem = nullptr;
     m_rootItem = new HistoryItem(nullptr);
 
     init();
 
     endResetModel();
 }
 
 bool HistoryModel::canFetchMore(const QModelIndex &parent) const
 {
     HistoryItem* parentItem = itemFromIndex(parent);
 
     return parentItem ? parentItem->canFetchMore : false;
 }
 
 void HistoryModel::fetchMore(const QModelIndex &parent)
 {
     HistoryItem* parentItem = itemFromIndex(parent);
 
     if (!parent.isValid() || !parentItem) {
         return;
     }
 
     parentItem->canFetchMore = false;
 
     QList<int> idList;
     for (int i = 0; i < parentItem->childCount(); ++i) {
         idList.append(parentItem->child(i)->historyEntry.id);
     }
 
     QSqlQuery query(SqlDatabase::instance()->database());
     query.prepare(QSL("SELECT id, count, title, url, date FROM history WHERE date BETWEEN ? AND ? ORDER BY date DESC"));
     query.addBindValue(parentItem->endTimestamp());
     query.addBindValue(parentItem->startTimestamp());
     query.exec();
 
     QVector<HistoryEntry> list;
 
     while (query.next()) {
         HistoryEntry entry;
         entry.id = query.value(0).toInt();
         entry.count = query.value(1).toInt();
         entry.title = query.value(2).toString();
         entry.url = query.value(3).toUrl();
         entry.date = QDateTime::fromMSecsSinceEpoch(query.value(4).toLongLong());
         entry.urlString = QString::fromUtf8(entry.url.toEncoded());
 
         if (!idList.contains(entry.id)) {
             list.append(entry);
         }
     }
 
     if (list.isEmpty()) {
         return;
     }
 
     beginInsertRows(parent, 0, list.size() - 1);
 
     for (const HistoryEntry &entry : std::as_const(list)) {
         auto* newItem = new HistoryItem(parentItem);
         newItem->historyEntry = entry;
     }
 
     endInsertRows();
 }
 
 void HistoryModel::historyEntryAdded(const HistoryEntry &entry)
 {
     if (!m_todayItem) {
         beginInsertRows(QModelIndex(), 0, 0);
 
         m_todayItem = new HistoryItem(nullptr);
         m_todayItem->setStartTimestamp(-1);
         m_todayItem->setEndTimestamp(QDateTime(QDate::currentDate(), QTime(), QTimeZone::systemTimeZone()).toMSecsSinceEpoch());
         m_todayItem->title = tr("Today");
 
         m_rootItem->prependChild(m_todayItem);
 
         endInsertRows();
     }
 
     beginInsertRows(createIndex(0, 0, m_todayItem), 0, 0);
 
     auto* item = new HistoryItem();
     item->historyEntry = entry;
 
     m_todayItem->prependChild(item);
 
     endInsertRows();
 }
 
 void HistoryModel::historyEntryDeleted(const HistoryEntry &entry)
 {
     HistoryItem* item = findHistoryItem(entry);
     if (!item) {
         return;
     }
 
     HistoryItem* parentItem = item->parent();
     int row = item->row();
 
     beginRemoveRows(createIndex(parentItem->row(), 0, parentItem), row, row);
     delete item;
     endRemoveRows();
 
     checkEmptyParentItem(parentItem);
 }
 
 void HistoryModel::historyEntryEdited(const HistoryEntry &before, const HistoryEntry &after)
 {
 #if 0
     HistoryItem* item = findHistoryItem(before);
 
     if (item) {
         HistoryItem* parentItem = item->parent();
         const QModelIndex sourceParent = createIndex(parentItem->row(), 0, parentItem);
         const QModelIndex destinationParent = createIndex(m_todayItem->row(), 0, m_todayItem);
         int row = item->row();
 
         beginMoveRows(sourceParent, row, row, destinationParent, 0);
         item->historyEntry = after;
         item->refreshIcon();
         item->changeParent(m_todayItem);
         endMoveRows(); // This line sometimes throw "std::bad_alloc" ... I don't know why ?!
 
         checkEmptyParentItem(parentItem);
     }
     else {
         historyEntryAdded(after);
     }
 #endif
     historyEntryDeleted(before);
     historyEntryAdded(after);
 }
 
 HistoryItem* HistoryModel::findHistoryItem(const HistoryEntry &entry)
 {
     HistoryItem* parentItem = nullptr;
     qint64 timestamp = entry.date.toMSecsSinceEpoch();
 
     for (int i = 0; i < m_rootItem->childCount(); ++i) {
         HistoryItem* item = m_rootItem->child(i);
 
         if (item->endTimestamp() < timestamp) {
             parentItem = item;
             break;
         }
     }
 
     if (!parentItem) {
         return nullptr;
     }
 
     for (int i = 0; i < parentItem->childCount(); ++i) {
         HistoryItem* item = parentItem->child(i);
         if (item->historyEntry.id == entry.id) {
             return item;
         }
     }
 
     return nullptr;
 }
 
 void HistoryModel::checkEmptyParentItem(HistoryItem* item)
 {
     if (item->childCount() == 0 && item->isTopLevel()) {
         int row = item->row();
 
         beginRemoveRows(QModelIndex(), row, row);
         delete item;
         endRemoveRows();
 
         if (item == m_todayItem) {
             m_todayItem = nullptr;
         }
     }
 }
 
 void HistoryModel::init()
 {
     QSqlQuery query(SqlDatabase::instance()->database());
     query.exec(QSL("SELECT MIN(date) FROM history"));
     if (!query.next()) {
         return;
     }
 
     const qint64 minTimestamp = query.value(0).toLongLong();
     if (minTimestamp <= 0) {
         return;
     }
 
     const QDate today = QDate::currentDate();
     const QDate week = today.addDays(1 - today.dayOfWeek());
     const QDate month = QDate(today.year(), today.month(), 1);
     const qint64 currentTimestamp = QDateTime::currentMSecsSinceEpoch();
 
     qint64 timestamp = currentTimestamp;
     while (timestamp > minTimestamp) {
         QDate timestampDate = QDateTime::fromMSecsSinceEpoch(timestamp).date();
         qint64 endTimestamp;
         QString itemName;
 
         if (timestampDate == today) {
             endTimestamp = QDateTime(today, QTime(), QTimeZone::systemTimeZone()).toMSecsSinceEpoch();
 
             itemName = tr("Today");
         }
         else if (timestampDate >= week) {
             endTimestamp = QDateTime(week, QTime(), QTimeZone::systemTimeZone()).toMSecsSinceEpoch();
 
             itemName = tr("This Week");
         }
         else if (timestampDate.month() == month.month() && timestampDate.year() == month.year()) {
             endTimestamp = QDateTime(month, QTime(), QTimeZone::systemTimeZone()).toMSecsSinceEpoch();
 
             itemName = tr("This Month");
         }
         else {
             QDate startDate(timestampDate.year(), timestampDate.month(), timestampDate.daysInMonth());
             QDate endDate(startDate.year(), startDate.month(), 1);
 
             timestamp = QDateTime(startDate, QTime(23, 59, 59), QTimeZone::systemTimeZone()).toMSecsSinceEpoch();
             endTimestamp = QDateTime(endDate, QTime(), QTimeZone::systemTimeZone()).toMSecsSinceEpoch();
             itemName = QSL("%1 %2").arg(History::titleCaseLocalizedMonth(timestampDate.month()), QString::number(timestampDate.year()));
         }
 
         QSqlQuery query(SqlDatabase::instance()->database());
         query.prepare(QSL("SELECT id FROM history WHERE date BETWEEN ? AND ? LIMIT 1"));
         query.addBindValue(endTimestamp);
         query.addBindValue(timestamp);
         query.exec();
 
         if (query.next()) {
             auto* item = new HistoryItem(m_rootItem);
             item->setStartTimestamp(timestamp == currentTimestamp ? -1 : timestamp);
             item->setEndTimestamp(endTimestamp);
             item->title = itemName;
             item->canFetchMore = true;
 
             if (timestamp == currentTimestamp) {
                 m_todayItem = item;
             }
         }
 
         timestamp = endTimestamp - 1;
     }
 }
 
 // HistoryFilterModel
 HistoryFilterModel::HistoryFilterModel(QAbstractItemModel* parent)
     : QSortFilterProxyModel(parent)
 {
     setSourceModel(parent);
     setFilterCaseSensitivity(Qt::CaseInsensitive);
 
     m_filterTimer = new QTimer(this);
     m_filterTimer->setSingleShot(true);
     m_filterTimer->setInterval(300);
 
     connect(m_filterTimer, &QTimer::timeout, this, &HistoryFilterModel::startFiltering);
 }
 
 void HistoryFilterModel::setFilterFixedString(const QString &pattern)
 {
     m_pattern = pattern;
 
     m_filterTimer->start();
 }
 
 void HistoryFilterModel::startFiltering()
 {
     if (m_pattern.isEmpty()) {
         Q_EMIT collapseAllItems();
         QSortFilterProxyModel::setFilterFixedString(m_pattern);
         return;
     }
 
     QApplication::setOverrideCursor(Qt::WaitCursor);
 
     // Expand all items also calls fetchmore
     Q_EMIT expandAllItems();
 
     QSortFilterProxyModel::setFilterFixedString(m_pattern);
 
     QApplication::restoreOverrideCursor();
 }
 
 bool HistoryFilterModel::filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const
 {
     const QModelIndex index = sourceModel()->index(sourceRow, 0, sourceParent);
 
     if (index.data(HistoryModel::IsTopLevelRole).toBool()) {
         return true;
     }
 
     return (index.data(HistoryModel::UrlStringRole).toString().contains(m_pattern, Qt::CaseInsensitive) ||
             index.data(HistoryModel::TitleRole).toString().contains(m_pattern, Qt::CaseInsensitive));
 }
 
 bool HistoryFilterModel::isPatternEmpty() const
 {
     return m_pattern.isEmpty();
 }