migrate therinaldos.com data

wedding-pics/lib/private/Files/Node/File.php

@@ -0,0 +1,161 @@
+<?php
+/**
+ * @copyright Copyright (c) 2016, ownCloud, Inc.
+ *
+ * @author Arthur Schiwon <blizzz@arthur-schiwon.de>
+ * @author Christoph Wurst <christoph@winzerhof-wurst.at>
+ * @author Joas Schilling <coding@schilljs.com>
+ * @author Julius Härtl <jus@bitgrid.net>
+ * @author Morris Jobke <hey@morrisjobke.de>
+ * @author Robin Appelman <robin@icewind.nl>
+ * @author Roeland Jago Douma <roeland@famdouma.nl>
+ * @author Vincent Petry <vincent@nextcloud.com>
+ *
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License, version 3,
+ * along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+namespace OC\Files\Node;
+
+use OCP\Files\GenericFileException;
+use OCP\Files\NotPermittedException;
+use OCP\Lock\LockedException;
+
+class File extends Node implements \OCP\Files\File {
+	/**
+	 * Creates a Folder that represents a non-existing path
+	 *
+	 * @param string $path path
+	 * @return NonExistingFile non-existing node
+	 */
+	protected function createNonExistingNode($path) {
+		return new NonExistingFile($this->root, $this->view, $path);
+	}
+
+	/**
+	 * @return string
+	 * @throws NotPermittedException
+	 * @throws GenericFileException
+	 * @throws LockedException
+	 */
+	public function getContent() {
+		if ($this->checkPermissions(\OCP\Constants::PERMISSION_READ)) {
+			$content = $this->view->file_get_contents($this->path);
+			if ($content === false) {
+				throw new GenericFileException();
+			}
+			return $content;
+		} else {
+			throw new NotPermittedException();
+		}
+	}
+
+	/**
+	 * @param string|resource $data
+	 * @throws NotPermittedException
+	 * @throws GenericFileException
+	 * @throws LockedException
+	 */
+	public function putContent($data) {
+		if ($this->checkPermissions(\OCP\Constants::PERMISSION_UPDATE)) {
+			$this->sendHooks(['preWrite']);
+			if ($this->view->file_put_contents($this->path, $data) === false) {
+				throw new GenericFileException('file_put_contents failed');
+			}
+			$this->fileInfo = null;
+			$this->sendHooks(['postWrite']);
+		} else {
+			throw new NotPermittedException();
+		}
+	}
+
+	/**
+	 * @param string $mode
+	 * @return resource|false
+	 * @throws NotPermittedException
+	 * @throws LockedException
+	 */
+	public function fopen($mode) {
+		$preHooks = [];
+		$postHooks = [];
+		$requiredPermissions = \OCP\Constants::PERMISSION_READ;
+		switch ($mode) {
+			case 'r+':
+			case 'rb+':
+			case 'w+':
+			case 'wb+':
+			case 'x+':
+			case 'xb+':
+			case 'a+':
+			case 'ab+':
+			case 'w':
+			case 'wb':
+			case 'x':
+			case 'xb':
+			case 'a':
+			case 'ab':
+				$preHooks[] = 'preWrite';
+				$postHooks[] = 'postWrite';
+				$requiredPermissions |= \OCP\Constants::PERMISSION_UPDATE;
+				break;
+		}
+
+		if ($this->checkPermissions($requiredPermissions)) {
+			$this->sendHooks($preHooks);
+			$result = $this->view->fopen($this->path, $mode);
+			$this->sendHooks($postHooks);
+			return $result;
+		} else {
+			throw new NotPermittedException();
+		}
+	}
+
+	/**
+	 * @throws NotPermittedException
+	 * @throws \OCP\Files\InvalidPathException
+	 * @throws \OCP\Files\NotFoundException
+	 */
+	public function delete() {
+		if ($this->checkPermissions(\OCP\Constants::PERMISSION_DELETE)) {
+			$this->sendHooks(['preDelete']);
+			$fileInfo = $this->getFileInfo();
+			$this->view->unlink($this->path);
+			$nonExisting = new NonExistingFile($this->root, $this->view, $this->path, $fileInfo);
+			$this->sendHooks(['postDelete'], [$nonExisting]);
+			$this->fileInfo = null;
+		} else {
+			throw new NotPermittedException();
+		}
+	}
+
+	/**
+	 * @param string $type
+	 * @param bool $raw
+	 * @return string
+	 */
+	public function hash($type, $raw = false) {
+		return $this->view->hash($type, $this->path, $raw);
+	}
+
+	/**
+	 * @inheritdoc
+	 */
+	public function getChecksum() {
+		return $this->getFileInfo()->getChecksum();
+	}
+
+	public function getExtension(): string {
+		return $this->getFileInfo()->getExtension();
+	}
+}

wedding-pics/lib/private/Files/Node/Folder.php

