nextcloud / server

lib/private/Files/Node/Folder.php

Indentation +398 added lines, -398 removed lines

@@ -50,402 +50,402 @@
 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 strpos($node->getPath(), $this->path . '/') === 0;
-	}
-
-	/**
-	 * 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);
-	}
-
-	/**
-	 * @param string $path
-	 * @param FileInfo $info
-	 * @return File|Folder
-	 */
-	protected function createNode($path, FileInfo $info = null, bool $infoHasSubMountsIncluded = true) {
-		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 (empty($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 = \OC::$server->query(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 (strpos($mimetype, '/') === false) {
-			$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);
-	}
-
-	/**
-	 * @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 {
-		$mount = $this->root->getMount('');
-		$cacheEntry = $mount->getStorage()->getCache($this->path)->get($id);
-		if (!$cacheEntry) {
-			return [];
-		}
-
-		$absolutePath = '/' . ltrim($cacheEntry->getPath(), '/');
-		$currentPath = rtrim($this->path, '/') . '/';
-
-		if (strpos($absolutePath, $currentPath) !== 0) {
-			return [];
-		}
-
-		return [$this->root->createNode(
-			$absolutePath, new \OC\Files\FileInfo(
-				$absolutePath,
-				$mount->getStorage(),
-				$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 \OCP\Files\Node[]
-	 */
-	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);
-	}
+    /**
+     * 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 strpos($node->getPath(), $this->path . '/') === 0;
+    }
+
+    /**
+     * 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);
+    }
+
+    /**
+     * @param string $path
+     * @param FileInfo $info
+     * @return File|Folder
+     */
+    protected function createNode($path, FileInfo $info = null, bool $infoHasSubMountsIncluded = true) {
+        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 (empty($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 = \OC::$server->query(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 (strpos($mimetype, '/') === false) {
+            $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);
+    }
+
+    /**
+     * @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 {
+        $mount = $this->root->getMount('');
+        $cacheEntry = $mount->getStorage()->getCache($this->path)->get($id);
+        if (!$cacheEntry) {
+            return [];
+        }
+
+        $absolutePath = '/' . ltrim($cacheEntry->getPath(), '/');
+        $currentPath = rtrim($this->path, '/') . '/';
+
+        if (strpos($absolutePath, $currentPath) !== 0) {
+            return [];
+        }
+
+        return [$this->root->createNode(
+            $absolutePath, new \OC\Files\FileInfo(
+                $absolutePath,
+                $mount->getStorage(),
+                $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 \OCP\Files\Node[]
+     */
+    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);
+    }
 }

lib/private/Files/Cache/CacheQueryBuilder.php

Indentation +91 added lines, -91 removed lines

@@ -35,95 +35,95 @@
  * Query builder with commonly used helpers for filecache queries
  */
 class CacheQueryBuilder extends QueryBuilder {
-	private $alias = null;
-
-	public function __construct(IDBConnection $connection, SystemConfig $systemConfig, LoggerInterface $logger) {
-		parent::__construct($connection, $systemConfig, $logger);
-	}
-
-	public function selectTagUsage(): self {
-		$this
-			->select('systemtag.name', 'systemtag.id', 'systemtag.visibility', 'systemtag.editable')
-			->selectAlias($this->createFunction('COUNT(filecache.fileid)'), 'number_files')
-			->selectAlias($this->createFunction('MAX(filecache.fileid)'), 'ref_file_id')
-			->from('filecache', 'filecache')
-			->leftJoin('filecache', 'systemtag_object_mapping', 'systemtagmap', $this->expr()->andX(
-				$this->expr()->eq('filecache.fileid', $this->expr()->castColumn('systemtagmap.objectid', IQueryBuilder::PARAM_INT)),
-				$this->expr()->eq('systemtagmap.objecttype', $this->createNamedParameter('files'))
-			))
-			->leftJoin('systemtagmap', 'systemtag', 'systemtag', $this->expr()->andX(
-				$this->expr()->eq('systemtag.id', 'systemtagmap.systemtagid'),
-				$this->expr()->eq('systemtag.visibility', $this->createNamedParameter(true))
-			))
-			->groupBy('systemtag.name', 'systemtag.id', 'systemtag.visibility', 'systemtag.editable');
-
-		return $this;
-	}
-
-	public function selectFileCache(string $alias = null, bool $joinExtendedCache = true) {
-		$name = $alias ?: 'filecache';
-		$this->select("$name.fileid", 'storage', 'path', 'path_hash', "$name.parent", "$name.name", 'mimetype', 'mimepart', 'size', 'mtime',
-			'storage_mtime', 'encrypted', 'etag', 'permissions', 'checksum', 'unencrypted_size')
-			->from('filecache', $name);
-
-		if ($joinExtendedCache) {
-			$this->addSelect('metadata_etag', 'creation_time', 'upload_time');
-			$this->leftJoin($name, 'filecache_extended', 'fe', $this->expr()->eq("$name.fileid", 'fe.fileid'));
-		}
-
-		$this->alias = $name;
-
-		return $this;
-	}
-
-	public function whereStorageId(int $storageId) {
-		$this->andWhere($this->expr()->eq('storage', $this->createNamedParameter($storageId, IQueryBuilder::PARAM_INT)));
-
-		return $this;
-	}
-
-	public function whereFileId(int $fileId) {
-		$alias = $this->alias;
-		if ($alias) {
-			$alias .= '.';
-		} else {
-			$alias = '';
-		}
-
-		$this->andWhere($this->expr()->eq("{$alias}fileid", $this->createNamedParameter($fileId, IQueryBuilder::PARAM_INT)));
-
-		return $this;
-	}
-
-	public function wherePath(string $path) {
-		$this->andWhere($this->expr()->eq('path_hash', $this->createNamedParameter(md5($path))));
-
-		return $this;
-	}
-
-	public function whereParent(int $parent) {
-		$alias = $this->alias;
-		if ($alias) {
-			$alias .= '.';
-		} else {
-			$alias = '';
-		}
-
-		$this->andWhere($this->expr()->eq("{$alias}parent", $this->createNamedParameter($parent, IQueryBuilder::PARAM_INT)));
-
-		return $this;
-	}
-
-	public function whereParentInParameter(string $parameter) {
-		$alias = $this->alias;
-		if ($alias) {
-			$alias .= '.';
-		} else {
-			$alias = '';
-		}
-
-		$this->andWhere($this->expr()->in("{$alias}parent", $this->createParameter($parameter)));
-
-		return $this;
-	}
+    private $alias = null;
+
+    public function __construct(IDBConnection $connection, SystemConfig $systemConfig, LoggerInterface $logger) {
+        parent::__construct($connection, $systemConfig, $logger);
+    }
+
+    public function selectTagUsage(): self {
+        $this
+            ->select('systemtag.name', 'systemtag.id', 'systemtag.visibility', 'systemtag.editable')
+            ->selectAlias($this->createFunction('COUNT(filecache.fileid)'), 'number_files')
+            ->selectAlias($this->createFunction('MAX(filecache.fileid)'), 'ref_file_id')
+            ->from('filecache', 'filecache')
+            ->leftJoin('filecache', 'systemtag_object_mapping', 'systemtagmap', $this->expr()->andX(
+                $this->expr()->eq('filecache.fileid', $this->expr()->castColumn('systemtagmap.objectid', IQueryBuilder::PARAM_INT)),
+                $this->expr()->eq('systemtagmap.objecttype', $this->createNamedParameter('files'))
+            ))
+            ->leftJoin('systemtagmap', 'systemtag', 'systemtag', $this->expr()->andX(
+                $this->expr()->eq('systemtag.id', 'systemtagmap.systemtagid'),
+                $this->expr()->eq('systemtag.visibility', $this->createNamedParameter(true))
+            ))
+            ->groupBy('systemtag.name', 'systemtag.id', 'systemtag.visibility', 'systemtag.editable');
+
+        return $this;
+    }
+
+    public function selectFileCache(string $alias = null, bool $joinExtendedCache = true) {
+        $name = $alias ?: 'filecache';
+        $this->select("$name.fileid", 'storage', 'path', 'path_hash', "$name.parent", "$name.name", 'mimetype', 'mimepart', 'size', 'mtime',
+            'storage_mtime', 'encrypted', 'etag', 'permissions', 'checksum', 'unencrypted_size')
+            ->from('filecache', $name);
+
+        if ($joinExtendedCache) {
+            $this->addSelect('metadata_etag', 'creation_time', 'upload_time');
+            $this->leftJoin($name, 'filecache_extended', 'fe', $this->expr()->eq("$name.fileid", 'fe.fileid'));
+        }
+
+        $this->alias = $name;
+
+        return $this;
+    }
+
+    public function whereStorageId(int $storageId) {
+        $this->andWhere($this->expr()->eq('storage', $this->createNamedParameter($storageId, IQueryBuilder::PARAM_INT)));
+
+        return $this;
+    }
+
+    public function whereFileId(int $fileId) {
+        $alias = $this->alias;
+        if ($alias) {
+            $alias .= '.';
+        } else {
+            $alias = '';
+        }
+
+        $this->andWhere($this->expr()->eq("{$alias}fileid", $this->createNamedParameter($fileId, IQueryBuilder::PARAM_INT)));
+
+        return $this;
+    }
+
+    public function wherePath(string $path) {
+        $this->andWhere($this->expr()->eq('path_hash', $this->createNamedParameter(md5($path))));
+
+        return $this;
+    }
+
+    public function whereParent(int $parent) {
+        $alias = $this->alias;
+        if ($alias) {
+            $alias .= '.';
+        } else {
+            $alias = '';
+        }
+
+        $this->andWhere($this->expr()->eq("{$alias}parent", $this->createNamedParameter($parent, IQueryBuilder::PARAM_INT)));
+
+        return $this;
+    }
+
+    public function whereParentInParameter(string $parameter) {
+        $alias = $this->alias;
+        if ($alias) {
+            $alias .= '.';
+        } else {
+            $alias = '';
+        }
+
+        $this->andWhere($this->expr()->in("{$alias}parent", $this->createParameter($parameter)));
+
+        return $this;
+    }
 }

lib/private/Files/Cache/QuerySearchHelper.php

Indentation +185 added lines, -185 removed lines

@@ -42,189 +42,189 @@
 use Psr\Log\LoggerInterface;
 
 class QuerySearchHelper {
-	/** @var IMimeTypeLoader */
-	private $mimetypeLoader;
-	/** @var IDBConnection */
-	private $connection;
-	/** @var SystemConfig */
-	private $systemConfig;
-	private LoggerInterface $logger;
-	/** @var SearchBuilder */
-	private $searchBuilder;
-	/** @var QueryOptimizer */
-	private $queryOptimizer;
-
-	public function __construct(
-		IMimeTypeLoader $mimetypeLoader,
-		IDBConnection $connection,
-		SystemConfig $systemConfig,
-		LoggerInterface $logger,
-		SearchBuilder $searchBuilder,
-		QueryOptimizer $queryOptimizer
-	) {
-		$this->mimetypeLoader = $mimetypeLoader;
-		$this->connection = $connection;
-		$this->systemConfig = $systemConfig;
-		$this->logger = $logger;
-		$this->searchBuilder = $searchBuilder;
-		$this->queryOptimizer = $queryOptimizer;
-	}
-
-	protected function getQueryBuilder() {
-		return new CacheQueryBuilder(
-			$this->connection,
-			$this->systemConfig,
-			$this->logger
-		);
-	}
-
-	protected function applySearchConstraints(CacheQueryBuilder $query, ISearchQuery $searchQuery, array $caches): void {
-		$storageFilters = array_values(array_map(function (ICache $cache) {
-			return $cache->getQueryFilterForStorage();
-		}, $caches));
-		$storageFilter = new SearchBinaryOperator(ISearchBinaryOperator::OPERATOR_OR, $storageFilters);
-		$filter = new SearchBinaryOperator(ISearchBinaryOperator::OPERATOR_AND, [$searchQuery->getSearchOperation(), $storageFilter]);
-		$this->queryOptimizer->processOperator($filter);
-
-		$searchExpr = $this->searchBuilder->searchOperatorToDBExpr($query, $filter);
-		if ($searchExpr) {
-			$query->andWhere($searchExpr);
-		}
-
-		$this->searchBuilder->addSearchOrdersToQuery($query, $searchQuery->getOrder());
-
-		if ($searchQuery->getLimit()) {
-			$query->setMaxResults($searchQuery->getLimit());
-		}
-		if ($searchQuery->getOffset()) {
-			$query->setFirstResult($searchQuery->getOffset());
-		}
-	}
-
-
-	/**
-	 * @return array<array-key, array{id: int, name: string, visibility: int, editable: int, ref_file_id: int, number_files: int}>
-	 */
-	public function findUsedTagsInCaches(ISearchQuery $searchQuery, array $caches): array {
-		$query = $this->getQueryBuilder();
-		$query->selectTagUsage();
-
-		$this->applySearchConstraints($query, $searchQuery, $caches);
-
-		$result = $query->execute();
-		$tags = $result->fetchAll();
-		$result->closeCursor();
-		return $tags;
-	}
-
-	/**
-	 * Perform a file system search in multiple caches
-	 *
-	 * the results will be grouped by the same array keys as the $caches argument to allow
-	 * post-processing based on which cache the result came from
-	 *
-	 * @template T of array-key
-	 * @param ISearchQuery $searchQuery
-	 * @param array<T, ICache> $caches
-	 * @return array<T, ICacheEntry[]>
-	 */
-	public function searchInCaches(ISearchQuery $searchQuery, array $caches): array {
-		// search in multiple caches at once by creating one query in the following format
-		// SELECT ... FROM oc_filecache WHERE
-		//     <filter expressions from the search query>
-		// AND (
-		//     <filter expression for storage1> OR
-		//     <filter expression for storage2> OR
-		//     ...
-		// );
-		//
-		// This gives us all the files matching the search query from all caches
-		//
-		// while the resulting rows don't have a way to tell what storage they came from (multiple storages/caches can share storage_id)
-		// we can just ask every cache if the row belongs to them and give them the cache to do any post processing on the result.
-
-		$builder = $this->getQueryBuilder();
-
-		$query = $builder->selectFileCache('file', false);
-
-		if ($this->searchBuilder->shouldJoinTags($searchQuery->getSearchOperation())) {
-			$user = $searchQuery->getUser();
-			if ($user === null) {
-				throw new \InvalidArgumentException("Searching by tag requires the user to be set in the query");
-			}
-			$query
-				->leftJoin('file', 'vcategory_to_object', 'tagmap', $builder->expr()->eq('file.fileid', 'tagmap.objid'))
-				->leftJoin('tagmap', 'vcategory', 'tag', $builder->expr()->andX(
-					$builder->expr()->eq('tagmap.type', 'tag.type'),
-					$builder->expr()->eq('tagmap.categoryid', 'tag.id'),
-					$builder->expr()->eq('tag.type', $builder->createNamedParameter('files')),
-					$builder->expr()->eq('tag.uid', $builder->createNamedParameter($user->getUID()))
-				))
-				->leftJoin('file', 'systemtag_object_mapping', 'systemtagmap', $builder->expr()->andX(
-					$builder->expr()->eq('file.fileid', $builder->expr()->castColumn('systemtagmap.objectid', IQueryBuilder::PARAM_INT)),
-					$builder->expr()->eq('systemtagmap.objecttype', $builder->createNamedParameter('files'))
-				))
-				->leftJoin('systemtagmap', 'systemtag', 'systemtag', $builder->expr()->andX(
-					$builder->expr()->eq('systemtag.id', 'systemtagmap.systemtagid'),
-					$builder->expr()->eq('systemtag.visibility', $builder->createNamedParameter(true))
-				));
-		}
-
-		$this->applySearchConstraints($query, $searchQuery, $caches);
-
-		$result = $query->execute();
-		$files = $result->fetchAll();
-
-		$rawEntries = array_map(function (array $data) {
-			return Cache::cacheEntryFromData($data, $this->mimetypeLoader);
-		}, $files);
-
-		$result->closeCursor();
-
-		// loop through all caches for each result to see if the result matches that storage
-		// results are grouped by the same array keys as the caches argument to allow the caller to distinguish the source of the results
-		$results = array_fill_keys(array_keys($caches), []);
-		foreach ($rawEntries as $rawEntry) {
-			foreach ($caches as $cacheKey => $cache) {
-				$entry = $cache->getCacheEntryFromSearchResult($rawEntry);
-				if ($entry) {
-					$results[$cacheKey][] = $entry;
-				}
-			}
-		}
-		return $results;
-	}
-
-	/**
-	 * @return array{array<string, ICache>, array<string, IMountPoint>}
-	 */
-	public function getCachesAndMountPointsForSearch(Root $root, string $path, bool $limitToHome = false): array {
-		$rootLength = strlen($path);
-		$mount = $root->getMount($path);
-		$storage = $mount->getStorage();
-		$internalPath = $mount->getInternalPath($path);
-
-		if ($internalPath !== '') {
-			// a temporary CacheJail is used to handle filtering down the results to within this folder
-			$caches = ['' => new CacheJail($storage->getCache(''), $internalPath)];
-		} else {
-			$caches = ['' => $storage->getCache('')];
-		}
-		$mountByMountPoint = ['' => $mount];
-
-		if (!$limitToHome) {
-			/** @var IMountPoint[] $mounts */
-			$mounts = $root->getMountsIn($path);
-			foreach ($mounts as $mount) {
-				$storage = $mount->getStorage();
-				if ($storage) {
-					$relativeMountPoint = ltrim(substr($mount->getMountPoint(), $rootLength), '/');
-					$caches[$relativeMountPoint] = $storage->getCache('');
-					$mountByMountPoint[$relativeMountPoint] = $mount;
-				}
-			}
-		}
-
-		return [$caches, $mountByMountPoint];
-	}
+    /** @var IMimeTypeLoader */
+    private $mimetypeLoader;
+    /** @var IDBConnection */
+    private $connection;
+    /** @var SystemConfig */
+    private $systemConfig;
+    private LoggerInterface $logger;
+    /** @var SearchBuilder */
+    private $searchBuilder;
+    /** @var QueryOptimizer */
+    private $queryOptimizer;
+
+    public function __construct(
+        IMimeTypeLoader $mimetypeLoader,
+        IDBConnection $connection,
+        SystemConfig $systemConfig,
+        LoggerInterface $logger,
+        SearchBuilder $searchBuilder,
+        QueryOptimizer $queryOptimizer
+    ) {
+        $this->mimetypeLoader = $mimetypeLoader;
+        $this->connection = $connection;
+        $this->systemConfig = $systemConfig;
+        $this->logger = $logger;
+        $this->searchBuilder = $searchBuilder;
+        $this->queryOptimizer = $queryOptimizer;
+    }
+
+    protected function getQueryBuilder() {
+        return new CacheQueryBuilder(
+            $this->connection,
+            $this->systemConfig,
+            $this->logger
+        );
+    }
+
+    protected function applySearchConstraints(CacheQueryBuilder $query, ISearchQuery $searchQuery, array $caches): void {
+        $storageFilters = array_values(array_map(function (ICache $cache) {
+            return $cache->getQueryFilterForStorage();
+        }, $caches));
+        $storageFilter = new SearchBinaryOperator(ISearchBinaryOperator::OPERATOR_OR, $storageFilters);
+        $filter = new SearchBinaryOperator(ISearchBinaryOperator::OPERATOR_AND, [$searchQuery->getSearchOperation(), $storageFilter]);
+        $this->queryOptimizer->processOperator($filter);
+
+        $searchExpr = $this->searchBuilder->searchOperatorToDBExpr($query, $filter);
+        if ($searchExpr) {
+            $query->andWhere($searchExpr);
+        }
+
+        $this->searchBuilder->addSearchOrdersToQuery($query, $searchQuery->getOrder());
+
+        if ($searchQuery->getLimit()) {
+            $query->setMaxResults($searchQuery->getLimit());
+        }
+        if ($searchQuery->getOffset()) {
+            $query->setFirstResult($searchQuery->getOffset());
+        }
+    }
+
+
+    /**
+     * @return array<array-key, array{id: int, name: string, visibility: int, editable: int, ref_file_id: int, number_files: int}>
+     */
+    public function findUsedTagsInCaches(ISearchQuery $searchQuery, array $caches): array {
+        $query = $this->getQueryBuilder();
+        $query->selectTagUsage();
+
+        $this->applySearchConstraints($query, $searchQuery, $caches);
+
+        $result = $query->execute();
+        $tags = $result->fetchAll();
+        $result->closeCursor();
+        return $tags;
+    }
+
+    /**
+     * Perform a file system search in multiple caches
+     *
+     * the results will be grouped by the same array keys as the $caches argument to allow
+     * post-processing based on which cache the result came from
+     *
+     * @template T of array-key
+     * @param ISearchQuery $searchQuery
+     * @param array<T, ICache> $caches
+     * @return array<T, ICacheEntry[]>
+     */
+    public function searchInCaches(ISearchQuery $searchQuery, array $caches): array {
+        // search in multiple caches at once by creating one query in the following format
+        // SELECT ... FROM oc_filecache WHERE
+        //     <filter expressions from the search query>
+        // AND (
+        //     <filter expression for storage1> OR
+        //     <filter expression for storage2> OR
+        //     ...
+        // );
+        //
+        // This gives us all the files matching the search query from all caches
+        //
+        // while the resulting rows don't have a way to tell what storage they came from (multiple storages/caches can share storage_id)
+        // we can just ask every cache if the row belongs to them and give them the cache to do any post processing on the result.
+
+        $builder = $this->getQueryBuilder();
+
+        $query = $builder->selectFileCache('file', false);
+
+        if ($this->searchBuilder->shouldJoinTags($searchQuery->getSearchOperation())) {
+            $user = $searchQuery->getUser();
+            if ($user === null) {
+                throw new \InvalidArgumentException("Searching by tag requires the user to be set in the query");
+            }
+            $query
+                ->leftJoin('file', 'vcategory_to_object', 'tagmap', $builder->expr()->eq('file.fileid', 'tagmap.objid'))
+                ->leftJoin('tagmap', 'vcategory', 'tag', $builder->expr()->andX(
+                    $builder->expr()->eq('tagmap.type', 'tag.type'),
+                    $builder->expr()->eq('tagmap.categoryid', 'tag.id'),
+                    $builder->expr()->eq('tag.type', $builder->createNamedParameter('files')),
+                    $builder->expr()->eq('tag.uid', $builder->createNamedParameter($user->getUID()))
+                ))
+                ->leftJoin('file', 'systemtag_object_mapping', 'systemtagmap', $builder->expr()->andX(
+                    $builder->expr()->eq('file.fileid', $builder->expr()->castColumn('systemtagmap.objectid', IQueryBuilder::PARAM_INT)),
+                    $builder->expr()->eq('systemtagmap.objecttype', $builder->createNamedParameter('files'))
+                ))
+                ->leftJoin('systemtagmap', 'systemtag', 'systemtag', $builder->expr()->andX(
+                    $builder->expr()->eq('systemtag.id', 'systemtagmap.systemtagid'),
+                    $builder->expr()->eq('systemtag.visibility', $builder->createNamedParameter(true))
+                ));
+        }
+
+        $this->applySearchConstraints($query, $searchQuery, $caches);
+
+        $result = $query->execute();
+        $files = $result->fetchAll();
+
+        $rawEntries = array_map(function (array $data) {
+            return Cache::cacheEntryFromData($data, $this->mimetypeLoader);
+        }, $files);
+
+        $result->closeCursor();
+
+        // loop through all caches for each result to see if the result matches that storage
+        // results are grouped by the same array keys as the caches argument to allow the caller to distinguish the source of the results
+        $results = array_fill_keys(array_keys($caches), []);
+        foreach ($rawEntries as $rawEntry) {
+            foreach ($caches as $cacheKey => $cache) {
+                $entry = $cache->getCacheEntryFromSearchResult($rawEntry);
+                if ($entry) {
+                    $results[$cacheKey][] = $entry;
+                }
+            }
+        }
+        return $results;
+    }
+
+    /**
+     * @return array{array<string, ICache>, array<string, IMountPoint>}
+     */
+    public function getCachesAndMountPointsForSearch(Root $root, string $path, bool $limitToHome = false): array {
+        $rootLength = strlen($path);
+        $mount = $root->getMount($path);
+        $storage = $mount->getStorage();
+        $internalPath = $mount->getInternalPath($path);
+
+        if ($internalPath !== '') {
+            // a temporary CacheJail is used to handle filtering down the results to within this folder
+            $caches = ['' => new CacheJail($storage->getCache(''), $internalPath)];
+        } else {
+            $caches = ['' => $storage->getCache('')];
+        }
+        $mountByMountPoint = ['' => $mount];
+
+        if (!$limitToHome) {
+            /** @var IMountPoint[] $mounts */
+            $mounts = $root->getMountsIn($path);
+            foreach ($mounts as $mount) {
+                $storage = $mount->getStorage();
+                if ($storage) {
+                    $relativeMountPoint = ltrim(substr($mount->getMountPoint(), $rootLength), '/');
+                    $caches[$relativeMountPoint] = $storage->getCache('');
+                    $mountByMountPoint[$relativeMountPoint] = $mount;
+                }
+            }
+        }
+
+        return [$caches, $mountByMountPoint];
+    }
 }

lib/private/SystemTag/SystemTagsInFilesDetector.php

Indentation +30 added lines, -30 removed lines

@@ -36,37 +36,37 @@
 use OCP\Files\Search\ISearchComparison;
 
 class SystemTagsInFilesDetector {
-	public function __construct(protected QuerySearchHelper $searchHelper) {
-	}
+    public function __construct(protected QuerySearchHelper $searchHelper) {
+    }
 
-	public function detectAssignedSystemTagsIn(
-		Folder $folder,
-		string $filteredMediaType = '',
-		int $limit = 0,
-		int $offset = 0
-	): array {
-		$operator = new SearchComparison(ISearchComparison::COMPARE_LIKE, 'systemtag', '%');
-		// Currently query has to have exactly one search condition. If no media type is provided,
-		// we fall back to the presence of a system tag.
-		if ($filteredMediaType !== '') {
-			$mimeOperator = new SearchComparison(ISearchComparison::COMPARE_LIKE, 'mimetype', $filteredMediaType . '/%');
-			$operator = new SearchBinaryOperator(ISearchBinaryOperator::OPERATOR_AND, [$operator, $mimeOperator]);
-		}
+    public function detectAssignedSystemTagsIn(
+        Folder $folder,
+        string $filteredMediaType = '',
+        int $limit = 0,
+        int $offset = 0
+    ): array {
+        $operator = new SearchComparison(ISearchComparison::COMPARE_LIKE, 'systemtag', '%');
+        // Currently query has to have exactly one search condition. If no media type is provided,
+        // we fall back to the presence of a system tag.
+        if ($filteredMediaType !== '') {
+            $mimeOperator = new SearchComparison(ISearchComparison::COMPARE_LIKE, 'mimetype', $filteredMediaType . '/%');
+            $operator = new SearchBinaryOperator(ISearchBinaryOperator::OPERATOR_AND, [$operator, $mimeOperator]);
+        }
 
-		$query = new SearchQuery($operator, $limit, $offset, []);
-		[$caches, ] = $this->searchHelper->getCachesAndMountPointsForSearch(
-			$this->getRootFolder($folder),
-			$folder->getPath(),
-		);
-		return $this->searchHelper->findUsedTagsInCaches($query, $caches);
-	}
+        $query = new SearchQuery($operator, $limit, $offset, []);
+        [$caches, ] = $this->searchHelper->getCachesAndMountPointsForSearch(
+            $this->getRootFolder($folder),
+            $folder->getPath(),
+        );
+        return $this->searchHelper->findUsedTagsInCaches($query, $caches);
+    }
 
-	protected function getRootFolder(?Folder $folder): Root {
-		if ($folder instanceof Root) {
-			return $folder;
-		} elseif ($folder === null) {
-			throw new \LogicException('Could not climb up to root folder');
-		}
-		return $this->getRootFolder($folder->getParent());
-	}
+    protected function getRootFolder(?Folder $folder): Root {
+        if ($folder instanceof Root) {
+            return $folder;
+        } elseif ($folder === null) {
+            throw new \LogicException('Could not climb up to root folder');
+        }
+        return $this->getRootFolder($folder->getParent());
+    }
 }

apps/dav/lib/RootCollection.php

Indentation +139 added lines, -139 removed lines

@@ -54,143 +54,143 @@
 use Sabre\DAV\SimpleCollection;
 
 class RootCollection extends SimpleCollection {
-	public function __construct() {
-		$l10n = \OC::$server->getL10N('dav');
-		$random = \OC::$server->getSecureRandom();
-		$logger = \OC::$server->get(LoggerInterface::class);
-		$userManager = \OC::$server->getUserManager();
-		$userSession = \OC::$server->getUserSession();
-		$groupManager = \OC::$server->getGroupManager();
-		$shareManager = \OC::$server->getShareManager();
-		$db = \OC::$server->getDatabaseConnection();
-		$dispatcher = \OC::$server->get(IEventDispatcher::class);
-		$config = \OC::$server->get(IConfig::class);
-		$proxyMapper = \OC::$server->query(ProxyMapper::class);
-		$rootFolder = \OCP\Server::get(IRootFolder::class);
-
-		$userPrincipalBackend = new Principal(
-			$userManager,
-			$groupManager,
-			\OC::$server->get(IAccountManager::class),
-			$shareManager,
-			\OC::$server->getUserSession(),
-			\OC::$server->getAppManager(),
-			$proxyMapper,
-			\OC::$server->get(KnownUserService::class),
-			\OC::$server->getConfig(),
-			\OC::$server->getL10NFactory()
-		);
-		$groupPrincipalBackend = new GroupPrincipalBackend($groupManager, $userSession, $shareManager, $config);
-		$calendarResourcePrincipalBackend = new ResourcePrincipalBackend($db, $userSession, $groupManager, $logger, $proxyMapper);
-		$calendarRoomPrincipalBackend = new RoomPrincipalBackend($db, $userSession, $groupManager, $logger, $proxyMapper);
-		// as soon as debug mode is enabled we allow listing of principals
-		$disableListing = !$config->getSystemValue('debug', false);
-
-		// setup the first level of the dav tree
-		$userPrincipals = new Collection($userPrincipalBackend, 'principals/users');
-		$userPrincipals->disableListing = $disableListing;
-		$groupPrincipals = new Collection($groupPrincipalBackend, 'principals/groups');
-		$groupPrincipals->disableListing = $disableListing;
-		$systemPrincipals = new Collection(new SystemPrincipalBackend(), 'principals/system');
-		$systemPrincipals->disableListing = $disableListing;
-		$calendarResourcePrincipals = new Collection($calendarResourcePrincipalBackend, 'principals/calendar-resources');
-		$calendarResourcePrincipals->disableListing = $disableListing;
-		$calendarRoomPrincipals = new Collection($calendarRoomPrincipalBackend, 'principals/calendar-rooms');
-		$calendarRoomPrincipals->disableListing = $disableListing;
-
-
-		$filesCollection = new Files\RootCollection($userPrincipalBackend, 'principals/users');
-		$filesCollection->disableListing = $disableListing;
-		$caldavBackend = new CalDavBackend(
-			$db,
-			$userPrincipalBackend,
-			$userManager,
-			$groupManager,
-			$random,
-			$logger,
-			$dispatcher,
-			$config
-		);
-		$userCalendarRoot = new CalendarRoot($userPrincipalBackend, $caldavBackend, 'principals/users', $logger);
-		$userCalendarRoot->disableListing = $disableListing;
-
-		$resourceCalendarRoot = new CalendarRoot($calendarResourcePrincipalBackend, $caldavBackend, 'principals/calendar-resources', $logger);
-		$resourceCalendarRoot->disableListing = $disableListing;
-		$roomCalendarRoot = new CalendarRoot($calendarRoomPrincipalBackend, $caldavBackend, 'principals/calendar-rooms', $logger);
-		$roomCalendarRoot->disableListing = $disableListing;
-
-		$publicCalendarRoot = new PublicCalendarRoot($caldavBackend, $l10n, $config, $logger);
-
-		$systemTagCollection = new SystemTag\SystemTagsByIdCollection(
-			\OC::$server->getSystemTagManager(),
-			\OC::$server->getUserSession(),
-			$groupManager
-		);
-		$systemTagRelationsCollection = new SystemTag\SystemTagsRelationsCollection(
-			\OC::$server->getSystemTagManager(),
-			\OC::$server->getSystemTagObjectMapper(),
-			\OC::$server->getUserSession(),
-			$groupManager,
-			\OC::$server->getEventDispatcher()
-		);
-		$systemTagInUseCollection = \OCP\Server::get(SystemTag\SystemTagsInUseCollection::class);
-		$commentsCollection = new Comments\RootCollection(
-			\OC::$server->getCommentsManager(),
-			$userManager,
-			\OC::$server->getUserSession(),
-			\OC::$server->getEventDispatcher(),
-			$logger
-		);
-
-		$pluginManager = new PluginManager(\OC::$server, \OC::$server->query(IAppManager::class));
-		$usersCardDavBackend = new CardDavBackend($db, $userPrincipalBackend, $userManager, $groupManager, $dispatcher);
-		$usersAddressBookRoot = new AddressBookRoot($userPrincipalBackend, $usersCardDavBackend, $pluginManager, 'principals/users');
-		$usersAddressBookRoot->disableListing = $disableListing;
-
-		$systemCardDavBackend = new CardDavBackend($db, $userPrincipalBackend, $userManager, $groupManager, $dispatcher);
-		$systemAddressBookRoot = new AddressBookRoot(new SystemPrincipalBackend(), $systemCardDavBackend, $pluginManager, 'principals/system');
-		$systemAddressBookRoot->disableListing = $disableListing;
-
-		$uploadCollection = new Upload\RootCollection(
-			$userPrincipalBackend,
-			'principals/users',
-			\OC::$server->query(CleanupService::class));
-		$uploadCollection->disableListing = $disableListing;
-
-		$avatarCollection = new Avatars\RootCollection($userPrincipalBackend, 'principals/users');
-		$avatarCollection->disableListing = $disableListing;
-
-		$appleProvisioning = new AppleProvisioningNode(
-			\OC::$server->query(ITimeFactory::class));
-
-		$children = [
-			new SimpleCollection('principals', [
-				$userPrincipals,
-				$groupPrincipals,
-				$systemPrincipals,
-				$calendarResourcePrincipals,
-				$calendarRoomPrincipals]),
-			$filesCollection,
-			$userCalendarRoot,
-			new SimpleCollection('system-calendars', [
-				$resourceCalendarRoot,
-				$roomCalendarRoot,
-			]),
-			$publicCalendarRoot,
-			new SimpleCollection('addressbooks', [
-				$usersAddressBookRoot,
-				$systemAddressBookRoot]),
-			$systemTagCollection,
-			$systemTagRelationsCollection,
-			$systemTagInUseCollection,
-			$commentsCollection,
-			$uploadCollection,
-			$avatarCollection,
-			new SimpleCollection('provisioning', [
-				$appleProvisioning
-			])
-		];
-
-		parent::__construct('root', $children);
-	}
+    public function __construct() {
+        $l10n = \OC::$server->getL10N('dav');
+        $random = \OC::$server->getSecureRandom();
+        $logger = \OC::$server->get(LoggerInterface::class);
+        $userManager = \OC::$server->getUserManager();
+        $userSession = \OC::$server->getUserSession();
+        $groupManager = \OC::$server->getGroupManager();
+        $shareManager = \OC::$server->getShareManager();
+        $db = \OC::$server->getDatabaseConnection();
+        $dispatcher = \OC::$server->get(IEventDispatcher::class);
+        $config = \OC::$server->get(IConfig::class);
+        $proxyMapper = \OC::$server->query(ProxyMapper::class);
+        $rootFolder = \OCP\Server::get(IRootFolder::class);
+
+        $userPrincipalBackend = new Principal(
+            $userManager,
+            $groupManager,
+            \OC::$server->get(IAccountManager::class),
+            $shareManager,
+            \OC::$server->getUserSession(),
+            \OC::$server->getAppManager(),
+            $proxyMapper,
+            \OC::$server->get(KnownUserService::class),
+            \OC::$server->getConfig(),
+            \OC::$server->getL10NFactory()
+        );
+        $groupPrincipalBackend = new GroupPrincipalBackend($groupManager, $userSession, $shareManager, $config);
+        $calendarResourcePrincipalBackend = new ResourcePrincipalBackend($db, $userSession, $groupManager, $logger, $proxyMapper);
+        $calendarRoomPrincipalBackend = new RoomPrincipalBackend($db, $userSession, $groupManager, $logger, $proxyMapper);
+        // as soon as debug mode is enabled we allow listing of principals
+        $disableListing = !$config->getSystemValue('debug', false);
+
+        // setup the first level of the dav tree
+        $userPrincipals = new Collection($userPrincipalBackend, 'principals/users');
+        $userPrincipals->disableListing = $disableListing;
+        $groupPrincipals = new Collection($groupPrincipalBackend, 'principals/groups');
+        $groupPrincipals->disableListing = $disableListing;
+        $systemPrincipals = new Collection(new SystemPrincipalBackend(), 'principals/system');
+        $systemPrincipals->disableListing = $disableListing;
+        $calendarResourcePrincipals = new Collection($calendarResourcePrincipalBackend, 'principals/calendar-resources');
+        $calendarResourcePrincipals->disableListing = $disableListing;
+        $calendarRoomPrincipals = new Collection($calendarRoomPrincipalBackend, 'principals/calendar-rooms');
+        $calendarRoomPrincipals->disableListing = $disableListing;
+
+
+        $filesCollection = new Files\RootCollection($userPrincipalBackend, 'principals/users');
+        $filesCollection->disableListing = $disableListing;
+        $caldavBackend = new CalDavBackend(
+            $db,
+            $userPrincipalBackend,
+            $userManager,
+            $groupManager,
+            $random,
+            $logger,
+            $dispatcher,
+            $config
+        );
+        $userCalendarRoot = new CalendarRoot($userPrincipalBackend, $caldavBackend, 'principals/users', $logger);
+        $userCalendarRoot->disableListing = $disableListing;
+
+        $resourceCalendarRoot = new CalendarRoot($calendarResourcePrincipalBackend, $caldavBackend, 'principals/calendar-resources', $logger);
+        $resourceCalendarRoot->disableListing = $disableListing;
+        $roomCalendarRoot = new CalendarRoot($calendarRoomPrincipalBackend, $caldavBackend, 'principals/calendar-rooms', $logger);
+        $roomCalendarRoot->disableListing = $disableListing;
+
+        $publicCalendarRoot = new PublicCalendarRoot($caldavBackend, $l10n, $config, $logger);
+
+        $systemTagCollection = new SystemTag\SystemTagsByIdCollection(
+            \OC::$server->getSystemTagManager(),
+            \OC::$server->getUserSession(),
+            $groupManager
+        );
+        $systemTagRelationsCollection = new SystemTag\SystemTagsRelationsCollection(
+            \OC::$server->getSystemTagManager(),
+            \OC::$server->getSystemTagObjectMapper(),
+            \OC::$server->getUserSession(),
+            $groupManager,
+            \OC::$server->getEventDispatcher()
+        );
+        $systemTagInUseCollection = \OCP\Server::get(SystemTag\SystemTagsInUseCollection::class);
+        $commentsCollection = new Comments\RootCollection(
+            \OC::$server->getCommentsManager(),
+            $userManager,
+            \OC::$server->getUserSession(),
+            \OC::$server->getEventDispatcher(),
+            $logger
+        );
+
+        $pluginManager = new PluginManager(\OC::$server, \OC::$server->query(IAppManager::class));
+        $usersCardDavBackend = new CardDavBackend($db, $userPrincipalBackend, $userManager, $groupManager, $dispatcher);
+        $usersAddressBookRoot = new AddressBookRoot($userPrincipalBackend, $usersCardDavBackend, $pluginManager, 'principals/users');
+        $usersAddressBookRoot->disableListing = $disableListing;
+
+        $systemCardDavBackend = new CardDavBackend($db, $userPrincipalBackend, $userManager, $groupManager, $dispatcher);
+        $systemAddressBookRoot = new AddressBookRoot(new SystemPrincipalBackend(), $systemCardDavBackend, $pluginManager, 'principals/system');
+        $systemAddressBookRoot->disableListing = $disableListing;
+
+        $uploadCollection = new Upload\RootCollection(
+            $userPrincipalBackend,
+            'principals/users',
+            \OC::$server->query(CleanupService::class));
+        $uploadCollection->disableListing = $disableListing;
+
+        $avatarCollection = new Avatars\RootCollection($userPrincipalBackend, 'principals/users');
+        $avatarCollection->disableListing = $disableListing;
+
+        $appleProvisioning = new AppleProvisioningNode(
+            \OC::$server->query(ITimeFactory::class));
+
+        $children = [
+            new SimpleCollection('principals', [
+                $userPrincipals,
+                $groupPrincipals,
+                $systemPrincipals,
+                $calendarResourcePrincipals,
+                $calendarRoomPrincipals]),
+            $filesCollection,
+            $userCalendarRoot,
+            new SimpleCollection('system-calendars', [
+                $resourceCalendarRoot,
+                $roomCalendarRoot,
+            ]),
+            $publicCalendarRoot,
+            new SimpleCollection('addressbooks', [
+                $usersAddressBookRoot,
+                $systemAddressBookRoot]),
+            $systemTagCollection,
+            $systemTagRelationsCollection,
+            $systemTagInUseCollection,
+            $commentsCollection,
+            $uploadCollection,
+            $avatarCollection,
+            new SimpleCollection('provisioning', [
+                $appleProvisioning
+            ])
+        ];
+
+        parent::__construct('root', $children);
+    }
 }

apps/dav/lib/SystemTag/SystemTagPlugin.php

Indentation +388 added lines, -388 removed lines

@@ -53,392 +53,392 @@
  */
 class SystemTagPlugin extends \Sabre\DAV\ServerPlugin {
 
-	// namespace
-	public const NS_OWNCLOUD = 'http://owncloud.org/ns';
-	public const ID_PROPERTYNAME = '{http://owncloud.org/ns}id';
-	public const DISPLAYNAME_PROPERTYNAME = '{http://owncloud.org/ns}display-name';
-	public const USERVISIBLE_PROPERTYNAME = '{http://owncloud.org/ns}user-visible';
-	public const USERASSIGNABLE_PROPERTYNAME = '{http://owncloud.org/ns}user-assignable';
-	public const GROUPS_PROPERTYNAME = '{http://owncloud.org/ns}groups';
-	public const CANASSIGN_PROPERTYNAME = '{http://owncloud.org/ns}can-assign';
-	public const SYSTEM_TAGS_PROPERTYNAME = '{http://nextcloud.org/ns}system-tags';
-	public const NUM_FILES_PROPERTYNAME = '{http://nextcloud.org/ns}files-assigned';
-	public const FILEID_PROPERTYNAME = '{http://nextcloud.org/ns}reference-fileid';
-
-	/**
-	 * @var \Sabre\DAV\Server $server
-	 */
-	private $server;
-
-	/**
-	 * @var ISystemTagManager
-	 */
-	protected $tagManager;
-
-	/**
-	 * @var IUserSession
-	 */
-	protected $userSession;
-
-	/**
-	 * @var IGroupManager
-	 */
-	protected $groupManager;
-
-	/** @var array<int, string[]> */
-	private array $cachedTagMappings = [];
-	/** @var array<string, ISystemTag> */
-	private array $cachedTags = [];
-
-	private ISystemTagObjectMapper $tagMapper;
-
-	public function __construct(
-		ISystemTagManager $tagManager,
-		IGroupManager $groupManager,
-		IUserSession $userSession,
-		ISystemTagObjectMapper $tagMapper,
-	) {
-		$this->tagManager = $tagManager;
-		$this->userSession = $userSession;
-		$this->groupManager = $groupManager;
-		$this->tagMapper = $tagMapper;
-	}
-
-	/**
-	 * This initializes the plugin.
-	 *
-	 * This function is called by \Sabre\DAV\Server, after
-	 * addPlugin is called.
-	 *
-	 * This method should set up the required event subscriptions.
-	 *
-	 * @param \Sabre\DAV\Server $server
-	 * @return void
-	 */
-	public function initialize(\Sabre\DAV\Server $server) {
-		$server->xml->namespaceMap[self::NS_OWNCLOUD] = 'oc';
-
-		$server->protectedProperties[] = self::ID_PROPERTYNAME;
-
-		$server->on('propFind', [$this, 'handleGetProperties']);
-		$server->on('propPatch', [$this, 'handleUpdateProperties']);
-		$server->on('method:POST', [$this, 'httpPost']);
-
-		$this->server = $server;
-	}
-
-	/**
-	 * POST operation on system tag collections
-	 *
-	 * @param RequestInterface $request request object
-	 * @param ResponseInterface $response response object
-	 * @return null|false
-	 */
-	public function httpPost(RequestInterface $request, ResponseInterface $response) {
-		$path = $request->getPath();
-
-		// Making sure the node exists
-		$node = $this->server->tree->getNodeForPath($path);
-		if ($node instanceof SystemTagsByIdCollection || $node instanceof SystemTagsObjectMappingCollection) {
-			$data = $request->getBodyAsString();
-
-			$tag = $this->createTag($data, $request->getHeader('Content-Type'));
-
-			if ($node instanceof SystemTagsObjectMappingCollection) {
-				// also add to collection
-				$node->createFile($tag->getId());
-				$url = $request->getBaseUrl() . 'systemtags/';
-			} else {
-				$url = $request->getUrl();
-			}
-
-			if ($url[strlen($url) - 1] !== '/') {
-				$url .= '/';
-			}
-
-			$response->setHeader('Content-Location', $url . $tag->getId());
-
-			// created
-			$response->setStatus(201);
-			return false;
-		}
-	}
-
-	/**
-	 * Creates a new tag
-	 *
-	 * @param string $data JSON encoded string containing the properties of the tag to create
-	 * @param string $contentType content type of the data
-	 * @return ISystemTag newly created system tag
-	 *
-	 * @throws BadRequest if a field was missing
-	 * @throws Conflict if a tag with the same properties already exists
-	 * @throws UnsupportedMediaType if the content type is not supported
-	 */
-	private function createTag($data, $contentType = 'application/json') {
-		if (explode(';', $contentType)[0] === 'application/json') {
-			$data = json_decode($data, true, 512, JSON_THROW_ON_ERROR);
-		} else {
-			throw new UnsupportedMediaType();
-		}
-
-		if (!isset($data['name'])) {
-			throw new BadRequest('Missing "name" attribute');
-		}
-
-		$tagName = $data['name'];
-		$userVisible = true;
-		$userAssignable = true;
-
-		if (isset($data['userVisible'])) {
-			$userVisible = (bool)$data['userVisible'];
-		}
-
-		if (isset($data['userAssignable'])) {
-			$userAssignable = (bool)$data['userAssignable'];
-		}
-
-		$groups = [];
-		if (isset($data['groups'])) {
-			$groups = $data['groups'];
-			if (is_string($groups)) {
-				$groups = explode('|', $groups);
-			}
-		}
-
-		if ($userVisible === false || $userAssignable === false || !empty($groups)) {
-			if (!$this->userSession->isLoggedIn() || !$this->groupManager->isAdmin($this->userSession->getUser()->getUID())) {
-				throw new BadRequest('Not sufficient permissions');
-			}
-		}
-
-		try {
-			$tag = $this->tagManager->createTag($tagName, $userVisible, $userAssignable);
-			if (!empty($groups)) {
-				$this->tagManager->setTagGroups($tag, $groups);
-			}
-			return $tag;
-		} catch (TagAlreadyExistsException $e) {
-			throw new Conflict('Tag already exists', 0, $e);
-		}
-	}
-
-
-	/**
-	 * Retrieves system tag properties
-	 *
-	 * @param PropFind $propFind
-	 * @param \Sabre\DAV\INode $node
-	 *
-	 * @return void
-	 */
-	public function handleGetProperties(
-		PropFind $propFind,
-		\Sabre\DAV\INode $node
-	) {
-		if ($node instanceof Node) {
-			$this->propfindForFile($propFind, $node);
-			return;
-		}
-
-		if (!($node instanceof SystemTagNode) && !($node instanceof SystemTagMappingNode)) {
-			return;
-		}
-
-		// child nodes from systemtags-assigned should point to normal tag endpoint
-		if (preg_match('/^systemtags-assigned\/[0-9]+/', $propFind->getPath())) {
-			$propFind->setPath(str_replace('systemtags-assigned/', 'systemtags/', $propFind->getPath()));
-		}
-
-		$propFind->handle(self::ID_PROPERTYNAME, function () use ($node) {
-			return $node->getSystemTag()->getId();
-		});
-
-		$propFind->handle(self::DISPLAYNAME_PROPERTYNAME, function () use ($node) {
-			return $node->getSystemTag()->getName();
-		});
-
-		$propFind->handle(self::USERVISIBLE_PROPERTYNAME, function () use ($node) {
-			return $node->getSystemTag()->isUserVisible() ? 'true' : 'false';
-		});
-
-		$propFind->handle(self::USERASSIGNABLE_PROPERTYNAME, function () use ($node) {
-			// this is the tag's inherent property "is user assignable"
-			return $node->getSystemTag()->isUserAssignable() ? 'true' : 'false';
-		});
-
-		$propFind->handle(self::CANASSIGN_PROPERTYNAME, function () use ($node) {
-			// this is the effective permission for the current user
-			return $this->tagManager->canUserAssignTag($node->getSystemTag(), $this->userSession->getUser()) ? 'true' : 'false';
-		});
-
-		$propFind->handle(self::GROUPS_PROPERTYNAME, function () use ($node) {
-			if (!$this->groupManager->isAdmin($this->userSession->getUser()->getUID())) {
-				// property only available for admins
-				throw new Forbidden();
-			}
-			$groups = [];
-			// no need to retrieve groups for namespaces that don't qualify
-			if ($node->getSystemTag()->isUserVisible() && !$node->getSystemTag()->isUserAssignable()) {
-				$groups = $this->tagManager->getTagGroups($node->getSystemTag());
-			}
-			return implode('|', $groups);
-		});
-
-		if ($node instanceof SystemTagNode) {
-			$propFind->handle(self::NUM_FILES_PROPERTYNAME, function () use ($node): int {
-				return $node->getNumberOfFiles();
-			});
-
-			$propFind->handle(self::FILEID_PROPERTYNAME, function () use ($node): int {
-				return $node->getReferenceFileId();
-			});
-		}
-	}
-
-	private function propfindForFile(PropFind $propFind, Node $node): void {
-		if ($node instanceof Directory
-			&& $propFind->getDepth() !== 0
-			&& !is_null($propFind->getStatus(self::SYSTEM_TAGS_PROPERTYNAME))) {
-			$fileIds = [$node->getId()];
-
-			// note: pre-fetching only supported for depth <= 1
-			$folderContent = $node->getNode()->getDirectoryListing();
-			foreach ($folderContent as $info) {
-				$fileIds[] = $info->getId();
-			}
-
-			$tags = $this->tagMapper->getTagIdsForObjects($fileIds, 'files');
-
-			$this->cachedTagMappings = $this->cachedTagMappings + $tags;
-			$emptyFileIds = array_diff($fileIds, array_keys($tags));
-
-			// also cache the ones that were not found
-			foreach ($emptyFileIds as $fileId) {
-				$this->cachedTagMappings[$fileId] = [];
-			}
-		}
-
-		$propFind->handle(self::SYSTEM_TAGS_PROPERTYNAME, function () use ($node) {
-			$user = $this->userSession->getUser();
-			if ($user === null) {
-				return;
-			}
-
-			$tags = $this->getTagsForFile($node->getId(), $user);
-			usort($tags, function (ISystemTag $tagA, ISystemTag $tagB): int {
-				return Util::naturalSortCompare($tagA->getName(), $tagB->getName());
-			});
-			return new SystemTagList($tags, $this->tagManager, $user);
-		});
-	}
-
-	/**
-	 * @param int $fileId
-	 * @return ISystemTag[]
-	 */
-	private function getTagsForFile(int $fileId, IUser $user): array {
-
-		if (isset($this->cachedTagMappings[$fileId])) {
-			$tagIds = $this->cachedTagMappings[$fileId];
-		} else {
-			$tags = $this->tagMapper->getTagIdsForObjects([$fileId], 'files');
-			$fileTags = current($tags);
-			if ($fileTags) {
-				$tagIds = $fileTags;
-			} else {
-				$tagIds = [];
-			}
-		}
-
-		$tags = array_filter(array_map(function(string $tagId) {
-			return $this->cachedTags[$tagId] ?? null;
-		}, $tagIds));
-
-		$uncachedTagIds = array_filter($tagIds, function(string $tagId): bool {
-			return !isset($this->cachedTags[$tagId]);
-		});
-
-		if (count($uncachedTagIds)) {
-			$retrievedTags = $this->tagManager->getTagsByIds($uncachedTagIds);
-			foreach ($retrievedTags as $tag) {
-				$this->cachedTags[$tag->getId()] = $tag;
-			}
-			$tags += $retrievedTags;
-		}
-
-		return array_filter($tags, function(ISystemTag $tag) use ($user) {
-			return $this->tagManager->canUserSeeTag($tag, $user);
-		});
-	}
-
-	/**
-	 * Updates tag attributes
-	 *
-	 * @param string $path
-	 * @param PropPatch $propPatch
-	 *
-	 * @return void
-	 */
-	public function handleUpdateProperties($path, PropPatch $propPatch) {
-		$node = $this->server->tree->getNodeForPath($path);
-		if (!($node instanceof SystemTagNode)) {
-			return;
-		}
-
-		$propPatch->handle([
-			self::DISPLAYNAME_PROPERTYNAME,
-			self::USERVISIBLE_PROPERTYNAME,
-			self::USERASSIGNABLE_PROPERTYNAME,
-			self::GROUPS_PROPERTYNAME,
-			self::NUM_FILES_PROPERTYNAME,
-			self::FILEID_PROPERTYNAME,
-		], function ($props) use ($node) {
-			$tag = $node->getSystemTag();
-			$name = $tag->getName();
-			$userVisible = $tag->isUserVisible();
-			$userAssignable = $tag->isUserAssignable();
-
-			$updateTag = false;
-
-			if (isset($props[self::DISPLAYNAME_PROPERTYNAME])) {
-				$name = $props[self::DISPLAYNAME_PROPERTYNAME];
-				$updateTag = true;
-			}
-
-			if (isset($props[self::USERVISIBLE_PROPERTYNAME])) {
-				$propValue = $props[self::USERVISIBLE_PROPERTYNAME];
-				$userVisible = ($propValue !== 'false' && $propValue !== '0');
-				$updateTag = true;
-			}
-
-			if (isset($props[self::USERASSIGNABLE_PROPERTYNAME])) {
-				$propValue = $props[self::USERASSIGNABLE_PROPERTYNAME];
-				$userAssignable = ($propValue !== 'false' && $propValue !== '0');
-				$updateTag = true;
-			}
-
-			if (isset($props[self::GROUPS_PROPERTYNAME])) {
-				if (!$this->groupManager->isAdmin($this->userSession->getUser()->getUID())) {
-					// property only available for admins
-					throw new Forbidden();
-				}
-
-				$propValue = $props[self::GROUPS_PROPERTYNAME];
-				$groupIds = explode('|', $propValue);
-				$this->tagManager->setTagGroups($tag, $groupIds);
-			}
-
-			if (isset($props[self::NUM_FILES_PROPERTYNAME]) || isset($props[self::FILEID_PROPERTYNAME])) {
-				// read-only properties
-				throw new Forbidden();
-			}
-
-			if ($updateTag) {
-				$node->update($name, $userVisible, $userAssignable);
-			}
-
-			return true;
-		});
-	}
+    // namespace
+    public const NS_OWNCLOUD = 'http://owncloud.org/ns';
+    public const ID_PROPERTYNAME = '{http://owncloud.org/ns}id';
+    public const DISPLAYNAME_PROPERTYNAME = '{http://owncloud.org/ns}display-name';
+    public const USERVISIBLE_PROPERTYNAME = '{http://owncloud.org/ns}user-visible';
+    public const USERASSIGNABLE_PROPERTYNAME = '{http://owncloud.org/ns}user-assignable';
+    public const GROUPS_PROPERTYNAME = '{http://owncloud.org/ns}groups';
+    public const CANASSIGN_PROPERTYNAME = '{http://owncloud.org/ns}can-assign';
+    public const SYSTEM_TAGS_PROPERTYNAME = '{http://nextcloud.org/ns}system-tags';
+    public const NUM_FILES_PROPERTYNAME = '{http://nextcloud.org/ns}files-assigned';
+    public const FILEID_PROPERTYNAME = '{http://nextcloud.org/ns}reference-fileid';
+
+    /**
+     * @var \Sabre\DAV\Server $server
+     */
+    private $server;
+
+    /**
+     * @var ISystemTagManager
+     */
+    protected $tagManager;
+
+    /**
+     * @var IUserSession
+     */
+    protected $userSession;
+
+    /**
+     * @var IGroupManager
+     */
+    protected $groupManager;
+
+    /** @var array<int, string[]> */
+    private array $cachedTagMappings = [];
+    /** @var array<string, ISystemTag> */
+    private array $cachedTags = [];
+
+    private ISystemTagObjectMapper $tagMapper;
+
+    public function __construct(
+        ISystemTagManager $tagManager,
+        IGroupManager $groupManager,
+        IUserSession $userSession,
+        ISystemTagObjectMapper $tagMapper,
+    ) {
+        $this->tagManager = $tagManager;
+        $this->userSession = $userSession;
+        $this->groupManager = $groupManager;
+        $this->tagMapper = $tagMapper;
+    }
+
+    /**
+     * This initializes the plugin.
+     *
+     * This function is called by \Sabre\DAV\Server, after
+     * addPlugin is called.
+     *
+     * This method should set up the required event subscriptions.
+     *
+     * @param \Sabre\DAV\Server $server
+     * @return void
+     */
+    public function initialize(\Sabre\DAV\Server $server) {
+        $server->xml->namespaceMap[self::NS_OWNCLOUD] = 'oc';
+
+        $server->protectedProperties[] = self::ID_PROPERTYNAME;
+
+        $server->on('propFind', [$this, 'handleGetProperties']);
+        $server->on('propPatch', [$this, 'handleUpdateProperties']);
+        $server->on('method:POST', [$this, 'httpPost']);
+
+        $this->server = $server;
+    }
+
+    /**
+     * POST operation on system tag collections
+     *
+     * @param RequestInterface $request request object
+     * @param ResponseInterface $response response object
+     * @return null|false
+     */
+    public function httpPost(RequestInterface $request, ResponseInterface $response) {
+        $path = $request->getPath();
+
+        // Making sure the node exists
+        $node = $this->server->tree->getNodeForPath($path);
+        if ($node instanceof SystemTagsByIdCollection || $node instanceof SystemTagsObjectMappingCollection) {
+            $data = $request->getBodyAsString();
+
+            $tag = $this->createTag($data, $request->getHeader('Content-Type'));
+
+            if ($node instanceof SystemTagsObjectMappingCollection) {
+                // also add to collection
+                $node->createFile($tag->getId());
+                $url = $request->getBaseUrl() . 'systemtags/';
+            } else {
+                $url = $request->getUrl();
+            }
+
+            if ($url[strlen($url) - 1] !== '/') {
+                $url .= '/';
+            }
+
+            $response->setHeader('Content-Location', $url . $tag->getId());
+
+            // created
+            $response->setStatus(201);
+            return false;
+        }
+    }
+
+    /**
+     * Creates a new tag
+     *
+     * @param string $data JSON encoded string containing the properties of the tag to create
+     * @param string $contentType content type of the data
+     * @return ISystemTag newly created system tag
+     *
+     * @throws BadRequest if a field was missing
+     * @throws Conflict if a tag with the same properties already exists
+     * @throws UnsupportedMediaType if the content type is not supported
+     */
+    private function createTag($data, $contentType = 'application/json') {
+        if (explode(';', $contentType)[0] === 'application/json') {
+            $data = json_decode($data, true, 512, JSON_THROW_ON_ERROR);
+        } else {
+            throw new UnsupportedMediaType();
+        }
+
+        if (!isset($data['name'])) {
+            throw new BadRequest('Missing "name" attribute');
+        }
+
+        $tagName = $data['name'];
+        $userVisible = true;
+        $userAssignable = true;
+
+        if (isset($data['userVisible'])) {
+            $userVisible = (bool)$data['userVisible'];
+        }
+
+        if (isset($data['userAssignable'])) {
+            $userAssignable = (bool)$data['userAssignable'];
+        }
+
+        $groups = [];
+        if (isset($data['groups'])) {
+            $groups = $data['groups'];
+            if (is_string($groups)) {
+                $groups = explode('|', $groups);
+            }
+        }
+
+        if ($userVisible === false || $userAssignable === false || !empty($groups)) {
+            if (!$this->userSession->isLoggedIn() || !$this->groupManager->isAdmin($this->userSession->getUser()->getUID())) {
+                throw new BadRequest('Not sufficient permissions');
+            }
+        }
+
+        try {
+            $tag = $this->tagManager->createTag($tagName, $userVisible, $userAssignable);
+            if (!empty($groups)) {
+                $this->tagManager->setTagGroups($tag, $groups);
+            }
+            return $tag;
+        } catch (TagAlreadyExistsException $e) {
+            throw new Conflict('Tag already exists', 0, $e);
+        }
+    }
+
+
+    /**
+     * Retrieves system tag properties
+     *
+     * @param PropFind $propFind
+     * @param \Sabre\DAV\INode $node
+     *
+     * @return void
+     */
+    public function handleGetProperties(
+        PropFind $propFind,
+        \Sabre\DAV\INode $node
+    ) {
+        if ($node instanceof Node) {
+            $this->propfindForFile($propFind, $node);
+            return;
+        }
+
+        if (!($node instanceof SystemTagNode) && !($node instanceof SystemTagMappingNode)) {
+            return;
+        }
+
+        // child nodes from systemtags-assigned should point to normal tag endpoint
+        if (preg_match('/^systemtags-assigned\/[0-9]+/', $propFind->getPath())) {
+            $propFind->setPath(str_replace('systemtags-assigned/', 'systemtags/', $propFind->getPath()));
+        }
+
+        $propFind->handle(self::ID_PROPERTYNAME, function () use ($node) {
+            return $node->getSystemTag()->getId();
+        });
+
+        $propFind->handle(self::DISPLAYNAME_PROPERTYNAME, function () use ($node) {
+            return $node->getSystemTag()->getName();
+        });
+
+        $propFind->handle(self::USERVISIBLE_PROPERTYNAME, function () use ($node) {
+            return $node->getSystemTag()->isUserVisible() ? 'true' : 'false';
+        });
+
+        $propFind->handle(self::USERASSIGNABLE_PROPERTYNAME, function () use ($node) {
+            // this is the tag's inherent property "is user assignable"
+            return $node->getSystemTag()->isUserAssignable() ? 'true' : 'false';
+        });
+
+        $propFind->handle(self::CANASSIGN_PROPERTYNAME, function () use ($node) {
+            // this is the effective permission for the current user
+            return $this->tagManager->canUserAssignTag($node->getSystemTag(), $this->userSession->getUser()) ? 'true' : 'false';
+        });
+
+        $propFind->handle(self::GROUPS_PROPERTYNAME, function () use ($node) {
+            if (!$this->groupManager->isAdmin($this->userSession->getUser()->getUID())) {
+                // property only available for admins
+                throw new Forbidden();
+            }
+            $groups = [];
+            // no need to retrieve groups for namespaces that don't qualify
+            if ($node->getSystemTag()->isUserVisible() && !$node->getSystemTag()->isUserAssignable()) {
+                $groups = $this->tagManager->getTagGroups($node->getSystemTag());
+            }
+            return implode('|', $groups);
+        });
+
+        if ($node instanceof SystemTagNode) {
+            $propFind->handle(self::NUM_FILES_PROPERTYNAME, function () use ($node): int {
+                return $node->getNumberOfFiles();
+            });
+
+            $propFind->handle(self::FILEID_PROPERTYNAME, function () use ($node): int {
+                return $node->getReferenceFileId();
+            });
+        }
+    }
+
+    private function propfindForFile(PropFind $propFind, Node $node): void {
+        if ($node instanceof Directory
+            && $propFind->getDepth() !== 0
+            && !is_null($propFind->getStatus(self::SYSTEM_TAGS_PROPERTYNAME))) {
+            $fileIds = [$node->getId()];
+
+            // note: pre-fetching only supported for depth <= 1
+            $folderContent = $node->getNode()->getDirectoryListing();
+            foreach ($folderContent as $info) {
+                $fileIds[] = $info->getId();
+            }
+
+            $tags = $this->tagMapper->getTagIdsForObjects($fileIds, 'files');
+
+            $this->cachedTagMappings = $this->cachedTagMappings + $tags;
+            $emptyFileIds = array_diff($fileIds, array_keys($tags));
+
+            // also cache the ones that were not found
+            foreach ($emptyFileIds as $fileId) {
+                $this->cachedTagMappings[$fileId] = [];
+            }
+        }
+
+        $propFind->handle(self::SYSTEM_TAGS_PROPERTYNAME, function () use ($node) {
+            $user = $this->userSession->getUser();
+            if ($user === null) {
+                return;
+            }
+
+            $tags = $this->getTagsForFile($node->getId(), $user);
+            usort($tags, function (ISystemTag $tagA, ISystemTag $tagB): int {
+                return Util::naturalSortCompare($tagA->getName(), $tagB->getName());
+            });
+            return new SystemTagList($tags, $this->tagManager, $user);
+        });
+    }
+
+    /**
+     * @param int $fileId
+     * @return ISystemTag[]
+     */
+    private function getTagsForFile(int $fileId, IUser $user): array {
+
+        if (isset($this->cachedTagMappings[$fileId])) {
+            $tagIds = $this->cachedTagMappings[$fileId];
+        } else {
+            $tags = $this->tagMapper->getTagIdsForObjects([$fileId], 'files');
+            $fileTags = current($tags);
+            if ($fileTags) {
+                $tagIds = $fileTags;
+            } else {
+                $tagIds = [];
+            }
+        }
+
+        $tags = array_filter(array_map(function(string $tagId) {
+            return $this->cachedTags[$tagId] ?? null;
+        }, $tagIds));
+
+        $uncachedTagIds = array_filter($tagIds, function(string $tagId): bool {
+            return !isset($this->cachedTags[$tagId]);
+        });
+
+        if (count($uncachedTagIds)) {
+            $retrievedTags = $this->tagManager->getTagsByIds($uncachedTagIds);
+            foreach ($retrievedTags as $tag) {
+                $this->cachedTags[$tag->getId()] = $tag;
+            }
+            $tags += $retrievedTags;
+        }
+
+        return array_filter($tags, function(ISystemTag $tag) use ($user) {
+            return $this->tagManager->canUserSeeTag($tag, $user);
+        });
+    }
+
+    /**
+     * Updates tag attributes
+     *
+     * @param string $path
+     * @param PropPatch $propPatch
+     *
+     * @return void
+     */
+    public function handleUpdateProperties($path, PropPatch $propPatch) {
+        $node = $this->server->tree->getNodeForPath($path);
+        if (!($node instanceof SystemTagNode)) {
+            return;
+        }
+
+        $propPatch->handle([
+            self::DISPLAYNAME_PROPERTYNAME,
+            self::USERVISIBLE_PROPERTYNAME,
+            self::USERASSIGNABLE_PROPERTYNAME,
+            self::GROUPS_PROPERTYNAME,
+            self::NUM_FILES_PROPERTYNAME,
+            self::FILEID_PROPERTYNAME,
+        ], function ($props) use ($node) {
+            $tag = $node->getSystemTag();
+            $name = $tag->getName();
+            $userVisible = $tag->isUserVisible();
+            $userAssignable = $tag->isUserAssignable();
+
+            $updateTag = false;
+
+            if (isset($props[self::DISPLAYNAME_PROPERTYNAME])) {
+                $name = $props[self::DISPLAYNAME_PROPERTYNAME];
+                $updateTag = true;
+            }
+
+            if (isset($props[self::USERVISIBLE_PROPERTYNAME])) {
+                $propValue = $props[self::USERVISIBLE_PROPERTYNAME];
+                $userVisible = ($propValue !== 'false' && $propValue !== '0');
+                $updateTag = true;
+            }
+
+            if (isset($props[self::USERASSIGNABLE_PROPERTYNAME])) {
+                $propValue = $props[self::USERASSIGNABLE_PROPERTYNAME];
+                $userAssignable = ($propValue !== 'false' && $propValue !== '0');
+                $updateTag = true;
+            }
+
+            if (isset($props[self::GROUPS_PROPERTYNAME])) {
+                if (!$this->groupManager->isAdmin($this->userSession->getUser()->getUID())) {
+                    // property only available for admins
+                    throw new Forbidden();
+                }
+
+                $propValue = $props[self::GROUPS_PROPERTYNAME];
+                $groupIds = explode('|', $propValue);
+                $this->tagManager->setTagGroups($tag, $groupIds);
+            }
+
+            if (isset($props[self::NUM_FILES_PROPERTYNAME]) || isset($props[self::FILEID_PROPERTYNAME])) {
+                // read-only properties
+                throw new Forbidden();
+            }
+
+            if ($updateTag) {
+                $node->update($name, $userVisible, $userAssignable);
+            }
+
+            return true;
+        });
+    }
 }

apps/dav/lib/SystemTag/SystemTagNode.php

Indentation +158 added lines, -158 removed lines

@@ -40,162 +40,162 @@
  */
 class SystemTagNode implements \Sabre\DAV\INode {
 
-	/**
-	 * @var ISystemTag
-	 */
-	protected $tag;
-
-	/**
-	 * @var ISystemTagManager
-	 */
-	protected $tagManager;
-
-	/**
-	 * User
-	 *
-	 * @var IUser
-	 */
-	protected $user;
-
-	/**
-	 * Whether to allow permissions for admins
-	 *
-	 * @var bool
-	 */
-	protected $isAdmin;
-
-	protected int $numberOfFiles = -1;
-	protected int $referenceFileId = -1;
-
-	/**
-	 * Sets up the node, expects a full path name
-	 *
-	 * @param ISystemTag $tag system tag
-	 * @param IUser $user user
-	 * @param bool $isAdmin whether to allow operations for admins
-	 * @param ISystemTagManager $tagManager tag manager
-	 */
-	public function __construct(ISystemTag $tag, IUser $user, $isAdmin, ISystemTagManager $tagManager) {
-		$this->tag = $tag;
-		$this->user = $user;
-		$this->isAdmin = $isAdmin;
-		$this->tagManager = $tagManager;
-	}
-
-	/**
-	 *  Returns the id of the tag
-	 *
-	 * @return string
-	 */
-	public function getName() {
-		return $this->tag->getId();
-	}
-
-	/**
-	 * Returns the system tag represented by this node
-	 *
-	 * @return ISystemTag system tag
-	 */
-	public function getSystemTag() {
-		return $this->tag;
-	}
-
-	/**
-	 * Renames the node
-	 *
-	 * @param string $name The new name
-	 *
-	 * @throws MethodNotAllowed not allowed to rename node
-	 *
-	 * @return never
-	 */
-	public function setName($name) {
-		throw new MethodNotAllowed();
-	}
-
-	/**
-	 * Update tag
-	 *
-	 * @param string $name new tag name
-	 * @param bool $userVisible user visible
-	 * @param bool $userAssignable user assignable
-	 *
-	 * @throws NotFound whenever the given tag id does not exist
-	 * @throws Forbidden whenever there is no permission to update said tag
-	 * @throws Conflict whenever a tag already exists with the given attributes
-	 */
-	public function update($name, $userVisible, $userAssignable): void {
-		try {
-			if (!$this->tagManager->canUserSeeTag($this->tag, $this->user)) {
-				throw new NotFound('Tag with id ' . $this->tag->getId() . ' does not exist');
-			}
-			if (!$this->tagManager->canUserAssignTag($this->tag, $this->user)) {
-				throw new Forbidden('No permission to update tag ' . $this->tag->getId());
-			}
-
-			// only admin is able to change permissions, regular users can only rename
-			if (!$this->isAdmin) {
-				// only renaming is allowed for regular users
-				if ($userVisible !== $this->tag->isUserVisible()
-					|| $userAssignable !== $this->tag->isUserAssignable()
-				) {
-					throw new Forbidden('No permission to update permissions for tag ' . $this->tag->getId());
-				}
-			}
-
-			$this->tagManager->updateTag($this->tag->getId(), $name, $userVisible, $userAssignable);
-		} catch (TagNotFoundException $e) {
-			throw new NotFound('Tag with id ' . $this->tag->getId() . ' does not exist');
-		} catch (TagAlreadyExistsException $e) {
-			throw new Conflict(
-				'Tag with the properties "' . $name . '", ' .
-				$userVisible . ', ' . $userAssignable . ' already exists'
-			);
-		}
-	}
-
-	/**
-	 * Returns null, not supported
-	 *
-	 * @return null
-	 */
-	public function getLastModified() {
-		return null;
-	}
-
-	/**
-	 * @return void
-	 */
-	public function delete() {
-		try {
-			if (!$this->isAdmin) {
-				throw new Forbidden('No permission to delete tag ' . $this->tag->getId());
-			}
-
-			if (!$this->tagManager->canUserSeeTag($this->tag, $this->user)) {
-				throw new NotFound('Tag with id ' . $this->tag->getId() . ' not found');
-			}
-
-			$this->tagManager->deleteTags($this->tag->getId());
-		} catch (TagNotFoundException $e) {
-			// can happen if concurrent deletion occurred
-			throw new NotFound('Tag with id ' . $this->tag->getId() . ' not found', 0, $e);
-		}
-	}
-
-	public function getNumberOfFiles(): int {
-		return $this->numberOfFiles;
-	}
-
-	public function setNumberOfFiles(int $numberOfFiles): void {
-		$this->numberOfFiles = $numberOfFiles;
-	}
-
-	public function getReferenceFileId(): int {
-		return $this->referenceFileId;
-	}
-
-	public function setReferenceFileId(int $referenceFileId): void {
-		$this->referenceFileId = $referenceFileId;
-	}
+    /**
+     * @var ISystemTag
+     */
+    protected $tag;
+
+    /**
+     * @var ISystemTagManager
+     */
+    protected $tagManager;
+
+    /**
+     * User
+     *
+     * @var IUser
+     */
+    protected $user;
+
+    /**
+     * Whether to allow permissions for admins
+     *
+     * @var bool
+     */
+    protected $isAdmin;
+
+    protected int $numberOfFiles = -1;
+    protected int $referenceFileId = -1;
+
+    /**
+     * Sets up the node, expects a full path name
+     *
+     * @param ISystemTag $tag system tag
+     * @param IUser $user user
+     * @param bool $isAdmin whether to allow operations for admins
+     * @param ISystemTagManager $tagManager tag manager
+     */
+    public function __construct(ISystemTag $tag, IUser $user, $isAdmin, ISystemTagManager $tagManager) {
+        $this->tag = $tag;
+        $this->user = $user;
+        $this->isAdmin = $isAdmin;
+        $this->tagManager = $tagManager;
+    }
+
+    /**
+     *  Returns the id of the tag
+     *
+     * @return string
+     */
+    public function getName() {
+        return $this->tag->getId();
+    }
+
+    /**
+     * Returns the system tag represented by this node
+     *
+     * @return ISystemTag system tag
+     */
+    public function getSystemTag() {
+        return $this->tag;
+    }
+
+    /**
+     * Renames the node
+     *
+     * @param string $name The new name
+     *
+     * @throws MethodNotAllowed not allowed to rename node
+     *
+     * @return never
+     */
+    public function setName($name) {
+        throw new MethodNotAllowed();
+    }
+
+    /**
+     * Update tag
+     *
+     * @param string $name new tag name
+     * @param bool $userVisible user visible
+     * @param bool $userAssignable user assignable
+     *
+     * @throws NotFound whenever the given tag id does not exist
+     * @throws Forbidden whenever there is no permission to update said tag
+     * @throws Conflict whenever a tag already exists with the given attributes
+     */
+    public function update($name, $userVisible, $userAssignable): void {
+        try {
+            if (!$this->tagManager->canUserSeeTag($this->tag, $this->user)) {
+                throw new NotFound('Tag with id ' . $this->tag->getId() . ' does not exist');
+            }
+            if (!$this->tagManager->canUserAssignTag($this->tag, $this->user)) {
+                throw new Forbidden('No permission to update tag ' . $this->tag->getId());
+            }
+
+            // only admin is able to change permissions, regular users can only rename
+            if (!$this->isAdmin) {
+                // only renaming is allowed for regular users
+                if ($userVisible !== $this->tag->isUserVisible()
+                    || $userAssignable !== $this->tag->isUserAssignable()
+                ) {
+                    throw new Forbidden('No permission to update permissions for tag ' . $this->tag->getId());
+                }
+            }
+
+            $this->tagManager->updateTag($this->tag->getId(), $name, $userVisible, $userAssignable);
+        } catch (TagNotFoundException $e) {
+            throw new NotFound('Tag with id ' . $this->tag->getId() . ' does not exist');
+        } catch (TagAlreadyExistsException $e) {
+            throw new Conflict(
+                'Tag with the properties "' . $name . '", ' .
+                $userVisible . ', ' . $userAssignable . ' already exists'
+            );
+        }
+    }
+
+    /**
+     * Returns null, not supported
+     *
+     * @return null
+     */
+    public function getLastModified() {
+        return null;
+    }
+
+    /**
+     * @return void
+     */
+    public function delete() {
+        try {
+            if (!$this->isAdmin) {
+                throw new Forbidden('No permission to delete tag ' . $this->tag->getId());
+            }
+
+            if (!$this->tagManager->canUserSeeTag($this->tag, $this->user)) {
+                throw new NotFound('Tag with id ' . $this->tag->getId() . ' not found');
+            }
+
+            $this->tagManager->deleteTags($this->tag->getId());
+        } catch (TagNotFoundException $e) {
+            // can happen if concurrent deletion occurred
+            throw new NotFound('Tag with id ' . $this->tag->getId() . ' not found', 0, $e);
+        }
+    }
+
+    public function getNumberOfFiles(): int {
+        return $this->numberOfFiles;
+    }
+
+    public function setNumberOfFiles(int $numberOfFiles): void {
+        $this->numberOfFiles = $numberOfFiles;
+    }
+
+    public function getReferenceFileId(): int {
+        return $this->referenceFileId;
+    }
+
+    public function setReferenceFileId(int $referenceFileId): void {
+        $this->referenceFileId = $referenceFileId;
+    }
 }

apps/dav/lib/SystemTag/SystemTagsInUseCollection.php

Indentation +62 added lines, -62 removed lines

@@ -38,71 +38,71 @@
 use Sabre\DAV\SimpleCollection;
 
 class SystemTagsInUseCollection extends SimpleCollection {
-	protected IUserSession $userSession;
-	protected IRootFolder $rootFolder;
-	protected string $mediaType;
-	protected ISystemTagManager $systemTagManager;
-	protected SystemTagsInFilesDetector $systemTagsInFilesDetector;
+    protected IUserSession $userSession;
+    protected IRootFolder $rootFolder;
+    protected string $mediaType;
+    protected ISystemTagManager $systemTagManager;
+    protected SystemTagsInFilesDetector $systemTagsInFilesDetector;
 
-	/** @noinspection PhpMissingParentConstructorInspection */
-	public function __construct(
-		IUserSession $userSession,
-		IRootFolder $rootFolder,
-		ISystemTagManager $systemTagManager,
-		SystemTagsInFilesDetector $systemTagsInFilesDetector,
-		string $mediaType = ''
-	) {
-		$this->userSession = $userSession;
-		$this->rootFolder = $rootFolder;
-		$this->systemTagManager = $systemTagManager;
-		$this->mediaType = $mediaType;
-		$this->systemTagsInFilesDetector = $systemTagsInFilesDetector;
-		$this->name = 'systemtags-assigned';
-		if ($this->mediaType != '') {
-			$this->name .= '/' . $this->mediaType;
-		}
-	}
+    /** @noinspection PhpMissingParentConstructorInspection */
+    public function __construct(
+        IUserSession $userSession,
+        IRootFolder $rootFolder,
+        ISystemTagManager $systemTagManager,
+        SystemTagsInFilesDetector $systemTagsInFilesDetector,
+        string $mediaType = ''
+    ) {
+        $this->userSession = $userSession;
+        $this->rootFolder = $rootFolder;
+        $this->systemTagManager = $systemTagManager;
+        $this->mediaType = $mediaType;
+        $this->systemTagsInFilesDetector = $systemTagsInFilesDetector;
+        $this->name = 'systemtags-assigned';
+        if ($this->mediaType != '') {
+            $this->name .= '/' . $this->mediaType;
+        }
+    }
 
-	public function setName($name): void {
-		throw new Forbidden('Permission denied to rename this collection');
-	}
+    public function setName($name): void {
+        throw new Forbidden('Permission denied to rename this collection');
+    }
 
-	public function getChild($name): self {
-		if ($this->mediaType !== '') {
-			throw new NotFound('Invalid media type');
-		}
-		return new self($this->userSession, $this->rootFolder, $this->systemTagManager, $this->systemTagsInFilesDetector, $name);
-	}
+    public function getChild($name): self {
+        if ($this->mediaType !== '') {
+            throw new NotFound('Invalid media type');
+        }
+        return new self($this->userSession, $this->rootFolder, $this->systemTagManager, $this->systemTagsInFilesDetector, $name);
+    }
 
-	/**
-	 * @return SystemTagNode[]
-	 * @throws NotPermittedException
-	 * @throws Forbidden
-	 */
-	public function getChildren(): array {
-		$user = $this->userSession->getUser();
-		$userFolder = null;
-		try {
-			if ($user) {
-				$userFolder = $this->rootFolder->getUserFolder($user->getUID());
-			}
-		} catch (NoUserException) {
-			// will throw a Sabre exception in the next step.
-		}
-		if ($user === null || $userFolder === null) {
-			throw new Forbidden('Permission denied to read this collection');
-		}
+    /**
+     * @return SystemTagNode[]
+     * @throws NotPermittedException
+     * @throws Forbidden
+     */
+    public function getChildren(): array {
+        $user = $this->userSession->getUser();
+        $userFolder = null;
+        try {
+            if ($user) {
+                $userFolder = $this->rootFolder->getUserFolder($user->getUID());
+            }
+        } catch (NoUserException) {
+            // will throw a Sabre exception in the next step.
+        }
+        if ($user === null || $userFolder === null) {
+            throw new Forbidden('Permission denied to read this collection');
+        }
 
-		$result = $this->systemTagsInFilesDetector->detectAssignedSystemTagsIn($userFolder, $this->mediaType);
-		$children = [];
-		foreach ($result as $tagData) {
-			$tag = new SystemTag((string)$tagData['id'], $tagData['name'], (bool)$tagData['visibility'], (bool)$tagData['editable']);
-			// read only, so we can submit the isAdmin parameter as false generally
-			$node = new SystemTagNode($tag, $user, false, $this->systemTagManager);
-			$node->setNumberOfFiles($tagData['number_files']);
-			$node->setReferenceFileId($tagData['ref_file_id']);
-			$children[] = $node;
-		}
-		return $children;
-	}
+        $result = $this->systemTagsInFilesDetector->detectAssignedSystemTagsIn($userFolder, $this->mediaType);
+        $children = [];
+        foreach ($result as $tagData) {
+            $tag = new SystemTag((string)$tagData['id'], $tagData['name'], (bool)$tagData['visibility'], (bool)$tagData['editable']);
+            // read only, so we can submit the isAdmin parameter as false generally
+            $node = new SystemTagNode($tag, $user, false, $this->systemTagManager);
+            $node->setNumberOfFiles($tagData['number_files']);
+            $node->setReferenceFileId($tagData['ref_file_id']);
+            $children[] = $node;
+        }
+        return $children;
+    }
 }