CollectiveFolderManager.php

<?php

declare(strict_types=1);

/**
 * SPDX-FileCopyrightText: 2020 Nextcloud GmbH and Nextcloud contributors
 * SPDX-License-Identifier: AGPL-3.0-or-later
 */

namespace OCA\Collectives\Mount;

use Exception;
use OC;
use OC\Files\Node\LazyFolder;
use OC\Files\Storage\Wrapper\Jail;
use OC\Files\Storage\Wrapper\PermissionsMask;
use OCA\Collectives\ACL\ACLStorageWrapper;
use OCA\Collectives\Model\FileInfo;
use OCP\DB\QueryBuilder\IQueryBuilder;
use OCP\Files\Cache\ICacheEntry;
use OCP\Files\Folder;
use OCP\Files\InvalidPathException;
use OCP\Files\IRootFolder;
use OCP\Files\Mount\IMountPoint;
use OCP\Files\NotFoundException;
use OCP\Files\NotPermittedException;
use OCP\Files\Storage\IStorageFactory;
use OCP\IConfig;
use OCP\IDBConnection;
use OCP\IRequest;
use OCP\IUser;
use OCP\IUserSession;
use OCP\L10N\IFactory;
use OCP\Server;

class CollectiveFolderManager {
	private const SKELETON_DIR = 'skeleton';
	private const LANDING_PAGE_TITLE = 'Readme';
	private const SUFFIX = '.md';

	private ?string $rootPath = null;
	private ?int $rootFolderId = null;
	private ?Folder $collectivesRootFolder = null;

	public function __construct(
		private IRootFolder $rootFolder,
		private IDBConnection $connection,
		private IConfig $config,
		private IUserSession $userSession,
		private IRequest $request,
		private IFactory $l10nFactory,
	) {
	}

	private function getAppdataPath(): string {
		$instanceId = $this->config->getSystemValueString('instanceid');
		return 'appdata_' . $instanceId;
	}

	public function getRootPath(): string {
		if ($this->rootPath !== null) {
			return $this->rootPath;
		}

		$this->rootPath = $this->getAppdataPath() . '/collectives';
		return $this->rootPath;
	}

	public function getRootFolder(): Folder {
		if ($this->collectivesRootFolder !== null) {
			return $this->collectivesRootFolder;
		}

		$rootFolder = $this->rootFolder;
		$appdataPath = $this->getAppdataPath();
		$this->collectivesRootFolder = new LazyFolder($rootFolder, function () use ($rootFolder, $appdataPath) {
			/** @var Folder $appdata */
			$appdata = $rootFolder->get($appdataPath);
			try {
				return $appdata->get('/collectives');
			} catch (NotFoundException) {
				return $appdata->newFolder('collectives');
			}
		}, [
			'path' => '/' . $this->getRootPath(),
		]);

		return $this->collectivesRootFolder;
	}

	private function getCurrentUID(): ?string {
		try {
			// wopi requests are not logged in, instead we need to get the editor user from the access token
			if (strpos($this->request->getRawPathInfo(), 'apps/richdocuments/wopi') && class_exists(\OCA\Richdocuments\Db\WopiMapper::class)) {
				$wopiMapper = Server::get(\OCA\Richdocuments\Db\WopiMapper::class);
				$token = $this->request->getParam('access_token');
				if ($token) {
					return $wopiMapper->getPathForToken($token)->getEditorUid();
				}
			}
		} catch (Exception) {
		}

		return $this->userSession->getUser()?->getUID();
	}

