Issues in FilesReportPlugin.php - Fixed Issues - Inspection of "commit transaction after select query" - owncloud/core - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#26700)

by Philipp

created 2016-11-23 11:35 UTC

apps/dav/lib/Connector/Sabre/FilesReportPlugin.php (1 issue)

Showing only issues like (Show All)

Check for PhpDoc comments which do parse

Documentation Minor

Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more

<?php
/**
 * @author Joas Schilling <[email protected]>
 * @author Vincent Petry <[email protected]>
 *
 * @copyright Copyright (c) 2016, ownCloud GmbH.
 * @license AGPL-3.0
 *
 * This code is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License, version 3,
 * as published by the Free Software Foundation.
 *
 * 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, version 3,
 * along with this program.  If not, see <http://www.gnu.org/licenses/>
 *
 */

namespace OCA\DAV\Connector\Sabre;

use OC\Files\View;
use Sabre\DAV\Exception\NotFound;
use Sabre\DAV\Exception\PreconditionFailed;
use Sabre\DAV\Exception\ReportNotSupported;
use Sabre\DAV\Exception\BadRequest;
use Sabre\DAV\ServerPlugin;
use Sabre\DAV\Tree;
use Sabre\DAV\Xml\Element\Response;
use Sabre\DAV\Xml\Response\MultiStatus;
use Sabre\DAV\PropFind;
use OCP\SystemTag\ISystemTagObjectMapper;
use OCP\IUserSession;
use OCP\Files\Folder;
use OCP\IGroupManager;
use OCP\SystemTag\ISystemTagManager;
use OCP\SystemTag\TagNotFoundException;
use OCP\ITagManager;

class FilesReportPlugin extends ServerPlugin {

	// namespace
	const NS_OWNCLOUD = 'http://owncloud.org/ns';
	const REPORT_NAME            = '{http://owncloud.org/ns}filter-files';
	const SYSTEMTAG_PROPERTYNAME = '{http://owncloud.org/ns}systemtag';

	/**
	 * Reference to main server object
	 *
	 * @var \Sabre\DAV\Server
	 */
	private $server;

	/**
	 * @var Tree
	 */
	private $tree;

	/**
	 * @var View
	 */
	private $fileView;

	/**
	 * @var ISystemTagManager
	 */
	private $tagManager;

	/**
	 * @var ISystemTagObjectMapper
	 */
	private $tagMapper;

	/**
	 * Manager for private tags
	 *
	 * @var ITagManager
	 */
	private $fileTagger;

	/**
	 * @var IUserSession
	 */
	private $userSession;

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

	/**
	 * @var Folder
	 */
	private $userFolder;

	/**
	 * @param Tree $tree
	 * @param View $view
	 * @param ISystemTagManager $tagManager
	 * @param ISystemTagObjectMapper $tagMapper
	 * @param ITagManager $fileTagger manager for private tags
	 * @param IUserSession $userSession
	 * @param IGroupManager $groupManager
	 * @param Folder $userfolder
	 */
	public function __construct(Tree $tree,
								View $view,
								ISystemTagManager $tagManager,
								ISystemTagObjectMapper $tagMapper,
								ITagManager $fileTagger,
								IUserSession $userSession,
								IGroupManager $groupManager,
								Folder $userFolder
	) {
		$this->tree = $tree;
		$this->fileView = $view;
		$this->tagManager = $tagManager;
		$this->tagMapper = $tagMapper;
		$this->fileTagger = $fileTagger;
		$this->userSession = $userSession;
		$this->groupManager = $groupManager;
		$this->userFolder = $userFolder;
	}

	/**
	 * This initializes the plugin.
	 *
	 * This function is called by \Sabre\DAV\Server, after
	 * addPlugin is called.
	 *
	 * This method should set up the required event subscriptions.
	 *
	 * @param \Sabre\DAV\Server $server
	 * @return void
	 */
	public function initialize(\Sabre\DAV\Server $server) {

		$server->xml->namespaceMap[self::NS_OWNCLOUD] = 'oc';

		$this->server = $server;
		$this->server->on('report', [$this, 'onReport']);
	}

