FileSystemService::findAllFolders() - Code Metrics - Inspection of "Refactoring: Extract file/folder-related functions..." - owncloud/music - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 6670ca...130e3c )

by Pauli

created 2025-10-29 21:41 UTC

FileSystemService::findAllFolders() A

↳ Parent: FileSystemService

Complexity

Conditions	1
Paths	1

Size

Total Lines	8
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	5
nc	1
nop	2
dl	0
loc	8
rs	10
c	1
b	0
f	0

<?php declare(strict_types=1);

/**
 * ownCloud - Music app
 *
 * This file is licensed under the Affero General Public License version 3 or
 * later. See the COPYING file.
 *
 * @author Pauli Järvinen <[email protected]>
 * @copyright Pauli Järvinen 2025
 */

namespace OCA\Music\Service;

use OCA\Music\AppFramework\Core\Logger;
use OCA\Music\Db\Track;
use OCA\Music\Db\TrackMapper;
use OCA\Music\Utility\ArrayUtil;

use OCP\AppFramework\Db\DoesNotExistException;
use OCP\Files\FileInfo;
use OCP\Files\Folder;

class FileSystemService {

	private TrackMapper $mapper;
	private Logger $logger;

	public function __construct(TrackMapper $trackMapper, Logger $logger) {
		$this->mapper = $trackMapper;
		$this->logger = $logger;
	}

	/**
	 * Returns all folders of the user containing indexed tracks, along with the contained track IDs
	 * @return array of entries like {id: int, name: string, parent: ?int, trackIds: int[]}
	 */
	public function findAllFolders(string $userId, Folder $musicFolder) : array {
		// All tracks of the user, grouped by their parent folders. Some of the parent folders
		// may be owned by other users and are invisible to this user (in case of shared files).
		$trackIdsByFolder = $this->mapper->findTrackAndFolderIds($userId);
		$foldersLut = $this->getFoldersLut($trackIdsByFolder, $userId, $musicFolder);
		return \array_map(
			fn($id, $folderInfo) => \array_merge($folderInfo, ['id' => $id]),
			\array_keys($foldersLut), $foldersLut
		);
	}

	/**
	 * @param Track[] $tracks (in|out)
	 */
	public function injectFolderPathsToTracks(array $tracks, string $userId, Folder $musicFolder) : void {
		$folderIds = \array_map(fn($t) => $t->getFolderId(), $tracks);
		$folderIds = \array_unique($folderIds);
		$trackIdsByFolder = \array_fill_keys($folderIds, []); // track IDs are not actually used here so we can use empty arrays

		$foldersLut = $this->getFoldersLut($trackIdsByFolder, $userId, $musicFolder);

		// recursive helper to get folder's path and cache all parent paths on the way
		$getFolderPath = function(int $id, array &$foldersLut) use (&$getFolderPath) : string {
			// setup the path if not cached already
			if (!isset($foldersLut[$id]['path'])) {
				$parentId = $foldersLut[$id]['parent'];
				if ($parentId === null) {
					$foldersLut[$id]['path'] = '';
				} else {
					$foldersLut[$id]['path'] = $getFolderPath($parentId, $foldersLut) . '/' . $foldersLut[$id]['name'];
				}
			}
			return $foldersLut[$id]['path'];
		};

		foreach ($tracks as $track) {
			$track->setFolderPath($getFolderPath($track->getFolderId(), $foldersLut));
		}
	}

	/**
	 * Find all direct and indirect sub folders of the given folder. The result will include also the start folder.
	 * NOTE: This does not return the mounted or shared folders even in case the $folderId points to user home directory.
	 * @return int[]
	 */
	public function findAllDescendantFolders(int $folderId) : array {
		$descendants = [];
		$foldersToProcess = [$folderId];

		while(\count($foldersToProcess)) {
			$descendants = \array_merge($descendants, $foldersToProcess);
			$foldersToProcess = $this->mapper->findSubFolderIds($foldersToProcess);
		}

		return $descendants;
	}

