PlaylistBusinessLayer::getPlaylistTrackIds() - Code Metrics - Inspection of "Merge branch 'feature/refactor_and_cleanup'" - owncloud/music - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 7b42d0...d80bc5 )

by Pauli

created 2025-06-24 13:56 UTC

PlaylistBusinessLayer::getPlaylistTrackIds() A

↳ Parent: PlaylistBusinessLayer

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?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 2016 - 2025
 */

namespace OCA\Music\BusinessLayer;

use OCA\Music\AppFramework\BusinessLayer\BusinessLayer;
use OCA\Music\AppFramework\Core\Logger;

use OCA\Music\Db\MatchMode;
use OCA\Music\Db\Playlist;
use OCA\Music\Db\PlaylistMapper;
use OCA\Music\Db\SortBy;
use OCA\Music\Db\Track;
use OCA\Music\Db\TrackMapper;
use OCA\Music\Utility\ArrayUtil;
use OCA\Music\Utility\Random;
use OCA\Music\Utility\StringUtil;

/**
 * Base class functions with actually used inherited types to help IDE and Scrutinizer:
 * @method Playlist find(int $playlistId, string $userId)
 * @method Playlist[] findAll(string $userId, int $sortBy=SortBy::Name, ?int $limit=null, ?int $offset=null)
 * @method Playlist[] findAllByName(string $name, string $userId, int $matchMode=MatchMode::Exact, ?int $limit=null, ?int $offset=null)
 * @property PlaylistMapper $mapper
 * @phpstan-extends BusinessLayer<Playlist>
 */
class PlaylistBusinessLayer extends BusinessLayer {
	private TrackMapper $trackMapper;
	private Logger $logger;

	public function __construct(
			PlaylistMapper $playlistMapper,
			TrackMapper $trackMapper,
			Logger $logger) {
		parent::__construct($playlistMapper);
		$this->trackMapper = $trackMapper;
		$this->logger = $logger;
	}

	public function setTracks(array $trackIds, int $playlistId, string $userId) : Playlist {
		$playlist = $this->find($playlistId, $userId);
		$playlist->setTrackIdsFromArray($trackIds);
		$this->mapper->update($playlist);
		return $playlist;
	}

	public function addTracks(array $trackIds, int $playlistId, string $userId, ?int $insertIndex = null) : Playlist {
		$playlist = $this->find($playlistId, $userId);
		$allTrackIds = $playlist->getTrackIdsAsArray();
		if ($insertIndex === null) {
			$allTrackIds = \array_merge($allTrackIds, $trackIds);
		} else {
			\array_splice($allTrackIds, $insertIndex, 0, $trackIds);
		}
		$playlist->setTrackIdsFromArray($allTrackIds);
		$this->mapper->update($playlist);
		return $playlist;
	}

	public function removeTracks(array $trackIndices, int $playlistId, string $userId) : Playlist {
		$playlist = $this->find($playlistId, $userId);
		$trackIds = $playlist->getTrackIdsAsArray();
		$trackIds = \array_diff_key($trackIds, \array_flip($trackIndices));
		$playlist->setTrackIdsFromArray($trackIds);
		$this->mapper->update($playlist);
		return $playlist;
	}

	public function removeAllTracks(int $playlistId, string $userId) : Playlist {
		$playlist = $this->find($playlistId, $userId);
		$playlist->setTrackIdsFromArray([]);
		$this->mapper->update($playlist);
		return $playlist;
	}

	public function moveTrack(int $fromIndex, int $toIndex, int $playlistId, string $userId) : Playlist {
		$playlist = $this->find($playlistId, $userId);
		$trackIds = $playlist->getTrackIdsAsArray();
		$movedTrack = \array_splice($trackIds, $fromIndex, 1);
		\array_splice($trackIds, $toIndex, 0, $movedTrack);
		$playlist->setTrackIdsFromArray($trackIds);
		$this->mapper->update($playlist);
		return $playlist;
	}

