File indexing completed on 2024-12-15 03:45:03

 /*
     SPDX-FileCopyrightText: 2017 Volker Krause <vkrause@kde.org>
 
     SPDX-License-Identifier: MIT
 */
 
 #include "auditloguicontroller.h"
 
 #include <provider.h>
 
 #include <QAbstractListModel>
 #include <QDateTime>
 #include <QDebug>
 #include <QDir>
 #include <QJsonArray>
 #include <QJsonDocument>
 #include <QJsonObject>
 #include <QLocale>
 #include <QMetaEnum>
 #include <QStandardPaths>
 
 #include <algorithm>
 #include <vector>
 
 using namespace KUserFeedback;
 
 namespace KUserFeedback {
 class AuditLogEntryModel : public QAbstractListModel
 {
     Q_OBJECT
 public:
     explicit AuditLogEntryModel(const QString &path, QObject *parent);
 
     void reload();
 
     int rowCount(const QModelIndex &parent = QModelIndex()) const override;
     QVariant data(const QModelIndex &index, int role) const override;
 
     QHash<int, QByteArray> roleNames() const override;
 
 private:
     QString m_path;
     std::vector<QDateTime> m_entries;
 };
 
 
 class AuditLogUiControllerPrivate
 {
 public:
     QString path;
     AuditLogEntryModel *logEntryModel;
 };
 }
 
 
 AuditLogEntryModel::AuditLogEntryModel(const QString &path, QObject *parent)
     : QAbstractListModel(parent)
     , m_path(path)
 {
     reload();
 }
 
 void AuditLogEntryModel::reload()
 {
     beginResetModel();
     m_entries.clear();
 
     foreach (auto e, QDir(m_path).entryList(QDir::Files | QDir::Readable)) {
         if (!e.endsWith(QLatin1String(".log")))
             continue;
         e.chop(4);
         const auto dt = QDateTime::fromString(e, QStringLiteral("yyyyMMdd-hhmmss"));
         if (dt.isValid())
             m_entries.push_back(dt);
     }
     std::sort(m_entries.begin(), m_entries.end(), [](const QDateTime &lhs, const QDateTime &rhs) {
         return lhs > rhs;
     });
     endResetModel();
 }
 
 int AuditLogEntryModel::rowCount(const QModelIndex &parent) const
 {
     if (parent.isValid())
         return 0;
     return m_entries.size();
 }
 
 QVariant AuditLogEntryModel::data(const QModelIndex &index, int role) const
 {
     switch (role) {
         case Qt::DisplayRole:
             return QLocale().toString(m_entries[index.row()]);
         case Qt::UserRole:
             return m_entries[index.row()];
     }
     return QVariant();
 }
 
 QHash<int, QByteArray> AuditLogEntryModel::roleNames() const
 {
     QHash<int, QByteArray> roles;
     roles.insert(Qt::DisplayRole, "display");
     roles.insert(Qt::UserRole, "data");
     return roles;
 }
 
 
 AuditLogUiController::AuditLogUiController(QObject* parent)
     : QObject(parent)
     , d(new AuditLogUiControllerPrivate)
 {
     d->path = QStandardPaths::writableLocation(QStandardPaths::AppLocalDataLocation) + QStringLiteral("/kuserfeedback/audit/");
     d->logEntryModel = new AuditLogEntryModel(d->path, this);
 
     connect(d->logEntryModel, &QAbstractItemModel::modelReset, this, &AuditLogUiController::logEntryCountChanged);
 }
 
 AuditLogUiController::~AuditLogUiController()
 {
 }
 
 bool AuditLogUiController::hasLogEntries() const
 {
     return d->logEntryModel->rowCount() != 0;
 }
 
 QAbstractItemModel* AuditLogUiController::logEntryModel() const
 {
     return d->logEntryModel;
 }
 
 static QString telemetryModeString(Provider::TelemetryMode mode)
 {
     switch (mode) {
         case Provider::NoTelemetry:
             Q_ASSERT(false);
             return QString();
         case Provider::BasicSystemInformation:
             return AuditLogUiController::tr("Basic System Information");
         case Provider::BasicUsageStatistics:
             return AuditLogUiController::tr("Basic Usage Statistics");
         case Provider::DetailedSystemInformation:
             return AuditLogUiController::tr("Detailed System Information");
         case Provider::DetailedUsageStatistics:
             return AuditLogUiController::tr("Detailed Usage Statistics");
     }
     Q_UNREACHABLE();
 }
 
 QString AuditLogUiController::logEntry(const QDateTime &dt) const
 {
     const QString fn = d->path + dt.toString(QStringLiteral("yyyyMMdd-hhmmss")) + QStringLiteral(".log");
     QFile file(fn);
     if (!file.open(QFile::ReadOnly))
         return tr("Unable to open file %1: %2.").arg(fn, file.errorString());
 
     const auto doc = QJsonDocument::fromJson(file.readAll());
     const auto topObj = doc.object();
     struct Entry {
         QString key;
         QString desc;
         QString rawData;
         Provider::TelemetryMode mode;
     };
     std::vector<Entry> entries;
     entries.reserve(topObj.size());
 
     const auto idx = Provider::staticMetaObject.indexOfEnumerator("TelemetryMode");
     Q_ASSERT(idx >= 0);
     const auto modeEnum = Provider::staticMetaObject.enumerator(idx);
 
     for (auto it = topObj.begin(); it != topObj.end(); ++it) {
         Entry e;
         e.key = it.key();
         const auto obj = it.value().toObject();
         e.desc = obj.value(QLatin1String("description")).toString();
         const auto data = obj.value(QLatin1String("data"));
         if (data.isObject())
             e.rawData = QString::fromUtf8(QJsonDocument(data.toObject()).toJson());
         else if (data.isArray())
             e.rawData = QString::fromUtf8(QJsonDocument(data.toArray()).toJson());
         e.mode = static_cast<Provider::TelemetryMode>(modeEnum.keyToValue(obj.value(QLatin1String("telemetryMode")).toString().toUtf8().constData()));
         entries.push_back(e);
     }
 
     std::sort(entries.begin(), entries.end(), [](const Entry &lhs, const Entry &rhs) -> bool {
         if (lhs.mode == rhs.mode)
             return lhs.key < rhs.key;
         return lhs.mode < rhs.mode;
     });
 
     QString res;
     for (auto it = entries.begin(); it != entries.end(); ++it) {
         res += QStringLiteral("<b>") + (*it).desc + QStringLiteral("</b><br/>");
         res += tr("Category: <i>%1</i><br/>").arg(telemetryModeString((*it).mode));
         res += tr("Key: <i>%1</i><br/>").arg((*it).key);
         res += tr("Submitted data: <tt>%1</tt><br/><br/>").arg((*it).rawData);
     }
     return res;
 }
 
 void AuditLogUiController::clear()
 {
     QDir dir(d->path);
     foreach (auto e, dir.entryList(QDir::Files | QDir::Readable)) {
         if (!e.endsWith(QLatin1String(".log")))
             continue;
         dir.remove(e);
     }
 
     d->logEntryModel->reload();
 }
 
 #include "auditloguicontroller.moc"
 
 #include "moc_auditloguicontroller.cpp"