	/**
	 * Get folder info lookup table, for the given tracks. The table will contain all the predecessor folders
	 * between those tracks and the root music folder (inclusive).
	 * 
	 * @param array $trackIdsByFolder Keys are folder IDs and values are arrays of track IDs
	 * @return array Keys are folder IDs and values are arrays like ['name' : string, 'parent' : int, 'trackIds' : int[]]
	 */
	private function getFoldersLut(array $trackIdsByFolder, string $userId, Folder $musicFolder) : array {
		// Get the folder names and direct parent folder IDs directly from the DB.
		// This is significantly more efficient than using the Files API because we need to
		// run only single DB query instead of one per folder.
		$folderNamesAndParents = $this->mapper->findNodeNamesAndParents(\array_keys($trackIdsByFolder));

		// Compile the look-up-table entries from our two intermediary arrays
		$lut = [];
		foreach ($trackIdsByFolder as $folderId => $trackIds) {
			// $folderId is not found from $folderNamesAndParents if it's a dummy ID created as placeholder on a malformed playlist
			$nameAndParent = $folderNamesAndParents[$folderId] ?? ['name' => '', 'parent' => null];
			$lut[$folderId] = \array_merge($nameAndParent, ['trackIds' => $trackIds]);
		}

		// the root folder should have null parent; here we also ensure it's included
		$rootFolderId = $musicFolder->getId();
		$rootTracks = $lut[$rootFolderId]['trackIds'] ?? [];
		$lut[$rootFolderId] = ['name' => '', 'parent' => null, 'trackIds' => $rootTracks];

		// External mounts and shared files/folders need some special handling. But if there are any, they should be found
		// right under the top-level folder.
		$this->addExternalMountsToFoldersLut($lut, $userId, $musicFolder);

		// Add the intermediate folders which do not directly contain any tracks
		$this->addMissingParentsToFoldersLut($lut);

		return $lut;
	}

	/**
	 * Add externally mounted folders and shared files and folders to the folder LUT if there are any under the $musicFolder
	 * 
	 * @param array $lut (in|out) Keys are folder IDs and values are arrays like ['name' : string, 'parent' : int, 'trackIds' : int[]]
	 */
	private function addExternalMountsToFoldersLut(array &$lut, string $userId, Folder $musicFolder) : void {
		$nodesUnderRoot = $musicFolder->getDirectoryListing();
		$homeStorageId = $musicFolder->getStorage()->getId();
		$rootFolderId = $musicFolder->getId();

		foreach ($nodesUnderRoot as $node) {
			if ($node->getStorage()->getId() != $homeStorageId) {
				// shared file/folder or external mount
				if ($node->getType() == FileInfo::TYPE_FOLDER) {
					// The mount point folders are always included in the result. At this time, we don't know if
					// they actually contain any tracks, unless they have direct track children. If there are direct tracks,
					// then the parent ID is incorrectly set and needs to be overridden.
					$trackIds = $lut[$node->getId()]['trackIds'] ?? [];
					$lut[$node->getId()] = ['name' => $node->getName(), 'parent' => $rootFolderId, 'trackIds' => $trackIds];

				} else if ($node->getMimePart() == 'audio') {
					// shared audio file, check if it's actually a scanned file in our library
					try {
						$sharedTrack = $this->mapper->findByFileId($node->getId(), $userId);
						$trackId = $sharedTrack->getId();
						foreach ($lut as $folderId => &$entry) {
							$trackIdIdx = \array_search($trackId, $entry['trackIds']);
							if ($trackIdIdx !== false) {
								// move the track from it's actual parent (in other user's storage) to our root
								unset($entry['trackIds'][$trackIdIdx]);
								$lut[$rootFolderId]['trackIds'][] = $trackId;

								// remove the former parent folder if it has no more tracks and it's not one of the mount point folders
								if (\count($entry['trackIds']) == 0 && empty(\array_filter($nodesUnderRoot, fn($n) => $n->getId() == $folderId))) {
									unset($lut[$folderId]);
								}
								break;
							}
						}
					} catch (DoesNotExistException $e) {
						// ignore
					}
				}
			}
		}
	}

	/**
	 * Add any missing intermediary folder to the LUT. For this function to work correctly, the pre-condition is that the LUT contains
	 * a root node which is predecessor of all other contained nodes and has 'parent' set as null.
	 * 
	 * @param array $lut (in|out) Keys are folder IDs and values are arrays like ['name' : string, 'parent' : int, 'trackIds' : int[]]
	 */
	private function addMissingParentsToFoldersLut(array &$lut) : void {
		$foldersToProcess = $lut;

		while (\count($foldersToProcess)) {
			$parentIds = \array_unique(\array_column($foldersToProcess, 'parent'));
			// do not process root even if it's included in $foldersToProcess
			$parentIds = \array_filter($parentIds, fn($i) => $i !== null);
			$parentIds = ArrayUtil::diff($parentIds, \array_keys($lut));
			$parentFolders = $this->mapper->findNodeNamesAndParents($parentIds);

			$foldersToProcess = [];
			foreach ($parentFolders as $folderId => $nameAndParent) {
				$foldersToProcess[] = $lut[$folderId] = \array_merge($nameAndParent, ['trackIds' => []]);
			}
		}
	}

}