	public function create(string $name, string $userId) : Playlist {
		$playlist = new Playlist();
		$playlist->setName(StringUtil::truncate($name, 256)); // some DB setups can't truncate automatically to column max size
		$playlist->setUserId($userId);

		return $this->mapper->insert($playlist);
	}

	public function rename(string $name, int $playlistId, string $userId) : Playlist {
		$playlist = $this->find($playlistId, $userId);
		$playlist->setName(StringUtil::truncate($name, 256)); // some DB setups can't truncate automatically to column max size
		$this->mapper->update($playlist);
		return $playlist;
	}

	public function setComment(string $comment, int $playlistId, string $userId) : Playlist {
		$playlist = $this->find($playlistId, $userId);
		$playlist->setComment(StringUtil::truncate($comment, 256)); // some DB setups can't truncate automatically to column max size
		$this->mapper->update($playlist);
		return $playlist;
	}

	/**
	 * removes tracks from all available playlists
	 * @param int[] $trackIds array of all track IDs to remove
	 */
	public function removeTracksFromAllLists(array $trackIds) : void {
		foreach ($trackIds as $trackId) {
			$affectedLists = $this->mapper->findListsContainingTrack($trackId);

			foreach ($affectedLists as $playlist) {
				$prevTrackIds = $playlist->getTrackIdsAsArray();
				$playlist->setTrackIdsFromArray(\array_diff($prevTrackIds, [$trackId]));
				$this->mapper->update($playlist);
			}
		}
	}

	/**
	 * @return int[]
	 */
	public function getPlaylistTrackIds(int $playlistId, string $userId) : array {
		$playlist = $this->find($playlistId, $userId);
		return $playlist->getTrackIdsAsArray();
	}

	/**
	 * get list of Track objects belonging to a given playlist
	 * @return Track[]
	 */
	public function getPlaylistTracks(int $playlistId, string $userId, ?int $limit=null, ?int $offset=null) : array {
		$trackIds = $this->getPlaylistTrackIds($playlistId, $userId);

		$trackIds = \array_slice($trackIds, \intval($offset), $limit);

		$tracks = empty($trackIds) ? [] : $this->trackMapper->findById($trackIds, $userId);

		// The $tracks contains the songs in unspecified order and with no duplicates.
		// Build a new array where the tracks are in the same order as in $trackIds.
		$tracksById = ArrayUtil::createIdLookupTable($tracks);

		$playlistTracks = [];
		foreach ($trackIds as $index => $trackId) {
			$track = $tracksById[$trackId] ?? null;
			if ($track !== null) {
				// in case the same track comes up again in the list, clone the track object
				// to have different numbers on the instances
				if ($track->getNumberOnPlaylist() !== null) {
					$track = clone $track;
				}
				$track->setNumberOnPlaylist(\intval($offset) + $index + 1);
			} else {
				$this->logger->log("Invalid track ID $trackId found on playlist $playlistId", 'debug');
				$track = Track::emptyInstance();
				$track->setId($trackId);
			}
			$playlistTracks[] = $track;
		}

		return $playlistTracks;
	}

	/**
	 * get the total duration of all the tracks on a playlist
	 *
	 * @return int duration in seconds
	 */
	public function getDuration(int $playlistId, string $userId) : int {
		$trackIds = $this->getPlaylistTrackIds($playlistId, $userId);
		$durations = $this->trackMapper->getDurations($trackIds);

		// We can't simply sum up the values of $durations array, because the playlist may
		// contain duplicate entries, and those are not reflected in $durations.
		// Be also prepared to invalid playlist entries where corresponding track length does not exist.
		$sum = 0;
		foreach ($trackIds as $trackId) {
			$sum += $durations[$trackId] ?? 0;
		}

		return $sum;
	}