	/**
	 * Returns a list of reports this plugin supports.
	 *
	 * This will be used in the {DAV:}supported-report-set property.
	 *
	 * @param string $uri
	 * @return array
	 */
	public function getSupportedReportSet($uri) {
		return [self::REPORT_NAME];
	}

	/**
	 * REPORT operations to look for files
	 *
	 * @param string $reportName
	 * @param [] $report

	 * @param string $uri
	 * @return bool
	 * @throws NotFound
	 * @throws ReportNotSupported
	 */
	public function onReport($reportName, $report, $uri) {
		$reportTargetNode = $this->server->tree->getNodeForPath($uri);
		if (!$reportTargetNode instanceof Directory || $reportName !== self::REPORT_NAME) {
			return;
		}

		$ns = '{' . $this::NS_OWNCLOUD . '}';
		$requestedProps = [];
		$filterRules = [];

		// parse report properties and gather filter info
		foreach ($report as $reportProps) {
			$name = $reportProps['name'];
			if ($name === $ns . 'filter-rules') {
				$filterRules = $reportProps['value'];
			} else if ($name === '{DAV:}prop') {
				// propfind properties
				foreach ($reportProps['value'] as $propVal) {
					$requestedProps[] = $propVal['name'];
				}
			}
		}

		if (empty($filterRules)) {
			// an empty filter would return all existing files which would be slow
			throw new BadRequest('Missing filter-rule block in request');
		}

		// gather all file ids matching filter
		try {
			$resultFileIds = $this->processFilterRules($filterRules);
		} catch (TagNotFoundException $e) {
			throw new PreconditionFailed('Cannot filter by non-existing tag', 0, $e);
		}

		// find sabre nodes by file id, restricted to the root node path
		$results = $this->findNodesByFileIds($reportTargetNode, $resultFileIds);

		$filesUri = $this->getFilesBaseUri($uri, $reportTargetNode->getPath());
		$responses = $this->prepareResponses($filesUri, $requestedProps, $results);

		$xml = $this->server->xml->write(
			'{DAV:}multistatus',
			new MultiStatus($responses)
		);

		$this->server->httpResponse->setStatus(207);
		$this->server->httpResponse->setHeader('Content-Type', 'application/xml; charset=utf-8');
		$this->server->httpResponse->setBody($xml);

		return false;
	}

	/**
	 * Returns the base uri of the files root by removing
	 * the subpath from the URI
	 *
	 * @param string $uri URI from this request
	 * @param string $subPath subpath to remove from the URI
	 *
	 * @return string files base uri
	 */
	private function getFilesBaseUri($uri, $subPath) {
		$uri = trim($uri, '/');
		$subPath = trim($subPath, '/');
		$filesUri = '';
		if (empty($subPath)) {
			$filesUri = $uri;
		} else {
			$filesUri = substr($uri, 0, strlen($uri) - strlen($subPath));
		}
		$filesUri = trim($filesUri, '/');
		if (empty($filesUri)) {
			return '';
		}
		return '/' . $filesUri;
	}

	/**
	 * Find file ids matching the given filter rules
	 *
	 * @param array $filterRules
	 * @return array array of unique file id results
	 *
	 * @throws TagNotFoundException whenever a tag was not found
	 */
	protected function processFilterRules($filterRules) {
		$ns = '{' . $this::NS_OWNCLOUD . '}';
		$resultFileIds = null;
		$systemTagIds = [];
		$favoriteFilter = null;
		foreach ($filterRules as $filterRule) {
			if ($filterRule['name'] === $ns . 'systemtag') {
				$systemTagIds[] = $filterRule['value'];
			}
			if ($filterRule['name'] === $ns . 'favorite') {
				$favoriteFilter = true;
			}
		}

		if ($favoriteFilter !== null) {
			$resultFileIds = $this->fileTagger->load('files')->getFavorites();
			if (empty($resultFileIds)) {
				return [];
			}
		}

		if (!empty($systemTagIds)) {
			$fileIds = $this->getSystemTagFileIds($systemTagIds);
			if (empty($resultFileIds)) {
				$resultFileIds = $fileIds;
			} else {
				$resultFileIds = array_intersect($fileIds, $resultFileIds);
			}
		}

		return $resultFileIds;
	}