1			<?php declare(strict_types=1);
2
3			/**
4			* ownCloud - Music app
5			*
6			* This file is licensed under the Affero General Public License version 3 or
7			* later. See the COPYING file.
8			*
9			* @author Pauli Järvinen <[email protected]>
10			* @copyright Pauli Järvinen 2025
11			*/
12
13			namespace OCA\Music\Service;
14
15			use OCA\Music\AppFramework\Core\Logger;
16			use OCA\Music\Db\Track;
17			use OCA\Music\Db\TrackMapper;
18			use OCA\Music\Utility\ArrayUtil;
19
20			use OCP\AppFramework\Db\DoesNotExistException;
21			use OCP\Files\FileInfo;
22			use OCP\Files\Folder;
23
24			class FileSystemService {
25
26			private TrackMapper $mapper;
27			private Logger $logger;
28
29			public function __construct(TrackMapper $trackMapper, Logger $logger) {
30			$this->mapper = $trackMapper;
31			$this->logger = $logger;
32			}
33
34			/**
35			* Returns all folders of the user containing indexed tracks, along with the contained track IDs
36			* @return array of entries like {id: int, name: string, parent: ?int, trackIds: int[]}
37			*/
38			public function findAllFolders(string $userId, Folder $musicFolder) : array {
39			// All tracks of the user, grouped by their parent folders. Some of the parent folders
40			// may be owned by other users and are invisible to this user (in case of shared files).
41			$trackIdsByFolder = $this->mapper->findTrackAndFolderIds($userId);
42			$foldersLut = $this->getFoldersLut($trackIdsByFolder, $userId, $musicFolder);
43			return \array_map(
44			fn($id, $folderInfo) => \array_merge($folderInfo, ['id' => $id]),
45			\array_keys($foldersLut), $foldersLut
46			);
47			}
48
49			/**
50			* @param Track[] $tracks (in\|out)
51			*/
52			public function injectFolderPathsToTracks(array $tracks, string $userId, Folder $musicFolder) : void {
53			$folderIds = \array_map(fn($t) => $t->getFolderId(), $tracks);
54			$folderIds = \array_unique($folderIds);
55			$trackIdsByFolder = \array_fill_keys($folderIds, []); // track IDs are not actually used here so we can use empty arrays
56
57			$foldersLut = $this->getFoldersLut($trackIdsByFolder, $userId, $musicFolder);
58
59			// recursive helper to get folder's path and cache all parent paths on the way
60			$getFolderPath = function(int $id, array &$foldersLut) use (&$getFolderPath) : string {
61			// setup the path if not cached already
62			if (!isset($foldersLut[$id]['path'])) {
63			$parentId = $foldersLut[$id]['parent'];
64			if ($parentId === null) {
65			$foldersLut[$id]['path'] = '';
66			} else {
67			$foldersLut[$id]['path'] = $getFolderPath($parentId, $foldersLut) . '/' . $foldersLut[$id]['name'];
68			}
69			}
70			return $foldersLut[$id]['path'];
71			};
72
73			foreach ($tracks as $track) {
74			$track->setFolderPath($getFolderPath($track->getFolderId(), $foldersLut));
75			}
76			}
77
78			/**
79			* Find all direct and indirect sub folders of the given folder. The result will include also the start folder.
80			* NOTE: This does not return the mounted or shared folders even in case the $folderId points to user home directory.
81			* @return int[]
82			*/
83			public function findAllDescendantFolders(int $folderId) : array {
84			$descendants = [];
85			$foldersToProcess = [$folderId];
86
87			while(\count($foldersToProcess)) {
88			$descendants = \array_merge($descendants, $foldersToProcess);
89			$foldersToProcess = $this->mapper->findSubFolderIds($foldersToProcess);
90			}
91
92			return $descendants;
93			}
94
95			/**
96			* Get folder info lookup table, for the given tracks. The table will contain all the predecessor folders
97			* between those tracks and the root music folder (inclusive).
98			*
99			* @param array $trackIdsByFolder Keys are folder IDs and values are arrays of track IDs
100			* @return array Keys are folder IDs and values are arrays like ['name' : string, 'parent' : int, 'trackIds' : int[]]
101			*/
102			private function getFoldersLut(array $trackIdsByFolder, string $userId, Folder $musicFolder) : array {
103			// Get the folder names and direct parent folder IDs directly from the DB.
104			// This is significantly more efficient than using the Files API because we need to
105			// run only single DB query instead of one per folder.
106			$folderNamesAndParents = $this->mapper->findNodeNamesAndParents(\array_keys($trackIdsByFolder));
107
108			// Compile the look-up-table entries from our two intermediary arrays
109			$lut = [];
110			foreach ($trackIdsByFolder as $folderId => $trackIds) {
111			// $folderId is not found from $folderNamesAndParents if it's a dummy ID created as placeholder on a malformed playlist
112			$nameAndParent = $folderNamesAndParents[$folderId] ?? ['name' => '', 'parent' => null];
113			$lut[$folderId] = \array_merge($nameAndParent, ['trackIds' => $trackIds]);
114			}
115
116			// the root folder should have null parent; here we also ensure it's included
117			$rootFolderId = $musicFolder->getId();
118			$rootTracks = $lut[$rootFolderId]['trackIds'] ?? [];
119			$lut[$rootFolderId] = ['name' => '', 'parent' => null, 'trackIds' => $rootTracks];
120
121			// External mounts and shared files/folders need some special handling. But if there are any, they should be found
122			// right under the top-level folder.
123			$this->addExternalMountsToFoldersLut($lut, $userId, $musicFolder);
124
125			// Add the intermediate folders which do not directly contain any tracks
126			$this->addMissingParentsToFoldersLut($lut);
127
128			return $lut;
129			}
130
131			/**
132			* Add externally mounted folders and shared files and folders to the folder LUT if there are any under the $musicFolder
133			*
134			* @param array $lut (in\|out) Keys are folder IDs and values are arrays like ['name' : string, 'parent' : int, 'trackIds' : int[]]
135			*/
136			private function addExternalMountsToFoldersLut(array &$lut, string $userId, Folder $musicFolder) : void {
137			$nodesUnderRoot = $musicFolder->getDirectoryListing();
138			$homeStorageId = $musicFolder->getStorage()->getId();
139			$rootFolderId = $musicFolder->getId();
140
141			foreach ($nodesUnderRoot as $node) {
142			if ($node->getStorage()->getId() != $homeStorageId) {
143			// shared file/folder or external mount
144			if ($node->getType() == FileInfo::TYPE_FOLDER) {
145			// The mount point folders are always included in the result. At this time, we don't know if
146			// they actually contain any tracks, unless they have direct track children. If there are direct tracks,
147			// then the parent ID is incorrectly set and needs to be overridden.
148			$trackIds = $lut[$node->getId()]['trackIds'] ?? [];
149			$lut[$node->getId()] = ['name' => $node->getName(), 'parent' => $rootFolderId, 'trackIds' => $trackIds];
150
151			} else if ($node->getMimePart() == 'audio') {
152			// shared audio file, check if it's actually a scanned file in our library
153			try {
154			$sharedTrack = $this->mapper->findByFileId($node->getId(), $userId);
155			$trackId = $sharedTrack->getId();
156			foreach ($lut as $folderId => &$entry) {
157			$trackIdIdx = \array_search($trackId, $entry['trackIds']);
158			if ($trackIdIdx !== false) {
159			// move the track from it's actual parent (in other user's storage) to our root
160			unset($entry['trackIds'][$trackIdIdx]);
161			$lut[$rootFolderId]['trackIds'][] = $trackId;
162
163			// remove the former parent folder if it has no more tracks and it's not one of the mount point folders
164			if (\count($entry['trackIds']) == 0 && empty(\array_filter($nodesUnderRoot, fn($n) => $n->getId() == $folderId))) {
165			unset($lut[$folderId]);
166			}
167			break;
168			}
169			}
170			} catch (DoesNotExistException $e) {
171			// ignore
172			}
173			}
174			}
175			}
176			}
177
178			/**
179			* Add any missing intermediary folder to the LUT. For this function to work correctly, the pre-condition is that the LUT contains
180			* a root node which is predecessor of all other contained nodes and has 'parent' set as null.
181			*
182			* @param array $lut (in\|out) Keys are folder IDs and values are arrays like ['name' : string, 'parent' : int, 'trackIds' : int[]]
183			*/
184			private function addMissingParentsToFoldersLut(array &$lut) : void {
185			$foldersToProcess = $lut;
186
187			while (\count($foldersToProcess)) {
188			$parentIds = \array_unique(\array_column($foldersToProcess, 'parent'));
189			// do not process root even if it's included in $foldersToProcess
190			$parentIds = \array_filter($parentIds, fn($i) => $i !== null);
191			$parentIds = ArrayUtil::diff($parentIds, \array_keys($lut));
192			$parentFolders = $this->mapper->findNodeNamesAndParents($parentIds);
193
194			$foldersToProcess = [];
195			foreach ($parentFolders as $folderId => $nameAndParent) {
196			$foldersToProcess[] = $lut[$folderId] = \array_merge($nameAndParent, ['trackIds' => []]);
197			}
198			}
199			}
200
201			}

owncloud / music

Push — master ( 6670ca...130e3c )

FileSystemService::findAllFolders() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like