@@ -0,0 +1,459 @@
+<?php
+/**
+ * @copyright Copyright (c) 2016, ownCloud, Inc.
+ * @copyright Copyright (c) 2022 Informatyka Boguslawski sp. z o.o. sp.k., http://www.ib.pl/
+ *
+ * @author Arthur Schiwon <blizzz@arthur-schiwon.de>
+ * @author Christoph Wurst <christoph@winzerhof-wurst.at>
+ * @author Georg Ehrke <oc.list@georgehrke.com>
+ * @author Joas Schilling <coding@schilljs.com>
+ * @author Julius Härtl <jus@bitgrid.net>
+ * @author Morris Jobke <hey@morrisjobke.de>
+ * @author Robin Appelman <robin@icewind.nl>
+ * @author Robin McCorkell <robin@mccorkell.me.uk>
+ * @author Roeland Jago Douma <roeland@famdouma.nl>
+ * @author Vincent Petry <vincent@nextcloud.com>
+ *
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License, version 3,
+ * along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+namespace OC\Files\Node;
+
+use OC\Files\Cache\QuerySearchHelper;
+use OC\Files\Search\SearchBinaryOperator;
+use OC\Files\Search\SearchComparison;
+use OC\Files\Search\SearchOrder;
+use OC\Files\Search\SearchQuery;
+use OC\Files\Utils\PathHelper;
+use OCP\Files\Cache\ICacheEntry;
+use OCP\Files\FileInfo;
+use OCP\Files\Mount\IMountPoint;
+use OCP\Files\Node as INode;
+use OCP\Files\NotFoundException;
+use OCP\Files\NotPermittedException;
+use OCP\Files\Search\ISearchBinaryOperator;
+use OCP\Files\Search\ISearchComparison;
+use OCP\Files\Search\ISearchOperator;
+use OCP\Files\Search\ISearchOrder;
+use OCP\Files\Search\ISearchQuery;
+use OCP\IUserManager;
+
+class Folder extends Node implements \OCP\Files\Folder {
+	/**
+	 * Creates a Folder that represents a non-existing path
+	 *
+	 * @param string $path path
+	 * @return NonExistingFolder non-existing node
+	 */
+	protected function createNonExistingNode($path) {
+		return new NonExistingFolder($this->root, $this->view, $path);
+	}
+
+	/**
+	 * @param string $path path relative to the folder
+	 * @return string
+	 * @throws \OCP\Files\NotPermittedException
+	 */
+	public function getFullPath($path) {
+		$path = $this->normalizePath($path);
+		if (!$this->isValidPath($path)) {
+			throw new NotPermittedException('Invalid path "' . $path . '"');
+		}
+		return $this->path . $path;
+	}
+
+	/**
+	 * @param string $path
+	 * @return string|null
+	 */
+	public function getRelativePath($path) {
+		return PathHelper::getRelativePath($this->getPath(), $path);
+	}
+
+	/**
+	 * check if a node is a (grand-)child of the folder
+	 *
+	 * @param \OC\Files\Node\Node $node
+	 * @return bool
+	 */
+	public function isSubNode($node) {
+		return str_starts_with($node->getPath(), $this->path . '/');
+	}
+
+	/**
+	 * get the content of this directory
+	 *
+	 * @return Node[]
+	 * @throws \OCP\Files\NotFoundException
+	 */
+	public function getDirectoryListing() {
+		$folderContent = $this->view->getDirectoryContent($this->path, '', $this->getFileInfo(false));
+
+		return array_map(function (FileInfo $info) {
+			if ($info->getMimetype() === FileInfo::MIMETYPE_FOLDER) {
+				return new Folder($this->root, $this->view, $info->getPath(), $info, $this);
+			} else {
+				return new File($this->root, $this->view, $info->getPath(), $info, $this);
+			}
+		}, $folderContent);
+	}
+
+	protected function createNode(string $path, ?FileInfo $info = null, bool $infoHasSubMountsIncluded = true): INode {
+		if (is_null($info)) {
+			$isDir = $this->view->is_dir($path);
+		} else {
+			$isDir = $info->getType() === FileInfo::TYPE_FOLDER;
+		}
+		$parent = dirname($path) === $this->getPath() ? $this : null;
+		if ($isDir) {
+			return new Folder($this->root, $this->view, $path, $info, $parent, $infoHasSubMountsIncluded);
+		} else {
+			return new File($this->root, $this->view, $path, $info, $parent);
+		}
+	}
+
+	/**
+	 * Get the node at $path
+	 *
+	 * @param string $path
+	 * @return \OC\Files\Node\Node
+	 * @throws \OCP\Files\NotFoundException
+	 */
+	public function get($path) {
+		return $this->root->get($this->getFullPath($path));
+	}
+
+	/**
+	 * @param string $path
+	 * @return bool
+	 */
+	public function nodeExists($path) {
+		try {
+			$this->get($path);
+			return true;
+		} catch (NotFoundException $e) {
+			return false;
+		}
+	}
+
+	/**
+	 * @param string $path
+	 * @return \OC\Files\Node\Folder
+	 * @throws \OCP\Files\NotPermittedException
+	 */
+	public function newFolder($path) {
+		if ($this->checkPermissions(\OCP\Constants::PERMISSION_CREATE)) {
+			$fullPath = $this->getFullPath($path);
+			$nonExisting = new NonExistingFolder($this->root, $this->view, $fullPath);
+			$this->sendHooks(['preWrite', 'preCreate'], [$nonExisting]);
+			if (!$this->view->mkdir($fullPath)) {
+				throw new NotPermittedException('Could not create folder "' . $fullPath . '"');
+			}
+			$parent = dirname($fullPath) === $this->getPath() ? $this : null;
+			$node = new Folder($this->root, $this->view, $fullPath, null, $parent);
+			$this->sendHooks(['postWrite', 'postCreate'], [$node]);
+			return $node;
+		} else {
+			throw new NotPermittedException('No create permission for folder "' . $path . '"');
+		}
+	}
+
+	/**
+	 * @param string $path
+	 * @param string | resource | null $content
+	 * @return \OC\Files\Node\File
+	 * @throws \OCP\Files\NotPermittedException
+	 */
+	public function newFile($path, $content = null) {
+		if ($path === '') {
+			throw new NotPermittedException('Could not create as provided path is empty');
+		}
+		if ($this->checkPermissions(\OCP\Constants::PERMISSION_CREATE)) {
+			$fullPath = $this->getFullPath($path);
+			$nonExisting = new NonExistingFile($this->root, $this->view, $fullPath);
+			$this->sendHooks(['preWrite', 'preCreate'], [$nonExisting]);
+			if ($content !== null) {
+				$result = $this->view->file_put_contents($fullPath, $content);
+			} else {
+				$result = $this->view->touch($fullPath);
+			}
+			if ($result === false) {
+				throw new NotPermittedException('Could not create path "' . $fullPath . '"');
+			}
+			$node = new File($this->root, $this->view, $fullPath, null, $this);
+			$this->sendHooks(['postWrite', 'postCreate'], [$node]);
+			return $node;
+		}
+		throw new NotPermittedException('No create permission for path "' . $path . '"');
+	}
+
+	private function queryFromOperator(ISearchOperator $operator, string $uid = null, int $limit = 0, int $offset = 0): ISearchQuery {
+		if ($uid === null) {
+			$user = null;
+		} else {
+			/** @var IUserManager $userManager */
+			$userManager = \OCP\Server::get(IUserManager::class);
+			$user = $userManager->get($uid);
+		}
+		return new SearchQuery($operator, $limit, $offset, [], $user);
+	}
+
+	/**
+	 * search for files with the name matching $query
+	 *
+	 * @param string|ISearchQuery $query
+	 * @return \OC\Files\Node\Node[]
+	 */
+	public function search($query) {
+		if (is_string($query)) {
+			$query = $this->queryFromOperator(new SearchComparison(ISearchComparison::COMPARE_LIKE, 'name', '%' . $query . '%'));
+		}
+
+		// search is handled by a single query covering all caches that this folder contains
+		// this is done by collect
+
+		$limitToHome = $query->limitToHome();
+		if ($limitToHome && count(explode('/', $this->path)) !== 3) {
+			throw new \InvalidArgumentException('searching by owner is only allowed in the users home folder');
+		}
+
+		/** @var QuerySearchHelper $searchHelper */
+		$searchHelper = \OC::$server->get(QuerySearchHelper::class);
+		[$caches, $mountByMountPoint] = $searchHelper->getCachesAndMountPointsForSearch($this->root, $this->path, $limitToHome);
+		$resultsPerCache = $searchHelper->searchInCaches($query, $caches);
+
+		// loop through all results per-cache, constructing the FileInfo object from the CacheEntry and merge them all
+		$files = array_merge(...array_map(function (array $results, string $relativeMountPoint) use ($mountByMountPoint) {
+			$mount = $mountByMountPoint[$relativeMountPoint];
+			return array_map(function (ICacheEntry $result) use ($relativeMountPoint, $mount) {
+				return $this->cacheEntryToFileInfo($mount, $relativeMountPoint, $result);
+			}, $results);
+		}, array_values($resultsPerCache), array_keys($resultsPerCache)));
+
+		// don't include this folder in the results
+		$files = array_filter($files, function (FileInfo $file) {
+			return $file->getPath() !== $this->getPath();
+		});
+
+		// since results were returned per-cache, they are no longer fully sorted
+		$order = $query->getOrder();
+		if ($order) {
+			usort($files, function (FileInfo $a, FileInfo $b) use ($order) {
+				foreach ($order as $orderField) {
+					$cmp = $orderField->sortFileInfo($a, $b);
+					if ($cmp !== 0) {
+						return $cmp;
+					}
+				}
+				return 0;
+			});
+		}
+
+		return array_map(function (FileInfo $file) {
+			return $this->createNode($file->getPath(), $file);
+		}, $files);
+	}
+
+	private function cacheEntryToFileInfo(IMountPoint $mount, string $appendRoot, ICacheEntry $cacheEntry): FileInfo {
+		$cacheEntry['internalPath'] = $cacheEntry['path'];
+		$cacheEntry['path'] = rtrim($appendRoot . $cacheEntry->getPath(), '/');
+		$subPath = $cacheEntry['path'] !== '' ? '/' . $cacheEntry['path'] : '';
+		return new \OC\Files\FileInfo($this->path . $subPath, $mount->getStorage(), $cacheEntry['internalPath'], $cacheEntry, $mount);
+	}
+
+	/**
+	 * search for files by mimetype
+	 *
+	 * @param string $mimetype
+	 * @return Node[]
+	 */
+	public function searchByMime($mimetype) {
+		if (!str_contains($mimetype, '/')) {
+			$query = $this->queryFromOperator(new SearchComparison(ISearchComparison::COMPARE_LIKE, 'mimetype', $mimetype . '/%'));
+		} else {
+			$query = $this->queryFromOperator(new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'mimetype', $mimetype));
+		}
+		return $this->search($query);
+	}
+
+	/**
+	 * search for files by tag
+	 *
+	 * @param string|int $tag name or tag id
+	 * @param string $userId owner of the tags
+	 * @return Node[]
+	 */
+	public function searchByTag($tag, $userId) {
+		$query = $this->queryFromOperator(new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'tagname', $tag), $userId);
+		return $this->search($query);
+	}
+
+	public function searchBySystemTag(string $tagName, string $userId, int $limit = 0, int $offset = 0): array {
+		$query = $this->queryFromOperator(new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'systemtag', $tagName), $userId, $limit, $offset);
+		return $this->search($query);
+	}
+
+	/**
+	 * @param int $id
+	 * @return \OC\Files\Node\Node[]
+	 */
+	public function getById($id) {
+		return $this->root->getByIdInPath((int)$id, $this->getPath());
+	}
+
+	protected function getAppDataDirectoryName(): string {
+		$instanceId = \OC::$server->getConfig()->getSystemValueString('instanceid');
+		return 'appdata_' . $instanceId;
+	}
+
+	/**
+	 * In case the path we are currently in is inside the appdata_* folder,
+	 * the original getById method does not work, because it can only look inside
+	 * the user's mount points. But the user has no mount point for the root storage.
+	 *
+	 * So in that case we directly check the mount of the root if it contains
+	 * the id. If it does we check if the path is inside the path we are working
+	 * in.
+	 *
+	 * @param int $id
+	 * @return array
+	 */
+	protected function getByIdInRootMount(int $id): array {
+		if (!method_exists($this->root, 'createNode')) {
+			// Always expected to be false. Being a method of Folder, this is
+			// always implemented. For it is an internal method and should not
+			// be exposed and made public, it is not part of an interface.
+			return [];
+		}
+		$mount = $this->root->getMount('');
+		$storage = $mount->getStorage();
+		$cacheEntry = $storage?->getCache($this->path)->get($id);
+		if (!$cacheEntry) {
+			return [];
+		}
+
+		$absolutePath = '/' . ltrim($cacheEntry->getPath(), '/');
+		$currentPath = rtrim($this->path, '/') . '/';
+
+		if (!str_starts_with($absolutePath, $currentPath)) {
+			return [];
+		}
+
+		return [$this->root->createNode(
+			$absolutePath, new \OC\Files\FileInfo(
+				$absolutePath,
+				$storage,
+				$cacheEntry->getPath(),
+				$cacheEntry,
+				$mount
+			))];
+	}
+
+	public function getFreeSpace() {
+		return $this->view->free_space($this->path);
+	}
+
+	public function delete() {
+		if ($this->checkPermissions(\OCP\Constants::PERMISSION_DELETE)) {
+			$this->sendHooks(['preDelete']);
+			$fileInfo = $this->getFileInfo();
+			$this->view->rmdir($this->path);
+			$nonExisting = new NonExistingFolder($this->root, $this->view, $this->path, $fileInfo);
+			$this->sendHooks(['postDelete'], [$nonExisting]);
+		} else {
+			throw new NotPermittedException('No delete permission for path "' . $this->path . '"');
+		}
+	}
+
+	/**
+	 * Add a suffix to the name in case the file exists
+	 *
+	 * @param string $name
+	 * @return string
+	 * @throws NotPermittedException
+	 */
+	public function getNonExistingName($name) {
+		$uniqueName = \OC_Helper::buildNotExistingFileNameForView($this->getPath(), $name, $this->view);
+		return trim($this->getRelativePath($uniqueName), '/');
+	}
+
+	/**
+	 * @param int $limit
+	 * @param int $offset
+	 * @return INode[]
+	 */
+	public function getRecent($limit, $offset = 0) {
+		$filterOutNonEmptyFolder = new SearchBinaryOperator(
+			// filter out non empty folders
+			ISearchBinaryOperator::OPERATOR_OR,
+			[
+				new SearchBinaryOperator(
+					ISearchBinaryOperator::OPERATOR_NOT,
+					[
+						new SearchComparison(
+							ISearchComparison::COMPARE_EQUAL,
+							'mimetype',
+							FileInfo::MIMETYPE_FOLDER
+						),
+					]
+				),
+				new SearchComparison(
+					ISearchComparison::COMPARE_EQUAL,
+					'size',
+					0
+				),
+			]
+		);
+
+		$filterNonRecentFiles = new SearchComparison(
+			ISearchComparison::COMPARE_GREATER_THAN,
+			'mtime',
+			strtotime("-2 week")
+		);
+		if ($offset === 0 && $limit <= 100) {
+			$query = new SearchQuery(
+				new SearchBinaryOperator(
+					ISearchBinaryOperator::OPERATOR_AND,
+					[
+						$filterOutNonEmptyFolder,
+						$filterNonRecentFiles,
+					],
+				),
+				$limit,
+				$offset,
+				[
+					new SearchOrder(
+						ISearchOrder::DIRECTION_DESCENDING,
+						'mtime'
+					),
+				]
+			);
+		} else {
+			$query = new SearchQuery(
+				$filterOutNonEmptyFolder,
+				$limit,
+				$offset,
+				[
+					new SearchOrder(
+						ISearchOrder::DIRECTION_DESCENDING,
+						'mtime'
+					),
+				]
+			);
+		}
+
+		return $this->search($query);
+	}
+}

