File indexing completed on 2024-05-12 16:21:31

 /**
  * SPDX-FileCopyrightText: 2021 Bart De Vries <bart@mogwai.be>
  *
  * SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only OR LicenseRef-KDE-Accepted-GPL
  */
 
 #include "storagemanager.h"
 #include "storagemanagerlogging.h"
 
 #include <KLocalizedString>
 #include <QCryptographicHash>
 #include <QDateTime>
 #include <QDebug>
 #include <QDir>
 #include <QFile>
 #include <QFileInfo>
 #include <QRegularExpression>
 #include <QStandardPaths>
 
 #include "enclosure.h"
 #include "models/errorlogmodel.h"
 #include "settingsmanager.h"
 #include "storagemovejob.h"
 
 StorageManager::StorageManager()
 {
     connect(this, &StorageManager::error, &ErrorLogModel::instance(), &ErrorLogModel::monitorErrorMessages);
 }
 
 QString StorageManager::storagePath() const
 {
     QString path = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);
 
     if (!SettingsManager::self()->storagePath().isEmpty()) {
         path = SettingsManager::self()->storagePath().toLocalFile();
     }
 
     // Create path if it doesn't exist yet
     QFileInfo().absoluteDir().mkpath(path);
 
     qCDebug(kastsStorageManager) << "Current storage path is" << path;
 
     return path;
 }
 
 void StorageManager::setStoragePath(QUrl url)
 {
     qCDebug(kastsStorageManager) << "New storage path url:" << url;
     QUrl oldUrl = SettingsManager::self()->storagePath();
     QString oldPath = storagePath();
     QString newPath = oldPath;
 
     if (url.isEmpty()) {
         qCDebug(kastsStorageManager) << "(Re)set storage path to default location";
         SettingsManager::self()->setStoragePath(url);
         newPath = storagePath(); // retrieve default storage path, since url is empty
     } else if (url.isLocalFile()) {
         SettingsManager::self()->setStoragePath(url);
         newPath = url.toLocalFile();
     } else {
         qCDebug(kastsStorageManager) << "Cannot set storage path; path is not on local filesystem:" << url;
         return;
     }
 
     qCDebug(kastsStorageManager) << "Current storage path in settings:" << SettingsManager::self()->storagePath();
     qCDebug(kastsStorageManager) << "New storage path will be:" << newPath;
 
     if (oldPath != newPath) {
         // make list of dirs to be moved (images/ and enclosures/*/)
         QStringList list = {QStringLiteral("images")};
         for (const QString &subdir : QDir(oldPath + QStringLiteral("/enclosures/")).entryList(QDir::Dirs | QDir::NoDotAndDotDot)) {
             list << QStringLiteral("enclosures/") + subdir;
         }
         list << QStringLiteral("enclosures");
 
         StorageMoveJob *moveJob = new StorageMoveJob(oldPath, newPath, list);
         connect(moveJob, &KJob::processedAmountChanged, this, [this, moveJob]() {
             m_storageMoveProgress = moveJob->processedAmount(KJob::Files);
             Q_EMIT storageMoveProgressChanged(m_storageMoveProgress);
         });
         connect(moveJob, &KJob::totalAmountChanged, this, [this, moveJob]() {
             m_storageMoveTotal = moveJob->totalAmount(KJob::Files);
             Q_EMIT storageMoveTotalChanged(m_storageMoveTotal);
         });
         connect(moveJob, &KJob::result, this, [=]() {
             if (moveJob->error() != 0) {
                 // Go back to previous old path
                 SettingsManager::self()->setStoragePath(oldUrl);
                 QString title =
                     i18n("Old location:") + QStringLiteral(" ") + oldPath + QStringLiteral("; ") + i18n("New location:") + QStringLiteral(" ") + newPath;
                 Q_EMIT error(Error::Type::StorageMoveError, QString(), QString(), moveJob->error(), moveJob->errorString(), title);
             }
             Q_EMIT storageMoveFinished();
             Q_EMIT storagePathChanged(newPath);
 
             // save settings now to avoid getting into an inconsistent app state
             SettingsManager::self()->save();
             disconnect(this, &StorageManager::cancelStorageMove, this, nullptr);
         });
         connect(this, &StorageManager::cancelStorageMove, this, [moveJob]() {
             moveJob->doKill();
         });
         Q_EMIT storageMoveStarted();
         moveJob->start();
     }
 }
 
 QString StorageManager::imageDirPath() const
 {
     QString path = storagePath() + QStringLiteral("/images/");
     // Create path if it doesn't exist yet
     QFileInfo().absoluteDir().mkpath(path);
     return path;
 }
 
 QString StorageManager::imagePath(const QString &url) const
 {
     return imageDirPath() + QString::fromStdString(QCryptographicHash::hash(url.toUtf8(), QCryptographicHash::Md5).toHex().toStdString());
 }
 
 QString StorageManager::enclosureDirPath() const
 {
     return enclosureDirPath(QStringLiteral(""));
 }
 
 QString StorageManager::enclosureDirPath(const QString &feedname) const
 {
     QString path = storagePath() + QStringLiteral("/enclosures/");
 
     if (!feedname.isEmpty()) {
         path += feedname + QStringLiteral("/");
     }
 
     // Create path if it doesn't exist yet
     QFileInfo().absoluteDir().mkpath(path);
     return path;
 }
 
 QString StorageManager::enclosurePath(const QString &name, const QString &url, const QString &feedname) const
 {
     // Generate filename based on episode name and url hash with feedname as subdirectory
     QString enclosureFilenameBase = sanitizedFilePath(name) + QStringLiteral(".")
         + QString::fromStdString(QCryptographicHash::hash(url.toUtf8(), QCryptographicHash::Md5).toHex().toStdString()).left(6);
 
     QString enclosureFilenameExt = QFileInfo(QUrl::fromUserInput(url).fileName()).suffix();
 
     QString enclosureFilename = !enclosureFilenameExt.isEmpty() ? enclosureFilenameBase + QStringLiteral(".") + enclosureFilenameExt : enclosureFilenameBase;
 
     return enclosureDirPath(feedname) + enclosureFilename;
 }
 
 qint64 StorageManager::dirSize(const QString &path) const
 {
     qint64 size = 0;
     QFileInfoList files = QDir(path).entryInfoList(QDir::Files | QDir::Dirs | QDir::NoDotAndDotDot);
 
     for (QFileInfo info : files) {
         if (info.isDir()) {
             size += dirSize(info.filePath());
         }
         size += info.size();
     }
 
     return size;
 }
 
 void StorageManager::removeImage(const QString &url)
 {
     qCDebug(kastsStorageManager) << "Removing image" << imagePath(url);
     QFile(imagePath(url)).remove();
     Q_EMIT imageDirSizeChanged();
 }
 
 void StorageManager::clearImageCache()
 {
     qCDebug(kastsStorageManager) << imageDirPath();
     QStringList images = QDir(imageDirPath()).entryList(QDir::Files);
     qCDebug(kastsStorageManager) << images;
     for (QString image : images) {
         qCDebug(kastsStorageManager) << image;
         QFile(QDir(imageDirPath()).absoluteFilePath(image)).remove();
     }
     Q_EMIT imageDirSizeChanged();
 }
 
 qint64 StorageManager::enclosureDirSize() const
 {
     return dirSize(enclosureDirPath());
 }
 
 qint64 StorageManager::imageDirSize() const
 {
     return dirSize(imageDirPath());
 }
 
 QString StorageManager::formattedEnclosureDirSize() const
 {
     return m_kformat.formatByteSize(enclosureDirSize());
 }
 
 QString StorageManager::formattedImageDirSize() const
 {
     return m_kformat.formatByteSize(imageDirSize());
 }
 
 QString StorageManager::passwordFilePath(const QString &username) const
 {
     return QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + QStringLiteral("/") + username;
 }
 
 QString StorageManager::sanitizedFilePath(const QString &path) const
 {
     // NOTE: Any changes here require a database migration!
 
     // Only keep alphanumeric ascii characters; this avoid any kind of issues
     // with the many types of filesystems out there.  Then remove excess whitespace
     // and limit the length of the string.
     QString newPath = path;
     newPath = newPath.remove(QRegularExpression(QStringLiteral("[^a-zA-Z0-9 ._()-]"))).simplified().left(maxFilenameLength);
 
     return newPath.isEmpty() ? QStringLiteral("Noname") : newPath;
 }