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

Passed

Pull Request — master (#77)

by Daniel

created 2019-11-18 10:36 UTC

Website::assertViewerAccess() D

↳ Parent: Website

Complexity

Conditions	20
Paths	29

Size

Total Lines	78
Code Lines	42

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	296.0416

Importance

Changes	3
Bugs	0	Features	0

Metric	Value
eloc	42
c	3
b	0
f	0
dl	0
loc	78
ccs	5
cts	43
cp	0.1163
rs	4.1666
cc	20
nc	29
nop	2
crap	296.0416

How to fix Long Method Complexity

<?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\Model;

use OCA\CMSPico\AppInfo\Application;
use OCA\CMSPico\Exceptions\TemplateNotCompatibleException;
use OCA\CMSPico\Exceptions\TemplateNotFoundException;
use OCA\CMSPico\Exceptions\ThemeNotCompatibleException;
use OCA\CMSPico\Exceptions\ThemeNotFoundException;
use OCA\CMSPico\Exceptions\WebsiteForeignOwnerException;
use OCA\CMSPico\Exceptions\WebsiteInvalidDataException;
use OCA\CMSPico\Exceptions\WebsiteInvalidFilesystemException;
use OCA\CMSPico\Exceptions\WebsiteInvalidOwnerException;
use OCA\CMSPico\Exceptions\WebsiteNotPermittedException;
use OCA\CMSPico\Files\StorageFile;
use OCA\CMSPico\Files\StorageFolder;
use OCA\CMSPico\Service\MiscService;
use OCA\CMSPico\Service\TemplatesService;
use OCA\CMSPico\Service\ThemesService;
use OCA\CMSPico\Service\WebsitesService;
use OCP\Files\Folder as OCFolder;
use OCP\Files\InvalidPathException;
use OCP\Files\Node as OCNode;
use OCP\Files\NotFoundException;
use OCP\Files\NotPermittedException;
use OCP\IConfig;
use OCP\IGroupManager;
use OCP\IL10N;
use OCP\IURLGenerator;
use OCP\IUserManager;

class Website extends WebsiteCore
{
	/** @var int */
	const SITE_LENGTH_MIN = 3;

	/** @var int */
	const SITE_LENGTH_MAX = 255;

	/** @var string */
	const SITE_REGEX = '^[a-z][a-z0-9_-]+[a-z0-9]$';

	/** @var int */
	const NAME_LENGTH_MIN = 3;

	/** @var int */
	const NAME_LENGTH_MAX = 255;

	/** @var IConfig */
	private $config;

	/** @var IL10N */
	private $l10n;

	/** @var IUserManager */
	private $userManager;

	/** @var IGroupManager */
	private $groupManager;

	/** @var IURLGenerator */
	private $urlGenerator;

	/** @var WebsitesService */
	private $websitesService;

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

	/** @var TemplatesService */
	private $templatesService;

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

	/** @var StorageFolder */
	private $folder;

	/**
	 * Website constructor.
	 *
	 * @param array|string|null $data
	 */
	public function __construct($data = null)
	{
		$this->config = \OC::$server->getConfig();
		$this->l10n = \OC::$server->getL10N(Application::APP_NAME);
		$this->userManager = \OC::$server->getUserManager();
		$this->groupManager = \OC::$server->getGroupManager();
		$this->urlGenerator = \OC::$server->getURLGenerator();
		$this->websitesService = \OC::$server->query(WebsitesService::class);
		$this->themesService = \OC::$server->query(ThemesService::class);
		$this->templatesService = \OC::$server->query(TemplatesService::class);
		$this->miscService = \OC::$server->query(MiscService::class);

		parent::__construct($data);
	}

	/**
	 * @return string
	 */
	public function getTimeZone(): string
	{
		$serverTimeZone = date_default_timezone_get() ?: 'UTC';
		return $this->config->getUserValue($this->getUserId(), 'core', 'timezone', $serverTimeZone);
	}

	/**
	 * @param string $path
	 * @param array  $meta
	 *
	 * @throws InvalidPathException
	 * @throws WebsiteInvalidFilesystemException
	 * @throws WebsiteNotPermittedException
	 * @throws NotPermittedException
	 */
	public function assertViewerAccess(string $path, array $meta = [])
	{
		$exceptionClass = WebsiteNotPermittedException::class;
		if ($this->getType() === self::TYPE_PUBLIC) {
			if (empty($meta['access'])) {
				return;
			}

			$groupAccess = $meta['access'];
			if (!is_array($groupAccess)) {
				$groupAccess = explode(',', strtolower($groupAccess));
			}

			foreach ($groupAccess as $group) {
				if ($group === 'public') {
					return;
				} elseif ($group === 'private') {
					continue;
				}

				if ($this->getViewer() && $this->groupManager->groupExists($group)) {
					if ($this->groupManager->isInGroup($this->getViewer(), $group)) {
						return;
					}
				}
			}

			$exceptionClass = NotPermittedException::class;
		}

		if ($this->getViewer()) {
			if ($this->getViewer() === $this->getUserId()) {
				return;
			}

			/** @var OCFolder $viewerOCFolder */
			$viewerOCFolder = \OC::$server->getUserFolder($this->getViewer());
			$viewerAccessClosure = function (OCNode $node) use ($viewerOCFolder) {
				$nodeId = $node->getId();

				$viewerNodes = $viewerOCFolder->getById($nodeId);
				foreach ($viewerNodes as $viewerNode) {
					if ($viewerNode->isReadable()) {
						return true;
					}
				}

				return false;
			};

			$websiteFolder = $this->getWebsiteFolder();

			$path = $this->miscService->normalizePath($path);
			while ($path && ($path !== '.')) {
				try {
					/** @var StorageFile|StorageFolder $file */
					$file = $websiteFolder->get($path);
				} catch (NotFoundException $e) {
					$file = null;
				}

				if ($file) {
					if ($viewerAccessClosure($file->getOCNode())) {
						return;
					}

					throw new $exceptionClass();
				}

				$path = dirname($path);
			}

			if ($viewerAccessClosure($websiteFolder->getOCNode())) {
				return;
			}
		}

		throw new $exceptionClass();
	}

	/**
	 * @throws WebsiteInvalidOwnerException
	 */
	public function assertValidOwner()
	{
		$user = $this->userManager->get($this->getUserId());
		if ($user === null) {
			throw new WebsiteInvalidOwnerException();
		}
		if (!$user->isEnabled()) {
			throw new WebsiteInvalidOwnerException();
		}
		if (!$this->websitesService->isUserAllowed($this->getUserId())) {
			throw new WebsiteInvalidOwnerException();
		}
	}

	/**
	 * @throws WebsiteInvalidDataException
	 */
	public function assertValidName()
	{
		if (strlen($this->getName()) < self::NAME_LENGTH_MIN) {
			throw new WebsiteInvalidDataException('name', $this->l10n->t('The name of the website must be longer.'));
		}
		if (strlen($this->getName()) > self::NAME_LENGTH_MAX) {
			throw new WebsiteInvalidDataException('name', $this->l10n->t('The name of the website is too long.'));
		}
	}

	/**
	 * @throws WebsiteInvalidDataException
	 */
	public function assertValidSite()
	{
		if (strlen($this->getSite()) < self::SITE_LENGTH_MIN) {
			$errorMessage = $this->l10n->t('The identifier of the website must be longer.');
			throw new WebsiteInvalidDataException('site', $errorMessage);
		}
		if (strlen($this->getSite()) > self::SITE_LENGTH_MAX) {
			$errorMessage = $this->l10n->t('The identifier of the website is too long.');
			throw new WebsiteInvalidDataException('site', $errorMessage);
		}
		if (preg_match('/' . self::SITE_REGEX . '/', $this->getSite()) !== 1) {
			$errorMessage = $this->l10n->t('The identifier of the website can only contains alpha numeric chars.');
			throw new WebsiteInvalidDataException('site', $errorMessage);
		}
	}

	/**
	 * @throws WebsiteInvalidDataException
	 */
	public function assertValidPath()
	{
		try {
			$path = $this->miscService->normalizePath($this->getPath());
			if ($path === '') {
				throw new InvalidPathException();
			}
		} catch (InvalidPathException $e) {
			throw new WebsiteInvalidDataException(
				'path',
				$this->l10n->t('The path of the website is invalid.')
			);
		}

		$userFolder = new StorageFolder(\OC::$server->getUserFolder($this->getUserId()));

		try {
			$websiteBaseFolder = $userFolder->getFolder(dirname($path));

			try {
				$websiteFolder = $websiteBaseFolder->getFolder(basename($path));

				if (!$websiteFolder->isLocal()) {
					throw new WebsiteInvalidDataException(
						'path',
						$this->l10n->t('The website\'s path is stored on a non-local storage.')
					);
				}
			} catch (NotFoundException $e) {
				if (!$websiteBaseFolder->isLocal()) {
					throw new WebsiteInvalidDataException(
						'path',
						$this->l10n->t('The website\'s path is stored on a non-local storage.')
					);
				}
			}
		} catch (InvalidPathException $e) {
			throw new WebsiteInvalidDataException(
				'path',
				$this->l10n->t('Parent folder of the website\'s path not found.')
			);
		} catch (NotFoundException $e) {
			throw new WebsiteInvalidDataException(
				'path',
				$this->l10n->t('Parent folder of the website\'s path not found.')
			);
		}
	}

	/**
	 * @throws ThemeNotFoundException
	 * @throws ThemeNotCompatibleException
	 */
	public function assertValidTheme()
	{
		$this->themesService->assertValidTheme($this->getTheme());
	}

	/**
	 * @throws TemplateNotFoundException
	 * @throws TemplateNotCompatibleException
	 */
	public function assertValidTemplate()
	{
		$this->templatesService->assertValidTemplate($this->getTemplateSource());
	}

	/**
	 * @param string $userId
	 *
	 * @throws WebsiteForeignOwnerException
	 */
	public function assertOwnedBy($userId)
	{
		if ($this->getUserId() !== $userId) {
			throw new WebsiteForeignOwnerException();
		}
	}

	/**
	 * @return StorageFolder
	 * @throws WebsiteInvalidFilesystemException
	 */
	public function getWebsiteFolder(): StorageFolder
	{
		if ($this->folder !== null) {
			try {
				// NC doesn't guarantee that mounts are present for the whole request lifetime
				// for example, if you call \OC\Files\Utils\Scanner::scan(), all mounts are reset
				// this makes OCNode instances, which rely on mounts of different users than the current, unusable
				// by calling OCFolder::get('') we can detect this situation and re-init the required mounts
				$this->folder->get('');
			} catch (\Exception $e) {
				$this->folder = null;
			}
		}

		if ($this->folder === null) {
			try {
				$ocUserFolder = \OC::$server->getUserFolder($this->getUserId());
				$userFolder = new StorageFolder($ocUserFolder);

				$websiteFolder = $userFolder->getFolder($this->getPath());
				$this->folder = $websiteFolder->fakeRoot();
			} catch (InvalidPathException $e) {
				throw new WebsiteInvalidFilesystemException($e);
			} catch (NotFoundException $e) {
				throw new WebsiteInvalidFilesystemException($e);
			}
		}

		return $this->folder;
	}

	/**
	 * @return string
	 * @throws WebsiteInvalidFilesystemException
	 */
	public function getWebsitePath(): string
	{
		try {
			return $this->getWebsiteFolder()->getLocalPath() . '/';
		} catch (InvalidPathException $e) {
			throw new WebsiteInvalidFilesystemException($e);
		} catch (NotFoundException $e) {
			throw new WebsiteInvalidFilesystemException($e);
		}
	}

	/**
	 * @return string
	 */
	public function getWebsiteUrl(): string
	{
		if (!$this->getProxyRequest()) {
			$route = Application::APP_NAME . '.Pico.getPage';
			$parameters = [ 'site' => $this->getSite(), 'page' => '' ];
			return $this->urlGenerator->linkToRoute($route, $parameters) . '/';
		} else {
			return \OC::$WEBROOT . '/sites/' . urlencode($this->getSite()) . '/';
		}
	}
}


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\Model;
27
28		use OCA\CMSPico\AppInfo\Application;
29		use OCA\CMSPico\Exceptions\TemplateNotCompatibleException;
30		use OCA\CMSPico\Exceptions\TemplateNotFoundException;
31		use OCA\CMSPico\Exceptions\ThemeNotCompatibleException;
32		use OCA\CMSPico\Exceptions\ThemeNotFoundException;
33		use OCA\CMSPico\Exceptions\WebsiteForeignOwnerException;
34		use OCA\CMSPico\Exceptions\WebsiteInvalidDataException;
35		use OCA\CMSPico\Exceptions\WebsiteInvalidFilesystemException;
36		use OCA\CMSPico\Exceptions\WebsiteInvalidOwnerException;
37		use OCA\CMSPico\Exceptions\WebsiteNotPermittedException;
38		use OCA\CMSPico\Files\StorageFile;
39		use OCA\CMSPico\Files\StorageFolder;
40		use OCA\CMSPico\Service\MiscService;
41		use OCA\CMSPico\Service\TemplatesService;
42		use OCA\CMSPico\Service\ThemesService;
43		use OCA\CMSPico\Service\WebsitesService;
44		use OCP\Files\Folder as OCFolder;
45		use OCP\Files\InvalidPathException;
46		use OCP\Files\Node as OCNode;
47		use OCP\Files\NotFoundException;
48		use OCP\Files\NotPermittedException;
49		use OCP\IConfig;
50		use OCP\IGroupManager;
51		use OCP\IL10N;
52		use OCP\IURLGenerator;
53		use OCP\IUserManager;
54
55		class Website extends WebsiteCore
56		{
57		/** @var int */
58		const SITE_LENGTH_MIN = 3;
59
60		/** @var int */
61		const SITE_LENGTH_MAX = 255;
62
63		/** @var string */
64		const SITE_REGEX = '^[a-z][a-z0-9_-]+[a-z0-9]$';
65
66		/** @var int */
67		const NAME_LENGTH_MIN = 3;
68
69		/** @var int */
70		const NAME_LENGTH_MAX = 255;
71
72		/** @var IConfig */
73		private $config;
74
75		/** @var IL10N */
76		private $l10n;
77
78		/** @var IUserManager */
79		private $userManager;
80
81		/** @var IGroupManager */
82		private $groupManager;
83
84		/** @var IURLGenerator */
85		private $urlGenerator;
86
87		/** @var WebsitesService */
88		private $websitesService;
89
90		/** @var ThemesService */
91		private $themesService;
92
93		/** @var TemplatesService */
94		private $templatesService;
95
96		/** @var MiscService */
97		private $miscService;
98
99		/** @var StorageFolder */
100		private $folder;
101
102		/**
103		* Website constructor.
104		*
105		* @param array\|string\|null $data
106		*/
107	10	public function __construct($data = null)
108		{
109	10	$this->config = \OC::$server->getConfig();
110	10	$this->l10n = \OC::$server->getL10N(Application::APP_NAME);
111	10	$this->userManager = \OC::$server->getUserManager();
112	10	$this->groupManager = \OC::$server->getGroupManager();
113	10	$this->urlGenerator = \OC::$server->getURLGenerator();
114	10	$this->websitesService = \OC::$server->query(WebsitesService::class);
115	10	$this->themesService = \OC::$server->query(ThemesService::class);
116	10	$this->templatesService = \OC::$server->query(TemplatesService::class);
117	10	$this->miscService = \OC::$server->query(MiscService::class);
118
119	10	parent::__construct($data);
120	10	}
121
122		/**
123		* @return string
124		*/
125	2	public function getTimeZone(): string
126		{
127	2	$serverTimeZone = date_default_timezone_get() ?: 'UTC';
128	2	return $this->config->getUserValue($this->getUserId(), 'core', 'timezone', $serverTimeZone);
129		}
130
131		/**
132		* @param string $path
133		* @param array $meta
134		*
135		* @throws InvalidPathException
136		* @throws WebsiteInvalidFilesystemException
137		* @throws WebsiteNotPermittedException
138		* @throws NotPermittedException
139		*/
140	2	public function assertViewerAccess(string $path, array $meta = [])
141		{
142	2	$exceptionClass = WebsiteNotPermittedException::class;
143	2	if ($this->getType() === self::TYPE_PUBLIC) {
144	2	if (empty($meta['access'])) {
145	2	return;
146		}
147
148		$groupAccess = $meta['access'];
149		if (!is_array($groupAccess)) {
150		$groupAccess = explode(',', strtolower($groupAccess));
151		}
152
153		foreach ($groupAccess as $group) {
154		if ($group === 'public') {
155		return;
156		} elseif ($group === 'private') {
157		continue;
158		}
159
160		if ($this->getViewer() && $this->groupManager->groupExists($group)) {
161		if ($this->groupManager->isInGroup($this->getViewer(), $group)) {
162		return;
163		}
164		}
165		}
166
167		$exceptionClass = NotPermittedException::class;
168		}
169
170		if ($this->getViewer()) {
171		if ($this->getViewer() === $this->getUserId()) {
172		return;
173		}
174
175		/** @var OCFolder $viewerOCFolder */
176		$viewerOCFolder = \OC::$server->getUserFolder($this->getViewer());
177		$viewerAccessClosure = function (OCNode $node) use ($viewerOCFolder) {
178		$nodeId = $node->getId();
179
180		$viewerNodes = $viewerOCFolder->getById($nodeId);
181		foreach ($viewerNodes as $viewerNode) {
182		if ($viewerNode->isReadable()) {
183		return true;
184		}
185		}
186
187		return false;
188		};
189
190		$websiteFolder = $this->getWebsiteFolder();
191
192		$path = $this->miscService->normalizePath($path);
193		while ($path && ($path !== '.')) {
194		try {
195		/** @var StorageFile\|StorageFolder $file */
196		$file = $websiteFolder->get($path);
197		} catch (NotFoundException $e) {
198		$file = null;
199		}
200
201		if ($file) {
202		if ($viewerAccessClosure($file->getOCNode())) {
203		return;
204		}
205
206		throw new $exceptionClass();
207		}
208
209		$path = dirname($path);
210		}
211
212		if ($viewerAccessClosure($websiteFolder->getOCNode())) {
213		return;
214		}
215		}
216
217		throw new $exceptionClass();
218		}
219
220		/**
221		* @throws WebsiteInvalidOwnerException
222		*/
223	5	public function assertValidOwner()
224		{
225	5	$user = $this->userManager->get($this->getUserId());
226	5	if ($user === null) {
227		throw new WebsiteInvalidOwnerException();
228		}
229	5	if (!$user->isEnabled()) {
230		throw new WebsiteInvalidOwnerException();
231		}
232	5	if (!$this->websitesService->isUserAllowed($this->getUserId())) {
233		throw new WebsiteInvalidOwnerException();
234		}
235	5	}
236
237		/**
238		* @throws WebsiteInvalidDataException
239		*/
240	4	public function assertValidName()
241		{
242	4	if (strlen($this->getName()) < self::NAME_LENGTH_MIN) {
243		throw new WebsiteInvalidDataException('name', $this->l10n->t('The name of the website must be longer.'));
244		}
245	4	if (strlen($this->getName()) > self::NAME_LENGTH_MAX) {
246		throw new WebsiteInvalidDataException('name', $this->l10n->t('The name of the website is too long.'));
247		}
248	4	}
249
250		/**
251		* @throws WebsiteInvalidDataException
252		*/
253	4	public function assertValidSite()
254		{
255	4	if (strlen($this->getSite()) < self::SITE_LENGTH_MIN) {
256		$errorMessage = $this->l10n->t('The identifier of the website must be longer.');
257		throw new WebsiteInvalidDataException('site', $errorMessage);
258		}
259	4	if (strlen($this->getSite()) > self::SITE_LENGTH_MAX) {
260		$errorMessage = $this->l10n->t('The identifier of the website is too long.');
261		throw new WebsiteInvalidDataException('site', $errorMessage);
262		}
263	4	if (preg_match('/' . self::SITE_REGEX . '/', $this->getSite()) !== 1) {
264		$errorMessage = $this->l10n->t('The identifier of the website can only contains alpha numeric chars.');
265		throw new WebsiteInvalidDataException('site', $errorMessage);
266		}
267	4	}
268
269		/**
270		* @throws WebsiteInvalidDataException
271		*/
272	3	public function assertValidPath()
273		{
274		try {
275	3	$path = $this->miscService->normalizePath($this->getPath());
276	3	if ($path === '') {
277	3	throw new InvalidPathException();
278		}
279		} catch (InvalidPathException $e) {
280		throw new WebsiteInvalidDataException(
281		'path',
282		$this->l10n->t('The path of the website is invalid.')
283		);
284		}
285
286	3	$userFolder = new StorageFolder(\OC::$server->getUserFolder($this->getUserId()));
287
288		try {
289	3	$websiteBaseFolder = $userFolder->getFolder(dirname($path));
290
291		try {
292	3	$websiteFolder = $websiteBaseFolder->getFolder(basename($path));
293
294	1	if (!$websiteFolder->isLocal()) {
295		throw new WebsiteInvalidDataException(
296		'path',
297	1	$this->l10n->t('The website\'s path is stored on a non-local storage.')
298		);
299		}
300	3	} catch (NotFoundException $e) {
301	3	if (!$websiteBaseFolder->isLocal()) {
302		throw new WebsiteInvalidDataException(
303		'path',
304	3	$this->l10n->t('The website\'s path is stored on a non-local storage.')
305		);
306		}
307		}
308		} catch (InvalidPathException $e) {
309		throw new WebsiteInvalidDataException(
310		'path',
311		$this->l10n->t('Parent folder of the website\'s path not found.')
312		);
313		} catch (NotFoundException $e) {
314		throw new WebsiteInvalidDataException(
315		'path',
316		$this->l10n->t('Parent folder of the website\'s path not found.')
317		);
318		}
319	3	}
320
321		/**
322		* @throws ThemeNotFoundException
323		* @throws ThemeNotCompatibleException
324		*/
325	3	public function assertValidTheme()
326		{
327	3	$this->themesService->assertValidTheme($this->getTheme());
328	3	}
329
330		/**
331		* @throws TemplateNotFoundException
332		* @throws TemplateNotCompatibleException
333		*/
334	3	public function assertValidTemplate()
335		{
336	3	$this->templatesService->assertValidTemplate($this->getTemplateSource());
337	3	}
338
339		/**
340		* @param string $userId
341		*
342		* @throws WebsiteForeignOwnerException
343		*/
344	2	public function assertOwnedBy($userId)
345		{
346	2	if ($this->getUserId() !== $userId) {
347	1	throw new WebsiteForeignOwnerException();
348		}
349	2	}
350
351		/**
352		* @return StorageFolder
353		* @throws WebsiteInvalidFilesystemException
354		*/
355	2	public function getWebsiteFolder(): StorageFolder
356		{
357	2	if ($this->folder !== null) {
358		try {
359		// NC doesn't guarantee that mounts are present for the whole request lifetime
360		// for example, if you call \OC\Files\Utils\Scanner::scan(), all mounts are reset
361		// this makes OCNode instances, which rely on mounts of different users than the current, unusable
362		// by calling OCFolder::get('') we can detect this situation and re-init the required mounts
363	2	$this->folder->get('');
364		} catch (\Exception $e) {
365		$this->folder = null;
366		}
367		}
368
369	2	if ($this->folder === null) {
370		try {
371	2	$ocUserFolder = \OC::$server->getUserFolder($this->getUserId());
372	2	$userFolder = new StorageFolder($ocUserFolder);
373
374	2	$websiteFolder = $userFolder->getFolder($this->getPath());
375	2	$this->folder = $websiteFolder->fakeRoot();
376		} catch (InvalidPathException $e) {
377		throw new WebsiteInvalidFilesystemException($e);
378		} catch (NotFoundException $e) {
379		throw new WebsiteInvalidFilesystemException($e);
380		}
381		}
382
383	2	return $this->folder;
384		}
385
386		/**
387		* @return string
388		* @throws WebsiteInvalidFilesystemException
389		*/
390	2	public function getWebsitePath(): string
391		{
392		try {
393	2	return $this->getWebsiteFolder()->getLocalPath() . '/';
394		} catch (InvalidPathException $e) {
395		throw new WebsiteInvalidFilesystemException($e);
396		} catch (NotFoundException $e) {
397		throw new WebsiteInvalidFilesystemException($e);
398		}
399		}
400
401		/**
402		* @return string
403		*/
404	2	public function getWebsiteUrl(): string
405		{
406	2	if (!$this->getProxyRequest()) {
407	2	$route = Application::APP_NAME . '.Pico.getPage';
408	2	$parameters = [ 'site' => $this->getSite(), 'page' => '' ];
409	2	return $this->urlGenerator->linkToRoute($route, $parameters) . '/';
410		} else {
411		return \OC::$WEBROOT . '/sites/' . urlencode($this->getSite()) . '/';
412		}
413		}
414		}
415

nextcloud / cms_pico

Pull Request — master (#77)

Website::assertViewerAccess() D

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like