WebsitesService::__construct() - Code Metrics - nextcloud/cms_pico - Measure and Improve Code Quality continuously with Scrutinizer

WebsitesService::__construct() A
last analyzed 2023-03-14 02:41 UTC

↳ Parent: WebsitesService

Complexity

Conditions	1
Paths	1

Size

Total Lines	16
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	8
CRAP Score	1

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	7
c	1
b	0
f	0
dl	0
loc	16
ccs	8
cts	8
cp	1
rs	10
cc	1
nc	1
nop	7
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\Db\WebsitesRequest;
use OCA\CMSPico\Exceptions\AssetInvalidPathException;
use OCA\CMSPico\Exceptions\AssetNotFoundException;
use OCA\CMSPico\Exceptions\AssetNotPermittedException;
use OCA\CMSPico\Exceptions\FilesystemNotLocalException;
use OCA\CMSPico\Exceptions\PageInvalidPathException;
use OCA\CMSPico\Exceptions\PageNotFoundException;
use OCA\CMSPico\Exceptions\PageNotPermittedException;
use OCA\CMSPico\Exceptions\PicoRuntimeException;
use OCA\CMSPico\Exceptions\TemplateNotCompatibleException;
use OCA\CMSPico\Exceptions\TemplateNotFoundException;
use OCA\CMSPico\Exceptions\ThemeNotCompatibleException;
use OCA\CMSPico\Exceptions\ThemeNotFoundException;
use OCA\CMSPico\Exceptions\WebsiteAlreadyExistsException;
use OCA\CMSPico\Exceptions\WebsiteInvalidDataException;
use OCA\CMSPico\Exceptions\WebsiteInvalidFilesystemException;
use OCA\CMSPico\Exceptions\WebsiteInvalidOwnerException;
use OCA\CMSPico\Exceptions\WebsiteNotFoundException;
use OCA\CMSPico\Exceptions\WebsiteNotPermittedException;
use OCA\CMSPico\Model\PicoAsset;
use OCA\CMSPico\Model\PicoPage;
use OCA\CMSPico\Model\Website;
use OCA\CMSPico\Model\WebsiteRequest;
use OCP\Files\InvalidPathException;
use OCP\IGroupManager;

class WebsitesService
{
	/** @var int */
	public const LINK_MODE_LONG = 1;

	/** @var int */
	public const LINK_MODE_SHORT = 2;

	/** @var WebsitesRequest */
	private $websitesRequest;

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

	/** @var ConfigService */
	private $configService;

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

	/** @var PicoService */
	private $picoService;

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

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

	/**
	 * WebsitesService constructor.
	 *
	 * @param WebsitesRequest  $websiteRequest
	 * @param IGroupManager    $groupManager
	 * @param ConfigService    $configService
	 * @param TemplatesService $templatesService
	 * @param PicoService      $picoService
	 * @param AssetsService    $assetsService
	 * @param MiscService      $miscService
	 */
	public function __construct(
		WebsitesRequest $websiteRequest,
		IGroupManager $groupManager,
		ConfigService $configService,
		TemplatesService $templatesService,
		PicoService $picoService,
		AssetsService $assetsService,
		MiscService $miscService
	) {
		$this->websitesRequest = $websiteRequest;
		$this->groupManager = $groupManager;
		$this->configService = $configService;
		$this->templatesService = $templatesService;
		$this->picoService = $picoService;
		$this->assetsService = $assetsService;
		$this->miscService = $miscService;
	}

	/**
	 * Creates a new website.
	 *
	 * Warning: This method does not check whether the user is allowed to create websites!
	 * Please use {@see Website::assertValidOwner()} beforehand.
	 *
	 * @param Website $website
	 * @param string  $templateName
	 *
	 * @throws WebsiteAlreadyExistsException
	 * @throws WebsiteInvalidDataException
	 * @throws WebsiteInvalidOwnerException
	 * @throws ThemeNotFoundException
	 * @throws ThemeNotCompatibleException
	 * @throws TemplateNotFoundException
	 * @throws TemplateNotCompatibleException
	 */
	public function createWebsite(Website $website, string $templateName): void
	{
		$website->assertValidName();
		$website->assertValidSite();
		$website->assertValidPath();
		$website->assertValidTheme();

		try {
			$this->websitesRequest->getWebsiteFromSite($website->getSite());
			throw new WebsiteAlreadyExistsException($website->getSite());
		} catch (WebsiteNotFoundException $e) {
			// in fact we want the website not to exist yet
		}

		$this->templatesService->assertValidTemplate($templateName);
		$this->templatesService->installTemplate($website, $templateName);

		$this->websitesRequest->create($website);
	}