	private function getSystemTagFileIds($systemTagIds) {
		$resultFileIds = null;

		// check user permissions, if applicable
		if (!$this->isAdmin()) {
			// check visibility/permission
			$tags = $this->tagManager->getTagsByIds($systemTagIds);
			$unknownTagIds = [];
			foreach ($tags as $tag) {
				if (!$tag->isUserVisible()) {
					$unknownTagIds[] = $tag->getId();
				}
			}

			if (!empty($unknownTagIds)) {
				throw new TagNotFoundException('Tag with ids ' . implode(', ', $unknownTagIds) . ' not found');
			}
		}

		// fetch all file ids and intersect them
		foreach ($systemTagIds as $systemTagId) {
			$fileIds = $this->tagMapper->getObjectIdsForTags($systemTagId, 'files');

			if (empty($fileIds)) {
				// This tag has no files, nothing can ever show up
				return [];
			}

			// first run ?
			if ($resultFileIds === null) {
				$resultFileIds = $fileIds;
			} else {
				$resultFileIds = array_intersect($resultFileIds, $fileIds);
			}

			if (empty($resultFileIds)) {
				// Empty intersection, nothing can show up anymore
				return [];
			}
		}
		return $resultFileIds;
	}

	/**
	 * Prepare propfind response for the given nodes
	 *
	 * @param string $filesUri $filesUri URI leading to root of the files URI,
	 * with a leading slash but no trailing slash
	 * @param string[] $requestedProps requested properties
	 * @param Node[] nodes nodes for which to fetch and prepare responses
	 * @return Response[]
	 */
	public function prepareResponses($filesUri, $requestedProps, $nodes) {
		$responses = [];
		foreach ($nodes as $node) {
			$propFind = new PropFind($filesUri . $node->getPath(), $requestedProps);

			$this->server->getPropertiesByNode($propFind, $node);
			// copied from Sabre Server's getPropertiesForPath
			$result = $propFind->getResultForMultiStatus();
			$result['href'] = $propFind->getPath();

			$resourceType = $this->server->getResourceTypeForNode($node);
			if (in_array('{DAV:}collection', $resourceType) || in_array('{DAV:}principal', $resourceType)) {
				$result['href'] .= '/';
			}

			$responses[] = new Response(
				rtrim($this->server->getBaseUri(), '/') . $filesUri . $node->getPath(),
				$result,
				200
			);
		}
		return $responses;
	}

	/**
	 * Find Sabre nodes by file ids
	 *
	 * @param Node $rootNode root node for search
	 * @param array $fileIds file ids
	 * @return Node[] array of Sabre nodes
	 */
	public function findNodesByFileIds($rootNode, $fileIds) {
		$folder = $this->userFolder;
		if (trim($rootNode->getPath(), '/') !== '') {
			$folder = $folder->get($rootNode->getPath());
		}

		$results = [];
		foreach ($fileIds as $fileId) {
			$entry = $folder->getById($fileId);
			if ($entry) {
				$entry = current($entry);
				if ($entry instanceof \OCP\Files\File) {
					$results[] = new File($this->fileView, $entry);
				} else if ($entry instanceof \OCP\Files\Folder) {
					$results[] = new Directory($this->fileView, $entry);
				}
			}
		}

		return $results;
	}

	/**
	 * Returns whether the currently logged in user is an administrator
	 */
	private function isAdmin() {
		$user = $this->userSession->getUser();
		if ($user !== null) {
			return $this->groupManager->isAdmin($user->getUID());
		}
		return false;
	}
}


