PicoService::__construct() - Code Metrics - Inspection of "Pico CMS for Nextcloud v1.1 (WIP)" - nextcloud/cms_pico - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#99)

by Daniel

created 2020-04-13 10:20 UTC

PicoService::__construct() A

↳ Parent: PicoService

Complexity

Conditions	1
Paths	1

Size

Total Lines	14
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	7
CRAP Score	1

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
eloc	6
c	2
b	0
f	0
dl	0
loc	14
ccs	7
cts	7
cp	1
rs	10
cc	1
nc	1
nop	6
crap	1

<?php
/**
 * CMS Pico - Create websites using Pico CMS for Nextcloud.
 *
 * @copyright Copyright (c) 2017, Maxence Lange (<[email protected]>)
 * @copyright Copyright (c) 2019, Daniel Rudolf (<[email protected]>)
 *
 * @license GNU AGPL version 3 or any later version
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

declare(strict_types=1);

namespace OCA\CMSPico\Service;

use OCA\CMSPico\AppInfo\Application;
use OCA\CMSPico\Exceptions\PageInvalidPathException;
use OCA\CMSPico\Exceptions\PageNotFoundException;
use OCA\CMSPico\Exceptions\PageNotPermittedException;
use OCA\CMSPico\Exceptions\PicoRuntimeException;
use OCA\CMSPico\Exceptions\ThemeNotCompatibleException;
use OCA\CMSPico\Exceptions\ThemeNotFoundException;
use OCA\CMSPico\Exceptions\WebsiteInvalidFilesystemException;
use OCA\CMSPico\Exceptions\WebsiteNotPermittedException;
use OCA\CMSPico\Files\StorageFolder;
use OCA\CMSPico\Model\PicoPage;
use OCA\CMSPico\Model\Website;
use OCA\CMSPico\Pico;
use OCP\Files\InvalidPathException;
use OCP\Files\NotFoundException;
use OCP\Files\NotPermittedException;
use OCP\ILogger;

class PicoService
{
	/** @var string */
	public const DIR_TEMPLATES = 'templates';

	/** @var string */
	public const DIR_CONFIG = 'config';

	/** @var string */
	public const DIR_PLUGINS = 'plugins';

	/** @var string */
	public const DIR_THEMES = 'themes';

	/** @var string */
	public const DIR_CONTENT = 'content';

	/** @var string */
	public const DIR_ASSETS = 'assets';

	/** @var string */
	public const CONTENT_EXT = '.md';

	/** @var ILogger */
	private $logger;

	/** @var AssetsService */
	private $assetsService;

	/** @var ThemesService */
	private $themesService;

	/** @var PluginsService */
	private $pluginsService;

	/** @var FileService */
	private $fileService;

	/** @var MiscService */
	private $miscService;

	/**
	 * PicoService constructor.
	 *
	 * @param ILogger        $logger
	 * @param AssetsService  $assetsService
	 * @param ThemesService  $themesService
	 * @param PluginsService $pluginsService
	 * @param FileService    $fileService
	 * @param MiscService    $miscService
	 */
	public function __construct(
		ILogger $logger,
		AssetsService $assetsService,
		ThemesService $themesService,
		PluginsService $pluginsService,
		FileService $fileService,
		MiscService $miscService
	) {
		$this->logger = $logger;
		$this->assetsService = $assetsService;
		$this->themesService = $themesService;
		$this->pluginsService = $pluginsService;
		$this->fileService = $fileService;
		$this->miscService = $miscService;
	}

	/**
	 * @param Website $website
	 *
	 * @return PicoPage
	 * @throws WebsiteInvalidFilesystemException
	 * @throws WebsiteNotPermittedException
	 * @throws ThemeNotFoundException
	 * @throws ThemeNotCompatibleException
	 * @throws PageInvalidPathException
	 * @throws PageNotFoundException
	 * @throws PageNotPermittedException
	 * @throws PicoRuntimeException
	 */
	public function getPage(Website $website): PicoPage
	{
		try {
			$page = $website->getPage();

			$website->assertViewerAccess(self::DIR_CONTENT . '/' . ($page ?: 'index') . self::CONTENT_EXT);

			$this->themesService->assertValidTheme($website->getTheme());

			$pico = new Pico(
				$website->getWebsitePath(),
				$this->getConfigPath(),
				$this->pluginsService->getPluginsPath(),
				$this->themesService->getThemesPath(),
				false
			);

			try {
				$this->setupPico($website, $pico, $page);
				$this->loadPicoPlugins($pico);

				$output = $pico->run();
			} catch (WebsiteInvalidFilesystemException $e) {
				throw $e;
			} catch (InvalidPathException | NotFoundException | NotPermittedException $e) {
				throw $e;
			} catch (\Exception $e) {
				$exception = new PicoRuntimeException($e);
				$this->logger->logException($exception, [ 'app' => Application::APP_NAME ]);
				throw $exception;
			}

			$picoPage = new PicoPage($website, $pico, $output);

			$picoPagePath = self::DIR_CONTENT . '/' . $picoPage->getRelativePath() . self::CONTENT_EXT;
			$website->assertViewerAccess($picoPagePath, $picoPage->getMeta());
		} catch (InvalidPathException $e) {
			throw new PageInvalidPathException($e);
		} catch (NotFoundException $e) {
			throw new PageNotFoundException($e);
		} catch (NotPermittedException $e) {
			throw new PageNotPermittedException($e);
		}

		return $picoPage;
	}

	/**
	 * @param Website $website
	 * @param Pico    $pico
	 * @param string  $page
	 *
	 * @throws WebsiteInvalidFilesystemException
	 */
	private function setupPico(Website $website, Pico $pico, string $page): void
	{
		$pico->setRequestUrl($page);
		$pico->setNextcloudWebsite($website);

		$pico->setConfig(
			[
				'site_title'     => $website->getName(),
				'base_url'       => $website->getWebsiteUrl(),
				'rewrite_url'    => true,
				'debug'          => \OC::$server->getConfig()->getSystemValue('debug', false),
				'timezone'       => $website->getTimeZone(),
				'theme'          => $website->getTheme(),
				'themes_url'     => $this->themesService->getThemesUrl(),
				'content_dir'    => $this->getContentPath($website),
				'content_ext'    => self::CONTENT_EXT,
				'assets_dir'     => $this->assetsService->getAssetsPath($website),
				'assets_url'     => $this->assetsService->getAssetsUrl($website),
				'plugins_url'    => $this->pluginsService->getPluginsUrl(),
				'nextcloud_site' => $website->getSite(),
			]
		);
	}

	/**
	 * @param Pico $pico
	 */
	private function loadPicoPlugins(Pico $pico): void
	{
		$includeClosure = static function (string $pluginFile) {
			/** @noinspection PhpIncludeInspection */
			require_once($pluginFile);
		};

		foreach ($this->pluginsService->getPlugins() as $pluginData) {
			if ($pluginData['compat']) {
				$pluginFile = $pluginData['name'] . '/' . $pluginData['name'] . '.php';
				$includeClosure($this->pluginsService->getPluginsPath() . '/' . $pluginFile);

				$pico->loadPlugin($pluginData['name']);
			}
		}
	}

	/**
	 * @param Website $website
	 * @param string  $absolutePath
	 *
	 * @return array
	 * @throws WebsiteInvalidFilesystemException
	 * @throws InvalidPathException
	 */
	public function getRelativePath(Website $website, string $absolutePath): array
	{
		$folder = $website->getWebsiteFolder();
		$basePath = $website->getWebsitePath();

		try {
			$relativePath = $this->miscService->getRelativePath($absolutePath, $basePath);
		} catch (InvalidPathException $e) {
			$folder = $this->pluginsService->getPluginsFolder();
			$basePath = $this->pluginsService->getPluginsPath();

			try {
				$relativePath = $this->miscService->getRelativePath($absolutePath, $basePath);
			} catch (InvalidPathException $e) {
				$folder = $this->themesService->getThemesFolder();
				$basePath = $this->themesService->getThemesPath();

				try {
					$relativePath = $this->miscService->getRelativePath($absolutePath, $basePath);
				} catch (InvalidPathException $e) {
					$folder = $this->getConfigFolder();
					$basePath = $this->getConfigPath();

					try {
						$relativePath = $this->miscService->getRelativePath($absolutePath, $basePath);
					} catch (InvalidPathException $e) {
						// the file is neither in the content nor assets, plugins, themes or config folder
						// Pico mustn't have access to any other directory
						throw new InvalidPathException();
					}
				}
			}
		}

		return [ $folder, rtrim($basePath, '/'), $relativePath ];
	}

	/**
	 * @param Website $website
	 *
	 * @return StorageFolder
	 * @throws WebsiteInvalidFilesystemException
	 */
	public function getContentFolder(Website $website): StorageFolder
	{
		try {
			/** @var StorageFolder $websiteFolder */
			$websiteFolder = $website->getWebsiteFolder()->getFolder(PicoService::DIR_CONTENT)->fakeRoot();
			return $websiteFolder;
		} catch (InvalidPathException | NotFoundException $e) {
			throw new WebsiteInvalidFilesystemException($e);
		}
	}

	/**
	 * @param Website $website
	 *
	 * @return string
	 * @throws WebsiteInvalidFilesystemException
	 */
	public function getContentPath(Website $website): string
	{
		try {
			return $this->getContentFolder($website)->getLocalPath() . '/';
		} catch (InvalidPathException | NotFoundException $e) {
			throw new WebsiteInvalidFilesystemException($e);
		}
	}

	/**
	 * @return StorageFolder
	 */
	public function getConfigFolder(): StorageFolder
	{
		/** @var StorageFolder $configFolder */
		$configFolder = $this->fileService->getAppDataFolder(self::DIR_CONFIG)->fakeRoot();
		return $configFolder;
	}

	/**
	 * @return string
	 */
	public function getConfigPath(): string
	{
		return $this->fileService->getAppDataFolderPath(self::DIR_CONFIG);
	}
}