	/**
	 * Updates a website.
	 *
	 * Warning: This method does not check the ownership of the website!
	 * Please use {@see Website::assertOwnedBy()} beforehand.
	 *
	 * @param Website $website
	 *
	 * @throws WebsiteNotFoundException
	 * @throws WebsiteInvalidDataException
	 * @throws ThemeNotFoundException
	 * @throws ThemeNotCompatibleException
	 * @throws TemplateNotFoundException
	 * @throws TemplateNotCompatibleException
	 */
	public function updateWebsite(Website $website): void
	{
		$originalWebsite = $this->websitesRequest->getWebsiteFromId($website->getId());

		if ($website->getName() !== $originalWebsite->getName()) {
			$website->assertValidName();
		}
		if ($website->getSite() !== $originalWebsite->getSite()) {
			$website->assertValidSite();
		}
		if ($website->getPath() !== $originalWebsite->getPath()) {
			$website->assertValidPath();
		}
		if ($website->getTheme() !== $originalWebsite->getTheme()) {
			$website->assertValidTheme();
		}

		$this->websitesRequest->update($website);
	}

	/**
	 * Deletes a website.
	 *
	 * Warning: This method does not check the ownership of the website!
	 * Please use {@see Website::assertOwnedBy()} beforehand.
	 *
	 * @param Website $website
	 *
	 * @throws WebsiteNotFoundException
	 */
	public function deleteWebsite(Website $website): void
	{
		// check whether website actually exists
		$this->websitesRequest->getWebsiteFromId($website->getId());

		$this->websitesRequest->delete($website);
	}

	/**
	 * Deletes all websites of a user.
	 *
	 * Warning: This method does not check the ownership of the website!
	 * Please use {@see Website::assertOwnedBy()} beforehand.
	 *
	 * @param string $userId
	 */
	public function deleteUserWebsites(string $userId): void
	{
		$this->websitesRequest->deleteAllFromUserId($userId);
	}

	/**
	 * @param int $siteId
	 *
	 * @return Website
	 * @throws WebsiteNotFoundException
	 */
	public function getWebsiteFromId(int $siteId): Website
	{
		return $this->websitesRequest->getWebsiteFromId($siteId);
	}

	/**
	 * @param string $site
	 *
	 * @return Website
	 * @throws WebsiteNotFoundException
	 */
	public function getWebsiteFromSite(string $site): Website
	{
		return $this->websitesRequest->getWebsiteFromSite($site);
	}

	/**
	 * @param string $userId
	 *
	 * @return Website[]
	 */
	public function getWebsitesFromUser(string $userId): array
	{
		return $this->websitesRequest->getWebsitesFromUserId($userId);
	}

	/**
	 * @return Website[]
	 */
	public function getWebsites(): array
	{
		return $this->websitesRequest->getWebsites();
	}

	/**
	 * @param string      $site
	 * @param string      $page
	 * @param string|null $viewer
	 * @param bool        $proxyRequest
	 *
	 * @return PicoPage
	 * @throws WebsiteNotFoundException
	 * @throws WebsiteInvalidOwnerException
	 * @throws WebsiteInvalidFilesystemException
	 * @throws WebsiteNotPermittedException
	 * @throws FilesystemNotLocalException
	 * @throws PageInvalidPathException
	 * @throws PageNotFoundException
	 * @throws PageNotPermittedException
	 * @throws ThemeNotFoundException
	 * @throws ThemeNotCompatibleException
	 * @throws PicoRuntimeException
	 */
	public function getPage(string $site, string $page, ?string $viewer, bool $proxyRequest = false): PicoPage
	{
		try {
			$page = $this->miscService->normalizePath($page);
		} catch (InvalidPathException $e) {
			throw new PageInvalidPathException($site, $page, $e);
		}

		$website = $this->getWebsiteFromSite($site);
		$website->assertValidOwner();

		if (!$website->getWebsiteFolder()->isLocal()) {
			throw new FilesystemNotLocalException();
		}

		$websiteRequest = new WebsiteRequest($website, $viewer, $page, $proxyRequest);
		return $this->picoService->getPage($websiteRequest);
	}

