Add option to notify when synced folder overcomes set size limit

src/common/syncjournaldb.cpp

@@ -205,6 +205,33 @@ bool SyncJournalDb::maybeMigrateDb(const QString &localPath, const QString &abso
     return true;
 }
 
+bool SyncJournalDb::findPathInSelectiveSyncList(const QStringList &list, const QString &path)
+{
+    Q_ASSERT(std::is_sorted(list.cbegin(), list.cend()));
+
+    if (list.size() == 1 && list.first() == QStringLiteral("/")) {
+        // Special case for the case "/" is there, it matches everything
+        return true;
+    }
+
+    const QString pathSlash = path + QLatin1Char('/');
+
+    // Since the list is sorted, we can do a binary search.
+    // If the path is a prefix of another item or right after in the lexical order.
+    auto it = std::lower_bound(list.cbegin(), list.cend(), pathSlash);
+
+    if (it != list.cend() && *it == pathSlash) {
+        return true;
+    }
+
+    if (it == list.cbegin()) {
+        return false;
+    }
+    --it;
+    Q_ASSERT(it->endsWith(QLatin1Char('/'))); // Folder::setSelectiveSyncBlackList makes sure of that
+    return pathSlash.startsWith(*it);
+}
+
 bool SyncJournalDb::exists()
 {
     QMutexLocker locker(&_mutex);
@@ -1958,10 +1985,7 @@ QStringList SyncJournalDb::getSelectiveSyncList(SyncJournalDb::SelectiveSyncList
         if (!next.hasData)
             break;
 
-        auto entry = query->stringValue(0);
-        if (!entry.endsWith(QLatin1Char('/'))) {
-            entry.append(QLatin1Char('/'));
-        }
+        const auto entry = Utility::trailingSlashPath(query->stringValue(0));
         result.append(entry);
     }
     *ok = true;
@@ -1986,7 +2010,7 @@ void SyncJournalDb::setSelectiveSyncList(SyncJournalDb::SelectiveSyncListType ty
     }
 
     SqlQuery insQuery("INSERT INTO selectivesync VALUES (?1, ?2)", _db);
-    foreach (const auto &path, list) {
+    for (const auto &path : list) {
         insQuery.reset_and_clear_bindings();
         insQuery.bindValue(1, path);
         insQuery.bindValue(2, int(type));

src/common/syncjournaldb.h

@@ -58,6 +58,9 @@ class OCSYNC_EXPORT SyncJournalDb : public QObject
     /// Migrate a csync_journal to the new path, if necessary. Returns false on error
     static bool maybeMigrateDb(const QString &localPath, const QString &absoluteJournalPath);
 
+    /// Given a sorted list of paths ending with '/', return whether or not the given path is within one of the paths of the list
+    static bool findPathInSelectiveSyncList(const QStringList &list, const QString &path);
+
     // To verify that the record could be found check with SyncJournalFileRecord::isValid()
     [[nodiscard]] bool getFileRecord(const QString &filename, SyncJournalFileRecord *rec) { return getFileRecord(filename.toUtf8(), rec); }
     [[nodiscard]] bool getFileRecord(const QByteArray &filename, SyncJournalFileRecord *rec);

src/common/utility.cpp

@@ -723,4 +723,10 @@ bool Utility::isCaseClashConflictFile(const QString &name)
     return bname.contains(QStringLiteral("(case clash from"));
 }
 
+QString Utility::trailingSlashPath(const QString &path)
+{
+    static const auto slash = QLatin1Char('/');
+    return path.endsWith(slash) ? path : QString(path + slash);
+}
+
 } // namespace OCC

src/common/utility.h

@@ -255,6 +255,8 @@ namespace Utility {
      */
     OCSYNC_EXPORT void registerUriHandlerForLocalEditing();
 
+    OCSYNC_EXPORT QString trailingSlashPath(const QString &path);
+
 #ifdef Q_OS_WIN
     OCSYNC_EXPORT bool registryKeyExists(HKEY hRootKey, const QString &subKey);
     OCSYNC_EXPORT QVariant registryGetKeyValue(HKEY hRootKey, const QString &subKey, const QString &valueName);

src/gui/accountsettings.cpp

@@ -14,6 +14,7 @@
 
 
 #include "accountsettings.h"
+#include "common/syncjournaldb.h"
 #include "common/syncjournalfilerecord.h"
 #include "qmessagebox.h"
 #include "ui_accountsettings.h"
@@ -1480,48 +1481,81 @@ void AccountSettings::folderTerminateSyncAndUpdateBlackList(const QStringList &b
 
 void AccountSettings::refreshSelectiveSyncStatus()
 {
-    QString msg;
-    auto cnt = 0;
+    QString unsyncedFoldersString;
+    QString becameBigFoldersString;
+
     const auto folders = FolderMan::instance()->map().values();
+
+    static const auto folderSeparatorString = QStringLiteral(", ");
+    static const auto folderLinkString = [](const QString &slashlessFolderPath, const QString &folderName) {
+        return QStringLiteral("<a href=\"%1?folder=%2\">%1</a>").arg(slashlessFolderPath, folderName);
+    };
+    static const auto appendFolderDisplayString = [](QString &foldersString, const QString &folderDisplayString) {
+        if (!foldersString.isEmpty()) {
+            foldersString += folderSeparatorString;
+        }
+        foldersString += folderDisplayString;
+    };
+
     _ui->bigFolderUi->setVisible(false);
+
     for (const auto folder : folders) {
         if (folder->accountState() != _accountState) {
             continue;
         }
 
         auto ok = false;
+        auto blacklistOk = false;
         const auto undecidedList = folder->journalDb()->getSelectiveSyncList(SyncJournalDb::SelectiveSyncUndecidedList, &ok);
+        auto blacklist = folder->journalDb()->getSelectiveSyncList(SyncJournalDb::SelectiveSyncBlackList, &blacklistOk);
+        blacklist.sort();
+
         for (const auto &it : undecidedList) {
             // FIXME: add the folder alias in a hoover hint.
             // folder->alias() + QLatin1String("/")
-            if (cnt++) {
-                msg += QLatin1String(", ");
-            }
-            auto myFolder = (it);
-            if (myFolder.endsWith('/')) {
-                myFolder.chop(1);
-            }
-            const auto theIndx = _model->indexForPath(folder, myFolder);
-            if (theIndx.isValid()) {
-                msg += QString::fromLatin1("<a href=\"%1?folder=%2\">%1</a>")
-                           .arg(Utility::escape(myFolder), Utility::escape(folder->alias()));
+
+            const auto folderTrailingSlash = Utility::trailingSlashPath(it);
+            const auto folderWithoutTrailingSlash = it.endsWith('/') ? it.left(it.length() - 1) : it;
+            const auto escapedFolderString = Utility::escape(folderWithoutTrailingSlash);
+            const auto escapedFolderName = Utility::escape(folder->alias());
+            const auto folderIdx = _model->indexForPath(folder, folderWithoutTrailingSlash);
+
+            // If we do not know the index yet then do not provide a link string
+            const auto folderDisplayString = folderIdx.isValid() ? folderLinkString(escapedFolderString, escapedFolderName) : folderWithoutTrailingSlash;
+
+            // The new big folder procedure automatically places these new big folders in the blacklist.
+            // This is not the case for existing folders discovered to have gone beyond the limit.
+            // So we need to check if the folder is in the blacklist or not and tweak the message accordingly.
+            if (SyncJournalDb::findPathInSelectiveSyncList(blacklist, folderTrailingSlash)) {
+                appendFolderDisplayString(unsyncedFoldersString, folderDisplayString);
             } else {
-                msg += myFolder; // no link because we do not know the index yet.
+                appendFolderDisplayString(becameBigFoldersString, folderDisplayString);
             }
         }
     }
 
-    if (!msg.isEmpty()) {
-        ConfigFile cfg;
-        const auto info = !cfg.confirmExternalStorage() ?
-                    tr("There are folders that were not synchronized because they are too big: ") :
-                    !cfg.newBigFolderSizeLimit().first ?
-                        tr("There are folders that were not synchronized because they are external storages: ") :
-                        tr("There are folders that were not synchronized because they are too big or external storages: ");
+    ConfigFile cfg;
+    QString infoString;
 
-        _ui->selectiveSyncNotification->setText(info + msg);
-        _ui->bigFolderUi->setVisible(true);
+    if (!unsyncedFoldersString.isEmpty()) {
+        infoString += !cfg.confirmExternalStorage() ? tr("There are folders that were not synchronized because they are too big: ")
+            : !cfg.newBigFolderSizeLimit().first    ? tr("There are folders that were not synchronized because they are external storages: ")
+                                                    : tr("There are folders that were not synchronized because they are too big or external storages: ");
+
+        infoString += unsyncedFoldersString;
     }
+
+    if (!becameBigFoldersString.isEmpty()) {
+        if (!infoString.isEmpty()) {
+            infoString += QStringLiteral("\n");
+        }
+
+        const auto folderSizeLimitString = QString::number(cfg.newBigFolderSizeLimit().second);
+        infoString += tr("There are folders that have grown in size beyond %1MB: %2").arg(folderSizeLimitString, becameBigFoldersString);
+    }
+
+    _ui->selectiveSyncNotification->setText(infoString);
+    _ui->bigFolderUi->setVisible(!infoString.isEmpty());
 }
 
 bool AccountSettings::event(QEvent *e)