wedding-pics/lib/private/Files/Node/HookConnector.php

@@ -0,0 +1,238 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * @copyright Copyright (c) 2016, ownCloud, Inc.
+ *
+ * @author Arthur Schiwon <blizzz@arthur-schiwon.de>
+ * @author Robin Appelman <robin@icewind.nl>
+ * @author Roeland Jago Douma <roeland@famdouma.nl>
+ *
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License, version 3,
+ * along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+namespace OC\Files\Node;
+
+use OC\Files\Filesystem;
+use OC\Files\View;
+use OCP\EventDispatcher\GenericEvent;
+use OCP\EventDispatcher\IEventDispatcher;
+use OCP\Files\Events\Node\BeforeNodeCopiedEvent;
+use OCP\Files\Events\Node\BeforeNodeCreatedEvent;
+use OCP\Files\Events\Node\BeforeNodeDeletedEvent;
+use OCP\Files\Events\Node\BeforeNodeReadEvent;
+use OCP\Files\Events\Node\BeforeNodeRenamedEvent;
+use OCP\Files\Events\Node\BeforeNodeTouchedEvent;
+use OCP\Files\Events\Node\BeforeNodeWrittenEvent;
+use OCP\Files\Events\Node\NodeCopiedEvent;
+use OCP\Files\Events\Node\NodeCreatedEvent;
+use OCP\Files\Events\Node\NodeDeletedEvent;
+use OCP\Files\Events\Node\NodeRenamedEvent;
+use OCP\Files\Events\Node\NodeTouchedEvent;
+use OCP\Files\Events\Node\NodeWrittenEvent;
+use OCP\Files\FileInfo;
+use OCP\Files\IRootFolder;
+use OCP\Util;
+
+class HookConnector {
+	/** @var IRootFolder */
+	private $root;
+
+	/** @var View */
+	private $view;
+
+	/** @var FileInfo[] */
+	private $deleteMetaCache = [];
+
+	/** @var IEventDispatcher */
+	private $dispatcher;
+
+	public function __construct(
+		IRootFolder $root,
+		View $view,
+		IEventDispatcher $dispatcher) {
+		$this->root = $root;
+		$this->view = $view;
+		$this->dispatcher = $dispatcher;
+	}
+
+	public function viewToNode() {
+		Util::connectHook('OC_Filesystem', 'write', $this, 'write');
+		Util::connectHook('OC_Filesystem', 'post_write', $this, 'postWrite');
+
+		Util::connectHook('OC_Filesystem', 'create', $this, 'create');
+		Util::connectHook('OC_Filesystem', 'post_create', $this, 'postCreate');
+
+		Util::connectHook('OC_Filesystem', 'delete', $this, 'delete');
+		Util::connectHook('OC_Filesystem', 'post_delete', $this, 'postDelete');
+
+		Util::connectHook('OC_Filesystem', 'rename', $this, 'rename');
+		Util::connectHook('OC_Filesystem', 'post_rename', $this, 'postRename');
+
+		Util::connectHook('OC_Filesystem', 'copy', $this, 'copy');
+		Util::connectHook('OC_Filesystem', 'post_copy', $this, 'postCopy');
+
+		Util::connectHook('OC_Filesystem', 'touch', $this, 'touch');
+		Util::connectHook('OC_Filesystem', 'post_touch', $this, 'postTouch');
+
+		Util::connectHook('OC_Filesystem', 'read', $this, 'read');
+	}
+
+	public function write($arguments) {
+		$node = $this->getNodeForPath($arguments['path']);
+		$this->root->emit('\OC\Files', 'preWrite', [$node]);
+		$this->dispatcher->dispatch('\OCP\Files::preWrite', new GenericEvent($node));
+
+		$event = new BeforeNodeWrittenEvent($node);
+		$this->dispatcher->dispatchTyped($event);
+	}
+
+	public function postWrite($arguments) {
+		$node = $this->getNodeForPath($arguments['path']);
+		$this->root->emit('\OC\Files', 'postWrite', [$node]);
+		$this->dispatcher->dispatch('\OCP\Files::postWrite', new GenericEvent($node));
+
+		$event = new NodeWrittenEvent($node);
+		$this->dispatcher->dispatchTyped($event);
+	}
+
+	public function create($arguments) {
+		$node = $this->getNodeForPath($arguments['path']);
+		$this->root->emit('\OC\Files', 'preCreate', [$node]);
+		$this->dispatcher->dispatch('\OCP\Files::preCreate', new GenericEvent($node));
+
+		$event = new BeforeNodeCreatedEvent($node);
+		$this->dispatcher->dispatchTyped($event);
+	}
+
+	public function postCreate($arguments) {
+		$node = $this->getNodeForPath($arguments['path']);
+		$this->root->emit('\OC\Files', 'postCreate', [$node]);
+		$this->dispatcher->dispatch('\OCP\Files::postCreate', new GenericEvent($node));
+
+		$event = new NodeCreatedEvent($node);
+		$this->dispatcher->dispatchTyped($event);
+	}
+
+	public function delete($arguments) {
+		$node = $this->getNodeForPath($arguments['path']);
+		$this->deleteMetaCache[$node->getPath()] = $node->getFileInfo();
+		$this->root->emit('\OC\Files', 'preDelete', [$node]);
+		$this->dispatcher->dispatch('\OCP\Files::preDelete', new GenericEvent($node));
+
+		$event = new BeforeNodeDeletedEvent($node, $arguments['run']);
+		$this->dispatcher->dispatchTyped($event);
+	}
+
+	public function postDelete($arguments) {
+		$node = $this->getNodeForPath($arguments['path']);
+		unset($this->deleteMetaCache[$node->getPath()]);
+		$this->root->emit('\OC\Files', 'postDelete', [$node]);
+		$this->dispatcher->dispatch('\OCP\Files::postDelete', new GenericEvent($node));
+
+		$event = new NodeDeletedEvent($node);
+		$this->dispatcher->dispatchTyped($event);
+	}
+
+	public function touch($arguments) {
+		$node = $this->getNodeForPath($arguments['path']);
+		$this->root->emit('\OC\Files', 'preTouch', [$node]);
+		$this->dispatcher->dispatch('\OCP\Files::preTouch', new GenericEvent($node));
+
+		$event = new BeforeNodeTouchedEvent($node);
+		$this->dispatcher->dispatchTyped($event);
+	}
+
+	public function postTouch($arguments) {
+		$node = $this->getNodeForPath($arguments['path']);
+		$this->root->emit('\OC\Files', 'postTouch', [$node]);
+		$this->dispatcher->dispatch('\OCP\Files::postTouch', new GenericEvent($node));
+
+		$event = new NodeTouchedEvent($node);
+		$this->dispatcher->dispatchTyped($event);
+	}
+
+	public function rename($arguments) {
+		$source = $this->getNodeForPath($arguments['oldpath']);
+		$target = $this->getNodeForPath($arguments['newpath']);
+		$this->root->emit('\OC\Files', 'preRename', [$source, $target]);
+		$this->dispatcher->dispatch('\OCP\Files::preRename', new GenericEvent([$source, $target]));
+
+		$event = new BeforeNodeRenamedEvent($source, $target, $arguments['run']);
+		$this->dispatcher->dispatchTyped($event);
+	}
+
+	public function postRename($arguments) {
+		$source = $this->getNodeForPath($arguments['oldpath']);
+		$target = $this->getNodeForPath($arguments['newpath']);
+		$this->root->emit('\OC\Files', 'postRename', [$source, $target]);
+		$this->dispatcher->dispatch('\OCP\Files::postRename', new GenericEvent([$source, $target]));
+
+		$event = new NodeRenamedEvent($source, $target);
+		$this->dispatcher->dispatchTyped($event);
+	}
+
+	public function copy($arguments) {
+		$source = $this->getNodeForPath($arguments['oldpath']);
+		$target = $this->getNodeForPath($arguments['newpath']);
+		$this->root->emit('\OC\Files', 'preCopy', [$source, $target]);
+		$this->dispatcher->dispatch('\OCP\Files::preCopy', new GenericEvent([$source, $target]));
+
+		$event = new BeforeNodeCopiedEvent($source, $target);
+		$this->dispatcher->dispatchTyped($event);
+	}
+
+	public function postCopy($arguments) {
+		$source = $this->getNodeForPath($arguments['oldpath']);
+		$target = $this->getNodeForPath($arguments['newpath']);
+		$this->root->emit('\OC\Files', 'postCopy', [$source, $target]);
+		$this->dispatcher->dispatch('\OCP\Files::postCopy', new GenericEvent([$source, $target]));
+
+		$event = new NodeCopiedEvent($source, $target);
+		$this->dispatcher->dispatchTyped($event);
+	}
+
+	public function read($arguments) {
+		$node = $this->getNodeForPath($arguments['path']);
+		$this->root->emit('\OC\Files', 'read', [$node]);
+		$this->dispatcher->dispatch('\OCP\Files::read', new GenericEvent([$node]));
+
+		$event = new BeforeNodeReadEvent($node);
+		$this->dispatcher->dispatchTyped($event);
+	}
+
+	private function getNodeForPath(string $path): Node {
+		$info = Filesystem::getView()->getFileInfo($path);
+		if (!$info) {
+			$fullPath = Filesystem::getView()->getAbsolutePath($path);
+			if (isset($this->deleteMetaCache[$fullPath])) {
+				$info = $this->deleteMetaCache[$fullPath];
+			} else {
+				$info = null;
+			}
+			if (Filesystem::is_dir($path)) {
+				return new NonExistingFolder($this->root, $this->view, $fullPath, $info);
+			} else {
+				return new NonExistingFile($this->root, $this->view, $fullPath, $info);
+			}
+		}
+		if ($info->getType() === FileInfo::TYPE_FILE) {
+			return new File($this->root, $this->view, $info->getPath(), $info);
+		} else {
+			return new Folder($this->root, $this->view, $info->getPath(), $info);
+		}
+	}
+}