	/**
	 * @param string      $site
	 * @param string      $asset
	 * @param string|null $viewer
	 *
	 * @return PicoAsset
	 * @throws WebsiteNotFoundException
	 * @throws WebsiteInvalidOwnerException
	 * @throws WebsiteInvalidFilesystemException
	 * @throws WebsiteNotPermittedException
	 * @throws FilesystemNotLocalException
	 * @throws AssetInvalidPathException
	 * @throws AssetNotFoundException
	 * @throws AssetNotPermittedException
	 */
	public function getAsset(string $site, string $asset, ?string $viewer): PicoAsset
	{
		try {
			$asset = $this->miscService->normalizePath($asset);
			if ($asset === '') {
				throw new InvalidPathException();
			}
		} catch (InvalidPathException $e) {
			throw new AssetInvalidPathException($site, $asset, $e);
		}

		$website = $this->getWebsiteFromSite($site);
		$website->assertValidOwner();

		if (!$website->getWebsiteFolder()->isLocal()) {
			throw new FilesystemNotLocalException();
		}

		$websiteRequest = new WebsiteRequest($website, $viewer, PicoService::DIR_ASSETS . '/' . $asset);
		return $this->assetsService->getAsset($websiteRequest);
	}

	/**
	 * @param string[] $limitGroups
	 *
	 * @throws \UnexpectedValueException
	 */
	public function setLimitGroups(array $limitGroups): void
	{
		foreach ($limitGroups as $group) {
			if (!$this->groupManager->groupExists($group)) {
				throw new \UnexpectedValueException();
			}
		}

		$this->configService->setAppValue(ConfigService::LIMIT_GROUPS, json_encode($limitGroups));
	}

	/**
	 * @return string[]
	 */
	public function getLimitGroups(): array
	{
		$json = $this->configService->getAppValue(ConfigService::LIMIT_GROUPS);
		return $json ? json_decode($json, true) : [];
	}

	/**
	 * @param string|null $userId
	 *
	 * @return bool
	 */
	public function isUserAllowed(?string $userId): bool
	{
		if (!$userId) {
			return false;
		}

		$limitGroups = $this->getLimitGroups();
		if (empty($limitGroups)) {
			return true;
		}

		foreach ($limitGroups as $groupId) {
			if ($this->groupManager->isInGroup($userId, $groupId)) {
				return true;
			}
		}

		return false;
	}

	/**
	 * @param int $linkMode
	 *
	 * @throws \UnexpectedValueException
	 */
	public function setLinkMode(int $linkMode): void
	{
		if (($linkMode !== self::LINK_MODE_LONG) && ($linkMode !== self::LINK_MODE_SHORT)) {
			throw new \UnexpectedValueException();
		}

		$this->configService->setAppValue(ConfigService::LINK_MODE, (string) $linkMode);
	}