	/**
	 * @throws InvalidPathException
	 * @throws NotFoundException
	 */
	public function getMount(int $id,
		string $mountPoint,
		int $permissions,
		?ICacheEntry $cacheEntry = null,
		?IStorageFactory $loader = null,
		?IUser $user = null): ?IMountPoint {
		if (!$cacheEntry) {
			try {
				$folder = $this->getOrCreateFolder($id);
			} catch (InvalidPathException|NotPermittedException) {
				return null;
			}
			$cacheEntry = $this->getRootFolder()->getStorage()->getCache()->get($folder->getId());
			if ($cacheEntry === false) {
				return null;
			}
		}

		$storage = new NoExcludePropagatorStorageWrapper(['storage' => $this->getRootFolder()->getStorage()]);

		$rootPath = $this->getJailPath($id);

		// apply acl before jail
		if ($user) {
			$inShare = !OC::$CLI && ($this->getCurrentUID() === null || $this->getCurrentUID() !== $user->getUID());
			$storage = new ACLStorageWrapper([
				'storage' => $storage,
				'permissions' => $permissions,
				'in_share' => $inShare
			]);
			$cacheEntry['permissions'] &= $permissions;
		}

		$baseStorage = new Jail([
			'storage' => $storage,
			'root' => $rootPath
		]);
		$collectiveStorage = new CollectiveStorage([
			'storage' => $baseStorage,
			'folder_id' => $id,
			'rootCacheEntry' => $cacheEntry,
			'mountOwner' => $user
		]);
		$maskedStorage = new PermissionsMask([
			'storage' => $collectiveStorage,
			'mask' => $permissions
		]);

		return new CollectiveMountPoint(
			$id,
			$this,
			$maskedStorage,
			$mountPoint,
			null,
			$loader
		);
	}

	private function getJailPath(int $folderId): string {
		return $this->getRootFolder()->getInternalPath() . '/' . $folderId;
	}

	/**
	 * @throws NotFoundException
	 */
	private function getRootFolderId(): int {
		if ($this->rootFolderId === null) {
			$qb = $this->connection->getQueryBuilder();

			$qb->select('f.fileid')
				->from('filecache', 'f')
				->where($qb->expr()->eq('storage', $qb->createNamedParameter($this->getRootFolderStorageId())))
				->andWhere($qb->expr()->eq('path_hash', $qb->createNamedParameter(md5($this->getRootPath()))));

			$this->rootFolderId = (int)$qb->executeQuery()->fetchColumn();
		}

		return $this->rootFolderId;
	}

	private function getRootFolderStorageId(): int {
		return $this->getRootFolder()->getStorage()->getCache()->getNumericStorageId();
	}

	/**
	 * @throws NotPermittedException
	 */
	private function getSkeletonFolder(Folder $folder): Folder {
		try {
			$skeletonFolder = $folder->get(self::SKELETON_DIR);
			if (!$skeletonFolder instanceof Folder) {
				throw new NotFoundException('Not a folder: ' . $skeletonFolder->getPath());
			}
		} catch (NotFoundException) {
			$skeletonFolder = $folder->newFolder(self::SKELETON_DIR);
		}

		return $skeletonFolder;
	}

	/**
	 * @throws NotFoundException
	 * @throws \OCP\DB\Exception
	 * @psalm-suppress MoreSpecificReturnType
	 * @return array<int, array{
	 *     folder_id: int,
	 *     fileid: int,
	 *     storage: int,
	 *     path: string,
	 *     name: string,
	 *     mimetype: string,
	 *     mimepart: string,
	 *     size: int|float,
	 *     mtime: int,
	 *     storage_mtime: int,
	 *     etag: string,
	 *     encrypted: bool,
	 *     parent: int,
	 *     permissions: int,
	 * }|null>
	 */
	public function getFolderFileCachePerCollectiveId(array $ids): array {
		if (!$ids) {
			return [];
		}
		$qb = $this->connection->getQueryBuilder();
		$qb->select(
			'co.id AS folder_id', 'fc.fileid', 'fc.storage', 'fc.path', 'fc.name AS name',
			'fc.mimetype', 'fc.mimepart', 'fc.size', 'fc.mtime', 'fc.storage_mtime', 'fc.etag', 'fc.encrypted', 'fc.parent', 'fc.permissions AS permissions')
			->from('collectives', 'co')
			->leftJoin('co', 'filecache', 'fc', $qb->expr()->eq('fc.name', $qb->expr()->castColumn('co.id', IQueryBuilder::PARAM_STR)))
			->where($qb->expr()->in('co.id', $qb->createNamedParameter($ids, IQueryBuilder::PARAM_INT_ARRAY)))
			->andWhere($qb->expr()->eq('fc.parent', $qb->createNamedParameter($this->getRootFolderId())))
			->andWhere($qb->expr()->eq('fc.storage', $qb->createNamedParameter($this->getRootFolderStorageId(), IQueryBuilder::PARAM_INT)));
		$rows = $qb->executeQuery()->fetchAll();
		$result = [];
		foreach ($rows as $row) {
			$result[$row['folder_id']] = $row;
		}
		/** @psalm-suppress LessSpecificReturnStatement */
		return $result;
	}

