Add support for playlist import.

michaelherger · michaelherger · commit 42504dada9af · 2020-01-19T22:48:39.000+01:00
Add simple playlist parser. Unfortunately this needs to be synchronous, thus must rely on the scanner keeping a copy in the cache.
diff --git a/API/Common.pm b/API/Common.pm
@@ -209,4 +209,20 @@ sub getUrl {
 	return 'qobuz://' . $id . '.' . $ext;
 }
 
+sub getPlaylistImage {
+	my ($class, $playlist) = @_;
+
+	my $image;
+	# pick the last image, as this is what is shown top most in the Qobuz Desktop client
+	foreach ('image_rectangle', 'images300', 'images_300', 'images150', 'images_150', 'images') {
+		if ($playlist->{$_} && ref $playlist->{$_} eq 'ARRAY') {
+			$image = $playlist->{$_}->[-1];
+			last;
+		}
+	}
+	$image =~ s/([a-z\d]{13}_)[\d]+(\.jpg)/${1}600$2/;
+
+	return $image;
+}
+
 1;
diff --git a/API/Sync.pm b/API/Sync.pm
@@ -132,6 +132,52 @@ sub getAlbum {
 	return $album;
 }
 
+sub myPlaylists {
+	my ($class, $limit) = @_;
+
+	my $playlists = $class->_get('playlist/getUserPlaylists', {
+		username => Plugins::Qobuz::API::Common->username,
+		limit    => QOBUZ_DEFAULT_LIMIT,
+		_ttl     => QOBUZ_USER_DATA_EXPIRY,
+		_use_token => 1,
+	});
+
+	return ($playlists && ref $playlists && $playlists->{playlists} && ref $playlists->{playlists}) 
+		? $playlists->{playlists}->{items}
+		: [];
+}
+
+sub getPlaylistTrackIDs {
+	my ($class, $playlistId) = @_;
+
+	my $offset = 0;
+	my @playlistTrackIds;
+
+	do {
+		my $response = $class->_get('playlist/get', {
+			playlist_id => $playlistId,
+			extra       => 'tracks',
+			limit       => QOBUZ_DEFAULT_LIMIT,
+			offset      => $offset,
+			_ttl        => QOBUZ_USER_DATA_EXPIRY,
+			_use_token  => 1,
+		});
+
+		$offset = 0;
+
+		if ($response && ref $response && $response->{tracks} && ref $response->{tracks} && $response->{tracks}->{items} && ref $response->{tracks}->{items}) {
+			my $tracks = $response->{tracks}->{items};
+			push @playlistTrackIds, map { $_->{id} } @{_precacheTracks($tracks)};
+
+			if (scalar $tracks && $response->{tracks}->{total} > $response->{tracks}->{offset} + QOBUZ_DEFAULT_LIMIT) {
+				$offset = $response->{tracks}->{offset} + QOBUZ_DEFAULT_LIMIT;
+			}
+		}
+	} while $offset && $offset < QOBUZ_USERDATA_LIMIT;
+
+	return \@playlistTrackIds;
+}
+
 sub _get {
 	my ( $class, $url, $params ) = @_;
 
diff --git a/Importer.pm b/Importer.pm
@@ -2,7 +2,7 @@ package Plugins::Qobuz::Importer;
 
 use strict;
 
-use Date::Parse qw(str2time);
+use List::Util qw(max);
 
 use Slim::Music::Import;
 use Slim::Utils::Log;
@@ -72,7 +72,7 @@ sub startScan {
 		my ($albums, $libraryMeta) = Plugins::Qobuz::API::Sync->myAlbums();
 		$progress->total(scalar @$albums + 2);
 
-		$cache->set('latest_album_update', _libraryMetaId($libraryMeta), 86400);
+		$cache->set('latest_album_update', _libraryMetaId($libraryMeta), time() + 360 * 86400);
 
 		my @albums;
 
@@ -105,6 +105,60 @@ sub startScan {
 		main::SCANNER && Slim::Schema->forceCommit;
 	}
 
+	my $progress = Slim::Utils::Progress->new({
+		'type'  => 'importer',
+		'name'  => 'plugin_qobuz_playlists',
+		'total' => 1,
+		'every' => 1,
+	});
+
+	$progress->update(string('PLUGIN_QOBUZ_PROGRESS_READ_PLAYLISTS'));
+
+	main::INFOLOG && $log->is_info && $log->info("Reading playlists...");
+	my $playlists = Plugins::Qobuz::API::Sync->myPlaylists();
+
+	$progress->total(scalar @$playlists);
+
+	$progress->update(string('PLUGIN_QOBUZ_PROGRESS_READ_TRACKS'));
+	my %tracks;
+	my $c = my $latestPlaylistUpdate = 0;
+
+	main::INFOLOG && $log->is_info && $log->info("Getting playlist tracks...");
+
+	# we need to get the tracks first
+	foreach my $playlist (@{$playlists || []}) {
+		next unless $playlist->{id} && $playlist->{duration};
+
+		$latestPlaylistUpdate = max($latestPlaylistUpdate, $playlist->{updated_at});
+
+		$progress->update($playlist->{name});
+		main::SCANNER && Slim::Schema->forceCommit;
+
+		my $playlistObj = Slim::Schema->updateOrCreate({
+			url        => 'qobuz://' . $playlist->{id} . '.qbz',
+			playlist   => 1,
+			integrateRemote => 1,
+			attributes => {
+				TITLE        => $playlist->{name},
+				COVER        => Plugins::Qobuz::API::Common->getPlaylistImage($playlist),
+				AUDIO        => 1,
+				EXTID        => $playlist->{id},
+				CONTENT_TYPE => 'ssp'
+			},
+		});
+
+		my @trackIDs = map { Plugins::Qobuz::API::Common->getUrl($_) } @{Plugins::Qobuz::API::Sync->getPlaylistTrackIDs($playlist->{id})};
+		$cache->set('playlist_tracks' . $playlist->{id}, \@trackIDs, time() + 86400 * 360);
+		$playlistObj->setTracks(\@trackIDs) if $playlistObj && scalar @trackIDs;
+	}
+
+	$cache->set('playlist_last_update', $latestPlaylistUpdate, time() + 86400 * 360);
+
+	main::INFOLOG && $log->is_info && $log->info("Done, finally!");
+
+	$progress->final();
+
+	Slim::Music::Import->endImporter($class);
 };
 
 
@@ -124,27 +178,26 @@ sub needsUpdate {
 			# don't run any further test in the queue if we already have a result
 			return $acb->($result) if $result;
 
-		# 	my $snapshotIds = $cache->get('spotty_snapshot_ids' . $accountId);
-
-		# 	my $api = Plugins::Spotty::Plugin->getAPIHandler($client);
-		# 	$api->playlists(sub {
-		# 		my ($playlists) = @_;
+			my $previousPlaylistUpdate = $cache->get('playlist_last_update');
 
+			Plugins::Qobuz::API->getUserPlaylists(sub {
+				my ($result) = @_;
 				my $needUpdate;
-		# 		for my $playlist (@$playlists) {
-		# 			my $snapshotId = $snapshotIds->{$playlist->{id}};
-		# 			# we need an update if
-		# 			# - we haven't a snapshot ID for this playlist, OR
-		# 			# - the snapshot ID doesn't match, OR
-		# 			# - the playlist is Spotify generated and older than a day
-		# 			if ( !$snapshotId || ($snapshotId =~ /^\d{10}$/ ? $snapshotId < $timestamp : $snapshotId ne $playlist->{snapshot_id}) ) {
-		# 				$needUpdate = 1;
-		# 				last;
-		# 			}
-		# 		}
+
+				if ($result && ref $result && $result->{playlists} && ref $result->{playlists} && $result->{playlists}->{items} && ref $result->{playlists}->{items}) {
+					my $playlists = $result->{playlists}->{items};
+					my $latestPlaylistUpdate = 0;
+
+					foreach (@$playlists) {
+						if ($_->{updated_at} > $previousPlaylistUpdate) {
+							$needUpdate = 1;
+							last;
+						}
+					}
+				}
 
 				$acb->($needUpdate);
-		# 	});
+			});
 		}, sub {
 			my ($result, $acb) = @_;
 
@@ -209,7 +262,7 @@ sub _storeTracks {
 			AUDIO        => 1,
 			EXTID        => $track->{id},
 			# COMPILATION  => $track->{album}->{album_type} eq 'compilation',
-			TIMESTAMP    => str2time($album->{favorited_at} || 0),
+			TIMESTAMP    => $album->{favorited_at} || $album->{purchased_at},
 			CONTENT_TYPE => $ct,
 			SAMPLERATE   => $track->{maximum_sampling_rate} * 1000,
 			SAMPLESIZE   => $track->{maximum_bit_depth},
diff --git a/PlaylistParser.pm b/PlaylistParser.pm
@@ -0,0 +1,21 @@
+package Plugins::Qobuz::PlaylistParser;
+
+use strict;
+
+use Plugins::Qobuz::API::Common;
+
+my $cache = Plugins::Qobuz::API::Common->getCache();
+
+sub read {
+	my ($class, $fh, $base, $url) = @_;
+
+	my ($id) = $url =~ m|qobuz://(.*)\.qbz|;
+	my $tracks = [];
+	if ($id) {
+		$tracks = $cache->get("playlist_tracks${id}") || [];
+	}
+
+	return @$tracks;
+}
+
+1;
diff --git a/Plugin.pm b/Plugin.pm
@@ -64,6 +64,8 @@ sub initPlugin {
 		qobuz => 'Plugins::Qobuz::ProtocolHandler'
 	);
 
+	Slim::Formats::Playlists->registerParser('qbz', 'Plugins::Qobuz::PlaylistParser');
+
 	Slim::Player::ProtocolHandlers->registerIconHandler(
 		qr|\.qobuz\.com/|,
 		sub { $class->_pluginDataFor('icon') }
@@ -978,15 +980,7 @@ sub _artistItem {
 sub _playlistItem {
 	my ($playlist, $showOwner, $isWeb) = @_;
 
-	# pick the last image, as this is what is shown top most in the Qobuz Desktop client
-	my $image;
-	foreach ('image_rectangle', 'images_300', 'images_150', 'images') {
-		if ($playlist->{$_} && ref $playlist->{$_} eq 'ARRAY') {
-			$image = $playlist->{$_}->[-1];
-			last;
-		}
-	}
-	$image =~ s/([a-z\d]{13}_)[\d]+(\.jpg)/${1}600$2/;
+	my $image = Plugins::Qobuz::API::Common->getPlaylistImage($playlist);
 
 	my $owner = $showOwner ? $playlist->{owner}->{name} : undef;
 
diff --git a/ProtocolHandler.pm b/ProtocolHandler.pm
@@ -203,6 +203,10 @@ sub getMetadataFor {
 		$meta->{artist} .= ', ' . $meta->{composer};
 	}
 
+	if ($meta->{cover} && ref $meta->{cover}) {
+		$meta->{cover} = $meta->{cover}->{large} || $meta->{cover}->{small} || $meta->{cover}->{thumbnail};
+	}
+
 	return $meta;
 }
 
diff --git a/custom-types.conf b/custom-types.conf
@@ -0,0 +1,4 @@
+#########################################################################
+#ID     Suffix          Mime Content-Type               Server File Type#
+#########################################################################
+qbz     qbz             audio/x-sb-qobuz                playlist
diff --git a/strings.txt b/strings.txt
@@ -194,3 +194,14 @@ PLUGIN_QOBUZ_PROGRESS_READ_ALBUMS
 	DE	Lese Alben...
 	EN	Fetching Albums...
 
+PLUGIN_QOBUZ_PROGRESS_READ_TRACKS
+	DE	Lese Titel-Informationen...
+	EN	Fetching Title Information...
+
+PLUGIN_QOBUZ_PLAYLISTS_PROGRESS
+	DE	Qobuz Wiedergabelisten
+	EN	Qobuz Playlists
+
+PLUGIN_QOBUZ_PROGRESS_READ_PLAYLISTS
+	DE	Lese Wiedergabelisten...
+	EN	Fetching Playlists...

Original file line number	Diff line number	Diff line change
`@@ -203,6 +203,10 @@ sub getMetadataFor {`
`203`	`203`	`$meta->{artist} .= ', ' . $meta->{composer};`
`204`	`204`	`}`
`205`	`205`
	`206`	`+ if ($meta->{cover} && ref $meta->{cover}) {`
	`207`	`+ $meta->{cover} = $meta->{cover}->{large} \|\| $meta->{cover}->{small} \|\| $meta->{cover}->{thumbnail};`
	`208`	`+ }`
	`209`	`+`
`206`	`210`	`return $meta;`
`207`	`211`	`}`
`208`	`212`