	/**
	 * Generate and return a playlist matching the given criteria. The playlist is not persisted.
	 *
	 * @param string|null $history One of: 'recently-played', 'not-recently-played', 'often-played', 'rarely-played', 'recently-added', 'not-recently-added'
	 * @param bool $historyStrict In the "strict" mode, there's no element of randomness when applying the history filter and e.g.
	 *             'recently-played' meas "The most recently played" instead of "Among the most recently played"
	 * @param int[] $genres Array of genre IDs
	 * @param int[] $artists Array of artist IDs
	 * @param int|null $fromYear Earliest release year to include
	 * @param int|null $toYear Latest release year to include
	 * @param string|null $favorite One of: 'track', 'album', 'artists', 'track_album_artist', null
	 * @param int $size Size of the playlist to generate, provided that there are enough matching tracks
	 * @param string $userId the name of the user
	 */
	public function generate(
			?string $history, bool $historyStrict, array $genres, array $artists,
			?int $fromYear, ?int $toYear, ?string $favorite, int $size, string $userId) : Playlist {

		$now = new \DateTime();
		$nowStr = $now->format(PlaylistMapper::SQL_DATE_FORMAT);

		$playlist = new Playlist();
		$playlist->setCreated($nowStr);
		$playlist->setUpdated($nowStr);
		$playlist->setName('Generated ' . $nowStr);
		$playlist->setUserId($userId);

		list('sortBy' => $sortBy, 'invert' => $invertSort) = self::sortRulesForHistory($history);
		$limit = ($sortBy === SortBy::None) ? null : ($historyStrict ? $size : $size * 4);

		$favoriteMask = self::favoriteMask($favorite);

		$tracks = $this->trackMapper->findAllByCriteria($genres, $artists, $fromYear, $toYear, $favoriteMask, $sortBy, $invertSort, $userId, $limit);

		if ($sortBy !== SortBy::None && !$historyStrict) {
			// When generating by non-strict history, use a pool of tracks at maximum twice the size of final list.
			// However, don't use more than half of the matching tracks unless that is required to satisfy the required list size.
			$poolSize = (int)max($size, \count($tracks) / 2);
			$tracks = \array_slice($tracks, 0, $poolSize);
		}

		// Pick the final random set of tracks
		$tracks = Random::pickItems($tracks, $size);

		$playlist->setTrackIdsFromArray(ArrayUtil::extractIds($tracks));

		return $playlist;
	}

	private static function sortRulesForHistory(?string $history) : array {
		switch ($history) {
			case 'recently-played':
				return ['sortBy' => SortBy::LastPlayed, 'invert' => false];
			case 'not-recently-played':
				return ['sortBy' => SortBy::LastPlayed, 'invert' => true];
			case 'often-played':
				return ['sortBy' => SortBy::PlayCount, 'invert' => false];
			case 'rarely-played':
				return ['sortBy' => SortBy::PlayCount, 'invert' => true];
			case 'recently-added':
				return ['sortBy' => SortBy::Newest, 'invert' => false];
			case 'not-recently-added':
				return ['sortBy' => SortBy::Newest, 'invert' => true];
			default:
				return ['sortBy' => SortBy::None, 'invert' => false];
		}
	}