	/**
	 * Load all filecache entries (files and folders) of a collective folder in a single query.
	 *
	 * @return FileInfo[] Indexed by file id, with paths relative to the collective root folder
	 *
	 * @throws NotFoundException
	 * @throws \OCP\DB\Exception
	 */
	public function getFileCacheForCollective(int $collectiveId): array {
		$jailPath = $this->getJailPath($collectiveId);
		$storageId = $this->getRootFolderStorageId();

		$qb = $this->connection->getQueryBuilder();
		$qb->select('fileid', 'storage', 'path', 'parent', 'name', 'mimetype', 'mimepart',
			'size', 'mtime', 'storage_mtime', 'encrypted', 'etag', 'permissions')
			->from('filecache')
			->where($qb->expr()->eq('storage', $qb->createNamedParameter($storageId, IQueryBuilder::PARAM_INT)))
			// Trailing slash matters: it restricts to descendants of this collective and
			// avoids matching sibling collectives (e.g. `16` must not match `160`).
			->andWhere($qb->expr()->like('path', $qb->createNamedParameter($this->connection->escapeLikeParameter($jailPath . '/') . '%')));

		$prefixLength = strlen($jailPath . '/');
		$result = [];
		$cursor = $qb->executeQuery();
		while ($row = $cursor->fetch()) {
			$relativePath = substr($row['path'], $prefixLength);
			$result[(int)$row['fileid']] = new FileInfo(
				fileId: (int)$row['fileid'],
				storage: (int)$row['storage'],
				path: $relativePath,
				parent: (int)$row['parent'],
				name: (string)$row['name'],
				mimetype: (int)$row['mimetype'],
				mimepart: (int)$row['mimepart'],
				size: (int)$row['size'],
				mtime: (int)$row['mtime'],
				storageMtime: (int)$row['storage_mtime'],
				encrypted: (int)$row['encrypted'],
				etag: (string)$row['etag'],
				permissions: (int)$row['permissions'],
			);
		}
		$cursor->closeCursor();

		return $result;
	}

	/**
	 * @throws InvalidPathException
	 * @throws NotFoundException
	 */
	public function getFolder(int $id): Folder {
		$folder = $this->getRootFolder()->get((string)$id);
		if (!$folder instanceof Folder) {
			throw new InvalidPathException('Not a folder: ' . $folder->getPath());
		}
		return $folder;
	}

	/**
	 * @throws InvalidPathException
	 * @throws NotPermittedException
	 */
	public function getOrCreateFolder(int $id): Folder {
		try {
			$folder = $this->getFolder($id);
		} catch (NotFoundException) {
			/** @var Folder $folder */
			$folder = $this->getSkeletonFolder($this->getRootFolder())
				->copy($this->getRootFolder()->getPath() . '/' . $id);
		}

		return $folder;
	}

	/**
	 * @throws InvalidPathException
	 * @throws NotPermittedException
	 */
	public function initializeFolder(int $id, string $lang, string $name): Folder {
		$folder = $this->getOrCreateFolder($id);

		$landingPageFileName = self::LANDING_PAGE_TITLE . self::SUFFIX;
		if (!$folder->nodeExists($landingPageFileName)) {
			$content = $this->getLandingPageContent($name, $lang);
			$folder->newFile($landingPageFileName, $content);
		}

		return $folder;
	}

	private function getLandingPageContent(string $name, string $lang): string {
		$l10n = $this->l10nFactory->get('collectives', $lang);
		return '# ' . $l10n->t('Welcome %s', $name) . "\n\n"
			. $l10n->t('Add pages with the ➕ in the page list! You can drag them to change the order. Dragging them into the editor will create a 🔗 link.') . "\n\n"
			. $l10n->t('Press `✏️ Edit` to change this text and make yourself at home! Multiple people can edit together. Find out more in the [documentation](https://docs.nextcloud.com/server/latest/user_manual/en/collectives/index.html) or ask [the community](https://help.nextcloud.com/tag/collectives-app).');
	}
}