1		<?php
2		/**
3		* CMS Pico - Create websites using Pico CMS for Nextcloud.
4		*
5		* @copyright Copyright (c) 2017, Maxence Lange (<[email protected]>)
6		* @copyright Copyright (c) 2019, Daniel Rudolf (<[email protected]>)
7		*
8		* @license GNU AGPL version 3 or any later version
9		*
10		* This program is free software: you can redistribute it and/or modify
11		* it under the terms of the GNU Affero General Public License as
12		* published by the Free Software Foundation, either version 3 of the
13		* License, or (at your option) any later version.
14		*
15		* This program is distributed in the hope that it will be useful,
16		* but WITHOUT ANY WARRANTY; without even the implied warranty of
17		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18		* GNU Affero General Public License for more details.
19		*
20		* You should have received a copy of the GNU Affero General Public License
21		* along with this program. If not, see <http://www.gnu.org/licenses/>.
22		*/
23
24		declare(strict_types=1);
25
26		namespace OCA\CMSPico\Service;
27
28		use OCA\CMSPico\AppInfo\Application;
29		use OCA\CMSPico\Exceptions\PageInvalidPathException;
30		use OCA\CMSPico\Exceptions\PageNotFoundException;
31		use OCA\CMSPico\Exceptions\PageNotPermittedException;
32		use OCA\CMSPico\Exceptions\PicoRuntimeException;
33		use OCA\CMSPico\Exceptions\ThemeNotCompatibleException;
34		use OCA\CMSPico\Exceptions\ThemeNotFoundException;
35		use OCA\CMSPico\Exceptions\WebsiteInvalidFilesystemException;
36		use OCA\CMSPico\Exceptions\WebsiteNotPermittedException;
37		use OCA\CMSPico\Files\StorageFolder;
38		use OCA\CMSPico\Model\PicoPage;
39		use OCA\CMSPico\Model\Website;
40		use OCA\CMSPico\Pico;
41		use OCP\Files\InvalidPathException;
42		use OCP\Files\NotFoundException;
43		use OCP\Files\NotPermittedException;
44		use OCP\ILogger;
45
46		class PicoService
47		{
48		/** @var string */
49		public const DIR_TEMPLATES = 'templates';
50
51		/** @var string */
52		public const DIR_CONFIG = 'config';
53
54		/** @var string */
55		public const DIR_PLUGINS = 'plugins';
56
57		/** @var string */
58		public const DIR_THEMES = 'themes';
59
60		/** @var string */
61		public const DIR_CONTENT = 'content';
62
63		/** @var string */
64		public const DIR_ASSETS = 'assets';
65
66		/** @var string */
67		public const CONTENT_EXT = '.md';
68
69		/** @var ILogger */
70		private $logger;
71
72		/** @var AssetsService */
73		private $assetsService;
74
75		/** @var ThemesService */
76		private $themesService;
77
78		/** @var PluginsService */
79		private $pluginsService;
80
81		/** @var FileService */
82		private $fileService;
83
84		/** @var MiscService */
85		private $miscService;
86
87		/**
88		* PicoService constructor.
89		*
90		* @param ILogger $logger
91		* @param AssetsService $assetsService
92		* @param ThemesService $themesService
93		* @param PluginsService $pluginsService
94		* @param FileService $fileService
95		* @param MiscService $miscService
96		*/
97	1	public function __construct(
98		ILogger $logger,
99		AssetsService $assetsService,
100		ThemesService $themesService,
101		PluginsService $pluginsService,
102		FileService $fileService,
103		MiscService $miscService
104		) {
105	1	$this->logger = $logger;
106	1	$this->assetsService = $assetsService;
107	1	$this->themesService = $themesService;
108	1	$this->pluginsService = $pluginsService;
109	1	$this->fileService = $fileService;
110	1	$this->miscService = $miscService;
111	1	}
112
113		/**
114		* @param Website $website
115		*
116		* @return PicoPage
117		* @throws WebsiteInvalidFilesystemException
118		* @throws WebsiteNotPermittedException
119		* @throws ThemeNotFoundException
120		* @throws ThemeNotCompatibleException
121		* @throws PageInvalidPathException
122		* @throws PageNotFoundException
123		* @throws PageNotPermittedException
124		* @throws PicoRuntimeException
125		*/
126	2	public function getPage(Website $website): PicoPage
127		{
128		try {
129	2	$page = $website->getPage();
130
131	2	$website->assertViewerAccess(self::DIR_CONTENT . '/' . ($page ?: 'index') . self::CONTENT_EXT);
132
133	2	$this->themesService->assertValidTheme($website->getTheme());
134
135	2	$pico = new Pico(
136	2	$website->getWebsitePath(),
137	2	$this->getConfigPath(),
138	2	$this->pluginsService->getPluginsPath(),
139	2	$this->themesService->getThemesPath(),
140	2	false
141		);
142
143		try {
144	2	$this->setupPico($website, $pico, $page);
145	2	$this->loadPicoPlugins($pico);
146
147	2	$output = $pico->run();
148		} catch (WebsiteInvalidFilesystemException $e) {
149		throw $e;
150		} catch (InvalidPathException \| NotFoundException \| NotPermittedException $e) {
151		throw $e;
152		} catch (\Exception $e) {
153		$exception = new PicoRuntimeException($e);
154		$this->logger->logException($exception, [ 'app' => Application::APP_NAME ]);
155		throw $exception;
156		}
157
158	2	$picoPage = new PicoPage($website, $pico, $output);
159
160	2	$picoPagePath = self::DIR_CONTENT . '/' . $picoPage->getRelativePath() . self::CONTENT_EXT;
161	2	$website->assertViewerAccess($picoPagePath, $picoPage->getMeta());
162		} catch (InvalidPathException $e) {
163		throw new PageInvalidPathException($e);
164		} catch (NotFoundException $e) {
165		throw new PageNotFoundException($e);
166		} catch (NotPermittedException $e) {
167		throw new PageNotPermittedException($e);
168		}
169
170	2	return $picoPage;
171		}
172
173		/**
174		* @param Website $website
175		* @param Pico $pico
176		* @param string $page
177		*
178		* @throws WebsiteInvalidFilesystemException
179		*/
180	2	private function setupPico(Website $website, Pico $pico, string $page): void
181		{
182	2	$pico->setRequestUrl($page);
183	2	$pico->setNextcloudWebsite($website);
184
185	2	$pico->setConfig(
186		[
187	2	'site_title' => $website->getName(),
188	2	'base_url' => $website->getWebsiteUrl(),
189		'rewrite_url' => true,
190	2	'debug' => \OC::$server->getConfig()->getSystemValue('debug', false),
191	2	'timezone' => $website->getTimeZone(),
192	2	'theme' => $website->getTheme(),
193	2	'themes_url' => $this->themesService->getThemesUrl(),
194	2	'content_dir' => $this->getContentPath($website),
195	2	'content_ext' => self::CONTENT_EXT,
196	2	'assets_dir' => $this->assetsService->getAssetsPath($website),
197	2	'assets_url' => $this->assetsService->getAssetsUrl($website),
198	2	'plugins_url' => $this->pluginsService->getPluginsUrl(),
199	2	'nextcloud_site' => $website->getSite(),
200		]
201		);
202	2	}
203
204		/**
205		* @param Pico $pico
206		*/
207		private function loadPicoPlugins(Pico $pico): void
208		{
209	2	$includeClosure = static function (string $pluginFile) {
210		/** @noinspection PhpIncludeInspection */
211	2	require_once($pluginFile);
212	2	};
213
214	2	foreach ($this->pluginsService->getPlugins() as $pluginData) {
215	2	if ($pluginData['compat']) {
216	2	$pluginFile = $pluginData['name'] . '/' . $pluginData['name'] . '.php';
217	2	$includeClosure($this->pluginsService->getPluginsPath() . '/' . $pluginFile);
218
219	2	$pico->loadPlugin($pluginData['name']);
220		}
221		}
222	2	}
223
224		/**
225		* @param Website $website
226		* @param string $absolutePath
227		*
228		* @return array
229		* @throws WebsiteInvalidFilesystemException
230		* @throws InvalidPathException
231		*/
232	2	public function getRelativePath(Website $website, string $absolutePath): array
233		{
234	2	$folder = $website->getWebsiteFolder();
235	2	$basePath = $website->getWebsitePath();
236
237		try {
238	2	$relativePath = $this->miscService->getRelativePath($absolutePath, $basePath);
239	2	} catch (InvalidPathException $e) {
240	2	$folder = $this->pluginsService->getPluginsFolder();
241	2	$basePath = $this->pluginsService->getPluginsPath();
242
243		try {
244	2	$relativePath = $this->miscService->getRelativePath($absolutePath, $basePath);
245	2	} catch (InvalidPathException $e) {
246	2	$folder = $this->themesService->getThemesFolder();
247	2	$basePath = $this->themesService->getThemesPath();
248
249		try {
250	2	$relativePath = $this->miscService->getRelativePath($absolutePath, $basePath);
251	2	} catch (InvalidPathException $e) {
252	2	$folder = $this->getConfigFolder();
253	2	$basePath = $this->getConfigPath();
254
255		try {
256	2	$relativePath = $this->miscService->getRelativePath($absolutePath, $basePath);
257		} catch (InvalidPathException $e) {
258		// the file is neither in the content nor assets, plugins, themes or config folder
259		// Pico mustn't have access to any other directory
260		throw new InvalidPathException();
261		}
262		}
263		}
264		}
265
266	2	return [ $folder, rtrim($basePath, '/'), $relativePath ];
267		}
268
269		/**
270		* @param Website $website
271		*
272		* @return StorageFolder
273		* @throws WebsiteInvalidFilesystemException
274		*/
275	2	public function getContentFolder(Website $website): StorageFolder
276		{
277		try {
278		/** @var StorageFolder $websiteFolder */
279	2	$websiteFolder = $website->getWebsiteFolder()->getFolder(PicoService::DIR_CONTENT)->fakeRoot();
280	2	return $websiteFolder;
281		} catch (InvalidPathException \| NotFoundException $e) {
282		throw new WebsiteInvalidFilesystemException($e);
283		}
284		}
285
286		/**
287		* @param Website $website
288		*
289		* @return string
290		* @throws WebsiteInvalidFilesystemException
291		*/
292	2	public function getContentPath(Website $website): string
293		{
294		try {
295	2	return $this->getContentFolder($website)->getLocalPath() . '/';
296		} catch (InvalidPathException \| NotFoundException $e) {
297		throw new WebsiteInvalidFilesystemException($e);
298		}
299		}
300
301		/**
302		* @return StorageFolder
303		*/
304	2	public function getConfigFolder(): StorageFolder
305		{
306		/** @var StorageFolder $configFolder */
307	2	$configFolder = $this->fileService->getAppDataFolder(self::DIR_CONFIG)->fakeRoot();
308	2	return $configFolder;
309		}
310
311		/**
312		* @return string
313		*/
314	2	public function getConfigPath(): string
315		{
316	2	return $this->fileService->getAppDataFolderPath(self::DIR_CONFIG);
317		}
318		}
319

nextcloud / cms_pico

Pull Request — master (#99)

PicoService::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like