Environment::getPathFromUserFolder() - Code Metrics - Inspection of "Backport 180816" - interfasys/galleryplus - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#46)

by Olivier

created 2016-06-18 17:57 UTC

Environment::getPathFromUserFolder() A

↳ Parent: Environment

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	5
ccs	3
cts	3
cp	1
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	3
nc	1
nop	1
crap	1

<?php
/**
 * ownCloud - galleryplus
 *
 * This file is licensed under the Affero General Public License version 3 or
 * later. See the COPYING file.
 *
 * @author Olivier Paroz <[email protected]>
 * @author Authors of \OCA\Files_Sharing\Helper
 *
 * @copyright Olivier Paroz 2016
 * @copyright Authors of \OCA\Files_Sharing\Helper 2014-2016
 */

namespace OCA\GalleryPlus\Environment;

use OCP\IUserManager;
use OCP\Share;
use OCP\Share\IShare;
use OCP\ILogger;
use OCP\Files\IRootFolder;
use OCP\Files\Folder;
use OCP\Files\Node;
use OCP\Files\File;
use OCP\Files\NotFoundException;

/**
 * Builds the environment so that the services have access to the files and folders' owner
 *
 * @package OCA\GalleryPlus\Environment
 */
class Environment {

	/**
	 * @var string
	 */
	private $appName;
	/**
	 * The userId of the logged-in user or the person sharing a folder publicly
	 *
	 * @var string
	 */
	private $userId;
	/**
	 * The userFolder of the logged-in user or the ORIGINAL owner of the files which are shared
	 * publicly
	 *
	 * A share needs to be tracked back to its original owner in order to be able to access the
	 * resource
	 *
	 * @var Folder|null
	 */
	private $userFolder;
	/**
	 * @var IUserManager
	 */
	private $userManager;
	/**
	 * @var int
	 */
	private $sharedNodeId;
	/**
	 * @var File|Folder
	 */
	private $sharedNode;
	/**
	 * @var IRootFolder
	 */
	private $rootFolder;
	/**
	 * @var ILogger
	 */
	private $logger;
	/**
	 * The path to the userFolder for users with accounts: /userId/files
	 *
	 * For public folders, it's the path from the shared folder to the root folder in the original
	 * owner's filesystem: /userId/files/parent_folder/shared_folder
	 *
	 * @var string
	 */
	private $fromRootToFolder;
	/**
	 * The name of the shared folder
	 *
	 * @var string
	 */
	private $folderName;
	/**
	 * @var string|null
	 */
	private $sharePassword;

	/***
	 * Constructor
	 *
	 * @param string $appName
	 * @param string|null $userId
	 * @param Folder|null $userFolder
	 * @param IUserManager $userManager
	 * @param IRootFolder $rootFolder
	 * @param ILogger $logger
	 */
	public function __construct(
		$appName,
		$userId,
		$userFolder,
		IUserManager $userManager,
		IRootFolder $rootFolder,
		ILogger $logger
	) {
		$this->appName = $appName;
		$this->userId = $userId;
		$this->userFolder = $userFolder;
		$this->userManager = $userManager;
		$this->rootFolder = $rootFolder;
		$this->logger = $logger;
	}

	/**
	 * Creates the environment based on the share the token links to
	 *
	 * @param IShare $share
	 */
	public function setTokenBasedEnv($share) {
		$origShareOwnerId = $share->getShareOwner();
		$this->userFolder = $this->rootFolder->getUserFolder($origShareOwnerId);

		$this->sharedNodeId = $share->getNodeId();
		$this->sharedNode = $share->getNode();
		$this->fromRootToFolder = $this->buildFromRootToFolder($this->sharedNodeId);

		$this->folderName = $share->getTarget();
		$this->userId = $origShareOwnerId;
		$this->sharePassword = $share->getPassword();
	}

	/**
	 * Creates the environment for a logged-in user
	 *
	 * userId and userFolder are already known, we define fromRootToFolder
	 * so that the services can use one method to have access to resources
	 * without having to know whether they're private or public
	 */
	public function setStandardEnv() {
		$this->fromRootToFolder = $this->userFolder->getPath() . '/';
	}