1		<?php
2		/**
3		* @author Joas Schilling <[email protected]>
4		* @author Vincent Petry <[email protected]>
5		*
6		* @copyright Copyright (c) 2016, ownCloud GmbH.
7		* @license AGPL-3.0
8		*
9		* This code is free software: you can redistribute it and/or modify
10		* it under the terms of the GNU Affero General Public License, version 3,
11		* as published by the Free Software Foundation.
12		*
13		* This program is distributed in the hope that it will be useful,
14		* but WITHOUT ANY WARRANTY; without even the implied warranty of
15		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16		* GNU Affero General Public License for more details.
17		*
18		* You should have received a copy of the GNU Affero General Public License, version 3,
19		* along with this program. If not, see <http://www.gnu.org/licenses/>
20		*
21		*/
22
23		namespace OCA\DAV\Connector\Sabre;
24
25		use OC\Files\View;
26		use Sabre\DAV\Exception\NotFound;
27		use Sabre\DAV\Exception\PreconditionFailed;
28		use Sabre\DAV\Exception\ReportNotSupported;
29		use Sabre\DAV\Exception\BadRequest;
30		use Sabre\DAV\ServerPlugin;
31		use Sabre\DAV\Tree;
32		use Sabre\DAV\Xml\Element\Response;
33		use Sabre\DAV\Xml\Response\MultiStatus;
34		use Sabre\DAV\PropFind;
35		use OCP\SystemTag\ISystemTagObjectMapper;
36		use OCP\IUserSession;
37		use OCP\Files\Folder;
38		use OCP\IGroupManager;
39		use OCP\SystemTag\ISystemTagManager;
40		use OCP\SystemTag\TagNotFoundException;
41		use OCP\ITagManager;
42
43		class FilesReportPlugin extends ServerPlugin {
44
45		// namespace
46		const NS_OWNCLOUD = 'http://owncloud.org/ns';
47		const REPORT_NAME = '{http://owncloud.org/ns}filter-files';
48		const SYSTEMTAG_PROPERTYNAME = '{http://owncloud.org/ns}systemtag';
49
50		/**
51		* Reference to main server object
52		*
53		* @var \Sabre\DAV\Server
54		*/
55		private $server;
56
57		/**
58		* @var Tree
59		*/
60		private $tree;
61
62		/**
63		* @var View
64		*/
65		private $fileView;
66
67		/**
68		* @var ISystemTagManager
69		*/
70		private $tagManager;
71
72		/**
73		* @var ISystemTagObjectMapper
74		*/
75		private $tagMapper;
76
77		/**
78		* Manager for private tags
79		*
80		* @var ITagManager
81		*/
82		private $fileTagger;
83
84		/**
85		* @var IUserSession
86		*/
87		private $userSession;
88
89		/**
90		* @var IGroupManager
91		*/
92		private $groupManager;
93
94		/**
95		* @var Folder
96		*/
97		private $userFolder;
98
99		/**
100		* @param Tree $tree
101		* @param View $view
102		* @param ISystemTagManager $tagManager
103		* @param ISystemTagObjectMapper $tagMapper
104		* @param ITagManager $fileTagger manager for private tags
105		* @param IUserSession $userSession
106		* @param IGroupManager $groupManager
107		* @param Folder $userfolder
108		*/
109		public function __construct(Tree $tree,
110		View $view,
111		ISystemTagManager $tagManager,
112		ISystemTagObjectMapper $tagMapper,
113		ITagManager $fileTagger,
114		IUserSession $userSession,
115		IGroupManager $groupManager,
116		Folder $userFolder
117		) {
118		$this->tree = $tree;
119		$this->fileView = $view;
120		$this->tagManager = $tagManager;
121		$this->tagMapper = $tagMapper;
122		$this->fileTagger = $fileTagger;
123		$this->userSession = $userSession;
124		$this->groupManager = $groupManager;
125		$this->userFolder = $userFolder;
126		}
127
128		/**
129		* This initializes the plugin.
130		*
131		* This function is called by \Sabre\DAV\Server, after
132		* addPlugin is called.
133		*
134		* This method should set up the required event subscriptions.
135		*
136		* @param \Sabre\DAV\Server $server
137		* @return void
138		*/
139		public function initialize(\Sabre\DAV\Server $server) {
140
141		$server->xml->namespaceMap[self::NS_OWNCLOUD] = 'oc';
142
143		$this->server = $server;
144		$this->server->on('report', [$this, 'onReport']);
145		}
146
147		/**
148		* Returns a list of reports this plugin supports.
149		*
150		* This will be used in the {DAV:}supported-report-set property.
151		*
152		* @param string $uri
153		* @return array
154		*/
155		public function getSupportedReportSet($uri) {
156		return [self::REPORT_NAME];
157		}
158
159		/**
160		* REPORT operations to look for files
161		*
162		* @param string $reportName
163		* @param [] $report
		0 ignored issues – show Documentation introduced 2016-02-09 08:39 UTC by Report Bug Copy Issue Report Show Similar Issues like this The doc-type `[]` could not be parsed: Unknown type name "" at position 0. [(view supported doc-types) This check marks PHPDoc comments that could not be parsed by our parser. To see which comment annotations we can parse, please refer to our documentation on supported doc-types. Loading history...
164		* @param string $uri
165		* @return bool
166		* @throws NotFound
167		* @throws ReportNotSupported
168		*/
169		public function onReport($reportName, $report, $uri) {
170		$reportTargetNode = $this->server->tree->getNodeForPath($uri);
171		if (!$reportTargetNode instanceof Directory \|\| $reportName !== self::REPORT_NAME) {
172		return;
173		}
174
175		$ns = '{' . $this::NS_OWNCLOUD . '}';
176		$requestedProps = [];
177		$filterRules = [];
178
179		// parse report properties and gather filter info
180		foreach ($report as $reportProps) {
181		$name = $reportProps['name'];
182		if ($name === $ns . 'filter-rules') {
183		$filterRules = $reportProps['value'];
184		} else if ($name === '{DAV:}prop') {
185		// propfind properties
186		foreach ($reportProps['value'] as $propVal) {
187		$requestedProps[] = $propVal['name'];
188		}
189		}
190		}
191
192		if (empty($filterRules)) {
193		// an empty filter would return all existing files which would be slow
194		throw new BadRequest('Missing filter-rule block in request');
195		}
196
197		// gather all file ids matching filter
198		try {
199		$resultFileIds = $this->processFilterRules($filterRules);
200		} catch (TagNotFoundException $e) {
201		throw new PreconditionFailed('Cannot filter by non-existing tag', 0, $e);
202		}
203
204		// find sabre nodes by file id, restricted to the root node path
205		$results = $this->findNodesByFileIds($reportTargetNode, $resultFileIds);
206
207		$filesUri = $this->getFilesBaseUri($uri, $reportTargetNode->getPath());
208		$responses = $this->prepareResponses($filesUri, $requestedProps, $results);
209
210		$xml = $this->server->xml->write(
211		'{DAV:}multistatus',
212		new MultiStatus($responses)
213		);
214
215		$this->server->httpResponse->setStatus(207);
216		$this->server->httpResponse->setHeader('Content-Type', 'application/xml; charset=utf-8');
217		$this->server->httpResponse->setBody($xml);
218
219		return false;
220		}
221
222		/**
223		* Returns the base uri of the files root by removing
224		* the subpath from the URI
225		*
226		* @param string $uri URI from this request
227		* @param string $subPath subpath to remove from the URI
228		*
229		* @return string files base uri
230		*/
231		private function getFilesBaseUri($uri, $subPath) {
232		$uri = trim($uri, '/');
233		$subPath = trim($subPath, '/');
234		$filesUri = '';
235		if (empty($subPath)) {
236		$filesUri = $uri;
237		} else {
238		$filesUri = substr($uri, 0, strlen($uri) - strlen($subPath));
239		}
240		$filesUri = trim($filesUri, '/');
241		if (empty($filesUri)) {
242		return '';
243		}
244		return '/' . $filesUri;
245		}
246
247		/**
248		* Find file ids matching the given filter rules
249		*
250		* @param array $filterRules
251		* @return array array of unique file id results
252		*
253		* @throws TagNotFoundException whenever a tag was not found
254		*/
255		protected function processFilterRules($filterRules) {
256		$ns = '{' . $this::NS_OWNCLOUD . '}';
257		$resultFileIds = null;
258		$systemTagIds = [];
259		$favoriteFilter = null;
260		foreach ($filterRules as $filterRule) {
261		if ($filterRule['name'] === $ns . 'systemtag') {
262		$systemTagIds[] = $filterRule['value'];
263		}
264		if ($filterRule['name'] === $ns . 'favorite') {
265		$favoriteFilter = true;
266		}
267		}
268
269		if ($favoriteFilter !== null) {
270		$resultFileIds = $this->fileTagger->load('files')->getFavorites();
271		if (empty($resultFileIds)) {
272		return [];
273		}
274		}
275
276		if (!empty($systemTagIds)) {
277		$fileIds = $this->getSystemTagFileIds($systemTagIds);
278		if (empty($resultFileIds)) {
279		$resultFileIds = $fileIds;
280		} else {
281		$resultFileIds = array_intersect($fileIds, $resultFileIds);
282		}
283		}
284
285		return $resultFileIds;
286		}
287
288		private function getSystemTagFileIds($systemTagIds) {
289		$resultFileIds = null;
290
291		// check user permissions, if applicable
292		if (!$this->isAdmin()) {
293		// check visibility/permission
294		$tags = $this->tagManager->getTagsByIds($systemTagIds);
295		$unknownTagIds = [];
296		foreach ($tags as $tag) {
297		if (!$tag->isUserVisible()) {
298		$unknownTagIds[] = $tag->getId();
299		}
300		}
301
302		if (!empty($unknownTagIds)) {
303		throw new TagNotFoundException('Tag with ids ' . implode(', ', $unknownTagIds) . ' not found');
304		}
305		}
306
307		// fetch all file ids and intersect them
308		foreach ($systemTagIds as $systemTagId) {
309		$fileIds = $this->tagMapper->getObjectIdsForTags($systemTagId, 'files');
310
311		if (empty($fileIds)) {
312		// This tag has no files, nothing can ever show up
313		return [];
314		}
315
316		// first run ?
317		if ($resultFileIds === null) {
318		$resultFileIds = $fileIds;
319		} else {
320		$resultFileIds = array_intersect($resultFileIds, $fileIds);
321		}
322
323		if (empty($resultFileIds)) {
324		// Empty intersection, nothing can show up anymore
325		return [];
326		}
327		}
328		return $resultFileIds;
329		}
330
331		/**
332		* Prepare propfind response for the given nodes
333		*
334		* @param string $filesUri $filesUri URI leading to root of the files URI,
335		* with a leading slash but no trailing slash
336		* @param string[] $requestedProps requested properties
337		* @param Node[] nodes nodes for which to fetch and prepare responses
338		* @return Response[]
339		*/
340		public function prepareResponses($filesUri, $requestedProps, $nodes) {
341		$responses = [];
342		foreach ($nodes as $node) {
343		$propFind = new PropFind($filesUri . $node->getPath(), $requestedProps);
344
345		$this->server->getPropertiesByNode($propFind, $node);
346		// copied from Sabre Server's getPropertiesForPath
347		$result = $propFind->getResultForMultiStatus();
348		$result['href'] = $propFind->getPath();
349
350		$resourceType = $this->server->getResourceTypeForNode($node);
351		if (in_array('{DAV:}collection', $resourceType) \|\| in_array('{DAV:}principal', $resourceType)) {
352		$result['href'] .= '/';
353		}
354
355		$responses[] = new Response(
356		rtrim($this->server->getBaseUri(), '/') . $filesUri . $node->getPath(),
357		$result,
358		200
359		);
360		}
361		return $responses;
362		}
363
364		/**
365		* Find Sabre nodes by file ids
366		*
367		* @param Node $rootNode root node for search
368		* @param array $fileIds file ids
369		* @return Node[] array of Sabre nodes
370		*/
371		public function findNodesByFileIds($rootNode, $fileIds) {
372		$folder = $this->userFolder;
373		if (trim($rootNode->getPath(), '/') !== '') {
374		$folder = $folder->get($rootNode->getPath());
375		}
376
377		$results = [];
378		foreach ($fileIds as $fileId) {
379		$entry = $folder->getById($fileId);
380		if ($entry) {
381		$entry = current($entry);
382		if ($entry instanceof \OCP\Files\File) {
383		$results[] = new File($this->fileView, $entry);
384		} else if ($entry instanceof \OCP\Files\Folder) {
385		$results[] = new Directory($this->fileView, $entry);
386		}
387		}
388		}
389
390		return $results;
391		}
392
393		/**
394		* Returns whether the currently logged in user is an administrator
395		*/
396	View Code Duplication	private function isAdmin() {
397		$user = $this->userSession->getUser();
398		if ($user !== null) {
399		return $this->groupManager->isAdmin($user->getUID());
400		}
401		return false;
402		}
403		}
404

owncloud / core

Pull Request — master (#26700)

apps/dav/lib/Connector/Sabre/FilesReportPlugin.php (1 issue)

Showing only issues like (Show All)

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like