{

/** FileName of the entry (this does not contains any directory or path, just the plain name */

QString name;

QByteArray etag;

QByteArray fileId;

QByteArray checksumHeader;

OCC::RemotePermissions remotePerm;

time_t modtime = 0;

int64_t size = 0;

bool isDirectory = false;

bool isValid() const { return !name.isNull(); }

QString directDownloadUrl;

QString directDownloadCookies;

{

/** FileName of the entry (this does not contains any directory or path, just the plain name */

QString name;

time_t modtime = 0;

int64_t size = 0;

uint64_t inode = 0;

ItemType type = ItemTypeSkip;

bool isDirectory = false;

bool isHidden = false;

bool isVirtualFile = false;

bool isSymLink = false;

bool isValid() const { return !name.isNull(); }

{

Q_OBJECT

explicit DiscoverySingleLocalDirectoryJob(const AccountPtr &account, const QString &localPath, OCC::Vfs *vfs, QObject *parent = nullptr);

void run() override;

signals:

void finished(QVector<LocalInfo> result);

void finishedFatalError(QString errorString);

void finishedNonFatalError(QString errorString);

void itemDiscovered(SyncFileItemPtr item);

void childIgnored(bool b);

private slots:

QString _localPath;

AccountPtr _account;

OCC::Vfs* _vfs;

{

Q_OBJECT

explicit DiscoverySingleDirectoryJob(const AccountPtr &account, const QString &path, QObject *parent = nullptr);

// Specify that this is the root and we need to check the data-fingerprint

void setIsRootPath() { _isRootPath = true; }

void start();

void abort();

// This is not actually a network job, it is just a job

signals:

void firstDirectoryPermissions(RemotePermissions);

void etag(const QByteArray &, const QDateTime &time);

void finished(const HttpResult<QVector<RemoteInfo>> &result);

private slots:

void directoryListingIteratedSlot(const QString &, const QMap<QString, QString> &);

void lsJobFinishedWithoutErrorSlot();

void lsJobFinishedWithErrorSlot(QNetworkReply *);

QVector<RemoteInfo> _results;

QString _subPath;

QByteArray _firstEtag;

AccountPtr _account;

// The first result is for the directory itself and need to be ignored.

// This flag is true if it was already ignored.

bool _ignoredFirst;

// Set to true if this is the root path and we need to check the data-fingerprint

bool _isRootPath;

// If this directory is an external storage (The first item has 'M' in its permission)

bool _isExternalStorage;

// If set, the discovery will finish with an error

QString _error;

QPointer<LsColJob> _lsColJob;

QByteArray _dataFingerprint;

{

Q_OBJECT

friend class ProcessDirectoryJob;

QPointer<ProcessDirectoryJob> _currentRootJob;

/** Maps the db-path of a deleted item to its SyncFileItem.

QMap<QString, SyncFileItemPtr> _deletedItem;

/** Maps the db-path of a deleted folder to its queued job.

QMap<QString, ProcessDirectoryJob *> _queuedDeletedDirectories;

// map source (original path) -> destinations (current server or local path)

QMap<QString, QString> _renamedItemsRemote;

QMap<QString, QString> _renamedItemsLocal;

// set of paths that should not be removed even though they are removed locally:

// there was a move to an invalid destination and now the source should be restored

//

// This applies recursively to subdirectories.

// All entries should have a trailing slash (even files), so lookup with

// lowerBound() is reliable.

//

// The value of this map doesn't matter.

QMap<QString, bool> _forbiddenDeletes;

/** Returns whether the db-path has been renamed locally or on the remote.

bool isRenamed(const QString &p) const { return _renamedItemsLocal.contains(p) || _renamedItemsRemote.contains(p); }

int _currentlyActiveJobs = 0;

// both must contain a sorted list

QStringList _selectiveSyncBlackList;

QStringList _selectiveSyncWhiteList;

void scheduleMoreJobs();

bool isInSelectiveSyncBlackList(const QString &path) const;

// Check if the new folder should be deselected or not.

// May be async. "Return" via the callback, true if the item is blacklisted

void checkSelectiveSyncNewFolder(const QString &path, RemotePermissions rp,

std::function<void(bool)> callback);

/** Given an original path, return the target path obtained when renaming is done.

QString adjustRenamedPath(const QString &original, SyncFileItem::Direction) const;

/** If the db-path is scheduled for deletion, abort it.

QPair<bool, QByteArray> findAndCancelDeletedJob(const QString &originalPath);

// input

QString _localDir; // absolute path to the local directory. ends with '/'

QString _remoteFolder; // remote folder, ends with '/'

SyncJournalDb *_statedb;

AccountPtr _account;

SyncOptions _syncOptions;

ExcludedFiles *_excludes;

QRegExp _invalidFilenameRx; // FIXME: maybe move in ExcludedFiles

QStringList _serverBlacklistedFiles; // The blacklist from the capabilities

bool _ignoreHiddenFiles = false;

std::function<bool(const QString &)> _shouldDiscoverLocaly;

void startJob(ProcessDirectoryJob *);

void setSelectiveSyncBlackList(const QStringList &list);

void setSelectiveSyncWhiteList(const QStringList &list);

// output

QByteArray _dataFingerprint;

bool _anotherSyncNeeded = false;

signals:

void fatalError(const QString &errorString);

void itemDiscovered(const SyncFileItemPtr &item);

void finished();

// A new folder was discovered and was not synced because of the confirmation feature

void newBigFolder(const QString &folder, bool isExternal);

/** For excluded items that don't show up in itemDiscovered()

void silentlyExcluded(const QString &folderPath);

void excluded(const QString &folderPath, CSYNC_EXCLUDE_TYPE reason);