	/**
	 * Returns true if the environment has been setup using a token
	 *
	 * @return bool
	 */
	public function isTokenBasedEnv() {
		return !empty($this->sharedNodeId);
	}

	/**
	 * Returns the Node based on a path starting from the virtual root
	 *
	 * @param string $subPath
	 *
	 * @return File|Folder

	 */
	public function getNodeFromVirtualRoot($subPath) {
		$relativePath = $this->getRelativePath($this->fromRootToFolder);
		$path = $relativePath . '/' . $subPath;
		$node = $this->getNodeFromUserFolder($path);

		return $this->getResourceFromId($node->getId());
	}

	/**
	 * Returns the Node based on a path starting from the files' owner user folder
	 *
	 * When logged in, this is the current user's user folder
	 * When visiting a link, this is the sharer's user folder
	 *
	 * @param string $path
	 *
	 * @return File|Folder
	 *
	 * @throws NotFoundEnvException
	 */
	public function getNodeFromUserFolder($path) {
		$folder = $this->userFolder;
		if ($folder === null) {
			throw new NotFoundEnvException("Could not access the user's folder");
		} else {
			try {
				$node = $folder->get($path);
			} catch (NotFoundException $exception) {
				$message = 'Could not find anything at: ' . $exception->getMessage();
				throw new NotFoundEnvException($message);
			}
		}

		return $node;
	}

	/**
	 * Returns the resource identified by the given ID
	 *
	 * @param int $resourceId
	 *
	 * @return Node
	 *
	 * @throws NotFoundEnvException
	 */
	public function getResourceFromId($resourceId) {
		if ($this->isTokenBasedEnv()) {
			if ($this->sharedNode->getType() === 'dir') {
				$resource = $this->getResourceFromFolderAndId($this->sharedNode, $resourceId);
			} else {
				$resource = $this->sharedNode;
			}
		} else {
			$resource = $this->getResourceFromFolderAndId($this->userFolder, $resourceId);
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
		}

		return $resource;
	}

	/**
	 * Returns the shared node
	 *
	 * @return File|Folder

	 */
	public function getSharedNode() {
		return $this->getResourceFromId($this->sharedNodeId);
	}

	/**
	 * Returns the virtual root where the user lands after logging in or when following a link
	 *
	 * @return Folder
	 * @throws NotFoundEnvException
	 */
	public function getVirtualRootFolder() {
		$rootFolder = $this->userFolder;
		if ($this->isTokenBasedEnv()) {
			$node = $this->getSharedNode();
			$nodeType = $node->getType();
			if ($nodeType === 'dir') {
				$rootFolder = $node;
			} else {
				throw new NotFoundEnvException($node->getPath() . ' is not a folder');
			}
		}

		return $rootFolder;
	}

	/**
	 * Returns the userId of the currently logged-in user or the sharer
	 *
	 * @return string
	 */
	public function getUserId() {
		return $this->userId;
	}

	/**
	 * Returns the name of the user sharing files publicly
	 *
	 * @return string
	 * @throws NotFoundEnvException
	 */
	public function getDisplayName() {
		$user = null;
		$userId = $this->userId;

		if (isset($userId)) {
			$user = $this->userManager->get($userId);
		}
		if ($user === null) {
			throw new NotFoundEnvException('Could not find user');
		}

		return $user->getDisplayName();
	}

	/**
	 * Returns the name of shared folder
	 *
	 * @return string
	 */
	public function getSharedFolderName() {
		return trim($this->folderName, '//');
	}

	/**
	 * Returns the password for the share, if there is one
	 *
	 * @return string|null
	 */
	public function getSharePassword() {
		return $this->sharePassword;
	}

