Differential D21721 Diff 66944 src/core/commentsmodel.cpp

Changeset View

Standalone View

View Options

src/core/commentsmodel.cpp

  • This file was added.
1​/*
2​ * Copyright (C) 2019 Dan Leinir Turthra Jensen <admin@leinir.dk>
3​ *
4​ * This library is free software; you can redistribute it and/or
5​ * modify it under the terms of the GNU Lesser General Public
6​ * License as published by the Free Software Foundation; either
7​ * version 2.1 of the License, or (at your option) version 3, or any
8​ * later version accepted by the membership of KDE e.V. (or its
9​ * successor approved by the membership of KDE e.V.), which shall
10​ * act as a proxy defined in Section 6 of version 3 of the license.
11​ *
12​ * This library is distributed in the hope that it will be useful,
13​ * but WITHOUT ANY WARRANTY; without even the implied warranty of
14​ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15​ * Lesser General Public License for more details.
16​ *
17​ * You should have received a copy of the GNU Lesser General Public
18​ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
19​ *
20​ */
21​
22​#include "commentsmodel.h"
23​
24​#include "entryinternal.h"
25​#include "engine.h"
26​#include "knewstuffcore_debug.h"
27​
28​#include <KLocalizedString>
29​
30​#include <QDateTime>
31​#include <QTimer>
32​
33​namespace KNSCore {
34​class CommentsModel::Private {
35​public:
36​ Private(CommentsModel *qq)
37​ : q(qq)
38​ {}
39​ CommentsModel *q = nullptr;
40​ Engine *engine = nullptr;
41​
42​ EntryInternal entry;
43​
44​ QList<std::shared_ptr<KNSCore::Comment>> comments;
45​
46​ enum FetchOptions {
47​ NoOption,
48​ ClearModel
49​ };
50​ bool fetchThrottle = false;
51​ void fetch(FetchOptions option = NoOption) {
52​ if (fetchThrottle) {
53​ return;
54​ }
55​ fetchThrottle = true;
56​ QTimer::singleShot(1, q, [this](){
57​ fetchThrottle = false;
58​ });
59​ // Sanity checks, because we need a few things to be correct before we can actually fetch comments...
60​ if (!engine) {
61​ qCWarning(KNEWSTUFFCORE) << "CommentsModel must be parented on a KNSCore::Engine instance to be able to fetch comments";
62​ }
63​ if (!entry.isValid()) {
64​ qCWarning(KNEWSTUFFCORE) << "Without an entry to fetch comments for, CommentsModel cannot fetch comments for it";
65​ }
66​
67​ if (engine && entry.isValid()) {
68​ QSharedPointer<Provider> provider = engine->provider(entry.providerId());
69​ if (option == ClearModel) {
70​ emit q->beginResetModel();
71​ comments.clear();
72​ provider->disconnect(q);
73​ q->connect(provider.data(), &Provider::commentsLoaded, q, [=](const QList<std::shared_ptr<KNSCore::Comment>> &newComments){
74​ QList<std::shared_ptr<KNSCore::Comment>> actualNewComments;
75​ for (std::shared_ptr<KNSCore::Comment> comment : newComments) {
76​ bool commentIsKnown = false;
77​ for (std::shared_ptr<KNSCore::Comment> existingComment : comments) {
78​ if (existingComment->id == comment->id) {
79​ commentIsKnown = true;
80​ break;
81​ }
82​ }
83​ if (commentIsKnown) {
84​ continue;
85​ }
86​ actualNewComments << comment;
87​ }
88​ if (actualNewComments.count() > 0) {
89​ q->beginInsertRows(QModelIndex(), comments.count(), comments.count() + actualNewComments.count() - 1);
90​ qCDebug(KNEWSTUFFCORE) << "Appending" << actualNewComments.count() << "new comments";
91​ comments.append(actualNewComments);
92​ q->endInsertRows();
93​ }
94​ });
95​ emit q->endResetModel();
96​ }
97​ int commentsPerPage = 100;
98​ int pageToLoad = comments.count() / commentsPerPage;
99​ qCDebug(KNEWSTUFFCORE) << "Loading comments, page" << pageToLoad << "with current comment count" << comments.count() << "out of a total of" << entry.numberOfComments();
100​ provider->loadComments(entry, commentsPerPage, pageToLoad);
ahiemstraUnsubmitted
Done

Categorise or drop :)

ahiemstra: Categorise or drop :)
101​ }
102​ }
103​};
104​}
105​
106​KNSCore::CommentsModel::CommentsModel(Engine *parent)
107​ : QAbstractListModel(parent)
108​ , d(new Private(this))
109​{
110​ d->engine = parent;
111​}
112​
113​KNSCore::CommentsModel::~CommentsModel()
114​{
115​ delete d;
116​}
117​
118​QHash<int, QByteArray> KNSCore::CommentsModel::roleNames() const
119​{
120​ static const QHash<int, QByteArray> roles{
121​ {IdRole, "id"},
122​ {SubjectRole, "subject"},
123​ {TextRole, "text"},
124​ {ChildCountRole, "childCound"},
125​ {UsernameRole, "username"},
126​ {DateRole, "date"},
127​ {ScoreRole, "score"},
128​ {ParentIndexRole, "parentIndex"},
129​ {DepthRole, "depth"}
130​ };
131​ return roles;
132​}
133​
134​QVariant KNSCore::CommentsModel::data(const QModelIndex &index, int role) const
135​{
136​ QVariant value;
ahiemstraUnsubmitted
Done

Might want to add a call to checkIndex here (https://doc.qt.io/qt-5/qabstractitemmodel.html#checkIndex), it would obsolete some additional checking you do later.

ahiemstra: Might want to add a call to checkIndex here (https://doc.qt.io/qt-5/qabstractitemmodel.
leinirAuthorUnsubmitted
Done

After confirming that 5.11 (which introduces that function) is indeed acceptable for Frameworks, i'm aaaall over that ;) Very handy little function, that :)

leinir: After confirming that 5.11 (which introduces that function) is indeed acceptable for Frameworks…
137​ if (checkIndex(index)) {
138​ std::shared_ptr<KNSCore::Comment> comment = d->comments[index.row()];
139​ switch (role)
140​ {
141​ case IdRole:
142​ value.setValue(comment->id);
143​ break;
144​ case SubjectRole:
145​ value.setValue(comment->subject);
146​ break;
147​ case TextRole:
148​ value.setValue(comment->text);
149​ break;
150​ case ChildCountRole:
151​ value.setValue(comment->childCount);
152​ break;
153​ case UsernameRole:
154​ value.setValue(comment->username);
155​ break;
156​ case DateRole:
157​ value.setValue(comment->date);
158​ break;
159​ case ScoreRole:
160​ value.setValue(comment->score);
161​ break;
162​ case ParentIndexRole:
163​ {
164​ int idx{-1};
165​ if (comment->parent) {
166​ d->comments.indexOf(std::shared_ptr<KNSCore::Comment>(comment->parent));
167​ }
168​ value.setValue(idx);
169​ }
170​ break;
171​ case DepthRole:
172​ {
173​ int depth{0};
174​ if (comment->parent) {
175​ std::shared_ptr<KNSCore::Comment> child = comment->parent;
176​ while (child) {
177​ ++depth;
178​ child = child->parent;
ahiemstraUnsubmitted
Done

Since you're already checking for child being true (aka not-null), this if becomes rather superfluous.

ahiemstra: Since you're already checking for `child` being true (aka not-null), this if becomes rather…
leinirAuthorUnsubmitted
Done

Hmm... leftovers from earlier versions of that function, there :)

leinir: Hmm... leftovers from earlier versions of that function, there :)
179​ }
180​ }
181​ value.setValue(depth);
182​ }
183​ break;
184​ default:
185​ value.setValue(i18nc("The value returned for an unknown role when requesting data from the model.", "Unknown CommentsModel role"));
broulikUnsubmitted
Done

Any particular reason not do just return a null QVariant()?

broulik: Any particular reason not do just return a null `QVariant()`?
leinirAuthorUnsubmitted
Done

Hmm... This actually is supposed to be "Unknown model role"... It's kind of corner-casey, but i've noticed in the past that something other than just an invalid QVariant is occasionally useful for those times where you've, say, missed the h in "depth" ;) Usually this wouldn't be hit, of course, so it's not actually expensive in any real way. But yes, compared to this, QVariant() would be the better option.

leinir: Hmm... This actually is supposed to be "Unknown model role"... It's kind of corner-casey, but…
186​ break;
187​ }
188​ }
189​ return value;
190​}
191​
192​int KNSCore::CommentsModel::rowCount(const QModelIndex &parent) const
193​{
194​ if (parent.isValid())
195​ return 0;
196​ return d->comments.count();
197​}
198​
199​bool KNSCore::CommentsModel::canFetchMore(const QModelIndex &parent) const
200​{
201​ if (parent.isValid())
202​ return false;
203​ if (d->entry.numberOfComments() > d->comments.count())
204​ return true;
205​ return false;
206​}
207​
208​void KNSCore::CommentsModel::fetchMore(const QModelIndex &parent)
209​{
210​ if(parent.isValid())
211​ return;
212​ d->fetch();
213​}
214​
215​const KNSCore::EntryInternal &KNSCore::CommentsModel::entry() const
216​{
217​ return d->entry;
218​}
219​
220​void KNSCore::CommentsModel::setEntry(const KNSCore::EntryInternal &newEntry)
221​{
222​ d->entry = newEntry;
223​ d->fetch(Private::ClearModel);
224​ emit entryChanged();
225​}