	private static function favoriteMask(?string $mode) : ?int {
		switch ($mode) {
			case 'track':				return TrackMapper::FAVORITE_TRACK;
			case 'album':				return TrackMapper::FAVORITE_ALBUM;
			case 'artist':				return TrackMapper::FAVORITE_ARTIST;
			case 'track_album_artist':	return TrackMapper::FAVORITE_TRACK | TrackMapper::FAVORITE_ALBUM | TrackMapper::FAVORITE_ARTIST;
			default:					return null;
		}
	}
}


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 2016 - 2025
11			*/
12
13			namespace OCA\Music\BusinessLayer;
14
15			use OCA\Music\AppFramework\BusinessLayer\BusinessLayer;
16			use OCA\Music\AppFramework\Core\Logger;
17
18			use OCA\Music\Db\MatchMode;
19			use OCA\Music\Db\Playlist;
20			use OCA\Music\Db\PlaylistMapper;
21			use OCA\Music\Db\SortBy;
22			use OCA\Music\Db\Track;
23			use OCA\Music\Db\TrackMapper;
24			use OCA\Music\Utility\ArrayUtil;
25			use OCA\Music\Utility\Random;
26			use OCA\Music\Utility\StringUtil;
27
28			/**
29			* Base class functions with actually used inherited types to help IDE and Scrutinizer:
30			* @method Playlist find(int $playlistId, string $userId)
31			* @method Playlist[] findAll(string $userId, int $sortBy=SortBy::Name, ?int $limit=null, ?int $offset=null)
32			* @method Playlist[] findAllByName(string $name, string $userId, int $matchMode=MatchMode::Exact, ?int $limit=null, ?int $offset=null)
33			* @property PlaylistMapper $mapper
34			* @phpstan-extends BusinessLayer<Playlist>
35			*/
36			class PlaylistBusinessLayer extends BusinessLayer {
37			private TrackMapper $trackMapper;
38			private Logger $logger;
39
40			public function __construct(
41			PlaylistMapper $playlistMapper,
42			TrackMapper $trackMapper,
43			Logger $logger) {
44			parent::__construct($playlistMapper);
45			$this->trackMapper = $trackMapper;
46			$this->logger = $logger;
47			}
48
49			public function setTracks(array $trackIds, int $playlistId, string $userId) : Playlist {
50			$playlist = $this->find($playlistId, $userId);
51			$playlist->setTrackIdsFromArray($trackIds);
52			$this->mapper->update($playlist);
53			return $playlist;
54			}
55
56			public function addTracks(array $trackIds, int $playlistId, string $userId, ?int $insertIndex = null) : Playlist {
57			$playlist = $this->find($playlistId, $userId);
58			$allTrackIds = $playlist->getTrackIdsAsArray();
59			if ($insertIndex === null) {
60			$allTrackIds = \array_merge($allTrackIds, $trackIds);
61			} else {
62			\array_splice($allTrackIds, $insertIndex, 0, $trackIds);
63			}
64			$playlist->setTrackIdsFromArray($allTrackIds);
65			$this->mapper->update($playlist);
66			return $playlist;
67			}
68
69			public function removeTracks(array $trackIndices, int $playlistId, string $userId) : Playlist {
70			$playlist = $this->find($playlistId, $userId);
71			$trackIds = $playlist->getTrackIdsAsArray();
72			$trackIds = \array_diff_key($trackIds, \array_flip($trackIndices));
73			$playlist->setTrackIdsFromArray($trackIds);
74			$this->mapper->update($playlist);
75			return $playlist;
76			}
77
78			public function removeAllTracks(int $playlistId, string $userId) : Playlist {
79			$playlist = $this->find($playlistId, $userId);
80			$playlist->setTrackIdsFromArray([]);
81			$this->mapper->update($playlist);
82			return $playlist;
83			}
84
85			public function moveTrack(int $fromIndex, int $toIndex, int $playlistId, string $userId) : Playlist {
86			$playlist = $this->find($playlistId, $userId);
87			$trackIds = $playlist->getTrackIdsAsArray();
88			$movedTrack = \array_splice($trackIds, $fromIndex, 1);
89			\array_splice($trackIds, $toIndex, 0, $movedTrack);
90			$playlist->setTrackIdsFromArray($trackIds);
91			$this->mapper->update($playlist);
92			return $playlist;
93			}
94
95			public function create(string $name, string $userId) : Playlist {
96			$playlist = new Playlist();
97			$playlist->setName(StringUtil::truncate($name, 256)); // some DB setups can't truncate automatically to column max size
98			$playlist->setUserId($userId);
99
100			return $this->mapper->insert($playlist);
101			}
102
103			public function rename(string $name, int $playlistId, string $userId) : Playlist {
104			$playlist = $this->find($playlistId, $userId);
105			$playlist->setName(StringUtil::truncate($name, 256)); // some DB setups can't truncate automatically to column max size
106			$this->mapper->update($playlist);
107			return $playlist;
108			}
109
110			public function setComment(string $comment, int $playlistId, string $userId) : Playlist {
111			$playlist = $this->find($playlistId, $userId);
112			$playlist->setComment(StringUtil::truncate($comment, 256)); // some DB setups can't truncate automatically to column max size
113			$this->mapper->update($playlist);
114			return $playlist;
115			}
116
117			/**
118			* removes tracks from all available playlists
119			* @param int[] $trackIds array of all track IDs to remove
120			*/
121			public function removeTracksFromAllLists(array $trackIds) : void {
122			foreach ($trackIds as $trackId) {
123			$affectedLists = $this->mapper->findListsContainingTrack($trackId);
124
125			foreach ($affectedLists as $playlist) {
126			$prevTrackIds = $playlist->getTrackIdsAsArray();
127			$playlist->setTrackIdsFromArray(\array_diff($prevTrackIds, [$trackId]));
128			$this->mapper->update($playlist);
129			}
130			}
131			}
132
133			/**
134			* @return int[]
135			*/
136			public function getPlaylistTrackIds(int $playlistId, string $userId) : array {
137			$playlist = $this->find($playlistId, $userId);
138			return $playlist->getTrackIdsAsArray();
139			}
140
141			/**
142			* get list of Track objects belonging to a given playlist
143			* @return Track[]
144			*/
145			public function getPlaylistTracks(int $playlistId, string $userId, ?int $limit=null, ?int $offset=null) : array {
146			$trackIds = $this->getPlaylistTrackIds($playlistId, $userId);
147
148			$trackIds = \array_slice($trackIds, \intval($offset), $limit);
149
150			$tracks = empty($trackIds) ? [] : $this->trackMapper->findById($trackIds, $userId);
151
152			// The $tracks contains the songs in unspecified order and with no duplicates.
153			// Build a new array where the tracks are in the same order as in $trackIds.
154			$tracksById = ArrayUtil::createIdLookupTable($tracks);
155
156			$playlistTracks = [];
157			foreach ($trackIds as $index => $trackId) {
158			$track = $tracksById[$trackId] ?? null;
159			if ($track !== null) {
160			// in case the same track comes up again in the list, clone the track object
161			// to have different numbers on the instances
162			if ($track->getNumberOnPlaylist() !== null) {
163			$track = clone $track;
164			}
165			$track->setNumberOnPlaylist(\intval($offset) + $index + 1);
166			} else {
167			$this->logger->log("Invalid track ID $trackId found on playlist $playlistId", 'debug');
168			$track = Track::emptyInstance();
169			$track->setId($trackId);
170			}
171			$playlistTracks[] = $track;
172			}
173
174			return $playlistTracks;
175			}
176
177			/**
178			* get the total duration of all the tracks on a playlist
179			*
180			* @return int duration in seconds
181			*/
182			public function getDuration(int $playlistId, string $userId) : int {
183			$trackIds = $this->getPlaylistTrackIds($playlistId, $userId);
184			$durations = $this->trackMapper->getDurations($trackIds);
185
186			// We can't simply sum up the values of $durations array, because the playlist may
187			// contain duplicate entries, and those are not reflected in $durations.
188			// Be also prepared to invalid playlist entries where corresponding track length does not exist.
189			$sum = 0;
190			foreach ($trackIds as $trackId) {
191			$sum += $durations[$trackId] ?? 0;
192			}
193
194			return $sum;
195			}
196
197			/**
198			* Generate and return a playlist matching the given criteria. The playlist is not persisted.
199			*
200			* @param string\|null $history One of: 'recently-played', 'not-recently-played', 'often-played', 'rarely-played', 'recently-added', 'not-recently-added'
201			* @param bool $historyStrict In the "strict" mode, there's no element of randomness when applying the history filter and e.g.
202			* 'recently-played' meas "The most recently played" instead of "Among the most recently played"
203			* @param int[] $genres Array of genre IDs
204			* @param int[] $artists Array of artist IDs
205			* @param int\|null $fromYear Earliest release year to include
206			* @param int\|null $toYear Latest release year to include
207			* @param string\|null $favorite One of: 'track', 'album', 'artists', 'track_album_artist', null
208			* @param int $size Size of the playlist to generate, provided that there are enough matching tracks
209			* @param string $userId the name of the user
210			*/
211			public function generate(
212			?string $history, bool $historyStrict, array $genres, array $artists,
213			?int $fromYear, ?int $toYear, ?string $favorite, int $size, string $userId) : Playlist {
214
215			$now = new \DateTime();
216			$nowStr = $now->format(PlaylistMapper::SQL_DATE_FORMAT);
217
218			$playlist = new Playlist();
219			$playlist->setCreated($nowStr);
220			$playlist->setUpdated($nowStr);
221			$playlist->setName('Generated ' . $nowStr);
222			$playlist->setUserId($userId);
223
224			list('sortBy' => $sortBy, 'invert' => $invertSort) = self::sortRulesForHistory($history);
225			$limit = ($sortBy === SortBy::None) ? null : ($historyStrict ? $size : $size * 4);
226
227			$favoriteMask = self::favoriteMask($favorite);
228
229			$tracks = $this->trackMapper->findAllByCriteria($genres, $artists, $fromYear, $toYear, $favoriteMask, $sortBy, $invertSort, $userId, $limit);
230
231			if ($sortBy !== SortBy::None && !$historyStrict) {
232			// When generating by non-strict history, use a pool of tracks at maximum twice the size of final list.
233			// However, don't use more than half of the matching tracks unless that is required to satisfy the required list size.
234			$poolSize = (int)max($size, \count($tracks) / 2);
235			$tracks = \array_slice($tracks, 0, $poolSize);
236			}
237
238			// Pick the final random set of tracks
239			$tracks = Random::pickItems($tracks, $size);
240
241			$playlist->setTrackIdsFromArray(ArrayUtil::extractIds($tracks));
242
243			return $playlist;
244			}
245
246			private static function sortRulesForHistory(?string $history) : array {
247			switch ($history) {
248			case 'recently-played':
249			return ['sortBy' => SortBy::LastPlayed, 'invert' => false];
250			case 'not-recently-played':
251			return ['sortBy' => SortBy::LastPlayed, 'invert' => true];
252			case 'often-played':
253			return ['sortBy' => SortBy::PlayCount, 'invert' => false];
254			case 'rarely-played':
255			return ['sortBy' => SortBy::PlayCount, 'invert' => true];
256			case 'recently-added':
257			return ['sortBy' => SortBy::Newest, 'invert' => false];
258			case 'not-recently-added':
259			return ['sortBy' => SortBy::Newest, 'invert' => true];
260			default:
261			return ['sortBy' => SortBy::None, 'invert' => false];
262			}
263			}
264
265			private static function favoriteMask(?string $mode) : ?int {
266			switch ($mode) {
267			case 'track': return TrackMapper::FAVORITE_TRACK;
268			case 'album': return TrackMapper::FAVORITE_ALBUM;
269			case 'artist': return TrackMapper::FAVORITE_ARTIST;
270			case 'track_album_artist': return TrackMapper::FAVORITE_TRACK \| TrackMapper::FAVORITE_ALBUM \| TrackMapper::FAVORITE_ARTIST;
271			default: return null;
272			}
273			}
274			}
275

owncloud / music

Push — master ( 7b42d0...d80bc5 )

PlaylistBusinessLayer::getPlaylistTrackIds() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like