	/**
	 * Returns the path which goes from the file, up to the user folder, based on a node:
	 * parent_folder/current_folder/my_file
	 *
	 * This is used for the preview system, which needs a full path
	 *
	 * getPath() on the file produces a path like:
	 * '/userId/files/my_folder/my_sub_folder/my_file'
	 *
	 * So we substract the path to the folder, giving us a relative path
	 * 'my_folder/my_sub_folder/my_file'
	 *
	 * @param Node $file
	 *
	 * @return string
	 */
	public function getPathFromUserFolder($file) {
		$path = $file->getPath();

		return $this->getRelativePath($path);
	}

	/**
	 * Returns the path which goes from the file, up to the root folder of the Gallery:
	 * current_folder/my_file
	 *
	 * That root folder changes when folders are shared publicly
	 *
	 * @param File|Folder|Node $node
	 *
	 * @return string
	 */
	public function getPathFromVirtualRoot($node) {
		$path = $node->getPath();
		$nodeType = $node->getType();

		// Needed because fromRootToFolder always ends with a slash
		if ($nodeType === 'dir') {
			$path .= '/';
		}

		$path = str_replace($this->fromRootToFolder, '', $path);
		$path = rtrim($path, '/');

		return $path;
	}

	/**
	 * Returns the resource found in a specific folder and identified by the given ID
	 *
	 * @param Folder $folder
	 * @param int $resourceId
	 *
	 * @return Node
	 * @throws NotFoundEnvException
	 */
	private function getResourceFromFolderAndId($folder, $resourceId) {
		$resourcesArray = $folder->getById($resourceId);

		if ($resourcesArray[0] === null) {
			throw new NotFoundEnvException('Could not locate node linked to ID: ' . $resourceId);
		}

		return $resourcesArray[0];
	}

	/**
	 * Returns the path from the shared folder to the root folder in the original
	 * owner's filesystem: /userId/files/parent_folder/shared_folder
	 *
	 * This cannot be calculated with paths and IDs, the share's file source is required
	 *
	 * @param string $fileSource
	 *
	 * @return string
	 */
	private function buildFromRootToFolder($fileSource) {
		$resource = $this->getResourceFromId($fileSource);
		$fromRootToFolder = $resource->getPath() . '/';

		return $fromRootToFolder;
	}

	/**
	 * Returns the path which goes from the file, up to the user folder, based on a path:
	 * parent_folder/current_folder/my_file
	 *
	 * getPath() on the file produces a path like:
	 * '/userId/files/my_folder/my_sub_folder/my_file'
	 *
	 * So we substract the path to the user folder, giving us a relative path
	 * 'my_folder/my_sub_folder'
	 *
	 * @param string $fullPath
	 *
	 * @return string
	 */
	private function getRelativePath($fullPath) {
		$folderPath = $this->userFolder->getPath() . '/';
		$origShareRelPath = str_replace($folderPath, '', $fullPath);

		return $origShareRelPath;
	}

}


