Implement skeleton folder support (#69)

When creating a new collective, copy over the skeleton folder instead of creating an empty folder.
nextcloud · Aug 22, 2020 · 21bd107 · 21bd107
1 parent fb8fbdc
commit 21bd107
Show file tree

Hide file tree

Showing 9 changed files with 184 additions and 130 deletions.
diff --git a/README.md b/README.md
@@ -11,6 +11,21 @@ organize together. Come and gather in collectives to build shared knowledge.
 * **Well-known [Markdown](https://en.wikipedia.org/wiki/Markdown) syntax**
   for page formatting
 
+## Usage
+
+### Custom skeletons for new collectives
+
+It's possible to customize the skeletons for new collectives by putting files
+in the app skeleton directory at `data/app_<INSTANCE_ID>/collectives/skeleton`.
+New collectives get the contents of this skeleton directory copied over.
+
+`README.md` is the landing page that is opened automatically when entering a
+collective.
+
+If the skeleton directory doesn't contain a `README.md`, the default landing
+page from `collectives/skeleton/README.md` will be copied into the collectives
+directory instead.
+
 ## Dependencies
 
 For installation (see below), the following tools need to be available:

diff --git a/lib/AppInfo/Application.php b/lib/AppInfo/Application.php
@@ -5,15 +5,14 @@
 namespace OCA\Collectives\AppInfo;
 
 use Closure;
-use OCA\Collectives\Mount\CollectiveRootPathHelper;
+use OCA\Collectives\Mount\CollectiveFolderManager;
 use OCA\Collectives\Mount\MountProvider;
 use OCA\Collectives\Service\CollectiveHelper;
 use OCP\AppFramework\App;
 use OCP\AppFramework\Bootstrap\IBootContext;
 use OCP\AppFramework\Bootstrap\IBootstrap;
 use OCP\AppFramework\Bootstrap\IRegistrationContext;
 use OCP\Files\Config\IMountProviderCollection;
-use OCP\Files\IRootFolder;
 use OCP\IUserSession;
 use Psr\Container\ContainerInterface;
 
@@ -31,8 +30,7 @@ public function register(IRegistrationContext $context): void {
 		$context->registerService(MountProvider::class, function (ContainerInterface $c) {
 			return new MountProvider(
 				$c->get(CollectiveHelper::class),
-				$c->get(CollectiveRootPathHelper::class),
-				$c->get(IRootFolder::class),
+				$c->get(CollectiveFolderManager::class),
 				$c->get(IUserSession::class)
 			);
 		});

diff --git a/lib/Mount/CollectiveFolderManager.php b/lib/Mount/CollectiveFolderManager.php
@@ -0,0 +1,101 @@
+<?php
+
+namespace OCA\Collectives\Mount;
+
+use OC\Files\Node\LazyFolder;
+use OC\SystemConfig;
+use OCP\Files\Folder;
+use OCP\Files\IRootFolder;
+use OCP\Files\NotFoundException;
+use OCP\Files\NotPermittedException;
+
+class CollectiveFolderManager {
+	public const SKELETON_DIR = 'skeleton';
+	public const LANDING_PAGE = 'README.md';
+
+	/** @var SystemConfig */
+	private $systemConfig;
+
+	/** @var IRootFolder */
+	private $rootFolder;
+
+	/**
+	 * MountProvider constructor.
+	 *
+	 * @param SystemConfig $systemConfig
+	 * @param IRootFolder              $rootFolder
+	 */
+	public function __construct(
+		IRootFolder $rootFolder,
+		SystemConfig $systemConfig) {
+		$this->systemConfig = $systemConfig;
+		$this->rootFolder = $rootFolder;
+	}
+
+	public function getRootPath(): string {
+		$instanceId = $this->systemConfig->getValue('instanceid', null);
+		if (null === $instanceId) {
+			throw new \RuntimeException('no instance id!');
+		}
+
+		return 'appdata_' . $instanceId . '/collectives';
+	}
+
+	/**
+	 * @return Folder
+	 */
+	public function getRootFolder(): Folder {
+		$rootFolder = $this->rootFolder;
+		return (new LazyFolder(function () use ($rootFolder) {
+			try {
+				return $rootFolder->get($this->getRootPath());
+			} catch (NotFoundException $e) {
+				return $rootFolder->newFolder($this->getRootPath());
+			}
+		}));
+	}
+
+	/**
+	 * @param Folder $folder
+	 *
+	 * @return Folder
+	 * @throws NotPermittedException
+	 */
+	public 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 $e) {
+			$skeletonFolder = $folder->newFolder(self::SKELETON_DIR);
+		}
+
+		return $skeletonFolder;
+	}
+
+	/**
+	 * @param int  $id
+	 * @param bool $create
+	 *
+	 * @return Folder|null
+	 * @throws NotPermittedException
+	 */
+	public function getFolder(int $id, bool $create = true): ?Folder {
+		try {
+			$folder = $this->getRootFolder()->get((string)$id);
+			if (!$folder instanceof Folder) {
+				return null;
+			}
+		} catch (NotFoundException $e) {
+			if (!$create) {
+				return null;
+			}
+
+			$folder = $this->getSkeletonFolder($this->getRootFolder())
+				->copy($this->getRootFolder()->getPath() . '/' . (string)$id);
+		}
+
+		return $folder;
+	}
+}
diff --git a/lib/Mount/CollectiveMountPoint.php b/lib/Mount/CollectiveMountPoint.php
@@ -9,33 +9,33 @@ class CollectiveMountPoint extends MountPoint {
 	/** @var int */
 	private $folderId;
 
-	/** @var CollectiveRootPathHelper */
-	private $collectiveRootPathHelper;
+	/** @var CollectiveFolderManager */
+	private $collectiveFolderManager;
 
 	/**
 	 * CollectiveMountPoint constructor.
 	 *
-	 * @param int|null                 $folderId
-	 * @param CollectiveRootPathHelper $collectiveRootPathHelper
-	 * @param CollectiveStorage        $storage
-	 * @param string                   $mountPoint
-	 * @param array|null               $arguments
-	 * @param IStorageFactory|null     $loader
-	 * @param array|null               $mountOptions
-	 * @param int|null                 $mountId
+	 * @param int|null                $folderId
+	 * @param CollectiveFolderManager $collectiveFolderManager
+	 * @param CollectiveStorage       $storage
+	 * @param string                  $mountPoint
+	 * @param array|null              $arguments
+	 * @param IStorageFactory|null    $loader
+	 * @param array|null              $mountOptions
+	 * @param int|null                $mountId
 	 *
 	 * @throws \Exception
 	 */
 	public function __construct(?int $folderId,
-								CollectiveRootPathHelper $collectiveRootPathHelper,
+								CollectiveFolderManager $collectiveFolderManager,
 								CollectiveStorage $storage,
 								string $mountPoint,
 								array $arguments = null,
 								IStorageFactory $loader = null,
 								array $mountOptions = null,
 								int $mountId = null) {
 		$this->folderId = $folderId;
-		$this->collectiveRootPathHelper = $collectiveRootPathHelper;
+		$this->collectiveFolderManager = $collectiveFolderManager;
 		parent::__construct($storage, $mountPoint, $arguments, $loader, $mountOptions, $mountId);
 	}
 
@@ -77,6 +77,6 @@ public function getFolderId(): int {
 	 * @return string
 	 */
 	public function getSourcePath(): string {
-		return '/' . $this->collectiveRootPathHelper->get() . '/' . $this->getFolderId();
+		return '/' . $this->collectiveFolderManager->getRootFolder()->getPath() . '/' . $this->getFolderId();
 	}
 }
diff --git a/lib/Mount/CollectiveRootPathHelper.php b/lib/Mount/CollectiveRootPathHelper.php
diff --git a/lib/Mount/MountProvider.php b/lib/Mount/MountProvider.php
@@ -2,12 +2,9 @@
 
 namespace OCA\Collectives\Mount;
 
-use OC\Files\Node\LazyFolder;
 use OC\Files\Storage\Wrapper\Jail;
 use OCA\Collectives\Service\CollectiveHelper;
 use OCP\Files\Config\IMountProvider;
-use OCP\Files\Folder;
-use OCP\Files\IRootFolder;
 use OCP\Files\Mount\IMountPoint;
 use OCP\Files\NotFoundException;
 use OCP\Files\NotPermittedException;
@@ -16,16 +13,11 @@
 use OCP\IUserSession;
 
 class MountProvider implements IMountProvider {
-	private const LANDING_PAGE = 'README.md';
-
 	/** @var CollectiveHelper */
 	private $collectiveHelper;
 
-	/** @var CollectiveRootPathHelper */
-	private $collectiveRootPathHelper;
-
-	/** @var IRootFolder */
-	private $rootFolder;
+	/** @var CollectiveFolderManager */
+	private $collectiveFolderManager;
 
 	/** @var IUserSession */
 	private $userSession;
@@ -34,18 +26,15 @@ class MountProvider implements IMountProvider {
 	 * MountProvider constructor.
 	 *
 	 * @param CollectiveHelper   $collectiveHelper
-	 * @param CollectiveRootPathHelper $collectiveRootPathHelper
-	 * @param IRootFolder              $rootFolder
+	 * @param CollectiveFolderManager $collectiveFolderManager
 	 * @param IUserSession             $userSession
 	 */
 	public function __construct(
 		CollectiveHelper $collectiveHelper,
-		CollectiveRootPathHelper $collectiveRootPathHelper,
-		IRootFolder $rootFolder,
+		CollectiveFolderManager $collectiveFolderManager,
 		IUserSession $userSession) {
 		$this->collectiveHelper = $collectiveHelper;
-		$this->collectiveRootPathHelper = $collectiveRootPathHelper;
-		$this->rootFolder = $rootFolder;
+		$this->collectiveFolderManager = $collectiveFolderManager;
 		$this->userSession = $userSession;
 	}
 
@@ -81,14 +70,6 @@ public function getMountsForUser(IUser $user, IStorageFactory $loader) {
 		}, $folders);
 	}
 
-	/**
-	 * @return string|null
-	 */
-	private function getCurrentUID(): ?string {
-		$user = $this->userSession->getUser();
-		return $user ? $user->getUID() : null;
-	}
-
 	/**
 	 * @param int                  $id
 	 * @param string               $mountPoint
@@ -107,10 +88,10 @@ public function getMount(int $id,
 							 IUser $user = null): IMountPoint {
 		if (!$cacheEntry) {
 			// trigger folder creation
-			$this->getFolder($id);
+			$this->collectiveFolderManager->getFolder($id);
 		}
 
-		$storage = $this->getCollectivesRootFolder()->getStorage();
+		$storage = $this->collectiveFolderManager->getRootFolder()->getStorage();
 
 		$rootPath = $this->getJailPath($id);
 
@@ -128,7 +109,7 @@ public function getMount(int $id,
 
 		return new CollectiveMountPoint(
 			$id,
-			$this->collectiveRootPathHelper,
+			$this->collectiveFolderManager,
 			$collectiveStorage,
 			$mountPoint,
 			null,
@@ -142,47 +123,6 @@ public function getMount(int $id,
 	 * @return string
 	 */
 	public function getJailPath(int $folderId): string {
-		return $this->getCollectivesRootFolder()->getInternalPath() . '/' . $folderId;
-	}
-
-	/**
-	 * @return Folder
-	 */
-	private function getCollectivesRootFolder(): Folder {
-		$rootFolder = $this->rootFolder;
-		return (new LazyFolder(function () use ($rootFolder) {
-			try {
-				return $rootFolder->get($this->collectiveRootPathHelper->get());
-			} catch (NotFoundException $e) {
-				return $rootFolder->newFolder($this->collectiveRootPathHelper->get());
-			}
-		}));
-	}
-
-	/**
-	 * @param int  $id
-	 * @param bool $create
-	 *
-	 * @return Folder|null
-	 * @throws NotPermittedException
-	 */
-	public function getFolder(int $id, bool $create = true): ?Folder {
-		try {
-			$folder = $this->getCollectivesRootFolder()->get((string)$id);
-			if (!$folder instanceof Folder) {
-				return null;
-			}
-		} catch (NotFoundException $e) {
-			if ($create) {
-				$folder = $this->getCollectivesRootFolder()->newFolder((string)$id);
-			}
-			return null;
-		}
-
-		if ($create && !$folder->nodeExists(self::LANDING_PAGE)) {
-			$folder->newFile(self::LANDING_PAGE);
-		}
-
-		return $folder;
+		return $this->collectiveFolderManager->getRootFolder()->getInternalPath() . '/' . $folderId;
 	}
 }