wedding-pics/lib/private/Files/Node/LazyFolder.php

@@ -0,0 +1,586 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * @copyright Copyright (c) 2020 Robin Appelman <robin@icewind.nl>
+ *
+ * @author Maxence Lange <maxence@artificial-owl.com>
+ * @author Robin Appelman <robin@icewind.nl>
+ *
+ * @license GNU AGPL version 3 or any later version
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+namespace OC\Files\Node;
+
+use OC\Files\Filesystem;
+use OC\Files\Utils\PathHelper;
+use OCP\Constants;
+use OCP\Files\Folder;
+use OCP\Files\IRootFolder;
+use OCP\Files\Mount\IMountPoint;
+use OCP\Files\NotPermittedException;
+
+/**
+ * Class LazyFolder
+ *
+ * This is a lazy wrapper around a folder. So only
+ * once it is needed this will get initialized.
+ *
+ * @package OC\Files\Node
+ */
+class LazyFolder implements Folder {
+	/** @var \Closure(): Folder */
+	private \Closure $folderClosure;
+	protected ?Folder $folder = null;
+	protected IRootFolder $rootFolder;
+	protected array $data;
+
+	/**
+	 * @param IRootFolder $rootFolder
+	 * @param \Closure(): Folder $folderClosure
+	 * @param array $data
+	 */
+	public function __construct(IRootFolder $rootFolder, \Closure $folderClosure, array $data = []) {
+		$this->rootFolder = $rootFolder;
+		$this->folderClosure = $folderClosure;
+		$this->data = $data;
+	}
+
+	protected function getRootFolder(): IRootFolder {
+		return $this->rootFolder;
+	}
+
+	protected function getRealFolder(): Folder {
+		if ($this->folder === null) {
+			$this->folder = call_user_func($this->folderClosure);
+		}
+		return $this->folder;
+	}
+
+	/**
+	 * Magic method to first get the real rootFolder and then
+	 * call $method with $args on it
+	 *
+	 * @param $method
+	 * @param $args
+	 * @return mixed
+	 */
+	public function __call($method, $args) {
+		return call_user_func_array([$this->getRealFolder(), $method], $args);
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function getUser() {
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function listen($scope, $method, callable $callback) {
+		$this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function removeListener($scope = null, $method = null, callable $callback = null) {
+		$this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function emit($scope, $method, $arguments = []) {
+		$this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function mount($storage, $mountPoint, $arguments = []) {
+		$this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function getMount(string $mountPoint): IMountPoint {
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @return IMountPoint[]
+	 */
+	public function getMountsIn(string $mountPoint): array {
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function getMountByStorageId($storageId) {
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function getMountByNumericStorageId($numericId) {
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function unMount($mount) {
+		$this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function get($path) {
+		return $this->getRootFolder()->get($this->getFullPath($path));
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function rename($targetPath) {
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function delete() {
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function copy($targetPath) {
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function touch($mtime = null) {
+		$this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function getStorage() {
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function getPath() {
+		if (isset($this->data['path'])) {
+			return $this->data['path'];
+		}
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function getInternalPath() {
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function getId() {
+		if (isset($this->data['fileid'])) {
+			return $this->data['fileid'];
+		}
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function stat() {
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function getMTime() {
+		if (isset($this->data['mtime'])) {
+			return $this->data['mtime'];
+		}
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function getSize($includeMounts = true): int|float {
+		if (isset($this->data['size'])) {
+			return $this->data['size'];
+		}
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function getEtag() {
+		if (isset($this->data['etag'])) {
+			return $this->data['etag'];
+		}
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function getPermissions() {
+		if (isset($this->data['permissions'])) {
+			return $this->data['permissions'];
+		}
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function isReadable() {
+		if (isset($this->data['permissions'])) {
+			return ($this->data['permissions'] & Constants::PERMISSION_READ) == Constants::PERMISSION_READ;
+		}
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function isUpdateable() {
+		if (isset($this->data['permissions'])) {
+			return ($this->data['permissions'] & Constants::PERMISSION_UPDATE) == Constants::PERMISSION_UPDATE;
+		}
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function isDeletable() {
+		if (isset($this->data['permissions'])) {
+			return ($this->data['permissions'] & Constants::PERMISSION_DELETE) == Constants::PERMISSION_DELETE;
+		}
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function isShareable() {
+		if (isset($this->data['permissions'])) {
+			return ($this->data['permissions'] & Constants::PERMISSION_SHARE) == Constants::PERMISSION_SHARE;
+		}
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function getParent() {
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function getName() {
+		if (isset($this->data['path'])) {
+			return basename($this->data['path']);
+		}
+		if (isset($this->data['name'])) {
+			return $this->data['name'];
+		}
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function getUserFolder($userId) {
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function getMimetype() {
+		if (isset($this->data['mimetype'])) {
+			return $this->data['mimetype'];
+		}
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function getMimePart() {
+		if (isset($this->data['mimetype'])) {
+			[$part,] = explode('/', $this->data['mimetype']);
+			return $part;
+		}
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function isEncrypted() {
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function getType() {
+		if (isset($this->data['type'])) {
+			return $this->data['type'];
+		}
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function isShared() {
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function isMounted() {
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function getMountPoint() {
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function getOwner() {
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function getChecksum() {
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	public function getExtension(): string {
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function getFullPath($path) {
+		if (isset($this->data['path'])) {
+			$path = PathHelper::normalizePath($path);
+			if (!Filesystem::isValidPath($path)) {
+				throw new NotPermittedException('Invalid path "' . $path . '"');
+			}
+			return $this->data['path'] . $path;
+		}
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function isSubNode($node) {
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function getDirectoryListing() {
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function nodeExists($path) {
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function newFolder($path) {
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function newFile($path, $content = null) {
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function search($query) {
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function searchByMime($mimetype) {
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function searchByTag($tag, $userId) {
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	public function searchBySystemTag(string $tagName, string $userId, int $limit = 0, int $offset = 0) {
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function getById($id) {
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function getFreeSpace() {
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function isCreatable() {
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function getNonExistingName($name) {
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function move($targetPath) {
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function lock($type) {
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function changeLock($targetType) {
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function unlock($type) {
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function getRecent($limit, $offset = 0) {
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function getCreationTime(): int {
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function getUploadTime(): int {
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	public function getRelativePath($path) {
+		return PathHelper::getRelativePath($this->getPath(), $path);
+	}
+
+	public function getParentId(): int {
+		if (isset($this->data['parent'])) {
+			return $this->data['parent'];
+		}
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	/**
+	 * @inheritDoc
+	 * @return array<string, int|string|bool|float|string[]|int[]>
+	 */
+	public function getMetadata(): array {
+		return $this->data['metadata'] ?? $this->__call(__FUNCTION__, func_get_args());
+	}
+}

wedding-pics/lib/private/Files/Node/LazyRoot.php

@@ -0,0 +1,62 @@
+<?php
+/**
+ * @copyright Copyright (c) 2016, ownCloud, Inc.
+ *
+ * @author Robin Appelman <robin@icewind.nl>
+ * @author Roeland Jago Douma <roeland@famdouma.nl>
+ *
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License, version 3,
+ * along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+namespace OC\Files\Node;
+
+use OCP\Files\Cache\ICacheEntry;
+use OCP\Files\IRootFolder;
+use OCP\Files\Mount\IMountPoint;
+use OCP\Files\Node as INode;
+
+/**
+ * Class LazyRoot
+ *
+ * This is a lazy wrapper around the root. So only
+ * once it is needed this will get initialized.
+ *
+ * @package OC\Files\Node
+ */
+class LazyRoot extends LazyFolder implements IRootFolder {
+	public function __construct(\Closure $folderClosure, array $data = []) {
+		parent::__construct($this, $folderClosure, $data);
+	}
+
+	protected function getRootFolder(): IRootFolder {
+		$folder = $this->getRealFolder();
+		if (!$folder instanceof IRootFolder) {
+			throw new \Exception('Lazy root folder closure didn\'t return a root folder');
+		}
+		return $folder;
+	}
+
+	public function getUserFolder($userId) {
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	public function getByIdInPath(int $id, string $path) {
+		return $this->__call(__FUNCTION__, func_get_args());
+	}
+
+	public function getNodeFromCacheEntryAndMount(ICacheEntry $cacheEntry, IMountPoint $mountPoint): INode {
+		return $this->getRootFolder()->getNodeFromCacheEntryAndMount($cacheEntry, $mountPoint);
+	}
+}

wedding-pics/lib/private/Files/Node/LazyUserFolder.php

@@ -0,0 +1,93 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * @copyright Copyright (c) 2022 Robin Appelman <robin@icewind.nl>
+ *
+ * @license GNU AGPL version 3 or any later version
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+namespace OC\Files\Node;
+
+use OCP\Constants;
+use OCP\Files\File;
+use OCP\Files\FileInfo;
+use OCP\Files\Folder;
+use OCP\Files\IRootFolder;
+use OCP\Files\Mount\IMountManager;
+use OCP\Files\NotFoundException;
+use OCP\IUser;
+use Psr\Log\LoggerInterface;
+
+class LazyUserFolder extends LazyFolder {
+	private IUser $user;
+	private string $path;
+	private IMountManager $mountManager;
+
+	public function __construct(IRootFolder $rootFolder, IUser $user, IMountManager $mountManager) {
+		$this->user = $user;
+		$this->mountManager = $mountManager;
+		$this->path = '/' . $user->getUID() . '/files';
+		parent::__construct($rootFolder, function () use ($user): Folder {
+			try {
+				$node = $this->getRootFolder()->get($this->path);
+				if ($node instanceof File) {
+					$e = new \RuntimeException();
+					\OCP\Server::get(LoggerInterface::class)->error('User root storage is not a folder: ' . $this->path, [
+						'exception' => $e,
+					]);
+					throw $e;
+				}
+				return $node;
+			} catch (NotFoundException $e) {
+				if (!$this->getRootFolder()->nodeExists('/' . $user->getUID())) {
+					$this->getRootFolder()->newFolder('/' . $user->getUID());
+				}
+				return $this->getRootFolder()->newFolder($this->path);
+			}
+		}, [
+			'path' => $this->path,
+			// Sharing user root folder is not allowed
+			'permissions' => Constants::PERMISSION_ALL ^ Constants::PERMISSION_SHARE,
+			'type' => FileInfo::TYPE_FOLDER,
+			'mimetype' => FileInfo::MIMETYPE_FOLDER,
+		]);
+	}
+
+	public function get($path) {
+		return $this->getRootFolder()->get('/' . $this->user->getUID() . '/files/' . ltrim($path, '/'));
+	}
+
+	/**
+	 * @param int $id
+	 * @return \OCP\Files\Node[]
+	 */
+	public function getById($id) {
+		return $this->getRootFolder()->getByIdInPath((int)$id, $this->getPath());
+	}
+
+	public function getMountPoint() {
+		if ($this->folder !== null) {
+			return $this->folder->getMountPoint();
+		}
+		$mountPoint = $this->mountManager->find('/' . $this->user->getUID());
+		if (is_null($mountPoint)) {
+			throw new \Exception("No mountpoint for user folder");
+		}
+		return $mountPoint;
+	}
+}

wedding-pics/lib/private/Files/Node/Node.php

@@ -0,0 +1,509 @@
+<?php
+/**
+ * @copyright Copyright (c) 2016, ownCloud, Inc.
+ *
+ * @author Arthur Schiwon <blizzz@arthur-schiwon.de>
+ * @author Bernhard Posselt <dev@bernhard-posselt.com>
+ * @author Christoph Wurst <christoph@winzerhof-wurst.at>
+ * @author Joas Schilling <coding@schilljs.com>
+ * @author Julius Härtl <jus@bitgrid.net>
+ * @author Maxence Lange <maxence@artificial-owl.com>
+ * @author Morris Jobke <hey@morrisjobke.de>
+ * @author Robin Appelman <robin@icewind.nl>
+ * @author Roeland Jago Douma <roeland@famdouma.nl>
+ * @author Vincent Petry <vincent@nextcloud.com>
+ *
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License, version 3,
+ * along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+namespace OC\Files\Node;
+
+use OC\Files\Filesystem;
+use OC\Files\Mount\MoveableMount;
+use OC\Files\Utils\PathHelper;
+use OCP\EventDispatcher\GenericEvent;
+use OCP\EventDispatcher\IEventDispatcher;
+use OCP\Files\FileInfo;
+use OCP\Files\InvalidPathException;
+use OCP\Files\IRootFolder;
+use OCP\Files\Node as INode;
+use OCP\Files\NotFoundException;
+use OCP\Files\NotPermittedException;
+use OCP\Lock\LockedException;
+use OCP\PreConditionNotMetException;
+
+// FIXME: this class really should be abstract (+1)
+class Node implements INode {
+	/**
+	 * @var \OC\Files\View $view
+	 */
+	protected $view;
+
+	protected IRootFolder $root;
+
+	/**
+	 * @var string $path Absolute path to the node (e.g. /admin/files/folder/file)
+	 */
+	protected $path;
+
+	protected ?FileInfo $fileInfo;
+
+	protected ?INode $parent;
+
+	private bool $infoHasSubMountsIncluded;
+
+	/**
+	 * @param \OC\Files\View $view
+	 * @param \OCP\Files\IRootFolder $root
+	 * @param string $path
+	 * @param FileInfo $fileInfo
+	 */
+	public function __construct(IRootFolder $root, $view, $path, $fileInfo = null, ?INode $parent = null, bool $infoHasSubMountsIncluded = true) {
+		if (Filesystem::normalizePath($view->getRoot()) !== '/') {
+			throw new PreConditionNotMetException('The view passed to the node should not have any fake root set');
+		}
+		$this->view = $view;
+		$this->root = $root;
+		$this->path = $path;
+		$this->fileInfo = $fileInfo;
+		$this->parent = $parent;
+		$this->infoHasSubMountsIncluded = $infoHasSubMountsIncluded;
+	}
+
+	/**
+	 * Creates a Node of the same type that represents a non-existing path
+	 *
+	 * @param string $path path
+	 * @return Node non-existing node
+	 * @throws \Exception
+	 */
+	protected function createNonExistingNode($path) {
+		throw new \Exception('Must be implemented by subclasses');
+	}
+
+	/**
+	 * Returns the matching file info
+	 *
+	 * @return FileInfo
+	 * @throws InvalidPathException
+	 * @throws NotFoundException
+	 */
+	public function getFileInfo(bool $includeMountPoint = true) {
+		if (!$this->fileInfo) {
+			if (!Filesystem::isValidPath($this->path)) {
+				throw new InvalidPathException();
+			}
+			$fileInfo = $this->view->getFileInfo($this->path, $includeMountPoint);
+			$this->infoHasSubMountsIncluded = $includeMountPoint;
+			if ($fileInfo instanceof FileInfo) {
+				$this->fileInfo = $fileInfo;
+			} else {
+				throw new NotFoundException();
+			}
+		} elseif ($includeMountPoint && !$this->infoHasSubMountsIncluded && $this instanceof Folder) {
+			if ($this->fileInfo instanceof \OC\Files\FileInfo) {
+				$this->view->addSubMounts($this->fileInfo);
+			}
+			$this->infoHasSubMountsIncluded = true;
+		}
+		return $this->fileInfo;
+	}
+
+	/**
+	 * @param string[] $hooks
+	 */
+	protected function sendHooks($hooks, array $args = null) {
+		$args = !empty($args) ? $args : [$this];
+		/** @var IEventDispatcher $dispatcher */
+		$dispatcher = \OC::$server->get(IEventDispatcher::class);
+		foreach ($hooks as $hook) {
+			if (method_exists($this->root, 'emit')) {
+				$this->root->emit('\OC\Files', $hook, $args);
+			}
+
+			if (in_array($hook, ['preWrite', 'postWrite', 'preCreate', 'postCreate', 'preTouch', 'postTouch', 'preDelete', 'postDelete'], true)) {
+				$event = new GenericEvent($args[0]);
+			} else {
+				$event = new GenericEvent($args);
+			}
+
+			$dispatcher->dispatch('\OCP\Files::' . $hook, $event);
+		}
+	}
+
+	/**
+	 * @param int $permissions
+	 * @return bool
+	 * @throws InvalidPathException
+	 * @throws NotFoundException
+	 */
+	protected function checkPermissions($permissions) {
+		return ($this->getPermissions() & $permissions) === $permissions;
+	}
+
+	public function delete() {
+	}
+
+	/**
+	 * @param int $mtime
+	 * @throws InvalidPathException
+	 * @throws NotFoundException
+	 * @throws NotPermittedException
+	 */
+	public function touch($mtime = null) {
+		if ($this->checkPermissions(\OCP\Constants::PERMISSION_UPDATE)) {
+			$this->sendHooks(['preTouch']);
+			$this->view->touch($this->path, $mtime);
+			$this->sendHooks(['postTouch']);
+			if ($this->fileInfo) {
+				if (is_null($mtime)) {
+					$mtime = time();
+				}
+				$this->fileInfo['mtime'] = $mtime;
+			}
+		} else {
+			throw new NotPermittedException();
+		}
+	}
+
+	public function getStorage() {
+		$storage = $this->getMountPoint()->getStorage();
+		if (!$storage) {
+			throw new \Exception("No storage for node");
+		}
+		return $storage;
+	}
+
+	/**
+	 * @return string
+	 */
+	public function getPath() {
+		return $this->path;
+	}
+
+	/**
+	 * @return string
+	 */
+	public function getInternalPath() {
+		return $this->getFileInfo(false)->getInternalPath();
+	}
+
+	/**
+	 * @return int
+	 * @throws InvalidPathException
+	 * @throws NotFoundException
+	 */
+	public function getId() {
+		return $this->getFileInfo(false)->getId() ?? -1;
+	}
+
+	/**
+	 * @return array
+	 */
+	public function stat() {
+		return $this->view->stat($this->path);
+	}
+
+	/**
+	 * @return int
+	 * @throws InvalidPathException
+	 * @throws NotFoundException
+	 */
+	public function getMTime() {
+		return $this->getFileInfo()->getMTime();
+	}
+
+	/**
+	 * @param bool $includeMounts
+	 * @return int|float
+	 * @throws InvalidPathException
+	 * @throws NotFoundException
+	 */
+	public function getSize($includeMounts = true): int|float {
+		return $this->getFileInfo()->getSize($includeMounts);
+	}
+
+	/**
+	 * @return string
+	 * @throws InvalidPathException
+	 * @throws NotFoundException
+	 */
+	public function getEtag() {
+		return $this->getFileInfo()->getEtag();
+	}
+
+	/**
+	 * @return int
+	 * @throws InvalidPathException
+	 * @throws NotFoundException
+	 */
+	public function getPermissions() {
+		return $this->getFileInfo(false)->getPermissions();
+	}
+
+	/**
+	 * @return bool
+	 * @throws InvalidPathException
+	 * @throws NotFoundException
+	 */
+	public function isReadable() {
+		return $this->getFileInfo(false)->isReadable();
+	}
+
+	/**
+	 * @return bool
+	 * @throws InvalidPathException
+	 * @throws NotFoundException
+	 */
+	public function isUpdateable() {
+		return $this->getFileInfo(false)->isUpdateable();
+	}
+
+	/**
+	 * @return bool
+	 * @throws InvalidPathException
+	 * @throws NotFoundException
+	 */
+	public function isDeletable() {
+		return $this->getFileInfo(false)->isDeletable();
+	}
+
+	/**
+	 * @return bool
+	 * @throws InvalidPathException
+	 * @throws NotFoundException
+	 */
+	public function isShareable() {
+		return $this->getFileInfo(false)->isShareable();
+	}
+
+	/**
+	 * @return bool
+	 * @throws InvalidPathException
+	 * @throws NotFoundException
+	 */
+	public function isCreatable() {
+		return $this->getFileInfo(false)->isCreatable();
+	}
+
+	public function getParent(): INode|IRootFolder {
+		if ($this->parent === null) {
+			$newPath = dirname($this->path);
+			if ($newPath === '' || $newPath === '.' || $newPath === '/') {
+				return $this->root;
+			}
+
+			// Manually fetch the parent if the current node doesn't have a file info yet
+			try {
+				$fileInfo = $this->getFileInfo();
+			} catch (NotFoundException) {
+				$this->parent = $this->root->get($newPath);
+				/** @var \OCP\Files\Folder $this->parent */
+				return $this->parent;
+			}
+
+			// gather the metadata we already know about our parent
+			$parentData = [
+				'path' => $newPath,
+				'fileid' => $fileInfo->getParentId(),
+			];
+
+			// and create lazy folder with it instead of always querying
+			$this->parent = new LazyFolder($this->root, function () use ($newPath) {
+				return $this->root->get($newPath);
+			}, $parentData);
+		}
+
+		return $this->parent;
+	}
+
+	/**
+	 * @return string
+	 */
+	public function getName() {
+		return basename($this->path);
+	}
+
+	/**
+	 * @param string $path
+	 * @return string
+	 */
+	protected function normalizePath($path) {
+		return PathHelper::normalizePath($path);
+	}
+
+	/**
+	 * check if the requested path is valid
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function isValidPath($path) {
+		return Filesystem::isValidPath($path);
+	}
+
+	public function isMounted() {
+		return $this->getFileInfo(false)->isMounted();
+	}
+
+	public function isShared() {
+		return $this->getFileInfo(false)->isShared();
+	}
+
+	public function getMimeType() {
+		return $this->getFileInfo(false)->getMimetype();
+	}
+
+	public function getMimePart() {
+		return $this->getFileInfo(false)->getMimePart();
+	}
+
+	public function getType() {
+		return $this->getFileInfo(false)->getType();
+	}
+
+	public function isEncrypted() {
+		return $this->getFileInfo(false)->isEncrypted();
+	}
+
+	public function getMountPoint() {
+		return $this->getFileInfo(false)->getMountPoint();
+	}
+
+	public function getOwner() {
+		return $this->getFileInfo(false)->getOwner();
+	}
+
+	public function getChecksum() {
+	}
+
+	public function getExtension(): string {
+		return $this->getFileInfo(false)->getExtension();
+	}
+
+	/**
+	 * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
+	 * @throws LockedException
+	 */
+	public function lock($type) {
+		$this->view->lockFile($this->path, $type);
+	}
+
+	/**
+	 * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
+	 * @throws LockedException
+	 */
+	public function changeLock($type) {
+		$this->view->changeLock($this->path, $type);
+	}
+
+	/**
+	 * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
+	 * @throws LockedException
+	 */
+	public function unlock($type) {
+		$this->view->unlockFile($this->path, $type);
+	}
+
+	/**
+	 * @param string $targetPath
+	 * @return INode
+	 * @throws InvalidPathException
+	 * @throws NotFoundException
+	 * @throws NotPermittedException if copy not allowed or failed
+	 */
+	public function copy($targetPath) {
+		$targetPath = $this->normalizePath($targetPath);
+		$parent = $this->root->get(dirname($targetPath));
+		if ($parent instanceof Folder and $this->isValidPath($targetPath) and $parent->isCreatable()) {
+			$nonExisting = $this->createNonExistingNode($targetPath);
+			$this->sendHooks(['preCopy'], [$this, $nonExisting]);
+			$this->sendHooks(['preWrite'], [$nonExisting]);
+			if (!$this->view->copy($this->path, $targetPath)) {
+				throw new NotPermittedException('Could not copy ' . $this->path . ' to ' . $targetPath);
+			}
+			$targetNode = $this->root->get($targetPath);
+			$this->sendHooks(['postCopy'], [$this, $targetNode]);
+			$this->sendHooks(['postWrite'], [$targetNode]);
+			return $targetNode;
+		} else {
+			throw new NotPermittedException('No permission to copy to path ' . $targetPath);
+		}
+	}
+
+	/**
+	 * @param string $targetPath
+	 * @return INode
+	 * @throws InvalidPathException
+	 * @throws NotFoundException
+	 * @throws NotPermittedException if move not allowed or failed
+	 * @throws LockedException
+	 */
+	public function move($targetPath) {
+		$targetPath = $this->normalizePath($targetPath);
+		$parent = $this->root->get(dirname($targetPath));
+		if (
+			$parent instanceof Folder and
+			$this->isValidPath($targetPath) and
+			(
+				$parent->isCreatable() ||
+				($parent->getInternalPath() === '' && $parent->getMountPoint() instanceof MoveableMount)
+			)
+		) {
+			$nonExisting = $this->createNonExistingNode($targetPath);
+			$this->sendHooks(['preRename'], [$this, $nonExisting]);
+			$this->sendHooks(['preWrite'], [$nonExisting]);
+			if (!$this->view->rename($this->path, $targetPath)) {
+				throw new NotPermittedException('Could not move ' . $this->path . ' to ' . $targetPath);
+			}
+
+			$mountPoint = $this->getMountPoint();
+			if ($mountPoint) {
+				// update the cached fileinfo with the new (internal) path
+				/** @var \OC\Files\FileInfo $oldFileInfo */
+				$oldFileInfo = $this->getFileInfo();
+				$this->fileInfo = new \OC\Files\FileInfo($targetPath, $oldFileInfo->getStorage(), $mountPoint->getInternalPath($targetPath), $oldFileInfo->getData(), $mountPoint, $oldFileInfo->getOwner());
+			}
+
+			$targetNode = $this->root->get($targetPath);
+			$this->sendHooks(['postRename'], [$this, $targetNode]);
+			$this->sendHooks(['postWrite'], [$targetNode]);
+			$this->path = $targetPath;
+			return $targetNode;
+		} else {
+			throw new NotPermittedException('No permission to move to path ' . $targetPath);
+		}
+	}
+
+	public function getCreationTime(): int {
+		return $this->getFileInfo()->getCreationTime();
+	}
+
+	public function getUploadTime(): int {
+		return $this->getFileInfo()->getUploadTime();
+	}
+
+	public function getParentId(): int {
+		return $this->fileInfo->getParentId();
+	}
+
+	/**
+	 * @inheritDoc
+	 * @return array<string, int|string|bool|float|string[]|int[]>
+	 */
+	public function getMetadata(): array {
+		return $this->fileInfo->getMetadata();
+	}
+}

wedding-pics/lib/private/Files/Node/NonExistingFile.php

@@ -0,0 +1,143 @@
+<?php
+/**
+ * @copyright Copyright (c) 2016, ownCloud, Inc.
+ *
+ * @author Morris Jobke <hey@morrisjobke.de>
+ * @author Robin Appelman <robin@icewind.nl>
+ *
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License, version 3,
+ * along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+namespace OC\Files\Node;
+
+use OCP\Files\NotFoundException;
+
+class NonExistingFile extends File {
+	/**
+	 * @param string $newPath
+	 * @throws \OCP\Files\NotFoundException
+	 */
+	public function rename($newPath) {
+		throw new NotFoundException();
+	}
+
+	public function delete() {
+		throw new NotFoundException();
+	}
+
+	public function copy($targetPath) {
+		throw new NotFoundException();
+	}
+
+	public function touch($mtime = null) {
+		throw new NotFoundException();
+	}
+
+	public function getId() {
+		if ($this->fileInfo) {
+			return parent::getId();
+		} else {
+			throw new NotFoundException();
+		}
+	}
+
+	public function stat() {
+		throw new NotFoundException();
+	}
+
+	public function getMTime() {
+		if ($this->fileInfo) {
+			return parent::getMTime();
+		} else {
+			throw new NotFoundException();
+		}
+	}
+
+	public function getSize($includeMounts = true): int|float {
+		if ($this->fileInfo) {
+			return parent::getSize($includeMounts);
+		} else {
+			throw new NotFoundException();
+		}
+	}
+
+	public function getEtag() {
+		if ($this->fileInfo) {
+			return parent::getEtag();
+		} else {
+			throw new NotFoundException();
+		}
+	}
+
+	public function getPermissions() {
+		if ($this->fileInfo) {
+			return parent::getPermissions();
+		} else {
+			throw new NotFoundException();
+		}
+	}
+
+	public function isReadable() {
+		if ($this->fileInfo) {
+			return parent::isReadable();
+		} else {
+			throw new NotFoundException();
+		}
+	}
+
+	public function isUpdateable() {
+		if ($this->fileInfo) {
+			return parent::isUpdateable();
+		} else {
+			throw new NotFoundException();
+		}
+	}
+
+	public function isDeletable() {
+		if ($this->fileInfo) {
+			return parent::isDeletable();
+		} else {
+			throw new NotFoundException();
+		}
+	}
+
+	public function isShareable() {
+		if ($this->fileInfo) {
+			return parent::isShareable();
+		} else {
+			throw new NotFoundException();
+		}
+	}
+
+	public function getContent() {
+		throw new NotFoundException();
+	}
+
+	public function putContent($data) {
+		throw new NotFoundException();
+	}
+
+	public function getMimeType() {
+		if ($this->fileInfo) {
+			return parent::getMimeType();
+		} else {
+			throw new NotFoundException();
+		}
+	}
+
+	public function fopen($mode) {
+		throw new NotFoundException();
+	}
+}

wedding-pics/lib/private/Files/Node/NonExistingFolder.php

@@ -0,0 +1,176 @@
+<?php
+/**
+ * @copyright Copyright (c) 2016, ownCloud, Inc.
+ *
+ * @author Morris Jobke <hey@morrisjobke.de>
+ * @author Robin Appelman <robin@icewind.nl>
+ * @author Vincent Petry <vincent@nextcloud.com>
+ *
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License, version 3,
+ * along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+namespace OC\Files\Node;
+
+use OCP\Files\NotFoundException;
+
+class NonExistingFolder extends Folder {
+	/**
+	 * @param string $newPath
+	 * @throws \OCP\Files\NotFoundException
+	 */
+	public function rename($newPath) {
+		throw new NotFoundException();
+	}
+
+	public function delete() {
+		throw new NotFoundException();
+	}
+
+	public function copy($targetPath) {
+		throw new NotFoundException();
+	}
+
+	public function touch($mtime = null) {
+		throw new NotFoundException();
+	}
+
+	public function getId() {
+		if ($this->fileInfo) {
+			return parent::getId();
+		} else {
+			throw new NotFoundException();
+		}
+	}
+
+	public function stat() {
+		throw new NotFoundException();
+	}
+
+	public function getMTime() {
+		if ($this->fileInfo) {
+			return parent::getMTime();
+		} else {
+			throw new NotFoundException();
+		}
+	}
+
+	public function getSize($includeMounts = true): int|float {
+		if ($this->fileInfo) {
+			return parent::getSize($includeMounts);
+		} else {
+			throw new NotFoundException();
+		}
+	}
+
+	public function getEtag() {
+		if ($this->fileInfo) {
+			return parent::getEtag();
+		} else {
+			throw new NotFoundException();
+		}
+	}
+
+	public function getPermissions() {
+		if ($this->fileInfo) {
+			return parent::getPermissions();
+		} else {
+			throw new NotFoundException();
+		}
+	}
+
+	public function isReadable() {
+		if ($this->fileInfo) {
+			return parent::isReadable();
+		} else {
+			throw new NotFoundException();
+		}
+	}
+
+	public function isUpdateable() {
+		if ($this->fileInfo) {
+			return parent::isUpdateable();
+		} else {
+			throw new NotFoundException();
+		}
+	}
+
+	public function isDeletable() {
+		if ($this->fileInfo) {
+			return parent::isDeletable();
+		} else {
+			throw new NotFoundException();
+		}
+	}
+
+	public function isShareable() {
+		if ($this->fileInfo) {
+			return parent::isShareable();
+		} else {
+			throw new NotFoundException();
+		}
+	}
+
+	public function get($path) {
+		throw new NotFoundException();
+	}
+
+	public function getDirectoryListing() {
+		throw new NotFoundException();
+	}
+
+	public function nodeExists($path) {
+		return false;
+	}
+
+	public function newFolder($path) {
+		throw new NotFoundException();
+	}
+
+	public function newFile($path, $content = null) {
+		throw new NotFoundException();
+	}
+
+	public function search($query) {
+		throw new NotFoundException();
+	}
+
+	public function searchByMime($mimetype) {
+		throw new NotFoundException();
+	}
+
+	public function searchByTag($tag, $userId) {
+		throw new NotFoundException();
+	}
+
+	public function searchBySystemTag(string $tagName, string $userId, int $limit = 0, int $offset = 0): array {
+		throw new NotFoundException();
+	}
+
+	public function getById($id) {
+		throw new NotFoundException();
+	}
+
+	public function getFreeSpace() {
+		throw new NotFoundException();
+	}
+
+	public function isCreatable() {
+		if ($this->fileInfo) {
+			return parent::isCreatable();
+		} else {
+			throw new NotFoundException();
+		}
+	}
+}

wedding-pics/lib/private/Files/Node/Root.php

@@ -0,0 +1,516 @@
+<?php
+/**
+ * @copyright Copyright (c) 2016, ownCloud, Inc.
+ *
+ * @author Bernhard Posselt <dev@bernhard-posselt.com>
+ * @author Christoph Wurst <christoph@winzerhof-wurst.at>
+ * @author Joas Schilling <coding@schilljs.com>
+ * @author Jörn Friedrich Dreyer <jfd@butonic.de>
+ * @author Julius Härtl <jus@bitgrid.net>
+ * @author Lukas Reschke <lukas@statuscode.ch>
+ * @author Morris Jobke <hey@morrisjobke.de>
+ * @author Robin Appelman <robin@icewind.nl>
+ * @author Roeland Jago Douma <roeland@famdouma.nl>
+ * @author Stefan Weil <sw@weilnetz.de>
+ * @author Vincent Petry <vincent@nextcloud.com>
+ *
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License, version 3,
+ * along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+
+namespace OC\Files\Node;
+
+use OC\Files\FileInfo;
+use OC\Files\Mount\Manager;
+use OC\Files\Mount\MountPoint;
+use OC\Files\Utils\PathHelper;
+use OC\Files\View;
+use OC\Hooks\PublicEmitter;
+use OC\User\NoUserException;
+use OCP\Cache\CappedMemoryCache;
+use OCP\EventDispatcher\IEventDispatcher;
+use OCP\Files\Cache\ICacheEntry;
+use OCP\Files\Config\IUserMountCache;
+use OCP\Files\Events\Node\FilesystemTornDownEvent;
+use OCP\Files\IRootFolder;
+use OCP\Files\Mount\IMountPoint;
+use OCP\Files\Node as INode;
+use OCP\Files\NotFoundException;
+use OCP\Files\NotPermittedException;
+use OCP\IUser;
+use OCP\IUserManager;
+use Psr\Log\LoggerInterface;
+
+/**
+ * Class Root
+ *
+ * Hooks available in scope \OC\Files
+ * - preWrite(\OCP\Files\Node $node)
+ * - postWrite(\OCP\Files\Node $node)
+ * - preCreate(\OCP\Files\Node $node)
+ * - postCreate(\OCP\Files\Node $node)
+ * - preDelete(\OCP\Files\Node $node)
+ * - postDelete(\OCP\Files\Node $node)
+ * - preTouch(\OC\FilesP\Node $node, int $mtime)
+ * - postTouch(\OCP\Files\Node $node)
+ * - preCopy(\OCP\Files\Node $source, \OCP\Files\Node $target)
+ * - postCopy(\OCP\Files\Node $source, \OCP\Files\Node $target)
+ * - preRename(\OCP\Files\Node $source, \OCP\Files\Node $target)
+ * - postRename(\OCP\Files\Node $source, \OCP\Files\Node $target)
+ *
+ * @package OC\Files\Node
+ */
+class Root extends Folder implements IRootFolder {
+	private Manager $mountManager;
+	private PublicEmitter $emitter;
+	private ?IUser $user;
+	private CappedMemoryCache $userFolderCache;
+	private IUserMountCache $userMountCache;
+	private LoggerInterface $logger;
+	private IUserManager $userManager;
+	private IEventDispatcher $eventDispatcher;
+
+	/**
+	 * @param Manager $manager
+	 * @param View $view
+	 * @param IUser|null $user
+	 */
+	public function __construct(
+		$manager,
+		$view,
+		$user,
+		IUserMountCache $userMountCache,
+		LoggerInterface $logger,
+		IUserManager $userManager,
+		IEventDispatcher $eventDispatcher
+	) {
+		parent::__construct($this, $view, '');
+		$this->mountManager = $manager;
+		$this->user = $user;
+		$this->emitter = new PublicEmitter();
+		$this->userFolderCache = new CappedMemoryCache();
+		$this->userMountCache = $userMountCache;
+		$this->logger = $logger;
+		$this->userManager = $userManager;
+		$eventDispatcher->addListener(FilesystemTornDownEvent::class, function () {
+			$this->userFolderCache = new CappedMemoryCache();
+		});
+	}
+
+	/**
+	 * Get the user for which the filesystem is setup
+	 *
+	 * @return \OC\User\User
+	 */
+	public function getUser() {
+		return $this->user;
+	}
+
+	/**
+	 * @param string $scope
+	 * @param string $method
+	 * @param callable $callback
+	 */
+	public function listen($scope, $method, callable $callback) {
+		$this->emitter->listen($scope, $method, $callback);
+	}
+
+	/**
+	 * @param string $scope optional
+	 * @param string $method optional
+	 * @param callable $callback optional
+	 */
+	public function removeListener($scope = null, $method = null, callable $callback = null) {
+		$this->emitter->removeListener($scope, $method, $callback);
+	}
+
+	/**
+	 * @param string $scope
+	 * @param string $method
+	 * @param Node[] $arguments
+	 */
+	public function emit($scope, $method, $arguments = []) {
+		$this->emitter->emit($scope, $method, $arguments);
+	}
+
+	/**
+	 * @param \OC\Files\Storage\Storage $storage
+	 * @param string $mountPoint
+	 * @param array $arguments
+	 */
+	public function mount($storage, $mountPoint, $arguments = []) {
+		$mount = new MountPoint($storage, $mountPoint, $arguments);
+		$this->mountManager->addMount($mount);
+	}
+
+	public function getMount(string $mountPoint): IMountPoint {
+		return $this->mountManager->find($mountPoint);
+	}
+
+	/**
+	 * @param string $mountPoint
+	 * @return \OC\Files\Mount\MountPoint[]
+	 */
+	public function getMountsIn(string $mountPoint): array {
+		return $this->mountManager->findIn($mountPoint);
+	}
+
+	/**
+	 * @param string $storageId
+	 * @return \OC\Files\Mount\MountPoint[]
+	 */
+	public function getMountByStorageId($storageId) {
+		return $this->mountManager->findByStorageId($storageId);
+	}
+
+	/**
+	 * @param int $numericId
+	 * @return MountPoint[]
+	 */
+	public function getMountByNumericStorageId($numericId) {
+		return $this->mountManager->findByNumericId($numericId);
+	}
+
+	/**
+	 * @param \OC\Files\Mount\MountPoint $mount
+	 */
+	public function unMount($mount) {
+		$this->mountManager->remove($mount);
+	}
+
+	/**
+	 * @param string $path
+	 * @return Node
+	 * @throws \OCP\Files\NotPermittedException
+	 * @throws \OCP\Files\NotFoundException
+	 */
+	public function get($path) {
+		$path = $this->normalizePath($path);
+		if ($this->isValidPath($path)) {
+			$fullPath = $this->getFullPath($path);
+			$fileInfo = $this->view->getFileInfo($fullPath, false);
+			if ($fileInfo) {
+				return $this->createNode($fullPath, $fileInfo, false);
+			} else {
+				throw new NotFoundException($path);
+			}
+		} else {
+			throw new NotPermittedException();
+		}
+	}
+
+	//most operations can't be done on the root
+
+	/**
+	 * @param string $targetPath
+	 * @return Node
+	 * @throws \OCP\Files\NotPermittedException
+	 */
+	public function rename($targetPath) {
+		throw new NotPermittedException();
+	}
+
+	public function delete() {
+		throw new NotPermittedException();
+	}
+
+	/**
+	 * @param string $targetPath
+	 * @return Node
+	 * @throws \OCP\Files\NotPermittedException
+	 */
+	public function copy($targetPath) {
+		throw new NotPermittedException();
+	}
+
+	/**
+	 * @param int $mtime
+	 * @throws \OCP\Files\NotPermittedException
+	 */
+	public function touch($mtime = null) {
+		throw new NotPermittedException();
+	}
+
+	/**
+	 * @return \OC\Files\Storage\Storage
+	 * @throws \OCP\Files\NotFoundException
+	 */
+	public function getStorage() {
+		throw new NotFoundException();
+	}
+
+	/**
+	 * @return string
+	 */
+	public function getPath() {
+		return '/';
+	}
+
+	/**
+	 * @return string
+	 */
+	public function getInternalPath() {
+		return '';
+	}
+
+	/**
+	 * @return int
+	 */
+	public function getId() {
+		return 0;
+	}
+
+	/**
+	 * @return array
+	 */
+	public function stat() {
+		return [];
+	}
+
+	/**
+	 * @return int
+	 */
+	public function getMTime() {
+		return 0;
+	}
+
+	/**
+	 * @param bool $includeMounts
+	 * @return int|float
+	 */
+	public function getSize($includeMounts = true): int|float {
+		return 0;
+	}
+
+	/**
+	 * @return string
+	 */
+	public function getEtag() {
+		return '';
+	}
+
+	/**
+	 * @return int
+	 */
+	public function getPermissions() {
+		return \OCP\Constants::PERMISSION_CREATE;
+	}
+
+	/**
+	 * @return bool
+	 */
+	public function isReadable() {
+		return false;
+	}
+
+	/**
+	 * @return bool
+	 */
+	public function isUpdateable() {
+		return false;
+	}
+
+	/**
+	 * @return bool
+	 */
+	public function isDeletable() {
+		return false;
+	}
+
+	/**
+	 * @return bool
+	 */
+	public function isShareable() {
+		return false;
+	}
+
+	/**
+	 * @throws \OCP\Files\NotFoundException
+	 */
+	public function getParent(): INode|IRootFolder {
+		throw new NotFoundException();
+	}
+
+	/**
+	 * @return string
+	 */
+	public function getName() {
+		return '';
+	}
+
+	/**
+	 * Returns a view to user's files folder
+	 *
+	 * @param string $userId user ID
+	 * @return \OCP\Files\Folder
+	 * @throws NoUserException
+	 * @throws NotPermittedException
+	 */
+	public function getUserFolder($userId) {
+		$userObject = $this->userManager->get($userId);
+
+		if (is_null($userObject)) {
+			$e = new NoUserException('Backends provided no user object');
+			$this->logger->error(
+				sprintf(
+					'Backends provided no user object for %s',
+					$userId
+				),
+				[
+					'app' => 'files',
+					'exception' => $e,
+				]
+			);
+			throw $e;
+		}
+
+		$userId = $userObject->getUID();
+
+		if (!$this->userFolderCache->hasKey($userId)) {
+			if ($this->mountManager->getSetupManager()->isSetupComplete($userObject)) {
+				try {
+					$folder = $this->get('/' . $userId . '/files');
+					if (!$folder instanceof \OCP\Files\Folder) {
+						throw new \Exception("User folder for $userId exists as a file");
+					}
+				} catch (NotFoundException $e) {
+					if (!$this->nodeExists('/' . $userId)) {
+						$this->newFolder('/' . $userId);
+					}
+					$folder = $this->newFolder('/' . $userId . '/files');
+				}
+			} else {
+				$folder = new LazyUserFolder($this, $userObject, $this->mountManager);
+			}
+
+			$this->userFolderCache->set($userId, $folder);
+		}
+
+		return $this->userFolderCache->get($userId);
+	}
+
+	public function getUserMountCache() {
+		return $this->userMountCache;
+	}
+
+	/**
+	 * @param int $id
+	 * @return Node[]
+	 */
+	public function getByIdInPath(int $id, string $path): array {
+		$mountCache = $this->getUserMountCache();
+		if (strpos($path, '/', 1) > 0) {
+			[, $user] = explode('/', $path);
+		} else {
+			$user = null;
+		}
+		$mountsContainingFile = $mountCache->getMountsForFileId($id, $user);
+
+		// if the mount isn't in the cache yet, perform a setup first, then try again
+		if (count($mountsContainingFile) === 0) {
+			$this->mountManager->getSetupManager()->setupForPath($path, true);
+			$mountsContainingFile = $mountCache->getMountsForFileId($id, $user);
+		}
+
+		// when a user has access through the same storage through multiple paths
+		// (such as an external storage that is both mounted for a user and shared to the user)
+		// the mount cache will only hold a single entry for the storage
+		// this can lead to issues as the different ways the user has access to a storage can have different permissions
+		//
+		// so instead of using the cached entries directly, we instead filter the current mounts by the rootid of the cache entry
+
+		$mountRootIds = array_map(function ($mount) {
+			return $mount->getRootId();
+		}, $mountsContainingFile);
+		$mountRootPaths = array_map(function ($mount) {
+			return $mount->getRootInternalPath();
+		}, $mountsContainingFile);
+		$mountProviders = array_unique(array_map(function ($mount) {
+			return $mount->getMountProvider();
+		}, $mountsContainingFile));
+		$mountRoots = array_combine($mountRootIds, $mountRootPaths);
+
+		$mounts = $this->mountManager->getMountsByMountProvider($path, $mountProviders);
+
+		$mountsContainingFile = array_filter($mounts, function ($mount) use ($mountRoots) {
+			return isset($mountRoots[$mount->getStorageRootId()]);
+		});
+
+		if (count($mountsContainingFile) === 0) {
+			if ($user === $this->getAppDataDirectoryName()) {
+				$folder = $this->get($path);
+				if ($folder instanceof Folder) {
+					return $folder->getByIdInRootMount($id);
+				} else {
+					throw new \Exception("getByIdInPath with non folder");
+				}
+			}
+			return [];
+		}
+
+		$nodes = array_map(function (IMountPoint $mount) use ($id, $mountRoots) {
+			$rootInternalPath = $mountRoots[$mount->getStorageRootId()];
+			$cacheEntry = $mount->getStorage()->getCache()->get($id);
+			if (!$cacheEntry) {
+				return null;
+			}
+
+			// cache jails will hide the "true" internal path
+			$internalPath = ltrim($rootInternalPath . '/' . $cacheEntry->getPath(), '/');
+			$pathRelativeToMount = substr($internalPath, strlen($rootInternalPath));
+			$pathRelativeToMount = ltrim($pathRelativeToMount, '/');
+			$absolutePath = rtrim($mount->getMountPoint() . $pathRelativeToMount, '/');
+			return $this->createNode($absolutePath, new FileInfo(
+				$absolutePath, $mount->getStorage(), $cacheEntry->getPath(), $cacheEntry, $mount,
+				\OC::$server->getUserManager()->get($mount->getStorage()->getOwner($pathRelativeToMount))
+			));
+		}, $mountsContainingFile);
+
+		$nodes = array_filter($nodes);
+
+		$folders = array_filter($nodes, function (Node $node) use ($path) {
+			return PathHelper::getRelativePath($path, $node->getPath()) !== null;
+		});
+		usort($folders, function ($a, $b) {
+			return $b->getPath() <=> $a->getPath();
+		});
+		return $folders;
+	}
+
+	public function getNodeFromCacheEntryAndMount(ICacheEntry $cacheEntry, IMountPoint $mountPoint): INode {
+		$path = $cacheEntry->getPath();
+		$fullPath = $mountPoint->getMountPoint() . $path;
+		// todo: LazyNode?
+		$info = new FileInfo($fullPath, $mountPoint->getStorage(), $path, $cacheEntry, $mountPoint);
+		$parentPath = dirname($fullPath);
+		$parent = new LazyFolder($this, function () use ($parentPath) {
+			$parent = $this->get($parentPath);
+			if ($parent instanceof \OCP\Files\Folder) {
+				return $parent;
+			} else {
+				throw new \Exception("parent $parentPath is not a folder");
+			}
+		}, [
+			'path' => $parentPath,
+		]);
+		$isDir = $info->getType() === FileInfo::TYPE_FOLDER;
+		$view = new View('');
+		if ($isDir) {
+			return new Folder($this, $view, $path, $info, $parent);
+		} else {
+			return new File($this, $view, $path, $info, $parent);
+		}
+	}
+}