1		<?php
2		/**
3		* ownCloud - galleryplus
4		*
5		* This file is licensed under the Affero General Public License version 3 or
6		* later. See the COPYING file.
7		*
8		* @author Olivier Paroz <[email protected]>
9		* @author Authors of \OCA\Files_Sharing\Helper
10		*
11		* @copyright Olivier Paroz 2016
12		* @copyright Authors of \OCA\Files_Sharing\Helper 2014-2016
13		*/
14
15		namespace OCA\GalleryPlus\Environment;
16
17		use OCP\IUserManager;
18		use OCP\Share;
19		use OCP\Share\IShare;
20		use OCP\ILogger;
21		use OCP\Files\IRootFolder;
22		use OCP\Files\Folder;
23		use OCP\Files\Node;
24		use OCP\Files\File;
25		use OCP\Files\NotFoundException;
26
27		/**
28		* Builds the environment so that the services have access to the files and folders' owner
29		*
30		* @package OCA\GalleryPlus\Environment
31		*/
32		class Environment {
33
34		/**
35		* @var string
36		*/
37		private $appName;
38		/**
39		* The userId of the logged-in user or the person sharing a folder publicly
40		*
41		* @var string
42		*/
43		private $userId;
44		/**
45		* The userFolder of the logged-in user or the ORIGINAL owner of the files which are shared
46		* publicly
47		*
48		* A share needs to be tracked back to its original owner in order to be able to access the
49		* resource
50		*
51		* @var Folder\|null
52		*/
53		private $userFolder;
54		/**
55		* @var IUserManager
56		*/
57		private $userManager;
58		/**
59		* @var int
60		*/
61		private $sharedNodeId;
62		/**
63		* @var File\|Folder
64		*/
65		private $sharedNode;
66		/**
67		* @var IRootFolder
68		*/
69		private $rootFolder;
70		/**
71		* @var ILogger
72		*/
73		private $logger;
74		/**
75		* The path to the userFolder for users with accounts: /userId/files
76		*
77		* For public folders, it's the path from the shared folder to the root folder in the original
78		* owner's filesystem: /userId/files/parent_folder/shared_folder
79		*
80		* @var string
81		*/
82		private $fromRootToFolder;
83		/**
84		* The name of the shared folder
85		*
86		* @var string
87		*/
88		private $folderName;
89		/**
90		* @var string\|null
91		*/
92		private $sharePassword;
93
94		/***
95		* Constructor
96		*
97		* @param string $appName
98		* @param string\|null $userId
99		* @param Folder\|null $userFolder
100		* @param IUserManager $userManager
101		* @param IRootFolder $rootFolder
102		* @param ILogger $logger
103		*/
104	59	public function __construct(
105		$appName,
106		$userId,
107		$userFolder,
108		IUserManager $userManager,
109		IRootFolder $rootFolder,
110		ILogger $logger
111		) {
112	59	$this->appName = $appName;
113	59	$this->userId = $userId;
114	59	$this->userFolder = $userFolder;
115	59	$this->userManager = $userManager;
116	59	$this->rootFolder = $rootFolder;
117	59	$this->logger = $logger;
118	59	}
119
120		/**
121		* Creates the environment based on the share the token links to
122		*
123		* @param IShare $share
124		*/
125	21	public function setTokenBasedEnv($share) {
126	21	$origShareOwnerId = $share->getShareOwner();
127	21	$this->userFolder = $this->rootFolder->getUserFolder($origShareOwnerId);
128
129	21	$this->sharedNodeId = $share->getNodeId();
130	21	$this->sharedNode = $share->getNode();
131	21	$this->fromRootToFolder = $this->buildFromRootToFolder($this->sharedNodeId);
132
133	21	$this->folderName = $share->getTarget();
134	21	$this->userId = $origShareOwnerId;
135	21	$this->sharePassword = $share->getPassword();
136	21	}
137
138		/**
139		* Creates the environment for a logged-in user
140		*
141		* userId and userFolder are already known, we define fromRootToFolder
142		* so that the services can use one method to have access to resources
143		* without having to know whether they're private or public
144		*/
145	29	public function setStandardEnv() {
146	29	$this->fromRootToFolder = $this->userFolder->getPath() . '/';
147	29	}
148
149		/**
150		* Returns true if the environment has been setup using a token
151		*
152		* @return bool
153		*/
154	43	public function isTokenBasedEnv() {
155	43	return !empty($this->sharedNodeId);
156		}
157
158		/**
159		* Returns the Node based on a path starting from the virtual root
160		*
161		* @param string $subPath
162		*
163		* @return File\|Folder
		0 ignored issues – show Documentation introduced 2016-02-21 16:24 UTC by Report Bug Copy Issue Report Should the return type not be `Node`? This check compares the return type specified in the `@return` annotation of a function or method doc comment with the types returned by the function and raises an issue if they mismatch. Loading history...
164		*/
165	8	public function getNodeFromVirtualRoot($subPath) {
166	8	$relativePath = $this->getRelativePath($this->fromRootToFolder);
167	8	$path = $relativePath . '/' . $subPath;
168	8	$node = $this->getNodeFromUserFolder($path);
169
170	8	return $this->getResourceFromId($node->getId());
171		}
172
173		/**
174		* Returns the Node based on a path starting from the files' owner user folder
175		*
176		* When logged in, this is the current user's user folder
177		* When visiting a link, this is the sharer's user folder
178		*
179		* @param string $path
180		*
181		* @return File\|Folder
182		*
183		* @throws NotFoundEnvException
184		*/
185	11	public function getNodeFromUserFolder($path) {
186	11	$folder = $this->userFolder;
187	11	if ($folder === null) {
188	1	throw new NotFoundEnvException("Could not access the user's folder");
189		} else {
190		try {
191	10	$node = $folder->get($path);
192	2	} catch (NotFoundException $exception) {
193	2	$message = 'Could not find anything at: ' . $exception->getMessage();
194	2	throw new NotFoundEnvException($message);
195		}
196		}
197
198	10	return $node;
199		}
200
201		/**
202		* Returns the resource identified by the given ID
203		*
204		* @param int $resourceId
205		*
206		* @return Node
207		*
208		* @throws NotFoundEnvException
209		*/
210	37	public function getResourceFromId($resourceId) {
211	37	if ($this->isTokenBasedEnv()) {
212	21	if ($this->sharedNode->getType() === 'dir') {
213	16	$resource = $this->getResourceFromFolderAndId($this->sharedNode, $resourceId);
214		} else {
215	21	$resource = $this->sharedNode;
216		}
217		} else {
218	17	$resource = $this->getResourceFromFolderAndId($this->userFolder, $resourceId);
		0 ignored issues – show Bug introduced 2016-06-18 16:05 UTC by Report Bug Copy Issue Report It seems like `$this->userFolder` can be `null`; however, `getResourceFromFolderAndId()` does not accept `null`, maybe add an additional type check? Unless you are absolutely sure that the expression can never be null because of other conditions, we strongly recommend to add an additional type check to your code: /** @return stdClass\|null */ function mayReturnNull() { } function doesNotAcceptNull(stdClass $x) { } // With potential error. function withoutCheck() { $x = mayReturnNull(); doesNotAcceptNull($x); // Potential error here. } // Safe - Alternative 1 function withCheck1() { $x = mayReturnNull(); if ( ! $x instanceof stdClass) { throw new \LogicException('$x must be defined.'); } doesNotAcceptNull($x); } // Safe - Alternative 2 function withCheck2() { $x = mayReturnNull(); if ($x instanceof stdClass) { doesNotAcceptNull($x); } } Loading history...
219		}
220
221	34	return $resource;
222		}
223
224		/**
225		* Returns the shared node
226		*
227		* @return File\|Folder
		0 ignored issues – show Documentation introduced 2016-02-21 16:24 UTC by Report Bug Copy Issue Report Should the return type not be `Node`? This check compares the return type specified in the `@return` annotation of a function or method doc comment with the types returned by the function and raises an issue if they mismatch. Loading history...
228		*/
229	8	public function getSharedNode() {
230	8	return $this->getResourceFromId($this->sharedNodeId);
231		}
232
233		/**
234		* Returns the virtual root where the user lands after logging in or when following a link
235		*
236		* @return Folder
237		* @throws NotFoundEnvException
238		*/
239	14	public function getVirtualRootFolder() {
240	14	$rootFolder = $this->userFolder;
241	14	if ($this->isTokenBasedEnv()) {
242	4	$node = $this->getSharedNode();
243	4	$nodeType = $node->getType();
244	4	if ($nodeType === 'dir') {
245	3	$rootFolder = $node;
246		} else {
247	1	throw new NotFoundEnvException($node->getPath() . ' is not a folder');
248		}
249		}
250
251	13	return $rootFolder;
252		}
253
254		/**
255		* Returns the userId of the currently logged-in user or the sharer
256		*
257		* @return string
258		*/
259	9	public function getUserId() {
260	9	return $this->userId;
261		}
262
263		/**
264		* Returns the name of the user sharing files publicly
265		*
266		* @return string
267		* @throws NotFoundEnvException
268		*/
269	2	public function getDisplayName() {
270	2	$user = null;
271	2	$userId = $this->userId;
272
273	2	if (isset($userId)) {
274	1	$user = $this->userManager->get($userId);
275		}
276	2	if ($user === null) {
277	1	throw new NotFoundEnvException('Could not find user');
278		}
279
280	1	return $user->getDisplayName();
281		}
282
283		/**
284		* Returns the name of shared folder
285		*
286		* @return string
287		*/
288	1	public function getSharedFolderName() {
289	1	return trim($this->folderName, '//');
290		}
291
292		/**
293		* Returns the password for the share, if there is one
294		*
295		* @return string\|null
296		*/
297	1	public function getSharePassword() {
298	1	return $this->sharePassword;
299		}
300
301		/**
302		* Returns the path which goes from the file, up to the user folder, based on a node:
303		* parent_folder/current_folder/my_file
304		*
305		* This is used for the preview system, which needs a full path
306		*
307		* getPath() on the file produces a path like:
308		* '/userId/files/my_folder/my_sub_folder/my_file'
309		*
310		* So we substract the path to the folder, giving us a relative path
311		* 'my_folder/my_sub_folder/my_file'
312		*
313		* @param Node $file
314		*
315		* @return string
316		*/
317	9	public function getPathFromUserFolder($file) {
318	9	$path = $file->getPath();
319
320	9	return $this->getRelativePath($path);
321		}
322
323		/**
324		* Returns the path which goes from the file, up to the root folder of the Gallery:
325		* current_folder/my_file
326		*
327		* That root folder changes when folders are shared publicly
328		*
329		* @param File\|Folder\|Node $node
330		*
331		* @return string
332		*/
333	10	public function getPathFromVirtualRoot($node) {
334	10	$path = $node->getPath();
335	10	$nodeType = $node->getType();
336
337		// Needed because fromRootToFolder always ends with a slash
338	10	if ($nodeType === 'dir') {
339	8	$path .= '/';
340		}
341
342	10	$path = str_replace($this->fromRootToFolder, '', $path);
343	10	$path = rtrim($path, '/');
344
345	10	return $path;
346		}
347
348		/**
349		* Returns the resource found in a specific folder and identified by the given ID
350		*
351		* @param Folder $folder
352		* @param int $resourceId
353		*
354		* @return Node
355		* @throws NotFoundEnvException
356		*/
357	33	private function getResourceFromFolderAndId($folder, $resourceId) {
358	33	$resourcesArray = $folder->getById($resourceId);
359
360	33	if ($resourcesArray[0] === null) {
361	3	throw new NotFoundEnvException('Could not locate node linked to ID: ' . $resourceId);
362		}
363
364	30	return $resourcesArray[0];
365		}
366
367		/**
368		* Returns the path from the shared folder to the root folder in the original
369		* owner's filesystem: /userId/files/parent_folder/shared_folder
370		*
371		* This cannot be calculated with paths and IDs, the share's file source is required
372		*
373		* @param string $fileSource
374		*
375		* @return string
376		*/
377	21	private function buildFromRootToFolder($fileSource) {
378	21	$resource = $this->getResourceFromId($fileSource);
379	21	$fromRootToFolder = $resource->getPath() . '/';
380
381	21	return $fromRootToFolder;
382		}
383
384		/**
385		* Returns the path which goes from the file, up to the user folder, based on a path:
386		* parent_folder/current_folder/my_file
387		*
388		* getPath() on the file produces a path like:
389		* '/userId/files/my_folder/my_sub_folder/my_file'
390		*
391		* So we substract the path to the user folder, giving us a relative path
392		* 'my_folder/my_sub_folder'
393		*
394		* @param string $fullPath
395		*
396		* @return string
397		*/
398	17	private function getRelativePath($fullPath) {
399	17	$folderPath = $this->userFolder->getPath() . '/';
400	17	$origShareRelPath = str_replace($folderPath, '', $fullPath);
401
402	17	return $origShareRelPath;
403		}
404
405		}
406

interfasys / galleryplus

Pull Request — master (#46)

Environment::getPathFromUserFolder() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like