	/**
	 * @return int
	 */
	public function getLinkMode(): int
	{
		return (int) $this->configService->getAppValue(ConfigService::LINK_MODE);
	}
}


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\Db\WebsitesRequest;
29		use OCA\CMSPico\Exceptions\AssetInvalidPathException;
30		use OCA\CMSPico\Exceptions\AssetNotFoundException;
31		use OCA\CMSPico\Exceptions\AssetNotPermittedException;
32		use OCA\CMSPico\Exceptions\FilesystemNotLocalException;
33		use OCA\CMSPico\Exceptions\PageInvalidPathException;
34		use OCA\CMSPico\Exceptions\PageNotFoundException;
35		use OCA\CMSPico\Exceptions\PageNotPermittedException;
36		use OCA\CMSPico\Exceptions\PicoRuntimeException;
37		use OCA\CMSPico\Exceptions\TemplateNotCompatibleException;
38		use OCA\CMSPico\Exceptions\TemplateNotFoundException;
39		use OCA\CMSPico\Exceptions\ThemeNotCompatibleException;
40		use OCA\CMSPico\Exceptions\ThemeNotFoundException;
41		use OCA\CMSPico\Exceptions\WebsiteAlreadyExistsException;
42		use OCA\CMSPico\Exceptions\WebsiteInvalidDataException;
43		use OCA\CMSPico\Exceptions\WebsiteInvalidFilesystemException;
44		use OCA\CMSPico\Exceptions\WebsiteInvalidOwnerException;
45		use OCA\CMSPico\Exceptions\WebsiteNotFoundException;
46		use OCA\CMSPico\Exceptions\WebsiteNotPermittedException;
47		use OCA\CMSPico\Model\PicoAsset;
48		use OCA\CMSPico\Model\PicoPage;
49		use OCA\CMSPico\Model\Website;
50		use OCA\CMSPico\Model\WebsiteRequest;
51		use OCP\Files\InvalidPathException;
52		use OCP\IGroupManager;
53
54		class WebsitesService
55		{
56		/** @var int */
57		public const LINK_MODE_LONG = 1;
58
59		/** @var int */
60		public const LINK_MODE_SHORT = 2;
61
62		/** @var WebsitesRequest */
63		private $websitesRequest;
64
65		/** @var IGroupManager */
66		private $groupManager;
67
68		/** @var ConfigService */
69		private $configService;
70
71		/** @var TemplatesService */
72		private $templatesService;
73
74		/** @var PicoService */
75		private $picoService;
76
77		/** @var AssetsService */
78		private $assetsService;
79
80		/** @var MiscService */
81		private $miscService;
82
83		/**
84		* WebsitesService constructor.
85		*
86		* @param WebsitesRequest $websiteRequest
87		* @param IGroupManager $groupManager
88		* @param ConfigService $configService
89		* @param TemplatesService $templatesService
90		* @param PicoService $picoService
91		* @param AssetsService $assetsService
92		* @param MiscService $miscService
93		*/
94	1	public function __construct(
95		WebsitesRequest $websiteRequest,
96		IGroupManager $groupManager,
97		ConfigService $configService,
98		TemplatesService $templatesService,
99		PicoService $picoService,
100		AssetsService $assetsService,
101		MiscService $miscService
102		) {
103	1	$this->websitesRequest = $websiteRequest;
104	1	$this->groupManager = $groupManager;
105	1	$this->configService = $configService;
106	1	$this->templatesService = $templatesService;
107	1	$this->picoService = $picoService;
108	1	$this->assetsService = $assetsService;
109	1	$this->miscService = $miscService;
110	1	}
111
112		/**
113		* Creates a new website.
114		*
115		* Warning: This method does not check whether the user is allowed to create websites!
116		* Please use {@see Website::assertValidOwner()} beforehand.
117		*
118		* @param Website $website
119		* @param string $templateName
120		*
121		* @throws WebsiteAlreadyExistsException
122		* @throws WebsiteInvalidDataException
123		* @throws WebsiteInvalidOwnerException
124		* @throws ThemeNotFoundException
125		* @throws ThemeNotCompatibleException
126		* @throws TemplateNotFoundException
127		* @throws TemplateNotCompatibleException
128		*/
129	5	public function createWebsite(Website $website, string $templateName): void
130		{
131	5	$website->assertValidName();
132	5	$website->assertValidSite();
133	5	$website->assertValidPath();
134	5	$website->assertValidTheme();
135
136		try {
137	5	$this->websitesRequest->getWebsiteFromSite($website->getSite());
138	1	throw new WebsiteAlreadyExistsException($website->getSite());
139	5	} catch (WebsiteNotFoundException $e) {
140		// in fact we want the website not to exist yet
141		}
142
143	4	$this->templatesService->assertValidTemplate($templateName);
144	4	$this->templatesService->installTemplate($website, $templateName);
145
146	4	$this->websitesRequest->create($website);
147	4	}
148
149		/**
150		* Updates a website.
151		*
152		* Warning: This method does not check the ownership of the website!
153		* Please use {@see Website::assertOwnedBy()} beforehand.
154		*
155		* @param Website $website
156		*
157		* @throws WebsiteNotFoundException
158		* @throws WebsiteInvalidDataException
159		* @throws ThemeNotFoundException
160		* @throws ThemeNotCompatibleException
161		* @throws TemplateNotFoundException
162		* @throws TemplateNotCompatibleException
163		*/
164	1	public function updateWebsite(Website $website): void
165		{
166	1	$originalWebsite = $this->websitesRequest->getWebsiteFromId($website->getId());
167
168	1	if ($website->getName() !== $originalWebsite->getName()) {
169		$website->assertValidName();
170		}
171	1	if ($website->getSite() !== $originalWebsite->getSite()) {
172		$website->assertValidSite();
173		}
174	1	if ($website->getPath() !== $originalWebsite->getPath()) {
175		$website->assertValidPath();
176		}
177	1	if ($website->getTheme() !== $originalWebsite->getTheme()) {
178		$website->assertValidTheme();
179		}
180
181	1	$this->websitesRequest->update($website);
182	1	}
183
184		/**
185		* Deletes a website.
186		*
187		* Warning: This method does not check the ownership of the website!
188		* Please use {@see Website::assertOwnedBy()} beforehand.
189		*
190		* @param Website $website
191		*
192		* @throws WebsiteNotFoundException
193		*/
194	1	public function deleteWebsite(Website $website): void
195		{
196		// check whether website actually exists
197	1	$this->websitesRequest->getWebsiteFromId($website->getId());
198
199	1	$this->websitesRequest->delete($website);
200	1	}
201
202		/**
203		* Deletes all websites of a user.
204		*
205		* Warning: This method does not check the ownership of the website!
206		* Please use {@see Website::assertOwnedBy()} beforehand.
207		*
208		* @param string $userId
209		*/
210		public function deleteUserWebsites(string $userId): void
211		{
212		$this->websitesRequest->deleteAllFromUserId($userId);
213		}
214
215		/**
216		* @param int $siteId
217		*
218		* @return Website
219		* @throws WebsiteNotFoundException
220		*/
221	2	public function getWebsiteFromId(int $siteId): Website
222		{
223	2	return $this->websitesRequest->getWebsiteFromId($siteId);
224		}
225
226		/**
227		* @param string $site
228		*
229		* @return Website
230		* @throws WebsiteNotFoundException
231		*/
232	9	public function getWebsiteFromSite(string $site): Website
233		{
234	9	return $this->websitesRequest->getWebsiteFromSite($site);
235		}
236
237		/**
238		* @param string $userId
239		*
240		* @return Website[]
241		*/
242	6	public function getWebsitesFromUser(string $userId): array
243		{
244	6	return $this->websitesRequest->getWebsitesFromUserId($userId);
245		}
246
247		/**
248		* @return Website[]
249		*/
250		public function getWebsites(): array
251		{
252		return $this->websitesRequest->getWebsites();
253		}
254
255		/**
256		* @param string $site
257		* @param string $page
258		* @param string\|null $viewer
259		* @param bool $proxyRequest
260		*
261		* @return PicoPage
262		* @throws WebsiteNotFoundException
263		* @throws WebsiteInvalidOwnerException
264		* @throws WebsiteInvalidFilesystemException
265		* @throws WebsiteNotPermittedException
266		* @throws FilesystemNotLocalException
267		* @throws PageInvalidPathException
268		* @throws PageNotFoundException
269		* @throws PageNotPermittedException
270		* @throws ThemeNotFoundException
271		* @throws ThemeNotCompatibleException
272		* @throws PicoRuntimeException
273		*/
274	6	public function getPage(string $site, string $page, ?string $viewer, bool $proxyRequest = false): PicoPage
275		{
276		try {
277	6	$page = $this->miscService->normalizePath($page);
278		} catch (InvalidPathException $e) {
279		throw new PageInvalidPathException($site, $page, $e);
280		}
281
282	6	$website = $this->getWebsiteFromSite($site);
283	6	$website->assertValidOwner();
284
285	6	if (!$website->getWebsiteFolder()->isLocal()) {
286		throw new FilesystemNotLocalException();
287		}
288
289	6	$websiteRequest = new WebsiteRequest($website, $viewer, $page, $proxyRequest);
290	6	return $this->picoService->getPage($websiteRequest);
291		}
292
293		/**
294		* @param string $site
295		* @param string $asset
296		* @param string\|null $viewer
297		*
298		* @return PicoAsset
299		* @throws WebsiteNotFoundException
300		* @throws WebsiteInvalidOwnerException
301		* @throws WebsiteInvalidFilesystemException
302		* @throws WebsiteNotPermittedException
303		* @throws FilesystemNotLocalException
304		* @throws AssetInvalidPathException
305		* @throws AssetNotFoundException
306		* @throws AssetNotPermittedException
307		*/
308	3	public function getAsset(string $site, string $asset, ?string $viewer): PicoAsset
309		{
310		try {
311	3	$asset = $this->miscService->normalizePath($asset);
312	3	if ($asset === '') {
313	3	throw new InvalidPathException();
314		}
315		} catch (InvalidPathException $e) {
316		throw new AssetInvalidPathException($site, $asset, $e);
317		}
318
319	3	$website = $this->getWebsiteFromSite($site);
320	3	$website->assertValidOwner();
321
322	3	if (!$website->getWebsiteFolder()->isLocal()) {
323		throw new FilesystemNotLocalException();
324		}
325
326	3	$websiteRequest = new WebsiteRequest($website, $viewer, PicoService::DIR_ASSETS . '/' . $asset);
327	3	return $this->assetsService->getAsset($websiteRequest);
328		}
329
330		/**
331		* @param string[] $limitGroups
332		*
333		* @throws \UnexpectedValueException
334		*/
335		public function setLimitGroups(array $limitGroups): void
336		{
337		foreach ($limitGroups as $group) {
338		if (!$this->groupManager->groupExists($group)) {
339		throw new \UnexpectedValueException();
340		}
341		}
342
343		$this->configService->setAppValue(ConfigService::LIMIT_GROUPS, json_encode($limitGroups));
344		}
345
346		/**
347		* @return string[]
348		*/
349	12	public function getLimitGroups(): array
350		{
351	12	$json = $this->configService->getAppValue(ConfigService::LIMIT_GROUPS);
352	12	return $json ? json_decode($json, true) : [];
353		}
354
355		/**
356		* @param string\|null $userId
357		*
358		* @return bool
359		*/
360	12	public function isUserAllowed(?string $userId): bool
361		{
362	12	if (!$userId) {
363		return false;
364		}
365
366	12	$limitGroups = $this->getLimitGroups();
367	12	if (empty($limitGroups)) {
368	12	return true;
369		}
370
371		foreach ($limitGroups as $groupId) {
372		if ($this->groupManager->isInGroup($userId, $groupId)) {
373		return true;
374		}
375		}
376
377		return false;
378		}
379
380		/**
381		* @param int $linkMode
382		*
383		* @throws \UnexpectedValueException
384		*/
385		public function setLinkMode(int $linkMode): void
386		{
387		if (($linkMode !== self::LINK_MODE_LONG) && ($linkMode !== self::LINK_MODE_SHORT)) {
388		throw new \UnexpectedValueException();
389		}
390
391		$this->configService->setAppValue(ConfigService::LINK_MODE, (string) $linkMode);
392		}
393
394		/**
395		* @return int
396		*/
397		public function getLinkMode(): int
398		{
399		return (int) $this->configService->getAppValue(ConfigService::LINK_MODE);
400		}
401		}
402

nextcloud / cms_pico

WebsitesService::__construct() A last analyzed 2023-03-14 02:41 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

WebsitesService::__construct() A
last analyzed 2023-03-14 02:41 UTC